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 (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
 220                                driver->description)) {
 221                        dev_dbg(&dev->dev, "controller already in use\n");
 222                        retval = -EBUSY;
 223                        goto put_hcd;
 224                }
 225                hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
 226                if (hcd->regs == NULL) {
 227                        dev_dbg(&dev->dev, "error mapping memory\n");
 228                        retval = -EFAULT;
 229                        goto release_mem_region;
 230                }
 231
 232        } else {
 233                /* UHCI */
 234                int     region;
 235
 236                for (region = 0; region < PCI_ROM_RESOURCE; region++) {
 237                        if (!(pci_resource_flags(dev, region) &
 238                                        IORESOURCE_IO))
 239                                continue;
 240
 241                        hcd->rsrc_start = pci_resource_start(dev, region);
 242                        hcd->rsrc_len = pci_resource_len(dev, region);
 243                        if (request_region(hcd->rsrc_start, hcd->rsrc_len,
 244                                        driver->description))
 245                                break;
 246                }
 247                if (region == PCI_ROM_RESOURCE) {
 248                        dev_dbg(&dev->dev, "no i/o regions available\n");
 249                        retval = -EBUSY;
 250                        goto put_hcd;
 251                }
 252        }
 253
 254        pci_set_master(dev);
 255
 256        /* Note: dev_set_drvdata must be called while holding the rwsem */
 257        if (dev->class == CL_EHCI) {
 258                down_write(&companions_rwsem);
 259                dev_set_drvdata(&dev->dev, hcd);
 260                for_each_companion(dev, hcd, ehci_pre_add);
 261                retval = usb_add_hcd(hcd, hcd_irq, IRQF_SHARED);
 262                if (retval != 0)
 263                        dev_set_drvdata(&dev->dev, NULL);
 264                for_each_companion(dev, hcd, ehci_post_add);
 265                up_write(&companions_rwsem);
 266        } else {
 267                down_read(&companions_rwsem);
 268                dev_set_drvdata(&dev->dev, hcd);
 269                retval = usb_add_hcd(hcd, hcd_irq, IRQF_SHARED);
 270                if (retval != 0)
 271                        dev_set_drvdata(&dev->dev, NULL);
 272                else
 273                        for_each_companion(dev, hcd, non_ehci_add);
 274                up_read(&companions_rwsem);
 275        }
 276
 277        if (retval != 0)
 278                goto unmap_registers;
 279        device_wakeup_enable(hcd->self.controller);
 280
 281        if (pci_dev_run_wake(dev))
 282                pm_runtime_put_noidle(&dev->dev);
 283        return retval;
 284
 285unmap_registers:
 286        if (driver->flags & HCD_MEMORY) {
 287                iounmap(hcd->regs);
 288release_mem_region:
 289                release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 290        } else
 291                release_region(hcd->rsrc_start, hcd->rsrc_len);
 292put_hcd:
 293        usb_put_hcd(hcd);
 294disable_pci:
 295        pci_disable_device(dev);
 296        dev_err(&dev->dev, "init %s fail, %d\n", pci_name(dev), retval);
 297        return retval;
 298}
 299EXPORT_SYMBOL_GPL(usb_hcd_pci_probe);
 300
 301
 302/* may be called without controller electrically present */
 303/* may be called with controller, bus, and devices active */
 304
 305/**
 306 * usb_hcd_pci_remove - shutdown processing for PCI-based HCDs
 307 * @dev: USB Host Controller being removed
 308 * Context: !in_interrupt()
 309 *
 310 * Reverses the effect of usb_hcd_pci_probe(), first invoking
 311 * the HCD's stop() method.  It is always called from a thread
 312 * context, normally "rmmod", "apmd", or something similar.
 313 *
 314 * Store this function in the HCD's struct pci_driver as remove().
 315 */
 316void usb_hcd_pci_remove(struct pci_dev *dev)
 317{
 318        struct usb_hcd          *hcd;
 319
 320        hcd = pci_get_drvdata(dev);
 321        if (!hcd)
 322                return;
 323
 324        if (pci_dev_run_wake(dev))
 325                pm_runtime_get_noresume(&dev->dev);
 326
 327        /* Fake an interrupt request in order to give the driver a chance
 328         * to test whether the controller hardware has been removed (e.g.,
 329         * cardbus physical eject).
 330         */
 331        local_irq_disable();
 332        usb_hcd_irq(0, hcd);
 333        local_irq_enable();
 334
 335        /* Note: dev_set_drvdata must be called while holding the rwsem */
 336        if (dev->class == CL_EHCI) {
 337                down_write(&companions_rwsem);
 338                for_each_companion(dev, hcd, ehci_remove);
 339                usb_remove_hcd(hcd);
 340                dev_set_drvdata(&dev->dev, NULL);
 341                up_write(&companions_rwsem);
 342        } else {
 343                /* Not EHCI; just clear the companion pointer */
 344                down_read(&companions_rwsem);
 345                hcd->self.hs_companion = NULL;
 346                usb_remove_hcd(hcd);
 347                dev_set_drvdata(&dev->dev, NULL);
 348                up_read(&companions_rwsem);
 349        }
 350
 351        if (hcd->driver->flags & HCD_MEMORY) {
 352                iounmap(hcd->regs);
 353                release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 354        } else {
 355                release_region(hcd->rsrc_start, hcd->rsrc_len);
 356        }
 357
 358        usb_put_hcd(hcd);
 359        pci_disable_device(dev);
 360}
 361EXPORT_SYMBOL_GPL(usb_hcd_pci_remove);
 362
 363/**
 364 * usb_hcd_pci_shutdown - shutdown host controller
 365 * @dev: USB Host Controller being shutdown
 366 */
 367void usb_hcd_pci_shutdown(struct pci_dev *dev)
 368{
 369        struct usb_hcd          *hcd;
 370
 371        hcd = pci_get_drvdata(dev);
 372        if (!hcd)
 373                return;
 374
 375        if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) &&
 376                        hcd->driver->shutdown) {
 377                hcd->driver->shutdown(hcd);
 378                if (usb_hcd_is_primary_hcd(hcd) && hcd->irq > 0)
 379                        free_irq(hcd->irq, hcd);
 380                pci_disable_device(dev);
 381        }
 382}
 383EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown);
 384
 385#ifdef  CONFIG_PM
 386
 387#ifdef  CONFIG_PPC_PMAC
 388static void powermac_set_asic(struct pci_dev *pci_dev, int enable)
 389{
 390        /* Enanble or disable ASIC clocks for USB */
 391        if (machine_is(powermac)) {
 392                struct device_node      *of_node;
 393
 394                of_node = pci_device_to_OF_node(pci_dev);
 395                if (of_node)
 396                        pmac_call_feature(PMAC_FTR_USB_ENABLE,
 397                                        of_node, 0, enable);
 398        }
 399}
 400
 401#else
 402
 403static inline void powermac_set_asic(struct pci_dev *pci_dev, int enable)
 404{}
 405
 406#endif  /* CONFIG_PPC_PMAC */
 407
 408static int check_root_hub_suspended(struct device *dev)
 409{
 410        struct pci_dev          *pci_dev = to_pci_dev(dev);
 411        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
 412
 413        if (HCD_RH_RUNNING(hcd)) {
 414                dev_warn(dev, "Root hub is not suspended\n");
 415                return -EBUSY;
 416        }
 417        if (hcd->shared_hcd) {
 418                hcd = hcd->shared_hcd;
 419                if (HCD_RH_RUNNING(hcd)) {
 420                        dev_warn(dev, "Secondary root hub is not suspended\n");
 421                        return -EBUSY;
 422                }
 423        }
 424        return 0;
 425}
 426
 427static int suspend_common(struct device *dev, bool do_wakeup)
 428{
 429        struct pci_dev          *pci_dev = to_pci_dev(dev);
 430        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
 431        int                     retval;
 432
 433        /* Root hub suspend should have stopped all downstream traffic,
 434         * and all bus master traffic.  And done so for both the interface
 435         * and the stub usb_device (which we check here).  But maybe it
 436         * didn't; writing sysfs power/state files ignores such rules...
 437         */
 438        retval = check_root_hub_suspended(dev);
 439        if (retval)
 440                return retval;
 441
 442        if (hcd->driver->pci_suspend && !HCD_DEAD(hcd)) {
 443                /* Optimization: Don't suspend if a root-hub wakeup is
 444                 * pending and it would cause the HCD to wake up anyway.
 445                 */
 446                if (do_wakeup && HCD_WAKEUP_PENDING(hcd))
 447                        return -EBUSY;
 448                if (do_wakeup && hcd->shared_hcd &&
 449                                HCD_WAKEUP_PENDING(hcd->shared_hcd))
 450                        return -EBUSY;
 451                retval = hcd->driver->pci_suspend(hcd, do_wakeup);
 452                suspend_report_result(hcd->driver->pci_suspend, retval);
 453
 454                /* Check again in case wakeup raced with pci_suspend */
 455                if ((retval == 0 && do_wakeup && HCD_WAKEUP_PENDING(hcd)) ||
 456                                (retval == 0 && do_wakeup && hcd->shared_hcd &&
 457                                 HCD_WAKEUP_PENDING(hcd->shared_hcd))) {
 458                        if (hcd->driver->pci_resume)
 459                                hcd->driver->pci_resume(hcd, false);
 460                        retval = -EBUSY;
 461                }
 462                if (retval)
 463                        return retval;
 464        }
 465
 466        /* If MSI-X is enabled, the driver will have synchronized all vectors
 467         * in pci_suspend(). If MSI or legacy PCI is enabled, that will be
 468         * synchronized here.
 469         */
 470        if (!hcd->msix_enabled)
 471                synchronize_irq(pci_dev->irq);
 472
 473        /* Downstream ports from this root hub should already be quiesced, so
 474         * there will be no DMA activity.  Now we can shut down the upstream
 475         * link (except maybe for PME# resume signaling).  We'll enter a
 476         * low power state during suspend_noirq, if the hardware allows.
 477         */
 478        pci_disable_device(pci_dev);
 479        return retval;
 480}
 481
 482static int resume_common(struct device *dev, int event)
 483{
 484        struct pci_dev          *pci_dev = to_pci_dev(dev);
 485        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
 486        int                     retval;
 487
 488        if (HCD_RH_RUNNING(hcd) ||
 489                        (hcd->shared_hcd &&
 490                         HCD_RH_RUNNING(hcd->shared_hcd))) {
 491                dev_dbg(dev, "can't resume, not suspended!\n");
 492                return 0;
 493        }
 494
 495        retval = pci_enable_device(pci_dev);
 496        if (retval < 0) {
 497                dev_err(dev, "can't re-enable after resume, %d!\n", retval);
 498                return retval;
 499        }
 500
 501        pci_set_master(pci_dev);
 502
 503        if (hcd->driver->pci_resume && !HCD_DEAD(hcd)) {
 504
 505                /*
 506                 * Only EHCI controllers have to wait for their companions.
 507                 * No locking is needed because PCI controller drivers do not
 508                 * get unbound during system resume.
 509                 */
 510                if (pci_dev->class == CL_EHCI && event != PM_EVENT_AUTO_RESUME)
 511                        for_each_companion(pci_dev, hcd,
 512                                        ehci_wait_for_companions);
 513
 514                retval = hcd->driver->pci_resume(hcd,
 515                                event == PM_EVENT_RESTORE);
 516                if (retval) {
 517                        dev_err(dev, "PCI post-resume error %d!\n", retval);
 518                        usb_hc_died(hcd);
 519                }
 520        }
 521        return retval;
 522}
 523
 524#ifdef  CONFIG_PM_SLEEP
 525
 526static int hcd_pci_suspend(struct device *dev)
 527{
 528        return suspend_common(dev, device_may_wakeup(dev));
 529}
 530
 531static int hcd_pci_suspend_noirq(struct device *dev)
 532{
 533        struct pci_dev          *pci_dev = to_pci_dev(dev);
 534        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
 535        int                     retval;
 536
 537        retval = check_root_hub_suspended(dev);
 538        if (retval)
 539                return retval;
 540
 541        pci_save_state(pci_dev);
 542
 543        /* If the root hub is dead rather than suspended, disallow remote
 544         * wakeup.  usb_hc_died() should ensure that both hosts are marked as
 545         * dying, so we only need to check the primary roothub.
 546         */
 547        if (HCD_DEAD(hcd))
 548                device_set_wakeup_enable(dev, 0);
 549        dev_dbg(dev, "wakeup: %d\n", device_may_wakeup(dev));
 550
 551        /* Possibly enable remote wakeup,
 552         * choose the appropriate low-power state, and go to that state.
 553         */
 554        retval = pci_prepare_to_sleep(pci_dev);
 555        if (retval == -EIO) {           /* Low-power not supported */
 556                dev_dbg(dev, "--> PCI D0 legacy\n");
 557                retval = 0;
 558        } else if (retval == 0) {
 559                dev_dbg(dev, "--> PCI %s\n",
 560                                pci_power_name(pci_dev->current_state));
 561        } else {
 562                suspend_report_result(pci_prepare_to_sleep, retval);
 563                return retval;
 564        }
 565
 566        powermac_set_asic(pci_dev, 0);
 567        return retval;
 568}
 569
 570static int hcd_pci_resume_noirq(struct device *dev)
 571{
 572        powermac_set_asic(to_pci_dev(dev), 1);
 573        return 0;
 574}
 575
 576static int hcd_pci_resume(struct device *dev)
 577{
 578        return resume_common(dev, PM_EVENT_RESUME);
 579}
 580
 581static int hcd_pci_restore(struct device *dev)
 582{
 583        return resume_common(dev, PM_EVENT_RESTORE);
 584}
 585
 586#else
 587
 588#define hcd_pci_suspend         NULL
 589#define hcd_pci_suspend_noirq   NULL
 590#define hcd_pci_resume_noirq    NULL
 591#define hcd_pci_resume          NULL
 592#define hcd_pci_restore         NULL
 593
 594#endif  /* CONFIG_PM_SLEEP */
 595
 596static int hcd_pci_runtime_suspend(struct device *dev)
 597{
 598        int     retval;
 599
 600        retval = suspend_common(dev, true);
 601        if (retval == 0)
 602                powermac_set_asic(to_pci_dev(dev), 0);
 603        dev_dbg(dev, "hcd_pci_runtime_suspend: %d\n", retval);
 604        return retval;
 605}
 606
 607static int hcd_pci_runtime_resume(struct device *dev)
 608{
 609        int     retval;
 610
 611        powermac_set_asic(to_pci_dev(dev), 1);
 612        retval = resume_common(dev, PM_EVENT_AUTO_RESUME);
 613        dev_dbg(dev, "hcd_pci_runtime_resume: %d\n", retval);
 614        return retval;
 615}
 616
 617const struct dev_pm_ops usb_hcd_pci_pm_ops = {
 618        .suspend        = hcd_pci_suspend,
 619        .suspend_noirq  = hcd_pci_suspend_noirq,
 620        .resume_noirq   = hcd_pci_resume_noirq,
 621        .resume         = hcd_pci_resume,
 622        .freeze         = check_root_hub_suspended,
 623        .freeze_noirq   = check_root_hub_suspended,
 624        .thaw_noirq     = NULL,
 625        .thaw           = NULL,
 626        .poweroff       = hcd_pci_suspend,
 627        .poweroff_noirq = hcd_pci_suspend_noirq,
 628        .restore_noirq  = hcd_pci_resume_noirq,
 629        .restore        = hcd_pci_restore,
 630        .runtime_suspend = hcd_pci_runtime_suspend,
 631        .runtime_resume = hcd_pci_runtime_resume,
 632};
 633EXPORT_SYMBOL_GPL(usb_hcd_pci_pm_ops);
 634
 635#endif  /* CONFIG_PM */
 636