Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
zr364xx.c
Go to the documentation of this file.
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 <[email protected]>
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 */
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 */
137  unsigned long dwFrames; /* number of frames in buffer */
138  struct zr364xx_framei frame[FRAMES]; /* array of FRAME structures */
139 };
140 
144 };
145 
150  void *stream_urb;
151  void *cam; /* back pointer to zr364xx_camera struct */
154 };
155 
156 struct zr364xx_fmt {
157  char *name;
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 */
173  struct usb_device *udev; /* save off the usb device pointer */
174  struct usb_interface *interface;/* the interface for this device */
177  struct video_device vdev; /* v4l video device */
178  struct v4l2_fh *owner; /* owns the streaming */
179  int nb;
181  int skip;
182  int width;
183  int height;
184  int method;
185  struct mutex lock;
186 
191  unsigned long frame_count;
194 
196 
197  const struct zr364xx_fmt *fmt;
200 };
201 
202 /* buffer for one video frame */
204  /* common v4l buffer stuff -- must be first */
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,
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,
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  struct timeval ts;
505  const char *tmpbuf;
506  char *vbuf = videobuf_to_vmalloc(&buf->vb);
507  unsigned long last_frame;
508 
509  if (!vbuf)
510  return;
511 
512  last_frame = cam->last_frame;
513  if (last_frame != -1) {
514  tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
515  switch (buf->fmt->fourcc) {
516  case V4L2_PIX_FMT_JPEG:
517  buf->vb.size = jpgsize;
518  memcpy(vbuf, tmpbuf, buf->vb.size);
519  break;
520  default:
521  printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
522  }
523  cam->last_frame = -1;
524  } else {
525  printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
526  return;
527  }
528  DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
529  (unsigned long)vbuf, pos);
530  /* tell v4l buffer was filled */
531 
532  buf->vb.field_count = cam->frame_count * 2;
534  buf->vb.ts = ts;
535  buf->vb.state = VIDEOBUF_DONE;
536 }
537 
538 static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
539 {
540  struct zr364xx_dmaqueue *dma_q = &cam->vidq;
541  struct zr364xx_buffer *buf;
542  unsigned long flags = 0;
543  int rc = 0;
544 
545  DBG("wakeup: %p\n", &dma_q);
546  spin_lock_irqsave(&cam->slock, flags);
547 
548  if (list_empty(&dma_q->active)) {
549  DBG("No active queue to serve\n");
550  rc = -1;
551  goto unlock;
552  }
553  buf = list_entry(dma_q->active.next,
554  struct zr364xx_buffer, vb.queue);
555 
556  if (!waitqueue_active(&buf->vb.done)) {
557  /* no one active */
558  rc = -1;
559  goto unlock;
560  }
561  list_del(&buf->vb.queue);
562  do_gettimeofday(&buf->vb.ts);
563  DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
564  zr364xx_fillbuff(cam, buf, jpgsize);
565  wake_up(&buf->vb.done);
566  DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
567 unlock:
568  spin_unlock_irqrestore(&cam->slock, flags);
569  return rc;
570 }
571 
572 /* this function moves the usb stream read pipe data
573  * into the system buffers.
574  * returns 0 on success, EAGAIN if more data to process (call this
575  * function again).
576  */
577 static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
578  struct zr364xx_pipeinfo *pipe_info,
579  struct urb *purb)
580 {
581  unsigned char *pdest;
582  unsigned char *psrc;
583  s32 idx = -1;
584  struct zr364xx_framei *frm;
585  int i = 0;
586  unsigned char *ptr = NULL;
587 
588  _DBG("buffer to user\n");
589  idx = cam->cur_frame;
590  frm = &cam->buffer.frame[idx];
591 
592  /* swap bytes if camera needs it */
593  if (cam->method == METHOD0) {
594  u16 *buf = (u16 *)pipe_info->transfer_buffer;
595  for (i = 0; i < purb->actual_length/2; i++)
596  swab16s(buf + i);
597  }
598 
599  /* search done. now find out if should be acquiring */
600  if (!cam->b_acquire) {
601  /* we found a frame, but this channel is turned off */
602  frm->ulState = ZR364XX_READ_IDLE;
603  return -EINVAL;
604  }
605 
606  psrc = (u8 *)pipe_info->transfer_buffer;
607  ptr = pdest = frm->lpvbits;
608 
609  if (frm->ulState == ZR364XX_READ_IDLE) {
611  frm->cur_size = 0;
612 
613  _DBG("jpeg header, ");
614  memcpy(ptr, header1, sizeof(header1));
615  ptr += sizeof(header1);
616  header3 = 0;
617  memcpy(ptr, &header3, 1);
618  ptr++;
619  memcpy(ptr, psrc, 64);
620  ptr += 64;
621  header3 = 1;
622  memcpy(ptr, &header3, 1);
623  ptr++;
624  memcpy(ptr, psrc + 64, 64);
625  ptr += 64;
626  memcpy(ptr, header2, sizeof(header2));
627  ptr += sizeof(header2);
628  memcpy(ptr, psrc + 128,
629  purb->actual_length - 128);
630  ptr += purb->actual_length - 128;
631  _DBG("header : %d %d %d %d %d %d %d %d %d\n",
632  psrc[0], psrc[1], psrc[2],
633  psrc[3], psrc[4], psrc[5],
634  psrc[6], psrc[7], psrc[8]);
635  frm->cur_size = ptr - pdest;
636  } else {
637  if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
638  dev_info(&cam->udev->dev,
639  "%s: buffer (%d bytes) too small to hold "
640  "frame data. Discarding frame data.\n",
641  __func__, MAX_FRAME_SIZE);
642  } else {
643  pdest += frm->cur_size;
644  memcpy(pdest, psrc, purb->actual_length);
645  frm->cur_size += purb->actual_length;
646  }
647  }
648  /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
649  purb->actual_length);*/
650 
651  if (purb->actual_length < pipe_info->transfer_size) {
652  _DBG("****************Buffer[%d]full*************\n", idx);
653  cam->last_frame = cam->cur_frame;
654  cam->cur_frame++;
655  /* end of system frame ring buffer, start at zero */
656  if (cam->cur_frame == cam->buffer.dwFrames)
657  cam->cur_frame = 0;
658 
659  /* frame ready */
660  /* go back to find the JPEG EOI marker */
661  ptr = pdest = frm->lpvbits;
662  ptr += frm->cur_size - 2;
663  while (ptr > pdest) {
664  if (*ptr == 0xFF && *(ptr + 1) == 0xD9
665  && *(ptr + 2) == 0xFF)
666  break;
667  ptr--;
668  }
669  if (ptr == pdest)
670  DBG("No EOI marker\n");
671 
672  /* Sometimes there is junk data in the middle of the picture,
673  * we want to skip this bogus frames */
674  while (ptr > pdest) {
675  if (*ptr == 0xFF && *(ptr + 1) == 0xFF
676  && *(ptr + 2) == 0xFF)
677  break;
678  ptr--;
679  }
680  if (ptr != pdest) {
681  DBG("Bogus frame ? %d\n", ++(cam->nb));
682  } else if (cam->b_acquire) {
683  /* we skip the 2 first frames which are usually buggy */
684  if (cam->skip)
685  cam->skip--;
686  else {
687  _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
688  frm->cur_size,
689  pdest[0], pdest[1], pdest[2], pdest[3],
690  pdest[4], pdest[5], pdest[6], pdest[7]);
691 
692  zr364xx_got_frame(cam, frm->cur_size);
693  }
694  }
695  cam->frame_count++;
696  frm->ulState = ZR364XX_READ_IDLE;
697  frm->cur_size = 0;
698  }
699  /* done successfully */
700  return 0;
701 }
702 
703 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
704  struct v4l2_capability *cap)
705 {
706  struct zr364xx_camera *cam = video_drvdata(file);
707 
708  strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
709  strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
710  strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
711  sizeof(cap->bus_info));
716 
717  return 0;
718 }
719 
720 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
721  struct v4l2_input *i)
722 {
723  if (i->index != 0)
724  return -EINVAL;
725  strcpy(i->name, DRIVER_DESC " Camera");
727  return 0;
728 }
729 
730 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
731  unsigned int *i)
732 {
733  *i = 0;
734  return 0;
735 }
736 
737 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
738  unsigned int i)
739 {
740  if (i != 0)
741  return -EINVAL;
742  return 0;
743 }
744 
745 static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
746 {
747  struct zr364xx_camera *cam =
749  int temp;
750 
751  switch (ctrl->id) {
752  case V4L2_CID_BRIGHTNESS:
753  /* hardware brightness */
754  send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
755  temp = (0x60 << 8) + 127 - ctrl->val;
756  send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
757  break;
758  default:
759  return -EINVAL;
760  }
761 
762  return 0;
763 }
764 
765 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
766  void *priv, struct v4l2_fmtdesc *f)
767 {
768  if (f->index > 0)
769  return -EINVAL;
771  strcpy(f->description, formats[0].name);
772  f->pixelformat = formats[0].fourcc;
773  return 0;
774 }
775 
776 static char *decode_fourcc(__u32 pixelformat, char *buf)
777 {
778  buf[0] = pixelformat & 0xff;
779  buf[1] = (pixelformat >> 8) & 0xff;
780  buf[2] = (pixelformat >> 16) & 0xff;
781  buf[3] = (pixelformat >> 24) & 0xff;
782  buf[4] = '\0';
783  return buf;
784 }
785 
786 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
787  struct v4l2_format *f)
788 {
789  struct zr364xx_camera *cam = video_drvdata(file);
790  char pixelformat_name[5];
791 
792  if (cam == NULL)
793  return -ENODEV;
794 
795  if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
796  DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
797  decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
798  return -EINVAL;
799  }
800 
801  if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
802  !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
803  f->fmt.pix.width = 320;
804  f->fmt.pix.height = 240;
805  }
806 
807  f->fmt.pix.field = V4L2_FIELD_NONE;
808  f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
809  f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
810  f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
811  f->fmt.pix.priv = 0;
812  DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
813  decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
814  f->fmt.pix.field);
815  return 0;
816 }
817 
818 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
819  struct v4l2_format *f)
820 {
821  struct zr364xx_camera *cam;
822 
823  if (file == NULL)
824  return -ENODEV;
825  cam = video_drvdata(file);
826 
827  f->fmt.pix.pixelformat = formats[0].fourcc;
828  f->fmt.pix.field = V4L2_FIELD_NONE;
829  f->fmt.pix.width = cam->width;
830  f->fmt.pix.height = cam->height;
831  f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
832  f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
833  f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
834  f->fmt.pix.priv = 0;
835  return 0;
836 }
837 
838 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
839  struct v4l2_format *f)
840 {
841  struct zr364xx_camera *cam = video_drvdata(file);
842  struct videobuf_queue *q = &cam->vb_vidq;
843  char pixelformat_name[5];
844  int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
845  int i;
846 
847  if (ret < 0)
848  return ret;
849 
850  mutex_lock(&q->vb_lock);
851 
852  if (videobuf_queue_is_busy(&cam->vb_vidq)) {
853  DBG("%s queue busy\n", __func__);
854  ret = -EBUSY;
855  goto out;
856  }
857 
858  if (cam->owner) {
859  DBG("%s can't change format after started\n", __func__);
860  ret = -EBUSY;
861  goto out;
862  }
863 
864  cam->width = f->fmt.pix.width;
865  cam->height = f->fmt.pix.height;
866  DBG("%s: %dx%d mode selected\n", __func__,
867  cam->width, cam->height);
868  f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
869  f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
870  f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
871  f->fmt.pix.priv = 0;
872  cam->vb_vidq.field = f->fmt.pix.field;
873 
874  if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
875  mode = 1;
876  else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
877  mode = 2;
878  else
879  mode = 0;
880 
881  m0d1[0] = mode;
882  m1[2].value = 0xf000 + mode;
883  m2[1].value = 0xf000 + mode;
884 
885  /* special case for METHOD3, the modes are different */
886  if (cam->method == METHOD3) {
887  switch (mode) {
888  case 1:
889  m2[1].value = 0xf000 + 4;
890  break;
891  case 2:
892  m2[1].value = 0xf000 + 0;
893  break;
894  default:
895  m2[1].value = 0xf000 + 1;
896  break;
897  }
898  }
899 
900  header2[437] = cam->height / 256;
901  header2[438] = cam->height % 256;
902  header2[439] = cam->width / 256;
903  header2[440] = cam->width % 256;
904 
905  for (i = 0; init[cam->method][i].size != -1; i++) {
906  ret =
907  send_control_msg(cam->udev, 1, init[cam->method][i].value,
908  0, init[cam->method][i].bytes,
909  init[cam->method][i].size);
910  if (ret < 0) {
911  dev_err(&cam->udev->dev,
912  "error during resolution change sequence: %d\n", i);
913  goto out;
914  }
915  }
916 
917  /* Added some delay here, since opening/closing the camera quickly,
918  * like Ekiga does during its startup, can crash the webcam
919  */
920  mdelay(100);
921  cam->skip = 2;
922  ret = 0;
923 
924 out:
925  mutex_unlock(&q->vb_lock);
926 
927  DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
928  decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
929  f->fmt.pix.field);
930  return ret;
931 }
932 
933 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
934  struct v4l2_requestbuffers *p)
935 {
936  struct zr364xx_camera *cam = video_drvdata(file);
937 
938  if (cam->owner && cam->owner != priv)
939  return -EBUSY;
940  return videobuf_reqbufs(&cam->vb_vidq, p);
941 }
942 
943 static int zr364xx_vidioc_querybuf(struct file *file,
944  void *priv,
945  struct v4l2_buffer *p)
946 {
947  int rc;
948  struct zr364xx_camera *cam = video_drvdata(file);
949  rc = videobuf_querybuf(&cam->vb_vidq, p);
950  return rc;
951 }
952 
953 static int zr364xx_vidioc_qbuf(struct file *file,
954  void *priv,
955  struct v4l2_buffer *p)
956 {
957  int rc;
958  struct zr364xx_camera *cam = video_drvdata(file);
959  _DBG("%s\n", __func__);
960  if (cam->owner && cam->owner != priv)
961  return -EBUSY;
962  rc = videobuf_qbuf(&cam->vb_vidq, p);
963  return rc;
964 }
965 
966 static int zr364xx_vidioc_dqbuf(struct file *file,
967  void *priv,
968  struct v4l2_buffer *p)
969 {
970  int rc;
971  struct zr364xx_camera *cam = video_drvdata(file);
972  _DBG("%s\n", __func__);
973  if (cam->owner && cam->owner != priv)
974  return -EBUSY;
975  rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
976  return rc;
977 }
978 
979 static void read_pipe_completion(struct urb *purb)
980 {
981  struct zr364xx_pipeinfo *pipe_info;
982  struct zr364xx_camera *cam;
983  int pipe;
984 
985  pipe_info = purb->context;
986  _DBG("%s %p, status %d\n", __func__, purb, purb->status);
987  if (pipe_info == NULL) {
988  printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
989  return;
990  }
991 
992  cam = pipe_info->cam;
993  if (cam == NULL) {
994  printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
995  return;
996  }
997 
998  /* if shutting down, do not resubmit, exit immediately */
999  if (purb->status == -ESHUTDOWN) {
1000  DBG("%s, err shutdown\n", __func__);
1001  pipe_info->err_count++;
1002  return;
1003  }
1004 
1005  if (pipe_info->state == 0) {
1006  DBG("exiting USB pipe\n");
1007  return;
1008  }
1009 
1010  if (purb->actual_length < 0 ||
1011  purb->actual_length > pipe_info->transfer_size) {
1012  dev_err(&cam->udev->dev, "wrong number of bytes\n");
1013  return;
1014  }
1015 
1016  if (purb->status == 0)
1017  zr364xx_read_video_callback(cam, pipe_info, purb);
1018  else {
1019  pipe_info->err_count++;
1020  DBG("%s: failed URB %d\n", __func__, purb->status);
1021  }
1022 
1023  pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1024 
1025  /* reuse urb */
1026  usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1027  pipe,
1028  pipe_info->transfer_buffer,
1029  pipe_info->transfer_size,
1030  read_pipe_completion, pipe_info);
1031 
1032  if (pipe_info->state != 0) {
1033  purb->status = usb_submit_urb(pipe_info->stream_urb,
1034  GFP_ATOMIC);
1035 
1036  if (purb->status)
1037  dev_err(&cam->udev->dev,
1038  "error submitting urb (error=%i)\n",
1039  purb->status);
1040  } else
1041  DBG("read pipe complete state 0\n");
1042 }
1043 
1044 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1045 {
1046  int pipe;
1047  int retval;
1048  struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1049  pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1050  DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1051 
1052  pipe_info->state = 1;
1053  pipe_info->err_count = 0;
1054  pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1055  if (!pipe_info->stream_urb) {
1056  dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1057  return -ENOMEM;
1058  }
1059  /* transfer buffer allocated in board_init */
1060  usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1061  pipe,
1062  pipe_info->transfer_buffer,
1063  pipe_info->transfer_size,
1064  read_pipe_completion, pipe_info);
1065 
1066  DBG("submitting URB %p\n", pipe_info->stream_urb);
1067  retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1068  if (retval) {
1069  printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1070  return retval;
1071  }
1072 
1073  return 0;
1074 }
1075 
1076 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1077 {
1078  struct zr364xx_pipeinfo *pipe_info;
1079 
1080  if (cam == NULL) {
1081  printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1082  return;
1083  }
1084  DBG("stop read pipe\n");
1085  pipe_info = cam->pipe;
1086  if (pipe_info) {
1087  if (pipe_info->state != 0)
1088  pipe_info->state = 0;
1089 
1090  if (pipe_info->stream_urb) {
1091  /* cancel urb */
1092  usb_kill_urb(pipe_info->stream_urb);
1093  usb_free_urb(pipe_info->stream_urb);
1094  pipe_info->stream_urb = NULL;
1095  }
1096  }
1097  return;
1098 }
1099 
1100 /* starts acquisition process */
1101 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1102 {
1103  int j;
1104 
1105  DBG("start acquire\n");
1106 
1107  cam->last_frame = -1;
1108  cam->cur_frame = 0;
1109  for (j = 0; j < FRAMES; j++) {
1110  cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1111  cam->buffer.frame[j].cur_size = 0;
1112  }
1113  cam->b_acquire = 1;
1114  return 0;
1115 }
1116 
1117 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1118 {
1119  cam->b_acquire = 0;
1120  return 0;
1121 }
1122 
1123 static int zr364xx_prepare(struct zr364xx_camera *cam)
1124 {
1125  int res;
1126  int i, j;
1127 
1128  for (i = 0; init[cam->method][i].size != -1; i++) {
1129  res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1130  0, init[cam->method][i].bytes,
1131  init[cam->method][i].size);
1132  if (res < 0) {
1133  dev_err(&cam->udev->dev,
1134  "error during open sequence: %d\n", i);
1135  return res;
1136  }
1137  }
1138 
1139  cam->skip = 2;
1140  cam->last_frame = -1;
1141  cam->cur_frame = 0;
1142  cam->frame_count = 0;
1143  for (j = 0; j < FRAMES; j++) {
1144  cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1145  cam->buffer.frame[j].cur_size = 0;
1146  }
1148  return 0;
1149 }
1150 
1151 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1152  enum v4l2_buf_type type)
1153 {
1154  struct zr364xx_camera *cam = video_drvdata(file);
1155  int res;
1156 
1157  DBG("%s\n", __func__);
1158 
1159  if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1160  return -EINVAL;
1161 
1162  if (cam->owner && cam->owner != priv)
1163  return -EBUSY;
1164 
1165  res = zr364xx_prepare(cam);
1166  if (res)
1167  return res;
1168  res = videobuf_streamon(&cam->vb_vidq);
1169  if (res == 0) {
1170  zr364xx_start_acquire(cam);
1171  cam->owner = file->private_data;
1172  }
1173  return res;
1174 }
1175 
1176 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1177  enum v4l2_buf_type type)
1178 {
1179  struct zr364xx_camera *cam = video_drvdata(file);
1180 
1181  DBG("%s\n", __func__);
1182  if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1183  return -EINVAL;
1184  if (cam->owner && cam->owner != priv)
1185  return -EBUSY;
1186  zr364xx_stop_acquire(cam);
1187  return videobuf_streamoff(&cam->vb_vidq);
1188 }
1189 
1190 
1191 /* open the camera */
1192 static int zr364xx_open(struct file *file)
1193 {
1194  struct zr364xx_camera *cam = video_drvdata(file);
1195  int err;
1196 
1197  DBG("%s\n", __func__);
1198 
1199  if (mutex_lock_interruptible(&cam->lock))
1200  return -ERESTARTSYS;
1201 
1202  err = v4l2_fh_open(file);
1203  if (err)
1204  goto out;
1205 
1206  /* Added some delay here, since opening/closing the camera quickly,
1207  * like Ekiga does during its startup, can crash the webcam
1208  */
1209  mdelay(100);
1210  err = 0;
1211 
1212 out:
1213  mutex_unlock(&cam->lock);
1214  DBG("%s: %d\n", __func__, err);
1215  return err;
1216 }
1217 
1218 static void zr364xx_release(struct v4l2_device *v4l2_dev)
1219 {
1220  struct zr364xx_camera *cam =
1221  container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
1222  unsigned long i;
1223 
1225 
1226  videobuf_mmap_free(&cam->vb_vidq);
1227 
1228  /* release sys buffers */
1229  for (i = 0; i < FRAMES; i++) {
1230  if (cam->buffer.frame[i].lpvbits) {
1231  DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1232  vfree(cam->buffer.frame[i].lpvbits);
1233  }
1234  cam->buffer.frame[i].lpvbits = NULL;
1235  }
1236 
1238  /* release transfer buffer */
1239  kfree(cam->pipe->transfer_buffer);
1240  kfree(cam);
1241 }
1242 
1243 /* release the camera */
1244 static int zr364xx_close(struct file *file)
1245 {
1246  struct zr364xx_camera *cam;
1247  struct usb_device *udev;
1248  int i;
1249 
1250  DBG("%s\n", __func__);
1251  cam = video_drvdata(file);
1252 
1253  mutex_lock(&cam->lock);
1254  udev = cam->udev;
1255 
1256  if (file->private_data == cam->owner) {
1257  /* turn off stream */
1258  if (cam->b_acquire)
1259  zr364xx_stop_acquire(cam);
1260  videobuf_streamoff(&cam->vb_vidq);
1261 
1262  for (i = 0; i < 2; i++) {
1263  send_control_msg(udev, 1, init[cam->method][i].value,
1264  0, init[cam->method][i].bytes,
1265  init[cam->method][i].size);
1266  }
1267  cam->owner = NULL;
1268  }
1269 
1270  /* Added some delay here, since opening/closing the camera quickly,
1271  * like Ekiga does during its startup, can crash the webcam
1272  */
1273  mdelay(100);
1274  mutex_unlock(&cam->lock);
1275  return v4l2_fh_release(file);
1276 }
1277 
1278 
1279 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1280 {
1281  struct zr364xx_camera *cam = video_drvdata(file);
1282  int ret;
1283 
1284  if (cam == NULL) {
1285  DBG("%s: cam == NULL\n", __func__);
1286  return -ENODEV;
1287  }
1288  DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1289 
1290  ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1291 
1292  DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1293  (unsigned long)vma->vm_start,
1294  (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1295  return ret;
1296 }
1297 
1298 static unsigned int zr364xx_poll(struct file *file,
1299  struct poll_table_struct *wait)
1300 {
1301  struct zr364xx_camera *cam = video_drvdata(file);
1302  struct videobuf_queue *q = &cam->vb_vidq;
1303  unsigned res = v4l2_ctrl_poll(file, wait);
1304 
1305  _DBG("%s\n", __func__);
1306 
1307  return res | videobuf_poll_stream(file, q, wait);
1308 }
1309 
1310 static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1311  .s_ctrl = zr364xx_s_ctrl,
1312 };
1313 
1314 static const struct v4l2_file_operations zr364xx_fops = {
1315  .owner = THIS_MODULE,
1316  .open = zr364xx_open,
1317  .release = zr364xx_close,
1318  .read = zr364xx_read,
1319  .mmap = zr364xx_mmap,
1320  .unlocked_ioctl = video_ioctl2,
1321  .poll = zr364xx_poll,
1322 };
1323 
1324 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1325  .vidioc_querycap = zr364xx_vidioc_querycap,
1326  .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1327  .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1328  .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1329  .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
1330  .vidioc_enum_input = zr364xx_vidioc_enum_input,
1331  .vidioc_g_input = zr364xx_vidioc_g_input,
1332  .vidioc_s_input = zr364xx_vidioc_s_input,
1333  .vidioc_streamon = zr364xx_vidioc_streamon,
1334  .vidioc_streamoff = zr364xx_vidioc_streamoff,
1335  .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1336  .vidioc_querybuf = zr364xx_vidioc_querybuf,
1337  .vidioc_qbuf = zr364xx_vidioc_qbuf,
1338  .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
1339  .vidioc_log_status = v4l2_ctrl_log_status,
1340  .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1341  .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1342 };
1343 
1344 static struct video_device zr364xx_template = {
1345  .name = DRIVER_DESC,
1346  .fops = &zr364xx_fops,
1347  .ioctl_ops = &zr364xx_ioctl_ops,
1348  .release = video_device_release_empty,
1349 };
1350 
1351 
1352 
1353 /*******************/
1354 /* USB integration */
1355 /*******************/
1356 static int zr364xx_board_init(struct zr364xx_camera *cam)
1357 {
1358  struct zr364xx_pipeinfo *pipe = cam->pipe;
1359  unsigned long i;
1360 
1361  DBG("board init: %p\n", cam);
1362  memset(pipe, 0, sizeof(*pipe));
1363  pipe->cam = cam;
1364  pipe->transfer_size = BUFFER_SIZE;
1365 
1366  pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1367  GFP_KERNEL);
1368  if (pipe->transfer_buffer == NULL) {
1369  DBG("out of memory!\n");
1370  return -ENOMEM;
1371  }
1372 
1373  cam->b_acquire = 0;
1374  cam->frame_count = 0;
1375 
1376  /*** start create system buffers ***/
1377  for (i = 0; i < FRAMES; i++) {
1378  /* always allocate maximum size for system buffers */
1379  cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1380 
1381  DBG("valloc %p, idx %lu, pdata %p\n",
1382  &cam->buffer.frame[i], i,
1383  cam->buffer.frame[i].lpvbits);
1384  if (cam->buffer.frame[i].lpvbits == NULL) {
1385  printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1386  "Using less frames\n");
1387  break;
1388  }
1389  }
1390 
1391  if (i == 0) {
1392  printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1393  kfree(cam->pipe->transfer_buffer);
1394  cam->pipe->transfer_buffer = NULL;
1395  return -ENOMEM;
1396  } else
1397  cam->buffer.dwFrames = i;
1398 
1399  /* make sure internal states are set */
1400  for (i = 0; i < FRAMES; i++) {
1401  cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1402  cam->buffer.frame[i].cur_size = 0;
1403  }
1404 
1405  cam->cur_frame = 0;
1406  cam->last_frame = -1;
1407  /*** end create system buffers ***/
1408 
1409  /* start read pipe */
1410  zr364xx_start_readpipe(cam);
1411  DBG(": board initialized\n");
1412  return 0;
1413 }
1414 
1415 static int zr364xx_probe(struct usb_interface *intf,
1416  const struct usb_device_id *id)
1417 {
1418  struct usb_device *udev = interface_to_usbdev(intf);
1419  struct zr364xx_camera *cam = NULL;
1420  struct usb_host_interface *iface_desc;
1422  struct v4l2_ctrl_handler *hdl;
1423  int err;
1424  int i;
1425 
1426  DBG("probing...\n");
1427 
1428  dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1429  dev_info(&intf->dev, "model %04x:%04x detected\n",
1430  le16_to_cpu(udev->descriptor.idVendor),
1431  le16_to_cpu(udev->descriptor.idProduct));
1432 
1433  cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1434  if (cam == NULL) {
1435  dev_err(&udev->dev, "cam: out of memory !\n");
1436  return -ENOMEM;
1437  }
1438 
1439  cam->v4l2_dev.release = zr364xx_release;
1440  err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1441  if (err < 0) {
1442  dev_err(&udev->dev, "couldn't register v4l2_device\n");
1443  kfree(cam);
1444  return err;
1445  }
1446  hdl = &cam->ctrl_handler;
1447  v4l2_ctrl_handler_init(hdl, 1);
1448  v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1449  V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1450  if (hdl->error) {
1451  err = hdl->error;
1452  dev_err(&udev->dev, "couldn't register control\n");
1453  goto fail;
1454  }
1455  /* save the init method used by this camera */
1456  cam->method = id->driver_info;
1457  mutex_init(&cam->lock);
1458  cam->vdev = zr364xx_template;
1459  cam->vdev.lock = &cam->lock;
1460  cam->vdev.v4l2_dev = &cam->v4l2_dev;
1461  cam->vdev.ctrl_handler = &cam->ctrl_handler;
1462  set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags);
1463  video_set_drvdata(&cam->vdev, cam);
1464  if (debug)
1466 
1467  cam->udev = udev;
1468 
1469  switch (mode) {
1470  case 1:
1471  dev_info(&udev->dev, "160x120 mode selected\n");
1472  cam->width = 160;
1473  cam->height = 120;
1474  break;
1475  case 2:
1476  dev_info(&udev->dev, "640x480 mode selected\n");
1477  cam->width = 640;
1478  cam->height = 480;
1479  break;
1480  default:
1481  dev_info(&udev->dev, "320x240 mode selected\n");
1482  cam->width = 320;
1483  cam->height = 240;
1484  break;
1485  }
1486 
1487  m0d1[0] = mode;
1488  m1[2].value = 0xf000 + mode;
1489  m2[1].value = 0xf000 + mode;
1490 
1491  /* special case for METHOD3, the modes are different */
1492  if (cam->method == METHOD3) {
1493  switch (mode) {
1494  case 1:
1495  m2[1].value = 0xf000 + 4;
1496  break;
1497  case 2:
1498  m2[1].value = 0xf000 + 0;
1499  break;
1500  default:
1501  m2[1].value = 0xf000 + 1;
1502  break;
1503  }
1504  }
1505 
1506  header2[437] = cam->height / 256;
1507  header2[438] = cam->height % 256;
1508  header2[439] = cam->width / 256;
1509  header2[440] = cam->width % 256;
1510 
1511  cam->nb = 0;
1512 
1513  DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1514 
1515  /* set up the endpoint information */
1516  iface_desc = intf->cur_altsetting;
1517  DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1518  for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1519  endpoint = &iface_desc->endpoint[i].desc;
1520  if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1521  /* we found the bulk in endpoint */
1522  cam->read_endpoint = endpoint->bEndpointAddress;
1523  }
1524  }
1525 
1526  if (!cam->read_endpoint) {
1527  err = -ENOMEM;
1528  dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1529  goto fail;
1530  }
1531 
1532  /* v4l */
1533  INIT_LIST_HEAD(&cam->vidq.active);
1534  cam->vidq.cam = cam;
1535 
1536  usb_set_intfdata(intf, cam);
1537 
1538  /* load zr364xx board specific */
1539  err = zr364xx_board_init(cam);
1540  if (!err)
1541  err = v4l2_ctrl_handler_setup(hdl);
1542  if (err)
1543  goto fail;
1544 
1545  spin_lock_init(&cam->slock);
1546 
1547  cam->fmt = formats;
1548 
1549  videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1550  NULL, &cam->slock,
1553  sizeof(struct zr364xx_buffer), cam, &cam->lock);
1554 
1555  err = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1556  if (err) {
1557  dev_err(&udev->dev, "video_register_device failed\n");
1558  goto fail;
1559  }
1560 
1561  dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1562  video_device_node_name(&cam->vdev));
1563  return 0;
1564 
1565 fail:
1568  kfree(cam);
1569  return err;
1570 }
1571 
1572 
1573 static void zr364xx_disconnect(struct usb_interface *intf)
1574 {
1575  struct zr364xx_camera *cam = usb_get_intfdata(intf);
1576 
1577  mutex_lock(&cam->lock);
1578  usb_set_intfdata(intf, NULL);
1579  dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1582 
1583  /* stops the read pipe if it is running */
1584  if (cam->b_acquire)
1585  zr364xx_stop_acquire(cam);
1586 
1587  zr364xx_stop_readpipe(cam);
1588  mutex_unlock(&cam->lock);
1589  v4l2_device_put(&cam->v4l2_dev);
1590 }
1591 
1592 
1593 #ifdef CONFIG_PM
1594 static int zr364xx_suspend(struct usb_interface *intf, pm_message_t message)
1595 {
1596  struct zr364xx_camera *cam = usb_get_intfdata(intf);
1597 
1598  cam->was_streaming = cam->b_acquire;
1599  if (!cam->was_streaming)
1600  return 0;
1601  zr364xx_stop_acquire(cam);
1602  zr364xx_stop_readpipe(cam);
1603  return 0;
1604 }
1605 
1606 static int zr364xx_resume(struct usb_interface *intf)
1607 {
1608  struct zr364xx_camera *cam = usb_get_intfdata(intf);
1609  int res;
1610 
1611  if (!cam->was_streaming)
1612  return 0;
1613 
1614  zr364xx_start_readpipe(cam);
1615  res = zr364xx_prepare(cam);
1616  if (!res)
1617  zr364xx_start_acquire(cam);
1618  return res;
1619 }
1620 #endif
1621 
1622 /**********************/
1623 /* Module integration */
1624 /**********************/
1625 
1626 static struct usb_driver zr364xx_driver = {
1627  .name = "zr364xx",
1628  .probe = zr364xx_probe,
1629  .disconnect = zr364xx_disconnect,
1630 #ifdef CONFIG_PM
1631  .suspend = zr364xx_suspend,
1632  .resume = zr364xx_resume,
1633  .reset_resume = zr364xx_resume,
1634 #endif
1635  .id_table = device_table
1636 };
1637 
1638 module_usb_driver(zr364xx_driver);
1639 
1642 MODULE_LICENSE("GPL");