?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add linux-next specific files for 20110831
[linux-2.6/next.git] / drivers / media / video / gspca / ov534.c
blob0c6369b7fe1892e0fcae05608587e8cd4999f333
1 /*
2 * ov534-ov7xxx gspca driver
3 *
4 * Copyright (C) 2008 Antonio Ospite <ospite@studenti.unina.it>
5 * Copyright (C) 2008 Jim Paris <jim@jtan.com>
6 * Copyright (C) 2009 Jean-Francois Moine http://moinejf.free.fr
7 *
8 * Based on a prototype written by Mark Ferrell <majortrips@gmail.com>
9 * USB protocol reverse engineered by Jim Paris <jim@jtan.com>
10 * https://jim.sh/svn/jim/devl/playstation/ps3/eye/test/
11 *
12 * PS3 Eye camera enhanced by Richard Kaswy http://kaswy.free.fr
13 * PS3 Eye camera - brightness, contrast, awb, agc, aec controls
14 * added by Max Thrun <bear24rw@gmail.com>
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 */
30
31 #define MODULE_NAME "ov534"
32
33 #include "gspca.h"
34
35 #define OV534_REG_ADDRESS 0xf1 /* sensor address */
36 #define OV534_REG_SUBADDR 0xf2
37 #define OV534_REG_WRITE 0xf3
38 #define OV534_REG_READ 0xf4
39 #define OV534_REG_OPERATION 0xf5
40 #define OV534_REG_STATUS 0xf6
41
42 #define OV534_OP_WRITE_3 0x37
43 #define OV534_OP_WRITE_2 0x33
44 #define OV534_OP_READ_2 0xf9
45
46 #define CTRL_TIMEOUT 500
47
48 MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
49 MODULE_DESCRIPTION("GSPCA/OV534 USB Camera Driver");
50 MODULE_LICENSE("GPL");
51
52 /* controls */
53 enum e_ctrl {
54 BRIGHTNESS,
55 CONTRAST,
56 GAIN,
57 EXPOSURE,
58 AGC,
59 AWB,
60 AEC,
61 SHARPNESS,
62 HFLIP,
63 VFLIP,
64 COLORS,
65 LIGHTFREQ,
66 NCTRLS /* number of controls */
67 };
68
69 /* specific webcam descriptor */
70 struct sd {
71 struct gspca_dev gspca_dev; /* !! must be the first item */
72
73 struct gspca_ctrl ctrls[NCTRLS];
74
75 __u32 last_pts;
76 u16 last_fid;
77 u8 frame_rate;
78
79 u8 sensor;
80 };
81 enum sensors {
82 SENSOR_OV767x,
83 SENSOR_OV772x,
84 NSENSORS
85 };
86
87 /* V4L2 controls supported by the driver */
88 static void setbrightness(struct gspca_dev *gspca_dev);
89 static void setcontrast(struct gspca_dev *gspca_dev);
90 static void setgain(struct gspca_dev *gspca_dev);
91 static void setexposure(struct gspca_dev *gspca_dev);
92 static int sd_setagc(struct gspca_dev *gspca_dev, __s32 val);
93 static void setawb(struct gspca_dev *gspca_dev);
94 static void setaec(struct gspca_dev *gspca_dev);
95 static void setsharpness(struct gspca_dev *gspca_dev);
96 static void sethvflip(struct gspca_dev *gspca_dev);
97 static void setcolors(struct gspca_dev *gspca_dev);
98 static void setlightfreq(struct gspca_dev *gspca_dev);
99
100 static int sd_start(struct gspca_dev *gspca_dev);
101 static void sd_stopN(struct gspca_dev *gspca_dev);
102
103 static const struct ctrl sd_ctrls[] = {
104 [BRIGHTNESS] = {
105 {
106 .id = V4L2_CID_BRIGHTNESS,
107 .type = V4L2_CTRL_TYPE_INTEGER,
108 .name = "Brightness",
109 .minimum = 0,
110 .maximum = 255,
111 .step = 1,
112 .default_value = 0,
113 },
114 .set_control = setbrightness
115 },
116 [CONTRAST] = {
117 {
118 .id = V4L2_CID_CONTRAST,
119 .type = V4L2_CTRL_TYPE_INTEGER,
120 .name = "Contrast",
121 .minimum = 0,
122 .maximum = 255,
123 .step = 1,
124 .default_value = 32,
125 },
126 .set_control = setcontrast
127 },
128 [GAIN] = {
129 {
130 .id = V4L2_CID_GAIN,
131 .type = V4L2_CTRL_TYPE_INTEGER,
132 .name = "Main Gain",
133 .minimum = 0,
134 .maximum = 63,
135 .step = 1,
136 .default_value = 20,
137 },
138 .set_control = setgain
139 },
140 [EXPOSURE] = {
141 {
142 .id = V4L2_CID_EXPOSURE,
143 .type = V4L2_CTRL_TYPE_INTEGER,
144 .name = "Exposure",
145 .minimum = 0,
146 .maximum = 255,
147 .step = 1,
148 .default_value = 120,
149 },
150 .set_control = setexposure
151 },
152 [AGC] = {
153 {
154 .id = V4L2_CID_AUTOGAIN,
155 .type = V4L2_CTRL_TYPE_BOOLEAN,
156 .name = "Auto Gain",
157 .minimum = 0,
158 .maximum = 1,
159 .step = 1,
160 .default_value = 1,
161 },
162 .set = sd_setagc
163 },
164 [AWB] = {
165 {
166 .id = V4L2_CID_AUTO_WHITE_BALANCE,
167 .type = V4L2_CTRL_TYPE_BOOLEAN,
168 .name = "Auto White Balance",
169 .minimum = 0,
170 .maximum = 1,
171 .step = 1,
172 .default_value = 1,
173 },
174 .set_control = setawb
175 },
176 [AEC] = {
177 {
178 .id = V4L2_CID_EXPOSURE_AUTO,
179 .type = V4L2_CTRL_TYPE_BOOLEAN,
180 .name = "Auto Exposure",
181 .minimum = 0,
182 .maximum = 1,
183 .step = 1,
184 .default_value = 1,
185 },
186 .set_control = setaec
187 },
188 [SHARPNESS] = {
189 {
190 .id = V4L2_CID_SHARPNESS,
191 .type = V4L2_CTRL_TYPE_INTEGER,
192 .name = "Sharpness",
193 .minimum = 0,
194 .maximum = 63,
195 .step = 1,
196 .default_value = 0,
197 },
198 .set_control = setsharpness
199 },
200 [HFLIP] = {
201 {
202 .id = V4L2_CID_HFLIP,
203 .type = V4L2_CTRL_TYPE_BOOLEAN,
204 .name = "HFlip",
205 .minimum = 0,
206 .maximum = 1,
207 .step = 1,
208 .default_value = 0,
209 },
210 .set_control = sethvflip
211 },
212 [VFLIP] = {
213 {
214 .id = V4L2_CID_VFLIP,
215 .type = V4L2_CTRL_TYPE_BOOLEAN,
216 .name = "VFlip",
217 .minimum = 0,
218 .maximum = 1,
219 .step = 1,
220 .default_value = 0,
221 },
222 .set_control = sethvflip
223 },
224 [COLORS] = {
225 {
226 .id = V4L2_CID_SATURATION,
227 .type = V4L2_CTRL_TYPE_INTEGER,
228 .name = "Saturation",
229 .minimum = 0,
230 .maximum = 6,
231 .step = 1,
232 .default_value = 3,
233 },
234 .set_control = setcolors
235 },
236 [LIGHTFREQ] = {
237 {
238 .id = V4L2_CID_POWER_LINE_FREQUENCY,
239 .type = V4L2_CTRL_TYPE_MENU,
240 .name = "Light Frequency Filter",
241 .minimum = 0,
242 .maximum = 1,
243 .step = 1,
244 .default_value = 0,
245 },
246 .set_control = setlightfreq
247 },
248 };
249
250 static const struct v4l2_pix_format ov772x_mode[] = {
251 {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
252 .bytesperline = 320 * 2,
253 .sizeimage = 320 * 240 * 2,
254 .colorspace = V4L2_COLORSPACE_SRGB,
255 .priv = 1},
256 {640, 480, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
257 .bytesperline = 640 * 2,
258 .sizeimage = 640 * 480 * 2,
259 .colorspace = V4L2_COLORSPACE_SRGB,
260 .priv = 0},
261 };
262 static const struct v4l2_pix_format ov767x_mode[] = {
263 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
264 .bytesperline = 320,
265 .sizeimage = 320 * 240 * 3 / 8 + 590,
266 .colorspace = V4L2_COLORSPACE_JPEG},
267 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
268 .bytesperline = 640,
269 .sizeimage = 640 * 480 * 3 / 8 + 590,
270 .colorspace = V4L2_COLORSPACE_JPEG},
271 };
272
273 static const u8 qvga_rates[] = {125, 100, 75, 60, 50, 40, 30};
274 static const u8 vga_rates[] = {60, 50, 40, 30, 15};
275
276 static const struct framerates ov772x_framerates[] = {
277 { /* 320x240 */
278 .rates = qvga_rates,
279 .nrates = ARRAY_SIZE(qvga_rates),
280 },
281 { /* 640x480 */
282 .rates = vga_rates,
283 .nrates = ARRAY_SIZE(vga_rates),
284 },
285 };
286
287 struct reg_array {
288 const u8 (*val)[2];
289 int len;
290 };
291
292 static const u8 bridge_init_767x[][2] = {
293 /* comments from the ms-win file apollo7670.set */
294 /* str1 */
295 {0xf1, 0x42},
296 {0x88, 0xf8},
297 {0x89, 0xff},
298 {0x76, 0x03},
299 {0x92, 0x03},
300 {0x95, 0x10},
301 {0xe2, 0x00},
302 {0xe7, 0x3e},
303 {0x8d, 0x1c},
304 {0x8e, 0x00},
305 {0x8f, 0x00},
306 {0x1f, 0x00},
307 {0xc3, 0xf9},
308 {0x89, 0xff},
309 {0x88, 0xf8},
310 {0x76, 0x03},
311 {0x92, 0x01},
312 {0x93, 0x18},
313 {0x1c, 0x00},
314 {0x1d, 0x48},
315 {0x1d, 0x00},
316 {0x1d, 0xff},
317 {0x1d, 0x02},
318 {0x1d, 0x58},
319 {0x1d, 0x00},
320 {0x1c, 0x0a},
321 {0x1d, 0x0a},
322 {0x1d, 0x0e},
323 {0xc0, 0x50}, /* HSize 640 */
324 {0xc1, 0x3c}, /* VSize 480 */
325 {0x34, 0x05}, /* enable Audio Suspend mode */
326 {0xc2, 0x0c}, /* Input YUV */
327 {0xc3, 0xf9}, /* enable PRE */
328 {0x34, 0x05}, /* enable Audio Suspend mode */
329 {0xe7, 0x2e}, /* this solves failure of "SuspendResumeTest" */
330 {0x31, 0xf9}, /* enable 1.8V Suspend */
331 {0x35, 0x02}, /* turn on JPEG */
332 {0xd9, 0x10},
333 {0x25, 0x42}, /* GPIO[8]:Input */
334 {0x94, 0x11}, /* If the default setting is loaded when
335 * system boots up, this flag is closed here */
336 };
337 static const u8 sensor_init_767x[][2] = {
338 {0x12, 0x80},
339 {0x11, 0x03},
340 {0x3a, 0x04},
341 {0x12, 0x00},
342 {0x17, 0x13},
343 {0x18, 0x01},
344 {0x32, 0xb6},
345 {0x19, 0x02},
346 {0x1a, 0x7a},
347 {0x03, 0x0a},
348 {0x0c, 0x00},
349 {0x3e, 0x00},
350 {0x70, 0x3a},
351 {0x71, 0x35},
352 {0x72, 0x11},
353 {0x73, 0xf0},
354 {0xa2, 0x02},
355 {0x7a, 0x2a}, /* set Gamma=1.6 below */
356 {0x7b, 0x12},
357 {0x7c, 0x1d},
358 {0x7d, 0x2d},
359 {0x7e, 0x45},
360 {0x7f, 0x50},
361 {0x80, 0x59},
362 {0x81, 0x62},
363 {0x82, 0x6b},
364 {0x83, 0x73},
365 {0x84, 0x7b},
366 {0x85, 0x8a},
367 {0x86, 0x98},
368 {0x87, 0xb2},
369 {0x88, 0xca},
370 {0x89, 0xe0},
371 {0x13, 0xe0},
372 {0x00, 0x00},
373 {0x10, 0x00},
374 {0x0d, 0x40},
375 {0x14, 0x38}, /* gain max 16x */
376 {0xa5, 0x05},
377 {0xab, 0x07},
378 {0x24, 0x95},
379 {0x25, 0x33},
380 {0x26, 0xe3},
381 {0x9f, 0x78},
382 {0xa0, 0x68},
383 {0xa1, 0x03},
384 {0xa6, 0xd8},
385 {0xa7, 0xd8},
386 {0xa8, 0xf0},
387 {0xa9, 0x90},
388 {0xaa, 0x94},
389 {0x13, 0xe5},
390 {0x0e, 0x61},
391 {0x0f, 0x4b},
392 {0x16, 0x02},
393 {0x21, 0x02},
394 {0x22, 0x91},
395 {0x29, 0x07},
396 {0x33, 0x0b},
397 {0x35, 0x0b},
398 {0x37, 0x1d},
399 {0x38, 0x71},
400 {0x39, 0x2a},
401 {0x3c, 0x78},
402 {0x4d, 0x40},
403 {0x4e, 0x20},
404 {0x69, 0x00},
405 {0x6b, 0x4a},
406 {0x74, 0x10},
407 {0x8d, 0x4f},
408 {0x8e, 0x00},
409 {0x8f, 0x00},
410 {0x90, 0x00},
411 {0x91, 0x00},
412 {0x96, 0x00},
413 {0x9a, 0x80},
414 {0xb0, 0x84},
415 {0xb1, 0x0c},
416 {0xb2, 0x0e},
417 {0xb3, 0x82},
418 {0xb8, 0x0a},
419 {0x43, 0x0a},
420 {0x44, 0xf0},
421 {0x45, 0x34},
422 {0x46, 0x58},
423 {0x47, 0x28},
424 {0x48, 0x3a},
425 {0x59, 0x88},
426 {0x5a, 0x88},
427 {0x5b, 0x44},
428 {0x5c, 0x67},
429 {0x5d, 0x49},
430 {0x5e, 0x0e},
431 {0x6c, 0x0a},
432 {0x6d, 0x55},
433 {0x6e, 0x11},
434 {0x6f, 0x9f},
435 {0x6a, 0x40},
436 {0x01, 0x40},
437 {0x02, 0x40},
438 {0x13, 0xe7},
439 {0x4f, 0x80},
440 {0x50, 0x80},
441 {0x51, 0x00},
442 {0x52, 0x22},
443 {0x53, 0x5e},
444 {0x54, 0x80},
445 {0x58, 0x9e},
446 {0x41, 0x08},
447 {0x3f, 0x00},
448 {0x75, 0x04},
449 {0x76, 0xe1},
450 {0x4c, 0x00},
451 {0x77, 0x01},
452 {0x3d, 0xc2},
453 {0x4b, 0x09},
454 {0xc9, 0x60},
455 {0x41, 0x38}, /* jfm: auto sharpness + auto de-noise */
456 {0x56, 0x40},
457 {0x34, 0x11},
458 {0x3b, 0xc2},
459 {0xa4, 0x8a}, /* Night mode trigger point */
460 {0x96, 0x00},
461 {0x97, 0x30},
462 {0x98, 0x20},
463 {0x99, 0x20},
464 {0x9a, 0x84},
465 {0x9b, 0x29},
466 {0x9c, 0x03},
467 {0x9d, 0x4c},
468 {0x9e, 0x3f},
469 {0x78, 0x04},
470 {0x79, 0x01},
471 {0xc8, 0xf0},
472 {0x79, 0x0f},
473 {0xc8, 0x00},
474 {0x79, 0x10},
475 {0xc8, 0x7e},
476 {0x79, 0x0a},
477 {0xc8, 0x80},
478 {0x79, 0x0b},
479 {0xc8, 0x01},
480 {0x79, 0x0c},
481 {0xc8, 0x0f},
482 {0x79, 0x0d},
483 {0xc8, 0x20},
484 {0x79, 0x09},
485 {0xc8, 0x80},
486 {0x79, 0x02},
487 {0xc8, 0xc0},
488 {0x79, 0x03},
489 {0xc8, 0x20},
490 {0x79, 0x26},
491 };
492 static const u8 bridge_start_vga_767x[][2] = {
493 /* str59 JPG */
494 {0x94, 0xaa},
495 {0xf1, 0x42},
496 {0xe5, 0x04},
497 {0xc0, 0x50},
498 {0xc1, 0x3c},
499 {0xc2, 0x0c},
500 {0x35, 0x02}, /* turn on JPEG */
501 {0xd9, 0x10},
502 {0xda, 0x00}, /* for higher clock rate(30fps) */
503 {0x34, 0x05}, /* enable Audio Suspend mode */
504 {0xc3, 0xf9}, /* enable PRE */
505 {0x8c, 0x00}, /* CIF VSize LSB[2:0] */
506 {0x8d, 0x1c}, /* output YUV */
507 /* {0x34, 0x05}, * enable Audio Suspend mode (?) */
508 {0x50, 0x00}, /* H/V divider=0 */
509 {0x51, 0xa0}, /* input H=640/4 */
510 {0x52, 0x3c}, /* input V=480/4 */
511 {0x53, 0x00}, /* offset X=0 */
512 {0x54, 0x00}, /* offset Y=0 */
513 {0x55, 0x00}, /* H/V size[8]=0 */
514 {0x57, 0x00}, /* H-size[9]=0 */
515 {0x5c, 0x00}, /* output size[9:8]=0 */
516 {0x5a, 0xa0}, /* output H=640/4 */
517 {0x5b, 0x78}, /* output V=480/4 */
518 {0x1c, 0x0a},
519 {0x1d, 0x0a},
520 {0x94, 0x11},
521 };
522 static const u8 sensor_start_vga_767x[][2] = {
523 {0x11, 0x01},
524 {0x1e, 0x04},
525 {0x19, 0x02},
526 {0x1a, 0x7a},
527 };
528 static const u8 bridge_start_qvga_767x[][2] = {
529 /* str86 JPG */
530 {0x94, 0xaa},
531 {0xf1, 0x42},
532 {0xe5, 0x04},
533 {0xc0, 0x80},
534 {0xc1, 0x60},
535 {0xc2, 0x0c},
536 {0x35, 0x02}, /* turn on JPEG */
537 {0xd9, 0x10},
538 {0xc0, 0x50}, /* CIF HSize 640 */
539 {0xc1, 0x3c}, /* CIF VSize 480 */
540 {0x8c, 0x00}, /* CIF VSize LSB[2:0] */
541 {0x8d, 0x1c}, /* output YUV */
542 {0x34, 0x05}, /* enable Audio Suspend mode */
543 {0xc2, 0x4c}, /* output YUV and Enable DCW */
544 {0xc3, 0xf9}, /* enable PRE */
545 {0x1c, 0x00}, /* indirect addressing */
546 {0x1d, 0x48}, /* output YUV422 */
547 {0x50, 0x89}, /* H/V divider=/2; plus DCW AVG */
548 {0x51, 0xa0}, /* DCW input H=640/4 */
549 {0x52, 0x78}, /* DCW input V=480/4 */
550 {0x53, 0x00}, /* offset X=0 */
551 {0x54, 0x00}, /* offset Y=0 */
552 {0x55, 0x00}, /* H/V size[8]=0 */
553 {0x57, 0x00}, /* H-size[9]=0 */
554 {0x5c, 0x00}, /* DCW output size[9:8]=0 */
555 {0x5a, 0x50}, /* DCW output H=320/4 */
556 {0x5b, 0x3c}, /* DCW output V=240/4 */
557 {0x1c, 0x0a},
558 {0x1d, 0x0a},
559 {0x94, 0x11},
560 };
561 static const u8 sensor_start_qvga_767x[][2] = {
562 {0x11, 0x01},
563 {0x1e, 0x04},
564 {0x19, 0x02},
565 {0x1a, 0x7a},
566 };
567
568 static const u8 bridge_init_772x[][2] = {
569 { 0xc2, 0x0c },
570 { 0x88, 0xf8 },
571 { 0xc3, 0x69 },
572 { 0x89, 0xff },
573 { 0x76, 0x03 },
574 { 0x92, 0x01 },
575 { 0x93, 0x18 },
576 { 0x94, 0x10 },
577 { 0x95, 0x10 },
578 { 0xe2, 0x00 },
579 { 0xe7, 0x3e },
580
581 { 0x96, 0x00 },
582
583 { 0x97, 0x20 },
584 { 0x97, 0x20 },
585 { 0x97, 0x20 },
586 { 0x97, 0x0a },
587 { 0x97, 0x3f },
588 { 0x97, 0x4a },
589 { 0x97, 0x20 },
590 { 0x97, 0x15 },
591 { 0x97, 0x0b },
592
593 { 0x8e, 0x40 },
594 { 0x1f, 0x81 },
595 { 0x34, 0x05 },
596 { 0xe3, 0x04 },
597 { 0x88, 0x00 },
598 { 0x89, 0x00 },
599 { 0x76, 0x00 },
600 { 0xe7, 0x2e },
601 { 0x31, 0xf9 },
602 { 0x25, 0x42 },
603 { 0x21, 0xf0 },
604
605 { 0x1c, 0x00 },
606 { 0x1d, 0x40 },
607 { 0x1d, 0x02 }, /* payload size 0x0200 * 4 = 2048 bytes */
608 { 0x1d, 0x00 }, /* payload size */
609
610 { 0x1d, 0x02 }, /* frame size 0x025800 * 4 = 614400 */
611 { 0x1d, 0x58 }, /* frame size */
612 { 0x1d, 0x00 }, /* frame size */
613
614 { 0x1c, 0x0a },
615 { 0x1d, 0x08 }, /* turn on UVC header */
616 { 0x1d, 0x0e }, /* .. */
617
618 { 0x8d, 0x1c },
619 { 0x8e, 0x80 },
620 { 0xe5, 0x04 },
621
622 { 0xc0, 0x50 },
623 { 0xc1, 0x3c },
624 { 0xc2, 0x0c },
625 };
626 static const u8 sensor_init_772x[][2] = {
627 { 0x12, 0x80 },
628 { 0x11, 0x01 },
629 /*fixme: better have a delay?*/
630 { 0x11, 0x01 },
631 { 0x11, 0x01 },
632 { 0x11, 0x01 },
633 { 0x11, 0x01 },
634 { 0x11, 0x01 },
635 { 0x11, 0x01 },
636 { 0x11, 0x01 },
637 { 0x11, 0x01 },
638 { 0x11, 0x01 },
639 { 0x11, 0x01 },
640
641 { 0x3d, 0x03 },
642 { 0x17, 0x26 },
643 { 0x18, 0xa0 },
644 { 0x19, 0x07 },
645 { 0x1a, 0xf0 },
646 { 0x32, 0x00 },
647 { 0x29, 0xa0 },
648 { 0x2c, 0xf0 },
649 { 0x65, 0x20 },
650 { 0x11, 0x01 },
651 { 0x42, 0x7f },
652 { 0x63, 0xaa }, /* AWB - was e0 */
653 { 0x64, 0xff },
654 { 0x66, 0x00 },
655 { 0x13, 0xf0 }, /* com8 */
656 { 0x0d, 0x41 },
657 { 0x0f, 0xc5 },
658 { 0x14, 0x11 },
659
660 { 0x22, 0x7f },
661 { 0x23, 0x03 },
662 { 0x24, 0x40 },
663 { 0x25, 0x30 },
664 { 0x26, 0xa1 },
665 { 0x2a, 0x00 },
666 { 0x2b, 0x00 },
667 { 0x6b, 0xaa },
668 { 0x13, 0xff }, /* AWB */
669
670 { 0x90, 0x05 },
671 { 0x91, 0x01 },
672 { 0x92, 0x03 },
673 { 0x93, 0x00 },
674 { 0x94, 0x60 },
675 { 0x95, 0x3c },
676 { 0x96, 0x24 },
677 { 0x97, 0x1e },
678 { 0x98, 0x62 },
679 { 0x99, 0x80 },
680 { 0x9a, 0x1e },
681 { 0x9b, 0x08 },
682 { 0x9c, 0x20 },
683 { 0x9e, 0x81 },
684
685 { 0xa6, 0x04 },
686 { 0x7e, 0x0c },
687 { 0x7f, 0x16 },
688 { 0x80, 0x2a },
689 { 0x81, 0x4e },
690 { 0x82, 0x61 },
691 { 0x83, 0x6f },
692 { 0x84, 0x7b },
693 { 0x85, 0x86 },
694 { 0x86, 0x8e },
695 { 0x87, 0x97 },
696 { 0x88, 0xa4 },
697 { 0x89, 0xaf },
698 { 0x8a, 0xc5 },
699 { 0x8b, 0xd7 },
700 { 0x8c, 0xe8 },
701 { 0x8d, 0x20 },
702
703 { 0x0c, 0x90 },
704
705 { 0x2b, 0x00 },
706 { 0x22, 0x7f },
707 { 0x23, 0x03 },
708 { 0x11, 0x01 },
709 { 0x0c, 0xd0 },
710 { 0x64, 0xff },
711 { 0x0d, 0x41 },
712
713 { 0x14, 0x41 },
714 { 0x0e, 0xcd },
715 { 0xac, 0xbf },
716 { 0x8e, 0x00 }, /* De-noise threshold */
717 { 0x0c, 0xd0 }
718 };
719 static const u8 bridge_start_vga_772x[][2] = {
720 {0x1c, 0x00},
721 {0x1d, 0x40},
722 {0x1d, 0x02},
723 {0x1d, 0x00},
724 {0x1d, 0x02},
725 {0x1d, 0x58},
726 {0x1d, 0x00},
727 {0xc0, 0x50},
728 {0xc1, 0x3c},
729 };
730 static const u8 sensor_start_vga_772x[][2] = {
731 {0x12, 0x00},
732 {0x17, 0x26},
733 {0x18, 0xa0},
734 {0x19, 0x07},
735 {0x1a, 0xf0},
736 {0x29, 0xa0},
737 {0x2c, 0xf0},
738 {0x65, 0x20},
739 };
740 static const u8 bridge_start_qvga_772x[][2] = {
741 {0x1c, 0x00},
742 {0x1d, 0x40},
743 {0x1d, 0x02},
744 {0x1d, 0x00},
745 {0x1d, 0x01},
746 {0x1d, 0x4b},
747 {0x1d, 0x00},
748 {0xc0, 0x28},
749 {0xc1, 0x1e},
750 };
751 static const u8 sensor_start_qvga_772x[][2] = {
752 {0x12, 0x40},
753 {0x17, 0x3f},
754 {0x18, 0x50},
755 {0x19, 0x03},
756 {0x1a, 0x78},
757 {0x29, 0x50},
758 {0x2c, 0x78},
759 {0x65, 0x2f},
760 };
761
762 static void ov534_reg_write(struct gspca_dev *gspca_dev, u16 reg, u8 val)
763 {
764 struct usb_device *udev = gspca_dev->dev;
765 int ret;
766
767 if (gspca_dev->usb_err < 0)
768 return;
769
770 PDEBUG(D_USBO, "SET 01 0000 %04x %02x", reg, val);
771 gspca_dev->usb_buf[0] = val;
772 ret = usb_control_msg(udev,
773 usb_sndctrlpipe(udev, 0),
774 0x01,
775 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
776 0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
777 if (ret < 0) {
778 err("write failed %d", ret);
779 gspca_dev->usb_err = ret;
780 }
781 }
782
783 static u8 ov534_reg_read(struct gspca_dev *gspca_dev, u16 reg)
784 {
785 struct usb_device *udev = gspca_dev->dev;
786 int ret;
787
788 if (gspca_dev->usb_err < 0)
789 return 0;
790 ret = usb_control_msg(udev,
791 usb_rcvctrlpipe(udev, 0),
792 0x01,
793 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
794 0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
795 PDEBUG(D_USBI, "GET 01 0000 %04x %02x", reg, gspca_dev->usb_buf[0]);
796 if (ret < 0) {
797 err("read failed %d", ret);
798 gspca_dev->usb_err = ret;
799 }
800 return gspca_dev->usb_buf[0];
801 }
802
803 /* Two bits control LED: 0x21 bit 7 and 0x23 bit 7.
804 * (direction and output)? */
805 static void ov534_set_led(struct gspca_dev *gspca_dev, int status)
806 {
807 u8 data;
808
809 PDEBUG(D_CONF, "led status: %d", status);
810
811 data = ov534_reg_read(gspca_dev, 0x21);
812 data |= 0x80;
813 ov534_reg_write(gspca_dev, 0x21, data);
814
815 data = ov534_reg_read(gspca_dev, 0x23);
816 if (status)
817 data |= 0x80;
818 else
819 data &= ~0x80;
820
821 ov534_reg_write(gspca_dev, 0x23, data);
822
823 if (!status) {
824 data = ov534_reg_read(gspca_dev, 0x21);
825 data &= ~0x80;
826 ov534_reg_write(gspca_dev, 0x21, data);
827 }
828 }
829
830 static int sccb_check_status(struct gspca_dev *gspca_dev)
831 {
832 u8 data;
833 int i;
834
835 for (i = 0; i < 5; i++) {
836 data = ov534_reg_read(gspca_dev, OV534_REG_STATUS);
837
838 switch (data) {
839 case 0x00:
840 return 1;
841 case 0x04:
842 return 0;
843 case 0x03:
844 break;
845 default:
846 PDEBUG(D_ERR, "sccb status 0x%02x, attempt %d/5",
847 data, i + 1);
848 }
849 }
850 return 0;
851 }
852
853 static void sccb_reg_write(struct gspca_dev *gspca_dev, u8 reg, u8 val)
854 {
855 PDEBUG(D_USBO, "sccb write: %02x %02x", reg, val);
856 ov534_reg_write(gspca_dev, OV534_REG_SUBADDR, reg);
857 ov534_reg_write(gspca_dev, OV534_REG_WRITE, val);
858 ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_3);
859
860 if (!sccb_check_status(gspca_dev)) {
861 err("sccb_reg_write failed");
862 gspca_dev->usb_err = -EIO;
863 }
864 }
865
866 static u8 sccb_reg_read(struct gspca_dev *gspca_dev, u16 reg)
867 {
868 ov534_reg_write(gspca_dev, OV534_REG_SUBADDR, reg);
869 ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_2);
870 if (!sccb_check_status(gspca_dev))
871 err("sccb_reg_read failed 1");
872
873 ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_READ_2);
874 if (!sccb_check_status(gspca_dev))
875 err("sccb_reg_read failed 2");
876
877 return ov534_reg_read(gspca_dev, OV534_REG_READ);
878 }
879
880 /* output a bridge sequence (reg - val) */
881 static void reg_w_array(struct gspca_dev *gspca_dev,
882 const u8 (*data)[2], int len)
883 {
884 while (--len >= 0) {
885 ov534_reg_write(gspca_dev, (*data)[0], (*data)[1]);
886 data++;
887 }
888 }
889
890 /* output a sensor sequence (reg - val) */
891 static void sccb_w_array(struct gspca_dev *gspca_dev,
892 const u8 (*data)[2], int len)
893 {
894 while (--len >= 0) {
895 if ((*data)[0] != 0xff) {
896 sccb_reg_write(gspca_dev, (*data)[0], (*data)[1]);
897 } else {
898 sccb_reg_read(gspca_dev, (*data)[1]);
899 sccb_reg_write(gspca_dev, 0xff, 0x00);
900 }
901 data++;
902 }
903 }
904
905 /* ov772x specific controls */
906 static void set_frame_rate(struct gspca_dev *gspca_dev)
907 {
908 struct sd *sd = (struct sd *) gspca_dev;
909 int i;
910 struct rate_s {
911 u8 fps;
912 u8 r11;
913 u8 r0d;
914 u8 re5;
915 };
916 const struct rate_s *r;
917 static const struct rate_s rate_0[] = { /* 640x480 */
918 {60, 0x01, 0xc1, 0x04},
919 {50, 0x01, 0x41, 0x02},
920 {40, 0x02, 0xc1, 0x04},
921 {30, 0x04, 0x81, 0x02},
922 {15, 0x03, 0x41, 0x04},
923 };
924 static const struct rate_s rate_1[] = { /* 320x240 */
925 {125, 0x02, 0x81, 0x02},
926 {100, 0x02, 0xc1, 0x04},
927 {75, 0x03, 0xc1, 0x04},
928 {60, 0x04, 0xc1, 0x04},
929 {50, 0x02, 0x41, 0x04},
930 {40, 0x03, 0x41, 0x04},
931 {30, 0x04, 0x41, 0x04},
932 };
933
934 if (sd->sensor != SENSOR_OV772x)
935 return;
936 if (gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv == 0) {
937 r = rate_0;
938 i = ARRAY_SIZE(rate_0);
939 } else {
940 r = rate_1;
941 i = ARRAY_SIZE(rate_1);
942 }
943 while (--i > 0) {
944 if (sd->frame_rate >= r->fps)
945 break;
946 r++;
947 }
948
949 sccb_reg_write(gspca_dev, 0x11, r->r11);
950 sccb_reg_write(gspca_dev, 0x0d, r->r0d);
951 ov534_reg_write(gspca_dev, 0xe5, r->re5);
952
953 PDEBUG(D_PROBE, "frame_rate: %d", r->fps);
954 }
955
956 static void setbrightness(struct gspca_dev *gspca_dev)
957 {
958 struct sd *sd = (struct sd *) gspca_dev;
959 int val;
960
961 val = sd->ctrls[BRIGHTNESS].val;
962 if (sd->sensor == SENSOR_OV767x) {
963 if (val < 0)
964 val = 0x80 - val;
965 sccb_reg_write(gspca_dev, 0x55, val); /* bright */
966 } else {
967 sccb_reg_write(gspca_dev, 0x9b, val);
968 }
969 }
970
971 static void setcontrast(struct gspca_dev *gspca_dev)
972 {
973 struct sd *sd = (struct sd *) gspca_dev;
974 u8 val;
975
976 val = sd->ctrls[CONTRAST].val;
977 if (sd->sensor == SENSOR_OV767x)
978 sccb_reg_write(gspca_dev, 0x56, val); /* contras */
979 else
980 sccb_reg_write(gspca_dev, 0x9c, val);
981 }
982
983 static void setgain(struct gspca_dev *gspca_dev)
984 {
985 struct sd *sd = (struct sd *) gspca_dev;
986 u8 val;
987
988 if (sd->ctrls[AGC].val)
989 return;
990
991 val = sd->ctrls[GAIN].val;
992 switch (val & 0x30) {
993 case 0x00:
994 val &= 0x0f;
995 break;
996 case 0x10:
997 val &= 0x0f;
998 val |= 0x30;
999 break;
1000 case 0x20:
1001 val &= 0x0f;
1002 val |= 0x70;
1003 break;
1004 default:
1005 /* case 0x30: */
1006 val &= 0x0f;
1007 val |= 0xf0;
1008 break;
1009 }
1010 sccb_reg_write(gspca_dev, 0x00, val);
1011 }
1012
1013 static void setexposure(struct gspca_dev *gspca_dev)
1014 {
1015 struct sd *sd = (struct sd *) gspca_dev;
1016 u8 val;
1017
1018 if (sd->ctrls[AEC].val)
1019 return;
1020
1021 val = sd->ctrls[EXPOSURE].val;
1022 if (sd->sensor == SENSOR_OV767x) {
1023
1024 /* set only aec[9:2] */
1025 sccb_reg_write(gspca_dev, 0x10, val); /* aech */
1026 } else {
1027
1028 /* 'val' is one byte and represents half of the exposure value
1029 * we are going to set into registers, a two bytes value:
1030 *
1031 * MSB: ((u16) val << 1) >> 8 == val >> 7
1032 * LSB: ((u16) val << 1) & 0xff == val << 1
1033 */
1034 sccb_reg_write(gspca_dev, 0x08, val >> 7);
1035 sccb_reg_write(gspca_dev, 0x10, val << 1);
1036 }
1037 }
1038
1039 static void setagc(struct gspca_dev *gspca_dev)
1040 {
1041 struct sd *sd = (struct sd *) gspca_dev;
1042
1043 if (sd->ctrls[AGC].val) {
1044 sccb_reg_write(gspca_dev, 0x13,
1045 sccb_reg_read(gspca_dev, 0x13) | 0x04);
1046 sccb_reg_write(gspca_dev, 0x64,
1047 sccb_reg_read(gspca_dev, 0x64) | 0x03);
1048 } else {
1049 sccb_reg_write(gspca_dev, 0x13,
1050 sccb_reg_read(gspca_dev, 0x13) & ~0x04);
1051 sccb_reg_write(gspca_dev, 0x64,
1052 sccb_reg_read(gspca_dev, 0x64) & ~0x03);
1053
1054 setgain(gspca_dev);
1055 }
1056 }
1057
1058 static void setawb(struct gspca_dev *gspca_dev)
1059 {
1060 struct sd *sd = (struct sd *) gspca_dev;
1061
1062 if (sd->ctrls[AWB].val) {
1063 sccb_reg_write(gspca_dev, 0x13,
1064 sccb_reg_read(gspca_dev, 0x13) | 0x02);
1065 if (sd->sensor == SENSOR_OV772x)
1066 sccb_reg_write(gspca_dev, 0x63,
1067 sccb_reg_read(gspca_dev, 0x63) | 0xc0);
1068 } else {
1069 sccb_reg_write(gspca_dev, 0x13,
1070 sccb_reg_read(gspca_dev, 0x13) & ~0x02);
1071 if (sd->sensor == SENSOR_OV772x)
1072 sccb_reg_write(gspca_dev, 0x63,
1073 sccb_reg_read(gspca_dev, 0x63) & ~0xc0);
1074 }
1075 }
1076
1077 static void setaec(struct gspca_dev *gspca_dev)
1078 {
1079 struct sd *sd = (struct sd *) gspca_dev;
1080 u8 data;
1081
1082 data = sd->sensor == SENSOR_OV767x ?
1083 0x05 : /* agc + aec */
1084 0x01; /* agc */
1085 if (sd->ctrls[AEC].val)
1086 sccb_reg_write(gspca_dev, 0x13,
1087 sccb_reg_read(gspca_dev, 0x13) | data);
1088 else {
1089 sccb_reg_write(gspca_dev, 0x13,
1090 sccb_reg_read(gspca_dev, 0x13) & ~data);
1091 if (sd->sensor == SENSOR_OV767x)
1092 sd->ctrls[EXPOSURE].val =
1093 sccb_reg_read(gspca_dev, 10); /* aech */
1094 else
1095 setexposure(gspca_dev);
1096 }
1097 }
1098
1099 static void setsharpness(struct gspca_dev *gspca_dev)
1100 {
1101 struct sd *sd = (struct sd *) gspca_dev;
1102 u8 val;
1103
1104 val = sd->ctrls[SHARPNESS].val;
1105 sccb_reg_write(gspca_dev, 0x91, val); /* Auto de-noise threshold */
1106 sccb_reg_write(gspca_dev, 0x8e, val); /* De-noise threshold */
1107 }
1108
1109 static void sethvflip(struct gspca_dev *gspca_dev)
1110 {
1111 struct sd *sd = (struct sd *) gspca_dev;
1112 u8 val;
1113
1114 if (sd->sensor == SENSOR_OV767x) {
1115 val = sccb_reg_read(gspca_dev, 0x1e); /* mvfp */
1116 val &= ~0x30;
1117 if (sd->ctrls[HFLIP].val)
1118 val |= 0x20;
1119 if (sd->ctrls[VFLIP].val)
1120 val |= 0x10;
1121 sccb_reg_write(gspca_dev, 0x1e, val);
1122 } else {
1123 val = sccb_reg_read(gspca_dev, 0x0c);
1124 val &= ~0xc0;
1125 if (sd->ctrls[HFLIP].val == 0)
1126 val |= 0x40;
1127 if (sd->ctrls[VFLIP].val == 0)
1128 val |= 0x80;
1129 sccb_reg_write(gspca_dev, 0x0c, val);
1130 }
1131 }
1132
1133 static void setcolors(struct gspca_dev *gspca_dev)
1134 {
1135 struct sd *sd = (struct sd *) gspca_dev;
1136 u8 val;
1137 int i;
1138 static u8 color_tb[][6] = {
1139 {0x42, 0x42, 0x00, 0x11, 0x30, 0x41},
1140 {0x52, 0x52, 0x00, 0x16, 0x3c, 0x52},
1141 {0x66, 0x66, 0x00, 0x1b, 0x4b, 0x66},
1142 {0x80, 0x80, 0x00, 0x22, 0x5e, 0x80},
1143 {0x9a, 0x9a, 0x00, 0x29, 0x71, 0x9a},
1144 {0xb8, 0xb8, 0x00, 0x31, 0x87, 0xb8},
1145 {0xdd, 0xdd, 0x00, 0x3b, 0xa2, 0xdd},
1146 };
1147
1148 val = sd->ctrls[COLORS].val;
1149 for (i = 0; i < ARRAY_SIZE(color_tb[0]); i++)
1150 sccb_reg_write(gspca_dev, 0x4f + i, color_tb[val][i]);
1151 }
1152
1153 static void setlightfreq(struct gspca_dev *gspca_dev)
1154 {
1155 struct sd *sd = (struct sd *) gspca_dev;
1156 u8 val;
1157
1158 val = sd->ctrls[LIGHTFREQ].val ? 0x9e : 0x00;
1159 if (sd->sensor == SENSOR_OV767x) {
1160 sccb_reg_write(gspca_dev, 0x2a, 0x00);
1161 if (val)
1162 val = 0x9d; /* insert dummy to 25fps for 50Hz */
1163 }
1164 sccb_reg_write(gspca_dev, 0x2b, val);
1165 }
1166
1167
1168 /* this function is called at probe time */
1169 static int sd_config(struct gspca_dev *gspca_dev,
1170 const struct usb_device_id *id)
1171 {
1172 struct sd *sd = (struct sd *) gspca_dev;
1173 struct cam *cam;
1174
1175 cam = &gspca_dev->cam;
1176
1177 cam->ctrls = sd->ctrls;
1178
1179 /* the auto white balance control works only when auto gain is set */
1180 if (sd_ctrls[AGC].qctrl.default_value == 0)
1181 gspca_dev->ctrl_inac |= (1 << AWB);
1182
1183 cam->cam_mode = ov772x_mode;
1184 cam->nmodes = ARRAY_SIZE(ov772x_mode);
1185
1186 sd->frame_rate = 30;
1187
1188 return 0;
1189 }
1190
1191 /* this function is called at probe and resume time */
1192 static int sd_init(struct gspca_dev *gspca_dev)
1193 {
1194 struct sd *sd = (struct sd *) gspca_dev;
1195 u16 sensor_id;
1196 static const struct reg_array bridge_init[NSENSORS] = {
1197 [SENSOR_OV767x] = {bridge_init_767x, ARRAY_SIZE(bridge_init_767x)},
1198 [SENSOR_OV772x] = {bridge_init_772x, ARRAY_SIZE(bridge_init_772x)},
1199 };
1200 static const struct reg_array sensor_init[NSENSORS] = {
1201 [SENSOR_OV767x] = {sensor_init_767x, ARRAY_SIZE(sensor_init_767x)},
1202 [SENSOR_OV772x] = {sensor_init_772x, ARRAY_SIZE(sensor_init_772x)},
1203 };
1204
1205 /* reset bridge */
1206 ov534_reg_write(gspca_dev, 0xe7, 0x3a);
1207 ov534_reg_write(gspca_dev, 0xe0, 0x08);
1208 msleep(100);
1209
1210 /* initialize the sensor address */
1211 ov534_reg_write(gspca_dev, OV534_REG_ADDRESS, 0x42);
1212
1213 /* reset sensor */
1214 sccb_reg_write(gspca_dev, 0x12, 0x80);
1215 msleep(10);
1216
1217 /* probe the sensor */
1218 sccb_reg_read(gspca_dev, 0x0a);
1219 sensor_id = sccb_reg_read(gspca_dev, 0x0a) << 8;
1220 sccb_reg_read(gspca_dev, 0x0b);
1221 sensor_id |= sccb_reg_read(gspca_dev, 0x0b);
1222 PDEBUG(D_PROBE, "Sensor ID: %04x", sensor_id);
1223
1224 if ((sensor_id & 0xfff0) == 0x7670) {
1225 sd->sensor = SENSOR_OV767x;
1226 gspca_dev->ctrl_dis = (1 << GAIN) |
1227 (1 << AGC) |
1228 (1 << SHARPNESS); /* auto */
1229 sd->ctrls[BRIGHTNESS].min = -127;
1230 sd->ctrls[BRIGHTNESS].max = 127;
1231 sd->ctrls[BRIGHTNESS].def = 0;
1232 sd->ctrls[CONTRAST].max = 0x80;
1233 sd->ctrls[CONTRAST].def = 0x40;
1234 sd->ctrls[EXPOSURE].min = 0x08;
1235 sd->ctrls[EXPOSURE].max = 0x60;
1236 sd->ctrls[EXPOSURE].def = 0x13;
1237 sd->ctrls[SHARPNESS].max = 9;
1238 sd->ctrls[SHARPNESS].def = 4;
1239 sd->ctrls[HFLIP].def = 1;
1240 gspca_dev->cam.cam_mode = ov767x_mode;
1241 gspca_dev->cam.nmodes = ARRAY_SIZE(ov767x_mode);
1242 } else {
1243 sd->sensor = SENSOR_OV772x;
1244 gspca_dev->ctrl_dis = (1 << COLORS);
1245 gspca_dev->cam.bulk = 1;
1246 gspca_dev->cam.bulk_size = 16384;
1247 gspca_dev->cam.bulk_nurbs = 2;
1248 gspca_dev->cam.mode_framerates = ov772x_framerates;
1249 }
1250
1251 /* initialize */
1252 reg_w_array(gspca_dev, bridge_init[sd->sensor].val,
1253 bridge_init[sd->sensor].len);
1254 ov534_set_led(gspca_dev, 1);
1255 sccb_w_array(gspca_dev, sensor_init[sd->sensor].val,
1256 sensor_init[sd->sensor].len);
1257 if (sd->sensor == SENSOR_OV767x)
1258 sd_start(gspca_dev);
1259 sd_stopN(gspca_dev);
1260 /* set_frame_rate(gspca_dev); */
1261
1262 return gspca_dev->usb_err;
1263 }
1264
1265 static int sd_start(struct gspca_dev *gspca_dev)
1266 {
1267 struct sd *sd = (struct sd *) gspca_dev;
1268 int mode;
1269 static const struct reg_array bridge_start[NSENSORS][2] = {
1270 [SENSOR_OV767x] = {{bridge_start_qvga_767x,
1271 ARRAY_SIZE(bridge_start_qvga_767x)},
1272 {bridge_start_vga_767x,
1273 ARRAY_SIZE(bridge_start_vga_767x)}},
1274 [SENSOR_OV772x] = {{bridge_start_qvga_772x,
1275 ARRAY_SIZE(bridge_start_qvga_772x)},
1276 {bridge_start_vga_772x,
1277 ARRAY_SIZE(bridge_start_vga_772x)}},
1278 };
1279 static const struct reg_array sensor_start[NSENSORS][2] = {
1280 [SENSOR_OV767x] = {{sensor_start_qvga_767x,
1281 ARRAY_SIZE(sensor_start_qvga_767x)},
1282 {sensor_start_vga_767x,
1283 ARRAY_SIZE(sensor_start_vga_767x)}},
1284 [SENSOR_OV772x] = {{sensor_start_qvga_772x,
1285 ARRAY_SIZE(sensor_start_qvga_772x)},
1286 {sensor_start_vga_772x,
1287 ARRAY_SIZE(sensor_start_vga_772x)}},
1288 };
1289
1290 /* (from ms-win trace) */
1291 if (sd->sensor == SENSOR_OV767x)
1292 sccb_reg_write(gspca_dev, 0x1e, 0x04);
1293 /* black sun enable ? */
1294
1295 mode = gspca_dev->curr_mode; /* 0: 320x240, 1: 640x480 */
1296 reg_w_array(gspca_dev, bridge_start[sd->sensor][mode].val,
1297 bridge_start[sd->sensor][mode].len);
1298 sccb_w_array(gspca_dev, sensor_start[sd->sensor][mode].val,
1299 sensor_start[sd->sensor][mode].len);
1300
1301 set_frame_rate(gspca_dev);
1302
1303 if (!(gspca_dev->ctrl_dis & (1 << AGC)))
1304 setagc(gspca_dev);
1305 setawb(gspca_dev);
1306 setaec(gspca_dev);
1307 if (!(gspca_dev->ctrl_dis & (1 << GAIN)))
1308 setgain(gspca_dev);
1309 setexposure(gspca_dev);
1310 setbrightness(gspca_dev);
1311 setcontrast(gspca_dev);
1312 if (!(gspca_dev->ctrl_dis & (1 << SHARPNESS)))
1313 setsharpness(gspca_dev);
1314 sethvflip(gspca_dev);
1315 if (!(gspca_dev->ctrl_dis & (1 << COLORS)))
1316 setcolors(gspca_dev);
1317 setlightfreq(gspca_dev);
1318
1319 ov534_set_led(gspca_dev, 1);
1320 ov534_reg_write(gspca_dev, 0xe0, 0x00);
1321 return gspca_dev->usb_err;
1322 }
1323
1324 static void sd_stopN(struct gspca_dev *gspca_dev)
1325 {
1326 ov534_reg_write(gspca_dev, 0xe0, 0x09);
1327 ov534_set_led(gspca_dev, 0);
1328 }
1329
1330 /* Values for bmHeaderInfo (Video and Still Image Payload Headers, 2.4.3.3) */
1331 #define UVC_STREAM_EOH (1 << 7)
1332 #define UVC_STREAM_ERR (1 << 6)
1333 #define UVC_STREAM_STI (1 << 5)
1334 #define UVC_STREAM_RES (1 << 4)
1335 #define UVC_STREAM_SCR (1 << 3)
1336 #define UVC_STREAM_PTS (1 << 2)
1337 #define UVC_STREAM_EOF (1 << 1)
1338 #define UVC_STREAM_FID (1 << 0)
1339
1340 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1341 u8 *data, int len)
1342 {
1343 struct sd *sd = (struct sd *) gspca_dev;
1344 __u32 this_pts;
1345 u16 this_fid;
1346 int remaining_len = len;
1347 int payload_len;
1348
1349 payload_len = gspca_dev->cam.bulk ? 2048 : 2040;
1350 do {
1351 len = min(remaining_len, payload_len);
1352
1353 /* Payloads are prefixed with a UVC-style header. We
1354 consider a frame to start when the FID toggles, or the PTS
1355 changes. A frame ends when EOF is set, and we've received
1356 the correct number of bytes. */
1357
1358 /* Verify UVC header. Header length is always 12 */
1359 if (data[0] != 12 || len < 12) {
1360 PDEBUG(D_PACK, "bad header");
1361 goto discard;
1362 }
1363
1364 /* Check errors */
1365 if (data[1] & UVC_STREAM_ERR) {
1366 PDEBUG(D_PACK, "payload error");
1367 goto discard;
1368 }
1369
1370 /* Extract PTS and FID */
1371 if (!(data[1] & UVC_STREAM_PTS)) {
1372 PDEBUG(D_PACK, "PTS not present");
1373 goto discard;
1374 }
1375 this_pts = (data[5] << 24) | (data[4] << 16)
1376 | (data[3] << 8) | data[2];
1377 this_fid = (data[1] & UVC_STREAM_FID) ? 1 : 0;
1378
1379 /* If PTS or FID has changed, start a new frame. */
1380 if (this_pts != sd->last_pts || this_fid != sd->last_fid) {
1381 if (gspca_dev->last_packet_type == INTER_PACKET)
1382 gspca_frame_add(gspca_dev, LAST_PACKET,
1383 NULL, 0);
1384 sd->last_pts = this_pts;
1385 sd->last_fid = this_fid;
1386 gspca_frame_add(gspca_dev, FIRST_PACKET,
1387 data + 12, len - 12);
1388 /* If this packet is marked as EOF, end the frame */
1389 } else if (data[1] & UVC_STREAM_EOF) {
1390 sd->last_pts = 0;
1391 if (gspca_dev->pixfmt == V4L2_PIX_FMT_YUYV
1392 && gspca_dev->image_len + len - 12 !=
1393 gspca_dev->width * gspca_dev->height * 2) {
1394 PDEBUG(D_PACK, "wrong sized frame");
1395 goto discard;
1396 }
1397 gspca_frame_add(gspca_dev, LAST_PACKET,
1398 data + 12, len - 12);
1399 } else {
1400
1401 /* Add the data from this payload */
1402 gspca_frame_add(gspca_dev, INTER_PACKET,
1403 data + 12, len - 12);
1404 }
1405
1406 /* Done this payload */
1407 goto scan_next;
1408
1409 discard:
1410 /* Discard data until a new frame starts. */
1411 gspca_dev->last_packet_type = DISCARD_PACKET;
1412
1413 scan_next:
1414 remaining_len -= len;
1415 data += len;
1416 } while (remaining_len > 0);
1417 }
1418
1419 static int sd_setagc(struct gspca_dev *gspca_dev, __s32 val)
1420 {
1421 struct sd *sd = (struct sd *) gspca_dev;
1422
1423 sd->ctrls[AGC].val = val;
1424
1425 /* the auto white balance control works only
1426 * when auto gain is set */
1427 if (val) {
1428 gspca_dev->ctrl_inac &= ~(1 << AWB);
1429 } else {
1430 gspca_dev->ctrl_inac |= (1 << AWB);
1431 if (sd->ctrls[AWB].val) {
1432 sd->ctrls[AWB].val = 0;
1433 if (gspca_dev->streaming)
1434 setawb(gspca_dev);
1435 }
1436 }
1437 if (gspca_dev->streaming)
1438 setagc(gspca_dev);
1439 return gspca_dev->usb_err;
1440 }
1441
1442 static int sd_querymenu(struct gspca_dev *gspca_dev,
1443 struct v4l2_querymenu *menu)
1444 {
1445 switch (menu->id) {
1446 case V4L2_CID_POWER_LINE_FREQUENCY:
1447 switch (menu->index) {
1448 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1449 strcpy((char *) menu->name, "Disabled");
1450 return 0;
1451 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1452 strcpy((char *) menu->name, "50 Hz");
1453 return 0;
1454 }
1455 break;
1456 }
1457
1458 return -EINVAL;
1459 }
1460
1461 /* get stream parameters (framerate) */
1462 static void sd_get_streamparm(struct gspca_dev *gspca_dev,
1463 struct v4l2_streamparm *parm)
1464 {
1465 struct v4l2_captureparm *cp = &parm->parm.capture;
1466 struct v4l2_fract *tpf = &cp->timeperframe;
1467 struct sd *sd = (struct sd *) gspca_dev;
1468
1469 cp->capability |= V4L2_CAP_TIMEPERFRAME;
1470 tpf->numerator = 1;
1471 tpf->denominator = sd->frame_rate;
1472 }
1473
1474 /* set stream parameters (framerate) */
1475 static void sd_set_streamparm(struct gspca_dev *gspca_dev,
1476 struct v4l2_streamparm *parm)
1477 {
1478 struct v4l2_captureparm *cp = &parm->parm.capture;
1479 struct v4l2_fract *tpf = &cp->timeperframe;
1480 struct sd *sd = (struct sd *) gspca_dev;
1481
1482 /* Set requested framerate */
1483 sd->frame_rate = tpf->denominator / tpf->numerator;
1484 if (gspca_dev->streaming)
1485 set_frame_rate(gspca_dev);
1486
1487 /* Return the actual framerate */
1488 tpf->numerator = 1;
1489 tpf->denominator = sd->frame_rate;
1490 }
1491
1492 /* sub-driver description */
1493 static const struct sd_desc sd_desc = {
1494 .name = MODULE_NAME,
1495 .ctrls = sd_ctrls,
1496 .nctrls = ARRAY_SIZE(sd_ctrls),
1497 .config = sd_config,
1498 .init = sd_init,
1499 .start = sd_start,
1500 .stopN = sd_stopN,
1501 .pkt_scan = sd_pkt_scan,
1502 .querymenu = sd_querymenu,
1503 .get_streamparm = sd_get_streamparm,
1504 .set_streamparm = sd_set_streamparm,
1505 };
1506
1507 /* -- module initialisation -- */
1508 static const struct usb_device_id device_table[] = {
1509 {USB_DEVICE(0x1415, 0x2000)},
1510 {USB_DEVICE(0x06f8, 0x3002)},
1511 {}
1512 };
1513
1514 MODULE_DEVICE_TABLE(usb, device_table);
1515
1516 /* -- device connect -- */
1517 static int sd_probe(struct usb_interface *intf, const struct usb_device_id *id)
1518 {
1519 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1520 THIS_MODULE);
1521 }
1522
1523 static struct usb_driver sd_driver = {
1524 .name = MODULE_NAME,
1525 .id_table = device_table,
1526 .probe = sd_probe,
1527 .disconnect = gspca_disconnect,
1528 #ifdef CONFIG_PM
1529 .suspend = gspca_suspend,
1530 .resume = gspca_resume,
1531 #endif
1532 };
1533
1534 /* -- module insert / remove -- */
1535 static int __init sd_mod_init(void)
1536 {
1537 return usb_register(&sd_driver);
1538 }
1539
1540 static void __exit sd_mod_exit(void)
1541 {
1542 usb_deregister(&sd_driver);
1543 }
1544
1545 module_init(sd_mod_init);
1546 module_exit(sd_mod_exit);
linux-next