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