1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * UHCI HCD (Host Controller Driver) PCI Bus Glue. 4 * 5 * Extracted from uhci-hcd.c: 6 * Maintainer: Alan Stern <stern@rowland.harvard.edu> 7 * 8 * (C) Copyright 1999 Linus Torvalds 9 * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com 10 * (C) Copyright 1999 Randy Dunlap 11 * (C) Copyright 1999 Georg Acher, acher@in.tum.de 12 * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de 13 * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch 14 * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at 15 * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface 16 * support from usb-ohci.c by Adam Richter, adam@yggdrasil.com). 17 * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c) 18 * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu 19 */ 20 21 #include "pci-quirks.h" 22 23 /* 24 * Make sure the controller is completely inactive, unable to 25 * generate interrupts or do DMA. 26 */ 27 static void uhci_pci_reset_hc(struct uhci_hcd *uhci) 28 { 29 uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr); 30 } 31 32 /* 33 * Initialize a controller that was newly discovered or has just been 34 * resumed. In either case we can't be sure of its previous state. 35 * 36 * Returns: 1 if the controller was reset, 0 otherwise. 37 */ 38 static int uhci_pci_check_and_reset_hc(struct uhci_hcd *uhci) 39 { 40 return uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)), 41 uhci->io_addr); 42 } 43 44 /* 45 * Store the basic register settings needed by the controller. 46 * This function is called at the end of configure_hc in uhci-hcd.c. 47 */ 48 static void uhci_pci_configure_hc(struct uhci_hcd *uhci) 49 { 50 struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci)); 51 52 /* Enable PIRQ */ 53 pci_write_config_word(pdev, USBLEGSUP, USBLEGSUP_DEFAULT); 54 55 /* Disable platform-specific non-PME# wakeup */ 56 if (pdev->vendor == PCI_VENDOR_ID_INTEL) 57 pci_write_config_byte(pdev, USBRES_INTEL, 0); 58 } 59 60 static int uhci_pci_resume_detect_interrupts_are_broken(struct uhci_hcd *uhci) 61 { 62 int port; 63 64 switch (to_pci_dev(uhci_dev(uhci))->vendor) { 65 default: 66 break; 67 68 case PCI_VENDOR_ID_GENESYS: 69 /* Genesys Logic's GL880S controllers don't generate 70 * resume-detect interrupts. 71 */ 72 return 1; 73 74 case PCI_VENDOR_ID_INTEL: 75 /* Some of Intel's USB controllers have a bug that causes 76 * resume-detect interrupts if any port has an over-current 77 * condition. To make matters worse, some motherboards 78 * hardwire unused USB ports' over-current inputs active! 79 * To prevent problems, we will not enable resume-detect 80 * interrupts if any ports are OC. 81 */ 82 for (port = 0; port < uhci->rh_numports; ++port) { 83 if (inw(uhci->io_addr + USBPORTSC1 + port * 2) & 84 USBPORTSC_OC) 85 return 1; 86 } 87 break; 88 } 89 return 0; 90 } 91 92 static int uhci_pci_global_suspend_mode_is_broken(struct uhci_hcd *uhci) 93 { 94 int port; 95 const char *sys_info; 96 static const char bad_Asus_board[] = "A7V8X"; 97 98 /* One of Asus's motherboards has a bug which causes it to 99 * wake up immediately from suspend-to-RAM if any of the ports 100 * are connected. In such cases we will not set EGSM. 101 */ 102 sys_info = dmi_get_system_info(DMI_BOARD_NAME); 103 if (sys_info && !strcmp(sys_info, bad_Asus_board)) { 104 for (port = 0; port < uhci->rh_numports; ++port) { 105 if (inw(uhci->io_addr + USBPORTSC1 + port * 2) & 106 USBPORTSC_CCS) 107 return 1; 108 } 109 } 110 111 return 0; 112 } 113 114 static int uhci_pci_init(struct usb_hcd *hcd) 115 { 116 struct uhci_hcd *uhci = hcd_to_uhci(hcd); 117 118 uhci->io_addr = (unsigned long) hcd->rsrc_start; 119 120 uhci->rh_numports = uhci_count_ports(hcd); 121 122 /* Intel controllers report the OverCurrent bit active on. 123 * VIA controllers report it active off, so we'll adjust the 124 * bit value. (It's not standardized in the UHCI spec.) 125 */ 126 if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_VIA) 127 uhci->oc_low = 1; 128 129 /* HP's server management chip requires a longer port reset delay. */ 130 if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_HP) 131 uhci->wait_for_hp = 1; 132 133 /* Intel controllers use non-PME wakeup signalling */ 134 if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_INTEL) 135 device_set_wakeup_capable(uhci_dev(uhci), true); 136 137 /* Set up pointers to PCI-specific functions */ 138 uhci->reset_hc = uhci_pci_reset_hc; 139 uhci->check_and_reset_hc = uhci_pci_check_and_reset_hc; 140 uhci->configure_hc = uhci_pci_configure_hc; 141 uhci->resume_detect_interrupts_are_broken = 142 uhci_pci_resume_detect_interrupts_are_broken; 143 uhci->global_suspend_mode_is_broken = 144 uhci_pci_global_suspend_mode_is_broken; 145 146 147 /* Kick BIOS off this hardware and reset if the controller 148 * isn't already safely quiescent. 149 */ 150 check_and_reset_hc(uhci); 151 return 0; 152 } 153 154 /* Make sure the controller is quiescent and that we're not using it 155 * any more. This is mainly for the benefit of programs which, like kexec, 156 * expect the hardware to be idle: not doing DMA or generating IRQs. 157 * 158 * This routine may be called in a damaged or failing kernel. Hence we 159 * do not acquire the spinlock before shutting down the controller. 160 */ 161 static void uhci_shutdown(struct pci_dev *pdev) 162 { 163 struct usb_hcd *hcd = pci_get_drvdata(pdev); 164 165 uhci_hc_died(hcd_to_uhci(hcd)); 166 } 167 168 #ifdef CONFIG_PM 169 170 static int uhci_pci_resume(struct usb_hcd *hcd, pm_message_t state); 171 172 static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup) 173 { 174 struct uhci_hcd *uhci = hcd_to_uhci(hcd); 175 struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci)); 176 int rc = 0; 177 178 dev_dbg(uhci_dev(uhci), "%s\n", __func__); 179 180 spin_lock_irq(&uhci->lock); 181 if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead) 182 goto done_okay; /* Already suspended or dead */ 183 184 /* All PCI host controllers are required to disable IRQ generation 185 * at the source, so we must turn off PIRQ. 186 */ 187 pci_write_config_word(pdev, USBLEGSUP, 0); 188 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags); 189 190 /* Enable platform-specific non-PME# wakeup */ 191 if (do_wakeup) { 192 if (pdev->vendor == PCI_VENDOR_ID_INTEL) 193 pci_write_config_byte(pdev, USBRES_INTEL, 194 USBPORT1EN | USBPORT2EN); 195 } 196 197 done_okay: 198 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 199 spin_unlock_irq(&uhci->lock); 200 201 synchronize_irq(hcd->irq); 202 203 /* Check for race with a wakeup request */ 204 if (do_wakeup && HCD_WAKEUP_PENDING(hcd)) { 205 uhci_pci_resume(hcd, PMSG_SUSPEND); 206 rc = -EBUSY; 207 } 208 return rc; 209 } 210 211 static int uhci_pci_resume(struct usb_hcd *hcd, pm_message_t msg) 212 { 213 bool hibernated = (msg.event == PM_EVENT_RESTORE); 214 struct uhci_hcd *uhci = hcd_to_uhci(hcd); 215 216 dev_dbg(uhci_dev(uhci), "%s\n", __func__); 217 218 /* Since we aren't in D3 any more, it's safe to set this flag 219 * even if the controller was dead. 220 */ 221 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 222 223 spin_lock_irq(&uhci->lock); 224 225 /* Make sure resume from hibernation re-enumerates everything */ 226 if (hibernated) { 227 uhci->reset_hc(uhci); 228 finish_reset(uhci); 229 } 230 231 /* The firmware may have changed the controller settings during 232 * a system wakeup. Check it and reconfigure to avoid problems. 233 */ 234 else { 235 check_and_reset_hc(uhci); 236 } 237 configure_hc(uhci); 238 239 /* Tell the core if the controller had to be reset */ 240 if (uhci->rh_state == UHCI_RH_RESET) 241 usb_root_hub_lost_power(hcd->self.root_hub); 242 243 spin_unlock_irq(&uhci->lock); 244 245 /* If interrupts don't work and remote wakeup is enabled then 246 * the suspended root hub needs to be polled. 247 */ 248 if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup) 249 set_bit(HCD_FLAG_POLL_RH, &hcd->flags); 250 251 /* Does the root hub have a port wakeup pending? */ 252 usb_hcd_poll_rh_status(hcd); 253 return 0; 254 } 255 256 #endif 257 258 static const struct hc_driver uhci_driver = { 259 .description = hcd_name, 260 .product_desc = "UHCI Host Controller", 261 .hcd_priv_size = sizeof(struct uhci_hcd), 262 263 /* Generic hardware linkage */ 264 .irq = uhci_irq, 265 .flags = HCD_DMA | HCD_USB11, 266 267 /* Basic lifecycle operations */ 268 .reset = uhci_pci_init, 269 .start = uhci_start, 270 #ifdef CONFIG_PM 271 .pci_suspend = uhci_pci_suspend, 272 .pci_resume = uhci_pci_resume, 273 .bus_suspend = uhci_rh_suspend, 274 .bus_resume = uhci_rh_resume, 275 #endif 276 .stop = uhci_stop, 277 278 .urb_enqueue = uhci_urb_enqueue, 279 .urb_dequeue = uhci_urb_dequeue, 280 281 .endpoint_disable = uhci_hcd_endpoint_disable, 282 .get_frame_number = uhci_hcd_get_frame_number, 283 284 .hub_status_data = uhci_hub_status_data, 285 .hub_control = uhci_hub_control, 286 }; 287 288 static const struct pci_device_id uhci_pci_ids[] = { { 289 /* handle any USB UHCI controller */ 290 PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_UHCI, ~0), 291 }, { /* end: all zeroes */ } 292 }; 293 294 MODULE_DEVICE_TABLE(pci, uhci_pci_ids); 295 296 static int uhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) 297 { 298 return usb_hcd_pci_probe(dev, &uhci_driver); 299 } 300 301 static struct pci_driver uhci_pci_driver = { 302 .name = hcd_name, 303 .id_table = uhci_pci_ids, 304 305 .probe = uhci_pci_probe, 306 .remove = usb_hcd_pci_remove, 307 .shutdown = uhci_shutdown, 308 309 #ifdef CONFIG_PM 310 .driver = { 311 .pm = &usb_hcd_pci_pm_ops 312 }, 313 #endif 314 }; 315 316 MODULE_SOFTDEP("pre: ehci_pci"); 317