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. Don't touch devices in D3cold or unknown states.
 394          */
 395         if (pci_dev->current_state <= PCI_D3hot)
 396                 pci_clear_master(pci_dev);
 397 }
 398
 399 #ifdef CONFIG_PM
 400
 401 /* Auxiliary functions used for system resume and run-time resume. */
 402
 403 /**
 404  * pci_restore_standard_config - restore standard config registers of PCI device
 405  * @pci_dev: PCI device to handle
 406  */
 407 static int pci_restore_standard_config(struct pci_dev *pci_dev)
 408 {
 409         pci_update_current_state(pci_dev, PCI_UNKNOWN);
 410
 411         if (pci_dev->current_state != PCI_D0) {
 412                 int error = pci_set_power_state(pci_dev, PCI_D0);
 413                 if (error)
 414                         return error;
 415         }
 416
 417         pci_restore_state(pci_dev);
 418         return 0;
 419 }
 420
 421 #endif
 422
 423 #ifdef CONFIG_PM_SLEEP
 424
 425 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
 426 {
 427         pci_power_up(pci_dev);
 428         pci_restore_state(pci_dev);
 429         pci_fixup_device(pci_fixup_resume_early, pci_dev);
 430 }
 431
 432 /*
 433  * Default "suspend" method for devices that have no driver provided suspend,
 434  * or not even a driver at all (second part).
 435  */
 436 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
 437 {
 438         /*
 439          * mark its power state as "unknown", since we don't know if
 440          * e.g. the BIOS will change its device state when we suspend.
 441          */
 442         if (pci_dev->current_state == PCI_D0)
 443                 pci_dev->current_state = PCI_UNKNOWN;
 444 }
 445
 446 /*
 447  * Default "resume" method for devices that have no driver provided resume,
 448  * or not even a driver at all (second part).
 449  */
 450 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
 451 {
 452         int retval;
 453
 454         /* if the device was enabled before suspend, reenable */
 455         retval = pci_reenable_device(pci_dev);
 456         /*
 457          * if the device was busmaster before the suspend, make it busmaster
 458          * again
 459          */
 460         if (pci_dev->is_busmaster)
 461                 pci_set_master(pci_dev);
 462
 463         return retval;
 464 }
 465
 466 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
 467 {
 468         struct pci_dev * pci_dev = to_pci_dev(dev);
 469         struct pci_driver * drv = pci_dev->driver;
 470
 471         if (drv && drv->suspend) {
 472                 pci_power_t prev = pci_dev->current_state;
 473                 int error;
 474
 475                 error = drv->suspend(pci_dev, state);
 476                 suspend_report_result(drv->suspend, error);
 477                 if (error)
 478                         return error;
 479
 480                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 481                     && pci_dev->current_state != PCI_UNKNOWN) {
 482                         WARN_ONCE(pci_dev->current_state != prev,
 483                                 "PCI PM: Device state not saved by %pF\n",
 484                                 drv->suspend);
 485                 }
 486         }
 487
 488         pci_fixup_device(pci_fixup_suspend, pci_dev);
 489
 490         return 0;
 491 }
 492
 493 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 494 {
 495         struct pci_dev * pci_dev = to_pci_dev(dev);
 496         struct pci_driver * drv = pci_dev->driver;
 497
 498         if (drv && drv->suspend_late) {
 499                 pci_power_t prev = pci_dev->current_state;
 500                 int error;
 501
 502                 error = drv->suspend_late(pci_dev, state);
 503                 suspend_report_result(drv->suspend_late, error);
 504                 if (error)
 505                         return error;
 506
 507                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 508                     && pci_dev->current_state != PCI_UNKNOWN) {
 509                         WARN_ONCE(pci_dev->current_state != prev,
 510                                 "PCI PM: Device state not saved by %pF\n",
 511                                 drv->suspend_late);
 512                         return 0;
 513                 }
 514         }
 515
 516         if (!pci_dev->state_saved)
 517                 pci_save_state(pci_dev);
 518
 519         pci_pm_set_unknown_state(pci_dev);
 520
 521         return 0;
 522 }
 523
 524 static int pci_legacy_resume_early(struct device *dev)
 525 {
 526         struct pci_dev * pci_dev = to_pci_dev(dev);
 527         struct pci_driver * drv = pci_dev->driver;
 528
 529         return drv && drv->resume_early ?
 530                         drv->resume_early(pci_dev) : 0;
 531 }
 532
 533 static int pci_legacy_resume(struct device *dev)
 534 {
 535         struct pci_dev * pci_dev = to_pci_dev(dev);
 536         struct pci_driver * drv = pci_dev->driver;
 537
 538         pci_fixup_device(pci_fixup_resume, pci_dev);
 539
 540         return drv && drv->resume ?
 541                         drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
 542 }
 543
 544 /* Auxiliary functions used by the new power management framework */
 545
 546 static void pci_pm_default_resume(struct pci_dev *pci_dev)
 547 {
 548         pci_fixup_device(pci_fixup_resume, pci_dev);
 549
 550         if (!pci_is_bridge(pci_dev))
 551                 pci_enable_wake(pci_dev, PCI_D0, false);
 552 }
 553
 554 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
 555 {
 556         /* Disable non-bridge devices without PM support */
 557         if (!pci_is_bridge(pci_dev))
 558                 pci_disable_enabled_device(pci_dev);
 559 }
 560
 561 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
 562 {
 563         struct pci_driver *drv = pci_dev->driver;
 564         bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
 565                 || drv->resume_early);
 566
 567         /*
 568          * Legacy PM support is used by default, so warn if the new framework is
 569          * supported as well.  Drivers are supposed to support either the
 570          * former, or the latter, but not both at the same time.
 571          */
 572         WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
 573                 drv->name, pci_dev->vendor, pci_dev->device);
 574
 575         return ret;
 576 }
 577
 578 /* New power management framework */
 579
 580 static int pci_pm_prepare(struct device *dev)
 581 {
 582         struct device_driver *drv = dev->driver;
 583         int error = 0;
 584
 585         /*
 586          * PCI devices suspended at run time need to be resumed at this
 587          * point, because in general it is necessary to reconfigure them for
 588          * system suspend.  Namely, if the device is supposed to wake up the
 589          * system from the sleep state, we may need to reconfigure it for this
 590          * purpose.  In turn, if the device is not supposed to wake up the
 591          * system from the sleep state, we'll have to prevent it from signaling
 592          * wake-up.
 593          */
 594         pm_runtime_resume(dev);
 595
 596         if (drv && drv->pm && drv->pm->prepare)
 597                 error = drv->pm->prepare(dev);
 598
 599         return error;
 600 }
 601
 602 static void pci_pm_complete(struct device *dev)
 603 {
 604         struct device_driver *drv = dev->driver;
 605
 606         if (drv && drv->pm && drv->pm->complete)
 607                 drv->pm->complete(dev);
 608 }
 609
 610 #else /* !CONFIG_PM_SLEEP */
 611
 612 #define pci_pm_prepare  NULL
 613 #define pci_pm_complete NULL
 614
 615 #endif /* !CONFIG_PM_SLEEP */
 616
 617 #ifdef CONFIG_SUSPEND
 618
 619 static int pci_pm_suspend(struct device *dev)
 620 {
 621         struct pci_dev *pci_dev = to_pci_dev(dev);
 622         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 623
 624         if (pci_has_legacy_pm_support(pci_dev))
 625                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
 626
 627         if (!pm) {
 628                 pci_pm_default_suspend(pci_dev);
 629                 goto Fixup;
 630         }
 631
 632         pci_dev->state_saved = false;
 633         if (pm->suspend) {
 634                 pci_power_t prev = pci_dev->current_state;
 635                 int error;
 636
 637                 error = pm->suspend(dev);
 638                 suspend_report_result(pm->suspend, error);
 639                 if (error)
 640                         return error;
 641
 642                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 643                     && pci_dev->current_state != PCI_UNKNOWN) {
 644                         WARN_ONCE(pci_dev->current_state != prev,
 645                                 "PCI PM: State of device not saved by %pF\n",
 646                                 pm->suspend);
 647                 }
 648         }
 649
 650  Fixup:
 651         pci_fixup_device(pci_fixup_suspend, pci_dev);
 652
 653         return 0;
 654 }
 655
 656 static int pci_pm_suspend_noirq(struct device *dev)
 657 {
 658         struct pci_dev *pci_dev = to_pci_dev(dev);
 659         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 660
 661         if (pci_has_legacy_pm_support(pci_dev))
 662                 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 663
 664         if (!pm) {
 665                 pci_save_state(pci_dev);
 666                 return 0;
 667         }
 668
 669         if (pm->suspend_noirq) {
 670                 pci_power_t prev = pci_dev->current_state;
 671                 int error;
 672
 673                 error = pm->suspend_noirq(dev);
 674                 suspend_report_result(pm->suspend_noirq, error);
 675                 if (error)
 676                         return error;
 677
 678                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 679                     && pci_dev->current_state != PCI_UNKNOWN) {
 680                         WARN_ONCE(pci_dev->current_state != prev,
 681                                 "PCI PM: State of device not saved by %pF\n",
 682                                 pm->suspend_noirq);
 683                         return 0;
 684                 }
 685         }
 686
 687         if (!pci_dev->state_saved) {
 688                 pci_save_state(pci_dev);
 689                 if (!pci_is_bridge(pci_dev))
 690                         pci_prepare_to_sleep(pci_dev);
 691         }
 692
 693         pci_pm_set_unknown_state(pci_dev);
 694
 695         /*
 696          * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
 697          * PCI COMMAND register isn't 0, the BIOS assumes that the controller
 698          * hasn't been quiesced and tries to turn it off.  If the controller
 699          * is already in D3, this can hang or cause memory corruption.
 700          *
 701          * Since the value of the COMMAND register doesn't matter once the
 702          * device has been suspended, we can safely set it to 0 here.
 703          */
 704         if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
 705                 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
 706
 707         return 0;
 708 }
 709
 710 static int pci_pm_resume_noirq(struct device *dev)
 711 {
 712         struct pci_dev *pci_dev = to_pci_dev(dev);
 713         struct device_driver *drv = dev->driver;
 714         int error = 0;
 715
 716         pci_pm_default_resume_early(pci_dev);
 717
 718         if (pci_has_legacy_pm_support(pci_dev))
 719                 return pci_legacy_resume_early(dev);
 720
 721         if (drv && drv->pm && drv->pm->resume_noirq)
 722                 error = drv->pm->resume_noirq(dev);
 723
 724         return error;
 725 }
 726
 727 static int pci_pm_resume(struct device *dev)
 728 {
 729         struct pci_dev *pci_dev = to_pci_dev(dev);
 730         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 731         int error = 0;
 732
 733         /*
 734          * This is necessary for the suspend error path in which resume is
 735          * called without restoring the standard config registers of the device.
 736          */
 737         if (pci_dev->state_saved)
 738                 pci_restore_standard_config(pci_dev);
 739
 740         if (pci_has_legacy_pm_support(pci_dev))
 741                 return pci_legacy_resume(dev);
 742
 743         pci_pm_default_resume(pci_dev);
 744
 745         if (pm) {
 746                 if (pm->resume)
 747                         error = pm->resume(dev);
 748         } else {
 749                 pci_pm_reenable_device(pci_dev);
 750         }
 751
 752         return error;
 753 }
 754
 755 #else /* !CONFIG_SUSPEND */
 756
 757 #define pci_pm_suspend          NULL
 758 #define pci_pm_suspend_noirq    NULL
 759 #define pci_pm_resume           NULL
 760 #define pci_pm_resume_noirq     NULL
 761
 762 #endif /* !CONFIG_SUSPEND */
 763
 764 #ifdef CONFIG_HIBERNATE_CALLBACKS
 765
 766 static int pci_pm_freeze(struct device *dev)
 767 {
 768         struct pci_dev *pci_dev = to_pci_dev(dev);
 769         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 770
 771         if (pci_has_legacy_pm_support(pci_dev))
 772                 return pci_legacy_suspend(dev, PMSG_FREEZE);
 773
 774         if (!pm) {
 775                 pci_pm_default_suspend(pci_dev);
 776                 return 0;
 777         }
 778
 779         pci_dev->state_saved = false;
 780         if (pm->freeze) {
 781                 int error;
 782
 783                 error = pm->freeze(dev);
 784                 suspend_report_result(pm->freeze, error);
 785                 if (error)
 786                         return error;
 787         }
 788
 789         return 0;
 790 }
 791
 792 static int pci_pm_freeze_noirq(struct device *dev)
 793 {
 794         struct pci_dev *pci_dev = to_pci_dev(dev);
 795         struct device_driver *drv = dev->driver;
 796
 797         if (pci_has_legacy_pm_support(pci_dev))
 798                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
 799
 800         if (drv && drv->pm && drv->pm->freeze_noirq) {
 801                 int error;
 802
 803                 error = drv->pm->freeze_noirq(dev);
 804                 suspend_report_result(drv->pm->freeze_noirq, error);
 805                 if (error)
 806                         return error;
 807         }
 808
 809         if (!pci_dev->state_saved)
 810                 pci_save_state(pci_dev);
 811
 812         pci_pm_set_unknown_state(pci_dev);
 813
 814         return 0;
 815 }
 816
 817 static int pci_pm_thaw_noirq(struct device *dev)
 818 {
 819         struct pci_dev *pci_dev = to_pci_dev(dev);
 820         struct device_driver *drv = dev->driver;
 821         int error = 0;
 822
 823         if (pci_has_legacy_pm_support(pci_dev))
 824                 return pci_legacy_resume_early(dev);
 825
 826         pci_update_current_state(pci_dev, PCI_D0);
 827
 828         if (drv && drv->pm && drv->pm->thaw_noirq)
 829                 error = drv->pm->thaw_noirq(dev);
 830
 831         return error;
 832 }
 833
 834 static int pci_pm_thaw(struct device *dev)
 835 {
 836         struct pci_dev *pci_dev = to_pci_dev(dev);
 837         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 838         int error = 0;
 839
 840         if (pci_has_legacy_pm_support(pci_dev))
 841                 return pci_legacy_resume(dev);
 842
 843         if (pm) {
 844                 if (pm->thaw)
 845                         error = pm->thaw(dev);
 846         } else {
 847                 pci_pm_reenable_device(pci_dev);
 848         }
 849
 850         pci_dev->state_saved = false;
 851
 852         return error;
 853 }
 854
 855 static int pci_pm_poweroff(struct device *dev)
 856 {
 857         struct pci_dev *pci_dev = to_pci_dev(dev);
 858         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 859
 860         if (pci_has_legacy_pm_support(pci_dev))
 861                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
 862
 863         if (!pm) {
 864                 pci_pm_default_suspend(pci_dev);
 865                 goto Fixup;
 866         }
 867
 868         pci_dev->state_saved = false;
 869         if (pm->poweroff) {
 870                 int error;
 871
 872                 error = pm->poweroff(dev);
 873                 suspend_report_result(pm->poweroff, error);
 874                 if (error)
 875                         return error;
 876         }
 877
 878  Fixup:
 879         pci_fixup_device(pci_fixup_suspend, pci_dev);
 880
 881         return 0;
 882 }
 883
 884 static int pci_pm_poweroff_noirq(struct device *dev)
 885 {
 886         struct pci_dev *pci_dev = to_pci_dev(dev);
 887         struct device_driver *drv = dev->driver;
 888
 889         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
 890                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 891
 892         if (!drv || !drv->pm)
 893                 return 0;
 894
 895         if (drv->pm->poweroff_noirq) {
 896                 int error;
 897
 898                 error = drv->pm->poweroff_noirq(dev);
 899                 suspend_report_result(drv->pm->poweroff_noirq, error);
 900                 if (error)
 901                         return error;
 902         }
 903
 904         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
 905                 pci_prepare_to_sleep(pci_dev);
 906
 907         /*
 908          * The reason for doing this here is the same as for the analogous code
 909          * in pci_pm_suspend_noirq().
 910          */
 911         if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
 912                 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
 913
 914         return 0;
 915 }
 916
 917 static int pci_pm_restore_noirq(struct device *dev)
 918 {
 919         struct pci_dev *pci_dev = to_pci_dev(dev);
 920         struct device_driver *drv = dev->driver;
 921         int error = 0;
 922
 923         pci_pm_default_resume_early(pci_dev);
 924
 925         if (pci_has_legacy_pm_support(pci_dev))
 926                 return pci_legacy_resume_early(dev);
 927
 928         if (drv && drv->pm && drv->pm->restore_noirq)
 929                 error = drv->pm->restore_noirq(dev);
 930
 931         return error;
 932 }
 933
 934 static int pci_pm_restore(struct device *dev)
 935 {
 936         struct pci_dev *pci_dev = to_pci_dev(dev);
 937         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 938         int error = 0;
 939
 940         /*
 941          * This is necessary for the hibernation error path in which restore is
 942          * called without restoring the standard config registers of the device.
 943          */
 944         if (pci_dev->state_saved)
 945                 pci_restore_standard_config(pci_dev);
 946
 947         if (pci_has_legacy_pm_support(pci_dev))
 948                 return pci_legacy_resume(dev);
 949
 950         pci_pm_default_resume(pci_dev);
 951
 952         if (pm) {
 953                 if (pm->restore)
 954                         error = pm->restore(dev);
 955         } else {
 956                 pci_pm_reenable_device(pci_dev);
 957         }
 958
 959         return error;
 960 }
 961
 962 #else /* !CONFIG_HIBERNATE_CALLBACKS */
 963
 964 #define pci_pm_freeze           NULL
 965 #define pci_pm_freeze_noirq     NULL
 966 #define pci_pm_thaw             NULL
 967 #define pci_pm_thaw_noirq       NULL
 968 #define pci_pm_poweroff         NULL
 969 #define pci_pm_poweroff_noirq   NULL
 970 #define pci_pm_restore          NULL
 971 #define pci_pm_restore_noirq    NULL
 972
 973 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
 974
 975 #ifdef CONFIG_PM_RUNTIME
 976
 977 static int pci_pm_runtime_suspend(struct device *dev)
 978 {
 979         struct pci_dev *pci_dev = to_pci_dev(dev);
 980         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 981         pci_power_t prev = pci_dev->current_state;
 982         int error;
 983
 984         /*
 985          * If pci_dev->driver is not set (unbound), the device should
 986          * always remain in D0 regardless of the runtime PM status
 987          */
 988         if (!pci_dev->driver)
 989                 return 0;
 990
 991         if (!pm || !pm->runtime_suspend)
 992                 return -ENOSYS;
 993
 994         pci_dev->state_saved = false;
 995         pci_dev->no_d3cold = false;
 996         error = pm->runtime_suspend(dev);
 997         suspend_report_result(pm->runtime_suspend, error);
 998         if (error)
 999                 return error;
1000         if (!pci_dev->d3cold_allowed)
1001                 pci_dev->no_d3cold = true;
1002
1003         pci_fixup_device(pci_fixup_suspend, pci_dev);
1004
1005         if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1006             && pci_dev->current_state != PCI_UNKNOWN) {
1007                 WARN_ONCE(pci_dev->current_state != prev,
1008                         "PCI PM: State of device not saved by %pF\n",
1009                         pm->runtime_suspend);
1010                 return 0;
1011         }
1012
1013         if (!pci_dev->state_saved) {
1014                 pci_save_state(pci_dev);
1015                 pci_finish_runtime_suspend(pci_dev);
1016         }
1017
1018         return 0;
1019 }
1020
1021 static int pci_pm_runtime_resume(struct device *dev)
1022 {
1023         int rc;
1024         struct pci_dev *pci_dev = to_pci_dev(dev);
1025         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1026
1027         /*
1028          * If pci_dev->driver is not set (unbound), the device should
1029          * always remain in D0 regardless of the runtime PM status
1030          */
1031         if (!pci_dev->driver)
1032                 return 0;
1033
1034         if (!pm || !pm->runtime_resume)
1035                 return -ENOSYS;
1036
1037         pci_restore_standard_config(pci_dev);
1038         pci_fixup_device(pci_fixup_resume_early, pci_dev);
1039         __pci_enable_wake(pci_dev, PCI_D0, true, false);
1040         pci_fixup_device(pci_fixup_resume, pci_dev);
1041
1042         rc = pm->runtime_resume(dev);
1043
1044         pci_dev->runtime_d3cold = false;
1045
1046         return rc;
1047 }
1048
1049 static int pci_pm_runtime_idle(struct device *dev)
1050 {
1051         struct pci_dev *pci_dev = to_pci_dev(dev);
1052         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1053
1054         /*
1055          * If pci_dev->driver is not set (unbound), the device should
1056          * always remain in D0 regardless of the runtime PM status
1057          */
1058         if (!pci_dev->driver)
1059                 goto out;
1060
1061         if (!pm)
1062                 return -ENOSYS;
1063
1064         if (pm->runtime_idle) {
1065                 int ret = pm->runtime_idle(dev);
1066                 if (ret)
1067                         return ret;
1068         }
1069
1070 out:
1071         pm_runtime_suspend(dev);
1072         return 0;
1073 }
1074
1075 #else /* !CONFIG_PM_RUNTIME */
1076
1077 #define pci_pm_runtime_suspend  NULL
1078 #define pci_pm_runtime_resume   NULL
1079 #define pci_pm_runtime_idle     NULL
1080
1081 #endif /* !CONFIG_PM_RUNTIME */
1082
1083 #ifdef CONFIG_PM
1084
1085 const struct dev_pm_ops pci_dev_pm_ops = {
1086         .prepare = pci_pm_prepare,
1087         .complete = pci_pm_complete,
1088         .suspend = pci_pm_suspend,
1089         .resume = pci_pm_resume,
1090         .freeze = pci_pm_freeze,
1091         .thaw = pci_pm_thaw,
1092         .poweroff = pci_pm_poweroff,
1093         .restore = pci_pm_restore,
1094         .suspend_noirq = pci_pm_suspend_noirq,
1095         .resume_noirq = pci_pm_resume_noirq,
1096         .freeze_noirq = pci_pm_freeze_noirq,
1097         .thaw_noirq = pci_pm_thaw_noirq,
1098         .poweroff_noirq = pci_pm_poweroff_noirq,
1099         .restore_noirq = pci_pm_restore_noirq,
1100         .runtime_suspend = pci_pm_runtime_suspend,
1101         .runtime_resume = pci_pm_runtime_resume,
1102         .runtime_idle = pci_pm_runtime_idle,
1103 };
1104
1105 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
1106
1107 #else /* !COMFIG_PM_OPS */
1108
1109 #define PCI_PM_OPS_PTR  NULL
1110
1111 #endif /* !COMFIG_PM_OPS */
1112
1113 /**
1114  * __pci_register_driver - register a new pci driver
1115  * @drv: the driver structure to register
1116  * @owner: owner module of drv
1117  * @mod_name: module name string
1118  *
1119  * Adds the driver structure to the list of registered drivers.
1120  * Returns a negative value on error, otherwise 0.
1121  * If no error occurred, the driver remains registered even if
1122  * no device was claimed during registration.
1123  */
1124 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1125                           const char *mod_name)
1126 {
1127         /* initialize common driver fields */
1128         drv->driver.name = drv->name;
1129         drv->driver.bus = &pci_bus_type;
1130         drv->driver.owner = owner;
1131         drv->driver.mod_name = mod_name;
1132
1133         spin_lock_init(&drv->dynids.lock);
1134         INIT_LIST_HEAD(&drv->dynids.list);
1135
1136         /* register with core */
1137         return driver_register(&drv->driver);
1138 }
1139
1140 /**
1141  * pci_unregister_driver - unregister a pci driver
1142  * @drv: the driver structure to unregister
1143  *
1144  * Deletes the driver structure from the list of registered PCI drivers,
1145  * gives it a chance to clean up by calling its remove() function for
1146  * each device it was responsible for, and marks those devices as
1147  * driverless.
1148  */
1149
1150 void
1151 pci_unregister_driver(struct pci_driver *drv)
1152 {
1153         driver_unregister(&drv->driver);
1154         pci_free_dynids(drv);
1155 }
1156
1157 static struct pci_driver pci_compat_driver = {
1158         .name = "compat"
1159 };
1160
1161 /**
1162  * pci_dev_driver - get the pci_driver of a device
1163  * @dev: the device to query
1164  *
1165  * Returns the appropriate pci_driver structure or %NULL if there is no
1166  * registered driver for the device.
1167  */
1168 struct pci_driver *
1169 pci_dev_driver(const struct pci_dev *dev)
1170 {
1171         if (dev->driver)
1172                 return dev->driver;
1173         else {
1174                 int i;
1175                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1176                         if (dev->resource[i].flags & IORESOURCE_BUSY)
1177                                 return &pci_compat_driver;
1178         }
1179         return NULL;
1180 }
1181
1182 /**
1183  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1184  * @dev: the PCI device structure to match against
1185  * @drv: the device driver to search for matching PCI device id structures
1186  *
1187  * Used by a driver to check whether a PCI device present in the
1188  * system is in its list of supported devices. Returns the matching
1189  * pci_device_id structure or %NULL if there is no match.
1190  */
1191 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1192 {
1193         struct pci_dev *pci_dev = to_pci_dev(dev);
1194         struct pci_driver *pci_drv;
1195         const struct pci_device_id *found_id;
1196
1197         if (!pci_dev->match_driver)
1198                 return 0;
1199
1200         pci_drv = to_pci_driver(drv);
1201         found_id = pci_match_device(pci_drv, pci_dev);
1202         if (found_id)
1203                 return 1;
1204
1205         return 0;
1206 }
1207
1208 /**
1209  * pci_dev_get - increments the reference count of the pci device structure
1210  * @dev: the device being referenced
1211  *
1212  * Each live reference to a device should be refcounted.
1213  *
1214  * Drivers for PCI devices should normally record such references in
1215  * their probe() methods, when they bind to a device, and release
1216  * them by calling pci_dev_put(), in their disconnect() methods.
1217  *
1218  * A pointer to the device with the incremented reference counter is returned.
1219  */
1220 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1221 {
1222         if (dev)
1223                 get_device(&dev->dev);
1224         return dev;
1225 }
1226
1227 /**
1228  * pci_dev_put - release a use of the pci device structure
1229  * @dev: device that's been disconnected
1230  *
1231  * Must be called when a user of a device is finished with it.  When the last
1232  * user of the device calls this function, the memory of the device is freed.
1233  */
1234 void pci_dev_put(struct pci_dev *dev)
1235 {
1236         if (dev)
1237                 put_device(&dev->dev);
1238 }
1239
1240 static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1241 {
1242         struct pci_dev *pdev;
1243
1244         if (!dev)
1245                 return -ENODEV;
1246
1247         pdev = to_pci_dev(dev);
1248         if (!pdev)
1249                 return -ENODEV;
1250
1251         if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1252                 return -ENOMEM;
1253
1254         if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1255                 return -ENOMEM;
1256
1257         if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1258                            pdev->subsystem_device))
1259                 return -ENOMEM;
1260
1261         if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1262                 return -ENOMEM;
1263
1264         if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
1265                            pdev->vendor, pdev->device,
1266                            pdev->subsystem_vendor, pdev->subsystem_device,
1267                            (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1268                            (u8)(pdev->class)))
1269                 return -ENOMEM;
1270         return 0;
1271 }
1272
1273 struct bus_type pci_bus_type = {
1274         .name           = "pci",
1275         .match          = pci_bus_match,
1276         .uevent         = pci_uevent,
1277         .probe          = pci_device_probe,
1278         .remove         = pci_device_remove,
1279         .shutdown       = pci_device_shutdown,
1280         .dev_attrs      = pci_dev_attrs,
1281         .bus_attrs      = pci_bus_attrs,
1282         .drv_attrs      = pci_drv_attrs,
1283         .pm             = PCI_PM_OPS_PTR,
1284 };
1285
1286 static int __init pci_driver_init(void)
1287 {
1288         return bus_register(&pci_bus_type);
1289 }
1290
1291 postcore_initcall(pci_driver_init);
1292
1293 EXPORT_SYMBOL_GPL(pci_add_dynid);
1294 EXPORT_SYMBOL(pci_match_id);
1295 EXPORT_SYMBOL(__pci_register_driver);
1296 EXPORT_SYMBOL(pci_unregister_driver);
1297 EXPORT_SYMBOL(pci_dev_driver);
1298 EXPORT_SYMBOL(pci_bus_type);
1299 EXPORT_SYMBOL(pci_dev_get);
1300 EXPORT_SYMBOL(pci_dev_put);