2 * sonix sn9c102 (bayer) library
3 * Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr
4 * Add Pas106 Stefano Mozzi (C) 2004
6 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
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
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.
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
23 /* Some documentation on known sonixb registers:
27 0x10 high nibble red gain low nibble blue gain
28 0x11 low nibble green gain
34 0x08-0x0f i2c / 3wire registers
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)
50 #define MODULE_NAME "sonixb"
52 #include <linux/input.h>
55 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
56 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
57 MODULE_LICENSE("GPL");
59 /* specific webcam descriptor */
61 struct gspca_dev gspca_dev; /* !! must be the first item */
67 u8 header[12]; /* Header without sof marker */
69 unsigned short exposure;
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 */
77 __u8 bridge; /* Type of bridge */
79 #define BRIDGE_102 0 /* We make no difference between 101 and 102 */
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
95 typedef const __u8 sensor_init_t[8];
98 const __u8 *bridge_init;
99 sensor_init_t *sensor_init;
100 int sensor_init_size;
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 */
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 */
115 /* ctrl_dis helper macros */
116 #define NO_EXPO ((1 << EXPOSURE_IDX) | (1 << COARSE_EXPOSURE_IDX) | \
118 #define NO_FREQ (1 << FREQ_IDX)
119 #define NO_BRIGHTNESS (1 << BRIGHTNESS_IDX)
121 #define COMP 0xc7 /* 0x87 //0x07 */
122 #define COMP1 0xc9 /* 0x89 //0x09 */
124 #define MCK_INIT 0x63
125 #define MCK_INIT1 0x20 /*fixme: Bayer - 0x50 for JPEG ??*/
129 #define SENS(bridge, sensor, _flags, _ctrl_dis, _sensor_addr) \
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 \
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
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);
155 static const struct ctrl sd_ctrls[] = {
156 #define BRIGHTNESS_IDX 0
159 .id = V4L2_CID_BRIGHTNESS,
160 .type = V4L2_CTRL_TYPE_INTEGER,
161 .name = "Brightness",
165 #define BRIGHTNESS_DEF 127
166 .default_value = BRIGHTNESS_DEF,
168 .set = sd_setbrightness,
169 .get = sd_getbrightness,
175 .type = V4L2_CTRL_TYPE_INTEGER,
181 #define GAIN_KNEE 230
182 .default_value = GAIN_DEF,
187 #define EXPOSURE_IDX 2
190 .id = V4L2_CID_EXPOSURE,
191 .type = V4L2_CTRL_TYPE_INTEGER,
193 #define EXPOSURE_DEF 66 /* 33 ms / 30 fps (except on PASXXX) */
194 #define EXPOSURE_KNEE 200 /* 100 ms / 10 fps (except on PASXXX) */
198 .default_value = EXPOSURE_DEF,
201 .set = sd_setexposure,
202 .get = sd_getexposure,
204 #define COARSE_EXPOSURE_IDX 3
207 .id = V4L2_CID_EXPOSURE,
208 .type = V4L2_CTRL_TYPE_INTEGER,
210 #define COARSE_EXPOSURE_DEF 2 /* 30 fps */
214 .default_value = COARSE_EXPOSURE_DEF,
217 .set = sd_setexposure,
218 .get = sd_getexposure,
220 #define AUTOGAIN_IDX 4
223 .id = V4L2_CID_AUTOGAIN,
224 .type = V4L2_CTRL_TYPE_BOOLEAN,
225 .name = "Automatic Gain (and Exposure)",
229 #define AUTOGAIN_DEF 1
230 .default_value = AUTOGAIN_DEF,
233 .set = sd_setautogain,
234 .get = sd_getautogain,
239 .id = V4L2_CID_POWER_LINE_FREQUENCY,
240 .type = V4L2_CTRL_TYPE_MENU,
241 .name = "Light frequency filter",
243 .maximum = 2, /* 0: 0, 1: 50Hz, 2:60Hz */
246 .default_value = FREQ_DEF,
253 static const struct v4l2_pix_format vga_mode[] = {
254 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
256 .sizeimage = 160 * 120,
257 .colorspace = V4L2_COLORSPACE_SRGB,
258 .priv = 2 | MODE_RAW},
259 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
261 .sizeimage = 160 * 120 * 5 / 4,
262 .colorspace = V4L2_COLORSPACE_SRGB,
264 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
266 .sizeimage = 320 * 240 * 5 / 4,
267 .colorspace = V4L2_COLORSPACE_SRGB,
269 {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
271 .sizeimage = 640 * 480 * 5 / 4,
272 .colorspace = V4L2_COLORSPACE_SRGB,
275 static const struct v4l2_pix_format sif_mode[] = {
276 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
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,
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,
288 .sizeimage = 176 * 144,
289 .colorspace = V4L2_COLORSPACE_SRGB,
290 .priv = 1 | MODE_RAW},
291 {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
293 .sizeimage = 176 * 144 * 5 / 4,
294 .colorspace = V4L2_COLORSPACE_SRGB,
296 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
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,
303 .sizeimage = 352 * 288 * 5 / 4,
304 .colorspace = V4L2_COLORSPACE_SRGB,
308 static const __u8 initHv7131d[] = {
309 0x04, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x02, 0x02, 0x00,
312 0x28, 0x1e, 0x60, 0x8e, 0x42,
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 */
322 static const __u8 initHv7131r[] = {
323 0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
325 0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
326 0x28, 0x1e, 0x60, 0x8a, 0x20,
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},
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,
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 */
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 */
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 */
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, 0x1c, 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},
402 static const __u8 initPas106[] = {
403 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
405 0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
406 0x16, 0x12, 0x24, COMP1, MCK_INIT1,
408 /* compression 0x86 mckinit1 0x2b */
410 /* "Known" PAS106B registers:
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)
430 0x13 Write 1 to commit settings to sensor
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 },
460 { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 },
462 { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 },
463 /* H&V synchro polarity */
464 { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 },
466 { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 },
468 { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 },
470 { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 },
471 /* Validate Settings */
472 { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 },
475 static const __u8 initPas202[] = {
476 0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
478 0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
479 0x28, 0x1e, 0x20, 0x89, 0x20,
482 /* "Known" PAS202BCB registers:
484 0x04 Variable framerate bits 6-11 (*)
485 0x05 Var framerate bits 0-5, one must leave the 2 msb's at 0 !!
489 0x0b offset sign bit (bit0 1 > negative 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.
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
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},
515 static const __u8 initTas5110c[] = {
516 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
518 0x00, 0x00, 0x00, 0x45, 0x09, 0x0a,
519 0x16, 0x12, 0x60, 0x86, 0x2b,
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,
525 0x00, 0x00, 0x00, 0x41, 0x09, 0x0a,
526 0x16, 0x12, 0x60, 0x86, 0x2b,
528 static const __u8 tas5110_sensor_init[][8] = {
529 {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
530 {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
531 {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17},
534 static const __u8 initTas5130[] = {
535 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
537 0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a,
538 0x28, 0x1e, 0x60, COMP, MCK_INIT,
540 static const __u8 tas5130_sensor_init[][8] = {
541 /* {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
542 * shutter 0x47 short exposure? */
543 {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
544 /* shutter 0x01 long exposure */
545 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
548 static struct sensor_data sensor_data[] = {
549 SENS(initHv7131d, hv7131d_sensor_init, F_GAIN, NO_BRIGHTNESS|NO_FREQ, 0),
550 SENS(initHv7131r, hv7131r_sensor_init, 0, NO_BRIGHTNESS|NO_EXPO|NO_FREQ, 0),
551 SENS(initOv6650, ov6650_sensor_init, F_GAIN|F_SIF, 0, 0x60),
552 SENS(initOv7630, ov7630_sensor_init, F_GAIN, 0, 0x21),
553 SENS(initPas106, pas106_sensor_init, F_GAIN|F_SIF, NO_FREQ, 0),
554 SENS(initPas202, pas202_sensor_init, F_GAIN, NO_FREQ, 0),
555 SENS(initTas5110c, tas5110_sensor_init, F_GAIN|F_SIF|F_COARSE_EXPO,
556 NO_BRIGHTNESS|NO_FREQ, 0),
557 SENS(initTas5110d, tas5110_sensor_init, F_GAIN|F_SIF|F_COARSE_EXPO,
558 NO_BRIGHTNESS|NO_FREQ, 0),
559 SENS(initTas5130, tas5130_sensor_init, 0, NO_EXPO|NO_FREQ, 0),
562 /* get one byte in gspca_dev->usb_buf */
563 static void reg_r(struct gspca_dev *gspca_dev,
566 usb_control_msg(gspca_dev->dev,
567 usb_rcvctrlpipe(gspca_dev->dev, 0),
569 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
572 gspca_dev->usb_buf, 1,
576 static void reg_w(struct gspca_dev *gspca_dev,
582 if (len > USB_BUF_SZ) {
583 PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
587 memcpy(gspca_dev->usb_buf, buffer, len);
588 usb_control_msg(gspca_dev->dev,
589 usb_sndctrlpipe(gspca_dev->dev, 0),
591 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
594 gspca_dev->usb_buf, len,
598 static int i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer)
603 reg_w(gspca_dev, 0x08, buffer, 8);
606 reg_r(gspca_dev, 0x08);
607 if (gspca_dev->usb_buf[0] & 0x04) {
608 if (gspca_dev->usb_buf[0] & 0x08)
616 static void i2c_w_vector(struct gspca_dev *gspca_dev,
617 const __u8 buffer[][8], int len)
620 reg_w(gspca_dev, 0x08, *buffer, 8);
628 static void setbrightness(struct gspca_dev *gspca_dev)
630 struct sd *sd = (struct sd *) gspca_dev;
633 switch (sd->sensor) {
635 case SENSOR_OV7630: {
637 {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
639 /* change reg 0x06 */
640 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
641 i2cOV[3] = sd->brightness;
642 if (i2c_w(gspca_dev, i2cOV) < 0)
647 case SENSOR_PAS202: {
649 {0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16};
651 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
653 /* PAS106 uses reg 7 and 8 instead of b and c */
654 if (sd->sensor == SENSOR_PAS106) {
659 if (sd->brightness < 127) {
660 /* change reg 0x0b, signreg */
661 i2cpbright[3] = 0x01;
662 /* set reg 0x0c, offset */
663 i2cpbright[4] = 127 - sd->brightness;
665 i2cpbright[4] = sd->brightness - 127;
667 if (i2c_w(gspca_dev, i2cpbright) < 0)
669 if (i2c_w(gspca_dev, i2cpdoit) < 0)
673 case SENSOR_TAS5130CXX: {
675 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
677 value = 0xff - sd->brightness;
679 PDEBUG(D_CONF, "brightness %d : %d", value, i2c[4]);
680 if (i2c_w(gspca_dev, i2c) < 0)
687 PDEBUG(D_ERR, "i2c error brightness");
690 static void setsensorgain(struct gspca_dev *gspca_dev)
692 struct sd *sd = (struct sd *) gspca_dev;
693 unsigned char gain = sd->gain;
695 switch (sd->sensor) {
696 case SENSOR_HV7131D: {
698 {0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17};
700 i2c[3] = 0x3f - (sd->gain / 4);
701 i2c[4] = 0x3f - (sd->gain / 4);
702 i2c[5] = 0x3f - (sd->gain / 4);
704 if (i2c_w(gspca_dev, i2c) < 0)
708 case SENSOR_TAS5110C:
709 case SENSOR_TAS5110D: {
711 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
714 if (i2c_w(gspca_dev, i2c) < 0)
722 case SENSOR_OV7630: {
723 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
725 i2c[1] = sensor_data[sd->sensor].sensor_addr;
727 if (i2c_w(gspca_dev, i2c) < 0)
732 case SENSOR_PAS202: {
734 {0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15};
735 __u8 i2cpcolorgain[] =
736 {0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15};
738 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
740 /* PAS106 uses different regs (and has split green gains) */
741 if (sd->sensor == SENSOR_PAS106) {
743 i2cpcolorgain[0] = 0xd0;
744 i2cpcolorgain[2] = 0x09;
748 i2cpgain[3] = sd->gain >> 3;
749 i2cpcolorgain[3] = sd->gain >> 4;
750 i2cpcolorgain[4] = sd->gain >> 4;
751 i2cpcolorgain[5] = sd->gain >> 4;
752 i2cpcolorgain[6] = sd->gain >> 4;
754 if (i2c_w(gspca_dev, i2cpgain) < 0)
756 if (i2c_w(gspca_dev, i2cpcolorgain) < 0)
758 if (i2c_w(gspca_dev, i2cpdoit) < 0)
765 PDEBUG(D_ERR, "i2c error gain");
768 static void setgain(struct gspca_dev *gspca_dev)
770 struct sd *sd = (struct sd *) gspca_dev;
772 __u8 buf[3] = { 0, 0, 0 };
774 if (sensor_data[sd->sensor].flags & F_GAIN) {
775 /* Use the sensor gain to do the actual gain */
776 setsensorgain(gspca_dev);
780 if (sd->bridge == BRIDGE_103) {
781 gain = sd->gain >> 1;
782 buf[0] = gain; /* Red */
783 buf[1] = gain; /* Green */
784 buf[2] = gain; /* Blue */
785 reg_w(gspca_dev, 0x05, buf, 3);
787 gain = sd->gain >> 4;
788 buf[0] = gain << 4 | gain; /* Red and blue */
789 buf[1] = gain; /* Green */
790 reg_w(gspca_dev, 0x10, buf, 2);
794 static void setexposure(struct gspca_dev *gspca_dev)
796 struct sd *sd = (struct sd *) gspca_dev;
798 switch (sd->sensor) {
799 case SENSOR_HV7131D: {
800 /* Note the datasheet wrongly says line mode exposure uses reg
801 0x26 and 0x27, testing has shown 0x25 + 0x26 */
802 __u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17};
803 /* The HV7131D's exposure goes from 0 - 65535, we scale our
804 exposure of 0-1023 to 0-6138. There are 2 reasons for this:
805 1) This puts our exposure knee of 200 at approx the point
806 where the framerate starts dropping
807 2) At 6138 the framerate has already dropped to 2 fps,
808 going any lower makes little sense */
809 __u16 reg = sd->exposure * 6;
812 if (i2c_w(gspca_dev, i2c) != 0)
816 case SENSOR_TAS5110C:
817 case SENSOR_TAS5110D: {
818 /* register 19's high nibble contains the sn9c10x clock divider
819 The high nibble configures the no fps according to the
820 formula: 60 / high_nibble. With a maximum of 30 fps */
821 __u8 reg = sd->exposure;
822 reg = (reg << 4) | 0x0b;
823 reg_w(gspca_dev, 0x19, ®, 1);
827 case SENSOR_OV7630: {
828 /* The ov6650 / ov7630 have 2 registers which both influence
829 exposure, register 11, whose low nibble sets the nr off fps
830 according to: fps = 30 / (low_nibble + 1)
832 The fps configures the maximum exposure setting, but it is
833 possible to use less exposure then what the fps maximum
834 allows by setting register 10. register 10 configures the
835 actual exposure as quotient of the full exposure, with 0
836 being no exposure at all (not very usefull) and reg10_max
837 being max exposure possible at that framerate.
839 The code maps our 0 - 510 ms exposure ctrl to these 2
840 registers, trying to keep fps as high as possible.
842 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
843 int reg10, reg11, reg10_max;
845 /* ov6645 datasheet says reg10_max is 9a, but that uses
846 tline * 2 * reg10 as formula for calculating texpo, the
847 ov6650 probably uses the same formula as the 7730 which uses
848 tline * 4 * reg10, which explains why the reg10max we've
849 found experimentally for the ov6650 is exactly half that of
850 the ov6645. The ov7630 datasheet says the max is 0x41. */
851 if (sd->sensor == SENSOR_OV6650) {
853 i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
857 reg11 = (15 * sd->exposure + 999) / 1000;
863 /* In 640x480, if the reg11 has less than 4, the image is
864 unstable (the bridge goes into a higher compression mode
865 which we have not reverse engineered yet). */
866 if (gspca_dev->width == 640 && reg11 < 4)
869 /* frame exposure time in ms = 1000 * reg11 / 30 ->
870 reg10 = (sd->exposure / 2) * reg10_max / (1000 * reg11 / 30) */
871 reg10 = (sd->exposure * 15 * reg10_max) / (1000 * reg11);
873 /* Don't allow this to get below 10 when using autogain, the
874 steps become very large (relatively) when below 10 causing
875 the image to oscilate from much too dark, to much too bright
877 if (sd->autogain && reg10 < 10)
879 else if (reg10 > reg10_max)
882 /* Write reg 10 and reg11 low nibble */
883 i2c[1] = sensor_data[sd->sensor].sensor_addr;
887 /* If register 11 didn't change, don't change it */
888 if (sd->reg11 == reg11)
891 if (i2c_w(gspca_dev, i2c) == 0)
897 case SENSOR_PAS202: {
898 __u8 i2cpframerate[] =
899 {0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16};
901 {0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16};
902 const __u8 i2cpdoit[] =
903 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
906 /* The exposure knee for the autogain algorithm is 200
907 (100 ms / 10 fps on other sensors), for values below this
908 use the control for setting the partial frame expose time,
909 above that use variable framerate. This way we run at max
910 framerate (640x480@7.5 fps, 320x240@10fps) until the knee
911 is reached. Using the variable framerate control above 200
912 is better then playing around with both clockdiv + partial
913 frame exposure times (like we are doing with the ov chips),
914 as that sometimes leads to jumps in the exposure control,
915 which are bad for auto exposure. */
916 if (sd->exposure < 200) {
917 i2cpexpo[3] = 255 - (sd->exposure * 255) / 200;
918 framerate_ctrl = 500;
920 /* The PAS202's exposure control goes from 0 - 4095,
921 but anything below 500 causes vsync issues, so scale
922 our 200-1023 to 500-4095 */
923 framerate_ctrl = (sd->exposure - 200) * 1000 / 229 +
927 i2cpframerate[3] = framerate_ctrl >> 6;
928 i2cpframerate[4] = framerate_ctrl & 0x3f;
929 if (i2c_w(gspca_dev, i2cpframerate) < 0)
931 if (i2c_w(gspca_dev, i2cpexpo) < 0)
933 if (i2c_w(gspca_dev, i2cpdoit) < 0)
937 case SENSOR_PAS106: {
938 __u8 i2cpframerate[] =
939 {0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14};
941 {0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14};
942 const __u8 i2cpdoit[] =
943 {0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14};
946 /* For values below 150 use partial frame exposure, above
947 that use framerate ctrl */
948 if (sd->exposure < 150) {
949 i2cpexpo[3] = 150 - sd->exposure;
950 framerate_ctrl = 300;
952 /* The PAS106's exposure control goes from 0 - 4095,
953 but anything below 300 causes vsync issues, so scale
954 our 150-1023 to 300-4095 */
955 framerate_ctrl = (sd->exposure - 150) * 1000 / 230 +
959 i2cpframerate[3] = framerate_ctrl >> 4;
960 i2cpframerate[4] = framerate_ctrl & 0x0f;
961 if (i2c_w(gspca_dev, i2cpframerate) < 0)
963 if (i2c_w(gspca_dev, i2cpexpo) < 0)
965 if (i2c_w(gspca_dev, i2cpdoit) < 0)
972 PDEBUG(D_ERR, "i2c error exposure");
975 static void setfreq(struct gspca_dev *gspca_dev)
977 struct sd *sd = (struct sd *) gspca_dev;
979 switch (sd->sensor) {
981 case SENSOR_OV7630: {
982 /* Framerate adjust register for artificial light 50 hz flicker
983 compensation, for the ov6650 this is identical to ov6630
984 0x2b register, see ov6630 datasheet.
985 0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
986 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
989 /* case 0: * no filter*/
990 /* case 2: * 60 hz */
994 i2c[3] = (sd->sensor == SENSOR_OV6650)
998 i2c[1] = sensor_data[sd->sensor].sensor_addr;
999 if (i2c_w(gspca_dev, i2c) < 0)
1000 PDEBUG(D_ERR, "i2c error setfreq");
1006 #include "coarse_expo_autogain.h"
1008 static void do_autogain(struct gspca_dev *gspca_dev)
1010 int deadzone, desired_avg_lum, result;
1011 struct sd *sd = (struct sd *) gspca_dev;
1012 int avg_lum = atomic_read(&sd->avg_lum);
1014 if (avg_lum == -1 || !sd->autogain)
1017 if (sd->autogain_ignore_frames > 0) {
1018 sd->autogain_ignore_frames--;
1022 /* SIF / VGA sensors have a different autoexposure area and thus
1023 different avg_lum values for the same picture brightness */
1024 if (sensor_data[sd->sensor].flags & F_SIF) {
1026 /* SIF sensors tend to overexpose, so keep this small */
1027 desired_avg_lum = 5000;
1030 desired_avg_lum = 18000;
1033 if (sensor_data[sd->sensor].flags & F_COARSE_EXPO)
1034 result = gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
1035 sd->brightness * desired_avg_lum / 127,
1038 result = gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
1039 sd->brightness * desired_avg_lum / 127,
1040 deadzone, GAIN_KNEE, EXPOSURE_KNEE);
1043 PDEBUG(D_FRAM, "autogain: gain changed: gain: %d expo: %d",
1044 (int)sd->gain, (int)sd->exposure);
1045 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1049 /* this function is called at probe time */
1050 static int sd_config(struct gspca_dev *gspca_dev,
1051 const struct usb_device_id *id)
1053 struct sd *sd = (struct sd *) gspca_dev;
1056 reg_r(gspca_dev, 0x00);
1057 if (gspca_dev->usb_buf[0] != 0x10)
1060 /* copy the webcam info from the device id */
1061 sd->sensor = id->driver_info >> 8;
1062 sd->bridge = id->driver_info & 0xff;
1063 gspca_dev->ctrl_dis = sensor_data[sd->sensor].ctrl_dis;
1065 cam = &gspca_dev->cam;
1066 if (!(sensor_data[sd->sensor].flags & F_SIF)) {
1067 cam->cam_mode = vga_mode;
1068 cam->nmodes = ARRAY_SIZE(vga_mode);
1070 cam->cam_mode = sif_mode;
1071 cam->nmodes = ARRAY_SIZE(sif_mode);
1073 cam->npkt = 36; /* 36 packets per ISOC message */
1075 sd->brightness = BRIGHTNESS_DEF;
1076 sd->gain = GAIN_DEF;
1077 if (sensor_data[sd->sensor].flags & F_COARSE_EXPO) {
1078 sd->exposure = COARSE_EXPOSURE_DEF;
1079 gspca_dev->ctrl_dis |= (1 << EXPOSURE_IDX);
1081 sd->exposure = EXPOSURE_DEF;
1082 gspca_dev->ctrl_dis |= (1 << COARSE_EXPOSURE_IDX);
1084 if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
1085 sd->autogain = 0; /* Disable do_autogain callback */
1087 sd->autogain = AUTOGAIN_DEF;
1088 sd->freq = FREQ_DEF;
1093 /* this function is called at probe and resume time */
1094 static int sd_init(struct gspca_dev *gspca_dev)
1096 const __u8 stop = 0x09; /* Disable stream turn of LED */
1098 reg_w(gspca_dev, 0x01, &stop, 1);
1103 /* -- start the camera -- */
1104 static int sd_start(struct gspca_dev *gspca_dev)
1106 struct sd *sd = (struct sd *) gspca_dev;
1107 struct cam *cam = &gspca_dev->cam;
1111 mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
1112 /* Copy registers 0x01 - 0x19 from the template */
1113 memcpy(®s[0x01], sensor_data[sd->sensor].bridge_init, 0x19);
1115 regs[0x18] |= mode << 4;
1117 /* Set bridge gain to 1.0 */
1118 if (sd->bridge == BRIDGE_103) {
1119 regs[0x05] = 0x20; /* Red */
1120 regs[0x06] = 0x20; /* Green */
1121 regs[0x07] = 0x20; /* Blue */
1123 regs[0x10] = 0x00; /* Red and blue */
1124 regs[0x11] = 0x00; /* Green */
1127 /* Setup pixel numbers and auto exposure window */
1128 if (sensor_data[sd->sensor].flags & F_SIF) {
1129 regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */
1130 regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */
1131 regs[0x1c] = 0x02; /* AE H-start 64 */
1132 regs[0x1d] = 0x02; /* AE V-start 64 */
1133 regs[0x1e] = 0x09; /* AE H-end 288 */
1134 regs[0x1f] = 0x07; /* AE V-end 224 */
1136 regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */
1137 regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */
1138 regs[0x1c] = 0x02; /* AE H-start 64 */
1139 regs[0x1d] = 0x03; /* AE V-start 96 */
1140 regs[0x1e] = 0x0f; /* AE H-end 480 */
1141 regs[0x1f] = 0x0c; /* AE V-end 384 */
1144 /* Setup the gamma table (only used with the sn9c103 bridge) */
1145 for (i = 0; i < 16; i++)
1146 regs[0x20 + i] = i * 16;
1147 regs[0x20 + i] = 255;
1149 /* Special cases where some regs depend on mode or bridge */
1150 switch (sd->sensor) {
1151 case SENSOR_TAS5130CXX:
1153 probably not mode specific at all most likely the upper
1154 nibble of 0x19 is exposure (clock divider) just as with
1155 the tas5110, we need someone to test this. */
1156 regs[0x19] = mode ? 0x23 : 0x43;
1159 /* FIXME / TESTME for some reason with the 101/102 bridge the
1160 clock is set to 12 Mhz (reg1 == 0x04), rather then 24.
1161 Also the hstart needs to go from 1 to 2 when using a 103,
1162 which is likely related. This does not seem right. */
1163 if (sd->bridge == BRIDGE_103) {
1164 regs[0x01] = 0x44; /* Select 24 Mhz clock */
1165 regs[0x12] = 0x02; /* Set hstart to 2 */
1168 /* Disable compression when the raw bayer format has been selected */
1169 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
1170 regs[0x18] &= ~0x80;
1172 /* Vga mode emulation on SIF sensor? */
1173 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
1174 regs[0x12] += 16; /* hstart adjust */
1175 regs[0x13] += 24; /* vstart adjust */
1176 regs[0x15] = 320 / 16; /* hsize */
1177 regs[0x16] = 240 / 16; /* vsize */
1180 /* reg 0x01 bit 2 video transfert on */
1181 reg_w(gspca_dev, 0x01, ®s[0x01], 1);
1182 /* reg 0x17 SensorClk enable inv Clk 0x60 */
1183 reg_w(gspca_dev, 0x17, ®s[0x17], 1);
1184 /* Set the registers from the template */
1185 reg_w(gspca_dev, 0x01, ®s[0x01],
1186 (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f);
1188 /* Init the sensor */
1189 i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
1190 sensor_data[sd->sensor].sensor_init_size);
1192 /* Mode / bridge specific sensor setup */
1193 switch (sd->sensor) {
1194 case SENSOR_PAS202: {
1195 const __u8 i2cpclockdiv[] =
1196 {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10};
1197 /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
1199 i2c_w(gspca_dev, i2cpclockdiv);
1203 /* FIXME / TESTME We should be able to handle this identical
1204 for the 101/102 and the 103 case */
1205 if (sd->bridge == BRIDGE_103) {
1206 const __u8 i2c[] = { 0xa0, 0x21, 0x13,
1207 0x80, 0x00, 0x00, 0x00, 0x10 };
1208 i2c_w(gspca_dev, i2c);
1212 /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
1213 reg_w(gspca_dev, 0x15, ®s[0x15], 2);
1214 /* compression register */
1215 reg_w(gspca_dev, 0x18, ®s[0x18], 1);
1217 reg_w(gspca_dev, 0x12, ®s[0x12], 1);
1219 reg_w(gspca_dev, 0x13, ®s[0x13], 1);
1220 /* reset 0x17 SensorClk enable inv Clk 0x60 */
1221 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
1222 reg_w(gspca_dev, 0x17, ®s[0x17], 1);
1223 /*MCKSIZE ->3 */ /*fixme: not ov7630*/
1224 reg_w(gspca_dev, 0x19, ®s[0x19], 1);
1225 /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
1226 reg_w(gspca_dev, 0x1c, ®s[0x1c], 4);
1227 /* Enable video transfert */
1228 reg_w(gspca_dev, 0x01, ®s[0x01], 1);
1230 reg_w(gspca_dev, 0x18, ®s[0x18], 2);
1236 setbrightness(gspca_dev);
1237 setexposure(gspca_dev);
1240 sd->frames_to_drop = 0;
1241 sd->autogain_ignore_frames = 0;
1242 sd->exp_too_high_cnt = 0;
1243 sd->exp_too_low_cnt = 0;
1244 atomic_set(&sd->avg_lum, -1);
1248 static void sd_stopN(struct gspca_dev *gspca_dev)
1253 static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
1255 struct sd *sd = (struct sd *) gspca_dev;
1256 int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12;
1258 /* frames start with:
1259 * ff ff 00 c4 c4 96 synchro
1261 * xx (frame sequence / size / compression)
1262 * (xx) (idem - extra byte for sn9c103)
1263 * ll mm brightness sum inside auto exposure
1264 * ll mm brightness sum outside auto exposure
1265 * (xx xx xx xx xx) audio values for snc103
1267 for (i = 0; i < len; i++) {
1268 switch (sd->header_read) {
1270 if (data[i] == 0xff)
1274 if (data[i] == 0xff)
1277 sd->header_read = 0;
1280 if (data[i] == 0x00)
1282 else if (data[i] != 0xff)
1283 sd->header_read = 0;
1286 if (data[i] == 0xc4)
1288 else if (data[i] == 0xff)
1289 sd->header_read = 1;
1291 sd->header_read = 0;
1294 if (data[i] == 0xc4)
1296 else if (data[i] == 0xff)
1297 sd->header_read = 1;
1299 sd->header_read = 0;
1302 if (data[i] == 0x96)
1304 else if (data[i] == 0xff)
1305 sd->header_read = 1;
1307 sd->header_read = 0;
1310 sd->header[sd->header_read - 6] = data[i];
1312 if (sd->header_read == header_size) {
1313 sd->header_read = 0;
1314 return data + i + 1;
1321 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1322 u8 *data, /* isoc packet */
1323 int len) /* iso packet length */
1325 int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0;
1326 struct sd *sd = (struct sd *) gspca_dev;
1327 struct cam *cam = &gspca_dev->cam;
1330 sof = find_sof(gspca_dev, data, len);
1332 if (sd->bridge == BRIDGE_103) {
1340 len_after_sof = len - (sof - data);
1341 len = (sof - data) - fr_h_sz;
1346 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1347 /* In raw mode we sometimes get some garbage after the frame
1350 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1352 used = gspca_dev->image_len;
1353 if (used + len > size)
1357 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1360 int lum = sd->header[lum_offset] +
1361 (sd->header[lum_offset + 1] << 8);
1363 /* When exposure changes midway a frame we
1364 get a lum of 0 in this case drop 2 frames
1365 as the frames directly after an exposure
1366 change have an unstable image. Sometimes lum
1367 *really* is 0 (cam used in low light with
1368 low exposure setting), so do not drop frames
1369 if the previous lum was 0 too. */
1370 if (lum == 0 && sd->prev_avg_lum != 0) {
1372 sd->frames_to_drop = 2;
1373 sd->prev_avg_lum = 0;
1375 sd->prev_avg_lum = lum;
1376 atomic_set(&sd->avg_lum, lum);
1378 if (sd->frames_to_drop)
1379 sd->frames_to_drop--;
1381 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1383 gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof);
1387 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1389 struct sd *sd = (struct sd *) gspca_dev;
1391 sd->brightness = val;
1392 if (gspca_dev->streaming)
1393 setbrightness(gspca_dev);
1397 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1399 struct sd *sd = (struct sd *) gspca_dev;
1401 *val = sd->brightness;
1405 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1407 struct sd *sd = (struct sd *) gspca_dev;
1410 if (gspca_dev->streaming)
1415 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1417 struct sd *sd = (struct sd *) gspca_dev;
1423 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1425 struct sd *sd = (struct sd *) gspca_dev;
1428 if (gspca_dev->streaming)
1429 setexposure(gspca_dev);
1433 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1435 struct sd *sd = (struct sd *) gspca_dev;
1437 *val = sd->exposure;
1441 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1443 struct sd *sd = (struct sd *) gspca_dev;
1446 sd->exp_too_high_cnt = 0;
1447 sd->exp_too_low_cnt = 0;
1449 /* when switching to autogain set defaults to make sure
1450 we are on a valid point of the autogain gain /
1451 exposure knee graph, and give this change time to
1452 take effect before doing autogain. */
1453 if (sd->autogain && !(sensor_data[sd->sensor].flags & F_COARSE_EXPO)) {
1454 sd->exposure = EXPOSURE_DEF;
1455 sd->gain = GAIN_DEF;
1456 if (gspca_dev->streaming) {
1457 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1458 setexposure(gspca_dev);
1466 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1468 struct sd *sd = (struct sd *) gspca_dev;
1470 *val = sd->autogain;
1474 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1476 struct sd *sd = (struct sd *) gspca_dev;
1479 if (gspca_dev->streaming)
1484 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1486 struct sd *sd = (struct sd *) gspca_dev;
1492 static int sd_querymenu(struct gspca_dev *gspca_dev,
1493 struct v4l2_querymenu *menu)
1496 case V4L2_CID_POWER_LINE_FREQUENCY:
1497 switch (menu->index) {
1498 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1499 strcpy((char *) menu->name, "NoFliker");
1501 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1502 strcpy((char *) menu->name, "50 Hz");
1504 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1505 strcpy((char *) menu->name, "60 Hz");
1513 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1514 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1515 u8 *data, /* interrupt packet data */
1516 int len) /* interrupt packet length */
1520 if (len == 1 && data[0] == 1) {
1521 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1522 input_sync(gspca_dev->input_dev);
1523 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1524 input_sync(gspca_dev->input_dev);
1532 /* sub-driver description */
1533 static const struct sd_desc sd_desc = {
1534 .name = MODULE_NAME,
1536 .nctrls = ARRAY_SIZE(sd_ctrls),
1537 .config = sd_config,
1541 .pkt_scan = sd_pkt_scan,
1542 .querymenu = sd_querymenu,
1543 .dq_callback = do_autogain,
1544 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1545 .int_pkt_scan = sd_int_pkt_scan,
1549 /* -- module initialisation -- */
1550 #define SB(sensor, bridge) \
1551 .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1554 static const struct usb_device_id device_table[] __devinitconst = {
1555 {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
1556 {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
1557 {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
1558 {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1559 {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1560 {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1561 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1562 {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1563 {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1564 {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1566 {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1567 {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1568 {USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)},
1569 /* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */
1570 {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1571 {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1572 {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1573 /* {USB_DEVICE(0x0c45, 0x602b), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */
1574 {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1575 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1576 {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1578 {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1581 MODULE_DEVICE_TABLE(usb, device_table);
1583 /* -- device connect -- */
1584 static int __devinit sd_probe(struct usb_interface *intf,
1585 const struct usb_device_id *id)
1587 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1591 static struct usb_driver sd_driver = {
1592 .name = MODULE_NAME,
1593 .id_table = device_table,
1595 .disconnect = gspca_disconnect,
1597 .suspend = gspca_suspend,
1598 .resume = gspca_resume,
1602 /* -- module insert / remove -- */
1603 static int __init sd_mod_init(void)
1605 return usb_register(&sd_driver);
1607 static void __exit sd_mod_exit(void)
1609 usb_deregister(&sd_driver);
1612 module_init(sd_mod_init);
1613 module_exit(sd_mod_exit);