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
 767 /*
 768  * pcibios_pm_ops - provide arch-specific hooks when a PCI device is doing
 769  * a hibernate transition
 770  */
 771 struct dev_pm_ops __weak pcibios_pm_ops;
 772
 773 static int pci_pm_freeze(struct device *dev)
 774 {
 775         struct pci_dev *pci_dev = to_pci_dev(dev);
 776         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 777
 778         if (pci_has_legacy_pm_support(pci_dev))
 779                 return pci_legacy_suspend(dev, PMSG_FREEZE);
 780
 781         if (!pm) {
 782                 pci_pm_default_suspend(pci_dev);
 783                 return 0;
 784         }
 785
 786         pci_dev->state_saved = false;
 787         if (pm->freeze) {
 788                 int error;
 789
 790                 error = pm->freeze(dev);
 791                 suspend_report_result(pm->freeze, error);
 792                 if (error)
 793                         return error;
 794         }
 795
 796         if (pcibios_pm_ops.freeze)
 797                 return pcibios_pm_ops.freeze(dev);
 798
 799         return 0;
 800 }
 801
 802 static int pci_pm_freeze_noirq(struct device *dev)
 803 {
 804         struct pci_dev *pci_dev = to_pci_dev(dev);
 805         struct device_driver *drv = dev->driver;
 806
 807         if (pci_has_legacy_pm_support(pci_dev))
 808                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
 809
 810         if (drv && drv->pm && drv->pm->freeze_noirq) {
 811                 int error;
 812
 813                 error = drv->pm->freeze_noirq(dev);
 814                 suspend_report_result(drv->pm->freeze_noirq, error);
 815                 if (error)
 816                         return error;
 817         }
 818
 819         if (!pci_dev->state_saved)
 820                 pci_save_state(pci_dev);
 821
 822         pci_pm_set_unknown_state(pci_dev);
 823
 824         if (pcibios_pm_ops.freeze_noirq)
 825                 return pcibios_pm_ops.freeze_noirq(dev);
 826
 827         return 0;
 828 }
 829
 830 static int pci_pm_thaw_noirq(struct device *dev)
 831 {
 832         struct pci_dev *pci_dev = to_pci_dev(dev);
 833         struct device_driver *drv = dev->driver;
 834         int error = 0;
 835
 836         if (pcibios_pm_ops.thaw_noirq) {
 837                 error = pcibios_pm_ops.thaw_noirq(dev);
 838                 if (error)
 839                         return error;
 840         }
 841
 842         if (pci_has_legacy_pm_support(pci_dev))
 843                 return pci_legacy_resume_early(dev);
 844
 845         pci_update_current_state(pci_dev, PCI_D0);
 846
 847         if (drv && drv->pm && drv->pm->thaw_noirq)
 848                 error = drv->pm->thaw_noirq(dev);
 849
 850         return error;
 851 }
 852
 853 static int pci_pm_thaw(struct device *dev)
 854 {
 855         struct pci_dev *pci_dev = to_pci_dev(dev);
 856         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 857         int error = 0;
 858
 859         if (pcibios_pm_ops.thaw) {
 860                 error = pcibios_pm_ops.thaw(dev);
 861                 if (error)
 862                         return error;
 863         }
 864
 865         if (pci_has_legacy_pm_support(pci_dev))
 866                 return pci_legacy_resume(dev);
 867
 868         if (pm) {
 869                 if (pm->thaw)
 870                         error = pm->thaw(dev);
 871         } else {
 872                 pci_pm_reenable_device(pci_dev);
 873         }
 874
 875         pci_dev->state_saved = false;
 876
 877         return error;
 878 }
 879
 880 static int pci_pm_poweroff(struct device *dev)
 881 {
 882         struct pci_dev *pci_dev = to_pci_dev(dev);
 883         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 884
 885         if (pci_has_legacy_pm_support(pci_dev))
 886                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
 887
 888         if (!pm) {
 889                 pci_pm_default_suspend(pci_dev);
 890                 goto Fixup;
 891         }
 892
 893         pci_dev->state_saved = false;
 894         if (pm->poweroff) {
 895                 int error;
 896
 897                 error = pm->poweroff(dev);
 898                 suspend_report_result(pm->poweroff, error);
 899                 if (error)
 900                         return error;
 901         }
 902
 903  Fixup:
 904         pci_fixup_device(pci_fixup_suspend, pci_dev);
 905
 906         if (pcibios_pm_ops.poweroff)
 907                 return pcibios_pm_ops.poweroff(dev);
 908
 909         return 0;
 910 }
 911
 912 static int pci_pm_poweroff_noirq(struct device *dev)
 913 {
 914         struct pci_dev *pci_dev = to_pci_dev(dev);
 915         struct device_driver *drv = dev->driver;
 916
 917         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
 918                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 919
 920         if (!drv || !drv->pm)
 921                 return 0;
 922
 923         if (drv->pm->poweroff_noirq) {
 924                 int error;
 925
 926                 error = drv->pm->poweroff_noirq(dev);
 927                 suspend_report_result(drv->pm->poweroff_noirq, error);
 928                 if (error)
 929                         return error;
 930         }
 931
 932         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
 933                 pci_prepare_to_sleep(pci_dev);
 934
 935         /*
 936          * The reason for doing this here is the same as for the analogous code
 937          * in pci_pm_suspend_noirq().
 938          */
 939         if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
 940                 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
 941
 942         if (pcibios_pm_ops.poweroff_noirq)
 943                 return pcibios_pm_ops.poweroff_noirq(dev);
 944
 945         return 0;
 946 }
 947
 948 static int pci_pm_restore_noirq(struct device *dev)
 949 {
 950         struct pci_dev *pci_dev = to_pci_dev(dev);
 951         struct device_driver *drv = dev->driver;
 952         int error = 0;
 953
 954         if (pcibios_pm_ops.restore_noirq) {
 955                 error = pcibios_pm_ops.restore_noirq(dev);
 956                 if (error)
 957                         return error;
 958         }
 959
 960         pci_pm_default_resume_early(pci_dev);
 961
 962         if (pci_has_legacy_pm_support(pci_dev))
 963                 return pci_legacy_resume_early(dev);
 964
 965         if (drv && drv->pm && drv->pm->restore_noirq)
 966                 error = drv->pm->restore_noirq(dev);
 967
 968         return error;
 969 }
 970
 971 static int pci_pm_restore(struct device *dev)
 972 {
 973         struct pci_dev *pci_dev = to_pci_dev(dev);
 974         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 975         int error = 0;
 976
 977         if (pcibios_pm_ops.restore) {
 978                 error = pcibios_pm_ops.restore(dev);
 979                 if (error)
 980                         return error;
 981         }
 982
 983         /*
 984          * This is necessary for the hibernation error path in which restore is
 985          * called without restoring the standard config registers of the device.
 986          */
 987         if (pci_dev->state_saved)
 988                 pci_restore_standard_config(pci_dev);
 989
 990         if (pci_has_legacy_pm_support(pci_dev))
 991                 return pci_legacy_resume(dev);
 992
 993         pci_pm_default_resume(pci_dev);
 994
 995         if (pm) {
 996                 if (pm->restore)
 997                         error = pm->restore(dev);
 998         } else {
 999                 pci_pm_reenable_device(pci_dev);
1000         }
1001
1002         return error;
1003 }
1004
1005 #else /* !CONFIG_HIBERNATE_CALLBACKS */
1006
1007 #define pci_pm_freeze           NULL
1008 #define pci_pm_freeze_noirq     NULL
1009 #define pci_pm_thaw             NULL
1010 #define pci_pm_thaw_noirq       NULL
1011 #define pci_pm_poweroff         NULL
1012 #define pci_pm_poweroff_noirq   NULL
1013 #define pci_pm_restore          NULL
1014 #define pci_pm_restore_noirq    NULL
1015
1016 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
1017
1018 #ifdef CONFIG_PM_RUNTIME
1019
1020 static int pci_pm_runtime_suspend(struct device *dev)
1021 {
1022         struct pci_dev *pci_dev = to_pci_dev(dev);
1023         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1024         pci_power_t prev = pci_dev->current_state;
1025         int error;
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_suspend)
1035                 return -ENOSYS;
1036
1037         pci_dev->state_saved = false;
1038         pci_dev->no_d3cold = false;
1039         error = pm->runtime_suspend(dev);
1040         suspend_report_result(pm->runtime_suspend, error);
1041         if (error)
1042                 return error;
1043         if (!pci_dev->d3cold_allowed)
1044                 pci_dev->no_d3cold = true;
1045
1046         pci_fixup_device(pci_fixup_suspend, pci_dev);
1047
1048         if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1049             && pci_dev->current_state != PCI_UNKNOWN) {
1050                 WARN_ONCE(pci_dev->current_state != prev,
1051                         "PCI PM: State of device not saved by %pF\n",
1052                         pm->runtime_suspend);
1053                 return 0;
1054         }
1055
1056         if (!pci_dev->state_saved) {
1057                 pci_save_state(pci_dev);
1058                 pci_finish_runtime_suspend(pci_dev);
1059         }
1060
1061         return 0;
1062 }
1063
1064 static int pci_pm_runtime_resume(struct device *dev)
1065 {
1066         int rc;
1067         struct pci_dev *pci_dev = to_pci_dev(dev);
1068         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1069
1070         /*
1071          * If pci_dev->driver is not set (unbound), the device should
1072          * always remain in D0 regardless of the runtime PM status
1073          */
1074         if (!pci_dev->driver)
1075                 return 0;
1076
1077         if (!pm || !pm->runtime_resume)
1078                 return -ENOSYS;
1079
1080         pci_restore_standard_config(pci_dev);
1081         pci_fixup_device(pci_fixup_resume_early, pci_dev);
1082         __pci_enable_wake(pci_dev, PCI_D0, true, false);
1083         pci_fixup_device(pci_fixup_resume, pci_dev);
1084
1085         rc = pm->runtime_resume(dev);
1086
1087         pci_dev->runtime_d3cold = false;
1088
1089         return rc;
1090 }
1091
1092 static int pci_pm_runtime_idle(struct device *dev)
1093 {
1094         struct pci_dev *pci_dev = to_pci_dev(dev);
1095         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1096         int ret = 0;
1097
1098         /*
1099          * If pci_dev->driver is not set (unbound), the device should
1100          * always remain in D0 regardless of the runtime PM status
1101          */
1102         if (!pci_dev->driver)
1103                 return 0;
1104
1105         if (!pm)
1106                 return -ENOSYS;
1107
1108         if (pm->runtime_idle)
1109                 ret = pm->runtime_idle(dev);
1110
1111         return ret;
1112 }
1113
1114 #else /* !CONFIG_PM_RUNTIME */
1115
1116 #define pci_pm_runtime_suspend  NULL
1117 #define pci_pm_runtime_resume   NULL
1118 #define pci_pm_runtime_idle     NULL
1119
1120 #endif /* !CONFIG_PM_RUNTIME */
1121
1122 #ifdef CONFIG_PM
1123
1124 const struct dev_pm_ops pci_dev_pm_ops = {
1125         .prepare = pci_pm_prepare,
1126         .complete = pci_pm_complete,
1127         .suspend = pci_pm_suspend,
1128         .resume = pci_pm_resume,
1129         .freeze = pci_pm_freeze,
1130         .thaw = pci_pm_thaw,
1131         .poweroff = pci_pm_poweroff,
1132         .restore = pci_pm_restore,
1133         .suspend_noirq = pci_pm_suspend_noirq,
1134         .resume_noirq = pci_pm_resume_noirq,
1135         .freeze_noirq = pci_pm_freeze_noirq,
1136         .thaw_noirq = pci_pm_thaw_noirq,
1137         .poweroff_noirq = pci_pm_poweroff_noirq,
1138         .restore_noirq = pci_pm_restore_noirq,
1139         .runtime_suspend = pci_pm_runtime_suspend,
1140         .runtime_resume = pci_pm_runtime_resume,
1141         .runtime_idle = pci_pm_runtime_idle,
1142 };
1143
1144 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
1145
1146 #else /* !COMFIG_PM_OPS */
1147
1148 #define PCI_PM_OPS_PTR  NULL
1149
1150 #endif /* !COMFIG_PM_OPS */
1151
1152 /**
1153  * __pci_register_driver - register a new pci driver
1154  * @drv: the driver structure to register
1155  * @owner: owner module of drv
1156  * @mod_name: module name string
1157  *
1158  * Adds the driver structure to the list of registered drivers.
1159  * Returns a negative value on error, otherwise 0.
1160  * If no error occurred, the driver remains registered even if
1161  * no device was claimed during registration.
1162  */
1163 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1164                           const char *mod_name)
1165 {
1166         /* initialize common driver fields */
1167         drv->driver.name = drv->name;
1168         drv->driver.bus = &pci_bus_type;
1169         drv->driver.owner = owner;
1170         drv->driver.mod_name = mod_name;
1171
1172         spin_lock_init(&drv->dynids.lock);
1173         INIT_LIST_HEAD(&drv->dynids.list);
1174
1175         /* register with core */
1176         return driver_register(&drv->driver);
1177 }
1178
1179 /**
1180  * pci_unregister_driver - unregister a pci driver
1181  * @drv: the driver structure to unregister
1182  *
1183  * Deletes the driver structure from the list of registered PCI drivers,
1184  * gives it a chance to clean up by calling its remove() function for
1185  * each device it was responsible for, and marks those devices as
1186  * driverless.
1187  */
1188
1189 void
1190 pci_unregister_driver(struct pci_driver *drv)
1191 {
1192         driver_unregister(&drv->driver);
1193         pci_free_dynids(drv);
1194 }
1195
1196 static struct pci_driver pci_compat_driver = {
1197         .name = "compat"
1198 };
1199
1200 /**
1201  * pci_dev_driver - get the pci_driver of a device
1202  * @dev: the device to query
1203  *
1204  * Returns the appropriate pci_driver structure or %NULL if there is no
1205  * registered driver for the device.
1206  */
1207 struct pci_driver *
1208 pci_dev_driver(const struct pci_dev *dev)
1209 {
1210         if (dev->driver)
1211                 return dev->driver;
1212         else {
1213                 int i;
1214                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1215                         if (dev->resource[i].flags & IORESOURCE_BUSY)
1216                                 return &pci_compat_driver;
1217         }
1218         return NULL;
1219 }
1220
1221 /**
1222  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1223  * @dev: the PCI device structure to match against
1224  * @drv: the device driver to search for matching PCI device id structures
1225  *
1226  * Used by a driver to check whether a PCI device present in the
1227  * system is in its list of supported devices. Returns the matching
1228  * pci_device_id structure or %NULL if there is no match.
1229  */
1230 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1231 {
1232         struct pci_dev *pci_dev = to_pci_dev(dev);
1233         struct pci_driver *pci_drv;
1234         const struct pci_device_id *found_id;
1235
1236         if (!pci_dev->match_driver)
1237                 return 0;
1238
1239         pci_drv = to_pci_driver(drv);
1240         found_id = pci_match_device(pci_drv, pci_dev);
1241         if (found_id)
1242                 return 1;
1243
1244         return 0;
1245 }
1246
1247 /**
1248  * pci_dev_get - increments the reference count of the pci device structure
1249  * @dev: the device being referenced
1250  *
1251  * Each live reference to a device should be refcounted.
1252  *
1253  * Drivers for PCI devices should normally record such references in
1254  * their probe() methods, when they bind to a device, and release
1255  * them by calling pci_dev_put(), in their disconnect() methods.
1256  *
1257  * A pointer to the device with the incremented reference counter is returned.
1258  */
1259 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1260 {
1261         if (dev)
1262                 get_device(&dev->dev);
1263         return dev;
1264 }
1265
1266 /**
1267  * pci_dev_put - release a use of the pci device structure
1268  * @dev: device that's been disconnected
1269  *
1270  * Must be called when a user of a device is finished with it.  When the last
1271  * user of the device calls this function, the memory of the device is freed.
1272  */
1273 void pci_dev_put(struct pci_dev *dev)
1274 {
1275         if (dev)
1276                 put_device(&dev->dev);
1277 }
1278
1279 static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1280 {
1281         struct pci_dev *pdev;
1282
1283         if (!dev)
1284                 return -ENODEV;
1285
1286         pdev = to_pci_dev(dev);
1287         if (!pdev)
1288                 return -ENODEV;
1289
1290         if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1291                 return -ENOMEM;
1292
1293         if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1294                 return -ENOMEM;
1295
1296         if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1297                            pdev->subsystem_device))
1298                 return -ENOMEM;
1299
1300         if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1301                 return -ENOMEM;
1302
1303         if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
1304                            pdev->vendor, pdev->device,
1305                            pdev->subsystem_vendor, pdev->subsystem_device,
1306                            (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1307                            (u8)(pdev->class)))
1308                 return -ENOMEM;
1309         return 0;
1310 }
1311
1312 struct bus_type pci_bus_type = {
1313         .name           = "pci",
1314         .match          = pci_bus_match,
1315         .uevent         = pci_uevent,
1316         .probe          = pci_device_probe,
1317         .remove         = pci_device_remove,
1318         .shutdown       = pci_device_shutdown,
1319         .dev_attrs      = pci_dev_attrs,
1320         .bus_attrs      = pci_bus_attrs,
1321         .drv_attrs      = pci_drv_attrs,
1322         .pm             = PCI_PM_OPS_PTR,
1323 };
1324
1325 static int __init pci_driver_init(void)
1326 {
1327         return bus_register(&pci_bus_type);
1328 }
1329
1330 postcore_initcall(pci_driver_init);
1331
1332 EXPORT_SYMBOL_GPL(pci_add_dynid);
1333 EXPORT_SYMBOL(pci_match_id);
1334 EXPORT_SYMBOL(__pci_register_driver);
1335 EXPORT_SYMBOL(pci_unregister_driver);
1336 EXPORT_SYMBOL(pci_dev_driver);
1337 EXPORT_SYMBOL(pci_bus_type);
1338 EXPORT_SYMBOL(pci_dev_get);
1339 EXPORT_SYMBOL(pci_dev_put);