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