drivers/media/usb/gspca/spca561.c

   1 /*
   2  * Sunplus spca561 subdriver
   3  *
   4  * Copyright (C) 2004 Michel Xhaard mxhaard@magic.fr
   5  *
   6  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21  */
  22
  23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24
  25 #define MODULE_NAME "spca561"
  26
  27 #include <linux/input.h>
  28 #include "gspca.h"
  29
  30 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  31 MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver");
  32 MODULE_LICENSE("GPL");
  33
  34 #define EXPOSURE_MAX (2047 + 325)
  35
  36 /* specific webcam descriptor */
  37 struct sd {
  38         struct gspca_dev gspca_dev;     /* !! must be the first item */
  39
  40         struct { /* hue/contrast control cluster */
  41                 struct v4l2_ctrl *contrast;
  42                 struct v4l2_ctrl *hue;
  43         };
  44         struct v4l2_ctrl *autogain;
  45
  46 #define EXPO12A_DEF 3
  47         __u8 expo12a;           /* expo/gain? for rev 12a */
  48
  49         __u8 chip_revision;
  50 #define Rev012A 0
  51 #define Rev072A 1
  52
  53         signed char ag_cnt;
  54 #define AG_CNT_START 13
  55 };
  56
  57 static const struct v4l2_pix_format sif_012a_mode[] = {
  58         {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
  59                 .bytesperline = 160,
  60                 .sizeimage = 160 * 120,
  61                 .colorspace = V4L2_COLORSPACE_SRGB,
  62                 .priv = 3},
  63         {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
  64                 .bytesperline = 176,
  65                 .sizeimage = 176 * 144,
  66                 .colorspace = V4L2_COLORSPACE_SRGB,
  67                 .priv = 2},
  68         {320, 240, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
  69                 .bytesperline = 320,
  70                 .sizeimage = 320 * 240 * 4 / 8,
  71                 .colorspace = V4L2_COLORSPACE_SRGB,
  72                 .priv = 1},
  73         {352, 288, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
  74                 .bytesperline = 352,
  75                 .sizeimage = 352 * 288 * 4 / 8,
  76                 .colorspace = V4L2_COLORSPACE_SRGB,
  77                 .priv = 0},
  78 };
  79
  80 static const struct v4l2_pix_format sif_072a_mode[] = {
  81         {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
  82                 .bytesperline = 160,
  83                 .sizeimage = 160 * 120,
  84                 .colorspace = V4L2_COLORSPACE_SRGB,
  85                 .priv = 3},
  86         {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
  87                 .bytesperline = 176,
  88                 .sizeimage = 176 * 144,
  89                 .colorspace = V4L2_COLORSPACE_SRGB,
  90                 .priv = 2},
  91         {320, 240, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
  92                 .bytesperline = 320,
  93                 .sizeimage = 320 * 240,
  94                 .colorspace = V4L2_COLORSPACE_SRGB,
  95                 .priv = 1},
  96         {352, 288, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
  97                 .bytesperline = 352,
  98                 .sizeimage = 352 * 288,
  99                 .colorspace = V4L2_COLORSPACE_SRGB,
 100                 .priv = 0},
 101 };
 102
 103 /*
 104  * Initialization data
 105  * I'm not very sure how to split initialization from open data
 106  * chunks. For now, we'll consider everything as initialization
 107  */
 108 /* Frame packet header offsets for the spca561 */
 109 #define SPCA561_OFFSET_SNAP 1
 110 #define SPCA561_OFFSET_TYPE 2
 111 #define SPCA561_OFFSET_COMPRESS 3
 112 #define SPCA561_OFFSET_FRAMSEQ   4
 113 #define SPCA561_OFFSET_GPIO 5
 114 #define SPCA561_OFFSET_USBBUFF 6
 115 #define SPCA561_OFFSET_WIN2GRAVE 7
 116 #define SPCA561_OFFSET_WIN2RAVE 8
 117 #define SPCA561_OFFSET_WIN2BAVE 9
 118 #define SPCA561_OFFSET_WIN2GBAVE 10
 119 #define SPCA561_OFFSET_WIN1GRAVE 11
 120 #define SPCA561_OFFSET_WIN1RAVE 12
 121 #define SPCA561_OFFSET_WIN1BAVE 13
 122 #define SPCA561_OFFSET_WIN1GBAVE 14
 123 #define SPCA561_OFFSET_FREQ 15
 124 #define SPCA561_OFFSET_VSYNC 16
 125 #define SPCA561_INDEX_I2C_BASE 0x8800
 126 #define SPCA561_SNAPBIT 0x20
 127 #define SPCA561_SNAPCTRL 0x40
 128
 129 static const u16 rev72a_reset[][2] = {
 130         {0x0000, 0x8114},       /* Software GPIO output data */
 131         {0x0001, 0x8114},       /* Software GPIO output data */
 132         {0x0000, 0x8112},       /* Some kind of reset */
 133         {}
 134 };
 135 static const __u16 rev72a_init_data1[][2] = {
 136         {0x0003, 0x8701},       /* PCLK clock delay adjustment */
 137         {0x0001, 0x8703},       /* HSYNC from cmos inverted */
 138         {0x0011, 0x8118},       /* Enable and conf sensor */
 139         {0x0001, 0x8118},       /* Conf sensor */
 140         {0x0092, 0x8804},       /* I know nothing about these */
 141         {0x0010, 0x8802},       /* 0x88xx registers, so I won't */
 142         {}
 143 };
 144 static const u16 rev72a_init_sensor1[][2] = {
 145         {0x0001, 0x000d},
 146         {0x0002, 0x0018},
 147         {0x0004, 0x0165},
 148         {0x0005, 0x0021},
 149         {0x0007, 0x00aa},
 150         {0x0020, 0x1504},
 151         {0x0039, 0x0002},
 152         {0x0035, 0x0010},
 153         {0x0009, 0x1049},
 154         {0x0028, 0x000b},
 155         {0x003b, 0x000f},
 156         {0x003c, 0x0000},
 157         {}
 158 };
 159 static const __u16 rev72a_init_data2[][2] = {
 160         {0x0018, 0x8601},       /* Pixel/line selection for color separation */
 161         {0x0000, 0x8602},       /* Optical black level for user setting */
 162         {0x0060, 0x8604},       /* Optical black horizontal offset */
 163         {0x0002, 0x8605},       /* Optical black vertical offset */
 164         {0x0000, 0x8603},       /* Non-automatic optical black level */
 165         {0x0002, 0x865b},       /* Horizontal offset for valid pixels */
 166         {0x0000, 0x865f},       /* Vertical valid pixels window (x2) */
 167         {0x00b0, 0x865d},       /* Horizontal valid pixels window (x2) */
 168         {0x0090, 0x865e},       /* Vertical valid lines window (x2) */
 169         {0x00e0, 0x8406},       /* Memory buffer threshold */
 170         {0x0000, 0x8660},       /* Compensation memory stuff */
 171         {0x0002, 0x8201},       /* Output address for r/w serial EEPROM */
 172         {0x0008, 0x8200},       /* Clear valid bit for serial EEPROM */
 173         {0x0001, 0x8200},       /* OprMode to be executed by hardware */
 174 /* from ms-win */
 175         {0x0000, 0x8611},       /* R offset for white balance */
 176         {0x00fd, 0x8612},       /* Gr offset for white balance */
 177         {0x0003, 0x8613},       /* B offset for white balance */
 178         {0x0000, 0x8614},       /* Gb offset for white balance */
 179 /* from ms-win */
 180         {0x0035, 0x8651},       /* R gain for white balance */
 181         {0x0040, 0x8652},       /* Gr gain for white balance */
 182         {0x005f, 0x8653},       /* B gain for white balance */
 183         {0x0040, 0x8654},       /* Gb gain for white balance */
 184         {0x0002, 0x8502},       /* Maximum average bit rate stuff */
 185         {0x0011, 0x8802},
 186
 187         {0x0087, 0x8700},       /* Set master clock (96Mhz????) */
 188         {0x0081, 0x8702},       /* Master clock output enable */
 189
 190         {0x0000, 0x8500},       /* Set image type (352x288 no compression) */
 191         /* Originally was 0x0010 (352x288 compression) */
 192
 193         {0x0002, 0x865b},       /* Horizontal offset for valid pixels */
 194         {0x0003, 0x865c},       /* Vertical offset for valid lines */
 195         {}
 196 };
 197 static const u16 rev72a_init_sensor2[][2] = {
 198         {0x0003, 0x0121},
 199         {0x0004, 0x0165},
 200         {0x0005, 0x002f},       /* blanking control column */
 201         {0x0006, 0x0000},       /* blanking mode row*/
 202         {0x000a, 0x0002},
 203         {0x0009, 0x1061},       /* setexposure times && pixel clock
 204                                  * 0001 0 | 000 0110 0001 */
 205         {0x0035, 0x0014},
 206         {}
 207 };
 208
 209 /******************** QC Express etch2 stuff ********************/
 210 static const __u16 Pb100_1map8300[][2] = {
 211         /* reg, value */
 212         {0x8320, 0x3304},
 213
 214         {0x8303, 0x0125},       /* image area */
 215         {0x8304, 0x0169},
 216         {0x8328, 0x000b},
 217         {0x833c, 0x0001},               /*fixme: win:07*/
 218
 219         {0x832f, 0x1904},               /*fixme: was 0419*/
 220         {0x8307, 0x00aa},
 221         {0x8301, 0x0003},
 222         {0x8302, 0x000e},
 223         {}
 224 };
 225 static const __u16 Pb100_2map8300[][2] = {
 226         /* reg, value */
 227         {0x8339, 0x0000},
 228         {0x8307, 0x00aa},
 229         {}
 230 };
 231
 232 static const __u16 spca561_161rev12A_data1[][2] = {
 233         {0x29, 0x8118},         /* Control register (various enable bits) */
 234         {0x08, 0x8114},         /* GPIO: Led off */
 235         {0x0e, 0x8112},         /* 0x0e stream off 0x3e stream on */
 236         {0x00, 0x8102},         /* white balance - new */
 237         {0x92, 0x8804},
 238         {0x04, 0x8802},         /* windows uses 08 */
 239         {}
 240 };
 241 static const __u16 spca561_161rev12A_data2[][2] = {
 242         {0x21, 0x8118},
 243         {0x10, 0x8500},
 244         {0x07, 0x8601},
 245         {0x07, 0x8602},
 246         {0x04, 0x8501},
 247
 248         {0x07, 0x8201},         /* windows uses 02 */
 249         {0x08, 0x8200},
 250         {0x01, 0x8200},
 251
 252         {0x90, 0x8604},
 253         {0x00, 0x8605},
 254         {0xb0, 0x8603},
 255
 256         /* sensor gains */
 257         {0x07, 0x8601},         /* white balance - new */
 258         {0x07, 0x8602},         /* white balance - new */
 259         {0x00, 0x8610},         /* *red */
 260         {0x00, 0x8611},         /* 3f   *green */
 261         {0x00, 0x8612},         /* green *blue */
 262         {0x00, 0x8613},         /* blue *green */
 263         {0x43, 0x8614},         /* green *red - white balance - was 0x35 */
 264         {0x40, 0x8615},         /* 40   *green - white balance - was 0x35 */
 265         {0x71, 0x8616},         /* 7a   *blue - white balance - was 0x35 */
 266         {0x40, 0x8617},         /* 40   *green - white balance - was 0x35 */
 267
 268         {0x0c, 0x8620},         /* 0c */
 269         {0xc8, 0x8631},         /* c8 */
 270         {0xc8, 0x8634},         /* c8 */
 271         {0x23, 0x8635},         /* 23 */
 272         {0x1f, 0x8636},         /* 1f */
 273         {0xdd, 0x8637},         /* dd */
 274         {0xe1, 0x8638},         /* e1 */
 275         {0x1d, 0x8639},         /* 1d */
 276         {0x21, 0x863a},         /* 21 */
 277         {0xe3, 0x863b},         /* e3 */
 278         {0xdf, 0x863c},         /* df */
 279         {0xf0, 0x8505},
 280         {0x32, 0x850a},
 281 /*      {0x99, 0x8700},          * - white balance - new (removed) */
 282         /* HDG we used to do this in stop0, making the init state and the state
 283            after a start / stop different, so do this here instead. */
 284         {0x29, 0x8118},
 285         {}
 286 };
 287
 288 static void reg_w_val(struct gspca_dev *gspca_dev, __u16 index, __u8 value)
 289 {
 290         int ret;
 291         struct usb_device *dev = gspca_dev->dev;
 292
 293         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 294                               0,                /* request */
 295                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 296                               value, index, NULL, 0, 500);
 297         PDEBUG(D_USBO, "reg write: 0x%02x:0x%02x", index, value);
 298         if (ret < 0)
 299                 pr_err("reg write: error %d\n", ret);
 300 }
 301
 302 static void write_vector(struct gspca_dev *gspca_dev,
 303                         const __u16 data[][2])
 304 {
 305         int i;
 306
 307         i = 0;
 308         while (data[i][1] != 0) {
 309                 reg_w_val(gspca_dev, data[i][1], data[i][0]);
 310                 i++;
 311         }
 312 }
 313
 314 /* read 'len' bytes to gspca_dev->usb_buf */
 315 static void reg_r(struct gspca_dev *gspca_dev,
 316                   __u16 index, __u16 length)
 317 {
 318         usb_control_msg(gspca_dev->dev,
 319                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 320                         0,                      /* request */
 321                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 322                         0,                      /* value */
 323                         index, gspca_dev->usb_buf, length, 500);
 324 }
 325
 326 /* write 'len' bytes from gspca_dev->usb_buf */
 327 static void reg_w_buf(struct gspca_dev *gspca_dev,
 328                       __u16 index, __u16 len)
 329 {
 330         usb_control_msg(gspca_dev->dev,
 331                         usb_sndctrlpipe(gspca_dev->dev, 0),
 332                         0,                      /* request */
 333                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 334                         0,                      /* value */
 335                         index, gspca_dev->usb_buf, len, 500);
 336 }
 337
 338 static void i2c_write(struct gspca_dev *gspca_dev, __u16 value, __u16 reg)
 339 {
 340         int retry = 60;
 341
 342         reg_w_val(gspca_dev, 0x8801, reg);
 343         reg_w_val(gspca_dev, 0x8805, value);
 344         reg_w_val(gspca_dev, 0x8800, value >> 8);
 345         do {
 346                 reg_r(gspca_dev, 0x8803, 1);
 347                 if (!gspca_dev->usb_buf[0])
 348                         return;
 349                 msleep(10);
 350         } while (--retry);
 351 }
 352
 353 static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode)
 354 {
 355         int retry = 60;
 356         __u8 value;
 357
 358         reg_w_val(gspca_dev, 0x8804, 0x92);
 359         reg_w_val(gspca_dev, 0x8801, reg);
 360         reg_w_val(gspca_dev, 0x8802, mode | 0x01);
 361         do {
 362                 reg_r(gspca_dev, 0x8803, 1);
 363                 if (!gspca_dev->usb_buf[0]) {
 364                         reg_r(gspca_dev, 0x8800, 1);
 365                         value = gspca_dev->usb_buf[0];
 366                         reg_r(gspca_dev, 0x8805, 1);
 367                         return ((int) value << 8) | gspca_dev->usb_buf[0];
 368                 }
 369                 msleep(10);
 370         } while (--retry);
 371         return -1;
 372 }
 373
 374 static void sensor_mapwrite(struct gspca_dev *gspca_dev,
 375                             const __u16 (*sensormap)[2])
 376 {
 377         while ((*sensormap)[0]) {
 378                 gspca_dev->usb_buf[0] = (*sensormap)[1];
 379                 gspca_dev->usb_buf[1] = (*sensormap)[1] >> 8;
 380                 reg_w_buf(gspca_dev, (*sensormap)[0], 2);
 381                 sensormap++;
 382         }
 383 }
 384
 385 static void write_sensor_72a(struct gspca_dev *gspca_dev,
 386                             const __u16 (*sensor)[2])
 387 {
 388         while ((*sensor)[0]) {
 389                 i2c_write(gspca_dev, (*sensor)[1], (*sensor)[0]);
 390                 sensor++;
 391         }
 392 }
 393
 394 static void init_161rev12A(struct gspca_dev *gspca_dev)
 395 {
 396         write_vector(gspca_dev, spca561_161rev12A_data1);
 397         sensor_mapwrite(gspca_dev, Pb100_1map8300);
 398 /*fixme: should be in sd_start*/
 399         write_vector(gspca_dev, spca561_161rev12A_data2);
 400         sensor_mapwrite(gspca_dev, Pb100_2map8300);
 401 }
 402
 403 /* this function is called at probe time */
 404 static int sd_config(struct gspca_dev *gspca_dev,
 405                      const struct usb_device_id *id)
 406 {
 407         struct sd *sd = (struct sd *) gspca_dev;
 408         struct cam *cam;
 409         __u16 vendor, product;
 410         __u8 data1, data2;
 411
 412         /* Read frm global register the USB product and vendor IDs, just to
 413          * prove that we can communicate with the device.  This works, which
 414          * confirms at we are communicating properly and that the device
 415          * is a 561. */
 416         reg_r(gspca_dev, 0x8104, 1);
 417         data1 = gspca_dev->usb_buf[0];
 418         reg_r(gspca_dev, 0x8105, 1);
 419         data2 = gspca_dev->usb_buf[0];
 420         vendor = (data2 << 8) | data1;
 421         reg_r(gspca_dev, 0x8106, 1);
 422         data1 = gspca_dev->usb_buf[0];
 423         reg_r(gspca_dev, 0x8107, 1);
 424         data2 = gspca_dev->usb_buf[0];
 425         product = (data2 << 8) | data1;
 426         if (vendor != id->idVendor || product != id->idProduct) {
 427                 PDEBUG(D_PROBE, "Bad vendor / product from device");
 428                 return -EINVAL;
 429         }
 430
 431         cam = &gspca_dev->cam;
 432         cam->needs_full_bandwidth = 1;
 433
 434         sd->chip_revision = id->driver_info;
 435         if (sd->chip_revision == Rev012A) {
 436                 cam->cam_mode = sif_012a_mode;
 437                 cam->nmodes = ARRAY_SIZE(sif_012a_mode);
 438         } else {
 439                 cam->cam_mode = sif_072a_mode;
 440                 cam->nmodes = ARRAY_SIZE(sif_072a_mode);
 441         }
 442         sd->expo12a = EXPO12A_DEF;
 443         return 0;
 444 }
 445
 446 /* this function is called at probe and resume time */
 447 static int sd_init_12a(struct gspca_dev *gspca_dev)
 448 {
 449         PDEBUG(D_STREAM, "Chip revision: 012a");
 450         init_161rev12A(gspca_dev);
 451         return 0;
 452 }
 453 static int sd_init_72a(struct gspca_dev *gspca_dev)
 454 {
 455         PDEBUG(D_STREAM, "Chip revision: 072a");
 456         write_vector(gspca_dev, rev72a_reset);
 457         msleep(200);
 458         write_vector(gspca_dev, rev72a_init_data1);
 459         write_sensor_72a(gspca_dev, rev72a_init_sensor1);
 460         write_vector(gspca_dev, rev72a_init_data2);
 461         write_sensor_72a(gspca_dev, rev72a_init_sensor2);
 462         reg_w_val(gspca_dev, 0x8112, 0x30);
 463         return 0;
 464 }
 465
 466 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
 467 {
 468         struct sd *sd = (struct sd *) gspca_dev;
 469         __u16 reg;
 470
 471         if (sd->chip_revision == Rev012A)
 472                 reg = 0x8610;
 473         else
 474                 reg = 0x8611;
 475
 476         reg_w_val(gspca_dev, reg + 0, val);             /* R */
 477         reg_w_val(gspca_dev, reg + 1, val);             /* Gr */
 478         reg_w_val(gspca_dev, reg + 2, val);             /* B */
 479         reg_w_val(gspca_dev, reg + 3, val);             /* Gb */
 480 }
 481
 482 static void setwhite(struct gspca_dev *gspca_dev, s32 white, s32 contrast)
 483 {
 484         struct sd *sd = (struct sd *) gspca_dev;
 485         __u8 blue, red;
 486         __u16 reg;
 487
 488         /* try to emulate MS-win as possible */
 489         red = 0x20 + white * 3 / 8;
 490         blue = 0x90 - white * 5 / 8;
 491         if (sd->chip_revision == Rev012A) {
 492                 reg = 0x8614;
 493         } else {
 494                 reg = 0x8651;
 495                 red += contrast - 0x20;
 496                 blue += contrast - 0x20;
 497                 reg_w_val(gspca_dev, 0x8652, contrast + 0x20); /* Gr */
 498                 reg_w_val(gspca_dev, 0x8654, contrast + 0x20); /* Gb */
 499         }
 500         reg_w_val(gspca_dev, reg, red);
 501         reg_w_val(gspca_dev, reg + 2, blue);
 502 }
 503
 504 /* rev 12a only */
 505 static void setexposure(struct gspca_dev *gspca_dev, s32 val)
 506 {
 507         int i, expo = 0;
 508
 509         /* Register 0x8309 controls exposure for the spca561,
 510            the basic exposure setting goes from 1-2047, where 1 is completely
 511            dark and 2047 is very bright. It not only influences exposure but
 512            also the framerate (to allow for longer exposure) from 1 - 300 it
 513            only raises the exposure time then from 300 - 600 it halves the
 514            framerate to be able to further raise the exposure time and for every
 515            300 more it halves the framerate again. This allows for a maximum
 516            exposure time of circa 0.2 - 0.25 seconds (30 / (2000/3000) fps).
 517            Sometimes this is not enough, the 1-2047 uses bits 0-10, bits 11-12
 518            configure a divider for the base framerate which us used at the
 519            exposure setting of 1-300. These bits configure the base framerate
 520            according to the following formula: fps = 60 / (value + 2) */
 521
 522         /* We choose to use the high bits setting the fixed framerate divisor
 523            asap, as setting high basic exposure setting without the fixed
 524            divider in combination with high gains makes the cam stop */
 525         int table[] =  { 0, 450, 550, 625, EXPOSURE_MAX };
 526
 527         for (i = 0; i < ARRAY_SIZE(table) - 1; i++) {
 528                 if (val <= table[i + 1]) {
 529                         expo  = val - table[i];
 530                         if (i)
 531                                 expo += 300;
 532                         expo |= i << 11;
 533                         break;
 534                 }
 535         }
 536
 537         gspca_dev->usb_buf[0] = expo;
 538         gspca_dev->usb_buf[1] = expo >> 8;
 539         reg_w_buf(gspca_dev, 0x8309, 2);
 540 }
 541
 542 /* rev 12a only */
 543 static void setgain(struct gspca_dev *gspca_dev, s32 val)
 544 {
 545         /* gain reg low 6 bits  0-63 gain, bit 6 and 7, both double the
 546            sensitivity when set, so 31 + one of them set == 63, and 15
 547            with both of them set == 63 */
 548         if (val < 64)
 549                 gspca_dev->usb_buf[0] = val;
 550         else if (val < 128)
 551                 gspca_dev->usb_buf[0] = (val / 2) | 0x40;
 552         else
 553                 gspca_dev->usb_buf[0] = (val / 4) | 0xc0;
 554
 555         gspca_dev->usb_buf[1] = 0;
 556         reg_w_buf(gspca_dev, 0x8335, 2);
 557 }
 558
 559 static void setautogain(struct gspca_dev *gspca_dev, s32 val)
 560 {
 561         struct sd *sd = (struct sd *) gspca_dev;
 562
 563         if (val)
 564                 sd->ag_cnt = AG_CNT_START;
 565         else
 566                 sd->ag_cnt = -1;
 567 }
 568
 569 static int sd_start_12a(struct gspca_dev *gspca_dev)
 570 {
 571         int mode;
 572         static const __u8 Reg8391[8] =
 573                 {0x92, 0x30, 0x20, 0x00, 0x0c, 0x00, 0x00, 0x00};
 574
 575         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
 576         if (mode <= 1) {
 577                 /* Use compression on 320x240 and above */
 578                 reg_w_val(gspca_dev, 0x8500, 0x10 | mode);
 579         } else {
 580                 /* I couldn't get the compression to work below 320x240
 581                  * Fortunately at these resolutions the bandwidth
 582                  * is sufficient to push raw frames at ~20fps */
 583                 reg_w_val(gspca_dev, 0x8500, mode);
 584         }               /* -- qq@kuku.eu.org */
 585
 586         gspca_dev->usb_buf[0] = 0xaa;
 587         gspca_dev->usb_buf[1] = 0x00;
 588         reg_w_buf(gspca_dev, 0x8307, 2);
 589         /* clock - lower 0x8X values lead to fps > 30 */
 590         reg_w_val(gspca_dev, 0x8700, 0x8a);
 591                                         /* 0x8f 0x85 0x27 clock */
 592         reg_w_val(gspca_dev, 0x8112, 0x1e | 0x20);
 593         reg_w_val(gspca_dev, 0x850b, 0x03);
 594         memcpy(gspca_dev->usb_buf, Reg8391, 8);
 595         reg_w_buf(gspca_dev, 0x8391, 8);
 596         reg_w_buf(gspca_dev, 0x8390, 8);
 597
 598         /* Led ON (bit 3 -> 0 */
 599         reg_w_val(gspca_dev, 0x8114, 0x00);
 600         return 0;
 601 }
 602 static int sd_start_72a(struct gspca_dev *gspca_dev)
 603 {
 604         struct sd *sd = (struct sd *) gspca_dev;
 605         int Clck;
 606         int mode;
 607
 608         write_vector(gspca_dev, rev72a_reset);
 609         msleep(200);
 610         write_vector(gspca_dev, rev72a_init_data1);
 611         write_sensor_72a(gspca_dev, rev72a_init_sensor1);
 612
 613         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
 614         switch (mode) {
 615         default:
 616         case 0:
 617                 Clck = 0x27;            /* ms-win 0x87 */
 618                 break;
 619         case 1:
 620                 Clck = 0x25;
 621                 break;
 622         case 2:
 623                 Clck = 0x22;
 624                 break;
 625         case 3:
 626                 Clck = 0x21;
 627                 break;
 628         }
 629         reg_w_val(gspca_dev, 0x8700, Clck);     /* 0x27 clock */
 630         reg_w_val(gspca_dev, 0x8702, 0x81);
 631         reg_w_val(gspca_dev, 0x8500, mode);     /* mode */
 632         write_sensor_72a(gspca_dev, rev72a_init_sensor2);
 633         setwhite(gspca_dev, v4l2_ctrl_g_ctrl(sd->hue),
 634                         v4l2_ctrl_g_ctrl(sd->contrast));
 635 /*      setbrightness(gspca_dev);        * fixme: bad values */
 636         setautogain(gspca_dev, v4l2_ctrl_g_ctrl(sd->autogain));
 637         reg_w_val(gspca_dev, 0x8112, 0x10 | 0x20);
 638         return 0;
 639 }
 640
 641 static void sd_stopN(struct gspca_dev *gspca_dev)
 642 {
 643         struct sd *sd = (struct sd *) gspca_dev;
 644
 645         if (sd->chip_revision == Rev012A) {
 646                 reg_w_val(gspca_dev, 0x8112, 0x0e);
 647                 /* Led Off (bit 3 -> 1 */
 648                 reg_w_val(gspca_dev, 0x8114, 0x08);
 649         } else {
 650                 reg_w_val(gspca_dev, 0x8112, 0x20);
 651 /*              reg_w_val(gspca_dev, 0x8102, 0x00); ?? */
 652         }
 653 }
 654
 655 static void do_autogain(struct gspca_dev *gspca_dev)
 656 {
 657         struct sd *sd = (struct sd *) gspca_dev;
 658         int expotimes;
 659         int pixelclk;
 660         int gainG;
 661         __u8 R, Gr, Gb, B;
 662         int y;
 663         __u8 luma_mean = 110;
 664         __u8 luma_delta = 20;
 665         __u8 spring = 4;
 666
 667         if (sd->ag_cnt < 0)
 668                 return;
 669         if (--sd->ag_cnt >= 0)
 670                 return;
 671         sd->ag_cnt = AG_CNT_START;
 672
 673         switch (sd->chip_revision) {
 674         case Rev072A:
 675                 reg_r(gspca_dev, 0x8621, 1);
 676                 Gr = gspca_dev->usb_buf[0];
 677                 reg_r(gspca_dev, 0x8622, 1);
 678                 R = gspca_dev->usb_buf[0];
 679                 reg_r(gspca_dev, 0x8623, 1);
 680                 B = gspca_dev->usb_buf[0];
 681                 reg_r(gspca_dev, 0x8624, 1);
 682                 Gb = gspca_dev->usb_buf[0];
 683                 y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8;
 684                 /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */
 685                 /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */
 686                 /* PDEBUG(D_CONF,"reading Y %d U %d V %d ",y,u,v); */
 687
 688                 if (y < luma_mean - luma_delta ||
 689                     y > luma_mean + luma_delta) {
 690                         expotimes = i2c_read(gspca_dev, 0x09, 0x10);
 691                         pixelclk = 0x0800;
 692                         expotimes = expotimes & 0x07ff;
 693                         /* PDEBUG(D_PACK,
 694                                 "Exposition Times 0x%03X Clock 0x%04X ",
 695                                 expotimes,pixelclk); */
 696                         gainG = i2c_read(gspca_dev, 0x35, 0x10);
 697                         /* PDEBUG(D_PACK,
 698                                 "reading Gain register %d", gainG); */
 699
 700                         expotimes += (luma_mean - y) >> spring;
 701                         gainG += (luma_mean - y) / 50;
 702                         /* PDEBUG(D_PACK,
 703                                 "compute expotimes %d gain %d",
 704                                 expotimes,gainG); */
 705
 706                         if (gainG > 0x3f)
 707                                 gainG = 0x3f;
 708                         else if (gainG < 3)
 709                                 gainG = 3;
 710                         i2c_write(gspca_dev, gainG, 0x35);
 711
 712                         if (expotimes > 0x0256)
 713                                 expotimes = 0x0256;
 714                         else if (expotimes < 3)
 715                                 expotimes = 3;
 716                         i2c_write(gspca_dev, expotimes | pixelclk, 0x09);
 717                 }
 718                 break;
 719         }
 720 }
 721
 722 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 723                         u8 *data,               /* isoc packet */
 724                         int len)                /* iso packet length */
 725 {
 726         struct sd *sd = (struct sd *) gspca_dev;
 727
 728         len--;
 729         switch (*data++) {                      /* sequence number */
 730         case 0:                                 /* start of frame */
 731                 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
 732
 733                 /* This should never happen */
 734                 if (len < 2) {
 735                         PERR("Short SOF packet, ignoring");
 736                         gspca_dev->last_packet_type = DISCARD_PACKET;
 737                         return;
 738                 }
 739
 740 #if IS_ENABLED(CONFIG_INPUT)
 741                 if (data[0] & 0x20) {
 742                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
 743                         input_sync(gspca_dev->input_dev);
 744                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
 745                         input_sync(gspca_dev->input_dev);
 746                 }
 747 #endif
 748
 749                 if (data[1] & 0x10) {
 750                         /* compressed bayer */
 751                         gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
 752                 } else {
 753                         /* raw bayer (with a header, which we skip) */
 754                         if (sd->chip_revision == Rev012A) {
 755                                 data += 20;
 756                                 len -= 20;
 757                         } else {
 758                                 data += 16;
 759                                 len -= 16;
 760                         }
 761                         gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
 762                 }
 763                 return;
 764         case 0xff:                      /* drop (empty mpackets) */
 765                 return;
 766         }
 767         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 768 }
 769
 770 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 771 {
 772         struct gspca_dev *gspca_dev =
 773                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 774         struct sd *sd = (struct sd *)gspca_dev;
 775
 776         gspca_dev->usb_err = 0;
 777
 778         if (!gspca_dev->streaming)
 779                 return 0;
 780
 781         switch (ctrl->id) {
 782         case V4L2_CID_BRIGHTNESS:
 783                 setbrightness(gspca_dev, ctrl->val);
 784                 break;
 785         case V4L2_CID_CONTRAST:
 786                 /* hue/contrast control cluster for 72a */
 787                 setwhite(gspca_dev, sd->hue->val, ctrl->val);
 788                 break;
 789         case V4L2_CID_HUE:
 790                 /* just plain hue control for 12a */
 791                 setwhite(gspca_dev, ctrl->val, 0);
 792                 break;
 793         case V4L2_CID_EXPOSURE:
 794                 setexposure(gspca_dev, ctrl->val);
 795                 break;
 796         case V4L2_CID_GAIN:
 797                 setgain(gspca_dev, ctrl->val);
 798                 break;
 799         case V4L2_CID_AUTOGAIN:
 800                 setautogain(gspca_dev, ctrl->val);
 801                 break;
 802         }
 803         return gspca_dev->usb_err;
 804 }
 805
 806 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 807         .s_ctrl = sd_s_ctrl,
 808 };
 809
 810 static int sd_init_controls_12a(struct gspca_dev *gspca_dev)
 811 {
 812         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 813
 814         gspca_dev->vdev.ctrl_handler = hdl;
 815         v4l2_ctrl_handler_init(hdl, 3);
 816         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 817                         V4L2_CID_HUE, 1, 0x7f, 1, 0x40);
 818         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 819                         V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
 820         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 821                         V4L2_CID_EXPOSURE, 1, EXPOSURE_MAX, 1, 700);
 822         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 823                         V4L2_CID_GAIN, 0, 255, 1, 63);
 824
 825         if (hdl->error) {
 826                 pr_err("Could not initialize controls\n");
 827                 return hdl->error;
 828         }
 829         return 0;
 830 }
 831
 832 static int sd_init_controls_72a(struct gspca_dev *gspca_dev)
 833 {
 834         struct sd *sd = (struct sd *)gspca_dev;
 835         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 836
 837         gspca_dev->vdev.ctrl_handler = hdl;
 838         v4l2_ctrl_handler_init(hdl, 4);
 839         sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 840                         V4L2_CID_CONTRAST, 0, 0x3f, 1, 0x20);
 841         sd->hue = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 842                         V4L2_CID_HUE, 1, 0x7f, 1, 0x40);
 843         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 844                         V4L2_CID_BRIGHTNESS, 0, 0x3f, 1, 0x20);
 845         sd->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 846                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
 847
 848         if (hdl->error) {
 849                 pr_err("Could not initialize controls\n");
 850                 return hdl->error;
 851         }
 852         v4l2_ctrl_cluster(2, &sd->contrast);
 853         return 0;
 854 }
 855
 856 /* sub-driver description */
 857 static const struct sd_desc sd_desc_12a = {
 858         .name = MODULE_NAME,
 859         .init_controls = sd_init_controls_12a,
 860         .config = sd_config,
 861         .init = sd_init_12a,
 862         .start = sd_start_12a,
 863         .stopN = sd_stopN,
 864         .pkt_scan = sd_pkt_scan,
 865 #if IS_ENABLED(CONFIG_INPUT)
 866         .other_input = 1,
 867 #endif
 868 };
 869 static const struct sd_desc sd_desc_72a = {
 870         .name = MODULE_NAME,
 871         .init_controls = sd_init_controls_72a,
 872         .config = sd_config,
 873         .init = sd_init_72a,
 874         .start = sd_start_72a,
 875         .stopN = sd_stopN,
 876         .pkt_scan = sd_pkt_scan,
 877         .dq_callback = do_autogain,
 878 #if IS_ENABLED(CONFIG_INPUT)
 879         .other_input = 1,
 880 #endif
 881 };
 882 static const struct sd_desc *sd_desc[2] = {
 883         &sd_desc_12a,
 884         &sd_desc_72a
 885 };
 886
 887 /* -- module initialisation -- */
 888 static const struct usb_device_id device_table[] = {
 889         {USB_DEVICE(0x041e, 0x401a), .driver_info = Rev072A},
 890         {USB_DEVICE(0x041e, 0x403b), .driver_info = Rev012A},
 891         {USB_DEVICE(0x0458, 0x7004), .driver_info = Rev072A},
 892         {USB_DEVICE(0x0461, 0x0815), .driver_info = Rev072A},
 893         {USB_DEVICE(0x046d, 0x0928), .driver_info = Rev012A},
 894         {USB_DEVICE(0x046d, 0x0929), .driver_info = Rev012A},
 895         {USB_DEVICE(0x046d, 0x092a), .driver_info = Rev012A},
 896         {USB_DEVICE(0x046d, 0x092b), .driver_info = Rev012A},
 897         {USB_DEVICE(0x046d, 0x092c), .driver_info = Rev012A},
 898         {USB_DEVICE(0x046d, 0x092d), .driver_info = Rev012A},
 899         {USB_DEVICE(0x046d, 0x092e), .driver_info = Rev012A},
 900         {USB_DEVICE(0x046d, 0x092f), .driver_info = Rev012A},
 901         {USB_DEVICE(0x04fc, 0x0561), .driver_info = Rev072A},
 902         {USB_DEVICE(0x060b, 0xa001), .driver_info = Rev072A},
 903         {USB_DEVICE(0x10fd, 0x7e50), .driver_info = Rev072A},
 904         {USB_DEVICE(0xabcd, 0xcdee), .driver_info = Rev072A},
 905         {}
 906 };
 907
 908 MODULE_DEVICE_TABLE(usb, device_table);
 909
 910 /* -- device connect -- */
 911 static int sd_probe(struct usb_interface *intf,
 912                     const struct usb_device_id *id)
 913 {
 914         return gspca_dev_probe(intf, id,
 915                                 sd_desc[id->driver_info],
 916                                 sizeof(struct sd),
 917                                THIS_MODULE);
 918 }
 919
 920 static struct usb_driver sd_driver = {
 921         .name = MODULE_NAME,
 922         .id_table = device_table,
 923         .probe = sd_probe,
 924         .disconnect = gspca_disconnect,
 925 #ifdef CONFIG_PM
 926         .suspend = gspca_suspend,
 927         .resume = gspca_resume,
 928         .reset_resume = gspca_resume,
 929 #endif
 930 };
 931
 932 module_usb_driver(sd_driver);