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;
514 last_frame = cam->last_frame;
515 if (last_frame != -1) {
516 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
517 switch (buf->fmt->fourcc) {
518 case V4L2_PIX_FMT_JPEG:
519 buf->vb.size = jpgsize;
520 memcpy(vbuf, tmpbuf, buf->vb.size);
523 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
525 cam->last_frame = -1;
527 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
530 DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
531 (unsigned long)vbuf, pos);
532 /* tell v4l buffer was filled */
534 buf->vb.field_count = cam->frame_count * 2;
535 do_gettimeofday(&ts);
537 buf->vb.state = VIDEOBUF_DONE;
540 static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
542 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
543 struct zr364xx_buffer *buf;
544 unsigned long flags = 0;
547 DBG("wakeup: %p\n", &dma_q);
548 spin_lock_irqsave(&cam->slock, flags);
550 if (list_empty(&dma_q->active)) {
551 DBG("No active queue to serve\n");
555 buf = list_entry(dma_q->active.next,
556 struct zr364xx_buffer, vb.queue);
558 if (!waitqueue_active(&buf->vb.done)) {
563 list_del(&buf->vb.queue);
564 do_gettimeofday(&buf->vb.ts);
565 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
566 zr364xx_fillbuff(cam, buf, jpgsize);
567 wake_up(&buf->vb.done);
568 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
570 spin_unlock_irqrestore(&cam->slock, flags);
574 /* this function moves the usb stream read pipe data
575 * into the system buffers.
576 * returns 0 on success, EAGAIN if more data to process (call this
579 static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
580 struct zr364xx_pipeinfo *pipe_info,
583 unsigned char *pdest;
586 struct zr364xx_framei *frm;
588 unsigned char *ptr = NULL;
590 _DBG("buffer to user\n");
591 idx = cam->cur_frame;
592 frm = &cam->buffer.frame[idx];
594 /* swap bytes if camera needs it */
595 if (cam->method == METHOD0) {
596 u16 *buf = (u16 *)pipe_info->transfer_buffer;
597 for (i = 0; i < purb->actual_length/2; i++)
601 /* search done. now find out if should be acquiring */
602 if (!cam->b_acquire) {
603 /* we found a frame, but this channel is turned off */
604 frm->ulState = ZR364XX_READ_IDLE;
608 psrc = (u8 *)pipe_info->transfer_buffer;
609 ptr = pdest = frm->lpvbits;
611 if (frm->ulState == ZR364XX_READ_IDLE) {
612 frm->ulState = ZR364XX_READ_FRAME;
615 _DBG("jpeg header, ");
616 memcpy(ptr, header1, sizeof(header1));
617 ptr += sizeof(header1);
619 memcpy(ptr, &header3, 1);
621 memcpy(ptr, psrc, 64);
624 memcpy(ptr, &header3, 1);
626 memcpy(ptr, psrc + 64, 64);
628 memcpy(ptr, header2, sizeof(header2));
629 ptr += sizeof(header2);
630 memcpy(ptr, psrc + 128,
631 purb->actual_length - 128);
632 ptr += purb->actual_length - 128;
633 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
634 psrc[0], psrc[1], psrc[2],
635 psrc[3], psrc[4], psrc[5],
636 psrc[6], psrc[7], psrc[8]);
637 frm->cur_size = ptr - pdest;
639 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
640 dev_info(&cam->udev->dev,
641 "%s: buffer (%d bytes) too small to hold "
642 "frame data. Discarding frame data.\n",
643 __func__, MAX_FRAME_SIZE);
645 pdest += frm->cur_size;
646 memcpy(pdest, psrc, purb->actual_length);
647 frm->cur_size += purb->actual_length;
650 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
651 purb->actual_length);*/
653 if (purb->actual_length < pipe_info->transfer_size) {
654 _DBG("****************Buffer[%d]full*************\n", idx);
655 cam->last_frame = cam->cur_frame;
657 /* end of system frame ring buffer, start at zero */
658 if (cam->cur_frame == cam->buffer.dwFrames)
662 /* go back to find the JPEG EOI marker */
663 ptr = pdest = frm->lpvbits;
664 ptr += frm->cur_size - 2;
665 while (ptr > pdest) {
666 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
667 && *(ptr + 2) == 0xFF)
672 DBG("No EOI marker\n");
674 /* Sometimes there is junk data in the middle of the picture,
675 * we want to skip this bogus frames */
676 while (ptr > pdest) {
677 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
678 && *(ptr + 2) == 0xFF)
683 DBG("Bogus frame ? %d\n", ++(cam->nb));
684 } else if (cam->b_acquire) {
685 /* we skip the 2 first frames which are usually buggy */
689 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
691 pdest[0], pdest[1], pdest[2], pdest[3],
692 pdest[4], pdest[5], pdest[6], pdest[7]);
694 zr364xx_got_frame(cam, frm->cur_size);
698 frm->ulState = ZR364XX_READ_IDLE;
701 /* done successfully */
705 static int res_get(struct zr364xx_camera *cam)
708 mutex_lock(&cam->lock);
709 if (cam->resources) {
710 /* no, someone else uses it */
711 mutex_unlock(&cam->lock);
714 /* it's free, grab it */
717 mutex_unlock(&cam->lock);
721 static inline int res_check(struct zr364xx_camera *cam)
723 return cam->resources;
726 static void res_free(struct zr364xx_camera *cam)
728 mutex_lock(&cam->lock);
730 mutex_unlock(&cam->lock);
734 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
735 struct v4l2_capability *cap)
737 struct zr364xx_camera *cam = video_drvdata(file);
739 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
740 strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
741 strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
742 sizeof(cap->bus_info));
743 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
750 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
751 struct v4l2_input *i)
755 strcpy(i->name, DRIVER_DESC " Camera");
756 i->type = V4L2_INPUT_TYPE_CAMERA;
760 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
767 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
775 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
776 struct v4l2_queryctrl *c)
778 struct zr364xx_camera *cam;
782 cam = video_drvdata(file);
785 case V4L2_CID_BRIGHTNESS:
786 c->type = V4L2_CTRL_TYPE_INTEGER;
787 strcpy(c->name, "Brightness");
791 c->default_value = cam->mode.brightness;
800 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
801 struct v4l2_control *c)
803 struct zr364xx_camera *cam;
808 cam = video_drvdata(file);
811 case V4L2_CID_BRIGHTNESS:
812 cam->mode.brightness = c->value;
813 /* hardware brightness */
814 mutex_lock(&cam->lock);
815 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
816 temp = (0x60 << 8) + 127 - cam->mode.brightness;
817 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
818 mutex_unlock(&cam->lock);
827 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
828 struct v4l2_control *c)
830 struct zr364xx_camera *cam;
834 cam = video_drvdata(file);
837 case V4L2_CID_BRIGHTNESS:
838 c->value = cam->mode.brightness;
846 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
847 void *priv, struct v4l2_fmtdesc *f)
851 f->flags = V4L2_FMT_FLAG_COMPRESSED;
852 strcpy(f->description, formats[0].name);
853 f->pixelformat = formats[0].fourcc;
857 static char *decode_fourcc(__u32 pixelformat, char *buf)
859 buf[0] = pixelformat & 0xff;
860 buf[1] = (pixelformat >> 8) & 0xff;
861 buf[2] = (pixelformat >> 16) & 0xff;
862 buf[3] = (pixelformat >> 24) & 0xff;
867 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
868 struct v4l2_format *f)
870 struct zr364xx_camera *cam = video_drvdata(file);
871 char pixelformat_name[5];
876 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
877 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
878 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
882 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
883 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
884 f->fmt.pix.width = 320;
885 f->fmt.pix.height = 240;
888 f->fmt.pix.field = V4L2_FIELD_NONE;
889 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
890 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
891 f->fmt.pix.colorspace = 0;
893 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
894 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
899 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
900 struct v4l2_format *f)
902 struct zr364xx_camera *cam;
906 cam = video_drvdata(file);
908 f->fmt.pix.pixelformat = formats[0].fourcc;
909 f->fmt.pix.field = V4L2_FIELD_NONE;
910 f->fmt.pix.width = cam->width;
911 f->fmt.pix.height = cam->height;
912 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
913 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
914 f->fmt.pix.colorspace = 0;
919 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
920 struct v4l2_format *f)
922 struct zr364xx_camera *cam = video_drvdata(file);
923 struct videobuf_queue *q = &cam->vb_vidq;
924 char pixelformat_name[5];
925 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
931 mutex_lock(&q->vb_lock);
933 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
934 DBG("%s queue busy\n", __func__);
939 if (res_check(cam)) {
940 DBG("%s can't change format after started\n", __func__);
945 cam->width = f->fmt.pix.width;
946 cam->height = f->fmt.pix.height;
947 dev_info(&cam->udev->dev, "%s: %dx%d mode selected\n", __func__,
948 cam->width, cam->height);
949 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
950 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
951 f->fmt.pix.colorspace = 0;
953 cam->vb_vidq.field = f->fmt.pix.field;
954 cam->mode.color = V4L2_PIX_FMT_JPEG;
956 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
958 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
964 m1[2].value = 0xf000 + mode;
965 m2[1].value = 0xf000 + mode;
967 /* special case for METHOD3, the modes are different */
968 if (cam->method == METHOD3) {
971 m2[1].value = 0xf000 + 4;
974 m2[1].value = 0xf000 + 0;
977 m2[1].value = 0xf000 + 1;
982 header2[437] = cam->height / 256;
983 header2[438] = cam->height % 256;
984 header2[439] = cam->width / 256;
985 header2[440] = cam->width % 256;
987 for (i = 0; init[cam->method][i].size != -1; i++) {
989 send_control_msg(cam->udev, 1, init[cam->method][i].value,
990 0, init[cam->method][i].bytes,
991 init[cam->method][i].size);
993 dev_err(&cam->udev->dev,
994 "error during resolution change sequence: %d\n", i);
999 /* Added some delay here, since opening/closing the camera quickly,
1000 * like Ekiga does during its startup, can crash the webcam
1007 mutex_unlock(&q->vb_lock);
1009 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
1010 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
1015 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
1016 struct v4l2_requestbuffers *p)
1019 struct zr364xx_camera *cam = video_drvdata(file);
1020 rc = videobuf_reqbufs(&cam->vb_vidq, p);
1024 static int zr364xx_vidioc_querybuf(struct file *file,
1026 struct v4l2_buffer *p)
1029 struct zr364xx_camera *cam = video_drvdata(file);
1030 rc = videobuf_querybuf(&cam->vb_vidq, p);
1034 static int zr364xx_vidioc_qbuf(struct file *file,
1036 struct v4l2_buffer *p)
1039 struct zr364xx_camera *cam = video_drvdata(file);
1040 _DBG("%s\n", __func__);
1041 rc = videobuf_qbuf(&cam->vb_vidq, p);
1045 static int zr364xx_vidioc_dqbuf(struct file *file,
1047 struct v4l2_buffer *p)
1050 struct zr364xx_camera *cam = video_drvdata(file);
1051 _DBG("%s\n", __func__);
1052 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
1056 static void read_pipe_completion(struct urb *purb)
1058 struct zr364xx_pipeinfo *pipe_info;
1059 struct zr364xx_camera *cam;
1062 pipe_info = purb->context;
1063 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
1064 if (pipe_info == NULL) {
1065 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1069 cam = pipe_info->cam;
1071 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1075 /* if shutting down, do not resubmit, exit immediately */
1076 if (purb->status == -ESHUTDOWN) {
1077 DBG("%s, err shutdown\n", __func__);
1078 pipe_info->err_count++;
1082 if (pipe_info->state == 0) {
1083 DBG("exiting USB pipe\n");
1087 if (purb->actual_length < 0 ||
1088 purb->actual_length > pipe_info->transfer_size) {
1089 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1093 if (purb->status == 0)
1094 zr364xx_read_video_callback(cam, pipe_info, purb);
1096 pipe_info->err_count++;
1097 DBG("%s: failed URB %d\n", __func__, purb->status);
1100 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1103 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1105 pipe_info->transfer_buffer,
1106 pipe_info->transfer_size,
1107 read_pipe_completion, pipe_info);
1109 if (pipe_info->state != 0) {
1110 purb->status = usb_submit_urb(pipe_info->stream_urb,
1114 dev_err(&cam->udev->dev,
1115 "error submitting urb (error=%i)\n",
1118 DBG("read pipe complete state 0\n");
1121 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1125 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1126 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1127 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1129 pipe_info->state = 1;
1130 pipe_info->err_count = 0;
1131 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1132 if (!pipe_info->stream_urb) {
1133 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1136 /* transfer buffer allocated in board_init */
1137 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1139 pipe_info->transfer_buffer,
1140 pipe_info->transfer_size,
1141 read_pipe_completion, pipe_info);
1143 DBG("submitting URB %p\n", pipe_info->stream_urb);
1144 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1146 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1153 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1155 struct zr364xx_pipeinfo *pipe_info;
1158 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1161 DBG("stop read pipe\n");
1162 pipe_info = cam->pipe;
1164 if (pipe_info->state != 0)
1165 pipe_info->state = 0;
1167 if (pipe_info->stream_urb) {
1169 usb_kill_urb(pipe_info->stream_urb);
1170 usb_free_urb(pipe_info->stream_urb);
1171 pipe_info->stream_urb = NULL;
1177 /* starts acquisition process */
1178 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1182 DBG("start acquire\n");
1184 cam->last_frame = -1;
1186 for (j = 0; j < FRAMES; j++) {
1187 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1188 cam->buffer.frame[j].cur_size = 0;
1194 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1200 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1201 enum v4l2_buf_type type)
1203 struct zr364xx_camera *cam = video_drvdata(file);
1207 DBG("%s\n", __func__);
1209 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1210 dev_err(&cam->udev->dev, "invalid fh type0\n");
1213 if (cam->type != type) {
1214 dev_err(&cam->udev->dev, "invalid fh type1\n");
1218 if (!res_get(cam)) {
1219 dev_err(&cam->udev->dev, "stream busy\n");
1223 cam->last_frame = -1;
1225 cam->frame_count = 0;
1226 for (j = 0; j < FRAMES; j++) {
1227 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1228 cam->buffer.frame[j].cur_size = 0;
1230 res = videobuf_streamon(&cam->vb_vidq);
1232 zr364xx_start_acquire(cam);
1239 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1240 enum v4l2_buf_type type)
1243 struct zr364xx_camera *cam = video_drvdata(file);
1245 DBG("%s\n", __func__);
1246 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1247 dev_err(&cam->udev->dev, "invalid fh type0\n");
1250 if (cam->type != type) {
1251 dev_err(&cam->udev->dev, "invalid fh type1\n");
1254 zr364xx_stop_acquire(cam);
1255 res = videobuf_streamoff(&cam->vb_vidq);
1263 /* open the camera */
1264 static int zr364xx_open(struct file *file)
1266 struct video_device *vdev = video_devdata(file);
1267 struct zr364xx_camera *cam = video_drvdata(file);
1268 struct usb_device *udev = cam->udev;
1271 DBG("%s\n", __func__);
1273 mutex_lock(&cam->open_lock);
1280 for (i = 0; init[cam->method][i].size != -1; i++) {
1282 send_control_msg(udev, 1, init[cam->method][i].value,
1283 0, init[cam->method][i].bytes,
1284 init[cam->method][i].size);
1286 dev_err(&cam->udev->dev,
1287 "error during open sequence: %d\n", i);
1294 file->private_data = vdev;
1295 cam->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1298 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1302 sizeof(struct zr364xx_buffer), cam, NULL);
1304 /* Added some delay here, since opening/closing the camera quickly,
1305 * like Ekiga does during its startup, can crash the webcam
1311 mutex_unlock(&cam->open_lock);
1312 DBG("%s: %d\n", __func__, err);
1316 static void zr364xx_destroy(struct zr364xx_camera *cam)
1321 printk(KERN_ERR KBUILD_MODNAME ", %s: no device\n", __func__);
1324 mutex_lock(&cam->open_lock);
1326 video_unregister_device(cam->vdev);
1329 /* stops the read pipe if it is running */
1331 zr364xx_stop_acquire(cam);
1333 zr364xx_stop_readpipe(cam);
1335 /* release sys buffers */
1336 for (i = 0; i < FRAMES; i++) {
1337 if (cam->buffer.frame[i].lpvbits) {
1338 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1339 vfree(cam->buffer.frame[i].lpvbits);
1341 cam->buffer.frame[i].lpvbits = NULL;
1344 /* release transfer buffer */
1345 kfree(cam->pipe->transfer_buffer);
1346 cam->pipe->transfer_buffer = NULL;
1347 mutex_unlock(&cam->open_lock);
1352 /* release the camera */
1353 static int zr364xx_release(struct file *file)
1355 struct zr364xx_camera *cam;
1356 struct usb_device *udev;
1359 DBG("%s\n", __func__);
1360 cam = video_drvdata(file);
1365 mutex_lock(&cam->open_lock);
1368 /* turn off stream */
1369 if (res_check(cam)) {
1371 zr364xx_stop_acquire(cam);
1372 videobuf_streamoff(&cam->vb_vidq);
1377 file->private_data = NULL;
1379 for (i = 0; i < 2; i++) {
1381 send_control_msg(udev, 1, init[cam->method][i].value,
1382 0, init[cam->method][i].bytes,
1383 init[cam->method][i].size);
1385 dev_err(&udev->dev, "error during release sequence\n");
1390 /* Added some delay here, since opening/closing the camera quickly,
1391 * like Ekiga does during its startup, can crash the webcam
1397 mutex_unlock(&cam->open_lock);
1403 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1405 struct zr364xx_camera *cam = video_drvdata(file);
1409 DBG("%s: cam == NULL\n", __func__);
1412 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1414 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1416 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1417 (unsigned long)vma->vm_start,
1418 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1422 static unsigned int zr364xx_poll(struct file *file,
1423 struct poll_table_struct *wait)
1425 struct zr364xx_camera *cam = video_drvdata(file);
1426 struct videobuf_queue *q = &cam->vb_vidq;
1427 _DBG("%s\n", __func__);
1429 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1432 return videobuf_poll_stream(file, q, wait);
1435 static const struct v4l2_file_operations zr364xx_fops = {
1436 .owner = THIS_MODULE,
1437 .open = zr364xx_open,
1438 .release = zr364xx_release,
1439 .read = zr364xx_read,
1440 .mmap = zr364xx_mmap,
1441 .ioctl = video_ioctl2,
1442 .poll = zr364xx_poll,
1445 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1446 .vidioc_querycap = zr364xx_vidioc_querycap,
1447 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1448 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1449 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1450 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
1451 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1452 .vidioc_g_input = zr364xx_vidioc_g_input,
1453 .vidioc_s_input = zr364xx_vidioc_s_input,
1454 .vidioc_streamon = zr364xx_vidioc_streamon,
1455 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1456 .vidioc_queryctrl = zr364xx_vidioc_queryctrl,
1457 .vidioc_g_ctrl = zr364xx_vidioc_g_ctrl,
1458 .vidioc_s_ctrl = zr364xx_vidioc_s_ctrl,
1459 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1460 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1461 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1462 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
1465 static struct video_device zr364xx_template = {
1466 .name = DRIVER_DESC,
1467 .fops = &zr364xx_fops,
1468 .ioctl_ops = &zr364xx_ioctl_ops,
1469 .release = video_device_release,
1474 /*******************/
1475 /* USB integration */
1476 /*******************/
1477 static int zr364xx_board_init(struct zr364xx_camera *cam)
1479 struct zr364xx_pipeinfo *pipe = cam->pipe;
1482 DBG("board init: %p\n", cam);
1483 memset(pipe, 0, sizeof(*pipe));
1485 pipe->transfer_size = BUFFER_SIZE;
1487 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1489 if (pipe->transfer_buffer == NULL) {
1490 DBG("out of memory!\n");
1495 cam->frame_count = 0;
1497 /*** start create system buffers ***/
1498 for (i = 0; i < FRAMES; i++) {
1499 /* always allocate maximum size for system buffers */
1500 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1502 DBG("valloc %p, idx %lu, pdata %p\n",
1503 &cam->buffer.frame[i], i,
1504 cam->buffer.frame[i].lpvbits);
1505 if (cam->buffer.frame[i].lpvbits == NULL) {
1506 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1507 "Using less frames\n");
1513 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1514 kfree(cam->pipe->transfer_buffer);
1515 cam->pipe->transfer_buffer = NULL;
1518 cam->buffer.dwFrames = i;
1520 /* make sure internal states are set */
1521 for (i = 0; i < FRAMES; i++) {
1522 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1523 cam->buffer.frame[i].cur_size = 0;
1527 cam->last_frame = -1;
1528 /*** end create system buffers ***/
1530 /* start read pipe */
1531 zr364xx_start_readpipe(cam);
1532 DBG(": board initialized\n");
1536 static int zr364xx_probe(struct usb_interface *intf,
1537 const struct usb_device_id *id)
1539 struct usb_device *udev = interface_to_usbdev(intf);
1540 struct zr364xx_camera *cam = NULL;
1541 struct usb_host_interface *iface_desc;
1542 struct usb_endpoint_descriptor *endpoint;
1546 DBG("probing...\n");
1548 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1549 dev_info(&intf->dev, "model %04x:%04x detected\n",
1550 le16_to_cpu(udev->descriptor.idVendor),
1551 le16_to_cpu(udev->descriptor.idProduct));
1553 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1555 dev_err(&udev->dev, "cam: out of memory !\n");
1558 /* save the init method used by this camera */
1559 cam->method = id->driver_info;
1561 cam->vdev = video_device_alloc();
1562 if (cam->vdev == NULL) {
1563 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
1568 memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
1569 cam->vdev->parent = &intf->dev;
1570 video_set_drvdata(cam->vdev, cam);
1572 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1578 dev_info(&udev->dev, "160x120 mode selected\n");
1583 dev_info(&udev->dev, "640x480 mode selected\n");
1588 dev_info(&udev->dev, "320x240 mode selected\n");
1595 m1[2].value = 0xf000 + mode;
1596 m2[1].value = 0xf000 + mode;
1598 /* special case for METHOD3, the modes are different */
1599 if (cam->method == METHOD3) {
1602 m2[1].value = 0xf000 + 4;
1605 m2[1].value = 0xf000 + 0;
1608 m2[1].value = 0xf000 + 1;
1613 header2[437] = cam->height / 256;
1614 header2[438] = cam->height % 256;
1615 header2[439] = cam->width / 256;
1616 header2[440] = cam->width % 256;
1620 cam->mode.brightness = 64;
1621 mutex_init(&cam->lock);
1622 mutex_init(&cam->open_lock);
1624 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1626 /* set up the endpoint information */
1627 iface_desc = intf->cur_altsetting;
1628 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1629 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1630 endpoint = &iface_desc->endpoint[i].desc;
1631 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1632 /* we found the bulk in endpoint */
1633 cam->read_endpoint = endpoint->bEndpointAddress;
1637 if (!cam->read_endpoint) {
1638 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1639 video_device_release(cam->vdev);
1646 INIT_LIST_HEAD(&cam->vidq.active);
1647 cam->vidq.cam = cam;
1648 err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
1650 dev_err(&udev->dev, "video_register_device failed\n");
1651 video_device_release(cam->vdev);
1657 usb_set_intfdata(intf, cam);
1659 /* load zr364xx board specific */
1660 err = zr364xx_board_init(cam);
1662 spin_lock_init(&cam->slock);
1666 spin_lock_init(&cam->slock);
1668 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1669 video_device_node_name(cam->vdev));
1674 static void zr364xx_disconnect(struct usb_interface *intf)
1676 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1677 videobuf_mmap_free(&cam->vb_vidq);
1678 usb_set_intfdata(intf, NULL);
1679 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1680 zr364xx_destroy(cam);
1685 /**********************/
1686 /* Module integration */
1687 /**********************/
1689 static struct usb_driver zr364xx_driver = {
1691 .probe = zr364xx_probe,
1692 .disconnect = zr364xx_disconnect,
1693 .id_table = device_table
1696 module_usb_driver(zr364xx_driver);
1698 MODULE_AUTHOR(DRIVER_AUTHOR);
1699 MODULE_DESCRIPTION(DRIVER_DESC);
1700 MODULE_LICENSE("GPL");
1701 MODULE_VERSION(DRIVER_VERSION);