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