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