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