Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/media/usb/gspca/sn9c20x.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us