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