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