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