drivers/media/usb/gspca/mr97310a.c

   1 /*
   2  * Mars MR97310A library
   3  *
   4  * The original mr97310a driver, which supported the Aiptek Pencam VGA+, is
   5  * Copyright (C) 2009 Kyle Guinn <elyk03@gmail.com>
   6  *
   7  * Support for the MR97310A cameras in addition to the Aiptek Pencam VGA+
   8  * and for the routines for detecting and classifying these various cameras,
   9  * is Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
  10  *
  11  * Support for the control settings for the CIF cameras is
  12  * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com> and
  13  * Thomas Kaiser <thomas@kaiser-linux.li>
  14  *
  15  * Support for the control settings for the VGA cameras is
  16  * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
  17  *
  18  * Several previously unsupported cameras are owned and have been tested by
  19  * Hans de Goede <hdegoede@redhat.com> and
  20  * Thomas Kaiser <thomas@kaiser-linux.li> and
  21  * Theodore Kilgore <kilgota@auburn.edu> and
  22  * Edmond Rodriguez <erodrig_97@yahoo.com> and
  23  * Aurelien Jacobs <aurel@gnuage.org>
  24  *
  25  * The MR97311A support in gspca/mars.c has been helpful in understanding some
  26  * of the registers in these cameras.
  27  *
  28  * This program is free software; you can redistribute it and/or modify
  29  * it under the terms of the GNU General Public License as published by
  30  * the Free Software Foundation; either version 2 of the License, or
  31  * any later version.
  32  *
  33  * This program is distributed in the hope that it will be useful,
  34  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  35  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  36  * GNU General Public License for more details.
  37  */
  38
  39 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  40
  41 #define MODULE_NAME "mr97310a"
  42
  43 #include "gspca.h"
  44
  45 #define CAM_TYPE_CIF                    0
  46 #define CAM_TYPE_VGA                    1
  47
  48 #define MR97310A_BRIGHTNESS_DEFAULT     0
  49
  50 #define MR97310A_EXPOSURE_MIN           0
  51 #define MR97310A_EXPOSURE_MAX           4095
  52 #define MR97310A_EXPOSURE_DEFAULT       1000
  53
  54 #define MR97310A_GAIN_MIN               0
  55 #define MR97310A_GAIN_MAX               31
  56 #define MR97310A_GAIN_DEFAULT           25
  57
  58 #define MR97310A_CONTRAST_MIN           0
  59 #define MR97310A_CONTRAST_MAX           31
  60 #define MR97310A_CONTRAST_DEFAULT       23
  61
  62 #define MR97310A_CS_GAIN_MIN            0
  63 #define MR97310A_CS_GAIN_MAX            0x7ff
  64 #define MR97310A_CS_GAIN_DEFAULT        0x110
  65
  66 #define MR97310A_CID_CLOCKDIV (V4L2_CTRL_CLASS_USER + 0x1000)
  67 #define MR97310A_MIN_CLOCKDIV_MIN       3
  68 #define MR97310A_MIN_CLOCKDIV_MAX       8
  69 #define MR97310A_MIN_CLOCKDIV_DEFAULT   3
  70
  71 MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>,Theodore Kilgore <kilgota@auburn.edu>");
  72 MODULE_DESCRIPTION("GSPCA/Mars-Semi MR97310A USB Camera Driver");
  73 MODULE_LICENSE("GPL");
  74
  75 /* global parameters */
  76 static int force_sensor_type = -1;
  77 module_param(force_sensor_type, int, 0644);
  78 MODULE_PARM_DESC(force_sensor_type, "Force sensor type (-1 (auto), 0 or 1)");
  79
  80 /* specific webcam descriptor */
  81 struct sd {
  82         struct gspca_dev gspca_dev;  /* !! must be the first item */
  83         struct { /* exposure/min_clockdiv control cluster */
  84                 struct v4l2_ctrl *exposure;
  85                 struct v4l2_ctrl *min_clockdiv;
  86         };
  87         u8 sof_read;
  88         u8 cam_type;    /* 0 is CIF and 1 is VGA */
  89         u8 sensor_type; /* We use 0 and 1 here, too. */
  90         u8 do_lcd_stop;
  91         u8 adj_colors;
  92 };
  93
  94 struct sensor_w_data {
  95         u8 reg;
  96         u8 flags;
  97         u8 data[16];
  98         int len;
  99 };
 100
 101 static void sd_stopN(struct gspca_dev *gspca_dev);
 102
 103 static const struct v4l2_pix_format vga_mode[] = {
 104         {160, 120, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
 105                 .bytesperline = 160,
 106                 .sizeimage = 160 * 120,
 107                 .colorspace = V4L2_COLORSPACE_SRGB,
 108                 .priv = 4},
 109         {176, 144, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
 110                 .bytesperline = 176,
 111                 .sizeimage = 176 * 144,
 112                 .colorspace = V4L2_COLORSPACE_SRGB,
 113                 .priv = 3},
 114         {320, 240, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
 115                 .bytesperline = 320,
 116                 .sizeimage = 320 * 240,
 117                 .colorspace = V4L2_COLORSPACE_SRGB,
 118                 .priv = 2},
 119         {352, 288, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
 120                 .bytesperline = 352,
 121                 .sizeimage = 352 * 288,
 122                 .colorspace = V4L2_COLORSPACE_SRGB,
 123                 .priv = 1},
 124         {640, 480, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
 125                 .bytesperline = 640,
 126                 .sizeimage = 640 * 480,
 127                 .colorspace = V4L2_COLORSPACE_SRGB,
 128                 .priv = 0},
 129 };
 130
 131 /* the bytes to write are in gspca_dev->usb_buf */
 132 static int mr_write(struct gspca_dev *gspca_dev, int len)
 133 {
 134         int rc;
 135
 136         rc = usb_bulk_msg(gspca_dev->dev,
 137                           usb_sndbulkpipe(gspca_dev->dev, 4),
 138                           gspca_dev->usb_buf, len, NULL, 500);
 139         if (rc < 0)
 140                 pr_err("reg write [%02x] error %d\n",
 141                        gspca_dev->usb_buf[0], rc);
 142         return rc;
 143 }
 144
 145 /* the bytes are read into gspca_dev->usb_buf */
 146 static int mr_read(struct gspca_dev *gspca_dev, int len)
 147 {
 148         int rc;
 149
 150         rc = usb_bulk_msg(gspca_dev->dev,
 151                           usb_rcvbulkpipe(gspca_dev->dev, 3),
 152                           gspca_dev->usb_buf, len, NULL, 500);
 153         if (rc < 0)
 154                 pr_err("reg read [%02x] error %d\n",
 155                        gspca_dev->usb_buf[0], rc);
 156         return rc;
 157 }
 158
 159 static int sensor_write_reg(struct gspca_dev *gspca_dev, u8 reg, u8 flags,
 160         const u8 *data, int len)
 161 {
 162         gspca_dev->usb_buf[0] = 0x1f;
 163         gspca_dev->usb_buf[1] = flags;
 164         gspca_dev->usb_buf[2] = reg;
 165         memcpy(gspca_dev->usb_buf + 3, data, len);
 166
 167         return mr_write(gspca_dev, len + 3);
 168 }
 169
 170 static int sensor_write_regs(struct gspca_dev *gspca_dev,
 171         const struct sensor_w_data *data, int len)
 172 {
 173         int i, rc;
 174
 175         for (i = 0; i < len; i++) {
 176                 rc = sensor_write_reg(gspca_dev, data[i].reg, data[i].flags,
 177                                           data[i].data, data[i].len);
 178                 if (rc < 0)
 179                         return rc;
 180         }
 181
 182         return 0;
 183 }
 184
 185 static int sensor_write1(struct gspca_dev *gspca_dev, u8 reg, u8 data)
 186 {
 187         struct sd *sd = (struct sd *) gspca_dev;
 188         u8 buf, confirm_reg;
 189         int rc;
 190
 191         buf = data;
 192         if (sd->cam_type == CAM_TYPE_CIF) {
 193                 rc = sensor_write_reg(gspca_dev, reg, 0x01, &buf, 1);
 194                 confirm_reg = sd->sensor_type ? 0x13 : 0x11;
 195         } else {
 196                 rc = sensor_write_reg(gspca_dev, reg, 0x00, &buf, 1);
 197                 confirm_reg = 0x11;
 198         }
 199         if (rc < 0)
 200                 return rc;
 201
 202         buf = 0x01;
 203         rc = sensor_write_reg(gspca_dev, confirm_reg, 0x00, &buf, 1);
 204         if (rc < 0)
 205                 return rc;
 206
 207         return 0;
 208 }
 209
 210 static int cam_get_response16(struct gspca_dev *gspca_dev, u8 reg, int verbose)
 211 {
 212         int err_code;
 213
 214         gspca_dev->usb_buf[0] = reg;
 215         err_code = mr_write(gspca_dev, 1);
 216         if (err_code < 0)
 217                 return err_code;
 218
 219         err_code = mr_read(gspca_dev, 16);
 220         if (err_code < 0)
 221                 return err_code;
 222
 223         if (verbose)
 224                 PDEBUG(D_PROBE, "Register: %02x reads %02x%02x%02x", reg,
 225                        gspca_dev->usb_buf[0],
 226                        gspca_dev->usb_buf[1],
 227                        gspca_dev->usb_buf[2]);
 228
 229         return 0;
 230 }
 231
 232 static int zero_the_pointer(struct gspca_dev *gspca_dev)
 233 {
 234         __u8 *data = gspca_dev->usb_buf;
 235         int err_code;
 236         u8 status = 0;
 237         int tries = 0;
 238
 239         err_code = cam_get_response16(gspca_dev, 0x21, 0);
 240         if (err_code < 0)
 241                 return err_code;
 242
 243         data[0] = 0x19;
 244         data[1] = 0x51;
 245         err_code = mr_write(gspca_dev, 2);
 246         if (err_code < 0)
 247                 return err_code;
 248
 249         err_code = cam_get_response16(gspca_dev, 0x21, 0);
 250         if (err_code < 0)
 251                 return err_code;
 252
 253         data[0] = 0x19;
 254         data[1] = 0xba;
 255         err_code = mr_write(gspca_dev, 2);
 256         if (err_code < 0)
 257                 return err_code;
 258
 259         err_code = cam_get_response16(gspca_dev, 0x21, 0);
 260         if (err_code < 0)
 261                 return err_code;
 262
 263         data[0] = 0x19;
 264         data[1] = 0x00;
 265         err_code = mr_write(gspca_dev, 2);
 266         if (err_code < 0)
 267                 return err_code;
 268
 269         err_code = cam_get_response16(gspca_dev, 0x21, 0);
 270         if (err_code < 0)
 271                 return err_code;
 272
 273         data[0] = 0x19;
 274         data[1] = 0x00;
 275         err_code = mr_write(gspca_dev, 2);
 276         if (err_code < 0)
 277                 return err_code;
 278
 279         while (status != 0x0a && tries < 256) {
 280                 err_code = cam_get_response16(gspca_dev, 0x21, 0);
 281                 status = data[0];
 282                 tries++;
 283                 if (err_code < 0)
 284                         return err_code;
 285         }
 286         if (status != 0x0a)
 287                 PERR("status is %02x", status);
 288
 289         tries = 0;
 290         while (tries < 4) {
 291                 data[0] = 0x19;
 292                 data[1] = 0x00;
 293                 err_code = mr_write(gspca_dev, 2);
 294                 if (err_code < 0)
 295                         return err_code;
 296
 297                 err_code = cam_get_response16(gspca_dev, 0x21, 0);
 298                 status = data[0];
 299                 tries++;
 300                 if (err_code < 0)
 301                         return err_code;
 302         }
 303
 304         data[0] = 0x19;
 305         err_code = mr_write(gspca_dev, 1);
 306         if (err_code < 0)
 307                 return err_code;
 308
 309         err_code = mr_read(gspca_dev, 16);
 310         if (err_code < 0)
 311                 return err_code;
 312
 313         return 0;
 314 }
 315
 316 static int stream_start(struct gspca_dev *gspca_dev)
 317 {
 318         gspca_dev->usb_buf[0] = 0x01;
 319         gspca_dev->usb_buf[1] = 0x01;
 320         return mr_write(gspca_dev, 2);
 321 }
 322
 323 static void stream_stop(struct gspca_dev *gspca_dev)
 324 {
 325         gspca_dev->usb_buf[0] = 0x01;
 326         gspca_dev->usb_buf[1] = 0x00;
 327         if (mr_write(gspca_dev, 2) < 0)
 328                 PERR("Stream Stop failed");
 329 }
 330
 331 static void lcd_stop(struct gspca_dev *gspca_dev)
 332 {
 333         gspca_dev->usb_buf[0] = 0x19;
 334         gspca_dev->usb_buf[1] = 0x54;
 335         if (mr_write(gspca_dev, 2) < 0)
 336                 PERR("LCD Stop failed");
 337 }
 338
 339 static int isoc_enable(struct gspca_dev *gspca_dev)
 340 {
 341         gspca_dev->usb_buf[0] = 0x00;
 342         gspca_dev->usb_buf[1] = 0x4d;  /* ISOC transferring enable... */
 343         return mr_write(gspca_dev, 2);
 344 }
 345
 346 /* This function is called at probe time */
 347 static int sd_config(struct gspca_dev *gspca_dev,
 348                      const struct usb_device_id *id)
 349 {
 350         struct sd *sd = (struct sd *) gspca_dev;
 351         struct cam *cam;
 352         int err_code;
 353
 354         cam = &gspca_dev->cam;
 355         cam->cam_mode = vga_mode;
 356         cam->nmodes = ARRAY_SIZE(vga_mode);
 357         sd->do_lcd_stop = 0;
 358
 359         /* Several of the supported CIF cameras share the same USB ID but
 360          * require different initializations and different control settings.
 361          * The same is true of the VGA cameras. Therefore, we are forced
 362          * to start the initialization process in order to determine which
 363          * camera is present. Some of the supported cameras require the
 364          * memory pointer to be set to 0 as the very first item of business
 365          * or else they will not stream. So we do that immediately.
 366          */
 367         err_code = zero_the_pointer(gspca_dev);
 368         if (err_code < 0)
 369                 return err_code;
 370
 371         err_code = stream_start(gspca_dev);
 372         if (err_code < 0)
 373                 return err_code;
 374
 375         /* Now, the query for sensor type. */
 376         err_code = cam_get_response16(gspca_dev, 0x07, 1);
 377         if (err_code < 0)
 378                 return err_code;
 379
 380         if (id->idProduct == 0x0110 || id->idProduct == 0x010e) {
 381                 sd->cam_type = CAM_TYPE_CIF;
 382                 cam->nmodes--;
 383                 /*
 384                  * All but one of the known CIF cameras share the same USB ID,
 385                  * but two different init routines are in use, and the control
 386                  * settings are different, too. We need to detect which camera
 387                  * of the two known varieties is connected!
 388                  *
 389                  * A list of known CIF cameras follows. They all report either
 390                  * 0200 for type 0 or 0300 for type 1.
 391                  * If you have another to report, please do
 392                  *
 393                  * Name         sd->sensor_type         reported by
 394                  *
 395                  * Sakar 56379 Spy-shot 0               T. Kilgore
 396                  * Innovage             0               T. Kilgore
 397                  * Vivitar Mini         0               H. De Goede
 398                  * Vivitar Mini         0               E. Rodriguez
 399                  * Vivitar Mini         1               T. Kilgore
 400                  * Elta-Media 8212dc    1               T. Kaiser
 401                  * Philips dig. keych.  1               T. Kilgore
 402                  * Trust Spyc@m 100     1               A. Jacobs
 403                  */
 404                 switch (gspca_dev->usb_buf[0]) {
 405                 case 2:
 406                         sd->sensor_type = 0;
 407                         break;
 408                 case 3:
 409                         sd->sensor_type = 1;
 410                         break;
 411                 default:
 412                         pr_err("Unknown CIF Sensor id : %02x\n",
 413                                gspca_dev->usb_buf[1]);
 414                         return -ENODEV;
 415                 }
 416                 PDEBUG(D_PROBE, "MR97310A CIF camera detected, sensor: %d",
 417                        sd->sensor_type);
 418         } else {
 419                 sd->cam_type = CAM_TYPE_VGA;
 420
 421                 /*
 422                  * Here is a table of the responses to the query for sensor
 423                  * type, from the known MR97310A VGA cameras. Six different
 424                  * cameras of which five share the same USB ID.
 425                  *
 426                  * Name                 gspca_dev->usb_buf[]    sd->sensor_type
 427                  *                              sd->do_lcd_stop
 428                  * Aiptek Pencam VGA+   0300            0               1
 429                  * ION digital          0300            0               1
 430                  * Argus DC-1620        0450            1               0
 431                  * Argus QuickClix      0420            1               1
 432                  * Sakar 77379 Digital  0350            0               1
 433                  * Sakar 1638x CyberPix 0120            0               2
 434                  *
 435                  * Based upon these results, we assume default settings
 436                  * and then correct as necessary, as follows.
 437                  *
 438                  */
 439
 440                 sd->sensor_type = 1;
 441                 sd->do_lcd_stop = 0;
 442                 sd->adj_colors = 0;
 443                 if (gspca_dev->usb_buf[0] == 0x01) {
 444                         sd->sensor_type = 2;
 445                 } else if ((gspca_dev->usb_buf[0] != 0x03) &&
 446                                         (gspca_dev->usb_buf[0] != 0x04)) {
 447                         pr_err("Unknown VGA Sensor id Byte 0: %02x\n",
 448                                gspca_dev->usb_buf[0]);
 449                         pr_err("Defaults assumed, may not work\n");
 450                         pr_err("Please report this\n");
 451                 }
 452                 /* Sakar Digital color needs to be adjusted. */
 453                 if ((gspca_dev->usb_buf[0] == 0x03) &&
 454                                         (gspca_dev->usb_buf[1] == 0x50))
 455                         sd->adj_colors = 1;
 456                 if (gspca_dev->usb_buf[0] == 0x04) {
 457                         sd->do_lcd_stop = 1;
 458                         switch (gspca_dev->usb_buf[1]) {
 459                         case 0x50:
 460                                 sd->sensor_type = 0;
 461                                 PDEBUG(D_PROBE, "sensor_type corrected to 0");
 462                                 break;
 463                         case 0x20:
 464                                 /* Nothing to do here. */
 465                                 break;
 466                         default:
 467                                 pr_err("Unknown VGA Sensor id Byte 1: %02x\n",
 468                                        gspca_dev->usb_buf[1]);
 469                                 pr_err("Defaults assumed, may not work\n");
 470                                 pr_err("Please report this\n");
 471                         }
 472                 }
 473                 PDEBUG(D_PROBE, "MR97310A VGA camera detected, sensor: %d",
 474                        sd->sensor_type);
 475         }
 476         /* Stop streaming as we've started it only to probe the sensor type. */
 477         sd_stopN(gspca_dev);
 478
 479         if (force_sensor_type != -1) {
 480                 sd->sensor_type = !!force_sensor_type;
 481                 PDEBUG(D_PROBE, "Forcing sensor type to: %d",
 482                        sd->sensor_type);
 483         }
 484
 485         return 0;
 486 }
 487
 488 /* this function is called at probe and resume time */
 489 static int sd_init(struct gspca_dev *gspca_dev)
 490 {
 491         return 0;
 492 }
 493
 494 static int start_cif_cam(struct gspca_dev *gspca_dev)
 495 {
 496         struct sd *sd = (struct sd *) gspca_dev;
 497         __u8 *data = gspca_dev->usb_buf;
 498         int err_code;
 499         static const __u8 startup_string[] = {
 500                 0x00,
 501                 0x0d,
 502                 0x01,
 503                 0x00, /* Hsize/8 for 352 or 320 */
 504                 0x00, /* Vsize/4 for 288 or 240 */
 505                 0x13, /* or 0xbb, depends on sensor */
 506                 0x00, /* Hstart, depends on res. */
 507                 0x00, /* reserved ? */
 508                 0x00, /* Vstart, depends on res. and sensor */
 509                 0x50, /* 0x54 to get 176 or 160 */
 510                 0xc0
 511         };
 512
 513         /* Note: Some of the above descriptions guessed from MR97113A driver */
 514
 515         memcpy(data, startup_string, 11);
 516         if (sd->sensor_type)
 517                 data[5] = 0xbb;
 518
 519         switch (gspca_dev->pixfmt.width) {
 520         case 160:
 521                 data[9] |= 0x04;  /* reg 8, 2:1 scale down from 320 */
 522                 /* fall thru */
 523         case 320:
 524         default:
 525                 data[3] = 0x28;                    /* reg 2, H size/8 */
 526                 data[4] = 0x3c;                    /* reg 3, V size/4 */
 527                 data[6] = 0x14;                    /* reg 5, H start  */
 528                 data[8] = 0x1a + sd->sensor_type;  /* reg 7, V start  */
 529                 break;
 530         case 176:
 531                 data[9] |= 0x04;  /* reg 8, 2:1 scale down from 352 */
 532                 /* fall thru */
 533         case 352:
 534                 data[3] = 0x2c;                    /* reg 2, H size/8 */
 535                 data[4] = 0x48;                    /* reg 3, V size/4 */
 536                 data[6] = 0x06;                    /* reg 5, H start  */
 537                 data[8] = 0x06 - sd->sensor_type;  /* reg 7, V start  */
 538                 break;
 539         }
 540         err_code = mr_write(gspca_dev, 11);
 541         if (err_code < 0)
 542                 return err_code;
 543
 544         if (!sd->sensor_type) {
 545                 static const struct sensor_w_data cif_sensor0_init_data[] = {
 546                         {0x02, 0x00, {0x03, 0x5a, 0xb5, 0x01,
 547                                       0x0f, 0x14, 0x0f, 0x10}, 8},
 548                         {0x0c, 0x00, {0x04, 0x01, 0x01, 0x00, 0x1f}, 5},
 549                         {0x12, 0x00, {0x07}, 1},
 550                         {0x1f, 0x00, {0x06}, 1},
 551                         {0x27, 0x00, {0x04}, 1},
 552                         {0x29, 0x00, {0x0c}, 1},
 553                         {0x40, 0x00, {0x40, 0x00, 0x04}, 3},
 554                         {0x50, 0x00, {0x60}, 1},
 555                         {0x60, 0x00, {0x06}, 1},
 556                         {0x6b, 0x00, {0x85, 0x85, 0xc8, 0xc8, 0xc8, 0xc8}, 6},
 557                         {0x72, 0x00, {0x1e, 0x56}, 2},
 558                         {0x75, 0x00, {0x58, 0x40, 0xa2, 0x02, 0x31, 0x02,
 559                                       0x31, 0x80, 0x00}, 9},
 560                         {0x11, 0x00, {0x01}, 1},
 561                         {0, 0, {0}, 0}
 562                 };
 563                 err_code = sensor_write_regs(gspca_dev, cif_sensor0_init_data,
 564                                          ARRAY_SIZE(cif_sensor0_init_data));
 565         } else {        /* sd->sensor_type = 1 */
 566                 static const struct sensor_w_data cif_sensor1_init_data[] = {
 567                         /* Reg 3,4, 7,8 get set by the controls */
 568                         {0x02, 0x00, {0x10}, 1},
 569                         {0x05, 0x01, {0x22}, 1}, /* 5/6 also seen as 65h/32h */
 570                         {0x06, 0x01, {0x00}, 1},
 571                         {0x09, 0x02, {0x0e}, 1},
 572                         {0x0a, 0x02, {0x05}, 1},
 573                         {0x0b, 0x02, {0x05}, 1},
 574                         {0x0c, 0x02, {0x0f}, 1},
 575                         {0x0d, 0x02, {0x07}, 1},
 576                         {0x0e, 0x02, {0x0c}, 1},
 577                         {0x0f, 0x00, {0x00}, 1},
 578                         {0x10, 0x00, {0x06}, 1},
 579                         {0x11, 0x00, {0x07}, 1},
 580                         {0x12, 0x00, {0x00}, 1},
 581                         {0x13, 0x00, {0x01}, 1},
 582                         {0, 0, {0}, 0}
 583                 };
 584                 /* Without this command the cam won't work with USB-UHCI */
 585                 gspca_dev->usb_buf[0] = 0x0a;
 586                 gspca_dev->usb_buf[1] = 0x00;
 587                 err_code = mr_write(gspca_dev, 2);
 588                 if (err_code < 0)
 589                         return err_code;
 590                 err_code = sensor_write_regs(gspca_dev, cif_sensor1_init_data,
 591                                          ARRAY_SIZE(cif_sensor1_init_data));
 592         }
 593         return err_code;
 594 }
 595
 596 static int start_vga_cam(struct gspca_dev *gspca_dev)
 597 {
 598         struct sd *sd = (struct sd *) gspca_dev;
 599         __u8 *data = gspca_dev->usb_buf;
 600         int err_code;
 601         static const __u8 startup_string[] =
 602                 {0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b, 0x00, 0x00,
 603                  0x00, 0x50, 0xc0};
 604         /* What some of these mean is explained in start_cif_cam(), above */
 605
 606         memcpy(data, startup_string, 11);
 607         if (!sd->sensor_type) {
 608                 data[5]  = 0x00;
 609                 data[10] = 0x91;
 610         }
 611         if (sd->sensor_type == 2) {
 612                 data[5]  = 0x00;
 613                 data[10] = 0x18;
 614         }
 615
 616         switch (gspca_dev->pixfmt.width) {
 617         case 160:
 618                 data[9] |= 0x0c;  /* reg 8, 4:1 scale down */
 619                 /* fall thru */
 620         case 320:
 621                 data[9] |= 0x04;  /* reg 8, 2:1 scale down */
 622                 /* fall thru */
 623         case 640:
 624         default:
 625                 data[3] = 0x50;  /* reg 2, H size/8 */
 626                 data[4] = 0x78;  /* reg 3, V size/4 */
 627                 data[6] = 0x04;  /* reg 5, H start */
 628                 data[8] = 0x03;  /* reg 7, V start */
 629                 if (sd->sensor_type == 2) {
 630                         data[6] = 2;
 631                         data[8] = 1;
 632                 }
 633                 if (sd->do_lcd_stop)
 634                         data[8] = 0x04;  /* Bayer tile shifted */
 635                 break;
 636
 637         case 176:
 638                 data[9] |= 0x04;  /* reg 8, 2:1 scale down */
 639                 /* fall thru */
 640         case 352:
 641                 data[3] = 0x2c;  /* reg 2, H size */
 642                 data[4] = 0x48;  /* reg 3, V size */
 643                 data[6] = 0x94;  /* reg 5, H start */
 644                 data[8] = 0x63;  /* reg 7, V start */
 645                 if (sd->do_lcd_stop)
 646                         data[8] = 0x64;  /* Bayer tile shifted */
 647                 break;
 648         }
 649
 650         err_code = mr_write(gspca_dev, 11);
 651         if (err_code < 0)
 652                 return err_code;
 653
 654         if (!sd->sensor_type) {
 655                 static const struct sensor_w_data vga_sensor0_init_data[] = {
 656                         {0x01, 0x00, {0x0c, 0x00, 0x04}, 3},
 657                         {0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4},
 658                         {0x20, 0x00, {0x00, 0x80, 0x00, 0x08}, 4},
 659                         {0x25, 0x00, {0x03, 0xa9, 0x80}, 3},
 660                         {0x30, 0x00, {0x30, 0x18, 0x10, 0x18}, 4},
 661                         {0, 0, {0}, 0}
 662                 };
 663                 err_code = sensor_write_regs(gspca_dev, vga_sensor0_init_data,
 664                                          ARRAY_SIZE(vga_sensor0_init_data));
 665         } else if (sd->sensor_type == 1) {
 666                 static const struct sensor_w_data color_adj[] = {
 667                         {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
 668                                 /* adjusted blue, green, red gain correct
 669                                    too much blue from the Sakar Digital */
 670                                 0x05, 0x01, 0x04}, 8}
 671                 };
 672
 673                 static const struct sensor_w_data color_no_adj[] = {
 674                         {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
 675                                 /* default blue, green, red gain settings */
 676                                 0x07, 0x00, 0x01}, 8}
 677                 };
 678
 679                 static const struct sensor_w_data vga_sensor1_init_data[] = {
 680                         {0x11, 0x04, {0x01}, 1},
 681                         {0x0a, 0x00, {0x00, 0x01, 0x00, 0x00, 0x01,
 682                         /* These settings may be better for some cameras */
 683                         /* {0x0a, 0x00, {0x01, 0x06, 0x00, 0x00, 0x01, */
 684                                 0x00, 0x0a}, 7},
 685                         {0x11, 0x04, {0x01}, 1},
 686                         {0x12, 0x00, {0x00, 0x63, 0x00, 0x70, 0x00, 0x00}, 6},
 687                         {0x11, 0x04, {0x01}, 1},
 688                         {0, 0, {0}, 0}
 689                 };
 690
 691                 if (sd->adj_colors)
 692                         err_code = sensor_write_regs(gspca_dev, color_adj,
 693                                          ARRAY_SIZE(color_adj));
 694                 else
 695                         err_code = sensor_write_regs(gspca_dev, color_no_adj,
 696                                          ARRAY_SIZE(color_no_adj));
 697
 698                 if (err_code < 0)
 699                         return err_code;
 700
 701                 err_code = sensor_write_regs(gspca_dev, vga_sensor1_init_data,
 702                                          ARRAY_SIZE(vga_sensor1_init_data));
 703         } else {        /* sensor type == 2 */
 704                 static const struct sensor_w_data vga_sensor2_init_data[] = {
 705
 706                         {0x01, 0x00, {0x48}, 1},
 707                         {0x02, 0x00, {0x22}, 1},
 708                         /* Reg 3 msb and 4 is lsb of the exposure setting*/
 709                         {0x05, 0x00, {0x10}, 1},
 710                         {0x06, 0x00, {0x00}, 1},
 711                         {0x07, 0x00, {0x00}, 1},
 712                         {0x08, 0x00, {0x00}, 1},
 713                         {0x09, 0x00, {0x00}, 1},
 714                         /* The following are used in the gain control
 715                          * which is BTW completely borked in the OEM driver
 716                          * The values for each color go from 0 to 0x7ff
 717                          *{0x0a, 0x00, {0x01}, 1},  green1 gain msb
 718                          *{0x0b, 0x00, {0x10}, 1},  green1 gain lsb
 719                          *{0x0c, 0x00, {0x01}, 1},  red gain msb
 720                          *{0x0d, 0x00, {0x10}, 1},  red gain lsb
 721                          *{0x0e, 0x00, {0x01}, 1},  blue gain msb
 722                          *{0x0f, 0x00, {0x10}, 1},  blue gain lsb
 723                          *{0x10, 0x00, {0x01}, 1}, green2 gain msb
 724                          *{0x11, 0x00, {0x10}, 1}, green2 gain lsb
 725                          */
 726                         {0x12, 0x00, {0x00}, 1},
 727                         {0x13, 0x00, {0x04}, 1}, /* weird effect on colors */
 728                         {0x14, 0x00, {0x00}, 1},
 729                         {0x15, 0x00, {0x06}, 1},
 730                         {0x16, 0x00, {0x01}, 1},
 731                         {0x17, 0x00, {0xe2}, 1}, /* vertical alignment */
 732                         {0x18, 0x00, {0x02}, 1},
 733                         {0x19, 0x00, {0x82}, 1}, /* don't mess with */
 734                         {0x1a, 0x00, {0x00}, 1},
 735                         {0x1b, 0x00, {0x20}, 1},
 736                         /* {0x1c, 0x00, {0x17}, 1}, contrast control */
 737                         {0x1d, 0x00, {0x80}, 1}, /* moving causes a mess */
 738                         {0x1e, 0x00, {0x08}, 1}, /* moving jams the camera */
 739                         {0x1f, 0x00, {0x0c}, 1},
 740                         {0x20, 0x00, {0x00}, 1},
 741                         {0, 0, {0}, 0}
 742                 };
 743                 err_code = sensor_write_regs(gspca_dev, vga_sensor2_init_data,
 744                                          ARRAY_SIZE(vga_sensor2_init_data));
 745         }
 746         return err_code;
 747 }
 748
 749 static int sd_start(struct gspca_dev *gspca_dev)
 750 {
 751         struct sd *sd = (struct sd *) gspca_dev;
 752         int err_code;
 753
 754         sd->sof_read = 0;
 755
 756         /* Some of the VGA cameras require the memory pointer
 757          * to be set to 0 again. We have been forced to start the
 758          * stream in sd_config() to detect the hardware, and closed it.
 759          * Thus, we need here to do a completely fresh and clean start. */
 760         err_code = zero_the_pointer(gspca_dev);
 761         if (err_code < 0)
 762                 return err_code;
 763
 764         err_code = stream_start(gspca_dev);
 765         if (err_code < 0)
 766                 return err_code;
 767
 768         if (sd->cam_type == CAM_TYPE_CIF) {
 769                 err_code = start_cif_cam(gspca_dev);
 770         } else {
 771                 err_code = start_vga_cam(gspca_dev);
 772         }
 773         if (err_code < 0)
 774                 return err_code;
 775
 776         return isoc_enable(gspca_dev);
 777 }
 778
 779 static void sd_stopN(struct gspca_dev *gspca_dev)
 780 {
 781         struct sd *sd = (struct sd *) gspca_dev;
 782
 783         stream_stop(gspca_dev);
 784         /* Not all the cams need this, but even if not, probably a good idea */
 785         zero_the_pointer(gspca_dev);
 786         if (sd->do_lcd_stop)
 787                 lcd_stop(gspca_dev);
 788 }
 789
 790 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
 791 {
 792         struct sd *sd = (struct sd *) gspca_dev;
 793         u8 sign_reg = 7;  /* This reg and the next one used on CIF cams. */
 794         u8 value_reg = 8; /* VGA cams seem to use regs 0x0b and 0x0c */
 795         static const u8 quick_clix_table[] =
 796         /*        0  1  2   3  4  5  6  7  8  9  10  11  12  13  14  15 */
 797                 { 0, 4, 8, 12, 1, 2, 3, 5, 6, 9,  7, 10, 13, 11, 14, 15};
 798         if (sd->cam_type == CAM_TYPE_VGA) {
 799                 sign_reg += 4;
 800                 value_reg += 4;
 801         }
 802
 803         /* Note register 7 is also seen as 0x8x or 0xCx in some dumps */
 804         if (val > 0) {
 805                 sensor_write1(gspca_dev, sign_reg, 0x00);
 806         } else {
 807                 sensor_write1(gspca_dev, sign_reg, 0x01);
 808                 val = 257 - val;
 809         }
 810         /* Use lookup table for funky Argus QuickClix brightness */
 811         if (sd->do_lcd_stop)
 812                 val = quick_clix_table[val];
 813
 814         sensor_write1(gspca_dev, value_reg, val);
 815 }
 816
 817 static void setexposure(struct gspca_dev *gspca_dev, s32 expo, s32 min_clockdiv)
 818 {
 819         struct sd *sd = (struct sd *) gspca_dev;
 820         int exposure = MR97310A_EXPOSURE_DEFAULT;
 821         u8 buf[2];
 822
 823         if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1) {
 824                 /* This cam does not like exposure settings < 300,
 825                    so scale 0 - 4095 to 300 - 4095 */
 826                 exposure = (expo * 9267) / 10000 + 300;
 827                 sensor_write1(gspca_dev, 3, exposure >> 4);
 828                 sensor_write1(gspca_dev, 4, exposure & 0x0f);
 829         } else if (sd->sensor_type == 2) {
 830                 exposure = expo;
 831                 exposure >>= 3;
 832                 sensor_write1(gspca_dev, 3, exposure >> 8);
 833                 sensor_write1(gspca_dev, 4, exposure & 0xff);
 834         } else {
 835                 /* We have both a clock divider and an exposure register.
 836                    We first calculate the clock divider, as that determines
 837                    the maximum exposure and then we calculate the exposure
 838                    register setting (which goes from 0 - 511).
 839
 840                    Note our 0 - 4095 exposure is mapped to 0 - 511
 841                    milliseconds exposure time */
 842                 u8 clockdiv = (60 * expo + 7999) / 8000;
 843
 844                 /* Limit framerate to not exceed usb bandwidth */
 845                 if (clockdiv < min_clockdiv && gspca_dev->pixfmt.width >= 320)
 846                         clockdiv = min_clockdiv;
 847                 else if (clockdiv < 2)
 848                         clockdiv = 2;
 849
 850                 if (sd->cam_type == CAM_TYPE_VGA && clockdiv < 4)
 851                         clockdiv = 4;
 852
 853                 /* Frame exposure time in ms = 1000 * clockdiv / 60 ->
 854                 exposure = (sd->exposure / 8) * 511 / (1000 * clockdiv / 60) */
 855                 exposure = (60 * 511 * expo) / (8000 * clockdiv);
 856                 if (exposure > 511)
 857                         exposure = 511;
 858
 859                 /* exposure register value is reversed! */
 860                 exposure = 511 - exposure;
 861
 862                 buf[0] = exposure & 0xff;
 863                 buf[1] = exposure >> 8;
 864                 sensor_write_reg(gspca_dev, 0x0e, 0, buf, 2);
 865                 sensor_write1(gspca_dev, 0x02, clockdiv);
 866         }
 867 }
 868
 869 static void setgain(struct gspca_dev *gspca_dev, s32 val)
 870 {
 871         struct sd *sd = (struct sd *) gspca_dev;
 872         u8 gainreg;
 873
 874         if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1)
 875                 sensor_write1(gspca_dev, 0x0e, val);
 876         else if (sd->cam_type == CAM_TYPE_VGA && sd->sensor_type == 2)
 877                 for (gainreg = 0x0a; gainreg < 0x11; gainreg += 2) {
 878                         sensor_write1(gspca_dev, gainreg, val >> 8);
 879                         sensor_write1(gspca_dev, gainreg + 1, val & 0xff);
 880                 }
 881         else
 882                 sensor_write1(gspca_dev, 0x10, val);
 883 }
 884
 885 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
 886 {
 887         sensor_write1(gspca_dev, 0x1c, val);
 888 }
 889
 890 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 891 {
 892         struct gspca_dev *gspca_dev =
 893                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 894         struct sd *sd = (struct sd *)gspca_dev;
 895
 896         gspca_dev->usb_err = 0;
 897
 898         if (!gspca_dev->streaming)
 899                 return 0;
 900
 901         switch (ctrl->id) {
 902         case V4L2_CID_BRIGHTNESS:
 903                 setbrightness(gspca_dev, ctrl->val);
 904                 break;
 905         case V4L2_CID_CONTRAST:
 906                 setcontrast(gspca_dev, ctrl->val);
 907                 break;
 908         case V4L2_CID_EXPOSURE:
 909                 setexposure(gspca_dev, sd->exposure->val,
 910                             sd->min_clockdiv ? sd->min_clockdiv->val : 0);
 911                 break;
 912         case V4L2_CID_GAIN:
 913                 setgain(gspca_dev, ctrl->val);
 914                 break;
 915         }
 916         return gspca_dev->usb_err;
 917 }
 918
 919 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 920         .s_ctrl = sd_s_ctrl,
 921 };
 922
 923 static int sd_init_controls(struct gspca_dev *gspca_dev)
 924 {
 925         struct sd *sd = (struct sd *)gspca_dev;
 926         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 927         static const struct v4l2_ctrl_config clockdiv = {
 928                 .ops = &sd_ctrl_ops,
 929                 .id = MR97310A_CID_CLOCKDIV,
 930                 .type = V4L2_CTRL_TYPE_INTEGER,
 931                 .name = "Minimum Clock Divider",
 932                 .min = MR97310A_MIN_CLOCKDIV_MIN,
 933                 .max = MR97310A_MIN_CLOCKDIV_MAX,
 934                 .step = 1,
 935                 .def = MR97310A_MIN_CLOCKDIV_DEFAULT,
 936         };
 937         bool has_brightness = false;
 938         bool has_argus_brightness = false;
 939         bool has_contrast = false;
 940         bool has_gain = false;
 941         bool has_cs_gain = false;
 942         bool has_exposure = false;
 943         bool has_clockdiv = false;
 944
 945         gspca_dev->vdev.ctrl_handler = hdl;
 946         v4l2_ctrl_handler_init(hdl, 4);
 947
 948         /* Setup controls depending on camera type */
 949         if (sd->cam_type == CAM_TYPE_CIF) {
 950                 /* No brightness for sensor_type 0 */
 951                 if (sd->sensor_type == 0)
 952                         has_exposure = has_gain = has_clockdiv = true;
 953                 else
 954                         has_exposure = has_gain = has_brightness = true;
 955         } else {
 956                 /* All controls need to be disabled if VGA sensor_type is 0 */
 957                 if (sd->sensor_type == 0)
 958                         ; /* no controls! */
 959                 else if (sd->sensor_type == 2)
 960                         has_exposure = has_cs_gain = has_contrast = true;
 961                 else if (sd->do_lcd_stop)
 962                         has_exposure = has_gain = has_argus_brightness =
 963                                 has_clockdiv = true;
 964                 else
 965                         has_exposure = has_gain = has_brightness =
 966                                 has_clockdiv = true;
 967         }
 968
 969         /* Separate brightness control description for Argus QuickClix as it has
 970          * different limits from the other mr97310a cameras, and separate gain
 971          * control for Sakar CyberPix camera. */
 972         /*
 973          * This control is disabled for CIF type 1 and VGA type 0 cameras.
 974          * It does not quite act linearly for the Argus QuickClix camera,
 975          * but it does control brightness. The values are 0 - 15 only, and
 976          * the table above makes them act consecutively.
 977          */
 978         if (has_brightness)
 979                 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 980                         V4L2_CID_BRIGHTNESS, -254, 255, 1,
 981                         MR97310A_BRIGHTNESS_DEFAULT);
 982         else if (has_argus_brightness)
 983                 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 984                         V4L2_CID_BRIGHTNESS, 0, 15, 1,
 985                         MR97310A_BRIGHTNESS_DEFAULT);
 986         if (has_contrast)
 987                 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 988                         V4L2_CID_CONTRAST, MR97310A_CONTRAST_MIN,
 989                         MR97310A_CONTRAST_MAX, 1, MR97310A_CONTRAST_DEFAULT);
 990         if (has_gain)
 991                 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 992                         V4L2_CID_GAIN, MR97310A_GAIN_MIN, MR97310A_GAIN_MAX,
 993                         1, MR97310A_GAIN_DEFAULT);
 994         else if (has_cs_gain)
 995                 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_GAIN,
 996                         MR97310A_CS_GAIN_MIN, MR97310A_CS_GAIN_MAX,
 997                         1, MR97310A_CS_GAIN_DEFAULT);
 998         if (has_exposure)
 999                 sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1000                         V4L2_CID_EXPOSURE, MR97310A_EXPOSURE_MIN,
