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 <linux/pm_runtime.h>
  21 #include <linux/suspend.h>
  22 #include "pci.h"
  23
  24 struct pci_dynid {
  25         struct list_head node;
  26         struct pci_device_id id;
  27 };
  28
  29 /**
  30  * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
  31  * @drv: target pci driver
  32  * @vendor: PCI vendor ID
  33  * @device: PCI device ID
  34  * @subvendor: PCI subvendor ID
  35  * @subdevice: PCI subdevice ID
  36  * @class: PCI class
  37  * @class_mask: PCI class mask
  38  * @driver_data: private driver data
  39  *
  40  * Adds a new dynamic pci device ID to this driver and causes the
  41  * driver to probe for all devices again.  @drv must have been
  42  * registered prior to calling this function.
  43  *
  44  * CONTEXT:
  45  * Does GFP_KERNEL allocation.
  46  *
  47  * RETURNS:
  48  * 0 on success, -errno on failure.
  49  */
  50 int pci_add_dynid(struct pci_driver *drv,
  51                   unsigned int vendor, unsigned int device,
  52                   unsigned int subvendor, unsigned int subdevice,
  53                   unsigned int class, unsigned int class_mask,
  54                   unsigned long driver_data)
  55 {
  56         struct pci_dynid *dynid;
  57         int retval;
  58
  59         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
  60         if (!dynid)
  61                 return -ENOMEM;
  62
  63         dynid->id.vendor = vendor;
  64         dynid->id.device = device;
  65         dynid->id.subvendor = subvendor;
  66         dynid->id.subdevice = subdevice;
  67         dynid->id.class = class;
  68         dynid->id.class_mask = class_mask;
  69         dynid->id.driver_data = driver_data;
  70
  71         spin_lock(&drv->dynids.lock);
  72         list_add_tail(&dynid->node, &drv->dynids.list);
  73         spin_unlock(&drv->dynids.lock);
  74
  75         retval = driver_attach(&drv->driver);
  76
  77         return retval;
  78 }
  79
  80 static void pci_free_dynids(struct pci_driver *drv)
  81 {
  82         struct pci_dynid *dynid, *n;
  83
  84         spin_lock(&drv->dynids.lock);
  85         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
  86                 list_del(&dynid->node);
  87                 kfree(dynid);
  88         }
  89         spin_unlock(&drv->dynids.lock);
  90 }
  91
  92 /*
  93  * Dynamic device ID manipulation via sysfs is disabled for !CONFIG_HOTPLUG
  94  */
  95 #ifdef CONFIG_HOTPLUG
  96 /**
  97  * store_new_id - sysfs frontend to pci_add_dynid()
  98  * @driver: target device driver
  99  * @buf: buffer for scanning device ID data
 100  * @count: input size
 101  *
 102  * Allow PCI IDs to be added to an existing driver via sysfs.
 103  */
 104 static ssize_t
 105 store_new_id(struct device_driver *driver, const char *buf, size_t count)
 106 {
 107         struct pci_driver *pdrv = to_pci_driver(driver);
 108         const struct pci_device_id *ids = pdrv->id_table;
 109         __u32 vendor, device, subvendor=PCI_ANY_ID,
 110                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
 111         unsigned long driver_data=0;
 112         int fields=0;
 113         int retval;
 114
 115         fields = sscanf(buf, "%x %x %x %x %x %x %lx",
 116                         &vendor, &device, &subvendor, &subdevice,
 117                         &class, &class_mask, &driver_data);
 118         if (fields < 2)
 119                 return -EINVAL;
 120
 121         /* Only accept driver_data values that match an existing id_table
 122            entry */
 123         if (ids) {
 124                 retval = -EINVAL;
 125                 while (ids->vendor || ids->subvendor || ids->class_mask) {
 126                         if (driver_data == ids->driver_data) {
 127                                 retval = 0;
 128                                 break;
 129                         }
 130                         ids++;
 131                 }
 132                 if (retval)     /* No match */
 133                         return retval;
 134         }
 135
 136         retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
 137                                class, class_mask, driver_data);
 138         if (retval)
 139                 return retval;
 140         return count;
 141 }
 142 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 143
 144 /**
 145  * store_remove_id - remove a PCI device ID from this driver
 146  * @driver: target device driver
 147  * @buf: buffer for scanning device ID data
 148  * @count: input size
 149  *
 150  * Removes a dynamic pci device ID to this driver.
 151  */
 152 static ssize_t
 153 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
 154 {
 155         struct pci_dynid *dynid, *n;
 156         struct pci_driver *pdrv = to_pci_driver(driver);
 157         __u32 vendor, device, subvendor = PCI_ANY_ID,
 158                 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
 159         int fields = 0;
 160         int retval = -ENODEV;
 161
 162         fields = sscanf(buf, "%x %x %x %x %x %x",
 163                         &vendor, &device, &subvendor, &subdevice,
 164                         &class, &class_mask);
 165         if (fields < 2)
 166                 return -EINVAL;
 167
 168         spin_lock(&pdrv->dynids.lock);
 169         list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
 170                 struct pci_device_id *id = &dynid->id;
 171                 if ((id->vendor == vendor) &&
 172                     (id->device == device) &&
 173                     (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
 174                     (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
 175                     !((id->class ^ class) & class_mask)) {
 176                         list_del(&dynid->node);
 177                         kfree(dynid);
 178                         retval = 0;
 179                         break;
 180                 }
 181         }
 182         spin_unlock(&pdrv->dynids.lock);
 183
 184         if (retval)
 185                 return retval;
 186         return count;
 187 }
 188 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
 189
 190 static int
 191 pci_create_newid_files(struct pci_driver *drv)
 192 {
 193         int error = 0;
 194
 195         if (drv->probe != NULL) {
 196                 error = driver_create_file(&drv->driver, &driver_attr_new_id);
 197                 if (error == 0) {
 198                         error = driver_create_file(&drv->driver,
 199                                         &driver_attr_remove_id);
 200                         if (error)
 201                                 driver_remove_file(&drv->driver,
 202                                                 &driver_attr_new_id);
 203                 }
 204         }
 205         return error;
 206 }
 207
 208 static void pci_remove_newid_files(struct pci_driver *drv)
 209 {
 210         driver_remove_file(&drv->driver, &driver_attr_remove_id);
 211         driver_remove_file(&drv->driver, &driver_attr_new_id);
 212 }
 213 #else /* !CONFIG_HOTPLUG */
 214 static inline int pci_create_newid_files(struct pci_driver *drv)
 215 {
 216         return 0;
 217 }
 218 static inline void pci_remove_newid_files(struct pci_driver *drv) {}
 219 #endif
 220
 221 /**
 222  * pci_match_id - See if a pci device matches a given pci_id table
 223  * @ids: array of PCI device id structures to search in
 224  * @dev: the PCI device structure to match against.
 225  *
 226  * Used by a driver to check whether a PCI device present in the
 227  * system is in its list of supported devices.  Returns the matching
 228  * pci_device_id structure or %NULL if there is no match.
 229  *
 230  * Deprecated, don't use this as it will not catch any dynamic ids
 231  * that a driver might want to check for.
 232  */
 233 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
 234                                          struct pci_dev *dev)
 235 {
 236         if (ids) {
 237                 while (ids->vendor || ids->subvendor || ids->class_mask) {
 238                         if (pci_match_one_device(ids, dev))
 239                                 return ids;
 240                         ids++;
 241                 }
 242         }
 243         return NULL;
 244 }
 245
 246 /**
 247  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
 248  * @drv: the PCI driver to match against
 249  * @dev: the PCI device structure to match against
 250  *
 251  * Used by a driver to check whether a PCI device present in the
 252  * system is in its list of supported devices.  Returns the matching
 253  * pci_device_id structure or %NULL if there is no match.
 254  */
 255 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
 256                                                     struct pci_dev *dev)
 257 {
 258         struct pci_dynid *dynid;
 259
 260         /* Look at the dynamic ids first, before the static ones */
 261         spin_lock(&drv->dynids.lock);
 262         list_for_each_entry(dynid, &drv->dynids.list, node) {
 263                 if (pci_match_one_device(&dynid->id, dev)) {
 264                         spin_unlock(&drv->dynids.lock);
 265                         return &dynid->id;
 266                 }
 267         }
 268         spin_unlock(&drv->dynids.lock);
 269
 270         return pci_match_id(drv->id_table, dev);
 271 }
 272
 273 struct drv_dev_and_id {
 274         struct pci_driver *drv;
 275         struct pci_dev *dev;
 276         const struct pci_device_id *id;
 277 };
 278
 279 static long local_pci_probe(void *_ddi)
 280 {
 281         struct drv_dev_and_id *ddi = _ddi;
 282         struct device *dev = &ddi->dev->dev;
 283         int rc;
 284
 285         /* Unbound PCI devices are always set to disabled and suspended.
 286          * During probe, the device is set to enabled and active and the
 287          * usage count is incremented.  If the driver supports runtime PM,
 288          * it should call pm_runtime_put_noidle() in its probe routine and
 289          * pm_runtime_get_noresume() in its remove routine.
 290          */
 291         pm_runtime_get_noresume(dev);
 292         pm_runtime_set_active(dev);
 293         pm_runtime_enable(dev);
 294
 295         rc = ddi->drv->probe(ddi->dev, ddi->id);
 296         if (rc) {
 297                 pm_runtime_disable(dev);
 298                 pm_runtime_set_suspended(dev);
 299                 pm_runtime_put_noidle(dev);
 300         }
 301         return rc;
 302 }
 303
 304 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
 305                           const struct pci_device_id *id)
 306 {
 307         int error, node;
 308         struct drv_dev_and_id ddi = { drv, dev, id };
 309
 310         /* Execute driver initialization on node where the device's
 311            bus is attached to.  This way the driver likely allocates
 312            its local memory on the right node without any need to
 313            change it. */
 314         node = dev_to_node(&dev->dev);
 315         if (node >= 0) {
 316                 int cpu;
 317
 318                 get_online_cpus();
 319                 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
 320                 if (cpu < nr_cpu_ids)
 321                         error = work_on_cpu(cpu, local_pci_probe, &ddi);
 322                 else
 323                         error = local_pci_probe(&ddi);
 324                 put_online_cpus();
 325         } else
 326                 error = local_pci_probe(&ddi);
 327         return error;
 328 }
 329
 330 /**
 331  * __pci_device_probe - check if a driver wants to claim a specific PCI device
 332  * @drv: driver to call to check if it wants the PCI device
 333  * @pci_dev: PCI device being probed
 334  *
 335  * returns 0 on success, else error.
 336  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
 337  */
 338 static int
 339 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
 340 {
 341         const struct pci_device_id *id;
 342         int error = 0;
 343
 344         if (!pci_dev->driver && drv->probe) {
 345                 error = -ENODEV;
 346
 347                 id = pci_match_device(drv, pci_dev);
 348                 if (id)
 349                         error = pci_call_probe(drv, pci_dev, id);
 350                 if (error >= 0) {
 351                         pci_dev->driver = drv;
 352                         error = 0;
 353                 }
 354         }
 355         return error;
 356 }
 357
 358 static int pci_device_probe(struct device * dev)
 359 {
 360         int error = 0;
 361         struct pci_driver *drv;
 362         struct pci_dev *pci_dev;
 363
 364         drv = to_pci_driver(dev->driver);
 365         pci_dev = to_pci_dev(dev);
 366         pci_dev_get(pci_dev);
 367         error = __pci_device_probe(drv, pci_dev);
 368         if (error)
 369                 pci_dev_put(pci_dev);
 370
 371         return error;
 372 }
 373
 374 static int pci_device_remove(struct device * dev)
 375 {
 376         struct pci_dev * pci_dev = to_pci_dev(dev);
 377         struct pci_driver * drv = pci_dev->driver;
 378
 379         if (drv) {
 380                 if (drv->remove) {
 381                         pm_runtime_get_sync(dev);
 382                         drv->remove(pci_dev);
 383                         pm_runtime_put_noidle(dev);
 384                 }
 385                 pci_dev->driver = NULL;
 386         }
 387
 388         /* Undo the runtime PM settings in local_pci_probe() */
 389         pm_runtime_disable(dev);
 390         pm_runtime_set_suspended(dev);
 391         pm_runtime_put_noidle(dev);
 392
 393         /*
 394          * If the device is still on, set the power state as "unknown",
 395          * since it might change by the next time we load the driver.
 396          */
 397         if (pci_dev->current_state == PCI_D0)
 398                 pci_dev->current_state = PCI_UNKNOWN;
 399
 400         /*
 401          * We would love to complain here if pci_dev->is_enabled is set, that
 402          * the driver should have called pci_disable_device(), but the
 403          * unfortunate fact is there are too many odd BIOS and bridge setups
 404          * that don't like drivers doing that all of the time.
 405          * Oh well, we can dream of sane hardware when we sleep, no matter how
 406          * horrible the crap we have to deal with is when we are awake...
 407          */
 408
 409         pci_dev_put(pci_dev);
 410         return 0;
 411 }
 412
 413 static void pci_device_shutdown(struct device *dev)
 414 {
 415         struct pci_dev *pci_dev = to_pci_dev(dev);
 416         struct pci_driver *drv = pci_dev->driver;
 417
 418         if (drv && drv->shutdown)
 419                 drv->shutdown(pci_dev);
 420         pci_msi_shutdown(pci_dev);
 421         pci_msix_shutdown(pci_dev);
 422
 423         /*
 424          * Devices may be enabled to wake up by runtime PM, but they need not
 425          * be supposed to wake up the system from its "power off" state (e.g.
 426          * ACPI S5).  Therefore disable wakeup for all devices that aren't
 427          * supposed to wake up the system at this point.  The state argument
 428          * will be ignored by pci_enable_wake().
 429          */
 430         if (!device_may_wakeup(dev))
 431                 pci_enable_wake(pci_dev, PCI_UNKNOWN, false);
 432 }
 433
 434 #ifdef CONFIG_PM
 435
 436 /* Auxiliary functions used for system resume and run-time resume. */
 437
 438 /**
 439  * pci_restore_standard_config - restore standard config registers of PCI device
 440  * @pci_dev: PCI device to handle
 441  */
 442 static int pci_restore_standard_config(struct pci_dev *pci_dev)
 443 {
 444         pci_update_current_state(pci_dev, PCI_UNKNOWN);
 445
 446         if (pci_dev->current_state != PCI_D0) {
 447                 int error = pci_set_power_state(pci_dev, PCI_D0);
 448                 if (error)
 449                         return error;
 450         }
 451
 452         pci_restore_state(pci_dev);
 453         return 0;
 454 }
 455
 456 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
 457 {
 458         pci_restore_standard_config(pci_dev);
 459         pci_fixup_device(pci_fixup_resume_early, pci_dev);
 460 }
 461
 462 #endif
 463
 464 #ifdef CONFIG_PM_SLEEP
 465
 466 /*
 467  * Default "suspend" method for devices that have no driver provided suspend,
 468  * or not even a driver at all (second part).
 469  */
 470 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
 471 {
 472         /*
 473          * mark its power state as "unknown", since we don't know if
 474          * e.g. the BIOS will change its device state when we suspend.
 475          */
 476         if (pci_dev->current_state == PCI_D0)
 477                 pci_dev->current_state = PCI_UNKNOWN;
 478 }
 479
 480 /*
 481  * Default "resume" method for devices that have no driver provided resume,
 482  * or not even a driver at all (second part).
 483  */
 484 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
 485 {
 486         int retval;
 487
 488         /* if the device was enabled before suspend, reenable */
 489         retval = pci_reenable_device(pci_dev);
 490         /*
 491          * if the device was busmaster before the suspend, make it busmaster
 492          * again
 493          */
 494         if (pci_dev->is_busmaster)
 495                 pci_set_master(pci_dev);
 496
 497         return retval;
 498 }
 499
 500 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
 501 {
 502         struct pci_dev * pci_dev = to_pci_dev(dev);
 503         struct pci_driver * drv = pci_dev->driver;
 504
 505         if (drv && drv->suspend) {
 506                 pci_power_t prev = pci_dev->current_state;
 507                 int error;
 508
 509                 error = drv->suspend(pci_dev, state);
 510                 suspend_report_result(drv->suspend, error);
 511                 if (error)
 512                         return error;
 513
 514                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 515                     && pci_dev->current_state != PCI_UNKNOWN) {
 516                         WARN_ONCE(pci_dev->current_state != prev,
 517                                 "PCI PM: Device state not saved by %pF\n",
 518                                 drv->suspend);
 519                 }
 520         }
 521
 522         pci_fixup_device(pci_fixup_suspend, pci_dev);
 523
 524         return 0;
 525 }
 526
 527 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 528 {
 529         struct pci_dev * pci_dev = to_pci_dev(dev);
 530         struct pci_driver * drv = pci_dev->driver;
 531
 532         if (drv && drv->suspend_late) {
 533                 pci_power_t prev = pci_dev->current_state;
 534                 int error;
 535
 536                 error = drv->suspend_late(pci_dev, state);
 537                 suspend_report_result(drv->suspend_late, error);
 538                 if (error)
 539                         return error;
 540
 541                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 542                     && pci_dev->current_state != PCI_UNKNOWN) {
 543                         WARN_ONCE(pci_dev->current_state != prev,
 544                                 "PCI PM: Device state not saved by %pF\n",
 545                                 drv->suspend_late);
 546                         return 0;
 547                 }
 548         }
 549
 550         if (!pci_dev->state_saved)
 551                 pci_save_state(pci_dev);
 552
 553         pci_pm_set_unknown_state(pci_dev);
 554
 555         return 0;
 556 }
 557
 558 static int pci_legacy_resume_early(struct device *dev)
 559 {
 560         struct pci_dev * pci_dev = to_pci_dev(dev);
 561         struct pci_driver * drv = pci_dev->driver;
 562
 563         return drv && drv->resume_early ?
 564                         drv->resume_early(pci_dev) : 0;
 565 }
 566
 567 static int pci_legacy_resume(struct device *dev)
 568 {
 569         struct pci_dev * pci_dev = to_pci_dev(dev);
 570         struct pci_driver * drv = pci_dev->driver;
 571
 572         pci_fixup_device(pci_fixup_resume, pci_dev);
 573
 574         return drv && drv->resume ?
 575                         drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
 576 }
 577
 578 /* Auxiliary functions used by the new power management framework */
 579
 580 static void pci_pm_default_resume(struct pci_dev *pci_dev)
 581 {
 582         pci_fixup_device(pci_fixup_resume, pci_dev);
 583
 584         if (!pci_is_bridge(pci_dev))
 585                 pci_enable_wake(pci_dev, PCI_D0, false);
 586 }
 587
 588 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
 589 {
 590         /* Disable non-bridge devices without PM support */
 591         if (!pci_is_bridge(pci_dev))
 592                 pci_disable_enabled_device(pci_dev);
 593 }
 594
 595 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
 596 {
 597         struct pci_driver *drv = pci_dev->driver;
 598         bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
 599                 || drv->resume_early);
 600
 601         /*
 602          * Legacy PM support is used by default, so warn if the new framework is
 603          * supported as well.  Drivers are supposed to support either the
 604          * former, or the latter, but not both at the same time.
 605          */
 606         WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
 607                 drv->name, pci_dev->vendor, pci_dev->device);
 608
 609         return ret;
 610 }
 611
 612 /* New power management framework */
 613
 614 static int pci_pm_prepare(struct device *dev)
 615 {
 616         struct device_driver *drv = dev->driver;
 617         int error = 0;
 618
 619         /*
 620          * If a PCI device configured to wake up the system from sleep states
 621          * has been suspended at run time and there's a resume request pending
 622          * for it, this is equivalent to the device signaling wakeup, so the
 623          * system suspend operation should be aborted.
 624          */
 625         pm_runtime_get_noresume(dev);
 626         if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
 627                 pm_wakeup_event(dev, 0);
 628
 629         if (pm_wakeup_pending()) {
 630                 pm_runtime_put_sync(dev);
 631                 return -EBUSY;
 632         }
 633
 634         /*
 635          * PCI devices suspended at run time need to be resumed at this
 636          * point, because in general it is necessary to reconfigure them for
 637          * system suspend.  Namely, if the device is supposed to wake up the
 638          * system from the sleep state, we may need to reconfigure it for this
 639          * purpose.  In turn, if the device is not supposed to wake up the
 640          * system from the sleep state, we'll have to prevent it from signaling
 641          * wake-up.
 642          */
 643         pm_runtime_resume(dev);
 644
 645         if (drv && drv->pm && drv->pm->prepare)
 646                 error = drv->pm->prepare(dev);
 647
 648         return error;
 649 }
 650
 651 static void pci_pm_complete(struct device *dev)
 652 {
 653         struct device_driver *drv = dev->driver;
 654
 655         if (drv && drv->pm && drv->pm->complete)
 656                 drv->pm->complete(dev);
 657
 658         pm_runtime_put_sync(dev);
 659 }
 660
 661 #else /* !CONFIG_PM_SLEEP */
 662
 663 #define pci_pm_prepare  NULL
 664 #define pci_pm_complete NULL
 665
 666 #endif /* !CONFIG_PM_SLEEP */
 667
 668 #ifdef CONFIG_SUSPEND
 669
 670 static int pci_pm_suspend(struct device *dev)
 671 {
 672         struct pci_dev *pci_dev = to_pci_dev(dev);
 673         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 674
 675         if (pci_has_legacy_pm_support(pci_dev))
 676                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
 677
 678         if (!pm) {
 679                 pci_pm_default_suspend(pci_dev);
 680                 goto Fixup;
 681         }
 682
 683         if (pm->suspend) {
 684                 pci_power_t prev = pci_dev->current_state;
 685                 int error;
 686
 687                 error = pm->suspend(dev);
 688                 suspend_report_result(pm->suspend, error);
 689                 if (error)
 690                         return error;
 691
 692                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 693                     && pci_dev->current_state != PCI_UNKNOWN) {
 694                         WARN_ONCE(pci_dev->current_state != prev,
 695                                 "PCI PM: State of device not saved by %pF\n",
 696                                 pm->suspend);
 697                 }
 698         }
 699
 700  Fixup:
 701         pci_fixup_device(pci_fixup_suspend, pci_dev);
 702
 703         return 0;
 704 }
 705
 706 static int pci_pm_suspend_noirq(struct device *dev)
 707 {
 708         struct pci_dev *pci_dev = to_pci_dev(dev);
 709         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 710
 711         if (pci_has_legacy_pm_support(pci_dev))
 712                 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 713
 714         if (!pm) {
 715                 pci_save_state(pci_dev);
 716                 return 0;
 717         }
 718
 719         if (pm->suspend_noirq) {
 720                 pci_power_t prev = pci_dev->current_state;
 721                 int error;
 722
 723                 error = pm->suspend_noirq(dev);
 724                 suspend_report_result(pm->suspend_noirq, error);
 725                 if (error)
 726                         return error;
 727
 728                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 729                     && pci_dev->current_state != PCI_UNKNOWN) {
 730                         WARN_ONCE(pci_dev->current_state != prev,
 731                                 "PCI PM: State of device not saved by %pF\n",
 732                                 pm->suspend_noirq);
 733                         return 0;
 734                 }
 735         }
 736
 737         if (!pci_dev->state_saved) {
 738                 pci_save_state(pci_dev);
 739                 if (!pci_is_bridge(pci_dev))
 740                         pci_prepare_to_sleep(pci_dev);
 741         }
 742
 743         pci_pm_set_unknown_state(pci_dev);
 744
 745         return 0;
 746 }
 747
 748 static int pci_pm_resume_noirq(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         pci_pm_default_resume_early(pci_dev);
 755
 756         if (pci_has_legacy_pm_support(pci_dev))
 757                 return pci_legacy_resume_early(dev);
 758
 759         if (drv && drv->pm && drv->pm->resume_noirq)
 760                 error = drv->pm->resume_noirq(dev);
 761
 762         return error;
 763 }
 764
 765 static int pci_pm_resume(struct device *dev)
 766 {
 767         struct pci_dev *pci_dev = to_pci_dev(dev);
 768         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 769         int error = 0;
 770
 771         /*
 772          * This is necessary for the suspend error path in which resume is
 773          * called without restoring the standard config registers of the device.
 774          */
 775         if (pci_dev->state_saved)
 776                 pci_restore_standard_config(pci_dev);
 777
 778         if (pci_has_legacy_pm_support(pci_dev))
 779                 return pci_legacy_resume(dev);
 780
 781         pci_pm_default_resume(pci_dev);
 782
 783         if (pm) {
 784                 if (pm->resume)
 785                         error = pm->resume(dev);
 786         } else {
 787                 pci_pm_reenable_device(pci_dev);
 788         }
 789
 790         return error;
 791 }
 792
 793 #else /* !CONFIG_SUSPEND */
 794
 795 #define pci_pm_suspend          NULL
 796 #define pci_pm_suspend_noirq    NULL
 797 #define pci_pm_resume           NULL
 798 #define pci_pm_resume_noirq     NULL
 799
 800 #endif /* !CONFIG_SUSPEND */
 801
 802 #ifdef CONFIG_HIBERNATE_CALLBACKS
 803
 804 static int pci_pm_freeze(struct device *dev)
 805 {
 806         struct pci_dev *pci_dev = to_pci_dev(dev);
 807         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 808
 809         if (pci_has_legacy_pm_support(pci_dev))
 810                 return pci_legacy_suspend(dev, PMSG_FREEZE);
 811
 812         if (!pm) {
 813                 pci_pm_default_suspend(pci_dev);
 814                 return 0;
 815         }
 816
 817         if (pm->freeze) {
 818                 int error;
 819
 820                 error = pm->freeze(dev);
 821                 suspend_report_result(pm->freeze, error);
 822                 if (error)
 823                         return error;
 824         }
 825
 826         return 0;
 827 }
 828
 829 static int pci_pm_freeze_noirq(struct device *dev)
 830 {
 831         struct pci_dev *pci_dev = to_pci_dev(dev);
 832         struct device_driver *drv = dev->driver;
 833
 834         if (pci_has_legacy_pm_support(pci_dev))
 835                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
 836
 837         if (drv && drv->pm && drv->pm->freeze_noirq) {
 838                 int error;
 839
 840                 error = drv->pm->freeze_noirq(dev);
 841                 suspend_report_result(drv->pm->freeze_noirq, error);
 842                 if (error)
 843                         return error;
 844         }
 845
 846         if (!pci_dev->state_saved)
 847                 pci_save_state(pci_dev);
 848
 849         pci_pm_set_unknown_state(pci_dev);
 850
 851         return 0;
 852 }
 853
 854 static int pci_pm_thaw_noirq(struct device *dev)
 855 {
 856         struct pci_dev *pci_dev = to_pci_dev(dev);
 857         struct device_driver *drv = dev->driver;
 858         int error = 0;
 859
 860         if (pci_has_legacy_pm_support(pci_dev))
 861                 return pci_legacy_resume_early(dev);
 862
 863         pci_update_current_state(pci_dev, PCI_D0);
 864
 865         if (drv && drv->pm && drv->pm->thaw_noirq)
 866                 error = drv->pm->thaw_noirq(dev);
 867
 868         return error;
 869 }
 870
 871 static int pci_pm_thaw(struct device *dev)
 872 {
 873         struct pci_dev *pci_dev = to_pci_dev(dev);
 874         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 875         int error = 0;
 876
 877         if (pci_has_legacy_pm_support(pci_dev))
 878                 return pci_legacy_resume(dev);
 879
 880         if (pm) {
 881                 if (pm->thaw)
 882                         error = pm->thaw(dev);
 883         } else {
 884                 pci_pm_reenable_device(pci_dev);
 885         }
 886
 887         pci_dev->state_saved = false;
 888
 889         return error;
 890 }
 891
 892 static int pci_pm_poweroff(struct device *dev)
 893 {
 894         struct pci_dev *pci_dev = to_pci_dev(dev);
 895         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 896
 897         if (pci_has_legacy_pm_support(pci_dev))
 898                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
 899
 900         if (!pm) {
 901                 pci_pm_default_suspend(pci_dev);
 902                 goto Fixup;
 903         }
 904
 905         if (pm->poweroff) {
 906                 int error;
 907
 908                 error = pm->poweroff(dev);
 909                 suspend_report_result(pm->poweroff, error);
 910                 if (error)
 911                         return error;
 912         }
 913
 914  Fixup:
 915         pci_fixup_device(pci_fixup_suspend, pci_dev);
 916
 917         return 0;
 918 }
 919
 920 static int pci_pm_poweroff_noirq(struct device *dev)
 921 {
 922         struct pci_dev *pci_dev = to_pci_dev(dev);
 923         struct device_driver *drv = dev->driver;
 924
 925         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
 926                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 927
 928         if (!drv || !drv->pm)
 929                 return 0;
 930
 931         if (drv->pm->poweroff_noirq) {
 932                 int error;
 933
 934                 error = drv->pm->poweroff_noirq(dev);
 935                 suspend_report_result(drv->pm->poweroff_noirq, error);
 936                 if (error)
 937                         return error;
 938         }
 939
 940         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
 941                 pci_prepare_to_sleep(pci_dev);
 942
 943         return 0;
 944 }
 945
 946 static int pci_pm_restore_noirq(struct device *dev)
 947 {
 948         struct pci_dev *pci_dev = to_pci_dev(dev);
 949         struct device_driver *drv = dev->driver;
 950         int error = 0;
 951
 952         pci_pm_default_resume_early(pci_dev);
 953
 954         if (pci_has_legacy_pm_support(pci_dev))
 955                 return pci_legacy_resume_early(dev);
 956
 957         if (drv && drv->pm && drv->pm->restore_noirq)
 958                 error = drv->pm->restore_noirq(dev);
 959
 960         return error;
 961 }
 962
 963 static int pci_pm_restore(struct device *dev)
 964 {
 965         struct pci_dev *pci_dev = to_pci_dev(dev);
 966         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 967         int error = 0;
 968
 969         /*
 970          * This is necessary for the hibernation error path in which restore is
 971          * called without restoring the standard config registers of the device.
 972          */
 973         if (pci_dev->state_saved)
 974                 pci_restore_standard_config(pci_dev);
 975
 976         if (pci_has_legacy_pm_support(pci_dev))
 977                 return pci_legacy_resume(dev);
 978
 979         pci_pm_default_resume(pci_dev);
 980
 981         if (pm) {
 982                 if (pm->restore)
 983                         error = pm->restore(dev);
 984         } else {
 985                 pci_pm_reenable_device(pci_dev);
 986         }
 987
 988         return error;
 989 }
 990
 991 #else /* !CONFIG_HIBERNATE_CALLBACKS */
 992
 993 #define pci_pm_freeze           NULL
 994 #define pci_pm_freeze_noirq     NULL
 995 #define pci_pm_thaw             NULL
 996 #define pci_pm_thaw_noirq       NULL
 997 #define pci_pm_poweroff         NULL
 998 #define pci_pm_poweroff_noirq   NULL
 999 #define pci_pm_restore          NULL
