?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.34-rc3
[pohmelfs.git] / drivers / media / video / gspca / sunplus.c
blob0c786e00ebcf39e758bb60f29f73f82f826fadc4
1 /*
2 * Sunplus spca504(abc) spca533 spca536 library
3 * Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
4 *
5 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #define MODULE_NAME "sunplus"
23
24 #include "gspca.h"
25 #include "jpeg.h"
26
27 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
28 MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver");
29 MODULE_LICENSE("GPL");
30
31 /* specific webcam descriptor */
32 struct sd {
33 struct gspca_dev gspca_dev; /* !! must be the first item */
34
35 s8 brightness;
36 u8 contrast;
37 u8 colors;
38 u8 autogain;
39 u8 quality;
40 #define QUALITY_MIN 70
41 #define QUALITY_MAX 95
42 #define QUALITY_DEF 85
43
44 u8 bridge;
45 #define BRIDGE_SPCA504 0
46 #define BRIDGE_SPCA504B 1
47 #define BRIDGE_SPCA504C 2
48 #define BRIDGE_SPCA533 3
49 #define BRIDGE_SPCA536 4
50 u8 subtype;
51 #define AiptekMiniPenCam13 1
52 #define LogitechClickSmart420 2
53 #define LogitechClickSmart820 3
54 #define MegapixV4 4
55 #define MegaImageVI 5
56
57 u8 *jpeg_hdr;
58 };
59
60 /* V4L2 controls supported by the driver */
61 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
62 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
63 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
64 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
65 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
66 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
67 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
68 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
69
70 static const struct ctrl sd_ctrls[] = {
71 {
72 {
73 .id = V4L2_CID_BRIGHTNESS,
74 .type = V4L2_CTRL_TYPE_INTEGER,
75 .name = "Brightness",
76 .minimum = -128,
77 .maximum = 127,
78 .step = 1,
79 #define BRIGHTNESS_DEF 0
80 .default_value = BRIGHTNESS_DEF,
81 },
82 .set = sd_setbrightness,
83 .get = sd_getbrightness,
84 },
85 {
86 {
87 .id = V4L2_CID_CONTRAST,
88 .type = V4L2_CTRL_TYPE_INTEGER,
89 .name = "Contrast",
90 .minimum = 0,
91 .maximum = 0xff,
92 .step = 1,
93 #define CONTRAST_DEF 0x20
94 .default_value = CONTRAST_DEF,
95 },
96 .set = sd_setcontrast,
97 .get = sd_getcontrast,
98 },
99 {
100 {
101 .id = V4L2_CID_SATURATION,
102 .type = V4L2_CTRL_TYPE_INTEGER,
103 .name = "Color",
104 .minimum = 0,
105 .maximum = 0xff,
106 .step = 1,
107 #define COLOR_DEF 0x1a
108 .default_value = COLOR_DEF,
109 },
110 .set = sd_setcolors,
111 .get = sd_getcolors,
112 },
113 {
114 {
115 .id = V4L2_CID_AUTOGAIN,
116 .type = V4L2_CTRL_TYPE_BOOLEAN,
117 .name = "Auto Gain",
118 .minimum = 0,
119 .maximum = 1,
120 .step = 1,
121 #define AUTOGAIN_DEF 1
122 .default_value = AUTOGAIN_DEF,
123 },
124 .set = sd_setautogain,
125 .get = sd_getautogain,
126 },
127 };
128
129 static const struct v4l2_pix_format vga_mode[] = {
130 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
131 .bytesperline = 320,
132 .sizeimage = 320 * 240 * 3 / 8 + 590,
133 .colorspace = V4L2_COLORSPACE_JPEG,
134 .priv = 2},
135 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
136 .bytesperline = 640,
137 .sizeimage = 640 * 480 * 3 / 8 + 590,
138 .colorspace = V4L2_COLORSPACE_JPEG,
139 .priv = 1},
140 };
141
142 static const struct v4l2_pix_format custom_mode[] = {
143 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
144 .bytesperline = 320,
145 .sizeimage = 320 * 240 * 3 / 8 + 590,
146 .colorspace = V4L2_COLORSPACE_JPEG,
147 .priv = 2},
148 {464, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
149 .bytesperline = 464,
150 .sizeimage = 464 * 480 * 3 / 8 + 590,
151 .colorspace = V4L2_COLORSPACE_JPEG,
152 .priv = 1},
153 };
154
155 static const struct v4l2_pix_format vga_mode2[] = {
156 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
157 .bytesperline = 176,
158 .sizeimage = 176 * 144 * 3 / 8 + 590,
159 .colorspace = V4L2_COLORSPACE_JPEG,
160 .priv = 4},
161 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
162 .bytesperline = 320,
163 .sizeimage = 320 * 240 * 3 / 8 + 590,
164 .colorspace = V4L2_COLORSPACE_JPEG,
165 .priv = 3},
166 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
167 .bytesperline = 352,
168 .sizeimage = 352 * 288 * 3 / 8 + 590,
169 .colorspace = V4L2_COLORSPACE_JPEG,
170 .priv = 2},
171 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
172 .bytesperline = 640,
173 .sizeimage = 640 * 480 * 3 / 8 + 590,
174 .colorspace = V4L2_COLORSPACE_JPEG,
175 .priv = 1},
176 };
177
178 #define SPCA50X_OFFSET_DATA 10
179 #define SPCA504_PCCAM600_OFFSET_SNAPSHOT 3
180 #define SPCA504_PCCAM600_OFFSET_COMPRESS 4
181 #define SPCA504_PCCAM600_OFFSET_MODE 5
182 #define SPCA504_PCCAM600_OFFSET_DATA 14
183 /* Frame packet header offsets for the spca533 */
184 #define SPCA533_OFFSET_DATA 16
185 #define SPCA533_OFFSET_FRAMSEQ 15
186 /* Frame packet header offsets for the spca536 */
187 #define SPCA536_OFFSET_DATA 4
188 #define SPCA536_OFFSET_FRAMSEQ 1
189
190 struct cmd {
191 u8 req;
192 u16 val;
193 u16 idx;
194 };
195
196 /* Initialisation data for the Creative PC-CAM 600 */
197 static const struct cmd spca504_pccam600_init_data[] = {
198 /* {0xa0, 0x0000, 0x0503}, * capture mode */
199 {0x00, 0x0000, 0x2000},
200 {0x00, 0x0013, 0x2301},
201 {0x00, 0x0003, 0x2000},
202 {0x00, 0x0001, 0x21ac},
203 {0x00, 0x0001, 0x21a6},
204 {0x00, 0x0000, 0x21a7}, /* brightness */
205 {0x00, 0x0020, 0x21a8}, /* contrast */
206 {0x00, 0x0001, 0x21ac}, /* sat/hue */
207 {0x00, 0x0000, 0x21ad}, /* hue */
208 {0x00, 0x001a, 0x21ae}, /* saturation */
209 {0x00, 0x0002, 0x21a3}, /* gamma */
210 {0x30, 0x0154, 0x0008},
211 {0x30, 0x0004, 0x0006},
212 {0x30, 0x0258, 0x0009},
213 {0x30, 0x0004, 0x0000},
214 {0x30, 0x0093, 0x0004},
215 {0x30, 0x0066, 0x0005},
216 {0x00, 0x0000, 0x2000},
217 {0x00, 0x0013, 0x2301},
218 {0x00, 0x0003, 0x2000},
219 {0x00, 0x0013, 0x2301},
220 {0x00, 0x0003, 0x2000},
221 };
222
223 /* Creative PC-CAM 600 specific open data, sent before using the
224 * generic initialisation data from spca504_open_data.
225 */
226 static const struct cmd spca504_pccam600_open_data[] = {
227 {0x00, 0x0001, 0x2501},
228 {0x20, 0x0500, 0x0001}, /* snapshot mode */
229 {0x00, 0x0003, 0x2880},
230 {0x00, 0x0001, 0x2881},
231 };
232
233 /* Initialisation data for the logitech clicksmart 420 */
234 static const struct cmd spca504A_clicksmart420_init_data[] = {
235 /* {0xa0, 0x0000, 0x0503}, * capture mode */
236 {0x00, 0x0000, 0x2000},
237 {0x00, 0x0013, 0x2301},
238 {0x00, 0x0003, 0x2000},
239 {0x00, 0x0001, 0x21ac},
240 {0x00, 0x0001, 0x21a6},
241 {0x00, 0x0000, 0x21a7}, /* brightness */
242 {0x00, 0x0020, 0x21a8}, /* contrast */
243 {0x00, 0x0001, 0x21ac}, /* sat/hue */
244 {0x00, 0x0000, 0x21ad}, /* hue */
245 {0x00, 0x001a, 0x21ae}, /* saturation */
246 {0x00, 0x0002, 0x21a3}, /* gamma */
247 {0x30, 0x0004, 0x000a},
248 {0xb0, 0x0001, 0x0000},
249
250
251 {0xa1, 0x0080, 0x0001},
252 {0x30, 0x0049, 0x0000},
253 {0x30, 0x0060, 0x0005},
254 {0x0c, 0x0004, 0x0000},
255 {0x00, 0x0000, 0x0000},
256 {0x00, 0x0000, 0x2000},
257 {0x00, 0x0013, 0x2301},
258 {0x00, 0x0003, 0x2000},
259 {0x00, 0x0000, 0x2000},
260
261 };
262
263 /* clicksmart 420 open data ? */
264 static const struct cmd spca504A_clicksmart420_open_data[] = {
265 {0x00, 0x0001, 0x2501},
266 {0x20, 0x0502, 0x0000},
267 {0x06, 0x0000, 0x0000},
268 {0x00, 0x0004, 0x2880},
269 {0x00, 0x0001, 0x2881},
270
271 {0xa0, 0x0000, 0x0503},
272 };
273
274 static const u8 qtable_creative_pccam[2][64] = {
275 { /* Q-table Y-components */
276 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
277 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
278 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
279 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
280 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
281 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
282 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
283 0x16, 0x1c, 0x1d, 0x1d, 0x22, 0x1e, 0x1f, 0x1e},
284 { /* Q-table C-components */
285 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
286 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
287 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
288 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
289 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
290 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
291 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
292 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
293 };
294
295 /* FIXME: This Q-table is identical to the Creative PC-CAM one,
296 * except for one byte. Possibly a typo?
297 * NWG: 18/05/2003.
298 */
299 static const u8 qtable_spca504_default[2][64] = {
300 { /* Q-table Y-components */
301 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
302 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
303 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
304 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
305 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
306 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
307 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
308 0x16, 0x1c, 0x1d, 0x1d, 0x1d /* 0x22 */ , 0x1e, 0x1f, 0x1e,
309 },
310 { /* Q-table C-components */
311 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
312 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
313 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
314 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
315 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
316 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
317 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
318 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
319 };
320
321 /* read <len> bytes to gspca_dev->usb_buf */
322 static void reg_r(struct gspca_dev *gspca_dev,
323 u8 req,
324 u16 index,
325 u16 len)
326 {
327 int ret;
328
329 #ifdef GSPCA_DEBUG
330 if (len > USB_BUF_SZ) {
331 err("reg_r: buffer overflow");
332 return;
333 }
334 #endif
335 if (gspca_dev->usb_err < 0)
336 return;
337 ret = usb_control_msg(gspca_dev->dev,
338 usb_rcvctrlpipe(gspca_dev->dev, 0),
339 req,
340 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
341 0, /* value */
342 index,
343 len ? gspca_dev->usb_buf : NULL, len,
344 500);
345 if (ret < 0) {
346 PDEBUG(D_ERR, "reg_r err %d", ret);
347 gspca_dev->usb_err = ret;
348 }
349 }
350
351 /* write one byte */
352 static void reg_w_1(struct gspca_dev *gspca_dev,
353 u8 req,
354 u16 value,
355 u16 index,
356 u16 byte)
357 {
358 int ret;
359
360 if (gspca_dev->usb_err < 0)
361 return;
362 gspca_dev->usb_buf[0] = byte;
363 ret = usb_control_msg(gspca_dev->dev,
364 usb_sndctrlpipe(gspca_dev->dev, 0),
365 req,
366 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
367 value, index,
368 gspca_dev->usb_buf, 1,
369 500);
370 if (ret < 0) {
371 PDEBUG(D_ERR, "reg_w_1 err %d", ret);
372 gspca_dev->usb_err = ret;
373 }
374 }
375
376 /* write req / index / value */
377 static void reg_w_riv(struct gspca_dev *gspca_dev,
378 u8 req, u16 index, u16 value)
379 {
380 struct usb_device *dev = gspca_dev->dev;
381 int ret;
382
383 if (gspca_dev->usb_err < 0)
384 return;
385 ret = usb_control_msg(dev,
386 usb_sndctrlpipe(dev, 0),
387 req,
388 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
389 value, index, NULL, 0, 500);
390 if (ret < 0) {
391 PDEBUG(D_ERR, "reg_w_riv err %d", ret);
392 gspca_dev->usb_err = ret;
393 return;
394 }
395 PDEBUG(D_USBO, "reg_w_riv: 0x%02x,0x%04x:0x%04x",
396 req, index, value);
397 }
398
399 /* read 1 byte */
400 static u8 reg_r_1(struct gspca_dev *gspca_dev,
401 u16 value) /* wValue */
402 {
403 int ret;
404
405 if (gspca_dev->usb_err < 0)
406 return 0;
407 ret = usb_control_msg(gspca_dev->dev,
408 usb_rcvctrlpipe(gspca_dev->dev, 0),
409 0x20, /* request */
410 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
411 value,
412 0, /* index */
413 gspca_dev->usb_buf, 1,
414 500); /* timeout */
415 if (ret < 0) {
416 PDEBUG(D_ERR, "reg_r_1 err %d", ret);
417 gspca_dev->usb_err = ret;
418 return 0;
419 }
420 return gspca_dev->usb_buf[0];
421 }
422
423 /* read 1 or 2 bytes */
424 static u16 reg_r_12(struct gspca_dev *gspca_dev,
425 u8 req, /* bRequest */
426 u16 index, /* wIndex */
427 u16 length) /* wLength (1 or 2 only) */
428 {
429 int ret;
430
431 if (gspca_dev->usb_err < 0)
432 return 0;
433 gspca_dev->usb_buf[1] = 0;
434 ret = usb_control_msg(gspca_dev->dev,
435 usb_rcvctrlpipe(gspca_dev->dev, 0),
436 req,
437 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
438 0, /* value */
439 index,
440 gspca_dev->usb_buf, length,
441 500);
442 if (ret < 0) {
443 PDEBUG(D_ERR, "reg_r_12 err %d", ret);
444 gspca_dev->usb_err = ret;
445 return 0;
446 }
447 return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
448 }
449
450 static void write_vector(struct gspca_dev *gspca_dev,
451 const struct cmd *data, int ncmds)
452 {
453 while (--ncmds >= 0) {
454 reg_w_riv(gspca_dev, data->req, data->idx, data->val);
455 data++;
456 }
457 }
458
459 static void setup_qtable(struct gspca_dev *gspca_dev,
460 const u8 qtable[2][64])
461 {
462 int i;
463
464 /* loop over y components */
465 for (i = 0; i < 64; i++)
466 reg_w_riv(gspca_dev, 0x00, 0x2800 + i, qtable[0][i]);
467
468 /* loop over c components */
469 for (i = 0; i < 64; i++)
470 reg_w_riv(gspca_dev, 0x00, 0x2840 + i, qtable[1][i]);
471 }
472
473 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
474 u8 req, u16 idx, u16 val)
475 {
476 u16 notdone;
477
478 reg_w_riv(gspca_dev, req, idx, val);
479 notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
480 reg_w_riv(gspca_dev, req, idx, val);
481
482 PDEBUG(D_FRAM, "before wait 0x%04x", notdone);
483
484 msleep(200);
485 notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
486 PDEBUG(D_FRAM, "after wait 0x%04x", notdone);
487 }
488
489 static void spca504_read_info(struct gspca_dev *gspca_dev)
490 {
491 int i;
492 u8 info[6];
493
494 for (i = 0; i < 6; i++)
495 info[i] = reg_r_1(gspca_dev, i);
496 PDEBUG(D_STREAM,
497 "Read info: %d %d %d %d %d %d."
498 " Should be 1,0,2,2,0,0",
499 info[0], info[1], info[2],
500 info[3], info[4], info[5]);
501 }
502
503 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
504 u8 req,
505 u16 idx, u16 val, u16 endcode, u8 count)
506 {
507 u16 status;
508
509 reg_w_riv(gspca_dev, req, idx, val);
510 status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
511 if (gspca_dev->usb_err < 0)
512 return;
513 PDEBUG(D_FRAM, "Status 0x%04x Need 0x%04x", status, endcode);
514 if (!count)
515 return;
516 count = 200;
517 while (--count > 0) {
518 msleep(10);
519 /* gsmart mini2 write a each wait setting 1 ms is enough */
520 /* reg_w_riv(gspca_dev, req, idx, val); */
521 status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
522 if (status == endcode) {
523 PDEBUG(D_FRAM, "status 0x%04x after wait %d",
524 status, 200 - count);
525 break;
526 }
527 }
528 }
529
530 static void spca504B_PollingDataReady(struct gspca_dev *gspca_dev)
531 {
532 int count = 10;
533
534 while (--count > 0) {
535 reg_r(gspca_dev, 0x21, 0, 1);
536 if ((gspca_dev->usb_buf[0] & 0x01) == 0)
537 break;
538 msleep(10);
539 }
540 }
541
542 static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
543 {
544 int count = 50;
545
546 while (--count > 0) {
547 reg_r(gspca_dev, 0x21, 1, 1);
548 if (gspca_dev->usb_buf[0] != 0) {
549 reg_w_1(gspca_dev, 0x21, 0, 1, 0);
550 reg_r(gspca_dev, 0x21, 1, 1);
551 spca504B_PollingDataReady(gspca_dev);
552 break;
553 }
554 msleep(10);
555 }
556 }
557
558 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
559 {
560 u8 *data;
561
562 data = gspca_dev->usb_buf;
563 reg_r(gspca_dev, 0x20, 0, 5);
564 PDEBUG(D_STREAM, "FirmWare : %d %d %d %d %d ",
565 data[0], data[1], data[2], data[3], data[4]);
566 reg_r(gspca_dev, 0x23, 0, 64);
567 reg_r(gspca_dev, 0x23, 1, 64);
568 }
569
570 static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
571 {
572 struct sd *sd = (struct sd *) gspca_dev;
573 u8 Size;
574
575 Size = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
576 switch (sd->bridge) {
577 case BRIDGE_SPCA533:
578 reg_w_riv(gspca_dev, 0x31, 0, 0);
579 spca504B_WaitCmdStatus(gspca_dev);
580 spca504B_PollingDataReady(gspca_dev);
581 spca50x_GetFirmware(gspca_dev);
582 reg_w_1(gspca_dev, 0x24, 0, 8, 2); /* type */
583 reg_r(gspca_dev, 0x24, 8, 1);
584
585 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
586 reg_r(gspca_dev, 0x25, 4, 1); /* size */
587 spca504B_PollingDataReady(gspca_dev);
588
589 /* Init the cam width height with some values get on init ? */
590 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00);
591 spca504B_WaitCmdStatus(gspca_dev);
592 spca504B_PollingDataReady(gspca_dev);
593 break;
594 default:
595 /* case BRIDGE_SPCA504B: */
596 /* case BRIDGE_SPCA536: */
597 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
598 reg_r(gspca_dev, 0x25, 4, 1); /* size */
599 reg_w_1(gspca_dev, 0x27, 0, 0, 6);
600 reg_r(gspca_dev, 0x27, 0, 1); /* type */
601 spca504B_PollingDataReady(gspca_dev);
602 break;
603 case BRIDGE_SPCA504:
604 Size += 3;
605 if (sd->subtype == AiptekMiniPenCam13) {
606 /* spca504a aiptek */
607 spca504A_acknowledged_command(gspca_dev,
608 0x08, Size, 0,
609 0x80 | (Size & 0x0f), 1);
610 spca504A_acknowledged_command(gspca_dev,
611 1, 3, 0, 0x9f, 0);
612 } else {
613 spca504_acknowledged_command(gspca_dev, 0x08, Size, 0);
614 }
615 break;
616 case BRIDGE_SPCA504C:
617 /* capture mode */
618 reg_w_riv(gspca_dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x00);
619 reg_w_riv(gspca_dev, 0x20, 0x01, 0x0500 | (Size & 0x0f));
620 break;
621 }
622 }
623
624 static void spca504_wait_status(struct gspca_dev *gspca_dev)
625 {
626 int cnt;
627
628 cnt = 256;
629 while (--cnt > 0) {
630 /* With this we get the status, when return 0 it's all ok */
631 if (reg_r_12(gspca_dev, 0x06, 0x00, 1) == 0)
632 return;
633 msleep(10);
634 }
635 }
636
637 static void spca504B_setQtable(struct gspca_dev *gspca_dev)
638 {
639 reg_w_1(gspca_dev, 0x26, 0, 0, 3);
640 reg_r(gspca_dev, 0x26, 0, 1);
641 spca504B_PollingDataReady(gspca_dev);
642 }
643
644 static void setbrightness(struct gspca_dev *gspca_dev)
645 {
646 struct sd *sd = (struct sd *) gspca_dev;
647 u16 reg;
648
649 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f0 : 0x21a7;
650 reg_w_riv(gspca_dev, 0x00, reg, sd->brightness);
651 }
652
653 static void setcontrast(struct gspca_dev *gspca_dev)
654 {
655 struct sd *sd = (struct sd *) gspca_dev;
656 u16 reg;
657
658 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f1 : 0x21a8;
659 reg_w_riv(gspca_dev, 0x00, reg, sd->contrast);
660 }
661
662 static void setcolors(struct gspca_dev *gspca_dev)
663 {
664 struct sd *sd = (struct sd *) gspca_dev;
665 u16 reg;
666
667 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f6 : 0x21ae;
668 reg_w_riv(gspca_dev, 0x00, reg, sd->colors);
669 }
670
671 static void init_ctl_reg(struct gspca_dev *gspca_dev)
672 {
673 struct sd *sd = (struct sd *) gspca_dev;
674 int pollreg = 1;
675
676 setbrightness(gspca_dev);
677 setcontrast(gspca_dev);
678 setcolors(gspca_dev);
679
680 switch (sd->bridge) {
681 case BRIDGE_SPCA504:
682 case BRIDGE_SPCA504C:
683 pollreg = 0;
684 /* fall thru */
685 default:
686 /* case BRIDGE_SPCA533: */
687 /* case BRIDGE_SPCA504B: */
688 reg_w_riv(gspca_dev, 0, 0x21ad, 0x00); /* hue */
689 reg_w_riv(gspca_dev, 0, 0x21ac, 0x01); /* sat/hue */
690 reg_w_riv(gspca_dev, 0, 0x21a3, 0x00); /* gamma */
691 break;
692 case BRIDGE_SPCA536:
693 reg_w_riv(gspca_dev, 0, 0x20f5, 0x40);
694 reg_w_riv(gspca_dev, 0, 0x20f4, 0x01);
695 reg_w_riv(gspca_dev, 0, 0x2089, 0x00);
696 break;
697 }
698 if (pollreg)
699 spca504B_PollingDataReady(gspca_dev);
700 }
701
702 /* this function is called at probe time */
703 static int sd_config(struct gspca_dev *gspca_dev,
704 const struct usb_device_id *id)
705 {
706 struct sd *sd = (struct sd *) gspca_dev;
707 struct cam *cam;
708
709 cam = &gspca_dev->cam;
710
711 sd->bridge = id->driver_info >> 8;
712 sd->subtype = id->driver_info;
713
714 if (sd->subtype == AiptekMiniPenCam13) {
715 /* try to get the firmware as some cam answer 2.0.1.2.2
716 * and should be a spca504b then overwrite that setting */
717 reg_r(gspca_dev, 0x20, 0, 1);
718 switch (gspca_dev->usb_buf[0]) {
719 case 1:
720 break; /* (right bridge/subtype) */
721 case 2:
722 sd->bridge = BRIDGE_SPCA504B;
723 sd->subtype = 0;
724 break;
725 default:
726 return -ENODEV;
727 }
728 }
729
730 switch (sd->bridge) {
731 default:
732 /* case BRIDGE_SPCA504B: */
733 /* case BRIDGE_SPCA504: */
734 /* case BRIDGE_SPCA536: */
735 cam->cam_mode = vga_mode;
736 cam->nmodes =ARRAY_SIZE(vga_mode);
737 break;
738 case BRIDGE_SPCA533:
739 cam->cam_mode = custom_mode;
740 if (sd->subtype == MegaImageVI) /* 320x240 only */
741 cam->nmodes = ARRAY_SIZE(custom_mode) - 1;
742 else
743 cam->nmodes = ARRAY_SIZE(custom_mode);
744 break;
745 case BRIDGE_SPCA504C:
746 cam->cam_mode = vga_mode2;
747 cam->nmodes = ARRAY_SIZE(vga_mode2);
748 break;
749 }
750 sd->brightness = BRIGHTNESS_DEF;
751 sd->contrast = CONTRAST_DEF;
752 sd->colors = COLOR_DEF;
753 sd->autogain = AUTOGAIN_DEF;
754 sd->quality = QUALITY_DEF;
755 return 0;
756 }
757
758 /* this function is called at probe and resume time */
759 static int sd_init(struct gspca_dev *gspca_dev)
760 {
761 struct sd *sd = (struct sd *) gspca_dev;
762
763 switch (sd->bridge) {
764 case BRIDGE_SPCA504B:
765 reg_w_riv(gspca_dev, 0x1d, 0x00, 0);
766 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x01);
767 reg_w_riv(gspca_dev, 0x00, 0x0d04, 0x00);
768 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x00);
769 reg_w_riv(gspca_dev, 0x00, 0x2301, 0x13);
770 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x00);
771 /* fall thru */
772 case BRIDGE_SPCA533:
773 spca504B_PollingDataReady(gspca_dev);
774 spca50x_GetFirmware(gspca_dev);
775 break;
776 case BRIDGE_SPCA536:
777 spca50x_GetFirmware(gspca_dev);
778 reg_r(gspca_dev, 0x00, 0x5002, 1);
779 reg_w_1(gspca_dev, 0x24, 0, 0, 0);
780 reg_r(gspca_dev, 0x24, 0, 1);
781 spca504B_PollingDataReady(gspca_dev);
782 reg_w_riv(gspca_dev, 0x34, 0, 0);
783 spca504B_WaitCmdStatus(gspca_dev);
784 break;
785 case BRIDGE_SPCA504C: /* pccam600 */
786 PDEBUG(D_STREAM, "Opening SPCA504 (PC-CAM 600)");
787 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0000);
788 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0001); /* reset */
789 spca504_wait_status(gspca_dev);
790 if (sd->subtype == LogitechClickSmart420)
791 write_vector(gspca_dev,
792 spca504A_clicksmart420_open_data,
793 ARRAY_SIZE(spca504A_clicksmart420_open_data));
794 else
795 write_vector(gspca_dev, spca504_pccam600_open_data,
796 ARRAY_SIZE(spca504_pccam600_open_data));
797 setup_qtable(gspca_dev, qtable_creative_pccam);
798 break;
799 default:
800 /* case BRIDGE_SPCA504: */
801 PDEBUG(D_STREAM, "Opening SPCA504");
802 if (sd->subtype == AiptekMiniPenCam13) {
803 spca504_read_info(gspca_dev);
804
805 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
806 spca504A_acknowledged_command(gspca_dev, 0x24,
807 8, 3, 0x9e, 1);
808 /* Twice sequencial need status 0xff->0x9e->0x9d */
809 spca504A_acknowledged_command(gspca_dev, 0x24,
810 8, 3, 0x9e, 0);
811
812 spca504A_acknowledged_command(gspca_dev, 0x24,
813 0, 0, 0x9d, 1);
814 /******************************/
815 /* spca504a aiptek */
816 spca504A_acknowledged_command(gspca_dev, 0x08,
817 6, 0, 0x86, 1);
818 /* reg_write (dev, 0, 0x2000, 0); */
819 /* reg_write (dev, 0, 0x2883, 1); */
820 /* spca504A_acknowledged_command (gspca_dev, 0x08,
821 6, 0, 0x86, 1); */
822 /* spca504A_acknowledged_command (gspca_dev, 0x24,
823 0, 0, 0x9D, 1); */
824 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05);
825 /* L92 sno1t.txt */
826 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05);
827 spca504A_acknowledged_command(gspca_dev, 0x01,
828 0x0f, 0, 0xff, 0);
829 }
830 /* setup qtable */
831 reg_w_riv(gspca_dev, 0, 0x2000, 0);
832 reg_w_riv(gspca_dev, 0, 0x2883, 1);
833 setup_qtable(gspca_dev, qtable_spca504_default);
834 break;
835 }
836 return gspca_dev->usb_err;
837 }
838
839 static int sd_start(struct gspca_dev *gspca_dev)
840 {
841 struct sd *sd = (struct sd *) gspca_dev;
842 int enable;
843
844 /* create the JPEG header */
845 sd->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
846 if (!sd->jpeg_hdr)
847 return -ENOMEM;
848 jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
849 0x22); /* JPEG 411 */
850 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
851
852 if (sd->bridge == BRIDGE_SPCA504B)
853 spca504B_setQtable(gspca_dev);
854 spca504B_SetSizeType(gspca_dev);
855 switch (sd->bridge) {
856 default:
857 /* case BRIDGE_SPCA504B: */
858 /* case BRIDGE_SPCA533: */
859 /* case BRIDGE_SPCA536: */
860 switch (sd->subtype) {
861 case MegapixV4:
862 case LogitechClickSmart820:
863 case MegaImageVI:
864 reg_w_riv(gspca_dev, 0xf0, 0, 0);
865 spca504B_WaitCmdStatus(gspca_dev);
866 reg_r(gspca_dev, 0xf0, 4, 0);
867 spca504B_WaitCmdStatus(gspca_dev);
868 break;
869 default:
870 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00);
871 spca504B_WaitCmdStatus(gspca_dev);
872 spca504B_PollingDataReady(gspca_dev);
873 break;
874 }
875 break;
876 case BRIDGE_SPCA504:
877 if (sd->subtype == AiptekMiniPenCam13) {
878 spca504_read_info(gspca_dev);
879
880 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
881 spca504A_acknowledged_command(gspca_dev, 0x24,
882 8, 3, 0x9e, 1);
883 /* Twice sequencial need status 0xff->0x9e->0x9d */
884 spca504A_acknowledged_command(gspca_dev, 0x24,
885 8, 3, 0x9e, 0);
886 spca504A_acknowledged_command(gspca_dev, 0x24,
887 0, 0, 0x9d, 1);
888 } else {
889 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
890 spca504_read_info(gspca_dev);
891 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
892 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
893 }
894 spca504B_SetSizeType(gspca_dev);
895 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05);
896 /* L92 sno1t.txt */
897 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05);
898 break;
899 case BRIDGE_SPCA504C:
900 if (sd->subtype == LogitechClickSmart420) {
901 write_vector(gspca_dev,
902 spca504A_clicksmart420_init_data,
903 ARRAY_SIZE(spca504A_clicksmart420_init_data));
904 } else {
905 write_vector(gspca_dev, spca504_pccam600_init_data,
906 ARRAY_SIZE(spca504_pccam600_init_data));
907 }
908 enable = (sd->autogain ? 0x04 : 0x01);
909 reg_w_riv(gspca_dev, 0x0c, 0x0000, enable);
910 /* auto exposure */
911 reg_w_riv(gspca_dev, 0xb0, 0x0000, enable);
912 /* auto whiteness */
913
914 /* set default exposure compensation and whiteness balance */
915 reg_w_riv(gspca_dev, 0x30, 0x0001, 800); /* ~ 20 fps */
916 reg_w_riv(gspca_dev, 0x30, 0x0002, 1600);
917 spca504B_SetSizeType(gspca_dev);
918 break;
919 }
920 init_ctl_reg(gspca_dev);
921 return gspca_dev->usb_err;
922 }
923
924 static void sd_stopN(struct gspca_dev *gspca_dev)
925 {
926 struct sd *sd = (struct sd *) gspca_dev;
927
928 switch (sd->bridge) {
929 default:
930 /* case BRIDGE_SPCA533: */
931 /* case BRIDGE_SPCA536: */
932 /* case BRIDGE_SPCA504B: */
933 reg_w_riv(gspca_dev, 0x31, 0, 0);
934 spca504B_WaitCmdStatus(gspca_dev);
935 spca504B_PollingDataReady(gspca_dev);
936 break;
937 case BRIDGE_SPCA504:
938 case BRIDGE_SPCA504C:
939 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x0000);
940
941 if (sd->subtype == AiptekMiniPenCam13) {
942 /* spca504a aiptek */
943 /* spca504A_acknowledged_command(gspca_dev, 0x08,
944 6, 0, 0x86, 1); */
945 spca504A_acknowledged_command(gspca_dev, 0x24,
946 0x00, 0x00, 0x9d, 1);
947 spca504A_acknowledged_command(gspca_dev, 0x01,
948 0x0f, 0x00, 0xff, 1);
949 } else {
950 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
951 reg_w_riv(gspca_dev, 0x01, 0x000f, 0x0000);
952 }
953 break;
954 }
955 }
956
957 static void sd_stop0(struct gspca_dev *gspca_dev)
958 {
959 struct sd *sd = (struct sd *) gspca_dev;
960
961 kfree(sd->jpeg_hdr);
962 }
963
964 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
965 u8 *data, /* isoc packet */
966 int len) /* iso packet length */
967 {
968 struct sd *sd = (struct sd *) gspca_dev;
969 int i, sof = 0;
970 static u8 ffd9[] = {0xff, 0xd9};
971
972 /* frames are jpeg 4.1.1 without 0xff escape */
973 switch (sd->bridge) {
974 case BRIDGE_SPCA533:
975 if (data[0] == 0xff) {
976 if (data[1] != 0x01) { /* drop packet */
977 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
978 return;
979 }
980 sof = 1;
981 data += SPCA533_OFFSET_DATA;
982 len -= SPCA533_OFFSET_DATA;
983 } else {
984 data += 1;
985 len -= 1;
986 }
987 break;
988 case BRIDGE_SPCA536:
989 if (data[0] == 0xff) {
990 sof = 1;
991 data += SPCA536_OFFSET_DATA;
992 len -= SPCA536_OFFSET_DATA;
993 } else {
994 data += 2;
995 len -= 2;
996 }
997 break;
998 default:
999 /* case BRIDGE_SPCA504: */
1000 /* case BRIDGE_SPCA504B: */
1001 switch (data[0]) {
1002 case 0xfe: /* start of frame */
1003 sof = 1;
1004 data += SPCA50X_OFFSET_DATA;
1005 len -= SPCA50X_OFFSET_DATA;
1006 break;
1007 case 0xff: /* drop packet */
1008 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
1009 return;
1010 default:
1011 data += 1;
1012 len -= 1;
1013 break;
1014 }
1015 break;
1016 case BRIDGE_SPCA504C:
1017 switch (data[0]) {
1018 case 0xfe: /* start of frame */
1019 sof = 1;
1020 data += SPCA504_PCCAM600_OFFSET_DATA;
1021 len -= SPCA504_PCCAM600_OFFSET_DATA;
1022 break;
1023 case 0xff: /* drop packet */
1024 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
1025 return;
1026 default:
1027 data += 1;
1028 len -= 1;
1029 break;
1030 }
1031 break;
1032 }
1033 if (sof) { /* start of frame */
1034 gspca_frame_add(gspca_dev, LAST_PACKET,
1035 ffd9, 2);
1036
1037 /* put the JPEG header in the new frame */
1038 gspca_frame_add(gspca_dev, FIRST_PACKET,
1039 sd->jpeg_hdr, JPEG_HDR_SZ);
1040 }
1041
1042 /* add 0x00 after 0xff */
1043 i = 0;
1044 do {
1045 if (data[i] == 0xff) {
1046 gspca_frame_add(gspca_dev, INTER_PACKET,
1047 data, i + 1);
1048 len -= i;
1049 data += i;
1050 *data = 0x00;
1051 i = 0;
1052 }
1053 i++;
1054 } while (i < len);
1055 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1056 }
1057
1058 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1059 {
1060 struct sd *sd = (struct sd *) gspca_dev;
1061
1062 sd->brightness = val;
1063 if (gspca_dev->streaming)
1064 setbrightness(gspca_dev);
1065 return gspca_dev->usb_err;
1066 }
1067
1068 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1069 {
1070 struct sd *sd = (struct sd *) gspca_dev;
1071
1072 *val = sd->brightness;
1073 return 0;
1074 }
1075
1076 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1077 {
1078 struct sd *sd = (struct sd *) gspca_dev;
1079
1080 sd->contrast = val;
1081 if (gspca_dev->streaming)
1082 setcontrast(gspca_dev);
1083 return gspca_dev->usb_err;
1084 }
1085
1086 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1087 {
1088 struct sd *sd = (struct sd *) gspca_dev;
1089
1090 *val = sd->contrast;
1091 return 0;
1092 }
1093
1094 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1095 {
1096 struct sd *sd = (struct sd *) gspca_dev;
1097
1098 sd->colors = val;
1099 if (gspca_dev->streaming)
1100 setcolors(gspca_dev);
1101 return gspca_dev->usb_err;
1102 }
1103
1104 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1105 {
1106 struct sd *sd = (struct sd *) gspca_dev;
1107
1108 *val = sd->colors;
1109 return 0;
1110 }
1111
1112 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1113 {
1114 struct sd *sd = (struct sd *) gspca_dev;
1115
1116 sd->autogain = val;
1117 return 0;
1118 }
1119
1120 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1121 {
1122 struct sd *sd = (struct sd *) gspca_dev;
1123
1124 *val = sd->autogain;
1125 return 0;
1126 }
1127
1128 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
1129 struct v4l2_jpegcompression *jcomp)
1130 {
1131 struct sd *sd = (struct sd *) gspca_dev;
1132
1133 if (jcomp->quality < QUALITY_MIN)
1134 sd->quality = QUALITY_MIN;
1135 else if (jcomp->quality > QUALITY_MAX)
1136 sd->quality = QUALITY_MAX;
1137 else
1138 sd->quality = jcomp->quality;
1139 if (gspca_dev->streaming)
1140 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
1141 return gspca_dev->usb_err;
1142 }
1143
1144 static int sd_get_jcomp(struct gspca_dev *gspca_dev,
1145 struct v4l2_jpegcompression *jcomp)
1146 {
1147 struct sd *sd = (struct sd *) gspca_dev;
1148
1149 memset(jcomp, 0, sizeof *jcomp);
1150 jcomp->quality = sd->quality;
1151 jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
1152 | V4L2_JPEG_MARKER_DQT;
1153 return 0;
1154 }
1155
1156 /* sub-driver description */
1157 static const struct sd_desc sd_desc = {
1158 .name = MODULE_NAME,
1159 .ctrls = sd_ctrls,
1160 .nctrls = ARRAY_SIZE(sd_ctrls),
1161 .config = sd_config,
1162 .init = sd_init,
1163 .start = sd_start,
1164 .stopN = sd_stopN,
1165 .stop0 = sd_stop0,
1166 .pkt_scan = sd_pkt_scan,
1167 .get_jcomp = sd_get_jcomp,
1168 .set_jcomp = sd_set_jcomp,
1169 };
1170
1171 /* -- module initialisation -- */
1172 #define BS(bridge, subtype) \
1173 .driver_info = (BRIDGE_ ## bridge << 8) \
1174 | (subtype)
1175 static const __devinitdata struct usb_device_id device_table[] = {
1176 {USB_DEVICE(0x041e, 0x400b), BS(SPCA504C, 0)},
1177 {USB_DEVICE(0x041e, 0x4012), BS(SPCA504C, 0)},
1178 {USB_DEVICE(0x041e, 0x4013), BS(SPCA504C, 0)},
1179 {USB_DEVICE(0x0458, 0x7006), BS(SPCA504B, 0)},
1180 {USB_DEVICE(0x0461, 0x0821), BS(SPCA533, 0)},
1181 {USB_DEVICE(0x046d, 0x0905), BS(SPCA533, LogitechClickSmart820)},
1182 {USB_DEVICE(0x046d, 0x0960), BS(SPCA504C, LogitechClickSmart420)},
1183 {USB_DEVICE(0x0471, 0x0322), BS(SPCA504B, 0)},
1184 {USB_DEVICE(0x04a5, 0x3003), BS(SPCA504B, 0)},
1185 {USB_DEVICE(0x04a5, 0x3008), BS(SPCA533, 0)},
1186 {USB_DEVICE(0x04a5, 0x300a), BS(SPCA533, 0)},
1187 {USB_DEVICE(0x04f1, 0x1001), BS(SPCA504B, 0)},
1188 {USB_DEVICE(0x04fc, 0x500c), BS(SPCA504B, 0)},
1189 {USB_DEVICE(0x04fc, 0x504a), BS(SPCA504, AiptekMiniPenCam13)},
1190 {USB_DEVICE(0x04fc, 0x504b), BS(SPCA504B, 0)},
1191 {USB_DEVICE(0x04fc, 0x5330), BS(SPCA533, 0)},
1192 {USB_DEVICE(0x04fc, 0x5360), BS(SPCA536, 0)},
1193 {USB_DEVICE(0x04fc, 0xffff), BS(SPCA504B, 0)},
1194 {USB_DEVICE(0x052b, 0x1507), BS(SPCA533, MegapixV4)},
1195 {USB_DEVICE(0x052b, 0x1513), BS(SPCA533, MegapixV4)},
1196 {USB_DEVICE(0x052b, 0x1803), BS(SPCA533, MegaImageVI)},
1197 {USB_DEVICE(0x0546, 0x3155), BS(SPCA533, 0)},
1198 {USB_DEVICE(0x0546, 0x3191), BS(SPCA504B, 0)},
1199 {USB_DEVICE(0x0546, 0x3273), BS(SPCA504B, 0)},
1200 {USB_DEVICE(0x055f, 0xc211), BS(SPCA536, 0)},
1201 {USB_DEVICE(0x055f, 0xc230), BS(SPCA533, 0)},
1202 {USB_DEVICE(0x055f, 0xc232), BS(SPCA533, 0)},
1203 {USB_DEVICE(0x055f, 0xc360), BS(SPCA536, 0)},
1204 {USB_DEVICE(0x055f, 0xc420), BS(SPCA504, 0)},
1205 {USB_DEVICE(0x055f, 0xc430), BS(SPCA533, 0)},
1206 {USB_DEVICE(0x055f, 0xc440), BS(SPCA533, 0)},
1207 {USB_DEVICE(0x055f, 0xc520), BS(SPCA504, 0)},
1208 {USB_DEVICE(0x055f, 0xc530), BS(SPCA533, 0)},
1209 {USB_DEVICE(0x055f, 0xc540), BS(SPCA533, 0)},
1210 {USB_DEVICE(0x055f, 0xc630), BS(SPCA533, 0)},
1211 {USB_DEVICE(0x055f, 0xc650), BS(SPCA533, 0)},
1212 {USB_DEVICE(0x05da, 0x1018), BS(SPCA504B, 0)},
1213 {USB_DEVICE(0x06d6, 0x0031), BS(SPCA533, 0)},
1214 {USB_DEVICE(0x0733, 0x1311), BS(SPCA533, 0)},
1215 {USB_DEVICE(0x0733, 0x1314), BS(SPCA533, 0)},
1216 {USB_DEVICE(0x0733, 0x2211), BS(SPCA533, 0)},
1217 {USB_DEVICE(0x0733, 0x2221), BS(SPCA533, 0)},
1218 {USB_DEVICE(0x0733, 0x3261), BS(SPCA536, 0)},
1219 {USB_DEVICE(0x0733, 0x3281), BS(SPCA536, 0)},
1220 {USB_DEVICE(0x08ca, 0x0104), BS(SPCA533, 0)},
1221 {USB_DEVICE(0x08ca, 0x0106), BS(SPCA533, 0)},
1222 {USB_DEVICE(0x08ca, 0x2008), BS(SPCA504B, 0)},
1223 {USB_DEVICE(0x08ca, 0x2010), BS(SPCA533, 0)},
1224 {USB_DEVICE(0x08ca, 0x2016), BS(SPCA504B, 0)},
1225 {USB_DEVICE(0x08ca, 0x2018), BS(SPCA504B, 0)},
1226 {USB_DEVICE(0x08ca, 0x2020), BS(SPCA533, 0)},
1227 {USB_DEVICE(0x08ca, 0x2022), BS(SPCA533, 0)},
1228 {USB_DEVICE(0x08ca, 0x2024), BS(SPCA536, 0)},
1229 {USB_DEVICE(0x08ca, 0x2028), BS(SPCA533, 0)},
1230 {USB_DEVICE(0x08ca, 0x2040), BS(SPCA536, 0)},
1231 {USB_DEVICE(0x08ca, 0x2042), BS(SPCA536, 0)},
1232 {USB_DEVICE(0x08ca, 0x2050), BS(SPCA536, 0)},
1233 {USB_DEVICE(0x08ca, 0x2060), BS(SPCA536, 0)},
1234 {USB_DEVICE(0x0d64, 0x0303), BS(SPCA536, 0)},
1235 {}
1236 };
1237 MODULE_DEVICE_TABLE(usb, device_table);
1238
1239 /* -- device connect -- */
1240 static int sd_probe(struct usb_interface *intf,
1241 const struct usb_device_id *id)
1242 {
1243 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1244 THIS_MODULE);
1245 }
1246
1247 static struct usb_driver sd_driver = {
1248 .name = MODULE_NAME,
1249 .id_table = device_table,
1250 .probe = sd_probe,
1251 .disconnect = gspca_disconnect,
1252 #ifdef CONFIG_PM
1253 .suspend = gspca_suspend,
1254 .resume = gspca_resume,
1255 #endif
1256 };
1257
1258 /* -- module insert / remove -- */
1259 static int __init sd_mod_init(void)
1260 {
1261 int ret;
1262 ret = usb_register(&sd_driver);
1263 if (ret < 0)
1264 return ret;
1265 PDEBUG(D_PROBE, "registered");
1266 return 0;
1267 }
1268 static void __exit sd_mod_exit(void)
1269 {
1270 usb_deregister(&sd_driver);
1271 PDEBUG(D_PROBE, "deregistered");
1272 }
1273
1274 module_init(sd_mod_init);
1275 module_exit(sd_mod_exit);