drivers/pci/pci-driver.c

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