Linux 2.6.31-rc6
[linux-2.6] / drivers / media / video / gspca / spca505.c
1 /*
2  * SPCA505 chip based cameras initialization data
3  *
4  * V4L2 by Jean-Francis Moine <http://moinejf.free.fr>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  */
21
22 #define MODULE_NAME "spca505"
23
24 #include "gspca.h"
25
26 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
27 MODULE_DESCRIPTION("GSPCA/SPCA505 USB Camera Driver");
28 MODULE_LICENSE("GPL");
29
30 /* specific webcam descriptor */
31 struct sd {
32         struct gspca_dev gspca_dev;             /* !! must be the first item */
33
34         u8 brightness;
35
36         u8 subtype;
37 #define IntelPCCameraPro 0
38 #define Nxultra 1
39 };
40
41 /* V4L2 controls supported by the driver */
42 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
43 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
44
45 static struct ctrl sd_ctrls[] = {
46         {
47             {
48                 .id      = V4L2_CID_BRIGHTNESS,
49                 .type    = V4L2_CTRL_TYPE_INTEGER,
50                 .name    = "Brightness",
51                 .minimum = 0,
52                 .maximum = 255,
53                 .step    = 1,
54 #define BRIGHTNESS_DEF 127
55                 .default_value = BRIGHTNESS_DEF,
56             },
57             .set = sd_setbrightness,
58             .get = sd_getbrightness,
59         },
60 };
61
62 static const struct v4l2_pix_format vga_mode[] = {
63         {160, 120, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
64                 .bytesperline = 160,
65                 .sizeimage = 160 * 120 * 3 / 2,
66                 .colorspace = V4L2_COLORSPACE_SRGB,
67                 .priv = 4},
68         {176, 144, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
69                 .bytesperline = 176,
70                 .sizeimage = 176 * 144 * 3 / 2,
71                 .colorspace = V4L2_COLORSPACE_SRGB,
72                 .priv = 3},
73         {320, 240, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
74                 .bytesperline = 320,
75                 .sizeimage = 320 * 240 * 3 / 2,
76                 .colorspace = V4L2_COLORSPACE_SRGB,
77                 .priv = 2},
78         {352, 288, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
79                 .bytesperline = 352,
80                 .sizeimage = 352 * 288 * 3 / 2,
81                 .colorspace = V4L2_COLORSPACE_SRGB,
82                 .priv = 1},
83         {640, 480, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
84                 .bytesperline = 640,
85                 .sizeimage = 640 * 480 * 3 / 2,
86                 .colorspace = V4L2_COLORSPACE_SRGB,
87                 .priv = 0},
88 };
89
90 #define SPCA50X_OFFSET_DATA 10
91
92 #define SPCA50X_REG_USB 0x02    /* spca505 501 */
93
94 #define SPCA50X_USB_CTRL 0x00   /* spca505 */
95 #define SPCA50X_CUSB_ENABLE 0x01 /* spca505 */
96
97 #define SPCA50X_REG_GLOBAL 0x03 /* spca505 */
98 #define SPCA50X_GMISC0_IDSEL 0x01 /* Global control device ID select spca505 */
99 #define SPCA50X_GLOBAL_MISC0 0x00 /* Global control miscellaneous 0 spca505 */
100
101 #define SPCA50X_GLOBAL_MISC1 0x01 /* 505 */
102 #define SPCA50X_GLOBAL_MISC3 0x03 /* 505 */
103 #define SPCA50X_GMISC3_SAA7113RST 0x20  /* Not sure about this one spca505 */
104
105 /* Image format and compression control */
106 #define SPCA50X_REG_COMPRESS 0x04
107
108 /*
109  * Data to initialize a SPCA505. Common to the CCD and external modes
110  */
111 static const u8 spca505_init_data[][3] = {
112         /* bmRequest,value,index */
113         {SPCA50X_REG_GLOBAL, SPCA50X_GMISC3_SAA7113RST, SPCA50X_GLOBAL_MISC3},
114         /* Sensor reset */
115         {SPCA50X_REG_GLOBAL, 0x00, SPCA50X_GLOBAL_MISC3},
116         {SPCA50X_REG_GLOBAL, 0x00, SPCA50X_GLOBAL_MISC1},
117         /* Block USB reset */
118         {SPCA50X_REG_GLOBAL, SPCA50X_GMISC0_IDSEL, SPCA50X_GLOBAL_MISC0},
119
120         {0x05, 0x01, 0x10},
121                                         /* Maybe power down some stuff */
122         {0x05, 0x0f, 0x11},
123
124         /* Setup internal CCD  ? */
125         {0x06, 0x10, 0x08},
126         {0x06, 0x00, 0x09},
127         {0x06, 0x00, 0x0a},
128         {0x06, 0x00, 0x0b},
129         {0x06, 0x10, 0x0c},
130         {0x06, 0x00, 0x0d},
131         {0x06, 0x00, 0x0e},
132         {0x06, 0x00, 0x0f},
133         {0x06, 0x10, 0x10},
134         {0x06, 0x02, 0x11},
135         {0x06, 0x00, 0x12},
136         {0x06, 0x04, 0x13},
137         {0x06, 0x02, 0x14},
138         {0x06, 0x8a, 0x51},
139         {0x06, 0x40, 0x52},
140         {0x06, 0xb6, 0x53},
141         {0x06, 0x3d, 0x54},
142         {}
143 };
144
145 /*
146  * Data to initialize the camera using the internal CCD
147  */
148 static const u8 spca505_open_data_ccd[][3] = {
149         /* bmRequest,value,index */
150         /* Internal CCD data set */
151         {0x03, 0x04, 0x01},
152         /* This could be a reset */
153         {0x03, 0x00, 0x01},
154
155         /* Setup compression and image registers. 0x6 and 0x7 seem to be
156            related to H&V hold, and are resolution mode specific */
157                 {0x04, 0x10, 0x01},
158                 /* DIFF(0x50), was (0x10) */
159         {0x04, 0x00, 0x04},
160         {0x04, 0x00, 0x05},
161         {0x04, 0x20, 0x06},
162         {0x04, 0x20, 0x07},
163
164         {0x08, 0x0a, 0x00},
165         /* DIFF (0x4a), was (0xa) */
166
167         {0x05, 0x00, 0x10},
168         {0x05, 0x00, 0x11},
169         {0x05, 0x00, 0x00},
170         /* DIFF not written */
171         {0x05, 0x00, 0x01},
172         /* DIFF not written */
173         {0x05, 0x00, 0x02},
174         /* DIFF not written */
175         {0x05, 0x00, 0x03},
176         /* DIFF not written */
177         {0x05, 0x00, 0x04},
178         /* DIFF not written */
179                 {0x05, 0x80, 0x05},
180                 /* DIFF not written */
181                 {0x05, 0xe0, 0x06},
182                 /* DIFF not written */
183                 {0x05, 0x20, 0x07},
184                 /* DIFF not written */
185                 {0x05, 0xa0, 0x08},
186                 /* DIFF not written */
187                 {0x05, 0x0, 0x12},
188                 /* DIFF not written */
189         {0x05, 0x02, 0x0f},
190         /* DIFF not written */
191                 {0x05, 0x10, 0x46},
192                 /* DIFF not written */
193                 {0x05, 0x8, 0x4a},
194                 /* DIFF not written */
195
196         {0x03, 0x08, 0x03},
197         /* DIFF (0x3,0x28,0x3) */
198         {0x03, 0x08, 0x01},
199         {0x03, 0x0c, 0x03},
200         /* DIFF not written */
201                 {0x03, 0x21, 0x00},
202                 /* DIFF (0x39) */
203
204 /* Extra block copied from init to hopefully ensure CCD is in a sane state */
205         {0x06, 0x10, 0x08},
206         {0x06, 0x00, 0x09},
207         {0x06, 0x00, 0x0a},
208         {0x06, 0x00, 0x0b},
209         {0x06, 0x10, 0x0c},
210         {0x06, 0x00, 0x0d},
211         {0x06, 0x00, 0x0e},
212         {0x06, 0x00, 0x0f},
213         {0x06, 0x10, 0x10},
214         {0x06, 0x02, 0x11},
215         {0x06, 0x00, 0x12},
216         {0x06, 0x04, 0x13},
217         {0x06, 0x02, 0x14},
218         {0x06, 0x8a, 0x51},
219         {0x06, 0x40, 0x52},
220         {0x06, 0xb6, 0x53},
221         {0x06, 0x3d, 0x54},
222         /* End of extra block */
223
224                 {0x06, 0x3f, 0x1},
225                 /* Block skipped */
226         {0x06, 0x10, 0x02},
227         {0x06, 0x64, 0x07},
228         {0x06, 0x10, 0x08},
229         {0x06, 0x00, 0x09},
230         {0x06, 0x00, 0x0a},
231         {0x06, 0x00, 0x0b},
232         {0x06, 0x10, 0x0c},
233         {0x06, 0x00, 0x0d},
234         {0x06, 0x00, 0x0e},
235         {0x06, 0x00, 0x0f},
236         {0x06, 0x10, 0x10},
237         {0x06, 0x02, 0x11},
238         {0x06, 0x00, 0x12},
239         {0x06, 0x04, 0x13},
240         {0x06, 0x02, 0x14},
241         {0x06, 0x8a, 0x51},
242         {0x06, 0x40, 0x52},
243         {0x06, 0xb6, 0x53},
244         {0x06, 0x3d, 0x54},
245         {0x06, 0x60, 0x57},
246         {0x06, 0x20, 0x58},
247         {0x06, 0x15, 0x59},
248         {0x06, 0x05, 0x5a},
249
250         {0x05, 0x01, 0xc0},
251         {0x05, 0x10, 0xcb},
252                 {0x05, 0x80, 0xc1},
253                 /* */
254                 {0x05, 0x0, 0xc2},
255                 /* 4 was 0 */
256         {0x05, 0x00, 0xca},
257                 {0x05, 0x80, 0xc1},
258                 /*  */
259         {0x05, 0x04, 0xc2},
260         {0x05, 0x00, 0xca},
261                 {0x05, 0x0, 0xc1},
262                 /*  */
263         {0x05, 0x00, 0xc2},
264         {0x05, 0x00, 0xca},
265                 {0x05, 0x40, 0xc1},
266                 /* */
267         {0x05, 0x17, 0xc2},
268         {0x05, 0x00, 0xca},
269                 {0x05, 0x80, 0xc1},
270                 /* */
271         {0x05, 0x06, 0xc2},
272         {0x05, 0x00, 0xca},
273                 {0x05, 0x80, 0xc1},
274                 /* */
275         {0x05, 0x04, 0xc2},
276         {0x05, 0x00, 0xca},
277
278         {0x03, 0x4c, 0x3},
279         {0x03, 0x18, 0x1},
280
281         {0x06, 0x70, 0x51},
282         {0x06, 0xbe, 0x53},
283         {0x06, 0x71, 0x57},
284         {0x06, 0x20, 0x58},
285         {0x06, 0x05, 0x59},
286         {0x06, 0x15, 0x5a},
287
288         {0x04, 0x00, 0x08},
289         /* Compress = OFF (0x1 to turn on) */
290         {0x04, 0x12, 0x09},
291         {0x04, 0x21, 0x0a},
292         {0x04, 0x10, 0x0b},
293         {0x04, 0x21, 0x0c},
294         {0x04, 0x05, 0x00},
295         /* was 5 (Image Type ? ) */
296         {0x04, 0x00, 0x01},
297
298         {0x06, 0x3f, 0x01},
299
300         {0x04, 0x00, 0x04},
301         {0x04, 0x00, 0x05},
302         {0x04, 0x40, 0x06},
303         {0x04, 0x40, 0x07},
304
305         {0x06, 0x1c, 0x17},
306         {0x06, 0xe2, 0x19},
307         {0x06, 0x1c, 0x1b},
308         {0x06, 0xe2, 0x1d},
309         {0x06, 0xaa, 0x1f},
310         {0x06, 0x70, 0x20},
311
312         {0x05, 0x01, 0x10},
313         {0x05, 0x00, 0x11},
314         {0x05, 0x01, 0x00},
315         {0x05, 0x05, 0x01},
316                 {0x05, 0x00, 0xc1},
317                 /* */
318         {0x05, 0x00, 0xc2},
319         {0x05, 0x00, 0xca},
320
321         {0x06, 0x70, 0x51},
322         {0x06, 0xbe, 0x53},
323         {}
324 };
325
326 /*
327  * Made by Tomasz Zablocki (skalamandra@poczta.onet.pl)
328  * SPCA505b chip based cameras initialization data
329  */
330 /* jfm */
331 #define initial_brightness 0x7f /* 0x0(white)-0xff(black) */
332 /* #define initial_brightness 0x0       //0x0(white)-0xff(black) */
333 /*
334  * Data to initialize a SPCA505. Common to the CCD and external modes
335  */
336 static const u8 spca505b_init_data[][3] = {
337 /* start */
338         {0x02, 0x00, 0x00},             /* init */
339         {0x02, 0x00, 0x01},
340         {0x02, 0x00, 0x02},
341         {0x02, 0x00, 0x03},
342         {0x02, 0x00, 0x04},
343         {0x02, 0x00, 0x05},
344         {0x02, 0x00, 0x06},
345         {0x02, 0x00, 0x07},
346         {0x02, 0x00, 0x08},
347         {0x02, 0x00, 0x09},
348         {0x03, 0x00, 0x00},
349         {0x03, 0x00, 0x01},
350         {0x03, 0x00, 0x02},
351         {0x03, 0x00, 0x03},
352         {0x03, 0x00, 0x04},
353         {0x03, 0x00, 0x05},
354         {0x03, 0x00, 0x06},
355         {0x04, 0x00, 0x00},
356         {0x04, 0x00, 0x02},
357         {0x04, 0x00, 0x04},
358         {0x04, 0x00, 0x05},
359         {0x04, 0x00, 0x06},
360         {0x04, 0x00, 0x07},
361         {0x04, 0x00, 0x08},
362         {0x04, 0x00, 0x09},
363         {0x04, 0x00, 0x0a},
364         {0x04, 0x00, 0x0b},
365         {0x04, 0x00, 0x0c},
366         {0x07, 0x00, 0x00},
367         {0x07, 0x00, 0x03},
368         {0x08, 0x00, 0x00},
369         {0x08, 0x00, 0x01},
370         {0x08, 0x00, 0x02},
371         {0x00, 0x01, 0x00},
372         {0x00, 0x01, 0x01},
373         {0x00, 0x01, 0x34},
374         {0x00, 0x01, 0x35},
375         {0x06, 0x18, 0x08},
376         {0x06, 0xfc, 0x09},
377         {0x06, 0xfc, 0x0a},
378         {0x06, 0xfc, 0x0b},
379         {0x06, 0x18, 0x0c},
380         {0x06, 0xfc, 0x0d},
381         {0x06, 0xfc, 0x0e},
382         {0x06, 0xfc, 0x0f},
383         {0x06, 0x18, 0x10},
384         {0x06, 0xfe, 0x12},
385         {0x06, 0x00, 0x11},
386         {0x06, 0x00, 0x14},
387         {0x06, 0x00, 0x13},
388         {0x06, 0x28, 0x51},
389         {0x06, 0xff, 0x53},
390         {0x02, 0x00, 0x08},
391
392         {0x03, 0x00, 0x03},
393         {0x03, 0x10, 0x03},
394         {}
395 };
396
397 /*
398  * Data to initialize the camera using the internal CCD
399  */
400 static const u8 spca505b_open_data_ccd[][3] = {
401
402 /* {0x02,0x00,0x00}, */
403         {0x03, 0x04, 0x01},             /* rst */
404         {0x03, 0x00, 0x01},
405         {0x03, 0x00, 0x00},
406         {0x03, 0x21, 0x00},
407         {0x03, 0x00, 0x04},
408         {0x03, 0x00, 0x03},
409         {0x03, 0x18, 0x03},
410         {0x03, 0x08, 0x01},
411         {0x03, 0x1c, 0x03},
412         {0x03, 0x5c, 0x03},
413         {0x03, 0x5c, 0x03},
414         {0x03, 0x18, 0x01},
415
416 /* same as 505 */
417         {0x04, 0x10, 0x01},
418         {0x04, 0x00, 0x04},
419         {0x04, 0x00, 0x05},
420         {0x04, 0x20, 0x06},
421         {0x04, 0x20, 0x07},
422
423         {0x08, 0x0a, 0x00},
424
425         {0x05, 0x00, 0x10},
426         {0x05, 0x00, 0x11},
427         {0x05, 0x00, 0x12},
428         {0x05, 0x6f, 0x00},
429         {0x05, initial_brightness >> 6, 0x00},
430         {0x05, (initial_brightness << 2) & 0xff, 0x01},
431         {0x05, 0x00, 0x02},
432         {0x05, 0x01, 0x03},
433         {0x05, 0x00, 0x04},
434         {0x05, 0x03, 0x05},
435         {0x05, 0xe0, 0x06},
436         {0x05, 0x20, 0x07},
437         {0x05, 0xa0, 0x08},
438         {0x05, 0x00, 0x12},
439         {0x05, 0x02, 0x0f},
440         {0x05, 0x80, 0x14},             /* max exposure off (0=on) */
441         {0x05, 0x01, 0xb0},
442         {0x05, 0x01, 0xbf},
443         {0x03, 0x02, 0x06},
444         {0x05, 0x10, 0x46},
445         {0x05, 0x08, 0x4a},
446
447         {0x06, 0x00, 0x01},
448         {0x06, 0x10, 0x02},
449         {0x06, 0x64, 0x07},
450         {0x06, 0x18, 0x08},
451         {0x06, 0xfc, 0x09},
452         {0x06, 0xfc, 0x0a},
453         {0x06, 0xfc, 0x0b},
454         {0x04, 0x00, 0x01},
455         {0x06, 0x18, 0x0c},
456         {0x06, 0xfc, 0x0d},
457         {0x06, 0xfc, 0x0e},
458         {0x06, 0xfc, 0x0f},
459         {0x06, 0x11, 0x10},             /* contrast */
460         {0x06, 0x00, 0x11},
461         {0x06, 0xfe, 0x12},
462         {0x06, 0x00, 0x13},
463         {0x06, 0x00, 0x14},
464         {0x06, 0x9d, 0x51},
465         {0x06, 0x40, 0x52},
466         {0x06, 0x7c, 0x53},
467         {0x06, 0x40, 0x54},
468         {0x06, 0x02, 0x57},
469         {0x06, 0x03, 0x58},
470         {0x06, 0x15, 0x59},
471         {0x06, 0x05, 0x5a},
472         {0x06, 0x03, 0x56},
473         {0x06, 0x02, 0x3f},
474         {0x06, 0x00, 0x40},
475         {0x06, 0x39, 0x41},
476         {0x06, 0x69, 0x42},
477         {0x06, 0x87, 0x43},
478         {0x06, 0x9e, 0x44},
479         {0x06, 0xb1, 0x45},
480         {0x06, 0xbf, 0x46},
481         {0x06, 0xcc, 0x47},
482         {0x06, 0xd5, 0x48},
483         {0x06, 0xdd, 0x49},
484         {0x06, 0xe3, 0x4a},
485         {0x06, 0xe8, 0x4b},
486         {0x06, 0xed, 0x4c},
487         {0x06, 0xf2, 0x4d},
488         {0x06, 0xf7, 0x4e},
489         {0x06, 0xfc, 0x4f},
490         {0x06, 0xff, 0x50},
491
492         {0x05, 0x01, 0xc0},
493         {0x05, 0x10, 0xcb},
494         {0x05, 0x40, 0xc1},
495         {0x05, 0x04, 0xc2},
496         {0x05, 0x00, 0xca},
497         {0x05, 0x40, 0xc1},
498         {0x05, 0x09, 0xc2},
499         {0x05, 0x00, 0xca},
500         {0x05, 0xc0, 0xc1},
501         {0x05, 0x09, 0xc2},
502         {0x05, 0x00, 0xca},
503         {0x05, 0x40, 0xc1},
504         {0x05, 0x59, 0xc2},
505         {0x05, 0x00, 0xca},
506         {0x04, 0x00, 0x01},
507         {0x05, 0x80, 0xc1},
508         {0x05, 0xec, 0xc2},
509         {0x05, 0x0, 0xca},
510
511         {0x06, 0x02, 0x57},
512         {0x06, 0x01, 0x58},
513         {0x06, 0x15, 0x59},
514         {0x06, 0x0a, 0x5a},
515         {0x06, 0x01, 0x57},
516         {0x06, 0x8a, 0x03},
517         {0x06, 0x0a, 0x6c},
518         {0x06, 0x30, 0x01},
519         {0x06, 0x20, 0x02},
520         {0x06, 0x00, 0x03},
521
522         {0x05, 0x8c, 0x25},
523
524         {0x06, 0x4d, 0x51},             /* maybe saturation (4d) */
525         {0x06, 0x84, 0x53},             /* making green (84) */
526         {0x06, 0x00, 0x57},             /* sharpness (1) */
527         {0x06, 0x18, 0x08},
528         {0x06, 0xfc, 0x09},
529         {0x06, 0xfc, 0x0a},
530         {0x06, 0xfc, 0x0b},
531         {0x06, 0x18, 0x0c},             /* maybe hue (18) */
532         {0x06, 0xfc, 0x0d},
533         {0x06, 0xfc, 0x0e},
534         {0x06, 0xfc, 0x0f},
535         {0x06, 0x18, 0x10},             /* maybe contrast (18) */
536
537         {0x05, 0x01, 0x02},
538
539         {0x04, 0x00, 0x08},             /* compression */
540         {0x04, 0x12, 0x09},
541         {0x04, 0x21, 0x0a},
542         {0x04, 0x10, 0x0b},
543         {0x04, 0x21, 0x0c},
544         {0x04, 0x1d, 0x00},             /* imagetype (1d) */
545         {0x04, 0x41, 0x01},             /* hardware snapcontrol */
546
547         {0x04, 0x00, 0x04},
548         {0x04, 0x00, 0x05},
549         {0x04, 0x10, 0x06},
550         {0x04, 0x10, 0x07},
551         {0x04, 0x40, 0x06},
552         {0x04, 0x40, 0x07},
553         {0x04, 0x00, 0x04},
554         {0x04, 0x00, 0x05},
555
556         {0x06, 0x1c, 0x17},
557         {0x06, 0xe2, 0x19},
558         {0x06, 0x1c, 0x1b},
559         {0x06, 0xe2, 0x1d},
560         {0x06, 0x5f, 0x1f},
561         {0x06, 0x32, 0x20},
562
563         {0x05, initial_brightness >> 6, 0x00},
564         {0x05, (initial_brightness << 2) & 0xff, 0x01},
565         {0x05, 0x06, 0xc1},
566         {0x05, 0x58, 0xc2},
567         {0x05, 0x00, 0xca},
568         {0x05, 0x00, 0x11},
569         {}
570 };
571
572 static int reg_write(struct usb_device *dev,
573                      u16 req, u16 index, u16 value)
574 {
575         int ret;
576
577         ret = usb_control_msg(dev,
578                         usb_sndctrlpipe(dev, 0),
579                         req,
580                         USB_TYPE_VENDOR | USB_RECIP_DEVICE,
581                         value, index, NULL, 0, 500);
582         PDEBUG(D_USBO, "reg write: 0x%02x,0x%02x:0x%02x, %d",
583                 req, index, value, ret);
584         if (ret < 0)
585                 PDEBUG(D_ERR, "reg write: error %d", ret);
586         return ret;
587 }
588
589 /* returns: negative is error, pos or zero is data */
590 static int reg_read(struct gspca_dev *gspca_dev,
591                         u16 req,        /* bRequest */
592                         u16 index)      /* wIndex */
593 {
594         int ret;
595
596         ret = usb_control_msg(gspca_dev->dev,
597                         usb_rcvctrlpipe(gspca_dev->dev, 0),
598                         req,
599                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
600                         0,                      /* value */
601                         index,
602                         gspca_dev->usb_buf, 2,
603                         500);                   /* timeout */
604         if (ret < 0)
605                 return ret;
606         return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
607 }
608
609 static int write_vector(struct gspca_dev *gspca_dev,
610                         const u8 data[][3])
611 {
612         struct usb_device *dev = gspca_dev->dev;
613         int ret, i = 0;
614
615         while (data[i][0] != 0) {
616                 ret = reg_write(dev, data[i][0], data[i][2], data[i][1]);
617                 if (ret < 0)
618                         return ret;
619                 i++;
620         }
621         return 0;
622 }
623
624 /* this function is called at probe time */
625 static int sd_config(struct gspca_dev *gspca_dev,
626                         const struct usb_device_id *id)
627 {
628         struct sd *sd = (struct sd *) gspca_dev;
629         struct cam *cam;
630
631         cam = &gspca_dev->cam;
632         cam->cam_mode = vga_mode;
633         sd->subtype = id->driver_info;
634         if (sd->subtype != IntelPCCameraPro)
635                 cam->nmodes = ARRAY_SIZE(vga_mode);
636         else                    /* no 640x480 for IntelPCCameraPro */
637                 cam->nmodes = ARRAY_SIZE(vga_mode) - 1;
638         sd->brightness = BRIGHTNESS_DEF;
639
640         return 0;
641 }
642
643 /* this function is called at probe and resume time */
644 static int sd_init(struct gspca_dev *gspca_dev)
645 {
646         struct sd *sd = (struct sd *) gspca_dev;
647
648         if (write_vector(gspca_dev,
649                          sd->subtype == Nxultra
650                                 ? spca505b_init_data
651                                 : spca505_init_data))
652                 return -EIO;
653         return 0;
654 }
655
656 static void setbrightness(struct gspca_dev *gspca_dev)
657 {
658         struct sd *sd = (struct sd *) gspca_dev;
659         u8 brightness = sd->brightness;
660
661         reg_write(gspca_dev->dev, 0x05, 0x00, (255 - brightness) >> 6);
662         reg_write(gspca_dev->dev, 0x05, 0x01, (255 - brightness) << 2);
663 }
664
665 static int sd_start(struct gspca_dev *gspca_dev)
666 {
667         struct sd *sd = (struct sd *) gspca_dev;
668         struct usb_device *dev = gspca_dev->dev;
669         int ret, mode;
670         static u8 mode_tb[][3] = {
671         /*        r00   r06   r07       */
672                 {0x00, 0x10, 0x10},     /* 640x480 */
673                 {0x01, 0x1a, 0x1a},     /* 352x288 */
674                 {0x02, 0x1c, 0x1d},     /* 320x240 */
675                 {0x04, 0x34, 0x34},     /* 176x144 */
676                 {0x05, 0x40, 0x40}      /* 160x120 */
677         };
678
679         if (sd->subtype == Nxultra)
680                 write_vector(gspca_dev, spca505b_open_data_ccd);
681         else
682                 write_vector(gspca_dev, spca505_open_data_ccd);
683         ret = reg_read(gspca_dev, 0x06, 0x16);
684
685         if (ret < 0) {
686                 PDEBUG(D_ERR|D_CONF,
687                        "register read failed err: %d",
688                        ret);
689                 return ret;
690         }
691         if (ret != 0x0101) {
692                 PDEBUG(D_ERR|D_CONF,
693                         "After vector read returns 0x%04x should be 0x0101",
694                         ret);
695         }
696
697         ret = reg_write(gspca_dev->dev, 0x06, 0x16, 0x0a);
698         if (ret < 0)
699                 return ret;
700         reg_write(gspca_dev->dev, 0x05, 0xc2, 0x12);
701
702         /* necessary because without it we can see stream
703          * only once after loading module */
704         /* stopping usb registers Tomasz change */
705         reg_write(dev, 0x02, 0x00, 0x00);
706
707         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
708         reg_write(dev, SPCA50X_REG_COMPRESS, 0x00, mode_tb[mode][0]);
709         reg_write(dev, SPCA50X_REG_COMPRESS, 0x06, mode_tb[mode][1]);
710         reg_write(dev, SPCA50X_REG_COMPRESS, 0x07, mode_tb[mode][2]);
711
712         ret = reg_write(dev, SPCA50X_REG_USB,
713                          SPCA50X_USB_CTRL,
714                          SPCA50X_CUSB_ENABLE);
715
716         setbrightness(gspca_dev);
717
718         return ret;
719 }
720
721 static void sd_stopN(struct gspca_dev *gspca_dev)
722 {
723         /* Disable ISO packet machine */
724         reg_write(gspca_dev->dev, 0x02, 0x00, 0x00);
725 }
726
727 /* called on streamoff with alt 0 and on disconnect */
728 static void sd_stop0(struct gspca_dev *gspca_dev)
729 {
730         if (!gspca_dev->present)
731                 return;
732
733         /* This maybe reset or power control */
734         reg_write(gspca_dev->dev, 0x03, 0x03, 0x20);
735         reg_write(gspca_dev->dev, 0x03, 0x01, 0x00);
736         reg_write(gspca_dev->dev, 0x03, 0x00, 0x01);
737         reg_write(gspca_dev->dev, 0x05, 0x10, 0x01);
738         reg_write(gspca_dev->dev, 0x05, 0x11, 0x0f);
739 }
740
741 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
742                         struct gspca_frame *frame,      /* target */
743                         u8 *data,                       /* isoc packet */
744                         int len)                        /* iso packet length */
745 {
746         switch (data[0]) {
747         case 0:                         /* start of frame */
748                 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
749                                         data, 0);
750                 data += SPCA50X_OFFSET_DATA;
751                 len -= SPCA50X_OFFSET_DATA;
752                 gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
753                                 data, len);
754                 break;
755         case 0xff:                      /* drop */
756                 break;
757         default:
758                 data += 1;
759                 len -= 1;
760                 gspca_frame_add(gspca_dev, INTER_PACKET, frame,
761                                 data, len);
762                 break;
763         }
764 }
765
766 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
767 {
768         struct sd *sd = (struct sd *) gspca_dev;
769
770         sd->brightness = val;
771         if (gspca_dev->streaming)
772                 setbrightness(gspca_dev);
773         return 0;
774 }
775
776 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
777 {
778         struct sd *sd = (struct sd *) gspca_dev;
779
780         *val = sd->brightness;
781         return 0;
782 }
783
784 /* sub-driver description */
785 static const struct sd_desc sd_desc = {
786         .name = MODULE_NAME,
787         .ctrls = sd_ctrls,
788         .nctrls = ARRAY_SIZE(sd_ctrls),
789         .config = sd_config,
790         .init = sd_init,
791         .start = sd_start,
792         .stopN = sd_stopN,
793         .stop0 = sd_stop0,
794         .pkt_scan = sd_pkt_scan,
795 };
796
797 /* -- module initialisation -- */
798 static const __devinitdata struct usb_device_id device_table[] = {
799         {USB_DEVICE(0x041e, 0x401d), .driver_info = Nxultra},
800         {USB_DEVICE(0x0733, 0x0430), .driver_info = IntelPCCameraPro},
801 /*fixme: may be UsbGrabberPV321 BRIDGE_SPCA506 SENSOR_SAA7113 */
802         {}
803 };
804 MODULE_DEVICE_TABLE(usb, device_table);
805
806 /* -- device connect -- */
807 static int sd_probe(struct usb_interface *intf,
808                         const struct usb_device_id *id)
809 {
810         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
811                                 THIS_MODULE);
812 }
813
814 static struct usb_driver sd_driver = {
815         .name = MODULE_NAME,
816         .id_table = device_table,
817         .probe = sd_probe,
818         .disconnect = gspca_disconnect,
819 #ifdef CONFIG_PM
820         .suspend = gspca_suspend,
821         .resume = gspca_resume,
822 #endif
823 };
824
825 /* -- module insert / remove -- */
826 static int __init sd_mod_init(void)
827 {
828         int ret;
829
830         ret = usb_register(&sd_driver);
831         if (ret < 0)
832                 return ret;
833         PDEBUG(D_PROBE, "registered");
834         return 0;
835 }
836 static void __exit sd_mod_exit(void)
837 {
838         usb_deregister(&sd_driver);
839         PDEBUG(D_PROBE, "deregistered");
840 }
841
842 module_init(sd_mod_init);
843 module_exit(sd_mod_exit);