?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[media] gspca: Use current logging styles
[pohmelfs.git] / drivers / media / video / gspca / mr97310a.c
blob473e813b680e4dd0c1440bfdcdbc765485d98a7b
1 /*
2 * Mars MR97310A library
3 *
4 * The original mr97310a driver, which supported the Aiptek Pencam VGA+, is
5 * Copyright (C) 2009 Kyle Guinn <elyk03@gmail.com>
6 *
7 * Support for the MR97310A cameras in addition to the Aiptek Pencam VGA+
8 * and for the routines for detecting and classifying these various cameras,
9 * is Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
10 *
11 * Support for the control settings for the CIF cameras is
12 * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com> and
13 * Thomas Kaiser <thomas@kaiser-linux.li>
14 *
15 * Support for the control settings for the VGA cameras is
16 * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
17 *
18 * Several previously unsupported cameras are owned and have been tested by
19 * Hans de Goede <hdegoede@redhat.com> and
20 * Thomas Kaiser <thomas@kaiser-linux.li> and
21 * Theodore Kilgore <kilgota@auburn.edu> and
22 * Edmond Rodriguez <erodrig_97@yahoo.com> and
23 * Aurelien Jacobs <aurel@gnuage.org>
24 *
25 * The MR97311A support in gspca/mars.c has been helpful in understanding some
26 * of the registers in these cameras.
27 *
28 * This program is free software; you can redistribute it and/or modify
29 * it under the terms of the GNU General Public License as published by
30 * the Free Software Foundation; either version 2 of the License, or
31 * any later version.
32 *
33 * This program is distributed in the hope that it will be useful,
34 * but WITHOUT ANY WARRANTY; without even the implied warranty of
35 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
36 * GNU General Public License for more details.
37 *
38 * You should have received a copy of the GNU General Public License
39 * along with this program; if not, write to the Free Software
40 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
41 */
42
43 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
44
45 #define MODULE_NAME "mr97310a"
46
47 #include "gspca.h"
48
49 #define CAM_TYPE_CIF 0
50 #define CAM_TYPE_VGA 1
51
52 #define MR97310A_BRIGHTNESS_DEFAULT 0
53
54 #define MR97310A_EXPOSURE_MIN 0
55 #define MR97310A_EXPOSURE_MAX 4095
56 #define MR97310A_EXPOSURE_DEFAULT 1000
57
58 #define MR97310A_GAIN_MIN 0
59 #define MR97310A_GAIN_MAX 31
60 #define MR97310A_GAIN_DEFAULT 25
61
62 #define MR97310A_CONTRAST_MIN 0
63 #define MR97310A_CONTRAST_MAX 31
64 #define MR97310A_CONTRAST_DEFAULT 23
65
66 #define MR97310A_CS_GAIN_MIN 0
67 #define MR97310A_CS_GAIN_MAX 0x7ff
68 #define MR97310A_CS_GAIN_DEFAULT 0x110
69
70 #define MR97310A_MIN_CLOCKDIV_MIN 3
71 #define MR97310A_MIN_CLOCKDIV_MAX 8
72 #define MR97310A_MIN_CLOCKDIV_DEFAULT 3
73
74 MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>,"
75 "Theodore Kilgore <kilgota@auburn.edu>");
76 MODULE_DESCRIPTION("GSPCA/Mars-Semi MR97310A USB Camera Driver");
77 MODULE_LICENSE("GPL");
78
79 /* global parameters */
80 static int force_sensor_type = -1;
81 module_param(force_sensor_type, int, 0644);
82 MODULE_PARM_DESC(force_sensor_type, "Force sensor type (-1 (auto), 0 or 1)");
83
84 /* specific webcam descriptor */
85 struct sd {
86 struct gspca_dev gspca_dev; /* !! must be the first item */
87 u8 sof_read;
88 u8 cam_type; /* 0 is CIF and 1 is VGA */
89 u8 sensor_type; /* We use 0 and 1 here, too. */
90 u8 do_lcd_stop;
91 u8 adj_colors;
92
93 int brightness;
94 u16 exposure;
95 u32 gain;
96 u8 contrast;
97 u8 min_clockdiv;
98 };
99
100 struct sensor_w_data {
101 u8 reg;
102 u8 flags;
103 u8 data[16];
104 int len;
105 };
106
107 static void sd_stopN(struct gspca_dev *gspca_dev);
108 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
109 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
110 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
111 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
112 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
113 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
114 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
115 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
116 static int sd_setmin_clockdiv(struct gspca_dev *gspca_dev, __s32 val);
117 static int sd_getmin_clockdiv(struct gspca_dev *gspca_dev, __s32 *val);
118 static void setbrightness(struct gspca_dev *gspca_dev);
119 static void setexposure(struct gspca_dev *gspca_dev);
120 static void setgain(struct gspca_dev *gspca_dev);
121 static void setcontrast(struct gspca_dev *gspca_dev);
122
123 /* V4L2 controls supported by the driver */
124 static const struct ctrl sd_ctrls[] = {
125 /* Separate brightness control description for Argus QuickClix as it has
126 * different limits from the other mr97310a cameras, and separate gain
127 * control for Sakar CyberPix camera. */
128 {
129 #define NORM_BRIGHTNESS_IDX 0
130 {
131 .id = V4L2_CID_BRIGHTNESS,
132 .type = V4L2_CTRL_TYPE_INTEGER,
133 .name = "Brightness",
134 .minimum = -254,
135 .maximum = 255,
136 .step = 1,
137 .default_value = MR97310A_BRIGHTNESS_DEFAULT,
138 .flags = 0,
139 },
140 .set = sd_setbrightness,
141 .get = sd_getbrightness,
142 },
143 {
144 #define ARGUS_QC_BRIGHTNESS_IDX 1
145 {
146 .id = V4L2_CID_BRIGHTNESS,
147 .type = V4L2_CTRL_TYPE_INTEGER,
148 .name = "Brightness",
149 .minimum = 0,
150 .maximum = 15,
151 .step = 1,
152 .default_value = MR97310A_BRIGHTNESS_DEFAULT,
153 .flags = 0,
154 },
155 .set = sd_setbrightness,
156 .get = sd_getbrightness,
157 },
158 {
159 #define EXPOSURE_IDX 2
160 {
161 .id = V4L2_CID_EXPOSURE,
162 .type = V4L2_CTRL_TYPE_INTEGER,
163 .name = "Exposure",
164 .minimum = MR97310A_EXPOSURE_MIN,
165 .maximum = MR97310A_EXPOSURE_MAX,
166 .step = 1,
167 .default_value = MR97310A_EXPOSURE_DEFAULT,
168 .flags = 0,
169 },
170 .set = sd_setexposure,
171 .get = sd_getexposure,
172 },
173 {
174 #define GAIN_IDX 3
175 {
176 .id = V4L2_CID_GAIN,
177 .type = V4L2_CTRL_TYPE_INTEGER,
178 .name = "Gain",
179 .minimum = MR97310A_GAIN_MIN,
180 .maximum = MR97310A_GAIN_MAX,
181 .step = 1,
182 .default_value = MR97310A_GAIN_DEFAULT,
183 .flags = 0,
184 },
185 .set = sd_setgain,
186 .get = sd_getgain,
187 },
188 {
189 #define SAKAR_CS_GAIN_IDX 4
190 {
191 .id = V4L2_CID_GAIN,
192 .type = V4L2_CTRL_TYPE_INTEGER,
193 .name = "Gain",
194 .minimum = MR97310A_CS_GAIN_MIN,
195 .maximum = MR97310A_CS_GAIN_MAX,
196 .step = 1,
197 .default_value = MR97310A_CS_GAIN_DEFAULT,
198 .flags = 0,
199 },
200 .set = sd_setgain,
201 .get = sd_getgain,
202 },
203 {
204 #define CONTRAST_IDX 5
205 {
206 .id = V4L2_CID_CONTRAST,
207 .type = V4L2_CTRL_TYPE_INTEGER,
208 .name = "Contrast",
209 .minimum = MR97310A_CONTRAST_MIN,
210 .maximum = MR97310A_CONTRAST_MAX,
211 .step = 1,
212 .default_value = MR97310A_CONTRAST_DEFAULT,
213 .flags = 0,
214 },
215 .set = sd_setcontrast,
216 .get = sd_getcontrast,
217 },
218 {
219 #define MIN_CLOCKDIV_IDX 6
220 {
221 .id = V4L2_CID_PRIVATE_BASE,
222 .type = V4L2_CTRL_TYPE_INTEGER,
223 .name = "Minimum Clock Divider",
224 .minimum = MR97310A_MIN_CLOCKDIV_MIN,
225 .maximum = MR97310A_MIN_CLOCKDIV_MAX,
226 .step = 1,
227 .default_value = MR97310A_MIN_CLOCKDIV_DEFAULT,
228 .flags = 0,
229 },
230 .set = sd_setmin_clockdiv,
231 .get = sd_getmin_clockdiv,
232 },
233 };
234
235 static const struct v4l2_pix_format vga_mode[] = {
236 {160, 120, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
237 .bytesperline = 160,
238 .sizeimage = 160 * 120,
239 .colorspace = V4L2_COLORSPACE_SRGB,
240 .priv = 4},
241 {176, 144, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
242 .bytesperline = 176,
243 .sizeimage = 176 * 144,
244 .colorspace = V4L2_COLORSPACE_SRGB,
245 .priv = 3},
246 {320, 240, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
247 .bytesperline = 320,
248 .sizeimage = 320 * 240,
249 .colorspace = V4L2_COLORSPACE_SRGB,
250 .priv = 2},
251 {352, 288, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
252 .bytesperline = 352,
253 .sizeimage = 352 * 288,
254 .colorspace = V4L2_COLORSPACE_SRGB,
255 .priv = 1},
256 {640, 480, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
257 .bytesperline = 640,
258 .sizeimage = 640 * 480,
259 .colorspace = V4L2_COLORSPACE_SRGB,
260 .priv = 0},
261 };
262
263 /* the bytes to write are in gspca_dev->usb_buf */
264 static int mr_write(struct gspca_dev *gspca_dev, int len)
265 {
266 int rc;
267
268 rc = usb_bulk_msg(gspca_dev->dev,
269 usb_sndbulkpipe(gspca_dev->dev, 4),
270 gspca_dev->usb_buf, len, NULL, 500);
271 if (rc < 0)
272 pr_err("reg write [%02x] error %d\n",
273 gspca_dev->usb_buf[0], rc);
274 return rc;
275 }
276
277 /* the bytes are read into gspca_dev->usb_buf */
278 static int mr_read(struct gspca_dev *gspca_dev, int len)
279 {
280 int rc;
281
282 rc = usb_bulk_msg(gspca_dev->dev,
283 usb_rcvbulkpipe(gspca_dev->dev, 3),
284 gspca_dev->usb_buf, len, NULL, 500);
285 if (rc < 0)
286 pr_err("reg read [%02x] error %d\n",
287 gspca_dev->usb_buf[0], rc);
288 return rc;
289 }
290
291 static int sensor_write_reg(struct gspca_dev *gspca_dev, u8 reg, u8 flags,
292 const u8 *data, int len)
293 {
294 gspca_dev->usb_buf[0] = 0x1f;
295 gspca_dev->usb_buf[1] = flags;
296 gspca_dev->usb_buf[2] = reg;
297 memcpy(gspca_dev->usb_buf + 3, data, len);
298
299 return mr_write(gspca_dev, len + 3);
300 }
301
302 static int sensor_write_regs(struct gspca_dev *gspca_dev,
303 const struct sensor_w_data *data, int len)
304 {
305 int i, rc;
306
307 for (i = 0; i < len; i++) {
308 rc = sensor_write_reg(gspca_dev, data[i].reg, data[i].flags,
309 data[i].data, data[i].len);
310 if (rc < 0)
311 return rc;
312 }
313
314 return 0;
315 }
316
317 static int sensor_write1(struct gspca_dev *gspca_dev, u8 reg, u8 data)
318 {
319 struct sd *sd = (struct sd *) gspca_dev;
320 u8 buf, confirm_reg;
321 int rc;
322
323 buf = data;
324 if (sd->cam_type == CAM_TYPE_CIF) {
325 rc = sensor_write_reg(gspca_dev, reg, 0x01, &buf, 1);
326 confirm_reg = sd->sensor_type ? 0x13 : 0x11;
327 } else {
328 rc = sensor_write_reg(gspca_dev, reg, 0x00, &buf, 1);
329 confirm_reg = 0x11;
330 }
331 if (rc < 0)
332 return rc;
333
334 buf = 0x01;
335 rc = sensor_write_reg(gspca_dev, confirm_reg, 0x00, &buf, 1);
336 if (rc < 0)
337 return rc;
338
339 return 0;
340 }
341
342 static int cam_get_response16(struct gspca_dev *gspca_dev, u8 reg, int verbose)
343 {
344 int err_code;
345
346 gspca_dev->usb_buf[0] = reg;
347 err_code = mr_write(gspca_dev, 1);
348 if (err_code < 0)
349 return err_code;
350
351 err_code = mr_read(gspca_dev, 16);
352 if (err_code < 0)
353 return err_code;
354
355 if (verbose)
356 PDEBUG(D_PROBE, "Register: %02x reads %02x%02x%02x", reg,
357 gspca_dev->usb_buf[0],
358 gspca_dev->usb_buf[1],
359 gspca_dev->usb_buf[2]);
360
361 return 0;
362 }
363
364 static int zero_the_pointer(struct gspca_dev *gspca_dev)
365 {
366 __u8 *data = gspca_dev->usb_buf;
367 int err_code;
368 u8 status = 0;
369 int tries = 0;
370
371 err_code = cam_get_response16(gspca_dev, 0x21, 0);
372 if (err_code < 0)
373 return err_code;
374
375 data[0] = 0x19;
376 data[1] = 0x51;
377 err_code = mr_write(gspca_dev, 2);
378 if (err_code < 0)
379 return err_code;
380
381 err_code = cam_get_response16(gspca_dev, 0x21, 0);
382 if (err_code < 0)
383 return err_code;
384
385 data[0] = 0x19;
386 data[1] = 0xba;
387 err_code = mr_write(gspca_dev, 2);
388 if (err_code < 0)
389 return err_code;
390
391 err_code = cam_get_response16(gspca_dev, 0x21, 0);
392 if (err_code < 0)
393 return err_code;
394
395 data[0] = 0x19;
396 data[1] = 0x00;
397 err_code = mr_write(gspca_dev, 2);
398 if (err_code < 0)
399 return err_code;
400
401 err_code = cam_get_response16(gspca_dev, 0x21, 0);
402 if (err_code < 0)
403 return err_code;
404
405 data[0] = 0x19;
406 data[1] = 0x00;
407 err_code = mr_write(gspca_dev, 2);
408 if (err_code < 0)
409 return err_code;
410
411 while (status != 0x0a && tries < 256) {
412 err_code = cam_get_response16(gspca_dev, 0x21, 0);
413 status = data[0];
414 tries++;
415 if (err_code < 0)
416 return err_code;
417 }
418 if (status != 0x0a)
419 PDEBUG(D_ERR, "status is %02x", status);
420
421 tries = 0;
422 while (tries < 4) {
423 data[0] = 0x19;
424 data[1] = 0x00;
425 err_code = mr_write(gspca_dev, 2);
426 if (err_code < 0)
427 return err_code;
428
429 err_code = cam_get_response16(gspca_dev, 0x21, 0);
430 status = data[0];
431 tries++;
432 if (err_code < 0)
433 return err_code;
434 }
435
436 data[0] = 0x19;
437 err_code = mr_write(gspca_dev, 1);
438 if (err_code < 0)
439 return err_code;
440
441 err_code = mr_read(gspca_dev, 16);
442 if (err_code < 0)
443 return err_code;
444
445 return 0;
446 }
447
448 static int stream_start(struct gspca_dev *gspca_dev)
449 {
450 gspca_dev->usb_buf[0] = 0x01;
451 gspca_dev->usb_buf[1] = 0x01;
452 return mr_write(gspca_dev, 2);
453 }
454
455 static void stream_stop(struct gspca_dev *gspca_dev)
456 {
457 gspca_dev->usb_buf[0] = 0x01;
458 gspca_dev->usb_buf[1] = 0x00;
459 if (mr_write(gspca_dev, 2) < 0)
460 PDEBUG(D_ERR, "Stream Stop failed");
461 }
462
463 static void lcd_stop(struct gspca_dev *gspca_dev)
464 {
465 gspca_dev->usb_buf[0] = 0x19;
466 gspca_dev->usb_buf[1] = 0x54;
467 if (mr_write(gspca_dev, 2) < 0)
468 PDEBUG(D_ERR, "LCD Stop failed");
469 }
470
471 static int isoc_enable(struct gspca_dev *gspca_dev)
472 {
473 gspca_dev->usb_buf[0] = 0x00;
474 gspca_dev->usb_buf[1] = 0x4d; /* ISOC transferring enable... */
475 return mr_write(gspca_dev, 2);
476 }
477
478 /* This function is called at probe time */
479 static int sd_config(struct gspca_dev *gspca_dev,
480 const struct usb_device_id *id)
481 {
482 struct sd *sd = (struct sd *) gspca_dev;
483 struct cam *cam;
484 int gain_default = MR97310A_GAIN_DEFAULT;
485 int err_code;
486
487 cam = &gspca_dev->cam;
488 cam->cam_mode = vga_mode;
489 cam->nmodes = ARRAY_SIZE(vga_mode);
490 sd->do_lcd_stop = 0;
491
492 /* Several of the supported CIF cameras share the same USB ID but
493 * require different initializations and different control settings.
494 * The same is true of the VGA cameras. Therefore, we are forced
495 * to start the initialization process in order to determine which
496 * camera is present. Some of the supported cameras require the
497 * memory pointer to be set to 0 as the very first item of business
498 * or else they will not stream. So we do that immediately.
499 */
500 err_code = zero_the_pointer(gspca_dev);
501 if (err_code < 0)
502 return err_code;
503
504 err_code = stream_start(gspca_dev);
505 if (err_code < 0)
506 return err_code;
507
508 /* Now, the query for sensor type. */
509 err_code = cam_get_response16(gspca_dev, 0x07, 1);
510 if (err_code < 0)
511 return err_code;
512
513 if (id->idProduct == 0x0110 || id->idProduct == 0x010e) {
514 sd->cam_type = CAM_TYPE_CIF;
515 cam->nmodes--;
516 /*
517 * All but one of the known CIF cameras share the same USB ID,
518 * but two different init routines are in use, and the control
519 * settings are different, too. We need to detect which camera
520 * of the two known varieties is connected!
521 *
522 * A list of known CIF cameras follows. They all report either
523 * 0200 for type 0 or 0300 for type 1.
524 * If you have another to report, please do
525 *
526 * Name sd->sensor_type reported by
527 *
528 * Sakar 56379 Spy-shot 0 T. Kilgore
529 * Innovage 0 T. Kilgore
530 * Vivitar Mini 0 H. De Goede
531 * Vivitar Mini 0 E. Rodriguez
532 * Vivitar Mini 1 T. Kilgore
533 * Elta-Media 8212dc 1 T. Kaiser
534 * Philips dig. keych. 1 T. Kilgore
535 * Trust Spyc@m 100 1 A. Jacobs
536 */
537 switch (gspca_dev->usb_buf[0]) {
538 case 2:
539 sd->sensor_type = 0;
540 break;
541 case 3:
542 sd->sensor_type = 1;
543 break;
544 default:
545 pr_err("Unknown CIF Sensor id : %02x\n",
546 gspca_dev->usb_buf[1]);
547 return -ENODEV;
548 }
549 PDEBUG(D_PROBE, "MR97310A CIF camera detected, sensor: %d",
550 sd->sensor_type);
551 } else {
552 sd->cam_type = CAM_TYPE_VGA;
553
554 /*
555 * Here is a table of the responses to the query for sensor
556 * type, from the known MR97310A VGA cameras. Six different
557 * cameras of which five share the same USB ID.
558 *
559 * Name gspca_dev->usb_buf[] sd->sensor_type
560 * sd->do_lcd_stop
561 * Aiptek Pencam VGA+ 0300 0 1
562 * ION digital 0300 0 1
563 * Argus DC-1620 0450 1 0
564 * Argus QuickClix 0420 1 1
565 * Sakar 77379 Digital 0350 0 1
566 * Sakar 1638x CyberPix 0120 0 2
567 *
568 * Based upon these results, we assume default settings
569 * and then correct as necessary, as follows.
570 *
571 */
572
573 sd->sensor_type = 1;
574 sd->do_lcd_stop = 0;
575 sd->adj_colors = 0;
576 if (gspca_dev->usb_buf[0] == 0x01) {
577 sd->sensor_type = 2;
578 } else if ((gspca_dev->usb_buf[0] != 0x03) &&
579 (gspca_dev->usb_buf[0] != 0x04)) {
580 pr_err("Unknown VGA Sensor id Byte 0: %02x\n",
581 gspca_dev->usb_buf[0]);
582 pr_err("Defaults assumed, may not work\n");
583 pr_err("Please report this\n");
584 }
585 /* Sakar Digital color needs to be adjusted. */
586 if ((gspca_dev->usb_buf[0] == 0x03) &&
587 (gspca_dev->usb_buf[1] == 0x50))
588 sd->adj_colors = 1;
589 if (gspca_dev->usb_buf[0] == 0x04) {
590 sd->do_lcd_stop = 1;
591 switch (gspca_dev->usb_buf[1]) {
592 case 0x50:
593 sd->sensor_type = 0;
594 PDEBUG(D_PROBE, "sensor_type corrected to 0");
595 break;
596 case 0x20:
597 /* Nothing to do here. */
598 break;
599 default:
600 pr_err("Unknown VGA Sensor id Byte 1: %02x\n",
601 gspca_dev->usb_buf[1]);
602 pr_err("Defaults assumed, may not work\n");
603 pr_err("Please report this\n");
604 }
605 }
606 PDEBUG(D_PROBE, "MR97310A VGA camera detected, sensor: %d",
607 sd->sensor_type);
608 }
609 /* Stop streaming as we've started it only to probe the sensor type. */
610 sd_stopN(gspca_dev);
611
612 if (force_sensor_type != -1) {
613 sd->sensor_type = !!force_sensor_type;
614 PDEBUG(D_PROBE, "Forcing sensor type to: %d",
615 sd->sensor_type);
616 }
617
618 /* Setup controls depending on camera type */
619 if (sd->cam_type == CAM_TYPE_CIF) {
620 /* No brightness for sensor_type 0 */
621 if (sd->sensor_type == 0)
622 gspca_dev->ctrl_dis = (1 << NORM_BRIGHTNESS_IDX) |
623 (1 << ARGUS_QC_BRIGHTNESS_IDX) |
624 (1 << CONTRAST_IDX) |
625 (1 << SAKAR_CS_GAIN_IDX);
626 else
627 gspca_dev->ctrl_dis = (1 << ARGUS_QC_BRIGHTNESS_IDX) |
628 (1 << CONTRAST_IDX) |
629 (1 << SAKAR_CS_GAIN_IDX) |
630 (1 << MIN_CLOCKDIV_IDX);
631 } else {
632 /* All controls need to be disabled if VGA sensor_type is 0 */
633 if (sd->sensor_type == 0)
634 gspca_dev->ctrl_dis = (1 << NORM_BRIGHTNESS_IDX) |
635 (1 << ARGUS_QC_BRIGHTNESS_IDX) |
636 (1 << EXPOSURE_IDX) |
637 (1 << GAIN_IDX) |
638 (1 << CONTRAST_IDX) |
639 (1 << SAKAR_CS_GAIN_IDX) |
640 (1 << MIN_CLOCKDIV_IDX);
641 else if (sd->sensor_type == 2) {
642 gspca_dev->ctrl_dis = (1 << NORM_BRIGHTNESS_IDX) |
643 (1 << ARGUS_QC_BRIGHTNESS_IDX) |
644 (1 << GAIN_IDX) |
645 (1 << MIN_CLOCKDIV_IDX);
646 gain_default = MR97310A_CS_GAIN_DEFAULT;
647 } else if (sd->do_lcd_stop)
648 /* Argus QuickClix has different brightness limits */
649 gspca_dev->ctrl_dis = (1 << NORM_BRIGHTNESS_IDX) |
650 (1 << CONTRAST_IDX) |
651 (1 << SAKAR_CS_GAIN_IDX);
652 else
653 gspca_dev->ctrl_dis = (1 << ARGUS_QC_BRIGHTNESS_IDX) |
654 (1 << CONTRAST_IDX) |
655 (1 << SAKAR_CS_GAIN_IDX);
656 }
657
658 sd->brightness = MR97310A_BRIGHTNESS_DEFAULT;
659 sd->exposure = MR97310A_EXPOSURE_DEFAULT;
660 sd->gain = gain_default;
661 sd->contrast = MR97310A_CONTRAST_DEFAULT;
662 sd->min_clockdiv = MR97310A_MIN_CLOCKDIV_DEFAULT;
663
664 return 0;
665 }
666
667 /* this function is called at probe and resume time */
668 static int sd_init(struct gspca_dev *gspca_dev)
669 {
670 return 0;
671 }
672
673 static int start_cif_cam(struct gspca_dev *gspca_dev)
674 {
675 struct sd *sd = (struct sd *) gspca_dev;
676 __u8 *data = gspca_dev->usb_buf;
677 int err_code;
678 static const __u8 startup_string[] = {
679 0x00,
680 0x0d,
681 0x01,
682 0x00, /* Hsize/8 for 352 or 320 */
683 0x00, /* Vsize/4 for 288 or 240 */
684 0x13, /* or 0xbb, depends on sensor */
685 0x00, /* Hstart, depends on res. */
686 0x00, /* reserved ? */
687 0x00, /* Vstart, depends on res. and sensor */
688 0x50, /* 0x54 to get 176 or 160 */
689 0xc0
690 };
691
692 /* Note: Some of the above descriptions guessed from MR97113A driver */
693
694 memcpy(data, startup_string, 11);
695 if (sd->sensor_type)
696 data[5] = 0xbb;
697
698 switch (gspca_dev->width) {
699 case 160:
700 data[9] |= 0x04; /* reg 8, 2:1 scale down from 320 */
701 /* fall thru */
702 case 320:
703 default:
704 data[3] = 0x28; /* reg 2, H size/8 */
705 data[4] = 0x3c; /* reg 3, V size/4 */
706 data[6] = 0x14; /* reg 5, H start */
707 data[8] = 0x1a + sd->sensor_type; /* reg 7, V start */
708 break;
709 case 176:
710 data[9] |= 0x04; /* reg 8, 2:1 scale down from 352 */
711 /* fall thru */
712 case 352:
713 data[3] = 0x2c; /* reg 2, H size/8 */
714 data[4] = 0x48; /* reg 3, V size/4 */
715 data[6] = 0x06; /* reg 5, H start */
716 data[8] = 0x06 - sd->sensor_type; /* reg 7, V start */
717 break;
718 }
719 err_code = mr_write(gspca_dev, 11);
720 if (err_code < 0)
721 return err_code;
722
723 if (!sd->sensor_type) {
724 static const struct sensor_w_data cif_sensor0_init_data[] = {
725 {0x02, 0x00, {0x03, 0x5a, 0xb5, 0x01,
726 0x0f, 0x14, 0x0f, 0x10}, 8},
727 {0x0c, 0x00, {0x04, 0x01, 0x01, 0x00, 0x1f}, 5},
728 {0x12, 0x00, {0x07}, 1},
729 {0x1f, 0x00, {0x06}, 1},
730 {0x27, 0x00, {0x04}, 1},
731 {0x29, 0x00, {0x0c}, 1},
732 {0x40, 0x00, {0x40, 0x00, 0x04}, 3},
733 {0x50, 0x00, {0x60}, 1},
734 {0x60, 0x00, {0x06}, 1},
735 {0x6b, 0x00, {0x85, 0x85, 0xc8, 0xc8, 0xc8, 0xc8}, 6},
736 {0x72, 0x00, {0x1e, 0x56}, 2},
737 {0x75, 0x00, {0x58, 0x40, 0xa2, 0x02, 0x31, 0x02,
738 0x31, 0x80, 0x00}, 9},
739 {0x11, 0x00, {0x01}, 1},
740 {0, 0, {0}, 0}
741 };
742 err_code = sensor_write_regs(gspca_dev, cif_sensor0_init_data,
743 ARRAY_SIZE(cif_sensor0_init_data));
744 } else { /* sd->sensor_type = 1 */
745 static const struct sensor_w_data cif_sensor1_init_data[] = {
746 /* Reg 3,4, 7,8 get set by the controls */
747 {0x02, 0x00, {0x10}, 1},
748 {0x05, 0x01, {0x22}, 1}, /* 5/6 also seen as 65h/32h */
749 {0x06, 0x01, {0x00}, 1},
750 {0x09, 0x02, {0x0e}, 1},
751 {0x0a, 0x02, {0x05}, 1},
752 {0x0b, 0x02, {0x05}, 1},
753 {0x0c, 0x02, {0x0f}, 1},
754 {0x0d, 0x02, {0x07}, 1},
755 {0x0e, 0x02, {0x0c}, 1},
756 {0x0f, 0x00, {0x00}, 1},
757 {0x10, 0x00, {0x06}, 1},
758 {0x11, 0x00, {0x07}, 1},
759 {0x12, 0x00, {0x00}, 1},
760 {0x13, 0x00, {0x01}, 1},
761 {0, 0, {0}, 0}
762 };
763 /* Without this command the cam won't work with USB-UHCI */
764 gspca_dev->usb_buf[0] = 0x0a;
765 gspca_dev->usb_buf[1] = 0x00;
766 err_code = mr_write(gspca_dev, 2);
767 if (err_code < 0)
768 return err_code;
769 err_code = sensor_write_regs(gspca_dev, cif_sensor1_init_data,
770 ARRAY_SIZE(cif_sensor1_init_data));
771 }
772 return err_code;
773 }
774
775 static int start_vga_cam(struct gspca_dev *gspca_dev)
776 {
777 struct sd *sd = (struct sd *) gspca_dev;
778 __u8 *data = gspca_dev->usb_buf;
779 int err_code;
780 static const __u8 startup_string[] =
781 {0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b, 0x00, 0x00,
782 0x00, 0x50, 0xc0};
783 /* What some of these mean is explained in start_cif_cam(), above */
784
785 memcpy(data, startup_string, 11);
786 if (!sd->sensor_type) {
787 data[5] = 0x00;
788 data[10] = 0x91;
789 }
790 if (sd->sensor_type == 2) {
791 data[5] = 0x00;
792 data[10] = 0x18;
793 }
794
795 switch (gspca_dev->width) {
796 case 160:
797 data[9] |= 0x0c; /* reg 8, 4:1 scale down */
798 /* fall thru */
799 case 320:
800 data[9] |= 0x04; /* reg 8, 2:1 scale down */
801 /* fall thru */
802 case 640:
803 default:
804 data[3] = 0x50; /* reg 2, H size/8 */
805 data[4] = 0x78; /* reg 3, V size/4 */
806 data[6] = 0x04; /* reg 5, H start */
807 data[8] = 0x03; /* reg 7, V start */
808 if (sd->sensor_type == 2) {
809 data[6] = 2;
810 data[8] = 1;
811 }
812 if (sd->do_lcd_stop)
813 data[8] = 0x04; /* Bayer tile shifted */
814 break;
815
816 case 176:
817 data[9] |= 0x04; /* reg 8, 2:1 scale down */
818 /* fall thru */
819 case 352:
820 data[3] = 0x2c; /* reg 2, H size */
821 data[4] = 0x48; /* reg 3, V size */
822 data[6] = 0x94; /* reg 5, H start */
823 data[8] = 0x63; /* reg 7, V start */
824 if (sd->do_lcd_stop)
825 data[8] = 0x64; /* Bayer tile shifted */
826 break;
827 }
828
829 err_code = mr_write(gspca_dev, 11);
830 if (err_code < 0)
831 return err_code;
832
833 if (!sd->sensor_type) {
834 static const struct sensor_w_data vga_sensor0_init_data[] = {
835 {0x01, 0x00, {0x0c, 0x00, 0x04}, 3},
836 {0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4},
837 {0x20, 0x00, {0x00, 0x80, 0x00, 0x08}, 4},
838 {0x25, 0x00, {0x03, 0xa9, 0x80}, 3},
839 {0x30, 0x00, {0x30, 0x18, 0x10, 0x18}, 4},
840 {0, 0, {0}, 0}
841 };
842 err_code = sensor_write_regs(gspca_dev, vga_sensor0_init_data,
843 ARRAY_SIZE(vga_sensor0_init_data));
844 } else if (sd->sensor_type == 1) {
845 static const struct sensor_w_data color_adj[] = {
846 {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
847 /* adjusted blue, green, red gain correct
848 too much blue from the Sakar Digital */
849 0x05, 0x01, 0x04}, 8}
850 };
851
852 static const struct sensor_w_data color_no_adj[] = {
853 {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
854 /* default blue, green, red gain settings */
855 0x07, 0x00, 0x01}, 8}
856 };
857
858 static const struct sensor_w_data vga_sensor1_init_data[] = {
859 {0x11, 0x04, {0x01}, 1},
860 {0x0a, 0x00, {0x00, 0x01, 0x00, 0x00, 0x01,
861 /* These settings may be better for some cameras */
862 /* {0x0a, 0x00, {0x01, 0x06, 0x00, 0x00, 0x01, */
863 0x00, 0x0a}, 7},
864 {0x11, 0x04, {0x01}, 1},
865 {0x12, 0x00, {0x00, 0x63, 0x00, 0x70, 0x00, 0x00}, 6},
866 {0x11, 0x04, {0x01}, 1},
867 {0, 0, {0}, 0}
868 };
869
870 if (sd->adj_colors)
871 err_code = sensor_write_regs(gspca_dev, color_adj,
872 ARRAY_SIZE(color_adj));
873 else
874 err_code = sensor_write_regs(gspca_dev, color_no_adj,
875 ARRAY_SIZE(color_no_adj));
876
877 if (err_code < 0)
878 return err_code;
879
880 err_code = sensor_write_regs(gspca_dev, vga_sensor1_init_data,
881 ARRAY_SIZE(vga_sensor1_init_data));
882 } else { /* sensor type == 2 */
883 static const struct sensor_w_data vga_sensor2_init_data[] = {
884
885 {0x01, 0x00, {0x48}, 1},
886 {0x02, 0x00, {0x22}, 1},
887 /* Reg 3 msb and 4 is lsb of the exposure setting*/
888 {0x05, 0x00, {0x10}, 1},
889 {0x06, 0x00, {0x00}, 1},
890 {0x07, 0x00, {0x00}, 1},
891 {0x08, 0x00, {0x00}, 1},
892 {0x09, 0x00, {0x00}, 1},
893 /* The following are used in the gain control
894 * which is BTW completely borked in the OEM driver
895 * The values for each color go from 0 to 0x7ff
896 *{0x0a, 0x00, {0x01}, 1}, green1 gain msb
897 *{0x0b, 0x00, {0x10}, 1}, green1 gain lsb
898 *{0x0c, 0x00, {0x01}, 1}, red gain msb
899 *{0x0d, 0x00, {0x10}, 1}, red gain lsb
900 *{0x0e, 0x00, {0x01}, 1}, blue gain msb
901 *{0x0f, 0x00, {0x10}, 1}, blue gain lsb
902 *{0x10, 0x00, {0x01}, 1}, green2 gain msb
903 *{0x11, 0x00, {0x10}, 1}, green2 gain lsb
904 */
905 {0x12, 0x00, {0x00}, 1},
906 {0x13, 0x00, {0x04}, 1}, /* weird effect on colors */
907 {0x14, 0x00, {0x00}, 1},
908 {0x15, 0x00, {0x06}, 1},
909 {0x16, 0x00, {0x01}, 1},
910 {0x17, 0x00, {0xe2}, 1}, /* vertical alignment */
911 {0x18, 0x00, {0x02}, 1},
912 {0x19, 0x00, {0x82}, 1}, /* don't mess with */
913 {0x1a, 0x00, {0x00}, 1},
914 {0x1b, 0x00, {0x20}, 1},
915 /* {0x1c, 0x00, {0x17}, 1}, contrast control */
916 {0x1d, 0x00, {0x80}, 1}, /* moving causes a mess */
917 {0x1e, 0x00, {0x08}, 1}, /* moving jams the camera */
918 {0x1f, 0x00, {0x0c}, 1},
919 {0x20, 0x00, {0x00}, 1},
920 {0, 0, {0}, 0}
921 };
922 err_code = sensor_write_regs(gspca_dev, vga_sensor2_init_data,
923 ARRAY_SIZE(vga_sensor2_init_data));
924 }
925 return err_code;
926 }
927
928 static int sd_start(struct gspca_dev *gspca_dev)
929 {
930 struct sd *sd = (struct sd *) gspca_dev;
931 int err_code;
932
933 sd->sof_read = 0;
934
935 /* Some of the VGA cameras require the memory pointer
936 * to be set to 0 again. We have been forced to start the
937 * stream in sd_config() to detect the hardware, and closed it.
938 * Thus, we need here to do a completely fresh and clean start. */
939 err_code = zero_the_pointer(gspca_dev);
940 if (err_code < 0)
941 return err_code;
942
943 err_code = stream_start(gspca_dev);
944 if (err_code < 0)
945 return err_code;
946
947 if (sd->cam_type == CAM_TYPE_CIF) {
948 err_code = start_cif_cam(gspca_dev);
949 } else {
950 err_code = start_vga_cam(gspca_dev);
951 }
952 if (err_code < 0)
953 return err_code;
954
955 setbrightness(gspca_dev);
956 setcontrast(gspca_dev);
957 setexposure(gspca_dev);
958 setgain(gspca_dev);
959
960 return isoc_enable(gspca_dev);
961 }
962
963 static void sd_stopN(struct gspca_dev *gspca_dev)
964 {
965 struct sd *sd = (struct sd *) gspca_dev;
966
967 stream_stop(gspca_dev);
968 /* Not all the cams need this, but even if not, probably a good idea */
969 zero_the_pointer(gspca_dev);
970 if (sd->do_lcd_stop)
971 lcd_stop(gspca_dev);
972 }
973
974 static void setbrightness(struct gspca_dev *gspca_dev)
975 {
976 struct sd *sd = (struct sd *) gspca_dev;
977 u8 val;
978 u8 sign_reg = 7; /* This reg and the next one used on CIF cams. */
979 u8 value_reg = 8; /* VGA cams seem to use regs 0x0b and 0x0c */
980 static const u8 quick_clix_table[] =
981 /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
982 { 0, 4, 8, 12, 1, 2, 3, 5, 6, 9, 7, 10, 13, 11, 14, 15};
983 /*
984 * This control is disabled for CIF type 1 and VGA type 0 cameras.
985 * It does not quite act linearly for the Argus QuickClix camera,
986 * but it does control brightness. The values are 0 - 15 only, and
987 * the table above makes them act consecutively.
988 */
989 if ((gspca_dev->ctrl_dis & (1 << NORM_BRIGHTNESS_IDX)) &&
990 (gspca_dev->ctrl_dis & (1 << ARGUS_QC_BRIGHTNESS_IDX)))
991 return;
992
993 if (sd->cam_type == CAM_TYPE_VGA) {
994 sign_reg += 4;
995 value_reg += 4;
996 }
997
998 /* Note register 7 is also seen as 0x8x or 0xCx in some dumps */
999 if (sd->brightness > 0) {
1000 sensor_write1(gspca_dev, sign_reg, 0x00);
1001 val = sd->brightness;
1002 } else {
1003 sensor_write1(gspca_dev, sign_reg, 0x01);
1004 val = (257 - sd->brightness);
1005 }
1006 /* Use lookup table for funky Argus QuickClix brightness */
1007 if (sd->do_lcd_stop)
1008 val = quick_clix_table[val];
1009
1010 sensor_write1(gspca_dev, value_reg, val);
1011 }
1012
1013 static void setexposure(struct gspca_dev *gspca_dev)
1014 {
1015 struct sd *sd = (struct sd *) gspca_dev;
1016 int exposure = MR97310A_EXPOSURE_DEFAULT;
1017 u8 buf[2];
1018
1019 if (gspca_dev->ctrl_dis & (1 << EXPOSURE_IDX))
1020 return;
1021
1022 if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1) {
1023 /* This cam does not like exposure settings < 300,
1024 so scale 0 - 4095 to 300 - 4095 */
1025 exposure = (sd->exposure * 9267) / 10000 + 300;
1026 sensor_write1(gspca_dev, 3, exposure >> 4);
1027 sensor_write1(gspca_dev, 4, exposure & 0x0f);
1028 } else if (sd->sensor_type == 2) {
1029 exposure = sd->exposure;
1030 exposure >>= 3;
1031 sensor_write1(gspca_dev, 3, exposure >> 8);
1032 sensor_write1(gspca_dev, 4, exposure & 0xff);
1033 } else {
1034 /* We have both a clock divider and an exposure register.
1035 We first calculate the clock divider, as that determines
1036 the maximum exposure and then we calculate the exposure
1037 register setting (which goes from 0 - 511).
1038
1039 Note our 0 - 4095 exposure is mapped to 0 - 511
1040 milliseconds exposure time */
1041 u8 clockdiv = (60 * sd->exposure + 7999) / 8000;
1042
1043 /* Limit framerate to not exceed usb bandwidth */
1044 if (clockdiv < sd->min_clockdiv && gspca_dev->width >= 320)
1045 clockdiv = sd->min_clockdiv;
1046 else if (clockdiv < 2)
1047 clockdiv = 2;
1048
1049 if (sd->cam_type == CAM_TYPE_VGA && clockdiv < 4)
1050 clockdiv = 4;
1051
1052 /* Frame exposure time in ms = 1000 * clockdiv / 60 ->
1053 exposure = (sd->exposure / 8) * 511 / (1000 * clockdiv / 60) */
1054 exposure = (60 * 511 * sd->exposure) / (8000 * clockdiv);
1055 if (exposure > 511)
1056 exposure = 511;
1057
1058 /* exposure register value is reversed! */
1059 exposure = 511 - exposure;
1060
1061 buf[0] = exposure & 0xff;
1062 buf[1] = exposure >> 8;
1063 sensor_write_reg(gspca_dev, 0x0e, 0, buf, 2);
1064 sensor_write1(gspca_dev, 0x02, clockdiv);
1065 }
1066 }
1067
1068 static void setgain(struct gspca_dev *gspca_dev)
1069 {
1070 struct sd *sd = (struct sd *) gspca_dev;
1071 u8 gainreg;
1072
1073 if ((gspca_dev->ctrl_dis & (1 << GAIN_IDX)) &&
1074 (gspca_dev->ctrl_dis & (1 << SAKAR_CS_GAIN_IDX)))
1075 return;
1076
1077 if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1)
1078 sensor_write1(gspca_dev, 0x0e, sd->gain);
1079 else if (sd->cam_type == CAM_TYPE_VGA && sd->sensor_type == 2)
1080 for (gainreg = 0x0a; gainreg < 0x11; gainreg += 2) {
1081 sensor_write1(gspca_dev, gainreg, sd->gain >> 8);
1082 sensor_write1(gspca_dev, gainreg + 1, sd->gain & 0xff);
1083 }
1084 else
1085 sensor_write1(gspca_dev, 0x10, sd->gain);
1086 }
1087
1088 static void setcontrast(struct gspca_dev *gspca_dev)
1089 {
1090 struct sd *sd = (struct sd *) gspca_dev;
1091
1092 if (gspca_dev->ctrl_dis & (1 << CONTRAST_IDX))
1093 return;
1094
1095 sensor_write1(gspca_dev, 0x1c, sd->contrast);
1096 }
1097
1098
1099 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1100 {
1101 struct sd *sd = (struct sd *) gspca_dev;
1102
1103 sd->brightness = val;
1104 if (gspca_dev->streaming)
1105 setbrightness(gspca_dev);
1106 return 0;
1107 }
1108
1109 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1110 {
1111 struct sd *sd = (struct sd *) gspca_dev;
1112
1113 *val = sd->brightness;
1114 return 0;
1115 }
1116
1117 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1118 {
1119 struct sd *sd = (struct sd *) gspca_dev;
1120
1121 sd->exposure = val;
1122 if (gspca_dev->streaming)
1123 setexposure(gspca_dev);
1124 return 0;
1125 }
1126
1127 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1128 {
1129 struct sd *sd = (struct sd *) gspca_dev;
1130
1131 *val = sd->exposure;
1132 return 0;
1133 }
1134
1135 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1136 {
1137 struct sd *sd = (struct sd *) gspca_dev;
1138
1139 sd->gain = val;
1140 if (gspca_dev->streaming)
1141 setgain(gspca_dev);
1142 return 0;
1143 }
1144
1145 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1146 {
1147 struct sd *sd = (struct sd *) gspca_dev;
1148
1149 *val = sd->gain;
1150 return 0;
1151 }
1152
1153 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1154 {
1155 struct sd *sd = (struct sd *) gspca_dev;
1156
1157 sd->contrast = val;
1158 if (gspca_dev->streaming)
1159 setcontrast(gspca_dev);
1160 return 0;
1161 }
1162
1163
1164 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1165 {
1166 struct sd *sd = (struct sd *) gspca_dev;
1167
1168 *val = sd->contrast;
1169 return 0;
1170 }
1171
1172 static int sd_setmin_clockdiv(struct gspca_dev *gspca_dev, __s32 val)
1173 {
1174 struct sd *sd = (struct sd *) gspca_dev;
1175
1176 sd->min_clockdiv = val;
1177 if (gspca_dev->streaming)
1178 setexposure(gspca_dev);
1179 return 0;
1180 }
1181
1182 static int sd_getmin_clockdiv(struct gspca_dev *gspca_dev, __s32 *val)
1183 {
1184 struct sd *sd = (struct sd *) gspca_dev;
1185
1186 *val = sd->min_clockdiv;
1187 return 0;
1188 }
1189
1190 /* Include pac common sof detection functions */
1191 #include "pac_common.h"
1192
1193 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1194 u8 *data, /* isoc packet */
1195 int len) /* iso packet length */
1196 {
1197 struct sd *sd = (struct sd *) gspca_dev;
1198 unsigned char *sof;
1199
1200 sof = pac_find_sof(&sd->sof_read, data, len);
1201 if (sof) {
1202 int n;
1203
1204 /* finish decoding current frame */
1205 n = sof - data;
1206 if (n > sizeof pac_sof_marker)
1207 n -= sizeof pac_sof_marker;
1208 else
1209 n = 0;
1210 gspca_frame_add(gspca_dev, LAST_PACKET,
1211 data, n);
1212 /* Start next frame. */
1213 gspca_frame_add(gspca_dev, FIRST_PACKET,
1214 pac_sof_marker, sizeof pac_sof_marker);
1215 len -= sof - data;
1216 data = sof;
1217 }
1218 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1219 }
1220
1221 /* sub-driver description */
1222 static const struct sd_desc sd_desc = {
1223 .name = MODULE_NAME,
1224 .ctrls = sd_ctrls,
1225 .nctrls = ARRAY_SIZE(sd_ctrls),
1226 .config = sd_config,
1227 .init = sd_init,
1228 .start = sd_start,
1229 .stopN = sd_stopN,
1230 .pkt_scan = sd_pkt_scan,
1231 };
1232
1233 /* -- module initialisation -- */
1234 static const struct usb_device_id device_table[] = {
1235 {USB_DEVICE(0x08ca, 0x0110)}, /* Trust Spyc@m 100 */
1236 {USB_DEVICE(0x08ca, 0x0111)}, /* Aiptek Pencam VGA+ */
1237 {USB_DEVICE(0x093a, 0x010f)}, /* All other known MR97310A VGA cams */
1238 {USB_DEVICE(0x093a, 0x010e)}, /* All known MR97310A CIF cams */
1239 {}
1240 };
1241 MODULE_DEVICE_TABLE(usb, device_table);
1242
1243 /* -- device connect -- */
1244 static int sd_probe(struct usb_interface *intf,
1245 const struct usb_device_id *id)
1246 {
1247 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1248 THIS_MODULE);
1249 }
1250
1251 static struct usb_driver sd_driver = {
1252 .name = MODULE_NAME,
1253 .id_table = device_table,
1254 .probe = sd_probe,
1255 .disconnect = gspca_disconnect,
1256 #ifdef CONFIG_PM
1257 .suspend = gspca_suspend,
1258 .resume = gspca_resume,
1259 #endif
1260 };
1261
1262 /* -- module insert / remove -- */
1263 static int __init sd_mod_init(void)
1264 {
1265 return usb_register(&sd_driver);
1266 }
1267 static void __exit sd_mod_exit(void)
1268 {
1269 usb_deregister(&sd_driver);
1270 }
1271
1272 module_init(sd_mod_init);
1273 module_exit(sd_mod_exit);