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