1 /* 2 * Driver for the Auvitek USB bridge 3 * 4 * Copyright (c) 2008 Steven Toth <stoth@linuxtv.org> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * 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., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include "au0828.h" 23 #include "au8522.h" 24 25 #include <linux/module.h> 26 #include <linux/slab.h> 27 #include <linux/videodev2.h> 28 #include <media/v4l2-common.h> 29 #include <linux/mutex.h> 30 31 /* Due to enum tuner_pad_index */ 32 #include <media/tuner.h> 33 34 /* 35 * 1 = General debug messages 36 * 2 = USB handling 37 * 4 = I2C related 38 * 8 = Bridge related 39 * 16 = IR related 40 */ 41 int au0828_debug; 42 module_param_named(debug, au0828_debug, int, 0644); 43 MODULE_PARM_DESC(debug, 44 "set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR"); 45 46 static unsigned int disable_usb_speed_check; 47 module_param(disable_usb_speed_check, int, 0444); 48 MODULE_PARM_DESC(disable_usb_speed_check, 49 "override min bandwidth requirement of 480M bps"); 50 51 #define _AU0828_BULKPIPE 0x03 52 #define _BULKPIPESIZE 0xffff 53 54 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value, 55 u16 index); 56 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value, 57 u16 index, unsigned char *cp, u16 size); 58 59 /* USB Direction */ 60 #define CMD_REQUEST_IN 0x00 61 #define CMD_REQUEST_OUT 0x01 62 63 u32 au0828_readreg(struct au0828_dev *dev, u16 reg) 64 { 65 u8 result = 0; 66 67 recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, &result, 1); 68 dprintk(8, "%s(0x%04x) = 0x%02x\n", __func__, reg, result); 69 70 return result; 71 } 72 73 u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val) 74 { 75 dprintk(8, "%s(0x%04x, 0x%02x)\n", __func__, reg, val); 76 return send_control_msg(dev, CMD_REQUEST_OUT, val, reg); 77 } 78 79 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value, 80 u16 index) 81 { 82 int status = -ENODEV; 83 84 if (dev->usbdev) { 85 86 /* cp must be memory that has been allocated by kmalloc */ 87 status = usb_control_msg(dev->usbdev, 88 usb_sndctrlpipe(dev->usbdev, 0), 89 request, 90 USB_DIR_OUT | USB_TYPE_VENDOR | 91 USB_RECIP_DEVICE, 92 value, index, NULL, 0, 1000); 93 94 status = min(status, 0); 95 96 if (status < 0) { 97 pr_err("%s() Failed sending control message, error %d.\n", 98 __func__, status); 99 } 100 101 } 102 103 return status; 104 } 105 106 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value, 107 u16 index, unsigned char *cp, u16 size) 108 { 109 int status = -ENODEV; 110 mutex_lock(&dev->mutex); 111 if (dev->usbdev) { 112 status = usb_control_msg(dev->usbdev, 113 usb_rcvctrlpipe(dev->usbdev, 0), 114 request, 115 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 116 value, index, 117 dev->ctrlmsg, size, 1000); 118 119 status = min(status, 0); 120 121 if (status < 0) { 122 pr_err("%s() Failed receiving control message, error %d.\n", 123 __func__, status); 124 } 125 126 /* the host controller requires heap allocated memory, which 127 is why we didn't just pass "cp" into usb_control_msg */ 128 memcpy(cp, dev->ctrlmsg, size); 129 } 130 mutex_unlock(&dev->mutex); 131 return status; 132 } 133 134 #ifdef CONFIG_MEDIA_CONTROLLER 135 static void au0828_media_graph_notify(struct media_entity *new, 136 void *notify_data); 137 #endif 138 139 static void au0828_unregister_media_device(struct au0828_dev *dev) 140 { 141 #ifdef CONFIG_MEDIA_CONTROLLER 142 struct media_device *mdev = dev->media_dev; 143 struct media_entity_notify *notify, *nextp; 144 145 if (!mdev || !media_devnode_is_registered(&mdev->devnode)) 146 return; 147 148 /* Remove au0828 entity_notify callbacks */ 149 list_for_each_entry_safe(notify, nextp, &mdev->entity_notify, list) { 150 if (notify->notify != au0828_media_graph_notify) 151 continue; 152 media_device_unregister_entity_notify(mdev, notify); 153 } 154 155 /* clear enable_source, disable_source */ 156 dev->media_dev->source_priv = NULL; 157 dev->media_dev->enable_source = NULL; 158 dev->media_dev->disable_source = NULL; 159 160 media_device_unregister(dev->media_dev); 161 media_device_cleanup(dev->media_dev); 162 kfree(dev->media_dev); 163 dev->media_dev = NULL; 164 #endif 165 } 166 167 void au0828_usb_release(struct au0828_dev *dev) 168 { 169 au0828_unregister_media_device(dev); 170 171 /* I2C */ 172 au0828_i2c_unregister(dev); 173 174 kfree(dev); 175 } 176 177 static void au0828_usb_disconnect(struct usb_interface *interface) 178 { 179 struct au0828_dev *dev = usb_get_intfdata(interface); 180 181 dprintk(1, "%s()\n", __func__); 182 183 /* there is a small window after disconnect, before 184 dev->usbdev is NULL, for poll (e.g: IR) try to access 185 the device and fill the dmesg with error messages. 186 Set the status so poll routines can check and avoid 187 access after disconnect. 188 */ 189 set_bit(DEV_DISCONNECTED, &dev->dev_state); 190 191 au0828_rc_unregister(dev); 192 /* Digital TV */ 193 au0828_dvb_unregister(dev); 194 195 usb_set_intfdata(interface, NULL); 196 mutex_lock(&dev->mutex); 197 dev->usbdev = NULL; 198 mutex_unlock(&dev->mutex); 199 if (au0828_analog_unregister(dev)) { 200 /* 201 * No need to call au0828_usb_release() if V4L2 is enabled, 202 * as this is already called via au0828_usb_v4l2_release() 203 */ 204 return; 205 } 206 au0828_usb_release(dev); 207 } 208 209 static int au0828_media_device_init(struct au0828_dev *dev, 210 struct usb_device *udev) 211 { 212 #ifdef CONFIG_MEDIA_CONTROLLER 213 struct media_device *mdev; 214 215 mdev = kzalloc(sizeof(*mdev), GFP_KERNEL); 216 if (!mdev) 217 return -ENOMEM; 218 219 /* check if media device is already initialized */ 220 if (!mdev->dev) 221 media_device_usb_init(mdev, udev, udev->product); 222 223 dev->media_dev = mdev; 224 #endif 225 return 0; 226 } 227 228 #ifdef CONFIG_MEDIA_CONTROLLER 229 static void au0828_media_graph_notify(struct media_entity *new, 230 void *notify_data) 231 { 232 struct au0828_dev *dev = (struct au0828_dev *) notify_data; 233 int ret; 234 struct media_entity *entity, *mixer = NULL, *decoder = NULL; 235 236 if (!new) { 237 /* 238 * Called during au0828 probe time to connect 239 * entites that were created prior to registering 240 * the notify handler. Find mixer and decoder. 241 */ 242 media_device_for_each_entity(entity, dev->media_dev) { 243 if (entity->function == MEDIA_ENT_F_AUDIO_MIXER) 244 mixer = entity; 245 else if (entity->function == MEDIA_ENT_F_ATV_DECODER) 246 decoder = entity; 247 } 248 goto create_link; 249 } 250 251 switch (new->function) { 252 case MEDIA_ENT_F_AUDIO_MIXER: 253 mixer = new; 254 if (dev->decoder) 255 decoder = dev->decoder; 256 break; 257 case MEDIA_ENT_F_ATV_DECODER: 258 /* In case, Mixer is added first, find mixer and create link */ 259 media_device_for_each_entity(entity, dev->media_dev) { 260 if (entity->function == MEDIA_ENT_F_AUDIO_MIXER) 261 mixer = entity; 262 } 263 decoder = new; 264 break; 265 default: 266 break; 267 } 268 269 create_link: 270 if (decoder && mixer) { 271 ret = media_create_pad_link(decoder, 272 DEMOD_PAD_AUDIO_OUT, 273 mixer, 0, 274 MEDIA_LNK_FL_ENABLED); 275 if (ret) 276 dev_err(&dev->usbdev->dev, 277 "Mixer Pad Link Create Error: %d\n", ret); 278 } 279 } 280 281 static int au0828_enable_source(struct media_entity *entity, 282 struct media_pipeline *pipe) 283 { 284 struct media_entity *source, *find_source; 285 struct media_entity *sink; 286 struct media_link *link, *found_link = NULL; 287 int ret = 0; 288 struct media_device *mdev = entity->graph_obj.mdev; 289 struct au0828_dev *dev; 290 291 if (!mdev) 292 return -ENODEV; 293 294 mutex_lock(&mdev->graph_mutex); 295 296 dev = mdev->source_priv; 297 298 /* 299 * For Audio and V4L2 entity, find the link to which decoder 300 * is the sink. Look for an active link between decoder and 301 * source (tuner/s-video/Composite), if one exists, nothing 302 * to do. If not, look for any active links between source 303 * and any other entity. If one exists, source is busy. If 304 * source is free, setup link and start pipeline from source. 305 * For DVB FE entity, the source for the link is the tuner. 306 * Check if tuner is available and setup link and start 307 * pipeline. 308 */ 309 if (entity->function == MEDIA_ENT_F_DTV_DEMOD) { 310 sink = entity; 311 find_source = dev->tuner; 312 } else { 313 /* Analog isn't configured or register failed */ 314 if (!dev->decoder) { 315 ret = -ENODEV; 316 goto end; 317 } 318 319 sink = dev->decoder; 320 321 /* 322 * Default input is tuner and default input_type 323 * is AU0828_VMUX_TELEVISION. 324 * FIXME: 325 * There is a problem when s_input is called to 326 * change the default input. s_input will try to 327 * enable_source before attempting to change the 328 * input on the device, and will end up enabling 329 * default source which is tuner. 330 * 331 * Additional logic is necessary in au0828 332 * to detect that the input has changed and 333 * enable the right source. 334 */ 335 336 if (dev->input_type == AU0828_VMUX_TELEVISION) 337 find_source = dev->tuner; 338 else if (dev->input_type == AU0828_VMUX_SVIDEO || 339 dev->input_type == AU0828_VMUX_COMPOSITE) 340 find_source = &dev->input_ent[dev->input_type]; 341 else { 342 /* unknown input - let user select input */ 343 ret = 0; 344 goto end; 345 } 346 } 347 348 /* Is an active link between sink and source */ 349 if (dev->active_link) { 350 /* 351 * If DVB is using the tuner and calling entity is 352 * audio/video, the following check will be false, 353 * since sink is different. Result is Busy. 354 */ 355 if (dev->active_link->sink->entity == sink && 356 dev->active_link->source->entity == find_source) { 357 /* 358 * Either ALSA or Video own tuner. sink is 359 * the same for both. Prevent Video stepping 360 * on ALSA when ALSA owns the source. 361 */ 362 if (dev->active_link_owner != entity && 363 dev->active_link_owner->function == 364 MEDIA_ENT_F_AUDIO_CAPTURE) { 365 pr_debug("ALSA has the tuner\n"); 366 ret = -EBUSY; 367 goto end; 368 } 369 ret = 0; 370 goto end; 371 } else { 372 ret = -EBUSY; 373 goto end; 374 } 375 } 376 377 list_for_each_entry(link, &sink->links, list) { 378 /* Check sink, and source */ 379 if (link->sink->entity == sink && 380 link->source->entity == find_source) { 381 found_link = link; 382 break; 383 } 384 } 385 386 if (!found_link) { 387 ret = -ENODEV; 388 goto end; 389 } 390 391 /* activate link between source and sink and start pipeline */ 392 source = found_link->source->entity; 393 ret = __media_entity_setup_link(found_link, MEDIA_LNK_FL_ENABLED); 394 if (ret) { 395 pr_err("Activate tuner link %s->%s. Error %d\n", 396 source->name, sink->name, ret); 397 goto end; 398 } 399 400 ret = __media_entity_pipeline_start(entity, pipe); 401 if (ret) { 402 pr_err("Start Pipeline: %s->%s Error %d\n", 403 source->name, entity->name, ret); 404 ret = __media_entity_setup_link(found_link, 0); 405 pr_err("Deactivate link Error %d\n", ret); 406 goto end; 407 } 408 /* 409 * save active link and active link owner to avoid audio 410 * deactivating video owned link from disable_source and 411 * vice versa 412 */ 413 dev->active_link = found_link; 414 dev->active_link_owner = entity; 415 dev->active_source = source; 416 dev->active_sink = sink; 417 418 pr_debug("Enabled Source: %s->%s->%s Ret %d\n", 419 dev->active_source->name, dev->active_sink->name, 420 dev->active_link_owner->name, ret); 421 end: 422 mutex_unlock(&mdev->graph_mutex); 423 pr_debug("au0828_enable_source() end %s %d %d\n", 424 entity->name, entity->function, ret); 425 return ret; 426 } 427 428 static void au0828_disable_source(struct media_entity *entity) 429 { 430 int ret = 0; 431 struct media_device *mdev = entity->graph_obj.mdev; 432 struct au0828_dev *dev; 433 434 if (!mdev) 435 return; 436 437 mutex_lock(&mdev->graph_mutex); 438 dev = mdev->source_priv; 439 440 if (!dev->active_link) { 441 ret = -ENODEV; 442 goto end; 443 } 444 445 /* link is active - stop pipeline from source (tuner) */ 446 if (dev->active_link->sink->entity == dev->active_sink && 447 dev->active_link->source->entity == dev->active_source) { 448 /* 449 * prevent video from deactivating link when audio 450 * has active pipeline 451 */ 452 if (dev->active_link_owner != entity) 453 goto end; 454 __media_entity_pipeline_stop(entity); 455 ret = __media_entity_setup_link(dev->active_link, 0); 456 if (ret) 457 pr_err("Deactivate link Error %d\n", ret); 458 459 pr_debug("Disabled Source: %s->%s->%s Ret %d\n", 460 dev->active_source->name, dev->active_sink->name, 461 dev->active_link_owner->name, ret); 462 463 dev->active_link = NULL; 464 dev->active_link_owner = NULL; 465 dev->active_source = NULL; 466 dev->active_sink = NULL; 467 } 468 469 end: 470 mutex_unlock(&mdev->graph_mutex); 471 } 472 #endif 473 474 static int au0828_media_device_register(struct au0828_dev *dev, 475 struct usb_device *udev) 476 { 477 #ifdef CONFIG_MEDIA_CONTROLLER 478 int ret; 479 struct media_entity *entity, *demod = NULL; 480 struct media_link *link; 481 482 if (!dev->media_dev) 483 return 0; 484 485 if (!media_devnode_is_registered(&dev->media_dev->devnode)) { 486 487 /* register media device */ 488 ret = media_device_register(dev->media_dev); 489 if (ret) { 490 dev_err(&udev->dev, 491 "Media Device Register Error: %d\n", ret); 492 return ret; 493 } 494 } else { 495 /* 496 * Call au0828_media_graph_notify() to connect 497 * audio graph to our graph. In this case, audio 498 * driver registered the device and there is no 499 * entity_notify to be called when new entities 500 * are added. Invoke it now. 501 */ 502 au0828_media_graph_notify(NULL, (void *) dev); 503 } 504 505 /* 506 * Find tuner, decoder and demod. 507 * 508 * The tuner and decoder should be cached, as they'll be used by 509 * au0828_enable_source. 510 * 511 * It also needs to disable the link between tuner and 512 * decoder/demod, to avoid disable step when tuner is requested 513 * by video or audio. Note that this step can't be done until dvb 514 * graph is created during dvb register. 515 */ 516 media_device_for_each_entity(entity, dev->media_dev) { 517 switch (entity->function) { 518 case MEDIA_ENT_F_TUNER: 519 dev->tuner = entity; 520 break; 521 case MEDIA_ENT_F_ATV_DECODER: 522 dev->decoder = entity; 523 break; 524 case MEDIA_ENT_F_DTV_DEMOD: 525 demod = entity; 526 break; 527 } 528 } 529 530 /* Disable link between tuner->demod and/or tuner->decoder */ 531 if (dev->tuner) { 532 list_for_each_entry(link, &dev->tuner->links, list) { 533 if (demod && link->sink->entity == demod) 534 media_entity_setup_link(link, 0); 535 if (dev->decoder && link->sink->entity == dev->decoder) 536 media_entity_setup_link(link, 0); 537 } 538 } 539 540 /* register entity_notify callback */ 541 dev->entity_notify.notify_data = (void *) dev; 542 dev->entity_notify.notify = (void *) au0828_media_graph_notify; 543 ret = media_device_register_entity_notify(dev->media_dev, 544 &dev->entity_notify); 545 if (ret) { 546 dev_err(&udev->dev, 547 "Media Device register entity_notify Error: %d\n", 548 ret); 549 return ret; 550 } 551 /* set enable_source */ 552 dev->media_dev->source_priv = (void *) dev; 553 dev->media_dev->enable_source = au0828_enable_source; 554 dev->media_dev->disable_source = au0828_disable_source; 555 #endif 556 return 0; 557 } 558 559 static int au0828_usb_probe(struct usb_interface *interface, 560 const struct usb_device_id *id) 561 { 562 int ifnum; 563 int retval = 0; 564 565 struct au0828_dev *dev; 566 struct usb_device *usbdev = interface_to_usbdev(interface); 567 568 ifnum = interface->altsetting->desc.bInterfaceNumber; 569 570 if (ifnum != 0) 571 return -ENODEV; 572 573 dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__, 574 le16_to_cpu(usbdev->descriptor.idVendor), 575 le16_to_cpu(usbdev->descriptor.idProduct), 576 ifnum); 577 578 /* 579 * Make sure we have 480 Mbps of bandwidth, otherwise things like 580 * video stream wouldn't likely work, since 12 Mbps is generally 581 * not enough even for most Digital TV streams. 582 */ 583 if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) { 584 pr_err("au0828: Device initialization failed.\n"); 585 pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n"); 586 return -ENODEV; 587 } 588 589 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 590 if (dev == NULL) { 591 pr_err("%s() Unable to allocate memory\n", __func__); 592 return -ENOMEM; 593 } 594 595 mutex_init(&dev->lock); 596 mutex_lock(&dev->lock); 597 mutex_init(&dev->mutex); 598 mutex_init(&dev->dvb.lock); 599 dev->usbdev = usbdev; 600 dev->boardnr = id->driver_info; 601 dev->board = au0828_boards[dev->boardnr]; 602 603 /* Initialize the media controller */ 604 retval = au0828_media_device_init(dev, usbdev); 605 if (retval) { 606 pr_err("%s() au0828_media_device_init failed\n", 607 __func__); 608 mutex_unlock(&dev->lock); 609 kfree(dev); 610 return retval; 611 } 612 613 retval = au0828_v4l2_device_register(interface, dev); 614 if (retval) { 615 au0828_usb_v4l2_media_release(dev); 616 mutex_unlock(&dev->lock); 617 kfree(dev); 618 return retval; 619 } 620 621 /* Power Up the bridge */ 622 au0828_write(dev, REG_600, 1 << 4); 623 624 /* Bring up the GPIO's and supporting devices */ 625 au0828_gpio_setup(dev); 626 627 /* I2C */ 628 au0828_i2c_register(dev); 629 630 /* Setup */ 631 au0828_card_setup(dev); 632 633 /* Analog TV */ 634 retval = au0828_analog_register(dev, interface); 635 if (retval) { 636 pr_err("%s() au0282_dev_register failed to register on V4L2\n", 637 __func__); 638 goto done; 639 } 640 641 /* Digital TV */ 642 retval = au0828_dvb_register(dev); 643 if (retval) 644 pr_err("%s() au0282_dev_register failed\n", 645 __func__); 646 647 /* Remote controller */ 648 au0828_rc_register(dev); 649 650 /* 651 * Store the pointer to the au0828_dev so it can be accessed in 652 * au0828_usb_disconnect 653 */ 654 usb_set_intfdata(interface, dev); 655 656 pr_info("Registered device AU0828 [%s]\n", 657 dev->board.name == NULL ? "Unset" : dev->board.name); 658 659 mutex_unlock(&dev->lock); 660 661 retval = au0828_media_device_register(dev, usbdev); 662 663 done: 664 if (retval < 0) 665 au0828_usb_disconnect(interface); 666 667 return retval; 668 } 669 670 static int au0828_suspend(struct usb_interface *interface, 671 pm_message_t message) 672 { 673 struct au0828_dev *dev = usb_get_intfdata(interface); 674 675 if (!dev) 676 return 0; 677 678 pr_info("Suspend\n"); 679 680 au0828_rc_suspend(dev); 681 au0828_v4l2_suspend(dev); 682 au0828_dvb_suspend(dev); 683 684 /* FIXME: should suspend also ATV/DTV */ 685 686 return 0; 687 } 688 689 static int au0828_resume(struct usb_interface *interface) 690 { 691 struct au0828_dev *dev = usb_get_intfdata(interface); 692 if (!dev) 693 return 0; 694 695 pr_info("Resume\n"); 696 697 /* Power Up the bridge */ 698 au0828_write(dev, REG_600, 1 << 4); 699 700 /* Bring up the GPIO's and supporting devices */ 701 au0828_gpio_setup(dev); 702 703 au0828_rc_resume(dev); 704 au0828_v4l2_resume(dev); 705 au0828_dvb_resume(dev); 706 707 /* FIXME: should resume also ATV/DTV */ 708 709 return 0; 710 } 711 712 static struct usb_driver au0828_usb_driver = { 713 .name = KBUILD_MODNAME, 714 .probe = au0828_usb_probe, 715 .disconnect = au0828_usb_disconnect, 716 .id_table = au0828_usb_id_table, 717 .suspend = au0828_suspend, 718 .resume = au0828_resume, 719 .reset_resume = au0828_resume, 720 }; 721 722 static int __init au0828_init(void) 723 { 724 int ret; 725 726 if (au0828_debug & 1) 727 pr_info("%s() Debugging is enabled\n", __func__); 728 729 if (au0828_debug & 2) 730 pr_info("%s() USB Debugging is enabled\n", __func__); 731 732 if (au0828_debug & 4) 733 pr_info("%s() I2C Debugging is enabled\n", __func__); 734 735 if (au0828_debug & 8) 736 pr_info("%s() Bridge Debugging is enabled\n", 737 __func__); 738 739 if (au0828_debug & 16) 740 pr_info("%s() IR Debugging is enabled\n", 741 __func__); 742 743 pr_info("au0828 driver loaded\n"); 744 745 ret = usb_register(&au0828_usb_driver); 746 if (ret) 747 pr_err("usb_register failed, error = %d\n", ret); 748 749 return ret; 750 } 751 752 static void __exit au0828_exit(void) 753 { 754 usb_deregister(&au0828_usb_driver); 755 } 756 757 module_init(au0828_init); 758 module_exit(au0828_exit); 759 760 MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products"); 761 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>"); 762 MODULE_LICENSE("GPL"); 763 MODULE_VERSION("0.0.3"); 764