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