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
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;
76 if (sd->gspca_dev.usb_err < 0)
80 memcpy(sd->gspca_dev.usb_buf, data, 6);
82 /* Avoid things going to fast for the bridge with a xhci host */
84 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0,
85 USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
86 value, 0x06, sd->gspca_dev.usb_buf, 6, 500);
88 pr_err("Write FSB registers failed (%d)\n", ret);
89 sd->gspca_dev.usb_err = ret;
93 /*--------------------------------------------------------------------------
94 Write data to the serial bus control register.
95 Return 0 on success, a negative number otherwise.
96 --------------------------------------------------------------------------*/
97 static void w9968cf_write_sb(struct sd *sd, u16 value)
101 if (sd->gspca_dev.usb_err < 0)
104 /* Avoid things going to fast for the bridge with a xhci host */
107 /* We don't use reg_w here, as that would cause all writes when
108 bitbanging i2c to be logged, making the logs impossible to read */
109 ret = usb_control_msg(sd->gspca_dev.dev,
110 usb_sndctrlpipe(sd->gspca_dev.dev, 0),
112 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
113 value, 0x01, NULL, 0, 500);
115 udelay(W9968CF_I2C_BUS_DELAY);
118 pr_err("Write SB reg [01] %04x failed\n", value);
119 sd->gspca_dev.usb_err = ret;
123 /*--------------------------------------------------------------------------
124 Read data from the serial bus control register.
125 Return 0 on success, a negative number otherwise.
126 --------------------------------------------------------------------------*/
127 static int w9968cf_read_sb(struct sd *sd)
131 if (sd->gspca_dev.usb_err < 0)
134 /* Avoid things going to fast for the bridge with a xhci host */
137 /* We don't use reg_r here, as the w9968cf is special and has 16
138 bit registers instead of 8 bit */
139 ret = usb_control_msg(sd->gspca_dev.dev,
140 usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
142 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
143 0, 0x01, sd->gspca_dev.usb_buf, 2, 500);
145 ret = sd->gspca_dev.usb_buf[0] |
146 (sd->gspca_dev.usb_buf[1] << 8);
148 pr_err("Read SB reg [01] failed\n");
149 sd->gspca_dev.usb_err = ret;
151 * Make sure the buffer is zeroed to avoid uninitialized
154 memset(sd->gspca_dev.usb_buf, 0, 2);
157 udelay(W9968CF_I2C_BUS_DELAY);
162 /*--------------------------------------------------------------------------
163 Upload quantization tables for the JPEG compression.
164 This function is called by w9968cf_start_transfer().
165 Return 0 on success, a negative number otherwise.
166 --------------------------------------------------------------------------*/
167 static void w9968cf_upload_quantizationtables(struct sd *sd)
172 reg_w(sd, 0x39, 0x0010); /* JPEG clock enable */
174 for (i = 0, j = 0; i < 32; i++, j += 2) {
175 a = Y_QUANTABLE[j] | ((unsigned)(Y_QUANTABLE[j + 1]) << 8);
176 b = UV_QUANTABLE[j] | ((unsigned)(UV_QUANTABLE[j + 1]) << 8);
177 reg_w(sd, 0x40 + i, a);
178 reg_w(sd, 0x60 + i, b);
180 reg_w(sd, 0x39, 0x0012); /* JPEG encoder enable */
183 /****************************************************************************
184 * Low-level I2C I/O functions. *
185 * The adapter supports the following I2C transfer functions: *
186 * i2c_adap_fastwrite_byte_data() (at 400 kHz bit frequency only) *
187 * i2c_adap_read_byte_data() *
188 * i2c_adap_read_byte() *
189 ****************************************************************************/
191 static void w9968cf_smbus_start(struct sd *sd)
193 w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
194 w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
197 static void w9968cf_smbus_stop(struct sd *sd)
199 w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
200 w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
201 w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
204 static void w9968cf_smbus_write_byte(struct sd *sd, u8 v)
209 for (bit = 0 ; bit < 8 ; bit++) {
210 sda = (v & 0x80) ? 2 : 0;
212 /* SDE=1, SDA=sda, SCL=0 */
213 w9968cf_write_sb(sd, 0x10 | sda);
214 /* SDE=1, SDA=sda, SCL=1 */
215 w9968cf_write_sb(sd, 0x11 | sda);
216 /* SDE=1, SDA=sda, SCL=0 */
217 w9968cf_write_sb(sd, 0x10 | sda);
221 static void w9968cf_smbus_read_byte(struct sd *sd, u8 *v)
225 /* No need to ensure SDA is high as we are always called after
226 read_ack which ends with SDA high */
228 for (bit = 0 ; bit < 8 ; bit++) {
230 /* SDE=1, SDA=1, SCL=1 */
231 w9968cf_write_sb(sd, 0x0013);
232 *v |= (w9968cf_read_sb(sd) & 0x0008) ? 1 : 0;
233 /* SDE=1, SDA=1, SCL=0 */
234 w9968cf_write_sb(sd, 0x0012);
238 static void w9968cf_smbus_write_nack(struct sd *sd)
240 /* No need to ensure SDA is high as we are always called after
241 read_byte which ends with SDA high */
242 w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
243 w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
246 static void w9968cf_smbus_read_ack(struct sd *sd)
248 struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
251 /* Ensure SDA is high before raising clock to avoid a spurious stop */
252 w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
253 w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
254 sda = w9968cf_read_sb(sd);
255 w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
256 if (sda >= 0 && (sda & 0x08)) {
257 PDEBUG(D_USBI, "Did not receive i2c ACK");
258 sd->gspca_dev.usb_err = -EIO;
262 /* SMBus protocol: S Addr Wr [A] Subaddr [A] Value [A] P */
263 static void w9968cf_i2c_w(struct sd *sd, u8 reg, u8 value)
265 struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
266 u16* data = (u16 *)sd->gspca_dev.usb_buf;
268 data[0] = 0x082f | ((sd->sensor_addr & 0x80) ? 0x1500 : 0x0);
269 data[0] |= (sd->sensor_addr & 0x40) ? 0x4000 : 0x0;
270 data[1] = 0x2082 | ((sd->sensor_addr & 0x40) ? 0x0005 : 0x0);
271 data[1] |= (sd->sensor_addr & 0x20) ? 0x0150 : 0x0;
272 data[1] |= (sd->sensor_addr & 0x10) ? 0x5400 : 0x0;
273 data[2] = 0x8208 | ((sd->sensor_addr & 0x08) ? 0x0015 : 0x0);
274 data[2] |= (sd->sensor_addr & 0x04) ? 0x0540 : 0x0;
275 data[2] |= (sd->sensor_addr & 0x02) ? 0x5000 : 0x0;
276 data[3] = 0x1d20 | ((sd->sensor_addr & 0x02) ? 0x0001 : 0x0);
277 data[3] |= (sd->sensor_addr & 0x01) ? 0x0054 : 0x0;
279 w9968cf_write_fsb(sd, data);
281 data[0] = 0x8208 | ((reg & 0x80) ? 0x0015 : 0x0);
282 data[0] |= (reg & 0x40) ? 0x0540 : 0x0;
283 data[0] |= (reg & 0x20) ? 0x5000 : 0x0;
284 data[1] = 0x0820 | ((reg & 0x20) ? 0x0001 : 0x0);
285 data[1] |= (reg & 0x10) ? 0x0054 : 0x0;
286 data[1] |= (reg & 0x08) ? 0x1500 : 0x0;
287 data[1] |= (reg & 0x04) ? 0x4000 : 0x0;
288 data[2] = 0x2082 | ((reg & 0x04) ? 0x0005 : 0x0);
289 data[2] |= (reg & 0x02) ? 0x0150 : 0x0;
290 data[2] |= (reg & 0x01) ? 0x5400 : 0x0;
293 w9968cf_write_fsb(sd, data);
295 data[0] = 0x8208 | ((value & 0x80) ? 0x0015 : 0x0);
296 data[0] |= (value & 0x40) ? 0x0540 : 0x0;
297 data[0] |= (value & 0x20) ? 0x5000 : 0x0;
298 data[1] = 0x0820 | ((value & 0x20) ? 0x0001 : 0x0);
299 data[1] |= (value & 0x10) ? 0x0054 : 0x0;
300 data[1] |= (value & 0x08) ? 0x1500 : 0x0;
301 data[1] |= (value & 0x04) ? 0x4000 : 0x0;
302 data[2] = 0x2082 | ((value & 0x04) ? 0x0005 : 0x0);
303 data[2] |= (value & 0x02) ? 0x0150 : 0x0;
304 data[2] |= (value & 0x01) ? 0x5400 : 0x0;
307 w9968cf_write_fsb(sd, data);
309 PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
312 /* SMBus protocol: S Addr Wr [A] Subaddr [A] P S Addr+1 Rd [A] [Value] NA P */
313 static int w9968cf_i2c_r(struct sd *sd, u8 reg)
315 struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
319 /* Fast serial bus data control disable */
320 w9968cf_write_sb(sd, 0x0013); /* don't change ! */
322 w9968cf_smbus_start(sd);
323 w9968cf_smbus_write_byte(sd, sd->sensor_addr);
324 w9968cf_smbus_read_ack(sd);
325 w9968cf_smbus_write_byte(sd, reg);
326 w9968cf_smbus_read_ack(sd);
327 w9968cf_smbus_stop(sd);
328 w9968cf_smbus_start(sd);
329 w9968cf_smbus_write_byte(sd, sd->sensor_addr + 1);
330 w9968cf_smbus_read_ack(sd);
331 w9968cf_smbus_read_byte(sd, &value);
332 /* signal we don't want to read anymore, the v4l1 driver used to
333 send an ack here which is very wrong! (and then fixed
334 the issues this gave by retrying reads) */
335 w9968cf_smbus_write_nack(sd);
336 w9968cf_smbus_stop(sd);
338 /* Fast serial bus data control re-enable */
339 w9968cf_write_sb(sd, 0x0030);
341 if (sd->gspca_dev.usb_err >= 0) {
343 PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
345 PERR("i2c read [0x%02x] failed", reg);
350 /*--------------------------------------------------------------------------
351 Turn on the LED on some webcams. A beep should be heard too.
352 Return 0 on success, a negative number otherwise.
353 --------------------------------------------------------------------------*/
354 static void w9968cf_configure(struct sd *sd)
356 reg_w(sd, 0x00, 0xff00); /* power-down */
357 reg_w(sd, 0x00, 0xbf17); /* reset everything */
358 reg_w(sd, 0x00, 0xbf10); /* normal operation */
359 reg_w(sd, 0x01, 0x0010); /* serial bus, SDS high */
360 reg_w(sd, 0x01, 0x0000); /* serial bus, SDS low */
361 reg_w(sd, 0x01, 0x0010); /* ..high 'beep-beep' */
362 reg_w(sd, 0x01, 0x0030); /* Set sda scl to FSB mode */
367 static void w9968cf_init(struct sd *sd)
369 unsigned long hw_bufsize = sd->sif ? (352 * 288 * 2) : (640 * 480 * 2),
371 u0 = y0 + hw_bufsize / 2,
372 v0 = u0 + hw_bufsize / 4,
373 y1 = v0 + hw_bufsize / 4,
374 u1 = y1 + hw_bufsize / 2,
375 v1 = u1 + hw_bufsize / 4;
377 reg_w(sd, 0x00, 0xff00); /* power off */
378 reg_w(sd, 0x00, 0xbf10); /* power on */
380 reg_w(sd, 0x03, 0x405d); /* DRAM timings */
381 reg_w(sd, 0x04, 0x0030); /* SDRAM timings */
383 reg_w(sd, 0x20, y0 & 0xffff); /* Y buf.0, low */
384 reg_w(sd, 0x21, y0 >> 16); /* Y buf.0, high */
385 reg_w(sd, 0x24, u0 & 0xffff); /* U buf.0, low */
386 reg_w(sd, 0x25, u0 >> 16); /* U buf.0, high */
387 reg_w(sd, 0x28, v0 & 0xffff); /* V buf.0, low */
388 reg_w(sd, 0x29, v0 >> 16); /* V buf.0, high */
390 reg_w(sd, 0x22, y1 & 0xffff); /* Y buf.1, low */
391 reg_w(sd, 0x23, y1 >> 16); /* Y buf.1, high */
392 reg_w(sd, 0x26, u1 & 0xffff); /* U buf.1, low */
393 reg_w(sd, 0x27, u1 >> 16); /* U buf.1, high */
394 reg_w(sd, 0x2a, v1 & 0xffff); /* V buf.1, low */
395 reg_w(sd, 0x2b, v1 >> 16); /* V buf.1, high */
397 reg_w(sd, 0x32, y1 & 0xffff); /* JPEG buf 0 low */
398 reg_w(sd, 0x33, y1 >> 16); /* JPEG buf 0 high */
400 reg_w(sd, 0x34, y1 & 0xffff); /* JPEG buf 1 low */
401 reg_w(sd, 0x35, y1 >> 16); /* JPEG bug 1 high */
403 reg_w(sd, 0x36, 0x0000);/* JPEG restart interval */
404 reg_w(sd, 0x37, 0x0804);/*JPEG VLE FIFO threshold*/
405 reg_w(sd, 0x38, 0x0000);/* disable hw up-scaling */
406 reg_w(sd, 0x3f, 0x0000); /* JPEG/MCTL test data */
409 static void w9968cf_set_crop_window(struct sd *sd)
411 int start_cropx, start_cropy, x, y, fw, fh, cw, ch,
412 max_width, max_height;
422 if (sd->sensor == SEN_OV7620) {
424 * Sigh, this is dependend on the clock / framerate changes
425 * made by the frequency control, sick.
427 * Note we cannot use v4l2_ctrl_g_ctrl here, as we get called
428 * from ov519.c:setfreq() with the ctrl lock held!
430 if (sd->freq->val == 1) {
442 /* Work around to avoid FP arithmetics */
443 #define SC(x) ((x) << 10)
445 /* Scaling factors */
446 fw = SC(sd->gspca_dev.pixfmt.width) / max_width;
447 fh = SC(sd->gspca_dev.pixfmt.height) / max_height;
449 cw = (fw >= fh) ? max_width : SC(sd->gspca_dev.pixfmt.width) / fh;
450 ch = (fw >= fh) ? SC(sd->gspca_dev.pixfmt.height) / fw : max_height;
452 sd->sensor_width = max_width;
453 sd->sensor_height = max_height;
455 x = (max_width - cw) / 2;
456 y = (max_height - ch) / 2;
458 reg_w(sd, 0x10, start_cropx + x);
459 reg_w(sd, 0x11, start_cropy + y);
460 reg_w(sd, 0x12, start_cropx + x + cw);
461 reg_w(sd, 0x13, start_cropy + y + ch);
464 static void w9968cf_mode_init_regs(struct sd *sd)
466 int val, vs_polarity, hs_polarity;
468 w9968cf_set_crop_window(sd);
470 reg_w(sd, 0x14, sd->gspca_dev.pixfmt.width);
471 reg_w(sd, 0x15, sd->gspca_dev.pixfmt.height);
473 /* JPEG width & height */
474 reg_w(sd, 0x30, sd->gspca_dev.pixfmt.width);
475 reg_w(sd, 0x31, sd->gspca_dev.pixfmt.height);
477 /* Y & UV frame buffer strides (in WORD) */
478 if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
480 reg_w(sd, 0x2c, sd->gspca_dev.pixfmt.width / 2);
481 reg_w(sd, 0x2d, sd->gspca_dev.pixfmt.width / 4);
483 reg_w(sd, 0x2c, sd->gspca_dev.pixfmt.width);
485 reg_w(sd, 0x00, 0xbf17); /* reset everything */
486 reg_w(sd, 0x00, 0xbf10); /* normal operation */
488 /* Transfer size in WORDS (for UYVY format only) */
489 val = sd->gspca_dev.pixfmt.width * sd->gspca_dev.pixfmt.height;
490 reg_w(sd, 0x3d, val & 0xffff); /* low bits */
491 reg_w(sd, 0x3e, val >> 16); /* high bits */
493 if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
495 /* We may get called multiple times (usb isoc bw negotiat.) */
496 jpeg_define(sd->jpeg_hdr, sd->gspca_dev.pixfmt.height,
497 sd->gspca_dev.pixfmt.width, 0x22); /* JPEG 420 */
498 jpeg_set_qual(sd->jpeg_hdr, v4l2_ctrl_g_ctrl(sd->jpegqual));
499 w9968cf_upload_quantizationtables(sd);
500 v4l2_ctrl_grab(sd->jpegqual, true);
503 /* Video Capture Control Register */
504 if (sd->sensor == SEN_OV7620) {
505 /* Seems to work around a bug in the image sensor */
513 val = (vs_polarity << 12) | (hs_polarity << 11);
515 /* NOTE: We may not have enough memory to do double buffering while
516 doing compression (amount of memory differs per model cam).
517 So we use the second image buffer also as jpeg stream buffer
518 (see w9968cf_init), and disable double buffering. */
519 if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
521 /* val |= 0x0002; YUV422P */
522 val |= 0x0003; /* YUV420P */
524 val |= 0x0080; /* Enable HW double buffering */
526 /* val |= 0x0020; enable clamping */
527 /* val |= 0x0008; enable (1-2-1) filter */
528 /* val |= 0x000c; enable (2-3-6-3-2) filter */
530 val |= 0x8000; /* capt. enable */
532 reg_w(sd, 0x16, val);
534 sd->gspca_dev.empty_packet = 0;
537 static void w9968cf_stop0(struct sd *sd)
539 v4l2_ctrl_grab(sd->jpegqual, false);
540 reg_w(sd, 0x39, 0x0000); /* disable JPEG encoder */
541 reg_w(sd, 0x16, 0x0000); /* stop video capture */
544 /* The w9968cf docs say that a 0 sized packet means EOF (and also SOF
545 for the next frame). This seems to simply not be true when operating
546 in JPEG mode, in this case there may be empty packets within the
547 frame. So in JPEG mode use the JPEG SOI marker to detect SOF.
549 Note to make things even more interesting the w9968cf sends *PLANAR* jpeg,
550 to be precise it sends: SOI, SOF, DRI, SOS, Y-data, SOS, U-data, SOS,
552 static void w9968cf_pkt_scan(struct gspca_dev *gspca_dev,
553 u8 *data, /* isoc packet */
554 int len) /* iso packet length */
556 struct sd *sd = (struct sd *) gspca_dev;
558 if (w9968cf_vga_mode[gspca_dev->curr_mode].pixelformat ==
563 gspca_frame_add(gspca_dev, LAST_PACKET,
565 gspca_frame_add(gspca_dev, FIRST_PACKET,
566 sd->jpeg_hdr, JPEG_HDR_SZ);
567 /* Strip the ff d8, our own header (which adds
568 huffman and quantization tables) already has this */
573 /* In UYVY mode an empty packet signals EOF */
574 if (gspca_dev->empty_packet) {
575 gspca_frame_add(gspca_dev, LAST_PACKET,
577 gspca_frame_add(gspca_dev, FIRST_PACKET,
579 gspca_dev->empty_packet = 0;
582 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);