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 * The hardware scaler supported is unimplemented
26 * AC97 audio support is unimplemented (only i2s audio mode)
33 #include <linux/module.h>
34 #include <linux/slab.h>
35 #include <linux/init.h>
36 #include <linux/device.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-mc.h>
39 #include <media/v4l2-ioctl.h>
40 #include <media/v4l2-event.h>
41 #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 pr_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 (test_bit(DEV_DISCONNECTED
, &dev
->dev_state
)) {
110 pr_info("v4l2 ioctl: device not present\n");
114 if (test_bit(DEV_MISCONFIGURED
, &dev
->dev_state
)) {
115 pr_info("v4l2 ioctl: device is misconfigured; close and open it again\n");
122 * IRQ callback, called by URB callback
124 static void au0828_irq_callback(struct urb
*urb
)
126 struct au0828_dmaqueue
*dma_q
= urb
->context
;
127 struct au0828_dev
*dev
= container_of(dma_q
, struct au0828_dev
, vidq
);
128 unsigned long flags
= 0;
131 switch (urb
->status
) {
132 case 0: /* success */
133 case -ETIMEDOUT
: /* NAK */
135 case -ECONNRESET
: /* kill */
138 au0828_isocdbg("au0828_irq_callback called: status kill\n");
140 default: /* unknown error */
141 au0828_isocdbg("urb completition error %d.\n", urb
->status
);
145 /* Copy data from URB */
146 spin_lock_irqsave(&dev
->slock
, flags
);
147 dev
->isoc_ctl
.isoc_copy(dev
, urb
);
148 spin_unlock_irqrestore(&dev
->slock
, flags
);
150 /* Reset urb buffers */
151 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
152 urb
->iso_frame_desc
[i
].status
= 0;
153 urb
->iso_frame_desc
[i
].actual_length
= 0;
157 urb
->status
= usb_submit_urb(urb
, GFP_ATOMIC
);
159 au0828_isocdbg("urb resubmit failed (error=%i)\n",
162 dev
->stream_state
= STREAM_ON
;
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;
203 dev
->stream_state
= STREAM_OFF
;
207 * Allocate URBs and start IRQ
209 static int au0828_init_isoc(struct au0828_dev
*dev
, int max_packets
,
210 int num_bufs
, int max_pkt_size
,
211 int (*isoc_copy
) (struct au0828_dev
*dev
, struct urb
*urb
))
213 struct au0828_dmaqueue
*dma_q
= &dev
->vidq
;
220 au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
222 dev
->isoc_ctl
.isoc_copy
= isoc_copy
;
223 dev
->isoc_ctl
.num_bufs
= num_bufs
;
225 dev
->isoc_ctl
.urb
= kzalloc(sizeof(void *)*num_bufs
, GFP_KERNEL
);
226 if (!dev
->isoc_ctl
.urb
) {
227 au0828_isocdbg("cannot alloc memory for usb buffers\n");
231 dev
->isoc_ctl
.transfer_buffer
= kzalloc(sizeof(void *)*num_bufs
,
233 if (!dev
->isoc_ctl
.transfer_buffer
) {
234 au0828_isocdbg("cannot allocate memory for usb transfer\n");
235 kfree(dev
->isoc_ctl
.urb
);
239 dev
->isoc_ctl
.max_pkt_size
= max_pkt_size
;
240 dev
->isoc_ctl
.buf
= NULL
;
242 sb_size
= max_packets
* dev
->isoc_ctl
.max_pkt_size
;
244 /* allocate urbs and transfer buffers */
245 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
246 urb
= usb_alloc_urb(max_packets
, GFP_KERNEL
);
248 au0828_isocdbg("cannot alloc isoc_ctl.urb %i\n", i
);
249 au0828_uninit_isoc(dev
);
252 dev
->isoc_ctl
.urb
[i
] = urb
;
254 dev
->isoc_ctl
.transfer_buffer
[i
] = usb_alloc_coherent(dev
->usbdev
,
255 sb_size
, GFP_KERNEL
, &urb
->transfer_dma
);
256 if (!dev
->isoc_ctl
.transfer_buffer
[i
]) {
257 printk("unable to allocate %i bytes for transfer"
260 in_interrupt() ? " while in int" : "");
261 au0828_uninit_isoc(dev
);
264 memset(dev
->isoc_ctl
.transfer_buffer
[i
], 0, sb_size
);
266 pipe
= usb_rcvisocpipe(dev
->usbdev
,
267 dev
->isoc_in_endpointaddr
),
269 usb_fill_int_urb(urb
, dev
->usbdev
, pipe
,
270 dev
->isoc_ctl
.transfer_buffer
[i
], sb_size
,
271 au0828_irq_callback
, dma_q
, 1);
273 urb
->number_of_packets
= max_packets
;
274 urb
->transfer_flags
= URB_ISO_ASAP
| URB_NO_TRANSFER_DMA_MAP
;
277 for (j
= 0; j
< max_packets
; j
++) {
278 urb
->iso_frame_desc
[j
].offset
= k
;
279 urb
->iso_frame_desc
[j
].length
=
280 dev
->isoc_ctl
.max_pkt_size
;
281 k
+= dev
->isoc_ctl
.max_pkt_size
;
285 /* submit urbs and enables IRQ */
286 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
287 rc
= usb_submit_urb(dev
->isoc_ctl
.urb
[i
], GFP_ATOMIC
);
289 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
291 au0828_uninit_isoc(dev
);
300 * Announces that a buffer were filled and request the next
302 static inline void buffer_filled(struct au0828_dev
*dev
,
303 struct au0828_dmaqueue
*dma_q
,
304 struct au0828_buffer
*buf
)
306 struct vb2_v4l2_buffer
*vb
= &buf
->vb
;
307 struct vb2_queue
*q
= vb
->vb2_buf
.vb2_queue
;
309 /* Advice that buffer was filled */
310 au0828_isocdbg("[%p/%d] wakeup\n", buf
, buf
->top_field
);
312 if (q
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
313 vb
->sequence
= dev
->frame_count
++;
315 vb
->sequence
= dev
->vbi_frame_count
++;
317 vb
->field
= V4L2_FIELD_INTERLACED
;
318 vb
->vb2_buf
.timestamp
= ktime_get_ns();
319 vb2_buffer_done(&vb
->vb2_buf
, VB2_BUF_STATE_DONE
);
323 * Identify the buffer header type and properly handles
325 static void au0828_copy_video(struct au0828_dev
*dev
,
326 struct au0828_dmaqueue
*dma_q
,
327 struct au0828_buffer
*buf
,
329 unsigned char *outp
, unsigned long len
)
331 void *fieldstart
, *startwrite
, *startread
;
332 int linesdone
, currlinedone
, offset
, lencopy
, remain
;
333 int bytesperline
= dev
->width
<< 1; /* Assumes 16-bit depth @@@@ */
338 if (dma_q
->pos
+ len
> buf
->length
)
339 len
= buf
->length
- dma_q
->pos
;
344 /* Interlaces frame */
348 fieldstart
= outp
+ bytesperline
;
350 linesdone
= dma_q
->pos
/ bytesperline
;
351 currlinedone
= dma_q
->pos
% bytesperline
;
352 offset
= linesdone
* bytesperline
* 2 + currlinedone
;
353 startwrite
= fieldstart
+ offset
;
354 lencopy
= bytesperline
- currlinedone
;
355 lencopy
= lencopy
> remain
? remain
: lencopy
;
357 if ((char *)startwrite
+ lencopy
> (char *)outp
+ buf
->length
) {
358 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
359 ((char *)startwrite
+ lencopy
) -
360 ((char *)outp
+ buf
->length
));
361 remain
= (char *)outp
+ buf
->length
- (char *)startwrite
;
366 memcpy(startwrite
, startread
, lencopy
);
371 startwrite
+= lencopy
+ bytesperline
;
372 startread
+= lencopy
;
373 if (bytesperline
> remain
)
376 lencopy
= bytesperline
;
378 if ((char *)startwrite
+ lencopy
> (char *)outp
+
380 au0828_isocdbg("Overflow %zi bytes past buf end (2)\n",
381 ((char *)startwrite
+ lencopy
) -
382 ((char *)outp
+ buf
->length
));
383 lencopy
= remain
= (char *)outp
+ buf
->length
-
389 memcpy(startwrite
, startread
, lencopy
);
395 /* We have enough data to check for greenscreen */
396 if (outp
[0] < 0x60 && outp
[1440] < 0x60)
397 dev
->greenscreen_detected
= 1;
404 * video-buf generic routine to get the next available buffer
406 static inline void get_next_buf(struct au0828_dmaqueue
*dma_q
,
407 struct au0828_buffer
**buf
)
409 struct au0828_dev
*dev
= container_of(dma_q
, struct au0828_dev
, vidq
);
411 if (list_empty(&dma_q
->active
)) {
412 au0828_isocdbg("No active queue to serve\n");
413 dev
->isoc_ctl
.buf
= NULL
;
418 /* Get the next buffer */
419 *buf
= list_entry(dma_q
->active
.next
, struct au0828_buffer
, list
);
420 /* Cleans up buffer - Useful for testing for frame/URB loss */
421 list_del(&(*buf
)->list
);
423 (*buf
)->vb_buf
= (*buf
)->mem
;
424 dev
->isoc_ctl
.buf
= *buf
;
429 static void au0828_copy_vbi(struct au0828_dev
*dev
,
430 struct au0828_dmaqueue
*dma_q
,
431 struct au0828_buffer
*buf
,
433 unsigned char *outp
, unsigned long len
)
435 unsigned char *startwrite
, *startread
;
440 au0828_isocdbg("dev is null\n");
445 au0828_isocdbg("dma_q is null\n");
451 au0828_isocdbg("p is null\n");
455 au0828_isocdbg("outp is null\n");
459 bytesperline
= dev
->vbi_width
;
461 if (dma_q
->pos
+ len
> buf
->length
)
462 len
= buf
->length
- dma_q
->pos
;
465 startwrite
= outp
+ (dma_q
->pos
/ 2);
467 /* Make sure the bottom field populates the second half of the frame */
468 if (buf
->top_field
== 0)
469 startwrite
+= bytesperline
* dev
->vbi_height
;
471 for (i
= 0; i
< len
; i
+= 2)
472 startwrite
[j
++] = startread
[i
+1];
479 * video-buf generic routine to get the next available VBI buffer
481 static inline void vbi_get_next_buf(struct au0828_dmaqueue
*dma_q
,
482 struct au0828_buffer
**buf
)
484 struct au0828_dev
*dev
= container_of(dma_q
, struct au0828_dev
, vbiq
);
486 if (list_empty(&dma_q
->active
)) {
487 au0828_isocdbg("No active queue to serve\n");
488 dev
->isoc_ctl
.vbi_buf
= NULL
;
493 /* Get the next buffer */
494 *buf
= list_entry(dma_q
->active
.next
, struct au0828_buffer
, list
);
495 /* Cleans up buffer - Useful for testing for frame/URB loss */
496 list_del(&(*buf
)->list
);
498 (*buf
)->vb_buf
= (*buf
)->mem
;
499 dev
->isoc_ctl
.vbi_buf
= *buf
;
504 * Controls the isoc copy of each urb packet
506 static inline int au0828_isoc_copy(struct au0828_dev
*dev
, struct urb
*urb
)
508 struct au0828_buffer
*buf
;
509 struct au0828_buffer
*vbi_buf
;
510 struct au0828_dmaqueue
*dma_q
= urb
->context
;
511 struct au0828_dmaqueue
*vbi_dma_q
= &dev
->vbiq
;
512 unsigned char *outp
= NULL
;
513 unsigned char *vbioutp
= NULL
;
514 int i
, len
= 0, rc
= 1;
517 unsigned int vbi_field_size
;
518 unsigned int remain
, lencopy
;
523 if (test_bit(DEV_DISCONNECTED
, &dev
->dev_state
) ||
524 test_bit(DEV_MISCONFIGURED
, &dev
->dev_state
))
527 if (urb
->status
< 0) {
528 print_err_status(dev
, -1, urb
->status
);
529 if (urb
->status
== -ENOENT
)
533 buf
= dev
->isoc_ctl
.buf
;
535 outp
= vb2_plane_vaddr(&buf
->vb
.vb2_buf
, 0);
537 vbi_buf
= dev
->isoc_ctl
.vbi_buf
;
539 vbioutp
= vb2_plane_vaddr(&vbi_buf
->vb
.vb2_buf
, 0);
541 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
542 int status
= urb
->iso_frame_desc
[i
].status
;
545 print_err_status(dev
, i
, status
);
546 if (urb
->iso_frame_desc
[i
].status
!= -EPROTO
)
550 if (urb
->iso_frame_desc
[i
].actual_length
<= 0)
553 if (urb
->iso_frame_desc
[i
].actual_length
>
555 au0828_isocdbg("packet bigger than packet size");
559 p
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
561 len
= urb
->iso_frame_desc
[i
].actual_length
- 4;
567 au0828_isocdbg("Video frame %s\n",
568 (fbyte
& 0x40) ? "odd" : "even");
572 buffer_filled(dev
, vbi_dma_q
, vbi_buf
);
573 vbi_get_next_buf(vbi_dma_q
, &vbi_buf
);
577 vbioutp
= vb2_plane_vaddr(
578 &vbi_buf
->vb
.vb2_buf
, 0);
582 buffer_filled(dev
, dma_q
, buf
);
583 get_next_buf(dma_q
, &buf
);
587 outp
= vb2_plane_vaddr(
588 &buf
->vb
.vb2_buf
, 0);
590 /* As long as isoc traffic is arriving, keep
591 resetting the timer */
592 if (dev
->vid_timeout_running
)
593 mod_timer(&dev
->vid_timeout
,
594 jiffies
+ (HZ
/ 10));
595 if (dev
->vbi_timeout_running
)
596 mod_timer(&dev
->vbi_timeout
,
597 jiffies
+ (HZ
/ 10));
607 if (vbi_buf
!= NULL
) {
609 vbi_buf
->top_field
= 1;
611 vbi_buf
->top_field
= 0;
619 vbi_field_size
= dev
->vbi_width
* dev
->vbi_height
* 2;
620 if (dev
->vbi_read
< vbi_field_size
) {
621 remain
= vbi_field_size
- dev
->vbi_read
;
628 au0828_copy_vbi(dev
, vbi_dma_q
, vbi_buf
, p
,
633 dev
->vbi_read
+= lencopy
;
636 if (dev
->vbi_read
>= vbi_field_size
&& buf
!= NULL
)
637 au0828_copy_video(dev
, dma_q
, buf
, p
, outp
, len
);
642 void au0828_usb_v4l2_media_release(struct au0828_dev
*dev
)
644 #ifdef CONFIG_MEDIA_CONTROLLER
647 for (i
= 0; i
< AU0828_MAX_INPUT
; i
++) {
648 if (AUVI_INPUT(i
).type
== AU0828_VMUX_UNDEFINED
)
650 media_device_unregister_entity(&dev
->input_ent
[i
]);
655 static void au0828_usb_v4l2_release(struct v4l2_device
*v4l2_dev
)
657 struct au0828_dev
*dev
=
658 container_of(v4l2_dev
, struct au0828_dev
, v4l2_dev
);
660 v4l2_ctrl_handler_free(&dev
->v4l2_ctrl_hdl
);
661 v4l2_device_unregister(&dev
->v4l2_dev
);
662 au0828_usb_v4l2_media_release(dev
);
663 au0828_usb_release(dev
);
666 int au0828_v4l2_device_register(struct usb_interface
*interface
,
667 struct au0828_dev
*dev
)
671 if (AUVI_INPUT(0).type
== AU0828_VMUX_UNDEFINED
)
674 /* Create the v4l2_device */
675 #ifdef CONFIG_MEDIA_CONTROLLER
676 dev
->v4l2_dev
.mdev
= dev
->media_dev
;
678 retval
= v4l2_device_register(&interface
->dev
, &dev
->v4l2_dev
);
680 pr_err("%s() v4l2_device_register failed\n",
685 dev
->v4l2_dev
.release
= au0828_usb_v4l2_release
;
687 /* This control handler will inherit the controls from au8522 */
688 retval
= v4l2_ctrl_handler_init(&dev
->v4l2_ctrl_hdl
, 4);
690 pr_err("%s() v4l2_ctrl_handler_init failed\n",
694 dev
->v4l2_dev
.ctrl_handler
= &dev
->v4l2_ctrl_hdl
;
699 static int queue_setup(struct vb2_queue
*vq
,
700 unsigned int *nbuffers
, unsigned int *nplanes
,
701 unsigned int sizes
[], struct device
*alloc_devs
[])
703 struct au0828_dev
*dev
= vb2_get_drv_priv(vq
);
704 unsigned long size
= dev
->height
* dev
->bytesperline
;
707 return sizes
[0] < size
? -EINVAL
: 0;
714 buffer_prepare(struct vb2_buffer
*vb
)
716 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
717 struct au0828_buffer
*buf
= container_of(vbuf
,
718 struct au0828_buffer
, vb
);
719 struct au0828_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
721 buf
->length
= dev
->height
* dev
->bytesperline
;
723 if (vb2_plane_size(vb
, 0) < buf
->length
) {
724 pr_err("%s data will not fit into plane (%lu < %lu)\n",
725 __func__
, vb2_plane_size(vb
, 0), buf
->length
);
728 vb2_set_plane_payload(&buf
->vb
.vb2_buf
, 0, buf
->length
);
733 buffer_queue(struct vb2_buffer
*vb
)
735 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
736 struct au0828_buffer
*buf
= container_of(vbuf
,
737 struct au0828_buffer
,
739 struct au0828_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
740 struct au0828_dmaqueue
*vidq
= &dev
->vidq
;
741 unsigned long flags
= 0;
743 buf
->mem
= vb2_plane_vaddr(vb
, 0);
744 buf
->length
= vb2_plane_size(vb
, 0);
746 spin_lock_irqsave(&dev
->slock
, flags
);
747 list_add_tail(&buf
->list
, &vidq
->active
);
748 spin_unlock_irqrestore(&dev
->slock
, flags
);
751 static int au0828_i2s_init(struct au0828_dev
*dev
)
753 /* Enable i2s mode */
754 au0828_writereg(dev
, AU0828_AUDIOCTRL_50C
, 0x01);
759 * Auvitek au0828 analog stream enable
761 static int au0828_analog_stream_enable(struct au0828_dev
*d
)
763 struct usb_interface
*iface
;
766 dprintk(1, "au0828_analog_stream_enable called\n");
768 iface
= usb_ifnum_to_if(d
->usbdev
, 0);
769 if (iface
&& iface
->cur_altsetting
->desc
.bAlternateSetting
!= 5) {
770 dprintk(1, "Changing intf#0 to alt 5\n");
771 /* set au0828 interface0 to AS5 here again */
772 ret
= usb_set_interface(d
->usbdev
, 0, 5);
774 pr_info("Au0828 can't set alt setting to 5!\n");
779 h
= d
->height
/ 2 + 2;
782 au0828_writereg(d
, AU0828_SENSORCTRL_VBI_103
, 0x00);
783 au0828_writereg(d
, 0x106, 0x00);
785 au0828_writereg(d
, 0x110, 0x00);
786 au0828_writereg(d
, 0x111, 0x00);
787 au0828_writereg(d
, 0x114, w
& 0xff);
788 au0828_writereg(d
, 0x115, w
>> 8);
790 au0828_writereg(d
, 0x112, 0x00);
791 au0828_writereg(d
, 0x113, 0x00);
792 au0828_writereg(d
, 0x116, h
& 0xff);
793 au0828_writereg(d
, 0x117, h
>> 8);
794 au0828_writereg(d
, AU0828_SENSORCTRL_100
, 0xb3);
799 static int au0828_analog_stream_disable(struct au0828_dev
*d
)
801 dprintk(1, "au0828_analog_stream_disable called\n");
802 au0828_writereg(d
, AU0828_SENSORCTRL_100
, 0x0);
806 static void au0828_analog_stream_reset(struct au0828_dev
*dev
)
808 dprintk(1, "au0828_analog_stream_reset called\n");
809 au0828_writereg(dev
, AU0828_SENSORCTRL_100
, 0x0);
811 au0828_writereg(dev
, AU0828_SENSORCTRL_100
, 0xb3);
815 * Some operations needs to stop current streaming
817 static int au0828_stream_interrupt(struct au0828_dev
*dev
)
821 dev
->stream_state
= STREAM_INTERRUPT
;
822 if (test_bit(DEV_DISCONNECTED
, &dev
->dev_state
))
825 set_bit(DEV_MISCONFIGURED
, &dev
->dev_state
);
826 dprintk(1, "%s device is misconfigured!\n", __func__
);
832 int au0828_start_analog_streaming(struct vb2_queue
*vq
, unsigned int count
)
834 struct au0828_dev
*dev
= vb2_get_drv_priv(vq
);
837 dprintk(1, "au0828_start_analog_streaming called %d\n",
838 dev
->streaming_users
);
840 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
841 dev
->frame_count
= 0;
843 dev
->vbi_frame_count
= 0;
845 if (dev
->streaming_users
== 0) {
846 /* If we were doing ac97 instead of i2s, it would go here...*/
847 au0828_i2s_init(dev
);
848 rc
= au0828_init_isoc(dev
, AU0828_ISO_PACKETS_PER_URB
,
849 AU0828_MAX_ISO_BUFS
, dev
->max_pkt_size
,
852 pr_info("au0828_init_isoc failed\n");
856 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
857 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
,
859 dev
->vid_timeout_running
= 1;
860 mod_timer(&dev
->vid_timeout
, jiffies
+ (HZ
/ 10));
861 } else if (vq
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
862 dev
->vbi_timeout_running
= 1;
863 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
866 dev
->streaming_users
++;
870 static void au0828_stop_streaming(struct vb2_queue
*vq
)
872 struct au0828_dev
*dev
= vb2_get_drv_priv(vq
);
873 struct au0828_dmaqueue
*vidq
= &dev
->vidq
;
874 unsigned long flags
= 0;
876 dprintk(1, "au0828_stop_streaming called %d\n", dev
->streaming_users
);
878 if (dev
->streaming_users
-- == 1)
879 au0828_uninit_isoc(dev
);
881 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_stream
, 0);
882 dev
->vid_timeout_running
= 0;
883 del_timer_sync(&dev
->vid_timeout
);
885 spin_lock_irqsave(&dev
->slock
, flags
);
886 if (dev
->isoc_ctl
.buf
!= NULL
) {
887 vb2_buffer_done(&dev
->isoc_ctl
.buf
->vb
.vb2_buf
,
888 VB2_BUF_STATE_ERROR
);
889 dev
->isoc_ctl
.buf
= NULL
;
891 while (!list_empty(&vidq
->active
)) {
892 struct au0828_buffer
*buf
;
894 buf
= list_entry(vidq
->active
.next
, struct au0828_buffer
, list
);
895 vb2_buffer_done(&buf
->vb
.vb2_buf
, VB2_BUF_STATE_ERROR
);
896 list_del(&buf
->list
);
898 spin_unlock_irqrestore(&dev
->slock
, flags
);
901 void au0828_stop_vbi_streaming(struct vb2_queue
*vq
)
903 struct au0828_dev
*dev
= vb2_get_drv_priv(vq
);
904 struct au0828_dmaqueue
*vbiq
= &dev
->vbiq
;
905 unsigned long flags
= 0;
907 dprintk(1, "au0828_stop_vbi_streaming called %d\n",
908 dev
->streaming_users
);
910 if (dev
->streaming_users
-- == 1)
911 au0828_uninit_isoc(dev
);
913 spin_lock_irqsave(&dev
->slock
, flags
);
914 if (dev
->isoc_ctl
.vbi_buf
!= NULL
) {
915 vb2_buffer_done(&dev
->isoc_ctl
.vbi_buf
->vb
.vb2_buf
,
916 VB2_BUF_STATE_ERROR
);
917 dev
->isoc_ctl
.vbi_buf
= NULL
;
919 while (!list_empty(&vbiq
->active
)) {
920 struct au0828_buffer
*buf
;
922 buf
= list_entry(vbiq
->active
.next
, struct au0828_buffer
, list
);
923 list_del(&buf
->list
);
924 vb2_buffer_done(&buf
->vb
.vb2_buf
, VB2_BUF_STATE_ERROR
);
926 spin_unlock_irqrestore(&dev
->slock
, flags
);
928 dev
->vbi_timeout_running
= 0;
929 del_timer_sync(&dev
->vbi_timeout
);
932 static struct vb2_ops au0828_video_qops
= {
933 .queue_setup
= queue_setup
,
934 .buf_prepare
= buffer_prepare
,
935 .buf_queue
= buffer_queue
,
936 .start_streaming
= au0828_start_analog_streaming
,
937 .stop_streaming
= au0828_stop_streaming
,
938 .wait_prepare
= vb2_ops_wait_prepare
,
939 .wait_finish
= vb2_ops_wait_finish
,
942 /* ------------------------------------------------------------------
944 ------------------------------------------------------------------*/
946 * au0828_analog_unregister
947 * unregister v4l2 devices
949 int au0828_analog_unregister(struct au0828_dev
*dev
)
951 dprintk(1, "au0828_analog_unregister called\n");
954 if (AUVI_INPUT(0).type
== AU0828_VMUX_UNDEFINED
)
957 mutex_lock(&au0828_sysfs_lock
);
958 video_unregister_device(&dev
->vdev
);
959 video_unregister_device(&dev
->vbi_dev
);
960 mutex_unlock(&au0828_sysfs_lock
);
962 v4l2_device_disconnect(&dev
->v4l2_dev
);
963 v4l2_device_put(&dev
->v4l2_dev
);
968 /* This function ensures that video frames continue to be delivered even if
969 the ITU-656 input isn't receiving any data (thereby preventing applications
970 such as tvtime from hanging) */
971 static void au0828_vid_buffer_timeout(unsigned long data
)
973 struct au0828_dev
*dev
= (struct au0828_dev
*) data
;
974 struct au0828_dmaqueue
*dma_q
= &dev
->vidq
;
975 struct au0828_buffer
*buf
;
976 unsigned char *vid_data
;
977 unsigned long flags
= 0;
979 spin_lock_irqsave(&dev
->slock
, flags
);
981 buf
= dev
->isoc_ctl
.buf
;
983 vid_data
= vb2_plane_vaddr(&buf
->vb
.vb2_buf
, 0);
984 memset(vid_data
, 0x00, buf
->length
); /* Blank green frame */
985 buffer_filled(dev
, dma_q
, buf
);
987 get_next_buf(dma_q
, &buf
);
989 if (dev
->vid_timeout_running
== 1)
990 mod_timer(&dev
->vid_timeout
, jiffies
+ (HZ
/ 10));
992 spin_unlock_irqrestore(&dev
->slock
, flags
);
995 static void au0828_vbi_buffer_timeout(unsigned long data
)
997 struct au0828_dev
*dev
= (struct au0828_dev
*) data
;
998 struct au0828_dmaqueue
*dma_q
= &dev
->vbiq
;
999 struct au0828_buffer
*buf
;
1000 unsigned char *vbi_data
;
1001 unsigned long flags
= 0;
1003 spin_lock_irqsave(&dev
->slock
, flags
);
1005 buf
= dev
->isoc_ctl
.vbi_buf
;
1007 vbi_data
= vb2_plane_vaddr(&buf
->vb
.vb2_buf
, 0);
1008 memset(vbi_data
, 0x00, buf
->length
);
1009 buffer_filled(dev
, dma_q
, buf
);
1011 vbi_get_next_buf(dma_q
, &buf
);
1013 if (dev
->vbi_timeout_running
== 1)
1014 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
1015 spin_unlock_irqrestore(&dev
->slock
, flags
);
1018 static int au0828_v4l2_open(struct file
*filp
)
1020 struct au0828_dev
*dev
= video_drvdata(filp
);
1024 "%s called std_set %d dev_state %ld stream users %d users %d\n",
1025 __func__
, dev
->std_set_in_tuner_core
, dev
->dev_state
,
1026 dev
->streaming_users
, dev
->users
);
1028 if (mutex_lock_interruptible(&dev
->lock
))
1029 return -ERESTARTSYS
;
1031 ret
= v4l2_fh_open(filp
);
1033 au0828_isocdbg("%s: v4l2_fh_open() returned error %d\n",
1035 mutex_unlock(&dev
->lock
);
1039 if (dev
->users
== 0) {
1040 au0828_analog_stream_enable(dev
);
1041 au0828_analog_stream_reset(dev
);
1042 dev
->stream_state
= STREAM_OFF
;
1043 set_bit(DEV_INITIALIZED
, &dev
->dev_state
);
1046 mutex_unlock(&dev
->lock
);
1050 static int au0828_v4l2_close(struct file
*filp
)
1053 struct au0828_dev
*dev
= video_drvdata(filp
);
1054 struct video_device
*vdev
= video_devdata(filp
);
1057 "%s called std_set %d dev_state %ld stream users %d users %d\n",
1058 __func__
, dev
->std_set_in_tuner_core
, dev
->dev_state
,
1059 dev
->streaming_users
, dev
->users
);
1061 mutex_lock(&dev
->lock
);
1062 if (vdev
->vfl_type
== VFL_TYPE_GRABBER
&& dev
->vid_timeout_running
) {
1063 /* Cancel timeout thread in case they didn't call streamoff */
1064 dev
->vid_timeout_running
= 0;
1065 del_timer_sync(&dev
->vid_timeout
);
1066 } else if (vdev
->vfl_type
== VFL_TYPE_VBI
&&
1067 dev
->vbi_timeout_running
) {
1068 /* Cancel timeout thread in case they didn't call streamoff */
1069 dev
->vbi_timeout_running
= 0;
1070 del_timer_sync(&dev
->vbi_timeout
);
1073 if (test_bit(DEV_DISCONNECTED
, &dev
->dev_state
))
1076 if (dev
->users
== 1) {
1078 * Avoid putting tuner in sleep if DVB or ALSA are
1081 * On most USB devices like au0828 the tuner can
1082 * be safely put in sleep stare here if ALSA isn't
1083 * streaming. Exceptions are some very old USB tuner
1084 * models such as em28xx-based WinTV USB2 which have
1085 * a separate audio output jack. The devices that have
1086 * a separate audio output jack have analog tuners,
1087 * like Philips FM1236. Those devices are always on,
1088 * so the s_power callback are silently ignored.
1089 * So, the current logic here does the following:
1090 * Disable (put tuner to sleep) when
1091 * - ALSA and DVB aren't not streaming;
1092 * - the last V4L2 file handler is closed.
1096 * Additionally, this logic could be improved to
1097 * disable the media source if the above conditions
1098 * are met and if the device:
1099 * - doesn't have a separate audio out plug (or
1100 * - doesn't use a silicon tuner like xc2028/3028/4000/5000).
1102 * Once this additional logic is in place, a callback
1103 * is needed to enable the media source and power on
1104 * the tuner, for radio to work.
1106 ret
= v4l_enable_media_source(vdev
);
1108 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
,
1110 dev
->std_set_in_tuner_core
= 0;
1112 /* When close the device, set the usb intf0 into alt0 to free
1114 ret
= usb_set_interface(dev
->usbdev
, 0, 0);
1116 pr_info("Au0828 can't set alternate to 0!\n");
1119 _vb2_fop_release(filp
, NULL
);
1121 mutex_unlock(&dev
->lock
);
1125 /* Must be called with dev->lock held */
1126 static void au0828_init_tuner(struct au0828_dev
*dev
)
1128 struct v4l2_frequency f
= {
1129 .frequency
= dev
->ctrl_freq
,
1130 .type
= V4L2_TUNER_ANALOG_TV
,
1133 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1134 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1136 if (dev
->std_set_in_tuner_core
)
1138 dev
->std_set_in_tuner_core
= 1;
1139 i2c_gate_ctrl(dev
, 1);
1140 /* If we've never sent the standard in tuner core, do so now.
1141 We don't do this at device probe because we don't want to
1142 incur the cost of a firmware load */
1143 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_std
, dev
->std
);
1144 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, &f
);
1145 i2c_gate_ctrl(dev
, 0);
1148 static int au0828_set_format(struct au0828_dev
*dev
, unsigned int cmd
,
1149 struct v4l2_format
*format
)
1152 int width
= format
->fmt
.pix
.width
;
1153 int height
= format
->fmt
.pix
.height
;
1155 /* If they are demanding a format other than the one we support,
1156 bail out (tvtime asks for UYVY and then retries with YUYV) */
1157 if (format
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_UYVY
)
1160 /* format->fmt.pix.width only support 720 and height 480 */
1166 format
->fmt
.pix
.width
= width
;
1167 format
->fmt
.pix
.height
= height
;
1168 format
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_UYVY
;
1169 format
->fmt
.pix
.bytesperline
= width
* 2;
1170 format
->fmt
.pix
.sizeimage
= width
* height
* 2;
1171 format
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1172 format
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1173 format
->fmt
.pix
.priv
= 0;
1175 if (cmd
== VIDIOC_TRY_FMT
)
1178 /* maybe set new image format, driver current only support 720*480 */
1180 dev
->height
= height
;
1181 dev
->frame_size
= width
* height
* 2;
1182 dev
->field_size
= width
* height
;
1183 dev
->bytesperline
= width
* 2;
1185 if (dev
->stream_state
== STREAM_ON
) {
1186 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
1187 ret
= au0828_stream_interrupt(dev
);
1189 dprintk(1, "error interrupting video stream!\n");
1194 au0828_analog_stream_enable(dev
);
1199 static int vidioc_querycap(struct file
*file
, void *priv
,
1200 struct v4l2_capability
*cap
)
1202 struct video_device
*vdev
= video_devdata(file
);
1203 struct au0828_dev
*dev
= video_drvdata(file
);
1205 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1206 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1208 strlcpy(cap
->driver
, "au0828", sizeof(cap
->driver
));
1209 strlcpy(cap
->card
, dev
->board
.name
, sizeof(cap
->card
));
1210 usb_make_path(dev
->usbdev
, cap
->bus_info
, sizeof(cap
->bus_info
));
1212 /* set the device capabilities */
1213 cap
->device_caps
= V4L2_CAP_AUDIO
|
1214 V4L2_CAP_READWRITE
|
1215 V4L2_CAP_STREAMING
|
1217 if (vdev
->vfl_type
== VFL_TYPE_GRABBER
)
1218 cap
->device_caps
|= V4L2_CAP_VIDEO_CAPTURE
;
1220 cap
->device_caps
|= V4L2_CAP_VBI_CAPTURE
;
1221 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
|
1222 V4L2_CAP_VBI_CAPTURE
| V4L2_CAP_VIDEO_CAPTURE
;
1226 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1227 struct v4l2_fmtdesc
*f
)
1232 dprintk(1, "%s called\n", __func__
);
1234 f
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1235 strcpy(f
->description
, "Packed YUV2");
1238 f
->pixelformat
= V4L2_PIX_FMT_UYVY
;
1243 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
1244 struct v4l2_format
*f
)
1246 struct au0828_dev
*dev
= video_drvdata(file
);
1248 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1249 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1251 f
->fmt
.pix
.width
= dev
->width
;
1252 f
->fmt
.pix
.height
= dev
->height
;
1253 f
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_UYVY
;
1254 f
->fmt
.pix
.bytesperline
= dev
->bytesperline
;
1255 f
->fmt
.pix
.sizeimage
= dev
->frame_size
;
1256 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
; /* NTSC/PAL */
1257 f
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1258 f
->fmt
.pix
.priv
= 0;
1262 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
1263 struct v4l2_format
*f
)
1265 struct au0828_dev
*dev
= video_drvdata(file
);
1267 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1268 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1270 return au0828_set_format(dev
, VIDIOC_TRY_FMT
, f
);
1273 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
1274 struct v4l2_format
*f
)
1276 struct au0828_dev
*dev
= video_drvdata(file
);
1279 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1280 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1282 rc
= check_dev(dev
);
1286 if (vb2_is_busy(&dev
->vb_vidq
)) {
1287 pr_info("%s queue busy\n", __func__
);
1292 rc
= au0828_set_format(dev
, VIDIOC_S_FMT
, f
);
1297 static int vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id norm
)
1299 struct au0828_dev
*dev
= video_drvdata(file
);
1301 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1302 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1304 if (norm
== dev
->std
)
1307 if (dev
->streaming_users
> 0)
1312 au0828_init_tuner(dev
);
1314 i2c_gate_ctrl(dev
, 1);
1317 * FIXME: when we support something other than 60Hz standards,
1318 * we are going to have to make the au0828 bridge adjust the size
1319 * of its capture buffer, which is currently hardcoded at 720x480
1322 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_std
, norm
);
1324 i2c_gate_ctrl(dev
, 0);
1329 static int vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*norm
)
1331 struct au0828_dev
*dev
= video_drvdata(file
);
1333 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1334 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1340 static int vidioc_enum_input(struct file
*file
, void *priv
,
1341 struct v4l2_input
*input
)
1343 struct au0828_dev
*dev
= video_drvdata(file
);
1346 static const char *inames
[] = {
1347 [AU0828_VMUX_UNDEFINED
] = "Undefined",
1348 [AU0828_VMUX_COMPOSITE
] = "Composite",
1349 [AU0828_VMUX_SVIDEO
] = "S-Video",
1350 [AU0828_VMUX_CABLE
] = "Cable TV",
1351 [AU0828_VMUX_TELEVISION
] = "Television",
1352 [AU0828_VMUX_DVB
] = "DVB",
1355 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1356 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1360 if (tmp
>= AU0828_MAX_INPUT
)
1362 if (AUVI_INPUT(tmp
).type
== 0)
1366 strcpy(input
->name
, inames
[AUVI_INPUT(tmp
).type
]);
1367 if ((AUVI_INPUT(tmp
).type
== AU0828_VMUX_TELEVISION
) ||
1368 (AUVI_INPUT(tmp
).type
== AU0828_VMUX_CABLE
)) {
1369 input
->type
|= V4L2_INPUT_TYPE_TUNER
;
1370 input
->audioset
= 1;
1372 input
->type
|= V4L2_INPUT_TYPE_CAMERA
;
1373 input
->audioset
= 2;
1376 input
->std
= dev
->vdev
.tvnorms
;
1381 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1383 struct au0828_dev
*dev
= video_drvdata(file
);
1385 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1386 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1388 *i
= dev
->ctrl_input
;
1392 static void au0828_s_input(struct au0828_dev
*dev
, int index
)
1396 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1397 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1399 switch (AUVI_INPUT(index
).type
) {
1400 case AU0828_VMUX_SVIDEO
:
1401 dev
->input_type
= AU0828_VMUX_SVIDEO
;
1402 dev
->ctrl_ainput
= 1;
1404 case AU0828_VMUX_COMPOSITE
:
1405 dev
->input_type
= AU0828_VMUX_COMPOSITE
;
1406 dev
->ctrl_ainput
= 1;
1408 case AU0828_VMUX_TELEVISION
:
1409 dev
->input_type
= AU0828_VMUX_TELEVISION
;
1410 dev
->ctrl_ainput
= 0;
1413 dprintk(1, "unknown input type set [%d]\n",
1414 AUVI_INPUT(index
).type
);
1418 dev
->ctrl_input
= index
;
1420 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_routing
,
1421 AUVI_INPUT(index
).vmux
, 0, 0);
1423 for (i
= 0; i
< AU0828_MAX_INPUT
; i
++) {
1425 if (AUVI_INPUT(i
).audio_setup
== NULL
)
1433 (AUVI_INPUT(i
).audio_setup
)(dev
, enable
);
1435 /* Make sure we leave it turned on if some
1436 other input is routed to this callback */
1437 if ((AUVI_INPUT(i
).audio_setup
) !=
1438 ((AUVI_INPUT(index
).audio_setup
))) {
1439 (AUVI_INPUT(i
).audio_setup
)(dev
, enable
);
1444 v4l2_device_call_all(&dev
->v4l2_dev
, 0, audio
, s_routing
,
1445 AUVI_INPUT(index
).amux
, 0, 0);
1448 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int index
)
1450 struct au0828_dev
*dev
= video_drvdata(file
);
1451 struct video_device
*vfd
= video_devdata(file
);
1453 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__
,
1455 if (index
>= AU0828_MAX_INPUT
)
1457 if (AUVI_INPUT(index
).type
== 0)
1460 if (dev
->ctrl_input
== index
)
1463 au0828_s_input(dev
, index
);
1466 * Input has been changed. Disable the media source
1467 * associated with the old input and enable source
1468 * for the newly set input
1470 v4l_disable_media_source(vfd
);
1471 return v4l_enable_media_source(vfd
);
1474 static int vidioc_enumaudio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
1479 dprintk(1, "%s called\n", __func__
);
1482 strcpy(a
->name
, "Television");
1484 strcpy(a
->name
, "Line in");
1486 a
->capability
= V4L2_AUDCAP_STEREO
;
1490 static int vidioc_g_audio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
1492 struct au0828_dev
*dev
= video_drvdata(file
);
1494 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1495 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1497 a
->index
= dev
->ctrl_ainput
;
1499 strcpy(a
->name
, "Television");
1501 strcpy(a
->name
, "Line in");
1503 a
->capability
= V4L2_AUDCAP_STEREO
;
1507 static int vidioc_s_audio(struct file
*file
, void *priv
, const struct v4l2_audio
*a
)
1509 struct au0828_dev
*dev
= video_drvdata(file
);
1511 if (a
->index
!= dev
->ctrl_ainput
)
1514 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1515 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1519 static int vidioc_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*t
)
1521 struct au0828_dev
*dev
= video_drvdata(file
);
1522 struct video_device
*vfd
= video_devdata(file
);
1528 ret
= v4l_enable_media_source(vfd
);
1532 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1533 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1535 strcpy(t
->name
, "Auvitek tuner");
1537 au0828_init_tuner(dev
);
1538 i2c_gate_ctrl(dev
, 1);
1539 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_tuner
, t
);
1540 i2c_gate_ctrl(dev
, 0);
1544 static int vidioc_s_tuner(struct file
*file
, void *priv
,
1545 const struct v4l2_tuner
*t
)
1547 struct au0828_dev
*dev
= video_drvdata(file
);
1552 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1553 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1555 au0828_init_tuner(dev
);
1556 i2c_gate_ctrl(dev
, 1);
1557 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_tuner
, t
);
1558 i2c_gate_ctrl(dev
, 0);
1560 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t
->signal
,
1567 static int vidioc_g_frequency(struct file
*file
, void *priv
,
1568 struct v4l2_frequency
*freq
)
1570 struct au0828_dev
*dev
= video_drvdata(file
);
1572 if (freq
->tuner
!= 0)
1574 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1575 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1576 freq
->frequency
= dev
->ctrl_freq
;
1580 static int vidioc_s_frequency(struct file
*file
, void *priv
,
1581 const struct v4l2_frequency
*freq
)
1583 struct au0828_dev
*dev
= video_drvdata(file
);
1584 struct v4l2_frequency new_freq
= *freq
;
1586 if (freq
->tuner
!= 0)
1589 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1590 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1592 au0828_init_tuner(dev
);
1593 i2c_gate_ctrl(dev
, 1);
1595 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, freq
);
1596 /* Get the actual set (and possibly clamped) frequency */
1597 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_frequency
, &new_freq
);
1598 dev
->ctrl_freq
= new_freq
.frequency
;
1600 i2c_gate_ctrl(dev
, 0);
1602 au0828_analog_stream_reset(dev
);
1608 /* RAW VBI ioctls */
1610 static int vidioc_g_fmt_vbi_cap(struct file
*file
, void *priv
,
1611 struct v4l2_format
*format
)
1613 struct au0828_dev
*dev
= video_drvdata(file
);
1615 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1616 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1618 format
->fmt
.vbi
.samples_per_line
= dev
->vbi_width
;
1619 format
->fmt
.vbi
.sample_format
= V4L2_PIX_FMT_GREY
;
1620 format
->fmt
.vbi
.offset
= 0;
1621 format
->fmt
.vbi
.flags
= 0;
1622 format
->fmt
.vbi
.sampling_rate
= 6750000 * 4 / 2;
1624 format
->fmt
.vbi
.count
[0] = dev
->vbi_height
;
1625 format
->fmt
.vbi
.count
[1] = dev
->vbi_height
;
1626 format
->fmt
.vbi
.start
[0] = 21;
1627 format
->fmt
.vbi
.start
[1] = 284;
1628 memset(format
->fmt
.vbi
.reserved
, 0, sizeof(format
->fmt
.vbi
.reserved
));
1633 static int vidioc_cropcap(struct file
*file
, void *priv
,
1634 struct v4l2_cropcap
*cc
)
1636 struct au0828_dev
*dev
= video_drvdata(file
);
1638 if (cc
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1641 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1642 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1644 cc
->bounds
.left
= 0;
1646 cc
->bounds
.width
= dev
->width
;
1647 cc
->bounds
.height
= dev
->height
;
1649 cc
->defrect
= cc
->bounds
;
1651 cc
->pixelaspect
.numerator
= 54;
1652 cc
->pixelaspect
.denominator
= 59;
1657 #ifdef CONFIG_VIDEO_ADV_DEBUG
1658 static int vidioc_g_register(struct file
*file
, void *priv
,
1659 struct v4l2_dbg_register
*reg
)
1661 struct au0828_dev
*dev
= video_drvdata(file
);
1663 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1664 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1666 reg
->val
= au0828_read(dev
, reg
->reg
);
1671 static int vidioc_s_register(struct file
*file
, void *priv
,
1672 const struct v4l2_dbg_register
*reg
)
1674 struct au0828_dev
*dev
= video_drvdata(file
);
1676 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__
,
1677 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1679 return au0828_writereg(dev
, reg
->reg
, reg
->val
);
1683 static int vidioc_log_status(struct file
*file
, void *fh
)
1685 struct video_device
*vdev
= video_devdata(file
);
1687 dprintk(1, "%s called\n", __func__
);
1689 v4l2_ctrl_log_status(file
, fh
);
1690 v4l2_device_call_all(vdev
->v4l2_dev
, 0, core
, log_status
);
1694 void au0828_v4l2_suspend(struct au0828_dev
*dev
)
1699 pr_info("stopping V4L2\n");
1701 if (dev
->stream_state
== STREAM_ON
) {
1702 pr_info("stopping V4L2 active URBs\n");
1703 au0828_analog_stream_disable(dev
);
1705 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
1706 urb
= dev
->isoc_ctl
.urb
[i
];
1708 if (!irqs_disabled())
1711 usb_unlink_urb(urb
);
1716 if (dev
->vid_timeout_running
)
1717 del_timer_sync(&dev
->vid_timeout
);
1718 if (dev
->vbi_timeout_running
)
1719 del_timer_sync(&dev
->vbi_timeout
);
1722 void au0828_v4l2_resume(struct au0828_dev
*dev
)
1726 pr_info("restarting V4L2\n");
1728 if (dev
->stream_state
== STREAM_ON
) {
1729 au0828_stream_interrupt(dev
);
1730 au0828_init_tuner(dev
);
1733 if (dev
->vid_timeout_running
)
1734 mod_timer(&dev
->vid_timeout
, jiffies
+ (HZ
/ 10));
1735 if (dev
->vbi_timeout_running
)
1736 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
1738 /* If we were doing ac97 instead of i2s, it would go here...*/
1739 au0828_i2s_init(dev
);
1741 au0828_analog_stream_enable(dev
);
1743 if (!(dev
->stream_state
== STREAM_ON
)) {
1744 au0828_analog_stream_reset(dev
);
1746 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
1747 rc
= usb_submit_urb(dev
->isoc_ctl
.urb
[i
], GFP_ATOMIC
);
1749 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
1751 au0828_uninit_isoc(dev
);
1757 static struct v4l2_file_operations au0828_v4l_fops
= {
1758 .owner
= THIS_MODULE
,
1759 .open
= au0828_v4l2_open
,
1760 .release
= au0828_v4l2_close
,
1761 .read
= vb2_fop_read
,
1762 .poll
= vb2_fop_poll
,
1763 .mmap
= vb2_fop_mmap
,
1764 .unlocked_ioctl
= video_ioctl2
,
1767 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
1768 .vidioc_querycap
= vidioc_querycap
,
1769 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1770 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1771 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1772 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1773 .vidioc_g_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1774 .vidioc_try_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1775 .vidioc_s_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1776 .vidioc_enumaudio
= vidioc_enumaudio
,
1777 .vidioc_g_audio
= vidioc_g_audio
,
1778 .vidioc_s_audio
= vidioc_s_audio
,
1779 .vidioc_cropcap
= vidioc_cropcap
,
1781 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1782 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
1783 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
1784 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1785 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1786 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1787 .vidioc_expbuf
= vb2_ioctl_expbuf
,
1789 .vidioc_s_std
= vidioc_s_std
,
1790 .vidioc_g_std
= vidioc_g_std
,
1791 .vidioc_enum_input
= vidioc_enum_input
,
1792 .vidioc_g_input
= vidioc_g_input
,
1793 .vidioc_s_input
= vidioc_s_input
,
1795 .vidioc_streamon
= vb2_ioctl_streamon
,
1796 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1798 .vidioc_g_tuner
= vidioc_g_tuner
,
1799 .vidioc_s_tuner
= vidioc_s_tuner
,
1800 .vidioc_g_frequency
= vidioc_g_frequency
,
1801 .vidioc_s_frequency
= vidioc_s_frequency
,
1802 #ifdef CONFIG_VIDEO_ADV_DEBUG
1803 .vidioc_g_register
= vidioc_g_register
,
1804 .vidioc_s_register
= vidioc_s_register
,
1806 .vidioc_log_status
= vidioc_log_status
,
1807 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1808 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1811 static const struct video_device au0828_video_template
= {
1812 .fops
= &au0828_v4l_fops
,
1813 .release
= video_device_release_empty
,
1814 .ioctl_ops
= &video_ioctl_ops
,
1815 .tvnorms
= V4L2_STD_NTSC_M
| V4L2_STD_PAL_M
,
1818 static int au0828_vb2_setup(struct au0828_dev
*dev
)
1821 struct vb2_queue
*q
;
1823 /* Setup Videobuf2 for Video capture */
1825 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1826 q
->io_modes
= VB2_READ
| VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
1827 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1829 q
->buf_struct_size
= sizeof(struct au0828_buffer
);
1830 q
->ops
= &au0828_video_qops
;
1831 q
->mem_ops
= &vb2_vmalloc_memops
;
1833 rc
= vb2_queue_init(q
);
1837 /* Setup Videobuf2 for VBI capture */
1839 q
->type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
1840 q
->io_modes
= VB2_READ
| VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
1841 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1843 q
->buf_struct_size
= sizeof(struct au0828_buffer
);
1844 q
->ops
= &au0828_vbi_qops
;
1845 q
->mem_ops
= &vb2_vmalloc_memops
;
1847 rc
= vb2_queue_init(q
);
1854 static void au0828_analog_create_entities(struct au0828_dev
*dev
)
1856 #if defined(CONFIG_MEDIA_CONTROLLER)
1857 static const char * const inames
[] = {
1858 [AU0828_VMUX_COMPOSITE
] = "Composite",
1859 [AU0828_VMUX_SVIDEO
] = "S-Video",
1860 [AU0828_VMUX_CABLE
] = "Cable TV",
1861 [AU0828_VMUX_TELEVISION
] = "Television",
1862 [AU0828_VMUX_DVB
] = "DVB",
1866 /* Initialize Video and VBI pads */
1867 dev
->video_pad
.flags
= MEDIA_PAD_FL_SINK
;
1868 ret
= media_entity_pads_init(&dev
->vdev
.entity
, 1, &dev
->video_pad
);
1870 pr_err("failed to initialize video media entity!\n");
1872 dev
->vbi_pad
.flags
= MEDIA_PAD_FL_SINK
;
1873 ret
= media_entity_pads_init(&dev
->vbi_dev
.entity
, 1, &dev
->vbi_pad
);
1875 pr_err("failed to initialize vbi media entity!\n");
1877 /* Create entities for each input connector */
1878 for (i
= 0; i
< AU0828_MAX_INPUT
; i
++) {
1879 struct media_entity
*ent
= &dev
->input_ent
[i
];
1881 if (AUVI_INPUT(i
).type
== AU0828_VMUX_UNDEFINED
)
1884 ent
->name
= inames
[AUVI_INPUT(i
).type
];
1885 ent
->flags
= MEDIA_ENT_FL_CONNECTOR
;
1886 dev
->input_pad
[i
].flags
= MEDIA_PAD_FL_SOURCE
;
1888 switch (AUVI_INPUT(i
).type
) {
1889 case AU0828_VMUX_COMPOSITE
:
1890 ent
->function
= MEDIA_ENT_F_CONN_COMPOSITE
;
1892 case AU0828_VMUX_SVIDEO
:
1893 ent
->function
= MEDIA_ENT_F_CONN_SVIDEO
;
1895 case AU0828_VMUX_CABLE
:
1896 case AU0828_VMUX_TELEVISION
:
1897 case AU0828_VMUX_DVB
:
1898 default: /* Just to shut up a warning */
1899 ent
->function
= MEDIA_ENT_F_CONN_RF
;
1903 ret
= media_entity_pads_init(ent
, 1, &dev
->input_pad
[i
]);
1905 pr_err("failed to initialize input pad[%d]!\n", i
);
1907 ret
= media_device_register_entity(dev
->media_dev
, ent
);
1909 pr_err("failed to register input entity %d!\n", i
);
1914 /**************************************************************************/
1916 int au0828_analog_register(struct au0828_dev
*dev
,
1917 struct usb_interface
*interface
)
1919 int retval
= -ENOMEM
;
1920 struct usb_host_interface
*iface_desc
;
1921 struct usb_endpoint_descriptor
*endpoint
;
1924 dprintk(1, "au0828_analog_register called for intf#%d!\n",
1925 interface
->cur_altsetting
->desc
.bInterfaceNumber
);
1928 if (AUVI_INPUT(0).type
== AU0828_VMUX_UNDEFINED
)
1931 /* set au0828 usb interface0 to as5 */
1932 retval
= usb_set_interface(dev
->usbdev
,
1933 interface
->cur_altsetting
->desc
.bInterfaceNumber
, 5);
1935 pr_info("Failure setting usb interface0 to as5\n");
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
)
1945 ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
1946 == USB_ENDPOINT_XFER_ISOC
)) {
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
;
1954 "Found isoc endpoint 0x%02x, max size = %d\n",
1955 dev
->isoc_in_endpointaddr
, dev
->max_pkt_size
);
1958 if (!(dev
->isoc_in_endpointaddr
)) {
1959 pr_info("Could not locate isoc endpoint\n");
1963 init_waitqueue_head(&dev
->open
);
1964 spin_lock_init(&dev
->slock
);
1966 /* init video dma queues */
1967 INIT_LIST_HEAD(&dev
->vidq
.active
);
1968 INIT_LIST_HEAD(&dev
->vbiq
.active
);
1970 setup_timer(&dev
->vid_timeout
, au0828_vid_buffer_timeout
,
1971 (unsigned long)dev
);
1972 setup_timer(&dev
->vbi_timeout
, au0828_vbi_buffer_timeout
,
1973 (unsigned long)dev
);
1975 dev
->width
= NTSC_STD_W
;
1976 dev
->height
= NTSC_STD_H
;
1977 dev
->field_size
= dev
->width
* dev
->height
;
1978 dev
->frame_size
= dev
->field_size
<< 1;
1979 dev
->bytesperline
= dev
->width
<< 1;
1980 dev
->vbi_width
= 720;
1981 dev
->vbi_height
= 1;
1982 dev
->ctrl_ainput
= 0;
1983 dev
->ctrl_freq
= 960;
1984 dev
->std
= V4L2_STD_NTSC_M
;
1985 /* Default input is TV Tuner */
1986 au0828_s_input(dev
, 0);
1988 mutex_init(&dev
->vb_queue_lock
);
1989 mutex_init(&dev
->vb_vbi_queue_lock
);
1991 /* Fill the video capture device struct */
1992 dev
->vdev
= au0828_video_template
;
1993 dev
->vdev
.v4l2_dev
= &dev
->v4l2_dev
;
1994 dev
->vdev
.lock
= &dev
->lock
;
1995 dev
->vdev
.queue
= &dev
->vb_vidq
;
1996 dev
->vdev
.queue
->lock
= &dev
->vb_queue_lock
;
1997 strcpy(dev
->vdev
.name
, "au0828a video");
1999 /* Setup the VBI device */
2000 dev
->vbi_dev
= au0828_video_template
;
2001 dev
->vbi_dev
.v4l2_dev
= &dev
->v4l2_dev
;
2002 dev
->vbi_dev
.lock
= &dev
->lock
;
2003 dev
->vbi_dev
.queue
= &dev
->vb_vbiq
;
2004 dev
->vbi_dev
.queue
->lock
= &dev
->vb_vbi_queue_lock
;
2005 strcpy(dev
->vbi_dev
.name
, "au0828a vbi");
2007 /* Init entities at the Media Controller */
2008 au0828_analog_create_entities(dev
);
2010 /* initialize videobuf2 stuff */
2011 retval
= au0828_vb2_setup(dev
);
2013 dprintk(1, "unable to setup videobuf2 queues (error = %d).\n",
2018 /* Register the v4l2 device */
2019 video_set_drvdata(&dev
->vdev
, dev
);
2020 retval
= video_register_device(&dev
->vdev
, VFL_TYPE_GRABBER
, -1);
2022 dprintk(1, "unable to register video device (error = %d).\n",
2028 /* Register the vbi device */
2029 video_set_drvdata(&dev
->vbi_dev
, dev
);
2030 retval
= video_register_device(&dev
->vbi_dev
, VFL_TYPE_VBI
, -1);
2032 dprintk(1, "unable to register vbi device (error = %d).\n",
2035 goto err_reg_vbi_dev
;
2038 #ifdef CONFIG_MEDIA_CONTROLLER
2039 retval
= v4l2_mc_create_media_graph(dev
->media_dev
);
2041 pr_err("%s() au0282_dev_register failed to create graph\n",
2044 goto err_reg_vbi_dev
;
2048 dprintk(1, "%s completed!\n", __func__
);
2053 video_unregister_device(&dev
->vdev
);
2055 vb2_queue_release(&dev
->vb_vidq
);
2056 vb2_queue_release(&dev
->vb_vbiq
);