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