1000 #define pci_pm_restore_noirq    NULL
1001
1002 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
1003
1004 #ifdef CONFIG_PM_RUNTIME
1005
1006 static int pci_pm_runtime_suspend(struct device *dev)
1007 {
1008         struct pci_dev *pci_dev = to_pci_dev(dev);
1009         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1010         pci_power_t prev = pci_dev->current_state;
1011         int error;
1012
1013         if (!pm || !pm->runtime_suspend)
1014                 return -ENOSYS;
1015
1016         error = pm->runtime_suspend(dev);
1017         suspend_report_result(pm->runtime_suspend, error);
1018         if (error)
1019                 return error;
1020
1021         pci_fixup_device(pci_fixup_suspend, pci_dev);
1022
1023         if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1024             && pci_dev->current_state != PCI_UNKNOWN) {
1025                 WARN_ONCE(pci_dev->current_state != prev,
1026                         "PCI PM: State of device not saved by %pF\n",
1027                         pm->runtime_suspend);
1028                 return 0;
1029         }
1030
1031         if (!pci_dev->state_saved)
1032                 pci_save_state(pci_dev);
1033
1034         pci_finish_runtime_suspend(pci_dev);
1035
1036         return 0;
1037 }
1038
1039 static int pci_pm_runtime_resume(struct device *dev)
1040 {
1041         struct pci_dev *pci_dev = to_pci_dev(dev);
1042         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1043
1044         if (!pm || !pm->runtime_resume)
1045                 return -ENOSYS;
1046
1047         pci_pm_default_resume_early(pci_dev);
1048         __pci_enable_wake(pci_dev, PCI_D0, true, false);
1049         pci_fixup_device(pci_fixup_resume, pci_dev);
1050
1051         return pm->runtime_resume(dev);
1052 }
1053
1054 static int pci_pm_runtime_idle(struct device *dev)
1055 {
1056         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1057
1058         if (!pm)
1059                 return -ENOSYS;
1060
1061         if (pm->runtime_idle) {
1062                 int ret = pm->runtime_idle(dev);
1063                 if (ret)
1064                         return ret;
1065         }
1066
1067         pm_runtime_suspend(dev);
1068
1069         return 0;
1070 }
1071
1072 #else /* !CONFIG_PM_RUNTIME */
1073
1074 #define pci_pm_runtime_suspend  NULL
1075 #define pci_pm_runtime_resume   NULL
1076 #define pci_pm_runtime_idle     NULL
1077
1078 #endif /* !CONFIG_PM_RUNTIME */
1079
1080 #ifdef CONFIG_PM
1081
1082 const struct dev_pm_ops pci_dev_pm_ops = {
1083         .prepare = pci_pm_prepare,
1084         .complete = pci_pm_complete,
1085         .suspend = pci_pm_suspend,
1086         .resume = pci_pm_resume,
1087         .freeze = pci_pm_freeze,
1088         .thaw = pci_pm_thaw,
1089         .poweroff = pci_pm_poweroff,
1090         .restore = pci_pm_restore,
1091         .suspend_noirq = pci_pm_suspend_noirq,
1092         .resume_noirq = pci_pm_resume_noirq,
1093         .freeze_noirq = pci_pm_freeze_noirq,
1094         .thaw_noirq = pci_pm_thaw_noirq,
1095         .poweroff_noirq = pci_pm_poweroff_noirq,
1096         .restore_noirq = pci_pm_restore_noirq,
1097         .runtime_suspend = pci_pm_runtime_suspend,
1098         .runtime_resume = pci_pm_runtime_resume,
1099         .runtime_idle = pci_pm_runtime_idle,
1100 };
1101
1102 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
1103
1104 #else /* !COMFIG_PM_OPS */
1105
1106 #define PCI_PM_OPS_PTR  NULL
1107
1108 #endif /* !COMFIG_PM_OPS */
1109
1110 /**
1111  * __pci_register_driver - register a new pci driver
1112  * @drv: the driver structure to register
1113  * @owner: owner module of drv
1114  * @mod_name: module name string
1115  *
1116  * Adds the driver structure to the list of registered drivers.
1117  * Returns a negative value on error, otherwise 0.
1118  * If no error occurred, the driver remains registered even if
1119  * no device was claimed during registration.
1120  */
1121 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1122                           const char *mod_name)
1123 {
1124         int error;
1125
1126         /* initialize common driver fields */
1127         drv->driver.name = drv->name;
1128         drv->driver.bus = &pci_bus_type;
1129         drv->driver.owner = owner;
1130         drv->driver.mod_name = mod_name;
1131
1132         spin_lock_init(&drv->dynids.lock);
1133         INIT_LIST_HEAD(&drv->dynids.list);
1134
1135         /* register with core */
1136         error = driver_register(&drv->driver);
1137         if (error)
1138                 goto out;
1139
1140         error = pci_create_newid_files(drv);
1141         if (error)
1142                 goto out_newid;
1143 out:
1144         return error;
1145
1146 out_newid:
1147         driver_unregister(&drv->driver);
1148         goto out;
1149 }
1150
1151 /**
1152  * pci_unregister_driver - unregister a pci driver
1153  * @drv: the driver structure to unregister
1154  *
1155  * Deletes the driver structure from the list of registered PCI drivers,
1156  * gives it a chance to clean up by calling its remove() function for
1157  * each device it was responsible for, and marks those devices as
1158  * driverless.
1159  */
1160
1161 void
1162 pci_unregister_driver(struct pci_driver *drv)
1163 {
1164         pci_remove_newid_files(drv);
1165         driver_unregister(&drv->driver);
1166         pci_free_dynids(drv);
1167 }
1168
1169 static struct pci_driver pci_compat_driver = {
1170         .name = "compat"
1171 };
1172
1173 /**
1174  * pci_dev_driver - get the pci_driver of a device
1175  * @dev: the device to query
1176  *
1177  * Returns the appropriate pci_driver structure or %NULL if there is no
1178  * registered driver for the device.
1179  */
1180 struct pci_driver *
1181 pci_dev_driver(const struct pci_dev *dev)
1182 {
1183         if (dev->driver)
1184                 return dev->driver;
1185         else {
1186                 int i;
1187                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1188                         if (dev->resource[i].flags & IORESOURCE_BUSY)
1189                                 return &pci_compat_driver;
1190         }
1191         return NULL;
1192 }
1193
1194 /**
1195  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1196  * @dev: the PCI device structure to match against
1197  * @drv: the device driver to search for matching PCI device id structures
1198  *
1199  * Used by a driver to check whether a PCI device present in the
1200  * system is in its list of supported devices. Returns the matching
1201  * pci_device_id structure or %NULL if there is no match.
1202  */
1203 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1204 {
1205         struct pci_dev *pci_dev = to_pci_dev(dev);
1206         struct pci_driver *pci_drv = to_pci_driver(drv);
1207         const struct pci_device_id *found_id;
1208
1209         found_id = pci_match_device(pci_drv, pci_dev);
1210         if (found_id)
1211                 return 1;
1212
1213         return 0;
1214 }
1215
1216 /**
1217  * pci_dev_get - increments the reference count of the pci device structure
1218  * @dev: the device being referenced
1219  *
1220  * Each live reference to a device should be refcounted.
1221  *
1222  * Drivers for PCI devices should normally record such references in
1223  * their probe() methods, when they bind to a device, and release
1224  * them by calling pci_dev_put(), in their disconnect() methods.
1225  *
1226  * A pointer to the device with the incremented reference counter is returned.
1227  */
1228 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1229 {
1230         if (dev)
1231                 get_device(&dev->dev);
1232         return dev;
1233 }
1234
1235 /**
1236  * pci_dev_put - release a use of the pci device structure
1237  * @dev: device that's been disconnected
1238  *
1239  * Must be called when a user of a device is finished with it.  When the last
1240  * user of the device calls this function, the memory of the device is freed.
1241  */
1242 void pci_dev_put(struct pci_dev *dev)
1243 {
1244         if (dev)
1245                 put_device(&dev->dev);
1246 }
1247
1248 #ifndef CONFIG_HOTPLUG
1249 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1250 {
1251         return -ENODEV;
1252 }
1253 #endif
1254
1255 struct bus_type pci_bus_type = {
1256         .name           = "pci",
1257         .match          = pci_bus_match,
1258         .uevent         = pci_uevent,
1259         .probe          = pci_device_probe,
1260         .remove         = pci_device_remove,
1261         .shutdown       = pci_device_shutdown,
1262         .dev_attrs      = pci_dev_attrs,
1263         .bus_attrs      = pci_bus_attrs,
1264         .pm             = PCI_PM_OPS_PTR,
1265 };
1266
1267 static int __init pci_driver_init(void)
1268 {
1269         return bus_register(&pci_bus_type);
1270 }
1271
1272 postcore_initcall(pci_driver_init);
1273
1274 EXPORT_SYMBOL_GPL(pci_add_dynid);
1275 EXPORT_SYMBOL(pci_match_id);
1276 EXPORT_SYMBOL(__pci_register_driver);
1277 EXPORT_SYMBOL(pci_unregister_driver);
1278 EXPORT_SYMBOL(pci_dev_driver);
1279 EXPORT_SYMBOL(pci_bus_type);
1280 EXPORT_SYMBOL(pci_dev_get);
1281 EXPORT_SYMBOL(pci_dev_put);