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