drivers/media/video/gspca/pac7311.c

   1 /*
   2  *              Pixart PAC7311 library
   3  *              Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
   4  *
   5  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21
  22 /* Some documentation about various registers as determined by trial and error.
  23    When the register addresses differ between the 7202 and the 7311 the 2
  24    different addresses are written as 7302addr/7311addr, when one of the 2
  25    addresses is a - sign that register description is not valid for the
  26    matching IC.
  27
  28    Register page 1:
  29
  30    Address      Description
  31    -/0x08       Unknown compressor related, must always be 8 except when not
  32                 in 640x480 resolution and page 4 reg 2 <= 3 then set it to 9 !
  33    -/0x1b       Auto white balance related, bit 0 is AWB enable (inverted)
  34                 bits 345 seem to toggle per color gains on/off (inverted)
  35    0x78         Global control, bit 6 controls the LED (inverted)
  36    -/0x80       JPEG compression ratio ? Best not touched
  37
  38    Register page 3/4:
  39
  40    Address      Description
  41    0x02         Clock divider 2-63, fps =~ 60 / val. Must be a multiple of 3 on
  42                 the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
  43    -/0x0f       Master gain 1-245, low value = high gain
  44    0x10/-       Master gain 0-31
  45    -/0x10       Another gain 0-15, limited influence (1-2x gain I guess)
  46    0x21         Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
  47    -/0x27       Seems to toggle various gains on / off, Setting bit 7 seems to
  48                 completely disable the analog amplification block. Set to 0x68
  49                 for max gain, 0x14 for minimal gain.
  50 */
  51
  52 #define MODULE_NAME "pac7311"
  53
  54 #include <linux/input.h>
  55 #include "gspca.h"
  56
  57 MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li");
  58 MODULE_DESCRIPTION("Pixart PAC7311");
  59 MODULE_LICENSE("GPL");
  60
  61 /* specific webcam descriptor for pac7311 */
  62 struct sd {
  63         struct gspca_dev gspca_dev;             /* !! must be the first item */
  64
  65         unsigned char contrast;
  66         unsigned char gain;
  67         unsigned char exposure;
  68         unsigned char autogain;
  69         __u8 hflip;
  70         __u8 vflip;
  71
  72         u8 sof_read;
  73         u8 autogain_ignore_frames;
  74
  75         atomic_t avg_lum;
  76 };
  77
  78 /* V4L2 controls supported by the driver */
  79 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  80 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  81 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
  82 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
  83 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
  84 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
  85 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
  86 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
  87 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
  88 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
  89 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
  90 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
  91
  92 static const struct ctrl sd_ctrls[] = {
  93 /* This control is for both the 7302 and the 7311 */
  94         {
  95             {
  96                 .id      = V4L2_CID_CONTRAST,
  97                 .type    = V4L2_CTRL_TYPE_INTEGER,
  98                 .name    = "Contrast",
  99                 .minimum = 0,
 100 #define CONTRAST_MAX 255
 101                 .maximum = CONTRAST_MAX,
 102                 .step    = 1,
 103 #define CONTRAST_DEF 127
 104                 .default_value = CONTRAST_DEF,
 105             },
 106             .set = sd_setcontrast,
 107             .get = sd_getcontrast,
 108         },
 109 /* All controls below are for both the 7302 and the 7311 */
 110         {
 111             {
 112                 .id      = V4L2_CID_GAIN,
 113                 .type    = V4L2_CTRL_TYPE_INTEGER,
 114                 .name    = "Gain",
 115                 .minimum = 0,
 116 #define GAIN_MAX 255
 117                 .maximum = GAIN_MAX,
 118                 .step    = 1,
 119 #define GAIN_DEF 127
 120 #define GAIN_KNEE 255 /* Gain seems to cause little noise on the pac73xx */
 121                 .default_value = GAIN_DEF,
 122             },
 123             .set = sd_setgain,
 124             .get = sd_getgain,
 125         },
 126         {
 127             {
 128                 .id      = V4L2_CID_EXPOSURE,
 129                 .type    = V4L2_CTRL_TYPE_INTEGER,
 130                 .name    = "Exposure",
 131                 .minimum = 0,
 132 #define EXPOSURE_MAX 255
 133                 .maximum = EXPOSURE_MAX,
 134                 .step    = 1,
 135 #define EXPOSURE_DEF  16 /*  32 ms / 30 fps */
 136 #define EXPOSURE_KNEE 50 /* 100 ms / 10 fps */
 137                 .default_value = EXPOSURE_DEF,
 138             },
 139             .set = sd_setexposure,
 140             .get = sd_getexposure,
 141         },
 142         {
 143             {
 144                 .id      = V4L2_CID_AUTOGAIN,
 145                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 146                 .name    = "Auto Gain",
 147                 .minimum = 0,
 148                 .maximum = 1,
 149                 .step    = 1,
 150 #define AUTOGAIN_DEF 1
 151                 .default_value = AUTOGAIN_DEF,
 152             },
 153             .set = sd_setautogain,
 154             .get = sd_getautogain,
 155         },
 156         {
 157             {
 158                 .id      = V4L2_CID_HFLIP,
 159                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 160                 .name    = "Mirror",
 161                 .minimum = 0,
 162                 .maximum = 1,
 163                 .step    = 1,
 164 #define HFLIP_DEF 0
 165                 .default_value = HFLIP_DEF,
 166             },
 167             .set = sd_sethflip,
 168             .get = sd_gethflip,
 169         },
 170         {
 171             {
 172                 .id      = V4L2_CID_VFLIP,
 173                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 174                 .name    = "Vflip",
 175                 .minimum = 0,
 176                 .maximum = 1,
 177                 .step    = 1,
 178 #define VFLIP_DEF 0
 179                 .default_value = VFLIP_DEF,
 180             },
 181             .set = sd_setvflip,
 182             .get = sd_getvflip,
 183         },
 184 };
 185
 186 static const struct v4l2_pix_format vga_mode[] = {
 187         {160, 120, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
 188                 .bytesperline = 160,
 189                 .sizeimage = 160 * 120 * 3 / 8 + 590,
 190                 .colorspace = V4L2_COLORSPACE_JPEG,
 191                 .priv = 2},
 192         {320, 240, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
 193                 .bytesperline = 320,
 194                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 195                 .colorspace = V4L2_COLORSPACE_JPEG,
 196                 .priv = 1},
 197         {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
 198                 .bytesperline = 640,
 199                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 200                 .colorspace = V4L2_COLORSPACE_JPEG,
 201                 .priv = 0},
 202 };
 203
 204 #define LOAD_PAGE4              254
 205 #define END_OF_SEQUENCE         0
 206
 207 /* pac 7311 */
 208 static const __u8 init_7311[] = {
 209         0x78, 0x40,     /* Bit_0=start stream, Bit_6=LED */
 210         0x78, 0x40,     /* Bit_0=start stream, Bit_6=LED */
 211         0x78, 0x44,     /* Bit_0=start stream, Bit_6=LED */
 212         0xff, 0x04,
 213         0x27, 0x80,
 214         0x28, 0xca,
 215         0x29, 0x53,
 216         0x2a, 0x0e,
 217         0xff, 0x01,
 218         0x3e, 0x20,
 219 };
 220
 221 static const __u8 start_7311[] = {
 222 /*      index, len, [value]* */
 223         0xff, 1,        0x01,           /* page 1 */
 224         0x02, 43,       0x48, 0x0a, 0x40, 0x08, 0x00, 0x00, 0x08, 0x00,
 225                         0x06, 0xff, 0x11, 0xff, 0x5a, 0x30, 0x90, 0x4c,
 226                         0x00, 0x07, 0x00, 0x0a, 0x10, 0x00, 0xa0, 0x10,
 227                         0x02, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x01, 0x00,
 228                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 229                         0x00, 0x00, 0x00,
 230         0x3e, 42,       0x00, 0x00, 0x78, 0x52, 0x4a, 0x52, 0x78, 0x6e,
 231                         0x48, 0x46, 0x48, 0x6e, 0x5f, 0x49, 0x42, 0x49,
 232                         0x5f, 0x5f, 0x49, 0x42, 0x49, 0x5f, 0x6e, 0x48,
 233                         0x46, 0x48, 0x6e, 0x78, 0x52, 0x4a, 0x52, 0x78,
 234                         0x00, 0x00, 0x09, 0x1b, 0x34, 0x49, 0x5c, 0x9b,
 235                         0xd0, 0xff,
 236         0x78, 6,        0x44, 0x00, 0xf2, 0x01, 0x01, 0x80,
 237         0x7f, 18,       0x2a, 0x1c, 0x00, 0xc8, 0x02, 0x58, 0x03, 0x84,
 238                         0x12, 0x00, 0x1a, 0x04, 0x08, 0x0c, 0x10, 0x14,
 239                         0x18, 0x20,
 240         0x96, 3,        0x01, 0x08, 0x04,
 241         0xa0, 4,        0x44, 0x44, 0x44, 0x04,
 242         0xf0, 13,       0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x20, 0x00,
 243                         0x3f, 0x00, 0x0a, 0x01, 0x00,
 244         0xff, 1,        0x04,           /* page 4 */
 245         0, LOAD_PAGE4,                  /* load the page 4 */
 246         0x11, 1,        0x01,
 247         0, END_OF_SEQUENCE              /* end of sequence */
 248 };
 249
 250 #define SKIP            0xaa
 251 /* page 4 - the value SKIP says skip the index - see reg_w_page() */
 252 static const __u8 page4_7311[] = {
 253         SKIP, SKIP, 0x04, 0x54, 0x07, 0x2b, 0x09, 0x0f,
 254         0x09, 0x00, SKIP, SKIP, 0x07, 0x00, 0x00, 0x62,
 255         0x08, SKIP, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
 256         0x00, 0x00, 0x00, 0x03, 0xa0, 0x01, 0xf4, SKIP,
 257         SKIP, 0x00, 0x08, SKIP, 0x03, SKIP, 0x00, 0x68,
 258         0xca, 0x10, 0x06, 0x78, 0x00, 0x00, 0x00, 0x00,
 259         0x23, 0x28, 0x04, 0x11, 0x00, 0x00
 260 };
 261
 262 static void reg_w_buf(struct gspca_dev *gspca_dev,
 263                   __u8 index,
 264                   const char *buffer, int len)
 265 {
 266         int ret;
 267
 268         if (gspca_dev->usb_err < 0)
 269                 return;
 270         memcpy(gspca_dev->usb_buf, buffer, len);
 271         ret = usb_control_msg(gspca_dev->dev,
 272                         usb_sndctrlpipe(gspca_dev->dev, 0),
 273                         0,              /* request */
 274                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 275                         0,              /* value */
 276                         index, gspca_dev->usb_buf, len,
 277                         500);
 278         if (ret < 0) {
 279                 PDEBUG(D_ERR, "reg_w_buf(): "
 280                 "Failed to write registers to index 0x%x, error %i",
 281                 index, ret);
 282                 gspca_dev->usb_err = ret;
 283         }
 284 }
 285
 286
 287 static void reg_w(struct gspca_dev *gspca_dev,
 288                   __u8 index,
 289                   __u8 value)
 290 {
 291         int ret;
 292
 293         if (gspca_dev->usb_err < 0)
 294                 return;
 295         gspca_dev->usb_buf[0] = value;
 296         ret = usb_control_msg(gspca_dev->dev,
 297                         usb_sndctrlpipe(gspca_dev->dev, 0),
 298                         0,                      /* request */
 299                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 300                         0, index, gspca_dev->usb_buf, 1,
 301                         500);
 302         if (ret < 0) {
 303                 PDEBUG(D_ERR, "reg_w(): "
 304                 "Failed to write register to index 0x%x, value 0x%x, error %i",
 305                 index, value, ret);
 306                 gspca_dev->usb_err = ret;
 307         }
 308 }
 309
 310 static void reg_w_seq(struct gspca_dev *gspca_dev,
 311                 const __u8 *seq, int len)
 312 {
 313         while (--len >= 0) {
 314                 reg_w(gspca_dev, seq[0], seq[1]);
 315                 seq += 2;
 316         }
 317 }
 318
 319 /* load the beginning of a page */
 320 static void reg_w_page(struct gspca_dev *gspca_dev,
 321                         const __u8 *page, int len)
 322 {
 323         int index;
 324         int ret = 0;
 325
 326         if (gspca_dev->usb_err < 0)
 327                 return;
 328         for (index = 0; index < len; index++) {
 329                 if (page[index] == SKIP)                /* skip this index */
 330                         continue;
 331                 gspca_dev->usb_buf[0] = page[index];
 332                 ret = usb_control_msg(gspca_dev->dev,
 333                                 usb_sndctrlpipe(gspca_dev->dev, 0),
 334                                 0,                      /* request */
 335                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 336                                 0, index, gspca_dev->usb_buf, 1,
 337                                 500);
 338                 if (ret < 0) {
 339                         PDEBUG(D_ERR, "reg_w_page(): "
 340                         "Failed to write register to index 0x%x, "
 341                         "value 0x%x, error %i",
 342                         index, page[index], ret);
 343                         gspca_dev->usb_err = ret;
 344                         break;
 345                 }
 346         }
 347 }
 348
 349 /* output a variable sequence */
 350 static void reg_w_var(struct gspca_dev *gspca_dev,
 351                         const __u8 *seq,
 352                         const __u8 *page4, unsigned int page4_len)
 353 {
 354         int index, len;
 355
 356         for (;;) {
 357                 index = *seq++;
 358                 len = *seq++;
 359                 switch (len) {
 360                 case END_OF_SEQUENCE:
 361                         return;
 362                 case LOAD_PAGE4:
 363                         reg_w_page(gspca_dev, page4, page4_len);
 364                         break;
 365                 default:
 366                         if (len > USB_BUF_SZ) {
 367                                 PDEBUG(D_ERR|D_STREAM,
 368                                         "Incorrect variable sequence");
 369                                 return;
 370                         }
 371                         while (len > 0) {
 372                                 if (len < 8) {
 373                                         reg_w_buf(gspca_dev,
 374                                                 index, seq, len);
 375                                         seq += len;
 376                                         break;
 377                                 }
 378                                 reg_w_buf(gspca_dev, index, seq, 8);
 379                                 seq += 8;
 380                                 index += 8;
 381                                 len -= 8;
 382                         }
 383                 }
 384         }
 385         /* not reached */
 386 }
 387
 388 /* this function is called at probe time for pac7311 */
 389 static int sd_config(struct gspca_dev *gspca_dev,
 390                         const struct usb_device_id *id)
 391 {
 392         struct sd *sd = (struct sd *) gspca_dev;
 393         struct cam *cam;
 394
 395         cam = &gspca_dev->cam;
 396
 397         PDEBUG(D_CONF, "Find Sensor PAC7311");
 398         cam->cam_mode = vga_mode;
 399         cam->nmodes = ARRAY_SIZE(vga_mode);
 400
 401         sd->contrast = CONTRAST_DEF;
 402         sd->gain = GAIN_DEF;
 403         sd->exposure = EXPOSURE_DEF;
 404         sd->autogain = AUTOGAIN_DEF;
 405         sd->hflip = HFLIP_DEF;
 406         sd->vflip = VFLIP_DEF;
 407         return 0;
 408 }
 409
 410 /* This function is used by pac7311 only */
 411 static void setcontrast(struct gspca_dev *gspca_dev)
 412 {
 413         struct sd *sd = (struct sd *) gspca_dev;
 414
 415         reg_w(gspca_dev, 0xff, 0x04);
 416         reg_w(gspca_dev, 0x10, sd->contrast >> 4);
 417         /* load registers to sensor (Bit 0, auto clear) */
 418         reg_w(gspca_dev, 0x11, 0x01);
 419 }
 420
 421 static void setgain(struct gspca_dev *gspca_dev)
 422 {
 423         struct sd *sd = (struct sd *) gspca_dev;
 424         int gain = GAIN_MAX - sd->gain;
 425
 426         if (gain < 1)
 427                 gain = 1;
 428         else if (gain > 245)
 429                 gain = 245;
 430         reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
 431         reg_w(gspca_dev, 0x0e, 0x00);
 432         reg_w(gspca_dev, 0x0f, gain);
 433
 434         /* load registers to sensor (Bit 0, auto clear) */
 435         reg_w(gspca_dev, 0x11, 0x01);
 436 }
 437
 438 static void setexposure(struct gspca_dev *gspca_dev)
 439 {
 440         struct sd *sd = (struct sd *) gspca_dev;
 441         __u8 reg;
 442
 443         /* register 2 of frame 3/4 contains the clock divider configuring the
 444            no fps according to the formula: 60 / reg. sd->exposure is the
 445            desired exposure time in ms. */
 446         reg = 120 * sd->exposure / 1000;
 447         if (reg < 2)
 448                 reg = 2;
 449         else if (reg > 63)
 450                 reg = 63;
 451
 452         reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
 453         reg_w(gspca_dev, 0x02, reg);
 454
 455         /* Page 1 register 8 must always be 0x08 except when not in
 456            640x480 mode and Page3/4 reg 2 <= 3 then it must be 9 */
 457         reg_w(gspca_dev, 0xff, 0x01);
 458         if (gspca_dev->cam.cam_mode[(int)gspca_dev->curr_mode].priv &&
 459                         reg <= 3) {
 460                 reg_w(gspca_dev, 0x08, 0x09);
 461         } else {
 462                 reg_w(gspca_dev, 0x08, 0x08);
 463         }
 464
 465         /* load registers to sensor (Bit 0, auto clear) */
 466         reg_w(gspca_dev, 0x11, 0x01);
 467 }
 468
 469 static void sethvflip(struct gspca_dev *gspca_dev)
 470 {
 471         struct sd *sd = (struct sd *) gspca_dev;
 472         __u8 data;
 473
 474         reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
 475         data = (sd->hflip ? 0x04 : 0x00) | (sd->vflip ? 0x08 : 0x00);
 476         reg_w(gspca_dev, 0x21, data);
 477
 478         /* load registers to sensor (Bit 0, auto clear) */
 479         reg_w(gspca_dev, 0x11, 0x01);
 480 }
 481
 482 /* this function is called at probe and resume time for pac7311 */
 483 static int sd_init(struct gspca_dev *gspca_dev)
 484 {
 485         reg_w_seq(gspca_dev, init_7311, sizeof(init_7311)/2);
 486         return gspca_dev->usb_err;
 487 }
 488
 489 static int sd_start(struct gspca_dev *gspca_dev)
 490 {
 491         struct sd *sd = (struct sd *) gspca_dev;
 492
 493         sd->sof_read = 0;
 494
 495         reg_w_var(gspca_dev, start_7311,
 496                 page4_7311, sizeof(page4_7311));
 497         setcontrast(gspca_dev);
 498         setgain(gspca_dev);
 499         setexposure(gspca_dev);
 500         sethvflip(gspca_dev);
 501
 502         /* set correct resolution */
 503         switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
 504         case 2:                                 /* 160x120 pac7311 */
 505                 reg_w(gspca_dev, 0xff, 0x01);
 506                 reg_w(gspca_dev, 0x17, 0x20);
 507                 reg_w(gspca_dev, 0x87, 0x10);
 508                 break;
 509         case 1:                                 /* 320x240 pac7311 */
 510                 reg_w(gspca_dev, 0xff, 0x01);
 511                 reg_w(gspca_dev, 0x17, 0x30);
 512                 reg_w(gspca_dev, 0x87, 0x11);
 513                 break;
 514         case 0:                                 /* 640x480 */
 515                 reg_w(gspca_dev, 0xff, 0x01);
 516                 reg_w(gspca_dev, 0x17, 0x00);
 517                 reg_w(gspca_dev, 0x87, 0x12);
 518                 break;
 519         }
 520
 521         sd->sof_read = 0;
 522         sd->autogain_ignore_frames = 0;
 523         atomic_set(&sd->avg_lum, -1);
 524
 525         /* start stream */
 526         reg_w(gspca_dev, 0xff, 0x01);
 527         reg_w(gspca_dev, 0x78, 0x05);
 528
 529         return gspca_dev->usb_err;
 530 }
 531
 532 static void sd_stopN(struct gspca_dev *gspca_dev)
 533 {
 534         reg_w(gspca_dev, 0xff, 0x04);
 535         reg_w(gspca_dev, 0x27, 0x80);
 536         reg_w(gspca_dev, 0x28, 0xca);
 537         reg_w(gspca_dev, 0x29, 0x53);
 538         reg_w(gspca_dev, 0x2a, 0x0e);
 539         reg_w(gspca_dev, 0xff, 0x01);
 540         reg_w(gspca_dev, 0x3e, 0x20);
 541         reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
 542         reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
 543         reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
 544 }
 545
 546 /* called on streamoff with alt 0 and on disconnect for 7311 */
 547 static void sd_stop0(struct gspca_dev *gspca_dev)
 548 {
 549 }
 550
 551 /* Include pac common sof detection functions */
 552 #include "pac_common.h"
 553
 554 static void do_autogain(struct gspca_dev *gspca_dev)
 555 {
 556         struct sd *sd = (struct sd *) gspca_dev;
 557         int avg_lum = atomic_read(&sd->avg_lum);
 558         int desired_lum, deadzone;
 559
 560         if (avg_lum == -1)
 561                 return;
 562
 563         desired_lum = 200;
 564         deadzone = 20;
 565
 566         if (sd->autogain_ignore_frames > 0)
 567                 sd->autogain_ignore_frames--;
 568         else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum, desired_lum,
 569                         deadzone, GAIN_KNEE, EXPOSURE_KNEE))
 570                 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
 571 }
 572
 573 /* JPEG header, part 1 */
 574 static const unsigned char pac_jpeg_header1[] = {
 575   0xff, 0xd8,           /* SOI: Start of Image */
 576
 577   0xff, 0xc0,           /* SOF0: Start of Frame (Baseline DCT) */
 578   0x00, 0x11,           /* length = 17 bytes (including this length field) */
 579   0x08                  /* Precision: 8 */
 580   /* 2 bytes is placed here: number of image lines */
 581   /* 2 bytes is placed here: samples per line */
 582 };
 583
 584 /* JPEG header, continued */
 585 static const unsigned char pac_jpeg_header2[] = {
 586   0x03,                 /* Number of image components: 3 */
 587   0x01, 0x21, 0x00,     /* ID=1, Subsampling 1x1, Quantization table: 0 */
 588   0x02, 0x11, 0x01,     /* ID=2, Subsampling 2x1, Quantization table: 1 */
 589   0x03, 0x11, 0x01,     /* ID=3, Subsampling 2x1, Quantization table: 1 */
 590
 591   0xff, 0xda,           /* SOS: Start Of Scan */
 592   0x00, 0x0c,           /* length = 12 bytes (including this length field) */
 593   0x03,                 /* number of components: 3 */
 594   0x01, 0x00,           /* selector 1, table 0x00 */
 595   0x02, 0x11,           /* selector 2, table 0x11 */
 596   0x03, 0x11,           /* selector 3, table 0x11 */
 597   0x00, 0x3f,           /* Spectral selection: 0 .. 63 */
 598   0x00                  /* Successive approximation: 0 */
 599 };
 600
 601 static void pac_start_frame(struct gspca_dev *gspca_dev,
 602                 __u16 lines, __u16 samples_per_line)
 603 {
 604         unsigned char tmpbuf[4];
 605
 606         gspca_frame_add(gspca_dev, FIRST_PACKET,
 607                 pac_jpeg_header1, sizeof(pac_jpeg_header1));
 608
 609         tmpbuf[0] = lines >> 8;
 610         tmpbuf[1] = lines & 0xff;
 611         tmpbuf[2] = samples_per_line >> 8;
 612         tmpbuf[3] = samples_per_line & 0xff;
 613
 614         gspca_frame_add(gspca_dev, INTER_PACKET,
 615                 tmpbuf, sizeof(tmpbuf));
 616         gspca_frame_add(gspca_dev, INTER_PACKET,
 617                 pac_jpeg_header2, sizeof(pac_jpeg_header2));
 618 }
 619
 620 /* this function is run at interrupt level */
 621 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 622                         u8 *data,                       /* isoc packet */
 623                         int len)                        /* iso packet length */
 624 {
 625         struct sd *sd = (struct sd *) gspca_dev;
 626         u8 *image;
 627         unsigned char *sof;
 628
 629         sof = pac_find_sof(&sd->sof_read, data, len);
 630         if (sof) {
 631                 int n, lum_offset, footer_length;
 632
 633                 /* 6 bytes after the FF D9 EOF marker a number of lumination
 634                    bytes are send corresponding to different parts of the
 635                    image, the 14th and 15th byte after the EOF seem to
 636                    correspond to the center of the image */
 637                 lum_offset = 24 + sizeof pac_sof_marker;
 638                 footer_length = 26;
 639
 640                 /* Finish decoding current frame */
 641                 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
 642                 if (n < 0) {
 643                         gspca_dev->image_len += n;
 644                         n = 0;
 645                 } else {
 646                         gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
 647                 }
 648                 image = gspca_dev->image;
 649                 if (image != NULL
 650                  && image[gspca_dev->image_len - 2] == 0xff
 651                  && image[gspca_dev->image_len - 1] == 0xd9)
 652                         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
 653
 654                 n = sof - data;
 655                 len -= n;
 656                 data = sof;
 657
 658                 /* Get average lumination */
 659                 if (gspca_dev->last_packet_type == LAST_PACKET &&
 660                                 n >= lum_offset)
 661                         atomic_set(&sd->avg_lum, data[-lum_offset] +
 662                                                 data[-lum_offset + 1]);
 663                 else
 664                         atomic_set(&sd->avg_lum, -1);
 665
 666                 /* Start the new frame with the jpeg header */
 667                 pac_start_frame(gspca_dev,
 668                         gspca_dev->height, gspca_dev->width);
 669         }
 670         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 671 }
 672
 673 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
 674 {
 675         struct sd *sd = (struct sd *) gspca_dev;
 676
 677         sd->contrast = val;
 678         if (gspca_dev->streaming) {
 679                 setcontrast(gspca_dev);
 680         }
 681         return gspca_dev->usb_err;
 682 }
 683
 684 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
 685 {
 686         struct sd *sd = (struct sd *) gspca_dev;
 687
 688         *val = sd->contrast;
 689         return 0;
 690 }
 691
 692 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
 693 {
 694         struct sd *sd = (struct sd *) gspca_dev;
 695
 696         sd->gain = val;
 697         if (gspca_dev->streaming)
 698                 setgain(gspca_dev);
 699         return gspca_dev->usb_err;
 700 }
 701
 702 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
 703 {
 704         struct sd *sd = (struct sd *) gspca_dev;
 705
 706         *val = sd->gain;
 707         return 0;
 708 }
 709
 710 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
 711 {
 712         struct sd *sd = (struct sd *) gspca_dev;
 713
 714         sd->exposure = val;
 715         if (gspca_dev->streaming)
 716                 setexposure(gspca_dev);
 717         return gspca_dev->usb_err;
 718 }
 719
 720 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
 721 {
 722         struct sd *sd = (struct sd *) gspca_dev;
 723
 724         *val = sd->exposure;
 725         return 0;
 726 }
 727
 728 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
 729 {
 730         struct sd *sd = (struct sd *) gspca_dev;
 731
 732         sd->autogain = val;
 733         /* when switching to autogain set defaults to make sure
 734            we are on a valid point of the autogain gain /
 735            exposure knee graph, and give this change time to
 736            take effect before doing autogain. */
 737         if (sd->autogain) {
 738                 sd->exposure = EXPOSURE_DEF;
 739                 sd->gain = GAIN_DEF;
 740                 if (gspca_dev->streaming) {
 741                         sd->autogain_ignore_frames =
 742                                 PAC_AUTOGAIN_IGNORE_FRAMES;
 743                         setexposure(gspca_dev);
 744                         setgain(gspca_dev);
 745                 }
 746         }
 747
 748         return gspca_dev->usb_err;
 749 }
 750
 751 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
 752 {
 753         struct sd *sd = (struct sd *) gspca_dev;
 754
 755         *val = sd->autogain;
 756         return 0;
 757 }
 758
 759 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
 760 {
 761         struct sd *sd = (struct sd *) gspca_dev;
 762
 763         sd->hflip = val;
 764         if (gspca_dev->streaming)
 765                 sethvflip(gspca_dev);
 766         return gspca_dev->usb_err;
 767 }
 768
 769 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
 770 {
 771         struct sd *sd = (struct sd *) gspca_dev;
 772
 773         *val = sd->hflip;
 774         return 0;
 775 }
 776
 777 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
 778 {
 779         struct sd *sd = (struct sd *) gspca_dev;
 780
 781         sd->vflip = val;
 782         if (gspca_dev->streaming)
 783                 sethvflip(gspca_dev);
 784         return gspca_dev->usb_err;
 785 }
 786
 787 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
 788 {
 789         struct sd *sd = (struct sd *) gspca_dev;
 790
 791         *val = sd->vflip;
 792         return 0;
 793 }
 794
 795 #ifdef CONFIG_INPUT
 796 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
 797                         u8 *data,               /* interrupt packet data */
 798                         int len)                /* interrupt packet length */
 799 {
 800         int ret = -EINVAL;
 801         u8 data0, data1;
 802
 803         if (len == 2) {
 804                 data0 = data[0];
 805                 data1 = data[1];
 806                 if ((data0 == 0x00 && data1 == 0x11) ||
 807                     (data0 == 0x22 && data1 == 0x33) ||
 808                     (data0 == 0x44 && data1 == 0x55) ||
 809                     (data0 == 0x66 && data1 == 0x77) ||
 810                     (data0 == 0x88 && data1 == 0x99) ||
 811                     (data0 == 0xaa && data1 == 0xbb) ||
 812                     (data0 == 0xcc && data1 == 0xdd) ||
 813                     (data0 == 0xee && data1 == 0xff)) {
 814                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
 815                         input_sync(gspca_dev->input_dev);
 816                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
 817                         input_sync(gspca_dev->input_dev);
 818                         ret = 0;
 819                 }
 820         }
 821
 822         return ret;
 823 }
 824 #endif
 825
 826 /* sub-driver description for pac7311 */
 827 static const struct sd_desc sd_desc = {
 828         .name = MODULE_NAME,
 829         .ctrls = sd_ctrls,
 830         .nctrls = ARRAY_SIZE(sd_ctrls),
 831         .config = sd_config,
 832         .init = sd_init,
 833         .start = sd_start,
 834         .stopN = sd_stopN,
 835         .stop0 = sd_stop0,
 836         .pkt_scan = sd_pkt_scan,
 837         .dq_callback = do_autogain,
 838 #ifdef CONFIG_INPUT
 839         .int_pkt_scan = sd_int_pkt_scan,
 840 #endif
 841 };
 842
 843 /* -- module initialisation -- */
 844 static const struct usb_device_id device_table[] __devinitconst = {
 845         {USB_DEVICE(0x093a, 0x2600)},
 846         {USB_DEVICE(0x093a, 0x2601)},
 847         {USB_DEVICE(0x093a, 0x2603)},
 848         {USB_DEVICE(0x093a, 0x2608)},
 849         {USB_DEVICE(0x093a, 0x260e)},
 850         {USB_DEVICE(0x093a, 0x260f)},
 851         {}
 852 };
 853 MODULE_DEVICE_TABLE(usb, device_table);
 854
 855 /* -- device connect -- */
 856 static int __devinit sd_probe(struct usb_interface *intf,
 857                         const struct usb_device_id *id)
 858 {
 859         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 860                                 THIS_MODULE);
 861 }
 862
 863 static struct usb_driver sd_driver = {
 864         .name = MODULE_NAME,
 865         .id_table = device_table,
 866         .probe = sd_probe,
 867         .disconnect = gspca_disconnect,
 868 #ifdef CONFIG_PM
 869         .suspend = gspca_suspend,
 870         .resume = gspca_resume,
 871 #endif
 872 };
 873
 874 /* -- module insert / remove -- */
 875 static int __init sd_mod_init(void)
 876 {
 877         int ret;
 878         ret = usb_register(&sd_driver);
 879         if (ret < 0)
 880                 return ret;
 881         PDEBUG(D_PROBE, "registered");
 882         return 0;
 883 }
 884 static void __exit sd_mod_exit(void)
 885 {
 886         usb_deregister(&sd_driver);
 887         PDEBUG(D_PROBE, "deregistered");
 888 }
 889
 890 module_init(sd_mod_init);
 891 module_exit(sd_mod_exit);