?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'v6v7' into devel
[linux/fpc-iii.git] / drivers / media / video / gspca / sonixb.c
blobc6cd68d66b533a9b08e87f114e5cba69d48bfe24
1 /*
2 * sonix sn9c102 (bayer) library
3 * Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr
4 * Add Pas106 Stefano Mozzi (C) 2004
5 *
6 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
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 /* Some documentation on known sonixb registers:
24
25 Reg Use
26 sn9c101 / sn9c102:
27 0x10 high nibble red gain low nibble blue gain
28 0x11 low nibble green gain
29 sn9c103:
30 0x05 red gain 0-127
31 0x06 blue gain 0-127
32 0x07 green gain 0-127
33 all:
34 0x08-0x0f i2c / 3wire registers
35 0x12 hstart
36 0x13 vstart
37 0x15 hsize (hsize = register-value * 16)
38 0x16 vsize (vsize = register-value * 16)
39 0x17 bit 0 toggle compression quality (according to sn9c102 driver)
40 0x18 bit 7 enables compression, bit 4-5 set image down scaling:
41 00 scale 1, 01 scale 1/2, 10, scale 1/4
42 0x19 high-nibble is sensor clock divider, changes exposure on sensors which
43 use a clock generated by the bridge. Some sensors have their own clock.
44 0x1c auto_exposure area (for avg_lum) startx (startx = register-value * 32)
45 0x1d auto_exposure area (for avg_lum) starty (starty = register-value * 32)
46 0x1e auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32)
47 0x1f auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32)
48 */
49
50 #define MODULE_NAME "sonixb"
51
52 #include <linux/input.h>
53 #include "gspca.h"
54
55 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
56 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
57 MODULE_LICENSE("GPL");
58
59 /* specific webcam descriptor */
60 struct sd {
61 struct gspca_dev gspca_dev; /* !! must be the first item */
62 atomic_t avg_lum;
63 int prev_avg_lum;
64 int exp_too_low_cnt;
65 int exp_too_high_cnt;
66 int header_read;
67 u8 header[12]; /* Header without sof marker */
68
69 unsigned short exposure;
70 unsigned char gain;
71 unsigned char brightness;
72 unsigned char autogain;
73 unsigned char autogain_ignore_frames;
74 unsigned char frames_to_drop;
75 unsigned char freq; /* light freq filter setting */
76
77 __u8 bridge; /* Type of bridge */
78 #define BRIDGE_101 0
79 #define BRIDGE_102 0 /* We make no difference between 101 and 102 */
80 #define BRIDGE_103 1
81
82 __u8 sensor; /* Type of image sensor chip */
83 #define SENSOR_HV7131D 0
84 #define SENSOR_HV7131R 1
85 #define SENSOR_OV6650 2
86 #define SENSOR_OV7630 3
87 #define SENSOR_PAS106 4
88 #define SENSOR_PAS202 5
89 #define SENSOR_TAS5110C 6
90 #define SENSOR_TAS5110D 7
91 #define SENSOR_TAS5130CXX 8
92 __u8 reg11;
93 };
94
95 typedef const __u8 sensor_init_t[8];
96
97 struct sensor_data {
98 const __u8 *bridge_init;
99 sensor_init_t *sensor_init;
100 int sensor_init_size;
101 int flags;
102 unsigned ctrl_dis;
103 __u8 sensor_addr;
104 };
105
106 /* sensor_data flags */
107 #define F_GAIN 0x01 /* has gain */
108 #define F_SIF 0x02 /* sif or vga */
109 #define F_COARSE_EXPO 0x04 /* exposure control is coarse */
110
111 /* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
112 #define MODE_RAW 0x10 /* raw bayer mode */
113 #define MODE_REDUCED_SIF 0x20 /* vga mode (320x240 / 160x120) on sif cam */
114
115 /* ctrl_dis helper macros */
116 #define NO_EXPO ((1 << EXPOSURE_IDX) | (1 << COARSE_EXPOSURE_IDX) | \
117 (1 << AUTOGAIN_IDX))
118 #define NO_FREQ (1 << FREQ_IDX)
119 #define NO_BRIGHTNESS (1 << BRIGHTNESS_IDX)
120
121 #define COMP 0xc7 /* 0x87 //0x07 */
122 #define COMP1 0xc9 /* 0x89 //0x09 */
123
124 #define MCK_INIT 0x63
125 #define MCK_INIT1 0x20 /*fixme: Bayer - 0x50 for JPEG ??*/
126
127 #define SYS_CLK 0x04
128
129 #define SENS(bridge, sensor, _flags, _ctrl_dis, _sensor_addr) \
130 { \
131 .bridge_init = bridge, \
132 .sensor_init = sensor, \
133 .sensor_init_size = sizeof(sensor), \
134 .flags = _flags, .ctrl_dis = _ctrl_dis, .sensor_addr = _sensor_addr \
135 }
136
137 /* We calculate the autogain at the end of the transfer of a frame, at this
138 moment a frame with the old settings is being captured and transmitted. So
139 if we adjust the gain or exposure we must ignore atleast the next frame for
140 the new settings to come into effect before doing any other adjustments. */
141 #define AUTOGAIN_IGNORE_FRAMES 1
142
143 /* V4L2 controls supported by the driver */
144 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
145 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
146 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
147 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
148 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
149 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
150 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
151 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
152 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
153 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
154
155 static const struct ctrl sd_ctrls[] = {
156 #define BRIGHTNESS_IDX 0
157 {
158 {
159 .id = V4L2_CID_BRIGHTNESS,
160 .type = V4L2_CTRL_TYPE_INTEGER,
161 .name = "Brightness",
162 .minimum = 0,
163 .maximum = 255,
164 .step = 1,
165 #define BRIGHTNESS_DEF 127
166 .default_value = BRIGHTNESS_DEF,
167 },
168 .set = sd_setbrightness,
169 .get = sd_getbrightness,
170 },
171 #define GAIN_IDX 1
172 {
173 {
174 .id = V4L2_CID_GAIN,
175 .type = V4L2_CTRL_TYPE_INTEGER,
176 .name = "Gain",
177 .minimum = 0,
178 .maximum = 255,
179 .step = 1,
180 #define GAIN_DEF 127
181 #define GAIN_KNEE 230
182 .default_value = GAIN_DEF,
183 },
184 .set = sd_setgain,
185 .get = sd_getgain,
186 },
187 #define EXPOSURE_IDX 2
188 {
189 {
190 .id = V4L2_CID_EXPOSURE,
191 .type = V4L2_CTRL_TYPE_INTEGER,
192 .name = "Exposure",
193 #define EXPOSURE_DEF 66 /* 33 ms / 30 fps (except on PASXXX) */
194 #define EXPOSURE_KNEE 200 /* 100 ms / 10 fps (except on PASXXX) */
195 .minimum = 0,
196 .maximum = 1023,
197 .step = 1,
198 .default_value = EXPOSURE_DEF,
199 .flags = 0,
200 },
201 .set = sd_setexposure,
202 .get = sd_getexposure,
203 },
204 #define COARSE_EXPOSURE_IDX 3
205 {
206 {
207 .id = V4L2_CID_EXPOSURE,
208 .type = V4L2_CTRL_TYPE_INTEGER,
209 .name = "Exposure",
210 #define COARSE_EXPOSURE_DEF 2 /* 30 fps */
211 .minimum = 2,
212 .maximum = 15,
213 .step = 1,
214 .default_value = COARSE_EXPOSURE_DEF,
215 .flags = 0,
216 },
217 .set = sd_setexposure,
218 .get = sd_getexposure,
219 },
220 #define AUTOGAIN_IDX 4
221 {
222 {
223 .id = V4L2_CID_AUTOGAIN,
224 .type = V4L2_CTRL_TYPE_BOOLEAN,
225 .name = "Automatic Gain (and Exposure)",
226 .minimum = 0,
227 .maximum = 1,
228 .step = 1,
229 #define AUTOGAIN_DEF 1
230 .default_value = AUTOGAIN_DEF,
231 .flags = 0,
232 },
233 .set = sd_setautogain,
234 .get = sd_getautogain,
235 },
236 #define FREQ_IDX 5
237 {
238 {
239 .id = V4L2_CID_POWER_LINE_FREQUENCY,
240 .type = V4L2_CTRL_TYPE_MENU,
241 .name = "Light frequency filter",
242 .minimum = 0,
243 .maximum = 2, /* 0: 0, 1: 50Hz, 2:60Hz */
244 .step = 1,
245 #define FREQ_DEF 0
246 .default_value = FREQ_DEF,
247 },
248 .set = sd_setfreq,
249 .get = sd_getfreq,
250 },
251 };
252
253 static const struct v4l2_pix_format vga_mode[] = {
254 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
255 .bytesperline = 160,
256 .sizeimage = 160 * 120,
257 .colorspace = V4L2_COLORSPACE_SRGB,
258 .priv = 2 | MODE_RAW},
259 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
260 .bytesperline = 160,
261 .sizeimage = 160 * 120 * 5 / 4,
262 .colorspace = V4L2_COLORSPACE_SRGB,
263 .priv = 2},
264 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
265 .bytesperline = 320,
266 .sizeimage = 320 * 240 * 5 / 4,
267 .colorspace = V4L2_COLORSPACE_SRGB,
268 .priv = 1},
269 {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
270 .bytesperline = 640,
271 .sizeimage = 640 * 480 * 5 / 4,
272 .colorspace = V4L2_COLORSPACE_SRGB,
273 .priv = 0},
274 };
275 static const struct v4l2_pix_format sif_mode[] = {
276 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
277 .bytesperline = 160,
278 .sizeimage = 160 * 120,
279 .colorspace = V4L2_COLORSPACE_SRGB,
280 .priv = 1 | MODE_RAW | MODE_REDUCED_SIF},
281 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
282 .bytesperline = 160,
283 .sizeimage = 160 * 120 * 5 / 4,
284 .colorspace = V4L2_COLORSPACE_SRGB,
285 .priv = 1 | MODE_REDUCED_SIF},
286 {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
287 .bytesperline = 176,
288 .sizeimage = 176 * 144,
289 .colorspace = V4L2_COLORSPACE_SRGB,
290 .priv = 1 | MODE_RAW},
291 {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
292 .bytesperline = 176,
293 .sizeimage = 176 * 144 * 5 / 4,
294 .colorspace = V4L2_COLORSPACE_SRGB,
295 .priv = 1},
296 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
297 .bytesperline = 320,
298 .sizeimage = 320 * 240 * 5 / 4,
299 .colorspace = V4L2_COLORSPACE_SRGB,
300 .priv = 0 | MODE_REDUCED_SIF},
301 {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
302 .bytesperline = 352,
303 .sizeimage = 352 * 288 * 5 / 4,
304 .colorspace = V4L2_COLORSPACE_SRGB,
305 .priv = 0},
306 };
307
308 static const __u8 initHv7131d[] = {
309 0x04, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
310 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x02, 0x02, 0x00,
312 0x28, 0x1e, 0x60, 0x8e, 0x42,
313 };
314 static const __u8 hv7131d_sensor_init[][8] = {
315 {0xa0, 0x11, 0x01, 0x04, 0x00, 0x00, 0x00, 0x17},
316 {0xa0, 0x11, 0x02, 0x00, 0x00, 0x00, 0x00, 0x17},
317 {0xa0, 0x11, 0x28, 0x00, 0x00, 0x00, 0x00, 0x17},
318 {0xa0, 0x11, 0x30, 0x30, 0x00, 0x00, 0x00, 0x17}, /* reset level */
319 {0xa0, 0x11, 0x34, 0x02, 0x00, 0x00, 0x00, 0x17}, /* pixel bias volt */
320 };
321
322 static const __u8 initHv7131r[] = {
323 0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
324 0x00, 0x00,
325 0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
326 0x28, 0x1e, 0x60, 0x8a, 0x20,
327 };
328 static const __u8 hv7131r_sensor_init[][8] = {
329 {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10},
330 {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10},
331 {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10},
332 {0xc0, 0x11, 0x25, 0x03, 0x0e, 0x28, 0x00, 0x16},
333 {0xa0, 0x11, 0x30, 0x10, 0x0e, 0x28, 0x00, 0x15},
334 };
335 static const __u8 initOv6650[] = {
336 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
337 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
338 0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
339 0x10,
340 };
341 static const __u8 ov6650_sensor_init[][8] = {
342 /* Bright, contrast, etc are set through SCBB interface.
343 * AVCAP on win2 do not send any data on this controls. */
344 /* Anyway, some registers appears to alter bright and constrat */
345
346 /* Reset sensor */
347 {0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
348 /* Set clock register 0x11 low nibble is clock divider */
349 {0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10},
350 /* Next some unknown stuff */
351 {0xb0, 0x60, 0x15, 0x00, 0x02, 0x18, 0xc1, 0x10},
352 /* {0xa0, 0x60, 0x1b, 0x01, 0x02, 0x18, 0xc1, 0x10},
353 * THIS SET GREEN SCREEN
354 * (pixels could be innverted in decode kind of "brg",
355 * but blue wont be there. Avoid this data ... */
356 {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */
357 {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10},
358 {0xa0, 0x60, 0x30, 0x3d, 0x0a, 0xd8, 0xa4, 0x10},
359 /* Enable rgb brightness control */
360 {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10},
361 /* HDG: Note windows uses the line below, which sets both register 0x60
362 and 0x61 I believe these registers of the ov6650 are identical as
363 those of the ov7630, because if this is true the windows settings
364 add a bit additional red gain and a lot additional blue gain, which
365 matches my findings that the windows settings make blue much too
366 blue and red a little too red.
367 {0xb0, 0x60, 0x60, 0x66, 0x68, 0xd8, 0xa4, 0x10}, */
368 /* Some more unknown stuff */
369 {0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10},
370 {0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */
371 };
372
373 static const __u8 initOv7630[] = {
374 0x04, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, /* r01 .. r08 */
375 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
376 0x00, 0x01, 0x01, 0x0a, /* r11 .. r14 */
377 0x28, 0x1e, /* H & V sizes r15 .. r16 */
378 0x68, 0x8f, MCK_INIT1, /* r17 .. r19 */
379 };
380 static const __u8 ov7630_sensor_init[][8] = {
381 {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
382 {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10},
383 /* {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10}, jfm */
384 {0xd0, 0x21, 0x12, 0x5c, 0x00, 0x80, 0x34, 0x10}, /* jfm */
385 {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10},
386 {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10},
387 {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10},
388 {0xd0, 0x21, 0x26, 0xa0, 0x9a, 0xa0, 0x30, 0x10},
389 {0xb0, 0x21, 0x2a, 0x80, 0x00, 0xa0, 0x30, 0x10},
390 {0xb0, 0x21, 0x2f, 0x3d, 0x24, 0xa0, 0x30, 0x10},
391 {0xa0, 0x21, 0x32, 0x86, 0x24, 0xa0, 0x30, 0x10},
392 {0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10},
393 /* {0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10}, * jfm */
394 {0xa0, 0x21, 0x65, 0x00, 0x42, 0xa0, 0x30, 0x10},
395 {0xa0, 0x21, 0x69, 0x38, 0x42, 0xa0, 0x30, 0x10},
396 {0xc0, 0x21, 0x6f, 0x88, 0x0b, 0x00, 0x30, 0x10},
397 {0xc0, 0x21, 0x74, 0x21, 0x8e, 0x00, 0x30, 0x10},
398 {0xa0, 0x21, 0x7d, 0xf7, 0x8e, 0x00, 0x30, 0x10},
399 {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10},
400 };
401
402 static const __u8 initPas106[] = {
403 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
404 0x00, 0x00,
405 0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
406 0x16, 0x12, 0x24, COMP1, MCK_INIT1,
407 };
408 /* compression 0x86 mckinit1 0x2b */
409
410 /* "Known" PAS106B registers:
411 0x02 clock divider
412 0x03 Variable framerate bits 4-11
413 0x04 Var framerate bits 0-3, one must leave the 4 msb's at 0 !!
414 The variable framerate control must never be set lower then 300,
415 which sets the framerate at 90 / reg02, otherwise vsync is lost.
416 0x05 Shutter Time Line Offset, this can be used as an exposure control:
417 0 = use full frame time, 255 = no exposure at all
418 Note this may never be larger then "var-framerate control" / 2 - 2.
419 When var-framerate control is < 514, no exposure is reached at the max
420 allowed value for the framerate control value, rather then at 255.
421 0x06 Shutter Time Pixel Offset, like reg05 this influences exposure, but
422 only a very little bit, leave at 0xcd
423 0x07 offset sign bit (bit0 1 > negative offset)
424 0x08 offset
425 0x09 Blue Gain
426 0x0a Green1 Gain
427 0x0b Green2 Gain
428 0x0c Red Gain
429 0x0e Global gain
430 0x13 Write 1 to commit settings to sensor
431 */
432
433 static const __u8 pas106_sensor_init[][8] = {
434 /* Pixel Clock Divider 6 */
435 { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 },
436 /* Frame Time MSB (also seen as 0x12) */
437 { 0xa1, 0x40, 0x03, 0x13, 0x00, 0x00, 0x00, 0x14 },
438 /* Frame Time LSB (also seen as 0x05) */
439 { 0xa1, 0x40, 0x04, 0x06, 0x00, 0x00, 0x00, 0x14 },
440 /* Shutter Time Line Offset (also seen as 0x6d) */
441 { 0xa1, 0x40, 0x05, 0x65, 0x00, 0x00, 0x00, 0x14 },
442 /* Shutter Time Pixel Offset (also seen as 0xb1) */
443 { 0xa1, 0x40, 0x06, 0xcd, 0x00, 0x00, 0x00, 0x14 },
444 /* Black Level Subtract Sign (also seen 0x00) */
445 { 0xa1, 0x40, 0x07, 0xc1, 0x00, 0x00, 0x00, 0x14 },
446 /* Black Level Subtract Level (also seen 0x01) */
447 { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
448 { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
449 /* Color Gain B Pixel 5 a */
450 { 0xa1, 0x40, 0x09, 0x05, 0x00, 0x00, 0x00, 0x14 },
451 /* Color Gain G1 Pixel 1 5 */
452 { 0xa1, 0x40, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x14 },
453 /* Color Gain G2 Pixel 1 0 5 */
454 { 0xa1, 0x40, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x14 },
455 /* Color Gain R Pixel 3 1 */
456 { 0xa1, 0x40, 0x0c, 0x05, 0x00, 0x00, 0x00, 0x14 },
457 /* Color GainH Pixel */
458 { 0xa1, 0x40, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x14 },
459 /* Global Gain */
460 { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 },
461 /* Contrast */
462 { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 },
463 /* H&V synchro polarity */
464 { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 },
465 /* ?default */
466 { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 },
467 /* DAC scale */
468 { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 },
469 /* ?default */
470 { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 },
471 /* Validate Settings */
472 { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 },
473 };
474
475 static const __u8 initPas202[] = {
476 0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
477 0x00, 0x00,
478 0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
479 0x28, 0x1e, 0x20, 0x89, 0x20,
480 };
481
482 /* "Known" PAS202BCB registers:
483 0x02 clock divider
484 0x04 Variable framerate bits 6-11 (*)
485 0x05 Var framerate bits 0-5, one must leave the 2 msb's at 0 !!
486 0x07 Blue Gain
487 0x08 Green Gain
488 0x09 Red Gain
489 0x0b offset sign bit (bit0 1 > negative offset)
490 0x0c offset
491 0x0e Unknown image is slightly brighter when bit 0 is 0, if reg0f is 0 too,
492 leave at 1 otherwise we get a jump in our exposure control
493 0x0f Exposure 0-255, 0 = use full frame time, 255 = no exposure at all
494 0x10 Master gain 0 - 31
495 0x11 write 1 to apply changes
496 (*) The variable framerate control must never be set lower then 500
497 which sets the framerate at 30 / reg02, otherwise vsync is lost.
498 */
499 static const __u8 pas202_sensor_init[][8] = {
500 /* Set the clock divider to 4 -> 30 / 4 = 7.5 fps, we would like
501 to set it lower, but for some reason the bridge starts missing
502 vsync's then */
503 {0xa0, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x10},
504 {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
505 {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
506 {0xd0, 0x40, 0x0c, 0x00, 0x0c, 0x01, 0x32, 0x10},
507 {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10},
508 {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10},
509 {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10},
510 {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
511 {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10},
512 {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
513 };
514
515 static const __u8 initTas5110c[] = {
516 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
517 0x00, 0x00,
518 0x00, 0x00, 0x00, 0x45, 0x09, 0x0a,
519 0x16, 0x12, 0x60, 0x86, 0x2b,
520 };
521 /* Same as above, except a different hstart */
522 static const __u8 initTas5110d[] = {
523 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
524 0x00, 0x00,
525 0x00, 0x00, 0x00, 0x41, 0x09, 0x0a,
526 0x16, 0x12, 0x60, 0x86, 0x2b,
527 };
528 /* tas5110c is 3 wire, tas5110d is 2 wire (regular i2c) */
529 static const __u8 tas5110c_sensor_init[][8] = {
530 {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
531 {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
532 };
533 /* Known TAS5110D registers
534 * reg02: gain, bit order reversed!! 0 == max gain, 255 == min gain
535 * reg03: bit3: vflip, bit4: ~hflip, bit7: ~gainboost (~ == inverted)
536 * Note: writing reg03 seems to only work when written together with 02
537 */
538 static const __u8 tas5110d_sensor_init[][8] = {
539 {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17}, /* reset */
540 };
541
542 static const __u8 initTas5130[] = {
543 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
544 0x00, 0x00,
545 0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a,
546 0x28, 0x1e, 0x60, COMP, MCK_INIT,
547 };
548 static const __u8 tas5130_sensor_init[][8] = {
549 /* {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
550 * shutter 0x47 short exposure? */
551 {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
552 /* shutter 0x01 long exposure */
553 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
554 };
555
556 static struct sensor_data sensor_data[] = {
557 SENS(initHv7131d, hv7131d_sensor_init, F_GAIN, NO_BRIGHTNESS|NO_FREQ, 0),
558 SENS(initHv7131r, hv7131r_sensor_init, 0, NO_BRIGHTNESS|NO_EXPO|NO_FREQ, 0),
559 SENS(initOv6650, ov6650_sensor_init, F_GAIN|F_SIF, 0, 0x60),
560 SENS(initOv7630, ov7630_sensor_init, F_GAIN, 0, 0x21),
561 SENS(initPas106, pas106_sensor_init, F_GAIN|F_SIF, NO_FREQ, 0),
562 SENS(initPas202, pas202_sensor_init, F_GAIN, NO_FREQ, 0),
563 SENS(initTas5110c, tas5110c_sensor_init, F_GAIN|F_SIF|F_COARSE_EXPO,
564 NO_BRIGHTNESS|NO_FREQ, 0),
565 SENS(initTas5110d, tas5110d_sensor_init, F_GAIN|F_SIF|F_COARSE_EXPO,
566 NO_BRIGHTNESS|NO_FREQ, 0),
567 SENS(initTas5130, tas5130_sensor_init, F_GAIN,
568 NO_BRIGHTNESS|NO_EXPO|NO_FREQ, 0),
569 };
570
571 /* get one byte in gspca_dev->usb_buf */
572 static void reg_r(struct gspca_dev *gspca_dev,
573 __u16 value)
574 {
575 usb_control_msg(gspca_dev->dev,
576 usb_rcvctrlpipe(gspca_dev->dev, 0),
577 0, /* request */
578 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
579 value,
580 0, /* index */
581 gspca_dev->usb_buf, 1,
582 500);
583 }
584
585 static void reg_w(struct gspca_dev *gspca_dev,
586 __u16 value,
587 const __u8 *buffer,
588 int len)
589 {
590 #ifdef GSPCA_DEBUG
591 if (len > USB_BUF_SZ) {
592 PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
593 return;
594 }
595 #endif
596 memcpy(gspca_dev->usb_buf, buffer, len);
597 usb_control_msg(gspca_dev->dev,
598 usb_sndctrlpipe(gspca_dev->dev, 0),
599 0x08, /* request */
600 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
601 value,
602 0, /* index */
603 gspca_dev->usb_buf, len,
604 500);
605 }
606
607 static int i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer)
608 {
609 int retry = 60;
610
611 /* is i2c ready */
612 reg_w(gspca_dev, 0x08, buffer, 8);
613 while (retry--) {
614 msleep(10);
615 reg_r(gspca_dev, 0x08);
616 if (gspca_dev->usb_buf[0] & 0x04) {
617 if (gspca_dev->usb_buf[0] & 0x08)
618 return -1;
619 return 0;
620 }
621 }
622 return -1;
623 }
624
625 static void i2c_w_vector(struct gspca_dev *gspca_dev,
626 const __u8 buffer[][8], int len)
627 {
628 for (;;) {
629 reg_w(gspca_dev, 0x08, *buffer, 8);
630 len -= 8;
631 if (len <= 0)
632 break;
633 buffer++;
634 }
635 }
636
637 static void setbrightness(struct gspca_dev *gspca_dev)
638 {
639 struct sd *sd = (struct sd *) gspca_dev;
640
641 switch (sd->sensor) {
642 case SENSOR_OV6650:
643 case SENSOR_OV7630: {
644 __u8 i2cOV[] =
645 {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
646
647 /* change reg 0x06 */
648 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
649 i2cOV[3] = sd->brightness;
650 if (i2c_w(gspca_dev, i2cOV) < 0)
651 goto err;
652 break;
653 }
654 case SENSOR_PAS106:
655 case SENSOR_PAS202: {
656 __u8 i2cpbright[] =
657 {0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16};
658 __u8 i2cpdoit[] =
659 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
660
661 /* PAS106 uses reg 7 and 8 instead of b and c */
662 if (sd->sensor == SENSOR_PAS106) {
663 i2cpbright[2] = 7;
664 i2cpdoit[2] = 0x13;
665 }
666
667 if (sd->brightness < 127) {
668 /* change reg 0x0b, signreg */
669 i2cpbright[3] = 0x01;
670 /* set reg 0x0c, offset */
671 i2cpbright[4] = 127 - sd->brightness;
672 } else
673 i2cpbright[4] = sd->brightness - 127;
674
675 if (i2c_w(gspca_dev, i2cpbright) < 0)
676 goto err;
677 if (i2c_w(gspca_dev, i2cpdoit) < 0)
678 goto err;
679 break;
680 }
681 }
682 return;
683 err:
684 PDEBUG(D_ERR, "i2c error brightness");
685 }
686
687 static void setsensorgain(struct gspca_dev *gspca_dev)
688 {
689 struct sd *sd = (struct sd *) gspca_dev;
690 unsigned char gain = sd->gain;
691
692 switch (sd->sensor) {
693 case SENSOR_HV7131D: {
694 __u8 i2c[] =
695 {0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17};
696
697 i2c[3] = 0x3f - (sd->gain / 4);
698 i2c[4] = 0x3f - (sd->gain / 4);
699 i2c[5] = 0x3f - (sd->gain / 4);
700
701 if (i2c_w(gspca_dev, i2c) < 0)
702 goto err;
703 break;
704 }
705 case SENSOR_TAS5110C:
706 case SENSOR_TAS5130CXX: {
707 __u8 i2c[] =
708 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
709
710 i2c[4] = 255 - gain;
711 if (i2c_w(gspca_dev, i2c) < 0)
712 goto err;
713 break;
714 }
715 case SENSOR_TAS5110D: {
716 __u8 i2c[] = {
717 0xb0, 0x61, 0x02, 0x00, 0x10, 0x00, 0x00, 0x17 };
718 gain = 255 - gain;
719 /* The bits in the register are the wrong way around!! */
720 i2c[3] |= (gain & 0x80) >> 7;
721 i2c[3] |= (gain & 0x40) >> 5;
722 i2c[3] |= (gain & 0x20) >> 3;
723 i2c[3] |= (gain & 0x10) >> 1;
724 i2c[3] |= (gain & 0x08) << 1;
725 i2c[3] |= (gain & 0x04) << 3;
726 i2c[3] |= (gain & 0x02) << 5;
727 i2c[3] |= (gain & 0x01) << 7;
728 if (i2c_w(gspca_dev, i2c) < 0)
729 goto err;
730 break;
731 }
732
733 case SENSOR_OV6650:
734 gain >>= 1;
735 /* fall thru */
736 case SENSOR_OV7630: {
737 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
738
739 i2c[1] = sensor_data[sd->sensor].sensor_addr;
740 i2c[3] = gain >> 2;
741 if (i2c_w(gspca_dev, i2c) < 0)
742 goto err;
743 break;
744 }
745 case SENSOR_PAS106:
746 case SENSOR_PAS202: {
747 __u8 i2cpgain[] =
748 {0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15};
749 __u8 i2cpcolorgain[] =
750 {0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15};
751 __u8 i2cpdoit[] =
752 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
753
754 /* PAS106 uses different regs (and has split green gains) */
755 if (sd->sensor == SENSOR_PAS106) {
756 i2cpgain[2] = 0x0e;
757 i2cpcolorgain[0] = 0xd0;
758 i2cpcolorgain[2] = 0x09;
759 i2cpdoit[2] = 0x13;
760 }
761
762 i2cpgain[3] = sd->gain >> 3;
763 i2cpcolorgain[3] = sd->gain >> 4;
764 i2cpcolorgain[4] = sd->gain >> 4;
765 i2cpcolorgain[5] = sd->gain >> 4;
766 i2cpcolorgain[6] = sd->gain >> 4;
767
768 if (i2c_w(gspca_dev, i2cpgain) < 0)
769 goto err;
770 if (i2c_w(gspca_dev, i2cpcolorgain) < 0)
771 goto err;
772 if (i2c_w(gspca_dev, i2cpdoit) < 0)
773 goto err;
774 break;
775 }
776 }
777 return;
778 err:
779 PDEBUG(D_ERR, "i2c error gain");
780 }
781
782 static void setgain(struct gspca_dev *gspca_dev)
783 {
784 struct sd *sd = (struct sd *) gspca_dev;
785 __u8 gain;
786 __u8 buf[3] = { 0, 0, 0 };
787
788 if (sensor_data[sd->sensor].flags & F_GAIN) {
789 /* Use the sensor gain to do the actual gain */
790 setsensorgain(gspca_dev);
791 return;
792 }
793
794 if (sd->bridge == BRIDGE_103) {
795 gain = sd->gain >> 1;
796 buf[0] = gain; /* Red */
797 buf[1] = gain; /* Green */
798 buf[2] = gain; /* Blue */
799 reg_w(gspca_dev, 0x05, buf, 3);
800 } else {
801 gain = sd->gain >> 4;
802 buf[0] = gain << 4 | gain; /* Red and blue */
803 buf[1] = gain; /* Green */
804 reg_w(gspca_dev, 0x10, buf, 2);
805 }
806 }
807
808 static void setexposure(struct gspca_dev *gspca_dev)
809 {
810 struct sd *sd = (struct sd *) gspca_dev;
811
812 switch (sd->sensor) {
813 case SENSOR_HV7131D: {
814 /* Note the datasheet wrongly says line mode exposure uses reg
815 0x26 and 0x27, testing has shown 0x25 + 0x26 */
816 __u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17};
817 /* The HV7131D's exposure goes from 0 - 65535, we scale our
818 exposure of 0-1023 to 0-6138. There are 2 reasons for this:
819 1) This puts our exposure knee of 200 at approx the point
820 where the framerate starts dropping
821 2) At 6138 the framerate has already dropped to 2 fps,
822 going any lower makes little sense */
823 __u16 reg = sd->exposure * 6;
824 i2c[3] = reg >> 8;
825 i2c[4] = reg & 0xff;
826 if (i2c_w(gspca_dev, i2c) != 0)
827 goto err;
828 break;
829 }
830 case SENSOR_TAS5110C:
831 case SENSOR_TAS5110D: {
832 /* register 19's high nibble contains the sn9c10x clock divider
833 The high nibble configures the no fps according to the
834 formula: 60 / high_nibble. With a maximum of 30 fps */
835 __u8 reg = sd->exposure;
836 reg = (reg << 4) | 0x0b;
837 reg_w(gspca_dev, 0x19, &reg, 1);
838 break;
839 }
840 case SENSOR_OV6650:
841 case SENSOR_OV7630: {
842 /* The ov6650 / ov7630 have 2 registers which both influence
843 exposure, register 11, whose low nibble sets the nr off fps
844 according to: fps = 30 / (low_nibble + 1)
845
846 The fps configures the maximum exposure setting, but it is
847 possible to use less exposure then what the fps maximum
848 allows by setting register 10. register 10 configures the
849 actual exposure as quotient of the full exposure, with 0
850 being no exposure at all (not very usefull) and reg10_max
851 being max exposure possible at that framerate.
852
853 The code maps our 0 - 510 ms exposure ctrl to these 2
854 registers, trying to keep fps as high as possible.
855 */
856 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
857 int reg10, reg11, reg10_max;
858
859 /* ov6645 datasheet says reg10_max is 9a, but that uses
860 tline * 2 * reg10 as formula for calculating texpo, the
861 ov6650 probably uses the same formula as the 7730 which uses
862 tline * 4 * reg10, which explains why the reg10max we've
863 found experimentally for the ov6650 is exactly half that of
864 the ov6645. The ov7630 datasheet says the max is 0x41. */
865 if (sd->sensor == SENSOR_OV6650) {
866 reg10_max = 0x4d;
867 i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
868 } else
869 reg10_max = 0x41;
870
871 reg11 = (15 * sd->exposure + 999) / 1000;
872 if (reg11 < 1)
873 reg11 = 1;
874 else if (reg11 > 16)
875 reg11 = 16;
876
877 /* In 640x480, if the reg11 has less than 4, the image is
878 unstable (the bridge goes into a higher compression mode
879 which we have not reverse engineered yet). */
880 if (gspca_dev->width == 640 && reg11 < 4)
881 reg11 = 4;
882
883 /* frame exposure time in ms = 1000 * reg11 / 30 ->
884 reg10 = (sd->exposure / 2) * reg10_max / (1000 * reg11 / 30) */
885 reg10 = (sd->exposure * 15 * reg10_max) / (1000 * reg11);
886
887 /* Don't allow this to get below 10 when using autogain, the
888 steps become very large (relatively) when below 10 causing
889 the image to oscilate from much too dark, to much too bright
890 and back again. */
891 if (sd->autogain && reg10 < 10)
892 reg10 = 10;
893 else if (reg10 > reg10_max)
894 reg10 = reg10_max;
895
896 /* Write reg 10 and reg11 low nibble */
897 i2c[1] = sensor_data[sd->sensor].sensor_addr;
898 i2c[3] = reg10;
899 i2c[4] |= reg11 - 1;
900
901 /* If register 11 didn't change, don't change it */
902 if (sd->reg11 == reg11)
903 i2c[0] = 0xa0;
904
905 if (i2c_w(gspca_dev, i2c) == 0)
906 sd->reg11 = reg11;
907 else
908 goto err;
909 break;
910 }
911 case SENSOR_PAS202: {
912 __u8 i2cpframerate[] =
913 {0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16};
914 __u8 i2cpexpo[] =
915 {0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16};
916 const __u8 i2cpdoit[] =
917 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
918 int framerate_ctrl;
919
920 /* The exposure knee for the autogain algorithm is 200
921 (100 ms / 10 fps on other sensors), for values below this
922 use the control for setting the partial frame expose time,
923 above that use variable framerate. This way we run at max
924 framerate (640x480@7.5 fps, 320x240@10fps) until the knee
925 is reached. Using the variable framerate control above 200
926 is better then playing around with both clockdiv + partial
927 frame exposure times (like we are doing with the ov chips),
928 as that sometimes leads to jumps in the exposure control,
929 which are bad for auto exposure. */
930 if (sd->exposure < 200) {
931 i2cpexpo[3] = 255 - (sd->exposure * 255) / 200;
932 framerate_ctrl = 500;
933 } else {
934 /* The PAS202's exposure control goes from 0 - 4095,
935 but anything below 500 causes vsync issues, so scale
936 our 200-1023 to 500-4095 */
937 framerate_ctrl = (sd->exposure - 200) * 1000 / 229 +
938 500;
939 }
940
941 i2cpframerate[3] = framerate_ctrl >> 6;
942 i2cpframerate[4] = framerate_ctrl & 0x3f;
943 if (i2c_w(gspca_dev, i2cpframerate) < 0)
944 goto err;
945 if (i2c_w(gspca_dev, i2cpexpo) < 0)
946 goto err;
947 if (i2c_w(gspca_dev, i2cpdoit) < 0)
948 goto err;
949 break;
950 }
951 case SENSOR_PAS106: {
952 __u8 i2cpframerate[] =
953 {0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14};
954 __u8 i2cpexpo[] =
955 {0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14};
956 const __u8 i2cpdoit[] =
957 {0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14};
958 int framerate_ctrl;
959
960 /* For values below 150 use partial frame exposure, above
961 that use framerate ctrl */
962 if (sd->exposure < 150) {
963 i2cpexpo[3] = 150 - sd->exposure;
964 framerate_ctrl = 300;
965 } else {
966 /* The PAS106's exposure control goes from 0 - 4095,
967 but anything below 300 causes vsync issues, so scale
968 our 150-1023 to 300-4095 */
969 framerate_ctrl = (sd->exposure - 150) * 1000 / 230 +
970 300;
971 }
972
973 i2cpframerate[3] = framerate_ctrl >> 4;
974 i2cpframerate[4] = framerate_ctrl & 0x0f;
975 if (i2c_w(gspca_dev, i2cpframerate) < 0)
976 goto err;
977 if (i2c_w(gspca_dev, i2cpexpo) < 0)
978 goto err;
979 if (i2c_w(gspca_dev, i2cpdoit) < 0)
980 goto err;
981 break;
982 }
983 }
984 return;
985 err:
986 PDEBUG(D_ERR, "i2c error exposure");
987 }
988
989 static void setfreq(struct gspca_dev *gspca_dev)
990 {
991 struct sd *sd = (struct sd *) gspca_dev;
992
993 switch (sd->sensor) {
994 case SENSOR_OV6650:
995 case SENSOR_OV7630: {
996 /* Framerate adjust register for artificial light 50 hz flicker
997 compensation, for the ov6650 this is identical to ov6630
998 0x2b register, see ov6630 datasheet.
999 0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
1000 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
1001 switch (sd->freq) {
1002 default:
1003 /* case 0: * no filter*/
1004 /* case 2: * 60 hz */
1005 i2c[3] = 0;
1006 break;
1007 case 1: /* 50 hz */
1008 i2c[3] = (sd->sensor == SENSOR_OV6650)
1009 ? 0x4f : 0x8a;
1010 break;
1011 }
1012 i2c[1] = sensor_data[sd->sensor].sensor_addr;
1013 if (i2c_w(gspca_dev, i2c) < 0)
1014 PDEBUG(D_ERR, "i2c error setfreq");
1015 break;
1016 }
1017 }
1018 }
1019
1020 #include "coarse_expo_autogain.h"
1021
1022 static void do_autogain(struct gspca_dev *gspca_dev)
1023 {
1024 int deadzone, desired_avg_lum, result;
1025 struct sd *sd = (struct sd *) gspca_dev;
1026 int avg_lum = atomic_read(&sd->avg_lum);
1027
1028 if (avg_lum == -1 || !sd->autogain)
1029 return;
1030
1031 if (sd->autogain_ignore_frames > 0) {
1032 sd->autogain_ignore_frames--;
1033 return;
1034 }
1035
1036 /* SIF / VGA sensors have a different autoexposure area and thus
1037 different avg_lum values for the same picture brightness */
1038 if (sensor_data[sd->sensor].flags & F_SIF) {
1039 deadzone = 500;
1040 /* SIF sensors tend to overexpose, so keep this small */
1041 desired_avg_lum = 5000;
1042 } else {
1043 deadzone = 1500;
1044 desired_avg_lum = 13000;
1045 }
1046
1047 if (sensor_data[sd->sensor].flags & F_COARSE_EXPO)
1048 result = gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
1049 sd->brightness * desired_avg_lum / 127,
1050 deadzone);
1051 else
1052 result = gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
1053 sd->brightness * desired_avg_lum / 127,
1054 deadzone, GAIN_KNEE, EXPOSURE_KNEE);
1055
1056 if (result) {
1057 PDEBUG(D_FRAM, "autogain: gain changed: gain: %d expo: %d",
1058 (int)sd->gain, (int)sd->exposure);
1059 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1060 }
1061 }
1062
1063 /* this function is called at probe time */
1064 static int sd_config(struct gspca_dev *gspca_dev,
1065 const struct usb_device_id *id)
1066 {
1067 struct sd *sd = (struct sd *) gspca_dev;
1068 struct cam *cam;
1069
1070 reg_r(gspca_dev, 0x00);
1071 if (gspca_dev->usb_buf[0] != 0x10)
1072 return -ENODEV;
1073
1074 /* copy the webcam info from the device id */
1075 sd->sensor = id->driver_info >> 8;
1076 sd->bridge = id->driver_info & 0xff;
1077 gspca_dev->ctrl_dis = sensor_data[sd->sensor].ctrl_dis;
1078
1079 cam = &gspca_dev->cam;
1080 if (!(sensor_data[sd->sensor].flags & F_SIF)) {
1081 cam->cam_mode = vga_mode;
1082 cam->nmodes = ARRAY_SIZE(vga_mode);
1083 } else {
1084 cam->cam_mode = sif_mode;
1085 cam->nmodes = ARRAY_SIZE(sif_mode);
1086 }
1087 cam->npkt = 36; /* 36 packets per ISOC message */
1088
1089 sd->brightness = BRIGHTNESS_DEF;
1090 sd->gain = GAIN_DEF;
1091 if (sensor_data[sd->sensor].flags & F_COARSE_EXPO) {
1092 sd->exposure = COARSE_EXPOSURE_DEF;
1093 gspca_dev->ctrl_dis |= (1 << EXPOSURE_IDX);
1094 } else {
1095 sd->exposure = EXPOSURE_DEF;
1096 gspca_dev->ctrl_dis |= (1 << COARSE_EXPOSURE_IDX);
1097 }
1098 if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
1099 sd->autogain = 0; /* Disable do_autogain callback */
1100 else
1101 sd->autogain = AUTOGAIN_DEF;
1102 sd->freq = FREQ_DEF;
1103
1104 return 0;
1105 }
1106
1107 /* this function is called at probe and resume time */
1108 static int sd_init(struct gspca_dev *gspca_dev)
1109 {
1110 const __u8 stop = 0x09; /* Disable stream turn of LED */
1111
1112 reg_w(gspca_dev, 0x01, &stop, 1);
1113
1114 return 0;
1115 }
1116
1117 /* -- start the camera -- */
1118 static int sd_start(struct gspca_dev *gspca_dev)
1119 {
1120 struct sd *sd = (struct sd *) gspca_dev;
1121 struct cam *cam = &gspca_dev->cam;
1122 int i, mode;
1123 __u8 regs[0x31];
1124
1125 mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
1126 /* Copy registers 0x01 - 0x19 from the template */
1127 memcpy(&regs[0x01], sensor_data[sd->sensor].bridge_init, 0x19);
1128 /* Set the mode */
1129 regs[0x18] |= mode << 4;
1130
1131 /* Set bridge gain to 1.0 */
1132 if (sd->bridge == BRIDGE_103) {
1133 regs[0x05] = 0x20; /* Red */
1134 regs[0x06] = 0x20; /* Green */
1135 regs[0x07] = 0x20; /* Blue */
1136 } else {
1137 regs[0x10] = 0x00; /* Red and blue */
1138 regs[0x11] = 0x00; /* Green */
1139 }
1140
1141 /* Setup pixel numbers and auto exposure window */
1142 if (sensor_data[sd->sensor].flags & F_SIF) {
1143 regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */
1144 regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */
1145 regs[0x1c] = 0x02; /* AE H-start 64 */
1146 regs[0x1d] = 0x02; /* AE V-start 64 */
1147 regs[0x1e] = 0x09; /* AE H-end 288 */
1148 regs[0x1f] = 0x07; /* AE V-end 224 */
1149 } else {
1150 regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */
1151 regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */
1152 regs[0x1c] = 0x05; /* AE H-start 160 */
1153 regs[0x1d] = 0x03; /* AE V-start 96 */
1154 regs[0x1e] = 0x0f; /* AE H-end 480 */
1155 regs[0x1f] = 0x0c; /* AE V-end 384 */
1156 }
1157
1158 /* Setup the gamma table (only used with the sn9c103 bridge) */
1159 for (i = 0; i < 16; i++)
1160 regs[0x20 + i] = i * 16;
1161 regs[0x20 + i] = 255;
1162
1163 /* Special cases where some regs depend on mode or bridge */
1164 switch (sd->sensor) {
1165 case SENSOR_TAS5130CXX:
1166 /* FIXME / TESTME
1167 probably not mode specific at all most likely the upper
1168 nibble of 0x19 is exposure (clock divider) just as with
1169 the tas5110, we need someone to test this. */
1170 regs[0x19] = mode ? 0x23 : 0x43;
1171 break;
1172 case SENSOR_OV7630:
1173 /* FIXME / TESTME for some reason with the 101/102 bridge the
1174 clock is set to 12 Mhz (reg1 == 0x04), rather then 24.
1175 Also the hstart needs to go from 1 to 2 when using a 103,
1176 which is likely related. This does not seem right. */
1177 if (sd->bridge == BRIDGE_103) {
1178 regs[0x01] = 0x44; /* Select 24 Mhz clock */
1179 regs[0x12] = 0x02; /* Set hstart to 2 */
1180 }
1181 }
1182 /* Disable compression when the raw bayer format has been selected */
1183 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
1184 regs[0x18] &= ~0x80;
1185
1186 /* Vga mode emulation on SIF sensor? */
1187 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
1188 regs[0x12] += 16; /* hstart adjust */
1189 regs[0x13] += 24; /* vstart adjust */
1190 regs[0x15] = 320 / 16; /* hsize */
1191 regs[0x16] = 240 / 16; /* vsize */
1192 }
1193
1194 /* reg 0x01 bit 2 video transfert on */
1195 reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1196 /* reg 0x17 SensorClk enable inv Clk 0x60 */
1197 reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1198 /* Set the registers from the template */
1199 reg_w(gspca_dev, 0x01, &regs[0x01],
1200 (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f);
1201
1202 /* Init the sensor */
1203 i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
1204 sensor_data[sd->sensor].sensor_init_size);
1205
1206 /* Mode / bridge specific sensor setup */
1207 switch (sd->sensor) {
1208 case SENSOR_PAS202: {
1209 const __u8 i2cpclockdiv[] =
1210 {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10};
1211 /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
1212 if (mode)
1213 i2c_w(gspca_dev, i2cpclockdiv);
1214 break;
1215 }
1216 case SENSOR_OV7630:
1217 /* FIXME / TESTME We should be able to handle this identical
1218 for the 101/102 and the 103 case */
1219 if (sd->bridge == BRIDGE_103) {
1220 const __u8 i2c[] = { 0xa0, 0x21, 0x13,
1221 0x80, 0x00, 0x00, 0x00, 0x10 };
1222 i2c_w(gspca_dev, i2c);
1223 }
1224 break;
1225 }
1226 /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
1227 reg_w(gspca_dev, 0x15, &regs[0x15], 2);
1228 /* compression register */
1229 reg_w(gspca_dev, 0x18, &regs[0x18], 1);
1230 /* H_start */
1231 reg_w(gspca_dev, 0x12, &regs[0x12], 1);
1232 /* V_START */
1233 reg_w(gspca_dev, 0x13, &regs[0x13], 1);
1234 /* reset 0x17 SensorClk enable inv Clk 0x60 */
1235 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
1236 reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1237 /*MCKSIZE ->3 */ /*fixme: not ov7630*/
1238 reg_w(gspca_dev, 0x19, &regs[0x19], 1);
1239 /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
1240 reg_w(gspca_dev, 0x1c, &regs[0x1c], 4);
1241 /* Enable video transfert */
1242 reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1243 /* Compression */
1244 reg_w(gspca_dev, 0x18, &regs[0x18], 2);
1245 msleep(20);
1246
1247 sd->reg11 = -1;
1248
1249 setgain(gspca_dev);
1250 setbrightness(gspca_dev);
1251 setexposure(gspca_dev);
1252 setfreq(gspca_dev);
1253
1254 sd->frames_to_drop = 0;
1255 sd->autogain_ignore_frames = 0;
1256 sd->exp_too_high_cnt = 0;
1257 sd->exp_too_low_cnt = 0;
1258 atomic_set(&sd->avg_lum, -1);
1259 return 0;
1260 }
1261
1262 static void sd_stopN(struct gspca_dev *gspca_dev)
1263 {
1264 sd_init(gspca_dev);
1265 }
1266
1267 static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
1268 {
1269 struct sd *sd = (struct sd *) gspca_dev;
1270 int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12;
1271
1272 /* frames start with:
1273 * ff ff 00 c4 c4 96 synchro
1274 * 00 (unknown)
1275 * xx (frame sequence / size / compression)
1276 * (xx) (idem - extra byte for sn9c103)
1277 * ll mm brightness sum inside auto exposure
1278 * ll mm brightness sum outside auto exposure
1279 * (xx xx xx xx xx) audio values for snc103
1280 */
1281 for (i = 0; i < len; i++) {
1282 switch (sd->header_read) {
1283 case 0:
1284 if (data[i] == 0xff)
1285 sd->header_read++;
1286 break;
1287 case 1:
1288 if (data[i] == 0xff)
1289 sd->header_read++;
1290 else
1291 sd->header_read = 0;
1292 break;
1293 case 2:
1294 if (data[i] == 0x00)
1295 sd->header_read++;
1296 else if (data[i] != 0xff)
1297 sd->header_read = 0;
1298 break;
1299 case 3:
1300 if (data[i] == 0xc4)
1301 sd->header_read++;
1302 else if (data[i] == 0xff)
1303 sd->header_read = 1;
1304 else
1305 sd->header_read = 0;
1306 break;
1307 case 4:
1308 if (data[i] == 0xc4)
1309 sd->header_read++;
1310 else if (data[i] == 0xff)
1311 sd->header_read = 1;
1312 else
1313 sd->header_read = 0;
1314 break;
1315 case 5:
1316 if (data[i] == 0x96)
1317 sd->header_read++;
1318 else if (data[i] == 0xff)
1319 sd->header_read = 1;
1320 else
1321 sd->header_read = 0;
1322 break;
1323 default:
1324 sd->header[sd->header_read - 6] = data[i];
1325 sd->header_read++;
1326 if (sd->header_read == header_size) {
1327 sd->header_read = 0;
1328 return data + i + 1;
1329 }
1330 }
1331 }
1332 return NULL;
1333 }
1334
1335 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1336 u8 *data, /* isoc packet */
1337 int len) /* iso packet length */
1338 {
1339 int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0;
1340 struct sd *sd = (struct sd *) gspca_dev;
1341 struct cam *cam = &gspca_dev->cam;
1342 u8 *sof;
1343
1344 sof = find_sof(gspca_dev, data, len);
1345 if (sof) {
1346 if (sd->bridge == BRIDGE_103) {
1347 fr_h_sz = 18;
1348 lum_offset = 3;
1349 } else {
1350 fr_h_sz = 12;
1351 lum_offset = 2;
1352 }
1353
1354 len_after_sof = len - (sof - data);
1355 len = (sof - data) - fr_h_sz;
1356 if (len < 0)
1357 len = 0;
1358 }
1359
1360 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1361 /* In raw mode we sometimes get some garbage after the frame
1362 ignore this */
1363 int used;
1364 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1365
1366 used = gspca_dev->image_len;
1367 if (used + len > size)
1368 len = size - used;
1369 }
1370
1371 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1372
1373 if (sof) {
1374 int lum = sd->header[lum_offset] +
1375 (sd->header[lum_offset + 1] << 8);
1376
1377 /* When exposure changes midway a frame we
1378 get a lum of 0 in this case drop 2 frames
1379 as the frames directly after an exposure
1380 change have an unstable image. Sometimes lum
1381 *really* is 0 (cam used in low light with
1382 low exposure setting), so do not drop frames
1383 if the previous lum was 0 too. */
1384 if (lum == 0 && sd->prev_avg_lum != 0) {
1385 lum = -1;
1386 sd->frames_to_drop = 2;
1387 sd->prev_avg_lum = 0;
1388 } else
1389 sd->prev_avg_lum = lum;
1390 atomic_set(&sd->avg_lum, lum);
1391
1392 if (sd->frames_to_drop)
1393 sd->frames_to_drop--;
1394 else
1395 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1396
1397 gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof);
1398 }
1399 }
1400
1401 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1402 {
1403 struct sd *sd = (struct sd *) gspca_dev;
1404
1405 sd->brightness = val;
1406 if (gspca_dev->streaming)
1407 setbrightness(gspca_dev);
1408 return 0;
1409 }
1410
1411 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1412 {
1413 struct sd *sd = (struct sd *) gspca_dev;
1414
1415 *val = sd->brightness;
1416 return 0;
1417 }
1418
1419 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1420 {
1421 struct sd *sd = (struct sd *) gspca_dev;
1422
1423 sd->gain = val;
1424 if (gspca_dev->streaming)
1425 setgain(gspca_dev);
1426 return 0;
1427 }
1428
1429 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1430 {
1431 struct sd *sd = (struct sd *) gspca_dev;
1432
1433 *val = sd->gain;
1434 return 0;
1435 }
1436
1437 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1438 {
1439 struct sd *sd = (struct sd *) gspca_dev;
1440
1441 sd->exposure = val;
1442 if (gspca_dev->streaming)
1443 setexposure(gspca_dev);
1444 return 0;
1445 }
1446
1447 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1448 {
1449 struct sd *sd = (struct sd *) gspca_dev;
1450
1451 *val = sd->exposure;
1452 return 0;
1453 }
1454
1455 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1456 {
1457 struct sd *sd = (struct sd *) gspca_dev;
1458
1459 sd->autogain = val;
1460 sd->exp_too_high_cnt = 0;
1461 sd->exp_too_low_cnt = 0;
1462
1463 /* when switching to autogain set defaults to make sure
1464 we are on a valid point of the autogain gain /
1465 exposure knee graph, and give this change time to
1466 take effect before doing autogain. */
1467 if (sd->autogain && !(sensor_data[sd->sensor].flags & F_COARSE_EXPO)) {
1468 sd->exposure = EXPOSURE_DEF;
1469 sd->gain = GAIN_DEF;
1470 if (gspca_dev->streaming) {
1471 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1472 setexposure(gspca_dev);
1473 setgain(gspca_dev);
1474 }
1475 }
1476
1477 return 0;
1478 }
1479
1480 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1481 {
1482 struct sd *sd = (struct sd *) gspca_dev;
1483
1484 *val = sd->autogain;
1485 return 0;
1486 }
1487
1488 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1489 {
1490 struct sd *sd = (struct sd *) gspca_dev;
1491
1492 sd->freq = val;
1493 if (gspca_dev->streaming)
1494 setfreq(gspca_dev);
1495 return 0;
1496 }
1497
1498 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1499 {
1500 struct sd *sd = (struct sd *) gspca_dev;
1501
1502 *val = sd->freq;
1503 return 0;
1504 }
1505
1506 static int sd_querymenu(struct gspca_dev *gspca_dev,
1507 struct v4l2_querymenu *menu)
1508 {
1509 switch (menu->id) {
1510 case V4L2_CID_POWER_LINE_FREQUENCY:
1511 switch (menu->index) {
1512 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1513 strcpy((char *) menu->name, "NoFliker");
1514 return 0;
1515 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1516 strcpy((char *) menu->name, "50 Hz");
1517 return 0;
1518 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1519 strcpy((char *) menu->name, "60 Hz");
1520 return 0;
1521 }
1522 break;
1523 }
1524 return -EINVAL;
1525 }
1526
1527 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1528 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1529 u8 *data, /* interrupt packet data */
1530 int len) /* interrupt packet length */
1531 {
1532 int ret = -EINVAL;
1533
1534 if (len == 1 && data[0] == 1) {
1535 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1536 input_sync(gspca_dev->input_dev);
1537 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1538 input_sync(gspca_dev->input_dev);
1539 ret = 0;
1540 }
1541
1542 return ret;
1543 }
1544 #endif
1545
1546 /* sub-driver description */
1547 static const struct sd_desc sd_desc = {
1548 .name = MODULE_NAME,
1549 .ctrls = sd_ctrls,
1550 .nctrls = ARRAY_SIZE(sd_ctrls),
1551 .config = sd_config,
1552 .init = sd_init,
1553 .start = sd_start,
1554 .stopN = sd_stopN,
1555 .pkt_scan = sd_pkt_scan,
1556 .querymenu = sd_querymenu,
1557 .dq_callback = do_autogain,
1558 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1559 .int_pkt_scan = sd_int_pkt_scan,
1560 #endif
1561 };
1562
1563 /* -- module initialisation -- */
1564 #define SB(sensor, bridge) \
1565 .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1566
1567
1568 static const struct usb_device_id device_table[] = {
1569 {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
1570 {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
1571 {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
1572 {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1573 {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1574 {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1575 {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1576 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1577 {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1578 {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1579 #endif
1580 {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1581 {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1582 {USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)},
1583 /* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */
1584 {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1585 {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1586 {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1587 /* {USB_DEVICE(0x0c45, 0x6030), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */
1588 /* {USB_DEVICE(0x0c45, 0x6082), SB(MI03XX, 103)}, */ /* MI0343 MI0360 */
1589 {USB_DEVICE(0x0c45, 0x6083), SB(HV7131D, 103)},
1590 {USB_DEVICE(0x0c45, 0x608c), SB(HV7131R, 103)},
1591 /* {USB_DEVICE(0x0c45, 0x608e), SB(CISVF10, 103)}, */
1592 {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1593 {USB_DEVICE(0x0c45, 0x60a8), SB(PAS106, 103)},
1594 {USB_DEVICE(0x0c45, 0x60aa), SB(TAS5130CXX, 103)},
1595 {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1596 {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1597 {}
1598 };
1599 MODULE_DEVICE_TABLE(usb, device_table);
1600
1601 /* -- device connect -- */
1602 static int sd_probe(struct usb_interface *intf,
1603 const struct usb_device_id *id)
1604 {
1605 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1606 THIS_MODULE);
1607 }
1608
1609 static struct usb_driver sd_driver = {
1610 .name = MODULE_NAME,
1611 .id_table = device_table,
1612 .probe = sd_probe,
1613 .disconnect = gspca_disconnect,
1614 #ifdef CONFIG_PM
1615 .suspend = gspca_suspend,
1616 .resume = gspca_resume,
1617 #endif
1618 };
1619
1620 /* -- module insert / remove -- */
1621 static int __init sd_mod_init(void)
1622 {
1623 return usb_register(&sd_driver);
1624 }
1625 static void __exit sd_mod_exit(void)
1626 {
1627 usb_deregister(&sd_driver);
1628 }
1629
1630 module_init(sd_mod_init);
1631 module_exit(sd_mod_exit);
Linux with added FPC-III support