drivers/media/usb/gspca/mr97310a.c

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