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