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