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