This source file includes following definitions.
- i2c_gate_ctrl
- print_err_status
- check_dev
- au0828_irq_callback
- au0828_uninit_isoc
- au0828_init_isoc
- buffer_filled
- au0828_copy_video
- get_next_buf
- au0828_copy_vbi
- vbi_get_next_buf
- au0828_isoc_copy
- au0828_usb_v4l2_media_release
- au0828_usb_v4l2_release
- au0828_v4l2_device_register
- queue_setup
- buffer_prepare
- buffer_queue
- au0828_i2s_init
- au0828_analog_stream_enable
- au0828_analog_stream_disable
- au0828_analog_stream_reset
- au0828_stream_interrupt
- au0828_start_analog_streaming
- au0828_stop_streaming
- au0828_stop_vbi_streaming
- au0828_analog_unregister
- au0828_vid_buffer_timeout
- au0828_vbi_buffer_timeout
- au0828_v4l2_open
- au0828_v4l2_close
- au0828_init_tuner
- au0828_set_format
- vidioc_querycap
- vidioc_enum_fmt_vid_cap
- vidioc_g_fmt_vid_cap
- vidioc_try_fmt_vid_cap
- vidioc_s_fmt_vid_cap
- vidioc_s_std
- vidioc_g_std
- vidioc_enum_input
- vidioc_g_input
- au0828_s_input
- vidioc_s_input
- vidioc_enumaudio
- vidioc_g_audio
- vidioc_s_audio
- vidioc_g_tuner
- vidioc_s_tuner
- vidioc_g_frequency
- vidioc_s_frequency
- vidioc_g_fmt_vbi_cap
- vidioc_g_pixelaspect
- vidioc_g_selection
- vidioc_g_register
- vidioc_s_register
- vidioc_log_status
- au0828_v4l2_suspend
- au0828_v4l2_resume
- au0828_vb2_setup
- au0828_analog_create_entities
- au0828_analog_register
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
30 static DEFINE_MUTEX(au0828_sysfs_lock);
31
32
33
34
35
36 static unsigned int isoc_debug;
37 module_param(isoc_debug, int, 0644);
38 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
39
40 #define au0828_isocdbg(fmt, arg...) \
41 do {\
42 if (isoc_debug) { \
43 pr_info("au0828 %s :"fmt, \
44 __func__ , ##arg); \
45 } \
46 } while (0)
47
48 static 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
54 static 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
93 static 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
110 static 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
154 static 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
195 static 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
286 static 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
309 static 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
390 static 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
413 static 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
465 static 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
490 static 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
626 void 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
639 static 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
650 int 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
683 static 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
697 static int
698 buffer_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
716 static void
717 buffer_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
735 static 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
745 static 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
786 static 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
793 static 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
804 static 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
812 int 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
850 static 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
882 void 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
915 static 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
932 int 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
954 static 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
978 static 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
1001 static 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
1033 static 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 }
1101 end:
1102 _vb2_fop_release(filp, NULL);
1103 dev->users--;
1104 mutex_unlock(&dev->lock);
1105 return 0;
1106 }
1107
1108
1109 static 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
1131 static 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
1157 if (cmd == VIDIOC_TRY_FMT)
1158 return 0;
1159
1160
1161 dev->width = width;
1162 dev->height = height;
1163 dev->frame_size = width * height * 2;
1164 dev->field_size = width * height;
1165 dev->bytesperline = width * 2;
1166
1167 if (dev->stream_state == STREAM_ON) {
1168 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
1169 ret = au0828_stream_interrupt(dev);
1170 if (ret != 0) {
1171 dprintk(1, "error interrupting video stream!\n");
1172 return ret;
1173 }
1174 }
1175
1176 au0828_analog_stream_enable(dev);
1177
1178 return 0;
1179 }
1180
1181 static int vidioc_querycap(struct file *file, void *priv,
1182 struct v4l2_capability *cap)
1183 {
1184 struct au0828_dev *dev = video_drvdata(file);
1185
1186 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1187 dev->std_set_in_tuner_core, dev->dev_state);
1188
1189 strscpy(cap->driver, "au0828", sizeof(cap->driver));
1190 strscpy(cap->card, dev->board.name, sizeof(cap->card));
1191 usb_make_path(dev->usbdev, cap->bus_info, sizeof(cap->bus_info));
1192
1193
1194 cap->capabilities =
1195 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
1196 V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE |
1197 V4L2_CAP_DEVICE_CAPS;
1198 return 0;
1199 }
1200
1201 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1202 struct v4l2_fmtdesc *f)
1203 {
1204 if (f->index)
1205 return -EINVAL;
1206
1207 dprintk(1, "%s called\n", __func__);
1208
1209 f->pixelformat = V4L2_PIX_FMT_UYVY;
1210
1211 return 0;
1212 }
1213
1214 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1215 struct v4l2_format *f)
1216 {
1217 struct au0828_dev *dev = video_drvdata(file);
1218
1219 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1220 dev->std_set_in_tuner_core, dev->dev_state);
1221
1222 f->fmt.pix.width = dev->width;
1223 f->fmt.pix.height = dev->height;
1224 f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1225 f->fmt.pix.bytesperline = dev->bytesperline;
1226 f->fmt.pix.sizeimage = dev->frame_size;
1227 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1228 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1229 return 0;
1230 }
1231
1232 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1233 struct v4l2_format *f)
1234 {
1235 struct au0828_dev *dev = video_drvdata(file);
1236
1237 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1238 dev->std_set_in_tuner_core, dev->dev_state);
1239
1240 return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1241 }
1242
1243 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1244 struct v4l2_format *f)
1245 {
1246 struct au0828_dev *dev = video_drvdata(file);
1247 int rc;
1248
1249 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1250 dev->std_set_in_tuner_core, dev->dev_state);
1251
1252 rc = check_dev(dev);
1253 if (rc < 0)
1254 return rc;
1255
1256 if (vb2_is_busy(&dev->vb_vidq)) {
1257 pr_info("%s queue busy\n", __func__);
1258 rc = -EBUSY;
1259 goto out;
1260 }
1261
1262 rc = au0828_set_format(dev, VIDIOC_S_FMT, f);
1263 out:
1264 return rc;
1265 }
1266
1267 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1268 {
1269 struct au0828_dev *dev = video_drvdata(file);
1270
1271 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1272 dev->std_set_in_tuner_core, dev->dev_state);
1273
1274 if (norm == dev->std)
1275 return 0;
1276
1277 if (dev->streaming_users > 0)
1278 return -EBUSY;
1279
1280 dev->std = norm;
1281
1282 au0828_init_tuner(dev);
1283
1284 i2c_gate_ctrl(dev, 1);
1285
1286
1287
1288
1289
1290
1291
1292 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, norm);
1293
1294 i2c_gate_ctrl(dev, 0);
1295
1296 return 0;
1297 }
1298
1299 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1300 {
1301 struct au0828_dev *dev = video_drvdata(file);
1302
1303 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1304 dev->std_set_in_tuner_core, dev->dev_state);
1305
1306 *norm = dev->std;
1307 return 0;
1308 }
1309
1310 static int vidioc_enum_input(struct file *file, void *priv,
1311 struct v4l2_input *input)
1312 {
1313 struct au0828_dev *dev = video_drvdata(file);
1314 unsigned int tmp;
1315
1316 static const char *inames[] = {
1317 [AU0828_VMUX_UNDEFINED] = "Undefined",
1318 [AU0828_VMUX_COMPOSITE] = "Composite",
1319 [AU0828_VMUX_SVIDEO] = "S-Video",
1320 [AU0828_VMUX_CABLE] = "Cable TV",
1321 [AU0828_VMUX_TELEVISION] = "Television",
1322 [AU0828_VMUX_DVB] = "DVB",
1323 };
1324
1325 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1326 dev->std_set_in_tuner_core, dev->dev_state);
1327
1328 tmp = input->index;
1329
1330 if (tmp >= AU0828_MAX_INPUT)
1331 return -EINVAL;
1332 if (AUVI_INPUT(tmp).type == 0)
1333 return -EINVAL;
1334
1335 input->index = tmp;
1336 strscpy(input->name, inames[AUVI_INPUT(tmp).type], sizeof(input->name));
1337 if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
1338 (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE)) {
1339 input->type |= V4L2_INPUT_TYPE_TUNER;
1340 input->audioset = 1;
1341 } else {
1342 input->type |= V4L2_INPUT_TYPE_CAMERA;
1343 input->audioset = 2;
1344 }
1345
1346 input->std = dev->vdev.tvnorms;
1347
1348 return 0;
1349 }
1350
1351 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1352 {
1353 struct au0828_dev *dev = video_drvdata(file);
1354
1355 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1356 dev->std_set_in_tuner_core, dev->dev_state);
1357
1358 *i = dev->ctrl_input;
1359 return 0;
1360 }
1361
1362 static void au0828_s_input(struct au0828_dev *dev, int index)
1363 {
1364 int i;
1365
1366 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1367 dev->std_set_in_tuner_core, dev->dev_state);
1368
1369 switch (AUVI_INPUT(index).type) {
1370 case AU0828_VMUX_SVIDEO:
1371 dev->input_type = AU0828_VMUX_SVIDEO;
1372 dev->ctrl_ainput = 1;
1373 break;
1374 case AU0828_VMUX_COMPOSITE:
1375 dev->input_type = AU0828_VMUX_COMPOSITE;
1376 dev->ctrl_ainput = 1;
1377 break;
1378 case AU0828_VMUX_TELEVISION:
1379 dev->input_type = AU0828_VMUX_TELEVISION;
1380 dev->ctrl_ainput = 0;
1381 break;
1382 default:
1383 dprintk(1, "unknown input type set [%d]\n",
1384 AUVI_INPUT(index).type);
1385 return;
1386 }
1387
1388 dev->ctrl_input = index;
1389
1390 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1391 AUVI_INPUT(index).vmux, 0, 0);
1392
1393 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1394 int enable = 0;
1395 if (AUVI_INPUT(i).audio_setup == NULL)
1396 continue;
1397
1398 if (i == index)
1399 enable = 1;
1400 else
1401 enable = 0;
1402 if (enable) {
1403 (AUVI_INPUT(i).audio_setup)(dev, enable);
1404 } else {
1405
1406
1407 if ((AUVI_INPUT(i).audio_setup) !=
1408 ((AUVI_INPUT(index).audio_setup))) {
1409 (AUVI_INPUT(i).audio_setup)(dev, enable);
1410 }
1411 }
1412 }
1413
1414 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1415 AUVI_INPUT(index).amux, 0, 0);
1416 }
1417
1418 static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1419 {
1420 struct au0828_dev *dev = video_drvdata(file);
1421 struct video_device *vfd = video_devdata(file);
1422
1423 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
1424 index);
1425 if (index >= AU0828_MAX_INPUT)
1426 return -EINVAL;
1427 if (AUVI_INPUT(index).type == 0)
1428 return -EINVAL;
1429
1430 if (dev->ctrl_input == index)
1431 return 0;
1432
1433 au0828_s_input(dev, index);
1434
1435
1436
1437
1438
1439
1440 v4l_disable_media_source(vfd);
1441 return v4l_enable_media_source(vfd);
1442 }
1443
1444 static int vidioc_enumaudio(struct file *file, void *priv, struct v4l2_audio *a)
1445 {
1446 if (a->index > 1)
1447 return -EINVAL;
1448
1449 dprintk(1, "%s called\n", __func__);
1450
1451 if (a->index == 0)
1452 strscpy(a->name, "Television", sizeof(a->name));
1453 else
1454 strscpy(a->name, "Line in", sizeof(a->name));
1455
1456 a->capability = V4L2_AUDCAP_STEREO;
1457 return 0;
1458 }
1459
1460 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1461 {
1462 struct au0828_dev *dev = video_drvdata(file);
1463
1464 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1465 dev->std_set_in_tuner_core, dev->dev_state);
1466
1467 a->index = dev->ctrl_ainput;
1468 if (a->index == 0)
1469 strscpy(a->name, "Television", sizeof(a->name));
1470 else
1471 strscpy(a->name, "Line in", sizeof(a->name));
1472
1473 a->capability = V4L2_AUDCAP_STEREO;
1474 return 0;
1475 }
1476
1477 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1478 {
1479 struct au0828_dev *dev = video_drvdata(file);
1480
1481 if (a->index != dev->ctrl_ainput)
1482 return -EINVAL;
1483
1484 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1485 dev->std_set_in_tuner_core, dev->dev_state);
1486 return 0;
1487 }
1488
1489 static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1490 {
1491 struct au0828_dev *dev = video_drvdata(file);
1492 struct video_device *vfd = video_devdata(file);
1493 int ret;
1494
1495 if (t->index != 0)
1496 return -EINVAL;
1497
1498 ret = v4l_enable_media_source(vfd);
1499 if (ret)
1500 return ret;
1501
1502 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1503 dev->std_set_in_tuner_core, dev->dev_state);
1504
1505 strscpy(t->name, "Auvitek tuner", sizeof(t->name));
1506
1507 au0828_init_tuner(dev);
1508 i2c_gate_ctrl(dev, 1);
1509 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1510 i2c_gate_ctrl(dev, 0);
1511 return 0;
1512 }
1513
1514 static int vidioc_s_tuner(struct file *file, void *priv,
1515 const struct v4l2_tuner *t)
1516 {
1517 struct au0828_dev *dev = video_drvdata(file);
1518
1519 if (t->index != 0)
1520 return -EINVAL;
1521
1522 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1523 dev->std_set_in_tuner_core, dev->dev_state);
1524
1525 au0828_init_tuner(dev);
1526 i2c_gate_ctrl(dev, 1);
1527 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1528 i2c_gate_ctrl(dev, 0);
1529
1530 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1531 t->afc);
1532
1533 return 0;
1534
1535 }
1536
1537 static int vidioc_g_frequency(struct file *file, void *priv,
1538 struct v4l2_frequency *freq)
1539 {
1540 struct au0828_dev *dev = video_drvdata(file);
1541
1542 if (freq->tuner != 0)
1543 return -EINVAL;
1544 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1545 dev->std_set_in_tuner_core, dev->dev_state);
1546 freq->frequency = dev->ctrl_freq;
1547 return 0;
1548 }
1549
1550 static int vidioc_s_frequency(struct file *file, void *priv,
1551 const struct v4l2_frequency *freq)
1552 {
1553 struct au0828_dev *dev = video_drvdata(file);
1554 struct v4l2_frequency new_freq = *freq;
1555
1556 if (freq->tuner != 0)
1557 return -EINVAL;
1558
1559 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1560 dev->std_set_in_tuner_core, dev->dev_state);
1561
1562 au0828_init_tuner(dev);
1563 i2c_gate_ctrl(dev, 1);
1564
1565 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
1566
1567 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1568 dev->ctrl_freq = new_freq.frequency;
1569
1570 i2c_gate_ctrl(dev, 0);
1571
1572 au0828_analog_stream_reset(dev);
1573
1574 return 0;
1575 }
1576
1577
1578
1579
1580 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1581 struct v4l2_format *format)
1582 {
1583 struct au0828_dev *dev = video_drvdata(file);
1584
1585 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1586 dev->std_set_in_tuner_core, dev->dev_state);
1587
1588 format->fmt.vbi.samples_per_line = dev->vbi_width;
1589 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1590 format->fmt.vbi.offset = 0;
1591 format->fmt.vbi.flags = 0;
1592 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1593
1594 format->fmt.vbi.count[0] = dev->vbi_height;
1595 format->fmt.vbi.count[1] = dev->vbi_height;
1596 format->fmt.vbi.start[0] = 21;
1597 format->fmt.vbi.start[1] = 284;
1598 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1599
1600 return 0;
1601 }
1602
1603 static int vidioc_g_pixelaspect(struct file *file, void *priv,
1604 int type, struct v4l2_fract *f)
1605 {
1606 struct au0828_dev *dev = video_drvdata(file);
1607
1608 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1609 return -EINVAL;
1610
1611 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1612 dev->std_set_in_tuner_core, dev->dev_state);
1613
1614 f->numerator = 54;
1615 f->denominator = 59;
1616
1617 return 0;
1618 }
1619
1620 static int vidioc_g_selection(struct file *file, void *priv,
1621 struct v4l2_selection *s)
1622 {
1623 struct au0828_dev *dev = video_drvdata(file);
1624
1625 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1626 return -EINVAL;
1627
1628 switch (s->target) {
1629 case V4L2_SEL_TGT_CROP_BOUNDS:
1630 case V4L2_SEL_TGT_CROP_DEFAULT:
1631 s->r.left = 0;
1632 s->r.top = 0;
1633 s->r.width = dev->width;
1634 s->r.height = dev->height;
1635 break;
1636 default:
1637 return -EINVAL;
1638 }
1639 return 0;
1640 }
1641
1642 #ifdef CONFIG_VIDEO_ADV_DEBUG
1643 static int vidioc_g_register(struct file *file, void *priv,
1644 struct v4l2_dbg_register *reg)
1645 {
1646 struct au0828_dev *dev = video_drvdata(file);
1647
1648 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1649 dev->std_set_in_tuner_core, dev->dev_state);
1650
1651 reg->val = au0828_read(dev, reg->reg);
1652 reg->size = 1;
1653 return 0;
1654 }
1655
1656 static int vidioc_s_register(struct file *file, void *priv,
1657 const struct v4l2_dbg_register *reg)
1658 {
1659 struct au0828_dev *dev = video_drvdata(file);
1660
1661 dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
1662 dev->std_set_in_tuner_core, dev->dev_state);
1663
1664 return au0828_writereg(dev, reg->reg, reg->val);
1665 }
1666 #endif
1667
1668 static int vidioc_log_status(struct file *file, void *fh)
1669 {
1670 struct video_device *vdev = video_devdata(file);
1671
1672 dprintk(1, "%s called\n", __func__);
1673
1674 v4l2_ctrl_log_status(file, fh);
1675 v4l2_device_call_all(vdev->v4l2_dev, 0, core, log_status);
1676 return 0;
1677 }
1678
1679 void au0828_v4l2_suspend(struct au0828_dev *dev)
1680 {
1681 struct urb *urb;
1682 int i;
1683
1684 pr_info("stopping V4L2\n");
1685
1686 if (dev->stream_state == STREAM_ON) {
1687 pr_info("stopping V4L2 active URBs\n");
1688 au0828_analog_stream_disable(dev);
1689
1690 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1691 urb = dev->isoc_ctl.urb[i];
1692 if (urb) {
1693 if (!irqs_disabled())
1694 usb_kill_urb(urb);
1695 else
1696 usb_unlink_urb(urb);
1697 }
1698 }
1699 }
1700
1701 if (dev->vid_timeout_running)
1702 del_timer_sync(&dev->vid_timeout);
1703 if (dev->vbi_timeout_running)
1704 del_timer_sync(&dev->vbi_timeout);
1705 }
1706
1707 void au0828_v4l2_resume(struct au0828_dev *dev)
1708 {
1709 int i, rc;
1710
1711 pr_info("restarting V4L2\n");
1712
1713 if (dev->stream_state == STREAM_ON) {
1714 au0828_stream_interrupt(dev);
1715 au0828_init_tuner(dev);
1716 }
1717
1718 if (dev->vid_timeout_running)
1719 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1720 if (dev->vbi_timeout_running)
1721 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1722
1723
1724 au0828_i2s_init(dev);
1725
1726 au0828_analog_stream_enable(dev);
1727
1728 if (!(dev->stream_state == STREAM_ON)) {
1729 au0828_analog_stream_reset(dev);
1730
1731 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1732 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
1733 if (rc) {
1734 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
1735 i, rc);
1736 au0828_uninit_isoc(dev);
1737 }
1738 }
1739 }
1740 }
1741
1742 static const struct v4l2_file_operations au0828_v4l_fops = {
1743 .owner = THIS_MODULE,
1744 .open = au0828_v4l2_open,
1745 .release = au0828_v4l2_close,
1746 .read = vb2_fop_read,
1747 .poll = vb2_fop_poll,
1748 .mmap = vb2_fop_mmap,
1749 .unlocked_ioctl = video_ioctl2,
1750 };
1751
1752 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1753 .vidioc_querycap = vidioc_querycap,
1754 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1755 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1756 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1757 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1758 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1759 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1760 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1761 .vidioc_enumaudio = vidioc_enumaudio,
1762 .vidioc_g_audio = vidioc_g_audio,
1763 .vidioc_s_audio = vidioc_s_audio,
1764 .vidioc_g_pixelaspect = vidioc_g_pixelaspect,
1765 .vidioc_g_selection = vidioc_g_selection,
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
1797 static 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
1804 static 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
1840 static 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
1902 int 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 timer_setup(&dev->vid_timeout, au0828_vid_buffer_timeout, 0);
1957 timer_setup(&dev->vbi_timeout, au0828_vbi_buffer_timeout, 0);
1958
1959 dev->width = NTSC_STD_W;
1960 dev->height = NTSC_STD_H;
1961 dev->field_size = dev->width * dev->height;
1962 dev->frame_size = dev->field_size << 1;
1963 dev->bytesperline = dev->width << 1;
1964 dev->vbi_width = 720;
1965 dev->vbi_height = 1;
1966 dev->ctrl_ainput = 0;
1967 dev->ctrl_freq = 960;
1968 dev->std = V4L2_STD_NTSC_M;
1969
1970 au0828_s_input(dev, 0);
1971
1972 mutex_init(&dev->vb_queue_lock);
1973 mutex_init(&dev->vb_vbi_queue_lock);
1974
1975
1976 dev->vdev = au0828_video_template;
1977 dev->vdev.v4l2_dev = &dev->v4l2_dev;
1978 dev->vdev.lock = &dev->lock;
1979 dev->vdev.queue = &dev->vb_vidq;
1980 dev->vdev.queue->lock = &dev->vb_queue_lock;
1981 dev->vdev.device_caps =
1982 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
1983 V4L2_CAP_TUNER | V4L2_CAP_VIDEO_CAPTURE;
1984 strscpy(dev->vdev.name, "au0828a video", sizeof(dev->vdev.name));
1985
1986
1987 dev->vbi_dev = au0828_video_template;
1988 dev->vbi_dev.v4l2_dev = &dev->v4l2_dev;
1989 dev->vbi_dev.lock = &dev->lock;
1990 dev->vbi_dev.queue = &dev->vb_vbiq;
1991 dev->vbi_dev.queue->lock = &dev->vb_vbi_queue_lock;
1992 dev->vbi_dev.device_caps =
1993 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
1994 V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE;
1995 strscpy(dev->vbi_dev.name, "au0828a vbi", sizeof(dev->vbi_dev.name));
1996
1997
1998 au0828_analog_create_entities(dev);
1999
2000
2001 retval = au0828_vb2_setup(dev);
2002 if (retval != 0) {
2003 dprintk(1, "unable to setup videobuf2 queues (error = %d).\n",
2004 retval);
2005 return -ENODEV;
2006 }
2007
2008
2009 video_set_drvdata(&dev->vdev, dev);
2010 retval = video_register_device(&dev->vdev, VFL_TYPE_GRABBER, -1);
2011 if (retval != 0) {
2012 dprintk(1, "unable to register video device (error = %d).\n",
2013 retval);
2014 ret = -ENODEV;
2015 goto err_reg_vdev;
2016 }
2017
2018
2019 video_set_drvdata(&dev->vbi_dev, dev);
2020 retval = video_register_device(&dev->vbi_dev, VFL_TYPE_VBI, -1);
2021 if (retval != 0) {
2022 dprintk(1, "unable to register vbi device (error = %d).\n",
2023 retval);
2024 ret = -ENODEV;
2025 goto err_reg_vbi_dev;
2026 }
2027
2028 #ifdef CONFIG_MEDIA_CONTROLLER
2029 retval = v4l2_mc_create_media_graph(dev->media_dev);
2030 if (retval) {
2031 pr_err("%s() au0282_dev_register failed to create graph\n",
2032 __func__);
2033 ret = -ENODEV;
2034 goto err_reg_vbi_dev;
2035 }
2036 #endif
2037
2038 dprintk(1, "%s completed!\n", __func__);
2039
2040 return 0;
2041
2042 err_reg_vbi_dev:
2043 video_unregister_device(&dev->vdev);
2044 err_reg_vdev:
2045 vb2_queue_release(&dev->vb_vidq);
2046 vb2_queue_release(&dev->vb_vbiq);
2047 return ret;
2048 }
2049