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