]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/media/usb/au0828/au0828-video.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] au0828: set reg->size
[mirror_ubuntu-artful-kernel.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
790 * Please set interface0 to AS5 before enable the stream
791 */
a094ca46 792static int au0828_analog_stream_enable(struct au0828_dev *d)
8b2f0795
DH		 793{
794 dprintk(1, "au0828_analog_stream_enable called\n");
795 au0828_writereg(d, AU0828_SENSORCTRL_VBI_103, 0x00);
796 au0828_writereg(d, 0x106, 0x00);
797 /* set x position */
798 au0828_writereg(d, 0x110, 0x00);
799 au0828_writereg(d, 0x111, 0x00);
800 au0828_writereg(d, 0x114, 0xa0);
801 au0828_writereg(d, 0x115, 0x05);
802 /* set y position */
7f8eacd2 803 au0828_writereg(d, 0x112, 0x00);
8b2f0795
DH		 804 au0828_writereg(d, 0x113, 0x00);
805 au0828_writereg(d, 0x116, 0xf2);
806 au0828_writereg(d, 0x117, 0x00);
807 au0828_writereg(d, AU0828_SENSORCTRL_100, 0xb3);
808
809 return 0;
810}
811
812int au0828_analog_stream_disable(struct au0828_dev *d)
813{
814 dprintk(1, "au0828_analog_stream_disable called\n");
815 au0828_writereg(d, AU0828_SENSORCTRL_100, 0x0);
816 return 0;
817}
818
a094ca46 819static void au0828_analog_stream_reset(struct au0828_dev *dev)
8b2f0795
DH		 820{
821 dprintk(1, "au0828_analog_stream_reset called\n");
822 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0x0);
823 mdelay(30);
824 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0xb3);
825}
826
827/*
828 * Some operations needs to stop current streaming
829 */
830static int au0828_stream_interrupt(struct au0828_dev *dev)
831{
832 int ret = 0;
833
834 dev->stream_state = STREAM_INTERRUPT;
62899a28 835 if (dev->dev_state == DEV_DISCONNECTED)
8b2f0795 836 return -ENODEV;
62899a28 837 else if (ret) {
8b2f0795 838 dev->dev_state = DEV_MISCONFIGURED;
62899a28 839 dprintk(1, "%s device is misconfigured!\n", __func__);
8b2f0795
DH		 840 return ret;
841 }
842 return 0;
843}
844
845/*
846 * au0828_release_resources
847 * unregister v4l2 devices
848 */
849void au0828_analog_unregister(struct au0828_dev *dev)
850{
851 dprintk(1, "au0828_release_resources called\n");
852 mutex_lock(&au0828_sysfs_lock);
853
63b0d5ad 854 if (dev->vdev)
5a5a4e16
DH		 855 video_unregister_device(dev->vdev);
856 if (dev->vbi_dev)
857 video_unregister_device(dev->vbi_dev);
8b2f0795
DH		 858
859 mutex_unlock(&au0828_sysfs_lock);
860}
861
862
863/* Usage lock check functions */
7f8eacd2 864static int res_get(struct au0828_fh *fh, unsigned int bit)
8b2f0795 865{
7f8eacd2 866 struct au0828_dev *dev = fh->dev;
8b2f0795 867
7f8eacd2
DH		 868 if (fh->resources & bit)
869 /* have it already allocated */
870 return 1;
8b2f0795 871
7f8eacd2 872 /* is it free? */
7f8eacd2
DH		 873 if (dev->resources & bit) {
874 /* no, someone else uses it */
7f8eacd2
DH		 875 return 0;
876 }
877 /* it's free, grab it */
878 fh->resources |= bit;
879 dev->resources |= bit;
880 dprintk(1, "res: get %d\n", bit);
549ee4df 881
7f8eacd2
DH		 882 return 1;
883}
8b2f0795 884
7f8eacd2
DH		 885static int res_check(struct au0828_fh *fh, unsigned int bit)
886{
887 return fh->resources & bit;
8b2f0795
DH		 888}
889
7f8eacd2 890static int res_locked(struct au0828_dev *dev, unsigned int bit)
8b2f0795 891{
7f8eacd2 892 return dev->resources & bit;
8b2f0795
DH		 893}
894
7f8eacd2 895static void res_free(struct au0828_fh *fh, unsigned int bits)
8b2f0795 896{
7f8eacd2
DH		 897 struct au0828_dev *dev = fh->dev;
898
899 BUG_ON((fh->resources & bits) != bits);
8b2f0795 900
7f8eacd2
DH		 901 fh->resources &= ~bits;
902 dev->resources &= ~bits;
903 dprintk(1, "res: put %d\n", bits);
7f8eacd2
DH		 904}
905
906static int get_ressource(struct au0828_fh *fh)
907{
908 switch (fh->type) {
909 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
910 return AU0828_RESOURCE_VIDEO;
911 case V4L2_BUF_TYPE_VBI_CAPTURE:
912 return AU0828_RESOURCE_VBI;
913 default:
914 BUG();
915 return 0;
916 }
8b2f0795
DH		 917}
918
6e04b7b9
DH		 919/* This function ensures that video frames continue to be delivered even if
920 the ITU-656 input isn't receiving any data (thereby preventing applications
921 such as tvtime from hanging) */
a094ca46 922static void au0828_vid_buffer_timeout(unsigned long data)
6e04b7b9
DH		 923{
924 struct au0828_dev *dev = (struct au0828_dev *) data;
925 struct au0828_dmaqueue *dma_q = &dev->vidq;
926 struct au0828_buffer *buf;
927 unsigned char *vid_data;
78ca5005 928 unsigned long flags = 0;
6e04b7b9 929
78ca5005 930 spin_lock_irqsave(&dev->slock, flags);
6e04b7b9
DH		 931
932 buf = dev->isoc_ctl.buf;
933 if (buf != NULL) {
934 vid_data = videobuf_to_vmalloc(&buf->vb);
935 memset(vid_data, 0x00, buf->vb.size); /* Blank green frame */
936 buffer_filled(dev, dma_q, buf);
6e04b7b9 937 }
78ca5005
DH		 938 get_next_buf(dma_q, &buf);
939
940 if (dev->vid_timeout_running == 1)
941 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
6e04b7b9 942
78ca5005 943 spin_unlock_irqrestore(&dev->slock, flags);
6e04b7b9
DH		 944}
945
a094ca46 946static void au0828_vbi_buffer_timeout(unsigned long data)
6e04b7b9
DH		 947{
948 struct au0828_dev *dev = (struct au0828_dev *) data;
949 struct au0828_dmaqueue *dma_q = &dev->vbiq;
950 struct au0828_buffer *buf;
951 unsigned char *vbi_data;
78ca5005 952 unsigned long flags = 0;
6e04b7b9 953
78ca5005 954 spin_lock_irqsave(&dev->slock, flags);
6e04b7b9
DH		 955
956 buf = dev->isoc_ctl.vbi_buf;
957 if (buf != NULL) {
958 vbi_data = videobuf_to_vmalloc(&buf->vb);
959 memset(vbi_data, 0x00, buf->vb.size);
960 vbi_buffer_filled(dev, dma_q, buf);
6e04b7b9 961 }
78ca5005 962 vbi_get_next_buf(dma_q, &buf);
6e04b7b9 963
78ca5005
DH		 964 if (dev->vbi_timeout_running == 1)
965 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
966 spin_unlock_irqrestore(&dev->slock, flags);
6e04b7b9
DH		 967}
968
969
8b2f0795
DH		 970static int au0828_v4l2_open(struct file *filp)
971{
8b2f0795 972 int ret = 0;
7f8eacd2 973 struct video_device *vdev = video_devdata(filp);
63b0d5ad 974 struct au0828_dev *dev = video_drvdata(filp);
8b2f0795 975 struct au0828_fh *fh;
7f8eacd2 976 int type;
63b0d5ad 977
7f8eacd2
DH		 978 switch (vdev->vfl_type) {
979 case VFL_TYPE_GRABBER:
980 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
981 break;
982 case VFL_TYPE_VBI:
63b0d5ad 983 type = V4L2_BUF_TYPE_VBI_CAPTURE;
7f8eacd2
DH		 984 break;
985 default:
986 return -EINVAL;
987 }
8b2f0795
DH		 988
989 fh = kzalloc(sizeof(struct au0828_fh), GFP_KERNEL);
62899a28 990 if (NULL == fh) {
8b2f0795
DH		 991 dprintk(1, "Failed allocate au0828_fh struct!\n");
992 return -ENOMEM;
993 }
994
995 fh->type = type;
996 fh->dev = dev;
83b09422 997 v4l2_fh_init(&fh->fh, vdev);
8b2f0795
DH		 998 filp->private_data = fh;
999
ea86968f
HV		 1000 if (mutex_lock_interruptible(&dev->lock)) {
1001 kfree(fh);
1002 return -ERESTARTSYS;
1003 }
1004 if (dev->users == 0) {
8b2f0795
DH		 1005 /* set au0828 interface0 to AS5 here again */
1006 ret = usb_set_interface(dev->usbdev, 0, 5);
62899a28 1007 if (ret < 0) {
ea86968f 1008 mutex_unlock(&dev->lock);
62899a28 1009 printk(KERN_INFO "Au0828 can't set alternate to 5!\n");
ea86968f 1010 kfree(fh);
8b2f0795
DH		 1011 return -EBUSY;
1012 }
8b2f0795
DH		 1013
1014 au0828_analog_stream_enable(dev);
1015 au0828_analog_stream_reset(dev);
1016
1017 /* If we were doing ac97 instead of i2s, it would go here...*/
1018 au0828_i2s_init(dev);
1019
1020 dev->stream_state = STREAM_OFF;
1021 dev->dev_state |= DEV_INITIALIZED;
1022 }
1023
1024 dev->users++;
ea86968f 1025 mutex_unlock(&dev->lock);
8b2f0795
DH		 1026
1027 videobuf_queue_vmalloc_init(&fh->vb_vidq, &au0828_video_qops,
7f8eacd2
DH		 1028 NULL, &dev->slock,
1029 V4L2_BUF_TYPE_VIDEO_CAPTURE,
8b2f0795 1030 V4L2_FIELD_INTERLACED,
549ee4df
DH		 1031 sizeof(struct au0828_buffer), fh,
1032 &dev->lock);
8b2f0795 1033
7f8eacd2 1034 /* VBI Setup */
7f8eacd2
DH		 1035 videobuf_queue_vmalloc_init(&fh->vb_vbiq, &au0828_vbi_qops,
1036 NULL, &dev->slock,
1037 V4L2_BUF_TYPE_VBI_CAPTURE,
1038 V4L2_FIELD_SEQ_TB,
549ee4df
DH		 1039 sizeof(struct au0828_buffer), fh,
1040 &dev->lock);
83b09422 1041 v4l2_fh_add(&fh->fh);
8b2f0795
DH		 1042 return ret;
1043}
1044
1045static int au0828_v4l2_close(struct file *filp)
1046{
1047 int ret;
1048 struct au0828_fh *fh = filp->private_data;
1049 struct au0828_dev *dev = fh->dev;
1050
83b09422
HV		 1051 v4l2_fh_del(&fh->fh);
1052 v4l2_fh_exit(&fh->fh);
ea86968f 1053 mutex_lock(&dev->lock);
7f8eacd2 1054 if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
78ca5005
DH		 1055 /* Cancel timeout thread in case they didn't call streamoff */
1056 dev->vid_timeout_running = 0;
1057 del_timer_sync(&dev->vid_timeout);
1058
8b2f0795 1059 videobuf_stop(&fh->vb_vidq);
7f8eacd2
DH		 1060 res_free(fh, AU0828_RESOURCE_VIDEO);
1061 }
8b2f0795 1062
7f8eacd2 1063 if (res_check(fh, AU0828_RESOURCE_VBI)) {
78ca5005
DH		 1064 /* Cancel timeout thread in case they didn't call streamoff */
1065 dev->vbi_timeout_running = 0;
1066 del_timer_sync(&dev->vbi_timeout);
1067
7f8eacd2
DH		 1068 videobuf_stop(&fh->vb_vbiq);
1069 res_free(fh, AU0828_RESOURCE_VBI);
1070 }
1071
823beb7e 1072 if (dev->users == 1 && video_is_registered(video_devdata(filp))) {
8b2f0795
DH		 1073 au0828_analog_stream_disable(dev);
1074
1075 au0828_uninit_isoc(dev);
1076
e4b8bc52 1077 /* Save some power by putting tuner to sleep */
622b828a 1078 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
ea86968f 1079 dev->std_set_in_tuner_core = 0;
e4b8bc52 1080
8b2f0795
DH		 1081 /* When close the device, set the usb intf0 into alt0 to free
1082 USB bandwidth */
1083 ret = usb_set_interface(dev->usbdev, 0, 0);
62899a28
DH		 1084 if (ret < 0)
1085 printk(KERN_INFO "Au0828 can't set alternate to 0!\n");
8b2f0795 1086 }
ea86968f 1087 mutex_unlock(&dev->lock);
8b2f0795 1088
7f8eacd2
DH		 1089 videobuf_mmap_free(&fh->vb_vidq);
1090 videobuf_mmap_free(&fh->vb_vbiq);
8b2f0795
DH		 1091 kfree(fh);
1092 dev->users--;
1093 wake_up_interruptible_nr(&dev->open, 1);
8b2f0795
DH		 1094 return 0;
1095}
1096
ea86968f
HV		 1097/* Must be called with dev->lock held */
1098static void au0828_init_tuner(struct au0828_dev *dev)
1099{
1100 struct v4l2_frequency f = {
1101 .frequency = dev->ctrl_freq,
1102 .type = V4L2_TUNER_ANALOG_TV,
1103 };
1104
1105 if (dev->std_set_in_tuner_core)
1106 return;
1107 dev->std_set_in_tuner_core = 1;
1108 i2c_gate_ctrl(dev, 1);
1109 /* If we've never sent the standard in tuner core, do so now.
1110 We don't do this at device probe because we don't want to
1111 incur the cost of a firmware load */
1112 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->std);
1113 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
1114 i2c_gate_ctrl(dev, 0);
1115}
1116
8b2f0795
DH		 1117static ssize_t au0828_v4l2_read(struct file *filp, char __user *buf,
1118 size_t count, loff_t *pos)
1119{
1120 struct au0828_fh *fh = filp->private_data;
1121 struct au0828_dev *dev = fh->dev;
1122 int rc;
1123
1124 rc = check_dev(dev);
1125 if (rc < 0)
1126 return rc;
1127
ea86968f
HV		 1128 if (mutex_lock_interruptible(&dev->lock))
1129 return -ERESTARTSYS;
1130 au0828_init_tuner(dev);
1131 mutex_unlock(&dev->lock);
1132
62899a28 1133 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
7f8eacd2
DH		 1134 if (res_locked(dev, AU0828_RESOURCE_VIDEO))
1135 return -EBUSY;
8b2f0795
DH		 1136
1137 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
1138 filp->f_flags & O_NONBLOCK);
1139 }
7f8eacd2
DH		 1140
1141 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1142 if (!res_get(fh, AU0828_RESOURCE_VBI))
1143 return -EBUSY;
1144
bf797165
DH		 1145 if (dev->vbi_timeout_running == 0) {
1146 /* Handle case where caller tries to read without
1147 calling streamon first */
1148 dev->vbi_timeout_running = 1;
1149 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1150 }
1151
7f8eacd2
DH		 1152 return videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
1153 filp->f_flags & O_NONBLOCK);
1154 }
1155
8b2f0795
DH		 1156 return 0;
1157}
1158
1159static unsigned int au0828_v4l2_poll(struct file *filp, poll_table *wait)
1160{
1161 struct au0828_fh *fh = filp->private_data;
1162 struct au0828_dev *dev = fh->dev;
83b09422
HV		 1163 unsigned long req_events = poll_requested_events(wait);
1164 unsigned int res;
8b2f0795 1165
83b09422
HV		 1166 if (check_dev(dev) < 0)
1167 return POLLERR;
1168
1169 res = v4l2_ctrl_poll(filp, wait);
1170 if (!(req_events & (POLLIN | POLLRDNORM)))
1171 return res;
8b2f0795 1172
ea86968f
HV		 1173 if (mutex_lock_interruptible(&dev->lock))
1174 return -ERESTARTSYS;
1175 au0828_init_tuner(dev);
1176 mutex_unlock(&dev->lock);
1177
7f8eacd2
DH		 1178 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1179 if (!res_get(fh, AU0828_RESOURCE_VIDEO))
1180 return POLLERR;
83b09422
HV		 1181 return res | videobuf_poll_stream(filp, &fh->vb_vidq, wait);
1182 }
1183 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
7f8eacd2
DH		 1184 if (!res_get(fh, AU0828_RESOURCE_VBI))
1185 return POLLERR;
83b09422 1186 return res | videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
7f8eacd2 1187 }
83b09422 1188 return POLLERR;
8b2f0795
DH		 1189}
1190
1191static int au0828_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
1192{
1193 struct au0828_fh *fh = filp->private_data;
1194 struct au0828_dev *dev = fh->dev;
1195 int rc;
1196
1197 rc = check_dev(dev);
1198 if (rc < 0)
1199 return rc;
1200
7f8eacd2
DH		 1201 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1202 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1203 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1204 rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma);
8b2f0795 1205
8b2f0795
DH		 1206 return rc;
1207}
1208
1209static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
1210 struct v4l2_format *format)
1211{
1212 int ret;
1213 int width = format->fmt.pix.width;
1214 int height = format->fmt.pix.height;
8b2f0795 1215
8b2f0795
DH		 1216 /* If they are demanding a format other than the one we support,
1217 bail out (tvtime asks for UYVY and then retries with YUYV) */
62899a28 1218 if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
8b2f0795 1219 return -EINVAL;
8b2f0795
DH		 1220
1221 /* format->fmt.pix.width only support 720 and height 480 */
62899a28 1222 if (width != 720)
8b2f0795 1223 width = 720;
62899a28 1224 if (height != 480)
8b2f0795
DH		 1225 height = 480;
1226
1227 format->fmt.pix.width = width;
1228 format->fmt.pix.height = height;
1229 format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1230 format->fmt.pix.bytesperline = width * 2;
1231 format->fmt.pix.sizeimage = width * height * 2;
1232 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1233 format->fmt.pix.field = V4L2_FIELD_INTERLACED;
8d86e4e8 1234 format->fmt.pix.priv = 0;
8b2f0795 1235
62899a28 1236 if (cmd == VIDIOC_TRY_FMT)
8b2f0795
DH		 1237 return 0;
1238
1239 /* maybe set new image format, driver current only support 720*480 */
1240 dev->width = width;
1241 dev->height = height;
1242 dev->frame_size = width * height * 2;
1243 dev->field_size = width * height;
1244 dev->bytesperline = width * 2;
1245
62899a28 1246 if (dev->stream_state == STREAM_ON) {
8b2f0795 1247 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
62899a28
DH		 1248 ret = au0828_stream_interrupt(dev);
1249 if (ret != 0) {
8b2f0795
DH		 1250 dprintk(1, "error interrupting video stream!\n");
1251 return ret;
1252 }
1253 }
1254
1255 /* set au0828 interface0 to AS5 here again */
1256 ret = usb_set_interface(dev->usbdev, 0, 5);
62899a28
DH		 1257 if (ret < 0) {
1258 printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
8b2f0795
DH		 1259 return -EBUSY;
1260 }
1261
1262 au0828_analog_stream_enable(dev);
1263
1264 return 0;
1265}
1266
1267
8b2f0795
DH		 1268static int vidioc_querycap(struct file *file, void *priv,
1269 struct v4l2_capability *cap)
1270{
59e05484
HV		 1271 struct video_device *vdev = video_devdata(file);
1272 struct au0828_fh *fh = priv;
8b2f0795
DH		 1273 struct au0828_dev *dev = fh->dev;
1274
8b2f0795 1275 strlcpy(cap->driver, "au0828", sizeof(cap->driver));
f1add5b5 1276 strlcpy(cap->card, dev->board.name, sizeof(cap->card));
59e05484 1277 usb_make_path(dev->usbdev, cap->bus_info, sizeof(cap->bus_info));
8b2f0795 1278
59e05484
HV		 1279 /* set the device capabilities */
1280 cap->device_caps = V4L2_CAP_AUDIO |
8b2f0795
DH		 1281 V4L2_CAP_READWRITE |
1282 V4L2_CAP_STREAMING |
1283 V4L2_CAP_TUNER;
59e05484
HV		 1284 if (vdev->vfl_type == VFL_TYPE_GRABBER)
1285 cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
1286 else
1287 cap->device_caps |= V4L2_CAP_VBI_CAPTURE;
1288 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1289 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE;
8b2f0795
DH		 1290 return 0;
1291}
1292
1293static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1294 struct v4l2_fmtdesc *f)
1295{
62899a28 1296 if (f->index)
8b2f0795
DH		 1297 return -EINVAL;
1298
8b2f0795
DH		 1299 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1300 strcpy(f->description, "Packed YUV2");
1301
1302 f->flags = 0;
1303 f->pixelformat = V4L2_PIX_FMT_UYVY;
1304
8b2f0795
DH		 1305 return 0;
1306}
1307
1308static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1309 struct v4l2_format *f)
1310{
1311 struct au0828_fh *fh = priv;
1312 struct au0828_dev *dev = fh->dev;
1313
1314 f->fmt.pix.width = dev->width;
1315 f->fmt.pix.height = dev->height;
1316 f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1317 f->fmt.pix.bytesperline = dev->bytesperline;
1318 f->fmt.pix.sizeimage = dev->frame_size;
1319 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
1320 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
8d86e4e8 1321 f->fmt.pix.priv = 0;
8b2f0795
DH		 1322 return 0;
1323}
1324
1325static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1326 struct v4l2_format *f)
1327{
1328 struct au0828_fh *fh = priv;
1329 struct au0828_dev *dev = fh->dev;
1330
1331 return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1332}
1333
1334static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1335 struct v4l2_format *f)
1336{
1337 struct au0828_fh *fh = priv;
1338 struct au0828_dev *dev = fh->dev;
1339 int rc;
1340
7f8eacd2
DH		 1341 rc = check_dev(dev);
1342 if (rc < 0)
1343 return rc;
1344
8b2f0795 1345 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
62899a28 1346 printk(KERN_INFO "%s queue busy\n", __func__);
8b2f0795
DH		 1347 rc = -EBUSY;
1348 goto out;
1349 }
1350
7f8eacd2 1351 rc = au0828_set_format(dev, VIDIOC_S_FMT, f);
8b2f0795
DH		 1352out:
1353 return rc;
1354}
1355
314527ac 1356static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
8b2f0795
DH		 1357{
1358 struct au0828_fh *fh = priv;
1359 struct au0828_dev *dev = fh->dev;
1360
ea86968f
HV		 1361 dev->std = norm;
1362
1363 au0828_init_tuner(dev);
1364
fa09cb9a 1365 i2c_gate_ctrl(dev, 1);
e58071f0 1366
8b2f0795
DH		 1367 /* FIXME: when we support something other than NTSC, we are going to
1368 have to make the au0828 bridge adjust the size of its capture
1369 buffer, which is currently hardcoded at 720x480 */
1370
314527ac 1371 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, norm);
e58071f0 1372
fa09cb9a 1373 i2c_gate_ctrl(dev, 0);
e58071f0 1374
8b2f0795
DH		 1375 return 0;
1376}
1377
33b6b89b
HV		 1378static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1379{
1380 struct au0828_fh *fh = priv;
1381 struct au0828_dev *dev = fh->dev;
1382
1383 *norm = dev->std;
1384 return 0;
1385}
1386
8b2f0795
DH		 1387static int vidioc_enum_input(struct file *file, void *priv,
1388 struct v4l2_input *input)
1389{
1390 struct au0828_fh *fh = priv;
1391 struct au0828_dev *dev = fh->dev;
1392 unsigned int tmp;
1393
1394 static const char *inames[] = {
3d62287e 1395 [AU0828_VMUX_UNDEFINED] = "Undefined",
8b2f0795
DH		 1396 [AU0828_VMUX_COMPOSITE] = "Composite",
1397 [AU0828_VMUX_SVIDEO] = "S-Video",
1398 [AU0828_VMUX_CABLE] = "Cable TV",
1399 [AU0828_VMUX_TELEVISION] = "Television",
1400 [AU0828_VMUX_DVB] = "DVB",
1401 [AU0828_VMUX_DEBUG] = "tv debug"
1402 };
1403
1404 tmp = input->index;
1405
f5e20c34 1406 if (tmp >= AU0828_MAX_INPUT)
8b2f0795 1407 return -EINVAL;
62899a28 1408 if (AUVI_INPUT(tmp).type == 0)
8b2f0795
DH		 1409 return -EINVAL;
1410
8b2f0795 1411 input->index = tmp;
f1add5b5 1412 strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
62899a28 1413 if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
a2cf96f9 1414 (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE)) {
8b2f0795 1415 input->type |= V4L2_INPUT_TYPE_TUNER;
a2cf96f9
HV		 1416 input->audioset = 1;
1417 } else {
8b2f0795 1418 input->type |= V4L2_INPUT_TYPE_CAMERA;
a2cf96f9
HV		 1419 input->audioset = 2;
1420 }
8b2f0795
DH		 1421
1422 input->std = dev->vdev->tvnorms;
1423
1424 return 0;
1425}
1426
1427static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1428{
1429 struct au0828_fh *fh = priv;
1430 struct au0828_dev *dev = fh->dev;
1431 *i = dev->ctrl_input;
1432 return 0;
1433}
1434
56230d1e 1435static void au0828_s_input(struct au0828_dev *dev, int index)
8b2f0795 1436{
8b2f0795 1437 int i;
8b2f0795 1438
62899a28 1439 switch (AUVI_INPUT(index).type) {
8b2f0795 1440 case AU0828_VMUX_SVIDEO:
8b2f0795 1441 dev->input_type = AU0828_VMUX_SVIDEO;
a2cf96f9 1442 dev->ctrl_ainput = 1;
8b2f0795 1443 break;
8b2f0795 1444 case AU0828_VMUX_COMPOSITE:
8b2f0795 1445 dev->input_type = AU0828_VMUX_COMPOSITE;
a2cf96f9 1446 dev->ctrl_ainput = 1;
8b2f0795 1447 break;
8b2f0795 1448 case AU0828_VMUX_TELEVISION:
8b2f0795 1449 dev->input_type = AU0828_VMUX_TELEVISION;
a2cf96f9 1450 dev->ctrl_ainput = 0;
8b2f0795 1451 break;
8b2f0795 1452 default:
56230d1e 1453 dprintk(1, "unknown input type set [%d]\n",
a1094c4c
DH		 1454 AUVI_INPUT(index).type);
1455 break;
8b2f0795
DH		 1456 }
1457
5325b427
HV		 1458 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1459 AUVI_INPUT(index).vmux, 0, 0);
8b2f0795
DH		 1460
1461 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1462 int enable = 0;
62899a28 1463 if (AUVI_INPUT(i).audio_setup == NULL)
8b2f0795 1464 continue;
8b2f0795
DH		 1465
1466 if (i == index)
1467 enable = 1;
1468 else
1469 enable = 0;
1470 if (enable) {
f1add5b5 1471 (AUVI_INPUT(i).audio_setup)(dev, enable);
8b2f0795
DH		 1472 } else {
1473 /* Make sure we leave it turned on if some
1474 other input is routed to this callback */
f1add5b5
DH		 1475 if ((AUVI_INPUT(i).audio_setup) !=
1476 ((AUVI_INPUT(index).audio_setup))) {
1477 (AUVI_INPUT(i).audio_setup)(dev, enable);
8b2f0795
DH		 1478 }
1479 }
1480 }
1481
5325b427
HV		 1482 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1483 AUVI_INPUT(index).amux, 0, 0);
56230d1e
HV		 1484}
1485
1486static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1487{
1488 struct au0828_fh *fh = priv;
1489 struct au0828_dev *dev = fh->dev;
1490
1491 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
1492 index);
1493 if (index >= AU0828_MAX_INPUT)
1494 return -EINVAL;
1495 if (AUVI_INPUT(index).type == 0)
1496 return -EINVAL;
1497 dev->ctrl_input = index;
1498 au0828_s_input(dev, index);
8b2f0795
DH		 1499 return 0;
1500}
1501
a2cf96f9
HV		 1502static int vidioc_enumaudio(struct file *file, void *priv, struct v4l2_audio *a)
1503{
1504 if (a->index > 1)
1505 return -EINVAL;
1506
1507 if (a->index == 0)
1508 strcpy(a->name, "Television");
1509 else
1510 strcpy(a->name, "Line in");
1511
1512 a->capability = V4L2_AUDCAP_STEREO;
1513 return 0;
1514}
1515
8b2f0795
DH		 1516static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1517{
1518 struct au0828_fh *fh = priv;
1519 struct au0828_dev *dev = fh->dev;
8b2f0795 1520
a2cf96f9
HV		 1521 a->index = dev->ctrl_ainput;
1522 if (a->index == 0)
8b2f0795
DH		 1523 strcpy(a->name, "Television");
1524 else
1525 strcpy(a->name, "Line in");
1526
1527 a->capability = V4L2_AUDCAP_STEREO;
8b2f0795
DH		 1528 return 0;
1529}
1530
0e8025b9 1531static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
8b2f0795
DH		 1532{
1533 struct au0828_fh *fh = priv;
1534 struct au0828_dev *dev = fh->dev;
a2cf96f9 1535
62899a28 1536 if (a->index != dev->ctrl_ainput)
8b2f0795
DH		 1537 return -EINVAL;
1538 return 0;
1539}
1540
8b2f0795
DH		 1541static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1542{
1543 struct au0828_fh *fh = priv;
1544 struct au0828_dev *dev = fh->dev;
1545
62899a28 1546 if (t->index != 0)
8b2f0795
DH		 1547 return -EINVAL;
1548
8b2f0795 1549 strcpy(t->name, "Auvitek tuner");
ea86968f
HV		 1550
1551 au0828_init_tuner(dev);
1552 i2c_gate_ctrl(dev, 1);
2689d3dc 1553 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
ea86968f 1554 i2c_gate_ctrl(dev, 0);
8b2f0795
DH		 1555 return 0;
1556}
1557
1558static int vidioc_s_tuner(struct file *file, void *priv,
2f73c7c5 1559 const struct v4l2_tuner *t)
8b2f0795
DH		 1560{
1561 struct au0828_fh *fh = priv;
1562 struct au0828_dev *dev = fh->dev;
1563
62899a28 1564 if (t->index != 0)
8b2f0795
DH		 1565 return -EINVAL;
1566
ea86968f 1567 au0828_init_tuner(dev);
fa09cb9a 1568 i2c_gate_ctrl(dev, 1);
2689d3dc 1569 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
fa09cb9a 1570 i2c_gate_ctrl(dev, 0);
e58071f0 1571
8b2f0795
DH		 1572 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1573 t->afc);
e58071f0 1574
8b2f0795
DH		 1575 return 0;
1576
1577}
1578
1579static int vidioc_g_frequency(struct file *file, void *priv,
1580 struct v4l2_frequency *freq)
1581{
1582 struct au0828_fh *fh = priv;
1583 struct au0828_dev *dev = fh->dev;
c888923d 1584
e1cf6587
HV		 1585 if (freq->tuner != 0)
1586 return -EINVAL;
8b2f0795
DH		 1587 freq->frequency = dev->ctrl_freq;
1588 return 0;
1589}
1590
1591static int vidioc_s_frequency(struct file *file, void *priv,
b530a447 1592 const struct v4l2_frequency *freq)
8b2f0795
DH		 1593{
1594 struct au0828_fh *fh = priv;
1595 struct au0828_dev *dev = fh->dev;
e1cf6587 1596 struct v4l2_frequency new_freq = *freq;
8b2f0795 1597
62899a28 1598 if (freq->tuner != 0)
8b2f0795 1599 return -EINVAL;
8b2f0795 1600
ea86968f 1601 au0828_init_tuner(dev);
fa09cb9a 1602 i2c_gate_ctrl(dev, 1);
4a03dafc 1603
2689d3dc 1604 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
e1cf6587
HV		 1605 /* Get the actual set (and possibly clamped) frequency */
1606 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1607 dev->ctrl_freq = new_freq.frequency;
8b2f0795 1608
fa09cb9a 1609 i2c_gate_ctrl(dev, 0);
4a03dafc 1610
8b2f0795
DH		 1611 au0828_analog_stream_reset(dev);
1612
1613 return 0;
1614}
1615
7f8eacd2
DH		 1616
1617/* RAW VBI ioctls */
1618
1619static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1620 struct v4l2_format *format)
1621{
1622 struct au0828_fh *fh = priv;
1623 struct au0828_dev *dev = fh->dev;
1624
1625 format->fmt.vbi.samples_per_line = dev->vbi_width;
1626 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1627 format->fmt.vbi.offset = 0;
1628 format->fmt.vbi.flags = 0;
1629 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1630
1631 format->fmt.vbi.count[0] = dev->vbi_height;
1632 format->fmt.vbi.count[1] = dev->vbi_height;
1633 format->fmt.vbi.start[0] = 21;
1634 format->fmt.vbi.start[1] = 284;
8d86e4e8 1635 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
7f8eacd2
DH		 1636
1637 return 0;
1638}
1639
8b2f0795
DH		 1640static int vidioc_cropcap(struct file *file, void *priv,
1641 struct v4l2_cropcap *cc)
1642{
1643 struct au0828_fh *fh = priv;
1644 struct au0828_dev *dev = fh->dev;
1645
62899a28 1646 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
8b2f0795
DH		 1647 return -EINVAL;
1648
1649 cc->bounds.left = 0;
1650 cc->bounds.top = 0;
1651 cc->bounds.width = dev->width;
1652 cc->bounds.height = dev->height;
1653
1654 cc->defrect = cc->bounds;
1655
1656 cc->pixelaspect.numerator = 54;
1657 cc->pixelaspect.denominator = 59;
1658
1659 return 0;
1660}
1661
1662static int vidioc_streamon(struct file *file, void *priv,
1663 enum v4l2_buf_type type)
1664{
7f8eacd2
DH		 1665 struct au0828_fh *fh = priv;
1666 struct au0828_dev *dev = fh->dev;
1667 int rc = -EINVAL;
8b2f0795
DH		 1668
1669 rc = check_dev(dev);
1670 if (rc < 0)
1671 return rc;
1672
7f8eacd2
DH		 1673 if (unlikely(type != fh->type))
1674 return -EINVAL;
1675
1676 dprintk(1, "vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
1677 fh, type, fh->resources, dev->resources);
1678
1679 if (unlikely(!res_get(fh, get_ressource(fh))))
1680 return -EBUSY;
1681
ea86968f 1682 au0828_init_tuner(dev);
8b2f0795
DH		 1683 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1684 au0828_analog_stream_enable(dev);
2689d3dc 1685 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
8b2f0795
DH		 1686 }
1687
78ca5005 1688 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
8b2f0795 1689 rc = videobuf_streamon(&fh->vb_vidq);
78ca5005
DH		 1690 dev->vid_timeout_running = 1;
1691 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1692 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
7f8eacd2 1693 rc = videobuf_streamon(&fh->vb_vbiq);
78ca5005
DH		 1694 dev->vbi_timeout_running = 1;
1695 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1696 }
8b2f0795
DH		 1697
1698 return rc;
1699}
1700
1701static int vidioc_streamoff(struct file *file, void *priv,
1702 enum v4l2_buf_type type)
1703{
7f8eacd2
DH		 1704 struct au0828_fh *fh = priv;
1705 struct au0828_dev *dev = fh->dev;
1706 int rc;
1707 int i;
8b2f0795
DH		 1708
1709 rc = check_dev(dev);
1710 if (rc < 0)
1711 return rc;
1712
7f8eacd2
DH		 1713 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1714 fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
8b2f0795
DH		 1715 return -EINVAL;
1716 if (type != fh->type)
1717 return -EINVAL;
1718
7f8eacd2
DH		 1719 dprintk(1, "vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
1720 fh, type, fh->resources, dev->resources);
1721
1722 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
78ca5005
DH		 1723 dev->vid_timeout_running = 0;
1724 del_timer_sync(&dev->vid_timeout);
1725
2689d3dc 1726 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
7f8eacd2
DH		 1727 rc = au0828_stream_interrupt(dev);
1728 if (rc != 0)
1729 return rc;
8b2f0795 1730
7f8eacd2
DH		 1731 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1732 if (AUVI_INPUT(i).audio_setup == NULL)
1733 continue;
1734 (AUVI_INPUT(i).audio_setup)(dev, 0);
1735 }
8b2f0795 1736
a595c1ce
DH		 1737 if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
1738 videobuf_streamoff(&fh->vb_vidq);
1739 res_free(fh, AU0828_RESOURCE_VIDEO);
1740 }
7f8eacd2 1741 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
78ca5005
DH		 1742 dev->vbi_timeout_running = 0;
1743 del_timer_sync(&dev->vbi_timeout);
1744
a595c1ce
DH		 1745 if (res_check(fh, AU0828_RESOURCE_VBI)) {
1746 videobuf_streamoff(&fh->vb_vbiq);
1747 res_free(fh, AU0828_RESOURCE_VBI);
1748 }
7f8eacd2 1749 }
8b2f0795
DH		 1750
1751 return 0;
1752}
1753
80c6e358 1754#ifdef CONFIG_VIDEO_ADV_DEBUG
8b2f0795
DH		 1755static int vidioc_g_register(struct file *file, void *priv,
1756 struct v4l2_dbg_register *reg)
1757{
1758 struct au0828_fh *fh = priv;
1759 struct au0828_dev *dev = fh->dev;
1760
364d2db2 1761 reg->val = au0828_read(dev, reg->reg);
ead5bc4e 1762 reg->size = 1;
364d2db2 1763 return 0;
8b2f0795
DH		 1764}
1765
1766static int vidioc_s_register(struct file *file, void *priv,
977ba3b1 1767 const struct v4l2_dbg_register *reg)
8b2f0795
DH		 1768{
1769 struct au0828_fh *fh = priv;
1770 struct au0828_dev *dev = fh->dev;
1771
364d2db2 1772 return au0828_writereg(dev, reg->reg, reg->val);
8b2f0795 1773}
80c6e358 1774#endif
8b2f0795 1775
83b09422
HV		 1776static int vidioc_log_status(struct file *file, void *fh)
1777{
1778 struct video_device *vdev = video_devdata(file);
1779
1780 v4l2_ctrl_log_status(file, fh);
1781 v4l2_device_call_all(vdev->v4l2_dev, 0, core, log_status);
1782 return 0;
1783}
1784
8b2f0795
DH		 1785static int vidioc_reqbufs(struct file *file, void *priv,
1786 struct v4l2_requestbuffers *rb)
1787{
1788 struct au0828_fh *fh = priv;
1789 struct au0828_dev *dev = fh->dev;
1790 int rc;
1791
1792 rc = check_dev(dev);
1793 if (rc < 0)
1794 return rc;
1795
54ebb8b8
DH		 1796 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1797 rc = videobuf_reqbufs(&fh->vb_vidq, rb);
1798 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1799 rc = videobuf_reqbufs(&fh->vb_vbiq, rb);
1800
1801 return rc;
8b2f0795
DH		 1802}
1803
1804static int vidioc_querybuf(struct file *file, void *priv,
1805 struct v4l2_buffer *b)
1806{
1807 struct au0828_fh *fh = priv;
1808 struct au0828_dev *dev = fh->dev;
1809 int rc;
1810
1811 rc = check_dev(dev);
1812 if (rc < 0)
1813 return rc;
1814
54ebb8b8
DH		 1815 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1816 rc = videobuf_querybuf(&fh->vb_vidq, b);
1817 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1818 rc = videobuf_querybuf(&fh->vb_vbiq, b);
1819
1820 return rc;
8b2f0795
DH		 1821}
1822
1823static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1824{
1825 struct au0828_fh *fh = priv;
1826 struct au0828_dev *dev = fh->dev;
1827 int rc;
1828
1829 rc = check_dev(dev);
1830 if (rc < 0)
1831 return rc;
1832
54ebb8b8
DH		 1833 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1834 rc = videobuf_qbuf(&fh->vb_vidq, b);
1835 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1836 rc = videobuf_qbuf(&fh->vb_vbiq, b);
1837
1838 return rc;
8b2f0795
DH		 1839}
1840
1841static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1842{
1843 struct au0828_fh *fh = priv;
1844 struct au0828_dev *dev = fh->dev;
1845 int rc;
1846
1847 rc = check_dev(dev);
1848 if (rc < 0)
1849 return rc;
1850
1851 /* Workaround for a bug in the au0828 hardware design that sometimes
1852 results in the colorspace being inverted */
1853 if (dev->greenscreen_detected == 1) {
1854 dprintk(1, "Detected green frame. Resetting stream...\n");
1855 au0828_analog_stream_reset(dev);
1856 dev->greenscreen_detected = 0;
1857 }
1858
54ebb8b8
DH		 1859 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1860 rc = videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1861 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1862 rc = videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags & O_NONBLOCK);
1863
1864 return rc;
8b2f0795
DH		 1865}
1866
8b2f0795
DH		 1867static struct v4l2_file_operations au0828_v4l_fops = {
1868 .owner = THIS_MODULE,
1869 .open = au0828_v4l2_open,
1870 .release = au0828_v4l2_close,
1871 .read = au0828_v4l2_read,
1872 .poll = au0828_v4l2_poll,
1873 .mmap = au0828_v4l2_mmap,
549ee4df 1874 .unlocked_ioctl = video_ioctl2,
8b2f0795
DH		 1875};
1876
1877static const struct v4l2_ioctl_ops video_ioctl_ops = {
1878 .vidioc_querycap = vidioc_querycap,
1879 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1880 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1881 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1882 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
5a5a4e16 1883 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
8d86e4e8 1884 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
7f8eacd2 1885 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
a2cf96f9 1886 .vidioc_enumaudio = vidioc_enumaudio,
8b2f0795
DH		 1887 .vidioc_g_audio = vidioc_g_audio,
1888 .vidioc_s_audio = vidioc_s_audio,
1889 .vidioc_cropcap = vidioc_cropcap,
8b2f0795
DH		 1890 .vidioc_reqbufs = vidioc_reqbufs,
1891 .vidioc_querybuf = vidioc_querybuf,
1892 .vidioc_qbuf = vidioc_qbuf,
1893 .vidioc_dqbuf = vidioc_dqbuf,
1894 .vidioc_s_std = vidioc_s_std,
33b6b89b 1895 .vidioc_g_std = vidioc_g_std,
8b2f0795
DH		 1896 .vidioc_enum_input = vidioc_enum_input,
1897 .vidioc_g_input = vidioc_g_input,
1898 .vidioc_s_input = vidioc_s_input,
8b2f0795
DH		 1899 .vidioc_streamon = vidioc_streamon,
1900 .vidioc_streamoff = vidioc_streamoff,
1901 .vidioc_g_tuner = vidioc_g_tuner,
1902 .vidioc_s_tuner = vidioc_s_tuner,
1903 .vidioc_g_frequency = vidioc_g_frequency,
1904 .vidioc_s_frequency = vidioc_s_frequency,
1905#ifdef CONFIG_VIDEO_ADV_DEBUG
1906 .vidioc_g_register = vidioc_g_register,
1907 .vidioc_s_register = vidioc_s_register,
8b2f0795 1908#endif
83b09422
HV		 1909 .vidioc_log_status = vidioc_log_status,
1910 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1911 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
8b2f0795
DH		 1912};
1913
1914static const struct video_device au0828_video_template = {
1915 .fops = &au0828_v4l_fops,
1916 .release = video_device_release,
1917 .ioctl_ops = &video_ioctl_ops,
0ef21071 1918 .tvnorms = V4L2_STD_NTSC_M,
8b2f0795
DH		 1919};
1920
1921/**************************************************************************/
1922
fc4ce6cd
DH		 1923int au0828_analog_register(struct au0828_dev *dev,
1924 struct usb_interface *interface)
8b2f0795
DH		 1925{
1926 int retval = -ENOMEM;
fc4ce6cd
DH		 1927 struct usb_host_interface *iface_desc;
1928 struct usb_endpoint_descriptor *endpoint;
d63b21bf 1929 int i, ret;
8b2f0795
DH		 1930
1931 dprintk(1, "au0828_analog_register called!\n");
1932
fc4ce6cd
DH		 1933 /* set au0828 usb interface0 to as5 */
1934 retval = usb_set_interface(dev->usbdev,
62899a28 1935 interface->cur_altsetting->desc.bInterfaceNumber, 5);
fc4ce6cd 1936 if (retval != 0) {
62899a28 1937 printk(KERN_INFO "Failure setting usb interface0 to as5\n");
fc4ce6cd
DH		 1938 return retval;
1939 }
1940
1941 /* Figure out which endpoint has the isoc interface */
1942 iface_desc = interface->cur_altsetting;
62899a28 1943 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
fc4ce6cd 1944 endpoint = &iface_desc->endpoint[i].desc;
62899a28
DH		 1945 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1946 == USB_DIR_IN) &&
1947 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1948 == USB_ENDPOINT_XFER_ISOC)) {
fc4ce6cd
DH		 1949
1950 /* we find our isoc in endpoint */
1951 u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
62899a28
DH		 1952 dev->max_pkt_size = (tmp & 0x07ff) *
1953 (((tmp & 0x1800) >> 11) + 1);
fc4ce6cd
DH		 1954 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1955 }
1956 }
62899a28
DH		 1957 if (!(dev->isoc_in_endpointaddr)) {
1958 printk(KERN_INFO "Could not locate isoc endpoint\n");
fc4ce6cd
DH		 1959 kfree(dev);
1960 return -ENODEV;
1961 }
1962
8b2f0795
DH		 1963 init_waitqueue_head(&dev->open);
1964 spin_lock_init(&dev->slock);
8b2f0795 1965
7f8eacd2 1966 /* init video dma queues */
8b2f0795
DH		 1967 INIT_LIST_HEAD(&dev->vidq.active);
1968 INIT_LIST_HEAD(&dev->vidq.queued);
7f8eacd2
DH		 1969 INIT_LIST_HEAD(&dev->vbiq.active);
1970 INIT_LIST_HEAD(&dev->vbiq.queued);
8b2f0795 1971
78ca5005
DH		 1972 dev->vid_timeout.function = au0828_vid_buffer_timeout;
1973 dev->vid_timeout.data = (unsigned long) dev;
1974 init_timer(&dev->vid_timeout);
1975
1976 dev->vbi_timeout.function = au0828_vbi_buffer_timeout;
1977 dev->vbi_timeout.data = (unsigned long) dev;
1978 init_timer(&dev->vbi_timeout);
1979
8b2f0795
DH		 1980 dev->width = NTSC_STD_W;
1981 dev->height = NTSC_STD_H;
1982 dev->field_size = dev->width * dev->height;
1983 dev->frame_size = dev->field_size << 1;
1984 dev->bytesperline = dev->width << 1;
de8d2bbf
HV		 1985 dev->vbi_width = 720;
1986 dev->vbi_height = 1;
8b2f0795 1987 dev->ctrl_ainput = 0;
e1cf6587 1988 dev->ctrl_freq = 960;
33b6b89b 1989 dev->std = V4L2_STD_NTSC_M;
56230d1e 1990 au0828_s_input(dev, 0);
8b2f0795
DH		 1991
1992 /* allocate and fill v4l2 video struct */
1993 dev->vdev = video_device_alloc();
62899a28 1994 if (NULL == dev->vdev) {
8b2f0795
DH		 1995 dprintk(1, "Can't allocate video_device.\n");
1996 return -ENOMEM;
1997 }
1998
7f8eacd2 1999 /* allocate the VBI struct */
8b2f0795 2000 dev->vbi_dev = video_device_alloc();
62899a28 2001 if (NULL == dev->vbi_dev) {
8b2f0795 2002 dprintk(1, "Can't allocate vbi_device.\n");
d63b21bf
JL		 2003 ret = -ENOMEM;
2004 goto err_vdev;
8b2f0795
DH		 2005 }
2006
2007 /* Fill the video capture device struct */
2008 *dev->vdev = au0828_video_template;
e8c26f45 2009 dev->vdev->v4l2_dev = &dev->v4l2_dev;
549ee4df 2010 dev->vdev->lock = &dev->lock;
83b09422 2011 set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev->flags);
8b2f0795
DH		 2012 strcpy(dev->vdev->name, "au0828a video");
2013
2014 /* Setup the VBI device */
2015 *dev->vbi_dev = au0828_video_template;
e8c26f45 2016 dev->vbi_dev->v4l2_dev = &dev->v4l2_dev;
549ee4df 2017 dev->vbi_dev->lock = &dev->lock;
83b09422 2018 set_bit(V4L2_FL_USE_FH_PRIO, &dev->vbi_dev->flags);
8b2f0795
DH		 2019 strcpy(dev->vbi_dev->name, "au0828a vbi");
2020
8b2f0795 2021 /* Register the v4l2 device */
63b0d5ad 2022 video_set_drvdata(dev->vdev, dev);
62899a28
DH		 2023 retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
2024 if (retval != 0) {
2025 dprintk(1, "unable to register video device (error = %d).\n",
2026 retval);
d63b21bf
JL		 2027 ret = -ENODEV;
2028 goto err_vbi_dev;
8b2f0795
DH		 2029 }
2030
2031 /* Register the vbi device */
63b0d5ad 2032 video_set_drvdata(dev->vbi_dev, dev);
62899a28
DH		 2033 retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
2034 if (retval != 0) {
2035 dprintk(1, "unable to register vbi device (error = %d).\n",
2036 retval);
d63b21bf
JL		 2037 ret = -ENODEV;
2038 goto err_vbi_dev;
8b2f0795
DH		 2039 }
2040
62899a28 2041 dprintk(1, "%s completed!\n", __func__);
8b2f0795
DH		 2042
2043 return 0;
d63b21bf
JL		 2044
2045err_vbi_dev:
2046 video_device_release(dev->vbi_dev);
2047err_vdev:
2048 video_device_release(dev->vdev);
2049 return ret;
8b2f0795
DH		 2050}
2051
Ubuntu Artful kernel mirror