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