2 * Auvitek AU0828 USB Bridge (Analog video support)
4 * Copyright (C) 2009 Devin Heitmueller <dheitmueller@linuxtv.org>
5 * Copyright (C) 2005-2008 Auvitek International, Ltd.
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * As published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 * VBI support is not yet working
26 * The hardware scaler supported is unimplemented
27 * AC97 audio support is unimplemented (only i2s audio mode)
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/init.h>
34 #include <linux/device.h>
35 #include <linux/suspend.h>
36 #include <linux/version.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-ioctl.h>
39 #include <media/v4l2-chip-ident.h>
40 #include <media/tuner.h>
42 #include "au0828-reg.h"
44 static DEFINE_MUTEX(au0828_sysfs_lock);
46 #define AU0828_VERSION_CODE KERNEL_VERSION(0, 0, 1)
48 /* ------------------------------------------------------------------
50 ------------------------------------------------------------------*/
52 static unsigned int isoc_debug;
53 module_param(isoc_debug, int, 0644);
54 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
56 #define au0828_isocdbg(fmt, arg...) \
59 printk(KERN_INFO "au0828 %s :"fmt, \
64 static inline void print_err_status(struct au0828_dev *dev,
65 int packet, int status)
67 char *errmsg = "Unknown";
71 errmsg = "unlinked synchronuously";
74 errmsg = "unlinked asynchronuously";
77 errmsg = "Buffer error (overrun)";
80 errmsg = "Stalled (device not responding)";
83 errmsg = "Babble (bad cable?)";
86 errmsg = "Bit-stuff error (bad cable?)";
89 errmsg = "CRC/Timeout (could be anything)";
92 errmsg = "Device does not respond";
96 au0828_isocdbg("URB status %d [%s].\n", status, errmsg);
98 au0828_isocdbg("URB packet %d, status %d [%s].\n",
99 packet, status, errmsg);
103 static int check_dev(struct au0828_dev *dev)
105 if (dev->dev_state & DEV_DISCONNECTED) {
106 printk(KERN_INFO "v4l2 ioctl: device not present\n");
110 if (dev->dev_state & DEV_MISCONFIGURED) {
111 printk(KERN_INFO "v4l2 ioctl: device is misconfigured; "
112 "close and open it again\n");
119 * IRQ callback, called by URB callback
121 static void au0828_irq_callback(struct urb *urb)
123 struct au0828_dmaqueue *dma_q = urb->context;
124 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
127 switch (urb->status) {
128 case 0: /* success */
129 case -ETIMEDOUT: /* NAK */
131 case -ECONNRESET: /* kill */
134 au0828_isocdbg("au0828_irq_callback called: status kill\n");
136 default: /* unknown error */
137 au0828_isocdbg("urb completition error %d.\n", urb->status);
141 /* Copy data from URB */
142 spin_lock(&dev->slock);
143 rc = dev->isoc_ctl.isoc_copy(dev, urb);
144 spin_unlock(&dev->slock);
146 /* Reset urb buffers */
147 for (i = 0; i < urb->number_of_packets; i++) {
148 urb->iso_frame_desc[i].status = 0;
149 urb->iso_frame_desc[i].actual_length = 0;
153 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
155 au0828_isocdbg("urb resubmit failed (error=%i)\n",
161 * Stop and Deallocate URBs
163 void au0828_uninit_isoc(struct au0828_dev *dev)
168 au0828_isocdbg("au0828: called au0828_uninit_isoc\n");
170 dev->isoc_ctl.nfields = -1;
171 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
172 urb = dev->isoc_ctl.urb[i];
174 if (!irqs_disabled())
179 if (dev->isoc_ctl.transfer_buffer[i]) {
180 usb_free_coherent(dev->usbdev,
181 urb->transfer_buffer_length,
182 dev->isoc_ctl.transfer_buffer[i],
186 dev->isoc_ctl.urb[i] = NULL;
188 dev->isoc_ctl.transfer_buffer[i] = NULL;
191 kfree(dev->isoc_ctl.urb);
192 kfree(dev->isoc_ctl.transfer_buffer);
194 dev->isoc_ctl.urb = NULL;
195 dev->isoc_ctl.transfer_buffer = NULL;
196 dev->isoc_ctl.num_bufs = 0;
200 * Allocate URBs and start IRQ
202 int au0828_init_isoc(struct au0828_dev *dev, int max_packets,
203 int num_bufs, int max_pkt_size,
204 int (*isoc_copy) (struct au0828_dev *dev, struct urb *urb))
206 struct au0828_dmaqueue *dma_q = &dev->vidq;
213 au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
215 /* De-allocates all pending stuff */
216 au0828_uninit_isoc(dev);
218 dev->isoc_ctl.isoc_copy = isoc_copy;
219 dev->isoc_ctl.num_bufs = num_bufs;
221 dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
222 if (!dev->isoc_ctl.urb) {
223 au0828_isocdbg("cannot alloc memory for usb buffers\n");
227 dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
229 if (!dev->isoc_ctl.transfer_buffer) {
230 au0828_isocdbg("cannot allocate memory for usb transfer\n");
231 kfree(dev->isoc_ctl.urb);
235 dev->isoc_ctl.max_pkt_size = max_pkt_size;
236 dev->isoc_ctl.buf = NULL;
238 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
240 /* allocate urbs and transfer buffers */
241 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
242 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
244 au0828_isocdbg("cannot alloc isoc_ctl.urb %i\n", i);
245 au0828_uninit_isoc(dev);
248 dev->isoc_ctl.urb[i] = urb;
250 dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->usbdev,
251 sb_size, GFP_KERNEL, &urb->transfer_dma);
252 if (!dev->isoc_ctl.transfer_buffer[i]) {
253 printk("unable to allocate %i bytes for transfer"
256 in_interrupt() ? " while in int" : "");
257 au0828_uninit_isoc(dev);
260 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
262 pipe = usb_rcvisocpipe(dev->usbdev,
263 dev->isoc_in_endpointaddr),
265 usb_fill_int_urb(urb, dev->usbdev, pipe,
266 dev->isoc_ctl.transfer_buffer[i], sb_size,
267 au0828_irq_callback, dma_q, 1);
269 urb->number_of_packets = max_packets;
270 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
273 for (j = 0; j < max_packets; j++) {
274 urb->iso_frame_desc[j].offset = k;
275 urb->iso_frame_desc[j].length =
276 dev->isoc_ctl.max_pkt_size;
277 k += dev->isoc_ctl.max_pkt_size;
281 init_waitqueue_head(&dma_q->wq);
283 /* submit urbs and enables IRQ */
284 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
285 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
287 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
289 au0828_uninit_isoc(dev);
298 * Announces that a buffer were filled and request the next
300 static inline void buffer_filled(struct au0828_dev *dev,
301 struct au0828_dmaqueue *dma_q,
302 struct au0828_buffer *buf)
304 /* Advice that buffer was filled */
305 au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
307 buf->vb.state = VIDEOBUF_DONE;
308 buf->vb.field_count++;
309 do_gettimeofday(&buf->vb.ts);
311 dev->isoc_ctl.buf = NULL;
313 list_del(&buf->vb.queue);
314 wake_up(&buf->vb.done);
318 * Identify the buffer header type and properly handles
320 static void au0828_copy_video(struct au0828_dev *dev,
321 struct au0828_dmaqueue *dma_q,
322 struct au0828_buffer *buf,
324 unsigned char *outp, unsigned long len)
326 void *fieldstart, *startwrite, *startread;
327 int linesdone, currlinedone, offset, lencopy, remain;
328 int bytesperline = dev->width << 1; /* Assumes 16-bit depth @@@@ */
330 if (dma_q->pos + len > buf->vb.size)
331 len = buf->vb.size - dma_q->pos;
336 /* Interlaces frame */
340 fieldstart = outp + bytesperline;
342 linesdone = dma_q->pos / bytesperline;
343 currlinedone = dma_q->pos % bytesperline;
344 offset = linesdone * bytesperline * 2 + currlinedone;
345 startwrite = fieldstart + offset;
346 lencopy = bytesperline - currlinedone;
347 lencopy = lencopy > remain ? remain : lencopy;
349 if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
350 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
351 ((char *)startwrite + lencopy) -
352 ((char *)outp + buf->vb.size));
353 remain = (char *)outp + buf->vb.size - (char *)startwrite;
358 memcpy(startwrite, startread, lencopy);
363 startwrite += lencopy + bytesperline;
364 startread += lencopy;
365 if (bytesperline > remain)
368 lencopy = bytesperline;
370 if ((char *)startwrite + lencopy > (char *)outp +
372 au0828_isocdbg("Overflow %zi bytes past buf end (2)\n",
373 ((char *)startwrite + lencopy) -
374 ((char *)outp + buf->vb.size));
375 lencopy = remain = (char *)outp + buf->vb.size -
381 memcpy(startwrite, startread, lencopy);
387 /* We have enough data to check for greenscreen */
388 if (outp[0] < 0x60 && outp[1440] < 0x60)
389 dev->greenscreen_detected = 1;
396 * video-buf generic routine to get the next available buffer
398 static inline void get_next_buf(struct au0828_dmaqueue *dma_q,
399 struct au0828_buffer **buf)
401 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
403 if (list_empty(&dma_q->active)) {
404 au0828_isocdbg("No active queue to serve\n");
405 dev->isoc_ctl.buf = NULL;
410 /* Get the next buffer */
411 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
412 dev->isoc_ctl.buf = *buf;
418 * Controls the isoc copy of each urb packet
420 static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
422 struct au0828_buffer *buf;
423 struct au0828_dmaqueue *dma_q = urb->context;
424 unsigned char *outp = NULL;
425 int i, len = 0, rc = 1;
432 if ((dev->dev_state & DEV_DISCONNECTED) ||
433 (dev->dev_state & DEV_MISCONFIGURED))
436 if (urb->status < 0) {
437 print_err_status(dev, -1, urb->status);
438 if (urb->status == -ENOENT)
442 buf = dev->isoc_ctl.buf;
444 outp = videobuf_to_vmalloc(&buf->vb);
446 for (i = 0; i < urb->number_of_packets; i++) {
447 int status = urb->iso_frame_desc[i].status;
450 print_err_status(dev, i, status);
451 if (urb->iso_frame_desc[i].status != -EPROTO)
455 if (urb->iso_frame_desc[i].actual_length <= 0)
458 if (urb->iso_frame_desc[i].actual_length >
460 au0828_isocdbg("packet bigger than packet size");
464 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
466 len = urb->iso_frame_desc[i].actual_length - 4;
472 au0828_isocdbg("Video frame %s\n",
473 (fbyte & 0x40) ? "odd" : "even");
474 if (!(fbyte & 0x40)) {
476 buffer_filled(dev, dma_q, buf);
477 get_next_buf(dma_q, &buf);
481 outp = videobuf_to_vmalloc(&buf->vb);
494 au0828_copy_video(dev, dma_q, buf, p, outp, len);
500 buffer_setup(struct videobuf_queue *vq, unsigned int *count,
503 struct au0828_fh *fh = vq->priv_data;
504 *size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
507 *count = AU0828_DEF_BUF;
509 if (*count < AU0828_MIN_BUF)
510 *count = AU0828_MIN_BUF;
514 /* This is called *without* dev->slock held; please keep it that way */
515 static void free_buffer(struct videobuf_queue *vq, struct au0828_buffer *buf)
517 struct au0828_fh *fh = vq->priv_data;
518 struct au0828_dev *dev = fh->dev;
519 unsigned long flags = 0;
523 /* We used to wait for the buffer to finish here, but this didn't work
524 because, as we were keeping the state as VIDEOBUF_QUEUED,
525 videobuf_queue_cancel marked it as finished for us.
526 (Also, it could wedge forever if the hardware was misconfigured.)
528 This should be safe; by the time we get here, the buffer isn't
529 queued anymore. If we ever start marking the buffers as
530 VIDEOBUF_ACTIVE, it won't be, though.
532 spin_lock_irqsave(&dev->slock, flags);
533 if (dev->isoc_ctl.buf == buf)
534 dev->isoc_ctl.buf = NULL;
535 spin_unlock_irqrestore(&dev->slock, flags);
537 videobuf_vmalloc_free(&buf->vb);
538 buf->vb.state = VIDEOBUF_NEEDS_INIT;
542 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
543 enum v4l2_field field)
545 struct au0828_fh *fh = vq->priv_data;
546 struct au0828_buffer *buf = container_of(vb, struct au0828_buffer, vb);
547 struct au0828_dev *dev = fh->dev;
548 int rc = 0, urb_init = 0;
550 buf->vb.size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
552 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
555 buf->vb.width = dev->width;
556 buf->vb.height = dev->height;
557 buf->vb.field = field;
559 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
560 rc = videobuf_iolock(vq, &buf->vb, NULL);
562 printk(KERN_INFO "videobuf_iolock failed\n");
567 if (!dev->isoc_ctl.num_bufs)
571 rc = au0828_init_isoc(dev, AU0828_ISO_PACKETS_PER_URB,
572 AU0828_MAX_ISO_BUFS, dev->max_pkt_size,
575 printk(KERN_INFO "au0828_init_isoc failed\n");
580 buf->vb.state = VIDEOBUF_PREPARED;
584 free_buffer(vq, buf);
589 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
591 struct au0828_buffer *buf = container_of(vb,
592 struct au0828_buffer,
594 struct au0828_fh *fh = vq->priv_data;
595 struct au0828_dev *dev = fh->dev;
596 struct au0828_dmaqueue *vidq = &dev->vidq;
598 buf->vb.state = VIDEOBUF_QUEUED;
599 list_add_tail(&buf->vb.queue, &vidq->active);
602 static void buffer_release(struct videobuf_queue *vq,
603 struct videobuf_buffer *vb)
605 struct au0828_buffer *buf = container_of(vb,
606 struct au0828_buffer,
609 free_buffer(vq, buf);
612 static struct videobuf_queue_ops au0828_video_qops = {
613 .buf_setup = buffer_setup,
614 .buf_prepare = buffer_prepare,
615 .buf_queue = buffer_queue,
616 .buf_release = buffer_release,
619 /* ------------------------------------------------------------------
621 ------------------------------------------------------------------*/
623 static int au0828_i2s_init(struct au0828_dev *dev)
625 /* Enable i2s mode */
626 au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
631 * Auvitek au0828 analog stream enable
632 * Please set interface0 to AS5 before enable the stream
634 int au0828_analog_stream_enable(struct au0828_dev *d)
636 dprintk(1, "au0828_analog_stream_enable called\n");
637 au0828_writereg(d, AU0828_SENSORCTRL_VBI_103, 0x00);
638 au0828_writereg(d, 0x106, 0x00);
640 au0828_writereg(d, 0x110, 0x00);
641 au0828_writereg(d, 0x111, 0x00);
642 au0828_writereg(d, 0x114, 0xa0);
643 au0828_writereg(d, 0x115, 0x05);
645 au0828_writereg(d, 0x112, 0x02);
646 au0828_writereg(d, 0x113, 0x00);
647 au0828_writereg(d, 0x116, 0xf2);
648 au0828_writereg(d, 0x117, 0x00);
649 au0828_writereg(d, AU0828_SENSORCTRL_100, 0xb3);
654 int au0828_analog_stream_disable(struct au0828_dev *d)
656 dprintk(1, "au0828_analog_stream_disable called\n");
657 au0828_writereg(d, AU0828_SENSORCTRL_100, 0x0);
661 void au0828_analog_stream_reset(struct au0828_dev *dev)
663 dprintk(1, "au0828_analog_stream_reset called\n");
664 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0x0);
666 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0xb3);
670 * Some operations needs to stop current streaming
672 static int au0828_stream_interrupt(struct au0828_dev *dev)
676 dev->stream_state = STREAM_INTERRUPT;
677 if (dev->dev_state == DEV_DISCONNECTED)
680 dev->dev_state = DEV_MISCONFIGURED;
681 dprintk(1, "%s device is misconfigured!\n", __func__);
688 * au0828_release_resources
689 * unregister v4l2 devices
691 void au0828_analog_unregister(struct au0828_dev *dev)
693 dprintk(1, "au0828_release_resources called\n");
694 mutex_lock(&au0828_sysfs_lock);
697 video_unregister_device(dev->vdev);
699 video_unregister_device(dev->vbi_dev);
701 mutex_unlock(&au0828_sysfs_lock);
705 /* Usage lock check functions */
706 static int res_get(struct au0828_fh *fh)
708 struct au0828_dev *dev = fh->dev;
711 /* This instance already has stream_on */
723 static int res_check(struct au0828_fh *fh)
725 return fh->stream_on;
728 static void res_free(struct au0828_fh *fh)
730 struct au0828_dev *dev = fh->dev;
736 static int au0828_v4l2_open(struct file *filp)
739 struct au0828_dev *dev = video_drvdata(filp);
740 struct au0828_fh *fh;
741 int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
743 #ifdef VBI_IS_WORKING
744 if (video_devdata(filp)->vfl_type == VFL_TYPE_GRABBER)
745 type = V4L2_BUF_TYPE_VBI_CAPTURE;
748 fh = kzalloc(sizeof(struct au0828_fh), GFP_KERNEL);
750 dprintk(1, "Failed allocate au0828_fh struct!\n");
756 filp->private_data = fh;
758 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
759 /* set au0828 interface0 to AS5 here again */
760 ret = usb_set_interface(dev->usbdev, 0, 5);
762 printk(KERN_INFO "Au0828 can't set alternate to 5!\n");
765 dev->width = NTSC_STD_W;
766 dev->height = NTSC_STD_H;
767 dev->frame_size = dev->width * dev->height * 2;
768 dev->field_size = dev->width * dev->height;
769 dev->bytesperline = dev->width * 2;
771 au0828_analog_stream_enable(dev);
772 au0828_analog_stream_reset(dev);
774 /* If we were doing ac97 instead of i2s, it would go here...*/
775 au0828_i2s_init(dev);
777 dev->stream_state = STREAM_OFF;
778 dev->dev_state |= DEV_INITIALIZED;
783 videobuf_queue_vmalloc_init(&fh->vb_vidq, &au0828_video_qops,
784 NULL, &dev->slock, fh->type,
785 V4L2_FIELD_INTERLACED,
786 sizeof(struct au0828_buffer), fh);
791 static int au0828_v4l2_close(struct file *filp)
794 struct au0828_fh *fh = filp->private_data;
795 struct au0828_dev *dev = fh->dev;
797 mutex_lock(&dev->lock);
801 if (dev->users == 1) {
802 videobuf_stop(&fh->vb_vidq);
803 videobuf_mmap_free(&fh->vb_vidq);
805 if (dev->dev_state & DEV_DISCONNECTED) {
806 au0828_analog_unregister(dev);
807 mutex_unlock(&dev->lock);
812 au0828_analog_stream_disable(dev);
814 au0828_uninit_isoc(dev);
816 /* Save some power by putting tuner to sleep */
817 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
819 /* When close the device, set the usb intf0 into alt0 to free
821 ret = usb_set_interface(dev->usbdev, 0, 0);
823 printk(KERN_INFO "Au0828 can't set alternate to 0!\n");
828 wake_up_interruptible_nr(&dev->open, 1);
829 mutex_unlock(&dev->lock);
833 static ssize_t au0828_v4l2_read(struct file *filp, char __user *buf,
834 size_t count, loff_t *pos)
836 struct au0828_fh *fh = filp->private_data;
837 struct au0828_dev *dev = fh->dev;
844 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
845 mutex_lock(&dev->lock);
847 mutex_unlock(&dev->lock);
849 if (unlikely(rc < 0))
852 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
853 filp->f_flags & O_NONBLOCK);
858 static unsigned int au0828_v4l2_poll(struct file *filp, poll_table *wait)
860 struct au0828_fh *fh = filp->private_data;
861 struct au0828_dev *dev = fh->dev;
868 mutex_lock(&dev->lock);
870 mutex_unlock(&dev->lock);
872 if (unlikely(rc < 0))
875 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
878 return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
881 static int au0828_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
883 struct au0828_fh *fh = filp->private_data;
884 struct au0828_dev *dev = fh->dev;
891 mutex_lock(&dev->lock);
893 mutex_unlock(&dev->lock);
895 if (unlikely(rc < 0))
898 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
903 static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
904 struct v4l2_format *format)
907 int width = format->fmt.pix.width;
908 int height = format->fmt.pix.height;
909 unsigned int maxwidth, maxheight;
914 #ifdef VBI_IS_WORKING
915 if (format->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
916 dprintk(1, "VBI format set: to be supported!\n");
919 if (format->type == V4L2_BUF_TYPE_VBI_CAPTURE)
922 if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
925 /* If they are demanding a format other than the one we support,
926 bail out (tvtime asks for UYVY and then retries with YUYV) */
927 if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
930 /* format->fmt.pix.width only support 720 and height 480 */
936 format->fmt.pix.width = width;
937 format->fmt.pix.height = height;
938 format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
939 format->fmt.pix.bytesperline = width * 2;
940 format->fmt.pix.sizeimage = width * height * 2;
941 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
942 format->fmt.pix.field = V4L2_FIELD_INTERLACED;
944 if (cmd == VIDIOC_TRY_FMT)
947 /* maybe set new image format, driver current only support 720*480 */
949 dev->height = height;
950 dev->frame_size = width * height * 2;
951 dev->field_size = width * height;
952 dev->bytesperline = width * 2;
954 if (dev->stream_state == STREAM_ON) {
955 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
956 ret = au0828_stream_interrupt(dev);
958 dprintk(1, "error interrupting video stream!\n");
963 /* set au0828 interface0 to AS5 here again */
964 ret = usb_set_interface(dev->usbdev, 0, 5);
966 printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
970 au0828_analog_stream_enable(dev);
976 static int vidioc_queryctrl(struct file *file, void *priv,
977 struct v4l2_queryctrl *qc)
979 struct au0828_fh *fh = priv;
980 struct au0828_dev *dev = fh->dev;
981 v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, qc);
988 static int vidioc_querycap(struct file *file, void *priv,
989 struct v4l2_capability *cap)
991 struct au0828_fh *fh = priv;
992 struct au0828_dev *dev = fh->dev;
994 strlcpy(cap->driver, "au0828", sizeof(cap->driver));
995 strlcpy(cap->card, dev->board.name, sizeof(cap->card));
996 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
998 cap->version = AU0828_VERSION_CODE;
1000 /*set the device capabilities */
1001 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1002 #ifdef VBI_IS_WORKING
1003 V4L2_CAP_VBI_CAPTURE |
1006 V4L2_CAP_READWRITE |
1007 V4L2_CAP_STREAMING |
1012 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1013 struct v4l2_fmtdesc *f)
1018 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1019 strcpy(f->description, "Packed YUV2");
1022 f->pixelformat = V4L2_PIX_FMT_UYVY;
1027 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1028 struct v4l2_format *f)
1030 struct au0828_fh *fh = priv;
1031 struct au0828_dev *dev = fh->dev;
1033 f->fmt.pix.width = dev->width;
1034 f->fmt.pix.height = dev->height;
1035 f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1036 f->fmt.pix.bytesperline = dev->bytesperline;
1037 f->fmt.pix.sizeimage = dev->frame_size;
1038 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
1039 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1043 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1044 struct v4l2_format *f)
1046 struct au0828_fh *fh = priv;
1047 struct au0828_dev *dev = fh->dev;
1049 return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1052 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1053 struct v4l2_format *f)
1055 struct au0828_fh *fh = priv;
1056 struct au0828_dev *dev = fh->dev;
1059 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1060 printk(KERN_INFO "%s queue busy\n", __func__);
1065 if (dev->stream_on && !fh->stream_on) {
1066 printk(KERN_INFO "%s device in use by another fh\n", __func__);
1071 return au0828_set_format(dev, VIDIOC_S_FMT, f);
1076 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id * norm)
1078 struct au0828_fh *fh = priv;
1079 struct au0828_dev *dev = fh->dev;
1081 /* FIXME: when we support something other than NTSC, we are going to
1082 have to make the au0828 bridge adjust the size of its capture
1083 buffer, which is currently hardcoded at 720x480 */
1085 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, *norm);
1089 static int vidioc_enum_input(struct file *file, void *priv,
1090 struct v4l2_input *input)
1092 struct au0828_fh *fh = priv;
1093 struct au0828_dev *dev = fh->dev;
1096 static const char *inames[] = {
1097 [AU0828_VMUX_UNDEFINED] = "Undefined",
1098 [AU0828_VMUX_COMPOSITE] = "Composite",
1099 [AU0828_VMUX_SVIDEO] = "S-Video",
1100 [AU0828_VMUX_CABLE] = "Cable TV",
1101 [AU0828_VMUX_TELEVISION] = "Television",
1102 [AU0828_VMUX_DVB] = "DVB",
1103 [AU0828_VMUX_DEBUG] = "tv debug"
1108 if (tmp > AU0828_MAX_INPUT)
1110 if (AUVI_INPUT(tmp).type == 0)
1114 strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
1115 if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
1116 (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE))
1117 input->type |= V4L2_INPUT_TYPE_TUNER;
1119 input->type |= V4L2_INPUT_TYPE_CAMERA;
1121 input->std = dev->vdev->tvnorms;
1126 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1128 struct au0828_fh *fh = priv;
1129 struct au0828_dev *dev = fh->dev;
1130 *i = dev->ctrl_input;
1134 static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1136 struct au0828_fh *fh = priv;
1137 struct au0828_dev *dev = fh->dev;
1140 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
1142 if (index >= AU0828_MAX_INPUT)
1144 if (AUVI_INPUT(index).type == 0)
1146 dev->ctrl_input = index;
1148 switch (AUVI_INPUT(index).type) {
1149 case AU0828_VMUX_SVIDEO:
1150 dev->input_type = AU0828_VMUX_SVIDEO;
1152 case AU0828_VMUX_COMPOSITE:
1153 dev->input_type = AU0828_VMUX_COMPOSITE;
1155 case AU0828_VMUX_TELEVISION:
1156 dev->input_type = AU0828_VMUX_TELEVISION;
1159 dprintk(1, "VIDIOC_S_INPUT unknown input type set [%d]\n",
1160 AUVI_INPUT(index).type);
1164 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1165 AUVI_INPUT(index).vmux, 0, 0);
1167 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1169 if (AUVI_INPUT(i).audio_setup == NULL)
1177 (AUVI_INPUT(i).audio_setup)(dev, enable);
1179 /* Make sure we leave it turned on if some
1180 other input is routed to this callback */
1181 if ((AUVI_INPUT(i).audio_setup) !=
1182 ((AUVI_INPUT(index).audio_setup))) {
1183 (AUVI_INPUT(i).audio_setup)(dev, enable);
1188 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1189 AUVI_INPUT(index).amux, 0, 0);
1193 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1195 struct au0828_fh *fh = priv;
1196 struct au0828_dev *dev = fh->dev;
1197 unsigned int index = a->index;
1202 index = dev->ctrl_ainput;
1204 strcpy(a->name, "Television");
1206 strcpy(a->name, "Line in");
1208 a->capability = V4L2_AUDCAP_STEREO;
1213 static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
1215 struct au0828_fh *fh = priv;
1216 struct au0828_dev *dev = fh->dev;
1217 if (a->index != dev->ctrl_ainput)
1222 static int vidioc_g_ctrl(struct file *file, void *priv,
1223 struct v4l2_control *ctrl)
1225 struct au0828_fh *fh = priv;
1226 struct au0828_dev *dev = fh->dev;
1228 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl);
1233 static int vidioc_s_ctrl(struct file *file, void *priv,
1234 struct v4l2_control *ctrl)
1236 struct au0828_fh *fh = priv;
1237 struct au0828_dev *dev = fh->dev;
1238 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_ctrl, ctrl);
1242 static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1244 struct au0828_fh *fh = priv;
1245 struct au0828_dev *dev = fh->dev;
1250 strcpy(t->name, "Auvitek tuner");
1251 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1255 static int vidioc_s_tuner(struct file *file, void *priv,
1256 struct v4l2_tuner *t)
1258 struct au0828_fh *fh = priv;
1259 struct au0828_dev *dev = fh->dev;
1264 t->type = V4L2_TUNER_ANALOG_TV;
1265 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1266 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1272 static int vidioc_g_frequency(struct file *file, void *priv,
1273 struct v4l2_frequency *freq)
1275 struct au0828_fh *fh = priv;
1276 struct au0828_dev *dev = fh->dev;
1278 freq->type = V4L2_TUNER_ANALOG_TV;
1279 freq->frequency = dev->ctrl_freq;
1283 static int vidioc_s_frequency(struct file *file, void *priv,
1284 struct v4l2_frequency *freq)
1286 struct au0828_fh *fh = priv;
1287 struct au0828_dev *dev = fh->dev;
1289 if (freq->tuner != 0)
1291 if (freq->type != V4L2_TUNER_ANALOG_TV)
1294 dev->ctrl_freq = freq->frequency;
1296 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
1298 au0828_analog_stream_reset(dev);
1303 static int vidioc_g_chip_ident(struct file *file, void *priv,
1304 struct v4l2_dbg_chip_ident *chip)
1306 struct au0828_fh *fh = priv;
1307 struct au0828_dev *dev = fh->dev;
1308 chip->ident = V4L2_IDENT_NONE;
1311 if (v4l2_chip_match_host(&chip->match)) {
1312 chip->ident = V4L2_IDENT_AU0828;
1316 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
1317 if (chip->ident == V4L2_IDENT_NONE)
1323 static int vidioc_cropcap(struct file *file, void *priv,
1324 struct v4l2_cropcap *cc)
1326 struct au0828_fh *fh = priv;
1327 struct au0828_dev *dev = fh->dev;
1329 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1332 cc->bounds.left = 0;
1334 cc->bounds.width = dev->width;
1335 cc->bounds.height = dev->height;
1337 cc->defrect = cc->bounds;
1339 cc->pixelaspect.numerator = 54;
1340 cc->pixelaspect.denominator = 59;
1345 static int vidioc_streamon(struct file *file, void *priv,
1346 enum v4l2_buf_type type)
1348 struct au0828_fh *fh = priv;
1349 struct au0828_dev *dev = fh->dev;
1352 rc = check_dev(dev);
1356 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1357 au0828_analog_stream_enable(dev);
1358 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
1361 mutex_lock(&dev->lock);
1364 if (likely(rc >= 0))
1365 rc = videobuf_streamon(&fh->vb_vidq);
1366 mutex_unlock(&dev->lock);
1371 static int vidioc_streamoff(struct file *file, void *priv,
1372 enum v4l2_buf_type type)
1374 struct au0828_fh *fh = priv;
1375 struct au0828_dev *dev = fh->dev;
1380 rc = check_dev(dev);
1384 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1386 if (type != fh->type)
1389 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1390 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1391 ret = au0828_stream_interrupt(dev);
1396 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1397 if (AUVI_INPUT(i).audio_setup == NULL)
1399 (AUVI_INPUT(i).audio_setup)(dev, 0);
1402 mutex_lock(&dev->lock);
1403 videobuf_streamoff(&fh->vb_vidq);
1405 mutex_unlock(&dev->lock);
1410 #ifdef CONFIG_VIDEO_ADV_DEBUG
1411 static int vidioc_g_register(struct file *file, void *priv,
1412 struct v4l2_dbg_register *reg)
1414 struct au0828_fh *fh = priv;
1415 struct au0828_dev *dev = fh->dev;
1417 switch (reg->match.type) {
1418 case V4L2_CHIP_MATCH_I2C_DRIVER:
1419 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
1426 static int vidioc_s_register(struct file *file, void *priv,
1427 struct v4l2_dbg_register *reg)
1429 struct au0828_fh *fh = priv;
1430 struct au0828_dev *dev = fh->dev;
1432 switch (reg->match.type) {
1433 case V4L2_CHIP_MATCH_I2C_DRIVER:
1434 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
1443 static int vidioc_reqbufs(struct file *file, void *priv,
1444 struct v4l2_requestbuffers *rb)
1446 struct au0828_fh *fh = priv;
1447 struct au0828_dev *dev = fh->dev;
1450 rc = check_dev(dev);
1454 return videobuf_reqbufs(&fh->vb_vidq, rb);
1457 static int vidioc_querybuf(struct file *file, void *priv,
1458 struct v4l2_buffer *b)
1460 struct au0828_fh *fh = priv;
1461 struct au0828_dev *dev = fh->dev;
1464 rc = check_dev(dev);
1468 return videobuf_querybuf(&fh->vb_vidq, b);
1471 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1473 struct au0828_fh *fh = priv;
1474 struct au0828_dev *dev = fh->dev;
1477 rc = check_dev(dev);
1481 return videobuf_qbuf(&fh->vb_vidq, b);
1484 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1486 struct au0828_fh *fh = priv;
1487 struct au0828_dev *dev = fh->dev;
1490 rc = check_dev(dev);
1494 /* Workaround for a bug in the au0828 hardware design that sometimes
1495 results in the colorspace being inverted */
1496 if (dev->greenscreen_detected == 1) {
1497 dprintk(1, "Detected green frame. Resetting stream...\n");
1498 au0828_analog_stream_reset(dev);
1499 dev->greenscreen_detected = 0;
1502 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1505 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1506 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1508 struct au0828_fh *fh = priv;
1510 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1514 static struct v4l2_file_operations au0828_v4l_fops = {
1515 .owner = THIS_MODULE,
1516 .open = au0828_v4l2_open,
1517 .release = au0828_v4l2_close,
1518 .read = au0828_v4l2_read,
1519 .poll = au0828_v4l2_poll,
1520 .mmap = au0828_v4l2_mmap,
1521 .ioctl = video_ioctl2,
1524 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1525 .vidioc_querycap = vidioc_querycap,
1526 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1527 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1528 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1529 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1530 #ifdef VBI_IS_WORKING
1531 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1532 .vidioc_try_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
1533 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
1535 .vidioc_g_audio = vidioc_g_audio,
1536 .vidioc_s_audio = vidioc_s_audio,
1537 .vidioc_cropcap = vidioc_cropcap,
1538 #ifdef VBI_IS_WORKING
1539 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
1540 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
1541 .vidioc_s_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
1543 .vidioc_reqbufs = vidioc_reqbufs,
1544 .vidioc_querybuf = vidioc_querybuf,
1545 .vidioc_qbuf = vidioc_qbuf,
1546 .vidioc_dqbuf = vidioc_dqbuf,
1547 .vidioc_s_std = vidioc_s_std,
1548 .vidioc_enum_input = vidioc_enum_input,
1549 .vidioc_g_input = vidioc_g_input,
1550 .vidioc_s_input = vidioc_s_input,
1551 .vidioc_queryctrl = vidioc_queryctrl,
1552 .vidioc_g_ctrl = vidioc_g_ctrl,
1553 .vidioc_s_ctrl = vidioc_s_ctrl,
1554 .vidioc_streamon = vidioc_streamon,
1555 .vidioc_streamoff = vidioc_streamoff,
1556 .vidioc_g_tuner = vidioc_g_tuner,
1557 .vidioc_s_tuner = vidioc_s_tuner,
1558 .vidioc_g_frequency = vidioc_g_frequency,
1559 .vidioc_s_frequency = vidioc_s_frequency,
1560 #ifdef CONFIG_VIDEO_ADV_DEBUG
1561 .vidioc_g_register = vidioc_g_register,
1562 .vidioc_s_register = vidioc_s_register,
1564 .vidioc_g_chip_ident = vidioc_g_chip_ident,
1565 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1566 .vidiocgmbuf = vidiocgmbuf,
1570 static const struct video_device au0828_video_template = {
1571 .fops = &au0828_v4l_fops,
1572 .release = video_device_release,
1573 .ioctl_ops = &video_ioctl_ops,
1574 .tvnorms = V4L2_STD_NTSC_M,
1575 .current_norm = V4L2_STD_NTSC_M,
1578 /**************************************************************************/
1580 int au0828_analog_register(struct au0828_dev *dev,
1581 struct usb_interface *interface)
1583 int retval = -ENOMEM;
1584 struct usb_host_interface *iface_desc;
1585 struct usb_endpoint_descriptor *endpoint;
1588 dprintk(1, "au0828_analog_register called!\n");
1590 /* set au0828 usb interface0 to as5 */
1591 retval = usb_set_interface(dev->usbdev,
1592 interface->cur_altsetting->desc.bInterfaceNumber, 5);
1594 printk(KERN_INFO "Failure setting usb interface0 to as5\n");
1598 /* Figure out which endpoint has the isoc interface */
1599 iface_desc = interface->cur_altsetting;
1600 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
1601 endpoint = &iface_desc->endpoint[i].desc;
1602 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1604 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1605 == USB_ENDPOINT_XFER_ISOC)) {
1607 /* we find our isoc in endpoint */
1608 u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
1609 dev->max_pkt_size = (tmp & 0x07ff) *
1610 (((tmp & 0x1800) >> 11) + 1);
1611 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1614 if (!(dev->isoc_in_endpointaddr)) {
1615 printk(KERN_INFO "Could not locate isoc endpoint\n");
1620 init_waitqueue_head(&dev->open);
1621 spin_lock_init(&dev->slock);
1622 mutex_init(&dev->lock);
1624 INIT_LIST_HEAD(&dev->vidq.active);
1625 INIT_LIST_HEAD(&dev->vidq.queued);
1627 dev->width = NTSC_STD_W;
1628 dev->height = NTSC_STD_H;
1629 dev->field_size = dev->width * dev->height;
1630 dev->frame_size = dev->field_size << 1;
1631 dev->bytesperline = dev->width << 1;
1632 dev->ctrl_ainput = 0;
1634 /* allocate and fill v4l2 video struct */
1635 dev->vdev = video_device_alloc();
1636 if (NULL == dev->vdev) {
1637 dprintk(1, "Can't allocate video_device.\n");
1641 #ifdef VBI_IS_WORKING
1642 dev->vbi_dev = video_device_alloc();
1643 if (NULL == dev->vbi_dev) {
1644 dprintk(1, "Can't allocate vbi_device.\n");
1650 /* Fill the video capture device struct */
1651 *dev->vdev = au0828_video_template;
1652 dev->vdev->parent = &dev->usbdev->dev;
1653 strcpy(dev->vdev->name, "au0828a video");
1655 #ifdef VBI_IS_WORKING
1656 /* Setup the VBI device */
1657 *dev->vbi_dev = au0828_video_template;
1658 dev->vbi_dev->parent = &dev->usbdev->dev;
1659 strcpy(dev->vbi_dev->name, "au0828a vbi");
1662 /* Register the v4l2 device */
1663 video_set_drvdata(dev->vdev, dev);
1664 retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
1666 dprintk(1, "unable to register video device (error = %d).\n",
1668 video_device_release(dev->vdev);
1672 #ifdef VBI_IS_WORKING
1673 /* Register the vbi device */
1674 video_set_drvdata(dev->vbi_dev, dev);
1675 retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
1677 dprintk(1, "unable to register vbi device (error = %d).\n",
1679 video_device_release(dev->vbi_dev);
1680 video_device_release(dev->vdev);
1685 dprintk(1, "%s completed!\n", __func__);