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