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