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