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