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