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