2 * Zoran 364xx based USB webcam module version 0.73
4 * Allows you to use your USB webcam with V4L2 applications
5 * This is still in heavy developpement !
7 * Copyright (C) 2004 Antoine Jacquet <royale@zerezo.com>
8 * http://royale.zerezo.com/zr364xx/
10 * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
11 * V4L2 version inspired by meye.c driver
13 * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/usb.h>
34 #include <linux/vmalloc.h>
35 #include <linux/slab.h>
36 #include <linux/proc_fs.h>
37 #include <linux/highmem.h>
38 #include <media/v4l2-common.h>
39 #include <media/v4l2-ioctl.h>
40 #include <media/v4l2-device.h>
41 #include <media/v4l2-ctrls.h>
42 #include <media/v4l2-fh.h>
43 #include <media/v4l2-event.h>
44 #include <media/videobuf-vmalloc.h>
47 /* Version Information */
48 #define DRIVER_VERSION "0.7.4"
49 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
50 #define DRIVER_DESC "Zoran 364xx"
55 #define MAX_FRAME_SIZE 200000
56 #define BUFFER_SIZE 0x1000
57 #define CTRL_TIMEOUT 500
59 #define ZR364XX_DEF_BUFS 4
60 #define ZR364XX_READ_IDLE 0
61 #define ZR364XX_READ_FRAME 1
64 #define DBG(fmt, args...) \
67 printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
71 /*#define FULL_DEBUG 1*/
75 #define _DBG(fmt, args...)
78 /* Init methods, need to find nicer names for these
79 * the exact names of the chipsets would be the best if someone finds it */
86 /* Module parameters */
91 /* Module parameters interface */
92 module_param(debug, int, 0644);
93 MODULE_PARM_DESC(debug, "Debug level");
94 module_param(mode, int, 0644);
95 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
98 /* Devices supported by this driver
99 * .driver_info contains the init method used by the camera */
100 static struct usb_device_id device_table[] = {
101 {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
102 {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
103 {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
104 {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
105 {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
106 {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
107 {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
108 {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
109 {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
110 {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
111 {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
112 {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
113 {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
114 {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
115 {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
116 {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
117 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
118 {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
119 {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
120 {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 },
121 {USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 },
122 {} /* Terminating entry */
125 MODULE_DEVICE_TABLE(usb, device_table);
127 /* frame structure */
128 struct zr364xx_framei {
129 unsigned long ulState; /* ulState:ZR364XX_READ_IDLE,
130 ZR364XX_READ_FRAME */
131 void *lpvbits; /* image data */
132 unsigned long cur_size; /* current data copied to it */
135 /* image buffer structure */
136 struct zr364xx_bufferi {
137 unsigned long dwFrames; /* number of frames in buffer */
138 struct zr364xx_framei frame[FRAMES]; /* array of FRAME structures */
141 struct zr364xx_dmaqueue {
142 struct list_head active;
143 struct zr364xx_camera *cam;
146 struct zr364xx_pipeinfo {
151 void *cam; /* back pointer to zr364xx_camera struct */
163 static const struct zr364xx_fmt formats[] = {
166 .fourcc = V4L2_PIX_FMT_JPEG,
172 struct zr364xx_camera {
173 struct usb_device *udev; /* save off the usb device pointer */
174 struct usb_interface *interface;/* the interface for this device */
175 struct v4l2_device v4l2_dev;
176 struct v4l2_ctrl_handler ctrl_handler;
177 struct video_device vdev; /* v4l video device */
178 struct v4l2_fh *owner; /* owns the streaming */
180 struct zr364xx_bufferi buffer;
188 struct zr364xx_dmaqueue vidq;
191 unsigned long frame_count;
193 struct zr364xx_pipeinfo pipe[1];
197 const struct zr364xx_fmt *fmt;
198 struct videobuf_queue vb_vidq;
202 /* buffer for one video frame */
203 struct zr364xx_buffer {
204 /* common v4l buffer stuff -- must be first */
205 struct videobuf_buffer vb;
206 const struct zr364xx_fmt *fmt;
209 /* function used to send initialisation commands to the camera */
210 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
211 u16 index, unsigned char *cp, u16 size)
215 unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
216 if (!transfer_buffer) {
217 dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
221 memcpy(transfer_buffer, cp, size);
223 status = usb_control_msg(udev,
224 usb_sndctrlpipe(udev, 0),
226 USB_DIR_OUT | USB_TYPE_VENDOR |
227 USB_RECIP_DEVICE, value, index,
228 transfer_buffer, size, CTRL_TIMEOUT);
230 kfree(transfer_buffer);
235 /* Control messages sent to the camera to initialize it
236 * and launch the capture */
240 unsigned char *bytes;
244 static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
245 static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
246 static unsigned char m0d3[] = { 0, 0 };
247 static message m0[] = {
250 {0x3370, sizeof(m0d1), m0d1},
253 {0x2610, sizeof(m0d2), m0d2},
258 {0x9a01, sizeof(m0d3), m0d3},
263 static unsigned char m1d1[] = { 0xff, 0xff };
264 static unsigned char m1d2[] = { 0x00, 0x00 };
265 static message m1[] = {
273 {0x2502, sizeof(m1d1), m1d1},
278 {0x9a01, sizeof(m1d2), m1d2},
283 static unsigned char m2d1[] = { 0xff, 0xff };
284 static message m2[] = {
291 {0x2502, sizeof(m2d1), m2d1},
297 static message *init[4] = { m0, m1, m2, m2 };
300 /* JPEG static data in header (Huffman table, etc) */
301 static unsigned char header1[] = {
304 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
305 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
307 0xFF, 0xDB, 0x00, 0x84
309 static unsigned char header2[] = {
310 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
311 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
313 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
314 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
315 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
316 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
317 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
318 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
319 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
320 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
321 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
322 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
323 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
324 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
325 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
326 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
327 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
328 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
329 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
330 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
331 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
332 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
333 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
334 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
335 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
336 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
337 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
338 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
339 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
340 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
341 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
342 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
343 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
344 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
345 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
346 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
347 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
348 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
349 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
350 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
351 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
354 static unsigned char header3;
356 /* ------------------------------------------------------------------
358 ------------------------------------------------------------------*/
360 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
363 struct zr364xx_camera *cam = vq->priv_data;
365 *size = cam->width * cam->height * (cam->fmt->depth >> 3);
368 *count = ZR364XX_DEF_BUFS;
370 if (*size * *count > ZR364XX_DEF_BUFS * 1024 * 1024)
371 *count = (ZR364XX_DEF_BUFS * 1024 * 1024) / *size;
376 static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
378 _DBG("%s\n", __func__);
383 videobuf_vmalloc_free(&buf->vb);
384 buf->vb.state = VIDEOBUF_NEEDS_INIT;
387 static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
388 enum v4l2_field field)
390 struct zr364xx_camera *cam = vq->priv_data;
391 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
395 DBG("%s, field=%d, fmt name = %s\n", __func__, field, cam->fmt != NULL ?
396 cam->fmt->name : "");
397 if (cam->fmt == NULL)
400 buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
402 if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
403 DBG("invalid buffer prepare\n");
408 buf->vb.width = cam->width;
409 buf->vb.height = cam->height;
410 buf->vb.field = field;
412 if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
413 rc = videobuf_iolock(vq, &buf->vb, NULL);
418 buf->vb.state = VIDEOBUF_PREPARED;
421 free_buffer(vq, buf);
425 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
427 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
429 struct zr364xx_camera *cam = vq->priv_data;
431 _DBG("%s\n", __func__);
433 buf->vb.state = VIDEOBUF_QUEUED;
434 list_add_tail(&buf->vb.queue, &cam->vidq.active);
437 static void buffer_release(struct videobuf_queue *vq,
438 struct videobuf_buffer *vb)
440 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
443 _DBG("%s\n", __func__);
444 free_buffer(vq, buf);
447 static struct videobuf_queue_ops zr364xx_video_qops = {
448 .buf_setup = buffer_setup,
449 .buf_prepare = buffer_prepare,
450 .buf_queue = buffer_queue,
451 .buf_release = buffer_release,
454 /********************/
455 /* V4L2 integration */
456 /********************/
457 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
458 enum v4l2_buf_type type);
460 static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
463 struct zr364xx_camera *cam = video_drvdata(file);
466 _DBG("%s\n", __func__);
474 if (mutex_lock_interruptible(&cam->lock))
477 err = zr364xx_vidioc_streamon(file, file->private_data,
478 V4L2_BUF_TYPE_VIDEO_CAPTURE);
480 DBG("%s: reading %d bytes at pos %d.\n", __func__,
481 (int) count, (int) *ppos);
484 err = videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
485 file->f_flags & O_NONBLOCK);
487 mutex_unlock(&cam->lock);
491 /* video buffer vmalloc implementation based partly on VIVI driver which is
492 * Copyright (c) 2006 by
493 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
494 * Ted Walther <ted--a.t--enumera.com>
495 * John Sokol <sokol--a.t--videotechnology.com>
496 * http://v4l.videotechnology.com/
499 static void zr364xx_fillbuff(struct zr364xx_camera *cam,
500 struct zr364xx_buffer *buf,
506 char *vbuf = videobuf_to_vmalloc(&buf->vb);
507 unsigned long last_frame;
512 last_frame = cam->last_frame;
513 if (last_frame != -1) {
514 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
515 switch (buf->fmt->fourcc) {
516 case V4L2_PIX_FMT_JPEG:
517 buf->vb.size = jpgsize;
518 memcpy(vbuf, tmpbuf, buf->vb.size);
521 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
523 cam->last_frame = -1;
525 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
528 DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
529 (unsigned long)vbuf, pos);
530 /* tell v4l buffer was filled */
532 buf->vb.field_count = cam->frame_count * 2;
533 do_gettimeofday(&ts);
535 buf->vb.state = VIDEOBUF_DONE;
538 static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
540 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
541 struct zr364xx_buffer *buf;
542 unsigned long flags = 0;
545 DBG("wakeup: %p\n", &dma_q);
546 spin_lock_irqsave(&cam->slock, flags);
548 if (list_empty(&dma_q->active)) {
549 DBG("No active queue to serve\n");
553 buf = list_entry(dma_q->active.next,
554 struct zr364xx_buffer, vb.queue);
556 if (!waitqueue_active(&buf->vb.done)) {
561 list_del(&buf->vb.queue);
562 do_gettimeofday(&buf->vb.ts);
563 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
564 zr364xx_fillbuff(cam, buf, jpgsize);
565 wake_up(&buf->vb.done);
566 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
568 spin_unlock_irqrestore(&cam->slock, flags);
572 /* this function moves the usb stream read pipe data
573 * into the system buffers.
574 * returns 0 on success, EAGAIN if more data to process (call this
577 static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
578 struct zr364xx_pipeinfo *pipe_info,
581 unsigned char *pdest;
584 struct zr364xx_framei *frm;
586 unsigned char *ptr = NULL;
588 _DBG("buffer to user\n");
589 idx = cam->cur_frame;
590 frm = &cam->buffer.frame[idx];
592 /* swap bytes if camera needs it */
593 if (cam->method == METHOD0) {
594 u16 *buf = (u16 *)pipe_info->transfer_buffer;
595 for (i = 0; i < purb->actual_length/2; i++)
599 /* search done. now find out if should be acquiring */
600 if (!cam->b_acquire) {
601 /* we found a frame, but this channel is turned off */
602 frm->ulState = ZR364XX_READ_IDLE;
606 psrc = (u8 *)pipe_info->transfer_buffer;
607 ptr = pdest = frm->lpvbits;
609 if (frm->ulState == ZR364XX_READ_IDLE) {
610 frm->ulState = ZR364XX_READ_FRAME;
613 _DBG("jpeg header, ");
614 memcpy(ptr, header1, sizeof(header1));
615 ptr += sizeof(header1);
617 memcpy(ptr, &header3, 1);
619 memcpy(ptr, psrc, 64);
622 memcpy(ptr, &header3, 1);
624 memcpy(ptr, psrc + 64, 64);
626 memcpy(ptr, header2, sizeof(header2));
627 ptr += sizeof(header2);
628 memcpy(ptr, psrc + 128,
629 purb->actual_length - 128);
630 ptr += purb->actual_length - 128;
631 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
632 psrc[0], psrc[1], psrc[2],
633 psrc[3], psrc[4], psrc[5],
634 psrc[6], psrc[7], psrc[8]);
635 frm->cur_size = ptr - pdest;
637 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
638 dev_info(&cam->udev->dev,
639 "%s: buffer (%d bytes) too small to hold "
640 "frame data. Discarding frame data.\n",
641 __func__, MAX_FRAME_SIZE);
643 pdest += frm->cur_size;
644 memcpy(pdest, psrc, purb->actual_length);
645 frm->cur_size += purb->actual_length;
648 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
649 purb->actual_length);*/
651 if (purb->actual_length < pipe_info->transfer_size) {
652 _DBG("****************Buffer[%d]full*************\n", idx);
653 cam->last_frame = cam->cur_frame;
655 /* end of system frame ring buffer, start at zero */
656 if (cam->cur_frame == cam->buffer.dwFrames)
660 /* go back to find the JPEG EOI marker */
661 ptr = pdest = frm->lpvbits;
662 ptr += frm->cur_size - 2;
663 while (ptr > pdest) {
664 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
665 && *(ptr + 2) == 0xFF)
670 DBG("No EOI marker\n");
672 /* Sometimes there is junk data in the middle of the picture,
673 * we want to skip this bogus frames */
674 while (ptr > pdest) {
675 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
676 && *(ptr + 2) == 0xFF)
681 DBG("Bogus frame ? %d\n", ++(cam->nb));
682 } else if (cam->b_acquire) {
683 /* we skip the 2 first frames which are usually buggy */
687 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
689 pdest[0], pdest[1], pdest[2], pdest[3],
690 pdest[4], pdest[5], pdest[6], pdest[7]);
692 zr364xx_got_frame(cam, frm->cur_size);
696 frm->ulState = ZR364XX_READ_IDLE;
699 /* done successfully */
703 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
704 struct v4l2_capability *cap)
706 struct zr364xx_camera *cam = video_drvdata(file);
708 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
709 strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
710 strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
711 sizeof(cap->bus_info));
712 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
715 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
720 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
721 struct v4l2_input *i)
725 strcpy(i->name, DRIVER_DESC " Camera");
726 i->type = V4L2_INPUT_TYPE_CAMERA;
730 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
737 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
745 static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
747 struct zr364xx_camera *cam =
748 container_of(ctrl->handler, struct zr364xx_camera, ctrl_handler);
752 case V4L2_CID_BRIGHTNESS:
753 /* hardware brightness */
754 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
755 temp = (0x60 << 8) + 127 - ctrl->val;
756 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
765 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
766 void *priv, struct v4l2_fmtdesc *f)
770 f->flags = V4L2_FMT_FLAG_COMPRESSED;
771 strcpy(f->description, formats[0].name);
772 f->pixelformat = formats[0].fourcc;
776 static char *decode_fourcc(__u32 pixelformat, char *buf)
778 buf[0] = pixelformat & 0xff;
779 buf[1] = (pixelformat >> 8) & 0xff;
780 buf[2] = (pixelformat >> 16) & 0xff;
781 buf[3] = (pixelformat >> 24) & 0xff;
786 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
787 struct v4l2_format *f)
789 struct zr364xx_camera *cam = video_drvdata(file);
790 char pixelformat_name[5];
795 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
796 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
797 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
801 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
802 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
803 f->fmt.pix.width = 320;
804 f->fmt.pix.height = 240;
807 f->fmt.pix.field = V4L2_FIELD_NONE;
808 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
809 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
810 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
812 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
813 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
818 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
819 struct v4l2_format *f)
821 struct zr364xx_camera *cam;
825 cam = video_drvdata(file);
827 f->fmt.pix.pixelformat = formats[0].fourcc;
828 f->fmt.pix.field = V4L2_FIELD_NONE;
829 f->fmt.pix.width = cam->width;
830 f->fmt.pix.height = cam->height;
831 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
832 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
833 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
838 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
839 struct v4l2_format *f)
841 struct zr364xx_camera *cam = video_drvdata(file);
842 struct videobuf_queue *q = &cam->vb_vidq;
843 char pixelformat_name[5];
844 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
850 mutex_lock(&q->vb_lock);
852 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
853 DBG("%s queue busy\n", __func__);
859 DBG("%s can't change format after started\n", __func__);
864 cam->width = f->fmt.pix.width;
865 cam->height = f->fmt.pix.height;
866 DBG("%s: %dx%d mode selected\n", __func__,
867 cam->width, cam->height);
868 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
869 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
870 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
872 cam->vb_vidq.field = f->fmt.pix.field;
874 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
876 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
882 m1[2].value = 0xf000 + mode;
883 m2[1].value = 0xf000 + mode;
885 /* special case for METHOD3, the modes are different */
886 if (cam->method == METHOD3) {
889 m2[1].value = 0xf000 + 4;
892 m2[1].value = 0xf000 + 0;
895 m2[1].value = 0xf000 + 1;
900 header2[437] = cam->height / 256;
901 header2[438] = cam->height % 256;
902 header2[439] = cam->width / 256;
903 header2[440] = cam->width % 256;
905 for (i = 0; init[cam->method][i].size != -1; i++) {
907 send_control_msg(cam->udev, 1, init[cam->method][i].value,
908 0, init[cam->method][i].bytes,
909 init[cam->method][i].size);
911 dev_err(&cam->udev->dev,
912 "error during resolution change sequence: %d\n", i);
917 /* Added some delay here, since opening/closing the camera quickly,
918 * like Ekiga does during its startup, can crash the webcam
925 mutex_unlock(&q->vb_lock);
927 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
928 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
933 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
934 struct v4l2_requestbuffers *p)
936 struct zr364xx_camera *cam = video_drvdata(file);
938 if (cam->owner && cam->owner != priv)
940 return videobuf_reqbufs(&cam->vb_vidq, p);
943 static int zr364xx_vidioc_querybuf(struct file *file,
945 struct v4l2_buffer *p)
948 struct zr364xx_camera *cam = video_drvdata(file);
949 rc = videobuf_querybuf(&cam->vb_vidq, p);
953 static int zr364xx_vidioc_qbuf(struct file *file,
955 struct v4l2_buffer *p)
958 struct zr364xx_camera *cam = video_drvdata(file);
959 _DBG("%s\n", __func__);
960 if (cam->owner && cam->owner != priv)
962 rc = videobuf_qbuf(&cam->vb_vidq, p);
966 static int zr364xx_vidioc_dqbuf(struct file *file,
968 struct v4l2_buffer *p)
971 struct zr364xx_camera *cam = video_drvdata(file);
972 _DBG("%s\n", __func__);
973 if (cam->owner && cam->owner != priv)
975 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
979 static void read_pipe_completion(struct urb *purb)
981 struct zr364xx_pipeinfo *pipe_info;
982 struct zr364xx_camera *cam;
985 pipe_info = purb->context;
986 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
987 if (pipe_info == NULL) {
988 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
992 cam = pipe_info->cam;
994 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
998 /* if shutting down, do not resubmit, exit immediately */
999 if (purb->status == -ESHUTDOWN) {
1000 DBG("%s, err shutdown\n", __func__);
1001 pipe_info->err_count++;
1005 if (pipe_info->state == 0) {
1006 DBG("exiting USB pipe\n");
1010 if (purb->actual_length < 0 ||
1011 purb->actual_length > pipe_info->transfer_size) {
1012 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1016 if (purb->status == 0)
1017 zr364xx_read_video_callback(cam, pipe_info, purb);
1019 pipe_info->err_count++;
1020 DBG("%s: failed URB %d\n", __func__, purb->status);
1023 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1026 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1028 pipe_info->transfer_buffer,
1029 pipe_info->transfer_size,
1030 read_pipe_completion, pipe_info);
1032 if (pipe_info->state != 0) {
1033 purb->status = usb_submit_urb(pipe_info->stream_urb,
1037 dev_err(&cam->udev->dev,
1038 "error submitting urb (error=%i)\n",
1041 DBG("read pipe complete state 0\n");
1044 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1048 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1049 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1050 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1052 pipe_info->state = 1;
1053 pipe_info->err_count = 0;
1054 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1055 if (!pipe_info->stream_urb) {
1056 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1059 /* transfer buffer allocated in board_init */
1060 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1062 pipe_info->transfer_buffer,
1063 pipe_info->transfer_size,
1064 read_pipe_completion, pipe_info);
1066 DBG("submitting URB %p\n", pipe_info->stream_urb);
1067 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1069 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1076 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1078 struct zr364xx_pipeinfo *pipe_info;
1081 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1084 DBG("stop read pipe\n");
1085 pipe_info = cam->pipe;
1087 if (pipe_info->state != 0)
1088 pipe_info->state = 0;
1090 if (pipe_info->stream_urb) {
1092 usb_kill_urb(pipe_info->stream_urb);
1093 usb_free_urb(pipe_info->stream_urb);
1094 pipe_info->stream_urb = NULL;
1100 /* starts acquisition process */
1101 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1105 DBG("start acquire\n");
1107 cam->last_frame = -1;
1109 for (j = 0; j < FRAMES; j++) {
1110 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1111 cam->buffer.frame[j].cur_size = 0;
1117 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1123 static int zr364xx_prepare(struct zr364xx_camera *cam)
1128 for (i = 0; init[cam->method][i].size != -1; i++) {
1129 res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1130 0, init[cam->method][i].bytes,
1131 init[cam->method][i].size);
1133 dev_err(&cam->udev->dev,
1134 "error during open sequence: %d\n", i);
1140 cam->last_frame = -1;
1142 cam->frame_count = 0;
1143 for (j = 0; j < FRAMES; j++) {
1144 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1145 cam->buffer.frame[j].cur_size = 0;
1147 v4l2_ctrl_handler_setup(&cam->ctrl_handler);
1151 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1152 enum v4l2_buf_type type)
1154 struct zr364xx_camera *cam = video_drvdata(file);
1157 DBG("%s\n", __func__);
1159 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1162 if (cam->owner && cam->owner != priv)
1165 res = zr364xx_prepare(cam);
1168 res = videobuf_streamon(&cam->vb_vidq);
1170 zr364xx_start_acquire(cam);
1171 cam->owner = file->private_data;
1176 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1177 enum v4l2_buf_type type)
1179 struct zr364xx_camera *cam = video_drvdata(file);
1181 DBG("%s\n", __func__);
1182 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1184 if (cam->owner && cam->owner != priv)
1186 zr364xx_stop_acquire(cam);
1187 return videobuf_streamoff(&cam->vb_vidq);
1191 /* open the camera */
1192 static int zr364xx_open(struct file *file)
1194 struct zr364xx_camera *cam = video_drvdata(file);
1197 DBG("%s\n", __func__);
1199 if (mutex_lock_interruptible(&cam->lock))
1200 return -ERESTARTSYS;
1202 err = v4l2_fh_open(file);
1206 /* Added some delay here, since opening/closing the camera quickly,
1207 * like Ekiga does during its startup, can crash the webcam
1213 mutex_unlock(&cam->lock);
1214 DBG("%s: %d\n", __func__, err);
1218 static void zr364xx_release(struct v4l2_device *v4l2_dev)
1220 struct zr364xx_camera *cam =
1221 container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
1224 v4l2_device_unregister(&cam->v4l2_dev);
1226 videobuf_mmap_free(&cam->vb_vidq);
1228 /* release sys buffers */
1229 for (i = 0; i < FRAMES; i++) {
1230 if (cam->buffer.frame[i].lpvbits) {
1231 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1232 vfree(cam->buffer.frame[i].lpvbits);
1234 cam->buffer.frame[i].lpvbits = NULL;
1237 v4l2_ctrl_handler_free(&cam->ctrl_handler);
1238 /* release transfer buffer */
1239 kfree(cam->pipe->transfer_buffer);
1243 /* release the camera */
1244 static int zr364xx_close(struct file *file)
1246 struct zr364xx_camera *cam;
1247 struct usb_device *udev;
1250 DBG("%s\n", __func__);
1251 cam = video_drvdata(file);
1253 mutex_lock(&cam->lock);
1256 if (file->private_data == cam->owner) {
1257 /* turn off stream */
1259 zr364xx_stop_acquire(cam);
1260 videobuf_streamoff(&cam->vb_vidq);
1262 for (i = 0; i < 2; i++) {
1263 send_control_msg(udev, 1, init[cam->method][i].value,
1264 0, init[cam->method][i].bytes,
1265 init[cam->method][i].size);
1270 /* Added some delay here, since opening/closing the camera quickly,
1271 * like Ekiga does during its startup, can crash the webcam
1274 mutex_unlock(&cam->lock);
1275 return v4l2_fh_release(file);
1279 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1281 struct zr364xx_camera *cam = video_drvdata(file);
1285 DBG("%s: cam == NULL\n", __func__);
1288 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1290 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1292 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1293 (unsigned long)vma->vm_start,
1294 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1298 static unsigned int zr364xx_poll(struct file *file,
1299 struct poll_table_struct *wait)
1301 struct zr364xx_camera *cam = video_drvdata(file);
1302 struct videobuf_queue *q = &cam->vb_vidq;
1303 unsigned res = v4l2_ctrl_poll(file, wait);
1305 _DBG("%s\n", __func__);
1307 return res | videobuf_poll_stream(file, q, wait);
1310 static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1311 .s_ctrl = zr364xx_s_ctrl,
1314 static const struct v4l2_file_operations zr364xx_fops = {
1315 .owner = THIS_MODULE,
1316 .open = zr364xx_open,
1317 .release = zr364xx_close,
1318 .read = zr364xx_read,
1319 .mmap = zr364xx_mmap,
1320 .unlocked_ioctl = video_ioctl2,
1321 .poll = zr364xx_poll,
1324 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1325 .vidioc_querycap = zr364xx_vidioc_querycap,
1326 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1327 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1328 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1329 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
1330 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1331 .vidioc_g_input = zr364xx_vidioc_g_input,
1332 .vidioc_s_input = zr364xx_vidioc_s_input,
1333 .vidioc_streamon = zr364xx_vidioc_streamon,
1334 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1335 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1336 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1337 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1338 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
1339 .vidioc_log_status = v4l2_ctrl_log_status,
1340 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1341 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1344 static struct video_device zr364xx_template = {
1345 .name = DRIVER_DESC,
1346 .fops = &zr364xx_fops,
1347 .ioctl_ops = &zr364xx_ioctl_ops,
1348 .release = video_device_release_empty,
1353 /*******************/
1354 /* USB integration */
1355 /*******************/
1356 static int zr364xx_board_init(struct zr364xx_camera *cam)
1358 struct zr364xx_pipeinfo *pipe = cam->pipe;
1361 DBG("board init: %p\n", cam);
1362 memset(pipe, 0, sizeof(*pipe));
1364 pipe->transfer_size = BUFFER_SIZE;
1366 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1368 if (pipe->transfer_buffer == NULL) {
1369 DBG("out of memory!\n");
1374 cam->frame_count = 0;
1376 /*** start create system buffers ***/
1377 for (i = 0; i < FRAMES; i++) {
1378 /* always allocate maximum size for system buffers */
1379 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1381 DBG("valloc %p, idx %lu, pdata %p\n",
1382 &cam->buffer.frame[i], i,
1383 cam->buffer.frame[i].lpvbits);
1384 if (cam->buffer.frame[i].lpvbits == NULL) {
1385 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1386 "Using less frames\n");
1392 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1393 kfree(cam->pipe->transfer_buffer);
1394 cam->pipe->transfer_buffer = NULL;
1397 cam->buffer.dwFrames = i;
1399 /* make sure internal states are set */
1400 for (i = 0; i < FRAMES; i++) {
1401 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1402 cam->buffer.frame[i].cur_size = 0;
1406 cam->last_frame = -1;
1407 /*** end create system buffers ***/
1409 /* start read pipe */
1410 zr364xx_start_readpipe(cam);
1411 DBG(": board initialized\n");
1415 static int zr364xx_probe(struct usb_interface *intf,
1416 const struct usb_device_id *id)
1418 struct usb_device *udev = interface_to_usbdev(intf);
1419 struct zr364xx_camera *cam = NULL;
1420 struct usb_host_interface *iface_desc;
1421 struct usb_endpoint_descriptor *endpoint;
1422 struct v4l2_ctrl_handler *hdl;
1426 DBG("probing...\n");
1428 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1429 dev_info(&intf->dev, "model %04x:%04x detected\n",
1430 le16_to_cpu(udev->descriptor.idVendor),
1431 le16_to_cpu(udev->descriptor.idProduct));
1433 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1435 dev_err(&udev->dev, "cam: out of memory !\n");
1439 cam->v4l2_dev.release = zr364xx_release;
1440 err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1442 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1446 hdl = &cam->ctrl_handler;
1447 v4l2_ctrl_handler_init(hdl, 1);
1448 v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1449 V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1452 dev_err(&udev->dev, "couldn't register control\n");
1455 /* save the init method used by this camera */
1456 cam->method = id->driver_info;
1457 mutex_init(&cam->lock);
1458 cam->vdev = zr364xx_template;
1459 cam->vdev.lock = &cam->lock;
1460 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1461 cam->vdev.ctrl_handler = &cam->ctrl_handler;
1462 set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags);
1463 video_set_drvdata(&cam->vdev, cam);
1465 cam->vdev.debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1471 dev_info(&udev->dev, "160x120 mode selected\n");
1476 dev_info(&udev->dev, "640x480 mode selected\n");
1481 dev_info(&udev->dev, "320x240 mode selected\n");
1488 m1[2].value = 0xf000 + mode;
1489 m2[1].value = 0xf000 + mode;
1491 /* special case for METHOD3, the modes are different */
1492 if (cam->method == METHOD3) {
1495 m2[1].value = 0xf000 + 4;
1498 m2[1].value = 0xf000 + 0;
1501 m2[1].value = 0xf000 + 1;
1506 header2[437] = cam->height / 256;
1507 header2[438] = cam->height % 256;
1508 header2[439] = cam->width / 256;
1509 header2[440] = cam->width % 256;
1513 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1515 /* set up the endpoint information */
1516 iface_desc = intf->cur_altsetting;
1517 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1518 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1519 endpoint = &iface_desc->endpoint[i].desc;
1520 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1521 /* we found the bulk in endpoint */
1522 cam->read_endpoint = endpoint->bEndpointAddress;
1526 if (!cam->read_endpoint) {
1528 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1533 INIT_LIST_HEAD(&cam->vidq.active);
1534 cam->vidq.cam = cam;
1536 usb_set_intfdata(intf, cam);
1538 /* load zr364xx board specific */
1539 err = zr364xx_board_init(cam);
1541 err = v4l2_ctrl_handler_setup(hdl);
1545 spin_lock_init(&cam->slock);
1549 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1551 V4L2_BUF_TYPE_VIDEO_CAPTURE,
1553 sizeof(struct zr364xx_buffer), cam, &cam->lock);
1555 err = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1557 dev_err(&udev->dev, "video_register_device failed\n");
1561 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1562 video_device_node_name(&cam->vdev));
1566 v4l2_ctrl_handler_free(hdl);
1567 v4l2_device_unregister(&cam->v4l2_dev);
1573 static void zr364xx_disconnect(struct usb_interface *intf)
1575 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1577 mutex_lock(&cam->lock);
1578 usb_set_intfdata(intf, NULL);
1579 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1580 video_unregister_device(&cam->vdev);
1581 v4l2_device_disconnect(&cam->v4l2_dev);
1583 /* stops the read pipe if it is running */
1585 zr364xx_stop_acquire(cam);
1587 zr364xx_stop_readpipe(cam);
1588 mutex_unlock(&cam->lock);
1589 v4l2_device_put(&cam->v4l2_dev);
1594 static int zr364xx_suspend(struct usb_interface *intf, pm_message_t message)
1596 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1598 cam->was_streaming = cam->b_acquire;
1599 if (!cam->was_streaming)
1601 zr364xx_stop_acquire(cam);
1602 zr364xx_stop_readpipe(cam);
1606 static int zr364xx_resume(struct usb_interface *intf)
1608 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1611 if (!cam->was_streaming)
1614 zr364xx_start_readpipe(cam);
1615 res = zr364xx_prepare(cam);
1617 zr364xx_start_acquire(cam);
1622 /**********************/
1623 /* Module integration */
1624 /**********************/
1626 static struct usb_driver zr364xx_driver = {
1628 .probe = zr364xx_probe,
1629 .disconnect = zr364xx_disconnect,
1631 .suspend = zr364xx_suspend,
1632 .resume = zr364xx_resume,
1633 .reset_resume = zr364xx_resume,
1635 .id_table = device_table
1638 module_usb_driver(zr364xx_driver);
1640 MODULE_AUTHOR(DRIVER_AUTHOR);
1641 MODULE_DESCRIPTION(DRIVER_DESC);
1642 MODULE_LICENSE("GPL");
1643 MODULE_VERSION(DRIVER_VERSION);