drivers/media/video/gspca/gl860/gl860.c

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