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