1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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
44static DEFINE_MUTEX(au0828_sysfs_lock);
45
46#define AU0828_VERSION_CODE KERNEL_VERSION(0, 0, 1)
47
48
49
50
51
52static unsigned int isoc_debug;
53module_param(isoc_debug, int, 0644);
54MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
55
56#define au0828_isocdbg(fmt, arg...) \
57do {\
58 if (isoc_debug) { \
59 printk(KERN_INFO "au0828 %s :"fmt, \
60 __func__ , ##arg); \
61 } \
62 } while (0)
63
64static 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
103static 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
120
121static 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:
130 case -ETIMEDOUT:
131 break;
132 case -ECONNRESET:
133 case -ENOENT:
134 case -ESHUTDOWN:
135 au0828_isocdbg("au0828_irq_callback called: status kill\n");
136 return;
137 default:
138 au0828_isocdbg("urb completition error %d.\n", urb->status);
139 break;
140 }
141
142
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
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
163
164void 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
202
203int 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
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
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
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
300
301static inline void buffer_filled(struct au0828_dev *dev,
302 struct au0828_dmaqueue *dma_q,
303 struct au0828_buffer *buf)
304{
305
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
318static inline void vbi_buffer_filled(struct au0828_dev *dev,
319 struct au0828_dmaqueue *dma_q,
320 struct au0828_buffer *buf)
321{
322
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
337
338static 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;
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
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
409 if (outp[0] < 0x60 && outp[1440] < 0x60)
410 dev->greenscreen_detected = 1;
411 }
412
413 dma_q->pos += len;
414}
415
416
417
418
419static 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
432 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
433 dev->isoc_ctl.buf = *buf;
434
435 return;
436}
437
438static 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
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
489
490static 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
504 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
505
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
516
517static 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
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
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
603
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
654static int
655buffer_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
670static 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
679
680
681
682
683
684
685
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
696static int
697buffer_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
738fail:
739 free_buffer(vq, buf);
740 return rc;
741}
742
743static void
744buffer_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
757static 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
767static 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
776
777
778static int au0828_i2s_init(struct au0828_dev *dev)
779{
780
781 au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
782 return 0;
783}
784
785
786
787
788
789int 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
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
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
809int 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
816void 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
826
827static 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
844
845
846void 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
861static 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
867 return 1;
868
869
870 mutex_lock(&dev->lock);
871 if (dev->resources & bit) {
872
873 mutex_unlock(&dev->lock);
874 return 0;
875 }
876
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
884static int res_check(struct au0828_fh *fh, unsigned int bit)
885{
886 return fh->resources & bit;
887}
888
889static int res_locked(struct au0828_dev *dev, unsigned int bit)
890{
891 return dev->resources & bit;
892}
893
894static 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
907static 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
921
922
923void 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);
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
947void 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
971static 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
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
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
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
1043static 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
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
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
1079 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
1080
1081
1082
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
1096static 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
1121
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
1133static 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
1156static 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
1174static 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
1189
1190 if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
1191 return -EINVAL;
1192
1193
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
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
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
1239static 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
1251static 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
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
1273static 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
1288static 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;
1300 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1301 return 0;
1302}
1303
1304static 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
1313static 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);
1333out:
1334 mutex_unlock(&dev->lock);
1335 return rc;
1336}
1337
1338static 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
1344
1345
1346
1347 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, *norm);
1348 return 0;
1349}
1350
1351static 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
1388static 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
1396static 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
1442
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
1455static 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
1475static 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
1484static 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
1495static 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
1504static 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
1517static 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
1534static 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
1545static 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
1567
1568static 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
1588static 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
1608static 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
1630static 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
1668static 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
1718static 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
1733static 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
1750static 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 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1762 rc = videobuf_reqbufs(&fh->vb_vidq, rb);
1763 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1764 rc = videobuf_reqbufs(&fh->vb_vbiq, rb);
1765
1766 return rc;
1767}
1768
1769static int vidioc_querybuf(struct file *file, void *priv,
1770 struct v4l2_buffer *b)
1771{
1772 struct au0828_fh *fh = priv;
1773 struct au0828_dev *dev = fh->dev;
1774 int rc;
1775
1776 rc = check_dev(dev);
1777 if (rc < 0)
1778 return rc;
1779
1780 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1781 rc = videobuf_querybuf(&fh->vb_vidq, b);
1782 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1783 rc = videobuf_querybuf(&fh->vb_vbiq, b);
1784
1785 return rc;
1786}
1787
1788static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1789{
1790 struct au0828_fh *fh = priv;
1791 struct au0828_dev *dev = fh->dev;
1792 int rc;
1793
1794 rc = check_dev(dev);
1795 if (rc < 0)
1796 return rc;
1797
1798 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1799 rc = videobuf_qbuf(&fh->vb_vidq, b);
1800 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1801 rc = videobuf_qbuf(&fh->vb_vbiq, b);
1802
1803 return rc;
1804}
1805
1806static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1807{
1808 struct au0828_fh *fh = priv;
1809 struct au0828_dev *dev = fh->dev;
1810 int rc;
1811
1812 rc = check_dev(dev);
1813 if (rc < 0)
1814 return rc;
1815
1816
1817
1818 if (dev->greenscreen_detected == 1) {
1819 dprintk(1, "Detected green frame. Resetting stream...\n");
1820 au0828_analog_stream_reset(dev);
1821 dev->greenscreen_detected = 0;
1822 }
1823
1824 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1825 rc = videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1826 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1827 rc = videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags & O_NONBLOCK);
1828
1829 return rc;
1830}
1831
1832static struct v4l2_file_operations au0828_v4l_fops = {
1833 .owner = THIS_MODULE,
1834 .open = au0828_v4l2_open,
1835 .release = au0828_v4l2_close,
1836 .read = au0828_v4l2_read,
1837 .poll = au0828_v4l2_poll,
1838 .mmap = au0828_v4l2_mmap,
1839 .ioctl = video_ioctl2,
1840};
1841
1842static const struct v4l2_ioctl_ops video_ioctl_ops = {
1843 .vidioc_querycap = vidioc_querycap,
1844 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1845 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1846 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1847 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1848 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1849 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1850 .vidioc_g_audio = vidioc_g_audio,
1851 .vidioc_s_audio = vidioc_s_audio,
1852 .vidioc_cropcap = vidioc_cropcap,
1853 .vidioc_reqbufs = vidioc_reqbufs,
1854 .vidioc_querybuf = vidioc_querybuf,
1855 .vidioc_qbuf = vidioc_qbuf,
1856 .vidioc_dqbuf = vidioc_dqbuf,
1857 .vidioc_s_std = vidioc_s_std,
1858 .vidioc_enum_input = vidioc_enum_input,
1859 .vidioc_g_input = vidioc_g_input,
1860 .vidioc_s_input = vidioc_s_input,
1861 .vidioc_queryctrl = vidioc_queryctrl,
1862 .vidioc_g_ctrl = vidioc_g_ctrl,
1863 .vidioc_s_ctrl = vidioc_s_ctrl,
1864 .vidioc_streamon = vidioc_streamon,
1865 .vidioc_streamoff = vidioc_streamoff,
1866 .vidioc_g_tuner = vidioc_g_tuner,
1867 .vidioc_s_tuner = vidioc_s_tuner,
1868 .vidioc_g_frequency = vidioc_g_frequency,
1869 .vidioc_s_frequency = vidioc_s_frequency,
1870#ifdef CONFIG_VIDEO_ADV_DEBUG
1871 .vidioc_g_register = vidioc_g_register,
1872 .vidioc_s_register = vidioc_s_register,
1873#endif
1874 .vidioc_g_chip_ident = vidioc_g_chip_ident,
1875};
1876
1877static const struct video_device au0828_video_template = {
1878 .fops = &au0828_v4l_fops,
1879 .release = video_device_release,
1880 .ioctl_ops = &video_ioctl_ops,
1881 .tvnorms = V4L2_STD_NTSC_M,
1882 .current_norm = V4L2_STD_NTSC_M,
1883};
1884
1885
1886
1887int au0828_analog_register(struct au0828_dev *dev,
1888 struct usb_interface *interface)
1889{
1890 int retval = -ENOMEM;
1891 struct usb_host_interface *iface_desc;
1892 struct usb_endpoint_descriptor *endpoint;
1893 int i;
1894
1895 dprintk(1, "au0828_analog_register called!\n");
1896
1897
1898 retval = usb_set_interface(dev->usbdev,
1899 interface->cur_altsetting->desc.bInterfaceNumber, 5);
1900 if (retval != 0) {
1901 printk(KERN_INFO "Failure setting usb interface0 to as5\n");
1902 return retval;
1903 }
1904
1905
1906 iface_desc = interface->cur_altsetting;
1907 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
1908 endpoint = &iface_desc->endpoint[i].desc;
1909 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1910 == USB_DIR_IN) &&
1911 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1912 == USB_ENDPOINT_XFER_ISOC)) {
1913
1914
1915 u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
1916 dev->max_pkt_size = (tmp & 0x07ff) *
1917 (((tmp & 0x1800) >> 11) + 1);
1918 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1919 }
1920 }
1921 if (!(dev->isoc_in_endpointaddr)) {
1922 printk(KERN_INFO "Could not locate isoc endpoint\n");
1923 kfree(dev);
1924 return -ENODEV;
1925 }
1926
1927 init_waitqueue_head(&dev->open);
1928 spin_lock_init(&dev->slock);
1929 mutex_init(&dev->lock);
1930
1931
1932 INIT_LIST_HEAD(&dev->vidq.active);
1933 INIT_LIST_HEAD(&dev->vidq.queued);
1934 INIT_LIST_HEAD(&dev->vbiq.active);
1935 INIT_LIST_HEAD(&dev->vbiq.queued);
1936
1937 dev->vid_timeout.function = au0828_vid_buffer_timeout;
1938 dev->vid_timeout.data = (unsigned long) dev;
1939 init_timer(&dev->vid_timeout);
1940
1941 dev->vbi_timeout.function = au0828_vbi_buffer_timeout;
1942 dev->vbi_timeout.data = (unsigned long) dev;
1943 init_timer(&dev->vbi_timeout);
1944
1945 dev->width = NTSC_STD_W;
1946 dev->height = NTSC_STD_H;
1947 dev->field_size = dev->width * dev->height;
1948 dev->frame_size = dev->field_size << 1;
1949 dev->bytesperline = dev->width << 1;
1950 dev->ctrl_ainput = 0;
1951
1952
1953 dev->vdev = video_device_alloc();
1954 if (NULL == dev->vdev) {
1955 dprintk(1, "Can't allocate video_device.\n");
1956 return -ENOMEM;
1957 }
1958
1959
1960 dev->vbi_dev = video_device_alloc();
1961 if (NULL == dev->vbi_dev) {
1962 dprintk(1, "Can't allocate vbi_device.\n");
1963 kfree(dev->vdev);
1964 return -ENOMEM;
1965 }
1966
1967
1968 *dev->vdev = au0828_video_template;
1969 dev->vdev->parent = &dev->usbdev->dev;
1970 strcpy(dev->vdev->name, "au0828a video");
1971
1972
1973 *dev->vbi_dev = au0828_video_template;
1974 dev->vbi_dev->parent = &dev->usbdev->dev;
1975 strcpy(dev->vbi_dev->name, "au0828a vbi");
1976
1977
1978 video_set_drvdata(dev->vdev, dev);
1979 retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
1980 if (retval != 0) {
1981 dprintk(1, "unable to register video device (error = %d).\n",
1982 retval);
1983 video_device_release(dev->vdev);
1984 return -ENODEV;
1985 }
1986
1987
1988 video_set_drvdata(dev->vbi_dev, dev);
1989 retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
1990 if (retval != 0) {
1991 dprintk(1, "unable to register vbi device (error = %d).\n",
1992 retval);
1993 video_device_release(dev->vbi_dev);
1994 video_device_release(dev->vdev);
1995 return -ENODEV;
1996 }
1997
1998 dprintk(1, "%s completed!\n", __func__);
1999
2000 return 0;
2001}
2002
2003
