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 #ifdef CONFIG_PM
 425
 426 /* Auxiliary functions used for system resume and run-time resume. */
 427
 428 /**
 429  * pci_restore_standard_config - restore standard config registers of PCI device
 430  * @pci_dev: PCI device to handle
 431  */
 432 static int pci_restore_standard_config(struct pci_dev *pci_dev)
 433 {
 434         pci_update_current_state(pci_dev, PCI_UNKNOWN);
 435
 436         if (pci_dev->current_state != PCI_D0) {
 437                 int error = pci_set_power_state(pci_dev, PCI_D0);
 438                 if (error)
 439                         return error;
 440         }
 441
 442         pci_restore_state(pci_dev);
 443         return 0;
 444 }
 445
 446 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
 447 {
 448         pci_restore_standard_config(pci_dev);
 449         pci_fixup_device(pci_fixup_resume_early, pci_dev);
 450 }
 451
 452 #endif
 453
 454 #ifdef CONFIG_PM_SLEEP
 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         return 0;
 736 }
 737
 738 static int pci_pm_resume_noirq(struct device *dev)
 739 {
 740         struct pci_dev *pci_dev = to_pci_dev(dev);
 741         struct device_driver *drv = dev->driver;
 742         int error = 0;
 743
 744         pci_pm_default_resume_early(pci_dev);
 745
 746         if (pci_has_legacy_pm_support(pci_dev))
 747                 return pci_legacy_resume_early(dev);
 748
 749         if (drv && drv->pm && drv->pm->resume_noirq)
 750                 error = drv->pm->resume_noirq(dev);
 751
 752         return error;
 753 }
 754
 755 static int pci_pm_resume(struct device *dev)
 756 {
 757         struct pci_dev *pci_dev = to_pci_dev(dev);
 758         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 759         int error = 0;
 760
 761         /*
 762          * This is necessary for the suspend error path in which resume is
 763          * called without restoring the standard config registers of the device.
 764          */
 765         if (pci_dev->state_saved)
 766                 pci_restore_standard_config(pci_dev);
 767
 768         if (pci_has_legacy_pm_support(pci_dev))
 769                 return pci_legacy_resume(dev);
 770
 771         pci_pm_default_resume(pci_dev);
 772
 773         if (pm) {
 774                 if (pm->resume)
 775                         error = pm->resume(dev);
 776         } else {
 777                 pci_pm_reenable_device(pci_dev);
 778         }
 779
 780         return error;
 781 }
 782
 783 #else /* !CONFIG_SUSPEND */
 784
 785 #define pci_pm_suspend          NULL
 786 #define pci_pm_suspend_noirq    NULL
 787 #define pci_pm_resume           NULL
 788 #define pci_pm_resume_noirq     NULL
 789
 790 #endif /* !CONFIG_SUSPEND */
 791
 792 #ifdef CONFIG_HIBERNATE_CALLBACKS
 793
 794 static int pci_pm_freeze(struct device *dev)
 795 {
 796         struct pci_dev *pci_dev = to_pci_dev(dev);
 797         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 798
 799         if (pci_has_legacy_pm_support(pci_dev))
 800                 return pci_legacy_suspend(dev, PMSG_FREEZE);
 801
 802         if (!pm) {
 803                 pci_pm_default_suspend(pci_dev);
 804                 return 0;
 805         }
 806
 807         if (pm->freeze) {
 808                 int error;
 809
 810                 error = pm->freeze(dev);
 811                 suspend_report_result(pm->freeze, error);
 812                 if (error)
 813                         return error;
 814         }
 815
 816         return 0;
 817 }
 818
 819 static int pci_pm_freeze_noirq(struct device *dev)
 820 {
 821         struct pci_dev *pci_dev = to_pci_dev(dev);
 822         struct device_driver *drv = dev->driver;
 823
 824         if (pci_has_legacy_pm_support(pci_dev))
 825                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
 826
 827         if (drv && drv->pm && drv->pm->freeze_noirq) {
 828                 int error;
 829
 830                 error = drv->pm->freeze_noirq(dev);
 831                 suspend_report_result(drv->pm->freeze_noirq, error);
 832                 if (error)
 833                         return error;
 834         }
 835
 836         if (!pci_dev->state_saved)
 837                 pci_save_state(pci_dev);
 838
 839         pci_pm_set_unknown_state(pci_dev);
 840
 841         return 0;
 842 }
 843
 844 static int pci_pm_thaw_noirq(struct device *dev)
 845 {
 846         struct pci_dev *pci_dev = to_pci_dev(dev);
 847         struct device_driver *drv = dev->driver;
 848         int error = 0;
 849
 850         if (pci_has_legacy_pm_support(pci_dev))
 851                 return pci_legacy_resume_early(dev);
 852
 853         pci_update_current_state(pci_dev, PCI_D0);
 854
 855         if (drv && drv->pm && drv->pm->thaw_noirq)
 856                 error = drv->pm->thaw_noirq(dev);
 857
 858         return error;
 859 }
 860
 861 static int pci_pm_thaw(struct device *dev)
 862 {
 863         struct pci_dev *pci_dev = to_pci_dev(dev);
 864         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 865         int error = 0;
 866
 867         if (pci_has_legacy_pm_support(pci_dev))
 868                 return pci_legacy_resume(dev);
 869
 870         if (pm) {
 871                 if (pm->thaw)
 872                         error = pm->thaw(dev);
 873         } else {
 874                 pci_pm_reenable_device(pci_dev);
 875         }
 876
 877         pci_dev->state_saved = false;
 878
 879         return error;
 880 }
 881
 882 static int pci_pm_poweroff(struct device *dev)
 883 {
 884         struct pci_dev *pci_dev = to_pci_dev(dev);
 885         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 886
 887         if (pci_has_legacy_pm_support(pci_dev))
 888                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
 889
 890         if (!pm) {
 891                 pci_pm_default_suspend(pci_dev);
 892                 goto Fixup;
 893         }
 894
 895         if (pm->poweroff) {
 896                 int error;
 897
 898                 error = pm->poweroff(dev);
 899                 suspend_report_result(pm->poweroff, error);
 900                 if (error)
 901                         return error;
 902         }
 903
 904  Fixup:
 905         pci_fixup_device(pci_fixup_suspend, pci_dev);
 906
 907         return 0;
 908 }
 909
 910 static int pci_pm_poweroff_noirq(struct device *dev)
 911 {
 912         struct pci_dev *pci_dev = to_pci_dev(dev);
 913         struct device_driver *drv = dev->driver;
 914
 915         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
 916                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 917
 918         if (!drv || !drv->pm)
 919                 return 0;
 920
 921         if (drv->pm->poweroff_noirq) {
 922                 int error;
 923
 924                 error = drv->pm->poweroff_noirq(dev);
 925                 suspend_report_result(drv->pm->poweroff_noirq, error);
 926                 if (error)
 927                         return error;
 928         }
 929
 930         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
 931                 pci_prepare_to_sleep(pci_dev);
 932
 933         return 0;
 934 }
 935
 936 static int pci_pm_restore_noirq(struct device *dev)
 937 {
 938         struct pci_dev *pci_dev = to_pci_dev(dev);
 939         struct device_driver *drv = dev->driver;
 940         int error = 0;
 941
 942         pci_pm_default_resume_early(pci_dev);
 943
 944         if (pci_has_legacy_pm_support(pci_dev))
 945                 return pci_legacy_resume_early(dev);
 946
 947         if (drv && drv->pm && drv->pm->restore_noirq)
 948                 error = drv->pm->restore_noirq(dev);
 949
 950         return error;
 951 }
 952
 953 static int pci_pm_restore(struct device *dev)
 954 {
 955         struct pci_dev *pci_dev = to_pci_dev(dev);
 956         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 957         int error = 0;
 958
 959         /*
 960          * This is necessary for the hibernation error path in which restore is
 961          * called without restoring the standard config registers of the device.
 962          */
 963         if (pci_dev->state_saved)
 964                 pci_restore_standard_config(pci_dev);
 965
 966         if (pci_has_legacy_pm_support(pci_dev))
 967                 return pci_legacy_resume(dev);
 968
 969         pci_pm_default_resume(pci_dev);
 970
 971         if (pm) {
 972                 if (pm->restore)
 973                         error = pm->restore(dev);
 974         } else {
 975                 pci_pm_reenable_device(pci_dev);
 976         }
 977
 978         return error;
 979 }
 980
 981 #else /* !CONFIG_HIBERNATE_CALLBACKS */
 982
 983 #define pci_pm_freeze           NULL
 984 #define pci_pm_freeze_noirq     NULL
 985 #define pci_pm_thaw             NULL
 986 #define pci_pm_thaw_noirq       NULL
 987 #define pci_pm_poweroff         NULL
 988 #define pci_pm_poweroff_noirq   NULL
 989 #define pci_pm_restore          NULL
 990 #define pci_pm_restore_noirq    NULL
 991
 992 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
 993
 994 #ifdef CONFIG_PM_RUNTIME
 995
 996 static int pci_pm_runtime_suspend(struct device *dev)
 997 {
 998         struct pci_dev *pci_dev = to_pci_dev(dev);
 999         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1000         pci_power_t prev = pci_dev->current_state;
1001         int error;
1002
1003         if (!pm || !pm->runtime_suspend)
1004                 return -ENOSYS;
1005
1006         error = pm->runtime_suspend(dev);
1007         suspend_report_result(pm->runtime_suspend, error);
1008         if (error)
1009                 return error;
1010
1011         pci_fixup_device(pci_fixup_suspend, pci_dev);
1012
1013         if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1014             && pci_dev->current_state != PCI_UNKNOWN) {
1015                 WARN_ONCE(pci_dev->current_state != prev,
1016                         "PCI PM: State of device not saved by %pF\n",
1017                         pm->runtime_suspend);
1018                 return 0;
1019         }
1020
1021         if (!pci_dev->state_saved)
1022                 pci_save_state(pci_dev);
1023
1024         pci_finish_runtime_suspend(pci_dev);
1025
1026         return 0;
1027 }
1028
1029 static int pci_pm_runtime_resume(struct device *dev)
1030 {
1031         struct pci_dev *pci_dev = to_pci_dev(dev);
1032         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1033
1034         if (!pm || !pm->runtime_resume)
1035                 return -ENOSYS;
1036
1037         pci_pm_default_resume_early(pci_dev);
1038         __pci_enable_wake(pci_dev, PCI_D0, true, false);
1039         pci_fixup_device(pci_fixup_resume, pci_dev);
1040
1041         return pm->runtime_resume(dev);
1042 }
1043
1044 static int pci_pm_runtime_idle(struct device *dev)
1045 {
1046         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1047
1048         if (!pm)
1049                 return -ENOSYS;
1050
1051         if (pm->runtime_idle) {
1052                 int ret = pm->runtime_idle(dev);
1053                 if (ret)
1054                         return ret;
1055         }
1056
1057         pm_runtime_suspend(dev);
1058
1059         return 0;
1060 }
1061
1062 #else /* !CONFIG_PM_RUNTIME */
1063
1064 #define pci_pm_runtime_suspend  NULL
1065 #define pci_pm_runtime_resume   NULL
1066 #define pci_pm_runtime_idle     NULL
1067
1068 #endif /* !CONFIG_PM_RUNTIME */
1069
1070 #ifdef CONFIG_PM
1071
1072 const struct dev_pm_ops pci_dev_pm_ops = {
1073         .prepare = pci_pm_prepare,
1074         .complete = pci_pm_complete,
1075         .suspend = pci_pm_suspend,
1076         .resume = pci_pm_resume,
1077         .freeze = pci_pm_freeze,
1078         .thaw = pci_pm_thaw,
1079         .poweroff = pci_pm_poweroff,
1080         .restore = pci_pm_restore,
1081         .suspend_noirq = pci_pm_suspend_noirq,
1082         .resume_noirq = pci_pm_resume_noirq,
1083         .freeze_noirq = pci_pm_freeze_noirq,
1084         .thaw_noirq = pci_pm_thaw_noirq,
1085         .poweroff_noirq = pci_pm_poweroff_noirq,
1086         .restore_noirq = pci_pm_restore_noirq,
1087         .runtime_suspend = pci_pm_runtime_suspend,
1088         .runtime_resume = pci_pm_runtime_resume,
1089         .runtime_idle = pci_pm_runtime_idle,
1090 };
1091
1092 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
1093
1094 #else /* !COMFIG_PM_OPS */
1095
1096 #define PCI_PM_OPS_PTR  NULL
1097
1098 #endif /* !COMFIG_PM_OPS */
1099
1100 /**
1101  * __pci_register_driver - register a new pci driver
1102  * @drv: the driver structure to register
1103  * @owner: owner module of drv
1104  * @mod_name: module name string
1105  *
1106  * Adds the driver structure to the list of registered drivers.
1107  * Returns a negative value on error, otherwise 0.
1108  * If no error occurred, the driver remains registered even if
1109  * no device was claimed during registration.
1110  */
1111 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1112                           const char *mod_name)
1113 {
1114         int error;
1115
1116         /* initialize common driver fields */
1117         drv->driver.name = drv->name;
1118         drv->driver.bus = &pci_bus_type;
1119         drv->driver.owner = owner;
1120         drv->driver.mod_name = mod_name;
1121
1122         spin_lock_init(&drv->dynids.lock);
1123         INIT_LIST_HEAD(&drv->dynids.list);
1124
1125         /* register with core */
1126         error = driver_register(&drv->driver);
1127         if (error)
1128                 goto out;
1129
1130         error = pci_create_newid_files(drv);
1131         if (error)
1132                 goto out_newid;
1133 out:
1134         return error;
1135
1136 out_newid:
1137         driver_unregister(&drv->driver);
1138         goto out;
1139 }
1140
1141 /**
1142  * pci_unregister_driver - unregister a pci driver
1143  * @drv: the driver structure to unregister
1144  *
1145  * Deletes the driver structure from the list of registered PCI drivers,
1146  * gives it a chance to clean up by calling its remove() function for
1147  * each device it was responsible for, and marks those devices as
1148  * driverless.
1149  */
1150
1151 void
1152 pci_unregister_driver(struct pci_driver *drv)
1153 {
1154         pci_remove_newid_files(drv);
1155         driver_unregister(&drv->driver);
1156         pci_free_dynids(drv);
1157 }
1158
1159 static struct pci_driver pci_compat_driver = {
1160         .name = "compat"
1161 };
1162
1163 /**
1164  * pci_dev_driver - get the pci_driver of a device
1165  * @dev: the device to query
1166  *
1167  * Returns the appropriate pci_driver structure or %NULL if there is no
1168  * registered driver for the device.
1169  */
1170 struct pci_driver *
1171 pci_dev_driver(const struct pci_dev *dev)
1172 {
1173         if (dev->driver)
1174                 return dev->driver;
1175         else {
1176                 int i;
1177                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1178                         if (dev->resource[i].flags & IORESOURCE_BUSY)
1179                                 return &pci_compat_driver;
1180         }
1181         return NULL;
1182 }
1183
1184 /**
1185  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1186  * @dev: the PCI device structure to match against
1187  * @drv: the device driver to search for matching PCI device id structures
1188  *
1189  * Used by a driver to check whether a PCI device present in the
1190  * system is in its list of supported devices. Returns the matching
1191  * pci_device_id structure or %NULL if there is no match.
1192  */
1193 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1194 {
1195         struct pci_dev *pci_dev = to_pci_dev(dev);
1196         struct pci_driver *pci_drv = to_pci_driver(drv);
1197         const struct pci_device_id *found_id;
1198
1199         found_id = pci_match_device(pci_drv, pci_dev);
1200         if (found_id)
1201                 return 1;
1202
1203         return 0;
1204 }
1205
1206 /**
1207  * pci_dev_get - increments the reference count of the pci device structure
1208  * @dev: the device being referenced
1209  *
1210  * Each live reference to a device should be refcounted.
1211  *
1212  * Drivers for PCI devices should normally record such references in
1213  * their probe() methods, when they bind to a device, and release
1214  * them by calling pci_dev_put(), in their disconnect() methods.
1215  *
1216  * A pointer to the device with the incremented reference counter is returned.
1217  */
1218 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1219 {
1220         if (dev)
1221                 get_device(&dev->dev);
1222         return dev;
1223 }
1224
1225 /**
1226  * pci_dev_put - release a use of the pci device structure
1227  * @dev: device that's been disconnected
1228  *
1229  * Must be called when a user of a device is finished with it.  When the last
1230  * user of the device calls this function, the memory of the device is freed.
1231  */
1232 void pci_dev_put(struct pci_dev *dev)
1233 {
1234         if (dev)
1235                 put_device(&dev->dev);
1236 }
1237
1238 #ifndef CONFIG_HOTPLUG
1239 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1240 {
1241         return -ENODEV;
1242 }
1243 #endif
1244
1245 struct bus_type pci_bus_type = {
1246         .name           = "pci",
1247         .match          = pci_bus_match,
1248         .uevent         = pci_uevent,
1249         .probe          = pci_device_probe,
1250         .remove         = pci_device_remove,
1251         .shutdown       = pci_device_shutdown,
1252         .dev_attrs      = pci_dev_attrs,
1253         .bus_attrs      = pci_bus_attrs,
1254         .pm             = PCI_PM_OPS_PTR,
1255 };
1256
1257 static int __init pci_driver_init(void)
1258 {
1259         return bus_register(&pci_bus_type);
1260 }
1261
1262 postcore_initcall(pci_driver_init);
1263
1264 EXPORT_SYMBOL_GPL(pci_add_dynid);
1265 EXPORT_SYMBOL(pci_match_id);
1266 EXPORT_SYMBOL(__pci_register_driver);
1267 EXPORT_SYMBOL(pci_unregister_driver);
1268 EXPORT_SYMBOL(pci_dev_driver);
1269 EXPORT_SYMBOL(pci_bus_type);
1270 EXPORT_SYMBOL(pci_dev_get);
1271 EXPORT_SYMBOL(pci_dev_put);