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