Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[linux-2.6.git] / drivers / media / video / gspca / sn9c20x.c
1 /*
2  *      Sonix sn9c201 sn9c202 library
3  *      Copyright (C) 2008-2009 microdia project <microdia@googlegroups.com>
4  *      Copyright (C) 2009 Brian Johnson <brijohn@gmail.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  */
20
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23 #include <linux/input.h>
24
25 #include "gspca.h"
26 #include "jpeg.h"
27
28 #include <media/v4l2-chip-ident.h>
29 #include <linux/dmi.h>
30
31 MODULE_AUTHOR("Brian Johnson <brijohn@gmail.com>, "
32                 "microdia project <microdia@googlegroups.com>");
33 MODULE_DESCRIPTION("GSPCA/SN9C20X USB Camera Driver");
34 MODULE_LICENSE("GPL");
35
36 #define MODULE_NAME "sn9c20x"
37
38 /*
39  * Pixel format private data
40  */
41 #define SCALE_MASK      0x0f
42 #define SCALE_160x120   0
43 #define SCALE_320x240   1
44 #define SCALE_640x480   2
45 #define SCALE_1280x1024 3
46 #define MODE_RAW        0x10
47 #define MODE_JPEG       0x20
48 #define MODE_SXGA       0x80
49
50 #define SENSOR_OV9650   0
51 #define SENSOR_OV9655   1
52 #define SENSOR_SOI968   2
53 #define SENSOR_OV7660   3
54 #define SENSOR_OV7670   4
55 #define SENSOR_MT9V011  5
56 #define SENSOR_MT9V111  6
57 #define SENSOR_MT9V112  7
58 #define SENSOR_MT9M001  8
59 #define SENSOR_MT9M111  9
60 #define SENSOR_MT9M112  10
61 #define SENSOR_HV7131R  11
62 #define SENSOR_MT9VPRB  20
63
64 /* camera flags */
65 #define HAS_NO_BUTTON   0x1
66 #define LED_REVERSE     0x2 /* some cameras unset gpio to turn on leds */
67 #define FLIP_DETECT     0x4
68
69 /* specific webcam descriptor */
70 struct sd {
71         struct gspca_dev gspca_dev;
72
73 #define MIN_AVG_LUM 80
74 #define MAX_AVG_LUM 130
75         atomic_t avg_lum;
76         u8 old_step;
77         u8 older_step;
78         u8 exposure_step;
79
80         u8 brightness;
81         u8 contrast;
82         u8 saturation;
83         s16 hue;
84         u8 gamma;
85         u8 red;
86         u8 blue;
87
88         u8 hflip;
89         u8 vflip;
90         u8 gain;
91         u16 exposure;
92         u8 auto_exposure;
93
94         u8 i2c_addr;
95         u8 sensor;
96         u8 hstart;
97         u8 vstart;
98
99         u8 jpeg_hdr[JPEG_HDR_SZ];
100         u8 quality;
101
102         u8 flags;
103 };
104
105 struct i2c_reg_u8 {
106         u8 reg;
107         u8 val;
108 };
109
110 struct i2c_reg_u16 {
111         u8 reg;
112         u16 val;
113 };
114
115 static int sd_setbrightness(struct gspca_dev *gspca_dev, s32 val);
116 static int sd_getbrightness(struct gspca_dev *gspca_dev, s32 *val);
117 static int sd_setcontrast(struct gspca_dev *gspca_dev, s32 val);
118 static int sd_getcontrast(struct gspca_dev *gspca_dev, s32 *val);
119 static int sd_setsaturation(struct gspca_dev *gspca_dev, s32 val);
120 static int sd_getsaturation(struct gspca_dev *gspca_dev, s32 *val);
121 static int sd_sethue(struct gspca_dev *gspca_dev, s32 val);
122 static int sd_gethue(struct gspca_dev *gspca_dev, s32 *val);
123 static int sd_setgamma(struct gspca_dev *gspca_dev, s32 val);
124 static int sd_getgamma(struct gspca_dev *gspca_dev, s32 *val);
125 static int sd_setredbalance(struct gspca_dev *gspca_dev, s32 val);
126 static int sd_getredbalance(struct gspca_dev *gspca_dev, s32 *val);
127 static int sd_setbluebalance(struct gspca_dev *gspca_dev, s32 val);
128 static int sd_getbluebalance(struct gspca_dev *gspca_dev, s32 *val);
129 static int sd_setvflip(struct gspca_dev *gspca_dev, s32 val);
130 static int sd_getvflip(struct gspca_dev *gspca_dev, s32 *val);
131 static int sd_sethflip(struct gspca_dev *gspca_dev, s32 val);
132 static int sd_gethflip(struct gspca_dev *gspca_dev, s32 *val);
133 static int sd_setgain(struct gspca_dev *gspca_dev, s32 val);
134 static int sd_getgain(struct gspca_dev *gspca_dev, s32 *val);
135 static int sd_setexposure(struct gspca_dev *gspca_dev, s32 val);
136 static int sd_getexposure(struct gspca_dev *gspca_dev, s32 *val);
137 static int sd_setautoexposure(struct gspca_dev *gspca_dev, s32 val);
138 static int sd_getautoexposure(struct gspca_dev *gspca_dev, s32 *val);
139
140 static const struct dmi_system_id flip_dmi_table[] = {
141         {
142                 .ident = "MSI MS-1034",
143                 .matches = {
144                         DMI_MATCH(DMI_SYS_VENDOR, "MICRO-STAR INT'L CO.,LTD."),
145                         DMI_MATCH(DMI_PRODUCT_NAME, "MS-1034"),
146                         DMI_MATCH(DMI_PRODUCT_VERSION, "0341")
147                 }
148         },
149         {
150                 .ident = "MSI MS-1632",
151                 .matches = {
152                         DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
153                         DMI_MATCH(DMI_BOARD_NAME, "MS-1632")
154                 }
155         },
156         {
157                 .ident = "MSI MS-1633X",
158                 .matches = {
159                         DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
160                         DMI_MATCH(DMI_BOARD_NAME, "MS-1633X")
161                 }
162         },
163         {
164                 .ident = "MSI MS-1635X",
165                 .matches = {
166                         DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
167                         DMI_MATCH(DMI_BOARD_NAME, "MS-1635X")
168                 }
169         },
170         {
171                 .ident = "ASUSTeK W7J",
172                 .matches = {
173                         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."),
174                         DMI_MATCH(DMI_BOARD_NAME, "W7J       ")
175                 }
176         },
177         {}
178 };
179
180 static const struct ctrl sd_ctrls[] = {
181         {
182 #define BRIGHTNESS_IDX 0
183             {
184                 .id      = V4L2_CID_BRIGHTNESS,
185                 .type    = V4L2_CTRL_TYPE_INTEGER,
186                 .name    = "Brightness",
187                 .minimum = 0,
188                 .maximum = 0xff,
189                 .step    = 1,
190 #define BRIGHTNESS_DEFAULT 0x7f
191                 .default_value = BRIGHTNESS_DEFAULT,
192             },
193             .set = sd_setbrightness,
194             .get = sd_getbrightness,
195         },
196         {
197 #define CONTRAST_IDX 1
198             {
199                 .id      = V4L2_CID_CONTRAST,
200                 .type    = V4L2_CTRL_TYPE_INTEGER,
201                 .name    = "Contrast",
202                 .minimum = 0,
203                 .maximum = 0xff,
204                 .step    = 1,
205 #define CONTRAST_DEFAULT 0x7f
206                 .default_value = CONTRAST_DEFAULT,
207             },
208             .set = sd_setcontrast,
209             .get = sd_getcontrast,
210         },
211         {
212 #define SATURATION_IDX 2
213             {
214                 .id      = V4L2_CID_SATURATION,
215                 .type    = V4L2_CTRL_TYPE_INTEGER,
216                 .name    = "Saturation",
217                 .minimum = 0,
218                 .maximum = 0xff,
219                 .step    = 1,
220 #define SATURATION_DEFAULT 0x7f
221                 .default_value = SATURATION_DEFAULT,
222             },
223             .set = sd_setsaturation,
224             .get = sd_getsaturation,
225         },
226         {
227 #define HUE_IDX 3
228             {
229                 .id      = V4L2_CID_HUE,
230                 .type    = V4L2_CTRL_TYPE_INTEGER,
231                 .name    = "Hue",
232                 .minimum = -180,
233                 .maximum = 180,
234                 .step    = 1,
235 #define HUE_DEFAULT 0
236                 .default_value = HUE_DEFAULT,
237             },
238             .set = sd_sethue,
239             .get = sd_gethue,
240         },
241         {
242 #define GAMMA_IDX 4
243             {
244                 .id      = V4L2_CID_GAMMA,
245                 .type    = V4L2_CTRL_TYPE_INTEGER,
246                 .name    = "Gamma",
247                 .minimum = 0,
248                 .maximum = 0xff,
249                 .step    = 1,
250 #define GAMMA_DEFAULT 0x10
251                 .default_value = GAMMA_DEFAULT,
252             },
253             .set = sd_setgamma,
254             .get = sd_getgamma,
255         },
256         {
257 #define BLUE_IDX 5
258             {
259                 .id      = V4L2_CID_BLUE_BALANCE,
260                 .type    = V4L2_CTRL_TYPE_INTEGER,
261                 .name    = "Blue Balance",
262                 .minimum = 0,
263                 .maximum = 0x7f,
264                 .step    = 1,
265 #define BLUE_DEFAULT 0x28
266                 .default_value = BLUE_DEFAULT,
267             },
268             .set = sd_setbluebalance,
269             .get = sd_getbluebalance,
270         },
271         {
272 #define RED_IDX 6
273             {
274                 .id      = V4L2_CID_RED_BALANCE,
275                 .type    = V4L2_CTRL_TYPE_INTEGER,
276                 .name    = "Red Balance",
277                 .minimum = 0,
278                 .maximum = 0x7f,
279                 .step    = 1,
280 #define RED_DEFAULT 0x28
281                 .default_value = RED_DEFAULT,
282             },
283             .set = sd_setredbalance,
284             .get = sd_getredbalance,
285         },
286         {
287 #define HFLIP_IDX 7
288             {
289                 .id      = V4L2_CID_HFLIP,
290                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
291                 .name    = "Horizontal Flip",
292                 .minimum = 0,
293                 .maximum = 1,
294                 .step    = 1,
295 #define HFLIP_DEFAULT 0
296                 .default_value = HFLIP_DEFAULT,
297             },
298             .set = sd_sethflip,
299             .get = sd_gethflip,
300         },
301         {
302 #define VFLIP_IDX 8
303             {
304                 .id      = V4L2_CID_VFLIP,
305                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
306                 .name    = "Vertical Flip",
307                 .minimum = 0,
308                 .maximum = 1,
309                 .step    = 1,
310 #define VFLIP_DEFAULT 0
311                 .default_value = VFLIP_DEFAULT,
312             },
313             .set = sd_setvflip,
314             .get = sd_getvflip,
315         },
316         {
317 #define EXPOSURE_IDX 9
318             {
319                 .id      = V4L2_CID_EXPOSURE,
320                 .type    = V4L2_CTRL_TYPE_INTEGER,
321                 .name    = "Exposure",
322                 .minimum = 0,
323                 .maximum = 0x1780,
324                 .step    = 1,
325 #define EXPOSURE_DEFAULT 0x33
326                 .default_value = EXPOSURE_DEFAULT,
327             },
328             .set = sd_setexposure,
329             .get = sd_getexposure,
330         },
331         {
332 #define GAIN_IDX 10
333             {
334                 .id      = V4L2_CID_GAIN,
335                 .type    = V4L2_CTRL_TYPE_INTEGER,
336                 .name    = "Gain",
337                 .minimum = 0,
338                 .maximum = 28,
339                 .step    = 1,
340 #define GAIN_DEFAULT 0x00
341                 .default_value = GAIN_DEFAULT,
342             },
343             .set = sd_setgain,
344             .get = sd_getgain,
345         },
346         {
347 #define AUTOGAIN_IDX 11
348             {
349                 .id      = V4L2_CID_AUTOGAIN,
350                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
351                 .name    = "Auto Exposure",
352                 .minimum = 0,
353                 .maximum = 1,
354                 .step    = 1,
355 #define AUTO_EXPOSURE_DEFAULT 1
356                 .default_value = AUTO_EXPOSURE_DEFAULT,
357             },
358             .set = sd_setautoexposure,
359             .get = sd_getautoexposure,
360         },
361 };
362
363 static const struct v4l2_pix_format vga_mode[] = {
364         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
365                 .bytesperline = 160,
366                 .sizeimage = 160 * 120 * 4 / 8 + 590,
367                 .colorspace = V4L2_COLORSPACE_JPEG,
368                 .priv = SCALE_160x120 | MODE_JPEG},
369         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
370                 .bytesperline = 160,
371                 .sizeimage = 160 * 120,
372                 .colorspace = V4L2_COLORSPACE_SRGB,
373                 .priv = SCALE_160x120 | MODE_RAW},
374         {160, 120, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
375                 .bytesperline = 160,
376                 .sizeimage = 240 * 120,
377                 .colorspace = V4L2_COLORSPACE_SRGB,
378                 .priv = SCALE_160x120},
379         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
380                 .bytesperline = 320,
381                 .sizeimage = 320 * 240 * 4 / 8 + 590,
382                 .colorspace = V4L2_COLORSPACE_JPEG,
383                 .priv = SCALE_320x240 | MODE_JPEG},
384         {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
385                 .bytesperline = 320,
386                 .sizeimage = 320 * 240 ,
387                 .colorspace = V4L2_COLORSPACE_SRGB,
388                 .priv = SCALE_320x240 | MODE_RAW},
389         {320, 240, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
390                 .bytesperline = 320,
391                 .sizeimage = 480 * 240 ,
392                 .colorspace = V4L2_COLORSPACE_SRGB,
393                 .priv = SCALE_320x240},
394         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
395                 .bytesperline = 640,
396                 .sizeimage = 640 * 480 * 4 / 8 + 590,
397                 .colorspace = V4L2_COLORSPACE_JPEG,
398                 .priv = SCALE_640x480 | MODE_JPEG},
399         {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
400                 .bytesperline = 640,
401                 .sizeimage = 640 * 480,
402                 .colorspace = V4L2_COLORSPACE_SRGB,
403                 .priv = SCALE_640x480 | MODE_RAW},
404         {640, 480, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
405                 .bytesperline = 640,
406                 .sizeimage = 960 * 480,
407                 .colorspace = V4L2_COLORSPACE_SRGB,
408                 .priv = SCALE_640x480},
409 };
410
411 static const struct v4l2_pix_format sxga_mode[] = {
412         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
413                 .bytesperline = 160,
414                 .sizeimage = 160 * 120 * 4 / 8 + 590,
415                 .colorspace = V4L2_COLORSPACE_JPEG,
416                 .priv = SCALE_160x120 | MODE_JPEG},
417         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
418                 .bytesperline = 160,
419                 .sizeimage = 160 * 120,
420                 .colorspace = V4L2_COLORSPACE_SRGB,
421                 .priv = SCALE_160x120 | MODE_RAW},
422         {160, 120, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
423                 .bytesperline = 160,
424                 .sizeimage = 240 * 120,
425                 .colorspace = V4L2_COLORSPACE_SRGB,
426                 .priv = SCALE_160x120},
427         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
428                 .bytesperline = 320,
429                 .sizeimage = 320 * 240 * 4 / 8 + 590,
430                 .colorspace = V4L2_COLORSPACE_JPEG,
431                 .priv = SCALE_320x240 | MODE_JPEG},
432         {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
433                 .bytesperline = 320,
434                 .sizeimage = 320 * 240 ,
435                 .colorspace = V4L2_COLORSPACE_SRGB,
436                 .priv = SCALE_320x240 | MODE_RAW},
437         {320, 240, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
438                 .bytesperline = 320,
439                 .sizeimage = 480 * 240 ,
440                 .colorspace = V4L2_COLORSPACE_SRGB,
441                 .priv = SCALE_320x240},
442         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
443                 .bytesperline = 640,
444                 .sizeimage = 640 * 480 * 4 / 8 + 590,
445                 .colorspace = V4L2_COLORSPACE_JPEG,
446                 .priv = SCALE_640x480 | MODE_JPEG},
447         {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
448                 .bytesperline = 640,
449                 .sizeimage = 640 * 480,
450                 .colorspace = V4L2_COLORSPACE_SRGB,
451                 .priv = SCALE_640x480 | MODE_RAW},
452         {640, 480, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
453                 .bytesperline = 640,
454                 .sizeimage = 960 * 480,
455                 .colorspace = V4L2_COLORSPACE_SRGB,
456                 .priv = SCALE_640x480},
457         {1280, 1024, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
458                 .bytesperline = 1280,
459                 .sizeimage = 1280 * 1024,
460                 .colorspace = V4L2_COLORSPACE_SRGB,
461                 .priv = SCALE_1280x1024 | MODE_RAW | MODE_SXGA},
462 };
463
464 static const struct v4l2_pix_format mono_mode[] = {
465         {160, 120, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
466                 .bytesperline = 160,
467                 .sizeimage = 160 * 120,
468                 .colorspace = V4L2_COLORSPACE_SRGB,
469                 .priv = SCALE_160x120 | MODE_RAW},
470         {320, 240, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
471                 .bytesperline = 320,
472                 .sizeimage = 320 * 240 ,
473                 .colorspace = V4L2_COLORSPACE_SRGB,
474                 .priv = SCALE_320x240 | MODE_RAW},
475         {640, 480, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
476                 .bytesperline = 640,
477                 .sizeimage = 640 * 480,
478                 .colorspace = V4L2_COLORSPACE_SRGB,
479                 .priv = SCALE_640x480 | MODE_RAW},
480         {1280, 1024, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
481                 .bytesperline = 1280,
482                 .sizeimage = 1280 * 1024,
483                 .colorspace = V4L2_COLORSPACE_SRGB,
484                 .priv = SCALE_1280x1024 | MODE_RAW | MODE_SXGA},
485 };
486
487 static const s16 hsv_red_x[] = {
488         41,  44,  46,  48,  50,  52,  54,  56,
489         58,  60,  62,  64,  66,  68,  70,  72,
490         74,  76,  78,  80,  81,  83,  85,  87,
491         88,  90,  92,  93,  95,  97,  98, 100,
492         101, 102, 104, 105, 107, 108, 109, 110,
493         112, 113, 114, 115, 116, 117, 118, 119,
494         120, 121, 122, 123, 123, 124, 125, 125,
495         126, 127, 127, 128, 128, 129, 129, 129,
496         130, 130, 130, 130, 131, 131, 131, 131,
497         131, 131, 131, 131, 130, 130, 130, 130,
498         129, 129, 129, 128, 128, 127, 127, 126,
499         125, 125, 124, 123, 122, 122, 121, 120,
500         119, 118, 117, 116, 115, 114, 112, 111,
501         110, 109, 107, 106, 105, 103, 102, 101,
502         99,  98,  96,  94,  93,  91,  90,  88,
503         86,  84,  83,  81,  79,  77,  75,  74,
504         72,  70,  68,  66,  64,  62,  60,  58,
505         56,  54,  52,  49,  47,  45,  43,  41,
506         39,  36,  34,  32,  30,  28,  25,  23,
507         21,  19,  16,  14,  12,   9,   7,   5,
508         3,   0,  -1,  -3,  -6,  -8, -10, -12,
509         -15, -17, -19, -22, -24, -26, -28, -30,
510         -33, -35, -37, -39, -41, -44, -46, -48,
511         -50, -52, -54, -56, -58, -60, -62, -64,
512         -66, -68, -70, -72, -74, -76, -78, -80,
513         -81, -83, -85, -87, -88, -90, -92, -93,
514         -95, -97, -98, -100, -101, -102, -104, -105,
515         -107, -108, -109, -110, -112, -113, -114, -115,
516         -116, -117, -118, -119, -120, -121, -122, -123,
517         -123, -124, -125, -125, -126, -127, -127, -128,
518         -128, -128, -128, -128, -128, -128, -128, -128,
519         -128, -128, -128, -128, -128, -128, -128, -128,
520         -128, -128, -128, -128, -128, -128, -128, -128,
521         -128, -127, -127, -126, -125, -125, -124, -123,
522         -122, -122, -121, -120, -119, -118, -117, -116,
523         -115, -114, -112, -111, -110, -109, -107, -106,
524         -105, -103, -102, -101, -99, -98, -96, -94,
525         -93, -91, -90, -88, -86, -84, -83, -81,
526         -79, -77, -75, -74, -72, -70, -68, -66,
527         -64, -62, -60, -58, -56, -54, -52, -49,
528         -47, -45, -43, -41, -39, -36, -34, -32,
529         -30, -28, -25, -23, -21, -19, -16, -14,
530         -12,  -9,  -7,  -5,  -3,   0,   1,   3,
531         6,   8,  10,  12,  15,  17,  19,  22,
532         24,  26,  28,  30,  33,  35,  37,  39, 41
533 };
534
535 static const s16 hsv_red_y[] = {
536         82,  80,  78,  76,  74,  73,  71,  69,
537         67,  65,  63,  61,  58,  56,  54,  52,
538         50,  48,  46,  44,  41,  39,  37,  35,
539         32,  30,  28,  26,  23,  21,  19,  16,
540         14,  12,  10,   7,   5,   3,   0,  -1,
541         -3,  -6,  -8, -10, -13, -15, -17, -19,
542         -22, -24, -26, -29, -31, -33, -35, -38,
543         -40, -42, -44, -46, -48, -51, -53, -55,
544         -57, -59, -61, -63, -65, -67, -69, -71,
545         -73, -75, -77, -79, -81, -82, -84, -86,
546         -88, -89, -91, -93, -94, -96, -98, -99,
547         -101, -102, -104, -105, -106, -108, -109, -110,
548         -112, -113, -114, -115, -116, -117, -119, -120,
549         -120, -121, -122, -123, -124, -125, -126, -126,
550         -127, -128, -128, -128, -128, -128, -128, -128,
551         -128, -128, -128, -128, -128, -128, -128, -128,
552         -128, -128, -128, -128, -128, -128, -128, -128,
553         -128, -128, -128, -128, -128, -128, -128, -128,
554         -127, -127, -126, -125, -125, -124, -123, -122,
555         -121, -120, -119, -118, -117, -116, -115, -114,
556         -113, -111, -110, -109, -107, -106, -105, -103,
557         -102, -100, -99, -97, -96, -94, -92, -91,
558         -89, -87, -85, -84, -82, -80, -78, -76,
559         -74, -73, -71, -69, -67, -65, -63, -61,
560         -58, -56, -54, -52, -50, -48, -46, -44,
561         -41, -39, -37, -35, -32, -30, -28, -26,
562         -23, -21, -19, -16, -14, -12, -10,  -7,
563         -5,  -3,   0,   1,   3,   6,   8,  10,
564         13,  15,  17,  19,  22,  24,  26,  29,
565         31,  33,  35,  38,  40,  42,  44,  46,
566         48,  51,  53,  55,  57,  59,  61,  63,
567         65,  67,  69,  71,  73,  75,  77,  79,
568         81,  82,  84,  86,  88,  89,  91,  93,
569         94,  96,  98,  99, 101, 102, 104, 105,
570         106, 108, 109, 110, 112, 113, 114, 115,
571         116, 117, 119, 120, 120, 121, 122, 123,
572         124, 125, 126, 126, 127, 128, 128, 129,
573         129, 130, 130, 131, 131, 131, 131, 132,
574         132, 132, 132, 132, 132, 132, 132, 132,
575         132, 132, 132, 131, 131, 131, 130, 130,
576         130, 129, 129, 128, 127, 127, 126, 125,
577         125, 124, 123, 122, 121, 120, 119, 118,
578         117, 116, 115, 114, 113, 111, 110, 109,
579         107, 106, 105, 103, 102, 100,  99,  97,
580         96, 94, 92, 91, 89, 87, 85, 84, 82
581 };
582
583 static const s16 hsv_green_x[] = {
584         -124, -124, -125, -125, -125, -125, -125, -125,
585         -125, -126, -126, -125, -125, -125, -125, -125,
586         -125, -124, -124, -124, -123, -123, -122, -122,
587         -121, -121, -120, -120, -119, -118, -117, -117,
588         -116, -115, -114, -113, -112, -111, -110, -109,
589         -108, -107, -105, -104, -103, -102, -100, -99,
590         -98, -96, -95, -93, -92, -91, -89, -87,
591         -86, -84, -83, -81, -79, -77, -76, -74,
592         -72, -70, -69, -67, -65, -63, -61, -59,
593         -57, -55, -53, -51, -49, -47, -45, -43,
594         -41, -39, -37, -35, -33, -30, -28, -26,
595         -24, -22, -20, -18, -15, -13, -11,  -9,
596         -7,  -4,  -2,   0,   1,   3,   6,   8,
597         10,  12,  14,  17,  19,  21,  23,  25,
598         27,  29,  32,  34,  36,  38,  40,  42,
599         44,  46,  48,  50,  52,  54,  56,  58,
600         60,  62,  64,  66,  68,  70,  71,  73,
601         75,  77,  78,  80,  82,  83,  85,  87,
602         88,  90,  91,  93,  94,  96,  97,  98,
603         100, 101, 102, 104, 105, 106, 107, 108,
604         109, 111, 112, 113, 113, 114, 115, 116,
605         117, 118, 118, 119, 120, 120, 121, 122,
606         122, 123, 123, 124, 124, 124, 125, 125,
607         125, 125, 125, 125, 125, 126, 126, 125,
608         125, 125, 125, 125, 125, 124, 124, 124,
609         123, 123, 122, 122, 121, 121, 120, 120,
610         119, 118, 117, 117, 116, 115, 114, 113,
611         112, 111, 110, 109, 108, 107, 105, 104,
612         103, 102, 100,  99,  98,  96,  95,  93,
613         92,  91,  89,  87,  86,  84,  83,  81,
614         79,  77,  76,  74,  72,  70,  69,  67,
615         65,  63,  61,  59,  57,  55,  53,  51,
616         49,  47,  45,  43,  41,  39,  37,  35,
617         33,  30,  28,  26,  24,  22,  20,  18,
618         15,  13,  11,   9,   7,   4,   2,   0,
619         -1,  -3,  -6,  -8, -10, -12, -14, -17,
620         -19, -21, -23, -25, -27, -29, -32, -34,
621         -36, -38, -40, -42, -44, -46, -48, -50,
622         -52, -54, -56, -58, -60, -62, -64, -66,
623         -68, -70, -71, -73, -75, -77, -78, -80,
624         -82, -83, -85, -87, -88, -90, -91, -93,
625         -94, -96, -97, -98, -100, -101, -102, -104,
626         -105, -106, -107, -108, -109, -111, -112, -113,
627         -113, -114, -115, -116, -117, -118, -118, -119,
628         -120, -120, -121, -122, -122, -123, -123, -124, -124
629 };
630
631 static const s16 hsv_green_y[] = {
632         -100, -99, -98, -97, -95, -94, -93, -91,
633         -90, -89, -87, -86, -84, -83, -81, -80,
634         -78, -76, -75, -73, -71, -70, -68, -66,
635         -64, -63, -61, -59, -57, -55, -53, -51,
636         -49, -48, -46, -44, -42, -40, -38, -36,
637         -34, -32, -30, -27, -25, -23, -21, -19,
638         -17, -15, -13, -11,  -9,  -7,  -4,  -2,
639         0,   1,   3,   5,   7,   9,  11,  14,
640         16,  18,  20,  22,  24,  26,  28,  30,
641         32,  34,  36,  38,  40,  42,  44,  46,
642         48,  50,  52,  54,  56,  58,  59,  61,
643         63,  65,  67,  68,  70,  72,  74,  75,
644         77,  78,  80,  82,  83,  85,  86,  88,
645         89,  90,  92,  93,  95,  96,  97,  98,
646         100, 101, 102, 103, 104, 105, 106, 107,
647         108, 109, 110, 111, 112, 112, 113, 114,
648         115, 115, 116, 116, 117, 117, 118, 118,
649         119, 119, 119, 120, 120, 120, 120, 120,
650         121, 121, 121, 121, 121, 121, 120, 120,
651         120, 120, 120, 119, 119, 119, 118, 118,
652         117, 117, 116, 116, 115, 114, 114, 113,
653         112, 111, 111, 110, 109, 108, 107, 106,
654         105, 104, 103, 102, 100,  99,  98,  97,
655         95,  94,  93,  91,  90,  89,  87,  86,
656         84,  83,  81,  80,  78,  76,  75,  73,
657         71,  70,  68,  66,  64,  63,  61,  59,
658         57,  55,  53,  51,  49,  48,  46,  44,
659         42,  40,  38,  36,  34,  32,  30,  27,
660         25,  23,  21,  19,  17,  15,  13,  11,
661         9,   7,   4,   2,   0,  -1,  -3,  -5,
662         -7,  -9, -11, -14, -16, -18, -20, -22,
663         -24, -26, -28, -30, -32, -34, -36, -38,
664         -40, -42, -44, -46, -48, -50, -52, -54,
665         -56, -58, -59, -61, -63, -65, -67, -68,
666         -70, -72, -74, -75, -77, -78, -80, -82,
667         -83, -85, -86, -88, -89, -90, -92, -93,
668         -95, -96, -97, -98, -100, -101, -102, -103,
669         -104, -105, -106, -107, -108, -109, -110, -111,
670         -112, -112, -113, -114, -115, -115, -116, -116,
671         -117, -117, -118, -118, -119, -119, -119, -120,
672         -120, -120, -120, -120, -121, -121, -121, -121,
673         -121, -121, -120, -120, -120, -120, -120, -119,
674         -119, -119, -118, -118, -117, -117, -116, -116,
675         -115, -114, -114, -113, -112, -111, -111, -110,
676         -109, -108, -107, -106, -105, -104, -103, -102, -100
677 };
678
679 static const s16 hsv_blue_x[] = {
680         112, 113, 114, 114, 115, 116, 117, 117,
681         118, 118, 119, 119, 120, 120, 120, 121,
682         121, 121, 122, 122, 122, 122, 122, 122,
683         122, 122, 122, 122, 122, 122, 121, 121,
684         121, 120, 120, 120, 119, 119, 118, 118,
685         117, 116, 116, 115, 114, 113, 113, 112,
686         111, 110, 109, 108, 107, 106, 105, 104,
687         103, 102, 100,  99,  98,  97,  95,  94,
688         93,  91,  90,  88,  87,  85,  84,  82,
689         80,  79,  77,  76,  74,  72,  70,  69,
690         67,  65,  63,  61,  60,  58,  56,  54,
691         52,  50,  48,  46,  44,  42,  40,  38,
692         36,  34,  32,  30,  28,  26,  24,  22,
693         19,  17,  15,  13,  11,   9,   7,   5,
694         2,   0,  -1,  -3,  -5,  -7,  -9, -12,
695         -14, -16, -18, -20, -22, -24, -26, -28,
696         -31, -33, -35, -37, -39, -41, -43, -45,
697         -47, -49, -51, -53, -54, -56, -58, -60,
698         -62, -64, -66, -67, -69, -71, -73, -74,
699         -76, -78, -79, -81, -83, -84, -86, -87,
700         -89, -90, -92, -93, -94, -96, -97, -98,
701         -99, -101, -102, -103, -104, -105, -106, -107,
702         -108, -109, -110, -111, -112, -113, -114, -114,
703         -115, -116, -117, -117, -118, -118, -119, -119,
704         -120, -120, -120, -121, -121, -121, -122, -122,
705         -122, -122, -122, -122, -122, -122, -122, -122,
706         -122, -122, -121, -121, -121, -120, -120, -120,
707         -119, -119, -118, -118, -117, -116, -116, -115,
708         -114, -113, -113, -112, -111, -110, -109, -108,
709         -107, -106, -105, -104, -103, -102, -100, -99,
710         -98, -97, -95, -94, -93, -91, -90, -88,
711         -87, -85, -84, -82, -80, -79, -77, -76,
712         -74, -72, -70, -69, -67, -65, -63, -61,
713         -60, -58, -56, -54, -52, -50, -48, -46,
714         -44, -42, -40, -38, -36, -34, -32, -30,
715         -28, -26, -24, -22, -19, -17, -15, -13,
716         -11,  -9,  -7,  -5,  -2,   0,   1,   3,
717         5,   7,   9,  12,  14,  16,  18,  20,
718         22,  24,  26,  28,  31,  33,  35,  37,
719         39,  41,  43,  45,  47,  49,  51,  53,
720         54,  56,  58,  60,  62,  64,  66,  67,
721         69,  71,  73,  74,  76,  78,  79,  81,
722         83,  84,  86,  87,  89,  90,  92,  93,
723         94,  96,  97,  98,  99, 101, 102, 103,
724         104, 105, 106, 107, 108, 109, 110, 111, 112
725 };
726
727 static const s16 hsv_blue_y[] = {
728         -11, -13, -15, -17, -19, -21, -23, -25,
729         -27, -29, -31, -33, -35, -37, -39, -41,
730         -43, -45, -46, -48, -50, -52, -54, -55,
731         -57, -59, -61, -62, -64, -66, -67, -69,
732         -71, -72, -74, -75, -77, -78, -80, -81,
733         -83, -84, -86, -87, -88, -90, -91, -92,
734         -93, -95, -96, -97, -98, -99, -100, -101,
735         -102, -103, -104, -105, -106, -106, -107, -108,
736         -109, -109, -110, -111, -111, -112, -112, -113,
737         -113, -114, -114, -114, -115, -115, -115, -115,
738         -116, -116, -116, -116, -116, -116, -116, -116,
739         -116, -115, -115, -115, -115, -114, -114, -114,
740         -113, -113, -112, -112, -111, -111, -110, -110,
741         -109, -108, -108, -107, -106, -105, -104, -103,
742         -102, -101, -100, -99, -98, -97, -96, -95,
743         -94, -93, -91, -90, -89, -88, -86, -85,
744         -84, -82, -81, -79, -78, -76, -75, -73,
745         -71, -70, -68, -67, -65, -63, -62, -60,
746         -58, -56, -55, -53, -51, -49, -47, -45,
747         -44, -42, -40, -38, -36, -34, -32, -30,
748         -28, -26, -24, -22, -20, -18, -16, -14,
749         -12, -10,  -8,  -6,  -4,  -2,   0,   1,
750         3,   5,   7,   9,  11,  13,  15,  17,
751         19,  21,  23,  25,  27,  29,  31,  33,
752         35,  37,  39,  41,  43,  45,  46,  48,
753         50,  52,  54,  55,  57,  59,  61,  62,
754         64,  66,  67,  69,  71,  72,  74,  75,
755         77,  78,  80,  81,  83,  84,  86,  87,
756         88,  90,  91,  92,  93,  95,  96,  97,
757         98,  99, 100, 101, 102, 103, 104, 105,
758         106, 106, 107, 108, 109, 109, 110, 111,
759         111, 112, 112, 113, 113, 114, 114, 114,
760         115, 115, 115, 115, 116, 116, 116, 116,
761         116, 116, 116, 116, 116, 115, 115, 115,
762         115, 114, 114, 114, 113, 113, 112, 112,
763         111, 111, 110, 110, 109, 108, 108, 107,
764         106, 105, 104, 103, 102, 101, 100,  99,
765         98,  97,  96,  95,  94,  93,  91,  90,
766         89,  88,  86,  85,  84,  82,  81,  79,
767         78,  76,  75,  73,  71,  70,  68,  67,
768         65,  63,  62,  60,  58,  56,  55,  53,
769         51,  49,  47,  45,  44,  42,  40,  38,
770         36,  34,  32,  30,  28,  26,  24,  22,
771         20,  18,  16,  14,  12,  10,   8,   6,
772         4,   2,   0,  -1,  -3,  -5,  -7,  -9, -11
773 };
774
775 static u16 i2c_ident[] = {
776         V4L2_IDENT_OV9650,
777         V4L2_IDENT_OV9655,
778         V4L2_IDENT_SOI968,
779         V4L2_IDENT_OV7660,
780         V4L2_IDENT_OV7670,
781         V4L2_IDENT_MT9V011,
782         V4L2_IDENT_MT9V111,
783         V4L2_IDENT_MT9V112,
784         V4L2_IDENT_MT9M001C12ST,
785         V4L2_IDENT_MT9M111,
786         V4L2_IDENT_MT9M112,
787         V4L2_IDENT_HV7131R,
788 };
789
790 static u16 bridge_init[][2] = {
791         {0x1000, 0x78}, {0x1001, 0x40}, {0x1002, 0x1c},
792         {0x1020, 0x80}, {0x1061, 0x01}, {0x1067, 0x40},
793         {0x1068, 0x30}, {0x1069, 0x20}, {0x106a, 0x10},
794         {0x106b, 0x08}, {0x1188, 0x87}, {0x11a1, 0x00},
795         {0x11a2, 0x00}, {0x11a3, 0x6a}, {0x11a4, 0x50},
796         {0x11ab, 0x00}, {0x11ac, 0x00}, {0x11ad, 0x50},
797         {0x11ae, 0x3c}, {0x118a, 0x04}, {0x0395, 0x04},
798         {0x11b8, 0x3a}, {0x118b, 0x0e}, {0x10f7, 0x05},
799         {0x10f8, 0x14}, {0x10fa, 0xff}, {0x10f9, 0x00},
800         {0x11ba, 0x0a}, {0x11a5, 0x2d}, {0x11a6, 0x2d},
801         {0x11a7, 0x3a}, {0x11a8, 0x05}, {0x11a9, 0x04},
802         {0x11aa, 0x3f}, {0x11af, 0x28}, {0x11b0, 0xd8},
803         {0x11b1, 0x14}, {0x11b2, 0xec}, {0x11b3, 0x32},
804         {0x11b4, 0xdd}, {0x11b5, 0x32}, {0x11b6, 0xdd},
805         {0x10e0, 0x2c}, {0x11bc, 0x40}, {0x11bd, 0x01},
806         {0x11be, 0xf0}, {0x11bf, 0x00}, {0x118c, 0x1f},
807         {0x118d, 0x1f}, {0x118e, 0x1f}, {0x118f, 0x1f},
808         {0x1180, 0x01}, {0x1181, 0x00}, {0x1182, 0x01},
809         {0x1183, 0x00}, {0x1184, 0x50}, {0x1185, 0x80},
810         {0x1007, 0x00}
811 };
812
813 /* Gain = (bit[3:0] / 16 + 1) * (bit[4] + 1) * (bit[5] + 1) * (bit[6] + 1) */
814 static u8 ov_gain[] = {
815         0x00 /* 1x */, 0x04 /* 1.25x */, 0x08 /* 1.5x */, 0x0c /* 1.75x */,
816         0x10 /* 2x */, 0x12 /* 2.25x */, 0x14 /* 2.5x */, 0x16 /* 2.75x */,
817         0x18 /* 3x */, 0x1a /* 3.25x */, 0x1c /* 3.5x */, 0x1e /* 3.75x */,
818         0x30 /* 4x */, 0x31 /* 4.25x */, 0x32 /* 4.5x */, 0x33 /* 4.75x */,
819         0x34 /* 5x */, 0x35 /* 5.25x */, 0x36 /* 5.5x */, 0x37 /* 5.75x */,
820         0x38 /* 6x */, 0x39 /* 6.25x */, 0x3a /* 6.5x */, 0x3b /* 6.75x */,
821         0x3c /* 7x */, 0x3d /* 7.25x */, 0x3e /* 7.5x */, 0x3f /* 7.75x */,
822         0x70 /* 8x */
823 };
824
825 /* Gain = (bit[8] + 1) * (bit[7] + 1) * (bit[6:0] * 0.03125) */
826 static u16 micron1_gain[] = {
827         /* 1x   1.25x   1.5x    1.75x */
828         0x0020, 0x0028, 0x0030, 0x0038,
829         /* 2x   2.25x   2.5x    2.75x */
830         0x00a0, 0x00a4, 0x00a8, 0x00ac,
831         /* 3x   3.25x   3.5x    3.75x */
832         0x00b0, 0x00b4, 0x00b8, 0x00bc,
833         /* 4x   4.25x   4.5x    4.75x */
834         0x00c0, 0x00c4, 0x00c8, 0x00cc,
835         /* 5x   5.25x   5.5x    5.75x */
836         0x00d0, 0x00d4, 0x00d8, 0x00dc,
837         /* 6x   6.25x   6.5x    6.75x */
838         0x00e0, 0x00e4, 0x00e8, 0x00ec,
839         /* 7x   7.25x   7.5x    7.75x */
840         0x00f0, 0x00f4, 0x00f8, 0x00fc,
841         /* 8x */
842         0x01c0
843 };
844
845 /* mt9m001 sensor uses a different gain formula then other micron sensors */
846 /* Gain = (bit[6] + 1) * (bit[5-0] * 0.125) */
847 static u16 micron2_gain[] = {
848         /* 1x   1.25x   1.5x    1.75x */
849         0x0008, 0x000a, 0x000c, 0x000e,
850         /* 2x   2.25x   2.5x    2.75x */
851         0x0010, 0x0012, 0x0014, 0x0016,
852         /* 3x   3.25x   3.5x    3.75x */
853         0x0018, 0x001a, 0x001c, 0x001e,
854         /* 4x   4.25x   4.5x    4.75x */
855         0x0020, 0x0051, 0x0052, 0x0053,
856         /* 5x   5.25x   5.5x    5.75x */
857         0x0054, 0x0055, 0x0056, 0x0057,
858         /* 6x   6.25x   6.5x    6.75x */
859         0x0058, 0x0059, 0x005a, 0x005b,
860         /* 7x   7.25x   7.5x    7.75x */
861         0x005c, 0x005d, 0x005e, 0x005f,
862         /* 8x */
863         0x0060
864 };
865
866 /* Gain = .5 + bit[7:0] / 16 */
867 static u8 hv7131r_gain[] = {
868         0x08 /* 1x */, 0x0c /* 1.25x */, 0x10 /* 1.5x */, 0x14 /* 1.75x */,
869         0x18 /* 2x */, 0x1c /* 2.25x */, 0x20 /* 2.5x */, 0x24 /* 2.75x */,
870         0x28 /* 3x */, 0x2c /* 3.25x */, 0x30 /* 3.5x */, 0x34 /* 3.75x */,
871         0x38 /* 4x */, 0x3c /* 4.25x */, 0x40 /* 4.5x */, 0x44 /* 4.75x */,
872         0x48 /* 5x */, 0x4c /* 5.25x */, 0x50 /* 5.5x */, 0x54 /* 5.75x */,
873         0x58 /* 6x */, 0x5c /* 6.25x */, 0x60 /* 6.5x */, 0x64 /* 6.75x */,
874         0x68 /* 7x */, 0x6c /* 7.25x */, 0x70 /* 7.5x */, 0x74 /* 7.75x */,
875         0x78 /* 8x */
876 };
877
878 static struct i2c_reg_u8 soi968_init[] = {
879         {0x12, 0x80}, {0x0c, 0x00}, {0x0f, 0x1f},
880         {0x11, 0x80}, {0x38, 0x52}, {0x1e, 0x00},
881         {0x33, 0x08}, {0x35, 0x8c}, {0x36, 0x0c},
882         {0x37, 0x04}, {0x45, 0x04}, {0x47, 0xff},
883         {0x3e, 0x00}, {0x3f, 0x00}, {0x3b, 0x20},
884         {0x3a, 0x96}, {0x3d, 0x0a}, {0x14, 0x8e},
885         {0x13, 0x8b}, {0x12, 0x40}, {0x17, 0x13},
886         {0x18, 0x63}, {0x19, 0x01}, {0x1a, 0x79},
887         {0x32, 0x24}, {0x03, 0x00}, {0x11, 0x40},
888         {0x2a, 0x10}, {0x2b, 0xe0}, {0x10, 0x32},
889         {0x00, 0x00}, {0x01, 0x80}, {0x02, 0x80},
890 };
891
892 static struct i2c_reg_u8 ov7660_init[] = {
893         {0x0e, 0x80}, {0x0d, 0x08}, {0x0f, 0xc3},
894         {0x04, 0xc3}, {0x10, 0x40}, {0x11, 0x40},
895         {0x12, 0x05}, {0x13, 0xba}, {0x14, 0x2a},
896         /* HDG Set hstart and hstop, datasheet default 0x11, 0x61, using
897            0x10, 0x61 and sd->hstart, vstart = 3, fixes ugly colored borders */
898         {0x17, 0x10}, {0x18, 0x61},
899         {0x37, 0x0f}, {0x38, 0x02}, {0x39, 0x43},
900         {0x3a, 0x00}, {0x69, 0x90}, {0x2d, 0xf6},
901         {0x2e, 0x0b}, {0x01, 0x78}, {0x02, 0x50},
902 };
903
904 static struct i2c_reg_u8 ov7670_init[] = {
905         {0x12, 0x80}, {0x11, 0x80}, {0x3a, 0x04}, {0x12, 0x01},
906         {0x32, 0xb6}, {0x03, 0x0a}, {0x0c, 0x00}, {0x3e, 0x00},
907         {0x70, 0x3a}, {0x71, 0x35}, {0x72, 0x11}, {0x73, 0xf0},
908         {0xa2, 0x02}, {0x13, 0xe0}, {0x00, 0x00}, {0x10, 0x00},
909         {0x0d, 0x40}, {0x14, 0x28}, {0xa5, 0x05}, {0xab, 0x07},
910         {0x24, 0x95}, {0x25, 0x33}, {0x26, 0xe3}, {0x9f, 0x75},
911         {0xa0, 0x65}, {0xa1, 0x0b}, {0xa6, 0xd8}, {0xa7, 0xd8},
912         {0xa8, 0xf0}, {0xa9, 0x90}, {0xaa, 0x94}, {0x13, 0xe5},
913         {0x0e, 0x61}, {0x0f, 0x4b}, {0x16, 0x02}, {0x1e, 0x27},
914         {0x21, 0x02}, {0x22, 0x91}, {0x29, 0x07}, {0x33, 0x0b},
915         {0x35, 0x0b}, {0x37, 0x1d}, {0x38, 0x71}, {0x39, 0x2a},
916         {0x3c, 0x78}, {0x4d, 0x40}, {0x4e, 0x20}, {0x69, 0x00},
917         {0x74, 0x19}, {0x8d, 0x4f}, {0x8e, 0x00}, {0x8f, 0x00},
918         {0x90, 0x00}, {0x91, 0x00}, {0x96, 0x00}, {0x9a, 0x80},
919         {0xb0, 0x84}, {0xb1, 0x0c}, {0xb2, 0x0e}, {0xb3, 0x82},
920         {0xb8, 0x0a}, {0x43, 0x0a}, {0x44, 0xf0}, {0x45, 0x20},
921         {0x46, 0x7d}, {0x47, 0x29}, {0x48, 0x4a}, {0x59, 0x8c},
922         {0x5a, 0xa5}, {0x5b, 0xde}, {0x5c, 0x96}, {0x5d, 0x66},
923         {0x5e, 0x10}, {0x6c, 0x0a}, {0x6d, 0x55}, {0x6e, 0x11},
924         {0x6f, 0x9e}, {0x6a, 0x40}, {0x01, 0x40}, {0x02, 0x40},
925         {0x13, 0xe7}, {0x4f, 0x6e}, {0x50, 0x70}, {0x51, 0x02},
926         {0x52, 0x1d}, {0x53, 0x56}, {0x54, 0x73}, {0x55, 0x0a},
927         {0x56, 0x55}, {0x57, 0x80}, {0x58, 0x9e}, {0x41, 0x08},
928         {0x3f, 0x02}, {0x75, 0x03}, {0x76, 0x63}, {0x4c, 0x04},
929         {0x77, 0x06}, {0x3d, 0x02}, {0x4b, 0x09}, {0xc9, 0x30},
930         {0x41, 0x08}, {0x56, 0x48}, {0x34, 0x11}, {0xa4, 0x88},
931         {0x96, 0x00}, {0x97, 0x30}, {0x98, 0x20}, {0x99, 0x30},
932         {0x9a, 0x84}, {0x9b, 0x29}, {0x9c, 0x03}, {0x9d, 0x99},
933         {0x9e, 0x7f}, {0x78, 0x04}, {0x79, 0x01}, {0xc8, 0xf0},
934         {0x79, 0x0f}, {0xc8, 0x00}, {0x79, 0x10}, {0xc8, 0x7e},
935         {0x79, 0x0a}, {0xc8, 0x80}, {0x79, 0x0b}, {0xc8, 0x01},
936         {0x79, 0x0c}, {0xc8, 0x0f}, {0x79, 0x0d}, {0xc8, 0x20},
937         {0x79, 0x09}, {0xc8, 0x80}, {0x79, 0x02}, {0xc8, 0xc0},
938         {0x79, 0x03}, {0xc8, 0x40}, {0x79, 0x05}, {0xc8, 0x30},
939         {0x79, 0x26}, {0x62, 0x20}, {0x63, 0x00}, {0x64, 0x06},
940         {0x65, 0x00}, {0x66, 0x05}, {0x94, 0x05}, {0x95, 0x0a},
941         {0x17, 0x13}, {0x18, 0x01}, {0x19, 0x02}, {0x1a, 0x7a},
942         {0x46, 0x59}, {0x47, 0x30}, {0x58, 0x9a}, {0x59, 0x84},
943         {0x5a, 0x91}, {0x5b, 0x57}, {0x5c, 0x75}, {0x5d, 0x6d},
944         {0x5e, 0x13}, {0x64, 0x07}, {0x94, 0x07}, {0x95, 0x0d},
945         {0xa6, 0xdf}, {0xa7, 0xdf}, {0x48, 0x4d}, {0x51, 0x00},
946         {0x6b, 0x0a}, {0x11, 0x80}, {0x2a, 0x00}, {0x2b, 0x00},
947         {0x92, 0x00}, {0x93, 0x00}, {0x55, 0x0a}, {0x56, 0x60},
948         {0x4f, 0x6e}, {0x50, 0x70}, {0x51, 0x00}, {0x52, 0x1d},
949         {0x53, 0x56}, {0x54, 0x73}, {0x58, 0x9a}, {0x4f, 0x6e},
950         {0x50, 0x70}, {0x51, 0x00}, {0x52, 0x1d}, {0x53, 0x56},
951         {0x54, 0x73}, {0x58, 0x9a}, {0x3f, 0x01}, {0x7b, 0x03},
952         {0x7c, 0x09}, {0x7d, 0x16}, {0x7e, 0x38}, {0x7f, 0x47},
953         {0x80, 0x53}, {0x81, 0x5e}, {0x82, 0x6a}, {0x83, 0x74},
954         {0x84, 0x80}, {0x85, 0x8c}, {0x86, 0x9b}, {0x87, 0xb2},
955         {0x88, 0xcc}, {0x89, 0xe5}, {0x7a, 0x24}, {0x3b, 0x00},
956         {0x9f, 0x76}, {0xa0, 0x65}, {0x13, 0xe2}, {0x6b, 0x0a},
957         {0x11, 0x80}, {0x2a, 0x00}, {0x2b, 0x00}, {0x92, 0x00},
958         {0x93, 0x00},
959 };
960
961 static struct i2c_reg_u8 ov9650_init[] = {
962         {0x12, 0x80}, {0x00, 0x00}, {0x01, 0x78},
963         {0x02, 0x78}, {0x03, 0x36}, {0x04, 0x03},
964         {0x05, 0x00}, {0x06, 0x00}, {0x08, 0x00},
965         {0x09, 0x01}, {0x0c, 0x00}, {0x0d, 0x00},
966         {0x0e, 0xa0}, {0x0f, 0x52}, {0x10, 0x7c},
967         {0x11, 0x80}, {0x12, 0x45}, {0x13, 0xc2},
968         {0x14, 0x2e}, {0x15, 0x00}, {0x16, 0x07},
969         {0x17, 0x24}, {0x18, 0xc5}, {0x19, 0x00},
970         {0x1a, 0x3c}, {0x1b, 0x00}, {0x1e, 0x04},
971         {0x1f, 0x00}, {0x24, 0x78}, {0x25, 0x68},
972         {0x26, 0xd4}, {0x27, 0x80}, {0x28, 0x80},
973         {0x29, 0x30}, {0x2a, 0x00}, {0x2b, 0x00},
974         {0x2c, 0x80}, {0x2d, 0x00}, {0x2e, 0x00},
975         {0x2f, 0x00}, {0x30, 0x08}, {0x31, 0x30},
976         {0x32, 0x84}, {0x33, 0xe2}, {0x34, 0xbf},
977         {0x35, 0x81}, {0x36, 0xf9}, {0x37, 0x00},
978         {0x38, 0x93}, {0x39, 0x50}, {0x3a, 0x01},
979         {0x3b, 0x01}, {0x3c, 0x73}, {0x3d, 0x19},
980         {0x3e, 0x0b}, {0x3f, 0x80}, {0x40, 0xc1},
981         {0x41, 0x00}, {0x42, 0x08}, {0x67, 0x80},
982         {0x68, 0x80}, {0x69, 0x40}, {0x6a, 0x00},
983         {0x6b, 0x0a}, {0x8b, 0x06}, {0x8c, 0x20},
984         {0x8d, 0x00}, {0x8e, 0x00}, {0x8f, 0xdf},
985         {0x92, 0x00}, {0x93, 0x00}, {0x94, 0x88},
986         {0x95, 0x88}, {0x96, 0x04}, {0xa1, 0x00},
987         {0xa5, 0x80}, {0xa8, 0x80}, {0xa9, 0xb8},
988         {0xaa, 0x92}, {0xab, 0x0a},
989 };
990
991 static struct i2c_reg_u8 ov9655_init[] = {
992         {0x12, 0x80}, {0x0e, 0x61}, {0x11, 0x80}, {0x13, 0xba},
993         {0x14, 0x2e}, {0x16, 0x24}, {0x1e, 0x04}, {0x27, 0x08},
994         {0x28, 0x08}, {0x29, 0x15}, {0x2c, 0x08}, {0x34, 0x3d},
995         {0x35, 0x00}, {0x38, 0x12}, {0x0f, 0x42}, {0x39, 0x57},
996         {0x3a, 0x00}, {0x3b, 0xcc}, {0x3c, 0x0c}, {0x3d, 0x19},
997         {0x3e, 0x0c}, {0x3f, 0x01}, {0x41, 0x40}, {0x42, 0x80},
998         {0x45, 0x46}, {0x46, 0x62}, {0x47, 0x2a}, {0x48, 0x3c},
999         {0x4a, 0xf0}, {0x4b, 0xdc}, {0x4c, 0xdc}, {0x4d, 0xdc},
1000         {0x4e, 0xdc}, {0x6c, 0x04}, {0x6f, 0x9e}, {0x70, 0x05},
1001         {0x71, 0x78}, {0x77, 0x02}, {0x8a, 0x23}, {0x90, 0x7e},
1002         {0x91, 0x7c}, {0x9f, 0x6e}, {0xa0, 0x6e}, {0xa5, 0x68},
1003         {0xa6, 0x60}, {0xa8, 0xc1}, {0xa9, 0xfa}, {0xaa, 0x92},
1004         {0xab, 0x04}, {0xac, 0x80}, {0xad, 0x80}, {0xae, 0x80},
1005         {0xaf, 0x80}, {0xb2, 0xf2}, {0xb3, 0x20}, {0xb5, 0x00},
1006         {0xb6, 0xaf}, {0xbb, 0xae}, {0xbc, 0x44}, {0xbd, 0x44},
1007         {0xbe, 0x3b}, {0xbf, 0x3a}, {0xc1, 0xc8}, {0xc2, 0x01},
1008         {0xc4, 0x00}, {0xc6, 0x85}, {0xc7, 0x81}, {0xc9, 0xe0},
1009         {0xca, 0xe8}, {0xcc, 0xd8}, {0xcd, 0x93}, {0x2d, 0x00},
1010         {0x2e, 0x00}, {0x01, 0x80}, {0x02, 0x80}, {0x12, 0x61},
1011         {0x36, 0xfa}, {0x8c, 0x8d}, {0xc0, 0xaa}, {0x69, 0x0a},
1012         {0x03, 0x09}, {0x17, 0x16}, {0x18, 0x6e}, {0x19, 0x01},
1013         {0x1a, 0x3e}, {0x32, 0x09}, {0x2a, 0x10}, {0x2b, 0x0a},
1014         {0x92, 0x00}, {0x93, 0x00}, {0xa1, 0x00}, {0x10, 0x7c},
1015         {0x04, 0x03}, {0x00, 0x13},
1016 };
1017
1018 static struct i2c_reg_u16 mt9v112_init[] = {
1019         {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0020},
1020         {0x34, 0xc019}, {0x0a, 0x0011}, {0x0b, 0x000b},
1021         {0x20, 0x0703}, {0x35, 0x2022}, {0xf0, 0x0001},
1022         {0x05, 0x0000}, {0x06, 0x340c}, {0x3b, 0x042a},
1023         {0x3c, 0x0400}, {0xf0, 0x0002}, {0x2e, 0x0c58},
1024         {0x5b, 0x0001}, {0xc8, 0x9f0b}, {0xf0, 0x0001},
1025         {0x9b, 0x5300}, {0xf0, 0x0000}, {0x2b, 0x0020},
1026         {0x2c, 0x002a}, {0x2d, 0x0032}, {0x2e, 0x0020},
1027         {0x09, 0x01dc}, {0x01, 0x000c}, {0x02, 0x0020},
1028         {0x03, 0x01e0}, {0x04, 0x0280}, {0x06, 0x000c},
1029         {0x05, 0x0098}, {0x20, 0x0703}, {0x09, 0x01f2},
1030         {0x2b, 0x00a0}, {0x2c, 0x00a0}, {0x2d, 0x00a0},
1031         {0x2e, 0x00a0}, {0x01, 0x000c}, {0x02, 0x0020},
1032         {0x03, 0x01e0}, {0x04, 0x0280}, {0x06, 0x000c},
1033         {0x05, 0x0098}, {0x09, 0x01c1}, {0x2b, 0x00ae},
1034         {0x2c, 0x00ae}, {0x2d, 0x00ae}, {0x2e, 0x00ae},
1035 };
1036
1037 static struct i2c_reg_u16 mt9v111_init[] = {
1038         {0x01, 0x0004}, {0x0d, 0x0001}, {0x0d, 0x0000},
1039         {0x01, 0x0001}, {0x05, 0x0004}, {0x2d, 0xe0a0},
1040         {0x2e, 0x0c64}, {0x2f, 0x0064}, {0x06, 0x600e},
1041         {0x08, 0x0480}, {0x01, 0x0004}, {0x02, 0x0016},
1042         {0x03, 0x01e7}, {0x04, 0x0287}, {0x05, 0x0004},
1043         {0x06, 0x002d}, {0x07, 0x3002}, {0x08, 0x0008},
1044         {0x0e, 0x0008}, {0x20, 0x0000}
1045 };
1046
1047 static struct i2c_reg_u16 mt9v011_init[] = {
1048         {0x07, 0x0002}, {0x0d, 0x0001}, {0x0d, 0x0000},
1049         {0x01, 0x0008}, {0x02, 0x0016}, {0x03, 0x01e1},
1050         {0x04, 0x0281}, {0x05, 0x0083}, {0x06, 0x0006},
1051         {0x0d, 0x0002}, {0x0a, 0x0000}, {0x0b, 0x0000},
1052         {0x0c, 0x0000}, {0x0d, 0x0000}, {0x0e, 0x0000},
1053         {0x0f, 0x0000}, {0x10, 0x0000}, {0x11, 0x0000},
1054         {0x12, 0x0000}, {0x13, 0x0000}, {0x14, 0x0000},
1055         {0x15, 0x0000}, {0x16, 0x0000}, {0x17, 0x0000},
1056         {0x18, 0x0000}, {0x19, 0x0000}, {0x1a, 0x0000},
1057         {0x1b, 0x0000}, {0x1c, 0x0000}, {0x1d, 0x0000},
1058         {0x32, 0x0000}, {0x20, 0x1101}, {0x21, 0x0000},
1059         {0x22, 0x0000}, {0x23, 0x0000}, {0x24, 0x0000},
1060         {0x25, 0x0000}, {0x26, 0x0000}, {0x27, 0x0024},
1061         {0x2f, 0xf7b0}, {0x30, 0x0005}, {0x31, 0x0000},
1062         {0x32, 0x0000}, {0x33, 0x0000}, {0x34, 0x0100},
1063         {0x3d, 0x068f}, {0x40, 0x01e0}, {0x41, 0x00d1},
1064         {0x44, 0x0082}, {0x5a, 0x0000}, {0x5b, 0x0000},
1065         {0x5c, 0x0000}, {0x5d, 0x0000}, {0x5e, 0x0000},
1066         {0x5f, 0xa31d}, {0x62, 0x0611}, {0x0a, 0x0000},
1067         {0x06, 0x0029}, {0x05, 0x0009}, {0x20, 0x1101},
1068         {0x20, 0x1101}, {0x09, 0x0064}, {0x07, 0x0003},
1069         {0x2b, 0x0033}, {0x2c, 0x00a0}, {0x2d, 0x00a0},
1070         {0x2e, 0x0033}, {0x07, 0x0002}, {0x06, 0x0000},
1071         {0x06, 0x0029}, {0x05, 0x0009},
1072 };
1073
1074 static struct i2c_reg_u16 mt9m001_init[] = {
1075         {0x0d, 0x0001},
1076         {0x0d, 0x0000},
1077         {0x04, 0x0500},         /* hres = 1280 */
1078         {0x03, 0x0400},         /* vres = 1024 */
1079         {0x20, 0x1100},
1080         {0x06, 0x0010},
1081         {0x2b, 0x0024},
1082         {0x2e, 0x0024},
1083         {0x35, 0x0024},
1084         {0x2d, 0x0020},
1085         {0x2c, 0x0020},
1086         {0x09, 0x0ad4},
1087         {0x35, 0x0057},
1088 };
1089
1090 static struct i2c_reg_u16 mt9m111_init[] = {
1091         {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0008},
1092         {0xf0, 0x0001}, {0x3a, 0x4300}, {0x9b, 0x4300},
1093         {0x06, 0x708e}, {0xf0, 0x0002}, {0x2e, 0x0a1e},
1094         {0xf0, 0x0000},
1095 };
1096
1097 static struct i2c_reg_u16 mt9m112_init[] = {
1098         {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0008},
1099         {0xf0, 0x0001}, {0x3a, 0x4300}, {0x9b, 0x4300},
1100         {0x06, 0x708e}, {0xf0, 0x0002}, {0x2e, 0x0a1e},
1101         {0xf0, 0x0000},
1102 };
1103
1104 static struct i2c_reg_u8 hv7131r_init[] = {
1105         {0x02, 0x08}, {0x02, 0x00}, {0x01, 0x08},
1106         {0x02, 0x00}, {0x20, 0x00}, {0x21, 0xd0},
1107         {0x22, 0x00}, {0x23, 0x09}, {0x01, 0x08},
1108         {0x01, 0x08}, {0x01, 0x08}, {0x25, 0x07},
1109         {0x26, 0xc3}, {0x27, 0x50}, {0x30, 0x62},
1110         {0x31, 0x10}, {0x32, 0x06}, {0x33, 0x10},
1111         {0x20, 0x00}, {0x21, 0xd0}, {0x22, 0x00},
1112         {0x23, 0x09}, {0x01, 0x08},
1113 };
1114
1115 static int reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length)
1116 {
1117         struct usb_device *dev = gspca_dev->dev;
1118         int result;
1119         result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1120                         0x00,
1121                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1122                         reg,
1123                         0x00,
1124                         gspca_dev->usb_buf,
1125                         length,
1126                         500);
1127         if (unlikely(result < 0 || result != length)) {
1128                 pr_err("Read register failed 0x%02X\n", reg);
1129                 return -EIO;
1130         }
1131         return 0;
1132 }
1133
1134 static int reg_w(struct gspca_dev *gspca_dev, u16 reg,
1135                  const u8 *buffer, int length)
1136 {
1137         struct usb_device *dev = gspca_dev->dev;
1138         int result;
1139         memcpy(gspca_dev->usb_buf, buffer, length);
1140         result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1141                         0x08,
1142                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1143                         reg,
1144                         0x00,
1145                         gspca_dev->usb_buf,
1146                         length,
1147                         500);
1148         if (unlikely(result < 0 || result != length)) {
1149                 pr_err("Write register failed index 0x%02X\n", reg);
1150                 return -EIO;
1151         }
1152         return 0;
1153 }
1154
1155 static int reg_w1(struct gspca_dev *gspca_dev, u16 reg, const u8 value)
1156 {
1157         u8 data[1] = {value};
1158         return reg_w(gspca_dev, reg, data, 1);
1159 }
1160
1161 static int i2c_w(struct gspca_dev *gspca_dev, const u8 *buffer)
1162 {
1163         int i;
1164         reg_w(gspca_dev, 0x10c0, buffer, 8);
1165         for (i = 0; i < 5; i++) {
1166                 reg_r(gspca_dev, 0x10c0, 1);
1167                 if (gspca_dev->usb_buf[0] & 0x04) {
1168                         if (gspca_dev->usb_buf[0] & 0x08)
1169                                 return -EIO;
1170                         return 0;
1171                 }
1172                 msleep(1);
1173         }
1174         return -EIO;
1175 }
1176
1177 static int i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
1178 {
1179         struct sd *sd = (struct sd *) gspca_dev;
1180
1181         u8 row[8];
1182
1183         /*
1184          * from the point of view of the bridge, the length
1185          * includes the address
1186          */
1187         row[0] = 0x81 | (2 << 4);
1188         row[1] = sd->i2c_addr;
1189         row[2] = reg;
1190         row[3] = val;
1191         row[4] = 0x00;
1192         row[5] = 0x00;
1193         row[6] = 0x00;
1194         row[7] = 0x10;
1195
1196         return i2c_w(gspca_dev, row);
1197 }
1198
1199 static int i2c_w2(struct gspca_dev *gspca_dev, u8 reg, u16 val)
1200 {
1201         struct sd *sd = (struct sd *) gspca_dev;
1202         u8 row[8];
1203
1204         /*
1205          * from the point of view of the bridge, the length
1206          * includes the address
1207          */
1208         row[0] = 0x81 | (3 << 4);
1209         row[1] = sd->i2c_addr;
1210         row[2] = reg;
1211         row[3] = (val >> 8) & 0xff;
1212         row[4] = val & 0xff;
1213         row[5] = 0x00;
1214         row[6] = 0x00;
1215         row[7] = 0x10;
1216
1217         return i2c_w(gspca_dev, row);
1218 }
1219
1220 static int i2c_r1(struct gspca_dev *gspca_dev, u8 reg, u8 *val)
1221 {
1222         struct sd *sd = (struct sd *) gspca_dev;
1223         u8 row[8];
1224
1225         row[0] = 0x81 | (1 << 4);
1226         row[1] = sd->i2c_addr;
1227         row[2] = reg;
1228         row[3] = 0;
1229         row[4] = 0;
1230         row[5] = 0;
1231         row[6] = 0;
1232         row[7] = 0x10;
1233         if (i2c_w(gspca_dev, row) < 0)
1234                 return -EIO;
1235         row[0] = 0x81 | (1 << 4) | 0x02;
1236         row[2] = 0;
1237         if (i2c_w(gspca_dev, row) < 0)
1238                 return -EIO;
1239         if (reg_r(gspca_dev, 0x10c2, 5) < 0)
1240                 return -EIO;
1241         *val = gspca_dev->usb_buf[4];
1242         return 0;
1243 }
1244
1245 static int i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val)
1246 {
1247         struct sd *sd = (struct sd *) gspca_dev;
1248         u8 row[8];
1249
1250         row[0] = 0x81 | (1 << 4);
1251         row[1] = sd->i2c_addr;
1252         row[2] = reg;
1253         row[3] = 0;
1254         row[4] = 0;
1255         row[5] = 0;
1256         row[6] = 0;
1257         row[7] = 0x10;
1258         if (i2c_w(gspca_dev, row) < 0)
1259                 return -EIO;
1260         row[0] = 0x81 | (2 << 4) | 0x02;
1261         row[2] = 0;
1262         if (i2c_w(gspca_dev, row) < 0)
1263                 return -EIO;
1264         if (reg_r(gspca_dev, 0x10c2, 5) < 0)
1265                 return -EIO;
1266         *val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
1267         return 0;
1268 }
1269
1270 static int ov9650_init_sensor(struct gspca_dev *gspca_dev)
1271 {
1272         int i;
1273         u16 id;
1274         struct sd *sd = (struct sd *) gspca_dev;
1275
1276         if (i2c_r2(gspca_dev, 0x1c, &id) < 0)
1277                 return -EINVAL;
1278
1279         if (id != 0x7fa2) {
1280                 pr_err("sensor id for ov9650 doesn't match (0x%04x)\n", id);
1281                 return -ENODEV;
1282         }
1283
1284         for (i = 0; i < ARRAY_SIZE(ov9650_init); i++) {
1285                 if (i2c_w1(gspca_dev, ov9650_init[i].reg,
1286                                 ov9650_init[i].val) < 0) {
1287                         pr_err("OV9650 sensor initialization failed\n");
1288                         return -ENODEV;
1289                 }
1290         }
1291         sd->hstart = 1;
1292         sd->vstart = 7;
1293         return 0;
1294 }
1295
1296 static int ov9655_init_sensor(struct gspca_dev *gspca_dev)
1297 {
1298         int i;
1299         struct sd *sd = (struct sd *) gspca_dev;
1300
1301         for (i = 0; i < ARRAY_SIZE(ov9655_init); i++) {
1302                 if (i2c_w1(gspca_dev, ov9655_init[i].reg,
1303                                 ov9655_init[i].val) < 0) {
1304                         pr_err("OV9655 sensor initialization failed\n");
1305                         return -ENODEV;
1306                 }
1307         }
1308         /* disable hflip and vflip */
1309         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
1310         sd->hstart = 1;
1311         sd->vstart = 2;
1312         return 0;
1313 }
1314
1315 static int soi968_init_sensor(struct gspca_dev *gspca_dev)
1316 {
1317         int i;
1318         struct sd *sd = (struct sd *) gspca_dev;
1319
1320         for (i = 0; i < ARRAY_SIZE(soi968_init); i++) {
1321                 if (i2c_w1(gspca_dev, soi968_init[i].reg,
1322                                 soi968_init[i].val) < 0) {
1323                         pr_err("SOI968 sensor initialization failed\n");
1324                         return -ENODEV;
1325                 }
1326         }
1327         /* disable hflip and vflip */
1328         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX)
1329                                 | (1 << EXPOSURE_IDX);
1330         sd->hstart = 60;
1331         sd->vstart = 11;
1332         return 0;
1333 }
1334
1335 static int ov7660_init_sensor(struct gspca_dev *gspca_dev)
1336 {
1337         int i;
1338         struct sd *sd = (struct sd *) gspca_dev;
1339
1340         for (i = 0; i < ARRAY_SIZE(ov7660_init); i++) {
1341                 if (i2c_w1(gspca_dev, ov7660_init[i].reg,
1342                                 ov7660_init[i].val) < 0) {
1343                         pr_err("OV7660 sensor initialization failed\n");
1344                         return -ENODEV;
1345                 }
1346         }
1347         sd->hstart = 3;
1348         sd->vstart = 3;
1349         return 0;
1350 }
1351
1352 static int ov7670_init_sensor(struct gspca_dev *gspca_dev)
1353 {
1354         int i;
1355         struct sd *sd = (struct sd *) gspca_dev;
1356
1357         for (i = 0; i < ARRAY_SIZE(ov7670_init); i++) {
1358                 if (i2c_w1(gspca_dev, ov7670_init[i].reg,
1359                                 ov7670_init[i].val) < 0) {
1360                         pr_err("OV7670 sensor initialization failed\n");
1361                         return -ENODEV;
1362                 }
1363         }
1364         /* disable hflip and vflip */
1365         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
1366         sd->hstart = 0;
1367         sd->vstart = 1;
1368         return 0;
1369 }
1370
1371 static int mt9v_init_sensor(struct gspca_dev *gspca_dev)
1372 {
1373         struct sd *sd = (struct sd *) gspca_dev;
1374         int i;
1375         u16 value;
1376         int ret;
1377
1378         sd->i2c_addr = 0x5d;
1379         ret = i2c_r2(gspca_dev, 0xff, &value);
1380         if ((ret == 0) && (value == 0x8243)) {
1381                 for (i = 0; i < ARRAY_SIZE(mt9v011_init); i++) {
1382                         if (i2c_w2(gspca_dev, mt9v011_init[i].reg,
1383                                         mt9v011_init[i].val) < 0) {
1384                                 pr_err("MT9V011 sensor initialization failed\n");
1385                                 return -ENODEV;
1386                         }
1387                 }
1388                 sd->hstart = 2;
1389                 sd->vstart = 2;
1390                 sd->sensor = SENSOR_MT9V011;
1391                 pr_info("MT9V011 sensor detected\n");
1392                 return 0;
1393         }
1394
1395         sd->i2c_addr = 0x5c;
1396         i2c_w2(gspca_dev, 0x01, 0x0004);
1397         ret = i2c_r2(gspca_dev, 0xff, &value);
1398         if ((ret == 0) && (value == 0x823a)) {
1399                 for (i = 0; i < ARRAY_SIZE(mt9v111_init); i++) {
1400                         if (i2c_w2(gspca_dev, mt9v111_init[i].reg,
1401                                         mt9v111_init[i].val) < 0) {
1402                                 pr_err("MT9V111 sensor initialization failed\n");
1403                                 return -ENODEV;
1404                         }
1405                 }
1406                 gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX)
1407                                         | (1 << AUTOGAIN_IDX)
1408                                         | (1 << GAIN_IDX);
1409                 sd->hstart = 2;
1410                 sd->vstart = 2;
1411                 sd->sensor = SENSOR_MT9V111;
1412                 pr_info("MT9V111 sensor detected\n");
1413                 return 0;
1414         }
1415
1416         sd->i2c_addr = 0x5d;
1417         ret = i2c_w2(gspca_dev, 0xf0, 0x0000);
1418         if (ret < 0) {
1419                 sd->i2c_addr = 0x48;
1420                 i2c_w2(gspca_dev, 0xf0, 0x0000);
1421         }
1422         ret = i2c_r2(gspca_dev, 0x00, &value);
1423         if ((ret == 0) && (value == 0x1229)) {
1424                 for (i = 0; i < ARRAY_SIZE(mt9v112_init); i++) {
1425                         if (i2c_w2(gspca_dev, mt9v112_init[i].reg,
1426                                         mt9v112_init[i].val) < 0) {
1427                                 pr_err("MT9V112 sensor initialization failed\n");
1428                                 return -ENODEV;
1429                         }
1430                 }
1431                 sd->hstart = 6;
1432                 sd->vstart = 2;
1433                 sd->sensor = SENSOR_MT9V112;
1434                 pr_info("MT9V112 sensor detected\n");
1435                 return 0;
1436         }
1437
1438         return -ENODEV;
1439 }
1440
1441 static int mt9m112_init_sensor(struct gspca_dev *gspca_dev)
1442 {
1443         struct sd *sd = (struct sd *) gspca_dev;
1444         int i;
1445         for (i = 0; i < ARRAY_SIZE(mt9m112_init); i++) {
1446                 if (i2c_w2(gspca_dev, mt9m112_init[i].reg,
1447                                 mt9m112_init[i].val) < 0) {
1448                         pr_err("MT9M112 sensor initialization failed\n");
1449                         return -ENODEV;
1450                 }
1451         }
1452         gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX)
1453                                 | (1 << GAIN_IDX);
1454         sd->hstart = 0;
1455         sd->vstart = 2;
1456         return 0;
1457 }
1458
1459 static int mt9m111_init_sensor(struct gspca_dev *gspca_dev)
1460 {
1461         struct sd *sd = (struct sd *) gspca_dev;
1462         int i;
1463         for (i = 0; i < ARRAY_SIZE(mt9m111_init); i++) {
1464                 if (i2c_w2(gspca_dev, mt9m111_init[i].reg,
1465                                 mt9m111_init[i].val) < 0) {
1466                         pr_err("MT9M111 sensor initialization failed\n");
1467                         return -ENODEV;
1468                 }
1469         }
1470         gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX)
1471                                 | (1 << GAIN_IDX);
1472         sd->hstart = 0;
1473         sd->vstart = 2;
1474         return 0;
1475 }
1476
1477 static int mt9m001_init_sensor(struct gspca_dev *gspca_dev)
1478 {
1479         struct sd *sd = (struct sd *) gspca_dev;
1480         int i;
1481         u16 id;
1482
1483         if (i2c_r2(gspca_dev, 0x00, &id) < 0)
1484                 return -EINVAL;
1485
1486         /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
1487         switch (id) {
1488         case 0x8411:
1489         case 0x8421:
1490                 pr_info("MT9M001 color sensor detected\n");
1491                 break;
1492         case 0x8431:
1493                 pr_info("MT9M001 mono sensor detected\n");
1494                 break;
1495         default:
1496                 pr_err("No MT9M001 chip detected, ID = %x\n\n", id);
1497                 return -ENODEV;
1498         }
1499
1500         for (i = 0; i < ARRAY_SIZE(mt9m001_init); i++) {
1501                 if (i2c_w2(gspca_dev, mt9m001_init[i].reg,
1502                                 mt9m001_init[i].val) < 0) {
1503                         pr_err("MT9M001 sensor initialization failed\n");
1504                         return -ENODEV;
1505                 }
1506         }
1507         /* disable hflip and vflip */
1508         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
1509         sd->hstart = 1;
1510         sd->vstart = 1;
1511         return 0;
1512 }
1513
1514 static int hv7131r_init_sensor(struct gspca_dev *gspca_dev)
1515 {
1516         int i;
1517         struct sd *sd = (struct sd *) gspca_dev;
1518
1519         for (i = 0; i < ARRAY_SIZE(hv7131r_init); i++) {
1520                 if (i2c_w1(gspca_dev, hv7131r_init[i].reg,
1521                                 hv7131r_init[i].val) < 0) {
1522                         pr_err("HV7131R Sensor initialization failed\n");
1523                         return -ENODEV;
1524                 }
1525         }
1526         sd->hstart = 0;
1527         sd->vstart = 1;
1528         return 0;
1529 }
1530
1531 static int set_cmatrix(struct gspca_dev *gspca_dev)
1532 {
1533         struct sd *sd = (struct sd *) gspca_dev;
1534         s32 hue_coord, hue_index = 180 + sd->hue;
1535         u8 cmatrix[21];
1536
1537         memset(cmatrix, 0, sizeof cmatrix);
1538         cmatrix[2] = (sd->contrast * 0x25 / 0x100) + 0x26;
1539         cmatrix[0] = 0x13 + (cmatrix[2] - 0x26) * 0x13 / 0x25;
1540         cmatrix[4] = 0x07 + (cmatrix[2] - 0x26) * 0x07 / 0x25;
1541         cmatrix[18] = sd->brightness - 0x80;
1542
1543         hue_coord = (hsv_red_x[hue_index] * sd->saturation) >> 8;
1544         cmatrix[6] = hue_coord;
1545         cmatrix[7] = (hue_coord >> 8) & 0x0f;
1546
1547         hue_coord = (hsv_red_y[hue_index] * sd->saturation) >> 8;
1548         cmatrix[8] = hue_coord;
1549         cmatrix[9] = (hue_coord >> 8) & 0x0f;
1550
1551         hue_coord = (hsv_green_x[hue_index] * sd->saturation) >> 8;
1552         cmatrix[10] = hue_coord;
1553         cmatrix[11] = (hue_coord >> 8) & 0x0f;
1554
1555         hue_coord = (hsv_green_y[hue_index] * sd->saturation) >> 8;
1556         cmatrix[12] = hue_coord;
1557         cmatrix[13] = (hue_coord >> 8) & 0x0f;
1558
1559         hue_coord = (hsv_blue_x[hue_index] * sd->saturation) >> 8;
1560         cmatrix[14] = hue_coord;
1561         cmatrix[15] = (hue_coord >> 8) & 0x0f;
1562
1563         hue_coord = (hsv_blue_y[hue_index] * sd->saturation) >> 8;
1564         cmatrix[16] = hue_coord;
1565         cmatrix[17] = (hue_coord >> 8) & 0x0f;
1566
1567         return reg_w(gspca_dev, 0x10e1, cmatrix, 21);
1568 }
1569
1570 static int set_gamma(struct gspca_dev *gspca_dev)
1571 {
1572         struct sd *sd = (struct sd *) gspca_dev;
1573         u8 gamma[17];
1574         u8 gval = sd->gamma * 0xb8 / 0x100;
1575
1576
1577         gamma[0] = 0x0a;
1578         gamma[1] = 0x13 + (gval * (0xcb - 0x13) / 0xb8);
1579         gamma[2] = 0x25 + (gval * (0xee - 0x25) / 0xb8);
1580         gamma[3] = 0x37 + (gval * (0xfa - 0x37) / 0xb8);
1581         gamma[4] = 0x45 + (gval * (0xfc - 0x45) / 0xb8);
1582         gamma[5] = 0x55 + (gval * (0xfb - 0x55) / 0xb8);
1583         gamma[6] = 0x65 + (gval * (0xfc - 0x65) / 0xb8);
1584         gamma[7] = 0x74 + (gval * (0xfd - 0x74) / 0xb8);
1585         gamma[8] = 0x83 + (gval * (0xfe - 0x83) / 0xb8);
1586         gamma[9] = 0x92 + (gval * (0xfc - 0x92) / 0xb8);
1587         gamma[10] = 0xa1 + (gval * (0xfc - 0xa1) / 0xb8);
1588         gamma[11] = 0xb0 + (gval * (0xfc - 0xb0) / 0xb8);
1589         gamma[12] = 0xbf + (gval * (0xfb - 0xbf) / 0xb8);
1590         gamma[13] = 0xce + (gval * (0xfb - 0xce) / 0xb8);
1591         gamma[14] = 0xdf + (gval * (0xfd - 0xdf) / 0xb8);
1592         gamma[15] = 0xea + (gval * (0xf9 - 0xea) / 0xb8);
1593         gamma[16] = 0xf5;
1594
1595         return reg_w(gspca_dev, 0x1190, gamma, 17);
1596 }
1597
1598 static int set_redblue(struct gspca_dev *gspca_dev)
1599 {
1600         struct sd *sd = (struct sd *) gspca_dev;
1601         reg_w1(gspca_dev, 0x118c, sd->red);
1602         reg_w1(gspca_dev, 0x118f, sd->blue);
1603         return 0;
1604 }
1605
1606 static int set_hvflip(struct gspca_dev *gspca_dev)
1607 {
1608         u8 value, tslb, hflip, vflip;
1609         u16 value2;
1610         struct sd *sd = (struct sd *) gspca_dev;
1611
1612         if ((sd->flags & FLIP_DETECT) && dmi_check_system(flip_dmi_table)) {
1613                 hflip = !sd->hflip;
1614                 vflip = !sd->vflip;
1615         } else {
1616                 hflip = sd->hflip;
1617                 vflip = sd->vflip;
1618         }
1619
1620         switch (sd->sensor) {
1621         case SENSOR_OV7660:
1622                 value = 0x01;
1623                 if (hflip)
1624                         value |= 0x20;
1625                 if (vflip) {
1626                         value |= 0x10;
1627                         sd->vstart = 2;
1628                 } else
1629                         sd->vstart = 3;
1630                 reg_w1(gspca_dev, 0x1182, sd->vstart);
1631                 i2c_w1(gspca_dev, 0x1e, value);
1632                 break;
1633         case SENSOR_OV9650:
1634                 i2c_r1(gspca_dev, 0x1e, &value);
1635                 value &= ~0x30;
1636                 tslb = 0x01;
1637                 if (hflip)
1638                         value |= 0x20;
1639                 if (vflip) {
1640                         value |= 0x10;
1641                         tslb = 0x49;
1642                 }
1643                 i2c_w1(gspca_dev, 0x1e, value);
1644                 i2c_w1(gspca_dev, 0x3a, tslb);
1645                 break;
1646         case SENSOR_MT9V111:
1647         case SENSOR_MT9V011:
1648                 i2c_r2(gspca_dev, 0x20, &value2);
1649                 value2 &= ~0xc0a0;
1650                 if (hflip)
1651                         value2 |= 0x8080;
1652                 if (vflip)
1653                         value2 |= 0x4020;
1654                 i2c_w2(gspca_dev, 0x20, value2);
1655                 break;
1656         case SENSOR_MT9M112:
1657         case SENSOR_MT9M111:
1658         case SENSOR_MT9V112:
1659                 i2c_r2(gspca_dev, 0x20, &value2);
1660                 value2 &= ~0x0003;
1661                 if (hflip)
1662                         value2 |= 0x0002;
1663                 if (vflip)
1664                         value2 |= 0x0001;
1665                 i2c_w2(gspca_dev, 0x20, value2);
1666                 break;
1667         case SENSOR_HV7131R:
1668                 i2c_r1(gspca_dev, 0x01, &value);
1669                 value &= ~0x03;
1670                 if (vflip)
1671                         value |= 0x01;
1672                 if (hflip)
1673                         value |= 0x02;
1674                 i2c_w1(gspca_dev, 0x01, value);
1675                 break;
1676         }
1677         return 0;
1678 }
1679
1680 static int set_exposure(struct gspca_dev *gspca_dev)
1681 {
1682         struct sd *sd = (struct sd *) gspca_dev;
1683         u8 exp[8] = {0x81, sd->i2c_addr, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e};
1684         switch (sd->sensor) {
1685         case SENSOR_OV7660:
1686         case SENSOR_OV7670:
1687         case SENSOR_OV9655:
1688         case SENSOR_OV9650:
1689                 exp[0] |= (3 << 4);
1690                 exp[2] = 0x2d;
1691                 exp[3] = sd->exposure & 0xff;
1692                 exp[4] = sd->exposure >> 8;
1693                 break;
1694         case SENSOR_MT9M001:
1695         case SENSOR_MT9V112:
1696         case SENSOR_MT9V011:
1697                 exp[0] |= (3 << 4);
1698                 exp[2] = 0x09;
1699                 exp[3] = sd->exposure >> 8;
1700                 exp[4] = sd->exposure & 0xff;
1701                 break;
1702         case SENSOR_HV7131R:
1703                 exp[0] |= (4 << 4);
1704                 exp[2] = 0x25;
1705                 exp[3] = (sd->exposure >> 5) & 0xff;
1706                 exp[4] = (sd->exposure << 3) & 0xff;
1707                 exp[5] = 0;
1708                 break;
1709         default:
1710                 return 0;
1711         }
1712         i2c_w(gspca_dev, exp);
1713         return 0;
1714 }
1715
1716 static int set_gain(struct gspca_dev *gspca_dev)
1717 {
1718         struct sd *sd = (struct sd *) gspca_dev;
1719         u8 gain[8] = {0x81, sd->i2c_addr, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d};
1720         switch (sd->sensor) {
1721         case SENSOR_OV7660:
1722         case SENSOR_OV7670:
1723         case SENSOR_SOI968:
1724         case SENSOR_OV9655:
1725         case SENSOR_OV9650:
1726                 gain[0] |= (2 << 4);
1727                 gain[3] = ov_gain[sd->gain];
1728                 break;
1729         case SENSOR_MT9V011:
1730                 gain[0] |= (3 << 4);
1731                 gain[2] = 0x35;
1732                 gain[3] = micron1_gain[sd->gain] >> 8;
1733                 gain[4] = micron1_gain[sd->gain] & 0xff;
1734                 break;
1735         case SENSOR_MT9V112:
1736                 gain[0] |= (3 << 4);
1737                 gain[2] = 0x2f;
1738                 gain[3] = micron1_gain[sd->gain] >> 8;
1739                 gain[4] = micron1_gain[sd->gain] & 0xff;
1740                 break;
1741         case SENSOR_MT9M001:
1742                 gain[0] |= (3 << 4);
1743                 gain[2] = 0x2f;
1744                 gain[3] = micron2_gain[sd->gain] >> 8;
1745                 gain[4] = micron2_gain[sd->gain] & 0xff;
1746                 break;
1747         case SENSOR_HV7131R:
1748                 gain[0] |= (2 << 4);
1749                 gain[2] = 0x30;
1750                 gain[3] = hv7131r_gain[sd->gain];
1751                 break;
1752         default:
1753                 return 0;
1754         }
1755         i2c_w(gspca_dev, gain);
1756         return 0;
1757 }
1758
1759 static int sd_setbrightness(struct gspca_dev *gspca_dev, s32 val)
1760 {
1761         struct sd *sd = (struct sd *) gspca_dev;
1762
1763         sd->brightness = val;
1764         if (gspca_dev->streaming)
1765                 return set_cmatrix(gspca_dev);
1766         return 0;
1767 }
1768
1769 static int sd_getbrightness(struct gspca_dev *gspca_dev, s32 *val)
1770 {
1771         struct sd *sd = (struct sd *) gspca_dev;
1772         *val = sd->brightness;
1773         return 0;
1774 }
1775
1776
1777 static int sd_setcontrast(struct gspca_dev *gspca_dev, s32 val)
1778 {
1779         struct sd *sd = (struct sd *) gspca_dev;
1780
1781         sd->contrast = val;
1782         if (gspca_dev->streaming)
1783                 return set_cmatrix(gspca_dev);
1784         return 0;
1785 }
1786
1787 static int sd_getcontrast(struct gspca_dev *gspca_dev, s32 *val)
1788 {
1789         struct sd *sd = (struct sd *) gspca_dev;
1790         *val = sd->contrast;
1791         return 0;
1792 }
1793
1794 static int sd_setsaturation(struct gspca_dev *gspca_dev, s32 val)
1795 {
1796         struct sd *sd = (struct sd *) gspca_dev;
1797
1798         sd->saturation = val;
1799         if (gspca_dev->streaming)
1800                 return set_cmatrix(gspca_dev);
1801         return 0;
1802 }
1803
1804 static int sd_getsaturation(struct gspca_dev *gspca_dev, s32 *val)
1805 {
1806         struct sd *sd = (struct sd *) gspca_dev;
1807         *val = sd->saturation;
1808         return 0;
1809 }
1810
1811 static int sd_sethue(struct gspca_dev *gspca_dev, s32 val)
1812 {
1813         struct sd *sd = (struct sd *) gspca_dev;
1814
1815         sd->hue = val;
1816         if (gspca_dev->streaming)
1817                 return set_cmatrix(gspca_dev);
1818         return 0;
1819 }
1820
1821 static int sd_gethue(struct gspca_dev *gspca_dev, s32 *val)
1822 {
1823         struct sd *sd = (struct sd *) gspca_dev;
1824         *val = sd->hue;
1825         return 0;
1826 }
1827
1828 static int sd_setgamma(struct gspca_dev *gspca_dev, s32 val)
1829 {
1830         struct sd *sd = (struct sd *) gspca_dev;
1831
1832         sd->gamma = val;
1833         if (gspca_dev->streaming)
1834                 return set_gamma(gspca_dev);
1835         return 0;
1836 }
1837
1838 static int sd_getgamma(struct gspca_dev *gspca_dev, s32 *val)
1839 {
1840         struct sd *sd = (struct sd *) gspca_dev;
1841         *val = sd->gamma;
1842         return 0;
1843 }
1844
1845 static int sd_setredbalance(struct gspca_dev *gspca_dev, s32 val)
1846 {
1847         struct sd *sd = (struct sd *) gspca_dev;
1848
1849         sd->red = val;
1850         if (gspca_dev->streaming)
1851                 return set_redblue(gspca_dev);
1852         return 0;
1853 }
1854
1855 static int sd_getredbalance(struct gspca_dev *gspca_dev, s32 *val)
1856 {
1857         struct sd *sd = (struct sd *) gspca_dev;
1858         *val = sd->red;
1859         return 0;
1860 }
1861
1862 static int sd_setbluebalance(struct gspca_dev *gspca_dev, s32 val)
1863 {
1864         struct sd *sd = (struct sd *) gspca_dev;
1865
1866         sd->blue = val;
1867         if (gspca_dev->streaming)
1868                 return set_redblue(gspca_dev);
1869         return 0;
1870 }
1871
1872 static int sd_getbluebalance(struct gspca_dev *gspca_dev, s32 *val)
1873 {
1874         struct sd *sd = (struct sd *) gspca_dev;
1875         *val = sd->blue;
1876         return 0;
1877 }
1878
1879 static int sd_sethflip(struct gspca_dev *gspca_dev, s32 val)
1880 {
1881         struct sd *sd = (struct sd *) gspca_dev;
1882
1883         sd->hflip = val;
1884         if (gspca_dev->streaming)
1885                 return set_hvflip(gspca_dev);
1886         return 0;
1887 }
1888
1889 static int sd_gethflip(struct gspca_dev *gspca_dev, s32 *val)
1890 {
1891         struct sd *sd = (struct sd *) gspca_dev;
1892         *val = sd->hflip;
1893         return 0;
1894 }
1895
1896 static int sd_setvflip(struct gspca_dev *gspca_dev, s32 val)
1897 {
1898         struct sd *sd = (struct sd *) gspca_dev;
1899
1900         sd->vflip = val;
1901         if (gspca_dev->streaming)
1902                 return set_hvflip(gspca_dev);
1903         return 0;
1904 }
1905
1906 static int sd_getvflip(struct gspca_dev *gspca_dev, s32 *val)
1907 {
1908         struct sd *sd = (struct sd *) gspca_dev;
1909         *val = sd->vflip;
1910         return 0;
1911 }
1912
1913 static int sd_setexposure(struct gspca_dev *gspca_dev, s32 val)
1914 {
1915         struct sd *sd = (struct sd *) gspca_dev;
1916
1917         sd->exposure = val;
1918         if (gspca_dev->streaming)
1919                 return set_exposure(gspca_dev);
1920         return 0;
1921 }
1922
1923 static int sd_getexposure(struct gspca_dev *gspca_dev, s32 *val)
1924 {
1925         struct sd *sd = (struct sd *) gspca_dev;
1926         *val = sd->exposure;
1927         return 0;
1928 }
1929
1930 static int sd_setgain(struct gspca_dev *gspca_dev, s32 val)
1931 {
1932         struct sd *sd = (struct sd *) gspca_dev;
1933
1934         sd->gain = val;
1935         if (gspca_dev->streaming)
1936                 return set_gain(gspca_dev);
1937         return 0;
1938 }
1939
1940 static int sd_getgain(struct gspca_dev *gspca_dev, s32 *val)
1941 {
1942         struct sd *sd = (struct sd *) gspca_dev;
1943         *val = sd->gain;
1944         return 0;
1945 }
1946
1947 static int sd_setautoexposure(struct gspca_dev *gspca_dev, s32 val)
1948 {
1949         struct sd *sd = (struct sd *) gspca_dev;
1950         sd->auto_exposure = val;
1951         return 0;
1952 }
1953
1954 static int sd_getautoexposure(struct gspca_dev *gspca_dev, s32 *val)
1955 {
1956         struct sd *sd = (struct sd *) gspca_dev;
1957         *val = sd->auto_exposure;
1958         return 0;
1959 }
1960
1961 #ifdef CONFIG_VIDEO_ADV_DEBUG
1962 static int sd_dbg_g_register(struct gspca_dev *gspca_dev,
1963                         struct v4l2_dbg_register *reg)
1964 {
1965         struct sd *sd = (struct sd *) gspca_dev;
1966         switch (reg->match.type) {
1967         case V4L2_CHIP_MATCH_HOST:
1968                 if (reg->match.addr != 0)
1969                         return -EINVAL;
1970                 if (reg->reg < 0x1000 || reg->reg > 0x11ff)
1971                         return -EINVAL;
1972                 if (reg_r(gspca_dev, reg->reg, 1) < 0)
1973                         return -EINVAL;
1974                 reg->val = gspca_dev->usb_buf[0];
1975                 return 0;
1976         case V4L2_CHIP_MATCH_I2C_ADDR:
1977                 if (reg->match.addr != sd->i2c_addr)
1978                         return -EINVAL;
1979                 if (sd->sensor >= SENSOR_MT9V011 &&
1980                     sd->sensor <= SENSOR_MT9M112) {
1981                         if (i2c_r2(gspca_dev, reg->reg, (u16 *)&reg->val) < 0)
1982                                 return -EINVAL;
1983                 } else {
1984                         if (i2c_r1(gspca_dev, reg->reg, (u8 *)&reg->val) < 0)
1985                                 return -EINVAL;
1986                 }
1987                 return 0;
1988         }
1989         return -EINVAL;
1990 }
1991
1992 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
1993                         struct v4l2_dbg_register *reg)
1994 {
1995         struct sd *sd = (struct sd *) gspca_dev;
1996         switch (reg->match.type) {
1997         case V4L2_CHIP_MATCH_HOST:
1998                 if (reg->match.addr != 0)
1999                         return -EINVAL;
2000                 if (reg->reg < 0x1000 || reg->reg > 0x11ff)
2001                         return -EINVAL;
2002                 if (reg_w1(gspca_dev, reg->reg, reg->val) < 0)
2003                         return -EINVAL;
2004                 return 0;
2005         case V4L2_CHIP_MATCH_I2C_ADDR:
2006                 if (reg->match.addr != sd->i2c_addr)
2007                         return -EINVAL;
2008                 if (sd->sensor >= SENSOR_MT9V011 &&
2009                     sd->sensor <= SENSOR_MT9M112) {
2010                         if (i2c_w2(gspca_dev, reg->reg, reg->val) < 0)
2011                                 return -EINVAL;
2012                 } else {
2013                         if (i2c_w1(gspca_dev, reg->reg, reg->val) < 0)
2014                                 return -EINVAL;
2015                 }
2016                 return 0;
2017         }
2018         return -EINVAL;
2019 }
2020 #endif
2021
2022 static int sd_chip_ident(struct gspca_dev *gspca_dev,
2023                         struct v4l2_dbg_chip_ident *chip)
2024 {
2025         struct sd *sd = (struct sd *) gspca_dev;
2026
2027         switch (chip->match.type) {
2028         case V4L2_CHIP_MATCH_HOST:
2029                 if (chip->match.addr != 0)
2030                         return -EINVAL;
2031                 chip->revision = 0;
2032                 chip->ident = V4L2_IDENT_SN9C20X;
2033                 return 0;
2034         case V4L2_CHIP_MATCH_I2C_ADDR:
2035                 if (chip->match.addr != sd->i2c_addr)
2036                         return -EINVAL;
2037                 chip->revision = 0;
2038                 chip->ident = i2c_ident[sd->sensor];
2039                 return 0;
2040         }
2041         return -EINVAL;
2042 }
2043
2044 static int sd_config(struct gspca_dev *gspca_dev,
2045                         const struct usb_device_id *id)
2046 {
2047         struct sd *sd = (struct sd *) gspca_dev;
2048         struct cam *cam;
2049
2050         cam = &gspca_dev->cam;
2051         cam->needs_full_bandwidth = 1;
2052
2053         sd->sensor = (id->driver_info >> 8) & 0xff;
2054         sd->i2c_addr = id->driver_info & 0xff;
2055         sd->flags = (id->driver_info >> 16) & 0xff;
2056
2057         switch (sd->sensor) {
2058         case SENSOR_MT9M112:
2059         case SENSOR_MT9M111:
2060         case SENSOR_OV9650:
2061         case SENSOR_SOI968:
2062                 cam->cam_mode = sxga_mode;
2063                 cam->nmodes = ARRAY_SIZE(sxga_mode);
2064                 break;
2065         case SENSOR_MT9M001:
2066                 cam->cam_mode = mono_mode;
2067                 cam->nmodes = ARRAY_SIZE(mono_mode);
2068                 break;
2069         default:
2070                 cam->cam_mode = vga_mode;
2071                 cam->nmodes = ARRAY_SIZE(vga_mode);
2072                 break;
2073         }
2074
2075         sd->old_step = 0;
2076         sd->older_step = 0;
2077         sd->exposure_step = 16;
2078
2079         sd->brightness = BRIGHTNESS_DEFAULT;
2080         sd->contrast = CONTRAST_DEFAULT;
2081         sd->saturation = SATURATION_DEFAULT;
2082         sd->hue = HUE_DEFAULT;
2083         sd->gamma = GAMMA_DEFAULT;
2084         sd->red = RED_DEFAULT;
2085         sd->blue = BLUE_DEFAULT;
2086
2087         sd->hflip = HFLIP_DEFAULT;
2088         sd->vflip = VFLIP_DEFAULT;
2089         sd->exposure = EXPOSURE_DEFAULT;
2090         sd->gain = GAIN_DEFAULT;
2091         sd->auto_exposure = AUTO_EXPOSURE_DEFAULT;
2092
2093         sd->quality = 95;
2094
2095         return 0;
2096 }
2097
2098 static int sd_init(struct gspca_dev *gspca_dev)
2099 {
2100         struct sd *sd = (struct sd *) gspca_dev;
2101         int i;
2102         u8 value;
2103         u8 i2c_init[9] =
2104                 {0x80, sd->i2c_addr, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03};
2105
2106         for (i = 0; i < ARRAY_SIZE(bridge_init); i++) {
2107                 value = bridge_init[i][1];
2108                 if (reg_w(gspca_dev, bridge_init[i][0], &value, 1) < 0) {
2109                         pr_err("Device initialization failed\n");
2110                         return -ENODEV;
2111                 }
2112         }
2113
2114         if (sd->flags & LED_REVERSE)
2115                 reg_w1(gspca_dev, 0x1006, 0x00);
2116         else
2117                 reg_w1(gspca_dev, 0x1006, 0x20);
2118
2119         if (reg_w(gspca_dev, 0x10c0, i2c_init, 9) < 0) {
2120                 pr_err("Device initialization failed\n");
2121                 return -ENODEV;
2122         }
2123
2124         switch (sd->sensor) {
2125         case SENSOR_OV9650:
2126                 if (ov9650_init_sensor(gspca_dev) < 0)
2127                         return -ENODEV;
2128                 pr_info("OV9650 sensor detected\n");
2129                 break;
2130         case SENSOR_OV9655:
2131                 if (ov9655_init_sensor(gspca_dev) < 0)
2132                         return -ENODEV;
2133                 pr_info("OV9655 sensor detected\n");
2134                 break;
2135         case SENSOR_SOI968:
2136                 if (soi968_init_sensor(gspca_dev) < 0)
2137                         return -ENODEV;
2138                 pr_info("SOI968 sensor detected\n");
2139                 break;
2140         case SENSOR_OV7660:
2141                 if (ov7660_init_sensor(gspca_dev) < 0)
2142                         return -ENODEV;
2143                 pr_info("OV7660 sensor detected\n");
2144                 break;
2145         case SENSOR_OV7670:
2146                 if (ov7670_init_sensor(gspca_dev) < 0)
2147                         return -ENODEV;
2148                 pr_info("OV7670 sensor detected\n");
2149                 break;
2150         case SENSOR_MT9VPRB:
2151                 if (mt9v_init_sensor(gspca_dev) < 0)
2152                         return -ENODEV;
2153                 break;
2154         case SENSOR_MT9M111:
2155                 if (mt9m111_init_sensor(gspca_dev) < 0)
2156                         return -ENODEV;
2157                 pr_info("MT9M111 sensor detected\n");
2158                 break;
2159         case SENSOR_MT9M112:
2160                 if (mt9m112_init_sensor(gspca_dev) < 0)
2161                         return -ENODEV;
2162                 pr_info("MT9M112 sensor detected\n");
2163                 break;
2164         case SENSOR_MT9M001:
2165                 if (mt9m001_init_sensor(gspca_dev) < 0)
2166                         return -ENODEV;
2167                 break;
2168         case SENSOR_HV7131R:
2169                 if (hv7131r_init_sensor(gspca_dev) < 0)
2170                         return -ENODEV;
2171                 pr_info("HV7131R sensor detected\n");
2172                 break;
2173         default:
2174                 pr_info("Unsupported Sensor\n");
2175                 return -ENODEV;
2176         }
2177
2178         return 0;
2179 }
2180
2181 static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode)
2182 {
2183         struct sd *sd = (struct sd *) gspca_dev;
2184         u8 value;
2185         switch (sd->sensor) {
2186         case SENSOR_SOI968:
2187                 if (mode & MODE_SXGA) {
2188                         i2c_w1(gspca_dev, 0x17, 0x1d);
2189                         i2c_w1(gspca_dev, 0x18, 0xbd);
2190                         i2c_w1(gspca_dev, 0x19, 0x01);
2191                         i2c_w1(gspca_dev, 0x1a, 0x81);
2192                         i2c_w1(gspca_dev, 0x12, 0x00);
2193                         sd->hstart = 140;
2194                         sd->vstart = 19;
2195                 } else {
2196                         i2c_w1(gspca_dev, 0x17, 0x13);
2197                         i2c_w1(gspca_dev, 0x18, 0x63);
2198                         i2c_w1(gspca_dev, 0x19, 0x01);
2199                         i2c_w1(gspca_dev, 0x1a, 0x79);
2200                         i2c_w1(gspca_dev, 0x12, 0x40);
2201                         sd->hstart = 60;
2202                         sd->vstart = 11;
2203                 }
2204                 break;
2205         case SENSOR_OV9650:
2206                 if (mode & MODE_SXGA) {
2207                         i2c_w1(gspca_dev, 0x17, 0x1b);
2208                         i2c_w1(gspca_dev, 0x18, 0xbc);
2209                         i2c_w1(gspca_dev, 0x19, 0x01);
2210                         i2c_w1(gspca_dev, 0x1a, 0x82);
2211                         i2c_r1(gspca_dev, 0x12, &value);
2212                         i2c_w1(gspca_dev, 0x12, value & 0x07);
2213                 } else {
2214                         i2c_w1(gspca_dev, 0x17, 0x24);
2215                         i2c_w1(gspca_dev, 0x18, 0xc5);
2216                         i2c_w1(gspca_dev, 0x19, 0x00);
2217                         i2c_w1(gspca_dev, 0x1a, 0x3c);
2218                         i2c_r1(gspca_dev, 0x12, &value);
2219                         i2c_w1(gspca_dev, 0x12, (value & 0x7) | 0x40);
2220                 }
2221                 break;
2222         case SENSOR_MT9M112:
2223         case SENSOR_MT9M111:
2224                 if (mode & MODE_SXGA) {
2225                         i2c_w2(gspca_dev, 0xf0, 0x0002);
2226                         i2c_w2(gspca_dev, 0xc8, 0x970b);
2227                         i2c_w2(gspca_dev, 0xf0, 0x0000);
2228                 } else {
2229                         i2c_w2(gspca_dev, 0xf0, 0x0002);
2230                         i2c_w2(gspca_dev, 0xc8, 0x8000);
2231                         i2c_w2(gspca_dev, 0xf0, 0x0000);
2232                 }
2233                 break;
2234         }
2235 }
2236
2237 static int sd_isoc_init(struct gspca_dev *gspca_dev)
2238 {
2239         struct usb_interface *intf;
2240         u32 flags = gspca_dev->cam.cam_mode[(int)gspca_dev->curr_mode].priv;
2241
2242         /*
2243          * When using the SN9C20X_I420 fmt the sn9c20x needs more bandwidth
2244          * than our regular bandwidth calculations reserve, so we force the
2245          * use of a specific altsetting when using the SN9C20X_I420 fmt.
2246          */
2247         if (!(flags & (MODE_RAW | MODE_JPEG))) {
2248                 intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
2249
2250                 if (intf->num_altsetting != 9) {
2251                         pr_warn("sn9c20x camera with unknown number of alt "
2252                                 "settings (%d), please report!\n",
2253                                 intf->num_altsetting);
2254                         gspca_dev->alt = intf->num_altsetting;
2255                         return 0;
2256                 }
2257
2258                 switch (gspca_dev->width) {
2259                 case 160: /* 160x120 */
2260                         gspca_dev->alt = 2;
2261                         break;
2262                 case 320: /* 320x240 */
2263                         gspca_dev->alt = 6;
2264                         break;
2265                 default:  /* >= 640x480 */
2266                         gspca_dev->alt = 9;
2267                 }
2268         }
2269
2270         return 0;
2271 }
2272
2273 #define HW_WIN(mode, hstart, vstart) \
2274 ((const u8 []){hstart, 0, vstart, 0, \
2275 (mode & MODE_SXGA ? 1280 >> 4 : 640 >> 4), \
2276 (mode & MODE_SXGA ? 1024 >> 3 : 480 >> 3)})
2277
2278 #define CLR_WIN(width, height) \
2279 ((const u8 [])\
2280 {0, width >> 2, 0, height >> 1,\
2281 ((width >> 10) & 0x01) | ((height >> 8) & 0x6)})
2282
2283 static int sd_start(struct gspca_dev *gspca_dev)
2284 {
2285         struct sd *sd = (struct sd *) gspca_dev;
2286         int mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
2287         int width = gspca_dev->width;
2288         int height = gspca_dev->height;
2289         u8 fmt, scale = 0;
2290
2291         jpeg_define(sd->jpeg_hdr, height, width,
2292                         0x21);
2293         jpeg_set_qual(sd->jpeg_hdr, sd->quality);
2294
2295         if (mode & MODE_RAW)
2296                 fmt = 0x2d;
2297         else if (mode & MODE_JPEG)
2298                 fmt = 0x2c;
2299         else
2300                 fmt = 0x2f;     /* YUV 420 */
2301
2302         switch (mode & SCALE_MASK) {
2303         case SCALE_1280x1024:
2304                 scale = 0xc0;
2305                 pr_info("Set 1280x1024\n");
2306                 break;
2307         case SCALE_640x480:
2308                 scale = 0x80;
2309                 pr_info("Set 640x480\n");
2310                 break;
2311         case SCALE_320x240:
2312                 scale = 0x90;
2313                 pr_info("Set 320x240\n");
2314                 break;
2315         case SCALE_160x120:
2316                 scale = 0xa0;
2317                 pr_info("Set 160x120\n");
2318                 break;
2319         }
2320
2321         configure_sensor_output(gspca_dev, mode);
2322         reg_w(gspca_dev, 0x1100, &sd->jpeg_hdr[JPEG_QT0_OFFSET], 64);
2323         reg_w(gspca_dev, 0x1140, &sd->jpeg_hdr[JPEG_QT1_OFFSET], 64);
2324         reg_w(gspca_dev, 0x10fb, CLR_WIN(width, height), 5);
2325         reg_w(gspca_dev, 0x1180, HW_WIN(mode, sd->hstart, sd->vstart), 6);
2326         reg_w1(gspca_dev, 0x1189, scale);
2327         reg_w1(gspca_dev, 0x10e0, fmt);
2328
2329         set_cmatrix(gspca_dev);
2330         set_gamma(gspca_dev);
2331         set_redblue(gspca_dev);
2332         set_gain(gspca_dev);
2333         set_exposure(gspca_dev);
2334         set_hvflip(gspca_dev);
2335
2336         reg_w1(gspca_dev, 0x1007, 0x20);
2337
2338         reg_r(gspca_dev, 0x1061, 1);
2339         reg_w1(gspca_dev, 0x1061, gspca_dev->usb_buf[0] | 0x02);
2340         return 0;
2341 }
2342
2343 static void sd_stopN(struct gspca_dev *gspca_dev)
2344 {
2345         reg_w1(gspca_dev, 0x1007, 0x00);
2346
2347         reg_r(gspca_dev, 0x1061, 1);
2348         reg_w1(gspca_dev, 0x1061, gspca_dev->usb_buf[0] & ~0x02);
2349 }
2350
2351 static void do_autoexposure(struct gspca_dev *gspca_dev, u16 avg_lum)
2352 {
2353         struct sd *sd = (struct sd *) gspca_dev;
2354         s16 new_exp;
2355
2356         /*
2357          * some hardcoded values are present
2358          * like those for maximal/minimal exposure
2359          * and exposure steps
2360          */
2361         if (avg_lum < MIN_AVG_LUM) {
2362                 if (sd->exposure > 0x1770)
2363                         return;
2364
2365                 new_exp = sd->exposure + sd->exposure_step;
2366                 if (new_exp > 0x1770)
2367                         new_exp = 0x1770;
2368                 if (new_exp < 0x10)
2369                         new_exp = 0x10;
2370                 sd->exposure = new_exp;
2371                 set_exposure(gspca_dev);
2372
2373                 sd->older_step = sd->old_step;
2374                 sd->old_step = 1;
2375
2376                 if (sd->old_step ^ sd->older_step)
2377                         sd->exposure_step /= 2;
2378                 else
2379                         sd->exposure_step += 2;
2380         }
2381         if (avg_lum > MAX_AVG_LUM) {
2382                 if (sd->exposure < 0x10)
2383                         return;
2384                 new_exp = sd->exposure - sd->exposure_step;
2385                 if (new_exp > 0x1700)
2386                         new_exp = 0x1770;
2387                 if (new_exp < 0x10)
2388                         new_exp = 0x10;
2389                 sd->exposure = new_exp;
2390                 set_exposure(gspca_dev);
2391                 sd->older_step = sd->old_step;
2392                 sd->old_step = 0;
2393
2394                 if (sd->old_step ^ sd->older_step)
2395                         sd->exposure_step /= 2;
2396                 else
2397                         sd->exposure_step += 2;
2398         }
2399 }
2400
2401 static void do_autogain(struct gspca_dev *gspca_dev, u16 avg_lum)
2402 {
2403         struct sd *sd = (struct sd *) gspca_dev;
2404
2405         if (avg_lum < MIN_AVG_LUM) {
2406                 if (sd->gain + 1 <= 28) {
2407                         sd->gain++;
2408                         set_gain(gspca_dev);
2409                 }
2410         }
2411         if (avg_lum > MAX_AVG_LUM) {
2412                 if (sd->gain > 0) {
2413                         sd->gain--;
2414                         set_gain(gspca_dev);
2415                 }
2416         }
2417 }
2418
2419 static void sd_dqcallback(struct gspca_dev *gspca_dev)
2420 {
2421         struct sd *sd = (struct sd *) gspca_dev;
2422         int avg_lum;
2423
2424         if (!sd->auto_exposure)
2425                 return;
2426
2427         avg_lum = atomic_read(&sd->avg_lum);
2428         if (sd->sensor == SENSOR_SOI968)
2429                 do_autogain(gspca_dev, avg_lum);
2430         else
2431                 do_autoexposure(gspca_dev, avg_lum);
2432 }
2433
2434 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2435 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
2436                         u8 *data,               /* interrupt packet */
2437                         int len)                /* interrupt packet length */
2438 {
2439         struct sd *sd = (struct sd *) gspca_dev;
2440         int ret = -EINVAL;
2441         if (!(sd->flags & HAS_NO_BUTTON) && len == 1) {
2442                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
2443                         input_sync(gspca_dev->input_dev);
2444                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
2445                         input_sync(gspca_dev->input_dev);
2446                         ret = 0;
2447         }
2448         return ret;
2449 }
2450 #endif
2451
2452 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
2453                         u8 *data,                       /* isoc packet */
2454                         int len)                        /* iso packet length */
2455 {
2456         struct sd *sd = (struct sd *) gspca_dev;
2457         int avg_lum;
2458         static u8 frame_header[] =
2459                 {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96};
2460         if (len == 64 && memcmp(data, frame_header, 6) == 0) {
2461                 avg_lum = ((data[35] >> 2) & 3) |
2462                            (data[20] << 2) |
2463                            (data[19] << 10);
2464                 avg_lum += ((data[35] >> 4) & 3) |
2465                             (data[22] << 2) |
2466                             (data[21] << 10);
2467                 avg_lum += ((data[35] >> 6) & 3) |
2468                             (data[24] << 2) |
2469                             (data[23] << 10);
2470                 avg_lum += (data[36] & 3) |
2471                            (data[26] << 2) |
2472                            (data[25] << 10);
2473                 avg_lum += ((data[36] >> 2) & 3) |
2474                             (data[28] << 2) |
2475                             (data[27] << 10);
2476                 avg_lum += ((data[36] >> 4) & 3) |
2477                             (data[30] << 2) |
2478                             (data[29] << 10);
2479                 avg_lum += ((data[36] >> 6) & 3) |
2480                             (data[32] << 2) |
2481                             (data[31] << 10);
2482                 avg_lum += ((data[44] >> 4) & 3) |
2483                             (data[34] << 2) |
2484                             (data[33] << 10);
2485                 avg_lum >>= 9;
2486                 atomic_set(&sd->avg_lum, avg_lum);
2487                 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
2488                 return;
2489         }
2490         if (gspca_dev->last_packet_type == LAST_PACKET) {
2491                 if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv
2492                                 & MODE_JPEG) {
2493                         gspca_frame_add(gspca_dev, FIRST_PACKET,
2494                                 sd->jpeg_hdr, JPEG_HDR_SZ);
2495                         gspca_frame_add(gspca_dev, INTER_PACKET,
2496                                 data, len);
2497                 } else {
2498                         gspca_frame_add(gspca_dev, FIRST_PACKET,
2499                                 data, len);
2500                 }
2501         } else {
2502                 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
2503         }
2504 }
2505
2506 /* sub-driver description */
2507 static const struct sd_desc sd_desc = {
2508         .name = MODULE_NAME,
2509         .ctrls = sd_ctrls,
2510         .nctrls = ARRAY_SIZE(sd_ctrls),
2511         .config = sd_config,
2512         .init = sd_init,
2513         .isoc_init = sd_isoc_init,
2514         .start = sd_start,
2515         .stopN = sd_stopN,
2516         .pkt_scan = sd_pkt_scan,
2517 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2518         .int_pkt_scan = sd_int_pkt_scan,
2519 #endif
2520         .dq_callback = sd_dqcallback,
2521 #ifdef CONFIG_VIDEO_ADV_DEBUG
2522         .set_register = sd_dbg_s_register,
2523         .get_register = sd_dbg_g_register,
2524 #endif
2525         .get_chip_ident = sd_chip_ident,
2526 };
2527
2528 #define SN9C20X(sensor, i2c_addr, flags) \
2529         .driver_info =  ((flags & 0xff) << 16) \
2530                         | (SENSOR_ ## sensor << 8) \
2531                         | (i2c_addr)
2532
2533 static const struct usb_device_id device_table[] = {
2534         {USB_DEVICE(0x0c45, 0x6240), SN9C20X(MT9M001, 0x5d, 0)},
2535         {USB_DEVICE(0x0c45, 0x6242), SN9C20X(MT9M111, 0x5d, 0)},
2536         {USB_DEVICE(0x0c45, 0x6248), SN9C20X(OV9655, 0x30, 0)},
2537         {USB_DEVICE(0x0c45, 0x624c), SN9C20X(MT9M112, 0x5d, 0)},
2538         {USB_DEVICE(0x0c45, 0x624e), SN9C20X(SOI968, 0x30, LED_REVERSE)},
2539         {USB_DEVICE(0x0c45, 0x624f), SN9C20X(OV9650, 0x30,
2540                                              (FLIP_DETECT | HAS_NO_BUTTON))},
2541         {USB_DEVICE(0x0c45, 0x6251), SN9C20X(OV9650, 0x30, 0)},
2542         {USB_DEVICE(0x0c45, 0x6253), SN9C20X(OV9650, 0x30, 0)},
2543         {USB_DEVICE(0x0c45, 0x6260), SN9C20X(OV7670, 0x21, 0)},
2544         {USB_DEVICE(0x0c45, 0x6270), SN9C20X(MT9VPRB, 0x00, 0)},
2545         {USB_DEVICE(0x0c45, 0x627b), SN9C20X(OV7660, 0x21, FLIP_DETECT)},
2546         {USB_DEVICE(0x0c45, 0x627c), SN9C20X(HV7131R, 0x11, 0)},
2547         {USB_DEVICE(0x0c45, 0x627f), SN9C20X(OV9650, 0x30, 0)},
2548         {USB_DEVICE(0x0c45, 0x6280), SN9C20X(MT9M001, 0x5d, 0)},
2549         {USB_DEVICE(0x0c45, 0x6282), SN9C20X(MT9M111, 0x5d, 0)},
2550         {USB_DEVICE(0x0c45, 0x6288), SN9C20X(OV9655, 0x30, 0)},
2551         {USB_DEVICE(0x0c45, 0x628c), SN9C20X(MT9M112, 0x5d, 0)},
2552         {USB_DEVICE(0x0c45, 0x628e), SN9C20X(SOI968, 0x30, 0)},
2553         {USB_DEVICE(0x0c45, 0x628f), SN9C20X(OV9650, 0x30, 0)},
2554         {USB_DEVICE(0x0c45, 0x62a0), SN9C20X(OV7670, 0x21, 0)},
2555         {USB_DEVICE(0x0c45, 0x62b0), SN9C20X(MT9VPRB, 0x00, 0)},
2556         {USB_DEVICE(0x0c45, 0x62b3), SN9C20X(OV9655, 0x30, LED_REVERSE)},
2557         {USB_DEVICE(0x0c45, 0x62bb), SN9C20X(OV7660, 0x21, LED_REVERSE)},
2558         {USB_DEVICE(0x0c45, 0x62bc), SN9C20X(HV7131R, 0x11, 0)},
2559         {USB_DEVICE(0x045e, 0x00f4), SN9C20X(OV9650, 0x30, 0)},
2560         {USB_DEVICE(0x145f, 0x013d), SN9C20X(OV7660, 0x21, 0)},
2561         {USB_DEVICE(0x0458, 0x7029), SN9C20X(HV7131R, 0x11, 0)},
2562         {USB_DEVICE(0x0458, 0x704a), SN9C20X(MT9M112, 0x5d, 0)},
2563         {USB_DEVICE(0x0458, 0x704c), SN9C20X(MT9M112, 0x5d, 0)},
2564         {USB_DEVICE(0xa168, 0x0610), SN9C20X(HV7131R, 0x11, 0)},
2565         {USB_DEVICE(0xa168, 0x0611), SN9C20X(HV7131R, 0x11, 0)},
2566         {USB_DEVICE(0xa168, 0x0613), SN9C20X(HV7131R, 0x11, 0)},
2567         {USB_DEVICE(0xa168, 0x0618), SN9C20X(HV7131R, 0x11, 0)},
2568         {USB_DEVICE(0xa168, 0x0614), SN9C20X(MT9M111, 0x5d, 0)},
2569         {USB_DEVICE(0xa168, 0x0615), SN9C20X(MT9M111, 0x5d, 0)},
2570         {USB_DEVICE(0xa168, 0x0617), SN9C20X(MT9M111, 0x5d, 0)},
2571         {}
2572 };
2573 MODULE_DEVICE_TABLE(usb, device_table);
2574
2575 /* -- device connect -- */
2576 static int sd_probe(struct usb_interface *intf,
2577                     const struct usb_device_id *id)
2578 {
2579         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
2580                                 THIS_MODULE);
2581 }
2582
2583 static struct usb_driver sd_driver = {
2584         .name = MODULE_NAME,
2585         .id_table = device_table,
2586         .probe = sd_probe,
2587         .disconnect = gspca_disconnect,
2588 #ifdef CONFIG_PM
2589         .suspend = gspca_suspend,
2590         .resume = gspca_resume,
2591         .reset_resume = gspca_resume,
2592 #endif
2593 };
2594
2595 module_usb_driver(sd_driver);