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