drivers/pci/pci-driver.c

   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
  26 struct 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  */
  42 static ssize_t
  43 store_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 }
 100 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 101
 102 static void
 103 pci_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
 115 static int
 116 pci_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
 124 static 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 */
 129 static inline void pci_free_dynids(struct pci_driver *drv) {}
 130 static inline int pci_create_newid_file(struct pci_driver *drv)
 131 {
 132         return 0;
 133 }
 134 static 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  */
 149 const 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  */
 171 static 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
 189 struct drv_dev_and_id {
 190         struct pci_driver *drv;
 191         struct pci_dev *dev;
 192         const struct pci_device_id *id;
 193 };
 194
 195 static 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
 202 static 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  */
 237 static 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
 257 static 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
 273 static 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
 304 static 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 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
 318 {
 319         struct pci_driver *drv = pci_dev->driver;
 320
 321         return drv && (drv->suspend || drv->suspend_late || drv->resume
 322                 || drv->resume_early);
 323 }
 324
 325 /*
 326  * Default "suspend" method for devices that have no driver provided suspend,
 327  * or not even a driver at all.
 328  */
 329 static void pci_default_pm_suspend(struct pci_dev *pci_dev)
 330 {
 331         pci_save_state(pci_dev);
 332         /*
 333          * mark its power state as "unknown", since we don't know if
 334          * e.g. the BIOS will change its device state when we suspend.
 335          */
 336         if (pci_dev->current_state == PCI_D0)
 337                 pci_dev->current_state = PCI_UNKNOWN;
 338 }
 339
 340 /*
 341  * Default "resume" method for devices that have no driver provided resume,
 342  * or not even a driver at all (first part).
 343  */
 344 static void pci_default_pm_resume_early(struct pci_dev *pci_dev)
 345 {
 346         /* restore the PCI config space */
 347         pci_restore_state(pci_dev);
 348 }
 349
 350 /*
 351  * Default "resume" method for devices that have no driver provided resume,
 352  * or not even a driver at all (second part).
 353  */
 354 static int pci_default_pm_resume_late(struct pci_dev *pci_dev)
 355 {
 356         int retval;
 357
 358         /* if the device was enabled before suspend, reenable */
 359         retval = pci_reenable_device(pci_dev);
 360         /*
 361          * if the device was busmaster before the suspend, make it busmaster
 362          * again
 363          */
 364         if (pci_dev->is_busmaster)
 365                 pci_set_master(pci_dev);
 366
 367         return retval;
 368 }
 369
 370 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
 371 {
 372         struct pci_dev * pci_dev = to_pci_dev(dev);
 373         struct pci_driver * drv = pci_dev->driver;
 374         int i = 0;
 375
 376         if (drv && drv->suspend) {
 377                 i = drv->suspend(pci_dev, state);
 378                 suspend_report_result(drv->suspend, i);
 379         } else {
 380                 pci_default_pm_suspend(pci_dev);
 381         }
 382         return i;
 383 }
 384
 385 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 386 {
 387         struct pci_dev * pci_dev = to_pci_dev(dev);
 388         struct pci_driver * drv = pci_dev->driver;
 389         int i = 0;
 390
 391         if (drv && drv->suspend_late) {
 392                 i = drv->suspend_late(pci_dev, state);
 393                 suspend_report_result(drv->suspend_late, i);
 394         }
 395         return i;
 396 }
 397
 398 static int pci_legacy_resume(struct device *dev)
 399 {
 400         int error;
 401         struct pci_dev * pci_dev = to_pci_dev(dev);
 402         struct pci_driver * drv = pci_dev->driver;
 403
 404         if (drv && drv->resume) {
 405                 error = drv->resume(pci_dev);
 406         } else {
 407                 pci_default_pm_resume_early(pci_dev);
 408                 error = pci_default_pm_resume_late(pci_dev);
 409         }
 410         return error;
 411 }
 412
 413 static int pci_legacy_resume_early(struct device *dev)
 414 {
 415         int error = 0;
 416         struct pci_dev * pci_dev = to_pci_dev(dev);
 417         struct pci_driver * drv = pci_dev->driver;
 418
 419         if (drv && drv->resume_early)
 420                 error = drv->resume_early(pci_dev);
 421         return error;
 422 }
 423
 424 static int pci_pm_prepare(struct device *dev)
 425 {
 426         struct device_driver *drv = dev->driver;
 427         int error = 0;
 428
 429         if (drv && drv->pm && drv->pm->prepare)
 430                 error = drv->pm->prepare(dev);
 431
 432         return error;
 433 }
 434
 435 static void pci_pm_complete(struct device *dev)
 436 {
 437         struct device_driver *drv = dev->driver;
 438
 439         if (drv && drv->pm && drv->pm->complete)
 440                 drv->pm->complete(dev);
 441 }
 442
 443 #ifdef CONFIG_SUSPEND
 444
 445 static int pci_pm_suspend(struct device *dev)
 446 {
 447         struct pci_dev *pci_dev = to_pci_dev(dev);
 448         struct device_driver *drv = dev->driver;
 449         int error = 0;
 450
 451         if (drv && drv->pm) {
 452                 if (drv->pm->suspend) {
 453                         error = drv->pm->suspend(dev);
 454                         suspend_report_result(drv->pm->suspend, error);
 455                 }
 456         } else if (pci_has_legacy_pm_support(pci_dev)) {
 457                 error = pci_legacy_suspend(dev, PMSG_SUSPEND);
 458         }
 459         pci_fixup_device(pci_fixup_suspend, pci_dev);
 460
 461         return error;
 462 }
 463
 464 static int pci_pm_suspend_noirq(struct device *dev)
 465 {
 466         struct pci_dev *pci_dev = to_pci_dev(dev);
 467         struct device_driver *drv = dev->driver;
 468         int error = 0;
 469
 470         if (drv && drv->pm) {
 471                 if (drv->pm->suspend_noirq) {
 472                         error = drv->pm->suspend_noirq(dev);
 473                         suspend_report_result(drv->pm->suspend_noirq, error);
 474                 }
 475         } else if (pci_has_legacy_pm_support(pci_dev)) {
 476                 error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 477         } else {
 478                 pci_default_pm_suspend(pci_dev);
 479         }
 480
 481         return error;
 482 }
 483
 484 static int pci_pm_resume(struct device *dev)
 485 {
 486         struct pci_dev *pci_dev = to_pci_dev(dev);
 487         struct device_driver *drv = dev->driver;
 488         int error = 0;
 489
 490         pci_fixup_device(pci_fixup_resume, pci_dev);
 491
 492         if (drv && drv->pm) {
 493                 if (drv->pm->resume)
 494                         error = drv->pm->resume(dev);
 495         } else if (pci_has_legacy_pm_support(pci_dev)) {
 496                 error = pci_legacy_resume(dev);
 497         } else {
 498                 error = pci_default_pm_resume_late(pci_dev);
 499         }
 500
 501         return error;
 502 }
 503
 504 static int pci_pm_resume_noirq(struct device *dev)
 505 {
 506         struct pci_dev *pci_dev = to_pci_dev(dev);
 507         struct device_driver *drv = dev->driver;
 508         int error = 0;
 509
 510         pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
 511
 512         if (drv && drv->pm) {
 513                 if (drv->pm->resume_noirq)
 514                         error = drv->pm->resume_noirq(dev);
 515         } else if (pci_has_legacy_pm_support(pci_dev)) {
 516                 error = pci_legacy_resume_early(dev);
 517         } else {
 518                 pci_default_pm_resume_early(pci_dev);
 519         }
 520
 521         return error;
 522 }
 523
 524 #else /* !CONFIG_SUSPEND */
 525
 526 #define pci_pm_suspend          NULL
 527 #define pci_pm_suspend_noirq    NULL
 528 #define pci_pm_resume           NULL
 529 #define pci_pm_resume_noirq     NULL
 530
 531 #endif /* !CONFIG_SUSPEND */
 532
 533 #ifdef CONFIG_HIBERNATION
 534
 535 static int pci_pm_freeze(struct device *dev)
 536 {
 537         struct pci_dev *pci_dev = to_pci_dev(dev);
 538         struct device_driver *drv = dev->driver;
 539         int error = 0;
 540
 541         if (drv && drv->pm) {
 542                 if (drv->pm->freeze) {
 543                         error = drv->pm->freeze(dev);
 544                         suspend_report_result(drv->pm->freeze, error);
 545                 }
 546         } else if (pci_has_legacy_pm_support(pci_dev)) {
 547                 error = pci_legacy_suspend(dev, PMSG_FREEZE);
 548                 pci_fixup_device(pci_fixup_suspend, pci_dev);
 549         }
 550
 551         return error;
 552 }
 553
 554 static int pci_pm_freeze_noirq(struct device *dev)
 555 {
 556         struct pci_dev *pci_dev = to_pci_dev(dev);
 557         struct device_driver *drv = dev->driver;
 558         int error = 0;
 559
 560         if (drv && drv->pm) {
 561                 if (drv->pm->freeze_noirq) {
 562                         error = drv->pm->freeze_noirq(dev);
 563                         suspend_report_result(drv->pm->freeze_noirq, error);
 564                 }
 565         } else if (pci_has_legacy_pm_support(pci_dev)) {
 566                 error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
 567         } else {
 568                 pci_default_pm_suspend(pci_dev);
 569         }
 570
 571         return error;
 572 }
 573
 574 static int pci_pm_thaw(struct device *dev)
 575 {
 576         struct pci_dev *pci_dev = to_pci_dev(dev);
 577         struct device_driver *drv = dev->driver;
 578         int error = 0;
 579
 580         if (drv && drv->pm) {
 581                 if (drv->pm->thaw)
 582                         error =  drv->pm->thaw(dev);
 583         } else if (pci_has_legacy_pm_support(pci_dev)) {
 584                 pci_fixup_device(pci_fixup_resume, pci_dev);
 585                 error = pci_legacy_resume(dev);
 586         }
 587
 588         return error;
 589 }
 590
 591 static int pci_pm_thaw_noirq(struct device *dev)
 592 {
 593         struct pci_dev *pci_dev = to_pci_dev(dev);
 594         struct device_driver *drv = dev->driver;
 595         int error = 0;
 596
 597         if (drv && drv->pm) {
 598                 if (drv->pm->thaw_noirq)
 599                         error = drv->pm->thaw_noirq(dev);
 600         } else if (pci_has_legacy_pm_support(pci_dev)) {
 601                 pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
 602                 error = pci_legacy_resume_early(dev);
 603         }
 604
 605         return error;
 606 }
 607
 608 static int pci_pm_poweroff(struct device *dev)
 609 {
 610         struct pci_dev *pci_dev = to_pci_dev(dev);
 611         struct device_driver *drv = dev->driver;
 612         int error = 0;
 613
 614         if (drv && drv->pm) {
 615                 if (drv->pm->poweroff) {
 616                         error = drv->pm->poweroff(dev);
 617                         suspend_report_result(drv->pm->poweroff, error);
 618                 }
 619         } else if (pci_has_legacy_pm_support(pci_dev)) {
 620                 error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
 621         }
 622
 623         pci_fixup_device(pci_fixup_suspend, pci_dev);
 624
 625         return error;
 626 }
 627
 628 static int pci_pm_poweroff_noirq(struct device *dev)
 629 {
 630         struct device_driver *drv = dev->driver;
 631         int error = 0;
 632
 633         if (drv && drv->pm) {
 634                 if (drv->pm->poweroff_noirq) {
 635                         error = drv->pm->poweroff_noirq(dev);
 636                         suspend_report_result(drv->pm->poweroff_noirq, error);
 637                 }
 638         } else if (pci_has_legacy_pm_support(to_pci_dev(dev))) {
 639                 error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 640         }
 641
 642         return error;
 643 }
 644
 645 static int pci_pm_restore(struct device *dev)
 646 {
 647         struct pci_dev *pci_dev = to_pci_dev(dev);
 648         struct device_driver *drv = dev->driver;
 649         int error = 0;
 650
 651         pci_fixup_device(pci_fixup_resume, pci_dev);
 652
 653         if (drv && drv->pm) {
 654                 if (drv->pm->restore)
 655                         error = drv->pm->restore(dev);
 656         } else if (pci_has_legacy_pm_support(pci_dev)) {
 657                 error = pci_legacy_resume(dev);
 658         } else {
 659                 error = pci_default_pm_resume_late(pci_dev);
 660         }
 661
 662         return error;
 663 }
 664
 665 static int pci_pm_restore_noirq(struct device *dev)
 666 {
 667         struct pci_dev *pci_dev = to_pci_dev(dev);
 668         struct device_driver *drv = dev->driver;
 669         int error = 0;
 670
 671         pci_fixup_device(pci_fixup_resume_early, pci_dev);
 672
 673         if (drv && drv->pm) {
 674                 if (drv->pm->restore_noirq)
 675                         error = drv->pm->restore_noirq(dev);
 676         } else if (pci_has_legacy_pm_support(pci_dev)) {
 677                 error = pci_legacy_resume_early(dev);
 678         } else {
 679                 pci_default_pm_resume_early(pci_dev);
 680         }
 681
 682         return error;
 683 }
 684
 685 #else /* !CONFIG_HIBERNATION */
 686
 687 #define pci_pm_freeze           NULL
 688 #define pci_pm_freeze_noirq     NULL
 689 #define pci_pm_thaw             NULL
 690 #define pci_pm_thaw_noirq       NULL
 691 #define pci_pm_poweroff         NULL
 692 #define pci_pm_poweroff_noirq   NULL
 693 #define pci_pm_restore          NULL
 694 #define pci_pm_restore_noirq    NULL
 695
 696 #endif /* !CONFIG_HIBERNATION */
 697
 698 struct dev_pm_ops pci_dev_pm_ops = {
 699         .prepare = pci_pm_prepare,
 700         .complete = pci_pm_complete,
 701         .suspend = pci_pm_suspend,
 702         .resume = pci_pm_resume,
 703         .freeze = pci_pm_freeze,
 704         .thaw = pci_pm_thaw,
 705         .poweroff = pci_pm_poweroff,
 706         .restore = pci_pm_restore,
 707         .suspend_noirq = pci_pm_suspend_noirq,
 708         .resume_noirq = pci_pm_resume_noirq,
 709         .freeze_noirq = pci_pm_freeze_noirq,
 710         .thaw_noirq = pci_pm_thaw_noirq,
 711         .poweroff_noirq = pci_pm_poweroff_noirq,
 712         .restore_noirq = pci_pm_restore_noirq,
 713 };
 714
 715 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
 716
 717 #else /* !CONFIG_PM_SLEEP */
 718
 719 #define PCI_PM_OPS_PTR  NULL
 720
 721 #endif /* !CONFIG_PM_SLEEP */
 722
 723 /**
 724  * __pci_register_driver - register a new pci driver
 725  * @drv: the driver structure to register
 726  * @owner: owner module of drv
 727  * @mod_name: module name string
 728  *
 729  * Adds the driver structure to the list of registered drivers.
 730  * Returns a negative value on error, otherwise 0.
 731  * If no error occurred, the driver remains registered even if
 732  * no device was claimed during registration.
 733  */
 734 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
 735                           const char *mod_name)
 736 {
 737         int error;
 738
 739         /* initialize common driver fields */
 740         drv->driver.name = drv->name;
 741         drv->driver.bus = &pci_bus_type;
 742         drv->driver.owner = owner;
 743         drv->driver.mod_name = mod_name;
 744
 745         spin_lock_init(&drv->dynids.lock);
 746         INIT_LIST_HEAD(&drv->dynids.list);
 747
 748         /* register with core */
 749         error = driver_register(&drv->driver);
 750         if (error)
 751                 return error;
 752
 753         error = pci_create_newid_file(drv);
 754         if (error)
 755                 driver_unregister(&drv->driver);
 756
 757         return error;
 758 }
 759
 760 /**
 761  * pci_unregister_driver - unregister a pci driver
 762  * @drv: the driver structure to unregister
 763  *
 764  * Deletes the driver structure from the list of registered PCI drivers,
 765  * gives it a chance to clean up by calling its remove() function for
 766  * each device it was responsible for, and marks those devices as
 767  * driverless.
 768  */
 769
 770 void
 771 pci_unregister_driver(struct pci_driver *drv)
 772 {
 773         pci_remove_newid_file(drv);
 774         driver_unregister(&drv->driver);
 775         pci_free_dynids(drv);
 776 }
 777
 778 static struct pci_driver pci_compat_driver = {
 779         .name = "compat"
 780 };
 781
 782 /**
 783  * pci_dev_driver - get the pci_driver of a device
 784  * @dev: the device to query
 785  *
 786  * Returns the appropriate pci_driver structure or %NULL if there is no
 787  * registered driver for the device.
 788  */
 789 struct pci_driver *
 790 pci_dev_driver(const struct pci_dev *dev)
 791 {
 792         if (dev->driver)
 793                 return dev->driver;
 794         else {
 795                 int i;
 796                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
 797                         if (dev->resource[i].flags & IORESOURCE_BUSY)
 798                                 return &pci_compat_driver;
 799         }
 800         return NULL;
 801 }
 802
 803 /**
 804  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
 805  * @dev: the PCI device structure to match against
 806  * @drv: the device driver to search for matching PCI device id structures
 807  *
 808  * Used by a driver to check whether a PCI device present in the
 809  * system is in its list of supported devices. Returns the matching
 810  * pci_device_id structure or %NULL if there is no match.
 811  */
 812 static int pci_bus_match(struct device *dev, struct device_driver *drv)
 813 {
 814         struct pci_dev *pci_dev = to_pci_dev(dev);
 815         struct pci_driver *pci_drv = to_pci_driver(drv);
 816         const struct pci_device_id *found_id;
 817
 818         found_id = pci_match_device(pci_drv, pci_dev);
 819         if (found_id)
 820                 return 1;
 821
 822         return 0;
 823 }
 824
 825 /**
 826  * pci_dev_get - increments the reference count of the pci device structure
 827  * @dev: the device being referenced
 828  *
 829  * Each live reference to a device should be refcounted.
 830  *
 831  * Drivers for PCI devices should normally record such references in
 832  * their probe() methods, when they bind to a device, and release
 833  * them by calling pci_dev_put(), in their disconnect() methods.
 834  *
 835  * A pointer to the device with the incremented reference counter is returned.
 836  */
 837 struct pci_dev *pci_dev_get(struct pci_dev *dev)
 838 {
 839         if (dev)
 840                 get_device(&dev->dev);
 841         return dev;
 842 }
 843
 844 /**
 845  * pci_dev_put - release a use of the pci device structure
 846  * @dev: device that's been disconnected
 847  *
 848  * Must be called when a user of a device is finished with it.  When the last
 849  * user of the device calls this function, the memory of the device is freed.
 850  */
 851 void pci_dev_put(struct pci_dev *dev)
 852 {
 853         if (dev)
 854                 put_device(&dev->dev);
 855 }
 856
 857 #ifndef CONFIG_HOTPLUG
 858 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
 859 {
 860         return -ENODEV;
 861 }
 862 #endif
 863
 864 struct bus_type pci_bus_type = {
 865         .name           = "pci",
 866         .match          = pci_bus_match,
 867         .uevent         = pci_uevent,
 868         .probe          = pci_device_probe,
 869         .remove         = pci_device_remove,
 870         .shutdown       = pci_device_shutdown,
 871         .dev_attrs      = pci_dev_attrs,
 872         .pm             = PCI_PM_OPS_PTR,
 873 };
 874
 875 static int __init pci_driver_init(void)
 876 {
 877         return bus_register(&pci_bus_type);
 878 }
 879
 880 postcore_initcall(pci_driver_init);
 881
 882 EXPORT_SYMBOL(pci_match_id);
 883 EXPORT_SYMBOL(__pci_register_driver);
 884 EXPORT_SYMBOL(pci_unregister_driver);
 885 EXPORT_SYMBOL(pci_dev_driver);
 886 EXPORT_SYMBOL(pci_bus_type);
 887 EXPORT_SYMBOL(pci_dev_get);
 888 EXPORT_SYMBOL(pci_dev_put);