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