kernel/drivers/media/usb/gspca/w996Xcf.c

   1 /**
   2  *
   3  * GSPCA sub driver for W996[78]CF JPEG USB Dual Mode Camera Chip.
   4  *
   5  * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com>
   6  *
   7  * This module is adapted from the in kernel v4l1 w9968cf driver:
   8  *
   9  * Copyright (C) 2002-2004 by Luca Risolia <luca.risolia@studio.unibo.it>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24  *
  25  */
  26
  27 /* Note this is not a stand alone driver, it gets included in ov519.c, this
  28    is a bit of a hack, but it needs the driver code for a lot of different
  29    ov sensors which is already present in ov519.c (the old v4l1 driver used
  30    the ovchipcam framework). When we have the time we really should move
  31    the sensor drivers to v4l2 sub drivers, and properly split of this
  32    driver from ov519.c */
  33
  34 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  35
  36 #define W9968CF_I2C_BUS_DELAY    4 /* delay in us for I2C bit r/w operations */
  37
  38 #define Y_QUANTABLE (&sd->jpeg_hdr[JPEG_QT0_OFFSET])
  39 #define UV_QUANTABLE (&sd->jpeg_hdr[JPEG_QT1_OFFSET])
  40
  41 static const struct v4l2_pix_format w9968cf_vga_mode[] = {
  42         {160, 120, V4L2_PIX_FMT_UYVY, V4L2_FIELD_NONE,
  43                 .bytesperline = 160 * 2,
  44                 .sizeimage = 160 * 120 * 2,
  45                 .colorspace = V4L2_COLORSPACE_JPEG},
  46         {176, 144, V4L2_PIX_FMT_UYVY, V4L2_FIELD_NONE,
  47                 .bytesperline = 176 * 2,
  48                 .sizeimage = 176 * 144 * 2,
  49                 .colorspace = V4L2_COLORSPACE_JPEG},
  50         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  51                 .bytesperline = 320 * 2,
  52                 .sizeimage = 320 * 240 * 2,
  53                 .colorspace = V4L2_COLORSPACE_JPEG},
  54         {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  55                 .bytesperline = 352 * 2,
  56                 .sizeimage = 352 * 288 * 2,
  57                 .colorspace = V4L2_COLORSPACE_JPEG},
  58         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  59                 .bytesperline = 640 * 2,
  60                 .sizeimage = 640 * 480 * 2,
  61                 .colorspace = V4L2_COLORSPACE_JPEG},
  62 };
  63
  64 static void reg_w(struct sd *sd, u16 index, u16 value);
  65
  66 /*--------------------------------------------------------------------------
  67   Write 64-bit data to the fast serial bus registers.
  68   Return 0 on success, -1 otherwise.
  69   --------------------------------------------------------------------------*/
  70 static void w9968cf_write_fsb(struct sd *sd, u16* data)
  71 {
  72         struct usb_device *udev = sd->gspca_dev.dev;
  73         u16 value;
  74         int ret;
  75
  76         if (sd->gspca_dev.usb_err < 0)
  77                 return;
  78
  79         value = *data++;
  80         memcpy(sd->gspca_dev.usb_buf, data, 6);
  81
  82         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0,
  83                               USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  84                               value, 0x06, sd->gspca_dev.usb_buf, 6, 500);
  85         if (ret < 0) {
  86                 pr_err("Write FSB registers failed (%d)\n", ret);
  87                 sd->gspca_dev.usb_err = ret;
  88         }
  89 }
  90
  91 /*--------------------------------------------------------------------------
  92   Write data to the serial bus control register.
  93   Return 0 on success, a negative number otherwise.
  94   --------------------------------------------------------------------------*/
  95 static void w9968cf_write_sb(struct sd *sd, u16 value)
  96 {
  97         int ret;
  98
  99         if (sd->gspca_dev.usb_err < 0)
 100                 return;
 101
 102         /* We don't use reg_w here, as that would cause all writes when
 103            bitbanging i2c to be logged, making the logs impossible to read */
 104         ret = usb_control_msg(sd->gspca_dev.dev,
 105                 usb_sndctrlpipe(sd->gspca_dev.dev, 0),
 106                 0,
 107                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 108                 value, 0x01, NULL, 0, 500);
 109
 110         udelay(W9968CF_I2C_BUS_DELAY);
 111
 112         if (ret < 0) {
 113                 pr_err("Write SB reg [01] %04x failed\n", value);
 114                 sd->gspca_dev.usb_err = ret;
 115         }
 116 }
 117
 118 /*--------------------------------------------------------------------------
 119   Read data from the serial bus control register.
 120   Return 0 on success, a negative number otherwise.
 121   --------------------------------------------------------------------------*/
 122 static int w9968cf_read_sb(struct sd *sd)
 123 {
 124         int ret;
 125
 126         if (sd->gspca_dev.usb_err < 0)
 127                 return -1;
 128
 129         /* We don't use reg_r here, as the w9968cf is special and has 16
 130            bit registers instead of 8 bit */
 131         ret = usb_control_msg(sd->gspca_dev.dev,
 132                         usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
 133                         1,
 134                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 135                         0, 0x01, sd->gspca_dev.usb_buf, 2, 500);
 136         if (ret >= 0) {
 137                 ret = sd->gspca_dev.usb_buf[0] |
 138                       (sd->gspca_dev.usb_buf[1] << 8);
 139         } else {
 140                 pr_err("Read SB reg [01] failed\n");
 141                 sd->gspca_dev.usb_err = ret;
 142         }
 143
 144         udelay(W9968CF_I2C_BUS_DELAY);
 145
 146         return ret;
 147 }
 148
 149 /*--------------------------------------------------------------------------
 150   Upload quantization tables for the JPEG compression.
 151   This function is called by w9968cf_start_transfer().
 152   Return 0 on success, a negative number otherwise.
 153   --------------------------------------------------------------------------*/
 154 static void w9968cf_upload_quantizationtables(struct sd *sd)
 155 {
 156         u16 a, b;
 157         int i, j;
 158
 159         reg_w(sd, 0x39, 0x0010); /* JPEG clock enable */
 160
 161         for (i = 0, j = 0; i < 32; i++, j += 2) {
 162                 a = Y_QUANTABLE[j] | ((unsigned)(Y_QUANTABLE[j + 1]) << 8);
 163                 b = UV_QUANTABLE[j] | ((unsigned)(UV_QUANTABLE[j + 1]) << 8);
 164                 reg_w(sd, 0x40 + i, a);
 165                 reg_w(sd, 0x60 + i, b);
 166         }
 167         reg_w(sd, 0x39, 0x0012); /* JPEG encoder enable */
 168 }
 169
 170 /****************************************************************************
 171  * Low-level I2C I/O functions.                                             *
 172  * The adapter supports the following I2C transfer functions:               *
 173  * i2c_adap_fastwrite_byte_data() (at 400 kHz bit frequency only)           *
 174  * i2c_adap_read_byte_data()                                                *
 175  * i2c_adap_read_byte()                                                     *
 176  ****************************************************************************/
 177
 178 static void w9968cf_smbus_start(struct sd *sd)
 179 {
 180         w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
 181         w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
 182 }
 183
 184 static void w9968cf_smbus_stop(struct sd *sd)
 185 {
 186         w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
 187         w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
 188         w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
 189 }
 190
 191 static void w9968cf_smbus_write_byte(struct sd *sd, u8 v)
 192 {
 193         u8 bit;
 194         int sda;
 195
 196         for (bit = 0 ; bit < 8 ; bit++) {
 197                 sda = (v & 0x80) ? 2 : 0;
 198                 v <<= 1;
 199                 /* SDE=1, SDA=sda, SCL=0 */
 200                 w9968cf_write_sb(sd, 0x10 | sda);
 201                 /* SDE=1, SDA=sda, SCL=1 */
 202                 w9968cf_write_sb(sd, 0x11 | sda);
 203                 /* SDE=1, SDA=sda, SCL=0 */
 204                 w9968cf_write_sb(sd, 0x10 | sda);
 205         }
 206 }
 207
 208 static void w9968cf_smbus_read_byte(struct sd *sd, u8 *v)
 209 {
 210         u8 bit;
 211
 212         /* No need to ensure SDA is high as we are always called after
 213            read_ack which ends with SDA high */
 214         *v = 0;
 215         for (bit = 0 ; bit < 8 ; bit++) {
 216                 *v <<= 1;
 217                 /* SDE=1, SDA=1, SCL=1 */
 218                 w9968cf_write_sb(sd, 0x0013);
 219                 *v |= (w9968cf_read_sb(sd) & 0x0008) ? 1 : 0;
 220                 /* SDE=1, SDA=1, SCL=0 */
 221                 w9968cf_write_sb(sd, 0x0012);
 222         }
 223 }
 224
 225 static void w9968cf_smbus_write_nack(struct sd *sd)
 226 {
 227         /* No need to ensure SDA is high as we are always called after
 228            read_byte which ends with SDA high */
 229         w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
 230         w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
 231 }
 232
 233 static void w9968cf_smbus_read_ack(struct sd *sd)
 234 {
 235         struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
 236         int sda;
 237
 238         /* Ensure SDA is high before raising clock to avoid a spurious stop */
 239         w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
 240         w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
 241         sda = w9968cf_read_sb(sd);
 242         w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
 243         if (sda >= 0 && (sda & 0x08)) {
 244                 PDEBUG(D_USBI, "Did not receive i2c ACK");
 245                 sd->gspca_dev.usb_err = -EIO;
 246         }
 247 }
 248
 249 /* SMBus protocol: S Addr Wr [A] Subaddr [A] Value [A] P */
 250 static void w9968cf_i2c_w(struct sd *sd, u8 reg, u8 value)
 251 {
 252         struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
 253         u16* data = (u16 *)sd->gspca_dev.usb_buf;
 254
 255         data[0] = 0x082f | ((sd->sensor_addr & 0x80) ? 0x1500 : 0x0);
 256         data[0] |= (sd->sensor_addr & 0x40) ? 0x4000 : 0x0;
 257         data[1] = 0x2082 | ((sd->sensor_addr & 0x40) ? 0x0005 : 0x0);
 258         data[1] |= (sd->sensor_addr & 0x20) ? 0x0150 : 0x0;
 259         data[1] |= (sd->sensor_addr & 0x10) ? 0x5400 : 0x0;
 260         data[2] = 0x8208 | ((sd->sensor_addr & 0x08) ? 0x0015 : 0x0);
 261         data[2] |= (sd->sensor_addr & 0x04) ? 0x0540 : 0x0;
 262         data[2] |= (sd->sensor_addr & 0x02) ? 0x5000 : 0x0;
 263         data[3] = 0x1d20 | ((sd->sensor_addr & 0x02) ? 0x0001 : 0x0);
 264         data[3] |= (sd->sensor_addr & 0x01) ? 0x0054 : 0x0;
 265
 266         w9968cf_write_fsb(sd, data);
 267
 268         data[0] = 0x8208 | ((reg & 0x80) ? 0x0015 : 0x0);
 269         data[0] |= (reg & 0x40) ? 0x0540 : 0x0;
 270         data[0] |= (reg & 0x20) ? 0x5000 : 0x0;
 271         data[1] = 0x0820 | ((reg & 0x20) ? 0x0001 : 0x0);
 272         data[1] |= (reg & 0x10) ? 0x0054 : 0x0;
 273         data[1] |= (reg & 0x08) ? 0x1500 : 0x0;
 274         data[1] |= (reg & 0x04) ? 0x4000 : 0x0;
 275         data[2] = 0x2082 | ((reg & 0x04) ? 0x0005 : 0x0);
 276         data[2] |= (reg & 0x02) ? 0x0150 : 0x0;
 277         data[2] |= (reg & 0x01) ? 0x5400 : 0x0;
 278         data[3] = 0x001d;
 279
 280         w9968cf_write_fsb(sd, data);
 281
 282         data[0] = 0x8208 | ((value & 0x80) ? 0x0015 : 0x0);
 283         data[0] |= (value & 0x40) ? 0x0540 : 0x0;
 284         data[0] |= (value & 0x20) ? 0x5000 : 0x0;
 285         data[1] = 0x0820 | ((value & 0x20) ? 0x0001 : 0x0);
 286         data[1] |= (value & 0x10) ? 0x0054 : 0x0;
 287         data[1] |= (value & 0x08) ? 0x1500 : 0x0;
 288         data[1] |= (value & 0x04) ? 0x4000 : 0x0;
 289         data[2] = 0x2082 | ((value & 0x04) ? 0x0005 : 0x0);
 290         data[2] |= (value & 0x02) ? 0x0150 : 0x0;
 291         data[2] |= (value & 0x01) ? 0x5400 : 0x0;
 292         data[3] = 0xfe1d;
 293
 294         w9968cf_write_fsb(sd, data);
 295
 296         PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
 297 }
 298
 299 /* SMBus protocol: S Addr Wr [A] Subaddr [A] P S Addr+1 Rd [A] [Value] NA P */
 300 static int w9968cf_i2c_r(struct sd *sd, u8 reg)
 301 {
 302         struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
 303         int ret = 0;
 304         u8 value;
 305
 306         /* Fast serial bus data control disable */
 307         w9968cf_write_sb(sd, 0x0013); /* don't change ! */
 308
 309         w9968cf_smbus_start(sd);
 310         w9968cf_smbus_write_byte(sd, sd->sensor_addr);
 311         w9968cf_smbus_read_ack(sd);
 312         w9968cf_smbus_write_byte(sd, reg);
 313         w9968cf_smbus_read_ack(sd);
 314         w9968cf_smbus_stop(sd);
 315         w9968cf_smbus_start(sd);
 316         w9968cf_smbus_write_byte(sd, sd->sensor_addr + 1);
 317         w9968cf_smbus_read_ack(sd);
 318         w9968cf_smbus_read_byte(sd, &value);
 319         /* signal we don't want to read anymore, the v4l1 driver used to
 320            send an ack here which is very wrong! (and then fixed
 321            the issues this gave by retrying reads) */
 322         w9968cf_smbus_write_nack(sd);
 323         w9968cf_smbus_stop(sd);
 324
 325         /* Fast serial bus data control re-enable */
 326         w9968cf_write_sb(sd, 0x0030);
 327
 328         if (sd->gspca_dev.usb_err >= 0) {
 329                 ret = value;
 330                 PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
 331         } else
 332                 PERR("i2c read [0x%02x] failed", reg);
 333
 334         return ret;
 335 }
 336
 337 /*--------------------------------------------------------------------------
 338   Turn on the LED on some webcams. A beep should be heard too.
 339   Return 0 on success, a negative number otherwise.
 340   --------------------------------------------------------------------------*/
 341 static void w9968cf_configure(struct sd *sd)
 342 {
 343         reg_w(sd, 0x00, 0xff00); /* power-down */
 344         reg_w(sd, 0x00, 0xbf17); /* reset everything */
 345         reg_w(sd, 0x00, 0xbf10); /* normal operation */
 346         reg_w(sd, 0x01, 0x0010); /* serial bus, SDS high */
 347         reg_w(sd, 0x01, 0x0000); /* serial bus, SDS low */
 348         reg_w(sd, 0x01, 0x0010); /* ..high 'beep-beep' */
 349         reg_w(sd, 0x01, 0x0030); /* Set sda scl to FSB mode */
 350
 351         sd->stopped = 1;
 352 }
 353
 354 static void w9968cf_init(struct sd *sd)
 355 {
 356         unsigned long hw_bufsize = sd->sif ? (352 * 288 * 2) : (640 * 480 * 2),
 357                       y0 = 0x0000,
 358                       u0 = y0 + hw_bufsize / 2,
 359                       v0 = u0 + hw_bufsize / 4,
 360                       y1 = v0 + hw_bufsize / 4,
 361                       u1 = y1 + hw_bufsize / 2,
 362                       v1 = u1 + hw_bufsize / 4;
 363
 364         reg_w(sd, 0x00, 0xff00); /* power off */
 365         reg_w(sd, 0x00, 0xbf10); /* power on */
 366
 367         reg_w(sd, 0x03, 0x405d); /* DRAM timings */
 368         reg_w(sd, 0x04, 0x0030); /* SDRAM timings */
 369
 370         reg_w(sd, 0x20, y0 & 0xffff); /* Y buf.0, low */
 371         reg_w(sd, 0x21, y0 >> 16);    /* Y buf.0, high */
 372         reg_w(sd, 0x24, u0 & 0xffff); /* U buf.0, low */
 373         reg_w(sd, 0x25, u0 >> 16);    /* U buf.0, high */
 374         reg_w(sd, 0x28, v0 & 0xffff); /* V buf.0, low */
 375         reg_w(sd, 0x29, v0 >> 16);    /* V buf.0, high */
 376
 377         reg_w(sd, 0x22, y1 & 0xffff); /* Y buf.1, low */
 378         reg_w(sd, 0x23, y1 >> 16);    /* Y buf.1, high */
 379         reg_w(sd, 0x26, u1 & 0xffff); /* U buf.1, low */
 380         reg_w(sd, 0x27, u1 >> 16);    /* U buf.1, high */
 381         reg_w(sd, 0x2a, v1 & 0xffff); /* V buf.1, low */
 382         reg_w(sd, 0x2b, v1 >> 16);    /* V buf.1, high */
 383
 384         reg_w(sd, 0x32, y1 & 0xffff); /* JPEG buf 0 low */
 385         reg_w(sd, 0x33, y1 >> 16);    /* JPEG buf 0 high */
 386
 387         reg_w(sd, 0x34, y1 & 0xffff); /* JPEG buf 1 low */
 388         reg_w(sd, 0x35, y1 >> 16);    /* JPEG bug 1 high */
 389
 390         reg_w(sd, 0x36, 0x0000);/* JPEG restart interval */
 391         reg_w(sd, 0x37, 0x0804);/*JPEG VLE FIFO threshold*/
 392         reg_w(sd, 0x38, 0x0000);/* disable hw up-scaling */
 393         reg_w(sd, 0x3f, 0x0000); /* JPEG/MCTL test data */
 394 }
 395
 396 static void w9968cf_set_crop_window(struct sd *sd)
 397 {
 398         int start_cropx, start_cropy,  x, y, fw, fh, cw, ch,
 399             max_width, max_height;
 400
 401         if (sd->sif) {
 402                 max_width  = 352;
 403                 max_height = 288;
 404         } else {
 405                 max_width  = 640;
 406                 max_height = 480;
 407         }
 408
 409         if (sd->sensor == SEN_OV7620) {
 410                 /*
 411                  * Sigh, this is dependend on the clock / framerate changes
 412                  * made by the frequency control, sick.
 413                  *
 414                  * Note we cannot use v4l2_ctrl_g_ctrl here, as we get called
 415                  * from ov519.c:setfreq() with the ctrl lock held!
 416                  */
 417                 if (sd->freq->val == 1) {
 418                         start_cropx = 277;
 419                         start_cropy = 37;
 420                 } else {
 421                         start_cropx = 105;
 422                         start_cropy = 37;
 423                 }
 424         } else {
 425                 start_cropx = 320;
 426                 start_cropy = 35;
 427         }
 428
 429         /* Work around to avoid FP arithmetics */
 430         #define SC(x) ((x) << 10)
 431
 432         /* Scaling factors */
 433         fw = SC(sd->gspca_dev.pixfmt.width) / max_width;
 434         fh = SC(sd->gspca_dev.pixfmt.height) / max_height;
 435
 436         cw = (fw >= fh) ? max_width : SC(sd->gspca_dev.pixfmt.width) / fh;
 437         ch = (fw >= fh) ? SC(sd->gspca_dev.pixfmt.height) / fw : max_height;
 438
 439         sd->sensor_width = max_width;
 440         sd->sensor_height = max_height;
 441
 442         x = (max_width - cw) / 2;
 443         y = (max_height - ch) / 2;
 444
 445         reg_w(sd, 0x10, start_cropx + x);
 446         reg_w(sd, 0x11, start_cropy + y);
 447         reg_w(sd, 0x12, start_cropx + x + cw);
 448         reg_w(sd, 0x13, start_cropy + y + ch);
 449 }
 450
 451 static void w9968cf_mode_init_regs(struct sd *sd)
 452 {
 453         int val, vs_polarity, hs_polarity;
 454
 455         w9968cf_set_crop_window(sd);
 456
 457         reg_w(sd, 0x14, sd->gspca_dev.pixfmt.width);
 458         reg_w(sd, 0x15, sd->gspca_dev.pixfmt.height);
 459
 460         /* JPEG width & height */
 461         reg_w(sd, 0x30, sd->gspca_dev.pixfmt.width);
 462         reg_w(sd, 0x31, sd->gspca_dev.pixfmt.height);
 463
 464         /* Y & UV frame buffer strides (in WORD) */
 465         if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
 466             V4L2_PIX_FMT_JPEG) {
 467                 reg_w(sd, 0x2c, sd->gspca_dev.pixfmt.width / 2);
 468                 reg_w(sd, 0x2d, sd->gspca_dev.pixfmt.width / 4);
 469         } else
 470                 reg_w(sd, 0x2c, sd->gspca_dev.pixfmt.width);
 471
 472         reg_w(sd, 0x00, 0xbf17); /* reset everything */
 473         reg_w(sd, 0x00, 0xbf10); /* normal operation */
 474
 475         /* Transfer size in WORDS (for UYVY format only) */
 476         val = sd->gspca_dev.pixfmt.width * sd->gspca_dev.pixfmt.height;
 477         reg_w(sd, 0x3d, val & 0xffff); /* low bits */
 478         reg_w(sd, 0x3e, val >> 16);    /* high bits */
 479
 480         if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
 481             V4L2_PIX_FMT_JPEG) {
 482                 /* We may get called multiple times (usb isoc bw negotiat.) */
 483                 jpeg_define(sd->jpeg_hdr, sd->gspca_dev.pixfmt.height,
 484                             sd->gspca_dev.pixfmt.width, 0x22); /* JPEG 420 */
 485                 jpeg_set_qual(sd->jpeg_hdr, v4l2_ctrl_g_ctrl(sd->jpegqual));
 486                 w9968cf_upload_quantizationtables(sd);
 487                 v4l2_ctrl_grab(sd->jpegqual, true);
 488         }
 489
 490         /* Video Capture Control Register */
 491         if (sd->sensor == SEN_OV7620) {
 492                 /* Seems to work around a bug in the image sensor */
 493                 vs_polarity = 1;
 494                 hs_polarity = 1;
 495         } else {
 496                 vs_polarity = 1;
 497                 hs_polarity = 0;
 498         }
 499
 500         val = (vs_polarity << 12) | (hs_polarity << 11);
 501
 502         /* NOTE: We may not have enough memory to do double buffering while
 503            doing compression (amount of memory differs per model cam).
 504            So we use the second image buffer also as jpeg stream buffer
 505            (see w9968cf_init), and disable double buffering. */
 506         if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
 507             V4L2_PIX_FMT_JPEG) {
 508                 /* val |= 0x0002; YUV422P */
 509                 val |= 0x0003; /* YUV420P */
 510         } else
 511                 val |= 0x0080; /* Enable HW double buffering */
 512
 513         /* val |= 0x0020; enable clamping */
 514         /* val |= 0x0008; enable (1-2-1) filter */
 515         /* val |= 0x000c; enable (2-3-6-3-2) filter */
 516
 517         val |= 0x8000; /* capt. enable */
 518
 519         reg_w(sd, 0x16, val);
 520
 521         sd->gspca_dev.empty_packet = 0;
 522 }
 523
 524 static void w9968cf_stop0(struct sd *sd)
 525 {
 526         v4l2_ctrl_grab(sd->jpegqual, false);
 527         reg_w(sd, 0x39, 0x0000); /* disable JPEG encoder */
 528         reg_w(sd, 0x16, 0x0000); /* stop video capture */
 529 }
 530
 531 /* The w9968cf docs say that a 0 sized packet means EOF (and also SOF
 532    for the next frame). This seems to simply not be true when operating
 533    in JPEG mode, in this case there may be empty packets within the
 534    frame. So in JPEG mode use the JPEG SOI marker to detect SOF.
 535
 536    Note to make things even more interesting the w9968cf sends *PLANAR* jpeg,
 537    to be precise it sends: SOI, SOF, DRI, SOS, Y-data, SOS, U-data, SOS,
 538    V-data, EOI. */
 539 static void w9968cf_pkt_scan(struct gspca_dev *gspca_dev,
 540                         u8 *data,                       /* isoc packet */
 541                         int len)                        /* iso packet length */
 542 {
 543         struct sd *sd = (struct sd *) gspca_dev;
 544
 545         if (w9968cf_vga_mode[gspca_dev->curr_mode].pixelformat ==
 546             V4L2_PIX_FMT_JPEG) {
 547                 if (len >= 2 &&
 548                     data[0] == 0xff &&
 549                     data[1] == 0xd8) {
 550                         gspca_frame_add(gspca_dev, LAST_PACKET,
 551                                         NULL, 0);
 552                         gspca_frame_add(gspca_dev, FIRST_PACKET,
 553                                         sd->jpeg_hdr, JPEG_HDR_SZ);
 554                         /* Strip the ff d8, our own header (which adds
 555                            huffman and quantization tables) already has this */
 556                         len -= 2;
 557                         data += 2;
 558                 }
 559         } else {
 560                 /* In UYVY mode an empty packet signals EOF */
 561                 if (gspca_dev->empty_packet) {
 562                         gspca_frame_add(gspca_dev, LAST_PACKET,
 563                                                 NULL, 0);
 564                         gspca_frame_add(gspca_dev, FIRST_PACKET,
 565                                         NULL, 0);
 566                         gspca_dev->empty_packet = 0;
 567                 }
 568         }
 569         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 570 }