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