projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (11084): au0828: add entry for undefined input type
[deliverable/linux.git] / drivers / media / video / au0828 / au0828-video.c
CommitLineData
8b2f0795
DH		 1/*
2 * Auvitek AU0828 USB Bridge (Analog video support)
3 *
4 * Copyright (C) 2009 Devin Heitmueller <dheitmueller@linuxtv.org>
5 * Copyright (C) 2005-2008 Auvitek International, Ltd.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * As published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301, USA.
21 */
22
23/* Developer Notes:
24 *
25 * VBI support is not yet working
26 * The hardware scaler supported is unimplemented
27 * AC97 audio support is unimplemented (only i2s audio mode)
28 *
29 */
30
31#include <linux/module.h>
32#include <linux/init.h>
33#include <linux/device.h>
34#include <linux/suspend.h>
35#include <linux/version.h>
36#include <linux/videodev.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>
41#include "au0828.h"
42#include "au0828-reg.h"
43
44static LIST_HEAD(au0828_devlist);
45static DEFINE_MUTEX(au0828_sysfs_lock);
46
47#define AU0828_VERSION_CODE KERNEL_VERSION(0, 0, 1)
48
49/* Forward declarations */
50void au0828_analog_stream_reset(struct au0828_dev *dev);
51
52/* ------------------------------------------------------------------
53 Videobuf operations
54 ------------------------------------------------------------------*/
55
56static unsigned int isoc_debug;
57module_param(isoc_debug, int, 0644);
58MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
59
60#define au0828_isocdbg(fmt, arg...) \
61do {\
62 if (isoc_debug) { \
63 printk(KERN_INFO "au0828 %s :"fmt, \
64 __func__ , ##arg); \
65 } \
66 } while (0)
67
68static inline void print_err_status(struct au0828_dev *dev,
69 int packet, int status)
70{
71 char *errmsg = "Unknown";
72
73 switch (status) {
74 case -ENOENT:
75 errmsg = "unlinked synchronuously";
76 break;
77 case -ECONNRESET:
78 errmsg = "unlinked asynchronuously";
79 break;
80 case -ENOSR:
81 errmsg = "Buffer error (overrun)";
82 break;
83 case -EPIPE:
84 errmsg = "Stalled (device not responding)";
85 break;
86 case -EOVERFLOW:
87 errmsg = "Babble (bad cable?)";
88 break;
89 case -EPROTO:
90 errmsg = "Bit-stuff error (bad cable?)";
91 break;
92 case -EILSEQ:
93 errmsg = "CRC/Timeout (could be anything)";
94 break;
95 case -ETIME:
96 errmsg = "Device does not respond";
97 break;
98 }
99 if (packet < 0) {
100 au0828_isocdbg("URB status %d [%s].\n", status, errmsg);
101 } else {
102 au0828_isocdbg("URB packet %d, status %d [%s].\n",
103 packet, status, errmsg);
104 }
105}
106
107static int check_dev(struct au0828_dev *dev)
108{
109 if (dev->dev_state & DEV_DISCONNECTED) {
110 printk("v4l2 ioctl: device not present\n");
111 return -ENODEV;
112 }
113
114 if (dev->dev_state & DEV_MISCONFIGURED) {
115 printk("v4l2 ioctl: device is misconfigured; "
116 "close and open it again\n");
117 return -EIO;
118 }
119 return 0;
120}
121
122/*
123 * IRQ callback, called by URB callback
124 */
125static void au0828_irq_callback(struct urb *urb)
126{
127 struct au0828_dmaqueue *dma_q = urb->context;
128 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
129 int rc, i;
130
131 switch (urb->status) {
132 case 0: /* success */
133 case -ETIMEDOUT: /* NAK */
134 break;
135 case -ECONNRESET: /* kill */
136 case -ENOENT:
137 case -ESHUTDOWN:
138 au0828_isocdbg("au0828_irq_callback called: status kill\n");
139 return;
140 default: /* unknown error */
141 au0828_isocdbg("urb completition error %d.\n", urb->status);
142 break;
143 }
144
145 /* Copy data from URB */
146 spin_lock(&dev->slock);
147 rc = dev->isoc_ctl.isoc_copy(dev, urb);
148 spin_unlock(&dev->slock);
149
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;
154 }
155 urb->status = 0;
156
157 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
158 if (urb->status) {
159 au0828_isocdbg("urb resubmit failed (error=%i)\n",
160 urb->status);
161 }
162}
163
164/*
165 * Stop and Deallocate URBs
166 */
167void au0828_uninit_isoc(struct au0828_dev *dev)
168{
169 struct urb *urb;
170 int i;
171
172 au0828_isocdbg("au0828: called au0828_uninit_isoc\n");
173
174 dev->isoc_ctl.nfields = -1;
175 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
176 urb = dev->isoc_ctl.urb[i];
177 if (urb) {
178 if (!irqs_disabled())
179 usb_kill_urb(urb);
180 else
181 usb_unlink_urb(urb);
182
183 if (dev->isoc_ctl.transfer_buffer[i]) {
184 usb_buffer_free(dev->usbdev,
185 urb->transfer_buffer_length,
186 dev->isoc_ctl.transfer_buffer[i],
187 urb->transfer_dma);
188 }
189 usb_free_urb(urb);
190 dev->isoc_ctl.urb[i] = NULL;
191 }
192 dev->isoc_ctl.transfer_buffer[i] = NULL;
193 }
194
195 kfree(dev->isoc_ctl.urb);
196 kfree(dev->isoc_ctl.transfer_buffer);
197
198 dev->isoc_ctl.urb = NULL;
199 dev->isoc_ctl.transfer_buffer = NULL;
200 dev->isoc_ctl.num_bufs = 0;
201}
202
203/*
204 * Allocate URBs and start IRQ
205 */
206int au0828_init_isoc(struct au0828_dev *dev, int max_packets,
207 int num_bufs, int max_pkt_size,
208 int (*isoc_copy) (struct au0828_dev *dev, struct urb *urb))
209{
210 struct au0828_dmaqueue *dma_q = &dev->vidq;
211 int i;
212 int sb_size, pipe;
213 struct urb *urb;
214 int j, k;
215 int rc;
216
217 au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
218
219 /* De-allocates all pending stuff */
220 au0828_uninit_isoc(dev);
221
222 dev->isoc_ctl.isoc_copy = isoc_copy;
223 dev->isoc_ctl.num_bufs = num_bufs;
224
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");
228 return -ENOMEM;
229 }
230
231 dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
232 GFP_KERNEL);
233 if (!dev->isoc_ctl.transfer_buffer) {
234 au0828_isocdbg("cannot allocate memory for usb transfer\n");
235 kfree(dev->isoc_ctl.urb);
236 return -ENOMEM;
237 }
238
239 dev->isoc_ctl.max_pkt_size = max_pkt_size;
240 dev->isoc_ctl.buf = NULL;
241
242 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
243
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);
247 if (!urb) {
248 au0828_isocdbg("cannot alloc isoc_ctl.urb %i\n", i);
249 au0828_uninit_isoc(dev);
250 return -ENOMEM;
251 }
252 dev->isoc_ctl.urb[i] = urb;
253
254 dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(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"
258 " buffer %i%s\n",
259 sb_size, i,
260 in_interrupt() ? " while in int" : "");
261 au0828_uninit_isoc(dev);
262 return -ENOMEM;
263 }
264 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
265
266 pipe = usb_rcvisocpipe(dev->usbdev,
267 dev->isoc_in_endpointaddr),
268
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);
272
273 urb->number_of_packets = max_packets;
274 urb->transfer_flags = URB_ISO_ASAP;
275
276 k = 0;
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;
282 }
283 }
284
285 init_waitqueue_head(&dma_q->wq);
286
287 /* submit urbs and enables IRQ */
288 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
289 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
290 if (rc) {
291 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
292 i, rc);
293 au0828_uninit_isoc(dev);
294 return rc;
295 }
296 }
297
298 return 0;
299}
300
301/*
302 * Announces that a buffer were filled and request the next
303 */
304static inline void buffer_filled(struct au0828_dev *dev,
305 struct au0828_dmaqueue *dma_q,
306 struct au0828_buffer *buf)
307{
308 /* Advice that buffer was filled */
309 au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
310
311 buf->vb.state = VIDEOBUF_DONE;
312 buf->vb.field_count++;
313 do_gettimeofday(&buf->vb.ts);
314
315 dev->isoc_ctl.buf = NULL;
316
317 list_del(&buf->vb.queue);
318 wake_up(&buf->vb.done);
319}
320
321/*
322 * Identify the buffer header type and properly handles
323 */
324static void au0828_copy_video(struct au0828_dev *dev,
325 struct au0828_dmaqueue *dma_q,
326 struct au0828_buffer *buf,
327 unsigned char *p,
328 unsigned char *outp, unsigned long len)
329{
330 void *fieldstart, *startwrite, *startread;
331 int linesdone, currlinedone, offset, lencopy, remain;
332 int bytesperline = dev->width << 1; /* Assumes 16-bit depth @@@@ */
333
334 if (dma_q->pos + len > buf->vb.size)
335 len = buf->vb.size - dma_q->pos;
336
337 startread = p;
338 remain = len;
339
340 /* Interlaces frame */
341 if (buf->top_field)
342 fieldstart = outp;
343 else
344 fieldstart = outp + bytesperline;
345
346 linesdone = dma_q->pos / bytesperline;
347 currlinedone = dma_q->pos % bytesperline;
348 offset = linesdone * bytesperline * 2 + currlinedone;
349 startwrite = fieldstart + offset;
350 lencopy = bytesperline - currlinedone;
351 lencopy = lencopy > remain ? remain : lencopy;
352
353 if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
354 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
355 ((char *)startwrite + lencopy) -
356 ((char *)outp + buf->vb.size));
357 remain = (char *)outp + buf->vb.size - (char *)startwrite;
358 lencopy = remain;
359 }
360 if (lencopy <= 0)
361 return;
362 memcpy(startwrite, startread, lencopy);
363
364 remain -= lencopy;
365
366 while (remain > 0) {
367 startwrite += lencopy + bytesperline;
368 startread += lencopy;
369 if (bytesperline > remain)
370 lencopy = remain;
371 else
372 lencopy = bytesperline;
373
374 if ((char *)startwrite + lencopy > (char *)outp +
375 buf->vb.size) {
376 au0828_isocdbg("Overflow of %zi bytes past buffer end (2)\n",
377 ((char *)startwrite + lencopy) -
378 ((char *)outp + buf->vb.size));
379 lencopy = remain = (char *)outp + buf->vb.size -
380 (char *)startwrite;
381 }
382 if (lencopy <= 0)
383 break;
384
385 memcpy(startwrite, startread, lencopy);
386
387 remain -= lencopy;
388 }
389
390 if (offset > 1440) {
391 /* We have enough data to check for greenscreen */
392 if (outp[0] < 0x60 && outp[1440] < 0x60) {
393 dev->greenscreen_detected = 1;
394 }
395 }
396
397 dma_q->pos += len;
398}
399
400/*
401 * video-buf generic routine to get the next available buffer
402 */
403static inline void get_next_buf(struct au0828_dmaqueue *dma_q,
404 struct au0828_buffer **buf)
405{
406 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
407
408 if (list_empty(&dma_q->active)) {
409 au0828_isocdbg("No active queue to serve\n");
410 dev->isoc_ctl.buf = NULL;
411 *buf = NULL;
412 return;
413 }
414
415 /* Get the next buffer */
416 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
417 dev->isoc_ctl.buf = *buf;
418
419 return;
420}
421
422/*
423 * Controls the isoc copy of each urb packet
424 */
425static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
426{
427 struct au0828_buffer *buf;
428 struct au0828_dmaqueue *dma_q = urb->context;
429 unsigned char *outp = NULL;
430 int i, len = 0, rc = 1;
431 unsigned char *p;
432 unsigned char fbyte;
433
434 if (!dev)
435 return 0;
436
437 if ((dev->dev_state & DEV_DISCONNECTED) ||
438 (dev->dev_state & DEV_MISCONFIGURED))
439 return 0;
440
441 if (urb->status < 0) {
442 print_err_status(dev, -1, urb->status);
443 if (urb->status == -ENOENT)
444 return 0;
445 }
446
447 buf = dev->isoc_ctl.buf;
448 if (buf != NULL)
449 outp = videobuf_to_vmalloc(&buf->vb);
450
451 for (i = 0; i < urb->number_of_packets; i++) {
452 int status = urb->iso_frame_desc[i].status;
453
454 if (status < 0) {
455 print_err_status(dev, i, status);
456 if (urb->iso_frame_desc[i].status != -EPROTO)
457 continue;
458 }
459
460 if (urb->iso_frame_desc[i].actual_length <= 0) {
461 continue;
462 }
463 if (urb->iso_frame_desc[i].actual_length >
464 dev->max_pkt_size) {
465 au0828_isocdbg("packet bigger than packet size");
466 continue;
467 }
468
469 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
470 fbyte = p[0];
471 len = urb->iso_frame_desc[i].actual_length - 4;
472 p += 4;
473
474 if (fbyte & 0x80) {
475 len -= 4;
476 p += 4;
477 au0828_isocdbg("Video frame %s\n",
478 (fbyte & 0x40) ? "odd" : "even");
479 if (!(fbyte & 0x40)) {
480 if (buf != NULL)
481 buffer_filled(dev, dma_q, buf);
482 get_next_buf(dma_q, &buf);
483 if (buf == NULL) {
484 outp = NULL;
485 } else
486 outp = videobuf_to_vmalloc(&buf->vb);
487 }
488
489 if (buf != NULL) {
490 if (fbyte & 0x40) {
491 buf->top_field = 1;
492 } else {
493 buf->top_field = 0;
494 }
495 }
496
497 dma_q->pos = 0;
498 }
499 if (buf != NULL) {
500 au0828_copy_video(dev, dma_q, buf, p, outp, len);
501 }
502 }
503 return rc;
504}
505
506static int
507buffer_setup(struct videobuf_queue *vq, unsigned int *count,
508 unsigned int *size)
509{
510 struct au0828_fh *fh = vq->priv_data;
511 *size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
512
513 if (0 == *count)
514 *count = AU0828_DEF_BUF;
515
516 if (*count < AU0828_MIN_BUF)
517 *count = AU0828_MIN_BUF;
518 return 0;
519}
520
521/* This is called *without* dev->slock held; please keep it that way */
522static void free_buffer(struct videobuf_queue *vq, struct au0828_buffer *buf)
523{
524 struct au0828_fh *fh = vq->priv_data;
525 struct au0828_dev *dev = fh->dev;
526 unsigned long flags = 0;
527 if (in_interrupt())
528 BUG();
529
530 /* We used to wait for the buffer to finish here, but this didn't work
531 because, as we were keeping the state as VIDEOBUF_QUEUED,
532 videobuf_queue_cancel marked it as finished for us.
533 (Also, it could wedge forever if the hardware was misconfigured.)
534
535 This should be safe; by the time we get here, the buffer isn't
536 queued anymore. If we ever start marking the buffers as
537 VIDEOBUF_ACTIVE, it won't be, though.
538 */
539 spin_lock_irqsave(&dev->slock, flags);
540 if (dev->isoc_ctl.buf == buf)
541 dev->isoc_ctl.buf = NULL;
542 spin_unlock_irqrestore(&dev->slock, flags);
543
544 videobuf_vmalloc_free(&buf->vb);
545 buf->vb.state = VIDEOBUF_NEEDS_INIT;
546}
547
548static int
549buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
550 enum v4l2_field field)
551{
552 struct au0828_fh *fh = vq->priv_data;
553 struct au0828_buffer *buf = container_of(vb, struct au0828_buffer, vb);
554 struct au0828_dev *dev = fh->dev;
555 int rc = 0, urb_init = 0;
556
557 buf->vb.size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
558
559 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
560 return -EINVAL;
561
562 buf->vb.width = dev->width;
563 buf->vb.height = dev->height;
564 buf->vb.field = field;
565
566 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
567 rc = videobuf_iolock(vq, &buf->vb, NULL);
568 if (rc < 0) {
569 printk("videobuf_iolock failed\n");
570 goto fail;
571 }
572 }
573
574 if (!dev->isoc_ctl.num_bufs)
575 urb_init = 1;
576
577 if (urb_init) {
578 rc = au0828_init_isoc(dev, AU0828_ISO_PACKETS_PER_URB,
579 AU0828_MAX_ISO_BUFS, dev->max_pkt_size,
580 au0828_isoc_copy);
581 if (rc < 0) {
582 printk("au0828_init_isoc failed\n");
583 goto fail;
584 }
585 }
586
587 buf->vb.state = VIDEOBUF_PREPARED;
588 return 0;
589
590fail:
591 free_buffer(vq, buf);
592 return rc;
593}
594
595static void
596buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
597{
598 struct au0828_buffer *buf = container_of(vb,
599 struct au0828_buffer,
600 vb);
601 struct au0828_fh *fh = vq->priv_data;
602 struct au0828_dev *dev = fh->dev;
603 struct au0828_dmaqueue *vidq = &dev->vidq;
604
605 buf->vb.state = VIDEOBUF_QUEUED;
606 list_add_tail(&buf->vb.queue, &vidq->active);
607}
608
609static void buffer_release(struct videobuf_queue *vq,
610 struct videobuf_buffer *vb)
611{
612 struct au0828_buffer *buf = container_of(vb,
613 struct au0828_buffer,
614 vb);
615
616 free_buffer(vq, buf);
617}
618
619static struct videobuf_queue_ops au0828_video_qops = {
620 .buf_setup = buffer_setup,
621 .buf_prepare = buffer_prepare,
622 .buf_queue = buffer_queue,
623 .buf_release = buffer_release,
624};
625
626/* ------------------------------------------------------------------
627 V4L2 interface
628 ------------------------------------------------------------------*/
629
630static int au0828_i2s_init(struct au0828_dev *dev)
631{
632 /* Enable i2s mode */
633 au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
634 return 0;
635}
636
637/*
638 * Auvitek au0828 analog stream enable
639 * Please set interface0 to AS5 before enable the stream
640 */
641int au0828_analog_stream_enable(struct au0828_dev *d)
642{
643 dprintk(1, "au0828_analog_stream_enable called\n");
644 au0828_writereg(d, AU0828_SENSORCTRL_VBI_103, 0x00);
645 au0828_writereg(d, 0x106, 0x00);
646 /* set x position */
647 au0828_writereg(d, 0x110, 0x00);
648 au0828_writereg(d, 0x111, 0x00);
649 au0828_writereg(d, 0x114, 0xa0);
650 au0828_writereg(d, 0x115, 0x05);
651 /* set y position */
652 au0828_writereg(d, 0x112, 0x02);
653 au0828_writereg(d, 0x113, 0x00);
654 au0828_writereg(d, 0x116, 0xf2);
655 au0828_writereg(d, 0x117, 0x00);
656 au0828_writereg(d, AU0828_SENSORCTRL_100, 0xb3);
657
658 return 0;
659}
660
661int au0828_analog_stream_disable(struct au0828_dev *d)
662{
663 dprintk(1, "au0828_analog_stream_disable called\n");
664 au0828_writereg(d, AU0828_SENSORCTRL_100, 0x0);
665 return 0;
666}
667
668void au0828_analog_stream_reset(struct au0828_dev *dev)
669{
670 dprintk(1, "au0828_analog_stream_reset called\n");
671 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0x0);
672 mdelay(30);
673 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0xb3);
674}
675
676/*
677 * Some operations needs to stop current streaming
678 */
679static int au0828_stream_interrupt(struct au0828_dev *dev)
680{
681 int ret = 0;
682
683 dev->stream_state = STREAM_INTERRUPT;
684 if(dev->dev_state == DEV_DISCONNECTED)
685 return -ENODEV;
686 else if(ret) {
687 dev->dev_state = DEV_MISCONFIGURED;
688 dprintk(1, "%s device is misconfigured!\n", __FUNCTION__);
689 return ret;
690 }
691 return 0;
692}
693
694/*
695 * au0828_release_resources
696 * unregister v4l2 devices
697 */
698void au0828_analog_unregister(struct au0828_dev *dev)
699{
700 dprintk(1, "au0828_release_resources called\n");
701 mutex_lock(&au0828_sysfs_lock);
702
2eaf3960
DH		 703 if (dev->vdev) {
704 list_del(&dev->au0828list);
5a5a4e16 705 video_unregister_device(dev->vdev);
2eaf3960 706 }
5a5a4e16
DH		 707 if (dev->vbi_dev)
708 video_unregister_device(dev->vbi_dev);
8b2f0795
DH		 709
710 mutex_unlock(&au0828_sysfs_lock);
711}
712
713
714/* Usage lock check functions */
715static int res_get(struct au0828_fh *fh)
716{
717 struct au0828_dev *dev = fh->dev;
718 int rc = 0;
719
720 /* This instance already has stream_on */
721 if (fh->stream_on)
722 return rc;
723
724 if (dev->stream_on)
725 return -EBUSY;
726
727 dev->stream_on = 1;
728 fh->stream_on = 1;
729 return rc;
730}
731
732static int res_check(struct au0828_fh *fh)
733{
734 return fh->stream_on;
735}
736
737static void res_free(struct au0828_fh *fh)
738{
739 struct au0828_dev *dev = fh->dev;
740
741 fh->stream_on = 0;
742 dev->stream_on = 0;
743}
744
745static int au0828_v4l2_open(struct file *filp)
746{
747 int minor = video_devdata(filp)->minor;
748 int ret = 0;
749 struct au0828_dev *h, *dev = NULL;
750 struct au0828_fh *fh;
751 int type = 0;
752 struct list_head *list;
753
754 list_for_each(list, &au0828_devlist) {
755 h = list_entry(list, struct au0828_dev, au0828list);
756 if(h->vdev->minor == minor) {
757 dev = h;
758 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
759 }
5a5a4e16 760#ifdef VBI_NOT_YET_WORKING
8b2f0795
DH		 761 if(h->vbi_dev->minor == minor) {
762 dev = h;
763 type = V4L2_BUF_TYPE_VBI_CAPTURE;
764 }
5a5a4e16 765#endif
8b2f0795
DH		 766 }
767
768 if(NULL == dev)
769 return -ENODEV;
770
771 fh = kzalloc(sizeof(struct au0828_fh), GFP_KERNEL);
772 if(NULL == fh) {
773 dprintk(1, "Failed allocate au0828_fh struct!\n");
774 return -ENOMEM;
775 }
776
777 fh->type = type;
778 fh->dev = dev;
779 filp->private_data = fh;
780
781 if(fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
782 /* set au0828 interface0 to AS5 here again */
783 ret = usb_set_interface(dev->usbdev, 0, 5);
784 if(ret < 0) {
785 printk("Au0828 can't set alt setting to 5!\n");
786 return -EBUSY;
787 }
788 dev->width = NTSC_STD_W;
789 dev->height = NTSC_STD_H;
790 dev->frame_size = dev->width * dev->height * 2;
791 dev->field_size = dev->width * dev->height;
792 dev->bytesperline = dev->width * 2;
793
794 au0828_analog_stream_enable(dev);
795 au0828_analog_stream_reset(dev);
796
797 /* If we were doing ac97 instead of i2s, it would go here...*/
798 au0828_i2s_init(dev);
799
800 dev->stream_state = STREAM_OFF;
801 dev->dev_state |= DEV_INITIALIZED;
802 }
803
804 dev->users++;
805
806 videobuf_queue_vmalloc_init(&fh->vb_vidq, &au0828_video_qops,
807 NULL, &dev->slock, fh->type,
808 V4L2_FIELD_INTERLACED,
809 sizeof(struct au0828_buffer), fh);
810
811 return ret;
812}
813
814static int au0828_v4l2_close(struct file *filp)
815{
816 int ret;
817 struct au0828_fh *fh = filp->private_data;
818 struct au0828_dev *dev = fh->dev;
819
820 mutex_lock(&dev->lock);
821 if (res_check(fh))
822 res_free(fh);
823
824 if(dev->users == 1) {
825 videobuf_stop(&fh->vb_vidq);
826 videobuf_mmap_free(&fh->vb_vidq);
827
828 if(dev->dev_state & DEV_DISCONNECTED) {
829 au0828_analog_unregister(dev);
830 mutex_unlock(&dev->lock);
831 kfree(dev);
832 return 0;
833 }
834
835 au0828_analog_stream_disable(dev);
836
837 au0828_uninit_isoc(dev);
838
839 /* When close the device, set the usb intf0 into alt0 to free
840 USB bandwidth */
841 ret = usb_set_interface(dev->usbdev, 0, 0);
842 if(ret < 0)
843 printk("Au0828 can't set alt setting to 0!\n");
844 }
845
846 kfree(fh);
847 dev->users--;
848 wake_up_interruptible_nr(&dev->open, 1);
849 mutex_unlock(&dev->lock);
850 return 0;
851}
852
853static ssize_t au0828_v4l2_read(struct file *filp, char __user *buf,
854 size_t count, loff_t *pos)
855{
856 struct au0828_fh *fh = filp->private_data;
857 struct au0828_dev *dev = fh->dev;
858 int rc;
859
860 rc = check_dev(dev);
861 if (rc < 0)
862 return rc;
863
864 if(fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
865 mutex_lock(&dev->lock);
866 rc = res_get(fh);
867 mutex_unlock(&dev->lock);
868
869 if (unlikely(rc < 0))
870 return rc;
871
872 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
873 filp->f_flags & O_NONBLOCK);
874 }
875 return 0;
876}
877
878static unsigned int au0828_v4l2_poll(struct file *filp, poll_table *wait)
879{
880 struct au0828_fh *fh = filp->private_data;
881 struct au0828_dev *dev = fh->dev;
882 int rc;
883
884 rc = check_dev(dev);
885 if (rc < 0)
886 return rc;
887
888 mutex_lock(&dev->lock);
889 rc = res_get(fh);
890 mutex_unlock(&dev->lock);
891
892 if (unlikely(rc < 0))
893 return POLLERR;
894
895 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
896 return POLLERR;
897
898 return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
899}
900
901static int au0828_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
902{
903 struct au0828_fh *fh = filp->private_data;
904 struct au0828_dev *dev = fh->dev;
905 int rc;
906
907 rc = check_dev(dev);
908 if (rc < 0)
909 return rc;
910
911 mutex_lock(&dev->lock);
912 rc = res_get(fh);
913 mutex_unlock(&dev->lock);
914
915 if (unlikely(rc < 0))
916 return rc;
917
918 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
919
920 dprintk(2, "vma start=0x%08lx, size=%ld, ret=%d\n",
921 (unsigned long)vma->vm_start,
922 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
923 rc);
924
925 return rc;
926}
927
928static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
929 struct v4l2_format *format)
930{
931 int ret;
932 int width = format->fmt.pix.width;
933 int height = format->fmt.pix.height;
934 unsigned int maxwidth, maxheight;
935
936 maxwidth = 720;
937 maxheight = 480;
938
5a5a4e16 939#ifdef VBI_NOT_YET_WORKING
8b2f0795
DH		 940 if(format->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
941 dprintk(1, "VBI format set: to be supported!\n");
942 return 0;
943 }
944 if(format->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
945 return 0;
946 }
5a5a4e16 947#endif
8b2f0795
DH		 948 if(format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
949 return -EINVAL;
950 }
951
952 /* If they are demanding a format other than the one we support,
953 bail out (tvtime asks for UYVY and then retries with YUYV) */
954 if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY) {
955 return -EINVAL;
956 }
957
958 /* format->fmt.pix.width only support 720 and height 480 */
959 if(width != 720)
960 width = 720;
961 if(height != 480)
962 height = 480;
963
964 format->fmt.pix.width = width;
965 format->fmt.pix.height = height;
966 format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
967 format->fmt.pix.bytesperline = width * 2;
968 format->fmt.pix.sizeimage = width * height * 2;
969 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
970 format->fmt.pix.field = V4L2_FIELD_INTERLACED;
971
972 if(cmd == VIDIOC_TRY_FMT)
973 return 0;
974
975 /* maybe set new image format, driver current only support 720*480 */
976 dev->width = width;
977 dev->height = height;
978 dev->frame_size = width * height * 2;
979 dev->field_size = width * height;
980 dev->bytesperline = width * 2;
981
982 if(dev->stream_state == STREAM_ON) {
983 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
984 if((ret = au0828_stream_interrupt(dev))) {
985 dprintk(1, "error interrupting video stream!\n");
986 return ret;
987 }
988 }
989
990 /* set au0828 interface0 to AS5 here again */
991 ret = usb_set_interface(dev->usbdev, 0, 5);
992 if(ret < 0) {
993 printk("Au0828 can't set alt setting to 5!\n");
994 return -EBUSY;
995 }
996
997 au0828_analog_stream_enable(dev);
998
999 return 0;
1000}
1001
1002
1003static int vidioc_queryctrl(struct file *file, void *priv,
1004 struct v4l2_queryctrl *qc)
1005{
1006 struct au0828_fh *fh = priv;
1007 struct au0828_dev *dev = fh->dev;
1008 au0828_call_i2c_clients(dev, VIDIOC_QUERYCTRL, qc);
1009 if (qc->type)
1010 return 0;
1011 else
1012 return -EINVAL;
1013}
1014
1015static int vidioc_querycap(struct file *file, void *priv,
1016 struct v4l2_capability *cap)
1017{
1018 struct au0828_fh *fh = priv;
1019 struct au0828_dev *dev = fh->dev;
1020
8b2f0795 1021 strlcpy(cap->driver, "au0828", sizeof(cap->driver));
f1add5b5 1022 strlcpy(cap->card, dev->board.name, sizeof(cap->card));
b14667f3 1023 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
8b2f0795
DH		 1024
1025 cap->version = AU0828_VERSION_CODE;
1026
1027 /*set the device capabilities */
5a5a4e16
DH		 1028 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1029#ifdef VBI_NOT_YET_WORKING
1030 V4L2_CAP_VBI_CAPTURE |
1031#endif
8b2f0795
DH		 1032 V4L2_CAP_AUDIO |
1033 V4L2_CAP_READWRITE |
1034 V4L2_CAP_STREAMING |
1035 V4L2_CAP_TUNER;
1036 return 0;
1037}
1038
1039static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1040 struct v4l2_fmtdesc *f)
1041{
1042 if(f->index)
1043 return -EINVAL;
1044
8b2f0795
DH		 1045 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1046 strcpy(f->description, "Packed YUV2");
1047
1048 f->flags = 0;
1049 f->pixelformat = V4L2_PIX_FMT_UYVY;
1050
8b2f0795
DH		 1051 return 0;
1052}
1053
1054static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1055 struct v4l2_format *f)
1056{
1057 struct au0828_fh *fh = priv;
1058 struct au0828_dev *dev = fh->dev;
1059
1060 f->fmt.pix.width = dev->width;
1061 f->fmt.pix.height = dev->height;
1062 f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1063 f->fmt.pix.bytesperline = dev->bytesperline;
1064 f->fmt.pix.sizeimage = dev->frame_size;
1065 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
1066 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1067 return 0;
1068}
1069
1070static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1071 struct v4l2_format *f)
1072{
1073 struct au0828_fh *fh = priv;
1074 struct au0828_dev *dev = fh->dev;
1075
1076 return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1077}
1078
1079static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1080 struct v4l2_format *f)
1081{
1082 struct au0828_fh *fh = priv;
1083 struct au0828_dev *dev = fh->dev;
1084 int rc;
1085
1086 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1087 printk("%s queue busy\n", __func__);
1088 rc = -EBUSY;
1089 goto out;
1090 }
1091
1092 if (dev->stream_on && !fh->stream_on) {
1093 printk("%s device in use by another fh\n", __func__);
1094 rc = -EBUSY;
1095 goto out;
1096 }
1097
1098 return au0828_set_format(dev, VIDIOC_S_FMT, f);
1099out:
1100 return rc;
1101}
1102
1103static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id * norm)
1104{
1105 struct au0828_fh *fh = priv;
1106 struct au0828_dev *dev = fh->dev;
1107
1108 /* FIXME: when we support something other than NTSC, we are going to
1109 have to make the au0828 bridge adjust the size of its capture
1110 buffer, which is currently hardcoded at 720x480 */
1111
1112 au0828_call_i2c_clients(dev, VIDIOC_S_STD, norm);
1113 return 0;
1114}
1115
1116static int vidioc_enum_input(struct file *file, void *priv,
1117 struct v4l2_input *input)
1118{
1119 struct au0828_fh *fh = priv;
1120 struct au0828_dev *dev = fh->dev;
1121 unsigned int tmp;
1122
1123 static const char *inames[] = {
3d62287e 1124 [AU0828_VMUX_UNDEFINED] = "Undefined",
8b2f0795
DH		 1125 [AU0828_VMUX_COMPOSITE] = "Composite",
1126 [AU0828_VMUX_SVIDEO] = "S-Video",
1127 [AU0828_VMUX_CABLE] = "Cable TV",
1128 [AU0828_VMUX_TELEVISION] = "Television",
1129 [AU0828_VMUX_DVB] = "DVB",
1130 [AU0828_VMUX_DEBUG] = "tv debug"
1131 };
1132
1133 tmp = input->index;
1134
1135 if(tmp > AU0828_MAX_INPUT)
1136 return -EINVAL;
f1add5b5 1137 if(AUVI_INPUT(tmp).type == 0)
8b2f0795
DH		 1138 return -EINVAL;
1139
8b2f0795 1140 input->index = tmp;
f1add5b5
DH		 1141 strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
1142 if((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
1143 (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE))
8b2f0795
DH		 1144 input->type |= V4L2_INPUT_TYPE_TUNER;
1145 else
1146 input->type |= V4L2_INPUT_TYPE_CAMERA;
1147
1148 input->std = dev->vdev->tvnorms;
1149
1150 return 0;
1151}
1152
1153static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1154{
1155 struct au0828_fh *fh = priv;
1156 struct au0828_dev *dev = fh->dev;
1157 *i = dev->ctrl_input;
1158 return 0;
1159}
1160
1161static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1162{
1163 struct au0828_fh *fh = priv;
1164 struct au0828_dev *dev = fh->dev;
1165 int i;
1166 struct v4l2_routing route;
1167
1168 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __FUNCTION__,
1169 index);
1170 if(index >= AU0828_MAX_INPUT)
1171 return -EINVAL;
f1add5b5 1172 if(AUVI_INPUT(index).type == 0)
8b2f0795
DH		 1173 return -EINVAL;
1174 dev->ctrl_input = index;
1175
f1add5b5 1176 switch(AUVI_INPUT(index).type) {
8b2f0795 1177 case AU0828_VMUX_SVIDEO:
8b2f0795
DH		 1178 dev->input_type = AU0828_VMUX_SVIDEO;
1179 break;
8b2f0795 1180 case AU0828_VMUX_COMPOSITE:
8b2f0795
DH		 1181 dev->input_type = AU0828_VMUX_COMPOSITE;
1182 break;
8b2f0795 1183 case AU0828_VMUX_TELEVISION:
8b2f0795
DH		 1184 dev->input_type = AU0828_VMUX_TELEVISION;
1185 break;
8b2f0795 1186 default:
a1094c4c
DH		 1187 dprintk(1, "VIDIOC_S_INPUT unknown input type set [%d]\n",
1188 AUVI_INPUT(index).type);
1189 break;
8b2f0795
DH		 1190 }
1191
f1add5b5 1192 route.input = AUVI_INPUT(index).vmux;
8b2f0795
DH		 1193 route.output = 0;
1194 au0828_call_i2c_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
1195
1196 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1197 int enable = 0;
f1add5b5 1198 if (AUVI_INPUT(i).audio_setup == NULL) {
8b2f0795
DH		 1199 continue;
1200 }
1201
1202 if (i == index)
1203 enable = 1;
1204 else
1205 enable = 0;
1206 if (enable) {
f1add5b5 1207 (AUVI_INPUT(i).audio_setup)(dev, enable);
8b2f0795
DH		 1208 } else {
1209 /* Make sure we leave it turned on if some
1210 other input is routed to this callback */
f1add5b5
DH		 1211 if ((AUVI_INPUT(i).audio_setup) !=
1212 ((AUVI_INPUT(index).audio_setup))) {
1213 (AUVI_INPUT(i).audio_setup)(dev, enable);
8b2f0795
DH		 1214 }
1215 }
1216 }
1217
f1add5b5 1218 route.input = AUVI_INPUT(index).amux;
8b2f0795
DH		 1219 au0828_call_i2c_clients(dev, VIDIOC_INT_S_AUDIO_ROUTING,
1220 &route);
1221 return 0;
1222}
1223
1224static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1225{
1226 struct au0828_fh *fh = priv;
1227 struct au0828_dev *dev = fh->dev;
1228 unsigned int index = a->index;
1229
1230 if(a->index > 1)
1231 return -EINVAL;
1232
8b2f0795
DH		 1233 index = dev->ctrl_ainput;
1234 if(index == 0)
1235 strcpy(a->name, "Television");
1236 else
1237 strcpy(a->name, "Line in");
1238
1239 a->capability = V4L2_AUDCAP_STEREO;
1240 a->index = index;
1241 return 0;
1242}
1243
1244static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
1245{
1246 struct au0828_fh *fh = priv;
1247 struct au0828_dev *dev = fh->dev;
1248 if(a->index != dev->ctrl_ainput)
1249 return -EINVAL;
1250 return 0;
1251}
1252
1253static int vidioc_g_ctrl(struct file *file, void *priv,
1254 struct v4l2_control *ctrl)
1255{
1256 struct au0828_fh *fh = priv;
1257 struct au0828_dev *dev = fh->dev;
1258
1259 au0828_call_i2c_clients(dev, VIDIOC_G_CTRL, ctrl);
1260 return 0;
1261
1262}
1263
1264static int vidioc_s_ctrl(struct file *file, void *priv,
1265 struct v4l2_control *ctrl)
1266{
1267 struct au0828_fh *fh = priv;
1268 struct au0828_dev *dev = fh->dev;
1269 au0828_call_i2c_clients(dev, VIDIOC_S_CTRL, ctrl);
1270 return 0;
1271}
1272
1273static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1274{
1275 struct au0828_fh *fh = priv;
1276 struct au0828_dev *dev = fh->dev;
1277
1278 if(t->index != 0)
1279 return -EINVAL;
1280
8b2f0795
DH		 1281 strcpy(t->name, "Auvitek tuner");
1282
1283 au0828_call_i2c_clients(dev, VIDIOC_G_TUNER, t);
1284 return 0;
1285}
1286
1287static int vidioc_s_tuner(struct file *file, void *priv,
1288 struct v4l2_tuner *t)
1289{
1290 struct au0828_fh *fh = priv;
1291 struct au0828_dev *dev = fh->dev;
1292
1293 if(t->index != 0)
1294 return -EINVAL;
1295
1296 t->type = V4L2_TUNER_ANALOG_TV;
1297 au0828_call_i2c_clients(dev, VIDIOC_S_TUNER, t);
1298 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1299 t->afc);
1300 return 0;
1301
1302}
1303
1304static int vidioc_g_frequency(struct file *file, void *priv,
1305 struct v4l2_frequency *freq)
1306{
1307 struct au0828_fh *fh = priv;
1308 struct au0828_dev *dev = fh->dev;
c888923d 1309
8b2f0795
DH		 1310 freq->type = V4L2_TUNER_ANALOG_TV;
1311 freq->frequency = dev->ctrl_freq;
1312 return 0;
1313}
1314
1315static int vidioc_s_frequency(struct file *file, void *priv,
1316 struct v4l2_frequency *freq)
1317{
1318 struct au0828_fh *fh = priv;
1319 struct au0828_dev *dev = fh->dev;
1320
1321 if(freq->tuner != 0)
1322 return -EINVAL;
1323 if(freq->type != V4L2_TUNER_ANALOG_TV)
1324 return -EINVAL;
1325
1326 dev->ctrl_freq = freq->frequency;
1327
1328 au0828_call_i2c_clients(dev, VIDIOC_S_FREQUENCY, freq);
1329
1330 au0828_analog_stream_reset(dev);
1331
1332 return 0;
1333}
1334
1335static int vidioc_g_chip_ident(struct file *file, void *priv,
1336 struct v4l2_dbg_chip_ident *chip)
1337{
1338 struct au0828_fh *fh = priv;
1339 struct au0828_dev *dev = fh->dev;
1340 chip->ident = V4L2_IDENT_NONE;
1341 chip->revision = 0;
1342
d9109bef
DH		 1343 if (v4l2_chip_match_host(&chip->match)) {
1344 chip->ident = V4L2_IDENT_AU0828;
1345 return 0;
1346 }
1347
8b2f0795 1348 au0828_call_i2c_clients(dev, VIDIOC_DBG_G_CHIP_IDENT, chip);
d9109bef
DH		 1349 if (chip->ident == V4L2_IDENT_NONE)
1350 return -EINVAL;
1351
8b2f0795
DH		 1352 return 0;
1353}
1354
1355static int vidioc_cropcap(struct file *file, void *priv,
1356 struct v4l2_cropcap *cc)
1357{
1358 struct au0828_fh *fh = priv;
1359 struct au0828_dev *dev = fh->dev;
1360
1361 if(cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1362 return -EINVAL;
1363
1364 cc->bounds.left = 0;
1365 cc->bounds.top = 0;
1366 cc->bounds.width = dev->width;
1367 cc->bounds.height = dev->height;
1368
1369 cc->defrect = cc->bounds;
1370
1371 cc->pixelaspect.numerator = 54;
1372 cc->pixelaspect.denominator = 59;
1373
1374 return 0;
1375}
1376
1377static int vidioc_streamon(struct file *file, void *priv,
1378 enum v4l2_buf_type type)
1379{
1380 struct au0828_fh *fh = priv;
1381 struct au0828_dev *dev = fh->dev;
1382 int b = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1383 int rc;
1384
1385 rc = check_dev(dev);
1386 if (rc < 0)
1387 return rc;
1388
1389 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1390 au0828_analog_stream_enable(dev);
1391 au0828_call_i2c_clients(dev, VIDIOC_STREAMON, &b);
1392 }
1393
1394 mutex_lock(&dev->lock);
1395 rc = res_get(fh);
1396
1397 if (likely(rc >= 0))
1398 rc = videobuf_streamon(&fh->vb_vidq);
1399 mutex_unlock(&dev->lock);
1400
1401 return rc;
1402}
1403
1404static int vidioc_streamoff(struct file *file, void *priv,
1405 enum v4l2_buf_type type)
1406{
1407 struct au0828_fh *fh = priv;
1408 struct au0828_dev *dev = fh->dev;
1409 int b = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1410 int i;
1411 int ret;
1412 int rc;
1413
1414 rc = check_dev(dev);
1415 if (rc < 0)
1416 return rc;
1417
1418 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1419 return -EINVAL;
1420 if (type != fh->type)
1421 return -EINVAL;
1422
1423 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1424 au0828_call_i2c_clients(dev, VIDIOC_STREAMOFF, &b);
1425 if((ret = au0828_stream_interrupt(dev)) != 0)
1426 return ret;
1427 }
1428
1429 for (i = 0; i < AU0828_MAX_INPUT; i++) {
f1add5b5 1430 if (AUVI_INPUT(i).audio_setup == NULL) {
8b2f0795
DH		 1431 continue;
1432 }
f1add5b5 1433 (AUVI_INPUT(i).audio_setup)(dev, 0);
8b2f0795
DH		 1434 }
1435
1436 mutex_lock(&dev->lock);
1437 videobuf_streamoff(&fh->vb_vidq);
1438 res_free(fh);
1439 mutex_unlock(&dev->lock);
1440
1441 return 0;
1442}
1443
1444static int vidioc_g_register(struct file *file, void *priv,
1445 struct v4l2_dbg_register *reg)
1446{
1447 struct au0828_fh *fh = priv;
1448 struct au0828_dev *dev = fh->dev;
1449
1450 switch (reg->match.type) {
1451 case V4L2_CHIP_MATCH_I2C_DRIVER:
1452 au0828_call_i2c_clients(dev, VIDIOC_DBG_G_REGISTER, reg);
1453 return 0;
1454 default:
1455 return -EINVAL;
1456 }
1457}
1458
1459static int vidioc_s_register(struct file *file, void *priv,
1460 struct v4l2_dbg_register *reg)
1461{
1462 struct au0828_fh *fh = priv;
1463 struct au0828_dev *dev = fh->dev;
1464
1465 switch (reg->match.type) {
1466 case V4L2_CHIP_MATCH_I2C_DRIVER:
1467 au0828_call_i2c_clients(dev, VIDIOC_DBG_S_REGISTER, reg);
1468 return 0;
1469 default:
1470 return -EINVAL;
1471 }
1472 return 0;
1473}
1474
1475static int vidioc_reqbufs(struct file *file, void *priv,
1476 struct v4l2_requestbuffers *rb)
1477{
1478 struct au0828_fh *fh = priv;
1479 struct au0828_dev *dev = fh->dev;
1480 int rc;
1481
1482 rc = check_dev(dev);
1483 if (rc < 0)
1484 return rc;
1485
1486 return videobuf_reqbufs(&fh->vb_vidq, rb);
1487}
1488
1489static int vidioc_querybuf(struct file *file, void *priv,
1490 struct v4l2_buffer *b)
1491{
1492 struct au0828_fh *fh = priv;
1493 struct au0828_dev *dev = fh->dev;
1494 int rc;
1495
1496 rc = check_dev(dev);
1497 if (rc < 0)
1498 return rc;
1499
1500 return videobuf_querybuf(&fh->vb_vidq, b);
1501}
1502
1503static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1504{
1505 struct au0828_fh *fh = priv;
1506 struct au0828_dev *dev = fh->dev;
1507 int rc;
1508
1509 rc = check_dev(dev);
1510 if (rc < 0)
1511 return rc;
1512
1513 return videobuf_qbuf(&fh->vb_vidq, b);
1514}
1515
1516static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1517{
1518 struct au0828_fh *fh = priv;
1519 struct au0828_dev *dev = fh->dev;
1520 int rc;
1521
1522 rc = check_dev(dev);
1523 if (rc < 0)
1524 return rc;
1525
1526 /* Workaround for a bug in the au0828 hardware design that sometimes
1527 results in the colorspace being inverted */
1528 if (dev->greenscreen_detected == 1) {
1529 dprintk(1, "Detected green frame. Resetting stream...\n");
1530 au0828_analog_stream_reset(dev);
1531 dev->greenscreen_detected = 0;
1532 }
1533
1534 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1535}
1536
1537#ifdef CONFIG_VIDEO_V4L1_COMPAT
1538static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1539{
1540 struct au0828_fh *fh = priv;
1541
1542 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1543}
1544#endif
1545
1546static struct v4l2_file_operations au0828_v4l_fops = {
1547 .owner = THIS_MODULE,
1548 .open = au0828_v4l2_open,
1549 .release = au0828_v4l2_close,
1550 .read = au0828_v4l2_read,
1551 .poll = au0828_v4l2_poll,
1552 .mmap = au0828_v4l2_mmap,
1553 .ioctl = video_ioctl2,
1554};
1555
1556static const struct v4l2_ioctl_ops video_ioctl_ops = {
1557 .vidioc_querycap = vidioc_querycap,
1558 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1559 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1560 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1561 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
5a5a4e16
DH		 1562#ifdef VBI_NOT_YET_WORKING
1563 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1564 .vidioc_try_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
1565 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
1566#endif
8b2f0795
DH		 1567 .vidioc_g_audio = vidioc_g_audio,
1568 .vidioc_s_audio = vidioc_s_audio,
1569 .vidioc_cropcap = vidioc_cropcap,
5a5a4e16 1570#ifdef VBI_NOT_YET_WORKING
8b2f0795
DH		 1571 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
1572 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
1573 .vidioc_s_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
1574#endif
1575 .vidioc_reqbufs = vidioc_reqbufs,
1576 .vidioc_querybuf = vidioc_querybuf,
1577 .vidioc_qbuf = vidioc_qbuf,
1578 .vidioc_dqbuf = vidioc_dqbuf,
1579 .vidioc_s_std = vidioc_s_std,
1580 .vidioc_enum_input = vidioc_enum_input,
1581 .vidioc_g_input = vidioc_g_input,
1582 .vidioc_s_input = vidioc_s_input,
1583 .vidioc_queryctrl = vidioc_queryctrl,
1584 .vidioc_g_ctrl = vidioc_g_ctrl,
1585 .vidioc_s_ctrl = vidioc_s_ctrl,
1586 .vidioc_streamon = vidioc_streamon,
1587 .vidioc_streamoff = vidioc_streamoff,
1588 .vidioc_g_tuner = vidioc_g_tuner,
1589 .vidioc_s_tuner = vidioc_s_tuner,
1590 .vidioc_g_frequency = vidioc_g_frequency,
1591 .vidioc_s_frequency = vidioc_s_frequency,
1592#ifdef CONFIG_VIDEO_ADV_DEBUG
1593 .vidioc_g_register = vidioc_g_register,
1594 .vidioc_s_register = vidioc_s_register,
1595 .vidioc_g_chip_ident = vidioc_g_chip_ident,
1596#endif
1597#ifdef CONFIG_VIDEO_V4L1_COMPAT
1598 .vidiocgmbuf = vidiocgmbuf,
1599#endif
1600};
1601
1602static const struct video_device au0828_video_template = {
1603 .fops = &au0828_v4l_fops,
1604 .release = video_device_release,
1605 .ioctl_ops = &video_ioctl_ops,
1606 .minor = -1,
0ef21071
DH		 1607 .tvnorms = V4L2_STD_NTSC_M,
1608 .current_norm = V4L2_STD_NTSC_M,
8b2f0795
DH		 1609};
1610
1611/**************************************************************************/
1612
fc4ce6cd
DH		 1613int au0828_analog_register(struct au0828_dev *dev,
1614 struct usb_interface *interface)
8b2f0795
DH		 1615{
1616 int retval = -ENOMEM;
fc4ce6cd
DH		 1617 struct usb_host_interface *iface_desc;
1618 struct usb_endpoint_descriptor *endpoint;
1619 int i;
8b2f0795
DH		 1620
1621 dprintk(1, "au0828_analog_register called!\n");
1622
fc4ce6cd
DH		 1623 /* set au0828 usb interface0 to as5 */
1624 retval = usb_set_interface(dev->usbdev,
1625 interface->cur_altsetting->desc.bInterfaceNumber, 5);
1626 if (retval != 0) {
1627 printk("Failure setting usb interface0 to as5\n");
1628 return retval;
1629 }
1630
1631 /* Figure out which endpoint has the isoc interface */
1632 iface_desc = interface->cur_altsetting;
1633 for(i = 0; i < iface_desc->desc.bNumEndpoints; i++){
1634 endpoint = &iface_desc->endpoint[i].desc;
1635 if(((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) &&
1636 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)){
1637
1638 /* we find our isoc in endpoint */
1639 u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
1640 dev->max_pkt_size = (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1641 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1642 }
1643 }
1644 if(!(dev->isoc_in_endpointaddr)) {
1645 printk("Could not locate isoc endpoint\n");
1646 kfree(dev);
1647 return -ENODEV;
1648 }
1649
8b2f0795
DH		 1650 init_waitqueue_head(&dev->open);
1651 spin_lock_init(&dev->slock);
1652 mutex_init(&dev->lock);
1653
1654 INIT_LIST_HEAD(&dev->vidq.active);
1655 INIT_LIST_HEAD(&dev->vidq.queued);
1656
1657 dev->width = NTSC_STD_W;
1658 dev->height = NTSC_STD_H;
1659 dev->field_size = dev->width * dev->height;
1660 dev->frame_size = dev->field_size << 1;
1661 dev->bytesperline = dev->width << 1;
1662 dev->ctrl_ainput = 0;
1663
1664 /* allocate and fill v4l2 video struct */
1665 dev->vdev = video_device_alloc();
1666 if(NULL == dev->vdev) {
1667 dprintk(1, "Can't allocate video_device.\n");
1668 return -ENOMEM;
1669 }
1670
5a5a4e16 1671#ifdef VBI_NOT_YET_WORKING
8b2f0795
DH		 1672 dev->vbi_dev = video_device_alloc();
1673 if(NULL == dev->vbi_dev) {
1674 dprintk(1, "Can't allocate vbi_device.\n");
1675 kfree(dev->vdev);
1676 return -ENOMEM;
1677 }
5a5a4e16 1678#endif
8b2f0795
DH		 1679
1680 /* Fill the video capture device struct */
1681 *dev->vdev = au0828_video_template;
1682 dev->vdev->vfl_type = VID_TYPE_CAPTURE | VID_TYPE_TUNER;
1683 dev->vdev->parent = &dev->usbdev->dev;
1684 strcpy(dev->vdev->name, "au0828a video");
1685
5a5a4e16 1686#ifdef VBI_NOT_YET_WORKING
8b2f0795
DH		 1687 /* Setup the VBI device */
1688 *dev->vbi_dev = au0828_video_template;
1689 dev->vbi_dev->vfl_type = VFL_TYPE_VBI;
1690 dev->vbi_dev->parent = &dev->usbdev->dev;
1691 strcpy(dev->vbi_dev->name, "au0828a vbi");
5a5a4e16 1692#endif
8b2f0795
DH		 1693
1694 list_add_tail(&dev->au0828list, &au0828_devlist);
1695
1696 /* Register the v4l2 device */
1697 if((retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1)) != 0) {
1698 dprintk(1, "unable to register video device (error = %d).\n", retval);
1699 list_del(&dev->au0828list);
1700 video_device_release(dev->vdev);
1701 return -ENODEV;
1702 }
1703
5a5a4e16 1704#ifdef VBI_NOT_YET_WORKING
8b2f0795
DH		 1705 /* Register the vbi device */
1706 if((retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1)) != 0) {
1707 dprintk(1, "unable to register vbi device (error = %d).\n", retval);
1708 list_del(&dev->au0828list);
1709 video_device_release(dev->vbi_dev);
1710 video_device_release(dev->vdev);
1711 return -ENODEV;
1712 }
5a5a4e16 1713#endif
8b2f0795
DH		 1714
1715 dprintk(1, "%s completed!\n", __FUNCTION__);
1716
1717 return 0;
1718}
1719
Linux kernel - Deliverables
This page took 0.091045 seconds and 5 git commands to generate.