Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ov534_9.c
Go to the documentation of this file.
1 /*
2  * ov534-ov9xxx gspca driver
3  *
4  * Copyright (C) 2009-2011 Jean-Francois Moine http://moinejf.free.fr
5  * Copyright (C) 2008 Antonio Ospite <[email protected]>
6  * Copyright (C) 2008 Jim Paris <[email protected]>
7  *
8  * Based on a prototype written by Mark Ferrell <[email protected]>
9  * USB protocol reverse engineered by Jim Paris <[email protected]>
10  * https://jim.sh/svn/jim/devl/playstation/ps3/eye/test/
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25  */
26 
27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28 
29 #define MODULE_NAME "ov534_9"
30 
31 #include "gspca.h"
32 
33 #define OV534_REG_ADDRESS 0xf1 /* sensor address */
34 #define OV534_REG_SUBADDR 0xf2
35 #define OV534_REG_WRITE 0xf3
36 #define OV534_REG_READ 0xf4
37 #define OV534_REG_OPERATION 0xf5
38 #define OV534_REG_STATUS 0xf6
39 
40 #define OV534_OP_WRITE_3 0x37
41 #define OV534_OP_WRITE_2 0x33
42 #define OV534_OP_READ_2 0xf9
43 
44 #define CTRL_TIMEOUT 500
45 
46 MODULE_AUTHOR("Jean-Francois Moine <[email protected]>");
47 MODULE_DESCRIPTION("GSPCA/OV534_9 USB Camera Driver");
48 MODULE_LICENSE("GPL");
49 
50 /* specific webcam descriptor */
51 struct sd {
52  struct gspca_dev gspca_dev; /* !! must be the first item */
55 
56  u8 sensor;
57 };
58 enum sensors {
59  SENSOR_OV965x, /* ov9657 */
60  SENSOR_OV971x, /* ov9712 */
61  SENSOR_OV562x, /* ov5621 */
63 };
64 
65 static const struct v4l2_pix_format ov965x_mode[] = {
66 #define QVGA_MODE 0
68  .bytesperline = 320,
69  .sizeimage = 320 * 240 * 3 / 8 + 590,
70  .colorspace = V4L2_COLORSPACE_JPEG},
71 #define VGA_MODE 1
73  .bytesperline = 640,
74  .sizeimage = 640 * 480 * 3 / 8 + 590,
75  .colorspace = V4L2_COLORSPACE_JPEG},
76 #define SVGA_MODE 2
78  .bytesperline = 800,
79  .sizeimage = 800 * 600 * 3 / 8 + 590,
80  .colorspace = V4L2_COLORSPACE_JPEG},
81 #define XGA_MODE 3
83  .bytesperline = 1024,
84  .sizeimage = 1024 * 768 * 3 / 8 + 590,
85  .colorspace = V4L2_COLORSPACE_JPEG},
86 #define SXGA_MODE 4
87  {1280, 1024, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
88  .bytesperline = 1280,
89  .sizeimage = 1280 * 1024 * 3 / 8 + 590,
90  .colorspace = V4L2_COLORSPACE_JPEG},
91 };
92 
93 static const struct v4l2_pix_format ov971x_mode[] = {
95  .bytesperline = 640,
96  .sizeimage = 640 * 480,
97  .colorspace = V4L2_COLORSPACE_SRGB
98  }
99 };
100 
101 static const struct v4l2_pix_format ov562x_mode[] = {
102  {2592, 1680, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
103  .bytesperline = 2592,
104  .sizeimage = 2592 * 1680,
105  .colorspace = V4L2_COLORSPACE_SRGB
106  }
107 };
108 
109 static const u8 bridge_init[][2] = {
110  {0x88, 0xf8},
111  {0x89, 0xff},
112  {0x76, 0x03},
113  {0x92, 0x03},
114  {0x95, 0x10},
115  {0xe2, 0x00},
116  {0xe7, 0x3e},
117  {0x8d, 0x1c},
118  {0x8e, 0x00},
119  {0x8f, 0x00},
120  {0x1f, 0x00},
121  {0xc3, 0xf9},
122  {0x89, 0xff},
123  {0x88, 0xf8},
124  {0x76, 0x03},
125  {0x92, 0x01},
126  {0x93, 0x18},
127  {0x1c, 0x0a},
128  {0x1d, 0x48},
129  {0xc0, 0x50},
130  {0xc1, 0x3c},
131  {0x34, 0x05},
132  {0xc2, 0x0c},
133  {0xc3, 0xf9},
134  {0x34, 0x05},
135  {0xe7, 0x2e},
136  {0x31, 0xf9},
137  {0x35, 0x02},
138  {0xd9, 0x10},
139  {0x25, 0x42},
140  {0x94, 0x11},
141 };
142 
143 static const u8 ov965x_init[][2] = {
144  {0x12, 0x80}, /* com7 - SSCB reset */
145  {0x00, 0x00}, /* gain */
146  {0x01, 0x80}, /* blue */
147  {0x02, 0x80}, /* red */
148  {0x03, 0x1b}, /* vref */
149  {0x04, 0x03}, /* com1 - exposure low bits */
150  {0x0b, 0x57}, /* ver */
151  {0x0e, 0x61}, /* com5 */
152  {0x0f, 0x42}, /* com6 */
153  {0x11, 0x00}, /* clkrc */
154  {0x12, 0x02}, /* com7 - 15fps VGA YUYV */
155  {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
156  {0x14, 0x28}, /* com9 */
157  {0x16, 0x24}, /* reg16 */
158  {0x17, 0x1d}, /* hstart*/
159  {0x18, 0xbd}, /* hstop */
160  {0x19, 0x01}, /* vstrt */
161  {0x1a, 0x81}, /* vstop*/
162  {0x1e, 0x04}, /* mvfp */
163  {0x24, 0x3c}, /* aew */
164  {0x25, 0x36}, /* aeb */
165  {0x26, 0x71}, /* vpt */
166  {0x27, 0x08}, /* bbias */
167  {0x28, 0x08}, /* gbbias */
168  {0x29, 0x15}, /* gr com */
169  {0x2a, 0x00}, /* exhch */
170  {0x2b, 0x00}, /* exhcl */
171  {0x2c, 0x08}, /* rbias */
172  {0x32, 0xff}, /* href */
173  {0x33, 0x00}, /* chlf */
174  {0x34, 0x3f}, /* aref1 */
175  {0x35, 0x00}, /* aref2 */
176  {0x36, 0xf8}, /* aref3 */
177  {0x38, 0x72}, /* adc2 */
178  {0x39, 0x57}, /* aref4 */
179  {0x3a, 0x80}, /* tslb - yuyv */
180  {0x3b, 0xc4}, /* com11 - night mode 1/4 frame rate */
181  {0x3d, 0x99}, /* com13 */
182  {0x3f, 0xc1}, /* edge */
183  {0x40, 0xc0}, /* com15 */
184  {0x41, 0x40}, /* com16 */
185  {0x42, 0xc0}, /* com17 */
186  {0x43, 0x0a}, /* rsvd */
187  {0x44, 0xf0},
188  {0x45, 0x46},
189  {0x46, 0x62},
190  {0x47, 0x2a},
191  {0x48, 0x3c},
192  {0x4a, 0xfc},
193  {0x4b, 0xfc},
194  {0x4c, 0x7f},
195  {0x4d, 0x7f},
196  {0x4e, 0x7f},
197  {0x4f, 0x98}, /* matrix */
198  {0x50, 0x98},
199  {0x51, 0x00},
200  {0x52, 0x28},
201  {0x53, 0x70},
202  {0x54, 0x98},
203  {0x58, 0x1a}, /* matrix coef sign */
204  {0x59, 0x85}, /* AWB control */
205  {0x5a, 0xa9},
206  {0x5b, 0x64},
207  {0x5c, 0x84},
208  {0x5d, 0x53},
209  {0x5e, 0x0e},
210  {0x5f, 0xf0}, /* AWB blue limit */
211  {0x60, 0xf0}, /* AWB red limit */
212  {0x61, 0xf0}, /* AWB green limit */
213  {0x62, 0x00}, /* lcc1 */
214  {0x63, 0x00}, /* lcc2 */
215  {0x64, 0x02}, /* lcc3 */
216  {0x65, 0x16}, /* lcc4 */
217  {0x66, 0x01}, /* lcc5 */
218  {0x69, 0x02}, /* hv */
219  {0x6b, 0x5a}, /* dbvl */
220  {0x6c, 0x04},
221  {0x6d, 0x55},
222  {0x6e, 0x00},
223  {0x6f, 0x9d},
224  {0x70, 0x21}, /* dnsth */
225  {0x71, 0x78},
226  {0x72, 0x00}, /* poidx */
227  {0x73, 0x01}, /* pckdv */
228  {0x74, 0x3a}, /* xindx */
229  {0x75, 0x35}, /* yindx */
230  {0x76, 0x01},
231  {0x77, 0x02},
232  {0x7a, 0x12}, /* gamma curve */
233  {0x7b, 0x08},
234  {0x7c, 0x16},
235  {0x7d, 0x30},
236  {0x7e, 0x5e},
237  {0x7f, 0x72},
238  {0x80, 0x82},
239  {0x81, 0x8e},
240  {0x82, 0x9a},
241  {0x83, 0xa4},
242  {0x84, 0xac},
243  {0x85, 0xb8},
244  {0x86, 0xc3},
245  {0x87, 0xd6},
246  {0x88, 0xe6},
247  {0x89, 0xf2},
248  {0x8a, 0x03},
249  {0x8c, 0x89}, /* com19 */
250  {0x14, 0x28}, /* com9 */
251  {0x90, 0x7d},
252  {0x91, 0x7b},
253  {0x9d, 0x03}, /* lcc6 */
254  {0x9e, 0x04}, /* lcc7 */
255  {0x9f, 0x7a},
256  {0xa0, 0x79},
257  {0xa1, 0x40}, /* aechm */
258  {0xa4, 0x50}, /* com21 */
259  {0xa5, 0x68}, /* com26 */
260  {0xa6, 0x4a}, /* AWB green */
261  {0xa8, 0xc1}, /* refa8 */
262  {0xa9, 0xef}, /* refa9 */
263  {0xaa, 0x92},
264  {0xab, 0x04},
265  {0xac, 0x80}, /* black level control */
266  {0xad, 0x80},
267  {0xae, 0x80},
268  {0xaf, 0x80},
269  {0xb2, 0xf2},
270  {0xb3, 0x20},
271  {0xb4, 0x20}, /* ctrlb4 */
272  {0xb5, 0x00},
273  {0xb6, 0xaf},
274  {0xbb, 0xae},
275  {0xbc, 0x7f}, /* ADC channel offsets */
276  {0xdb, 0x7f},
277  {0xbe, 0x7f},
278  {0xbf, 0x7f},
279  {0xc0, 0xe2},
280  {0xc1, 0xc0},
281  {0xc2, 0x01},
282  {0xc3, 0x4e},
283  {0xc6, 0x85},
284  {0xc7, 0x80}, /* com24 */
285  {0xc9, 0xe0},
286  {0xca, 0xe8},
287  {0xcb, 0xf0},
288  {0xcc, 0xd8},
289  {0xcd, 0xf1},
290  {0x4f, 0x98}, /* matrix */
291  {0x50, 0x98},
292  {0x51, 0x00},
293  {0x52, 0x28},
294  {0x53, 0x70},
295  {0x54, 0x98},
296  {0x58, 0x1a},
297  {0xff, 0x41}, /* read 41, write ff 00 */
298  {0x41, 0x40}, /* com16 */
299 
300  {0xc5, 0x03}, /* 60 Hz banding filter */
301  {0x6a, 0x02}, /* 50 Hz banding filter */
302 
303  {0x12, 0x62}, /* com7 - 30fps VGA YUV */
304  {0x36, 0xfa}, /* aref3 */
305  {0x69, 0x0a}, /* hv */
306  {0x8c, 0x89}, /* com22 */
307  {0x14, 0x28}, /* com9 */
308  {0x3e, 0x0c},
309  {0x41, 0x40}, /* com16 */
310  {0x72, 0x00},
311  {0x73, 0x00},
312  {0x74, 0x3a},
313  {0x75, 0x35},
314  {0x76, 0x01},
315  {0xc7, 0x80},
316  {0x03, 0x12}, /* vref */
317  {0x17, 0x16}, /* hstart */
318  {0x18, 0x02}, /* hstop */
319  {0x19, 0x01}, /* vstrt */
320  {0x1a, 0x3d}, /* vstop */
321  {0x32, 0xff}, /* href */
322  {0xc0, 0xaa},
323 };
324 
325 static const u8 bridge_init_2[][2] = {
326  {0x94, 0xaa},
327  {0xf1, 0x60},
328  {0xe5, 0x04},
329  {0xc0, 0x50},
330  {0xc1, 0x3c},
331  {0x8c, 0x00},
332  {0x8d, 0x1c},
333  {0x34, 0x05},
334 
335  {0xc2, 0x0c},
336  {0xc3, 0xf9},
337  {0xda, 0x01},
338  {0x50, 0x00},
339  {0x51, 0xa0},
340  {0x52, 0x3c},
341  {0x53, 0x00},
342  {0x54, 0x00},
343  {0x55, 0x00},
344  {0x57, 0x00},
345  {0x5c, 0x00},
346  {0x5a, 0xa0},
347  {0x5b, 0x78},
348  {0x35, 0x02},
349  {0xd9, 0x10},
350  {0x94, 0x11},
351 };
352 
353 static const u8 ov965x_init_2[][2] = {
354  {0x3b, 0xc4},
355  {0x1e, 0x04}, /* mvfp */
356  {0x13, 0xe0}, /* com8 */
357  {0x00, 0x00}, /* gain */
358  {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
359  {0x11, 0x03}, /* clkrc */
360  {0x6b, 0x5a}, /* dblv */
361  {0x6a, 0x05},
362  {0xc5, 0x07},
363  {0xa2, 0x4b},
364  {0xa3, 0x3e},
365  {0x2d, 0x00},
366  {0xff, 0x42}, /* read 42, write ff 00 */
367  {0x42, 0xc0}, /* com17 */
368  {0x2d, 0x00},
369  {0xff, 0x42}, /* read 42, write ff 00 */
370  {0x42, 0xc1}, /* com17 */
371 /* sharpness */
372  {0x3f, 0x01},
373  {0xff, 0x42}, /* read 42, write ff 00 */
374  {0x42, 0xc1}, /* com17 */
375 /* saturation */
376  {0x4f, 0x98}, /* matrix */
377  {0x50, 0x98},
378  {0x51, 0x00},
379  {0x52, 0x28},
380  {0x53, 0x70},
381  {0x54, 0x98},
382  {0x58, 0x1a},
383  {0xff, 0x41}, /* read 41, write ff 00 */
384  {0x41, 0x40}, /* com16 */
385 /* contrast */
386  {0x56, 0x40},
387 /* brightness */
388  {0x55, 0x8f},
389 /* expo */
390  {0x10, 0x25}, /* aech - exposure high bits */
391  {0xff, 0x13}, /* read 13, write ff 00 */
392  {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
393 };
394 
395 static const u8 ov971x_init[][2] = {
396  {0x12, 0x80},
397  {0x09, 0x10},
398  {0x1e, 0x07},
399  {0x5f, 0x18},
400  {0x69, 0x04},
401  {0x65, 0x2a},
402  {0x68, 0x0a},
403  {0x39, 0x28},
404  {0x4d, 0x90},
405  {0xc1, 0x80},
406  {0x0c, 0x30},
407  {0x6d, 0x02},
408  {0x96, 0xf1},
409  {0xbc, 0x68},
410  {0x12, 0x00},
411  {0x3b, 0x00},
412  {0x97, 0x80},
413  {0x17, 0x25},
414  {0x18, 0xa2},
415  {0x19, 0x01},
416  {0x1a, 0xca},
417  {0x03, 0x0a},
418  {0x32, 0x07},
419  {0x98, 0x40}, /*{0x98, 0x00},*/
420  {0x99, 0xA0}, /*{0x99, 0x00},*/
421  {0x9a, 0x01}, /*{0x9a, 0x00},*/
422  {0x57, 0x00},
423  {0x58, 0x78}, /*{0x58, 0xc8},*/
424  {0x59, 0x50}, /*{0x59, 0xa0},*/
425  {0x4c, 0x13},
426  {0x4b, 0x36},
427  {0x3d, 0x3c},
428  {0x3e, 0x03},
429  {0xbd, 0x50}, /*{0xbd, 0xa0},*/
430  {0xbe, 0x78}, /*{0xbe, 0xc8},*/
431  {0x4e, 0x55},
432  {0x4f, 0x55},
433  {0x50, 0x55},
434  {0x51, 0x55},
435  {0x24, 0x55},
436  {0x25, 0x40},
437  {0x26, 0xa1},
438  {0x5c, 0x59},
439  {0x5d, 0x00},
440  {0x11, 0x00},
441  {0x2a, 0x98},
442  {0x2b, 0x06},
443  {0x2d, 0x00},
444  {0x2e, 0x00},
445  {0x13, 0xa5},
446  {0x14, 0x40},
447  {0x4a, 0x00},
448  {0x49, 0xce},
449  {0x22, 0x03},
450  {0x09, 0x00}
451 };
452 
453 static const u8 ov965x_start_1_vga[][2] = { /* same for qvga */
454  {0x12, 0x62}, /* com7 - 30fps VGA YUV */
455  {0x36, 0xfa}, /* aref3 */
456  {0x69, 0x0a}, /* hv */
457  {0x8c, 0x89}, /* com22 */
458  {0x14, 0x28}, /* com9 */
459  {0x3e, 0x0c}, /* com14 */
460  {0x41, 0x40}, /* com16 */
461  {0x72, 0x00},
462  {0x73, 0x00},
463  {0x74, 0x3a},
464  {0x75, 0x35},
465  {0x76, 0x01},
466  {0xc7, 0x80}, /* com24 */
467  {0x03, 0x12}, /* vref */
468  {0x17, 0x16}, /* hstart */
469  {0x18, 0x02}, /* hstop */
470  {0x19, 0x01}, /* vstrt */
471  {0x1a, 0x3d}, /* vstop */
472  {0x32, 0xff}, /* href */
473  {0xc0, 0xaa},
474 };
475 
476 static const u8 ov965x_start_1_svga[][2] = {
477  {0x12, 0x02}, /* com7 - YUYV - VGA 15 full resolution */
478  {0x36, 0xf8}, /* aref3 */
479  {0x69, 0x02}, /* hv */
480  {0x8c, 0x0d}, /* com22 */
481  {0x3e, 0x0c}, /* com14 */
482  {0x41, 0x40}, /* com16 */
483  {0x72, 0x00},
484  {0x73, 0x01},
485  {0x74, 0x3a},
486  {0x75, 0x35},
487  {0x76, 0x01},
488  {0xc7, 0x80}, /* com24 */
489  {0x03, 0x1b}, /* vref */
490  {0x17, 0x1d}, /* hstart */
491  {0x18, 0xbd}, /* hstop */
492  {0x19, 0x01}, /* vstrt */
493  {0x1a, 0x81}, /* vstop */
494  {0x32, 0xff}, /* href */
495  {0xc0, 0xe2},
496 };
497 
498 static const u8 ov965x_start_1_xga[][2] = {
499  {0x12, 0x02}, /* com7 */
500  {0x36, 0xf8}, /* aref3 */
501  {0x69, 0x02}, /* hv */
502  {0x8c, 0x89}, /* com22 */
503  {0x14, 0x28}, /* com9 */
504  {0x3e, 0x0c}, /* com14 */
505  {0x41, 0x40}, /* com16 */
506  {0x72, 0x00},
507  {0x73, 0x01},
508  {0x74, 0x3a},
509  {0x75, 0x35},
510  {0x76, 0x01},
511  {0xc7, 0x80}, /* com24 */
512  {0x03, 0x1b}, /* vref */
513  {0x17, 0x1d}, /* hstart */
514  {0x18, 0xbd}, /* hstop */
515  {0x19, 0x01}, /* vstrt */
516  {0x1a, 0x81}, /* vstop */
517  {0x32, 0xff}, /* href */
518  {0xc0, 0xe2},
519 };
520 
521 static const u8 ov965x_start_1_sxga[][2] = {
522  {0x12, 0x02}, /* com7 */
523  {0x36, 0xf8}, /* aref3 */
524  {0x69, 0x02}, /* hv */
525  {0x8c, 0x89}, /* com22 */
526  {0x14, 0x28}, /* com9 */
527  {0x3e, 0x0c}, /* com14 */
528  {0x41, 0x40}, /* com16 */
529  {0x72, 0x00},
530  {0x73, 0x01},
531  {0x74, 0x3a},
532  {0x75, 0x35},
533  {0x76, 0x01},
534  {0xc7, 0x80}, /* com24 */
535  {0x03, 0x1b}, /* vref */
536  {0x17, 0x1d}, /* hstart */
537  {0x18, 0x02}, /* hstop */
538  {0x19, 0x01}, /* vstrt */
539  {0x1a, 0x81}, /* vstop */
540  {0x32, 0xff}, /* href */
541  {0xc0, 0xe2},
542 };
543 
544 static const u8 bridge_start_qvga[][2] = {
545  {0x94, 0xaa},
546  {0xf1, 0x60},
547  {0xe5, 0x04},
548  {0xc0, 0x50},
549  {0xc1, 0x3c},
550  {0x8c, 0x00},
551  {0x8d, 0x1c},
552  {0x34, 0x05},
553 
554  {0xc2, 0x4c},
555  {0xc3, 0xf9},
556  {0xda, 0x00},
557  {0x50, 0x00},
558  {0x51, 0xa0},
559  {0x52, 0x78},
560  {0x53, 0x00},
561  {0x54, 0x00},
562  {0x55, 0x00},
563  {0x57, 0x00},
564  {0x5c, 0x00},
565  {0x5a, 0x50},
566  {0x5b, 0x3c},
567  {0x35, 0x02},
568  {0xd9, 0x10},
569  {0x94, 0x11},
570 };
571 
572 static const u8 bridge_start_vga[][2] = {
573  {0x94, 0xaa},
574  {0xf1, 0x60},
575  {0xe5, 0x04},
576  {0xc0, 0x50},
577  {0xc1, 0x3c},
578  {0x8c, 0x00},
579  {0x8d, 0x1c},
580  {0x34, 0x05},
581  {0xc2, 0x0c},
582  {0xc3, 0xf9},
583  {0xda, 0x01},
584  {0x50, 0x00},
585  {0x51, 0xa0},
586  {0x52, 0x3c},
587  {0x53, 0x00},
588  {0x54, 0x00},
589  {0x55, 0x00},
590  {0x57, 0x00},
591  {0x5c, 0x00},
592  {0x5a, 0xa0},
593  {0x5b, 0x78},
594  {0x35, 0x02},
595  {0xd9, 0x10},
596  {0x94, 0x11},
597 };
598 
599 static const u8 bridge_start_svga[][2] = {
600  {0x94, 0xaa},
601  {0xf1, 0x60},
602  {0xe5, 0x04},
603  {0xc0, 0xa0},
604  {0xc1, 0x80},
605  {0x8c, 0x00},
606  {0x8d, 0x1c},
607  {0x34, 0x05},
608  {0xc2, 0x4c},
609  {0xc3, 0xf9},
610  {0x50, 0x00},
611  {0x51, 0x40},
612  {0x52, 0x00},
613  {0x53, 0x00},
614  {0x54, 0x00},
615  {0x55, 0x88},
616  {0x57, 0x00},
617  {0x5c, 0x00},
618  {0x5a, 0xc8},
619  {0x5b, 0x96},
620  {0x35, 0x02},
621  {0xd9, 0x10},
622  {0xda, 0x00},
623  {0x94, 0x11},
624 };
625 
626 static const u8 bridge_start_xga[][2] = {
627  {0x94, 0xaa},
628  {0xf1, 0x60},
629  {0xe5, 0x04},
630  {0xc0, 0xa0},
631  {0xc1, 0x80},
632  {0x8c, 0x00},
633  {0x8d, 0x1c},
634  {0x34, 0x05},
635  {0xc2, 0x4c},
636  {0xc3, 0xf9},
637  {0x50, 0x00},
638  {0x51, 0x40},
639  {0x52, 0x00},
640  {0x53, 0x00},
641  {0x54, 0x00},
642  {0x55, 0x88},
643  {0x57, 0x00},
644  {0x5c, 0x01},
645  {0x5a, 0x00},
646  {0x5b, 0xc0},
647  {0x35, 0x02},
648  {0xd9, 0x10},
649  {0xda, 0x01},
650  {0x94, 0x11},
651 };
652 
653 static const u8 bridge_start_sxga[][2] = {
654  {0x94, 0xaa},
655  {0xf1, 0x60},
656  {0xe5, 0x04},
657  {0xc0, 0xa0},
658  {0xc1, 0x80},
659  {0x8c, 0x00},
660  {0x8d, 0x1c},
661  {0x34, 0x05},
662  {0xc2, 0x0c},
663  {0xc3, 0xf9},
664  {0xda, 0x00},
665  {0x35, 0x02},
666  {0xd9, 0x10},
667  {0x94, 0x11},
668 };
669 
670 static const u8 ov965x_start_2_qvga[][2] = {
671  {0x3b, 0xe4}, /* com11 - night mode 1/4 frame rate */
672  {0x1e, 0x04}, /* mvfp */
673  {0x13, 0xe0}, /* com8 */
674  {0x00, 0x00},
675  {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
676  {0x11, 0x01}, /* clkrc */
677  {0x6b, 0x5a}, /* dblv */
678  {0x6a, 0x02}, /* 50 Hz banding filter */
679  {0xc5, 0x03}, /* 60 Hz banding filter */
680  {0xa2, 0x96}, /* bd50 */
681  {0xa3, 0x7d}, /* bd60 */
682 
683  {0xff, 0x13}, /* read 13, write ff 00 */
684  {0x13, 0xe7},
685  {0x3a, 0x80}, /* tslb - yuyv */
686 };
687 
688 static const u8 ov965x_start_2_vga[][2] = {
689  {0x3b, 0xc4}, /* com11 - night mode 1/4 frame rate */
690  {0x1e, 0x04}, /* mvfp */
691  {0x13, 0xe0}, /* com8 */
692  {0x00, 0x00},
693  {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
694  {0x11, 0x03}, /* clkrc */
695  {0x6b, 0x5a}, /* dblv */
696  {0x6a, 0x05}, /* 50 Hz banding filter */
697  {0xc5, 0x07}, /* 60 Hz banding filter */
698  {0xa2, 0x4b}, /* bd50 */
699  {0xa3, 0x3e}, /* bd60 */
700 
701  {0x2d, 0x00}, /* advfl */
702 };
703 
704 static const u8 ov965x_start_2_svga[][2] = { /* same for xga */
705  {0x3b, 0xc4}, /* com11 - night mode 1/4 frame rate */
706  {0x1e, 0x04}, /* mvfp */
707  {0x13, 0xe0}, /* com8 */
708  {0x00, 0x00},
709  {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
710  {0x11, 0x01}, /* clkrc */
711  {0x6b, 0x5a}, /* dblv */
712  {0x6a, 0x0c}, /* 50 Hz banding filter */
713  {0xc5, 0x0f}, /* 60 Hz banding filter */
714  {0xa2, 0x4e}, /* bd50 */
715  {0xa3, 0x41}, /* bd60 */
716 };
717 
718 static const u8 ov965x_start_2_sxga[][2] = {
719  {0x13, 0xe0}, /* com8 */
720  {0x00, 0x00},
721  {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
722  {0x3b, 0xc4}, /* com11 - night mode 1/4 frame rate */
723  {0x1e, 0x04}, /* mvfp */
724  {0x11, 0x01}, /* clkrc */
725  {0x6b, 0x5a}, /* dblv */
726  {0x6a, 0x0c}, /* 50 Hz banding filter */
727  {0xc5, 0x0f}, /* 60 Hz banding filter */
728  {0xa2, 0x4e}, /* bd50 */
729  {0xa3, 0x41}, /* bd60 */
730 };
731 
732 static const u8 ov562x_init[][2] = {
733  {0x88, 0x20},
734  {0x89, 0x0a},
735  {0x8a, 0x90},
736  {0x8b, 0x06},
737  {0x8c, 0x01},
738  {0x8d, 0x10},
739  {0x1c, 0x00},
740  {0x1d, 0x48},
741  {0x1d, 0x00},
742  {0x1d, 0xff},
743  {0x1c, 0x0a},
744  {0x1d, 0x2e},
745  {0x1d, 0x1e},
746 };
747 
748 static const u8 ov562x_init_2[][2] = {
749  {0x12, 0x80},
750  {0x11, 0x41},
751  {0x13, 0x00},
752  {0x10, 0x1e},
753  {0x3b, 0x07},
754  {0x5b, 0x40},
755  {0x39, 0x07},
756  {0x53, 0x02},
757  {0x54, 0x60},
758  {0x04, 0x20},
759  {0x27, 0x04},
760  {0x3d, 0x40},
761  {0x36, 0x00},
762  {0xc5, 0x04},
763  {0x4e, 0x00},
764  {0x4f, 0x93},
765  {0x50, 0x7b},
766  {0xca, 0x0c},
767  {0xcb, 0x0f},
768  {0x39, 0x07},
769  {0x4a, 0x10},
770  {0x3e, 0x0a},
771  {0x3d, 0x00},
772  {0x0c, 0x38},
773  {0x38, 0x90},
774  {0x46, 0x30},
775  {0x4f, 0x93},
776  {0x50, 0x7b},
777  {0xab, 0x00},
778  {0xca, 0x0c},
779  {0xcb, 0x0f},
780  {0x37, 0x02},
781  {0x44, 0x48},
782  {0x8d, 0x44},
783  {0x2a, 0x00},
784  {0x2b, 0x00},
785  {0x32, 0x00},
786  {0x38, 0x90},
787  {0x53, 0x02},
788  {0x54, 0x60},
789  {0x12, 0x00},
790  {0x17, 0x12},
791  {0x18, 0xb4},
792  {0x19, 0x0c},
793  {0x1a, 0xf4},
794  {0x03, 0x4a},
795  {0x89, 0x20},
796  {0x83, 0x80},
797  {0xb7, 0x9d},
798  {0xb6, 0x11},
799  {0xb5, 0x55},
800  {0xb4, 0x00},
801  {0xa9, 0xf0},
802  {0xa8, 0x0a},
803  {0xb8, 0xf0},
804  {0xb9, 0xf0},
805  {0xba, 0xf0},
806  {0x81, 0x07},
807  {0x63, 0x44},
808  {0x13, 0xc7},
809  {0x14, 0x60},
810  {0x33, 0x75},
811  {0x2c, 0x00},
812  {0x09, 0x00},
813  {0x35, 0x30},
814  {0x27, 0x04},
815  {0x3c, 0x07},
816  {0x3a, 0x0a},
817  {0x3b, 0x07},
818  {0x01, 0x40},
819  {0x02, 0x40},
820  {0x16, 0x40},
821  {0x52, 0xb0},
822  {0x51, 0x83},
823  {0x21, 0xbb},
824  {0x22, 0x10},
825  {0x23, 0x03},
826  {0x35, 0x38},
827  {0x20, 0x90},
828  {0x28, 0x30},
829  {0x73, 0xe1},
830  {0x6c, 0x00},
831  {0x6d, 0x80},
832  {0x6e, 0x00},
833  {0x70, 0x04},
834  {0x71, 0x00},
835  {0x8d, 0x04},
836  {0x64, 0x00},
837  {0x65, 0x00},
838  {0x66, 0x00},
839  {0x67, 0x00},
840  {0x68, 0x00},
841  {0x69, 0x00},
842  {0x6a, 0x00},
843  {0x6b, 0x00},
844  {0x71, 0x94},
845  {0x74, 0x20},
846  {0x80, 0x09},
847  {0x85, 0xc0},
848 };
849 
850 static void reg_w_i(struct gspca_dev *gspca_dev, u16 reg, u8 val)
851 {
852  struct usb_device *udev = gspca_dev->dev;
853  int ret;
854 
855  if (gspca_dev->usb_err < 0)
856  return;
857  gspca_dev->usb_buf[0] = val;
858  ret = usb_control_msg(udev,
859  usb_sndctrlpipe(udev, 0),
860  0x01,
862  0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
863  if (ret < 0) {
864  pr_err("reg_w failed %d\n", ret);
865  gspca_dev->usb_err = ret;
866  }
867 }
868 
869 static void reg_w(struct gspca_dev *gspca_dev, u16 reg, u8 val)
870 {
871  PDEBUG(D_USBO, "reg_w [%04x] = %02x", reg, val);
872  reg_w_i(gspca_dev, reg, val);
873 }
874 
875 static u8 reg_r(struct gspca_dev *gspca_dev, u16 reg)
876 {
877  struct usb_device *udev = gspca_dev->dev;
878  int ret;
879 
880  if (gspca_dev->usb_err < 0)
881  return 0;
882  ret = usb_control_msg(udev,
883  usb_rcvctrlpipe(udev, 0),
884  0x01,
886  0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
887  PDEBUG(D_USBI, "reg_r [%04x] -> %02x", reg, gspca_dev->usb_buf[0]);
888  if (ret < 0) {
889  pr_err("reg_r err %d\n", ret);
890  gspca_dev->usb_err = ret;
891  }
892  return gspca_dev->usb_buf[0];
893 }
894 
895 static int sccb_check_status(struct gspca_dev *gspca_dev)
896 {
897  u8 data;
898  int i;
899 
900  for (i = 0; i < 5; i++) {
901  msleep(10);
902  data = reg_r(gspca_dev, OV534_REG_STATUS);
903 
904  switch (data) {
905  case 0x00:
906  return 1;
907  case 0x04:
908  return 0;
909  case 0x03:
910  break;
911  default:
912  PDEBUG(D_USBI|D_USBO,
913  "sccb status 0x%02x, attempt %d/5",
914  data, i + 1);
915  }
916  }
917  return 0;
918 }
919 
920 static void sccb_write(struct gspca_dev *gspca_dev, u8 reg, u8 val)
921 {
922  PDEBUG(D_USBO, "sccb_write [%02x] = %02x", reg, val);
923  reg_w_i(gspca_dev, OV534_REG_SUBADDR, reg);
924  reg_w_i(gspca_dev, OV534_REG_WRITE, val);
925  reg_w_i(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_3);
926 
927  if (!sccb_check_status(gspca_dev))
928  pr_err("sccb_write failed\n");
929 }
930 
931 static u8 sccb_read(struct gspca_dev *gspca_dev, u16 reg)
932 {
933  reg_w(gspca_dev, OV534_REG_SUBADDR, reg);
934  reg_w(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_2);
935  if (!sccb_check_status(gspca_dev))
936  pr_err("sccb_read failed 1\n");
937 
938  reg_w(gspca_dev, OV534_REG_OPERATION, OV534_OP_READ_2);
939  if (!sccb_check_status(gspca_dev))
940  pr_err("sccb_read failed 2\n");
941 
942  return reg_r(gspca_dev, OV534_REG_READ);
943 }
944 
945 /* output a bridge sequence (reg - val) */
946 static void reg_w_array(struct gspca_dev *gspca_dev,
947  const u8 (*data)[2], int len)
948 {
949  while (--len >= 0) {
950  reg_w(gspca_dev, (*data)[0], (*data)[1]);
951  data++;
952  }
953 }
954 
955 /* output a sensor sequence (reg - val) */
956 static void sccb_w_array(struct gspca_dev *gspca_dev,
957  const u8 (*data)[2], int len)
958 {
959  while (--len >= 0) {
960  if ((*data)[0] != 0xff) {
961  sccb_write(gspca_dev, (*data)[0], (*data)[1]);
962  } else {
963  sccb_read(gspca_dev, (*data)[1]);
964  sccb_write(gspca_dev, 0xff, 0x00);
965  }
966  data++;
967  }
968 }
969 
970 /* Two bits control LED: 0x21 bit 7 and 0x23 bit 7.
971  * (direction and output)? */
972 static void set_led(struct gspca_dev *gspca_dev, int status)
973 {
974  u8 data;
975 
976  PDEBUG(D_CONF, "led status: %d", status);
977 
978  data = reg_r(gspca_dev, 0x21);
979  data |= 0x80;
980  reg_w(gspca_dev, 0x21, data);
981 
982  data = reg_r(gspca_dev, 0x23);
983  if (status)
984  data |= 0x80;
985  else
986  data &= ~0x80;
987 
988  reg_w(gspca_dev, 0x23, data);
989 
990  if (!status) {
991  data = reg_r(gspca_dev, 0x21);
992  data &= ~0x80;
993  reg_w(gspca_dev, 0x21, data);
994  }
995 }
996 
997 static void setbrightness(struct gspca_dev *gspca_dev, s32 brightness)
998 {
999  struct sd *sd = (struct sd *) gspca_dev;
1000  u8 val;
1001  s8 sval;
1002 
1003  if (sd->sensor == SENSOR_OV562x) {
1004  sval = brightness;
1005  val = 0x76;
1006  val += sval;
1007  sccb_write(gspca_dev, 0x24, val);
1008  val = 0x6a;
1009  val += sval;
1010  sccb_write(gspca_dev, 0x25, val);
1011  if (sval < -40)
1012  val = 0x71;
1013  else if (sval < 20)
1014  val = 0x94;
1015  else
1016  val = 0xe6;
1017  sccb_write(gspca_dev, 0x26, val);
1018  } else {
1019  val = brightness;
1020  if (val < 8)
1021  val = 15 - val; /* f .. 8 */
1022  else
1023  val = val - 8; /* 0 .. 7 */
1024  sccb_write(gspca_dev, 0x55, /* brtn - brightness adjustment */
1025  0x0f | (val << 4));
1026  }
1027 }
1028 
1029 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
1030 {
1031  sccb_write(gspca_dev, 0x56, /* cnst1 - contrast 1 ctrl coeff */
1032  val << 4);
1033 }
1034 
1035 static void setautogain(struct gspca_dev *gspca_dev, s32 autogain)
1036 {
1037  u8 val;
1038 
1039 /*fixme: should adjust agc/awb/aec by different controls */
1040  val = sccb_read(gspca_dev, 0x13); /* com8 */
1041  sccb_write(gspca_dev, 0xff, 0x00);
1042  if (autogain)
1043  val |= 0x05; /* agc & aec */
1044  else
1045  val &= 0xfa;
1046  sccb_write(gspca_dev, 0x13, val);
1047 }
1048 
1049 static void setexposure(struct gspca_dev *gspca_dev, s32 exposure)
1050 {
1051  static const u8 expo[4] = {0x00, 0x25, 0x38, 0x5e};
1052  u8 val;
1053 
1054  sccb_write(gspca_dev, 0x10, expo[exposure]); /* aec[9:2] */
1055 
1056  val = sccb_read(gspca_dev, 0x13); /* com8 */
1057  sccb_write(gspca_dev, 0xff, 0x00);
1058  sccb_write(gspca_dev, 0x13, val);
1059 
1060  val = sccb_read(gspca_dev, 0xa1); /* aech */
1061  sccb_write(gspca_dev, 0xff, 0x00);
1062  sccb_write(gspca_dev, 0xa1, val & 0xe0); /* aec[15:10] = 0 */
1063 }
1064 
1065 static void setsharpness(struct gspca_dev *gspca_dev, s32 val)
1066 {
1067  if (val < 0) { /* auto */
1068  val = sccb_read(gspca_dev, 0x42); /* com17 */
1069  sccb_write(gspca_dev, 0xff, 0x00);
1070  sccb_write(gspca_dev, 0x42, val | 0x40);
1071  /* Edge enhancement strength auto adjust */
1072  return;
1073  }
1074  if (val != 0)
1075  val = 1 << (val - 1);
1076  sccb_write(gspca_dev, 0x3f, /* edge - edge enhance. factor */
1077  val);
1078  val = sccb_read(gspca_dev, 0x42); /* com17 */
1079  sccb_write(gspca_dev, 0xff, 0x00);
1080  sccb_write(gspca_dev, 0x42, val & 0xbf);
1081 }
1082 
1083 static void setsatur(struct gspca_dev *gspca_dev, s32 val)
1084 {
1085  u8 val1, val2, val3;
1086  static const u8 matrix[5][2] = {
1087  {0x14, 0x38},
1088  {0x1e, 0x54},
1089  {0x28, 0x70},
1090  {0x32, 0x8c},
1091  {0x48, 0x90}
1092  };
1093 
1094  val1 = matrix[val][0];
1095  val2 = matrix[val][1];
1096  val3 = val1 + val2;
1097  sccb_write(gspca_dev, 0x4f, val3); /* matrix coeff */
1098  sccb_write(gspca_dev, 0x50, val3);
1099  sccb_write(gspca_dev, 0x51, 0x00);
1100  sccb_write(gspca_dev, 0x52, val1);
1101  sccb_write(gspca_dev, 0x53, val2);
1102  sccb_write(gspca_dev, 0x54, val3);
1103  sccb_write(gspca_dev, 0x58, 0x1a); /* mtxs - coeff signs */
1104 
1105  val1 = sccb_read(gspca_dev, 0x41); /* com16 */
1106  sccb_write(gspca_dev, 0xff, 0x00);
1107  sccb_write(gspca_dev, 0x41, val1);
1108 }
1109 
1110 static void setlightfreq(struct gspca_dev *gspca_dev, s32 freq)
1111 {
1112  u8 val;
1113 
1114  val = sccb_read(gspca_dev, 0x13); /* com8 */
1115  sccb_write(gspca_dev, 0xff, 0x00);
1116  if (freq == 0) {
1117  sccb_write(gspca_dev, 0x13, val & 0xdf);
1118  return;
1119  }
1120  sccb_write(gspca_dev, 0x13, val | 0x20);
1121 
1122  val = sccb_read(gspca_dev, 0x42); /* com17 */
1123  sccb_write(gspca_dev, 0xff, 0x00);
1124  if (freq == 1)
1125  val |= 0x01;
1126  else
1127  val &= 0xfe;
1128  sccb_write(gspca_dev, 0x42, val);
1129 }
1130 
1131 /* this function is called at probe time */
1132 static int sd_config(struct gspca_dev *gspca_dev,
1133  const struct usb_device_id *id)
1134 {
1135  return 0;
1136 }
1137 
1138 /* this function is called at probe and resume time */
1139 static int sd_init(struct gspca_dev *gspca_dev)
1140 {
1141  struct sd *sd = (struct sd *) gspca_dev;
1142  u16 sensor_id;
1143 
1144  /* reset bridge */
1145  reg_w(gspca_dev, 0xe7, 0x3a);
1146  reg_w(gspca_dev, 0xe0, 0x08);
1147  msleep(100);
1148 
1149  /* initialize the sensor address */
1150  reg_w(gspca_dev, OV534_REG_ADDRESS, 0x60);
1151 
1152  /* reset sensor */
1153  sccb_write(gspca_dev, 0x12, 0x80);
1154  msleep(10);
1155 
1156  /* probe the sensor */
1157  sccb_read(gspca_dev, 0x0a);
1158  sensor_id = sccb_read(gspca_dev, 0x0a) << 8;
1159  sccb_read(gspca_dev, 0x0b);
1160  sensor_id |= sccb_read(gspca_dev, 0x0b);
1161  PDEBUG(D_PROBE, "Sensor ID: %04x", sensor_id);
1162 
1163  /* initialize */
1164  if ((sensor_id & 0xfff0) == 0x9650) {
1165  sd->sensor = SENSOR_OV965x;
1166 
1167  gspca_dev->cam.cam_mode = ov965x_mode;
1168  gspca_dev->cam.nmodes = ARRAY_SIZE(ov965x_mode);
1169 
1170  reg_w_array(gspca_dev, bridge_init,
1171  ARRAY_SIZE(bridge_init));
1172  sccb_w_array(gspca_dev, ov965x_init,
1173  ARRAY_SIZE(ov965x_init));
1174  reg_w_array(gspca_dev, bridge_init_2,
1175  ARRAY_SIZE(bridge_init_2));
1176  sccb_w_array(gspca_dev, ov965x_init_2,
1177  ARRAY_SIZE(ov965x_init_2));
1178  reg_w(gspca_dev, 0xe0, 0x00);
1179  reg_w(gspca_dev, 0xe0, 0x01);
1180  set_led(gspca_dev, 0);
1181  reg_w(gspca_dev, 0xe0, 0x00);
1182  } else if ((sensor_id & 0xfff0) == 0x9710) {
1183  const char *p;
1184  int l;
1185 
1186  sd->sensor = SENSOR_OV971x;
1187 
1188  gspca_dev->cam.cam_mode = ov971x_mode;
1189  gspca_dev->cam.nmodes = ARRAY_SIZE(ov971x_mode);
1190 
1191  gspca_dev->cam.bulk = 1;
1192  gspca_dev->cam.bulk_size = 16384;
1193  gspca_dev->cam.bulk_nurbs = 2;
1194 
1195  sccb_w_array(gspca_dev, ov971x_init,
1196  ARRAY_SIZE(ov971x_init));
1197 
1198  /* set video format on bridge processor */
1199  /* access bridge processor's video format registers at: 0x00 */
1200  reg_w(gspca_dev, 0x1c, 0x00);
1201  /*set register: 0x00 is 'RAW8', 0x40 is 'YUV422' (YUYV?)*/
1202  reg_w(gspca_dev, 0x1d, 0x00);
1203 
1204  /* Will W. specific stuff
1205  * set VSYNC to
1206  * output (0x1f) if first webcam
1207  * input (0x17) if 2nd or 3rd webcam */
1208  p = video_device_node_name(&gspca_dev->vdev);
1209  l = strlen(p) - 1;
1210  if (p[l] == '0')
1211  reg_w(gspca_dev, 0x56, 0x1f);
1212  else
1213  reg_w(gspca_dev, 0x56, 0x17);
1214  } else if ((sensor_id & 0xfff0) == 0x5620) {
1215  sd->sensor = SENSOR_OV562x;
1216  gspca_dev->cam.cam_mode = ov562x_mode;
1217  gspca_dev->cam.nmodes = ARRAY_SIZE(ov562x_mode);
1218 
1219  reg_w_array(gspca_dev, ov562x_init,
1220  ARRAY_SIZE(ov562x_init));
1221  sccb_w_array(gspca_dev, ov562x_init_2,
1222  ARRAY_SIZE(ov562x_init_2));
1223  reg_w(gspca_dev, 0xe0, 0x00);
1224  } else {
1225  pr_err("Unknown sensor %04x", sensor_id);
1226  return -EINVAL;
1227  }
1228 
1229  return gspca_dev->usb_err;
1230 }
1231 
1232 static int sd_start(struct gspca_dev *gspca_dev)
1233 {
1234  struct sd *sd = (struct sd *) gspca_dev;
1235 
1236  if (sd->sensor == SENSOR_OV971x)
1237  return gspca_dev->usb_err;
1238  if (sd->sensor == SENSOR_OV562x)
1239  return gspca_dev->usb_err;
1240 
1241  switch (gspca_dev->curr_mode) {
1242  case QVGA_MODE: /* 320x240 */
1243  sccb_w_array(gspca_dev, ov965x_start_1_vga,
1244  ARRAY_SIZE(ov965x_start_1_vga));
1245  reg_w_array(gspca_dev, bridge_start_qvga,
1246  ARRAY_SIZE(bridge_start_qvga));
1247  sccb_w_array(gspca_dev, ov965x_start_2_qvga,
1248  ARRAY_SIZE(ov965x_start_2_qvga));
1249  break;
1250  case VGA_MODE: /* 640x480 */
1251  sccb_w_array(gspca_dev, ov965x_start_1_vga,
1252  ARRAY_SIZE(ov965x_start_1_vga));
1253  reg_w_array(gspca_dev, bridge_start_vga,
1254  ARRAY_SIZE(bridge_start_vga));
1255  sccb_w_array(gspca_dev, ov965x_start_2_vga,
1256  ARRAY_SIZE(ov965x_start_2_vga));
1257  break;
1258  case SVGA_MODE: /* 800x600 */
1259  sccb_w_array(gspca_dev, ov965x_start_1_svga,
1260  ARRAY_SIZE(ov965x_start_1_svga));
1261  reg_w_array(gspca_dev, bridge_start_svga,
1262  ARRAY_SIZE(bridge_start_svga));
1263  sccb_w_array(gspca_dev, ov965x_start_2_svga,
1264  ARRAY_SIZE(ov965x_start_2_svga));
1265  break;
1266  case XGA_MODE: /* 1024x768 */
1267  sccb_w_array(gspca_dev, ov965x_start_1_xga,
1268  ARRAY_SIZE(ov965x_start_1_xga));
1269  reg_w_array(gspca_dev, bridge_start_xga,
1270  ARRAY_SIZE(bridge_start_xga));
1271  sccb_w_array(gspca_dev, ov965x_start_2_svga,
1272  ARRAY_SIZE(ov965x_start_2_svga));
1273  break;
1274  default:
1275 /* case SXGA_MODE: * 1280x1024 */
1276  sccb_w_array(gspca_dev, ov965x_start_1_sxga,
1277  ARRAY_SIZE(ov965x_start_1_sxga));
1278  reg_w_array(gspca_dev, bridge_start_sxga,
1279  ARRAY_SIZE(bridge_start_sxga));
1280  sccb_w_array(gspca_dev, ov965x_start_2_sxga,
1281  ARRAY_SIZE(ov965x_start_2_sxga));
1282  break;
1283  }
1284 
1285  reg_w(gspca_dev, 0xe0, 0x00);
1286  reg_w(gspca_dev, 0xe0, 0x00);
1287  set_led(gspca_dev, 1);
1288  return gspca_dev->usb_err;
1289 }
1290 
1291 static void sd_stopN(struct gspca_dev *gspca_dev)
1292 {
1293  reg_w(gspca_dev, 0xe0, 0x01);
1294  set_led(gspca_dev, 0);
1295  reg_w(gspca_dev, 0xe0, 0x00);
1296 }
1297 
1298 /* Values for bmHeaderInfo (Video and Still Image Payload Headers, 2.4.3.3) */
1299 #define UVC_STREAM_EOH (1 << 7)
1300 #define UVC_STREAM_ERR (1 << 6)
1301 #define UVC_STREAM_STI (1 << 5)
1302 #define UVC_STREAM_RES (1 << 4)
1303 #define UVC_STREAM_SCR (1 << 3)
1304 #define UVC_STREAM_PTS (1 << 2)
1305 #define UVC_STREAM_EOF (1 << 1)
1306 #define UVC_STREAM_FID (1 << 0)
1307 
1308 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1309  u8 *data, int len)
1310 {
1311  struct sd *sd = (struct sd *) gspca_dev;
1312  __u32 this_pts;
1313  u8 this_fid;
1314  int remaining_len = len;
1315  int payload_len;
1316 
1317  payload_len = gspca_dev->cam.bulk ? 2048 : 2040;
1318  do {
1319  len = min(remaining_len, payload_len);
1320 
1321  /* Payloads are prefixed with a UVC-style header. We
1322  consider a frame to start when the FID toggles, or the PTS
1323  changes. A frame ends when EOF is set, and we've received
1324  the correct number of bytes. */
1325 
1326  /* Verify UVC header. Header length is always 12 */
1327  if (data[0] != 12 || len < 12) {
1328  PDEBUG(D_PACK, "bad header");
1329  goto discard;
1330  }
1331 
1332  /* Check errors */
1333  if (data[1] & UVC_STREAM_ERR) {
1334  PDEBUG(D_PACK, "payload error");
1335  goto discard;
1336  }
1337 
1338  /* Extract PTS and FID */
1339  if (!(data[1] & UVC_STREAM_PTS)) {
1340  PDEBUG(D_PACK, "PTS not present");
1341  goto discard;
1342  }
1343  this_pts = (data[5] << 24) | (data[4] << 16)
1344  | (data[3] << 8) | data[2];
1345  this_fid = data[1] & UVC_STREAM_FID;
1346 
1347  /* If PTS or FID has changed, start a new frame. */
1348  if (this_pts != sd->last_pts || this_fid != sd->last_fid) {
1349  if (gspca_dev->last_packet_type == INTER_PACKET)
1350  gspca_frame_add(gspca_dev, LAST_PACKET,
1351  NULL, 0);
1352  sd->last_pts = this_pts;
1353  sd->last_fid = this_fid;
1354  gspca_frame_add(gspca_dev, FIRST_PACKET,
1355  data + 12, len - 12);
1356  /* If this packet is marked as EOF, end the frame */
1357  } else if (data[1] & UVC_STREAM_EOF) {
1358  sd->last_pts = 0;
1359  gspca_frame_add(gspca_dev, LAST_PACKET,
1360  data + 12, len - 12);
1361  } else {
1362 
1363  /* Add the data from this payload */
1364  gspca_frame_add(gspca_dev, INTER_PACKET,
1365  data + 12, len - 12);
1366  }
1367 
1368  /* Done this payload */
1369  goto scan_next;
1370 
1371 discard:
1372  /* Discard data until a new frame starts. */
1373  gspca_dev->last_packet_type = DISCARD_PACKET;
1374 
1375 scan_next:
1376  remaining_len -= len;
1377  data += len;
1378  } while (remaining_len > 0);
1379 }
1380 
1381 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
1382 {
1383  struct gspca_dev *gspca_dev =
1384  container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
1385 
1386  gspca_dev->usb_err = 0;
1387 
1388  if (!gspca_dev->streaming)
1389  return 0;
1390 
1391  switch (ctrl->id) {
1392  case V4L2_CID_BRIGHTNESS:
1393  setbrightness(gspca_dev, ctrl->val);
1394  break;
1395  case V4L2_CID_CONTRAST:
1396  setcontrast(gspca_dev, ctrl->val);
1397  break;
1398  case V4L2_CID_SATURATION:
1399  setsatur(gspca_dev, ctrl->val);
1400  break;
1402  setlightfreq(gspca_dev, ctrl->val);
1403  break;
1404  case V4L2_CID_SHARPNESS:
1405  setsharpness(gspca_dev, ctrl->val);
1406  break;
1407  case V4L2_CID_AUTOGAIN:
1408  if (ctrl->is_new)
1409  setautogain(gspca_dev, ctrl->val);
1410  if (!ctrl->val && gspca_dev->exposure->is_new)
1411  setexposure(gspca_dev, gspca_dev->exposure->val);
1412  break;
1413  }
1414  return gspca_dev->usb_err;
1415 }
1416 
1417 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
1418  .s_ctrl = sd_s_ctrl,
1419 };
1420 
1421 static int sd_init_controls(struct gspca_dev *gspca_dev)
1422 {
1423  struct sd *sd = (struct sd *)gspca_dev;
1424  struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1425 
1426  if (sd->sensor == SENSOR_OV971x)
1427  return 0;
1428  gspca_dev->vdev.ctrl_handler = hdl;
1429  v4l2_ctrl_handler_init(hdl, 7);
1430  if (sd->sensor == SENSOR_OV562x) {
1431  v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1432  V4L2_CID_BRIGHTNESS, -90, 90, 1, 0);
1433  } else {
1434  v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1435  V4L2_CID_BRIGHTNESS, 0, 15, 1, 7);
1436  v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1437  V4L2_CID_CONTRAST, 0, 15, 1, 3);
1438  v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1439  V4L2_CID_SATURATION, 0, 4, 1, 2);
1440  /* -1 = auto */
1441  v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1442  V4L2_CID_SHARPNESS, -1, 4, 1, -1);
1443  gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1444  V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1445  gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1446  V4L2_CID_EXPOSURE, 0, 3, 1, 0);
1447  v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
1450  v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
1451  }
1452 
1453  if (hdl->error) {
1454  pr_err("Could not initialize controls\n");
1455  return hdl->error;
1456  }
1457  return 0;
1458 }
1459 
1460 /* sub-driver description */
1461 static const struct sd_desc sd_desc = {
1462  .name = MODULE_NAME,
1463  .config = sd_config,
1464  .init = sd_init,
1465  .init_controls = sd_init_controls,
1466  .start = sd_start,
1467  .stopN = sd_stopN,
1468  .pkt_scan = sd_pkt_scan,
1469 };
1470 
1471 /* -- module initialisation -- */
1472 static const struct usb_device_id device_table[] = {
1473  {USB_DEVICE(0x05a9, 0x8065)},
1474  {USB_DEVICE(0x06f8, 0x3003)},
1475  {USB_DEVICE(0x05a9, 0x1550)},
1476  {}
1477 };
1478 
1479 MODULE_DEVICE_TABLE(usb, device_table);
1480 
1481 /* -- device connect -- */
1482 static int sd_probe(struct usb_interface *intf, const struct usb_device_id *id)
1483 {
1484  return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1485  THIS_MODULE);
1486 }
1487 
1488 static struct usb_driver sd_driver = {
1489  .name = MODULE_NAME,
1490  .id_table = device_table,
1491  .probe = sd_probe,
1492  .disconnect = gspca_disconnect,
1493 #ifdef CONFIG_PM
1494  .suspend = gspca_suspend,
1495  .resume = gspca_resume,
1496  .reset_resume = gspca_resume,
1497 #endif
1498 };
1499 
1500 module_usb_driver(sd_driver);