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