V4L/DVB (8780): v4l: replace the last uses of video_exclusive_open/release
[linux-2.6] / drivers / media / video / zr364xx.c
1 /*
2  * Zoran 364xx based USB webcam module version 0.72
3  *
4  * Allows you to use your USB webcam with V4L2 applications
5  * This is still in heavy developpement !
6  *
7  * Copyright (C) 2004  Antoine Jacquet <royale@zerezo.com>
8  * http://royale.zerezo.com/zr364xx/
9  *
10  * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
11  * V4L2 version inspired by meye.c driver
12  *
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.
17  *
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.
22  *
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
26  */
27
28
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>
39
40
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"
45
46
47 /* Camera */
48 #define FRAMES 2
49 #define MAX_FRAME_SIZE 100000
50 #define BUFFER_SIZE 0x1000
51 #define CTRL_TIMEOUT 500
52
53
54 /* Debug macro */
55 #define DBG(x...) if (debug) info(x)
56
57
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 */
60 #define METHOD0 0
61 #define METHOD1 1
62 #define METHOD2 2
63
64
65 /* Module parameters */
66 static int debug;
67 static int mode;
68
69
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");
75
76
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 */
100 };
101
102 MODULE_DEVICE_TABLE(usb, device_table);
103
104
105 /* Camera stuff */
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 */
110         u8 *framebuf;
111         int nb;
112         unsigned char *buffer;
113         int skip;
114         int brightness;
115         int width;
116         int height;
117         int method;
118         struct mutex lock;
119         int users;
120 };
121
122
123 /* function used to send initialisation commands to the camera */
124 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
125                             u16 index, unsigned char *cp, u16 size)
126 {
127         int status;
128
129         unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
130         if (!transfer_buffer) {
131                 info("kmalloc(%d) failed", size);
132                 return -ENOMEM;
133         }
134
135         memcpy(transfer_buffer, cp, size);
136
137         status = usb_control_msg(udev,
138                                  usb_sndctrlpipe(udev, 0),
139                                  request,
140                                  USB_DIR_OUT | USB_TYPE_VENDOR |
141                                  USB_RECIP_DEVICE, value, index,
142                                  transfer_buffer, size, CTRL_TIMEOUT);
143
144         kfree(transfer_buffer);
145
146         if (status < 0)
147                 info("Failed sending control message, error %d.", status);
148
149         return status;
150 }
151
152
153 /* Control messages sent to the camera to initialize it
154  * and launch the capture */
155 typedef struct {
156         unsigned int value;
157         unsigned int size;
158         unsigned char *bytes;
159 } message;
160
161 /* method 0 */
162 static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
163 static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
164 static unsigned char m0d3[] = { 0, 0 };
165 static message m0[] = {
166         {0x1f30, 0, NULL},
167         {0xd000, 0, NULL},
168         {0x3370, sizeof(m0d1), m0d1},
169         {0x2000, 0, NULL},
170         {0x2f0f, 0, NULL},
171         {0x2610, sizeof(m0d2), m0d2},
172         {0xe107, 0, NULL},
173         {0x2502, 0, NULL},
174         {0x1f70, 0, NULL},
175         {0xd000, 0, NULL},
176         {0x9a01, sizeof(m0d3), m0d3},
177         {-1, -1, NULL}
178 };
179
180 /* method 1 */
181 static unsigned char m1d1[] = { 0xff, 0xff };
182 static unsigned char m1d2[] = { 0x00, 0x00 };
183 static message m1[] = {
184         {0x1f30, 0, NULL},
185         {0xd000, 0, NULL},
186         {0xf000, 0, NULL},
187         {0x2000, 0, NULL},
188         {0x2f0f, 0, NULL},
189         {0x2650, 0, NULL},
190         {0xe107, 0, NULL},
191         {0x2502, sizeof(m1d1), m1d1},
192         {0x1f70, 0, NULL},
193         {0xd000, 0, NULL},
194         {0xd000, 0, NULL},
195         {0xd000, 0, NULL},
196         {0x9a01, sizeof(m1d2), m1d2},
197         {-1, -1, NULL}
198 };
199
200 /* method 2 */
201 static unsigned char m2d1[] = { 0xff, 0xff };
202 static message m2[] = {
203         {0x1f30, 0, NULL},
204         {0xf000, 0, NULL},
205         {0x2000, 0, NULL},
206         {0x2f0f, 0, NULL},
207         {0x2650, 0, NULL},
208         {0xe107, 0, NULL},
209         {0x2502, sizeof(m2d1), m2d1},
210         {0x1f70, 0, NULL},
211         {-1, -1, NULL}
212 };
213
214 /* init table */
215 static message *init[3] = { m0, m1, m2 };
216
217
218 /* JPEG static data in header (Huffman table, etc) */
219 static unsigned char header1[] = {
220         0xFF, 0xD8,
221         /*
222         0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
223         0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
224         */
225         0xFF, 0xDB, 0x00, 0x84
226 };
227 static unsigned char header2[] = {
228         0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
229         0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
230         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
231         0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
232         0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
233         0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
234         0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
235         0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
236         0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
237         0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
238         0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
239         0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
240         0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
241         0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
242         0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
243         0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
244         0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
245         0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
246         0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
247         0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
248         0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
249         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
250         0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
251         0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
252         0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
253         0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
254         0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
255         0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
256         0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
257         0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
258         0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
259         0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
260         0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
261         0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
262         0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
263         0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
264         0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
265         0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
266         0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
267         0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
268         0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
269         0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
270         0x00, 0x3F, 0x00
271 };
272 static unsigned char header3;
273
274
275
276 /********************/
277 /* V4L2 integration */
278 /********************/
279
280 /* this function reads a full JPEG picture synchronously
281  * TODO: do it asynchronously... */
282 static int read_frame(struct zr364xx_camera *cam, int framenum)
283 {
284         int i, n, temp, head, size, actual_length;
285         unsigned char *ptr = NULL, *jpeg;
286
287       redo:
288         /* hardware brightness */
289         n = send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
290         temp = (0x60 << 8) + 127 - cam->brightness;
291         n = send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
292
293         /* during the first loop we are going to insert JPEG header */
294         head = 0;
295         /* this is the place in memory where we are going to build
296          * the JPEG image */
297         jpeg = cam->framebuf + framenum * MAX_FRAME_SIZE;
298         /* read data... */
299         do {
300                 n = usb_bulk_msg(cam->udev,
301                                  usb_rcvbulkpipe(cam->udev, 0x81),
302                                  cam->buffer, BUFFER_SIZE, &actual_length,
303                                  CTRL_TIMEOUT);
304                 DBG("buffer : %d %d", cam->buffer[0], cam->buffer[1]);
305                 DBG("bulk : n=%d size=%d", n, actual_length);
306                 if (n < 0) {
307                         info("error reading bulk msg");
308                         return 0;
309                 }
310                 if (actual_length < 0 || actual_length > BUFFER_SIZE) {
311                         info("wrong number of bytes");
312                         return 0;
313                 }
314
315                 /* swap bytes if camera needs it */
316                 if (cam->method == METHOD0) {
317                         u16 *buf = (u16*)cam->buffer;
318                         for (i = 0; i < BUFFER_SIZE/2; i++)
319                                 swab16s(buf + i);
320                 }
321
322                 /* write the JPEG header */
323                 if (!head) {
324                         DBG("jpeg header");
325                         ptr = jpeg;
326                         memcpy(ptr, header1, sizeof(header1));
327                         ptr += sizeof(header1);
328                         header3 = 0;
329                         memcpy(ptr, &header3, 1);
330                         ptr++;
331                         memcpy(ptr, cam->buffer, 64);
332                         ptr += 64;
333                         header3 = 1;
334                         memcpy(ptr, &header3, 1);
335                         ptr++;
336                         memcpy(ptr, cam->buffer + 64, 64);
337                         ptr += 64;
338                         memcpy(ptr, header2, sizeof(header2));
339                         ptr += sizeof(header2);
340                         memcpy(ptr, cam->buffer + 128,
341                                actual_length - 128);
342                         ptr += actual_length - 128;
343                         head = 1;
344                         DBG("header : %d %d %d %d %d %d %d %d %d",
345                             cam->buffer[0], cam->buffer[1], cam->buffer[2],
346                             cam->buffer[3], cam->buffer[4], cam->buffer[5],
347                             cam->buffer[6], cam->buffer[7], cam->buffer[8]);
348                 } else {
349                         memcpy(ptr, cam->buffer, actual_length);
350                         ptr += actual_length;
351                 }
352         }
353         /* ... until there is no more */
354         while (actual_length == BUFFER_SIZE);
355
356         /* we skip the 2 first frames which are usually buggy */
357         if (cam->skip) {
358                 cam->skip--;
359                 goto redo;
360         }
361
362         /* go back to find the JPEG EOI marker */
363         size = ptr - jpeg;
364         ptr -= 2;
365         while (ptr > jpeg) {
366                 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
367                     && *(ptr + 2) == 0xFF)
368                         break;
369                 ptr--;
370         }
371         if (ptr == jpeg)
372                 DBG("No EOI marker");
373
374         /* Sometimes there is junk data in the middle of the picture,
375          * we want to skip this bogus frames */
376         while (ptr > jpeg) {
377                 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
378                     && *(ptr + 2) == 0xFF)
379                         break;
380                 ptr--;
381         }
382         if (ptr != jpeg) {
383                 DBG("Bogus frame ? %d", cam->nb);
384                 goto redo;
385         }
386
387         DBG("jpeg : %d %d %d %d %d %d %d %d",
388             jpeg[0], jpeg[1], jpeg[2], jpeg[3],
389             jpeg[4], jpeg[5], jpeg[6], jpeg[7]);
390
391         return size;
392 }
393
394
395 static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t cnt,
396                             loff_t * ppos)
397 {
398         unsigned long count = cnt;
399         struct video_device *vdev = video_devdata(file);
400         struct zr364xx_camera *cam;
401
402         DBG("zr364xx_read: read %d bytes.", (int) count);
403
404         if (vdev == NULL)
405                 return -ENODEV;
406         cam = video_get_drvdata(vdev);
407
408         if (!buf)
409                 return -EINVAL;
410
411         if (!count)
412                 return -EINVAL;
413
414         /* NoMan Sux ! */
415         count = read_frame(cam, 0);
416
417         if (copy_to_user(buf, cam->framebuf, count))
418                 return -EFAULT;
419
420         return count;
421 }
422
423
424 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
425                                    struct v4l2_capability *cap)
426 {
427         memset(cap, 0, sizeof(*cap));
428         strcpy(cap->driver, DRIVER_DESC);
429         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
430         return 0;
431 }
432
433 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
434                                      struct v4l2_input *i)
435 {
436         if (i->index != 0)
437                 return -EINVAL;
438         memset(i, 0, sizeof(*i));
439         i->index = 0;
440         strcpy(i->name, DRIVER_DESC " Camera");
441         i->type = V4L2_INPUT_TYPE_CAMERA;
442         return 0;
443 }
444
445 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
446                                   unsigned int *i)
447 {
448         *i = 0;
449         return 0;
450 }
451
452 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
453                                   unsigned int i)
454 {
455         if (i != 0)
456                 return -EINVAL;
457         return 0;
458 }
459
460 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
461                                     struct v4l2_queryctrl *c)
462 {
463         struct video_device *vdev = video_devdata(file);
464         struct zr364xx_camera *cam;
465
466         if (vdev == NULL)
467                 return -ENODEV;
468         cam = video_get_drvdata(vdev);
469
470         switch (c->id) {
471         case V4L2_CID_BRIGHTNESS:
472                 c->type = V4L2_CTRL_TYPE_INTEGER;
473                 strcpy(c->name, "Brightness");
474                 c->minimum = 0;
475                 c->maximum = 127;
476                 c->step = 1;
477                 c->default_value = cam->brightness;
478                 c->flags = 0;
479                 break;
480         default:
481                 return -EINVAL;
482         }
483         return 0;
484 }
485
486 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
487                                  struct v4l2_control *c)
488 {
489         struct video_device *vdev = video_devdata(file);
490         struct zr364xx_camera *cam;
491
492         if (vdev == NULL)
493                 return -ENODEV;
494         cam = video_get_drvdata(vdev);
495
496         switch (c->id) {
497         case V4L2_CID_BRIGHTNESS:
498                 cam->brightness = c->value;
499                 break;
500         default:
501                 return -EINVAL;
502         }
503         return 0;
504 }
505
506 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
507                                  struct v4l2_control *c)
508 {
509         struct video_device *vdev = video_devdata(file);
510         struct zr364xx_camera *cam;
511
512         if (vdev == NULL)
513                 return -ENODEV;
514         cam = video_get_drvdata(vdev);
515
516         switch (c->id) {
517         case V4L2_CID_BRIGHTNESS:
518                 c->value = cam->brightness;
519                 break;
520         default:
521                 return -EINVAL;
522         }
523         return 0;
524 }
525
526 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
527                                        void *priv, struct v4l2_fmtdesc *f)
528 {
529         if (f->index > 0)
530                 return -EINVAL;
531         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
532                 return -EINVAL;
533         memset(f, 0, sizeof(*f));
534         f->index = 0;
535         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
536         f->flags = V4L2_FMT_FLAG_COMPRESSED;
537         strcpy(f->description, "JPEG");
538         f->pixelformat = V4L2_PIX_FMT_JPEG;
539         return 0;
540 }
541
542 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
543                                       struct v4l2_format *f)
544 {
545         struct video_device *vdev = video_devdata(file);
546         struct zr364xx_camera *cam;
547
548         if (vdev == NULL)
549                 return -ENODEV;
550         cam = video_get_drvdata(vdev);
551
552         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
553                 return -EINVAL;
554         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
555                 return -EINVAL;
556         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
557             f->fmt.pix.field != V4L2_FIELD_NONE)
558                 return -EINVAL;
559         f->fmt.pix.field = V4L2_FIELD_NONE;
560         f->fmt.pix.width = cam->width;
561         f->fmt.pix.height = cam->height;
562         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
563         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
564         f->fmt.pix.colorspace = 0;
565         f->fmt.pix.priv = 0;
566         return 0;
567 }
568
569 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
570                                     struct v4l2_format *f)
571 {
572         struct video_device *vdev = video_devdata(file);
573         struct zr364xx_camera *cam;
574
575         if (vdev == NULL)
576                 return -ENODEV;
577         cam = video_get_drvdata(vdev);
578
579         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
580                 return -EINVAL;
581         memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
582         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
583         f->fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
584         f->fmt.pix.field = V4L2_FIELD_NONE;
585         f->fmt.pix.width = cam->width;
586         f->fmt.pix.height = cam->height;
587         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
588         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
589         f->fmt.pix.colorspace = 0;
590         f->fmt.pix.priv = 0;
591         return 0;
592 }
593
594 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
595                                     struct v4l2_format *f)
596 {
597         struct video_device *vdev = video_devdata(file);
598         struct zr364xx_camera *cam;
599
600         if (vdev == NULL)
601                 return -ENODEV;
602         cam = video_get_drvdata(vdev);
603
604         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
605                 return -EINVAL;
606         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
607                 return -EINVAL;
608         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
609             f->fmt.pix.field != V4L2_FIELD_NONE)
610                 return -EINVAL;
611         f->fmt.pix.field = V4L2_FIELD_NONE;
612         f->fmt.pix.width = cam->width;
613         f->fmt.pix.height = cam->height;
614         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
615         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
616         f->fmt.pix.colorspace = 0;
617         f->fmt.pix.priv = 0;
618         DBG("ok!");
619         return 0;
620 }
621
622 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
623                                    enum v4l2_buf_type type)
624 {
625         return 0;
626 }
627
628 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
629                                     enum v4l2_buf_type type)
630 {
631         return 0;
632 }
633
634
635 /* open the camera */
636 static int zr364xx_open(struct inode *inode, struct file *file)
637 {
638         struct video_device *vdev = video_devdata(file);
639         struct zr364xx_camera *cam = video_get_drvdata(vdev);
640         struct usb_device *udev = cam->udev;
641         int i, err;
642
643         DBG("zr364xx_open");
644
645         mutex_lock(&cam->lock);
646
647         if (cam->users) {
648                 err = -EBUSY;
649                 goto out;
650         }
651
652         if (!cam->framebuf) {
653                 cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
654                 if (!cam->framebuf) {
655                         info("vmalloc_32 failed!");
656                         err = -ENOMEM;
657                         goto out;
658                 }
659         }
660
661         for (i = 0; init[cam->method][i].size != -1; i++) {
662                 err =
663                     send_control_msg(udev, 1, init[cam->method][i].value,
664                                      0, init[cam->method][i].bytes,
665                                      init[cam->method][i].size);
666                 if (err < 0) {
667                         info("error during open sequence: %d", i);
668                         goto out;
669                 }
670         }
671
672         cam->skip = 2;
673         cam->users++;
674         file->private_data = vdev;
675
676         /* Added some delay here, since opening/closing the camera quickly,
677          * like Ekiga does during its startup, can crash the webcam
678          */
679         mdelay(100);
680         err = 0;
681
682 out:
683         mutex_unlock(&cam->lock);
684         return err;
685 }
686
687
688 /* release the camera */
689 static int zr364xx_release(struct inode *inode, struct file *file)
690 {
691         struct video_device *vdev = video_devdata(file);
692         struct zr364xx_camera *cam;
693         struct usb_device *udev;
694         int i, err;
695
696         DBG("zr364xx_release");
697
698         if (vdev == NULL)
699                 return -ENODEV;
700         cam = video_get_drvdata(vdev);
701
702         udev = cam->udev;
703
704         mutex_lock(&cam->lock);
705
706         cam->users--;
707         file->private_data = NULL;
708
709         for (i = 0; i < 2; i++) {
710                 err =
711                     send_control_msg(udev, 1, init[cam->method][i].value,
712                                      0, init[i][cam->method].bytes,
713                                      init[cam->method][i].size);
714                 if (err < 0) {
715                         info("error during release sequence");
716                         goto out;
717                 }
718         }
719
720         /* Added some delay here, since opening/closing the camera quickly,
721          * like Ekiga does during its startup, can crash the webcam
722          */
723         mdelay(100);
724         err = 0;
725
726 out:
727         mutex_unlock(&cam->lock);
728         return err;
729 }
730
731
732 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
733 {
734         void *pos;
735         unsigned long start = vma->vm_start;
736         unsigned long size = vma->vm_end - vma->vm_start;
737         struct video_device *vdev = video_devdata(file);
738         struct zr364xx_camera *cam;
739
740         DBG("zr364xx_mmap: %ld\n", size);
741
742         if (vdev == NULL)
743                 return -ENODEV;
744         cam = video_get_drvdata(vdev);
745
746         pos = cam->framebuf;
747         while (size > 0) {
748                 if (vm_insert_page(vma, start, vmalloc_to_page(pos)))
749                         return -EAGAIN;
750                 start += PAGE_SIZE;
751                 pos += PAGE_SIZE;
752                 if (size > PAGE_SIZE)
753                         size -= PAGE_SIZE;
754                 else
755                         size = 0;
756         }
757
758         return 0;
759 }
760
761
762 static const struct file_operations zr364xx_fops = {
763         .owner = THIS_MODULE,
764         .open = zr364xx_open,
765         .release = zr364xx_release,
766         .read = zr364xx_read,
767         .mmap = zr364xx_mmap,
768         .ioctl = video_ioctl2,
769         .llseek = no_llseek,
770 };
771
772 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
773         .vidioc_querycap        = zr364xx_vidioc_querycap,
774         .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
775         .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
776         .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
777         .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
778         .vidioc_enum_input      = zr364xx_vidioc_enum_input,
779         .vidioc_g_input         = zr364xx_vidioc_g_input,
780         .vidioc_s_input         = zr364xx_vidioc_s_input,
781         .vidioc_streamon        = zr364xx_vidioc_streamon,
782         .vidioc_streamoff       = zr364xx_vidioc_streamoff,
783         .vidioc_queryctrl       = zr364xx_vidioc_queryctrl,
784         .vidioc_g_ctrl          = zr364xx_vidioc_g_ctrl,
785         .vidioc_s_ctrl          = zr364xx_vidioc_s_ctrl,
786 };
787
788 static struct video_device zr364xx_template = {
789         .name = DRIVER_DESC,
790         .fops = &zr364xx_fops,
791         .ioctl_ops = &zr364xx_ioctl_ops,
792         .release = video_device_release,
793         .minor = -1,
794 };
795
796
797
798 /*******************/
799 /* USB integration */
800 /*******************/
801
802 static int zr364xx_probe(struct usb_interface *intf,
803                          const struct usb_device_id *id)
804 {
805         struct usb_device *udev = interface_to_usbdev(intf);
806         struct zr364xx_camera *cam = NULL;
807         int err;
808
809         DBG("probing...");
810
811         info(DRIVER_DESC " compatible webcam plugged");
812         info("model %04x:%04x detected", udev->descriptor.idVendor,
813              udev->descriptor.idProduct);
814
815         cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
816         if (cam == NULL) {
817                 info("cam: out of memory !");
818                 return -ENOMEM;
819         }
820         /* save the init method used by this camera */
821         cam->method = id->driver_info;
822
823         cam->vdev = video_device_alloc();
824         if (cam->vdev == NULL) {
825                 info("cam->vdev: out of memory !");
826                 kfree(cam);
827                 return -ENOMEM;
828         }
829         memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
830         video_set_drvdata(cam->vdev, cam);
831         if (debug)
832                 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
833
834         cam->udev = udev;
835
836         if ((cam->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)) == NULL) {
837                 info("cam->buffer: out of memory !");
838                 video_device_release(cam->vdev);
839                 kfree(cam);
840                 return -ENODEV;
841         }
842
843         switch (mode) {
844         case 1:
845                 info("160x120 mode selected");
846                 cam->width = 160;
847                 cam->height = 120;
848                 break;
849         case 2:
850                 info("640x480 mode selected");
851                 cam->width = 640;
852                 cam->height = 480;
853                 break;
854         default:
855                 info("320x240 mode selected");
856                 cam->width = 320;
857                 cam->height = 240;
858                 break;
859         }
860
861         m0d1[0] = mode;
862         m1[2].value = 0xf000 + mode;
863         m2[1].value = 0xf000 + mode;
864         header2[437] = cam->height / 256;
865         header2[438] = cam->height % 256;
866         header2[439] = cam->width / 256;
867         header2[440] = cam->width % 256;
868
869         cam->nb = 0;
870         cam->brightness = 64;
871         mutex_init(&cam->lock);
872
873         err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
874         if (err) {
875                 info("video_register_device failed");
876                 video_device_release(cam->vdev);
877                 kfree(cam->buffer);
878                 kfree(cam);
879                 return err;
880         }
881
882         usb_set_intfdata(intf, cam);
883
884         info(DRIVER_DESC " controlling video device %d", cam->vdev->minor);
885         return 0;
886 }
887
888
889 static void zr364xx_disconnect(struct usb_interface *intf)
890 {
891         struct zr364xx_camera *cam = usb_get_intfdata(intf);
892         usb_set_intfdata(intf, NULL);
893         dev_set_drvdata(&intf->dev, NULL);
894         info(DRIVER_DESC " webcam unplugged");
895         if (cam->vdev)
896                 video_unregister_device(cam->vdev);
897         cam->vdev = NULL;
898         kfree(cam->buffer);
899         if (cam->framebuf)
900                 vfree(cam->framebuf);
901         kfree(cam);
902 }
903
904
905
906 /**********************/
907 /* Module integration */
908 /**********************/
909
910 static struct usb_driver zr364xx_driver = {
911         .name = "zr364xx",
912         .probe = zr364xx_probe,
913         .disconnect = zr364xx_disconnect,
914         .id_table = device_table
915 };
916
917
918 static int __init zr364xx_init(void)
919 {
920         int retval;
921         retval = usb_register(&zr364xx_driver);
922         if (retval)
923                 info("usb_register failed!");
924         else
925                 info(DRIVER_DESC " module loaded");
926         return retval;
927 }
928
929
930 static void __exit zr364xx_exit(void)
931 {
932         info(DRIVER_DESC " module unloaded");
933         usb_deregister(&zr364xx_driver);
934 }
935
936
937 module_init(zr364xx_init);
938 module_exit(zr364xx_exit);
939
940 MODULE_AUTHOR(DRIVER_AUTHOR);
941 MODULE_DESCRIPTION(DRIVER_DESC);
942 MODULE_LICENSE("GPL");