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