Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[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) printk(KERN_INFO KBUILD_MODNAME 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                 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         memset(cap, 0, sizeof(*cap));
429         strcpy(cap->driver, DRIVER_DESC);
430         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
431         return 0;
432 }
433
434 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
435                                      struct v4l2_input *i)
436 {
437         if (i->index != 0)
438                 return -EINVAL;
439         memset(i, 0, sizeof(*i));
440         i->index = 0;
441         strcpy(i->name, DRIVER_DESC " Camera");
442         i->type = V4L2_INPUT_TYPE_CAMERA;
443         return 0;
444 }
445
446 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
447                                   unsigned int *i)
448 {
449         *i = 0;
450         return 0;
451 }
452
453 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
454                                   unsigned int i)
455 {
456         if (i != 0)
457                 return -EINVAL;
458         return 0;
459 }
460
461 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
462                                     struct v4l2_queryctrl *c)
463 {
464         struct video_device *vdev = video_devdata(file);
465         struct zr364xx_camera *cam;
466
467         if (vdev == NULL)
468                 return -ENODEV;
469         cam = video_get_drvdata(vdev);
470
471         switch (c->id) {
472         case V4L2_CID_BRIGHTNESS:
473                 c->type = V4L2_CTRL_TYPE_INTEGER;
474                 strcpy(c->name, "Brightness");
475                 c->minimum = 0;
476                 c->maximum = 127;
477                 c->step = 1;
478                 c->default_value = cam->brightness;
479                 c->flags = 0;
480                 break;
481         default:
482                 return -EINVAL;
483         }
484         return 0;
485 }
486
487 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
488                                  struct v4l2_control *c)
489 {
490         struct video_device *vdev = video_devdata(file);
491         struct zr364xx_camera *cam;
492
493         if (vdev == NULL)
494                 return -ENODEV;
495         cam = video_get_drvdata(vdev);
496
497         switch (c->id) {
498         case V4L2_CID_BRIGHTNESS:
499                 cam->brightness = c->value;
500                 break;
501         default:
502                 return -EINVAL;
503         }
504         return 0;
505 }
506
507 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
508                                  struct v4l2_control *c)
509 {
510         struct video_device *vdev = video_devdata(file);
511         struct zr364xx_camera *cam;
512
513         if (vdev == NULL)
514                 return -ENODEV;
515         cam = video_get_drvdata(vdev);
516
517         switch (c->id) {
518         case V4L2_CID_BRIGHTNESS:
519                 c->value = cam->brightness;
520                 break;
521         default:
522                 return -EINVAL;
523         }
524         return 0;
525 }
526
527 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
528                                        void *priv, struct v4l2_fmtdesc *f)
529 {
530         if (f->index > 0)
531                 return -EINVAL;
532         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
533                 return -EINVAL;
534         memset(f, 0, sizeof(*f));
535         f->index = 0;
536         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
537         f->flags = V4L2_FMT_FLAG_COMPRESSED;
538         strcpy(f->description, "JPEG");
539         f->pixelformat = V4L2_PIX_FMT_JPEG;
540         return 0;
541 }
542
543 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
544                                       struct v4l2_format *f)
545 {
546         struct video_device *vdev = video_devdata(file);
547         struct zr364xx_camera *cam;
548
549         if (vdev == NULL)
550                 return -ENODEV;
551         cam = video_get_drvdata(vdev);
552
553         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
554                 return -EINVAL;
555         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
556                 return -EINVAL;
557         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
558             f->fmt.pix.field != V4L2_FIELD_NONE)
559                 return -EINVAL;
560         f->fmt.pix.field = V4L2_FIELD_NONE;
561         f->fmt.pix.width = cam->width;
562         f->fmt.pix.height = cam->height;
563         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
564         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
565         f->fmt.pix.colorspace = 0;
566         f->fmt.pix.priv = 0;
567         return 0;
568 }
569
570 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
571                                     struct v4l2_format *f)
572 {
573         struct video_device *vdev = video_devdata(file);
574         struct zr364xx_camera *cam;
575
576         if (vdev == NULL)
577                 return -ENODEV;
578         cam = video_get_drvdata(vdev);
579
580         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
581                 return -EINVAL;
582         memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
583         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
584         f->fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
585         f->fmt.pix.field = V4L2_FIELD_NONE;
586         f->fmt.pix.width = cam->width;
587         f->fmt.pix.height = cam->height;
588         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
589         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
590         f->fmt.pix.colorspace = 0;
591         f->fmt.pix.priv = 0;
592         return 0;
593 }
594
595 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
596                                     struct v4l2_format *f)
597 {
598         struct video_device *vdev = video_devdata(file);
599         struct zr364xx_camera *cam;
600
601         if (vdev == NULL)
602                 return -ENODEV;
603         cam = video_get_drvdata(vdev);
604
605         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
606                 return -EINVAL;
607         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
608                 return -EINVAL;
609         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
610             f->fmt.pix.field != V4L2_FIELD_NONE)
611                 return -EINVAL;
612         f->fmt.pix.field = V4L2_FIELD_NONE;
613         f->fmt.pix.width = cam->width;
614         f->fmt.pix.height = cam->height;
615         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
616         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
617         f->fmt.pix.colorspace = 0;
618         f->fmt.pix.priv = 0;
619         DBG("ok!");
620         return 0;
621 }
622
623 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
624                                    enum v4l2_buf_type type)
625 {
626         return 0;
627 }
628
629 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
630                                     enum v4l2_buf_type type)
631 {
632         return 0;
633 }
634
635
636 /* open the camera */
637 static int zr364xx_open(struct file *file)
638 {
639         struct video_device *vdev = video_devdata(file);
640         struct zr364xx_camera *cam = video_get_drvdata(vdev);
641         struct usb_device *udev = cam->udev;
642         int i, err;
643
644         DBG("zr364xx_open");
645
646         mutex_lock(&cam->lock);
647
648         if (cam->users) {
649                 err = -EBUSY;
650                 goto out;
651         }
652
653         if (!cam->framebuf) {
654                 cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
655                 if (!cam->framebuf) {
656                         dev_err(&cam->udev->dev, "vmalloc_32 failed!\n");
657                         err = -ENOMEM;
658                         goto out;
659                 }
660         }
661
662         for (i = 0; init[cam->method][i].size != -1; i++) {
663                 err =
664                     send_control_msg(udev, 1, init[cam->method][i].value,
665                                      0, init[cam->method][i].bytes,
666                                      init[cam->method][i].size);
667                 if (err < 0) {
668                         dev_err(&cam->udev->dev,
669                                 "error during open sequence: %d\n", i);
670                         goto out;
671                 }
672         }
673
674         cam->skip = 2;
675         cam->users++;
676         file->private_data = vdev;
677
678         /* Added some delay here, since opening/closing the camera quickly,
679          * like Ekiga does during its startup, can crash the webcam
680          */
681         mdelay(100);
682         err = 0;
683
684 out:
685         mutex_unlock(&cam->lock);
686         return err;
687 }
688
689
690 /* release the camera */
691 static int zr364xx_release(struct file *file)
692 {
693         struct video_device *vdev = video_devdata(file);
694         struct zr364xx_camera *cam;
695         struct usb_device *udev;
696         int i, err;
697
698         DBG("zr364xx_release");
699
700         if (vdev == NULL)
701                 return -ENODEV;
702         cam = video_get_drvdata(vdev);
703
704         udev = cam->udev;
705
706         mutex_lock(&cam->lock);
707
708         cam->users--;
709         file->private_data = NULL;
710
711         for (i = 0; i < 2; i++) {
712                 err =
713                     send_control_msg(udev, 1, init[cam->method][i].value,
714                                      0, init[i][cam->method].bytes,
715                                      init[cam->method][i].size);
716                 if (err < 0) {
717                         dev_err(&udev->dev, "error during release sequence\n");
718                         goto out;
719                 }
720         }
721
722         /* Added some delay here, since opening/closing the camera quickly,
723          * like Ekiga does during its startup, can crash the webcam
724          */
725         mdelay(100);
726         err = 0;
727
728 out:
729         mutex_unlock(&cam->lock);
730         return err;
731 }
732
733
734 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
735 {
736         void *pos;
737         unsigned long start = vma->vm_start;
738         unsigned long size = vma->vm_end - vma->vm_start;
739         struct video_device *vdev = video_devdata(file);
740         struct zr364xx_camera *cam;
741
742         DBG("zr364xx_mmap: %ld\n", size);
743
744         if (vdev == NULL)
745                 return -ENODEV;
746         cam = video_get_drvdata(vdev);
747
748         pos = cam->framebuf;
749         while (size > 0) {
750                 if (vm_insert_page(vma, start, vmalloc_to_page(pos)))
751                         return -EAGAIN;
752                 start += PAGE_SIZE;
753                 pos += PAGE_SIZE;
754                 if (size > PAGE_SIZE)
755                         size -= PAGE_SIZE;
756                 else
757                         size = 0;
758         }
759
760         return 0;
761 }
762
763
764 static const struct v4l2_file_operations zr364xx_fops = {
765         .owner = THIS_MODULE,
766         .open = zr364xx_open,
767         .release = zr364xx_release,
768         .read = zr364xx_read,
769         .mmap = zr364xx_mmap,
770         .ioctl = video_ioctl2,
771 };
772
773 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
774         .vidioc_querycap        = zr364xx_vidioc_querycap,
775         .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
776         .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
777         .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
778         .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
779         .vidioc_enum_input      = zr364xx_vidioc_enum_input,
780         .vidioc_g_input         = zr364xx_vidioc_g_input,
781         .vidioc_s_input         = zr364xx_vidioc_s_input,
782         .vidioc_streamon        = zr364xx_vidioc_streamon,
783         .vidioc_streamoff       = zr364xx_vidioc_streamoff,
784         .vidioc_queryctrl       = zr364xx_vidioc_queryctrl,
785         .vidioc_g_ctrl          = zr364xx_vidioc_g_ctrl,
786         .vidioc_s_ctrl          = zr364xx_vidioc_s_ctrl,
787 };
788
789 static struct video_device zr364xx_template = {
790         .name = DRIVER_DESC,
791         .fops = &zr364xx_fops,
792         .ioctl_ops = &zr364xx_ioctl_ops,
793         .release = video_device_release,
794         .minor = -1,
795 };
796
797
798
799 /*******************/
800 /* USB integration */
801 /*******************/
802
803 static int zr364xx_probe(struct usb_interface *intf,
804                          const struct usb_device_id *id)
805 {
806         struct usb_device *udev = interface_to_usbdev(intf);
807         struct zr364xx_camera *cam = NULL;
808         int err;
809
810         DBG("probing...");
811
812         dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
813         dev_info(&intf->dev, "model %04x:%04x detected\n",
814                  le16_to_cpu(udev->descriptor.idVendor),
815                  le16_to_cpu(udev->descriptor.idProduct));
816
817         cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
818         if (cam == NULL) {
819                 dev_err(&udev->dev, "cam: out of memory !\n");
820                 return -ENOMEM;
821         }
822         /* save the init method used by this camera */
823         cam->method = id->driver_info;
824
825         cam->vdev = video_device_alloc();
826         if (cam->vdev == NULL) {
827                 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
828                 kfree(cam);
829                 return -ENOMEM;
830         }
831         memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
832         video_set_drvdata(cam->vdev, cam);
833         if (debug)
834                 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
835
836         cam->udev = udev;
837
838         if ((cam->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)) == NULL) {
839                 dev_info(&udev->dev, "cam->buffer: out of memory !\n");
840                 video_device_release(cam->vdev);
841                 kfree(cam);
842                 return -ENODEV;
843         }
844
845         switch (mode) {
846         case 1:
847                 dev_info(&udev->dev, "160x120 mode selected\n");
848                 cam->width = 160;
849                 cam->height = 120;
850                 break;
851         case 2:
852                 dev_info(&udev->dev, "640x480 mode selected\n");
853                 cam->width = 640;
854                 cam->height = 480;
855                 break;
856         default:
857                 dev_info(&udev->dev, "320x240 mode selected\n");
858                 cam->width = 320;
859                 cam->height = 240;
860                 break;
861         }
862
863         m0d1[0] = mode;
864         m1[2].value = 0xf000 + mode;
865         m2[1].value = 0xf000 + mode;
866         header2[437] = cam->height / 256;
867         header2[438] = cam->height % 256;
868         header2[439] = cam->width / 256;
869         header2[440] = cam->width % 256;
870
871         cam->nb = 0;
872         cam->brightness = 64;
873         mutex_init(&cam->lock);
874
875         err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
876         if (err) {
877                 dev_err(&udev->dev, "video_register_device failed\n");
878                 video_device_release(cam->vdev);
879                 kfree(cam->buffer);
880                 kfree(cam);
881                 return err;
882         }
883
884         usb_set_intfdata(intf, cam);
885
886         dev_info(&udev->dev, DRIVER_DESC " controlling video device %d\n",
887                  cam->vdev->num);
888         return 0;
889 }
890
891
892 static void zr364xx_disconnect(struct usb_interface *intf)
893 {
894         struct zr364xx_camera *cam = usb_get_intfdata(intf);
895         usb_set_intfdata(intf, NULL);
896         dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
897         if (cam->vdev)
898                 video_unregister_device(cam->vdev);
899         cam->vdev = NULL;
900         kfree(cam->buffer);
901         if (cam->framebuf)
902                 vfree(cam->framebuf);
903         kfree(cam);
904 }
905
906
907
908 /**********************/
909 /* Module integration */
910 /**********************/
911
912 static struct usb_driver zr364xx_driver = {
913         .name = "zr364xx",
914         .probe = zr364xx_probe,
915         .disconnect = zr364xx_disconnect,
916         .id_table = device_table
917 };
918
919
920 static int __init zr364xx_init(void)
921 {
922         int retval;
923         retval = usb_register(&zr364xx_driver);
924         if (retval)
925                 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
926         else
927                 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
928         return retval;
929 }
930
931
932 static void __exit zr364xx_exit(void)
933 {
934         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
935         usb_deregister(&zr364xx_driver);
936 }
937
938
939 module_init(zr364xx_init);
940 module_exit(zr364xx_exit);
941
942 MODULE_AUTHOR(DRIVER_AUTHOR);
943 MODULE_DESCRIPTION(DRIVER_DESC);
944 MODULE_LICENSE("GPL");