SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/gspca/sunplus.c

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