projects / deliverable / linux.git / blob
? search:


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