1001                         MR97310A_EXPOSURE_MAX, 1, MR97310A_EXPOSURE_DEFAULT);
1002         if (has_clockdiv)
1003                 sd->min_clockdiv = v4l2_ctrl_new_custom(hdl, &clockdiv, NULL);
1004
1005         if (hdl->error) {
1006                 pr_err("Could not initialize controls\n");
1007                 return hdl->error;
1008         }
1009         if (has_exposure && has_clockdiv)
1010                 v4l2_ctrl_cluster(2, &sd->exposure);
1011         return 0;
1012 }
1013
1014 /* Include pac common sof detection functions */
1015 #include "pac_common.h"
1016
1017 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1018                         u8 *data,               /* isoc packet */
1019                         int len)                /* iso packet length */
1020 {
1021         struct sd *sd = (struct sd *) gspca_dev;
1022         unsigned char *sof;
1023
1024         sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len);
1025         if (sof) {
1026                 int n;
1027
1028                 /* finish decoding current frame */
1029                 n = sof - data;
1030                 if (n > sizeof pac_sof_marker)
1031                         n -= sizeof pac_sof_marker;
1032                 else
1033                         n = 0;
1034                 gspca_frame_add(gspca_dev, LAST_PACKET,
1035                                         data, n);
1036                 /* Start next frame. */
1037                 gspca_frame_add(gspca_dev, FIRST_PACKET,
1038                         pac_sof_marker, sizeof pac_sof_marker);
1039                 len -= sof - data;
1040                 data = sof;
1041         }
1042         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1043 }
1044
1045 /* sub-driver description */
1046 static const struct sd_desc sd_desc = {
1047         .name = MODULE_NAME,
1048         .config = sd_config,
1049         .init = sd_init,
1050         .init_controls = sd_init_controls,
1051         .start = sd_start,
1052         .stopN = sd_stopN,
1053         .pkt_scan = sd_pkt_scan,
1054 };
1055
1056 /* -- module initialisation -- */
1057 static const struct usb_device_id device_table[] = {
1058         {USB_DEVICE(0x08ca, 0x0110)},   /* Trust Spyc@m 100 */
1059         {USB_DEVICE(0x08ca, 0x0111)},   /* Aiptek Pencam VGA+ */
1060         {USB_DEVICE(0x093a, 0x010f)},   /* All other known MR97310A VGA cams */
1061         {USB_DEVICE(0x093a, 0x010e)},   /* All known MR97310A CIF cams */
1062         {}
1063 };
1064 MODULE_DEVICE_TABLE(usb, device_table);
1065
1066 /* -- device connect -- */
1067 static int sd_probe(struct usb_interface *intf,
1068                     const struct usb_device_id *id)
1069 {
1070         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1071                                THIS_MODULE);
1072 }
1073
1074 static struct usb_driver sd_driver = {
1075         .name = MODULE_NAME,
1076         .id_table = device_table,
1077         .probe = sd_probe,
1078         .disconnect = gspca_disconnect,
1079 #ifdef CONFIG_PM
1080         .suspend = gspca_suspend,
1081         .resume = gspca_resume,
1082         .reset_resume = gspca_resume,
1083 #endif
1084 };
1085
1086 module_usb_driver(sd_driver);