1 /* 2 * drivers/pci/pci-driver.c 3 * 4 * (C) Copyright 2002-2004, 2007 Greg Kroah-Hartman <greg@kroah.com> 5 * (C) Copyright 2007 Novell Inc. 6 * 7 * Released under the GPL v2 only. 8 * 9 */ 10 11 #include <linux/pci.h> 12 #include <linux/module.h> 13 #include <linux/init.h> 14 #include <linux/device.h> 15 #include <linux/mempolicy.h> 16 #include <linux/string.h> 17 #include <linux/slab.h> 18 #include <linux/sched.h> 19 #include <linux/cpu.h> 20 #include <linux/pm_runtime.h> 21 #include <linux/suspend.h> 22 #include "pci.h" 23 24 struct pci_dynid { 25 struct list_head node; 26 struct pci_device_id id; 27 }; 28 29 /** 30 * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices 31 * @drv: target pci driver 32 * @vendor: PCI vendor ID 33 * @device: PCI device ID 34 * @subvendor: PCI subvendor ID 35 * @subdevice: PCI subdevice ID 36 * @class: PCI class 37 * @class_mask: PCI class mask 38 * @driver_data: private driver data 39 * 40 * Adds a new dynamic pci device ID to this driver and causes the 41 * driver to probe for all devices again. @drv must have been 42 * registered prior to calling this function. 43 * 44 * CONTEXT: 45 * Does GFP_KERNEL allocation. 46 * 47 * RETURNS: 48 * 0 on success, -errno on failure. 49 */ 50 int pci_add_dynid(struct pci_driver *drv, 51 unsigned int vendor, unsigned int device, 52 unsigned int subvendor, unsigned int subdevice, 53 unsigned int class, unsigned int class_mask, 54 unsigned long driver_data) 55 { 56 struct pci_dynid *dynid; 57 int retval; 58 59 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); 60 if (!dynid) 61 return -ENOMEM; 62 63 dynid->id.vendor = vendor; 64 dynid->id.device = device; 65 dynid->id.subvendor = subvendor; 66 dynid->id.subdevice = subdevice; 67 dynid->id.class = class; 68 dynid->id.class_mask = class_mask; 69 dynid->id.driver_data = driver_data; 70 71 spin_lock(&drv->dynids.lock); 72 list_add_tail(&dynid->node, &drv->dynids.list); 73 spin_unlock(&drv->dynids.lock); 74 75 retval = driver_attach(&drv->driver); 76 77 return retval; 78 } 79 80 static void pci_free_dynids(struct pci_driver *drv) 81 { 82 struct pci_dynid *dynid, *n; 83 84 spin_lock(&drv->dynids.lock); 85 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) { 86 list_del(&dynid->node); 87 kfree(dynid); 88 } 89 spin_unlock(&drv->dynids.lock); 90 } 91 92 /** 93 * store_new_id - sysfs frontend to pci_add_dynid() 94 * @driver: target device driver 95 * @buf: buffer for scanning device ID data 96 * @count: input size 97 * 98 * Allow PCI IDs to be added to an existing driver via sysfs. 99 */ 100 static ssize_t 101 store_new_id(struct device_driver *driver, const char *buf, size_t count) 102 { 103 struct pci_driver *pdrv = to_pci_driver(driver); 104 const struct pci_device_id *ids = pdrv->id_table; 105 __u32 vendor, device, subvendor=PCI_ANY_ID, 106 subdevice=PCI_ANY_ID, class=0, class_mask=0; 107 unsigned long driver_data=0; 108 int fields=0; 109 int retval; 110 111 fields = sscanf(buf, "%x %x %x %x %x %x %lx", 112 &vendor, &device, &subvendor, &subdevice, 113 &class, &class_mask, &driver_data); 114 if (fields < 2) 115 return -EINVAL; 116 117 /* Only accept driver_data values that match an existing id_table 118 entry */ 119 if (ids) { 120 retval = -EINVAL; 121 while (ids->vendor || ids->subvendor || ids->class_mask) { 122 if (driver_data == ids->driver_data) { 123 retval = 0; 124 break; 125 } 126 ids++; 127 } 128 if (retval) /* No match */ 129 return retval; 130 } 131 132 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice, 133 class, class_mask, driver_data); 134 if (retval) 135 return retval; 136 return count; 137 } 138 139 /** 140 * store_remove_id - remove a PCI device ID from this driver 141 * @driver: target device driver 142 * @buf: buffer for scanning device ID data 143 * @count: input size 144 * 145 * Removes a dynamic pci device ID to this driver. 146 */ 147 static ssize_t 148 store_remove_id(struct device_driver *driver, const char *buf, size_t count) 149 { 150 struct pci_dynid *dynid, *n; 151 struct pci_driver *pdrv = to_pci_driver(driver); 152 __u32 vendor, device, subvendor = PCI_ANY_ID, 153 subdevice = PCI_ANY_ID, class = 0, class_mask = 0; 154 int fields = 0; 155 int retval = -ENODEV; 156 157 fields = sscanf(buf, "%x %x %x %x %x %x", 158 &vendor, &device, &subvendor, &subdevice, 159 &class, &class_mask); 160 if (fields < 2) 161 return -EINVAL; 162 163 spin_lock(&pdrv->dynids.lock); 164 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) { 165 struct pci_device_id *id = &dynid->id; 166 if ((id->vendor == vendor) && 167 (id->device == device) && 168 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) && 169 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) && 170 !((id->class ^ class) & class_mask)) { 171 list_del(&dynid->node); 172 kfree(dynid); 173 retval = 0; 174 break; 175 } 176 } 177 spin_unlock(&pdrv->dynids.lock); 178 179 if (retval) 180 return retval; 181 return count; 182 } 183 184 static struct driver_attribute pci_drv_attrs[] = { 185 __ATTR(new_id, S_IWUSR, NULL, store_new_id), 186 __ATTR(remove_id, S_IWUSR, NULL, store_remove_id), 187 __ATTR_NULL, 188 }; 189 190 /** 191 * pci_match_id - See if a pci device matches a given pci_id table 192 * @ids: array of PCI device id structures to search in 193 * @dev: the PCI device structure to match against. 194 * 195 * Used by a driver to check whether a PCI device present in the 196 * system is in its list of supported devices. Returns the matching 197 * pci_device_id structure or %NULL if there is no match. 198 * 199 * Deprecated, don't use this as it will not catch any dynamic ids 200 * that a driver might want to check for. 201 */ 202 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids, 203 struct pci_dev *dev) 204 { 205 if (ids) { 206 while (ids->vendor || ids->subvendor || ids->class_mask) { 207 if (pci_match_one_device(ids, dev)) 208 return ids; 209 ids++; 210 } 211 } 212 return NULL; 213 } 214 215 /** 216 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure 217 * @drv: the PCI driver to match against 218 * @dev: the PCI device structure to match against 219 * 220 * Used by a driver to check whether a PCI device present in the 221 * system is in its list of supported devices. Returns the matching 222 * pci_device_id structure or %NULL if there is no match. 223 */ 224 static const struct pci_device_id *pci_match_device(struct pci_driver *drv, 225 struct pci_dev *dev) 226 { 227 struct pci_dynid *dynid; 228 229 /* Look at the dynamic ids first, before the static ones */ 230 spin_lock(&drv->dynids.lock); 231 list_for_each_entry(dynid, &drv->dynids.list, node) { 232 if (pci_match_one_device(&dynid->id, dev)) { 233 spin_unlock(&drv->dynids.lock); 234 return &dynid->id; 235 } 236 } 237 spin_unlock(&drv->dynids.lock); 238 239 return pci_match_id(drv->id_table, dev); 240 } 241 242 struct drv_dev_and_id { 243 struct pci_driver *drv; 244 struct pci_dev *dev; 245 const struct pci_device_id *id; 246 }; 247 248 static long local_pci_probe(void *_ddi) 249 { 250 struct drv_dev_and_id *ddi = _ddi; 251 struct pci_dev *pci_dev = ddi->dev; 252 struct pci_driver *pci_drv = ddi->drv; 253 struct device *dev = &pci_dev->dev; 254 int rc; 255 256 /* 257 * Unbound PCI devices are always put in D0, regardless of 258 * runtime PM status. During probe, the device is set to 259 * active and the usage count is incremented. If the driver 260 * supports runtime PM, it should call pm_runtime_put_noidle() 261 * in its probe routine and pm_runtime_get_noresume() in its 262 * remove routine. 263 */ 264 pm_runtime_get_sync(dev); 265 pci_dev->driver = pci_drv; 266 rc = pci_drv->probe(pci_dev, ddi->id); 267 if (rc) { 268 pci_dev->driver = NULL; 269 pm_runtime_put_sync(dev); 270 } 271 return rc; 272 } 273 274 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev, 275 const struct pci_device_id *id) 276 { 277 int error, node; 278 struct drv_dev_and_id ddi = { drv, dev, id }; 279 280 /* Execute driver initialization on node where the device's 281 bus is attached to. This way the driver likely allocates 282 its local memory on the right node without any need to 283 change it. */ 284 node = dev_to_node(&dev->dev); 285 if (node >= 0) { 286 int cpu; 287 288 get_online_cpus(); 289 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask); 290 if (cpu < nr_cpu_ids) 291 error = work_on_cpu(cpu, local_pci_probe, &ddi); 292 else 293 error = local_pci_probe(&ddi); 294 put_online_cpus(); 295 } else 296 error = local_pci_probe(&ddi); 297 return error; 298 } 299 300 /** 301 * __pci_device_probe - check if a driver wants to claim a specific PCI device 302 * @drv: driver to call to check if it wants the PCI device 303 * @pci_dev: PCI device being probed 304 * 305 * returns 0 on success, else error. 306 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev. 307 */ 308 static int 309 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev) 310 { 311 const struct pci_device_id *id; 312 int error = 0; 313 314 if (!pci_dev->driver && drv->probe) { 315 error = -ENODEV; 316 317 id = pci_match_device(drv, pci_dev); 318 if (id) 319 error = pci_call_probe(drv, pci_dev, id); 320 if (error >= 0) 321 error = 0; 322 } 323 return error; 324 } 325 326 static int pci_device_probe(struct device * dev) 327 { 328 int error = 0; 329 struct pci_driver *drv; 330 struct pci_dev *pci_dev; 331 332 drv = to_pci_driver(dev->driver); 333 pci_dev = to_pci_dev(dev); 334 pci_dev_get(pci_dev); 335 error = __pci_device_probe(drv, pci_dev); 336 if (error) 337 pci_dev_put(pci_dev); 338 339 return error; 340 } 341 342 static int pci_device_remove(struct device * dev) 343 { 344 struct pci_dev * pci_dev = to_pci_dev(dev); 345 struct pci_driver * drv = pci_dev->driver; 346 347 if (drv) { 348 if (drv->remove) { 349 pm_runtime_get_sync(dev); 350 drv->remove(pci_dev); 351 pm_runtime_put_noidle(dev); 352 } 353 pci_dev->driver = NULL; 354 } 355 356 /* Undo the runtime PM settings in local_pci_probe() */ 357 pm_runtime_put_sync(dev); 358 359 /* 360 * If the device is still on, set the power state as "unknown", 361 * since it might change by the next time we load the driver. 362 */ 363 if (pci_dev->current_state == PCI_D0) 364 pci_dev->current_state = PCI_UNKNOWN; 365 366 /* 367 * We would love to complain here if pci_dev->is_enabled is set, that 368 * the driver should have called pci_disable_device(), but the 369 * unfortunate fact is there are too many odd BIOS and bridge setups 370 * that don't like drivers doing that all of the time. 371 * Oh well, we can dream of sane hardware when we sleep, no matter how 372 * horrible the crap we have to deal with is when we are awake... 373 */ 374 375 pci_dev_put(pci_dev); 376 return 0; 377 } 378 379 static void pci_device_shutdown(struct device *dev) 380 { 381 struct pci_dev *pci_dev = to_pci_dev(dev); 382 struct pci_driver *drv = pci_dev->driver; 383 384 pm_runtime_resume(dev); 385 386 if (drv && drv->shutdown) 387 drv->shutdown(pci_dev); 388 pci_msi_shutdown(pci_dev); 389 pci_msix_shutdown(pci_dev); 390 391 /* 392 * Turn off Bus Master bit on the device to tell it to not 393 * continue to do DMA. Don't touch devices in D3cold or unknown states. 394 */ 395 if (pci_dev->current_state <= PCI_D3hot) 396 pci_clear_master(pci_dev); 397 } 398 399 #ifdef CONFIG_PM 400 401 /* Auxiliary functions used for system resume and run-time resume. */ 402 403 /** 404 * pci_restore_standard_config - restore standard config registers of PCI device 405 * @pci_dev: PCI device to handle 406 */ 407 static int pci_restore_standard_config(struct pci_dev *pci_dev) 408 { 409 pci_update_current_state(pci_dev, PCI_UNKNOWN); 410 411 if (pci_dev->current_state != PCI_D0) { 412 int error = pci_set_power_state(pci_dev, PCI_D0); 413 if (error) 414 return error; 415 } 416 417 pci_restore_state(pci_dev); 418 return 0; 419 } 420 421 #endif 422 423 #ifdef CONFIG_PM_SLEEP 424 425 static void pci_pm_default_resume_early(struct pci_dev *pci_dev) 426 { 427 pci_power_up(pci_dev); 428 pci_restore_state(pci_dev); 429 pci_fixup_device(pci_fixup_resume_early, pci_dev); 430 } 431 432 /* 433 * Default "suspend" method for devices that have no driver provided suspend, 434 * or not even a driver at all (second part). 435 */ 436 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev) 437 { 438 /* 439 * mark its power state as "unknown", since we don't know if 440 * e.g. the BIOS will change its device state when we suspend. 441 */ 442 if (pci_dev->current_state == PCI_D0) 443 pci_dev->current_state = PCI_UNKNOWN; 444 } 445 446 /* 447 * Default "resume" method for devices that have no driver provided resume, 448 * or not even a driver at all (second part). 449 */ 450 static int pci_pm_reenable_device(struct pci_dev *pci_dev) 451 { 452 int retval; 453 454 /* if the device was enabled before suspend, reenable */ 455 retval = pci_reenable_device(pci_dev); 456 /* 457 * if the device was busmaster before the suspend, make it busmaster 458 * again 459 */ 460 if (pci_dev->is_busmaster) 461 pci_set_master(pci_dev); 462 463 return retval; 464 } 465 466 static int pci_legacy_suspend(struct device *dev, pm_message_t state) 467 { 468 struct pci_dev * pci_dev = to_pci_dev(dev); 469 struct pci_driver * drv = pci_dev->driver; 470 471 if (drv && drv->suspend) { 472 pci_power_t prev = pci_dev->current_state; 473 int error; 474 475 error = drv->suspend(pci_dev, state); 476 suspend_report_result(drv->suspend, error); 477 if (error) 478 return error; 479 480 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 481 && pci_dev->current_state != PCI_UNKNOWN) { 482 WARN_ONCE(pci_dev->current_state != prev, 483 "PCI PM: Device state not saved by %pF\n", 484 drv->suspend); 485 } 486 } 487 488 pci_fixup_device(pci_fixup_suspend, pci_dev); 489 490 return 0; 491 } 492 493 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state) 494 { 495 struct pci_dev * pci_dev = to_pci_dev(dev); 496 struct pci_driver * drv = pci_dev->driver; 497 498 if (drv && drv->suspend_late) { 499 pci_power_t prev = pci_dev->current_state; 500 int error; 501 502 error = drv->suspend_late(pci_dev, state); 503 suspend_report_result(drv->suspend_late, error); 504 if (error) 505 return error; 506 507 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 508 && pci_dev->current_state != PCI_UNKNOWN) { 509 WARN_ONCE(pci_dev->current_state != prev, 510 "PCI PM: Device state not saved by %pF\n", 511 drv->suspend_late); 512 return 0; 513 } 514 } 515 516 if (!pci_dev->state_saved) 517 pci_save_state(pci_dev); 518 519 pci_pm_set_unknown_state(pci_dev); 520 521 return 0; 522 } 523 524 static int pci_legacy_resume_early(struct device *dev) 525 { 526 struct pci_dev * pci_dev = to_pci_dev(dev); 527 struct pci_driver * drv = pci_dev->driver; 528 529 return drv && drv->resume_early ? 530 drv->resume_early(pci_dev) : 0; 531 } 532 533 static int pci_legacy_resume(struct device *dev) 534 { 535 struct pci_dev * pci_dev = to_pci_dev(dev); 536 struct pci_driver * drv = pci_dev->driver; 537 538 pci_fixup_device(pci_fixup_resume, pci_dev); 539 540 return drv && drv->resume ? 541 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev); 542 } 543 544 /* Auxiliary functions used by the new power management framework */ 545 546 static void pci_pm_default_resume(struct pci_dev *pci_dev) 547 { 548 pci_fixup_device(pci_fixup_resume, pci_dev); 549 550 if (!pci_is_bridge(pci_dev)) 551 pci_enable_wake(pci_dev, PCI_D0, false); 552 } 553 554 static void pci_pm_default_suspend(struct pci_dev *pci_dev) 555 { 556 /* Disable non-bridge devices without PM support */ 557 if (!pci_is_bridge(pci_dev)) 558 pci_disable_enabled_device(pci_dev); 559 } 560 561 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev) 562 { 563 struct pci_driver *drv = pci_dev->driver; 564 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume 565 || drv->resume_early); 566 567 /* 568 * Legacy PM support is used by default, so warn if the new framework is 569 * supported as well. Drivers are supposed to support either the 570 * former, or the latter, but not both at the same time. 571 */ 572 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n", 573 drv->name, pci_dev->vendor, pci_dev->device); 574 575 return ret; 576 } 577 578 /* New power management framework */ 579 580 static int pci_pm_prepare(struct device *dev) 581 { 582 struct device_driver *drv = dev->driver; 583 int error = 0; 584 585 /* 586 * PCI devices suspended at run time need to be resumed at this 587 * point, because in general it is necessary to reconfigure them for 588 * system suspend. Namely, if the device is supposed to wake up the 589 * system from the sleep state, we may need to reconfigure it for this 590 * purpose. In turn, if the device is not supposed to wake up the 591 * system from the sleep state, we'll have to prevent it from signaling 592 * wake-up. 593 */ 594 pm_runtime_resume(dev); 595 596 if (drv && drv->pm && drv->pm->prepare) 597 error = drv->pm->prepare(dev); 598 599 return error; 600 } 601 602 static void pci_pm_complete(struct device *dev) 603 { 604 struct device_driver *drv = dev->driver; 605 606 if (drv && drv->pm && drv->pm->complete) 607 drv->pm->complete(dev); 608 } 609 610 #else /* !CONFIG_PM_SLEEP */ 611 612 #define pci_pm_prepare NULL 613 #define pci_pm_complete NULL 614 615 #endif /* !CONFIG_PM_SLEEP */ 616 617 #ifdef CONFIG_SUSPEND 618 619 static int pci_pm_suspend(struct device *dev) 620 { 621 struct pci_dev *pci_dev = to_pci_dev(dev); 622 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 623 624 if (pci_has_legacy_pm_support(pci_dev)) 625 return pci_legacy_suspend(dev, PMSG_SUSPEND); 626 627 if (!pm) { 628 pci_pm_default_suspend(pci_dev); 629 goto Fixup; 630 } 631 632 pci_dev->state_saved = false; 633 if (pm->suspend) { 634 pci_power_t prev = pci_dev->current_state; 635 int error; 636 637 error = pm->suspend(dev); 638 suspend_report_result(pm->suspend, error); 639 if (error) 640 return error; 641 642 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 643 && pci_dev->current_state != PCI_UNKNOWN) { 644 WARN_ONCE(pci_dev->current_state != prev, 645 "PCI PM: State of device not saved by %pF\n", 646 pm->suspend); 647 } 648 } 649 650 Fixup: 651 pci_fixup_device(pci_fixup_suspend, pci_dev); 652 653 return 0; 654 } 655 656 static int pci_pm_suspend_noirq(struct device *dev) 657 { 658 struct pci_dev *pci_dev = to_pci_dev(dev); 659 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 660 661 if (pci_has_legacy_pm_support(pci_dev)) 662 return pci_legacy_suspend_late(dev, PMSG_SUSPEND); 663 664 if (!pm) { 665 pci_save_state(pci_dev); 666 return 0; 667 } 668 669 if (pm->suspend_noirq) { 670 pci_power_t prev = pci_dev->current_state; 671 int error; 672 673 error = pm->suspend_noirq(dev); 674 suspend_report_result(pm->suspend_noirq, error); 675 if (error) 676 return error; 677 678 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 679 && pci_dev->current_state != PCI_UNKNOWN) { 680 WARN_ONCE(pci_dev->current_state != prev, 681 "PCI PM: State of device not saved by %pF\n", 682 pm->suspend_noirq); 683 return 0; 684 } 685 } 686 687 if (!pci_dev->state_saved) { 688 pci_save_state(pci_dev); 689 if (!pci_is_bridge(pci_dev)) 690 pci_prepare_to_sleep(pci_dev); 691 } 692 693 pci_pm_set_unknown_state(pci_dev); 694 695 /* 696 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's 697 * PCI COMMAND register isn't 0, the BIOS assumes that the controller 698 * hasn't been quiesced and tries to turn it off. If the controller 699 * is already in D3, this can hang or cause memory corruption. 700 * 701 * Since the value of the COMMAND register doesn't matter once the 702 * device has been suspended, we can safely set it to 0 here. 703 */ 704 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI) 705 pci_write_config_word(pci_dev, PCI_COMMAND, 0); 706 707 return 0; 708 } 709 710 static int pci_pm_resume_noirq(struct device *dev) 711 { 712 struct pci_dev *pci_dev = to_pci_dev(dev); 713 struct device_driver *drv = dev->driver; 714 int error = 0; 715 716 pci_pm_default_resume_early(pci_dev); 717 718 if (pci_has_legacy_pm_support(pci_dev)) 719 return pci_legacy_resume_early(dev); 720 721 if (drv && drv->pm && drv->pm->resume_noirq) 722 error = drv->pm->resume_noirq(dev); 723 724 return error; 725 } 726 727 static int pci_pm_resume(struct device *dev) 728 { 729 struct pci_dev *pci_dev = to_pci_dev(dev); 730 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 731 int error = 0; 732 733 /* 734 * This is necessary for the suspend error path in which resume is 735 * called without restoring the standard config registers of the device. 736 */ 737 if (pci_dev->state_saved) 738 pci_restore_standard_config(pci_dev); 739 740 if (pci_has_legacy_pm_support(pci_dev)) 741 return pci_legacy_resume(dev); 742 743 pci_pm_default_resume(pci_dev); 744 745 if (pm) { 746 if (pm->resume) 747 error = pm->resume(dev); 748 } else { 749 pci_pm_reenable_device(pci_dev); 750 } 751 752 return error; 753 } 754 755 #else /* !CONFIG_SUSPEND */ 756 757 #define pci_pm_suspend NULL 758 #define pci_pm_suspend_noirq NULL 759 #define pci_pm_resume NULL 760 #define pci_pm_resume_noirq NULL 761 762 #endif /* !CONFIG_SUSPEND */ 763 764 #ifdef CONFIG_HIBERNATE_CALLBACKS 765 766 static int pci_pm_freeze(struct device *dev) 767 { 768 struct pci_dev *pci_dev = to_pci_dev(dev); 769 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 770 771 if (pci_has_legacy_pm_support(pci_dev)) 772 return pci_legacy_suspend(dev, PMSG_FREEZE); 773 774 if (!pm) { 775 pci_pm_default_suspend(pci_dev); 776 return 0; 777 } 778 779 pci_dev->state_saved = false; 780 if (pm->freeze) { 781 int error; 782 783 error = pm->freeze(dev); 784 suspend_report_result(pm->freeze, error); 785 if (error) 786 return error; 787 } 788 789 return 0; 790 } 791 792 static int pci_pm_freeze_noirq(struct device *dev) 793 { 794 struct pci_dev *pci_dev = to_pci_dev(dev); 795 struct device_driver *drv = dev->driver; 796 797 if (pci_has_legacy_pm_support(pci_dev)) 798 return pci_legacy_suspend_late(dev, PMSG_FREEZE); 799 800 if (drv && drv->pm && drv->pm->freeze_noirq) { 801 int error; 802 803 error = drv->pm->freeze_noirq(dev); 804 suspend_report_result(drv->pm->freeze_noirq, error); 805 if (error) 806 return error; 807 } 808 809 if (!pci_dev->state_saved) 810 pci_save_state(pci_dev); 811 812 pci_pm_set_unknown_state(pci_dev); 813 814 return 0; 815 } 816 817 static int pci_pm_thaw_noirq(struct device *dev) 818 { 819 struct pci_dev *pci_dev = to_pci_dev(dev); 820 struct device_driver *drv = dev->driver; 821 int error = 0; 822 823 if (pci_has_legacy_pm_support(pci_dev)) 824 return pci_legacy_resume_early(dev); 825 826 pci_update_current_state(pci_dev, PCI_D0); 827 828 if (drv && drv->pm && drv->pm->thaw_noirq) 829 error = drv->pm->thaw_noirq(dev); 830 831 return error; 832 } 833 834 static int pci_pm_thaw(struct device *dev) 835 { 836 struct pci_dev *pci_dev = to_pci_dev(dev); 837 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 838 int error = 0; 839 840 if (pci_has_legacy_pm_support(pci_dev)) 841 return pci_legacy_resume(dev); 842 843 if (pm) { 844 if (pm->thaw) 845 error = pm->thaw(dev); 846 } else { 847 pci_pm_reenable_device(pci_dev); 848 } 849 850 pci_dev->state_saved = false; 851 852 return error; 853 } 854 855 static int pci_pm_poweroff(struct device *dev) 856 { 857 struct pci_dev *pci_dev = to_pci_dev(dev); 858 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 859 860 if (pci_has_legacy_pm_support(pci_dev)) 861 return pci_legacy_suspend(dev, PMSG_HIBERNATE); 862 863 if (!pm) { 864 pci_pm_default_suspend(pci_dev); 865 goto Fixup; 866 } 867 868 pci_dev->state_saved = false; 869 if (pm->poweroff) { 870 int error; 871 872 error = pm->poweroff(dev); 873 suspend_report_result(pm->poweroff, error); 874 if (error) 875 return error; 876 } 877 878 Fixup: 879 pci_fixup_device(pci_fixup_suspend, pci_dev); 880 881 return 0; 882 } 883 884 static int pci_pm_poweroff_noirq(struct device *dev) 885 { 886 struct pci_dev *pci_dev = to_pci_dev(dev); 887 struct device_driver *drv = dev->driver; 888 889 if (pci_has_legacy_pm_support(to_pci_dev(dev))) 890 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE); 891 892 if (!drv || !drv->pm) 893 return 0; 894 895 if (drv->pm->poweroff_noirq) { 896 int error; 897 898 error = drv->pm->poweroff_noirq(dev); 899 suspend_report_result(drv->pm->poweroff_noirq, error); 900 if (error) 901 return error; 902 } 903 904 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev)) 905 pci_prepare_to_sleep(pci_dev); 906 907 /* 908 * The reason for doing this here is the same as for the analogous code 909 * in pci_pm_suspend_noirq(). 910 */ 911 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI) 912 pci_write_config_word(pci_dev, PCI_COMMAND, 0); 913 914 return 0; 915 } 916 917 static int pci_pm_restore_noirq(struct device *dev) 918 { 919 struct pci_dev *pci_dev = to_pci_dev(dev); 920 struct device_driver *drv = dev->driver; 921 int error = 0; 922 923 pci_pm_default_resume_early(pci_dev); 924 925 if (pci_has_legacy_pm_support(pci_dev)) 926 return pci_legacy_resume_early(dev); 927 928 if (drv && drv->pm && drv->pm->restore_noirq) 929 error = drv->pm->restore_noirq(dev); 930 931 return error; 932 } 933 934 static int pci_pm_restore(struct device *dev) 935 { 936 struct pci_dev *pci_dev = to_pci_dev(dev); 937 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 938 int error = 0; 939 940 /* 941 * This is necessary for the hibernation error path in which restore is 942 * called without restoring the standard config registers of the device. 943 */ 944 if (pci_dev->state_saved) 945 pci_restore_standard_config(pci_dev); 946 947 if (pci_has_legacy_pm_support(pci_dev)) 948 return pci_legacy_resume(dev); 949 950 pci_pm_default_resume(pci_dev); 951 952 if (pm) { 953 if (pm->restore) 954 error = pm->restore(dev); 955 } else { 956 pci_pm_reenable_device(pci_dev); 957 } 958 959 return error; 960 } 961 962 #else /* !CONFIG_HIBERNATE_CALLBACKS */ 963 964 #define pci_pm_freeze NULL 965 #define pci_pm_freeze_noirq NULL 966 #define pci_pm_thaw NULL 967 #define pci_pm_thaw_noirq NULL 968 #define pci_pm_poweroff NULL 969 #define pci_pm_poweroff_noirq NULL 970 #define pci_pm_restore NULL 971 #define pci_pm_restore_noirq NULL 972 973 #endif /* !CONFIG_HIBERNATE_CALLBACKS */ 974 975 #ifdef CONFIG_PM_RUNTIME 976 977 static int pci_pm_runtime_suspend(struct device *dev) 978 { 979 struct pci_dev *pci_dev = to_pci_dev(dev); 980 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 981 pci_power_t prev = pci_dev->current_state; 982 int error; 983 984 /* 985 * If pci_dev->driver is not set (unbound), the device should 986 * always remain in D0 regardless of the runtime PM status 987 */ 988 if (!pci_dev->driver) 989 return 0; 990 991 if (!pm || !pm->runtime_suspend) 992 return -ENOSYS; 993 994 pci_dev->state_saved = false; 995 pci_dev->no_d3cold = false; 996 error = pm->runtime_suspend(dev); 997 suspend_report_result(pm->runtime_suspend, error); 998 if (error) 999 return error; 1000 if (!pci_dev->d3cold_allowed) 1001 pci_dev->no_d3cold = true; 1002 1003 pci_fixup_device(pci_fixup_suspend, pci_dev); 1004 1005 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 1006 && pci_dev->current_state != PCI_UNKNOWN) { 1007 WARN_ONCE(pci_dev->current_state != prev, 1008 "PCI PM: State of device not saved by %pF\n", 1009 pm->runtime_suspend); 1010 return 0; 1011 } 1012 1013 if (!pci_dev->state_saved) { 1014 pci_save_state(pci_dev); 1015 pci_finish_runtime_suspend(pci_dev); 1016 } 1017 1018 return 0; 1019 } 1020 1021 static int pci_pm_runtime_resume(struct device *dev) 1022 { 1023 int rc; 1024 struct pci_dev *pci_dev = to_pci_dev(dev); 1025 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 1026 1027 /* 1028 * If pci_dev->driver is not set (unbound), the device should 1029 * always remain in D0 regardless of the runtime PM status 1030 */ 1031 if (!pci_dev->driver) 1032 return 0; 1033 1034 if (!pm || !pm->runtime_resume) 1035 return -ENOSYS; 1036 1037 pci_restore_standard_config(pci_dev); 1038 pci_fixup_device(pci_fixup_resume_early, pci_dev); 1039 __pci_enable_wake(pci_dev, PCI_D0, true, false); 1040 pci_fixup_device(pci_fixup_resume, pci_dev); 1041 1042 rc = pm->runtime_resume(dev); 1043 1044 pci_dev->runtime_d3cold = false; 1045 1046 return rc; 1047 } 1048 1049 static int pci_pm_runtime_idle(struct device *dev) 1050 { 1051 struct pci_dev *pci_dev = to_pci_dev(dev); 1052 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 1053 int ret = 0; 1054 1055 /* 1056 * If pci_dev->driver is not set (unbound), the device should 1057 * always remain in D0 regardless of the runtime PM status 1058 */ 1059 if (!pci_dev->driver) 1060 return 0; 1061 1062 if (!pm) 1063 return -ENOSYS; 1064 1065 if (pm->runtime_idle) 1066 ret = pm->runtime_idle(dev); 1067 1068 return ret; 1069 } 1070 1071 #else /* !CONFIG_PM_RUNTIME */ 1072 1073 #define pci_pm_runtime_suspend NULL 1074 #define pci_pm_runtime_resume NULL 1075 #define pci_pm_runtime_idle NULL 1076 1077 #endif /* !CONFIG_PM_RUNTIME */ 1078 1079 #ifdef CONFIG_PM 1080 1081 const struct dev_pm_ops pci_dev_pm_ops = { 1082 .prepare = pci_pm_prepare, 1083 .complete = pci_pm_complete, 1084 .suspend = pci_pm_suspend, 1085 .resume = pci_pm_resume, 1086 .freeze = pci_pm_freeze, 1087 .thaw = pci_pm_thaw, 1088 .poweroff = pci_pm_poweroff, 1089 .restore = pci_pm_restore, 1090 .suspend_noirq = pci_pm_suspend_noirq, 1091 .resume_noirq = pci_pm_resume_noirq, 1092 .freeze_noirq = pci_pm_freeze_noirq, 1093 .thaw_noirq = pci_pm_thaw_noirq, 1094 .poweroff_noirq = pci_pm_poweroff_noirq, 1095 .restore_noirq = pci_pm_restore_noirq, 1096 .runtime_suspend = pci_pm_runtime_suspend, 1097 .runtime_resume = pci_pm_runtime_resume, 1098 .runtime_idle = pci_pm_runtime_idle, 1099 }; 1100 1101 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops) 1102 1103 #else /* !COMFIG_PM_OPS */ 1104 1105 #define PCI_PM_OPS_PTR NULL 1106 1107 #endif /* !COMFIG_PM_OPS */ 1108 1109 /** 1110 * __pci_register_driver - register a new pci driver 1111 * @drv: the driver structure to register 1112 * @owner: owner module of drv 1113 * @mod_name: module name string 1114 * 1115 * Adds the driver structure to the list of registered drivers. 1116 * Returns a negative value on error, otherwise 0. 1117 * If no error occurred, the driver remains registered even if 1118 * no device was claimed during registration. 1119 */ 1120 int __pci_register_driver(struct pci_driver *drv, struct module *owner, 1121 const char *mod_name) 1122 { 1123 /* initialize common driver fields */ 1124 drv->driver.name = drv->name; 1125 drv->driver.bus = &pci_bus_type; 1126 drv->driver.owner = owner; 1127 drv->driver.mod_name = mod_name; 1128 1129 spin_lock_init(&drv->dynids.lock); 1130 INIT_LIST_HEAD(&drv->dynids.list); 1131 1132 /* register with core */ 1133 return driver_register(&drv->driver); 1134 } 1135 1136 /** 1137 * pci_unregister_driver - unregister a pci driver 1138 * @drv: the driver structure to unregister 1139 * 1140 * Deletes the driver structure from the list of registered PCI drivers, 1141 * gives it a chance to clean up by calling its remove() function for 1142 * each device it was responsible for, and marks those devices as 1143 * driverless. 1144 */ 1145 1146 void 1147 pci_unregister_driver(struct pci_driver *drv) 1148 { 1149 driver_unregister(&drv->driver); 1150 pci_free_dynids(drv); 1151 } 1152 1153 static struct pci_driver pci_compat_driver = { 1154 .name = "compat" 1155 }; 1156 1157 /** 1158 * pci_dev_driver - get the pci_driver of a device 1159 * @dev: the device to query 1160 * 1161 * Returns the appropriate pci_driver structure or %NULL if there is no 1162 * registered driver for the device. 1163 */ 1164 struct pci_driver * 1165 pci_dev_driver(const struct pci_dev *dev) 1166 { 1167 if (dev->driver) 1168 return dev->driver; 1169 else { 1170 int i; 1171 for(i=0; i<=PCI_ROM_RESOURCE; i++) 1172 if (dev->resource[i].flags & IORESOURCE_BUSY) 1173 return &pci_compat_driver; 1174 } 1175 return NULL; 1176 } 1177 1178 /** 1179 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure 1180 * @dev: the PCI device structure to match against 1181 * @drv: the device driver to search for matching PCI device id structures 1182 * 1183 * Used by a driver to check whether a PCI device present in the 1184 * system is in its list of supported devices. Returns the matching 1185 * pci_device_id structure or %NULL if there is no match. 1186 */ 1187 static int pci_bus_match(struct device *dev, struct device_driver *drv) 1188 { 1189 struct pci_dev *pci_dev = to_pci_dev(dev); 1190 struct pci_driver *pci_drv; 1191 const struct pci_device_id *found_id; 1192 1193 if (!pci_dev->match_driver) 1194 return 0; 1195 1196 pci_drv = to_pci_driver(drv); 1197 found_id = pci_match_device(pci_drv, pci_dev); 1198 if (found_id) 1199 return 1; 1200 1201 return 0; 1202 } 1203 1204 /** 1205 * pci_dev_get - increments the reference count of the pci device structure 1206 * @dev: the device being referenced 1207 * 1208 * Each live reference to a device should be refcounted. 1209 * 1210 * Drivers for PCI devices should normally record such references in 1211 * their probe() methods, when they bind to a device, and release 1212 * them by calling pci_dev_put(), in their disconnect() methods. 1213 * 1214 * A pointer to the device with the incremented reference counter is returned. 1215 */ 1216 struct pci_dev *pci_dev_get(struct pci_dev *dev) 1217 { 1218 if (dev) 1219 get_device(&dev->dev); 1220 return dev; 1221 } 1222 1223 /** 1224 * pci_dev_put - release a use of the pci device structure 1225 * @dev: device that's been disconnected 1226 * 1227 * Must be called when a user of a device is finished with it. When the last 1228 * user of the device calls this function, the memory of the device is freed. 1229 */ 1230 void pci_dev_put(struct pci_dev *dev) 1231 { 1232 if (dev) 1233 put_device(&dev->dev); 1234 } 1235 1236 static int pci_uevent(struct device *dev, struct kobj_uevent_env *env) 1237 { 1238 struct pci_dev *pdev; 1239 1240 if (!dev) 1241 return -ENODEV; 1242 1243 pdev = to_pci_dev(dev); 1244 if (!pdev) 1245 return -ENODEV; 1246 1247 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class)) 1248 return -ENOMEM; 1249 1250 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device)) 1251 return -ENOMEM; 1252 1253 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor, 1254 pdev->subsystem_device)) 1255 return -ENOMEM; 1256 1257 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev))) 1258 return -ENOMEM; 1259 1260 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x", 1261 pdev->vendor, pdev->device, 1262 pdev->subsystem_vendor, pdev->subsystem_device, 1263 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8), 1264 (u8)(pdev->class))) 1265 return -ENOMEM; 1266 return 0; 1267 } 1268 1269 struct bus_type pci_bus_type = { 1270 .name = "pci", 1271 .match = pci_bus_match, 1272 .uevent = pci_uevent, 1273 .probe = pci_device_probe, 1274 .remove = pci_device_remove, 1275 .shutdown = pci_device_shutdown, 1276 .dev_attrs = pci_dev_attrs, 1277 .bus_attrs = pci_bus_attrs, 1278 .drv_attrs = pci_drv_attrs, 1279 .pm = PCI_PM_OPS_PTR, 1280 }; 1281 1282 static int __init pci_driver_init(void) 1283 { 1284 return bus_register(&pci_bus_type); 1285 } 1286 1287 postcore_initcall(pci_driver_init); 1288 1289 EXPORT_SYMBOL_GPL(pci_add_dynid); 1290 EXPORT_SYMBOL(pci_match_id); 1291 EXPORT_SYMBOL(__pci_register_driver); 1292 EXPORT_SYMBOL(pci_unregister_driver); 1293 EXPORT_SYMBOL(pci_dev_driver); 1294 EXPORT_SYMBOL(pci_bus_type); 1295 EXPORT_SYMBOL(pci_dev_get); 1296 EXPORT_SYMBOL(pci_dev_put); 1297