?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / media / usb / gspca / gl860 / gl860.c
blob2c05ea2598e7630a50c0ae13e7fe433f33947bde
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* GSPCA subdrivers for Genesys Logic webcams with the GL860 chip
3 * Subdriver core
4 *
5 * 2009/09/24 Olivier Lorin <o.lorin@laposte.net>
6 * GSPCA by Jean-Francois Moine <http://moinejf.free.fr>
7 * Thanks BUGabundo and Malmostoso for your amazing help!
8 */
9
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12 #include "gspca.h"
13 #include "gl860.h"
14
15 MODULE_AUTHOR("Olivier Lorin <o.lorin@laposte.net>");
16 MODULE_DESCRIPTION("Genesys Logic USB PC Camera Driver");
17 MODULE_LICENSE("GPL");
18
19 /*======================== static function declarations ====================*/
20
21 static void (*dev_init_settings)(struct gspca_dev *gspca_dev);
22
23 static int sd_config(struct gspca_dev *gspca_dev,
24 const struct usb_device_id *id);
25 static int sd_init(struct gspca_dev *gspca_dev);
26 static int sd_isoc_init(struct gspca_dev *gspca_dev);
27 static int sd_start(struct gspca_dev *gspca_dev);
28 static void sd_stop0(struct gspca_dev *gspca_dev);
29 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
30 u8 *data, int len);
31 static void sd_callback(struct gspca_dev *gspca_dev);
32
33 static int gl860_guess_sensor(struct gspca_dev *gspca_dev,
34 u16 vendor_id, u16 product_id);
35
36 /*============================ driver options ==============================*/
37
38 static s32 AC50Hz = 0xff;
39 module_param(AC50Hz, int, 0644);
40 MODULE_PARM_DESC(AC50Hz, " Does AC power frequency is 50Hz? (0/1)");
41
42 static char sensor[7];
43 module_param_string(sensor, sensor, sizeof(sensor), 0644);
44 MODULE_PARM_DESC(sensor,
45 " Driver sensor ('MI1320'/'MI2020'/'OV9655'/'OV2640')");
46
47 /*============================ webcam controls =============================*/
48
49 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
50 {
51 struct gspca_dev *gspca_dev =
52 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
53 struct sd *sd = (struct sd *) gspca_dev;
54
55 switch (ctrl->id) {
56 case V4L2_CID_BRIGHTNESS:
57 sd->vcur.brightness = ctrl->val;
58 break;
59 case V4L2_CID_CONTRAST:
60 sd->vcur.contrast = ctrl->val;
61 break;
62 case V4L2_CID_SATURATION:
63 sd->vcur.saturation = ctrl->val;
64 break;
65 case V4L2_CID_HUE:
66 sd->vcur.hue = ctrl->val;
67 break;
68 case V4L2_CID_GAMMA:
69 sd->vcur.gamma = ctrl->val;
70 break;
71 case V4L2_CID_HFLIP:
72 sd->vcur.mirror = ctrl->val;
73 break;
74 case V4L2_CID_VFLIP:
75 sd->vcur.flip = ctrl->val;
76 break;
77 case V4L2_CID_POWER_LINE_FREQUENCY:
78 sd->vcur.AC50Hz = ctrl->val;
79 break;
80 case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
81 sd->vcur.whitebal = ctrl->val;
82 break;
83 case V4L2_CID_SHARPNESS:
84 sd->vcur.sharpness = ctrl->val;
85 break;
86 case V4L2_CID_BACKLIGHT_COMPENSATION:
87 sd->vcur.backlight = ctrl->val;
88 break;
89 default:
90 return -EINVAL;
91 }
92
93 if (gspca_dev->streaming)
94 sd->waitSet = 1;
95
96 return 0;
97 }
98
99 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
100 .s_ctrl = sd_s_ctrl,
101 };
102
103 static int sd_init_controls(struct gspca_dev *gspca_dev)
104 {
105 struct sd *sd = (struct sd *) gspca_dev;
106 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
107
108 gspca_dev->vdev.ctrl_handler = hdl;
109 v4l2_ctrl_handler_init(hdl, 11);
110
111 if (sd->vmax.brightness)
112 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_BRIGHTNESS,
113 0, sd->vmax.brightness, 1,
114 sd->vcur.brightness);
115
116 if (sd->vmax.contrast)
117 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_CONTRAST,
118 0, sd->vmax.contrast, 1,
119 sd->vcur.contrast);
120
121 if (sd->vmax.saturation)
122 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_SATURATION,
123 0, sd->vmax.saturation, 1,
124 sd->vcur.saturation);
125
126 if (sd->vmax.hue)
127 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_HUE,
128 0, sd->vmax.hue, 1, sd->vcur.hue);
129
130 if (sd->vmax.gamma)
131 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_GAMMA,
132 0, sd->vmax.gamma, 1, sd->vcur.gamma);
133
134 if (sd->vmax.mirror)
135 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_HFLIP,
136 0, sd->vmax.mirror, 1, sd->vcur.mirror);
137
138 if (sd->vmax.flip)
139 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_VFLIP,
140 0, sd->vmax.flip, 1, sd->vcur.flip);
141
142 if (sd->vmax.AC50Hz)
143 v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
144 V4L2_CID_POWER_LINE_FREQUENCY,
145 sd->vmax.AC50Hz, 0, sd->vcur.AC50Hz);
146
147 if (sd->vmax.whitebal)
148 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
149 V4L2_CID_WHITE_BALANCE_TEMPERATURE,
150 0, sd->vmax.whitebal, 1, sd->vcur.whitebal);
151
152 if (sd->vmax.sharpness)
153 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_SHARPNESS,
154 0, sd->vmax.sharpness, 1,
155 sd->vcur.sharpness);
156
157 if (sd->vmax.backlight)
158 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
159 V4L2_CID_BACKLIGHT_COMPENSATION,
160 0, sd->vmax.backlight, 1,
161 sd->vcur.backlight);
162
163 if (hdl->error) {
164 pr_err("Could not initialize controls\n");
165 return hdl->error;
166 }
167
168 return 0;
169 }
170
171 /*==================== sud-driver structure initialisation =================*/
172
173 static const struct sd_desc sd_desc_mi1320 = {
174 .name = MODULE_NAME,
175 .config = sd_config,
176 .init = sd_init,
177 .init_controls = sd_init_controls,
178 .isoc_init = sd_isoc_init,
179 .start = sd_start,
180 .stop0 = sd_stop0,
181 .pkt_scan = sd_pkt_scan,
182 .dq_callback = sd_callback,
183 };
184
185 static const struct sd_desc sd_desc_mi2020 = {
186 .name = MODULE_NAME,
187 .config = sd_config,
188 .init = sd_init,
189 .init_controls = sd_init_controls,
190 .isoc_init = sd_isoc_init,
191 .start = sd_start,
192 .stop0 = sd_stop0,
193 .pkt_scan = sd_pkt_scan,
194 .dq_callback = sd_callback,
195 };
196
197 static const struct sd_desc sd_desc_ov2640 = {
198 .name = MODULE_NAME,
199 .config = sd_config,
200 .init = sd_init,
201 .init_controls = sd_init_controls,
202 .isoc_init = sd_isoc_init,
203 .start = sd_start,
204 .stop0 = sd_stop0,
205 .pkt_scan = sd_pkt_scan,
206 .dq_callback = sd_callback,
207 };
208
209 static const struct sd_desc sd_desc_ov9655 = {
210 .name = MODULE_NAME,
211 .config = sd_config,
212 .init = sd_init,
213 .init_controls = sd_init_controls,
214 .isoc_init = sd_isoc_init,
215 .start = sd_start,
216 .stop0 = sd_stop0,
217 .pkt_scan = sd_pkt_scan,
218 .dq_callback = sd_callback,
219 };
220
221 /*=========================== sub-driver image sizes =======================*/
222
223 static struct v4l2_pix_format mi2020_mode[] = {
224 { 640, 480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
225 .bytesperline = 640,
226 .sizeimage = 640 * 480,
227 .colorspace = V4L2_COLORSPACE_SRGB,
228 .priv = 0
229 },
230 { 800, 598, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
231 .bytesperline = 800,
232 .sizeimage = 800 * 598,
233 .colorspace = V4L2_COLORSPACE_SRGB,
234 .priv = 1
235 },
236 {1280, 1024, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
237 .bytesperline = 1280,
238 .sizeimage = 1280 * 1024,
239 .colorspace = V4L2_COLORSPACE_SRGB,
240 .priv = 2
241 },
242 {1600, 1198, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
243 .bytesperline = 1600,
244 .sizeimage = 1600 * 1198,
245 .colorspace = V4L2_COLORSPACE_SRGB,
246 .priv = 3
247 },
248 };
249
250 static struct v4l2_pix_format ov2640_mode[] = {
251 { 640, 480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
252 .bytesperline = 640,
253 .sizeimage = 640 * 480,
254 .colorspace = V4L2_COLORSPACE_SRGB,
255 .priv = 0
256 },
257 { 800, 600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
258 .bytesperline = 800,
259 .sizeimage = 800 * 600,
260 .colorspace = V4L2_COLORSPACE_SRGB,
261 .priv = 1
262 },
263 {1280, 960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
264 .bytesperline = 1280,
265 .sizeimage = 1280 * 960,
266 .colorspace = V4L2_COLORSPACE_SRGB,
267 .priv = 2
268 },
269 {1600, 1200, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
270 .bytesperline = 1600,
271 .sizeimage = 1600 * 1200,
272 .colorspace = V4L2_COLORSPACE_SRGB,
273 .priv = 3
274 },
275 };
276
277 static struct v4l2_pix_format mi1320_mode[] = {
278 { 640, 480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
279 .bytesperline = 640,
280 .sizeimage = 640 * 480,
281 .colorspace = V4L2_COLORSPACE_SRGB,
282 .priv = 0
283 },
284 { 800, 600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
285 .bytesperline = 800,
286 .sizeimage = 800 * 600,
287 .colorspace = V4L2_COLORSPACE_SRGB,
288 .priv = 1
289 },
290 {1280, 960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
291 .bytesperline = 1280,
292 .sizeimage = 1280 * 960,
293 .colorspace = V4L2_COLORSPACE_SRGB,
294 .priv = 2
295 },
296 };
297
298 static struct v4l2_pix_format ov9655_mode[] = {
299 { 640, 480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
300 .bytesperline = 640,
301 .sizeimage = 640 * 480,
302 .colorspace = V4L2_COLORSPACE_SRGB,
303 .priv = 0
304 },
305 {1280, 960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
306 .bytesperline = 1280,
307 .sizeimage = 1280 * 960,
308 .colorspace = V4L2_COLORSPACE_SRGB,
309 .priv = 1
310 },
311 };
312
313 /*========================= sud-driver functions ===========================*/
314
315 /* This function is called at probe time */
316 static int sd_config(struct gspca_dev *gspca_dev,
317 const struct usb_device_id *id)
318 {
319 struct sd *sd = (struct sd *) gspca_dev;
320 struct cam *cam;
321 u16 vendor_id, product_id;
322
323 /* Get USB VendorID and ProductID */
324 vendor_id = id->idVendor;
325 product_id = id->idProduct;
326
327 sd->nbRightUp = 1;
328 sd->nbIm = -1;
329
330 sd->sensor = 0xff;
331 if (strcmp(sensor, "MI1320") == 0)
332 sd->sensor = ID_MI1320;
333 else if (strcmp(sensor, "OV2640") == 0)
334 sd->sensor = ID_OV2640;
335 else if (strcmp(sensor, "OV9655") == 0)
336 sd->sensor = ID_OV9655;
337 else if (strcmp(sensor, "MI2020") == 0)
338 sd->sensor = ID_MI2020;
339
340 /* Get sensor and set the suitable init/start/../stop functions */
341 if (gl860_guess_sensor(gspca_dev, vendor_id, product_id) == -1)
342 return -1;
343
344 cam = &gspca_dev->cam;
345
346 switch (sd->sensor) {
347 case ID_MI1320:
348 gspca_dev->sd_desc = &sd_desc_mi1320;
349 cam->cam_mode = mi1320_mode;
350 cam->nmodes = ARRAY_SIZE(mi1320_mode);
351 dev_init_settings = mi1320_init_settings;
352 break;
353
354 case ID_MI2020:
355 gspca_dev->sd_desc = &sd_desc_mi2020;
356 cam->cam_mode = mi2020_mode;
357 cam->nmodes = ARRAY_SIZE(mi2020_mode);
358 dev_init_settings = mi2020_init_settings;
359 break;
360
361 case ID_OV2640:
362 gspca_dev->sd_desc = &sd_desc_ov2640;
363 cam->cam_mode = ov2640_mode;
364 cam->nmodes = ARRAY_SIZE(ov2640_mode);
365 dev_init_settings = ov2640_init_settings;
366 break;
367
368 case ID_OV9655:
369 gspca_dev->sd_desc = &sd_desc_ov9655;
370 cam->cam_mode = ov9655_mode;
371 cam->nmodes = ARRAY_SIZE(ov9655_mode);
372 dev_init_settings = ov9655_init_settings;
373 break;
374 }
375
376 dev_init_settings(gspca_dev);
377 if (AC50Hz != 0xff)
378 ((struct sd *) gspca_dev)->vcur.AC50Hz = AC50Hz;
379
380 return 0;
381 }
382
383 /* This function is called at probe time after sd_config */
384 static int sd_init(struct gspca_dev *gspca_dev)
385 {
386 struct sd *sd = (struct sd *) gspca_dev;
387
388 return sd->dev_init_at_startup(gspca_dev);
389 }
390
391 /* This function is called before to choose the alt setting */
392 static int sd_isoc_init(struct gspca_dev *gspca_dev)
393 {
394 struct sd *sd = (struct sd *) gspca_dev;
395
396 return sd->dev_configure_alt(gspca_dev);
397 }
398
399 /* This function is called to start the webcam */
400 static int sd_start(struct gspca_dev *gspca_dev)
401 {
402 struct sd *sd = (struct sd *) gspca_dev;
403
404 return sd->dev_init_pre_alt(gspca_dev);
405 }
406
407 /* This function is called to stop the webcam */
408 static void sd_stop0(struct gspca_dev *gspca_dev)
409 {
410 struct sd *sd = (struct sd *) gspca_dev;
411
412 if (!sd->gspca_dev.present)
413 return;
414
415 return sd->dev_post_unset_alt(gspca_dev);
416 }
417
418 /* This function is called when an image is being received */
419 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
420 u8 *data, int len)
421 {
422 struct sd *sd = (struct sd *) gspca_dev;
423 static s32 nSkipped;
424
425 s32 mode = (s32) gspca_dev->curr_mode;
426 s32 nToSkip =
427 sd->swapRB * (gspca_dev->cam.cam_mode[mode].bytesperline + 1);
428
429 /* Test only against 0202h, so endianness does not matter */
430 switch (*(s16 *) data) {
431 case 0x0202: /* End of frame, start a new one */
432 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
433 nSkipped = 0;
434 if (sd->nbIm >= 0 && sd->nbIm < 10)
435 sd->nbIm++;
436 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
437 break;
438
439 default:
440 data += 2;
441 len -= 2;
442 if (nSkipped + len <= nToSkip)
443 nSkipped += len;
444 else {
445 if (nSkipped < nToSkip && nSkipped + len > nToSkip) {
446 data += nToSkip - nSkipped;
447 len -= nToSkip - nSkipped;
448 nSkipped = nToSkip + 1;
449 }
450 gspca_frame_add(gspca_dev,
451 INTER_PACKET, data, len);
452 }
453 break;
454 }
455 }
456
457 /* This function is called when an image has been read */
458 /* This function is used to monitor webcam orientation */
459 static void sd_callback(struct gspca_dev *gspca_dev)
460 {
461 struct sd *sd = (struct sd *) gspca_dev;
462
463 if (!_OV9655_) {
464 u8 state;
465 u8 upsideDown;
466
467 /* Probe sensor orientation */
468 ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, (void *)&state);
469
470 /* C8/40 means upside-down (looking backwards) */
471 /* D8/50 means right-up (looking onwards) */
472 upsideDown = (state == 0xc8 || state == 0x40);
473
474 if (upsideDown && sd->nbRightUp > -4) {
475 if (sd->nbRightUp > 0)
476 sd->nbRightUp = 0;
477 if (sd->nbRightUp == -3) {
478 sd->mirrorMask = 1;
479 sd->waitSet = 1;
480 }
481 sd->nbRightUp--;
482 }
483 if (!upsideDown && sd->nbRightUp < 4) {
484 if (sd->nbRightUp < 0)
485 sd->nbRightUp = 0;
486 if (sd->nbRightUp == 3) {
487 sd->mirrorMask = 0;
488 sd->waitSet = 1;
489 }
490 sd->nbRightUp++;
491 }
492 }
493
494 if (sd->waitSet)
495 sd->dev_camera_settings(gspca_dev);
496 }
497
498 /*=================== USB driver structure initialisation ==================*/
499
500 static const struct usb_device_id device_table[] = {
501 {USB_DEVICE(0x05e3, 0x0503)},
502 {USB_DEVICE(0x05e3, 0xf191)},
503 {}
504 };
505
506 MODULE_DEVICE_TABLE(usb, device_table);
507
508 static int sd_probe(struct usb_interface *intf,
509 const struct usb_device_id *id)
510 {
511 return gspca_dev_probe(intf, id,
512 &sd_desc_mi1320, sizeof(struct sd), THIS_MODULE);
513 }
514
515 static void sd_disconnect(struct usb_interface *intf)
516 {
517 gspca_disconnect(intf);
518 }
519
520 static struct usb_driver sd_driver = {
521 .name = MODULE_NAME,
522 .id_table = device_table,
523 .probe = sd_probe,
524 .disconnect = sd_disconnect,
525 #ifdef CONFIG_PM
526 .suspend = gspca_suspend,
527 .resume = gspca_resume,
528 .reset_resume = gspca_resume,
529 #endif
530 };
531
532 /*====================== Init and Exit module functions ====================*/
533
534 module_usb_driver(sd_driver);
535
536 /*==========================================================================*/
537
538 int gl860_RTx(struct gspca_dev *gspca_dev,
539 unsigned char pref, u32 req, u16 val, u16 index,
540 s32 len, void *pdata)
541 {
542 struct usb_device *udev = gspca_dev->dev;
543 s32 r = 0;
544
545 if (pref == 0x40) { /* Send */
546 if (len > 0) {
547 memcpy(gspca_dev->usb_buf, pdata, len);
548 r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
549 req, pref, val, index,
550 gspca_dev->usb_buf,
551 len, 400 + 200 * (len > 1));
552 } else {
553 r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
554 req, pref, val, index, NULL, len, 400);
555 }
556 } else { /* Receive */
557 if (len > 0) {
558 r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
559 req, pref, val, index,
560 gspca_dev->usb_buf,
561 len, 400 + 200 * (len > 1));
562 memcpy(pdata, gspca_dev->usb_buf, len);
563 } else {
564 r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
565 req, pref, val, index, NULL, len, 400);
566 }
567 }
568
569 if (r < 0)
570 pr_err("ctrl transfer failed %4d [p%02x r%d v%04x i%04x len%d]\n",
571 r, pref, req, val, index, len);
572 else if (len > 1 && r < len)
573 gspca_err(gspca_dev, "short ctrl transfer %d/%d\n", r, len);
574
575 msleep(1);
576
577 return r;
578 }
579
580 int fetch_validx(struct gspca_dev *gspca_dev, struct validx *tbl, int len)
581 {
582 int n;
583
584 for (n = 0; n < len; n++) {
585 if (tbl[n].idx != 0xffff)
586 ctrl_out(gspca_dev, 0x40, 1, tbl[n].val,
587 tbl[n].idx, 0, NULL);
588 else if (tbl[n].val == 0xffff)
589 break;
590 else
591 msleep(tbl[n].val);
592 }
593 return n;
594 }
595
596 int keep_on_fetching_validx(struct gspca_dev *gspca_dev, struct validx *tbl,
597 int len, int n)
598 {
599 while (++n < len) {
600 if (tbl[n].idx != 0xffff)
601 ctrl_out(gspca_dev, 0x40, 1, tbl[n].val, tbl[n].idx,
602 0, NULL);
603 else if (tbl[n].val == 0xffff)
604 break;
605 else
606 msleep(tbl[n].val);
607 }
608 return n;
609 }
610
611 void fetch_idxdata(struct gspca_dev *gspca_dev, struct idxdata *tbl, int len)
612 {
613 int n;
614
615 for (n = 0; n < len; n++) {
616 if (memcmp(tbl[n].data, "\xff\xff\xff", 3) != 0)
617 ctrl_out(gspca_dev, 0x40, 3, 0x7a00, tbl[n].idx,
618 3, tbl[n].data);
619 else
620 msleep(tbl[n].idx);
621 }
622 }
623
624 static int gl860_guess_sensor(struct gspca_dev *gspca_dev,
625 u16 vendor_id, u16 product_id)
626 {
627 struct sd *sd = (struct sd *) gspca_dev;
628 u8 probe, nb26, nb96, nOV, ntry;
629
630 if (product_id == 0xf191)
631 sd->sensor = ID_MI1320;
632
633 if (sd->sensor == 0xff) {
634 ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &probe);
635 ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &probe);
636
637 ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x0000, 0, NULL);
638 msleep(3);
639 ctrl_out(gspca_dev, 0x40, 1, 0x0010, 0x0010, 0, NULL);
640 msleep(3);
641 ctrl_out(gspca_dev, 0x40, 1, 0x0008, 0x00c0, 0, NULL);
642 msleep(3);
643 ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x00c1, 0, NULL);
644 msleep(3);
645 ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x00c2, 0, NULL);
646 msleep(3);
647 ctrl_out(gspca_dev, 0x40, 1, 0x0020, 0x0006, 0, NULL);
648 msleep(3);
649 ctrl_out(gspca_dev, 0x40, 1, 0x006a, 0x000d, 0, NULL);
650 msleep(56);
651
652 gspca_dbg(gspca_dev, D_PROBE, "probing for sensor MI2020 or OVXXXX\n");
653 nOV = 0;
654 for (ntry = 0; ntry < 4; ntry++) {
655 ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
656 msleep(3);
657 ctrl_out(gspca_dev, 0x40, 1, 0x0063, 0x0006, 0, NULL);
658 msleep(3);
659 ctrl_out(gspca_dev, 0x40, 1, 0x7a00, 0x8030, 0, NULL);
660 msleep(10);
661 ctrl_in(gspca_dev, 0xc0, 2, 0x7a00, 0x8030, 1, &probe);
662 gspca_dbg(gspca_dev, D_PROBE, "probe=0x%02x\n", probe);
663 if (probe == 0xff)
664 nOV++;
665 }
666
667 if (nOV) {
668 gspca_dbg(gspca_dev, D_PROBE, "0xff -> OVXXXX\n");
669 gspca_dbg(gspca_dev, D_PROBE, "probing for sensor OV2640 or OV9655");
670
671 nb26 = nb96 = 0;
672 for (ntry = 0; ntry < 4; ntry++) {
673 ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000,
674 0, NULL);
675 msleep(3);
676 ctrl_out(gspca_dev, 0x40, 1, 0x6000, 0x800a,
677 0, NULL);
678 msleep(10);
679
680 /* Wait for 26(OV2640) or 96(OV9655) */
681 ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x800a,
682 1, &probe);
683
684 if (probe == 0x26 || probe == 0x40) {
685 gspca_dbg(gspca_dev, D_PROBE,
686 "probe=0x%02x -> OV2640\n",
687 probe);
688 sd->sensor = ID_OV2640;
689 nb26 += 4;
690 break;
691 }
692 if (probe == 0x96 || probe == 0x55) {
693 gspca_dbg(gspca_dev, D_PROBE,
694 "probe=0x%02x -> OV9655\n",
695 probe);
696 sd->sensor = ID_OV9655;
697 nb96 += 4;
698 break;
699 }
700 gspca_dbg(gspca_dev, D_PROBE, "probe=0x%02x\n",
701 probe);
702 if (probe == 0x00)
703 nb26++;
704 if (probe == 0xff)
705 nb96++;
706 msleep(3);
707 }
708 if (nb26 < 4 && nb96 < 4)
709 return -1;
710 } else {
711 gspca_dbg(gspca_dev, D_PROBE, "Not any 0xff -> MI2020\n");
712 sd->sensor = ID_MI2020;
713 }
714 }
715
716 if (_MI1320_) {
717 gspca_dbg(gspca_dev, D_PROBE, "05e3:f191 sensor MI1320 (1.3M)\n");
718 } else if (_MI2020_) {
719 gspca_dbg(gspca_dev, D_PROBE, "05e3:0503 sensor MI2020 (2.0M)\n");
720 } else if (_OV9655_) {
721 gspca_dbg(gspca_dev, D_PROBE, "05e3:0503 sensor OV9655 (1.3M)\n");
722 } else if (_OV2640_) {
723 gspca_dbg(gspca_dev, D_PROBE, "05e3:0503 sensor OV2640 (2.0M)\n");
724 } else {
725 gspca_dbg(gspca_dev, D_PROBE, "***** Unknown sensor *****\n");
726 return -1;
727 }
728
729 return 0;
730 }
Linux with added FPC-III support