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