?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[XFRM]: skb_cow_data() does not set proper owner for new skbs.
[linux-2.6/verdex.git] / drivers / usb / media / w9968cf.c
blobca9f3a30634fef6eb3f9fb2aed8d319b33aa660b
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 .name = "W996[87]CF algorithm",
1577 .id = I2C_ALGO_SMBUS,
1578 .smbus_xfer = w9968cf_i2c_smbus_xfer,
1579 .algo_control = w9968cf_i2c_control,
1580 .functionality = w9968cf_i2c_func,
1581 };
1582
1583 static struct i2c_adapter adap = {
1584 .id = I2C_ALGO_SMBUS | I2C_HW_SMBUS_W9968CF,
1585 .class = I2C_CLASS_CAM_DIGITAL,
1586 .owner = THIS_MODULE,
1587 .client_register = w9968cf_i2c_attach_inform,
1588 .client_unregister = w9968cf_i2c_detach_inform,
1589 .algo = &algo,
1590 };
1591
1592 memcpy(&cam->i2c_adapter, &adap, sizeof(struct i2c_adapter));
1593 strcpy(cam->i2c_adapter.name, "w9968cf");
1594 i2c_set_adapdata(&cam->i2c_adapter, cam);
1595
1596 DBG(6, "Registering I2C adapter with kernel...")
1597
1598 err = i2c_add_adapter(&cam->i2c_adapter);
1599 if (err)
1600 DBG(1, "Failed to register the I2C adapter")
1601 else
1602 DBG(5, "I2C adapter registered")
1603
1604 return err;
1605 }
1606
1607
1608
1609 /****************************************************************************
1610 * Helper functions *
1611 ****************************************************************************/
1612
1613 /*--------------------------------------------------------------------------
1614 Turn on the LED on some webcams. A beep should be heard too.
1615 Return 0 on success, a negative number otherwise.
1616 --------------------------------------------------------------------------*/
1617 static int w9968cf_turn_on_led(struct w9968cf_device* cam)
1618 {
1619 int err = 0;
1620
1621 err += w9968cf_write_reg(cam, 0xff00, 0x00); /* power-down */
1622 err += w9968cf_write_reg(cam, 0xbf17, 0x00); /* reset everything */
1623 err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* normal operation */
1624 err += w9968cf_write_reg(cam, 0x0010, 0x01); /* serial bus, SDS high */
1625 err += w9968cf_write_reg(cam, 0x0000, 0x01); /* serial bus, SDS low */
1626 err += w9968cf_write_reg(cam, 0x0010, 0x01); /* ..high 'beep-beep' */
1627
1628 if (err)
1629 DBG(2, "Couldn't turn on the LED")
1630
1631 DBG(5, "LED turned on")
1632
1633 return err;
1634 }
1635
1636
1637 /*--------------------------------------------------------------------------
1638 Write some registers for the device initialization.
1639 This function is called once on open().
1640 Return 0 on success, a negative number otherwise.
1641 --------------------------------------------------------------------------*/
1642 static int w9968cf_init_chip(struct w9968cf_device* cam)
1643 {
1644 unsigned long hw_bufsize = cam->maxwidth*cam->maxheight*2,
1645 y0 = 0x0000,
1646 u0 = y0 + hw_bufsize/2,
1647 v0 = u0 + hw_bufsize/4,
1648 y1 = v0 + hw_bufsize/4,
1649 u1 = y1 + hw_bufsize/2,
1650 v1 = u1 + hw_bufsize/4;
1651 int err = 0;
1652
1653 err += w9968cf_write_reg(cam, 0xff00, 0x00); /* power off */
1654 err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* power on */
1655
1656 err += w9968cf_write_reg(cam, 0x405d, 0x03); /* DRAM timings */
1657 err += w9968cf_write_reg(cam, 0x0030, 0x04); /* SDRAM timings */
1658
1659 err += w9968cf_write_reg(cam, y0 & 0xffff, 0x20); /* Y buf.0, low */
1660 err += w9968cf_write_reg(cam, y0 >> 16, 0x21); /* Y buf.0, high */
1661 err += w9968cf_write_reg(cam, u0 & 0xffff, 0x24); /* U buf.0, low */
1662 err += w9968cf_write_reg(cam, u0 >> 16, 0x25); /* U buf.0, high */
1663 err += w9968cf_write_reg(cam, v0 & 0xffff, 0x28); /* V buf.0, low */
1664 err += w9968cf_write_reg(cam, v0 >> 16, 0x29); /* V buf.0, high */
1665
1666 err += w9968cf_write_reg(cam, y1 & 0xffff, 0x22); /* Y buf.1, low */
1667 err += w9968cf_write_reg(cam, y1 >> 16, 0x23); /* Y buf.1, high */
1668 err += w9968cf_write_reg(cam, u1 & 0xffff, 0x26); /* U buf.1, low */
1669 err += w9968cf_write_reg(cam, u1 >> 16, 0x27); /* U buf.1, high */
1670 err += w9968cf_write_reg(cam, v1 & 0xffff, 0x2a); /* V buf.1, low */
1671 err += w9968cf_write_reg(cam, v1 >> 16, 0x2b); /* V buf.1, high */
1672
1673 err += w9968cf_write_reg(cam, y1 & 0xffff, 0x32); /* JPEG buf 0 low */
1674 err += w9968cf_write_reg(cam, y1 >> 16, 0x33); /* JPEG buf 0 high */
1675
1676 err += w9968cf_write_reg(cam, y1 & 0xffff, 0x34); /* JPEG buf 1 low */
1677 err += w9968cf_write_reg(cam, y1 >> 16, 0x35); /* JPEG bug 1 high */
1678
1679 err += w9968cf_write_reg(cam, 0x0000, 0x36);/* JPEG restart interval */
1680 err += w9968cf_write_reg(cam, 0x0804, 0x37);/*JPEG VLE FIFO threshold*/
1681 err += w9968cf_write_reg(cam, 0x0000, 0x38);/* disable hw up-scaling */
1682 err += w9968cf_write_reg(cam, 0x0000, 0x3f); /* JPEG/MCTL test data */
1683
1684 err += w9968cf_set_picture(cam, cam->picture); /* this before */
1685 err += w9968cf_set_window(cam, cam->window);
1686
1687 if (err)
1688 DBG(1, "Chip initialization failed")
1689 else
1690 DBG(5, "Chip successfully initialized")
1691
1692 return err;
1693 }
1694
1695
1696 /*--------------------------------------------------------------------------
1697 Return non-zero if the palette is supported, 0 otherwise.
1698 --------------------------------------------------------------------------*/
1699 static inline u16 w9968cf_valid_palette(u16 palette)
1700 {
1701 u8 i = 0;
1702 while (w9968cf_formatlist[i].palette != 0) {
1703 if (palette == w9968cf_formatlist[i].palette)
1704 return palette;
1705 i++;
1706 }
1707 return 0;
1708 }
1709
1710
1711 /*--------------------------------------------------------------------------
1712 Return the depth corresponding to the given palette.
1713 Palette _must_ be supported !
1714 --------------------------------------------------------------------------*/
1715 static inline u16 w9968cf_valid_depth(u16 palette)
1716 {
1717 u8 i=0;
1718 while (w9968cf_formatlist[i].palette != palette)
1719 i++;
1720
1721 return w9968cf_formatlist[i].depth;
1722 }
1723
1724
1725 /*--------------------------------------------------------------------------
1726 Return non-zero if the format requires decompression, 0 otherwise.
1727 --------------------------------------------------------------------------*/
1728 static inline u8 w9968cf_need_decompression(u16 palette)
1729 {
1730 u8 i = 0;
1731 while (w9968cf_formatlist[i].palette != 0) {
1732 if (palette == w9968cf_formatlist[i].palette)
1733 return w9968cf_formatlist[i].compression;
1734 i++;
1735 }
1736 return 0;
1737 }
1738
1739
1740 /*--------------------------------------------------------------------------
1741 Change the picture settings of the camera.
1742 Return 0 on success, a negative number otherwise.
1743 --------------------------------------------------------------------------*/
1744 static int
1745 w9968cf_set_picture(struct w9968cf_device* cam, struct video_picture pict)
1746 {
1747 u16 fmt, hw_depth, hw_palette, reg_v = 0x0000;
1748 int err = 0;
1749
1750 /* Make sure we are using a valid depth */
1751 pict.depth = w9968cf_valid_depth(pict.palette);
1752
1753 fmt = pict.palette;
1754
1755 hw_depth = pict.depth; /* depth used by the winbond chip */
1756 hw_palette = pict.palette; /* palette used by the winbond chip */
1757
1758 /* VS & HS polarities */
1759 reg_v = (cam->vs_polarity << 12) | (cam->hs_polarity << 11);
1760
1761 switch (fmt)
1762 {
1763 case VIDEO_PALETTE_UYVY:
1764 reg_v |= 0x0000;
1765 cam->vpp_flag = VPP_NONE;
1766 break;
1767 case VIDEO_PALETTE_YUV422P:
1768 reg_v |= 0x0002;
1769 cam->vpp_flag = VPP_DECOMPRESSION;
1770 break;
1771 case VIDEO_PALETTE_YUV420:
1772 case VIDEO_PALETTE_YUV420P:
1773 reg_v |= 0x0003;
1774 cam->vpp_flag = VPP_DECOMPRESSION;
1775 break;
1776 case VIDEO_PALETTE_YUYV:
1777 case VIDEO_PALETTE_YUV422:
1778 reg_v |= 0x0000;
1779 cam->vpp_flag = VPP_SWAP_YUV_BYTES;
1780 hw_palette = VIDEO_PALETTE_UYVY;
1781 break;
1782 /* Original video is used instead of RGBX palettes.
1783 Software conversion later. */
1784 case VIDEO_PALETTE_GREY:
1785 case VIDEO_PALETTE_RGB555:
1786 case VIDEO_PALETTE_RGB565:
1787 case VIDEO_PALETTE_RGB24:
1788 case VIDEO_PALETTE_RGB32:
1789 reg_v |= 0x0000; /* UYVY 16 bit is used */
1790 hw_depth = 16;
1791 hw_palette = VIDEO_PALETTE_UYVY;
1792 cam->vpp_flag = VPP_UYVY_TO_RGBX;
1793 break;
1794 }
1795
1796 /* NOTE: due to memory issues, it is better to disable the hardware
1797 double buffering during compression */
1798 if (cam->double_buffer && !(cam->vpp_flag & VPP_DECOMPRESSION))
1799 reg_v |= 0x0080;
1800
1801 if (cam->clamping)
1802 reg_v |= 0x0020;
1803
1804 if (cam->filter_type == 1)
1805 reg_v |= 0x0008;
1806 else if (cam->filter_type == 2)
1807 reg_v |= 0x000c;
1808
1809 if ((err = w9968cf_write_reg(cam, reg_v, 0x16)))
1810 goto error;
1811
1812 if ((err = w9968cf_sensor_update_picture(cam, pict)))
1813 goto error;
1814
1815 /* If all went well, update the device data structure */
1816 memcpy(&cam->picture, &pict, sizeof(pict));
1817 cam->hw_depth = hw_depth;
1818 cam->hw_palette = hw_palette;
1819
1820 /* Settings changed, so we clear the frame buffers */
1821 memset(cam->frame[0].buffer, 0, cam->nbuffers*cam->frame[0].size);
1822
1823 DBG(4, "Palette is %s, depth is %u bpp",
1824 symbolic(v4l1_plist, pict.palette), pict.depth)
1825
1826 return 0;
1827
1828 error:
1829 DBG(1, "Failed to change picture settings")
1830 return err;
1831 }
1832
1833
1834 /*--------------------------------------------------------------------------
1835 Change the capture area size of the camera.
1836 This function _must_ be called _after_ w9968cf_set_picture().
1837 Return 0 on success, a negative number otherwise.
1838 --------------------------------------------------------------------------*/
1839 static int
1840 w9968cf_set_window(struct w9968cf_device* cam, struct video_window win)
1841 {
1842 u16 x, y, w, h, scx, scy, cw, ch, ax, ay;
1843 unsigned long fw, fh;
1844 struct ovcamchip_window s_win;
1845 int err = 0;
1846
1847 /* Work around to avoid FP arithmetics */
1848 #define __SC(x) ((x) << 10)
1849 #define __UNSC(x) ((x) >> 10)
1850
1851 /* Make sure we are using a supported resolution */
1852 if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
1853 (u16*)&win.height)))
1854 goto error;
1855
1856 /* Scaling factors */
1857 fw = __SC(win.width) / cam->maxwidth;
1858 fh = __SC(win.height) / cam->maxheight;
1859
1860 /* Set up the width and height values used by the chip */
1861 if ((win.width > cam->maxwidth) || (win.height > cam->maxheight)) {
1862 cam->vpp_flag |= VPP_UPSCALE;
1863 /* Calculate largest w,h mantaining the same w/h ratio */
1864 w = (fw >= fh) ? cam->maxwidth : __SC(win.width)/fh;
1865 h = (fw >= fh) ? __SC(win.height)/fw : cam->maxheight;
1866 if (w < cam->minwidth) /* just in case */
1867 w = cam->minwidth;
1868 if (h < cam->minheight) /* just in case */
1869 h = cam->minheight;
1870 } else {
1871 cam->vpp_flag &= ~VPP_UPSCALE;
1872 w = win.width;
1873 h = win.height;
1874 }
1875
1876 /* x,y offsets of the cropped area */
1877 scx = cam->start_cropx;
1878 scy = cam->start_cropy;
1879
1880 /* Calculate cropped area manteining the right w/h ratio */
1881 if (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE)) {
1882 cw = (fw >= fh) ? cam->maxwidth : __SC(win.width)/fh;
1883 ch = (fw >= fh) ? __SC(win.height)/fw : cam->maxheight;
1884 } else {
1885 cw = w;
1886 ch = h;
1887 }
1888
1889 /* Setup the window of the sensor */
1890 s_win.format = VIDEO_PALETTE_UYVY;
1891 s_win.width = cam->maxwidth;
1892 s_win.height = cam->maxheight;
1893 s_win.quarter = 0; /* full progressive video */
1894
1895 /* Center it */
1896 s_win.x = (s_win.width - cw) / 2;
1897 s_win.y = (s_win.height - ch) / 2;
1898
1899 /* Clock divisor */
1900 if (cam->clockdiv >= 0)
1901 s_win.clockdiv = cam->clockdiv; /* manual override */
1902 else
1903 switch (cam->sensor) {
1904 case CC_OV6620:
1905 s_win.clockdiv = 0;
1906 break;
1907 case CC_OV6630:
1908 s_win.clockdiv = 0;
1909 break;
1910 case CC_OV76BE:
1911 case CC_OV7610:
1912 case CC_OV7620:
1913 s_win.clockdiv = 0;
1914 break;
1915 default:
1916 s_win.clockdiv = W9968CF_DEF_CLOCKDIVISOR;
1917 }
1918
1919 /* We have to scale win.x and win.y offsets */
1920 if ( (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE))
1921 || (cam->vpp_flag & VPP_UPSCALE) ) {
1922 ax = __SC(win.x)/fw;
1923 ay = __SC(win.y)/fh;
1924 } else {
1925 ax = win.x;
1926 ay = win.y;
1927 }
1928
1929 if ((ax + cw) > cam->maxwidth)
1930 ax = cam->maxwidth - cw;
1931
1932 if ((ay + ch) > cam->maxheight)
1933 ay = cam->maxheight - ch;
1934
1935 /* Adjust win.x, win.y */
1936 if ( (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE))
1937 || (cam->vpp_flag & VPP_UPSCALE) ) {
1938 win.x = __UNSC(ax*fw);
1939 win.y = __UNSC(ay*fh);
1940 } else {
1941 win.x = ax;
1942 win.y = ay;
1943 }
1944
1945 /* Offsets used by the chip */
1946 x = ax + s_win.x;
1947 y = ay + s_win.y;
1948
1949 /* Go ! */
1950 if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_S_MODE, &s_win)))
1951 goto error;
1952
1953 err += w9968cf_write_reg(cam, scx + x, 0x10);
1954 err += w9968cf_write_reg(cam, scy + y, 0x11);
1955 err += w9968cf_write_reg(cam, scx + x + cw, 0x12);
1956 err += w9968cf_write_reg(cam, scy + y + ch, 0x13);
1957 err += w9968cf_write_reg(cam, w, 0x14);
1958 err += w9968cf_write_reg(cam, h, 0x15);
1959
1960 /* JPEG width & height */
1961 err += w9968cf_write_reg(cam, w, 0x30);
1962 err += w9968cf_write_reg(cam, h, 0x31);
1963
1964 /* Y & UV frame buffer strides (in WORD) */
1965 if (cam->vpp_flag & VPP_DECOMPRESSION) {
1966 err += w9968cf_write_reg(cam, w/2, 0x2c);
1967 err += w9968cf_write_reg(cam, w/4, 0x2d);
1968 } else
1969 err += w9968cf_write_reg(cam, w, 0x2c);
1970
1971 if (err)
1972 goto error;
1973
1974 /* If all went well, update the device data structure */
1975 memcpy(&cam->window, &win, sizeof(win));
1976 cam->hw_width = w;
1977 cam->hw_height = h;
1978
1979 /* Settings changed, so we clear the frame buffers */
1980 memset(cam->frame[0].buffer, 0, cam->nbuffers*cam->frame[0].size);
1981
1982 DBG(4, "The capture area is %dx%d, Offset (x,y)=(%u,%u)",
1983 win.width, win.height, win.x, win.y)
1984
1985 PDBGG("x=%u ,y=%u, w=%u, h=%u, ax=%u, ay=%u, s_win.x=%u, s_win.y=%u, "
1986 "cw=%u, ch=%u, win.x=%u, win.y=%u, win.width=%u, win.height=%u",
1987 x, y, w, h, ax, ay, s_win.x, s_win.y, cw, ch, win.x, win.y,
1988 win.width, win.height)
1989
1990 return 0;
1991
1992 error:
1993 DBG(1, "Failed to change the capture area size")
1994 return err;
1995 }
1996
1997
1998 /*--------------------------------------------------------------------------
1999 Adjust the asked values for window width and height.
2000 Return 0 on success, -1 otherwise.
2001 --------------------------------------------------------------------------*/
2002 static int
2003 w9968cf_adjust_window_size(struct w9968cf_device* cam, u16* width, u16* height)
2004 {
2005 u16 maxw, maxh;
2006
2007 if ((*width < cam->minwidth) || (*height < cam->minheight))
2008 return -ERANGE;
2009
2010 maxw = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
2011 w9968cf_vpp ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
2012 : cam->maxwidth;
2013 maxh = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
2014 w9968cf_vpp ? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
2015 : cam->maxheight;
2016
2017 if (*width > maxw)
2018 *width = maxw;
2019 if (*height > maxh)
2020 *height = maxh;
2021
2022 if (cam->vpp_flag & VPP_DECOMPRESSION) {
2023 *width &= ~15L; /* multiple of 16 */
2024 *height &= ~15L;
2025 }
2026
2027 PDBGG("Window size adjusted w=%u, h=%u ", *width, *height)
2028
2029 return 0;
2030 }
2031
2032
2033 /*--------------------------------------------------------------------------
2034 Initialize the FIFO list of requested frames.
2035 --------------------------------------------------------------------------*/
2036 static void w9968cf_init_framelist(struct w9968cf_device* cam)
2037 {
2038 u8 i;
2039
2040 for (i = 0; i < cam->nbuffers; i++) {
2041 cam->requested_frame[i] = NULL;
2042 cam->frame[i].queued = 0;
2043 cam->frame[i].status = F_UNUSED;
2044 }
2045 }
2046
2047
2048 /*--------------------------------------------------------------------------
2049 Add a frame in the FIFO list of requested frames.
2050 This function is called in process context.
2051 --------------------------------------------------------------------------*/
2052 static void w9968cf_push_frame(struct w9968cf_device* cam, u8 f_num)
2053 {
2054 u8 f;
2055 unsigned long lock_flags;
2056
2057 spin_lock_irqsave(&cam->flist_lock, lock_flags);
2058
2059 for (f=0; cam->requested_frame[f] != NULL; f++);
2060 cam->requested_frame[f] = &cam->frame[f_num];
2061 cam->frame[f_num].queued = 1;
2062 cam->frame[f_num].status = F_UNUSED; /* clear the status */
2063
2064 spin_unlock_irqrestore(&cam->flist_lock, lock_flags);
2065
2066 DBG(6, "Frame #%u pushed into the FIFO list. Position %u", f_num, f)
2067 }
2068
2069
2070 /*--------------------------------------------------------------------------
2071 Read, store and remove the first pointer in the FIFO list of requested
2072 frames. This function is called in interrupt context.
2073 --------------------------------------------------------------------------*/
2074 static void
2075 w9968cf_pop_frame(struct w9968cf_device* cam, struct w9968cf_frame_t** framep)
2076 {
2077 u8 i;
2078
2079 spin_lock(&cam->flist_lock);
2080
2081 *framep = cam->requested_frame[0];
2082
2083 /* Shift the list of pointers */
2084 for (i = 0; i < cam->nbuffers-1; i++)
2085 cam->requested_frame[i] = cam->requested_frame[i+1];
2086 cam->requested_frame[i] = NULL;
2087
2088 spin_unlock(&cam->flist_lock);
2089
2090 DBG(6,"Popped frame #%d from the list", (*framep)->number)
2091 }
2092
2093
2094 /*--------------------------------------------------------------------------
2095 High-level video post-processing routine on grabbed frames.
2096 Return 0 on success, a negative number otherwise.
2097 --------------------------------------------------------------------------*/
2098 static int
2099 w9968cf_postprocess_frame(struct w9968cf_device* cam,
2100 struct w9968cf_frame_t* fr)
2101 {
2102 void *pIn = fr->buffer, *pOut = cam->frame_vpp.buffer, *tmp;
2103 u16 w = cam->window.width,
2104 h = cam->window.height,
2105 d = cam->picture.depth,
2106 fmt = cam->picture.palette,
2107 rgb = cam->force_rgb,
2108 hw_w = cam->hw_width,
2109 hw_h = cam->hw_height,
2110 hw_d = cam->hw_depth;
2111 int err = 0;
2112
2113 #define _PSWAP(pIn, pOut) {tmp = (pIn); (pIn) = (pOut); (pOut) = tmp;}
2114
2115 if (cam->vpp_flag & VPP_DECOMPRESSION) {
2116 memcpy(pOut, pIn, fr->length);
2117 _PSWAP(pIn, pOut)
2118 err = w9968cf_vpp->decode(pIn, fr->length, hw_w, hw_h, pOut);
2119 PDBGG("Compressed frame length: %lu",(unsigned long)fr->length)
2120 fr->length = (hw_w*hw_h*hw_d)/8;
2121 _PSWAP(pIn, pOut)
2122 if (err) {
2123 DBG(4, "An error occurred while decoding the frame: "
2124 "%s", symbolic(decoder_errlist, err))
2125 return err;
2126 } else
2127 DBG(6, "Frame decoded")
2128 }
2129
2130 if (cam->vpp_flag & VPP_SWAP_YUV_BYTES) {
2131 w9968cf_vpp->swap_yuvbytes(pIn, fr->length);
2132 DBG(6, "Original UYVY component ordering changed")
2133 }
2134
2135 if (cam->vpp_flag & VPP_UPSCALE) {
2136 w9968cf_vpp->scale_up(pIn, pOut, hw_w, hw_h, hw_d, w, h);
2137 fr->length = (w*h*hw_d)/8;
2138 _PSWAP(pIn, pOut)
2139 DBG(6, "Vertical up-scaling done: %u,%u,%ubpp->%u,%u",
2140 hw_w, hw_h, hw_d, w, h)
2141 }
2142
2143 if (cam->vpp_flag & VPP_UYVY_TO_RGBX) {
2144 w9968cf_vpp->uyvy_to_rgbx(pIn, fr->length, pOut, fmt, rgb);
2145 fr->length = (w*h*d)/8;
2146 _PSWAP(pIn, pOut)
2147 DBG(6, "UYVY-16bit to %s conversion done",
2148 symbolic(v4l1_plist, fmt))
2149 }
2150
2151 if (pOut == fr->buffer)
2152 memcpy(fr->buffer, cam->frame_vpp.buffer, fr->length);
2153
2154 return 0;
2155 }
2156
2157
2158
2159 /****************************************************************************
2160 * Image sensor control routines *
2161 ****************************************************************************/
2162
2163 static int
2164 w9968cf_sensor_set_control(struct w9968cf_device* cam, int cid, int val)
2165 {
2166 struct ovcamchip_control ctl;
2167 int err;
2168
2169 ctl.id = cid;
2170 ctl.value = val;
2171
2172 err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_S_CTRL, &ctl);
2173
2174 return err;
2175 }
2176
2177
2178 static int
2179 w9968cf_sensor_get_control(struct w9968cf_device* cam, int cid, int* val)
2180 {
2181 struct ovcamchip_control ctl;
2182 int err;
2183
2184 ctl.id = cid;
2185
2186 err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_G_CTRL, &ctl);
2187 if (!err)
2188 *val = ctl.value;
2189
2190 return err;
2191 }
2192
2193
2194 static int
2195 w9968cf_sensor_cmd(struct w9968cf_device* cam, unsigned int cmd, void* arg)
2196 {
2197 struct i2c_client* c = cam->sensor_client;
2198 int rc = 0;
2199
2200 if (!c || !c->driver || !c->driver->command)
2201 return -EINVAL;
2202
2203 rc = c->driver->command(c, cmd, arg);
2204 /* The I2C driver returns -EPERM on non-supported controls */
2205 return (rc < 0 && rc != -EPERM) ? rc : 0;
2206 }
2207
2208
2209 /*--------------------------------------------------------------------------
2210 Update some settings of the image sensor.
2211 Returns: 0 on success, a negative number otherwise.
2212 --------------------------------------------------------------------------*/
2213 static int w9968cf_sensor_update_settings(struct w9968cf_device* cam)
2214 {
2215 int err = 0;
2216
2217 /* Auto brightness */
2218 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_AUTOBRIGHT,
2219 cam->auto_brt);
2220 if (err)
2221 return err;
2222
2223 /* Auto exposure */
2224 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_AUTOEXP,
2225 cam->auto_exp);
2226 if (err)
2227 return err;
2228
2229 /* Banding filter */
2230 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BANDFILT,
2231 cam->bandfilt);
2232 if (err)
2233 return err;
2234
2235 /* Light frequency */
2236 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_FREQ,
2237 cam->lightfreq);
2238 if (err)
2239 return err;
2240
2241 /* Back light */
2242 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BACKLIGHT,
2243 cam->backlight);
2244 if (err)
2245 return err;
2246
2247 /* Mirror */
2248 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_MIRROR,
2249 cam->mirror);
2250 if (err)
2251 return err;
2252
2253 return 0;
2254 }
2255
2256
2257 /*--------------------------------------------------------------------------
2258 Get some current picture settings from the image sensor and update the
2259 internal 'picture' structure of the camera.
2260 Returns: 0 on success, a negative number otherwise.
2261 --------------------------------------------------------------------------*/
2262 static int w9968cf_sensor_get_picture(struct w9968cf_device* cam)
2263 {
2264 int err, v;
2265
2266 err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_CONT, &v);
2267 if (err)
2268 return err;
2269 cam->picture.contrast = v;
2270
2271 err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_BRIGHT, &v);
2272 if (err)
2273 return err;
2274 cam->picture.brightness = v;
2275
2276 err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_SAT, &v);
2277 if (err)
2278 return err;
2279 cam->picture.colour = v;
2280
2281 err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_HUE, &v);
2282 if (err)
2283 return err;
2284 cam->picture.hue = v;
2285
2286 DBG(5, "Got picture settings from the image sensor")
2287
2288 PDBGG("Brightness, contrast, hue, colour, whiteness are "
2289 "%u,%u,%u,%u,%u", cam->picture.brightness,cam->picture.contrast,
2290 cam->picture.hue, cam->picture.colour, cam->picture.whiteness)
2291
2292 return 0;
2293 }
2294
2295
2296 /*--------------------------------------------------------------------------
2297 Update picture settings of the image sensor.
2298 Returns: 0 on success, a negative number otherwise.
2299 --------------------------------------------------------------------------*/
2300 static int
2301 w9968cf_sensor_update_picture(struct w9968cf_device* cam,
2302 struct video_picture pict)
2303 {
2304 int err = 0;
2305
2306 if ((!cam->sensor_initialized)
2307 || pict.contrast != cam->picture.contrast) {
2308 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_CONT,
2309 pict.contrast);
2310 if (err)
2311 goto fail;
2312 DBG(4, "Contrast changed from %u to %u",
2313 cam->picture.contrast, pict.contrast)
2314 cam->picture.contrast = pict.contrast;
2315 }
2316
2317 if (((!cam->sensor_initialized) ||
2318 pict.brightness != cam->picture.brightness) && (!cam->auto_brt)) {
2319 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BRIGHT,
2320 pict.brightness);
2321 if (err)
2322 goto fail;
2323 DBG(4, "Brightness changed from %u to %u",
2324 cam->picture.brightness, pict.brightness)
2325 cam->picture.brightness = pict.brightness;
2326 }
2327
2328 if ((!cam->sensor_initialized) || pict.colour != cam->picture.colour) {
2329 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_SAT,
2330 pict.colour);
2331 if (err)
2332 goto fail;
2333 DBG(4, "Colour changed from %u to %u",
2334 cam->picture.colour, pict.colour)
2335 cam->picture.colour = pict.colour;
2336 }
2337
2338 if ((!cam->sensor_initialized) || pict.hue != cam->picture.hue) {
2339 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_HUE,
2340 pict.hue);
2341 if (err)
2342 goto fail;
2343 DBG(4, "Hue changed from %u to %u",
2344 cam->picture.hue, pict.hue)
2345 cam->picture.hue = pict.hue;
2346 }
2347
2348 return 0;
2349
2350 fail:
2351 DBG(4, "Failed to change sensor picture setting")
2352 return err;
2353 }
2354
2355
2356
2357 /****************************************************************************
2358 * Camera configuration *
2359 ****************************************************************************/
2360
2361 /*--------------------------------------------------------------------------
2362 This function is called when a supported image sensor is detected.
2363 Return 0 if the initialization succeeds, a negative number otherwise.
2364 --------------------------------------------------------------------------*/
2365 static int w9968cf_sensor_init(struct w9968cf_device* cam)
2366 {
2367 int err = 0;
2368
2369 if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_INITIALIZE,
2370 &cam->monochrome)))
2371 goto error;
2372
2373 if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_Q_SUBTYPE,
2374 &cam->sensor)))
2375 goto error;
2376
2377 /* NOTE: Make sure width and height are a multiple of 16 */
2378 switch (cam->sensor_client->addr) {
2379 case OV6xx0_SID:
2380 cam->maxwidth = 352;
2381 cam->maxheight = 288;
2382 cam->minwidth = 64;
2383 cam->minheight = 48;
2384 break;
2385 case OV7xx0_SID:
2386 cam->maxwidth = 640;
2387 cam->maxheight = 480;
2388 cam->minwidth = 64;
2389 cam->minheight = 48;
2390 break;
2391 default:
2392 DBG(1, "Not supported image sensor detected for %s",
2393 symbolic(camlist, cam->id))
2394 return -EINVAL;
2395 }
2396
2397 /* These values depend on the ones in the ovxxx0.c sources */
2398 switch (cam->sensor) {
2399 case CC_OV7620:
2400 cam->start_cropx = 287;
2401 cam->start_cropy = 35;
2402 /* Seems to work around a bug in the image sensor */
2403 cam->vs_polarity = 1;
2404 cam->hs_polarity = 1;
2405 break;
2406 default:
2407 cam->start_cropx = 320;
2408 cam->start_cropy = 35;
2409 cam->vs_polarity = 1;
2410 cam->hs_polarity = 0;
2411 }
2412
2413 if ((err = w9968cf_sensor_update_settings(cam)))
2414 goto error;
2415
2416 if ((err = w9968cf_sensor_update_picture(cam, cam->picture)))
2417 goto error;
2418
2419 cam->sensor_initialized = 1;
2420
2421 DBG(2, "%s image sensor initialized", symbolic(senlist, cam->sensor))
2422 return 0;
2423
2424 error:
2425 cam->sensor_initialized = 0;
2426 cam->sensor = CC_UNKNOWN;
2427 DBG(1, "Image sensor initialization failed for %s (/dev/video%d). "
2428 "Try to detach and attach this device again",
2429 symbolic(camlist, cam->id), cam->v4ldev->minor)
2430 return err;
2431 }
2432
2433
2434 /*--------------------------------------------------------------------------
2435 Fill some basic fields in the main device data structure.
2436 This function is called once on w9968cf_usb_probe() for each recognized
2437 camera.
2438 --------------------------------------------------------------------------*/
2439 static void
2440 w9968cf_configure_camera(struct w9968cf_device* cam,
2441 struct usb_device* udev,
2442 enum w9968cf_model_id mod_id,
2443 const unsigned short dev_nr)
2444 {
2445 init_MUTEX(&cam->fileop_sem);
2446 init_waitqueue_head(&cam->open);
2447 spin_lock_init(&cam->urb_lock);
2448 spin_lock_init(&cam->flist_lock);
2449
2450 cam->users = 0;
2451 cam->disconnected = 0;
2452 cam->id = mod_id;
2453 cam->sensor = CC_UNKNOWN;
2454 cam->sensor_initialized = 0;
2455
2456 /* Calculate the alternate setting number (from 1 to 16)
2457 according to the 'packet_size' module parameter */
2458 if (packet_size[dev_nr] < W9968CF_MIN_PACKET_SIZE)
2459 packet_size[dev_nr] = W9968CF_MIN_PACKET_SIZE;
2460 for (cam->altsetting = 1;
2461 packet_size[dev_nr] < wMaxPacketSize[cam->altsetting-1];
2462 cam->altsetting++);
2463
2464 cam->max_buffers = (max_buffers[dev_nr] < 2 ||
2465 max_buffers[dev_nr] > W9968CF_MAX_BUFFERS)
2466 ? W9968CF_BUFFERS : (u8)max_buffers[dev_nr];
2467
2468 cam->double_buffer = (double_buffer[dev_nr] == 0 ||
2469 double_buffer[dev_nr] == 1)
2470 ? (u8)double_buffer[dev_nr]:W9968CF_DOUBLE_BUFFER;
2471
2472 cam->clamping = (clamping[dev_nr] == 0 || clamping[dev_nr] == 1)
2473 ? (u8)clamping[dev_nr] : W9968CF_CLAMPING;
2474
2475 cam->filter_type = (filter_type[dev_nr] == 0 ||
2476 filter_type[dev_nr] == 1 ||
2477 filter_type[dev_nr] == 2)
2478 ? (u8)filter_type[dev_nr] : W9968CF_FILTER_TYPE;
2479
2480 cam->capture = 1;
2481
2482 cam->largeview = (largeview[dev_nr] == 0 || largeview[dev_nr] == 1)
2483 ? (u8)largeview[dev_nr] : W9968CF_LARGEVIEW;
2484
2485 cam->decompression = (decompression[dev_nr] == 0 ||
2486 decompression[dev_nr] == 1 ||
2487 decompression[dev_nr] == 2)
2488 ? (u8)decompression[dev_nr]:W9968CF_DECOMPRESSION;
2489
2490 cam->upscaling = (upscaling[dev_nr] == 0 ||
2491 upscaling[dev_nr] == 1)
2492 ? (u8)upscaling[dev_nr] : W9968CF_UPSCALING;
2493
2494 cam->auto_brt = (autobright[dev_nr] == 0 || autobright[dev_nr] == 1)
2495 ? (u8)autobright[dev_nr] : W9968CF_AUTOBRIGHT;
2496
2497 cam->auto_exp = (autoexp[dev_nr] == 0 || autoexp[dev_nr] == 1)
2498 ? (u8)autoexp[dev_nr] : W9968CF_AUTOEXP;
2499
2500 cam->lightfreq = (lightfreq[dev_nr] == 50 || lightfreq[dev_nr] == 60)
2501 ? (u8)lightfreq[dev_nr] : W9968CF_LIGHTFREQ;
2502
2503 cam->bandfilt = (bandingfilter[dev_nr] == 0 ||
2504 bandingfilter[dev_nr] == 1)
2505 ? (u8)bandingfilter[dev_nr] : W9968CF_BANDINGFILTER;
2506
2507 cam->backlight = (backlight[dev_nr] == 0 || backlight[dev_nr] == 1)
2508 ? (u8)backlight[dev_nr] : W9968CF_BACKLIGHT;
2509
2510 cam->clockdiv = (clockdiv[dev_nr] == -1 || clockdiv[dev_nr] >= 0)
2511 ? (s8)clockdiv[dev_nr] : W9968CF_CLOCKDIV;
2512
2513 cam->mirror = (mirror[dev_nr] == 0 || mirror[dev_nr] == 1)
2514 ? (u8)mirror[dev_nr] : W9968CF_MIRROR;
2515
2516 cam->monochrome = (monochrome[dev_nr] == 0 || monochrome[dev_nr] == 1)
2517 ? monochrome[dev_nr] : W9968CF_MONOCHROME;
2518
2519 cam->picture.brightness = (u16)brightness[dev_nr];
2520 cam->picture.hue = (u16)hue[dev_nr];
2521 cam->picture.colour = (u16)colour[dev_nr];
2522 cam->picture.contrast = (u16)contrast[dev_nr];
2523 cam->picture.whiteness = (u16)whiteness[dev_nr];
2524 if (w9968cf_valid_palette((u16)force_palette[dev_nr])) {
2525 cam->picture.palette = (u16)force_palette[dev_nr];
2526 cam->force_palette = 1;
2527 } else {
2528 cam->force_palette = 0;
2529 if (cam->decompression == 0)
2530 cam->picture.palette = W9968CF_PALETTE_DECOMP_OFF;
2531 else if (cam->decompression == 1)
2532 cam->picture.palette = W9968CF_PALETTE_DECOMP_FORCE;
2533 else
2534 cam->picture.palette = W9968CF_PALETTE_DECOMP_ON;
2535 }
2536 cam->picture.depth = w9968cf_valid_depth(cam->picture.palette);
2537
2538 cam->force_rgb = (force_rgb[dev_nr] == 0 || force_rgb[dev_nr] == 1)
2539 ? (u8)force_rgb[dev_nr] : W9968CF_FORCE_RGB;
2540
2541 cam->window.x = 0;
2542 cam->window.y = 0;
2543 cam->window.width = W9968CF_WIDTH;
2544 cam->window.height = W9968CF_HEIGHT;
2545 cam->window.chromakey = 0;
2546 cam->window.clipcount = 0;
2547 cam->window.flags = 0;
2548
2549 DBG(3, "%s configured with settings #%u:",
2550 symbolic(camlist, cam->id), dev_nr)
2551
2552 DBG(3, "- Data packet size for USB isochrnous transfer: %u bytes",
2553 wMaxPacketSize[cam->altsetting-1])
2554
2555 DBG(3, "- Number of requested video frame buffers: %u",
2556 cam->max_buffers)
2557
2558 if (cam->double_buffer)
2559 DBG(3, "- Hardware double buffering enabled")
2560 else
2561 DBG(3, "- Hardware double buffering disabled")
2562
2563 if (cam->filter_type == 0)
2564 DBG(3, "- Video filtering disabled")
2565 else if (cam->filter_type == 1)
2566 DBG(3, "- Video filtering enabled: type 1-2-1")
2567 else if (cam->filter_type == 2)
2568 DBG(3, "- Video filtering enabled: type 2-3-6-3-2")
2569
2570 if (cam->clamping)
2571 DBG(3, "- Video data clamping (CCIR-601 format) enabled")
2572 else
2573 DBG(3, "- Video data clamping (CCIR-601 format) disabled")
2574
2575 if (cam->largeview)
2576 DBG(3, "- Large view enabled")
2577 else
2578 DBG(3, "- Large view disabled")
2579
2580 if ((cam->decompression) == 0 && (!cam->force_palette))
2581 DBG(3, "- Decompression disabled")
2582 else if ((cam->decompression) == 1 && (!cam->force_palette))
2583 DBG(3, "- Decompression forced")
2584 else if ((cam->decompression) == 2 && (!cam->force_palette))
2585 DBG(3, "- Decompression allowed")
2586
2587 if (cam->upscaling)
2588 DBG(3, "- Software image scaling enabled")
2589 else
2590 DBG(3, "- Software image scaling disabled")
2591
2592 if (cam->force_palette)
2593 DBG(3, "- Image palette forced to %s",
2594 symbolic(v4l1_plist, cam->picture.palette))
2595
2596 if (cam->force_rgb)
2597 DBG(3, "- RGB component ordering will be used instead of BGR")
2598
2599 if (cam->auto_brt)
2600 DBG(3, "- Auto brightness enabled")
2601 else
2602 DBG(3, "- Auto brightness disabled")
2603
2604 if (cam->auto_exp)
2605 DBG(3, "- Auto exposure enabled")
2606 else
2607 DBG(3, "- Auto exposure disabled")
2608
2609 if (cam->backlight)
2610 DBG(3, "- Backlight exposure algorithm enabled")
2611 else
2612 DBG(3, "- Backlight exposure algorithm disabled")
2613
2614 if (cam->mirror)
2615 DBG(3, "- Mirror enabled")
2616 else
2617 DBG(3, "- Mirror disabled")
2618
2619 if (cam->bandfilt)
2620 DBG(3, "- Banding filter enabled")
2621 else
2622 DBG(3, "- Banding filter disabled")
2623
2624 DBG(3, "- Power lighting frequency: %u", cam->lightfreq)
2625
2626 if (cam->clockdiv == -1)
2627 DBG(3, "- Automatic clock divisor enabled")
2628 else
2629 DBG(3, "- Clock divisor: %d", cam->clockdiv)
2630
2631 if (cam->monochrome)
2632 DBG(3, "- Image sensor used as monochrome")
2633 else
2634 DBG(3, "- Image sensor not used as monochrome")
2635 }
2636
2637
2638 /*--------------------------------------------------------------------------
2639 If the video post-processing module is not loaded, some parameters
2640 must be overridden.
2641 --------------------------------------------------------------------------*/
2642 static void w9968cf_adjust_configuration(struct w9968cf_device* cam)
2643 {
2644 if (!w9968cf_vpp) {
2645 if (cam->decompression == 1) {
2646 cam->decompression = 2;
2647 DBG(2, "Video post-processing module not found: "
2648 "'decompression' parameter forced to 2")
2649 }
2650 if (cam->upscaling) {
2651 cam->upscaling = 0;
2652 DBG(2, "Video post-processing module not found: "
2653 "'upscaling' parameter forced to 0")
2654 }
2655 if (cam->picture.palette != VIDEO_PALETTE_UYVY) {
2656 cam->force_palette = 0;
2657 DBG(2, "Video post-processing module not found: "
2658 "'force_palette' parameter forced to 0")
2659 }
2660 cam->picture.palette = VIDEO_PALETTE_UYVY;
2661 cam->picture.depth = w9968cf_valid_depth(cam->picture.palette);
2662 }
2663 }
2664
2665
2666 /*--------------------------------------------------------------------------
2667 Release the resources used by the driver.
2668 This function is called on disconnect
2669 (or on close if deallocation has been deferred)
2670 --------------------------------------------------------------------------*/
2671 static void w9968cf_release_resources(struct w9968cf_device* cam)
2672 {
2673 down(&w9968cf_devlist_sem);
2674
2675 DBG(2, "V4L device deregistered: /dev/video%d", cam->v4ldev->minor)
2676
2677 video_unregister_device(cam->v4ldev);
2678 list_del(&cam->v4llist);
2679 i2c_del_adapter(&cam->i2c_adapter);
2680 w9968cf_deallocate_memory(cam);
2681 kfree(cam->control_buffer);
2682 kfree(cam->data_buffer);
2683
2684 up(&w9968cf_devlist_sem);
2685 }
2686
2687
2688
2689 /****************************************************************************
2690 * Video4Linux interface *
2691 ****************************************************************************/
2692
2693 static int w9968cf_open(struct inode* inode, struct file* filp)
2694 {
2695 struct w9968cf_device* cam;
2696 int err;
2697
2698 /* This the only safe way to prevent race conditions with disconnect */
2699 if (!down_read_trylock(&w9968cf_disconnect))
2700 return -ERESTARTSYS;
2701
2702 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2703
2704 down(&cam->dev_sem);
2705
2706 if (cam->sensor == CC_UNKNOWN) {
2707 DBG(2, "No supported image sensor has been detected by the "
2708 "'ovcamchip' module for the %s (/dev/video%d). Make "
2709 "sure it is loaded *before* (re)connecting the camera.",
2710 symbolic(camlist, cam->id), cam->v4ldev->minor)
2711 up(&cam->dev_sem);
2712 up_read(&w9968cf_disconnect);
2713 return -ENODEV;
2714 }
2715
2716 if (cam->users) {
2717 DBG(2, "%s (/dev/video%d) has been already occupied by '%s'",
2718 symbolic(camlist, cam->id),cam->v4ldev->minor,cam->command)
2719 if ((filp->f_flags & O_NONBLOCK)||(filp->f_flags & O_NDELAY)) {
2720 up(&cam->dev_sem);
2721 up_read(&w9968cf_disconnect);
2722 return -EWOULDBLOCK;
2723 }
2724 up(&cam->dev_sem);
2725 err = wait_event_interruptible_exclusive(cam->open,
2726 cam->disconnected ||
2727 !cam->users);
2728 if (err) {
2729 up_read(&w9968cf_disconnect);
2730 return err;
2731 }
2732 if (cam->disconnected) {
2733 up_read(&w9968cf_disconnect);
2734 return -ENODEV;
2735 }
2736 down(&cam->dev_sem);
2737 }
2738
2739 DBG(5, "Opening '%s', /dev/video%d ...",
2740 symbolic(camlist, cam->id), cam->v4ldev->minor)
2741
2742 cam->streaming = 0;
2743 cam->misconfigured = 0;
2744
2745 if (!w9968cf_vpp)
2746 if ((err = w9968cf_vppmod_detect(cam)))
2747 goto out;
2748
2749 if ((err = w9968cf_allocate_memory(cam)))
2750 goto deallocate_memory;
2751
2752 if ((err = w9968cf_init_chip(cam)))
2753 goto deallocate_memory;
2754
2755 if ((err = w9968cf_start_transfer(cam)))
2756 goto deallocate_memory;
2757
2758 filp->private_data = cam;
2759
2760 cam->users++;
2761 strcpy(cam->command, current->comm);
2762
2763 init_waitqueue_head(&cam->wait_queue);
2764
2765 DBG(5, "Video device is open")
2766
2767 up(&cam->dev_sem);
2768 up_read(&w9968cf_disconnect);
2769
2770 return 0;
2771
2772 deallocate_memory:
2773 w9968cf_deallocate_memory(cam);
2774 out:
2775 DBG(2, "Failed to open the video device")
2776 up(&cam->dev_sem);
2777 up_read(&w9968cf_disconnect);
2778 return err;
2779 }
2780
2781
2782 static int w9968cf_release(struct inode* inode, struct file* filp)
2783 {
2784 struct w9968cf_device* cam;
2785
2786 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2787
2788 down(&cam->dev_sem); /* prevent disconnect() to be called */
2789
2790 w9968cf_stop_transfer(cam);
2791
2792 w9968cf_vppmod_release(cam);
2793
2794 if (cam->disconnected) {
2795 w9968cf_release_resources(cam);
2796 up(&cam->dev_sem);
2797 kfree(cam);
2798 return 0;
2799 }
2800
2801 cam->users--;
2802 w9968cf_deallocate_memory(cam);
2803 wake_up_interruptible_nr(&cam->open, 1);
2804
2805 DBG(5, "Video device closed")
2806 up(&cam->dev_sem);
2807 return 0;
2808 }
2809
2810
2811 static ssize_t
2812 w9968cf_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
2813 {
2814 struct w9968cf_device* cam;
2815 struct w9968cf_frame_t* fr;
2816 int err = 0;
2817
2818 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2819
2820 if (filp->f_flags & O_NONBLOCK)
2821 return -EWOULDBLOCK;
2822
2823 if (down_interruptible(&cam->fileop_sem))
2824 return -ERESTARTSYS;
2825
2826 if (cam->disconnected) {
2827 DBG(2, "Device not present")
2828 up(&cam->fileop_sem);
2829 return -ENODEV;
2830 }
2831
2832 if (cam->misconfigured) {
2833 DBG(2, "The camera is misconfigured. Close and open it again.")
2834 up(&cam->fileop_sem);
2835 return -EIO;
2836 }
2837
2838 if (!cam->frame[0].queued)
2839 w9968cf_push_frame(cam, 0);
2840
2841 if (!cam->frame[1].queued)
2842 w9968cf_push_frame(cam, 1);
2843
2844 err = wait_event_interruptible(cam->wait_queue,
2845 cam->frame[0].status == F_READY ||
2846 cam->frame[1].status == F_READY ||
2847 cam->disconnected);
2848 if (err) {
2849 up(&cam->fileop_sem);
2850 return err;
2851 }
2852 if (cam->disconnected) {
2853 up(&cam->fileop_sem);
2854 return -ENODEV;
2855 }
2856
2857 fr = (cam->frame[0].status == F_READY) ? &cam->frame[0]:&cam->frame[1];
2858
2859 if (w9968cf_vpp)
2860 w9968cf_postprocess_frame(cam, fr);
2861
2862 if (count > fr->length)
2863 count = fr->length;
2864
2865 if (copy_to_user(buf, fr->buffer, count)) {
2866 fr->status = F_UNUSED;
2867 up(&cam->fileop_sem);
2868 return -EFAULT;
2869 }
2870 *f_pos += count;
2871
2872 fr->status = F_UNUSED;
2873
2874 DBG(5, "%zu bytes read", count)
2875
2876 up(&cam->fileop_sem);
2877 return count;
2878 }
2879
2880
2881 static int w9968cf_mmap(struct file* filp, struct vm_area_struct *vma)
2882 {
2883 struct w9968cf_device* cam = (struct w9968cf_device*)
2884 video_get_drvdata(video_devdata(filp));
2885 unsigned long vsize = vma->vm_end - vma->vm_start,
2886 psize = cam->nbuffers * cam->frame[0].size,
2887 start = vma->vm_start,
2888 pos = (unsigned long)cam->frame[0].buffer,
2889 page;
2890
2891 if (cam->disconnected) {
2892 DBG(2, "Device not present")
2893 return -ENODEV;
2894 }
2895
2896 if (cam->misconfigured) {
2897 DBG(2, "The camera is misconfigured. Close and open it again")
2898 return -EIO;
2899 }
2900
2901 PDBGG("mmapping %lu bytes...", vsize)
2902
2903 if (vsize > psize - (vma->vm_pgoff << PAGE_SHIFT))
2904 return -EINVAL;
2905
2906 while (vsize > 0) {
2907 page = vmalloc_to_pfn((void *)pos);
2908 if (remap_pfn_range(vma, start, page + vma->vm_pgoff,
2909 PAGE_SIZE, vma->vm_page_prot))
2910 return -EAGAIN;
2911 start += PAGE_SIZE;
2912 pos += PAGE_SIZE;
2913 vsize -= PAGE_SIZE;
2914 }
2915
2916 DBG(5, "mmap method successfully called")
2917 return 0;
2918 }
2919
2920
2921 static int
2922 w9968cf_ioctl(struct inode* inode, struct file* filp,
2923 unsigned int cmd, unsigned long arg)
2924 {
2925 struct w9968cf_device* cam;
2926 int err;
2927
2928 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2929
2930 if (down_interruptible(&cam->fileop_sem))
2931 return -ERESTARTSYS;
2932
2933 if (cam->disconnected) {
2934 DBG(2, "Device not present")
2935 up(&cam->fileop_sem);
2936 return -ENODEV;
2937 }
2938
2939 if (cam->misconfigured) {
2940 DBG(2, "The camera is misconfigured. Close and open it again.")
2941 up(&cam->fileop_sem);
2942 return -EIO;
2943 }
2944
2945 err = w9968cf_v4l_ioctl(inode, filp, cmd, (void __user *)arg);
2946
2947 up(&cam->fileop_sem);
2948 return err;
2949 }
2950
2951
2952 static int w9968cf_v4l_ioctl(struct inode* inode, struct file* filp,
2953 unsigned int cmd, void __user * arg)
2954 {
2955 struct w9968cf_device* cam;
2956 const char* v4l1_ioctls[] = {
2957 "?", "CGAP", "GCHAN", "SCHAN", "GTUNER", "STUNER",
2958 "GPICT", "SPICT", "CCAPTURE", "GWIN", "SWIN", "GFBUF",
2959 "SFBUF", "KEY", "GFREQ", "SFREQ", "GAUDIO", "SAUDIO",
2960 "SYNC", "MCAPTURE", "GMBUF", "GUNIT", "GCAPTURE", "SCAPTURE",
2961 "SPLAYMODE", "SWRITEMODE", "GPLAYINFO", "SMICROCODE",
2962 "GVBIFMT", "SVBIFMT"
2963 };
2964
2965 #define V4L1_IOCTL(cmd) \
2966 ((_IOC_NR((cmd)) < sizeof(v4l1_ioctls)/sizeof(char*)) ? \
2967 v4l1_ioctls[_IOC_NR((cmd))] : "?")
2968
2969 cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2970
2971 switch (cmd) {
2972
2973 case VIDIOCGCAP: /* get video capability */
2974 {
2975 struct video_capability cap = {
2976 .type = VID_TYPE_CAPTURE | VID_TYPE_SCALES,
2977 .channels = 1,
2978 .audios = 0,
2979 .minwidth = cam->minwidth,
2980 .minheight = cam->minheight,
2981 };
2982 sprintf(cap.name, "W996[87]CF USB Camera #%d",
2983 cam->v4ldev->minor);
2984 cap.maxwidth = (cam->upscaling && w9968cf_vpp)
2985 ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
2986 : cam->maxwidth;
2987 cap.maxheight = (cam->upscaling && w9968cf_vpp)
2988 ? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
2989 : cam->maxheight;
2990
2991 if (copy_to_user(arg, &cap, sizeof(cap)))
2992 return -EFAULT;
2993
2994 DBG(5, "VIDIOCGCAP successfully called")
2995 return 0;
2996 }
2997
2998 case VIDIOCGCHAN: /* get video channel informations */
2999 {
3000 struct video_channel chan;
3001 if (copy_from_user(&chan, arg, sizeof(chan)))
3002 return -EFAULT;
3003
3004 if (chan.channel != 0)
3005 return -EINVAL;
3006
3007 strcpy(chan.name, "Camera");
3008 chan.tuners = 0;
3009 chan.flags = 0;
3010 chan.type = VIDEO_TYPE_CAMERA;
3011 chan.norm = VIDEO_MODE_AUTO;
3012
3013 if (copy_to_user(arg, &chan, sizeof(chan)))
3014 return -EFAULT;
3015
3016 DBG(5, "VIDIOCGCHAN successfully called")
3017 return 0;
3018 }
3019
3020 case VIDIOCSCHAN: /* set active channel */
3021 {
3022 struct video_channel chan;
3023
3024 if (copy_from_user(&chan, arg, sizeof(chan)))
3025 return -EFAULT;
3026
3027 if (chan.channel != 0)
3028 return -EINVAL;
3029
3030 DBG(5, "VIDIOCSCHAN successfully called")
3031 return 0;
3032 }
3033
3034 case VIDIOCGPICT: /* get image properties of the picture */
3035 {
3036 if (w9968cf_sensor_get_picture(cam))
3037 return -EIO;
3038
3039 if (copy_to_user(arg, &cam->picture, sizeof(cam->picture)))
3040 return -EFAULT;
3041
3042 DBG(5, "VIDIOCGPICT successfully called")
3043 return 0;
3044 }
3045
3046 case VIDIOCSPICT: /* change picture settings */
3047 {
3048 struct video_picture pict;
3049 int err = 0;
3050
3051 if (copy_from_user(&pict, arg, sizeof(pict)))
3052 return -EFAULT;
3053
3054 if ( (cam->force_palette || !w9968cf_vpp)
3055 && pict.palette != cam->picture.palette ) {
3056 DBG(4, "Palette %s rejected: only %s is allowed",
3057 symbolic(v4l1_plist, pict.palette),
3058 symbolic(v4l1_plist, cam->picture.palette))
3059 return -EINVAL;
3060 }
3061
3062 if (!w9968cf_valid_palette(pict.palette)) {
3063 DBG(4, "Palette %s not supported. VIDIOCSPICT failed",
3064 symbolic(v4l1_plist, pict.palette))
3065 return -EINVAL;
3066 }
3067
3068 if (!cam->force_palette) {
3069 if (cam->decompression == 0) {
3070 if (w9968cf_need_decompression(pict.palette)) {
3071 DBG(4, "Decompression disabled: palette %s is not "
3072 "allowed. VIDIOCSPICT failed",
3073 symbolic(v4l1_plist, pict.palette))
3074 return -EINVAL;
3075 }
3076 } else if (cam->decompression == 1) {
3077 if (!w9968cf_need_decompression(pict.palette)) {
3078 DBG(4, "Decompression forced: palette %s is not "
3079 "allowed. VIDIOCSPICT failed",
3080 symbolic(v4l1_plist, pict.palette))
3081 return -EINVAL;
3082 }
3083 }
3084 }
3085
3086 if (pict.depth != w9968cf_valid_depth(pict.palette)) {
3087 DBG(4, "Requested depth %u bpp is not valid for %s "
3088 "palette: ignored and changed to %u bpp",
3089 pict.depth, symbolic(v4l1_plist, pict.palette),
3090 w9968cf_valid_depth(pict.palette))
3091 pict.depth = w9968cf_valid_depth(pict.palette);
3092 }
3093
3094 if (pict.palette != cam->picture.palette) {
3095 if(*cam->requested_frame
3096 || cam->frame_current->queued) {
3097 err = wait_event_interruptible
3098 ( cam->wait_queue,
3099 cam->disconnected ||
3100 (!*cam->requested_frame &&
3101 !cam->frame_current->queued) );
3102 if (err)
3103 return err;
3104 if (cam->disconnected)
3105 return -ENODEV;
3106 }
3107
3108 if (w9968cf_stop_transfer(cam))
3109 goto ioctl_fail;
3110
3111 if (w9968cf_set_picture(cam, pict))
3112 goto ioctl_fail;
3113
3114 if (w9968cf_start_transfer(cam))
3115 goto ioctl_fail;
3116
3117 } else if (w9968cf_sensor_update_picture(cam, pict))
3118 return -EIO;
3119
3120
3121 DBG(5, "VIDIOCSPICT successfully called")
3122 return 0;
3123 }
3124
3125 case VIDIOCSWIN: /* set capture area */
3126 {
3127 struct video_window win;
3128 int err = 0;
3129
3130 if (copy_from_user(&win, arg, sizeof(win)))
3131 return -EFAULT;
3132
3133 DBG(6, "VIDIOCSWIN called: clipcount=%d, flags=%u, "
3134 "x=%u, y=%u, %ux%u", win.clipcount, win.flags,
3135 win.x, win.y, win.width, win.height)
3136
3137 if (win.clipcount != 0 || win.flags != 0)
3138 return -EINVAL;
3139
3140 if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
3141 (u16*)&win.height))) {
3142 DBG(4, "Resolution not supported (%ux%u). "
3143 "VIDIOCSWIN failed", win.width, win.height)
3144 return err;
3145 }
3146
3147 if (win.x != cam->window.x ||
3148 win.y != cam->window.y ||
3149 win.width != cam->window.width ||
3150 win.height != cam->window.height) {
3151 if(*cam->requested_frame
3152 || cam->frame_current->queued) {
3153 err = wait_event_interruptible
3154 ( cam->wait_queue,
3155 cam->disconnected ||
3156 (!*cam->requested_frame &&
3157 !cam->frame_current->queued) );
3158 if (err)
3159 return err;
3160 if (cam->disconnected)
3161 return -ENODEV;
3162 }
3163
3164 if (w9968cf_stop_transfer(cam))
3165 goto ioctl_fail;
3166
3167 /* This _must_ be called before set_window() */
3168 if (w9968cf_set_picture(cam, cam->picture))
3169 goto ioctl_fail;
3170
3171 if (w9968cf_set_window(cam, win))
3172 goto ioctl_fail;
3173
3174 if (w9968cf_start_transfer(cam))
3175 goto ioctl_fail;
3176 }
3177
3178 DBG(5, "VIDIOCSWIN successfully called. ")
3179 return 0;
3180 }
3181
3182 case VIDIOCGWIN: /* get current window properties */
3183 {
3184 if (copy_to_user(arg,&cam->window,sizeof(struct video_window)))
3185 return -EFAULT;
3186
3187 DBG(5, "VIDIOCGWIN successfully called")
3188 return 0;
3189 }
3190
3191 case VIDIOCGMBUF: /* request for memory (mapped) buffer */
3192 {
3193 struct video_mbuf mbuf;
3194 u8 i;
3195
3196 mbuf.size = cam->nbuffers * cam->frame[0].size;
3197 mbuf.frames = cam->nbuffers;
3198 for (i = 0; i < cam->nbuffers; i++)
3199 mbuf.offsets[i] = (unsigned long)cam->frame[i].buffer -
3200 (unsigned long)cam->frame[0].buffer;
3201
3202 if (copy_to_user(arg, &mbuf, sizeof(mbuf)))
3203 return -EFAULT;
3204
3205 DBG(5, "VIDIOCGMBUF successfully called")
3206 return 0;
3207 }
3208
3209 case VIDIOCMCAPTURE: /* start the capture to a frame */
3210 {
3211 struct video_mmap mmap;
3212 struct w9968cf_frame_t* fr;
3213 int err = 0;
3214
3215 if (copy_from_user(&mmap, arg, sizeof(mmap)))
3216 return -EFAULT;
3217
3218 DBG(6, "VIDIOCMCAPTURE called: frame #%u, format=%s, %dx%d",
3219 mmap.frame, symbolic(v4l1_plist, mmap.format),
3220 mmap.width, mmap.height)
3221
3222 if (mmap.frame >= cam->nbuffers) {
3223 DBG(4, "Invalid frame number (%u). "
3224 "VIDIOCMCAPTURE failed", mmap.frame)
3225 return -EINVAL;
3226 }
3227
3228 if (mmap.format!=cam->picture.palette &&
3229 (cam->force_palette || !w9968cf_vpp)) {
3230 DBG(4, "Palette %s rejected: only %s is allowed",
3231 symbolic(v4l1_plist, mmap.format),
3232 symbolic(v4l1_plist, cam->picture.palette))
3233 return -EINVAL;
3234 }
3235
3236 if (!w9968cf_valid_palette(mmap.format)) {
3237 DBG(4, "Palette %s not supported. "
3238 "VIDIOCMCAPTURE failed",
3239 symbolic(v4l1_plist, mmap.format))
3240 return -EINVAL;
3241 }
3242
3243 if (!cam->force_palette) {
3244 if (cam->decompression == 0) {
3245 if (w9968cf_need_decompression(mmap.format)) {
3246 DBG(4, "Decompression disabled: palette %s is not "
3247 "allowed. VIDIOCSPICT failed",
3248 symbolic(v4l1_plist, mmap.format))
3249 return -EINVAL;
3250 }
3251 } else if (cam->decompression == 1) {
3252 if (!w9968cf_need_decompression(mmap.format)) {
3253 DBG(4, "Decompression forced: palette %s is not "
3254 "allowed. VIDIOCSPICT failed",
3255 symbolic(v4l1_plist, mmap.format))
3256 return -EINVAL;
3257 }
3258 }
3259 }
3260
3261 if ((err = w9968cf_adjust_window_size(cam, (u16*)&mmap.width,
3262 (u16*)&mmap.height))) {
3263 DBG(4, "Resolution not supported (%dx%d). "
3264 "VIDIOCMCAPTURE failed",
3265 mmap.width, mmap.height)
3266 return err;
3267 }
3268
3269 fr = &cam->frame[mmap.frame];
3270
3271 if (mmap.width != cam->window.width ||
3272 mmap.height != cam->window.height ||
3273 mmap.format != cam->picture.palette) {
3274
3275 struct video_window win;
3276 struct video_picture pict;
3277
3278 if(*cam->requested_frame
3279 || cam->frame_current->queued) {
3280 DBG(6, "VIDIOCMCAPTURE. Change settings for "
3281 "frame #%u: %dx%d, format %s. Wait...",
3282 mmap.frame, mmap.width, mmap.height,
3283 symbolic(v4l1_plist, mmap.format))
3284 err = wait_event_interruptible
3285 ( cam->wait_queue,
3286 cam->disconnected ||
3287 (!*cam->requested_frame &&
3288 !cam->frame_current->queued) );
3289 if (err)
3290 return err;
3291 if (cam->disconnected)
3292 return -ENODEV;
3293 }
3294
3295 memcpy(&win, &cam->window, sizeof(win));
3296 memcpy(&pict, &cam->picture, sizeof(pict));
3297 win.width = mmap.width;
3298 win.height = mmap.height;
3299 pict.palette = mmap.format;
3300
3301 if (w9968cf_stop_transfer(cam))
3302 goto ioctl_fail;
3303
3304 /* This before set_window */
3305 if (w9968cf_set_picture(cam, pict))
3306 goto ioctl_fail;
3307
3308 if (w9968cf_set_window(cam, win))
3309 goto ioctl_fail;
3310
3311 if (w9968cf_start_transfer(cam))
3312 goto ioctl_fail;
3313
3314 } else if (fr->queued) {
3315
3316 DBG(6, "Wait until frame #%u is free", mmap.frame)
3317
3318 err = wait_event_interruptible(cam->wait_queue,
3319 cam->disconnected ||
3320 (!fr->queued));
3321 if (err)
3322 return err;
3323 if (cam->disconnected)
3324 return -ENODEV;
3325 }
3326
3327 w9968cf_push_frame(cam, mmap.frame);
3328 DBG(5, "VIDIOCMCAPTURE(%u): successfully called", mmap.frame)
3329 return 0;
3330 }
3331
3332 case VIDIOCSYNC: /* wait until the capture of a frame is finished */
3333 {
3334 unsigned int f_num;
3335 struct w9968cf_frame_t* fr;
3336 int err = 0;
3337
3338 if (copy_from_user(&f_num, arg, sizeof(f_num)))
3339 return -EFAULT;
3340
3341 if (f_num >= cam->nbuffers) {
3342 DBG(4, "Invalid frame number (%u). "
3343 "VIDIOCMCAPTURE failed", f_num)
3344 return -EINVAL;
3345 }
3346
3347 DBG(6, "VIDIOCSYNC called for frame #%u", f_num)
3348
3349 fr = &cam->frame[f_num];
3350
3351 switch (fr->status) {
3352 case F_UNUSED:
3353 if (!fr->queued) {
3354 DBG(4, "VIDIOSYNC: Frame #%u not requested!",
3355 f_num)
3356 return -EFAULT;
3357 }
3358 case F_ERROR:
3359 case F_GRABBING:
3360 err = wait_event_interruptible(cam->wait_queue,
3361 (fr->status == F_READY)
3362 || cam->disconnected);
3363 if (err)
3364 return err;
3365 if (cam->disconnected)
3366 return -ENODEV;
3367 break;
3368 case F_READY:
3369 break;
3370 }
3371
3372 if (w9968cf_vpp)
3373 w9968cf_postprocess_frame(cam, fr);
3374
3375 fr->status = F_UNUSED;
3376
3377 DBG(5, "VIDIOCSYNC(%u) successfully called", f_num)
3378 return 0;
3379 }
3380
3381 case VIDIOCGUNIT:/* report the unit numbers of the associated devices*/
3382 {
3383 struct video_unit unit = {
3384 .video = cam->v4ldev->minor,
3385 .vbi = VIDEO_NO_UNIT,
3386 .radio = VIDEO_NO_UNIT,
3387 .audio = VIDEO_NO_UNIT,
3388 .teletext = VIDEO_NO_UNIT,
3389 };
3390
3391 if (copy_to_user(arg, &unit, sizeof(unit)))
3392 return -EFAULT;
3393
3394 DBG(5, "VIDIOCGUNIT successfully called")
3395 return 0;
3396 }
3397
3398 case VIDIOCKEY:
3399 return 0;
3400
3401 case VIDIOCGFBUF:
3402 {
3403 if (clear_user(arg, sizeof(struct video_buffer)))
3404 return -EFAULT;
3405
3406 DBG(5, "VIDIOCGFBUF successfully called")
3407 return 0;
3408 }
3409
3410 case VIDIOCGTUNER:
3411 {
3412 struct video_tuner tuner;
3413 if (copy_from_user(&tuner, arg, sizeof(tuner)))
3414 return -EFAULT;
3415
3416 if (tuner.tuner != 0)
3417 return -EINVAL;
3418
3419 strcpy(tuner.name, "no_tuner");
3420 tuner.rangelow = 0;
3421 tuner.rangehigh = 0;
3422 tuner.flags = VIDEO_TUNER_NORM;
3423 tuner.mode = VIDEO_MODE_AUTO;
3424 tuner.signal = 0xffff;
3425
3426 if (copy_to_user(arg, &tuner, sizeof(tuner)))
3427 return -EFAULT;
3428
3429 DBG(5, "VIDIOCGTUNER successfully called")
3430 return 0;
3431 }
3432
3433 case VIDIOCSTUNER:
3434 {
3435 struct video_tuner tuner;
3436 if (copy_from_user(&tuner, arg, sizeof(tuner)))
3437 return -EFAULT;
3438
3439 if (tuner.tuner != 0)
3440 return -EINVAL;
3441
3442 if (tuner.mode != VIDEO_MODE_AUTO)
3443 return -EINVAL;
3444
3445 DBG(5, "VIDIOCSTUNER successfully called")
3446 return 0;
3447 }
3448
3449 case VIDIOCSFBUF:
3450 case VIDIOCCAPTURE:
3451 case VIDIOCGFREQ:
3452 case VIDIOCSFREQ:
3453 case VIDIOCGAUDIO:
3454 case VIDIOCSAUDIO:
3455 case VIDIOCSPLAYMODE:
3456 case VIDIOCSWRITEMODE:
3457 case VIDIOCGPLAYINFO:
3458 case VIDIOCSMICROCODE:
3459 case VIDIOCGVBIFMT:
3460 case VIDIOCSVBIFMT:
3461 DBG(4, "Unsupported V4L1 IOCtl: VIDIOC%s "
3462 "(type 0x%01X, "
3463 "n. 0x%01X, "
3464 "dir. 0x%01X, "
3465 "size 0x%02X)",
3466 V4L1_IOCTL(cmd),
3467 _IOC_TYPE(cmd),_IOC_NR(cmd),_IOC_DIR(cmd),_IOC_SIZE(cmd))
3468
3469 return -EINVAL;
3470
3471 default:
3472 DBG(4, "Invalid V4L1 IOCtl: VIDIOC%s "
3473 "type 0x%01X, "
3474 "n. 0x%01X, "
3475 "dir. 0x%01X, "
3476 "size 0x%02X",
3477 V4L1_IOCTL(cmd),
3478 _IOC_TYPE(cmd),_IOC_NR(cmd),_IOC_DIR(cmd),_IOC_SIZE(cmd))
3479
3480 return -ENOIOCTLCMD;
3481
3482 } /* end of switch */
3483
3484 ioctl_fail:
3485 cam->misconfigured = 1;
3486 DBG(1, "VIDIOC%s failed because of hardware problems. "
3487 "To use the camera, close and open it again.", V4L1_IOCTL(cmd))
3488 return -EFAULT;
3489 }
3490
3491
3492 static struct file_operations w9968cf_fops = {
3493 .owner = THIS_MODULE,
3494 .open = w9968cf_open,
3495 .release = w9968cf_release,
3496 .read = w9968cf_read,
3497 .ioctl = w9968cf_ioctl,
3498 .mmap = w9968cf_mmap,
3499 .llseek = no_llseek,
3500 };
3501
3502
3503
3504 /****************************************************************************
3505 * USB probe and V4L registration, disconnect and id_table[] definition *
3506 ****************************************************************************/
3507
3508 static int
3509 w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
3510 {
3511 struct usb_device *udev = interface_to_usbdev(intf);
3512 struct w9968cf_device* cam;
3513 int err = 0;
3514 enum w9968cf_model_id mod_id;
3515 struct list_head* ptr;
3516 u8 sc = 0; /* number of simultaneous cameras */
3517 static unsigned short dev_nr = 0; /* we are handling device number n */
3518
3519 if (le16_to_cpu(udev->descriptor.idVendor) == winbond_id_table[0].idVendor &&
3520 le16_to_cpu(udev->descriptor.idProduct) == winbond_id_table[0].idProduct)
3521 mod_id = W9968CF_MOD_CLVBWGP; /* see camlist[] table */
3522 else if (le16_to_cpu(udev->descriptor.idVendor) == winbond_id_table[1].idVendor &&
3523 le16_to_cpu(udev->descriptor.idProduct) == winbond_id_table[1].idProduct)
3524 mod_id = W9968CF_MOD_GENERIC; /* see camlist[] table */
3525 else
3526 return -ENODEV;
3527
3528 cam = (struct w9968cf_device*)
3529 kmalloc(sizeof(struct w9968cf_device), GFP_KERNEL);
3530 if (!cam)
3531 return -ENOMEM;
3532
3533 memset(cam, 0, sizeof(*cam));
3534
3535 init_MUTEX(&cam->dev_sem);
3536 down(&cam->dev_sem);
3537
3538 cam->usbdev = udev;
3539 /* NOTE: a local copy is used to avoid possible race conditions */
3540 memcpy(&cam->dev, &udev->dev, sizeof(struct device));
3541
3542 DBG(2, "%s detected", symbolic(camlist, mod_id))
3543
3544 if (simcams > W9968CF_MAX_DEVICES)
3545 simcams = W9968CF_SIMCAMS;
3546
3547 /* How many cameras are connected ? */
3548 down(&w9968cf_devlist_sem);
3549 list_for_each(ptr, &w9968cf_dev_list)
3550 sc++;
3551 up(&w9968cf_devlist_sem);
3552
3553 if (sc >= simcams) {
3554 DBG(2, "Device rejected: too many connected cameras "
3555 "(max. %u)", simcams)
3556 err = -EPERM;
3557 goto fail;
3558 }
3559
3560
3561 /* Allocate 2 bytes of memory for camera control USB transfers */
3562 if (!(cam->control_buffer = (u16*)kmalloc(2, GFP_KERNEL))) {
3563 DBG(1,"Couldn't allocate memory for camera control transfers")
3564 err = -ENOMEM;
3565 goto fail;
3566 }
3567 memset(cam->control_buffer, 0, 2);
3568
3569 /* Allocate 8 bytes of memory for USB data transfers to the FSB */
3570 if (!(cam->data_buffer = (u16*)kmalloc(8, GFP_KERNEL))) {
3571 DBG(1, "Couldn't allocate memory for data "
3572 "transfers to the FSB")
3573 err = -ENOMEM;
3574 goto fail;
3575 }
3576 memset(cam->data_buffer, 0, 8);
3577
3578 /* Register the V4L device */
3579 cam->v4ldev = video_device_alloc();
3580 if (!cam->v4ldev) {
3581 DBG(1, "Could not allocate memory for a V4L structure")
3582 err = -ENOMEM;
3583 goto fail;
3584 }
3585
3586 strcpy(cam->v4ldev->name, symbolic(camlist, mod_id));
3587 cam->v4ldev->owner = THIS_MODULE;
3588 cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
3589 cam->v4ldev->hardware = VID_HARDWARE_W9968CF;
3590 cam->v4ldev->fops = &w9968cf_fops;
3591 cam->v4ldev->minor = video_nr[dev_nr];
3592 cam->v4ldev->release = video_device_release;
3593 video_set_drvdata(cam->v4ldev, cam);
3594 cam->v4ldev->dev = &cam->dev;
3595
3596 err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3597 video_nr[dev_nr]);
3598 if (err) {
3599 DBG(1, "V4L device registration failed")
3600 if (err == -ENFILE && video_nr[dev_nr] == -1)
3601 DBG(2, "Couldn't find a free /dev/videoX node")
3602 video_nr[dev_nr] = -1;
3603 dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
3604 goto fail;
3605 }
3606
3607 DBG(2, "V4L device registered as /dev/video%d", cam->v4ldev->minor)
3608
3609 /* Set some basic constants */
3610 w9968cf_configure_camera(cam, udev, mod_id, dev_nr);
3611
3612 /* Add a new entry into the list of V4L registered devices */
3613 down(&w9968cf_devlist_sem);
3614 list_add(&cam->v4llist, &w9968cf_dev_list);
3615 up(&w9968cf_devlist_sem);
3616 dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
3617
3618 w9968cf_turn_on_led(cam);
3619
3620 w9968cf_i2c_init(cam);
3621
3622 usb_set_intfdata(intf, cam);
3623 up(&cam->dev_sem);
3624 return 0;
3625
3626 fail: /* Free unused memory */
3627 kfree(cam->control_buffer);
3628 kfree(cam->data_buffer);
3629 if (cam->v4ldev)
3630 video_device_release(cam->v4ldev);
3631 up(&cam->dev_sem);
3632 kfree(cam);
3633 return err;
3634 }
3635
3636
3637 static void w9968cf_usb_disconnect(struct usb_interface* intf)
3638 {
3639 struct w9968cf_device* cam =
3640 (struct w9968cf_device*)usb_get_intfdata(intf);
3641
3642 down_write(&w9968cf_disconnect);
3643
3644 if (cam) {
3645 /* Prevent concurrent accesses to data */
3646 down(&cam->dev_sem);
3647
3648 cam->disconnected = 1;
3649
3650 DBG(2, "Disconnecting %s...", symbolic(camlist, cam->id))
3651
3652 wake_up_interruptible_all(&cam->open);
3653
3654 if (cam->users) {
3655 DBG(2, "The device is open (/dev/video%d)! "
3656 "Process name: %s. Deregistration and memory "
3657 "deallocation are deferred on close.",
3658 cam->v4ldev->minor, cam->command)
3659 cam->misconfigured = 1;
3660 w9968cf_stop_transfer(cam);
3661 wake_up_interruptible(&cam->wait_queue);
3662 } else
3663 w9968cf_release_resources(cam);
3664
3665 up(&cam->dev_sem);
3666
3667 if (!cam->users)
3668 kfree(cam);
3669 }
3670
3671 up_write(&w9968cf_disconnect);
3672 }
3673
3674
3675 static struct usb_driver w9968cf_usb_driver = {
3676 .owner = THIS_MODULE,
3677 .name = "w9968cf",
3678 .id_table = winbond_id_table,
3679 .probe = w9968cf_usb_probe,
3680 .disconnect = w9968cf_usb_disconnect,
3681 };
3682
3683
3684
3685 /****************************************************************************
3686 * Module init, exit and intermodule communication *
3687 ****************************************************************************/
3688
3689 static int w9968cf_vppmod_detect(struct w9968cf_device* cam)
3690 {
3691 if (!w9968cf_vpp)
3692 if (vppmod_load)
3693 request_module("w9968cf-vpp");
3694
3695 down(&w9968cf_vppmod_lock);
3696
3697 if (!w9968cf_vpp) {
3698 DBG(4, "Video post-processing module not detected")
3699 w9968cf_adjust_configuration(cam);
3700 goto out;
3701 }
3702
3703 if (!try_module_get(w9968cf_vpp->owner)) {
3704 DBG(1, "Couldn't increment the reference count of "
3705 "the video post-processing module")
3706 up(&w9968cf_vppmod_lock);
3707 return -ENOSYS;
3708 }
3709
3710 w9968cf_vpp->busy++;
3711
3712 DBG(5, "Video post-processing module detected")
3713
3714 out:
3715 up(&w9968cf_vppmod_lock);
3716 return 0;
3717 }
3718
3719
3720 static void w9968cf_vppmod_release(struct w9968cf_device* cam)
3721 {
3722 down(&w9968cf_vppmod_lock);
3723
3724 if (w9968cf_vpp && w9968cf_vpp->busy) {
3725 module_put(w9968cf_vpp->owner);
3726 w9968cf_vpp->busy--;
3727 wake_up(&w9968cf_vppmod_wait);
3728 DBG(5, "Video post-processing module released")
3729 }
3730
3731 up(&w9968cf_vppmod_lock);
3732 }
3733
3734
3735 int w9968cf_vppmod_register(struct w9968cf_vpp_t* vpp)
3736 {
3737 down(&w9968cf_vppmod_lock);
3738
3739 if (w9968cf_vpp) {
3740 KDBG(1, "Video post-processing module already registered")
3741 up(&w9968cf_vppmod_lock);
3742 return -EINVAL;
3743 }
3744
3745 w9968cf_vpp = vpp;
3746 w9968cf_vpp->busy = 0;
3747
3748 KDBG(2, "Video post-processing module registered")
3749 up(&w9968cf_vppmod_lock);
3750 return 0;
3751 }
3752
3753
3754 int w9968cf_vppmod_deregister(struct w9968cf_vpp_t* vpp)
3755 {
3756 down(&w9968cf_vppmod_lock);
3757
3758 if (!w9968cf_vpp) {
3759 up(&w9968cf_vppmod_lock);
3760 return -EINVAL;
3761 }
3762
3763 if (w9968cf_vpp != vpp) {
3764 KDBG(1, "Only the owner can unregister the video "
3765 "post-processing module")
3766 up(&w9968cf_vppmod_lock);
3767 return -EINVAL;
3768 }
3769
3770 if (w9968cf_vpp->busy) {
3771 KDBG(2, "Video post-processing module busy. Wait for it to be "
3772 "released...")
3773 up(&w9968cf_vppmod_lock);
3774 wait_event(w9968cf_vppmod_wait, !w9968cf_vpp->busy);
3775 w9968cf_vpp = NULL;
3776 goto out;
3777 }
3778
3779 w9968cf_vpp = NULL;
3780
3781 up(&w9968cf_vppmod_lock);
3782
3783 out:
3784 KDBG(2, "Video post-processing module unregistered")
3785 return 0;
3786 }
3787
3788
3789 static int __init w9968cf_module_init(void)
3790 {
3791 int err;
3792
3793 KDBG(2, W9968CF_MODULE_NAME" "W9968CF_MODULE_VERSION)
3794 KDBG(3, W9968CF_MODULE_AUTHOR)
3795
3796 if (ovmod_load)
3797 request_module("ovcamchip");
3798
3799 if ((err = usb_register(&w9968cf_usb_driver)))
3800 return err;
3801
3802 return 0;
3803 }
3804
3805
3806 static void __exit w9968cf_module_exit(void)
3807 {
3808 /* w9968cf_usb_disconnect() will be called */
3809 usb_deregister(&w9968cf_usb_driver);
3810
3811 KDBG(2, W9968CF_MODULE_NAME" deregistered")
3812 }
3813
3814
3815 module_init(w9968cf_module_init);
3816 module_exit(w9968cf_module_exit);
3817
3818
3819 EXPORT_SYMBOL(w9968cf_vppmod_register);
3820 EXPORT_SYMBOL(w9968cf_vppmod_deregister);
Verdex Pro support