1
/* GSPCA subdrivers for Genesys Logic webcams with the GL860 chip
4
* 2009/09/24 Olivier Lorin <o.lorin@laposte.net>
5
* GSPCA by Jean-Francois Moine <http://moinejf.free.fr>
6
* Thanks BUGabundo and Malmostoso for your amazing help!
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, see <http://www.gnu.org/licenses/>.
22
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
MODULE_AUTHOR("Olivier Lorin <o.lorin@laposte.net>");
28
MODULE_DESCRIPTION("Genesys Logic USB PC Camera Driver");
29
MODULE_LICENSE("GPL");
31
/*======================== static function declarations ====================*/
33
static void (*dev_init_settings)(struct gspca_dev *gspca_dev);
35
static int sd_config(struct gspca_dev *gspca_dev,
36
const struct usb_device_id *id);
37
static int sd_init(struct gspca_dev *gspca_dev);
38
static int sd_isoc_init(struct gspca_dev *gspca_dev);
39
static int sd_start(struct gspca_dev *gspca_dev);
40
static void sd_stop0(struct gspca_dev *gspca_dev);
41
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
43
static void sd_callback(struct gspca_dev *gspca_dev);
45
static int gl860_guess_sensor(struct gspca_dev *gspca_dev,
46
u16 vendor_id, u16 product_id);
48
/*============================ driver options ==============================*/
50
static s32 AC50Hz = 0xff;
51
module_param(AC50Hz, int, 0644);
52
MODULE_PARM_DESC(AC50Hz, " Does AC power frequency is 50Hz? (0/1)");
54
static char sensor[7];
55
module_param_string(sensor, sensor, sizeof(sensor), 0644);
56
MODULE_PARM_DESC(sensor,
57
" Driver sensor ('MI1320'/'MI2020'/'OV9655'/'OV2640')");
59
/*============================ webcam controls =============================*/
61
/* Functions to get and set a control value */
62
#define SD_SETGET(thename) \
63
static int sd_set_##thename(struct gspca_dev *gspca_dev, s32 val)\
65
struct sd *sd = (struct sd *) gspca_dev;\
67
sd->vcur.thename = val;\
68
if (gspca_dev->streaming)\
72
static int sd_get_##thename(struct gspca_dev *gspca_dev, s32 *val)\
74
struct sd *sd = (struct sd *) gspca_dev;\
76
*val = sd->vcur.thename;\
92
#define GL860_NCTRLS 11
95
static struct ctrl sd_ctrls_mi1320[GL860_NCTRLS];
96
static struct ctrl sd_ctrls_mi2020[GL860_NCTRLS];
97
static struct ctrl sd_ctrls_ov2640[GL860_NCTRLS];
98
static struct ctrl sd_ctrls_ov9655[GL860_NCTRLS];
100
#define SET_MY_CTRL(theid, \
101
thetype, thelabel, thename) \
102
if (sd->vmax.thename != 0) {\
103
sd_ctrls[nCtrls].qctrl.id = theid;\
104
sd_ctrls[nCtrls].qctrl.type = thetype;\
105
strcpy(sd_ctrls[nCtrls].qctrl.name, thelabel);\
106
sd_ctrls[nCtrls].qctrl.minimum = 0;\
107
sd_ctrls[nCtrls].qctrl.maximum = sd->vmax.thename;\
108
sd_ctrls[nCtrls].qctrl.default_value = sd->vcur.thename;\
109
sd_ctrls[nCtrls].qctrl.step = \
110
(sd->vmax.thename < 16) ? 1 : sd->vmax.thename/16;\
111
sd_ctrls[nCtrls].set = sd_set_##thename;\
112
sd_ctrls[nCtrls].get = sd_get_##thename;\
116
static int gl860_build_control_table(struct gspca_dev *gspca_dev)
118
struct sd *sd = (struct sd *) gspca_dev;
119
struct ctrl *sd_ctrls;
123
sd_ctrls = sd_ctrls_mi1320;
125
sd_ctrls = sd_ctrls_mi2020;
127
sd_ctrls = sd_ctrls_ov2640;
129
sd_ctrls = sd_ctrls_ov9655;
133
memset(sd_ctrls, 0, GL860_NCTRLS * sizeof(struct ctrl));
135
SET_MY_CTRL(V4L2_CID_BRIGHTNESS,
136
V4L2_CTRL_TYPE_INTEGER, "Brightness", brightness)
137
SET_MY_CTRL(V4L2_CID_SHARPNESS,
138
V4L2_CTRL_TYPE_INTEGER, "Sharpness", sharpness)
139
SET_MY_CTRL(V4L2_CID_CONTRAST,
140
V4L2_CTRL_TYPE_INTEGER, "Contrast", contrast)
141
SET_MY_CTRL(V4L2_CID_GAMMA,
142
V4L2_CTRL_TYPE_INTEGER, "Gamma", gamma)
143
SET_MY_CTRL(V4L2_CID_HUE,
144
V4L2_CTRL_TYPE_INTEGER, "Palette", hue)
145
SET_MY_CTRL(V4L2_CID_SATURATION,
146
V4L2_CTRL_TYPE_INTEGER, "Saturation", saturation)
147
SET_MY_CTRL(V4L2_CID_WHITE_BALANCE_TEMPERATURE,
148
V4L2_CTRL_TYPE_INTEGER, "White Bal.", whitebal)
149
SET_MY_CTRL(V4L2_CID_BACKLIGHT_COMPENSATION,
150
V4L2_CTRL_TYPE_INTEGER, "Backlight" , backlight)
152
SET_MY_CTRL(V4L2_CID_HFLIP,
153
V4L2_CTRL_TYPE_BOOLEAN, "Mirror", mirror)
154
SET_MY_CTRL(V4L2_CID_VFLIP,
155
V4L2_CTRL_TYPE_BOOLEAN, "Flip", flip)
156
SET_MY_CTRL(V4L2_CID_POWER_LINE_FREQUENCY,
157
V4L2_CTRL_TYPE_BOOLEAN, "AC power 50Hz", AC50Hz)
162
/*==================== sud-driver structure initialisation =================*/
164
static const struct sd_desc sd_desc_mi1320 = {
166
.ctrls = sd_ctrls_mi1320,
167
.nctrls = GL860_NCTRLS,
170
.isoc_init = sd_isoc_init,
173
.pkt_scan = sd_pkt_scan,
174
.dq_callback = sd_callback,
177
static const struct sd_desc sd_desc_mi2020 = {
179
.ctrls = sd_ctrls_mi2020,
180
.nctrls = GL860_NCTRLS,
183
.isoc_init = sd_isoc_init,
186
.pkt_scan = sd_pkt_scan,
187
.dq_callback = sd_callback,
190
static const struct sd_desc sd_desc_ov2640 = {
192
.ctrls = sd_ctrls_ov2640,
193
.nctrls = GL860_NCTRLS,
196
.isoc_init = sd_isoc_init,
199
.pkt_scan = sd_pkt_scan,
200
.dq_callback = sd_callback,
203
static const struct sd_desc sd_desc_ov9655 = {
205
.ctrls = sd_ctrls_ov9655,
206
.nctrls = GL860_NCTRLS,
209
.isoc_init = sd_isoc_init,
212
.pkt_scan = sd_pkt_scan,
213
.dq_callback = sd_callback,
216
/*=========================== sub-driver image sizes =======================*/
218
static struct v4l2_pix_format mi2020_mode[] = {
219
{ 640, 480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
221
.sizeimage = 640 * 480,
222
.colorspace = V4L2_COLORSPACE_SRGB,
225
{ 800, 598, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
227
.sizeimage = 800 * 598,
228
.colorspace = V4L2_COLORSPACE_SRGB,
231
{1280, 1024, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
232
.bytesperline = 1280,
233
.sizeimage = 1280 * 1024,
234
.colorspace = V4L2_COLORSPACE_SRGB,
237
{1600, 1198, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
238
.bytesperline = 1600,
239
.sizeimage = 1600 * 1198,
240
.colorspace = V4L2_COLORSPACE_SRGB,
245
static struct v4l2_pix_format ov2640_mode[] = {
246
{ 640, 480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
248
.sizeimage = 640 * 480,
249
.colorspace = V4L2_COLORSPACE_SRGB,
252
{ 800, 600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
254
.sizeimage = 800 * 600,
255
.colorspace = V4L2_COLORSPACE_SRGB,
258
{1280, 960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
259
.bytesperline = 1280,
260
.sizeimage = 1280 * 960,
261
.colorspace = V4L2_COLORSPACE_SRGB,
264
{1600, 1200, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
265
.bytesperline = 1600,
266
.sizeimage = 1600 * 1200,
267
.colorspace = V4L2_COLORSPACE_SRGB,
272
static struct v4l2_pix_format mi1320_mode[] = {
273
{ 640, 480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
275
.sizeimage = 640 * 480,
276
.colorspace = V4L2_COLORSPACE_SRGB,
279
{ 800, 600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
281
.sizeimage = 800 * 600,
282
.colorspace = V4L2_COLORSPACE_SRGB,
285
{1280, 960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
286
.bytesperline = 1280,
287
.sizeimage = 1280 * 960,
288
.colorspace = V4L2_COLORSPACE_SRGB,
293
static struct v4l2_pix_format ov9655_mode[] = {
294
{ 640, 480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
296
.sizeimage = 640 * 480,
297
.colorspace = V4L2_COLORSPACE_SRGB,
300
{1280, 960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
301
.bytesperline = 1280,
302
.sizeimage = 1280 * 960,
303
.colorspace = V4L2_COLORSPACE_SRGB,
308
/*========================= sud-driver functions ===========================*/
310
/* This function is called at probe time */
311
static int sd_config(struct gspca_dev *gspca_dev,
312
const struct usb_device_id *id)
314
struct sd *sd = (struct sd *) gspca_dev;
316
u16 vendor_id, product_id;
318
/* Get USB VendorID and ProductID */
319
vendor_id = id->idVendor;
320
product_id = id->idProduct;
326
if (strcmp(sensor, "MI1320") == 0)
327
sd->sensor = ID_MI1320;
328
else if (strcmp(sensor, "OV2640") == 0)
329
sd->sensor = ID_OV2640;
330
else if (strcmp(sensor, "OV9655") == 0)
331
sd->sensor = ID_OV9655;
332
else if (strcmp(sensor, "MI2020") == 0)
333
sd->sensor = ID_MI2020;
335
/* Get sensor and set the suitable init/start/../stop functions */
336
if (gl860_guess_sensor(gspca_dev, vendor_id, product_id) == -1)
339
cam = &gspca_dev->cam;
340
gspca_dev->nbalt = 4;
342
switch (sd->sensor) {
344
gspca_dev->sd_desc = &sd_desc_mi1320;
345
cam->cam_mode = mi1320_mode;
346
cam->nmodes = ARRAY_SIZE(mi1320_mode);
347
dev_init_settings = mi1320_init_settings;
351
gspca_dev->sd_desc = &sd_desc_mi2020;
352
cam->cam_mode = mi2020_mode;
353
cam->nmodes = ARRAY_SIZE(mi2020_mode);
354
dev_init_settings = mi2020_init_settings;
358
gspca_dev->sd_desc = &sd_desc_ov2640;
359
cam->cam_mode = ov2640_mode;
360
cam->nmodes = ARRAY_SIZE(ov2640_mode);
361
dev_init_settings = ov2640_init_settings;
365
gspca_dev->sd_desc = &sd_desc_ov9655;
366
cam->cam_mode = ov9655_mode;
367
cam->nmodes = ARRAY_SIZE(ov9655_mode);
368
dev_init_settings = ov9655_init_settings;
372
dev_init_settings(gspca_dev);
374
((struct sd *) gspca_dev)->vcur.AC50Hz = AC50Hz;
375
gl860_build_control_table(gspca_dev);
380
/* This function is called at probe time after sd_config */
381
static int sd_init(struct gspca_dev *gspca_dev)
383
struct sd *sd = (struct sd *) gspca_dev;
385
return sd->dev_init_at_startup(gspca_dev);
388
/* This function is called before to choose the alt setting */
389
static int sd_isoc_init(struct gspca_dev *gspca_dev)
391
struct sd *sd = (struct sd *) gspca_dev;
393
return sd->dev_configure_alt(gspca_dev);
396
/* This function is called to start the webcam */
397
static int sd_start(struct gspca_dev *gspca_dev)
399
struct sd *sd = (struct sd *) gspca_dev;
401
return sd->dev_init_pre_alt(gspca_dev);
404
/* This function is called to stop the webcam */
405
static void sd_stop0(struct gspca_dev *gspca_dev)
407
struct sd *sd = (struct sd *) gspca_dev;
409
return sd->dev_post_unset_alt(gspca_dev);
412
/* This function is called when an image is being received */
413
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
416
struct sd *sd = (struct sd *) gspca_dev;
419
s32 mode = (s32) gspca_dev->curr_mode;
421
sd->swapRB * (gspca_dev->cam.cam_mode[mode].bytesperline + 1);
423
/* Test only against 0202h, so endianess does not matter */
424
switch (*(s16 *) data) {
425
case 0x0202: /* End of frame, start a new one */
426
gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
428
if (sd->nbIm >= 0 && sd->nbIm < 10)
430
gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
436
if (nSkipped + len <= nToSkip)
439
if (nSkipped < nToSkip && nSkipped + len > nToSkip) {
440
data += nToSkip - nSkipped;
441
len -= nToSkip - nSkipped;
442
nSkipped = nToSkip + 1;
444
gspca_frame_add(gspca_dev,
445
INTER_PACKET, data, len);
451
/* This function is called when an image has been read */
452
/* This function is used to monitor webcam orientation */
453
static void sd_callback(struct gspca_dev *gspca_dev)
455
struct sd *sd = (struct sd *) gspca_dev;
461
/* Probe sensor orientation */
462
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, (void *)&state);
464
/* C8/40 means upside-down (looking backwards) */
465
/* D8/50 means right-up (looking onwards) */
466
upsideDown = (state == 0xc8 || state == 0x40);
468
if (upsideDown && sd->nbRightUp > -4) {
469
if (sd->nbRightUp > 0)
471
if (sd->nbRightUp == -3) {
477
if (!upsideDown && sd->nbRightUp < 4) {
478
if (sd->nbRightUp < 0)
480
if (sd->nbRightUp == 3) {
489
sd->dev_camera_settings(gspca_dev);
492
/*=================== USB driver structure initialisation ==================*/
494
static const struct usb_device_id device_table[] = {
495
{USB_DEVICE(0x05e3, 0x0503)},
496
{USB_DEVICE(0x05e3, 0xf191)},
500
MODULE_DEVICE_TABLE(usb, device_table);
502
static int sd_probe(struct usb_interface *intf,
503
const struct usb_device_id *id)
505
return gspca_dev_probe(intf, id,
506
&sd_desc_mi1320, sizeof(struct sd), THIS_MODULE);
509
static void sd_disconnect(struct usb_interface *intf)
511
gspca_disconnect(intf);
514
static struct usb_driver sd_driver = {
516
.id_table = device_table,
518
.disconnect = sd_disconnect,
520
.suspend = gspca_suspend,
521
.resume = gspca_resume,
525
/*====================== Init and Exit module functions ====================*/
527
static int __init sd_mod_init(void)
529
PDEBUG(D_PROBE, "driver startup - version %s", DRIVER_VERSION);
531
if (usb_register(&sd_driver) < 0)
536
static void __exit sd_mod_exit(void)
538
usb_deregister(&sd_driver);
541
module_init(sd_mod_init);
542
module_exit(sd_mod_exit);
544
/*==========================================================================*/
546
int gl860_RTx(struct gspca_dev *gspca_dev,
547
unsigned char pref, u32 req, u16 val, u16 index,
548
s32 len, void *pdata)
550
struct usb_device *udev = gspca_dev->dev;
553
if (pref == 0x40) { /* Send */
555
memcpy(gspca_dev->usb_buf, pdata, len);
556
r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
557
req, pref, val, index,
559
len, 400 + 200 * (len > 1));
561
r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
562
req, pref, val, index, NULL, len, 400);
564
} else { /* Receive */
566
r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
567
req, pref, val, index,
569
len, 400 + 200 * (len > 1));
570
memcpy(pdata, gspca_dev->usb_buf, len);
572
r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
573
req, pref, val, index, NULL, len, 400);
578
pr_err("ctrl transfer failed %4d [p%02x r%d v%04x i%04x len%d]\n",
579
r, pref, req, val, index, len);
580
else if (len > 1 && r < len)
581
PDEBUG(D_ERR, "short ctrl transfer %d/%d", r, len);
588
int fetch_validx(struct gspca_dev *gspca_dev, struct validx *tbl, int len)
592
for (n = 0; n < len; n++) {
593
if (tbl[n].idx != 0xffff)
594
ctrl_out(gspca_dev, 0x40, 1, tbl[n].val,
595
tbl[n].idx, 0, NULL);
596
else if (tbl[n].val == 0xffff)
604
int keep_on_fetching_validx(struct gspca_dev *gspca_dev, struct validx *tbl,
608
if (tbl[n].idx != 0xffff)
609
ctrl_out(gspca_dev, 0x40, 1, tbl[n].val, tbl[n].idx,
611
else if (tbl[n].val == 0xffff)
619
void fetch_idxdata(struct gspca_dev *gspca_dev, struct idxdata *tbl, int len)
623
for (n = 0; n < len; n++) {
624
if (memcmp(tbl[n].data, "\xff\xff\xff", 3) != 0)
625
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, tbl[n].idx,
632
static int gl860_guess_sensor(struct gspca_dev *gspca_dev,
633
u16 vendor_id, u16 product_id)
635
struct sd *sd = (struct sd *) gspca_dev;
636
u8 probe, nb26, nb96, nOV, ntry;
638
if (product_id == 0xf191)
639
sd->sensor = ID_MI1320;
641
if (sd->sensor == 0xff) {
642
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &probe);
643
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &probe);
645
ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x0000, 0, NULL);
647
ctrl_out(gspca_dev, 0x40, 1, 0x0010, 0x0010, 0, NULL);
649
ctrl_out(gspca_dev, 0x40, 1, 0x0008, 0x00c0, 0, NULL);
651
ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x00c1, 0, NULL);
653
ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x00c2, 0, NULL);
655
ctrl_out(gspca_dev, 0x40, 1, 0x0020, 0x0006, 0, NULL);
657
ctrl_out(gspca_dev, 0x40, 1, 0x006a, 0x000d, 0, NULL);
660
PDEBUG(D_PROBE, "probing for sensor MI2020 or OVXXXX");
662
for (ntry = 0; ntry < 4; ntry++) {
663
ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
665
ctrl_out(gspca_dev, 0x40, 1, 0x0063, 0x0006, 0, NULL);
667
ctrl_out(gspca_dev, 0x40, 1, 0x7a00, 0x8030, 0, NULL);
669
ctrl_in(gspca_dev, 0xc0, 2, 0x7a00, 0x8030, 1, &probe);
670
PDEBUG(D_PROBE, "probe=0x%02x", probe);
676
PDEBUG(D_PROBE, "0xff -> OVXXXX");
677
PDEBUG(D_PROBE, "probing for sensor OV2640 or OV9655");
680
for (ntry = 0; ntry < 4; ntry++) {
681
ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000,
684
ctrl_out(gspca_dev, 0x40, 1, 0x6000, 0x800a,
688
/* Wait for 26(OV2640) or 96(OV9655) */
689
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x800a,
692
if (probe == 0x26 || probe == 0x40) {
694
"probe=0x%02x -> OV2640",
696
sd->sensor = ID_OV2640;
700
if (probe == 0x96 || probe == 0x55) {
702
"probe=0x%02x -> OV9655",
704
sd->sensor = ID_OV9655;
708
PDEBUG(D_PROBE, "probe=0x%02x", probe);
715
if (nb26 < 4 && nb96 < 4)
718
PDEBUG(D_PROBE, "Not any 0xff -> MI2020");
719
sd->sensor = ID_MI2020;
724
PDEBUG(D_PROBE, "05e3:f191 sensor MI1320 (1.3M)");
725
} else if (_MI2020_) {
726
PDEBUG(D_PROBE, "05e3:0503 sensor MI2020 (2.0M)");
727
} else if (_OV9655_) {
728
PDEBUG(D_PROBE, "05e3:0503 sensor OV9655 (1.3M)");
729
} else if (_OV2640_) {
730
PDEBUG(D_PROBE, "05e3:0503 sensor OV2640 (2.0M)");
732
PDEBUG(D_PROBE, "***** Unknown sensor *****");