drivers/media/video/gspca/pac7302.c

   1 /*
   2  *              Pixart PAC7302 library
   3  *              Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
   4  *
   5  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   6  *
   7  * Separated from Pixart PAC7311 library by Márton Németh
   8  * Camera button input handling by Márton Németh <nm127@freemail.hu>
   9  * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24  */
  25
  26 /* Some documentation about various registers as determined by trial and error.
  27
  28    Register page 1:
  29
  30    Address      Description
  31    0x78         Global control, bit 6 controls the LED (inverted)
  32
  33    Register page 3:
  34
  35    Address      Description
  36    0x02         Clock divider 3-63, fps = 90 / val. Must be a multiple of 3 on
  37                 the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
  38    0x03         Variable framerate ctrl reg2==3: 0 -> ~30 fps, 255 -> ~22fps
  39    0x04         Another var framerate ctrl reg2==3, reg3==0: 0 -> ~30 fps,
  40                 63 -> ~27 fps, the 2 msb's must always be 1 !!
  41    0x05         Another var framerate ctrl reg2==3, reg3==0, reg4==0xc0:
  42                 1 -> ~30 fps, 2 -> ~20 fps
  43    0x0e         Exposure bits 0-7, 0-448, 0 = use full frame time
  44    0x0f         Exposure bit 8, 0-448, 448 = no exposure at all
  45    0x10         Master gain 0-31
  46    0x21         Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
  47
  48    The registers are accessed in the following functions:
  49
  50    Page | Register   | Function
  51    -----+------------+---------------------------------------------------
  52     0   | 0x0f..0x20 | setcolors()
  53     0   | 0xa2..0xab | setbrightcont()
  54     0   | 0xc5       | setredbalance()
  55     0   | 0xc6       | setwhitebalance()
  56     0   | 0xc7       | setbluebalance()
  57     0   | 0xdc       | setbrightcont(), setcolors()
  58     3   | 0x02       | setexposure()
  59     3   | 0x10       | setgain()
  60     3   | 0x11       | setcolors(), setgain(), setexposure(), sethvflip()
  61     3   | 0x21       | sethvflip()
  62 */
  63
  64 #define MODULE_NAME "pac7302"
  65
  66 #include <linux/input.h>
  67 #include <media/v4l2-chip-ident.h>
  68 #include "gspca.h"
  69
  70 MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li");
  71 MODULE_DESCRIPTION("Pixart PAC7302");
  72 MODULE_LICENSE("GPL");
  73
  74 /* specific webcam descriptor for pac7302 */
  75 struct sd {
  76         struct gspca_dev gspca_dev;             /* !! must be the first item */
  77
  78         unsigned char brightness;
  79         unsigned char contrast;
  80         unsigned char colors;
  81         unsigned char white_balance;
  82         unsigned char red_balance;
  83         unsigned char blue_balance;
  84         unsigned char gain;
  85         unsigned char autogain;
  86         unsigned short exposure;
  87         __u8 hflip;
  88         __u8 vflip;
  89         u8 flags;
  90 #define FL_HFLIP 0x01           /* mirrored by default */
  91 #define FL_VFLIP 0x02           /* vertical flipped by default */
  92
  93         u8 sof_read;
  94         u8 autogain_ignore_frames;
  95
  96         atomic_t avg_lum;
  97 };
  98
  99 /* V4L2 controls supported by the driver */
 100 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
 101 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
 102 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
 103 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
 104 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
 105 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
 106 static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val);
 107 static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val);
 108 static int sd_setredbalance(struct gspca_dev *gspca_dev, __s32 val);
 109 static int sd_getredbalance(struct gspca_dev *gspca_dev, __s32 *val);
 110 static int sd_setbluebalance(struct gspca_dev *gspca_dev, __s32 val);
 111 static int sd_getbluebalance(struct gspca_dev *gspca_dev, __s32 *val);
 112 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
 113 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 114 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
 115 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
 116 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
 117 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
 118 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
 119 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
 120 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
 121 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
 122
 123 static const struct ctrl sd_ctrls[] = {
 124         {
 125             {
 126                 .id      = V4L2_CID_BRIGHTNESS,
 127                 .type    = V4L2_CTRL_TYPE_INTEGER,
 128                 .name    = "Brightness",
 129                 .minimum = 0,
 130 #define BRIGHTNESS_MAX 0x20
 131                 .maximum = BRIGHTNESS_MAX,
 132                 .step    = 1,
 133 #define BRIGHTNESS_DEF 0x10
 134                 .default_value = BRIGHTNESS_DEF,
 135             },
 136             .set = sd_setbrightness,
 137             .get = sd_getbrightness,
 138         },
 139         {
 140             {
 141                 .id      = V4L2_CID_CONTRAST,
 142                 .type    = V4L2_CTRL_TYPE_INTEGER,
 143                 .name    = "Contrast",
 144                 .minimum = 0,
 145 #define CONTRAST_MAX 255
 146                 .maximum = CONTRAST_MAX,
 147                 .step    = 1,
 148 #define CONTRAST_DEF 127
 149                 .default_value = CONTRAST_DEF,
 150             },
 151             .set = sd_setcontrast,
 152             .get = sd_getcontrast,
 153         },
 154         {
 155             {
 156                 .id      = V4L2_CID_SATURATION,
 157                 .type    = V4L2_CTRL_TYPE_INTEGER,
 158                 .name    = "Saturation",
 159                 .minimum = 0,
 160 #define COLOR_MAX 255
 161                 .maximum = COLOR_MAX,
 162                 .step    = 1,
 163 #define COLOR_DEF 127
 164                 .default_value = COLOR_DEF,
 165             },
 166             .set = sd_setcolors,
 167             .get = sd_getcolors,
 168         },
 169         {
 170             {
 171                 .id      = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
 172                 .type    = V4L2_CTRL_TYPE_INTEGER,
 173                 .name    = "White Balance",
 174                 .minimum = 0,
 175                 .maximum = 255,
 176                 .step    = 1,
 177 #define WHITEBALANCE_DEF 4
 178                 .default_value = WHITEBALANCE_DEF,
 179             },
 180             .set = sd_setwhitebalance,
 181             .get = sd_getwhitebalance,
 182         },
 183         {
 184             {
 185                 .id      = V4L2_CID_RED_BALANCE,
 186                 .type    = V4L2_CTRL_TYPE_INTEGER,
 187                 .name    = "Red",
 188                 .minimum = 0,
 189                 .maximum = 3,
 190                 .step    = 1,
 191 #define REDBALANCE_DEF 1
 192                 .default_value = REDBALANCE_DEF,
 193             },
 194             .set = sd_setredbalance,
 195             .get = sd_getredbalance,
 196         },
 197         {
 198             {
 199                 .id      = V4L2_CID_BLUE_BALANCE,
 200                 .type    = V4L2_CTRL_TYPE_INTEGER,
 201                 .name    = "Blue",
 202                 .minimum = 0,
 203                 .maximum = 3,
 204                 .step    = 1,
 205 #define BLUEBALANCE_DEF 1
 206                 .default_value = BLUEBALANCE_DEF,
 207             },
 208             .set = sd_setbluebalance,
 209             .get = sd_getbluebalance,
 210         },
 211         {
 212             {
 213                 .id      = V4L2_CID_GAIN,
 214                 .type    = V4L2_CTRL_TYPE_INTEGER,
 215                 .name    = "Gain",
 216                 .minimum = 0,
 217 #define GAIN_MAX 255
 218                 .maximum = GAIN_MAX,
 219                 .step    = 1,
 220 #define GAIN_DEF 127
 221 #define GAIN_KNEE 255 /* Gain seems to cause little noise on the pac73xx */
 222                 .default_value = GAIN_DEF,
 223             },
 224             .set = sd_setgain,
 225             .get = sd_getgain,
 226         },
 227         {
 228             {
 229                 .id      = V4L2_CID_EXPOSURE,
 230                 .type    = V4L2_CTRL_TYPE_INTEGER,
 231                 .name    = "Exposure",
 232                 .minimum = 0,
 233                 .maximum = 1023,
 234                 .step    = 1,
 235 #define EXPOSURE_DEF  66  /*  33 ms / 30 fps */
 236 #define EXPOSURE_KNEE 133 /*  66 ms / 15 fps */
 237                 .default_value = EXPOSURE_DEF,
 238             },
 239             .set = sd_setexposure,
 240             .get = sd_getexposure,
 241         },
 242         {
 243             {
 244                 .id      = V4L2_CID_AUTOGAIN,
 245                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 246                 .name    = "Auto Gain",
 247                 .minimum = 0,
 248                 .maximum = 1,
 249                 .step    = 1,
 250 #define AUTOGAIN_DEF 1
 251                 .default_value = AUTOGAIN_DEF,
 252             },
 253             .set = sd_setautogain,
 254             .get = sd_getautogain,
 255         },
 256         {
 257             {
 258                 .id      = V4L2_CID_HFLIP,
 259                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 260                 .name    = "Mirror",
 261                 .minimum = 0,
 262                 .maximum = 1,
 263                 .step    = 1,
 264 #define HFLIP_DEF 0
 265                 .default_value = HFLIP_DEF,
 266             },
 267             .set = sd_sethflip,
 268             .get = sd_gethflip,
 269         },
 270         {
 271             {
 272                 .id      = V4L2_CID_VFLIP,
 273                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 274                 .name    = "Vflip",
 275                 .minimum = 0,
 276                 .maximum = 1,
 277                 .step    = 1,
 278 #define VFLIP_DEF 0
 279                 .default_value = VFLIP_DEF,
 280             },
 281             .set = sd_setvflip,
 282             .get = sd_getvflip,
 283         },
 284 };
 285
 286 static const struct v4l2_pix_format vga_mode[] = {
 287         {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
 288                 .bytesperline = 640,
 289                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 290                 .colorspace = V4L2_COLORSPACE_JPEG,
 291                 .priv = 0},
 292 };
 293
 294 #define LOAD_PAGE3              255
 295 #define END_OF_SEQUENCE         0
 296
 297 /* pac 7302 */
 298 static const __u8 init_7302[] = {
 299 /*      index,value */
 300         0xff, 0x01,             /* page 1 */
 301         0x78, 0x00,             /* deactivate */
 302         0xff, 0x01,
 303         0x78, 0x40,             /* led off */
 304 };
 305 static const __u8 start_7302[] = {
 306 /*      index, len, [value]* */
 307         0xff, 1,        0x00,           /* page 0 */
 308         0x00, 12,       0x01, 0x40, 0x40, 0x40, 0x01, 0xe0, 0x02, 0x80,
 309                         0x00, 0x00, 0x00, 0x00,
 310         0x0d, 24,       0x03, 0x01, 0x00, 0xb5, 0x07, 0xcb, 0x00, 0x00,
 311                         0x07, 0xc8, 0x00, 0xea, 0x07, 0xcf, 0x07, 0xf7,
 312                         0x07, 0x7e, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x11,
 313         0x26, 2,        0xaa, 0xaa,
 314         0x2e, 1,        0x31,
 315         0x38, 1,        0x01,
 316         0x3a, 3,        0x14, 0xff, 0x5a,
 317         0x43, 11,       0x00, 0x0a, 0x18, 0x11, 0x01, 0x2c, 0x88, 0x11,
 318                         0x00, 0x54, 0x11,
 319         0x55, 1,        0x00,
 320         0x62, 4,        0x10, 0x1e, 0x1e, 0x18,
 321         0x6b, 1,        0x00,
 322         0x6e, 3,        0x08, 0x06, 0x00,
 323         0x72, 3,        0x00, 0xff, 0x00,
 324         0x7d, 23,       0x01, 0x01, 0x58, 0x46, 0x50, 0x3c, 0x50, 0x3c,
 325                         0x54, 0x46, 0x54, 0x56, 0x52, 0x50, 0x52, 0x50,
 326                         0x56, 0x64, 0xa4, 0x00, 0xda, 0x00, 0x00,
 327         0xa2, 10,       0x22, 0x2c, 0x3c, 0x54, 0x69, 0x7c, 0x9c, 0xb9,
 328                         0xd2, 0xeb,
 329         0xaf, 1,        0x02,
 330         0xb5, 2,        0x08, 0x08,
 331         0xb8, 2,        0x08, 0x88,
 332         0xc4, 4,        0xae, 0x01, 0x04, 0x01,
 333         0xcc, 1,        0x00,
 334         0xd1, 11,       0x01, 0x30, 0x49, 0x5e, 0x6f, 0x7f, 0x8e, 0xa9,
 335                         0xc1, 0xd7, 0xec,
 336         0xdc, 1,        0x01,
 337         0xff, 1,        0x01,           /* page 1 */
 338         0x12, 3,        0x02, 0x00, 0x01,
 339         0x3e, 2,        0x00, 0x00,
 340         0x76, 5,        0x01, 0x20, 0x40, 0x00, 0xf2,
 341         0x7c, 1,        0x00,
 342         0x7f, 10,       0x4b, 0x0f, 0x01, 0x2c, 0x02, 0x58, 0x03, 0x20,
 343                         0x02, 0x00,
 344         0x96, 5,        0x01, 0x10, 0x04, 0x01, 0x04,
 345         0xc8, 14,       0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
 346                         0x07, 0x00, 0x01, 0x07, 0x04, 0x01,
 347         0xd8, 1,        0x01,
 348         0xdb, 2,        0x00, 0x01,
 349         0xde, 7,        0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00,
 350         0xe6, 4,        0x00, 0x00, 0x00, 0x01,
 351         0xeb, 1,        0x00,
 352         0xff, 1,        0x02,           /* page 2 */
 353         0x22, 1,        0x00,
 354         0xff, 1,        0x03,           /* page 3 */
 355         0, LOAD_PAGE3,                  /* load the page 3 */
 356         0x11, 1,        0x01,
 357         0xff, 1,        0x02,           /* page 2 */
 358         0x13, 1,        0x00,
 359         0x22, 4,        0x1f, 0xa4, 0xf0, 0x96,
 360         0x27, 2,        0x14, 0x0c,
 361         0x2a, 5,        0xc8, 0x00, 0x18, 0x12, 0x22,
 362         0x64, 8,        0x00, 0x00, 0xf0, 0x01, 0x14, 0x44, 0x44, 0x44,
 363         0x6e, 1,        0x08,
 364         0xff, 1,        0x01,           /* page 1 */
 365         0x78, 1,        0x00,
 366         0, END_OF_SEQUENCE              /* end of sequence */
 367 };
 368
 369 #define SKIP            0xaa
 370 /* page 3 - the value SKIP says skip the index - see reg_w_page() */
 371 static const __u8 page3_7302[] = {
 372         0x90, 0x40, 0x03, 0x00, 0xc0, 0x01, 0x14, 0x16,
 373         0x14, 0x12, 0x00, 0x00, 0x00, 0x02, 0x33, 0x00,
 374         0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 375         0x00, 0x00, 0x00, 0x47, 0x01, 0xb3, 0x01, 0x00,
 376         0x00, 0x08, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x21,
 377         0x00, 0x00, 0x00, 0x54, 0xf4, 0x02, 0x52, 0x54,
 378         0xa4, 0xb8, 0xe0, 0x2a, 0xf6, 0x00, 0x00, 0x00,
 379         0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 380         0x00, 0xfc, 0x00, 0xf2, 0x1f, 0x04, 0x00, 0x00,
 381         SKIP, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00,
 382         0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 383         0x00, 0x40, 0xff, 0x03, 0x19, 0x00, 0x00, 0x00,
 384         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 385         0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xc8, 0xc8,
 386         0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50,
 387         0x08, 0x10, 0x24, 0x40, 0x00, 0x00, 0x00, 0x00,
 388         0x01, 0x00, 0x02, 0x47, 0x00, 0x00, 0x00, 0x00,
 389         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 390         0x00, 0x02, 0xfa, 0x00, 0x64, 0x5a, 0x28, 0x00,
 391         0x00
 392 };
 393
 394 static void reg_w_buf(struct gspca_dev *gspca_dev,
 395                   __u8 index,
 396                   const char *buffer, int len)
 397 {
 398         int ret;
 399
 400         if (gspca_dev->usb_err < 0)
 401                 return;
 402         memcpy(gspca_dev->usb_buf, buffer, len);
 403         ret = usb_control_msg(gspca_dev->dev,
 404                         usb_sndctrlpipe(gspca_dev->dev, 0),
 405                         1,              /* request */
 406                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 407                         0,              /* value */
 408                         index, gspca_dev->usb_buf, len,
 409                         500);
 410         if (ret < 0) {
 411                 PDEBUG(D_ERR, "reg_w_buf(): "
 412                 "Failed to write registers to index 0x%x, error %i",
 413                 index, ret);
 414                 gspca_dev->usb_err = ret;
 415         }
 416 }
 417
 418
 419 static void reg_w(struct gspca_dev *gspca_dev,
 420                   __u8 index,
 421                   __u8 value)
 422 {
 423         int ret;
 424
 425         if (gspca_dev->usb_err < 0)
 426                 return;
 427         gspca_dev->usb_buf[0] = value;
 428         ret = usb_control_msg(gspca_dev->dev,
 429                         usb_sndctrlpipe(gspca_dev->dev, 0),
 430                         0,                      /* request */
 431                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 432                         0, index, gspca_dev->usb_buf, 1,
 433                         500);
 434         if (ret < 0) {
 435                 PDEBUG(D_ERR, "reg_w(): "
 436                 "Failed to write register to index 0x%x, value 0x%x, error %i",
 437                 index, value, ret);
 438                 gspca_dev->usb_err = ret;
 439         }
 440 }
 441
 442 static void reg_w_seq(struct gspca_dev *gspca_dev,
 443                 const __u8 *seq, int len)
 444 {
 445         while (--len >= 0) {
 446                 reg_w(gspca_dev, seq[0], seq[1]);
 447                 seq += 2;
 448         }
 449 }
 450
 451 /* load the beginning of a page */
 452 static void reg_w_page(struct gspca_dev *gspca_dev,
 453                         const __u8 *page, int len)
 454 {
 455         int index;
 456         int ret = 0;
 457
 458         if (gspca_dev->usb_err < 0)
 459                 return;
 460         for (index = 0; index < len; index++) {
 461                 if (page[index] == SKIP)                /* skip this index */
 462                         continue;
 463                 gspca_dev->usb_buf[0] = page[index];
 464                 ret = usb_control_msg(gspca_dev->dev,
 465                                 usb_sndctrlpipe(gspca_dev->dev, 0),
 466                                 0,                      /* request */
 467                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 468                                 0, index, gspca_dev->usb_buf, 1,
 469                                 500);
 470                 if (ret < 0) {
 471                         PDEBUG(D_ERR, "reg_w_page(): "
 472                         "Failed to write register to index 0x%x, "
 473                         "value 0x%x, error %i",
 474                         index, page[index], ret);
 475                         gspca_dev->usb_err = ret;
 476                         break;
 477                 }
 478         }
 479 }
 480
 481 /* output a variable sequence */
 482 static void reg_w_var(struct gspca_dev *gspca_dev,
 483                         const __u8 *seq,
 484                         const __u8 *page3, unsigned int page3_len)
 485 {
 486         int index, len;
 487
 488         for (;;) {
 489                 index = *seq++;
 490                 len = *seq++;
 491                 switch (len) {
 492                 case END_OF_SEQUENCE:
 493                         return;
 494                 case LOAD_PAGE3:
 495                         reg_w_page(gspca_dev, page3, page3_len);
 496                         break;
 497                 default:
 498                         if (len > USB_BUF_SZ) {
 499                                 PDEBUG(D_ERR|D_STREAM,
 500                                         "Incorrect variable sequence");
 501                                 return;
 502                         }
 503                         while (len > 0) {
 504                                 if (len < 8) {
 505                                         reg_w_buf(gspca_dev,
 506                                                 index, seq, len);
 507                                         seq += len;
 508                                         break;
 509                                 }
 510                                 reg_w_buf(gspca_dev, index, seq, 8);
 511                                 seq += 8;
 512                                 index += 8;
 513                                 len -= 8;
 514                         }
 515                 }
 516         }
 517         /* not reached */
 518 }
 519
 520 /* this function is called at probe time for pac7302 */
 521 static int sd_config(struct gspca_dev *gspca_dev,
 522                         const struct usb_device_id *id)
 523 {
 524         struct sd *sd = (struct sd *) gspca_dev;
 525         struct cam *cam;
 526
 527         cam = &gspca_dev->cam;
 528
 529         PDEBUG(D_CONF, "Find Sensor PAC7302");
 530         cam->cam_mode = vga_mode;       /* only 640x480 */
 531         cam->nmodes = ARRAY_SIZE(vga_mode);
 532
 533         sd->brightness = BRIGHTNESS_DEF;
 534         sd->contrast = CONTRAST_DEF;
 535         sd->colors = COLOR_DEF;
 536         sd->white_balance = WHITEBALANCE_DEF;
 537         sd->red_balance = REDBALANCE_DEF;
 538         sd->blue_balance = BLUEBALANCE_DEF;
 539         sd->gain = GAIN_DEF;
 540         sd->exposure = EXPOSURE_DEF;
 541         sd->autogain = AUTOGAIN_DEF;
 542         sd->hflip = HFLIP_DEF;
 543         sd->vflip = VFLIP_DEF;
 544         sd->flags = id->driver_info;
 545         return 0;
 546 }
 547
 548 /* This function is used by pac7302 only */
 549 static void setbrightcont(struct gspca_dev *gspca_dev)
 550 {
 551         struct sd *sd = (struct sd *) gspca_dev;
 552         int i, v;
 553         static const __u8 max[10] =
 554                 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb,
 555                  0xd4, 0xec};
 556         static const __u8 delta[10] =
 557                 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17,
 558                  0x11, 0x0b};
 559
 560         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 561         for (i = 0; i < 10; i++) {
 562                 v = max[i];
 563                 v += (sd->brightness - BRIGHTNESS_MAX)
 564                         * 150 / BRIGHTNESS_MAX;         /* 200 ? */
 565                 v -= delta[i] * sd->contrast / CONTRAST_MAX;
 566                 if (v < 0)
 567                         v = 0;
 568                 else if (v > 0xff)
 569                         v = 0xff;
 570                 reg_w(gspca_dev, 0xa2 + i, v);
 571         }
 572         reg_w(gspca_dev, 0xdc, 0x01);
 573 }
 574
 575 /* This function is used by pac7302 only */
 576 static void setcolors(struct gspca_dev *gspca_dev)
 577 {
 578         struct sd *sd = (struct sd *) gspca_dev;
 579         int i, v;
 580         static const int a[9] =
 581                 {217, -212, 0, -101, 170, -67, -38, -315, 355};
 582         static const int b[9] =
 583                 {19, 106, 0, 19, 106, 1, 19, 106, 1};
 584
 585         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 586         reg_w(gspca_dev, 0x11, 0x01);
 587         reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
 588         for (i = 0; i < 9; i++) {
 589                 v = a[i] * sd->colors / COLOR_MAX + b[i];
 590                 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
 591                 reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
 592         }
 593         reg_w(gspca_dev, 0xdc, 0x01);
 594         PDEBUG(D_CONF|D_STREAM, "color: %i", sd->colors);
 595 }
 596
 597 static void setwhitebalance(struct gspca_dev *gspca_dev)
 598 {
 599         struct sd *sd = (struct sd *) gspca_dev;
 600
 601         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 602         reg_w(gspca_dev, 0xc6, sd->white_balance);
 603
 604         reg_w(gspca_dev, 0xdc, 0x01);
 605         PDEBUG(D_CONF|D_STREAM, "white_balance: %i", sd->white_balance);
 606 }
 607
 608 static void setredbalance(struct gspca_dev *gspca_dev)
 609 {
 610         struct sd *sd = (struct sd *) gspca_dev;
 611
 612         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 613         reg_w(gspca_dev, 0xc5, sd->red_balance);
 614
 615         reg_w(gspca_dev, 0xdc, 0x01);
 616         PDEBUG(D_CONF|D_STREAM, "red_balance: %i", sd->red_balance);
 617 }
 618
 619 static void setbluebalance(struct gspca_dev *gspca_dev)
 620 {
 621         struct sd *sd = (struct sd *) gspca_dev;
 622
 623         reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
 624         reg_w(gspca_dev, 0xc7, sd->blue_balance);
 625
 626         reg_w(gspca_dev, 0xdc, 0x01);
 627         PDEBUG(D_CONF|D_STREAM, "blue_balance: %i", sd->blue_balance);
 628 }
 629
 630 static void setgain(struct gspca_dev *gspca_dev)
 631 {
 632         struct sd *sd = (struct sd *) gspca_dev;
 633
 634         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 635         reg_w(gspca_dev, 0x10, sd->gain >> 3);
 636
 637         /* load registers to sensor (Bit 0, auto clear) */
 638         reg_w(gspca_dev, 0x11, 0x01);
 639 }
 640
 641 static void setexposure(struct gspca_dev *gspca_dev)
 642 {
 643         struct sd *sd = (struct sd *) gspca_dev;
 644         __u8 clockdiv;
 645         __u16 exposure;
 646
 647         /* register 2 of frame 3 contains the clock divider configuring the
 648            no fps according to the formula: 90 / reg. sd->exposure is the
 649            desired exposure time in 0.5 ms. */
 650         clockdiv = (90 * sd->exposure + 1999) / 2000;
 651
 652         /* Note clockdiv = 3 also works, but when running at 30 fps, depending
 653            on the scene being recorded, the camera switches to another
 654            quantization table for certain JPEG blocks, and we don't know how
 655            to decompress these blocks. So we cap the framerate at 15 fps */
 656         if (clockdiv < 6)
 657                 clockdiv = 6;
 658         else if (clockdiv > 63)
 659                 clockdiv = 63;
 660
 661         /* reg2 MUST be a multiple of 3, except when between 6 and 12?
 662            Always round up, otherwise we cannot get the desired frametime
 663            using the partial frame time exposure control */
 664         if (clockdiv < 6 || clockdiv > 12)
 665                 clockdiv = ((clockdiv + 2) / 3) * 3;
 666
 667         /* frame exposure time in ms = 1000 * clockdiv / 90    ->
 668         exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90) */
 669         exposure = (sd->exposure * 45 * 448) / (1000 * clockdiv);
 670         /* 0 = use full frametime, 448 = no exposure, reverse it */
 671         exposure = 448 - exposure;
 672
 673         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 674         reg_w(gspca_dev, 0x02, clockdiv);
 675         reg_w(gspca_dev, 0x0e, exposure & 0xff);
 676         reg_w(gspca_dev, 0x0f, exposure >> 8);
 677
 678         /* load registers to sensor (Bit 0, auto clear) */
 679         reg_w(gspca_dev, 0x11, 0x01);
 680 }
 681
 682 static void sethvflip(struct gspca_dev *gspca_dev)
 683 {
 684         struct sd *sd = (struct sd *) gspca_dev;
 685         u8 data, hflip, vflip;
 686
 687         hflip = sd->hflip;
 688         if (sd->flags & FL_HFLIP)
 689                 hflip = !hflip;
 690         vflip = sd->vflip;
 691         if (sd->flags & FL_VFLIP)
 692                 vflip = !vflip;
 693
 694         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 695         data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00);
 696         reg_w(gspca_dev, 0x21, data);
 697
 698         /* load registers to sensor (Bit 0, auto clear) */
 699         reg_w(gspca_dev, 0x11, 0x01);
 700 }
 701
 702 /* this function is called at probe and resume time for pac7302 */
 703 static int sd_init(struct gspca_dev *gspca_dev)
 704 {
 705         reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
 706         return gspca_dev->usb_err;
 707 }
 708
 709 static int sd_start(struct gspca_dev *gspca_dev)
 710 {
 711         struct sd *sd = (struct sd *) gspca_dev;
 712
 713         sd->sof_read = 0;
 714
 715         reg_w_var(gspca_dev, start_7302,
 716                 page3_7302, sizeof(page3_7302));
 717         setbrightcont(gspca_dev);
 718         setcolors(gspca_dev);
 719         setwhitebalance(gspca_dev);
 720         setredbalance(gspca_dev);
 721         setbluebalance(gspca_dev);
 722         setgain(gspca_dev);
 723         setexposure(gspca_dev);
 724         sethvflip(gspca_dev);
 725
 726         /* only resolution 640x480 is supported for pac7302 */
 727
 728         sd->sof_read = 0;
 729         sd->autogain_ignore_frames = 0;
 730         atomic_set(&sd->avg_lum, -1);
 731
 732         /* start stream */
 733         reg_w(gspca_dev, 0xff, 0x01);
 734         reg_w(gspca_dev, 0x78, 0x01);
 735
 736         return gspca_dev->usb_err;
 737 }
 738
 739 static void sd_stopN(struct gspca_dev *gspca_dev)
 740 {
 741
 742         /* stop stream */
 743         reg_w(gspca_dev, 0xff, 0x01);
 744         reg_w(gspca_dev, 0x78, 0x00);
 745 }
 746
 747 /* called on streamoff with alt 0 and on disconnect for pac7302 */
 748 static void sd_stop0(struct gspca_dev *gspca_dev)
 749 {
 750         if (!gspca_dev->present)
 751                 return;
 752         reg_w(gspca_dev, 0xff, 0x01);
 753         reg_w(gspca_dev, 0x78, 0x40);
 754 }
 755
 756 /* Include pac common sof detection functions */
 757 #include "pac_common.h"
 758
 759 static void do_autogain(struct gspca_dev *gspca_dev)
 760 {
 761         struct sd *sd = (struct sd *) gspca_dev;
 762         int avg_lum = atomic_read(&sd->avg_lum);
 763         int desired_lum;
 764         const int deadzone = 30;
 765
 766         if (avg_lum == -1)
 767                 return;
 768
 769         desired_lum = 270 + sd->brightness;
 770
 771         if (sd->autogain_ignore_frames > 0)
 772                 sd->autogain_ignore_frames--;
 773         else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum, desired_lum,
 774                         deadzone, GAIN_KNEE, EXPOSURE_KNEE))
 775                 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
 776 }
 777
 778 /* JPEG header, part 1 */
 779 static const unsigned char pac_jpeg_header1[] = {
 780   0xff, 0xd8,           /* SOI: Start of Image */
 781
 782   0xff, 0xc0,           /* SOF0: Start of Frame (Baseline DCT) */
 783   0x00, 0x11,           /* length = 17 bytes (including this length field) */
 784   0x08                  /* Precision: 8 */
 785   /* 2 bytes is placed here: number of image lines */
 786   /* 2 bytes is placed here: samples per line */
 787 };
 788
 789 /* JPEG header, continued */
 790 static const unsigned char pac_jpeg_header2[] = {
 791   0x03,                 /* Number of image components: 3 */
 792   0x01, 0x21, 0x00,     /* ID=1, Subsampling 1x1, Quantization table: 0 */
 793   0x02, 0x11, 0x01,     /* ID=2, Subsampling 2x1, Quantization table: 1 */
 794   0x03, 0x11, 0x01,     /* ID=3, Subsampling 2x1, Quantization table: 1 */
 795
 796   0xff, 0xda,           /* SOS: Start Of Scan */
 797   0x00, 0x0c,           /* length = 12 bytes (including this length field) */
 798   0x03,                 /* number of components: 3 */
 799   0x01, 0x00,           /* selector 1, table 0x00 */
 800   0x02, 0x11,           /* selector 2, table 0x11 */
 801   0x03, 0x11,           /* selector 3, table 0x11 */
 802   0x00, 0x3f,           /* Spectral selection: 0 .. 63 */
 803   0x00                  /* Successive approximation: 0 */
 804 };
 805
 806 static void pac_start_frame(struct gspca_dev *gspca_dev,
 807                 struct gspca_frame *frame,
 808                 __u16 lines, __u16 samples_per_line)
 809 {
 810         unsigned char tmpbuf[4];
 811
 812         gspca_frame_add(gspca_dev, FIRST_PACKET,
 813                 pac_jpeg_header1, sizeof(pac_jpeg_header1));
 814
 815         tmpbuf[0] = lines >> 8;
 816         tmpbuf[1] = lines & 0xff;
 817         tmpbuf[2] = samples_per_line >> 8;
 818         tmpbuf[3] = samples_per_line & 0xff;
 819
 820         gspca_frame_add(gspca_dev, INTER_PACKET,
 821                 tmpbuf, sizeof(tmpbuf));
 822         gspca_frame_add(gspca_dev, INTER_PACKET,
 823                 pac_jpeg_header2, sizeof(pac_jpeg_header2));
 824 }
 825
 826 /* this function is run at interrupt level */
 827 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 828                         u8 *data,                       /* isoc packet */
 829                         int len)                        /* iso packet length */
 830 {
 831         struct sd *sd = (struct sd *) gspca_dev;
 832         struct gspca_frame *frame;
 833         unsigned char *sof;
 834
 835         sof = pac_find_sof(&sd->sof_read, data, len);
 836         if (sof) {
 837                 int n, lum_offset, footer_length;
 838
 839                 frame = gspca_get_i_frame(gspca_dev);
 840                 if (frame == NULL) {
 841                         gspca_dev->last_packet_type = DISCARD_PACKET;
 842                         return;
 843                 }
 844
 845                 /* 6 bytes after the FF D9 EOF marker a number of lumination
 846                    bytes are send corresponding to different parts of the
 847                    image, the 14th and 15th byte after the EOF seem to
 848                    correspond to the center of the image */
 849                 lum_offset = 61 + sizeof pac_sof_marker;
 850                 footer_length = 74;
 851
 852                 /* Finish decoding current frame */
 853                 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
 854                 if (n < 0) {
 855                         frame->data_end += n;
 856                         n = 0;
 857                 }
 858                 gspca_frame_add(gspca_dev, INTER_PACKET,
 859                                         data, n);
 860                 if (gspca_dev->last_packet_type != DISCARD_PACKET &&
 861                                 frame->data_end[-2] == 0xff &&
 862                                 frame->data_end[-1] == 0xd9)
 863                         gspca_frame_add(gspca_dev, LAST_PACKET,
 864                                                 NULL, 0);
 865
 866                 n = sof - data;
 867                 len -= n;
 868                 data = sof;
 869
 870                 /* Get average lumination */
 871                 if (gspca_dev->last_packet_type == LAST_PACKET &&
 872                                 n >= lum_offset)
 873                         atomic_set(&sd->avg_lum, data[-lum_offset] +
 874                                                 data[-lum_offset + 1]);
 875                 else
 876                         atomic_set(&sd->avg_lum, -1);
 877
 878                 /* Start the new frame with the jpeg header */
 879                 /* The PAC7302 has the image rotated 90 degrees */
 880                 pac_start_frame(gspca_dev, frame,
 881                         gspca_dev->width, gspca_dev->height);
 882         }
 883         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 884 }
 885
 886 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 887 {
 888         struct sd *sd = (struct sd *) gspca_dev;
 889
 890         sd->brightness = val;
 891         if (gspca_dev->streaming)
 892                 setbrightcont(gspca_dev);
 893         return gspca_dev->usb_err;
 894 }
 895
 896 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
 897 {
 898         struct sd *sd = (struct sd *) gspca_dev;
 899
 900         *val = sd->brightness;
 901         return 0;
 902 }
 903
 904 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
 905 {
 906         struct sd *sd = (struct sd *) gspca_dev;
 907
 908         sd->contrast = val;
 909         if (gspca_dev->streaming) {
 910                 setbrightcont(gspca_dev);
 911         }
 912         return gspca_dev->usb_err;
 913 }
 914
 915 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
 916 {
 917         struct sd *sd = (struct sd *) gspca_dev;
 918
 919         *val = sd->contrast;
 920         return 0;
 921 }
 922
 923 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
 924 {
 925         struct sd *sd = (struct sd *) gspca_dev;
 926
 927         sd->colors = val;
 928         if (gspca_dev->streaming)
 929                 setcolors(gspca_dev);
 930         return gspca_dev->usb_err;
 931 }
 932
 933 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
 934 {
 935         struct sd *sd = (struct sd *) gspca_dev;
 936
 937         *val = sd->colors;
 938         return 0;
 939 }
 940
 941 static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val)
 942 {
 943         struct sd *sd = (struct sd *) gspca_dev;
 944
 945         sd->white_balance = val;
 946         if (gspca_dev->streaming)
 947                 setwhitebalance(gspca_dev);
 948         return gspca_dev->usb_err;
 949 }
 950
 951 static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val)
 952 {
 953         struct sd *sd = (struct sd *) gspca_dev;
 954
 955         *val = sd->white_balance;
 956         return 0;
 957 }
 958
 959 static int sd_setredbalance(struct gspca_dev *gspca_dev, __s32 val)
 960 {
 961         struct sd *sd = (struct sd *) gspca_dev;
 962
 963         sd->red_balance = val;
 964         if (gspca_dev->streaming)
 965                 setredbalance(gspca_dev);
 966         return gspca_dev->usb_err;
 967 }
 968
 969 static int sd_getredbalance(struct gspca_dev *gspca_dev, __s32 *val)
 970 {
 971         struct sd *sd = (struct sd *) gspca_dev;
 972
 973         *val = sd->red_balance;
 974         return 0;
 975 }
 976
 977 static int sd_setbluebalance(struct gspca_dev *gspca_dev, __s32 val)
 978 {
 979         struct sd *sd = (struct sd *) gspca_dev;
 980
 981         sd->blue_balance = val;
 982         if (gspca_dev->streaming)
 983                 setbluebalance(gspca_dev);
 984         return gspca_dev->usb_err;
 985 }
 986
 987 static int sd_getbluebalance(struct gspca_dev *gspca_dev, __s32 *val)
 988 {
 989         struct sd *sd = (struct sd *) gspca_dev;
 990
 991         *val = sd->blue_balance;
 992         return 0;
 993 }
 994
 995 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
 996 {
 997         struct sd *sd = (struct sd *) gspca_dev;
 998
 999         sd->gain = val;
1000         if (gspca_dev->streaming)
1001                 setgain(gspca_dev);
1002         return gspca_dev->usb_err;
1003 }
1004
1005 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1006 {
1007         struct sd *sd = (struct sd *) gspca_dev;
1008
1009         *val = sd->gain;
1010         return 0;
1011 }
1012
1013 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1014 {
1015         struct sd *sd = (struct sd *) gspca_dev;
1016
1017         sd->exposure = val;
1018         if (gspca_dev->streaming)
1019                 setexposure(gspca_dev);
1020         return gspca_dev->usb_err;
1021 }
1022
1023 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1024 {
1025         struct sd *sd = (struct sd *) gspca_dev;
1026
1027         *val = sd->exposure;
1028         return 0;
1029 }
1030
1031 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1032 {
1033         struct sd *sd = (struct sd *) gspca_dev;
1034
1035         sd->autogain = val;
1036         /* when switching to autogain set defaults to make sure
1037            we are on a valid point of the autogain gain /
1038            exposure knee graph, and give this change time to
1039            take effect before doing autogain. */
1040         if (sd->autogain) {
1041                 sd->exposure = EXPOSURE_DEF;
1042                 sd->gain = GAIN_DEF;
1043                 if (gspca_dev->streaming) {
1044                         sd->autogain_ignore_frames =
1045                                 PAC_AUTOGAIN_IGNORE_FRAMES;
1046                         setexposure(gspca_dev);
1047                         setgain(gspca_dev);
1048                 }
1049         }
1050
1051         return gspca_dev->usb_err;
1052 }
1053
1054 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1055 {
1056         struct sd *sd = (struct sd *) gspca_dev;
1057
1058         *val = sd->autogain;
1059         return 0;
1060 }
1061
1062 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
1063 {
1064         struct sd *sd = (struct sd *) gspca_dev;
1065
1066         sd->hflip = val;
1067         if (gspca_dev->streaming)
1068                 sethvflip(gspca_dev);
1069         return gspca_dev->usb_err;
1070 }
1071
1072 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
1073 {
1074         struct sd *sd = (struct sd *) gspca_dev;
1075
1076         *val = sd->hflip;
1077         return 0;
1078 }
1079
1080 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
1081 {
1082         struct sd *sd = (struct sd *) gspca_dev;
1083
1084         sd->vflip = val;
1085         if (gspca_dev->streaming)
1086                 sethvflip(gspca_dev);
1087         return gspca_dev->usb_err;
1088 }
1089
1090 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
1091 {
1092         struct sd *sd = (struct sd *) gspca_dev;
1093
1094         *val = sd->vflip;
1095         return 0;
1096 }
1097
1098 #ifdef CONFIG_VIDEO_ADV_DEBUG
1099 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
1100                         struct v4l2_dbg_register *reg)
1101 {
1102         __u8 index;
1103         __u8 value;
1104
1105         /* reg->reg: bit0..15: reserved for register index (wIndex is 16bit
1106                                long on the USB bus)
1107         */
1108         if (reg->match.type == V4L2_CHIP_MATCH_HOST &&
1109             reg->match.addr == 0 &&
1110             (reg->reg < 0x000000ff) &&
1111             (reg->val <= 0x000000ff)
1112         ) {
1113                 /* Currently writing to page 0 is only supported. */
1114                 /* reg_w() only supports 8bit index */
1115                 index = reg->reg & 0x000000ff;
1116                 value = reg->val & 0x000000ff;
1117
1118                 /* Note that there shall be no access to other page
1119                    by any other function between the page swith and
1120                    the actual register write */
1121                 reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
1122                 reg_w(gspca_dev, index, value);
1123
1124                 reg_w(gspca_dev, 0xdc, 0x01);
1125         }
1126         return gspca_dev->usb_err;
1127 }
1128
1129 static int sd_chip_ident(struct gspca_dev *gspca_dev,
1130                         struct v4l2_dbg_chip_ident *chip)
1131 {
1132         int ret = -EINVAL;
1133
1134         if (chip->match.type == V4L2_CHIP_MATCH_HOST &&
1135             chip->match.addr == 0) {
1136                 chip->revision = 0;
1137                 chip->ident = V4L2_IDENT_UNKNOWN;
1138                 ret = 0;
1139         }
1140         return ret;
1141 }
1142 #endif
1143
1144 #ifdef CONFIG_INPUT
1145 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1146                         u8 *data,               /* interrupt packet data */
1147                         int len)                /* interrput packet length */
1148 {
1149         int ret = -EINVAL;
1150         u8 data0, data1;
1151
1152         if (len == 2) {
1153                 data0 = data[0];
1154                 data1 = data[1];
1155                 if ((data0 == 0x00 && data1 == 0x11) ||
1156                     (data0 == 0x22 && data1 == 0x33) ||
1157                     (data0 == 0x44 && data1 == 0x55) ||
1158                     (data0 == 0x66 && data1 == 0x77) ||
1159                     (data0 == 0x88 && data1 == 0x99) ||
1160                     (data0 == 0xaa && data1 == 0xbb) ||
1161                     (data0 == 0xcc && data1 == 0xdd) ||
1162                     (data0 == 0xee && data1 == 0xff)) {
1163                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1164                         input_sync(gspca_dev->input_dev);
1165                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1166                         input_sync(gspca_dev->input_dev);
1167                         ret = 0;
1168                 }
1169         }
1170
1171         return ret;
1172 }
1173 #endif
1174
1175 /* sub-driver description for pac7302 */
1176 static const struct sd_desc sd_desc = {
1177         .name = MODULE_NAME,
1178         .ctrls = sd_ctrls,
1179         .nctrls = ARRAY_SIZE(sd_ctrls),
1180         .config = sd_config,
1181         .init = sd_init,
1182         .start = sd_start,
1183         .stopN = sd_stopN,
1184         .stop0 = sd_stop0,
1185         .pkt_scan = sd_pkt_scan,
1186         .dq_callback = do_autogain,
1187 #ifdef CONFIG_VIDEO_ADV_DEBUG
1188         .set_register = sd_dbg_s_register,
1189         .get_chip_ident = sd_chip_ident,
1190 #endif
1191 #ifdef CONFIG_INPUT
1192         .int_pkt_scan = sd_int_pkt_scan,
1193 #endif
1194 };
1195
1196 /* -- module initialisation -- */
1197 static const struct usb_device_id device_table[] __devinitconst = {
1198         {USB_DEVICE(0x06f8, 0x3009)},
1199         {USB_DEVICE(0x093a, 0x2620)},
1200         {USB_DEVICE(0x093a, 0x2621)},
1201         {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP},
1202         {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP},
1203         {USB_DEVICE(0x093a, 0x2626)},
1204         {USB_DEVICE(0x093a, 0x2628)},
1205         {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP},
1206         {USB_DEVICE(0x093a, 0x262a)},
1207         {USB_DEVICE(0x093a, 0x262c)},
1208         {}
1209 };
1210 MODULE_DEVICE_TABLE(usb, device_table);
1211
1212 /* -- device connect -- */
1213 static int __devinit sd_probe(struct usb_interface *intf,
1214                         const struct usb_device_id *id)
1215 {
1216         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1217                                 THIS_MODULE);
1218 }
1219
1220 static struct usb_driver sd_driver = {
1221         .name = MODULE_NAME,
1222         .id_table = device_table,
1223         .probe = sd_probe,
1224         .disconnect = gspca_disconnect,
1225 #ifdef CONFIG_PM
1226         .suspend = gspca_suspend,
1227         .resume = gspca_resume,
1228 #endif
1229 };
1230
1231 /* -- module insert / remove -- */
1232 static int __init sd_mod_init(void)
1233 {
1234         int ret;
1235         ret = usb_register(&sd_driver);
1236         if (ret < 0)
1237                 return ret;
1238         PDEBUG(D_PROBE, "registered");
1239         return 0;
1240 }
1241 static void __exit sd_mod_exit(void)
1242 {
1243         usb_deregister(&sd_driver);
1244         PDEBUG(D_PROBE, "deregistered");
1245 }
1246
1247 module_init(sd_mod_init);
1248 module_exit(sd_mod_exit);