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