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