2 * Mars MR97310A library
4 * The original mr97310a driver, which supported the Aiptek Pencam VGA+, is
5 * Copyright (C) 2009 Kyle Guinn <elyk03@gmail.com>
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>
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>
15 * Support for the control settings for the VGA cameras is
16 * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
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>
25 * The MR97311A support in gspca/mars.c has been helpful in understanding some
26 * of the registers in these cameras.
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
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.
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
43 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
45 #define MODULE_NAME "mr97310a"
49 #define CAM_TYPE_CIF 0
50 #define CAM_TYPE_VGA 1
52 #define MR97310A_BRIGHTNESS_DEFAULT 0
54 #define MR97310A_EXPOSURE_MIN 0
55 #define MR97310A_EXPOSURE_MAX 4095
56 #define MR97310A_EXPOSURE_DEFAULT 1000
58 #define MR97310A_GAIN_MIN 0
59 #define MR97310A_GAIN_MAX 31
60 #define MR97310A_GAIN_DEFAULT 25
62 #define MR97310A_CONTRAST_MIN 0
63 #define MR97310A_CONTRAST_MAX 31
64 #define MR97310A_CONTRAST_DEFAULT 23
66 #define MR97310A_CS_GAIN_MIN 0
67 #define MR97310A_CS_GAIN_MAX 0x7ff
68 #define MR97310A_CS_GAIN_DEFAULT 0x110
70 #define MR97310A_MIN_CLOCKDIV_MIN 3
71 #define MR97310A_MIN_CLOCKDIV_MAX 8
72 #define MR97310A_MIN_CLOCKDIV_DEFAULT 3
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");
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)");
84 /* specific webcam descriptor */
86 struct gspca_dev gspca_dev
; /* !! must be the first item */
88 u8 cam_type
; /* 0 is CIF and 1 is VGA */
89 u8 sensor_type
; /* We use 0 and 1 here, too. */
100 struct sensor_w_data
{
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
);
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. */
129 #define NORM_BRIGHTNESS_IDX 0
131 .id
= V4L2_CID_BRIGHTNESS
,
132 .type
= V4L2_CTRL_TYPE_INTEGER
,
133 .name
= "Brightness",
137 .default_value
= MR97310A_BRIGHTNESS_DEFAULT
,
140 .set
= sd_setbrightness
,
141 .get
= sd_getbrightness
,
144 #define ARGUS_QC_BRIGHTNESS_IDX 1
146 .id
= V4L2_CID_BRIGHTNESS
,
147 .type
= V4L2_CTRL_TYPE_INTEGER
,
148 .name
= "Brightness",
152 .default_value
= MR97310A_BRIGHTNESS_DEFAULT
,
155 .set
= sd_setbrightness
,
156 .get
= sd_getbrightness
,
159 #define EXPOSURE_IDX 2
161 .id
= V4L2_CID_EXPOSURE
,
162 .type
= V4L2_CTRL_TYPE_INTEGER
,
164 .minimum
= MR97310A_EXPOSURE_MIN
,
165 .maximum
= MR97310A_EXPOSURE_MAX
,
167 .default_value
= MR97310A_EXPOSURE_DEFAULT
,
170 .set
= sd_setexposure
,
171 .get
= sd_getexposure
,
177 .type
= V4L2_CTRL_TYPE_INTEGER
,
179 .minimum
= MR97310A_GAIN_MIN
,
180 .maximum
= MR97310A_GAIN_MAX
,
182 .default_value
= MR97310A_GAIN_DEFAULT
,
189 #define SAKAR_CS_GAIN_IDX 4
192 .type
= V4L2_CTRL_TYPE_INTEGER
,
194 .minimum
= MR97310A_CS_GAIN_MIN
,
195 .maximum
= MR97310A_CS_GAIN_MAX
,
197 .default_value
= MR97310A_CS_GAIN_DEFAULT
,
204 #define CONTRAST_IDX 5
206 .id
= V4L2_CID_CONTRAST
,
207 .type
= V4L2_CTRL_TYPE_INTEGER
,
209 .minimum
= MR97310A_CONTRAST_MIN
,
210 .maximum
= MR97310A_CONTRAST_MAX
,
212 .default_value
= MR97310A_CONTRAST_DEFAULT
,
215 .set
= sd_setcontrast
,
216 .get
= sd_getcontrast
,
219 #define MIN_CLOCKDIV_IDX 6
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
,
227 .default_value
= MR97310A_MIN_CLOCKDIV_DEFAULT
,
230 .set
= sd_setmin_clockdiv
,
231 .get
= sd_getmin_clockdiv
,
235 static const struct v4l2_pix_format vga_mode
[] = {
236 {160, 120, V4L2_PIX_FMT_MR97310A
, V4L2_FIELD_NONE
,
238 .sizeimage
= 160 * 120,
239 .colorspace
= V4L2_COLORSPACE_SRGB
,
241 {176, 144, V4L2_PIX_FMT_MR97310A
, V4L2_FIELD_NONE
,
243 .sizeimage
= 176 * 144,
244 .colorspace
= V4L2_COLORSPACE_SRGB
,
246 {320, 240, V4L2_PIX_FMT_MR97310A
, V4L2_FIELD_NONE
,
248 .sizeimage
= 320 * 240,
249 .colorspace
= V4L2_COLORSPACE_SRGB
,
251 {352, 288, V4L2_PIX_FMT_MR97310A
, V4L2_FIELD_NONE
,
253 .sizeimage
= 352 * 288,
254 .colorspace
= V4L2_COLORSPACE_SRGB
,
256 {640, 480, V4L2_PIX_FMT_MR97310A
, V4L2_FIELD_NONE
,
258 .sizeimage
= 640 * 480,
259 .colorspace
= V4L2_COLORSPACE_SRGB
,
263 /* the bytes to write are in gspca_dev->usb_buf */
264 static int mr_write(struct gspca_dev
*gspca_dev
, int len
)
268 rc
= usb_bulk_msg(gspca_dev
->dev
,
269 usb_sndbulkpipe(gspca_dev
->dev
, 4),
270 gspca_dev
->usb_buf
, len
, NULL
, 500);
272 pr_err("reg write [%02x] error %d\n",
273 gspca_dev
->usb_buf
[0], rc
);
277 /* the bytes are read into gspca_dev->usb_buf */
278 static int mr_read(struct gspca_dev
*gspca_dev
, int len
)
282 rc
= usb_bulk_msg(gspca_dev
->dev
,
283 usb_rcvbulkpipe(gspca_dev
->dev
, 3),
284 gspca_dev
->usb_buf
, len
, NULL
, 500);
286 pr_err("reg read [%02x] error %d\n",
287 gspca_dev
->usb_buf
[0], rc
);
291 static int sensor_write_reg(struct gspca_dev
*gspca_dev
, u8 reg
, u8 flags
,
292 const u8
*data
, int len
)
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
);
299 return mr_write(gspca_dev
, len
+ 3);
302 static int sensor_write_regs(struct gspca_dev
*gspca_dev
,
303 const struct sensor_w_data
*data
, int len
)
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
);
317 static int sensor_write1(struct gspca_dev
*gspca_dev
, u8 reg
, u8 data
)
319 struct sd
*sd
= (struct sd
*) gspca_dev
;
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;
328 rc
= sensor_write_reg(gspca_dev
, reg
, 0x00, &buf
, 1);
335 rc
= sensor_write_reg(gspca_dev
, confirm_reg
, 0x00, &buf
, 1);
342 static int cam_get_response16(struct gspca_dev
*gspca_dev
, u8 reg
, int verbose
)
346 gspca_dev
->usb_buf
[0] = reg
;
347 err_code
= mr_write(gspca_dev
, 1);
351 err_code
= mr_read(gspca_dev
, 16);
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]);
364 static int zero_the_pointer(struct gspca_dev
*gspca_dev
)
366 __u8
*data
= gspca_dev
->usb_buf
;
371 err_code
= cam_get_response16(gspca_dev
, 0x21, 0);
377 err_code
= mr_write(gspca_dev
, 2);
381 err_code
= cam_get_response16(gspca_dev
, 0x21, 0);
387 err_code
= mr_write(gspca_dev
, 2);
391 err_code
= cam_get_response16(gspca_dev
, 0x21, 0);
397 err_code
= mr_write(gspca_dev
, 2);
401 err_code
= cam_get_response16(gspca_dev
, 0x21, 0);
407 err_code
= mr_write(gspca_dev
, 2);
411 while (status
!= 0x0a && tries
< 256) {
412 err_code
= cam_get_response16(gspca_dev
, 0x21, 0);
419 PDEBUG(D_ERR
, "status is %02x", status
);
425 err_code
= mr_write(gspca_dev
, 2);
429 err_code
= cam_get_response16(gspca_dev
, 0x21, 0);
437 err_code
= mr_write(gspca_dev
, 1);
441 err_code
= mr_read(gspca_dev
, 16);
448 static int stream_start(struct gspca_dev
*gspca_dev
)
450 gspca_dev
->usb_buf
[0] = 0x01;
451 gspca_dev
->usb_buf
[1] = 0x01;
452 return mr_write(gspca_dev
, 2);
455 static void stream_stop(struct gspca_dev
*gspca_dev
)
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");
463 static void lcd_stop(struct gspca_dev
*gspca_dev
)
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");
471 static int isoc_enable(struct gspca_dev
*gspca_dev
)
473 gspca_dev
->usb_buf
[0] = 0x00;
474 gspca_dev
->usb_buf
[1] = 0x4d; /* ISOC transferring enable... */
475 return mr_write(gspca_dev
, 2);
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
)
482 struct sd
*sd
= (struct sd
*) gspca_dev
;
484 int gain_default
= MR97310A_GAIN_DEFAULT
;
487 cam
= &gspca_dev
->cam
;
488 cam
->cam_mode
= vga_mode
;
489 cam
->nmodes
= ARRAY_SIZE(vga_mode
);
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.
500 err_code
= zero_the_pointer(gspca_dev
);
504 err_code
= stream_start(gspca_dev
);
508 /* Now, the query for sensor type. */
509 err_code
= cam_get_response16(gspca_dev
, 0x07, 1);
513 if (id
->idProduct
== 0x0110 || id
->idProduct
== 0x010e) {
514 sd
->cam_type
= CAM_TYPE_CIF
;
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!
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
526 * Name sd->sensor_type reported by
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
537 switch (gspca_dev
->usb_buf
[0]) {
545 pr_err("Unknown CIF Sensor id : %02x\n",
546 gspca_dev
->usb_buf
[1]);
549 PDEBUG(D_PROBE
, "MR97310A CIF camera detected, sensor: %d",
552 sd
->cam_type
= CAM_TYPE_VGA
;
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.
559 * Name gspca_dev->usb_buf[] sd->sensor_type
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
568 * Based upon these results, we assume default settings
569 * and then correct as necessary, as follows.
576 if (gspca_dev
->usb_buf
[0] == 0x01) {
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");
585 /* Sakar Digital color needs to be adjusted. */
586 if ((gspca_dev
->usb_buf
[0] == 0x03) &&
587 (gspca_dev
->usb_buf
[1] == 0x50))
589 if (gspca_dev
->usb_buf
[0] == 0x04) {
591 switch (gspca_dev
->usb_buf
[1]) {
594 PDEBUG(D_PROBE
, "sensor_type corrected to 0");
597 /* Nothing to do here. */
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");
606 PDEBUG(D_PROBE
, "MR97310A VGA camera detected, sensor: %d",
609 /* Stop streaming as we've started it only to probe the sensor type. */
612 if (force_sensor_type
!= -1) {
613 sd
->sensor_type
= !!force_sensor_type
;
614 PDEBUG(D_PROBE
, "Forcing sensor type to: %d",
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
);
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
);
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
) |
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
) |
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
);
653 gspca_dev
->ctrl_dis
= (1 << ARGUS_QC_BRIGHTNESS_IDX
) |
654 (1 << CONTRAST_IDX
) |
655 (1 << SAKAR_CS_GAIN_IDX
);
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
;
667 /* this function is called at probe and resume time */
668 static int sd_init(struct gspca_dev
*gspca_dev
)
673 static int start_cif_cam(struct gspca_dev
*gspca_dev
)
675 struct sd
*sd
= (struct sd
*) gspca_dev
;
676 __u8
*data
= gspca_dev
->usb_buf
;
678 static const __u8 startup_string
[] = {
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 */
692 /* Note: Some of the above descriptions guessed from MR97113A driver */
694 memcpy(data
, startup_string
, 11);
698 switch (gspca_dev
->width
) {
700 data
[9] |= 0x04; /* reg 8, 2:1 scale down from 320 */
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 */
710 data
[9] |= 0x04; /* reg 8, 2:1 scale down from 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 */
719 err_code
= mr_write(gspca_dev
, 11);
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},
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},
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);
769 err_code
= sensor_write_regs(gspca_dev
, cif_sensor1_init_data
,
770 ARRAY_SIZE(cif_sensor1_init_data
));
775 static int start_vga_cam(struct gspca_dev
*gspca_dev
)
777 struct sd
*sd
= (struct sd
*) gspca_dev
;
778 __u8
*data
= gspca_dev
->usb_buf
;
780 static const __u8 startup_string
[] =
781 {0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b, 0x00, 0x00,
783 /* What some of these mean is explained in start_cif_cam(), above */
785 memcpy(data
, startup_string
, 11);
786 if (!sd
->sensor_type
) {
790 if (sd
->sensor_type
== 2) {
795 switch (gspca_dev
->width
) {
797 data
[9] |= 0x0c; /* reg 8, 4:1 scale down */
800 data
[9] |= 0x04; /* reg 8, 2:1 scale down */
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) {
813 data
[8] = 0x04; /* Bayer tile shifted */
817 data
[9] |= 0x04; /* reg 8, 2:1 scale down */
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 */
825 data
[8] = 0x64; /* Bayer tile shifted */
829 err_code
= mr_write(gspca_dev
, 11);
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},
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}
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}
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, */
864 {0x11, 0x04, {0x01}, 1},
865 {0x12, 0x00, {0x00, 0x63, 0x00, 0x70, 0x00, 0x00}, 6},
866 {0x11, 0x04, {0x01}, 1},
871 err_code
= sensor_write_regs(gspca_dev
, color_adj
,
872 ARRAY_SIZE(color_adj
));
874 err_code
= sensor_write_regs(gspca_dev
, color_no_adj
,
875 ARRAY_SIZE(color_no_adj
));
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
[] = {
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
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},
922 err_code
= sensor_write_regs(gspca_dev
, vga_sensor2_init_data
,
923 ARRAY_SIZE(vga_sensor2_init_data
));
928 static int sd_start(struct gspca_dev
*gspca_dev
)
930 struct sd
*sd
= (struct sd
*) gspca_dev
;
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
);
943 err_code
= stream_start(gspca_dev
);
947 if (sd
->cam_type
== CAM_TYPE_CIF
) {
948 err_code
= start_cif_cam(gspca_dev
);
950 err_code
= start_vga_cam(gspca_dev
);
955 setbrightness(gspca_dev
);
956 setcontrast(gspca_dev
);
957 setexposure(gspca_dev
);
960 return isoc_enable(gspca_dev
);
963 static void sd_stopN(struct gspca_dev
*gspca_dev
)
965 struct sd
*sd
= (struct sd
*) gspca_dev
;
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
);
974 static void setbrightness(struct gspca_dev
*gspca_dev
)
976 struct sd
*sd
= (struct sd
*) gspca_dev
;
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};
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.
989 if ((gspca_dev
->ctrl_dis
& (1 << NORM_BRIGHTNESS_IDX
)) &&
990 (gspca_dev
->ctrl_dis
& (1 << ARGUS_QC_BRIGHTNESS_IDX
)))
993 if (sd
->cam_type
== CAM_TYPE_VGA
) {
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
;
1003 sensor_write1(gspca_dev
, sign_reg
, 0x01);
1004 val
= (257 - sd
->brightness
);
1006 /* Use lookup table for funky Argus QuickClix brightness */
1007 if (sd
->do_lcd_stop
)
1008 val
= quick_clix_table
[val
];
1010 sensor_write1(gspca_dev
, value_reg
, val
);
1013 static void setexposure(struct gspca_dev
*gspca_dev
)
1015 struct sd
*sd
= (struct sd
*) gspca_dev
;
1016 int exposure
= MR97310A_EXPOSURE_DEFAULT
;
1019 if (gspca_dev
->ctrl_dis
& (1 << EXPOSURE_IDX
))
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
;
1031 sensor_write1(gspca_dev
, 3, exposure
>> 8);
1032 sensor_write1(gspca_dev
, 4, exposure
& 0xff);
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).
1039 Note our 0 - 4095 exposure is mapped to 0 - 511
1040 milliseconds exposure time */
1041 u8 clockdiv
= (60 * sd
->exposure
+ 7999) / 8000;
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)
1049 if (sd
->cam_type
== CAM_TYPE_VGA
&& clockdiv
< 4)
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
);
1058 /* exposure register value is reversed! */
1059 exposure
= 511 - exposure
;
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
);
1068 static void setgain(struct gspca_dev
*gspca_dev
)
1070 struct sd
*sd
= (struct sd
*) gspca_dev
;
1073 if ((gspca_dev
->ctrl_dis
& (1 << GAIN_IDX
)) &&
1074 (gspca_dev
->ctrl_dis
& (1 << SAKAR_CS_GAIN_IDX
)))
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);
1085 sensor_write1(gspca_dev
, 0x10, sd
->gain
);
1088 static void setcontrast(struct gspca_dev
*gspca_dev
)
1090 struct sd
*sd
= (struct sd
*) gspca_dev
;
1092 if (gspca_dev
->ctrl_dis
& (1 << CONTRAST_IDX
))
1095 sensor_write1(gspca_dev
, 0x1c, sd
->contrast
);
1099 static int sd_setbrightness(struct gspca_dev
*gspca_dev
, __s32 val
)
1101 struct sd
*sd
= (struct sd
*) gspca_dev
;
1103 sd
->brightness
= val
;
1104 if (gspca_dev
->streaming
)
1105 setbrightness(gspca_dev
);
1109 static int sd_getbrightness(struct gspca_dev
*gspca_dev
, __s32
*val
)
1111 struct sd
*sd
= (struct sd
*) gspca_dev
;
1113 *val
= sd
->brightness
;
1117 static int sd_setexposure(struct gspca_dev
*gspca_dev
, __s32 val
)
1119 struct sd
*sd
= (struct sd
*) gspca_dev
;
1122 if (gspca_dev
->streaming
)
1123 setexposure(gspca_dev
);
1127 static int sd_getexposure(struct gspca_dev
*gspca_dev
, __s32
*val
)
1129 struct sd
*sd
= (struct sd
*) gspca_dev
;
1131 *val
= sd
->exposure
;
1135 static int sd_setgain(struct gspca_dev
*gspca_dev
, __s32 val
)
1137 struct sd
*sd
= (struct sd
*) gspca_dev
;
1140 if (gspca_dev
->streaming
)
1145 static int sd_getgain(struct gspca_dev
*gspca_dev
, __s32
*val
)
1147 struct sd
*sd
= (struct sd
*) gspca_dev
;
1153 static int sd_setcontrast(struct gspca_dev
*gspca_dev
, __s32 val
)
1155 struct sd
*sd
= (struct sd
*) gspca_dev
;
1158 if (gspca_dev
->streaming
)
1159 setcontrast(gspca_dev
);
1164 static int sd_getcontrast(struct gspca_dev
*gspca_dev
, __s32
*val
)
1166 struct sd
*sd
= (struct sd
*) gspca_dev
;
1168 *val
= sd
->contrast
;
1172 static int sd_setmin_clockdiv(struct gspca_dev
*gspca_dev
, __s32 val
)
1174 struct sd
*sd
= (struct sd
*) gspca_dev
;
1176 sd
->min_clockdiv
= val
;
1177 if (gspca_dev
->streaming
)
1178 setexposure(gspca_dev
);
1182 static int sd_getmin_clockdiv(struct gspca_dev
*gspca_dev
, __s32
*val
)
1184 struct sd
*sd
= (struct sd
*) gspca_dev
;
1186 *val
= sd
->min_clockdiv
;
1190 /* Include pac common sof detection functions */
1191 #include "pac_common.h"
1193 static void sd_pkt_scan(struct gspca_dev
*gspca_dev
,
1194 u8
*data
, /* isoc packet */
1195 int len
) /* iso packet length */
1197 struct sd
*sd
= (struct sd
*) gspca_dev
;
1200 sof
= pac_find_sof(&sd
->sof_read
, data
, len
);
1204 /* finish decoding current frame */
1206 if (n
> sizeof pac_sof_marker
)
1207 n
-= sizeof pac_sof_marker
;
1210 gspca_frame_add(gspca_dev
, LAST_PACKET
,
1212 /* Start next frame. */
1213 gspca_frame_add(gspca_dev
, FIRST_PACKET
,
1214 pac_sof_marker
, sizeof pac_sof_marker
);
1218 gspca_frame_add(gspca_dev
, INTER_PACKET
, data
, len
);
1221 /* sub-driver description */
1222 static const struct sd_desc sd_desc
= {
1223 .name
= MODULE_NAME
,
1225 .nctrls
= ARRAY_SIZE(sd_ctrls
),
1226 .config
= sd_config
,
1230 .pkt_scan
= sd_pkt_scan
,
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 */
1241 MODULE_DEVICE_TABLE(usb
, device_table
);
1243 /* -- device connect -- */
1244 static int sd_probe(struct usb_interface
*intf
,
1245 const struct usb_device_id
*id
)
1247 return gspca_dev_probe(intf
, id
, &sd_desc
, sizeof(struct sd
),
1251 static struct usb_driver sd_driver
= {
1252 .name
= MODULE_NAME
,
1253 .id_table
= device_table
,
1255 .disconnect
= gspca_disconnect
,
1257 .suspend
= gspca_suspend
,
1258 .resume
= gspca_resume
,
1262 module_usb_driver(sd_driver
);