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