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