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