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