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