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