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