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