2 * Zoran 364xx based USB webcam module version 0.72
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 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 #include <linux/version.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/usb.h>
33 #include <linux/vmalloc.h>
34 #include <linux/slab.h>
35 #include <linux/proc_fs.h>
36 #include <linux/highmem.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-ioctl.h>
41 /* Version Information */
42 #define DRIVER_VERSION "v0.72"
43 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
44 #define DRIVER_DESC "Zoran 364xx"
49 #define MAX_FRAME_SIZE 100000
50 #define BUFFER_SIZE 0x1000
51 #define CTRL_TIMEOUT 500
55 #define DBG(x...) if (debug) info(x)
58 /* Init methods, need to find nicer names for these
59 * the exact names of the chipsets would be the best if someone finds it */
65 /* Module parameters */
70 /* Module parameters interface */
71 module_param(debug
, int, 0644);
72 MODULE_PARM_DESC(debug
, "Debug level");
73 module_param(mode
, int, 0644);
74 MODULE_PARM_DESC(mode
, "0 = 320x240, 1 = 160x120, 2 = 640x480");
77 /* Devices supported by this driver
78 * .driver_info contains the init method used by the camera */
79 static struct usb_device_id device_table
[] = {
80 {USB_DEVICE(0x08ca, 0x0109), .driver_info
= METHOD0
},
81 {USB_DEVICE(0x041e, 0x4024), .driver_info
= METHOD0
},
82 {USB_DEVICE(0x0d64, 0x0108), .driver_info
= METHOD0
},
83 {USB_DEVICE(0x0546, 0x3187), .driver_info
= METHOD0
},
84 {USB_DEVICE(0x0d64, 0x3108), .driver_info
= METHOD0
},
85 {USB_DEVICE(0x0595, 0x4343), .driver_info
= METHOD0
},
86 {USB_DEVICE(0x0bb0, 0x500d), .driver_info
= METHOD0
},
87 {USB_DEVICE(0x0feb, 0x2004), .driver_info
= METHOD0
},
88 {USB_DEVICE(0x055f, 0xb500), .driver_info
= METHOD0
},
89 {USB_DEVICE(0x08ca, 0x2062), .driver_info
= METHOD2
},
90 {USB_DEVICE(0x052b, 0x1a18), .driver_info
= METHOD1
},
91 {USB_DEVICE(0x04c8, 0x0729), .driver_info
= METHOD0
},
92 {USB_DEVICE(0x04f2, 0xa208), .driver_info
= METHOD0
},
93 {USB_DEVICE(0x0784, 0x0040), .driver_info
= METHOD1
},
94 {USB_DEVICE(0x06d6, 0x0034), .driver_info
= METHOD0
},
95 {USB_DEVICE(0x0a17, 0x0062), .driver_info
= METHOD2
},
96 {USB_DEVICE(0x06d6, 0x003b), .driver_info
= METHOD0
},
97 {USB_DEVICE(0x0a17, 0x004e), .driver_info
= METHOD2
},
98 {USB_DEVICE(0x041e, 0x405d), .driver_info
= METHOD2
},
99 {} /* Terminating entry */
102 MODULE_DEVICE_TABLE(usb
, device_table
);
106 struct zr364xx_camera
{
107 struct usb_device
*udev
; /* save off the usb device pointer */
108 struct usb_interface
*interface
;/* the interface for this device */
109 struct video_device
*vdev
; /* v4l video device */
112 unsigned char *buffer
;
122 /* function used to send initialisation commands to the camera */
123 static int send_control_msg(struct usb_device
*udev
, u8 request
, u16 value
,
124 u16 index
, unsigned char *cp
, u16 size
)
128 unsigned char *transfer_buffer
= kmalloc(size
, GFP_KERNEL
);
129 if (!transfer_buffer
) {
130 info("kmalloc(%d) failed", size
);
134 memcpy(transfer_buffer
, cp
, size
);
136 status
= usb_control_msg(udev
,
137 usb_sndctrlpipe(udev
, 0),
139 USB_DIR_OUT
| USB_TYPE_VENDOR
|
140 USB_RECIP_DEVICE
, value
, index
,
141 transfer_buffer
, size
, CTRL_TIMEOUT
);
143 kfree(transfer_buffer
);
146 info("Failed sending control message, error %d.", status
);
152 /* Control messages sent to the camera to initialize it
153 * and launch the capture */
157 unsigned char *bytes
;
161 static unsigned char m0d1
[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
162 static unsigned char m0d2
[] = { 0, 0, 0, 0, 0, 0 };
163 static unsigned char m0d3
[] = { 0, 0 };
164 static message m0
[] = {
167 {0x3370, sizeof(m0d1
), m0d1
},
170 {0x2610, sizeof(m0d2
), m0d2
},
175 {0x9a01, sizeof(m0d3
), m0d3
},
180 static unsigned char m1d1
[] = { 0xff, 0xff };
181 static unsigned char m1d2
[] = { 0x00, 0x00 };
182 static message m1
[] = {
190 {0x2502, sizeof(m1d1
), m1d1
},
195 {0x9a01, sizeof(m1d2
), m1d2
},
200 static unsigned char m2d1
[] = { 0xff, 0xff };
201 static message m2
[] = {
208 {0x2502, sizeof(m2d1
), m2d1
},
214 static message
*init
[3] = { m0
, m1
, m2
};
217 /* JPEG static data in header (Huffman table, etc) */
218 static unsigned char header1
[] = {
221 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
222 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
224 0xFF, 0xDB, 0x00, 0x84
226 static unsigned char header2
[] = {
227 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
228 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
229 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
230 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
231 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
232 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
233 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
234 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
235 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
236 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
237 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
238 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
239 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
240 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
241 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
242 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
243 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
244 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
245 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
246 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
247 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
248 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
249 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
250 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
251 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
252 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
253 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
254 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
255 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
256 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
257 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
258 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
259 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
260 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
261 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
262 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
263 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
264 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
265 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
266 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
267 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
268 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
271 static unsigned char header3
;
275 /********************/
276 /* V4L2 integration */
277 /********************/
279 /* this function reads a full JPEG picture synchronously
280 * TODO: do it asynchronously... */
281 static int read_frame(struct zr364xx_camera
*cam
, int framenum
)
283 int i
, n
, temp
, head
, size
, actual_length
;
284 unsigned char *ptr
= NULL
, *jpeg
;
287 /* hardware brightness */
288 n
= send_control_msg(cam
->udev
, 1, 0x2001, 0, NULL
, 0);
289 temp
= (0x60 << 8) + 127 - cam
->brightness
;
290 n
= send_control_msg(cam
->udev
, 1, temp
, 0, NULL
, 0);
292 /* during the first loop we are going to insert JPEG header */
294 /* this is the place in memory where we are going to build
296 jpeg
= cam
->framebuf
+ framenum
* MAX_FRAME_SIZE
;
299 n
= usb_bulk_msg(cam
->udev
,
300 usb_rcvbulkpipe(cam
->udev
, 0x81),
301 cam
->buffer
, BUFFER_SIZE
, &actual_length
,
303 DBG("buffer : %d %d", cam
->buffer
[0], cam
->buffer
[1]);
304 DBG("bulk : n=%d size=%d", n
, actual_length
);
306 info("error reading bulk msg");
309 if (actual_length
< 0 || actual_length
> BUFFER_SIZE
) {
310 info("wrong number of bytes");
314 /* swap bytes if camera needs it */
315 if (cam
->method
== METHOD0
) {
316 u16
*buf
= (u16
*)cam
->buffer
;
317 for (i
= 0; i
< BUFFER_SIZE
/2; i
++)
321 /* write the JPEG header */
325 memcpy(ptr
, header1
, sizeof(header1
));
326 ptr
+= sizeof(header1
);
328 memcpy(ptr
, &header3
, 1);
330 memcpy(ptr
, cam
->buffer
, 64);
333 memcpy(ptr
, &header3
, 1);
335 memcpy(ptr
, cam
->buffer
+ 64, 64);
337 memcpy(ptr
, header2
, sizeof(header2
));
338 ptr
+= sizeof(header2
);
339 memcpy(ptr
, cam
->buffer
+ 128,
340 actual_length
- 128);
341 ptr
+= actual_length
- 128;
343 DBG("header : %d %d %d %d %d %d %d %d %d",
344 cam
->buffer
[0], cam
->buffer
[1], cam
->buffer
[2],
345 cam
->buffer
[3], cam
->buffer
[4], cam
->buffer
[5],
346 cam
->buffer
[6], cam
->buffer
[7], cam
->buffer
[8]);
348 memcpy(ptr
, cam
->buffer
, actual_length
);
349 ptr
+= actual_length
;
352 /* ... until there is no more */
353 while (actual_length
== BUFFER_SIZE
);
355 /* we skip the 2 first frames which are usually buggy */
361 /* go back to find the JPEG EOI marker */
365 if (*ptr
== 0xFF && *(ptr
+ 1) == 0xD9
366 && *(ptr
+ 2) == 0xFF)
371 DBG("No EOI marker");
373 /* Sometimes there is junk data in the middle of the picture,
374 * we want to skip this bogus frames */
376 if (*ptr
== 0xFF && *(ptr
+ 1) == 0xFF
377 && *(ptr
+ 2) == 0xFF)
382 DBG("Bogus frame ? %d", cam
->nb
);
386 DBG("jpeg : %d %d %d %d %d %d %d %d",
387 jpeg
[0], jpeg
[1], jpeg
[2], jpeg
[3],
388 jpeg
[4], jpeg
[5], jpeg
[6], jpeg
[7]);
394 static ssize_t
zr364xx_read(struct file
*file
, char __user
*buf
, size_t cnt
,
397 unsigned long count
= cnt
;
398 struct video_device
*vdev
= video_devdata(file
);
399 struct zr364xx_camera
*cam
;
401 DBG("zr364xx_read: read %d bytes.", (int) count
);
405 cam
= video_get_drvdata(vdev
);
414 count
= read_frame(cam
, 0);
416 if (copy_to_user(buf
, cam
->framebuf
, count
))
423 static int zr364xx_vidioc_querycap(struct file
*file
, void *priv
,
424 struct v4l2_capability
*cap
)
426 memset(cap
, 0, sizeof(*cap
));
427 strcpy(cap
->driver
, DRIVER_DESC
);
428 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_READWRITE
;
432 static int zr364xx_vidioc_enum_input(struct file
*file
, void *priv
,
433 struct v4l2_input
*i
)
437 memset(i
, 0, sizeof(*i
));
439 strcpy(i
->name
, DRIVER_DESC
" Camera");
440 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
444 static int zr364xx_vidioc_g_input(struct file
*file
, void *priv
,
451 static int zr364xx_vidioc_s_input(struct file
*file
, void *priv
,
459 static int zr364xx_vidioc_queryctrl(struct file
*file
, void *priv
,
460 struct v4l2_queryctrl
*c
)
462 struct video_device
*vdev
= video_devdata(file
);
463 struct zr364xx_camera
*cam
;
467 cam
= video_get_drvdata(vdev
);
470 case V4L2_CID_BRIGHTNESS
:
471 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
472 strcpy(c
->name
, "Brightness");
476 c
->default_value
= cam
->brightness
;
485 static int zr364xx_vidioc_s_ctrl(struct file
*file
, void *priv
,
486 struct v4l2_control
*c
)
488 struct video_device
*vdev
= video_devdata(file
);
489 struct zr364xx_camera
*cam
;
493 cam
= video_get_drvdata(vdev
);
496 case V4L2_CID_BRIGHTNESS
:
497 cam
->brightness
= c
->value
;
505 static int zr364xx_vidioc_g_ctrl(struct file
*file
, void *priv
,
506 struct v4l2_control
*c
)
508 struct video_device
*vdev
= video_devdata(file
);
509 struct zr364xx_camera
*cam
;
513 cam
= video_get_drvdata(vdev
);
516 case V4L2_CID_BRIGHTNESS
:
517 c
->value
= cam
->brightness
;
525 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file
*file
,
526 void *priv
, struct v4l2_fmtdesc
*f
)
530 if (f
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
532 memset(f
, 0, sizeof(*f
));
534 f
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
535 f
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
536 strcpy(f
->description
, "JPEG");
537 f
->pixelformat
= V4L2_PIX_FMT_JPEG
;
541 static int zr364xx_vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
542 struct v4l2_format
*f
)
544 struct video_device
*vdev
= video_devdata(file
);
545 struct zr364xx_camera
*cam
;
549 cam
= video_get_drvdata(vdev
);
551 if (f
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
553 if (f
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_JPEG
)
555 if (f
->fmt
.pix
.field
!= V4L2_FIELD_ANY
&&
556 f
->fmt
.pix
.field
!= V4L2_FIELD_NONE
)
558 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
559 f
->fmt
.pix
.width
= cam
->width
;
560 f
->fmt
.pix
.height
= cam
->height
;
561 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
562 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
563 f
->fmt
.pix
.colorspace
= 0;
568 static int zr364xx_vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
569 struct v4l2_format
*f
)
571 struct video_device
*vdev
= video_devdata(file
);
572 struct zr364xx_camera
*cam
;
576 cam
= video_get_drvdata(vdev
);
578 if (f
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
580 memset(&f
->fmt
.pix
, 0, sizeof(struct v4l2_pix_format
));
581 f
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
582 f
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_JPEG
;
583 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
584 f
->fmt
.pix
.width
= cam
->width
;
585 f
->fmt
.pix
.height
= cam
->height
;
586 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
587 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
588 f
->fmt
.pix
.colorspace
= 0;
593 static int zr364xx_vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
594 struct v4l2_format
*f
)
596 struct video_device
*vdev
= video_devdata(file
);
597 struct zr364xx_camera
*cam
;
601 cam
= video_get_drvdata(vdev
);
603 if (f
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
605 if (f
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_JPEG
)
607 if (f
->fmt
.pix
.field
!= V4L2_FIELD_ANY
&&
608 f
->fmt
.pix
.field
!= V4L2_FIELD_NONE
)
610 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
611 f
->fmt
.pix
.width
= cam
->width
;
612 f
->fmt
.pix
.height
= cam
->height
;
613 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
614 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
615 f
->fmt
.pix
.colorspace
= 0;
621 static int zr364xx_vidioc_streamon(struct file
*file
, void *priv
,
622 enum v4l2_buf_type type
)
627 static int zr364xx_vidioc_streamoff(struct file
*file
, void *priv
,
628 enum v4l2_buf_type type
)
634 /* open the camera */
635 static int zr364xx_open(struct inode
*inode
, struct file
*file
)
637 struct video_device
*vdev
= video_devdata(file
);
638 struct zr364xx_camera
*cam
= video_get_drvdata(vdev
);
639 struct usb_device
*udev
= cam
->udev
;
646 err
= video_exclusive_open(inode
, file
);
650 if (!cam
->framebuf
) {
651 cam
->framebuf
= vmalloc_32(MAX_FRAME_SIZE
* FRAMES
);
652 if (!cam
->framebuf
) {
653 info("vmalloc_32 failed!");
658 mutex_lock(&cam
->lock
);
659 for (i
= 0; init
[cam
->method
][i
].size
!= -1; i
++) {
661 send_control_msg(udev
, 1, init
[cam
->method
][i
].value
,
662 0, init
[cam
->method
][i
].bytes
,
663 init
[cam
->method
][i
].size
);
665 info("error during open sequence: %d", i
);
666 mutex_unlock(&cam
->lock
);
671 file
->private_data
= vdev
;
673 /* Added some delay here, since opening/closing the camera quickly,
674 * like Ekiga does during its startup, can crash the webcam
678 mutex_unlock(&cam
->lock
);
683 /* release the camera */
684 static int zr364xx_release(struct inode
*inode
, struct file
*file
)
686 struct video_device
*vdev
= video_devdata(file
);
687 struct zr364xx_camera
*cam
;
688 struct usb_device
*udev
;
691 DBG("zr364xx_release");
695 cam
= video_get_drvdata(vdev
);
699 mutex_lock(&cam
->lock
);
700 for (i
= 0; i
< 2; i
++) {
702 send_control_msg(udev
, 1, init
[cam
->method
][i
].value
,
703 0, init
[i
][cam
->method
].bytes
,
704 init
[cam
->method
][i
].size
);
706 info("error during release sequence");
707 mutex_unlock(&cam
->lock
);
712 file
->private_data
= NULL
;
713 video_exclusive_release(inode
, file
);
715 /* Added some delay here, since opening/closing the camera quickly,
716 * like Ekiga does during its startup, can crash the webcam
720 mutex_unlock(&cam
->lock
);
725 static int zr364xx_mmap(struct file
*file
, struct vm_area_struct
*vma
)
728 unsigned long start
= vma
->vm_start
;
729 unsigned long size
= vma
->vm_end
- vma
->vm_start
;
730 struct video_device
*vdev
= video_devdata(file
);
731 struct zr364xx_camera
*cam
;
733 DBG("zr364xx_mmap: %ld\n", size
);
737 cam
= video_get_drvdata(vdev
);
741 if (vm_insert_page(vma
, start
, vmalloc_to_page(pos
)))
745 if (size
> PAGE_SIZE
)
755 static const struct file_operations zr364xx_fops
= {
756 .owner
= THIS_MODULE
,
757 .open
= zr364xx_open
,
758 .release
= zr364xx_release
,
759 .read
= zr364xx_read
,
760 .mmap
= zr364xx_mmap
,
761 .ioctl
= video_ioctl2
,
765 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops
= {
766 .vidioc_querycap
= zr364xx_vidioc_querycap
,
767 .vidioc_enum_fmt_vid_cap
= zr364xx_vidioc_enum_fmt_vid_cap
,
768 .vidioc_try_fmt_vid_cap
= zr364xx_vidioc_try_fmt_vid_cap
,
769 .vidioc_s_fmt_vid_cap
= zr364xx_vidioc_s_fmt_vid_cap
,
770 .vidioc_g_fmt_vid_cap
= zr364xx_vidioc_g_fmt_vid_cap
,
771 .vidioc_enum_input
= zr364xx_vidioc_enum_input
,
772 .vidioc_g_input
= zr364xx_vidioc_g_input
,
773 .vidioc_s_input
= zr364xx_vidioc_s_input
,
774 .vidioc_streamon
= zr364xx_vidioc_streamon
,
775 .vidioc_streamoff
= zr364xx_vidioc_streamoff
,
776 .vidioc_queryctrl
= zr364xx_vidioc_queryctrl
,
777 .vidioc_g_ctrl
= zr364xx_vidioc_g_ctrl
,
778 .vidioc_s_ctrl
= zr364xx_vidioc_s_ctrl
,
781 static struct video_device zr364xx_template
= {
782 .owner
= THIS_MODULE
,
784 .type
= VID_TYPE_CAPTURE
,
785 .fops
= &zr364xx_fops
,
786 .ioctl_ops
= &zr364xx_ioctl_ops
,
787 .release
= video_device_release
,
793 /*******************/
794 /* USB integration */
795 /*******************/
797 static int zr364xx_probe(struct usb_interface
*intf
,
798 const struct usb_device_id
*id
)
800 struct usb_device
*udev
= interface_to_usbdev(intf
);
801 struct zr364xx_camera
*cam
= NULL
;
806 info(DRIVER_DESC
" compatible webcam plugged");
807 info("model %04x:%04x detected", udev
->descriptor
.idVendor
,
808 udev
->descriptor
.idProduct
);
810 cam
= kzalloc(sizeof(struct zr364xx_camera
), GFP_KERNEL
);
812 info("cam: out of memory !");
815 /* save the init method used by this camera */
816 cam
->method
= id
->driver_info
;
818 cam
->vdev
= video_device_alloc();
819 if (cam
->vdev
== NULL
) {
820 info("cam->vdev: out of memory !");
824 memcpy(cam
->vdev
, &zr364xx_template
, sizeof(zr364xx_template
));
825 video_set_drvdata(cam
->vdev
, cam
);
827 cam
->vdev
->debug
= V4L2_DEBUG_IOCTL
| V4L2_DEBUG_IOCTL_ARG
;
831 if ((cam
->buffer
= kmalloc(BUFFER_SIZE
, GFP_KERNEL
)) == NULL
) {
832 info("cam->buffer: out of memory !");
833 video_device_release(cam
->vdev
);
840 info("160x120 mode selected");
845 info("640x480 mode selected");
850 info("320x240 mode selected");
857 m1
[2].value
= 0xf000 + mode
;
858 m2
[1].value
= 0xf000 + mode
;
859 header2
[437] = cam
->height
/ 256;
860 header2
[438] = cam
->height
% 256;
861 header2
[439] = cam
->width
/ 256;
862 header2
[440] = cam
->width
% 256;
865 cam
->brightness
= 64;
866 mutex_init(&cam
->lock
);
868 err
= video_register_device(cam
->vdev
, VFL_TYPE_GRABBER
, -1);
870 info("video_register_device failed");
871 video_device_release(cam
->vdev
);
877 usb_set_intfdata(intf
, cam
);
879 info(DRIVER_DESC
" controlling video device %d", cam
->vdev
->minor
);
884 static void zr364xx_disconnect(struct usb_interface
*intf
)
886 struct zr364xx_camera
*cam
= usb_get_intfdata(intf
);
887 usb_set_intfdata(intf
, NULL
);
888 dev_set_drvdata(&intf
->dev
, NULL
);
889 info(DRIVER_DESC
" webcam unplugged");
891 video_unregister_device(cam
->vdev
);
895 vfree(cam
->framebuf
);
901 /**********************/
902 /* Module integration */
903 /**********************/
905 static struct usb_driver zr364xx_driver
= {
907 .probe
= zr364xx_probe
,
908 .disconnect
= zr364xx_disconnect
,
909 .id_table
= device_table
913 static int __init
zr364xx_init(void)
916 retval
= usb_register(&zr364xx_driver
);
918 info("usb_register failed!");
920 info(DRIVER_DESC
" module loaded");
925 static void __exit
zr364xx_exit(void)
927 info(DRIVER_DESC
" module unloaded");
928 usb_deregister(&zr364xx_driver
);
932 module_init(zr364xx_init
);
933 module_exit(zr364xx_exit
);
935 MODULE_AUTHOR(DRIVER_AUTHOR
);
936 MODULE_DESCRIPTION(DRIVER_DESC
);
937 MODULE_LICENSE("GPL");