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