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
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
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
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
64#define DBG(fmt, args...) \
65 do { \
66 if (debug) { \
67 printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
68 } \
69 } while (0)
70
71
72#ifdef FULL_DEBUG
73#define _DBG DBG
74#else
75#define _DBG(fmt, args...)
76#endif
77
78
79
80#define METHOD0 0
81#define METHOD1 1
82#define METHOD2 2
83#define METHOD3 3
84
85
86
87static int debug;
88static int mode;
89
90
91
92module_param(debug, int, 0644);
93MODULE_PARM_DESC(debug, "Debug level");
94module_param(mode, int, 0644);
95MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
96
97
98
99
100static 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 {}
123};
124
125MODULE_DEVICE_TABLE(usb, device_table);
126
127
128struct zr364xx_framei {
129 unsigned long ulState;
130
131 void *lpvbits;
132 unsigned long cur_size;
133};
134
135
136struct zr364xx_bufferi {
137 unsigned long dwFrames;
138 struct zr364xx_framei frame[FRAMES];
139};
140
141struct zr364xx_dmaqueue {
142 struct list_head active;
143 struct zr364xx_camera *cam;
144};
145
146struct zr364xx_pipeinfo {
147 u32 transfer_size;
148 u8 *transfer_buffer;
149 u32 state;
150 void *stream_urb;
151 void *cam;
152 u32 err_count;
153 u32 idx;
154};
155
156struct zr364xx_fmt {
157 char *name;
158 u32 fourcc;
159 int depth;
160};
161
162
163static const struct zr364xx_fmt formats[] = {
164 {
165 .name = "JPG",
166 .fourcc = V4L2_PIX_FMT_JPEG,
167 .depth = 24
168 }
169};
170
171
172struct zr364xx_camera {
173 struct usb_device *udev;
174 struct usb_interface *interface;
175 struct v4l2_device v4l2_dev;
176 struct v4l2_ctrl_handler ctrl_handler;
177 struct video_device vdev;
178 struct v4l2_fh *owner;
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
203struct zr364xx_buffer {
204
205 struct videobuf_buffer vb;
206 const struct zr364xx_fmt *fmt;
207};
208
209
210static 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
236
237typedef struct {
238 unsigned int value;
239 unsigned int size;
240 unsigned char *bytes;
241} message;
242
243
244static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
245static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
246static unsigned char m0d3[] = { 0, 0 };
247static 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
263static unsigned char m1d1[] = { 0xff, 0xff };
264static unsigned char m1d2[] = { 0x00, 0x00 };
265static 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
283static unsigned char m2d1[] = { 0xff, 0xff };
284static 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
297static message *init[4] = { m0, m1, m2, m2 };
298
299
300
301static unsigned char header1[] = {
302 0xFF, 0xD8,
303
304
305
306
307 0xFF, 0xDB, 0x00, 0x84
308};
309static 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};
354static unsigned char header3;
355
356
357
358
359
360static 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
376static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
377{
378 _DBG("%s\n", __func__);
379
380 if (in_interrupt())
381 BUG();
382
383 videobuf_vmalloc_free(&buf->vb);
384 buf->vb.state = VIDEOBUF_NEEDS_INIT;
385}
386
387static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
388 enum v4l2_field field)
389{
390 struct zr364xx_camera *cam = vq->priv_data;
391 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
392 vb);
393 int rc;
394
395 DBG("%s, field=%d, fmt name = %s\n", __func__, field, cam->fmt != NULL ?
396 cam->fmt->name : "");
397 if (cam->fmt == NULL)
398 return -EINVAL;
399
400 buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
401
402 if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
403 DBG("invalid buffer prepare\n");
404 return -EINVAL;
405 }
406
407 buf->fmt = cam->fmt;
408 buf->vb.width = cam->width;
409 buf->vb.height = cam->height;
410 buf->vb.field = field;
411
412 if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
413 rc = videobuf_iolock(vq, &buf->vb, NULL);
414 if (rc < 0)
415 goto fail;
416 }
417
418 buf->vb.state = VIDEOBUF_PREPARED;
419 return 0;
420fail:
421 free_buffer(vq, buf);
422 return rc;
423}
424
425static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
426{
427 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
428 vb);
429 struct zr364xx_camera *cam = vq->priv_data;
430
431 _DBG("%s\n", __func__);
432
433 buf->vb.state = VIDEOBUF_QUEUED;
434 list_add_tail(&buf->vb.queue, &cam->vidq.active);
435}
436
437static void buffer_release(struct videobuf_queue *vq,
438 struct videobuf_buffer *vb)
439{
440 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
441 vb);
442
443 _DBG("%s\n", __func__);
444 free_buffer(vq, buf);
445}
446
447static struct videobuf_queue_ops zr364xx_video_qops = {
448 .buf_setup = buffer_setup,
449 .buf_prepare = buffer_prepare,
450 .buf_queue = buffer_queue,
451 .buf_release = buffer_release,
452};
453
454
455
456
457static int zr364xx_vidioc_streamon(struct file *file, void *priv,
458 enum v4l2_buf_type type);
459
460static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
461 loff_t * ppos)
462{
463 struct zr364xx_camera *cam = video_drvdata(file);
464 int err = 0;
465
466 _DBG("%s\n", __func__);
467
468 if (!buf)
469 return -EINVAL;
470
471 if (!count)
472 return -EINVAL;
473
474 if (mutex_lock_interruptible(&cam->lock))
475 return -ERESTARTSYS;
476
477 err = zr364xx_vidioc_streamon(file, file->private_data,
478 V4L2_BUF_TYPE_VIDEO_CAPTURE);
479 if (err == 0) {
480 DBG("%s: reading %d bytes at pos %d.\n", __func__,
481 (int) count, (int) *ppos);
482
483
484 err = videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
485 file->f_flags & O_NONBLOCK);
486 }
487 mutex_unlock(&cam->lock);
488 return err;
489}
490
491
492
493
494
495
496
497
498
499static void zr364xx_fillbuff(struct zr364xx_camera *cam,
500 struct zr364xx_buffer *buf,
501 int jpgsize)
502{
503 int pos = 0;
504 const char *tmpbuf;
505 char *vbuf = videobuf_to_vmalloc(&buf->vb);
506 unsigned long last_frame;
507
508 if (!vbuf)
509 return;
510
511 last_frame = cam->last_frame;
512 if (last_frame != -1) {
513 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
514 switch (buf->fmt->fourcc) {
515 case V4L2_PIX_FMT_JPEG:
516 buf->vb.size = jpgsize;
517 memcpy(vbuf, tmpbuf, buf->vb.size);
518 break;
519 default:
520 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
521 }
522 cam->last_frame = -1;
523 } else {
524 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
525 return;
526 }
527 DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
528 (unsigned long)vbuf, pos);
529
530
531 buf->vb.field_count = cam->frame_count * 2;
532 v4l2_get_timestamp(&buf->vb.ts);
533 buf->vb.state = VIDEOBUF_DONE;
534}
535
536static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
537{
538 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
539 struct zr364xx_buffer *buf;
540 unsigned long flags = 0;
541 int rc = 0;
542
543 DBG("wakeup: %p\n", &dma_q);
544 spin_lock_irqsave(&cam->slock, flags);
545
546 if (list_empty(&dma_q->active)) {
547 DBG("No active queue to serve\n");
548 rc = -1;
549 goto unlock;
550 }
551 buf = list_entry(dma_q->active.next,
552 struct zr364xx_buffer, vb.queue);
553
554 if (!waitqueue_active(&buf->vb.done)) {
555
556 rc = -1;
557 goto unlock;
558 }
559 list_del(&buf->vb.queue);
560 v4l2_get_timestamp(&buf->vb.ts);
561 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
562 zr364xx_fillbuff(cam, buf, jpgsize);
563 wake_up(&buf->vb.done);
564 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
565unlock:
566 spin_unlock_irqrestore(&cam->slock, flags);
567 return rc;
568}
569
570
571
572
573
574
575static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
576 struct zr364xx_pipeinfo *pipe_info,
577 struct urb *purb)
578{
579 unsigned char *pdest;
580 unsigned char *psrc;
581 s32 idx = -1;
582 struct zr364xx_framei *frm;
583 int i = 0;
584 unsigned char *ptr = NULL;
585
586 _DBG("buffer to user\n");
587 idx = cam->cur_frame;
588 frm = &cam->buffer.frame[idx];
589
590
591 if (cam->method == METHOD0) {
592 u16 *buf = (u16 *)pipe_info->transfer_buffer;
593 for (i = 0; i < purb->actual_length/2; i++)
594 swab16s(buf + i);
595 }
596
597
598 if (!cam->b_acquire) {
599
600 frm->ulState = ZR364XX_READ_IDLE;
601 return -EINVAL;
602 }
603
604 psrc = (u8 *)pipe_info->transfer_buffer;
605 ptr = pdest = frm->lpvbits;
606
607 if (frm->ulState == ZR364XX_READ_IDLE) {
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 "
638 "frame data. Discarding frame data.\n",
639 __func__, MAX_FRAME_SIZE);
640 } else {
641 pdest += frm->cur_size;
642 memcpy(pdest, psrc, purb->actual_length);
643 frm->cur_size += purb->actual_length;
644 }
645 }
646
647
648
649 if (purb->actual_length < pipe_info->transfer_size) {
650 _DBG("****************Buffer[%d]full*************\n", idx);
651 cam->last_frame = cam->cur_frame;
652 cam->cur_frame++;
653
654 if (cam->cur_frame == cam->buffer.dwFrames)
655 cam->cur_frame = 0;
656
657
658
659 ptr = pdest = frm->lpvbits;
660 ptr += frm->cur_size - 2;
661 while (ptr > pdest) {
662 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
663 && *(ptr + 2) == 0xFF)
664 break;
665 ptr--;
666 }
667 if (ptr == pdest)
668 DBG("No EOI marker\n");
669
670
671
672 while (ptr > pdest) {
673 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
674 && *(ptr + 2) == 0xFF)
675 break;
676 ptr--;
677 }
678 if (ptr != pdest) {
679 DBG("Bogus frame ? %d\n", ++(cam->nb));
680 } else if (cam->b_acquire) {
681
682 if (cam->skip)
683 cam->skip--;
684 else {
685 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
686 frm->cur_size,
687 pdest[0], pdest[1], pdest[2], pdest[3],
688 pdest[4], pdest[5], pdest[6], pdest[7]);
689
690 zr364xx_got_frame(cam, frm->cur_size);
691 }
692 }
693 cam->frame_count++;
694 frm->ulState = ZR364XX_READ_IDLE;
695 frm->cur_size = 0;
696 }
697
698 return 0;
699}
700
701static int zr364xx_vidioc_querycap(struct file *file, void *priv,
702 struct v4l2_capability *cap)
703{
704 struct zr364xx_camera *cam = video_drvdata(file);
705
706 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
707 strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
708 strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
709 sizeof(cap->bus_info));
710 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
711 V4L2_CAP_READWRITE |
712 V4L2_CAP_STREAMING;
713 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
714
715 return 0;
716}
717
718static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
719 struct v4l2_input *i)
720{
721 if (i->index != 0)
722 return -EINVAL;
723 strcpy(i->name, DRIVER_DESC " Camera");
724 i->type = V4L2_INPUT_TYPE_CAMERA;
725 return 0;
726}
727
728static int zr364xx_vidioc_g_input(struct file *file, void *priv,
729 unsigned int *i)
730{
731 *i = 0;
732 return 0;
733}
734
735static int zr364xx_vidioc_s_input(struct file *file, void *priv,
736 unsigned int i)
737{
738 if (i != 0)
739 return -EINVAL;
740 return 0;
741}
742
743static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
744{
745 struct zr364xx_camera *cam =
746 container_of(ctrl->handler, struct zr364xx_camera, ctrl_handler);
747 int temp;
748
749 switch (ctrl->id) {
750 case V4L2_CID_BRIGHTNESS:
751
752 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
753 temp = (0x60 << 8) + 127 - ctrl->val;
754 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
755 break;
756 default:
757 return -EINVAL;
758 }
759
760 return 0;
761}
762
763static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
764 void *priv, struct v4l2_fmtdesc *f)
765{
766 if (f->index > 0)
767 return -EINVAL;
768 f->flags = V4L2_FMT_FLAG_COMPRESSED;
769 strcpy(f->description, formats[0].name);
770 f->pixelformat = formats[0].fourcc;
771 return 0;
772}
773
774static char *decode_fourcc(__u32 pixelformat, char *buf)
775{
776 buf[0] = pixelformat & 0xff;
777 buf[1] = (pixelformat >> 8) & 0xff;
778 buf[2] = (pixelformat >> 16) & 0xff;
779 buf[3] = (pixelformat >> 24) & 0xff;
780 buf[4] = '\0';
781 return buf;
782}
783
784static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
785 struct v4l2_format *f)
786{
787 struct zr364xx_camera *cam = video_drvdata(file);
788 char pixelformat_name[5];
789
790 if (cam == NULL)
791 return -ENODEV;
792
793 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
794 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
795 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
796 return -EINVAL;
797 }
798
799 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
800 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
801 f->fmt.pix.width = 320;
802 f->fmt.pix.height = 240;
803 }
804
805 f->fmt.pix.field = V4L2_FIELD_NONE;
806 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
807 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
808 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
809 f->fmt.pix.priv = 0;
810 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
811 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
812 f->fmt.pix.field);
813 return 0;
814}
815
816static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
817 struct v4l2_format *f)
818{
819 struct zr364xx_camera *cam;
820
821 if (file == NULL)
822 return -ENODEV;
823 cam = video_drvdata(file);
824
825 f->fmt.pix.pixelformat = formats[0].fourcc;
826 f->fmt.pix.field = V4L2_FIELD_NONE;
827 f->fmt.pix.width = cam->width;
828 f->fmt.pix.height = cam->height;
829 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
830 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
831 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
832 f->fmt.pix.priv = 0;
833 return 0;
834}
835
836static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
837 struct v4l2_format *f)
838{
839 struct zr364xx_camera *cam = video_drvdata(file);
840 struct videobuf_queue *q = &cam->vb_vidq;
841 char pixelformat_name[5];
842 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
843 int i;
844
845 if (ret < 0)
846 return ret;
847
848 mutex_lock(&q->vb_lock);
849
850 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
851 DBG("%s queue busy\n", __func__);
852 ret = -EBUSY;
853 goto out;
854 }
855
856 if (cam->owner) {
857 DBG("%s can't change format after started\n", __func__);
858 ret = -EBUSY;
859 goto out;
860 }
861
862 cam->width = f->fmt.pix.width;
863 cam->height = f->fmt.pix.height;
864 DBG("%s: %dx%d mode selected\n", __func__,
865 cam->width, cam->height);
866 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
867 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
868 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
869 f->fmt.pix.priv = 0;
870 cam->vb_vidq.field = f->fmt.pix.field;
871
872 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
873 mode = 1;
874 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
875 mode = 2;
876 else
877 mode = 0;
878
879 m0d1[0] = mode;
880 m1[2].value = 0xf000 + mode;
881 m2[1].value = 0xf000 + mode;
882
883
884 if (cam->method == METHOD3) {
885 switch (mode) {
886 case 1:
887 m2[1].value = 0xf000 + 4;
888 break;
889 case 2:
890 m2[1].value = 0xf000 + 0;
891 break;
892 default:
893 m2[1].value = 0xf000 + 1;
894 break;
895 }
896 }
897
898 header2[437] = cam->height / 256;
899 header2[438] = cam->height % 256;
900 header2[439] = cam->width / 256;
901 header2[440] = cam->width % 256;
902
903 for (i = 0; init[cam->method][i].size != -1; i++) {
904 ret =
905 send_control_msg(cam->udev, 1, init[cam->method][i].value,
906 0, init[cam->method][i].bytes,
907 init[cam->method][i].size);
908 if (ret < 0) {
909 dev_err(&cam->udev->dev,
910 "error during resolution change sequence: %d\n", i);
911 goto out;
912 }
913 }
914
915
916
917
918 mdelay(100);
919 cam->skip = 2;
920 ret = 0;
921
922out:
923 mutex_unlock(&q->vb_lock);
924
925 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
926 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
927 f->fmt.pix.field);
928 return ret;
929}
930
931static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
932 struct v4l2_requestbuffers *p)
933{
934 struct zr364xx_camera *cam = video_drvdata(file);
935
936 if (cam->owner && cam->owner != priv)
937 return -EBUSY;
938 return videobuf_reqbufs(&cam->vb_vidq, p);
939}
940
941static int zr364xx_vidioc_querybuf(struct file *file,
942 void *priv,
943 struct v4l2_buffer *p)
944{
945 int rc;
946 struct zr364xx_camera *cam = video_drvdata(file);
947 rc = videobuf_querybuf(&cam->vb_vidq, p);
948 return rc;
949}
950
951static int zr364xx_vidioc_qbuf(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_qbuf(&cam->vb_vidq, p);
961 return rc;
962}
963
964static int zr364xx_vidioc_dqbuf(struct file *file,
965 void *priv,
966 struct v4l2_buffer *p)
967{
968 int rc;
969 struct zr364xx_camera *cam = video_drvdata(file);
970 _DBG("%s\n", __func__);
971 if (cam->owner && cam->owner != priv)
972 return -EBUSY;
973 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
974 return rc;
975}
976
977static void read_pipe_completion(struct urb *purb)
978{
979 struct zr364xx_pipeinfo *pipe_info;
980 struct zr364xx_camera *cam;
981 int pipe;
982
983 pipe_info = purb->context;
984 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
985 if (pipe_info == NULL) {
986 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
987 return;
988 }
989
990 cam = pipe_info->cam;
991 if (cam == NULL) {
992 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
993 return;
994 }
995
996
997 if (purb->status == -ESHUTDOWN) {
998 DBG("%s, err shutdown\n", __func__);
999 pipe_info->err_count++;
1000 return;
1001 }
1002
1003 if (pipe_info->state == 0) {
1004 DBG("exiting USB pipe\n");
1005 return;
1006 }
1007
1008 if (purb->actual_length > pipe_info->transfer_size) {
1009 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1010 return;
1011 }
1012
1013 if (purb->status == 0)
1014 zr364xx_read_video_callback(cam, pipe_info, purb);
1015 else {
1016 pipe_info->err_count++;
1017 DBG("%s: failed URB %d\n", __func__, purb->status);
1018 }
1019
1020 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1021
1022
1023 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1024 pipe,
1025 pipe_info->transfer_buffer,
1026 pipe_info->transfer_size,
1027 read_pipe_completion, pipe_info);
1028
1029 if (pipe_info->state != 0) {
1030 purb->status = usb_submit_urb(pipe_info->stream_urb,
1031 GFP_ATOMIC);
1032
1033 if (purb->status)
1034 dev_err(&cam->udev->dev,
1035 "error submitting urb (error=%i)\n",
1036 purb->status);
1037 } else
1038 DBG("read pipe complete state 0\n");
1039}
1040
1041static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1042{
1043 int pipe;
1044 int retval;
1045 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1046 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1047 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1048
1049 pipe_info->state = 1;
1050 pipe_info->err_count = 0;
1051 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1052 if (!pipe_info->stream_urb) {
1053 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1054 return -ENOMEM;
1055 }
1056
1057 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1058 pipe,
1059 pipe_info->transfer_buffer,
1060 pipe_info->transfer_size,
1061 read_pipe_completion, pipe_info);
1062
1063 DBG("submitting URB %p\n", pipe_info->stream_urb);
1064 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1065 if (retval) {
1066 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1067 return retval;
1068 }
1069
1070 return 0;
1071}
1072
1073static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1074{
1075 struct zr364xx_pipeinfo *pipe_info;
1076
1077 if (cam == NULL) {
1078 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1079 return;
1080 }
1081 DBG("stop read pipe\n");
1082 pipe_info = cam->pipe;
1083 if (pipe_info) {
1084 if (pipe_info->state != 0)
1085 pipe_info->state = 0;
1086
1087 if (pipe_info->stream_urb) {
1088
1089 usb_kill_urb(pipe_info->stream_urb);
1090 usb_free_urb(pipe_info->stream_urb);
1091 pipe_info->stream_urb = NULL;
1092 }
1093 }
1094 return;
1095}
1096
1097
1098static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1099{
1100 int j;
1101
1102 DBG("start acquire\n");
1103
1104 cam->last_frame = -1;
1105 cam->cur_frame = 0;
1106 for (j = 0; j < FRAMES; j++) {
1107 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1108 cam->buffer.frame[j].cur_size = 0;
1109 }
1110 cam->b_acquire = 1;
1111 return 0;
1112}
1113
1114static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1115{
1116 cam->b_acquire = 0;
1117 return 0;
1118}
1119
1120static int zr364xx_prepare(struct zr364xx_camera *cam)
1121{
1122 int res;
1123 int i, j;
1124
1125 for (i = 0; init[cam->method][i].size != -1; i++) {
1126 res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1127 0, init[cam->method][i].bytes,
1128 init[cam->method][i].size);
1129 if (res < 0) {
1130 dev_err(&cam->udev->dev,
1131 "error during open sequence: %d\n", i);
1132 return res;
1133 }
1134 }
1135
1136 cam->skip = 2;
1137 cam->last_frame = -1;
1138 cam->cur_frame = 0;
1139 cam->frame_count = 0;
1140 for (j = 0; j < FRAMES; j++) {
1141 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1142 cam->buffer.frame[j].cur_size = 0;
1143 }
1144 v4l2_ctrl_handler_setup(&cam->ctrl_handler);
1145 return 0;
1146}
1147
1148static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1149 enum v4l2_buf_type type)
1150{
1151 struct zr364xx_camera *cam = video_drvdata(file);
1152 int res;
1153
1154 DBG("%s\n", __func__);
1155
1156 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1157 return -EINVAL;
1158
1159 if (cam->owner && cam->owner != priv)
1160 return -EBUSY;
1161
1162 res = zr364xx_prepare(cam);
1163 if (res)
1164 return res;
1165 res = videobuf_streamon(&cam->vb_vidq);
1166 if (res == 0) {
1167 zr364xx_start_acquire(cam);
1168 cam->owner = file->private_data;
1169 }
1170 return res;
1171}
1172
1173static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1174 enum v4l2_buf_type type)
1175{
1176 struct zr364xx_camera *cam = video_drvdata(file);
1177
1178 DBG("%s\n", __func__);
1179 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1180 return -EINVAL;
1181 if (cam->owner && cam->owner != priv)
1182 return -EBUSY;
1183 zr364xx_stop_acquire(cam);
1184 return videobuf_streamoff(&cam->vb_vidq);
1185}
1186
1187
1188
1189static int zr364xx_open(struct file *file)
1190{
1191 struct zr364xx_camera *cam = video_drvdata(file);
1192 int err;
1193
1194 DBG("%s\n", __func__);
1195
1196 if (mutex_lock_interruptible(&cam->lock))
1197 return -ERESTARTSYS;
1198
1199 err = v4l2_fh_open(file);
1200 if (err)
1201 goto out;
1202
1203
1204
1205
1206 mdelay(100);
1207 err = 0;
1208
1209out:
1210 mutex_unlock(&cam->lock);
1211 DBG("%s: %d\n", __func__, err);
1212 return err;
1213}
1214
1215static void zr364xx_release(struct v4l2_device *v4l2_dev)
1216{
1217 struct zr364xx_camera *cam =
1218 container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
1219 unsigned long i;
1220
1221 v4l2_device_unregister(&cam->v4l2_dev);
1222
1223 videobuf_mmap_free(&cam->vb_vidq);
1224
1225
1226 for (i = 0; i < FRAMES; i++) {
1227 if (cam->buffer.frame[i].lpvbits) {
1228 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1229 vfree(cam->buffer.frame[i].lpvbits);
1230 }
1231 cam->buffer.frame[i].lpvbits = NULL;
1232 }
1233
1234 v4l2_ctrl_handler_free(&cam->ctrl_handler);
1235
1236 kfree(cam->pipe->transfer_buffer);
1237 kfree(cam);
1238}
1239
1240
1241static int zr364xx_close(struct file *file)
1242{
1243 struct zr364xx_camera *cam;
1244 struct usb_device *udev;
1245 int i;
1246
1247 DBG("%s\n", __func__);
1248 cam = video_drvdata(file);
1249
1250 mutex_lock(&cam->lock);
1251 udev = cam->udev;
1252
1253 if (file->private_data == cam->owner) {
1254
1255 if (cam->b_acquire)
1256 zr364xx_stop_acquire(cam);
1257 videobuf_streamoff(&cam->vb_vidq);
1258
1259 for (i = 0; i < 2; i++) {
1260 send_control_msg(udev, 1, init[cam->method][i].value,
1261 0, init[cam->method][i].bytes,
1262 init[cam->method][i].size);
1263 }
1264 cam->owner = NULL;
1265 }
1266
1267
1268
1269
1270 mdelay(100);
1271 mutex_unlock(&cam->lock);
1272 return v4l2_fh_release(file);
1273}
1274
1275
1276static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1277{
1278 struct zr364xx_camera *cam = video_drvdata(file);
1279 int ret;
1280
1281 if (cam == NULL) {
1282 DBG("%s: cam == NULL\n", __func__);
1283 return -ENODEV;
1284 }
1285 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1286
1287 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1288
1289 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1290 (unsigned long)vma->vm_start,
1291 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1292 return ret;
1293}
1294
1295static unsigned int zr364xx_poll(struct file *file,
1296 struct poll_table_struct *wait)
1297{
1298 struct zr364xx_camera *cam = video_drvdata(file);
1299 struct videobuf_queue *q = &cam->vb_vidq;
1300 unsigned res = v4l2_ctrl_poll(file, wait);
1301
1302 _DBG("%s\n", __func__);
1303
1304 return res | videobuf_poll_stream(file, q, wait);
1305}
1306
1307static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1308 .s_ctrl = zr364xx_s_ctrl,
1309};
1310
1311static const struct v4l2_file_operations zr364xx_fops = {
1312 .owner = THIS_MODULE,
1313 .open = zr364xx_open,
1314 .release = zr364xx_close,
1315 .read = zr364xx_read,
1316 .mmap = zr364xx_mmap,
1317 .unlocked_ioctl = video_ioctl2,
1318 .poll = zr364xx_poll,
1319};
1320
1321static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1322 .vidioc_querycap = zr364xx_vidioc_querycap,
1323 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1324 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1325 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1326 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
1327 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1328 .vidioc_g_input = zr364xx_vidioc_g_input,
1329 .vidioc_s_input = zr364xx_vidioc_s_input,
1330 .vidioc_streamon = zr364xx_vidioc_streamon,
1331 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1332 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1333 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1334 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1335 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
1336 .vidioc_log_status = v4l2_ctrl_log_status,
1337 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1338 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1339};
1340
1341static struct video_device zr364xx_template = {
1342 .name = DRIVER_DESC,
1343 .fops = &zr364xx_fops,
1344 .ioctl_ops = &zr364xx_ioctl_ops,
1345 .release = video_device_release_empty,
1346};
1347
1348
1349
1350
1351
1352
1353static int zr364xx_board_init(struct zr364xx_camera *cam)
1354{
1355 struct zr364xx_pipeinfo *pipe = cam->pipe;
1356 unsigned long i;
1357
1358 DBG("board init: %p\n", cam);
1359 memset(pipe, 0, sizeof(*pipe));
1360 pipe->cam = cam;
1361 pipe->transfer_size = BUFFER_SIZE;
1362
1363 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1364 GFP_KERNEL);
1365 if (pipe->transfer_buffer == NULL) {
1366 DBG("out of memory!\n");
1367 return -ENOMEM;
1368 }
1369
1370 cam->b_acquire = 0;
1371 cam->frame_count = 0;
1372
1373
1374 for (i = 0; i < FRAMES; i++) {
1375
1376 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1377
1378 DBG("valloc %p, idx %lu, pdata %p\n",
1379 &cam->buffer.frame[i], i,
1380 cam->buffer.frame[i].lpvbits);
1381 if (cam->buffer.frame[i].lpvbits == NULL) {
1382 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1383 "Using less frames\n");
1384 break;
1385 }
1386 }
1387
1388 if (i == 0) {
1389 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1390 kfree(cam->pipe->transfer_buffer);
1391 cam->pipe->transfer_buffer = NULL;
1392 return -ENOMEM;
1393 } else
1394 cam->buffer.dwFrames = i;
1395
1396
1397 for (i = 0; i < FRAMES; i++) {
1398 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1399 cam->buffer.frame[i].cur_size = 0;
1400 }
1401
1402 cam->cur_frame = 0;
1403 cam->last_frame = -1;
1404
1405
1406
1407 zr364xx_start_readpipe(cam);
1408 DBG(": board initialized\n");
1409 return 0;
1410}
1411
1412static int zr364xx_probe(struct usb_interface *intf,
1413 const struct usb_device_id *id)
1414{
1415 struct usb_device *udev = interface_to_usbdev(intf);
1416 struct zr364xx_camera *cam = NULL;
1417 struct usb_host_interface *iface_desc;
1418 struct usb_endpoint_descriptor *endpoint;
1419 struct v4l2_ctrl_handler *hdl;
1420 int err;
1421 int i;
1422
1423 DBG("probing...\n");
1424
1425 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1426 dev_info(&intf->dev, "model %04x:%04x detected\n",
1427 le16_to_cpu(udev->descriptor.idVendor),
1428 le16_to_cpu(udev->descriptor.idProduct));
1429
1430 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1431 if (cam == NULL) {
1432 dev_err(&udev->dev, "cam: out of memory !\n");
1433 return -ENOMEM;
1434 }
1435
1436 cam->v4l2_dev.release = zr364xx_release;
1437 err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1438 if (err < 0) {
1439 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1440 kfree(cam);
1441 return err;
1442 }
1443 hdl = &cam->ctrl_handler;
1444 v4l2_ctrl_handler_init(hdl, 1);
1445 v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1446 V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1447 if (hdl->error) {
1448 err = hdl->error;
1449 dev_err(&udev->dev, "couldn't register control\n");
1450 goto fail;
1451 }
1452
1453 cam->method = id->driver_info;
1454 mutex_init(&cam->lock);
1455 cam->vdev = zr364xx_template;
1456 cam->vdev.lock = &cam->lock;
1457 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1458 cam->vdev.ctrl_handler = &cam->ctrl_handler;
1459 set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags);
1460 video_set_drvdata(&cam->vdev, cam);
1461 if (debug)
1462 cam->vdev.debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1463
1464 cam->udev = udev;
1465
1466 switch (mode) {
1467 case 1:
1468 dev_info(&udev->dev, "160x120 mode selected\n");
1469 cam->width = 160;
1470 cam->height = 120;
1471 break;
1472 case 2:
1473 dev_info(&udev->dev, "640x480 mode selected\n");
1474 cam->width = 640;
1475 cam->height = 480;
1476 break;
1477 default:
1478 dev_info(&udev->dev, "320x240 mode selected\n");
1479 cam->width = 320;
1480 cam->height = 240;
1481 break;
1482 }
1483
1484 m0d1[0] = mode;
1485 m1[2].value = 0xf000 + mode;
1486 m2[1].value = 0xf000 + mode;
1487
1488
1489 if (cam->method == METHOD3) {
1490 switch (mode) {
1491 case 1:
1492 m2[1].value = 0xf000 + 4;
1493 break;
1494 case 2:
1495 m2[1].value = 0xf000 + 0;
1496 break;
1497 default:
1498 m2[1].value = 0xf000 + 1;
1499 break;
1500 }
1501 }
1502
1503 header2[437] = cam->height / 256;
1504 header2[438] = cam->height % 256;
1505 header2[439] = cam->width / 256;
1506 header2[440] = cam->width % 256;
1507
1508 cam->nb = 0;
1509
1510 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1511
1512
1513 iface_desc = intf->cur_altsetting;
1514 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1515 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1516 endpoint = &iface_desc->endpoint[i].desc;
1517 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1518
1519 cam->read_endpoint = endpoint->bEndpointAddress;
1520 }
1521 }
1522
1523 if (!cam->read_endpoint) {
1524 err = -ENOMEM;
1525 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1526 goto fail;
1527 }
1528
1529
1530 INIT_LIST_HEAD(&cam->vidq.active);
1531 cam->vidq.cam = cam;
1532
1533 usb_set_intfdata(intf, cam);
1534
1535
1536 err = zr364xx_board_init(cam);
1537 if (!err)
1538 err = v4l2_ctrl_handler_setup(hdl);
1539 if (err)
1540 goto fail;
1541
1542 spin_lock_init(&cam->slock);
1543
1544 cam->fmt = formats;
1545
1546 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1547 NULL, &cam->slock,
1548 V4L2_BUF_TYPE_VIDEO_CAPTURE,
1549 V4L2_FIELD_NONE,
1550 sizeof(struct zr364xx_buffer), cam, &cam->lock);
1551
1552 err = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1553 if (err) {
1554 dev_err(&udev->dev, "video_register_device failed\n");
1555 goto fail;
1556 }
1557
1558 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1559 video_device_node_name(&cam->vdev));
1560 return 0;
1561
1562fail:
1563 v4l2_ctrl_handler_free(hdl);
1564 v4l2_device_unregister(&cam->v4l2_dev);
1565 kfree(cam);
1566 return err;
1567}
1568
1569
1570static void zr364xx_disconnect(struct usb_interface *intf)
1571{
1572 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1573
1574 mutex_lock(&cam->lock);
1575 usb_set_intfdata(intf, NULL);
1576 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1577 video_unregister_device(&cam->vdev);
1578 v4l2_device_disconnect(&cam->v4l2_dev);
1579
1580
1581 if (cam->b_acquire)
1582 zr364xx_stop_acquire(cam);
1583
1584 zr364xx_stop_readpipe(cam);
1585 mutex_unlock(&cam->lock);
1586 v4l2_device_put(&cam->v4l2_dev);
1587}
1588
1589
1590#ifdef CONFIG_PM
1591static int zr364xx_suspend(struct usb_interface *intf, pm_message_t message)
1592{
1593 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1594
1595 cam->was_streaming = cam->b_acquire;
1596 if (!cam->was_streaming)
1597 return 0;
1598 zr364xx_stop_acquire(cam);
1599 zr364xx_stop_readpipe(cam);
1600 return 0;
1601}
1602
1603static int zr364xx_resume(struct usb_interface *intf)
1604{
1605 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1606 int res;
1607
1608 if (!cam->was_streaming)
1609 return 0;
1610
1611 zr364xx_start_readpipe(cam);
1612 res = zr364xx_prepare(cam);
1613 if (!res)
1614 zr364xx_start_acquire(cam);
1615 return res;
1616}
1617#endif
1618
1619
1620
1621
1622
1623static struct usb_driver zr364xx_driver = {
1624 .name = "zr364xx",
1625 .probe = zr364xx_probe,
1626 .disconnect = zr364xx_disconnect,
1627#ifdef CONFIG_PM
1628 .suspend = zr364xx_suspend,
1629 .resume = zr364xx_resume,
1630 .reset_resume = zr364xx_resume,
1631#endif
1632 .id_table = device_table
1633};
1634
1635module_usb_driver(zr364xx_driver);
1636
1637MODULE_AUTHOR(DRIVER_AUTHOR);
1638MODULE_DESCRIPTION(DRIVER_DESC);
1639MODULE_LICENSE("GPL");
1640MODULE_VERSION(DRIVER_VERSION);
1641