drivers/media/usb/gspca/spca500.c

   1 /*
   2  * SPCA500 chip based cameras initialization data
   3  *
   4  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  *
  16  */
  17
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #define MODULE_NAME "spca500"
  21
  22 #include "gspca.h"
  23 #include "jpeg.h"
  24
  25 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  26 MODULE_DESCRIPTION("GSPCA/SPCA500 USB Camera Driver");
  27 MODULE_LICENSE("GPL");
  28
  29 #define QUALITY 85
  30
  31 /* specific webcam descriptor */
  32 struct sd {
  33         struct gspca_dev gspca_dev;             /* !! must be the first item */
  34
  35         char subtype;
  36 #define AgfaCl20 0
  37 #define AiptekPocketDV 1
  38 #define BenqDC1016 2
  39 #define CreativePCCam300 3
  40 #define DLinkDSC350 4
  41 #define Gsmartmini 5
  42 #define IntelPocketPCCamera 6
  43 #define KodakEZ200 7
  44 #define LogitechClickSmart310 8
  45 #define LogitechClickSmart510 9
  46 #define LogitechTraveler 10
  47 #define MustekGsmart300 11
  48 #define Optimedia 12
  49 #define PalmPixDC85 13
  50 #define ToptroIndus 14
  51
  52         u8 jpeg_hdr[JPEG_HDR_SZ];
  53 };
  54
  55 static const struct v4l2_pix_format vga_mode[] = {
  56         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  57                 .bytesperline = 320,
  58                 .sizeimage = 320 * 240 * 3 / 8 + 590,
  59                 .colorspace = V4L2_COLORSPACE_JPEG,
  60                 .priv = 1},
  61         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  62                 .bytesperline = 640,
  63                 .sizeimage = 640 * 480 * 3 / 8 + 590,
  64                 .colorspace = V4L2_COLORSPACE_JPEG,
  65                 .priv = 0},
  66 };
  67
  68 static const struct v4l2_pix_format sif_mode[] = {
  69         {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  70                 .bytesperline = 176,
  71                 .sizeimage = 176 * 144 * 3 / 8 + 590,
  72                 .colorspace = V4L2_COLORSPACE_JPEG,
  73                 .priv = 1},
  74         {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  75                 .bytesperline = 352,
  76                 .sizeimage = 352 * 288 * 3 / 8 + 590,
  77                 .colorspace = V4L2_COLORSPACE_JPEG,
  78                 .priv = 0},
  79 };
  80
  81 /* Frame packet header offsets for the spca500 */
  82 #define SPCA500_OFFSET_PADDINGLB 2
  83 #define SPCA500_OFFSET_PADDINGHB 3
  84 #define SPCA500_OFFSET_MODE      4
  85 #define SPCA500_OFFSET_IMGWIDTH  5
  86 #define SPCA500_OFFSET_IMGHEIGHT 6
  87 #define SPCA500_OFFSET_IMGMODE   7
  88 #define SPCA500_OFFSET_QTBLINDEX 8
  89 #define SPCA500_OFFSET_FRAMSEQ   9
  90 #define SPCA500_OFFSET_CDSPINFO  10
  91 #define SPCA500_OFFSET_GPIO      11
  92 #define SPCA500_OFFSET_AUGPIO    12
  93 #define SPCA500_OFFSET_DATA      16
  94
  95
  96 static const __u16 spca500_visual_defaults[][3] = {
  97         {0x00, 0x0003, 0x816b}, /* SSI not active sync with vsync,
  98                                  * hue (H byte) = 0,
  99                                  * saturation/hue enable,
 100                                  * brightness/contrast enable.
 101                                  */
 102         {0x00, 0x0000, 0x8167}, /* brightness = 0 */
 103         {0x00, 0x0020, 0x8168}, /* contrast = 0 */
 104         {0x00, 0x0003, 0x816b}, /* SSI not active sync with vsync,
 105                                  * hue (H byte) = 0, saturation/hue enable,
 106                                  * brightness/contrast enable.
 107                                  * was 0x0003, now 0x0000.
 108                                  */
 109         {0x00, 0x0000, 0x816a}, /* hue (L byte) = 0 */
 110         {0x00, 0x0020, 0x8169}, /* saturation = 0x20 */
 111         {0x00, 0x0050, 0x8157}, /* edge gain high threshold */
 112         {0x00, 0x0030, 0x8158}, /* edge gain low threshold */
 113         {0x00, 0x0028, 0x8159}, /* edge bandwidth high threshold */
 114         {0x00, 0x000a, 0x815a}, /* edge bandwidth low threshold */
 115         {0x00, 0x0001, 0x8202}, /* clock rate compensation = 1/25 sec/frame */
 116         {0x0c, 0x0004, 0x0000},
 117         /* set interface */
 118         {}
 119 };
 120 static const __u16 Clicksmart510_defaults[][3] = {
 121         {0x00, 0x00, 0x8211},
 122         {0x00, 0x01, 0x82c0},
 123         {0x00, 0x10, 0x82cb},
 124         {0x00, 0x0f, 0x800d},
 125         {0x00, 0x82, 0x8225},
 126         {0x00, 0x21, 0x8228},
 127         {0x00, 0x00, 0x8203},
 128         {0x00, 0x00, 0x8204},
 129         {0x00, 0x08, 0x8205},
 130         {0x00, 0xf8, 0x8206},
 131         {0x00, 0x28, 0x8207},
 132         {0x00, 0xa0, 0x8208},
 133         {0x00, 0x08, 0x824a},
 134         {0x00, 0x08, 0x8214},
 135         {0x00, 0x80, 0x82c1},
 136         {0x00, 0x00, 0x82c2},
 137         {0x00, 0x00, 0x82ca},
 138         {0x00, 0x80, 0x82c1},
 139         {0x00, 0x04, 0x82c2},
 140         {0x00, 0x00, 0x82ca},
 141         {0x00, 0xfc, 0x8100},
 142         {0x00, 0xfc, 0x8105},
 143         {0x00, 0x30, 0x8101},
 144         {0x00, 0x00, 0x8102},
 145         {0x00, 0x00, 0x8103},
 146         {0x00, 0x66, 0x8107},
 147         {0x00, 0x00, 0x816b},
 148         {0x00, 0x00, 0x8155},
 149         {0x00, 0x01, 0x8156},
 150         {0x00, 0x60, 0x8157},
 151         {0x00, 0x40, 0x8158},
 152         {0x00, 0x0a, 0x8159},
 153         {0x00, 0x06, 0x815a},
 154         {0x00, 0x00, 0x813f},
 155         {0x00, 0x00, 0x8200},
 156         {0x00, 0x19, 0x8201},
 157         {0x00, 0x00, 0x82c1},
 158         {0x00, 0xa0, 0x82c2},
 159         {0x00, 0x00, 0x82ca},
 160         {0x00, 0x00, 0x8117},
 161         {0x00, 0x00, 0x8118},
 162         {0x00, 0x65, 0x8119},
 163         {0x00, 0x00, 0x811a},
 164         {0x00, 0x00, 0x811b},
 165         {0x00, 0x55, 0x811c},
 166         {0x00, 0x65, 0x811d},
 167         {0x00, 0x55, 0x811e},
 168         {0x00, 0x16, 0x811f},
 169         {0x00, 0x19, 0x8120},
 170         {0x00, 0x80, 0x8103},
 171         {0x00, 0x83, 0x816b},
 172         {0x00, 0x25, 0x8168},
 173         {0x00, 0x01, 0x820f},
 174         {0x00, 0xff, 0x8115},
 175         {0x00, 0x48, 0x8116},
 176         {0x00, 0x50, 0x8151},
 177         {0x00, 0x40, 0x8152},
 178         {0x00, 0x78, 0x8153},
 179         {0x00, 0x40, 0x8154},
 180         {0x00, 0x00, 0x8167},
 181         {0x00, 0x20, 0x8168},
 182         {0x00, 0x00, 0x816a},
 183         {0x00, 0x03, 0x816b},
 184         {0x00, 0x20, 0x8169},
 185         {0x00, 0x60, 0x8157},
 186         {0x00, 0x00, 0x8190},
 187         {0x00, 0x00, 0x81a1},
 188         {0x00, 0x00, 0x81b2},
 189         {0x00, 0x27, 0x8191},
 190         {0x00, 0x27, 0x81a2},
 191         {0x00, 0x27, 0x81b3},
 192         {0x00, 0x4b, 0x8192},
 193         {0x00, 0x4b, 0x81a3},
 194         {0x00, 0x4b, 0x81b4},
 195         {0x00, 0x66, 0x8193},
 196         {0x00, 0x66, 0x81a4},
 197         {0x00, 0x66, 0x81b5},
 198         {0x00, 0x79, 0x8194},
 199         {0x00, 0x79, 0x81a5},
 200         {0x00, 0x79, 0x81b6},
 201         {0x00, 0x8a, 0x8195},
 202         {0x00, 0x8a, 0x81a6},
 203         {0x00, 0x8a, 0x81b7},
 204         {0x00, 0x9b, 0x8196},
 205         {0x00, 0x9b, 0x81a7},
 206         {0x00, 0x9b, 0x81b8},
 207         {0x00, 0xa6, 0x8197},
 208         {0x00, 0xa6, 0x81a8},
 209         {0x00, 0xa6, 0x81b9},
 210         {0x00, 0xb2, 0x8198},
 211         {0x00, 0xb2, 0x81a9},
 212         {0x00, 0xb2, 0x81ba},
 213         {0x00, 0xbe, 0x8199},
 214         {0x00, 0xbe, 0x81aa},
 215         {0x00, 0xbe, 0x81bb},
 216         {0x00, 0xc8, 0x819a},
 217         {0x00, 0xc8, 0x81ab},
 218         {0x00, 0xc8, 0x81bc},
 219         {0x00, 0xd2, 0x819b},
 220         {0x00, 0xd2, 0x81ac},
 221         {0x00, 0xd2, 0x81bd},
 222         {0x00, 0xdb, 0x819c},
 223         {0x00, 0xdb, 0x81ad},
 224         {0x00, 0xdb, 0x81be},
 225         {0x00, 0xe4, 0x819d},
 226         {0x00, 0xe4, 0x81ae},
 227         {0x00, 0xe4, 0x81bf},
 228         {0x00, 0xed, 0x819e},
 229         {0x00, 0xed, 0x81af},
 230         {0x00, 0xed, 0x81c0},
 231         {0x00, 0xf7, 0x819f},
 232         {0x00, 0xf7, 0x81b0},
 233         {0x00, 0xf7, 0x81c1},
 234         {0x00, 0xff, 0x81a0},
 235         {0x00, 0xff, 0x81b1},
 236         {0x00, 0xff, 0x81c2},
 237         {0x00, 0x03, 0x8156},
 238         {0x00, 0x00, 0x8211},
 239         {0x00, 0x20, 0x8168},
 240         {0x00, 0x01, 0x8202},
 241         {0x00, 0x30, 0x8101},
 242         {0x00, 0x00, 0x8111},
 243         {0x00, 0x00, 0x8112},
 244         {0x00, 0x00, 0x8113},
 245         {0x00, 0x00, 0x8114},
 246         {}
 247 };
 248
 249 static const __u8 qtable_creative_pccam[2][64] = {
 250         {                               /* Q-table Y-components */
 251          0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
 252          0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
 253          0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
 254          0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
 255          0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
 256          0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
 257          0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
 258          0x16, 0x1c, 0x1d, 0x1d, 0x22, 0x1e, 0x1f, 0x1e},
 259         {                               /* Q-table C-components */
 260          0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
 261          0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
 262          0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 263          0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 264          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 265          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 266          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
 267          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
 268 };
 269
 270 static const __u8 qtable_kodak_ez200[2][64] = {
 271         {                               /* Q-table Y-components */
 272          0x02, 0x01, 0x01, 0x02, 0x02, 0x04, 0x05, 0x06,
 273          0x01, 0x01, 0x01, 0x02, 0x03, 0x06, 0x06, 0x06,
 274          0x01, 0x01, 0x02, 0x02, 0x04, 0x06, 0x07, 0x06,
 275          0x01, 0x02, 0x02, 0x03, 0x05, 0x09, 0x08, 0x06,
 276          0x02, 0x02, 0x04, 0x06, 0x07, 0x0b, 0x0a, 0x08,
 277          0x02, 0x04, 0x06, 0x06, 0x08, 0x0a, 0x0b, 0x09,
 278          0x05, 0x06, 0x08, 0x09, 0x0a, 0x0c, 0x0c, 0x0a,
 279          0x07, 0x09, 0x0a, 0x0a, 0x0b, 0x0a, 0x0a, 0x0a},
 280         {                               /* Q-table C-components */
 281          0x02, 0x02, 0x02, 0x05, 0x0a, 0x0a, 0x0a, 0x0a,
 282          0x02, 0x02, 0x03, 0x07, 0x0a, 0x0a, 0x0a, 0x0a,
 283          0x02, 0x03, 0x06, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 284          0x05, 0x07, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 285          0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 286          0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 287          0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 288          0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a}
 289 };
 290
 291 static const __u8 qtable_pocketdv[2][64] = {
 292         {               /* Q-table Y-components start registers 0x8800 */
 293          0x06, 0x04, 0x04, 0x06, 0x0a, 0x10, 0x14, 0x18,
 294          0x05, 0x05, 0x06, 0x08, 0x0a, 0x17, 0x18, 0x16,
 295          0x06, 0x05, 0x06, 0x0a, 0x10, 0x17, 0x1c, 0x16,
 296          0x06, 0x07, 0x09, 0x0c, 0x14, 0x23, 0x20, 0x19,
 297          0x07, 0x09, 0x0f, 0x16, 0x1b, 0x2c, 0x29, 0x1f,
 298          0x0a, 0x0e, 0x16, 0x1a, 0x20, 0x2a, 0x2d, 0x25,
 299          0x14, 0x1a, 0x1f, 0x23, 0x29, 0x30, 0x30, 0x28,
 300          0x1d, 0x25, 0x26, 0x27, 0x2d, 0x28, 0x29, 0x28,
 301          },
 302         {               /* Q-table C-components start registers 0x8840 */
 303          0x07, 0x07, 0x0a, 0x13, 0x28, 0x28, 0x28, 0x28,
 304          0x07, 0x08, 0x0a, 0x1a, 0x28, 0x28, 0x28, 0x28,
 305          0x0a, 0x0a, 0x16, 0x28, 0x28, 0x28, 0x28, 0x28,
 306          0x13, 0x1a, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
 307          0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
 308          0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
 309          0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
 310          0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28}
 311 };
 312
 313 /* read 'len' bytes to gspca_dev->usb_buf */
 314 static void reg_r(struct gspca_dev *gspca_dev,
 315                   __u16 index,
 316                   __u16 length)
 317 {
 318         usb_control_msg(gspca_dev->dev,
 319                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 320                         0,
 321                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 322                         0,              /* value */
 323                         index, gspca_dev->usb_buf, length, 500);
 324 }
 325
 326 static int reg_w(struct gspca_dev *gspca_dev,
 327                      __u16 req, __u16 index, __u16 value)
 328 {
 329         int ret;
 330
 331         gspca_dbg(gspca_dev, D_USBO, "reg write: [0x%02x] = 0x%02x\n",
 332                   index, value);
 333         ret = usb_control_msg(gspca_dev->dev,
 334                         usb_sndctrlpipe(gspca_dev->dev, 0),
 335                         req,
 336                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 337                         value, index, NULL, 0, 500);
 338         if (ret < 0)
 339                 pr_err("reg write: error %d\n", ret);
 340         return ret;
 341 }
 342
 343 /* returns: negative is error, pos or zero is data */
 344 static int reg_r_12(struct gspca_dev *gspca_dev,
 345                         __u16 req,      /* bRequest */
 346                         __u16 index,    /* wIndex */
 347                         __u16 length)   /* wLength (1 or 2 only) */
 348 {
 349         int ret;
 350
 351         gspca_dev->usb_buf[1] = 0;
 352         ret = usb_control_msg(gspca_dev->dev,
 353                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 354                         req,
 355                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 356                         0,              /* value */
 357                         index,
 358                         gspca_dev->usb_buf, length,
 359                         500);           /* timeout */
 360         if (ret < 0) {
 361                 pr_err("reg_r_12 err %d\n", ret);
 362                 return ret;
 363         }
 364         return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
 365 }
 366
 367 /*
 368  * Simple function to wait for a given 8-bit value to be returned from
 369  * a reg_read call.
 370  * Returns: negative is error or timeout, zero is success.
 371  */
 372 static int reg_r_wait(struct gspca_dev *gspca_dev,
 373                         __u16 reg, __u16 index, __u16 value)
 374 {
 375         int ret, cnt = 20;
 376
 377         while (--cnt > 0) {
 378                 ret = reg_r_12(gspca_dev, reg, index, 1);
 379                 if (ret == value)
 380                         return 0;
 381                 msleep(50);
 382         }
 383         return -EIO;
 384 }
 385
 386 static int write_vector(struct gspca_dev *gspca_dev,
 387                         const __u16 data[][3])
 388 {
 389         int ret, i = 0;
 390
 391         while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) {
 392                 ret = reg_w(gspca_dev, data[i][0], data[i][2], data[i][1]);
 393                 if (ret < 0)
 394                         return ret;
 395                 i++;
 396         }
 397         return 0;
 398 }
 399
 400 static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
 401                                 unsigned int request,
 402                                 unsigned int ybase,
 403                                 unsigned int cbase,
 404                                 const __u8 qtable[2][64])
 405 {
 406         int i, err;
 407
 408         /* loop over y components */
 409         for (i = 0; i < 64; i++) {
 410                 err = reg_w(gspca_dev, request, ybase + i, qtable[0][i]);
 411                 if (err < 0)
 412                         return err;
 413         }
 414
 415         /* loop over c components */
 416         for (i = 0; i < 64; i++) {
 417                 err = reg_w(gspca_dev, request, cbase + i, qtable[1][i]);
 418                 if (err < 0)
 419                         return err;
 420         }
 421         return 0;
 422 }
 423
 424 static void spca500_ping310(struct gspca_dev *gspca_dev)
 425 {
 426         reg_r(gspca_dev, 0x0d04, 2);
 427         gspca_dbg(gspca_dev, D_STREAM, "ClickSmart310 ping 0x0d04 0x%02x 0x%02x\n",
 428                   gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
 429 }
 430
 431 static void spca500_clksmart310_init(struct gspca_dev *gspca_dev)
 432 {
 433         reg_r(gspca_dev, 0x0d05, 2);
 434         gspca_dbg(gspca_dev, D_STREAM, "ClickSmart310 init 0x0d05 0x%02x 0x%02x\n",
 435                   gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
 436         reg_w(gspca_dev, 0x00, 0x8167, 0x5a);
 437         spca500_ping310(gspca_dev);
 438
 439         reg_w(gspca_dev, 0x00, 0x8168, 0x22);
 440         reg_w(gspca_dev, 0x00, 0x816a, 0xc0);
 441         reg_w(gspca_dev, 0x00, 0x816b, 0x0b);
 442         reg_w(gspca_dev, 0x00, 0x8169, 0x25);
 443         reg_w(gspca_dev, 0x00, 0x8157, 0x5b);
 444         reg_w(gspca_dev, 0x00, 0x8158, 0x5b);
 445         reg_w(gspca_dev, 0x00, 0x813f, 0x03);
 446         reg_w(gspca_dev, 0x00, 0x8151, 0x4a);
 447         reg_w(gspca_dev, 0x00, 0x8153, 0x78);
 448         reg_w(gspca_dev, 0x00, 0x0d01, 0x04);
 449                                                 /* 00 for adjust shutter */
 450         reg_w(gspca_dev, 0x00, 0x0d02, 0x01);
 451         reg_w(gspca_dev, 0x00, 0x8169, 0x25);
 452         reg_w(gspca_dev, 0x00, 0x0d01, 0x02);
 453 }
 454
 455 static void spca500_setmode(struct gspca_dev *gspca_dev,
 456                         __u8 xmult, __u8 ymult)
 457 {
 458         int mode;
 459
 460         /* set x multiplier */
 461         reg_w(gspca_dev, 0, 0x8001, xmult);
 462
 463         /* set y multiplier */
 464         reg_w(gspca_dev, 0, 0x8002, ymult);
 465
 466         /* use compressed mode, VGA, with mode specific subsample */
 467         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
 468         reg_w(gspca_dev, 0, 0x8003, mode << 4);
 469 }
 470
 471 static int spca500_full_reset(struct gspca_dev *gspca_dev)
 472 {
 473         int err;
 474
 475         /* send the reset command */
 476         err = reg_w(gspca_dev, 0xe0, 0x0001, 0x0000);
 477         if (err < 0)
 478                 return err;
 479
 480         /* wait for the reset to complete */
 481         err = reg_r_wait(gspca_dev, 0x06, 0x0000, 0x0000);
 482         if (err < 0)
 483                 return err;
 484         err = reg_w(gspca_dev, 0xe0, 0x0000, 0x0000);
 485         if (err < 0)
 486                 return err;
 487         err = reg_r_wait(gspca_dev, 0x06, 0, 0);
 488         if (err < 0) {
 489                 gspca_err(gspca_dev, "reg_r_wait() failed\n");
 490                 return err;
 491         }
 492         /* all ok */
 493         return 0;
 494 }
 495
 496 /* Synchro the Bridge with sensor */
 497 /* Maybe that will work on all spca500 chip */
 498 /* because i only own a clicksmart310 try for that chip */
 499 /* using spca50x_set_packet_size() cause an Ooops here */
 500 /* usb_set_interface from kernel 2.6.x clear all the urb stuff */
 501 /* up-port the same feature as in 2.4.x kernel */
 502 static int spca500_synch310(struct gspca_dev *gspca_dev)
 503 {
 504         if (usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0) < 0) {
 505                 gspca_err(gspca_dev, "Set packet size: set interface error\n");
 506                 goto error;
 507         }
 508         spca500_ping310(gspca_dev);
 509
 510         reg_r(gspca_dev, 0x0d00, 1);
 511
 512         /* need alt setting here */
 513         gspca_dbg(gspca_dev, D_PACK, "ClickSmart310 sync alt: %d\n",
 514                   gspca_dev->alt);
 515
 516         /* Windoze use pipe with altsetting 6 why 7 here */
 517         if (usb_set_interface(gspca_dev->dev,
 518                                 gspca_dev->iface,
 519                                 gspca_dev->alt) < 0) {
 520                 gspca_err(gspca_dev, "Set packet size: set interface error\n");
 521                 goto error;
 522         }
 523         return 0;
 524 error:
 525         return -EBUSY;
 526 }
 527
 528 static void spca500_reinit(struct gspca_dev *gspca_dev)
 529 {
 530         int err;
 531         __u8 Data;
 532
 533         /* some unknown command from Aiptek pocket dv and family300 */
 534
 535         reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
 536         reg_w(gspca_dev, 0x00, 0x0d03, 0x00);
 537         reg_w(gspca_dev, 0x00, 0x0d02, 0x01);
 538
 539         /* enable drop packet */
 540         reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 541
 542         err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840,
 543                                  qtable_pocketdv);
 544         if (err < 0)
 545                 gspca_err(gspca_dev, "spca50x_setup_qtable failed on init\n");
 546
 547         /* set qtable index */
 548         reg_w(gspca_dev, 0x00, 0x8880, 2);
 549         /* family cam Quicksmart stuff */
 550         reg_w(gspca_dev, 0x00, 0x800a, 0x00);
 551         /* Set agc transfer: synced between frames */
 552         reg_w(gspca_dev, 0x00, 0x820f, 0x01);
 553         /* Init SDRAM - needed for SDRAM access */
 554         reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 555         /*Start init sequence or stream */
 556         reg_w(gspca_dev, 0, 0x8003, 0x00);
 557         /* switch to video camera mode */
 558         reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 559         msleep(2000);
 560         if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) {
 561                 reg_r(gspca_dev, 0x816b, 1);
 562                 Data = gspca_dev->usb_buf[0];
 563                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 564         }
 565 }
 566
 567 /* this function is called at probe time */
 568 static int sd_config(struct gspca_dev *gspca_dev,
 569                         const struct usb_device_id *id)
 570 {
 571         struct sd *sd = (struct sd *) gspca_dev;
 572         struct cam *cam;
 573
 574         cam = &gspca_dev->cam;
 575         sd->subtype = id->driver_info;
 576         if (sd->subtype != LogitechClickSmart310) {
 577                 cam->cam_mode = vga_mode;
 578                 cam->nmodes = ARRAY_SIZE(vga_mode);
 579         } else {
 580                 cam->cam_mode = sif_mode;
 581                 cam->nmodes = ARRAY_SIZE(sif_mode);
 582         }
 583         return 0;
 584 }
 585
 586 /* this function is called at probe and resume time */
 587 static int sd_init(struct gspca_dev *gspca_dev)
 588 {
 589         struct sd *sd = (struct sd *) gspca_dev;
 590
 591         /* initialisation of spca500 based cameras is deferred */
 592         gspca_dbg(gspca_dev, D_STREAM, "SPCA500 init\n");
 593         if (sd->subtype == LogitechClickSmart310)
 594                 spca500_clksmart310_init(gspca_dev);
 595 /*      else
 596                 spca500_initialise(gspca_dev); */
 597         gspca_dbg(gspca_dev, D_STREAM, "SPCA500 init done\n");
 598         return 0;
 599 }
 600
 601 static int sd_start(struct gspca_dev *gspca_dev)
 602 {
 603         struct sd *sd = (struct sd *) gspca_dev;
 604         int err;
 605         __u8 Data;
 606         __u8 xmult, ymult;
 607
 608         /* create the JPEG header */
 609         jpeg_define(sd->jpeg_hdr, gspca_dev->pixfmt.height,
 610                         gspca_dev->pixfmt.width,
 611                         0x22);          /* JPEG 411 */
 612         jpeg_set_qual(sd->jpeg_hdr, QUALITY);
 613
 614         if (sd->subtype == LogitechClickSmart310) {
 615                 xmult = 0x16;
 616                 ymult = 0x12;
 617         } else {
 618                 xmult = 0x28;
 619                 ymult = 0x1e;
 620         }
 621
 622         /* is there a sensor here ? */
 623         reg_r(gspca_dev, 0x8a04, 1);
 624         gspca_dbg(gspca_dev, D_STREAM, "Spca500 Sensor Address 0x%02x\n",
 625                   gspca_dev->usb_buf[0]);
 626         gspca_dbg(gspca_dev, D_STREAM, "Spca500 curr_mode: %d Xmult: 0x%02x, Ymult: 0x%02x",
 627                   gspca_dev->curr_mode, xmult, ymult);
 628
 629         /* setup qtable */
 630         switch (sd->subtype) {
 631         case LogitechClickSmart310:
 632                  spca500_setmode(gspca_dev, xmult, ymult);
 633
 634                 /* enable drop packet */
 635                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 636                 reg_w(gspca_dev, 0x00, 0x8880, 3);
 637                 err = spca50x_setup_qtable(gspca_dev,
 638                                            0x00, 0x8800, 0x8840,
 639                                            qtable_creative_pccam);
 640                 if (err < 0)
 641                         gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
 642                 /* Init SDRAM - needed for SDRAM access */
 643                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 644
 645                 /* switch to video camera mode */
 646                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 647                 msleep(500);
 648                 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
 649                         gspca_err(gspca_dev, "reg_r_wait() failed\n");
 650
 651                 reg_r(gspca_dev, 0x816b, 1);
 652                 Data = gspca_dev->usb_buf[0];
 653                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 654
 655                 spca500_synch310(gspca_dev);
 656
 657                 write_vector(gspca_dev, spca500_visual_defaults);
 658                 spca500_setmode(gspca_dev, xmult, ymult);
 659                 /* enable drop packet */
 660                 err = reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 661                 if (err < 0)
 662                         gspca_err(gspca_dev, "failed to enable drop packet\n");
 663                 reg_w(gspca_dev, 0x00, 0x8880, 3);
 664                 err = spca50x_setup_qtable(gspca_dev,
 665                                            0x00, 0x8800, 0x8840,
 666                                            qtable_creative_pccam);
 667                 if (err < 0)
 668                         gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
 669
 670                 /* Init SDRAM - needed for SDRAM access */
 671                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 672
 673                 /* switch to video camera mode */
 674                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 675
 676                 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
 677                         gspca_err(gspca_dev, "reg_r_wait() failed\n");
 678
 679                 reg_r(gspca_dev, 0x816b, 1);
 680                 Data = gspca_dev->usb_buf[0];
 681                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 682                 break;
 683         case CreativePCCam300:          /* Creative PC-CAM 300 640x480 CCD */
 684         case IntelPocketPCCamera:       /* FIXME: Temporary fix for
 685                                          *      Intel Pocket PC Camera
 686                                          *      - NWG (Sat 29th March 2003) */
 687
 688                 /* do a full reset */
 689                 err = spca500_full_reset(gspca_dev);
 690                 if (err < 0)
 691                         gspca_err(gspca_dev, "spca500_full_reset failed\n");
 692
 693                 /* enable drop packet */
 694                 err = reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 695                 if (err < 0)
 696                         gspca_err(gspca_dev, "failed to enable drop packet\n");
 697                 reg_w(gspca_dev, 0x00, 0x8880, 3);
 698                 err = spca50x_setup_qtable(gspca_dev,
 699                                            0x00, 0x8800, 0x8840,
 700                                            qtable_creative_pccam);
 701                 if (err < 0)
 702                         gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
 703
 704                 spca500_setmode(gspca_dev, xmult, ymult);
 705                 reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
 706
 707                 /* switch to video camera mode */
 708                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 709
 710                 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
 711                         gspca_err(gspca_dev, "reg_r_wait() failed\n");
 712
 713                 reg_r(gspca_dev, 0x816b, 1);
 714                 Data = gspca_dev->usb_buf[0];
 715                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 716
 717 /*              write_vector(gspca_dev, spca500_visual_defaults); */
 718                 break;
 719         case KodakEZ200:                /* Kodak EZ200 */
 720
 721                 /* do a full reset */
 722                 err = spca500_full_reset(gspca_dev);
 723                 if (err < 0)
 724                         gspca_err(gspca_dev, "spca500_full_reset failed\n");
 725                 /* enable drop packet */
 726                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 727                 reg_w(gspca_dev, 0x00, 0x8880, 0);
 728                 err = spca50x_setup_qtable(gspca_dev,
 729                                            0x00, 0x8800, 0x8840,
 730                                            qtable_kodak_ez200);
 731                 if (err < 0)
 732                         gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
 733                 spca500_setmode(gspca_dev, xmult, ymult);
 734
 735                 reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
 736
 737                 /* switch to video camera mode */
 738                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 739
 740                 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
 741                         gspca_err(gspca_dev, "reg_r_wait() failed\n");
 742
 743                 reg_r(gspca_dev, 0x816b, 1);
 744                 Data = gspca_dev->usb_buf[0];
 745                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 746
 747 /*              write_vector(gspca_dev, spca500_visual_defaults); */
 748                 break;
 749
 750         case BenqDC1016:
 751         case DLinkDSC350:               /* FamilyCam 300 */
 752         case AiptekPocketDV:            /* Aiptek PocketDV */
 753         case Gsmartmini:                /*Mustek Gsmart Mini */
 754         case MustekGsmart300:           /* Mustek Gsmart 300 */
 755         case PalmPixDC85:
 756         case Optimedia:
 757         case ToptroIndus:
 758         case AgfaCl20:
 759                 spca500_reinit(gspca_dev);
 760                 reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
 761                 /* enable drop packet */
 762                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 763
 764                 err = spca50x_setup_qtable(gspca_dev,
 765                                    0x00, 0x8800, 0x8840, qtable_pocketdv);
 766                 if (err < 0)
 767                         gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
 768                 reg_w(gspca_dev, 0x00, 0x8880, 2);
 769
 770                 /* familycam Quicksmart pocketDV stuff */
 771                 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
 772                 /* Set agc transfer: synced between frames */
 773                 reg_w(gspca_dev, 0x00, 0x820f, 0x01);
 774                 /* Init SDRAM - needed for SDRAM access */
 775                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 776
 777                 spca500_setmode(gspca_dev, xmult, ymult);
 778                 /* switch to video camera mode */
 779                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 780
 781                 reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
 782
 783                 reg_r(gspca_dev, 0x816b, 1);
 784                 Data = gspca_dev->usb_buf[0];
 785                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 786                 break;
 787         case LogitechTraveler:
 788         case LogitechClickSmart510:
 789                 reg_w(gspca_dev, 0x02, 0x00, 0x00);
 790                 /* enable drop packet */
 791                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 792
 793                 err = spca50x_setup_qtable(gspca_dev,
 794                                         0x00, 0x8800,
 795                                         0x8840, qtable_creative_pccam);
 796                 if (err < 0)
 797                         gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
 798                 reg_w(gspca_dev, 0x00, 0x8880, 3);
 799                 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
 800                 /* Init SDRAM - needed for SDRAM access */
 801                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 802
 803                 spca500_setmode(gspca_dev, xmult, ymult);
 804
 805                 /* switch to video camera mode */
 806                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 807                 reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
 808
 809                 reg_r(gspca_dev, 0x816b, 1);
 810                 Data = gspca_dev->usb_buf[0];
 811                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 812                 write_vector(gspca_dev, Clicksmart510_defaults);
 813                 break;
 814         }
 815         return 0;
 816 }
 817
 818 static void sd_stopN(struct gspca_dev *gspca_dev)
 819 {
 820         reg_w(gspca_dev, 0, 0x8003, 0x00);
 821
 822         /* switch to video camera mode */
 823         reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 824         reg_r(gspca_dev, 0x8000, 1);
 825         gspca_dbg(gspca_dev, D_STREAM, "stop SPCA500 done reg8000: 0x%2x\n",
 826                   gspca_dev->usb_buf[0]);
 827 }
 828
 829 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 830                         u8 *data,                       /* isoc packet */
 831                         int len)                        /* iso packet length */
 832 {
 833         struct sd *sd = (struct sd *) gspca_dev;
 834         int i;
 835         static __u8 ffd9[] = {0xff, 0xd9};
 836
 837 /* frames are jpeg 4.1.1 without 0xff escape */
 838         if (data[0] == 0xff) {
 839                 if (data[1] != 0x01) {  /* drop packet */
 840 /*                      gspca_dev->last_packet_type = DISCARD_PACKET; */
 841                         return;
 842                 }
 843                 gspca_frame_add(gspca_dev, LAST_PACKET,
 844                                         ffd9, 2);
 845
 846                 /* put the JPEG header in the new frame */
 847                 gspca_frame_add(gspca_dev, FIRST_PACKET,
 848                         sd->jpeg_hdr, JPEG_HDR_SZ);
 849
 850                 data += SPCA500_OFFSET_DATA;
 851                 len -= SPCA500_OFFSET_DATA;
 852         } else {
 853                 data += 1;
 854                 len -= 1;
 855         }
 856
 857         /* add 0x00 after 0xff */
 858         i = 0;
 859         do {
 860                 if (data[i] == 0xff) {
 861                         gspca_frame_add(gspca_dev, INTER_PACKET,
 862                                         data, i + 1);
 863                         len -= i;
 864                         data += i;
 865                         *data = 0x00;
 866                         i = 0;
 867                 }
 868                 i++;
 869         } while (i < len);
 870         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 871 }
 872
 873 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
 874 {
 875         reg_w(gspca_dev, 0x00, 0x8167,
 876                         (__u8) (val - 128));
 877 }
 878
 879 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
 880 {
 881         reg_w(gspca_dev, 0x00, 0x8168, val);
 882 }
 883
 884 static void setcolors(struct gspca_dev *gspca_dev, s32 val)
 885 {
 886         reg_w(gspca_dev, 0x00, 0x8169, val);
 887 }
 888
 889 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 890 {
 891         struct gspca_dev *gspca_dev =
 892                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 893
 894         gspca_dev->usb_err = 0;
 895
 896         if (!gspca_dev->streaming)
 897                 return 0;
 898
 899         switch (ctrl->id) {
 900         case V4L2_CID_BRIGHTNESS:
 901                 setbrightness(gspca_dev, ctrl->val);
 902                 break;
 903         case V4L2_CID_CONTRAST:
 904                 setcontrast(gspca_dev, ctrl->val);
 905                 break;
 906         case V4L2_CID_SATURATION:
 907                 setcolors(gspca_dev, ctrl->val);
 908                 break;
 909         }
 910         return gspca_dev->usb_err;
 911 }
 912
 913 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 914         .s_ctrl = sd_s_ctrl,
 915 };
 916
 917 static int sd_init_controls(struct gspca_dev *gspca_dev)
 918 {
 919         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 920
 921         gspca_dev->vdev.ctrl_handler = hdl;
 922         v4l2_ctrl_handler_init(hdl, 3);
 923         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 924                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
 925         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 926                         V4L2_CID_CONTRAST, 0, 63, 1, 31);
 927         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 928                         V4L2_CID_SATURATION, 0, 63, 1, 31);
 929
 930         if (hdl->error) {
 931                 pr_err("Could not initialize controls\n");
 932                 return hdl->error;
 933         }
 934         return 0;
 935 }
 936
 937 /* sub-driver description */
 938 static const struct sd_desc sd_desc = {
 939         .name = MODULE_NAME,
 940         .config = sd_config,
 941         .init = sd_init,
 942         .init_controls = sd_init_controls,
 943         .start = sd_start,
 944         .stopN = sd_stopN,
 945         .pkt_scan = sd_pkt_scan,
 946 };
 947
 948 /* -- module initialisation -- */
 949 static const struct usb_device_id device_table[] = {
 950         {USB_DEVICE(0x040a, 0x0300), .driver_info = KodakEZ200},
 951         {USB_DEVICE(0x041e, 0x400a), .driver_info = CreativePCCam300},
 952         {USB_DEVICE(0x046d, 0x0890), .driver_info = LogitechTraveler},
 953         {USB_DEVICE(0x046d, 0x0900), .driver_info = LogitechClickSmart310},
 954         {USB_DEVICE(0x046d, 0x0901), .driver_info = LogitechClickSmart510},
 955         {USB_DEVICE(0x04a5, 0x300c), .driver_info = BenqDC1016},
 956         {USB_DEVICE(0x04fc, 0x7333), .driver_info = PalmPixDC85},
 957         {USB_DEVICE(0x055f, 0xc200), .driver_info = MustekGsmart300},
 958         {USB_DEVICE(0x055f, 0xc220), .driver_info = Gsmartmini},
 959         {USB_DEVICE(0x06bd, 0x0404), .driver_info = AgfaCl20},
 960         {USB_DEVICE(0x06be, 0x0800), .driver_info = Optimedia},
 961         {USB_DEVICE(0x084d, 0x0003), .driver_info = DLinkDSC350},
 962         {USB_DEVICE(0x08ca, 0x0103), .driver_info = AiptekPocketDV},
 963         {USB_DEVICE(0x2899, 0x012c), .driver_info = ToptroIndus},
 964         {USB_DEVICE(0x8086, 0x0630), .driver_info = IntelPocketPCCamera},
 965         {}
 966 };
 967 MODULE_DEVICE_TABLE(usb, device_table);
 968
 969 /* -- device connect -- */
 970 static int sd_probe(struct usb_interface *intf,
 971                         const struct usb_device_id *id)
 972 {
 973         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 974                                 THIS_MODULE);
 975 }
 976
 977 static struct usb_driver sd_driver = {
 978         .name = MODULE_NAME,
 979         .id_table = device_table,
 980         .probe = sd_probe,
 981         .disconnect = gspca_disconnect,
 982 #ifdef CONFIG_PM
 983         .suspend = gspca_suspend,
 984         .resume = gspca_resume,
 985         .reset_resume = gspca_resume,
 986 #endif
 987 };
 988
 989 module_usb_driver(sd_driver);