drivers/media/video/gspca/t613.c

   1 /*
   2  * T613 subdriver
   3  *
   4  * Copyright (C) 2010 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  *Notes: * t613  + tas5130A
  21  *      * Focus to light do not balance well as in win.
  22  *        Quality in win is not good, but its kinda better.
  23  *       * Fix some "extraneous bytes", most of apps will show the image anyway
  24  *       * Gamma table, is there, but its really doing something?
  25  *       * 7~8 Fps, its ok, max on win its 10.
  26  *                      Costantino Leandro
  27  */
  28
  29 #define MODULE_NAME "t613"
  30
  31 #include "gspca.h"
  32
  33 #define V4L2_CID_EFFECTS (V4L2_CID_PRIVATE_BASE + 0)
  34
  35 MODULE_AUTHOR("Leandro Costantino <le_costantino@pixartargentina.com.ar>");
  36 MODULE_DESCRIPTION("GSPCA/T613 (JPEG Compliance) USB Camera Driver");
  37 MODULE_LICENSE("GPL");
  38
  39 struct sd {
  40         struct gspca_dev gspca_dev;     /* !! must be the first item */
  41
  42         u8 brightness;
  43         u8 contrast;
  44         u8 colors;
  45         u8 autogain;
  46         u8 gamma;
  47         u8 sharpness;
  48         u8 freq;
  49         u8 red_balance; /* split balance */
  50         u8 blue_balance;
  51         u8 global_gain; /* aka gain */
  52         u8 awb; /* set default r/g/b and activate */
  53         u8 mirror;
  54         u8 effect;
  55
  56         u8 sensor;
  57 enum {
  58         SENSOR_OM6802,
  59         SENSOR_OTHER,
  60         SENSOR_TAS5130A,
  61         SENSOR_LT168G,          /* must verify if this is the actual model */
  62 } sensors;
  63 };
  64
  65 /* V4L2 controls supported by the driver */
  66 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  67 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  68 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  69 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  70 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
  71 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
  72 static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val);
  73 static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val);
  74 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
  75 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
  76 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
  77 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
  78 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
  79 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
  80
  81 static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val);
  82 static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val);
  83 static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val);
  84 static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val);
  85 static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val);
  86 static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val);
  87 static int sd_setglobal_gain(struct gspca_dev *gspca_dev, __s32 val);
  88 static int sd_getglobal_gain(struct gspca_dev *gspca_dev, __s32 *val);
  89
  90 static int sd_setmirror(struct gspca_dev *gspca_dev, __s32 val);
  91 static int sd_getmirror(struct gspca_dev *gspca_dev, __s32 *val);
  92 static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val);
  93 static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val);
  94 static int sd_querymenu(struct gspca_dev *gspca_dev,
  95                         struct v4l2_querymenu *menu);
  96
  97 static const struct ctrl sd_ctrls[] = {
  98         {
  99          {
 100           .id = V4L2_CID_BRIGHTNESS,
 101           .type = V4L2_CTRL_TYPE_INTEGER,
 102           .name = "Brightness",
 103           .minimum = 0,
 104           .maximum = 14,
 105           .step = 1,
 106 #define BRIGHTNESS_DEF 8
 107           .default_value = BRIGHTNESS_DEF,
 108           },
 109          .set = sd_setbrightness,
 110          .get = sd_getbrightness,
 111          },
 112         {
 113          {
 114           .id = V4L2_CID_CONTRAST,
 115           .type = V4L2_CTRL_TYPE_INTEGER,
 116           .name = "Contrast",
 117           .minimum = 0,
 118           .maximum = 0x0d,
 119           .step = 1,
 120 #define CONTRAST_DEF 0x07
 121           .default_value = CONTRAST_DEF,
 122           },
 123          .set = sd_setcontrast,
 124          .get = sd_getcontrast,
 125          },
 126         {
 127          {
 128           .id = V4L2_CID_SATURATION,
 129           .type = V4L2_CTRL_TYPE_INTEGER,
 130           .name = "Color",
 131           .minimum = 0,
 132           .maximum = 0x0f,
 133           .step = 1,
 134 #define COLORS_DEF 0x05
 135           .default_value = COLORS_DEF,
 136           },
 137          .set = sd_setcolors,
 138          .get = sd_getcolors,
 139          },
 140 #define GAMMA_MAX 16
 141 #define GAMMA_DEF 10
 142         {
 143          {
 144           .id = V4L2_CID_GAMMA, /* (gamma on win) */
 145           .type = V4L2_CTRL_TYPE_INTEGER,
 146           .name = "Gamma",
 147           .minimum = 0,
 148           .maximum = GAMMA_MAX - 1,
 149           .step = 1,
 150           .default_value = GAMMA_DEF,
 151           },
 152          .set = sd_setgamma,
 153          .get = sd_getgamma,
 154          },
 155         {
 156          {
 157           .id = V4L2_CID_BACKLIGHT_COMPENSATION, /* Activa lowlight,
 158                                  * some apps dont bring up the
 159                                  * backligth_compensation control) */
 160           .type = V4L2_CTRL_TYPE_INTEGER,
 161           .name = "Low Light",
 162           .minimum = 0,
 163           .maximum = 1,
 164           .step = 1,
 165 #define AUTOGAIN_DEF 0x01
 166           .default_value = AUTOGAIN_DEF,
 167           },
 168          .set = sd_setlowlight,
 169          .get = sd_getlowlight,
 170          },
 171         {
 172          {
 173           .id = V4L2_CID_HFLIP,
 174           .type = V4L2_CTRL_TYPE_BOOLEAN,
 175           .name = "Mirror Image",
 176           .minimum = 0,
 177           .maximum = 1,
 178           .step = 1,
 179 #define MIRROR_DEF 0
 180           .default_value = MIRROR_DEF,
 181           },
 182          .set = sd_setmirror,
 183          .get = sd_getmirror
 184         },
 185         {
 186          {
 187           .id = V4L2_CID_POWER_LINE_FREQUENCY,
 188           .type = V4L2_CTRL_TYPE_MENU,
 189           .name = "Light Frequency Filter",
 190           .minimum = 1,         /* 1 -> 0x50, 2->0x60 */
 191           .maximum = 2,
 192           .step = 1,
 193 #define FREQ_DEF 1
 194           .default_value = FREQ_DEF,
 195           },
 196          .set = sd_setfreq,
 197          .get = sd_getfreq},
 198
 199         {
 200          {
 201           .id =  V4L2_CID_AUTO_WHITE_BALANCE,
 202           .type = V4L2_CTRL_TYPE_INTEGER,
 203           .name = "Auto White Balance",
 204           .minimum = 0,
 205           .maximum = 1,
 206           .step = 1,
 207 #define AWB_DEF 0
 208           .default_value = AWB_DEF,
 209           },
 210          .set = sd_setawb,
 211          .get = sd_getawb
 212         },
 213         {
 214          {
 215           .id = V4L2_CID_SHARPNESS,
 216           .type = V4L2_CTRL_TYPE_INTEGER,
 217           .name = "Sharpness",
 218           .minimum = 0,
 219           .maximum = 15,
 220           .step = 1,
 221 #define SHARPNESS_DEF 0x06
 222           .default_value = SHARPNESS_DEF,
 223           },
 224          .set = sd_setsharpness,
 225          .get = sd_getsharpness,
 226          },
 227         {
 228          {
 229           .id = V4L2_CID_EFFECTS,
 230           .type = V4L2_CTRL_TYPE_MENU,
 231           .name = "Webcam Effects",
 232           .minimum = 0,
 233           .maximum = 4,
 234           .step = 1,
 235 #define EFFECTS_DEF 0
 236           .default_value = EFFECTS_DEF,
 237           },
 238          .set = sd_seteffect,
 239          .get = sd_geteffect
 240         },
 241         {
 242          {
 243             .id      = V4L2_CID_BLUE_BALANCE,
 244             .type    = V4L2_CTRL_TYPE_INTEGER,
 245             .name    = "Blue Balance",
 246             .minimum = 0x10,
 247             .maximum = 0x40,
 248             .step    = 1,
 249 #define BLUE_BALANCE_DEF 0x20
 250             .default_value = BLUE_BALANCE_DEF,
 251          },
 252         .set = sd_setblue_balance,
 253         .get = sd_getblue_balance,
 254         },
 255         {
 256          {
 257             .id      = V4L2_CID_RED_BALANCE,
 258             .type    = V4L2_CTRL_TYPE_INTEGER,
 259             .name    = "Red Balance",
 260             .minimum = 0x10,
 261             .maximum = 0x40,
 262             .step    = 1,
 263 #define RED_BALANCE_DEF 0x20
 264             .default_value = RED_BALANCE_DEF,
 265          },
 266         .set = sd_setred_balance,
 267         .get = sd_getred_balance,
 268         },
 269         {
 270          {
 271             .id      = V4L2_CID_GAIN,
 272             .type    = V4L2_CTRL_TYPE_INTEGER,
 273             .name    = "Gain",
 274             .minimum = 0x10,
 275             .maximum = 0x40,
 276             .step    = 1,
 277 #define global_gain_DEF  0x20
 278             .default_value = global_gain_DEF,
 279          },
 280         .set = sd_setglobal_gain,
 281         .get = sd_getglobal_gain,
 282         },
 283 };
 284
 285 static const struct v4l2_pix_format vga_mode_t16[] = {
 286         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 287                 .bytesperline = 160,
 288                 .sizeimage = 160 * 120 * 4 / 8 + 590,
 289                 .colorspace = V4L2_COLORSPACE_JPEG,
 290                 .priv = 4},
 291         {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 292                 .bytesperline = 176,
 293                 .sizeimage = 176 * 144 * 3 / 8 + 590,
 294                 .colorspace = V4L2_COLORSPACE_JPEG,
 295                 .priv = 3},
 296         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 297                 .bytesperline = 320,
 298                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 299                 .colorspace = V4L2_COLORSPACE_JPEG,
 300                 .priv = 2},
 301         {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 302                 .bytesperline = 352,
 303                 .sizeimage = 352 * 288 * 3 / 8 + 590,
 304                 .colorspace = V4L2_COLORSPACE_JPEG,
 305                 .priv = 1},
 306         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 307                 .bytesperline = 640,
 308                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 309                 .colorspace = V4L2_COLORSPACE_JPEG,
 310                 .priv = 0},
 311 };
 312
 313 /* sensor specific data */
 314 struct additional_sensor_data {
 315         const u8 n3[6];
 316         const u8 *n4, n4sz;
 317         const u8 reg80, reg8e;
 318         const u8 nset8[6];
 319         const u8 data1[10];
 320         const u8 data2[9];
 321         const u8 data3[9];
 322         const u8 data5[6];
 323         const u8 stream[4];
 324 };
 325
 326 static const u8 n4_om6802[] = {
 327         0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c,
 328         0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68,
 329         0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1,
 330         0xa2, 0x60, 0xa5, 0x30, 0xa6, 0x3a, 0xa8, 0xe8,
 331         0xae, 0x05, 0xb1, 0x00, 0xbb, 0x04, 0xbc, 0x48,
 332         0xbe, 0x36, 0xc6, 0x88, 0xe9, 0x00, 0xc5, 0xc0,
 333         0x65, 0x0a, 0xbb, 0x86, 0xaf, 0x58, 0xb0, 0x68,
 334         0x87, 0x40, 0x89, 0x2b, 0x8d, 0xff, 0x83, 0x40,
 335         0xac, 0x84, 0xad, 0x86, 0xaf, 0x46
 336 };
 337 static const u8 n4_other[] = {
 338         0x66, 0x00, 0x7f, 0x00, 0x80, 0xac, 0x81, 0x69,
 339         0x84, 0x40, 0x85, 0x70, 0x86, 0x20, 0x8a, 0x68,
 340         0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xff, 0x8e, 0xb8,
 341         0x8f, 0x28, 0xa2, 0x60, 0xa5, 0x40, 0xa8, 0xa8,
 342         0xac, 0x84, 0xad, 0x84, 0xae, 0x24, 0xaf, 0x56,
 343         0xb0, 0x68, 0xb1, 0x00, 0xb2, 0x88, 0xbb, 0xc5,
 344         0xbc, 0x4a, 0xbe, 0x36, 0xc2, 0x88, 0xc5, 0xc0,
 345         0xc6, 0xda, 0xe9, 0x26, 0xeb, 0x00
 346 };
 347 static const u8 n4_tas5130a[] = {
 348         0x80, 0x3c, 0x81, 0x68, 0x83, 0xa0, 0x84, 0x20,
 349         0x8a, 0x68, 0x8b, 0x58, 0x8c, 0x88, 0x8e, 0xb4,
 350         0x8f, 0x24, 0xa1, 0xb1, 0xa2, 0x30, 0xa5, 0x10,
 351         0xa6, 0x4a, 0xae, 0x03, 0xb1, 0x44, 0xb2, 0x08,
 352         0xb7, 0x06, 0xb9, 0xe7, 0xbb, 0xc4, 0xbc, 0x4a,
 353         0xbe, 0x36, 0xbf, 0xff, 0xc2, 0x88, 0xc5, 0xc8,
 354         0xc6, 0xda
 355 };
 356 static const u8 n4_lt168g[] = {
 357         0x66, 0x01, 0x7f, 0x00, 0x80, 0x7c, 0x81, 0x28,
 358         0x83, 0x44, 0x84, 0x20, 0x86, 0x20, 0x8a, 0x70,
 359         0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xa0, 0x8e, 0xb3,
 360         0x8f, 0x24, 0xa1, 0xb0, 0xa2, 0x38, 0xa5, 0x20,
 361         0xa6, 0x4a, 0xa8, 0xe8, 0xaf, 0x38, 0xb0, 0x68,
 362         0xb1, 0x44, 0xb2, 0x88, 0xbb, 0x86, 0xbd, 0x40,
 363         0xbe, 0x26, 0xc1, 0x05, 0xc2, 0x88, 0xc5, 0xc0,
 364         0xda, 0x8e, 0xdb, 0xca, 0xdc, 0xa8, 0xdd, 0x8c,
 365         0xde, 0x44, 0xdf, 0x0c, 0xe9, 0x80
 366 };
 367
 368 static const struct additional_sensor_data sensor_data[] = {
 369 [SENSOR_OM6802] = {
 370         .n3 =
 371                 {0x61, 0x68, 0x65, 0x0a, 0x60, 0x04},
 372         .n4 = n4_om6802,
 373         .n4sz = sizeof n4_om6802,
 374         .reg80 = 0x3c,
 375         .reg8e = 0x33,
 376         .nset8 = {0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00},
 377         .data1 =
 378                 {0xc2, 0x28, 0x0f, 0x22, 0xcd, 0x27, 0x2c, 0x06,
 379                  0xb3, 0xfc},
 380         .data2 =
 381                 {0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff,
 382                  0xff},
 383         .data3 =
 384                 {0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff,
 385                  0xff},
 386         .data5 =        /* this could be removed later */
 387                 {0x0c, 0x03, 0xab, 0x13, 0x81, 0x23},
 388         .stream =
 389                 {0x0b, 0x04, 0x0a, 0x78},
 390     },
 391 [SENSOR_OTHER] = {
 392         .n3 =
 393                 {0x61, 0xc2, 0x65, 0x88, 0x60, 0x00},
 394         .n4 = n4_other,
 395         .n4sz = sizeof n4_other,
 396         .reg80 = 0xac,
 397         .reg8e = 0xb8,
 398         .nset8 = {0xa8, 0xa8, 0xc6, 0xda, 0xc0, 0x00},
 399         .data1 =
 400                 {0xc1, 0x48, 0x04, 0x1b, 0xca, 0x2e, 0x33, 0x3a,
 401                  0xe8, 0xfc},
 402         .data2 =
 403                 {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96,
 404                  0xd9},
 405         .data3 =
 406                 {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96,
 407                  0xd9},
 408         .data5 =
 409                 {0x0c, 0x03, 0xab, 0x29, 0x81, 0x69},
 410         .stream =
 411                 {0x0b, 0x04, 0x0a, 0x00},
 412     },
 413 [SENSOR_TAS5130A] = {
 414         .n3 =
 415                 {0x61, 0xc2, 0x65, 0x0d, 0x60, 0x08},
 416         .n4 = n4_tas5130a,
 417         .n4sz = sizeof n4_tas5130a,
 418         .reg80 = 0x3c,
 419         .reg8e = 0xb4,
 420         .nset8 = {0xa8, 0xf0, 0xc6, 0xda, 0xc0, 0x00},
 421         .data1 =
 422                 {0xbb, 0x28, 0x10, 0x10, 0xbb, 0x28, 0x1e, 0x27,
 423                  0xc8, 0xfc},
 424         .data2 =
 425                 {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8,
 426                  0xe0},
 427         .data3 =
 428                 {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8,
 429                  0xe0},
 430         .data5 =
 431                 {0x0c, 0x03, 0xab, 0x10, 0x81, 0x20},
 432         .stream =
 433                 {0x0b, 0x04, 0x0a, 0x40},
 434     },
 435 [SENSOR_LT168G] = {
 436         .n3 = {0x61, 0xc2, 0x65, 0x68, 0x60, 0x00},
 437         .n4 = n4_lt168g,
 438         .n4sz = sizeof n4_lt168g,
 439         .reg80 = 0x7c,
 440         .reg8e = 0xb3,
 441         .nset8 = {0xa8, 0xf0, 0xc6, 0xba, 0xc0, 0x00},
 442         .data1 = {0xc0, 0x38, 0x08, 0x10, 0xc0, 0x30, 0x10, 0x40,
 443                  0xb0, 0xf4},
 444         .data2 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6,
 445                  0xff},
 446         .data3 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6,
 447                  0xff},
 448         .data5 = {0x0c, 0x03, 0xab, 0x4b, 0x81, 0x2b},
 449         .stream = {0x0b, 0x04, 0x0a, 0x28},
 450     },
 451 };
 452
 453 #define MAX_EFFECTS 7
 454 /* easily done by soft, this table could be removed,
 455  * i keep it here just in case */
 456 static char *effects_control[MAX_EFFECTS] = {
 457         "Normal",
 458         "Emboss",               /* disabled */
 459         "Monochrome",
 460         "Sepia",
 461         "Sketch",
 462         "Sun Effect",           /* disabled */
 463         "Negative",
 464 };
 465 static const u8 effects_table[MAX_EFFECTS][6] = {
 466         {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x00},   /* Normal */
 467         {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x04},   /* Repujar */
 468         {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x20},   /* Monochrome */
 469         {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x80},   /* Sepia */
 470         {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x02},   /* Croquis */
 471         {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x10},   /* Sun Effect */
 472         {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x40},   /* Negative */
 473 };
 474
 475 static const u8 gamma_table[GAMMA_MAX][17] = {
 476         {0x00, 0x3e, 0x69, 0x85, 0x95, 0xa1, 0xae, 0xb9,        /* 0 */
 477          0xc2, 0xcb, 0xd4, 0xdb, 0xe3, 0xea, 0xf1, 0xf8,
 478          0xff},
 479         {0x00, 0x33, 0x5a, 0x75, 0x85, 0x93, 0xa1, 0xad,        /* 1 */
 480          0xb7, 0xc2, 0xcb, 0xd4, 0xde, 0xe7, 0xf0, 0xf7,
 481          0xff},
 482         {0x00, 0x2f, 0x51, 0x6b, 0x7c, 0x8a, 0x99, 0xa6,        /* 2 */
 483          0xb1, 0xbc, 0xc6, 0xd0, 0xdb, 0xe4, 0xed, 0xf6,
 484          0xff},
 485         {0x00, 0x29, 0x48, 0x60, 0x72, 0x81, 0x90, 0x9e,        /* 3 */
 486          0xaa, 0xb5, 0xbf, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5,
 487          0xff},
 488         {0x00, 0x23, 0x3f, 0x55, 0x68, 0x77, 0x86, 0x95,        /* 4 */
 489          0xa2, 0xad, 0xb9, 0xc6, 0xd2, 0xde, 0xe9, 0xf4,
 490          0xff},
 491         {0x00, 0x1b, 0x33, 0x48, 0x59, 0x69, 0x79, 0x87,        /* 5 */
 492          0x96, 0xa3, 0xb1, 0xbe, 0xcc, 0xda, 0xe7, 0xf3,
 493          0xff},
 494         {0x00, 0x02, 0x10, 0x20, 0x32, 0x40, 0x57, 0x67,        /* 6 */
 495          0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee,
 496          0xff},
 497         {0x00, 0x02, 0x14, 0x26, 0x38, 0x4a, 0x60, 0x70,        /* 7 */
 498          0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
 499          0xff},
 500         {0x00, 0x10, 0x22, 0x35, 0x47, 0x5a, 0x69, 0x79,        /* 8 */
 501          0x88, 0x97, 0xa7, 0xb6, 0xc4, 0xd3, 0xe0, 0xf0,
 502          0xff},
 503         {0x00, 0x10, 0x26, 0x40, 0x54, 0x65, 0x75, 0x84,        /* 9 */
 504          0x93, 0xa1, 0xb0, 0xbd, 0xca, 0xd6, 0xe0, 0xf0,
 505          0xff},
 506         {0x00, 0x18, 0x2b, 0x44, 0x60, 0x70, 0x80, 0x8e,        /* 10 */
 507          0x9c, 0xaa, 0xb7, 0xc4, 0xd0, 0xd8, 0xe2, 0xf0,
 508          0xff},
 509         {0x00, 0x1a, 0x34, 0x52, 0x66, 0x7e, 0x8d, 0x9b,        /* 11 */
 510          0xa8, 0xb4, 0xc0, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5,
 511          0xff},
 512         {0x00, 0x3f, 0x5a, 0x6e, 0x7f, 0x8e, 0x9c, 0xa8,        /* 12 */
 513          0xb4, 0xbf, 0xc9, 0xd3, 0xdc, 0xe5, 0xee, 0xf6,
 514          0xff},
 515         {0x00, 0x54, 0x6f, 0x83, 0x93, 0xa0, 0xad, 0xb7,        /* 13 */
 516          0xc2, 0xcb, 0xd4, 0xdc, 0xe4, 0xeb, 0xf2, 0xf9,
 517          0xff},
 518         {0x00, 0x6e, 0x88, 0x9a, 0xa8, 0xb3, 0xbd, 0xc6,        /* 14 */
 519          0xcf, 0xd6, 0xdd, 0xe3, 0xe9, 0xef, 0xf4, 0xfa,
 520          0xff},
 521         {0x00, 0x93, 0xa8, 0xb7, 0xc1, 0xca, 0xd2, 0xd8,        /* 15 */
 522          0xde, 0xe3, 0xe8, 0xed, 0xf1, 0xf5, 0xf8, 0xfc,
 523          0xff}
 524 };
 525
 526 static const u8 tas5130a_sensor_init[][8] = {
 527         {0x62, 0x08, 0x63, 0x70, 0x64, 0x1d, 0x60, 0x09},
 528         {0x62, 0x20, 0x63, 0x01, 0x64, 0x02, 0x60, 0x09},
 529         {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
 530 };
 531
 532 static u8 sensor_reset[] = {0x61, 0x68, 0x62, 0xff, 0x60, 0x07};
 533
 534 /* read 1 byte */
 535 static u8 reg_r(struct gspca_dev *gspca_dev,
 536                    u16 index)
 537 {
 538         usb_control_msg(gspca_dev->dev,
 539                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 540                         0,              /* request */
 541                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 542                         0,              /* value */
 543                         index,
 544                         gspca_dev->usb_buf, 1, 500);
 545         return gspca_dev->usb_buf[0];
 546 }
 547
 548 static void reg_w(struct gspca_dev *gspca_dev,
 549                   u16 index)
 550 {
 551         usb_control_msg(gspca_dev->dev,
 552                         usb_sndctrlpipe(gspca_dev->dev, 0),
 553                         0,
 554                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 555                         0, index,
 556                         NULL, 0, 500);
 557 }
 558
 559 static void reg_w_buf(struct gspca_dev *gspca_dev,
 560                   const u8 *buffer, u16 len)
 561 {
 562         if (len <= USB_BUF_SZ) {
 563                 memcpy(gspca_dev->usb_buf, buffer, len);
 564                 usb_control_msg(gspca_dev->dev,
 565                                 usb_sndctrlpipe(gspca_dev->dev, 0),
 566                                 0,
 567                            USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 568                                 0x01, 0,
 569                                 gspca_dev->usb_buf, len, 500);
 570         } else {
 571                 u8 *tmpbuf;
 572
 573                 tmpbuf = kmalloc(len, GFP_KERNEL);
 574                 if (!tmpbuf) {
 575                         err("Out of memory");
 576                         return;
 577                 }
 578                 memcpy(tmpbuf, buffer, len);
 579                 usb_control_msg(gspca_dev->dev,
 580                                 usb_sndctrlpipe(gspca_dev->dev, 0),
 581                                 0,
 582                            USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 583                                 0x01, 0,
 584                                 tmpbuf, len, 500);
 585                 kfree(tmpbuf);
 586         }
 587 }
 588
 589 /* write values to consecutive registers */
 590 static void reg_w_ixbuf(struct gspca_dev *gspca_dev,
 591                         u8 reg,
 592                         const u8 *buffer, u16 len)
 593 {
 594         int i;
 595         u8 *p, *tmpbuf;
 596
 597         if (len * 2 <= USB_BUF_SZ) {
 598                 p = tmpbuf = gspca_dev->usb_buf;
 599         } else {
 600                 p = tmpbuf = kmalloc(len * 2, GFP_KERNEL);
 601                 if (!tmpbuf) {
 602                         err("Out of memory");
 603                         return;
 604                 }
 605         }
 606         i = len;
 607         while (--i >= 0) {
 608                 *p++ = reg++;
 609                 *p++ = *buffer++;
 610         }
 611         usb_control_msg(gspca_dev->dev,
 612                         usb_sndctrlpipe(gspca_dev->dev, 0),
 613                         0,
 614                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 615                         0x01, 0,
 616                         tmpbuf, len * 2, 500);
 617         if (len * 2 > USB_BUF_SZ)
 618                 kfree(tmpbuf);
 619 }
 620
 621 static void om6802_sensor_init(struct gspca_dev *gspca_dev)
 622 {
 623         int i;
 624         const u8 *p;
 625         u8 byte;
 626         u8 val[6] = {0x62, 0, 0x64, 0, 0x60, 0x05};
 627         static const u8 sensor_init[] = {
 628                 0xdf, 0x6d,
 629                 0xdd, 0x18,
 630                 0x5a, 0xe0,
 631                 0x5c, 0x07,
 632                 0x5d, 0xb0,
 633                 0x5e, 0x1e,
 634                 0x60, 0x71,
 635                 0xef, 0x00,
 636                 0xe9, 0x00,
 637                 0xea, 0x00,
 638                 0x90, 0x24,
 639                 0x91, 0xb2,
 640                 0x82, 0x32,
 641                 0xfd, 0x41,
 642                 0x00                    /* table end */
 643         };
 644
 645         reg_w_buf(gspca_dev, sensor_reset, sizeof sensor_reset);
 646         msleep(100);
 647         i = 4;
 648         while (--i > 0) {
 649                 byte = reg_r(gspca_dev, 0x0060);
 650                 if (!(byte & 0x01))
 651                         break;
 652                 msleep(100);
 653         }
 654         byte = reg_r(gspca_dev, 0x0063);
 655         if (byte != 0x17) {
 656                 err("Bad sensor reset %02x", byte);
 657                 /* continue? */
 658         }
 659
 660         p = sensor_init;
 661         while (*p != 0) {
 662                 val[1] = *p++;
 663                 val[3] = *p++;
 664                 if (*p == 0)
 665                         reg_w(gspca_dev, 0x3c80);
 666                 reg_w_buf(gspca_dev, val, sizeof val);
 667                 i = 4;
 668                 while (--i >= 0) {
 669                         msleep(15);
 670                         byte = reg_r(gspca_dev, 0x60);
 671                         if (!(byte & 0x01))
 672                                 break;
 673                 }
 674         }
 675         msleep(15);
 676         reg_w(gspca_dev, 0x3c80);
 677 }
 678
 679 /* this function is called at probe time */
 680 static int sd_config(struct gspca_dev *gspca_dev,
 681                      const struct usb_device_id *id)
 682 {
 683         struct sd *sd = (struct sd *) gspca_dev;
 684         struct cam *cam;
 685
 686         cam = &gspca_dev->cam;
 687
 688         cam->cam_mode = vga_mode_t16;
 689         cam->nmodes = ARRAY_SIZE(vga_mode_t16);
 690
 691         sd->brightness = BRIGHTNESS_DEF;
 692         sd->contrast = CONTRAST_DEF;
 693         sd->colors = COLORS_DEF;
 694         sd->gamma = GAMMA_DEF;
 695         sd->autogain = AUTOGAIN_DEF;
 696         sd->mirror = MIRROR_DEF;
 697         sd->freq = FREQ_DEF;
 698         sd->awb = AWB_DEF;
 699         sd->sharpness = SHARPNESS_DEF;
 700         sd->effect = EFFECTS_DEF;
 701         sd->red_balance = RED_BALANCE_DEF;
 702         sd->blue_balance = BLUE_BALANCE_DEF;
 703         sd->global_gain = global_gain_DEF;
 704
 705         return 0;
 706 }
 707
 708 static void setbrightness(struct gspca_dev *gspca_dev)
 709 {
 710         struct sd *sd = (struct sd *) gspca_dev;
 711         unsigned int brightness;
 712         u8 set6[4] = { 0x8f, 0x24, 0xc3, 0x00 };
 713
 714         brightness = sd->brightness;
 715         if (brightness < 7) {
 716                 set6[1] = 0x26;
 717                 set6[3] = 0x70 - brightness * 0x10;
 718         } else {
 719                 set6[3] = 0x00 + ((brightness - 7) * 0x10);
 720         }
 721
 722         reg_w_buf(gspca_dev, set6, sizeof set6);
 723 }
 724
 725 static void setcontrast(struct gspca_dev *gspca_dev)
 726 {
 727         struct sd *sd = (struct sd *) gspca_dev;
 728         unsigned int contrast = sd->contrast;
 729         u16 reg_to_write;
 730
 731         if (contrast < 7)
 732                 reg_to_write = 0x8ea9 - contrast * 0x200;
 733         else
 734                 reg_to_write = 0x00a9 + (contrast - 7) * 0x200;
 735
 736         reg_w(gspca_dev, reg_to_write);
 737 }
 738
 739 static void setcolors(struct gspca_dev *gspca_dev)
 740 {
 741         struct sd *sd = (struct sd *) gspca_dev;
 742         u16 reg_to_write;
 743
 744         reg_to_write = 0x80bb + sd->colors * 0x100;     /* was 0xc0 */
 745         reg_w(gspca_dev, reg_to_write);
 746 }
 747
 748 static void setgamma(struct gspca_dev *gspca_dev)
 749 {
 750         struct sd *sd = (struct sd *) gspca_dev;
 751
 752         PDEBUG(D_CONF, "Gamma: %d", sd->gamma);
 753         reg_w_ixbuf(gspca_dev, 0x90,
 754                 gamma_table[sd->gamma], sizeof gamma_table[0]);
 755 }
 756 static void setglobalgain(struct gspca_dev *gspca_dev)
 757 {
 758
 759         struct sd *sd = (struct sd *) gspca_dev;
 760         reg_w(gspca_dev, (sd->red_balance  << 8) + 0x87);
 761         reg_w(gspca_dev, (sd->blue_balance << 8) + 0x88);
 762         reg_w(gspca_dev, (sd->global_gain  << 8) + 0x89);
 763 }
 764
 765 /* Generic fnc for r/b balance, exposure and whitebalance */
 766 static void setawb(struct gspca_dev *gspca_dev)
 767 {
 768         struct sd *sd = (struct sd *) gspca_dev;
 769
 770         /* on awb leave defaults values */
 771         if (sd->awb) {
 772                 reg_w(gspca_dev, 0x3c80);
 773         } else {
 774                 reg_w(gspca_dev, 0x3880);
 775                 /* shoud we wait here.. */
 776                 /* update and reset 'global gain' with webcam parameters */
 777                 sd->red_balance = reg_r(gspca_dev, 0x0087);
 778                 sd->blue_balance = reg_r(gspca_dev, 0x0088);
 779                 sd->global_gain = reg_r(gspca_dev, 0x0089);
 780                 setglobalgain(gspca_dev);
 781         }
 782
 783 }
 784
 785 static void setsharpness(struct gspca_dev *gspca_dev)
 786 {
 787         struct sd *sd = (struct sd *) gspca_dev;
 788         u16 reg_to_write;
 789
 790         reg_to_write = 0x0aa6 + 0x1000 * sd->sharpness;
 791
 792         reg_w(gspca_dev, reg_to_write);
 793 }
 794
 795 static void setfreq(struct gspca_dev *gspca_dev)
 796 {
 797         struct sd *sd = (struct sd *) gspca_dev;
 798         u8 reg66;
 799         u8 freq[4] = { 0x66, 0x00, 0xa8, 0xe8 };
 800
 801         switch (sd->sensor) {
 802         case SENSOR_LT168G:
 803                 if (sd->freq != 0)
 804                         freq[3] = 0xa8;
 805                 reg66 = 0x41;
 806                 break;
 807         case SENSOR_OM6802:
 808                 reg66 = 0xca;
 809                 break;
 810         default:
 811                 reg66 = 0x40;
 812                 break;
 813         }
 814         switch (sd->freq) {
 815         case 0:                         /* no flicker */
 816                 freq[3] = 0xf0;
 817                 break;
 818         case 2:                         /* 60Hz */
 819                 reg66 &= ~0x40;
 820                 break;
 821         }
 822         freq[1] = reg66;
 823
 824         reg_w_buf(gspca_dev, freq, sizeof freq);
 825 }
 826
 827 /* this function is called at probe and resume time */
 828 static int sd_init(struct gspca_dev *gspca_dev)
 829 {
 830         /* some of this registers are not really neded, because
 831          * they are overriden by setbrigthness, setcontrast, etc,
 832          * but wont hurt anyway, and can help someone with similar webcam
 833          * to see the initial parameters.*/
 834         struct sd *sd = (struct sd *) gspca_dev;
 835         const struct additional_sensor_data *sensor;
 836         int i;
 837         u16 sensor_id;
 838         u8 test_byte = 0;
 839
 840         static const u8 read_indexs[] =
 841                 { 0x0a, 0x0b, 0x66, 0x80, 0x81, 0x8e, 0x8f, 0xa5,
 842                   0xa6, 0xa8, 0xbb, 0xbc, 0xc6, 0x00 };
 843         static const u8 n1[] =
 844                         {0x08, 0x03, 0x09, 0x03, 0x12, 0x04};
 845         static const u8 n2[] =
 846                         {0x08, 0x00};
 847
 848         sensor_id = (reg_r(gspca_dev, 0x06) << 8)
 849                         | reg_r(gspca_dev, 0x07);
 850         switch (sensor_id & 0xff0f) {
 851         case 0x0801:
 852                 PDEBUG(D_PROBE, "sensor tas5130a");
 853                 sd->sensor = SENSOR_TAS5130A;
 854                 break;
 855         case 0x0802:
 856                 PDEBUG(D_PROBE, "sensor lt168g");
 857                 sd->sensor = SENSOR_LT168G;
 858                 break;
 859         case 0x0803:
 860                 PDEBUG(D_PROBE, "sensor 'other'");
 861                 sd->sensor = SENSOR_OTHER;
 862                 break;
 863         case 0x0807:
 864                 PDEBUG(D_PROBE, "sensor om6802");
 865                 sd->sensor = SENSOR_OM6802;
 866                 break;
 867         default:
 868                 PDEBUG(D_ERR|D_PROBE, "unknown sensor %04x", sensor_id);
 869                 return -EINVAL;
 870         }
 871
 872         if (sd->sensor == SENSOR_OM6802) {
 873                 reg_w_buf(gspca_dev, n1, sizeof n1);
 874                 i = 5;
 875                 while (--i >= 0) {
 876                         reg_w_buf(gspca_dev, sensor_reset, sizeof sensor_reset);
 877                         test_byte = reg_r(gspca_dev, 0x0063);
 878                         msleep(100);
 879                         if (test_byte == 0x17)
 880                                 break;          /* OK */
 881                 }
 882                 if (i < 0) {
 883                         err("Bad sensor reset %02x", test_byte);
 884                         return -EIO;
 885                 }
 886                 reg_w_buf(gspca_dev, n2, sizeof n2);
 887         }
 888
 889         i = 0;
 890         while (read_indexs[i] != 0x00) {
 891                 test_byte = reg_r(gspca_dev, read_indexs[i]);
 892                 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", read_indexs[i],
 893                        test_byte);
 894                 i++;
 895         }
 896
 897         sensor = &sensor_data[sd->sensor];
 898         reg_w_buf(gspca_dev, sensor->n3, sizeof sensor->n3);
 899         reg_w_buf(gspca_dev, sensor->n4, sensor->n4sz);
 900
 901         if (sd->sensor == SENSOR_LT168G) {
 902                 test_byte = reg_r(gspca_dev, 0x80);
 903                 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", 0x80,
 904                        test_byte);
 905                 reg_w(gspca_dev, 0x6c80);
 906         }
 907
 908         reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1);
 909         reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2);
 910         reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3);
 911
 912         reg_w(gspca_dev, (sensor->reg80 << 8) + 0x80);
 913         reg_w(gspca_dev, (sensor->reg80 << 8) + 0x80);
 914         reg_w(gspca_dev, (sensor->reg8e << 8) + 0x8e);
 915
 916         setbrightness(gspca_dev);
 917         setcontrast(gspca_dev);
 918         setgamma(gspca_dev);
 919         setcolors(gspca_dev);
 920         setsharpness(gspca_dev);
 921         setawb(gspca_dev);
 922         setfreq(gspca_dev);
 923
 924         reg_w(gspca_dev, 0x2087);       /* tied to white balance? */
 925         reg_w(gspca_dev, 0x2088);
 926         reg_w(gspca_dev, 0x2089);
 927
 928         reg_w_buf(gspca_dev, sensor->data4, sizeof sensor->data4);
 929         reg_w_buf(gspca_dev, sensor->data5, sizeof sensor->data5);
 930         reg_w_buf(gspca_dev, sensor->nset8, sizeof sensor->nset8);
 931         reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
 932
 933         if (sd->sensor == SENSOR_LT168G) {
 934                 test_byte = reg_r(gspca_dev, 0x80);
 935                 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", 0x80,
 936                        test_byte);
 937                 reg_w(gspca_dev, 0x6c80);
 938         }
 939
 940         reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1);
 941         reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2);
 942         reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3);
 943
 944         return 0;
 945 }
 946
 947 static void setmirror(struct gspca_dev *gspca_dev)
 948 {
 949         struct sd *sd = (struct sd *) gspca_dev;
 950         u8 hflipcmd[8] =
 951                 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09};
 952
 953         if (sd->mirror)
 954                 hflipcmd[3] = 0x01;
 955
 956         reg_w_buf(gspca_dev, hflipcmd, sizeof hflipcmd);
 957 }
 958
 959 static void seteffect(struct gspca_dev *gspca_dev)
 960 {
 961         struct sd *sd = (struct sd *) gspca_dev;
 962
 963         reg_w_buf(gspca_dev, effects_table[sd->effect],
 964                                 sizeof effects_table[0]);
 965         if (sd->effect == 1 || sd->effect == 5) {
 966                 PDEBUG(D_CONF,
 967                        "This effect have been disabled for webcam \"safety\"");
 968                 return;
 969         }
 970
 971         if (sd->effect == 1 || sd->effect == 4)
 972                 reg_w(gspca_dev, 0x4aa6);
 973         else
 974                 reg_w(gspca_dev, 0xfaa6);
 975 }
 976
 977 /* Is this really needed?
 978  * i added some module parameters for test with some users */
 979 static void poll_sensor(struct gspca_dev *gspca_dev)
 980 {
 981         static const u8 poll1[] =
 982                 {0x67, 0x05, 0x68, 0x81, 0x69, 0x80, 0x6a, 0x82,
 983                  0x6b, 0x68, 0x6c, 0x69, 0x72, 0xd9, 0x73, 0x34,
 984                  0x74, 0x32, 0x75, 0x92, 0x76, 0x00, 0x09, 0x01,
 985                  0x60, 0x14};
 986         static const u8 poll2[] =
 987                 {0x67, 0x02, 0x68, 0x71, 0x69, 0x72, 0x72, 0xa9,
 988                  0x73, 0x02, 0x73, 0x02, 0x60, 0x14};
 989         static const u8 poll3[] =
 990                 {0x87, 0x3f, 0x88, 0x20, 0x89, 0x2d};
 991         static const u8 poll4[] =
 992                 {0xa6, 0x0a, 0xea, 0xcf, 0xbe, 0x26, 0xb1, 0x5f,
 993                  0xa1, 0xb1, 0xda, 0x6b, 0xdb, 0x98, 0xdf, 0x0c,
 994                  0xc2, 0x80, 0xc3, 0x10};
 995
 996         PDEBUG(D_STREAM, "[Sensor requires polling]");
 997         reg_w_buf(gspca_dev, poll1, sizeof poll1);
 998         reg_w_buf(gspca_dev, poll2, sizeof poll2);
 999         reg_w_buf(gspca_dev, poll3, sizeof poll3);
1000         reg_w_buf(gspca_dev, poll4, sizeof poll4);
1001 }
1002
1003 static int sd_start(struct gspca_dev *gspca_dev)
1004 {
1005         struct sd *sd = (struct sd *) gspca_dev;
1006         const struct additional_sensor_data *sensor;
1007         int i, mode;
1008         u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };
1009         static const u8 t3[] =
1010                 { 0x07, 0x00, 0x88, 0x02, 0x06, 0x00, 0xe7, 0x01 };
1011
1012         mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
1013         switch (mode) {
1014         case 0:         /* 640x480 (0x00) */
1015                 break;
1016         case 1:         /* 352x288 */
1017                 t2[1] = 0x40;
1018                 break;
1019         case 2:         /* 320x240 */
1020                 t2[1] = 0x10;
1021                 break;
1022         case 3:         /* 176x144 */
1023                 t2[1] = 0x50;
1024                 break;
1025         default:
1026 /*      case 4:          * 160x120 */
1027                 t2[1] = 0x20;
1028                 break;
1029         }
1030
1031         switch (sd->sensor) {
1032         case SENSOR_OM6802:
1033                 om6802_sensor_init(gspca_dev);
1034                 break;
1035         case SENSOR_TAS5130A:
1036                 i = 0;
1037                 for (;;) {
1038                         reg_w_buf(gspca_dev, tas5130a_sensor_init[i],
1039                                          sizeof tas5130a_sensor_init[0]);
1040                         if (i >= ARRAY_SIZE(tas5130a_sensor_init) - 1)
1041                                 break;
1042                         i++;
1043                 }
1044                 reg_w(gspca_dev, 0x3c80);
1045                 /* just in case and to keep sync with logs (for mine) */
1046                 reg_w_buf(gspca_dev, tas5130a_sensor_init[i],
1047                                  sizeof tas5130a_sensor_init[0]);
1048                 reg_w(gspca_dev, 0x3c80);
1049                 break;
1050         }
1051         sensor = &sensor_data[sd->sensor];
1052         setfreq(gspca_dev);
1053         reg_r(gspca_dev, 0x0012);
1054         reg_w_buf(gspca_dev, t2, sizeof t2);
1055         reg_w_ixbuf(gspca_dev, 0xb3, t3, sizeof t3);
1056         reg_w(gspca_dev, 0x0013);
1057         msleep(15);
1058         reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
1059         reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
1060
1061         if (sd->sensor == SENSOR_OM6802)
1062                 poll_sensor(gspca_dev);
1063
1064         return 0;
1065 }
1066
1067 static void sd_stopN(struct gspca_dev *gspca_dev)
1068 {
1069         struct sd *sd = (struct sd *) gspca_dev;
1070
1071         reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
1072                         sizeof sensor_data[sd->sensor].stream);
1073         reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
1074                         sizeof sensor_data[sd->sensor].stream);
1075         if (sd->sensor == SENSOR_OM6802) {
1076                 msleep(20);
1077                 reg_w(gspca_dev, 0x0309);
1078         }
1079 }
1080
1081 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1082                         u8 *data,                       /* isoc packet */
1083                         int len)                        /* iso packet length */
1084 {
1085         static u8 ffd9[] = { 0xff, 0xd9 };
1086
1087         if (data[0] == 0x5a) {
1088                 /* Control Packet, after this came the header again,
1089                  * but extra bytes came in the packet before this,
1090                  * sometimes an EOF arrives, sometimes not... */
1091                 return;
1092         }
1093         data += 2;
1094         len -= 2;
1095         if (data[0] == 0xff && data[1] == 0xd8) {
1096                 /* extra bytes....., could be processed too but would be
1097                  * a waste of time, right now leave the application and
1098                  * libjpeg do it for ourserlves.. */
1099                 gspca_frame_add(gspca_dev, LAST_PACKET,
1100                                         ffd9, 2);
1101                 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
1102                 return;
1103         }
1104
1105         if (data[len - 2] == 0xff && data[len - 1] == 0xd9) {
1106                 /* Just in case, i have seen packets with the marker,
1107                  * other's do not include it... */
1108                 len -= 2;
1109         }
1110         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1111 }
1112
1113
1114 static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val)
1115 {
1116         struct sd *sd = (struct sd *) gspca_dev;
1117
1118         sd->blue_balance = val;
1119         if (gspca_dev->streaming)
1120                 reg_w(gspca_dev, (val << 8) + 0x88);
1121         return 0;
1122 }
1123
1124 static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val)
1125 {
1126         struct sd *sd = (struct sd *) gspca_dev;
1127
1128         *val = sd->blue_balance;
1129         return 0;
1130 }
1131
1132 static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val)
1133 {
1134         struct sd *sd = (struct sd *) gspca_dev;
1135
1136         sd->red_balance = val;
1137         if (gspca_dev->streaming)
1138                 reg_w(gspca_dev, (val << 8) + 0x87);
1139
1140         return 0;
1141 }
1142
1143 static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val)
1144 {
1145         struct sd *sd = (struct sd *) gspca_dev;
1146
1147         *val = sd->red_balance;
1148         return 0;
1149 }
1150
1151
1152
1153 static int sd_setglobal_gain(struct gspca_dev *gspca_dev, __s32 val)
1154 {
1155         struct sd *sd = (struct sd *) gspca_dev;
1156
1157         sd->global_gain = val;
1158         if (gspca_dev->streaming)
1159                 setglobalgain(gspca_dev);
1160
1161         return 0;
1162 }
1163
1164 static int sd_getglobal_gain(struct gspca_dev *gspca_dev, __s32 *val)
1165 {
1166         struct sd *sd = (struct sd *) gspca_dev;
1167
1168         *val = sd->global_gain;
1169         return 0;
1170 }
1171
1172 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1173 {
1174         struct sd *sd = (struct sd *) gspca_dev;
1175
1176         sd->brightness = val;
1177         if (gspca_dev->streaming)
1178                 setbrightness(gspca_dev);
1179         return 0;
1180 }
1181
1182 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1183 {
1184         struct sd *sd = (struct sd *) gspca_dev;
1185
1186         *val = sd->brightness;
1187         return *val;
1188 }
1189
1190 static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val)
1191 {
1192         struct sd *sd = (struct sd *) gspca_dev;
1193
1194         sd->awb = val;
1195         if (gspca_dev->streaming)
1196                 setawb(gspca_dev);
1197         return 0;
1198 }
1199
1200 static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val)
1201 {
1202         struct sd *sd = (struct sd *) gspca_dev;
1203
1204         *val = sd->awb;
1205         return *val;
1206 }
1207
1208 static int sd_setmirror(struct gspca_dev *gspca_dev, __s32 val)
1209 {
1210         struct sd *sd = (struct sd *) gspca_dev;
1211
1212         sd->mirror = val;
1213         if (gspca_dev->streaming)
1214                 setmirror(gspca_dev);
1215         return 0;
1216 }
1217
1218 static int sd_getmirror(struct gspca_dev *gspca_dev, __s32 *val)
1219 {
1220         struct sd *sd = (struct sd *) gspca_dev;
1221
1222         *val = sd->mirror;
1223         return *val;
1224 }
1225
1226 static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val)
1227 {
1228         struct sd *sd = (struct sd *) gspca_dev;
1229
1230         sd->effect = val;
1231         if (gspca_dev->streaming)
1232                 seteffect(gspca_dev);
1233         return 0;
1234 }
1235
1236 static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val)
1237 {
1238         struct sd *sd = (struct sd *) gspca_dev;
1239
1240         *val = sd->effect;
1241         return *val;
1242 }
1243
1244 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1245 {
1246         struct sd *sd = (struct sd *) gspca_dev;
1247
1248         sd->contrast = val;
1249         if (gspca_dev->streaming)
1250                 setcontrast(gspca_dev);
1251         return 0;
1252 }
1253
1254 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1255 {
1256         struct sd *sd = (struct sd *) gspca_dev;
1257
1258         *val = sd->contrast;
1259         return *val;
1260 }
1261
1262 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1263 {
1264         struct sd *sd = (struct sd *) gspca_dev;
1265
1266         sd->colors = val;
1267         if (gspca_dev->streaming)
1268                 setcolors(gspca_dev);
1269         return 0;
1270 }
1271
1272 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1273 {
1274         struct sd *sd = (struct sd *) gspca_dev;
1275
1276         *val = sd->colors;
1277         return 0;
1278 }
1279
1280 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
1281 {
1282         struct sd *sd = (struct sd *) gspca_dev;
1283
1284         sd->gamma = val;
1285         if (gspca_dev->streaming)
1286                 setgamma(gspca_dev);
1287         return 0;
1288 }
1289
1290 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
1291 {
1292         struct sd *sd = (struct sd *) gspca_dev;
1293
1294         *val = sd->gamma;
1295         return 0;
1296 }
1297
1298 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1299 {
1300         struct sd *sd = (struct sd *) gspca_dev;
1301
1302         sd->freq = val;
1303         if (gspca_dev->streaming)
1304                 setfreq(gspca_dev);
1305         return 0;
1306 }
1307
1308 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1309 {
1310         struct sd *sd = (struct sd *) gspca_dev;
1311
1312         *val = sd->freq;
1313         return 0;
1314 }
1315
1316 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
1317 {
1318         struct sd *sd = (struct sd *) gspca_dev;
1319
1320         sd->sharpness = val;
1321         if (gspca_dev->streaming)
1322                 setsharpness(gspca_dev);
1323         return 0;
1324 }
1325
1326 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
1327 {
1328         struct sd *sd = (struct sd *) gspca_dev;
1329
1330         *val = sd->sharpness;
1331         return 0;
1332 }
1333
1334 /* Low Light set  here......*/
1335 static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val)
1336 {
1337         struct sd *sd = (struct sd *) gspca_dev;
1338
1339         sd->autogain = val;
1340         if (val != 0)
1341                 reg_w(gspca_dev, 0xf48e);
1342         else
1343                 reg_w(gspca_dev, 0xb48e);
1344         return 0;
1345 }
1346
1347 static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val)
1348 {
1349         struct sd *sd = (struct sd *) gspca_dev;
1350
1351         *val = sd->autogain;
1352         return 0;
1353 }
1354
1355 static int sd_querymenu(struct gspca_dev *gspca_dev,
1356                         struct v4l2_querymenu *menu)
1357 {
1358         switch (menu->id) {
1359         case V4L2_CID_POWER_LINE_FREQUENCY:
1360                 switch (menu->index) {
1361                 case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1362                         strcpy((char *) menu->name, "50 Hz");
1363                         return 0;
1364                 case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1365                         strcpy((char *) menu->name, "60 Hz");
1366                         return 0;
1367                 }
1368                 break;
1369         case V4L2_CID_EFFECTS:
1370                 if ((unsigned) menu->index < ARRAY_SIZE(effects_control)) {
1371                         strncpy((char *) menu->name,
1372                                 effects_control[menu->index],
1373                                 sizeof menu->name);
1374                         return 0;
1375                 }
1376                 break;
1377         }
1378         return -EINVAL;
1379 }
1380
1381 /* sub-driver description */
1382 static const struct sd_desc sd_desc = {
1383         .name = MODULE_NAME,
1384         .ctrls = sd_ctrls,
1385         .nctrls = ARRAY_SIZE(sd_ctrls),
1386         .config = sd_config,
1387         .init = sd_init,
1388         .start = sd_start,
1389         .stopN = sd_stopN,
1390         .pkt_scan = sd_pkt_scan,
1391         .querymenu = sd_querymenu,
1392 };
1393
1394 /* -- module initialisation -- */
1395 static const __devinitdata struct usb_device_id device_table[] = {
1396         {USB_DEVICE(0x17a1, 0x0128)},
1397         {}
1398 };
1399 MODULE_DEVICE_TABLE(usb, device_table);
1400
1401 /* -- device connect -- */
1402 static int sd_probe(struct usb_interface *intf,
1403                     const struct usb_device_id *id)
1404 {
1405         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1406                                THIS_MODULE);
1407 }
1408
1409 static struct usb_driver sd_driver = {
1410         .name = MODULE_NAME,
1411         .id_table = device_table,
1412         .probe = sd_probe,
1413         .disconnect = gspca_disconnect,
1414 #ifdef CONFIG_PM
1415         .suspend = gspca_suspend,
1416         .resume = gspca_resume,
1417 #endif
1418 };
1419
1420 /* -- module insert / remove -- */
1421 static int __init sd_mod_init(void)
1422 {
1423         int ret;
1424         ret = usb_register(&sd_driver);
1425         if (ret < 0)
1426                 return ret;
1427         PDEBUG(D_PROBE, "registered");
1428         return 0;
1429 }
1430 static void __exit sd_mod_exit(void)
1431 {
1432         usb_deregister(&sd_driver);
1433         PDEBUG(D_PROBE, "deregistered");
1434 }
1435
1436 module_init(sd_mod_init);
1437 module_exit(sd_mod_exit);