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