2 * Auvitek AU0828 USB Bridge (Analog video support)
4 * Copyright (C) 2009 Devin Heitmueller <dheitmueller@linuxtv.org>
5 * Copyright (C) 2005-2008 Auvitek International, Ltd.
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.
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.
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
25 * VBI support is not yet working
26 * The hardware scaler supported is unimplemented
27 * AC97 audio support is unimplemented (only i2s audio mode)
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>
42 #include "au0828-reg.h"
44 static DEFINE_MUTEX(au0828_sysfs_lock
);
46 /* ------------------------------------------------------------------
48 ------------------------------------------------------------------*/
50 static unsigned int isoc_debug
;
51 module_param(isoc_debug
, int, 0644);
52 MODULE_PARM_DESC(isoc_debug
, "enable debug messages [isoc transfers]");
54 #define au0828_isocdbg(fmt, arg...) \
57 printk(KERN_INFO "au0828 %s :"fmt, \
62 static inline void i2c_gate_ctrl(struct au0828_dev
*dev
, int val
)
64 if (dev
->dvb
.frontend
&& dev
->dvb
.frontend
->ops
.analog_ops
.i2c_gate_ctrl
)
65 dev
->dvb
.frontend
->ops
.analog_ops
.i2c_gate_ctrl(dev
->dvb
.frontend
, val
);
68 static inline void print_err_status(struct au0828_dev
*dev
,
69 int packet
, int status
)
71 char *errmsg
= "Unknown";
75 errmsg
= "unlinked synchronuously";
78 errmsg
= "unlinked asynchronuously";
81 errmsg
= "Buffer error (overrun)";
84 errmsg
= "Stalled (device not responding)";
87 errmsg
= "Babble (bad cable?)";
90 errmsg
= "Bit-stuff error (bad cable?)";
93 errmsg
= "CRC/Timeout (could be anything)";
96 errmsg
= "Device does not respond";
100 au0828_isocdbg("URB status %d [%s].\n", status
, errmsg
);
102 au0828_isocdbg("URB packet %d, status %d [%s].\n",
103 packet
, status
, errmsg
);
107 static int check_dev(struct au0828_dev
*dev
)
109 if (dev
->dev_state
& DEV_DISCONNECTED
) {
110 printk(KERN_INFO
"v4l2 ioctl: device not present\n");
114 if (dev
->dev_state
& DEV_MISCONFIGURED
) {
115 printk(KERN_INFO
"v4l2 ioctl: device is misconfigured; "
116 "close and open it again\n");
123 * IRQ callback, called by URB callback
125 static void au0828_irq_callback(struct urb
*urb
)
127 struct au0828_dmaqueue
*dma_q
= urb
->context
;
128 struct au0828_dev
*dev
= container_of(dma_q
, struct au0828_dev
, vidq
);
129 unsigned long flags
= 0;
132 switch (urb
->status
) {
133 case 0: /* success */
134 case -ETIMEDOUT
: /* NAK */
136 case -ECONNRESET
: /* kill */
139 au0828_isocdbg("au0828_irq_callback called: status kill\n");
141 default: /* unknown error */
142 au0828_isocdbg("urb completition error %d.\n", urb
->status
);
146 /* Copy data from URB */
147 spin_lock_irqsave(&dev
->slock
, flags
);
148 dev
->isoc_ctl
.isoc_copy(dev
, urb
);
149 spin_unlock_irqrestore(&dev
->slock
, flags
);
151 /* Reset urb buffers */
152 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
153 urb
->iso_frame_desc
[i
].status
= 0;
154 urb
->iso_frame_desc
[i
].actual_length
= 0;
158 urb
->status
= usb_submit_urb(urb
, GFP_ATOMIC
);
160 au0828_isocdbg("urb resubmit failed (error=%i)\n",
166 * Stop and Deallocate URBs
168 static void au0828_uninit_isoc(struct au0828_dev
*dev
)
173 au0828_isocdbg("au0828: called au0828_uninit_isoc\n");
175 dev
->isoc_ctl
.nfields
= -1;
176 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
177 urb
= dev
->isoc_ctl
.urb
[i
];
179 if (!irqs_disabled())
184 if (dev
->isoc_ctl
.transfer_buffer
[i
]) {
185 usb_free_coherent(dev
->usbdev
,
186 urb
->transfer_buffer_length
,
187 dev
->isoc_ctl
.transfer_buffer
[i
],
191 dev
->isoc_ctl
.urb
[i
] = NULL
;
193 dev
->isoc_ctl
.transfer_buffer
[i
] = NULL
;
196 kfree(dev
->isoc_ctl
.urb
);
197 kfree(dev
->isoc_ctl
.transfer_buffer
);
199 dev
->isoc_ctl
.urb
= NULL
;
200 dev
->isoc_ctl
.transfer_buffer
= NULL
;
201 dev
->isoc_ctl
.num_bufs
= 0;
205 * Allocate URBs and start IRQ
207 static int au0828_init_isoc(struct au0828_dev
*dev
, int max_packets
,
208 int num_bufs
, int max_pkt_size
,
209 int (*isoc_copy
) (struct au0828_dev
*dev
, struct urb
*urb
))
211 struct au0828_dmaqueue
*dma_q
= &dev
->vidq
;
218 au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
220 /* De-allocates all pending stuff */
221 au0828_uninit_isoc(dev
);
223 dev
->isoc_ctl
.isoc_copy
= isoc_copy
;
224 dev
->isoc_ctl
.num_bufs
= num_bufs
;
226 dev
->isoc_ctl
.urb
= kzalloc(sizeof(void *)*num_bufs
, GFP_KERNEL
);
227 if (!dev
->isoc_ctl
.urb
) {
228 au0828_isocdbg("cannot alloc memory for usb buffers\n");
232 dev
->isoc_ctl
.transfer_buffer
= kzalloc(sizeof(void *)*num_bufs
,
234 if (!dev
->isoc_ctl
.transfer_buffer
) {
235 au0828_isocdbg("cannot allocate memory for usb transfer\n");
236 kfree(dev
->isoc_ctl
.urb
);
240 dev
->isoc_ctl
.max_pkt_size
= max_pkt_size
;
241 dev
->isoc_ctl
.buf
= NULL
;
243 sb_size
= max_packets
* dev
->isoc_ctl
.max_pkt_size
;
245 /* allocate urbs and transfer buffers */
246 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
247 urb
= usb_alloc_urb(max_packets
, GFP_KERNEL
);
249 au0828_isocdbg("cannot alloc isoc_ctl.urb %i\n", i
);
250 au0828_uninit_isoc(dev
);
253 dev
->isoc_ctl
.urb
[i
] = urb
;
255 dev
->isoc_ctl
.transfer_buffer
[i
] = usb_alloc_coherent(dev
->usbdev
,
256 sb_size
, GFP_KERNEL
, &urb
->transfer_dma
);
257 if (!dev
->isoc_ctl
.transfer_buffer
[i
]) {
258 printk("unable to allocate %i bytes for transfer"
261 in_interrupt() ? " while in int" : "");
262 au0828_uninit_isoc(dev
);
265 memset(dev
->isoc_ctl
.transfer_buffer
[i
], 0, sb_size
);
267 pipe
= usb_rcvisocpipe(dev
->usbdev
,
268 dev
->isoc_in_endpointaddr
),
270 usb_fill_int_urb(urb
, dev
->usbdev
, pipe
,
271 dev
->isoc_ctl
.transfer_buffer
[i
], sb_size
,
272 au0828_irq_callback
, dma_q
, 1);
274 urb
->number_of_packets
= max_packets
;
275 urb
->transfer_flags
= URB_ISO_ASAP
| URB_NO_TRANSFER_DMA_MAP
;
278 for (j
= 0; j
< max_packets
; j
++) {
279 urb
->iso_frame_desc
[j
].offset
= k
;
280 urb
->iso_frame_desc
[j
].length
=
281 dev
->isoc_ctl
.max_pkt_size
;
282 k
+= dev
->isoc_ctl
.max_pkt_size
;
286 init_waitqueue_head(&dma_q
->wq
);
288 /* submit urbs and enables IRQ */
289 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
290 rc
= usb_submit_urb(dev
->isoc_ctl
.urb
[i
], GFP_ATOMIC
);
292 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
294 au0828_uninit_isoc(dev
);
303 * Announces that a buffer were filled and request the next
305 static inline void buffer_filled(struct au0828_dev
*dev
,
306 struct au0828_dmaqueue
*dma_q
,
307 struct au0828_buffer
*buf
)
309 /* Advice that buffer was filled */
310 au0828_isocdbg("[%p/%d] wakeup\n", buf
, buf
->vb
.i
);
312 buf
->vb
.state
= VIDEOBUF_DONE
;
313 buf
->vb
.field_count
++;
314 v4l2_get_timestamp(&buf
->vb
.ts
);
316 dev
->isoc_ctl
.buf
= NULL
;
318 list_del(&buf
->vb
.queue
);
319 wake_up(&buf
->vb
.done
);
322 static inline void vbi_buffer_filled(struct au0828_dev
*dev
,
323 struct au0828_dmaqueue
*dma_q
,
324 struct au0828_buffer
*buf
)
326 /* Advice that buffer was filled */
327 au0828_isocdbg("[%p/%d] wakeup\n", buf
, buf
->vb
.i
);
329 buf
->vb
.state
= VIDEOBUF_DONE
;
330 buf
->vb
.field_count
++;
331 v4l2_get_timestamp(&buf
->vb
.ts
);
333 dev
->isoc_ctl
.vbi_buf
= NULL
;
335 list_del(&buf
->vb
.queue
);
336 wake_up(&buf
->vb
.done
);
340 * Identify the buffer header type and properly handles
342 static void au0828_copy_video(struct au0828_dev
*dev
,
343 struct au0828_dmaqueue
*dma_q
,
344 struct au0828_buffer
*buf
,
346 unsigned char *outp
, unsigned long len
)
348 void *fieldstart
, *startwrite
, *startread
;
349 int linesdone
, currlinedone
, offset
, lencopy
, remain
;
350 int bytesperline
= dev
->width
<< 1; /* Assumes 16-bit depth @@@@ */
355 if (dma_q
->pos
+ len
> buf
->vb
.size
)
356 len
= buf
->vb
.size
- dma_q
->pos
;
361 /* Interlaces frame */
365 fieldstart
= outp
+ bytesperline
;
367 linesdone
= dma_q
->pos
/ bytesperline
;
368 currlinedone
= dma_q
->pos
% bytesperline
;
369 offset
= linesdone
* bytesperline
* 2 + currlinedone
;
370 startwrite
= fieldstart
+ offset
;
371 lencopy
= bytesperline
- currlinedone
;
372 lencopy
= lencopy
> remain
? remain
: lencopy
;
374 if ((char *)startwrite
+ lencopy
> (char *)outp
+ buf
->vb
.size
) {
375 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
376 ((char *)startwrite
+ lencopy
) -
377 ((char *)outp
+ buf
->vb
.size
));
378 remain
= (char *)outp
+ buf
->vb
.size
- (char *)startwrite
;
383 memcpy(startwrite
, startread
, lencopy
);
388 startwrite
+= lencopy
+ bytesperline
;
389 startread
+= lencopy
;
390 if (bytesperline
> remain
)
393 lencopy
= bytesperline
;
395 if ((char *)startwrite
+ lencopy
> (char *)outp
+
397 au0828_isocdbg("Overflow %zi bytes past buf end (2)\n",
398 ((char *)startwrite
+ lencopy
) -
399 ((char *)outp
+ buf
->vb
.size
));
400 lencopy
= remain
= (char *)outp
+ buf
->vb
.size
-
406 memcpy(startwrite
, startread
, lencopy
);
412 /* We have enough data to check for greenscreen */
413 if (outp
[0] < 0x60 && outp
[1440] < 0x60)
414 dev
->greenscreen_detected
= 1;
421 * video-buf generic routine to get the next available buffer
423 static inline void get_next_buf(struct au0828_dmaqueue
*dma_q
,
424 struct au0828_buffer
**buf
)
426 struct au0828_dev
*dev
= container_of(dma_q
, struct au0828_dev
, vidq
);
428 if (list_empty(&dma_q
->active
)) {
429 au0828_isocdbg("No active queue to serve\n");
430 dev
->isoc_ctl
.buf
= NULL
;
435 /* Get the next buffer */
436 *buf
= list_entry(dma_q
->active
.next
, struct au0828_buffer
, vb
.queue
);
437 dev
->isoc_ctl
.buf
= *buf
;
442 static void au0828_copy_vbi(struct au0828_dev
*dev
,
443 struct au0828_dmaqueue
*dma_q
,
444 struct au0828_buffer
*buf
,
446 unsigned char *outp
, unsigned long len
)
448 unsigned char *startwrite
, *startread
;
453 au0828_isocdbg("dev is null\n");
458 au0828_isocdbg("dma_q is null\n");
464 au0828_isocdbg("p is null\n");
468 au0828_isocdbg("outp is null\n");
472 bytesperline
= dev
->vbi_width
;
474 if (dma_q
->pos
+ len
> buf
->vb
.size
)
475 len
= buf
->vb
.size
- dma_q
->pos
;
478 startwrite
= outp
+ (dma_q
->pos
/ 2);
480 /* Make sure the bottom field populates the second half of the frame */
481 if (buf
->top_field
== 0)
482 startwrite
+= bytesperline
* dev
->vbi_height
;
484 for (i
= 0; i
< len
; i
+= 2)
485 startwrite
[j
++] = startread
[i
+1];
492 * video-buf generic routine to get the next available VBI buffer
494 static inline void vbi_get_next_buf(struct au0828_dmaqueue
*dma_q
,
495 struct au0828_buffer
**buf
)
497 struct au0828_dev
*dev
= container_of(dma_q
, struct au0828_dev
, vbiq
);
500 if (list_empty(&dma_q
->active
)) {
501 au0828_isocdbg("No active queue to serve\n");
502 dev
->isoc_ctl
.vbi_buf
= NULL
;
507 /* Get the next buffer */
508 *buf
= list_entry(dma_q
->active
.next
, struct au0828_buffer
, vb
.queue
);
509 /* Cleans up buffer - Useful for testing for frame/URB loss */
510 outp
= videobuf_to_vmalloc(&(*buf
)->vb
);
511 memset(outp
, 0x00, (*buf
)->vb
.size
);
513 dev
->isoc_ctl
.vbi_buf
= *buf
;
519 * Controls the isoc copy of each urb packet
521 static inline int au0828_isoc_copy(struct au0828_dev
*dev
, struct urb
*urb
)
523 struct au0828_buffer
*buf
;
524 struct au0828_buffer
*vbi_buf
;
525 struct au0828_dmaqueue
*dma_q
= urb
->context
;
526 struct au0828_dmaqueue
*vbi_dma_q
= &dev
->vbiq
;
527 unsigned char *outp
= NULL
;
528 unsigned char *vbioutp
= NULL
;
529 int i
, len
= 0, rc
= 1;
532 unsigned int vbi_field_size
;
533 unsigned int remain
, lencopy
;
538 if ((dev
->dev_state
& DEV_DISCONNECTED
) ||
539 (dev
->dev_state
& DEV_MISCONFIGURED
))
542 if (urb
->status
< 0) {
543 print_err_status(dev
, -1, urb
->status
);
544 if (urb
->status
== -ENOENT
)
548 buf
= dev
->isoc_ctl
.buf
;
550 outp
= videobuf_to_vmalloc(&buf
->vb
);
552 vbi_buf
= dev
->isoc_ctl
.vbi_buf
;
554 vbioutp
= videobuf_to_vmalloc(&vbi_buf
->vb
);
556 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
557 int status
= urb
->iso_frame_desc
[i
].status
;
560 print_err_status(dev
, i
, status
);
561 if (urb
->iso_frame_desc
[i
].status
!= -EPROTO
)
565 if (urb
->iso_frame_desc
[i
].actual_length
<= 0)
568 if (urb
->iso_frame_desc
[i
].actual_length
>
570 au0828_isocdbg("packet bigger than packet size");
574 p
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
576 len
= urb
->iso_frame_desc
[i
].actual_length
- 4;
582 au0828_isocdbg("Video frame %s\n",
583 (fbyte
& 0x40) ? "odd" : "even");
587 vbi_buffer_filled(dev
,
590 vbi_get_next_buf(vbi_dma_q
, &vbi_buf
);
594 vbioutp
= videobuf_to_vmalloc(
599 buffer_filled(dev
, dma_q
, buf
);
600 get_next_buf(dma_q
, &buf
);
604 outp
= videobuf_to_vmalloc(&buf
->vb
);
606 /* As long as isoc traffic is arriving, keep
607 resetting the timer */
608 if (dev
->vid_timeout_running
)
609 mod_timer(&dev
->vid_timeout
,
610 jiffies
+ (HZ
/ 10));
611 if (dev
->vbi_timeout_running
)
612 mod_timer(&dev
->vbi_timeout
,
613 jiffies
+ (HZ
/ 10));
623 if (vbi_buf
!= NULL
) {
625 vbi_buf
->top_field
= 1;
627 vbi_buf
->top_field
= 0;
635 vbi_field_size
= dev
->vbi_width
* dev
->vbi_height
* 2;
636 if (dev
->vbi_read
< vbi_field_size
) {
637 remain
= vbi_field_size
- dev
->vbi_read
;
644 au0828_copy_vbi(dev
, vbi_dma_q
, vbi_buf
, p
,
649 dev
->vbi_read
+= lencopy
;
652 if (dev
->vbi_read
>= vbi_field_size
&& buf
!= NULL
)
653 au0828_copy_video(dev
, dma_q
, buf
, p
, outp
, len
);
659 buffer_setup(struct videobuf_queue
*vq
, unsigned int *count
,
662 struct au0828_fh
*fh
= vq
->priv_data
;
663 *size
= (fh
->dev
->width
* fh
->dev
->height
* 16 + 7) >> 3;
666 *count
= AU0828_DEF_BUF
;
668 if (*count
< AU0828_MIN_BUF
)
669 *count
= AU0828_MIN_BUF
;
673 /* This is called *without* dev->slock held; please keep it that way */
674 static void free_buffer(struct videobuf_queue
*vq
, struct au0828_buffer
*buf
)
676 struct au0828_fh
*fh
= vq
->priv_data
;
677 struct au0828_dev
*dev
= fh
->dev
;
678 unsigned long flags
= 0;
682 /* We used to wait for the buffer to finish here, but this didn't work
683 because, as we were keeping the state as VIDEOBUF_QUEUED,
684 videobuf_queue_cancel marked it as finished for us.
685 (Also, it could wedge forever if the hardware was misconfigured.)
687 This should be safe; by the time we get here, the buffer isn't
688 queued anymore. If we ever start marking the buffers as
689 VIDEOBUF_ACTIVE, it won't be, though.
691 spin_lock_irqsave(&dev
->slock
, flags
);
692 if (dev
->isoc_ctl
.buf
== buf
)
693 dev
->isoc_ctl
.buf
= NULL
;
694 spin_unlock_irqrestore(&dev
->slock
, flags
);
696 videobuf_vmalloc_free(&buf
->vb
);
697 buf
->vb
.state
= VIDEOBUF_NEEDS_INIT
;
701 buffer_prepare(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
,
702 enum v4l2_field field
)
704 struct au0828_fh
*fh
= vq
->priv_data
;
705 struct au0828_buffer
*buf
= container_of(vb
, struct au0828_buffer
, vb
);
706 struct au0828_dev
*dev
= fh
->dev
;
707 int rc
= 0, urb_init
= 0;
709 buf
->vb
.size
= (fh
->dev
->width
* fh
->dev
->height
* 16 + 7) >> 3;
711 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
714 buf
->vb
.width
= dev
->width
;
715 buf
->vb
.height
= dev
->height
;
716 buf
->vb
.field
= field
;
718 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
719 rc
= videobuf_iolock(vq
, &buf
->vb
, NULL
);
721 printk(KERN_INFO
"videobuf_iolock failed\n");
726 if (!dev
->isoc_ctl
.num_bufs
)
730 rc
= au0828_init_isoc(dev
, AU0828_ISO_PACKETS_PER_URB
,
731 AU0828_MAX_ISO_BUFS
, dev
->max_pkt_size
,
734 printk(KERN_INFO
"au0828_init_isoc failed\n");
739 buf
->vb
.state
= VIDEOBUF_PREPARED
;
743 free_buffer(vq
, buf
);
748 buffer_queue(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
)
750 struct au0828_buffer
*buf
= container_of(vb
,
751 struct au0828_buffer
,
753 struct au0828_fh
*fh
= vq
->priv_data
;
754 struct au0828_dev
*dev
= fh
->dev
;
755 struct au0828_dmaqueue
*vidq
= &dev
->vidq
;
757 buf
->vb
.state
= VIDEOBUF_QUEUED
;
758 list_add_tail(&buf
->vb
.queue
, &vidq
->active
);
761 static void buffer_release(struct videobuf_queue
*vq
,
762 struct videobuf_buffer
*vb
)
764 struct au0828_buffer
*buf
= container_of(vb
,
765 struct au0828_buffer
,
768 free_buffer(vq
, buf
);
771 static struct videobuf_queue_ops au0828_video_qops
= {
772 .buf_setup
= buffer_setup
,
773 .buf_prepare
= buffer_prepare
,
774 .buf_queue
= buffer_queue
,
775 .buf_release
= buffer_release
,
778 /* ------------------------------------------------------------------
780 ------------------------------------------------------------------*/
782 static int au0828_i2s_init(struct au0828_dev
*dev
)
784 /* Enable i2s mode */
785 au0828_writereg(dev
, AU0828_AUDIOCTRL_50C
, 0x01);
790 * Auvitek au0828 analog stream enable
791 * Please set interface0 to AS5 before enable the stream
793 static int au0828_analog_stream_enable(struct au0828_dev
*d
)
795 dprintk(1, "au0828_analog_stream_enable called\n");
796 au0828_writereg(d
, AU0828_SENSORCTRL_VBI_103
, 0x00);
797 au0828_writereg(d
, 0x106, 0x00);
799 au0828_writereg(d
, 0x110, 0x00);
800 au0828_writereg(d
, 0x111, 0x00);
801 au0828_writereg(d
, 0x114, 0xa0);
802 au0828_writereg(d
, 0x115, 0x05);
804 au0828_writereg(d
, 0x112, 0x00);
805 au0828_writereg(d
, 0x113, 0x00);
806 au0828_writereg(d
, 0x116, 0xf2);
807 au0828_writereg(d
, 0x117, 0x00);
808 au0828_writereg(d
, AU0828_SENSORCTRL_100
, 0xb3);
813 int au0828_analog_stream_disable(struct au0828_dev
*d
)
815 dprintk(1, "au0828_analog_stream_disable called\n");
816 au0828_writereg(d
, AU0828_SENSORCTRL_100
, 0x0);
820 static void au0828_analog_stream_reset(struct au0828_dev
*dev
)
822 dprintk(1, "au0828_analog_stream_reset called\n");
823 au0828_writereg(dev
, AU0828_SENSORCTRL_100
, 0x0);
825 au0828_writereg(dev
, AU0828_SENSORCTRL_100
, 0xb3);
829 * Some operations needs to stop current streaming
831 static int au0828_stream_interrupt(struct au0828_dev
*dev
)
835 dev
->stream_state
= STREAM_INTERRUPT
;
836 if (dev
->dev_state
== DEV_DISCONNECTED
)
839 dev
->dev_state
= DEV_MISCONFIGURED
;
840 dprintk(1, "%s device is misconfigured!\n", __func__
);
847 * au0828_release_resources
848 * unregister v4l2 devices
850 void au0828_analog_unregister(struct au0828_dev
*dev
)
852 dprintk(1, "au0828_release_resources called\n");
853 mutex_lock(&au0828_sysfs_lock
);
856 video_unregister_device(dev
->vdev
);
858 video_unregister_device(dev
->vbi_dev
);
860 mutex_unlock(&au0828_sysfs_lock
);
864 /* Usage lock check functions */
865 static int res_get(struct au0828_fh
*fh
, unsigned int bit
)
867 struct au0828_dev
*dev
= fh
->dev
;
869 if (fh
->resources
& bit
)
870 /* have it already allocated */
874 if (dev
->resources
& bit
) {
875 /* no, someone else uses it */
878 /* it's free, grab it */
879 fh
->resources
|= bit
;
880 dev
->resources
|= bit
;
881 dprintk(1, "res: get %d\n", bit
);
886 static int res_check(struct au0828_fh
*fh
, unsigned int bit
)
888 return fh
->resources
& bit
;
891 static int res_locked(struct au0828_dev
*dev
, unsigned int bit
)
893 return dev
->resources
& bit
;
896 static void res_free(struct au0828_fh
*fh
, unsigned int bits
)
898 struct au0828_dev
*dev
= fh
->dev
;
900 BUG_ON((fh
->resources
& bits
) != bits
);
902 fh
->resources
&= ~bits
;
903 dev
->resources
&= ~bits
;
904 dprintk(1, "res: put %d\n", bits
);
907 static int get_ressource(struct au0828_fh
*fh
)
910 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
911 return AU0828_RESOURCE_VIDEO
;
912 case V4L2_BUF_TYPE_VBI_CAPTURE
:
913 return AU0828_RESOURCE_VBI
;
920 /* This function ensures that video frames continue to be delivered even if
921 the ITU-656 input isn't receiving any data (thereby preventing applications
922 such as tvtime from hanging) */
923 static void au0828_vid_buffer_timeout(unsigned long data
)
925 struct au0828_dev
*dev
= (struct au0828_dev
*) data
;
926 struct au0828_dmaqueue
*dma_q
= &dev
->vidq
;
927 struct au0828_buffer
*buf
;
928 unsigned char *vid_data
;
929 unsigned long flags
= 0;
931 spin_lock_irqsave(&dev
->slock
, flags
);
933 buf
= dev
->isoc_ctl
.buf
;
935 vid_data
= videobuf_to_vmalloc(&buf
->vb
);
936 memset(vid_data
, 0x00, buf
->vb
.size
); /* Blank green frame */
937 buffer_filled(dev
, dma_q
, buf
);
939 get_next_buf(dma_q
, &buf
);
941 if (dev
->vid_timeout_running
== 1)
942 mod_timer(&dev
->vid_timeout
, jiffies
+ (HZ
/ 10));
944 spin_unlock_irqrestore(&dev
->slock
, flags
);
947 static void au0828_vbi_buffer_timeout(unsigned long data
)
949 struct au0828_dev
*dev
= (struct au0828_dev
*) data
;
950 struct au0828_dmaqueue
*dma_q
= &dev
->vbiq
;
951 struct au0828_buffer
*buf
;
952 unsigned char *vbi_data
;
953 unsigned long flags
= 0;
955 spin_lock_irqsave(&dev
->slock
, flags
);
957 buf
= dev
->isoc_ctl
.vbi_buf
;
959 vbi_data
= videobuf_to_vmalloc(&buf
->vb
);
960 memset(vbi_data
, 0x00, buf
->vb
.size
);
961 vbi_buffer_filled(dev
, dma_q
, buf
);
963 vbi_get_next_buf(dma_q
, &buf
);
965 if (dev
->vbi_timeout_running
== 1)
966 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
967 spin_unlock_irqrestore(&dev
->slock
, flags
);
971 static int au0828_v4l2_open(struct file
*filp
)
974 struct video_device
*vdev
= video_devdata(filp
);
975 struct au0828_dev
*dev
= video_drvdata(filp
);
976 struct au0828_fh
*fh
;
979 switch (vdev
->vfl_type
) {
980 case VFL_TYPE_GRABBER
:
981 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
984 type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
990 fh
= kzalloc(sizeof(struct au0828_fh
), GFP_KERNEL
);
992 dprintk(1, "Failed allocate au0828_fh struct!\n");
998 v4l2_fh_init(&fh
->fh
, vdev
);
999 filp
->private_data
= fh
;
1001 if (mutex_lock_interruptible(&dev
->lock
)) {
1003 return -ERESTARTSYS
;
1005 if (dev
->users
== 0) {
1006 /* set au0828 interface0 to AS5 here again */
1007 ret
= usb_set_interface(dev
->usbdev
, 0, 5);
1009 mutex_unlock(&dev
->lock
);
1010 printk(KERN_INFO
"Au0828 can't set alternate to 5!\n");
1015 au0828_analog_stream_enable(dev
);
1016 au0828_analog_stream_reset(dev
);
1018 /* If we were doing ac97 instead of i2s, it would go here...*/
1019 au0828_i2s_init(dev
);
1021 dev
->stream_state
= STREAM_OFF
;
1022 dev
->dev_state
|= DEV_INITIALIZED
;
1026 mutex_unlock(&dev
->lock
);
1028 videobuf_queue_vmalloc_init(&fh
->vb_vidq
, &au0828_video_qops
,
1030 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1031 V4L2_FIELD_INTERLACED
,
1032 sizeof(struct au0828_buffer
), fh
,
1036 videobuf_queue_vmalloc_init(&fh
->vb_vbiq
, &au0828_vbi_qops
,
1038 V4L2_BUF_TYPE_VBI_CAPTURE
,
1040 sizeof(struct au0828_buffer
), fh
,
1042 v4l2_fh_add(&fh
->fh
);
1046 static int au0828_v4l2_close(struct file
*filp
)
1049 struct au0828_fh
*fh
= filp
->private_data
;
1050 struct au0828_dev
*dev
= fh
->dev
;
1052 v4l2_fh_del(&fh
->fh
);
1053 v4l2_fh_exit(&fh
->fh
);
1054 mutex_lock(&dev
->lock
);
1055 if (res_check(fh
, AU0828_RESOURCE_VIDEO
)) {
1056 /* Cancel timeout thread in case they didn't call streamoff */
1057 dev
->vid_timeout_running
= 0;
1058 del_timer_sync(&dev
->vid_timeout
);
1060 videobuf_stop(&fh
->vb_vidq
);
1061 res_free(fh
, AU0828_RESOURCE_VIDEO
);
1064 if (res_check(fh
, AU0828_RESOURCE_VBI
)) {
1065 /* Cancel timeout thread in case they didn't call streamoff */
1066 dev
->vbi_timeout_running
= 0;
1067 del_timer_sync(&dev
->vbi_timeout
);
1069 videobuf_stop(&fh
->vb_vbiq
);
1070 res_free(fh
, AU0828_RESOURCE_VBI
);
1073 if (dev
->users
== 1 && video_is_registered(video_devdata(filp
))) {
1074 au0828_analog_stream_disable(dev
);
1076 au0828_uninit_isoc(dev
);
1078 /* Save some power by putting tuner to sleep */
1079 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_power
, 0);
1080 dev
->std_set_in_tuner_core
= 0;
1082 /* When close the device, set the usb intf0 into alt0 to free
1084 ret
= usb_set_interface(dev
->usbdev
, 0, 0);
1086 printk(KERN_INFO
"Au0828 can't set alternate to 0!\n");
1088 mutex_unlock(&dev
->lock
);
1090 videobuf_mmap_free(&fh
->vb_vidq
);
1091 videobuf_mmap_free(&fh
->vb_vbiq
);
1094 wake_up_interruptible_nr(&dev
->open
, 1);
1098 /* Must be called with dev->lock held */
1099 static void au0828_init_tuner(struct au0828_dev
*dev
)
1101 struct v4l2_frequency f
= {
1102 .frequency
= dev
->ctrl_freq
,
1103 .type
= V4L2_TUNER_ANALOG_TV
,
1106 if (dev
->std_set_in_tuner_core
)
1108 dev
->std_set_in_tuner_core
= 1;
1109 i2c_gate_ctrl(dev
, 1);
1110 /* If we've never sent the standard in tuner core, do so now.
1111 We don't do this at device probe because we don't want to
1112 incur the cost of a firmware load */
1113 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_std
, dev
->std
);
1114 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, &f
);
1115 i2c_gate_ctrl(dev
, 0);
1118 static ssize_t
au0828_v4l2_read(struct file
*filp
, char __user
*buf
,
1119 size_t count
, loff_t
*pos
)
1121 struct au0828_fh
*fh
= filp
->private_data
;
1122 struct au0828_dev
*dev
= fh
->dev
;
1125 rc
= check_dev(dev
);
1129 if (mutex_lock_interruptible(&dev
->lock
))
1130 return -ERESTARTSYS
;
1131 au0828_init_tuner(dev
);
1132 mutex_unlock(&dev
->lock
);
1134 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1135 if (res_locked(dev
, AU0828_RESOURCE_VIDEO
))
1138 return videobuf_read_stream(&fh
->vb_vidq
, buf
, count
, pos
, 0,
1139 filp
->f_flags
& O_NONBLOCK
);
1142 if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
1143 if (!res_get(fh
, AU0828_RESOURCE_VBI
))
1146 if (dev
->vbi_timeout_running
== 0) {
1147 /* Handle case where caller tries to read without
1148 calling streamon first */
1149 dev
->vbi_timeout_running
= 1;
1150 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
1153 return videobuf_read_stream(&fh
->vb_vbiq
, buf
, count
, pos
, 0,
1154 filp
->f_flags
& O_NONBLOCK
);
1160 static unsigned int au0828_v4l2_poll(struct file
*filp
, poll_table
*wait
)
1162 struct au0828_fh
*fh
= filp
->private_data
;
1163 struct au0828_dev
*dev
= fh
->dev
;
1164 unsigned long req_events
= poll_requested_events(wait
);
1167 if (check_dev(dev
) < 0)
1170 res
= v4l2_ctrl_poll(filp
, wait
);
1171 if (!(req_events
& (POLLIN
| POLLRDNORM
)))
1174 if (mutex_lock_interruptible(&dev
->lock
))
1175 return -ERESTARTSYS
;
1176 au0828_init_tuner(dev
);
1177 mutex_unlock(&dev
->lock
);
1179 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1180 if (!res_get(fh
, AU0828_RESOURCE_VIDEO
))
1182 return res
| videobuf_poll_stream(filp
, &fh
->vb_vidq
, wait
);
1184 if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
1185 if (!res_get(fh
, AU0828_RESOURCE_VBI
))
1187 return res
| videobuf_poll_stream(filp
, &fh
->vb_vbiq
, wait
);
1192 static int au0828_v4l2_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
1194 struct au0828_fh
*fh
= filp
->private_data
;
1195 struct au0828_dev
*dev
= fh
->dev
;
1198 rc
= check_dev(dev
);
1202 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1203 rc
= videobuf_mmap_mapper(&fh
->vb_vidq
, vma
);
1204 else if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1205 rc
= videobuf_mmap_mapper(&fh
->vb_vbiq
, vma
);
1210 static int au0828_set_format(struct au0828_dev
*dev
, unsigned int cmd
,
1211 struct v4l2_format
*format
)
1214 int width
= format
->fmt
.pix
.width
;
1215 int height
= format
->fmt
.pix
.height
;
1217 /* If they are demanding a format other than the one we support,
1218 bail out (tvtime asks for UYVY and then retries with YUYV) */
1219 if (format
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_UYVY
)
1222 /* format->fmt.pix.width only support 720 and height 480 */
1228 format
->fmt
.pix
.width
= width
;
1229 format
->fmt
.pix
.height
= height
;
1230 format
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_UYVY
;
1231 format
->fmt
.pix
.bytesperline
= width
* 2;
1232 format
->fmt
.pix
.sizeimage
= width
* height
* 2;
1233 format
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1234 format
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1235 format
->fmt
.pix
.priv
= 0;
1237 if (cmd
== VIDIOC_TRY_FMT
)
1240 /* maybe set new image format, driver current only support 720*480 */
1242 dev
->height
= height
;
1243 dev
->frame_size
= width
* height
* 2;
1244 dev
->field_size
= width
* height
;
1245 dev
->bytesperline
= width
* 2;
1247 if (dev
->stream_state
== STREAM_ON
) {
1248 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
1249 ret
= au0828_stream_interrupt(dev
);
1251 dprintk(1, "error interrupting video stream!\n");
1256 /* set au0828 interface0 to AS5 here again */
1257 ret
= usb_set_interface(dev
->usbdev
, 0, 5);
1259 printk(KERN_INFO
"Au0828 can't set alt setting to 5!\n");
1263 au0828_analog_stream_enable(dev
);
1269 static int vidioc_querycap(struct file
*file
, void *priv
,
1270 struct v4l2_capability
*cap
)
1272 struct video_device
*vdev
= video_devdata(file
);
1273 struct au0828_fh
*fh
= priv
;
1274 struct au0828_dev
*dev
= fh
->dev
;
1276 strlcpy(cap
->driver
, "au0828", sizeof(cap
->driver
));
1277 strlcpy(cap
->card
, dev
->board
.name
, sizeof(cap
->card
));
1278 usb_make_path(dev
->usbdev
, cap
->bus_info
, sizeof(cap
->bus_info
));
1280 /* set the device capabilities */
1281 cap
->device_caps
= V4L2_CAP_AUDIO
|
1282 V4L2_CAP_READWRITE
|
1283 V4L2_CAP_STREAMING
|
1285 if (vdev
->vfl_type
== VFL_TYPE_GRABBER
)
1286 cap
->device_caps
|= V4L2_CAP_VIDEO_CAPTURE
;
1288 cap
->device_caps
|= V4L2_CAP_VBI_CAPTURE
;
1289 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
|
1290 V4L2_CAP_VBI_CAPTURE
| V4L2_CAP_VIDEO_CAPTURE
;
1294 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1295 struct v4l2_fmtdesc
*f
)
1300 f
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1301 strcpy(f
->description
, "Packed YUV2");
1304 f
->pixelformat
= V4L2_PIX_FMT_UYVY
;
1309 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
1310 struct v4l2_format
*f
)
1312 struct au0828_fh
*fh
= priv
;
1313 struct au0828_dev
*dev
= fh
->dev
;
1315 f
->fmt
.pix
.width
= dev
->width
;
1316 f
->fmt
.pix
.height
= dev
->height
;
1317 f
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_UYVY
;
1318 f
->fmt
.pix
.bytesperline
= dev
->bytesperline
;
1319 f
->fmt
.pix
.sizeimage
= dev
->frame_size
;
1320 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
; /* NTSC/PAL */
1321 f
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1322 f
->fmt
.pix
.priv
= 0;
1326 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
1327 struct v4l2_format
*f
)
1329 struct au0828_fh
*fh
= priv
;
1330 struct au0828_dev
*dev
= fh
->dev
;
1332 return au0828_set_format(dev
, VIDIOC_TRY_FMT
, f
);
1335 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
1336 struct v4l2_format
*f
)
1338 struct au0828_fh
*fh
= priv
;
1339 struct au0828_dev
*dev
= fh
->dev
;
1342 rc
= check_dev(dev
);
1346 if (videobuf_queue_is_busy(&fh
->vb_vidq
)) {
1347 printk(KERN_INFO
"%s queue busy\n", __func__
);
1352 rc
= au0828_set_format(dev
, VIDIOC_S_FMT
, f
);
1357 static int vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id norm
)
1359 struct au0828_fh
*fh
= priv
;
1360 struct au0828_dev
*dev
= fh
->dev
;
1364 au0828_init_tuner(dev
);
1366 i2c_gate_ctrl(dev
, 1);
1368 /* FIXME: when we support something other than NTSC, we are going to
1369 have to make the au0828 bridge adjust the size of its capture
1370 buffer, which is currently hardcoded at 720x480 */
1372 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_std
, norm
);
1374 i2c_gate_ctrl(dev
, 0);
1379 static int vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*norm
)
1381 struct au0828_fh
*fh
= priv
;
1382 struct au0828_dev
*dev
= fh
->dev
;
1388 static int vidioc_enum_input(struct file
*file
, void *priv
,
1389 struct v4l2_input
*input
)
1391 struct au0828_fh
*fh
= priv
;
1392 struct au0828_dev
*dev
= fh
->dev
;
1395 static const char *inames
[] = {
1396 [AU0828_VMUX_UNDEFINED
] = "Undefined",
1397 [AU0828_VMUX_COMPOSITE
] = "Composite",
1398 [AU0828_VMUX_SVIDEO
] = "S-Video",
1399 [AU0828_VMUX_CABLE
] = "Cable TV",
1400 [AU0828_VMUX_TELEVISION
] = "Television",
1401 [AU0828_VMUX_DVB
] = "DVB",
1402 [AU0828_VMUX_DEBUG
] = "tv debug"
1407 if (tmp
>= AU0828_MAX_INPUT
)
1409 if (AUVI_INPUT(tmp
).type
== 0)
1413 strcpy(input
->name
, inames
[AUVI_INPUT(tmp
).type
]);
1414 if ((AUVI_INPUT(tmp
).type
== AU0828_VMUX_TELEVISION
) ||
1415 (AUVI_INPUT(tmp
).type
== AU0828_VMUX_CABLE
)) {
1416 input
->type
|= V4L2_INPUT_TYPE_TUNER
;
1417 input
->audioset
= 1;
1419 input
->type
|= V4L2_INPUT_TYPE_CAMERA
;
1420 input
->audioset
= 2;
1423 input
->std
= dev
->vdev
->tvnorms
;
1428 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1430 struct au0828_fh
*fh
= priv
;
1431 struct au0828_dev
*dev
= fh
->dev
;
1432 *i
= dev
->ctrl_input
;
1436 static void au0828_s_input(struct au0828_dev
*dev
, int index
)
1440 switch (AUVI_INPUT(index
).type
) {
1441 case AU0828_VMUX_SVIDEO
:
1442 dev
->input_type
= AU0828_VMUX_SVIDEO
;
1443 dev
->ctrl_ainput
= 1;
1445 case AU0828_VMUX_COMPOSITE
:
1446 dev
->input_type
= AU0828_VMUX_COMPOSITE
;
1447 dev
->ctrl_ainput
= 1;
1449 case AU0828_VMUX_TELEVISION
:
1450 dev
->input_type
= AU0828_VMUX_TELEVISION
;
1451 dev
->ctrl_ainput
= 0;
1454 dprintk(1, "unknown input type set [%d]\n",
1455 AUVI_INPUT(index
).type
);
1459 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_routing
,
1460 AUVI_INPUT(index
).vmux
, 0, 0);
1462 for (i
= 0; i
< AU0828_MAX_INPUT
; i
++) {
1464 if (AUVI_INPUT(i
).audio_setup
== NULL
)
1472 (AUVI_INPUT(i
).audio_setup
)(dev
, enable
);
1474 /* Make sure we leave it turned on if some
1475 other input is routed to this callback */
1476 if ((AUVI_INPUT(i
).audio_setup
) !=
1477 ((AUVI_INPUT(index
).audio_setup
))) {
1478 (AUVI_INPUT(i
).audio_setup
)(dev
, enable
);
1483 v4l2_device_call_all(&dev
->v4l2_dev
, 0, audio
, s_routing
,
1484 AUVI_INPUT(index
).amux
, 0, 0);
1487 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int index
)
1489 struct au0828_fh
*fh
= priv
;
1490 struct au0828_dev
*dev
= fh
->dev
;
1492 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__
,
1494 if (index
>= AU0828_MAX_INPUT
)
1496 if (AUVI_INPUT(index
).type
== 0)
1498 dev
->ctrl_input
= index
;
1499 au0828_s_input(dev
, index
);
1503 static int vidioc_enumaudio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
1509 strcpy(a
->name
, "Television");
1511 strcpy(a
->name
, "Line in");
1513 a
->capability
= V4L2_AUDCAP_STEREO
;
1517 static int vidioc_g_audio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
1519 struct au0828_fh
*fh
= priv
;
1520 struct au0828_dev
*dev
= fh
->dev
;
1522 a
->index
= dev
->ctrl_ainput
;
1524 strcpy(a
->name
, "Television");
1526 strcpy(a
->name
, "Line in");
1528 a
->capability
= V4L2_AUDCAP_STEREO
;
1532 static int vidioc_s_audio(struct file
*file
, void *priv
, const struct v4l2_audio
*a
)
1534 struct au0828_fh
*fh
= priv
;
1535 struct au0828_dev
*dev
= fh
->dev
;
1537 if (a
->index
!= dev
->ctrl_ainput
)
1542 static int vidioc_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*t
)
1544 struct au0828_fh
*fh
= priv
;
1545 struct au0828_dev
*dev
= fh
->dev
;
1550 strcpy(t
->name
, "Auvitek tuner");
1552 au0828_init_tuner(dev
);
1553 i2c_gate_ctrl(dev
, 1);
1554 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_tuner
, t
);
1555 i2c_gate_ctrl(dev
, 0);
1559 static int vidioc_s_tuner(struct file
*file
, void *priv
,
1560 const struct v4l2_tuner
*t
)
1562 struct au0828_fh
*fh
= priv
;
1563 struct au0828_dev
*dev
= fh
->dev
;
1568 au0828_init_tuner(dev
);
1569 i2c_gate_ctrl(dev
, 1);
1570 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_tuner
, t
);
1571 i2c_gate_ctrl(dev
, 0);
1573 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t
->signal
,
1580 static int vidioc_g_frequency(struct file
*file
, void *priv
,
1581 struct v4l2_frequency
*freq
)
1583 struct au0828_fh
*fh
= priv
;
1584 struct au0828_dev
*dev
= fh
->dev
;
1586 if (freq
->tuner
!= 0)
1588 freq
->frequency
= dev
->ctrl_freq
;
1592 static int vidioc_s_frequency(struct file
*file
, void *priv
,
1593 const struct v4l2_frequency
*freq
)
1595 struct au0828_fh
*fh
= priv
;
1596 struct au0828_dev
*dev
= fh
->dev
;
1597 struct v4l2_frequency new_freq
= *freq
;
1599 if (freq
->tuner
!= 0)
1602 au0828_init_tuner(dev
);
1603 i2c_gate_ctrl(dev
, 1);
1605 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, freq
);
1606 /* Get the actual set (and possibly clamped) frequency */
1607 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_frequency
, &new_freq
);
1608 dev
->ctrl_freq
= new_freq
.frequency
;
1610 i2c_gate_ctrl(dev
, 0);
1612 au0828_analog_stream_reset(dev
);
1618 /* RAW VBI ioctls */
1620 static int vidioc_g_fmt_vbi_cap(struct file
*file
, void *priv
,
1621 struct v4l2_format
*format
)
1623 struct au0828_fh
*fh
= priv
;
1624 struct au0828_dev
*dev
= fh
->dev
;
1626 format
->fmt
.vbi
.samples_per_line
= dev
->vbi_width
;
1627 format
->fmt
.vbi
.sample_format
= V4L2_PIX_FMT_GREY
;
1628 format
->fmt
.vbi
.offset
= 0;
1629 format
->fmt
.vbi
.flags
= 0;
1630 format
->fmt
.vbi
.sampling_rate
= 6750000 * 4 / 2;
1632 format
->fmt
.vbi
.count
[0] = dev
->vbi_height
;
1633 format
->fmt
.vbi
.count
[1] = dev
->vbi_height
;
1634 format
->fmt
.vbi
.start
[0] = 21;
1635 format
->fmt
.vbi
.start
[1] = 284;
1636 memset(format
->fmt
.vbi
.reserved
, 0, sizeof(format
->fmt
.vbi
.reserved
));
1641 static int vidioc_g_chip_ident(struct file
*file
, void *priv
,
1642 struct v4l2_dbg_chip_ident
*chip
)
1644 struct au0828_fh
*fh
= priv
;
1645 struct au0828_dev
*dev
= fh
->dev
;
1646 chip
->ident
= V4L2_IDENT_NONE
;
1649 if (v4l2_chip_match_host(&chip
->match
)) {
1650 chip
->ident
= V4L2_IDENT_AU0828
;
1654 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, g_chip_ident
, chip
);
1655 if (chip
->ident
== V4L2_IDENT_NONE
)
1661 static int vidioc_cropcap(struct file
*file
, void *priv
,
1662 struct v4l2_cropcap
*cc
)
1664 struct au0828_fh
*fh
= priv
;
1665 struct au0828_dev
*dev
= fh
->dev
;
1667 if (cc
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1670 cc
->bounds
.left
= 0;
1672 cc
->bounds
.width
= dev
->width
;
1673 cc
->bounds
.height
= dev
->height
;
1675 cc
->defrect
= cc
->bounds
;
1677 cc
->pixelaspect
.numerator
= 54;
1678 cc
->pixelaspect
.denominator
= 59;
1683 static int vidioc_streamon(struct file
*file
, void *priv
,
1684 enum v4l2_buf_type type
)
1686 struct au0828_fh
*fh
= priv
;
1687 struct au0828_dev
*dev
= fh
->dev
;
1690 rc
= check_dev(dev
);
1694 if (unlikely(type
!= fh
->type
))
1697 dprintk(1, "vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
1698 fh
, type
, fh
->resources
, dev
->resources
);
1700 if (unlikely(!res_get(fh
, get_ressource(fh
))))
1703 au0828_init_tuner(dev
);
1704 if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1705 au0828_analog_stream_enable(dev
);
1706 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_stream
, 1);
1709 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1710 rc
= videobuf_streamon(&fh
->vb_vidq
);
1711 dev
->vid_timeout_running
= 1;
1712 mod_timer(&dev
->vid_timeout
, jiffies
+ (HZ
/ 10));
1713 } else if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
1714 rc
= videobuf_streamon(&fh
->vb_vbiq
);
1715 dev
->vbi_timeout_running
= 1;
1716 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
1722 static int vidioc_streamoff(struct file
*file
, void *priv
,
1723 enum v4l2_buf_type type
)
1725 struct au0828_fh
*fh
= priv
;
1726 struct au0828_dev
*dev
= fh
->dev
;
1730 rc
= check_dev(dev
);
1734 if (fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
1735 fh
->type
!= V4L2_BUF_TYPE_VBI_CAPTURE
)
1737 if (type
!= fh
->type
)
1740 dprintk(1, "vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
1741 fh
, type
, fh
->resources
, dev
->resources
);
1743 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1744 dev
->vid_timeout_running
= 0;
1745 del_timer_sync(&dev
->vid_timeout
);
1747 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_stream
, 0);
1748 rc
= au0828_stream_interrupt(dev
);
1752 for (i
= 0; i
< AU0828_MAX_INPUT
; i
++) {
1753 if (AUVI_INPUT(i
).audio_setup
== NULL
)
1755 (AUVI_INPUT(i
).audio_setup
)(dev
, 0);
1758 if (res_check(fh
, AU0828_RESOURCE_VIDEO
)) {
1759 videobuf_streamoff(&fh
->vb_vidq
);
1760 res_free(fh
, AU0828_RESOURCE_VIDEO
);
1762 } else if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
1763 dev
->vbi_timeout_running
= 0;
1764 del_timer_sync(&dev
->vbi_timeout
);
1766 if (res_check(fh
, AU0828_RESOURCE_VBI
)) {
1767 videobuf_streamoff(&fh
->vb_vbiq
);
1768 res_free(fh
, AU0828_RESOURCE_VBI
);
1775 #ifdef CONFIG_VIDEO_ADV_DEBUG
1776 static int vidioc_g_register(struct file
*file
, void *priv
,
1777 struct v4l2_dbg_register
*reg
)
1779 struct au0828_fh
*fh
= priv
;
1780 struct au0828_dev
*dev
= fh
->dev
;
1782 switch (reg
->match
.type
) {
1783 case V4L2_CHIP_MATCH_I2C_DRIVER
:
1784 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, g_register
, reg
);
1787 if (!v4l2_chip_match_host(®
->match
))
1791 reg
->val
= au0828_read(dev
, reg
->reg
);
1795 static int vidioc_s_register(struct file
*file
, void *priv
,
1796 const struct v4l2_dbg_register
*reg
)
1798 struct au0828_fh
*fh
= priv
;
1799 struct au0828_dev
*dev
= fh
->dev
;
1801 switch (reg
->match
.type
) {
1802 case V4L2_CHIP_MATCH_I2C_DRIVER
:
1803 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_register
, reg
);
1806 if (!v4l2_chip_match_host(®
->match
))
1809 return au0828_writereg(dev
, reg
->reg
, reg
->val
);
1813 static int vidioc_log_status(struct file
*file
, void *fh
)
1815 struct video_device
*vdev
= video_devdata(file
);
1817 v4l2_ctrl_log_status(file
, fh
);
1818 v4l2_device_call_all(vdev
->v4l2_dev
, 0, core
, log_status
);
1822 static int vidioc_reqbufs(struct file
*file
, void *priv
,
1823 struct v4l2_requestbuffers
*rb
)
1825 struct au0828_fh
*fh
= priv
;
1826 struct au0828_dev
*dev
= fh
->dev
;
1829 rc
= check_dev(dev
);
1833 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1834 rc
= videobuf_reqbufs(&fh
->vb_vidq
, rb
);
1835 else if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1836 rc
= videobuf_reqbufs(&fh
->vb_vbiq
, rb
);
1841 static int vidioc_querybuf(struct file
*file
, void *priv
,
1842 struct v4l2_buffer
*b
)
1844 struct au0828_fh
*fh
= priv
;
1845 struct au0828_dev
*dev
= fh
->dev
;
1848 rc
= check_dev(dev
);
1852 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1853 rc
= videobuf_querybuf(&fh
->vb_vidq
, b
);
1854 else if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1855 rc
= videobuf_querybuf(&fh
->vb_vbiq
, b
);
1860 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*b
)
1862 struct au0828_fh
*fh
= priv
;
1863 struct au0828_dev
*dev
= fh
->dev
;
1866 rc
= check_dev(dev
);
1870 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1871 rc
= videobuf_qbuf(&fh
->vb_vidq
, b
);
1872 else if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1873 rc
= videobuf_qbuf(&fh
->vb_vbiq
, b
);
1878 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*b
)
1880 struct au0828_fh
*fh
= priv
;
1881 struct au0828_dev
*dev
= fh
->dev
;
1884 rc
= check_dev(dev
);
1888 /* Workaround for a bug in the au0828 hardware design that sometimes
1889 results in the colorspace being inverted */
1890 if (dev
->greenscreen_detected
== 1) {
1891 dprintk(1, "Detected green frame. Resetting stream...\n");
1892 au0828_analog_stream_reset(dev
);
1893 dev
->greenscreen_detected
= 0;
1896 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1897 rc
= videobuf_dqbuf(&fh
->vb_vidq
, b
, file
->f_flags
& O_NONBLOCK
);
1898 else if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1899 rc
= videobuf_dqbuf(&fh
->vb_vbiq
, b
, file
->f_flags
& O_NONBLOCK
);
1904 static struct v4l2_file_operations au0828_v4l_fops
= {
1905 .owner
= THIS_MODULE
,
1906 .open
= au0828_v4l2_open
,
1907 .release
= au0828_v4l2_close
,
1908 .read
= au0828_v4l2_read
,
1909 .poll
= au0828_v4l2_poll
,
1910 .mmap
= au0828_v4l2_mmap
,
1911 .unlocked_ioctl
= video_ioctl2
,
1914 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
1915 .vidioc_querycap
= vidioc_querycap
,
1916 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1917 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1918 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1919 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1920 .vidioc_g_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1921 .vidioc_try_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1922 .vidioc_s_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1923 .vidioc_enumaudio
= vidioc_enumaudio
,
1924 .vidioc_g_audio
= vidioc_g_audio
,
1925 .vidioc_s_audio
= vidioc_s_audio
,
1926 .vidioc_cropcap
= vidioc_cropcap
,
1927 .vidioc_reqbufs
= vidioc_reqbufs
,
1928 .vidioc_querybuf
= vidioc_querybuf
,
1929 .vidioc_qbuf
= vidioc_qbuf
,
1930 .vidioc_dqbuf
= vidioc_dqbuf
,
1931 .vidioc_s_std
= vidioc_s_std
,
1932 .vidioc_g_std
= vidioc_g_std
,
1933 .vidioc_enum_input
= vidioc_enum_input
,
1934 .vidioc_g_input
= vidioc_g_input
,
1935 .vidioc_s_input
= vidioc_s_input
,
1936 .vidioc_streamon
= vidioc_streamon
,
1937 .vidioc_streamoff
= vidioc_streamoff
,
1938 .vidioc_g_tuner
= vidioc_g_tuner
,
1939 .vidioc_s_tuner
= vidioc_s_tuner
,
1940 .vidioc_g_frequency
= vidioc_g_frequency
,
1941 .vidioc_s_frequency
= vidioc_s_frequency
,
1942 #ifdef CONFIG_VIDEO_ADV_DEBUG
1943 .vidioc_g_register
= vidioc_g_register
,
1944 .vidioc_s_register
= vidioc_s_register
,
1946 .vidioc_g_chip_ident
= vidioc_g_chip_ident
,
1947 .vidioc_log_status
= vidioc_log_status
,
1948 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1949 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1952 static const struct video_device au0828_video_template
= {
1953 .fops
= &au0828_v4l_fops
,
1954 .release
= video_device_release
,
1955 .ioctl_ops
= &video_ioctl_ops
,
1956 .tvnorms
= V4L2_STD_NTSC_M
,
1959 /**************************************************************************/
1961 int au0828_analog_register(struct au0828_dev
*dev
,
1962 struct usb_interface
*interface
)
1964 int retval
= -ENOMEM
;
1965 struct usb_host_interface
*iface_desc
;
1966 struct usb_endpoint_descriptor
*endpoint
;
1969 dprintk(1, "au0828_analog_register called!\n");
1971 /* set au0828 usb interface0 to as5 */
1972 retval
= usb_set_interface(dev
->usbdev
,
1973 interface
->cur_altsetting
->desc
.bInterfaceNumber
, 5);
1975 printk(KERN_INFO
"Failure setting usb interface0 to as5\n");
1979 /* Figure out which endpoint has the isoc interface */
1980 iface_desc
= interface
->cur_altsetting
;
1981 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; i
++) {
1982 endpoint
= &iface_desc
->endpoint
[i
].desc
;
1983 if (((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
1985 ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
1986 == USB_ENDPOINT_XFER_ISOC
)) {
1988 /* we find our isoc in endpoint */
1989 u16 tmp
= le16_to_cpu(endpoint
->wMaxPacketSize
);
1990 dev
->max_pkt_size
= (tmp
& 0x07ff) *
1991 (((tmp
& 0x1800) >> 11) + 1);
1992 dev
->isoc_in_endpointaddr
= endpoint
->bEndpointAddress
;
1995 if (!(dev
->isoc_in_endpointaddr
)) {
1996 printk(KERN_INFO
"Could not locate isoc endpoint\n");
2001 init_waitqueue_head(&dev
->open
);
2002 spin_lock_init(&dev
->slock
);
2004 /* init video dma queues */
2005 INIT_LIST_HEAD(&dev
->vidq
.active
);
2006 INIT_LIST_HEAD(&dev
->vidq
.queued
);
2007 INIT_LIST_HEAD(&dev
->vbiq
.active
);
2008 INIT_LIST_HEAD(&dev
->vbiq
.queued
);
2010 dev
->vid_timeout
.function
= au0828_vid_buffer_timeout
;
2011 dev
->vid_timeout
.data
= (unsigned long) dev
;
2012 init_timer(&dev
->vid_timeout
);
2014 dev
->vbi_timeout
.function
= au0828_vbi_buffer_timeout
;
2015 dev
->vbi_timeout
.data
= (unsigned long) dev
;
2016 init_timer(&dev
->vbi_timeout
);
2018 dev
->width
= NTSC_STD_W
;
2019 dev
->height
= NTSC_STD_H
;
2020 dev
->field_size
= dev
->width
* dev
->height
;
2021 dev
->frame_size
= dev
->field_size
<< 1;
2022 dev
->bytesperline
= dev
->width
<< 1;
2023 dev
->vbi_width
= 720;
2024 dev
->vbi_height
= 1;
2025 dev
->ctrl_ainput
= 0;
2026 dev
->ctrl_freq
= 960;
2027 dev
->std
= V4L2_STD_NTSC_M
;
2028 au0828_s_input(dev
, 0);
2030 /* allocate and fill v4l2 video struct */
2031 dev
->vdev
= video_device_alloc();
2032 if (NULL
== dev
->vdev
) {
2033 dprintk(1, "Can't allocate video_device.\n");
2037 /* allocate the VBI struct */
2038 dev
->vbi_dev
= video_device_alloc();
2039 if (NULL
== dev
->vbi_dev
) {
2040 dprintk(1, "Can't allocate vbi_device.\n");
2045 /* Fill the video capture device struct */
2046 *dev
->vdev
= au0828_video_template
;
2047 dev
->vdev
->v4l2_dev
= &dev
->v4l2_dev
;
2048 dev
->vdev
->lock
= &dev
->lock
;
2049 set_bit(V4L2_FL_USE_FH_PRIO
, &dev
->vdev
->flags
);
2050 strcpy(dev
->vdev
->name
, "au0828a video");
2052 /* Setup the VBI device */
2053 *dev
->vbi_dev
= au0828_video_template
;
2054 dev
->vbi_dev
->v4l2_dev
= &dev
->v4l2_dev
;
2055 dev
->vbi_dev
->lock
= &dev
->lock
;
2056 set_bit(V4L2_FL_USE_FH_PRIO
, &dev
->vbi_dev
->flags
);
2057 strcpy(dev
->vbi_dev
->name
, "au0828a vbi");
2059 /* Register the v4l2 device */
2060 video_set_drvdata(dev
->vdev
, dev
);
2061 retval
= video_register_device(dev
->vdev
, VFL_TYPE_GRABBER
, -1);
2063 dprintk(1, "unable to register video device (error = %d).\n",
2069 /* Register the vbi device */
2070 video_set_drvdata(dev
->vbi_dev
, dev
);
2071 retval
= video_register_device(dev
->vbi_dev
, VFL_TYPE_VBI
, -1);
2073 dprintk(1, "unable to register vbi device (error = %d).\n",
2079 dprintk(1, "%s completed!\n", __func__
);
2084 video_device_release(dev
->vbi_dev
);
2086 video_device_release(dev
->vdev
);