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