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