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