drivers/media/video/gspca/sunplus.c

   1 /*
   2  *              Sunplus spca504(abc) spca533 spca536 library
   3  *              Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
   4  *
   5  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21
  22 #define MODULE_NAME "sunplus"
  23
  24 #include "gspca.h"
  25 #include "jpeg.h"
  26
  27 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  28 MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver");
  29 MODULE_LICENSE("GPL");
  30
  31 /* specific webcam descriptor */
  32 struct sd {
  33         struct gspca_dev gspca_dev;     /* !! must be the first item */
  34
  35         s8 brightness;
  36         u8 contrast;
  37         u8 colors;
  38         u8 autogain;
  39         u8 quality;
  40 #define QUALITY_MIN 70
  41 #define QUALITY_MAX 95
  42 #define QUALITY_DEF 85
  43
  44         u8 bridge;
  45 #define BRIDGE_SPCA504 0
  46 #define BRIDGE_SPCA504B 1
  47 #define BRIDGE_SPCA504C 2
  48 #define BRIDGE_SPCA533 3
  49 #define BRIDGE_SPCA536 4
  50         u8 subtype;
  51 #define AiptekMiniPenCam13 1
  52 #define LogitechClickSmart420 2
  53 #define LogitechClickSmart820 3
  54 #define MegapixV4 4
  55 #define MegaImageVI 5
  56
  57         u8 jpeg_hdr[JPEG_HDR_SZ];
  58 };
  59
  60 /* V4L2 controls supported by the driver */
  61 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  62 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  63 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  64 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  65 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
  66 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
  67 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
  68 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
  69
  70 static const struct ctrl sd_ctrls[] = {
  71         {
  72             {
  73                 .id      = V4L2_CID_BRIGHTNESS,
  74                 .type    = V4L2_CTRL_TYPE_INTEGER,
  75                 .name    = "Brightness",
  76                 .minimum = -128,
  77                 .maximum = 127,
  78                 .step    = 1,
  79 #define BRIGHTNESS_DEF 0
  80                 .default_value = BRIGHTNESS_DEF,
  81             },
  82             .set = sd_setbrightness,
  83             .get = sd_getbrightness,
  84         },
  85         {
  86             {
  87                 .id      = V4L2_CID_CONTRAST,
  88                 .type    = V4L2_CTRL_TYPE_INTEGER,
  89                 .name    = "Contrast",
  90                 .minimum = 0,
  91                 .maximum = 0xff,
  92                 .step    = 1,
  93 #define CONTRAST_DEF 0x20
  94                 .default_value = CONTRAST_DEF,
  95             },
  96             .set = sd_setcontrast,
  97             .get = sd_getcontrast,
  98         },
  99         {
 100             {
 101                 .id      = V4L2_CID_SATURATION,
 102                 .type    = V4L2_CTRL_TYPE_INTEGER,
 103                 .name    = "Color",
 104                 .minimum = 0,
 105                 .maximum = 0xff,
 106                 .step    = 1,
 107 #define COLOR_DEF 0x1a
 108                 .default_value = COLOR_DEF,
 109             },
 110             .set = sd_setcolors,
 111             .get = sd_getcolors,
 112         },
 113         {
 114             {
 115                 .id      = V4L2_CID_AUTOGAIN,
 116                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 117                 .name    = "Auto Gain",
 118                 .minimum = 0,
 119                 .maximum = 1,
 120                 .step    = 1,
 121 #define AUTOGAIN_DEF 1
 122                 .default_value = AUTOGAIN_DEF,
 123             },
 124             .set = sd_setautogain,
 125             .get = sd_getautogain,
 126         },
 127 };
 128
 129 static const struct v4l2_pix_format vga_mode[] = {
 130         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 131                 .bytesperline = 320,
 132                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 133                 .colorspace = V4L2_COLORSPACE_JPEG,
 134                 .priv = 2},
 135         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 136                 .bytesperline = 640,
 137                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 138                 .colorspace = V4L2_COLORSPACE_JPEG,
 139                 .priv = 1},
 140 };
 141
 142 static const struct v4l2_pix_format custom_mode[] = {
 143         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 144                 .bytesperline = 320,
 145                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 146                 .colorspace = V4L2_COLORSPACE_JPEG,
 147                 .priv = 2},
 148         {464, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 149                 .bytesperline = 464,
 150                 .sizeimage = 464 * 480 * 3 / 8 + 590,
 151                 .colorspace = V4L2_COLORSPACE_JPEG,
 152                 .priv = 1},
 153 };
 154
 155 static const struct v4l2_pix_format vga_mode2[] = {
 156         {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 157                 .bytesperline = 176,
 158                 .sizeimage = 176 * 144 * 3 / 8 + 590,
 159                 .colorspace = V4L2_COLORSPACE_JPEG,
 160                 .priv = 4},
 161         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 162                 .bytesperline = 320,
 163                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 164                 .colorspace = V4L2_COLORSPACE_JPEG,
 165                 .priv = 3},
 166         {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 167                 .bytesperline = 352,
 168                 .sizeimage = 352 * 288 * 3 / 8 + 590,
 169                 .colorspace = V4L2_COLORSPACE_JPEG,
 170                 .priv = 2},
 171         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 172                 .bytesperline = 640,
 173                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 174                 .colorspace = V4L2_COLORSPACE_JPEG,
 175                 .priv = 1},
 176 };
 177
 178 #define SPCA50X_OFFSET_DATA 10
 179 #define SPCA504_PCCAM600_OFFSET_SNAPSHOT 3
 180 #define SPCA504_PCCAM600_OFFSET_COMPRESS 4
 181 #define SPCA504_PCCAM600_OFFSET_MODE     5
 182 #define SPCA504_PCCAM600_OFFSET_DATA     14
 183  /* Frame packet header offsets for the spca533 */
 184 #define SPCA533_OFFSET_DATA     16
 185 #define SPCA533_OFFSET_FRAMSEQ  15
 186 /* Frame packet header offsets for the spca536 */
 187 #define SPCA536_OFFSET_DATA     4
 188 #define SPCA536_OFFSET_FRAMSEQ  1
 189
 190 struct cmd {
 191         u8 req;
 192         u16 val;
 193         u16 idx;
 194 };
 195
 196 /* Initialisation data for the Creative PC-CAM 600 */
 197 static const struct cmd spca504_pccam600_init_data[] = {
 198 /*      {0xa0, 0x0000, 0x0503},  * capture mode */
 199         {0x00, 0x0000, 0x2000},
 200         {0x00, 0x0013, 0x2301},
 201         {0x00, 0x0003, 0x2000},
 202         {0x00, 0x0001, 0x21ac},
 203         {0x00, 0x0001, 0x21a6},
 204         {0x00, 0x0000, 0x21a7}, /* brightness */
 205         {0x00, 0x0020, 0x21a8}, /* contrast */
 206         {0x00, 0x0001, 0x21ac}, /* sat/hue */
 207         {0x00, 0x0000, 0x21ad}, /* hue */
 208         {0x00, 0x001a, 0x21ae}, /* saturation */
 209         {0x00, 0x0002, 0x21a3}, /* gamma */
 210         {0x30, 0x0154, 0x0008},
 211         {0x30, 0x0004, 0x0006},
 212         {0x30, 0x0258, 0x0009},
 213         {0x30, 0x0004, 0x0000},
 214         {0x30, 0x0093, 0x0004},
 215         {0x30, 0x0066, 0x0005},
 216         {0x00, 0x0000, 0x2000},
 217         {0x00, 0x0013, 0x2301},
 218         {0x00, 0x0003, 0x2000},
 219         {0x00, 0x0013, 0x2301},
 220         {0x00, 0x0003, 0x2000},
 221 };
 222
 223 /* Creative PC-CAM 600 specific open data, sent before using the
 224  * generic initialisation data from spca504_open_data.
 225  */
 226 static const struct cmd spca504_pccam600_open_data[] = {
 227         {0x00, 0x0001, 0x2501},
 228         {0x20, 0x0500, 0x0001}, /* snapshot mode */
 229         {0x00, 0x0003, 0x2880},
 230         {0x00, 0x0001, 0x2881},
 231 };
 232
 233 /* Initialisation data for the logitech clicksmart 420 */
 234 static const struct cmd spca504A_clicksmart420_init_data[] = {
 235 /*      {0xa0, 0x0000, 0x0503},  * capture mode */
 236         {0x00, 0x0000, 0x2000},
 237         {0x00, 0x0013, 0x2301},
 238         {0x00, 0x0003, 0x2000},
 239         {0x00, 0x0001, 0x21ac},
 240         {0x00, 0x0001, 0x21a6},
 241         {0x00, 0x0000, 0x21a7}, /* brightness */
 242         {0x00, 0x0020, 0x21a8}, /* contrast */
 243         {0x00, 0x0001, 0x21ac}, /* sat/hue */
 244         {0x00, 0x0000, 0x21ad}, /* hue */
 245         {0x00, 0x001a, 0x21ae}, /* saturation */
 246         {0x00, 0x0002, 0x21a3}, /* gamma */
 247         {0x30, 0x0004, 0x000a},
 248         {0xb0, 0x0001, 0x0000},
 249
 250
 251         {0xa1, 0x0080, 0x0001},
 252         {0x30, 0x0049, 0x0000},
 253         {0x30, 0x0060, 0x0005},
 254         {0x0c, 0x0004, 0x0000},
 255         {0x00, 0x0000, 0x0000},
 256         {0x00, 0x0000, 0x2000},
 257         {0x00, 0x0013, 0x2301},
 258         {0x00, 0x0003, 0x2000},
 259         {0x00, 0x0000, 0x2000},
 260
 261 };
 262
 263 /* clicksmart 420 open data ? */
 264 static const struct cmd spca504A_clicksmart420_open_data[] = {
 265         {0x00, 0x0001, 0x2501},
 266         {0x20, 0x0502, 0x0000},
 267         {0x06, 0x0000, 0x0000},
 268         {0x00, 0x0004, 0x2880},
 269         {0x00, 0x0001, 0x2881},
 270
 271         {0xa0, 0x0000, 0x0503},
 272 };
 273
 274 static const u8 qtable_creative_pccam[2][64] = {
 275         {                               /* Q-table Y-components */
 276          0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
 277          0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
 278          0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
 279          0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
 280          0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
 281          0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
 282          0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
 283          0x16, 0x1c, 0x1d, 0x1d, 0x22, 0x1e, 0x1f, 0x1e},
 284         {                               /* Q-table C-components */
 285          0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
 286          0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
 287          0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 288          0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 289          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 290          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 291          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 292          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
 293 };
 294
 295 /* FIXME: This Q-table is identical to the Creative PC-CAM one,
 296  *              except for one byte. Possibly a typo?
 297  *              NWG: 18/05/2003.
 298  */
 299 static const u8 qtable_spca504_default[2][64] = {
 300         {                               /* Q-table Y-components */
 301          0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
 302          0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
 303          0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
 304          0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
 305          0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
 306          0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
 307          0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
 308          0x16, 0x1c, 0x1d, 0x1d, 0x1d /* 0x22 */ , 0x1e, 0x1f, 0x1e,
 309          },
 310         {                               /* Q-table C-components */
 311          0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
 312          0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
 313          0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 314          0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 315          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 316          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 317          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 318          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
 319 };
 320
 321 /* read <len> bytes to gspca_dev->usb_buf */
 322 static void reg_r(struct gspca_dev *gspca_dev,
 323                   u8 req,
 324                   u16 index,
 325                   u16 len)
 326 {
 327         int ret;
 328
 329 #ifdef GSPCA_DEBUG
 330         if (len > USB_BUF_SZ) {
 331                 err("reg_r: buffer overflow");
 332                 return;
 333         }
 334 #endif
 335         if (gspca_dev->usb_err < 0)
 336                 return;
 337         ret = usb_control_msg(gspca_dev->dev,
 338                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 339                         req,
 340                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 341                         0,              /* value */
 342                         index,
 343                         len ? gspca_dev->usb_buf : NULL, len,
 344                         500);
 345         if (ret < 0) {
 346                 err("reg_r err %d", ret);
 347                 gspca_dev->usb_err = ret;
 348         }
 349 }
 350
 351 /* write one byte */
 352 static void reg_w_1(struct gspca_dev *gspca_dev,
 353                    u8 req,
 354                    u16 value,
 355                    u16 index,
 356                    u16 byte)
 357 {
 358         int ret;
 359
 360         if (gspca_dev->usb_err < 0)
 361                 return;
 362         gspca_dev->usb_buf[0] = byte;
 363         ret = usb_control_msg(gspca_dev->dev,
 364                         usb_sndctrlpipe(gspca_dev->dev, 0),
 365                         req,
 366                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 367                         value, index,
 368                         gspca_dev->usb_buf, 1,
 369                         500);
 370         if (ret < 0) {
 371                 err("reg_w_1 err %d", ret);
 372                 gspca_dev->usb_err = ret;
 373         }
 374 }
 375
 376 /* write req / index / value */
 377 static void reg_w_riv(struct gspca_dev *gspca_dev,
 378                      u8 req, u16 index, u16 value)
 379 {
 380         struct usb_device *dev = gspca_dev->dev;
 381         int ret;
 382
 383         if (gspca_dev->usb_err < 0)
 384                 return;
 385         ret = usb_control_msg(dev,
 386                         usb_sndctrlpipe(dev, 0),
 387                         req,
 388                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 389                         value, index, NULL, 0, 500);
 390         if (ret < 0) {
 391                 err("reg_w_riv err %d", ret);
 392                 gspca_dev->usb_err = ret;
 393                 return;
 394         }
 395         PDEBUG(D_USBO, "reg_w_riv: 0x%02x,0x%04x:0x%04x",
 396                 req, index, value);
 397 }
 398
 399 /* read 1 byte */
 400 static u8 reg_r_1(struct gspca_dev *gspca_dev,
 401                         u16 value)      /* wValue */
 402 {
 403         int ret;
 404
 405         if (gspca_dev->usb_err < 0)
 406                 return 0;
 407         ret = usb_control_msg(gspca_dev->dev,
 408                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 409                         0x20,                   /* request */
 410                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 411                         value,
 412                         0,                      /* index */
 413                         gspca_dev->usb_buf, 1,
 414                         500);                   /* timeout */
 415         if (ret < 0) {
 416                 err("reg_r_1 err %d", ret);
 417                 gspca_dev->usb_err = ret;
 418                 return 0;
 419         }
 420         return gspca_dev->usb_buf[0];
 421 }
 422
 423 /* read 1 or 2 bytes */
 424 static u16 reg_r_12(struct gspca_dev *gspca_dev,
 425                         u8 req,         /* bRequest */
 426                         u16 index,      /* wIndex */
 427                         u16 length)     /* wLength (1 or 2 only) */
 428 {
 429         int ret;
 430
 431         if (gspca_dev->usb_err < 0)
 432                 return 0;
 433         gspca_dev->usb_buf[1] = 0;
 434         ret = usb_control_msg(gspca_dev->dev,
 435                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 436                         req,
 437                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 438                         0,              /* value */
 439                         index,
 440                         gspca_dev->usb_buf, length,
 441                         500);
 442         if (ret < 0) {
 443                 err("reg_r_12 err %d", ret);
 444                 gspca_dev->usb_err = ret;
 445                 return 0;
 446         }
 447         return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
 448 }
 449
 450 static void write_vector(struct gspca_dev *gspca_dev,
 451                         const struct cmd *data, int ncmds)
 452 {
 453         while (--ncmds >= 0) {
 454                 reg_w_riv(gspca_dev, data->req, data->idx, data->val);
 455                 data++;
 456         }
 457 }
 458
 459 static void setup_qtable(struct gspca_dev *gspca_dev,
 460                         const u8 qtable[2][64])
 461 {
 462         int i;
 463
 464         /* loop over y components */
 465         for (i = 0; i < 64; i++)
 466                 reg_w_riv(gspca_dev, 0x00, 0x2800 + i, qtable[0][i]);
 467
 468         /* loop over c components */
 469         for (i = 0; i < 64; i++)
 470                 reg_w_riv(gspca_dev, 0x00, 0x2840 + i, qtable[1][i]);
 471 }
 472
 473 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
 474                              u8 req, u16 idx, u16 val)
 475 {
 476         u16 notdone;
 477
 478         reg_w_riv(gspca_dev, req, idx, val);
 479         notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
 480         reg_w_riv(gspca_dev, req, idx, val);
 481
 482         PDEBUG(D_FRAM, "before wait 0x%04x", notdone);
 483
 484         msleep(200);
 485         notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
 486         PDEBUG(D_FRAM, "after wait 0x%04x", notdone);
 487 }
 488
 489 static void spca504_read_info(struct gspca_dev *gspca_dev)
 490 {
 491         int i;
 492         u8 info[6];
 493
 494         for (i = 0; i < 6; i++)
 495                 info[i] = reg_r_1(gspca_dev, i);
 496         PDEBUG(D_STREAM,
 497                 "Read info: %d %d %d %d %d %d."
 498                 " Should be 1,0,2,2,0,0",
 499                 info[0], info[1], info[2],
 500                 info[3], info[4], info[5]);
 501 }
 502
 503 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
 504                         u8 req,
 505                         u16 idx, u16 val, u16 endcode, u8 count)
 506 {
 507         u16 status;
 508
 509         reg_w_riv(gspca_dev, req, idx, val);
 510         status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
 511         if (gspca_dev->usb_err < 0)
 512                 return;
 513         PDEBUG(D_FRAM, "Status 0x%04x Need 0x%04x", status, endcode);
 514         if (!count)
 515                 return;
 516         count = 200;
 517         while (--count > 0) {
 518                 msleep(10);
 519                 /* gsmart mini2 write a each wait setting 1 ms is enough */
 520 /*              reg_w_riv(gspca_dev, req, idx, val); */
 521                 status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
 522                 if (status == endcode) {
 523                         PDEBUG(D_FRAM, "status 0x%04x after wait %d",
 524                                 status, 200 - count);
 525                                 break;
 526                 }
 527         }
 528 }
 529
 530 static void spca504B_PollingDataReady(struct gspca_dev *gspca_dev)
 531 {
 532         int count = 10;
 533
 534         while (--count > 0) {
 535                 reg_r(gspca_dev, 0x21, 0, 1);
 536                 if ((gspca_dev->usb_buf[0] & 0x01) == 0)
 537                         break;
 538                 msleep(10);
 539         }
 540 }
 541
 542 static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
 543 {
 544         int count = 50;
 545
 546         while (--count > 0) {
 547                 reg_r(gspca_dev, 0x21, 1, 1);
 548                 if (gspca_dev->usb_buf[0] != 0) {
 549                         reg_w_1(gspca_dev, 0x21, 0, 1, 0);
 550                         reg_r(gspca_dev, 0x21, 1, 1);
 551                         spca504B_PollingDataReady(gspca_dev);
 552                         break;
 553                 }
 554                 msleep(10);
 555         }
 556 }
 557
 558 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
 559 {
 560         u8 *data;
 561
 562         data = gspca_dev->usb_buf;
 563         reg_r(gspca_dev, 0x20, 0, 5);
 564         PDEBUG(D_STREAM, "FirmWare : %d %d %d %d %d ",
 565                 data[0], data[1], data[2], data[3], data[4]);
 566         reg_r(gspca_dev, 0x23, 0, 64);
 567         reg_r(gspca_dev, 0x23, 1, 64);
 568 }
 569
 570 static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
 571 {
 572         struct sd *sd = (struct sd *) gspca_dev;
 573         u8 Size;
 574
 575         Size = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
 576         switch (sd->bridge) {
 577         case BRIDGE_SPCA533:
 578                 reg_w_riv(gspca_dev, 0x31, 0, 0);
 579                 spca504B_WaitCmdStatus(gspca_dev);
 580                 spca504B_PollingDataReady(gspca_dev);
 581                 spca50x_GetFirmware(gspca_dev);
 582                 reg_w_1(gspca_dev, 0x24, 0, 8, 2);              /* type */
 583                 reg_r(gspca_dev, 0x24, 8, 1);
 584
 585                 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
 586                 reg_r(gspca_dev, 0x25, 4, 1);                   /* size */
 587                 spca504B_PollingDataReady(gspca_dev);
 588
 589                 /* Init the cam width height with some values get on init ? */
 590                 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00);
 591                 spca504B_WaitCmdStatus(gspca_dev);
 592                 spca504B_PollingDataReady(gspca_dev);
 593                 break;
 594         default:
 595 /* case BRIDGE_SPCA504B: */
 596 /* case BRIDGE_SPCA536: */
 597                 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
 598                 reg_r(gspca_dev, 0x25, 4, 1);                   /* size */
 599                 reg_w_1(gspca_dev, 0x27, 0, 0, 6);
 600                 reg_r(gspca_dev, 0x27, 0, 1);                   /* type */
 601                 spca504B_PollingDataReady(gspca_dev);
 602                 break;
 603         case BRIDGE_SPCA504:
 604                 Size += 3;
 605                 if (sd->subtype == AiptekMiniPenCam13) {
 606                         /* spca504a aiptek */
 607                         spca504A_acknowledged_command(gspca_dev,
 608                                                 0x08, Size, 0,
 609                                                 0x80 | (Size & 0x0f), 1);
 610                         spca504A_acknowledged_command(gspca_dev,
 611                                                         1, 3, 0, 0x9f, 0);
 612                 } else {
 613                         spca504_acknowledged_command(gspca_dev, 0x08, Size, 0);
 614                 }
 615                 break;
 616         case BRIDGE_SPCA504C:
 617                 /* capture mode */
 618                 reg_w_riv(gspca_dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x00);
 619                 reg_w_riv(gspca_dev, 0x20, 0x01, 0x0500 | (Size & 0x0f));
 620                 break;
 621         }
 622 }
 623
 624 static void spca504_wait_status(struct gspca_dev *gspca_dev)
 625 {
 626         int cnt;
 627
 628         cnt = 256;
 629         while (--cnt > 0) {
 630                 /* With this we get the status, when return 0 it's all ok */
 631                 if (reg_r_12(gspca_dev, 0x06, 0x00, 1) == 0)
 632                         return;
 633                 msleep(10);
 634         }
 635 }
 636
 637 static void spca504B_setQtable(struct gspca_dev *gspca_dev)
 638 {
 639         reg_w_1(gspca_dev, 0x26, 0, 0, 3);
 640         reg_r(gspca_dev, 0x26, 0, 1);
 641         spca504B_PollingDataReady(gspca_dev);
 642 }
 643
 644 static void setbrightness(struct gspca_dev *gspca_dev)
 645 {
 646         struct sd *sd = (struct sd *) gspca_dev;
 647         u16 reg;
 648
 649         reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f0 : 0x21a7;
 650         reg_w_riv(gspca_dev, 0x00, reg, sd->brightness);
 651 }
 652
 653 static void setcontrast(struct gspca_dev *gspca_dev)
 654 {
 655         struct sd *sd = (struct sd *) gspca_dev;
 656         u16 reg;
 657
 658         reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f1 : 0x21a8;
 659         reg_w_riv(gspca_dev, 0x00, reg, sd->contrast);
 660 }
 661
 662 static void setcolors(struct gspca_dev *gspca_dev)
 663 {
 664         struct sd *sd = (struct sd *) gspca_dev;
 665         u16 reg;
 666
 667         reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f6 : 0x21ae;
 668         reg_w_riv(gspca_dev, 0x00, reg, sd->colors);
 669 }
 670
 671 static void init_ctl_reg(struct gspca_dev *gspca_dev)
 672 {
 673         struct sd *sd = (struct sd *) gspca_dev;
 674         int pollreg = 1;
 675
 676         setbrightness(gspca_dev);
 677         setcontrast(gspca_dev);
 678         setcolors(gspca_dev);
 679
 680         switch (sd->bridge) {
 681         case BRIDGE_SPCA504:
 682         case BRIDGE_SPCA504C:
 683                 pollreg = 0;
 684                 /* fall thru */
 685         default:
 686 /*      case BRIDGE_SPCA533: */
 687 /*      case BRIDGE_SPCA504B: */
 688                 reg_w_riv(gspca_dev, 0, 0x21ad, 0x00);  /* hue */
 689                 reg_w_riv(gspca_dev, 0, 0x21ac, 0x01);  /* sat/hue */
 690                 reg_w_riv(gspca_dev, 0, 0x21a3, 0x00);  /* gamma */
 691                 break;
 692         case BRIDGE_SPCA536:
 693                 reg_w_riv(gspca_dev, 0, 0x20f5, 0x40);
 694                 reg_w_riv(gspca_dev, 0, 0x20f4, 0x01);
 695                 reg_w_riv(gspca_dev, 0, 0x2089, 0x00);
 696                 break;
 697         }
 698         if (pollreg)
 699                 spca504B_PollingDataReady(gspca_dev);
 700 }
 701
 702 /* this function is called at probe time */
 703 static int sd_config(struct gspca_dev *gspca_dev,
 704                         const struct usb_device_id *id)
 705 {
 706         struct sd *sd = (struct sd *) gspca_dev;
 707         struct cam *cam;
 708
 709         cam = &gspca_dev->cam;
 710
 711         sd->bridge = id->driver_info >> 8;
 712         sd->subtype = id->driver_info;
 713
 714         if (sd->subtype == AiptekMiniPenCam13) {
 715
 716                 /* try to get the firmware as some cam answer 2.0.1.2.2
 717                  * and should be a spca504b then overwrite that setting */
 718                 reg_r(gspca_dev, 0x20, 0, 1);
 719                 switch (gspca_dev->usb_buf[0]) {
 720                 case 1:
 721                         break;          /* (right bridge/subtype) */
 722                 case 2:
 723                         sd->bridge = BRIDGE_SPCA504B;
 724                         sd->subtype = 0;
 725                         break;
 726                 default:
 727                         return -ENODEV;
 728                 }
 729         }
 730
 731         switch (sd->bridge) {
 732         default:
 733 /*      case BRIDGE_SPCA504B: */
 734 /*      case BRIDGE_SPCA504: */
 735 /*      case BRIDGE_SPCA536: */
 736                 cam->cam_mode = vga_mode;
 737                 cam->nmodes = ARRAY_SIZE(vga_mode);
 738                 break;
 739         case BRIDGE_SPCA533:
 740                 cam->cam_mode = custom_mode;
 741                 if (sd->subtype == MegaImageVI)         /* 320x240 only */
 742                         cam->nmodes = ARRAY_SIZE(custom_mode) - 1;
 743                 else
 744                         cam->nmodes = ARRAY_SIZE(custom_mode);
 745                 break;
 746         case BRIDGE_SPCA504C:
 747                 cam->cam_mode = vga_mode2;
 748                 cam->nmodes = ARRAY_SIZE(vga_mode2);
 749                 break;
 750         }
 751         sd->brightness = BRIGHTNESS_DEF;
 752         sd->contrast = CONTRAST_DEF;
 753         sd->colors = COLOR_DEF;
 754         sd->autogain = AUTOGAIN_DEF;
 755         sd->quality = QUALITY_DEF;
 756         return 0;
 757 }
 758
 759 /* this function is called at probe and resume time */
 760 static int sd_init(struct gspca_dev *gspca_dev)
 761 {
 762         struct sd *sd = (struct sd *) gspca_dev;
 763
 764         switch (sd->bridge) {
 765         case BRIDGE_SPCA504B:
 766                 reg_w_riv(gspca_dev, 0x1d, 0x00, 0);
 767                 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x01);
 768                 reg_w_riv(gspca_dev, 0x00, 0x0d04, 0x00);
 769                 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x00);
 770                 reg_w_riv(gspca_dev, 0x00, 0x2301, 0x13);
 771                 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x00);
 772                 /* fall thru */
 773         case BRIDGE_SPCA533:
 774                 spca504B_PollingDataReady(gspca_dev);
 775                 spca50x_GetFirmware(gspca_dev);
 776                 break;
 777         case BRIDGE_SPCA536:
 778                 spca50x_GetFirmware(gspca_dev);
 779                 reg_r(gspca_dev, 0x00, 0x5002, 1);
 780                 reg_w_1(gspca_dev, 0x24, 0, 0, 0);
 781                 reg_r(gspca_dev, 0x24, 0, 1);
 782                 spca504B_PollingDataReady(gspca_dev);
 783                 reg_w_riv(gspca_dev, 0x34, 0, 0);
 784                 spca504B_WaitCmdStatus(gspca_dev);
 785                 break;
 786         case BRIDGE_SPCA504C:   /* pccam600 */
 787                 PDEBUG(D_STREAM, "Opening SPCA504 (PC-CAM 600)");
 788                 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0000);
 789                 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0001);     /* reset */
 790                 spca504_wait_status(gspca_dev);
 791                 if (sd->subtype == LogitechClickSmart420)
 792                         write_vector(gspca_dev,
 793                                 spca504A_clicksmart420_open_data,
 794                                 ARRAY_SIZE(spca504A_clicksmart420_open_data));
 795                 else
 796                         write_vector(gspca_dev, spca504_pccam600_open_data,
 797                                 ARRAY_SIZE(spca504_pccam600_open_data));
 798                 setup_qtable(gspca_dev, qtable_creative_pccam);
 799                 break;
 800         default:
 801 /*      case BRIDGE_SPCA504: */
 802                 PDEBUG(D_STREAM, "Opening SPCA504");
 803                 if (sd->subtype == AiptekMiniPenCam13) {
 804                         spca504_read_info(gspca_dev);
 805
 806                         /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
 807                         spca504A_acknowledged_command(gspca_dev, 0x24,
 808                                                         8, 3, 0x9e, 1);
 809                         /* Twice sequential need status 0xff->0x9e->0x9d */
 810                         spca504A_acknowledged_command(gspca_dev, 0x24,
 811                                                         8, 3, 0x9e, 0);
 812
 813                         spca504A_acknowledged_command(gspca_dev, 0x24,
 814                                                         0, 0, 0x9d, 1);
 815                         /******************************/
 816                         /* spca504a aiptek */
 817                         spca504A_acknowledged_command(gspca_dev, 0x08,
 818                                                         6, 0, 0x86, 1);
 819 /*                      reg_write (dev, 0, 0x2000, 0); */
 820 /*                      reg_write (dev, 0, 0x2883, 1); */
 821 /*                      spca504A_acknowledged_command (gspca_dev, 0x08,
 822                                                         6, 0, 0x86, 1); */
 823 /*                      spca504A_acknowledged_command (gspca_dev, 0x24,
 824                                                         0, 0, 0x9D, 1); */
 825                         reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05);
 826                                                         /* L92 sno1t.txt */
 827                         reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05);
 828                         spca504A_acknowledged_command(gspca_dev, 0x01,
 829                                                         0x0f, 0, 0xff, 0);
 830                 }
 831                 /* setup qtable */
 832                 reg_w_riv(gspca_dev, 0, 0x2000, 0);
 833                 reg_w_riv(gspca_dev, 0, 0x2883, 1);
 834                 setup_qtable(gspca_dev, qtable_spca504_default);
 835                 break;
 836         }
 837         return gspca_dev->usb_err;
 838 }
 839
 840 static int sd_start(struct gspca_dev *gspca_dev)
 841 {
 842         struct sd *sd = (struct sd *) gspca_dev;
 843         int enable;
 844
 845         /* create the JPEG header */
 846         jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
 847                         0x22);          /* JPEG 411 */
 848         jpeg_set_qual(sd->jpeg_hdr, sd->quality);
 849
 850         if (sd->bridge == BRIDGE_SPCA504B)
 851                 spca504B_setQtable(gspca_dev);
 852         spca504B_SetSizeType(gspca_dev);
 853         switch (sd->bridge) {
 854         default:
 855 /*      case BRIDGE_SPCA504B: */
 856 /*      case BRIDGE_SPCA533: */
 857 /*      case BRIDGE_SPCA536: */
 858                 switch (sd->subtype) {
 859                 case MegapixV4:
 860                 case LogitechClickSmart820:
 861                 case MegaImageVI:
 862                         reg_w_riv(gspca_dev, 0xf0, 0, 0);
 863                         spca504B_WaitCmdStatus(gspca_dev);
 864                         reg_r(gspca_dev, 0xf0, 4, 0);
 865                         spca504B_WaitCmdStatus(gspca_dev);
 866                         break;
 867                 default:
 868                         reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00);
 869                         spca504B_WaitCmdStatus(gspca_dev);
 870                         spca504B_PollingDataReady(gspca_dev);
 871                         break;
 872                 }
 873                 break;
 874         case BRIDGE_SPCA504:
 875                 if (sd->subtype == AiptekMiniPenCam13) {
 876                         spca504_read_info(gspca_dev);
 877
 878                         /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
 879                         spca504A_acknowledged_command(gspca_dev, 0x24,
 880                                                         8, 3, 0x9e, 1);
 881                         /* Twice sequential need status 0xff->0x9e->0x9d */
 882                         spca504A_acknowledged_command(gspca_dev, 0x24,
 883                                                         8, 3, 0x9e, 0);
 884                         spca504A_acknowledged_command(gspca_dev, 0x24,
 885                                                         0, 0, 0x9d, 1);
 886                 } else {
 887                         spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
 888                         spca504_read_info(gspca_dev);
 889                         spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
 890                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
 891                 }
 892                 spca504B_SetSizeType(gspca_dev);
 893                 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05);
 894                                                         /* L92 sno1t.txt */
 895                 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05);
 896                 break;
 897         case BRIDGE_SPCA504C:
 898                 if (sd->subtype == LogitechClickSmart420) {
 899                         write_vector(gspca_dev,
 900                                 spca504A_clicksmart420_init_data,
 901                                 ARRAY_SIZE(spca504A_clicksmart420_init_data));
 902                 } else {
 903                         write_vector(gspca_dev, spca504_pccam600_init_data,
 904                                 ARRAY_SIZE(spca504_pccam600_init_data));
 905                 }
 906                 enable = (sd->autogain ? 0x04 : 0x01);
 907                 reg_w_riv(gspca_dev, 0x0c, 0x0000, enable);
 908                                                         /* auto exposure */
 909                 reg_w_riv(gspca_dev, 0xb0, 0x0000, enable);
 910                                                         /* auto whiteness */
 911
 912                 /* set default exposure compensation and whiteness balance */
 913                 reg_w_riv(gspca_dev, 0x30, 0x0001, 800);        /* ~ 20 fps */
 914                 reg_w_riv(gspca_dev, 0x30, 0x0002, 1600);
 915                 spca504B_SetSizeType(gspca_dev);
 916                 break;
 917         }
 918         init_ctl_reg(gspca_dev);
 919         return gspca_dev->usb_err;
 920 }
 921
 922 static void sd_stopN(struct gspca_dev *gspca_dev)
 923 {
 924         struct sd *sd = (struct sd *) gspca_dev;
 925
 926         switch (sd->bridge) {
 927         default:
 928 /*      case BRIDGE_SPCA533: */
 929 /*      case BRIDGE_SPCA536: */
 930 /*      case BRIDGE_SPCA504B: */
 931                 reg_w_riv(gspca_dev, 0x31, 0, 0);
 932                 spca504B_WaitCmdStatus(gspca_dev);
 933                 spca504B_PollingDataReady(gspca_dev);
 934                 break;
 935         case BRIDGE_SPCA504:
 936         case BRIDGE_SPCA504C:
 937                 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x0000);
 938
 939                 if (sd->subtype == AiptekMiniPenCam13) {
 940                         /* spca504a aiptek */
 941 /*                      spca504A_acknowledged_command(gspca_dev, 0x08,
 942                                                          6, 0, 0x86, 1); */
 943                         spca504A_acknowledged_command(gspca_dev, 0x24,
 944                                                         0x00, 0x00, 0x9d, 1);
 945                         spca504A_acknowledged_command(gspca_dev, 0x01,
 946                                                         0x0f, 0x00, 0xff, 1);
 947                 } else {
 948                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
 949                         reg_w_riv(gspca_dev, 0x01, 0x000f, 0x0000);
 950                 }
 951                 break;
 952         }
 953 }
 954
 955 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 956                         u8 *data,                       /* isoc packet */
 957                         int len)                        /* iso packet length */
 958 {
 959         struct sd *sd = (struct sd *) gspca_dev;
 960         int i, sof = 0;
 961         static u8 ffd9[] = {0xff, 0xd9};
 962
 963 /* frames are jpeg 4.1.1 without 0xff escape */
 964         switch (sd->bridge) {
 965         case BRIDGE_SPCA533:
 966                 if (data[0] == 0xff) {
 967                         if (data[1] != 0x01) {  /* drop packet */
 968 /*                              gspca_dev->last_packet_type = DISCARD_PACKET; */
 969                                 return;
 970                         }
 971                         sof = 1;
 972                         data += SPCA533_OFFSET_DATA;
 973                         len -= SPCA533_OFFSET_DATA;
 974                 } else {
 975                         data += 1;
 976                         len -= 1;
 977                 }
 978                 break;
 979         case BRIDGE_SPCA536:
 980                 if (data[0] == 0xff) {
 981                         sof = 1;
 982                         data += SPCA536_OFFSET_DATA;
 983                         len -= SPCA536_OFFSET_DATA;
 984                 } else {
 985                         data += 2;
 986                         len -= 2;
 987                 }
 988                 break;
 989         default:
 990 /*      case BRIDGE_SPCA504: */
 991 /*      case BRIDGE_SPCA504B: */
 992                 switch (data[0]) {
 993                 case 0xfe:                      /* start of frame */
 994                         sof = 1;
 995                         data += SPCA50X_OFFSET_DATA;
 996                         len -= SPCA50X_OFFSET_DATA;
 997                         break;
 998                 case 0xff:                      /* drop packet */
 999 /*                      gspca_dev->last_packet_type = DISCARD_PACKET; */
1000                         return;
1001                 default:
1002                         data += 1;
1003                         len -= 1;
1004                         break;
1005                 }
1006                 break;
1007         case BRIDGE_SPCA504C:
1008                 switch (data[0]) {
1009                 case 0xfe:                      /* start of frame */
1010                         sof = 1;
1011                         data += SPCA504_PCCAM600_OFFSET_DATA;
1012                         len -= SPCA504_PCCAM600_OFFSET_DATA;
1013                         break;
1014                 case 0xff:                      /* drop packet */
1015 /*                      gspca_dev->last_packet_type = DISCARD_PACKET; */
1016                         return;
1017                 default:
1018                         data += 1;
1019                         len -= 1;
1020                         break;
1021                 }
1022                 break;
1023         }
1024         if (sof) {              /* start of frame */
1025                 gspca_frame_add(gspca_dev, LAST_PACKET,
1026                                 ffd9, 2);
1027
1028                 /* put the JPEG header in the new frame */
1029                 gspca_frame_add(gspca_dev, FIRST_PACKET,
1030                         sd->jpeg_hdr, JPEG_HDR_SZ);
1031         }
1032
1033         /* add 0x00 after 0xff */
1034         i = 0;
1035         do {
1036                 if (data[i] == 0xff) {
1037                         gspca_frame_add(gspca_dev, INTER_PACKET,
1038                                         data, i + 1);
1039                         len -= i;
1040                         data += i;
1041                         *data = 0x00;
1042                         i = 0;
1043                 }
1044                 i++;
1045         } while (i < len);
1046         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1047 }
1048
1049 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1050 {
1051         struct sd *sd = (struct sd *) gspca_dev;
1052
1053         sd->brightness = val;
1054         if (gspca_dev->streaming)
1055                 setbrightness(gspca_dev);
1056         return gspca_dev->usb_err;
1057 }
1058
1059 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1060 {
1061         struct sd *sd = (struct sd *) gspca_dev;
1062
1063         *val = sd->brightness;
1064         return 0;
1065 }
1066
1067 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1068 {
1069         struct sd *sd = (struct sd *) gspca_dev;
1070
1071         sd->contrast = val;
1072         if (gspca_dev->streaming)
1073                 setcontrast(gspca_dev);
1074         return gspca_dev->usb_err;
1075 }
1076
1077 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1078 {
1079         struct sd *sd = (struct sd *) gspca_dev;
1080
1081         *val = sd->contrast;
1082         return 0;
1083 }
1084
1085 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1086 {
1087         struct sd *sd = (struct sd *) gspca_dev;
1088
1089         sd->colors = val;
1090         if (gspca_dev->streaming)
1091                 setcolors(gspca_dev);
1092         return gspca_dev->usb_err;
1093 }
1094
1095 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1096 {
1097         struct sd *sd = (struct sd *) gspca_dev;
1098
1099         *val = sd->colors;
1100         return 0;
1101 }
1102
1103 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1104 {
1105         struct sd *sd = (struct sd *) gspca_dev;
1106
1107         sd->autogain = val;
1108         return 0;
1109 }
1110
1111 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1112 {
1113         struct sd *sd = (struct sd *) gspca_dev;
1114
1115         *val = sd->autogain;
1116         return 0;
1117 }
1118
1119 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
1120                         struct v4l2_jpegcompression *jcomp)
1121 {
1122         struct sd *sd = (struct sd *) gspca_dev;
1123
1124         if (jcomp->quality < QUALITY_MIN)
1125                 sd->quality = QUALITY_MIN;
1126         else if (jcomp->quality > QUALITY_MAX)
1127                 sd->quality = QUALITY_MAX;
1128         else
1129                 sd->quality = jcomp->quality;
1130         if (gspca_dev->streaming)
1131                 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
1132         return gspca_dev->usb_err;
1133 }
1134
1135 static int sd_get_jcomp(struct gspca_dev *gspca_dev,
1136                         struct v4l2_jpegcompression *jcomp)
1137 {
1138         struct sd *sd = (struct sd *) gspca_dev;
1139
1140         memset(jcomp, 0, sizeof *jcomp);
1141         jcomp->quality = sd->quality;
1142         jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
1143                         | V4L2_JPEG_MARKER_DQT;
1144         return 0;
1145 }
1146
1147 /* sub-driver description */
1148 static const struct sd_desc sd_desc = {
1149         .name = MODULE_NAME,
1150         .ctrls = sd_ctrls,
1151         .nctrls = ARRAY_SIZE(sd_ctrls),
1152         .config = sd_config,
1153         .init = sd_init,
1154         .start = sd_start,
1155         .stopN = sd_stopN,
1156         .pkt_scan = sd_pkt_scan,
1157         .get_jcomp = sd_get_jcomp,
1158         .set_jcomp = sd_set_jcomp,
1159 };
1160
1161 /* -- module initialisation -- */
1162 #define BS(bridge, subtype) \
1163         .driver_info = (BRIDGE_ ## bridge << 8) \
1164                         | (subtype)
1165 static const __devinitdata struct usb_device_id device_table[] = {
1166         {USB_DEVICE(0x041e, 0x400b), BS(SPCA504C, 0)},
1167         {USB_DEVICE(0x041e, 0x4012), BS(SPCA504C, 0)},
1168         {USB_DEVICE(0x041e, 0x4013), BS(SPCA504C, 0)},
1169         {USB_DEVICE(0x0458, 0x7006), BS(SPCA504B, 0)},
1170         {USB_DEVICE(0x0461, 0x0821), BS(SPCA533, 0)},
1171         {USB_DEVICE(0x046d, 0x0905), BS(SPCA533, LogitechClickSmart820)},
1172         {USB_DEVICE(0x046d, 0x0960), BS(SPCA504C, LogitechClickSmart420)},
1173         {USB_DEVICE(0x0471, 0x0322), BS(SPCA504B, 0)},
1174         {USB_DEVICE(0x04a5, 0x3003), BS(SPCA504B, 0)},
1175         {USB_DEVICE(0x04a5, 0x3008), BS(SPCA533, 0)},
1176         {USB_DEVICE(0x04a5, 0x300a), BS(SPCA533, 0)},
1177         {USB_DEVICE(0x04f1, 0x1001), BS(SPCA504B, 0)},
1178         {USB_DEVICE(0x04fc, 0x500c), BS(SPCA504B, 0)},
1179         {USB_DEVICE(0x04fc, 0x504a), BS(SPCA504, AiptekMiniPenCam13)},
1180         {USB_DEVICE(0x04fc, 0x504b), BS(SPCA504B, 0)},
1181         {USB_DEVICE(0x04fc, 0x5330), BS(SPCA533, 0)},
1182         {USB_DEVICE(0x04fc, 0x5360), BS(SPCA536, 0)},
1183         {USB_DEVICE(0x04fc, 0xffff), BS(SPCA504B, 0)},
1184         {USB_DEVICE(0x052b, 0x1507), BS(SPCA533, MegapixV4)},
1185         {USB_DEVICE(0x052b, 0x1513), BS(SPCA533, MegapixV4)},
1186         {USB_DEVICE(0x052b, 0x1803), BS(SPCA533, MegaImageVI)},
1187         {USB_DEVICE(0x0546, 0x3155), BS(SPCA533, 0)},
1188         {USB_DEVICE(0x0546, 0x3191), BS(SPCA504B, 0)},
1189         {USB_DEVICE(0x0546, 0x3273), BS(SPCA504B, 0)},
1190         {USB_DEVICE(0x055f, 0xc211), BS(SPCA536, 0)},
1191         {USB_DEVICE(0x055f, 0xc230), BS(SPCA533, 0)},
1192         {USB_DEVICE(0x055f, 0xc232), BS(SPCA533, 0)},
1193         {USB_DEVICE(0x055f, 0xc360), BS(SPCA536, 0)},
1194         {USB_DEVICE(0x055f, 0xc420), BS(SPCA504, 0)},
1195         {USB_DEVICE(0x055f, 0xc430), BS(SPCA533, 0)},
1196         {USB_DEVICE(0x055f, 0xc440), BS(SPCA533, 0)},
1197         {USB_DEVICE(0x055f, 0xc520), BS(SPCA504, 0)},
1198         {USB_DEVICE(0x055f, 0xc530), BS(SPCA533, 0)},
1199         {USB_DEVICE(0x055f, 0xc540), BS(SPCA533, 0)},
1200         {USB_DEVICE(0x055f, 0xc630), BS(SPCA533, 0)},
1201         {USB_DEVICE(0x055f, 0xc650), BS(SPCA533, 0)},
1202         {USB_DEVICE(0x05da, 0x1018), BS(SPCA504B, 0)},
1203         {USB_DEVICE(0x06d6, 0x0031), BS(SPCA533, 0)},
1204         {USB_DEVICE(0x0733, 0x1311), BS(SPCA533, 0)},
1205         {USB_DEVICE(0x0733, 0x1314), BS(SPCA533, 0)},
1206         {USB_DEVICE(0x0733, 0x2211), BS(SPCA533, 0)},
1207         {USB_DEVICE(0x0733, 0x2221), BS(SPCA533, 0)},
1208         {USB_DEVICE(0x0733, 0x3261), BS(SPCA536, 0)},
1209         {USB_DEVICE(0x0733, 0x3281), BS(SPCA536, 0)},
1210         {USB_DEVICE(0x08ca, 0x0104), BS(SPCA533, 0)},
1211         {USB_DEVICE(0x08ca, 0x0106), BS(SPCA533, 0)},
1212         {USB_DEVICE(0x08ca, 0x2008), BS(SPCA504B, 0)},
1213         {USB_DEVICE(0x08ca, 0x2010), BS(SPCA533, 0)},
1214         {USB_DEVICE(0x08ca, 0x2016), BS(SPCA504B, 0)},
1215         {USB_DEVICE(0x08ca, 0x2018), BS(SPCA504B, 0)},
1216         {USB_DEVICE(0x08ca, 0x2020), BS(SPCA533, 0)},
1217         {USB_DEVICE(0x08ca, 0x2022), BS(SPCA533, 0)},
1218         {USB_DEVICE(0x08ca, 0x2024), BS(SPCA536, 0)},
1219         {USB_DEVICE(0x08ca, 0x2028), BS(SPCA533, 0)},
1220         {USB_DEVICE(0x08ca, 0x2040), BS(SPCA536, 0)},
1221         {USB_DEVICE(0x08ca, 0x2042), BS(SPCA536, 0)},
1222         {USB_DEVICE(0x08ca, 0x2050), BS(SPCA536, 0)},
1223         {USB_DEVICE(0x08ca, 0x2060), BS(SPCA536, 0)},
1224         {USB_DEVICE(0x0d64, 0x0303), BS(SPCA536, 0)},
1225         {}
1226 };
1227 MODULE_DEVICE_TABLE(usb, device_table);
1228
1229 /* -- device connect -- */
1230 static int sd_probe(struct usb_interface *intf,
1231                         const struct usb_device_id *id)
1232 {
1233         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1234                                 THIS_MODULE);
1235 }
1236
1237 static struct usb_driver sd_driver = {
1238         .name = MODULE_NAME,
1239         .id_table = device_table,
1240         .probe = sd_probe,
1241         .disconnect = gspca_disconnect,
1242 #ifdef CONFIG_PM
1243         .suspend = gspca_suspend,
1244         .resume = gspca_resume,
1245 #endif
1246 };
1247
1248 /* -- module insert / remove -- */
1249 static int __init sd_mod_init(void)
1250 {
1251         return usb_register(&sd_driver);
1252 }
1253 static void __exit sd_mod_exit(void)
1254 {
1255         usb_deregister(&sd_driver);
1256 }
1257
1258 module_init(sd_mod_init);
1259 module_exit(sd_mod_exit);