1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Zoran 364xx based USB webcam module version 0.73
5 * Allows you to use your USB webcam with V4L2 applications
6 * This is still in heavy development !
8 * Copyright (C) 2004 Antoine Jacquet <royale@zerezo.com>
9 * http://royale.zerezo.com/zr364xx/
11 * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
12 * V4L2 version inspired by meye.c driver
14 * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/usb.h>
21 #include <linux/vmalloc.h>
22 #include <linux/slab.h>
23 #include <linux/proc_fs.h>
24 #include <linux/highmem.h>
25 #include <media/v4l2-common.h>
26 #include <media/v4l2-ioctl.h>
27 #include <media/v4l2-device.h>
28 #include <media/v4l2-ctrls.h>
29 #include <media/v4l2-fh.h>
30 #include <media/v4l2-event.h>
31 #include <media/videobuf-vmalloc.h>
34 /* Version Information */
35 #define DRIVER_VERSION "0.7.4"
36 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
37 #define DRIVER_DESC "Zoran 364xx"
42 #define MAX_FRAME_SIZE 200000
43 #define BUFFER_SIZE 0x1000
44 #define CTRL_TIMEOUT 500
46 #define ZR364XX_DEF_BUFS 4
47 #define ZR364XX_READ_IDLE 0
48 #define ZR364XX_READ_FRAME 1
51 #define DBG(fmt, args...) \
54 printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
58 /*#define FULL_DEBUG 1*/
62 #define _DBG(fmt, args...)
65 /* Init methods, need to find nicer names for these
66 * the exact names of the chipsets would be the best if someone finds it */
73 /* Module parameters */
78 /* Module parameters interface */
79 module_param(debug, int, 0644);
80 MODULE_PARM_DESC(debug, "Debug level");
81 module_param(mode, int, 0644);
82 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
85 /* Devices supported by this driver
86 * .driver_info contains the init method used by the camera */
87 static const struct usb_device_id device_table[] = {
88 {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
89 {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
90 {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
91 {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
92 {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
93 {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
94 {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
95 {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
96 {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
97 {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
98 {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
99 {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
100 {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
101 {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
102 {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
103 {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
104 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
105 {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
106 {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
107 {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 },
108 {USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 },
109 {} /* Terminating entry */
112 MODULE_DEVICE_TABLE(usb, device_table);
114 /* frame structure */
115 struct zr364xx_framei {
116 unsigned long ulState; /* ulState:ZR364XX_READ_IDLE,
117 ZR364XX_READ_FRAME */
118 void *lpvbits; /* image data */
119 unsigned long cur_size; /* current data copied to it */
122 /* image buffer structure */
123 struct zr364xx_bufferi {
124 unsigned long dwFrames; /* number of frames in buffer */
125 struct zr364xx_framei frame[FRAMES]; /* array of FRAME structures */
128 struct zr364xx_dmaqueue {
129 struct list_head active;
130 struct zr364xx_camera *cam;
133 struct zr364xx_pipeinfo {
138 void *cam; /* back pointer to zr364xx_camera struct */
149 static const struct zr364xx_fmt formats[] = {
151 .fourcc = V4L2_PIX_FMT_JPEG,
157 struct zr364xx_camera {
158 struct usb_device *udev; /* save off the usb device pointer */
159 struct usb_interface *interface;/* the interface for this device */
160 struct v4l2_device v4l2_dev;
161 struct v4l2_ctrl_handler ctrl_handler;
162 struct video_device vdev; /* v4l video device */
163 struct v4l2_fh *owner; /* owns the streaming */
165 struct zr364xx_bufferi buffer;
173 struct zr364xx_dmaqueue vidq;
176 unsigned long frame_count;
178 struct zr364xx_pipeinfo pipe[1];
182 const struct zr364xx_fmt *fmt;
183 struct videobuf_queue vb_vidq;
187 /* buffer for one video frame */
188 struct zr364xx_buffer {
189 /* common v4l buffer stuff -- must be first */
190 struct videobuf_buffer vb;
191 const struct zr364xx_fmt *fmt;
194 /* function used to send initialisation commands to the camera */
195 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
196 u16 index, unsigned char *cp, u16 size)
200 unsigned char *transfer_buffer = kmemdup(cp, size, GFP_KERNEL);
201 if (!transfer_buffer)
204 status = usb_control_msg(udev,
205 usb_sndctrlpipe(udev, 0),
207 USB_DIR_OUT | USB_TYPE_VENDOR |
208 USB_RECIP_DEVICE, value, index,
209 transfer_buffer, size, CTRL_TIMEOUT);
211 kfree(transfer_buffer);
216 /* Control messages sent to the camera to initialize it
217 * and launch the capture */
221 unsigned char *bytes;
225 static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
226 static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
227 static unsigned char m0d3[] = { 0, 0 };
228 static message m0[] = {
231 {0x3370, sizeof(m0d1), m0d1},
234 {0x2610, sizeof(m0d2), m0d2},
239 {0x9a01, sizeof(m0d3), m0d3},
244 static unsigned char m1d1[] = { 0xff, 0xff };
245 static unsigned char m1d2[] = { 0x00, 0x00 };
246 static message m1[] = {
254 {0x2502, sizeof(m1d1), m1d1},
259 {0x9a01, sizeof(m1d2), m1d2},
264 static unsigned char m2d1[] = { 0xff, 0xff };
265 static message m2[] = {
272 {0x2502, sizeof(m2d1), m2d1},
278 static message *init[4] = { m0, m1, m2, m2 };
281 /* JPEG static data in header (Huffman table, etc) */
282 static unsigned char header1[] = {
285 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
286 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
288 0xFF, 0xDB, 0x00, 0x84
290 static unsigned char header2[] = {
291 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
292 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
294 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
295 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
296 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
297 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
298 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
299 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
300 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
301 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
302 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
303 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
304 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
305 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
306 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
307 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
308 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
309 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
310 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
311 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
312 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
313 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
314 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
315 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
316 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
317 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
318 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
319 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
320 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
321 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
322 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
323 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
324 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
325 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
326 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
327 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
328 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
329 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
330 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
331 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
332 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
335 static unsigned char header3;
337 /* ------------------------------------------------------------------
339 ------------------------------------------------------------------*/
341 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
344 struct zr364xx_camera *cam = vq->priv_data;
346 *size = cam->width * cam->height * (cam->fmt->depth >> 3);
349 *count = ZR364XX_DEF_BUFS;
351 if (*size * *count > ZR364XX_DEF_BUFS * 1024 * 1024)
352 *count = (ZR364XX_DEF_BUFS * 1024 * 1024) / *size;
357 static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
359 _DBG("%s\n", __func__);
361 BUG_ON(in_interrupt());
363 videobuf_vmalloc_free(&buf->vb);
364 buf->vb.state = VIDEOBUF_NEEDS_INIT;
367 static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
368 enum v4l2_field field)
370 struct zr364xx_camera *cam = vq->priv_data;
371 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
375 DBG("%s, field=%d\n", __func__, field);
379 buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
381 if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
382 DBG("invalid buffer prepare\n");
387 buf->vb.width = cam->width;
388 buf->vb.height = cam->height;
389 buf->vb.field = field;
391 if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
392 rc = videobuf_iolock(vq, &buf->vb, NULL);
397 buf->vb.state = VIDEOBUF_PREPARED;
400 free_buffer(vq, buf);
404 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
406 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
408 struct zr364xx_camera *cam = vq->priv_data;
410 _DBG("%s\n", __func__);
412 buf->vb.state = VIDEOBUF_QUEUED;
413 list_add_tail(&buf->vb.queue, &cam->vidq.active);
416 static void buffer_release(struct videobuf_queue *vq,
417 struct videobuf_buffer *vb)
419 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
422 _DBG("%s\n", __func__);
423 free_buffer(vq, buf);
426 static const struct videobuf_queue_ops zr364xx_video_qops = {
427 .buf_setup = buffer_setup,
428 .buf_prepare = buffer_prepare,
429 .buf_queue = buffer_queue,
430 .buf_release = buffer_release,
433 /********************/
434 /* V4L2 integration */
435 /********************/
436 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
437 enum v4l2_buf_type type);
439 static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
442 struct zr364xx_camera *cam = video_drvdata(file);
445 _DBG("%s\n", __func__);
453 if (mutex_lock_interruptible(&cam->lock))
456 err = zr364xx_vidioc_streamon(file, file->private_data,
457 V4L2_BUF_TYPE_VIDEO_CAPTURE);
459 DBG("%s: reading %d bytes at pos %d.\n", __func__,
460 (int) count, (int) *ppos);
463 err = videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
464 file->f_flags & O_NONBLOCK);
466 mutex_unlock(&cam->lock);
470 /* video buffer vmalloc implementation based partly on VIVI driver which is
471 * Copyright (c) 2006 by
472 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
473 * Ted Walther <ted--a.t--enumera.com>
474 * John Sokol <sokol--a.t--videotechnology.com>
475 * http://v4l.videotechnology.com/
478 static void zr364xx_fillbuff(struct zr364xx_camera *cam,
479 struct zr364xx_buffer *buf,
484 char *vbuf = videobuf_to_vmalloc(&buf->vb);
485 unsigned long last_frame;
490 last_frame = cam->last_frame;
491 if (last_frame != -1) {
492 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
493 switch (buf->fmt->fourcc) {
494 case V4L2_PIX_FMT_JPEG:
495 buf->vb.size = jpgsize;
496 memcpy(vbuf, tmpbuf, buf->vb.size);
499 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
501 cam->last_frame = -1;
503 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
506 DBG("%s: Buffer %p size= %d\n", __func__, vbuf, pos);
507 /* tell v4l buffer was filled */
509 buf->vb.field_count = cam->frame_count * 2;
510 buf->vb.ts = ktime_get_ns();
511 buf->vb.state = VIDEOBUF_DONE;
514 static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
516 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
517 struct zr364xx_buffer *buf;
518 unsigned long flags = 0;
521 DBG("wakeup: %p\n", &dma_q);
522 spin_lock_irqsave(&cam->slock, flags);
524 if (list_empty(&dma_q->active)) {
525 DBG("No active queue to serve\n");
529 buf = list_entry(dma_q->active.next,
530 struct zr364xx_buffer, vb.queue);
532 if (!waitqueue_active(&buf->vb.done)) {
537 list_del(&buf->vb.queue);
538 buf->vb.ts = ktime_get_ns();
539 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
540 zr364xx_fillbuff(cam, buf, jpgsize);
541 wake_up(&buf->vb.done);
542 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
544 spin_unlock_irqrestore(&cam->slock, flags);
548 /* this function moves the usb stream read pipe data
549 * into the system buffers.
550 * returns 0 on success, EAGAIN if more data to process (call this
553 static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
554 struct zr364xx_pipeinfo *pipe_info,
557 unsigned char *pdest;
560 struct zr364xx_framei *frm;
562 unsigned char *ptr = NULL;
564 _DBG("buffer to user\n");
565 idx = cam->cur_frame;
566 frm = &cam->buffer.frame[idx];
568 /* swap bytes if camera needs it */
569 if (cam->method == METHOD0) {
570 u16 *buf = (u16 *)pipe_info->transfer_buffer;
571 for (i = 0; i < purb->actual_length/2; i++)
575 /* search done. now find out if should be acquiring */
576 if (!cam->b_acquire) {
577 /* we found a frame, but this channel is turned off */
578 frm->ulState = ZR364XX_READ_IDLE;
582 psrc = (u8 *)pipe_info->transfer_buffer;
583 ptr = pdest = frm->lpvbits;
585 if (frm->ulState == ZR364XX_READ_IDLE) {
586 if (purb->actual_length < 128) {
587 /* header incomplete */
588 dev_info(&cam->udev->dev,
589 "%s: buffer (%d bytes) too small to hold jpeg header. Discarding.\n",
590 __func__, purb->actual_length);
594 frm->ulState = ZR364XX_READ_FRAME;
597 _DBG("jpeg header, ");
598 memcpy(ptr, header1, sizeof(header1));
599 ptr += sizeof(header1);
601 memcpy(ptr, &header3, 1);
603 memcpy(ptr, psrc, 64);
606 memcpy(ptr, &header3, 1);
608 memcpy(ptr, psrc + 64, 64);
610 memcpy(ptr, header2, sizeof(header2));
611 ptr += sizeof(header2);
612 memcpy(ptr, psrc + 128,
613 purb->actual_length - 128);
614 ptr += purb->actual_length - 128;
615 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
616 psrc[0], psrc[1], psrc[2],
617 psrc[3], psrc[4], psrc[5],
618 psrc[6], psrc[7], psrc[8]);
619 frm->cur_size = ptr - pdest;
621 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
622 dev_info(&cam->udev->dev,
623 "%s: buffer (%d bytes) too small to hold frame data. Discarding frame data.\n",
624 __func__, MAX_FRAME_SIZE);
626 pdest += frm->cur_size;
627 memcpy(pdest, psrc, purb->actual_length);
628 frm->cur_size += purb->actual_length;
631 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
632 purb->actual_length);*/
634 if (purb->actual_length < pipe_info->transfer_size) {
635 _DBG("****************Buffer[%d]full*************\n", idx);
636 cam->last_frame = cam->cur_frame;
638 /* end of system frame ring buffer, start at zero */
639 if (cam->cur_frame == cam->buffer.dwFrames)
643 /* go back to find the JPEG EOI marker */
644 ptr = pdest = frm->lpvbits;
645 ptr += frm->cur_size - 2;
646 while (ptr > pdest) {
647 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
648 && *(ptr + 2) == 0xFF)
653 DBG("No EOI marker\n");
655 /* Sometimes there is junk data in the middle of the picture,
656 * we want to skip this bogus frames */
657 while (ptr > pdest) {
658 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
659 && *(ptr + 2) == 0xFF)
664 DBG("Bogus frame ? %d\n", ++(cam->nb));
665 } else if (cam->b_acquire) {
666 /* we skip the 2 first frames which are usually buggy */
670 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
672 pdest[0], pdest[1], pdest[2], pdest[3],
673 pdest[4], pdest[5], pdest[6], pdest[7]);
675 zr364xx_got_frame(cam, frm->cur_size);
679 frm->ulState = ZR364XX_READ_IDLE;
682 /* done successfully */
686 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
687 struct v4l2_capability *cap)
689 struct zr364xx_camera *cam = video_drvdata(file);
691 strscpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
692 if (cam->udev->product)
693 strscpy(cap->card, cam->udev->product, sizeof(cap->card));
694 strscpy(cap->bus_info, dev_name(&cam->udev->dev),
695 sizeof(cap->bus_info));
699 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
700 struct v4l2_input *i)
704 strscpy(i->name, DRIVER_DESC " Camera", sizeof(i->name));
705 i->type = V4L2_INPUT_TYPE_CAMERA;
709 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
716 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
724 static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
726 struct zr364xx_camera *cam =
727 container_of(ctrl->handler, struct zr364xx_camera, ctrl_handler);
731 case V4L2_CID_BRIGHTNESS:
732 /* hardware brightness */
733 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
734 temp = (0x60 << 8) + 127 - ctrl->val;
735 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
744 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
745 void *priv, struct v4l2_fmtdesc *f)
749 f->pixelformat = formats[0].fourcc;
753 static char *decode_fourcc(__u32 pixelformat, char *buf)
755 buf[0] = pixelformat & 0xff;
756 buf[1] = (pixelformat >> 8) & 0xff;
757 buf[2] = (pixelformat >> 16) & 0xff;
758 buf[3] = (pixelformat >> 24) & 0xff;
763 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
764 struct v4l2_format *f)
766 struct zr364xx_camera *cam = video_drvdata(file);
767 char pixelformat_name[5];
772 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
773 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
774 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
778 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
779 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
780 f->fmt.pix.width = 320;
781 f->fmt.pix.height = 240;
784 f->fmt.pix.field = V4L2_FIELD_NONE;
785 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
786 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
787 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
788 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
789 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
794 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
795 struct v4l2_format *f)
797 struct zr364xx_camera *cam;
801 cam = video_drvdata(file);
803 f->fmt.pix.pixelformat = formats[0].fourcc;
804 f->fmt.pix.field = V4L2_FIELD_NONE;
805 f->fmt.pix.width = cam->width;
806 f->fmt.pix.height = cam->height;
807 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
808 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
809 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
813 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
814 struct v4l2_format *f)
816 struct zr364xx_camera *cam = video_drvdata(file);
817 struct videobuf_queue *q = &cam->vb_vidq;
818 char pixelformat_name[5];
819 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
825 mutex_lock(&q->vb_lock);
827 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
828 DBG("%s queue busy\n", __func__);
834 DBG("%s can't change format after started\n", __func__);
839 cam->width = f->fmt.pix.width;
840 cam->height = f->fmt.pix.height;
841 DBG("%s: %dx%d mode selected\n", __func__,
842 cam->width, cam->height);
843 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
844 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
845 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
846 cam->vb_vidq.field = f->fmt.pix.field;
848 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
850 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
856 m1[2].value = 0xf000 + mode;
857 m2[1].value = 0xf000 + mode;
859 /* special case for METHOD3, the modes are different */
860 if (cam->method == METHOD3) {
863 m2[1].value = 0xf000 + 4;
866 m2[1].value = 0xf000 + 0;
869 m2[1].value = 0xf000 + 1;
874 header2[437] = cam->height / 256;
875 header2[438] = cam->height % 256;
876 header2[439] = cam->width / 256;
877 header2[440] = cam->width % 256;
879 for (i = 0; init[cam->method][i].size != -1; i++) {
881 send_control_msg(cam->udev, 1, init[cam->method][i].value,
882 0, init[cam->method][i].bytes,
883 init[cam->method][i].size);
885 dev_err(&cam->udev->dev,
886 "error during resolution change sequence: %d\n", i);
891 /* Added some delay here, since opening/closing the camera quickly,
892 * like Ekiga does during its startup, can crash the webcam
899 mutex_unlock(&q->vb_lock);
901 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
902 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
907 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
908 struct v4l2_requestbuffers *p)
910 struct zr364xx_camera *cam = video_drvdata(file);
912 if (cam->owner && cam->owner != priv)
914 return videobuf_reqbufs(&cam->vb_vidq, p);
917 static int zr364xx_vidioc_querybuf(struct file *file,
919 struct v4l2_buffer *p)
922 struct zr364xx_camera *cam = video_drvdata(file);
923 rc = videobuf_querybuf(&cam->vb_vidq, p);
927 static int zr364xx_vidioc_qbuf(struct file *file,
929 struct v4l2_buffer *p)
932 struct zr364xx_camera *cam = video_drvdata(file);
933 _DBG("%s\n", __func__);
934 if (cam->owner && cam->owner != priv)
936 rc = videobuf_qbuf(&cam->vb_vidq, p);
940 static int zr364xx_vidioc_dqbuf(struct file *file,
942 struct v4l2_buffer *p)
945 struct zr364xx_camera *cam = video_drvdata(file);
946 _DBG("%s\n", __func__);
947 if (cam->owner && cam->owner != priv)
949 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
953 static void read_pipe_completion(struct urb *purb)
955 struct zr364xx_pipeinfo *pipe_info;
956 struct zr364xx_camera *cam;
959 pipe_info = purb->context;
960 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
962 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
966 cam = pipe_info->cam;
968 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
972 /* if shutting down, do not resubmit, exit immediately */
973 if (purb->status == -ESHUTDOWN) {
974 DBG("%s, err shutdown\n", __func__);
975 pipe_info->err_count++;
979 if (pipe_info->state == 0) {
980 DBG("exiting USB pipe\n");
984 if (purb->actual_length > pipe_info->transfer_size) {
985 dev_err(&cam->udev->dev, "wrong number of bytes\n");
989 if (purb->status == 0)
990 zr364xx_read_video_callback(cam, pipe_info, purb);
992 pipe_info->err_count++;
993 DBG("%s: failed URB %d\n", __func__, purb->status);
996 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
999 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1001 pipe_info->transfer_buffer,
1002 pipe_info->transfer_size,
1003 read_pipe_completion, pipe_info);
1005 if (pipe_info->state != 0) {
1006 purb->status = usb_submit_urb(pipe_info->stream_urb,
1010 dev_err(&cam->udev->dev,
1011 "error submitting urb (error=%i)\n",
1014 DBG("read pipe complete state 0\n");
1017 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1021 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1022 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1023 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1025 pipe_info->state = 1;
1026 pipe_info->err_count = 0;
1027 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1028 if (!pipe_info->stream_urb)
1030 /* transfer buffer allocated in board_init */
1031 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1033 pipe_info->transfer_buffer,
1034 pipe_info->transfer_size,
1035 read_pipe_completion, pipe_info);
1037 DBG("submitting URB %p\n", pipe_info->stream_urb);
1038 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1040 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1047 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1049 struct zr364xx_pipeinfo *pipe_info;
1052 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1055 DBG("stop read pipe\n");
1056 pipe_info = cam->pipe;
1058 if (pipe_info->state != 0)
1059 pipe_info->state = 0;
1061 if (pipe_info->stream_urb) {
1063 usb_kill_urb(pipe_info->stream_urb);
1064 usb_free_urb(pipe_info->stream_urb);
1065 pipe_info->stream_urb = NULL;
1071 /* starts acquisition process */
1072 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1076 DBG("start acquire\n");
1078 cam->last_frame = -1;
1080 for (j = 0; j < FRAMES; j++) {
1081 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1082 cam->buffer.frame[j].cur_size = 0;
1088 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1094 static int zr364xx_prepare(struct zr364xx_camera *cam)
1099 for (i = 0; init[cam->method][i].size != -1; i++) {
1100 res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1101 0, init[cam->method][i].bytes,
1102 init[cam->method][i].size);
1104 dev_err(&cam->udev->dev,
1105 "error during open sequence: %d\n", i);
1111 cam->last_frame = -1;
1113 cam->frame_count = 0;
1114 for (j = 0; j < FRAMES; j++) {
1115 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1116 cam->buffer.frame[j].cur_size = 0;
1118 v4l2_ctrl_handler_setup(&cam->ctrl_handler);
1122 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1123 enum v4l2_buf_type type)
1125 struct zr364xx_camera *cam = video_drvdata(file);
1128 DBG("%s\n", __func__);
1130 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1133 if (cam->owner && cam->owner != priv)
1136 res = zr364xx_prepare(cam);
1139 res = videobuf_streamon(&cam->vb_vidq);
1141 zr364xx_start_acquire(cam);
1142 cam->owner = file->private_data;
1147 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1148 enum v4l2_buf_type type)
1150 struct zr364xx_camera *cam = video_drvdata(file);
1152 DBG("%s\n", __func__);
1153 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1155 if (cam->owner && cam->owner != priv)
1157 zr364xx_stop_acquire(cam);
1158 return videobuf_streamoff(&cam->vb_vidq);
1162 /* open the camera */
1163 static int zr364xx_open(struct file *file)
1165 struct zr364xx_camera *cam = video_drvdata(file);
1168 DBG("%s\n", __func__);
1170 if (mutex_lock_interruptible(&cam->lock))
1171 return -ERESTARTSYS;
1173 err = v4l2_fh_open(file);
1177 /* Added some delay here, since opening/closing the camera quickly,
1178 * like Ekiga does during its startup, can crash the webcam
1184 mutex_unlock(&cam->lock);
1185 DBG("%s: %d\n", __func__, err);
1189 static void zr364xx_release(struct v4l2_device *v4l2_dev)
1191 struct zr364xx_camera *cam =
1192 container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
1195 v4l2_device_unregister(&cam->v4l2_dev);
1197 videobuf_mmap_free(&cam->vb_vidq);
1199 /* release sys buffers */
1200 for (i = 0; i < FRAMES; i++) {
1201 if (cam->buffer.frame[i].lpvbits) {
1202 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1203 vfree(cam->buffer.frame[i].lpvbits);
1205 cam->buffer.frame[i].lpvbits = NULL;
1208 v4l2_ctrl_handler_free(&cam->ctrl_handler);
1209 /* release transfer buffer */
1210 kfree(cam->pipe->transfer_buffer);
1214 /* release the camera */
1215 static int zr364xx_close(struct file *file)
1217 struct zr364xx_camera *cam;
1218 struct usb_device *udev;
1221 DBG("%s\n", __func__);
1222 cam = video_drvdata(file);
1224 mutex_lock(&cam->lock);
1227 if (file->private_data == cam->owner) {
1228 /* turn off stream */
1230 zr364xx_stop_acquire(cam);
1231 videobuf_streamoff(&cam->vb_vidq);
1233 for (i = 0; i < 2; i++) {
1234 send_control_msg(udev, 1, init[cam->method][i].value,
1235 0, init[cam->method][i].bytes,
1236 init[cam->method][i].size);
1241 /* Added some delay here, since opening/closing the camera quickly,
1242 * like Ekiga does during its startup, can crash the webcam
1245 mutex_unlock(&cam->lock);
1246 return v4l2_fh_release(file);
1250 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1252 struct zr364xx_camera *cam = video_drvdata(file);
1256 DBG("%s: cam == NULL\n", __func__);
1259 DBG("mmap called, vma=%p\n", vma);
1261 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1263 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1264 (unsigned long)vma->vm_start,
1265 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1269 static __poll_t zr364xx_poll(struct file *file,
1270 struct poll_table_struct *wait)
1272 struct zr364xx_camera *cam = video_drvdata(file);
1273 struct videobuf_queue *q = &cam->vb_vidq;
1274 __poll_t res = v4l2_ctrl_poll(file, wait);
1276 _DBG("%s\n", __func__);
1278 return res | videobuf_poll_stream(file, q, wait);
1281 static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1282 .s_ctrl = zr364xx_s_ctrl,
1285 static const struct v4l2_file_operations zr364xx_fops = {
1286 .owner = THIS_MODULE,
1287 .open = zr364xx_open,
1288 .release = zr364xx_close,
1289 .read = zr364xx_read,
1290 .mmap = zr364xx_mmap,
1291 .unlocked_ioctl = video_ioctl2,
1292 .poll = zr364xx_poll,
1295 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1296 .vidioc_querycap = zr364xx_vidioc_querycap,
1297 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1298 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1299 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1300 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
1301 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1302 .vidioc_g_input = zr364xx_vidioc_g_input,
1303 .vidioc_s_input = zr364xx_vidioc_s_input,
1304 .vidioc_streamon = zr364xx_vidioc_streamon,
1305 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1306 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1307 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1308 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1309 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
1310 .vidioc_log_status = v4l2_ctrl_log_status,
1311 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1312 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1315 static const struct video_device zr364xx_template = {
1316 .name = DRIVER_DESC,
1317 .fops = &zr364xx_fops,
1318 .ioctl_ops = &zr364xx_ioctl_ops,
1319 .release = video_device_release_empty,
1320 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1326 /*******************/
1327 /* USB integration */
1328 /*******************/
1329 static int zr364xx_board_init(struct zr364xx_camera *cam)
1331 struct zr364xx_pipeinfo *pipe = cam->pipe;
1334 DBG("board init: %p\n", cam);
1335 memset(pipe, 0, sizeof(*pipe));
1337 pipe->transfer_size = BUFFER_SIZE;
1339 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1341 if (!pipe->transfer_buffer) {
1342 DBG("out of memory!\n");
1347 cam->frame_count = 0;
1349 /*** start create system buffers ***/
1350 for (i = 0; i < FRAMES; i++) {
1351 /* always allocate maximum size for system buffers */
1352 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1354 DBG("valloc %p, idx %lu, pdata %p\n",
1355 &cam->buffer.frame[i], i,
1356 cam->buffer.frame[i].lpvbits);
1357 if (!cam->buffer.frame[i].lpvbits) {
1358 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Using less frames\n");
1364 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1365 kfree(cam->pipe->transfer_buffer);
1366 cam->pipe->transfer_buffer = NULL;
1369 cam->buffer.dwFrames = i;
1371 /* make sure internal states are set */
1372 for (i = 0; i < FRAMES; i++) {
1373 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1374 cam->buffer.frame[i].cur_size = 0;
1378 cam->last_frame = -1;
1379 /*** end create system buffers ***/
1381 /* start read pipe */
1382 zr364xx_start_readpipe(cam);
1383 DBG(": board initialized\n");
1387 static int zr364xx_probe(struct usb_interface *intf,
1388 const struct usb_device_id *id)
1390 struct usb_device *udev = interface_to_usbdev(intf);
1391 struct zr364xx_camera *cam = NULL;
1392 struct usb_host_interface *iface_desc;
1393 struct usb_endpoint_descriptor *endpoint;
1394 struct v4l2_ctrl_handler *hdl;
1398 DBG("probing...\n");
1400 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1401 dev_info(&intf->dev, "model %04x:%04x detected\n",
1402 le16_to_cpu(udev->descriptor.idVendor),
1403 le16_to_cpu(udev->descriptor.idProduct));
1405 cam = kzalloc(sizeof(*cam), GFP_KERNEL);
1409 cam->v4l2_dev.release = zr364xx_release;
1410 err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1412 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1416 hdl = &cam->ctrl_handler;
1417 v4l2_ctrl_handler_init(hdl, 1);
1418 v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1419 V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1422 dev_err(&udev->dev, "couldn't register control\n");
1425 /* save the init method used by this camera */
1426 cam->method = id->driver_info;
1427 mutex_init(&cam->lock);
1428 cam->vdev = zr364xx_template;
1429 cam->vdev.lock = &cam->lock;
1430 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1431 cam->vdev.ctrl_handler = &cam->ctrl_handler;
1432 video_set_drvdata(&cam->vdev, cam);
1438 dev_info(&udev->dev, "160x120 mode selected\n");
1443 dev_info(&udev->dev, "640x480 mode selected\n");
1448 dev_info(&udev->dev, "320x240 mode selected\n");
1455 m1[2].value = 0xf000 + mode;
1456 m2[1].value = 0xf000 + mode;
1458 /* special case for METHOD3, the modes are different */
1459 if (cam->method == METHOD3) {
1462 m2[1].value = 0xf000 + 4;
1465 m2[1].value = 0xf000 + 0;
1468 m2[1].value = 0xf000 + 1;
1473 header2[437] = cam->height / 256;
1474 header2[438] = cam->height % 256;
1475 header2[439] = cam->width / 256;
1476 header2[440] = cam->width % 256;
1480 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1482 /* set up the endpoint information */
1483 iface_desc = intf->cur_altsetting;
1484 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1485 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1486 endpoint = &iface_desc->endpoint[i].desc;
1487 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1488 /* we found the bulk in endpoint */
1489 cam->read_endpoint = endpoint->bEndpointAddress;
1493 if (!cam->read_endpoint) {
1495 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1500 INIT_LIST_HEAD(&cam->vidq.active);
1501 cam->vidq.cam = cam;
1503 usb_set_intfdata(intf, cam);
1505 /* load zr364xx board specific */
1506 err = zr364xx_board_init(cam);
1508 err = v4l2_ctrl_handler_setup(hdl);
1512 spin_lock_init(&cam->slock);
1516 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1518 V4L2_BUF_TYPE_VIDEO_CAPTURE,
1520 sizeof(struct zr364xx_buffer), cam, &cam->lock);
1522 err = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1524 dev_err(&udev->dev, "video_register_device failed\n");
1528 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1529 video_device_node_name(&cam->vdev));
1533 v4l2_ctrl_handler_free(hdl);
1534 v4l2_device_unregister(&cam->v4l2_dev);
1540 static void zr364xx_disconnect(struct usb_interface *intf)
1542 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1544 mutex_lock(&cam->lock);
1545 usb_set_intfdata(intf, NULL);
1546 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1547 video_unregister_device(&cam->vdev);
1548 v4l2_device_disconnect(&cam->v4l2_dev);
1550 /* stops the read pipe if it is running */
1552 zr364xx_stop_acquire(cam);
1554 zr364xx_stop_readpipe(cam);
1555 mutex_unlock(&cam->lock);
1556 v4l2_device_put(&cam->v4l2_dev);
1561 static int zr364xx_suspend(struct usb_interface *intf, pm_message_t message)
1563 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1565 cam->was_streaming = cam->b_acquire;
1566 if (!cam->was_streaming)
1568 zr364xx_stop_acquire(cam);
1569 zr364xx_stop_readpipe(cam);
1573 static int zr364xx_resume(struct usb_interface *intf)
1575 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1578 if (!cam->was_streaming)
1581 zr364xx_start_readpipe(cam);
1582 res = zr364xx_prepare(cam);
1584 zr364xx_start_acquire(cam);
1589 /**********************/
1590 /* Module integration */
1591 /**********************/
1593 static struct usb_driver zr364xx_driver = {
1595 .probe = zr364xx_probe,
1596 .disconnect = zr364xx_disconnect,
1598 .suspend = zr364xx_suspend,
1599 .resume = zr364xx_resume,
1600 .reset_resume = zr364xx_resume,
1602 .id_table = device_table
1605 module_usb_driver(zr364xx_driver);
1607 MODULE_AUTHOR(DRIVER_AUTHOR);
1608 MODULE_DESCRIPTION(DRIVER_DESC);
1609 MODULE_LICENSE("GPL");
1610 MODULE_VERSION(DRIVER_VERSION);