pci-driver.c revision 57ef80266e14ecc363380268fedc64e519047b4a
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 "pci.h" 21 22/* 23 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG 24 */ 25 26struct pci_dynid { 27 struct list_head node; 28 struct pci_device_id id; 29}; 30 31#ifdef CONFIG_HOTPLUG 32 33/** 34 * store_new_id - add a new PCI device ID to this driver and re-probe devices 35 * @driver: target device driver 36 * @buf: buffer for scanning device ID data 37 * @count: input size 38 * 39 * Adds a new dynamic pci device ID to this driver, 40 * and causes the driver to probe for all devices again. 41 */ 42static ssize_t 43store_new_id(struct device_driver *driver, const char *buf, size_t count) 44{ 45 struct pci_dynid *dynid; 46 struct pci_driver *pdrv = to_pci_driver(driver); 47 const struct pci_device_id *ids = pdrv->id_table; 48 __u32 vendor, device, subvendor=PCI_ANY_ID, 49 subdevice=PCI_ANY_ID, class=0, class_mask=0; 50 unsigned long driver_data=0; 51 int fields=0; 52 int retval=0; 53 54 fields = sscanf(buf, "%x %x %x %x %x %x %lx", 55 &vendor, &device, &subvendor, &subdevice, 56 &class, &class_mask, &driver_data); 57 if (fields < 2) 58 return -EINVAL; 59 60 /* Only accept driver_data values that match an existing id_table 61 entry */ 62 if (ids) { 63 retval = -EINVAL; 64 while (ids->vendor || ids->subvendor || ids->class_mask) { 65 if (driver_data == ids->driver_data) { 66 retval = 0; 67 break; 68 } 69 ids++; 70 } 71 if (retval) /* No match */ 72 return retval; 73 } 74 75 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); 76 if (!dynid) 77 return -ENOMEM; 78 79 dynid->id.vendor = vendor; 80 dynid->id.device = device; 81 dynid->id.subvendor = subvendor; 82 dynid->id.subdevice = subdevice; 83 dynid->id.class = class; 84 dynid->id.class_mask = class_mask; 85 dynid->id.driver_data = driver_data; 86 87 spin_lock(&pdrv->dynids.lock); 88 list_add_tail(&dynid->node, &pdrv->dynids.list); 89 spin_unlock(&pdrv->dynids.lock); 90 91 if (get_driver(&pdrv->driver)) { 92 retval = driver_attach(&pdrv->driver); 93 put_driver(&pdrv->driver); 94 } 95 96 if (retval) 97 return retval; 98 return count; 99} 100static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id); 101 102static void 103pci_free_dynids(struct pci_driver *drv) 104{ 105 struct pci_dynid *dynid, *n; 106 107 spin_lock(&drv->dynids.lock); 108 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) { 109 list_del(&dynid->node); 110 kfree(dynid); 111 } 112 spin_unlock(&drv->dynids.lock); 113} 114 115static int 116pci_create_newid_file(struct pci_driver *drv) 117{ 118 int error = 0; 119 if (drv->probe != NULL) 120 error = driver_create_file(&drv->driver, &driver_attr_new_id); 121 return error; 122} 123 124static void pci_remove_newid_file(struct pci_driver *drv) 125{ 126 driver_remove_file(&drv->driver, &driver_attr_new_id); 127} 128#else /* !CONFIG_HOTPLUG */ 129static inline void pci_free_dynids(struct pci_driver *drv) {} 130static inline int pci_create_newid_file(struct pci_driver *drv) 131{ 132 return 0; 133} 134static inline void pci_remove_newid_file(struct pci_driver *drv) {} 135#endif 136 137/** 138 * pci_match_id - See if a pci device matches a given pci_id table 139 * @ids: array of PCI device id structures to search in 140 * @dev: the PCI device structure to match against. 141 * 142 * Used by a driver to check whether a PCI device present in the 143 * system is in its list of supported devices. Returns the matching 144 * pci_device_id structure or %NULL if there is no match. 145 * 146 * Deprecated, don't use this as it will not catch any dynamic ids 147 * that a driver might want to check for. 148 */ 149const struct pci_device_id *pci_match_id(const struct pci_device_id *ids, 150 struct pci_dev *dev) 151{ 152 if (ids) { 153 while (ids->vendor || ids->subvendor || ids->class_mask) { 154 if (pci_match_one_device(ids, dev)) 155 return ids; 156 ids++; 157 } 158 } 159 return NULL; 160} 161 162/** 163 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure 164 * @drv: the PCI driver to match against 165 * @dev: the PCI device structure to match against 166 * 167 * Used by a driver to check whether a PCI device present in the 168 * system is in its list of supported devices. Returns the matching 169 * pci_device_id structure or %NULL if there is no match. 170 */ 171static const struct pci_device_id *pci_match_device(struct pci_driver *drv, 172 struct pci_dev *dev) 173{ 174 struct pci_dynid *dynid; 175 176 /* Look at the dynamic ids first, before the static ones */ 177 spin_lock(&drv->dynids.lock); 178 list_for_each_entry(dynid, &drv->dynids.list, node) { 179 if (pci_match_one_device(&dynid->id, dev)) { 180 spin_unlock(&drv->dynids.lock); 181 return &dynid->id; 182 } 183 } 184 spin_unlock(&drv->dynids.lock); 185 186 return pci_match_id(drv->id_table, dev); 187} 188 189struct drv_dev_and_id { 190 struct pci_driver *drv; 191 struct pci_dev *dev; 192 const struct pci_device_id *id; 193}; 194 195static long local_pci_probe(void *_ddi) 196{ 197 struct drv_dev_and_id *ddi = _ddi; 198 199 return ddi->drv->probe(ddi->dev, ddi->id); 200} 201 202static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev, 203 const struct pci_device_id *id) 204{ 205 int error, node; 206 struct drv_dev_and_id ddi = { drv, dev, id }; 207 208 /* Execute driver initialization on node where the device's 209 bus is attached to. This way the driver likely allocates 210 its local memory on the right node without any need to 211 change it. */ 212 node = dev_to_node(&dev->dev); 213 if (node >= 0) { 214 int cpu; 215 node_to_cpumask_ptr(nodecpumask, node); 216 217 get_online_cpus(); 218 cpu = cpumask_any_and(nodecpumask, cpu_online_mask); 219 if (cpu < nr_cpu_ids) 220 error = work_on_cpu(cpu, local_pci_probe, &ddi); 221 else 222 error = local_pci_probe(&ddi); 223 put_online_cpus(); 224 } else 225 error = local_pci_probe(&ddi); 226 return error; 227} 228 229/** 230 * __pci_device_probe() 231 * @drv: driver to call to check if it wants the PCI device 232 * @pci_dev: PCI device being probed 233 * 234 * returns 0 on success, else error. 235 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev. 236 */ 237static int 238__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev) 239{ 240 const struct pci_device_id *id; 241 int error = 0; 242 243 if (!pci_dev->driver && drv->probe) { 244 error = -ENODEV; 245 246 id = pci_match_device(drv, pci_dev); 247 if (id) 248 error = pci_call_probe(drv, pci_dev, id); 249 if (error >= 0) { 250 pci_dev->driver = drv; 251 error = 0; 252 } 253 } 254 return error; 255} 256 257static int pci_device_probe(struct device * dev) 258{ 259 int error = 0; 260 struct pci_driver *drv; 261 struct pci_dev *pci_dev; 262 263 drv = to_pci_driver(dev->driver); 264 pci_dev = to_pci_dev(dev); 265 pci_dev_get(pci_dev); 266 error = __pci_device_probe(drv, pci_dev); 267 if (error) 268 pci_dev_put(pci_dev); 269 270 return error; 271} 272 273static int pci_device_remove(struct device * dev) 274{ 275 struct pci_dev * pci_dev = to_pci_dev(dev); 276 struct pci_driver * drv = pci_dev->driver; 277 278 if (drv) { 279 if (drv->remove) 280 drv->remove(pci_dev); 281 pci_dev->driver = NULL; 282 } 283 284 /* 285 * If the device is still on, set the power state as "unknown", 286 * since it might change by the next time we load the driver. 287 */ 288 if (pci_dev->current_state == PCI_D0) 289 pci_dev->current_state = PCI_UNKNOWN; 290 291 /* 292 * We would love to complain here if pci_dev->is_enabled is set, that 293 * the driver should have called pci_disable_device(), but the 294 * unfortunate fact is there are too many odd BIOS and bridge setups 295 * that don't like drivers doing that all of the time. 296 * Oh well, we can dream of sane hardware when we sleep, no matter how 297 * horrible the crap we have to deal with is when we are awake... 298 */ 299 300 pci_dev_put(pci_dev); 301 return 0; 302} 303 304static void pci_device_shutdown(struct device *dev) 305{ 306 struct pci_dev *pci_dev = to_pci_dev(dev); 307 struct pci_driver *drv = pci_dev->driver; 308 309 if (drv && drv->shutdown) 310 drv->shutdown(pci_dev); 311 pci_msi_shutdown(pci_dev); 312 pci_msix_shutdown(pci_dev); 313} 314 315#ifdef CONFIG_PM_SLEEP 316 317/* 318 * Default "suspend" method for devices that have no driver provided suspend, 319 * or not even a driver at all (second part). 320 */ 321static void pci_pm_set_unknown_state(struct pci_dev *pci_dev) 322{ 323 /* 324 * mark its power state as "unknown", since we don't know if 325 * e.g. the BIOS will change its device state when we suspend. 326 */ 327 if (pci_dev->current_state == PCI_D0) 328 pci_dev->current_state = PCI_UNKNOWN; 329} 330 331/* 332 * Default "resume" method for devices that have no driver provided resume, 333 * or not even a driver at all (second part). 334 */ 335static int pci_pm_reenable_device(struct pci_dev *pci_dev) 336{ 337 int retval; 338 339 /* if the device was enabled before suspend, reenable */ 340 retval = pci_reenable_device(pci_dev); 341 /* 342 * if the device was busmaster before the suspend, make it busmaster 343 * again 344 */ 345 if (pci_dev->is_busmaster) 346 pci_set_master(pci_dev); 347 348 return retval; 349} 350 351static int pci_legacy_suspend(struct device *dev, pm_message_t state) 352{ 353 struct pci_dev * pci_dev = to_pci_dev(dev); 354 struct pci_driver * drv = pci_dev->driver; 355 int error = 0; 356 357 if (drv && drv->suspend) { 358 pci_power_t prev = pci_dev->current_state; 359 360 pci_dev->state_saved = false; 361 362 error = drv->suspend(pci_dev, state); 363 suspend_report_result(drv->suspend, error); 364 if (error) 365 return error; 366 367 if (pci_dev->state_saved) 368 goto Fixup; 369 370 if (pci_dev->current_state != PCI_D0 371 && pci_dev->current_state != PCI_UNKNOWN) { 372 WARN_ONCE(pci_dev->current_state != prev, 373 "PCI PM: Device state not saved by %pF\n", 374 drv->suspend); 375 goto Fixup; 376 } 377 } 378 379 pci_save_state(pci_dev); 380 /* 381 * This is for compatibility with existing code with legacy PM support. 382 */ 383 pci_pm_set_unknown_state(pci_dev); 384 385 Fixup: 386 pci_fixup_device(pci_fixup_suspend, pci_dev); 387 388 return error; 389} 390 391static int pci_legacy_suspend_late(struct device *dev, pm_message_t state) 392{ 393 struct pci_dev * pci_dev = to_pci_dev(dev); 394 struct pci_driver * drv = pci_dev->driver; 395 int error = 0; 396 397 if (drv && drv->suspend_late) { 398 error = drv->suspend_late(pci_dev, state); 399 suspend_report_result(drv->suspend_late, error); 400 } 401 return error; 402} 403 404static int pci_legacy_resume_early(struct device *dev) 405{ 406 struct pci_dev * pci_dev = to_pci_dev(dev); 407 struct pci_driver * drv = pci_dev->driver; 408 409 return drv && drv->resume_early ? 410 drv->resume_early(pci_dev) : 0; 411} 412 413static int pci_legacy_resume(struct device *dev) 414{ 415 struct pci_dev * pci_dev = to_pci_dev(dev); 416 struct pci_driver * drv = pci_dev->driver; 417 418 pci_fixup_device(pci_fixup_resume, pci_dev); 419 420 return drv && drv->resume ? 421 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev); 422} 423 424/* Auxiliary functions used by the new power management framework */ 425 426static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev) 427{ 428 pci_restore_standard_config(pci_dev); 429 pci_dev->state_saved = false; 430 pci_fixup_device(pci_fixup_resume_early, pci_dev); 431} 432 433static void pci_pm_default_resume(struct pci_dev *pci_dev) 434{ 435 pci_fixup_device(pci_fixup_resume, pci_dev); 436 437 if (!pci_is_bridge(pci_dev)) 438 pci_enable_wake(pci_dev, PCI_D0, false); 439} 440 441static void pci_pm_default_suspend(struct pci_dev *pci_dev) 442{ 443 /* Disable non-bridge devices without PM support */ 444 if (!pci_is_bridge(pci_dev)) 445 pci_disable_enabled_device(pci_dev); 446 pci_save_state(pci_dev); 447} 448 449static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev) 450{ 451 struct pci_driver *drv = pci_dev->driver; 452 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume 453 || drv->resume_early); 454 455 /* 456 * Legacy PM support is used by default, so warn if the new framework is 457 * supported as well. Drivers are supposed to support either the 458 * former, or the latter, but not both at the same time. 459 */ 460 WARN_ON(ret && drv->driver.pm); 461 462 return ret; 463} 464 465/* New power management framework */ 466 467static int pci_pm_prepare(struct device *dev) 468{ 469 struct device_driver *drv = dev->driver; 470 int error = 0; 471 472 if (drv && drv->pm && drv->pm->prepare) 473 error = drv->pm->prepare(dev); 474 475 return error; 476} 477 478static void pci_pm_complete(struct device *dev) 479{ 480 struct device_driver *drv = dev->driver; 481 482 if (drv && drv->pm && drv->pm->complete) 483 drv->pm->complete(dev); 484} 485 486#ifdef CONFIG_SUSPEND 487 488static int pci_pm_suspend(struct device *dev) 489{ 490 struct pci_dev *pci_dev = to_pci_dev(dev); 491 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 492 493 if (pci_has_legacy_pm_support(pci_dev)) 494 return pci_legacy_suspend(dev, PMSG_SUSPEND); 495 496 if (!pm) { 497 pci_pm_default_suspend(pci_dev); 498 goto Fixup; 499 } 500 501 pci_dev->state_saved = false; 502 503 if (pm->suspend) { 504 pci_power_t prev = pci_dev->current_state; 505 int error; 506 507 error = pm->suspend(dev); 508 suspend_report_result(pm->suspend, error); 509 if (error) 510 return error; 511 512 if (pci_dev->state_saved) 513 goto Fixup; 514 515 if (pci_dev->current_state != PCI_D0 516 && pci_dev->current_state != PCI_UNKNOWN) { 517 WARN_ONCE(pci_dev->current_state != prev, 518 "PCI PM: State of device not saved by %pF\n", 519 pm->suspend); 520 goto Fixup; 521 } 522 } 523 524 if (!pci_dev->state_saved) { 525 pci_save_state(pci_dev); 526 if (!pci_is_bridge(pci_dev)) 527 pci_prepare_to_sleep(pci_dev); 528 } 529 530 Fixup: 531 pci_fixup_device(pci_fixup_suspend, pci_dev); 532 533 return 0; 534} 535 536static int pci_pm_suspend_noirq(struct device *dev) 537{ 538 struct pci_dev *pci_dev = to_pci_dev(dev); 539 struct device_driver *drv = dev->driver; 540 int error = 0; 541 542 if (pci_has_legacy_pm_support(pci_dev)) 543 return pci_legacy_suspend_late(dev, PMSG_SUSPEND); 544 545 if (drv && drv->pm && drv->pm->suspend_noirq) { 546 error = drv->pm->suspend_noirq(dev); 547 suspend_report_result(drv->pm->suspend_noirq, error); 548 } 549 550 if (!error) 551 pci_pm_set_unknown_state(pci_dev); 552 553 return error; 554} 555 556static int pci_pm_resume_noirq(struct device *dev) 557{ 558 struct pci_dev *pci_dev = to_pci_dev(dev); 559 struct device_driver *drv = dev->driver; 560 int error = 0; 561 562 pci_pm_default_resume_noirq(pci_dev); 563 564 if (pci_has_legacy_pm_support(pci_dev)) 565 return pci_legacy_resume_early(dev); 566 567 if (drv && drv->pm && drv->pm->resume_noirq) 568 error = drv->pm->resume_noirq(dev); 569 570 return error; 571} 572 573static int pci_pm_resume(struct device *dev) 574{ 575 struct pci_dev *pci_dev = to_pci_dev(dev); 576 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 577 int error = 0; 578 579 /* 580 * This is necessary for the suspend error path in which resume is 581 * called without restoring the standard config registers of the device. 582 */ 583 if (pci_dev->state_saved) 584 pci_restore_standard_config(pci_dev); 585 586 if (pci_has_legacy_pm_support(pci_dev)) 587 return pci_legacy_resume(dev); 588 589 pci_pm_default_resume(pci_dev); 590 591 if (pm) { 592 if (pm->resume) 593 error = pm->resume(dev); 594 } else { 595 pci_pm_reenable_device(pci_dev); 596 } 597 598 return 0; 599} 600 601#else /* !CONFIG_SUSPEND */ 602 603#define pci_pm_suspend NULL 604#define pci_pm_suspend_noirq NULL 605#define pci_pm_resume NULL 606#define pci_pm_resume_noirq NULL 607 608#endif /* !CONFIG_SUSPEND */ 609 610#ifdef CONFIG_HIBERNATION 611 612static int pci_pm_freeze(struct device *dev) 613{ 614 struct pci_dev *pci_dev = to_pci_dev(dev); 615 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 616 617 if (pci_has_legacy_pm_support(pci_dev)) 618 return pci_legacy_suspend(dev, PMSG_FREEZE); 619 620 if (!pm) { 621 pci_pm_default_suspend(pci_dev); 622 return 0; 623 } 624 625 pci_dev->state_saved = false; 626 627 if (pm->freeze) { 628 int error; 629 630 error = pm->freeze(dev); 631 suspend_report_result(pm->freeze, error); 632 if (error) 633 return error; 634 } 635 636 if (!pci_dev->state_saved) 637 pci_save_state(pci_dev); 638 639 return 0; 640} 641 642static int pci_pm_freeze_noirq(struct device *dev) 643{ 644 struct pci_dev *pci_dev = to_pci_dev(dev); 645 struct device_driver *drv = dev->driver; 646 int error = 0; 647 648 if (pci_has_legacy_pm_support(pci_dev)) 649 return pci_legacy_suspend_late(dev, PMSG_FREEZE); 650 651 if (drv && drv->pm && drv->pm->freeze_noirq) { 652 error = drv->pm->freeze_noirq(dev); 653 suspend_report_result(drv->pm->freeze_noirq, error); 654 } 655 656 if (!error) 657 pci_pm_set_unknown_state(pci_dev); 658 659 return error; 660} 661 662static int pci_pm_thaw_noirq(struct device *dev) 663{ 664 struct pci_dev *pci_dev = to_pci_dev(dev); 665 struct device_driver *drv = dev->driver; 666 int error = 0; 667 668 if (pci_has_legacy_pm_support(pci_dev)) 669 return pci_legacy_resume_early(dev); 670 671 pci_update_current_state(pci_dev, PCI_D0); 672 673 if (drv && drv->pm && drv->pm->thaw_noirq) 674 error = drv->pm->thaw_noirq(dev); 675 676 return error; 677} 678 679static int pci_pm_thaw(struct device *dev) 680{ 681 struct pci_dev *pci_dev = to_pci_dev(dev); 682 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 683 int error = 0; 684 685 if (pci_has_legacy_pm_support(pci_dev)) 686 return pci_legacy_resume(dev); 687 688 if (pm) { 689 if (pm->thaw) 690 error = pm->thaw(dev); 691 } else { 692 pci_pm_reenable_device(pci_dev); 693 } 694 695 return error; 696} 697 698static int pci_pm_poweroff(struct device *dev) 699{ 700 struct pci_dev *pci_dev = to_pci_dev(dev); 701 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 702 int error = 0; 703 704 if (pci_has_legacy_pm_support(pci_dev)) 705 return pci_legacy_suspend(dev, PMSG_HIBERNATE); 706 707 if (!pm) { 708 pci_pm_default_suspend(pci_dev); 709 goto Fixup; 710 } 711 712 pci_dev->state_saved = false; 713 714 if (pm->poweroff) { 715 error = pm->poweroff(dev); 716 suspend_report_result(pm->poweroff, error); 717 } 718 719 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev)) 720 pci_prepare_to_sleep(pci_dev); 721 722 Fixup: 723 pci_fixup_device(pci_fixup_suspend, pci_dev); 724 725 return error; 726} 727 728static int pci_pm_poweroff_noirq(struct device *dev) 729{ 730 struct device_driver *drv = dev->driver; 731 int error = 0; 732 733 if (pci_has_legacy_pm_support(to_pci_dev(dev))) 734 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE); 735 736 if (drv && drv->pm && drv->pm->poweroff_noirq) { 737 error = drv->pm->poweroff_noirq(dev); 738 suspend_report_result(drv->pm->poweroff_noirq, error); 739 } 740 741 return error; 742} 743 744static int pci_pm_restore_noirq(struct device *dev) 745{ 746 struct pci_dev *pci_dev = to_pci_dev(dev); 747 struct device_driver *drv = dev->driver; 748 int error = 0; 749 750 pci_pm_default_resume_noirq(pci_dev); 751 752 if (pci_has_legacy_pm_support(pci_dev)) 753 return pci_legacy_resume_early(dev); 754 755 if (drv && drv->pm && drv->pm->restore_noirq) 756 error = drv->pm->restore_noirq(dev); 757 758 return error; 759} 760 761static int pci_pm_restore(struct device *dev) 762{ 763 struct pci_dev *pci_dev = to_pci_dev(dev); 764 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 765 int error = 0; 766 767 /* 768 * This is necessary for the hibernation error path in which restore is 769 * called without restoring the standard config registers of the device. 770 */ 771 if (pci_dev->state_saved) 772 pci_restore_standard_config(pci_dev); 773 774 if (pci_has_legacy_pm_support(pci_dev)) 775 return pci_legacy_resume(dev); 776 777 pci_pm_default_resume(pci_dev); 778 779 if (pm) { 780 if (pm->restore) 781 error = pm->restore(dev); 782 } else { 783 pci_pm_reenable_device(pci_dev); 784 } 785 786 return error; 787} 788 789#else /* !CONFIG_HIBERNATION */ 790 791#define pci_pm_freeze NULL 792#define pci_pm_freeze_noirq NULL 793#define pci_pm_thaw NULL 794#define pci_pm_thaw_noirq NULL 795#define pci_pm_poweroff NULL 796#define pci_pm_poweroff_noirq NULL 797#define pci_pm_restore NULL 798#define pci_pm_restore_noirq NULL 799 800#endif /* !CONFIG_HIBERNATION */ 801 802struct dev_pm_ops pci_dev_pm_ops = { 803 .prepare = pci_pm_prepare, 804 .complete = pci_pm_complete, 805 .suspend = pci_pm_suspend, 806 .resume = pci_pm_resume, 807 .freeze = pci_pm_freeze, 808 .thaw = pci_pm_thaw, 809 .poweroff = pci_pm_poweroff, 810 .restore = pci_pm_restore, 811 .suspend_noirq = pci_pm_suspend_noirq, 812 .resume_noirq = pci_pm_resume_noirq, 813 .freeze_noirq = pci_pm_freeze_noirq, 814 .thaw_noirq = pci_pm_thaw_noirq, 815 .poweroff_noirq = pci_pm_poweroff_noirq, 816 .restore_noirq = pci_pm_restore_noirq, 817}; 818 819#define PCI_PM_OPS_PTR (&pci_dev_pm_ops) 820 821#else /* !CONFIG_PM_SLEEP */ 822 823#define PCI_PM_OPS_PTR NULL 824 825#endif /* !CONFIG_PM_SLEEP */ 826 827/** 828 * __pci_register_driver - register a new pci driver 829 * @drv: the driver structure to register 830 * @owner: owner module of drv 831 * @mod_name: module name string 832 * 833 * Adds the driver structure to the list of registered drivers. 834 * Returns a negative value on error, otherwise 0. 835 * If no error occurred, the driver remains registered even if 836 * no device was claimed during registration. 837 */ 838int __pci_register_driver(struct pci_driver *drv, struct module *owner, 839 const char *mod_name) 840{ 841 int error; 842 843 /* initialize common driver fields */ 844 drv->driver.name = drv->name; 845 drv->driver.bus = &pci_bus_type; 846 drv->driver.owner = owner; 847 drv->driver.mod_name = mod_name; 848 849 spin_lock_init(&drv->dynids.lock); 850 INIT_LIST_HEAD(&drv->dynids.list); 851 852 /* register with core */ 853 error = driver_register(&drv->driver); 854 if (error) 855 return error; 856 857 error = pci_create_newid_file(drv); 858 if (error) 859 driver_unregister(&drv->driver); 860 861 return error; 862} 863 864/** 865 * pci_unregister_driver - unregister a pci driver 866 * @drv: the driver structure to unregister 867 * 868 * Deletes the driver structure from the list of registered PCI drivers, 869 * gives it a chance to clean up by calling its remove() function for 870 * each device it was responsible for, and marks those devices as 871 * driverless. 872 */ 873 874void 875pci_unregister_driver(struct pci_driver *drv) 876{ 877 pci_remove_newid_file(drv); 878 driver_unregister(&drv->driver); 879 pci_free_dynids(drv); 880} 881 882static struct pci_driver pci_compat_driver = { 883 .name = "compat" 884}; 885 886/** 887 * pci_dev_driver - get the pci_driver of a device 888 * @dev: the device to query 889 * 890 * Returns the appropriate pci_driver structure or %NULL if there is no 891 * registered driver for the device. 892 */ 893struct pci_driver * 894pci_dev_driver(const struct pci_dev *dev) 895{ 896 if (dev->driver) 897 return dev->driver; 898 else { 899 int i; 900 for(i=0; i<=PCI_ROM_RESOURCE; i++) 901 if (dev->resource[i].flags & IORESOURCE_BUSY) 902 return &pci_compat_driver; 903 } 904 return NULL; 905} 906 907/** 908 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure 909 * @dev: the PCI device structure to match against 910 * @drv: the device driver to search for matching PCI device id structures 911 * 912 * Used by a driver to check whether a PCI device present in the 913 * system is in its list of supported devices. Returns the matching 914 * pci_device_id structure or %NULL if there is no match. 915 */ 916static int pci_bus_match(struct device *dev, struct device_driver *drv) 917{ 918 struct pci_dev *pci_dev = to_pci_dev(dev); 919 struct pci_driver *pci_drv = to_pci_driver(drv); 920 const struct pci_device_id *found_id; 921 922 found_id = pci_match_device(pci_drv, pci_dev); 923 if (found_id) 924 return 1; 925 926 return 0; 927} 928 929/** 930 * pci_dev_get - increments the reference count of the pci device structure 931 * @dev: the device being referenced 932 * 933 * Each live reference to a device should be refcounted. 934 * 935 * Drivers for PCI devices should normally record such references in 936 * their probe() methods, when they bind to a device, and release 937 * them by calling pci_dev_put(), in their disconnect() methods. 938 * 939 * A pointer to the device with the incremented reference counter is returned. 940 */ 941struct pci_dev *pci_dev_get(struct pci_dev *dev) 942{ 943 if (dev) 944 get_device(&dev->dev); 945 return dev; 946} 947 948/** 949 * pci_dev_put - release a use of the pci device structure 950 * @dev: device that's been disconnected 951 * 952 * Must be called when a user of a device is finished with it. When the last 953 * user of the device calls this function, the memory of the device is freed. 954 */ 955void pci_dev_put(struct pci_dev *dev) 956{ 957 if (dev) 958 put_device(&dev->dev); 959} 960 961#ifndef CONFIG_HOTPLUG 962int pci_uevent(struct device *dev, struct kobj_uevent_env *env) 963{ 964 return -ENODEV; 965} 966#endif 967 968struct bus_type pci_bus_type = { 969 .name = "pci", 970 .match = pci_bus_match, 971 .uevent = pci_uevent, 972 .probe = pci_device_probe, 973 .remove = pci_device_remove, 974 .shutdown = pci_device_shutdown, 975 .dev_attrs = pci_dev_attrs, 976 .pm = PCI_PM_OPS_PTR, 977}; 978 979static int __init pci_driver_init(void) 980{ 981 return bus_register(&pci_bus_type); 982} 983 984postcore_initcall(pci_driver_init); 985 986EXPORT_SYMBOL(pci_match_id); 987EXPORT_SYMBOL(__pci_register_driver); 988EXPORT_SYMBOL(pci_unregister_driver); 989EXPORT_SYMBOL(pci_dev_driver); 990EXPORT_SYMBOL(pci_bus_type); 991EXPORT_SYMBOL(pci_dev_get); 992EXPORT_SYMBOL(pci_dev_put); 993