Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / drivers / media / video / gspca / w996Xcf.c
blob27d2cef0692a8dafa834bb5ba408614a0cd785e3
1 /**
3 * GSPCA sub driver for W996[78]CF JPEG USB Dual Mode Camera Chip.
5 * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com>
7 * This module is adapted from the in kernel v4l1 w9968cf driver:
9 * Copyright (C) 2002-2004 by Luca Risolia <luca.risolia@studio.unibo.it>
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.
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.
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
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 */
34 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
36 #define W9968CF_I2C_BUS_DELAY 4 /* delay in us for I2C bit r/w operations */
38 #define Y_QUANTABLE (&sd->jpeg_hdr[JPEG_QT0_OFFSET])
39 #define UV_QUANTABLE (&sd->jpeg_hdr[JPEG_QT1_OFFSET])
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},
64 static void reg_w(struct sd *sd, u16 index, u16 value);
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)
72 struct usb_device *udev = sd->gspca_dev.dev;
73 u16 value;
74 int ret;
76 if (sd->gspca_dev.usb_err < 0)
77 return;
79 value = *data++;
80 memcpy(sd->gspca_dev.usb_buf, data, 6);
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;
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)
97 int ret;
99 if (sd->gspca_dev.usb_err < 0)
100 return;
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),
107 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
108 value, 0x01, NULL, 0, 500);
110 udelay(W9968CF_I2C_BUS_DELAY);
112 if (ret < 0) {
113 pr_err("Write SB reg [01] %04x failed\n", value);
114 sd->gspca_dev.usb_err = ret;
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)
124 int ret;
126 if (sd->gspca_dev.usb_err < 0)
127 return -1;
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),
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;
144 udelay(W9968CF_I2C_BUS_DELAY);
146 return ret;
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)
156 u16 a, b;
157 int i, j;
159 reg_w(sd, 0x39, 0x0010); /* JPEG clock enable */
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);
167 reg_w(sd, 0x39, 0x0012); /* JPEG encoder enable */
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 ****************************************************************************/
178 static void w9968cf_smbus_start(struct sd *sd)
180 w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
181 w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
184 static void w9968cf_smbus_stop(struct sd *sd)
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 */
191 static void w9968cf_smbus_write_byte(struct sd *sd, u8 v)
193 u8 bit;
194 int sda;
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);
208 static void w9968cf_smbus_read_byte(struct sd *sd, u8 *v)
210 u8 bit;
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);
225 static void w9968cf_smbus_write_nack(struct sd *sd)
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 */
233 static void w9968cf_smbus_read_ack(struct sd *sd)
235 int sda;
237 /* Ensure SDA is high before raising clock to avoid a spurious stop */
238 w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
239 w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
240 sda = w9968cf_read_sb(sd);
241 w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
242 if (sda >= 0 && (sda & 0x08)) {
243 PDEBUG(D_USBI, "Did not receive i2c ACK");
244 sd->gspca_dev.usb_err = -EIO;
248 /* SMBus protocol: S Addr Wr [A] Subaddr [A] Value [A] P */
249 static void w9968cf_i2c_w(struct sd *sd, u8 reg, u8 value)
251 u16* data = (u16 *)sd->gspca_dev.usb_buf;
253 data[0] = 0x082f | ((sd->sensor_addr & 0x80) ? 0x1500 : 0x0);
254 data[0] |= (sd->sensor_addr & 0x40) ? 0x4000 : 0x0;
255 data[1] = 0x2082 | ((sd->sensor_addr & 0x40) ? 0x0005 : 0x0);
256 data[1] |= (sd->sensor_addr & 0x20) ? 0x0150 : 0x0;
257 data[1] |= (sd->sensor_addr & 0x10) ? 0x5400 : 0x0;
258 data[2] = 0x8208 | ((sd->sensor_addr & 0x08) ? 0x0015 : 0x0);
259 data[2] |= (sd->sensor_addr & 0x04) ? 0x0540 : 0x0;
260 data[2] |= (sd->sensor_addr & 0x02) ? 0x5000 : 0x0;
261 data[3] = 0x1d20 | ((sd->sensor_addr & 0x02) ? 0x0001 : 0x0);
262 data[3] |= (sd->sensor_addr & 0x01) ? 0x0054 : 0x0;
264 w9968cf_write_fsb(sd, data);
266 data[0] = 0x8208 | ((reg & 0x80) ? 0x0015 : 0x0);
267 data[0] |= (reg & 0x40) ? 0x0540 : 0x0;
268 data[0] |= (reg & 0x20) ? 0x5000 : 0x0;
269 data[1] = 0x0820 | ((reg & 0x20) ? 0x0001 : 0x0);
270 data[1] |= (reg & 0x10) ? 0x0054 : 0x0;
271 data[1] |= (reg & 0x08) ? 0x1500 : 0x0;
272 data[1] |= (reg & 0x04) ? 0x4000 : 0x0;
273 data[2] = 0x2082 | ((reg & 0x04) ? 0x0005 : 0x0);
274 data[2] |= (reg & 0x02) ? 0x0150 : 0x0;
275 data[2] |= (reg & 0x01) ? 0x5400 : 0x0;
276 data[3] = 0x001d;
278 w9968cf_write_fsb(sd, data);
280 data[0] = 0x8208 | ((value & 0x80) ? 0x0015 : 0x0);
281 data[0] |= (value & 0x40) ? 0x0540 : 0x0;
282 data[0] |= (value & 0x20) ? 0x5000 : 0x0;
283 data[1] = 0x0820 | ((value & 0x20) ? 0x0001 : 0x0);
284 data[1] |= (value & 0x10) ? 0x0054 : 0x0;
285 data[1] |= (value & 0x08) ? 0x1500 : 0x0;
286 data[1] |= (value & 0x04) ? 0x4000 : 0x0;
287 data[2] = 0x2082 | ((value & 0x04) ? 0x0005 : 0x0);
288 data[2] |= (value & 0x02) ? 0x0150 : 0x0;
289 data[2] |= (value & 0x01) ? 0x5400 : 0x0;
290 data[3] = 0xfe1d;
292 w9968cf_write_fsb(sd, data);
294 PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
297 /* SMBus protocol: S Addr Wr [A] Subaddr [A] P S Addr+1 Rd [A] [Value] NA P */
298 static int w9968cf_i2c_r(struct sd *sd, u8 reg)
300 int ret = 0;
301 u8 value;
303 /* Fast serial bus data control disable */
304 w9968cf_write_sb(sd, 0x0013); /* don't change ! */
306 w9968cf_smbus_start(sd);
307 w9968cf_smbus_write_byte(sd, sd->sensor_addr);
308 w9968cf_smbus_read_ack(sd);
309 w9968cf_smbus_write_byte(sd, reg);
310 w9968cf_smbus_read_ack(sd);
311 w9968cf_smbus_stop(sd);
312 w9968cf_smbus_start(sd);
313 w9968cf_smbus_write_byte(sd, sd->sensor_addr + 1);
314 w9968cf_smbus_read_ack(sd);
315 w9968cf_smbus_read_byte(sd, &value);
316 /* signal we don't want to read anymore, the v4l1 driver used to
317 send an ack here which is very wrong! (and then fixed
318 the issues this gave by retrying reads) */
319 w9968cf_smbus_write_nack(sd);
320 w9968cf_smbus_stop(sd);
322 /* Fast serial bus data control re-enable */
323 w9968cf_write_sb(sd, 0x0030);
325 if (sd->gspca_dev.usb_err >= 0) {
326 ret = value;
327 PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
328 } else
329 PDEBUG(D_ERR, "i2c read [0x%02x] failed", reg);
331 return ret;
334 /*--------------------------------------------------------------------------
335 Turn on the LED on some webcams. A beep should be heard too.
336 Return 0 on success, a negative number otherwise.
337 --------------------------------------------------------------------------*/
338 static void w9968cf_configure(struct sd *sd)
340 reg_w(sd, 0x00, 0xff00); /* power-down */
341 reg_w(sd, 0x00, 0xbf17); /* reset everything */
342 reg_w(sd, 0x00, 0xbf10); /* normal operation */
343 reg_w(sd, 0x01, 0x0010); /* serial bus, SDS high */
344 reg_w(sd, 0x01, 0x0000); /* serial bus, SDS low */
345 reg_w(sd, 0x01, 0x0010); /* ..high 'beep-beep' */
346 reg_w(sd, 0x01, 0x0030); /* Set sda scl to FSB mode */
348 sd->stopped = 1;
351 static void w9968cf_init(struct sd *sd)
353 unsigned long hw_bufsize = sd->sif ? (352 * 288 * 2) : (640 * 480 * 2),
354 y0 = 0x0000,
355 u0 = y0 + hw_bufsize / 2,
356 v0 = u0 + hw_bufsize / 4,
357 y1 = v0 + hw_bufsize / 4,
358 u1 = y1 + hw_bufsize / 2,
359 v1 = u1 + hw_bufsize / 4;
361 reg_w(sd, 0x00, 0xff00); /* power off */
362 reg_w(sd, 0x00, 0xbf10); /* power on */
364 reg_w(sd, 0x03, 0x405d); /* DRAM timings */
365 reg_w(sd, 0x04, 0x0030); /* SDRAM timings */
367 reg_w(sd, 0x20, y0 & 0xffff); /* Y buf.0, low */
368 reg_w(sd, 0x21, y0 >> 16); /* Y buf.0, high */
369 reg_w(sd, 0x24, u0 & 0xffff); /* U buf.0, low */
370 reg_w(sd, 0x25, u0 >> 16); /* U buf.0, high */
371 reg_w(sd, 0x28, v0 & 0xffff); /* V buf.0, low */
372 reg_w(sd, 0x29, v0 >> 16); /* V buf.0, high */
374 reg_w(sd, 0x22, y1 & 0xffff); /* Y buf.1, low */
375 reg_w(sd, 0x23, y1 >> 16); /* Y buf.1, high */
376 reg_w(sd, 0x26, u1 & 0xffff); /* U buf.1, low */
377 reg_w(sd, 0x27, u1 >> 16); /* U buf.1, high */
378 reg_w(sd, 0x2a, v1 & 0xffff); /* V buf.1, low */
379 reg_w(sd, 0x2b, v1 >> 16); /* V buf.1, high */
381 reg_w(sd, 0x32, y1 & 0xffff); /* JPEG buf 0 low */
382 reg_w(sd, 0x33, y1 >> 16); /* JPEG buf 0 high */
384 reg_w(sd, 0x34, y1 & 0xffff); /* JPEG buf 1 low */
385 reg_w(sd, 0x35, y1 >> 16); /* JPEG bug 1 high */
387 reg_w(sd, 0x36, 0x0000);/* JPEG restart interval */
388 reg_w(sd, 0x37, 0x0804);/*JPEG VLE FIFO threshold*/
389 reg_w(sd, 0x38, 0x0000);/* disable hw up-scaling */
390 reg_w(sd, 0x3f, 0x0000); /* JPEG/MCTL test data */
393 static void w9968cf_set_crop_window(struct sd *sd)
395 int start_cropx, start_cropy, x, y, fw, fh, cw, ch,
396 max_width, max_height;
398 if (sd->sif) {
399 max_width = 352;
400 max_height = 288;
401 } else {
402 max_width = 640;
403 max_height = 480;
406 if (sd->sensor == SEN_OV7620) {
407 /* Sigh, this is dependend on the clock / framerate changes
408 made by the frequency control, sick. */
409 if (sd->ctrls[FREQ].val == 1) {
410 start_cropx = 277;
411 start_cropy = 37;
412 } else {
413 start_cropx = 105;
414 start_cropy = 37;
416 } else {
417 start_cropx = 320;
418 start_cropy = 35;
421 /* Work around to avoid FP arithmetics */
422 #define SC(x) ((x) << 10)
424 /* Scaling factors */
425 fw = SC(sd->gspca_dev.width) / max_width;
426 fh = SC(sd->gspca_dev.height) / max_height;
428 cw = (fw >= fh) ? max_width : SC(sd->gspca_dev.width) / fh;
429 ch = (fw >= fh) ? SC(sd->gspca_dev.height) / fw : max_height;
431 sd->sensor_width = max_width;
432 sd->sensor_height = max_height;
434 x = (max_width - cw) / 2;
435 y = (max_height - ch) / 2;
437 reg_w(sd, 0x10, start_cropx + x);
438 reg_w(sd, 0x11, start_cropy + y);
439 reg_w(sd, 0x12, start_cropx + x + cw);
440 reg_w(sd, 0x13, start_cropy + y + ch);
443 static void w9968cf_mode_init_regs(struct sd *sd)
445 int val, vs_polarity, hs_polarity;
447 w9968cf_set_crop_window(sd);
449 reg_w(sd, 0x14, sd->gspca_dev.width);
450 reg_w(sd, 0x15, sd->gspca_dev.height);
452 /* JPEG width & height */
453 reg_w(sd, 0x30, sd->gspca_dev.width);
454 reg_w(sd, 0x31, sd->gspca_dev.height);
456 /* Y & UV frame buffer strides (in WORD) */
457 if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
458 V4L2_PIX_FMT_JPEG) {
459 reg_w(sd, 0x2c, sd->gspca_dev.width / 2);
460 reg_w(sd, 0x2d, sd->gspca_dev.width / 4);
461 } else
462 reg_w(sd, 0x2c, sd->gspca_dev.width);
464 reg_w(sd, 0x00, 0xbf17); /* reset everything */
465 reg_w(sd, 0x00, 0xbf10); /* normal operation */
467 /* Transfer size in WORDS (for UYVY format only) */
468 val = sd->gspca_dev.width * sd->gspca_dev.height;
469 reg_w(sd, 0x3d, val & 0xffff); /* low bits */
470 reg_w(sd, 0x3e, val >> 16); /* high bits */
472 if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
473 V4L2_PIX_FMT_JPEG) {
474 /* We may get called multiple times (usb isoc bw negotiat.) */
475 jpeg_define(sd->jpeg_hdr, sd->gspca_dev.height,
476 sd->gspca_dev.width, 0x22); /* JPEG 420 */
477 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
478 w9968cf_upload_quantizationtables(sd);
481 /* Video Capture Control Register */
482 if (sd->sensor == SEN_OV7620) {
483 /* Seems to work around a bug in the image sensor */
484 vs_polarity = 1;
485 hs_polarity = 1;
486 } else {
487 vs_polarity = 1;
488 hs_polarity = 0;
491 val = (vs_polarity << 12) | (hs_polarity << 11);
493 /* NOTE: We may not have enough memory to do double buffering while
494 doing compression (amount of memory differs per model cam).
495 So we use the second image buffer also as jpeg stream buffer
496 (see w9968cf_init), and disable double buffering. */
497 if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
498 V4L2_PIX_FMT_JPEG) {
499 /* val |= 0x0002; YUV422P */
500 val |= 0x0003; /* YUV420P */
501 } else
502 val |= 0x0080; /* Enable HW double buffering */
504 /* val |= 0x0020; enable clamping */
505 /* val |= 0x0008; enable (1-2-1) filter */
506 /* val |= 0x000c; enable (2-3-6-3-2) filter */
508 val |= 0x8000; /* capt. enable */
510 reg_w(sd, 0x16, val);
512 sd->gspca_dev.empty_packet = 0;
515 static void w9968cf_stop0(struct sd *sd)
517 reg_w(sd, 0x39, 0x0000); /* disable JPEG encoder */
518 reg_w(sd, 0x16, 0x0000); /* stop video capture */
521 /* The w9968cf docs say that a 0 sized packet means EOF (and also SOF
522 for the next frame). This seems to simply not be true when operating
523 in JPEG mode, in this case there may be empty packets within the
524 frame. So in JPEG mode use the JPEG SOI marker to detect SOF.
526 Note to make things even more interesting the w9968cf sends *PLANAR* jpeg,
527 to be precise it sends: SOI, SOF, DRI, SOS, Y-data, SOS, U-data, SOS,
528 V-data, EOI. */
529 static void w9968cf_pkt_scan(struct gspca_dev *gspca_dev,
530 u8 *data, /* isoc packet */
531 int len) /* iso packet length */
533 struct sd *sd = (struct sd *) gspca_dev;
535 if (w9968cf_vga_mode[gspca_dev->curr_mode].pixelformat ==
536 V4L2_PIX_FMT_JPEG) {
537 if (len >= 2 &&
538 data[0] == 0xff &&
539 data[1] == 0xd8) {
540 gspca_frame_add(gspca_dev, LAST_PACKET,
541 NULL, 0);
542 gspca_frame_add(gspca_dev, FIRST_PACKET,
543 sd->jpeg_hdr, JPEG_HDR_SZ);
544 /* Strip the ff d8, our own header (which adds
545 huffman and quantization tables) already has this */
546 len -= 2;
547 data += 2;
549 } else {
550 /* In UYVY mode an empty packet signals EOF */
551 if (gspca_dev->empty_packet) {
552 gspca_frame_add(gspca_dev, LAST_PACKET,
553 NULL, 0);
554 gspca_frame_add(gspca_dev, FIRST_PACKET,
555 NULL, 0);
556 gspca_dev->empty_packet = 0;
559 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);