drivers/media/usb/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
  18 /* Some documentation about various registers as determined by trial and error.
  19  *
  20  * Register page 1:
  21  *
  22  * Address      Description
  23  * 0x08         Unknown compressor related, must always be 8 except when not
  24  *              in 640x480 resolution and page 4 reg 2 <= 3 then set it to 9 !
  25  * 0x1b         Auto white balance related, bit 0 is AWB enable (inverted)
  26  *              bits 345 seem to toggle per color gains on/off (inverted)
  27  * 0x78         Global control, bit 6 controls the LED (inverted)
  28  * 0x80         Compression balance, interesting settings:
  29  *              0x01 Use this to allow the camera to switch to higher compr.
  30  *                   on the fly. Needed to stay within bandwidth @ 640x480@30
  31  *              0x1c From usb captures under Windows for 640x480
  32  *              0x2a Values >= this switch the camera to a lower compression,
  33  *                   using the same table for both luminance and chrominance.
  34  *                   This gives a sharper picture. Usable only at 640x480@ <
  35  *                   15 fps or 320x240 / 160x120. Note currently the driver
  36  *                   does not use this as the quality gain is small and the
  37  *                   generated JPG-s are only understood by v4l-utils >= 0.8.9
  38  *              0x3f From usb captures under Windows for 320x240
  39  *              0x69 From usb captures under Windows for 160x120
  40  *
  41  * Register page 4:
  42  *
  43  * Address      Description
  44  * 0x02         Clock divider 2-63, fps =~ 60 / val. Must be a multiple of 3 on
  45  *              the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
  46  * 0x0f         Master gain 1-245, low value = high gain
  47  * 0x10         Another gain 0-15, limited influence (1-2x gain I guess)
  48  * 0x21         Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
  49  *              Note setting vflip disabled leads to a much lower image quality,
  50  *              so we always vflip, and tell userspace to flip it back
  51  * 0x27         Seems to toggle various gains on / off, Setting bit 7 seems to
  52  *              completely disable the analog amplification block. Set to 0x68
  53  *              for max gain, 0x14 for minimal gain.
  54  */
  55
  56 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  57
  58 #define MODULE_NAME "pac7311"
  59
  60 #include <linux/input.h>
  61 #include "gspca.h"
  62 /* Include pac common sof detection functions */
  63 #include "pac_common.h"
  64
  65 #define PAC7311_GAIN_DEFAULT     122
  66 #define PAC7311_EXPOSURE_DEFAULT   3 /* 20 fps, avoid using high compr. */
  67
  68 MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li");
  69 MODULE_DESCRIPTION("Pixart PAC7311");
  70 MODULE_LICENSE("GPL");
  71
  72 struct sd {
  73         struct gspca_dev gspca_dev;             /* !! must be the first item */
  74
  75         struct v4l2_ctrl *contrast;
  76         struct v4l2_ctrl *hflip;
  77
  78         u8 sof_read;
  79         u8 autogain_ignore_frames;
  80
  81         atomic_t avg_lum;
  82 };
  83
  84 static const struct v4l2_pix_format vga_mode[] = {
  85         {160, 120, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
  86                 .bytesperline = 160,
  87                 .sizeimage = 160 * 120 * 3 / 8 + 590,
  88                 .colorspace = V4L2_COLORSPACE_JPEG,
  89                 .priv = 2},
  90         {320, 240, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
  91                 .bytesperline = 320,
  92                 .sizeimage = 320 * 240 * 3 / 8 + 590,
  93                 .colorspace = V4L2_COLORSPACE_JPEG,
  94                 .priv = 1},
  95         {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
  96                 .bytesperline = 640,
  97                 .sizeimage = 640 * 480 * 3 / 8 + 590,
  98                 .colorspace = V4L2_COLORSPACE_JPEG,
  99                 .priv = 0},
 100 };
 101
 102 #define LOAD_PAGE4              254
 103 #define END_OF_SEQUENCE         0
 104
 105 static const __u8 init_7311[] = {
 106         0xff, 0x01,
 107         0x78, 0x40,     /* Bit_0=start stream, Bit_6=LED */
 108         0x78, 0x40,     /* Bit_0=start stream, Bit_6=LED */
 109         0x78, 0x44,     /* Bit_0=start stream, Bit_6=LED */
 110         0xff, 0x04,
 111         0x27, 0x80,
 112         0x28, 0xca,
 113         0x29, 0x53,
 114         0x2a, 0x0e,
 115         0xff, 0x01,
 116         0x3e, 0x20,
 117 };
 118
 119 static const __u8 start_7311[] = {
 120 /*      index, len, [value]* */
 121         0xff, 1,        0x01,           /* page 1 */
 122         0x02, 43,       0x48, 0x0a, 0x40, 0x08, 0x00, 0x00, 0x08, 0x00,
 123                         0x06, 0xff, 0x11, 0xff, 0x5a, 0x30, 0x90, 0x4c,
 124                         0x00, 0x07, 0x00, 0x0a, 0x10, 0x00, 0xa0, 0x10,
 125                         0x02, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x01, 0x00,
 126                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 127                         0x00, 0x00, 0x00,
 128         0x3e, 42,       0x00, 0x00, 0x78, 0x52, 0x4a, 0x52, 0x78, 0x6e,
 129                         0x48, 0x46, 0x48, 0x6e, 0x5f, 0x49, 0x42, 0x49,
 130                         0x5f, 0x5f, 0x49, 0x42, 0x49, 0x5f, 0x6e, 0x48,
 131                         0x46, 0x48, 0x6e, 0x78, 0x52, 0x4a, 0x52, 0x78,
 132                         0x00, 0x00, 0x09, 0x1b, 0x34, 0x49, 0x5c, 0x9b,
 133                         0xd0, 0xff,
 134         0x78, 6,        0x44, 0x00, 0xf2, 0x01, 0x01, 0x80,
 135         0x7f, 18,       0x2a, 0x1c, 0x00, 0xc8, 0x02, 0x58, 0x03, 0x84,
 136                         0x12, 0x00, 0x1a, 0x04, 0x08, 0x0c, 0x10, 0x14,
 137                         0x18, 0x20,
 138         0x96, 3,        0x01, 0x08, 0x04,
 139         0xa0, 4,        0x44, 0x44, 0x44, 0x04,
 140         0xf0, 13,       0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x20, 0x00,
 141                         0x3f, 0x00, 0x0a, 0x01, 0x00,
 142         0xff, 1,        0x04,           /* page 4 */
 143         0, LOAD_PAGE4,                  /* load the page 4 */
 144         0x11, 1,        0x01,
 145         0, END_OF_SEQUENCE              /* end of sequence */
 146 };
 147
 148 #define SKIP            0xaa
 149 /* page 4 - the value SKIP says skip the index - see reg_w_page() */
 150 static const __u8 page4_7311[] = {
 151         SKIP, SKIP, 0x04, 0x54, 0x07, 0x2b, 0x09, 0x0f,
 152         0x09, 0x00, SKIP, SKIP, 0x07, 0x00, 0x00, 0x62,
 153         0x08, SKIP, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
 154         0x00, 0x00, 0x00, 0x03, 0xa0, 0x01, 0xf4, SKIP,
 155         SKIP, 0x00, 0x08, SKIP, 0x03, SKIP, 0x00, 0x68,
 156         0xca, 0x10, 0x06, 0x78, 0x00, 0x00, 0x00, 0x00,
 157         0x23, 0x28, 0x04, 0x11, 0x00, 0x00
 158 };
 159
 160 static void reg_w_buf(struct gspca_dev *gspca_dev,
 161                   __u8 index,
 162                   const u8 *buffer, int len)
 163 {
 164         int ret;
 165
 166         if (gspca_dev->usb_err < 0)
 167                 return;
 168         memcpy(gspca_dev->usb_buf, buffer, len);
 169         ret = usb_control_msg(gspca_dev->dev,
 170                         usb_sndctrlpipe(gspca_dev->dev, 0),
 171                         0,              /* request */
 172                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 173                         0,              /* value */
 174                         index, gspca_dev->usb_buf, len,
 175                         500);
 176         if (ret < 0) {
 177                 pr_err("reg_w_buf() failed index 0x%02x, error %d\n",
 178                        index, ret);
 179                 gspca_dev->usb_err = ret;
 180         }
 181 }
 182
 183
 184 static void reg_w(struct gspca_dev *gspca_dev,
 185                   __u8 index,
 186                   __u8 value)
 187 {
 188         int ret;
 189
 190         if (gspca_dev->usb_err < 0)
 191                 return;
 192         gspca_dev->usb_buf[0] = value;
 193         ret = usb_control_msg(gspca_dev->dev,
 194                         usb_sndctrlpipe(gspca_dev->dev, 0),
 195                         0,                      /* request */
 196                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 197                         0, index, gspca_dev->usb_buf, 1,
 198                         500);
 199         if (ret < 0) {
 200                 pr_err("reg_w() failed index 0x%02x, value 0x%02x, error %d\n",
 201                        index, value, ret);
 202                 gspca_dev->usb_err = ret;
 203         }
 204 }
 205
 206 static void reg_w_seq(struct gspca_dev *gspca_dev,
 207                 const __u8 *seq, int len)
 208 {
 209         while (--len >= 0) {
 210                 reg_w(gspca_dev, seq[0], seq[1]);
 211                 seq += 2;
 212         }
 213 }
 214
 215 /* load the beginning of a page */
 216 static void reg_w_page(struct gspca_dev *gspca_dev,
 217                         const __u8 *page, int len)
 218 {
 219         int index;
 220         int ret = 0;
 221
 222         if (gspca_dev->usb_err < 0)
 223                 return;
 224         for (index = 0; index < len; index++) {
 225                 if (page[index] == SKIP)                /* skip this index */
 226                         continue;
 227                 gspca_dev->usb_buf[0] = page[index];
 228                 ret = usb_control_msg(gspca_dev->dev,
 229                                 usb_sndctrlpipe(gspca_dev->dev, 0),
 230                                 0,                      /* request */
 231                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 232                                 0, index, gspca_dev->usb_buf, 1,
 233                                 500);
 234                 if (ret < 0) {
 235                         pr_err("reg_w_page() failed index 0x%02x, value 0x%02x, error %d\n",
 236                                index, page[index], ret);
 237                         gspca_dev->usb_err = ret;
 238                         break;
 239                 }
 240         }
 241 }
 242
 243 /* output a variable sequence */
 244 static void reg_w_var(struct gspca_dev *gspca_dev,
 245                         const __u8 *seq,
 246                         const __u8 *page4, unsigned int page4_len)
 247 {
 248         int index, len;
 249
 250         for (;;) {
 251                 index = *seq++;
 252                 len = *seq++;
 253                 switch (len) {
 254                 case END_OF_SEQUENCE:
 255                         return;
 256                 case LOAD_PAGE4:
 257                         reg_w_page(gspca_dev, page4, page4_len);
 258                         break;
 259                 default:
 260                         if (len > USB_BUF_SZ) {
 261                                 PERR("Incorrect variable sequence");
 262                                 return;
 263                         }
 264                         while (len > 0) {
 265                                 if (len < 8) {
 266                                         reg_w_buf(gspca_dev,
 267                                                 index, seq, len);
 268                                         seq += len;
 269                                         break;
 270                                 }
 271                                 reg_w_buf(gspca_dev, index, seq, 8);
 272                                 seq += 8;
 273                                 index += 8;
 274                                 len -= 8;
 275                         }
 276                 }
 277         }
 278         /* not reached */
 279 }
 280
 281 /* this function is called at probe time for pac7311 */
 282 static int sd_config(struct gspca_dev *gspca_dev,
 283                         const struct usb_device_id *id)
 284 {
 285         struct cam *cam = &gspca_dev->cam;
 286
 287         cam->cam_mode = vga_mode;
 288         cam->nmodes = ARRAY_SIZE(vga_mode);
 289         cam->input_flags = V4L2_IN_ST_VFLIP;
 290
 291         return 0;
 292 }
 293
 294 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
 295 {
 296         reg_w(gspca_dev, 0xff, 0x04);
 297         reg_w(gspca_dev, 0x10, val);
 298         /* load registers to sensor (Bit 0, auto clear) */
 299         reg_w(gspca_dev, 0x11, 0x01);
 300 }
 301
 302 static void setgain(struct gspca_dev *gspca_dev, s32 val)
 303 {
 304         reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
 305         reg_w(gspca_dev, 0x0e, 0x00);
 306         reg_w(gspca_dev, 0x0f, gspca_dev->gain->maximum - val + 1);
 307
 308         /* load registers to sensor (Bit 0, auto clear) */
 309         reg_w(gspca_dev, 0x11, 0x01);
 310 }
 311
 312 static void setexposure(struct gspca_dev *gspca_dev, s32 val)
 313 {
 314         reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
 315         reg_w(gspca_dev, 0x02, val);
 316
 317         /* load registers to sensor (Bit 0, auto clear) */
 318         reg_w(gspca_dev, 0x11, 0x01);
 319
 320         /*
 321          * Page 1 register 8 must always be 0x08 except when not in
 322          *  640x480 mode and page 4 reg 2 <= 3 then it must be 9
 323          */
 324         reg_w(gspca_dev, 0xff, 0x01);
 325         if (gspca_dev->pixfmt.width != 640 && val <= 3)
 326                 reg_w(gspca_dev, 0x08, 0x09);
 327         else
 328                 reg_w(gspca_dev, 0x08, 0x08);
 329
 330         /*
 331          * Page1 register 80 sets the compression balance, normally we
 332          * want / use 0x1c, but for 640x480@30fps we must allow the
 333          * camera to use higher compression or we may run out of
 334          * bandwidth.
 335          */
 336         if (gspca_dev->pixfmt.width == 640 && val == 2)
 337                 reg_w(gspca_dev, 0x80, 0x01);
 338         else
 339                 reg_w(gspca_dev, 0x80, 0x1c);
 340
 341         /* load registers to sensor (Bit 0, auto clear) */
 342         reg_w(gspca_dev, 0x11, 0x01);
 343 }
 344
 345 static void sethvflip(struct gspca_dev *gspca_dev, s32 hflip, s32 vflip)
 346 {
 347         __u8 data;
 348
 349         reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
 350         data = (hflip ? 0x04 : 0x00) |
 351                (vflip ? 0x08 : 0x00);
 352         reg_w(gspca_dev, 0x21, data);
 353
 354         /* load registers to sensor (Bit 0, auto clear) */
 355         reg_w(gspca_dev, 0x11, 0x01);
 356 }
 357
 358 /* this function is called at probe and resume time for pac7311 */
 359 static int sd_init(struct gspca_dev *gspca_dev)
 360 {
 361         reg_w_seq(gspca_dev, init_7311, sizeof(init_7311)/2);
 362         return gspca_dev->usb_err;
 363 }
 364
 365 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 366 {
 367         struct gspca_dev *gspca_dev =
 368                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 369         struct sd *sd = (struct sd *)gspca_dev;
 370
 371         gspca_dev->usb_err = 0;
 372
 373         if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
 374                 /* when switching to autogain set defaults to make sure
 375                    we are on a valid point of the autogain gain /
 376                    exposure knee graph, and give this change time to
 377                    take effect before doing autogain. */
 378                 gspca_dev->exposure->val    = PAC7311_EXPOSURE_DEFAULT;
 379                 gspca_dev->gain->val        = PAC7311_GAIN_DEFAULT;
 380                 sd->autogain_ignore_frames  = PAC_AUTOGAIN_IGNORE_FRAMES;
 381         }
 382
 383         if (!gspca_dev->streaming)
 384                 return 0;
 385
 386         switch (ctrl->id) {
 387         case V4L2_CID_CONTRAST:
 388                 setcontrast(gspca_dev, ctrl->val);
 389                 break;
 390         case V4L2_CID_AUTOGAIN:
 391                 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
 392                         setexposure(gspca_dev, gspca_dev->exposure->val);
 393                 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
 394                         setgain(gspca_dev, gspca_dev->gain->val);
 395                 break;
 396         case V4L2_CID_HFLIP:
 397                 sethvflip(gspca_dev, sd->hflip->val, 1);
 398                 break;
 399         default:
 400                 return -EINVAL;
 401         }
 402         return gspca_dev->usb_err;
 403 }
 404
 405 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 406         .s_ctrl = sd_s_ctrl,
 407 };
 408
 409 /* this function is called at probe time */
 410 static int sd_init_controls(struct gspca_dev *gspca_dev)
 411 {
 412         struct sd *sd = (struct sd *) gspca_dev;
 413         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 414
 415         gspca_dev->vdev.ctrl_handler = hdl;
 416         v4l2_ctrl_handler_init(hdl, 5);
 417
 418         sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 419                                         V4L2_CID_CONTRAST, 0, 15, 1, 7);
 420         gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 421                                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
 422         gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 423                                         V4L2_CID_EXPOSURE, 2, 63, 1,
 424                                         PAC7311_EXPOSURE_DEFAULT);
 425         gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 426                                         V4L2_CID_GAIN, 0, 244, 1,
 427                                         PAC7311_GAIN_DEFAULT);
 428         sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 429                 V4L2_CID_HFLIP, 0, 1, 1, 0);
 430
 431         if (hdl->error) {
 432                 pr_err("Could not initialize controls\n");
 433                 return hdl->error;
 434         }
 435
 436         v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
 437         return 0;
 438 }
 439
 440 /* -- start the camera -- */
 441 static int sd_start(struct gspca_dev *gspca_dev)
 442 {
 443         struct sd *sd = (struct sd *) gspca_dev;
 444
 445         sd->sof_read = 0;
 446
 447         reg_w_var(gspca_dev, start_7311,
 448                 page4_7311, sizeof(page4_7311));
 449         setcontrast(gspca_dev, v4l2_ctrl_g_ctrl(sd->contrast));
 450         setgain(gspca_dev, v4l2_ctrl_g_ctrl(gspca_dev->gain));
 451         setexposure(gspca_dev, v4l2_ctrl_g_ctrl(gspca_dev->exposure));
 452         sethvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip), 1);
 453
 454         /* set correct resolution */
 455         switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
 456         case 2:                                 /* 160x120 */
 457                 reg_w(gspca_dev, 0xff, 0x01);
 458                 reg_w(gspca_dev, 0x17, 0x20);
 459                 reg_w(gspca_dev, 0x87, 0x10);
 460                 break;
 461         case 1:                                 /* 320x240 */
 462                 reg_w(gspca_dev, 0xff, 0x01);
 463                 reg_w(gspca_dev, 0x17, 0x30);
 464                 reg_w(gspca_dev, 0x87, 0x11);
 465                 break;
 466         case 0:                                 /* 640x480 */
 467                 reg_w(gspca_dev, 0xff, 0x01);
 468                 reg_w(gspca_dev, 0x17, 0x00);
 469                 reg_w(gspca_dev, 0x87, 0x12);
 470                 break;
 471         }
 472
 473         sd->sof_read = 0;
 474         sd->autogain_ignore_frames = 0;
 475         atomic_set(&sd->avg_lum, -1);
 476
 477         /* start stream */
 478         reg_w(gspca_dev, 0xff, 0x01);
 479         reg_w(gspca_dev, 0x78, 0x05);
 480
 481         return gspca_dev->usb_err;
 482 }
 483
 484 static void sd_stopN(struct gspca_dev *gspca_dev)
 485 {
 486         reg_w(gspca_dev, 0xff, 0x04);
 487         reg_w(gspca_dev, 0x27, 0x80);
 488         reg_w(gspca_dev, 0x28, 0xca);
 489         reg_w(gspca_dev, 0x29, 0x53);
 490         reg_w(gspca_dev, 0x2a, 0x0e);
 491         reg_w(gspca_dev, 0xff, 0x01);
 492         reg_w(gspca_dev, 0x3e, 0x20);
 493         reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
 494         reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
 495         reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
 496 }
 497
 498 static void do_autogain(struct gspca_dev *gspca_dev)
 499 {
 500         struct sd *sd = (struct sd *) gspca_dev;
 501         int avg_lum = atomic_read(&sd->avg_lum);
 502         int desired_lum, deadzone;
 503
 504         if (avg_lum == -1)
 505                 return;
 506
 507         desired_lum = 170;
 508         deadzone = 20;
 509
 510         if (sd->autogain_ignore_frames > 0)
 511                 sd->autogain_ignore_frames--;
 512         else if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
 513                                                     desired_lum, deadzone))
 514                 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
 515 }
 516
 517 /* JPEG header, part 1 */
 518 static const unsigned char pac_jpeg_header1[] = {
 519   0xff, 0xd8,           /* SOI: Start of Image */
 520
 521   0xff, 0xc0,           /* SOF0: Start of Frame (Baseline DCT) */
 522   0x00, 0x11,           /* length = 17 bytes (including this length field) */
 523   0x08                  /* Precision: 8 */
 524   /* 2 bytes is placed here: number of image lines */
 525   /* 2 bytes is placed here: samples per line */
 526 };
 527
 528 /* JPEG header, continued */
 529 static const unsigned char pac_jpeg_header2[] = {
 530   0x03,                 /* Number of image components: 3 */
 531   0x01, 0x21, 0x00,     /* ID=1, Subsampling 1x1, Quantization table: 0 */
 532   0x02, 0x11, 0x01,     /* ID=2, Subsampling 2x1, Quantization table: 1 */
 533   0x03, 0x11, 0x01,     /* ID=3, Subsampling 2x1, Quantization table: 1 */
 534
 535   0xff, 0xda,           /* SOS: Start Of Scan */
 536   0x00, 0x0c,           /* length = 12 bytes (including this length field) */
 537   0x03,                 /* number of components: 3 */
 538   0x01, 0x00,           /* selector 1, table 0x00 */
 539   0x02, 0x11,           /* selector 2, table 0x11 */
 540   0x03, 0x11,           /* selector 3, table 0x11 */
 541   0x00, 0x3f,           /* Spectral selection: 0 .. 63 */
 542   0x00                  /* Successive approximation: 0 */
 543 };
 544
 545 static void pac_start_frame(struct gspca_dev *gspca_dev,
 546                 __u16 lines, __u16 samples_per_line)
 547 {
 548         unsigned char tmpbuf[4];
 549
 550         gspca_frame_add(gspca_dev, FIRST_PACKET,
 551                 pac_jpeg_header1, sizeof(pac_jpeg_header1));
 552
 553         tmpbuf[0] = lines >> 8;
 554         tmpbuf[1] = lines & 0xff;
 555         tmpbuf[2] = samples_per_line >> 8;
 556         tmpbuf[3] = samples_per_line & 0xff;
 557
 558         gspca_frame_add(gspca_dev, INTER_PACKET,
 559                 tmpbuf, sizeof(tmpbuf));
 560         gspca_frame_add(gspca_dev, INTER_PACKET,
 561                 pac_jpeg_header2, sizeof(pac_jpeg_header2));
 562 }
 563
 564 /* this function is run at interrupt level */
 565 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 566                         u8 *data,                       /* isoc packet */
 567                         int len)                        /* iso packet length */
 568 {
 569         struct sd *sd = (struct sd *) gspca_dev;
 570         u8 *image;
 571         unsigned char *sof;
 572
 573         sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len);
 574         if (sof) {
 575                 int n, lum_offset, footer_length;
 576
 577                 /*
 578                  * 6 bytes after the FF D9 EOF marker a number of lumination
 579                  * bytes are send corresponding to different parts of the
 580                  * image, the 14th and 15th byte after the EOF seem to
 581                  * correspond to the center of the image.
 582                  */
 583                 lum_offset = 24 + sizeof pac_sof_marker;
 584                 footer_length = 26;
 585
 586                 /* Finish decoding current frame */
 587                 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
 588                 if (n < 0) {
 589                         gspca_dev->image_len += n;
 590                         n = 0;
 591                 } else {
 592                         gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
 593                 }
 594                 image = gspca_dev->image;
 595                 if (image != NULL
 596                  && image[gspca_dev->image_len - 2] == 0xff
 597                  && image[gspca_dev->image_len - 1] == 0xd9)
 598                         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
 599
 600                 n = sof - data;
 601                 len -= n;
 602                 data = sof;
 603
 604                 /* Get average lumination */
 605                 if (gspca_dev->last_packet_type == LAST_PACKET &&
 606                                 n >= lum_offset)
 607                         atomic_set(&sd->avg_lum, data[-lum_offset] +
 608                                                 data[-lum_offset + 1]);
 609                 else
 610                         atomic_set(&sd->avg_lum, -1);
 611
 612                 /* Start the new frame with the jpeg header */
 613                 pac_start_frame(gspca_dev,
 614                         gspca_dev->pixfmt.height, gspca_dev->pixfmt.width);
 615         }
 616         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 617 }
 618
 619 #if IS_ENABLED(CONFIG_INPUT)
 620 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
 621                         u8 *data,               /* interrupt packet data */
 622                         int len)                /* interrupt packet length */
 623 {
 624         int ret = -EINVAL;
 625         u8 data0, data1;
 626
 627         if (len == 2) {
 628                 data0 = data[0];
 629                 data1 = data[1];
 630                 if ((data0 == 0x00 && data1 == 0x11) ||
 631                     (data0 == 0x22 && data1 == 0x33) ||
 632                     (data0 == 0x44 && data1 == 0x55) ||
 633                     (data0 == 0x66 && data1 == 0x77) ||
 634                     (data0 == 0x88 && data1 == 0x99) ||
 635                     (data0 == 0xaa && data1 == 0xbb) ||
 636                     (data0 == 0xcc && data1 == 0xdd) ||
 637                     (data0 == 0xee && data1 == 0xff)) {
 638                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
 639                         input_sync(gspca_dev->input_dev);
 640                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
 641                         input_sync(gspca_dev->input_dev);
 642                         ret = 0;
 643                 }
 644         }
 645
 646         return ret;
 647 }
 648 #endif
 649
 650 static const struct sd_desc sd_desc = {
 651         .name = MODULE_NAME,
 652         .config = sd_config,
 653         .init = sd_init,
 654         .init_controls = sd_init_controls,
 655         .start = sd_start,
 656         .stopN = sd_stopN,
 657         .pkt_scan = sd_pkt_scan,
 658         .dq_callback = do_autogain,
 659 #if IS_ENABLED(CONFIG_INPUT)
 660         .int_pkt_scan = sd_int_pkt_scan,
 661 #endif
 662 };
 663
 664 /* -- module initialisation -- */
 665 static const struct usb_device_id device_table[] = {
 666         {USB_DEVICE(0x093a, 0x2600)},
 667         {USB_DEVICE(0x093a, 0x2601)},
 668         {USB_DEVICE(0x093a, 0x2603)},
 669         {USB_DEVICE(0x093a, 0x2608)},
 670         {USB_DEVICE(0x093a, 0x260e)},
 671         {USB_DEVICE(0x093a, 0x260f)},
 672         {}
 673 };
 674 MODULE_DEVICE_TABLE(usb, device_table);
 675
 676 /* -- device connect -- */
 677 static int sd_probe(struct usb_interface *intf,
 678                         const struct usb_device_id *id)
 679 {
 680         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 681                                 THIS_MODULE);
 682 }
 683
 684 static struct usb_driver sd_driver = {
 685         .name = MODULE_NAME,
 686         .id_table = device_table,
 687         .probe = sd_probe,
 688         .disconnect = gspca_disconnect,
 689 #ifdef CONFIG_PM
 690         .suspend = gspca_suspend,
 691         .resume = gspca_resume,
 692         .reset_resume = gspca_resume,
 693 #endif
 694 };
 695
 696 module_usb_driver(sd_driver);