projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


28071ff756e2b63e9017653a04e3f7fe587fe65a
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / usb / au0828 / au0828-video.c
1 /*
2 * Auvitek AU0828 USB Bridge (Analog video support)
3 *
4 * Copyright (C) 2009 Devin Heitmueller <dheitmueller@linuxtv.org>
5 * Copyright (C) 2005-2008 Auvitek International, Ltd.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * As published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301, USA.
21 */
22
23 /* Developer Notes:
24 *
25 * VBI support is not yet working
26 * The hardware scaler supported is unimplemented
27 * AC97 audio support is unimplemented (only i2s audio mode)
28 *
29 */
30
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/init.h>
34 #include <linux/device.h>
35 #include <linux/suspend.h>
36 #include <media/v4l2-common.h>
37 #include <media/v4l2-ioctl.h>
38 #include <media/v4l2-chip-ident.h>
39 #include <media/tuner.h>
40 #include "au0828.h"
41 #include "au0828-reg.h"
42
43 static DEFINE_MUTEX(au0828_sysfs_lock);
44
45 /* ------------------------------------------------------------------
46 Videobuf operations
47 ------------------------------------------------------------------*/
48
49 static unsigned int isoc_debug;
50 module_param(isoc_debug, int, 0644);
51 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
52
53 #define au0828_isocdbg(fmt, arg...) \
54 do {\
55 if (isoc_debug) { \
56 printk(KERN_INFO "au0828 %s :"fmt, \
57 __func__ , ##arg); \
58 } \
59 } while (0)
60
61 static inline void print_err_status(struct au0828_dev *dev,
62 int packet, int status)
63 {
64 char *errmsg = "Unknown";
65
66 switch (status) {
67 case -ENOENT:
68 errmsg = "unlinked synchronuously";
69 break;
70 case -ECONNRESET:
71 errmsg = "unlinked asynchronuously";
72 break;
73 case -ENOSR:
74 errmsg = "Buffer error (overrun)";
75 break;
76 case -EPIPE:
77 errmsg = "Stalled (device not responding)";
78 break;
79 case -EOVERFLOW:
80 errmsg = "Babble (bad cable?)";
81 break;
82 case -EPROTO:
83 errmsg = "Bit-stuff error (bad cable?)";
84 break;
85 case -EILSEQ:
86 errmsg = "CRC/Timeout (could be anything)";
87 break;
88 case -ETIME:
89 errmsg = "Device does not respond";
90 break;
91 }
92 if (packet < 0) {
93 au0828_isocdbg("URB status %d [%s].\n", status, errmsg);
94 } else {
95 au0828_isocdbg("URB packet %d, status %d [%s].\n",
96 packet, status, errmsg);
97 }
98 }
99
100 static int check_dev(struct au0828_dev *dev)
101 {
102 if (dev->dev_state & DEV_DISCONNECTED) {
103 printk(KERN_INFO "v4l2 ioctl: device not present\n");
104 return -ENODEV;
105 }
106
107 if (dev->dev_state & DEV_MISCONFIGURED) {
108 printk(KERN_INFO "v4l2 ioctl: device is misconfigured; "
109 "close and open it again\n");
110 return -EIO;
111 }
112 return 0;
113 }
114
115 /*
116 * IRQ callback, called by URB callback
117 */
118 static void au0828_irq_callback(struct urb *urb)
119 {
120 struct au0828_dmaqueue *dma_q = urb->context;
121 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
122 unsigned long flags = 0;
123 int i;
124
125 switch (urb->status) {
126 case 0: /* success */
127 case -ETIMEDOUT: /* NAK */
128 break;
129 case -ECONNRESET: /* kill */
130 case -ENOENT:
131 case -ESHUTDOWN:
132 au0828_isocdbg("au0828_irq_callback called: status kill\n");
133 return;
134 default: /* unknown error */
135 au0828_isocdbg("urb completition error %d.\n", urb->status);
136 break;
137 }
138
139 /* Copy data from URB */
140 spin_lock_irqsave(&dev->slock, flags);
141 dev->isoc_ctl.isoc_copy(dev, urb);
142 spin_unlock_irqrestore(&dev->slock, flags);
143
144 /* Reset urb buffers */
145 for (i = 0; i < urb->number_of_packets; i++) {
146 urb->iso_frame_desc[i].status = 0;
147 urb->iso_frame_desc[i].actual_length = 0;
148 }
149 urb->status = 0;
150
151 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
152 if (urb->status) {
153 au0828_isocdbg("urb resubmit failed (error=%i)\n",
154 urb->status);
155 }
156 }
157
158 /*
159 * Stop and Deallocate URBs
160 */
161 static void au0828_uninit_isoc(struct au0828_dev *dev)
162 {
163 struct urb *urb;
164 int i;
165
166 au0828_isocdbg("au0828: called au0828_uninit_isoc\n");
167
168 dev->isoc_ctl.nfields = -1;
169 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
170 urb = dev->isoc_ctl.urb[i];
171 if (urb) {
172 if (!irqs_disabled())
173 usb_kill_urb(urb);
174 else
175 usb_unlink_urb(urb);
176
177 if (dev->isoc_ctl.transfer_buffer[i]) {
178 usb_free_coherent(dev->usbdev,
179 urb->transfer_buffer_length,
180 dev->isoc_ctl.transfer_buffer[i],
181 urb->transfer_dma);
182 }
183 usb_free_urb(urb);
184 dev->isoc_ctl.urb[i] = NULL;
185 }
186 dev->isoc_ctl.transfer_buffer[i] = NULL;
187 }
188
189 kfree(dev->isoc_ctl.urb);
190 kfree(dev->isoc_ctl.transfer_buffer);
191
192 dev->isoc_ctl.urb = NULL;
193 dev->isoc_ctl.transfer_buffer = NULL;
194 dev->isoc_ctl.num_bufs = 0;
195 }
196
197 /*
198 * Allocate URBs and start IRQ
199 */
200 static int au0828_init_isoc(struct au0828_dev *dev, int max_packets,
201 int num_bufs, int max_pkt_size,
202 int (*isoc_copy) (struct au0828_dev *dev, struct urb *urb))
203 {
204 struct au0828_dmaqueue *dma_q = &dev->vidq;
205 int i;
206 int sb_size, pipe;
207 struct urb *urb;
208 int j, k;
209 int rc;
210
211 au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
212
213 /* De-allocates all pending stuff */
214 au0828_uninit_isoc(dev);
215
216 dev->isoc_ctl.isoc_copy = isoc_copy;
217 dev->isoc_ctl.num_bufs = num_bufs;
218
219 dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
220 if (!dev->isoc_ctl.urb) {
221 au0828_isocdbg("cannot alloc memory for usb buffers\n");
222 return -ENOMEM;
223 }
224
225 dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
226 GFP_KERNEL);
227 if (!dev->isoc_ctl.transfer_buffer) {
228 au0828_isocdbg("cannot allocate memory for usb transfer\n");
229 kfree(dev->isoc_ctl.urb);
230 return -ENOMEM;
231 }
232
233 dev->isoc_ctl.max_pkt_size = max_pkt_size;
234 dev->isoc_ctl.buf = NULL;
235
236 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
237
238 /* allocate urbs and transfer buffers */
239 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
240 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
241 if (!urb) {
242 au0828_isocdbg("cannot alloc isoc_ctl.urb %i\n", i);
243 au0828_uninit_isoc(dev);
244 return -ENOMEM;
245 }
246 dev->isoc_ctl.urb[i] = urb;
247
248 dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->usbdev,
249 sb_size, GFP_KERNEL, &urb->transfer_dma);
250 if (!dev->isoc_ctl.transfer_buffer[i]) {
251 printk("unable to allocate %i bytes for transfer"
252 " buffer %i%s\n",
253 sb_size, i,
254 in_interrupt() ? " while in int" : "");
255 au0828_uninit_isoc(dev);
256 return -ENOMEM;
257 }
258 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
259
260 pipe = usb_rcvisocpipe(dev->usbdev,
261 dev->isoc_in_endpointaddr),
262
263 usb_fill_int_urb(urb, dev->usbdev, pipe,
264 dev->isoc_ctl.transfer_buffer[i], sb_size,
265 au0828_irq_callback, dma_q, 1);
266
267 urb->number_of_packets = max_packets;
268 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
269
270 k = 0;
271 for (j = 0; j < max_packets; j++) {
272 urb->iso_frame_desc[j].offset = k;
273 urb->iso_frame_desc[j].length =
274 dev->isoc_ctl.max_pkt_size;
275 k += dev->isoc_ctl.max_pkt_size;
276 }
277 }
278
279 init_waitqueue_head(&dma_q->wq);
280
281 /* submit urbs and enables IRQ */
282 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
283 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
284 if (rc) {
285 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
286 i, rc);
287 au0828_uninit_isoc(dev);
288 return rc;
289 }
290 }
291
292 return 0;
293 }
294
295 /*
296 * Announces that a buffer were filled and request the next
297 */
298 static inline void buffer_filled(struct au0828_dev *dev,
299 struct au0828_dmaqueue *dma_q,
300 struct au0828_buffer *buf)
301 {
302 /* Advice that buffer was filled */
303 au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
304
305 buf->vb.state = VIDEOBUF_DONE;
306 buf->vb.field_count++;
307 v4l2_get_timestamp(&buf->vb.ts);
308
309 dev->isoc_ctl.buf = NULL;
310
311 list_del(&buf->vb.queue);
312 wake_up(&buf->vb.done);
313 }
314
315 static inline void vbi_buffer_filled(struct au0828_dev *dev,
316 struct au0828_dmaqueue *dma_q,
317 struct au0828_buffer *buf)
318 {
319 /* Advice that buffer was filled */
320 au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
321
322 buf->vb.state = VIDEOBUF_DONE;
323 buf->vb.field_count++;
324 v4l2_get_timestamp(&buf->vb.ts);
325
326 dev->isoc_ctl.vbi_buf = NULL;
327
328 list_del(&buf->vb.queue);
329 wake_up(&buf->vb.done);
330 }
331
332 /*
333 * Identify the buffer header type and properly handles
334 */
335 static void au0828_copy_video(struct au0828_dev *dev,
336 struct au0828_dmaqueue *dma_q,
337 struct au0828_buffer *buf,
338 unsigned char *p,
339 unsigned char *outp, unsigned long len)
340 {
341 void *fieldstart, *startwrite, *startread;
342 int linesdone, currlinedone, offset, lencopy, remain;
343 int bytesperline = dev->width << 1; /* Assumes 16-bit depth @@@@ */
344
345 if (len == 0)
346 return;
347
348 if (dma_q->pos + len > buf->vb.size)
349 len = buf->vb.size - dma_q->pos;
350
351 startread = p;
352 remain = len;
353
354 /* Interlaces frame */
355 if (buf->top_field)
356 fieldstart = outp;
357 else
358 fieldstart = outp + bytesperline;
359
360 linesdone = dma_q->pos / bytesperline;
361 currlinedone = dma_q->pos % bytesperline;
362 offset = linesdone * bytesperline * 2 + currlinedone;
363 startwrite = fieldstart + offset;
364 lencopy = bytesperline - currlinedone;
365 lencopy = lencopy > remain ? remain : lencopy;
366
367 if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
368 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
369 ((char *)startwrite + lencopy) -
370 ((char *)outp + buf->vb.size));
371 remain = (char *)outp + buf->vb.size - (char *)startwrite;
372 lencopy = remain;
373 }
374 if (lencopy <= 0)
375 return;
376 memcpy(startwrite, startread, lencopy);
377
378 remain -= lencopy;
379
380 while (remain > 0) {
381 startwrite += lencopy + bytesperline;
382 startread += lencopy;
383 if (bytesperline > remain)
384 lencopy = remain;
385 else
386 lencopy = bytesperline;
387
388 if ((char *)startwrite + lencopy > (char *)outp +
389 buf->vb.size) {
390 au0828_isocdbg("Overflow %zi bytes past buf end (2)\n",
391 ((char *)startwrite + lencopy) -
392 ((char *)outp + buf->vb.size));
393 lencopy = remain = (char *)outp + buf->vb.size -
394 (char *)startwrite;
395 }
396 if (lencopy <= 0)
397 break;
398
399 memcpy(startwrite, startread, lencopy);
400
401 remain -= lencopy;
402 }
403
404 if (offset > 1440) {
405 /* We have enough data to check for greenscreen */
406 if (outp[0] < 0x60 && outp[1440] < 0x60)
407 dev->greenscreen_detected = 1;
408 }
409
410 dma_q->pos += len;
411 }
412
413 /*
414 * video-buf generic routine to get the next available buffer
415 */
416 static inline void get_next_buf(struct au0828_dmaqueue *dma_q,
417 struct au0828_buffer **buf)
418 {
419 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
420
421 if (list_empty(&dma_q->active)) {
422 au0828_isocdbg("No active queue to serve\n");
423 dev->isoc_ctl.buf = NULL;
424 *buf = NULL;
425 return;
426 }
427
428 /* Get the next buffer */
429 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
430 dev->isoc_ctl.buf = *buf;
431
432 return;
433 }
434
435 static void au0828_copy_vbi(struct au0828_dev *dev,
436 struct au0828_dmaqueue *dma_q,
437 struct au0828_buffer *buf,
438 unsigned char *p,
439 unsigned char *outp, unsigned long len)
440 {
441 unsigned char *startwrite, *startread;
442 int bytesperline;
443 int i, j = 0;
444
445 if (dev == NULL) {
446 au0828_isocdbg("dev is null\n");
447 return;
448 }
449
450 if (dma_q == NULL) {
451 au0828_isocdbg("dma_q is null\n");
452 return;
453 }
454 if (buf == NULL)
455 return;
456 if (p == NULL) {
457 au0828_isocdbg("p is null\n");
458 return;
459 }
460 if (outp == NULL) {
461 au0828_isocdbg("outp is null\n");
462 return;
463 }
464
465 bytesperline = dev->vbi_width;
466
467 if (dma_q->pos + len > buf->vb.size)
468 len = buf->vb.size - dma_q->pos;
469
470 startread = p;
471 startwrite = outp + (dma_q->pos / 2);
472
473 /* Make sure the bottom field populates the second half of the frame */
474 if (buf->top_field == 0)
475 startwrite += bytesperline * dev->vbi_height;
476
477 for (i = 0; i < len; i += 2)
478 startwrite[j++] = startread[i+1];
479
480 dma_q->pos += len;
481 }
482
483
484 /*
485 * video-buf generic routine to get the next available VBI buffer
486 */
487 static inline void vbi_get_next_buf(struct au0828_dmaqueue *dma_q,
488 struct au0828_buffer **buf)
489 {
490 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vbiq);
491 char *outp;
492
493 if (list_empty(&dma_q->active)) {
494 au0828_isocdbg("No active queue to serve\n");
495 dev->isoc_ctl.vbi_buf = NULL;
496 *buf = NULL;
497 return;
498 }
499
500 /* Get the next buffer */
501 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
502 /* Cleans up buffer - Useful for testing for frame/URB loss */
503 outp = videobuf_to_vmalloc(&(*buf)->vb);
504 memset(outp, 0x00, (*buf)->vb.size);
505
506 dev->isoc_ctl.vbi_buf = *buf;
507
508 return;
509 }
510
511 /*
512 * Controls the isoc copy of each urb packet
513 */
514 static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
515 {
516 struct au0828_buffer *buf;
517 struct au0828_buffer *vbi_buf;
518 struct au0828_dmaqueue *dma_q = urb->context;
519 struct au0828_dmaqueue *vbi_dma_q = &dev->vbiq;
520 unsigned char *outp = NULL;
521 unsigned char *vbioutp = NULL;
522 int i, len = 0, rc = 1;
523 unsigned char *p;
524 unsigned char fbyte;
525 unsigned int vbi_field_size;
526 unsigned int remain, lencopy;
527
528 if (!dev)
529 return 0;
530
531 if ((dev->dev_state & DEV_DISCONNECTED) ||
532 (dev->dev_state & DEV_MISCONFIGURED))
533 return 0;
534
535 if (urb->status < 0) {
536 print_err_status(dev, -1, urb->status);
537 if (urb->status == -ENOENT)
538 return 0;
539 }
540
541 buf = dev->isoc_ctl.buf;
542 if (buf != NULL)
543 outp = videobuf_to_vmalloc(&buf->vb);
544
545 vbi_buf = dev->isoc_ctl.vbi_buf;
546 if (vbi_buf != NULL)
547 vbioutp = videobuf_to_vmalloc(&vbi_buf->vb);
548
549 for (i = 0; i < urb->number_of_packets; i++) {
550 int status = urb->iso_frame_desc[i].status;
551
552 if (status < 0) {
553 print_err_status(dev, i, status);
554 if (urb->iso_frame_desc[i].status != -EPROTO)
555 continue;
556 }
557
558 if (urb->iso_frame_desc[i].actual_length <= 0)
559 continue;
560
561 if (urb->iso_frame_desc[i].actual_length >
562 dev->max_pkt_size) {
563 au0828_isocdbg("packet bigger than packet size");
564 continue;
565 }
566
567 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
568 fbyte = p[0];
569 len = urb->iso_frame_desc[i].actual_length - 4;
570 p += 4;
571
572 if (fbyte & 0x80) {
573 len -= 4;
574 p += 4;
575 au0828_isocdbg("Video frame %s\n",
576 (fbyte & 0x40) ? "odd" : "even");
577 if (fbyte & 0x40) {
578 /* VBI */
579 if (vbi_buf != NULL)
580 vbi_buffer_filled(dev,
581 vbi_dma_q,
582 vbi_buf);
583 vbi_get_next_buf(vbi_dma_q, &vbi_buf);
584 if (vbi_buf == NULL)
585 vbioutp = NULL;
586 else
587 vbioutp = videobuf_to_vmalloc(
588 &vbi_buf->vb);
589
590 /* Video */
591 if (buf != NULL)
592 buffer_filled(dev, dma_q, buf);
593 get_next_buf(dma_q, &buf);
594 if (buf == NULL)
595 outp = NULL;
596 else
597 outp = videobuf_to_vmalloc(&buf->vb);
598
599 /* As long as isoc traffic is arriving, keep
600 resetting the timer */
601 if (dev->vid_timeout_running)
602 mod_timer(&dev->vid_timeout,
603 jiffies + (HZ / 10));
604 if (dev->vbi_timeout_running)
605 mod_timer(&dev->vbi_timeout,
606 jiffies + (HZ / 10));
607 }
608
609 if (buf != NULL) {
610 if (fbyte & 0x40)
611 buf->top_field = 1;
612 else
613 buf->top_field = 0;
614 }
615
616 if (vbi_buf != NULL) {
617 if (fbyte & 0x40)
618 vbi_buf->top_field = 1;
619 else
620 vbi_buf->top_field = 0;
621 }
622
623 dev->vbi_read = 0;
624 vbi_dma_q->pos = 0;
625 dma_q->pos = 0;
626 }
627
628 vbi_field_size = dev->vbi_width * dev->vbi_height * 2;
629 if (dev->vbi_read < vbi_field_size) {
630 remain = vbi_field_size - dev->vbi_read;
631 if (len < remain)
632 lencopy = len;
633 else
634 lencopy = remain;
635
636 if (vbi_buf != NULL)
637 au0828_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
638 vbioutp, len);
639
640 len -= lencopy;
641 p += lencopy;
642 dev->vbi_read += lencopy;
643 }
644
645 if (dev->vbi_read >= vbi_field_size && buf != NULL)
646 au0828_copy_video(dev, dma_q, buf, p, outp, len);
647 }
648 return rc;
649 }
650
651 static int
652 buffer_setup(struct videobuf_queue *vq, unsigned int *count,
653 unsigned int *size)
654 {
655 struct au0828_fh *fh = vq->priv_data;
656 *size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
657
658 if (0 == *count)
659 *count = AU0828_DEF_BUF;
660
661 if (*count < AU0828_MIN_BUF)
662 *count = AU0828_MIN_BUF;
663 return 0;
664 }
665
666 /* This is called *without* dev->slock held; please keep it that way */
667 static void free_buffer(struct videobuf_queue *vq, struct au0828_buffer *buf)
668 {
669 struct au0828_fh *fh = vq->priv_data;
670 struct au0828_dev *dev = fh->dev;
671 unsigned long flags = 0;
672 if (in_interrupt())
673 BUG();
674
675 /* We used to wait for the buffer to finish here, but this didn't work
676 because, as we were keeping the state as VIDEOBUF_QUEUED,
677 videobuf_queue_cancel marked it as finished for us.
678 (Also, it could wedge forever if the hardware was misconfigured.)
679
680 This should be safe; by the time we get here, the buffer isn't
681 queued anymore. If we ever start marking the buffers as
682 VIDEOBUF_ACTIVE, it won't be, though.
683 */
684 spin_lock_irqsave(&dev->slock, flags);
685 if (dev->isoc_ctl.buf == buf)
686 dev->isoc_ctl.buf = NULL;
687 spin_unlock_irqrestore(&dev->slock, flags);
688
689 videobuf_vmalloc_free(&buf->vb);
690 buf->vb.state = VIDEOBUF_NEEDS_INIT;
691 }
692
693 static int
694 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
695 enum v4l2_field field)
696 {
697 struct au0828_fh *fh = vq->priv_data;
698 struct au0828_buffer *buf = container_of(vb, struct au0828_buffer, vb);
699 struct au0828_dev *dev = fh->dev;
700 int rc = 0, urb_init = 0;
701
702 buf->vb.size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
703
704 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
705 return -EINVAL;
706
707 buf->vb.width = dev->width;
708 buf->vb.height = dev->height;
709 buf->vb.field = field;
710
711 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
712 rc = videobuf_iolock(vq, &buf->vb, NULL);
713 if (rc < 0) {
714 printk(KERN_INFO "videobuf_iolock failed\n");
715 goto fail;
716 }
717 }
718
719 if (!dev->isoc_ctl.num_bufs)
720 urb_init = 1;
721
722 if (urb_init) {
723 rc = au0828_init_isoc(dev, AU0828_ISO_PACKETS_PER_URB,
724 AU0828_MAX_ISO_BUFS, dev->max_pkt_size,
725 au0828_isoc_copy);
726 if (rc < 0) {
727 printk(KERN_INFO "au0828_init_isoc failed\n");
728 goto fail;
729 }
730 }
731
732 buf->vb.state = VIDEOBUF_PREPARED;
733 return 0;
734
735 fail:
736 free_buffer(vq, buf);
737 return rc;
738 }
739
740 static void
741 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
742 {
743 struct au0828_buffer *buf = container_of(vb,
744 struct au0828_buffer,
745 vb);
746 struct au0828_fh *fh = vq->priv_data;
747 struct au0828_dev *dev = fh->dev;
748 struct au0828_dmaqueue *vidq = &dev->vidq;
749
750 buf->vb.state = VIDEOBUF_QUEUED;
751 list_add_tail(&buf->vb.queue, &vidq->active);
752 }
753
754 static void buffer_release(struct videobuf_queue *vq,
755 struct videobuf_buffer *vb)
756 {
757 struct au0828_buffer *buf = container_of(vb,
758 struct au0828_buffer,
759 vb);
760
761 free_buffer(vq, buf);
762 }
763
764 static struct videobuf_queue_ops au0828_video_qops = {
765 .buf_setup = buffer_setup,
766 .buf_prepare = buffer_prepare,
767 .buf_queue = buffer_queue,
768 .buf_release = buffer_release,
769 };
770
771 /* ------------------------------------------------------------------
772 V4L2 interface
773 ------------------------------------------------------------------*/
774
775 static int au0828_i2s_init(struct au0828_dev *dev)
776 {
777 /* Enable i2s mode */
778 au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
779 return 0;
780 }
781
782 /*
783 * Auvitek au0828 analog stream enable
784 * Please set interface0 to AS5 before enable the stream
785 */
786 static int au0828_analog_stream_enable(struct au0828_dev *d)
787 {
788 dprintk(1, "au0828_analog_stream_enable called\n");
789 au0828_writereg(d, AU0828_SENSORCTRL_VBI_103, 0x00);
790 au0828_writereg(d, 0x106, 0x00);
791 /* set x position */
792 au0828_writereg(d, 0x110, 0x00);
793 au0828_writereg(d, 0x111, 0x00);
794 au0828_writereg(d, 0x114, 0xa0);
795 au0828_writereg(d, 0x115, 0x05);
796 /* set y position */
797 au0828_writereg(d, 0x112, 0x00);
798 au0828_writereg(d, 0x113, 0x00);
799 au0828_writereg(d, 0x116, 0xf2);
800 au0828_writereg(d, 0x117, 0x00);
801 au0828_writereg(d, AU0828_SENSORCTRL_100, 0xb3);
802
803 return 0;
804 }
805
806 int au0828_analog_stream_disable(struct au0828_dev *d)
807 {
808 dprintk(1, "au0828_analog_stream_disable called\n");
809 au0828_writereg(d, AU0828_SENSORCTRL_100, 0x0);
810 return 0;
811 }
812
813 static void au0828_analog_stream_reset(struct au0828_dev *dev)
814 {
815 dprintk(1, "au0828_analog_stream_reset called\n");
816 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0x0);
817 mdelay(30);
818 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0xb3);
819 }
820
821 /*
822 * Some operations needs to stop current streaming
823 */
824 static int au0828_stream_interrupt(struct au0828_dev *dev)
825 {
826 int ret = 0;
827
828 dev->stream_state = STREAM_INTERRUPT;
829 if (dev->dev_state == DEV_DISCONNECTED)
830 return -ENODEV;
831 else if (ret) {
832 dev->dev_state = DEV_MISCONFIGURED;
833 dprintk(1, "%s device is misconfigured!\n", __func__);
834 return ret;
835 }
836 return 0;
837 }
838
839 /*
840 * au0828_release_resources
841 * unregister v4l2 devices
842 */
843 void au0828_analog_unregister(struct au0828_dev *dev)
844 {
845 dprintk(1, "au0828_release_resources called\n");
846 mutex_lock(&au0828_sysfs_lock);
847
848 if (dev->vdev)
849 video_unregister_device(dev->vdev);
850 if (dev->vbi_dev)
851 video_unregister_device(dev->vbi_dev);
852
853 mutex_unlock(&au0828_sysfs_lock);
854 }
855
856
857 /* Usage lock check functions */
858 static int res_get(struct au0828_fh *fh, unsigned int bit)
859 {
860 struct au0828_dev *dev = fh->dev;
861
862 if (fh->resources & bit)
863 /* have it already allocated */
864 return 1;
865
866 /* is it free? */
867 if (dev->resources & bit) {
868 /* no, someone else uses it */
869 return 0;
870 }
871 /* it's free, grab it */
872 fh->resources |= bit;
873 dev->resources |= bit;
874 dprintk(1, "res: get %d\n", bit);
875
876 return 1;
877 }
878
879 static int res_check(struct au0828_fh *fh, unsigned int bit)
880 {
881 return fh->resources & bit;
882 }
883
884 static int res_locked(struct au0828_dev *dev, unsigned int bit)
885 {
886 return dev->resources & bit;
887 }
888
889 static void res_free(struct au0828_fh *fh, unsigned int bits)
890 {
891 struct au0828_dev *dev = fh->dev;
892
893 BUG_ON((fh->resources & bits) != bits);
894
895 fh->resources &= ~bits;
896 dev->resources &= ~bits;
897 dprintk(1, "res: put %d\n", bits);
898 }
899
900 static int get_ressource(struct au0828_fh *fh)
901 {
902 switch (fh->type) {
903 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
904 return AU0828_RESOURCE_VIDEO;
905 case V4L2_BUF_TYPE_VBI_CAPTURE:
906 return AU0828_RESOURCE_VBI;
907 default:
908 BUG();
909 return 0;
910 }
911 }
912
913 /* This function ensures that video frames continue to be delivered even if
914 the ITU-656 input isn't receiving any data (thereby preventing applications
915 such as tvtime from hanging) */
916 static void au0828_vid_buffer_timeout(unsigned long data)
917 {
918 struct au0828_dev *dev = (struct au0828_dev *) data;
919 struct au0828_dmaqueue *dma_q = &dev->vidq;
920 struct au0828_buffer *buf;
921 unsigned char *vid_data;
922 unsigned long flags = 0;
923
924 spin_lock_irqsave(&dev->slock, flags);
925
926 buf = dev->isoc_ctl.buf;
927 if (buf != NULL) {
928 vid_data = videobuf_to_vmalloc(&buf->vb);
929 memset(vid_data, 0x00, buf->vb.size); /* Blank green frame */
930 buffer_filled(dev, dma_q, buf);
931 }
932 get_next_buf(dma_q, &buf);
933
934 if (dev->vid_timeout_running == 1)
935 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
936
937 spin_unlock_irqrestore(&dev->slock, flags);
938 }
939
940 static void au0828_vbi_buffer_timeout(unsigned long data)
941 {
942 struct au0828_dev *dev = (struct au0828_dev *) data;
943 struct au0828_dmaqueue *dma_q = &dev->vbiq;
944 struct au0828_buffer *buf;
945 unsigned char *vbi_data;
946 unsigned long flags = 0;
947
948 spin_lock_irqsave(&dev->slock, flags);
949
950 buf = dev->isoc_ctl.vbi_buf;
951 if (buf != NULL) {
952 vbi_data = videobuf_to_vmalloc(&buf->vb);
953 memset(vbi_data, 0x00, buf->vb.size);
954 vbi_buffer_filled(dev, dma_q, buf);
955 }
956 vbi_get_next_buf(dma_q, &buf);
957
958 if (dev->vbi_timeout_running == 1)
959 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
960 spin_unlock_irqrestore(&dev->slock, flags);
961 }
962
963
964 static int au0828_v4l2_open(struct file *filp)
965 {
966 int ret = 0;
967 struct video_device *vdev = video_devdata(filp);
968 struct au0828_dev *dev = video_drvdata(filp);
969 struct au0828_fh *fh;
970 int type;
971
972 switch (vdev->vfl_type) {
973 case VFL_TYPE_GRABBER:
974 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
975 break;
976 case VFL_TYPE_VBI:
977 type = V4L2_BUF_TYPE_VBI_CAPTURE;
978 break;
979 default:
980 return -EINVAL;
981 }
982
983 fh = kzalloc(sizeof(struct au0828_fh), GFP_KERNEL);
984 if (NULL == fh) {
985 dprintk(1, "Failed allocate au0828_fh struct!\n");
986 return -ENOMEM;
987 }
988
989 fh->type = type;
990 fh->dev = dev;
991 filp->private_data = fh;
992
993 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
994 /* set au0828 interface0 to AS5 here again */
995 ret = usb_set_interface(dev->usbdev, 0, 5);
996 if (ret < 0) {
997 printk(KERN_INFO "Au0828 can't set alternate to 5!\n");
998 return -EBUSY;
999 }
1000 dev->width = NTSC_STD_W;
1001 dev->height = NTSC_STD_H;
1002 dev->frame_size = dev->width * dev->height * 2;
1003 dev->field_size = dev->width * dev->height;
1004 dev->bytesperline = dev->width * 2;
1005
1006 au0828_analog_stream_enable(dev);
1007 au0828_analog_stream_reset(dev);
1008
1009 /* If we were doing ac97 instead of i2s, it would go here...*/
1010 au0828_i2s_init(dev);
1011
1012 dev->stream_state = STREAM_OFF;
1013 dev->dev_state |= DEV_INITIALIZED;
1014 }
1015
1016 dev->users++;
1017
1018 videobuf_queue_vmalloc_init(&fh->vb_vidq, &au0828_video_qops,
1019 NULL, &dev->slock,
1020 V4L2_BUF_TYPE_VIDEO_CAPTURE,
1021 V4L2_FIELD_INTERLACED,
1022 sizeof(struct au0828_buffer), fh,
1023 &dev->lock);
1024
1025 /* VBI Setup */
1026 dev->vbi_width = 720;
1027 dev->vbi_height = 1;
1028 videobuf_queue_vmalloc_init(&fh->vb_vbiq, &au0828_vbi_qops,
1029 NULL, &dev->slock,
1030 V4L2_BUF_TYPE_VBI_CAPTURE,
1031 V4L2_FIELD_SEQ_TB,
1032 sizeof(struct au0828_buffer), fh,
1033 &dev->lock);
1034 return ret;
1035 }
1036
1037 static int au0828_v4l2_close(struct file *filp)
1038 {
1039 int ret;
1040 struct au0828_fh *fh = filp->private_data;
1041 struct au0828_dev *dev = fh->dev;
1042
1043 if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
1044 /* Cancel timeout thread in case they didn't call streamoff */
1045 dev->vid_timeout_running = 0;
1046 del_timer_sync(&dev->vid_timeout);
1047
1048 videobuf_stop(&fh->vb_vidq);
1049 res_free(fh, AU0828_RESOURCE_VIDEO);
1050 }
1051
1052 if (res_check(fh, AU0828_RESOURCE_VBI)) {
1053 /* Cancel timeout thread in case they didn't call streamoff */
1054 dev->vbi_timeout_running = 0;
1055 del_timer_sync(&dev->vbi_timeout);
1056
1057 videobuf_stop(&fh->vb_vbiq);
1058 res_free(fh, AU0828_RESOURCE_VBI);
1059 }
1060
1061 if (dev->users == 1) {
1062 if (dev->dev_state & DEV_DISCONNECTED) {
1063 au0828_analog_unregister(dev);
1064 kfree(dev);
1065 return 0;
1066 }
1067
1068 au0828_analog_stream_disable(dev);
1069
1070 au0828_uninit_isoc(dev);
1071
1072 /* Save some power by putting tuner to sleep */
1073 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
1074
1075 /* When close the device, set the usb intf0 into alt0 to free
1076 USB bandwidth */
1077 ret = usb_set_interface(dev->usbdev, 0, 0);
1078 if (ret < 0)
1079 printk(KERN_INFO "Au0828 can't set alternate to 0!\n");
1080 }
1081
1082 videobuf_mmap_free(&fh->vb_vidq);
1083 videobuf_mmap_free(&fh->vb_vbiq);
1084 kfree(fh);
1085 dev->users--;
1086 wake_up_interruptible_nr(&dev->open, 1);
1087 return 0;
1088 }
1089
1090 static ssize_t au0828_v4l2_read(struct file *filp, char __user *buf,
1091 size_t count, loff_t *pos)
1092 {
1093 struct au0828_fh *fh = filp->private_data;
1094 struct au0828_dev *dev = fh->dev;
1095 int rc;
1096
1097 rc = check_dev(dev);
1098 if (rc < 0)
1099 return rc;
1100
1101 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1102 if (res_locked(dev, AU0828_RESOURCE_VIDEO))
1103 return -EBUSY;
1104
1105 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
1106 filp->f_flags & O_NONBLOCK);
1107 }
1108
1109 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1110 if (!res_get(fh, AU0828_RESOURCE_VBI))
1111 return -EBUSY;
1112
1113 if (dev->vbi_timeout_running == 0) {
1114 /* Handle case where caller tries to read without
1115 calling streamon first */
1116 dev->vbi_timeout_running = 1;
1117 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1118 }
1119
1120 return videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
1121 filp->f_flags & O_NONBLOCK);
1122 }
1123
1124 return 0;
1125 }
1126
1127 static unsigned int au0828_v4l2_poll(struct file *filp, poll_table *wait)
1128 {
1129 struct au0828_fh *fh = filp->private_data;
1130 struct au0828_dev *dev = fh->dev;
1131 int rc;
1132
1133 rc = check_dev(dev);
1134 if (rc < 0)
1135 return rc;
1136
1137 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1138 if (!res_get(fh, AU0828_RESOURCE_VIDEO))
1139 return POLLERR;
1140 return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
1141 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1142 if (!res_get(fh, AU0828_RESOURCE_VBI))
1143 return POLLERR;
1144 return videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
1145 } else {
1146 return POLLERR;
1147 }
1148 }
1149
1150 static int au0828_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
1151 {
1152 struct au0828_fh *fh = filp->private_data;
1153 struct au0828_dev *dev = fh->dev;
1154 int rc;
1155
1156 rc = check_dev(dev);
1157 if (rc < 0)
1158 return rc;
1159
1160 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1161 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1162 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1163 rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma);
1164
1165 return rc;
1166 }
1167
1168 static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
1169 struct v4l2_format *format)
1170 {
1171 int ret;
1172 int width = format->fmt.pix.width;
1173 int height = format->fmt.pix.height;
1174
1175 if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1176 return -EINVAL;
1177
1178 /* If they are demanding a format other than the one we support,
1179 bail out (tvtime asks for UYVY and then retries with YUYV) */
1180 if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
1181 return -EINVAL;
1182
1183 /* format->fmt.pix.width only support 720 and height 480 */
1184 if (width != 720)
1185 width = 720;
1186 if (height != 480)
1187 height = 480;
1188
1189 format->fmt.pix.width = width;
1190 format->fmt.pix.height = height;
1191 format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1192 format->fmt.pix.bytesperline = width * 2;
1193 format->fmt.pix.sizeimage = width * height * 2;
1194 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1195 format->fmt.pix.field = V4L2_FIELD_INTERLACED;
1196
1197 if (cmd == VIDIOC_TRY_FMT)
1198 return 0;
1199
1200 /* maybe set new image format, driver current only support 720*480 */
1201 dev->width = width;
1202 dev->height = height;
1203 dev->frame_size = width * height * 2;
1204 dev->field_size = width * height;
1205 dev->bytesperline = width * 2;
1206
1207 if (dev->stream_state == STREAM_ON) {
1208 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
1209 ret = au0828_stream_interrupt(dev);
1210 if (ret != 0) {
1211 dprintk(1, "error interrupting video stream!\n");
1212 return ret;
1213 }
1214 }
1215
1216 /* set au0828 interface0 to AS5 here again */
1217 ret = usb_set_interface(dev->usbdev, 0, 5);
1218 if (ret < 0) {
1219 printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
1220 return -EBUSY;
1221 }
1222
1223 au0828_analog_stream_enable(dev);
1224
1225 return 0;
1226 }
1227
1228
1229 static int vidioc_queryctrl(struct file *file, void *priv,
1230 struct v4l2_queryctrl *qc)
1231 {
1232 struct au0828_fh *fh = priv;
1233 struct au0828_dev *dev = fh->dev;
1234 v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, qc);
1235 if (qc->type)
1236 return 0;
1237 else
1238 return -EINVAL;
1239 }
1240
1241 static int vidioc_querycap(struct file *file, void *priv,
1242 struct v4l2_capability *cap)
1243 {
1244 struct video_device *vdev = video_devdata(file);
1245 struct au0828_fh *fh = priv;
1246 struct au0828_dev *dev = fh->dev;
1247
1248 strlcpy(cap->driver, "au0828", sizeof(cap->driver));
1249 strlcpy(cap->card, dev->board.name, sizeof(cap->card));
1250 usb_make_path(dev->usbdev, cap->bus_info, sizeof(cap->bus_info));
1251
1252 /* set the device capabilities */
1253 cap->device_caps = V4L2_CAP_AUDIO |
1254 V4L2_CAP_READWRITE |
1255 V4L2_CAP_STREAMING |
1256 V4L2_CAP_TUNER;
1257 if (vdev->vfl_type == VFL_TYPE_GRABBER)
1258 cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
1259 else
1260 cap->device_caps |= V4L2_CAP_VBI_CAPTURE;
1261 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1262 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE;
1263 return 0;
1264 }
1265
1266 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1267 struct v4l2_fmtdesc *f)
1268 {
1269 if (f->index)
1270 return -EINVAL;
1271
1272 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1273 strcpy(f->description, "Packed YUV2");
1274
1275 f->flags = 0;
1276 f->pixelformat = V4L2_PIX_FMT_UYVY;
1277
1278 return 0;
1279 }
1280
1281 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1282 struct v4l2_format *f)
1283 {
1284 struct au0828_fh *fh = priv;
1285 struct au0828_dev *dev = fh->dev;
1286
1287 f->fmt.pix.width = dev->width;
1288 f->fmt.pix.height = dev->height;
1289 f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1290 f->fmt.pix.bytesperline = dev->bytesperline;
1291 f->fmt.pix.sizeimage = dev->frame_size;
1292 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
1293 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1294 return 0;
1295 }
1296
1297 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1298 struct v4l2_format *f)
1299 {
1300 struct au0828_fh *fh = priv;
1301 struct au0828_dev *dev = fh->dev;
1302
1303 return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1304 }
1305
1306 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1307 struct v4l2_format *f)
1308 {
1309 struct au0828_fh *fh = priv;
1310 struct au0828_dev *dev = fh->dev;
1311 int rc;
1312
1313 rc = check_dev(dev);
1314 if (rc < 0)
1315 return rc;
1316
1317 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1318 printk(KERN_INFO "%s queue busy\n", __func__);
1319 rc = -EBUSY;
1320 goto out;
1321 }
1322
1323 rc = au0828_set_format(dev, VIDIOC_S_FMT, f);
1324 out:
1325 return rc;
1326 }
1327
1328 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1329 {
1330 struct au0828_fh *fh = priv;
1331 struct au0828_dev *dev = fh->dev;
1332
1333 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1334 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 1);
1335
1336 /* FIXME: when we support something other than NTSC, we are going to
1337 have to make the au0828 bridge adjust the size of its capture
1338 buffer, which is currently hardcoded at 720x480 */
1339
1340 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, norm);
1341 dev->std_set_in_tuner_core = 1;
1342
1343 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1344 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 0);
1345
1346 return 0;
1347 }
1348
1349 static int vidioc_enum_input(struct file *file, void *priv,
1350 struct v4l2_input *input)
1351 {
1352 struct au0828_fh *fh = priv;
1353 struct au0828_dev *dev = fh->dev;
1354 unsigned int tmp;
1355
1356 static const char *inames[] = {
1357 [AU0828_VMUX_UNDEFINED] = "Undefined",
1358 [AU0828_VMUX_COMPOSITE] = "Composite",
1359 [AU0828_VMUX_SVIDEO] = "S-Video",
1360 [AU0828_VMUX_CABLE] = "Cable TV",
1361 [AU0828_VMUX_TELEVISION] = "Television",
1362 [AU0828_VMUX_DVB] = "DVB",
1363 [AU0828_VMUX_DEBUG] = "tv debug"
1364 };
1365
1366 tmp = input->index;
1367
1368 if (tmp >= AU0828_MAX_INPUT)
1369 return -EINVAL;
1370 if (AUVI_INPUT(tmp).type == 0)
1371 return -EINVAL;
1372
1373 input->index = tmp;
1374 strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
1375 if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
1376 (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE)) {
1377 input->type |= V4L2_INPUT_TYPE_TUNER;
1378 input->audioset = 1;
1379 } else {
1380 input->type |= V4L2_INPUT_TYPE_CAMERA;
1381 input->audioset = 2;
1382 }
1383
1384 input->std = dev->vdev->tvnorms;
1385
1386 return 0;
1387 }
1388
1389 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1390 {
1391 struct au0828_fh *fh = priv;
1392 struct au0828_dev *dev = fh->dev;
1393 *i = dev->ctrl_input;
1394 return 0;
1395 }
1396
1397 static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1398 {
1399 struct au0828_fh *fh = priv;
1400 struct au0828_dev *dev = fh->dev;
1401 int i;
1402
1403 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
1404 index);
1405 if (index >= AU0828_MAX_INPUT)
1406 return -EINVAL;
1407 if (AUVI_INPUT(index).type == 0)
1408 return -EINVAL;
1409 dev->ctrl_input = index;
1410
1411 switch (AUVI_INPUT(index).type) {
1412 case AU0828_VMUX_SVIDEO:
1413 dev->input_type = AU0828_VMUX_SVIDEO;
1414 dev->ctrl_ainput = 1;
1415 break;
1416 case AU0828_VMUX_COMPOSITE:
1417 dev->input_type = AU0828_VMUX_COMPOSITE;
1418 dev->ctrl_ainput = 1;
1419 break;
1420 case AU0828_VMUX_TELEVISION:
1421 dev->input_type = AU0828_VMUX_TELEVISION;
1422 dev->ctrl_ainput = 0;
1423 break;
1424 default:
1425 dprintk(1, "VIDIOC_S_INPUT unknown input type set [%d]\n",
1426 AUVI_INPUT(index).type);
1427 break;
1428 }
1429
1430 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1431 AUVI_INPUT(index).vmux, 0, 0);
1432
1433 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1434 int enable = 0;
1435 if (AUVI_INPUT(i).audio_setup == NULL)
1436 continue;
1437
1438 if (i == index)
1439 enable = 1;
1440 else
1441 enable = 0;
1442 if (enable) {
1443 (AUVI_INPUT(i).audio_setup)(dev, enable);
1444 } else {
1445 /* Make sure we leave it turned on if some
1446 other input is routed to this callback */
1447 if ((AUVI_INPUT(i).audio_setup) !=
1448 ((AUVI_INPUT(index).audio_setup))) {
1449 (AUVI_INPUT(i).audio_setup)(dev, enable);
1450 }
1451 }
1452 }
1453
1454 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1455 AUVI_INPUT(index).amux, 0, 0);
1456 return 0;
1457 }
1458
1459 static int vidioc_enumaudio(struct file *file, void *priv, struct v4l2_audio *a)
1460 {
1461 if (a->index > 1)
1462 return -EINVAL;
1463
1464 if (a->index == 0)
1465 strcpy(a->name, "Television");
1466 else
1467 strcpy(a->name, "Line in");
1468
1469 a->capability = V4L2_AUDCAP_STEREO;
1470 return 0;
1471 }
1472
1473 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1474 {
1475 struct au0828_fh *fh = priv;
1476 struct au0828_dev *dev = fh->dev;
1477
1478 a->index = dev->ctrl_ainput;
1479 if (a->index == 0)
1480 strcpy(a->name, "Television");
1481 else
1482 strcpy(a->name, "Line in");
1483
1484 a->capability = V4L2_AUDCAP_STEREO;
1485 return 0;
1486 }
1487
1488 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1489 {
1490 struct au0828_fh *fh = priv;
1491 struct au0828_dev *dev = fh->dev;
1492
1493 if (a->index != dev->ctrl_ainput)
1494 return -EINVAL;
1495 return 0;
1496 }
1497
1498 static int vidioc_g_ctrl(struct file *file, void *priv,
1499 struct v4l2_control *ctrl)
1500 {
1501 struct au0828_fh *fh = priv;
1502 struct au0828_dev *dev = fh->dev;
1503
1504 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl);
1505 return 0;
1506
1507 }
1508
1509 static int vidioc_s_ctrl(struct file *file, void *priv,
1510 struct v4l2_control *ctrl)
1511 {
1512 struct au0828_fh *fh = priv;
1513 struct au0828_dev *dev = fh->dev;
1514 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_ctrl, ctrl);
1515 return 0;
1516 }
1517
1518 static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1519 {
1520 struct au0828_fh *fh = priv;
1521 struct au0828_dev *dev = fh->dev;
1522
1523 if (t->index != 0)
1524 return -EINVAL;
1525
1526 strcpy(t->name, "Auvitek tuner");
1527 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1528 return 0;
1529 }
1530
1531 static int vidioc_s_tuner(struct file *file, void *priv,
1532 const struct v4l2_tuner *t)
1533 {
1534 struct au0828_fh *fh = priv;
1535 struct au0828_dev *dev = fh->dev;
1536
1537 if (t->index != 0)
1538 return -EINVAL;
1539
1540 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1541 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 1);
1542
1543 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1544
1545 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1546 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 0);
1547
1548 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1549 t->afc);
1550
1551 return 0;
1552
1553 }
1554
1555 static int vidioc_g_frequency(struct file *file, void *priv,
1556 struct v4l2_frequency *freq)
1557 {
1558 struct au0828_fh *fh = priv;
1559 struct au0828_dev *dev = fh->dev;
1560
1561 if (freq->tuner != 0)
1562 return -EINVAL;
1563 freq->frequency = dev->ctrl_freq;
1564 return 0;
1565 }
1566
1567 static int vidioc_s_frequency(struct file *file, void *priv,
1568 const struct v4l2_frequency *freq)
1569 {
1570 struct au0828_fh *fh = priv;
1571 struct au0828_dev *dev = fh->dev;
1572 struct v4l2_frequency new_freq = *freq;
1573
1574 if (freq->tuner != 0)
1575 return -EINVAL;
1576
1577 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1578 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 1);
1579
1580 if (dev->std_set_in_tuner_core == 0) {
1581 /* If we've never sent the standard in tuner core, do so now.
1582 We don't do this at device probe because we don't want to
1583 incur the cost of a firmware load */
1584 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std,
1585 dev->vdev->tvnorms);
1586 dev->std_set_in_tuner_core = 1;
1587 }
1588
1589 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
1590 /* Get the actual set (and possibly clamped) frequency */
1591 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1592 dev->ctrl_freq = new_freq.frequency;
1593
1594 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1595 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 0);
1596
1597 au0828_analog_stream_reset(dev);
1598
1599 return 0;
1600 }
1601
1602
1603 /* RAW VBI ioctls */
1604
1605 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1606 struct v4l2_format *format)
1607 {
1608 struct au0828_fh *fh = priv;
1609 struct au0828_dev *dev = fh->dev;
1610
1611 format->fmt.vbi.samples_per_line = dev->vbi_width;
1612 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1613 format->fmt.vbi.offset = 0;
1614 format->fmt.vbi.flags = 0;
1615 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1616
1617 format->fmt.vbi.count[0] = dev->vbi_height;
1618 format->fmt.vbi.count[1] = dev->vbi_height;
1619 format->fmt.vbi.start[0] = 21;
1620 format->fmt.vbi.start[1] = 284;
1621
1622 return 0;
1623 }
1624
1625 static int vidioc_g_chip_ident(struct file *file, void *priv,
1626 struct v4l2_dbg_chip_ident *chip)
1627 {
1628 struct au0828_fh *fh = priv;
1629 struct au0828_dev *dev = fh->dev;
1630 chip->ident = V4L2_IDENT_NONE;
1631 chip->revision = 0;
1632
1633 if (v4l2_chip_match_host(&chip->match)) {
1634 chip->ident = V4L2_IDENT_AU0828;
1635 return 0;
1636 }
1637
1638 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
1639 if (chip->ident == V4L2_IDENT_NONE)
1640 return -EINVAL;
1641
1642 return 0;
1643 }
1644
1645 static int vidioc_cropcap(struct file *file, void *priv,
1646 struct v4l2_cropcap *cc)
1647 {
1648 struct au0828_fh *fh = priv;
1649 struct au0828_dev *dev = fh->dev;
1650
1651 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1652 return -EINVAL;
1653
1654 cc->bounds.left = 0;
1655 cc->bounds.top = 0;
1656 cc->bounds.width = dev->width;
1657 cc->bounds.height = dev->height;
1658
1659 cc->defrect = cc->bounds;
1660
1661 cc->pixelaspect.numerator = 54;
1662 cc->pixelaspect.denominator = 59;
1663
1664 return 0;
1665 }
1666
1667 static int vidioc_streamon(struct file *file, void *priv,
1668 enum v4l2_buf_type type)
1669 {
1670 struct au0828_fh *fh = priv;
1671 struct au0828_dev *dev = fh->dev;
1672 int rc = -EINVAL;
1673
1674 rc = check_dev(dev);
1675 if (rc < 0)
1676 return rc;
1677
1678 if (unlikely(type != fh->type))
1679 return -EINVAL;
1680
1681 dprintk(1, "vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
1682 fh, type, fh->resources, dev->resources);
1683
1684 if (unlikely(!res_get(fh, get_ressource(fh))))
1685 return -EBUSY;
1686
1687 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1688 au0828_analog_stream_enable(dev);
1689 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
1690 }
1691
1692 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1693 rc = videobuf_streamon(&fh->vb_vidq);
1694 dev->vid_timeout_running = 1;
1695 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1696 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1697 rc = videobuf_streamon(&fh->vb_vbiq);
1698 dev->vbi_timeout_running = 1;
1699 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1700 }
1701
1702 return rc;
1703 }
1704
1705 static int vidioc_streamoff(struct file *file, void *priv,
1706 enum v4l2_buf_type type)
1707 {
1708 struct au0828_fh *fh = priv;
1709 struct au0828_dev *dev = fh->dev;
1710 int rc;
1711 int i;
1712
1713 rc = check_dev(dev);
1714 if (rc < 0)
1715 return rc;
1716
1717 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1718 fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
1719 return -EINVAL;
1720 if (type != fh->type)
1721 return -EINVAL;
1722
1723 dprintk(1, "vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
1724 fh, type, fh->resources, dev->resources);
1725
1726 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1727 dev->vid_timeout_running = 0;
1728 del_timer_sync(&dev->vid_timeout);
1729
1730 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1731 rc = au0828_stream_interrupt(dev);
1732 if (rc != 0)
1733 return rc;
1734
1735 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1736 if (AUVI_INPUT(i).audio_setup == NULL)
1737 continue;
1738 (AUVI_INPUT(i).audio_setup)(dev, 0);
1739 }
1740
1741 if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
1742 videobuf_streamoff(&fh->vb_vidq);
1743 res_free(fh, AU0828_RESOURCE_VIDEO);
1744 }
1745 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1746 dev->vbi_timeout_running = 0;
1747 del_timer_sync(&dev->vbi_timeout);
1748
1749 if (res_check(fh, AU0828_RESOURCE_VBI)) {
1750 videobuf_streamoff(&fh->vb_vbiq);
1751 res_free(fh, AU0828_RESOURCE_VBI);
1752 }
1753 }
1754
1755 return 0;
1756 }
1757
1758 #ifdef CONFIG_VIDEO_ADV_DEBUG
1759 static int vidioc_g_register(struct file *file, void *priv,
1760 struct v4l2_dbg_register *reg)
1761 {
1762 struct au0828_fh *fh = priv;
1763 struct au0828_dev *dev = fh->dev;
1764
1765 switch (reg->match.type) {
1766 case V4L2_CHIP_MATCH_I2C_DRIVER:
1767 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
1768 return 0;
1769 default:
1770 if (!v4l2_chip_match_host(&reg->match))
1771 return -EINVAL;
1772 }
1773
1774 reg->val = au0828_read(dev, reg->reg);
1775 return 0;
1776 }
1777
1778 static int vidioc_s_register(struct file *file, void *priv,
1779 const struct v4l2_dbg_register *reg)
1780 {
1781 struct au0828_fh *fh = priv;
1782 struct au0828_dev *dev = fh->dev;
1783
1784 switch (reg->match.type) {
1785 case V4L2_CHIP_MATCH_I2C_DRIVER:
1786 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
1787 return 0;
1788 default:
1789 if (!v4l2_chip_match_host(&reg->match))
1790 return -EINVAL;
1791 }
1792 return au0828_writereg(dev, reg->reg, reg->val);
1793 }
1794 #endif
1795
1796 static int vidioc_reqbufs(struct file *file, void *priv,
1797 struct v4l2_requestbuffers *rb)
1798 {
1799 struct au0828_fh *fh = priv;
1800 struct au0828_dev *dev = fh->dev;
1801 int rc;
1802
1803 rc = check_dev(dev);
1804 if (rc < 0)
1805 return rc;
1806
1807 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1808 rc = videobuf_reqbufs(&fh->vb_vidq, rb);
1809 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1810 rc = videobuf_reqbufs(&fh->vb_vbiq, rb);
1811
1812 return rc;
1813 }
1814
1815 static int vidioc_querybuf(struct file *file, void *priv,
1816 struct v4l2_buffer *b)
1817 {
1818 struct au0828_fh *fh = priv;
1819 struct au0828_dev *dev = fh->dev;
1820 int rc;
1821
1822 rc = check_dev(dev);
1823 if (rc < 0)
1824 return rc;
1825
1826 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1827 rc = videobuf_querybuf(&fh->vb_vidq, b);
1828 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1829 rc = videobuf_querybuf(&fh->vb_vbiq, b);
1830
1831 return rc;
1832 }
1833
1834 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1835 {
1836 struct au0828_fh *fh = priv;
1837 struct au0828_dev *dev = fh->dev;
1838 int rc;
1839
1840 rc = check_dev(dev);
1841 if (rc < 0)
1842 return rc;
1843
1844 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1845 rc = videobuf_qbuf(&fh->vb_vidq, b);
1846 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1847 rc = videobuf_qbuf(&fh->vb_vbiq, b);
1848
1849 return rc;
1850 }
1851
1852 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1853 {
1854 struct au0828_fh *fh = priv;
1855 struct au0828_dev *dev = fh->dev;
1856 int rc;
1857
1858 rc = check_dev(dev);
1859 if (rc < 0)
1860 return rc;
1861
1862 /* Workaround for a bug in the au0828 hardware design that sometimes
1863 results in the colorspace being inverted */
1864 if (dev->greenscreen_detected == 1) {
1865 dprintk(1, "Detected green frame. Resetting stream...\n");
1866 au0828_analog_stream_reset(dev);
1867 dev->greenscreen_detected = 0;
1868 }
1869
1870 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1871 rc = videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1872 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1873 rc = videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags & O_NONBLOCK);
1874
1875 return rc;
1876 }
1877
1878 static struct v4l2_file_operations au0828_v4l_fops = {
1879 .owner = THIS_MODULE,
1880 .open = au0828_v4l2_open,
1881 .release = au0828_v4l2_close,
1882 .read = au0828_v4l2_read,
1883 .poll = au0828_v4l2_poll,
1884 .mmap = au0828_v4l2_mmap,
1885 .unlocked_ioctl = video_ioctl2,
1886 };
1887
1888 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1889 .vidioc_querycap = vidioc_querycap,
1890 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1891 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1892 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1893 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1894 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1895 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1896 .vidioc_enumaudio = vidioc_enumaudio,
1897 .vidioc_g_audio = vidioc_g_audio,
1898 .vidioc_s_audio = vidioc_s_audio,
1899 .vidioc_cropcap = vidioc_cropcap,
1900 .vidioc_reqbufs = vidioc_reqbufs,
1901 .vidioc_querybuf = vidioc_querybuf,
1902 .vidioc_qbuf = vidioc_qbuf,
1903 .vidioc_dqbuf = vidioc_dqbuf,
1904 .vidioc_s_std = vidioc_s_std,
1905 .vidioc_enum_input = vidioc_enum_input,
1906 .vidioc_g_input = vidioc_g_input,
1907 .vidioc_s_input = vidioc_s_input,
1908 .vidioc_queryctrl = vidioc_queryctrl,
1909 .vidioc_g_ctrl = vidioc_g_ctrl,
1910 .vidioc_s_ctrl = vidioc_s_ctrl,
1911 .vidioc_streamon = vidioc_streamon,
1912 .vidioc_streamoff = vidioc_streamoff,
1913 .vidioc_g_tuner = vidioc_g_tuner,
1914 .vidioc_s_tuner = vidioc_s_tuner,
1915 .vidioc_g_frequency = vidioc_g_frequency,
1916 .vidioc_s_frequency = vidioc_s_frequency,
1917 #ifdef CONFIG_VIDEO_ADV_DEBUG
1918 .vidioc_g_register = vidioc_g_register,
1919 .vidioc_s_register = vidioc_s_register,
1920 #endif
1921 .vidioc_g_chip_ident = vidioc_g_chip_ident,
1922 };
1923
1924 static const struct video_device au0828_video_template = {
1925 .fops = &au0828_v4l_fops,
1926 .release = video_device_release,
1927 .ioctl_ops = &video_ioctl_ops,
1928 .tvnorms = V4L2_STD_NTSC_M,
1929 .current_norm = V4L2_STD_NTSC_M,
1930 };
1931
1932 /**************************************************************************/
1933
1934 int au0828_analog_register(struct au0828_dev *dev,
1935 struct usb_interface *interface)
1936 {
1937 int retval = -ENOMEM;
1938 struct usb_host_interface *iface_desc;
1939 struct usb_endpoint_descriptor *endpoint;
1940 int i, ret;
1941
1942 dprintk(1, "au0828_analog_register called!\n");
1943
1944 /* set au0828 usb interface0 to as5 */
1945 retval = usb_set_interface(dev->usbdev,
1946 interface->cur_altsetting->desc.bInterfaceNumber, 5);
1947 if (retval != 0) {
1948 printk(KERN_INFO "Failure setting usb interface0 to as5\n");
1949 return retval;
1950 }
1951
1952 /* Figure out which endpoint has the isoc interface */
1953 iface_desc = interface->cur_altsetting;
1954 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
1955 endpoint = &iface_desc->endpoint[i].desc;
1956 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1957 == USB_DIR_IN) &&
1958 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1959 == USB_ENDPOINT_XFER_ISOC)) {
1960
1961 /* we find our isoc in endpoint */
1962 u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
1963 dev->max_pkt_size = (tmp & 0x07ff) *
1964 (((tmp & 0x1800) >> 11) + 1);
1965 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1966 }
1967 }
1968 if (!(dev->isoc_in_endpointaddr)) {
1969 printk(KERN_INFO "Could not locate isoc endpoint\n");
1970 kfree(dev);
1971 return -ENODEV;
1972 }
1973
1974 init_waitqueue_head(&dev->open);
1975 spin_lock_init(&dev->slock);
1976
1977 /* init video dma queues */
1978 INIT_LIST_HEAD(&dev->vidq.active);
1979 INIT_LIST_HEAD(&dev->vidq.queued);
1980 INIT_LIST_HEAD(&dev->vbiq.active);
1981 INIT_LIST_HEAD(&dev->vbiq.queued);
1982
1983 dev->vid_timeout.function = au0828_vid_buffer_timeout;
1984 dev->vid_timeout.data = (unsigned long) dev;
1985 init_timer(&dev->vid_timeout);
1986
1987 dev->vbi_timeout.function = au0828_vbi_buffer_timeout;
1988 dev->vbi_timeout.data = (unsigned long) dev;
1989 init_timer(&dev->vbi_timeout);
1990
1991 dev->width = NTSC_STD_W;
1992 dev->height = NTSC_STD_H;
1993 dev->field_size = dev->width * dev->height;
1994 dev->frame_size = dev->field_size << 1;
1995 dev->bytesperline = dev->width << 1;
1996 dev->ctrl_ainput = 0;
1997 dev->ctrl_freq = 960;
1998
1999 /* allocate and fill v4l2 video struct */
2000 dev->vdev = video_device_alloc();
2001 if (NULL == dev->vdev) {
2002 dprintk(1, "Can't allocate video_device.\n");
2003 return -ENOMEM;
2004 }
2005
2006 /* allocate the VBI struct */
2007 dev->vbi_dev = video_device_alloc();
2008 if (NULL == dev->vbi_dev) {
2009 dprintk(1, "Can't allocate vbi_device.\n");
2010 ret = -ENOMEM;
2011 goto err_vdev;
2012 }
2013
2014 /* Fill the video capture device struct */
2015 *dev->vdev = au0828_video_template;
2016 dev->vdev->parent = &dev->usbdev->dev;
2017 dev->vdev->lock = &dev->lock;
2018 strcpy(dev->vdev->name, "au0828a video");
2019
2020 /* Setup the VBI device */
2021 *dev->vbi_dev = au0828_video_template;
2022 dev->vbi_dev->parent = &dev->usbdev->dev;
2023 dev->vbi_dev->lock = &dev->lock;
2024 strcpy(dev->vbi_dev->name, "au0828a vbi");
2025
2026 /* Register the v4l2 device */
2027 video_set_drvdata(dev->vdev, dev);
2028 retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
2029 if (retval != 0) {
2030 dprintk(1, "unable to register video device (error = %d).\n",
2031 retval);
2032 ret = -ENODEV;
2033 goto err_vbi_dev;
2034 }
2035
2036 /* Register the vbi device */
2037 video_set_drvdata(dev->vbi_dev, dev);
2038 retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
2039 if (retval != 0) {
2040 dprintk(1, "unable to register vbi device (error = %d).\n",
2041 retval);
2042 ret = -ENODEV;
2043 goto err_vbi_dev;
2044 }
2045
2046 dprintk(1, "%s completed!\n", __func__);
2047
2048 return 0;
2049
2050 err_vbi_dev:
2051 video_device_release(dev->vbi_dev);
2052 err_vdev:
2053 video_device_release(dev->vdev);
2054 return ret;
2055 }
2056
kernel source for telekom puls (alcatel/mediatek)