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