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