2 * Sunplus spca561 subdriver
4 * Copyright (C) 2004 Michel Xhaard mxhaard@magic.fr
6 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #define MODULE_NAME "spca561"
25 #include <linux/input.h>
28 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
29 MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver");
30 MODULE_LICENSE("GPL");
32 /* specific webcam descriptor */
34 struct gspca_dev gspca_dev
; /* !! must be the first item */
36 __u16 exposure
; /* rev12a only */
37 #define EXPOSURE_MIN 1
38 #define EXPOSURE_DEF 700 /* == 10 fps */
39 #define EXPOSURE_MAX (2047 + 325) /* see setexposure */
41 __u8 contrast
; /* rev72a only */
42 #define CONTRAST_MIN 0x00
43 #define CONTRAST_DEF 0x20
44 #define CONTRAST_MAX 0x3f
46 __u8 brightness
; /* rev72a only */
47 #define BRIGHTNESS_MIN 0
48 #define BRIGHTNESS_DEF 0x20
49 #define BRIGHTNESS_MAX 0x3f
57 #define AUTOGAIN_MIN 0
58 #define AUTOGAIN_DEF 1
59 #define AUTOGAIN_MAX 1
61 __u8 gain
; /* rev12a only */
67 __u8 expo12a
; /* expo/gain? for rev 12a */
74 #define AG_CNT_START 13
77 static const struct v4l2_pix_format sif_012a_mode
[] = {
78 {160, 120, V4L2_PIX_FMT_SGBRG8
, V4L2_FIELD_NONE
,
80 .sizeimage
= 160 * 120,
81 .colorspace
= V4L2_COLORSPACE_SRGB
,
83 {176, 144, V4L2_PIX_FMT_SGBRG8
, V4L2_FIELD_NONE
,
85 .sizeimage
= 176 * 144,
86 .colorspace
= V4L2_COLORSPACE_SRGB
,
88 {320, 240, V4L2_PIX_FMT_SPCA561
, V4L2_FIELD_NONE
,
90 .sizeimage
= 320 * 240 * 4 / 8,
91 .colorspace
= V4L2_COLORSPACE_SRGB
,
93 {352, 288, V4L2_PIX_FMT_SPCA561
, V4L2_FIELD_NONE
,
95 .sizeimage
= 352 * 288 * 4 / 8,
96 .colorspace
= V4L2_COLORSPACE_SRGB
,
100 static const struct v4l2_pix_format sif_072a_mode
[] = {
101 {160, 120, V4L2_PIX_FMT_SGBRG8
, V4L2_FIELD_NONE
,
103 .sizeimage
= 160 * 120,
104 .colorspace
= V4L2_COLORSPACE_SRGB
,
106 {176, 144, V4L2_PIX_FMT_SGBRG8
, V4L2_FIELD_NONE
,
108 .sizeimage
= 176 * 144,
109 .colorspace
= V4L2_COLORSPACE_SRGB
,
111 {320, 240, V4L2_PIX_FMT_SGBRG8
, V4L2_FIELD_NONE
,
113 .sizeimage
= 320 * 240,
114 .colorspace
= V4L2_COLORSPACE_SRGB
,
116 {352, 288, V4L2_PIX_FMT_SGBRG8
, V4L2_FIELD_NONE
,
118 .sizeimage
= 352 * 288,
119 .colorspace
= V4L2_COLORSPACE_SRGB
,
124 * Initialization data
125 * I'm not very sure how to split initialization from open data
126 * chunks. For now, we'll consider everything as initialization
128 /* Frame packet header offsets for the spca561 */
129 #define SPCA561_OFFSET_SNAP 1
130 #define SPCA561_OFFSET_TYPE 2
131 #define SPCA561_OFFSET_COMPRESS 3
132 #define SPCA561_OFFSET_FRAMSEQ 4
133 #define SPCA561_OFFSET_GPIO 5
134 #define SPCA561_OFFSET_USBBUFF 6
135 #define SPCA561_OFFSET_WIN2GRAVE 7
136 #define SPCA561_OFFSET_WIN2RAVE 8
137 #define SPCA561_OFFSET_WIN2BAVE 9
138 #define SPCA561_OFFSET_WIN2GBAVE 10
139 #define SPCA561_OFFSET_WIN1GRAVE 11
140 #define SPCA561_OFFSET_WIN1RAVE 12
141 #define SPCA561_OFFSET_WIN1BAVE 13
142 #define SPCA561_OFFSET_WIN1GBAVE 14
143 #define SPCA561_OFFSET_FREQ 15
144 #define SPCA561_OFFSET_VSYNC 16
145 #define SPCA561_INDEX_I2C_BASE 0x8800
146 #define SPCA561_SNAPBIT 0x20
147 #define SPCA561_SNAPCTRL 0x40
149 static const u16 rev72a_reset
[][2] = {
150 {0x0000, 0x8114}, /* Software GPIO output data */
151 {0x0001, 0x8114}, /* Software GPIO output data */
152 {0x0000, 0x8112}, /* Some kind of reset */
155 static const __u16 rev72a_init_data1
[][2] = {
156 {0x0003, 0x8701}, /* PCLK clock delay adjustment */
157 {0x0001, 0x8703}, /* HSYNC from cmos inverted */
158 {0x0011, 0x8118}, /* Enable and conf sensor */
159 {0x0001, 0x8118}, /* Conf sensor */
160 {0x0092, 0x8804}, /* I know nothing about these */
161 {0x0010, 0x8802}, /* 0x88xx registers, so I won't */
164 static const u16 rev72a_init_sensor1
[][2] = {
179 static const __u16 rev72a_init_data2
[][2] = {
180 {0x0018, 0x8601}, /* Pixel/line selection for color separation */
181 {0x0000, 0x8602}, /* Optical black level for user setting */
182 {0x0060, 0x8604}, /* Optical black horizontal offset */
183 {0x0002, 0x8605}, /* Optical black vertical offset */
184 {0x0000, 0x8603}, /* Non-automatic optical black level */
185 {0x0002, 0x865b}, /* Horizontal offset for valid pixels */
186 {0x0000, 0x865f}, /* Vertical valid pixels window (x2) */
187 {0x00b0, 0x865d}, /* Horizontal valid pixels window (x2) */
188 {0x0090, 0x865e}, /* Vertical valid lines window (x2) */
189 {0x00e0, 0x8406}, /* Memory buffer threshold */
190 {0x0000, 0x8660}, /* Compensation memory stuff */
191 {0x0002, 0x8201}, /* Output address for r/w serial EEPROM */
192 {0x0008, 0x8200}, /* Clear valid bit for serial EEPROM */
193 {0x0001, 0x8200}, /* OprMode to be executed by hardware */
195 {0x0000, 0x8611}, /* R offset for white balance */
196 {0x00fd, 0x8612}, /* Gr offset for white balance */
197 {0x0003, 0x8613}, /* B offset for white balance */
198 {0x0000, 0x8614}, /* Gb offset for white balance */
200 {0x0035, 0x8651}, /* R gain for white balance */
201 {0x0040, 0x8652}, /* Gr gain for white balance */
202 {0x005f, 0x8653}, /* B gain for white balance */
203 {0x0040, 0x8654}, /* Gb gain for white balance */
204 {0x0002, 0x8502}, /* Maximum average bit rate stuff */
207 {0x0087, 0x8700}, /* Set master clock (96Mhz????) */
208 {0x0081, 0x8702}, /* Master clock output enable */
210 {0x0000, 0x8500}, /* Set image type (352x288 no compression) */
211 /* Originally was 0x0010 (352x288 compression) */
213 {0x0002, 0x865b}, /* Horizontal offset for valid pixels */
214 {0x0003, 0x865c}, /* Vertical offset for valid lines */
217 static const u16 rev72a_init_sensor2
[][2] = {
220 {0x0005, 0x002f}, /* blanking control column */
221 {0x0006, 0x0000}, /* blanking mode row*/
223 {0x0009, 0x1061}, /* setexposure times && pixel clock
224 * 0001 0 | 000 0110 0001 */
229 /******************** QC Express etch2 stuff ********************/
230 static const __u16 Pb100_1map8300
[][2] = {
234 {0x8303, 0x0125}, /* image area */
237 {0x833c, 0x0001}, /*fixme: win:07*/
239 {0x832f, 0x1904}, /*fixme: was 0419*/
245 static const __u16 Pb100_2map8300
[][2] = {
252 static const __u16 spca561_161rev12A_data1
[][2] = {
253 {0x29, 0x8118}, /* Control register (various enable bits) */
254 {0x08, 0x8114}, /* GPIO: Led off */
255 {0x0e, 0x8112}, /* 0x0e stream off 0x3e stream on */
256 {0x00, 0x8102}, /* white balance - new */
258 {0x04, 0x8802}, /* windows uses 08 */
261 static const __u16 spca561_161rev12A_data2
[][2] = {
268 {0x07, 0x8201}, /* windows uses 02 */
277 {0x07, 0x8601}, /* white balance - new */
278 {0x07, 0x8602}, /* white balance - new */
279 {0x00, 0x8610}, /* *red */
280 {0x00, 0x8611}, /* 3f *green */
281 {0x00, 0x8612}, /* green *blue */
282 {0x00, 0x8613}, /* blue *green */
283 {0x43, 0x8614}, /* green *red - white balance - was 0x35 */
284 {0x40, 0x8615}, /* 40 *green - white balance - was 0x35 */
285 {0x71, 0x8616}, /* 7a *blue - white balance - was 0x35 */
286 {0x40, 0x8617}, /* 40 *green - white balance - was 0x35 */
288 {0x0c, 0x8620}, /* 0c */
289 {0xc8, 0x8631}, /* c8 */
290 {0xc8, 0x8634}, /* c8 */
291 {0x23, 0x8635}, /* 23 */
292 {0x1f, 0x8636}, /* 1f */
293 {0xdd, 0x8637}, /* dd */
294 {0xe1, 0x8638}, /* e1 */
295 {0x1d, 0x8639}, /* 1d */
296 {0x21, 0x863a}, /* 21 */
297 {0xe3, 0x863b}, /* e3 */
298 {0xdf, 0x863c}, /* df */
301 /* {0x99, 0x8700}, * - white balance - new (removed) */
302 /* HDG we used to do this in stop0, making the init state and the state
303 after a start / stop different, so do this here instead. */
308 static void reg_w_val(struct usb_device
*dev
, __u16 index
, __u8 value
)
312 ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
314 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
315 value
, index
, NULL
, 0, 500);
316 PDEBUG(D_USBO
, "reg write: 0x%02x:0x%02x", index
, value
);
318 err("reg write: error %d", ret
);
321 static void write_vector(struct gspca_dev
*gspca_dev
,
322 const __u16 data
[][2])
324 struct usb_device
*dev
= gspca_dev
->dev
;
328 while (data
[i
][1] != 0) {
329 reg_w_val(dev
, data
[i
][1], data
[i
][0]);
334 /* read 'len' bytes to gspca_dev->usb_buf */
335 static void reg_r(struct gspca_dev
*gspca_dev
,
336 __u16 index
, __u16 length
)
338 usb_control_msg(gspca_dev
->dev
,
339 usb_rcvctrlpipe(gspca_dev
->dev
, 0),
341 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
343 index
, gspca_dev
->usb_buf
, length
, 500);
346 /* write 'len' bytes from gspca_dev->usb_buf */
347 static void reg_w_buf(struct gspca_dev
*gspca_dev
,
348 __u16 index
, __u16 len
)
350 usb_control_msg(gspca_dev
->dev
,
351 usb_sndctrlpipe(gspca_dev
->dev
, 0),
353 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
355 index
, gspca_dev
->usb_buf
, len
, 500);
358 static void i2c_write(struct gspca_dev
*gspca_dev
, __u16 value
, __u16 reg
)
362 reg_w_val(gspca_dev
->dev
, 0x8801, reg
);
363 reg_w_val(gspca_dev
->dev
, 0x8805, value
);
364 reg_w_val(gspca_dev
->dev
, 0x8800, value
>> 8);
366 reg_r(gspca_dev
, 0x8803, 1);
367 if (!gspca_dev
->usb_buf
[0])
373 static int i2c_read(struct gspca_dev
*gspca_dev
, __u16 reg
, __u8 mode
)
378 reg_w_val(gspca_dev
->dev
, 0x8804, 0x92);
379 reg_w_val(gspca_dev
->dev
, 0x8801, reg
);
380 reg_w_val(gspca_dev
->dev
, 0x8802, mode
| 0x01);
382 reg_r(gspca_dev
, 0x8803, 1);
383 if (!gspca_dev
->usb_buf
[0]) {
384 reg_r(gspca_dev
, 0x8800, 1);
385 value
= gspca_dev
->usb_buf
[0];
386 reg_r(gspca_dev
, 0x8805, 1);
387 return ((int) value
<< 8) | gspca_dev
->usb_buf
[0];
394 static void sensor_mapwrite(struct gspca_dev
*gspca_dev
,
395 const __u16 (*sensormap
)[2])
397 while ((*sensormap
)[0]) {
398 gspca_dev
->usb_buf
[0] = (*sensormap
)[1];
399 gspca_dev
->usb_buf
[1] = (*sensormap
)[1] >> 8;
400 reg_w_buf(gspca_dev
, (*sensormap
)[0], 2);
405 static void write_sensor_72a(struct gspca_dev
*gspca_dev
,
406 const __u16 (*sensor
)[2])
408 while ((*sensor
)[0]) {
409 i2c_write(gspca_dev
, (*sensor
)[1], (*sensor
)[0]);
414 static void init_161rev12A(struct gspca_dev
*gspca_dev
)
416 write_vector(gspca_dev
, spca561_161rev12A_data1
);
417 sensor_mapwrite(gspca_dev
, Pb100_1map8300
);
418 /*fixme: should be in sd_start*/
419 write_vector(gspca_dev
, spca561_161rev12A_data2
);
420 sensor_mapwrite(gspca_dev
, Pb100_2map8300
);
423 /* this function is called at probe time */
424 static int sd_config(struct gspca_dev
*gspca_dev
,
425 const struct usb_device_id
*id
)
427 struct sd
*sd
= (struct sd
*) gspca_dev
;
429 __u16 vendor
, product
;
432 /* Read frm global register the USB product and vendor IDs, just to
433 * prove that we can communicate with the device. This works, which
434 * confirms at we are communicating properly and that the device
436 reg_r(gspca_dev
, 0x8104, 1);
437 data1
= gspca_dev
->usb_buf
[0];
438 reg_r(gspca_dev
, 0x8105, 1);
439 data2
= gspca_dev
->usb_buf
[0];
440 vendor
= (data2
<< 8) | data1
;
441 reg_r(gspca_dev
, 0x8106, 1);
442 data1
= gspca_dev
->usb_buf
[0];
443 reg_r(gspca_dev
, 0x8107, 1);
444 data2
= gspca_dev
->usb_buf
[0];
445 product
= (data2
<< 8) | data1
;
446 if (vendor
!= id
->idVendor
|| product
!= id
->idProduct
) {
447 PDEBUG(D_PROBE
, "Bad vendor / product from device");
451 cam
= &gspca_dev
->cam
;
452 gspca_dev
->nbalt
= 7 + 1; /* choose alternate 7 first */
454 sd
->chip_revision
= id
->driver_info
;
455 if (sd
->chip_revision
== Rev012A
) {
456 cam
->cam_mode
= sif_012a_mode
;
457 cam
->nmodes
= ARRAY_SIZE(sif_012a_mode
);
459 cam
->cam_mode
= sif_072a_mode
;
460 cam
->nmodes
= ARRAY_SIZE(sif_072a_mode
);
462 sd
->brightness
= BRIGHTNESS_DEF
;
463 sd
->contrast
= CONTRAST_DEF
;
465 sd
->exposure
= EXPOSURE_DEF
;
466 sd
->autogain
= AUTOGAIN_DEF
;
468 sd
->expo12a
= EXPO12A_DEF
;
472 /* this function is called at probe and resume time */
473 static int sd_init_12a(struct gspca_dev
*gspca_dev
)
475 PDEBUG(D_STREAM
, "Chip revision: 012a");
476 init_161rev12A(gspca_dev
);
479 static int sd_init_72a(struct gspca_dev
*gspca_dev
)
481 PDEBUG(D_STREAM
, "Chip revision: 072a");
482 write_vector(gspca_dev
, rev72a_reset
);
484 write_vector(gspca_dev
, rev72a_init_data1
);
485 write_sensor_72a(gspca_dev
, rev72a_init_sensor1
);
486 write_vector(gspca_dev
, rev72a_init_data2
);
487 write_sensor_72a(gspca_dev
, rev72a_init_sensor2
);
488 reg_w_val(gspca_dev
->dev
, 0x8112, 0x30);
493 static void setbrightness(struct gspca_dev
*gspca_dev
)
495 struct sd
*sd
= (struct sd
*) gspca_dev
;
496 struct usb_device
*dev
= gspca_dev
->dev
;
499 value
= sd
->brightness
;
501 /* offsets for white balance */
502 reg_w_val(dev
, 0x8611, value
); /* R */
503 reg_w_val(dev
, 0x8612, value
); /* Gr */
504 reg_w_val(dev
, 0x8613, value
); /* B */
505 reg_w_val(dev
, 0x8614, value
); /* Gb */
508 static void setwhite(struct gspca_dev
*gspca_dev
)
510 struct sd
*sd
= (struct sd
*) gspca_dev
;
515 /* try to emulate MS-win as possible */
517 red
= 0x20 + white
* 3 / 8;
518 blue
= 0x90 - white
* 5 / 8;
519 if (sd
->chip_revision
== Rev012A
) {
523 red
+= sd
->contrast
- 0x20;
524 blue
+= sd
->contrast
- 0x20;
526 reg_w_val(gspca_dev
->dev
, reg
, red
);
527 reg_w_val(gspca_dev
->dev
, reg
+ 2, blue
);
530 static void setcontrast(struct gspca_dev
*gspca_dev
)
532 struct sd
*sd
= (struct sd
*) gspca_dev
;
533 struct usb_device
*dev
= gspca_dev
->dev
;
536 if (sd
->chip_revision
!= Rev072A
)
538 value
= sd
->contrast
+ 0x20;
540 /* gains for white balance */
542 /* reg_w_val(dev, 0x8651, value); * R - done by setwhite */
543 reg_w_val(dev
, 0x8652, value
); /* Gr */
544 /* reg_w_val(dev, 0x8653, value); * B - done by setwhite */
545 reg_w_val(dev
, 0x8654, value
); /* Gb */
549 static void setexposure(struct gspca_dev
*gspca_dev
)
551 struct sd
*sd
= (struct sd
*) gspca_dev
;
554 /* Register 0x8309 controls exposure for the spca561,
555 the basic exposure setting goes from 1-2047, where 1 is completely
556 dark and 2047 is very bright. It not only influences exposure but
557 also the framerate (to allow for longer exposure) from 1 - 300 it
558 only raises the exposure time then from 300 - 600 it halves the
559 framerate to be able to further raise the exposure time and for every
560 300 more it halves the framerate again. This allows for a maximum
561 exposure time of circa 0.2 - 0.25 seconds (30 / (2000/3000) fps).
562 Sometimes this is not enough, the 1-2047 uses bits 0-10, bits 11-12
563 configure a divider for the base framerate which us used at the
564 exposure setting of 1-300. These bits configure the base framerate
565 according to the following formula: fps = 60 / (value + 2) */
567 /* We choose to use the high bits setting the fixed framerate divisor
568 asap, as setting high basic exposure setting without the fixed
569 divider in combination with high gains makes the cam stop */
570 int table
[] = { 0, 450, 550, 625, EXPOSURE_MAX
};
572 for (i
= 0; i
< ARRAY_SIZE(table
) - 1; i
++) {
573 if (sd
->exposure
<= table
[i
+ 1]) {
574 expo
= sd
->exposure
- table
[i
];
582 gspca_dev
->usb_buf
[0] = expo
;
583 gspca_dev
->usb_buf
[1] = expo
>> 8;
584 reg_w_buf(gspca_dev
, 0x8309, 2);
588 static void setgain(struct gspca_dev
*gspca_dev
)
590 struct sd
*sd
= (struct sd
*) gspca_dev
;
592 /* gain reg low 6 bits 0-63 gain, bit 6 and 7, both double the
593 sensitivity when set, so 31 + one of them set == 63, and 15
594 with both of them set == 63 */
596 gspca_dev
->usb_buf
[0] = sd
->gain
;
597 else if (sd
->gain
< 128)
598 gspca_dev
->usb_buf
[0] = (sd
->gain
/ 2) | 0x40;
600 gspca_dev
->usb_buf
[0] = (sd
->gain
/ 4) | 0xC0;
602 gspca_dev
->usb_buf
[1] = 0;
603 reg_w_buf(gspca_dev
, 0x8335, 2);
606 static void setautogain(struct gspca_dev
*gspca_dev
)
608 struct sd
*sd
= (struct sd
*) gspca_dev
;
611 sd
->ag_cnt
= AG_CNT_START
;
616 static int sd_start_12a(struct gspca_dev
*gspca_dev
)
618 struct usb_device
*dev
= gspca_dev
->dev
;
620 static const __u8 Reg8391
[8] =
621 {0x92, 0x30, 0x20, 0x00, 0x0c, 0x00, 0x00, 0x00};
623 mode
= gspca_dev
->cam
.cam_mode
[(int) gspca_dev
->curr_mode
].priv
;
625 /* Use compression on 320x240 and above */
626 reg_w_val(dev
, 0x8500, 0x10 | mode
);
628 /* I couldn't get the compression to work below 320x240
629 * Fortunately at these resolutions the bandwidth
630 * is sufficient to push raw frames at ~20fps */
631 reg_w_val(dev
, 0x8500, mode
);
632 } /* -- qq@kuku.eu.org */
634 gspca_dev
->usb_buf
[0] = 0xaa;
635 gspca_dev
->usb_buf
[1] = 0x00;
636 reg_w_buf(gspca_dev
, 0x8307, 2);
637 /* clock - lower 0x8X values lead to fps > 30 */
638 reg_w_val(gspca_dev
->dev
, 0x8700, 0x8a);
639 /* 0x8f 0x85 0x27 clock */
640 reg_w_val(gspca_dev
->dev
, 0x8112, 0x1e | 0x20);
641 reg_w_val(gspca_dev
->dev
, 0x850b, 0x03);
642 memcpy(gspca_dev
->usb_buf
, Reg8391
, 8);
643 reg_w_buf(gspca_dev
, 0x8391, 8);
644 reg_w_buf(gspca_dev
, 0x8390, 8);
647 setexposure(gspca_dev
);
649 /* Led ON (bit 3 -> 0 */
650 reg_w_val(gspca_dev
->dev
, 0x8114, 0x00);
653 static int sd_start_72a(struct gspca_dev
*gspca_dev
)
655 struct usb_device
*dev
= gspca_dev
->dev
;
659 write_vector(gspca_dev
, rev72a_reset
);
661 write_vector(gspca_dev
, rev72a_init_data1
);
662 write_sensor_72a(gspca_dev
, rev72a_init_sensor1
);
664 mode
= gspca_dev
->cam
.cam_mode
[(int) gspca_dev
->curr_mode
].priv
;
668 Clck
= 0x27; /* ms-win 0x87 */
680 reg_w_val(dev
, 0x8700, Clck
); /* 0x27 clock */
681 reg_w_val(dev
, 0x8702, 0x81);
682 reg_w_val(dev
, 0x8500, mode
); /* mode */
683 write_sensor_72a(gspca_dev
, rev72a_init_sensor2
);
684 setcontrast(gspca_dev
);
685 /* setbrightness(gspca_dev); * fixme: bad values */
686 setautogain(gspca_dev
);
687 reg_w_val(dev
, 0x8112, 0x10 | 0x20);
691 static void sd_stopN(struct gspca_dev
*gspca_dev
)
693 struct sd
*sd
= (struct sd
*) gspca_dev
;
695 if (sd
->chip_revision
== Rev012A
) {
696 reg_w_val(gspca_dev
->dev
, 0x8112, 0x0e);
697 /* Led Off (bit 3 -> 1 */
698 reg_w_val(gspca_dev
->dev
, 0x8114, 0x08);
700 reg_w_val(gspca_dev
->dev
, 0x8112, 0x20);
701 /* reg_w_val(gspca_dev->dev, 0x8102, 0x00); ?? */
705 static void do_autogain(struct gspca_dev
*gspca_dev
)
707 struct sd
*sd
= (struct sd
*) gspca_dev
;
713 __u8 luma_mean
= 110;
714 __u8 luma_delta
= 20;
719 if (--sd
->ag_cnt
>= 0)
721 sd
->ag_cnt
= AG_CNT_START
;
723 switch (sd
->chip_revision
) {
725 reg_r(gspca_dev
, 0x8621, 1);
726 Gr
= gspca_dev
->usb_buf
[0];
727 reg_r(gspca_dev
, 0x8622, 1);
728 R
= gspca_dev
->usb_buf
[0];
729 reg_r(gspca_dev
, 0x8623, 1);
730 B
= gspca_dev
->usb_buf
[0];
731 reg_r(gspca_dev
, 0x8624, 1);
732 Gb
= gspca_dev
->usb_buf
[0];
733 y
= (77 * R
+ 75 * (Gr
+ Gb
) + 29 * B
) >> 8;
734 /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */
735 /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */
736 /* PDEBUG(D_CONF,"reading Y %d U %d V %d ",y,u,v); */
738 if (y
< luma_mean
- luma_delta
||
739 y
> luma_mean
+ luma_delta
) {
740 expotimes
= i2c_read(gspca_dev
, 0x09, 0x10);
742 expotimes
= expotimes
& 0x07ff;
744 "Exposition Times 0x%03X Clock 0x%04X ",
745 expotimes,pixelclk); */
746 gainG
= i2c_read(gspca_dev
, 0x35, 0x10);
748 "reading Gain register %d", gainG); */
750 expotimes
+= (luma_mean
- y
) >> spring
;
751 gainG
+= (luma_mean
- y
) / 50;
753 "compute expotimes %d gain %d",
760 i2c_write(gspca_dev
, gainG
, 0x35);
762 if (expotimes
> 0x0256)
764 else if (expotimes
< 3)
766 i2c_write(gspca_dev
, expotimes
| pixelclk
, 0x09);
772 static void sd_pkt_scan(struct gspca_dev
*gspca_dev
,
773 u8
*data
, /* isoc packet */
774 int len
) /* iso packet length */
776 struct sd
*sd
= (struct sd
*) gspca_dev
;
779 switch (*data
++) { /* sequence number */
780 case 0: /* start of frame */
781 gspca_frame_add(gspca_dev
, LAST_PACKET
, NULL
, 0);
783 /* This should never happen */
785 PDEBUG(D_ERR
, "Short SOF packet, ignoring");
786 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
790 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
791 if (data
[0] & 0x20) {
792 input_report_key(gspca_dev
->input_dev
, KEY_CAMERA
, 1);
793 input_sync(gspca_dev
->input_dev
);
794 input_report_key(gspca_dev
->input_dev
, KEY_CAMERA
, 0);
795 input_sync(gspca_dev
->input_dev
);
799 if (data
[1] & 0x10) {
800 /* compressed bayer */
801 gspca_frame_add(gspca_dev
, FIRST_PACKET
, data
, len
);
803 /* raw bayer (with a header, which we skip) */
804 if (sd
->chip_revision
== Rev012A
) {
811 gspca_frame_add(gspca_dev
, FIRST_PACKET
, data
, len
);
814 case 0xff: /* drop (empty mpackets) */
817 gspca_frame_add(gspca_dev
, INTER_PACKET
, data
, len
);
821 static int sd_setbrightness(struct gspca_dev
*gspca_dev
, __s32 val
)
823 struct sd
*sd
= (struct sd
*) gspca_dev
;
825 sd
->brightness
= val
;
826 if (gspca_dev
->streaming
)
827 setbrightness(gspca_dev
);
831 static int sd_getbrightness(struct gspca_dev
*gspca_dev
, __s32
*val
)
833 struct sd
*sd
= (struct sd
*) gspca_dev
;
835 *val
= sd
->brightness
;
840 static int sd_setcontrast(struct gspca_dev
*gspca_dev
, __s32 val
)
842 struct sd
*sd
= (struct sd
*) gspca_dev
;
845 if (gspca_dev
->streaming
)
846 setcontrast(gspca_dev
);
850 static int sd_getcontrast(struct gspca_dev
*gspca_dev
, __s32
*val
)
852 struct sd
*sd
= (struct sd
*) gspca_dev
;
858 static int sd_setautogain(struct gspca_dev
*gspca_dev
, __s32 val
)
860 struct sd
*sd
= (struct sd
*) gspca_dev
;
863 if (gspca_dev
->streaming
)
864 setautogain(gspca_dev
);
868 static int sd_getautogain(struct gspca_dev
*gspca_dev
, __s32
*val
)
870 struct sd
*sd
= (struct sd
*) gspca_dev
;
876 static int sd_setwhite(struct gspca_dev
*gspca_dev
, __s32 val
)
878 struct sd
*sd
= (struct sd
*) gspca_dev
;
881 if (gspca_dev
->streaming
)
886 static int sd_getwhite(struct gspca_dev
*gspca_dev
, __s32
*val
)
888 struct sd
*sd
= (struct sd
*) gspca_dev
;
895 static int sd_setexposure(struct gspca_dev
*gspca_dev
, __s32 val
)
897 struct sd
*sd
= (struct sd
*) gspca_dev
;
900 if (gspca_dev
->streaming
)
901 setexposure(gspca_dev
);
905 static int sd_getexposure(struct gspca_dev
*gspca_dev
, __s32
*val
)
907 struct sd
*sd
= (struct sd
*) gspca_dev
;
914 static int sd_setgain(struct gspca_dev
*gspca_dev
, __s32 val
)
916 struct sd
*sd
= (struct sd
*) gspca_dev
;
919 if (gspca_dev
->streaming
)
924 static int sd_getgain(struct gspca_dev
*gspca_dev
, __s32
*val
)
926 struct sd
*sd
= (struct sd
*) gspca_dev
;
933 static const struct ctrl sd_ctrls_12a
[] = {
937 .type
= V4L2_CTRL_TYPE_INTEGER
,
942 .default_value
= HUE_DEF
,
949 .id
= V4L2_CID_EXPOSURE
,
950 .type
= V4L2_CTRL_TYPE_INTEGER
,
952 .minimum
= EXPOSURE_MIN
,
953 .maximum
= EXPOSURE_MAX
,
955 .default_value
= EXPOSURE_DEF
,
957 .set
= sd_setexposure
,
958 .get
= sd_getexposure
,
963 .type
= V4L2_CTRL_TYPE_INTEGER
,
968 .default_value
= GAIN_DEF
,
975 static const struct ctrl sd_ctrls_72a
[] = {
979 .type
= V4L2_CTRL_TYPE_INTEGER
,
984 .default_value
= HUE_DEF
,
991 .id
= V4L2_CID_BRIGHTNESS
,
992 .type
= V4L2_CTRL_TYPE_INTEGER
,
993 .name
= "Brightness",
994 .minimum
= BRIGHTNESS_MIN
,
995 .maximum
= BRIGHTNESS_MAX
,
997 .default_value
= BRIGHTNESS_DEF
,
999 .set
= sd_setbrightness
,
1000 .get
= sd_getbrightness
,
1004 .id
= V4L2_CID_CONTRAST
,
1005 .type
= V4L2_CTRL_TYPE_INTEGER
,
1007 .minimum
= CONTRAST_MIN
,
1008 .maximum
= CONTRAST_MAX
,
1010 .default_value
= CONTRAST_DEF
,
1012 .set
= sd_setcontrast
,
1013 .get
= sd_getcontrast
,
1017 .id
= V4L2_CID_AUTOGAIN
,
1018 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
1019 .name
= "Auto Gain",
1020 .minimum
= AUTOGAIN_MIN
,
1021 .maximum
= AUTOGAIN_MAX
,
1023 .default_value
= AUTOGAIN_DEF
,
1025 .set
= sd_setautogain
,
1026 .get
= sd_getautogain
,
1030 /* sub-driver description */
1031 static const struct sd_desc sd_desc_12a
= {
1032 .name
= MODULE_NAME
,
1033 .ctrls
= sd_ctrls_12a
,
1034 .nctrls
= ARRAY_SIZE(sd_ctrls_12a
),
1035 .config
= sd_config
,
1036 .init
= sd_init_12a
,
1037 .start
= sd_start_12a
,
1039 .pkt_scan
= sd_pkt_scan
,
1040 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1044 static const struct sd_desc sd_desc_72a
= {
1045 .name
= MODULE_NAME
,
1046 .ctrls
= sd_ctrls_72a
,
1047 .nctrls
= ARRAY_SIZE(sd_ctrls_72a
),
1048 .config
= sd_config
,
1049 .init
= sd_init_72a
,
1050 .start
= sd_start_72a
,
1052 .pkt_scan
= sd_pkt_scan
,
1053 .dq_callback
= do_autogain
,
1054 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1058 static const struct sd_desc
*sd_desc
[2] = {
1063 /* -- module initialisation -- */
1064 static const __devinitdata
struct usb_device_id device_table
[] = {
1065 {USB_DEVICE(0x041e, 0x401a), .driver_info
= Rev072A
},
1066 {USB_DEVICE(0x041e, 0x403b), .driver_info
= Rev012A
},
1067 {USB_DEVICE(0x0458, 0x7004), .driver_info
= Rev072A
},
1068 {USB_DEVICE(0x0461, 0x0815), .driver_info
= Rev072A
},
1069 {USB_DEVICE(0x046d, 0x0928), .driver_info
= Rev012A
},
1070 {USB_DEVICE(0x046d, 0x0929), .driver_info
= Rev012A
},
1071 {USB_DEVICE(0x046d, 0x092a), .driver_info
= Rev012A
},
1072 {USB_DEVICE(0x046d, 0x092b), .driver_info
= Rev012A
},
1073 {USB_DEVICE(0x046d, 0x092c), .driver_info
= Rev012A
},
1074 {USB_DEVICE(0x046d, 0x092d), .driver_info
= Rev012A
},
1075 {USB_DEVICE(0x046d, 0x092e), .driver_info
= Rev012A
},
1076 {USB_DEVICE(0x046d, 0x092f), .driver_info
= Rev012A
},
1077 {USB_DEVICE(0x04fc, 0x0561), .driver_info
= Rev072A
},
1078 {USB_DEVICE(0x060b, 0xa001), .driver_info
= Rev072A
},
1079 {USB_DEVICE(0x10fd, 0x7e50), .driver_info
= Rev072A
},
1080 {USB_DEVICE(0xabcd, 0xcdee), .driver_info
= Rev072A
},
1084 MODULE_DEVICE_TABLE(usb
, device_table
);
1086 /* -- device connect -- */
1087 static int sd_probe(struct usb_interface
*intf
,
1088 const struct usb_device_id
*id
)
1090 return gspca_dev_probe(intf
, id
,
1091 sd_desc
[id
->driver_info
],
1096 static struct usb_driver sd_driver
= {
1097 .name
= MODULE_NAME
,
1098 .id_table
= device_table
,
1100 .disconnect
= gspca_disconnect
,
1102 .suspend
= gspca_suspend
,
1103 .resume
= gspca_resume
,
1107 /* -- module insert / remove -- */
1108 static int __init
sd_mod_init(void)
1110 return usb_register(&sd_driver
);
1112 static void __exit
sd_mod_exit(void)
1114 usb_deregister(&sd_driver
);
1117 module_init(sd_mod_init
);
1118 module_exit(sd_mod_exit
);