Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/media/usb/zr364xx/zr364xx.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us