projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] au0828: fix disconnect sequence
[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
823beb7e 1066 if (dev->users == 1 && video_is_registered(video_devdata(filp))) {
8b2f0795
DH		 1067 au0828_analog_stream_disable(dev);
1068
1069 au0828_uninit_isoc(dev);
1070
e4b8bc52 1071 /* Save some power by putting tuner to sleep */
622b828a 1072 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
e4b8bc52 1073
8b2f0795
DH		 1074 /* When close the device, set the usb intf0 into alt0 to free
1075 USB bandwidth */
1076 ret = usb_set_interface(dev->usbdev, 0, 0);
62899a28
DH		 1077 if (ret < 0)
1078 printk(KERN_INFO "Au0828 can't set alternate to 0!\n");
8b2f0795
DH		 1079 }
1080
7f8eacd2
DH		 1081 videobuf_mmap_free(&fh->vb_vidq);
1082 videobuf_mmap_free(&fh->vb_vbiq);
8b2f0795
DH		 1083 kfree(fh);
1084 dev->users--;
1085 wake_up_interruptible_nr(&dev->open, 1);
8b2f0795
DH		 1086 return 0;
1087}
1088
1089static ssize_t au0828_v4l2_read(struct file *filp, char __user *buf,
1090 size_t count, loff_t *pos)
1091{
1092 struct au0828_fh *fh = filp->private_data;
1093 struct au0828_dev *dev = fh->dev;
1094 int rc;
1095
1096 rc = check_dev(dev);
1097 if (rc < 0)
1098 return rc;
1099
62899a28 1100 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
7f8eacd2
DH		 1101 if (res_locked(dev, AU0828_RESOURCE_VIDEO))
1102 return -EBUSY;
8b2f0795
DH		 1103
1104 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
1105 filp->f_flags & O_NONBLOCK);
1106 }
7f8eacd2
DH		 1107
1108 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1109 if (!res_get(fh, AU0828_RESOURCE_VBI))
1110 return -EBUSY;
1111
bf797165
DH		 1112 if (dev->vbi_timeout_running == 0) {
1113 /* Handle case where caller tries to read without
1114 calling streamon first */
1115 dev->vbi_timeout_running = 1;
1116 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1117 }
1118
7f8eacd2
DH		 1119 return videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
1120 filp->f_flags & O_NONBLOCK);
1121 }
1122
8b2f0795
DH		 1123 return 0;
1124}
1125
1126static unsigned int au0828_v4l2_poll(struct file *filp, poll_table *wait)
1127{
1128 struct au0828_fh *fh = filp->private_data;
1129 struct au0828_dev *dev = fh->dev;
83b09422
HV		 1130 unsigned long req_events = poll_requested_events(wait);
1131 unsigned int res;
8b2f0795 1132
83b09422
HV		 1133 if (check_dev(dev) < 0)
1134 return POLLERR;
1135
1136 res = v4l2_ctrl_poll(filp, wait);
1137 if (!(req_events & (POLLIN | POLLRDNORM)))
1138 return res;
8b2f0795 1139
7f8eacd2
DH		 1140 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1141 if (!res_get(fh, AU0828_RESOURCE_VIDEO))
1142 return POLLERR;
83b09422
HV		 1143 return res | videobuf_poll_stream(filp, &fh->vb_vidq, wait);
1144 }
1145 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
7f8eacd2
DH		 1146 if (!res_get(fh, AU0828_RESOURCE_VBI))
1147 return POLLERR;
83b09422 1148 return res | videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
7f8eacd2 1149 }
83b09422 1150 return POLLERR;
8b2f0795
DH		 1151}
1152
1153static int au0828_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
1154{
1155 struct au0828_fh *fh = filp->private_data;
1156 struct au0828_dev *dev = fh->dev;
1157 int rc;
1158
1159 rc = check_dev(dev);
1160 if (rc < 0)
1161 return rc;
1162
7f8eacd2
DH		 1163 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1164 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1165 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1166 rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma);
8b2f0795 1167
8b2f0795
DH		 1168 return rc;
1169}
1170
1171static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
1172 struct v4l2_format *format)
1173{
1174 int ret;
1175 int width = format->fmt.pix.width;
1176 int height = format->fmt.pix.height;
8b2f0795 1177
8b2f0795
DH		 1178 /* If they are demanding a format other than the one we support,
1179 bail out (tvtime asks for UYVY and then retries with YUYV) */
62899a28 1180 if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
8b2f0795 1181 return -EINVAL;
8b2f0795
DH		 1182
1183 /* format->fmt.pix.width only support 720 and height 480 */
62899a28 1184 if (width != 720)
8b2f0795 1185 width = 720;
62899a28 1186 if (height != 480)
8b2f0795
DH		 1187 height = 480;
1188
1189 format->fmt.pix.width = width;
1190 format->fmt.pix.height = height;
1191 format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1192 format->fmt.pix.bytesperline = width * 2;
1193 format->fmt.pix.sizeimage = width * height * 2;
1194 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1195 format->fmt.pix.field = V4L2_FIELD_INTERLACED;
8d86e4e8 1196 format->fmt.pix.priv = 0;
8b2f0795 1197
62899a28 1198 if (cmd == VIDIOC_TRY_FMT)
8b2f0795
DH		 1199 return 0;
1200
1201 /* maybe set new image format, driver current only support 720*480 */
1202 dev->width = width;
1203 dev->height = height;
1204 dev->frame_size = width * height * 2;
1205 dev->field_size = width * height;
1206 dev->bytesperline = width * 2;
1207
62899a28 1208 if (dev->stream_state == STREAM_ON) {
8b2f0795 1209 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
62899a28
DH		 1210 ret = au0828_stream_interrupt(dev);
1211 if (ret != 0) {
8b2f0795
DH		 1212 dprintk(1, "error interrupting video stream!\n");
1213 return ret;
1214 }
1215 }
1216
1217 /* set au0828 interface0 to AS5 here again */
1218 ret = usb_set_interface(dev->usbdev, 0, 5);
62899a28
DH		 1219 if (ret < 0) {
1220 printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
8b2f0795
DH		 1221 return -EBUSY;
1222 }
1223
1224 au0828_analog_stream_enable(dev);
1225
1226 return 0;
1227}
1228
1229
8b2f0795
DH		 1230static int vidioc_querycap(struct file *file, void *priv,
1231 struct v4l2_capability *cap)
1232{
59e05484
HV		 1233 struct video_device *vdev = video_devdata(file);
1234 struct au0828_fh *fh = priv;
8b2f0795
DH		 1235 struct au0828_dev *dev = fh->dev;
1236
8b2f0795 1237 strlcpy(cap->driver, "au0828", sizeof(cap->driver));
f1add5b5 1238 strlcpy(cap->card, dev->board.name, sizeof(cap->card));
59e05484 1239 usb_make_path(dev->usbdev, cap->bus_info, sizeof(cap->bus_info));
8b2f0795 1240
59e05484
HV		 1241 /* set the device capabilities */
1242 cap->device_caps = V4L2_CAP_AUDIO |
8b2f0795
DH		 1243 V4L2_CAP_READWRITE |
1244 V4L2_CAP_STREAMING |
1245 V4L2_CAP_TUNER;
59e05484
HV		 1246 if (vdev->vfl_type == VFL_TYPE_GRABBER)
1247 cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
1248 else
1249 cap->device_caps |= V4L2_CAP_VBI_CAPTURE;
1250 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1251 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE;
8b2f0795
DH		 1252 return 0;
1253}
1254
1255static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1256 struct v4l2_fmtdesc *f)
1257{
62899a28 1258 if (f->index)
8b2f0795
DH		 1259 return -EINVAL;
1260
8b2f0795
DH		 1261 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1262 strcpy(f->description, "Packed YUV2");
1263
1264 f->flags = 0;
1265 f->pixelformat = V4L2_PIX_FMT_UYVY;
1266
8b2f0795
DH		 1267 return 0;
1268}
1269
1270static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1271 struct v4l2_format *f)
1272{
1273 struct au0828_fh *fh = priv;
1274 struct au0828_dev *dev = fh->dev;
1275
1276 f->fmt.pix.width = dev->width;
1277 f->fmt.pix.height = dev->height;
1278 f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1279 f->fmt.pix.bytesperline = dev->bytesperline;
1280 f->fmt.pix.sizeimage = dev->frame_size;
1281 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
1282 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
8d86e4e8 1283 f->fmt.pix.priv = 0;
8b2f0795
DH		 1284 return 0;
1285}
1286
1287static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1288 struct v4l2_format *f)
1289{
1290 struct au0828_fh *fh = priv;
1291 struct au0828_dev *dev = fh->dev;
1292
1293 return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1294}
1295
1296static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1297 struct v4l2_format *f)
1298{
1299 struct au0828_fh *fh = priv;
1300 struct au0828_dev *dev = fh->dev;
1301 int rc;
1302
7f8eacd2
DH		 1303 rc = check_dev(dev);
1304 if (rc < 0)
1305 return rc;
1306
8b2f0795 1307 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
62899a28 1308 printk(KERN_INFO "%s queue busy\n", __func__);
8b2f0795
DH		 1309 rc = -EBUSY;
1310 goto out;
1311 }
1312
7f8eacd2 1313 rc = au0828_set_format(dev, VIDIOC_S_FMT, f);
8b2f0795
DH		 1314out:
1315 return rc;
1316}
1317
314527ac 1318static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
8b2f0795
DH		 1319{
1320 struct au0828_fh *fh = priv;
1321 struct au0828_dev *dev = fh->dev;
1322
e58071f0
DH		 1323 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1324 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 1);
1325
8b2f0795
DH		 1326 /* FIXME: when we support something other than NTSC, we are going to
1327 have to make the au0828 bridge adjust the size of its capture
1328 buffer, which is currently hardcoded at 720x480 */
1329
314527ac 1330 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, norm);
c98bc032 1331 dev->std_set_in_tuner_core = 1;
e58071f0
DH		 1332
1333 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1334 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 0);
33b6b89b 1335 dev->std = norm;
e58071f0 1336
8b2f0795
DH		 1337 return 0;
1338}
1339
33b6b89b
HV		 1340static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1341{
1342 struct au0828_fh *fh = priv;
1343 struct au0828_dev *dev = fh->dev;
1344
1345 *norm = dev->std;
1346 return 0;
1347}
1348
8b2f0795
DH		 1349static int vidioc_enum_input(struct file *file, void *priv,
1350 struct v4l2_input *input)
1351{
1352 struct au0828_fh *fh = priv;
1353 struct au0828_dev *dev = fh->dev;
1354 unsigned int tmp;
1355
1356 static const char *inames[] = {
3d62287e 1357 [AU0828_VMUX_UNDEFINED] = "Undefined",
8b2f0795
DH		 1358 [AU0828_VMUX_COMPOSITE] = "Composite",
1359 [AU0828_VMUX_SVIDEO] = "S-Video",
1360 [AU0828_VMUX_CABLE] = "Cable TV",
1361 [AU0828_VMUX_TELEVISION] = "Television",
1362 [AU0828_VMUX_DVB] = "DVB",
1363 [AU0828_VMUX_DEBUG] = "tv debug"
1364 };
1365
1366 tmp = input->index;
1367
f5e20c34 1368 if (tmp >= AU0828_MAX_INPUT)
8b2f0795 1369 return -EINVAL;
62899a28 1370 if (AUVI_INPUT(tmp).type == 0)
8b2f0795
DH		 1371 return -EINVAL;
1372
8b2f0795 1373 input->index = tmp;
f1add5b5 1374 strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
62899a28 1375 if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
a2cf96f9 1376 (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE)) {
8b2f0795 1377 input->type |= V4L2_INPUT_TYPE_TUNER;
a2cf96f9
HV		 1378 input->audioset = 1;
1379 } else {
8b2f0795 1380 input->type |= V4L2_INPUT_TYPE_CAMERA;
a2cf96f9
HV		 1381 input->audioset = 2;
1382 }
8b2f0795
DH		 1383
1384 input->std = dev->vdev->tvnorms;
1385
1386 return 0;
1387}
1388
1389static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1390{
1391 struct au0828_fh *fh = priv;
1392 struct au0828_dev *dev = fh->dev;
1393 *i = dev->ctrl_input;
1394 return 0;
1395}
1396
1397static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1398{
1399 struct au0828_fh *fh = priv;
1400 struct au0828_dev *dev = fh->dev;
1401 int i;
8b2f0795 1402
62899a28 1403 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
8b2f0795 1404 index);
62899a28 1405 if (index >= AU0828_MAX_INPUT)
8b2f0795 1406 return -EINVAL;
62899a28 1407 if (AUVI_INPUT(index).type == 0)
8b2f0795
DH		 1408 return -EINVAL;
1409 dev->ctrl_input = index;
1410
62899a28 1411 switch (AUVI_INPUT(index).type) {
8b2f0795 1412 case AU0828_VMUX_SVIDEO:
8b2f0795 1413 dev->input_type = AU0828_VMUX_SVIDEO;
a2cf96f9 1414 dev->ctrl_ainput = 1;
8b2f0795 1415 break;
8b2f0795 1416 case AU0828_VMUX_COMPOSITE:
8b2f0795 1417 dev->input_type = AU0828_VMUX_COMPOSITE;
a2cf96f9 1418 dev->ctrl_ainput = 1;
8b2f0795 1419 break;
8b2f0795 1420 case AU0828_VMUX_TELEVISION:
8b2f0795 1421 dev->input_type = AU0828_VMUX_TELEVISION;
a2cf96f9 1422 dev->ctrl_ainput = 0;
8b2f0795 1423 break;
8b2f0795 1424 default:
a1094c4c
DH		 1425 dprintk(1, "VIDIOC_S_INPUT unknown input type set [%d]\n",
1426 AUVI_INPUT(index).type);
1427 break;
8b2f0795
DH		 1428 }
1429
5325b427
HV		 1430 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1431 AUVI_INPUT(index).vmux, 0, 0);
8b2f0795
DH		 1432
1433 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1434 int enable = 0;
62899a28 1435 if (AUVI_INPUT(i).audio_setup == NULL)
8b2f0795 1436 continue;
8b2f0795
DH		 1437
1438 if (i == index)
1439 enable = 1;
1440 else
1441 enable = 0;
1442 if (enable) {
f1add5b5 1443 (AUVI_INPUT(i).audio_setup)(dev, enable);
8b2f0795
DH		 1444 } else {
1445 /* Make sure we leave it turned on if some
1446 other input is routed to this callback */
f1add5b5
DH		 1447 if ((AUVI_INPUT(i).audio_setup) !=
1448 ((AUVI_INPUT(index).audio_setup))) {
1449 (AUVI_INPUT(i).audio_setup)(dev, enable);
8b2f0795
DH		 1450 }
1451 }
1452 }
1453
5325b427
HV		 1454 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1455 AUVI_INPUT(index).amux, 0, 0);
8b2f0795
DH		 1456 return 0;
1457}
1458
a2cf96f9
HV		 1459static int vidioc_enumaudio(struct file *file, void *priv, struct v4l2_audio *a)
1460{
1461 if (a->index > 1)
1462 return -EINVAL;
1463
1464 if (a->index == 0)
1465 strcpy(a->name, "Television");
1466 else
1467 strcpy(a->name, "Line in");
1468
1469 a->capability = V4L2_AUDCAP_STEREO;
1470 return 0;
1471}
1472
8b2f0795
DH		 1473static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1474{
1475 struct au0828_fh *fh = priv;
1476 struct au0828_dev *dev = fh->dev;
8b2f0795 1477
a2cf96f9
HV		 1478 a->index = dev->ctrl_ainput;
1479 if (a->index == 0)
8b2f0795
DH		 1480 strcpy(a->name, "Television");
1481 else
1482 strcpy(a->name, "Line in");
1483
1484 a->capability = V4L2_AUDCAP_STEREO;
8b2f0795
DH		 1485 return 0;
1486}
1487
0e8025b9 1488static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
8b2f0795
DH		 1489{
1490 struct au0828_fh *fh = priv;
1491 struct au0828_dev *dev = fh->dev;
a2cf96f9 1492
62899a28 1493 if (a->index != dev->ctrl_ainput)
8b2f0795
DH		 1494 return -EINVAL;
1495 return 0;
1496}
1497
8b2f0795
DH		 1498static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1499{
1500 struct au0828_fh *fh = priv;
1501 struct au0828_dev *dev = fh->dev;
1502
62899a28 1503 if (t->index != 0)
8b2f0795
DH		 1504 return -EINVAL;
1505
8b2f0795 1506 strcpy(t->name, "Auvitek tuner");
2689d3dc 1507 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
8b2f0795
DH		 1508 return 0;
1509}
1510
1511static int vidioc_s_tuner(struct file *file, void *priv,
2f73c7c5 1512 const struct v4l2_tuner *t)
8b2f0795
DH		 1513{
1514 struct au0828_fh *fh = priv;
1515 struct au0828_dev *dev = fh->dev;
1516
62899a28 1517 if (t->index != 0)
8b2f0795
DH		 1518 return -EINVAL;
1519
e58071f0
DH		 1520 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1521 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 1);
1522
2689d3dc 1523 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
e58071f0
DH		 1524
1525 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1526 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 0);
1527
8b2f0795
DH		 1528 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1529 t->afc);
e58071f0 1530
8b2f0795
DH		 1531 return 0;
1532
1533}
1534
1535static int vidioc_g_frequency(struct file *file, void *priv,
1536 struct v4l2_frequency *freq)
1537{
1538 struct au0828_fh *fh = priv;
1539 struct au0828_dev *dev = fh->dev;
c888923d 1540
e1cf6587
HV		 1541 if (freq->tuner != 0)
1542 return -EINVAL;
8b2f0795
DH		 1543 freq->frequency = dev->ctrl_freq;
1544 return 0;
1545}
1546
1547static int vidioc_s_frequency(struct file *file, void *priv,
b530a447 1548 const struct v4l2_frequency *freq)
8b2f0795
DH		 1549{
1550 struct au0828_fh *fh = priv;
1551 struct au0828_dev *dev = fh->dev;
e1cf6587 1552 struct v4l2_frequency new_freq = *freq;
8b2f0795 1553
62899a28 1554 if (freq->tuner != 0)
8b2f0795 1555 return -EINVAL;
8b2f0795 1556
4a03dafc
DH		 1557 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1558 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 1);
1559
c98bc032 1560 if (dev->std_set_in_tuner_core == 0) {
38823b29
HV		 1561 /* If we've never sent the standard in tuner core, do so now.
1562 We don't do this at device probe because we don't want to
1563 incur the cost of a firmware load */
1564 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std,
1565 dev->vdev->tvnorms);
1566 dev->std_set_in_tuner_core = 1;
c98bc032
DH		 1567 }
1568
2689d3dc 1569 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
e1cf6587
HV		 1570 /* Get the actual set (and possibly clamped) frequency */
1571 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1572 dev->ctrl_freq = new_freq.frequency;
8b2f0795 1573
4a03dafc
DH		 1574 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
1575 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, 0);
1576
8b2f0795
DH		 1577 au0828_analog_stream_reset(dev);
1578
1579 return 0;
1580}
1581
7f8eacd2
DH		 1582
1583/* RAW VBI ioctls */
1584
1585static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1586 struct v4l2_format *format)
1587{
1588 struct au0828_fh *fh = priv;
1589 struct au0828_dev *dev = fh->dev;
1590
1591 format->fmt.vbi.samples_per_line = dev->vbi_width;
1592 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1593 format->fmt.vbi.offset = 0;
1594 format->fmt.vbi.flags = 0;
1595 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1596
1597 format->fmt.vbi.count[0] = dev->vbi_height;
1598 format->fmt.vbi.count[1] = dev->vbi_height;
1599 format->fmt.vbi.start[0] = 21;
1600 format->fmt.vbi.start[1] = 284;
8d86e4e8 1601 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
7f8eacd2
DH		 1602
1603 return 0;
1604}
1605
8b2f0795
DH		 1606static int vidioc_g_chip_ident(struct file *file, void *priv,
1607 struct v4l2_dbg_chip_ident *chip)
1608{
1609 struct au0828_fh *fh = priv;
1610 struct au0828_dev *dev = fh->dev;
1611 chip->ident = V4L2_IDENT_NONE;
1612 chip->revision = 0;
1613
d9109bef
DH		 1614 if (v4l2_chip_match_host(&chip->match)) {
1615 chip->ident = V4L2_IDENT_AU0828;
1616 return 0;
1617 }
1618
2689d3dc 1619 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
d9109bef
DH		 1620 if (chip->ident == V4L2_IDENT_NONE)
1621 return -EINVAL;
1622
8b2f0795
DH		 1623 return 0;
1624}
1625
1626static int vidioc_cropcap(struct file *file, void *priv,
1627 struct v4l2_cropcap *cc)
1628{
1629 struct au0828_fh *fh = priv;
1630 struct au0828_dev *dev = fh->dev;
1631
62899a28 1632 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
8b2f0795
DH		 1633 return -EINVAL;
1634
1635 cc->bounds.left = 0;
1636 cc->bounds.top = 0;
1637 cc->bounds.width = dev->width;
1638 cc->bounds.height = dev->height;
1639
1640 cc->defrect = cc->bounds;
1641
1642 cc->pixelaspect.numerator = 54;
1643 cc->pixelaspect.denominator = 59;
1644
1645 return 0;
1646}
1647
1648static int vidioc_streamon(struct file *file, void *priv,
1649 enum v4l2_buf_type type)
1650{
7f8eacd2
DH		 1651 struct au0828_fh *fh = priv;
1652 struct au0828_dev *dev = fh->dev;
1653 int rc = -EINVAL;
8b2f0795
DH		 1654
1655 rc = check_dev(dev);
1656 if (rc < 0)
1657 return rc;
1658
7f8eacd2
DH		 1659 if (unlikely(type != fh->type))
1660 return -EINVAL;
1661
1662 dprintk(1, "vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
1663 fh, type, fh->resources, dev->resources);
1664
1665 if (unlikely(!res_get(fh, get_ressource(fh))))
1666 return -EBUSY;
1667
8b2f0795
DH		 1668 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1669 au0828_analog_stream_enable(dev);
2689d3dc 1670 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
8b2f0795
DH		 1671 }
1672
78ca5005 1673 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
8b2f0795 1674 rc = videobuf_streamon(&fh->vb_vidq);
78ca5005
DH		 1675 dev->vid_timeout_running = 1;
1676 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1677 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
7f8eacd2 1678 rc = videobuf_streamon(&fh->vb_vbiq);
78ca5005
DH		 1679 dev->vbi_timeout_running = 1;
1680 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1681 }
8b2f0795
DH		 1682
1683 return rc;
1684}
1685
1686static int vidioc_streamoff(struct file *file, void *priv,
1687 enum v4l2_buf_type type)
1688{
7f8eacd2
DH		 1689 struct au0828_fh *fh = priv;
1690 struct au0828_dev *dev = fh->dev;
1691 int rc;
1692 int i;
8b2f0795
DH		 1693
1694 rc = check_dev(dev);
1695 if (rc < 0)
1696 return rc;
1697
7f8eacd2
DH		 1698 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1699 fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
8b2f0795
DH		 1700 return -EINVAL;
1701 if (type != fh->type)
1702 return -EINVAL;
1703
7f8eacd2
DH		 1704 dprintk(1, "vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
1705 fh, type, fh->resources, dev->resources);
1706
1707 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
78ca5005
DH		 1708 dev->vid_timeout_running = 0;
1709 del_timer_sync(&dev->vid_timeout);
1710
2689d3dc 1711 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
7f8eacd2
DH		 1712 rc = au0828_stream_interrupt(dev);
1713 if (rc != 0)
1714 return rc;
8b2f0795 1715
7f8eacd2
DH		 1716 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1717 if (AUVI_INPUT(i).audio_setup == NULL)
1718 continue;
1719 (AUVI_INPUT(i).audio_setup)(dev, 0);
1720 }
8b2f0795 1721
a595c1ce
DH		 1722 if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
1723 videobuf_streamoff(&fh->vb_vidq);
1724 res_free(fh, AU0828_RESOURCE_VIDEO);
1725 }
7f8eacd2 1726 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
78ca5005
DH		 1727 dev->vbi_timeout_running = 0;
1728 del_timer_sync(&dev->vbi_timeout);
1729
a595c1ce
DH		 1730 if (res_check(fh, AU0828_RESOURCE_VBI)) {
1731 videobuf_streamoff(&fh->vb_vbiq);
1732 res_free(fh, AU0828_RESOURCE_VBI);
1733 }
7f8eacd2 1734 }
8b2f0795
DH		 1735
1736 return 0;
1737}
1738
80c6e358 1739#ifdef CONFIG_VIDEO_ADV_DEBUG
8b2f0795
DH		 1740static int vidioc_g_register(struct file *file, void *priv,
1741 struct v4l2_dbg_register *reg)
1742{
1743 struct au0828_fh *fh = priv;
1744 struct au0828_dev *dev = fh->dev;
1745
1746 switch (reg->match.type) {
1747 case V4L2_CHIP_MATCH_I2C_DRIVER:
2689d3dc 1748 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
8b2f0795
DH		 1749 return 0;
1750 default:
364d2db2
DH		 1751 if (!v4l2_chip_match_host(&reg->match))
1752 return -EINVAL;
8b2f0795 1753 }
364d2db2
DH		 1754
1755 reg->val = au0828_read(dev, reg->reg);
1756 return 0;
8b2f0795
DH		 1757}
1758
1759static int vidioc_s_register(struct file *file, void *priv,
977ba3b1 1760 const struct v4l2_dbg_register *reg)
8b2f0795
DH		 1761{
1762 struct au0828_fh *fh = priv;
1763 struct au0828_dev *dev = fh->dev;
1764
1765 switch (reg->match.type) {
1766 case V4L2_CHIP_MATCH_I2C_DRIVER:
2689d3dc 1767 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
8b2f0795
DH		 1768 return 0;
1769 default:
364d2db2
DH		 1770 if (!v4l2_chip_match_host(&reg->match))
1771 return -EINVAL;
8b2f0795 1772 }
364d2db2 1773 return au0828_writereg(dev, reg->reg, reg->val);
8b2f0795 1774}
80c6e358 1775#endif
8b2f0795 1776
83b09422
HV		 1777static int vidioc_log_status(struct file *file, void *fh)
1778{
1779 struct video_device *vdev = video_devdata(file);
1780
1781 v4l2_ctrl_log_status(file, fh);
1782 v4l2_device_call_all(vdev->v4l2_dev, 0, core, log_status);
1783 return 0;
1784}
1785
8b2f0795
DH		 1786static int vidioc_reqbufs(struct file *file, void *priv,
1787 struct v4l2_requestbuffers *rb)
1788{
1789 struct au0828_fh *fh = priv;
1790 struct au0828_dev *dev = fh->dev;
1791 int rc;
1792
1793 rc = check_dev(dev);
1794 if (rc < 0)
1795 return rc;
1796
54ebb8b8
DH		 1797 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1798 rc = videobuf_reqbufs(&fh->vb_vidq, rb);
1799 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1800 rc = videobuf_reqbufs(&fh->vb_vbiq, rb);
1801
1802 return rc;
8b2f0795
DH		 1803}
1804
1805static int vidioc_querybuf(struct file *file, void *priv,
1806 struct v4l2_buffer *b)
1807{
1808 struct au0828_fh *fh = priv;
1809 struct au0828_dev *dev = fh->dev;
1810 int rc;
1811
1812 rc = check_dev(dev);
1813 if (rc < 0)
1814 return rc;
1815
54ebb8b8
DH		 1816 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1817 rc = videobuf_querybuf(&fh->vb_vidq, b);
1818 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1819 rc = videobuf_querybuf(&fh->vb_vbiq, b);
1820
1821 return rc;
8b2f0795
DH		 1822}
1823
1824static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1825{
1826 struct au0828_fh *fh = priv;
1827 struct au0828_dev *dev = fh->dev;
1828 int rc;
1829
1830 rc = check_dev(dev);
1831 if (rc < 0)
1832 return rc;
1833
54ebb8b8
DH		 1834 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1835 rc = videobuf_qbuf(&fh->vb_vidq, b);
1836 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1837 rc = videobuf_qbuf(&fh->vb_vbiq, b);
1838
1839 return rc;
8b2f0795
DH		 1840}
1841
1842static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1843{
1844 struct au0828_fh *fh = priv;
1845 struct au0828_dev *dev = fh->dev;
1846 int rc;
1847
1848 rc = check_dev(dev);
1849 if (rc < 0)
1850 return rc;
1851
1852 /* Workaround for a bug in the au0828 hardware design that sometimes
1853 results in the colorspace being inverted */
1854 if (dev->greenscreen_detected == 1) {
1855 dprintk(1, "Detected green frame. Resetting stream...\n");
1856 au0828_analog_stream_reset(dev);
1857 dev->greenscreen_detected = 0;
1858 }
1859
54ebb8b8
DH		 1860 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1861 rc = videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1862 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1863 rc = videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags & O_NONBLOCK);
1864
1865 return rc;
8b2f0795
DH		 1866}
1867
8b2f0795
DH		 1868static struct v4l2_file_operations au0828_v4l_fops = {
1869 .owner = THIS_MODULE,
1870 .open = au0828_v4l2_open,
1871 .release = au0828_v4l2_close,
1872 .read = au0828_v4l2_read,
1873 .poll = au0828_v4l2_poll,
1874 .mmap = au0828_v4l2_mmap,
549ee4df 1875 .unlocked_ioctl = video_ioctl2,
8b2f0795
DH		 1876};
1877
1878static const struct v4l2_ioctl_ops video_ioctl_ops = {
1879 .vidioc_querycap = vidioc_querycap,
1880 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1881 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1882 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1883 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
5a5a4e16 1884 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
8d86e4e8 1885 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
7f8eacd2 1886 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
a2cf96f9 1887 .vidioc_enumaudio = vidioc_enumaudio,
8b2f0795
DH		 1888 .vidioc_g_audio = vidioc_g_audio,
1889 .vidioc_s_audio = vidioc_s_audio,
1890 .vidioc_cropcap = vidioc_cropcap,
8b2f0795
DH		 1891 .vidioc_reqbufs = vidioc_reqbufs,
1892 .vidioc_querybuf = vidioc_querybuf,
1893 .vidioc_qbuf = vidioc_qbuf,
1894 .vidioc_dqbuf = vidioc_dqbuf,
1895 .vidioc_s_std = vidioc_s_std,
33b6b89b 1896 .vidioc_g_std = vidioc_g_std,
8b2f0795
DH		 1897 .vidioc_enum_input = vidioc_enum_input,
1898 .vidioc_g_input = vidioc_g_input,
1899 .vidioc_s_input = vidioc_s_input,
8b2f0795
DH		 1900 .vidioc_streamon = vidioc_streamon,
1901 .vidioc_streamoff = vidioc_streamoff,
1902 .vidioc_g_tuner = vidioc_g_tuner,
1903 .vidioc_s_tuner = vidioc_s_tuner,
1904 .vidioc_g_frequency = vidioc_g_frequency,
1905 .vidioc_s_frequency = vidioc_s_frequency,
1906#ifdef CONFIG_VIDEO_ADV_DEBUG
1907 .vidioc_g_register = vidioc_g_register,
1908 .vidioc_s_register = vidioc_s_register,
8b2f0795 1909#endif
80c6e358 1910 .vidioc_g_chip_ident = vidioc_g_chip_ident,
83b09422
HV		 1911 .vidioc_log_status = vidioc_log_status,
1912 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1913 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
8b2f0795
DH		 1914};
1915
1916static const struct video_device au0828_video_template = {
1917 .fops = &au0828_v4l_fops,
1918 .release = video_device_release,
1919 .ioctl_ops = &video_ioctl_ops,
0ef21071 1920 .tvnorms = V4L2_STD_NTSC_M,
8b2f0795
DH		 1921};
1922
1923/**************************************************************************/
1924
fc4ce6cd
DH		 1925int au0828_analog_register(struct au0828_dev *dev,
1926 struct usb_interface *interface)
8b2f0795
DH		 1927{
1928 int retval = -ENOMEM;
fc4ce6cd
DH		 1929 struct usb_host_interface *iface_desc;
1930 struct usb_endpoint_descriptor *endpoint;
d63b21bf 1931 int i, ret;
8b2f0795
DH		 1932
1933 dprintk(1, "au0828_analog_register called!\n");
1934
fc4ce6cd
DH		 1935 /* set au0828 usb interface0 to as5 */
1936 retval = usb_set_interface(dev->usbdev,
62899a28 1937 interface->cur_altsetting->desc.bInterfaceNumber, 5);
fc4ce6cd 1938 if (retval != 0) {
62899a28 1939 printk(KERN_INFO "Failure setting usb interface0 to as5\n");
fc4ce6cd
DH		 1940 return retval;
1941 }
1942
1943 /* Figure out which endpoint has the isoc interface */
1944 iface_desc = interface->cur_altsetting;
62899a28 1945 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
fc4ce6cd 1946 endpoint = &iface_desc->endpoint[i].desc;
62899a28
DH		 1947 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1948 == USB_DIR_IN) &&
1949 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1950 == USB_ENDPOINT_XFER_ISOC)) {
fc4ce6cd
DH		 1951
1952 /* we find our isoc in endpoint */
1953 u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
62899a28
DH		 1954 dev->max_pkt_size = (tmp & 0x07ff) *
1955 (((tmp & 0x1800) >> 11) + 1);
fc4ce6cd
DH		 1956 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1957 }
1958 }
62899a28
DH		 1959 if (!(dev->isoc_in_endpointaddr)) {
1960 printk(KERN_INFO "Could not locate isoc endpoint\n");
fc4ce6cd
DH		 1961 kfree(dev);
1962 return -ENODEV;
1963 }
1964
8b2f0795
DH		 1965 init_waitqueue_head(&dev->open);
1966 spin_lock_init(&dev->slock);
8b2f0795 1967
7f8eacd2 1968 /* init video dma queues */
8b2f0795
DH		 1969 INIT_LIST_HEAD(&dev->vidq.active);
1970 INIT_LIST_HEAD(&dev->vidq.queued);
7f8eacd2
DH		 1971 INIT_LIST_HEAD(&dev->vbiq.active);
1972 INIT_LIST_HEAD(&dev->vbiq.queued);
8b2f0795 1973
78ca5005
DH		 1974 dev->vid_timeout.function = au0828_vid_buffer_timeout;
1975 dev->vid_timeout.data = (unsigned long) dev;
1976 init_timer(&dev->vid_timeout);
1977
1978 dev->vbi_timeout.function = au0828_vbi_buffer_timeout;
1979 dev->vbi_timeout.data = (unsigned long) dev;
1980 init_timer(&dev->vbi_timeout);
1981
8b2f0795
DH		 1982 dev->width = NTSC_STD_W;
1983 dev->height = NTSC_STD_H;
1984 dev->field_size = dev->width * dev->height;
1985 dev->frame_size = dev->field_size << 1;
1986 dev->bytesperline = dev->width << 1;
1987 dev->ctrl_ainput = 0;
e1cf6587 1988 dev->ctrl_freq = 960;
33b6b89b 1989 dev->std = V4L2_STD_NTSC_M;
8b2f0795
DH		 1990
1991 /* allocate and fill v4l2 video struct */
1992 dev->vdev = video_device_alloc();
62899a28 1993 if (NULL == dev->vdev) {
8b2f0795
DH		 1994 dprintk(1, "Can't allocate video_device.\n");
1995 return -ENOMEM;
1996 }
1997
7f8eacd2 1998 /* allocate the VBI struct */
8b2f0795 1999 dev->vbi_dev = video_device_alloc();
62899a28 2000 if (NULL == dev->vbi_dev) {
8b2f0795 2001 dprintk(1, "Can't allocate vbi_device.\n");
d63b21bf
JL		 2002 ret = -ENOMEM;
2003 goto err_vdev;
8b2f0795
DH		 2004 }
2005
2006 /* Fill the video capture device struct */
2007 *dev->vdev = au0828_video_template;
e8c26f45 2008 dev->vdev->v4l2_dev = &dev->v4l2_dev;
549ee4df 2009 dev->vdev->lock = &dev->lock;
83b09422 2010 set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev->flags);
8b2f0795
DH		 2011 strcpy(dev->vdev->name, "au0828a video");
2012
2013 /* Setup the VBI device */
2014 *dev->vbi_dev = au0828_video_template;
e8c26f45 2015 dev->vbi_dev->v4l2_dev = &dev->v4l2_dev;
549ee4df 2016 dev->vbi_dev->lock = &dev->lock;
83b09422 2017 set_bit(V4L2_FL_USE_FH_PRIO, &dev->vbi_dev->flags);
8b2f0795
DH		 2018 strcpy(dev->vbi_dev->name, "au0828a vbi");
2019
8b2f0795 2020 /* Register the v4l2 device */
63b0d5ad 2021 video_set_drvdata(dev->vdev, dev);
62899a28
DH		 2022 retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
2023 if (retval != 0) {
2024 dprintk(1, "unable to register video device (error = %d).\n",
2025 retval);
d63b21bf
JL		 2026 ret = -ENODEV;
2027 goto err_vbi_dev;
8b2f0795
DH		 2028 }
2029
2030 /* Register the vbi device */
63b0d5ad 2031 video_set_drvdata(dev->vbi_dev, dev);
62899a28
DH		 2032 retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
2033 if (retval != 0) {
2034 dprintk(1, "unable to register vbi device (error = %d).\n",
2035 retval);
d63b21bf
JL		 2036 ret = -ENODEV;
2037 goto err_vbi_dev;
8b2f0795
DH		 2038 }
2039
62899a28 2040 dprintk(1, "%s completed!\n", __func__);
8b2f0795
DH		 2041
2042 return 0;
d63b21bf
JL		 2043
2044err_vbi_dev:
2045 video_device_release(dev->vbi_dev);
2046err_vdev:
2047 video_device_release(dev->vdev);
2048 return ret;
8b2f0795
DH		 2049}
2050
kernel source for telekom puls (alcatel/mediatek)