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