?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drivers/tty/serial/8250_pci.c: fix warning
[linux-2.6/next.git] / drivers / media / video / gspca / sunplus.c
blobb089c0d3ee9f96dc7b2de6f770105efe35db1503
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[JPEG_HDR_SZ];
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 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 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 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 static void write_vector(struct gspca_dev *gspca_dev,
400 const struct cmd *data, int ncmds)
401 {
402 while (--ncmds >= 0) {
403 reg_w_riv(gspca_dev, data->req, data->idx, data->val);
404 data++;
405 }
406 }
407
408 static void setup_qtable(struct gspca_dev *gspca_dev,
409 const u8 qtable[2][64])
410 {
411 int i;
412
413 /* loop over y components */
414 for (i = 0; i < 64; i++)
415 reg_w_riv(gspca_dev, 0x00, 0x2800 + i, qtable[0][i]);
416
417 /* loop over c components */
418 for (i = 0; i < 64; i++)
419 reg_w_riv(gspca_dev, 0x00, 0x2840 + i, qtable[1][i]);
420 }
421
422 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
423 u8 req, u16 idx, u16 val)
424 {
425 reg_w_riv(gspca_dev, req, idx, val);
426 reg_r(gspca_dev, 0x01, 0x0001, 1);
427 PDEBUG(D_FRAM, "before wait 0x%04x", gspca_dev->usb_buf[0]);
428 reg_w_riv(gspca_dev, req, idx, val);
429
430 msleep(200);
431 reg_r(gspca_dev, 0x01, 0x0001, 1);
432 PDEBUG(D_FRAM, "after wait 0x%04x", gspca_dev->usb_buf[0]);
433 }
434
435 #ifdef GSPCA_DEBUG
436 static void spca504_read_info(struct gspca_dev *gspca_dev)
437 {
438 int i;
439 u8 info[6];
440
441 for (i = 0; i < 6; i++) {
442 reg_r(gspca_dev, 0, i, 1);
443 info[i] = gspca_dev->usb_buf[0];
444 }
445 PDEBUG(D_STREAM,
446 "Read info: %d %d %d %d %d %d."
447 " Should be 1,0,2,2,0,0",
448 info[0], info[1], info[2],
449 info[3], info[4], info[5]);
450 }
451 #endif
452
453 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
454 u8 req,
455 u16 idx, u16 val, u8 endcode, u8 count)
456 {
457 u16 status;
458
459 reg_w_riv(gspca_dev, req, idx, val);
460 reg_r(gspca_dev, 0x01, 0x0001, 1);
461 if (gspca_dev->usb_err < 0)
462 return;
463 PDEBUG(D_FRAM, "Status 0x%02x Need 0x%02x",
464 gspca_dev->usb_buf[0], endcode);
465 if (!count)
466 return;
467 count = 200;
468 while (--count > 0) {
469 msleep(10);
470 /* gsmart mini2 write a each wait setting 1 ms is enough */
471 /* reg_w_riv(gspca_dev, req, idx, val); */
472 reg_r(gspca_dev, 0x01, 0x0001, 1);
473 status = gspca_dev->usb_buf[0];
474 if (status == endcode) {
475 PDEBUG(D_FRAM, "status 0x%04x after wait %d",
476 status, 200 - count);
477 break;
478 }
479 }
480 }
481
482 static void spca504B_PollingDataReady(struct gspca_dev *gspca_dev)
483 {
484 int count = 10;
485
486 while (--count > 0) {
487 reg_r(gspca_dev, 0x21, 0, 1);
488 if ((gspca_dev->usb_buf[0] & 0x01) == 0)
489 break;
490 msleep(10);
491 }
492 }
493
494 static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
495 {
496 int count = 50;
497
498 while (--count > 0) {
499 reg_r(gspca_dev, 0x21, 1, 1);
500 if (gspca_dev->usb_buf[0] != 0) {
501 reg_w_1(gspca_dev, 0x21, 0, 1, 0);
502 reg_r(gspca_dev, 0x21, 1, 1);
503 spca504B_PollingDataReady(gspca_dev);
504 break;
505 }
506 msleep(10);
507 }
508 }
509
510 #ifdef GSPCA_DEBUG
511 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
512 {
513 u8 *data;
514
515 data = gspca_dev->usb_buf;
516 reg_r(gspca_dev, 0x20, 0, 5);
517 PDEBUG(D_STREAM, "FirmWare: %d %d %d %d %d",
518 data[0], data[1], data[2], data[3], data[4]);
519 reg_r(gspca_dev, 0x23, 0, 64);
520 reg_r(gspca_dev, 0x23, 1, 64);
521 }
522 #endif
523
524 static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
525 {
526 struct sd *sd = (struct sd *) gspca_dev;
527 u8 Size;
528
529 Size = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
530 switch (sd->bridge) {
531 case BRIDGE_SPCA533:
532 reg_w_riv(gspca_dev, 0x31, 0, 0);
533 spca504B_WaitCmdStatus(gspca_dev);
534 spca504B_PollingDataReady(gspca_dev);
535 #ifdef GSPCA_DEBUG
536 spca50x_GetFirmware(gspca_dev);
537 #endif
538 reg_w_1(gspca_dev, 0x24, 0, 8, 2); /* type */
539 reg_r(gspca_dev, 0x24, 8, 1);
540
541 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
542 reg_r(gspca_dev, 0x25, 4, 1); /* size */
543 spca504B_PollingDataReady(gspca_dev);
544
545 /* Init the cam width height with some values get on init ? */
546 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00);
547 spca504B_WaitCmdStatus(gspca_dev);
548 spca504B_PollingDataReady(gspca_dev);
549 break;
550 default:
551 /* case BRIDGE_SPCA504B: */
552 /* case BRIDGE_SPCA536: */
553 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
554 reg_r(gspca_dev, 0x25, 4, 1); /* size */
555 reg_w_1(gspca_dev, 0x27, 0, 0, 6);
556 reg_r(gspca_dev, 0x27, 0, 1); /* type */
557 spca504B_PollingDataReady(gspca_dev);
558 break;
559 case BRIDGE_SPCA504:
560 Size += 3;
561 if (sd->subtype == AiptekMiniPenCam13) {
562 /* spca504a aiptek */
563 spca504A_acknowledged_command(gspca_dev,
564 0x08, Size, 0,
565 0x80 | (Size & 0x0f), 1);
566 spca504A_acknowledged_command(gspca_dev,
567 1, 3, 0, 0x9f, 0);
568 } else {
569 spca504_acknowledged_command(gspca_dev, 0x08, Size, 0);
570 }
571 break;
572 case BRIDGE_SPCA504C:
573 /* capture mode */
574 reg_w_riv(gspca_dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x00);
575 reg_w_riv(gspca_dev, 0x20, 0x01, 0x0500 | (Size & 0x0f));
576 break;
577 }
578 }
579
580 static void spca504_wait_status(struct gspca_dev *gspca_dev)
581 {
582 int cnt;
583
584 cnt = 256;
585 while (--cnt > 0) {
586 /* With this we get the status, when return 0 it's all ok */
587 reg_r(gspca_dev, 0x06, 0x00, 1);
588 if (gspca_dev->usb_buf[0] == 0)
589 return;
590 msleep(10);
591 }
592 }
593
594 static void spca504B_setQtable(struct gspca_dev *gspca_dev)
595 {
596 reg_w_1(gspca_dev, 0x26, 0, 0, 3);
597 reg_r(gspca_dev, 0x26, 0, 1);
598 spca504B_PollingDataReady(gspca_dev);
599 }
600
601 static void setbrightness(struct gspca_dev *gspca_dev)
602 {
603 struct sd *sd = (struct sd *) gspca_dev;
604 u16 reg;
605
606 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f0 : 0x21a7;
607 reg_w_riv(gspca_dev, 0x00, reg, sd->brightness);
608 }
609
610 static void setcontrast(struct gspca_dev *gspca_dev)
611 {
612 struct sd *sd = (struct sd *) gspca_dev;
613 u16 reg;
614
615 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f1 : 0x21a8;
616 reg_w_riv(gspca_dev, 0x00, reg, sd->contrast);
617 }
618
619 static void setcolors(struct gspca_dev *gspca_dev)
620 {
621 struct sd *sd = (struct sd *) gspca_dev;
622 u16 reg;
623
624 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f6 : 0x21ae;
625 reg_w_riv(gspca_dev, 0x00, reg, sd->colors);
626 }
627
628 static void init_ctl_reg(struct gspca_dev *gspca_dev)
629 {
630 struct sd *sd = (struct sd *) gspca_dev;
631 int pollreg = 1;
632
633 setbrightness(gspca_dev);
634 setcontrast(gspca_dev);
635 setcolors(gspca_dev);
636
637 switch (sd->bridge) {
638 case BRIDGE_SPCA504:
639 case BRIDGE_SPCA504C:
640 pollreg = 0;
641 /* fall thru */
642 default:
643 /* case BRIDGE_SPCA533: */
644 /* case BRIDGE_SPCA504B: */
645 reg_w_riv(gspca_dev, 0, 0x21ad, 0x00); /* hue */
646 reg_w_riv(gspca_dev, 0, 0x21ac, 0x01); /* sat/hue */
647 reg_w_riv(gspca_dev, 0, 0x21a3, 0x00); /* gamma */
648 break;
649 case BRIDGE_SPCA536:
650 reg_w_riv(gspca_dev, 0, 0x20f5, 0x40);
651 reg_w_riv(gspca_dev, 0, 0x20f4, 0x01);
652 reg_w_riv(gspca_dev, 0, 0x2089, 0x00);
653 break;
654 }
655 if (pollreg)
656 spca504B_PollingDataReady(gspca_dev);
657 }
658
659 /* this function is called at probe time */
660 static int sd_config(struct gspca_dev *gspca_dev,
661 const struct usb_device_id *id)
662 {
663 struct sd *sd = (struct sd *) gspca_dev;
664 struct cam *cam;
665
666 cam = &gspca_dev->cam;
667
668 sd->bridge = id->driver_info >> 8;
669 sd->subtype = id->driver_info;
670
671 if (sd->subtype == AiptekMiniPenCam13) {
672
673 /* try to get the firmware as some cam answer 2.0.1.2.2
674 * and should be a spca504b then overwrite that setting */
675 reg_r(gspca_dev, 0x20, 0, 1);
676 switch (gspca_dev->usb_buf[0]) {
677 case 1:
678 break; /* (right bridge/subtype) */
679 case 2:
680 sd->bridge = BRIDGE_SPCA504B;
681 sd->subtype = 0;
682 break;
683 default:
684 return -ENODEV;
685 }
686 }
687
688 switch (sd->bridge) {
689 default:
690 /* case BRIDGE_SPCA504B: */
691 /* case BRIDGE_SPCA504: */
692 /* case BRIDGE_SPCA536: */
693 cam->cam_mode = vga_mode;
694 cam->nmodes = ARRAY_SIZE(vga_mode);
695 break;
696 case BRIDGE_SPCA533:
697 cam->cam_mode = custom_mode;
698 if (sd->subtype == MegaImageVI) /* 320x240 only */
699 cam->nmodes = ARRAY_SIZE(custom_mode) - 1;
700 else
701 cam->nmodes = ARRAY_SIZE(custom_mode);
702 break;
703 case BRIDGE_SPCA504C:
704 cam->cam_mode = vga_mode2;
705 cam->nmodes = ARRAY_SIZE(vga_mode2);
706 break;
707 }
708 sd->brightness = BRIGHTNESS_DEF;
709 sd->contrast = CONTRAST_DEF;
710 sd->colors = COLOR_DEF;
711 sd->autogain = AUTOGAIN_DEF;
712 sd->quality = QUALITY_DEF;
713 return 0;
714 }
715
716 /* this function is called at probe and resume time */
717 static int sd_init(struct gspca_dev *gspca_dev)
718 {
719 struct sd *sd = (struct sd *) gspca_dev;
720
721 switch (sd->bridge) {
722 case BRIDGE_SPCA504B:
723 reg_w_riv(gspca_dev, 0x1d, 0x00, 0);
724 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x01);
725 reg_w_riv(gspca_dev, 0x00, 0x0d04, 0x00);
726 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x00);
727 reg_w_riv(gspca_dev, 0x00, 0x2301, 0x13);
728 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x00);
729 /* fall thru */
730 case BRIDGE_SPCA533:
731 spca504B_PollingDataReady(gspca_dev);
732 #ifdef GSPCA_DEBUG
733 spca50x_GetFirmware(gspca_dev);
734 #endif
735 break;
736 case BRIDGE_SPCA536:
737 #ifdef GSPCA_DEBUG
738 spca50x_GetFirmware(gspca_dev);
739 #endif
740 reg_r(gspca_dev, 0x00, 0x5002, 1);
741 reg_w_1(gspca_dev, 0x24, 0, 0, 0);
742 reg_r(gspca_dev, 0x24, 0, 1);
743 spca504B_PollingDataReady(gspca_dev);
744 reg_w_riv(gspca_dev, 0x34, 0, 0);
745 spca504B_WaitCmdStatus(gspca_dev);
746 break;
747 case BRIDGE_SPCA504C: /* pccam600 */
748 PDEBUG(D_STREAM, "Opening SPCA504 (PC-CAM 600)");
749 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0000);
750 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0001); /* reset */
751 spca504_wait_status(gspca_dev);
752 if (sd->subtype == LogitechClickSmart420)
753 write_vector(gspca_dev,
754 spca504A_clicksmart420_open_data,
755 ARRAY_SIZE(spca504A_clicksmart420_open_data));
756 else
757 write_vector(gspca_dev, spca504_pccam600_open_data,
758 ARRAY_SIZE(spca504_pccam600_open_data));
759 setup_qtable(gspca_dev, qtable_creative_pccam);
760 break;
761 default:
762 /* case BRIDGE_SPCA504: */
763 PDEBUG(D_STREAM, "Opening SPCA504");
764 if (sd->subtype == AiptekMiniPenCam13) {
765 #ifdef GSPCA_DEBUG
766 spca504_read_info(gspca_dev);
767 #endif
768
769 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
770 spca504A_acknowledged_command(gspca_dev, 0x24,
771 8, 3, 0x9e, 1);
772 /* Twice sequential need status 0xff->0x9e->0x9d */
773 spca504A_acknowledged_command(gspca_dev, 0x24,
774 8, 3, 0x9e, 0);
775
776 spca504A_acknowledged_command(gspca_dev, 0x24,
777 0, 0, 0x9d, 1);
778 /******************************/
779 /* spca504a aiptek */
780 spca504A_acknowledged_command(gspca_dev, 0x08,
781 6, 0, 0x86, 1);
782 /* reg_write (dev, 0, 0x2000, 0); */
783 /* reg_write (dev, 0, 0x2883, 1); */
784 /* spca504A_acknowledged_command (gspca_dev, 0x08,
785 6, 0, 0x86, 1); */
786 /* spca504A_acknowledged_command (gspca_dev, 0x24,
787 0, 0, 0x9D, 1); */
788 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05);
789 /* L92 sno1t.txt */
790 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05);
791 spca504A_acknowledged_command(gspca_dev, 0x01,
792 0x0f, 0, 0xff, 0);
793 }
794 /* setup qtable */
795 reg_w_riv(gspca_dev, 0, 0x2000, 0);
796 reg_w_riv(gspca_dev, 0, 0x2883, 1);
797 setup_qtable(gspca_dev, qtable_spca504_default);
798 break;
799 }
800 return gspca_dev->usb_err;
801 }
802
803 static int sd_start(struct gspca_dev *gspca_dev)
804 {
805 struct sd *sd = (struct sd *) gspca_dev;
806 int enable;
807
808 /* create the JPEG header */
809 jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
810 0x22); /* JPEG 411 */
811 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
812
813 if (sd->bridge == BRIDGE_SPCA504B)
814 spca504B_setQtable(gspca_dev);
815 spca504B_SetSizeType(gspca_dev);
816 switch (sd->bridge) {
817 default:
818 /* case BRIDGE_SPCA504B: */
819 /* case BRIDGE_SPCA533: */
820 /* case BRIDGE_SPCA536: */
821 switch (sd->subtype) {
822 case MegapixV4:
823 case LogitechClickSmart820:
824 case MegaImageVI:
825 reg_w_riv(gspca_dev, 0xf0, 0, 0);
826 spca504B_WaitCmdStatus(gspca_dev);
827 reg_r(gspca_dev, 0xf0, 4, 0);
828 spca504B_WaitCmdStatus(gspca_dev);
829 break;
830 default:
831 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00);
832 spca504B_WaitCmdStatus(gspca_dev);
833 spca504B_PollingDataReady(gspca_dev);
834 break;
835 }
836 break;
837 case BRIDGE_SPCA504:
838 if (sd->subtype == AiptekMiniPenCam13) {
839 #ifdef GSPCA_DEBUG
840 spca504_read_info(gspca_dev);
841 #endif
842
843 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
844 spca504A_acknowledged_command(gspca_dev, 0x24,
845 8, 3, 0x9e, 1);
846 /* Twice sequential need status 0xff->0x9e->0x9d */
847 spca504A_acknowledged_command(gspca_dev, 0x24,
848 8, 3, 0x9e, 0);
849 spca504A_acknowledged_command(gspca_dev, 0x24,
850 0, 0, 0x9d, 1);
851 } else {
852 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
853 #ifdef GSPCA_DEBUG
854 spca504_read_info(gspca_dev);
855 #endif
856 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
857 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
858 }
859 spca504B_SetSizeType(gspca_dev);
860 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05);
861 /* L92 sno1t.txt */
862 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05);
863 break;
864 case BRIDGE_SPCA504C:
865 if (sd->subtype == LogitechClickSmart420) {
866 write_vector(gspca_dev,
867 spca504A_clicksmart420_init_data,
868 ARRAY_SIZE(spca504A_clicksmart420_init_data));
869 } else {
870 write_vector(gspca_dev, spca504_pccam600_init_data,
871 ARRAY_SIZE(spca504_pccam600_init_data));
872 }
873 enable = (sd->autogain ? 0x04 : 0x01);
874 reg_w_riv(gspca_dev, 0x0c, 0x0000, enable);
875 /* auto exposure */
876 reg_w_riv(gspca_dev, 0xb0, 0x0000, enable);
877 /* auto whiteness */
878
879 /* set default exposure compensation and whiteness balance */
880 reg_w_riv(gspca_dev, 0x30, 0x0001, 800); /* ~ 20 fps */
881 reg_w_riv(gspca_dev, 0x30, 0x0002, 1600);
882 spca504B_SetSizeType(gspca_dev);
883 break;
884 }
885 init_ctl_reg(gspca_dev);
886 return gspca_dev->usb_err;
887 }
888
889 static void sd_stopN(struct gspca_dev *gspca_dev)
890 {
891 struct sd *sd = (struct sd *) gspca_dev;
892
893 switch (sd->bridge) {
894 default:
895 /* case BRIDGE_SPCA533: */
896 /* case BRIDGE_SPCA536: */
897 /* case BRIDGE_SPCA504B: */
898 reg_w_riv(gspca_dev, 0x31, 0, 0);
899 spca504B_WaitCmdStatus(gspca_dev);
900 spca504B_PollingDataReady(gspca_dev);
901 break;
902 case BRIDGE_SPCA504:
903 case BRIDGE_SPCA504C:
904 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x0000);
905
906 if (sd->subtype == AiptekMiniPenCam13) {
907 /* spca504a aiptek */
908 /* spca504A_acknowledged_command(gspca_dev, 0x08,
909 6, 0, 0x86, 1); */
910 spca504A_acknowledged_command(gspca_dev, 0x24,
911 0x00, 0x00, 0x9d, 1);
912 spca504A_acknowledged_command(gspca_dev, 0x01,
913 0x0f, 0x00, 0xff, 1);
914 } else {
915 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
916 reg_w_riv(gspca_dev, 0x01, 0x000f, 0x0000);
917 }
918 break;
919 }
920 }
921
922 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
923 u8 *data, /* isoc packet */
924 int len) /* iso packet length */
925 {
926 struct sd *sd = (struct sd *) gspca_dev;
927 int i, sof = 0;
928 static u8 ffd9[] = {0xff, 0xd9};
929
930 /* frames are jpeg 4.1.1 without 0xff escape */
931 switch (sd->bridge) {
932 case BRIDGE_SPCA533:
933 if (data[0] == 0xff) {
934 if (data[1] != 0x01) { /* drop packet */
935 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
936 return;
937 }
938 sof = 1;
939 data += SPCA533_OFFSET_DATA;
940 len -= SPCA533_OFFSET_DATA;
941 } else {
942 data += 1;
943 len -= 1;
944 }
945 break;
946 case BRIDGE_SPCA536:
947 if (data[0] == 0xff) {
948 sof = 1;
949 data += SPCA536_OFFSET_DATA;
950 len -= SPCA536_OFFSET_DATA;
951 } else {
952 data += 2;
953 len -= 2;
954 }
955 break;
956 default:
957 /* case BRIDGE_SPCA504: */
958 /* case BRIDGE_SPCA504B: */
959 switch (data[0]) {
960 case 0xfe: /* start of frame */
961 sof = 1;
962 data += SPCA50X_OFFSET_DATA;
963 len -= SPCA50X_OFFSET_DATA;
964 break;
965 case 0xff: /* drop packet */
966 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
967 return;
968 default:
969 data += 1;
970 len -= 1;
971 break;
972 }
973 break;
974 case BRIDGE_SPCA504C:
975 switch (data[0]) {
976 case 0xfe: /* start of frame */
977 sof = 1;
978 data += SPCA504_PCCAM600_OFFSET_DATA;
979 len -= SPCA504_PCCAM600_OFFSET_DATA;
980 break;
981 case 0xff: /* drop packet */
982 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
983 return;
984 default:
985 data += 1;
986 len -= 1;
987 break;
988 }
989 break;
990 }
991 if (sof) { /* start of frame */
992 gspca_frame_add(gspca_dev, LAST_PACKET,
993 ffd9, 2);
994
995 /* put the JPEG header in the new frame */
996 gspca_frame_add(gspca_dev, FIRST_PACKET,
997 sd->jpeg_hdr, JPEG_HDR_SZ);
998 }
999
1000 /* add 0x00 after 0xff */
1001 i = 0;
1002 do {
1003 if (data[i] == 0xff) {
1004 gspca_frame_add(gspca_dev, INTER_PACKET,
1005 data, i + 1);
1006 len -= i;
1007 data += i;
1008 *data = 0x00;
1009 i = 0;
1010 }
1011 i++;
1012 } while (i < len);
1013 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1014 }
1015
1016 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1017 {
1018 struct sd *sd = (struct sd *) gspca_dev;
1019
1020 sd->brightness = val;
1021 if (gspca_dev->streaming)
1022 setbrightness(gspca_dev);
1023 return gspca_dev->usb_err;
1024 }
1025
1026 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1027 {
1028 struct sd *sd = (struct sd *) gspca_dev;
1029
1030 *val = sd->brightness;
1031 return 0;
1032 }
1033
1034 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1035 {
1036 struct sd *sd = (struct sd *) gspca_dev;
1037
1038 sd->contrast = val;
1039 if (gspca_dev->streaming)
1040 setcontrast(gspca_dev);
1041 return gspca_dev->usb_err;
1042 }
1043
1044 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1045 {
1046 struct sd *sd = (struct sd *) gspca_dev;
1047
1048 *val = sd->contrast;
1049 return 0;
1050 }
1051
1052 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1053 {
1054 struct sd *sd = (struct sd *) gspca_dev;
1055
1056 sd->colors = val;
1057 if (gspca_dev->streaming)
1058 setcolors(gspca_dev);
1059 return gspca_dev->usb_err;
1060 }
1061
1062 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1063 {
1064 struct sd *sd = (struct sd *) gspca_dev;
1065
1066 *val = sd->colors;
1067 return 0;
1068 }
1069
1070 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1071 {
1072 struct sd *sd = (struct sd *) gspca_dev;
1073
1074 sd->autogain = val;
1075 return 0;
1076 }
1077
1078 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1079 {
1080 struct sd *sd = (struct sd *) gspca_dev;
1081
1082 *val = sd->autogain;
1083 return 0;
1084 }
1085
1086 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
1087 struct v4l2_jpegcompression *jcomp)
1088 {
1089 struct sd *sd = (struct sd *) gspca_dev;
1090
1091 if (jcomp->quality < QUALITY_MIN)
1092 sd->quality = QUALITY_MIN;
1093 else if (jcomp->quality > QUALITY_MAX)
1094 sd->quality = QUALITY_MAX;
1095 else
1096 sd->quality = jcomp->quality;
1097 if (gspca_dev->streaming)
1098 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
1099 return gspca_dev->usb_err;
1100 }
1101
1102 static int sd_get_jcomp(struct gspca_dev *gspca_dev,
1103 struct v4l2_jpegcompression *jcomp)
1104 {
1105 struct sd *sd = (struct sd *) gspca_dev;
1106
1107 memset(jcomp, 0, sizeof *jcomp);
1108 jcomp->quality = sd->quality;
1109 jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
1110 | V4L2_JPEG_MARKER_DQT;
1111 return 0;
1112 }
1113
1114 /* sub-driver description */
1115 static const struct sd_desc sd_desc = {
1116 .name = MODULE_NAME,
1117 .ctrls = sd_ctrls,
1118 .nctrls = ARRAY_SIZE(sd_ctrls),
1119 .config = sd_config,
1120 .init = sd_init,
1121 .start = sd_start,
1122 .stopN = sd_stopN,
1123 .pkt_scan = sd_pkt_scan,
1124 .get_jcomp = sd_get_jcomp,
1125 .set_jcomp = sd_set_jcomp,
1126 };
1127
1128 /* -- module initialisation -- */
1129 #define BS(bridge, subtype) \
1130 .driver_info = (BRIDGE_ ## bridge << 8) \
1131 | (subtype)
1132 static const struct usb_device_id device_table[] = {
1133 {USB_DEVICE(0x041e, 0x400b), BS(SPCA504C, 0)},
1134 {USB_DEVICE(0x041e, 0x4012), BS(SPCA504C, 0)},
1135 {USB_DEVICE(0x041e, 0x4013), BS(SPCA504C, 0)},
1136 {USB_DEVICE(0x0458, 0x7006), BS(SPCA504B, 0)},
1137 {USB_DEVICE(0x0461, 0x0821), BS(SPCA533, 0)},
1138 {USB_DEVICE(0x046d, 0x0905), BS(SPCA533, LogitechClickSmart820)},
1139 {USB_DEVICE(0x046d, 0x0960), BS(SPCA504C, LogitechClickSmart420)},
1140 {USB_DEVICE(0x0471, 0x0322), BS(SPCA504B, 0)},
1141 {USB_DEVICE(0x04a5, 0x3003), BS(SPCA504B, 0)},
1142 {USB_DEVICE(0x04a5, 0x3008), BS(SPCA533, 0)},
1143 {USB_DEVICE(0x04a5, 0x300a), BS(SPCA533, 0)},
1144 {USB_DEVICE(0x04f1, 0x1001), BS(SPCA504B, 0)},
1145 {USB_DEVICE(0x04fc, 0x500c), BS(SPCA504B, 0)},
1146 {USB_DEVICE(0x04fc, 0x504a), BS(SPCA504, AiptekMiniPenCam13)},
1147 {USB_DEVICE(0x04fc, 0x504b), BS(SPCA504B, 0)},
1148 {USB_DEVICE(0x04fc, 0x5330), BS(SPCA533, 0)},
1149 {USB_DEVICE(0x04fc, 0x5360), BS(SPCA536, 0)},
1150 {USB_DEVICE(0x04fc, 0xffff), BS(SPCA504B, 0)},
1151 {USB_DEVICE(0x052b, 0x1507), BS(SPCA533, MegapixV4)},
1152 {USB_DEVICE(0x052b, 0x1513), BS(SPCA533, MegapixV4)},
1153 {USB_DEVICE(0x052b, 0x1803), BS(SPCA533, MegaImageVI)},
1154 {USB_DEVICE(0x0546, 0x3155), BS(SPCA533, 0)},
1155 {USB_DEVICE(0x0546, 0x3191), BS(SPCA504B, 0)},
1156 {USB_DEVICE(0x0546, 0x3273), BS(SPCA504B, 0)},
1157 {USB_DEVICE(0x055f, 0xc211), BS(SPCA536, 0)},
1158 {USB_DEVICE(0x055f, 0xc230), BS(SPCA533, 0)},
1159 {USB_DEVICE(0x055f, 0xc232), BS(SPCA533, 0)},
1160 {USB_DEVICE(0x055f, 0xc360), BS(SPCA536, 0)},
1161 {USB_DEVICE(0x055f, 0xc420), BS(SPCA504, 0)},
1162 {USB_DEVICE(0x055f, 0xc430), BS(SPCA533, 0)},
1163 {USB_DEVICE(0x055f, 0xc440), BS(SPCA533, 0)},
1164 {USB_DEVICE(0x055f, 0xc520), BS(SPCA504, 0)},
1165 {USB_DEVICE(0x055f, 0xc530), BS(SPCA533, 0)},
1166 {USB_DEVICE(0x055f, 0xc540), BS(SPCA533, 0)},
1167 {USB_DEVICE(0x055f, 0xc630), BS(SPCA533, 0)},
1168 {USB_DEVICE(0x055f, 0xc650), BS(SPCA533, 0)},
1169 {USB_DEVICE(0x05da, 0x1018), BS(SPCA504B, 0)},
1170 {USB_DEVICE(0x06d6, 0x0031), BS(SPCA533, 0)},
1171 {USB_DEVICE(0x0733, 0x1311), BS(SPCA533, 0)},
1172 {USB_DEVICE(0x0733, 0x1314), BS(SPCA533, 0)},
1173 {USB_DEVICE(0x0733, 0x2211), BS(SPCA533, 0)},
1174 {USB_DEVICE(0x0733, 0x2221), BS(SPCA533, 0)},
1175 {USB_DEVICE(0x0733, 0x3261), BS(SPCA536, 0)},
1176 {USB_DEVICE(0x0733, 0x3281), BS(SPCA536, 0)},
1177 {USB_DEVICE(0x08ca, 0x0104), BS(SPCA533, 0)},
1178 {USB_DEVICE(0x08ca, 0x0106), BS(SPCA533, 0)},
1179 {USB_DEVICE(0x08ca, 0x2008), BS(SPCA504B, 0)},
1180 {USB_DEVICE(0x08ca, 0x2010), BS(SPCA533, 0)},
1181 {USB_DEVICE(0x08ca, 0x2016), BS(SPCA504B, 0)},
1182 {USB_DEVICE(0x08ca, 0x2018), BS(SPCA504B, 0)},
1183 {USB_DEVICE(0x08ca, 0x2020), BS(SPCA533, 0)},
1184 {USB_DEVICE(0x08ca, 0x2022), BS(SPCA533, 0)},
1185 {USB_DEVICE(0x08ca, 0x2024), BS(SPCA536, 0)},
1186 {USB_DEVICE(0x08ca, 0x2028), BS(SPCA533, 0)},
1187 {USB_DEVICE(0x08ca, 0x2040), BS(SPCA536, 0)},
1188 {USB_DEVICE(0x08ca, 0x2042), BS(SPCA536, 0)},
1189 {USB_DEVICE(0x08ca, 0x2050), BS(SPCA536, 0)},
1190 {USB_DEVICE(0x08ca, 0x2060), BS(SPCA536, 0)},
1191 {USB_DEVICE(0x0d64, 0x0303), BS(SPCA536, 0)},
1192 {}
1193 };
1194 MODULE_DEVICE_TABLE(usb, device_table);
1195
1196 /* -- device connect -- */
1197 static int sd_probe(struct usb_interface *intf,
1198 const struct usb_device_id *id)
1199 {
1200 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1201 THIS_MODULE);
1202 }
1203
1204 static struct usb_driver sd_driver = {
1205 .name = MODULE_NAME,
1206 .id_table = device_table,
1207 .probe = sd_probe,
1208 .disconnect = gspca_disconnect,
1209 #ifdef CONFIG_PM
1210 .suspend = gspca_suspend,
1211 .resume = gspca_resume,
1212 #endif
1213 };
1214
1215 /* -- module insert / remove -- */
1216 static int __init sd_mod_init(void)
1217 {
1218 return usb_register(&sd_driver);
1219 }
1220 static void __exit sd_mod_exit(void)
1221 {
1222 usb_deregister(&sd_driver);
1223 }
1224
1225 module_init(sd_mod_init);
1226 module_exit(sd_mod_exit);
linux-next