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 (dev
->dev_state
& DEV_DISCONNECTED
) {
110 pr_info("v4l2 ioctl: device not present\n");
114 if (dev
->dev_state
& DEV_MISCONFIGURED
) {
115 pr_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",
163 dev
->stream_state
= STREAM_ON
;
167 * Stop and Deallocate URBs
169 static void au0828_uninit_isoc(struct au0828_dev
*dev
)
174 au0828_isocdbg("au0828: called au0828_uninit_isoc\n");
176 dev
->isoc_ctl
.nfields
= -1;
177 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
178 urb
= dev
->isoc_ctl
.urb
[i
];
180 if (!irqs_disabled())
185 if (dev
->isoc_ctl
.transfer_buffer
[i
]) {
186 usb_free_coherent(dev
->usbdev
,
187 urb
->transfer_buffer_length
,
188 dev
->isoc_ctl
.transfer_buffer
[i
],
192 dev
->isoc_ctl
.urb
[i
] = NULL
;
194 dev
->isoc_ctl
.transfer_buffer
[i
] = NULL
;
197 kfree(dev
->isoc_ctl
.urb
);
198 kfree(dev
->isoc_ctl
.transfer_buffer
);
200 dev
->isoc_ctl
.urb
= NULL
;
201 dev
->isoc_ctl
.transfer_buffer
= NULL
;
202 dev
->isoc_ctl
.num_bufs
= 0;
204 dev
->stream_state
= STREAM_OFF
;
208 * Allocate URBs and start IRQ
210 static int au0828_init_isoc(struct au0828_dev
*dev
, int max_packets
,
211 int num_bufs
, int max_pkt_size
,
212 int (*isoc_copy
) (struct au0828_dev
*dev
, struct urb
*urb
))
214 struct au0828_dmaqueue
*dma_q
= &dev
->vidq
;
221 au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
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 /* submit urbs and enables IRQ */
287 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
288 rc
= usb_submit_urb(dev
->isoc_ctl
.urb
[i
], GFP_ATOMIC
);
290 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
292 au0828_uninit_isoc(dev
);
301 * Announces that a buffer were filled and request the next
303 static inline void buffer_filled(struct au0828_dev
*dev
,
304 struct au0828_dmaqueue
*dma_q
,
305 struct au0828_buffer
*buf
)
307 struct vb2_v4l2_buffer
*vb
= &buf
->vb
;
308 struct vb2_queue
*q
= vb
->vb2_buf
.vb2_queue
;
310 /* Advice that buffer was filled */
311 au0828_isocdbg("[%p/%d] wakeup\n", buf
, buf
->top_field
);
313 if (q
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
314 vb
->sequence
= dev
->frame_count
++;
316 vb
->sequence
= dev
->vbi_frame_count
++;
318 vb
->field
= V4L2_FIELD_INTERLACED
;
319 vb
->vb2_buf
.timestamp
= ktime_get_ns();
320 vb2_buffer_done(&vb
->vb2_buf
, VB2_BUF_STATE_DONE
);
324 * Identify the buffer header type and properly handles
326 static void au0828_copy_video(struct au0828_dev
*dev
,
327 struct au0828_dmaqueue
*dma_q
,
328 struct au0828_buffer
*buf
,
330 unsigned char *outp
, unsigned long len
)
332 void *fieldstart
, *startwrite
, *startread
;
333 int linesdone
, currlinedone
, offset
, lencopy
, remain
;
334 int bytesperline
= dev
->width
<< 1; /* Assumes 16-bit depth @@@@ */
339 if (dma_q
->pos
+ len
> buf
->length
)
340 len
= buf
->length
- dma_q
->pos
;
345 /* Interlaces frame */
349 fieldstart
= outp
+ bytesperline
;
351 linesdone
= dma_q
->pos
/ bytesperline
;
352 currlinedone
= dma_q
->pos
% bytesperline
;
353 offset
= linesdone
* bytesperline
* 2 + currlinedone
;
354 startwrite
= fieldstart
+ offset
;
355 lencopy
= bytesperline
- currlinedone
;
356 lencopy
= lencopy
> remain
? remain
: lencopy
;
358 if ((char *)startwrite
+ lencopy
> (char *)outp
+ buf
->length
) {
359 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
360 ((char *)startwrite
+ lencopy
) -
361 ((char *)outp
+ buf
->length
));
362 remain
= (char *)outp
+ buf
->length
- (char *)startwrite
;
367 memcpy(startwrite
, startread
, lencopy
);
372 startwrite
+= lencopy
+ bytesperline
;
373 startread
+= lencopy
;
374 if (bytesperline
> remain
)
377 lencopy
= bytesperline
;
379 if ((char *)startwrite
+ lencopy
> (char *)outp
+
381 au0828_isocdbg("Overflow %zi bytes past buf end (2)\n",
382 ((char *)startwrite
+ lencopy
) -
383 ((char *)outp
+ buf
->length
));
384 lencopy
= remain
= (char *)outp
+ buf
->length
-
390 memcpy(startwrite
, startread
, lencopy
);
396 /* We have enough data to check for greenscreen */
397 if (outp
[0] < 0x60 && outp
[1440] < 0x60)
398 dev
->greenscreen_detected
= 1;
405 * video-buf generic routine to get the next available buffer
407 static inline void get_next_buf(struct au0828_dmaqueue
*dma_q
,
408 struct au0828_buffer
**buf
)
410 struct au0828_dev
*dev
= container_of(dma_q
, struct au0828_dev
, vidq
);
412 if (list_empty(&dma_q
->active
)) {
413 au0828_isocdbg("No active queue to serve\n");
414 dev
->isoc_ctl
.buf
= NULL
;
419 /* Get the next buffer */
420 *buf
= list_entry(dma_q
->active
.next
, struct au0828_buffer
, list
);
421 /* Cleans up buffer - Useful for testing for frame/URB loss */
422 list_del(&(*buf
)->list
);
424 (*buf
)->vb_buf
= (*buf
)->mem
;
425 dev
->isoc_ctl
.buf
= *buf
;
430 static void au0828_copy_vbi(struct au0828_dev
*dev
,
431 struct au0828_dmaqueue
*dma_q
,
432 struct au0828_buffer
*buf
,
434 unsigned char *outp
, unsigned long len
)
436 unsigned char *startwrite
, *startread
;
441 au0828_isocdbg("dev is null\n");
446 au0828_isocdbg("dma_q is null\n");
452 au0828_isocdbg("p is null\n");
456 au0828_isocdbg("outp is null\n");
460 bytesperline
= dev
->vbi_width
;
462 if (dma_q
->pos
+ len
> buf
->length
)
463 len
= buf
->length
- dma_q
->pos
;
466 startwrite
= outp
+ (dma_q
->pos
/ 2);
468 /* Make sure the bottom field populates the second half of the frame */
469 if (buf
->top_field
== 0)
470 startwrite
+= bytesperline
* dev
->vbi_height
;
472 for (i
= 0; i
< len
; i
+= 2)
473 startwrite
[j
++] = startread
[i
+1];
480 * video-buf generic routine to get the next available VBI buffer
482 static inline void vbi_get_next_buf(struct au0828_dmaqueue
*dma_q
,
483 struct au0828_buffer
**buf
)
485 struct au0828_dev
*dev
= container_of(dma_q
, struct au0828_dev
, vbiq
);
487 if (list_empty(&dma_q
->active
)) {
488 au0828_isocdbg("No active queue to serve\n");
489 dev
->isoc_ctl
.vbi_buf
= NULL
;
494 /* Get the next buffer */
495 *buf
= list_entry(dma_q
->active
.next
, struct au0828_buffer
, list
);
496 /* Cleans up buffer - Useful for testing for frame/URB loss */
497 list_del(&(*buf
)->list
);
499 (*buf
)->vb_buf
= (*buf
)->mem
;
500 dev
->isoc_ctl
.vbi_buf
= *buf
;
505 * Controls the isoc copy of each urb packet
507 static inline int au0828_isoc_copy(struct au0828_dev
*dev
, struct urb
*urb
)
509 struct au0828_buffer
*buf
;
510 struct au0828_buffer
*vbi_buf
;
511 struct au0828_dmaqueue
*dma_q
= urb
->context
;
512 struct au0828_dmaqueue
*vbi_dma_q
= &dev
->vbiq
;
513 unsigned char *outp
= NULL
;
514 unsigned char *vbioutp
= NULL
;
515 int i
, len
= 0, rc
= 1;
518 unsigned int vbi_field_size
;
519 unsigned int remain
, lencopy
;
524 if ((dev
->dev_state
& DEV_DISCONNECTED
) ||
525 (dev
->dev_state
& DEV_MISCONFIGURED
))
528 if (urb
->status
< 0) {
529 print_err_status(dev
, -1, urb
->status
);
530 if (urb
->status
== -ENOENT
)
534 buf
= dev
->isoc_ctl
.buf
;
536 outp
= vb2_plane_vaddr(&buf
->vb
.vb2_buf
, 0);
538 vbi_buf
= dev
->isoc_ctl
.vbi_buf
;
540 vbioutp
= vb2_plane_vaddr(&vbi_buf
->vb
.vb2_buf
, 0);
542 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
543 int status
= urb
->iso_frame_desc
[i
].status
;
546 print_err_status(dev
, i
, status
);
547 if (urb
->iso_frame_desc
[i
].status
!= -EPROTO
)
551 if (urb
->iso_frame_desc
[i
].actual_length
<= 0)
554 if (urb
->iso_frame_desc
[i
].actual_length
>
556 au0828_isocdbg("packet bigger than packet size");
560 p
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
562 len
= urb
->iso_frame_desc
[i
].actual_length
- 4;
568 au0828_isocdbg("Video frame %s\n",
569 (fbyte
& 0x40) ? "odd" : "even");
573 buffer_filled(dev
, vbi_dma_q
, vbi_buf
);
574 vbi_get_next_buf(vbi_dma_q
, &vbi_buf
);
578 vbioutp
= vb2_plane_vaddr(
579 &vbi_buf
->vb
.vb2_buf
, 0);
583 buffer_filled(dev
, dma_q
, buf
);
584 get_next_buf(dma_q
, &buf
);
588 outp
= vb2_plane_vaddr(
589 &buf
->vb
.vb2_buf
, 0);
591 /* As long as isoc traffic is arriving, keep
592 resetting the timer */
593 if (dev
->vid_timeout_running
)
594 mod_timer(&dev
->vid_timeout
,
595 jiffies
+ (HZ
/ 10));
596 if (dev
->vbi_timeout_running
)
597 mod_timer(&dev
->vbi_timeout
,
598 jiffies
+ (HZ
/ 10));
608 if (vbi_buf
!= NULL
) {
610 vbi_buf
->top_field
= 1;
612 vbi_buf
->top_field
= 0;
620 vbi_field_size
= dev
->vbi_width
* dev
->vbi_height
* 2;
621 if (dev
->vbi_read
< vbi_field_size
) {
622 remain
= vbi_field_size
- dev
->vbi_read
;
629 au0828_copy_vbi(dev
, vbi_dma_q
, vbi_buf
, p
,
634 dev
->vbi_read
+= lencopy
;
637 if (dev
->vbi_read
>= vbi_field_size
&& buf
!= NULL
)
638 au0828_copy_video(dev
, dma_q
, buf
, p
, outp
, len
);
643 void au0828_usb_v4l2_media_release(struct au0828_dev
*dev
)
645 #ifdef CONFIG_MEDIA_CONTROLLER
648 for (i
= 0; i
< AU0828_MAX_INPUT
; i
++) {
649 if (AUVI_INPUT(i
).type
== AU0828_VMUX_UNDEFINED
)
651 media_device_unregister_entity(&dev
->input_ent
[i
]);
656 static void au0828_usb_v4l2_release(struct v4l2_device
*v4l2_dev
)
658 struct au0828_dev
*dev
=
659 container_of(v4l2_dev
, struct au0828_dev
, v4l2_dev
);
661 v4l2_ctrl_handler_free(&dev
->v4l2_ctrl_hdl
);
662 v4l2_device_unregister(&dev
->v4l2_dev
);
663 au0828_usb_v4l2_media_release(dev
);
664 au0828_usb_release(dev
);
667 int au0828_v4l2_device_register(struct usb_interface
*interface
,
668 struct au0828_dev
*dev
)
672 if (AUVI_INPUT(0).type
== AU0828_VMUX_UNDEFINED
)
675 /* Create the v4l2_device */
676 #ifdef CONFIG_MEDIA_CONTROLLER
677 dev
->v4l2_dev
.mdev
= dev
->media_dev
;
679 retval
= v4l2_device_register(&interface
->dev
, &dev
->v4l2_dev
);
681 pr_err("%s() v4l2_device_register failed\n",
683 mutex_unlock(&dev
->lock
);
688 dev
->v4l2_dev
.release
= au0828_usb_v4l2_release
;
690 /* This control handler will inherit the controls from au8522 */
691 retval
= v4l2_ctrl_handler_init(&dev
->v4l2_ctrl_hdl
, 4);
693 pr_err("%s() v4l2_ctrl_handler_init failed\n",
695 mutex_unlock(&dev
->lock
);
699 dev
->v4l2_dev
.ctrl_handler
= &dev
->v4l2_ctrl_hdl
;
704 static int queue_setup(struct vb2_queue
*vq
,
705 unsigned int *nbuffers
, unsigned int *nplanes
,
706 unsigned int sizes
[], void *alloc_ctxs
[])
708 struct au0828_dev
*dev
= vb2_get_drv_priv(vq
);
709 unsigned long size
= dev
->height
* dev
->bytesperline
;
712 return sizes
[0] < size
? -EINVAL
: 0;
719 buffer_prepare(struct vb2_buffer
*vb
)
721 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
722 struct au0828_buffer
*buf
= container_of(vbuf
,
723 struct au0828_buffer
, vb
);
724 struct au0828_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
726 buf
->length
= dev
->height
* dev
->bytesperline
;
728 if (vb2_plane_size(vb
, 0) < buf
->length
) {
729 pr_err("%s data will not fit into plane (%lu < %lu)\n",
730 __func__
, vb2_plane_size(vb
, 0), buf
->length
);
733 vb2_set_plane_payload(&buf
->vb
.vb2_buf
, 0, buf
->length
);
738 buffer_queue(struct vb2_buffer
*vb
)
740 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
741 struct au0828_buffer
*buf
= container_of(vbuf
,
742 struct au0828_buffer
,
744 struct au0828_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
745 struct au0828_dmaqueue
*vidq
= &dev
->vidq
;
746 unsigned long flags
= 0;
748 buf
->mem
= vb2_plane_vaddr(vb
, 0);
749 buf
->length
= vb2_plane_size(vb
, 0);
751 spin_lock_irqsave(&dev
->slock
, flags
);
752 list_add_tail(&buf
->list
, &vidq
->active
);
753 spin_unlock_irqrestore(&dev
->slock
, flags
);
756 static int au0828_i2s_init(struct au0828_dev
*dev
)
758 /* Enable i2s mode */
759 au0828_writereg(dev
, AU0828_AUDIOCTRL_50C
, 0x01);
764 * Auvitek au0828 analog stream enable
766 static int au0828_analog_stream_enable(struct au0828_dev
*d
)
768 struct usb_interface
*iface
;
771 dprintk(1, "au0828_analog_stream_enable called\n");
773 iface
= usb_ifnum_to_if(d
->usbdev
, 0);
774 if (iface
&& iface
->cur_altsetting
->desc
.bAlternateSetting
!= 5) {
775 dprintk(1, "Changing intf#0 to alt 5\n");
776 /* set au0828 interface0 to AS5 here again */
777 ret
= usb_set_interface(d
->usbdev
, 0, 5);
779 pr_info("Au0828 can't set alt setting to 5!\n");
784 h
= d
->height
/ 2 + 2;
787 au0828_writereg(d
, AU0828_SENSORCTRL_VBI_103
, 0x00);
788 au0828_writereg(d
, 0x106, 0x00);
790 au0828_writereg(d
, 0x110, 0x00);
791 au0828_writereg(d
, 0x111, 0x00);
792 au0828_writereg(d
, 0x114, w
& 0xff);
793 au0828_writereg(d
, 0x115, w
>> 8);
795 au0828_writereg(d
, 0x112, 0x00);
796 au0828_writereg(d
, 0x113, 0x00);
797 au0828_writereg(d
, 0x116, h
& 0xff);
798 au0828_writereg(d
, 0x117, h
>> 8);
799 au0828_writereg(d
, AU0828_SENSORCTRL_100
, 0xb3);
804 static int au0828_analog_stream_disable(struct au0828_dev
*d
)
806 dprintk(1, "au0828_analog_stream_disable called\n");
807 au0828_writereg(d
, AU0828_SENSORCTRL_100
, 0x0);
811 static void au0828_analog_stream_reset(struct au0828_dev
*dev
)
813 dprintk(1, "au0828_analog_stream_reset called\n");
814 au0828_writereg(dev
, AU0828_SENSORCTRL_100
, 0x0);
816 au0828_writereg(dev
, AU0828_SENSORCTRL_100
, 0xb3);
820 * Some operations needs to stop current streaming
822 static int au0828_stream_interrupt(struct au0828_dev
*dev
)
826 dev
->stream_state
= STREAM_INTERRUPT
;
827 if (dev
->dev_state
== DEV_DISCONNECTED
)
830 dev
->dev_state
= DEV_MISCONFIGURED
;
831 dprintk(1, "%s device is misconfigured!\n", __func__
);
837 int au0828_start_analog_streaming(struct vb2_queue
*vq
, unsigned int count
)
839 struct au0828_dev
*dev
= vb2_get_drv_priv(vq
);
842 dprintk(1, "au0828_start_analog_streaming called %d\n",
843 dev
->streaming_users
);
845 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
846 dev
->frame_count
= 0;
848 dev
->vbi_frame_count
= 0;
850 if (dev
->streaming_users
== 0) {
851 /* If we were doing ac97 instead of i2s, it would go here...*/
852 au0828_i2s_init(dev
);
853 rc
= au0828_init_isoc(dev
, AU0828_ISO_PACKETS_PER_URB
,
854 AU0828_MAX_ISO_BUFS
, dev
->max_pkt_size
,
857 pr_info("au0828_init_isoc failed\n");
861 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
862 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
,
864 dev
->vid_timeout_running
= 1;
865 mod_timer(&dev
->vid_timeout
, jiffies
+ (HZ
/ 10));
866 } else if (vq
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
867 dev
->vbi_timeout_running
= 1;
868 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
871 dev
->streaming_users
++;
875 static void au0828_stop_streaming(struct vb2_queue
*vq
)
877 struct au0828_dev
*dev
= vb2_get_drv_priv(vq
);
878 struct au0828_dmaqueue
*vidq
= &dev
->vidq
;
879 unsigned long flags
= 0;
881 dprintk(1, "au0828_stop_streaming called %d\n", dev
->streaming_users
);
883 if (dev
->streaming_users
-- == 1)
884 au0828_uninit_isoc(dev
);
886 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_stream
, 0);
887 dev
->vid_timeout_running
= 0;
888 del_timer_sync(&dev
->vid_timeout
);
890 spin_lock_irqsave(&dev
->slock
, flags
);
891 if (dev
->isoc_ctl
.buf
!= NULL
) {
892 vb2_buffer_done(&dev
->isoc_ctl
.buf
->vb
.vb2_buf
,
893 VB2_BUF_STATE_ERROR
);
894 dev
->isoc_ctl
.buf
= NULL
;
896 while (!list_empty(&vidq
->active
)) {
897 struct au0828_buffer
*buf
;
899 buf
= list_entry(vidq
->active
.next
, struct au0828_buffer
, list
);
900 vb2_buffer_done(&buf
->vb
.vb2_buf
, VB2_BUF_STATE_ERROR
);
901 list_del(&buf
->list
);
903 spin_unlock_irqrestore(&dev
->slock
, flags
);
906 void au0828_stop_vbi_streaming(struct vb2_queue
*vq
)
908 struct au0828_dev
*dev
= vb2_get_drv_priv(vq
);
909 struct au0828_dmaqueue
*vbiq
= &dev
->vbiq
;
910 unsigned long flags
= 0;
912 dprintk(1, "au0828_stop_vbi_streaming called %d\n",
913 dev
->streaming_users
);
915 if (dev
->streaming_users
-- == 1)
916 au0828_uninit_isoc(dev
);
918 spin_lock_irqsave(&dev
->slock
, flags
);
919 if (dev
->isoc_ctl
.vbi_buf
!= NULL
) {
920 vb2_buffer_done(&dev
->isoc_ctl
.vbi_buf
->vb
.vb2_buf
,
921 VB2_BUF_STATE_ERROR
);
922 dev
->isoc_ctl
.vbi_buf
= NULL
;
924 while (!list_empty(&vbiq
->active
)) {
925 struct au0828_buffer
*buf
;
927 buf
= list_entry(vbiq
->active
.next
, struct au0828_buffer
, list
);
928 list_del(&buf
->list
);
929 vb2_buffer_done(&buf
->vb
.vb2_buf
, VB2_BUF_STATE_ERROR
);
931 spin_unlock_irqrestore(&dev
->slock
, flags
);
933 dev
->vbi_timeout_running
= 0;
934 del_timer_sync(&dev
->vbi_timeout
);
937 static struct vb2_ops au0828_video_qops
= {
938 .queue_setup
= queue_setup
,
939 .buf_prepare
= buffer_prepare
,
940 .buf_queue
= buffer_queue
,
941 .start_streaming
= au0828_start_analog_streaming
,
942 .stop_streaming
= au0828_stop_streaming
,
943 .wait_prepare
= vb2_ops_wait_prepare
,
944 .wait_finish
= vb2_ops_wait_finish
,
947 /* ------------------------------------------------------------------
949 ------------------------------------------------------------------*/
951 * au0828_analog_unregister
952 * unregister v4l2 devices
954 int au0828_analog_unregister(struct au0828_dev
*dev
)
956 dprintk(1, "au0828_analog_unregister called\n");
959 if (AUVI_INPUT(0).type
== AU0828_VMUX_UNDEFINED
)
962 mutex_lock(&au0828_sysfs_lock
);
963 video_unregister_device(&dev
->vdev
);
964 video_unregister_device(&dev
->vbi_dev
);
965 mutex_unlock(&au0828_sysfs_lock
);
967 v4l2_device_disconnect(&dev
->v4l2_dev
);
968 v4l2_device_put(&dev
->v4l2_dev
);
973 /* This function ensures that video frames continue to be delivered even if
974 the ITU-656 input isn't receiving any data (thereby preventing applications
975 such as tvtime from hanging) */
976 static void au0828_vid_buffer_timeout(unsigned long data
)
978 struct au0828_dev
*dev
= (struct au0828_dev
*) data
;
979 struct au0828_dmaqueue
*dma_q
= &dev
->vidq
;
980 struct au0828_buffer
*buf
;
981 unsigned char *vid_data
;
982 unsigned long flags
= 0;
984 spin_lock_irqsave(&dev
->slock
, flags
);
986 buf
= dev
->isoc_ctl
.buf
;
988 vid_data
= vb2_plane_vaddr(&buf
->vb
.vb2_buf
, 0);
989 memset(vid_data
, 0x00, buf
->length
); /* Blank green frame */
990 buffer_filled(dev
, dma_q
, buf
);
992 get_next_buf(dma_q
, &buf
);
994 if (dev
->vid_timeout_running
== 1)
995 mod_timer(&dev
->vid_timeout
, jiffies
+ (HZ
/ 10));
997 spin_unlock_irqrestore(&dev
->slock
, flags
);
1000 static void au0828_vbi_buffer_timeout(unsigned long data
)
1002 struct au0828_dev
*dev
= (struct au0828_dev
*) data
;
1003 struct au0828_dmaqueue
*dma_q
= &dev
->vbiq
;
1004 struct au0828_buffer
*buf
;
1005 unsigned char *vbi_data
;
1006 unsigned long flags
= 0;
1008 spin_lock_irqsave(&dev
->slock
, flags
);
1010 buf
= dev
->isoc_ctl
.vbi_buf
;
1012 vbi_data
= vb2_plane_vaddr(&buf
->vb
.vb2_buf
, 0);
1013 memset(vbi_data
, 0x00, buf
->length
);
1014 buffer_filled(dev
, dma_q
, buf
);
1016 vbi_get_next_buf(dma_q
, &buf
);
1018 if (dev
->vbi_timeout_running
== 1)
1019 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
1020 spin_unlock_irqrestore(&dev
->slock
, flags
);
1023 static int au0828_v4l2_open(struct file
*filp
)
1025 struct au0828_dev
*dev
= video_drvdata(filp
);
1029 "%s called std_set %d dev_state %d stream users %d users %d\n",
1030 __func__
, dev
->std_set_in_tuner_core
, dev
->dev_state
,
1031 dev
->streaming_users
, dev
->users
);
1033 if (mutex_lock_interruptible(&dev
->lock
))
1034 return -ERESTARTSYS
;
1036 ret
= v4l2_fh_open(filp
);
1038 au0828_isocdbg("%s: v4l2_fh_open() returned error %d\n",
1040 mutex_unlock(&dev
->lock
);
1044 if (dev
->users
== 0) {
1045 au0828_analog_stream_enable(dev
);
1046 au0828_analog_stream_reset(dev
);
1047 dev
->stream_state
= STREAM_OFF
;
1048 dev
->dev_state
|= DEV_INITIALIZED
;
1051 mutex_unlock(&dev
->lock
);
1055 static int au0828_v4l2_close(struct file
*filp
)
1058 struct au0828_dev
*dev
= video_drvdata(filp
);
1059 struct video_device
*vdev
= video_devdata(filp
);
1062 "%s called std_set %d dev_state %d stream users %d users %d\n",
1063 __func__
, dev
->std_set_in_tuner_core
, dev
->dev_state
,
1064 dev
->streaming_users
, dev
->users
);
1066 mutex_lock(&dev
->lock
);
1067 if (vdev
->vfl_type
== VFL_TYPE_GRABBER
&& dev
->vid_timeout_running
) {
1068 /* Cancel timeout thread in case they didn't call streamoff */
1069 dev
->vid_timeout_running
= 0;
1070 del_timer_sync(&dev
->vid_timeout
);
1071 } else if (vdev
->vfl_type
== VFL_TYPE_VBI
&&
1072 dev
->vbi_timeout_running
) {
1073 /* Cancel timeout thread in case they didn't call streamoff */
1074 dev
->vbi_timeout_running
= 0;
1075 del_timer_sync(&dev
->vbi_timeout
);
1078 if (dev
->dev_state
== DEV_DISCONNECTED
)
1081 if (dev
->users
== 1) {
1083 * Avoid putting tuner in sleep if DVB or ALSA are
1086 * On most USB devices like au0828 the tuner can
1087 * be safely put in sleep stare here if ALSA isn't
1088 * streaming. Exceptions are some very old USB tuner
1089 * models such as em28xx-based WinTV USB2 which have
1090 * a separate audio output jack. The devices that have
1091 * a separate audio output jack have analog tuners,
1092 * like Philips FM1236. Those devices are always on,
1093 * so the s_power callback are silently ignored.
1094 * So, the current logic here does the following:
1095 * Disable (put tuner to sleep) when
1096 * - ALSA and DVB aren't not streaming;
1097 * - the last V4L2 file handler is closed.
1101 * Additionally, this logic could be improved to
1102 * disable the media source if the above conditions
1103 * are met and if the device:
1104 * - doesn't have a separate audio out plug (or
1105 * - doesn't use a silicon tuner like xc2028/3028/4000/5000).
1107 * Once this additional logic is in place, a callback
1108 * is needed to enable the media source and power on
1109 * the tuner, for radio to work.
1111 ret
= v4l_enable_media_source(vdev
);
1113 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
,
1115 dev
->std_set_in_tuner_core
= 0;
1117 /* When close the device, set the usb intf0 into alt0 to free
1119 ret
= usb_set_interface(dev
->usbdev
, 0, 0);
1121 pr_info("Au0828 can't set alternate to 0!\n");
1124 _vb2_fop_release(filp
, NULL
);
1126 mutex_unlock(&dev
->lock
);
1130 /* Must be called with dev->lock held */
1131 static void au0828_init_tuner(struct au0828_dev
*dev
)
1133 struct v4l2_frequency f
= {
1134 .frequency
= dev
->ctrl_freq
,
1135 .type
= V4L2_TUNER_ANALOG_TV
,
1138 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1139 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1141 if (dev
->std_set_in_tuner_core
)
1143 dev
->std_set_in_tuner_core
= 1;
1144 i2c_gate_ctrl(dev
, 1);
1145 /* If we've never sent the standard in tuner core, do so now.
1146 We don't do this at device probe because we don't want to
1147 incur the cost of a firmware load */
1148 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_std
, dev
->std
);
1149 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, &f
);
1150 i2c_gate_ctrl(dev
, 0);
1153 static int au0828_set_format(struct au0828_dev
*dev
, unsigned int cmd
,
1154 struct v4l2_format
*format
)
1157 int width
= format
->fmt
.pix
.width
;
1158 int height
= format
->fmt
.pix
.height
;
1160 /* If they are demanding a format other than the one we support,
1161 bail out (tvtime asks for UYVY and then retries with YUYV) */
1162 if (format
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_UYVY
)
1165 /* format->fmt.pix.width only support 720 and height 480 */
1171 format
->fmt
.pix
.width
= width
;
1172 format
->fmt
.pix
.height
= height
;
1173 format
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_UYVY
;
1174 format
->fmt
.pix
.bytesperline
= width
* 2;
1175 format
->fmt
.pix
.sizeimage
= width
* height
* 2;
1176 format
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1177 format
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1178 format
->fmt
.pix
.priv
= 0;
1180 if (cmd
== VIDIOC_TRY_FMT
)
1183 /* maybe set new image format, driver current only support 720*480 */
1185 dev
->height
= height
;
1186 dev
->frame_size
= width
* height
* 2;
1187 dev
->field_size
= width
* height
;
1188 dev
->bytesperline
= width
* 2;
1190 if (dev
->stream_state
== STREAM_ON
) {
1191 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
1192 ret
= au0828_stream_interrupt(dev
);
1194 dprintk(1, "error interrupting video stream!\n");
1199 au0828_analog_stream_enable(dev
);
1204 static int vidioc_querycap(struct file
*file
, void *priv
,
1205 struct v4l2_capability
*cap
)
1207 struct video_device
*vdev
= video_devdata(file
);
1208 struct au0828_dev
*dev
= video_drvdata(file
);
1210 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1211 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1213 strlcpy(cap
->driver
, "au0828", sizeof(cap
->driver
));
1214 strlcpy(cap
->card
, dev
->board
.name
, sizeof(cap
->card
));
1215 usb_make_path(dev
->usbdev
, cap
->bus_info
, sizeof(cap
->bus_info
));
1217 /* set the device capabilities */
1218 cap
->device_caps
= V4L2_CAP_AUDIO
|
1219 V4L2_CAP_READWRITE
|
1220 V4L2_CAP_STREAMING
|
1222 if (vdev
->vfl_type
== VFL_TYPE_GRABBER
)
1223 cap
->device_caps
|= V4L2_CAP_VIDEO_CAPTURE
;
1225 cap
->device_caps
|= V4L2_CAP_VBI_CAPTURE
;
1226 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
|
1227 V4L2_CAP_VBI_CAPTURE
| V4L2_CAP_VIDEO_CAPTURE
;
1231 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1232 struct v4l2_fmtdesc
*f
)
1237 dprintk(1, "%s called\n", __func__
);
1239 f
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1240 strcpy(f
->description
, "Packed YUV2");
1243 f
->pixelformat
= V4L2_PIX_FMT_UYVY
;
1248 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
1249 struct v4l2_format
*f
)
1251 struct au0828_dev
*dev
= video_drvdata(file
);
1253 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1254 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1256 f
->fmt
.pix
.width
= dev
->width
;
1257 f
->fmt
.pix
.height
= dev
->height
;
1258 f
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_UYVY
;
1259 f
->fmt
.pix
.bytesperline
= dev
->bytesperline
;
1260 f
->fmt
.pix
.sizeimage
= dev
->frame_size
;
1261 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
; /* NTSC/PAL */
1262 f
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1263 f
->fmt
.pix
.priv
= 0;
1267 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
1268 struct v4l2_format
*f
)
1270 struct au0828_dev
*dev
= video_drvdata(file
);
1272 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1273 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1275 return au0828_set_format(dev
, VIDIOC_TRY_FMT
, f
);
1278 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
1279 struct v4l2_format
*f
)
1281 struct au0828_dev
*dev
= video_drvdata(file
);
1284 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1285 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1287 rc
= check_dev(dev
);
1291 if (vb2_is_busy(&dev
->vb_vidq
)) {
1292 pr_info("%s queue busy\n", __func__
);
1297 rc
= au0828_set_format(dev
, VIDIOC_S_FMT
, f
);
1302 static int vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id norm
)
1304 struct au0828_dev
*dev
= video_drvdata(file
);
1306 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1307 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1309 if (norm
== dev
->std
)
1312 if (dev
->streaming_users
> 0)
1317 au0828_init_tuner(dev
);
1319 i2c_gate_ctrl(dev
, 1);
1322 * FIXME: when we support something other than 60Hz standards,
1323 * we are going to have to make the au0828 bridge adjust the size
1324 * of its capture buffer, which is currently hardcoded at 720x480
1327 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_std
, norm
);
1329 i2c_gate_ctrl(dev
, 0);
1334 static int vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*norm
)
1336 struct au0828_dev
*dev
= video_drvdata(file
);
1338 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1339 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1345 static int vidioc_enum_input(struct file
*file
, void *priv
,
1346 struct v4l2_input
*input
)
1348 struct au0828_dev
*dev
= video_drvdata(file
);
1351 static const char *inames
[] = {
1352 [AU0828_VMUX_UNDEFINED
] = "Undefined",
1353 [AU0828_VMUX_COMPOSITE
] = "Composite",
1354 [AU0828_VMUX_SVIDEO
] = "S-Video",
1355 [AU0828_VMUX_CABLE
] = "Cable TV",
1356 [AU0828_VMUX_TELEVISION
] = "Television",
1357 [AU0828_VMUX_DVB
] = "DVB",
1360 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1361 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1365 if (tmp
>= AU0828_MAX_INPUT
)
1367 if (AUVI_INPUT(tmp
).type
== 0)
1371 strcpy(input
->name
, inames
[AUVI_INPUT(tmp
).type
]);
1372 if ((AUVI_INPUT(tmp
).type
== AU0828_VMUX_TELEVISION
) ||
1373 (AUVI_INPUT(tmp
).type
== AU0828_VMUX_CABLE
)) {
1374 input
->type
|= V4L2_INPUT_TYPE_TUNER
;
1375 input
->audioset
= 1;
1377 input
->type
|= V4L2_INPUT_TYPE_CAMERA
;
1378 input
->audioset
= 2;
1381 input
->std
= dev
->vdev
.tvnorms
;
1386 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1388 struct au0828_dev
*dev
= video_drvdata(file
);
1390 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1391 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1393 *i
= dev
->ctrl_input
;
1397 static void au0828_s_input(struct au0828_dev
*dev
, int index
)
1401 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1402 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1404 switch (AUVI_INPUT(index
).type
) {
1405 case AU0828_VMUX_SVIDEO
:
1406 dev
->input_type
= AU0828_VMUX_SVIDEO
;
1407 dev
->ctrl_ainput
= 1;
1409 case AU0828_VMUX_COMPOSITE
:
1410 dev
->input_type
= AU0828_VMUX_COMPOSITE
;
1411 dev
->ctrl_ainput
= 1;
1413 case AU0828_VMUX_TELEVISION
:
1414 dev
->input_type
= AU0828_VMUX_TELEVISION
;
1415 dev
->ctrl_ainput
= 0;
1418 dprintk(1, "unknown input type set [%d]\n",
1419 AUVI_INPUT(index
).type
);
1423 dev
->ctrl_input
= index
;
1425 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_routing
,
1426 AUVI_INPUT(index
).vmux
, 0, 0);
1428 for (i
= 0; i
< AU0828_MAX_INPUT
; i
++) {
1430 if (AUVI_INPUT(i
).audio_setup
== NULL
)
1438 (AUVI_INPUT(i
).audio_setup
)(dev
, enable
);
1440 /* Make sure we leave it turned on if some
1441 other input is routed to this callback */
1442 if ((AUVI_INPUT(i
).audio_setup
) !=
1443 ((AUVI_INPUT(index
).audio_setup
))) {
1444 (AUVI_INPUT(i
).audio_setup
)(dev
, enable
);
1449 v4l2_device_call_all(&dev
->v4l2_dev
, 0, audio
, s_routing
,
1450 AUVI_INPUT(index
).amux
, 0, 0);
1453 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int index
)
1455 struct au0828_dev
*dev
= video_drvdata(file
);
1456 struct video_device
*vfd
= video_devdata(file
);
1458 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__
,
1460 if (index
>= AU0828_MAX_INPUT
)
1462 if (AUVI_INPUT(index
).type
== 0)
1465 if (dev
->ctrl_input
== index
)
1468 au0828_s_input(dev
, index
);
1471 * Input has been changed. Disable the media source
1472 * associated with the old input and enable source
1473 * for the newly set input
1475 v4l_disable_media_source(vfd
);
1476 return v4l_enable_media_source(vfd
);
1479 static int vidioc_enumaudio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
1484 dprintk(1, "%s called\n", __func__
);
1487 strcpy(a
->name
, "Television");
1489 strcpy(a
->name
, "Line in");
1491 a
->capability
= V4L2_AUDCAP_STEREO
;
1495 static int vidioc_g_audio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
1497 struct au0828_dev
*dev
= video_drvdata(file
);
1499 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1500 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1502 a
->index
= dev
->ctrl_ainput
;
1504 strcpy(a
->name
, "Television");
1506 strcpy(a
->name
, "Line in");
1508 a
->capability
= V4L2_AUDCAP_STEREO
;
1512 static int vidioc_s_audio(struct file
*file
, void *priv
, const struct v4l2_audio
*a
)
1514 struct au0828_dev
*dev
= video_drvdata(file
);
1516 if (a
->index
!= dev
->ctrl_ainput
)
1519 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1520 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1524 static int vidioc_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*t
)
1526 struct au0828_dev
*dev
= video_drvdata(file
);
1527 struct video_device
*vfd
= video_devdata(file
);
1533 ret
= v4l_enable_media_source(vfd
);
1537 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1538 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1540 strcpy(t
->name
, "Auvitek tuner");
1542 au0828_init_tuner(dev
);
1543 i2c_gate_ctrl(dev
, 1);
1544 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_tuner
, t
);
1545 i2c_gate_ctrl(dev
, 0);
1549 static int vidioc_s_tuner(struct file
*file
, void *priv
,
1550 const struct v4l2_tuner
*t
)
1552 struct au0828_dev
*dev
= video_drvdata(file
);
1557 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1558 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1560 au0828_init_tuner(dev
);
1561 i2c_gate_ctrl(dev
, 1);
1562 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_tuner
, t
);
1563 i2c_gate_ctrl(dev
, 0);
1565 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t
->signal
,
1572 static int vidioc_g_frequency(struct file
*file
, void *priv
,
1573 struct v4l2_frequency
*freq
)
1575 struct au0828_dev
*dev
= video_drvdata(file
);
1577 if (freq
->tuner
!= 0)
1579 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1580 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1581 freq
->frequency
= dev
->ctrl_freq
;
1585 static int vidioc_s_frequency(struct file
*file
, void *priv
,
1586 const struct v4l2_frequency
*freq
)
1588 struct au0828_dev
*dev
= video_drvdata(file
);
1589 struct v4l2_frequency new_freq
= *freq
;
1591 if (freq
->tuner
!= 0)
1594 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1595 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1597 au0828_init_tuner(dev
);
1598 i2c_gate_ctrl(dev
, 1);
1600 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, freq
);
1601 /* Get the actual set (and possibly clamped) frequency */
1602 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_frequency
, &new_freq
);
1603 dev
->ctrl_freq
= new_freq
.frequency
;
1605 i2c_gate_ctrl(dev
, 0);
1607 au0828_analog_stream_reset(dev
);
1613 /* RAW VBI ioctls */
1615 static int vidioc_g_fmt_vbi_cap(struct file
*file
, void *priv
,
1616 struct v4l2_format
*format
)
1618 struct au0828_dev
*dev
= video_drvdata(file
);
1620 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1621 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1623 format
->fmt
.vbi
.samples_per_line
= dev
->vbi_width
;
1624 format
->fmt
.vbi
.sample_format
= V4L2_PIX_FMT_GREY
;
1625 format
->fmt
.vbi
.offset
= 0;
1626 format
->fmt
.vbi
.flags
= 0;
1627 format
->fmt
.vbi
.sampling_rate
= 6750000 * 4 / 2;
1629 format
->fmt
.vbi
.count
[0] = dev
->vbi_height
;
1630 format
->fmt
.vbi
.count
[1] = dev
->vbi_height
;
1631 format
->fmt
.vbi
.start
[0] = 21;
1632 format
->fmt
.vbi
.start
[1] = 284;
1633 memset(format
->fmt
.vbi
.reserved
, 0, sizeof(format
->fmt
.vbi
.reserved
));
1638 static int vidioc_cropcap(struct file
*file
, void *priv
,
1639 struct v4l2_cropcap
*cc
)
1641 struct au0828_dev
*dev
= video_drvdata(file
);
1643 if (cc
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1646 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1647 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1649 cc
->bounds
.left
= 0;
1651 cc
->bounds
.width
= dev
->width
;
1652 cc
->bounds
.height
= dev
->height
;
1654 cc
->defrect
= cc
->bounds
;
1656 cc
->pixelaspect
.numerator
= 54;
1657 cc
->pixelaspect
.denominator
= 59;
1662 #ifdef CONFIG_VIDEO_ADV_DEBUG
1663 static int vidioc_g_register(struct file
*file
, void *priv
,
1664 struct v4l2_dbg_register
*reg
)
1666 struct au0828_dev
*dev
= video_drvdata(file
);
1668 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1669 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1671 reg
->val
= au0828_read(dev
, reg
->reg
);
1676 static int vidioc_s_register(struct file
*file
, void *priv
,
1677 const struct v4l2_dbg_register
*reg
)
1679 struct au0828_dev
*dev
= video_drvdata(file
);
1681 dprintk(1, "%s called std_set %d dev_state %d\n", __func__
,
1682 dev
->std_set_in_tuner_core
, dev
->dev_state
);
1684 return au0828_writereg(dev
, reg
->reg
, reg
->val
);
1688 static int vidioc_log_status(struct file
*file
, void *fh
)
1690 struct video_device
*vdev
= video_devdata(file
);
1692 dprintk(1, "%s called\n", __func__
);
1694 v4l2_ctrl_log_status(file
, fh
);
1695 v4l2_device_call_all(vdev
->v4l2_dev
, 0, core
, log_status
);
1699 void au0828_v4l2_suspend(struct au0828_dev
*dev
)
1704 pr_info("stopping V4L2\n");
1706 if (dev
->stream_state
== STREAM_ON
) {
1707 pr_info("stopping V4L2 active URBs\n");
1708 au0828_analog_stream_disable(dev
);
1710 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
1711 urb
= dev
->isoc_ctl
.urb
[i
];
1713 if (!irqs_disabled())
1716 usb_unlink_urb(urb
);
1721 if (dev
->vid_timeout_running
)
1722 del_timer_sync(&dev
->vid_timeout
);
1723 if (dev
->vbi_timeout_running
)
1724 del_timer_sync(&dev
->vbi_timeout
);
1727 void au0828_v4l2_resume(struct au0828_dev
*dev
)
1731 pr_info("restarting V4L2\n");
1733 if (dev
->stream_state
== STREAM_ON
) {
1734 au0828_stream_interrupt(dev
);
1735 au0828_init_tuner(dev
);
1738 if (dev
->vid_timeout_running
)
1739 mod_timer(&dev
->vid_timeout
, jiffies
+ (HZ
/ 10));
1740 if (dev
->vbi_timeout_running
)
1741 mod_timer(&dev
->vbi_timeout
, jiffies
+ (HZ
/ 10));
1743 /* If we were doing ac97 instead of i2s, it would go here...*/
1744 au0828_i2s_init(dev
);
1746 au0828_analog_stream_enable(dev
);
1748 if (!(dev
->stream_state
== STREAM_ON
)) {
1749 au0828_analog_stream_reset(dev
);
1751 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
1752 rc
= usb_submit_urb(dev
->isoc_ctl
.urb
[i
], GFP_ATOMIC
);
1754 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
1756 au0828_uninit_isoc(dev
);
1762 static struct v4l2_file_operations au0828_v4l_fops
= {
1763 .owner
= THIS_MODULE
,
1764 .open
= au0828_v4l2_open
,
1765 .release
= au0828_v4l2_close
,
1766 .read
= vb2_fop_read
,
1767 .poll
= vb2_fop_poll
,
1768 .mmap
= vb2_fop_mmap
,
1769 .unlocked_ioctl
= video_ioctl2
,
1772 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
1773 .vidioc_querycap
= vidioc_querycap
,
1774 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1775 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1776 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1777 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1778 .vidioc_g_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1779 .vidioc_try_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1780 .vidioc_s_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1781 .vidioc_enumaudio
= vidioc_enumaudio
,
1782 .vidioc_g_audio
= vidioc_g_audio
,
1783 .vidioc_s_audio
= vidioc_s_audio
,
1784 .vidioc_cropcap
= vidioc_cropcap
,
1786 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1787 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
1788 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
1789 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1790 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1791 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1792 .vidioc_expbuf
= vb2_ioctl_expbuf
,
1794 .vidioc_s_std
= vidioc_s_std
,
1795 .vidioc_g_std
= vidioc_g_std
,
1796 .vidioc_enum_input
= vidioc_enum_input
,
1797 .vidioc_g_input
= vidioc_g_input
,
1798 .vidioc_s_input
= vidioc_s_input
,
1800 .vidioc_streamon
= vb2_ioctl_streamon
,
1801 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1803 .vidioc_g_tuner
= vidioc_g_tuner
,
1804 .vidioc_s_tuner
= vidioc_s_tuner
,
1805 .vidioc_g_frequency
= vidioc_g_frequency
,
1806 .vidioc_s_frequency
= vidioc_s_frequency
,
1807 #ifdef CONFIG_VIDEO_ADV_DEBUG
1808 .vidioc_g_register
= vidioc_g_register
,
1809 .vidioc_s_register
= vidioc_s_register
,
1811 .vidioc_log_status
= vidioc_log_status
,
1812 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1813 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1816 static const struct video_device au0828_video_template
= {
1817 .fops
= &au0828_v4l_fops
,
1818 .release
= video_device_release_empty
,
1819 .ioctl_ops
= &video_ioctl_ops
,
1820 .tvnorms
= V4L2_STD_NTSC_M
| V4L2_STD_PAL_M
,
1823 static int au0828_vb2_setup(struct au0828_dev
*dev
)
1826 struct vb2_queue
*q
;
1828 /* Setup Videobuf2 for Video capture */
1830 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1831 q
->io_modes
= VB2_READ
| VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
1832 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1834 q
->buf_struct_size
= sizeof(struct au0828_buffer
);
1835 q
->ops
= &au0828_video_qops
;
1836 q
->mem_ops
= &vb2_vmalloc_memops
;
1838 rc
= vb2_queue_init(q
);
1842 /* Setup Videobuf2 for VBI capture */
1844 q
->type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
1845 q
->io_modes
= VB2_READ
| VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
1846 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1848 q
->buf_struct_size
= sizeof(struct au0828_buffer
);
1849 q
->ops
= &au0828_vbi_qops
;
1850 q
->mem_ops
= &vb2_vmalloc_memops
;
1852 rc
= vb2_queue_init(q
);
1859 static void au0828_analog_create_entities(struct au0828_dev
*dev
)
1861 #if defined(CONFIG_MEDIA_CONTROLLER)
1862 static const char * const inames
[] = {
1863 [AU0828_VMUX_COMPOSITE
] = "Composite",
1864 [AU0828_VMUX_SVIDEO
] = "S-Video",
1865 [AU0828_VMUX_CABLE
] = "Cable TV",
1866 [AU0828_VMUX_TELEVISION
] = "Television",
1867 [AU0828_VMUX_DVB
] = "DVB",
1871 /* Initialize Video and VBI pads */
1872 dev
->video_pad
.flags
= MEDIA_PAD_FL_SINK
;
1873 ret
= media_entity_pads_init(&dev
->vdev
.entity
, 1, &dev
->video_pad
);
1875 pr_err("failed to initialize video media entity!\n");
1877 dev
->vbi_pad
.flags
= MEDIA_PAD_FL_SINK
;
1878 ret
= media_entity_pads_init(&dev
->vbi_dev
.entity
, 1, &dev
->vbi_pad
);
1880 pr_err("failed to initialize vbi media entity!\n");
1882 /* Create entities for each input connector */
1883 for (i
= 0; i
< AU0828_MAX_INPUT
; i
++) {
1884 struct media_entity
*ent
= &dev
->input_ent
[i
];
1886 if (AUVI_INPUT(i
).type
== AU0828_VMUX_UNDEFINED
)
1889 ent
->name
= inames
[AUVI_INPUT(i
).type
];
1890 ent
->flags
= MEDIA_ENT_FL_CONNECTOR
;
1891 dev
->input_pad
[i
].flags
= MEDIA_PAD_FL_SOURCE
;
1893 switch (AUVI_INPUT(i
).type
) {
1894 case AU0828_VMUX_COMPOSITE
:
1895 ent
->function
= MEDIA_ENT_F_CONN_COMPOSITE
;
1897 case AU0828_VMUX_SVIDEO
:
1898 ent
->function
= MEDIA_ENT_F_CONN_SVIDEO
;
1900 case AU0828_VMUX_CABLE
:
1901 case AU0828_VMUX_TELEVISION
:
1902 case AU0828_VMUX_DVB
:
1903 default: /* Just to shut up a warning */
1904 ent
->function
= MEDIA_ENT_F_CONN_RF
;
1908 ret
= media_entity_pads_init(ent
, 1, &dev
->input_pad
[i
]);
1910 pr_err("failed to initialize input pad[%d]!\n", i
);
1912 ret
= media_device_register_entity(dev
->media_dev
, ent
);
1914 pr_err("failed to register input entity %d!\n", i
);
1919 /**************************************************************************/
1921 int au0828_analog_register(struct au0828_dev
*dev
,
1922 struct usb_interface
*interface
)
1924 int retval
= -ENOMEM
;
1925 struct usb_host_interface
*iface_desc
;
1926 struct usb_endpoint_descriptor
*endpoint
;
1929 dprintk(1, "au0828_analog_register called for intf#%d!\n",
1930 interface
->cur_altsetting
->desc
.bInterfaceNumber
);
1933 if (AUVI_INPUT(0).type
== AU0828_VMUX_UNDEFINED
)
1936 /* set au0828 usb interface0 to as5 */
1937 retval
= usb_set_interface(dev
->usbdev
,
1938 interface
->cur_altsetting
->desc
.bInterfaceNumber
, 5);
1940 pr_info("Failure setting usb interface0 to as5\n");
1944 /* Figure out which endpoint has the isoc interface */
1945 iface_desc
= interface
->cur_altsetting
;
1946 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; i
++) {
1947 endpoint
= &iface_desc
->endpoint
[i
].desc
;
1948 if (((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
1950 ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
1951 == USB_ENDPOINT_XFER_ISOC
)) {
1953 /* we find our isoc in endpoint */
1954 u16 tmp
= le16_to_cpu(endpoint
->wMaxPacketSize
);
1955 dev
->max_pkt_size
= (tmp
& 0x07ff) *
1956 (((tmp
& 0x1800) >> 11) + 1);
1957 dev
->isoc_in_endpointaddr
= endpoint
->bEndpointAddress
;
1959 "Found isoc endpoint 0x%02x, max size = %d\n",
1960 dev
->isoc_in_endpointaddr
, dev
->max_pkt_size
);
1963 if (!(dev
->isoc_in_endpointaddr
)) {
1964 pr_info("Could not locate isoc endpoint\n");
1968 init_waitqueue_head(&dev
->open
);
1969 spin_lock_init(&dev
->slock
);
1971 /* init video dma queues */
1972 INIT_LIST_HEAD(&dev
->vidq
.active
);
1973 INIT_LIST_HEAD(&dev
->vbiq
.active
);
1975 setup_timer(&dev
->vid_timeout
, au0828_vid_buffer_timeout
,
1976 (unsigned long)dev
);
1977 setup_timer(&dev
->vbi_timeout
, au0828_vbi_buffer_timeout
,
1978 (unsigned long)dev
);
1980 dev
->width
= NTSC_STD_W
;
1981 dev
->height
= NTSC_STD_H
;
1982 dev
->field_size
= dev
->width
* dev
->height
;
1983 dev
->frame_size
= dev
->field_size
<< 1;
1984 dev
->bytesperline
= dev
->width
<< 1;
1985 dev
->vbi_width
= 720;
1986 dev
->vbi_height
= 1;
1987 dev
->ctrl_ainput
= 0;
1988 dev
->ctrl_freq
= 960;
1989 dev
->std
= V4L2_STD_NTSC_M
;
1990 /* Default input is TV Tuner */
1991 au0828_s_input(dev
, 0);
1993 mutex_init(&dev
->vb_queue_lock
);
1994 mutex_init(&dev
->vb_vbi_queue_lock
);
1996 /* Fill the video capture device struct */
1997 dev
->vdev
= au0828_video_template
;
1998 dev
->vdev
.v4l2_dev
= &dev
->v4l2_dev
;
1999 dev
->vdev
.lock
= &dev
->lock
;
2000 dev
->vdev
.queue
= &dev
->vb_vidq
;
2001 dev
->vdev
.queue
->lock
= &dev
->vb_queue_lock
;
2002 strcpy(dev
->vdev
.name
, "au0828a video");
2004 /* Setup the VBI device */
2005 dev
->vbi_dev
= au0828_video_template
;
2006 dev
->vbi_dev
.v4l2_dev
= &dev
->v4l2_dev
;
2007 dev
->vbi_dev
.lock
= &dev
->lock
;
2008 dev
->vbi_dev
.queue
= &dev
->vb_vbiq
;
2009 dev
->vbi_dev
.queue
->lock
= &dev
->vb_vbi_queue_lock
;
2010 strcpy(dev
->vbi_dev
.name
, "au0828a vbi");
2012 /* Init entities at the Media Controller */
2013 au0828_analog_create_entities(dev
);
2015 /* initialize videobuf2 stuff */
2016 retval
= au0828_vb2_setup(dev
);
2018 dprintk(1, "unable to setup videobuf2 queues (error = %d).\n",
2023 /* Register the v4l2 device */
2024 video_set_drvdata(&dev
->vdev
, dev
);
2025 retval
= video_register_device(&dev
->vdev
, VFL_TYPE_GRABBER
, -1);
2027 dprintk(1, "unable to register video device (error = %d).\n",
2033 /* Register the vbi device */
2034 video_set_drvdata(&dev
->vbi_dev
, dev
);
2035 retval
= video_register_device(&dev
->vbi_dev
, VFL_TYPE_VBI
, -1);
2037 dprintk(1, "unable to register vbi device (error = %d).\n",
2040 goto err_reg_vbi_dev
;
2043 #ifdef CONFIG_MEDIA_CONTROLLER
2044 retval
= v4l2_mc_create_media_graph(dev
->media_dev
);
2046 pr_err("%s() au0282_dev_register failed to create graph\n",
2049 goto err_reg_vbi_dev
;
2053 dprintk(1, "%s completed!\n", __func__
);
2058 video_unregister_device(&dev
->vdev
);
2060 vb2_queue_release(&dev
->vb_vidq
);
2061 vb2_queue_release(&dev
->vb_vbiq
);