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