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