?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] I2C: Kill i2c_algorithm.id (4/7)
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / media / w9968cf.c
blob908cfdf17039bb7f29277834f71d995d6925ed2c
1 /***************************************************************************
2 * Video4Linux driver for W996[87]CF JPEG USB Dual Mode Camera Chip. *
3 * *
4 * Copyright (C) 2002-2004 by Luca Risolia <luca.risolia@studio.unibo.it> *
5 * *
6 * - Memory management code from bttv driver by Ralph Metzler, *
7 * Marcus Metzler and Gerd Knorr. *
8 * - I2C interface to kernel, high-level image sensor control routines and *
9 * some symbolic names from OV511 driver by Mark W. McClelland. *
10 * - Low-level I2C fast write function by Piotr Czerczak. *
11 * - Low-level I2C read function by Frederic Jouault. *
12 * *
13 * This program is free software; you can redistribute it and/or modify *
14 * it under the terms of the GNU General Public License as published by *
15 * the Free Software Foundation; either version 2 of the License, or *
16 * (at your option) any later version. *
17 * *
18 * This program is distributed in the hope that it will be useful, *
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
21 * GNU General Public License for more details. *
22 * *
23 * You should have received a copy of the GNU General Public License *
24 * along with this program; if not, write to the Free Software *
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
26 ***************************************************************************/
27
28 #include <linux/version.h>
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/kmod.h>
32 #include <linux/init.h>
33 #include <linux/fs.h>
34 #include <linux/vmalloc.h>
35 #include <linux/slab.h>
36 #include <linux/mm.h>
37 #include <linux/string.h>
38 #include <linux/errno.h>
39 #include <linux/sched.h>
40 #include <linux/ioctl.h>
41 #include <linux/delay.h>
42 #include <linux/stddef.h>
43 #include <asm/page.h>
44 #include <asm/uaccess.h>
45 #include <linux/page-flags.h>
46 #include <linux/moduleparam.h>
47
48 #include "w9968cf.h"
49 #include "w9968cf_decoder.h"
50
51
52
53 /****************************************************************************
54 * Module macros and parameters *
55 ****************************************************************************/
56
57 MODULE_DEVICE_TABLE(usb, winbond_id_table);
58
59 MODULE_AUTHOR(W9968CF_MODULE_AUTHOR" "W9968CF_AUTHOR_EMAIL);
60 MODULE_DESCRIPTION(W9968CF_MODULE_NAME);
61 MODULE_VERSION(W9968CF_MODULE_VERSION);
62 MODULE_LICENSE(W9968CF_MODULE_LICENSE);
63 MODULE_SUPPORTED_DEVICE("Video");
64
65 static int ovmod_load = W9968CF_OVMOD_LOAD;
66 static int vppmod_load = W9968CF_VPPMOD_LOAD;
67 static unsigned short simcams = W9968CF_SIMCAMS;
68 static short video_nr[]={[0 ... W9968CF_MAX_DEVICES-1] = -1}; /*-1=first free*/
69 static unsigned int packet_size[] = {[0 ... W9968CF_MAX_DEVICES-1] =
70 W9968CF_PACKET_SIZE};
71 static unsigned short max_buffers[] = {[0 ... W9968CF_MAX_DEVICES-1] =
72 W9968CF_BUFFERS};
73 static int double_buffer[] = {[0 ... W9968CF_MAX_DEVICES-1] =
74 W9968CF_DOUBLE_BUFFER};
75 static int clamping[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_CLAMPING};
76 static unsigned short filter_type[]= {[0 ... W9968CF_MAX_DEVICES-1] =
77 W9968CF_FILTER_TYPE};
78 static int largeview[]= {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_LARGEVIEW};
79 static unsigned short decompression[] = {[0 ... W9968CF_MAX_DEVICES-1] =
80 W9968CF_DECOMPRESSION};
81 static int upscaling[]= {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_UPSCALING};
82 static unsigned short force_palette[] = {[0 ... W9968CF_MAX_DEVICES-1] = 0};
83 static int force_rgb[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_FORCE_RGB};
84 static int autobright[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_AUTOBRIGHT};
85 static int autoexp[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_AUTOEXP};
86 static unsigned short lightfreq[] = {[0 ... W9968CF_MAX_DEVICES-1] =
87 W9968CF_LIGHTFREQ};
88 static int bandingfilter[] = {[0 ... W9968CF_MAX_DEVICES-1]=
89 W9968CF_BANDINGFILTER};
90 static short clockdiv[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_CLOCKDIV};
91 static int backlight[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_BACKLIGHT};
92 static int mirror[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_MIRROR};
93 static int monochrome[] = {[0 ... W9968CF_MAX_DEVICES-1]=W9968CF_MONOCHROME};
94 static unsigned int brightness[] = {[0 ... W9968CF_MAX_DEVICES-1] =
95 W9968CF_BRIGHTNESS};
96 static unsigned int hue[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_HUE};
97 static unsigned int colour[]={[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_COLOUR};
98 static unsigned int contrast[] = {[0 ... W9968CF_MAX_DEVICES-1] =
99 W9968CF_CONTRAST};
100 static unsigned int whiteness[] = {[0 ... W9968CF_MAX_DEVICES-1] =
101 W9968CF_WHITENESS};
102 #ifdef W9968CF_DEBUG
103 static unsigned short debug = W9968CF_DEBUG_LEVEL;
104 static int specific_debug = W9968CF_SPECIFIC_DEBUG;
105 #endif
106
107 static unsigned int param_nv[24]; /* number of values per parameter */
108
109 #ifdef CONFIG_KMOD
110 module_param(ovmod_load, bool, 0644);
111 module_param(vppmod_load, bool, 0444);
112 #endif
113 module_param(simcams, ushort, 0644);
114 module_param_array(video_nr, short, &param_nv[0], 0444);
115 module_param_array(packet_size, uint, &param_nv[1], 0444);
116 module_param_array(max_buffers, ushort, &param_nv[2], 0444);
117 module_param_array(double_buffer, bool, &param_nv[3], 0444);
118 module_param_array(clamping, bool, &param_nv[4], 0444);
119 module_param_array(filter_type, ushort, &param_nv[5], 0444);
120 module_param_array(largeview, bool, &param_nv[6], 0444);
121 module_param_array(decompression, ushort, &param_nv[7], 0444);
122 module_param_array(upscaling, bool, &param_nv[8], 0444);
123 module_param_array(force_palette, ushort, &param_nv[9], 0444);
124 module_param_array(force_rgb, ushort, &param_nv[10], 0444);
125 module_param_array(autobright, bool, &param_nv[11], 0444);
126 module_param_array(autoexp, bool, &param_nv[12], 0444);
127 module_param_array(lightfreq, ushort, &param_nv[13], 0444);
128 module_param_array(bandingfilter, bool, &param_nv[14], 0444);
129 module_param_array(clockdiv, short, &param_nv[15], 0444);
130 module_param_array(backlight, bool, &param_nv[16], 0444);
131 module_param_array(mirror, bool, &param_nv[17], 0444);
132 module_param_array(monochrome, bool, &param_nv[18], 0444);
133 module_param_array(brightness, uint, &param_nv[19], 0444);
134 module_param_array(hue, uint, &param_nv[20], 0444);
135 module_param_array(colour, uint, &param_nv[21], 0444);
136 module_param_array(contrast, uint, &param_nv[22], 0444);
137 module_param_array(whiteness, uint, &param_nv[23], 0444);
138 #ifdef W9968CF_DEBUG
139 module_param(debug, ushort, 0644);
140 module_param(specific_debug, bool, 0644);
141 #endif
142
143 #ifdef CONFIG_KMOD
144 MODULE_PARM_DESC(ovmod_load,
145 "\n<0|1> Automatic 'ovcamchip' module loading."
146 "\n0 disabled, 1 enabled."
147 "\nIf enabled,'insmod' searches for the required 'ovcamchip'"
148 "\nmodule in the system, according to its configuration, and"
149 "\nattempts to load that module automatically. This action is"
150 "\nperformed once as soon as the 'w9968cf' module is loaded"
151 "\ninto memory."
152 "\nDefault value is "__MODULE_STRING(W9968CF_OVMOD_LOAD)"."
153 "\n");
154 MODULE_PARM_DESC(vppmod_load,
155 "\n<0|1> Automatic 'w9968cf-vpp' module loading."
156 "\n0 disabled, 1 enabled."
157 "\nIf enabled, every time an application attempts to open a"
158 "\ncamera, 'insmod' searches for the video post-processing"
159 "\nmodule in the system and loads it automatically (if"
160 "\npresent). The optional 'w9968cf-vpp' module adds extra"
161 "\n image manipulation functions to the 'w9968cf' module,like"
162 "\nsoftware up-scaling,colour conversions and video decoding"
163 "\nfor very high frame rates."
164 "\nDefault value is "__MODULE_STRING(W9968CF_VPPMOD_LOAD)"."
165 "\n");
166 #endif
167 MODULE_PARM_DESC(simcams,
168 "\n<n> Number of cameras allowed to stream simultaneously."
169 "\nn may vary from 0 to "
170 __MODULE_STRING(W9968CF_MAX_DEVICES)"."
171 "\nDefault value is "__MODULE_STRING(W9968CF_SIMCAMS)"."
172 "\n");
173 MODULE_PARM_DESC(video_nr,
174 "\n<-1|n[,...]> Specify V4L minor mode number."
175 "\n -1 = use next available (default)"
176 "\n n = use minor number n (integer >= 0)"
177 "\nYou can specify up to "__MODULE_STRING(W9968CF_MAX_DEVICES)
178 " cameras this way."
179 "\nFor example:"
180 "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
181 "\nthe second camera and use auto for the first"
182 "\none and for every other camera."
183 "\n");
184 MODULE_PARM_DESC(packet_size,
185 "\n<n[,...]> Specify the maximum data payload"
186 "\nsize in bytes for alternate settings, for each device."
187 "\nn is scaled between 63 and 1023 "
188 "(default is "__MODULE_STRING(W9968CF_PACKET_SIZE)")."
189 "\n");
190 MODULE_PARM_DESC(max_buffers,
191 "\n<n[,...]> For advanced users."
192 "\nSpecify the maximum number of video frame buffers"
193 "\nto allocate for each device, from 2 to "
194 __MODULE_STRING(W9968CF_MAX_BUFFERS)
195 ". (default is "__MODULE_STRING(W9968CF_BUFFERS)")."
196 "\n");
197 MODULE_PARM_DESC(double_buffer,
198 "\n<0|1[,...]> "
199 "Hardware double buffering: 0 disabled, 1 enabled."
200 "\nIt should be enabled if you want smooth video output: if"
201 "\nyou obtain out of sync. video, disable it, or try to"
202 "\ndecrease the 'clockdiv' module parameter value."
203 "\nDefault value is "__MODULE_STRING(W9968CF_DOUBLE_BUFFER)
204 " for every device."
205 "\n");
206 MODULE_PARM_DESC(clamping,
207 "\n<0|1[,...]> Video data clamping: 0 disabled, 1 enabled."
208 "\nDefault value is "__MODULE_STRING(W9968CF_CLAMPING)
209 " for every device."
210 "\n");
211 MODULE_PARM_DESC(filter_type,
212 "\n<0|1|2[,...]> Video filter type."
213 "\n0 none, 1 (1-2-1) 3-tap filter, "
214 "2 (2-3-6-3-2) 5-tap filter."
215 "\nDefault value is "__MODULE_STRING(W9968CF_FILTER_TYPE)
216 " for every device."
217 "\nThe filter is used to reduce noise and aliasing artifacts"
218 "\nproduced by the CCD or CMOS image sensor, and the scaling"
219 " process."
220 "\n");
221 MODULE_PARM_DESC(largeview,
222 "\n<0|1[,...]> Large view: 0 disabled, 1 enabled."
223 "\nDefault value is "__MODULE_STRING(W9968CF_LARGEVIEW)
224 " for every device."
225 "\n");
226 MODULE_PARM_DESC(upscaling,
227 "\n<0|1[,...]> Software scaling (for non-compressed video):"
228 "\n0 disabled, 1 enabled."
229 "\nDisable it if you have a slow CPU or you don't have"
230 " enough memory."
231 "\nDefault value is "__MODULE_STRING(W9968CF_UPSCALING)
232 " for every device."
233 "\nIf 'w9968cf-vpp' is not present, this parameter is"
234 " set to 0."
235 "\n");
236 MODULE_PARM_DESC(decompression,
237 "\n<0|1|2[,...]> Software video decompression:"
238 "\n- 0 disables decompression (doesn't allow formats needing"
239 " decompression)"
240 "\n- 1 forces decompression (allows formats needing"
241 " decompression only);"
242 "\n- 2 allows any permitted formats."
243 "\nFormats supporting compressed video are YUV422P and"
244 " YUV420P/YUV420 "
245 "\nin any resolutions where both width and height are "
246 "a multiple of 16."
247 "\nDefault value is "__MODULE_STRING(W9968CF_DECOMPRESSION)
248 " for every device."
249 "\nIf 'w9968cf-vpp' is not present, forcing decompression is "
250 "\nnot allowed; in this case this parameter is set to 2."
251 "\n");
252 MODULE_PARM_DESC(force_palette,
253 "\n<0"
254 "|" __MODULE_STRING(VIDEO_PALETTE_UYVY)
255 "|" __MODULE_STRING(VIDEO_PALETTE_YUV420)
256 "|" __MODULE_STRING(VIDEO_PALETTE_YUV422P)
257 "|" __MODULE_STRING(VIDEO_PALETTE_YUV420P)
258 "|" __MODULE_STRING(VIDEO_PALETTE_YUYV)
259 "|" __MODULE_STRING(VIDEO_PALETTE_YUV422)
260 "|" __MODULE_STRING(VIDEO_PALETTE_GREY)
261 "|" __MODULE_STRING(VIDEO_PALETTE_RGB555)
262 "|" __MODULE_STRING(VIDEO_PALETTE_RGB565)
263 "|" __MODULE_STRING(VIDEO_PALETTE_RGB24)
264 "|" __MODULE_STRING(VIDEO_PALETTE_RGB32)
265 "[,...]>"
266 " Force picture palette."
267 "\nIn order:"
268 "\n- 0 allows any of the following formats:"
269 "\n- UYVY 16 bpp - Original video, compression disabled"
270 "\n- YUV420 12 bpp - Original video, compression enabled"
271 "\n- YUV422P 16 bpp - Original video, compression enabled"
272 "\n- YUV420P 12 bpp - Original video, compression enabled"
273 "\n- YUVY 16 bpp - Software conversion from UYVY"
274 "\n- YUV422 16 bpp - Software conversion from UYVY"
275 "\n- GREY 8 bpp - Software conversion from UYVY"
276 "\n- RGB555 16 bpp - Software conversion from UYVY"
277 "\n- RGB565 16 bpp - Software conversion from UYVY"
278 "\n- RGB24 24 bpp - Software conversion from UYVY"
279 "\n- RGB32 32 bpp - Software conversion from UYVY"
280 "\nWhen not 0, this parameter will override 'decompression'."
281 "\nDefault value is 0 for every device."
282 "\nInitial palette is "
283 __MODULE_STRING(W9968CF_PALETTE_DECOMP_ON)"."
284 "\nIf 'w9968cf-vpp' is not present, this parameter is"
285 " set to 9 (UYVY)."
286 "\n");
287 MODULE_PARM_DESC(force_rgb,
288 "\n<0|1[,...]> Read RGB video data instead of BGR:"
289 "\n 1 = use RGB component ordering."
290 "\n 0 = use BGR component ordering."
291 "\nThis parameter has effect when using RGBX palettes only."
292 "\nDefault value is "__MODULE_STRING(W9968CF_FORCE_RGB)
293 " for every device."
294 "\n");
295 MODULE_PARM_DESC(autobright,
296 "\n<0|1[,...]> Image sensor automatically changes brightness:"
297 "\n 0 = no, 1 = yes"
298 "\nDefault value is "__MODULE_STRING(W9968CF_AUTOBRIGHT)
299 " for every device."
300 "\n");
301 MODULE_PARM_DESC(autoexp,
302 "\n<0|1[,...]> Image sensor automatically changes exposure:"
303 "\n 0 = no, 1 = yes"
304 "\nDefault value is "__MODULE_STRING(W9968CF_AUTOEXP)
305 " for every device."
306 "\n");
307 MODULE_PARM_DESC(lightfreq,
308 "\n<50|60[,...]> Light frequency in Hz:"
309 "\n 50 for European and Asian lighting,"
310 " 60 for American lighting."
311 "\nDefault value is "__MODULE_STRING(W9968CF_LIGHTFREQ)
312 " for every device."
313 "\n");
314 MODULE_PARM_DESC(bandingfilter,
315 "\n<0|1[,...]> Banding filter to reduce effects of"
316 " fluorescent lighting:"
317 "\n 0 disabled, 1 enabled."
318 "\nThis filter tries to reduce the pattern of horizontal"
319 "\nlight/dark bands caused by some (usually fluorescent)"
320 " lighting."
321 "\nDefault value is "__MODULE_STRING(W9968CF_BANDINGFILTER)
322 " for every device."
323 "\n");
324 MODULE_PARM_DESC(clockdiv,
325 "\n<-1|n[,...]> "
326 "Force pixel clock divisor to a specific value (for experts):"
327 "\n n may vary from 0 to 127."
328 "\n -1 for automatic value."
329 "\nSee also the 'double_buffer' module parameter."
330 "\nDefault value is "__MODULE_STRING(W9968CF_CLOCKDIV)
331 " for every device."
332 "\n");
333 MODULE_PARM_DESC(backlight,
334 "\n<0|1[,...]> Objects are lit from behind:"
335 "\n 0 = no, 1 = yes"
336 "\nDefault value is "__MODULE_STRING(W9968CF_BACKLIGHT)
337 " for every device."
338 "\n");
339 MODULE_PARM_DESC(mirror,
340 "\n<0|1[,...]> Reverse image horizontally:"
341 "\n 0 = no, 1 = yes"
342 "\nDefault value is "__MODULE_STRING(W9968CF_MIRROR)
343 " for every device."
344 "\n");
345 MODULE_PARM_DESC(monochrome,
346 "\n<0|1[,...]> Use image sensor as monochrome sensor:"
347 "\n 0 = no, 1 = yes"
348 "\nNot all the sensors support monochrome color."
349 "\nDefault value is "__MODULE_STRING(W9968CF_MONOCHROME)
350 " for every device."
351 "\n");
352 MODULE_PARM_DESC(brightness,
353 "\n<n[,...]> Set picture brightness (0-65535)."
354 "\nDefault value is "__MODULE_STRING(W9968CF_BRIGHTNESS)
355 " for every device."
356 "\nThis parameter has no effect if 'autobright' is enabled."
357 "\n");
358 MODULE_PARM_DESC(hue,
359 "\n<n[,...]> Set picture hue (0-65535)."
360 "\nDefault value is "__MODULE_STRING(W9968CF_HUE)
361 " for every device."
362 "\n");
363 MODULE_PARM_DESC(colour,
364 "\n<n[,...]> Set picture saturation (0-65535)."
365 "\nDefault value is "__MODULE_STRING(W9968CF_COLOUR)
366 " for every device."
367 "\n");
368 MODULE_PARM_DESC(contrast,
369 "\n<n[,...]> Set picture contrast (0-65535)."
370 "\nDefault value is "__MODULE_STRING(W9968CF_CONTRAST)
371 " for every device."
372 "\n");
373 MODULE_PARM_DESC(whiteness,
374 "\n<n[,...]> Set picture whiteness (0-65535)."
375 "\nDefault value is "__MODULE_STRING(W9968CF_WHITENESS)
376 " for every device."
377 "\n");
378 #ifdef W9968CF_DEBUG
379 MODULE_PARM_DESC(debug,
380 "\n<n> Debugging information level, from 0 to 6:"
381 "\n0 = none (use carefully)"
382 "\n1 = critical errors"
383 "\n2 = significant informations"
384 "\n3 = configuration or general messages"
385 "\n4 = warnings"
386 "\n5 = called functions"
387 "\n6 = function internals"
388 "\nLevel 5 and 6 are useful for testing only, when only "
389 "one device is used."
390 "\nDefault value is "__MODULE_STRING(W9968CF_DEBUG_LEVEL)"."
391 "\n");
392 MODULE_PARM_DESC(specific_debug,
393 "\n<0|1> Enable or disable specific debugging messages:"
394 "\n0 = print messages concerning every level"
395 " <= 'debug' level."
396 "\n1 = print messages concerning the level"
397 " indicated by 'debug'."
398 "\nDefault value is "
399 __MODULE_STRING(W9968CF_SPECIFIC_DEBUG)"."
400 "\n");
401 #endif /* W9968CF_DEBUG */
402
403
404
405 /****************************************************************************
406 * Some prototypes *
407 ****************************************************************************/
408
409 /* Video4linux interface */
410 static struct file_operations w9968cf_fops;
411 static int w9968cf_open(struct inode*, struct file*);
412 static int w9968cf_release(struct inode*, struct file*);
413 static int w9968cf_mmap(struct file*, struct vm_area_struct*);
414 static int w9968cf_ioctl(struct inode*, struct file*, unsigned, unsigned long);
415 static ssize_t w9968cf_read(struct file*, char __user *, size_t, loff_t*);
416 static int w9968cf_v4l_ioctl(struct inode*, struct file*, unsigned int,
417 void __user *);
418
419 /* USB-specific */
420 static int w9968cf_start_transfer(struct w9968cf_device*);
421 static int w9968cf_stop_transfer(struct w9968cf_device*);
422 static int w9968cf_write_reg(struct w9968cf_device*, u16 value, u16 index);
423 static int w9968cf_read_reg(struct w9968cf_device*, u16 index);
424 static int w9968cf_write_fsb(struct w9968cf_device*, u16* data);
425 static int w9968cf_write_sb(struct w9968cf_device*, u16 value);
426 static int w9968cf_read_sb(struct w9968cf_device*);
427 static int w9968cf_upload_quantizationtables(struct w9968cf_device*);
428 static void w9968cf_urb_complete(struct urb *urb, struct pt_regs *regs);
429
430 /* Low-level I2C (SMBus) I/O */
431 static int w9968cf_smbus_start(struct w9968cf_device*);
432 static int w9968cf_smbus_stop(struct w9968cf_device*);
433 static int w9968cf_smbus_write_byte(struct w9968cf_device*, u8 v);
434 static int w9968cf_smbus_read_byte(struct w9968cf_device*, u8* v);
435 static int w9968cf_smbus_write_ack(struct w9968cf_device*);
436 static int w9968cf_smbus_read_ack(struct w9968cf_device*);
437 static int w9968cf_smbus_refresh_bus(struct w9968cf_device*);
438 static int w9968cf_i2c_adap_read_byte(struct w9968cf_device* cam,
439 u16 address, u8* value);
440 static int w9968cf_i2c_adap_read_byte_data(struct w9968cf_device*, u16 address,
441 u8 subaddress, u8* value);
442 static int w9968cf_i2c_adap_write_byte(struct w9968cf_device*,
443 u16 address, u8 subaddress);
444 static int w9968cf_i2c_adap_fastwrite_byte_data(struct w9968cf_device*,
445 u16 address, u8 subaddress,
446 u8 value);
447
448 /* I2C interface to kernel */
449 static int w9968cf_i2c_init(struct w9968cf_device*);
450 static int w9968cf_i2c_smbus_xfer(struct i2c_adapter*, u16 addr,
451 unsigned short flags, char read_write,
452 u8 command, int size, union i2c_smbus_data*);
453 static u32 w9968cf_i2c_func(struct i2c_adapter*);
454 static int w9968cf_i2c_attach_inform(struct i2c_client*);
455 static int w9968cf_i2c_detach_inform(struct i2c_client*);
456 static int w9968cf_i2c_control(struct i2c_adapter*, unsigned int cmd,
457 unsigned long arg);
458
459 /* Memory management */
460 static void* rvmalloc(unsigned long size);
461 static void rvfree(void *mem, unsigned long size);
462 static void w9968cf_deallocate_memory(struct w9968cf_device*);
463 static int w9968cf_allocate_memory(struct w9968cf_device*);
464
465 /* High-level image sensor control functions */
466 static int w9968cf_sensor_set_control(struct w9968cf_device*,int cid,int val);
467 static int w9968cf_sensor_get_control(struct w9968cf_device*,int cid,int *val);
468 static int w9968cf_sensor_cmd(struct w9968cf_device*,
469 unsigned int cmd, void *arg);
470 static int w9968cf_sensor_init(struct w9968cf_device*);
471 static int w9968cf_sensor_update_settings(struct w9968cf_device*);
472 static int w9968cf_sensor_get_picture(struct w9968cf_device*);
473 static int w9968cf_sensor_update_picture(struct w9968cf_device*,
474 struct video_picture pict);
475
476 /* Other helper functions */
477 static void w9968cf_configure_camera(struct w9968cf_device*,struct usb_device*,
478 enum w9968cf_model_id,
479 const unsigned short dev_nr);
480 static void w9968cf_adjust_configuration(struct w9968cf_device*);
481 static int w9968cf_turn_on_led(struct w9968cf_device*);
482 static int w9968cf_init_chip(struct w9968cf_device*);
483 static inline u16 w9968cf_valid_palette(u16 palette);
484 static inline u16 w9968cf_valid_depth(u16 palette);
485 static inline u8 w9968cf_need_decompression(u16 palette);
486 static int w9968cf_set_picture(struct w9968cf_device*, struct video_picture);
487 static int w9968cf_set_window(struct w9968cf_device*, struct video_window);
488 static int w9968cf_postprocess_frame(struct w9968cf_device*,
489 struct w9968cf_frame_t*);
490 static int w9968cf_adjust_window_size(struct w9968cf_device*, u16* w, u16* h);
491 static void w9968cf_init_framelist(struct w9968cf_device*);
492 static void w9968cf_push_frame(struct w9968cf_device*, u8 f_num);
493 static void w9968cf_pop_frame(struct w9968cf_device*,struct w9968cf_frame_t**);
494 static void w9968cf_release_resources(struct w9968cf_device*);
495
496 /* Intermodule communication */
497 static int w9968cf_vppmod_detect(struct w9968cf_device*);
498 static void w9968cf_vppmod_release(struct w9968cf_device*);
499
500
501
502 /****************************************************************************
503 * Symbolic names *
504 ****************************************************************************/
505
506 /* Used to represent a list of values and their respective symbolic names */
507 struct w9968cf_symbolic_list {
508 const int num;
509 const char *name;
510 };
511
512 /*--------------------------------------------------------------------------
513 Returns the name of the matching element in the symbolic_list array. The
514 end of the list must be marked with an element that has a NULL name.
515 --------------------------------------------------------------------------*/
516 static inline const char *
517 symbolic(struct w9968cf_symbolic_list list[], const int num)
518 {
519 int i;
520
521 for (i = 0; list[i].name != NULL; i++)
522 if (list[i].num == num)
523 return (list[i].name);
524
525 return "Unknown";
526 }
527
528 static struct w9968cf_symbolic_list camlist[] = {
529 { W9968CF_MOD_GENERIC, "W996[87]CF JPEG USB Dual Mode Camera" },
530 { W9968CF_MOD_CLVBWGP, "Creative Labs Video Blaster WebCam Go Plus" },
531
532 /* Other cameras (having the same descriptors as Generic W996[87]CF) */
533 { W9968CF_MOD_ADPVDMA, "Aroma Digi Pen VGA Dual Mode ADG-5000" },
534 { W9986CF_MOD_AAU, "AVerMedia AVerTV USB" },
535 { W9968CF_MOD_CLVBWG, "Creative Labs Video Blaster WebCam Go" },
536 { W9968CF_MOD_LL, "Lebon LDC-035A" },
537 { W9968CF_MOD_EEEMC, "Ezonics EZ-802 EZMega Cam" },
538 { W9968CF_MOD_OOE, "OmniVision OV8610-EDE" },
539 { W9968CF_MOD_ODPVDMPC, "OPCOM Digi Pen VGA Dual Mode Pen Camera" },
540 { W9968CF_MOD_PDPII, "Pretec Digi Pen-II" },
541 { W9968CF_MOD_PDP480, "Pretec DigiPen-480" },
542
543 { -1, NULL }
544 };
545
546 static struct w9968cf_symbolic_list senlist[] = {
547 { CC_OV76BE, "OV76BE" },
548 { CC_OV7610, "OV7610" },
549 { CC_OV7620, "OV7620" },
550 { CC_OV7620AE, "OV7620AE" },
551 { CC_OV6620, "OV6620" },
552 { CC_OV6630, "OV6630" },
553 { CC_OV6630AE, "OV6630AE" },
554 { CC_OV6630AF, "OV6630AF" },
555 { -1, NULL }
556 };
557
558 /* Video4Linux1 palettes */
559 static struct w9968cf_symbolic_list v4l1_plist[] = {
560 { VIDEO_PALETTE_GREY, "GREY" },
561 { VIDEO_PALETTE_HI240, "HI240" },
562 { VIDEO_PALETTE_RGB565, "RGB565" },
563 { VIDEO_PALETTE_RGB24, "RGB24" },
564 { VIDEO_PALETTE_RGB32, "RGB32" },
565 { VIDEO_PALETTE_RGB555, "RGB555" },
566 { VIDEO_PALETTE_YUV422, "YUV422" },
567 { VIDEO_PALETTE_YUYV, "YUYV" },
568 { VIDEO_PALETTE_UYVY, "UYVY" },
569 { VIDEO_PALETTE_YUV420, "YUV420" },
570 { VIDEO_PALETTE_YUV411, "YUV411" },
571 { VIDEO_PALETTE_RAW, "RAW" },
572 { VIDEO_PALETTE_YUV422P, "YUV422P" },
573 { VIDEO_PALETTE_YUV411P, "YUV411P" },
574 { VIDEO_PALETTE_YUV420P, "YUV420P" },
575 { VIDEO_PALETTE_YUV410P, "YUV410P" },
576 { -1, NULL }
577 };
578
579 /* Decoder error codes: */
580 static struct w9968cf_symbolic_list decoder_errlist[] = {
581 { W9968CF_DEC_ERR_CORRUPTED_DATA, "Corrupted data" },
582 { W9968CF_DEC_ERR_BUF_OVERFLOW, "Buffer overflow" },
583 { W9968CF_DEC_ERR_NO_SOI, "SOI marker not found" },
584 { W9968CF_DEC_ERR_NO_SOF0, "SOF0 marker not found" },
585 { W9968CF_DEC_ERR_NO_SOS, "SOS marker not found" },
586 { W9968CF_DEC_ERR_NO_EOI, "EOI marker not found" },
587 { -1, NULL }
588 };
589
590 /* URB error codes: */
591 static struct w9968cf_symbolic_list urb_errlist[] = {
592 { -ENOMEM, "No memory for allocation of internal structures" },
593 { -ENOSPC, "The host controller's bandwidth is already consumed" },
594 { -ENOENT, "URB was canceled by unlink_urb" },
595 { -EXDEV, "ISO transfer only partially completed" },
596 { -EAGAIN, "Too match scheduled for the future" },
597 { -ENXIO, "URB already queued" },
598 { -EFBIG, "Too much ISO frames requested" },
599 { -ENOSR, "Buffer error (overrun)" },
600 { -EPIPE, "Specified endpoint is stalled (device not responding)"},
601 { -EOVERFLOW, "Babble (bad cable?)" },
602 { -EPROTO, "Bit-stuff error (bad cable?)" },
603 { -EILSEQ, "CRC/Timeout" },
604 { -ETIMEDOUT, "NAK (device does not respond)" },
605 { -1, NULL }
606 };
607
608
609
610 /****************************************************************************
611 * Memory management functions *
612 ****************************************************************************/
613 static void* rvmalloc(unsigned long size)
614 {
615 void* mem;
616 unsigned long adr;
617
618 size = PAGE_ALIGN(size);
619 mem = vmalloc_32(size);
620 if (!mem)
621 return NULL;
622
623 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
624 adr = (unsigned long) mem;
625 while (size > 0) {
626 SetPageReserved(vmalloc_to_page((void *)adr));
627 adr += PAGE_SIZE;
628 size -= PAGE_SIZE;
629 }
630
631 return mem;
632 }
633
634
635 static void rvfree(void* mem, unsigned long size)
636 {
637 unsigned long adr;
638
639 if (!mem)
640 return;
641
642 adr = (unsigned long) mem;
643 while ((long) size > 0) {
644 ClearPageReserved(vmalloc_to_page((void *)adr));
645 adr += PAGE_SIZE;
646 size -= PAGE_SIZE;
647 }
648 vfree(mem);
649 }
650
651
652 /*--------------------------------------------------------------------------
653 Deallocate previously allocated memory.
654 --------------------------------------------------------------------------*/
655 static void w9968cf_deallocate_memory(struct w9968cf_device* cam)
656 {
657 u8 i;
658
659 /* Free the isochronous transfer buffers */
660 for (i = 0; i < W9968CF_URBS; i++) {
661 kfree(cam->transfer_buffer[i]);
662 cam->transfer_buffer[i] = NULL;
663 }
664
665 /* Free temporary frame buffer */
666 if (cam->frame_tmp.buffer) {
667 rvfree(cam->frame_tmp.buffer, cam->frame_tmp.size);
668 cam->frame_tmp.buffer = NULL;
669 }
670
671 /* Free helper buffer */
672 if (cam->frame_vpp.buffer) {
673 rvfree(cam->frame_vpp.buffer, cam->frame_vpp.size);
674 cam->frame_vpp.buffer = NULL;
675 }
676
677 /* Free video frame buffers */
678 if (cam->frame[0].buffer) {
679 rvfree(cam->frame[0].buffer, cam->nbuffers*cam->frame[0].size);
680 cam->frame[0].buffer = NULL;
681 }
682
683 cam->nbuffers = 0;
684
685 DBG(5, "Memory successfully deallocated")
686 }
687
688
689 /*--------------------------------------------------------------------------
690 Allocate memory buffers for USB transfers and video frames.
691 This function is called by open() only.
692 Return 0 on success, a negative number otherwise.
693 --------------------------------------------------------------------------*/
694 static int w9968cf_allocate_memory(struct w9968cf_device* cam)
695 {
696 const u16 p_size = wMaxPacketSize[cam->altsetting-1];
697 void* buff = NULL;
698 unsigned long hw_bufsize, vpp_bufsize;
699 u8 i, bpp;
700
701 /* NOTE: Deallocation is done elsewhere in case of error */
702
703 /* Calculate the max amount of raw data per frame from the device */
704 hw_bufsize = cam->maxwidth*cam->maxheight*2;
705
706 /* Calculate the max buf. size needed for post-processing routines */
707 bpp = (w9968cf_vpp) ? 4 : 2;
708 if (cam->upscaling)
709 vpp_bufsize = max(W9968CF_MAX_WIDTH*W9968CF_MAX_HEIGHT*bpp,
710 cam->maxwidth*cam->maxheight*bpp);
711 else
712 vpp_bufsize = cam->maxwidth*cam->maxheight*bpp;
713
714 /* Allocate memory for the isochronous transfer buffers */
715 for (i = 0; i < W9968CF_URBS; i++) {
716 if (!(cam->transfer_buffer[i] =
717 kmalloc(W9968CF_ISO_PACKETS*p_size, GFP_KERNEL))) {
718 DBG(1, "Couldn't allocate memory for the isochronous "
719 "transfer buffers (%u bytes)",
720 p_size * W9968CF_ISO_PACKETS)
721 return -ENOMEM;
722 }
723 memset(cam->transfer_buffer[i], 0, W9968CF_ISO_PACKETS*p_size);
724 }
725
726 /* Allocate memory for the temporary frame buffer */
727 if (!(cam->frame_tmp.buffer = rvmalloc(hw_bufsize))) {
728 DBG(1, "Couldn't allocate memory for the temporary "
729 "video frame buffer (%lu bytes)", hw_bufsize)
730 return -ENOMEM;
731 }
732 cam->frame_tmp.size = hw_bufsize;
733 cam->frame_tmp.number = -1;
734
735 /* Allocate memory for the helper buffer */
736 if (w9968cf_vpp) {
737 if (!(cam->frame_vpp.buffer = rvmalloc(vpp_bufsize))) {
738 DBG(1, "Couldn't allocate memory for the helper buffer"
739 " (%lu bytes)", vpp_bufsize)
740 return -ENOMEM;
741 }
742 cam->frame_vpp.size = vpp_bufsize;
743 } else
744 cam->frame_vpp.buffer = NULL;
745
746 /* Allocate memory for video frame buffers */
747 cam->nbuffers = cam->max_buffers;
748 while (cam->nbuffers >= 2) {
749 if ((buff = rvmalloc(cam->nbuffers * vpp_bufsize)))
750 break;
751 else
752 cam->nbuffers--;
753 }
754
755 if (!buff) {
756 DBG(1, "Couldn't allocate memory for the video frame buffers")
757 cam->nbuffers = 0;
758 return -ENOMEM;
759 }
760
761 if (cam->nbuffers != cam->max_buffers)
762 DBG(2, "Couldn't allocate memory for %u video frame buffers. "
763 "Only memory for %u buffers has been allocated",
764 cam->max_buffers, cam->nbuffers)
765
766 for (i = 0; i < cam->nbuffers; i++) {
767 cam->frame[i].buffer = buff + i*vpp_bufsize;
768 cam->frame[i].size = vpp_bufsize;
769 cam->frame[i].number = i;
770 /* Circular list */
771 if (i != cam->nbuffers-1)
772 cam->frame[i].next = &cam->frame[i+1];
773 else
774 cam->frame[i].next = &cam->frame[0];
775 cam->frame[i].status = F_UNUSED;
776 }
777
778 DBG(5, "Memory successfully allocated")
779 return 0;
780 }
781
782
783
784 /****************************************************************************
785 * USB-specific functions *
786 ****************************************************************************/
787
788 /*--------------------------------------------------------------------------
789 This is an handler function which is called after the URBs are completed.
790 It collects multiple data packets coming from the camera by putting them
791 into frame buffers: one or more zero data length data packets are used to
792 mark the end of a video frame; the first non-zero data packet is the start
793 of the next video frame; if an error is encountered in a packet, the entire
794 video frame is discarded and grabbed again.
795 If there are no requested frames in the FIFO list, packets are collected into
796 a temporary buffer.
797 --------------------------------------------------------------------------*/
798 static void w9968cf_urb_complete(struct urb *urb, struct pt_regs *regs)
799 {
800 struct w9968cf_device* cam = (struct w9968cf_device*)urb->context;
801 struct w9968cf_frame_t** f;
802 unsigned int len, status;
803 void* pos;
804 u8 i;
805 int err = 0;
806
807 if ((!cam->streaming) || cam->disconnected) {
808 DBG(4, "Got interrupt, but not streaming")
809 return;
810 }
811
812 /* "(*f)" will be used instead of "cam->frame_current" */
813 f = &cam->frame_current;
814
815 /* If a frame has been requested and we are grabbing into
816 the temporary frame, we'll switch to that requested frame */
817 if ((*f) == &cam->frame_tmp && *cam->requested_frame) {
818 if (cam->frame_tmp.status == F_GRABBING) {
819 w9968cf_pop_frame(cam, &cam->frame_current);
820 (*f)->status = F_GRABBING;
821 (*f)->length = cam->frame_tmp.length;
822 memcpy((*f)->buffer, cam->frame_tmp.buffer,
823 (*f)->length);
824 DBG(6, "Switched from temp. frame to frame #%d",
825 (*f)->number)
826 }
827 }
828
829 for (i = 0; i < urb->number_of_packets; i++) {
830 len = urb->iso_frame_desc[i].actual_length;
831 status = urb->iso_frame_desc[i].status;
832 pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
833
834 if (status && len != 0) {
835 DBG(4, "URB failed, error in data packet "
836 "(error #%u, %s)",
837 status, symbolic(urb_errlist, status))
838 (*f)->status = F_ERROR;
839 continue;
840 }
841
842 if (len) { /* start of frame */
843
844 if ((*f)->status == F_UNUSED) {
845 (*f)->status = F_GRABBING;
846 (*f)->length = 0;
847 }
848
849 /* Buffer overflows shouldn't happen, however...*/
850 if ((*f)->length + len > (*f)->size) {
851 DBG(4, "Buffer overflow: bad data packets")
852 (*f)->status = F_ERROR;
853 }
854
855 if ((*f)->status == F_GRABBING) {
856 memcpy((*f)->buffer + (*f)->length, pos, len);
857 (*f)->length += len;
858 }
859
860 } else if ((*f)->status == F_GRABBING) { /* end of frame */
861
862 DBG(6, "Frame #%d successfully grabbed", (*f)->number)
863
864 if (cam->vpp_flag & VPP_DECOMPRESSION) {
865 err = w9968cf_vpp->check_headers((*f)->buffer,
866 (*f)->length);
867 if (err) {
868 DBG(4, "Skip corrupted frame: %s",
869 symbolic(decoder_errlist, err))
870 (*f)->status = F_UNUSED;
871 continue; /* grab this frame again */
872 }
873 }
874
875 (*f)->status = F_READY;
876 (*f)->queued = 0;
877
878 /* Take a pointer to the new frame from the FIFO list.
879 If the list is empty,we'll use the temporary frame*/
880 if (*cam->requested_frame)
881 w9968cf_pop_frame(cam, &cam->frame_current);
882 else {
883 cam->frame_current = &cam->frame_tmp;
884 (*f)->status = F_UNUSED;
885 }
886
887 } else if ((*f)->status == F_ERROR)
888 (*f)->status = F_UNUSED; /* grab it again */
889
890 PDBGG("Frame length %lu | pack.#%u | pack.len. %u | state %d",
891 (unsigned long)(*f)->length, i, len, (*f)->status)
892
893 } /* end for */
894
895 /* Resubmit this URB */
896 urb->dev = cam->usbdev;
897 urb->status = 0;
898 spin_lock(&cam->urb_lock);
899 if (cam->streaming)
900 if ((err = usb_submit_urb(urb, GFP_ATOMIC))) {
901 cam->misconfigured = 1;
902 DBG(1, "Couldn't resubmit the URB: error %d, %s",
903 err, symbolic(urb_errlist, err))
904 }
905 spin_unlock(&cam->urb_lock);
906
907 /* Wake up the user process */
908 wake_up_interruptible(&cam->wait_queue);
909 }
910
911
912 /*---------------------------------------------------------------------------
913 Setup the URB structures for the isochronous transfer.
914 Submit the URBs so that the data transfer begins.
915 Return 0 on success, a negative number otherwise.
916 ---------------------------------------------------------------------------*/
917 static int w9968cf_start_transfer(struct w9968cf_device* cam)
918 {
919 struct usb_device *udev = cam->usbdev;
920 struct urb* urb;
921 const u16 p_size = wMaxPacketSize[cam->altsetting-1];
922 u16 w, h, d;
923 int vidcapt;
924 u32 t_size;
925 int err = 0;
926 s8 i, j;
927
928 for (i = 0; i < W9968CF_URBS; i++) {
929 urb = usb_alloc_urb(W9968CF_ISO_PACKETS, GFP_KERNEL);
930 cam->urb[i] = urb;
931 if (!urb) {
932 for (j = 0; j < i; j++)
933 usb_free_urb(cam->urb[j]);
934 DBG(1, "Couldn't allocate the URB structures")
935 return -ENOMEM;
936 }
937
938 urb->dev = udev;
939 urb->context = (void*)cam;
940 urb->pipe = usb_rcvisocpipe(udev, 1);
941 urb->transfer_flags = URB_ISO_ASAP;
942 urb->number_of_packets = W9968CF_ISO_PACKETS;
943 urb->complete = w9968cf_urb_complete;
944 urb->transfer_buffer = cam->transfer_buffer[i];
945 urb->transfer_buffer_length = p_size*W9968CF_ISO_PACKETS;
946 urb->interval = 1;
947 for (j = 0; j < W9968CF_ISO_PACKETS; j++) {
948 urb->iso_frame_desc[j].offset = p_size*j;
949 urb->iso_frame_desc[j].length = p_size;
950 }
951 }
952
953 /* Transfer size per frame, in WORD ! */
954 d = cam->hw_depth;
955 w = cam->hw_width;
956 h = cam->hw_height;
957
958 t_size = (w*h*d)/16;
959
960 err = w9968cf_write_reg(cam, 0xbf17, 0x00); /* reset everything */
961 err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* normal operation */
962
963 /* Transfer size */
964 err += w9968cf_write_reg(cam, t_size & 0xffff, 0x3d); /* low bits */
965 err += w9968cf_write_reg(cam, t_size >> 16, 0x3e); /* high bits */
966
967 if (cam->vpp_flag & VPP_DECOMPRESSION)
968 err += w9968cf_upload_quantizationtables(cam);
969
970 vidcapt = w9968cf_read_reg(cam, 0x16); /* read picture settings */
971 err += w9968cf_write_reg(cam, vidcapt|0x8000, 0x16); /* capt. enable */
972
973 err += usb_set_interface(udev, 0, cam->altsetting);
974 err += w9968cf_write_reg(cam, 0x8a05, 0x3c); /* USB FIFO enable */
975
976 if (err || (vidcapt < 0)) {
977 for (i = 0; i < W9968CF_URBS; i++)
978 usb_free_urb(cam->urb[i]);
979 DBG(1, "Couldn't tell the camera to start the data transfer")
980 return err;
981 }
982
983 w9968cf_init_framelist(cam);
984
985 /* Begin to grab into the temporary buffer */
986 cam->frame_tmp.status = F_UNUSED;
987 cam->frame_tmp.queued = 0;
988 cam->frame_current = &cam->frame_tmp;
989
990 if (!(cam->vpp_flag & VPP_DECOMPRESSION))
991 DBG(5, "Isochronous transfer size: %lu bytes/frame",
992 (unsigned long)t_size*2)
993
994 DBG(5, "Starting the isochronous transfer...")
995
996 cam->streaming = 1;
997
998 /* Submit the URBs */
999 for (i = 0; i < W9968CF_URBS; i++) {
1000 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
1001 if (err) {
1002 cam->streaming = 0;
1003 for (j = i-1; j >= 0; j--) {
1004 usb_kill_urb(cam->urb[j]);
1005 usb_free_urb(cam->urb[j]);
1006 }
1007 DBG(1, "Couldn't send a transfer request to the "
1008 "USB core (error #%d, %s)", err,
1009 symbolic(urb_errlist, err))
1010 return err;
1011 }
1012 }
1013
1014 return 0;
1015 }
1016
1017
1018 /*--------------------------------------------------------------------------
1019 Stop the isochronous transfer and set alternate setting to 0 (0Mb/s).
1020 Return 0 on success, a negative number otherwise.
1021 --------------------------------------------------------------------------*/
1022 static int w9968cf_stop_transfer(struct w9968cf_device* cam)
1023 {
1024 struct usb_device *udev = cam->usbdev;
1025 unsigned long lock_flags;
1026 int err = 0;
1027 s8 i;
1028
1029 if (!cam->streaming)
1030 return 0;
1031
1032 /* This avoids race conditions with usb_submit_urb()
1033 in the URB completition handler */
1034 spin_lock_irqsave(&cam->urb_lock, lock_flags);
1035 cam->streaming = 0;
1036 spin_unlock_irqrestore(&cam->urb_lock, lock_flags);
1037
1038 for (i = W9968CF_URBS-1; i >= 0; i--)
1039 if (cam->urb[i]) {
1040 usb_kill_urb(cam->urb[i]);
1041 usb_free_urb(cam->urb[i]);
1042 cam->urb[i] = NULL;
1043 }
1044
1045 if (cam->disconnected)
1046 goto exit;
1047
1048 err = w9968cf_write_reg(cam, 0x0a05, 0x3c); /* stop USB transfer */
1049 err += usb_set_interface(udev, 0, 0); /* 0 Mb/s */
1050 err += w9968cf_write_reg(cam, 0x0000, 0x39); /* disable JPEG encoder */
1051 err += w9968cf_write_reg(cam, 0x0000, 0x16); /* stop video capture */
1052
1053 if (err) {
1054 DBG(2, "Failed to tell the camera to stop the isochronous "
1055 "transfer. However this is not a critical error.")
1056 return -EIO;
1057 }
1058
1059 exit:
1060 DBG(5, "Isochronous transfer stopped")
1061 return 0;
1062 }
1063
1064
1065 /*--------------------------------------------------------------------------
1066 Write a W9968CF register.
1067 Return 0 on success, -1 otherwise.
1068 --------------------------------------------------------------------------*/
1069 static int w9968cf_write_reg(struct w9968cf_device* cam, u16 value, u16 index)
1070 {
1071 struct usb_device* udev = cam->usbdev;
1072 int res;
1073
1074 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0,
1075 USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
1076 value, index, NULL, 0, W9968CF_USB_CTRL_TIMEOUT);
1077
1078 if (res < 0)
1079 DBG(4, "Failed to write a register "
1080 "(value 0x%04X, index 0x%02X, error #%d, %s)",
1081 value, index, res, symbolic(urb_errlist, res))
1082
1083 return (res >= 0) ? 0 : -1;
1084 }
1085
1086
1087 /*--------------------------------------------------------------------------
1088 Read a W9968CF register.
1089 Return the register value on success, -1 otherwise.
1090 --------------------------------------------------------------------------*/
1091 static int w9968cf_read_reg(struct w9968cf_device* cam, u16 index)
1092 {
1093 struct usb_device* udev = cam->usbdev;
1094 u16* buff = cam->control_buffer;
1095 int res;
1096
1097 res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 1,
1098 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1099 0, index, buff, 2, W9968CF_USB_CTRL_TIMEOUT);
1100
1101 if (res < 0)
1102 DBG(4, "Failed to read a register "
1103 "(index 0x%02X, error #%d, %s)",
1104 index, res, symbolic(urb_errlist, res))
1105
1106 return (res >= 0) ? (int)(*buff) : -1;
1107 }
1108
1109
1110 /*--------------------------------------------------------------------------
1111 Write 64-bit data to the fast serial bus registers.
1112 Return 0 on success, -1 otherwise.
1113 --------------------------------------------------------------------------*/
1114 static int w9968cf_write_fsb(struct w9968cf_device* cam, u16* data)
1115 {
1116 struct usb_device* udev = cam->usbdev;
1117 u16 value;
1118 int res;
1119
1120 value = *data++;
1121
1122 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0,
1123 USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
1124 value, 0x06, data, 6, W9968CF_USB_CTRL_TIMEOUT);
1125
1126 if (res < 0)
1127 DBG(4, "Failed to write the FSB registers "
1128 "(error #%d, %s)", res, symbolic(urb_errlist, res))
1129
1130 return (res >= 0) ? 0 : -1;
1131 }
1132
1133
1134 /*--------------------------------------------------------------------------
1135 Write data to the serial bus control register.
1136 Return 0 on success, a negative number otherwise.
1137 --------------------------------------------------------------------------*/
1138 static int w9968cf_write_sb(struct w9968cf_device* cam, u16 value)
1139 {
1140 int err = 0;
1141
1142 err = w9968cf_write_reg(cam, value, 0x01);
1143 udelay(W9968CF_I2C_BUS_DELAY);
1144
1145 return err;
1146 }
1147
1148
1149 /*--------------------------------------------------------------------------
1150 Read data from the serial bus control register.
1151 Return 0 on success, a negative number otherwise.
1152 --------------------------------------------------------------------------*/
1153 static int w9968cf_read_sb(struct w9968cf_device* cam)
1154 {
1155 int v = 0;
1156
1157 v = w9968cf_read_reg(cam, 0x01);
1158 udelay(W9968CF_I2C_BUS_DELAY);
1159
1160 return v;
1161 }
1162
1163
1164 /*--------------------------------------------------------------------------
1165 Upload quantization tables for the JPEG compression.
1166 This function is called by w9968cf_start_transfer().
1167 Return 0 on success, a negative number otherwise.
1168 --------------------------------------------------------------------------*/
1169 static int w9968cf_upload_quantizationtables(struct w9968cf_device* cam)
1170 {
1171 u16 a, b;
1172 int err = 0, i, j;
1173
1174 err += w9968cf_write_reg(cam, 0x0010, 0x39); /* JPEG clock enable */
1175
1176 for (i = 0, j = 0; i < 32; i++, j += 2) {
1177 a = Y_QUANTABLE[j] | ((unsigned)(Y_QUANTABLE[j+1]) << 8);
1178 b = UV_QUANTABLE[j] | ((unsigned)(UV_QUANTABLE[j+1]) << 8);
1179 err += w9968cf_write_reg(cam, a, 0x40+i);
1180 err += w9968cf_write_reg(cam, b, 0x60+i);
1181 }
1182 err += w9968cf_write_reg(cam, 0x0012, 0x39); /* JPEG encoder enable */
1183
1184 return err;
1185 }
1186
1187
1188
1189 /****************************************************************************
1190 * Low-level I2C I/O functions. *
1191 * The adapter supports the following I2C transfer functions: *
1192 * i2c_adap_fastwrite_byte_data() (at 400 kHz bit frequency only) *
1193 * i2c_adap_read_byte_data() *
1194 * i2c_adap_read_byte() *
1195 ****************************************************************************/
1196
1197 static int w9968cf_smbus_start(struct w9968cf_device* cam)
1198 {
1199 int err = 0;
1200
1201 err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
1202 err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
1203
1204 return err;
1205 }
1206
1207
1208 static int w9968cf_smbus_stop(struct w9968cf_device* cam)
1209 {
1210 int err = 0;
1211
1212 err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
1213 err += w9968cf_write_sb(cam, 0x0013); /* SDE=1, SDA=1, SCL=1 */
1214
1215 return err;
1216 }
1217
1218
1219 static int w9968cf_smbus_write_byte(struct w9968cf_device* cam, u8 v)
1220 {
1221 u8 bit;
1222 int err = 0, sda;
1223
1224 for (bit = 0 ; bit < 8 ; bit++) {
1225 sda = (v & 0x80) ? 2 : 0;
1226 v <<= 1;
1227 /* SDE=1, SDA=sda, SCL=0 */
1228 err += w9968cf_write_sb(cam, 0x10 | sda);
1229 /* SDE=1, SDA=sda, SCL=1 */
1230 err += w9968cf_write_sb(cam, 0x11 | sda);
1231 /* SDE=1, SDA=sda, SCL=0 */
1232 err += w9968cf_write_sb(cam, 0x10 | sda);
1233 }
1234
1235 return err;
1236 }
1237
1238
1239 static int w9968cf_smbus_read_byte(struct w9968cf_device* cam, u8* v)
1240 {
1241 u8 bit;
1242 int err = 0;
1243
1244 *v = 0;
1245 for (bit = 0 ; bit < 8 ; bit++) {
1246 *v <<= 1;
1247 err += w9968cf_write_sb(cam, 0x0013);
1248 *v |= (w9968cf_read_sb(cam) & 0x0008) ? 1 : 0;
1249 err += w9968cf_write_sb(cam, 0x0012);
1250 }
1251
1252 return err;
1253 }
1254
1255
1256 static int w9968cf_smbus_write_ack(struct w9968cf_device* cam)
1257 {
1258 int err = 0;
1259
1260 err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
1261 err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
1262 err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
1263
1264 return err;
1265 }
1266
1267
1268 static int w9968cf_smbus_read_ack(struct w9968cf_device* cam)
1269 {
1270 int err = 0, sda;
1271
1272 err += w9968cf_write_sb(cam, 0x0013); /* SDE=1, SDA=1, SCL=1 */
1273 sda = (w9968cf_read_sb(cam) & 0x08) ? 1 : 0; /* sda = SDA */
1274 err += w9968cf_write_sb(cam, 0x0012); /* SDE=1, SDA=1, SCL=0 */
1275 if (sda < 0)
1276 err += sda;
1277 if (sda == 1) {
1278 DBG(6, "Couldn't receive the ACK")
1279 err += -1;
1280 }
1281
1282 return err;
1283 }
1284
1285
1286 /* This seems to refresh the communication through the serial bus */
1287 static int w9968cf_smbus_refresh_bus(struct w9968cf_device* cam)
1288 {
1289 int err = 0, j;
1290
1291 for (j = 1; j <= 10; j++) {
1292 err = w9968cf_write_reg(cam, 0x0020, 0x01);
1293 err += w9968cf_write_reg(cam, 0x0000, 0x01);
1294 if (err)
1295 break;
1296 }
1297
1298 return err;
1299 }
1300
1301
1302 /* SMBus protocol: S Addr Wr [A] Subaddr [A] Value [A] P */
1303 static int
1304 w9968cf_i2c_adap_fastwrite_byte_data(struct w9968cf_device* cam,
1305 u16 address, u8 subaddress,u8 value)
1306 {
1307 u16* data = cam->data_buffer;
1308 int err = 0;
1309
1310 err += w9968cf_smbus_refresh_bus(cam);
1311
1312 /* Enable SBUS outputs */
1313 err += w9968cf_write_sb(cam, 0x0020);
1314
1315 data[0] = 0x082f | ((address & 0x80) ? 0x1500 : 0x0);
1316 data[0] |= (address & 0x40) ? 0x4000 : 0x0;
1317 data[1] = 0x2082 | ((address & 0x40) ? 0x0005 : 0x0);
1318 data[1] |= (address & 0x20) ? 0x0150 : 0x0;
1319 data[1] |= (address & 0x10) ? 0x5400 : 0x0;
1320 data[2] = 0x8208 | ((address & 0x08) ? 0x0015 : 0x0);
1321 data[2] |= (address & 0x04) ? 0x0540 : 0x0;
1322 data[2] |= (address & 0x02) ? 0x5000 : 0x0;
1323 data[3] = 0x1d20 | ((address & 0x02) ? 0x0001 : 0x0);
1324 data[3] |= (address & 0x01) ? 0x0054 : 0x0;
1325
1326 err += w9968cf_write_fsb(cam, data);
1327
1328 data[0] = 0x8208 | ((subaddress & 0x80) ? 0x0015 : 0x0);
1329 data[0] |= (subaddress & 0x40) ? 0x0540 : 0x0;
1330 data[0] |= (subaddress & 0x20) ? 0x5000 : 0x0;
1331 data[1] = 0x0820 | ((subaddress & 0x20) ? 0x0001 : 0x0);
1332 data[1] |= (subaddress & 0x10) ? 0x0054 : 0x0;
1333 data[1] |= (subaddress & 0x08) ? 0x1500 : 0x0;
1334 data[1] |= (subaddress & 0x04) ? 0x4000 : 0x0;
1335 data[2] = 0x2082 | ((subaddress & 0x04) ? 0x0005 : 0x0);
1336 data[2] |= (subaddress & 0x02) ? 0x0150 : 0x0;
1337 data[2] |= (subaddress & 0x01) ? 0x5400 : 0x0;
1338 data[3] = 0x001d;
1339
1340 err += w9968cf_write_fsb(cam, data);
1341
1342 data[0] = 0x8208 | ((value & 0x80) ? 0x0015 : 0x0);
1343 data[0] |= (value & 0x40) ? 0x0540 : 0x0;
1344 data[0] |= (value & 0x20) ? 0x5000 : 0x0;
1345 data[1] = 0x0820 | ((value & 0x20) ? 0x0001 : 0x0);
1346 data[1] |= (value & 0x10) ? 0x0054 : 0x0;
1347 data[1] |= (value & 0x08) ? 0x1500 : 0x0;
1348 data[1] |= (value & 0x04) ? 0x4000 : 0x0;
1349 data[2] = 0x2082 | ((value & 0x04) ? 0x0005 : 0x0);
1350 data[2] |= (value & 0x02) ? 0x0150 : 0x0;
1351 data[2] |= (value & 0x01) ? 0x5400 : 0x0;
1352 data[3] = 0xfe1d;
1353
1354 err += w9968cf_write_fsb(cam, data);
1355
1356 /* Disable SBUS outputs */
1357 err += w9968cf_write_sb(cam, 0x0000);
1358
1359 if (!err)
1360 DBG(5, "I2C write byte data done, addr.0x%04X, subaddr.0x%02X "
1361 "value 0x%02X", address, subaddress, value)
1362 else
1363 DBG(5, "I2C write byte data failed, addr.0x%04X, "
1364 "subaddr.0x%02X, value 0x%02X",
1365 address, subaddress, value)
1366
1367 return err;
1368 }
1369
1370
1371 /* SMBus protocol: S Addr Wr [A] Subaddr [A] P S Addr+1 Rd [A] [Value] NA P */
1372 static int
1373 w9968cf_i2c_adap_read_byte_data(struct w9968cf_device* cam,
1374 u16 address, u8 subaddress,
1375 u8* value)
1376 {
1377 int err = 0;
1378
1379 /* Serial data enable */
1380 err += w9968cf_write_sb(cam, 0x0013); /* don't change ! */
1381
1382 err += w9968cf_smbus_start(cam);
1383 err += w9968cf_smbus_write_byte(cam, address);
1384 err += w9968cf_smbus_read_ack(cam);
1385 err += w9968cf_smbus_write_byte(cam, subaddress);
1386 err += w9968cf_smbus_read_ack(cam);
1387 err += w9968cf_smbus_stop(cam);
1388 err += w9968cf_smbus_start(cam);
1389 err += w9968cf_smbus_write_byte(cam, address + 1);
1390 err += w9968cf_smbus_read_ack(cam);
1391 err += w9968cf_smbus_read_byte(cam, value);
1392 err += w9968cf_smbus_write_ack(cam);
1393 err += w9968cf_smbus_stop(cam);
1394
1395 /* Serial data disable */
1396 err += w9968cf_write_sb(cam, 0x0000);
1397
1398 if (!err)
1399 DBG(5, "I2C read byte data done, addr.0x%04X, "
1400 "subaddr.0x%02X, value 0x%02X",
1401 address, subaddress, *value)
1402 else
1403 DBG(5, "I2C read byte data failed, addr.0x%04X, "
1404 "subaddr.0x%02X, wrong value 0x%02X",
1405 address, subaddress, *value)
1406
1407 return err;
1408 }
1409
1410
1411 /* SMBus protocol: S Addr+1 Rd [A] [Value] NA P */
1412 static int
1413 w9968cf_i2c_adap_read_byte(struct w9968cf_device* cam,
1414 u16 address, u8* value)
1415 {
1416 int err = 0;
1417
1418 /* Serial data enable */
1419 err += w9968cf_write_sb(cam, 0x0013);
1420
1421 err += w9968cf_smbus_start(cam);
1422 err += w9968cf_smbus_write_byte(cam, address + 1);
1423 err += w9968cf_smbus_read_ack(cam);
1424 err += w9968cf_smbus_read_byte(cam, value);
1425 err += w9968cf_smbus_write_ack(cam);
1426 err += w9968cf_smbus_stop(cam);
1427
1428 /* Serial data disable */
1429 err += w9968cf_write_sb(cam, 0x0000);
1430
1431 if (!err)
1432 DBG(5, "I2C read byte done, addr.0x%04X, "
1433 "value 0x%02X", address, *value)
1434 else
1435 DBG(5, "I2C read byte failed, addr.0x%04X, "
1436 "wrong value 0x%02X", address, *value)
1437
1438 return err;
1439 }
1440
1441
1442 /* SMBus protocol: S Addr Wr [A] Value [A] P */
1443 static int
1444 w9968cf_i2c_adap_write_byte(struct w9968cf_device* cam,
1445 u16 address, u8 value)
1446 {
1447 DBG(4, "i2c_write_byte() is an unsupported transfer mode")
1448 return -EINVAL;
1449 }
1450
1451
1452
1453 /****************************************************************************
1454 * I2C interface to kernel *
1455 ****************************************************************************/
1456
1457 static int
1458 w9968cf_i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
1459 unsigned short flags, char read_write, u8 command,
1460 int size, union i2c_smbus_data *data)
1461 {
1462 struct w9968cf_device* cam = i2c_get_adapdata(adapter);
1463 u8 i;
1464 int err = 0;
1465
1466 switch (addr) {
1467 case OV6xx0_SID:
1468 case OV7xx0_SID:
1469 break;
1470 default:
1471 DBG(4, "Rejected slave ID 0x%04X", addr)
1472 return -EINVAL;
1473 }
1474
1475 if (size == I2C_SMBUS_BYTE) {
1476 /* Why addr <<= 1? See OVXXX0_SID defines in ovcamchip.h */
1477 addr <<= 1;
1478
1479 if (read_write == I2C_SMBUS_WRITE)
1480 err = w9968cf_i2c_adap_write_byte(cam, addr, command);
1481 else if (read_write == I2C_SMBUS_READ)
1482 err = w9968cf_i2c_adap_read_byte(cam,addr,&data->byte);
1483
1484 } else if (size == I2C_SMBUS_BYTE_DATA) {
1485 addr <<= 1;
1486
1487 if (read_write == I2C_SMBUS_WRITE)
1488 err = w9968cf_i2c_adap_fastwrite_byte_data(cam, addr,
1489 command, data->byte);
1490 else if (read_write == I2C_SMBUS_READ) {
1491 for (i = 1; i <= W9968CF_I2C_RW_RETRIES; i++) {
1492 err = w9968cf_i2c_adap_read_byte_data(cam,addr,
1493 command, &data->byte);
1494 if (err) {
1495 if (w9968cf_smbus_refresh_bus(cam)) {
1496 err = -EIO;
1497 break;
1498 }
1499 } else
1500 break;
1501 }
1502
1503 } else
1504 return -EINVAL;
1505
1506 } else {
1507 DBG(4, "Unsupported I2C transfer mode (%d)", size)
1508 return -EINVAL;
1509 }
1510
1511 return err;
1512 }
1513
1514
1515 static u32 w9968cf_i2c_func(struct i2c_adapter* adap)
1516 {
1517 return I2C_FUNC_SMBUS_READ_BYTE |
1518 I2C_FUNC_SMBUS_READ_BYTE_DATA |
1519 I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
1520 }
1521
1522
1523 static int w9968cf_i2c_attach_inform(struct i2c_client* client)
1524 {
1525 struct w9968cf_device* cam = i2c_get_adapdata(client->adapter);
1526 const char* clientname = i2c_clientname(client);
1527 int id = client->driver->id, err = 0;
1528
1529 if (id == I2C_DRIVERID_OVCAMCHIP) {
1530 cam->sensor_client = client;
1531 err = w9968cf_sensor_init(cam);
1532 if (err) {
1533 cam->sensor_client = NULL;
1534 return err;
1535 }
1536 } else {
1537 DBG(4, "Rejected client [%s] with driver [%s]",
1538 clientname, client->driver->name)
1539 return -EINVAL;
1540 }
1541
1542 DBG(5, "I2C attach client [%s] with driver [%s]",
1543 clientname, client->driver->name)
1544
1545 return 0;
1546 }
1547
1548
1549 static int w9968cf_i2c_detach_inform(struct i2c_client* client)
1550 {
1551 struct w9968cf_device* cam = i2c_get_adapdata(client->adapter);
1552 const char* clientname = i2c_clientname(client);
1553
1554 if (cam->sensor_client == client)
1555 cam->sensor_client = NULL;
1556
1557 DBG(5, "I2C detach client [%s]", clientname)
1558
1559 return 0;
1560 }
1561
1562
1563 static int
1564 w9968cf_i2c_control(struct i2c_adapter* adapter, unsigned int cmd,
1565 unsigned long arg)
1566 {
1567 return 0;
1568 }
1569
1570
1571 static int w9968cf_i2c_init(struct w9968cf_device* cam)
1572 {
1573 int err = 0;
1574
1575 static struct i2c_algorithm algo = {
1576 .smbus_xfer = w9968cf_i2c_smbus_xfer,
1577 .algo_control = w9968cf_i2c_control,
1578 .functionality = w9968cf_i2c_func,
1579 };
1580
1581 static struct i2c_adapter adap = {
1582 .id = I2C_ALGO_SMBUS | I2C_HW_SMBUS_W9968CF,
1583 .class = I2C_CLASS_CAM_DIGITAL,
1584 .owner = THIS_MODULE,
1585 .client_register = w9968cf_i2c_attach_inform,
1586 .client_unregister = w9968cf_i2c_detach_inform,
1587 .algo = &algo,
1588 };
1589
1590 memcpy(&cam->i2c_adapter, &adap, sizeof(struct i2c_adapter));
1591 strcpy(cam->i2c_adapter.name, "w9968cf");
1592 i2c_set_adapdata(&cam->i2c_adapter, cam);
1593
1594 DBG(6, "Registering I2C adapter with kernel...")
1595
1596 err = i2c_add_adapter(&cam->i2c_adapter);
1597 if (err)
1598 DBG(1, "Failed to register the I2C adapter")
1599 else
1600 DBG(5, "I2C adapter registered")
1601
1602 return err;
1603 }
1604
1605
1606
1607 /****************************************************************************
1608 * Helper functions *
1609 ****************************************************************************/
1610
1611 /*--------------------------------------------------------------------------
1612 Turn on the LED on some webcams. A beep should be heard too.
1613 Return 0 on success, a negative number otherwise.
1614 --------------------------------------------------------------------------*/
1615 static int w9968cf_turn_on_led(struct w9968cf_device* cam)
1616 {
1617 int err = 0;
1618
1619 err += w9968cf_write_reg(cam, 0xff00, 0x00); /* power-down */
1620 err += w9968cf_write_reg(cam, 0xbf17, 0x00); /* reset everything */
1621 err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* normal operation */
1622 err += w9968cf_write_reg(cam, 0x0010, 0x01); /* serial bus, SDS high */
1623 err += w9968cf_write_reg(cam, 0x0000, 0x01); /* serial bus, SDS low */
1624 err += w9968cf_write_reg(cam, 0x0010, 0x01); /* ..high 'beep-beep' */
1625
1626 if (err)
1627 DBG(2, "Couldn't turn on the LED")
1628
1629 DBG(5, "LED turned on")
1630
1631 return err;
1632 }
1633
1634
1635 /*--------------------------------------------------------------------------
1636 Write some registers for the device initialization.
1637 This function is called once on open().
1638 Return 0 on success, a negative number otherwise.
1639 --------------------------------------------------------------------------*/
1640 static int w9968cf_init_chip(struct w9968cf_device* cam)
1641 {
1642 unsigned long hw_bufsize = cam->maxwidth*cam->maxheight*2,
1643 y0 = 0x0000,
1644 u0 = y0 + hw_bufsize/2,
1645 v0 = u0 + hw_bufsize/4,
1646 y1 = v0 + hw_bufsize/4,
1647 u1 = y1 + hw_bufsize/2,
1648 v1 = u1 + hw_bufsize/4;
1649 int err = 0;
1650
1651 err += w9968cf_write_reg(cam, 0xff00, 0x00); /* power off */
1652 err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* power on */
1653
1654 err += w9968cf_write_reg(cam, 0x405d, 0x03); /* DRAM timings */
1655 err += w9968cf_write_reg(cam, 0x0030, 0x04); /* SDRAM timings */
1656
1657 err += w9968cf_write_reg(cam, y0 & 0xffff, 0x20); /* Y buf.0, low */
1658 err += w9968cf_write_reg(cam, y0 >> 16, 0x21); /* Y buf.0, high */
1659 err += w9968cf_write_reg(cam, u0 & 0xffff, 0x24); /* U buf.0, low */
1660 err += w9968cf_write_reg(cam, u0 >> 16, 0x25); /* U buf.0, high */
1661 err += w9968cf_write_reg(cam, v0 & 0xffff, 0x28); /* V buf.0, low */
1662 err += w9968cf_write_reg(cam, v0 >> 16, 0x29); /* V buf.0, high */
1663
1664 err += w9968cf_write_reg(cam, y1 & 0xffff, 0x22); /* Y buf.1, low */
1665 err += w9968cf_write_reg(cam, y1 >> 16, 0x23); /* Y buf.1, high */
1666 err += w9968cf_write_reg(cam, u1 & 0xffff, 0x26); /* U buf.1, low */
1667 err += w9968cf_write_reg(cam, u1 >> 16, 0x27); /* U buf.1, high */
1668 err += w9968cf_write_reg(cam, v1 & 0xffff, 0x2a); /* V buf.1, low */
1669 err += w9968cf_write_reg(cam, v1 >> 16, 0x2b); /* V buf.1, high */
1670
1671 err += w9968cf_write_reg(cam, y1 & 0xffff, 0x32); /* JPEG buf 0 low */
1672 err += w9968cf_write_reg(cam, y1 >> 16, 0x33); /* JPEG buf 0 high */
1673
1674 err += w9968cf_write_reg(cam, y1 & 0xffff, 0x34); /* JPEG buf 1 low */
1675 err += w9968cf_write_reg(cam, y1 >> 16, 0x35); /* JPEG bug 1 high */
1676
1677 err += w9968cf_write_reg(cam, 0x0000, 0x36);/* JPEG restart interval */
1678 err += w9968cf_write_reg(cam, 0x0804, 0x37);/*JPEG VLE FIFO threshold*/
1679 err += w9968cf_write_reg(cam, 0x0000, 0x38);/* disable hw up-scaling */
1680 err += w9968cf_write_reg(cam, 0x0000, 0x3f); /* JPEG/MCTL test data */
1681
1682 err += w9968cf_set_picture(cam, cam->picture); /* this before */
1683 err += w9968cf_set_window(cam, cam->window);
1684
1685 if (err)
1686 DBG(1, "Chip initialization failed")
1687 else
1688 DBG(5, "Chip successfully initialized")
1689
1690 return err;
1691 }
1692
1693
1694 /*--------------------------------------------------------------------------
1695 Return non-zero if the palette is supported, 0 otherwise.
1696 --------------------------------------------------------------------------*/
1697 static inline u16 w9968cf_valid_palette(u16 palette)
1698 {
1699 u8 i = 0;
1700 while (w9968cf_formatlist[i].palette != 0) {
1701 if (palette == w9968cf_formatlist[i].palette)
1702 return palette;
1703 i++;
1704 }
1705 return 0;
1706 }
1707
1708
1709 /*--------------------------------------------------------------------------
1710 Return the depth corresponding to the given palette.
1711 Palette _must_ be supported !
1712 --------------------------------------------------------------------------*/
1713 static inline u16 w9968cf_valid_depth(u16 palette)
1714 {
1715 u8 i=0;
1716 while (w9968cf_formatlist[i].palette != palette)
1717 i++;
1718
1719 return w9968cf_formatlist[i].depth;
1720 }
1721
1722
1723 /*--------------------------------------------------------------------------
1724 Return non-zero if the format requires decompression, 0 otherwise.
1725 --------------------------------------------------------------------------*/
1726 static inline u8 w9968cf_need_decompression(u16 palette)
1727 {
1728 u8 i = 0;
1729 while (w9968cf_formatlist[i].palette != 0) {
1730 if (palette == w9968cf_formatlist[i].palette)
1731 return w9968cf_formatlist[i].compression;
1732 i++;
1733 }
1734 return 0;
1735 }
1736
1737
1738 /*--------------------------------------------------------------------------
1739 Change the picture settings of the camera.
1740 Return 0 on success, a negative number otherwise.
1741 --------------------------------------------------------------------------*/
1742 static int
1743 w9968cf_set_picture(struct w9968cf_device* cam, struct video_picture pict)
1744 {
1745 u16 fmt, hw_depth, hw_palette, reg_v = 0x0000;
1746 int err = 0;
1747
1748 /* Make sure we are using a valid depth */
1749 pict.depth = w9968cf_valid_depth(pict.palette);
1750
1751 fmt = pict.palette;
1752
1753 hw_depth = pict.depth; /* depth used by the winbond chip */
1754 hw_palette = pict.palette; /* palette used by the winbond chip */
1755
1756 /* VS & HS polarities */
1757 reg_v = (cam->vs_polarity << 12) | (cam->hs_polarity << 11);
1758
1759 switch (fmt)
1760 {
1761 case VIDEO_PALETTE_UYVY:
1762 reg_v |= 0x0000;
1763 cam->vpp_flag = VPP_NONE;
1764 break;
1765 case VIDEO_PALETTE_YUV422P:
1766 reg_v |= 0x0002;
1767 cam->vpp_flag = VPP_DECOMPRESSION;
1768 break;
1769 case VIDEO_PALETTE_YUV420:
1770 case VIDEO_PALETTE_YUV420P:
1771 reg_v |= 0x0003;
1772 cam->vpp_flag = VPP_DECOMPRESSION;
1773 break;
1774 case VIDEO_PALETTE_YUYV:
1775 case VIDEO_PALETTE_YUV422:
1776 reg_v |= 0x0000;
1777 cam->vpp_flag = VPP_SWAP_YUV_BYTES;
1778 hw_palette = VIDEO_PALETTE_UYVY;
1779 break;
1780 /* Original video is used instead of RGBX palettes.
1781 Software conversion later. */
1782 case VIDEO_PALETTE_GREY:
1783 case VIDEO_PALETTE_RGB555:
1784 case VIDEO_PALETTE_RGB565:
1785 case VIDEO_PALETTE_RGB24:
1786 case VIDEO_PALETTE_RGB32:
1787 reg_v |= 0x0000; /* UYVY 16 bit is used */
1788 hw_depth = 16;
1789 hw_palette = VIDEO_PALETTE_UYVY;
1790 cam->vpp_flag = VPP_UYVY_TO_RGBX;
1791 break;
1792 }
1793
1794 /* NOTE: due to memory issues, it is better to disable the hardware
1795 double buffering during compression */
1796 if (cam->double_buffer && !(cam->vpp_flag & VPP_DECOMPRESSION))
1797 reg_v |= 0x0080;
1798
1799 if (cam->clamping)
1800 reg_v |= 0x0020;
1801
1802 if (cam->filter_type == 1)
1803 reg_v |= 0x0008;
1804 else if (cam->filter_type == 2)
1805 reg_v |= 0x000c;
1806
1807 if ((err = w9968cf_write_reg(cam, reg_v, 0x16)))
1808 goto error;
1809
1810 if ((err = w9968cf_sensor_update_picture(cam, pict)))
1811 goto error;
1812
1813 /* If all went well, update the device data structure */
1814 memcpy(&cam->picture, &pict, sizeof(pict));
1815 cam->hw_depth = hw_depth;
1816 cam->hw_palette = hw_palette;
1817
1818 /* Settings changed, so we clear the frame buffers */
1819 memset(cam->frame[0].buffer, 0, cam->nbuffers*cam->frame[0].size);
1820
1821 DBG(4, "Palette is %s, depth is %u bpp",
1822 symbolic(v4l1_plist, pict.palette), pict.depth)
1823
1824 return 0;
1825
1826 error:
1827 DBG(1, "Failed to change picture settings")
1828 return err;
1829 }
1830
1831
1832 /*--------------------------------------------------------------------------
1833 Change the capture area size of the camera.
1834 This function _must_ be called _after_ w9968cf_set_picture().
1835 Return 0 on success, a negative number otherwise.
1836 --------------------------------------------------------------------------*/
1837 static int
1838 w9968cf_set_window(struct w9968cf_device* cam, struct video_window win)
1839 {
1840 u16 x, y, w, h, scx, scy, cw, ch, ax, ay;
1841 unsigned long fw, fh;
1842 struct ovcamchip_window s_win;
1843 int err = 0;
1844
1845 /* Work around to avoid FP arithmetics */
1846 #define __SC(x) ((x) << 10)
1847 #define __UNSC(x) ((x) >> 10)
1848
1849 /* Make sure we are using a supported resolution */
1850 if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
1851 (u16*)&win.height)))
1852 goto error;
1853
1854 /* Scaling factors */
1855 fw = __SC(win.width) / cam->maxwidth;
1856 fh = __SC(win.height) / cam->maxheight;
1857
1858 /* Set up the width and height values used by the chip */
1859 if ((win.width > cam->maxwidth) || (win.height > cam->maxheight)) {
1860 cam->vpp_flag |= VPP_UPSCALE;
1861 /* Calculate largest w,h mantaining the same w/h ratio */
1862 w = (fw >= fh) ? cam->maxwidth : __SC(win.width)/fh;
1863 h = (fw >= fh) ? __SC(win.height)/fw : cam->maxheight;
1864 if (w < cam->minwidth) /* just in case */
1865 w = cam->minwidth;
1866 if (h < cam->minheight) /* just in case */
1867 h = cam->minheight;
1868 } else {
1869 cam->vpp_flag &= ~VPP_UPSCALE;
1870 w = win.width;
1871 h = win.height;
1872 }
1873
1874 /* x,y offsets of the cropped area */
1875 scx = cam->start_cropx;
1876 scy = cam->start_cropy;
1877
1878 /* Calculate cropped area manteining the right w/h ratio */
1879 if (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE)) {
1880 cw = (fw >= fh) ? cam->maxwidth : __SC(win.width)/fh;
1881 ch = (fw >= fh) ? __SC(win.height)/fw : cam->maxheight;
1882 } else {
1883 cw = w;
1884 ch = h;
1885 }
1886
1887 /* Setup the window of the sensor */
1888 s_win.format = VIDEO_PALETTE_UYVY;
1889 s_win.width = cam->maxwidth;
1890 s_win.height = cam->maxheight;
1891 s_win.quarter = 0; /* full progressive video */
1892
1893 /* Center it */
1894 s_win.x = (s_win.width - cw) / 2;
1895 s_win.y = (s_win.height - ch) / 2;
1896
1897 /* Clock divisor */
1898 if (cam->clockdiv >= 0)
1899 s_win.clockdiv = cam->clockdiv; /* manual override */
1900 else
1901 switch (cam->sensor) {
1902 case CC_OV6620:
1903 s_win.clockdiv = 0;
1904 break;
1905 case CC_OV6630:
1906 s_win.clockdiv = 0;
1907 break;
1908 case CC_OV76BE:
1909 case CC_OV7610:
1910 case CC_OV7620:
1911 s_win.clockdiv = 0;
1912 break;
1913 default:
1914 s_win.clockdiv = W9968CF_DEF_CLOCKDIVISOR;
1915 }
1916
1917 /* We have to scale win.x and win.y offsets */
1918 if ( (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE))
1919 || (cam->vpp_flag & VPP_UPSCALE) ) {
1920 ax = __SC(win.x)/fw;
1921 ay = __SC(win.y)/fh;
1922 } else {
1923 ax = win.x;
1924 ay = win.y;
1925 }
1926
1927 if ((ax + cw) > cam->maxwidth)
1928 ax = cam->maxwidth - cw;
1929
1930 if ((ay + ch) > cam->maxheight)
1931 ay = cam->maxheight - ch;
1932
1933 /* Adjust win.x, win.y */
1934 if ( (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE))
1935 || (cam->vpp_flag & VPP_UPSCALE) ) {
1936 win.x = __UNSC(ax*fw);
1937 win.y = __UNSC(ay*fh);
1938 } else {
1939 win.x = ax;
1940 win.y = ay;
1941 }
1942
1943 /* Offsets used by the chip */
1944 x = ax + s_win.x;
1945 y = ay + s_win.y;
1946
1947 /* Go ! */
1948 if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_S_MODE, &s_win)))
1949 goto error;
1950
1951 err += w9968cf_write_reg(cam, scx + x, 0x10);
1952 err += w9968cf_write_reg(cam, scy + y, 0x11);
1953 err += w9968cf_write_reg(cam, scx + x + cw, 0x12);
1954 err += w9968cf_write_reg(cam, scy + y + ch, 0x13);
1955 err += w9968cf_write_reg(cam, w, 0x14);
1956 err += w9968cf_write_reg(cam, h, 0x15);
1957
1958 /* JPEG width & height */
1959 err += w9968cf_write_reg(cam, w, 0x30);
1960 err += w9968cf_write_reg(cam, h, 0x31);
1961
1962 /* Y & UV frame buffer strides (in WORD) */
1963 if (cam->vpp_flag & VPP_DECOMPRESSION) {
1964 err += w9968cf_write_reg(cam, w/2, 0x2c);
1965 err += w9968cf_write_reg(cam, w/4, 0x2d);
1966 } else
1967 err += w9968cf_write_reg(cam, w, 0x2c);
1968
1969 if (err)
1970 goto error;
1971
1972 /* If all went well, update the device data structure */
1973 memcpy(&cam->window, &win, sizeof(win));
1974 cam->hw_width = w;
1975 cam->hw_height = h;
1976
1977 /* Settings changed, so we clear the frame buffers */
1978 memset(cam->frame[0].buffer, 0, cam->nbuffers*cam->frame[0].size);
1979
1980 DBG(4, "The capture area is %dx%d, Offset (x,y)=(%u,%u)",
1981 win.width, win.height, win.x, win.y)
1982
1983 PDBGG("x=%u ,y=%u, w=%u, h=%u, ax=%u, ay=%u, s_win.x=%u, s_win.y=%u, "
1984 "cw=%u, ch=%u, win.x=%u, win.y=%u, win.width=%u, win.height=%u",
1985 x, y, w, h, ax, ay, s_win.x, s_win.y, cw, ch, win.x, win.y,
1986 win.width, win.height)
1987
1988 return 0;
1989
1990 error:
1991 DBG(1, "Failed to change the capture area size")
1992 return err;
1993 }
1994
1995
1996 /*--------------------------------------------------------------------------
1997 Adjust the asked values for window width and height.
1998 Return 0 on success, -1 otherwise.
1999 --------------------------------------------------------------------------*/
2000 static int
2001 w9968cf_adjust_window_size(struct w9968cf_device* cam, u16* width, u16* height)
2002 {
2003 u16 maxw, maxh;
2004
2005 if ((*width < cam->minwidth) || (*height < cam->minheight))
2006 return -ERANGE;
2007
2008 maxw = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
2009 w9968cf_vpp ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
2010 : cam->maxwidth;
2011 maxh = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
2012 w9968cf_vpp ? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
2013 : cam->maxheight;
2014
2015 if (*width > maxw)
2016 *width = maxw;
2017 if (*height > maxh)
2018 *height = maxh;
2019
2020 if (cam->vpp_flag & VPP_DECOMPRESSION) {
2021 *width &= ~15L; /* multiple of 16 */
2022 *height &= ~15L;
2023 }
2024
2025 PDBGG("Window size adjusted w=%u, h=%u ", *width, *height)
2026
2027 return 0;
2028 }
2029
2030
2031 /*--------------------------------------------------------------------------
2032 Initialize the FIFO list of requested frames.
2033 --------------------------------------------------------------------------*/
2034 static void w9968cf_init_framelist(struct w9968cf_device* cam)
2035 {
2036 u8 i;
2037
2038 for (i = 0; i < cam->nbuffers; i++) {
2039 cam->requested_frame[i] = NULL;
2040 cam->frame[i].queued = 0;
2041 cam->frame[i].status = F_UNUSED;
2042 }
2043 }
2044
2045
2046 /*--------------------------------------------------------------------------
2047 Add a frame in the FIFO list of requested frames.
2048 This function is called in process context.
2049 --------------------------------------------------------------------------*/
2050 static void w9968cf_push_frame(struct w9968cf_device* cam, u8 f_num)
2051 {
2052 u8 f;
2053 unsigned long lock_flags;
2054
2055 spin_lock_irqsave(&cam->flist_lock, lock_flags);
2056
2057 for (f=0; cam->requested_frame[f] != NULL; f++);
2058 cam->requested_frame[f] = &cam->frame[f_num];
2059 cam->frame[f_num].queued = 1;
2060 cam->frame[f_num].status = F_UNUSED; /* clear the status */
2061
2062 spin_unlock_irqrestore(&cam->flist_lock, lock_flags);
2063
2064 DBG(6, "Frame #%u pushed into the FIFO list. Position %u", f_num, f)
2065 }
2066
2067
2068 /*--------------------------------------------------------------------------
2069 Read, store and remove the first pointer in the FIFO list of requested
2070 frames. This function is called in interrupt context.
2071 --------------------------------------------------------------------------*/
2072 static void
2073 w9968cf_pop_frame(struct w9968cf_device* cam, struct w9968cf_frame_t** framep)
2074 {
2075 u8 i;
2076
2077 spin_lock(&cam->flist_lock);
2078
2079 *framep = cam->requested_frame[0];
2080
2081 /* Shift the list of pointers */
2082 for (i = 0; i < cam->nbuffers-1; i++)
2083 cam->requested_frame[i] = cam->requested_frame[i+1];
2084 cam->requested_frame[i] = NULL;
2085
2086 spin_unlock(&cam->flist_lock);
2087
2088 DBG(6,"Popped frame #%d from the list", (*framep)->number)
2089 }
2090
2091
2092 /*--------------------------------------------------------------------------
2093 High-level video post-processing routine on grabbed frames.
2094 Return 0 on success, a negative number otherwise.
2095 --------------------------------------------------------------------------*/
2096 static int
2097 w9968cf_postprocess_frame(struct w9968cf_device* cam,
2098 struct w9968cf_frame_t* fr)
2099 {
2100 void *pIn = fr->buffer, *pOut = cam->frame_vpp.buffer, *tmp;
2101 u16 w = cam->window.width,
2102 h = cam->window.height,
2103 d = cam->picture.depth,
2104 fmt = cam->picture.palette,
2105 rgb = cam->force_rgb,
2106 hw_w = cam->hw_width,
2107 hw_h = cam->hw_height,
2108 hw_d = cam->hw_depth;
2109 int err = 0;
2110
2111 #define _PSWAP(pIn, pOut) {tmp = (pIn); (pIn) = (pOut); (pOut) = tmp;}
2112
2113 if (cam->vpp_flag & VPP_DECOMPRESSION) {
2114 memcpy(pOut, pIn, fr->length);
2115 _PSWAP(pIn, pOut)
2116 err = w9968cf_vpp->decode(pIn, fr->length, hw_w, hw_h, pOut);
2117 PDBGG("Compressed frame length: %lu",(unsigned long)fr->length)
2118 fr->length = (hw_w*hw_h*hw_d)/8;
2119 _PSWAP(pIn, pOut)
2120 if (err) {
2121 DBG(4, "An error occurred while decoding the frame: "
2122 "%s", symbolic(decoder_errlist, err))
2123 return err;
2124 } else
2125 DBG(6, "Frame decoded")
2126 }
2127
2128 if (cam->vpp_flag & VPP_SWAP_YUV_BYTES) {
2129 w9968cf_vpp->swap_yuvbytes(pIn, fr->length);
2130 DBG(6, "Original UYVY component ordering changed")
2131 }
2132
2133 if (cam->vpp_flag & VPP_UPSCALE) {
2134 w9968cf_vpp->scale_up(pIn, pOut, hw_w, hw_h, hw_d, w, h);
2135 fr->length = (w*h*hw_d)/8;
2136 _PSWAP(pIn, pOut)
2137 DBG(6, "Vertical up-scaling done: %u,%u,%ubpp->%u,%u",
2138 hw_w, hw_h, hw_d, w, h)
2139 }
2140
2141 if (cam->vpp_flag & VPP_UYVY_TO_RGBX) {
2142 w9968cf_vpp->uyvy_to_rgbx(pIn, fr->length, pOut, fmt, rgb);
2143 fr->length = (w*h*d)/8;
2144 _PSWAP(pIn, pOut)
2145 DBG(6, "UYVY-16bit to %s conversion done",
2146 symbolic(v4l1_plist, fmt))
2147 }
2148
2149 if (pOut == fr->buffer)
2150 memcpy(fr->buffer, cam->frame_vpp.buffer, fr->length);
2151
2152 return 0;
2153 }
2154
2155
2156
2157 /****************************************************************************
2158 * Image sensor control routines *
2159 ****************************************************************************/
2160
2161 static int
2162 w9968cf_sensor_set_control(struct w9968cf_device* cam, int cid, int val)
2163 {
2164 struct ovcamchip_control ctl;
2165 int err;
2166
2167 ctl.id = cid;
2168 ctl.value = val;
2169
2170 err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_S_CTRL, &ctl);
2171
2172 return err;
2173 }
2174
2175
2176 static int
2177 w9968cf_sensor_get_control(struct w9968cf_device* cam, int cid, int* val)
2178 {
2179 struct ovcamchip_control ctl;
2180 int err;
2181
2182 ctl.id = cid;
2183
2184 err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_G_CTRL, &ctl);
2185 if (!err)
2186 *val = ctl.value;
2187
2188 return err;
2189 }
2190
2191
2192 static int
2193 w9968cf_sensor_cmd(struct w9968cf_device* cam, unsigned int cmd, void* arg)
2194 {
2195 struct i2c_client* c = cam->sensor_client;
2196 int rc = 0;
2197
2198 if (!c || !c->driver || !c->driver->command)
2199 return -EINVAL;
2200
2201 rc = c->driver->command(c, cmd, arg);
2202 /* The I2C driver returns -EPERM on non-supported controls */
2203 return (rc < 0 && rc != -EPERM) ? rc : 0;
2204 }
2205
2206
2207 /*--------------------------------------------------------------------------
2208 Update some settings of the image sensor.
2209 Returns: 0 on success, a negative number otherwise.
2210 --------------------------------------------------------------------------*/
2211 static int w9968cf_sensor_update_settings(struct w9968cf_device* cam)
2212 {
2213 int err = 0;
2214
2215 /* Auto brightness */
2216 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_AUTOBRIGHT,
2217 cam->auto_brt);
2218 if (err)
2219 return err;
2220
2221 /* Auto exposure */
2222 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_AUTOEXP,
2223 cam->auto_exp);
2224 if (err)
2225 return err;
2226
2227 /* Banding filter */
2228 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BANDFILT,
2229 cam->bandfilt);
2230 if (err)
2231 return err;
2232
2233 /* Light frequency */
2234 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_FREQ,
2235 cam->lightfreq);
2236 if (err)
2237 return err;
2238
2239 /* Back light */
2240 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BACKLIGHT,
2241 cam->backlight);
2242 if (err)
2243 return err;
2244
2245 /* Mirror */
2246 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_MIRROR,
2247 cam->mirror);
2248 if (err)
2249 return err;
2250
2251 return 0;
2252 }
2253
2254
2255 /*--------------------------------------------------------------------------
2256 Get some current picture settings from the image sensor and update the
2257 internal 'picture' structure of the camera.
2258 Returns: 0 on success, a negative number otherwise.
2259 --------------------------------------------------------------------------*/
2260 static int w9968cf_sensor_get_picture(struct w9968cf_device* cam)
2261 {
2262 int err, v;
2263
2264 err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_CONT, &v);
2265 if (err)
2266 return err;
2267 cam->picture.contrast = v;
2268
2269 err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_BRIGHT, &v);
2270 if (err)
2271 return err;
2272 cam->picture.brightness = v;
2273
2274 err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_SAT, &v);
2275 if (err)
2276 return err;
2277 cam->picture.colour = v;
2278
2279 err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_HUE, &v);
2280 if (err)
2281 return err;
2282 cam->picture.hue = v;
2283
2284 DBG(5, "Got picture settings from the image sensor")
2285
2286 PDBGG("Brightness, contrast, hue, colour, whiteness are "
2287 "%u,%u,%u,%u,%u", cam->picture.brightness,cam->picture.contrast,
2288 cam->picture.hue, cam->picture.colour, cam->picture.whiteness)
2289
2290 return 0;
2291 }
2292
2293
2294 /*--------------------------------------------------------------------------
2295 Update picture settings of the image sensor.
2296 Returns: 0 on success, a negative number otherwise.
2297 --------------------------------------------------------------------------*/
2298 static int
2299 w9968cf_sensor_update_picture(struct w9968cf_device* cam,
2300 struct video_picture pict)
2301 {
2302 int err = 0;
2303
2304 if ((!cam->sensor_initialized)
2305 || pict.contrast != cam->picture.contrast) {
2306 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_CONT,
2307 pict.contrast);
2308 if (err)
2309 goto fail;
2310 DBG(4, "Contrast changed from %u to %u",
2311 cam->picture.contrast, pict.contrast)
2312 cam->picture.contrast = pict.contrast;
2313 }
2314
2315 if (((!cam->sensor_initialized) ||
2316 pict.brightness != cam->picture.brightness) && (!cam->auto_brt)) {
2317 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BRIGHT,
2318 pict.brightness);
2319 if (err)
2320 goto fail;
2321 DBG(4, "Brightness changed from %u to %u",
2322 cam->picture.brightness, pict.brightness)
2323 cam->picture.brightness = pict.brightness;
2324 }
2325
2326 if ((!cam->sensor_initialized) || pict.colour != cam->picture.colour) {
2327 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_SAT,
2328 pict.colour);
2329 if (err)
2330 goto fail;
2331 DBG(4, "Colour changed from %u to %u",
2332 cam->picture.colour, pict.colour)
2333 cam->picture.colour = pict.colour;
2334 }
2335
2336 if ((!cam->sensor_initialized) || pict.hue != cam->picture.hue) {
2337 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_HUE,
2338 pict.hue);
2339 if (err)
2340 goto fail;
2341 DBG(4, "Hue changed from %u to %u",
2342 cam->picture.hue, pict.hue)
2343 cam->picture.hue = pict.hue;
2344 }
2345
2346 return 0;
2347
2348 fail:
2349 DBG(4, "Failed to change sensor picture setting")
2350 return err;
2351 }
2352
2353
2354
2355 /****************************************************************************
2356 * Camera configuration *
2357 ****************************************************************************/
2358
2359 /*--------------------------------------------------------------------------
2360 This function is called when a supported image sensor is detected.
2361 Return 0 if the initialization succeeds, a negative number otherwise.
2362 --------------------------------------------------------------------------*/
2363 static int w9968cf_sensor_init(struct w9968cf_device* cam)
2364 {
2365 int err = 0;
2366
2367 if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_INITIALIZE,
2368 &cam->monochrome)))
2369 goto error;
2370
2371 if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_Q_SUBTYPE,
2372 &cam->sensor)))
2373 goto error;
2374
2375 /* NOTE: Make sure width and height are a multiple of 16 */
2376 switch (cam->sensor_client->addr) {
2377 case OV6xx0_SID:
2378 cam->maxwidth = 352;
2379 cam->maxheight = 288;
2380 cam->minwidth = 64;
2381 cam->minheight = 48;
2382 break;
2383 case OV7xx0_SID:
2384 cam->maxwidth = 640;
2385 cam->maxheight = 480;
2386 cam->minwidth = 64;
2387 cam->minheight = 48;
2388 break;
2389 default:
2390 DBG(1, "Not supported image sensor detected for %s",
2391 symbolic(camlist, cam->id))
2392 return -EINVAL;
2393 }
2394
2395 /* These values depend on the ones in the ovxxx0.c sources */
2396 switch (cam->sensor) {
2397 case CC_OV7620:
2398 cam->start_cropx = 287;
2399 cam->start_cropy = 35;
2400 /* Seems to work around a bug in the image sensor */
2401 cam->vs_polarity = 1;
2402 cam->hs_polarity = 1;
2403 break;
2404 default:
2405 cam->start_cropx = 320;
2406 cam->start_cropy = 35;
2407 cam->vs_polarity = 1;
2408 cam->hs_polarity = 0;
2409 }
2410
2411 if ((err = w9968cf_sensor_update_settings(cam)))
2412 goto error;
2413
2414 if ((err = w9968cf_sensor_update_picture(cam, cam->picture)))
2415 goto error;
2416
2417 cam->sensor_initialized = 1;
2418
2419 DBG(2, "%s image sensor initialized", symbolic(senlist, cam->sensor))
2420 return 0;
2421
2422 error:
2423 cam->sensor_initialized = 0;
2424 cam->sensor = CC_UNKNOWN;
2425 DBG(1, "Image sensor initialization failed for %s (/dev/video%d). "
2426 "Try to detach and attach this device again",
2427 symbolic(camlist, cam->id), cam->v4ldev->minor)
2428 return err;
2429 }
2430
2431
2432 /*--------------------------------------------------------------------------
2433 Fill some basic fields in the main device data structure.
2434 This function is called once on w9968cf_usb_probe() for each recognized
2435 camera.
2436 --------------------------------------------------------------------------*/
2437 static void
2438 w9968cf_configure_camera(struct w9968cf_device* cam,
2439 struct usb_device* udev,
2440 enum w9968cf_model_id mod_id,
2441 const unsigned short dev_nr)
2442 {
2443 init_MUTEX(&cam->fileop_sem);
2444 init_waitqueue_head(&cam->open);
2445 spin_lock_init(&cam->urb_lock);
2446 spin_lock_init(&cam->flist_lock);
2447
2448 cam->users = 0;
2449 cam->disconnected = 0;
2450 cam->id = mod_id;
2451 cam->sensor = CC_UNKNOWN;
2452 cam->sensor_initialized = 0;
2453
2454 /* Calculate the alternate setting number (from 1 to 16)
2455 according to the 'packet_size' module parameter */
2456 if (packet_size[dev_nr] < W9968CF_MIN_PACKET_SIZE)
2457 packet_size[dev_nr] = W9968CF_MIN_PACKET_SIZE;
2458 for (cam->altsetting = 1;
2459 packet_size[dev_nr] < wMaxPacketSize[cam->altsetting-1];
2460 cam->altsetting++);
2461
2462 cam->max_buffers = (max_buffers[dev_nr] < 2 ||
2463 max_buffers[dev_nr] > W9968CF_MAX_BUFFERS)
2464 ? W9968CF_BUFFERS : (u8)max_buffers[dev_nr];
2465
2466 cam->double_buffer = (double_buffer[dev_nr] == 0 ||
2467 double_buffer[dev_nr] == 1)
2468 ? (u8)double_buffer[dev_nr]:W9968CF_DOUBLE_BUFFER;
2469
2470 cam->clamping = (clamping[dev_nr] == 0 || clamping[dev_nr] == 1)
2471 ? (u8)clamping[dev_nr] : W9968CF_CLAMPING;
2472
2473 cam->filter_type = (filter_type[dev_nr] == 0 ||
2474 filter_type[dev_nr] == 1 ||
2475 filter_type[dev_nr] == 2)
2476 ? (u8)filter_type[dev_nr] : W9968CF_FILTER_TYPE;
2477
2478 cam->capture = 1;
2479
2480 cam->largeview = (largeview[dev_nr] == 0 || largeview[dev_nr] == 1)
2481 ? (u8)largeview[dev_nr] : W9968CF_LARGEVIEW;
2482
2483 cam->decompression = (decompression[dev_nr] == 0 ||
2484 decompression[dev_nr] == 1 ||
2485 decompression[dev_nr] == 2)
2486 ? (u8)decompression[dev_nr]:W9968CF_DECOMPRESSION;
2487
2488 cam->upscaling = (upscaling[dev_nr] == 0 ||
2489 upscaling[dev_nr] == 1)
2490 ? (u8)upscaling[dev_nr] : W9968CF_UPSCALING;
2491
2492 cam->auto_brt = (autobright[dev_nr] == 0 || autobright[dev_nr] == 1)
2493 ? (u8)autobright[dev_nr] : W9968CF_AUTOBRIGHT;
2494
2495 cam->auto_exp = (autoexp[dev_nr] == 0 || autoexp[dev_nr] == 1)
2496 ? (u8)autoexp[dev_nr] : W9968CF_AUTOEXP;
2497
2498 cam->lightfreq = (lightfreq[dev_nr] == 50 || lightfreq[dev_nr] == 60)
2499 ? (u8)lightfreq[dev_nr] : W9968CF_LIGHTFREQ;
2500
2501 cam->bandfilt = (bandingfilter[dev_nr] == 0 ||
2502 bandingfilter[dev_nr] == 1)
2503 ? (u8)bandingfilter[dev_nr] : W9968CF_BANDINGFILTER;
2504
2505 cam->backlight = (backlight[dev_nr] == 0 || backlight[dev_nr] == 1)
2506 ? (u8)backlight[dev_nr] : W9968CF_BACKLIGHT;
2507
2508 cam->clockdiv = (clockdiv[dev_nr] == -1 || clockdiv[dev_nr] >= 0)
2509 ? (s8)clockdiv[dev_nr] : W9968CF_CLOCKDIV;
2510
2511 cam->mirror = (mirror[dev_nr] == 0 || mirror[dev_nr] == 1)
2512 ? (u8)mirror[dev_nr] : W9968CF_MIRROR;
2513
2514 cam->monochrome = (monochrome[dev_nr] == 0 || monochrome[dev_nr] == 1)
2515 ? monochrome[dev_nr] : W9968CF_MONOCHROME;
2516
2517 cam->picture.brightness = (u16)brightness[dev_nr];
2518 cam->picture.hue = (u16)hue[dev_nr];
2519 cam->picture.colour = (u16)colour[dev_nr];
2520 cam->picture.contrast = (u16)contrast[dev_nr];
2521 cam->picture.whiteness = (u16)whiteness[dev_nr];
2522 if (w9968cf_valid_palette((u16)force_palette[dev_nr])) {
2523 cam->picture.palette = (u16)force_palette[dev_nr];
2524 cam->force_palette = 1;
2525 } else {
2526 cam->force_palette = 0;
2527 if (cam->decompression == 0)
2528 cam->picture.palette = W9968CF_PALETTE_DECOMP_OFF;
2529 else if (cam->decompression == 1)
2530 cam->picture.palette = W9968CF_PALETTE_DECOMP_FORCE;
2531 else
2532 cam->picture.palette = W9968CF_PALETTE_DECOMP_ON;
2533 }
2534 cam->picture.depth = w9968cf_valid_depth(cam->picture.palette);
2535
2536 cam->force_rgb = (force_rgb[dev_nr] == 0 || force_rgb[dev_nr] == 1)
2537 ? (u8)force_rgb[dev_nr] : W9968CF_FORCE_RGB;
2538
2539 cam->window.x = 0;
2540 cam->window.y = 0;
2541 cam->window.width = W9968CF_WIDTH;
2542 cam->window.height = W9968CF_HEIGHT;
2543 cam->window.chromakey = 0;
2544 cam->window.clipcount = 0;
2545 cam->window.flags = 0;
2546
2547 DBG(3, "%s configured with settings #%u:",
2548 symbolic(camlist, cam->id), dev_nr)
2549
2550 DBG(3, "- Data packet size for USB isochrnous transfer: %u bytes",
2551 wMaxPacketSize[cam->altsetting-1])
2552
2553 DBG(3, "- Number of requested video frame buffers: %u",
2554 cam->max_buffers)
2555
2556 if (cam->double_buffer)
2557 DBG(3, "- Hardware double buffering enabled")
2558 else
2559 DBG(3, "- Hardware double buffering disabled")
2560
2561 if (cam->filter_type == 0)
2562 DBG(3, "- Video filtering disabled")
2563 else if (cam->filter_type == 1)
2564 DBG(3, "- Video filtering enabled: type 1-2-1")
2565 else if (cam->filter_type == 2)
2566 DBG(3, "- Video filtering enabled: type 2-3-6-3-2")
2567
2568 if (cam->clamping)
2569 DBG(3, "- Video data clamping (CCIR-601 format) enabled")
2570 else
2571 DBG(3, "- Video data clamping (CCIR-601 format) disabled")
2572
2573 if (cam->largeview)
2574 DBG(3, "- Large view enabled")
2575 else
2576 DBG(3, "- Large view disabled")
2577
2578 if ((cam->decompression) == 0 && (!cam->force_palette))
2579 DBG(3, "- Decompression disabled")
2580 else if ((cam->decompression) == 1 && (!cam->force_palette))
2581 DBG(3, "- Decompression forced")
2582 else if ((cam->decompression) == 2 && (!cam->force_palette))
2583 DBG(3, "- Decompression allowed")
2584
2585 if (cam->upscaling)
2586 DBG(3, "- Software image scaling enabled")
2587 else
2588 DBG(3, "- Software image scaling disabled")
2589
2590 if (cam->force_palette)
2591 DBG(3, "- Image palette forced to %s",
2592 symbolic(v4l1_plist, cam->picture.palette))
2593
2594 if (cam->force_rgb)
2595 DBG(3, "- RGB component ordering will be used instead of BGR")
2596
2597 if (cam->auto_brt)
2598 DBG(3, "- Auto brightness enabled")
2599 else
2600 DBG(3, "- Auto brightness disabled")
2601
2602 if (cam->auto_exp)
2603 DBG(3, "- Auto exposure enabled")
2604 else
2605 DBG(3, "- Auto exposure disabled")
2606
2607 if (cam->backlight)
2608 DBG(3, "- Backlight exposure algorithm enabled")
2609 else
2610 DBG(3, "- Backlight exposure algorithm disabled")
2611
2612 if (cam->mirror)
2613 DBG(3, "- Mirror enabled")
2614 else
2615 DBG(3, "- Mirror disabled")
2616
2617 if (cam->bandfilt)
2618 DBG(3, "- Banding filter enabled")
2619 else
2620 DBG(3, "- Banding filter disabled")
2621
2622 DBG(3, "- Power lighting frequency: %u", cam->lightfreq)
2623
2624 if (cam->clockdiv == -1)
2625 DBG(3, "- Automatic clock divisor enabled")
2626 else
2627 DBG(3, "- Clock divisor: %d", cam->clockdiv)
2628
2629 if (cam->monochrome)
2630 DBG(3, "- Image sensor used as monochrome")
2631 else
2632 DBG(3, "- Image sensor not used as monochrome")
2633 }
2634
2635
2636 /*--------------------------------------------------------------------------
2637 If the video post-processing module is not loaded, some parameters
2638 must be overridden.
2639 --------------------------------------------------------------------------*/
2640 static void w9968cf_adjust_configuration(struct w9968cf_device* cam)
2641 {
2642 if (!w9968cf_vpp) {
2643 if (cam->decompression == 1) {
2644 cam->decompression = 2;
2645 DBG(2, "Video post-processing module not found: "
2646 "'decompression' parameter forced to 2")
2647 }
2648 if (cam->upscaling) {
2649 cam->upscaling = 0;
2650 DBG(2, "Video post-processing module not found: "
2651 "'upscaling' parameter forced to 0")
2652 }
2653 if (cam->picture.palette != VIDEO_PALETTE_UYVY) {
2654 cam->force_palette = 0;
2655 DBG(2, "Video post-processing module not found: "
2656 "'force_palette' parameter forced to 0")
2657 }
2658 cam->picture.palette = VIDEO_PALETTE_UYVY;
2659 cam->picture.depth = w9968cf_valid_depth(cam->picture.palette);
2660 }
2661 }
2662
2663
2664 /*--------------------------------------------------------------------------
2665 Release the resources used by the driver.
2666 This function is called on disconnect
2667 (or on close if deallocation has been deferred)
2668 --------------------------------------------------------------------------*/
2669 static void w9968cf_release_resources(struct w9968cf_device* cam)
2670 {
2671 down(&w9968cf_devlist_sem);
2672
2673 DBG(2, "V4L device deregistered: /dev/video%d", cam->v4ldev->minor)
2674
2675 video_unregister_device(cam->v4ldev);
2676 list_del(&cam->v4llist);
2677 i2c_del_adapter(&cam->i2c_adapter);
2678 w9968cf_deallocate_memory(cam);
2679 kfree(cam->control_buffer);
2680 kfree(cam->data_buffer);
2681
2682 up(&w9968cf_devlist_sem);
2683 }
2684
2685
2686
2687 /****************************************************************************
2688 * Video4Linux interface *
2689 ****************************************************************************/
2690
2691 static int w9968cf_open(struct inode* inode, struct file* filp)
2692 {
2693 struct w9968cf_device* cam;
2694 int err;
2695
2696 /* This the only safe way to prevent race conditions with disconnect */
2697 if (!down_read_trylock(&w9968cf_disconnect))
2698 return -ERESTARTSYS;
2699
2700 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2701
2702 down(&cam->dev_sem);
2703
2704 if (cam->sensor == CC_UNKNOWN) {
2705 DBG(2, "No supported image sensor has been detected by the "
2706 "'ovcamchip' module for the %s (/dev/video%d). Make "
2707 "sure it is loaded *before* (re)connecting the camera.",
2708 symbolic(camlist, cam->id), cam->v4ldev->minor)
2709 up(&cam->dev_sem);
2710 up_read(&w9968cf_disconnect);
2711 return -ENODEV;
2712 }
2713
2714 if (cam->users) {
2715 DBG(2, "%s (/dev/video%d) has been already occupied by '%s'",
2716 symbolic(camlist, cam->id),cam->v4ldev->minor,cam->command)
2717 if ((filp->f_flags & O_NONBLOCK)||(filp->f_flags & O_NDELAY)) {
2718 up(&cam->dev_sem);
2719 up_read(&w9968cf_disconnect);
2720 return -EWOULDBLOCK;
2721 }
2722 up(&cam->dev_sem);
2723 err = wait_event_interruptible_exclusive(cam->open,
2724 cam->disconnected ||
2725 !cam->users);
2726 if (err) {
2727 up_read(&w9968cf_disconnect);
2728 return err;
2729 }
2730 if (cam->disconnected) {
2731 up_read(&w9968cf_disconnect);
2732 return -ENODEV;
2733 }
2734 down(&cam->dev_sem);
2735 }
2736
2737 DBG(5, "Opening '%s', /dev/video%d ...",
2738 symbolic(camlist, cam->id), cam->v4ldev->minor)
2739
2740 cam->streaming = 0;
2741 cam->misconfigured = 0;
2742
2743 if (!w9968cf_vpp)
2744 if ((err = w9968cf_vppmod_detect(cam)))
2745 goto out;
2746
2747 if ((err = w9968cf_allocate_memory(cam)))
2748 goto deallocate_memory;
2749
2750 if ((err = w9968cf_init_chip(cam)))
2751 goto deallocate_memory;
2752
2753 if ((err = w9968cf_start_transfer(cam)))
2754 goto deallocate_memory;
2755
2756 filp->private_data = cam;
2757
2758 cam->users++;
2759 strcpy(cam->command, current->comm);
2760
2761 init_waitqueue_head(&cam->wait_queue);
2762
2763 DBG(5, "Video device is open")
2764
2765 up(&cam->dev_sem);
2766 up_read(&w9968cf_disconnect);
2767
2768 return 0;
2769
2770 deallocate_memory:
2771 w9968cf_deallocate_memory(cam);
2772 out:
2773 DBG(2, "Failed to open the video device")
2774 up(&cam->dev_sem);
2775 up_read(&w9968cf_disconnect);
2776 return err;
2777 }
2778
2779
2780 static int w9968cf_release(struct inode* inode, struct file* filp)
2781 {
2782 struct w9968cf_device* cam;
2783
2784 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2785
2786 down(&cam->dev_sem); /* prevent disconnect() to be called */
2787
2788 w9968cf_stop_transfer(cam);
2789
2790 w9968cf_vppmod_release(cam);
2791
2792 if (cam->disconnected) {
2793 w9968cf_release_resources(cam);
2794 up(&cam->dev_sem);
2795 kfree(cam);
2796 return 0;
2797 }
2798
2799 cam->users--;
2800 w9968cf_deallocate_memory(cam);
2801 wake_up_interruptible_nr(&cam->open, 1);
2802
2803 DBG(5, "Video device closed")
2804 up(&cam->dev_sem);
2805 return 0;
2806 }
2807
2808
2809 static ssize_t
2810 w9968cf_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
2811 {
2812 struct w9968cf_device* cam;
2813 struct w9968cf_frame_t* fr;
2814 int err = 0;
2815
2816 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2817
2818 if (filp->f_flags & O_NONBLOCK)
2819 return -EWOULDBLOCK;
2820
2821 if (down_interruptible(&cam->fileop_sem))
2822 return -ERESTARTSYS;
2823
2824 if (cam->disconnected) {
2825 DBG(2, "Device not present")
2826 up(&cam->fileop_sem);
2827 return -ENODEV;
2828 }
2829
2830 if (cam->misconfigured) {
2831 DBG(2, "The camera is misconfigured. Close and open it again.")
2832 up(&cam->fileop_sem);
2833 return -EIO;
2834 }
2835
2836 if (!cam->frame[0].queued)
2837 w9968cf_push_frame(cam, 0);
2838
2839 if (!cam->frame[1].queued)
2840 w9968cf_push_frame(cam, 1);
2841
2842 err = wait_event_interruptible(cam->wait_queue,
2843 cam->frame[0].status == F_READY ||
2844 cam->frame[1].status == F_READY ||
2845 cam->disconnected);
2846 if (err) {
2847 up(&cam->fileop_sem);
2848 return err;
2849 }
2850 if (cam->disconnected) {
2851 up(&cam->fileop_sem);
2852 return -ENODEV;
2853 }
2854
2855 fr = (cam->frame[0].status == F_READY) ? &cam->frame[0]:&cam->frame[1];
2856
2857 if (w9968cf_vpp)
2858 w9968cf_postprocess_frame(cam, fr);
2859
2860 if (count > fr->length)
2861 count = fr->length;
2862
2863 if (copy_to_user(buf, fr->buffer, count)) {
2864 fr->status = F_UNUSED;
2865 up(&cam->fileop_sem);
2866 return -EFAULT;
2867 }
2868 *f_pos += count;
2869
2870 fr->status = F_UNUSED;
2871
2872 DBG(5, "%zu bytes read", count)
2873
2874 up(&cam->fileop_sem);
2875 return count;
2876 }
2877
2878
2879 static int w9968cf_mmap(struct file* filp, struct vm_area_struct *vma)
2880 {
2881 struct w9968cf_device* cam = (struct w9968cf_device*)
2882 video_get_drvdata(video_devdata(filp));
2883 unsigned long vsize = vma->vm_end - vma->vm_start,
2884 psize = cam->nbuffers * cam->frame[0].size,
2885 start = vma->vm_start,
2886 pos = (unsigned long)cam->frame[0].buffer,
2887 page;
2888
2889 if (cam->disconnected) {
2890 DBG(2, "Device not present")
2891 return -ENODEV;
2892 }
2893
2894 if (cam->misconfigured) {
2895 DBG(2, "The camera is misconfigured. Close and open it again")
2896 return -EIO;
2897 }
2898
2899 PDBGG("mmapping %lu bytes...", vsize)
2900
2901 if (vsize > psize - (vma->vm_pgoff << PAGE_SHIFT))
2902 return -EINVAL;
2903
2904 while (vsize > 0) {
2905 page = vmalloc_to_pfn((void *)pos);
2906 if (remap_pfn_range(vma, start, page + vma->vm_pgoff,
2907 PAGE_SIZE, vma->vm_page_prot))
2908 return -EAGAIN;
2909 start += PAGE_SIZE;
2910 pos += PAGE_SIZE;
2911 vsize -= PAGE_SIZE;
2912 }
2913
2914 DBG(5, "mmap method successfully called")
2915 return 0;
2916 }
2917
2918
2919 static int
2920 w9968cf_ioctl(struct inode* inode, struct file* filp,
2921 unsigned int cmd, unsigned long arg)
2922 {
2923 struct w9968cf_device* cam;
2924 int err;
2925
2926 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2927
2928 if (down_interruptible(&cam->fileop_sem))
2929 return -ERESTARTSYS;
2930
2931 if (cam->disconnected) {
2932 DBG(2, "Device not present")
2933 up(&cam->fileop_sem);
2934 return -ENODEV;
2935 }
2936
2937 if (cam->misconfigured) {
2938 DBG(2, "The camera is misconfigured. Close and open it again.")
2939 up(&cam->fileop_sem);
2940 return -EIO;
2941 }
2942
2943 err = w9968cf_v4l_ioctl(inode, filp, cmd, (void __user *)arg);
2944
2945 up(&cam->fileop_sem);
2946 return err;
2947 }
2948
2949
2950 static int w9968cf_v4l_ioctl(struct inode* inode, struct file* filp,
2951 unsigned int cmd, void __user * arg)
2952 {
2953 struct w9968cf_device* cam;
2954 const char* v4l1_ioctls[] = {
2955 "?", "CGAP", "GCHAN", "SCHAN", "GTUNER", "STUNER",
2956 "GPICT", "SPICT", "CCAPTURE", "GWIN", "SWIN", "GFBUF",
2957 "SFBUF", "KEY", "GFREQ", "SFREQ", "GAUDIO", "SAUDIO",
2958 "SYNC", "MCAPTURE", "GMBUF", "GUNIT", "GCAPTURE", "SCAPTURE",
2959 "SPLAYMODE", "SWRITEMODE", "GPLAYINFO", "SMICROCODE",
2960 "GVBIFMT", "SVBIFMT"
2961 };
2962
2963 #define V4L1_IOCTL(cmd) \
2964 ((_IOC_NR((cmd)) < sizeof(v4l1_ioctls)/sizeof(char*)) ? \
2965 v4l1_ioctls[_IOC_NR((cmd))] : "?")
2966
2967 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2968
2969 switch (cmd) {
2970
2971 case VIDIOCGCAP: /* get video capability */
2972 {
2973 struct video_capability cap = {
2974 .type = VID_TYPE_CAPTURE | VID_TYPE_SCALES,
2975 .channels = 1,
2976 .audios = 0,
2977 .minwidth = cam->minwidth,
2978 .minheight = cam->minheight,
2979 };
2980 sprintf(cap.name, "W996[87]CF USB Camera #%d",
2981 cam->v4ldev->minor);
2982 cap.maxwidth = (cam->upscaling && w9968cf_vpp)
2983 ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
2984 : cam->maxwidth;
2985 cap.maxheight = (cam->upscaling && w9968cf_vpp)
2986 ? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
2987 : cam->maxheight;
2988
2989 if (copy_to_user(arg, &cap, sizeof(cap)))
2990 return -EFAULT;
2991
2992 DBG(5, "VIDIOCGCAP successfully called")
2993 return 0;
2994 }
2995
2996 case VIDIOCGCHAN: /* get video channel informations */
2997 {
2998 struct video_channel chan;
2999 if (copy_from_user(&chan, arg, sizeof(chan)))
3000 return -EFAULT;
3001
3002 if (chan.channel != 0)
3003 return -EINVAL;
3004
3005 strcpy(chan.name, "Camera");
3006 chan.tuners = 0;
3007 chan.flags = 0;
3008 chan.type = VIDEO_TYPE_CAMERA;
3009 chan.norm = VIDEO_MODE_AUTO;
3010
3011 if (copy_to_user(arg, &chan, sizeof(chan)))
3012 return -EFAULT;
3013
3014 DBG(5, "VIDIOCGCHAN successfully called")
3015 return 0;
3016 }
3017
3018 case VIDIOCSCHAN: /* set active channel */
3019 {
3020 struct video_channel chan;
3021
3022 if (copy_from_user(&chan, arg, sizeof(chan)))
3023 return -EFAULT;
3024
3025 if (chan.channel != 0)
3026 return -EINVAL;
3027
3028 DBG(5, "VIDIOCSCHAN successfully called")
3029 return 0;
3030 }
3031
3032 case VIDIOCGPICT: /* get image properties of the picture */
3033 {
3034 if (w9968cf_sensor_get_picture(cam))
3035 return -EIO;
3036
3037 if (copy_to_user(arg, &cam->picture, sizeof(cam->picture)))
3038 return -EFAULT;
3039
3040 DBG(5, "VIDIOCGPICT successfully called")
3041 return 0;
3042 }
3043
3044 case VIDIOCSPICT: /* change picture settings */
3045 {
3046 struct video_picture pict;
3047 int err = 0;
3048
3049 if (copy_from_user(&pict, arg, sizeof(pict)))
3050 return -EFAULT;
3051
3052 if ( (cam->force_palette || !w9968cf_vpp)
3053 && pict.palette != cam->picture.palette ) {
3054 DBG(4, "Palette %s rejected: only %s is allowed",
3055 symbolic(v4l1_plist, pict.palette),
3056 symbolic(v4l1_plist, cam->picture.palette))
3057 return -EINVAL;
3058 }
3059
3060 if (!w9968cf_valid_palette(pict.palette)) {
3061 DBG(4, "Palette %s not supported. VIDIOCSPICT failed",
3062 symbolic(v4l1_plist, pict.palette))
3063 return -EINVAL;
3064 }
3065
3066 if (!cam->force_palette) {
3067 if (cam->decompression == 0) {
3068 if (w9968cf_need_decompression(pict.palette)) {
3069 DBG(4, "Decompression disabled: palette %s is not "
3070 "allowed. VIDIOCSPICT failed",
3071 symbolic(v4l1_plist, pict.palette))
3072 return -EINVAL;
3073 }
3074 } else if (cam->decompression == 1) {
3075 if (!w9968cf_need_decompression(pict.palette)) {
3076 DBG(4, "Decompression forced: palette %s is not "
3077 "allowed. VIDIOCSPICT failed",
3078 symbolic(v4l1_plist, pict.palette))
3079 return -EINVAL;
3080 }
3081 }
3082 }
3083
3084 if (pict.depth != w9968cf_valid_depth(pict.palette)) {
3085 DBG(4, "Requested depth %u bpp is not valid for %s "
3086 "palette: ignored and changed to %u bpp",
3087 pict.depth, symbolic(v4l1_plist, pict.palette),
3088 w9968cf_valid_depth(pict.palette))
3089 pict.depth = w9968cf_valid_depth(pict.palette);
3090 }
3091
3092 if (pict.palette != cam->picture.palette) {
3093 if(*cam->requested_frame
3094 || cam->frame_current->queued) {
3095 err = wait_event_interruptible
3096 ( cam->wait_queue,
3097 cam->disconnected ||
3098 (!*cam->requested_frame &&
3099 !cam->frame_current->queued) );
3100 if (err)
3101 return err;
3102 if (cam->disconnected)
3103 return -ENODEV;
3104 }
3105
3106 if (w9968cf_stop_transfer(cam))
3107 goto ioctl_fail;
3108
3109 if (w9968cf_set_picture(cam, pict))
3110 goto ioctl_fail;
3111
3112 if (w9968cf_start_transfer(cam))
3113 goto ioctl_fail;
3114
3115 } else if (w9968cf_sensor_update_picture(cam, pict))
3116 return -EIO;
3117
3118
3119 DBG(5, "VIDIOCSPICT successfully called")
3120 return 0;
3121 }
3122
3123 case VIDIOCSWIN: /* set capture area */
3124 {
3125 struct video_window win;
3126 int err = 0;
3127
3128 if (copy_from_user(&win, arg, sizeof(win)))
3129 return -EFAULT;
3130
3131 DBG(6, "VIDIOCSWIN called: clipcount=%d, flags=%u, "
3132 "x=%u, y=%u, %ux%u", win.clipcount, win.flags,
3133 win.x, win.y, win.width, win.height)
3134
3135 if (win.clipcount != 0 || win.flags != 0)
3136 return -EINVAL;
3137
3138 if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
3139 (u16*)&win.height))) {
3140 DBG(4, "Resolution not supported (%ux%u). "
3141 "VIDIOCSWIN failed", win.width, win.height)
3142 return err;
3143 }
3144
3145 if (win.x != cam->window.x ||
3146 win.y != cam->window.y ||
3147 win.width != cam->window.width ||
3148 win.height != cam->window.height) {
3149 if(*cam->requested_frame
3150 || cam->frame_current->queued) {
3151 err = wait_event_interruptible
3152 ( cam->wait_queue,
3153 cam->disconnected ||
3154 (!*cam->requested_frame &&
3155 !cam->frame_current->queued) );
3156 if (err)
3157 return err;
3158 if (cam->disconnected)
3159 return -ENODEV;
3160 }
3161
3162 if (w9968cf_stop_transfer(cam))
3163 goto ioctl_fail;
3164
3165 /* This _must_ be called before set_window() */
3166 if (w9968cf_set_picture(cam, cam->picture))
3167 goto ioctl_fail;
3168
3169 if (w9968cf_set_window(cam, win))
3170 goto ioctl_fail;
3171
3172 if (w9968cf_start_transfer(cam))
3173 goto ioctl_fail;
3174 }
3175
3176 DBG(5, "VIDIOCSWIN successfully called. ")
3177 return 0;
3178 }
3179
3180 case VIDIOCGWIN: /* get current window properties */
3181 {
3182 if (copy_to_user(arg,&cam->window,sizeof(struct video_window)))
3183 return -EFAULT;
3184
3185 DBG(5, "VIDIOCGWIN successfully called")
3186 return 0;
3187 }
3188
3189 case VIDIOCGMBUF: /* request for memory (mapped) buffer */
3190 {
3191 struct video_mbuf mbuf;
3192 u8 i;
3193
3194 mbuf.size = cam->nbuffers * cam->frame[0].size;
3195 mbuf.frames = cam->nbuffers;
3196 for (i = 0; i < cam->nbuffers; i++)
3197 mbuf.offsets[i] = (unsigned long)cam->frame[i].buffer -
3198 (unsigned long)cam->frame[0].buffer;
3199
3200 if (copy_to_user(arg, &mbuf, sizeof(mbuf)))
3201 return -EFAULT;
3202
3203 DBG(5, "VIDIOCGMBUF successfully called")
3204 return 0;
3205 }
3206
3207 case VIDIOCMCAPTURE: /* start the capture to a frame */
3208 {
3209 struct video_mmap mmap;
3210 struct w9968cf_frame_t* fr;
3211 int err = 0;
3212
3213 if (copy_from_user(&mmap, arg, sizeof(mmap)))
3214 return -EFAULT;
3215
3216 DBG(6, "VIDIOCMCAPTURE called: frame #%u, format=%s, %dx%d",
3217 mmap.frame, symbolic(v4l1_plist, mmap.format),
3218 mmap.width, mmap.height)
3219
3220 if (mmap.frame >= cam->nbuffers) {
3221 DBG(4, "Invalid frame number (%u). "
3222 "VIDIOCMCAPTURE failed", mmap.frame)
3223 return -EINVAL;
3224 }
3225
3226 if (mmap.format!=cam->picture.palette &&
3227 (cam->force_palette || !w9968cf_vpp)) {
3228 DBG(4, "Palette %s rejected: only %s is allowed",
3229 symbolic(v4l1_plist, mmap.format),
3230 symbolic(v4l1_plist, cam->picture.palette))
3231 return -EINVAL;
3232 }
3233
3234 if (!w9968cf_valid_palette(mmap.format)) {
3235 DBG(4, "Palette %s not supported. "
3236 "VIDIOCMCAPTURE failed",
3237 symbolic(v4l1_plist, mmap.format))
3238 return -EINVAL;
3239 }
3240
3241 if (!cam->force_palette) {
3242 if (cam->decompression == 0) {
3243 if (w9968cf_need_decompression(mmap.format)) {
3244 DBG(4, "Decompression disabled: palette %s is not "
3245 "allowed. VIDIOCSPICT failed",
3246 symbolic(v4l1_plist, mmap.format))
3247 return -EINVAL;
3248 }
3249 } else if (cam->decompression == 1) {
3250 if (!w9968cf_need_decompression(mmap.format)) {
3251 DBG(4, "Decompression forced: palette %s is not "
3252 "allowed. VIDIOCSPICT failed",
3253 symbolic(v4l1_plist, mmap.format))
3254 return -EINVAL;
3255 }
3256 }
3257 }
3258
3259 if ((err = w9968cf_adjust_window_size(cam, (u16*)&mmap.width,
3260 (u16*)&mmap.height))) {
3261 DBG(4, "Resolution not supported (%dx%d). "
3262 "VIDIOCMCAPTURE failed",
3263 mmap.width, mmap.height)
3264 return err;
3265 }
3266
3267 fr = &cam->frame[mmap.frame];
3268
3269 if (mmap.width != cam->window.width ||
3270 mmap.height != cam->window.height ||
3271 mmap.format != cam->picture.palette) {
3272
3273 struct video_window win;
3274 struct video_picture pict;
3275
3276 if(*cam->requested_frame
3277 || cam->frame_current->queued) {
3278 DBG(6, "VIDIOCMCAPTURE. Change settings for "
3279 "frame #%u: %dx%d, format %s. Wait...",
3280 mmap.frame, mmap.width, mmap.height,
3281 symbolic(v4l1_plist, mmap.format))
3282 err = wait_event_interruptible
3283 ( cam->wait_queue,
3284 cam->disconnected ||
3285 (!*cam->requested_frame &&
3286 !cam->frame_current->queued) );
3287 if (err)
3288 return err;
3289 if (cam->disconnected)
3290 return -ENODEV;
3291 }
3292
3293 memcpy(&win, &cam->window, sizeof(win));
3294 memcpy(&pict, &cam->picture, sizeof(pict));
3295 win.width = mmap.width;
3296 win.height = mmap.height;
3297 pict.palette = mmap.format;
3298
3299 if (w9968cf_stop_transfer(cam))
3300 goto ioctl_fail;
3301
3302 /* This before set_window */
3303 if (w9968cf_set_picture(cam, pict))
3304 goto ioctl_fail;
3305
3306 if (w9968cf_set_window(cam, win))
3307 goto ioctl_fail;
3308
3309 if (w9968cf_start_transfer(cam))
3310 goto ioctl_fail;
3311
3312 } else if (fr->queued) {
3313
3314 DBG(6, "Wait until frame #%u is free", mmap.frame)
3315
3316 err = wait_event_interruptible(cam->wait_queue,
3317 cam->disconnected ||
3318 (!fr->queued));
3319 if (err)
3320 return err;
3321 if (cam->disconnected)
3322 return -ENODEV;
3323 }
3324
3325 w9968cf_push_frame(cam, mmap.frame);
3326 DBG(5, "VIDIOCMCAPTURE(%u): successfully called", mmap.frame)
3327 return 0;
3328 }
3329
3330 case VIDIOCSYNC: /* wait until the capture of a frame is finished */
3331 {
3332 unsigned int f_num;
3333 struct w9968cf_frame_t* fr;
3334 int err = 0;
3335
3336 if (copy_from_user(&f_num, arg, sizeof(f_num)))
3337 return -EFAULT;
3338
3339 if (f_num >= cam->nbuffers) {
3340 DBG(4, "Invalid frame number (%u). "
3341 "VIDIOCMCAPTURE failed", f_num)
3342 return -EINVAL;
3343 }
3344
3345 DBG(6, "VIDIOCSYNC called for frame #%u", f_num)
3346
3347 fr = &cam->frame[f_num];
3348
3349 switch (fr->status) {
3350 case F_UNUSED:
3351 if (!fr->queued) {
3352 DBG(4, "VIDIOSYNC: Frame #%u not requested!",
3353 f_num)
3354 return -EFAULT;
3355 }
3356 case F_ERROR:
3357 case F_GRABBING:
3358 err = wait_event_interruptible(cam->wait_queue,
3359 (fr->status == F_READY)
3360 || cam->disconnected);
3361 if (err)
3362 return err;
3363 if (cam->disconnected)
3364 return -ENODEV;
3365 break;
3366 case F_READY:
3367 break;
3368 }
3369
3370 if (w9968cf_vpp)
3371 w9968cf_postprocess_frame(cam, fr);
3372
3373 fr->status = F_UNUSED;
3374
3375 DBG(5, "VIDIOCSYNC(%u) successfully called", f_num)
3376 return 0;
3377 }
3378
3379 case VIDIOCGUNIT:/* report the unit numbers of the associated devices*/
3380 {
3381 struct video_unit unit = {
3382 .video = cam->v4ldev->minor,
3383 .vbi = VIDEO_NO_UNIT,
3384 .radio = VIDEO_NO_UNIT,
3385 .audio = VIDEO_NO_UNIT,
3386 .teletext = VIDEO_NO_UNIT,
3387 };
3388
3389 if (copy_to_user(arg, &unit, sizeof(unit)))
3390 return -EFAULT;
3391
3392 DBG(5, "VIDIOCGUNIT successfully called")
3393 return 0;
3394 }
3395
3396 case VIDIOCKEY:
3397 return 0;
3398
3399 case VIDIOCGFBUF:
3400 {
3401 if (clear_user(arg, sizeof(struct video_buffer)))
3402 return -EFAULT;
3403
3404 DBG(5, "VIDIOCGFBUF successfully called")
3405 return 0;
3406 }
3407
3408 case VIDIOCGTUNER:
3409 {
3410 struct video_tuner tuner;
3411 if (copy_from_user(&tuner, arg, sizeof(tuner)))
3412 return -EFAULT;
3413
3414 if (tuner.tuner != 0)
3415 return -EINVAL;
3416
3417 strcpy(tuner.name, "no_tuner");
3418 tuner.rangelow = 0;
3419 tuner.rangehigh = 0;
3420 tuner.flags = VIDEO_TUNER_NORM;
3421 tuner.mode = VIDEO_MODE_AUTO;
3422 tuner.signal = 0xffff;
3423
3424 if (copy_to_user(arg, &tuner, sizeof(tuner)))
3425 return -EFAULT;
3426
3427 DBG(5, "VIDIOCGTUNER successfully called")
3428 return 0;
3429 }
3430
3431 case VIDIOCSTUNER:
3432 {
3433 struct video_tuner tuner;
3434 if (copy_from_user(&tuner, arg, sizeof(tuner)))
3435 return -EFAULT;
3436
3437 if (tuner.tuner != 0)
3438 return -EINVAL;
3439
3440 if (tuner.mode != VIDEO_MODE_AUTO)
3441 return -EINVAL;
3442
3443 DBG(5, "VIDIOCSTUNER successfully called")
3444 return 0;
3445 }
3446
3447 case VIDIOCSFBUF:
3448 case VIDIOCCAPTURE:
3449 case VIDIOCGFREQ:
3450 case VIDIOCSFREQ:
3451 case VIDIOCGAUDIO:
3452 case VIDIOCSAUDIO:
3453 case VIDIOCSPLAYMODE:
3454 case VIDIOCSWRITEMODE:
3455 case VIDIOCGPLAYINFO:
3456 case VIDIOCSMICROCODE:
3457 case VIDIOCGVBIFMT:
3458 case VIDIOCSVBIFMT:
3459 DBG(4, "Unsupported V4L1 IOCtl: VIDIOC%s "
3460 "(type 0x%01X, "
3461 "n. 0x%01X, "
3462 "dir. 0x%01X, "
3463 "size 0x%02X)",
3464 V4L1_IOCTL(cmd),
3465 _IOC_TYPE(cmd),_IOC_NR(cmd),_IOC_DIR(cmd),_IOC_SIZE(cmd))
3466
3467 return -EINVAL;
3468
3469 default:
3470 DBG(4, "Invalid V4L1 IOCtl: VIDIOC%s "
3471 "type 0x%01X, "
3472 "n. 0x%01X, "
3473 "dir. 0x%01X, "
3474 "size 0x%02X",
3475 V4L1_IOCTL(cmd),
3476 _IOC_TYPE(cmd),_IOC_NR(cmd),_IOC_DIR(cmd),_IOC_SIZE(cmd))
3477
3478 return -ENOIOCTLCMD;
3479
3480 } /* end of switch */
3481
3482 ioctl_fail:
3483 cam->misconfigured = 1;
3484 DBG(1, "VIDIOC%s failed because of hardware problems. "
3485 "To use the camera, close and open it again.", V4L1_IOCTL(cmd))
3486 return -EFAULT;
3487 }
3488
3489
3490 static struct file_operations w9968cf_fops = {
3491 .owner = THIS_MODULE,
3492 .open = w9968cf_open,
3493 .release = w9968cf_release,
3494 .read = w9968cf_read,
3495 .ioctl = w9968cf_ioctl,
3496 .mmap = w9968cf_mmap,
3497 .llseek = no_llseek,
3498 };
3499
3500
3501
3502 /****************************************************************************
3503 * USB probe and V4L registration, disconnect and id_table[] definition *
3504 ****************************************************************************/
3505
3506 static int
3507 w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
3508 {
3509 struct usb_device *udev = interface_to_usbdev(intf);
3510 struct w9968cf_device* cam;
3511 int err = 0;
3512 enum w9968cf_model_id mod_id;
3513 struct list_head* ptr;
3514 u8 sc = 0; /* number of simultaneous cameras */
3515 static unsigned short dev_nr = 0; /* we are handling device number n */
3516
3517 if (le16_to_cpu(udev->descriptor.idVendor) == winbond_id_table[0].idVendor &&
3518 le16_to_cpu(udev->descriptor.idProduct) == winbond_id_table[0].idProduct)
3519 mod_id = W9968CF_MOD_CLVBWGP; /* see camlist[] table */
3520 else if (le16_to_cpu(udev->descriptor.idVendor) == winbond_id_table[1].idVendor &&
3521 le16_to_cpu(udev->descriptor.idProduct) == winbond_id_table[1].idProduct)
3522 mod_id = W9968CF_MOD_GENERIC; /* see camlist[] table */
3523 else
3524 return -ENODEV;
3525
3526 cam = (struct w9968cf_device*)
3527 kmalloc(sizeof(struct w9968cf_device), GFP_KERNEL);
3528 if (!cam)
3529 return -ENOMEM;
3530
3531 memset(cam, 0, sizeof(*cam));
3532
3533 init_MUTEX(&cam->dev_sem);
3534 down(&cam->dev_sem);
3535
3536 cam->usbdev = udev;
3537 /* NOTE: a local copy is used to avoid possible race conditions */
3538 memcpy(&cam->dev, &udev->dev, sizeof(struct device));
3539
3540 DBG(2, "%s detected", symbolic(camlist, mod_id))
3541
3542 if (simcams > W9968CF_MAX_DEVICES)
3543 simcams = W9968CF_SIMCAMS;
3544
3545 /* How many cameras are connected ? */
3546 down(&w9968cf_devlist_sem);
3547 list_for_each(ptr, &w9968cf_dev_list)
3548 sc++;
3549 up(&w9968cf_devlist_sem);
3550
3551 if (sc >= simcams) {
3552 DBG(2, "Device rejected: too many connected cameras "
3553 "(max. %u)", simcams)
3554 err = -EPERM;
3555 goto fail;
3556 }
3557
3558
3559 /* Allocate 2 bytes of memory for camera control USB transfers */
3560 if (!(cam->control_buffer = (u16*)kmalloc(2, GFP_KERNEL))) {
3561 DBG(1,"Couldn't allocate memory for camera control transfers")
3562 err = -ENOMEM;
3563 goto fail;
3564 }
3565 memset(cam->control_buffer, 0, 2);
3566
3567 /* Allocate 8 bytes of memory for USB data transfers to the FSB */
3568 if (!(cam->data_buffer = (u16*)kmalloc(8, GFP_KERNEL))) {
3569 DBG(1, "Couldn't allocate memory for data "
3570 "transfers to the FSB")
3571 err = -ENOMEM;
3572 goto fail;
3573 }
3574 memset(cam->data_buffer, 0, 8);
3575
3576 /* Register the V4L device */
3577 cam->v4ldev = video_device_alloc();
3578 if (!cam->v4ldev) {
3579 DBG(1, "Could not allocate memory for a V4L structure")
3580 err = -ENOMEM;
3581 goto fail;
3582 }
3583
3584 strcpy(cam->v4ldev->name, symbolic(camlist, mod_id));
3585 cam->v4ldev->owner = THIS_MODULE;
3586 cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
3587 cam->v4ldev->hardware = VID_HARDWARE_W9968CF;
3588 cam->v4ldev->fops = &w9968cf_fops;
3589 cam->v4ldev->minor = video_nr[dev_nr];
3590 cam->v4ldev->release = video_device_release;
3591 video_set_drvdata(cam->v4ldev, cam);
3592 cam->v4ldev->dev = &cam->dev;
3593
3594 err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3595 video_nr[dev_nr]);
3596 if (err) {
3597 DBG(1, "V4L device registration failed")
3598 if (err == -ENFILE && video_nr[dev_nr] == -1)
3599 DBG(2, "Couldn't find a free /dev/videoX node")
3600 video_nr[dev_nr] = -1;
3601 dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
3602 goto fail;
3603 }
3604
3605 DBG(2, "V4L device registered as /dev/video%d", cam->v4ldev->minor)
3606
3607 /* Set some basic constants */
3608 w9968cf_configure_camera(cam, udev, mod_id, dev_nr);
3609
3610 /* Add a new entry into the list of V4L registered devices */
3611 down(&w9968cf_devlist_sem);
3612 list_add(&cam->v4llist, &w9968cf_dev_list);
3613 up(&w9968cf_devlist_sem);
3614 dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
3615
3616 w9968cf_turn_on_led(cam);
3617
3618 w9968cf_i2c_init(cam);
3619
3620 usb_set_intfdata(intf, cam);
3621 up(&cam->dev_sem);
3622 return 0;
3623
3624 fail: /* Free unused memory */
3625 kfree(cam->control_buffer);
3626 kfree(cam->data_buffer);
3627 if (cam->v4ldev)
3628 video_device_release(cam->v4ldev);
3629 up(&cam->dev_sem);
3630 kfree(cam);
3631 return err;
3632 }
3633
3634
3635 static void w9968cf_usb_disconnect(struct usb_interface* intf)
3636 {
3637 struct w9968cf_device* cam =
3638 (struct w9968cf_device*)usb_get_intfdata(intf);
3639
3640 down_write(&w9968cf_disconnect);
3641
3642 if (cam) {
3643 /* Prevent concurrent accesses to data */
3644 down(&cam->dev_sem);
3645
3646 cam->disconnected = 1;
3647
3648 DBG(2, "Disconnecting %s...", symbolic(camlist, cam->id))
3649
3650 wake_up_interruptible_all(&cam->open);
3651
3652 if (cam->users) {
3653 DBG(2, "The device is open (/dev/video%d)! "
3654 "Process name: %s. Deregistration and memory "
3655 "deallocation are deferred on close.",
3656 cam->v4ldev->minor, cam->command)
3657 cam->misconfigured = 1;
3658 w9968cf_stop_transfer(cam);
3659 wake_up_interruptible(&cam->wait_queue);
3660 } else
3661 w9968cf_release_resources(cam);
3662
3663 up(&cam->dev_sem);
3664
3665 if (!cam->users)
3666 kfree(cam);
3667 }
3668
3669 up_write(&w9968cf_disconnect);
3670 }
3671
3672
3673 static struct usb_driver w9968cf_usb_driver = {
3674 .owner = THIS_MODULE,
3675 .name = "w9968cf",
3676 .id_table = winbond_id_table,
3677 .probe = w9968cf_usb_probe,
3678 .disconnect = w9968cf_usb_disconnect,
3679 };
3680
3681
3682
3683 /****************************************************************************
3684 * Module init, exit and intermodule communication *
3685 ****************************************************************************/
3686
3687 static int w9968cf_vppmod_detect(struct w9968cf_device* cam)
3688 {
3689 if (!w9968cf_vpp)
3690 if (vppmod_load)
3691 request_module("w9968cf-vpp");
3692
3693 down(&w9968cf_vppmod_lock);
3694
3695 if (!w9968cf_vpp) {
3696 DBG(4, "Video post-processing module not detected")
3697 w9968cf_adjust_configuration(cam);
3698 goto out;
3699 }
3700
3701 if (!try_module_get(w9968cf_vpp->owner)) {
3702 DBG(1, "Couldn't increment the reference count of "
3703 "the video post-processing module")
3704 up(&w9968cf_vppmod_lock);
3705 return -ENOSYS;
3706 }
3707
3708 w9968cf_vpp->busy++;
3709
3710 DBG(5, "Video post-processing module detected")
3711
3712 out:
3713 up(&w9968cf_vppmod_lock);
3714 return 0;
3715 }
3716
3717
3718 static void w9968cf_vppmod_release(struct w9968cf_device* cam)
3719 {
3720 down(&w9968cf_vppmod_lock);
3721
3722 if (w9968cf_vpp && w9968cf_vpp->busy) {
3723 module_put(w9968cf_vpp->owner);
3724 w9968cf_vpp->busy--;
3725 wake_up(&w9968cf_vppmod_wait);
3726 DBG(5, "Video post-processing module released")
3727 }
3728
3729 up(&w9968cf_vppmod_lock);
3730 }
3731
3732
3733 int w9968cf_vppmod_register(struct w9968cf_vpp_t* vpp)
3734 {
3735 down(&w9968cf_vppmod_lock);
3736
3737 if (w9968cf_vpp) {
3738 KDBG(1, "Video post-processing module already registered")
3739 up(&w9968cf_vppmod_lock);
3740 return -EINVAL;
3741 }
3742
3743 w9968cf_vpp = vpp;
3744 w9968cf_vpp->busy = 0;
3745
3746 KDBG(2, "Video post-processing module registered")
3747 up(&w9968cf_vppmod_lock);
3748 return 0;
3749 }
3750
3751
3752 int w9968cf_vppmod_deregister(struct w9968cf_vpp_t* vpp)
3753 {
3754 down(&w9968cf_vppmod_lock);
3755
3756 if (!w9968cf_vpp) {
3757 up(&w9968cf_vppmod_lock);
3758 return -EINVAL;
3759 }
3760
3761 if (w9968cf_vpp != vpp) {
3762 KDBG(1, "Only the owner can unregister the video "
3763 "post-processing module")
3764 up(&w9968cf_vppmod_lock);
3765 return -EINVAL;
3766 }
3767
3768 if (w9968cf_vpp->busy) {
3769 KDBG(2, "Video post-processing module busy. Wait for it to be "
3770 "released...")
3771 up(&w9968cf_vppmod_lock);
3772 wait_event(w9968cf_vppmod_wait, !w9968cf_vpp->busy);
3773 w9968cf_vpp = NULL;
3774 goto out;
3775 }
3776
3777 w9968cf_vpp = NULL;
3778
3779 up(&w9968cf_vppmod_lock);
3780
3781 out:
3782 KDBG(2, "Video post-processing module unregistered")
3783 return 0;
3784 }
3785
3786
3787 static int __init w9968cf_module_init(void)
3788 {
3789 int err;
3790
3791 KDBG(2, W9968CF_MODULE_NAME" "W9968CF_MODULE_VERSION)
3792 KDBG(3, W9968CF_MODULE_AUTHOR)
3793
3794 if (ovmod_load)
3795 request_module("ovcamchip");
3796
3797 if ((err = usb_register(&w9968cf_usb_driver)))
3798 return err;
3799
3800 return 0;
3801 }
3802
3803
3804 static void __exit w9968cf_module_exit(void)
3805 {
3806 /* w9968cf_usb_disconnect() will be called */
3807 usb_deregister(&w9968cf_usb_driver);
3808
3809 KDBG(2, W9968CF_MODULE_NAME" deregistered")
3810 }
3811
3812
3813 module_init(w9968cf_module_init);
3814 module_exit(w9968cf_module_exit);
3815
3816
3817 EXPORT_SYMBOL(w9968cf_vppmod_register);
3818 EXPORT_SYMBOL(w9968cf_vppmod_deregister);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree