2 * This file contains code to reset and initialize USB host controllers.
3 * Some of it includes work-arounds for PCI hardware and BIOS quirks.
4 * It may need to run early during booting -- before USB would normally
5 * initialize -- to ensure that Linux doesn't use any legacy modes.
7 * Copyright (c) 1999 Martin Mares <mj@ucw.cz>
11 #include <linux/types.h>
12 #include <linux/kconfig.h>
13 #include <linux/kernel.h>
14 #include <linux/pci.h>
15 #include <linux/init.h>
16 #include <linux/delay.h>
17 #include <linux/export.h>
18 #include <linux/acpi.h>
19 #include <linux/dmi.h>
20 #include "pci-quirks.h"
21 #include "xhci-ext-caps.h"
24 #define UHCI_USBLEGSUP 0xc0 /* legacy support */
25 #define UHCI_USBCMD 0 /* command register */
26 #define UHCI_USBINTR 4 /* interrupt register */
27 #define UHCI_USBLEGSUP_RWC 0x8f00 /* the R/WC bits */
28 #define UHCI_USBLEGSUP_RO 0x5040 /* R/O and reserved bits */
29 #define UHCI_USBCMD_RUN 0x0001 /* RUN/STOP bit */
30 #define UHCI_USBCMD_HCRESET 0x0002 /* Host Controller reset */
31 #define UHCI_USBCMD_EGSM 0x0008 /* Global Suspend Mode */
32 #define UHCI_USBCMD_CONFIGURE 0x0040 /* Config Flag */
33 #define UHCI_USBINTR_RESUME 0x0002 /* Resume interrupt enable */
35 #define OHCI_CONTROL 0x04
36 #define OHCI_CMDSTATUS 0x08
37 #define OHCI_INTRSTATUS 0x0c
38 #define OHCI_INTRENABLE 0x10
39 #define OHCI_INTRDISABLE 0x14
40 #define OHCI_FMINTERVAL 0x34
41 #define OHCI_HCFS (3 << 6) /* hc functional state */
42 #define OHCI_HCR (1 << 0) /* host controller reset */
43 #define OHCI_OCR (1 << 3) /* ownership change request */
44 #define OHCI_CTRL_RWC (1 << 9) /* remote wakeup connected */
45 #define OHCI_CTRL_IR (1 << 8) /* interrupt routing */
46 #define OHCI_INTR_OC (1 << 30) /* ownership change */
48 #define EHCI_HCC_PARAMS 0x08 /* extended capabilities */
49 #define EHCI_USBCMD 0 /* command register */
50 #define EHCI_USBCMD_RUN (1 << 0) /* RUN/STOP bit */
51 #define EHCI_USBSTS 4 /* status register */
52 #define EHCI_USBSTS_HALTED (1 << 12) /* HCHalted bit */
53 #define EHCI_USBINTR 8 /* interrupt register */
54 #define EHCI_CONFIGFLAG 0x40 /* configured flag register */
55 #define EHCI_USBLEGSUP 0 /* legacy support register */
56 #define EHCI_USBLEGSUP_BIOS (1 << 16) /* BIOS semaphore */
57 #define EHCI_USBLEGSUP_OS (1 << 24) /* OS semaphore */
58 #define EHCI_USBLEGCTLSTS 4 /* legacy control/status */
59 #define EHCI_USBLEGCTLSTS_SOOE (1 << 13) /* SMI on ownership change */
62 #define AB_REG_BAR_LOW 0xe0
63 #define AB_REG_BAR_HIGH 0xe1
64 #define AB_REG_BAR_SB700 0xf0
65 #define AB_INDX(addr) ((addr) + 0x00)
66 #define AB_DATA(addr) ((addr) + 0x04)
70 #define NB_PCIE_INDX_ADDR 0xe0
71 #define NB_PCIE_INDX_DATA 0xe4
72 #define PCIE_P_CNTL 0x10040
73 #define BIF_NB 0x10002
74 #define NB_PIF0_PWRDOWN_0 0x01100012
75 #define NB_PIF0_PWRDOWN_1 0x01100013
77 #define USB_INTEL_XUSB2PR 0xD0
78 #define USB_INTEL_USB2PRM 0xD4
79 #define USB_INTEL_USB3_PSSEN 0xD8
80 #define USB_INTEL_USB3PRM 0xDC
83 * amd_chipset_gen values represent AMD different chipset generations
85 enum amd_chipset_gen {
96 struct amd_chipset_type {
97 enum amd_chipset_gen gen;
101 static struct amd_chipset_info {
102 struct pci_dev *nb_dev;
103 struct pci_dev *smbus_dev;
105 struct amd_chipset_type sb_type;
111 static DEFINE_SPINLOCK(amd_lock);
114 * amd_chipset_sb_type_init - initialize amd chipset southbridge type
116 * AMD FCH/SB generation and revision is identified by SMBus controller
117 * vendor, device and revision IDs.
119 * Returns: 1 if it is an AMD chipset, 0 otherwise.
121 static int amd_chipset_sb_type_init(struct amd_chipset_info *pinfo)
124 pinfo->sb_type.gen = AMD_CHIPSET_UNKNOWN;
126 pinfo->smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI,
127 PCI_DEVICE_ID_ATI_SBX00_SMBUS, NULL);
128 if (pinfo->smbus_dev) {
129 rev = pinfo->smbus_dev->revision;
130 if (rev >= 0x10 && rev <= 0x1f)
131 pinfo->sb_type.gen = AMD_CHIPSET_SB600;
132 else if (rev >= 0x30 && rev <= 0x3f)
133 pinfo->sb_type.gen = AMD_CHIPSET_SB700;
134 else if (rev >= 0x40 && rev <= 0x4f)
135 pinfo->sb_type.gen = AMD_CHIPSET_SB800;
137 pinfo->smbus_dev = pci_get_device(PCI_VENDOR_ID_AMD,
138 PCI_DEVICE_ID_AMD_HUDSON2_SMBUS, NULL);
140 if (!pinfo->smbus_dev) {
141 pinfo->sb_type.gen = NOT_AMD_CHIPSET;
145 rev = pinfo->smbus_dev->revision;
146 if (rev >= 0x11 && rev <= 0x14)
147 pinfo->sb_type.gen = AMD_CHIPSET_HUDSON2;
148 else if (rev >= 0x15 && rev <= 0x18)
149 pinfo->sb_type.gen = AMD_CHIPSET_BOLTON;
150 else if (rev >= 0x39 && rev <= 0x3a)
151 pinfo->sb_type.gen = AMD_CHIPSET_YANGTZE;
154 pinfo->sb_type.rev = rev;
158 void sb800_prefetch(struct device *dev, int on)
161 struct pci_dev *pdev = to_pci_dev(dev);
163 pci_read_config_word(pdev, 0x50, &misc);
165 pci_write_config_word(pdev, 0x50, misc & 0xfcff);
167 pci_write_config_word(pdev, 0x50, misc | 0x0300);
169 EXPORT_SYMBOL_GPL(sb800_prefetch);
171 int usb_amd_find_chipset_info(void)
174 struct amd_chipset_info info;
177 spin_lock_irqsave(&amd_lock, flags);
179 /* probe only once */
180 if (amd_chipset.probe_count > 0) {
181 amd_chipset.probe_count++;
182 spin_unlock_irqrestore(&amd_lock, flags);
183 return amd_chipset.probe_result;
185 memset(&info, 0, sizeof(info));
186 spin_unlock_irqrestore(&amd_lock, flags);
188 if (!amd_chipset_sb_type_init(&info)) {
193 /* Below chipset generations needn't enable AMD PLL quirk */
194 if (info.sb_type.gen == AMD_CHIPSET_UNKNOWN ||
195 info.sb_type.gen == AMD_CHIPSET_SB600 ||
196 info.sb_type.gen == AMD_CHIPSET_YANGTZE ||
197 (info.sb_type.gen == AMD_CHIPSET_SB700 &&
198 info.sb_type.rev > 0x3b)) {
199 if (info.smbus_dev) {
200 pci_dev_put(info.smbus_dev);
201 info.smbus_dev = NULL;
207 info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x9601, NULL);
211 info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x1510, NULL);
215 info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD,
222 ret = info.probe_result = 1;
223 printk(KERN_DEBUG "QUIRK: Enable AMD PLL fix\n");
227 spin_lock_irqsave(&amd_lock, flags);
228 if (amd_chipset.probe_count > 0) {
229 /* race - someone else was faster - drop devices */
231 /* Mark that we where here */
232 amd_chipset.probe_count++;
233 ret = amd_chipset.probe_result;
235 spin_unlock_irqrestore(&amd_lock, flags);
238 pci_dev_put(info.nb_dev);
240 pci_dev_put(info.smbus_dev);
243 /* no race - commit the result */
246 spin_unlock_irqrestore(&amd_lock, flags);
251 EXPORT_SYMBOL_GPL(usb_amd_find_chipset_info);
253 int usb_hcd_amd_remote_wakeup_quirk(struct pci_dev *pdev)
255 /* Make sure amd chipset type has already been initialized */
256 usb_amd_find_chipset_info();
257 if (amd_chipset.sb_type.gen != AMD_CHIPSET_YANGTZE)
260 dev_dbg(&pdev->dev, "QUIRK: Enable AMD remote wakeup fix\n");
263 EXPORT_SYMBOL_GPL(usb_hcd_amd_remote_wakeup_quirk);
266 * The hardware normally enables the A-link power management feature, which
267 * lets the system lower the power consumption in idle states.
269 * This USB quirk prevents the link going into that lower power state
270 * during isochronous transfers.
272 * Without this quirk, isochronous stream on OHCI/EHCI/xHCI controllers of
273 * some AMD platforms may stutter or have breaks occasionally.
275 static void usb_amd_quirk_pll(int disable)
277 u32 addr, addr_low, addr_high, val;
278 u32 bit = disable ? 0 : 1;
281 spin_lock_irqsave(&amd_lock, flags);
284 amd_chipset.isoc_reqs++;
285 if (amd_chipset.isoc_reqs > 1) {
286 spin_unlock_irqrestore(&amd_lock, flags);
290 amd_chipset.isoc_reqs--;
291 if (amd_chipset.isoc_reqs > 0) {
292 spin_unlock_irqrestore(&amd_lock, flags);
297 if (amd_chipset.sb_type.gen == AMD_CHIPSET_SB800 ||
298 amd_chipset.sb_type.gen == AMD_CHIPSET_HUDSON2 ||
299 amd_chipset.sb_type.gen == AMD_CHIPSET_BOLTON) {
300 outb_p(AB_REG_BAR_LOW, 0xcd6);
301 addr_low = inb_p(0xcd7);
302 outb_p(AB_REG_BAR_HIGH, 0xcd6);
303 addr_high = inb_p(0xcd7);
304 addr = addr_high << 8 | addr_low;
306 outl_p(0x30, AB_INDX(addr));
307 outl_p(0x40, AB_DATA(addr));
308 outl_p(0x34, AB_INDX(addr));
309 val = inl_p(AB_DATA(addr));
310 } else if (amd_chipset.sb_type.gen == AMD_CHIPSET_SB700 &&
311 amd_chipset.sb_type.rev <= 0x3b) {
312 pci_read_config_dword(amd_chipset.smbus_dev,
313 AB_REG_BAR_SB700, &addr);
314 outl(AX_INDXC, AB_INDX(addr));
315 outl(0x40, AB_DATA(addr));
316 outl(AX_DATAC, AB_INDX(addr));
317 val = inl(AB_DATA(addr));
319 spin_unlock_irqrestore(&amd_lock, flags);
325 val |= (1 << 4) | (1 << 9);
328 val &= ~((1 << 4) | (1 << 9));
330 outl_p(val, AB_DATA(addr));
332 if (!amd_chipset.nb_dev) {
333 spin_unlock_irqrestore(&amd_lock, flags);
337 if (amd_chipset.nb_type == 1 || amd_chipset.nb_type == 3) {
339 pci_write_config_dword(amd_chipset.nb_dev,
340 NB_PCIE_INDX_ADDR, addr);
341 pci_read_config_dword(amd_chipset.nb_dev,
342 NB_PCIE_INDX_DATA, &val);
344 val &= ~(1 | (1 << 3) | (1 << 4) | (1 << 9) | (1 << 12));
345 val |= bit | (bit << 3) | (bit << 12);
346 val |= ((!bit) << 4) | ((!bit) << 9);
347 pci_write_config_dword(amd_chipset.nb_dev,
348 NB_PCIE_INDX_DATA, val);
351 pci_write_config_dword(amd_chipset.nb_dev,
352 NB_PCIE_INDX_ADDR, addr);
353 pci_read_config_dword(amd_chipset.nb_dev,
354 NB_PCIE_INDX_DATA, &val);
358 pci_write_config_dword(amd_chipset.nb_dev,
359 NB_PCIE_INDX_DATA, val);
360 } else if (amd_chipset.nb_type == 2) {
361 addr = NB_PIF0_PWRDOWN_0;
362 pci_write_config_dword(amd_chipset.nb_dev,
363 NB_PCIE_INDX_ADDR, addr);
364 pci_read_config_dword(amd_chipset.nb_dev,
365 NB_PCIE_INDX_DATA, &val);
371 pci_write_config_dword(amd_chipset.nb_dev,
372 NB_PCIE_INDX_DATA, val);
374 addr = NB_PIF0_PWRDOWN_1;
375 pci_write_config_dword(amd_chipset.nb_dev,
376 NB_PCIE_INDX_ADDR, addr);
377 pci_read_config_dword(amd_chipset.nb_dev,
378 NB_PCIE_INDX_DATA, &val);
384 pci_write_config_dword(amd_chipset.nb_dev,
385 NB_PCIE_INDX_DATA, val);
388 spin_unlock_irqrestore(&amd_lock, flags);
392 void usb_amd_quirk_pll_disable(void)
394 usb_amd_quirk_pll(1);
396 EXPORT_SYMBOL_GPL(usb_amd_quirk_pll_disable);
398 void usb_amd_quirk_pll_enable(void)
400 usb_amd_quirk_pll(0);
402 EXPORT_SYMBOL_GPL(usb_amd_quirk_pll_enable);
404 void usb_amd_dev_put(void)
406 struct pci_dev *nb, *smbus;
409 spin_lock_irqsave(&amd_lock, flags);
411 amd_chipset.probe_count--;
412 if (amd_chipset.probe_count > 0) {
413 spin_unlock_irqrestore(&amd_lock, flags);
417 /* save them to pci_dev_put outside of spinlock */
418 nb = amd_chipset.nb_dev;
419 smbus = amd_chipset.smbus_dev;
421 amd_chipset.nb_dev = NULL;
422 amd_chipset.smbus_dev = NULL;
423 amd_chipset.nb_type = 0;
424 memset(&amd_chipset.sb_type, 0, sizeof(amd_chipset.sb_type));
425 amd_chipset.isoc_reqs = 0;
426 amd_chipset.probe_result = 0;
428 spin_unlock_irqrestore(&amd_lock, flags);
435 EXPORT_SYMBOL_GPL(usb_amd_dev_put);
438 * Make sure the controller is completely inactive, unable to
439 * generate interrupts or do DMA.
441 void uhci_reset_hc(struct pci_dev *pdev, unsigned long base)
443 /* Turn off PIRQ enable and SMI enable. (This also turns off the
444 * BIOS's USB Legacy Support.) Turn off all the R/WC bits too.
446 pci_write_config_word(pdev, UHCI_USBLEGSUP, UHCI_USBLEGSUP_RWC);
448 /* Reset the HC - this will force us to get a
449 * new notification of any already connected
450 * ports due to the virtual disconnect that it
453 outw(UHCI_USBCMD_HCRESET, base + UHCI_USBCMD);
456 if (inw(base + UHCI_USBCMD) & UHCI_USBCMD_HCRESET)
457 dev_warn(&pdev->dev, "HCRESET not completed yet!\n");
459 /* Just to be safe, disable interrupt requests and
460 * make sure the controller is stopped.
462 outw(0, base + UHCI_USBINTR);
463 outw(0, base + UHCI_USBCMD);
465 EXPORT_SYMBOL_GPL(uhci_reset_hc);
468 * Initialize a controller that was newly discovered or has just been
469 * resumed. In either case we can't be sure of its previous state.
471 * Returns: 1 if the controller was reset, 0 otherwise.
473 int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base)
476 unsigned int cmd, intr;
479 * When restarting a suspended controller, we expect all the
480 * settings to be the same as we left them:
482 * PIRQ and SMI disabled, no R/W bits set in USBLEGSUP;
483 * Controller is stopped and configured with EGSM set;
484 * No interrupts enabled except possibly Resume Detect.
486 * If any of these conditions are violated we do a complete reset.
488 pci_read_config_word(pdev, UHCI_USBLEGSUP, &legsup);
489 if (legsup & ~(UHCI_USBLEGSUP_RO | UHCI_USBLEGSUP_RWC)) {
490 dev_dbg(&pdev->dev, "%s: legsup = 0x%04x\n",
495 cmd = inw(base + UHCI_USBCMD);
496 if ((cmd & UHCI_USBCMD_RUN) || !(cmd & UHCI_USBCMD_CONFIGURE) ||
497 !(cmd & UHCI_USBCMD_EGSM)) {
498 dev_dbg(&pdev->dev, "%s: cmd = 0x%04x\n",
503 intr = inw(base + UHCI_USBINTR);
504 if (intr & (~UHCI_USBINTR_RESUME)) {
505 dev_dbg(&pdev->dev, "%s: intr = 0x%04x\n",
512 dev_dbg(&pdev->dev, "Performing full reset\n");
513 uhci_reset_hc(pdev, base);
516 EXPORT_SYMBOL_GPL(uhci_check_and_reset_hc);
518 static inline int io_type_enabled(struct pci_dev *pdev, unsigned int mask)
521 return !pci_read_config_word(pdev, PCI_COMMAND, &cmd) && (cmd & mask);
524 #define pio_enabled(dev) io_type_enabled(dev, PCI_COMMAND_IO)
525 #define mmio_enabled(dev) io_type_enabled(dev, PCI_COMMAND_MEMORY)
527 static void quirk_usb_handoff_uhci(struct pci_dev *pdev)
529 unsigned long base = 0;
532 if (!pio_enabled(pdev))
535 for (i = 0; i < PCI_ROM_RESOURCE; i++)
536 if ((pci_resource_flags(pdev, i) & IORESOURCE_IO)) {
537 base = pci_resource_start(pdev, i);
542 uhci_check_and_reset_hc(pdev, base);
545 static int mmio_resource_enabled(struct pci_dev *pdev, int idx)
547 return pci_resource_start(pdev, idx) && mmio_enabled(pdev);
550 static void quirk_usb_handoff_ohci(struct pci_dev *pdev)
557 if (!mmio_resource_enabled(pdev, 0))
560 base = pci_ioremap_bar(pdev, 0);
564 control = readl(base + OHCI_CONTROL);
566 /* On PA-RISC, PDC can leave IR set incorrectly; ignore it there. */
568 #define OHCI_CTRL_MASK (OHCI_CTRL_RWC | OHCI_CTRL_IR)
570 #define OHCI_CTRL_MASK OHCI_CTRL_RWC
572 if (control & OHCI_CTRL_IR) {
573 int wait_time = 500; /* arbitrary; 5 seconds */
574 writel(OHCI_INTR_OC, base + OHCI_INTRENABLE);
575 writel(OHCI_OCR, base + OHCI_CMDSTATUS);
576 while (wait_time > 0 &&
577 readl(base + OHCI_CONTROL) & OHCI_CTRL_IR) {
582 dev_warn(&pdev->dev, "OHCI: BIOS handoff failed"
583 " (BIOS bug?) %08x\n",
584 readl(base + OHCI_CONTROL));
588 /* disable interrupts */
589 writel((u32) ~0, base + OHCI_INTRDISABLE);
591 /* Reset the USB bus, if the controller isn't already in RESET */
592 if (control & OHCI_HCFS) {
593 /* Go into RESET, preserving RWC (and possibly IR) */
594 writel(control & OHCI_CTRL_MASK, base + OHCI_CONTROL);
595 readl(base + OHCI_CONTROL);
597 /* drive bus reset for at least 50 ms (7.1.7.5) */
601 /* software reset of the controller, preserving HcFmInterval */
602 fminterval = readl(base + OHCI_FMINTERVAL);
603 writel(OHCI_HCR, base + OHCI_CMDSTATUS);
605 /* reset requires max 10 us delay */
606 for (cnt = 30; cnt > 0; --cnt) { /* ... allow extra time */
607 if ((readl(base + OHCI_CMDSTATUS) & OHCI_HCR) == 0)
611 writel(fminterval, base + OHCI_FMINTERVAL);
613 /* Now the controller is safely in SUSPEND and nothing can wake it up */
617 static const struct dmi_system_id ehci_dmi_nohandoff_table[] = {
619 /* Pegatron Lucid (ExoPC) */
621 DMI_MATCH(DMI_BOARD_NAME, "EXOPG06411"),
622 DMI_MATCH(DMI_BIOS_VERSION, "Lucid-CE-133"),
626 /* Pegatron Lucid (Ordissimo AIRIS) */
628 DMI_MATCH(DMI_BOARD_NAME, "M11JB"),
629 DMI_MATCH(DMI_BIOS_VERSION, "Lucid-"),
633 /* Pegatron Lucid (Ordissimo) */
635 DMI_MATCH(DMI_BOARD_NAME, "Ordissimo"),
636 DMI_MATCH(DMI_BIOS_VERSION, "Lucid-"),
642 static void ehci_bios_handoff(struct pci_dev *pdev,
643 void __iomem *op_reg_base,
646 int try_handoff = 1, tried_handoff = 0;
648 /* The Pegatron Lucid tablet sporadically waits for 98 seconds trying
649 * the handoff on its unused controller. Skip it. */
650 if (pdev->vendor == 0x8086 && pdev->device == 0x283a) {
651 if (dmi_check_system(ehci_dmi_nohandoff_table))
655 if (try_handoff && (cap & EHCI_USBLEGSUP_BIOS)) {
656 dev_dbg(&pdev->dev, "EHCI: BIOS handoff\n");
659 /* aleksey_gorelov@phoenix.com reports that some systems need SMI forced on,
660 * but that seems dubious in general (the BIOS left it off intentionally)
661 * and is known to prevent some systems from booting. so we won't do this
662 * unless maybe we can determine when we're on a system that needs SMI forced.
664 /* BIOS workaround (?): be sure the pre-Linux code
667 pci_read_config_dword(pdev, offset + EHCI_USBLEGCTLSTS, &val);
668 pci_write_config_dword(pdev, offset + EHCI_USBLEGCTLSTS,
669 val | EHCI_USBLEGCTLSTS_SOOE);
672 /* some systems get upset if this semaphore is
673 * set for any other reason than forcing a BIOS
676 pci_write_config_byte(pdev, offset + 3, 1);
679 /* if boot firmware now owns EHCI, spin till it hands it over. */
682 while ((cap & EHCI_USBLEGSUP_BIOS) && (msec > 0)) {
686 pci_read_config_dword(pdev, offset, &cap);
690 if (cap & EHCI_USBLEGSUP_BIOS) {
691 /* well, possibly buggy BIOS... try to shut it down,
692 * and hope nothing goes too wrong
695 dev_warn(&pdev->dev, "EHCI: BIOS handoff failed"
696 " (BIOS bug?) %08x\n", cap);
697 pci_write_config_byte(pdev, offset + 2, 0);
700 /* just in case, always disable EHCI SMIs */
701 pci_write_config_dword(pdev, offset + EHCI_USBLEGCTLSTS, 0);
703 /* If the BIOS ever owned the controller then we can't expect
704 * any power sessions to remain intact.
707 writel(0, op_reg_base + EHCI_CONFIGFLAG);
710 static void quirk_usb_disable_ehci(struct pci_dev *pdev)
712 void __iomem *base, *op_reg_base;
713 u32 hcc_params, cap, val;
714 u8 offset, cap_length;
715 int wait_time, count = 256/4;
717 if (!mmio_resource_enabled(pdev, 0))
720 base = pci_ioremap_bar(pdev, 0);
724 cap_length = readb(base);
725 op_reg_base = base + cap_length;
727 /* EHCI 0.96 and later may have "extended capabilities"
728 * spec section 5.1 explains the bios handoff, e.g. for
729 * booting from USB disk or using a usb keyboard
731 hcc_params = readl(base + EHCI_HCC_PARAMS);
732 offset = (hcc_params >> 8) & 0xff;
733 while (offset && --count) {
734 pci_read_config_dword(pdev, offset, &cap);
736 switch (cap & 0xff) {
738 ehci_bios_handoff(pdev, op_reg_base, cap, offset);
740 case 0: /* Illegal reserved cap, set cap=0 so we exit */
741 cap = 0; /* then fallthrough... */
743 dev_warn(&pdev->dev, "EHCI: unrecognized capability "
744 "%02x\n", cap & 0xff);
746 offset = (cap >> 8) & 0xff;
749 dev_printk(KERN_DEBUG, &pdev->dev, "EHCI: capability loop?\n");
752 * halt EHCI & disable its interrupts in any case
754 val = readl(op_reg_base + EHCI_USBSTS);
755 if ((val & EHCI_USBSTS_HALTED) == 0) {
756 val = readl(op_reg_base + EHCI_USBCMD);
757 val &= ~EHCI_USBCMD_RUN;
758 writel(val, op_reg_base + EHCI_USBCMD);
762 writel(0x3f, op_reg_base + EHCI_USBSTS);
765 val = readl(op_reg_base + EHCI_USBSTS);
766 if ((val == ~(u32)0) || (val & EHCI_USBSTS_HALTED)) {
769 } while (wait_time > 0);
771 writel(0, op_reg_base + EHCI_USBINTR);
772 writel(0x3f, op_reg_base + EHCI_USBSTS);
778 * handshake - spin reading a register until handshake completes
779 * @ptr: address of hc register to be read
780 * @mask: bits to look at in result of read
781 * @done: value of those bits when handshake succeeds
782 * @wait_usec: timeout in microseconds
783 * @delay_usec: delay in microseconds to wait between polling
785 * Polls a register every delay_usec microseconds.
786 * Returns 0 when the mask bits have the value done.
787 * Returns -ETIMEDOUT if this condition is not true after
788 * wait_usec microseconds have passed.
790 static int handshake(void __iomem *ptr, u32 mask, u32 done,
791 int wait_usec, int delay_usec)
801 wait_usec -= delay_usec;
802 } while (wait_usec > 0);
807 * Intel's Panther Point chipset has two host controllers (EHCI and xHCI) that
808 * share some number of ports. These ports can be switched between either
809 * controller. Not all of the ports under the EHCI host controller may be
812 * The ports should be switched over to xHCI before PCI probes for any device
813 * start. This avoids active devices under EHCI being disconnected during the
814 * port switchover, which could cause loss of data on USB storage devices, or
815 * failed boot when the root file system is on a USB mass storage device and is
816 * enumerated under EHCI first.
818 * We write into the xHC's PCI configuration space in some Intel-specific
819 * registers to switch the ports over. The USB 3.0 terminations and the USB
820 * 2.0 data wires are switched separately. We want to enable the SuperSpeed
821 * terminations before switching the USB 2.0 wires over, so that USB 3.0
822 * devices connect at SuperSpeed, rather than at USB 2.0 speeds.
824 void usb_enable_intel_xhci_ports(struct pci_dev *xhci_pdev)
827 bool ehci_found = false;
828 struct pci_dev *companion = NULL;
830 /* make sure an intel EHCI controller exists */
831 for_each_pci_dev(companion) {
832 if (companion->class == PCI_CLASS_SERIAL_USB_EHCI &&
833 companion->vendor == PCI_VENDOR_ID_INTEL) {
842 /* Don't switchover the ports if the user hasn't compiled the xHCI
843 * driver. Otherwise they will see "dead" USB ports that don't power
846 if (!IS_ENABLED(CONFIG_USB_XHCI_HCD)) {
847 dev_warn(&xhci_pdev->dev,
848 "CONFIG_USB_XHCI_HCD is turned off, "
849 "defaulting to EHCI.\n");
850 dev_warn(&xhci_pdev->dev,
851 "USB 3.0 devices will work at USB 2.0 speeds.\n");
852 usb_disable_xhci_ports(xhci_pdev);
856 /* Read USB3PRM, the USB 3.0 Port Routing Mask Register
857 * Indicate the ports that can be changed from OS.
859 pci_read_config_dword(xhci_pdev, USB_INTEL_USB3PRM,
862 dev_dbg(&xhci_pdev->dev, "Configurable ports to enable SuperSpeed: 0x%x\n",
865 /* Write USB3_PSSEN, the USB 3.0 Port SuperSpeed Enable
866 * Register, to turn on SuperSpeed terminations for the
869 pci_write_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
870 cpu_to_le32(ports_available));
872 pci_read_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
874 dev_dbg(&xhci_pdev->dev, "USB 3.0 ports that are now enabled "
875 "under xHCI: 0x%x\n", ports_available);
877 /* Read XUSB2PRM, xHCI USB 2.0 Port Routing Mask Register
878 * Indicate the USB 2.0 ports to be controlled by the xHCI host.
881 pci_read_config_dword(xhci_pdev, USB_INTEL_USB2PRM,
884 dev_dbg(&xhci_pdev->dev, "Configurable USB 2.0 ports to hand over to xCHI: 0x%x\n",
887 /* Write XUSB2PR, the xHC USB 2.0 Port Routing Register, to
888 * switch the USB 2.0 power and data lines over to the xHCI
891 pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
892 cpu_to_le32(ports_available));
894 pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
896 dev_dbg(&xhci_pdev->dev, "USB 2.0 ports that are now switched over "
897 "to xHCI: 0x%x\n", ports_available);
899 EXPORT_SYMBOL_GPL(usb_enable_intel_xhci_ports);
901 void usb_disable_xhci_ports(struct pci_dev *xhci_pdev)
903 pci_write_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN, 0x0);
904 pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR, 0x0);
906 EXPORT_SYMBOL_GPL(usb_disable_xhci_ports);
909 * PCI Quirks for xHCI.
911 * Takes care of the handoff between the Pre-OS (i.e. BIOS) and the OS.
912 * It signals to the BIOS that the OS wants control of the host controller,
913 * and then waits 5 seconds for the BIOS to hand over control.
914 * If we timeout, assume the BIOS is broken and take control anyway.
916 static void quirk_usb_handoff_xhci(struct pci_dev *pdev)
920 void __iomem *op_reg_base;
923 int len = pci_resource_len(pdev, 0);
925 if (!mmio_resource_enabled(pdev, 0))
928 base = ioremap_nocache(pci_resource_start(pdev, 0), len);
933 * Find the Legacy Support Capability register -
934 * this is optional for xHCI host controllers.
936 ext_cap_offset = xhci_find_next_cap_offset(base, XHCI_HCC_PARAMS_OFFSET);
938 if ((ext_cap_offset + sizeof(val)) > len) {
939 /* We're reading garbage from the controller */
941 "xHCI controller failing to respond");
946 /* We've reached the end of the extended capabilities */
949 val = readl(base + ext_cap_offset);
950 if (XHCI_EXT_CAPS_ID(val) == XHCI_EXT_CAPS_LEGACY)
952 ext_cap_offset = xhci_find_next_cap_offset(base, ext_cap_offset);
955 /* If the BIOS owns the HC, signal that the OS wants it, and wait */
956 if (val & XHCI_HC_BIOS_OWNED) {
957 writel(val | XHCI_HC_OS_OWNED, base + ext_cap_offset);
959 /* Wait for 5 seconds with 10 microsecond polling interval */
960 timeout = handshake(base + ext_cap_offset, XHCI_HC_BIOS_OWNED,
963 /* Assume a buggy BIOS and take HC ownership anyway */
965 dev_warn(&pdev->dev, "xHCI BIOS handoff failed"
966 " (BIOS bug ?) %08x\n", val);
967 writel(val & ~XHCI_HC_BIOS_OWNED, base + ext_cap_offset);
971 val = readl(base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
972 /* Mask off (turn off) any enabled SMIs */
973 val &= XHCI_LEGACY_DISABLE_SMI;
974 /* Mask all SMI events bits, RW1C */
975 val |= XHCI_LEGACY_SMI_EVENTS;
976 /* Disable any BIOS SMIs and clear all SMI events*/
977 writel(val, base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
980 if (pdev->vendor == PCI_VENDOR_ID_INTEL)
981 usb_enable_intel_xhci_ports(pdev);
983 op_reg_base = base + XHCI_HC_LENGTH(readl(base));
985 /* Wait for the host controller to be ready before writing any
986 * operational or runtime registers. Wait 5 seconds and no more.
988 timeout = handshake(op_reg_base + XHCI_STS_OFFSET, XHCI_STS_CNR, 0,
990 /* Assume a buggy HC and start HC initialization anyway */
992 val = readl(op_reg_base + XHCI_STS_OFFSET);
994 "xHCI HW not ready after 5 sec (HC bug?) "
995 "status = 0x%x\n", val);
998 /* Send the halt and disable interrupts command */
999 val = readl(op_reg_base + XHCI_CMD_OFFSET);
1000 val &= ~(XHCI_CMD_RUN | XHCI_IRQS);
1001 writel(val, op_reg_base + XHCI_CMD_OFFSET);
1003 /* Wait for the HC to halt - poll every 125 usec (one microframe). */
1004 timeout = handshake(op_reg_base + XHCI_STS_OFFSET, XHCI_STS_HALT, 1,
1005 XHCI_MAX_HALT_USEC, 125);
1007 val = readl(op_reg_base + XHCI_STS_OFFSET);
1008 dev_warn(&pdev->dev,
1009 "xHCI HW did not halt within %d usec "
1010 "status = 0x%x\n", XHCI_MAX_HALT_USEC, val);
1016 static void quirk_usb_early_handoff(struct pci_dev *pdev)
1018 /* Skip Netlogic mips SoC's internal PCI USB controller.
1019 * This device does not need/support EHCI/OHCI handoff
1021 if (pdev->vendor == 0x184e) /* vendor Netlogic */
1023 if (pdev->class != PCI_CLASS_SERIAL_USB_UHCI &&
1024 pdev->class != PCI_CLASS_SERIAL_USB_OHCI &&
1025 pdev->class != PCI_CLASS_SERIAL_USB_EHCI &&
1026 pdev->class != PCI_CLASS_SERIAL_USB_XHCI)
1029 if (pci_enable_device(pdev) < 0) {
1030 dev_warn(&pdev->dev, "Can't enable PCI device, "
1031 "BIOS handoff failed.\n");
1034 if (pdev->class == PCI_CLASS_SERIAL_USB_UHCI)
1035 quirk_usb_handoff_uhci(pdev);
1036 else if (pdev->class == PCI_CLASS_SERIAL_USB_OHCI)
1037 quirk_usb_handoff_ohci(pdev);
1038 else if (pdev->class == PCI_CLASS_SERIAL_USB_EHCI)
1039 quirk_usb_disable_ehci(pdev);
1040 else if (pdev->class == PCI_CLASS_SERIAL_USB_XHCI)
1041 quirk_usb_handoff_xhci(pdev);
1042 pci_disable_device(pdev);
1044 DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_ANY_ID, PCI_ANY_ID,
1045 PCI_CLASS_SERIAL_USB, 8, quirk_usb_early_handoff);