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