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