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