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