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