treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / media / usb / zr364xx / zr364xx.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Zoran 364xx based USB webcam module version 0.73
4  *
5  * Allows you to use your USB webcam with V4L2 applications
6  * This is still in heavy development !
7  *
8  * Copyright (C) 2004  Antoine Jacquet <royale@zerezo.com>
9  * http://royale.zerezo.com/zr364xx/
10  *
11  * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
12  * V4L2 version inspired by meye.c driver
13  *
14  * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
15  */
16
17
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/usb.h>
21 #include <linux/vmalloc.h>
22 #include <linux/slab.h>
23 #include <linux/proc_fs.h>
24 #include <linux/highmem.h>
25 #include <media/v4l2-common.h>
26 #include <media/v4l2-ioctl.h>
27 #include <media/v4l2-device.h>
28 #include <media/v4l2-ctrls.h>
29 #include <media/v4l2-fh.h>
30 #include <media/v4l2-event.h>
31 #include <media/videobuf-vmalloc.h>
32
33
34 /* Version Information */
35 #define DRIVER_VERSION "0.7.4"
36 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
37 #define DRIVER_DESC "Zoran 364xx"
38
39
40 /* Camera */
41 #define FRAMES 1
42 #define MAX_FRAME_SIZE 200000
43 #define BUFFER_SIZE 0x1000
44 #define CTRL_TIMEOUT 500
45
46 #define ZR364XX_DEF_BUFS        4
47 #define ZR364XX_READ_IDLE       0
48 #define ZR364XX_READ_FRAME      1
49
50 /* Debug macro */
51 #define DBG(fmt, args...) \
52         do { \
53                 if (debug) { \
54                         printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
55                 } \
56         } while (0)
57
58 /*#define FULL_DEBUG 1*/
59 #ifdef FULL_DEBUG
60 #define _DBG DBG
61 #else
62 #define _DBG(fmt, args...)
63 #endif
64
65 /* Init methods, need to find nicer names for these
66  * the exact names of the chipsets would be the best if someone finds it */
67 #define METHOD0 0
68 #define METHOD1 1
69 #define METHOD2 2
70 #define METHOD3 3
71
72
73 /* Module parameters */
74 static int debug;
75 static int mode;
76
77
78 /* Module parameters interface */
79 module_param(debug, int, 0644);
80 MODULE_PARM_DESC(debug, "Debug level");
81 module_param(mode, int, 0644);
82 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
83
84
85 /* Devices supported by this driver
86  * .driver_info contains the init method used by the camera */
87 static const struct usb_device_id device_table[] = {
88         {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
89         {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
90         {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
91         {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
92         {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
93         {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
94         {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
95         {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
96         {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
97         {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
98         {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
99         {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
100         {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
101         {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
102         {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
103         {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
104         {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
105         {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
106         {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
107         {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 },
108         {USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 },
109         {}                      /* Terminating entry */
110 };
111
112 MODULE_DEVICE_TABLE(usb, device_table);
113
114 /* frame structure */
115 struct zr364xx_framei {
116         unsigned long ulState;  /* ulState:ZR364XX_READ_IDLE,
117                                            ZR364XX_READ_FRAME */
118         void *lpvbits;          /* image data */
119         unsigned long cur_size; /* current data copied to it */
120 };
121
122 /* image buffer structure */
123 struct zr364xx_bufferi {
124         unsigned long dwFrames;                 /* number of frames in buffer */
125         struct zr364xx_framei frame[FRAMES];    /* array of FRAME structures */
126 };
127
128 struct zr364xx_dmaqueue {
129         struct list_head        active;
130         struct zr364xx_camera   *cam;
131 };
132
133 struct zr364xx_pipeinfo {
134         u32 transfer_size;
135         u8 *transfer_buffer;
136         u32 state;
137         void *stream_urb;
138         void *cam;      /* back pointer to zr364xx_camera struct */
139         u32 err_count;
140         u32 idx;
141 };
142
143 struct zr364xx_fmt {
144         char *name;
145         u32 fourcc;
146         int depth;
147 };
148
149 /* image formats.  */
150 static const struct zr364xx_fmt formats[] = {
151         {
152                 .name = "JPG",
153                 .fourcc = V4L2_PIX_FMT_JPEG,
154                 .depth = 24
155         }
156 };
157
158 /* Camera stuff */
159 struct zr364xx_camera {
160         struct usb_device *udev;        /* save off the usb device pointer */
161         struct usb_interface *interface;/* the interface for this device */
162         struct v4l2_device v4l2_dev;
163         struct v4l2_ctrl_handler ctrl_handler;
164         struct video_device vdev;       /* v4l video device */
165         struct v4l2_fh *owner;          /* owns the streaming */
166         int nb;
167         struct zr364xx_bufferi          buffer;
168         int skip;
169         int width;
170         int height;
171         int method;
172         struct mutex lock;
173
174         spinlock_t              slock;
175         struct zr364xx_dmaqueue vidq;
176         int                     last_frame;
177         int                     cur_frame;
178         unsigned long           frame_count;
179         int                     b_acquire;
180         struct zr364xx_pipeinfo pipe[1];
181
182         u8                      read_endpoint;
183
184         const struct zr364xx_fmt *fmt;
185         struct videobuf_queue   vb_vidq;
186         bool was_streaming;
187 };
188
189 /* buffer for one video frame */
190 struct zr364xx_buffer {
191         /* common v4l buffer stuff -- must be first */
192         struct videobuf_buffer vb;
193         const struct zr364xx_fmt *fmt;
194 };
195
196 /* function used to send initialisation commands to the camera */
197 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
198                             u16 index, unsigned char *cp, u16 size)
199 {
200         int status;
201
202         unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
203         if (!transfer_buffer)
204                 return -ENOMEM;
205
206         memcpy(transfer_buffer, cp, size);
207
208         status = usb_control_msg(udev,
209                                  usb_sndctrlpipe(udev, 0),
210                                  request,
211                                  USB_DIR_OUT | USB_TYPE_VENDOR |
212                                  USB_RECIP_DEVICE, value, index,
213                                  transfer_buffer, size, CTRL_TIMEOUT);
214
215         kfree(transfer_buffer);
216         return status;
217 }
218
219
220 /* Control messages sent to the camera to initialize it
221  * and launch the capture */
222 typedef struct {
223         unsigned int value;
224         unsigned int size;
225         unsigned char *bytes;
226 } message;
227
228 /* method 0 */
229 static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
230 static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
231 static unsigned char m0d3[] = { 0, 0 };
232 static message m0[] = {
233         {0x1f30, 0, NULL},
234         {0xd000, 0, NULL},
235         {0x3370, sizeof(m0d1), m0d1},
236         {0x2000, 0, NULL},
237         {0x2f0f, 0, NULL},
238         {0x2610, sizeof(m0d2), m0d2},
239         {0xe107, 0, NULL},
240         {0x2502, 0, NULL},
241         {0x1f70, 0, NULL},
242         {0xd000, 0, NULL},
243         {0x9a01, sizeof(m0d3), m0d3},
244         {-1, -1, NULL}
245 };
246
247 /* method 1 */
248 static unsigned char m1d1[] = { 0xff, 0xff };
249 static unsigned char m1d2[] = { 0x00, 0x00 };
250 static message m1[] = {
251         {0x1f30, 0, NULL},
252         {0xd000, 0, NULL},
253         {0xf000, 0, NULL},
254         {0x2000, 0, NULL},
255         {0x2f0f, 0, NULL},
256         {0x2650, 0, NULL},
257         {0xe107, 0, NULL},
258         {0x2502, sizeof(m1d1), m1d1},
259         {0x1f70, 0, NULL},
260         {0xd000, 0, NULL},
261         {0xd000, 0, NULL},
262         {0xd000, 0, NULL},
263         {0x9a01, sizeof(m1d2), m1d2},
264         {-1, -1, NULL}
265 };
266
267 /* method 2 */
268 static unsigned char m2d1[] = { 0xff, 0xff };
269 static message m2[] = {
270         {0x1f30, 0, NULL},
271         {0xf000, 0, NULL},
272         {0x2000, 0, NULL},
273         {0x2f0f, 0, NULL},
274         {0x2650, 0, NULL},
275         {0xe107, 0, NULL},
276         {0x2502, sizeof(m2d1), m2d1},
277         {0x1f70, 0, NULL},
278         {-1, -1, NULL}
279 };
280
281 /* init table */
282 static message *init[4] = { m0, m1, m2, m2 };
283
284
285 /* JPEG static data in header (Huffman table, etc) */
286 static unsigned char header1[] = {
287         0xFF, 0xD8,
288         /*
289         0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
290         0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
291         */
292         0xFF, 0xDB, 0x00, 0x84
293 };
294 static unsigned char header2[] = {
295         0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
296         0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
297         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
298         0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
299         0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
300         0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
301         0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
302         0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
303         0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
304         0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
305         0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
306         0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
307         0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
308         0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
309         0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
310         0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
311         0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
312         0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
313         0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
314         0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
315         0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
316         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
317         0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
318         0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
319         0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
320         0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
321         0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
322         0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
323         0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
324         0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
325         0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
326         0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
327         0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
328         0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
329         0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
330         0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
331         0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
332         0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
333         0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
334         0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
335         0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
336         0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
337         0x00, 0x3F, 0x00
338 };
339 static unsigned char header3;
340
341 /* ------------------------------------------------------------------
342    Videobuf operations
343    ------------------------------------------------------------------*/
344
345 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
346                         unsigned int *size)
347 {
348         struct zr364xx_camera *cam = vq->priv_data;
349
350         *size = cam->width * cam->height * (cam->fmt->depth >> 3);
351
352         if (*count == 0)
353                 *count = ZR364XX_DEF_BUFS;
354
355         if (*size * *count > ZR364XX_DEF_BUFS * 1024 * 1024)
356                 *count = (ZR364XX_DEF_BUFS * 1024 * 1024) / *size;
357
358         return 0;
359 }
360
361 static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
362 {
363         _DBG("%s\n", __func__);
364
365         BUG_ON(in_interrupt());
366
367         videobuf_vmalloc_free(&buf->vb);
368         buf->vb.state = VIDEOBUF_NEEDS_INIT;
369 }
370
371 static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
372                           enum v4l2_field field)
373 {
374         struct zr364xx_camera *cam = vq->priv_data;
375         struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
376                                                   vb);
377         int rc;
378
379         DBG("%s, field=%d, fmt name = %s\n", __func__, field,
380             cam->fmt ? cam->fmt->name : "");
381         if (!cam->fmt)
382                 return -EINVAL;
383
384         buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
385
386         if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
387                 DBG("invalid buffer prepare\n");
388                 return -EINVAL;
389         }
390
391         buf->fmt = cam->fmt;
392         buf->vb.width = cam->width;
393         buf->vb.height = cam->height;
394         buf->vb.field = field;
395
396         if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
397                 rc = videobuf_iolock(vq, &buf->vb, NULL);
398                 if (rc < 0)
399                         goto fail;
400         }
401
402         buf->vb.state = VIDEOBUF_PREPARED;
403         return 0;
404 fail:
405         free_buffer(vq, buf);
406         return rc;
407 }
408
409 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
410 {
411         struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
412                                                   vb);
413         struct zr364xx_camera *cam = vq->priv_data;
414
415         _DBG("%s\n", __func__);
416
417         buf->vb.state = VIDEOBUF_QUEUED;
418         list_add_tail(&buf->vb.queue, &cam->vidq.active);
419 }
420
421 static void buffer_release(struct videobuf_queue *vq,
422                            struct videobuf_buffer *vb)
423 {
424         struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
425                                                   vb);
426
427         _DBG("%s\n", __func__);
428         free_buffer(vq, buf);
429 }
430
431 static const struct videobuf_queue_ops zr364xx_video_qops = {
432         .buf_setup = buffer_setup,
433         .buf_prepare = buffer_prepare,
434         .buf_queue = buffer_queue,
435         .buf_release = buffer_release,
436 };
437
438 /********************/
439 /* V4L2 integration */
440 /********************/
441 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
442                                    enum v4l2_buf_type type);
443
444 static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
445                             loff_t * ppos)
446 {
447         struct zr364xx_camera *cam = video_drvdata(file);
448         int err = 0;
449
450         _DBG("%s\n", __func__);
451
452         if (!buf)
453                 return -EINVAL;
454
455         if (!count)
456                 return -EINVAL;
457
458         if (mutex_lock_interruptible(&cam->lock))
459                 return -ERESTARTSYS;
460
461         err = zr364xx_vidioc_streamon(file, file->private_data,
462                                 V4L2_BUF_TYPE_VIDEO_CAPTURE);
463         if (err == 0) {
464                 DBG("%s: reading %d bytes at pos %d.\n", __func__,
465                                 (int) count, (int) *ppos);
466
467                 /* NoMan Sux ! */
468                 err = videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
469                                         file->f_flags & O_NONBLOCK);
470         }
471         mutex_unlock(&cam->lock);
472         return err;
473 }
474
475 /* video buffer vmalloc implementation based partly on VIVI driver which is
476  *          Copyright (c) 2006 by
477  *                  Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
478  *                  Ted Walther <ted--a.t--enumera.com>
479  *                  John Sokol <sokol--a.t--videotechnology.com>
480  *                  http://v4l.videotechnology.com/
481  *
482  */
483 static void zr364xx_fillbuff(struct zr364xx_camera *cam,
484                              struct zr364xx_buffer *buf,
485                              int jpgsize)
486 {
487         int pos = 0;
488         const char *tmpbuf;
489         char *vbuf = videobuf_to_vmalloc(&buf->vb);
490         unsigned long last_frame;
491
492         if (!vbuf)
493                 return;
494
495         last_frame = cam->last_frame;
496         if (last_frame != -1) {
497                 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
498                 switch (buf->fmt->fourcc) {
499                 case V4L2_PIX_FMT_JPEG:
500                         buf->vb.size = jpgsize;
501                         memcpy(vbuf, tmpbuf, buf->vb.size);
502                         break;
503                 default:
504                         printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
505                 }
506                 cam->last_frame = -1;
507         } else {
508                 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
509                 return;
510         }
511         DBG("%s: Buffer %p size= %d\n", __func__, vbuf, pos);
512         /* tell v4l buffer was filled */
513
514         buf->vb.field_count = cam->frame_count * 2;
515         buf->vb.ts = ktime_get_ns();
516         buf->vb.state = VIDEOBUF_DONE;
517 }
518
519 static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
520 {
521         struct zr364xx_dmaqueue *dma_q = &cam->vidq;
522         struct zr364xx_buffer *buf;
523         unsigned long flags = 0;
524         int rc = 0;
525
526         DBG("wakeup: %p\n", &dma_q);
527         spin_lock_irqsave(&cam->slock, flags);
528
529         if (list_empty(&dma_q->active)) {
530                 DBG("No active queue to serve\n");
531                 rc = -1;
532                 goto unlock;
533         }
534         buf = list_entry(dma_q->active.next,
535                          struct zr364xx_buffer, vb.queue);
536
537         if (!waitqueue_active(&buf->vb.done)) {
538                 /* no one active */
539                 rc = -1;
540                 goto unlock;
541         }
542         list_del(&buf->vb.queue);
543         buf->vb.ts = ktime_get_ns();
544         DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
545         zr364xx_fillbuff(cam, buf, jpgsize);
546         wake_up(&buf->vb.done);
547         DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
548 unlock:
549         spin_unlock_irqrestore(&cam->slock, flags);
550         return rc;
551 }
552
553 /* this function moves the usb stream read pipe data
554  * into the system buffers.
555  * returns 0 on success, EAGAIN if more data to process (call this
556  * function again).
557  */
558 static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
559                                         struct zr364xx_pipeinfo *pipe_info,
560                                         struct urb *purb)
561 {
562         unsigned char *pdest;
563         unsigned char *psrc;
564         s32 idx = -1;
565         struct zr364xx_framei *frm;
566         int i = 0;
567         unsigned char *ptr = NULL;
568
569         _DBG("buffer to user\n");
570         idx = cam->cur_frame;
571         frm = &cam->buffer.frame[idx];
572
573         /* swap bytes if camera needs it */
574         if (cam->method == METHOD0) {
575                 u16 *buf = (u16 *)pipe_info->transfer_buffer;
576                 for (i = 0; i < purb->actual_length/2; i++)
577                         swab16s(buf + i);
578         }
579
580         /* search done.  now find out if should be acquiring */
581         if (!cam->b_acquire) {
582                 /* we found a frame, but this channel is turned off */
583                 frm->ulState = ZR364XX_READ_IDLE;
584                 return -EINVAL;
585         }
586
587         psrc = (u8 *)pipe_info->transfer_buffer;
588         ptr = pdest = frm->lpvbits;
589
590         if (frm->ulState == ZR364XX_READ_IDLE) {
591                 if (purb->actual_length < 128) {
592                         /* header incomplete */
593                         dev_info(&cam->udev->dev,
594                                  "%s: buffer (%d bytes) too small to hold jpeg header. Discarding.\n",
595                                  __func__, purb->actual_length);
596                         return -EINVAL;
597                 }
598
599                 frm->ulState = ZR364XX_READ_FRAME;
600                 frm->cur_size = 0;
601
602                 _DBG("jpeg header, ");
603                 memcpy(ptr, header1, sizeof(header1));
604                 ptr += sizeof(header1);
605                 header3 = 0;
606                 memcpy(ptr, &header3, 1);
607                 ptr++;
608                 memcpy(ptr, psrc, 64);
609                 ptr += 64;
610                 header3 = 1;
611                 memcpy(ptr, &header3, 1);
612                 ptr++;
613                 memcpy(ptr, psrc + 64, 64);
614                 ptr += 64;
615                 memcpy(ptr, header2, sizeof(header2));
616                 ptr += sizeof(header2);
617                 memcpy(ptr, psrc + 128,
618                        purb->actual_length - 128);
619                 ptr += purb->actual_length - 128;
620                 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
621                     psrc[0], psrc[1], psrc[2],
622                     psrc[3], psrc[4], psrc[5],
623                     psrc[6], psrc[7], psrc[8]);
624                 frm->cur_size = ptr - pdest;
625         } else {
626                 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
627                         dev_info(&cam->udev->dev,
628                                  "%s: buffer (%d bytes) too small to hold frame data. Discarding frame data.\n",
629                                  __func__, MAX_FRAME_SIZE);
630                 } else {
631                         pdest += frm->cur_size;
632                         memcpy(pdest, psrc, purb->actual_length);
633                         frm->cur_size += purb->actual_length;
634                 }
635         }
636         /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
637                 purb->actual_length);*/
638
639         if (purb->actual_length < pipe_info->transfer_size) {
640                 _DBG("****************Buffer[%d]full*************\n", idx);
641                 cam->last_frame = cam->cur_frame;
642                 cam->cur_frame++;
643                 /* end of system frame ring buffer, start at zero */
644                 if (cam->cur_frame == cam->buffer.dwFrames)
645                         cam->cur_frame = 0;
646
647                 /* frame ready */
648                 /* go back to find the JPEG EOI marker */
649                 ptr = pdest = frm->lpvbits;
650                 ptr += frm->cur_size - 2;
651                 while (ptr > pdest) {
652                         if (*ptr == 0xFF && *(ptr + 1) == 0xD9
653                             && *(ptr + 2) == 0xFF)
654                                 break;
655                         ptr--;
656                 }
657                 if (ptr == pdest)
658                         DBG("No EOI marker\n");
659
660                 /* Sometimes there is junk data in the middle of the picture,
661                  * we want to skip this bogus frames */
662                 while (ptr > pdest) {
663                         if (*ptr == 0xFF && *(ptr + 1) == 0xFF
664                             && *(ptr + 2) == 0xFF)
665                                 break;
666                         ptr--;
667                 }
668                 if (ptr != pdest) {
669                         DBG("Bogus frame ? %d\n", ++(cam->nb));
670                 } else if (cam->b_acquire) {
671                         /* we skip the 2 first frames which are usually buggy */
672                         if (cam->skip)
673                                 cam->skip--;
674                         else {
675                                 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
676                                     frm->cur_size,
677                                     pdest[0], pdest[1], pdest[2], pdest[3],
678                                     pdest[4], pdest[5], pdest[6], pdest[7]);
679
680                                 zr364xx_got_frame(cam, frm->cur_size);
681                         }
682                 }
683                 cam->frame_count++;
684                 frm->ulState = ZR364XX_READ_IDLE;
685                 frm->cur_size = 0;
686         }
687         /* done successfully */
688         return 0;
689 }
690
691 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
692                                    struct v4l2_capability *cap)
693 {
694         struct zr364xx_camera *cam = video_drvdata(file);
695
696         strscpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
697         strscpy(cap->card, cam->udev->product, sizeof(cap->card));
698         strscpy(cap->bus_info, dev_name(&cam->udev->dev),
699                 sizeof(cap->bus_info));
700         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
701                             V4L2_CAP_READWRITE |
702                             V4L2_CAP_STREAMING;
703         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
704
705         return 0;
706 }
707
708 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
709                                      struct v4l2_input *i)
710 {
711         if (i->index != 0)
712                 return -EINVAL;
713         strscpy(i->name, DRIVER_DESC " Camera", sizeof(i->name));
714         i->type = V4L2_INPUT_TYPE_CAMERA;
715         return 0;
716 }
717
718 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
719                                   unsigned int *i)
720 {
721         *i = 0;
722         return 0;
723 }
724
725 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
726                                   unsigned int i)
727 {
728         if (i != 0)
729                 return -EINVAL;
730         return 0;
731 }
732
733 static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
734 {
735         struct zr364xx_camera *cam =
736                 container_of(ctrl->handler, struct zr364xx_camera, ctrl_handler);
737         int temp;
738
739         switch (ctrl->id) {
740         case V4L2_CID_BRIGHTNESS:
741                 /* hardware brightness */
742                 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
743                 temp = (0x60 << 8) + 127 - ctrl->val;
744                 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
745                 break;
746         default:
747                 return -EINVAL;
748         }
749
750         return 0;
751 }
752
753 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
754                                        void *priv, struct v4l2_fmtdesc *f)
755 {
756         if (f->index > 0)
757                 return -EINVAL;
758         f->flags = V4L2_FMT_FLAG_COMPRESSED;
759         strscpy(f->description, formats[0].name, sizeof(f->description));
760         f->pixelformat = formats[0].fourcc;
761         return 0;
762 }
763
764 static char *decode_fourcc(__u32 pixelformat, char *buf)
765 {
766         buf[0] = pixelformat & 0xff;
767         buf[1] = (pixelformat >> 8) & 0xff;
768         buf[2] = (pixelformat >> 16) & 0xff;
769         buf[3] = (pixelformat >> 24) & 0xff;
770         buf[4] = '\0';
771         return buf;
772 }
773
774 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
775                                       struct v4l2_format *f)
776 {
777         struct zr364xx_camera *cam = video_drvdata(file);
778         char pixelformat_name[5];
779
780         if (!cam)
781                 return -ENODEV;
782
783         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
784                 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
785                     decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
786                 return -EINVAL;
787         }
788
789         if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
790             !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
791                 f->fmt.pix.width = 320;
792                 f->fmt.pix.height = 240;
793         }
794
795         f->fmt.pix.field = V4L2_FIELD_NONE;
796         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
797         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
798         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
799         DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
800             decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
801             f->fmt.pix.field);
802         return 0;
803 }
804
805 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
806                                     struct v4l2_format *f)
807 {
808         struct zr364xx_camera *cam;
809
810         if (!file)
811                 return -ENODEV;
812         cam = video_drvdata(file);
813
814         f->fmt.pix.pixelformat = formats[0].fourcc;
815         f->fmt.pix.field = V4L2_FIELD_NONE;
816         f->fmt.pix.width = cam->width;
817         f->fmt.pix.height = cam->height;
818         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
819         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
820         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
821         return 0;
822 }
823
824 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
825                                     struct v4l2_format *f)
826 {
827         struct zr364xx_camera *cam = video_drvdata(file);
828         struct videobuf_queue *q = &cam->vb_vidq;
829         char pixelformat_name[5];
830         int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
831         int i;
832
833         if (ret < 0)
834                 return ret;
835
836         mutex_lock(&q->vb_lock);
837
838         if (videobuf_queue_is_busy(&cam->vb_vidq)) {
839                 DBG("%s queue busy\n", __func__);
840                 ret = -EBUSY;
841                 goto out;
842         }
843
844         if (cam->owner) {
845                 DBG("%s can't change format after started\n", __func__);
846                 ret = -EBUSY;
847                 goto out;
848         }
849
850         cam->width = f->fmt.pix.width;
851         cam->height = f->fmt.pix.height;
852         DBG("%s: %dx%d mode selected\n", __func__,
853                  cam->width, cam->height);
854         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
855         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
856         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
857         cam->vb_vidq.field = f->fmt.pix.field;
858
859         if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
860                 mode = 1;
861         else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
862                 mode = 2;
863         else
864                 mode = 0;
865
866         m0d1[0] = mode;
867         m1[2].value = 0xf000 + mode;
868         m2[1].value = 0xf000 + mode;
869
870         /* special case for METHOD3, the modes are different */
871         if (cam->method == METHOD3) {
872                 switch (mode) {
873                 case 1:
874                         m2[1].value = 0xf000 + 4;
875                         break;
876                 case 2:
877                         m2[1].value = 0xf000 + 0;
878                         break;
879                 default:
880                         m2[1].value = 0xf000 + 1;
881                         break;
882                 }
883         }
884
885         header2[437] = cam->height / 256;
886         header2[438] = cam->height % 256;
887         header2[439] = cam->width / 256;
888         header2[440] = cam->width % 256;
889
890         for (i = 0; init[cam->method][i].size != -1; i++) {
891                 ret =
892                     send_control_msg(cam->udev, 1, init[cam->method][i].value,
893                                      0, init[cam->method][i].bytes,
894                                      init[cam->method][i].size);
895                 if (ret < 0) {
896                         dev_err(&cam->udev->dev,
897                            "error during resolution change sequence: %d\n", i);
898                         goto out;
899                 }
900         }
901
902         /* Added some delay here, since opening/closing the camera quickly,
903          * like Ekiga does during its startup, can crash the webcam
904          */
905         mdelay(100);
906         cam->skip = 2;
907         ret = 0;
908
909 out:
910         mutex_unlock(&q->vb_lock);
911
912         DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
913             decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
914             f->fmt.pix.field);
915         return ret;
916 }
917
918 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
919                           struct v4l2_requestbuffers *p)
920 {
921         struct zr364xx_camera *cam = video_drvdata(file);
922
923         if (cam->owner && cam->owner != priv)
924                 return -EBUSY;
925         return videobuf_reqbufs(&cam->vb_vidq, p);
926 }
927
928 static int zr364xx_vidioc_querybuf(struct file *file,
929                                 void *priv,
930                                 struct v4l2_buffer *p)
931 {
932         int rc;
933         struct zr364xx_camera *cam = video_drvdata(file);
934         rc = videobuf_querybuf(&cam->vb_vidq, p);
935         return rc;
936 }
937
938 static int zr364xx_vidioc_qbuf(struct file *file,
939                                 void *priv,
940                                 struct v4l2_buffer *p)
941 {
942         int rc;
943         struct zr364xx_camera *cam = video_drvdata(file);
944         _DBG("%s\n", __func__);
945         if (cam->owner && cam->owner != priv)
946                 return -EBUSY;
947         rc = videobuf_qbuf(&cam->vb_vidq, p);
948         return rc;
949 }
950
951 static int zr364xx_vidioc_dqbuf(struct file *file,
952                                 void *priv,
953                                 struct v4l2_buffer *p)
954 {
955         int rc;
956         struct zr364xx_camera *cam = video_drvdata(file);
957         _DBG("%s\n", __func__);
958         if (cam->owner && cam->owner != priv)
959                 return -EBUSY;
960         rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
961         return rc;
962 }
963
964 static void read_pipe_completion(struct urb *purb)
965 {
966         struct zr364xx_pipeinfo *pipe_info;
967         struct zr364xx_camera *cam;
968         int pipe;
969
970         pipe_info = purb->context;
971         _DBG("%s %p, status %d\n", __func__, purb, purb->status);
972         if (!pipe_info) {
973                 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
974                 return;
975         }
976
977         cam = pipe_info->cam;
978         if (!cam) {
979                 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
980                 return;
981         }
982
983         /* if shutting down, do not resubmit, exit immediately */
984         if (purb->status == -ESHUTDOWN) {
985                 DBG("%s, err shutdown\n", __func__);
986                 pipe_info->err_count++;
987                 return;
988         }
989
990         if (pipe_info->state == 0) {
991                 DBG("exiting USB pipe\n");
992                 return;
993         }
994
995         if (purb->actual_length > pipe_info->transfer_size) {
996                 dev_err(&cam->udev->dev, "wrong number of bytes\n");
997                 return;
998         }
999
1000         if (purb->status == 0)
1001                 zr364xx_read_video_callback(cam, pipe_info, purb);
1002         else {
1003                 pipe_info->err_count++;
1004                 DBG("%s: failed URB %d\n", __func__, purb->status);
1005         }
1006
1007         pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1008
1009         /* reuse urb */
1010         usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1011                           pipe,
1012                           pipe_info->transfer_buffer,
1013                           pipe_info->transfer_size,
1014                           read_pipe_completion, pipe_info);
1015
1016         if (pipe_info->state != 0) {
1017                 purb->status = usb_submit_urb(pipe_info->stream_urb,
1018                                               GFP_ATOMIC);
1019
1020                 if (purb->status)
1021                         dev_err(&cam->udev->dev,
1022                                 "error submitting urb (error=%i)\n",
1023                                 purb->status);
1024         } else
1025                 DBG("read pipe complete state 0\n");
1026 }
1027
1028 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1029 {
1030         int pipe;
1031         int retval;
1032         struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1033         pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1034         DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1035
1036         pipe_info->state = 1;
1037         pipe_info->err_count = 0;
1038         pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1039         if (!pipe_info->stream_urb)
1040                 return -ENOMEM;
1041         /* transfer buffer allocated in board_init */
1042         usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1043                           pipe,
1044                           pipe_info->transfer_buffer,
1045                           pipe_info->transfer_size,
1046                           read_pipe_completion, pipe_info);
1047
1048         DBG("submitting URB %p\n", pipe_info->stream_urb);
1049         retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1050         if (retval) {
1051                 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1052                 return retval;
1053         }
1054
1055         return 0;
1056 }
1057
1058 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1059 {
1060         struct zr364xx_pipeinfo *pipe_info;
1061
1062         if (!cam) {
1063                 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1064                 return;
1065         }
1066         DBG("stop read pipe\n");
1067         pipe_info = cam->pipe;
1068         if (pipe_info) {
1069                 if (pipe_info->state != 0)
1070                         pipe_info->state = 0;
1071
1072                 if (pipe_info->stream_urb) {
1073                         /* cancel urb */
1074                         usb_kill_urb(pipe_info->stream_urb);
1075                         usb_free_urb(pipe_info->stream_urb);
1076                         pipe_info->stream_urb = NULL;
1077                 }
1078         }
1079         return;
1080 }
1081
1082 /* starts acquisition process */
1083 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1084 {
1085         int j;
1086
1087         DBG("start acquire\n");
1088
1089         cam->last_frame = -1;
1090         cam->cur_frame = 0;
1091         for (j = 0; j < FRAMES; j++) {
1092                 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1093                 cam->buffer.frame[j].cur_size = 0;
1094         }
1095         cam->b_acquire = 1;
1096         return 0;
1097 }
1098
1099 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1100 {
1101         cam->b_acquire = 0;
1102         return 0;
1103 }
1104
1105 static int zr364xx_prepare(struct zr364xx_camera *cam)
1106 {
1107         int res;
1108         int i, j;
1109
1110         for (i = 0; init[cam->method][i].size != -1; i++) {
1111                 res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1112                                      0, init[cam->method][i].bytes,
1113                                      init[cam->method][i].size);
1114                 if (res < 0) {
1115                         dev_err(&cam->udev->dev,
1116                                 "error during open sequence: %d\n", i);
1117                         return res;
1118                 }
1119         }
1120
1121         cam->skip = 2;
1122         cam->last_frame = -1;
1123         cam->cur_frame = 0;
1124         cam->frame_count = 0;
1125         for (j = 0; j < FRAMES; j++) {
1126                 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1127                 cam->buffer.frame[j].cur_size = 0;
1128         }
1129         v4l2_ctrl_handler_setup(&cam->ctrl_handler);
1130         return 0;
1131 }
1132
1133 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1134                                    enum v4l2_buf_type type)
1135 {
1136         struct zr364xx_camera *cam = video_drvdata(file);
1137         int res;
1138
1139         DBG("%s\n", __func__);
1140
1141         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1142                 return -EINVAL;
1143
1144         if (cam->owner && cam->owner != priv)
1145                 return -EBUSY;
1146
1147         res = zr364xx_prepare(cam);
1148         if (res)
1149                 return res;
1150         res = videobuf_streamon(&cam->vb_vidq);
1151         if (res == 0) {
1152                 zr364xx_start_acquire(cam);
1153                 cam->owner = file->private_data;
1154         }
1155         return res;
1156 }
1157
1158 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1159                                     enum v4l2_buf_type type)
1160 {
1161         struct zr364xx_camera *cam = video_drvdata(file);
1162
1163         DBG("%s\n", __func__);
1164         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1165                 return -EINVAL;
1166         if (cam->owner && cam->owner != priv)
1167                 return -EBUSY;
1168         zr364xx_stop_acquire(cam);
1169         return videobuf_streamoff(&cam->vb_vidq);
1170 }
1171
1172
1173 /* open the camera */
1174 static int zr364xx_open(struct file *file)
1175 {
1176         struct zr364xx_camera *cam = video_drvdata(file);
1177         int err;
1178
1179         DBG("%s\n", __func__);
1180
1181         if (mutex_lock_interruptible(&cam->lock))
1182                 return -ERESTARTSYS;
1183
1184         err = v4l2_fh_open(file);
1185         if (err)
1186                 goto out;
1187
1188         /* Added some delay here, since opening/closing the camera quickly,
1189          * like Ekiga does during its startup, can crash the webcam
1190          */
1191         mdelay(100);
1192         err = 0;
1193
1194 out:
1195         mutex_unlock(&cam->lock);
1196         DBG("%s: %d\n", __func__, err);
1197         return err;
1198 }
1199
1200 static void zr364xx_release(struct v4l2_device *v4l2_dev)
1201 {
1202         struct zr364xx_camera *cam =
1203                 container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
1204         unsigned long i;
1205
1206         v4l2_device_unregister(&cam->v4l2_dev);
1207
1208         videobuf_mmap_free(&cam->vb_vidq);
1209
1210         /* release sys buffers */
1211         for (i = 0; i < FRAMES; i++) {
1212                 if (cam->buffer.frame[i].lpvbits) {
1213                         DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1214                         vfree(cam->buffer.frame[i].lpvbits);
1215                 }
1216                 cam->buffer.frame[i].lpvbits = NULL;
1217         }
1218
1219         v4l2_ctrl_handler_free(&cam->ctrl_handler);
1220         /* release transfer buffer */
1221         kfree(cam->pipe->transfer_buffer);
1222         kfree(cam);
1223 }
1224
1225 /* release the camera */
1226 static int zr364xx_close(struct file *file)
1227 {
1228         struct zr364xx_camera *cam;
1229         struct usb_device *udev;
1230         int i;
1231
1232         DBG("%s\n", __func__);
1233         cam = video_drvdata(file);
1234
1235         mutex_lock(&cam->lock);
1236         udev = cam->udev;
1237
1238         if (file->private_data == cam->owner) {
1239                 /* turn off stream */
1240                 if (cam->b_acquire)
1241                         zr364xx_stop_acquire(cam);
1242                 videobuf_streamoff(&cam->vb_vidq);
1243
1244                 for (i = 0; i < 2; i++) {
1245                         send_control_msg(udev, 1, init[cam->method][i].value,
1246                                         0, init[cam->method][i].bytes,
1247                                         init[cam->method][i].size);
1248                 }
1249                 cam->owner = NULL;
1250         }
1251
1252         /* Added some delay here, since opening/closing the camera quickly,
1253          * like Ekiga does during its startup, can crash the webcam
1254          */
1255         mdelay(100);
1256         mutex_unlock(&cam->lock);
1257         return v4l2_fh_release(file);
1258 }
1259
1260
1261 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1262 {
1263         struct zr364xx_camera *cam = video_drvdata(file);
1264         int ret;
1265
1266         if (!cam) {
1267                 DBG("%s: cam == NULL\n", __func__);
1268                 return -ENODEV;
1269         }
1270         DBG("mmap called, vma=%p\n", vma);
1271
1272         ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1273
1274         DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1275                 (unsigned long)vma->vm_start,
1276                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1277         return ret;
1278 }
1279
1280 static __poll_t zr364xx_poll(struct file *file,
1281                                struct poll_table_struct *wait)
1282 {
1283         struct zr364xx_camera *cam = video_drvdata(file);
1284         struct videobuf_queue *q = &cam->vb_vidq;
1285         __poll_t res = v4l2_ctrl_poll(file, wait);
1286
1287         _DBG("%s\n", __func__);
1288
1289         return res | videobuf_poll_stream(file, q, wait);
1290 }
1291
1292 static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1293         .s_ctrl = zr364xx_s_ctrl,
1294 };
1295
1296 static const struct v4l2_file_operations zr364xx_fops = {
1297         .owner = THIS_MODULE,
1298         .open = zr364xx_open,
1299         .release = zr364xx_close,
1300         .read = zr364xx_read,
1301         .mmap = zr364xx_mmap,
1302         .unlocked_ioctl = video_ioctl2,
1303         .poll = zr364xx_poll,
1304 };
1305
1306 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1307         .vidioc_querycap        = zr364xx_vidioc_querycap,
1308         .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1309         .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1310         .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
1311         .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
1312         .vidioc_enum_input      = zr364xx_vidioc_enum_input,
1313         .vidioc_g_input         = zr364xx_vidioc_g_input,
1314         .vidioc_s_input         = zr364xx_vidioc_s_input,
1315         .vidioc_streamon        = zr364xx_vidioc_streamon,
1316         .vidioc_streamoff       = zr364xx_vidioc_streamoff,
1317         .vidioc_reqbufs         = zr364xx_vidioc_reqbufs,
1318         .vidioc_querybuf        = zr364xx_vidioc_querybuf,
1319         .vidioc_qbuf            = zr364xx_vidioc_qbuf,
1320         .vidioc_dqbuf           = zr364xx_vidioc_dqbuf,
1321         .vidioc_log_status      = v4l2_ctrl_log_status,
1322         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1323         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1324 };
1325
1326 static const struct video_device zr364xx_template = {
1327         .name = DRIVER_DESC,
1328         .fops = &zr364xx_fops,
1329         .ioctl_ops = &zr364xx_ioctl_ops,
1330         .release = video_device_release_empty,
1331 };
1332
1333
1334
1335 /*******************/
1336 /* USB integration */
1337 /*******************/
1338 static int zr364xx_board_init(struct zr364xx_camera *cam)
1339 {
1340         struct zr364xx_pipeinfo *pipe = cam->pipe;
1341         unsigned long i;
1342
1343         DBG("board init: %p\n", cam);
1344         memset(pipe, 0, sizeof(*pipe));
1345         pipe->cam = cam;
1346         pipe->transfer_size = BUFFER_SIZE;
1347
1348         pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1349                                         GFP_KERNEL);
1350         if (!pipe->transfer_buffer) {
1351                 DBG("out of memory!\n");
1352                 return -ENOMEM;
1353         }
1354
1355         cam->b_acquire = 0;
1356         cam->frame_count = 0;
1357
1358         /*** start create system buffers ***/
1359         for (i = 0; i < FRAMES; i++) {
1360                 /* always allocate maximum size for system buffers */
1361                 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1362
1363                 DBG("valloc %p, idx %lu, pdata %p\n",
1364                         &cam->buffer.frame[i], i,
1365                         cam->buffer.frame[i].lpvbits);
1366                 if (!cam->buffer.frame[i].lpvbits) {
1367                         printk(KERN_INFO KBUILD_MODNAME ": out of memory. Using less frames\n");
1368                         break;
1369                 }
1370         }
1371
1372         if (i == 0) {
1373                 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1374                 kfree(cam->pipe->transfer_buffer);
1375                 cam->pipe->transfer_buffer = NULL;
1376                 return -ENOMEM;
1377         } else
1378                 cam->buffer.dwFrames = i;
1379
1380         /* make sure internal states are set */
1381         for (i = 0; i < FRAMES; i++) {
1382                 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1383                 cam->buffer.frame[i].cur_size = 0;
1384         }
1385
1386         cam->cur_frame = 0;
1387         cam->last_frame = -1;
1388         /*** end create system buffers ***/
1389
1390         /* start read pipe */
1391         zr364xx_start_readpipe(cam);
1392         DBG(": board initialized\n");
1393         return 0;
1394 }
1395
1396 static int zr364xx_probe(struct usb_interface *intf,
1397                          const struct usb_device_id *id)
1398 {
1399         struct usb_device *udev = interface_to_usbdev(intf);
1400         struct zr364xx_camera *cam = NULL;
1401         struct usb_host_interface *iface_desc;
1402         struct usb_endpoint_descriptor *endpoint;
1403         struct v4l2_ctrl_handler *hdl;
1404         int err;
1405         int i;
1406
1407         DBG("probing...\n");
1408
1409         dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1410         dev_info(&intf->dev, "model %04x:%04x detected\n",
1411                  le16_to_cpu(udev->descriptor.idVendor),
1412                  le16_to_cpu(udev->descriptor.idProduct));
1413
1414         cam = kzalloc(sizeof(*cam), GFP_KERNEL);
1415         if (!cam)
1416                 return -ENOMEM;
1417
1418         cam->v4l2_dev.release = zr364xx_release;
1419         err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1420         if (err < 0) {
1421                 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1422                 kfree(cam);
1423                 return err;
1424         }
1425         hdl = &cam->ctrl_handler;
1426         v4l2_ctrl_handler_init(hdl, 1);
1427         v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1428                           V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1429         if (hdl->error) {
1430                 err = hdl->error;
1431                 dev_err(&udev->dev, "couldn't register control\n");
1432                 goto fail;
1433         }
1434         /* save the init method used by this camera */
1435         cam->method = id->driver_info;
1436         mutex_init(&cam->lock);
1437         cam->vdev = zr364xx_template;
1438         cam->vdev.lock = &cam->lock;
1439         cam->vdev.v4l2_dev = &cam->v4l2_dev;
1440         cam->vdev.ctrl_handler = &cam->ctrl_handler;
1441         video_set_drvdata(&cam->vdev, cam);
1442
1443         cam->udev = udev;
1444
1445         switch (mode) {
1446         case 1:
1447                 dev_info(&udev->dev, "160x120 mode selected\n");
1448                 cam->width = 160;
1449                 cam->height = 120;
1450                 break;
1451         case 2:
1452                 dev_info(&udev->dev, "640x480 mode selected\n");
1453                 cam->width = 640;
1454                 cam->height = 480;
1455                 break;
1456         default:
1457                 dev_info(&udev->dev, "320x240 mode selected\n");
1458                 cam->width = 320;
1459                 cam->height = 240;
1460                 break;
1461         }
1462
1463         m0d1[0] = mode;
1464         m1[2].value = 0xf000 + mode;
1465         m2[1].value = 0xf000 + mode;
1466
1467         /* special case for METHOD3, the modes are different */
1468         if (cam->method == METHOD3) {
1469                 switch (mode) {
1470                 case 1:
1471                         m2[1].value = 0xf000 + 4;
1472                         break;
1473                 case 2:
1474                         m2[1].value = 0xf000 + 0;
1475                         break;
1476                 default:
1477                         m2[1].value = 0xf000 + 1;
1478                         break;
1479                 }
1480         }
1481
1482         header2[437] = cam->height / 256;
1483         header2[438] = cam->height % 256;
1484         header2[439] = cam->width / 256;
1485         header2[440] = cam->width % 256;
1486
1487         cam->nb = 0;
1488
1489         DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1490
1491         /* set up the endpoint information  */
1492         iface_desc = intf->cur_altsetting;
1493         DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1494         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1495                 endpoint = &iface_desc->endpoint[i].desc;
1496                 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1497                         /* we found the bulk in endpoint */
1498                         cam->read_endpoint = endpoint->bEndpointAddress;
1499                 }
1500         }
1501
1502         if (!cam->read_endpoint) {
1503                 err = -ENOMEM;
1504                 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1505                 goto fail;
1506         }
1507
1508         /* v4l */
1509         INIT_LIST_HEAD(&cam->vidq.active);
1510         cam->vidq.cam = cam;
1511
1512         usb_set_intfdata(intf, cam);
1513
1514         /* load zr364xx board specific */
1515         err = zr364xx_board_init(cam);
1516         if (!err)
1517                 err = v4l2_ctrl_handler_setup(hdl);
1518         if (err)
1519                 goto fail;
1520
1521         spin_lock_init(&cam->slock);
1522
1523         cam->fmt = formats;
1524
1525         videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1526                                     NULL, &cam->slock,
1527                                     V4L2_BUF_TYPE_VIDEO_CAPTURE,
1528                                     V4L2_FIELD_NONE,
1529                                     sizeof(struct zr364xx_buffer), cam, &cam->lock);
1530
1531         err = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1532         if (err) {
1533                 dev_err(&udev->dev, "video_register_device failed\n");
1534                 goto fail;
1535         }
1536
1537         dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1538                  video_device_node_name(&cam->vdev));
1539         return 0;
1540
1541 fail:
1542         v4l2_ctrl_handler_free(hdl);
1543         v4l2_device_unregister(&cam->v4l2_dev);
1544         kfree(cam);
1545         return err;
1546 }
1547
1548
1549 static void zr364xx_disconnect(struct usb_interface *intf)
1550 {
1551         struct zr364xx_camera *cam = usb_get_intfdata(intf);
1552
1553         mutex_lock(&cam->lock);
1554         usb_set_intfdata(intf, NULL);
1555         dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1556         video_unregister_device(&cam->vdev);
1557         v4l2_device_disconnect(&cam->v4l2_dev);
1558
1559         /* stops the read pipe if it is running */
1560         if (cam->b_acquire)
1561                 zr364xx_stop_acquire(cam);
1562
1563         zr364xx_stop_readpipe(cam);
1564         mutex_unlock(&cam->lock);
1565         v4l2_device_put(&cam->v4l2_dev);
1566 }
1567
1568
1569 #ifdef CONFIG_PM
1570 static int zr364xx_suspend(struct usb_interface *intf, pm_message_t message)
1571 {
1572         struct zr364xx_camera *cam = usb_get_intfdata(intf);
1573
1574         cam->was_streaming = cam->b_acquire;
1575         if (!cam->was_streaming)
1576                 return 0;
1577         zr364xx_stop_acquire(cam);
1578         zr364xx_stop_readpipe(cam);
1579         return 0;
1580 }
1581
1582 static int zr364xx_resume(struct usb_interface *intf)
1583 {
1584         struct zr364xx_camera *cam = usb_get_intfdata(intf);
1585         int res;
1586
1587         if (!cam->was_streaming)
1588                 return 0;
1589
1590         zr364xx_start_readpipe(cam);
1591         res = zr364xx_prepare(cam);
1592         if (!res)
1593                 zr364xx_start_acquire(cam);
1594         return res;
1595 }
1596 #endif
1597
1598 /**********************/
1599 /* Module integration */
1600 /**********************/
1601
1602 static struct usb_driver zr364xx_driver = {
1603         .name = "zr364xx",
1604         .probe = zr364xx_probe,
1605         .disconnect = zr364xx_disconnect,
1606 #ifdef CONFIG_PM
1607         .suspend = zr364xx_suspend,
1608         .resume = zr364xx_resume,
1609         .reset_resume = zr364xx_resume,
1610 #endif
1611         .id_table = device_table
1612 };
1613
1614 module_usb_driver(zr364xx_driver);
1615
1616 MODULE_AUTHOR(DRIVER_AUTHOR);
1617 MODULE_DESCRIPTION(DRIVER_DESC);
1618 MODULE_LICENSE("GPL");
1619 MODULE_VERSION(DRIVER_VERSION);