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