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/videobuf-vmalloc.h>
43 /* Version Information */
44 #define DRIVER_VERSION "0.7.4"
45 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
46 #define DRIVER_DESC "Zoran 364xx"
51 #define MAX_FRAME_SIZE 200000
52 #define BUFFER_SIZE 0x1000
53 #define CTRL_TIMEOUT 500
55 #define ZR364XX_DEF_BUFS 4
56 #define ZR364XX_READ_IDLE 0
57 #define ZR364XX_READ_FRAME 1
60 #define DBG(fmt, args...) \
63 printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
67 /*#define FULL_DEBUG 1*/
71 #define _DBG(fmt, args...)
74 /* Init methods, need to find nicer names for these
75 * the exact names of the chipsets would be the best if someone finds it */
82 /* Module parameters */
87 /* Module parameters interface */
88 module_param(debug, int, 0644);
89 MODULE_PARM_DESC(debug, "Debug level");
90 module_param(mode, int, 0644);
91 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
94 /* Devices supported by this driver
95 * .driver_info contains the init method used by the camera */
96 static struct usb_device_id device_table[] = {
97 {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
98 {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
99 {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
100 {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
101 {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
102 {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
103 {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
104 {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
105 {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
106 {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
107 {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
108 {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
109 {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
110 {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
111 {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
112 {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
113 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
114 {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
115 {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
116 {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 },
117 {USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 },
118 {} /* Terminating entry */
121 MODULE_DEVICE_TABLE(usb, device_table);
123 struct zr364xx_mode {
124 u32 color; /* output video color format */
125 u32 brightness; /* brightness */
128 /* frame structure */
129 struct zr364xx_framei {
130 unsigned long ulState; /* ulState:ZR364XX_READ_IDLE,
131 ZR364XX_READ_FRAME */
132 void *lpvbits; /* image data */
133 unsigned long cur_size; /* current data copied to it */
136 /* image buffer structure */
137 struct zr364xx_bufferi {
138 unsigned long dwFrames; /* number of frames in buffer */
139 struct zr364xx_framei frame[FRAMES]; /* array of FRAME structures */
142 struct zr364xx_dmaqueue {
143 struct list_head active;
144 struct zr364xx_camera *cam;
147 struct zr364xx_pipeinfo {
152 void *cam; /* back pointer to zr364xx_camera struct */
164 static const struct zr364xx_fmt formats[] = {
167 .fourcc = V4L2_PIX_FMT_JPEG,
173 struct zr364xx_camera {
174 struct usb_device *udev; /* save off the usb device pointer */
175 struct usb_interface *interface;/* the interface for this device */
176 struct video_device *vdev; /* v4l video device */
178 struct zr364xx_bufferi buffer;
184 struct mutex open_lock;
188 struct zr364xx_dmaqueue vidq;
192 unsigned long frame_count;
194 struct zr364xx_pipeinfo pipe[1];
198 const struct zr364xx_fmt *fmt;
199 struct videobuf_queue vb_vidq;
200 enum v4l2_buf_type type;
201 struct zr364xx_mode mode;
204 /* buffer for one video frame */
205 struct zr364xx_buffer {
206 /* common v4l buffer stuff -- must be first */
207 struct videobuf_buffer vb;
208 const struct zr364xx_fmt *fmt;
211 /* function used to send initialisation commands to the camera */
212 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
213 u16 index, unsigned char *cp, u16 size)
217 unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
218 if (!transfer_buffer) {
219 dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
223 memcpy(transfer_buffer, cp, size);
225 status = usb_control_msg(udev,
226 usb_sndctrlpipe(udev, 0),
228 USB_DIR_OUT | USB_TYPE_VENDOR |
229 USB_RECIP_DEVICE, value, index,
230 transfer_buffer, size, CTRL_TIMEOUT);
232 kfree(transfer_buffer);
236 "Failed sending control message, error %d.\n", status);
242 /* Control messages sent to the camera to initialize it
243 * and launch the capture */
247 unsigned char *bytes;
251 static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
252 static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
253 static unsigned char m0d3[] = { 0, 0 };
254 static message m0[] = {
257 {0x3370, sizeof(m0d1), m0d1},
260 {0x2610, sizeof(m0d2), m0d2},
265 {0x9a01, sizeof(m0d3), m0d3},
270 static unsigned char m1d1[] = { 0xff, 0xff };
271 static unsigned char m1d2[] = { 0x00, 0x00 };
272 static message m1[] = {
280 {0x2502, sizeof(m1d1), m1d1},
285 {0x9a01, sizeof(m1d2), m1d2},
290 static unsigned char m2d1[] = { 0xff, 0xff };
291 static message m2[] = {
298 {0x2502, sizeof(m2d1), m2d1},
304 static message *init[4] = { m0, m1, m2, m2 };
307 /* JPEG static data in header (Huffman table, etc) */
308 static unsigned char header1[] = {
311 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
312 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
314 0xFF, 0xDB, 0x00, 0x84
316 static unsigned char header2[] = {
317 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
318 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
320 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
321 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
322 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
323 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
324 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
325 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
326 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
327 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
328 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
329 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
330 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
331 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
332 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
333 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
334 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
335 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
336 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
337 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
338 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
339 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
340 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
341 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
342 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
343 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
344 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
345 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
346 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
347 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
348 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
349 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
350 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
351 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
352 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
353 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
354 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
355 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
356 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
357 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
358 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
361 static unsigned char header3;
363 /* ------------------------------------------------------------------
365 ------------------------------------------------------------------*/
367 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
370 struct zr364xx_camera *cam = vq->priv_data;
372 *size = cam->width * cam->height * (cam->fmt->depth >> 3);
375 *count = ZR364XX_DEF_BUFS;
377 if (*size * *count > ZR364XX_DEF_BUFS * 1024 * 1024)
378 *count = (ZR364XX_DEF_BUFS * 1024 * 1024) / *size;
383 static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
385 _DBG("%s\n", __func__);
390 videobuf_vmalloc_free(&buf->vb);
391 buf->vb.state = VIDEOBUF_NEEDS_INIT;
394 static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
395 enum v4l2_field field)
397 struct zr364xx_camera *cam = vq->priv_data;
398 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
402 DBG("%s, field=%d, fmt name = %s\n", __func__, field, cam->fmt != NULL ?
403 cam->fmt->name : "");
404 if (cam->fmt == NULL)
407 buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
409 if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
410 DBG("invalid buffer prepare\n");
415 buf->vb.width = cam->width;
416 buf->vb.height = cam->height;
417 buf->vb.field = field;
419 if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
420 rc = videobuf_iolock(vq, &buf->vb, NULL);
425 buf->vb.state = VIDEOBUF_PREPARED;
428 free_buffer(vq, buf);
432 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
434 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
436 struct zr364xx_camera *cam = vq->priv_data;
438 _DBG("%s\n", __func__);
440 buf->vb.state = VIDEOBUF_QUEUED;
441 list_add_tail(&buf->vb.queue, &cam->vidq.active);
444 static void buffer_release(struct videobuf_queue *vq,
445 struct videobuf_buffer *vb)
447 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
450 _DBG("%s\n", __func__);
451 free_buffer(vq, buf);
454 static struct videobuf_queue_ops zr364xx_video_qops = {
455 .buf_setup = buffer_setup,
456 .buf_prepare = buffer_prepare,
457 .buf_queue = buffer_queue,
458 .buf_release = buffer_release,
461 /********************/
462 /* V4L2 integration */
463 /********************/
464 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
465 enum v4l2_buf_type type);
467 static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
470 struct zr364xx_camera *cam = video_drvdata(file);
472 _DBG("%s\n", __func__);
480 if (cam->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
481 zr364xx_vidioc_streamon(file, cam, cam->type) == 0) {
482 DBG("%s: reading %d bytes at pos %d.\n", __func__, (int) count,
486 return videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
487 file->f_flags & O_NONBLOCK);
493 /* video buffer vmalloc implementation based partly on VIVI driver which is
494 * Copyright (c) 2006 by
495 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
496 * Ted Walther <ted--a.t--enumera.com>
497 * John Sokol <sokol--a.t--videotechnology.com>
498 * http://v4l.videotechnology.com/
501 static void zr364xx_fillbuff(struct zr364xx_camera *cam,
502 struct zr364xx_buffer *buf,
508 char *vbuf = videobuf_to_vmalloc(&buf->vb);
509 unsigned long last_frame;
510 struct zr364xx_framei *frm;
515 last_frame = cam->last_frame;
516 if (last_frame != -1) {
517 frm = &cam->buffer.frame[last_frame];
518 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
519 switch (buf->fmt->fourcc) {
520 case V4L2_PIX_FMT_JPEG:
521 buf->vb.size = jpgsize;
522 memcpy(vbuf, tmpbuf, buf->vb.size);
525 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
527 cam->last_frame = -1;
529 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
532 DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
533 (unsigned long)vbuf, pos);
534 /* tell v4l buffer was filled */
536 buf->vb.field_count = cam->frame_count * 2;
537 do_gettimeofday(&ts);
539 buf->vb.state = VIDEOBUF_DONE;
542 static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
544 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
545 struct zr364xx_buffer *buf;
546 unsigned long flags = 0;
549 DBG("wakeup: %p\n", &dma_q);
550 spin_lock_irqsave(&cam->slock, flags);
552 if (list_empty(&dma_q->active)) {
553 DBG("No active queue to serve\n");
557 buf = list_entry(dma_q->active.next,
558 struct zr364xx_buffer, vb.queue);
560 if (!waitqueue_active(&buf->vb.done)) {
565 list_del(&buf->vb.queue);
566 do_gettimeofday(&buf->vb.ts);
567 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
568 zr364xx_fillbuff(cam, buf, jpgsize);
569 wake_up(&buf->vb.done);
570 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
572 spin_unlock_irqrestore(&cam->slock, flags);
576 /* this function moves the usb stream read pipe data
577 * into the system buffers.
578 * returns 0 on success, EAGAIN if more data to process (call this
581 static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
582 struct zr364xx_pipeinfo *pipe_info,
585 unsigned char *pdest;
588 struct zr364xx_framei *frm;
590 unsigned char *ptr = NULL;
592 _DBG("buffer to user\n");
593 idx = cam->cur_frame;
594 frm = &cam->buffer.frame[idx];
596 /* swap bytes if camera needs it */
597 if (cam->method == METHOD0) {
598 u16 *buf = (u16 *)pipe_info->transfer_buffer;
599 for (i = 0; i < purb->actual_length/2; i++)
603 /* search done. now find out if should be acquiring */
604 if (!cam->b_acquire) {
605 /* we found a frame, but this channel is turned off */
606 frm->ulState = ZR364XX_READ_IDLE;
610 psrc = (u8 *)pipe_info->transfer_buffer;
611 ptr = pdest = frm->lpvbits;
613 if (frm->ulState == ZR364XX_READ_IDLE) {
614 if (purb->actual_length < 128) {
615 /* header incomplete */
616 dev_info(&cam->udev->dev,
617 "%s: buffer (%d bytes) too small to hold jpeg header. Discarding.\n",
618 __func__, purb->actual_length);
622 frm->ulState = ZR364XX_READ_FRAME;
625 _DBG("jpeg header, ");
626 memcpy(ptr, header1, sizeof(header1));
627 ptr += sizeof(header1);
629 memcpy(ptr, &header3, 1);
631 memcpy(ptr, psrc, 64);
634 memcpy(ptr, &header3, 1);
636 memcpy(ptr, psrc + 64, 64);
638 memcpy(ptr, header2, sizeof(header2));
639 ptr += sizeof(header2);
640 memcpy(ptr, psrc + 128,
641 purb->actual_length - 128);
642 ptr += purb->actual_length - 128;
643 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
644 psrc[0], psrc[1], psrc[2],
645 psrc[3], psrc[4], psrc[5],
646 psrc[6], psrc[7], psrc[8]);
647 frm->cur_size = ptr - pdest;
649 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
650 dev_info(&cam->udev->dev,
651 "%s: buffer (%d bytes) too small to hold "
652 "frame data. Discarding frame data.\n",
653 __func__, MAX_FRAME_SIZE);
655 pdest += frm->cur_size;
656 memcpy(pdest, psrc, purb->actual_length);
657 frm->cur_size += purb->actual_length;
660 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
661 purb->actual_length);*/
663 if (purb->actual_length < pipe_info->transfer_size) {
664 _DBG("****************Buffer[%d]full*************\n", idx);
665 cam->last_frame = cam->cur_frame;
667 /* end of system frame ring buffer, start at zero */
668 if (cam->cur_frame == cam->buffer.dwFrames)
672 /* go back to find the JPEG EOI marker */
673 ptr = pdest = frm->lpvbits;
674 ptr += frm->cur_size - 2;
675 while (ptr > pdest) {
676 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
677 && *(ptr + 2) == 0xFF)
682 DBG("No EOI marker\n");
684 /* Sometimes there is junk data in the middle of the picture,
685 * we want to skip this bogus frames */
686 while (ptr > pdest) {
687 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
688 && *(ptr + 2) == 0xFF)
693 DBG("Bogus frame ? %d\n", ++(cam->nb));
694 } else if (cam->b_acquire) {
695 /* we skip the 2 first frames which are usually buggy */
699 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
701 pdest[0], pdest[1], pdest[2], pdest[3],
702 pdest[4], pdest[5], pdest[6], pdest[7]);
704 zr364xx_got_frame(cam, frm->cur_size);
708 frm->ulState = ZR364XX_READ_IDLE;
711 /* done successfully */
715 static int res_get(struct zr364xx_camera *cam)
718 mutex_lock(&cam->lock);
719 if (cam->resources) {
720 /* no, someone else uses it */
721 mutex_unlock(&cam->lock);
724 /* it's free, grab it */
727 mutex_unlock(&cam->lock);
731 static inline int res_check(struct zr364xx_camera *cam)
733 return cam->resources;
736 static void res_free(struct zr364xx_camera *cam)
738 mutex_lock(&cam->lock);
740 mutex_unlock(&cam->lock);
744 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
745 struct v4l2_capability *cap)
747 struct zr364xx_camera *cam = video_drvdata(file);
749 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
750 strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
751 strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
752 sizeof(cap->bus_info));
753 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
760 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
761 struct v4l2_input *i)
765 strcpy(i->name, DRIVER_DESC " Camera");
766 i->type = V4L2_INPUT_TYPE_CAMERA;
770 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
777 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
785 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
786 struct v4l2_queryctrl *c)
788 struct zr364xx_camera *cam;
792 cam = video_drvdata(file);
795 case V4L2_CID_BRIGHTNESS:
796 c->type = V4L2_CTRL_TYPE_INTEGER;
797 strcpy(c->name, "Brightness");
801 c->default_value = cam->mode.brightness;
810 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
811 struct v4l2_control *c)
813 struct zr364xx_camera *cam;
818 cam = video_drvdata(file);
821 case V4L2_CID_BRIGHTNESS:
822 cam->mode.brightness = c->value;
823 /* hardware brightness */
824 mutex_lock(&cam->lock);
825 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
826 temp = (0x60 << 8) + 127 - cam->mode.brightness;
827 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
828 mutex_unlock(&cam->lock);
837 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
838 struct v4l2_control *c)
840 struct zr364xx_camera *cam;
844 cam = video_drvdata(file);
847 case V4L2_CID_BRIGHTNESS:
848 c->value = cam->mode.brightness;
856 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
857 void *priv, struct v4l2_fmtdesc *f)
861 f->flags = V4L2_FMT_FLAG_COMPRESSED;
862 strcpy(f->description, formats[0].name);
863 f->pixelformat = formats[0].fourcc;
867 static char *decode_fourcc(__u32 pixelformat, char *buf)
869 buf[0] = pixelformat & 0xff;
870 buf[1] = (pixelformat >> 8) & 0xff;
871 buf[2] = (pixelformat >> 16) & 0xff;
872 buf[3] = (pixelformat >> 24) & 0xff;
877 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
878 struct v4l2_format *f)
880 struct zr364xx_camera *cam = video_drvdata(file);
881 char pixelformat_name[5];
886 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
887 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
888 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
892 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
893 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
894 f->fmt.pix.width = 320;
895 f->fmt.pix.height = 240;
898 f->fmt.pix.field = V4L2_FIELD_NONE;
899 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
900 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
901 f->fmt.pix.colorspace = 0;
903 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
904 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
909 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
910 struct v4l2_format *f)
912 struct zr364xx_camera *cam;
916 cam = video_drvdata(file);
918 f->fmt.pix.pixelformat = formats[0].fourcc;
919 f->fmt.pix.field = V4L2_FIELD_NONE;
920 f->fmt.pix.width = cam->width;
921 f->fmt.pix.height = cam->height;
922 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
923 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
924 f->fmt.pix.colorspace = 0;
929 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
930 struct v4l2_format *f)
932 struct zr364xx_camera *cam = video_drvdata(file);
933 struct videobuf_queue *q = &cam->vb_vidq;
934 char pixelformat_name[5];
935 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
941 mutex_lock(&q->vb_lock);
943 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
944 DBG("%s queue busy\n", __func__);
949 if (res_check(cam)) {
950 DBG("%s can't change format after started\n", __func__);
955 cam->width = f->fmt.pix.width;
956 cam->height = f->fmt.pix.height;
957 dev_info(&cam->udev->dev, "%s: %dx%d mode selected\n", __func__,
958 cam->width, cam->height);
959 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
960 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
961 f->fmt.pix.colorspace = 0;
963 cam->vb_vidq.field = f->fmt.pix.field;
964 cam->mode.color = V4L2_PIX_FMT_JPEG;
966 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
968 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
974 m1[2].value = 0xf000 + mode;
975 m2[1].value = 0xf000 + mode;
977 /* special case for METHOD3, the modes are different */
978 if (cam->method == METHOD3) {
981 m2[1].value = 0xf000 + 4;
984 m2[1].value = 0xf000 + 0;
987 m2[1].value = 0xf000 + 1;
992 header2[437] = cam->height / 256;
993 header2[438] = cam->height % 256;
994 header2[439] = cam->width / 256;
995 header2[440] = cam->width % 256;
997 for (i = 0; init[cam->method][i].size != -1; i++) {
999 send_control_msg(cam->udev, 1, init[cam->method][i].value,
1000 0, init[cam->method][i].bytes,
1001 init[cam->method][i].size);
1003 dev_err(&cam->udev->dev,
1004 "error during resolution change sequence: %d\n", i);
1009 /* Added some delay here, since opening/closing the camera quickly,
1010 * like Ekiga does during its startup, can crash the webcam
1017 mutex_unlock(&q->vb_lock);
1019 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
1020 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
1025 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
1026 struct v4l2_requestbuffers *p)
1029 struct zr364xx_camera *cam = video_drvdata(file);
1030 rc = videobuf_reqbufs(&cam->vb_vidq, p);
1034 static int zr364xx_vidioc_querybuf(struct file *file,
1036 struct v4l2_buffer *p)
1039 struct zr364xx_camera *cam = video_drvdata(file);
1040 rc = videobuf_querybuf(&cam->vb_vidq, p);
1044 static int zr364xx_vidioc_qbuf(struct file *file,
1046 struct v4l2_buffer *p)
1049 struct zr364xx_camera *cam = video_drvdata(file);
1050 _DBG("%s\n", __func__);
1051 rc = videobuf_qbuf(&cam->vb_vidq, p);
1055 static int zr364xx_vidioc_dqbuf(struct file *file,
1057 struct v4l2_buffer *p)
1060 struct zr364xx_camera *cam = video_drvdata(file);
1061 _DBG("%s\n", __func__);
1062 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
1066 static void read_pipe_completion(struct urb *purb)
1068 struct zr364xx_pipeinfo *pipe_info;
1069 struct zr364xx_camera *cam;
1072 pipe_info = purb->context;
1073 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
1074 if (pipe_info == NULL) {
1075 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1079 cam = pipe_info->cam;
1081 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1085 /* if shutting down, do not resubmit, exit immediately */
1086 if (purb->status == -ESHUTDOWN) {
1087 DBG("%s, err shutdown\n", __func__);
1088 pipe_info->err_count++;
1092 if (pipe_info->state == 0) {
1093 DBG("exiting USB pipe\n");
1097 if (purb->actual_length < 0 ||
1098 purb->actual_length > pipe_info->transfer_size) {
1099 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1103 if (purb->status == 0)
1104 zr364xx_read_video_callback(cam, pipe_info, purb);
1106 pipe_info->err_count++;
1107 DBG("%s: failed URB %d\n", __func__, purb->status);
1110 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1113 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1115 pipe_info->transfer_buffer,
1116 pipe_info->transfer_size,
1117 read_pipe_completion, pipe_info);
1119 if (pipe_info->state != 0) {
1120 purb->status = usb_submit_urb(pipe_info->stream_urb,
1124 dev_err(&cam->udev->dev,
1125 "error submitting urb (error=%i)\n",
1128 DBG("read pipe complete state 0\n");
1131 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1135 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1136 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1137 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1139 pipe_info->state = 1;
1140 pipe_info->err_count = 0;
1141 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1142 if (!pipe_info->stream_urb) {
1143 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1146 /* transfer buffer allocated in board_init */
1147 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1149 pipe_info->transfer_buffer,
1150 pipe_info->transfer_size,
1151 read_pipe_completion, pipe_info);
1153 DBG("submitting URB %p\n", pipe_info->stream_urb);
1154 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1156 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1163 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1165 struct zr364xx_pipeinfo *pipe_info;
1168 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1171 DBG("stop read pipe\n");
1172 pipe_info = cam->pipe;
1174 if (pipe_info->state != 0)
1175 pipe_info->state = 0;
1177 if (pipe_info->stream_urb) {
1179 usb_kill_urb(pipe_info->stream_urb);
1180 usb_free_urb(pipe_info->stream_urb);
1181 pipe_info->stream_urb = NULL;
1187 /* starts acquisition process */
1188 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1192 DBG("start acquire\n");
1194 cam->last_frame = -1;
1196 for (j = 0; j < FRAMES; j++) {
1197 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1198 cam->buffer.frame[j].cur_size = 0;
1204 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1210 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1211 enum v4l2_buf_type type)
1213 struct zr364xx_camera *cam = video_drvdata(file);
1217 DBG("%s\n", __func__);
1219 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1220 dev_err(&cam->udev->dev, "invalid fh type0\n");
1223 if (cam->type != type) {
1224 dev_err(&cam->udev->dev, "invalid fh type1\n");
1228 if (!res_get(cam)) {
1229 dev_err(&cam->udev->dev, "stream busy\n");
1233 cam->last_frame = -1;
1235 cam->frame_count = 0;
1236 for (j = 0; j < FRAMES; j++) {
1237 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1238 cam->buffer.frame[j].cur_size = 0;
1240 res = videobuf_streamon(&cam->vb_vidq);
1242 zr364xx_start_acquire(cam);
1249 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1250 enum v4l2_buf_type type)
1253 struct zr364xx_camera *cam = video_drvdata(file);
1255 DBG("%s\n", __func__);
1256 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1257 dev_err(&cam->udev->dev, "invalid fh type0\n");
1260 if (cam->type != type) {
1261 dev_err(&cam->udev->dev, "invalid fh type1\n");
1264 zr364xx_stop_acquire(cam);
1265 res = videobuf_streamoff(&cam->vb_vidq);
1273 /* open the camera */
1274 static int zr364xx_open(struct file *file)
1276 struct video_device *vdev = video_devdata(file);
1277 struct zr364xx_camera *cam = video_drvdata(file);
1278 struct usb_device *udev = cam->udev;
1281 DBG("%s\n", __func__);
1283 mutex_lock(&cam->open_lock);
1290 for (i = 0; init[cam->method][i].size != -1; i++) {
1292 send_control_msg(udev, 1, init[cam->method][i].value,
1293 0, init[cam->method][i].bytes,
1294 init[cam->method][i].size);
1296 dev_err(&cam->udev->dev,
1297 "error during open sequence: %d\n", i);
1304 file->private_data = vdev;
1305 cam->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1308 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1312 sizeof(struct zr364xx_buffer), cam, NULL);
1314 /* Added some delay here, since opening/closing the camera quickly,
1315 * like Ekiga does during its startup, can crash the webcam
1321 mutex_unlock(&cam->open_lock);
1322 DBG("%s: %d\n", __func__, err);
1326 static void zr364xx_destroy(struct zr364xx_camera *cam)
1331 printk(KERN_ERR KBUILD_MODNAME ", %s: no device\n", __func__);
1334 mutex_lock(&cam->open_lock);
1336 video_unregister_device(cam->vdev);
1339 /* stops the read pipe if it is running */
1341 zr364xx_stop_acquire(cam);
1343 zr364xx_stop_readpipe(cam);
1345 /* release sys buffers */
1346 for (i = 0; i < FRAMES; i++) {
1347 if (cam->buffer.frame[i].lpvbits) {
1348 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1349 vfree(cam->buffer.frame[i].lpvbits);
1351 cam->buffer.frame[i].lpvbits = NULL;
1354 /* release transfer buffer */
1355 kfree(cam->pipe->transfer_buffer);
1356 cam->pipe->transfer_buffer = NULL;
1357 mutex_unlock(&cam->open_lock);
1362 /* release the camera */
1363 static int zr364xx_release(struct file *file)
1365 struct zr364xx_camera *cam;
1366 struct usb_device *udev;
1369 DBG("%s\n", __func__);
1370 cam = video_drvdata(file);
1375 mutex_lock(&cam->open_lock);
1378 /* turn off stream */
1379 if (res_check(cam)) {
1381 zr364xx_stop_acquire(cam);
1382 videobuf_streamoff(&cam->vb_vidq);
1387 file->private_data = NULL;
1389 for (i = 0; i < 2; i++) {
1391 send_control_msg(udev, 1, init[cam->method][i].value,
1392 0, init[cam->method][i].bytes,
1393 init[cam->method][i].size);
1395 dev_err(&udev->dev, "error during release sequence\n");
1400 /* Added some delay here, since opening/closing the camera quickly,
1401 * like Ekiga does during its startup, can crash the webcam
1407 mutex_unlock(&cam->open_lock);
1413 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1415 struct zr364xx_camera *cam = video_drvdata(file);
1419 DBG("%s: cam == NULL\n", __func__);
1422 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1424 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1426 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1427 (unsigned long)vma->vm_start,
1428 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1432 static unsigned int zr364xx_poll(struct file *file,
1433 struct poll_table_struct *wait)
1435 struct zr364xx_camera *cam = video_drvdata(file);
1436 struct videobuf_queue *q = &cam->vb_vidq;
1437 _DBG("%s\n", __func__);
1439 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1442 return videobuf_poll_stream(file, q, wait);
1445 static const struct v4l2_file_operations zr364xx_fops = {
1446 .owner = THIS_MODULE,
1447 .open = zr364xx_open,
1448 .release = zr364xx_release,
1449 .read = zr364xx_read,
1450 .mmap = zr364xx_mmap,
1451 .ioctl = video_ioctl2,
1452 .poll = zr364xx_poll,
1455 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1456 .vidioc_querycap = zr364xx_vidioc_querycap,
1457 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1458 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1459 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1460 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
1461 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1462 .vidioc_g_input = zr364xx_vidioc_g_input,
1463 .vidioc_s_input = zr364xx_vidioc_s_input,
1464 .vidioc_streamon = zr364xx_vidioc_streamon,
1465 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1466 .vidioc_queryctrl = zr364xx_vidioc_queryctrl,
1467 .vidioc_g_ctrl = zr364xx_vidioc_g_ctrl,
1468 .vidioc_s_ctrl = zr364xx_vidioc_s_ctrl,
1469 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1470 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1471 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1472 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
1475 static struct video_device zr364xx_template = {
1476 .name = DRIVER_DESC,
1477 .fops = &zr364xx_fops,
1478 .ioctl_ops = &zr364xx_ioctl_ops,
1479 .release = video_device_release,
1484 /*******************/
1485 /* USB integration */
1486 /*******************/
1487 static int zr364xx_board_init(struct zr364xx_camera *cam)
1489 struct zr364xx_pipeinfo *pipe = cam->pipe;
1492 DBG("board init: %p\n", cam);
1493 memset(pipe, 0, sizeof(*pipe));
1495 pipe->transfer_size = BUFFER_SIZE;
1497 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1499 if (pipe->transfer_buffer == NULL) {
1500 DBG("out of memory!\n");
1505 cam->frame_count = 0;
1507 /*** start create system buffers ***/
1508 for (i = 0; i < FRAMES; i++) {
1509 /* always allocate maximum size for system buffers */
1510 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1512 DBG("valloc %p, idx %lu, pdata %p\n",
1513 &cam->buffer.frame[i], i,
1514 cam->buffer.frame[i].lpvbits);
1515 if (cam->buffer.frame[i].lpvbits == NULL) {
1516 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1517 "Using less frames\n");
1523 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1524 kfree(cam->pipe->transfer_buffer);
1525 cam->pipe->transfer_buffer = NULL;
1528 cam->buffer.dwFrames = i;
1530 /* make sure internal states are set */
1531 for (i = 0; i < FRAMES; i++) {
1532 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1533 cam->buffer.frame[i].cur_size = 0;
1537 cam->last_frame = -1;
1538 /*** end create system buffers ***/
1540 /* start read pipe */
1541 zr364xx_start_readpipe(cam);
1542 DBG(": board initialized\n");
1546 static int zr364xx_probe(struct usb_interface *intf,
1547 const struct usb_device_id *id)
1549 struct usb_device *udev = interface_to_usbdev(intf);
1550 struct zr364xx_camera *cam = NULL;
1551 struct usb_host_interface *iface_desc;
1552 struct usb_endpoint_descriptor *endpoint;
1556 DBG("probing...\n");
1558 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1559 dev_info(&intf->dev, "model %04x:%04x detected\n",
1560 le16_to_cpu(udev->descriptor.idVendor),
1561 le16_to_cpu(udev->descriptor.idProduct));
1563 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1565 dev_err(&udev->dev, "cam: out of memory !\n");
1568 /* save the init method used by this camera */
1569 cam->method = id->driver_info;
1571 cam->vdev = video_device_alloc();
1572 if (cam->vdev == NULL) {
1573 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
1578 memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
1579 cam->vdev->parent = &intf->dev;
1580 video_set_drvdata(cam->vdev, cam);
1582 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1588 dev_info(&udev->dev, "160x120 mode selected\n");
1593 dev_info(&udev->dev, "640x480 mode selected\n");
1598 dev_info(&udev->dev, "320x240 mode selected\n");
1605 m1[2].value = 0xf000 + mode;
1606 m2[1].value = 0xf000 + mode;
1608 /* special case for METHOD3, the modes are different */
1609 if (cam->method == METHOD3) {
1612 m2[1].value = 0xf000 + 4;
1615 m2[1].value = 0xf000 + 0;
1618 m2[1].value = 0xf000 + 1;
1623 header2[437] = cam->height / 256;
1624 header2[438] = cam->height % 256;
1625 header2[439] = cam->width / 256;
1626 header2[440] = cam->width % 256;
1630 cam->mode.brightness = 64;
1631 mutex_init(&cam->lock);
1632 mutex_init(&cam->open_lock);
1634 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1636 /* set up the endpoint information */
1637 iface_desc = intf->cur_altsetting;
1638 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1639 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1640 endpoint = &iface_desc->endpoint[i].desc;
1641 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1642 /* we found the bulk in endpoint */
1643 cam->read_endpoint = endpoint->bEndpointAddress;
1647 if (!cam->read_endpoint) {
1648 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1649 video_device_release(cam->vdev);
1656 INIT_LIST_HEAD(&cam->vidq.active);
1657 cam->vidq.cam = cam;
1658 err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
1660 dev_err(&udev->dev, "video_register_device failed\n");
1661 video_device_release(cam->vdev);
1667 usb_set_intfdata(intf, cam);
1669 /* load zr364xx board specific */
1670 err = zr364xx_board_init(cam);
1672 spin_lock_init(&cam->slock);
1676 spin_lock_init(&cam->slock);
1678 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1679 video_device_node_name(cam->vdev));
1684 static void zr364xx_disconnect(struct usb_interface *intf)
1686 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1687 videobuf_mmap_free(&cam->vb_vidq);
1688 usb_set_intfdata(intf, NULL);
1689 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1690 zr364xx_destroy(cam);
1695 /**********************/
1696 /* Module integration */
1697 /**********************/
1699 static struct usb_driver zr364xx_driver = {
1701 .probe = zr364xx_probe,
1702 .disconnect = zr364xx_disconnect,
1703 .id_table = device_table
1707 static int __init zr364xx_init(void)
1710 retval = usb_register(&zr364xx_driver);
1712 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
1714 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1719 static void __exit zr364xx_exit(void)
1721 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
1722 usb_deregister(&zr364xx_driver);
1726 module_init(zr364xx_init);
1727 module_exit(zr364xx_exit);
1729 MODULE_AUTHOR(DRIVER_AUTHOR);
1730 MODULE_DESCRIPTION(DRIVER_DESC);
1731 MODULE_LICENSE("GPL");
1732 MODULE_VERSION(DRIVER_VERSION);