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