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