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 } 731