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,
505 char *vbuf = videobuf_to_vmalloc(&buf->vb);
506 unsigned long last_frame;
511 last_frame = cam->last_frame;
512 if (last_frame != -1) {
513 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
514 switch (buf->fmt->fourcc) {
515 case V4L2_PIX_FMT_JPEG:
516 buf->vb.size = jpgsize;
517 memcpy(vbuf, tmpbuf, buf->vb.size);
520 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
522 cam->last_frame = -1;
524 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
527 DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
528 (unsigned long)vbuf, pos);
529 /* tell v4l buffer was filled */
531 buf->vb.field_count = cam->frame_count * 2;
532 v4l2_get_timestamp(&buf->vb.ts);
533 buf->vb.state = VIDEOBUF_DONE;
536 static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
538 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
539 struct zr364xx_buffer *buf;
540 unsigned long flags = 0;
543 DBG("wakeup: %p\n", &dma_q);
544 spin_lock_irqsave(&cam->slock, flags);
546 if (list_empty(&dma_q->active)) {
547 DBG("No active queue to serve\n");
551 buf = list_entry(dma_q->active.next,
552 struct zr364xx_buffer, vb.queue);
554 if (!waitqueue_active(&buf->vb.done)) {
559 list_del(&buf->vb.queue);
560 v4l2_get_timestamp(&buf->vb.ts);
561 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
562 zr364xx_fillbuff(cam, buf, jpgsize);
563 wake_up(&buf->vb.done);
564 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
566 spin_unlock_irqrestore(&cam->slock, flags);
570 /* this function moves the usb stream read pipe data
571 * into the system buffers.
572 * returns 0 on success, EAGAIN if more data to process (call this
575 static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
576 struct zr364xx_pipeinfo *pipe_info,
579 unsigned char *pdest;
582 struct zr364xx_framei *frm;
584 unsigned char *ptr = NULL;
586 _DBG("buffer to user\n");
587 idx = cam->cur_frame;
588 frm = &cam->buffer.frame[idx];
590 /* swap bytes if camera needs it */
591 if (cam->method == METHOD0) {
592 u16 *buf = (u16 *)pipe_info->transfer_buffer;
593 for (i = 0; i < purb->actual_length/2; i++)
597 /* search done. now find out if should be acquiring */
598 if (!cam->b_acquire) {
599 /* we found a frame, but this channel is turned off */
600 frm->ulState = ZR364XX_READ_IDLE;
604 psrc = (u8 *)pipe_info->transfer_buffer;
605 ptr = pdest = frm->lpvbits;
607 if (frm->ulState == ZR364XX_READ_IDLE) {
608 frm->ulState = ZR364XX_READ_FRAME;
611 _DBG("jpeg header, ");
612 memcpy(ptr, header1, sizeof(header1));
613 ptr += sizeof(header1);
615 memcpy(ptr, &header3, 1);
617 memcpy(ptr, psrc, 64);
620 memcpy(ptr, &header3, 1);
622 memcpy(ptr, psrc + 64, 64);
624 memcpy(ptr, header2, sizeof(header2));
625 ptr += sizeof(header2);
626 memcpy(ptr, psrc + 128,
627 purb->actual_length - 128);
628 ptr += purb->actual_length - 128;
629 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
630 psrc[0], psrc[1], psrc[2],
631 psrc[3], psrc[4], psrc[5],
632 psrc[6], psrc[7], psrc[8]);
633 frm->cur_size = ptr - pdest;
635 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
636 dev_info(&cam->udev->dev,
637 "%s: buffer (%d bytes) too small to hold "
638 "frame data. Discarding frame data.\n",
639 __func__, MAX_FRAME_SIZE);
641 pdest += frm->cur_size;
642 memcpy(pdest, psrc, purb->actual_length);
643 frm->cur_size += purb->actual_length;
646 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
647 purb->actual_length);*/
649 if (purb->actual_length < pipe_info->transfer_size) {
650 _DBG("****************Buffer[%d]full*************\n", idx);
651 cam->last_frame = cam->cur_frame;
653 /* end of system frame ring buffer, start at zero */
654 if (cam->cur_frame == cam->buffer.dwFrames)
658 /* go back to find the JPEG EOI marker */
659 ptr = pdest = frm->lpvbits;
660 ptr += frm->cur_size - 2;
661 while (ptr > pdest) {
662 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
663 && *(ptr + 2) == 0xFF)
668 DBG("No EOI marker\n");
670 /* Sometimes there is junk data in the middle of the picture,
671 * we want to skip this bogus frames */
672 while (ptr > pdest) {
673 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
674 && *(ptr + 2) == 0xFF)
679 DBG("Bogus frame ? %d\n", ++(cam->nb));
680 } else if (cam->b_acquire) {
681 /* we skip the 2 first frames which are usually buggy */
685 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
687 pdest[0], pdest[1], pdest[2], pdest[3],
688 pdest[4], pdest[5], pdest[6], pdest[7]);
690 zr364xx_got_frame(cam, frm->cur_size);
694 frm->ulState = ZR364XX_READ_IDLE;
697 /* done successfully */
701 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
702 struct v4l2_capability *cap)
704 struct zr364xx_camera *cam = video_drvdata(file);
706 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
707 strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
708 strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
709 sizeof(cap->bus_info));
710 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
713 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
718 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
719 struct v4l2_input *i)
723 strcpy(i->name, DRIVER_DESC " Camera");
724 i->type = V4L2_INPUT_TYPE_CAMERA;
728 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
735 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
743 static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
745 struct zr364xx_camera *cam =
746 container_of(ctrl->handler, struct zr364xx_camera, ctrl_handler);
750 case V4L2_CID_BRIGHTNESS:
751 /* hardware brightness */
752 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
753 temp = (0x60 << 8) + 127 - ctrl->val;
754 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
763 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
764 void *priv, struct v4l2_fmtdesc *f)
768 f->flags = V4L2_FMT_FLAG_COMPRESSED;
769 strcpy(f->description, formats[0].name);
770 f->pixelformat = formats[0].fourcc;
774 static char *decode_fourcc(__u32 pixelformat, char *buf)
776 buf[0] = pixelformat & 0xff;
777 buf[1] = (pixelformat >> 8) & 0xff;
778 buf[2] = (pixelformat >> 16) & 0xff;
779 buf[3] = (pixelformat >> 24) & 0xff;
784 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
785 struct v4l2_format *f)
787 struct zr364xx_camera *cam = video_drvdata(file);
788 char pixelformat_name[5];
793 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
794 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
795 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
799 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
800 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
801 f->fmt.pix.width = 320;
802 f->fmt.pix.height = 240;
805 f->fmt.pix.field = V4L2_FIELD_NONE;
806 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
807 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
808 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
809 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
810 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
815 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
816 struct v4l2_format *f)
818 struct zr364xx_camera *cam;
822 cam = video_drvdata(file);
824 f->fmt.pix.pixelformat = formats[0].fourcc;
825 f->fmt.pix.field = V4L2_FIELD_NONE;
826 f->fmt.pix.width = cam->width;
827 f->fmt.pix.height = cam->height;
828 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
829 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
830 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
834 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
835 struct v4l2_format *f)
837 struct zr364xx_camera *cam = video_drvdata(file);
838 struct videobuf_queue *q = &cam->vb_vidq;
839 char pixelformat_name[5];
840 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
846 mutex_lock(&q->vb_lock);
848 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
849 DBG("%s queue busy\n", __func__);
855 DBG("%s can't change format after started\n", __func__);
860 cam->width = f->fmt.pix.width;
861 cam->height = f->fmt.pix.height;
862 DBG("%s: %dx%d mode selected\n", __func__,
863 cam->width, cam->height);
864 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
865 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
866 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
867 cam->vb_vidq.field = f->fmt.pix.field;
869 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
871 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
877 m1[2].value = 0xf000 + mode;
878 m2[1].value = 0xf000 + mode;
880 /* special case for METHOD3, the modes are different */
881 if (cam->method == METHOD3) {
884 m2[1].value = 0xf000 + 4;
887 m2[1].value = 0xf000 + 0;
890 m2[1].value = 0xf000 + 1;
895 header2[437] = cam->height / 256;
896 header2[438] = cam->height % 256;
897 header2[439] = cam->width / 256;
898 header2[440] = cam->width % 256;
900 for (i = 0; init[cam->method][i].size != -1; i++) {
902 send_control_msg(cam->udev, 1, init[cam->method][i].value,
903 0, init[cam->method][i].bytes,
904 init[cam->method][i].size);
906 dev_err(&cam->udev->dev,
907 "error during resolution change sequence: %d\n", i);
912 /* Added some delay here, since opening/closing the camera quickly,
913 * like Ekiga does during its startup, can crash the webcam
920 mutex_unlock(&q->vb_lock);
922 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
923 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
928 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
929 struct v4l2_requestbuffers *p)
931 struct zr364xx_camera *cam = video_drvdata(file);
933 if (cam->owner && cam->owner != priv)
935 return videobuf_reqbufs(&cam->vb_vidq, p);
938 static int zr364xx_vidioc_querybuf(struct file *file,
940 struct v4l2_buffer *p)
943 struct zr364xx_camera *cam = video_drvdata(file);
944 rc = videobuf_querybuf(&cam->vb_vidq, p);
948 static int zr364xx_vidioc_qbuf(struct file *file,
950 struct v4l2_buffer *p)
953 struct zr364xx_camera *cam = video_drvdata(file);
954 _DBG("%s\n", __func__);
955 if (cam->owner && cam->owner != priv)
957 rc = videobuf_qbuf(&cam->vb_vidq, p);
961 static int zr364xx_vidioc_dqbuf(struct file *file,
963 struct v4l2_buffer *p)
966 struct zr364xx_camera *cam = video_drvdata(file);
967 _DBG("%s\n", __func__);
968 if (cam->owner && cam->owner != priv)
970 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
974 static void read_pipe_completion(struct urb *purb)
976 struct zr364xx_pipeinfo *pipe_info;
977 struct zr364xx_camera *cam;
980 pipe_info = purb->context;
981 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
982 if (pipe_info == NULL) {
983 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
987 cam = pipe_info->cam;
989 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
993 /* if shutting down, do not resubmit, exit immediately */
994 if (purb->status == -ESHUTDOWN) {
995 DBG("%s, err shutdown\n", __func__);
996 pipe_info->err_count++;
1000 if (pipe_info->state == 0) {
1001 DBG("exiting USB pipe\n");
1005 if (purb->actual_length > pipe_info->transfer_size) {
1006 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1010 if (purb->status == 0)
1011 zr364xx_read_video_callback(cam, pipe_info, purb);
1013 pipe_info->err_count++;
1014 DBG("%s: failed URB %d\n", __func__, purb->status);
1017 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1020 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1022 pipe_info->transfer_buffer,
1023 pipe_info->transfer_size,
1024 read_pipe_completion, pipe_info);
1026 if (pipe_info->state != 0) {
1027 purb->status = usb_submit_urb(pipe_info->stream_urb,
1031 dev_err(&cam->udev->dev,
1032 "error submitting urb (error=%i)\n",
1035 DBG("read pipe complete state 0\n");
1038 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1042 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1043 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1044 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1046 pipe_info->state = 1;
1047 pipe_info->err_count = 0;
1048 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1049 if (!pipe_info->stream_urb) {
1050 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1053 /* transfer buffer allocated in board_init */
1054 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1056 pipe_info->transfer_buffer,
1057 pipe_info->transfer_size,
1058 read_pipe_completion, pipe_info);
1060 DBG("submitting URB %p\n", pipe_info->stream_urb);
1061 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1063 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1070 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1072 struct zr364xx_pipeinfo *pipe_info;
1075 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1078 DBG("stop read pipe\n");
1079 pipe_info = cam->pipe;
1081 if (pipe_info->state != 0)
1082 pipe_info->state = 0;
1084 if (pipe_info->stream_urb) {
1086 usb_kill_urb(pipe_info->stream_urb);
1087 usb_free_urb(pipe_info->stream_urb);
1088 pipe_info->stream_urb = NULL;
1094 /* starts acquisition process */
1095 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1099 DBG("start acquire\n");
1101 cam->last_frame = -1;
1103 for (j = 0; j < FRAMES; j++) {
1104 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1105 cam->buffer.frame[j].cur_size = 0;
1111 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1117 static int zr364xx_prepare(struct zr364xx_camera *cam)
1122 for (i = 0; init[cam->method][i].size != -1; i++) {
1123 res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1124 0, init[cam->method][i].bytes,
1125 init[cam->method][i].size);
1127 dev_err(&cam->udev->dev,
1128 "error during open sequence: %d\n", i);
1134 cam->last_frame = -1;
1136 cam->frame_count = 0;
1137 for (j = 0; j < FRAMES; j++) {
1138 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1139 cam->buffer.frame[j].cur_size = 0;
1141 v4l2_ctrl_handler_setup(&cam->ctrl_handler);
1145 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1146 enum v4l2_buf_type type)
1148 struct zr364xx_camera *cam = video_drvdata(file);
1151 DBG("%s\n", __func__);
1153 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1156 if (cam->owner && cam->owner != priv)
1159 res = zr364xx_prepare(cam);
1162 res = videobuf_streamon(&cam->vb_vidq);
1164 zr364xx_start_acquire(cam);
1165 cam->owner = file->private_data;
1170 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1171 enum v4l2_buf_type type)
1173 struct zr364xx_camera *cam = video_drvdata(file);
1175 DBG("%s\n", __func__);
1176 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1178 if (cam->owner && cam->owner != priv)
1180 zr364xx_stop_acquire(cam);
1181 return videobuf_streamoff(&cam->vb_vidq);
1185 /* open the camera */
1186 static int zr364xx_open(struct file *file)
1188 struct zr364xx_camera *cam = video_drvdata(file);
1191 DBG("%s\n", __func__);
1193 if (mutex_lock_interruptible(&cam->lock))
1194 return -ERESTARTSYS;
1196 err = v4l2_fh_open(file);
1200 /* Added some delay here, since opening/closing the camera quickly,
1201 * like Ekiga does during its startup, can crash the webcam
1207 mutex_unlock(&cam->lock);
1208 DBG("%s: %d\n", __func__, err);
1212 static void zr364xx_release(struct v4l2_device *v4l2_dev)
1214 struct zr364xx_camera *cam =
1215 container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
1218 v4l2_device_unregister(&cam->v4l2_dev);
1220 videobuf_mmap_free(&cam->vb_vidq);
1222 /* release sys buffers */
1223 for (i = 0; i < FRAMES; i++) {
1224 if (cam->buffer.frame[i].lpvbits) {
1225 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1226 vfree(cam->buffer.frame[i].lpvbits);
1228 cam->buffer.frame[i].lpvbits = NULL;
1231 v4l2_ctrl_handler_free(&cam->ctrl_handler);
1232 /* release transfer buffer */
1233 kfree(cam->pipe->transfer_buffer);
1237 /* release the camera */
1238 static int zr364xx_close(struct file *file)
1240 struct zr364xx_camera *cam;
1241 struct usb_device *udev;
1244 DBG("%s\n", __func__);
1245 cam = video_drvdata(file);
1247 mutex_lock(&cam->lock);
1250 if (file->private_data == cam->owner) {
1251 /* turn off stream */
1253 zr364xx_stop_acquire(cam);
1254 videobuf_streamoff(&cam->vb_vidq);
1256 for (i = 0; i < 2; i++) {
1257 send_control_msg(udev, 1, init[cam->method][i].value,
1258 0, init[cam->method][i].bytes,
1259 init[cam->method][i].size);
1264 /* Added some delay here, since opening/closing the camera quickly,
1265 * like Ekiga does during its startup, can crash the webcam
1268 mutex_unlock(&cam->lock);
1269 return v4l2_fh_release(file);
1273 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1275 struct zr364xx_camera *cam = video_drvdata(file);
1279 DBG("%s: cam == NULL\n", __func__);
1282 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1284 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1286 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1287 (unsigned long)vma->vm_start,
1288 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1292 static unsigned int zr364xx_poll(struct file *file,
1293 struct poll_table_struct *wait)
1295 struct zr364xx_camera *cam = video_drvdata(file);
1296 struct videobuf_queue *q = &cam->vb_vidq;
1297 unsigned res = v4l2_ctrl_poll(file, wait);
1299 _DBG("%s\n", __func__);
1301 return res | videobuf_poll_stream(file, q, wait);
1304 static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1305 .s_ctrl = zr364xx_s_ctrl,
1308 static const struct v4l2_file_operations zr364xx_fops = {
1309 .owner = THIS_MODULE,
1310 .open = zr364xx_open,
1311 .release = zr364xx_close,
1312 .read = zr364xx_read,
1313 .mmap = zr364xx_mmap,
1314 .unlocked_ioctl = video_ioctl2,
1315 .poll = zr364xx_poll,
1318 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1319 .vidioc_querycap = zr364xx_vidioc_querycap,
1320 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1321 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1322 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1323 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
1324 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1325 .vidioc_g_input = zr364xx_vidioc_g_input,
1326 .vidioc_s_input = zr364xx_vidioc_s_input,
1327 .vidioc_streamon = zr364xx_vidioc_streamon,
1328 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1329 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1330 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1331 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1332 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
1333 .vidioc_log_status = v4l2_ctrl_log_status,
1334 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1335 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1338 static struct video_device zr364xx_template = {
1339 .name = DRIVER_DESC,
1340 .fops = &zr364xx_fops,
1341 .ioctl_ops = &zr364xx_ioctl_ops,
1342 .release = video_device_release_empty,
1347 /*******************/
1348 /* USB integration */
1349 /*******************/
1350 static int zr364xx_board_init(struct zr364xx_camera *cam)
1352 struct zr364xx_pipeinfo *pipe = cam->pipe;
1355 DBG("board init: %p\n", cam);
1356 memset(pipe, 0, sizeof(*pipe));
1358 pipe->transfer_size = BUFFER_SIZE;
1360 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1362 if (pipe->transfer_buffer == NULL) {
1363 DBG("out of memory!\n");
1368 cam->frame_count = 0;
1370 /*** start create system buffers ***/
1371 for (i = 0; i < FRAMES; i++) {
1372 /* always allocate maximum size for system buffers */
1373 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1375 DBG("valloc %p, idx %lu, pdata %p\n",
1376 &cam->buffer.frame[i], i,
1377 cam->buffer.frame[i].lpvbits);
1378 if (cam->buffer.frame[i].lpvbits == NULL) {
1379 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1380 "Using less frames\n");
1386 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1387 kfree(cam->pipe->transfer_buffer);
1388 cam->pipe->transfer_buffer = NULL;
1391 cam->buffer.dwFrames = i;
1393 /* make sure internal states are set */
1394 for (i = 0; i < FRAMES; i++) {
1395 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1396 cam->buffer.frame[i].cur_size = 0;
1400 cam->last_frame = -1;
1401 /*** end create system buffers ***/
1403 /* start read pipe */
1404 zr364xx_start_readpipe(cam);
1405 DBG(": board initialized\n");
1409 static int zr364xx_probe(struct usb_interface *intf,
1410 const struct usb_device_id *id)
1412 struct usb_device *udev = interface_to_usbdev(intf);
1413 struct zr364xx_camera *cam = NULL;
1414 struct usb_host_interface *iface_desc;
1415 struct usb_endpoint_descriptor *endpoint;
1416 struct v4l2_ctrl_handler *hdl;
1420 DBG("probing...\n");
1422 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1423 dev_info(&intf->dev, "model %04x:%04x detected\n",
1424 le16_to_cpu(udev->descriptor.idVendor),
1425 le16_to_cpu(udev->descriptor.idProduct));
1427 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1429 dev_err(&udev->dev, "cam: out of memory !\n");
1433 cam->v4l2_dev.release = zr364xx_release;
1434 err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1436 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1440 hdl = &cam->ctrl_handler;
1441 v4l2_ctrl_handler_init(hdl, 1);
1442 v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1443 V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1446 dev_err(&udev->dev, "couldn't register control\n");
1449 /* save the init method used by this camera */
1450 cam->method = id->driver_info;
1451 mutex_init(&cam->lock);
1452 cam->vdev = zr364xx_template;
1453 cam->vdev.lock = &cam->lock;
1454 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1455 cam->vdev.ctrl_handler = &cam->ctrl_handler;
1456 set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags);
1457 video_set_drvdata(&cam->vdev, cam);
1459 cam->vdev.debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1465 dev_info(&udev->dev, "160x120 mode selected\n");
1470 dev_info(&udev->dev, "640x480 mode selected\n");
1475 dev_info(&udev->dev, "320x240 mode selected\n");
1482 m1[2].value = 0xf000 + mode;
1483 m2[1].value = 0xf000 + mode;
1485 /* special case for METHOD3, the modes are different */
1486 if (cam->method == METHOD3) {
1489 m2[1].value = 0xf000 + 4;
1492 m2[1].value = 0xf000 + 0;
1495 m2[1].value = 0xf000 + 1;
1500 header2[437] = cam->height / 256;
1501 header2[438] = cam->height % 256;
1502 header2[439] = cam->width / 256;
1503 header2[440] = cam->width % 256;
1507 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1509 /* set up the endpoint information */
1510 iface_desc = intf->cur_altsetting;
1511 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1512 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1513 endpoint = &iface_desc->endpoint[i].desc;
1514 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1515 /* we found the bulk in endpoint */
1516 cam->read_endpoint = endpoint->bEndpointAddress;
1520 if (!cam->read_endpoint) {
1522 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1527 INIT_LIST_HEAD(&cam->vidq.active);
1528 cam->vidq.cam = cam;
1530 usb_set_intfdata(intf, cam);
1532 /* load zr364xx board specific */
1533 err = zr364xx_board_init(cam);
1535 err = v4l2_ctrl_handler_setup(hdl);
1539 spin_lock_init(&cam->slock);
1543 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1545 V4L2_BUF_TYPE_VIDEO_CAPTURE,
1547 sizeof(struct zr364xx_buffer), cam, &cam->lock);
1549 err = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1551 dev_err(&udev->dev, "video_register_device failed\n");
1555 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1556 video_device_node_name(&cam->vdev));
1560 v4l2_ctrl_handler_free(hdl);
1561 v4l2_device_unregister(&cam->v4l2_dev);
1567 static void zr364xx_disconnect(struct usb_interface *intf)
1569 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1571 mutex_lock(&cam->lock);
1572 usb_set_intfdata(intf, NULL);
1573 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1574 video_unregister_device(&cam->vdev);
1575 v4l2_device_disconnect(&cam->v4l2_dev);
1577 /* stops the read pipe if it is running */
1579 zr364xx_stop_acquire(cam);
1581 zr364xx_stop_readpipe(cam);
1582 mutex_unlock(&cam->lock);
1583 v4l2_device_put(&cam->v4l2_dev);
1588 static int zr364xx_suspend(struct usb_interface *intf, pm_message_t message)
1590 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1592 cam->was_streaming = cam->b_acquire;
1593 if (!cam->was_streaming)
1595 zr364xx_stop_acquire(cam);
1596 zr364xx_stop_readpipe(cam);
1600 static int zr364xx_resume(struct usb_interface *intf)
1602 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1605 if (!cam->was_streaming)
1608 zr364xx_start_readpipe(cam);
1609 res = zr364xx_prepare(cam);
1611 zr364xx_start_acquire(cam);
1616 /**********************/
1617 /* Module integration */
1618 /**********************/
1620 static struct usb_driver zr364xx_driver = {
1622 .probe = zr364xx_probe,
1623 .disconnect = zr364xx_disconnect,
1625 .suspend = zr364xx_suspend,
1626 .resume = zr364xx_resume,
1627 .reset_resume = zr364xx_resume,
1629 .id_table = device_table
1632 module_usb_driver(zr364xx_driver);
1634 MODULE_AUTHOR(DRIVER_AUTHOR);
1635 MODULE_DESCRIPTION(DRIVER_DESC);
1636 MODULE_LICENSE("GPL");
1637 MODULE_VERSION(DRIVER_VERSION);