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