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