linux/drivers/usb/core/hcd-pci.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * (C) Copyright David Brownell 2000-2002
   4 */
   5
   6#include <linux/kernel.h>
   7#include <linux/module.h>
   8#include <linux/pci.h>
   9#include <linux/usb.h>
  10#include <linux/usb/hcd.h>
  11
  12#include <asm/io.h>
  13#include <asm/irq.h>
  14
  15#ifdef CONFIG_PPC_PMAC
  16#include <asm/machdep.h>
  17#include <asm/pmac_feature.h>
  18#include <asm/prom.h>
  19#endif
  20
  21#include "usb.h"
  22
  23
  24/* PCI-based HCs are common, but plenty of non-PCI HCs are used too */
  25
  26/*
  27 * Coordinate handoffs between EHCI and companion controllers
  28 * during EHCI probing and system resume.
  29 */
  30
  31static DECLARE_RWSEM(companions_rwsem);
  32
  33#define CL_UHCI         PCI_CLASS_SERIAL_USB_UHCI
  34#define CL_OHCI         PCI_CLASS_SERIAL_USB_OHCI
  35#define CL_EHCI         PCI_CLASS_SERIAL_USB_EHCI
  36
  37static inline int is_ohci_or_uhci(struct pci_dev *pdev)
  38{
  39        return pdev->class == CL_OHCI || pdev->class == CL_UHCI;
  40}
  41
  42typedef void (*companion_fn)(struct pci_dev *pdev, struct usb_hcd *hcd,
  43                struct pci_dev *companion, struct usb_hcd *companion_hcd);
  44
  45/* Iterate over PCI devices in the same slot as pdev and call fn for each */
  46static void for_each_companion(struct pci_dev *pdev, struct usb_hcd *hcd,
  47                companion_fn fn)
  48{
  49        struct pci_dev          *companion;
  50        struct usb_hcd          *companion_hcd;
  51        unsigned int            slot = PCI_SLOT(pdev->devfn);
  52
  53        /*
  54         * Iterate through other PCI functions in the same slot.
  55         * If the function's drvdata isn't set then it isn't bound to
  56         * a USB host controller driver, so skip it.
  57         */
  58        companion = NULL;
  59        for_each_pci_dev(companion) {
  60                if (companion->bus != pdev->bus ||
  61                                PCI_SLOT(companion->devfn) != slot)
  62                        continue;
  63
  64                /*
  65                 * Companion device should be either UHCI,OHCI or EHCI host
  66                 * controller, otherwise skip.
  67                 */
  68                if (companion->class != CL_UHCI && companion->class != CL_OHCI &&
  69                                companion->class != CL_EHCI)
  70                        continue;
  71
  72                companion_hcd = pci_get_drvdata(companion);
  73                if (!companion_hcd || !companion_hcd->self.root_hub)
  74                        continue;
  75                fn(pdev, hcd, companion, companion_hcd);
  76        }
  77}
  78
  79/*
  80 * We're about to add an EHCI controller, which will unceremoniously grab
  81 * all the port connections away from its companions.  To prevent annoying
  82 * error messages, lock the companion's root hub and gracefully unconfigure
  83 * it beforehand.  Leave it locked until the EHCI controller is all set.
  84 */
  85static void ehci_pre_add(struct pci_dev *pdev, struct usb_hcd *hcd,
  86                struct pci_dev *companion, struct usb_hcd *companion_hcd)
  87{
  88        struct usb_device *udev;
  89
  90        if (is_ohci_or_uhci(companion)) {
  91                udev = companion_hcd->self.root_hub;
  92                usb_lock_device(udev);
  93                usb_set_configuration(udev, 0);
  94        }
  95}
  96
  97/*
  98 * Adding the EHCI controller has either succeeded or failed.  Set the
  99 * companion pointer accordingly, and in either case, reconfigure and
 100 * unlock the root hub.
 101 */
 102static void ehci_post_add(struct pci_dev *pdev, struct usb_hcd *hcd,
 103                struct pci_dev *companion, struct usb_hcd *companion_hcd)
 104{
 105        struct usb_device *udev;
 106
 107        if (is_ohci_or_uhci(companion)) {
 108                if (dev_get_drvdata(&pdev->dev)) {      /* Succeeded */
 109                        dev_dbg(&pdev->dev, "HS companion for %s\n",
 110                                        dev_name(&companion->dev));
 111                        companion_hcd->self.hs_companion = &hcd->self;
 112                }
 113                udev = companion_hcd->self.root_hub;
 114                usb_set_configuration(udev, 1);
 115                usb_unlock_device(udev);
 116        }
 117}
 118
 119/*
 120 * We just added a non-EHCI controller.  Find the EHCI controller to
 121 * which it is a companion, and store a pointer to the bus structure.
 122 */
 123static void non_ehci_add(struct pci_dev *pdev, struct usb_hcd *hcd,
 124                struct pci_dev *companion, struct usb_hcd *companion_hcd)
 125{
 126        if (is_ohci_or_uhci(pdev) && companion->class == CL_EHCI) {
 127                dev_dbg(&pdev->dev, "FS/LS companion for %s\n",
 128                                dev_name(&companion->dev));
 129                hcd->self.hs_companion = &companion_hcd->self;
 130        }
 131}
 132
 133/* We are removing an EHCI controller.  Clear the companions' pointers. */
 134static void ehci_remove(struct pci_dev *pdev, struct usb_hcd *hcd,
 135                struct pci_dev *companion, struct usb_hcd *companion_hcd)
 136{
 137        if (is_ohci_or_uhci(companion))
 138                companion_hcd->self.hs_companion = NULL;
 139}
 140
 141#ifdef  CONFIG_PM
 142
 143/* An EHCI controller must wait for its companions before resuming. */
 144static void ehci_wait_for_companions(struct pci_dev *pdev, struct usb_hcd *hcd,
 145                struct pci_dev *companion, struct usb_hcd *companion_hcd)
 146{
 147        if (is_ohci_or_uhci(companion))
 148                device_pm_wait_for_dev(&pdev->dev, &companion->dev);
 149}
 150
 151#endif  /* CONFIG_PM */
 152
 153/*-------------------------------------------------------------------------*/
 154
 155/* configure so an HC device and id are always provided */
 156/* always called with process context; sleeping is OK */
 157
 158/**
 159 * usb_hcd_pci_probe - initialize PCI-based HCDs
 160 * @dev: USB Host Controller being probed
 161 * @id: pci hotplug id connecting controller to HCD framework
 162 * Context: !in_interrupt()
 163 *
 164 * Allocates basic PCI resources for this USB host controller, and
 165 * then invokes the start() method for the HCD associated with it
 166 * through the hotplug entry's driver_data.
 167 *
 168 * Store this function in the HCD's struct pci_driver as probe().
 169 *
 170 * Return: 0 if successful.
 171 */
 172int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 173{
 174        struct hc_driver        *driver;
 175        struct usb_hcd          *hcd;
 176        int                     retval;
 177        int                     hcd_irq = 0;
 178
 179        if (usb_disabled())
 180                return -ENODEV;
 181
 182        if (!id)
 183                return -EINVAL;
 184        driver = (struct hc_driver *)id->driver_data;
 185        if (!driver)
 186                return -EINVAL;
 187
 188        if (pci_enable_device(dev) < 0)
 189                return -ENODEV;
 190
 191        /*
 192         * The xHCI driver has its own irq management
 193         * make sure irq setup is not touched for xhci in generic hcd code
 194         */
 195        if ((driver->flags & HCD_MASK) < HCD_USB3) {
 196                if (!dev->irq) {
 197                        dev_err(&dev->dev,
 198                        "Found HC with no IRQ. Check BIOS/PCI %s setup!\n",
 199                                pci_name(dev));
 200                        retval = -ENODEV;
 201                        goto disable_pci;
 202                }
 203                hcd_irq = dev->irq;
 204        }
 205
 206        hcd = usb_create_hcd(driver, &dev->dev, pci_name(dev));
 207        if (!hcd) {
 208                retval = -ENOMEM;
 209                goto disable_pci;
 210        }
 211
 212        hcd->amd_resume_bug = (usb_hcd_amd_remote_wakeup_quirk(dev) &&
 213                        driver->flags & (HCD_USB11 | HCD_USB3)) ? 1 : 0;
 214
 215        if (driver->flags & HCD_MEMORY) {
 216                /* EHCI, OHCI */
 217                hcd->rsrc_start = pci_resource_start(dev, 0);
 218                hcd->rsrc_len = pci_resource_len(dev, 0);
 219                if (!devm_request_mem_region(&dev->dev, hcd->rsrc_start,
 220                                hcd->rsrc_len, driver->description)) {
 221                        dev_dbg(&dev->dev, "controller already in use\n");
 222                        retval = -EBUSY;
 223                        goto put_hcd;
 224                }
 225                hcd->regs = devm_ioremap_nocache(&dev->dev, hcd->rsrc_start,
 226                                hcd->rsrc_len);
 227                if (hcd->regs == NULL) {
 228                        dev_dbg(&dev->dev, "error mapping memory\n");
 229                        retval = -EFAULT;
 230                        goto put_hcd;
 231                }
 232
 233        } else {
 234                /* UHCI */
 235                int     region;
 236
 237                for (region = 0; region < PCI_ROM_RESOURCE; region++) {
 238                        if (!(pci_resource_flags(dev, region) &
 239                                        IORESOURCE_IO))
 240                                continue;
 241
 242                        hcd->rsrc_start = pci_resource_start(dev, region);
 243                        hcd->rsrc_len = pci_resource_len(dev, region);
 244                        if (devm_request_region(&dev->dev, hcd->rsrc_start,
 245                                        hcd->rsrc_len, driver->description))
 246                                break;
 247                }
 248                if (region == PCI_ROM_RESOURCE) {
 249                        dev_dbg(&dev->dev, "no i/o regions available\n");
 250                        retval = -EBUSY;
 251                        goto put_hcd;
 252                }
 253        }
 254
 255        pci_set_master(dev);
 256
 257        /* Note: dev_set_drvdata must be called while holding the rwsem */
 258        if (dev->class == CL_EHCI) {
 259                down_write(&companions_rwsem);
 260                dev_set_drvdata(&dev->dev, hcd);
 261                for_each_companion(dev, hcd, ehci_pre_add);
 262                retval = usb_add_hcd(hcd, hcd_irq, IRQF_SHARED);
 263                if (retval != 0)
 264                        dev_set_drvdata(&dev->dev, NULL);
 265                for_each_companion(dev, hcd, ehci_post_add);
 266                up_write(&companions_rwsem);
 267        } else {
 268                down_read(&companions_rwsem);
 269                dev_set_drvdata(&dev->dev, hcd);
 270                retval = usb_add_hcd(hcd, hcd_irq, IRQF_SHARED);
 271                if (retval != 0)
 272                        dev_set_drvdata(&dev->dev, NULL);
 273                else
 274                        for_each_companion(dev, hcd, non_ehci_add);
 275                up_read(&companions_rwsem);
 276        }
 277
 278        if (retval != 0)
 279                goto put_hcd;
 280        device_wakeup_enable(hcd->self.controller);
 281
 282        if (pci_dev_run_wake(dev))
 283                pm_runtime_put_noidle(&dev->dev);
 284        return retval;
 285
 286put_hcd:
 287        usb_put_hcd(hcd);
 288disable_pci:
 289        pci_disable_device(dev);
 290        dev_err(&dev->dev, "init %s fail, %d\n", pci_name(dev), retval);
 291        return retval;
 292}
 293EXPORT_SYMBOL_GPL(usb_hcd_pci_probe);
 294
 295
 296/* may be called without controller electrically present */
 297/* may be called with controller, bus, and devices active */
 298
 299/**
 300 * usb_hcd_pci_remove - shutdown processing for PCI-based HCDs
 301 * @dev: USB Host Controller being removed
 302 * Context: !in_interrupt()
 303 *
 304 * Reverses the effect of usb_hcd_pci_probe(), first invoking
 305 * the HCD's stop() method.  It is always called from a thread
 306 * context, normally "rmmod", "apmd", or something similar.
 307 *
 308 * Store this function in the HCD's struct pci_driver as remove().
 309 */
 310void usb_hcd_pci_remove(struct pci_dev *dev)
 311{
 312        struct usb_hcd          *hcd;
 313
 314        hcd = pci_get_drvdata(dev);
 315        if (!hcd)
 316                return;
 317
 318        if (pci_dev_run_wake(dev))
 319                pm_runtime_get_noresume(&dev->dev);
 320
 321        /* Fake an interrupt request in order to give the driver a chance
 322         * to test whether the controller hardware has been removed (e.g.,
 323         * cardbus physical eject).
 324         */
 325        local_irq_disable();
 326        usb_hcd_irq(0, hcd);
 327        local_irq_enable();
 328
 329        /* Note: dev_set_drvdata must be called while holding the rwsem */
 330        if (dev->class == CL_EHCI) {
 331                down_write(&companions_rwsem);
 332                for_each_companion(dev, hcd, ehci_remove);
 333                usb_remove_hcd(hcd);
 334                dev_set_drvdata(&dev->dev, NULL);
 335                up_write(&companions_rwsem);
 336        } else {
 337                /* Not EHCI; just clear the companion pointer */
 338                down_read(&companions_rwsem);
 339                hcd->self.hs_companion = NULL;
 340                usb_remove_hcd(hcd);
 341                dev_set_drvdata(&dev->dev, NULL);
 342                up_read(&companions_rwsem);
 343        }
 344        usb_put_hcd(hcd);
 345        pci_disable_device(dev);
 346}
 347EXPORT_SYMBOL_GPL(usb_hcd_pci_remove);
 348
 349/**
 350 * usb_hcd_pci_shutdown - shutdown host controller
 351 * @dev: USB Host Controller being shutdown
 352 */
 353void usb_hcd_pci_shutdown(struct pci_dev *dev)
 354{
 355        struct usb_hcd          *hcd;
 356
 357        hcd = pci_get_drvdata(dev);
 358        if (!hcd)
 359                return;
 360
 361        if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) &&
 362                        hcd->driver->shutdown) {
 363                hcd->driver->shutdown(hcd);
 364                if (usb_hcd_is_primary_hcd(hcd) && hcd->irq > 0)
 365                        free_irq(hcd->irq, hcd);
 366                pci_disable_device(dev);
 367        }
 368}
 369EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown);
 370
 371#ifdef  CONFIG_PM
 372
 373#ifdef  CONFIG_PPC_PMAC
 374static void powermac_set_asic(struct pci_dev *pci_dev, int enable)
 375{
 376        /* Enanble or disable ASIC clocks for USB */
 377        if (machine_is(powermac)) {
 378                struct device_node      *of_node;
 379
 380                of_node = pci_device_to_OF_node(pci_dev);
 381                if (of_node)
 382                        pmac_call_feature(PMAC_FTR_USB_ENABLE,
 383                                        of_node, 0, enable);
 384        }
 385}
 386
 387#else
 388
 389static inline void powermac_set_asic(struct pci_dev *pci_dev, int enable)
 390{}
 391
 392#endif  /* CONFIG_PPC_PMAC */
 393
 394static int check_root_hub_suspended(struct device *dev)
 395{
 396        struct usb_hcd          *hcd = dev_get_drvdata(dev);
 397
 398        if (HCD_RH_RUNNING(hcd)) {
 399                dev_warn(dev, "Root hub is not suspended\n");
 400                return -EBUSY;
 401        }
 402        if (hcd->shared_hcd) {
 403                hcd = hcd->shared_hcd;
 404                if (HCD_RH_RUNNING(hcd)) {
 405                        dev_warn(dev, "Secondary root hub is not suspended\n");
 406                        return -EBUSY;
 407                }
 408        }
 409        return 0;
 410}
 411
 412static int suspend_common(struct device *dev, bool do_wakeup)
 413{
 414        struct pci_dev          *pci_dev = to_pci_dev(dev);
 415        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
 416        int                     retval;
 417
 418        /* Root hub suspend should have stopped all downstream traffic,
 419         * and all bus master traffic.  And done so for both the interface
 420         * and the stub usb_device (which we check here).  But maybe it
 421         * didn't; writing sysfs power/state files ignores such rules...
 422         */
 423        retval = check_root_hub_suspended(dev);
 424        if (retval)
 425                return retval;
 426
 427        if (hcd->driver->pci_suspend && !HCD_DEAD(hcd)) {
 428                /* Optimization: Don't suspend if a root-hub wakeup is
 429                 * pending and it would cause the HCD to wake up anyway.
 430                 */
 431                if (do_wakeup && HCD_WAKEUP_PENDING(hcd))
 432                        return -EBUSY;
 433                if (do_wakeup && hcd->shared_hcd &&
 434                                HCD_WAKEUP_PENDING(hcd->shared_hcd))
 435                        return -EBUSY;
 436                retval = hcd->driver->pci_suspend(hcd, do_wakeup);
 437                suspend_report_result(hcd->driver->pci_suspend, retval);
 438
 439                /* Check again in case wakeup raced with pci_suspend */
 440                if ((retval == 0 && do_wakeup && HCD_WAKEUP_PENDING(hcd)) ||
 441                                (retval == 0 && do_wakeup && hcd->shared_hcd &&
 442                                 HCD_WAKEUP_PENDING(hcd->shared_hcd))) {
 443                        if (hcd->driver->pci_resume)
 444                                hcd->driver->pci_resume(hcd, false);
 445                        retval = -EBUSY;
 446                }
 447                if (retval)
 448                        return retval;
 449        }
 450
 451        /* If MSI-X is enabled, the driver will have synchronized all vectors
 452         * in pci_suspend(). If MSI or legacy PCI is enabled, that will be
 453         * synchronized here.
 454         */
 455        if (!hcd->msix_enabled)
 456                synchronize_irq(pci_dev->irq);
 457
 458        /* Downstream ports from this root hub should already be quiesced, so
 459         * there will be no DMA activity.  Now we can shut down the upstream
 460         * link (except maybe for PME# resume signaling).  We'll enter a
 461         * low power state during suspend_noirq, if the hardware allows.
 462         */
 463        pci_disable_device(pci_dev);
 464        return retval;
 465}
 466
 467static int resume_common(struct device *dev, int event)
 468{
 469        struct pci_dev          *pci_dev = to_pci_dev(dev);
 470        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
 471        int                     retval;
 472
 473        if (HCD_RH_RUNNING(hcd) ||
 474                        (hcd->shared_hcd &&
 475                         HCD_RH_RUNNING(hcd->shared_hcd))) {
 476                dev_dbg(dev, "can't resume, not suspended!\n");
 477                return 0;
 478        }
 479
 480        retval = pci_enable_device(pci_dev);
 481        if (retval < 0) {
 482                dev_err(dev, "can't re-enable after resume, %d!\n", retval);
 483                return retval;
 484        }
 485
 486        pci_set_master(pci_dev);
 487
 488        if (hcd->driver->pci_resume && !HCD_DEAD(hcd)) {
 489
 490                /*
 491                 * Only EHCI controllers have to wait for their companions.
 492                 * No locking is needed because PCI controller drivers do not
 493                 * get unbound during system resume.
 494                 */
 495                if (pci_dev->class == CL_EHCI && event != PM_EVENT_AUTO_RESUME)
 496                        for_each_companion(pci_dev, hcd,
 497                                        ehci_wait_for_companions);
 498
 499                retval = hcd->driver->pci_resume(hcd,
 500                                event == PM_EVENT_RESTORE);
 501                if (retval) {
 502                        dev_err(dev, "PCI post-resume error %d!\n", retval);
 503                        usb_hc_died(hcd);
 504                }
 505        }
 506        return retval;
 507}
 508
 509#ifdef  CONFIG_PM_SLEEP
 510
 511static int hcd_pci_suspend(struct device *dev)
 512{
 513        return suspend_common(dev, device_may_wakeup(dev));
 514}
 515
 516static int hcd_pci_suspend_noirq(struct device *dev)
 517{
 518        struct pci_dev          *pci_dev = to_pci_dev(dev);
 519        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
 520        int                     retval;
 521
 522        retval = check_root_hub_suspended(dev);
 523        if (retval)
 524                return retval;
 525
 526        pci_save_state(pci_dev);
 527
 528        /* If the root hub is dead rather than suspended, disallow remote
 529         * wakeup.  usb_hc_died() should ensure that both hosts are marked as
 530         * dying, so we only need to check the primary roothub.
 531         */
 532        if (HCD_DEAD(hcd))
 533                device_set_wakeup_enable(dev, 0);
 534        dev_dbg(dev, "wakeup: %d\n", device_may_wakeup(dev));
 535
 536        /* Possibly enable remote wakeup,
 537         * choose the appropriate low-power state, and go to that state.
 538         */
 539        retval = pci_prepare_to_sleep(pci_dev);
 540        if (retval == -EIO) {           /* Low-power not supported */
 541                dev_dbg(dev, "--> PCI D0 legacy\n");
 542                retval = 0;
 543        } else if (retval == 0) {
 544                dev_dbg(dev, "--> PCI %s\n",
 545                                pci_power_name(pci_dev->current_state));
 546        } else {
 547                suspend_report_result(pci_prepare_to_sleep, retval);
 548                return retval;
 549        }
 550
 551        powermac_set_asic(pci_dev, 0);
 552        return retval;
 553}
 554
 555static int hcd_pci_resume_noirq(struct device *dev)
 556{
 557        powermac_set_asic(to_pci_dev(dev), 1);
 558        return 0;
 559}
 560
 561static int hcd_pci_resume(struct device *dev)
 562{
 563        return resume_common(dev, PM_EVENT_RESUME);
 564}
 565
 566static int hcd_pci_restore(struct device *dev)
 567{
 568        return resume_common(dev, PM_EVENT_RESTORE);
 569}
 570
 571#else
 572
 573#define hcd_pci_suspend         NULL
 574#define hcd_pci_suspend_noirq   NULL
 575#define hcd_pci_resume_noirq    NULL
 576#define hcd_pci_resume          NULL
 577#define hcd_pci_restore         NULL
 578
 579#endif  /* CONFIG_PM_SLEEP */
 580
 581static int hcd_pci_runtime_suspend(struct device *dev)
 582{
 583        int     retval;
 584
 585        retval = suspend_common(dev, true);
 586        if (retval == 0)
 587                powermac_set_asic(to_pci_dev(dev), 0);
 588        dev_dbg(dev, "hcd_pci_runtime_suspend: %d\n", retval);
 589        return retval;
 590}
 591
 592static int hcd_pci_runtime_resume(struct device *dev)
 593{
 594        int     retval;
 595
 596        powermac_set_asic(to_pci_dev(dev), 1);
 597        retval = resume_common(dev, PM_EVENT_AUTO_RESUME);
 598        dev_dbg(dev, "hcd_pci_runtime_resume: %d\n", retval);
 599        return retval;
 600}
 601
 602const struct dev_pm_ops usb_hcd_pci_pm_ops = {
 603        .suspend        = hcd_pci_suspend,
 604        .suspend_noirq  = hcd_pci_suspend_noirq,
 605        .resume_noirq   = hcd_pci_resume_noirq,
 606        .resume         = hcd_pci_resume,
 607        .freeze         = check_root_hub_suspended,
 608        .freeze_noirq   = check_root_hub_suspended,
 609        .thaw_noirq     = NULL,
 610        .thaw           = NULL,
 611        .poweroff       = hcd_pci_suspend,
 612        .poweroff_noirq = hcd_pci_suspend_noirq,
 613        .restore_noirq  = hcd_pci_resume_noirq,
 614        .restore        = hcd_pci_restore,
 615        .runtime_suspend = hcd_pci_runtime_suspend,
 616        .runtime_resume = hcd_pci_runtime_resume,
 617};
 618EXPORT_SYMBOL_GPL(usb_hcd_pci_pm_ops);
 619
 620#endif  /* CONFIG_PM */
 621