drivers/pci/pci-driver.c

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