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