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 #include "jpeg.h"
  26
  27 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  28 MODULE_DESCRIPTION("GSPCA/SPCA500 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         __u8 packet[ISO_MAX_SIZE + 128];
  36                                  /* !! no more than 128 ff in an ISO packet */
  37
  38         unsigned char brightness;
  39         unsigned char contrast;
  40         unsigned char colors;
  41
  42         char qindex;
  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 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 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         __u16 vendor;
 631         __u16 product;
 632
 633         vendor = id->idVendor;
 634         product = id->idProduct;
 635         switch (vendor) {
 636         case 0x040a:            /* Kodak cameras */
 637 /*              switch (product) { */
 638 /*              case 0x0300: */
 639                         sd->subtype = KodakEZ200;
 640 /*                      break; */
 641 /*              } */
 642                 break;
 643         case 0x041e:            /* Creative cameras */
 644 /*              switch (product) { */
 645 /*              case 0x400a: */
 646                         sd->subtype = CreativePCCam300;
 647 /*                      break; */
 648 /*              } */
 649                 break;
 650         case 0x046d:            /* Logitech Labtec */
 651                 switch (product) {
 652                 case 0x0890:
 653                         sd->subtype = LogitechTraveler;
 654                         break;
 655                 case 0x0900:
 656                         sd->subtype = LogitechClickSmart310;
 657                         break;
 658                 case 0x0901:
 659                         sd->subtype = LogitechClickSmart510;
 660                         break;
 661                 }
 662                 break;
 663         case 0x04a5:            /* Benq */
 664 /*              switch (product) { */
 665 /*              case 0x300c: */
 666                         sd->subtype = BenqDC1016;
 667 /*                      break; */
 668 /*              } */
 669                 break;
 670         case 0x04fc:            /* SunPlus */
 671 /*              switch (product) { */
 672 /*              case 0x7333: */
 673                         sd->subtype = PalmPixDC85;
 674 /*                      break; */
 675 /*              } */
 676                 break;
 677         case 0x055f:            /* Mustek cameras */
 678                 switch (product) {
 679                 case 0xc200:
 680                         sd->subtype = MustekGsmart300;
 681                         break;
 682                 case 0xc220:
 683                         sd->subtype = Gsmartmini;
 684                         break;
 685                 }
 686                 break;
 687         case 0x06bd:            /* Agfa Cl20 */
 688 /*              switch (product) { */
 689 /*              case 0x0404: */
 690                         sd->subtype = AgfaCl20;
 691 /*                      break; */
 692 /*              } */
 693                 break;
 694         case 0x06be:            /* Optimedia */
 695 /*              switch (product) { */
 696 /*              case 0x0800: */
 697                         sd->subtype = Optimedia;
 698 /*                      break; */
 699 /*              } */
 700                 break;
 701         case 0x084d:            /* D-Link / Minton */
 702 /*              switch (product) { */
 703 /*              case 0x0003:     * DSC-350 / S-Cam F5 */
 704                         sd->subtype = DLinkDSC350;
 705 /*                      break; */
 706 /*              } */
 707                 break;
 708         case 0x08ca:            /* Aiptek */
 709 /*              switch (product) { */
 710 /*              case 0x0103: */
 711                         sd->subtype = AiptekPocketDV;
 712 /*                      break; */
 713 /*              } */
 714                 break;
 715         case 0x2899:            /* ToptroIndustrial */
 716 /*              switch (product) { */
 717 /*              case 0x012c: */
 718                         sd->subtype = ToptroIndus;
 719 /*                      break; */
 720 /*              } */
 721                 break;
 722         case 0x8086:            /* Intel */
 723 /*              switch (product) { */
 724 /*              case 0x0630:     * Pocket PC Camera */
 725                         sd->subtype = IntelPocketPCCamera;
 726 /*                      break; */
 727 /*              } */
 728                 break;
 729         }
 730         cam = &gspca_dev->cam;
 731         cam->epaddr = 0x01;
 732         if (sd->subtype != LogitechClickSmart310) {
 733                 cam->cam_mode = vga_mode;
 734                 cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
 735         } else {
 736                 cam->cam_mode = sif_mode;
 737                 cam->nmodes = sizeof sif_mode / sizeof sif_mode[0];
 738         }
 739         sd->qindex = 5;
 740         sd->brightness = BRIGHTNESS_DEF;
 741         sd->contrast = CONTRAST_DEF;
 742         sd->colors = COLOR_DEF;
 743         return 0;
 744 }
 745
 746 /* this function is called at open time */
 747 static int sd_open(struct gspca_dev *gspca_dev)
 748 {
 749         struct sd *sd = (struct sd *) gspca_dev;
 750
 751         /* initialisation of spca500 based cameras is deferred */
 752         PDEBUG(D_STREAM, "SPCA500 init");
 753         if (sd->subtype == LogitechClickSmart310)
 754                 spca500_clksmart310_init(gspca_dev);
 755 /*      else
 756                 spca500_initialise(gspca_dev); */
 757         PDEBUG(D_STREAM, "SPCA500 init done");
 758         return 0;
 759 }
 760
 761 static void sd_start(struct gspca_dev *gspca_dev)
 762 {
 763         struct sd *sd = (struct sd *) gspca_dev;
 764         int err;
 765         __u8 Data;
 766         __u8 xmult, ymult;
 767
 768         if (sd->subtype == LogitechClickSmart310) {
 769                 xmult = 0x16;
 770                 ymult = 0x12;
 771         } else {
 772                 xmult = 0x28;
 773                 ymult = 0x1e;
 774         }
 775
 776         /* is there a sensor here ? */
 777         reg_r(gspca_dev, 0x8a04, 1);
 778         PDEBUG(D_STREAM, "Spca500 Sensor Address 0x%02x",
 779                 gspca_dev->usb_buf[0]);
 780         PDEBUG(D_STREAM, "Spca500 curr_mode: %d Xmult: 0x%02x, Ymult: 0x%02x",
 781                 gspca_dev->curr_mode, xmult, ymult);
 782
 783         /* setup qtable */
 784         switch (sd->subtype) {
 785         case LogitechClickSmart310:
 786                  spca500_setmode(gspca_dev, xmult, ymult);
 787
 788                 /* enable drop packet */
 789                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 790                 reg_w(gspca_dev, 0x00, 0x8880, 3);
 791                 err = spca50x_setup_qtable(gspca_dev,
 792                                            0x00, 0x8800, 0x8840,
 793                                            qtable_creative_pccam);
 794                 if (err < 0)
 795                         PDEBUG(D_ERR, "spca50x_setup_qtable failed");
 796                 /* Init SDRAM - needed for SDRAM access */
 797                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 798
 799                 /* switch to video camera mode */
 800                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 801                 msleep(500);
 802                 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
 803                         PDEBUG(D_ERR, "reg_r_wait() failed");
 804
 805                 reg_r(gspca_dev, 0x816b, 1);
 806                 Data = gspca_dev->usb_buf[0];
 807                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 808
 809                 spca500_synch310(gspca_dev);
 810
 811                 write_vector(gspca_dev, spca500_visual_defaults);
 812                 spca500_setmode(gspca_dev, xmult, ymult);
 813                 /* enable drop packet */
 814                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 815                         PDEBUG(D_ERR, "failed to enable drop packet");
 816                 reg_w(gspca_dev, 0x00, 0x8880, 3);
 817                 err = spca50x_setup_qtable(gspca_dev,
 818                                            0x00, 0x8800, 0x8840,
 819                                            qtable_creative_pccam);
 820                 if (err < 0)
 821                         PDEBUG(D_ERR, "spca50x_setup_qtable failed");
 822
 823                 /* Init SDRAM - needed for SDRAM access */
 824                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 825
 826                 /* switch to video camera mode */
 827                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 828
 829                 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
 830                         PDEBUG(D_ERR, "reg_r_wait() failed");
 831
 832                 reg_r(gspca_dev, 0x816b, 1);
 833                 Data = gspca_dev->usb_buf[0];
 834                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 835                 break;
 836         case CreativePCCam300:          /* Creative PC-CAM 300 640x480 CCD */
 837         case IntelPocketPCCamera:       /* FIXME: Temporary fix for
 838                                          *      Intel Pocket PC Camera
 839                                          *      - NWG (Sat 29th March 2003) */
 840
 841                 /* do a full reset */
 842                 err = spca500_full_reset(gspca_dev);
 843                 if (err < 0)
 844                         PDEBUG(D_ERR, "spca500_full_reset failed");
 845
 846                 /* enable drop packet */
 847                 err = reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 848                 if (err < 0)
 849                         PDEBUG(D_ERR, "failed to enable drop packet");
 850                 reg_w(gspca_dev, 0x00, 0x8880, 3);
 851                 err = spca50x_setup_qtable(gspca_dev,
 852                                            0x00, 0x8800, 0x8840,
 853                                            qtable_creative_pccam);
 854                 if (err < 0)
 855                         PDEBUG(D_ERR, "spca50x_setup_qtable failed");
 856
 857                 spca500_setmode(gspca_dev, xmult, ymult);
 858                 reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
 859
 860                 /* switch to video camera mode */
 861                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 862
 863                 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
 864                         PDEBUG(D_ERR, "reg_r_wait() failed");
 865
 866                 reg_r(gspca_dev, 0x816b, 1);
 867                 Data = gspca_dev->usb_buf[0];
 868                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 869
 870 /*              write_vector(gspca_dev, spca500_visual_defaults); */
 871                 break;
 872         case KodakEZ200:                /* Kodak EZ200 */
 873
 874                 /* do a full reset */
 875                 err = spca500_full_reset(gspca_dev);
 876                 if (err < 0)
 877                         PDEBUG(D_ERR, "spca500_full_reset failed");
 878                 /* enable drop packet */
 879                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 880                 reg_w(gspca_dev, 0x00, 0x8880, 0);
 881                 err = spca50x_setup_qtable(gspca_dev,
 882                                            0x00, 0x8800, 0x8840,
 883                                            qtable_kodak_ez200);
 884                 if (err < 0)
 885                         PDEBUG(D_ERR, "spca50x_setup_qtable failed");
 886                 spca500_setmode(gspca_dev, xmult, ymult);
 887
 888                 reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
 889
 890                 /* switch to video camera mode */
 891                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 892
 893                 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
 894                         PDEBUG(D_ERR, "reg_r_wait() failed");
 895
 896                 reg_r(gspca_dev, 0x816b, 1);
 897                 Data = gspca_dev->usb_buf[0];
 898                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 899
 900 /*              write_vector(gspca_dev, spca500_visual_defaults); */
 901                 break;
 902
 903         case BenqDC1016:
 904         case DLinkDSC350:               /* FamilyCam 300 */
 905         case AiptekPocketDV:            /* Aiptek PocketDV */
 906         case Gsmartmini:                /*Mustek Gsmart Mini */
 907         case MustekGsmart300:           /* Mustek Gsmart 300 */
 908         case PalmPixDC85:
 909         case Optimedia:
 910         case ToptroIndus:
 911         case AgfaCl20:
 912                 spca500_reinit(gspca_dev);
 913                 reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
 914                 /* enable drop packet */
 915                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 916
 917                 err = spca50x_setup_qtable(gspca_dev,
 918                                    0x00, 0x8800, 0x8840, qtable_pocketdv);
 919                 if (err < 0)
 920                         PDEBUG(D_ERR, "spca50x_setup_qtable failed");
 921                 reg_w(gspca_dev, 0x00, 0x8880, 2);
 922
 923                 /* familycam Quicksmart pocketDV stuff */
 924                 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
 925                 /* Set agc transfer: synced inbetween frames */
 926                 reg_w(gspca_dev, 0x00, 0x820f, 0x01);
 927                 /* Init SDRAM - needed for SDRAM access */
 928                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 929
 930                 spca500_setmode(gspca_dev, xmult, ymult);
 931                 /* switch to video camera mode */
 932                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 933
 934                 reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
 935
 936                 reg_r(gspca_dev, 0x816b, 1);
 937                 Data = gspca_dev->usb_buf[0];
 938                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 939                 break;
 940         case LogitechTraveler:
 941         case LogitechClickSmart510:
 942                 reg_w(gspca_dev, 0x02, 0x00, 0x00);
 943                 /* enable drop packet */
 944                 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 945
 946                 err = spca50x_setup_qtable(gspca_dev,
 947                                         0x00, 0x8800,
 948                                         0x8840, qtable_creative_pccam);
 949                 if (err < 0)
 950                         PDEBUG(D_ERR, "spca50x_setup_qtable failed");
 951                 reg_w(gspca_dev, 0x00, 0x8880, 3);
 952                 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
 953                 /* Init SDRAM - needed for SDRAM access */
 954                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 955
 956                 spca500_setmode(gspca_dev, xmult, ymult);
 957
 958                 /* switch to video camera mode */
 959                 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 960                 reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
 961
 962                 reg_r(gspca_dev, 0x816b, 1);
 963                 Data = gspca_dev->usb_buf[0];
 964                 reg_w(gspca_dev, 0x00, 0x816b, Data);
 965                 write_vector(gspca_dev, Clicksmart510_defaults);
 966                 break;
 967         }
 968 }
 969
 970 static void sd_stopN(struct gspca_dev *gspca_dev)
 971 {
 972         reg_w(gspca_dev, 0, 0x8003, 0x00);
 973
 974         /* switch to video camera mode */
 975         reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 976         reg_r(gspca_dev, 0x8000, 1);
 977         PDEBUG(D_STREAM, "stop SPCA500 done reg8000: 0x%2x",
 978                 gspca_dev->usb_buf[0]);
 979 }
 980
 981 static void sd_stop0(struct gspca_dev *gspca_dev)
 982 {
 983 }
 984
 985 static void sd_close(struct gspca_dev *gspca_dev)
 986 {
 987 }
 988
 989 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 990                         struct gspca_frame *frame,      /* target */
 991                         __u8 *data,                     /* isoc packet */
 992                         int len)                        /* iso packet length */
 993 {
 994         struct sd *sd = (struct sd *) gspca_dev;
 995         int i;
 996         __u8 *s, *d;
 997         static __u8 ffd9[] = {0xff, 0xd9};
 998
 999 /* frames are jpeg 4.1.1 without 0xff escape */
1000         if (data[0] == 0xff) {
1001                 if (data[1] != 0x01) {  /* drop packet */
1002 /*                      gspca_dev->last_packet_type = DISCARD_PACKET; */
1003                         return;
1004                 }
1005                 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
1006                                         ffd9, 2);
1007
1008                 /* put the JPEG header in the new frame */
1009                 jpeg_put_header(gspca_dev, frame, sd->qindex, 0x22);
1010
1011                 data += SPCA500_OFFSET_DATA;
1012                 len -= SPCA500_OFFSET_DATA;
1013         } else {
1014                 data += 1;
1015                 len -= 1;
1016         }
1017
1018         /* add 0x00 after 0xff */
1019         for (i = len; --i >= 0; )
1020                 if (data[i] == 0xff)
1021                         break;
1022         if (i < 0) {                    /* no 0xff */
1023                 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
1024                 return;
1025         }
1026         s = data;
1027         d = sd->packet;
1028         for (i = 0; i < len; i++) {
1029                 *d++ = *s++;
1030                 if (s[-1] == 0xff)
1031                         *d++ = 0x00;
1032         }
1033         gspca_frame_add(gspca_dev, INTER_PACKET, frame,
1034                         sd->packet, d - sd->packet);
1035 }
1036
1037 static void setbrightness(struct gspca_dev *gspca_dev)
1038 {
1039         struct sd *sd = (struct sd *) gspca_dev;
1040
1041         reg_w(gspca_dev, 0x00, 0x8167,
1042                         (__u8) (sd->brightness - 128));
1043 }
1044
1045 static void getbrightness(struct gspca_dev *gspca_dev)
1046 {
1047         struct sd *sd = (struct sd *) gspca_dev;
1048         int ret;
1049
1050         ret = reg_r_12(gspca_dev, 0x00, 0x8167, 1);
1051         if (ret >= 0)
1052                 sd->brightness = ret + 128;
1053 }
1054
1055 static void setcontrast(struct gspca_dev *gspca_dev)
1056 {
1057         struct sd *sd = (struct sd *) gspca_dev;
1058
1059         reg_w(gspca_dev, 0x00, 0x8168, sd->contrast);
1060 }
1061
1062 static void getcontrast(struct gspca_dev *gspca_dev)
1063 {
1064         struct sd *sd = (struct sd *) gspca_dev;
1065         int ret;
1066
1067         ret = reg_r_12(gspca_dev, 0x0, 0x8168, 1);
1068         if (ret >= 0)
1069                 sd->contrast = ret;
1070 }
1071
1072 static void setcolors(struct gspca_dev *gspca_dev)
1073 {
1074         struct sd *sd = (struct sd *) gspca_dev;
1075
1076         reg_w(gspca_dev, 0x00, 0x8169, sd->colors);
1077 }
1078
1079 static void getcolors(struct gspca_dev *gspca_dev)
1080 {
1081         struct sd *sd = (struct sd *) gspca_dev;
1082         int ret;
1083
1084         ret = reg_r_12(gspca_dev, 0x0, 0x8169, 1);
1085         if (ret >= 0)
1086                 sd->colors = ret;
1087 }
1088
1089 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1090 {
1091         struct sd *sd = (struct sd *) gspca_dev;
1092
1093         sd->brightness = val;
1094         if (gspca_dev->streaming)
1095                 setbrightness(gspca_dev);
1096         return 0;
1097 }
1098
1099 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1100 {
1101         struct sd *sd = (struct sd *) gspca_dev;
1102
1103         getbrightness(gspca_dev);
1104         *val = sd->brightness;
1105         return 0;
1106 }
1107
1108 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1109 {
1110         struct sd *sd = (struct sd *) gspca_dev;
1111
1112         sd->contrast = val;
1113         if (gspca_dev->streaming)
1114                 setcontrast(gspca_dev);
1115         return 0;
1116 }
1117
1118 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1119 {
1120         struct sd *sd = (struct sd *) gspca_dev;
1121
1122         getcontrast(gspca_dev);
1123         *val = sd->contrast;
1124         return 0;
1125 }
1126
1127 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1128 {
1129         struct sd *sd = (struct sd *) gspca_dev;
1130
1131         sd->colors = val;
1132         if (gspca_dev->streaming)
1133                 setcolors(gspca_dev);
1134         return 0;
1135 }
1136
1137 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1138 {
1139         struct sd *sd = (struct sd *) gspca_dev;
1140
1141         getcolors(gspca_dev);
1142         *val = sd->colors;
1143         return 0;
1144 }
1145
1146 /* sub-driver description */
1147 static struct sd_desc sd_desc = {
1148         .name = MODULE_NAME,
1149         .ctrls = sd_ctrls,
1150         .nctrls = ARRAY_SIZE(sd_ctrls),
1151         .config = sd_config,
1152         .open = sd_open,
1153         .start = sd_start,
1154         .stopN = sd_stopN,
1155         .stop0 = sd_stop0,
1156         .close = sd_close,
1157         .pkt_scan = sd_pkt_scan,
1158 };
1159
1160 /* -- module initialisation -- */
1161 #define DVNM(name) .driver_info = (kernel_ulong_t) name
1162 static const __devinitdata struct usb_device_id device_table[] = {
1163         {USB_DEVICE(0x040a, 0x0300), DVNM("Kodak EZ200")},
1164         {USB_DEVICE(0x041e, 0x400a), DVNM("Creative PC-CAM 300")},
1165         {USB_DEVICE(0x046d, 0x0890), DVNM("Logitech QuickCam traveler")},
1166         {USB_DEVICE(0x046d, 0x0900), DVNM("Logitech Inc. ClickSmart 310")},
1167         {USB_DEVICE(0x046d, 0x0901), DVNM("Logitech Inc. ClickSmart 510")},
1168         {USB_DEVICE(0x04a5, 0x300c), DVNM("Benq DC1016")},
1169         {USB_DEVICE(0x04fc, 0x7333), DVNM("PalmPixDC85")},
1170         {USB_DEVICE(0x055f, 0xc200), DVNM("Mustek Gsmart 300")},
1171         {USB_DEVICE(0x055f, 0xc220), DVNM("Gsmart Mini")},
1172         {USB_DEVICE(0x06bd, 0x0404), DVNM("Agfa CL20")},
1173         {USB_DEVICE(0x06be, 0x0800), DVNM("Optimedia")},
1174         {USB_DEVICE(0x084d, 0x0003), DVNM("D-Link DSC-350")},
1175         {USB_DEVICE(0x08ca, 0x0103), DVNM("Aiptek PocketDV")},
1176         {USB_DEVICE(0x2899, 0x012c), DVNM("Toptro Industrial")},
1177         {USB_DEVICE(0x8086, 0x0630), DVNM("Intel Pocket PC Camera")},
1178         {}
1179 };
1180 MODULE_DEVICE_TABLE(usb, device_table);
1181
1182 /* -- device connect -- */
1183 static int sd_probe(struct usb_interface *intf,
1184                         const struct usb_device_id *id)
1185 {
1186         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1187                                 THIS_MODULE);
1188 }
1189
1190 static struct usb_driver sd_driver = {
1191         .name = MODULE_NAME,
1192         .id_table = device_table,
1193         .probe = sd_probe,
1194         .disconnect = gspca_disconnect,
1195 };
1196
1197 /* -- module insert / remove -- */
1198 static int __init sd_mod_init(void)
1199 {
1200         if (usb_register(&sd_driver) < 0)
1201                 return -1;
1202         PDEBUG(D_PROBE, "registered");
1203         return 0;
1204 }
1205 static void __exit sd_mod_exit(void)
1206 {
1207         usb_deregister(&sd_driver);
1208         PDEBUG(D_PROBE, "deregistered");
1209 }
1210
1211 module_init(sd_mod_init);
1212 module_exit(sd_mod_exit);