projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'v3.10.55' into update
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / usb / au0828 / au0828-video.c
CommitLineData
8b2f0795
DH		 1/*
2 * Auvitek AU0828 USB Bridge (Analog video support)
3 *
4 * Copyright (C) 2009 Devin Heitmueller <dheitmueller@linuxtv.org>
5 * Copyright (C) 2005-2008 Auvitek International, Ltd.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * As published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301, USA.
21 */
22
23/* Developer Notes:
24 *
25 * VBI support is not yet working
26 * The hardware scaler supported is unimplemented
27 * AC97 audio support is unimplemented (only i2s audio mode)
28 *
29 */
30
31#include <linux/module.h>
5a0e3ad6 32#include <linux/slab.h>
8b2f0795
DH		 33#include <linux/init.h>
34#include <linux/device.h>
35#include <linux/suspend.h>
8b2f0795
DH		 36#include <media/v4l2-common.h>
37#include <media/v4l2-ioctl.h>
83b09422 38#include <media/v4l2-event.h>
8b2f0795
DH		 39#include <media/v4l2-chip-ident.h>
40#include <media/tuner.h>
41#include "au0828.h"
42#include "au0828-reg.h"
43
8b2f0795
DH		 44static DEFINE_MUTEX(au0828_sysfs_lock);
45
8b2f0795
DH		 46/* ------------------------------------------------------------------
47 Videobuf operations
48 ------------------------------------------------------------------*/
49
50static unsigned int isoc_debug;
51module_param(isoc_debug, int, 0644);
52MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
53
54#define au0828_isocdbg(fmt, arg...) \
55do {\
56 if (isoc_debug) { \
57 printk(KERN_INFO "au0828 %s :"fmt, \
58 __func__ , ##arg); \
59 } \
60 } while (0)
61
fa09cb9a
HV		 62static inline void i2c_gate_ctrl(struct au0828_dev *dev, int val)
63{
64 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
65 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, val);
66}
67
8b2f0795
DH		 68static inline void print_err_status(struct au0828_dev *dev,
69 int packet, int status)
70{
71 char *errmsg = "Unknown";
72
73 switch (status) {
74 case -ENOENT:
75 errmsg = "unlinked synchronuously";
76 break;
77 case -ECONNRESET:
78 errmsg = "unlinked asynchronuously";
79 break;
80 case -ENOSR:
81 errmsg = "Buffer error (overrun)";
82 break;
83 case -EPIPE:
84 errmsg = "Stalled (device not responding)";
85 break;
86 case -EOVERFLOW:
87 errmsg = "Babble (bad cable?)";
88 break;
89 case -EPROTO:
90 errmsg = "Bit-stuff error (bad cable?)";
91 break;
92 case -EILSEQ:
93 errmsg = "CRC/Timeout (could be anything)";
94 break;
95 case -ETIME:
96 errmsg = "Device does not respond";
97 break;
98 }
99 if (packet < 0) {
100 au0828_isocdbg("URB status %d [%s].\n", status, errmsg);
101 } else {
102 au0828_isocdbg("URB packet %d, status %d [%s].\n",
103 packet, status, errmsg);
104 }
105}
106
107static int check_dev(struct au0828_dev *dev)
108{
109 if (dev->dev_state & DEV_DISCONNECTED) {
62899a28 110 printk(KERN_INFO "v4l2 ioctl: device not present\n");
8b2f0795
DH		 111 return -ENODEV;
112 }
113
114 if (dev->dev_state & DEV_MISCONFIGURED) {
62899a28 115 printk(KERN_INFO "v4l2 ioctl: device is misconfigured; "
8b2f0795
DH		 116 "close and open it again\n");
117 return -EIO;
118 }
119 return 0;
120}
121
122/*
123 * IRQ callback, called by URB callback
124 */
125static void au0828_irq_callback(struct urb *urb)
126{
127 struct au0828_dmaqueue *dma_q = urb->context;
128 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
78ca5005 129 unsigned long flags = 0;
e92ba283 130 int i;
8b2f0795
DH		 131
132 switch (urb->status) {
133 case 0: /* success */
134 case -ETIMEDOUT: /* NAK */
135 break;
136 case -ECONNRESET: /* kill */
137 case -ENOENT:
138 case -ESHUTDOWN:
139 au0828_isocdbg("au0828_irq_callback called: status kill\n");
140 return;
141 default: /* unknown error */
142 au0828_isocdbg("urb completition error %d.\n", urb->status);
143 break;
144 }
145
146 /* Copy data from URB */
78ca5005 147 spin_lock_irqsave(&dev->slock, flags);
e92ba283 148 dev->isoc_ctl.isoc_copy(dev, urb);
78ca5005 149 spin_unlock_irqrestore(&dev->slock, flags);
8b2f0795
DH		 150
151 /* Reset urb buffers */
152 for (i = 0; i < urb->number_of_packets; i++) {
153 urb->iso_frame_desc[i].status = 0;
154 urb->iso_frame_desc[i].actual_length = 0;
155 }
156 urb->status = 0;
157
158 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
159 if (urb->status) {
160 au0828_isocdbg("urb resubmit failed (error=%i)\n",
161 urb->status);
162 }
163}
164
165/*
166 * Stop and Deallocate URBs
167 */
a094ca46 168static void au0828_uninit_isoc(struct au0828_dev *dev)
8b2f0795
DH		 169{
170 struct urb *urb;
171 int i;
172
173 au0828_isocdbg("au0828: called au0828_uninit_isoc\n");
174
175 dev->isoc_ctl.nfields = -1;
176 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
177 urb = dev->isoc_ctl.urb[i];
178 if (urb) {
179 if (!irqs_disabled())
180 usb_kill_urb(urb);
181 else
182 usb_unlink_urb(urb);
183
184 if (dev->isoc_ctl.transfer_buffer[i]) {
997ea58e 185 usb_free_coherent(dev->usbdev,
8b2f0795
DH		 186 urb->transfer_buffer_length,
187 dev->isoc_ctl.transfer_buffer[i],
188 urb->transfer_dma);
189 }
190 usb_free_urb(urb);
191 dev->isoc_ctl.urb[i] = NULL;
192 }
193 dev->isoc_ctl.transfer_buffer[i] = NULL;
194 }
195
196 kfree(dev->isoc_ctl.urb);
197 kfree(dev->isoc_ctl.transfer_buffer);
198
199 dev->isoc_ctl.urb = NULL;
200 dev->isoc_ctl.transfer_buffer = NULL;
201 dev->isoc_ctl.num_bufs = 0;
202}
203
204/*
205 * Allocate URBs and start IRQ
206 */
a094ca46
MCC		 207static int au0828_init_isoc(struct au0828_dev *dev, int max_packets,
208 int num_bufs, int max_pkt_size,
209 int (*isoc_copy) (struct au0828_dev *dev, struct urb *urb))
8b2f0795
DH		 210{
211 struct au0828_dmaqueue *dma_q = &dev->vidq;
212 int i;
213 int sb_size, pipe;
214 struct urb *urb;
215 int j, k;
216 int rc;
217
218 au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
219
220 /* De-allocates all pending stuff */
221 au0828_uninit_isoc(dev);
222
223 dev->isoc_ctl.isoc_copy = isoc_copy;
224 dev->isoc_ctl.num_bufs = num_bufs;
225
226 dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
227 if (!dev->isoc_ctl.urb) {
228 au0828_isocdbg("cannot alloc memory for usb buffers\n");
229 return -ENOMEM;
230 }
231
232 dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
233 GFP_KERNEL);
234 if (!dev->isoc_ctl.transfer_buffer) {
235 au0828_isocdbg("cannot allocate memory for usb transfer\n");
236 kfree(dev->isoc_ctl.urb);
237 return -ENOMEM;
238 }
239
240 dev->isoc_ctl.max_pkt_size = max_pkt_size;
241 dev->isoc_ctl.buf = NULL;
242
243 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
244
245 /* allocate urbs and transfer buffers */
246 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
247 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
248 if (!urb) {
249 au0828_isocdbg("cannot alloc isoc_ctl.urb %i\n", i);
250 au0828_uninit_isoc(dev);
251 return -ENOMEM;
252 }
253 dev->isoc_ctl.urb[i] = urb;
254
997ea58e 255 dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->usbdev,
8b2f0795
DH		 256 sb_size, GFP_KERNEL, &urb->transfer_dma);
257 if (!dev->isoc_ctl.transfer_buffer[i]) {
258 printk("unable to allocate %i bytes for transfer"
259 " buffer %i%s\n",
260 sb_size, i,
261 in_interrupt() ? " while in int" : "");
262 au0828_uninit_isoc(dev);
263 return -ENOMEM;
264 }
265 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
266
267 pipe = usb_rcvisocpipe(dev->usbdev,
268 dev->isoc_in_endpointaddr),
269
270 usb_fill_int_urb(urb, dev->usbdev, pipe,
271 dev->isoc_ctl.transfer_buffer[i], sb_size,
272 au0828_irq_callback, dma_q, 1);
273
274 urb->number_of_packets = max_packets;
fadadb7d 275 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
8b2f0795
DH		 276
277 k = 0;
278 for (j = 0; j < max_packets; j++) {
279 urb->iso_frame_desc[j].offset = k;
280 urb->iso_frame_desc[j].length =
281 dev->isoc_ctl.max_pkt_size;
282 k += dev->isoc_ctl.max_pkt_size;
283 }
284 }
285
286 init_waitqueue_head(&dma_q->wq);
287
288 /* submit urbs and enables IRQ */
289 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
290 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
291 if (rc) {
292 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
293 i, rc);
294 au0828_uninit_isoc(dev);
295 return rc;
296 }
297 }
298
299 return 0;
300}
301
302/*
303 * Announces that a buffer were filled and request the next
304 */
305static inline void buffer_filled(struct au0828_dev *dev,
306 struct au0828_dmaqueue *dma_q,
307 struct au0828_buffer *buf)
308{
309 /* Advice that buffer was filled */
310 au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
311
312 buf->vb.state = VIDEOBUF_DONE;
313 buf->vb.field_count++;
8e6057b5 314 v4l2_get_timestamp(&buf->vb.ts);
8b2f0795
DH		 315
316 dev->isoc_ctl.buf = NULL;
317
318 list_del(&buf->vb.queue);
319 wake_up(&buf->vb.done);
320}
321
7f8eacd2
DH		 322static inline void vbi_buffer_filled(struct au0828_dev *dev,
323 struct au0828_dmaqueue *dma_q,
324 struct au0828_buffer *buf)
325{
326 /* Advice that buffer was filled */
327 au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
328
329 buf->vb.state = VIDEOBUF_DONE;
330 buf->vb.field_count++;
8e6057b5 331 v4l2_get_timestamp(&buf->vb.ts);
7f8eacd2
DH		 332
333 dev->isoc_ctl.vbi_buf = NULL;
334
335 list_del(&buf->vb.queue);
336 wake_up(&buf->vb.done);
337}
338
8b2f0795
DH		 339/*
340 * Identify the buffer header type and properly handles
341 */
342static void au0828_copy_video(struct au0828_dev *dev,
343 struct au0828_dmaqueue *dma_q,
344 struct au0828_buffer *buf,
345 unsigned char *p,
346 unsigned char *outp, unsigned long len)
347{
348 void *fieldstart, *startwrite, *startread;
349 int linesdone, currlinedone, offset, lencopy, remain;
350 int bytesperline = dev->width << 1; /* Assumes 16-bit depth @@@@ */
351
7f8eacd2
DH		 352 if (len == 0)
353 return;
354
8b2f0795
DH		 355 if (dma_q->pos + len > buf->vb.size)
356 len = buf->vb.size - dma_q->pos;
357
358 startread = p;
359 remain = len;
360
361 /* Interlaces frame */
362 if (buf->top_field)
363 fieldstart = outp;
364 else
365 fieldstart = outp + bytesperline;
366
367 linesdone = dma_q->pos / bytesperline;
368 currlinedone = dma_q->pos % bytesperline;
369 offset = linesdone * bytesperline * 2 + currlinedone;
370 startwrite = fieldstart + offset;
371 lencopy = bytesperline - currlinedone;
372 lencopy = lencopy > remain ? remain : lencopy;
373
374 if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
375 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
376 ((char *)startwrite + lencopy) -
377 ((char *)outp + buf->vb.size));
378 remain = (char *)outp + buf->vb.size - (char *)startwrite;
379 lencopy = remain;
380 }
381 if (lencopy <= 0)
382 return;
383 memcpy(startwrite, startread, lencopy);
384
385 remain -= lencopy;
386
387 while (remain > 0) {
388 startwrite += lencopy + bytesperline;
389 startread += lencopy;
390 if (bytesperline > remain)
391 lencopy = remain;
392 else
393 lencopy = bytesperline;
394
395 if ((char *)startwrite + lencopy > (char *)outp +
396 buf->vb.size) {
62899a28 397 au0828_isocdbg("Overflow %zi bytes past buf end (2)\n",
8b2f0795
DH		 398 ((char *)startwrite + lencopy) -
399 ((char *)outp + buf->vb.size));
400 lencopy = remain = (char *)outp + buf->vb.size -
401 (char *)startwrite;
402 }
403 if (lencopy <= 0)
404 break;
405
406 memcpy(startwrite, startread, lencopy);
407
408 remain -= lencopy;
409 }
410
411 if (offset > 1440) {
412 /* We have enough data to check for greenscreen */
62899a28 413 if (outp[0] < 0x60 && outp[1440] < 0x60)
8b2f0795 414 dev->greenscreen_detected = 1;
8b2f0795
DH		 415 }
416
417 dma_q->pos += len;
418}
419
420/*
421 * video-buf generic routine to get the next available buffer
422 */
423static inline void get_next_buf(struct au0828_dmaqueue *dma_q,
424 struct au0828_buffer **buf)
425{
426 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
427
428 if (list_empty(&dma_q->active)) {
429 au0828_isocdbg("No active queue to serve\n");
430 dev->isoc_ctl.buf = NULL;
431 *buf = NULL;
432 return;
433 }
434
435 /* Get the next buffer */
436 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
437 dev->isoc_ctl.buf = *buf;
438
439 return;
440}
441
7f8eacd2
DH		 442static void au0828_copy_vbi(struct au0828_dev *dev,
443 struct au0828_dmaqueue *dma_q,
444 struct au0828_buffer *buf,
445 unsigned char *p,
446 unsigned char *outp, unsigned long len)
447{
448 unsigned char *startwrite, *startread;
b5f5933a 449 int bytesperline;
7f8eacd2
DH		 450 int i, j = 0;
451
452 if (dev == NULL) {
453 au0828_isocdbg("dev is null\n");
454 return;
455 }
456
457 if (dma_q == NULL) {
458 au0828_isocdbg("dma_q is null\n");
459 return;
460 }
461 if (buf == NULL)
462 return;
463 if (p == NULL) {
464 au0828_isocdbg("p is null\n");
465 return;
466 }
467 if (outp == NULL) {
468 au0828_isocdbg("outp is null\n");
469 return;
470 }
471
b5f5933a
DC		 472 bytesperline = dev->vbi_width;
473
7f8eacd2
DH		 474 if (dma_q->pos + len > buf->vb.size)
475 len = buf->vb.size - dma_q->pos;
476
477 startread = p;
478 startwrite = outp + (dma_q->pos / 2);
479
480 /* Make sure the bottom field populates the second half of the frame */
481 if (buf->top_field == 0)
482 startwrite += bytesperline * dev->vbi_height;
483
484 for (i = 0; i < len; i += 2)
485 startwrite[j++] = startread[i+1];
486
487 dma_q->pos += len;
488}
489
490
491/*
492 * video-buf generic routine to get the next available VBI buffer
493 */
494static inline void vbi_get_next_buf(struct au0828_dmaqueue *dma_q,
495 struct au0828_buffer **buf)
496{
497 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vbiq);
498 char *outp;
499
500 if (list_empty(&dma_q->active)) {
501 au0828_isocdbg("No active queue to serve\n");
502 dev->isoc_ctl.vbi_buf = NULL;
503 *buf = NULL;
504 return;
505 }
506
507 /* Get the next buffer */
508 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
25985edc 509 /* Cleans up buffer - Useful for testing for frame/URB loss */
7f8eacd2
DH		 510 outp = videobuf_to_vmalloc(&(*buf)->vb);
511 memset(outp, 0x00, (*buf)->vb.size);
512
513 dev->isoc_ctl.vbi_buf = *buf;
514
515 return;
516}
517
8b2f0795
DH		 518/*
519 * Controls the isoc copy of each urb packet
520 */
521static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
522{
523 struct au0828_buffer *buf;
7f8eacd2 524 struct au0828_buffer *vbi_buf;
8b2f0795 525 struct au0828_dmaqueue *dma_q = urb->context;
7f8eacd2 526 struct au0828_dmaqueue *vbi_dma_q = &dev->vbiq;
8b2f0795 527 unsigned char *outp = NULL;
7f8eacd2 528 unsigned char *vbioutp = NULL;
8b2f0795
DH		 529 int i, len = 0, rc = 1;
530 unsigned char *p;
531 unsigned char fbyte;
7f8eacd2
DH		 532 unsigned int vbi_field_size;
533 unsigned int remain, lencopy;
8b2f0795
DH		 534
535 if (!dev)
536 return 0;
537
538 if ((dev->dev_state & DEV_DISCONNECTED) ||
539 (dev->dev_state & DEV_MISCONFIGURED))
540 return 0;
541
542 if (urb->status < 0) {
543 print_err_status(dev, -1, urb->status);
544 if (urb->status == -ENOENT)
545 return 0;
546 }
547
548 buf = dev->isoc_ctl.buf;
549 if (buf != NULL)
550 outp = videobuf_to_vmalloc(&buf->vb);
551
7f8eacd2
DH		 552 vbi_buf = dev->isoc_ctl.vbi_buf;
553 if (vbi_buf != NULL)
554 vbioutp = videobuf_to_vmalloc(&vbi_buf->vb);
555
8b2f0795
DH		 556 for (i = 0; i < urb->number_of_packets; i++) {
557 int status = urb->iso_frame_desc[i].status;
558
559 if (status < 0) {
560 print_err_status(dev, i, status);
561 if (urb->iso_frame_desc[i].status != -EPROTO)
562 continue;
563 }
564
62899a28 565 if (urb->iso_frame_desc[i].actual_length <= 0)
8b2f0795 566 continue;
62899a28 567
8b2f0795
DH		 568 if (urb->iso_frame_desc[i].actual_length >
569 dev->max_pkt_size) {
570 au0828_isocdbg("packet bigger than packet size");
571 continue;
572 }
573
574 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
575 fbyte = p[0];
576 len = urb->iso_frame_desc[i].actual_length - 4;
577 p += 4;
578
579 if (fbyte & 0x80) {
580 len -= 4;
581 p += 4;
582 au0828_isocdbg("Video frame %s\n",
583 (fbyte & 0x40) ? "odd" : "even");
bde3bb9a 584 if (fbyte & 0x40) {
7f8eacd2
DH		 585 /* VBI */
586 if (vbi_buf != NULL)
587 vbi_buffer_filled(dev,
588 vbi_dma_q,
589 vbi_buf);
590 vbi_get_next_buf(vbi_dma_q, &vbi_buf);
591 if (vbi_buf == NULL)
592 vbioutp = NULL;
593 else
594 vbioutp = videobuf_to_vmalloc(
595 &vbi_buf->vb);
596
597 /* Video */
8b2f0795
DH		 598 if (buf != NULL)
599 buffer_filled(dev, dma_q, buf);
600 get_next_buf(dma_q, &buf);
62899a28 601 if (buf == NULL)
8b2f0795 602 outp = NULL;
62899a28 603 else
8b2f0795 604 outp = videobuf_to_vmalloc(&buf->vb);
78ca5005
DH		 605
606 /* As long as isoc traffic is arriving, keep
607 resetting the timer */
608 if (dev->vid_timeout_running)
609 mod_timer(&dev->vid_timeout,
610 jiffies + (HZ / 10));
611 if (dev->vbi_timeout_running)
612 mod_timer(&dev->vbi_timeout,
613 jiffies + (HZ / 10));
8b2f0795
DH		 614 }
615
616 if (buf != NULL) {
62899a28 617 if (fbyte & 0x40)
8b2f0795 618 buf->top_field = 1;
62899a28 619 else
8b2f0795 620 buf->top_field = 0;
8b2f0795
DH		 621 }
622
7f8eacd2
DH		 623 if (vbi_buf != NULL) {
624 if (fbyte & 0x40)
625 vbi_buf->top_field = 1;
626 else
627 vbi_buf->top_field = 0;
628 }
629
630 dev->vbi_read = 0;
631 vbi_dma_q->pos = 0;
8b2f0795
DH		 632 dma_q->pos = 0;
633 }
7f8eacd2
DH		 634
635 vbi_field_size = dev->vbi_width * dev->vbi_height * 2;
636 if (dev->vbi_read < vbi_field_size) {
637 remain = vbi_field_size - dev->vbi_read;
638 if (len < remain)
639 lencopy = len;
640 else
641 lencopy = remain;
642
643 if (vbi_buf != NULL)
644 au0828_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
645 vbioutp, len);
646
647 len -= lencopy;
648 p += lencopy;
649 dev->vbi_read += lencopy;
650 }
651
652 if (dev->vbi_read >= vbi_field_size && buf != NULL)
8b2f0795 653 au0828_copy_video(dev, dma_q, buf, p, outp, len);
8b2f0795
DH		 654 }
655 return rc;
656}
657
658static int
659buffer_setup(struct videobuf_queue *vq, unsigned int *count,
660 unsigned int *size)
661{
662 struct au0828_fh *fh = vq->priv_data;
663 *size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
664
665 if (0 == *count)
666 *count = AU0828_DEF_BUF;
667
668 if (*count < AU0828_MIN_BUF)
669 *count = AU0828_MIN_BUF;
670 return 0;
671}
672
673/* This is called *without* dev->slock held; please keep it that way */
674static void free_buffer(struct videobuf_queue *vq, struct au0828_buffer *buf)
675{
676 struct au0828_fh *fh = vq->priv_data;
677 struct au0828_dev *dev = fh->dev;
678 unsigned long flags = 0;
679 if (in_interrupt())
680 BUG();
681
682 /* We used to wait for the buffer to finish here, but this didn't work
683 because, as we were keeping the state as VIDEOBUF_QUEUED,
684 videobuf_queue_cancel marked it as finished for us.
685 (Also, it could wedge forever if the hardware was misconfigured.)
686
687 This should be safe; by the time we get here, the buffer isn't
688 queued anymore. If we ever start marking the buffers as
689 VIDEOBUF_ACTIVE, it won't be, though.
690 */
691 spin_lock_irqsave(&dev->slock, flags);
692 if (dev->isoc_ctl.buf == buf)
693 dev->isoc_ctl.buf = NULL;
694 spin_unlock_irqrestore(&dev->slock, flags);
695
696 videobuf_vmalloc_free(&buf->vb);
697 buf->vb.state = VIDEOBUF_NEEDS_INIT;
698}
699
700static int
701buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
702 enum v4l2_field field)
703{
704 struct au0828_fh *fh = vq->priv_data;
705 struct au0828_buffer *buf = container_of(vb, struct au0828_buffer, vb);
706 struct au0828_dev *dev = fh->dev;
707 int rc = 0, urb_init = 0;
708
709 buf->vb.size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
710
711 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
712 return -EINVAL;
713
714 buf->vb.width = dev->width;
715 buf->vb.height = dev->height;
716 buf->vb.field = field;
717
718 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
719 rc = videobuf_iolock(vq, &buf->vb, NULL);
720 if (rc < 0) {
62899a28 721 printk(KERN_INFO "videobuf_iolock failed\n");
8b2f0795
DH		 722 goto fail;
723 }
724 }
725
726 if (!dev->isoc_ctl.num_bufs)
727 urb_init = 1;
728
729 if (urb_init) {
730 rc = au0828_init_isoc(dev, AU0828_ISO_PACKETS_PER_URB,
731 AU0828_MAX_ISO_BUFS, dev->max_pkt_size,
732 au0828_isoc_copy);
733 if (rc < 0) {
62899a28 734 printk(KERN_INFO "au0828_init_isoc failed\n");
8b2f0795
DH		 735 goto fail;
736 }
737 }
738
739 buf->vb.state = VIDEOBUF_PREPARED;
740 return 0;
741
742fail:
743 free_buffer(vq, buf);
744 return rc;
745}
746
747static void
748buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
749{
750 struct au0828_buffer *buf = container_of(vb,
751 struct au0828_buffer,
752 vb);
753 struct au0828_fh *fh = vq->priv_data;
754 struct au0828_dev *dev = fh->dev;
755 struct au0828_dmaqueue *vidq = &dev->vidq;
756
757 buf->vb.state = VIDEOBUF_QUEUED;
758 list_add_tail(&buf->vb.queue, &vidq->active);
759}
760
761static void buffer_release(struct videobuf_queue *vq,
762 struct videobuf_buffer *vb)
763{
764 struct au0828_buffer *buf = container_of(vb,
765 struct au0828_buffer,
766 vb);
767
768 free_buffer(vq, buf);
769}
770
771static struct videobuf_queue_ops au0828_video_qops = {
772 .buf_setup = buffer_setup,
773 .buf_prepare = buffer_prepare,
774 .buf_queue = buffer_queue,
775 .buf_release = buffer_release,
776};
777
778/* ------------------------------------------------------------------
779 V4L2 interface
780 ------------------------------------------------------------------*/
781
782static int au0828_i2s_init(struct au0828_dev *dev)
783{
784 /* Enable i2s mode */
785 au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
786 return 0;
787}
788
789/*
790 * Auvitek au0828 analog stream enable
8b2f0795 791 */
a094ca46 792static int au0828_analog_stream_enable(struct au0828_dev *d)
8b2f0795 793{
f3e8f271
MCC		 794 struct usb_interface *iface;
795 int ret;
796
8b2f0795 797 dprintk(1, "au0828_analog_stream_enable called\n");
f3e8f271
MCC		 798
799 iface = usb_ifnum_to_if(d->usbdev, 0);
800 if (iface && iface->cur_altsetting->desc.bAlternateSetting != 5) {
801 dprintk(1, "Changing intf#0 to alt 5\n");
802 /* set au0828 interface0 to AS5 here again */
803 ret = usb_set_interface(d->usbdev, 0, 5);
804 if (ret < 0) {
805 printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
806 return -EBUSY;
807 }
808 }
809
810 /* FIXME: size should be calculated using d->width, d->height */
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);
817 au0828_writereg(d, 0x114, 0xa0);
818 au0828_writereg(d, 0x115, 0x05);
819 /* set y position */
7f8eacd2 820 au0828_writereg(d, 0x112, 0x00);
8b2f0795
DH		 821 au0828_writereg(d, 0x113, 0x00);
822 au0828_writereg(d, 0x116, 0xf2);
823 au0828_writereg(d, 0x117, 0x00);
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 */
1120 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->std);
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
8b2f0795
DH		 1368 /* FIXME: when we support something other than NTSC, we are going to
1369 have to make the au0828 bridge adjust the size of its capture
1370 buffer, which is currently hardcoded at 720x480 */
1371
314527ac 1372 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, norm);
e58071f0 1373
fa09cb9a 1374 i2c_gate_ctrl(dev, 0);
e58071f0 1375
8b2f0795
DH		 1376 return 0;
1377}
1378
33b6b89b
HV		 1379static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1380{
1381 struct au0828_fh *fh = priv;
1382 struct au0828_dev *dev = fh->dev;
1383
1384 *norm = dev->std;
1385 return 0;
1386}
1387
8b2f0795
DH		 1388static int vidioc_enum_input(struct file *file, void *priv,
1389 struct v4l2_input *input)
1390{
1391 struct au0828_fh *fh = priv;
1392 struct au0828_dev *dev = fh->dev;
1393 unsigned int tmp;
1394
1395 static const char *inames[] = {
3d62287e 1396 [AU0828_VMUX_UNDEFINED] = "Undefined",
8b2f0795
DH		 1397 [AU0828_VMUX_COMPOSITE] = "Composite",
1398 [AU0828_VMUX_SVIDEO] = "S-Video",
1399 [AU0828_VMUX_CABLE] = "Cable TV",
1400 [AU0828_VMUX_TELEVISION] = "Television",
1401 [AU0828_VMUX_DVB] = "DVB",
1402 [AU0828_VMUX_DEBUG] = "tv debug"
1403 };
1404
1405 tmp = input->index;
1406
f5e20c34 1407 if (tmp >= AU0828_MAX_INPUT)
8b2f0795 1408 return -EINVAL;
62899a28 1409 if (AUVI_INPUT(tmp).type == 0)
8b2f0795
DH		 1410 return -EINVAL;
1411
8b2f0795 1412 input->index = tmp;
f1add5b5 1413 strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
62899a28 1414 if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
a2cf96f9 1415 (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE)) {
8b2f0795 1416 input->type |= V4L2_INPUT_TYPE_TUNER;
a2cf96f9
HV		 1417 input->audioset = 1;
1418 } else {
8b2f0795 1419 input->type |= V4L2_INPUT_TYPE_CAMERA;
a2cf96f9
HV		 1420 input->audioset = 2;
1421 }
8b2f0795
DH		 1422
1423 input->std = dev->vdev->tvnorms;
1424
1425 return 0;
1426}
1427
1428static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1429{
1430 struct au0828_fh *fh = priv;
1431 struct au0828_dev *dev = fh->dev;
1432 *i = dev->ctrl_input;
1433 return 0;
1434}
1435
56230d1e 1436static void au0828_s_input(struct au0828_dev *dev, int index)
8b2f0795 1437{
8b2f0795 1438 int i;
8b2f0795 1439
62899a28 1440 switch (AUVI_INPUT(index).type) {
8b2f0795 1441 case AU0828_VMUX_SVIDEO:
8b2f0795 1442 dev->input_type = AU0828_VMUX_SVIDEO;
a2cf96f9 1443 dev->ctrl_ainput = 1;
8b2f0795 1444 break;
8b2f0795 1445 case AU0828_VMUX_COMPOSITE:
8b2f0795 1446 dev->input_type = AU0828_VMUX_COMPOSITE;
a2cf96f9 1447 dev->ctrl_ainput = 1;
8b2f0795 1448 break;
8b2f0795 1449 case AU0828_VMUX_TELEVISION:
8b2f0795 1450 dev->input_type = AU0828_VMUX_TELEVISION;
a2cf96f9 1451 dev->ctrl_ainput = 0;
8b2f0795 1452 break;
8b2f0795 1453 default:
56230d1e 1454 dprintk(1, "unknown input type set [%d]\n",
a1094c4c
DH		 1455 AUVI_INPUT(index).type);
1456 break;
8b2f0795
DH		 1457 }
1458
5325b427
HV		 1459 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1460 AUVI_INPUT(index).vmux, 0, 0);
8b2f0795
DH		 1461
1462 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1463 int enable = 0;
62899a28 1464 if (AUVI_INPUT(i).audio_setup == NULL)
8b2f0795 1465 continue;
8b2f0795
DH		 1466
1467 if (i == index)
1468 enable = 1;
1469 else
1470 enable = 0;
1471 if (enable) {
f1add5b5 1472 (AUVI_INPUT(i).audio_setup)(dev, enable);
8b2f0795
DH		 1473 } else {
1474 /* Make sure we leave it turned on if some
1475 other input is routed to this callback */
f1add5b5
DH		 1476 if ((AUVI_INPUT(i).audio_setup) !=
1477 ((AUVI_INPUT(index).audio_setup))) {
1478 (AUVI_INPUT(i).audio_setup)(dev, enable);
8b2f0795
DH		 1479 }
1480 }
1481 }
1482
5325b427
HV		 1483 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1484 AUVI_INPUT(index).amux, 0, 0);
56230d1e
HV		 1485}
1486
1487static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1488{
1489 struct au0828_fh *fh = priv;
1490 struct au0828_dev *dev = fh->dev;
1491
1492 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
1493 index);
1494 if (index >= AU0828_MAX_INPUT)
1495 return -EINVAL;
1496 if (AUVI_INPUT(index).type == 0)
1497 return -EINVAL;
1498 dev->ctrl_input = index;
1499 au0828_s_input(dev, index);
8b2f0795
DH		 1500 return 0;
1501}
1502
a2cf96f9
HV		 1503static int vidioc_enumaudio(struct file *file, void *priv, struct v4l2_audio *a)
1504{
1505 if (a->index > 1)
1506 return -EINVAL;
1507
1508 if (a->index == 0)
1509 strcpy(a->name, "Television");
1510 else
1511 strcpy(a->name, "Line in");
1512
1513 a->capability = V4L2_AUDCAP_STEREO;
1514 return 0;
1515}
1516
8b2f0795
DH		 1517static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1518{
1519 struct au0828_fh *fh = priv;
1520 struct au0828_dev *dev = fh->dev;
8b2f0795 1521
a2cf96f9
HV		 1522 a->index = dev->ctrl_ainput;
1523 if (a->index == 0)
8b2f0795
DH		 1524 strcpy(a->name, "Television");
1525 else
1526 strcpy(a->name, "Line in");
1527
1528 a->capability = V4L2_AUDCAP_STEREO;
8b2f0795
DH		 1529 return 0;
1530}
1531
0e8025b9 1532static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
8b2f0795
DH		 1533{
1534 struct au0828_fh *fh = priv;
1535 struct au0828_dev *dev = fh->dev;
a2cf96f9 1536
62899a28 1537 if (a->index != dev->ctrl_ainput)
8b2f0795
DH		 1538 return -EINVAL;
1539 return 0;
1540}
1541
8b2f0795
DH		 1542static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1543{
1544 struct au0828_fh *fh = priv;
1545 struct au0828_dev *dev = fh->dev;
1546
62899a28 1547 if (t->index != 0)
8b2f0795
DH		 1548 return -EINVAL;
1549
8b2f0795 1550 strcpy(t->name, "Auvitek tuner");
ea86968f
HV		 1551
1552 au0828_init_tuner(dev);
1553 i2c_gate_ctrl(dev, 1);
2689d3dc 1554 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
ea86968f 1555 i2c_gate_ctrl(dev, 0);
8b2f0795
DH		 1556 return 0;
1557}
1558
1559static int vidioc_s_tuner(struct file *file, void *priv,
2f73c7c5 1560 const struct v4l2_tuner *t)
8b2f0795
DH		 1561{
1562 struct au0828_fh *fh = priv;
1563 struct au0828_dev *dev = fh->dev;
1564
62899a28 1565 if (t->index != 0)
8b2f0795
DH		 1566 return -EINVAL;
1567
ea86968f 1568 au0828_init_tuner(dev);
fa09cb9a 1569 i2c_gate_ctrl(dev, 1);
2689d3dc 1570 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
fa09cb9a 1571 i2c_gate_ctrl(dev, 0);
e58071f0 1572
8b2f0795
DH		 1573 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1574 t->afc);
e58071f0 1575
8b2f0795
DH		 1576 return 0;
1577
1578}
1579
1580static int vidioc_g_frequency(struct file *file, void *priv,
1581 struct v4l2_frequency *freq)
1582{
1583 struct au0828_fh *fh = priv;
1584 struct au0828_dev *dev = fh->dev;
c888923d 1585
e1cf6587
HV		 1586 if (freq->tuner != 0)
1587 return -EINVAL;
8b2f0795
DH		 1588 freq->frequency = dev->ctrl_freq;
1589 return 0;
1590}
1591
1592static int vidioc_s_frequency(struct file *file, void *priv,
b530a447 1593 const struct v4l2_frequency *freq)
8b2f0795
DH		 1594{
1595 struct au0828_fh *fh = priv;
1596 struct au0828_dev *dev = fh->dev;
e1cf6587 1597 struct v4l2_frequency new_freq = *freq;
8b2f0795 1598
62899a28 1599 if (freq->tuner != 0)
8b2f0795 1600 return -EINVAL;
8b2f0795 1601
ea86968f 1602 au0828_init_tuner(dev);
fa09cb9a 1603 i2c_gate_ctrl(dev, 1);
4a03dafc 1604
2689d3dc 1605 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
e1cf6587
HV		 1606 /* Get the actual set (and possibly clamped) frequency */
1607 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1608 dev->ctrl_freq = new_freq.frequency;
8b2f0795 1609
fa09cb9a 1610 i2c_gate_ctrl(dev, 0);
4a03dafc 1611
8b2f0795
DH		 1612 au0828_analog_stream_reset(dev);
1613
1614 return 0;
1615}
1616
7f8eacd2
DH		 1617
1618/* RAW VBI ioctls */
1619
1620static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1621 struct v4l2_format *format)
1622{
1623 struct au0828_fh *fh = priv;
1624 struct au0828_dev *dev = fh->dev;
1625
1626 format->fmt.vbi.samples_per_line = dev->vbi_width;
1627 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1628 format->fmt.vbi.offset = 0;
1629 format->fmt.vbi.flags = 0;
1630 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1631
1632 format->fmt.vbi.count[0] = dev->vbi_height;
1633 format->fmt.vbi.count[1] = dev->vbi_height;
1634 format->fmt.vbi.start[0] = 21;
1635 format->fmt.vbi.start[1] = 284;
8d86e4e8 1636 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
7f8eacd2
DH		 1637
1638 return 0;
1639}
1640
8b2f0795
DH		 1641static int vidioc_g_chip_ident(struct file *file, void *priv,
1642 struct v4l2_dbg_chip_ident *chip)
1643{
1644 struct au0828_fh *fh = priv;
1645 struct au0828_dev *dev = fh->dev;
1646 chip->ident = V4L2_IDENT_NONE;
1647 chip->revision = 0;
1648
d9109bef
DH		 1649 if (v4l2_chip_match_host(&chip->match)) {
1650 chip->ident = V4L2_IDENT_AU0828;
1651 return 0;
1652 }
1653
2689d3dc 1654 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
d9109bef
DH		 1655 if (chip->ident == V4L2_IDENT_NONE)
1656 return -EINVAL;
1657
8b2f0795
DH		 1658 return 0;
1659}
1660
1661static int vidioc_cropcap(struct file *file, void *priv,
1662 struct v4l2_cropcap *cc)
1663{
1664 struct au0828_fh *fh = priv;
1665 struct au0828_dev *dev = fh->dev;
1666
62899a28 1667 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
8b2f0795
DH		 1668 return -EINVAL;
1669
1670 cc->bounds.left = 0;
1671 cc->bounds.top = 0;
1672 cc->bounds.width = dev->width;
1673 cc->bounds.height = dev->height;
1674
1675 cc->defrect = cc->bounds;
1676
1677 cc->pixelaspect.numerator = 54;
1678 cc->pixelaspect.denominator = 59;
1679
1680 return 0;
1681}
1682
1683static int vidioc_streamon(struct file *file, void *priv,
1684 enum v4l2_buf_type type)
1685{
7f8eacd2
DH		 1686 struct au0828_fh *fh = priv;
1687 struct au0828_dev *dev = fh->dev;
1688 int rc = -EINVAL;
8b2f0795
DH		 1689
1690 rc = check_dev(dev);
1691 if (rc < 0)
1692 return rc;
1693
7f8eacd2
DH		 1694 if (unlikely(type != fh->type))
1695 return -EINVAL;
1696
1697 dprintk(1, "vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
1698 fh, type, fh->resources, dev->resources);
1699
1700 if (unlikely(!res_get(fh, get_ressource(fh))))
1701 return -EBUSY;
1702
ea86968f 1703 au0828_init_tuner(dev);
8b2f0795
DH		 1704 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1705 au0828_analog_stream_enable(dev);
2689d3dc 1706 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
8b2f0795
DH		 1707 }
1708
78ca5005 1709 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
8b2f0795 1710 rc = videobuf_streamon(&fh->vb_vidq);
78ca5005
DH		 1711 dev->vid_timeout_running = 1;
1712 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1713 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
7f8eacd2 1714 rc = videobuf_streamon(&fh->vb_vbiq);
78ca5005
DH		 1715 dev->vbi_timeout_running = 1;
1716 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1717 }
8b2f0795
DH		 1718
1719 return rc;
1720}
1721
1722static int vidioc_streamoff(struct file *file, void *priv,
1723 enum v4l2_buf_type type)
1724{
7f8eacd2
DH		 1725 struct au0828_fh *fh = priv;
1726 struct au0828_dev *dev = fh->dev;
1727 int rc;
1728 int i;
8b2f0795
DH		 1729
1730 rc = check_dev(dev);
1731 if (rc < 0)
1732 return rc;
1733
7f8eacd2
DH		 1734 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1735 fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
8b2f0795
DH		 1736 return -EINVAL;
1737 if (type != fh->type)
1738 return -EINVAL;
1739
7f8eacd2
DH		 1740 dprintk(1, "vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
1741 fh, type, fh->resources, dev->resources);
1742
1743 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
78ca5005
DH		 1744 dev->vid_timeout_running = 0;
1745 del_timer_sync(&dev->vid_timeout);
1746
2689d3dc 1747 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
7f8eacd2
DH		 1748 rc = au0828_stream_interrupt(dev);
1749 if (rc != 0)
1750 return rc;
8b2f0795 1751
7f8eacd2
DH		 1752 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1753 if (AUVI_INPUT(i).audio_setup == NULL)
1754 continue;
1755 (AUVI_INPUT(i).audio_setup)(dev, 0);
1756 }
8b2f0795 1757
a595c1ce
DH		 1758 if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
1759 videobuf_streamoff(&fh->vb_vidq);
1760 res_free(fh, AU0828_RESOURCE_VIDEO);
1761 }
7f8eacd2 1762 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
78ca5005
DH		 1763 dev->vbi_timeout_running = 0;
1764 del_timer_sync(&dev->vbi_timeout);
1765
a595c1ce
DH		 1766 if (res_check(fh, AU0828_RESOURCE_VBI)) {
1767 videobuf_streamoff(&fh->vb_vbiq);
1768 res_free(fh, AU0828_RESOURCE_VBI);
1769 }
7f8eacd2 1770 }
8b2f0795
DH		 1771
1772 return 0;
1773}
1774
80c6e358 1775#ifdef CONFIG_VIDEO_ADV_DEBUG
8b2f0795
DH		 1776static int vidioc_g_register(struct file *file, void *priv,
1777 struct v4l2_dbg_register *reg)
1778{
1779 struct au0828_fh *fh = priv;
1780 struct au0828_dev *dev = fh->dev;
1781
1782 switch (reg->match.type) {
1783 case V4L2_CHIP_MATCH_I2C_DRIVER:
2689d3dc 1784 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
8b2f0795
DH		 1785 return 0;
1786 default:
364d2db2
DH		 1787 if (!v4l2_chip_match_host(&reg->match))
1788 return -EINVAL;
8b2f0795 1789 }
364d2db2
DH		 1790
1791 reg->val = au0828_read(dev, reg->reg);
1792 return 0;
8b2f0795
DH		 1793}
1794
1795static int vidioc_s_register(struct file *file, void *priv,
977ba3b1 1796 const struct v4l2_dbg_register *reg)
8b2f0795
DH		 1797{
1798 struct au0828_fh *fh = priv;
1799 struct au0828_dev *dev = fh->dev;
1800
1801 switch (reg->match.type) {
1802 case V4L2_CHIP_MATCH_I2C_DRIVER:
2689d3dc 1803 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
8b2f0795
DH		 1804 return 0;
1805 default:
364d2db2
DH		 1806 if (!v4l2_chip_match_host(&reg->match))
1807 return -EINVAL;
8b2f0795 1808 }
364d2db2 1809 return au0828_writereg(dev, reg->reg, reg->val);
8b2f0795 1810}
80c6e358 1811#endif
8b2f0795 1812
83b09422
HV		 1813static int vidioc_log_status(struct file *file, void *fh)
1814{
1815 struct video_device *vdev = video_devdata(file);
1816
1817 v4l2_ctrl_log_status(file, fh);
1818 v4l2_device_call_all(vdev->v4l2_dev, 0, core, log_status);
1819 return 0;
1820}
1821
8b2f0795
DH		 1822static int vidioc_reqbufs(struct file *file, void *priv,
1823 struct v4l2_requestbuffers *rb)
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_reqbufs(&fh->vb_vidq, rb);
1835 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1836 rc = videobuf_reqbufs(&fh->vb_vbiq, rb);
1837
1838 return rc;
8b2f0795
DH		 1839}
1840
1841static int vidioc_querybuf(struct file *file, void *priv,
1842 struct v4l2_buffer *b)
1843{
1844 struct au0828_fh *fh = priv;
1845 struct au0828_dev *dev = fh->dev;
1846 int rc;
1847
1848 rc = check_dev(dev);
1849 if (rc < 0)
1850 return rc;
1851
54ebb8b8
DH		 1852 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1853 rc = videobuf_querybuf(&fh->vb_vidq, b);
1854 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1855 rc = videobuf_querybuf(&fh->vb_vbiq, b);
1856
1857 return rc;
8b2f0795
DH		 1858}
1859
1860static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1861{
1862 struct au0828_fh *fh = priv;
1863 struct au0828_dev *dev = fh->dev;
1864 int rc;
1865
1866 rc = check_dev(dev);
1867 if (rc < 0)
1868 return rc;
1869
54ebb8b8
DH		 1870 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1871 rc = videobuf_qbuf(&fh->vb_vidq, b);
1872 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1873 rc = videobuf_qbuf(&fh->vb_vbiq, b);
1874
1875 return rc;
8b2f0795
DH		 1876}
1877
1878static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1879{
1880 struct au0828_fh *fh = priv;
1881 struct au0828_dev *dev = fh->dev;
1882 int rc;
1883
1884 rc = check_dev(dev);
1885 if (rc < 0)
1886 return rc;
1887
1888 /* Workaround for a bug in the au0828 hardware design that sometimes
1889 results in the colorspace being inverted */
1890 if (dev->greenscreen_detected == 1) {
1891 dprintk(1, "Detected green frame. Resetting stream...\n");
1892 au0828_analog_stream_reset(dev);
1893 dev->greenscreen_detected = 0;
1894 }
1895
54ebb8b8
DH		 1896 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1897 rc = videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1898 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1899 rc = videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags & O_NONBLOCK);
1900
1901 return rc;
8b2f0795
DH		 1902}
1903
8b2f0795
DH		 1904static struct v4l2_file_operations au0828_v4l_fops = {
1905 .owner = THIS_MODULE,
1906 .open = au0828_v4l2_open,
1907 .release = au0828_v4l2_close,
1908 .read = au0828_v4l2_read,
1909 .poll = au0828_v4l2_poll,
1910 .mmap = au0828_v4l2_mmap,
549ee4df 1911 .unlocked_ioctl = video_ioctl2,
8b2f0795
DH		 1912};
1913
1914static const struct v4l2_ioctl_ops video_ioctl_ops = {
1915 .vidioc_querycap = vidioc_querycap,
1916 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1917 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1918 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1919 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
5a5a4e16 1920 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
8d86e4e8 1921 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
7f8eacd2 1922 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
a2cf96f9 1923 .vidioc_enumaudio = vidioc_enumaudio,
8b2f0795
DH		 1924 .vidioc_g_audio = vidioc_g_audio,
1925 .vidioc_s_audio = vidioc_s_audio,
1926 .vidioc_cropcap = vidioc_cropcap,
8b2f0795
DH		 1927 .vidioc_reqbufs = vidioc_reqbufs,
1928 .vidioc_querybuf = vidioc_querybuf,
1929 .vidioc_qbuf = vidioc_qbuf,
1930 .vidioc_dqbuf = vidioc_dqbuf,
1931 .vidioc_s_std = vidioc_s_std,
33b6b89b 1932 .vidioc_g_std = vidioc_g_std,
8b2f0795
DH		 1933 .vidioc_enum_input = vidioc_enum_input,
1934 .vidioc_g_input = vidioc_g_input,
1935 .vidioc_s_input = vidioc_s_input,
8b2f0795
DH		 1936 .vidioc_streamon = vidioc_streamon,
1937 .vidioc_streamoff = vidioc_streamoff,
1938 .vidioc_g_tuner = vidioc_g_tuner,
1939 .vidioc_s_tuner = vidioc_s_tuner,
1940 .vidioc_g_frequency = vidioc_g_frequency,
1941 .vidioc_s_frequency = vidioc_s_frequency,
1942#ifdef CONFIG_VIDEO_ADV_DEBUG
1943 .vidioc_g_register = vidioc_g_register,
1944 .vidioc_s_register = vidioc_s_register,
8b2f0795 1945#endif
80c6e358 1946 .vidioc_g_chip_ident = vidioc_g_chip_ident,
83b09422
HV		 1947 .vidioc_log_status = vidioc_log_status,
1948 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1949 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
8b2f0795
DH		 1950};
1951
1952static const struct video_device au0828_video_template = {
1953 .fops = &au0828_v4l_fops,
1954 .release = video_device_release,
1955 .ioctl_ops = &video_ioctl_ops,
0ef21071 1956 .tvnorms = V4L2_STD_NTSC_M,
8b2f0795
DH		 1957};
1958
1959/**************************************************************************/
1960
fc4ce6cd
DH		 1961int au0828_analog_register(struct au0828_dev *dev,
1962 struct usb_interface *interface)
8b2f0795
DH		 1963{
1964 int retval = -ENOMEM;
fc4ce6cd
DH		 1965 struct usb_host_interface *iface_desc;
1966 struct usb_endpoint_descriptor *endpoint;
d63b21bf 1967 int i, ret;
8b2f0795
DH		 1968
1969 dprintk(1, "au0828_analog_register called!\n");
1970
fc4ce6cd
DH		 1971 /* set au0828 usb interface0 to as5 */
1972 retval = usb_set_interface(dev->usbdev,
62899a28 1973 interface->cur_altsetting->desc.bInterfaceNumber, 5);
fc4ce6cd 1974 if (retval != 0) {
62899a28 1975 printk(KERN_INFO "Failure setting usb interface0 to as5\n");
fc4ce6cd
DH		 1976 return retval;
1977 }
1978
1979 /* Figure out which endpoint has the isoc interface */
1980 iface_desc = interface->cur_altsetting;
62899a28 1981 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
fc4ce6cd 1982 endpoint = &iface_desc->endpoint[i].desc;
62899a28
DH		 1983 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1984 == USB_DIR_IN) &&
1985 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1986 == USB_ENDPOINT_XFER_ISOC)) {
fc4ce6cd
DH		 1987
1988 /* we find our isoc in endpoint */
1989 u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
62899a28
DH		 1990 dev->max_pkt_size = (tmp & 0x07ff) *
1991 (((tmp & 0x1800) >> 11) + 1);
fc4ce6cd
DH		 1992 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1993 }
1994 }
62899a28
DH		 1995 if (!(dev->isoc_in_endpointaddr)) {
1996 printk(KERN_INFO "Could not locate isoc endpoint\n");
fc4ce6cd
DH		 1997 kfree(dev);
1998 return -ENODEV;
1999 }
2000
8b2f0795
DH		 2001 init_waitqueue_head(&dev->open);
2002 spin_lock_init(&dev->slock);
8b2f0795 2003
7f8eacd2 2004 /* init video dma queues */
8b2f0795
DH		 2005 INIT_LIST_HEAD(&dev->vidq.active);
2006 INIT_LIST_HEAD(&dev->vidq.queued);
7f8eacd2
DH		 2007 INIT_LIST_HEAD(&dev->vbiq.active);
2008 INIT_LIST_HEAD(&dev->vbiq.queued);
8b2f0795 2009
78ca5005
DH		 2010 dev->vid_timeout.function = au0828_vid_buffer_timeout;
2011 dev->vid_timeout.data = (unsigned long) dev;
2012 init_timer(&dev->vid_timeout);
2013
2014 dev->vbi_timeout.function = au0828_vbi_buffer_timeout;
2015 dev->vbi_timeout.data = (unsigned long) dev;
2016 init_timer(&dev->vbi_timeout);
2017
8b2f0795
DH		 2018 dev->width = NTSC_STD_W;
2019 dev->height = NTSC_STD_H;
2020 dev->field_size = dev->width * dev->height;
2021 dev->frame_size = dev->field_size << 1;
2022 dev->bytesperline = dev->width << 1;
de8d2bbf
HV		 2023 dev->vbi_width = 720;
2024 dev->vbi_height = 1;
8b2f0795 2025 dev->ctrl_ainput = 0;
e1cf6587 2026 dev->ctrl_freq = 960;
33b6b89b 2027 dev->std = V4L2_STD_NTSC_M;
56230d1e 2028 au0828_s_input(dev, 0);
8b2f0795
DH		 2029
2030 /* allocate and fill v4l2 video struct */
2031 dev->vdev = video_device_alloc();
62899a28 2032 if (NULL == dev->vdev) {
8b2f0795
DH		 2033 dprintk(1, "Can't allocate video_device.\n");
2034 return -ENOMEM;
2035 }
2036
7f8eacd2 2037 /* allocate the VBI struct */
8b2f0795 2038 dev->vbi_dev = video_device_alloc();
62899a28 2039 if (NULL == dev->vbi_dev) {
8b2f0795 2040 dprintk(1, "Can't allocate vbi_device.\n");
d63b21bf
JL		 2041 ret = -ENOMEM;
2042 goto err_vdev;
8b2f0795
DH		 2043 }
2044
2045 /* Fill the video capture device struct */
2046 *dev->vdev = au0828_video_template;
e8c26f45 2047 dev->vdev->v4l2_dev = &dev->v4l2_dev;
549ee4df 2048 dev->vdev->lock = &dev->lock;
83b09422 2049 set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev->flags);
8b2f0795
DH		 2050 strcpy(dev->vdev->name, "au0828a video");
2051
2052 /* Setup the VBI device */
2053 *dev->vbi_dev = au0828_video_template;
e8c26f45 2054 dev->vbi_dev->v4l2_dev = &dev->v4l2_dev;
549ee4df 2055 dev->vbi_dev->lock = &dev->lock;
83b09422 2056 set_bit(V4L2_FL_USE_FH_PRIO, &dev->vbi_dev->flags);
8b2f0795
DH		 2057 strcpy(dev->vbi_dev->name, "au0828a vbi");
2058
8b2f0795 2059 /* Register the v4l2 device */
63b0d5ad 2060 video_set_drvdata(dev->vdev, dev);
62899a28
DH		 2061 retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
2062 if (retval != 0) {
2063 dprintk(1, "unable to register video device (error = %d).\n",
2064 retval);
d63b21bf
JL		 2065 ret = -ENODEV;
2066 goto err_vbi_dev;
8b2f0795
DH		 2067 }
2068
2069 /* Register the vbi device */
63b0d5ad 2070 video_set_drvdata(dev->vbi_dev, dev);
62899a28
DH		 2071 retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
2072 if (retval != 0) {
2073 dprintk(1, "unable to register vbi device (error = %d).\n",
2074 retval);
d63b21bf
JL		 2075 ret = -ENODEV;
2076 goto err_vbi_dev;
8b2f0795
DH		 2077 }
2078
62899a28 2079 dprintk(1, "%s completed!\n", __func__);
8b2f0795
DH		 2080
2081 return 0;
d63b21bf
JL		 2082
2083err_vbi_dev:
2084 video_device_release(dev->vbi_dev);
2085err_vdev:
2086 video_device_release(dev->vdev);
2087 return ret;
8b2f0795
DH		 2088}
2089
kernel source for telekom puls (alcatel/mediatek)