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