drivers/media/usb/gspca/gl860/gl860.c

   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 }