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