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 * 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 */ 104 static ssize_t 105 store_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 } 142 static 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 */ 152 static ssize_t 153 store_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 } 188 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id); 189 190 static int 191 pci_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 208 static 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 */ 214 static inline int pci_create_newid_files(struct pci_driver *drv) 215 { 216 return 0; 217 } 218 static 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 */ 233 const 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 */ 255 static 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 273 struct drv_dev_and_id { 274 struct pci_driver *drv; 275 struct pci_dev *dev; 276 const struct pci_device_id *id; 277 }; 278 279 static 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 304 static 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 */ 338 static 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 358 static 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 374 static 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 413 static 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 #ifdef CONFIG_PM 425 426 /* Auxiliary functions used for system resume and run-time resume. */ 427 428 /** 429 * pci_restore_standard_config - restore standard config registers of PCI device 430 * @pci_dev: PCI device to handle 431 */ 432 static int pci_restore_standard_config(struct pci_dev *pci_dev) 433 { 434 pci_update_current_state(pci_dev, PCI_UNKNOWN); 435 436 if (pci_dev->current_state != PCI_D0) { 437 int error = pci_set_power_state(pci_dev, PCI_D0); 438 if (error) 439 return error; 440 } 441 442 pci_restore_state(pci_dev); 443 return 0; 444 } 445 446 static void pci_pm_default_resume_early(struct pci_dev *pci_dev) 447 { 448 pci_restore_standard_config(pci_dev); 449 pci_fixup_device(pci_fixup_resume_early, pci_dev); 450 } 451 452 #endif 453 454 #ifdef CONFIG_PM_SLEEP 455 456 /* 457 * Default "suspend" method for devices that have no driver provided suspend, 458 * or not even a driver at all (second part). 459 */ 460 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev) 461 { 462 /* 463 * mark its power state as "unknown", since we don't know if 464 * e.g. the BIOS will change its device state when we suspend. 465 */ 466 if (pci_dev->current_state == PCI_D0) 467 pci_dev->current_state = PCI_UNKNOWN; 468 } 469 470 /* 471 * Default "resume" method for devices that have no driver provided resume, 472 * or not even a driver at all (second part). 473 */ 474 static int pci_pm_reenable_device(struct pci_dev *pci_dev) 475 { 476 int retval; 477 478 /* if the device was enabled before suspend, reenable */ 479 retval = pci_reenable_device(pci_dev); 480 /* 481 * if the device was busmaster before the suspend, make it busmaster 482 * again 483 */ 484 if (pci_dev->is_busmaster) 485 pci_set_master(pci_dev); 486 487 return retval; 488 } 489 490 static int pci_legacy_suspend(struct device *dev, pm_message_t state) 491 { 492 struct pci_dev * pci_dev = to_pci_dev(dev); 493 struct pci_driver * drv = pci_dev->driver; 494 495 if (drv && drv->suspend) { 496 pci_power_t prev = pci_dev->current_state; 497 int error; 498 499 error = drv->suspend(pci_dev, state); 500 suspend_report_result(drv->suspend, error); 501 if (error) 502 return error; 503 504 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 505 && pci_dev->current_state != PCI_UNKNOWN) { 506 WARN_ONCE(pci_dev->current_state != prev, 507 "PCI PM: Device state not saved by %pF\n", 508 drv->suspend); 509 } 510 } 511 512 pci_fixup_device(pci_fixup_suspend, pci_dev); 513 514 return 0; 515 } 516 517 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state) 518 { 519 struct pci_dev * pci_dev = to_pci_dev(dev); 520 struct pci_driver * drv = pci_dev->driver; 521 522 if (drv && drv->suspend_late) { 523 pci_power_t prev = pci_dev->current_state; 524 int error; 525 526 error = drv->suspend_late(pci_dev, state); 527 suspend_report_result(drv->suspend_late, error); 528 if (error) 529 return error; 530 531 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 532 && pci_dev->current_state != PCI_UNKNOWN) { 533 WARN_ONCE(pci_dev->current_state != prev, 534 "PCI PM: Device state not saved by %pF\n", 535 drv->suspend_late); 536 return 0; 537 } 538 } 539 540 if (!pci_dev->state_saved) 541 pci_save_state(pci_dev); 542 543 pci_pm_set_unknown_state(pci_dev); 544 545 return 0; 546 } 547 548 static int pci_legacy_resume_early(struct device *dev) 549 { 550 struct pci_dev * pci_dev = to_pci_dev(dev); 551 struct pci_driver * drv = pci_dev->driver; 552 553 return drv && drv->resume_early ? 554 drv->resume_early(pci_dev) : 0; 555 } 556 557 static int pci_legacy_resume(struct device *dev) 558 { 559 struct pci_dev * pci_dev = to_pci_dev(dev); 560 struct pci_driver * drv = pci_dev->driver; 561 562 pci_fixup_device(pci_fixup_resume, pci_dev); 563 564 return drv && drv->resume ? 565 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev); 566 } 567 568 /* Auxiliary functions used by the new power management framework */ 569 570 static void pci_pm_default_resume(struct pci_dev *pci_dev) 571 { 572 pci_fixup_device(pci_fixup_resume, pci_dev); 573 574 if (!pci_is_bridge(pci_dev)) 575 pci_enable_wake(pci_dev, PCI_D0, false); 576 } 577 578 static void pci_pm_default_suspend(struct pci_dev *pci_dev) 579 { 580 /* Disable non-bridge devices without PM support */ 581 if (!pci_is_bridge(pci_dev)) 582 pci_disable_enabled_device(pci_dev); 583 } 584 585 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev) 586 { 587 struct pci_driver *drv = pci_dev->driver; 588 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume 589 || drv->resume_early); 590 591 /* 592 * Legacy PM support is used by default, so warn if the new framework is 593 * supported as well. Drivers are supposed to support either the 594 * former, or the latter, but not both at the same time. 595 */ 596 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n", 597 drv->name, pci_dev->vendor, pci_dev->device); 598 599 return ret; 600 } 601 602 /* New power management framework */ 603 604 static int pci_pm_prepare(struct device *dev) 605 { 606 struct device_driver *drv = dev->driver; 607 int error = 0; 608 609 /* 610 * If a PCI device configured to wake up the system from sleep states 611 * has been suspended at run time and there's a resume request pending 612 * for it, this is equivalent to the device signaling wakeup, so the 613 * system suspend operation should be aborted. 614 */ 615 pm_runtime_get_noresume(dev); 616 if (pm_runtime_barrier(dev) && device_may_wakeup(dev)) 617 pm_wakeup_event(dev, 0); 618 619 if (pm_wakeup_pending()) { 620 pm_runtime_put_sync(dev); 621 return -EBUSY; 622 } 623 624 /* 625 * PCI devices suspended at run time need to be resumed at this 626 * point, because in general it is necessary to reconfigure them for 627 * system suspend. Namely, if the device is supposed to wake up the 628 * system from the sleep state, we may need to reconfigure it for this 629 * purpose. In turn, if the device is not supposed to wake up the 630 * system from the sleep state, we'll have to prevent it from signaling 631 * wake-up. 632 */ 633 pm_runtime_resume(dev); 634 635 if (drv && drv->pm && drv->pm->prepare) 636 error = drv->pm->prepare(dev); 637 638 return error; 639 } 640 641 static void pci_pm_complete(struct device *dev) 642 { 643 struct device_driver *drv = dev->driver; 644 645 if (drv && drv->pm && drv->pm->complete) 646 drv->pm->complete(dev); 647 648 pm_runtime_put_sync(dev); 649 } 650 651 #else /* !CONFIG_PM_SLEEP */ 652 653 #define pci_pm_prepare NULL 654 #define pci_pm_complete NULL 655 656 #endif /* !CONFIG_PM_SLEEP */ 657 658 #ifdef CONFIG_SUSPEND 659 660 static int pci_pm_suspend(struct device *dev) 661 { 662 struct pci_dev *pci_dev = to_pci_dev(dev); 663 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 664 665 if (pci_has_legacy_pm_support(pci_dev)) 666 return pci_legacy_suspend(dev, PMSG_SUSPEND); 667 668 if (!pm) { 669 pci_pm_default_suspend(pci_dev); 670 goto Fixup; 671 } 672 673 if (pm->suspend) { 674 pci_power_t prev = pci_dev->current_state; 675 int error; 676 677 error = pm->suspend(dev); 678 suspend_report_result(pm->suspend, error); 679 if (error) 680 return error; 681 682 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 683 && pci_dev->current_state != PCI_UNKNOWN) { 684 WARN_ONCE(pci_dev->current_state != prev, 685 "PCI PM: State of device not saved by %pF\n", 686 pm->suspend); 687 } 688 } 689 690 Fixup: 691 pci_fixup_device(pci_fixup_suspend, pci_dev); 692 693 return 0; 694 } 695 696 static int pci_pm_suspend_noirq(struct device *dev) 697 { 698 struct pci_dev *pci_dev = to_pci_dev(dev); 699 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 700 701 if (pci_has_legacy_pm_support(pci_dev)) 702 return pci_legacy_suspend_late(dev, PMSG_SUSPEND); 703 704 if (!pm) { 705 pci_save_state(pci_dev); 706 return 0; 707 } 708 709 if (pm->suspend_noirq) { 710 pci_power_t prev = pci_dev->current_state; 711 int error; 712 713 error = pm->suspend_noirq(dev); 714 suspend_report_result(pm->suspend_noirq, error); 715 if (error) 716 return error; 717 718 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 719 && pci_dev->current_state != PCI_UNKNOWN) { 720 WARN_ONCE(pci_dev->current_state != prev, 721 "PCI PM: State of device not saved by %pF\n", 722 pm->suspend_noirq); 723 return 0; 724 } 725 } 726 727 if (!pci_dev->state_saved) { 728 pci_save_state(pci_dev); 729 if (!pci_is_bridge(pci_dev)) 730 pci_prepare_to_sleep(pci_dev); 731 } 732 733 pci_pm_set_unknown_state(pci_dev); 734 735 return 0; 736 } 737 738 static int pci_pm_resume_noirq(struct device *dev) 739 { 740 struct pci_dev *pci_dev = to_pci_dev(dev); 741 struct device_driver *drv = dev->driver; 742 int error = 0; 743 744 pci_pm_default_resume_early(pci_dev); 745 746 if (pci_has_legacy_pm_support(pci_dev)) 747 return pci_legacy_resume_early(dev); 748 749 if (drv && drv->pm && drv->pm->resume_noirq) 750 error = drv->pm->resume_noirq(dev); 751 752 return error; 753 } 754 755 static int pci_pm_resume(struct device *dev) 756 { 757 struct pci_dev *pci_dev = to_pci_dev(dev); 758 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 759 int error = 0; 760 761 /* 762 * This is necessary for the suspend error path in which resume is 763 * called without restoring the standard config registers of the device. 764 */ 765 if (pci_dev->state_saved) 766 pci_restore_standard_config(pci_dev); 767 768 if (pci_has_legacy_pm_support(pci_dev)) 769 return pci_legacy_resume(dev); 770 771 pci_pm_default_resume(pci_dev); 772 773 if (pm) { 774 if (pm->resume) 775 error = pm->resume(dev); 776 } else { 777 pci_pm_reenable_device(pci_dev); 778 } 779 780 return error; 781 } 782 783 #else /* !CONFIG_SUSPEND */ 784 785 #define pci_pm_suspend NULL 786 #define pci_pm_suspend_noirq NULL 787 #define pci_pm_resume NULL 788 #define pci_pm_resume_noirq NULL 789 790 #endif /* !CONFIG_SUSPEND */ 791 792 #ifdef CONFIG_HIBERNATE_CALLBACKS 793 794 static int pci_pm_freeze(struct device *dev) 795 { 796 struct pci_dev *pci_dev = to_pci_dev(dev); 797 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 798 799 if (pci_has_legacy_pm_support(pci_dev)) 800 return pci_legacy_suspend(dev, PMSG_FREEZE); 801 802 if (!pm) { 803 pci_pm_default_suspend(pci_dev); 804 return 0; 805 } 806 807 if (pm->freeze) { 808 int error; 809 810 error = pm->freeze(dev); 811 suspend_report_result(pm->freeze, error); 812 if (error) 813 return error; 814 } 815 816 return 0; 817 } 818 819 static int pci_pm_freeze_noirq(struct device *dev) 820 { 821 struct pci_dev *pci_dev = to_pci_dev(dev); 822 struct device_driver *drv = dev->driver; 823 824 if (pci_has_legacy_pm_support(pci_dev)) 825 return pci_legacy_suspend_late(dev, PMSG_FREEZE); 826 827 if (drv && drv->pm && drv->pm->freeze_noirq) { 828 int error; 829 830 error = drv->pm->freeze_noirq(dev); 831 suspend_report_result(drv->pm->freeze_noirq, error); 832 if (error) 833 return error; 834 } 835 836 if (!pci_dev->state_saved) 837 pci_save_state(pci_dev); 838 839 pci_pm_set_unknown_state(pci_dev); 840 841 return 0; 842 } 843 844 static int pci_pm_thaw_noirq(struct device *dev) 845 { 846 struct pci_dev *pci_dev = to_pci_dev(dev); 847 struct device_driver *drv = dev->driver; 848 int error = 0; 849 850 if (pci_has_legacy_pm_support(pci_dev)) 851 return pci_legacy_resume_early(dev); 852 853 pci_update_current_state(pci_dev, PCI_D0); 854 855 if (drv && drv->pm && drv->pm->thaw_noirq) 856 error = drv->pm->thaw_noirq(dev); 857 858 return error; 859 } 860 861 static int pci_pm_thaw(struct device *dev) 862 { 863 struct pci_dev *pci_dev = to_pci_dev(dev); 864 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 865 int error = 0; 866 867 if (pci_has_legacy_pm_support(pci_dev)) 868 return pci_legacy_resume(dev); 869 870 if (pm) { 871 if (pm->thaw) 872 error = pm->thaw(dev); 873 } else { 874 pci_pm_reenable_device(pci_dev); 875 } 876 877 pci_dev->state_saved = false; 878 879 return error; 880 } 881 882 static int pci_pm_poweroff(struct device *dev) 883 { 884 struct pci_dev *pci_dev = to_pci_dev(dev); 885 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 886 887 if (pci_has_legacy_pm_support(pci_dev)) 888 return pci_legacy_suspend(dev, PMSG_HIBERNATE); 889 890 if (!pm) { 891 pci_pm_default_suspend(pci_dev); 892 goto Fixup; 893 } 894 895 if (pm->poweroff) { 896 int error; 897 898 error = pm->poweroff(dev); 899 suspend_report_result(pm->poweroff, error); 900 if (error) 901 return error; 902 } 903 904 Fixup: 905 pci_fixup_device(pci_fixup_suspend, pci_dev); 906 907 return 0; 908 } 909 910 static int pci_pm_poweroff_noirq(struct device *dev) 911 { 912 struct pci_dev *pci_dev = to_pci_dev(dev); 913 struct device_driver *drv = dev->driver; 914 915 if (pci_has_legacy_pm_support(to_pci_dev(dev))) 916 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE); 917 918 if (!drv || !drv->pm) 919 return 0; 920 921 if (drv->pm->poweroff_noirq) { 922 int error; 923 924 error = drv->pm->poweroff_noirq(dev); 925 suspend_report_result(drv->pm->poweroff_noirq, error); 926 if (error) 927 return error; 928 } 929 930 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev)) 931 pci_prepare_to_sleep(pci_dev); 932 933 return 0; 934 } 935 936 static int pci_pm_restore_noirq(struct device *dev) 937 { 938 struct pci_dev *pci_dev = to_pci_dev(dev); 939 struct device_driver *drv = dev->driver; 940 int error = 0; 941 942 pci_pm_default_resume_early(pci_dev); 943 944 if (pci_has_legacy_pm_support(pci_dev)) 945 return pci_legacy_resume_early(dev); 946 947 if (drv && drv->pm && drv->pm->restore_noirq) 948 error = drv->pm->restore_noirq(dev); 949 950 return error; 951 } 952 953 static int pci_pm_restore(struct device *dev) 954 { 955 struct pci_dev *pci_dev = to_pci_dev(dev); 956 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 957 int error = 0; 958 959 /* 960 * This is necessary for the hibernation error path in which restore is 961 * called without restoring the standard config registers of the device. 962 */ 963 if (pci_dev->state_saved) 964 pci_restore_standard_config(pci_dev); 965 966 if (pci_has_legacy_pm_support(pci_dev)) 967 return pci_legacy_resume(dev); 968 969 pci_pm_default_resume(pci_dev); 970 971 if (pm) { 972 if (pm->restore) 973 error = pm->restore(dev); 974 } else { 975 pci_pm_reenable_device(pci_dev); 976 } 977 978 return error; 979 } 980 981 #else /* !CONFIG_HIBERNATE_CALLBACKS */ 982 983 #define pci_pm_freeze NULL 984 #define pci_pm_freeze_noirq NULL 985 #define pci_pm_thaw NULL 986 #define pci_pm_thaw_noirq NULL 987 #define pci_pm_poweroff NULL 988 #define pci_pm_poweroff_noirq NULL 989 #define pci_pm_restore NULL 990 #define pci_pm_restore_noirq NULL 991 992 #endif /* !CONFIG_HIBERNATE_CALLBACKS */ 993 994 #ifdef CONFIG_PM_RUNTIME 995 996 static int pci_pm_runtime_suspend(struct device *dev) 997 { 998 struct pci_dev *pci_dev = to_pci_dev(dev); 999 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 1000 pci_power_t prev = pci_dev->current_state; 1001 int error; 1002 1003 if (!pm || !pm->runtime_suspend) 1004 return -ENOSYS; 1005 1006 error = pm->runtime_suspend(dev); 1007 suspend_report_result(pm->runtime_suspend, error); 1008 if (error) 1009 return error; 1010 1011 pci_fixup_device(pci_fixup_suspend, pci_dev); 1012 1013 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0 1014 && pci_dev->current_state != PCI_UNKNOWN) { 1015 WARN_ONCE(pci_dev->current_state != prev, 1016 "PCI PM: State of device not saved by %pF\n", 1017 pm->runtime_suspend); 1018 return 0; 1019 } 1020 1021 if (!pci_dev->state_saved) 1022 pci_save_state(pci_dev); 1023 1024 pci_finish_runtime_suspend(pci_dev); 1025 1026 return 0; 1027 } 1028 1029 static int pci_pm_runtime_resume(struct device *dev) 1030 { 1031 struct pci_dev *pci_dev = to_pci_dev(dev); 1032 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 1033 1034 if (!pm || !pm->runtime_resume) 1035 return -ENOSYS; 1036 1037 pci_pm_default_resume_early(pci_dev); 1038 __pci_enable_wake(pci_dev, PCI_D0, true, false); 1039 pci_fixup_device(pci_fixup_resume, pci_dev); 1040 1041 return pm->runtime_resume(dev); 1042 } 1043 1044 static int pci_pm_runtime_idle(struct device *dev) 1045 { 1046 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 1047 1048 if (!pm) 1049 return -ENOSYS; 1050 1051 if (pm->runtime_idle) { 1052 int ret = pm->runtime_idle(dev); 1053 if (ret) 1054 return ret; 1055 } 1056 1057 pm_runtime_suspend(dev); 1058 1059 return 0; 1060 } 1061 1062 #else /* !CONFIG_PM_RUNTIME */ 1063 1064 #define pci_pm_runtime_suspend NULL 1065 #define pci_pm_runtime_resume NULL 1066 #define pci_pm_runtime_idle NULL 1067 1068 #endif /* !CONFIG_PM_RUNTIME */ 1069 1070 #ifdef CONFIG_PM 1071 1072 const struct dev_pm_ops pci_dev_pm_ops = { 1073 .prepare = pci_pm_prepare, 1074 .complete = pci_pm_complete, 1075 .suspend = pci_pm_suspend, 1076 .resume = pci_pm_resume, 1077 .freeze = pci_pm_freeze, 1078 .thaw = pci_pm_thaw, 1079 .poweroff = pci_pm_poweroff, 1080 .restore = pci_pm_restore, 1081 .suspend_noirq = pci_pm_suspend_noirq, 1082 .resume_noirq = pci_pm_resume_noirq, 1083 .freeze_noirq = pci_pm_freeze_noirq, 1084 .thaw_noirq = pci_pm_thaw_noirq, 1085 .poweroff_noirq = pci_pm_poweroff_noirq, 1086 .restore_noirq = pci_pm_restore_noirq, 1087 .runtime_suspend = pci_pm_runtime_suspend, 1088 .runtime_resume = pci_pm_runtime_resume, 1089 .runtime_idle = pci_pm_runtime_idle, 1090 }; 1091 1092 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops) 1093 1094 #else /* !COMFIG_PM_OPS */ 1095 1096 #define PCI_PM_OPS_PTR NULL 1097 1098 #endif /* !COMFIG_PM_OPS */ 1099 1100 /** 1101 * __pci_register_driver - register a new pci driver 1102 * @drv: the driver structure to register 1103 * @owner: owner module of drv 1104 * @mod_name: module name string 1105 * 1106 * Adds the driver structure to the list of registered drivers. 1107 * Returns a negative value on error, otherwise 0. 1108 * If no error occurred, the driver remains registered even if 1109 * no device was claimed during registration. 1110 */ 1111 int __pci_register_driver(struct pci_driver *drv, struct module *owner, 1112 const char *mod_name) 1113 { 1114 int error; 1115 1116 /* initialize common driver fields */ 1117 drv->driver.name = drv->name; 1118 drv->driver.bus = &pci_bus_type; 1119 drv->driver.owner = owner; 1120 drv->driver.mod_name = mod_name; 1121 1122 spin_lock_init(&drv->dynids.lock); 1123 INIT_LIST_HEAD(&drv->dynids.list); 1124 1125 /* register with core */ 1126 error = driver_register(&drv->driver); 1127 if (error) 1128 goto out; 1129 1130 error = pci_create_newid_files(drv); 1131 if (error) 1132 goto out_newid; 1133 out: 1134 return error; 1135 1136 out_newid: 1137 driver_unregister(&drv->driver); 1138 goto out; 1139 } 1140 1141 /** 1142 * pci_unregister_driver - unregister a pci driver 1143 * @drv: the driver structure to unregister 1144 * 1145 * Deletes the driver structure from the list of registered PCI drivers, 1146 * gives it a chance to clean up by calling its remove() function for 1147 * each device it was responsible for, and marks those devices as 1148 * driverless. 1149 */ 1150 1151 void 1152 pci_unregister_driver(struct pci_driver *drv) 1153 { 1154 pci_remove_newid_files(drv); 1155 driver_unregister(&drv->driver); 1156 pci_free_dynids(drv); 1157 } 1158 1159 static struct pci_driver pci_compat_driver = { 1160 .name = "compat" 1161 }; 1162 1163 /** 1164 * pci_dev_driver - get the pci_driver of a device 1165 * @dev: the device to query 1166 * 1167 * Returns the appropriate pci_driver structure or %NULL if there is no 1168 * registered driver for the device. 1169 */ 1170 struct pci_driver * 1171 pci_dev_driver(const struct pci_dev *dev) 1172 { 1173 if (dev->driver) 1174 return dev->driver; 1175 else { 1176 int i; 1177 for(i=0; i<=PCI_ROM_RESOURCE; i++) 1178 if (dev->resource[i].flags & IORESOURCE_BUSY) 1179 return &pci_compat_driver; 1180 } 1181 return NULL; 1182 } 1183 1184 /** 1185 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure 1186 * @dev: the PCI device structure to match against 1187 * @drv: the device driver to search for matching PCI device id structures 1188 * 1189 * Used by a driver to check whether a PCI device present in the 1190 * system is in its list of supported devices. Returns the matching 1191 * pci_device_id structure or %NULL if there is no match. 1192 */ 1193 static int pci_bus_match(struct device *dev, struct device_driver *drv) 1194 { 1195 struct pci_dev *pci_dev = to_pci_dev(dev); 1196 struct pci_driver *pci_drv = to_pci_driver(drv); 1197 const struct pci_device_id *found_id; 1198 1199 found_id = pci_match_device(pci_drv, pci_dev); 1200 if (found_id) 1201 return 1; 1202 1203 return 0; 1204 } 1205 1206 /** 1207 * pci_dev_get - increments the reference count of the pci device structure 1208 * @dev: the device being referenced 1209 * 1210 * Each live reference to a device should be refcounted. 1211 * 1212 * Drivers for PCI devices should normally record such references in 1213 * their probe() methods, when they bind to a device, and release 1214 * them by calling pci_dev_put(), in their disconnect() methods. 1215 * 1216 * A pointer to the device with the incremented reference counter is returned. 1217 */ 1218 struct pci_dev *pci_dev_get(struct pci_dev *dev) 1219 { 1220 if (dev) 1221 get_device(&dev->dev); 1222 return dev; 1223 } 1224 1225 /** 1226 * pci_dev_put - release a use of the pci device structure 1227 * @dev: device that's been disconnected 1228 * 1229 * Must be called when a user of a device is finished with it. When the last 1230 * user of the device calls this function, the memory of the device is freed. 1231 */ 1232 void pci_dev_put(struct pci_dev *dev) 1233 { 1234 if (dev) 1235 put_device(&dev->dev); 1236 } 1237 1238 #ifndef CONFIG_HOTPLUG 1239 int pci_uevent(struct device *dev, struct kobj_uevent_env *env) 1240 { 1241 return -ENODEV; 1242 } 1243 #endif 1244 1245 struct bus_type pci_bus_type = { 1246 .name = "pci", 1247 .match = pci_bus_match, 1248 .uevent = pci_uevent, 1249 .probe = pci_device_probe, 1250 .remove = pci_device_remove, 1251 .shutdown = pci_device_shutdown, 1252 .dev_attrs = pci_dev_attrs, 1253 .bus_attrs = pci_bus_attrs, 1254 .pm = PCI_PM_OPS_PTR, 1255 }; 1256 1257 static int __init pci_driver_init(void) 1258 { 1259 return bus_register(&pci_bus_type); 1260 } 1261 1262 postcore_initcall(pci_driver_init); 1263 1264 EXPORT_SYMBOL_GPL(pci_add_dynid); 1265 EXPORT_SYMBOL(pci_match_id); 1266 EXPORT_SYMBOL(__pci_register_driver); 1267 EXPORT_SYMBOL(pci_unregister_driver); 1268 EXPORT_SYMBOL(pci_dev_driver); 1269 EXPORT_SYMBOL(pci_bus_type); 1270 EXPORT_SYMBOL(pci_dev_get); 1271 EXPORT_SYMBOL(pci_dev_put); 1272