1 /* 2 * (C) Copyright David Brownell 2000-2002 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License as published by the 6 * Free Software Foundation; either version 2 of the License, or (at your 7 * option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, but 10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 11 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software Foundation, 16 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 17 */ 18 19 #include <linux/kernel.h> 20 #include <linux/module.h> 21 #include <linux/pci.h> 22 #include <linux/pm_runtime.h> 23 #include <linux/usb.h> 24 #include <linux/usb/hcd.h> 25 26 #include <asm/io.h> 27 #include <asm/irq.h> 28 29 #ifdef CONFIG_PPC_PMAC 30 #include <asm/machdep.h> 31 #include <asm/pmac_feature.h> 32 #include <asm/pci-bridge.h> 33 #include <asm/prom.h> 34 #endif 35 36 #include "usb.h" 37 38 39 /* PCI-based HCs are common, but plenty of non-PCI HCs are used too */ 40 41 #ifdef CONFIG_PM_SLEEP 42 43 /* Coordinate handoffs between EHCI and companion controllers 44 * during system resume 45 */ 46 47 static DEFINE_MUTEX(companions_mutex); 48 49 #define CL_UHCI PCI_CLASS_SERIAL_USB_UHCI 50 #define CL_OHCI PCI_CLASS_SERIAL_USB_OHCI 51 #define CL_EHCI PCI_CLASS_SERIAL_USB_EHCI 52 53 enum companion_action { 54 SET_HS_COMPANION, CLEAR_HS_COMPANION, WAIT_FOR_COMPANIONS 55 }; 56 57 static void companion_common(struct pci_dev *pdev, struct usb_hcd *hcd, 58 enum companion_action action) 59 { 60 struct pci_dev *companion; 61 struct usb_hcd *companion_hcd; 62 unsigned int slot = PCI_SLOT(pdev->devfn); 63 64 /* Iterate through other PCI functions in the same slot. 65 * If pdev is OHCI or UHCI then we are looking for EHCI, and 66 * vice versa. 67 */ 68 companion = NULL; 69 for_each_pci_dev(companion) { 70 if (companion->bus != pdev->bus || 71 PCI_SLOT(companion->devfn) != slot) 72 continue; 73 74 companion_hcd = pci_get_drvdata(companion); 75 if (!companion_hcd) 76 continue; 77 78 /* For SET_HS_COMPANION, store a pointer to the EHCI bus in 79 * the OHCI/UHCI companion bus structure. 80 * For CLEAR_HS_COMPANION, clear the pointer to the EHCI bus 81 * in the OHCI/UHCI companion bus structure. 82 * For WAIT_FOR_COMPANIONS, wait until the OHCI/UHCI 83 * companion controllers have fully resumed. 84 */ 85 86 if ((pdev->class == CL_OHCI || pdev->class == CL_UHCI) && 87 companion->class == CL_EHCI) { 88 /* action must be SET_HS_COMPANION */ 89 dev_dbg(&companion->dev, "HS companion for %s\n", 90 dev_name(&pdev->dev)); 91 hcd->self.hs_companion = &companion_hcd->self; 92 93 } else if (pdev->class == CL_EHCI && 94 (companion->class == CL_OHCI || 95 companion->class == CL_UHCI)) { 96 switch (action) { 97 case SET_HS_COMPANION: 98 dev_dbg(&pdev->dev, "HS companion for %s\n", 99 dev_name(&companion->dev)); 100 companion_hcd->self.hs_companion = &hcd->self; 101 break; 102 case CLEAR_HS_COMPANION: 103 companion_hcd->self.hs_companion = NULL; 104 break; 105 case WAIT_FOR_COMPANIONS: 106 device_pm_wait_for_dev(&pdev->dev, 107 &companion->dev); 108 break; 109 } 110 } 111 } 112 } 113 114 static void set_hs_companion(struct pci_dev *pdev, struct usb_hcd *hcd) 115 { 116 mutex_lock(&companions_mutex); 117 dev_set_drvdata(&pdev->dev, hcd); 118 companion_common(pdev, hcd, SET_HS_COMPANION); 119 mutex_unlock(&companions_mutex); 120 } 121 122 static void clear_hs_companion(struct pci_dev *pdev, struct usb_hcd *hcd) 123 { 124 mutex_lock(&companions_mutex); 125 dev_set_drvdata(&pdev->dev, NULL); 126 127 /* If pdev is OHCI or UHCI, just clear its hs_companion pointer */ 128 if (pdev->class == CL_OHCI || pdev->class == CL_UHCI) 129 hcd->self.hs_companion = NULL; 130 131 /* Otherwise search for companion buses and clear their pointers */ 132 else 133 companion_common(pdev, hcd, CLEAR_HS_COMPANION); 134 mutex_unlock(&companions_mutex); 135 } 136 137 static void wait_for_companions(struct pci_dev *pdev, struct usb_hcd *hcd) 138 { 139 /* Only EHCI controllers need to wait. 140 * No locking is needed because a controller cannot be resumed 141 * while one of its companions is getting unbound. 142 */ 143 if (pdev->class == CL_EHCI) 144 companion_common(pdev, hcd, WAIT_FOR_COMPANIONS); 145 } 146 147 #else /* !CONFIG_PM_SLEEP */ 148 149 static inline void set_hs_companion(struct pci_dev *d, struct usb_hcd *h) {} 150 static inline void clear_hs_companion(struct pci_dev *d, struct usb_hcd *h) {} 151 static inline void wait_for_companions(struct pci_dev *d, struct usb_hcd *h) {} 152 153 #endif /* !CONFIG_PM_SLEEP */ 154 155 /*-------------------------------------------------------------------------*/ 156 157 /* configure so an HC device and id are always provided */ 158 /* always called with process context; sleeping is OK */ 159 160 /** 161 * usb_hcd_pci_probe - initialize PCI-based HCDs 162 * @dev: USB Host Controller being probed 163 * @id: pci hotplug id connecting controller to HCD framework 164 * Context: !in_interrupt() 165 * 166 * Allocates basic PCI resources for this USB host controller, and 167 * then invokes the start() method for the HCD associated with it 168 * through the hotplug entry's driver_data. 169 * 170 * Store this function in the HCD's struct pci_driver as probe(). 171 */ 172 int 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 178 if (usb_disabled()) 179 return -ENODEV; 180 181 if (!id) 182 return -EINVAL; 183 driver = (struct hc_driver *)id->driver_data; 184 if (!driver) 185 return -EINVAL; 186 187 if (pci_enable_device(dev) < 0) 188 return -ENODEV; 189 dev->current_state = PCI_D0; 190 191 if (!dev->irq) { 192 dev_err(&dev->dev, 193 "Found HC with no IRQ. Check BIOS/PCI %s setup!\n", 194 pci_name(dev)); 195 retval = -ENODEV; 196 goto err1; 197 } 198 199 hcd = usb_create_hcd(driver, &dev->dev, pci_name(dev)); 200 if (!hcd) { 201 retval = -ENOMEM; 202 goto err1; 203 } 204 205 if (driver->flags & HCD_MEMORY) { 206 /* EHCI, OHCI */ 207 hcd->rsrc_start = pci_resource_start(dev, 0); 208 hcd->rsrc_len = pci_resource_len(dev, 0); 209 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, 210 driver->description)) { 211 dev_dbg(&dev->dev, "controller already in use\n"); 212 retval = -EBUSY; 213 goto err2; 214 } 215 hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len); 216 if (hcd->regs == NULL) { 217 dev_dbg(&dev->dev, "error mapping memory\n"); 218 retval = -EFAULT; 219 goto err3; 220 } 221 222 } else { 223 /* UHCI */ 224 int region; 225 226 for (region = 0; region < PCI_ROM_RESOURCE; region++) { 227 if (!(pci_resource_flags(dev, region) & 228 IORESOURCE_IO)) 229 continue; 230 231 hcd->rsrc_start = pci_resource_start(dev, region); 232 hcd->rsrc_len = pci_resource_len(dev, region); 233 if (request_region(hcd->rsrc_start, hcd->rsrc_len, 234 driver->description)) 235 break; 236 } 237 if (region == PCI_ROM_RESOURCE) { 238 dev_dbg(&dev->dev, "no i/o regions available\n"); 239 retval = -EBUSY; 240 goto err2; 241 } 242 } 243 244 pci_set_master(dev); 245 246 retval = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED); 247 if (retval != 0) 248 goto err4; 249 set_hs_companion(dev, hcd); 250 251 if (pci_dev_run_wake(dev)) 252 pm_runtime_put_noidle(&dev->dev); 253 return retval; 254 255 err4: 256 if (driver->flags & HCD_MEMORY) { 257 iounmap(hcd->regs); 258 err3: 259 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 260 } else 261 release_region(hcd->rsrc_start, hcd->rsrc_len); 262 err2: 263 clear_hs_companion(dev, hcd); 264 usb_put_hcd(hcd); 265 err1: 266 pci_disable_device(dev); 267 dev_err(&dev->dev, "init %s fail, %d\n", pci_name(dev), retval); 268 return retval; 269 } 270 EXPORT_SYMBOL_GPL(usb_hcd_pci_probe); 271 272 273 /* may be called without controller electrically present */ 274 /* may be called with controller, bus, and devices active */ 275 276 /** 277 * usb_hcd_pci_remove - shutdown processing for PCI-based HCDs 278 * @dev: USB Host Controller being removed 279 * Context: !in_interrupt() 280 * 281 * Reverses the effect of usb_hcd_pci_probe(), first invoking 282 * the HCD's stop() method. It is always called from a thread 283 * context, normally "rmmod", "apmd", or something similar. 284 * 285 * Store this function in the HCD's struct pci_driver as remove(). 286 */ 287 void usb_hcd_pci_remove(struct pci_dev *dev) 288 { 289 struct usb_hcd *hcd; 290 291 hcd = pci_get_drvdata(dev); 292 if (!hcd) 293 return; 294 295 if (pci_dev_run_wake(dev)) 296 pm_runtime_get_noresume(&dev->dev); 297 298 /* Fake an interrupt request in order to give the driver a chance 299 * to test whether the controller hardware has been removed (e.g., 300 * cardbus physical eject). 301 */ 302 local_irq_disable(); 303 usb_hcd_irq(0, hcd); 304 local_irq_enable(); 305 306 usb_remove_hcd(hcd); 307 if (hcd->driver->flags & HCD_MEMORY) { 308 iounmap(hcd->regs); 309 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 310 } else { 311 release_region(hcd->rsrc_start, hcd->rsrc_len); 312 } 313 clear_hs_companion(dev, hcd); 314 usb_put_hcd(hcd); 315 pci_disable_device(dev); 316 } 317 EXPORT_SYMBOL_GPL(usb_hcd_pci_remove); 318 319 /** 320 * usb_hcd_pci_shutdown - shutdown host controller 321 * @dev: USB Host Controller being shutdown 322 */ 323 void usb_hcd_pci_shutdown(struct pci_dev *dev) 324 { 325 struct usb_hcd *hcd; 326 327 hcd = pci_get_drvdata(dev); 328 if (!hcd) 329 return; 330 331 if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) && 332 hcd->driver->shutdown) { 333 hcd->driver->shutdown(hcd); 334 pci_disable_device(dev); 335 } 336 } 337 EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown); 338 339 #ifdef CONFIG_PM_OPS 340 341 #ifdef CONFIG_PPC_PMAC 342 static void powermac_set_asic(struct pci_dev *pci_dev, int enable) 343 { 344 /* Enanble or disable ASIC clocks for USB */ 345 if (machine_is(powermac)) { 346 struct device_node *of_node; 347 348 of_node = pci_device_to_OF_node(pci_dev); 349 if (of_node) 350 pmac_call_feature(PMAC_FTR_USB_ENABLE, 351 of_node, 0, enable); 352 } 353 } 354 355 #else 356 357 static inline void powermac_set_asic(struct pci_dev *pci_dev, int enable) 358 {} 359 360 #endif /* CONFIG_PPC_PMAC */ 361 362 static int check_root_hub_suspended(struct device *dev) 363 { 364 struct pci_dev *pci_dev = to_pci_dev(dev); 365 struct usb_hcd *hcd = pci_get_drvdata(pci_dev); 366 367 if (!(hcd->state == HC_STATE_SUSPENDED || 368 hcd->state == HC_STATE_HALT)) { 369 dev_warn(dev, "Root hub is not suspended\n"); 370 return -EBUSY; 371 } 372 return 0; 373 } 374 375 static int suspend_common(struct device *dev, bool do_wakeup) 376 { 377 struct pci_dev *pci_dev = to_pci_dev(dev); 378 struct usb_hcd *hcd = pci_get_drvdata(pci_dev); 379 int retval; 380 381 /* Root hub suspend should have stopped all downstream traffic, 382 * and all bus master traffic. And done so for both the interface 383 * and the stub usb_device (which we check here). But maybe it 384 * didn't; writing sysfs power/state files ignores such rules... 385 */ 386 retval = check_root_hub_suspended(dev); 387 if (retval) 388 return retval; 389 390 if (hcd->driver->pci_suspend) { 391 /* Optimization: Don't suspend if a root-hub wakeup is 392 * pending and it would cause the HCD to wake up anyway. 393 */ 394 if (do_wakeup && HCD_WAKEUP_PENDING(hcd)) 395 return -EBUSY; 396 retval = hcd->driver->pci_suspend(hcd, do_wakeup); 397 suspend_report_result(hcd->driver->pci_suspend, retval); 398 399 /* Check again in case wakeup raced with pci_suspend */ 400 if (retval == 0 && do_wakeup && HCD_WAKEUP_PENDING(hcd)) { 401 if (hcd->driver->pci_resume) 402 hcd->driver->pci_resume(hcd, false); 403 retval = -EBUSY; 404 } 405 if (retval) 406 return retval; 407 } 408 409 synchronize_irq(pci_dev->irq); 410 411 /* Downstream ports from this root hub should already be quiesced, so 412 * there will be no DMA activity. Now we can shut down the upstream 413 * link (except maybe for PME# resume signaling). We'll enter a 414 * low power state during suspend_noirq, if the hardware allows. 415 */ 416 pci_disable_device(pci_dev); 417 return retval; 418 } 419 420 static int resume_common(struct device *dev, int event) 421 { 422 struct pci_dev *pci_dev = to_pci_dev(dev); 423 struct usb_hcd *hcd = pci_get_drvdata(pci_dev); 424 int retval; 425 426 if (hcd->state != HC_STATE_SUSPENDED) { 427 dev_dbg(dev, "can't resume, not suspended!\n"); 428 return 0; 429 } 430 431 retval = pci_enable_device(pci_dev); 432 if (retval < 0) { 433 dev_err(dev, "can't re-enable after resume, %d!\n", retval); 434 return retval; 435 } 436 437 pci_set_master(pci_dev); 438 439 clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags); 440 441 if (hcd->driver->pci_resume) { 442 if (event != PM_EVENT_AUTO_RESUME) 443 wait_for_companions(pci_dev, hcd); 444 445 retval = hcd->driver->pci_resume(hcd, 446 event == PM_EVENT_RESTORE); 447 if (retval) { 448 dev_err(dev, "PCI post-resume error %d!\n", retval); 449 usb_hc_died(hcd); 450 } 451 } 452 return retval; 453 } 454 455 #ifdef CONFIG_PM_SLEEP 456 457 static int hcd_pci_suspend(struct device *dev) 458 { 459 return suspend_common(dev, device_may_wakeup(dev)); 460 } 461 462 static int hcd_pci_suspend_noirq(struct device *dev) 463 { 464 struct pci_dev *pci_dev = to_pci_dev(dev); 465 struct usb_hcd *hcd = pci_get_drvdata(pci_dev); 466 int retval; 467 468 retval = check_root_hub_suspended(dev); 469 if (retval) 470 return retval; 471 472 pci_save_state(pci_dev); 473 474 /* If the root hub is HALTed rather than SUSPENDed, 475 * disallow remote wakeup. 476 */ 477 if (hcd->state == HC_STATE_HALT) 478 device_set_wakeup_enable(dev, 0); 479 dev_dbg(dev, "wakeup: %d\n", device_may_wakeup(dev)); 480 481 /* Possibly enable remote wakeup, 482 * choose the appropriate low-power state, and go to that state. 483 */ 484 retval = pci_prepare_to_sleep(pci_dev); 485 if (retval == -EIO) { /* Low-power not supported */ 486 dev_dbg(dev, "--> PCI D0 legacy\n"); 487 retval = 0; 488 } else if (retval == 0) { 489 dev_dbg(dev, "--> PCI %s\n", 490 pci_power_name(pci_dev->current_state)); 491 } else { 492 suspend_report_result(pci_prepare_to_sleep, retval); 493 return retval; 494 } 495 496 powermac_set_asic(pci_dev, 0); 497 return retval; 498 } 499 500 static int hcd_pci_resume_noirq(struct device *dev) 501 { 502 struct pci_dev *pci_dev = to_pci_dev(dev); 503 504 powermac_set_asic(pci_dev, 1); 505 506 /* Go back to D0 and disable remote wakeup */ 507 pci_back_from_sleep(pci_dev); 508 return 0; 509 } 510 511 static int hcd_pci_resume(struct device *dev) 512 { 513 return resume_common(dev, PM_EVENT_RESUME); 514 } 515 516 static int hcd_pci_restore(struct device *dev) 517 { 518 return resume_common(dev, PM_EVENT_RESTORE); 519 } 520 521 #else 522 523 #define hcd_pci_suspend NULL 524 #define hcd_pci_suspend_noirq NULL 525 #define hcd_pci_resume_noirq NULL 526 #define hcd_pci_resume NULL 527 #define hcd_pci_restore NULL 528 529 #endif /* CONFIG_PM_SLEEP */ 530 531 #ifdef CONFIG_PM_RUNTIME 532 533 static int hcd_pci_runtime_suspend(struct device *dev) 534 { 535 int retval; 536 537 retval = suspend_common(dev, true); 538 if (retval == 0) 539 powermac_set_asic(to_pci_dev(dev), 0); 540 dev_dbg(dev, "hcd_pci_runtime_suspend: %d\n", retval); 541 return retval; 542 } 543 544 static int hcd_pci_runtime_resume(struct device *dev) 545 { 546 int retval; 547 548 powermac_set_asic(to_pci_dev(dev), 1); 549 retval = resume_common(dev, PM_EVENT_AUTO_RESUME); 550 dev_dbg(dev, "hcd_pci_runtime_resume: %d\n", retval); 551 return retval; 552 } 553 554 #else 555 556 #define hcd_pci_runtime_suspend NULL 557 #define hcd_pci_runtime_resume NULL 558 559 #endif /* CONFIG_PM_RUNTIME */ 560 561 const struct dev_pm_ops usb_hcd_pci_pm_ops = { 562 .suspend = hcd_pci_suspend, 563 .suspend_noirq = hcd_pci_suspend_noirq, 564 .resume_noirq = hcd_pci_resume_noirq, 565 .resume = hcd_pci_resume, 566 .freeze = check_root_hub_suspended, 567 .freeze_noirq = check_root_hub_suspended, 568 .thaw_noirq = NULL, 569 .thaw = NULL, 570 .poweroff = hcd_pci_suspend, 571 .poweroff_noirq = hcd_pci_suspend_noirq, 572 .restore_noirq = hcd_pci_resume_noirq, 573 .restore = hcd_pci_restore, 574 .runtime_suspend = hcd_pci_runtime_suspend, 575 .runtime_resume = hcd_pci_runtime_resume, 576 }; 577 EXPORT_SYMBOL_GPL(usb_hcd_pci_pm_ops); 578 579 #endif /* CONFIG_PM_OPS */ 580