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