blob: 27bedc6c779114da92758f7efb494fa3ca6582f0 [file] [log] [blame]
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001/*
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>
32#include <linux/init.h>
33#include <linux/device.h>
34#include <linux/suspend.h>
35#include <linux/version.h>
Devin Heitmueller8b2f0792009-03-11 03:00:40 -030036#include <media/v4l2-common.h>
37#include <media/v4l2-ioctl.h>
38#include <media/v4l2-chip-ident.h>
39#include <media/tuner.h>
40#include "au0828.h"
41#include "au0828-reg.h"
42
43static LIST_HEAD(au0828_devlist);
44static DEFINE_MUTEX(au0828_sysfs_lock);
45
46#define AU0828_VERSION_CODE KERNEL_VERSION(0, 0, 1)
47
Devin Heitmueller8b2f0792009-03-11 03:00:40 -030048/* ------------------------------------------------------------------
49 Videobuf operations
50 ------------------------------------------------------------------*/
51
52static unsigned int isoc_debug;
53module_param(isoc_debug, int, 0644);
54MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
55
56#define au0828_isocdbg(fmt, arg...) \
57do {\
58 if (isoc_debug) { \
59 printk(KERN_INFO "au0828 %s :"fmt, \
60 __func__ , ##arg); \
61 } \
62 } while (0)
63
64static inline void print_err_status(struct au0828_dev *dev,
65 int packet, int status)
66{
67 char *errmsg = "Unknown";
68
69 switch (status) {
70 case -ENOENT:
71 errmsg = "unlinked synchronuously";
72 break;
73 case -ECONNRESET:
74 errmsg = "unlinked asynchronuously";
75 break;
76 case -ENOSR:
77 errmsg = "Buffer error (overrun)";
78 break;
79 case -EPIPE:
80 errmsg = "Stalled (device not responding)";
81 break;
82 case -EOVERFLOW:
83 errmsg = "Babble (bad cable?)";
84 break;
85 case -EPROTO:
86 errmsg = "Bit-stuff error (bad cable?)";
87 break;
88 case -EILSEQ:
89 errmsg = "CRC/Timeout (could be anything)";
90 break;
91 case -ETIME:
92 errmsg = "Device does not respond";
93 break;
94 }
95 if (packet < 0) {
96 au0828_isocdbg("URB status %d [%s].\n", status, errmsg);
97 } else {
98 au0828_isocdbg("URB packet %d, status %d [%s].\n",
99 packet, status, errmsg);
100 }
101}
102
103static int check_dev(struct au0828_dev *dev)
104{
105 if (dev->dev_state & DEV_DISCONNECTED) {
Devin Heitmueller62899a22009-03-15 18:48:52 -0300106 printk(KERN_INFO "v4l2 ioctl: device not present\n");
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300107 return -ENODEV;
108 }
109
110 if (dev->dev_state & DEV_MISCONFIGURED) {
Devin Heitmueller62899a22009-03-15 18:48:52 -0300111 printk(KERN_INFO "v4l2 ioctl: device is misconfigured; "
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300112 "close and open it again\n");
113 return -EIO;
114 }
115 return 0;
116}
117
118/*
119 * IRQ callback, called by URB callback
120 */
121static void au0828_irq_callback(struct urb *urb)
122{
123 struct au0828_dmaqueue *dma_q = urb->context;
124 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
125 int rc, i;
126
127 switch (urb->status) {
128 case 0: /* success */
129 case -ETIMEDOUT: /* NAK */
130 break;
131 case -ECONNRESET: /* kill */
132 case -ENOENT:
133 case -ESHUTDOWN:
134 au0828_isocdbg("au0828_irq_callback called: status kill\n");
135 return;
136 default: /* unknown error */
137 au0828_isocdbg("urb completition error %d.\n", urb->status);
138 break;
139 }
140
141 /* Copy data from URB */
142 spin_lock(&dev->slock);
143 rc = dev->isoc_ctl.isoc_copy(dev, urb);
144 spin_unlock(&dev->slock);
145
146 /* Reset urb buffers */
147 for (i = 0; i < urb->number_of_packets; i++) {
148 urb->iso_frame_desc[i].status = 0;
149 urb->iso_frame_desc[i].actual_length = 0;
150 }
151 urb->status = 0;
152
153 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
154 if (urb->status) {
155 au0828_isocdbg("urb resubmit failed (error=%i)\n",
156 urb->status);
157 }
158}
159
160/*
161 * Stop and Deallocate URBs
162 */
163void au0828_uninit_isoc(struct au0828_dev *dev)
164{
165 struct urb *urb;
166 int i;
167
168 au0828_isocdbg("au0828: called au0828_uninit_isoc\n");
169
170 dev->isoc_ctl.nfields = -1;
171 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
172 urb = dev->isoc_ctl.urb[i];
173 if (urb) {
174 if (!irqs_disabled())
175 usb_kill_urb(urb);
176 else
177 usb_unlink_urb(urb);
178
179 if (dev->isoc_ctl.transfer_buffer[i]) {
180 usb_buffer_free(dev->usbdev,
181 urb->transfer_buffer_length,
182 dev->isoc_ctl.transfer_buffer[i],
183 urb->transfer_dma);
184 }
185 usb_free_urb(urb);
186 dev->isoc_ctl.urb[i] = NULL;
187 }
188 dev->isoc_ctl.transfer_buffer[i] = NULL;
189 }
190
191 kfree(dev->isoc_ctl.urb);
192 kfree(dev->isoc_ctl.transfer_buffer);
193
194 dev->isoc_ctl.urb = NULL;
195 dev->isoc_ctl.transfer_buffer = NULL;
196 dev->isoc_ctl.num_bufs = 0;
197}
198
199/*
200 * Allocate URBs and start IRQ
201 */
202int au0828_init_isoc(struct au0828_dev *dev, int max_packets,
203 int num_bufs, int max_pkt_size,
204 int (*isoc_copy) (struct au0828_dev *dev, struct urb *urb))
205{
206 struct au0828_dmaqueue *dma_q = &dev->vidq;
207 int i;
208 int sb_size, pipe;
209 struct urb *urb;
210 int j, k;
211 int rc;
212
213 au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
214
215 /* De-allocates all pending stuff */
216 au0828_uninit_isoc(dev);
217
218 dev->isoc_ctl.isoc_copy = isoc_copy;
219 dev->isoc_ctl.num_bufs = num_bufs;
220
221 dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
222 if (!dev->isoc_ctl.urb) {
223 au0828_isocdbg("cannot alloc memory for usb buffers\n");
224 return -ENOMEM;
225 }
226
227 dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
228 GFP_KERNEL);
229 if (!dev->isoc_ctl.transfer_buffer) {
230 au0828_isocdbg("cannot allocate memory for usb transfer\n");
231 kfree(dev->isoc_ctl.urb);
232 return -ENOMEM;
233 }
234
235 dev->isoc_ctl.max_pkt_size = max_pkt_size;
236 dev->isoc_ctl.buf = NULL;
237
238 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
239
240 /* allocate urbs and transfer buffers */
241 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
242 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
243 if (!urb) {
244 au0828_isocdbg("cannot alloc isoc_ctl.urb %i\n", i);
245 au0828_uninit_isoc(dev);
246 return -ENOMEM;
247 }
248 dev->isoc_ctl.urb[i] = urb;
249
250 dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(dev->usbdev,
251 sb_size, GFP_KERNEL, &urb->transfer_dma);
252 if (!dev->isoc_ctl.transfer_buffer[i]) {
253 printk("unable to allocate %i bytes for transfer"
254 " buffer %i%s\n",
255 sb_size, i,
256 in_interrupt() ? " while in int" : "");
257 au0828_uninit_isoc(dev);
258 return -ENOMEM;
259 }
260 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
261
262 pipe = usb_rcvisocpipe(dev->usbdev,
263 dev->isoc_in_endpointaddr),
264
265 usb_fill_int_urb(urb, dev->usbdev, pipe,
266 dev->isoc_ctl.transfer_buffer[i], sb_size,
267 au0828_irq_callback, dma_q, 1);
268
269 urb->number_of_packets = max_packets;
Devin Heitmuellerfadadb72009-03-22 23:42:26 -0300270 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300271
272 k = 0;
273 for (j = 0; j < max_packets; j++) {
274 urb->iso_frame_desc[j].offset = k;
275 urb->iso_frame_desc[j].length =
276 dev->isoc_ctl.max_pkt_size;
277 k += dev->isoc_ctl.max_pkt_size;
278 }
279 }
280
281 init_waitqueue_head(&dma_q->wq);
282
283 /* submit urbs and enables IRQ */
284 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
285 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
286 if (rc) {
287 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
288 i, rc);
289 au0828_uninit_isoc(dev);
290 return rc;
291 }
292 }
293
294 return 0;
295}
296
297/*
298 * Announces that a buffer were filled and request the next
299 */
300static inline void buffer_filled(struct au0828_dev *dev,
301 struct au0828_dmaqueue *dma_q,
302 struct au0828_buffer *buf)
303{
304 /* Advice that buffer was filled */
305 au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
306
307 buf->vb.state = VIDEOBUF_DONE;
308 buf->vb.field_count++;
309 do_gettimeofday(&buf->vb.ts);
310
311 dev->isoc_ctl.buf = NULL;
312
313 list_del(&buf->vb.queue);
314 wake_up(&buf->vb.done);
315}
316
317/*
318 * Identify the buffer header type and properly handles
319 */
320static void au0828_copy_video(struct au0828_dev *dev,
321 struct au0828_dmaqueue *dma_q,
322 struct au0828_buffer *buf,
323 unsigned char *p,
324 unsigned char *outp, unsigned long len)
325{
326 void *fieldstart, *startwrite, *startread;
327 int linesdone, currlinedone, offset, lencopy, remain;
328 int bytesperline = dev->width << 1; /* Assumes 16-bit depth @@@@ */
329
330 if (dma_q->pos + len > buf->vb.size)
331 len = buf->vb.size - dma_q->pos;
332
333 startread = p;
334 remain = len;
335
336 /* Interlaces frame */
337 if (buf->top_field)
338 fieldstart = outp;
339 else
340 fieldstart = outp + bytesperline;
341
342 linesdone = dma_q->pos / bytesperline;
343 currlinedone = dma_q->pos % bytesperline;
344 offset = linesdone * bytesperline * 2 + currlinedone;
345 startwrite = fieldstart + offset;
346 lencopy = bytesperline - currlinedone;
347 lencopy = lencopy > remain ? remain : lencopy;
348
349 if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
350 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
351 ((char *)startwrite + lencopy) -
352 ((char *)outp + buf->vb.size));
353 remain = (char *)outp + buf->vb.size - (char *)startwrite;
354 lencopy = remain;
355 }
356 if (lencopy <= 0)
357 return;
358 memcpy(startwrite, startread, lencopy);
359
360 remain -= lencopy;
361
362 while (remain > 0) {
363 startwrite += lencopy + bytesperline;
364 startread += lencopy;
365 if (bytesperline > remain)
366 lencopy = remain;
367 else
368 lencopy = bytesperline;
369
370 if ((char *)startwrite + lencopy > (char *)outp +
371 buf->vb.size) {
Devin Heitmueller62899a22009-03-15 18:48:52 -0300372 au0828_isocdbg("Overflow %zi bytes past buf end (2)\n",
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300373 ((char *)startwrite + lencopy) -
374 ((char *)outp + buf->vb.size));
375 lencopy = remain = (char *)outp + buf->vb.size -
376 (char *)startwrite;
377 }
378 if (lencopy <= 0)
379 break;
380
381 memcpy(startwrite, startread, lencopy);
382
383 remain -= lencopy;
384 }
385
386 if (offset > 1440) {
387 /* We have enough data to check for greenscreen */
Devin Heitmueller62899a22009-03-15 18:48:52 -0300388 if (outp[0] < 0x60 && outp[1440] < 0x60)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300389 dev->greenscreen_detected = 1;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300390 }
391
392 dma_q->pos += len;
393}
394
395/*
396 * video-buf generic routine to get the next available buffer
397 */
398static inline void get_next_buf(struct au0828_dmaqueue *dma_q,
399 struct au0828_buffer **buf)
400{
401 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
402
403 if (list_empty(&dma_q->active)) {
404 au0828_isocdbg("No active queue to serve\n");
405 dev->isoc_ctl.buf = NULL;
406 *buf = NULL;
407 return;
408 }
409
410 /* Get the next buffer */
411 *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
412 dev->isoc_ctl.buf = *buf;
413
414 return;
415}
416
417/*
418 * Controls the isoc copy of each urb packet
419 */
420static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
421{
422 struct au0828_buffer *buf;
423 struct au0828_dmaqueue *dma_q = urb->context;
424 unsigned char *outp = NULL;
425 int i, len = 0, rc = 1;
426 unsigned char *p;
427 unsigned char fbyte;
428
429 if (!dev)
430 return 0;
431
432 if ((dev->dev_state & DEV_DISCONNECTED) ||
433 (dev->dev_state & DEV_MISCONFIGURED))
434 return 0;
435
436 if (urb->status < 0) {
437 print_err_status(dev, -1, urb->status);
438 if (urb->status == -ENOENT)
439 return 0;
440 }
441
442 buf = dev->isoc_ctl.buf;
443 if (buf != NULL)
444 outp = videobuf_to_vmalloc(&buf->vb);
445
446 for (i = 0; i < urb->number_of_packets; i++) {
447 int status = urb->iso_frame_desc[i].status;
448
449 if (status < 0) {
450 print_err_status(dev, i, status);
451 if (urb->iso_frame_desc[i].status != -EPROTO)
452 continue;
453 }
454
Devin Heitmueller62899a22009-03-15 18:48:52 -0300455 if (urb->iso_frame_desc[i].actual_length <= 0)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300456 continue;
Devin Heitmueller62899a22009-03-15 18:48:52 -0300457
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300458 if (urb->iso_frame_desc[i].actual_length >
459 dev->max_pkt_size) {
460 au0828_isocdbg("packet bigger than packet size");
461 continue;
462 }
463
464 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
465 fbyte = p[0];
466 len = urb->iso_frame_desc[i].actual_length - 4;
467 p += 4;
468
469 if (fbyte & 0x80) {
470 len -= 4;
471 p += 4;
472 au0828_isocdbg("Video frame %s\n",
473 (fbyte & 0x40) ? "odd" : "even");
474 if (!(fbyte & 0x40)) {
475 if (buf != NULL)
476 buffer_filled(dev, dma_q, buf);
477 get_next_buf(dma_q, &buf);
Devin Heitmueller62899a22009-03-15 18:48:52 -0300478 if (buf == NULL)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300479 outp = NULL;
Devin Heitmueller62899a22009-03-15 18:48:52 -0300480 else
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300481 outp = videobuf_to_vmalloc(&buf->vb);
482 }
483
484 if (buf != NULL) {
Devin Heitmueller62899a22009-03-15 18:48:52 -0300485 if (fbyte & 0x40)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300486 buf->top_field = 1;
Devin Heitmueller62899a22009-03-15 18:48:52 -0300487 else
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300488 buf->top_field = 0;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300489 }
490
491 dma_q->pos = 0;
492 }
Devin Heitmueller62899a22009-03-15 18:48:52 -0300493 if (buf != NULL)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300494 au0828_copy_video(dev, dma_q, buf, p, outp, len);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300495 }
496 return rc;
497}
498
499static int
500buffer_setup(struct videobuf_queue *vq, unsigned int *count,
501 unsigned int *size)
502{
503 struct au0828_fh *fh = vq->priv_data;
504 *size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
505
506 if (0 == *count)
507 *count = AU0828_DEF_BUF;
508
509 if (*count < AU0828_MIN_BUF)
510 *count = AU0828_MIN_BUF;
511 return 0;
512}
513
514/* This is called *without* dev->slock held; please keep it that way */
515static void free_buffer(struct videobuf_queue *vq, struct au0828_buffer *buf)
516{
517 struct au0828_fh *fh = vq->priv_data;
518 struct au0828_dev *dev = fh->dev;
519 unsigned long flags = 0;
520 if (in_interrupt())
521 BUG();
522
523 /* We used to wait for the buffer to finish here, but this didn't work
524 because, as we were keeping the state as VIDEOBUF_QUEUED,
525 videobuf_queue_cancel marked it as finished for us.
526 (Also, it could wedge forever if the hardware was misconfigured.)
527
528 This should be safe; by the time we get here, the buffer isn't
529 queued anymore. If we ever start marking the buffers as
530 VIDEOBUF_ACTIVE, it won't be, though.
531 */
532 spin_lock_irqsave(&dev->slock, flags);
533 if (dev->isoc_ctl.buf == buf)
534 dev->isoc_ctl.buf = NULL;
535 spin_unlock_irqrestore(&dev->slock, flags);
536
537 videobuf_vmalloc_free(&buf->vb);
538 buf->vb.state = VIDEOBUF_NEEDS_INIT;
539}
540
541static int
542buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
543 enum v4l2_field field)
544{
545 struct au0828_fh *fh = vq->priv_data;
546 struct au0828_buffer *buf = container_of(vb, struct au0828_buffer, vb);
547 struct au0828_dev *dev = fh->dev;
548 int rc = 0, urb_init = 0;
549
550 buf->vb.size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
551
552 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
553 return -EINVAL;
554
555 buf->vb.width = dev->width;
556 buf->vb.height = dev->height;
557 buf->vb.field = field;
558
559 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
560 rc = videobuf_iolock(vq, &buf->vb, NULL);
561 if (rc < 0) {
Devin Heitmueller62899a22009-03-15 18:48:52 -0300562 printk(KERN_INFO "videobuf_iolock failed\n");
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300563 goto fail;
564 }
565 }
566
567 if (!dev->isoc_ctl.num_bufs)
568 urb_init = 1;
569
570 if (urb_init) {
571 rc = au0828_init_isoc(dev, AU0828_ISO_PACKETS_PER_URB,
572 AU0828_MAX_ISO_BUFS, dev->max_pkt_size,
573 au0828_isoc_copy);
574 if (rc < 0) {
Devin Heitmueller62899a22009-03-15 18:48:52 -0300575 printk(KERN_INFO "au0828_init_isoc failed\n");
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300576 goto fail;
577 }
578 }
579
580 buf->vb.state = VIDEOBUF_PREPARED;
581 return 0;
582
583fail:
584 free_buffer(vq, buf);
585 return rc;
586}
587
588static void
589buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
590{
591 struct au0828_buffer *buf = container_of(vb,
592 struct au0828_buffer,
593 vb);
594 struct au0828_fh *fh = vq->priv_data;
595 struct au0828_dev *dev = fh->dev;
596 struct au0828_dmaqueue *vidq = &dev->vidq;
597
598 buf->vb.state = VIDEOBUF_QUEUED;
599 list_add_tail(&buf->vb.queue, &vidq->active);
600}
601
602static void buffer_release(struct videobuf_queue *vq,
603 struct videobuf_buffer *vb)
604{
605 struct au0828_buffer *buf = container_of(vb,
606 struct au0828_buffer,
607 vb);
608
609 free_buffer(vq, buf);
610}
611
612static struct videobuf_queue_ops au0828_video_qops = {
613 .buf_setup = buffer_setup,
614 .buf_prepare = buffer_prepare,
615 .buf_queue = buffer_queue,
616 .buf_release = buffer_release,
617};
618
619/* ------------------------------------------------------------------
620 V4L2 interface
621 ------------------------------------------------------------------*/
622
623static int au0828_i2s_init(struct au0828_dev *dev)
624{
625 /* Enable i2s mode */
626 au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
627 return 0;
628}
629
630/*
631 * Auvitek au0828 analog stream enable
632 * Please set interface0 to AS5 before enable the stream
633 */
634int au0828_analog_stream_enable(struct au0828_dev *d)
635{
636 dprintk(1, "au0828_analog_stream_enable called\n");
637 au0828_writereg(d, AU0828_SENSORCTRL_VBI_103, 0x00);
638 au0828_writereg(d, 0x106, 0x00);
639 /* set x position */
640 au0828_writereg(d, 0x110, 0x00);
641 au0828_writereg(d, 0x111, 0x00);
642 au0828_writereg(d, 0x114, 0xa0);
643 au0828_writereg(d, 0x115, 0x05);
644 /* set y position */
645 au0828_writereg(d, 0x112, 0x02);
646 au0828_writereg(d, 0x113, 0x00);
647 au0828_writereg(d, 0x116, 0xf2);
648 au0828_writereg(d, 0x117, 0x00);
649 au0828_writereg(d, AU0828_SENSORCTRL_100, 0xb3);
650
651 return 0;
652}
653
654int au0828_analog_stream_disable(struct au0828_dev *d)
655{
656 dprintk(1, "au0828_analog_stream_disable called\n");
657 au0828_writereg(d, AU0828_SENSORCTRL_100, 0x0);
658 return 0;
659}
660
661void au0828_analog_stream_reset(struct au0828_dev *dev)
662{
663 dprintk(1, "au0828_analog_stream_reset called\n");
664 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0x0);
665 mdelay(30);
666 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0xb3);
667}
668
669/*
670 * Some operations needs to stop current streaming
671 */
672static int au0828_stream_interrupt(struct au0828_dev *dev)
673{
674 int ret = 0;
675
676 dev->stream_state = STREAM_INTERRUPT;
Devin Heitmueller62899a22009-03-15 18:48:52 -0300677 if (dev->dev_state == DEV_DISCONNECTED)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300678 return -ENODEV;
Devin Heitmueller62899a22009-03-15 18:48:52 -0300679 else if (ret) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300680 dev->dev_state = DEV_MISCONFIGURED;
Devin Heitmueller62899a22009-03-15 18:48:52 -0300681 dprintk(1, "%s device is misconfigured!\n", __func__);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300682 return ret;
683 }
684 return 0;
685}
686
687/*
688 * au0828_release_resources
689 * unregister v4l2 devices
690 */
691void au0828_analog_unregister(struct au0828_dev *dev)
692{
693 dprintk(1, "au0828_release_resources called\n");
694 mutex_lock(&au0828_sysfs_lock);
695
Devin Heitmueller2eaf3962009-03-11 03:01:02 -0300696 if (dev->vdev) {
697 list_del(&dev->au0828list);
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -0300698 video_unregister_device(dev->vdev);
Devin Heitmueller2eaf3962009-03-11 03:01:02 -0300699 }
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -0300700 if (dev->vbi_dev)
701 video_unregister_device(dev->vbi_dev);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300702
703 mutex_unlock(&au0828_sysfs_lock);
704}
705
706
707/* Usage lock check functions */
708static int res_get(struct au0828_fh *fh)
709{
710 struct au0828_dev *dev = fh->dev;
711 int rc = 0;
712
713 /* This instance already has stream_on */
714 if (fh->stream_on)
715 return rc;
716
717 if (dev->stream_on)
718 return -EBUSY;
719
720 dev->stream_on = 1;
721 fh->stream_on = 1;
722 return rc;
723}
724
725static int res_check(struct au0828_fh *fh)
726{
727 return fh->stream_on;
728}
729
730static void res_free(struct au0828_fh *fh)
731{
732 struct au0828_dev *dev = fh->dev;
733
734 fh->stream_on = 0;
735 dev->stream_on = 0;
736}
737
738static int au0828_v4l2_open(struct file *filp)
739{
740 int minor = video_devdata(filp)->minor;
741 int ret = 0;
742 struct au0828_dev *h, *dev = NULL;
743 struct au0828_fh *fh;
744 int type = 0;
745 struct list_head *list;
746
747 list_for_each(list, &au0828_devlist) {
748 h = list_entry(list, struct au0828_dev, au0828list);
Devin Heitmueller62899a22009-03-15 18:48:52 -0300749 if (h->vdev->minor == minor) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300750 dev = h;
751 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
752 }
Devin Heitmuellerdd27ade2009-03-15 18:52:10 -0300753#ifdef VBI_IS_WORKING
Devin Heitmueller62899a22009-03-15 18:48:52 -0300754 if (h->vbi_dev->minor == minor) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300755 dev = h;
756 type = V4L2_BUF_TYPE_VBI_CAPTURE;
757 }
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -0300758#endif
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300759 }
760
Devin Heitmueller62899a22009-03-15 18:48:52 -0300761 if (NULL == dev)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300762 return -ENODEV;
763
764 fh = kzalloc(sizeof(struct au0828_fh), GFP_KERNEL);
Devin Heitmueller62899a22009-03-15 18:48:52 -0300765 if (NULL == fh) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300766 dprintk(1, "Failed allocate au0828_fh struct!\n");
767 return -ENOMEM;
768 }
769
770 fh->type = type;
771 fh->dev = dev;
772 filp->private_data = fh;
773
Devin Heitmueller62899a22009-03-15 18:48:52 -0300774 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300775 /* set au0828 interface0 to AS5 here again */
776 ret = usb_set_interface(dev->usbdev, 0, 5);
Devin Heitmueller62899a22009-03-15 18:48:52 -0300777 if (ret < 0) {
778 printk(KERN_INFO "Au0828 can't set alternate to 5!\n");
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300779 return -EBUSY;
780 }
781 dev->width = NTSC_STD_W;
782 dev->height = NTSC_STD_H;
783 dev->frame_size = dev->width * dev->height * 2;
784 dev->field_size = dev->width * dev->height;
785 dev->bytesperline = dev->width * 2;
786
787 au0828_analog_stream_enable(dev);
788 au0828_analog_stream_reset(dev);
789
790 /* If we were doing ac97 instead of i2s, it would go here...*/
791 au0828_i2s_init(dev);
792
793 dev->stream_state = STREAM_OFF;
794 dev->dev_state |= DEV_INITIALIZED;
795 }
796
797 dev->users++;
798
799 videobuf_queue_vmalloc_init(&fh->vb_vidq, &au0828_video_qops,
800 NULL, &dev->slock, fh->type,
801 V4L2_FIELD_INTERLACED,
802 sizeof(struct au0828_buffer), fh);
803
804 return ret;
805}
806
807static int au0828_v4l2_close(struct file *filp)
808{
809 int ret;
810 struct au0828_fh *fh = filp->private_data;
811 struct au0828_dev *dev = fh->dev;
812
813 mutex_lock(&dev->lock);
814 if (res_check(fh))
815 res_free(fh);
816
Devin Heitmueller62899a22009-03-15 18:48:52 -0300817 if (dev->users == 1) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300818 videobuf_stop(&fh->vb_vidq);
819 videobuf_mmap_free(&fh->vb_vidq);
820
Devin Heitmueller62899a22009-03-15 18:48:52 -0300821 if (dev->dev_state & DEV_DISCONNECTED) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300822 au0828_analog_unregister(dev);
823 mutex_unlock(&dev->lock);
824 kfree(dev);
825 return 0;
826 }
827
828 au0828_analog_stream_disable(dev);
829
830 au0828_uninit_isoc(dev);
831
832 /* When close the device, set the usb intf0 into alt0 to free
833 USB bandwidth */
834 ret = usb_set_interface(dev->usbdev, 0, 0);
Devin Heitmueller62899a22009-03-15 18:48:52 -0300835 if (ret < 0)
836 printk(KERN_INFO "Au0828 can't set alternate to 0!\n");
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300837 }
838
839 kfree(fh);
840 dev->users--;
841 wake_up_interruptible_nr(&dev->open, 1);
842 mutex_unlock(&dev->lock);
843 return 0;
844}
845
846static ssize_t au0828_v4l2_read(struct file *filp, char __user *buf,
847 size_t count, loff_t *pos)
848{
849 struct au0828_fh *fh = filp->private_data;
850 struct au0828_dev *dev = fh->dev;
851 int rc;
852
853 rc = check_dev(dev);
854 if (rc < 0)
855 return rc;
856
Devin Heitmueller62899a22009-03-15 18:48:52 -0300857 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300858 mutex_lock(&dev->lock);
859 rc = res_get(fh);
860 mutex_unlock(&dev->lock);
861
862 if (unlikely(rc < 0))
863 return rc;
864
865 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
866 filp->f_flags & O_NONBLOCK);
867 }
868 return 0;
869}
870
871static unsigned int au0828_v4l2_poll(struct file *filp, poll_table *wait)
872{
873 struct au0828_fh *fh = filp->private_data;
874 struct au0828_dev *dev = fh->dev;
875 int rc;
876
877 rc = check_dev(dev);
878 if (rc < 0)
879 return rc;
880
881 mutex_lock(&dev->lock);
882 rc = res_get(fh);
883 mutex_unlock(&dev->lock);
884
885 if (unlikely(rc < 0))
886 return POLLERR;
887
888 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
889 return POLLERR;
890
891 return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
892}
893
894static int au0828_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
895{
896 struct au0828_fh *fh = filp->private_data;
897 struct au0828_dev *dev = fh->dev;
898 int rc;
899
900 rc = check_dev(dev);
901 if (rc < 0)
902 return rc;
903
904 mutex_lock(&dev->lock);
905 rc = res_get(fh);
906 mutex_unlock(&dev->lock);
907
908 if (unlikely(rc < 0))
909 return rc;
910
911 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
912
913 dprintk(2, "vma start=0x%08lx, size=%ld, ret=%d\n",
914 (unsigned long)vma->vm_start,
915 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
916 rc);
917
918 return rc;
919}
920
921static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
922 struct v4l2_format *format)
923{
924 int ret;
925 int width = format->fmt.pix.width;
926 int height = format->fmt.pix.height;
927 unsigned int maxwidth, maxheight;
928
929 maxwidth = 720;
930 maxheight = 480;
931
Devin Heitmuellerdd27ade2009-03-15 18:52:10 -0300932#ifdef VBI_IS_WORKING
Devin Heitmueller62899a22009-03-15 18:48:52 -0300933 if (format->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300934 dprintk(1, "VBI format set: to be supported!\n");
935 return 0;
936 }
Devin Heitmueller62899a22009-03-15 18:48:52 -0300937 if (format->type == V4L2_BUF_TYPE_VBI_CAPTURE)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300938 return 0;
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -0300939#endif
Devin Heitmueller62899a22009-03-15 18:48:52 -0300940 if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300941 return -EINVAL;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300942
943 /* If they are demanding a format other than the one we support,
944 bail out (tvtime asks for UYVY and then retries with YUYV) */
Devin Heitmueller62899a22009-03-15 18:48:52 -0300945 if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300946 return -EINVAL;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300947
948 /* format->fmt.pix.width only support 720 and height 480 */
Devin Heitmueller62899a22009-03-15 18:48:52 -0300949 if (width != 720)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300950 width = 720;
Devin Heitmueller62899a22009-03-15 18:48:52 -0300951 if (height != 480)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300952 height = 480;
953
954 format->fmt.pix.width = width;
955 format->fmt.pix.height = height;
956 format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
957 format->fmt.pix.bytesperline = width * 2;
958 format->fmt.pix.sizeimage = width * height * 2;
959 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
960 format->fmt.pix.field = V4L2_FIELD_INTERLACED;
961
Devin Heitmueller62899a22009-03-15 18:48:52 -0300962 if (cmd == VIDIOC_TRY_FMT)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300963 return 0;
964
965 /* maybe set new image format, driver current only support 720*480 */
966 dev->width = width;
967 dev->height = height;
968 dev->frame_size = width * height * 2;
969 dev->field_size = width * height;
970 dev->bytesperline = width * 2;
971
Devin Heitmueller62899a22009-03-15 18:48:52 -0300972 if (dev->stream_state == STREAM_ON) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300973 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
Devin Heitmueller62899a22009-03-15 18:48:52 -0300974 ret = au0828_stream_interrupt(dev);
975 if (ret != 0) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300976 dprintk(1, "error interrupting video stream!\n");
977 return ret;
978 }
979 }
980
981 /* set au0828 interface0 to AS5 here again */
982 ret = usb_set_interface(dev->usbdev, 0, 5);
Devin Heitmueller62899a22009-03-15 18:48:52 -0300983 if (ret < 0) {
984 printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
Devin Heitmueller8b2f0792009-03-11 03:00:40 -0300985 return -EBUSY;
986 }
987
988 au0828_analog_stream_enable(dev);
989
990 return 0;
991}
992
993
994static int vidioc_queryctrl(struct file *file, void *priv,
995 struct v4l2_queryctrl *qc)
996{
997 struct au0828_fh *fh = priv;
998 struct au0828_dev *dev = fh->dev;
Devin Heitmueller2689d3d2009-03-15 20:01:53 -0300999 v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, qc);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001000 if (qc->type)
1001 return 0;
1002 else
1003 return -EINVAL;
1004}
1005
1006static int vidioc_querycap(struct file *file, void *priv,
1007 struct v4l2_capability *cap)
1008{
1009 struct au0828_fh *fh = priv;
1010 struct au0828_dev *dev = fh->dev;
1011
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001012 strlcpy(cap->driver, "au0828", sizeof(cap->driver));
Devin Heitmuellerf1add5b2009-03-11 03:00:47 -03001013 strlcpy(cap->card, dev->board.name, sizeof(cap->card));
Devin Heitmuellerb14667f2009-03-11 03:01:04 -03001014 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001015
1016 cap->version = AU0828_VERSION_CODE;
1017
1018 /*set the device capabilities */
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -03001019 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
Devin Heitmuellerdd27ade2009-03-15 18:52:10 -03001020#ifdef VBI_IS_WORKING
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -03001021 V4L2_CAP_VBI_CAPTURE |
1022#endif
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001023 V4L2_CAP_AUDIO |
1024 V4L2_CAP_READWRITE |
1025 V4L2_CAP_STREAMING |
1026 V4L2_CAP_TUNER;
1027 return 0;
1028}
1029
1030static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1031 struct v4l2_fmtdesc *f)
1032{
Devin Heitmueller62899a22009-03-15 18:48:52 -03001033 if (f->index)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001034 return -EINVAL;
1035
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001036 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1037 strcpy(f->description, "Packed YUV2");
1038
1039 f->flags = 0;
1040 f->pixelformat = V4L2_PIX_FMT_UYVY;
1041
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001042 return 0;
1043}
1044
1045static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1046 struct v4l2_format *f)
1047{
1048 struct au0828_fh *fh = priv;
1049 struct au0828_dev *dev = fh->dev;
1050
1051 f->fmt.pix.width = dev->width;
1052 f->fmt.pix.height = dev->height;
1053 f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1054 f->fmt.pix.bytesperline = dev->bytesperline;
1055 f->fmt.pix.sizeimage = dev->frame_size;
1056 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
1057 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1058 return 0;
1059}
1060
1061static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1062 struct v4l2_format *f)
1063{
1064 struct au0828_fh *fh = priv;
1065 struct au0828_dev *dev = fh->dev;
1066
1067 return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1068}
1069
1070static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1071 struct v4l2_format *f)
1072{
1073 struct au0828_fh *fh = priv;
1074 struct au0828_dev *dev = fh->dev;
1075 int rc;
1076
1077 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
Devin Heitmueller62899a22009-03-15 18:48:52 -03001078 printk(KERN_INFO "%s queue busy\n", __func__);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001079 rc = -EBUSY;
1080 goto out;
1081 }
1082
1083 if (dev->stream_on && !fh->stream_on) {
Devin Heitmueller62899a22009-03-15 18:48:52 -03001084 printk(KERN_INFO "%s device in use by another fh\n", __func__);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001085 rc = -EBUSY;
1086 goto out;
1087 }
1088
1089 return au0828_set_format(dev, VIDIOC_S_FMT, f);
1090out:
1091 return rc;
1092}
1093
1094static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id * norm)
1095{
1096 struct au0828_fh *fh = priv;
1097 struct au0828_dev *dev = fh->dev;
1098
1099 /* FIXME: when we support something other than NTSC, we are going to
1100 have to make the au0828 bridge adjust the size of its capture
1101 buffer, which is currently hardcoded at 720x480 */
1102
Hans Verkuilf41737e2009-04-01 03:52:39 -03001103 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, *norm);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001104 return 0;
1105}
1106
1107static int vidioc_enum_input(struct file *file, void *priv,
1108 struct v4l2_input *input)
1109{
1110 struct au0828_fh *fh = priv;
1111 struct au0828_dev *dev = fh->dev;
1112 unsigned int tmp;
1113
1114 static const char *inames[] = {
Devin Heitmueller3d622872009-03-15 17:48:26 -03001115 [AU0828_VMUX_UNDEFINED] = "Undefined",
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001116 [AU0828_VMUX_COMPOSITE] = "Composite",
1117 [AU0828_VMUX_SVIDEO] = "S-Video",
1118 [AU0828_VMUX_CABLE] = "Cable TV",
1119 [AU0828_VMUX_TELEVISION] = "Television",
1120 [AU0828_VMUX_DVB] = "DVB",
1121 [AU0828_VMUX_DEBUG] = "tv debug"
1122 };
1123
1124 tmp = input->index;
1125
Devin Heitmueller62899a22009-03-15 18:48:52 -03001126 if (tmp > AU0828_MAX_INPUT)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001127 return -EINVAL;
Devin Heitmueller62899a22009-03-15 18:48:52 -03001128 if (AUVI_INPUT(tmp).type == 0)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001129 return -EINVAL;
1130
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001131 input->index = tmp;
Devin Heitmuellerf1add5b2009-03-11 03:00:47 -03001132 strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
Devin Heitmueller62899a22009-03-15 18:48:52 -03001133 if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
1134 (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE))
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001135 input->type |= V4L2_INPUT_TYPE_TUNER;
1136 else
1137 input->type |= V4L2_INPUT_TYPE_CAMERA;
1138
1139 input->std = dev->vdev->tvnorms;
1140
1141 return 0;
1142}
1143
1144static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1145{
1146 struct au0828_fh *fh = priv;
1147 struct au0828_dev *dev = fh->dev;
1148 *i = dev->ctrl_input;
1149 return 0;
1150}
1151
1152static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1153{
1154 struct au0828_fh *fh = priv;
1155 struct au0828_dev *dev = fh->dev;
1156 int i;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001157
Devin Heitmueller62899a22009-03-15 18:48:52 -03001158 dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001159 index);
Devin Heitmueller62899a22009-03-15 18:48:52 -03001160 if (index >= AU0828_MAX_INPUT)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001161 return -EINVAL;
Devin Heitmueller62899a22009-03-15 18:48:52 -03001162 if (AUVI_INPUT(index).type == 0)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001163 return -EINVAL;
1164 dev->ctrl_input = index;
1165
Devin Heitmueller62899a22009-03-15 18:48:52 -03001166 switch (AUVI_INPUT(index).type) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001167 case AU0828_VMUX_SVIDEO:
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001168 dev->input_type = AU0828_VMUX_SVIDEO;
1169 break;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001170 case AU0828_VMUX_COMPOSITE:
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001171 dev->input_type = AU0828_VMUX_COMPOSITE;
1172 break;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001173 case AU0828_VMUX_TELEVISION:
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001174 dev->input_type = AU0828_VMUX_TELEVISION;
1175 break;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001176 default:
Devin Heitmuellera1094c42009-03-15 17:43:13 -03001177 dprintk(1, "VIDIOC_S_INPUT unknown input type set [%d]\n",
1178 AUVI_INPUT(index).type);
1179 break;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001180 }
1181
Hans Verkuil5325b422009-04-02 11:26:22 -03001182 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1183 AUVI_INPUT(index).vmux, 0, 0);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001184
1185 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1186 int enable = 0;
Devin Heitmueller62899a22009-03-15 18:48:52 -03001187 if (AUVI_INPUT(i).audio_setup == NULL)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001188 continue;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001189
1190 if (i == index)
1191 enable = 1;
1192 else
1193 enable = 0;
1194 if (enable) {
Devin Heitmuellerf1add5b2009-03-11 03:00:47 -03001195 (AUVI_INPUT(i).audio_setup)(dev, enable);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001196 } else {
1197 /* Make sure we leave it turned on if some
1198 other input is routed to this callback */
Devin Heitmuellerf1add5b2009-03-11 03:00:47 -03001199 if ((AUVI_INPUT(i).audio_setup) !=
1200 ((AUVI_INPUT(index).audio_setup))) {
1201 (AUVI_INPUT(i).audio_setup)(dev, enable);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001202 }
1203 }
1204 }
1205
Hans Verkuil5325b422009-04-02 11:26:22 -03001206 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1207 AUVI_INPUT(index).amux, 0, 0);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001208 return 0;
1209}
1210
1211static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1212{
1213 struct au0828_fh *fh = priv;
1214 struct au0828_dev *dev = fh->dev;
1215 unsigned int index = a->index;
1216
Devin Heitmueller62899a22009-03-15 18:48:52 -03001217 if (a->index > 1)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001218 return -EINVAL;
1219
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001220 index = dev->ctrl_ainput;
Devin Heitmueller62899a22009-03-15 18:48:52 -03001221 if (index == 0)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001222 strcpy(a->name, "Television");
1223 else
1224 strcpy(a->name, "Line in");
1225
1226 a->capability = V4L2_AUDCAP_STEREO;
1227 a->index = index;
1228 return 0;
1229}
1230
1231static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
1232{
1233 struct au0828_fh *fh = priv;
1234 struct au0828_dev *dev = fh->dev;
Devin Heitmueller62899a22009-03-15 18:48:52 -03001235 if (a->index != dev->ctrl_ainput)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001236 return -EINVAL;
1237 return 0;
1238}
1239
1240static int vidioc_g_ctrl(struct file *file, void *priv,
1241 struct v4l2_control *ctrl)
1242{
1243 struct au0828_fh *fh = priv;
1244 struct au0828_dev *dev = fh->dev;
1245
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001246 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001247 return 0;
1248
1249}
1250
1251static int vidioc_s_ctrl(struct file *file, void *priv,
1252 struct v4l2_control *ctrl)
1253{
1254 struct au0828_fh *fh = priv;
1255 struct au0828_dev *dev = fh->dev;
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001256 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_ctrl, ctrl);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001257 return 0;
1258}
1259
1260static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1261{
1262 struct au0828_fh *fh = priv;
1263 struct au0828_dev *dev = fh->dev;
1264
Devin Heitmueller62899a22009-03-15 18:48:52 -03001265 if (t->index != 0)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001266 return -EINVAL;
1267
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001268 strcpy(t->name, "Auvitek tuner");
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001269 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001270 return 0;
1271}
1272
1273static int vidioc_s_tuner(struct file *file, void *priv,
1274 struct v4l2_tuner *t)
1275{
1276 struct au0828_fh *fh = priv;
1277 struct au0828_dev *dev = fh->dev;
1278
Devin Heitmueller62899a22009-03-15 18:48:52 -03001279 if (t->index != 0)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001280 return -EINVAL;
1281
1282 t->type = V4L2_TUNER_ANALOG_TV;
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001283 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001284 dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1285 t->afc);
1286 return 0;
1287
1288}
1289
1290static int vidioc_g_frequency(struct file *file, void *priv,
1291 struct v4l2_frequency *freq)
1292{
1293 struct au0828_fh *fh = priv;
1294 struct au0828_dev *dev = fh->dev;
Devin Heitmuellerc8889232009-03-15 17:38:47 -03001295
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001296 freq->type = V4L2_TUNER_ANALOG_TV;
1297 freq->frequency = dev->ctrl_freq;
1298 return 0;
1299}
1300
1301static int vidioc_s_frequency(struct file *file, void *priv,
1302 struct v4l2_frequency *freq)
1303{
1304 struct au0828_fh *fh = priv;
1305 struct au0828_dev *dev = fh->dev;
1306
Devin Heitmueller62899a22009-03-15 18:48:52 -03001307 if (freq->tuner != 0)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001308 return -EINVAL;
Devin Heitmueller62899a22009-03-15 18:48:52 -03001309 if (freq->type != V4L2_TUNER_ANALOG_TV)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001310 return -EINVAL;
1311
1312 dev->ctrl_freq = freq->frequency;
1313
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001314 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001315
1316 au0828_analog_stream_reset(dev);
1317
1318 return 0;
1319}
1320
1321static int vidioc_g_chip_ident(struct file *file, void *priv,
1322 struct v4l2_dbg_chip_ident *chip)
1323{
1324 struct au0828_fh *fh = priv;
1325 struct au0828_dev *dev = fh->dev;
1326 chip->ident = V4L2_IDENT_NONE;
1327 chip->revision = 0;
1328
Devin Heitmuellerd9109be2009-03-11 03:00:58 -03001329 if (v4l2_chip_match_host(&chip->match)) {
1330 chip->ident = V4L2_IDENT_AU0828;
1331 return 0;
1332 }
1333
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001334 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
Devin Heitmuellerd9109be2009-03-11 03:00:58 -03001335 if (chip->ident == V4L2_IDENT_NONE)
1336 return -EINVAL;
1337
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001338 return 0;
1339}
1340
1341static int vidioc_cropcap(struct file *file, void *priv,
1342 struct v4l2_cropcap *cc)
1343{
1344 struct au0828_fh *fh = priv;
1345 struct au0828_dev *dev = fh->dev;
1346
Devin Heitmueller62899a22009-03-15 18:48:52 -03001347 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001348 return -EINVAL;
1349
1350 cc->bounds.left = 0;
1351 cc->bounds.top = 0;
1352 cc->bounds.width = dev->width;
1353 cc->bounds.height = dev->height;
1354
1355 cc->defrect = cc->bounds;
1356
1357 cc->pixelaspect.numerator = 54;
1358 cc->pixelaspect.denominator = 59;
1359
1360 return 0;
1361}
1362
1363static int vidioc_streamon(struct file *file, void *priv,
1364 enum v4l2_buf_type type)
1365{
1366 struct au0828_fh *fh = priv;
1367 struct au0828_dev *dev = fh->dev;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001368 int rc;
1369
1370 rc = check_dev(dev);
1371 if (rc < 0)
1372 return rc;
1373
1374 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1375 au0828_analog_stream_enable(dev);
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001376 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001377 }
1378
1379 mutex_lock(&dev->lock);
1380 rc = res_get(fh);
1381
1382 if (likely(rc >= 0))
1383 rc = videobuf_streamon(&fh->vb_vidq);
1384 mutex_unlock(&dev->lock);
1385
1386 return rc;
1387}
1388
1389static int vidioc_streamoff(struct file *file, void *priv,
1390 enum v4l2_buf_type type)
1391{
1392 struct au0828_fh *fh = priv;
1393 struct au0828_dev *dev = fh->dev;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001394 int i;
1395 int ret;
1396 int rc;
1397
1398 rc = check_dev(dev);
1399 if (rc < 0)
1400 return rc;
1401
1402 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1403 return -EINVAL;
1404 if (type != fh->type)
1405 return -EINVAL;
1406
1407 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001408 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
Devin Heitmueller62899a22009-03-15 18:48:52 -03001409 ret = au0828_stream_interrupt(dev);
1410 if (ret != 0)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001411 return ret;
1412 }
1413
1414 for (i = 0; i < AU0828_MAX_INPUT; i++) {
Devin Heitmueller62899a22009-03-15 18:48:52 -03001415 if (AUVI_INPUT(i).audio_setup == NULL)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001416 continue;
Devin Heitmuellerf1add5b2009-03-11 03:00:47 -03001417 (AUVI_INPUT(i).audio_setup)(dev, 0);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001418 }
1419
1420 mutex_lock(&dev->lock);
1421 videobuf_streamoff(&fh->vb_vidq);
1422 res_free(fh);
1423 mutex_unlock(&dev->lock);
1424
1425 return 0;
1426}
1427
Mauro Carvalho Chehab80c6e352009-03-19 19:26:23 -03001428#ifdef CONFIG_VIDEO_ADV_DEBUG
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001429static int vidioc_g_register(struct file *file, void *priv,
1430 struct v4l2_dbg_register *reg)
1431{
1432 struct au0828_fh *fh = priv;
1433 struct au0828_dev *dev = fh->dev;
1434
1435 switch (reg->match.type) {
1436 case V4L2_CHIP_MATCH_I2C_DRIVER:
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001437 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001438 return 0;
1439 default:
1440 return -EINVAL;
1441 }
1442}
1443
1444static int vidioc_s_register(struct file *file, void *priv,
1445 struct v4l2_dbg_register *reg)
1446{
1447 struct au0828_fh *fh = priv;
1448 struct au0828_dev *dev = fh->dev;
1449
1450 switch (reg->match.type) {
1451 case V4L2_CHIP_MATCH_I2C_DRIVER:
Devin Heitmueller2689d3d2009-03-15 20:01:53 -03001452 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001453 return 0;
1454 default:
1455 return -EINVAL;
1456 }
1457 return 0;
1458}
Mauro Carvalho Chehab80c6e352009-03-19 19:26:23 -03001459#endif
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001460
1461static int vidioc_reqbufs(struct file *file, void *priv,
1462 struct v4l2_requestbuffers *rb)
1463{
1464 struct au0828_fh *fh = priv;
1465 struct au0828_dev *dev = fh->dev;
1466 int rc;
1467
1468 rc = check_dev(dev);
1469 if (rc < 0)
1470 return rc;
1471
1472 return videobuf_reqbufs(&fh->vb_vidq, rb);
1473}
1474
1475static int vidioc_querybuf(struct file *file, void *priv,
1476 struct v4l2_buffer *b)
1477{
1478 struct au0828_fh *fh = priv;
1479 struct au0828_dev *dev = fh->dev;
1480 int rc;
1481
1482 rc = check_dev(dev);
1483 if (rc < 0)
1484 return rc;
1485
1486 return videobuf_querybuf(&fh->vb_vidq, b);
1487}
1488
1489static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1490{
1491 struct au0828_fh *fh = priv;
1492 struct au0828_dev *dev = fh->dev;
1493 int rc;
1494
1495 rc = check_dev(dev);
1496 if (rc < 0)
1497 return rc;
1498
1499 return videobuf_qbuf(&fh->vb_vidq, b);
1500}
1501
1502static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1503{
1504 struct au0828_fh *fh = priv;
1505 struct au0828_dev *dev = fh->dev;
1506 int rc;
1507
1508 rc = check_dev(dev);
1509 if (rc < 0)
1510 return rc;
1511
1512 /* Workaround for a bug in the au0828 hardware design that sometimes
1513 results in the colorspace being inverted */
1514 if (dev->greenscreen_detected == 1) {
1515 dprintk(1, "Detected green frame. Resetting stream...\n");
1516 au0828_analog_stream_reset(dev);
1517 dev->greenscreen_detected = 0;
1518 }
1519
1520 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1521}
1522
1523#ifdef CONFIG_VIDEO_V4L1_COMPAT
1524static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1525{
1526 struct au0828_fh *fh = priv;
1527
1528 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1529}
1530#endif
1531
1532static struct v4l2_file_operations au0828_v4l_fops = {
1533 .owner = THIS_MODULE,
1534 .open = au0828_v4l2_open,
1535 .release = au0828_v4l2_close,
1536 .read = au0828_v4l2_read,
1537 .poll = au0828_v4l2_poll,
1538 .mmap = au0828_v4l2_mmap,
1539 .ioctl = video_ioctl2,
1540};
1541
1542static const struct v4l2_ioctl_ops video_ioctl_ops = {
1543 .vidioc_querycap = vidioc_querycap,
1544 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1545 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1546 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1547 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
Devin Heitmuellerdd27ade2009-03-15 18:52:10 -03001548#ifdef VBI_IS_WORKING
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -03001549 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1550 .vidioc_try_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
1551 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
1552#endif
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001553 .vidioc_g_audio = vidioc_g_audio,
1554 .vidioc_s_audio = vidioc_s_audio,
1555 .vidioc_cropcap = vidioc_cropcap,
Devin Heitmuellerdd27ade2009-03-15 18:52:10 -03001556#ifdef VBI_IS_WORKING
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001557 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
1558 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
1559 .vidioc_s_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
1560#endif
1561 .vidioc_reqbufs = vidioc_reqbufs,
1562 .vidioc_querybuf = vidioc_querybuf,
1563 .vidioc_qbuf = vidioc_qbuf,
1564 .vidioc_dqbuf = vidioc_dqbuf,
1565 .vidioc_s_std = vidioc_s_std,
1566 .vidioc_enum_input = vidioc_enum_input,
1567 .vidioc_g_input = vidioc_g_input,
1568 .vidioc_s_input = vidioc_s_input,
1569 .vidioc_queryctrl = vidioc_queryctrl,
1570 .vidioc_g_ctrl = vidioc_g_ctrl,
1571 .vidioc_s_ctrl = vidioc_s_ctrl,
1572 .vidioc_streamon = vidioc_streamon,
1573 .vidioc_streamoff = vidioc_streamoff,
1574 .vidioc_g_tuner = vidioc_g_tuner,
1575 .vidioc_s_tuner = vidioc_s_tuner,
1576 .vidioc_g_frequency = vidioc_g_frequency,
1577 .vidioc_s_frequency = vidioc_s_frequency,
1578#ifdef CONFIG_VIDEO_ADV_DEBUG
1579 .vidioc_g_register = vidioc_g_register,
1580 .vidioc_s_register = vidioc_s_register,
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001581#endif
Mauro Carvalho Chehab80c6e352009-03-19 19:26:23 -03001582 .vidioc_g_chip_ident = vidioc_g_chip_ident,
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001583#ifdef CONFIG_VIDEO_V4L1_COMPAT
1584 .vidiocgmbuf = vidiocgmbuf,
1585#endif
1586};
1587
1588static const struct video_device au0828_video_template = {
1589 .fops = &au0828_v4l_fops,
1590 .release = video_device_release,
1591 .ioctl_ops = &video_ioctl_ops,
1592 .minor = -1,
Devin Heitmueller0ef210712009-03-11 03:00:53 -03001593 .tvnorms = V4L2_STD_NTSC_M,
1594 .current_norm = V4L2_STD_NTSC_M,
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001595};
1596
1597/**************************************************************************/
1598
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001599int au0828_analog_register(struct au0828_dev *dev,
1600 struct usb_interface *interface)
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001601{
1602 int retval = -ENOMEM;
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001603 struct usb_host_interface *iface_desc;
1604 struct usb_endpoint_descriptor *endpoint;
1605 int i;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001606
1607 dprintk(1, "au0828_analog_register called!\n");
1608
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001609 /* set au0828 usb interface0 to as5 */
1610 retval = usb_set_interface(dev->usbdev,
Devin Heitmueller62899a22009-03-15 18:48:52 -03001611 interface->cur_altsetting->desc.bInterfaceNumber, 5);
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001612 if (retval != 0) {
Devin Heitmueller62899a22009-03-15 18:48:52 -03001613 printk(KERN_INFO "Failure setting usb interface0 to as5\n");
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001614 return retval;
1615 }
1616
1617 /* Figure out which endpoint has the isoc interface */
1618 iface_desc = interface->cur_altsetting;
Devin Heitmueller62899a22009-03-15 18:48:52 -03001619 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001620 endpoint = &iface_desc->endpoint[i].desc;
Devin Heitmueller62899a22009-03-15 18:48:52 -03001621 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1622 == USB_DIR_IN) &&
1623 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1624 == USB_ENDPOINT_XFER_ISOC)) {
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001625
1626 /* we find our isoc in endpoint */
1627 u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
Devin Heitmueller62899a22009-03-15 18:48:52 -03001628 dev->max_pkt_size = (tmp & 0x07ff) *
1629 (((tmp & 0x1800) >> 11) + 1);
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001630 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1631 }
1632 }
Devin Heitmueller62899a22009-03-15 18:48:52 -03001633 if (!(dev->isoc_in_endpointaddr)) {
1634 printk(KERN_INFO "Could not locate isoc endpoint\n");
Devin Heitmuellerfc4ce6c2009-03-11 03:01:00 -03001635 kfree(dev);
1636 return -ENODEV;
1637 }
1638
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001639 init_waitqueue_head(&dev->open);
1640 spin_lock_init(&dev->slock);
1641 mutex_init(&dev->lock);
1642
1643 INIT_LIST_HEAD(&dev->vidq.active);
1644 INIT_LIST_HEAD(&dev->vidq.queued);
1645
1646 dev->width = NTSC_STD_W;
1647 dev->height = NTSC_STD_H;
1648 dev->field_size = dev->width * dev->height;
1649 dev->frame_size = dev->field_size << 1;
1650 dev->bytesperline = dev->width << 1;
1651 dev->ctrl_ainput = 0;
1652
1653 /* allocate and fill v4l2 video struct */
1654 dev->vdev = video_device_alloc();
Devin Heitmueller62899a22009-03-15 18:48:52 -03001655 if (NULL == dev->vdev) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001656 dprintk(1, "Can't allocate video_device.\n");
1657 return -ENOMEM;
1658 }
1659
Devin Heitmuellerdd27ade2009-03-15 18:52:10 -03001660#ifdef VBI_IS_WORKING
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001661 dev->vbi_dev = video_device_alloc();
Devin Heitmueller62899a22009-03-15 18:48:52 -03001662 if (NULL == dev->vbi_dev) {
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001663 dprintk(1, "Can't allocate vbi_device.\n");
1664 kfree(dev->vdev);
1665 return -ENOMEM;
1666 }
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -03001667#endif
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001668
1669 /* Fill the video capture device struct */
1670 *dev->vdev = au0828_video_template;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001671 dev->vdev->parent = &dev->usbdev->dev;
1672 strcpy(dev->vdev->name, "au0828a video");
1673
Devin Heitmuellerdd27ade2009-03-15 18:52:10 -03001674#ifdef VBI_IS_WORKING
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001675 /* Setup the VBI device */
1676 *dev->vbi_dev = au0828_video_template;
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001677 dev->vbi_dev->parent = &dev->usbdev->dev;
1678 strcpy(dev->vbi_dev->name, "au0828a vbi");
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -03001679#endif
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001680
1681 list_add_tail(&dev->au0828list, &au0828_devlist);
1682
1683 /* Register the v4l2 device */
Devin Heitmueller62899a22009-03-15 18:48:52 -03001684 retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
1685 if (retval != 0) {
1686 dprintk(1, "unable to register video device (error = %d).\n",
1687 retval);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001688 list_del(&dev->au0828list);
1689 video_device_release(dev->vdev);
1690 return -ENODEV;
1691 }
1692
Devin Heitmuellerdd27ade2009-03-15 18:52:10 -03001693#ifdef VBI_IS_WORKING
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001694 /* Register the vbi device */
Devin Heitmueller62899a22009-03-15 18:48:52 -03001695 retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
1696 if (retval != 0) {
1697 dprintk(1, "unable to register vbi device (error = %d).\n",
1698 retval);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001699 list_del(&dev->au0828list);
1700 video_device_release(dev->vbi_dev);
1701 video_device_release(dev->vdev);
1702 return -ENODEV;
1703 }
Devin Heitmueller5a5a4e12009-03-11 03:00:55 -03001704#endif
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001705
Devin Heitmueller62899a22009-03-15 18:48:52 -03001706 dprintk(1, "%s completed!\n", __func__);
Devin Heitmueller8b2f0792009-03-11 03:00:40 -03001707
1708 return 0;
1709}
1710