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