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.
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/usb.h>
30 #include <linux/vmalloc.h>
31 #include <linux/slab.h>
32 #include <linux/proc_fs.h>
33 #include <linux/highmem.h>
34 #include <media/v4l2-common.h>
35 #include <media/v4l2-ioctl.h>
36 #include <media/v4l2-device.h>
37 #include <media/v4l2-ctrls.h>
38 #include <media/v4l2-fh.h>
39 #include <media/v4l2-event.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 /* frame structure */
124 struct zr364xx_framei
{
125 unsigned long ulState
; /* ulState:ZR364XX_READ_IDLE,
126 ZR364XX_READ_FRAME */
127 void *lpvbits
; /* image data */
128 unsigned long cur_size
; /* current data copied to it */
131 /* image buffer structure */
132 struct zr364xx_bufferi
{
133 unsigned long dwFrames
; /* number of frames in buffer */
134 struct zr364xx_framei frame
[FRAMES
]; /* array of FRAME structures */
137 struct zr364xx_dmaqueue
{
138 struct list_head active
;
139 struct zr364xx_camera
*cam
;
142 struct zr364xx_pipeinfo
{
147 void *cam
; /* back pointer to zr364xx_camera struct */
159 static const struct zr364xx_fmt formats
[] = {
162 .fourcc
= V4L2_PIX_FMT_JPEG
,
168 struct zr364xx_camera
{
169 struct usb_device
*udev
; /* save off the usb device pointer */
170 struct usb_interface
*interface
;/* the interface for this device */
171 struct v4l2_device v4l2_dev
;
172 struct v4l2_ctrl_handler ctrl_handler
;
173 struct video_device vdev
; /* v4l video device */
174 struct v4l2_fh
*owner
; /* owns the streaming */
176 struct zr364xx_bufferi buffer
;
184 struct zr364xx_dmaqueue vidq
;
187 unsigned long frame_count
;
189 struct zr364xx_pipeinfo pipe
[1];
193 const struct zr364xx_fmt
*fmt
;
194 struct videobuf_queue vb_vidq
;
198 /* buffer for one video frame */
199 struct zr364xx_buffer
{
200 /* common v4l buffer stuff -- must be first */
201 struct videobuf_buffer vb
;
202 const struct zr364xx_fmt
*fmt
;
205 /* function used to send initialisation commands to the camera */
206 static int send_control_msg(struct usb_device
*udev
, u8 request
, u16 value
,
207 u16 index
, unsigned char *cp
, u16 size
)
211 unsigned char *transfer_buffer
= kmalloc(size
, GFP_KERNEL
);
212 if (!transfer_buffer
) {
213 dev_err(&udev
->dev
, "kmalloc(%d) failed\n", size
);
217 memcpy(transfer_buffer
, cp
, size
);
219 status
= usb_control_msg(udev
,
220 usb_sndctrlpipe(udev
, 0),
222 USB_DIR_OUT
| USB_TYPE_VENDOR
|
223 USB_RECIP_DEVICE
, value
, index
,
224 transfer_buffer
, size
, CTRL_TIMEOUT
);
226 kfree(transfer_buffer
);
231 /* Control messages sent to the camera to initialize it
232 * and launch the capture */
236 unsigned char *bytes
;
240 static unsigned char m0d1
[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
241 static unsigned char m0d2
[] = { 0, 0, 0, 0, 0, 0 };
242 static unsigned char m0d3
[] = { 0, 0 };
243 static message m0
[] = {
246 {0x3370, sizeof(m0d1
), m0d1
},
249 {0x2610, sizeof(m0d2
), m0d2
},
254 {0x9a01, sizeof(m0d3
), m0d3
},
259 static unsigned char m1d1
[] = { 0xff, 0xff };
260 static unsigned char m1d2
[] = { 0x00, 0x00 };
261 static message m1
[] = {
269 {0x2502, sizeof(m1d1
), m1d1
},
274 {0x9a01, sizeof(m1d2
), m1d2
},
279 static unsigned char m2d1
[] = { 0xff, 0xff };
280 static message m2
[] = {
287 {0x2502, sizeof(m2d1
), m2d1
},
293 static message
*init
[4] = { m0
, m1
, m2
, m2
};
296 /* JPEG static data in header (Huffman table, etc) */
297 static unsigned char header1
[] = {
300 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
301 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
303 0xFF, 0xDB, 0x00, 0x84
305 static unsigned char header2
[] = {
306 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
307 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
309 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
310 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
311 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
312 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
313 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
314 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
315 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
316 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
317 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
318 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
319 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
320 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
321 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
322 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
323 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
324 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
325 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
326 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
327 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
328 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
329 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
330 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
331 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
332 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
333 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
334 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
335 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
336 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
337 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
338 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
339 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
340 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
341 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
342 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
343 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
344 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
345 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
346 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
347 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
350 static unsigned char header3
;
352 /* ------------------------------------------------------------------
354 ------------------------------------------------------------------*/
356 static int buffer_setup(struct videobuf_queue
*vq
, unsigned int *count
,
359 struct zr364xx_camera
*cam
= vq
->priv_data
;
361 *size
= cam
->width
* cam
->height
* (cam
->fmt
->depth
>> 3);
364 *count
= ZR364XX_DEF_BUFS
;
366 if (*size
* *count
> ZR364XX_DEF_BUFS
* 1024 * 1024)
367 *count
= (ZR364XX_DEF_BUFS
* 1024 * 1024) / *size
;
372 static void free_buffer(struct videobuf_queue
*vq
, struct zr364xx_buffer
*buf
)
374 _DBG("%s\n", __func__
);
376 BUG_ON(in_interrupt());
378 videobuf_vmalloc_free(&buf
->vb
);
379 buf
->vb
.state
= VIDEOBUF_NEEDS_INIT
;
382 static int buffer_prepare(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
,
383 enum v4l2_field field
)
385 struct zr364xx_camera
*cam
= vq
->priv_data
;
386 struct zr364xx_buffer
*buf
= container_of(vb
, struct zr364xx_buffer
,
390 DBG("%s, field=%d, fmt name = %s\n", __func__
, field
, cam
->fmt
!= NULL
?
391 cam
->fmt
->name
: "");
392 if (cam
->fmt
== NULL
)
395 buf
->vb
.size
= cam
->width
* cam
->height
* (cam
->fmt
->depth
>> 3);
397 if (buf
->vb
.baddr
!= 0 && buf
->vb
.bsize
< buf
->vb
.size
) {
398 DBG("invalid buffer prepare\n");
403 buf
->vb
.width
= cam
->width
;
404 buf
->vb
.height
= cam
->height
;
405 buf
->vb
.field
= field
;
407 if (buf
->vb
.state
== VIDEOBUF_NEEDS_INIT
) {
408 rc
= videobuf_iolock(vq
, &buf
->vb
, NULL
);
413 buf
->vb
.state
= VIDEOBUF_PREPARED
;
416 free_buffer(vq
, buf
);
420 static void buffer_queue(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
)
422 struct zr364xx_buffer
*buf
= container_of(vb
, struct zr364xx_buffer
,
424 struct zr364xx_camera
*cam
= vq
->priv_data
;
426 _DBG("%s\n", __func__
);
428 buf
->vb
.state
= VIDEOBUF_QUEUED
;
429 list_add_tail(&buf
->vb
.queue
, &cam
->vidq
.active
);
432 static void buffer_release(struct videobuf_queue
*vq
,
433 struct videobuf_buffer
*vb
)
435 struct zr364xx_buffer
*buf
= container_of(vb
, struct zr364xx_buffer
,
438 _DBG("%s\n", __func__
);
439 free_buffer(vq
, buf
);
442 static struct videobuf_queue_ops zr364xx_video_qops
= {
443 .buf_setup
= buffer_setup
,
444 .buf_prepare
= buffer_prepare
,
445 .buf_queue
= buffer_queue
,
446 .buf_release
= buffer_release
,
449 /********************/
450 /* V4L2 integration */
451 /********************/
452 static int zr364xx_vidioc_streamon(struct file
*file
, void *priv
,
453 enum v4l2_buf_type type
);
455 static ssize_t
zr364xx_read(struct file
*file
, char __user
*buf
, size_t count
,
458 struct zr364xx_camera
*cam
= video_drvdata(file
);
461 _DBG("%s\n", __func__
);
469 if (mutex_lock_interruptible(&cam
->lock
))
472 err
= zr364xx_vidioc_streamon(file
, file
->private_data
,
473 V4L2_BUF_TYPE_VIDEO_CAPTURE
);
475 DBG("%s: reading %d bytes at pos %d.\n", __func__
,
476 (int) count
, (int) *ppos
);
479 err
= videobuf_read_one(&cam
->vb_vidq
, buf
, count
, ppos
,
480 file
->f_flags
& O_NONBLOCK
);
482 mutex_unlock(&cam
->lock
);
486 /* video buffer vmalloc implementation based partly on VIVI driver which is
487 * Copyright (c) 2006 by
488 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
489 * Ted Walther <ted--a.t--enumera.com>
490 * John Sokol <sokol--a.t--videotechnology.com>
491 * http://v4l.videotechnology.com/
494 static void zr364xx_fillbuff(struct zr364xx_camera
*cam
,
495 struct zr364xx_buffer
*buf
,
500 char *vbuf
= videobuf_to_vmalloc(&buf
->vb
);
501 unsigned long last_frame
;
506 last_frame
= cam
->last_frame
;
507 if (last_frame
!= -1) {
508 tmpbuf
= (const char *)cam
->buffer
.frame
[last_frame
].lpvbits
;
509 switch (buf
->fmt
->fourcc
) {
510 case V4L2_PIX_FMT_JPEG
:
511 buf
->vb
.size
= jpgsize
;
512 memcpy(vbuf
, tmpbuf
, buf
->vb
.size
);
515 printk(KERN_DEBUG KBUILD_MODNAME
": unknown format?\n");
517 cam
->last_frame
= -1;
519 printk(KERN_ERR KBUILD_MODNAME
": =======no frame\n");
522 DBG("%s: Buffer 0x%08lx size= %d\n", __func__
,
523 (unsigned long)vbuf
, pos
);
524 /* tell v4l buffer was filled */
526 buf
->vb
.field_count
= cam
->frame_count
* 2;
527 v4l2_get_timestamp(&buf
->vb
.ts
);
528 buf
->vb
.state
= VIDEOBUF_DONE
;
531 static int zr364xx_got_frame(struct zr364xx_camera
*cam
, int jpgsize
)
533 struct zr364xx_dmaqueue
*dma_q
= &cam
->vidq
;
534 struct zr364xx_buffer
*buf
;
535 unsigned long flags
= 0;
538 DBG("wakeup: %p\n", &dma_q
);
539 spin_lock_irqsave(&cam
->slock
, flags
);
541 if (list_empty(&dma_q
->active
)) {
542 DBG("No active queue to serve\n");
546 buf
= list_entry(dma_q
->active
.next
,
547 struct zr364xx_buffer
, vb
.queue
);
549 if (!waitqueue_active(&buf
->vb
.done
)) {
554 list_del(&buf
->vb
.queue
);
555 v4l2_get_timestamp(&buf
->vb
.ts
);
556 DBG("[%p/%d] wakeup\n", buf
, buf
->vb
.i
);
557 zr364xx_fillbuff(cam
, buf
, jpgsize
);
558 wake_up(&buf
->vb
.done
);
559 DBG("wakeup [buf/i] [%p/%d]\n", buf
, buf
->vb
.i
);
561 spin_unlock_irqrestore(&cam
->slock
, flags
);
565 /* this function moves the usb stream read pipe data
566 * into the system buffers.
567 * returns 0 on success, EAGAIN if more data to process (call this
570 static int zr364xx_read_video_callback(struct zr364xx_camera
*cam
,
571 struct zr364xx_pipeinfo
*pipe_info
,
574 unsigned char *pdest
;
577 struct zr364xx_framei
*frm
;
579 unsigned char *ptr
= NULL
;
581 _DBG("buffer to user\n");
582 idx
= cam
->cur_frame
;
583 frm
= &cam
->buffer
.frame
[idx
];
585 /* swap bytes if camera needs it */
586 if (cam
->method
== METHOD0
) {
587 u16
*buf
= (u16
*)pipe_info
->transfer_buffer
;
588 for (i
= 0; i
< purb
->actual_length
/2; i
++)
592 /* search done. now find out if should be acquiring */
593 if (!cam
->b_acquire
) {
594 /* we found a frame, but this channel is turned off */
595 frm
->ulState
= ZR364XX_READ_IDLE
;
599 psrc
= (u8
*)pipe_info
->transfer_buffer
;
600 ptr
= pdest
= frm
->lpvbits
;
602 if (frm
->ulState
== ZR364XX_READ_IDLE
) {
603 if (purb
->actual_length
< 128) {
604 /* header incomplete */
605 dev_info(&cam
->udev
->dev
,
606 "%s: buffer (%d bytes) too small to hold jpeg header. Discarding.\n",
607 __func__
, purb
->actual_length
);
611 frm
->ulState
= ZR364XX_READ_FRAME
;
614 _DBG("jpeg header, ");
615 memcpy(ptr
, header1
, sizeof(header1
));
616 ptr
+= sizeof(header1
);
618 memcpy(ptr
, &header3
, 1);
620 memcpy(ptr
, psrc
, 64);
623 memcpy(ptr
, &header3
, 1);
625 memcpy(ptr
, psrc
+ 64, 64);
627 memcpy(ptr
, header2
, sizeof(header2
));
628 ptr
+= sizeof(header2
);
629 memcpy(ptr
, psrc
+ 128,
630 purb
->actual_length
- 128);
631 ptr
+= purb
->actual_length
- 128;
632 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
633 psrc
[0], psrc
[1], psrc
[2],
634 psrc
[3], psrc
[4], psrc
[5],
635 psrc
[6], psrc
[7], psrc
[8]);
636 frm
->cur_size
= ptr
- pdest
;
638 if (frm
->cur_size
+ purb
->actual_length
> MAX_FRAME_SIZE
) {
639 dev_info(&cam
->udev
->dev
,
640 "%s: buffer (%d bytes) too small to hold frame data. Discarding frame data.\n",
641 __func__
, MAX_FRAME_SIZE
);
643 pdest
+= frm
->cur_size
;
644 memcpy(pdest
, psrc
, purb
->actual_length
);
645 frm
->cur_size
+= purb
->actual_length
;
648 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
649 purb->actual_length);*/
651 if (purb
->actual_length
< pipe_info
->transfer_size
) {
652 _DBG("****************Buffer[%d]full*************\n", idx
);
653 cam
->last_frame
= cam
->cur_frame
;
655 /* end of system frame ring buffer, start at zero */
656 if (cam
->cur_frame
== cam
->buffer
.dwFrames
)
660 /* go back to find the JPEG EOI marker */
661 ptr
= pdest
= frm
->lpvbits
;
662 ptr
+= frm
->cur_size
- 2;
663 while (ptr
> pdest
) {
664 if (*ptr
== 0xFF && *(ptr
+ 1) == 0xD9
665 && *(ptr
+ 2) == 0xFF)
670 DBG("No EOI marker\n");
672 /* Sometimes there is junk data in the middle of the picture,
673 * we want to skip this bogus frames */
674 while (ptr
> pdest
) {
675 if (*ptr
== 0xFF && *(ptr
+ 1) == 0xFF
676 && *(ptr
+ 2) == 0xFF)
681 DBG("Bogus frame ? %d\n", ++(cam
->nb
));
682 } else if (cam
->b_acquire
) {
683 /* we skip the 2 first frames which are usually buggy */
687 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
689 pdest
[0], pdest
[1], pdest
[2], pdest
[3],
690 pdest
[4], pdest
[5], pdest
[6], pdest
[7]);
692 zr364xx_got_frame(cam
, frm
->cur_size
);
696 frm
->ulState
= ZR364XX_READ_IDLE
;
699 /* done successfully */
703 static int zr364xx_vidioc_querycap(struct file
*file
, void *priv
,
704 struct v4l2_capability
*cap
)
706 struct zr364xx_camera
*cam
= video_drvdata(file
);
708 strlcpy(cap
->driver
, DRIVER_DESC
, sizeof(cap
->driver
));
709 strlcpy(cap
->card
, cam
->udev
->product
, sizeof(cap
->card
));
710 strlcpy(cap
->bus_info
, dev_name(&cam
->udev
->dev
),
711 sizeof(cap
->bus_info
));
712 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
|
715 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
720 static int zr364xx_vidioc_enum_input(struct file
*file
, void *priv
,
721 struct v4l2_input
*i
)
725 strcpy(i
->name
, DRIVER_DESC
" Camera");
726 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
730 static int zr364xx_vidioc_g_input(struct file
*file
, void *priv
,
737 static int zr364xx_vidioc_s_input(struct file
*file
, void *priv
,
745 static int zr364xx_s_ctrl(struct v4l2_ctrl
*ctrl
)
747 struct zr364xx_camera
*cam
=
748 container_of(ctrl
->handler
, struct zr364xx_camera
, ctrl_handler
);
752 case V4L2_CID_BRIGHTNESS
:
753 /* hardware brightness */
754 send_control_msg(cam
->udev
, 1, 0x2001, 0, NULL
, 0);
755 temp
= (0x60 << 8) + 127 - ctrl
->val
;
756 send_control_msg(cam
->udev
, 1, temp
, 0, NULL
, 0);
765 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file
*file
,
766 void *priv
, struct v4l2_fmtdesc
*f
)
770 f
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
771 strcpy(f
->description
, formats
[0].name
);
772 f
->pixelformat
= formats
[0].fourcc
;
776 static char *decode_fourcc(__u32 pixelformat
, char *buf
)
778 buf
[0] = pixelformat
& 0xff;
779 buf
[1] = (pixelformat
>> 8) & 0xff;
780 buf
[2] = (pixelformat
>> 16) & 0xff;
781 buf
[3] = (pixelformat
>> 24) & 0xff;
786 static int zr364xx_vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
787 struct v4l2_format
*f
)
789 struct zr364xx_camera
*cam
= video_drvdata(file
);
790 char pixelformat_name
[5];
795 if (f
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_JPEG
) {
796 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__
,
797 decode_fourcc(f
->fmt
.pix
.pixelformat
, pixelformat_name
));
801 if (!(f
->fmt
.pix
.width
== 160 && f
->fmt
.pix
.height
== 120) &&
802 !(f
->fmt
.pix
.width
== 640 && f
->fmt
.pix
.height
== 480)) {
803 f
->fmt
.pix
.width
= 320;
804 f
->fmt
.pix
.height
= 240;
807 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
808 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
809 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
810 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
811 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__
,
812 decode_fourcc(f
->fmt
.pix
.pixelformat
, pixelformat_name
),
817 static int zr364xx_vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
818 struct v4l2_format
*f
)
820 struct zr364xx_camera
*cam
;
824 cam
= video_drvdata(file
);
826 f
->fmt
.pix
.pixelformat
= formats
[0].fourcc
;
827 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
828 f
->fmt
.pix
.width
= cam
->width
;
829 f
->fmt
.pix
.height
= cam
->height
;
830 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
831 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
832 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
836 static int zr364xx_vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
837 struct v4l2_format
*f
)
839 struct zr364xx_camera
*cam
= video_drvdata(file
);
840 struct videobuf_queue
*q
= &cam
->vb_vidq
;
841 char pixelformat_name
[5];
842 int ret
= zr364xx_vidioc_try_fmt_vid_cap(file
, cam
, f
);
848 mutex_lock(&q
->vb_lock
);
850 if (videobuf_queue_is_busy(&cam
->vb_vidq
)) {
851 DBG("%s queue busy\n", __func__
);
857 DBG("%s can't change format after started\n", __func__
);
862 cam
->width
= f
->fmt
.pix
.width
;
863 cam
->height
= f
->fmt
.pix
.height
;
864 DBG("%s: %dx%d mode selected\n", __func__
,
865 cam
->width
, cam
->height
);
866 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
867 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
868 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
869 cam
->vb_vidq
.field
= f
->fmt
.pix
.field
;
871 if (f
->fmt
.pix
.width
== 160 && f
->fmt
.pix
.height
== 120)
873 else if (f
->fmt
.pix
.width
== 640 && f
->fmt
.pix
.height
== 480)
879 m1
[2].value
= 0xf000 + mode
;
880 m2
[1].value
= 0xf000 + mode
;
882 /* special case for METHOD3, the modes are different */
883 if (cam
->method
== METHOD3
) {
886 m2
[1].value
= 0xf000 + 4;
889 m2
[1].value
= 0xf000 + 0;
892 m2
[1].value
= 0xf000 + 1;
897 header2
[437] = cam
->height
/ 256;
898 header2
[438] = cam
->height
% 256;
899 header2
[439] = cam
->width
/ 256;
900 header2
[440] = cam
->width
% 256;
902 for (i
= 0; init
[cam
->method
][i
].size
!= -1; i
++) {
904 send_control_msg(cam
->udev
, 1, init
[cam
->method
][i
].value
,
905 0, init
[cam
->method
][i
].bytes
,
906 init
[cam
->method
][i
].size
);
908 dev_err(&cam
->udev
->dev
,
909 "error during resolution change sequence: %d\n", i
);
914 /* Added some delay here, since opening/closing the camera quickly,
915 * like Ekiga does during its startup, can crash the webcam
922 mutex_unlock(&q
->vb_lock
);
924 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__
,
925 decode_fourcc(f
->fmt
.pix
.pixelformat
, pixelformat_name
),
930 static int zr364xx_vidioc_reqbufs(struct file
*file
, void *priv
,
931 struct v4l2_requestbuffers
*p
)
933 struct zr364xx_camera
*cam
= video_drvdata(file
);
935 if (cam
->owner
&& cam
->owner
!= priv
)
937 return videobuf_reqbufs(&cam
->vb_vidq
, p
);
940 static int zr364xx_vidioc_querybuf(struct file
*file
,
942 struct v4l2_buffer
*p
)
945 struct zr364xx_camera
*cam
= video_drvdata(file
);
946 rc
= videobuf_querybuf(&cam
->vb_vidq
, p
);
950 static int zr364xx_vidioc_qbuf(struct file
*file
,
952 struct v4l2_buffer
*p
)
955 struct zr364xx_camera
*cam
= video_drvdata(file
);
956 _DBG("%s\n", __func__
);
957 if (cam
->owner
&& cam
->owner
!= priv
)
959 rc
= videobuf_qbuf(&cam
->vb_vidq
, p
);
963 static int zr364xx_vidioc_dqbuf(struct file
*file
,
965 struct v4l2_buffer
*p
)
968 struct zr364xx_camera
*cam
= video_drvdata(file
);
969 _DBG("%s\n", __func__
);
970 if (cam
->owner
&& cam
->owner
!= priv
)
972 rc
= videobuf_dqbuf(&cam
->vb_vidq
, p
, file
->f_flags
& O_NONBLOCK
);
976 static void read_pipe_completion(struct urb
*purb
)
978 struct zr364xx_pipeinfo
*pipe_info
;
979 struct zr364xx_camera
*cam
;
982 pipe_info
= purb
->context
;
983 _DBG("%s %p, status %d\n", __func__
, purb
, purb
->status
);
984 if (pipe_info
== NULL
) {
985 printk(KERN_ERR KBUILD_MODNAME
": no context!\n");
989 cam
= pipe_info
->cam
;
991 printk(KERN_ERR KBUILD_MODNAME
": no context!\n");
995 /* if shutting down, do not resubmit, exit immediately */
996 if (purb
->status
== -ESHUTDOWN
) {
997 DBG("%s, err shutdown\n", __func__
);
998 pipe_info
->err_count
++;
1002 if (pipe_info
->state
== 0) {
1003 DBG("exiting USB pipe\n");
1007 if (purb
->actual_length
> pipe_info
->transfer_size
) {
1008 dev_err(&cam
->udev
->dev
, "wrong number of bytes\n");
1012 if (purb
->status
== 0)
1013 zr364xx_read_video_callback(cam
, pipe_info
, purb
);
1015 pipe_info
->err_count
++;
1016 DBG("%s: failed URB %d\n", __func__
, purb
->status
);
1019 pipe
= usb_rcvbulkpipe(cam
->udev
, cam
->read_endpoint
);
1022 usb_fill_bulk_urb(pipe_info
->stream_urb
, cam
->udev
,
1024 pipe_info
->transfer_buffer
,
1025 pipe_info
->transfer_size
,
1026 read_pipe_completion
, pipe_info
);
1028 if (pipe_info
->state
!= 0) {
1029 purb
->status
= usb_submit_urb(pipe_info
->stream_urb
,
1033 dev_err(&cam
->udev
->dev
,
1034 "error submitting urb (error=%i)\n",
1037 DBG("read pipe complete state 0\n");
1040 static int zr364xx_start_readpipe(struct zr364xx_camera
*cam
)
1044 struct zr364xx_pipeinfo
*pipe_info
= cam
->pipe
;
1045 pipe
= usb_rcvbulkpipe(cam
->udev
, cam
->read_endpoint
);
1046 DBG("%s: start pipe IN x%x\n", __func__
, cam
->read_endpoint
);
1048 pipe_info
->state
= 1;
1049 pipe_info
->err_count
= 0;
1050 pipe_info
->stream_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1051 if (!pipe_info
->stream_urb
)
1053 /* transfer buffer allocated in board_init */
1054 usb_fill_bulk_urb(pipe_info
->stream_urb
, cam
->udev
,
1056 pipe_info
->transfer_buffer
,
1057 pipe_info
->transfer_size
,
1058 read_pipe_completion
, pipe_info
);
1060 DBG("submitting URB %p\n", pipe_info
->stream_urb
);
1061 retval
= usb_submit_urb(pipe_info
->stream_urb
, GFP_KERNEL
);
1063 printk(KERN_ERR KBUILD_MODNAME
": start read pipe failed\n");
1070 static void zr364xx_stop_readpipe(struct zr364xx_camera
*cam
)
1072 struct zr364xx_pipeinfo
*pipe_info
;
1075 printk(KERN_ERR KBUILD_MODNAME
": invalid device\n");
1078 DBG("stop read pipe\n");
1079 pipe_info
= cam
->pipe
;
1081 if (pipe_info
->state
!= 0)
1082 pipe_info
->state
= 0;
1084 if (pipe_info
->stream_urb
) {
1086 usb_kill_urb(pipe_info
->stream_urb
);
1087 usb_free_urb(pipe_info
->stream_urb
);
1088 pipe_info
->stream_urb
= NULL
;
1094 /* starts acquisition process */
1095 static int zr364xx_start_acquire(struct zr364xx_camera
*cam
)
1099 DBG("start acquire\n");
1101 cam
->last_frame
= -1;
1103 for (j
= 0; j
< FRAMES
; j
++) {
1104 cam
->buffer
.frame
[j
].ulState
= ZR364XX_READ_IDLE
;
1105 cam
->buffer
.frame
[j
].cur_size
= 0;
1111 static inline int zr364xx_stop_acquire(struct zr364xx_camera
*cam
)
1117 static int zr364xx_prepare(struct zr364xx_camera
*cam
)
1122 for (i
= 0; init
[cam
->method
][i
].size
!= -1; i
++) {
1123 res
= send_control_msg(cam
->udev
, 1, init
[cam
->method
][i
].value
,
1124 0, init
[cam
->method
][i
].bytes
,
1125 init
[cam
->method
][i
].size
);
1127 dev_err(&cam
->udev
->dev
,
1128 "error during open sequence: %d\n", i
);
1134 cam
->last_frame
= -1;
1136 cam
->frame_count
= 0;
1137 for (j
= 0; j
< FRAMES
; j
++) {
1138 cam
->buffer
.frame
[j
].ulState
= ZR364XX_READ_IDLE
;
1139 cam
->buffer
.frame
[j
].cur_size
= 0;
1141 v4l2_ctrl_handler_setup(&cam
->ctrl_handler
);
1145 static int zr364xx_vidioc_streamon(struct file
*file
, void *priv
,
1146 enum v4l2_buf_type type
)
1148 struct zr364xx_camera
*cam
= video_drvdata(file
);
1151 DBG("%s\n", __func__
);
1153 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1156 if (cam
->owner
&& cam
->owner
!= priv
)
1159 res
= zr364xx_prepare(cam
);
1162 res
= videobuf_streamon(&cam
->vb_vidq
);
1164 zr364xx_start_acquire(cam
);
1165 cam
->owner
= file
->private_data
;
1170 static int zr364xx_vidioc_streamoff(struct file
*file
, void *priv
,
1171 enum v4l2_buf_type type
)
1173 struct zr364xx_camera
*cam
= video_drvdata(file
);
1175 DBG("%s\n", __func__
);
1176 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1178 if (cam
->owner
&& cam
->owner
!= priv
)
1180 zr364xx_stop_acquire(cam
);
1181 return videobuf_streamoff(&cam
->vb_vidq
);
1185 /* open the camera */
1186 static int zr364xx_open(struct file
*file
)
1188 struct zr364xx_camera
*cam
= video_drvdata(file
);
1191 DBG("%s\n", __func__
);
1193 if (mutex_lock_interruptible(&cam
->lock
))
1194 return -ERESTARTSYS
;
1196 err
= v4l2_fh_open(file
);
1200 /* Added some delay here, since opening/closing the camera quickly,
1201 * like Ekiga does during its startup, can crash the webcam
1207 mutex_unlock(&cam
->lock
);
1208 DBG("%s: %d\n", __func__
, err
);
1212 static void zr364xx_release(struct v4l2_device
*v4l2_dev
)
1214 struct zr364xx_camera
*cam
=
1215 container_of(v4l2_dev
, struct zr364xx_camera
, v4l2_dev
);
1218 v4l2_device_unregister(&cam
->v4l2_dev
);
1220 videobuf_mmap_free(&cam
->vb_vidq
);
1222 /* release sys buffers */
1223 for (i
= 0; i
< FRAMES
; i
++) {
1224 if (cam
->buffer
.frame
[i
].lpvbits
) {
1225 DBG("vfree %p\n", cam
->buffer
.frame
[i
].lpvbits
);
1226 vfree(cam
->buffer
.frame
[i
].lpvbits
);
1228 cam
->buffer
.frame
[i
].lpvbits
= NULL
;
1231 v4l2_ctrl_handler_free(&cam
->ctrl_handler
);
1232 /* release transfer buffer */
1233 kfree(cam
->pipe
->transfer_buffer
);
1237 /* release the camera */
1238 static int zr364xx_close(struct file
*file
)
1240 struct zr364xx_camera
*cam
;
1241 struct usb_device
*udev
;
1244 DBG("%s\n", __func__
);
1245 cam
= video_drvdata(file
);
1247 mutex_lock(&cam
->lock
);
1250 if (file
->private_data
== cam
->owner
) {
1251 /* turn off stream */
1253 zr364xx_stop_acquire(cam
);
1254 videobuf_streamoff(&cam
->vb_vidq
);
1256 for (i
= 0; i
< 2; i
++) {
1257 send_control_msg(udev
, 1, init
[cam
->method
][i
].value
,
1258 0, init
[cam
->method
][i
].bytes
,
1259 init
[cam
->method
][i
].size
);
1264 /* Added some delay here, since opening/closing the camera quickly,
1265 * like Ekiga does during its startup, can crash the webcam
1268 mutex_unlock(&cam
->lock
);
1269 return v4l2_fh_release(file
);
1273 static int zr364xx_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1275 struct zr364xx_camera
*cam
= video_drvdata(file
);
1279 DBG("%s: cam == NULL\n", __func__
);
1282 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma
);
1284 ret
= videobuf_mmap_mapper(&cam
->vb_vidq
, vma
);
1286 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1287 (unsigned long)vma
->vm_start
,
1288 (unsigned long)vma
->vm_end
- (unsigned long)vma
->vm_start
, ret
);
1292 static unsigned int zr364xx_poll(struct file
*file
,
1293 struct poll_table_struct
*wait
)
1295 struct zr364xx_camera
*cam
= video_drvdata(file
);
1296 struct videobuf_queue
*q
= &cam
->vb_vidq
;
1297 unsigned res
= v4l2_ctrl_poll(file
, wait
);
1299 _DBG("%s\n", __func__
);
1301 return res
| videobuf_poll_stream(file
, q
, wait
);
1304 static const struct v4l2_ctrl_ops zr364xx_ctrl_ops
= {
1305 .s_ctrl
= zr364xx_s_ctrl
,
1308 static const struct v4l2_file_operations zr364xx_fops
= {
1309 .owner
= THIS_MODULE
,
1310 .open
= zr364xx_open
,
1311 .release
= zr364xx_close
,
1312 .read
= zr364xx_read
,
1313 .mmap
= zr364xx_mmap
,
1314 .unlocked_ioctl
= video_ioctl2
,
1315 .poll
= zr364xx_poll
,
1318 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops
= {
1319 .vidioc_querycap
= zr364xx_vidioc_querycap
,
1320 .vidioc_enum_fmt_vid_cap
= zr364xx_vidioc_enum_fmt_vid_cap
,
1321 .vidioc_try_fmt_vid_cap
= zr364xx_vidioc_try_fmt_vid_cap
,
1322 .vidioc_s_fmt_vid_cap
= zr364xx_vidioc_s_fmt_vid_cap
,
1323 .vidioc_g_fmt_vid_cap
= zr364xx_vidioc_g_fmt_vid_cap
,
1324 .vidioc_enum_input
= zr364xx_vidioc_enum_input
,
1325 .vidioc_g_input
= zr364xx_vidioc_g_input
,
1326 .vidioc_s_input
= zr364xx_vidioc_s_input
,
1327 .vidioc_streamon
= zr364xx_vidioc_streamon
,
1328 .vidioc_streamoff
= zr364xx_vidioc_streamoff
,
1329 .vidioc_reqbufs
= zr364xx_vidioc_reqbufs
,
1330 .vidioc_querybuf
= zr364xx_vidioc_querybuf
,
1331 .vidioc_qbuf
= zr364xx_vidioc_qbuf
,
1332 .vidioc_dqbuf
= zr364xx_vidioc_dqbuf
,
1333 .vidioc_log_status
= v4l2_ctrl_log_status
,
1334 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1335 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1338 static struct video_device zr364xx_template
= {
1339 .name
= DRIVER_DESC
,
1340 .fops
= &zr364xx_fops
,
1341 .ioctl_ops
= &zr364xx_ioctl_ops
,
1342 .release
= video_device_release_empty
,
1347 /*******************/
1348 /* USB integration */
1349 /*******************/
1350 static int zr364xx_board_init(struct zr364xx_camera
*cam
)
1352 struct zr364xx_pipeinfo
*pipe
= cam
->pipe
;
1355 DBG("board init: %p\n", cam
);
1356 memset(pipe
, 0, sizeof(*pipe
));
1358 pipe
->transfer_size
= BUFFER_SIZE
;
1360 pipe
->transfer_buffer
= kzalloc(pipe
->transfer_size
,
1362 if (pipe
->transfer_buffer
== NULL
) {
1363 DBG("out of memory!\n");
1368 cam
->frame_count
= 0;
1370 /*** start create system buffers ***/
1371 for (i
= 0; i
< FRAMES
; i
++) {
1372 /* always allocate maximum size for system buffers */
1373 cam
->buffer
.frame
[i
].lpvbits
= vmalloc(MAX_FRAME_SIZE
);
1375 DBG("valloc %p, idx %lu, pdata %p\n",
1376 &cam
->buffer
.frame
[i
], i
,
1377 cam
->buffer
.frame
[i
].lpvbits
);
1378 if (cam
->buffer
.frame
[i
].lpvbits
== NULL
) {
1379 printk(KERN_INFO KBUILD_MODNAME
": out of memory. Using less frames\n");
1385 printk(KERN_INFO KBUILD_MODNAME
": out of memory. Aborting\n");
1386 kfree(cam
->pipe
->transfer_buffer
);
1387 cam
->pipe
->transfer_buffer
= NULL
;
1390 cam
->buffer
.dwFrames
= i
;
1392 /* make sure internal states are set */
1393 for (i
= 0; i
< FRAMES
; i
++) {
1394 cam
->buffer
.frame
[i
].ulState
= ZR364XX_READ_IDLE
;
1395 cam
->buffer
.frame
[i
].cur_size
= 0;
1399 cam
->last_frame
= -1;
1400 /*** end create system buffers ***/
1402 /* start read pipe */
1403 zr364xx_start_readpipe(cam
);
1404 DBG(": board initialized\n");
1408 static int zr364xx_probe(struct usb_interface
*intf
,
1409 const struct usb_device_id
*id
)
1411 struct usb_device
*udev
= interface_to_usbdev(intf
);
1412 struct zr364xx_camera
*cam
= NULL
;
1413 struct usb_host_interface
*iface_desc
;
1414 struct usb_endpoint_descriptor
*endpoint
;
1415 struct v4l2_ctrl_handler
*hdl
;
1419 DBG("probing...\n");
1421 dev_info(&intf
->dev
, DRIVER_DESC
" compatible webcam plugged\n");
1422 dev_info(&intf
->dev
, "model %04x:%04x detected\n",
1423 le16_to_cpu(udev
->descriptor
.idVendor
),
1424 le16_to_cpu(udev
->descriptor
.idProduct
));
1426 cam
= kzalloc(sizeof(struct zr364xx_camera
), GFP_KERNEL
);
1428 dev_err(&udev
->dev
, "cam: out of memory !\n");
1432 cam
->v4l2_dev
.release
= zr364xx_release
;
1433 err
= v4l2_device_register(&intf
->dev
, &cam
->v4l2_dev
);
1435 dev_err(&udev
->dev
, "couldn't register v4l2_device\n");
1439 hdl
= &cam
->ctrl_handler
;
1440 v4l2_ctrl_handler_init(hdl
, 1);
1441 v4l2_ctrl_new_std(hdl
, &zr364xx_ctrl_ops
,
1442 V4L2_CID_BRIGHTNESS
, 0, 127, 1, 64);
1445 dev_err(&udev
->dev
, "couldn't register control\n");
1448 /* save the init method used by this camera */
1449 cam
->method
= id
->driver_info
;
1450 mutex_init(&cam
->lock
);
1451 cam
->vdev
= zr364xx_template
;
1452 cam
->vdev
.lock
= &cam
->lock
;
1453 cam
->vdev
.v4l2_dev
= &cam
->v4l2_dev
;
1454 cam
->vdev
.ctrl_handler
= &cam
->ctrl_handler
;
1455 video_set_drvdata(&cam
->vdev
, cam
);
1461 dev_info(&udev
->dev
, "160x120 mode selected\n");
1466 dev_info(&udev
->dev
, "640x480 mode selected\n");
1471 dev_info(&udev
->dev
, "320x240 mode selected\n");
1478 m1
[2].value
= 0xf000 + mode
;
1479 m2
[1].value
= 0xf000 + mode
;
1481 /* special case for METHOD3, the modes are different */
1482 if (cam
->method
== METHOD3
) {
1485 m2
[1].value
= 0xf000 + 4;
1488 m2
[1].value
= 0xf000 + 0;
1491 m2
[1].value
= 0xf000 + 1;
1496 header2
[437] = cam
->height
/ 256;
1497 header2
[438] = cam
->height
% 256;
1498 header2
[439] = cam
->width
/ 256;
1499 header2
[440] = cam
->width
% 256;
1503 DBG("dev: %p, udev %p interface %p\n", cam
, cam
->udev
, intf
);
1505 /* set up the endpoint information */
1506 iface_desc
= intf
->cur_altsetting
;
1507 DBG("num endpoints %d\n", iface_desc
->desc
.bNumEndpoints
);
1508 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
1509 endpoint
= &iface_desc
->endpoint
[i
].desc
;
1510 if (!cam
->read_endpoint
&& usb_endpoint_is_bulk_in(endpoint
)) {
1511 /* we found the bulk in endpoint */
1512 cam
->read_endpoint
= endpoint
->bEndpointAddress
;
1516 if (!cam
->read_endpoint
) {
1518 dev_err(&intf
->dev
, "Could not find bulk-in endpoint\n");
1523 INIT_LIST_HEAD(&cam
->vidq
.active
);
1524 cam
->vidq
.cam
= cam
;
1526 usb_set_intfdata(intf
, cam
);
1528 /* load zr364xx board specific */
1529 err
= zr364xx_board_init(cam
);
1531 err
= v4l2_ctrl_handler_setup(hdl
);
1535 spin_lock_init(&cam
->slock
);
1539 videobuf_queue_vmalloc_init(&cam
->vb_vidq
, &zr364xx_video_qops
,
1541 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1543 sizeof(struct zr364xx_buffer
), cam
, &cam
->lock
);
1545 err
= video_register_device(&cam
->vdev
, VFL_TYPE_GRABBER
, -1);
1547 dev_err(&udev
->dev
, "video_register_device failed\n");
1551 dev_info(&udev
->dev
, DRIVER_DESC
" controlling device %s\n",
1552 video_device_node_name(&cam
->vdev
));
1556 v4l2_ctrl_handler_free(hdl
);
1557 v4l2_device_unregister(&cam
->v4l2_dev
);
1563 static void zr364xx_disconnect(struct usb_interface
*intf
)
1565 struct zr364xx_camera
*cam
= usb_get_intfdata(intf
);
1567 mutex_lock(&cam
->lock
);
1568 usb_set_intfdata(intf
, NULL
);
1569 dev_info(&intf
->dev
, DRIVER_DESC
" webcam unplugged\n");
1570 video_unregister_device(&cam
->vdev
);
1571 v4l2_device_disconnect(&cam
->v4l2_dev
);
1573 /* stops the read pipe if it is running */
1575 zr364xx_stop_acquire(cam
);
1577 zr364xx_stop_readpipe(cam
);
1578 mutex_unlock(&cam
->lock
);
1579 v4l2_device_put(&cam
->v4l2_dev
);
1584 static int zr364xx_suspend(struct usb_interface
*intf
, pm_message_t message
)
1586 struct zr364xx_camera
*cam
= usb_get_intfdata(intf
);
1588 cam
->was_streaming
= cam
->b_acquire
;
1589 if (!cam
->was_streaming
)
1591 zr364xx_stop_acquire(cam
);
1592 zr364xx_stop_readpipe(cam
);
1596 static int zr364xx_resume(struct usb_interface
*intf
)
1598 struct zr364xx_camera
*cam
= usb_get_intfdata(intf
);
1601 if (!cam
->was_streaming
)
1604 zr364xx_start_readpipe(cam
);
1605 res
= zr364xx_prepare(cam
);
1607 zr364xx_start_acquire(cam
);
1612 /**********************/
1613 /* Module integration */
1614 /**********************/
1616 static struct usb_driver zr364xx_driver
= {
1618 .probe
= zr364xx_probe
,
1619 .disconnect
= zr364xx_disconnect
,
1621 .suspend
= zr364xx_suspend
,
1622 .resume
= zr364xx_resume
,
1623 .reset_resume
= zr364xx_resume
,
1625 .id_table
= device_table
1628 module_usb_driver(zr364xx_driver
);
1630 MODULE_AUTHOR(DRIVER_AUTHOR
);
1631 MODULE_DESCRIPTION(DRIVER_DESC
);
1632 MODULE_LICENSE("GPL");
1633 MODULE_VERSION(DRIVER_VERSION
);