tree-wide: fix assorted typos all over the place
[linux-2.6.git] / drivers / media / video / gspca / sonixb.c
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 0x10    high nibble red gain low nibble blue gain
27 0x11    low nibble green gain
28 0x12    hstart
29 0x13    vstart
30 0x15    hsize (hsize = register-value * 16)
31 0x16    vsize (vsize = register-value * 16)
32 0x17    bit 0 toggle compression quality (according to sn9c102 driver)
33 0x18    bit 7 enables compression, bit 4-5 set image down scaling:
34         00 scale 1, 01 scale 1/2, 10, scale 1/4
35 0x19    high-nibble is sensor clock divider, changes exposure on sensors which
36         use a clock generated by the bridge. Some sensors have their own clock.
37 0x1c    auto_exposure area (for avg_lum) startx (startx = register-value * 32)
38 0x1d    auto_exposure area (for avg_lum) starty (starty = register-value * 32)
39 0x1e    auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32)
40 0x1f    auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32)
41 */
42
43 #define MODULE_NAME "sonixb"
44
45 #include "gspca.h"
46
47 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
48 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
49 MODULE_LICENSE("GPL");
50
51 /* specific webcam descriptor */
52 struct sd {
53         struct gspca_dev gspca_dev;     /* !! must be the first item */
54         atomic_t avg_lum;
55         int prev_avg_lum;
56
57         unsigned char gain;
58         unsigned char exposure;
59         unsigned char brightness;
60         unsigned char autogain;
61         unsigned char autogain_ignore_frames;
62         unsigned char frames_to_drop;
63         unsigned char freq;             /* light freq filter setting */
64
65         __u8 bridge;                    /* Type of bridge */
66 #define BRIDGE_101 0
67 #define BRIDGE_102 0 /* We make no difference between 101 and 102 */
68 #define BRIDGE_103 1
69
70         __u8 sensor;                    /* Type of image sensor chip */
71 #define SENSOR_HV7131R 0
72 #define SENSOR_OV6650 1
73 #define SENSOR_OV7630 2
74 #define SENSOR_PAS106 3
75 #define SENSOR_PAS202 4
76 #define SENSOR_TAS5110 5
77 #define SENSOR_TAS5130CXX 6
78         __u8 reg11;
79 };
80
81 typedef const __u8 sensor_init_t[8];
82
83 struct sensor_data {
84         const __u8 *bridge_init[2];
85         int bridge_init_size[2];
86         sensor_init_t *sensor_init;
87         int sensor_init_size;
88         sensor_init_t *sensor_bridge_init[2];
89         int sensor_bridge_init_size[2];
90         int flags;
91         unsigned ctrl_dis;
92         __u8 sensor_addr;
93 };
94
95 /* sensor_data flags */
96 #define F_GAIN 0x01             /* has gain */
97 #define F_SIF  0x02             /* sif or vga */
98
99 /* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
100 #define MODE_RAW 0x10           /* raw bayer mode */
101 #define MODE_REDUCED_SIF 0x20   /* vga mode (320x240 / 160x120) on sif cam */
102
103 /* ctrl_dis helper macros */
104 #define NO_EXPO ((1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX))
105 #define NO_FREQ (1 << FREQ_IDX)
106 #define NO_BRIGHTNESS (1 << BRIGHTNESS_IDX)
107
108 #define COMP2 0x8f
109 #define COMP 0xc7               /* 0x87 //0x07 */
110 #define COMP1 0xc9              /* 0x89 //0x09 */
111
112 #define MCK_INIT 0x63
113 #define MCK_INIT1 0x20          /*fixme: Bayer - 0x50 for JPEG ??*/
114
115 #define SYS_CLK 0x04
116
117 #define SENS(bridge_1, bridge_3, sensor, sensor_1, \
118         sensor_3, _flags, _ctrl_dis, _sensor_addr) \
119 { \
120         .bridge_init = { bridge_1, bridge_3 }, \
121         .bridge_init_size = { sizeof(bridge_1), sizeof(bridge_3) }, \
122         .sensor_init = sensor, \
123         .sensor_init_size = sizeof(sensor), \
124         .sensor_bridge_init = { sensor_1, sensor_3,}, \
125         .sensor_bridge_init_size = { sizeof(sensor_1), sizeof(sensor_3)}, \
126         .flags = _flags, .ctrl_dis = _ctrl_dis, .sensor_addr = _sensor_addr \
127 }
128
129 /* We calculate the autogain at the end of the transfer of a frame, at this
130    moment a frame with the old settings is being transmitted, and a frame is
131    being captured with the old settings. So if we adjust the autogain we must
132    ignore atleast the 2 next frames for the new settings to come into effect
133    before doing any other adjustments */
134 #define AUTOGAIN_IGNORE_FRAMES 3
135
136 /* V4L2 controls supported by the driver */
137 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
138 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
139 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
140 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
141 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
142 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
143 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
144 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
145 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
146 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
147
148 static struct ctrl sd_ctrls[] = {
149 #define BRIGHTNESS_IDX 0
150         {
151             {
152                 .id      = V4L2_CID_BRIGHTNESS,
153                 .type    = V4L2_CTRL_TYPE_INTEGER,
154                 .name    = "Brightness",
155                 .minimum = 0,
156                 .maximum = 255,
157                 .step    = 1,
158 #define BRIGHTNESS_DEF 127
159                 .default_value = BRIGHTNESS_DEF,
160             },
161             .set = sd_setbrightness,
162             .get = sd_getbrightness,
163         },
164 #define GAIN_IDX 1
165         {
166             {
167                 .id      = V4L2_CID_GAIN,
168                 .type    = V4L2_CTRL_TYPE_INTEGER,
169                 .name    = "Gain",
170                 .minimum = 0,
171                 .maximum = 255,
172                 .step    = 1,
173 #define GAIN_DEF 127
174 #define GAIN_KNEE 200
175                 .default_value = GAIN_DEF,
176             },
177             .set = sd_setgain,
178             .get = sd_getgain,
179         },
180 #define EXPOSURE_IDX 2
181         {
182                 {
183                         .id = V4L2_CID_EXPOSURE,
184                         .type = V4L2_CTRL_TYPE_INTEGER,
185                         .name = "Exposure",
186 #define EXPOSURE_DEF  16 /*  32 ms / 30 fps */
187 #define EXPOSURE_KNEE 50 /* 100 ms / 10 fps */
188                         .minimum = 0,
189                         .maximum = 255,
190                         .step = 1,
191                         .default_value = EXPOSURE_DEF,
192                         .flags = 0,
193                 },
194                 .set = sd_setexposure,
195                 .get = sd_getexposure,
196         },
197 #define AUTOGAIN_IDX 3
198         {
199                 {
200                         .id = V4L2_CID_AUTOGAIN,
201                         .type = V4L2_CTRL_TYPE_BOOLEAN,
202                         .name = "Automatic Gain (and Exposure)",
203                         .minimum = 0,
204                         .maximum = 1,
205                         .step = 1,
206 #define AUTOGAIN_DEF 1
207                         .default_value = AUTOGAIN_DEF,
208                         .flags = 0,
209                 },
210                 .set = sd_setautogain,
211                 .get = sd_getautogain,
212         },
213 #define FREQ_IDX 4
214         {
215                 {
216                         .id      = V4L2_CID_POWER_LINE_FREQUENCY,
217                         .type    = V4L2_CTRL_TYPE_MENU,
218                         .name    = "Light frequency filter",
219                         .minimum = 0,
220                         .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
221                         .step    = 1,
222 #define FREQ_DEF 1
223                         .default_value = FREQ_DEF,
224                 },
225                 .set = sd_setfreq,
226                 .get = sd_getfreq,
227         },
228 };
229
230 static const struct v4l2_pix_format vga_mode[] = {
231         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
232                 .bytesperline = 160,
233                 .sizeimage = 160 * 120,
234                 .colorspace = V4L2_COLORSPACE_SRGB,
235                 .priv = 2 | MODE_RAW},
236         {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
237                 .bytesperline = 160,
238                 .sizeimage = 160 * 120 * 5 / 4,
239                 .colorspace = V4L2_COLORSPACE_SRGB,
240                 .priv = 2},
241         {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
242                 .bytesperline = 320,
243                 .sizeimage = 320 * 240 * 5 / 4,
244                 .colorspace = V4L2_COLORSPACE_SRGB,
245                 .priv = 1},
246         {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
247                 .bytesperline = 640,
248                 .sizeimage = 640 * 480 * 5 / 4,
249                 .colorspace = V4L2_COLORSPACE_SRGB,
250                 .priv = 0},
251 };
252 static const struct v4l2_pix_format sif_mode[] = {
253         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
254                 .bytesperline = 160,
255                 .sizeimage = 160 * 120,
256                 .colorspace = V4L2_COLORSPACE_SRGB,
257                 .priv = 1 | MODE_RAW | MODE_REDUCED_SIF},
258         {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
259                 .bytesperline = 160,
260                 .sizeimage = 160 * 120 * 5 / 4,
261                 .colorspace = V4L2_COLORSPACE_SRGB,
262                 .priv = 1 | MODE_REDUCED_SIF},
263         {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
264                 .bytesperline = 176,
265                 .sizeimage = 176 * 144,
266                 .colorspace = V4L2_COLORSPACE_SRGB,
267                 .priv = 1 | MODE_RAW},
268         {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
269                 .bytesperline = 176,
270                 .sizeimage = 176 * 144 * 5 / 4,
271                 .colorspace = V4L2_COLORSPACE_SRGB,
272                 .priv = 1},
273         {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
274                 .bytesperline = 320,
275                 .sizeimage = 320 * 240 * 5 / 4,
276                 .colorspace = V4L2_COLORSPACE_SRGB,
277                 .priv = 0 | MODE_REDUCED_SIF},
278         {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
279                 .bytesperline = 352,
280                 .sizeimage = 352 * 288 * 5 / 4,
281                 .colorspace = V4L2_COLORSPACE_SRGB,
282                 .priv = 0},
283 };
284
285 static const __u8 initHv7131[] = {
286         0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
287         0x00, 0x00,
288         0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
289         0x28, 0x1e, 0x60, 0x8a, 0x20,
290         0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c
291 };
292 static const __u8 hv7131_sensor_init[][8] = {
293         {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10},
294         {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10},
295         {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10},
296         {0xc0, 0x11, 0x25, 0x03, 0x0e, 0x28, 0x00, 0x16},
297         {0xa0, 0x11, 0x30, 0x10, 0x0e, 0x28, 0x00, 0x15},
298 };
299 static const __u8 initOv6650[] = {
300         0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
301         0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
302         0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
303         0x10, 0x1d, 0x10, 0x02, 0x02, 0x09, 0x07
304 };
305 static const __u8 ov6650_sensor_init[][8] =
306 {
307         /* Bright, contrast, etc are set through SCBB interface.
308          * AVCAP on win2 do not send any data on this   controls. */
309         /* Anyway, some registers appears to alter bright and constrat */
310
311         /* Reset sensor */
312         {0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
313         /* Set clock register 0x11 low nibble is clock divider */
314         {0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10},
315         /* Next some unknown stuff */
316         {0xb0, 0x60, 0x15, 0x00, 0x02, 0x18, 0xc1, 0x10},
317 /*      {0xa0, 0x60, 0x1b, 0x01, 0x02, 0x18, 0xc1, 0x10},
318                  * THIS SET GREEN SCREEN
319                  * (pixels could be innverted in decode kind of "brg",
320                  * but blue wont be there. Avoid this data ... */
321         {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */
322         {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10},
323         {0xa0, 0x60, 0x30, 0x3d, 0x0A, 0xd8, 0xa4, 0x10},
324         /* Enable rgb brightness control */
325         {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10},
326         /* HDG: Note windows uses the line below, which sets both register 0x60
327            and 0x61 I believe these registers of the ov6650 are identical as
328            those of the ov7630, because if this is true the windows settings
329            add a bit additional red gain and a lot additional blue gain, which
330            matches my findings that the windows settings make blue much too
331            blue and red a little too red.
332         {0xb0, 0x60, 0x60, 0x66, 0x68, 0xd8, 0xa4, 0x10}, */
333         /* Some more unknown stuff */
334         {0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10},
335         {0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */
336 };
337
338 static const __u8 initOv7630[] = {
339         0x04, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, /* r01 .. r08 */
340         0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
341         0x00, 0x01, 0x01, 0x0a,                         /* r11 .. r14 */
342         0x28, 0x1e,                     /* H & V sizes     r15 .. r16 */
343         0x68, COMP2, MCK_INIT1,                         /* r17 .. r19 */
344         0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c              /* r1a .. r1f */
345 };
346 static const __u8 initOv7630_3[] = {
347         0x44, 0x44, 0x00, 0x1a, 0x20, 0x20, 0x20, 0x80, /* r01 .. r08 */
348         0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, /* r09 .. r10 */
349         0x00, 0x02, 0x01, 0x0a,                         /* r11 .. r14 */
350         0x28, 0x1e,                     /* H & V sizes     r15 .. r16 */
351         0x68, 0x8f, MCK_INIT1,                          /* r17 .. r19 */
352         0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c, 0x00,       /* r1a .. r20 */
353         0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, /* r21 .. r28 */
354         0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xff  /* r29 .. r30 */
355 };
356 static const __u8 ov7630_sensor_init[][8] = {
357         {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
358         {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10},
359 /*      {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10},          jfm */
360         {0xd0, 0x21, 0x12, 0x1c, 0x00, 0x80, 0x34, 0x10},       /* jfm */
361         {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10},
362         {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10},
363         {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10},
364         {0xd0, 0x21, 0x26, 0xa0, 0x9a, 0xa0, 0x30, 0x10},
365         {0xb0, 0x21, 0x2a, 0x80, 0x00, 0xa0, 0x30, 0x10},
366         {0xb0, 0x21, 0x2f, 0x3d, 0x24, 0xa0, 0x30, 0x10},
367         {0xa0, 0x21, 0x32, 0x86, 0x24, 0xa0, 0x30, 0x10},
368         {0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10},
369 /*      {0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10},        * jfm */
370         {0xa0, 0x21, 0x65, 0x00, 0x42, 0xa0, 0x30, 0x10},
371         {0xa0, 0x21, 0x69, 0x38, 0x42, 0xa0, 0x30, 0x10},
372         {0xc0, 0x21, 0x6f, 0x88, 0x0b, 0x00, 0x30, 0x10},
373         {0xc0, 0x21, 0x74, 0x21, 0x8e, 0x00, 0x30, 0x10},
374         {0xa0, 0x21, 0x7d, 0xf7, 0x8e, 0x00, 0x30, 0x10},
375         {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10},
376 };
377
378 static const __u8 ov7630_sensor_init_3[][8] = {
379         {0xa0, 0x21, 0x13, 0x80, 0x00,  0x00, 0x00, 0x10},
380 };
381
382 static const __u8 initPas106[] = {
383         0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
384         0x00, 0x00,
385         0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
386         0x16, 0x12, 0x24, COMP1, MCK_INIT1,
387         0x18, 0x10, 0x02, 0x02, 0x09, 0x07
388 };
389 /* compression 0x86 mckinit1 0x2b */
390 static const __u8 pas106_sensor_init[][8] = {
391         /* Pixel Clock Divider 6 */
392         { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 },
393         /* Frame Time MSB (also seen as 0x12) */
394         { 0xa1, 0x40, 0x03, 0x13, 0x00, 0x00, 0x00, 0x14 },
395         /* Frame Time LSB (also seen as 0x05) */
396         { 0xa1, 0x40, 0x04, 0x06, 0x00, 0x00, 0x00, 0x14 },
397         /* Shutter Time Line Offset (also seen as 0x6d) */
398         { 0xa1, 0x40, 0x05, 0x65, 0x00, 0x00, 0x00, 0x14 },
399         /* Shutter Time Pixel Offset (also seen as 0xb1) */
400         { 0xa1, 0x40, 0x06, 0xcd, 0x00, 0x00, 0x00, 0x14 },
401         /* Black Level Subtract Sign (also seen 0x00) */
402         { 0xa1, 0x40, 0x07, 0xc1, 0x00, 0x00, 0x00, 0x14 },
403         /* Black Level Subtract Level (also seen 0x01) */
404         { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
405         { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
406         /* Color Gain B Pixel 5 a */
407         { 0xa1, 0x40, 0x09, 0x05, 0x00, 0x00, 0x00, 0x14 },
408         /* Color Gain G1 Pixel 1 5 */
409         { 0xa1, 0x40, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x14 },
410         /* Color Gain G2 Pixel 1 0 5 */
411         { 0xa1, 0x40, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x14 },
412         /* Color Gain R Pixel 3 1 */
413         { 0xa1, 0x40, 0x0c, 0x05, 0x00, 0x00, 0x00, 0x14 },
414         /* Color GainH  Pixel */
415         { 0xa1, 0x40, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x14 },
416         /* Global Gain */
417         { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 },
418         /* Contrast */
419         { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 },
420         /* H&V synchro polarity */
421         { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 },
422         /* ?default */
423         { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 },
424         /* DAC scale */
425         { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 },
426         /* ?default */
427         { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 },
428         /* Validate Settings */
429         { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 },
430 };
431
432 static const __u8 initPas202[] = {
433         0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
434         0x00, 0x00,
435         0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
436         0x28, 0x1e, 0x28, 0x89, 0x20,
437         0x00, 0x00, 0x02, 0x03, 0x0f, 0x0c
438 };
439 static const __u8 pas202_sensor_init[][8] = {
440         {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10},
441         {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
442         {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
443         {0xd0, 0x40, 0x0C, 0x00, 0x0C, 0x00, 0x32, 0x10},
444         {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10},
445         {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10},
446         {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10},
447         {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
448         {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10},
449         {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
450         {0xb0, 0x40, 0x04, 0x07, 0x2a, 0x00, 0x63, 0x10},
451         {0xb0, 0x40, 0x0e, 0x00, 0x3d, 0x00, 0x63, 0x10},
452
453         {0xa0, 0x40, 0x11, 0x01, 0x3d, 0x00, 0x63, 0x16},
454         {0xa0, 0x40, 0x10, 0x08, 0x3d, 0x00, 0x63, 0x15},
455         {0xa0, 0x40, 0x02, 0x04, 0x3d, 0x00, 0x63, 0x16},
456         {0xa0, 0x40, 0x11, 0x01, 0x3d, 0x00, 0x63, 0x16},
457         {0xb0, 0x40, 0x0e, 0x00, 0x31, 0x00, 0x63, 0x16},
458         {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16},
459         {0xa0, 0x40, 0x10, 0x0e, 0x31, 0x00, 0x63, 0x15},
460         {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16},
461 };
462
463 static const __u8 initTas5110[] = {
464         0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
465         0x00, 0x00,
466         0x00, 0x01, 0x00, 0x45, 0x09, 0x0a,
467         0x16, 0x12, 0x60, 0x86, 0x2b,
468         0x14, 0x0a, 0x02, 0x02, 0x09, 0x07
469 };
470 static const __u8 tas5110_sensor_init[][8] = {
471         {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
472         {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
473         {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17},
474 };
475
476 static const __u8 initTas5130[] = {
477         0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
478         0x00, 0x00,
479         0x00, 0x01, 0x00, 0x68, 0x0c, 0x0a,
480         0x28, 0x1e, 0x60, COMP, MCK_INIT,
481         0x18, 0x10, 0x04, 0x03, 0x11, 0x0c
482 };
483 static const __u8 tas5130_sensor_init[][8] = {
484 /*      {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
485                                         * shutter 0x47 short exposure? */
486         {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
487                                         /* shutter 0x01 long exposure */
488         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
489 };
490
491 static struct sensor_data sensor_data[] = {
492 SENS(initHv7131, NULL, hv7131_sensor_init, NULL, NULL, 0, NO_EXPO|NO_FREQ, 0),
493 SENS(initOv6650, NULL, ov6650_sensor_init, NULL, NULL, F_GAIN|F_SIF, 0, 0x60),
494 SENS(initOv7630, initOv7630_3, ov7630_sensor_init, NULL, ov7630_sensor_init_3,
495         F_GAIN, 0, 0x21),
496 SENS(initPas106, NULL, pas106_sensor_init, NULL, NULL, F_SIF, NO_EXPO|NO_FREQ,
497         0),
498 SENS(initPas202, initPas202, pas202_sensor_init, NULL, NULL, 0,
499         NO_EXPO|NO_FREQ, 0),
500 SENS(initTas5110, NULL, tas5110_sensor_init, NULL, NULL, F_GAIN|F_SIF,
501         NO_BRIGHTNESS|NO_FREQ, 0),
502 SENS(initTas5130, NULL, tas5130_sensor_init, NULL, NULL, 0, NO_EXPO|NO_FREQ,
503         0),
504 };
505
506 /* get one byte in gspca_dev->usb_buf */
507 static void reg_r(struct gspca_dev *gspca_dev,
508                   __u16 value)
509 {
510         usb_control_msg(gspca_dev->dev,
511                         usb_rcvctrlpipe(gspca_dev->dev, 0),
512                         0,                      /* request */
513                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
514                         value,
515                         0,                      /* index */
516                         gspca_dev->usb_buf, 1,
517                         500);
518 }
519
520 static void reg_w(struct gspca_dev *gspca_dev,
521                   __u16 value,
522                   const __u8 *buffer,
523                   int len)
524 {
525 #ifdef GSPCA_DEBUG
526         if (len > USB_BUF_SZ) {
527                 PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
528                 return;
529         }
530 #endif
531         memcpy(gspca_dev->usb_buf, buffer, len);
532         usb_control_msg(gspca_dev->dev,
533                         usb_sndctrlpipe(gspca_dev->dev, 0),
534                         0x08,                   /* request */
535                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
536                         value,
537                         0,                      /* index */
538                         gspca_dev->usb_buf, len,
539                         500);
540 }
541
542 static int i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer)
543 {
544         int retry = 60;
545
546         /* is i2c ready */
547         reg_w(gspca_dev, 0x08, buffer, 8);
548         while (retry--) {
549                 msleep(10);
550                 reg_r(gspca_dev, 0x08);
551                 if (gspca_dev->usb_buf[0] & 0x04) {
552                         if (gspca_dev->usb_buf[0] & 0x08)
553                                 return -1;
554                         return 0;
555                 }
556         }
557         return -1;
558 }
559
560 static void i2c_w_vector(struct gspca_dev *gspca_dev,
561                         const __u8 buffer[][8], int len)
562 {
563         for (;;) {
564                 reg_w(gspca_dev, 0x08, *buffer, 8);
565                 len -= 8;
566                 if (len <= 0)
567                         break;
568                 buffer++;
569         }
570 }
571
572 static void setbrightness(struct gspca_dev *gspca_dev)
573 {
574         struct sd *sd = (struct sd *) gspca_dev;
575         __u8 value;
576
577         switch (sd->sensor) {
578         case  SENSOR_OV6650:
579         case  SENSOR_OV7630: {
580                 __u8 i2cOV[] =
581                         {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
582
583                 /* change reg 0x06 */
584                 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
585                 i2cOV[3] = sd->brightness;
586                 if (i2c_w(gspca_dev, i2cOV) < 0)
587                         goto err;
588                 break;
589             }
590         case SENSOR_PAS106: {
591                 __u8 i2c1[] =
592                         {0xa1, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14};
593
594                 i2c1[3] = sd->brightness >> 3;
595                 i2c1[2] = 0x0e;
596                 if (i2c_w(gspca_dev, i2c1) < 0)
597                         goto err;
598                 i2c1[3] = 0x01;
599                 i2c1[2] = 0x13;
600                 if (i2c_w(gspca_dev, i2c1) < 0)
601                         goto err;
602                 break;
603             }
604         case SENSOR_PAS202: {
605                 /* __u8 i2cpexpo1[] =
606                         {0xb0, 0x40, 0x04, 0x07, 0x2a, 0x00, 0x63, 0x16}; */
607                 __u8 i2cpexpo[] =
608                         {0xb0, 0x40, 0x0e, 0x01, 0xab, 0x00, 0x63, 0x16};
609                 __u8 i2cp202[] =
610                         {0xa0, 0x40, 0x10, 0x0e, 0x31, 0x00, 0x63, 0x15};
611                 static __u8 i2cpdoit[] =
612                         {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16};
613
614                 /* change reg 0x10 */
615                 i2cpexpo[4] = 0xff - sd->brightness;
616 /*              if(i2c_w(gspca_dev,i2cpexpo1) < 0)
617                         goto err; */
618 /*              if(i2c_w(gspca_dev,i2cpdoit) < 0)
619                         goto err; */
620                 if (i2c_w(gspca_dev, i2cpexpo) < 0)
621                         goto err;
622                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
623                         goto err;
624                 i2cp202[3] = sd->brightness >> 3;
625                 if (i2c_w(gspca_dev, i2cp202) < 0)
626                         goto err;
627                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
628                         goto err;
629                 break;
630             }
631         case SENSOR_TAS5130CXX: {
632                 __u8 i2c[] =
633                         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
634
635                 value = 0xff - sd->brightness;
636                 i2c[4] = value;
637                 PDEBUG(D_CONF, "brightness %d : %d", value, i2c[4]);
638                 if (i2c_w(gspca_dev, i2c) < 0)
639                         goto err;
640                 break;
641             }
642         }
643         return;
644 err:
645         PDEBUG(D_ERR, "i2c error brightness");
646 }
647
648 static void setsensorgain(struct gspca_dev *gspca_dev)
649 {
650         struct sd *sd = (struct sd *) gspca_dev;
651         unsigned char gain = sd->gain;
652
653         switch (sd->sensor) {
654
655         case SENSOR_TAS5110: {
656                 __u8 i2c[] =
657                         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
658
659                 i2c[4] = 255 - gain;
660                 if (i2c_w(gspca_dev, i2c) < 0)
661                         goto err;
662                 break;
663             }
664
665         case SENSOR_OV6650:
666                 gain >>= 1;
667                 /* fall thru */
668         case SENSOR_OV7630: {
669                 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
670
671                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
672                 i2c[3] = gain >> 2;
673                 if (i2c_w(gspca_dev, i2c) < 0)
674                         goto err;
675                 break;
676             }
677         }
678         return;
679 err:
680         PDEBUG(D_ERR, "i2c error gain");
681 }
682
683 static void setgain(struct gspca_dev *gspca_dev)
684 {
685         struct sd *sd = (struct sd *) gspca_dev;
686         __u8 gain;
687         __u8 rgb_value;
688
689         gain = sd->gain >> 4;
690
691         /* red and blue gain */
692         rgb_value = gain << 4 | gain;
693         reg_w(gspca_dev, 0x10, &rgb_value, 1);
694         /* green gain */
695         rgb_value = gain;
696         reg_w(gspca_dev, 0x11, &rgb_value, 1);
697
698         if (sensor_data[sd->sensor].flags & F_GAIN)
699                 setsensorgain(gspca_dev);
700 }
701
702 static void setexposure(struct gspca_dev *gspca_dev)
703 {
704         struct sd *sd = (struct sd *) gspca_dev;
705
706         switch (sd->sensor) {
707         case SENSOR_TAS5110: {
708                 __u8 reg;
709
710                 /* register 19's high nibble contains the sn9c10x clock divider
711                    The high nibble configures the no fps according to the
712                    formula: 60 / high_nibble. With a maximum of 30 fps */
713                 reg = 120 * sd->exposure / 1000;
714                 if (reg < 2)
715                         reg = 2;
716                 else if (reg > 15)
717                         reg = 15;
718                 reg = (reg << 4) | 0x0b;
719                 reg_w(gspca_dev, 0x19, &reg, 1);
720                 break;
721             }
722         case SENSOR_OV6650:
723         case SENSOR_OV7630: {
724                 /* The ov6650 / ov7630 have 2 registers which both influence
725                    exposure, register 11, whose low nibble sets the nr off fps
726                    according to: fps = 30 / (low_nibble + 1)
727
728                    The fps configures the maximum exposure setting, but it is
729                    possible to use less exposure then what the fps maximum
730                    allows by setting register 10. register 10 configures the
731                    actual exposure as quotient of the full exposure, with 0
732                    being no exposure at all (not very usefull) and reg10_max
733                    being max exposure possible at that framerate.
734
735                    The code maps our 0 - 510 ms exposure ctrl to these 2
736                    registers, trying to keep fps as high as possible.
737                 */
738                 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
739                 int reg10, reg11, reg10_max;
740
741                 /* ov6645 datasheet says reg10_max is 9a, but that uses
742                    tline * 2 * reg10 as formula for calculating texpo, the
743                    ov6650 probably uses the same formula as the 7730 which uses
744                    tline * 4 * reg10, which explains why the reg10max we've
745                    found experimentally for the ov6650 is exactly half that of
746                    the ov6645. The ov7630 datasheet says the max is 0x41. */
747                 if (sd->sensor == SENSOR_OV6650) {
748                         reg10_max = 0x4d;
749                         i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
750                 } else
751                         reg10_max = 0x41;
752
753                 reg11 = (60 * sd->exposure + 999) / 1000;
754                 if (reg11 < 1)
755                         reg11 = 1;
756                 else if (reg11 > 16)
757                         reg11 = 16;
758
759                 /* In 640x480, if the reg11 has less than 3, the image is
760                    unstable (not enough bandwidth). */
761                 if (gspca_dev->width == 640 && reg11 < 3)
762                         reg11 = 3;
763
764                 /* frame exposure time in ms = 1000 * reg11 / 30    ->
765                 reg10 = sd->exposure * 2 * reg10_max / (1000 * reg11 / 30) */
766                 reg10 = (sd->exposure * 60 * reg10_max) / (1000 * reg11);
767
768                 /* Don't allow this to get below 10 when using autogain, the
769                    steps become very large (relatively) when below 10 causing
770                    the image to oscilate from much too dark, to much too bright
771                    and back again. */
772                 if (sd->autogain && reg10 < 10)
773                         reg10 = 10;
774                 else if (reg10 > reg10_max)
775                         reg10 = reg10_max;
776
777                 /* Write reg 10 and reg11 low nibble */
778                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
779                 i2c[3] = reg10;
780                 i2c[4] |= reg11 - 1;
781
782                 /* If register 11 didn't change, don't change it */
783                 if (sd->reg11 == reg11 )
784                         i2c[0] = 0xa0;
785
786                 if (i2c_w(gspca_dev, i2c) == 0)
787                         sd->reg11 = reg11;
788                 else
789                         PDEBUG(D_ERR, "i2c error exposure");
790                 break;
791             }
792         }
793 }
794
795 static void setfreq(struct gspca_dev *gspca_dev)
796 {
797         struct sd *sd = (struct sd *) gspca_dev;
798
799         switch (sd->sensor) {
800         case SENSOR_OV6650:
801         case SENSOR_OV7630: {
802                 /* Framerate adjust register for artificial light 50 hz flicker
803                    compensation, for the ov6650 this is identical to ov6630
804                    0x2b register, see ov6630 datasheet.
805                    0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
806                 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
807                 switch (sd->freq) {
808                 default:
809 /*              case 0:                  * no filter*/
810 /*              case 2:                  * 60 hz */
811                         i2c[3] = 0;
812                         break;
813                 case 1:                 /* 50 hz */
814                         i2c[3] = (sd->sensor == SENSOR_OV6650)
815                                         ? 0x4f : 0x8a;
816                         break;
817                 }
818                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
819                 if (i2c_w(gspca_dev, i2c) < 0)
820                         PDEBUG(D_ERR, "i2c error setfreq");
821                 break;
822             }
823         }
824 }
825
826 static void do_autogain(struct gspca_dev *gspca_dev)
827 {
828         int deadzone, desired_avg_lum;
829         struct sd *sd = (struct sd *) gspca_dev;
830         int avg_lum = atomic_read(&sd->avg_lum);
831
832         if (avg_lum == -1)
833                 return;
834
835         /* SIF / VGA sensors have a different autoexposure area and thus
836            different avg_lum values for the same picture brightness */
837         if (sensor_data[sd->sensor].flags & F_SIF) {
838                 deadzone = 1000;
839                 desired_avg_lum = 7000;
840         } else {
841                 deadzone = 3000;
842                 desired_avg_lum = 23000;
843         }
844
845         if (sd->autogain_ignore_frames > 0)
846                 sd->autogain_ignore_frames--;
847         else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
848                         sd->brightness * desired_avg_lum / 127,
849                         deadzone, GAIN_KNEE, EXPOSURE_KNEE)) {
850                 PDEBUG(D_FRAM, "autogain: gain changed: gain: %d expo: %d",
851                         (int)sd->gain, (int)sd->exposure);
852                 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
853         }
854 }
855
856 /* this function is called at probe time */
857 static int sd_config(struct gspca_dev *gspca_dev,
858                         const struct usb_device_id *id)
859 {
860         struct sd *sd = (struct sd *) gspca_dev;
861         struct cam *cam;
862
863         reg_r(gspca_dev, 0x00);
864         if (gspca_dev->usb_buf[0] != 0x10)
865                 return -ENODEV;
866
867         /* copy the webcam info from the device id */
868         sd->sensor = id->driver_info >> 8;
869         sd->bridge = id->driver_info & 0xff;
870         gspca_dev->ctrl_dis = sensor_data[sd->sensor].ctrl_dis;
871
872         cam = &gspca_dev->cam;
873         if (!(sensor_data[sd->sensor].flags & F_SIF)) {
874                 cam->cam_mode = vga_mode;
875                 cam->nmodes = ARRAY_SIZE(vga_mode);
876         } else {
877                 cam->cam_mode = sif_mode;
878                 cam->nmodes = ARRAY_SIZE(sif_mode);
879         }
880         cam->npkt = 36;                 /* 36 packets per ISOC message */
881
882         sd->brightness = BRIGHTNESS_DEF;
883         sd->gain = GAIN_DEF;
884         sd->exposure = EXPOSURE_DEF;
885         if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
886                 sd->autogain = 0; /* Disable do_autogain callback */
887         else
888                 sd->autogain = AUTOGAIN_DEF;
889         sd->freq = FREQ_DEF;
890
891         return 0;
892 }
893
894 /* this function is called at probe and resume time */
895 static int sd_init(struct gspca_dev *gspca_dev)
896 {
897         const __u8 stop = 0x09; /* Disable stream turn of LED */
898
899         reg_w(gspca_dev, 0x01, &stop, 1);
900
901         return 0;
902 }
903
904 /* -- start the camera -- */
905 static int sd_start(struct gspca_dev *gspca_dev)
906 {
907         struct sd *sd = (struct sd *) gspca_dev;
908         struct cam *cam = &gspca_dev->cam;
909         int mode, l;
910         const __u8 *sn9c10x;
911         __u8 reg12_19[8];
912
913         mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
914         sn9c10x = sensor_data[sd->sensor].bridge_init[sd->bridge];
915         l = sensor_data[sd->sensor].bridge_init_size[sd->bridge];
916         memcpy(reg12_19, &sn9c10x[0x12 - 1], 8);
917         reg12_19[6] = sn9c10x[0x18 - 1] | (mode << 4);
918         /* Special cases where reg 17 and or 19 value depends on mode */
919         switch (sd->sensor) {
920         case SENSOR_PAS202:
921                 reg12_19[5] = mode ? 0x24 : 0x20;
922                 break;
923         case SENSOR_TAS5130CXX:
924                 /* probably not mode specific at all most likely the upper
925                    nibble of 0x19 is exposure (clock divider) just as with
926                    the tas5110, we need someone to test this. */
927                 reg12_19[7] = mode ? 0x23 : 0x43;
928                 break;
929         }
930         /* Disable compression when the raw bayer format has been selected */
931         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
932                 reg12_19[6] &= ~0x80;
933
934         /* Vga mode emulation on SIF sensor? */
935         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
936                 reg12_19[0] += 16; /* 0x12: hstart adjust */
937                 reg12_19[1] += 24; /* 0x13: vstart adjust */
938                 reg12_19[3] = 320 / 16; /* 0x15: hsize */
939                 reg12_19[4] = 240 / 16; /* 0x16: vsize */
940         }
941
942         /* reg 0x01 bit 2 video transfert on */
943         reg_w(gspca_dev, 0x01, &sn9c10x[0x01 - 1], 1);
944         /* reg 0x17 SensorClk enable inv Clk 0x60 */
945         reg_w(gspca_dev, 0x17, &sn9c10x[0x17 - 1], 1);
946         /* Set the registers from the template */
947         reg_w(gspca_dev, 0x01, sn9c10x, l);
948
949         /* Init the sensor */
950         i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
951                         sensor_data[sd->sensor].sensor_init_size);
952         if (sensor_data[sd->sensor].sensor_bridge_init[sd->bridge])
953                 i2c_w_vector(gspca_dev,
954                         sensor_data[sd->sensor].sensor_bridge_init[sd->bridge],
955                         sensor_data[sd->sensor].sensor_bridge_init_size[
956                                 sd->bridge]);
957
958         /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
959         reg_w(gspca_dev, 0x15, &reg12_19[3], 2);
960         /* compression register */
961         reg_w(gspca_dev, 0x18, &reg12_19[6], 1);
962         /* H_start */
963         reg_w(gspca_dev, 0x12, &reg12_19[0], 1);
964         /* V_START */
965         reg_w(gspca_dev, 0x13, &reg12_19[1], 1);
966         /* reset 0x17 SensorClk enable inv Clk 0x60 */
967                                 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
968         reg_w(gspca_dev, 0x17, &reg12_19[5], 1);
969         /*MCKSIZE ->3 */        /*fixme: not ov7630*/
970         reg_w(gspca_dev, 0x19, &reg12_19[7], 1);
971         /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
972         reg_w(gspca_dev, 0x1c, &sn9c10x[0x1c - 1], 4);
973         /* Enable video transfert */
974         reg_w(gspca_dev, 0x01, &sn9c10x[0], 1);
975         /* Compression */
976         reg_w(gspca_dev, 0x18, &reg12_19[6], 2);
977         msleep(20);
978
979         sd->reg11 = -1;
980
981         setgain(gspca_dev);
982         setbrightness(gspca_dev);
983         setexposure(gspca_dev);
984         setfreq(gspca_dev);
985
986         sd->frames_to_drop = 0;
987         sd->autogain_ignore_frames = 0;
988         atomic_set(&sd->avg_lum, -1);
989         return 0;
990 }
991
992 static void sd_stopN(struct gspca_dev *gspca_dev)
993 {
994         sd_init(gspca_dev);
995 }
996
997 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
998                         struct gspca_frame *frame,      /* target */
999                         unsigned char *data,            /* isoc packet */
1000                         int len)                        /* iso packet length */
1001 {
1002         int i;
1003         struct sd *sd = (struct sd *) gspca_dev;
1004         struct cam *cam = &gspca_dev->cam;
1005
1006         /* frames start with:
1007          *      ff ff 00 c4 c4 96       synchro
1008          *      00              (unknown)
1009          *      xx              (frame sequence / size / compression)
1010          *      (xx)            (idem - extra byte for sn9c103)
1011          *      ll mm           brightness sum inside auto exposure
1012          *      ll mm           brightness sum outside auto exposure
1013          *      (xx xx xx xx xx)        audio values for snc103
1014          */
1015         if (len > 6 && len < 24) {
1016                 for (i = 0; i < len - 6; i++) {
1017                         if (data[0 + i] == 0xff
1018                             && data[1 + i] == 0xff
1019                             && data[2 + i] == 0x00
1020                             && data[3 + i] == 0xc4
1021                             && data[4 + i] == 0xc4
1022                             && data[5 + i] == 0x96) {   /* start of frame */
1023                                 int lum = -1;
1024                                 int pkt_type = LAST_PACKET;
1025                                 int fr_h_sz = (sd->bridge == BRIDGE_103) ?
1026                                         18 : 12;
1027
1028                                 if (len - i < fr_h_sz) {
1029                                         PDEBUG(D_STREAM, "packet too short to"
1030                                                 " get avg brightness");
1031                                 } else if (sd->bridge == BRIDGE_103) {
1032                                         lum = data[i + 9] +
1033                                                 (data[i + 10] << 8);
1034                                 } else {
1035                                         lum = data[i + 8] + (data[i + 9] << 8);
1036                                 }
1037                                 /* When exposure changes midway a frame we
1038                                    get a lum of 0 in this case drop 2 frames
1039                                    as the frames directly after an exposure
1040                                    change have an unstable image. Sometimes lum
1041                                    *really* is 0 (cam used in low light with
1042                                    low exposure setting), so do not drop frames
1043                                    if the previous lum was 0 too. */
1044                                 if (lum == 0 && sd->prev_avg_lum != 0) {
1045                                         lum = -1;
1046                                         sd->frames_to_drop = 2;
1047                                         sd->prev_avg_lum = 0;
1048                                 } else
1049                                         sd->prev_avg_lum = lum;
1050                                 atomic_set(&sd->avg_lum, lum);
1051
1052                                 if (sd->frames_to_drop) {
1053                                         sd->frames_to_drop--;
1054                                         pkt_type = DISCARD_PACKET;
1055                                 }
1056
1057                                 frame = gspca_frame_add(gspca_dev, pkt_type,
1058                                                         frame, data, 0);
1059                                 data += i + fr_h_sz;
1060                                 len -= i + fr_h_sz;
1061                                 gspca_frame_add(gspca_dev, FIRST_PACKET,
1062                                                 frame, data, len);
1063                                 return;
1064                         }
1065                 }
1066         }
1067
1068         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1069                 /* In raw mode we sometimes get some garbage after the frame
1070                    ignore this */
1071                 int used = frame->data_end - frame->data;
1072                 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1073
1074                 if (used + len > size)
1075                         len = size - used;
1076         }
1077
1078         gspca_frame_add(gspca_dev, INTER_PACKET,
1079                         frame, data, len);
1080 }
1081
1082 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1083 {
1084         struct sd *sd = (struct sd *) gspca_dev;
1085
1086         sd->brightness = val;
1087         if (gspca_dev->streaming)
1088                 setbrightness(gspca_dev);
1089         return 0;
1090 }
1091
1092 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1093 {
1094         struct sd *sd = (struct sd *) gspca_dev;
1095
1096         *val = sd->brightness;
1097         return 0;
1098 }
1099
1100 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1101 {
1102         struct sd *sd = (struct sd *) gspca_dev;
1103
1104         sd->gain = val;
1105         if (gspca_dev->streaming)
1106                 setgain(gspca_dev);
1107         return 0;
1108 }
1109
1110 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1111 {
1112         struct sd *sd = (struct sd *) gspca_dev;
1113
1114         *val = sd->gain;
1115         return 0;
1116 }
1117
1118 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1119 {
1120         struct sd *sd = (struct sd *) gspca_dev;
1121
1122         sd->exposure = val;
1123         if (gspca_dev->streaming)
1124                 setexposure(gspca_dev);
1125         return 0;
1126 }
1127
1128 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1129 {
1130         struct sd *sd = (struct sd *) gspca_dev;
1131
1132         *val = sd->exposure;
1133         return 0;
1134 }
1135
1136 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1137 {
1138         struct sd *sd = (struct sd *) gspca_dev;
1139
1140         sd->autogain = val;
1141         /* when switching to autogain set defaults to make sure
1142            we are on a valid point of the autogain gain /
1143            exposure knee graph, and give this change time to
1144            take effect before doing autogain. */
1145         if (sd->autogain) {
1146                 sd->exposure = EXPOSURE_DEF;
1147                 sd->gain = GAIN_DEF;
1148                 if (gspca_dev->streaming) {
1149                         sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1150                         setexposure(gspca_dev);
1151                         setgain(gspca_dev);
1152                 }
1153         }
1154
1155         return 0;
1156 }
1157
1158 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1159 {
1160         struct sd *sd = (struct sd *) gspca_dev;
1161
1162         *val = sd->autogain;
1163         return 0;
1164 }
1165
1166 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1167 {
1168         struct sd *sd = (struct sd *) gspca_dev;
1169
1170         sd->freq = val;
1171         if (gspca_dev->streaming)
1172                 setfreq(gspca_dev);
1173         return 0;
1174 }
1175
1176 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1177 {
1178         struct sd *sd = (struct sd *) gspca_dev;
1179
1180         *val = sd->freq;
1181         return 0;
1182 }
1183
1184 static int sd_querymenu(struct gspca_dev *gspca_dev,
1185                         struct v4l2_querymenu *menu)
1186 {
1187         switch (menu->id) {
1188         case V4L2_CID_POWER_LINE_FREQUENCY:
1189                 switch (menu->index) {
1190                 case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1191                         strcpy((char *) menu->name, "NoFliker");
1192                         return 0;
1193                 case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1194                         strcpy((char *) menu->name, "50 Hz");
1195                         return 0;
1196                 case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1197                         strcpy((char *) menu->name, "60 Hz");
1198                         return 0;
1199                 }
1200                 break;
1201         }
1202         return -EINVAL;
1203 }
1204
1205 /* sub-driver description */
1206 static const struct sd_desc sd_desc = {
1207         .name = MODULE_NAME,
1208         .ctrls = sd_ctrls,
1209         .nctrls = ARRAY_SIZE(sd_ctrls),
1210         .config = sd_config,
1211         .init = sd_init,
1212         .start = sd_start,
1213         .stopN = sd_stopN,
1214         .pkt_scan = sd_pkt_scan,
1215         .querymenu = sd_querymenu,
1216         .dq_callback = do_autogain,
1217 };
1218
1219 /* -- module initialisation -- */
1220 #define SB(sensor, bridge) \
1221         .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1222
1223
1224 static __devinitdata struct usb_device_id device_table[] = {
1225         {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110, 102)}, /* TAS5110C1B */
1226         {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110, 101)}, /* TAS5110C1B */
1227 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1228         {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110, 101)}, /* TAS5110D */
1229         {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1230         {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1231 #endif
1232         {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1233 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1234         {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1235         {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1236         {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1237         {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1238         {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1239 #endif
1240         {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1241         {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1242 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1243         {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1244 #endif
1245         {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1246 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1247         {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1248 #endif
1249         {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1250         {}
1251 };
1252 MODULE_DEVICE_TABLE(usb, device_table);
1253
1254 /* -- device connect -- */
1255 static int sd_probe(struct usb_interface *intf,
1256                         const struct usb_device_id *id)
1257 {
1258         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1259                                 THIS_MODULE);
1260 }
1261
1262 static struct usb_driver sd_driver = {
1263         .name = MODULE_NAME,
1264         .id_table = device_table,
1265         .probe = sd_probe,
1266         .disconnect = gspca_disconnect,
1267 #ifdef CONFIG_PM
1268         .suspend = gspca_suspend,
1269         .resume = gspca_resume,
1270 #endif
1271 };
1272
1273 /* -- module insert / remove -- */
1274 static int __init sd_mod_init(void)
1275 {
1276         int ret;
1277         ret = usb_register(&sd_driver);
1278         if (ret < 0)
1279                 return ret;
1280         PDEBUG(D_PROBE, "registered");
1281         return 0;
1282 }
1283 static void __exit sd_mod_exit(void)
1284 {
1285         usb_deregister(&sd_driver);
1286         PDEBUG(D_PROBE, "deregistered");
1287 }
1288
1289 module_init(sd_mod_init);
1290 module_exit(sd_mod_exit);