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__);
380 BUG_ON(in_interrupt());
382 videobuf_vmalloc_free(&buf->vb);
383 buf->vb.state = VIDEOBUF_NEEDS_INIT;
386 static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
387 enum v4l2_field field)
389 struct zr364xx_camera *cam = vq->priv_data;
390 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
394 DBG("%s, field=%d, fmt name = %s\n", __func__, field, cam->fmt != NULL ?
395 cam->fmt->name : "");
396 if (cam->fmt == NULL)
399 buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
401 if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
402 DBG("invalid buffer prepare\n");
407 buf->vb.width = cam->width;
408 buf->vb.height = cam->height;
409 buf->vb.field = field;
411 if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
412 rc = videobuf_iolock(vq, &buf->vb, NULL);
417 buf->vb.state = VIDEOBUF_PREPARED;
420 free_buffer(vq, buf);
424 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
426 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
428 struct zr364xx_camera *cam = vq->priv_data;
430 _DBG("%s\n", __func__);
432 buf->vb.state = VIDEOBUF_QUEUED;
433 list_add_tail(&buf->vb.queue, &cam->vidq.active);
436 static void buffer_release(struct videobuf_queue *vq,
437 struct videobuf_buffer *vb)
439 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
442 _DBG("%s\n", __func__);
443 free_buffer(vq, buf);
446 static struct videobuf_queue_ops zr364xx_video_qops = {
447 .buf_setup = buffer_setup,
448 .buf_prepare = buffer_prepare,
449 .buf_queue = buffer_queue,
450 .buf_release = buffer_release,
453 /********************/
454 /* V4L2 integration */
455 /********************/
456 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
457 enum v4l2_buf_type type);
459 static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
462 struct zr364xx_camera *cam = video_drvdata(file);
465 _DBG("%s\n", __func__);
473 if (mutex_lock_interruptible(&cam->lock))
476 err = zr364xx_vidioc_streamon(file, file->private_data,
477 V4L2_BUF_TYPE_VIDEO_CAPTURE);
479 DBG("%s: reading %d bytes at pos %d.\n", __func__,
480 (int) count, (int) *ppos);
483 err = videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
484 file->f_flags & O_NONBLOCK);
486 mutex_unlock(&cam->lock);
490 /* video buffer vmalloc implementation based partly on VIVI driver which is
491 * Copyright (c) 2006 by
492 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
493 * Ted Walther <ted--a.t--enumera.com>
494 * John Sokol <sokol--a.t--videotechnology.com>
495 * http://v4l.videotechnology.com/
498 static void zr364xx_fillbuff(struct zr364xx_camera *cam,
499 struct zr364xx_buffer *buf,
504 char *vbuf = videobuf_to_vmalloc(&buf->vb);
505 unsigned long last_frame;
510 last_frame = cam->last_frame;
511 if (last_frame != -1) {
512 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
513 switch (buf->fmt->fourcc) {
514 case V4L2_PIX_FMT_JPEG:
515 buf->vb.size = jpgsize;
516 memcpy(vbuf, tmpbuf, buf->vb.size);
519 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
521 cam->last_frame = -1;
523 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
526 DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
527 (unsigned long)vbuf, pos);
528 /* tell v4l buffer was filled */
530 buf->vb.field_count = cam->frame_count * 2;
531 v4l2_get_timestamp(&buf->vb.ts);
532 buf->vb.state = VIDEOBUF_DONE;
535 static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
537 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
538 struct zr364xx_buffer *buf;
539 unsigned long flags = 0;
542 DBG("wakeup: %p\n", &dma_q);
543 spin_lock_irqsave(&cam->slock, flags);
545 if (list_empty(&dma_q->active)) {
546 DBG("No active queue to serve\n");
550 buf = list_entry(dma_q->active.next,
551 struct zr364xx_buffer, vb.queue);
553 if (!waitqueue_active(&buf->vb.done)) {
558 list_del(&buf->vb.queue);
559 v4l2_get_timestamp(&buf->vb.ts);
560 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
561 zr364xx_fillbuff(cam, buf, jpgsize);
562 wake_up(&buf->vb.done);
563 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
565 spin_unlock_irqrestore(&cam->slock, flags);
569 /* this function moves the usb stream read pipe data
570 * into the system buffers.
571 * returns 0 on success, EAGAIN if more data to process (call this
574 static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
575 struct zr364xx_pipeinfo *pipe_info,
578 unsigned char *pdest;
581 struct zr364xx_framei *frm;
583 unsigned char *ptr = NULL;
585 _DBG("buffer to user\n");
586 idx = cam->cur_frame;
587 frm = &cam->buffer.frame[idx];
589 /* swap bytes if camera needs it */
590 if (cam->method == METHOD0) {
591 u16 *buf = (u16 *)pipe_info->transfer_buffer;
592 for (i = 0; i < purb->actual_length/2; i++)
596 /* search done. now find out if should be acquiring */
597 if (!cam->b_acquire) {
598 /* we found a frame, but this channel is turned off */
599 frm->ulState = ZR364XX_READ_IDLE;
603 psrc = (u8 *)pipe_info->transfer_buffer;
604 ptr = pdest = frm->lpvbits;
606 if (frm->ulState == ZR364XX_READ_IDLE) {
607 if (purb->actual_length < 128) {
608 /* header incomplete */
609 dev_info(&cam->udev->dev,
610 "%s: buffer (%d bytes) too small to hold jpeg header. Discarding.\n",
611 __func__, purb->actual_length);
615 frm->ulState = ZR364XX_READ_FRAME;
618 _DBG("jpeg header, ");
619 memcpy(ptr, header1, sizeof(header1));
620 ptr += sizeof(header1);
622 memcpy(ptr, &header3, 1);
624 memcpy(ptr, psrc, 64);
627 memcpy(ptr, &header3, 1);
629 memcpy(ptr, psrc + 64, 64);
631 memcpy(ptr, header2, sizeof(header2));
632 ptr += sizeof(header2);
633 memcpy(ptr, psrc + 128,
634 purb->actual_length - 128);
635 ptr += purb->actual_length - 128;
636 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
637 psrc[0], psrc[1], psrc[2],
638 psrc[3], psrc[4], psrc[5],
639 psrc[6], psrc[7], psrc[8]);
640 frm->cur_size = ptr - pdest;
642 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
643 dev_info(&cam->udev->dev,
644 "%s: buffer (%d bytes) too small to hold "
645 "frame data. Discarding frame data.\n",
646 __func__, MAX_FRAME_SIZE);
648 pdest += frm->cur_size;
649 memcpy(pdest, psrc, purb->actual_length);
650 frm->cur_size += purb->actual_length;
653 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
654 purb->actual_length);*/
656 if (purb->actual_length < pipe_info->transfer_size) {
657 _DBG("****************Buffer[%d]full*************\n", idx);
658 cam->last_frame = cam->cur_frame;
660 /* end of system frame ring buffer, start at zero */
661 if (cam->cur_frame == cam->buffer.dwFrames)
665 /* go back to find the JPEG EOI marker */
666 ptr = pdest = frm->lpvbits;
667 ptr += frm->cur_size - 2;
668 while (ptr > pdest) {
669 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
670 && *(ptr + 2) == 0xFF)
675 DBG("No EOI marker\n");
677 /* Sometimes there is junk data in the middle of the picture,
678 * we want to skip this bogus frames */
679 while (ptr > pdest) {
680 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
681 && *(ptr + 2) == 0xFF)
686 DBG("Bogus frame ? %d\n", ++(cam->nb));
687 } else if (cam->b_acquire) {
688 /* we skip the 2 first frames which are usually buggy */
692 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
694 pdest[0], pdest[1], pdest[2], pdest[3],
695 pdest[4], pdest[5], pdest[6], pdest[7]);
697 zr364xx_got_frame(cam, frm->cur_size);
701 frm->ulState = ZR364XX_READ_IDLE;
704 /* done successfully */
708 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
709 struct v4l2_capability *cap)
711 struct zr364xx_camera *cam = video_drvdata(file);
713 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
714 if (cam->udev->product)
715 strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
716 strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
717 sizeof(cap->bus_info));
718 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
721 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
726 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
727 struct v4l2_input *i)
731 strcpy(i->name, DRIVER_DESC " Camera");
732 i->type = V4L2_INPUT_TYPE_CAMERA;
736 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
743 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
751 static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
753 struct zr364xx_camera *cam =
754 container_of(ctrl->handler, struct zr364xx_camera, ctrl_handler);
758 case V4L2_CID_BRIGHTNESS:
759 /* hardware brightness */
760 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
761 temp = (0x60 << 8) + 127 - ctrl->val;
762 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
771 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
772 void *priv, struct v4l2_fmtdesc *f)
776 f->flags = V4L2_FMT_FLAG_COMPRESSED;
777 strcpy(f->description, formats[0].name);
778 f->pixelformat = formats[0].fourcc;
782 static char *decode_fourcc(__u32 pixelformat, char *buf)
784 buf[0] = pixelformat & 0xff;
785 buf[1] = (pixelformat >> 8) & 0xff;
786 buf[2] = (pixelformat >> 16) & 0xff;
787 buf[3] = (pixelformat >> 24) & 0xff;
792 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
793 struct v4l2_format *f)
795 struct zr364xx_camera *cam = video_drvdata(file);
796 char pixelformat_name[5];
801 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
802 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
803 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
807 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
808 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
809 f->fmt.pix.width = 320;
810 f->fmt.pix.height = 240;
813 f->fmt.pix.field = V4L2_FIELD_NONE;
814 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
815 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
816 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
817 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
818 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
823 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
824 struct v4l2_format *f)
826 struct zr364xx_camera *cam;
830 cam = video_drvdata(file);
832 f->fmt.pix.pixelformat = formats[0].fourcc;
833 f->fmt.pix.field = V4L2_FIELD_NONE;
834 f->fmt.pix.width = cam->width;
835 f->fmt.pix.height = cam->height;
836 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
837 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
838 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
842 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
843 struct v4l2_format *f)
845 struct zr364xx_camera *cam = video_drvdata(file);
846 struct videobuf_queue *q = &cam->vb_vidq;
847 char pixelformat_name[5];
848 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
854 mutex_lock(&q->vb_lock);
856 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
857 DBG("%s queue busy\n", __func__);
863 DBG("%s can't change format after started\n", __func__);
868 cam->width = f->fmt.pix.width;
869 cam->height = f->fmt.pix.height;
870 DBG("%s: %dx%d mode selected\n", __func__,
871 cam->width, cam->height);
872 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
873 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
874 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
875 cam->vb_vidq.field = f->fmt.pix.field;
877 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
879 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
885 m1[2].value = 0xf000 + mode;
886 m2[1].value = 0xf000 + mode;
888 /* special case for METHOD3, the modes are different */
889 if (cam->method == METHOD3) {
892 m2[1].value = 0xf000 + 4;
895 m2[1].value = 0xf000 + 0;
898 m2[1].value = 0xf000 + 1;
903 header2[437] = cam->height / 256;
904 header2[438] = cam->height % 256;
905 header2[439] = cam->width / 256;
906 header2[440] = cam->width % 256;
908 for (i = 0; init[cam->method][i].size != -1; i++) {
910 send_control_msg(cam->udev, 1, init[cam->method][i].value,
911 0, init[cam->method][i].bytes,
912 init[cam->method][i].size);
914 dev_err(&cam->udev->dev,
915 "error during resolution change sequence: %d\n", i);
920 /* Added some delay here, since opening/closing the camera quickly,
921 * like Ekiga does during its startup, can crash the webcam
928 mutex_unlock(&q->vb_lock);
930 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
931 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
936 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
937 struct v4l2_requestbuffers *p)
939 struct zr364xx_camera *cam = video_drvdata(file);
941 if (cam->owner && cam->owner != priv)
943 return videobuf_reqbufs(&cam->vb_vidq, p);
946 static int zr364xx_vidioc_querybuf(struct file *file,
948 struct v4l2_buffer *p)
951 struct zr364xx_camera *cam = video_drvdata(file);
952 rc = videobuf_querybuf(&cam->vb_vidq, p);
956 static int zr364xx_vidioc_qbuf(struct file *file,
958 struct v4l2_buffer *p)
961 struct zr364xx_camera *cam = video_drvdata(file);
962 _DBG("%s\n", __func__);
963 if (cam->owner && cam->owner != priv)
965 rc = videobuf_qbuf(&cam->vb_vidq, p);
969 static int zr364xx_vidioc_dqbuf(struct file *file,
971 struct v4l2_buffer *p)
974 struct zr364xx_camera *cam = video_drvdata(file);
975 _DBG("%s\n", __func__);
976 if (cam->owner && cam->owner != priv)
978 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
982 static void read_pipe_completion(struct urb *purb)
984 struct zr364xx_pipeinfo *pipe_info;
985 struct zr364xx_camera *cam;
988 pipe_info = purb->context;
989 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
990 if (pipe_info == NULL) {
991 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
995 cam = pipe_info->cam;
997 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1001 /* if shutting down, do not resubmit, exit immediately */
1002 if (purb->status == -ESHUTDOWN) {
1003 DBG("%s, err shutdown\n", __func__);
1004 pipe_info->err_count++;
1008 if (pipe_info->state == 0) {
1009 DBG("exiting USB pipe\n");
1013 if (purb->actual_length > pipe_info->transfer_size) {
1014 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1018 if (purb->status == 0)
1019 zr364xx_read_video_callback(cam, pipe_info, purb);
1021 pipe_info->err_count++;
1022 DBG("%s: failed URB %d\n", __func__, purb->status);
1025 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1028 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1030 pipe_info->transfer_buffer,
1031 pipe_info->transfer_size,
1032 read_pipe_completion, pipe_info);
1034 if (pipe_info->state != 0) {
1035 purb->status = usb_submit_urb(pipe_info->stream_urb,
1039 dev_err(&cam->udev->dev,
1040 "error submitting urb (error=%i)\n",
1043 DBG("read pipe complete state 0\n");
1046 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1050 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1051 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1052 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1054 pipe_info->state = 1;
1055 pipe_info->err_count = 0;
1056 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1057 if (!pipe_info->stream_urb) {
1058 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1061 /* transfer buffer allocated in board_init */
1062 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1064 pipe_info->transfer_buffer,
1065 pipe_info->transfer_size,
1066 read_pipe_completion, pipe_info);
1068 DBG("submitting URB %p\n", pipe_info->stream_urb);
1069 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1071 usb_free_urb(pipe_info->stream_urb);
1072 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1079 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1081 struct zr364xx_pipeinfo *pipe_info;
1084 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1087 DBG("stop read pipe\n");
1088 pipe_info = cam->pipe;
1090 if (pipe_info->state != 0)
1091 pipe_info->state = 0;
1093 if (pipe_info->stream_urb) {
1095 usb_kill_urb(pipe_info->stream_urb);
1096 usb_free_urb(pipe_info->stream_urb);
1097 pipe_info->stream_urb = NULL;
1103 /* starts acquisition process */
1104 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1108 DBG("start acquire\n");
1110 cam->last_frame = -1;
1112 for (j = 0; j < FRAMES; j++) {
1113 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1114 cam->buffer.frame[j].cur_size = 0;
1120 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1126 static int zr364xx_prepare(struct zr364xx_camera *cam)
1131 for (i = 0; init[cam->method][i].size != -1; i++) {
1132 res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1133 0, init[cam->method][i].bytes,
1134 init[cam->method][i].size);
1136 dev_err(&cam->udev->dev,
1137 "error during open sequence: %d\n", i);
1143 cam->last_frame = -1;
1145 cam->frame_count = 0;
1146 for (j = 0; j < FRAMES; j++) {
1147 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1148 cam->buffer.frame[j].cur_size = 0;
1150 v4l2_ctrl_handler_setup(&cam->ctrl_handler);
1154 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1155 enum v4l2_buf_type type)
1157 struct zr364xx_camera *cam = video_drvdata(file);
1160 DBG("%s\n", __func__);
1162 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1165 if (cam->owner && cam->owner != priv)
1168 res = zr364xx_prepare(cam);
1171 res = videobuf_streamon(&cam->vb_vidq);
1173 zr364xx_start_acquire(cam);
1174 cam->owner = file->private_data;
1179 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1180 enum v4l2_buf_type type)
1182 struct zr364xx_camera *cam = video_drvdata(file);
1184 DBG("%s\n", __func__);
1185 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1187 if (cam->owner && cam->owner != priv)
1189 zr364xx_stop_acquire(cam);
1190 return videobuf_streamoff(&cam->vb_vidq);
1194 /* open the camera */
1195 static int zr364xx_open(struct file *file)
1197 struct zr364xx_camera *cam = video_drvdata(file);
1200 DBG("%s\n", __func__);
1202 if (mutex_lock_interruptible(&cam->lock))
1203 return -ERESTARTSYS;
1205 err = v4l2_fh_open(file);
1209 /* Added some delay here, since opening/closing the camera quickly,
1210 * like Ekiga does during its startup, can crash the webcam
1216 mutex_unlock(&cam->lock);
1217 DBG("%s: %d\n", __func__, err);
1221 static void zr364xx_release(struct v4l2_device *v4l2_dev)
1223 struct zr364xx_camera *cam =
1224 container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
1227 v4l2_device_unregister(&cam->v4l2_dev);
1229 videobuf_mmap_free(&cam->vb_vidq);
1231 /* release sys buffers */
1232 for (i = 0; i < FRAMES; i++) {
1233 if (cam->buffer.frame[i].lpvbits) {
1234 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1235 vfree(cam->buffer.frame[i].lpvbits);
1237 cam->buffer.frame[i].lpvbits = NULL;
1240 v4l2_ctrl_handler_free(&cam->ctrl_handler);
1241 /* release transfer buffer */
1242 kfree(cam->pipe->transfer_buffer);
1246 /* release the camera */
1247 static int zr364xx_close(struct file *file)
1249 struct zr364xx_camera *cam;
1250 struct usb_device *udev;
1253 DBG("%s\n", __func__);
1254 cam = video_drvdata(file);
1256 mutex_lock(&cam->lock);
1259 if (file->private_data == cam->owner) {
1260 /* turn off stream */
1262 zr364xx_stop_acquire(cam);
1263 videobuf_streamoff(&cam->vb_vidq);
1265 for (i = 0; i < 2; i++) {
1266 send_control_msg(udev, 1, init[cam->method][i].value,
1267 0, init[cam->method][i].bytes,
1268 init[cam->method][i].size);
1273 /* Added some delay here, since opening/closing the camera quickly,
1274 * like Ekiga does during its startup, can crash the webcam
1277 mutex_unlock(&cam->lock);
1278 return v4l2_fh_release(file);
1282 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1284 struct zr364xx_camera *cam = video_drvdata(file);
1288 DBG("%s: cam == NULL\n", __func__);
1291 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1293 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1295 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1296 (unsigned long)vma->vm_start,
1297 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1301 static unsigned int zr364xx_poll(struct file *file,
1302 struct poll_table_struct *wait)
1304 struct zr364xx_camera *cam = video_drvdata(file);
1305 struct videobuf_queue *q = &cam->vb_vidq;
1306 unsigned res = v4l2_ctrl_poll(file, wait);
1308 _DBG("%s\n", __func__);
1310 return res | videobuf_poll_stream(file, q, wait);
1313 static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1314 .s_ctrl = zr364xx_s_ctrl,
1317 static const struct v4l2_file_operations zr364xx_fops = {
1318 .owner = THIS_MODULE,
1319 .open = zr364xx_open,
1320 .release = zr364xx_close,
1321 .read = zr364xx_read,
1322 .mmap = zr364xx_mmap,
1323 .unlocked_ioctl = video_ioctl2,
1324 .poll = zr364xx_poll,
1327 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1328 .vidioc_querycap = zr364xx_vidioc_querycap,
1329 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1330 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1331 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1332 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
1333 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1334 .vidioc_g_input = zr364xx_vidioc_g_input,
1335 .vidioc_s_input = zr364xx_vidioc_s_input,
1336 .vidioc_streamon = zr364xx_vidioc_streamon,
1337 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1338 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1339 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1340 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1341 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
1342 .vidioc_log_status = v4l2_ctrl_log_status,
1343 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1344 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1347 static struct video_device zr364xx_template = {
1348 .name = DRIVER_DESC,
1349 .fops = &zr364xx_fops,
1350 .ioctl_ops = &zr364xx_ioctl_ops,
1351 .release = video_device_release_empty,
1356 /*******************/
1357 /* USB integration */
1358 /*******************/
1359 static int zr364xx_board_init(struct zr364xx_camera *cam)
1361 struct zr364xx_pipeinfo *pipe = cam->pipe;
1364 DBG("board init: %p\n", cam);
1365 memset(pipe, 0, sizeof(*pipe));
1367 pipe->transfer_size = BUFFER_SIZE;
1369 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1371 if (pipe->transfer_buffer == NULL) {
1372 DBG("out of memory!\n");
1377 cam->frame_count = 0;
1379 /*** start create system buffers ***/
1380 for (i = 0; i < FRAMES; i++) {
1381 /* always allocate maximum size for system buffers */
1382 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1384 DBG("valloc %p, idx %lu, pdata %p\n",
1385 &cam->buffer.frame[i], i,
1386 cam->buffer.frame[i].lpvbits);
1387 if (cam->buffer.frame[i].lpvbits == NULL) {
1388 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1389 "Using less frames\n");
1395 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1396 kfree(cam->pipe->transfer_buffer);
1397 cam->pipe->transfer_buffer = NULL;
1400 cam->buffer.dwFrames = i;
1402 /* make sure internal states are set */
1403 for (i = 0; i < FRAMES; i++) {
1404 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1405 cam->buffer.frame[i].cur_size = 0;
1409 cam->last_frame = -1;
1410 /*** end create system buffers ***/
1412 /* start read pipe */
1413 zr364xx_start_readpipe(cam);
1414 DBG(": board initialized\n");
1418 static int zr364xx_probe(struct usb_interface *intf,
1419 const struct usb_device_id *id)
1421 struct usb_device *udev = interface_to_usbdev(intf);
1422 struct zr364xx_camera *cam = NULL;
1423 struct usb_host_interface *iface_desc;
1424 struct usb_endpoint_descriptor *endpoint;
1425 struct v4l2_ctrl_handler *hdl;
1429 DBG("probing...\n");
1431 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1432 dev_info(&intf->dev, "model %04x:%04x detected\n",
1433 le16_to_cpu(udev->descriptor.idVendor),
1434 le16_to_cpu(udev->descriptor.idProduct));
1436 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1438 dev_err(&udev->dev, "cam: out of memory !\n");
1442 cam->v4l2_dev.release = zr364xx_release;
1443 err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1445 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1449 hdl = &cam->ctrl_handler;
1450 v4l2_ctrl_handler_init(hdl, 1);
1451 v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1452 V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1455 dev_err(&udev->dev, "couldn't register control\n");
1458 /* save the init method used by this camera */
1459 cam->method = id->driver_info;
1460 mutex_init(&cam->lock);
1461 cam->vdev = zr364xx_template;
1462 cam->vdev.lock = &cam->lock;
1463 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1464 cam->vdev.ctrl_handler = &cam->ctrl_handler;
1465 video_set_drvdata(&cam->vdev, cam);
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);