drivers/pci/pci-driver.c

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