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