Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / drivers / media / video / gspca / spca561.c
1 /*
2  * Sunplus spca561 subdriver
3  *
4  * Copyright (C) 2004 Michel Xhaard mxhaard@magic.fr
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 #define MODULE_NAME "spca561"
24
25 #include "gspca.h"
26
27 #define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 1, 7)
28 static const char version[] = "2.1.7";
29
30 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
31 MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver");
32 MODULE_LICENSE("GPL");
33
34 /* specific webcam descriptor */
35 struct sd {
36         struct gspca_dev gspca_dev;     /* !! must be the first item */
37
38         unsigned short contrast;
39         __u8 brightness;
40         __u8 autogain;
41
42         __u8 chip_revision;
43         signed char ag_cnt;
44 #define AG_CNT_START 13
45 };
46
47 /* V4L2 controls supported by the driver */
48 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
49 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
50 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
51 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
52 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
53 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
54
55 static struct ctrl sd_ctrls[] = {
56 #define SD_BRIGHTNESS 0
57         {
58          {
59           .id = V4L2_CID_BRIGHTNESS,
60           .type = V4L2_CTRL_TYPE_INTEGER,
61           .name = "Brightness",
62           .minimum = 0,
63           .maximum = 63,
64           .step = 1,
65           .default_value = 32,
66           },
67          .set = sd_setbrightness,
68          .get = sd_getbrightness,
69          },
70 #define SD_CONTRAST 1
71         {
72          {
73           .id = V4L2_CID_CONTRAST,
74           .type = V4L2_CTRL_TYPE_INTEGER,
75           .name = "Contrast",
76           .minimum = 0,
77           .maximum = 0x3fff,
78           .step = 1,
79           .default_value = 0x2000,
80           },
81          .set = sd_setcontrast,
82          .get = sd_getcontrast,
83          },
84 #define SD_AUTOGAIN 2
85         {
86          {
87           .id = V4L2_CID_AUTOGAIN,
88           .type = V4L2_CTRL_TYPE_BOOLEAN,
89           .name = "Auto Gain",
90           .minimum = 0,
91           .maximum = 1,
92           .step = 1,
93           .default_value = 1,
94           },
95          .set = sd_setautogain,
96          .get = sd_getautogain,
97          },
98 };
99
100 static struct v4l2_pix_format sif_mode[] = {
101         {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
102                 .bytesperline = 160,
103                 .sizeimage = 160 * 120,
104                 .colorspace = V4L2_COLORSPACE_SRGB,
105                 .priv = 3},
106         {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
107                 .bytesperline = 176,
108                 .sizeimage = 176 * 144,
109                 .colorspace = V4L2_COLORSPACE_SRGB,
110                 .priv = 2},
111         {320, 240, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
112                 .bytesperline = 320,
113                 .sizeimage = 320 * 240 * 4 / 8,
114                 .colorspace = V4L2_COLORSPACE_SRGB,
115                 .priv = 1},
116         {352, 288, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
117                 .bytesperline = 352,
118                 .sizeimage = 352 * 288 * 4 / 8,
119                 .colorspace = V4L2_COLORSPACE_SRGB,
120                 .priv = 0},
121 };
122
123 /*
124  * Initialization data
125  * I'm not very sure how to split initialization from open data
126  * chunks. For now, we'll consider everything as initialization
127  */
128 /* Frame packet header offsets for the spca561 */
129 #define SPCA561_OFFSET_SNAP 1
130 #define SPCA561_OFFSET_TYPE 2
131 #define SPCA561_OFFSET_COMPRESS 3
132 #define SPCA561_OFFSET_FRAMSEQ   4
133 #define SPCA561_OFFSET_GPIO 5
134 #define SPCA561_OFFSET_USBBUFF 6
135 #define SPCA561_OFFSET_WIN2GRAVE 7
136 #define SPCA561_OFFSET_WIN2RAVE 8
137 #define SPCA561_OFFSET_WIN2BAVE 9
138 #define SPCA561_OFFSET_WIN2GBAVE 10
139 #define SPCA561_OFFSET_WIN1GRAVE 11
140 #define SPCA561_OFFSET_WIN1RAVE 12
141 #define SPCA561_OFFSET_WIN1BAVE 13
142 #define SPCA561_OFFSET_WIN1GBAVE 14
143 #define SPCA561_OFFSET_FREQ 15
144 #define SPCA561_OFFSET_VSYNC 16
145 #define SPCA561_OFFSET_DATA 1
146 #define SPCA561_INDEX_I2C_BASE 0x8800
147 #define SPCA561_SNAPBIT 0x20
148 #define SPCA561_SNAPCTRL 0x40
149 enum {
150         Rev072A = 0,
151         Rev012A,
152 };
153
154 static void reg_w_val(struct usb_device *dev, __u16 index, __u16 value)
155 {
156         int ret;
157
158         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
159                               0,                /* request */
160                               USB_TYPE_VENDOR | USB_RECIP_DEVICE,
161                               value, index, NULL, 0, 500);
162         PDEBUG(D_USBO, "reg write: 0x%02x:0x%02x", index, value);
163         if (ret < 0)
164                 PDEBUG(D_ERR, "reg write: error %d", ret);
165 }
166
167 static void write_vector(struct gspca_dev *gspca_dev,
168                         const __u16 data[][2])
169 {
170         struct usb_device *dev = gspca_dev->dev;
171         int i;
172
173         i = 0;
174         while (data[i][1] != 0) {
175                 reg_w_val(dev, data[i][1], data[i][0]);
176                 i++;
177         }
178 }
179
180 /* read 'len' bytes to gspca_dev->usb_buf */
181 static void reg_r(struct gspca_dev *gspca_dev,
182                   __u16 index, __u16 length)
183 {
184         usb_control_msg(gspca_dev->dev,
185                         usb_rcvctrlpipe(gspca_dev->dev, 0),
186                         0,                      /* request */
187                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
188                         0,                      /* value */
189                         index, gspca_dev->usb_buf, length, 500);
190 }
191
192 static void reg_w_buf(struct gspca_dev *gspca_dev,
193                       __u16 index, const __u8 *buffer, __u16 len)
194 {
195         memcpy(gspca_dev->usb_buf, buffer, len);
196         usb_control_msg(gspca_dev->dev,
197                         usb_sndctrlpipe(gspca_dev->dev, 0),
198                         0,                      /* request */
199                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
200                         0,                      /* value */
201                         index, gspca_dev->usb_buf, len, 500);
202 }
203
204 static void i2c_init(struct gspca_dev *gspca_dev, __u8 mode)
205 {
206         reg_w_val(gspca_dev->dev, 0x92, 0x8804);
207         reg_w_val(gspca_dev->dev, mode, 0x8802);
208 }
209
210 static void i2c_write(struct gspca_dev *gspca_dev, __u16 valeur, __u16 reg)
211 {
212         int retry = 60;
213         __u8 DataLow;
214         __u8 DataHight;
215
216         DataLow = valeur;
217         DataHight = valeur >> 8;
218         reg_w_val(gspca_dev->dev, reg, 0x8801);
219         reg_w_val(gspca_dev->dev, DataLow, 0x8805);
220         reg_w_val(gspca_dev->dev, DataHight, 0x8800);
221         while (retry--) {
222                 reg_r(gspca_dev, 0x8803, 1);
223                 if (!gspca_dev->usb_buf[0])
224                         break;
225         }
226 }
227
228 static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode)
229 {
230         int retry = 60;
231         __u8 value;
232         __u8 vallsb;
233
234         reg_w_val(gspca_dev->dev, 0x92, 0x8804);
235         reg_w_val(gspca_dev->dev, reg, 0x8801);
236         reg_w_val(gspca_dev->dev, (mode | 0x01), 0x8802);
237         while (retry--) {
238                 reg_r(gspca_dev, 0x8803, 1);
239                 if (!gspca_dev->usb_buf)
240                         break;
241         }
242         if (retry == 0)
243                 return -1;
244         reg_r(gspca_dev, 0x8800, 1);
245         value = gspca_dev->usb_buf[0];
246         reg_r(gspca_dev, 0x8805, 1);
247         vallsb = gspca_dev->usb_buf[0];
248         return ((int) value << 8) | vallsb;
249 }
250
251 static const __u16 spca561_init_data[][2] = {
252         {0x0000, 0x8114},       /* Software GPIO output data */
253         {0x0001, 0x8114},       /* Software GPIO output data */
254         {0x0000, 0x8112},       /* Some kind of reset */
255         {0x0003, 0x8701},       /* PCLK clock delay adjustment */
256         {0x0001, 0x8703},       /* HSYNC from cmos inverted */
257         {0x0011, 0x8118},       /* Enable and conf sensor */
258         {0x0001, 0x8118},       /* Conf sensor */
259         {0x0092, 0x8804},       /* I know nothing about these */
260         {0x0010, 0x8802},       /* 0x88xx registers, so I won't */
261         /***************/
262         {0x000d, 0x8805},       /* sensor default setting */
263         {0x0001, 0x8801},       /* 1 <- 0x0d */
264         {0x0000, 0x8800},
265         {0x0018, 0x8805},
266         {0x0002, 0x8801},       /* 2 <- 0x18 */
267         {0x0000, 0x8800},
268         {0x0065, 0x8805},
269         {0x0004, 0x8801},       /* 4 <- 0x01 0x65 */
270         {0x0001, 0x8800},
271         {0x0021, 0x8805},
272         {0x0005, 0x8801},       /* 5 <- 0x21 */
273         {0x0000, 0x8800},
274         {0x00aa, 0x8805},
275         {0x0007, 0x8801},       /* 7 <- 0xaa */
276         {0x0000, 0x8800},
277         {0x0004, 0x8805},
278         {0x0020, 0x8801},       /* 0x20 <- 0x15 0x04 */
279         {0x0015, 0x8800},
280         {0x0002, 0x8805},
281         {0x0039, 0x8801},       /* 0x39 <- 0x02 */
282         {0x0000, 0x8800},
283         {0x0010, 0x8805},
284         {0x0035, 0x8801},       /* 0x35 <- 0x10 */
285         {0x0000, 0x8800},
286         {0x0049, 0x8805},
287         {0x0009, 0x8801},       /* 0x09 <- 0x10 0x49 */
288         {0x0010, 0x8800},
289         {0x000b, 0x8805},
290         {0x0028, 0x8801},       /* 0x28 <- 0x0b */
291         {0x0000, 0x8800},
292         {0x000f, 0x8805},
293         {0x003b, 0x8801},       /* 0x3b <- 0x0f */
294         {0x0000, 0x8800},
295         {0x0000, 0x8805},
296         {0x003c, 0x8801},       /* 0x3c <- 0x00 */
297         {0x0000, 0x8800},
298         /***************/
299         {0x0018, 0x8601},       /* Pixel/line selection for color separation */
300         {0x0000, 0x8602},       /* Optical black level for user setting */
301         {0x0060, 0x8604},       /* Optical black horizontal offset */
302         {0x0002, 0x8605},       /* Optical black vertical offset */
303         {0x0000, 0x8603},       /* Non-automatic optical black level */
304         {0x0002, 0x865b},       /* Horizontal offset for valid pixels */
305         {0x0000, 0x865f},       /* Vertical valid pixels window (x2) */
306         {0x00b0, 0x865d},       /* Horizontal valid pixels window (x2) */
307         {0x0090, 0x865e},       /* Vertical valid lines window (x2) */
308         {0x00e0, 0x8406},       /* Memory buffer threshold */
309         {0x0000, 0x8660},       /* Compensation memory stuff */
310         {0x0002, 0x8201},       /* Output address for r/w serial EEPROM */
311         {0x0008, 0x8200},       /* Clear valid bit for serial EEPROM */
312         {0x0001, 0x8200},       /* OprMode to be executed by hardware */
313         {0x0007, 0x8201},       /* Output address for r/w serial EEPROM */
314         {0x0008, 0x8200},       /* Clear valid bit for serial EEPROM */
315         {0x0001, 0x8200},       /* OprMode to be executed by hardware */
316         {0x0010, 0x8660},       /* Compensation memory stuff */
317         {0x0018, 0x8660},       /* Compensation memory stuff */
318
319         {0x0004, 0x8611},       /* R offset for white balance */
320         {0x0004, 0x8612},       /* Gr offset for white balance */
321         {0x0007, 0x8613},       /* B offset for white balance */
322         {0x0000, 0x8614},       /* Gb offset for white balance */
323         {0x008c, 0x8651},       /* R gain for white balance */
324         {0x008c, 0x8652},       /* Gr gain for white balance */
325         {0x00b5, 0x8653},       /* B gain for white balance */
326         {0x008c, 0x8654},       /* Gb gain for white balance */
327         {0x0002, 0x8502},       /* Maximum average bit rate stuff */
328
329         {0x0011, 0x8802},
330         {0x0087, 0x8700},       /* Set master clock (96Mhz????) */
331         {0x0081, 0x8702},       /* Master clock output enable */
332
333         {0x0000, 0x8500},       /* Set image type (352x288 no compression) */
334         /* Originally was 0x0010 (352x288 compression) */
335
336         {0x0002, 0x865b},       /* Horizontal offset for valid pixels */
337         {0x0003, 0x865c},       /* Vertical offset for valid lines */
338         /***************//* sensor active */
339         {0x0003, 0x8801},       /* 0x03 <- 0x01 0x21 //289 */
340         {0x0021, 0x8805},
341         {0x0001, 0x8800},
342         {0x0004, 0x8801},       /* 0x04 <- 0x01 0x65 //357 */
343         {0x0065, 0x8805},
344         {0x0001, 0x8800},
345         {0x0005, 0x8801},       /* 0x05 <- 0x2f */
346         {0x002f, 0x8805},
347         {0x0000, 0x8800},
348         {0x0006, 0x8801},       /* 0x06 <- 0 */
349         {0x0000, 0x8805},
350         {0x0000, 0x8800},
351         {0x000a, 0x8801},       /* 0x0a <- 2 */
352         {0x0002, 0x8805},
353         {0x0000, 0x8800},
354         {0x0009, 0x8801},       /* 0x09 <- 0x1061 */
355         {0x0061, 0x8805},
356         {0x0010, 0x8800},
357         {0x0035, 0x8801},       /* 0x35 <-0x14 */
358         {0x0014, 0x8805},
359         {0x0000, 0x8800},
360         {0x0030, 0x8112},       /* ISO and drop packet enable */
361         {0x0000, 0x8112},       /* Some kind of reset ???? */
362         {0x0009, 0x8118},       /* Enable sensor and set standby */
363         {0x0000, 0x8114},       /* Software GPIO output data */
364         {0x0000, 0x8114},       /* Software GPIO output data */
365         {0x0001, 0x8114},       /* Software GPIO output data */
366         {0x0000, 0x8112},       /* Some kind of reset ??? */
367         {0x0003, 0x8701},
368         {0x0001, 0x8703},
369         {0x0011, 0x8118},
370         {0x0001, 0x8118},
371         /***************/
372         {0x0092, 0x8804},
373         {0x0010, 0x8802},
374         {0x000d, 0x8805},
375         {0x0001, 0x8801},
376         {0x0000, 0x8800},
377         {0x0018, 0x8805},
378         {0x0002, 0x8801},
379         {0x0000, 0x8800},
380         {0x0065, 0x8805},
381         {0x0004, 0x8801},
382         {0x0001, 0x8800},
383         {0x0021, 0x8805},
384         {0x0005, 0x8801},
385         {0x0000, 0x8800},
386         {0x00aa, 0x8805},
387         {0x0007, 0x8801},       /* mode 0xaa */
388         {0x0000, 0x8800},
389         {0x0004, 0x8805},
390         {0x0020, 0x8801},
391         {0x0015, 0x8800},       /* mode 0x0415 */
392         {0x0002, 0x8805},
393         {0x0039, 0x8801},
394         {0x0000, 0x8800},
395         {0x0010, 0x8805},
396         {0x0035, 0x8801},
397         {0x0000, 0x8800},
398         {0x0049, 0x8805},
399         {0x0009, 0x8801},
400         {0x0010, 0x8800},
401         {0x000b, 0x8805},
402         {0x0028, 0x8801},
403         {0x0000, 0x8800},
404         {0x000f, 0x8805},
405         {0x003b, 0x8801},
406         {0x0000, 0x8800},
407         {0x0000, 0x8805},
408         {0x003c, 0x8801},
409         {0x0000, 0x8800},
410         {0x0002, 0x8502},
411         {0x0039, 0x8801},
412         {0x0000, 0x8805},
413         {0x0000, 0x8800},
414
415         {0x0087, 0x8700},       /* overwrite by start */
416         {0x0081, 0x8702},
417         {0x0000, 0x8500},
418 /*      {0x0010, 0x8500},  -- Previous line was this */
419         {0x0002, 0x865b},
420         {0x0003, 0x865c},
421         /***************/
422         {0x0003, 0x8801},       /* 0x121-> 289 */
423         {0x0021, 0x8805},
424         {0x0001, 0x8800},
425         {0x0004, 0x8801},       /* 0x165 -> 357 */
426         {0x0065, 0x8805},
427         {0x0001, 0x8800},
428         {0x0005, 0x8801},       /* 0x2f //blanking control colonne */
429         {0x002f, 0x8805},
430         {0x0000, 0x8800},
431         {0x0006, 0x8801},       /* 0x00 //blanking mode row */
432         {0x0000, 0x8805},
433         {0x0000, 0x8800},
434         {0x000a, 0x8801},       /* 0x01 //0x02 */
435         {0x0001, 0x8805},
436         {0x0000, 0x8800},
437         {0x0009, 0x8801},       /* 0x1061 - setexposure times && pixel clock
438                                  * 0001 0 | 000 0110 0001 */
439         {0x0061, 0x8805},       /* 61 31 */
440         {0x0008, 0x8800},       /* 08 */
441         {0x0035, 0x8801},       /* 0x14 - set gain general */
442         {0x001f, 0x8805},       /* 0x14 */
443         {0x0000, 0x8800},
444         {0x0030, 0x8112},
445         {}
446 };
447
448 static void sensor_reset(struct gspca_dev *gspca_dev)
449 {
450         reg_w_val(gspca_dev->dev, 0x8631, 0xc8);
451         reg_w_val(gspca_dev->dev, 0x8634, 0xc8);
452         reg_w_val(gspca_dev->dev, 0x8112, 0x00);
453         reg_w_val(gspca_dev->dev, 0x8114, 0x00);
454         reg_w_val(gspca_dev->dev, 0x8118, 0x21);
455         i2c_init(gspca_dev, 0x14);
456         i2c_write(gspca_dev, 1, 0x0d);
457         i2c_write(gspca_dev, 0, 0x0d);
458 }
459
460 /******************** QC Express etch2 stuff ********************/
461 static const __u16 Pb100_1map8300[][2] = {
462         /* reg, value */
463         {0x8320, 0x3304},
464
465         {0x8303, 0x0125},       /* image area */
466         {0x8304, 0x0169},
467         {0x8328, 0x000b},
468         {0x833c, 0x0001},
469
470         {0x832f, 0x0419},
471         {0x8307, 0x00aa},
472         {0x8301, 0x0003},
473         {0x8302, 0x000e},
474         {}
475 };
476 static const __u16 Pb100_2map8300[][2] = {
477         /* reg, value */
478         {0x8339, 0x0000},
479         {0x8307, 0x00aa},
480         {}
481 };
482
483 static const __u16 spca561_161rev12A_data1[][2] = {
484         {0x21, 0x8118},
485         {0x01, 0x8114},
486         {0x00, 0x8112},
487         {0x92, 0x8804},
488         {0x04, 0x8802},         /* windows uses 08 */
489         {}
490 };
491 static const __u16 spca561_161rev12A_data2[][2] = {
492         {0x21, 0x8118},
493         {0x10, 0x8500},
494         {0x07, 0x8601},
495         {0x07, 0x8602},
496         {0x04, 0x8501},
497         {0x21, 0x8118},
498
499         {0x07, 0x8201},         /* windows uses 02 */
500         {0x08, 0x8200},
501         {0x01, 0x8200},
502
503         {0x00, 0x8114},
504         {0x01, 0x8114},         /* windows uses 00 */
505
506         {0x90, 0x8604},
507         {0x00, 0x8605},
508         {0xb0, 0x8603},
509
510         /* sensor gains */
511         {0x00, 0x8610},         /* *red */
512         {0x00, 0x8611},         /* 3f   *green */
513         {0x00, 0x8612},         /* green *blue */
514         {0x00, 0x8613},         /* blue *green */
515         {0x35, 0x8614},         /* green *red */
516         {0x35, 0x8615},         /* 40   *green */
517         {0x35, 0x8616},         /* 7a   *blue */
518         {0x35, 0x8617},         /* 40   *green */
519
520         {0x0c, 0x8620},         /* 0c */
521         {0xc8, 0x8631},         /* c8 */
522         {0xc8, 0x8634},         /* c8 */
523         {0x23, 0x8635},         /* 23 */
524         {0x1f, 0x8636},         /* 1f */
525         {0xdd, 0x8637},         /* dd */
526         {0xe1, 0x8638},         /* e1 */
527         {0x1d, 0x8639},         /* 1d */
528         {0x21, 0x863a},         /* 21 */
529         {0xe3, 0x863b},         /* e3 */
530         {0xdf, 0x863c},         /* df */
531         {0xf0, 0x8505},
532         {0x32, 0x850a},
533         {}
534 };
535
536 static void sensor_mapwrite(struct gspca_dev *gspca_dev,
537                             const __u16 sensormap[][2])
538 {
539         int i = 0;
540         __u8 usbval[2];
541
542         while (sensormap[i][0]) {
543                 usbval[0] = sensormap[i][1];
544                 usbval[1] = sensormap[i][1] >> 8;
545                 reg_w_buf(gspca_dev, sensormap[i][0], usbval, 2);
546                 i++;
547         }
548 }
549 static void init_161rev12A(struct gspca_dev *gspca_dev)
550 {
551         sensor_reset(gspca_dev);
552         write_vector(gspca_dev, spca561_161rev12A_data1);
553         sensor_mapwrite(gspca_dev, Pb100_1map8300);
554         write_vector(gspca_dev, spca561_161rev12A_data2);
555         sensor_mapwrite(gspca_dev, Pb100_2map8300);
556 }
557
558 /* this function is called at probe time */
559 static int sd_config(struct gspca_dev *gspca_dev,
560                      const struct usb_device_id *id)
561 {
562         struct sd *sd = (struct sd *) gspca_dev;
563         struct cam *cam;
564         __u16 vendor, product;
565         __u8 data1, data2;
566
567         /* Read frm global register the USB product and vendor IDs, just to
568          * prove that we can communicate with the device.  This works, which
569          * confirms at we are communicating properly and that the device
570          * is a 561. */
571         reg_r(gspca_dev, 0x8104, 1);
572         data1 = gspca_dev->usb_buf[0];
573         reg_r(gspca_dev, 0x8105, 1);
574         data2 = gspca_dev->usb_buf[0];
575         vendor = (data2 << 8) | data1;
576         reg_r(gspca_dev, 0x8106, 1);
577         data1 = gspca_dev->usb_buf[0];
578         reg_r(gspca_dev, 0x8107, 1);
579         data2 = gspca_dev->usb_buf[0];
580         product = (data2 << 8) | data1;
581         if (vendor != id->idVendor || product != id->idProduct) {
582                 PDEBUG(D_PROBE, "Bad vendor / product from device");
583                 return -EINVAL;
584         }
585         switch (product) {
586         case 0x0928:
587         case 0x0929:
588         case 0x092a:
589         case 0x092b:
590         case 0x092c:
591         case 0x092d:
592         case 0x092e:
593         case 0x092f:
594         case 0x403b:
595                 sd->chip_revision = Rev012A;
596                 break;
597         default:
598 /*      case 0x0561:
599         case 0x0815:                    * ?? in spca508.c
600         case 0x401a:
601         case 0x7004:
602         case 0x7e50:
603         case 0xa001:
604         case 0xcdee: */
605                 sd->chip_revision = Rev072A;
606                 break;
607         }
608         cam = &gspca_dev->cam;
609         cam->dev_name = (char *) id->driver_info;
610         cam->epaddr = 0x01;
611         gspca_dev->nbalt = 7 + 1;       /* choose alternate 7 first */
612         cam->cam_mode = sif_mode;
613         cam->nmodes = sizeof sif_mode / sizeof sif_mode[0];
614         sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
615         sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
616         sd->autogain = sd_ctrls[SD_AUTOGAIN].qctrl.default_value;
617         return 0;
618 }
619
620 /* this function is called at open time */
621 static int sd_open(struct gspca_dev *gspca_dev)
622 {
623         struct sd *sd = (struct sd *) gspca_dev;
624
625         switch (sd->chip_revision) {
626         case Rev072A:
627                 PDEBUG(D_STREAM, "Chip revision id: 072a");
628                 write_vector(gspca_dev, spca561_init_data);
629                 break;
630         default:
631 /*      case Rev012A: */
632                 PDEBUG(D_STREAM, "Chip revision id: 012a");
633                 init_161rev12A(gspca_dev);
634                 break;
635         }
636         return 0;
637 }
638
639 static void setcontrast(struct gspca_dev *gspca_dev)
640 {
641         struct sd *sd = (struct sd *) gspca_dev;
642         struct usb_device *dev = gspca_dev->dev;
643         __u8 lowb;
644         int expotimes;
645
646         switch (sd->chip_revision) {
647         case Rev072A:
648                 lowb = sd->contrast >> 8;
649                 reg_w_val(dev, lowb, 0x8651);
650                 reg_w_val(dev, lowb, 0x8652);
651                 reg_w_val(dev, lowb, 0x8653);
652                 reg_w_val(dev, lowb, 0x8654);
653                 break;
654         case Rev012A: {
655                 __u8 Reg8391[] =
656                         { 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00 };
657
658                 /* Write camera sensor settings */
659                 expotimes = (sd->contrast >> 5) & 0x07ff;
660                 Reg8391[0] = expotimes & 0xff;  /* exposure */
661                 Reg8391[1] = 0x18 | (expotimes >> 8);
662                 Reg8391[2] = sd->brightness;    /* gain */
663                 reg_w_buf(gspca_dev, 0x8391, Reg8391, 8);
664                 reg_w_buf(gspca_dev, 0x8390, Reg8391, 8);
665                 break;
666             }
667         }
668 }
669
670 static void sd_start(struct gspca_dev *gspca_dev)
671 {
672         struct sd *sd = (struct sd *) gspca_dev;
673         struct usb_device *dev = gspca_dev->dev;
674         int Clck;
675         __u8 Reg8307[] = { 0xaa, 0x00 };
676         int mode;
677
678         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
679         switch (sd->chip_revision) {
680         case Rev072A:
681                 switch (mode) {
682                 default:
683 /*              case 0:
684                 case 1: */
685                         Clck = 0x25;
686                         break;
687                 case 2:
688                         Clck = 0x22;
689                         break;
690                 case 3:
691                         Clck = 0x21;
692                         break;
693                 }
694                 reg_w_val(dev, 0x8500, mode);   /* mode */
695                 reg_w_val(dev, 0x8700, Clck);   /* 0x27 clock */
696                 reg_w_val(dev, 0x8112, 0x10 | 0x20);
697                 break;
698         default:
699 /*      case Rev012A: */
700                 switch (mode) {
701                 case 0:
702                 case 1:
703                         Clck = 0x8a;
704                         break;
705                 case 2:
706                         Clck = 0x85;
707                         break;
708                 default:
709                         Clck = 0x83;
710                         break;
711                 }
712                 if (mode <= 1) {
713                         /* Use compression on 320x240 and above */
714                         reg_w_val(dev, 0x8500, 0x10 | mode);
715                 } else {
716                         /* I couldn't get the compression to work below 320x240
717                          * Fortunately at these resolutions the bandwidth
718                          * is sufficient to push raw frames at ~20fps */
719                         reg_w_val(dev, 0x8500, mode);
720                 }               /* -- qq@kuku.eu.org */
721                 reg_w_buf(gspca_dev, 0x8307, Reg8307, 2);
722                 reg_w_val(gspca_dev->dev, 0x8700, Clck);
723                                                 /* 0x8f 0x85 0x27 clock */
724                 reg_w_val(gspca_dev->dev, 0x8112, 0x1e | 0x20);
725                 reg_w_val(gspca_dev->dev, 0x850b, 0x03);
726                 setcontrast(gspca_dev);
727                 break;
728         }
729 }
730
731 static void sd_stopN(struct gspca_dev *gspca_dev)
732 {
733         reg_w_val(gspca_dev->dev, 0x8112, 0x20);
734 }
735
736 static void sd_stop0(struct gspca_dev *gspca_dev)
737 {
738 }
739
740 /* this function is called at close time */
741 static void sd_close(struct gspca_dev *gspca_dev)
742 {
743         reg_w_val(gspca_dev->dev, 0x8114, 0);
744 }
745
746 static void setautogain(struct gspca_dev *gspca_dev)
747 {
748         struct sd *sd = (struct sd *) gspca_dev;
749         int expotimes = 0;
750         int pixelclk = 0;
751         int gainG = 0;
752         __u8 R, Gr, Gb, B;
753         int y;
754         __u8 luma_mean = 110;
755         __u8 luma_delta = 20;
756         __u8 spring = 4;
757
758         switch (sd->chip_revision) {
759         case Rev072A:
760                 reg_r(gspca_dev, 0x8621, 1);
761                 Gr = gspca_dev->usb_buf[0];
762                 reg_r(gspca_dev, 0x8622, 1);
763                 R = gspca_dev->usb_buf[0];
764                 reg_r(gspca_dev, 0x8623, 1);
765                 B = gspca_dev->usb_buf[0];
766                 reg_r(gspca_dev, 0x8624, 1);
767                 Gb = gspca_dev->usb_buf[0];
768                 y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8;
769                 /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */
770                 /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */
771                 /* PDEBUG(D_CONF,"reading Y %d U %d V %d ",y,u,v); */
772
773                 if (y < luma_mean - luma_delta ||
774                     y > luma_mean + luma_delta) {
775                         expotimes = i2c_read(gspca_dev, 0x09, 0x10);
776                         pixelclk = 0x0800;
777                         expotimes = expotimes & 0x07ff;
778                         /* PDEBUG(D_PACK,
779                                 "Exposition Times 0x%03X Clock 0x%04X ",
780                                 expotimes,pixelclk); */
781                         gainG = i2c_read(gspca_dev, 0x35, 0x10);
782                         /* PDEBUG(D_PACK,
783                                 "reading Gain register %d", gainG); */
784
785                         expotimes += (luma_mean - y) >> spring;
786                         gainG += (luma_mean - y) / 50;
787                         /* PDEBUG(D_PACK,
788                                 "compute expotimes %d gain %d",
789                                 expotimes,gainG); */
790
791                         if (gainG > 0x3f)
792                                 gainG = 0x3f;
793                         else if (gainG < 4)
794                                 gainG = 3;
795                         i2c_write(gspca_dev, gainG, 0x35);
796
797                         if (expotimes >= 0x0256)
798                                 expotimes = 0x0256;
799                         else if (expotimes < 4)
800                                 expotimes = 3;
801                         i2c_write(gspca_dev, expotimes | pixelclk, 0x09);
802                 }
803                 break;
804         case Rev012A:
805                 /* sensor registers is access and memory mapped to 0x8300 */
806                 /* readind all 0x83xx block the sensor */
807                 /*
808                  * The data from the header seem wrong where is the luma
809                  * and chroma mean value
810                  * at the moment set exposure in contrast set
811                  */
812                 break;
813         }
814 }
815
816 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
817                         struct gspca_frame *frame, /* target */
818                         __u8 *data,             /* isoc packet */
819                         int len)                /* iso packet length */
820 {
821         struct sd *sd = (struct sd *) gspca_dev;
822
823         switch (data[0]) {
824         case 0:         /* start of frame */
825                 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
826                                         data, 0);
827                 if (sd->ag_cnt >= 0) {
828                         if (--sd->ag_cnt < 0) {
829                                 sd->ag_cnt = AG_CNT_START;
830                                 setautogain(gspca_dev);
831                         }
832                 }
833                 data += SPCA561_OFFSET_DATA;
834                 len -= SPCA561_OFFSET_DATA;
835                 if (data[1] & 0x10) {
836                         /* compressed bayer */
837                         gspca_frame_add(gspca_dev, FIRST_PACKET,
838                                         frame, data, len);
839                 } else {
840                         /* raw bayer (with a header, which we skip) */
841                         data += 20;
842                         len -= 20;
843                         gspca_frame_add(gspca_dev, FIRST_PACKET,
844                                                 frame, data, len);
845                 }
846                 return;
847         case 0xff:              /* drop */
848 /*              gspca_dev->last_packet_type = DISCARD_PACKET; */
849                 return;
850         }
851         data++;
852         len--;
853         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
854 }
855
856 static void setbrightness(struct gspca_dev *gspca_dev)
857 {
858         struct sd *sd = (struct sd *) gspca_dev;
859         __u8 value;
860
861         switch (sd->chip_revision) {
862         case Rev072A:
863                 value = sd->brightness;
864                 reg_w_val(gspca_dev->dev, value, 0x8611);
865                 reg_w_val(gspca_dev->dev, value, 0x8612);
866                 reg_w_val(gspca_dev->dev, value, 0x8613);
867                 reg_w_val(gspca_dev->dev, value, 0x8614);
868                 break;
869         default:
870 /*      case Rev012A: */
871                 setcontrast(gspca_dev);
872                 break;
873         }
874 }
875
876 static void getbrightness(struct gspca_dev *gspca_dev)
877 {
878         struct sd *sd = (struct sd *) gspca_dev;
879         __u16 tot;
880
881         switch (sd->chip_revision) {
882         case Rev072A:
883                 tot = 0;
884                 reg_r(gspca_dev, 0x8611, 1);
885                 tot += gspca_dev->usb_buf[0];
886                 reg_r(gspca_dev, 0x8612, 1);
887                 tot += gspca_dev->usb_buf[0];
888                 reg_r(gspca_dev, 0x8613, 1);
889                 tot += gspca_dev->usb_buf[0];
890                 reg_r(gspca_dev, 0x8614, 1);
891                 tot += gspca_dev->usb_buf[0];
892                 sd->brightness = tot >> 2;
893                 break;
894         default:
895 /*      case Rev012A: */
896                 /* no way to read sensor settings */
897                 break;
898         }
899 }
900
901 static void getcontrast(struct gspca_dev *gspca_dev)
902 {
903         struct sd *sd = (struct sd *) gspca_dev;
904         __u16 tot;
905
906         switch (sd->chip_revision) {
907         case Rev072A:
908                 tot = 0;
909                 reg_r(gspca_dev, 0x8651, 1);
910                 tot += gspca_dev->usb_buf[0];
911                 reg_r(gspca_dev, 0x8652, 1);
912                 tot += gspca_dev->usb_buf[0];
913                 reg_r(gspca_dev, 0x8653, 1);
914                 tot += gspca_dev->usb_buf[0];
915                 reg_r(gspca_dev, 0x8654, 1);
916                 tot += gspca_dev->usb_buf[0];
917                 sd->contrast = tot << 6;
918                 break;
919         default:
920 /*      case Rev012A: */
921                 /* no way to read sensor settings */
922                 break;
923         }
924         PDEBUG(D_CONF, "get contrast %d", sd->contrast);
925 }
926
927 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
928 {
929         struct sd *sd = (struct sd *) gspca_dev;
930
931         sd->brightness = val;
932         if (gspca_dev->streaming)
933                 setbrightness(gspca_dev);
934         return 0;
935 }
936
937 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
938 {
939         struct sd *sd = (struct sd *) gspca_dev;
940
941         getbrightness(gspca_dev);
942         *val = sd->brightness;
943         return 0;
944 }
945
946 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
947 {
948         struct sd *sd = (struct sd *) gspca_dev;
949
950         sd->contrast = val;
951         if (gspca_dev->streaming)
952                 setcontrast(gspca_dev);
953         return 0;
954 }
955
956 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
957 {
958         struct sd *sd = (struct sd *) gspca_dev;
959
960         getcontrast(gspca_dev);
961         *val = sd->contrast;
962         return 0;
963 }
964
965 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
966 {
967         struct sd *sd = (struct sd *) gspca_dev;
968
969         sd->autogain = val;
970         if (val)
971                 sd->ag_cnt = AG_CNT_START;
972         else
973                 sd->ag_cnt = -1;
974         return 0;
975 }
976
977 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
978 {
979         struct sd *sd = (struct sd *) gspca_dev;
980
981         *val = sd->autogain;
982         return 0;
983 }
984
985 /* sub-driver description */
986 static const struct sd_desc sd_desc = {
987         .name = MODULE_NAME,
988         .ctrls = sd_ctrls,
989         .nctrls = ARRAY_SIZE(sd_ctrls),
990         .config = sd_config,
991         .open = sd_open,
992         .start = sd_start,
993         .stopN = sd_stopN,
994         .stop0 = sd_stop0,
995         .close = sd_close,
996         .pkt_scan = sd_pkt_scan,
997 };
998
999 /* -- module initialisation -- */
1000 #define DVNM(name) .driver_info = (kernel_ulong_t) name
1001 static const __devinitdata struct usb_device_id device_table[] = {
1002         {USB_DEVICE(0x041e, 0x401a), DVNM("Creative Webcam Vista (PD1100)")},
1003         {USB_DEVICE(0x041e, 0x403b),  DVNM("Creative Webcam Vista (VF0010)")},
1004         {USB_DEVICE(0x0458, 0x7004), DVNM("Genius VideoCAM Express V2")},
1005         {USB_DEVICE(0x046d, 0x0928), DVNM("Logitech QC Express Etch2")},
1006         {USB_DEVICE(0x046d, 0x0929), DVNM("Labtec Webcam Elch2")},
1007         {USB_DEVICE(0x046d, 0x092a), DVNM("Logitech QC for Notebook")},
1008         {USB_DEVICE(0x046d, 0x092b), DVNM("Labtec Webcam Plus")},
1009         {USB_DEVICE(0x046d, 0x092c), DVNM("Logitech QC chat Elch2")},
1010         {USB_DEVICE(0x046d, 0x092d), DVNM("Logitech QC Elch2")},
1011         {USB_DEVICE(0x046d, 0x092e), DVNM("Logitech QC Elch2")},
1012         {USB_DEVICE(0x046d, 0x092f), DVNM("Logitech QC Elch2")},
1013         {USB_DEVICE(0x04fc, 0x0561), DVNM("Flexcam 100")},
1014         {USB_DEVICE(0x060b, 0xa001), DVNM("Maxell Compact Pc PM3")},
1015         {USB_DEVICE(0x10fd, 0x7e50), DVNM("FlyCam Usb 100")},
1016         {USB_DEVICE(0xabcd, 0xcdee), DVNM("Petcam")},
1017         {}
1018 };
1019
1020 MODULE_DEVICE_TABLE(usb, device_table);
1021
1022 /* -- device connect -- */
1023 static int sd_probe(struct usb_interface *intf,
1024                     const struct usb_device_id *id)
1025 {
1026         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1027                                THIS_MODULE);
1028 }
1029
1030 static struct usb_driver sd_driver = {
1031         .name = MODULE_NAME,
1032         .id_table = device_table,
1033         .probe = sd_probe,
1034         .disconnect = gspca_disconnect,
1035 };
1036
1037 /* -- module insert / remove -- */
1038 static int __init sd_mod_init(void)
1039 {
1040         if (usb_register(&sd_driver) < 0)
1041                 return -1;
1042         PDEBUG(D_PROBE, "v%s registered", version);
1043         return 0;
1044 }
1045 static void __exit sd_mod_exit(void)
1046 {
1047         usb_deregister(&sd_driver);
1048         PDEBUG(D_PROBE, "deregistered");
1049 }
1050
1051 module_init(sd_mod_init);
1052 module_exit(sd_mod_exit);