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