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