Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

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

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