2 * Sonix sn9c102p sn9c105 sn9c120 (jpeg) subdriver
4 * Copyright (C) 2009-2010 Jean-François Moine <http://moinejf.free.fr>
5 * Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #define MODULE_NAME "sonixj"
24 #include <linux/input.h>
28 MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
29 MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
30 MODULE_LICENSE("GPL");
48 NCTRLS
/* number of controls */
51 /* specific webcam descriptor */
53 struct gspca_dev gspca_dev
; /* !! must be the first item */
55 struct gspca_ctrl ctrls
[NCTRLS
];
62 u8 quality
; /* image quality */
63 #define QUALITY_MIN 60
64 #define QUALITY_MAX 95
65 #define QUALITY_DEF 80
66 u8 jpegqual
; /* webcam quality */
74 #define AG_CNT_START 13
77 #define BRIDGE_SN9C102P 0
78 #define BRIDGE_SN9C105 1
79 #define BRIDGE_SN9C110 2
80 #define BRIDGE_SN9C120 3
81 u8 sensor
; /* Type of image sensor chip */
84 u8 jpeg_hdr
[JPEG_HDR_SZ
];
105 #define F_PDN_INV 0x01 /* inverse pin S_PWR_DN / sn_xxx tables */
106 #define F_ILLUM 0x02 /* presence of illuminator */
108 /* sn9c1xx definitions */
110 #define S_PWR_DN 0x01 /* sensor power down */
111 #define S_PDN_INV 0x02 /* inverse pin S_PWR_DN */
112 #define V_TX_EN 0x04 /* video transfer enable */
113 #define LED 0x08 /* output to pin LED */
114 #define SCL_SEL_OD 0x20 /* open-drain mode */
115 #define SYS_SEL_48M 0x40 /* system clock 0: 24MHz, 1: 48MHz */
117 #define MCK_SIZE_MASK 0x1f /* sensor master clock */
118 #define SEN_CLK_EN 0x20 /* enable sensor clock */
119 #define DEF_EN 0x80 /* defect pixel by 0: soft, 1: hard */
121 /* V4L2 controls supported by the driver */
122 static void setbrightness(struct gspca_dev
*gspca_dev
);
123 static void setcontrast(struct gspca_dev
*gspca_dev
);
124 static void setcolors(struct gspca_dev
*gspca_dev
);
125 static void setredblue(struct gspca_dev
*gspca_dev
);
126 static void setgamma(struct gspca_dev
*gspca_dev
);
127 static void setautogain(struct gspca_dev
*gspca_dev
);
128 static void sethvflip(struct gspca_dev
*gspca_dev
);
129 static void setsharpness(struct gspca_dev
*gspca_dev
);
130 static void setillum(struct gspca_dev
*gspca_dev
);
131 static void setfreq(struct gspca_dev
*gspca_dev
);
133 static const struct ctrl sd_ctrls
[NCTRLS
] = {
136 .id
= V4L2_CID_BRIGHTNESS
,
137 .type
= V4L2_CTRL_TYPE_INTEGER
,
138 .name
= "Brightness",
142 .default_value
= 0x80,
144 .set_control
= setbrightness
148 .id
= V4L2_CID_CONTRAST
,
149 .type
= V4L2_CTRL_TYPE_INTEGER
,
152 #define CONTRAST_MAX 127
153 .maximum
= CONTRAST_MAX
,
157 .set_control
= setcontrast
161 .id
= V4L2_CID_SATURATION
,
162 .type
= V4L2_CTRL_TYPE_INTEGER
,
163 .name
= "Saturation",
167 #define COLORS_DEF 25
168 .default_value
= COLORS_DEF
,
170 .set_control
= setcolors
174 .id
= V4L2_CID_BLUE_BALANCE
,
175 .type
= V4L2_CTRL_TYPE_INTEGER
,
176 .name
= "Blue Balance",
182 .set_control
= setredblue
186 .id
= V4L2_CID_RED_BALANCE
,
187 .type
= V4L2_CTRL_TYPE_INTEGER
,
188 .name
= "Red Balance",
194 .set_control
= setredblue
198 .id
= V4L2_CID_GAMMA
,
199 .type
= V4L2_CTRL_TYPE_INTEGER
,
205 .default_value
= GAMMA_DEF
,
207 .set_control
= setgamma
211 .id
= V4L2_CID_AUTOGAIN
,
212 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
219 .set_control
= setautogain
223 .id
= V4L2_CID_HFLIP
,
224 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
231 .set_control
= sethvflip
235 .id
= V4L2_CID_VFLIP
,
236 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
243 .set_control
= sethvflip
247 .id
= V4L2_CID_SHARPNESS
,
248 .type
= V4L2_CTRL_TYPE_INTEGER
,
255 .set_control
= setsharpness
259 .id
= V4L2_CID_ILLUMINATORS_1
,
260 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
261 .name
= "Illuminator / infrared",
267 .set_control
= setillum
269 /* ov7630/ov7648/ov7660 only */
272 .id
= V4L2_CID_POWER_LINE_FREQUENCY
,
273 .type
= V4L2_CTRL_TYPE_MENU
,
274 .name
= "Light frequency filter",
276 .maximum
= 2, /* 0: 0, 1: 50Hz, 2:60Hz */
280 .set_control
= setfreq
284 /* table of the disabled controls */
285 static const __u32 ctrl_dis
[] = {
286 [SENSOR_ADCM1700
] = (1 << AUTOGAIN
) |
291 [SENSOR_GC0307
] = (1 << HFLIP
) |
295 [SENSOR_HV7131R
] = (1 << HFLIP
) |
298 [SENSOR_MI0360
] = (1 << HFLIP
) |
302 [SENSOR_MI0360B
] = (1 << HFLIP
) |
306 [SENSOR_MO4000
] = (1 << HFLIP
) |
310 [SENSOR_MT9V111
] = (1 << HFLIP
) |
314 [SENSOR_OM6802
] = (1 << HFLIP
) |
318 [SENSOR_OV7630
] = (1 << HFLIP
),
320 [SENSOR_OV7648
] = (1 << HFLIP
),
322 [SENSOR_OV7660
] = (1 << AUTOGAIN
) |
326 [SENSOR_PO1030
] = (1 << AUTOGAIN
) |
331 [SENSOR_PO2030N
] = (1 << AUTOGAIN
) |
334 [SENSOR_SOI768
] = (1 << AUTOGAIN
) |
339 [SENSOR_SP80708
] = (1 << AUTOGAIN
) |
345 static const struct v4l2_pix_format cif_mode
[] = {
346 {352, 288, V4L2_PIX_FMT_JPEG
, V4L2_FIELD_NONE
,
348 .sizeimage
= 352 * 288 * 4 / 8 + 590,
349 .colorspace
= V4L2_COLORSPACE_JPEG
,
352 static const struct v4l2_pix_format vga_mode
[] = {
353 {160, 120, V4L2_PIX_FMT_JPEG
, V4L2_FIELD_NONE
,
355 .sizeimage
= 160 * 120 * 4 / 8 + 590,
356 .colorspace
= V4L2_COLORSPACE_JPEG
,
358 {320, 240, V4L2_PIX_FMT_JPEG
, V4L2_FIELD_NONE
,
360 .sizeimage
= 320 * 240 * 3 / 8 + 590,
361 .colorspace
= V4L2_COLORSPACE_JPEG
,
363 {640, 480, V4L2_PIX_FMT_JPEG
, V4L2_FIELD_NONE
,
365 /* Note 3 / 8 is not large enough, not even 5 / 8 is ?! */
366 .sizeimage
= 640 * 480 * 3 / 4 + 590,
367 .colorspace
= V4L2_COLORSPACE_JPEG
,
371 static const u8 sn_adcm1700
[0x1c] = {
372 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
373 0x00, 0x43, 0x60, 0x00, 0x1a, 0x00, 0x00, 0x00,
374 /* reg8 reg9 rega regb regc regd rege regf */
375 0x80, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
376 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
377 0x03, 0x00, 0x05, 0x01, 0x05, 0x16, 0x12, 0x42,
378 /* reg18 reg19 reg1a reg1b */
379 0x06, 0x00, 0x00, 0x00
382 static const u8 sn_gc0307
[0x1c] = {
383 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
384 0x00, 0x61, 0x62, 0x00, 0x1a, 0x00, 0x00, 0x00,
385 /* reg8 reg9 rega regb regc regd rege regf */
386 0x80, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
387 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
388 0x03, 0x00, 0x03, 0x01, 0x08, 0x28, 0x1e, 0x02,
389 /* reg18 reg19 reg1a reg1b */
390 0x06, 0x00, 0x00, 0x00
393 static const u8 sn_hv7131
[0x1c] = {
394 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
395 0x00, 0x03, 0x60, 0x00, 0x1a, 0x20, 0x20, 0x20,
396 /* reg8 reg9 rega regb regc regd rege regf */
397 0x81, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
398 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
399 0x03, 0x00, 0x00, 0x01, 0x03, 0x28, 0x1e, 0x41,
400 /* reg18 reg19 reg1a reg1b */
401 0x0a, 0x00, 0x00, 0x00
404 static const u8 sn_mi0360
[0x1c] = {
405 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
406 0x00, 0x61, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
407 /* reg8 reg9 rega regb regc regd rege regf */
408 0x81, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
409 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
410 0x03, 0x00, 0x00, 0x02, 0x0a, 0x28, 0x1e, 0x61,
411 /* reg18 reg19 reg1a reg1b */
412 0x06, 0x00, 0x00, 0x00
415 static const u8 sn_mi0360b
[0x1c] = {
416 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
417 0x00, 0x61, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
418 /* reg8 reg9 rega regb regc regd rege regf */
419 0x81, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
420 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
421 0x03, 0x00, 0x00, 0x02, 0x0a, 0x28, 0x1e, 0x40,
422 /* reg18 reg19 reg1a reg1b */
423 0x06, 0x00, 0x00, 0x00
426 static const u8 sn_mo4000
[0x1c] = {
427 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
428 0x00, 0x23, 0x60, 0x00, 0x1a, 0x00, 0x20, 0x18,
429 /* reg8 reg9 rega regb regc regd rege regf */
430 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
431 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
432 0x03, 0x00, 0x0b, 0x0f, 0x14, 0x28, 0x1e, 0x40,
433 /* reg18 reg19 reg1a reg1b */
434 0x08, 0x00, 0x00, 0x00
437 static const u8 sn_mt9v111
[0x1c] = {
438 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
439 0x00, 0x61, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
440 /* reg8 reg9 rega regb regc regd rege regf */
441 0x81, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
442 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
443 0x03, 0x00, 0x00, 0x02, 0x1c, 0x28, 0x1e, 0x40,
444 /* reg18 reg19 reg1a reg1b */
445 0x06, 0x00, 0x00, 0x00
448 static const u8 sn_om6802
[0x1c] = {
449 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
450 0x00, 0x23, 0x72, 0x00, 0x1a, 0x20, 0x20, 0x19,
451 /* reg8 reg9 rega regb regc regd rege regf */
452 0x80, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
453 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
454 0x03, 0x00, 0x51, 0x01, 0x00, 0x28, 0x1e, 0x40,
455 /* reg18 reg19 reg1a reg1b */
456 0x05, 0x00, 0x00, 0x00
459 static const u8 sn_ov7630
[0x1c] = {
460 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
461 0x00, 0x21, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
462 /* reg8 reg9 rega regb regc regd rege regf */
463 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
464 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
465 0x03, 0x00, 0x04, 0x01, 0x0a, 0x28, 0x1e, 0xc2,
466 /* reg18 reg19 reg1a reg1b */
467 0x0b, 0x00, 0x00, 0x00
470 static const u8 sn_ov7648
[0x1c] = {
471 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
472 0x00, 0x63, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
473 /* reg8 reg9 rega regb regc regd rege regf */
474 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
475 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
476 0x03, 0x00, 0x00, 0x01, 0x00, 0x28, 0x1e, 0x00,
477 /* reg18 reg19 reg1a reg1b */
478 0x0b, 0x00, 0x00, 0x00
481 static const u8 sn_ov7660
[0x1c] = {
482 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
483 0x00, 0x61, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
484 /* reg8 reg9 rega regb regc regd rege regf */
485 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
486 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
487 0x03, 0x00, 0x01, 0x01, 0x08, 0x28, 0x1e, 0x20,
488 /* reg18 reg19 reg1a reg1b */
489 0x07, 0x00, 0x00, 0x00
492 static const u8 sn_po1030
[0x1c] = {
493 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
494 0x00, 0x21, 0x62, 0x00, 0x1a, 0x20, 0x20, 0x20,
495 /* reg8 reg9 rega regb regc regd rege regf */
496 0x81, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
497 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
498 0x03, 0x00, 0x00, 0x06, 0x06, 0x28, 0x1e, 0x00,
499 /* reg18 reg19 reg1a reg1b */
500 0x07, 0x00, 0x00, 0x00
503 static const u8 sn_po2030n
[0x1c] = {
504 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
505 0x00, 0x63, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
506 /* reg8 reg9 rega regb regc regd rege regf */
507 0x81, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
508 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
509 0x03, 0x00, 0x00, 0x01, 0x14, 0x28, 0x1e, 0x00,
510 /* reg18 reg19 reg1a reg1b */
511 0x07, 0x00, 0x00, 0x00
514 static const u8 sn_soi768
[0x1c] = {
515 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
516 0x00, 0x21, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
517 /* reg8 reg9 rega regb regc regd rege regf */
518 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
519 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
520 0x03, 0x00, 0x00, 0x01, 0x08, 0x28, 0x1e, 0x00,
521 /* reg18 reg19 reg1a reg1b */
522 0x07, 0x00, 0x00, 0x00
525 static const u8 sn_sp80708
[0x1c] = {
526 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
527 0x00, 0x63, 0x60, 0x00, 0x1a, 0x20, 0x20, 0x20,
528 /* reg8 reg9 rega regb regc regd rege regf */
529 0x81, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
530 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
531 0x03, 0x00, 0x00, 0x03, 0x04, 0x28, 0x1e, 0x00,
532 /* reg18 reg19 reg1a reg1b */
533 0x07, 0x00, 0x00, 0x00
536 /* sequence specific to the sensors - !! index = SENSOR_xxx */
537 static const u8
*sn_tb
[] = {
538 [SENSOR_ADCM1700
] = sn_adcm1700
,
539 [SENSOR_GC0307
] = sn_gc0307
,
540 [SENSOR_HV7131R
] = sn_hv7131
,
541 [SENSOR_MI0360
] = sn_mi0360
,
542 [SENSOR_MI0360B
] = sn_mi0360b
,
543 [SENSOR_MO4000
] = sn_mo4000
,
544 [SENSOR_MT9V111
] = sn_mt9v111
,
545 [SENSOR_OM6802
] = sn_om6802
,
546 [SENSOR_OV7630
] = sn_ov7630
,
547 [SENSOR_OV7648
] = sn_ov7648
,
548 [SENSOR_OV7660
] = sn_ov7660
,
549 [SENSOR_PO1030
] = sn_po1030
,
550 [SENSOR_PO2030N
] = sn_po2030n
,
551 [SENSOR_SOI768
] = sn_soi768
,
552 [SENSOR_SP80708
] = sn_sp80708
,
555 /* default gamma table */
556 static const u8 gamma_def
[17] = {
557 0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
558 0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
560 /* gamma for sensor ADCM1700 */
561 static const u8 gamma_spec_0
[17] = {
562 0x0f, 0x39, 0x5a, 0x74, 0x86, 0x95, 0xa6, 0xb4,
563 0xbd, 0xc4, 0xcc, 0xd4, 0xd5, 0xde, 0xe4, 0xed, 0xf5
565 /* gamma for sensors HV7131R and MT9V111 */
566 static const u8 gamma_spec_1
[17] = {
567 0x08, 0x3a, 0x52, 0x65, 0x75, 0x83, 0x91, 0x9d,
568 0xa9, 0xb4, 0xbe, 0xc8, 0xd2, 0xdb, 0xe4, 0xed, 0xf5
570 /* gamma for sensor GC0307 */
571 static const u8 gamma_spec_2
[17] = {
572 0x14, 0x37, 0x50, 0x6a, 0x7c, 0x8d, 0x9d, 0xab,
573 0xb5, 0xbf, 0xc2, 0xcb, 0xd1, 0xd6, 0xdb, 0xe1, 0xeb
575 /* gamma for sensor SP80708 */
576 static const u8 gamma_spec_3
[17] = {
577 0x0a, 0x2d, 0x4e, 0x68, 0x7d, 0x8f, 0x9f, 0xab,
578 0xb7, 0xc2, 0xcc, 0xd3, 0xd8, 0xde, 0xe2, 0xe5, 0xe6
581 /* color matrix and offsets */
582 static const u8 reg84
[] = {
583 0x14, 0x00, 0x27, 0x00, 0x07, 0x00, /* YR YG YB gains */
584 0xe8, 0x0f, 0xda, 0x0f, 0x40, 0x00, /* UR UG UB */
585 0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f, /* VR VG VB */
586 0x00, 0x00, 0x00 /* YUV offsets */
591 static const u8 adcm1700_sensor_init
[][8] = {
592 {0xa0, 0x51, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x10},
593 {0xb0, 0x51, 0x04, 0x08, 0x00, 0x00, 0x00, 0x10}, /* reset */
594 {DELAY
, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
595 {0xb0, 0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
596 {DELAY
, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
597 {0xb0, 0x51, 0x0c, 0xe0, 0x2e, 0x00, 0x00, 0x10},
598 {0xb0, 0x51, 0x10, 0x02, 0x02, 0x00, 0x00, 0x10},
599 {0xb0, 0x51, 0x14, 0x0e, 0x0e, 0x00, 0x00, 0x10},
600 {0xb0, 0x51, 0x1c, 0x00, 0x80, 0x00, 0x00, 0x10},
601 {0xb0, 0x51, 0x20, 0x01, 0x00, 0x00, 0x00, 0x10},
602 {DELAY
, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
603 {0xb0, 0x51, 0x04, 0x04, 0x00, 0x00, 0x00, 0x10},
604 {DELAY
, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
605 {0xb0, 0x51, 0x04, 0x01, 0x00, 0x00, 0x00, 0x10},
606 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
607 {0xb0, 0x51, 0x14, 0x01, 0x00, 0x00, 0x00, 0x10},
608 {0xb0, 0x51, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
611 static const u8 adcm1700_sensor_param1
[][8] = {
612 {0xb0, 0x51, 0x26, 0xf9, 0x01, 0x00, 0x00, 0x10}, /* exposure? */
613 {0xd0, 0x51, 0x1e, 0x8e, 0x8e, 0x8e, 0x8e, 0x10},
615 {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
616 {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
617 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
618 {0xb0, 0x51, 0x32, 0x00, 0x72, 0x00, 0x00, 0x10},
619 {0xd0, 0x51, 0x1e, 0xbe, 0xd7, 0xe8, 0xbe, 0x10}, /* exposure? */
621 {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
622 {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
623 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
624 {0xb0, 0x51, 0x32, 0x00, 0xa2, 0x00, 0x00, 0x10},
627 static const u8 gc0307_sensor_init
[][8] = {
628 {0xa0, 0x21, 0x43, 0x00, 0x00, 0x00, 0x00, 0x10},
629 {0xa0, 0x21, 0x44, 0xa2, 0x00, 0x00, 0x00, 0x10},
630 {0xa0, 0x21, 0x01, 0x6a, 0x00, 0x00, 0x00, 0x10},
631 {0xa0, 0x21, 0x02, 0x70, 0x00, 0x00, 0x00, 0x10},
632 {0xa0, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
633 {0xa0, 0x21, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
634 {0xa0, 0x21, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
635 {0xa0, 0x21, 0x11, 0x05, 0x00, 0x00, 0x00, 0x10},
636 {0xa0, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
637 {0xa0, 0x21, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
638 {0xa0, 0x21, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10},
639 {0xa0, 0x21, 0x08, 0x02, 0x00, 0x00, 0x00, 0x10},
640 {0xa0, 0x21, 0x09, 0x01, 0x00, 0x00, 0x00, 0x10},
641 {0xa0, 0x21, 0x0a, 0xe8, 0x00, 0x00, 0x00, 0x10},
642 {0xa0, 0x21, 0x0b, 0x02, 0x00, 0x00, 0x00, 0x10},
643 {0xa0, 0x21, 0x0c, 0x80, 0x00, 0x00, 0x00, 0x10},
644 {0xa0, 0x21, 0x0d, 0x22, 0x00, 0x00, 0x00, 0x10},
645 {0xa0, 0x21, 0x0e, 0x02, 0x00, 0x00, 0x00, 0x10},
646 {0xa0, 0x21, 0x0f, 0xb2, 0x00, 0x00, 0x00, 0x10},
647 {0xa0, 0x21, 0x12, 0x70, 0x00, 0x00, 0x00, 0x10},
648 {DELAY
, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 10ms*/
649 {0xa0, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00, 0x10},
650 {0xa0, 0x21, 0x15, 0xb8, 0x00, 0x00, 0x00, 0x10},
651 {0xa0, 0x21, 0x16, 0x13, 0x00, 0x00, 0x00, 0x10},
652 {0xa0, 0x21, 0x17, 0x52, 0x00, 0x00, 0x00, 0x10},
653 {0xa0, 0x21, 0x18, 0x50, 0x00, 0x00, 0x00, 0x10},
654 {0xa0, 0x21, 0x1e, 0x0d, 0x00, 0x00, 0x00, 0x10},
655 {0xa0, 0x21, 0x1f, 0x32, 0x00, 0x00, 0x00, 0x10},
656 {0xa0, 0x21, 0x61, 0x90, 0x00, 0x00, 0x00, 0x10},
657 {0xa0, 0x21, 0x63, 0x70, 0x00, 0x00, 0x00, 0x10},
658 {0xa0, 0x21, 0x65, 0x98, 0x00, 0x00, 0x00, 0x10},
659 {0xa0, 0x21, 0x67, 0x90, 0x00, 0x00, 0x00, 0x10},
660 {0xa0, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
661 {0xa0, 0x21, 0x04, 0x96, 0x00, 0x00, 0x00, 0x10},
662 {0xa0, 0x21, 0x45, 0x27, 0x00, 0x00, 0x00, 0x10},
663 {0xa0, 0x21, 0x47, 0x2c, 0x00, 0x00, 0x00, 0x10},
664 {0xa0, 0x21, 0x43, 0x47, 0x00, 0x00, 0x00, 0x10},
665 {0xa0, 0x21, 0x44, 0xd8, 0x00, 0x00, 0x00, 0x10},
668 static const u8 gc0307_sensor_param1
[][8] = {
669 {0xa0, 0x21, 0x68, 0x13, 0x00, 0x00, 0x00, 0x10},
670 {0xd0, 0x21, 0x61, 0x80, 0x00, 0x80, 0x00, 0x10},
671 {0xc0, 0x21, 0x65, 0x80, 0x00, 0x80, 0x00, 0x10},
672 {0xc0, 0x21, 0x63, 0xa0, 0x00, 0xa6, 0x00, 0x10},
674 {0xa0, 0x21, 0x01, 0x6e, 0x00, 0x00, 0x00, 0x10},
675 {0xa0, 0x21, 0x02, 0x88, 0x00, 0x00, 0x00, 0x10},
679 static const u8 hv7131r_sensor_init
[][8] = {
680 {0xc1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
681 {0xb1, 0x11, 0x34, 0x17, 0x7f, 0x00, 0x00, 0x10},
682 {0xd1, 0x11, 0x40, 0xff, 0x7f, 0x7f, 0x7f, 0x10},
683 /* {0x91, 0x11, 0x44, 0x00, 0x00, 0x00, 0x00, 0x10}, */
684 {0xd1, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
685 {0xd1, 0x11, 0x14, 0x01, 0xe2, 0x02, 0x82, 0x10},
686 /* {0x91, 0x11, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10}, */
688 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
689 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
690 {0xc1, 0x11, 0x25, 0x00, 0x61, 0xa8, 0x00, 0x10},
691 {0xa1, 0x11, 0x30, 0x22, 0x00, 0x00, 0x00, 0x10},
692 {0xc1, 0x11, 0x31, 0x20, 0x2e, 0x20, 0x00, 0x10},
693 {0xc1, 0x11, 0x25, 0x00, 0xc3, 0x50, 0x00, 0x10},
694 {0xa1, 0x11, 0x30, 0x07, 0x00, 0x00, 0x00, 0x10}, /* gain14 */
695 {0xc1, 0x11, 0x31, 0x10, 0x10, 0x10, 0x00, 0x10}, /* r g b 101a10 */
697 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
698 {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
699 {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
700 {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
701 {0xa1, 0x11, 0x23, 0x09, 0x00, 0x00, 0x00, 0x10},
703 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
704 {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
705 {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
706 {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
707 {0xa1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
708 {0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10},
709 /* set sensor clock */
712 static const u8 mi0360_sensor_init
[][8] = {
713 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
714 {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
715 {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
716 {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
717 {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
718 {0xd1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x53, 0x10},
719 {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
720 {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
721 {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
722 {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
723 {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
724 {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
725 {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
726 {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
727 {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
728 {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
729 {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
730 {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
731 {0xd1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
732 {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
733 {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
734 {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
735 {0xd1, 0x5d, 0x2f, 0xf7, 0xB0, 0x00, 0x04, 0x10},
736 {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
737 {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
738 {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
739 {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
740 {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
741 {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
742 {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
743 {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
744 {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
745 {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
747 {0xb1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
748 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
749 {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
750 {0xd1, 0x5d, 0x2b, 0x00, 0xa0, 0x00, 0xb0, 0x10},
751 {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0xa0, 0x10},
753 {0xb1, 0x5d, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor clck ?2 */
754 {0xb1, 0x5d, 0x06, 0x00, 0x30, 0x00, 0x00, 0x10},
755 {0xb1, 0x5d, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10},
756 {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */
758 {0xd1, 0x5d, 0x2b, 0x00, 0xb9, 0x00, 0xe3, 0x10},
759 {0xd1, 0x5d, 0x2d, 0x00, 0x5f, 0x00, 0xb9, 0x10}, /* 42 */
760 /* {0xb1, 0x5d, 0x35, 0x00, 0x67, 0x00, 0x00, 0x10}, * gain orig */
761 /* {0xb1, 0x5d, 0x35, 0x00, 0x20, 0x00, 0x00, 0x10}, * gain */
762 {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
763 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
766 static const u8 mi0360b_sensor_init
[][8] = {
767 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
768 {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
769 {DELAY
, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 20ms*/
770 {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
771 {DELAY
, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 20ms*/
772 {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
773 {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
774 {0xd1, 0x5d, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
775 {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
776 {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
777 {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
778 {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
779 {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
780 {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
781 {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
782 {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
783 {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
784 {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
785 {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
786 {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
787 {0xd1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
788 {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
789 {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
790 {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
791 {0xd1, 0x5d, 0x2f, 0xf7, 0xb0, 0x00, 0x04, 0x10},
792 {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
793 {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
794 {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
795 {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
796 {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
797 {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
798 {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
799 {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
800 {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
801 {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
803 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
804 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
805 {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
806 {0xd1, 0x5d, 0x2b, 0x00, 0x33, 0x00, 0xa0, 0x10},
807 {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0x33, 0x10},
810 static const u8 mi0360b_sensor_param1
[][8] = {
811 {0xb1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
812 {0xb1, 0x5d, 0x06, 0x00, 0x53, 0x00, 0x00, 0x10},
813 {0xb1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x00, 0x10},
814 {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */
816 {0xd1, 0x5d, 0x2b, 0x00, 0xd1, 0x01, 0xc9, 0x10},
817 {0xd1, 0x5d, 0x2d, 0x00, 0xed, 0x00, 0xd1, 0x10},
818 {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
819 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
822 static const u8 mo4000_sensor_init
[][8] = {
823 {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
824 {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
825 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
826 {0xa1, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
827 {0xa1, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
828 {0xa1, 0x21, 0x05, 0x04, 0x00, 0x00, 0x00, 0x10},
829 {0xa1, 0x21, 0x06, 0x80, 0x00, 0x00, 0x00, 0x10},
830 {0xa1, 0x21, 0x06, 0x81, 0x00, 0x00, 0x00, 0x10},
831 {0xa1, 0x21, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
832 {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
833 {0xa1, 0x21, 0x11, 0x20, 0x00, 0x00, 0x00, 0x10},
834 {0xa1, 0x21, 0x11, 0x30, 0x00, 0x00, 0x00, 0x10},
835 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
836 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
837 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
838 {0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
839 {0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10},
840 {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
841 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
842 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
845 static const u8 mt9v111_sensor_init
[][8] = {
846 {0xb1, 0x5c, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10}, /* reset? */
847 {DELAY
, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
848 {0xb1, 0x5c, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
849 {0xb1, 0x5c, 0x01, 0x00, 0x01, 0x00, 0x00, 0x10}, /* IFP select */
850 {0xb1, 0x5c, 0x08, 0x04, 0x80, 0x00, 0x00, 0x10}, /* output fmt ctrl */
851 {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10}, /* op mode ctrl */
852 {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
853 {0xb1, 0x5c, 0x03, 0x01, 0xe1, 0x00, 0x00, 0x10},
854 {0xb1, 0x5c, 0x04, 0x02, 0x81, 0x00, 0x00, 0x10},
855 {0xb1, 0x5c, 0x05, 0x00, 0x04, 0x00, 0x00, 0x10},
856 {0xb1, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10}, /* sensor select */
857 {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
858 {0xb1, 0x5c, 0x03, 0x01, 0xe6, 0x00, 0x00, 0x10},
859 {0xb1, 0x5c, 0x04, 0x02, 0x86, 0x00, 0x00, 0x10},
860 {0xb1, 0x5c, 0x05, 0x00, 0x04, 0x00, 0x00, 0x10},
861 {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
862 {0xb1, 0x5c, 0x08, 0x00, 0x08, 0x00, 0x00, 0x10}, /* row start */
863 {0xb1, 0x5c, 0x0e, 0x00, 0x08, 0x00, 0x00, 0x10},
864 {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10}, /* col start */
865 {0xb1, 0x5c, 0x03, 0x01, 0xe7, 0x00, 0x00, 0x10}, /* window height */
866 {0xb1, 0x5c, 0x04, 0x02, 0x87, 0x00, 0x00, 0x10}, /* window width */
867 {0xb1, 0x5c, 0x07, 0x30, 0x02, 0x00, 0x00, 0x10}, /* output ctrl */
868 {0xb1, 0x5c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10}, /* shutter delay */
869 {0xb1, 0x5c, 0x12, 0x00, 0xb0, 0x00, 0x00, 0x10}, /* zoom col start */
870 {0xb1, 0x5c, 0x13, 0x00, 0x7c, 0x00, 0x00, 0x10}, /* zoom row start */
871 {0xb1, 0x5c, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* digital zoom */
872 {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10}, /* read mode */
873 {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
876 static const u8 mt9v111_sensor_param1
[][8] = {
877 {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
878 {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
879 {0xb1, 0x5c, 0x09, 0x01, 0x2c, 0x00, 0x00, 0x10},
880 {0xd1, 0x5c, 0x2b, 0x00, 0x33, 0x00, 0xa0, 0x10}, /* green1 gain */
881 {0xd1, 0x5c, 0x2d, 0x00, 0xa0, 0x00, 0x33, 0x10}, /* red gain */
883 {0xb1, 0x5c, 0x06, 0x00, 0x1e, 0x00, 0x00, 0x10}, /* vert blanking */
884 {0xb1, 0x5c, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10}, /* horiz blanking */
885 {0xd1, 0x5c, 0x2c, 0x00, 0xad, 0x00, 0xad, 0x10}, /* blue gain */
886 {0xb1, 0x5c, 0x35, 0x01, 0xc0, 0x00, 0x00, 0x10}, /* global gain */
889 static const u8 om6802_init0
[2][8] = {
891 {0xa0, 0x34, 0x29, 0x0e, 0x00, 0x00, 0x00, 0x10},
892 {0xa0, 0x34, 0x23, 0xb0, 0x00, 0x00, 0x00, 0x10},
894 static const u8 om6802_sensor_init
[][8] = {
895 {0xa0, 0x34, 0xdf, 0x6d, 0x00, 0x00, 0x00, 0x10},
897 {0xa0, 0x34, 0xdd, 0x18, 0x00, 0x00, 0x00, 0x10},
899 {0xa0, 0x34, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
900 /* {0xa0, 0x34, 0xfb, 0x11, 0x00, 0x00, 0x00, 0x10}, */
901 {0xa0, 0x34, 0xf0, 0x04, 0x00, 0x00, 0x00, 0x10},
902 /* auto-exposure speed (0) / white balance mode (auto RGB) */
903 /* {0xa0, 0x34, 0xf1, 0x02, 0x00, 0x00, 0x00, 0x10},
905 /* {0xa0, 0x34, 0xfe, 0x5b, 0x00, 0x00, 0x00, 0x10},
906 * max AGC value in AE */
907 /* {0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10},
909 /* {0xa0, 0x34, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x10},
910 * preset brightness */
911 /* {0xa0, 0x34, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x10},
913 /* {0xa0, 0x34, 0xe8, 0x31, 0x00, 0x00, 0x00, 0x10},
915 {0xa0, 0x34, 0xe9, 0x0f, 0x00, 0x00, 0x00, 0x10},
916 /* luminance mode (0x4f -> AutoExpo on) */
917 {0xa0, 0x34, 0xe4, 0xff, 0x00, 0x00, 0x00, 0x10},
919 /* {0xa0, 0x34, 0xef, 0x00, 0x00, 0x00, 0x00, 0x10},
921 /* {0xa0, 0x34, 0xfb, 0xee, 0x00, 0x00, 0x00, 0x10}, */
922 {0xa0, 0x34, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
925 static const u8 om6802_sensor_param1
[][8] = {
926 {0xa0, 0x34, 0x71, 0x84, 0x00, 0x00, 0x00, 0x10},
927 {0xa0, 0x34, 0x72, 0x05, 0x00, 0x00, 0x00, 0x10},
928 {0xa0, 0x34, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10},
929 {0xa0, 0x34, 0x69, 0x01, 0x00, 0x00, 0x00, 0x10},
932 static const u8 ov7630_sensor_init
[][8] = {
933 {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
934 {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
935 {DELAY
, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
936 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
937 {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
938 {DELAY
, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
939 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
940 /* win: i2c_r from 00 to 80 */
941 {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
942 {0xb1, 0x21, 0x0c, 0x20, 0x20, 0x00, 0x00, 0x10},
943 /* HDG: 0x11 was 0x00 change to 0x01 for better exposure (15 fps instead of 30)
944 0x13 was 0xc0 change to 0xc3 for auto gain and exposure */
945 {0xd1, 0x21, 0x11, 0x01, 0x48, 0xc3, 0x00, 0x10},
946 {0xb1, 0x21, 0x15, 0x80, 0x03, 0x00, 0x00, 0x10},
947 {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
948 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
949 {0xd1, 0x21, 0x1f, 0x00, 0x80, 0x80, 0x80, 0x10},
950 {0xd1, 0x21, 0x23, 0xde, 0x10, 0x8a, 0xa0, 0x10},
951 {0xc1, 0x21, 0x27, 0xca, 0xa2, 0x74, 0x00, 0x10},
952 {0xd1, 0x21, 0x2a, 0x88, 0x00, 0x88, 0x01, 0x10},
953 {0xc1, 0x21, 0x2e, 0x80, 0x00, 0x18, 0x00, 0x10},
954 {0xa1, 0x21, 0x21, 0x08, 0x00, 0x00, 0x00, 0x10},
955 {0xa1, 0x21, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
956 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
957 {0xb1, 0x21, 0x32, 0xc2, 0x08, 0x00, 0x00, 0x10},
958 {0xb1, 0x21, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x10},
959 {0xd1, 0x21, 0x60, 0x05, 0x40, 0x12, 0x57, 0x10},
960 {0xa1, 0x21, 0x64, 0x73, 0x00, 0x00, 0x00, 0x10},
961 {0xd1, 0x21, 0x65, 0x00, 0x55, 0x01, 0xac, 0x10},
962 {0xa1, 0x21, 0x69, 0x38, 0x00, 0x00, 0x00, 0x10},
963 {0xd1, 0x21, 0x6f, 0x1f, 0x01, 0x00, 0x10, 0x10},
964 {0xd1, 0x21, 0x73, 0x50, 0x20, 0x02, 0x01, 0x10},
965 {0xd1, 0x21, 0x77, 0xf3, 0x90, 0x98, 0x98, 0x10},
966 {0xc1, 0x21, 0x7b, 0x00, 0x4c, 0xf7, 0x00, 0x10},
967 {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
968 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
971 static const u8 ov7630_sensor_param1
[][8] = {
972 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
973 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
974 /*fixme: + 0x12, 0x04*/
975 /* {0xa1, 0x21, 0x75, 0x82, 0x00, 0x00, 0x00, 0x10}, * COMN
977 {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
978 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
979 {0xb1, 0x21, 0x01, 0x80, 0x80, 0x00, 0x00, 0x10},
981 /* {0xa1, 0x21, 0x2a, 0x88, 0x00, 0x00, 0x00, 0x10}, * set by setfreq */
982 /* {0xa1, 0x21, 0x2b, 0x34, 0x00, 0x00, 0x00, 0x10}, * set by setfreq */
984 {0xa1, 0x21, 0x10, 0x83, 0x00, 0x00, 0x00, 0x10},
985 /* {0xb1, 0x21, 0x01, 0x88, 0x70, 0x00, 0x00, 0x10}, */
989 static const u8 ov7648_sensor_init
[][8] = {
990 {0xa1, 0x21, 0x76, 0x00, 0x00, 0x00, 0x00, 0x10},
991 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset */
992 {DELAY
, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
993 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
994 {0xd1, 0x21, 0x03, 0xa4, 0x30, 0x88, 0x00, 0x10},
995 {0xb1, 0x21, 0x11, 0x80, 0x08, 0x00, 0x00, 0x10},
996 {0xc1, 0x21, 0x13, 0xa0, 0x04, 0x84, 0x00, 0x10},
997 {0xd1, 0x21, 0x17, 0x1a, 0x02, 0xba, 0xf4, 0x10},
998 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
999 {0xd1, 0x21, 0x1f, 0x41, 0xc0, 0x80, 0x80, 0x10},
1000 {0xd1, 0x21, 0x23, 0xde, 0xa0, 0x80, 0x32, 0x10},
1001 {0xd1, 0x21, 0x27, 0xfe, 0xa0, 0x00, 0x91, 0x10},
1002 {0xd1, 0x21, 0x2b, 0x00, 0x88, 0x85, 0x80, 0x10},
1003 {0xc1, 0x21, 0x2f, 0x9c, 0x00, 0xc4, 0x00, 0x10},
1004 {0xd1, 0x21, 0x60, 0xa6, 0x60, 0x88, 0x12, 0x10},
1005 {0xd1, 0x21, 0x64, 0x88, 0x00, 0x00, 0x94, 0x10},
1006 {0xd1, 0x21, 0x68, 0x7a, 0x0c, 0x00, 0x00, 0x10},
1007 {0xd1, 0x21, 0x6c, 0x11, 0x33, 0x22, 0x00, 0x10},
1008 {0xd1, 0x21, 0x70, 0x11, 0x00, 0x10, 0x50, 0x10},
1009 {0xd1, 0x21, 0x74, 0x20, 0x06, 0x00, 0xb5, 0x10},
1010 {0xd1, 0x21, 0x78, 0x8a, 0x00, 0x00, 0x00, 0x10},
1011 {0xb1, 0x21, 0x7c, 0x00, 0x43, 0x00, 0x00, 0x10},
1013 {0xd1, 0x21, 0x21, 0x86, 0x00, 0xde, 0xa0, 0x10},
1014 /* {0xd1, 0x21, 0x25, 0x80, 0x32, 0xfe, 0xa0, 0x10}, jfm done */
1015 /* {0xd1, 0x21, 0x29, 0x00, 0x91, 0x00, 0x88, 0x10}, jfm done */
1016 /* {0xb1, 0x21, 0x2d, 0x85, 0x00, 0x00, 0x00, 0x10}, set by setfreq */
1019 static const u8 ov7648_sensor_param1
[][8] = {
1020 /* {0xa1, 0x21, 0x12, 0x08, 0x00, 0x00, 0x00, 0x10}, jfm done */
1021 /* {0xa1, 0x21, 0x75, 0x06, 0x00, 0x00, 0x00, 0x10}, * COMN
1022 * set by setvflip */
1023 {0xa1, 0x21, 0x19, 0x02, 0x00, 0x00, 0x00, 0x10},
1024 {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
1025 /* {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
1026 /* {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}, * GAIN - def */
1027 /* {0xb1, 0x21, 0x01, 0x6c, 0x6c, 0x00, 0x00, 0x10}, * B R - def: 80 */
1029 {0xa1, 0x21, 0x11, 0x81, 0x00, 0x00, 0x00, 0x10}, /* CLKRC */
1030 /* {0xa1, 0x21, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
1031 /* {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
1032 /* {0xa1, 0x21, 0x2a, 0x91, 0x00, 0x00, 0x00, 0x10}, jfm done */
1033 /* {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
1034 /* {0xb1, 0x21, 0x01, 0x64, 0x84, 0x00, 0x00, 0x10}, * B R - def: 80 */
1039 static const u8 ov7660_sensor_init
[][8] = {
1040 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
1041 {DELAY
, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
1042 {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
1043 /* Outformat = rawRGB */
1044 {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
1045 {0xd1, 0x21, 0x00, 0x01, 0x74, 0x92, 0x00, 0x10},
1046 /* GAIN BLUE RED VREF */
1047 {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
1048 /* COM 1 BAVE GEAVE AECHH */
1049 {0xb1, 0x21, 0x08, 0x83, 0x01, 0x00, 0x00, 0x10}, /* RAVE COM2 */
1050 {0xd1, 0x21, 0x0c, 0x00, 0x08, 0x04, 0x4f, 0x10}, /* COM 3 4 5 6 */
1051 {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10},
1052 /* AECH CLKRC COM7 COM8 */
1053 {0xc1, 0x21, 0x14, 0x2c, 0x00, 0x02, 0x00, 0x10}, /* COM9 COM10 */
1054 {0xd1, 0x21, 0x17, 0x10, 0x60, 0x02, 0x7b, 0x10},
1055 /* HSTART HSTOP VSTRT VSTOP */
1056 {0xa1, 0x21, 0x1b, 0x02, 0x00, 0x00, 0x00, 0x10}, /* PSHFT */
1057 {0xb1, 0x21, 0x1e, 0x01, 0x0e, 0x00, 0x00, 0x10}, /* MVFP LAEC */
1058 {0xd1, 0x21, 0x20, 0x07, 0x07, 0x07, 0x07, 0x10},
1059 /* BOS GBOS GROS ROS (BGGR offset) */
1060 /* {0xd1, 0x21, 0x24, 0x68, 0x58, 0xd4, 0x80, 0x10}, */
1061 {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10},
1062 /* AEW AEB VPT BBIAS */
1063 {0xd1, 0x21, 0x28, 0x80, 0x30, 0x00, 0x00, 0x10},
1064 /* GbBIAS RSVD EXHCH EXHCL */
1065 {0xd1, 0x21, 0x2c, 0x80, 0x00, 0x00, 0x62, 0x10},
1066 /* RBIAS ADVFL ASDVFH YAVE */
1067 {0xc1, 0x21, 0x30, 0x08, 0x30, 0xb4, 0x00, 0x10},
1068 /* HSYST HSYEN HREF */
1069 {0xd1, 0x21, 0x33, 0x00, 0x07, 0x84, 0x00, 0x10}, /* reserved */
1070 {0xd1, 0x21, 0x37, 0x0c, 0x02, 0x43, 0x00, 0x10},
1071 /* ADC ACOM OFON TSLB */
1072 {0xd1, 0x21, 0x3b, 0x02, 0x6c, 0x19, 0x0e, 0x10},
1073 /* COM11 COM12 COM13 COM14 */
1074 {0xd1, 0x21, 0x3f, 0x41, 0xc1, 0x22, 0x08, 0x10},
1075 /* EDGE COM15 COM16 COM17 */
1076 {0xd1, 0x21, 0x43, 0xf0, 0x10, 0x78, 0xa8, 0x10}, /* reserved */
1077 {0xd1, 0x21, 0x47, 0x60, 0x80, 0x00, 0x00, 0x10}, /* reserved */
1078 {0xd1, 0x21, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* reserved */
1079 {0xd1, 0x21, 0x4f, 0x46, 0x36, 0x0f, 0x17, 0x10}, /* MTX 1 2 3 4 */
1080 {0xd1, 0x21, 0x53, 0x7f, 0x96, 0x40, 0x40, 0x10}, /* MTX 5 6 7 8 */
1081 {0xb1, 0x21, 0x57, 0x40, 0x0f, 0x00, 0x00, 0x10}, /* MTX9 MTXS */
1082 {0xd1, 0x21, 0x59, 0xba, 0x9a, 0x22, 0xb9, 0x10}, /* reserved */
1083 {0xd1, 0x21, 0x5d, 0x9b, 0x10, 0xf0, 0x05, 0x10}, /* reserved */
1084 {0xa1, 0x21, 0x61, 0x60, 0x00, 0x00, 0x00, 0x10}, /* reserved */
1085 {0xd1, 0x21, 0x62, 0x00, 0x00, 0x50, 0x30, 0x10},
1086 /* LCC1 LCC2 LCC3 LCC4 */
1087 {0xa1, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00, 0x10}, /* LCC5 */
1088 {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10}, /* MANU */
1089 {0xa1, 0x21, 0x6b, 0x0a, 0x00, 0x00, 0x00, 0x10},
1090 /* band gap reference [0:3] DBLV */
1091 {0xd1, 0x21, 0x6c, 0x30, 0x48, 0x80, 0x74, 0x10}, /* gamma curve */
1092 {0xd1, 0x21, 0x70, 0x64, 0x60, 0x5c, 0x58, 0x10}, /* gamma curve */
1093 {0xd1, 0x21, 0x74, 0x54, 0x4c, 0x40, 0x38, 0x10}, /* gamma curve */
1094 {0xd1, 0x21, 0x78, 0x34, 0x30, 0x2f, 0x2b, 0x10}, /* gamma curve */
1095 {0xd1, 0x21, 0x7c, 0x03, 0x07, 0x17, 0x34, 0x10}, /* gamma curve */
1096 {0xd1, 0x21, 0x80, 0x41, 0x4d, 0x58, 0x63, 0x10}, /* gamma curve */
1097 {0xd1, 0x21, 0x84, 0x6e, 0x77, 0x87, 0x95, 0x10}, /* gamma curve */
1098 {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10}, /* gamma curve */
1099 {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10}, /* reserved */
1100 {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10}, /* DM_LNL/H */
1101 /* not in all ms-win traces*/
1102 {0xa1, 0x21, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x10},
1105 static const u8 ov7660_sensor_param1
[][8] = {
1106 {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10}, /* MVFP */
1107 /* bits[3..0]reserved */
1108 {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
1109 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
1110 /* VREF vertical frame ctrl */
1111 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
1112 {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10}, /* AECH 0x20 */
1113 {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFL */
1114 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFH */
1115 {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10}, /* GAIN */
1116 /* {0xb1, 0x21, 0x01, 0x78, 0x78, 0x00, 0x00, 0x10}, * BLUE */
1117 /****** (some exchanges in the win trace) ******/
1119 {0xa1, 0x21, 0x93, 0x00, 0x00, 0x00, 0x00, 0x10},/* dummy line hight */
1120 {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10}, /* dummy line low */
1121 {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCH */
1122 {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCL */
1123 /* {0xa1, 0x21, 0x02, 0x90, 0x00, 0x00, 0x00, 0x10}, * RED */
1124 /****** (some exchanges in the win trace) ******/
1125 /******!! startsensor KO if changed !!****/
1127 {0xa1, 0x21, 0x93, 0x01, 0x00, 0x00, 0x00, 0x10},
1128 {0xa1, 0x21, 0x92, 0xff, 0x00, 0x00, 0x00, 0x10},
1129 {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
1130 {0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
1134 static const u8 po1030_sensor_init
[][8] = {
1135 /* the sensor registers are described in m5602/m5602_po1030.h */
1136 {0xa1, 0x6e, 0x3f, 0x20, 0x00, 0x00, 0x00, 0x10}, /* sensor reset */
1137 {DELAY
, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
1138 {0xa1, 0x6e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x10},
1139 {0xa1, 0x6e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x10},
1140 {0xd1, 0x6e, 0x04, 0x02, 0xb1, 0x02, 0x39, 0x10},
1141 {0xd1, 0x6e, 0x08, 0x00, 0x01, 0x00, 0x00, 0x10},
1142 {0xd1, 0x6e, 0x0c, 0x02, 0x7f, 0x01, 0xe0, 0x10},
1143 {0xd1, 0x6e, 0x12, 0x03, 0x02, 0x00, 0x03, 0x10},
1144 {0xd1, 0x6e, 0x16, 0x85, 0x40, 0x4a, 0x40, 0x10}, /* r/g1/b/g2 gains */
1145 {0xc1, 0x6e, 0x1a, 0x00, 0x80, 0x00, 0x00, 0x10},
1146 {0xd1, 0x6e, 0x1d, 0x08, 0x03, 0x00, 0x00, 0x10},
1147 {0xd1, 0x6e, 0x23, 0x00, 0xb0, 0x00, 0x94, 0x10},
1148 {0xd1, 0x6e, 0x27, 0x58, 0x00, 0x00, 0x00, 0x10},
1149 {0xb1, 0x6e, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
1150 {0xd1, 0x6e, 0x2d, 0x14, 0x35, 0x61, 0x84, 0x10}, /* gamma corr */
1151 {0xd1, 0x6e, 0x31, 0xa2, 0xbd, 0xd8, 0xff, 0x10},
1152 {0xd1, 0x6e, 0x35, 0x06, 0x1e, 0x12, 0x02, 0x10}, /* color matrix */
1153 {0xd1, 0x6e, 0x39, 0xaa, 0x53, 0x37, 0xd5, 0x10},
1154 {0xa1, 0x6e, 0x3d, 0xf2, 0x00, 0x00, 0x00, 0x10},
1155 {0xd1, 0x6e, 0x3e, 0x00, 0x00, 0x80, 0x03, 0x10},
1156 {0xd1, 0x6e, 0x42, 0x03, 0x00, 0x00, 0x00, 0x10},
1157 {0xc1, 0x6e, 0x46, 0x00, 0x80, 0x80, 0x00, 0x10},
1158 {0xd1, 0x6e, 0x4b, 0x02, 0xef, 0x08, 0xcd, 0x10},
1159 {0xd1, 0x6e, 0x4f, 0x00, 0xd0, 0x00, 0xa0, 0x10},
1160 {0xd1, 0x6e, 0x53, 0x01, 0xaa, 0x01, 0x40, 0x10},
1161 {0xd1, 0x6e, 0x5a, 0x50, 0x04, 0x30, 0x03, 0x10}, /* raw rgb bayer */
1162 {0xa1, 0x6e, 0x5e, 0x00, 0x00, 0x00, 0x00, 0x10},
1163 {0xd1, 0x6e, 0x5f, 0x10, 0x40, 0xff, 0x00, 0x10},
1165 {0xd1, 0x6e, 0x63, 0x40, 0x40, 0x00, 0x00, 0x10},
1166 {0xd1, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x10},
1167 {0xd1, 0x6e, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x10},
1168 {0xd1, 0x6e, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x10},
1169 {0xc1, 0x6e, 0x73, 0x10, 0x80, 0xeb, 0x00, 0x10},
1172 static const u8 po1030_sensor_param1
[][8] = {
1173 /* from ms-win traces - these values change with auto gain/expo/wb.. */
1174 {0xa1, 0x6e, 0x1e, 0x03, 0x00, 0x00, 0x00, 0x10},
1175 {0xa1, 0x6e, 0x1e, 0x03, 0x00, 0x00, 0x00, 0x10},
1177 {0xc1, 0x6e, 0x1a, 0x02, 0xd4, 0xa4, 0x00, 0x10}, /* integlines */
1178 {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10}, /* global gain */
1179 {0xc1, 0x6e, 0x16, 0x40, 0x40, 0x40, 0x00, 0x10}, /* r/g1/b gains */
1181 {0xa1, 0x6e, 0x1d, 0x08, 0x00, 0x00, 0x00, 0x10}, /* control1 */
1182 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10}, /* frameheight */
1183 {0xa1, 0x6e, 0x07, 0xd5, 0x00, 0x00, 0x00, 0x10},
1184 /* {0xc1, 0x6e, 0x16, 0x49, 0x40, 0x45, 0x00, 0x10}, */
1188 static const u8 po2030n_sensor_init
[][8] = {
1189 {0xa1, 0x6e, 0x1e, 0x1a, 0x00, 0x00, 0x00, 0x10},
1190 {0xa1, 0x6e, 0x1f, 0x99, 0x00, 0x00, 0x00, 0x10},
1191 {DELAY
, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
1192 {0xa1, 0x6e, 0x1e, 0x0a, 0x00, 0x00, 0x00, 0x10},
1193 {0xa1, 0x6e, 0x1f, 0x19, 0x00, 0x00, 0x00, 0x10},
1194 {DELAY
, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
1195 {0xa1, 0x6e, 0x20, 0x44, 0x00, 0x00, 0x00, 0x10},
1196 {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
1197 {0xa1, 0x6e, 0x05, 0x70, 0x00, 0x00, 0x00, 0x10},
1198 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
1199 {0xa1, 0x6e, 0x07, 0x25, 0x00, 0x00, 0x00, 0x10},
1200 {0xd1, 0x6e, 0x08, 0x00, 0xd0, 0x00, 0x08, 0x10},
1201 {0xd1, 0x6e, 0x0c, 0x03, 0x50, 0x01, 0xe8, 0x10},
1202 {0xd1, 0x6e, 0x1d, 0x20, 0x0a, 0x19, 0x44, 0x10},
1203 {0xd1, 0x6e, 0x21, 0x00, 0x00, 0x00, 0x00, 0x10},
1204 {0xd1, 0x6e, 0x25, 0x00, 0x00, 0x00, 0x00, 0x10},
1205 {0xd1, 0x6e, 0x29, 0x00, 0x00, 0x00, 0x00, 0x10},
1206 {0xd1, 0x6e, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
1207 {0xd1, 0x6e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
1208 {0xd1, 0x6e, 0x35, 0x00, 0x00, 0x00, 0x00, 0x10},
1209 {0xd1, 0x6e, 0x39, 0x00, 0x00, 0x00, 0x00, 0x10},
1210 {0xd1, 0x6e, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x10},
1211 {0xd1, 0x6e, 0x41, 0x00, 0x00, 0x00, 0x00, 0x10},
1212 {0xd1, 0x6e, 0x45, 0x00, 0x00, 0x00, 0x00, 0x10},
1213 {0xd1, 0x6e, 0x49, 0x00, 0x00, 0x00, 0x00, 0x10},
1214 {0xd1, 0x6e, 0x4d, 0x00, 0x00, 0x00, 0xed, 0x10},
1215 {0xd1, 0x6e, 0x51, 0x17, 0x4a, 0x2f, 0xc0, 0x10},
1216 {0xd1, 0x6e, 0x55, 0x00, 0x00, 0x00, 0x00, 0x10},
1217 {0xd1, 0x6e, 0x59, 0x00, 0x00, 0x00, 0x00, 0x10},
1218 {0xd1, 0x6e, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x10},
1219 {0xd1, 0x6e, 0x61, 0x00, 0x00, 0x00, 0x00, 0x10},
1220 {0xd1, 0x6e, 0x65, 0x00, 0x00, 0x00, 0x00, 0x10},
1221 {0xd1, 0x6e, 0x69, 0x00, 0x00, 0x00, 0x00, 0x10},
1222 {0xd1, 0x6e, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x10},
1223 {0xd1, 0x6e, 0x71, 0x00, 0x00, 0x00, 0x00, 0x10},
1224 {0xd1, 0x6e, 0x75, 0x00, 0x00, 0x00, 0x00, 0x10},
1225 {0xd1, 0x6e, 0x79, 0x00, 0x00, 0x00, 0x00, 0x10},
1226 {0xd1, 0x6e, 0x7d, 0x00, 0x00, 0x00, 0x00, 0x10},
1227 {0xd1, 0x6e, 0x81, 0x00, 0x00, 0x00, 0x00, 0x10},
1228 {0xd1, 0x6e, 0x85, 0x00, 0x00, 0x00, 0x08, 0x10},
1229 {0xd1, 0x6e, 0x89, 0x01, 0xe8, 0x00, 0x01, 0x10},
1230 {0xa1, 0x6e, 0x8d, 0x00, 0x00, 0x00, 0x00, 0x10},
1231 {0xd1, 0x6e, 0x21, 0x00, 0x00, 0x00, 0x00, 0x10},
1232 {0xd1, 0x6e, 0x25, 0x00, 0x00, 0x00, 0x01, 0x10},
1233 {0xd1, 0x6e, 0x29, 0xe6, 0x00, 0xbd, 0x03, 0x10},
1234 {0xd1, 0x6e, 0x2d, 0x41, 0x38, 0x68, 0x40, 0x10},
1235 {0xd1, 0x6e, 0x31, 0x2b, 0x00, 0x36, 0x00, 0x10},
1236 {0xd1, 0x6e, 0x35, 0x30, 0x30, 0x08, 0x00, 0x10},
1237 {0xd1, 0x6e, 0x39, 0x00, 0x00, 0x33, 0x06, 0x10},
1238 {0xb1, 0x6e, 0x3d, 0x06, 0x02, 0x00, 0x00, 0x10},
1241 static const u8 po2030n_sensor_param1
[][8] = {
1242 {0xa1, 0x6e, 0x1a, 0x01, 0x00, 0x00, 0x00, 0x10},
1243 {DELAY
, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 8ms */
1244 {0xa1, 0x6e, 0x1b, 0xf4, 0x00, 0x00, 0x00, 0x10},
1245 {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
1246 {0xd1, 0x6e, 0x16, 0x50, 0x40, 0x49, 0x40, 0x10},
1248 {0xa1, 0x6e, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
1249 {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
1250 {0xa1, 0x6e, 0x05, 0x6f, 0x00, 0x00, 0x00, 0x10},
1251 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
1252 {0xa1, 0x6e, 0x07, 0x25, 0x00, 0x00, 0x00, 0x10},
1253 {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
1254 {0xc1, 0x6e, 0x16, 0x52, 0x40, 0x48, 0x00, 0x10},
1256 {0xa1, 0x6e, 0x15, 0x0f, 0x00, 0x00, 0x00, 0x10},
1257 {DELAY
, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 5ms */
1258 {0xa1, 0x6e, 0x1a, 0x05, 0x00, 0x00, 0x00, 0x10},
1259 {DELAY
, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 5ms */
1260 {0xa1, 0x6e, 0x1b, 0x53, 0x00, 0x00, 0x00, 0x10},
1264 static const u8 soi768_sensor_init
[][8] = {
1265 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset */
1266 {DELAY
, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 96ms */
1267 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
1268 {0xa1, 0x21, 0x13, 0x80, 0x00, 0x00, 0x00, 0x10},
1269 {0xa1, 0x21, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x10},
1270 {0xa1, 0x21, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10},
1273 static const u8 soi768_sensor_param1
[][8] = {
1274 {0xa1, 0x21, 0x10, 0x10, 0x00, 0x00, 0x00, 0x10},
1275 {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
1276 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
1277 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1278 {0xb1, 0x21, 0x01, 0x7f, 0x7f, 0x00, 0x00, 0x10},
1280 /* {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, */
1281 /* {0xa1, 0x21, 0x2d, 0x25, 0x00, 0x00, 0x00, 0x10}, */
1282 {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
1283 /* {0xb1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, */
1284 {0xa1, 0x21, 0x02, 0x8d, 0x00, 0x00, 0x00, 0x10},
1285 /* the next sequence should be used for auto gain */
1286 {0xa1, 0x21, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10},
1287 /* global gain ? : 07 - change with 0x15 at the end */
1288 {0xa1, 0x21, 0x10, 0x3f, 0x00, 0x00, 0x00, 0x10}, /* ???? : 063f */
1289 {0xa1, 0x21, 0x04, 0x06, 0x00, 0x00, 0x00, 0x10},
1290 {0xb1, 0x21, 0x2d, 0x00, 0x02, 0x00, 0x00, 0x10},
1291 /* exposure ? : 0200 - change with 0x1e at the end */
1295 static const u8 sp80708_sensor_init
[][8] = {
1296 {0xa1, 0x18, 0x06, 0xf9, 0x00, 0x00, 0x00, 0x10},
1297 {0xa1, 0x18, 0x09, 0x1f, 0x00, 0x00, 0x00, 0x10},
1298 {0xa1, 0x18, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
1299 {0xa1, 0x18, 0x0d, 0xc0, 0x00, 0x00, 0x00, 0x10},
1300 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
1301 {0xa1, 0x18, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x10},
1302 {0xa1, 0x18, 0x10, 0x40, 0x00, 0x00, 0x00, 0x10},
1303 {0xa1, 0x18, 0x11, 0x4e, 0x00, 0x00, 0x00, 0x10},
1304 {0xa1, 0x18, 0x12, 0x53, 0x00, 0x00, 0x00, 0x10},
1305 {0xa1, 0x18, 0x15, 0x80, 0x00, 0x00, 0x00, 0x10},
1306 {0xa1, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x10},
1307 {0xa1, 0x18, 0x19, 0x18, 0x00, 0x00, 0x00, 0x10},
1308 {0xa1, 0x18, 0x1a, 0x10, 0x00, 0x00, 0x00, 0x10},
1309 {0xa1, 0x18, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x10},
1310 {0xa1, 0x18, 0x1c, 0x28, 0x00, 0x00, 0x00, 0x10},
1311 {0xa1, 0x18, 0x1d, 0x02, 0x00, 0x00, 0x00, 0x10},
1312 {0xa1, 0x18, 0x1e, 0x10, 0x00, 0x00, 0x00, 0x10},
1313 {0xa1, 0x18, 0x26, 0x04, 0x00, 0x00, 0x00, 0x10},
1314 {0xa1, 0x18, 0x27, 0x1e, 0x00, 0x00, 0x00, 0x10},
1315 {0xa1, 0x18, 0x28, 0x5a, 0x00, 0x00, 0x00, 0x10},
1316 {0xa1, 0x18, 0x29, 0x28, 0x00, 0x00, 0x00, 0x10},
1317 {0xa1, 0x18, 0x2a, 0x78, 0x00, 0x00, 0x00, 0x10},
1318 {0xa1, 0x18, 0x2b, 0x01, 0x00, 0x00, 0x00, 0x10},
1319 {0xa1, 0x18, 0x2c, 0xf7, 0x00, 0x00, 0x00, 0x10},
1320 {0xa1, 0x18, 0x2d, 0x2d, 0x00, 0x00, 0x00, 0x10},
1321 {0xa1, 0x18, 0x2e, 0xd5, 0x00, 0x00, 0x00, 0x10},
1322 {0xa1, 0x18, 0x39, 0x42, 0x00, 0x00, 0x00, 0x10},
1323 {0xa1, 0x18, 0x3a, 0x67, 0x00, 0x00, 0x00, 0x10},
1324 {0xa1, 0x18, 0x3b, 0x87, 0x00, 0x00, 0x00, 0x10},
1325 {0xa1, 0x18, 0x3c, 0xa3, 0x00, 0x00, 0x00, 0x10},
1326 {0xa1, 0x18, 0x3d, 0xb0, 0x00, 0x00, 0x00, 0x10},
1327 {0xa1, 0x18, 0x3e, 0xbc, 0x00, 0x00, 0x00, 0x10},
1328 {0xa1, 0x18, 0x3f, 0xc8, 0x00, 0x00, 0x00, 0x10},
1329 {0xa1, 0x18, 0x40, 0xd4, 0x00, 0x00, 0x00, 0x10},
1330 {0xa1, 0x18, 0x41, 0xdf, 0x00, 0x00, 0x00, 0x10},
1331 {0xa1, 0x18, 0x42, 0xea, 0x00, 0x00, 0x00, 0x10},
1332 {0xa1, 0x18, 0x43, 0xf5, 0x00, 0x00, 0x00, 0x10},
1333 {0xa1, 0x18, 0x45, 0x80, 0x00, 0x00, 0x00, 0x10},
1334 {0xa1, 0x18, 0x46, 0x60, 0x00, 0x00, 0x00, 0x10},
1335 {0xa1, 0x18, 0x47, 0x50, 0x00, 0x00, 0x00, 0x10},
1336 {0xa1, 0x18, 0x48, 0x30, 0x00, 0x00, 0x00, 0x10},
1337 {0xa1, 0x18, 0x49, 0x01, 0x00, 0x00, 0x00, 0x10},
1338 {0xa1, 0x18, 0x4d, 0xae, 0x00, 0x00, 0x00, 0x10},
1339 {0xa1, 0x18, 0x4e, 0x03, 0x00, 0x00, 0x00, 0x10},
1340 {0xa1, 0x18, 0x4f, 0x66, 0x00, 0x00, 0x00, 0x10},
1341 {0xa1, 0x18, 0x50, 0x1c, 0x00, 0x00, 0x00, 0x10},
1342 {0xa1, 0x18, 0x44, 0x10, 0x00, 0x00, 0x00, 0x10},
1343 {0xa1, 0x18, 0x4a, 0x30, 0x00, 0x00, 0x00, 0x10},
1344 {0xa1, 0x18, 0x51, 0x80, 0x00, 0x00, 0x00, 0x10},
1345 {0xa1, 0x18, 0x52, 0x80, 0x00, 0x00, 0x00, 0x10},
1346 {0xa1, 0x18, 0x53, 0x80, 0x00, 0x00, 0x00, 0x10},
1347 {0xa1, 0x18, 0x54, 0x80, 0x00, 0x00, 0x00, 0x10},
1348 {0xa1, 0x18, 0x55, 0x80, 0x00, 0x00, 0x00, 0x10},
1349 {0xa1, 0x18, 0x56, 0x80, 0x00, 0x00, 0x00, 0x10},
1350 {0xa1, 0x18, 0x57, 0xe0, 0x00, 0x00, 0x00, 0x10},
1351 {0xa1, 0x18, 0x58, 0xc0, 0x00, 0x00, 0x00, 0x10},
1352 {0xa1, 0x18, 0x59, 0xab, 0x00, 0x00, 0x00, 0x10},
1353 {0xa1, 0x18, 0x5a, 0xa0, 0x00, 0x00, 0x00, 0x10},
1354 {0xa1, 0x18, 0x5b, 0x99, 0x00, 0x00, 0x00, 0x10},
1355 {0xa1, 0x18, 0x5c, 0x90, 0x00, 0x00, 0x00, 0x10},
1356 {0xa1, 0x18, 0x5e, 0x24, 0x00, 0x00, 0x00, 0x10},
1357 {0xa1, 0x18, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x10},
1358 {0xa1, 0x18, 0x60, 0x00, 0x00, 0x00, 0x00, 0x10},
1359 {0xa1, 0x18, 0x61, 0x73, 0x00, 0x00, 0x00, 0x10},
1360 {0xa1, 0x18, 0x63, 0x42, 0x00, 0x00, 0x00, 0x10},
1361 {0xa1, 0x18, 0x64, 0x42, 0x00, 0x00, 0x00, 0x10},
1362 {0xa1, 0x18, 0x65, 0x42, 0x00, 0x00, 0x00, 0x10},
1363 {0xa1, 0x18, 0x66, 0x24, 0x00, 0x00, 0x00, 0x10},
1364 {0xa1, 0x18, 0x67, 0x24, 0x00, 0x00, 0x00, 0x10},
1365 {0xa1, 0x18, 0x68, 0x08, 0x00, 0x00, 0x00, 0x10},
1366 {0xa1, 0x18, 0x2f, 0xc9, 0x00, 0x00, 0x00, 0x10},
1369 static const u8 sp80708_sensor_param1
[][8] = {
1370 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
1371 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
1372 {0xa1, 0x18, 0x03, 0x01, 0x00, 0x00, 0x00, 0x10},
1373 {0xa1, 0x18, 0x04, 0xa4, 0x00, 0x00, 0x00, 0x10},
1374 {0xa1, 0x18, 0x14, 0x3f, 0x00, 0x00, 0x00, 0x10},
1375 {0xa1, 0x18, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
1376 {0xb1, 0x18, 0x11, 0x40, 0x40, 0x00, 0x00, 0x10},
1380 static const u8 (*sensor_init
[])[8] = {
1381 [SENSOR_ADCM1700
] = adcm1700_sensor_init
,
1382 [SENSOR_GC0307
] = gc0307_sensor_init
,
1383 [SENSOR_HV7131R
] = hv7131r_sensor_init
,
1384 [SENSOR_MI0360
] = mi0360_sensor_init
,
1385 [SENSOR_MI0360B
] = mi0360b_sensor_init
,
1386 [SENSOR_MO4000
] = mo4000_sensor_init
,
1387 [SENSOR_MT9V111
] = mt9v111_sensor_init
,
1388 [SENSOR_OM6802
] = om6802_sensor_init
,
1389 [SENSOR_OV7630
] = ov7630_sensor_init
,
1390 [SENSOR_OV7648
] = ov7648_sensor_init
,
1391 [SENSOR_OV7660
] = ov7660_sensor_init
,
1392 [SENSOR_PO1030
] = po1030_sensor_init
,
1393 [SENSOR_PO2030N
] = po2030n_sensor_init
,
1394 [SENSOR_SOI768
] = soi768_sensor_init
,
1395 [SENSOR_SP80708
] = sp80708_sensor_init
,
1398 /* read <len> bytes to gspca_dev->usb_buf */
1399 static void reg_r(struct gspca_dev
*gspca_dev
,
1404 if (gspca_dev
->usb_err
< 0)
1407 if (len
> USB_BUF_SZ
) {
1408 err("reg_r: buffer overflow");
1412 ret
= usb_control_msg(gspca_dev
->dev
,
1413 usb_rcvctrlpipe(gspca_dev
->dev
, 0),
1415 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
1417 gspca_dev
->usb_buf
, len
,
1419 PDEBUG(D_USBI
, "reg_r [%02x] -> %02x", value
, gspca_dev
->usb_buf
[0]);
1421 err("reg_r err %d", ret
);
1422 gspca_dev
->usb_err
= ret
;
1426 static void reg_w1(struct gspca_dev
*gspca_dev
,
1432 if (gspca_dev
->usb_err
< 0)
1434 PDEBUG(D_USBO
, "reg_w1 [%04x] = %02x", value
, data
);
1435 gspca_dev
->usb_buf
[0] = data
;
1436 ret
= usb_control_msg(gspca_dev
->dev
,
1437 usb_sndctrlpipe(gspca_dev
->dev
, 0),
1439 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
1442 gspca_dev
->usb_buf
, 1,
1445 err("reg_w1 err %d", ret
);
1446 gspca_dev
->usb_err
= ret
;
1449 static void reg_w(struct gspca_dev
*gspca_dev
,
1456 if (gspca_dev
->usb_err
< 0)
1458 PDEBUG(D_USBO
, "reg_w [%04x] = %02x %02x ..",
1459 value
, buffer
[0], buffer
[1]);
1461 if (len
> USB_BUF_SZ
) {
1462 err("reg_w: buffer overflow");
1466 memcpy(gspca_dev
->usb_buf
, buffer
, len
);
1467 ret
= usb_control_msg(gspca_dev
->dev
,
1468 usb_sndctrlpipe(gspca_dev
->dev
, 0),
1470 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
1472 gspca_dev
->usb_buf
, len
,
1475 err("reg_w err %d", ret
);
1476 gspca_dev
->usb_err
= ret
;
1480 /* I2C write 1 byte */
1481 static void i2c_w1(struct gspca_dev
*gspca_dev
, u8 reg
, u8 val
)
1483 struct sd
*sd
= (struct sd
*) gspca_dev
;
1486 if (gspca_dev
->usb_err
< 0)
1488 PDEBUG(D_USBO
, "i2c_w1 [%02x] = %02x", reg
, val
);
1489 switch (sd
->sensor
) {
1490 case SENSOR_ADCM1700
:
1492 case SENSOR_GC0307
: /* i2c command = a0 (100 kHz) */
1493 gspca_dev
->usb_buf
[0] = 0x80 | (2 << 4);
1495 default: /* i2c command = a1 (400 kHz) */
1496 gspca_dev
->usb_buf
[0] = 0x81 | (2 << 4);
1499 gspca_dev
->usb_buf
[1] = sd
->i2c_addr
;
1500 gspca_dev
->usb_buf
[2] = reg
;
1501 gspca_dev
->usb_buf
[3] = val
;
1502 gspca_dev
->usb_buf
[4] = 0;
1503 gspca_dev
->usb_buf
[5] = 0;
1504 gspca_dev
->usb_buf
[6] = 0;
1505 gspca_dev
->usb_buf
[7] = 0x10;
1506 ret
= usb_control_msg(gspca_dev
->dev
,
1507 usb_sndctrlpipe(gspca_dev
->dev
, 0),
1509 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
1510 0x08, /* value = i2c */
1512 gspca_dev
->usb_buf
, 8,
1515 err("i2c_w1 err %d", ret
);
1516 gspca_dev
->usb_err
= ret
;
1520 /* I2C write 8 bytes */
1521 static void i2c_w8(struct gspca_dev
*gspca_dev
,
1526 if (gspca_dev
->usb_err
< 0)
1528 PDEBUG(D_USBO
, "i2c_w8 [%02x] = %02x ..",
1529 buffer
[2], buffer
[3]);
1530 memcpy(gspca_dev
->usb_buf
, buffer
, 8);
1531 ret
= usb_control_msg(gspca_dev
->dev
,
1532 usb_sndctrlpipe(gspca_dev
->dev
, 0),
1534 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
1535 0x08, 0, /* value, index */
1536 gspca_dev
->usb_buf
, 8,
1540 err("i2c_w8 err %d", ret
);
1541 gspca_dev
->usb_err
= ret
;
1545 /* sensor read 'len' (1..5) bytes in gspca_dev->usb_buf */
1546 static void i2c_r(struct gspca_dev
*gspca_dev
, u8 reg
, int len
)
1548 struct sd
*sd
= (struct sd
*) gspca_dev
;
1551 switch (sd
->sensor
) {
1552 case SENSOR_ADCM1700
:
1554 case SENSOR_GC0307
: /* i2c command = a0 (100 kHz) */
1555 mode
[0] = 0x80 | 0x10;
1557 default: /* i2c command = 91 (400 kHz) */
1558 mode
[0] = 0x81 | 0x10;
1561 mode
[1] = sd
->i2c_addr
;
1568 i2c_w8(gspca_dev
, mode
);
1570 mode
[0] = (mode
[0] & 0x81) | (len
<< 4) | 0x02;
1572 i2c_w8(gspca_dev
, mode
);
1574 reg_r(gspca_dev
, 0x0a, 5);
1577 static void i2c_w_seq(struct gspca_dev
*gspca_dev
,
1578 const u8 (*data
)[8])
1580 while ((*data
)[0] != 0) {
1581 if ((*data
)[0] != DELAY
)
1582 i2c_w8(gspca_dev
, *data
);
1589 /* check the ID of the hv7131 sensor */
1590 /* this sequence is needed because it activates the sensor */
1591 static void hv7131r_probe(struct gspca_dev
*gspca_dev
)
1593 i2c_w1(gspca_dev
, 0x02, 0); /* sensor wakeup */
1595 reg_w1(gspca_dev
, 0x02, 0x66); /* Gpio on */
1597 i2c_r(gspca_dev
, 0, 5); /* read sensor id */
1598 if (gspca_dev
->usb_buf
[0] == 0x02 /* chip ID (02 is R) */
1599 && gspca_dev
->usb_buf
[1] == 0x09
1600 && gspca_dev
->usb_buf
[2] == 0x01) {
1601 PDEBUG(D_PROBE
, "Sensor HV7131R found");
1604 warn("Erroneous HV7131R ID 0x%02x 0x%02x 0x%02x",
1605 gspca_dev
->usb_buf
[0], gspca_dev
->usb_buf
[1],
1606 gspca_dev
->usb_buf
[2]);
1609 static void mi0360_probe(struct gspca_dev
*gspca_dev
)
1611 struct sd
*sd
= (struct sd
*) gspca_dev
;
1614 static const u8 probe_tb
[][4][8] = {
1616 {0xb0, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
1617 {0x90, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1618 {0xa2, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1619 {0xb0, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10}
1622 {0xb0, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10},
1623 {0x90, 0x5c, 0x36, 0x00, 0x00, 0x00, 0x00, 0x10},
1624 {0xa2, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1629 for (i
= 0; i
< ARRAY_SIZE(probe_tb
); i
++) {
1630 reg_w1(gspca_dev
, 0x17, 0x62);
1631 reg_w1(gspca_dev
, 0x01, 0x08);
1632 for (j
= 0; j
< 3; j
++)
1633 i2c_w8(gspca_dev
, probe_tb
[i
][j
]);
1635 reg_r(gspca_dev
, 0x0a, 5);
1636 val
= (gspca_dev
->usb_buf
[3] << 8) | gspca_dev
->usb_buf
[4];
1637 if (probe_tb
[i
][3][0] != 0)
1638 i2c_w8(gspca_dev
, probe_tb
[i
][3]);
1639 reg_w1(gspca_dev
, 0x01, 0x29);
1640 reg_w1(gspca_dev
, 0x17, 0x42);
1644 if (gspca_dev
->usb_err
< 0)
1648 PDEBUG(D_PROBE
, "Sensor mi0360b");
1649 sd
->sensor
= SENSOR_MI0360B
;
1652 PDEBUG(D_PROBE
, "Sensor mt9v111");
1653 sd
->sensor
= SENSOR_MT9V111
;
1656 PDEBUG(D_PROBE
, "Sensor mi0360");
1659 PDEBUG(D_PROBE
, "Unknown sensor %04x - forced to mi0360", val
);
1664 static void ov7630_probe(struct gspca_dev
*gspca_dev
)
1666 struct sd
*sd
= (struct sd
*) gspca_dev
;
1670 reg_w1(gspca_dev
, 0x17, 0x62);
1671 reg_w1(gspca_dev
, 0x01, 0x08);
1672 sd
->i2c_addr
= 0x21;
1673 i2c_r(gspca_dev
, 0x0a, 2);
1674 val
= (gspca_dev
->usb_buf
[3] << 8) | gspca_dev
->usb_buf
[4];
1675 reg_w1(gspca_dev
, 0x01, 0x29);
1676 reg_w1(gspca_dev
, 0x17, 0x42);
1677 if (gspca_dev
->usb_err
< 0)
1679 if (val
== 0x7628) { /* soi768 */
1680 sd
->sensor
= SENSOR_SOI768
;
1681 /*fixme: only valid for 0c45:613e?*/
1682 gspca_dev
->cam
.input_flags
=
1683 V4L2_IN_ST_VFLIP
| V4L2_IN_ST_HFLIP
;
1684 PDEBUG(D_PROBE
, "Sensor soi768");
1687 PDEBUG(D_PROBE
, "Sensor ov%04x", val
);
1690 static void ov7648_probe(struct gspca_dev
*gspca_dev
)
1692 struct sd
*sd
= (struct sd
*) gspca_dev
;
1696 reg_w1(gspca_dev
, 0x17, 0x62);
1697 reg_w1(gspca_dev
, 0x01, 0x08);
1698 sd
->i2c_addr
= 0x21;
1699 i2c_r(gspca_dev
, 0x0a, 2);
1700 val
= (gspca_dev
->usb_buf
[3] << 8) | gspca_dev
->usb_buf
[4];
1701 reg_w1(gspca_dev
, 0x01, 0x29);
1702 reg_w1(gspca_dev
, 0x17, 0x42);
1703 if ((val
& 0xff00) == 0x7600) { /* ov76xx */
1704 PDEBUG(D_PROBE
, "Sensor ov%04x", val
);
1709 reg_w1(gspca_dev
, 0x17, 0x62);
1710 reg_w1(gspca_dev
, 0x01, 0x08);
1711 sd
->i2c_addr
= 0x6e;
1712 i2c_r(gspca_dev
, 0x00, 2);
1713 val
= (gspca_dev
->usb_buf
[3] << 8) | gspca_dev
->usb_buf
[4];
1714 reg_w1(gspca_dev
, 0x01, 0x29);
1715 reg_w1(gspca_dev
, 0x17, 0x42);
1716 if (gspca_dev
->usb_err
< 0)
1718 if (val
== 0x1030) { /* po1030 */
1719 PDEBUG(D_PROBE
, "Sensor po1030");
1720 sd
->sensor
= SENSOR_PO1030
;
1723 err("Unknown sensor %04x", val
);
1726 /* 0c45:6142 sensor may be po2030n, gc0305 or gc0307 */
1727 static void po2030n_probe(struct gspca_dev
*gspca_dev
)
1729 struct sd
*sd
= (struct sd
*) gspca_dev
;
1733 reg_w1(gspca_dev
, 0x17, 0x62);
1734 reg_w1(gspca_dev
, 0x01, 0x08);
1735 reg_w1(gspca_dev
, 0x02, 0x22);
1736 sd
->i2c_addr
= 0x21;
1737 i2c_r(gspca_dev
, 0x00, 1);
1738 val
= gspca_dev
->usb_buf
[4];
1739 reg_w1(gspca_dev
, 0x01, 0x29); /* reset */
1740 reg_w1(gspca_dev
, 0x17, 0x42);
1741 if (val
== 0x99) { /* gc0307 (?) */
1742 PDEBUG(D_PROBE
, "Sensor gc0307");
1743 sd
->sensor
= SENSOR_GC0307
;
1748 reg_w1(gspca_dev
, 0x17, 0x62);
1749 reg_w1(gspca_dev
, 0x01, 0x0a);
1750 sd
->i2c_addr
= 0x6e;
1751 i2c_r(gspca_dev
, 0x00, 2);
1752 val
= (gspca_dev
->usb_buf
[3] << 8) | gspca_dev
->usb_buf
[4];
1753 reg_w1(gspca_dev
, 0x01, 0x29);
1754 reg_w1(gspca_dev
, 0x17, 0x42);
1755 if (gspca_dev
->usb_err
< 0)
1757 if (val
== 0x2030) {
1758 PDEBUG(D_PROBE
, "Sensor po2030n");
1759 /* sd->sensor = SENSOR_PO2030N; */
1761 err("Unknown sensor ID %04x", val
);
1765 /* this function is called at probe time */
1766 static int sd_config(struct gspca_dev
*gspca_dev
,
1767 const struct usb_device_id
*id
)
1769 struct sd
*sd
= (struct sd
*) gspca_dev
;
1772 sd
->bridge
= id
->driver_info
>> 16;
1773 sd
->sensor
= id
->driver_info
>> 8;
1774 sd
->flags
= id
->driver_info
;
1776 cam
= &gspca_dev
->cam
;
1777 if (sd
->sensor
== SENSOR_ADCM1700
) {
1778 cam
->cam_mode
= cif_mode
;
1779 cam
->nmodes
= ARRAY_SIZE(cif_mode
);
1781 cam
->cam_mode
= vga_mode
;
1782 cam
->nmodes
= ARRAY_SIZE(vga_mode
);
1784 cam
->npkt
= 24; /* 24 packets per ISOC message */
1785 cam
->ctrls
= sd
->ctrls
;
1788 sd
->quality
= QUALITY_DEF
;
1794 /* this function is called at probe and resume time */
1795 static int sd_init(struct gspca_dev
*gspca_dev
)
1797 struct sd
*sd
= (struct sd
*) gspca_dev
;
1799 u8 regGpio
[] = { 0x29, 0x74 }; /* with audio */
1802 /* setup a selector by bridge */
1803 reg_w1(gspca_dev
, 0xf1, 0x01);
1804 reg_r(gspca_dev
, 0x00, 1);
1805 reg_w1(gspca_dev
, 0xf1, 0x00);
1806 reg_r(gspca_dev
, 0x00, 1); /* get sonix chip id */
1807 regF1
= gspca_dev
->usb_buf
[0];
1808 if (gspca_dev
->usb_err
< 0)
1809 return gspca_dev
->usb_err
;
1810 PDEBUG(D_PROBE
, "Sonix chip id: %02x", regF1
);
1811 switch (sd
->bridge
) {
1812 case BRIDGE_SN9C102P
:
1813 case BRIDGE_SN9C105
:
1818 /* case BRIDGE_SN9C110: */
1819 /* case BRIDGE_SN9C120: */
1824 switch (sd
->sensor
) {
1826 mi0360_probe(gspca_dev
);
1829 ov7630_probe(gspca_dev
);
1832 ov7648_probe(gspca_dev
);
1834 case SENSOR_PO2030N
:
1835 po2030n_probe(gspca_dev
);
1839 switch (sd
->bridge
) {
1840 case BRIDGE_SN9C102P
:
1841 reg_w1(gspca_dev
, 0x02, regGpio
[1]);
1843 case BRIDGE_SN9C105
:
1844 reg_w(gspca_dev
, 0x01, regGpio
, 2);
1846 case BRIDGE_SN9C110
:
1847 reg_w1(gspca_dev
, 0x02, 0x62);
1849 case BRIDGE_SN9C120
:
1850 regGpio
[1] = 0x70; /* no audio */
1851 reg_w(gspca_dev
, 0x01, regGpio
, 2);
1855 if (sd
->sensor
== SENSOR_OM6802
)
1856 sd
->ctrls
[SHARPNESS
].def
= 0x10;
1858 /* Note we do not disable the sensor clock here (power saving mode),
1859 as that also disables the button on the cam. */
1860 reg_w1(gspca_dev
, 0xf1, 0x00);
1862 /* set the i2c address */
1863 sn9c1xx
= sn_tb
[sd
->sensor
];
1864 sd
->i2c_addr
= sn9c1xx
[9];
1866 gspca_dev
->ctrl_dis
= ctrl_dis
[sd
->sensor
];
1867 if (!(sd
->flags
& F_ILLUM
))
1868 gspca_dev
->ctrl_dis
|= (1 << ILLUM
);
1870 return gspca_dev
->usb_err
;
1873 static u32
setexposure(struct gspca_dev
*gspca_dev
,
1876 struct sd
*sd
= (struct sd
*) gspca_dev
;
1878 switch (sd
->sensor
) {
1879 case SENSOR_GC0307
: {
1882 /* expo = 0..255 -> a = 19..43 */
1883 a
= 19 + expo
* 25 / 256;
1884 i2c_w1(gspca_dev
, 0x68, a
);
1886 b
= a
* a
* 4; /* heuristic */
1887 i2c_w1(gspca_dev
, 0x03, b
>> 8);
1888 i2c_w1(gspca_dev
, 0x04, b
);
1891 case SENSOR_HV7131R
: {
1893 { 0xc1, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x16 };
1895 Expodoit
[3] = expo
>> 16;
1896 Expodoit
[4] = expo
>> 8;
1898 i2c_w8(gspca_dev
, Expodoit
);
1902 case SENSOR_MI0360B
: {
1903 u8 expoMi
[] = /* exposure 0x0635 -> 4 fp/s 0x10 */
1904 { 0xb1, 0x5d, 0x09, 0x00, 0x00, 0x00, 0x00, 0x16 };
1905 static const u8 doit
[] = /* update sensor */
1906 { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
1907 static const u8 sensorgo
[] = /* sensor on */
1908 { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
1912 else if (expo
< 0x0001)
1914 expoMi
[3] = expo
>> 8;
1916 i2c_w8(gspca_dev
, expoMi
);
1917 i2c_w8(gspca_dev
, doit
);
1918 i2c_w8(gspca_dev
, sensorgo
);
1921 case SENSOR_MO4000
: {
1923 { 0xa1, 0x21, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x10 };
1925 { 0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10 };
1926 static const u8 gainMo
[] =
1927 { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
1931 else if (expo
< 0x0001)
1933 expoMof
[3] = (expo
& 0x03fc) >> 2;
1934 i2c_w8(gspca_dev
, expoMof
);
1935 expoMo10
[3] = ((expo
& 0x1c00) >> 10)
1936 | ((expo
& 0x0003) << 4);
1937 i2c_w8(gspca_dev
, expoMo10
);
1938 i2c_w8(gspca_dev
, gainMo
);
1939 PDEBUG(D_FRAM
, "set exposure %d",
1940 ((expoMo10
[3] & 0x07) << 10)
1942 | ((expoMo10
[3] & 0x30) >> 4));
1945 case SENSOR_MT9V111
: {
1947 { 0xb1, 0x5c, 0x09, 0x00, 0x00, 0x00, 0x00, 0x10 };
1951 else if (expo
< 0x0040)
1953 expo_c1
[3] = expo
>> 8;
1955 i2c_w8(gspca_dev
, expo_c1
);
1958 case SENSOR_OM6802
: {
1960 { 0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10 };
1961 /* preset AGC - works when AutoExpo = off */
1967 gainOm
[3] = expo
>> 2;
1968 i2c_w8(gspca_dev
, gainOm
);
1969 reg_w1(gspca_dev
, 0x96, expo
>> 5);
1970 PDEBUG(D_FRAM
, "set exposure %d", gainOm
[3]);
1977 static void setbrightness(struct gspca_dev
*gspca_dev
)
1979 struct sd
*sd
= (struct sd
*) gspca_dev
;
1984 brightness
= sd
->ctrls
[BRIGHTNESS
].val
;
1985 k2
= (brightness
- 0x80) >> 2;
1986 switch (sd
->sensor
) {
1987 case SENSOR_ADCM1700
:
1989 k2
= 0; /* only positive Y offset */
1991 case SENSOR_HV7131R
:
1992 expo
= brightness
<< 12;
1993 if (expo
> 0x002dc6c0)
1995 else if (expo
< 0x02a0)
1997 sd
->exposure
= setexposure(gspca_dev
, expo
);
2001 expo
= brightness
<< 4;
2002 sd
->exposure
= setexposure(gspca_dev
, expo
);
2004 case SENSOR_MI0360B
:
2005 expo
= brightness
<< 2;
2006 sd
->exposure
= setexposure(gspca_dev
, expo
);
2009 case SENSOR_MT9V111
:
2011 sd
->exposure
= setexposure(gspca_dev
, expo
);
2012 return; /* don't set the Y offset */
2014 expo
= brightness
<< 2;
2015 sd
->exposure
= setexposure(gspca_dev
, expo
);
2016 k2
= brightness
>> 3;
2020 reg_w1(gspca_dev
, 0x96, k2
); /* color matrix Y offset */
2023 static void setcontrast(struct gspca_dev
*gspca_dev
)
2025 struct sd
*sd
= (struct sd
*) gspca_dev
;
2029 k2
= sd
->ctrls
[CONTRAST
].val
* 0x30 / (CONTRAST_MAX
+ 1)
2030 + 0x10; /* 10..40 */
2031 contrast
[0] = (k2
+ 1) / 2; /* red */
2033 contrast
[2] = k2
; /* green */
2035 contrast
[4] = (k2
+ 1) / 5; /* blue */
2037 reg_w(gspca_dev
, 0x84, contrast
, sizeof contrast
);
2040 static void setcolors(struct gspca_dev
*gspca_dev
)
2042 struct sd
*sd
= (struct sd
*) gspca_dev
;
2045 u8 reg8a
[12]; /* U & V gains */
2046 static const s16 uv_com
[6] = { /* same as reg84 in signed decimal */
2047 -24, -38, 64, /* UR UG UB */
2048 62, -51, -9 /* VR VG VB */
2050 static const s16 uv_mi0360b
[6] = {
2051 -20, -38, 64, /* UR UG UB */
2052 60, -51, -9 /* VR VG VB */
2055 colors
= sd
->ctrls
[COLORS
].val
;
2056 if (sd
->sensor
== SENSOR_MI0360B
)
2060 for (i
= 0; i
< 6; i
++) {
2061 v
= uv
[i
] * colors
/ COLORS_DEF
;
2063 reg8a
[i
* 2 + 1] = (v
>> 8) & 0x0f;
2065 reg_w(gspca_dev
, 0x8a, reg8a
, sizeof reg8a
);
2068 static void setredblue(struct gspca_dev
*gspca_dev
)
2070 struct sd
*sd
= (struct sd
*) gspca_dev
;
2072 reg_w1(gspca_dev
, 0x05, sd
->ctrls
[RED
].val
);
2073 /* reg_w1(gspca_dev, 0x07, 32); */
2074 reg_w1(gspca_dev
, 0x06, sd
->ctrls
[BLUE
].val
);
2077 static void setgamma(struct gspca_dev
*gspca_dev
)
2079 struct sd
*sd
= (struct sd
*) gspca_dev
;
2082 const u8
*gamma_base
;
2083 static const u8 delta
[17] = {
2084 0x00, 0x14, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1a,
2085 0x18, 0x13, 0x10, 0x0e, 0x08, 0x07, 0x04, 0x02, 0x00
2088 switch (sd
->sensor
) {
2089 case SENSOR_ADCM1700
:
2090 gamma_base
= gamma_spec_0
;
2092 case SENSOR_HV7131R
:
2093 case SENSOR_MI0360B
:
2094 case SENSOR_MT9V111
:
2095 gamma_base
= gamma_spec_1
;
2098 gamma_base
= gamma_spec_2
;
2100 case SENSOR_SP80708
:
2101 gamma_base
= gamma_spec_3
;
2104 gamma_base
= gamma_def
;
2108 val
= sd
->ctrls
[GAMMA
].val
;
2109 for (i
= 0; i
< sizeof gamma
; i
++)
2110 gamma
[i
] = gamma_base
[i
]
2111 + delta
[i
] * (val
- GAMMA_DEF
) / 32;
2112 reg_w(gspca_dev
, 0x20, gamma
, sizeof gamma
);
2115 static void setautogain(struct gspca_dev
*gspca_dev
)
2117 struct sd
*sd
= (struct sd
*) gspca_dev
;
2119 if (gspca_dev
->ctrl_dis
& (1 << AUTOGAIN
))
2121 switch (sd
->sensor
) {
2123 case SENSOR_OV7648
: {
2126 if (sd
->sensor
== SENSOR_OV7630
)
2130 if (sd
->ctrls
[AUTOGAIN
].val
)
2132 i2c_w1(&sd
->gspca_dev
, 0x13, comb
);
2136 if (sd
->ctrls
[AUTOGAIN
].val
)
2137 sd
->ag_cnt
= AG_CNT_START
;
2142 static void sethvflip(struct gspca_dev
*gspca_dev
)
2144 struct sd
*sd
= (struct sd
*) gspca_dev
;
2147 switch (sd
->sensor
) {
2148 case SENSOR_HV7131R
:
2149 comn
= 0x18; /* clkdiv = 1, ablcen = 1 */
2150 if (sd
->ctrls
[VFLIP
].val
)
2152 i2c_w1(gspca_dev
, 0x01, comn
); /* sctra */
2156 if (!sd
->ctrls
[VFLIP
].val
)
2158 i2c_w1(gspca_dev
, 0x75, comn
);
2162 if (sd
->ctrls
[VFLIP
].val
)
2164 i2c_w1(gspca_dev
, 0x75, comn
);
2166 case SENSOR_PO2030N
:
2167 /* Reg. 0x1E: Timing Generator Control Register 2 (Tgcontrol2)
2168 * (reset value: 0x0A)
2169 * bit7: HM: Horizontal Mirror: 0: disable, 1: enable
2170 * bit6: VM: Vertical Mirror: 0: disable, 1: enable
2171 * bit5: ST: Shutter Selection: 0: electrical, 1: mechanical
2172 * bit4: FT: Single Frame Transfer: 0: disable, 1: enable
2176 if (sd
->ctrls
[HFLIP
].val
)
2178 if (sd
->ctrls
[VFLIP
].val
)
2180 i2c_w1(&sd
->gspca_dev
, 0x1e, comn
);
2185 static void setsharpness(struct gspca_dev
*gspca_dev
)
2187 struct sd
*sd
= (struct sd
*) gspca_dev
;
2189 reg_w1(gspca_dev
, 0x99, sd
->ctrls
[SHARPNESS
].val
);
2192 static void setillum(struct gspca_dev
*gspca_dev
)
2194 struct sd
*sd
= (struct sd
*) gspca_dev
;
2196 if (gspca_dev
->ctrl_dis
& (1 << ILLUM
))
2198 switch (sd
->sensor
) {
2199 case SENSOR_ADCM1700
:
2200 reg_w1(gspca_dev
, 0x02, /* gpio */
2201 sd
->ctrls
[ILLUM
].val
? 0x64 : 0x60);
2203 case SENSOR_MT9V111
:
2205 reg_w1(gspca_dev
, 0x02,
2206 sd
->ctrls
[ILLUM
].val
?
2207 0x55 : 0x54); /* 370i */
2209 reg_w1(gspca_dev
, 0x02,
2210 sd
->ctrls
[ILLUM
].val
?
2211 0x66 : 0x64); /* Clip */
2216 static void setfreq(struct gspca_dev
*gspca_dev
)
2218 struct sd
*sd
= (struct sd
*) gspca_dev
;
2220 if (gspca_dev
->ctrl_dis
& (1 << FREQ
))
2222 if (sd
->sensor
== SENSOR_OV7660
) {
2225 com8
= 0xdf; /* auto gain/wb/expo */
2226 switch (sd
->ctrls
[FREQ
].val
) {
2227 case 0: /* Banding filter disabled */
2228 i2c_w1(gspca_dev
, 0x13, com8
| 0x20);
2231 i2c_w1(gspca_dev
, 0x13, com8
);
2232 i2c_w1(gspca_dev
, 0x3b, 0x0a);
2235 i2c_w1(gspca_dev
, 0x13, com8
);
2236 i2c_w1(gspca_dev
, 0x3b, 0x02);
2240 u8 reg2a
= 0, reg2b
= 0, reg2d
= 0;
2242 /* Get reg2a / reg2d base values */
2243 switch (sd
->sensor
) {
2254 switch (sd
->ctrls
[FREQ
].val
) {
2255 case 0: /* Banding filter disabled */
2257 case 1: /* 50 hz (filter on and framerate adj) */
2262 case 2: /* 60 hz (filter on, no framerate adj) */
2267 i2c_w1(gspca_dev
, 0x2a, reg2a
);
2268 i2c_w1(gspca_dev
, 0x2b, reg2b
);
2269 i2c_w1(gspca_dev
, 0x2d, reg2d
);
2273 static void setjpegqual(struct gspca_dev
*gspca_dev
)
2275 struct sd
*sd
= (struct sd
*) gspca_dev
;
2278 if (sd
->jpegqual
< 50)
2279 sc
= 5000 / sd
->jpegqual
;
2281 sc
= 200 - sd
->jpegqual
* 2;
2283 #error "No room enough in usb_buf for quantization table"
2285 for (i
= 0; i
< 64; i
++)
2286 gspca_dev
->usb_buf
[i
] =
2287 (jpeg_head
[JPEG_QT0_OFFSET
+ i
] * sc
+ 50) / 100;
2288 usb_control_msg(gspca_dev
->dev
,
2289 usb_sndctrlpipe(gspca_dev
->dev
, 0),
2291 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
2293 gspca_dev
->usb_buf
, 64,
2295 for (i
= 0; i
< 64; i
++)
2296 gspca_dev
->usb_buf
[i
] =
2297 (jpeg_head
[JPEG_QT1_OFFSET
+ i
] * sc
+ 50) / 100;
2298 usb_control_msg(gspca_dev
->dev
,
2299 usb_sndctrlpipe(gspca_dev
->dev
, 0),
2301 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
2303 gspca_dev
->usb_buf
, 64,
2307 reg_w1(gspca_dev
, 0x18, sd
->reg18
);
2310 /* -- start the camera -- */
2311 static int sd_start(struct gspca_dev
*gspca_dev
)
2313 struct sd
*sd
= (struct sd
*) gspca_dev
;
2318 const u8 (*init
)[8];
2321 static const u8 reg9a_def
[] =
2322 {0x00, 0x40, 0x20, 0x00, 0x00, 0x00};
2323 static const u8 reg9a_spec
[] =
2324 {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
2325 static const u8 regd4
[] = {0x60, 0x00, 0x00};
2326 static const u8 C0
[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
2327 static const u8 CA
[] = { 0x28, 0xd8, 0x14, 0xec };
2328 static const u8 CA_adcm1700
[] =
2329 { 0x14, 0xec, 0x0a, 0xf6 };
2330 static const u8 CA_po2030n
[] =
2331 { 0x1e, 0xe2, 0x14, 0xec };
2332 static const u8 CE
[] = { 0x32, 0xdd, 0x2d, 0xdd }; /* MI0360 */
2333 static const u8 CE_gc0307
[] =
2334 { 0x32, 0xce, 0x2d, 0xd3 };
2335 static const u8 CE_ov76xx
[] =
2336 { 0x32, 0xdd, 0x32, 0xdd };
2337 static const u8 CE_po2030n
[] =
2338 { 0x14, 0xe7, 0x1e, 0xdd };
2340 /* create the JPEG header */
2341 jpeg_define(sd
->jpeg_hdr
, gspca_dev
->height
, gspca_dev
->width
,
2342 0x21); /* JPEG 422 */
2343 jpeg_set_qual(sd
->jpeg_hdr
, sd
->quality
);
2345 /* initialize the bridge */
2346 sn9c1xx
= sn_tb
[sd
->sensor
];
2348 /* sensor clock already enabled in sd_init */
2349 /* reg_w1(gspca_dev, 0xf1, 0x00); */
2351 if (sd
->flags
& F_PDN_INV
)
2352 reg01
^= S_PDN_INV
; /* power down inverted */
2353 reg_w1(gspca_dev
, 0x01, reg01
);
2355 /* configure gpio */
2357 reg0102
[1] = sn9c1xx
[2];
2358 if (gspca_dev
->audio
)
2359 reg0102
[1] |= 0x04; /* keep the audio connection */
2360 reg_w(gspca_dev
, 0x01, reg0102
, 2);
2361 reg_w(gspca_dev
, 0x08, &sn9c1xx
[8], 2);
2362 reg_w(gspca_dev
, 0x17, &sn9c1xx
[0x17], 5);
2363 switch (sd
->sensor
) {
2367 case SENSOR_PO2030N
:
2369 case SENSOR_SP80708
:
2376 reg_w(gspca_dev
, 0x9a, reg9a
, 6);
2378 reg_w(gspca_dev
, 0xd4, regd4
, sizeof regd4
);
2380 reg_w(gspca_dev
, 0x03, &sn9c1xx
[3], 0x0f);
2382 reg17
= sn9c1xx
[0x17];
2383 switch (sd
->sensor
) {
2385 msleep(50); /*fixme: is it useful? */
2389 reg_w1(gspca_dev
, 0x02, 0x73);
2390 reg17
|= SEN_CLK_EN
;
2391 reg_w1(gspca_dev
, 0x17, reg17
);
2392 reg_w1(gspca_dev
, 0x01, 0x22);
2394 reg01
= SCL_SEL_OD
| S_PDN_INV
;
2395 reg17
&= MCK_SIZE_MASK
;
2396 reg17
|= 0x04; /* clock / 4 */
2399 reg01
|= SYS_SEL_48M
;
2400 reg_w1(gspca_dev
, 0x01, reg01
);
2401 reg17
|= SEN_CLK_EN
;
2402 reg_w1(gspca_dev
, 0x17, reg17
);
2403 reg01
&= ~S_PWR_DN
; /* sensor power on */
2404 reg_w1(gspca_dev
, 0x01, reg01
);
2405 reg01
&= ~SYS_SEL_48M
;
2406 reg_w1(gspca_dev
, 0x01, reg01
);
2408 switch (sd
->sensor
) {
2409 case SENSOR_HV7131R
:
2410 hv7131r_probe(gspca_dev
); /*fixme: is it useful? */
2414 reg_w1(gspca_dev
, 0x01, reg01
);
2415 i2c_w8(gspca_dev
, om6802_init0
[0]);
2416 i2c_w8(gspca_dev
, om6802_init0
[1]);
2418 reg_w1(gspca_dev
, 0x02, 0x71);
2421 case SENSOR_SP80708
:
2423 reg_w1(gspca_dev
, 0x02, 0x62);
2427 /* initialize the sensor */
2428 i2c_w_seq(gspca_dev
, sensor_init
[sd
->sensor
]);
2430 reg_w1(gspca_dev
, 0x15, sn9c1xx
[0x15]);
2431 reg_w1(gspca_dev
, 0x16, sn9c1xx
[0x16]);
2432 reg_w1(gspca_dev
, 0x12, sn9c1xx
[0x12]);
2433 reg_w1(gspca_dev
, 0x13, sn9c1xx
[0x13]);
2434 reg_w1(gspca_dev
, 0x18, sn9c1xx
[0x18]);
2435 if (sd
->sensor
== SENSOR_ADCM1700
) {
2436 reg_w1(gspca_dev
, 0xd2, 0x3a); /* AE_H_SIZE = 116 */
2437 reg_w1(gspca_dev
, 0xd3, 0x30); /* AE_V_SIZE = 96 */
2439 reg_w1(gspca_dev
, 0xd2, 0x6a); /* AE_H_SIZE = 212 */
2440 reg_w1(gspca_dev
, 0xd3, 0x50); /* AE_V_SIZE = 160 */
2442 reg_w1(gspca_dev
, 0xc6, 0x00);
2443 reg_w1(gspca_dev
, 0xc7, 0x00);
2444 if (sd
->sensor
== SENSOR_ADCM1700
) {
2445 reg_w1(gspca_dev
, 0xc8, 0x2c); /* AW_H_STOP = 352 */
2446 reg_w1(gspca_dev
, 0xc9, 0x24); /* AW_V_STOP = 288 */
2448 reg_w1(gspca_dev
, 0xc8, 0x50); /* AW_H_STOP = 640 */
2449 reg_w1(gspca_dev
, 0xc9, 0x3c); /* AW_V_STOP = 480 */
2451 reg_w1(gspca_dev
, 0x18, sn9c1xx
[0x18]);
2452 switch (sd
->sensor
) {
2454 /* case SENSOR_OV7648: * fixme: sometimes */
2460 reg_w1(gspca_dev
, 0x17, reg17
);
2462 reg_w1(gspca_dev
, 0x05, 0x00); /* red */
2463 reg_w1(gspca_dev
, 0x07, 0x00); /* green */
2464 reg_w1(gspca_dev
, 0x06, 0x00); /* blue */
2465 reg_w1(gspca_dev
, 0x14, sn9c1xx
[0x14]);
2467 setgamma(gspca_dev
);
2469 /*fixme: 8 times with all zeroes and 1 or 2 times with normal values */
2470 for (i
= 0; i
< 8; i
++)
2471 reg_w(gspca_dev
, 0x84, reg84
, sizeof reg84
);
2472 switch (sd
->sensor
) {
2473 case SENSOR_ADCM1700
:
2475 case SENSOR_SP80708
:
2476 reg_w1(gspca_dev
, 0x9a, 0x05);
2479 case SENSOR_MT9V111
:
2480 case SENSOR_MI0360B
:
2481 reg_w1(gspca_dev
, 0x9a, 0x07);
2485 reg_w1(gspca_dev
, 0x9a, 0x0a);
2487 case SENSOR_PO2030N
:
2489 reg_w1(gspca_dev
, 0x9a, 0x06);
2492 reg_w1(gspca_dev
, 0x9a, 0x08);
2495 setsharpness(gspca_dev
);
2497 reg_w(gspca_dev
, 0x84, reg84
, sizeof reg84
);
2498 reg_w1(gspca_dev
, 0x05, 0x20); /* red */
2499 reg_w1(gspca_dev
, 0x07, 0x20); /* green */
2500 reg_w1(gspca_dev
, 0x06, 0x20); /* blue */
2503 mode
= gspca_dev
->cam
.cam_mode
[gspca_dev
->curr_mode
].priv
;
2504 reg01
|= SYS_SEL_48M
| V_TX_EN
;
2505 reg17
&= ~MCK_SIZE_MASK
;
2506 reg17
|= 0x02; /* clock / 2 */
2507 switch (sd
->sensor
) {
2508 case SENSOR_ADCM1700
:
2509 init
= adcm1700_sensor_param1
;
2512 init
= gc0307_sensor_param1
;
2514 case SENSOR_HV7131R
:
2517 reg01
|= SYS_SEL_48M
; /* 320x240: clk 48Mhz */
2519 reg01
&= ~SYS_SEL_48M
; /* 640x480: clk 24Mhz */
2520 reg17
&= ~MCK_SIZE_MASK
;
2521 reg17
|= 0x01; /* clock / 1 */
2523 case SENSOR_MI0360B
:
2524 init
= mi0360b_sensor_param1
;
2527 if (mode
) { /* if 320x240 */
2528 reg01
&= ~SYS_SEL_48M
; /* clk 24Mz */
2529 reg17
&= ~MCK_SIZE_MASK
;
2530 reg17
|= 0x01; /* clock / 1 */
2533 case SENSOR_MT9V111
:
2534 init
= mt9v111_sensor_param1
;
2537 init
= om6802_sensor_param1
;
2538 if (!mode
) { /* if 640x480 */
2539 reg17
&= ~MCK_SIZE_MASK
;
2540 reg17
|= 0x04; /* clock / 4 */
2544 init
= ov7630_sensor_param1
;
2547 init
= ov7648_sensor_param1
;
2548 reg17
&= ~MCK_SIZE_MASK
;
2549 reg17
|= 0x01; /* clock / 1 */
2552 init
= ov7660_sensor_param1
;
2555 init
= po1030_sensor_param1
;
2557 case SENSOR_PO2030N
:
2558 init
= po2030n_sensor_param1
;
2561 init
= soi768_sensor_param1
;
2563 case SENSOR_SP80708
:
2564 init
= sp80708_sensor_param1
;
2568 /* more sensor initialization - param1 */
2570 i2c_w_seq(gspca_dev
, init
);
2574 reg_w(gspca_dev
, 0xc0, C0
, 6);
2575 switch (sd
->sensor
) {
2576 case SENSOR_ADCM1700
:
2579 reg_w(gspca_dev
, 0xca, CA_adcm1700
, 4);
2581 case SENSOR_PO2030N
:
2582 reg_w(gspca_dev
, 0xca, CA_po2030n
, 4);
2585 reg_w(gspca_dev
, 0xca, CA
, 4);
2588 switch (sd
->sensor
) {
2589 case SENSOR_ADCM1700
:
2594 reg_w(gspca_dev
, 0xce, CE_ov76xx
, 4);
2597 reg_w(gspca_dev
, 0xce, CE_gc0307
, 4);
2599 case SENSOR_PO2030N
:
2600 reg_w(gspca_dev
, 0xce, CE_po2030n
, 4);
2603 reg_w(gspca_dev
, 0xce, CE
, 4);
2604 /* ?? {0x1e, 0xdd, 0x2d, 0xe7} */
2608 /* here change size mode 0 -> VGA; 1 -> CIF */
2609 sd
->reg18
= sn9c1xx
[0x18] | (mode
<< 4) | 0x40;
2610 reg_w1(gspca_dev
, 0x18, sd
->reg18
);
2611 setjpegqual(gspca_dev
);
2613 reg_w1(gspca_dev
, 0x17, reg17
);
2614 reg_w1(gspca_dev
, 0x01, reg01
);
2618 sethvflip(gspca_dev
);
2619 setbrightness(gspca_dev
);
2620 setcontrast(gspca_dev
);
2621 setcolors(gspca_dev
);
2622 setautogain(gspca_dev
);
2624 return gspca_dev
->usb_err
;
2627 static void sd_stopN(struct gspca_dev
*gspca_dev
)
2629 struct sd
*sd
= (struct sd
*) gspca_dev
;
2630 static const u8 stophv7131
[] =
2631 { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
2632 static const u8 stopmi0360
[] =
2633 { 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
2634 static const u8 stopov7648
[] =
2635 { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 };
2636 static const u8 stopsoi768
[] =
2637 { 0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10 };
2642 reg17
= sd
->reg17
& ~SEN_CLK_EN
;
2643 switch (sd
->sensor
) {
2644 case SENSOR_ADCM1700
:
2646 case SENSOR_PO2030N
:
2647 case SENSOR_SP80708
:
2649 reg_w1(gspca_dev
, 0x01, reg01
);
2650 reg01
&= ~(LED
| V_TX_EN
);
2651 reg_w1(gspca_dev
, 0x01, reg01
);
2652 /* reg_w1(gspca_dev, 0x02, 0x??); * LED off ? */
2654 case SENSOR_HV7131R
:
2656 reg_w1(gspca_dev
, 0x01, reg01
);
2657 i2c_w8(gspca_dev
, stophv7131
);
2660 case SENSOR_MI0360B
:
2662 reg_w1(gspca_dev
, 0x01, reg01
);
2663 /* reg_w1(gspca_dev, 0x02, 0x40); * LED off ? */
2664 i2c_w8(gspca_dev
, stopmi0360
);
2666 case SENSOR_MT9V111
:
2670 reg_w1(gspca_dev
, 0x01, reg01
);
2675 reg_w1(gspca_dev
, 0x01, reg01
);
2676 i2c_w8(gspca_dev
, stopov7648
);
2680 reg_w1(gspca_dev
, 0x01, reg01
);
2683 i2c_w8(gspca_dev
, stopsoi768
);
2687 reg01
|= SCL_SEL_OD
;
2688 reg_w1(gspca_dev
, 0x01, reg01
);
2689 reg01
|= S_PWR_DN
; /* sensor power down */
2690 reg_w1(gspca_dev
, 0x01, reg01
);
2691 reg_w1(gspca_dev
, 0x17, reg17
);
2692 reg01
&= ~SYS_SEL_48M
; /* clock 24MHz */
2693 reg_w1(gspca_dev
, 0x01, reg01
);
2695 reg_w1(gspca_dev
, 0x01, reg01
);
2696 /* Don't disable sensor clock as that disables the button on the cam */
2697 /* reg_w1(gspca_dev, 0xf1, 0x01); */
2700 static void do_autogain(struct gspca_dev
*gspca_dev
)
2702 struct sd
*sd
= (struct sd
*) gspca_dev
;
2708 /* Thanks S., without your advice, autobright should not work :) */
2711 if (--sd
->ag_cnt
>= 0)
2713 sd
->ag_cnt
= AG_CNT_START
;
2715 delta
= atomic_read(&sd
->avg_lum
);
2716 PDEBUG(D_FRAM
, "mean lum %d", delta
);
2717 if (delta
< luma_mean
- luma_delta
||
2718 delta
> luma_mean
+ luma_delta
) {
2719 switch (sd
->sensor
) {
2721 expotimes
= sd
->exposure
;
2722 expotimes
+= (luma_mean
- delta
) >> 6;
2725 sd
->exposure
= setexposure(gspca_dev
,
2726 (unsigned int) expotimes
);
2728 case SENSOR_HV7131R
:
2729 expotimes
= sd
->exposure
>> 8;
2730 expotimes
+= (luma_mean
- delta
) >> 4;
2733 sd
->exposure
= setexposure(gspca_dev
,
2734 (unsigned int) (expotimes
<< 8));
2737 expotimes
= sd
->exposure
;
2738 expotimes
+= (luma_mean
- delta
) >> 2;
2741 sd
->exposure
= setexposure(gspca_dev
,
2742 (unsigned int) expotimes
);
2743 setredblue(gspca_dev
);
2746 /* case SENSOR_MO4000: */
2747 /* case SENSOR_MI0360: */
2748 /* case SENSOR_MI0360B: */
2749 /* case SENSOR_MT9V111: */
2750 expotimes
= sd
->exposure
;
2751 expotimes
+= (luma_mean
- delta
) >> 6;
2754 sd
->exposure
= setexposure(gspca_dev
,
2755 (unsigned int) expotimes
);
2756 setredblue(gspca_dev
);
2762 /* set the average luminosity from an isoc marker */
2763 static void set_lum(struct sd
*sd
,
2772 avg_lum
= (data
[27] << 8) + data
[28] /* w3 */
2774 + (data
[31] << 8) + data
[32] /* w5 */
2776 + (data
[23] << 8) + data
[24] /* w1 */
2778 + (data
[35] << 8) + data
[36] /* w7 */
2780 + (data
[29] << 10) + (data
[30] << 2); /* w4 * 4 */
2782 atomic_set(&sd
->avg_lum
, avg_lum
);
2785 /* scan the URB packets */
2786 /* This function is run at interrupt level. */
2787 static void sd_pkt_scan(struct gspca_dev
*gspca_dev
,
2788 u8
*data
, /* isoc packet */
2789 int len
) /* iso packet length */
2791 struct sd
*sd
= (struct sd
*) gspca_dev
;
2795 * A frame ends on the marker
2796 * ff ff 00 c4 c4 96 ..
2797 * which is 62 bytes long and is followed by various information
2798 * including statuses and luminosity.
2800 * A marker may be splitted on two packets.
2802 * The 6th byte of a marker contains the bits:
2804 * 0xc0: frame sequence
2805 * When the bit 'USB full' is set, the frame must be discarded;
2806 * this is also the case when the 2 bytes before the marker are
2807 * not the JPEG end of frame ('ff d9').
2810 /*fixme: assumption about the following code:
2811 * - there can be only one marker in a packet
2814 /* skip the remaining bytes of a short marker */
2818 if (i
< 0 /* if 'ff' at end of previous packet */
2822 if (data
[0] == 0xff && data
[1] == 0xff) {
2832 /* search backwards if there is a marker in the packet */
2833 for (i
= len
- 1; --i
>= 0; ) {
2834 if (data
[i
] != 0xff) {
2838 if (data
[i
+ 1] == 0xff) {
2840 /* (there may be 'ff ff' inside a marker) */
2841 if (i
+ 2 >= len
|| data
[i
+ 2] == 0x00)
2846 /* no marker found */
2847 /* add the JPEG header if first fragment */
2848 if (data
[len
- 1] == 0xff)
2849 sd
->short_mark
= -1;
2850 if (gspca_dev
->last_packet_type
== LAST_PACKET
)
2851 gspca_frame_add(gspca_dev
, FIRST_PACKET
,
2852 sd
->jpeg_hdr
, JPEG_HDR_SZ
);
2853 gspca_frame_add(gspca_dev
, INTER_PACKET
, data
, len
);
2857 /* if some error, discard the frame */
2860 if (data
[i
- 2] != 0xff || data
[i
- 1] != 0xd9) {
2861 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
2863 } else if (i
+ 6 < len
) {
2864 if (data
[i
+ 6] & 0x08) {
2865 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
2869 gspca_frame_add(gspca_dev
, LAST_PACKET
, data
, i
);
2871 /* if the marker is smaller than 62 bytes,
2872 * memorize the number of bytes to skip in the next packet */
2873 if (i
+ 62 > len
) { /* no more usable data */
2874 sd
->short_mark
= i
+ 62 - len
;
2878 if (sd
->ag_cnt
>= 0)
2879 set_lum(sd
, data
+ i
);
2881 /* if more data, start a new frame */
2886 gspca_frame_add(gspca_dev
, FIRST_PACKET
,
2887 sd
->jpeg_hdr
, JPEG_HDR_SZ
);
2888 gspca_frame_add(gspca_dev
, INTER_PACKET
, data
, len
);
2892 static int sd_set_jcomp(struct gspca_dev
*gspca_dev
,
2893 struct v4l2_jpegcompression
*jcomp
)
2895 struct sd
*sd
= (struct sd
*) gspca_dev
;
2897 if (jcomp
->quality
< QUALITY_MIN
)
2898 sd
->quality
= QUALITY_MIN
;
2899 else if (jcomp
->quality
> QUALITY_MAX
)
2900 sd
->quality
= QUALITY_MAX
;
2902 sd
->quality
= jcomp
->quality
;
2903 if (gspca_dev
->streaming
)
2904 jpeg_set_qual(sd
->jpeg_hdr
, sd
->quality
);
2908 static int sd_get_jcomp(struct gspca_dev
*gspca_dev
,
2909 struct v4l2_jpegcompression
*jcomp
)
2911 struct sd
*sd
= (struct sd
*) gspca_dev
;
2913 memset(jcomp
, 0, sizeof *jcomp
);
2914 jcomp
->quality
= sd
->quality
;
2915 jcomp
->jpeg_markers
= V4L2_JPEG_MARKER_DHT
2916 | V4L2_JPEG_MARKER_DQT
;
2920 static int sd_querymenu(struct gspca_dev
*gspca_dev
,
2921 struct v4l2_querymenu
*menu
)
2924 case V4L2_CID_POWER_LINE_FREQUENCY
:
2925 switch (menu
->index
) {
2926 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
2927 strcpy((char *) menu
->name
, "NoFliker");
2929 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
2930 strcpy((char *) menu
->name
, "50 Hz");
2932 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
2933 strcpy((char *) menu
->name
, "60 Hz");
2941 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2942 static int sd_int_pkt_scan(struct gspca_dev
*gspca_dev
,
2943 u8
*data
, /* interrupt packet data */
2944 int len
) /* interrupt packet length */
2948 if (len
== 1 && data
[0] == 1) {
2949 input_report_key(gspca_dev
->input_dev
, KEY_CAMERA
, 1);
2950 input_sync(gspca_dev
->input_dev
);
2951 input_report_key(gspca_dev
->input_dev
, KEY_CAMERA
, 0);
2952 input_sync(gspca_dev
->input_dev
);
2960 /* sub-driver description */
2961 static const struct sd_desc sd_desc
= {
2962 .name
= MODULE_NAME
,
2965 .config
= sd_config
,
2969 .pkt_scan
= sd_pkt_scan
,
2970 .dq_callback
= do_autogain
,
2971 .get_jcomp
= sd_get_jcomp
,
2972 .set_jcomp
= sd_set_jcomp
,
2973 .querymenu
= sd_querymenu
,
2974 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2975 .int_pkt_scan
= sd_int_pkt_scan
,
2979 /* -- module initialisation -- */
2980 #define BS(bridge, sensor) \
2981 .driver_info = (BRIDGE_ ## bridge << 16) \
2982 | (SENSOR_ ## sensor << 8)
2983 #define BSF(bridge, sensor, flags) \
2984 .driver_info = (BRIDGE_ ## bridge << 16) \
2985 | (SENSOR_ ## sensor << 8) \
2987 static const struct usb_device_id device_table
[] = {
2988 {USB_DEVICE(0x0458, 0x7025), BS(SN9C120
, MI0360
)},
2989 {USB_DEVICE(0x0458, 0x702e), BS(SN9C120
, OV7660
)},
2990 {USB_DEVICE(0x045e, 0x00f5), BSF(SN9C105
, OV7660
, F_PDN_INV
)},
2991 {USB_DEVICE(0x045e, 0x00f7), BSF(SN9C105
, OV7660
, F_PDN_INV
)},
2992 {USB_DEVICE(0x0471, 0x0327), BS(SN9C105
, MI0360
)},
2993 {USB_DEVICE(0x0471, 0x0328), BS(SN9C105
, MI0360
)},
2994 {USB_DEVICE(0x0471, 0x0330), BS(SN9C105
, MI0360
)},
2995 {USB_DEVICE(0x06f8, 0x3004), BS(SN9C105
, OV7660
)},
2996 {USB_DEVICE(0x06f8, 0x3008), BS(SN9C105
, OV7660
)},
2997 /* {USB_DEVICE(0x0c45, 0x603a), BS(SN9C102P, OV7648)}, */
2998 {USB_DEVICE(0x0c45, 0x6040), BS(SN9C102P
, HV7131R
)},
2999 /* {USB_DEVICE(0x0c45, 0x607a), BS(SN9C102P, OV7648)}, */
3000 /* {USB_DEVICE(0x0c45, 0x607b), BS(SN9C102P, OV7660)}, */
3001 {USB_DEVICE(0x0c45, 0x607c), BS(SN9C102P
, HV7131R
)},
3002 /* {USB_DEVICE(0x0c45, 0x607e), BS(SN9C102P, OV7630)}, */
3003 {USB_DEVICE(0x0c45, 0x60c0), BSF(SN9C105
, MI0360
, F_ILLUM
)},
3005 /* {USB_DEVICE(0x0c45, 0x60c2), BS(SN9C105, P1030xC)}, */
3006 /* {USB_DEVICE(0x0c45, 0x60c8), BS(SN9C105, OM6802)}, */
3007 /* {USB_DEVICE(0x0c45, 0x60cc), BS(SN9C105, HV7131GP)}, */
3008 {USB_DEVICE(0x0c45, 0x60ce), BS(SN9C105
, SP80708
)},
3009 {USB_DEVICE(0x0c45, 0x60ec), BS(SN9C105
, MO4000
)},
3010 /* {USB_DEVICE(0x0c45, 0x60ef), BS(SN9C105, ICM105C)}, */
3011 /* {USB_DEVICE(0x0c45, 0x60fa), BS(SN9C105, OV7648)}, */
3012 /* {USB_DEVICE(0x0c45, 0x60f2), BS(SN9C105, OV7660)}, */
3013 {USB_DEVICE(0x0c45, 0x60fb), BS(SN9C105
, OV7660
)},
3014 {USB_DEVICE(0x0c45, 0x60fc), BS(SN9C105
, HV7131R
)},
3015 {USB_DEVICE(0x0c45, 0x60fe), BS(SN9C105
, OV7630
)},
3016 {USB_DEVICE(0x0c45, 0x6100), BS(SN9C120
, MI0360
)}, /*sn9c128*/
3017 {USB_DEVICE(0x0c45, 0x6102), BS(SN9C120
, PO2030N
)}, /* /GC0305*/
3018 /* {USB_DEVICE(0x0c45, 0x6108), BS(SN9C120, OM6802)}, */
3019 {USB_DEVICE(0x0c45, 0x610a), BS(SN9C120
, OV7648
)}, /*sn9c128*/
3020 {USB_DEVICE(0x0c45, 0x610b), BS(SN9C120
, OV7660
)}, /*sn9c128*/
3021 {USB_DEVICE(0x0c45, 0x610c), BS(SN9C120
, HV7131R
)}, /*sn9c128*/
3022 {USB_DEVICE(0x0c45, 0x610e), BS(SN9C120
, OV7630
)}, /*sn9c128*/
3023 /* {USB_DEVICE(0x0c45, 0x610f), BS(SN9C120, S5K53BEB)}, */
3024 /* {USB_DEVICE(0x0c45, 0x6122), BS(SN9C110, ICM105C)}, */
3025 /* {USB_DEVICE(0x0c45, 0x6123), BS(SN9C110, SanyoCCD)}, */
3026 {USB_DEVICE(0x0c45, 0x6128), BS(SN9C120
, OM6802
)}, /*sn9c325?*/
3028 {USB_DEVICE(0x0c45, 0x612a), BS(SN9C120
, OV7648
)}, /*sn9c325?*/
3029 {USB_DEVICE(0x0c45, 0x612b), BS(SN9C110
, ADCM1700
)},
3030 {USB_DEVICE(0x0c45, 0x612c), BS(SN9C110
, MO4000
)},
3031 {USB_DEVICE(0x0c45, 0x612e), BS(SN9C110
, OV7630
)},
3032 /* {USB_DEVICE(0x0c45, 0x612f), BS(SN9C110, ICM105C)}, */
3033 {USB_DEVICE(0x0c45, 0x6130), BS(SN9C120
, MI0360
)},
3034 /* or MT9V111 / MI0360B */
3035 /* {USB_DEVICE(0x0c45, 0x6132), BS(SN9C120, OV7670)}, */
3036 {USB_DEVICE(0x0c45, 0x6138), BS(SN9C120
, MO4000
)},
3037 {USB_DEVICE(0x0c45, 0x613a), BS(SN9C120
, OV7648
)},
3038 {USB_DEVICE(0x0c45, 0x613b), BS(SN9C120
, OV7660
)},
3039 {USB_DEVICE(0x0c45, 0x613c), BS(SN9C120
, HV7131R
)},
3040 {USB_DEVICE(0x0c45, 0x613e), BS(SN9C120
, OV7630
)},
3041 {USB_DEVICE(0x0c45, 0x6142), BS(SN9C120
, PO2030N
)}, /*sn9c120b*/
3042 /* or GC0305 / GC0307 */
3043 {USB_DEVICE(0x0c45, 0x6143), BS(SN9C120
, SP80708
)}, /*sn9c120b*/
3044 {USB_DEVICE(0x0c45, 0x6148), BS(SN9C120
, OM6802
)}, /*sn9c120b*/
3045 {USB_DEVICE(0x0c45, 0x614a), BSF(SN9C120
, ADCM1700
, F_ILLUM
)},
3046 /* {USB_DEVICE(0x0c45, 0x614c), BS(SN9C120, GC0306)}, */ /*sn9c120b*/
3049 MODULE_DEVICE_TABLE(usb
, device_table
);
3051 /* -- device connect -- */
3052 static int sd_probe(struct usb_interface
*intf
,
3053 const struct usb_device_id
*id
)
3055 return gspca_dev_probe(intf
, id
, &sd_desc
, sizeof(struct sd
),
3059 static struct usb_driver sd_driver
= {
3060 .name
= MODULE_NAME
,
3061 .id_table
= device_table
,
3063 .disconnect
= gspca_disconnect
,
3065 .suspend
= gspca_suspend
,
3066 .resume
= gspca_resume
,
3070 /* -- module insert / remove -- */
3071 static int __init
sd_mod_init(void)
3073 return usb_register(&sd_driver
);
3075 static void __exit
sd_mod_exit(void)
3077 usb_deregister(&sd_driver
);
3080 module_init(sd_mod_init
);
3081 module_exit(sd_mod_exit
);
3083 module_param(starcam
, int, 0644);
3084 MODULE_PARM_DESC(starcam
,
3085 "StarCam model. 0: Clip, 1: 370i");