projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-rmk/samsung3' of git://git.fluff.org/bjdooks/linux into devel-stable
[deliverable/linux.git] / drivers / media / video / gspca / ov534.c
1 /*
2 * ov534 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, hue, AWB control added
14 * 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 /* specific webcam descriptor */
53 struct sd {
54 struct gspca_dev gspca_dev; /* !! must be the first item */
55 __u32 last_pts;
56 u16 last_fid;
57 u8 frame_rate;
58
59 u8 brightness;
60 u8 contrast;
61 u8 gain;
62 u8 exposure;
63 u8 redblc;
64 u8 blueblc;
65 u8 hue;
66 u8 autogain;
67 u8 awb;
68 s8 sharpness;
69 u8 hflip;
70 u8 vflip;
71 u8 satur;
72 u8 lightfreq;
73
74 u8 sensor;
75 #define SENSOR_OV772X 0
76 #define SENSOR_OV965X 1
77 };
78
79 /* V4L2 controls supported by the driver */
80 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
81 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
82 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
83 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
84 static int sd_setredblc(struct gspca_dev *gspca_dev, __s32 val);
85 static int sd_getredblc(struct gspca_dev *gspca_dev, __s32 *val);
86 static int sd_setblueblc(struct gspca_dev *gspca_dev, __s32 val);
87 static int sd_getblueblc(struct gspca_dev *gspca_dev, __s32 *val);
88 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
89 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
90 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
91 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
92 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
93 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
94 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
95 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
96 static int sd_sethue(struct gspca_dev *gspca_dev, __s32 val);
97 static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val);
98 static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val);
99 static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val);
100 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
101 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
102 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
103 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
104 static int sd_setsatur(struct gspca_dev *gspca_dev, __s32 val);
105 static int sd_getsatur(struct gspca_dev *gspca_dev, __s32 *val);
106 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
107 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
108
109 static struct ctrl sd_ctrls_ov772x[] = {
110 { /* 0 */
111 {
112 .id = V4L2_CID_BRIGHTNESS,
113 .type = V4L2_CTRL_TYPE_INTEGER,
114 .name = "Brightness",
115 .minimum = 0,
116 .maximum = 255,
117 .step = 1,
118 #define BRIGHTNESS_77_DEF 20
119 .default_value = BRIGHTNESS_77_DEF,
120 },
121 .set = sd_setbrightness,
122 .get = sd_getbrightness,
123 },
124 { /* 1 */
125 {
126 .id = V4L2_CID_CONTRAST,
127 .type = V4L2_CTRL_TYPE_INTEGER,
128 .name = "Contrast",
129 .minimum = 0,
130 .maximum = 255,
131 .step = 1,
132 #define CONTRAST_77_DEF 37
133 .default_value = CONTRAST_77_DEF,
134 },
135 .set = sd_setcontrast,
136 .get = sd_getcontrast,
137 },
138 { /* 2 */
139 {
140 .id = V4L2_CID_GAIN,
141 .type = V4L2_CTRL_TYPE_INTEGER,
142 .name = "Main Gain",
143 .minimum = 0,
144 .maximum = 63,
145 .step = 1,
146 #define GAIN_DEF 20
147 .default_value = GAIN_DEF,
148 },
149 .set = sd_setgain,
150 .get = sd_getgain,
151 },
152 { /* 3 */
153 {
154 .id = V4L2_CID_EXPOSURE,
155 .type = V4L2_CTRL_TYPE_INTEGER,
156 .name = "Exposure",
157 .minimum = 0,
158 .maximum = 255,
159 .step = 1,
160 #define EXPO_77_DEF 120
161 .default_value = EXPO_77_DEF,
162 },
163 .set = sd_setexposure,
164 .get = sd_getexposure,
165 },
166 { /* 4 */
167 {
168 .id = V4L2_CID_RED_BALANCE,
169 .type = V4L2_CTRL_TYPE_INTEGER,
170 .name = "Red Balance",
171 .minimum = 0,
172 .maximum = 255,
173 .step = 1,
174 #define RED_BALANCE_DEF 128
175 .default_value = RED_BALANCE_DEF,
176 },
177 .set = sd_setredblc,
178 .get = sd_getredblc,
179 },
180 { /* 5 */
181 {
182 .id = V4L2_CID_BLUE_BALANCE,
183 .type = V4L2_CTRL_TYPE_INTEGER,
184 .name = "Blue Balance",
185 .minimum = 0,
186 .maximum = 255,
187 .step = 1,
188 #define BLUE_BALANCE_DEF 128
189 .default_value = BLUE_BALANCE_DEF,
190 },
191 .set = sd_setblueblc,
192 .get = sd_getblueblc,
193 },
194 { /* 6 */
195 {
196 .id = V4L2_CID_HUE,
197 .type = V4L2_CTRL_TYPE_INTEGER,
198 .name = "Hue",
199 .minimum = 0,
200 .maximum = 255,
201 .step = 1,
202 #define HUE_DEF 143
203 .default_value = HUE_DEF,
204 },
205 .set = sd_sethue,
206 .get = sd_gethue,
207 },
208 { /* 7 */
209 {
210 .id = V4L2_CID_AUTOGAIN,
211 .type = V4L2_CTRL_TYPE_BOOLEAN,
212 .name = "Autogain",
213 .minimum = 0,
214 .maximum = 1,
215 .step = 1,
216 #define AUTOGAIN_77_DEF 0
217 .default_value = AUTOGAIN_77_DEF,
218 },
219 .set = sd_setautogain,
220 .get = sd_getautogain,
221 },
222 #define AWB_77_IDX 8
223 { /* 8 */
224 {
225 .id = V4L2_CID_AUTO_WHITE_BALANCE,
226 .type = V4L2_CTRL_TYPE_BOOLEAN,
227 .name = "Auto White Balance",
228 .minimum = 0,
229 .maximum = 1,
230 .step = 1,
231 #define AWB_DEF 0
232 .default_value = AWB_DEF,
233 },
234 .set = sd_setawb,
235 .get = sd_getawb,
236 },
237 { /* 9 */
238 {
239 .id = V4L2_CID_SHARPNESS,
240 .type = V4L2_CTRL_TYPE_INTEGER,
241 .name = "Sharpness",
242 .minimum = 0,
243 .maximum = 63,
244 .step = 1,
245 #define SHARPNESS_77_DEF 0
246 .default_value = SHARPNESS_77_DEF,
247 },
248 .set = sd_setsharpness,
249 .get = sd_getsharpness,
250 },
251 { /* 10 */
252 {
253 .id = V4L2_CID_HFLIP,
254 .type = V4L2_CTRL_TYPE_BOOLEAN,
255 .name = "HFlip",
256 .minimum = 0,
257 .maximum = 1,
258 .step = 1,
259 #define HFLIP_DEF 0
260 .default_value = HFLIP_DEF,
261 },
262 .set = sd_sethflip,
263 .get = sd_gethflip,
264 },
265 { /* 11 */
266 {
267 .id = V4L2_CID_VFLIP,
268 .type = V4L2_CTRL_TYPE_BOOLEAN,
269 .name = "VFlip",
270 .minimum = 0,
271 .maximum = 1,
272 .step = 1,
273 #define VFLIP_DEF 0
274 .default_value = VFLIP_DEF,
275 },
276 .set = sd_setvflip,
277 .get = sd_getvflip,
278 },
279 };
280 static struct ctrl sd_ctrls_ov965x[] = {
281 { /* 0 */
282 {
283 .id = V4L2_CID_BRIGHTNESS,
284 .type = V4L2_CTRL_TYPE_INTEGER,
285 .name = "Brightness",
286 .minimum = 0,
287 .maximum = 15,
288 .step = 1,
289 #define BRIGHTNESS_96_DEF 7
290 .default_value = BRIGHTNESS_96_DEF,
291 },
292 .set = sd_setbrightness,
293 .get = sd_getbrightness,
294 },
295 { /* 1 */
296 {
297 .id = V4L2_CID_CONTRAST,
298 .type = V4L2_CTRL_TYPE_INTEGER,
299 .name = "Contrast",
300 .minimum = 0,
301 .maximum = 15,
302 .step = 1,
303 #define CONTRAST_96_DEF 3
304 .default_value = CONTRAST_96_DEF,
305 },
306 .set = sd_setcontrast,
307 .get = sd_getcontrast,
308 },
309 { /* 2 */
310 {
311 .id = V4L2_CID_AUTOGAIN,
312 .type = V4L2_CTRL_TYPE_BOOLEAN,
313 .name = "Autogain",
314 .minimum = 0,
315 .maximum = 1,
316 .step = 1,
317 #define AUTOGAIN_96_DEF 1
318 .default_value = AUTOGAIN_96_DEF,
319 },
320 .set = sd_setautogain,
321 .get = sd_getautogain,
322 },
323 #define EXPO_96_IDX 3
324 { /* 3 */
325 {
326 .id = V4L2_CID_EXPOSURE,
327 .type = V4L2_CTRL_TYPE_INTEGER,
328 .name = "Exposure",
329 .minimum = 0,
330 .maximum = 3,
331 .step = 1,
332 #define EXPO_96_DEF 0
333 .default_value = EXPO_96_DEF,
334 },
335 .set = sd_setexposure,
336 .get = sd_getexposure,
337 },
338 { /* 4 */
339 {
340 .id = V4L2_CID_SHARPNESS,
341 .type = V4L2_CTRL_TYPE_INTEGER,
342 .name = "Sharpness",
343 .minimum = -1, /* -1 = auto */
344 .maximum = 4,
345 .step = 1,
346 #define SHARPNESS_96_DEF -1
347 .default_value = SHARPNESS_96_DEF,
348 },
349 .set = sd_setsharpness,
350 .get = sd_getsharpness,
351 },
352 { /* 5 */
353 {
354 .id = V4L2_CID_SATURATION,
355 .type = V4L2_CTRL_TYPE_INTEGER,
356 .name = "Saturation",
357 .minimum = 0,
358 .maximum = 4,
359 .step = 1,
360 #define SATUR_DEF 2
361 .default_value = SATUR_DEF,
362 },
363 .set = sd_setsatur,
364 .get = sd_getsatur,
365 },
366 {
367 {
368 .id = V4L2_CID_POWER_LINE_FREQUENCY,
369 .type = V4L2_CTRL_TYPE_MENU,
370 .name = "Light frequency filter",
371 .minimum = 0,
372 .maximum = 2, /* 0: 0, 1: 50Hz, 2:60Hz */
373 .step = 1,
374 #define FREQ_DEF 0
375 .default_value = FREQ_DEF,
376 },
377 .set = sd_setfreq,
378 .get = sd_getfreq,
379 },
380 };
381
382 static const struct v4l2_pix_format ov772x_mode[] = {
383 {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
384 .bytesperline = 320 * 2,
385 .sizeimage = 320 * 240 * 2,
386 .colorspace = V4L2_COLORSPACE_SRGB,
387 .priv = 1},
388 {640, 480, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
389 .bytesperline = 640 * 2,
390 .sizeimage = 640 * 480 * 2,
391 .colorspace = V4L2_COLORSPACE_SRGB,
392 .priv = 0},
393 };
394
395 static const struct v4l2_pix_format ov965x_mode[] = {
396 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
397 .bytesperline = 320,
398 .sizeimage = 320 * 240 * 3 / 8 + 590,
399 .colorspace = V4L2_COLORSPACE_JPEG,
400 .priv = 4},
401 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
402 .bytesperline = 640,
403 .sizeimage = 640 * 480 * 3 / 8 + 590,
404 .colorspace = V4L2_COLORSPACE_JPEG,
405 .priv = 3},
406 {800, 600, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
407 .bytesperline = 800,
408 .sizeimage = 800 * 600 * 3 / 8 + 590,
409 .colorspace = V4L2_COLORSPACE_JPEG,
410 .priv = 2},
411 {1024, 768, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
412 .bytesperline = 1024,
413 .sizeimage = 1024 * 768 * 3 / 8 + 590,
414 .colorspace = V4L2_COLORSPACE_JPEG,
415 .priv = 1},
416 {1280, 1024, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
417 .bytesperline = 1280,
418 .sizeimage = 1280 * 1024 * 3 / 8 + 590,
419 .colorspace = V4L2_COLORSPACE_JPEG,
420 .priv = 0},
421 };
422
423 static const u8 bridge_init_ov772x[][2] = {
424 { 0xc2, 0x0c },
425 { 0x88, 0xf8 },
426 { 0xc3, 0x69 },
427 { 0x89, 0xff },
428 { 0x76, 0x03 },
429 { 0x92, 0x01 },
430 { 0x93, 0x18 },
431 { 0x94, 0x10 },
432 { 0x95, 0x10 },
433 { 0xe2, 0x00 },
434 { 0xe7, 0x3e },
435
436 { 0x96, 0x00 },
437
438 { 0x97, 0x20 },
439 { 0x97, 0x20 },
440 { 0x97, 0x20 },
441 { 0x97, 0x0a },
442 { 0x97, 0x3f },
443 { 0x97, 0x4a },
444 { 0x97, 0x20 },
445 { 0x97, 0x15 },
446 { 0x97, 0x0b },
447
448 { 0x8e, 0x40 },
449 { 0x1f, 0x81 },
450 { 0x34, 0x05 },
451 { 0xe3, 0x04 },
452 { 0x88, 0x00 },
453 { 0x89, 0x00 },
454 { 0x76, 0x00 },
455 { 0xe7, 0x2e },
456 { 0x31, 0xf9 },
457 { 0x25, 0x42 },
458 { 0x21, 0xf0 },
459
460 { 0x1c, 0x00 },
461 { 0x1d, 0x40 },
462 { 0x1d, 0x02 }, /* payload size 0x0200 * 4 = 2048 bytes */
463 { 0x1d, 0x00 }, /* payload size */
464
465 { 0x1d, 0x02 }, /* frame size 0x025800 * 4 = 614400 */
466 { 0x1d, 0x58 }, /* frame size */
467 { 0x1d, 0x00 }, /* frame size */
468
469 { 0x1c, 0x0a },
470 { 0x1d, 0x08 }, /* turn on UVC header */
471 { 0x1d, 0x0e }, /* .. */
472
473 { 0x8d, 0x1c },
474 { 0x8e, 0x80 },
475 { 0xe5, 0x04 },
476
477 { 0xc0, 0x50 },
478 { 0xc1, 0x3c },
479 { 0xc2, 0x0c },
480 };
481 static const u8 sensor_init_ov772x[][2] = {
482 { 0x12, 0x80 },
483 { 0x11, 0x01 },
484 /*fixme: better have a delay?*/
485 { 0x11, 0x01 },
486 { 0x11, 0x01 },
487 { 0x11, 0x01 },
488 { 0x11, 0x01 },
489 { 0x11, 0x01 },
490 { 0x11, 0x01 },
491 { 0x11, 0x01 },
492 { 0x11, 0x01 },
493 { 0x11, 0x01 },
494 { 0x11, 0x01 },
495
496 { 0x3d, 0x03 },
497 { 0x17, 0x26 },
498 { 0x18, 0xa0 },
499 { 0x19, 0x07 },
500 { 0x1a, 0xf0 },
501 { 0x32, 0x00 },
502 { 0x29, 0xa0 },
503 { 0x2c, 0xf0 },
504 { 0x65, 0x20 },
505 { 0x11, 0x01 },
506 { 0x42, 0x7f },
507 { 0x63, 0xaa }, /* AWB - was e0 */
508 { 0x64, 0xff },
509 { 0x66, 0x00 },
510 { 0x13, 0xf0 }, /* com8 */
511 { 0x0d, 0x41 },
512 { 0x0f, 0xc5 },
513 { 0x14, 0x11 },
514
515 { 0x22, 0x7f },
516 { 0x23, 0x03 },
517 { 0x24, 0x40 },
518 { 0x25, 0x30 },
519 { 0x26, 0xa1 },
520 { 0x2a, 0x00 },
521 { 0x2b, 0x00 },
522 { 0x6b, 0xaa },
523 { 0x13, 0xff }, /* AWB */
524
525 { 0x90, 0x05 },
526 { 0x91, 0x01 },
527 { 0x92, 0x03 },
528 { 0x93, 0x00 },
529 { 0x94, 0x60 },
530 { 0x95, 0x3c },
531 { 0x96, 0x24 },
532 { 0x97, 0x1e },
533 { 0x98, 0x62 },
534 { 0x99, 0x80 },
535 { 0x9a, 0x1e },
536 { 0x9b, 0x08 },
537 { 0x9c, 0x20 },
538 { 0x9e, 0x81 },
539
540 { 0xa6, 0x04 },
541 { 0x7e, 0x0c },
542 { 0x7f, 0x16 },
543 { 0x80, 0x2a },
544 { 0x81, 0x4e },
545 { 0x82, 0x61 },
546 { 0x83, 0x6f },
547 { 0x84, 0x7b },
548 { 0x85, 0x86 },
549 { 0x86, 0x8e },
550 { 0x87, 0x97 },
551 { 0x88, 0xa4 },
552 { 0x89, 0xaf },
553 { 0x8a, 0xc5 },
554 { 0x8b, 0xd7 },
555 { 0x8c, 0xe8 },
556 { 0x8d, 0x20 },
557
558 { 0x0c, 0x90 },
559
560 { 0x2b, 0x00 },
561 { 0x22, 0x7f },
562 { 0x23, 0x03 },
563 { 0x11, 0x01 },
564 { 0x0c, 0xd0 },
565 { 0x64, 0xff },
566 { 0x0d, 0x41 },
567
568 { 0x14, 0x41 },
569 { 0x0e, 0xcd },
570 { 0xac, 0xbf },
571 { 0x8e, 0x00 }, /* De-noise threshold */
572 { 0x0c, 0xd0 }
573 };
574 static const u8 bridge_start_ov772x_vga[][2] = {
575 {0x1c, 0x00},
576 {0x1d, 0x40},
577 {0x1d, 0x02},
578 {0x1d, 0x00},
579 {0x1d, 0x02},
580 {0x1d, 0x58},
581 {0x1d, 0x00},
582 {0xc0, 0x50},
583 {0xc1, 0x3c},
584 };
585 static const u8 sensor_start_ov772x_vga[][2] = {
586 {0x12, 0x00},
587 {0x17, 0x26},
588 {0x18, 0xa0},
589 {0x19, 0x07},
590 {0x1a, 0xf0},
591 {0x29, 0xa0},
592 {0x2c, 0xf0},
593 {0x65, 0x20},
594 };
595 static const u8 bridge_start_ov772x_qvga[][2] = {
596 {0x1c, 0x00},
597 {0x1d, 0x40},
598 {0x1d, 0x02},
599 {0x1d, 0x00},
600 {0x1d, 0x01},
601 {0x1d, 0x4b},
602 {0x1d, 0x00},
603 {0xc0, 0x28},
604 {0xc1, 0x1e},
605 };
606 static const u8 sensor_start_ov772x_qvga[][2] = {
607 {0x12, 0x40},
608 {0x17, 0x3f},
609 {0x18, 0x50},
610 {0x19, 0x03},
611 {0x1a, 0x78},
612 {0x29, 0x50},
613 {0x2c, 0x78},
614 {0x65, 0x2f},
615 };
616
617 static const u8 bridge_init_ov965x[][2] = {
618 {0x88, 0xf8},
619 {0x89, 0xff},
620 {0x76, 0x03},
621 {0x92, 0x03},
622 {0x95, 0x10},
623 {0xe2, 0x00},
624 {0xe7, 0x3e},
625 {0x8d, 0x1c},
626 {0x8e, 0x00},
627 {0x8f, 0x00},
628 {0x1f, 0x00},
629 {0xc3, 0xf9},
630 {0x89, 0xff},
631 {0x88, 0xf8},
632 {0x76, 0x03},
633 {0x92, 0x01},
634 {0x93, 0x18},
635 {0x1c, 0x0a},
636 {0x1d, 0x48},
637 {0xc0, 0x50},
638 {0xc1, 0x3c},
639 {0x34, 0x05},
640 {0xc2, 0x0c},
641 {0xc3, 0xf9},
642 {0x34, 0x05},
643 {0xe7, 0x2e},
644 {0x31, 0xf9},
645 {0x35, 0x02},
646 {0xd9, 0x10},
647 {0x25, 0x42},
648 {0x94, 0x11},
649 };
650
651 static const u8 sensor_init_ov965x[][2] = {
652 {0x12, 0x80}, /* com7 - SSCB reset */
653 {0x00, 0x00}, /* gain */
654 {0x01, 0x80}, /* blue */
655 {0x02, 0x80}, /* red */
656 {0x03, 0x1b}, /* vref */
657 {0x04, 0x03}, /* com1 - exposure low bits */
658 {0x0b, 0x57}, /* ver */
659 {0x0e, 0x61}, /* com5 */
660 {0x0f, 0x42}, /* com6 */
661 {0x11, 0x00}, /* clkrc */
662 {0x12, 0x02}, /* com7 - 15fps VGA YUYV */
663 {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
664 {0x14, 0x28}, /* com9 */
665 {0x16, 0x24}, /* reg16 */
666 {0x17, 0x1d}, /* hstart*/
667 {0x18, 0xbd}, /* hstop */
668 {0x19, 0x01}, /* vstrt */
669 {0x1a, 0x81}, /* vstop*/
670 {0x1e, 0x04}, /* mvfp */
671 {0x24, 0x3c}, /* aew */
672 {0x25, 0x36}, /* aeb */
673 {0x26, 0x71}, /* vpt */
674 {0x27, 0x08}, /* bbias */
675 {0x28, 0x08}, /* gbbias */
676 {0x29, 0x15}, /* gr com */
677 {0x2a, 0x00}, /* exhch */
678 {0x2b, 0x00}, /* exhcl */
679 {0x2c, 0x08}, /* rbias */
680 {0x32, 0xff}, /* href */
681 {0x33, 0x00}, /* chlf */
682 {0x34, 0x3f}, /* aref1 */
683 {0x35, 0x00}, /* aref2 */
684 {0x36, 0xf8}, /* aref3 */
685 {0x38, 0x72}, /* adc2 */
686 {0x39, 0x57}, /* aref4 */
687 {0x3a, 0x80}, /* tslb - yuyv */
688 {0x3b, 0xc4}, /* com11 - night mode 1/4 frame rate */
689 {0x3d, 0x99}, /* com13 */
690 {0x3f, 0xc1}, /* edge */
691 {0x40, 0xc0}, /* com15 */
692 {0x41, 0x40}, /* com16 */
693 {0x42, 0xc0}, /* com17 */
694 {0x43, 0x0a}, /* rsvd */
695 {0x44, 0xf0},
696 {0x45, 0x46},
697 {0x46, 0x62},
698 {0x47, 0x2a},
699 {0x48, 0x3c},
700 {0x4a, 0xfc},
701 {0x4b, 0xfc},
702 {0x4c, 0x7f},
703 {0x4d, 0x7f},
704 {0x4e, 0x7f},
705 {0x4f, 0x98}, /* matrix */
706 {0x50, 0x98},
707 {0x51, 0x00},
708 {0x52, 0x28},
709 {0x53, 0x70},
710 {0x54, 0x98},
711 {0x58, 0x1a}, /* matrix coef sign */
712 {0x59, 0x85}, /* AWB control */
713 {0x5a, 0xa9},
714 {0x5b, 0x64},
715 {0x5c, 0x84},
716 {0x5d, 0x53},
717 {0x5e, 0x0e},
718 {0x5f, 0xf0}, /* AWB blue limit */
719 {0x60, 0xf0}, /* AWB red limit */
720 {0x61, 0xf0}, /* AWB green limit */
721 {0x62, 0x00}, /* lcc1 */
722 {0x63, 0x00}, /* lcc2 */
723 {0x64, 0x02}, /* lcc3 */
724 {0x65, 0x16}, /* lcc4 */
725 {0x66, 0x01}, /* lcc5 */
726 {0x69, 0x02}, /* hv */
727 {0x6b, 0x5a}, /* dbvl */
728 {0x6c, 0x04},
729 {0x6d, 0x55},
730 {0x6e, 0x00},
731 {0x6f, 0x9d},
732 {0x70, 0x21}, /* dnsth */
733 {0x71, 0x78},
734 {0x72, 0x00}, /* poidx */
735 {0x73, 0x01}, /* pckdv */
736 {0x74, 0x3a}, /* xindx */
737 {0x75, 0x35}, /* yindx */
738 {0x76, 0x01},
739 {0x77, 0x02},
740 {0x7a, 0x12}, /* gamma curve */
741 {0x7b, 0x08},
742 {0x7c, 0x16},
743 {0x7d, 0x30},
744 {0x7e, 0x5e},
745 {0x7f, 0x72},
746 {0x80, 0x82},
747 {0x81, 0x8e},
748 {0x82, 0x9a},
749 {0x83, 0xa4},
750 {0x84, 0xac},
751 {0x85, 0xb8},
752 {0x86, 0xc3},
753 {0x87, 0xd6},
754 {0x88, 0xe6},
755 {0x89, 0xf2},
756 {0x8a, 0x03},
757 {0x8c, 0x89}, /* com19 */
758 {0x14, 0x28}, /* com9 */
759 {0x90, 0x7d},
760 {0x91, 0x7b},
761 {0x9d, 0x03}, /* lcc6 */
762 {0x9e, 0x04}, /* lcc7 */
763 {0x9f, 0x7a},
764 {0xa0, 0x79},
765 {0xa1, 0x40}, /* aechm */
766 {0xa4, 0x50}, /* com21 */
767 {0xa5, 0x68}, /* com26 */
768 {0xa6, 0x4a}, /* AWB green */
769 {0xa8, 0xc1}, /* refa8 */
770 {0xa9, 0xef}, /* refa9 */
771 {0xaa, 0x92},
772 {0xab, 0x04},
773 {0xac, 0x80}, /* black level control */
774 {0xad, 0x80},
775 {0xae, 0x80},
776 {0xaf, 0x80},
777 {0xb2, 0xf2},
778 {0xb3, 0x20},
779 {0xb4, 0x20}, /* ctrlb4 */
780 {0xb5, 0x00},
781 {0xb6, 0xaf},
782 {0xbb, 0xae},
783 {0xbc, 0x7f}, /* ADC channel offsets */
784 {0xdb, 0x7f},
785 {0xbe, 0x7f},
786 {0xbf, 0x7f},
787 {0xc0, 0xe2},
788 {0xc1, 0xc0},
789 {0xc2, 0x01},
790 {0xc3, 0x4e},
791 {0xc6, 0x85},
792 {0xc7, 0x80}, /* com24 */
793 {0xc9, 0xe0},
794 {0xca, 0xe8},
795 {0xcb, 0xf0},
796 {0xcc, 0xd8},
797 {0xcd, 0xf1},
798 {0x4f, 0x98}, /* matrix */
799 {0x50, 0x98},
800 {0x51, 0x00},
801 {0x52, 0x28},
802 {0x53, 0x70},
803 {0x54, 0x98},
804 {0x58, 0x1a},
805 {0xff, 0x41}, /* read 41, write ff 00 */
806 {0x41, 0x40}, /* com16 */
807
808 {0xc5, 0x03}, /* 60 Hz banding filter */
809 {0x6a, 0x02}, /* 50 Hz banding filter */
810
811 {0x12, 0x62}, /* com7 - 30fps VGA YUV */
812 {0x36, 0xfa}, /* aref3 */
813 {0x69, 0x0a}, /* hv */
814 {0x8c, 0x89}, /* com22 */
815 {0x14, 0x28}, /* com9 */
816 {0x3e, 0x0c},
817 {0x41, 0x40}, /* com16 */
818 {0x72, 0x00},
819 {0x73, 0x00},
820 {0x74, 0x3a},
821 {0x75, 0x35},
822 {0x76, 0x01},
823 {0xc7, 0x80},
824 {0x03, 0x12}, /* vref */
825 {0x17, 0x16}, /* hstart */
826 {0x18, 0x02}, /* hstop */
827 {0x19, 0x01}, /* vstrt */
828 {0x1a, 0x3d}, /* vstop */
829 {0x32, 0xff}, /* href */
830 {0xc0, 0xaa},
831 };
832
833 static const u8 bridge_init_ov965x_2[][2] = {
834 {0x94, 0xaa},
835 {0xf1, 0x60},
836 {0xe5, 0x04},
837 {0xc0, 0x50},
838 {0xc1, 0x3c},
839 {0x8c, 0x00},
840 {0x8d, 0x1c},
841 {0x34, 0x05},
842
843 {0xc2, 0x0c},
844 {0xc3, 0xf9},
845 {0xda, 0x01},
846 {0x50, 0x00},
847 {0x51, 0xa0},
848 {0x52, 0x3c},
849 {0x53, 0x00},
850 {0x54, 0x00},
851 {0x55, 0x00},
852 {0x57, 0x00},
853 {0x5c, 0x00},
854 {0x5a, 0xa0},
855 {0x5b, 0x78},
856 {0x35, 0x02},
857 {0xd9, 0x10},
858 {0x94, 0x11},
859 };
860
861 static const u8 sensor_init_ov965x_2[][2] = {
862 {0x3b, 0xc4},
863 {0x1e, 0x04}, /* mvfp */
864 {0x13, 0xe0}, /* com8 */
865 {0x00, 0x00}, /* gain */
866 {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
867 {0x11, 0x03}, /* clkrc */
868 {0x6b, 0x5a}, /* dblv */
869 {0x6a, 0x05},
870 {0xc5, 0x07},
871 {0xa2, 0x4b},
872 {0xa3, 0x3e},
873 {0x2d, 0x00},
874 {0xff, 0x42}, /* read 42, write ff 00 */
875 {0x42, 0xc0}, /* com17 */
876 {0x2d, 0x00},
877 {0xff, 0x42}, /* read 42, write ff 00 */
878 {0x42, 0xc1}, /* com17 */
879 /* sharpness */
880 {0x3f, 0x01},
881 {0xff, 0x42}, /* read 42, write ff 00 */
882 {0x42, 0xc1}, /* com17 */
883 /* saturation */
884 {0x4f, 0x98}, /* matrix */
885 {0x50, 0x98},
886 {0x51, 0x00},
887 {0x52, 0x28},
888 {0x53, 0x70},
889 {0x54, 0x98},
890 {0x58, 0x1a},
891 {0xff, 0x41}, /* read 41, write ff 00 */
892 {0x41, 0x40}, /* com16 */
893 /* contrast */
894 {0x56, 0x40},
895 /* brightness */
896 {0x55, 0x8f},
897 /* expo */
898 {0x10, 0x25}, /* aech - exposure high bits */
899 {0xff, 0x13}, /* read 13, write ff 00 */
900 {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
901 };
902
903 static const u8 sensor_start_ov965x_1_vga[][2] = { /* same for qvga */
904 {0x12, 0x62}, /* com7 - 30fps VGA YUV */
905 {0x36, 0xfa}, /* aref3 */
906 {0x69, 0x0a}, /* hv */
907 {0x8c, 0x89}, /* com22 */
908 {0x14, 0x28}, /* com9 */
909 {0x3e, 0x0c}, /* com14 */
910 {0x41, 0x40}, /* com16 */
911 {0x72, 0x00},
912 {0x73, 0x00},
913 {0x74, 0x3a},
914 {0x75, 0x35},
915 {0x76, 0x01},
916 {0xc7, 0x80}, /* com24 */
917 {0x03, 0x12}, /* vref */
918 {0x17, 0x16}, /* hstart */
919 {0x18, 0x02}, /* hstop */
920 {0x19, 0x01}, /* vstrt */
921 {0x1a, 0x3d}, /* vstop */
922 {0x32, 0xff}, /* href */
923 {0xc0, 0xaa},
924 };
925
926 static const u8 sensor_start_ov965x_1_svga[][2] = {
927 {0x12, 0x02}, /* com7 - YUYV - VGA 15 full resolution */
928 {0x36, 0xf8}, /* aref3 */
929 {0x69, 0x02}, /* hv */
930 {0x8c, 0x0d}, /* com22 */
931 {0x3e, 0x0c}, /* com14 */
932 {0x41, 0x40}, /* com16 */
933 {0x72, 0x00},
934 {0x73, 0x01},
935 {0x74, 0x3a},
936 {0x75, 0x35},
937 {0x76, 0x01},
938 {0xc7, 0x80}, /* com24 */
939 {0x03, 0x1b}, /* vref */
940 {0x17, 0x1d}, /* hstart */
941 {0x18, 0xbd}, /* hstop */
942 {0x19, 0x01}, /* vstrt */
943 {0x1a, 0x81}, /* vstop */
944 {0x32, 0xff}, /* href */
945 {0xc0, 0xe2},
946 };
947
948 static const u8 sensor_start_ov965x_1_xga[][2] = {
949 {0x12, 0x02}, /* com7 */
950 {0x36, 0xf8}, /* aref3 */
951 {0x69, 0x02}, /* hv */
952 {0x8c, 0x89}, /* com22 */
953 {0x14, 0x28}, /* com9 */
954 {0x3e, 0x0c}, /* com14 */
955 {0x41, 0x40}, /* com16 */
956 {0x72, 0x00},
957 {0x73, 0x01},
958 {0x74, 0x3a},
959 {0x75, 0x35},
960 {0x76, 0x01},
961 {0xc7, 0x80}, /* com24 */
962 {0x03, 0x1b}, /* vref */
963 {0x17, 0x1d}, /* hstart */
964 {0x18, 0xbd}, /* hstop */
965 {0x19, 0x01}, /* vstrt */
966 {0x1a, 0x81}, /* vstop */
967 {0x32, 0xff}, /* href */
968 {0xc0, 0xe2},
969 };
970
971 static const u8 sensor_start_ov965x_1_sxga[][2] = {
972 {0x12, 0x02}, /* com7 */
973 {0x36, 0xf8}, /* aref3 */
974 {0x69, 0x02}, /* hv */
975 {0x8c, 0x89}, /* com22 */
976 {0x14, 0x28}, /* com9 */
977 {0x3e, 0x0c}, /* com14 */
978 {0x41, 0x40}, /* com16 */
979 {0x72, 0x00},
980 {0x73, 0x01},
981 {0x74, 0x3a},
982 {0x75, 0x35},
983 {0x76, 0x01},
984 {0xc7, 0x80}, /* com24 */
985 {0x03, 0x1b}, /* vref */
986 {0x17, 0x1d}, /* hstart */
987 {0x18, 0x02}, /* hstop */
988 {0x19, 0x01}, /* vstrt */
989 {0x1a, 0x81}, /* vstop */
990 {0x32, 0xff}, /* href */
991 {0xc0, 0xe2},
992 };
993
994 static const u8 bridge_start_ov965x_qvga[][2] = {
995 {0x94, 0xaa},
996 {0xf1, 0x60},
997 {0xe5, 0x04},
998 {0xc0, 0x50},
999 {0xc1, 0x3c},
1000 {0x8c, 0x00},
1001 {0x8d, 0x1c},
1002 {0x34, 0x05},
1003
1004 {0xc2, 0x4c},
1005 {0xc3, 0xf9},
1006 {0xda, 0x00},
1007 {0x50, 0x00},
1008 {0x51, 0xa0},
1009 {0x52, 0x78},
1010 {0x53, 0x00},
1011 {0x54, 0x00},
1012 {0x55, 0x00},
1013 {0x57, 0x00},
1014 {0x5c, 0x00},
1015 {0x5a, 0x50},
1016 {0x5b, 0x3c},
1017 {0x35, 0x02},
1018 {0xd9, 0x10},
1019 {0x94, 0x11},
1020 };
1021
1022 static const u8 bridge_start_ov965x_vga[][2] = {
1023 {0x94, 0xaa},
1024 {0xf1, 0x60},
1025 {0xe5, 0x04},
1026 {0xc0, 0x50},
1027 {0xc1, 0x3c},
1028 {0x8c, 0x00},
1029 {0x8d, 0x1c},
1030 {0x34, 0x05},
1031 {0xc2, 0x0c},
1032 {0xc3, 0xf9},
1033 {0xda, 0x01},
1034 {0x50, 0x00},
1035 {0x51, 0xa0},
1036 {0x52, 0x3c},
1037 {0x53, 0x00},
1038 {0x54, 0x00},
1039 {0x55, 0x00},
1040 {0x57, 0x00},
1041 {0x5c, 0x00},
1042 {0x5a, 0xa0},
1043 {0x5b, 0x78},
1044 {0x35, 0x02},
1045 {0xd9, 0x10},
1046 {0x94, 0x11},
1047 };
1048
1049 static const u8 bridge_start_ov965x_svga[][2] = {
1050 {0x94, 0xaa},
1051 {0xf1, 0x60},
1052 {0xe5, 0x04},
1053 {0xc0, 0xa0},
1054 {0xc1, 0x80},
1055 {0x8c, 0x00},
1056 {0x8d, 0x1c},
1057 {0x34, 0x05},
1058 {0xc2, 0x4c},
1059 {0xc3, 0xf9},
1060 {0x50, 0x00},
1061 {0x51, 0x40},
1062 {0x52, 0x00},
1063 {0x53, 0x00},
1064 {0x54, 0x00},
1065 {0x55, 0x88},
1066 {0x57, 0x00},
1067 {0x5c, 0x00},
1068 {0x5a, 0xc8},
1069 {0x5b, 0x96},
1070 {0x35, 0x02},
1071 {0xd9, 0x10},
1072 {0xda, 0x00},
1073 {0x94, 0x11},
1074 };
1075
1076 static const u8 bridge_start_ov965x_xga[][2] = {
1077 {0x94, 0xaa},
1078 {0xf1, 0x60},
1079 {0xe5, 0x04},
1080 {0xc0, 0xa0},
1081 {0xc1, 0x80},
1082 {0x8c, 0x00},
1083 {0x8d, 0x1c},
1084 {0x34, 0x05},
1085 {0xc2, 0x4c},
1086 {0xc3, 0xf9},
1087 {0x50, 0x00},
1088 {0x51, 0x40},
1089 {0x52, 0x00},
1090 {0x53, 0x00},
1091 {0x54, 0x00},
1092 {0x55, 0x88},
1093 {0x57, 0x00},
1094 {0x5c, 0x01},
1095 {0x5a, 0x00},
1096 {0x5b, 0xc0},
1097 {0x35, 0x02},
1098 {0xd9, 0x10},
1099 {0xda, 0x01},
1100 {0x94, 0x11},
1101 };
1102
1103 static const u8 bridge_start_ov965x_sxga[][2] = {
1104 {0x94, 0xaa},
1105 {0xf1, 0x60},
1106 {0xe5, 0x04},
1107 {0xc0, 0xa0},
1108 {0xc1, 0x80},
1109 {0x8c, 0x00},
1110 {0x8d, 0x1c},
1111 {0x34, 0x05},
1112 {0xc2, 0x0c},
1113 {0xc3, 0xf9},
1114 {0xda, 0x00},
1115 {0x35, 0x02},
1116 {0xd9, 0x10},
1117 {0x94, 0x11},
1118 };
1119
1120 static const u8 sensor_start_ov965x_2_qvga[][2] = {
1121 {0x3b, 0xe4}, /* com11 - night mode 1/4 frame rate */
1122 {0x1e, 0x04}, /* mvfp */
1123 {0x13, 0xe0}, /* com8 */
1124 {0x00, 0x00},
1125 {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
1126 {0x11, 0x01}, /* clkrc */
1127 {0x6b, 0x5a}, /* dblv */
1128 {0x6a, 0x02}, /* 50 Hz banding filter */
1129 {0xc5, 0x03}, /* 60 Hz banding filter */
1130 {0xa2, 0x96}, /* bd50 */
1131 {0xa3, 0x7d}, /* bd60 */
1132
1133 {0xff, 0x13}, /* read 13, write ff 00 */
1134 {0x13, 0xe7},
1135 {0x3a, 0x80}, /* tslb - yuyv */
1136 };
1137
1138 static const u8 sensor_start_ov965x_2_vga[][2] = {
1139 {0x3b, 0xc4}, /* com11 - night mode 1/4 frame rate */
1140 {0x1e, 0x04}, /* mvfp */
1141 {0x13, 0xe0}, /* com8 */
1142 {0x00, 0x00},
1143 {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
1144 {0x11, 0x03}, /* clkrc */
1145 {0x6b, 0x5a}, /* dblv */
1146 {0x6a, 0x05}, /* 50 Hz banding filter */
1147 {0xc5, 0x07}, /* 60 Hz banding filter */
1148 {0xa2, 0x4b}, /* bd50 */
1149 {0xa3, 0x3e}, /* bd60 */
1150
1151 {0x2d, 0x00}, /* advfl */
1152 };
1153
1154 static const u8 sensor_start_ov965x_2_svga[][2] = { /* same for xga */
1155 {0x3b, 0xc4}, /* com11 - night mode 1/4 frame rate */
1156 {0x1e, 0x04}, /* mvfp */
1157 {0x13, 0xe0}, /* com8 */
1158 {0x00, 0x00},
1159 {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
1160 {0x11, 0x01}, /* clkrc */
1161 {0x6b, 0x5a}, /* dblv */
1162 {0x6a, 0x0c}, /* 50 Hz banding filter */
1163 {0xc5, 0x0f}, /* 60 Hz banding filter */
1164 {0xa2, 0x4e}, /* bd50 */
1165 {0xa3, 0x41}, /* bd60 */
1166 };
1167
1168 static const u8 sensor_start_ov965x_2_sxga[][2] = {
1169 {0x13, 0xe0}, /* com8 */
1170 {0x00, 0x00},
1171 {0x13, 0xe7}, /* com8 - everything (AGC, AWB and AEC) */
1172 {0x3b, 0xc4}, /* com11 - night mode 1/4 frame rate */
1173 {0x1e, 0x04}, /* mvfp */
1174 {0x11, 0x01}, /* clkrc */
1175 {0x6b, 0x5a}, /* dblv */
1176 {0x6a, 0x0c}, /* 50 Hz banding filter */
1177 {0xc5, 0x0f}, /* 60 Hz banding filter */
1178 {0xa2, 0x4e}, /* bd50 */
1179 {0xa3, 0x41}, /* bd60 */
1180 };
1181
1182 static void ov534_reg_write(struct gspca_dev *gspca_dev, u16 reg, u8 val)
1183 {
1184 struct usb_device *udev = gspca_dev->dev;
1185 int ret;
1186
1187 PDEBUG(D_USBO, "reg=0x%04x, val=0%02x", reg, val);
1188 gspca_dev->usb_buf[0] = val;
1189 ret = usb_control_msg(udev,
1190 usb_sndctrlpipe(udev, 0),
1191 0x01,
1192 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1193 0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
1194 if (ret < 0)
1195 PDEBUG(D_ERR, "write failed");
1196 }
1197
1198 static u8 ov534_reg_read(struct gspca_dev *gspca_dev, u16 reg)
1199 {
1200 struct usb_device *udev = gspca_dev->dev;
1201 int ret;
1202
1203 ret = usb_control_msg(udev,
1204 usb_rcvctrlpipe(udev, 0),
1205 0x01,
1206 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1207 0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
1208 PDEBUG(D_USBI, "reg=0x%04x, data=0x%02x", reg, gspca_dev->usb_buf[0]);
1209 if (ret < 0)
1210 PDEBUG(D_ERR, "read failed");
1211 return gspca_dev->usb_buf[0];
1212 }
1213
1214 /* Two bits control LED: 0x21 bit 7 and 0x23 bit 7.
1215 * (direction and output)? */
1216 static void ov534_set_led(struct gspca_dev *gspca_dev, int status)
1217 {
1218 u8 data;
1219
1220 PDEBUG(D_CONF, "led status: %d", status);
1221
1222 data = ov534_reg_read(gspca_dev, 0x21);
1223 data |= 0x80;
1224 ov534_reg_write(gspca_dev, 0x21, data);
1225
1226 data = ov534_reg_read(gspca_dev, 0x23);
1227 if (status)
1228 data |= 0x80;
1229 else
1230 data &= ~0x80;
1231
1232 ov534_reg_write(gspca_dev, 0x23, data);
1233
1234 if (!status) {
1235 data = ov534_reg_read(gspca_dev, 0x21);
1236 data &= ~0x80;
1237 ov534_reg_write(gspca_dev, 0x21, data);
1238 }
1239 }
1240
1241 static int sccb_check_status(struct gspca_dev *gspca_dev)
1242 {
1243 u8 data;
1244 int i;
1245
1246 for (i = 0; i < 5; i++) {
1247 data = ov534_reg_read(gspca_dev, OV534_REG_STATUS);
1248
1249 switch (data) {
1250 case 0x00:
1251 return 1;
1252 case 0x04:
1253 return 0;
1254 case 0x03:
1255 break;
1256 default:
1257 PDEBUG(D_ERR, "sccb status 0x%02x, attempt %d/5",
1258 data, i + 1);
1259 }
1260 }
1261 return 0;
1262 }
1263
1264 static void sccb_reg_write(struct gspca_dev *gspca_dev, u8 reg, u8 val)
1265 {
1266 PDEBUG(D_USBO, "reg: 0x%02x, val: 0x%02x", reg, val);
1267 ov534_reg_write(gspca_dev, OV534_REG_SUBADDR, reg);
1268 ov534_reg_write(gspca_dev, OV534_REG_WRITE, val);
1269 ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_3);
1270
1271 if (!sccb_check_status(gspca_dev))
1272 PDEBUG(D_ERR, "sccb_reg_write failed");
1273 }
1274
1275 static u8 sccb_reg_read(struct gspca_dev *gspca_dev, u16 reg)
1276 {
1277 ov534_reg_write(gspca_dev, OV534_REG_SUBADDR, reg);
1278 ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_2);
1279 if (!sccb_check_status(gspca_dev))
1280 PDEBUG(D_ERR, "sccb_reg_read failed 1");
1281
1282 ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_READ_2);
1283 if (!sccb_check_status(gspca_dev))
1284 PDEBUG(D_ERR, "sccb_reg_read failed 2");
1285
1286 return ov534_reg_read(gspca_dev, OV534_REG_READ);
1287 }
1288
1289 /* output a bridge sequence (reg - val) */
1290 static void reg_w_array(struct gspca_dev *gspca_dev,
1291 const u8 (*data)[2], int len)
1292 {
1293 while (--len >= 0) {
1294 ov534_reg_write(gspca_dev, (*data)[0], (*data)[1]);
1295 data++;
1296 }
1297 }
1298
1299 /* output a sensor sequence (reg - val) */
1300 static void sccb_w_array(struct gspca_dev *gspca_dev,
1301 const u8 (*data)[2], int len)
1302 {
1303 while (--len >= 0) {
1304 if ((*data)[0] != 0xff) {
1305 sccb_reg_write(gspca_dev, (*data)[0], (*data)[1]);
1306 } else {
1307 sccb_reg_read(gspca_dev, (*data)[1]);
1308 sccb_reg_write(gspca_dev, 0xff, 0x00);
1309 }
1310 data++;
1311 }
1312 }
1313
1314 /* ov772x specific controls */
1315 static void set_frame_rate(struct gspca_dev *gspca_dev)
1316 {
1317 struct sd *sd = (struct sd *) gspca_dev;
1318 int i;
1319 struct rate_s {
1320 u8 fps;
1321 u8 r11;
1322 u8 r0d;
1323 u8 re5;
1324 };
1325 const struct rate_s *r;
1326 static const struct rate_s rate_0[] = { /* 640x480 */
1327 {60, 0x01, 0xc1, 0x04},
1328 {50, 0x01, 0x41, 0x02},
1329 {40, 0x02, 0xc1, 0x04},
1330 {30, 0x04, 0x81, 0x02},
1331 {15, 0x03, 0x41, 0x04},
1332 };
1333 static const struct rate_s rate_1[] = { /* 320x240 */
1334 {125, 0x02, 0x81, 0x02},
1335 {100, 0x02, 0xc1, 0x04},
1336 {75, 0x03, 0xc1, 0x04},
1337 {60, 0x04, 0xc1, 0x04},
1338 {50, 0x02, 0x41, 0x04},
1339 {40, 0x03, 0x41, 0x04},
1340 {30, 0x04, 0x41, 0x04},
1341 };
1342
1343 if (gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv == 0) {
1344 r = rate_0;
1345 i = ARRAY_SIZE(rate_0);
1346 } else {
1347 r = rate_1;
1348 i = ARRAY_SIZE(rate_1);
1349 }
1350 while (--i > 0) {
1351 if (sd->frame_rate >= r->fps)
1352 break;
1353 r++;
1354 }
1355
1356 sccb_reg_write(gspca_dev, 0x11, r->r11);
1357 sccb_reg_write(gspca_dev, 0x0d, r->r0d);
1358 ov534_reg_write(gspca_dev, 0xe5, r->re5);
1359
1360 PDEBUG(D_PROBE, "frame_rate: %d", r->fps);
1361 }
1362
1363 static void setbrightness_77(struct gspca_dev *gspca_dev)
1364 {
1365 struct sd *sd = (struct sd *) gspca_dev;
1366
1367 sccb_reg_write(gspca_dev, 0x9B, sd->brightness);
1368 }
1369
1370 static void setcontrast_77(struct gspca_dev *gspca_dev)
1371 {
1372 struct sd *sd = (struct sd *) gspca_dev;
1373
1374 sccb_reg_write(gspca_dev, 0x9C, sd->contrast);
1375 }
1376
1377 static void setgain(struct gspca_dev *gspca_dev)
1378 {
1379 struct sd *sd = (struct sd *) gspca_dev;
1380 u8 val;
1381
1382 val = sd->gain;
1383 switch (val & 0x30) {
1384 case 0x00:
1385 val &= 0x0f;
1386 break;
1387 case 0x10:
1388 val &= 0x0f;
1389 val |= 0x30;
1390 break;
1391 case 0x20:
1392 val &= 0x0f;
1393 val |= 0x70;
1394 break;
1395 default:
1396 /* case 0x30: */
1397 val &= 0x0f;
1398 val |= 0xf0;
1399 break;
1400 }
1401 sccb_reg_write(gspca_dev, 0x00, val);
1402 }
1403
1404 static void setexposure_77(struct gspca_dev *gspca_dev)
1405 {
1406 struct sd *sd = (struct sd *) gspca_dev;
1407 u8 val;
1408
1409 val = sd->exposure;
1410 sccb_reg_write(gspca_dev, 0x08, val >> 7);
1411 sccb_reg_write(gspca_dev, 0x10, val << 1);
1412 }
1413
1414 static void setredblc(struct gspca_dev *gspca_dev)
1415 {
1416 struct sd *sd = (struct sd *) gspca_dev;
1417
1418 sccb_reg_write(gspca_dev, 0x43, sd->redblc);
1419 }
1420
1421 static void setblueblc(struct gspca_dev *gspca_dev)
1422 {
1423 struct sd *sd = (struct sd *) gspca_dev;
1424
1425 sccb_reg_write(gspca_dev, 0x42, sd->blueblc);
1426 }
1427
1428 static void sethue(struct gspca_dev *gspca_dev)
1429 {
1430 struct sd *sd = (struct sd *) gspca_dev;
1431
1432 sccb_reg_write(gspca_dev, 0x01, sd->hue);
1433 }
1434
1435 static void setautogain_77(struct gspca_dev *gspca_dev)
1436 {
1437 struct sd *sd = (struct sd *) gspca_dev;
1438
1439 if (sd->autogain) {
1440 sccb_reg_write(gspca_dev, 0x13, 0xf7); /* AGC,AEC,AWB ON */
1441 sccb_reg_write(gspca_dev, 0x64,
1442 sccb_reg_read(gspca_dev, 0x64) | 0x03);
1443 } else {
1444 sccb_reg_write(gspca_dev, 0x13, 0xf0); /* AGC,AEC,AWB OFF */
1445 sccb_reg_write(gspca_dev, 0x64,
1446 sccb_reg_read(gspca_dev, 0x64) & 0xfc);
1447 }
1448 }
1449
1450 static void setawb(struct gspca_dev *gspca_dev)
1451 {
1452 struct sd *sd = (struct sd *) gspca_dev;
1453
1454 if (sd->awb)
1455 sccb_reg_write(gspca_dev, 0x63, 0xe0); /* AWB on */
1456 else
1457 sccb_reg_write(gspca_dev, 0x63, 0xaa); /* AWB off */
1458 }
1459
1460 static void setsharpness_77(struct gspca_dev *gspca_dev)
1461 {
1462 struct sd *sd = (struct sd *) gspca_dev;
1463 u8 val;
1464
1465 val = sd->sharpness;
1466 sccb_reg_write(gspca_dev, 0x91, val); /* vga noise */
1467 sccb_reg_write(gspca_dev, 0x8e, val); /* qvga noise */
1468 }
1469
1470 static void sethflip(struct gspca_dev *gspca_dev)
1471 {
1472 struct sd *sd = (struct sd *) gspca_dev;
1473
1474 if (sd->hflip == 0)
1475 sccb_reg_write(gspca_dev, 0x0c,
1476 sccb_reg_read(gspca_dev, 0x0c) | 0x40);
1477 else
1478 sccb_reg_write(gspca_dev, 0x0c,
1479 sccb_reg_read(gspca_dev, 0x0c) & 0xbf);
1480 }
1481
1482 static void setvflip(struct gspca_dev *gspca_dev)
1483 {
1484 struct sd *sd = (struct sd *) gspca_dev;
1485
1486 if (sd->vflip == 0)
1487 sccb_reg_write(gspca_dev, 0x0c,
1488 sccb_reg_read(gspca_dev, 0x0c) | 0x80);
1489 else
1490 sccb_reg_write(gspca_dev, 0x0c,
1491 sccb_reg_read(gspca_dev, 0x0c) & 0x7f);
1492 }
1493
1494 /* ov965x specific controls */
1495 static void setbrightness_96(struct gspca_dev *gspca_dev)
1496 {
1497 struct sd *sd = (struct sd *) gspca_dev;
1498 u8 val;
1499
1500 val = sd->brightness;
1501 if (val < 8)
1502 val = 15 - val; /* f .. 8 */
1503 else
1504 val = val - 8; /* 0 .. 7 */
1505 sccb_reg_write(gspca_dev, 0x55, /* brtn - brightness adjustment */
1506 0x0f | (val << 4));
1507 }
1508
1509 static void setcontrast_96(struct gspca_dev *gspca_dev)
1510 {
1511 struct sd *sd = (struct sd *) gspca_dev;
1512
1513 sccb_reg_write(gspca_dev, 0x56, /* cnst1 - contrast 1 ctrl coeff */
1514 sd->contrast << 4);
1515 }
1516
1517 static void setexposure_96(struct gspca_dev *gspca_dev)
1518 {
1519 struct sd *sd = (struct sd *) gspca_dev;
1520 u8 val;
1521 static const u8 expo[4] = {0x00, 0x25, 0x38, 0x5e};
1522
1523 sccb_reg_write(gspca_dev, 0x10, /* aec[9:2] */
1524 expo[sd->exposure]);
1525 val = sccb_reg_read(gspca_dev, 0x13); /* com8 */
1526 sccb_reg_write(gspca_dev, 0xff, 0x00);
1527 sccb_reg_write(gspca_dev, 0x13, val);
1528 val = sccb_reg_read(gspca_dev, 0xa1); /* aech */
1529 sccb_reg_write(gspca_dev, 0xff, 0x00);
1530 sccb_reg_write(gspca_dev, 0xa1, val & 0xe0); /* aec[15:10] = 0 */
1531 }
1532
1533 static void setsharpness_96(struct gspca_dev *gspca_dev)
1534 {
1535 struct sd *sd = (struct sd *) gspca_dev;
1536 u8 val;
1537
1538 val = sd->sharpness;
1539 if (val < 0) { /* auto */
1540 val = sccb_reg_read(gspca_dev, 0x42); /* com17 */
1541 sccb_reg_write(gspca_dev, 0xff, 0x00);
1542 sccb_reg_write(gspca_dev, 0x42, val | 0x40);
1543 /* Edge enhancement strength auto adjust */
1544 return;
1545 }
1546 if (val != 0)
1547 val = 1 << (val - 1);
1548 sccb_reg_write(gspca_dev, 0x3f, /* edge - edge enhance. factor */
1549 val);
1550 val = sccb_reg_read(gspca_dev, 0x42); /* com17 */
1551 sccb_reg_write(gspca_dev, 0xff, 0x00);
1552 sccb_reg_write(gspca_dev, 0x42, val & 0xbf);
1553 }
1554
1555 static void setautogain_96(struct gspca_dev *gspca_dev)
1556 {
1557 struct sd *sd = (struct sd *) gspca_dev;
1558 u8 val;
1559
1560 /*fixme: should adjust agc/awb/aec by different controls */
1561 val = sd->autogain;
1562 val = sccb_reg_read(gspca_dev, 0x13); /* com8 */
1563 sccb_reg_write(gspca_dev, 0xff, 0x00);
1564 if (sd->autogain)
1565 val |= 0x05; /* agc & aec */
1566 else
1567 val &= 0xfa;
1568 sccb_reg_write(gspca_dev, 0x13, val);
1569 }
1570
1571 static void setsatur(struct gspca_dev *gspca_dev)
1572 {
1573 struct sd *sd = (struct sd *) gspca_dev;
1574 u8 val1, val2, val3;
1575 static const u8 matrix[5][2] = {
1576 {0x14, 0x38},
1577 {0x1e, 0x54},
1578 {0x28, 0x70},
1579 {0x32, 0x8c},
1580 {0x48, 0x90}
1581 };
1582
1583 val1 = matrix[sd->satur][0];
1584 val2 = matrix[sd->satur][1];
1585 val3 = val1 + val2;
1586 sccb_reg_write(gspca_dev, 0x4f, val3); /* matrix coeff */
1587 sccb_reg_write(gspca_dev, 0x50, val3);
1588 sccb_reg_write(gspca_dev, 0x51, 0x00);
1589 sccb_reg_write(gspca_dev, 0x52, val1);
1590 sccb_reg_write(gspca_dev, 0x53, val2);
1591 sccb_reg_write(gspca_dev, 0x54, val3);
1592 sccb_reg_write(gspca_dev, 0x58, 0x1a); /* mtxs - coeff signs */
1593 val1 = sccb_reg_read(gspca_dev, 0x41); /* com16 */
1594 sccb_reg_write(gspca_dev, 0xff, 0x00);
1595 sccb_reg_write(gspca_dev, 0x41, val1);
1596 }
1597
1598 static void setfreq(struct gspca_dev *gspca_dev)
1599 {
1600 struct sd *sd = (struct sd *) gspca_dev;
1601 u8 val;
1602
1603 val = sccb_reg_read(gspca_dev, 0x13); /* com8 */
1604 sccb_reg_write(gspca_dev, 0xff, 0x00);
1605 if (sd->lightfreq == 0) {
1606 sccb_reg_write(gspca_dev, 0x13, val & 0xdf);
1607 return;
1608 }
1609 sccb_reg_write(gspca_dev, 0x13, val | 0x20);
1610
1611 val = sccb_reg_read(gspca_dev, 0x42); /* com17 */
1612 sccb_reg_write(gspca_dev, 0xff, 0x00);
1613 if (sd->lightfreq == 1)
1614 val |= 0x01;
1615 else
1616 val &= 0xfe;
1617 sccb_reg_write(gspca_dev, 0x42, val);
1618 }
1619
1620 /* this function is called at probe time */
1621 static int sd_config(struct gspca_dev *gspca_dev,
1622 const struct usb_device_id *id)
1623 {
1624 struct sd *sd = (struct sd *) gspca_dev;
1625 struct cam *cam;
1626
1627 sd->sensor = id->driver_info;
1628
1629 cam = &gspca_dev->cam;
1630
1631 if (sd->sensor == SENSOR_OV772X) {
1632 cam->cam_mode = ov772x_mode;
1633 cam->nmodes = ARRAY_SIZE(ov772x_mode);
1634
1635 cam->bulk = 1;
1636 cam->bulk_size = 16384;
1637 cam->bulk_nurbs = 2;
1638 } else { /* ov965x */
1639 cam->cam_mode = ov965x_mode;
1640 cam->nmodes = ARRAY_SIZE(ov965x_mode);
1641 }
1642
1643 sd->frame_rate = 30;
1644
1645 if (sd->sensor == SENSOR_OV772X) {
1646 sd->brightness = BRIGHTNESS_77_DEF;
1647 sd->contrast = CONTRAST_77_DEF;
1648 sd->gain = GAIN_DEF;
1649 sd->exposure = EXPO_77_DEF;
1650 sd->redblc = RED_BALANCE_DEF;
1651 sd->blueblc = BLUE_BALANCE_DEF;
1652 sd->hue = HUE_DEF;
1653 #if AUTOGAIN_77_DEF != 0
1654 sd->autogain = AUTOGAIN_77_DEF;
1655 #else
1656 gspca_dev->ctrl_inac |= (1 << AWB_77_IDX);
1657 #endif
1658 #if AWB_DEF != 0
1659 sd->awb = AWB_DEF
1660 #endif
1661 #if SHARPNESS_77_DEF != 0
1662 sd->sharpness = SHARPNESS_77_DEF;
1663 #endif
1664 #if HFLIP_DEF != 0
1665 sd->hflip = HFLIP_DEF;
1666 #endif
1667 #if VFLIP_DEF != 0
1668 sd->vflip = VFLIP_DEF;
1669 #endif
1670 } else {
1671 sd->brightness = BRIGHTNESS_96_DEF;
1672 sd->contrast = CONTRAST_96_DEF;
1673 #if AUTOGAIN_96_DEF != 0
1674 sd->autogain = AUTOGAIN_96_DEF;
1675 gspca_dev->ctrl_inac |= (1 << EXPO_96_IDX);
1676 #endif
1677 #if EXPO_96_DEF != 0
1678 sd->exposure = EXPO_96_DEF;
1679 #endif
1680 #if SHARPNESS_96_DEF != 0
1681 sd->sharpness = SHARPNESS_96_DEF;
1682 #endif
1683 sd->satur = SATUR_DEF;
1684 sd->lightfreq = FREQ_DEF;
1685 }
1686 return 0;
1687 }
1688
1689 /* this function is called at probe and resume time */
1690 static int sd_init(struct gspca_dev *gspca_dev)
1691 {
1692 struct sd *sd = (struct sd *) gspca_dev;
1693 u16 sensor_id;
1694 static const u8 sensor_addr[2] = {
1695 0x42, /* 0 SENSOR_OV772X */
1696 0x60, /* 1 SENSOR_OV965X */
1697 };
1698
1699 /* reset bridge */
1700 ov534_reg_write(gspca_dev, 0xe7, 0x3a);
1701 ov534_reg_write(gspca_dev, 0xe0, 0x08);
1702 msleep(100);
1703
1704 /* initialize the sensor address */
1705 ov534_reg_write(gspca_dev, OV534_REG_ADDRESS,
1706 sensor_addr[sd->sensor]);
1707
1708 /* reset sensor */
1709 sccb_reg_write(gspca_dev, 0x12, 0x80);
1710 msleep(10);
1711
1712 /* probe the sensor */
1713 sccb_reg_read(gspca_dev, 0x0a);
1714 sensor_id = sccb_reg_read(gspca_dev, 0x0a) << 8;
1715 sccb_reg_read(gspca_dev, 0x0b);
1716 sensor_id |= sccb_reg_read(gspca_dev, 0x0b);
1717 PDEBUG(D_PROBE, "Sensor ID: %04x", sensor_id);
1718
1719 /* initialize */
1720 switch (sd->sensor) {
1721 case SENSOR_OV772X:
1722 reg_w_array(gspca_dev, bridge_init_ov772x,
1723 ARRAY_SIZE(bridge_init_ov772x));
1724 ov534_set_led(gspca_dev, 1);
1725 sccb_w_array(gspca_dev, sensor_init_ov772x,
1726 ARRAY_SIZE(sensor_init_ov772x));
1727 ov534_reg_write(gspca_dev, 0xe0, 0x09);
1728 ov534_set_led(gspca_dev, 0);
1729 set_frame_rate(gspca_dev);
1730 break;
1731 default:
1732 /* case SENSOR_OV965X: */
1733 reg_w_array(gspca_dev, bridge_init_ov965x,
1734 ARRAY_SIZE(bridge_init_ov965x));
1735 sccb_w_array(gspca_dev, sensor_init_ov965x,
1736 ARRAY_SIZE(sensor_init_ov965x));
1737 reg_w_array(gspca_dev, bridge_init_ov965x_2,
1738 ARRAY_SIZE(bridge_init_ov965x_2));
1739 sccb_w_array(gspca_dev, sensor_init_ov965x_2,
1740 ARRAY_SIZE(sensor_init_ov965x_2));
1741 ov534_reg_write(gspca_dev, 0xe0, 0x00);
1742 ov534_reg_write(gspca_dev, 0xe0, 0x01);
1743 ov534_set_led(gspca_dev, 0);
1744 ov534_reg_write(gspca_dev, 0xe0, 0x00);
1745 }
1746
1747 return 0;
1748 }
1749
1750 static int sd_start_ov772x(struct gspca_dev *gspca_dev)
1751 {
1752 int mode;
1753
1754 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
1755 if (mode != 0) { /* 320x240 */
1756 reg_w_array(gspca_dev, bridge_start_ov772x_qvga,
1757 ARRAY_SIZE(bridge_start_ov772x_qvga));
1758 sccb_w_array(gspca_dev, sensor_start_ov772x_qvga,
1759 ARRAY_SIZE(sensor_start_ov772x_qvga));
1760 } else { /* 640x480 */
1761 reg_w_array(gspca_dev, bridge_start_ov772x_vga,
1762 ARRAY_SIZE(bridge_start_ov772x_vga));
1763 sccb_w_array(gspca_dev, sensor_start_ov772x_vga,
1764 ARRAY_SIZE(sensor_start_ov772x_vga));
1765 }
1766 set_frame_rate(gspca_dev);
1767
1768 setautogain_77(gspca_dev);
1769 setawb(gspca_dev);
1770 setgain(gspca_dev);
1771 setredblc(gspca_dev);
1772 setblueblc(gspca_dev);
1773 sethue(gspca_dev);
1774 setexposure_77(gspca_dev);
1775 setbrightness_77(gspca_dev);
1776 setcontrast_77(gspca_dev);
1777 setsharpness_77(gspca_dev);
1778 setvflip(gspca_dev);
1779 sethflip(gspca_dev);
1780
1781 ov534_set_led(gspca_dev, 1);
1782 ov534_reg_write(gspca_dev, 0xe0, 0x00);
1783 return 0;
1784 }
1785
1786 static int sd_start_ov965x(struct gspca_dev *gspca_dev)
1787 {
1788 int mode;
1789
1790 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
1791 switch (mode) {
1792 default:
1793 /* case 4: * 320x240 */
1794 sccb_w_array(gspca_dev, sensor_start_ov965x_1_vga,
1795 ARRAY_SIZE(sensor_start_ov965x_1_vga));
1796 reg_w_array(gspca_dev, bridge_start_ov965x_qvga,
1797 ARRAY_SIZE(bridge_start_ov965x_qvga));
1798 sccb_w_array(gspca_dev, sensor_start_ov965x_2_qvga,
1799 ARRAY_SIZE(sensor_start_ov965x_2_qvga));
1800 break;
1801 case 3: /* 640x480 */
1802 sccb_w_array(gspca_dev, sensor_start_ov965x_1_vga,
1803 ARRAY_SIZE(sensor_start_ov965x_1_vga));
1804 reg_w_array(gspca_dev, bridge_start_ov965x_vga,
1805 ARRAY_SIZE(bridge_start_ov965x_vga));
1806 sccb_w_array(gspca_dev, sensor_start_ov965x_2_vga,
1807 ARRAY_SIZE(sensor_start_ov965x_2_vga));
1808 break;
1809 case 2: /* 800x600 */
1810 sccb_w_array(gspca_dev, sensor_start_ov965x_1_svga,
1811 ARRAY_SIZE(sensor_start_ov965x_1_svga));
1812 reg_w_array(gspca_dev, bridge_start_ov965x_svga,
1813 ARRAY_SIZE(bridge_start_ov965x_svga));
1814 sccb_w_array(gspca_dev, sensor_start_ov965x_2_svga,
1815 ARRAY_SIZE(sensor_start_ov965x_2_svga));
1816 break;
1817 case 1: /* 1024x768 */
1818 sccb_w_array(gspca_dev, sensor_start_ov965x_1_xga,
1819 ARRAY_SIZE(sensor_start_ov965x_1_xga));
1820 reg_w_array(gspca_dev, bridge_start_ov965x_xga,
1821 ARRAY_SIZE(bridge_start_ov965x_xga));
1822 sccb_w_array(gspca_dev, sensor_start_ov965x_2_svga,
1823 ARRAY_SIZE(sensor_start_ov965x_2_svga));
1824 break;
1825 case 0: /* 1280x1024 */
1826 sccb_w_array(gspca_dev, sensor_start_ov965x_1_sxga,
1827 ARRAY_SIZE(sensor_start_ov965x_1_sxga));
1828 reg_w_array(gspca_dev, bridge_start_ov965x_sxga,
1829 ARRAY_SIZE(bridge_start_ov965x_sxga));
1830 sccb_w_array(gspca_dev, sensor_start_ov965x_2_sxga,
1831 ARRAY_SIZE(sensor_start_ov965x_2_sxga));
1832 break;
1833 }
1834 setfreq(gspca_dev);
1835 setautogain_96(gspca_dev);
1836 setbrightness_96(gspca_dev);
1837 setcontrast_96(gspca_dev);
1838 setexposure_96(gspca_dev);
1839 setsharpness_96(gspca_dev);
1840 setsatur(gspca_dev);
1841
1842 ov534_reg_write(gspca_dev, 0xe0, 0x00);
1843 ov534_reg_write(gspca_dev, 0xe0, 0x00);
1844 ov534_set_led(gspca_dev, 1);
1845 return 0;
1846 }
1847
1848 static void sd_stopN_ov772x(struct gspca_dev *gspca_dev)
1849 {
1850 ov534_reg_write(gspca_dev, 0xe0, 0x09);
1851 ov534_set_led(gspca_dev, 0);
1852 }
1853
1854 static void sd_stopN_ov965x(struct gspca_dev *gspca_dev)
1855 {
1856 ov534_reg_write(gspca_dev, 0xe0, 0x01);
1857 ov534_set_led(gspca_dev, 0);
1858 ov534_reg_write(gspca_dev, 0xe0, 0x00);
1859 }
1860
1861 /* Values for bmHeaderInfo (Video and Still Image Payload Headers, 2.4.3.3) */
1862 #define UVC_STREAM_EOH (1 << 7)
1863 #define UVC_STREAM_ERR (1 << 6)
1864 #define UVC_STREAM_STI (1 << 5)
1865 #define UVC_STREAM_RES (1 << 4)
1866 #define UVC_STREAM_SCR (1 << 3)
1867 #define UVC_STREAM_PTS (1 << 2)
1868 #define UVC_STREAM_EOF (1 << 1)
1869 #define UVC_STREAM_FID (1 << 0)
1870
1871 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1872 u8 *data, int len)
1873 {
1874 struct sd *sd = (struct sd *) gspca_dev;
1875 __u32 this_pts;
1876 u16 this_fid;
1877 int remaining_len = len;
1878 int payload_len;
1879
1880 payload_len = gspca_dev->cam.bulk ? 2048 : 2040;
1881 do {
1882 len = min(remaining_len, payload_len);
1883
1884 /* Payloads are prefixed with a UVC-style header. We
1885 consider a frame to start when the FID toggles, or the PTS
1886 changes. A frame ends when EOF is set, and we've received
1887 the correct number of bytes. */
1888
1889 /* Verify UVC header. Header length is always 12 */
1890 if (data[0] != 12 || len < 12) {
1891 PDEBUG(D_PACK, "bad header");
1892 goto discard;
1893 }
1894
1895 /* Check errors */
1896 if (data[1] & UVC_STREAM_ERR) {
1897 PDEBUG(D_PACK, "payload error");
1898 goto discard;
1899 }
1900
1901 /* Extract PTS and FID */
1902 if (!(data[1] & UVC_STREAM_PTS)) {
1903 PDEBUG(D_PACK, "PTS not present");
1904 goto discard;
1905 }
1906 this_pts = (data[5] << 24) | (data[4] << 16)
1907 | (data[3] << 8) | data[2];
1908 this_fid = (data[1] & UVC_STREAM_FID) ? 1 : 0;
1909
1910 /* If PTS or FID has changed, start a new frame. */
1911 if (this_pts != sd->last_pts || this_fid != sd->last_fid) {
1912 if (gspca_dev->last_packet_type == INTER_PACKET)
1913 gspca_frame_add(gspca_dev, LAST_PACKET,
1914 NULL, 0);
1915 sd->last_pts = this_pts;
1916 sd->last_fid = this_fid;
1917 gspca_frame_add(gspca_dev, FIRST_PACKET,
1918 data + 12, len - 12);
1919 /* If this packet is marked as EOF, end the frame */
1920 } else if (data[1] & UVC_STREAM_EOF) {
1921 sd->last_pts = 0;
1922 gspca_frame_add(gspca_dev, LAST_PACKET,
1923 data + 12, len - 12);
1924 } else {
1925
1926 /* Add the data from this payload */
1927 gspca_frame_add(gspca_dev, INTER_PACKET,
1928 data + 12, len - 12);
1929 }
1930
1931 /* Done this payload */
1932 goto scan_next;
1933
1934 discard:
1935 /* Discard data until a new frame starts. */
1936 gspca_dev->last_packet_type = DISCARD_PACKET;
1937
1938 scan_next:
1939 remaining_len -= len;
1940 data += len;
1941 } while (remaining_len > 0);
1942 }
1943
1944 /* controls */
1945 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1946 {
1947 struct sd *sd = (struct sd *) gspca_dev;
1948
1949 sd->gain = val;
1950 if (gspca_dev->streaming)
1951 setgain(gspca_dev);
1952 return 0;
1953 }
1954
1955 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1956 {
1957 struct sd *sd = (struct sd *) gspca_dev;
1958
1959 *val = sd->gain;
1960 return 0;
1961 }
1962
1963 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1964 {
1965 struct sd *sd = (struct sd *) gspca_dev;
1966
1967 sd->exposure = val;
1968 if (gspca_dev->streaming) {
1969 if (sd->sensor == SENSOR_OV772X)
1970 setexposure_77(gspca_dev);
1971 else
1972 setexposure_96(gspca_dev);
1973 }
1974 return 0;
1975 }
1976
1977 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1978 {
1979 struct sd *sd = (struct sd *) gspca_dev;
1980
1981 *val = sd->exposure;
1982 return 0;
1983 }
1984
1985 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1986 {
1987 struct sd *sd = (struct sd *) gspca_dev;
1988
1989 sd->brightness = val;
1990 if (gspca_dev->streaming) {
1991 if (sd->sensor == SENSOR_OV772X)
1992 setbrightness_77(gspca_dev);
1993 else
1994 setbrightness_96(gspca_dev);
1995 }
1996 return 0;
1997 }
1998
1999 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
2000 {
2001 struct sd *sd = (struct sd *) gspca_dev;
2002
2003 *val = sd->brightness;
2004 return 0;
2005 }
2006
2007 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
2008 {
2009 struct sd *sd = (struct sd *) gspca_dev;
2010
2011 sd->contrast = val;
2012 if (gspca_dev->streaming) {
2013 if (sd->sensor == SENSOR_OV772X)
2014 setcontrast_77(gspca_dev);
2015 else
2016 setcontrast_96(gspca_dev);
2017 }
2018 return 0;
2019 }
2020
2021 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
2022 {
2023 struct sd *sd = (struct sd *) gspca_dev;
2024
2025 *val = sd->contrast;
2026 return 0;
2027 }
2028
2029 static int sd_setsatur(struct gspca_dev *gspca_dev, __s32 val)
2030 {
2031 struct sd *sd = (struct sd *) gspca_dev;
2032
2033 sd->satur = val;
2034 if (gspca_dev->streaming)
2035 setsatur(gspca_dev);
2036 return 0;
2037 }
2038
2039 static int sd_getsatur(struct gspca_dev *gspca_dev, __s32 *val)
2040 {
2041 struct sd *sd = (struct sd *) gspca_dev;
2042
2043 *val = sd->satur;
2044 return 0;
2045 }
2046 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
2047 {
2048 struct sd *sd = (struct sd *) gspca_dev;
2049
2050 sd->lightfreq = val;
2051 if (gspca_dev->streaming)
2052 setfreq(gspca_dev);
2053 return 0;
2054 }
2055
2056 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
2057 {
2058 struct sd *sd = (struct sd *) gspca_dev;
2059
2060 *val = sd->lightfreq;
2061 return 0;
2062 }
2063
2064 static int sd_setredblc(struct gspca_dev *gspca_dev, __s32 val)
2065 {
2066 struct sd *sd = (struct sd *) gspca_dev;
2067
2068 sd->redblc = val;
2069 if (gspca_dev->streaming)
2070 setredblc(gspca_dev);
2071 return 0;
2072 }
2073
2074 static int sd_getredblc(struct gspca_dev *gspca_dev, __s32 *val)
2075 {
2076 struct sd *sd = (struct sd *) gspca_dev;
2077
2078 *val = sd->redblc;
2079 return 0;
2080 }
2081
2082 static int sd_setblueblc(struct gspca_dev *gspca_dev, __s32 val)
2083 {
2084 struct sd *sd = (struct sd *) gspca_dev;
2085
2086 sd->blueblc = val;
2087 if (gspca_dev->streaming)
2088 setblueblc(gspca_dev);
2089 return 0;
2090 }
2091
2092 static int sd_getblueblc(struct gspca_dev *gspca_dev, __s32 *val)
2093 {
2094 struct sd *sd = (struct sd *) gspca_dev;
2095
2096 *val = sd->blueblc;
2097 return 0;
2098 }
2099
2100 static int sd_sethue(struct gspca_dev *gspca_dev, __s32 val)
2101 {
2102 struct sd *sd = (struct sd *) gspca_dev;
2103
2104 sd->hue = val;
2105 if (gspca_dev->streaming)
2106 sethue(gspca_dev);
2107 return 0;
2108 }
2109
2110 static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val)
2111 {
2112 struct sd *sd = (struct sd *) gspca_dev;
2113
2114 *val = sd->hue;
2115 return 0;
2116 }
2117
2118 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
2119 {
2120 struct sd *sd = (struct sd *) gspca_dev;
2121
2122 sd->autogain = val;
2123
2124 if (gspca_dev->streaming) {
2125 if (sd->sensor == SENSOR_OV772X) {
2126
2127 /* the auto white balance control works only
2128 * when auto gain is set */
2129 if (val)
2130 gspca_dev->ctrl_inac &= ~(1 << AWB_77_IDX);
2131 else
2132 gspca_dev->ctrl_inac |= (1 << AWB_77_IDX);
2133 setautogain_77(gspca_dev);
2134 } else {
2135 if (val)
2136 gspca_dev->ctrl_inac |= (1 << EXPO_96_IDX);
2137 else
2138 gspca_dev->ctrl_inac &= ~(1 << EXPO_96_IDX);
2139 setautogain_96(gspca_dev);
2140 }
2141 }
2142 return 0;
2143 }
2144
2145 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
2146 {
2147 struct sd *sd = (struct sd *) gspca_dev;
2148
2149 *val = sd->autogain;
2150 return 0;
2151 }
2152
2153 static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val)
2154 {
2155 struct sd *sd = (struct sd *) gspca_dev;
2156
2157 sd->awb = val;
2158 if (gspca_dev->streaming)
2159 setawb(gspca_dev);
2160 return 0;
2161 }
2162
2163 static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val)
2164 {
2165 struct sd *sd = (struct sd *) gspca_dev;
2166
2167 *val = sd->awb;
2168 return 0;
2169 }
2170
2171 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
2172 {
2173 struct sd *sd = (struct sd *) gspca_dev;
2174
2175 sd->sharpness = val;
2176 if (gspca_dev->streaming) {
2177 if (sd->sensor == SENSOR_OV772X)
2178 setsharpness_77(gspca_dev);
2179 else
2180 setsharpness_96(gspca_dev);
2181 }
2182 return 0;
2183 }
2184
2185 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
2186 {
2187 struct sd *sd = (struct sd *) gspca_dev;
2188
2189 *val = sd->sharpness;
2190 return 0;
2191 }
2192
2193 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
2194 {
2195 struct sd *sd = (struct sd *) gspca_dev;
2196
2197 sd->hflip = val;
2198 if (gspca_dev->streaming)
2199 sethflip(gspca_dev);
2200 return 0;
2201 }
2202
2203 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
2204 {
2205 struct sd *sd = (struct sd *) gspca_dev;
2206
2207 *val = sd->hflip;
2208 return 0;
2209 }
2210
2211 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
2212 {
2213 struct sd *sd = (struct sd *) gspca_dev;
2214
2215 sd->vflip = val;
2216 if (gspca_dev->streaming)
2217 setvflip(gspca_dev);
2218 return 0;
2219 }
2220
2221 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
2222 {
2223 struct sd *sd = (struct sd *) gspca_dev;
2224
2225 *val = sd->vflip;
2226 return 0;
2227 }
2228
2229 /* get stream parameters (framerate) */
2230 static int sd_get_streamparm(struct gspca_dev *gspca_dev,
2231 struct v4l2_streamparm *parm)
2232 {
2233 struct v4l2_captureparm *cp = &parm->parm.capture;
2234 struct v4l2_fract *tpf = &cp->timeperframe;
2235 struct sd *sd = (struct sd *) gspca_dev;
2236
2237 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2238 return -EINVAL;
2239
2240 cp->capability |= V4L2_CAP_TIMEPERFRAME;
2241 tpf->numerator = 1;
2242 tpf->denominator = sd->frame_rate;
2243
2244 return 0;
2245 }
2246
2247 /* set stream parameters (framerate) */
2248 static int sd_set_streamparm(struct gspca_dev *gspca_dev,
2249 struct v4l2_streamparm *parm)
2250 {
2251 struct v4l2_captureparm *cp = &parm->parm.capture;
2252 struct v4l2_fract *tpf = &cp->timeperframe;
2253 struct sd *sd = (struct sd *) gspca_dev;
2254
2255 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2256 return -EINVAL;
2257
2258 /* Set requested framerate */
2259 sd->frame_rate = tpf->denominator / tpf->numerator;
2260 if (gspca_dev->streaming && sd->sensor == SENSOR_OV772X)
2261 set_frame_rate(gspca_dev);
2262
2263 /* Return the actual framerate */
2264 tpf->numerator = 1;
2265 tpf->denominator = sd->frame_rate;
2266
2267 return 0;
2268 }
2269
2270 static int sd_querymenu(struct gspca_dev *gspca_dev,
2271 struct v4l2_querymenu *menu)
2272 {
2273 switch (menu->id) {
2274 case V4L2_CID_POWER_LINE_FREQUENCY:
2275 switch (menu->index) {
2276 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
2277 strcpy((char *) menu->name, "NoFliker");
2278 return 0;
2279 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
2280 strcpy((char *) menu->name, "50 Hz");
2281 return 0;
2282 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
2283 strcpy((char *) menu->name, "60 Hz");
2284 return 0;
2285 }
2286 break;
2287 }
2288 return -EINVAL;
2289 }
2290
2291 /* sub-driver description */
2292 static const struct sd_desc sd_desc_ov772x = {
2293 .name = MODULE_NAME,
2294 .ctrls = sd_ctrls_ov772x,
2295 .nctrls = ARRAY_SIZE(sd_ctrls_ov772x),
2296 .config = sd_config,
2297 .init = sd_init,
2298 .start = sd_start_ov772x,
2299 .stopN = sd_stopN_ov772x,
2300 .pkt_scan = sd_pkt_scan,
2301 .get_streamparm = sd_get_streamparm,
2302 .set_streamparm = sd_set_streamparm,
2303 };
2304
2305 static const struct sd_desc sd_desc_ov965x = {
2306 .name = MODULE_NAME,
2307 .ctrls = sd_ctrls_ov965x,
2308 .nctrls = ARRAY_SIZE(sd_ctrls_ov965x),
2309 .config = sd_config,
2310 .init = sd_init,
2311 .start = sd_start_ov965x,
2312 .stopN = sd_stopN_ov965x,
2313 .pkt_scan = sd_pkt_scan,
2314 .querymenu = sd_querymenu,
2315 };
2316
2317 /* -- module initialisation -- */
2318 static const __devinitdata struct usb_device_id device_table[] = {
2319 {USB_DEVICE(0x06f8, 0x3003), .driver_info = SENSOR_OV965X},
2320 {USB_DEVICE(0x1415, 0x2000), .driver_info = SENSOR_OV772X},
2321 {}
2322 };
2323
2324 MODULE_DEVICE_TABLE(usb, device_table);
2325
2326 /* -- device connect -- */
2327 static int sd_probe(struct usb_interface *intf, const struct usb_device_id *id)
2328 {
2329 return gspca_dev_probe(intf, id,
2330 id->driver_info == SENSOR_OV772X
2331 ? &sd_desc_ov772x
2332 : &sd_desc_ov965x,
2333 sizeof(struct sd),
2334 THIS_MODULE);
2335 }
2336
2337 static struct usb_driver sd_driver = {
2338 .name = MODULE_NAME,
2339 .id_table = device_table,
2340 .probe = sd_probe,
2341 .disconnect = gspca_disconnect,
2342 #ifdef CONFIG_PM
2343 .suspend = gspca_suspend,
2344 .resume = gspca_resume,
2345 #endif
2346 };
2347
2348 /* -- module insert / remove -- */
2349 static int __init sd_mod_init(void)
2350 {
2351 int ret;
2352
2353 ret = usb_register(&sd_driver);
2354 if (ret < 0)
2355 return ret;
2356 PDEBUG(D_PROBE, "registered");
2357 return 0;
2358 }
2359
2360 static void __exit sd_mod_exit(void)
2361 {
2362 usb_deregister(&sd_driver);
2363 PDEBUG(D_PROBE, "deregistered");
2364 }
2365
2366 module_init(sd_mod_init);
2367 module_exit(sd_mod_exit);
Linux kernel - Deliverables
This page took 0.126918 seconds and 5 git commands to generate.