drivers/pci/pci-driver.c

   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 "pci.h"
  21
  22 /*
  23  * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
  24  */
  25
  26 struct pci_dynid {
  27         struct list_head node;
  28         struct pci_device_id id;
  29 };
  30
  31 #ifdef CONFIG_HOTPLUG
  32
  33 /**
  34  * store_new_id - add a new PCI device ID to this driver and re-probe devices
  35  * @driver: target device driver
  36  * @buf: buffer for scanning device ID data
  37  * @count: input size
  38  *
  39  * Adds a new dynamic pci device ID to this driver,
  40  * and causes the driver to probe for all devices again.
  41  */
  42 static ssize_t
  43 store_new_id(struct device_driver *driver, const char *buf, size_t count)
  44 {
  45         struct pci_dynid *dynid;
  46         struct pci_driver *pdrv = to_pci_driver(driver);
  47         const struct pci_device_id *ids = pdrv->id_table;
  48         __u32 vendor, device, subvendor=PCI_ANY_ID,
  49                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
  50         unsigned long driver_data=0;
  51         int fields=0;
  52         int retval=0;
  53
  54         fields = sscanf(buf, "%x %x %x %x %x %x %lx",
  55                         &vendor, &device, &subvendor, &subdevice,
  56                         &class, &class_mask, &driver_data);
  57         if (fields < 2)
  58                 return -EINVAL;
  59
  60         /* Only accept driver_data values that match an existing id_table
  61            entry */
  62         if (ids) {
  63                 retval = -EINVAL;
  64                 while (ids->vendor || ids->subvendor || ids->class_mask) {
  65                         if (driver_data == ids->driver_data) {
  66                                 retval = 0;
  67                                 break;
  68                         }
  69                         ids++;
  70                 }
  71                 if (retval)     /* No match */
  72                         return retval;
  73         }
  74
  75         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
  76         if (!dynid)
  77                 return -ENOMEM;
  78
  79         dynid->id.vendor = vendor;
  80         dynid->id.device = device;
  81         dynid->id.subvendor = subvendor;
  82         dynid->id.subdevice = subdevice;
  83         dynid->id.class = class;
  84         dynid->id.class_mask = class_mask;
  85         dynid->id.driver_data = driver_data;
  86
  87         spin_lock(&pdrv->dynids.lock);
  88         list_add_tail(&dynid->node, &pdrv->dynids.list);
  89         spin_unlock(&pdrv->dynids.lock);
  90
  91         if (get_driver(&pdrv->driver)) {
  92                 retval = driver_attach(&pdrv->driver);
  93                 put_driver(&pdrv->driver);
  94         }
  95
  96         if (retval)
  97                 return retval;
  98         return count;
  99 }
 100 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 101
 102 static void
 103 pci_free_dynids(struct pci_driver *drv)
 104 {
 105         struct pci_dynid *dynid, *n;
 106
 107         spin_lock(&drv->dynids.lock);
 108         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
 109                 list_del(&dynid->node);
 110                 kfree(dynid);
 111         }
 112         spin_unlock(&drv->dynids.lock);
 113 }
 114
 115 static int
 116 pci_create_newid_file(struct pci_driver *drv)
 117 {
 118         int error = 0;
 119         if (drv->probe != NULL)
 120                 error = driver_create_file(&drv->driver, &driver_attr_new_id);
 121         return error;
 122 }
 123
 124 static void pci_remove_newid_file(struct pci_driver *drv)
 125 {
 126         driver_remove_file(&drv->driver, &driver_attr_new_id);
 127 }
 128 #else /* !CONFIG_HOTPLUG */
 129 static inline void pci_free_dynids(struct pci_driver *drv) {}
 130 static inline int pci_create_newid_file(struct pci_driver *drv)
 131 {
 132         return 0;
 133 }
 134 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
 135 #endif
 136
 137 /**
 138  * pci_match_id - See if a pci device matches a given pci_id table
 139  * @ids: array of PCI device id structures to search in
 140  * @dev: the PCI device structure to match against.
 141  *
 142  * Used by a driver to check whether a PCI device present in the
 143  * system is in its list of supported devices.  Returns the matching
 144  * pci_device_id structure or %NULL if there is no match.
 145  *
 146  * Deprecated, don't use this as it will not catch any dynamic ids
 147  * that a driver might want to check for.
 148  */
 149 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
 150                                          struct pci_dev *dev)
 151 {
 152         if (ids) {
 153                 while (ids->vendor || ids->subvendor || ids->class_mask) {
 154                         if (pci_match_one_device(ids, dev))
 155                                 return ids;
 156                         ids++;
 157                 }
 158         }
 159         return NULL;
 160 }
 161
 162 /**
 163  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
 164  * @drv: the PCI driver to match against
 165  * @dev: the PCI device structure to match against
 166  *
 167  * Used by a driver to check whether a PCI device present in the
 168  * system is in its list of supported devices.  Returns the matching
 169  * pci_device_id structure or %NULL if there is no match.
 170  */
 171 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
 172                                                     struct pci_dev *dev)
 173 {
 174         struct pci_dynid *dynid;
 175
 176         /* Look at the dynamic ids first, before the static ones */
 177         spin_lock(&drv->dynids.lock);
 178         list_for_each_entry(dynid, &drv->dynids.list, node) {
 179                 if (pci_match_one_device(&dynid->id, dev)) {
 180                         spin_unlock(&drv->dynids.lock);
 181                         return &dynid->id;
 182                 }
 183         }
 184         spin_unlock(&drv->dynids.lock);
 185
 186         return pci_match_id(drv->id_table, dev);
 187 }
 188
 189 struct drv_dev_and_id {
 190         struct pci_driver *drv;
 191         struct pci_dev *dev;
 192         const struct pci_device_id *id;
 193 };
 194
 195 static long local_pci_probe(void *_ddi)
 196 {
 197         struct drv_dev_and_id *ddi = _ddi;
 198
 199         return ddi->drv->probe(ddi->dev, ddi->id);
 200 }
 201
 202 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
 203                           const struct pci_device_id *id)
 204 {
 205         int error, node;
 206         struct drv_dev_and_id ddi = { drv, dev, id };
 207
 208         /* Execute driver initialization on node where the device's
 209            bus is attached to.  This way the driver likely allocates
 210            its local memory on the right node without any need to
 211            change it. */
 212         node = dev_to_node(&dev->dev);
 213         if (node >= 0) {
 214                 int cpu;
 215
 216                 get_online_cpus();
 217                 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
 218                 if (cpu < nr_cpu_ids)
 219                         error = work_on_cpu(cpu, local_pci_probe, &ddi);
 220                 else
 221                         error = local_pci_probe(&ddi);
 222                 put_online_cpus();
 223         } else
 224                 error = local_pci_probe(&ddi);
 225         return error;
 226 }
 227
 228 /**
 229  * __pci_device_probe()
 230  * @drv: driver to call to check if it wants the PCI device
 231  * @pci_dev: PCI device being probed
 232  *
 233  * returns 0 on success, else error.
 234  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
 235  */
 236 static int
 237 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
 238 {
 239         const struct pci_device_id *id;
 240         int error = 0;
 241
 242         if (!pci_dev->driver && drv->probe) {
 243                 error = -ENODEV;
 244
 245                 id = pci_match_device(drv, pci_dev);
 246                 if (id)
 247                         error = pci_call_probe(drv, pci_dev, id);
 248                 if (error >= 0) {
 249                         pci_dev->driver = drv;
 250                         error = 0;
 251                 }
 252         }
 253         return error;
 254 }
 255
 256 static int pci_device_probe(struct device * dev)
 257 {
 258         int error = 0;
 259         struct pci_driver *drv;
 260         struct pci_dev *pci_dev;
 261
 262         drv = to_pci_driver(dev->driver);
 263         pci_dev = to_pci_dev(dev);
 264         pci_dev_get(pci_dev);
 265         error = __pci_device_probe(drv, pci_dev);
 266         if (error)
 267                 pci_dev_put(pci_dev);
 268
 269         return error;
 270 }
 271
 272 static int pci_device_remove(struct device * dev)
 273 {
 274         struct pci_dev * pci_dev = to_pci_dev(dev);
 275         struct pci_driver * drv = pci_dev->driver;
 276
 277         if (drv) {
 278                 if (drv->remove)
 279                         drv->remove(pci_dev);
 280                 pci_dev->driver = NULL;
 281         }
 282
 283         /*
 284          * If the device is still on, set the power state as "unknown",
 285          * since it might change by the next time we load the driver.
 286          */
 287         if (pci_dev->current_state == PCI_D0)
 288                 pci_dev->current_state = PCI_UNKNOWN;
 289
 290         /*
 291          * We would love to complain here if pci_dev->is_enabled is set, that
 292          * the driver should have called pci_disable_device(), but the
 293          * unfortunate fact is there are too many odd BIOS and bridge setups
 294          * that don't like drivers doing that all of the time.
 295          * Oh well, we can dream of sane hardware when we sleep, no matter how
 296          * horrible the crap we have to deal with is when we are awake...
 297          */
 298
 299         pci_dev_put(pci_dev);
 300         return 0;
 301 }
 302
 303 static void pci_device_shutdown(struct device *dev)
 304 {
 305         struct pci_dev *pci_dev = to_pci_dev(dev);
 306         struct pci_driver *drv = pci_dev->driver;
 307
 308         if (drv && drv->shutdown)
 309                 drv->shutdown(pci_dev);
 310         pci_msi_shutdown(pci_dev);
 311         pci_msix_shutdown(pci_dev);
 312 }
 313
 314 #ifdef CONFIG_PM_SLEEP
 315
 316 /*
 317  * Default "suspend" method for devices that have no driver provided suspend,
 318  * or not even a driver at all (second part).
 319  */
 320 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
 321 {
 322         /*
 323          * mark its power state as "unknown", since we don't know if
 324          * e.g. the BIOS will change its device state when we suspend.
 325          */
 326         if (pci_dev->current_state == PCI_D0)
 327                 pci_dev->current_state = PCI_UNKNOWN;
 328 }
 329
 330 /*
 331  * Default "resume" method for devices that have no driver provided resume,
 332  * or not even a driver at all (second part).
 333  */
 334 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
 335 {
 336         int retval;
 337
 338         /* if the device was enabled before suspend, reenable */
 339         retval = pci_reenable_device(pci_dev);
 340         /*
 341          * if the device was busmaster before the suspend, make it busmaster
 342          * again
 343          */
 344         if (pci_dev->is_busmaster)
 345                 pci_set_master(pci_dev);
 346
 347         return retval;
 348 }
 349
 350 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
 351 {
 352         struct pci_dev * pci_dev = to_pci_dev(dev);
 353         struct pci_driver * drv = pci_dev->driver;
 354
 355         pci_dev->state_saved = false;
 356
 357         if (drv && drv->suspend) {
 358                 pci_power_t prev = pci_dev->current_state;
 359                 int error;
 360
 361                 error = drv->suspend(pci_dev, state);
 362                 suspend_report_result(drv->suspend, error);
 363                 if (error)
 364                         return error;
 365
 366                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 367                     && pci_dev->current_state != PCI_UNKNOWN) {
 368                         WARN_ONCE(pci_dev->current_state != prev,
 369                                 "PCI PM: Device state not saved by %pF\n",
 370                                 drv->suspend);
 371                 }
 372         }
 373
 374         pci_fixup_device(pci_fixup_suspend, pci_dev);
 375
 376         return 0;
 377 }
 378
 379 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 380 {
 381         struct pci_dev * pci_dev = to_pci_dev(dev);
 382         struct pci_driver * drv = pci_dev->driver;
 383
 384         if (drv && drv->suspend_late) {
 385                 pci_power_t prev = pci_dev->current_state;
 386                 int error;
 387
 388                 error = drv->suspend_late(pci_dev, state);
 389                 suspend_report_result(drv->suspend_late, error);
 390                 if (error)
 391                         return error;
 392
 393                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 394                     && pci_dev->current_state != PCI_UNKNOWN) {
 395                         WARN_ONCE(pci_dev->current_state != prev,
 396                                 "PCI PM: Device state not saved by %pF\n",
 397                                 drv->suspend_late);
 398                         return 0;
 399                 }
 400         }
 401
 402         if (!pci_dev->state_saved)
 403                 pci_save_state(pci_dev);
 404
 405         pci_pm_set_unknown_state(pci_dev);
 406
 407         return 0;
 408 }
 409
 410 static int pci_legacy_resume_early(struct device *dev)
 411 {
 412         struct pci_dev * pci_dev = to_pci_dev(dev);
 413         struct pci_driver * drv = pci_dev->driver;
 414
 415         return drv && drv->resume_early ?
 416                         drv->resume_early(pci_dev) : 0;
 417 }
 418
 419 static int pci_legacy_resume(struct device *dev)
 420 {
 421         struct pci_dev * pci_dev = to_pci_dev(dev);
 422         struct pci_driver * drv = pci_dev->driver;
 423
 424         pci_fixup_device(pci_fixup_resume, pci_dev);
 425
 426         return drv && drv->resume ?
 427                         drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
 428 }
 429
 430 /* Auxiliary functions used by the new power management framework */
 431
 432 /**
 433  * pci_restore_standard_config - restore standard config registers of PCI device
 434  * @pci_dev: PCI device to handle
 435  */
 436 static int pci_restore_standard_config(struct pci_dev *pci_dev)
 437 {
 438         pci_update_current_state(pci_dev, PCI_UNKNOWN);
 439
 440         if (pci_dev->current_state != PCI_D0) {
 441                 int error = pci_set_power_state(pci_dev, PCI_D0);
 442                 if (error)
 443                         return error;
 444         }
 445
 446         return pci_dev->state_saved ? pci_restore_state(pci_dev) : 0;
 447 }
 448
 449 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
 450 {
 451         pci_restore_standard_config(pci_dev);
 452         pci_dev->state_saved = false;
 453         pci_fixup_device(pci_fixup_resume_early, pci_dev);
 454 }
 455
 456 static void pci_pm_default_resume(struct pci_dev *pci_dev)
 457 {
 458         pci_fixup_device(pci_fixup_resume, pci_dev);
 459
 460         if (!pci_is_bridge(pci_dev))
 461                 pci_enable_wake(pci_dev, PCI_D0, false);
 462 }
 463
 464 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
 465 {
 466         /* Disable non-bridge devices without PM support */
 467         if (!pci_is_bridge(pci_dev))
 468                 pci_disable_enabled_device(pci_dev);
 469 }
 470
 471 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
 472 {
 473         struct pci_driver *drv = pci_dev->driver;
 474         bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
 475                 || drv->resume_early);
 476
 477         /*
 478          * Legacy PM support is used by default, so warn if the new framework is
 479          * supported as well.  Drivers are supposed to support either the
 480          * former, or the latter, but not both at the same time.
 481          */
 482         WARN_ON(ret && drv->driver.pm);
 483
 484         return ret;
 485 }
 486
 487 /* New power management framework */
 488
 489 static int pci_pm_prepare(struct device *dev)
 490 {
 491         struct device_driver *drv = dev->driver;
 492         int error = 0;
 493
 494         if (drv && drv->pm && drv->pm->prepare)
 495                 error = drv->pm->prepare(dev);
 496
 497         return error;
 498 }
 499
 500 static void pci_pm_complete(struct device *dev)
 501 {
 502         struct device_driver *drv = dev->driver;
 503
 504         if (drv && drv->pm && drv->pm->complete)
 505                 drv->pm->complete(dev);
 506 }
 507
 508 #ifdef CONFIG_SUSPEND
 509
 510 static int pci_pm_suspend(struct device *dev)
 511 {
 512         struct pci_dev *pci_dev = to_pci_dev(dev);
 513         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 514
 515         if (pci_has_legacy_pm_support(pci_dev))
 516                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
 517
 518         pci_dev->state_saved = false;
 519
 520         if (!pm) {
 521                 pci_pm_default_suspend(pci_dev);
 522                 goto Fixup;
 523         }
 524
 525         if (pm->suspend) {
 526                 pci_power_t prev = pci_dev->current_state;
 527                 int error;
 528
 529                 error = pm->suspend(dev);
 530                 suspend_report_result(pm->suspend, error);
 531                 if (error)
 532                         return error;
 533
 534                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 535                     && pci_dev->current_state != PCI_UNKNOWN) {
 536                         WARN_ONCE(pci_dev->current_state != prev,
 537                                 "PCI PM: State of device not saved by %pF\n",
 538                                 pm->suspend);
 539                 }
 540         }
 541
 542  Fixup:
 543         pci_fixup_device(pci_fixup_suspend, pci_dev);
 544
 545         return 0;
 546 }
 547
 548 static int pci_pm_suspend_noirq(struct device *dev)
 549 {
 550         struct pci_dev *pci_dev = to_pci_dev(dev);
 551         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 552
 553         if (pci_has_legacy_pm_support(pci_dev))
 554                 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 555
 556         if (!pm) {
 557                 pci_save_state(pci_dev);
 558                 return 0;
 559         }
 560
 561         if (pm->suspend_noirq) {
 562                 pci_power_t prev = pci_dev->current_state;
 563                 int error;
 564
 565                 error = pm->suspend_noirq(dev);
 566                 suspend_report_result(pm->suspend_noirq, error);
 567                 if (error)
 568                         return error;
 569
 570                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 571                     && pci_dev->current_state != PCI_UNKNOWN) {
 572                         WARN_ONCE(pci_dev->current_state != prev,
 573                                 "PCI PM: State of device not saved by %pF\n",
 574                                 pm->suspend_noirq);
 575                         return 0;
 576                 }
 577         }
 578
 579         if (!pci_dev->state_saved) {
 580                 pci_save_state(pci_dev);
 581                 if (!pci_is_bridge(pci_dev))
 582                         pci_prepare_to_sleep(pci_dev);
 583         }
 584
 585         pci_pm_set_unknown_state(pci_dev);
 586
 587         return 0;
 588 }
 589
 590 static int pci_pm_resume_noirq(struct device *dev)
 591 {
 592         struct pci_dev *pci_dev = to_pci_dev(dev);
 593         struct device_driver *drv = dev->driver;
 594         int error = 0;
 595
 596         pci_pm_default_resume_noirq(pci_dev);
 597
 598         if (pci_has_legacy_pm_support(pci_dev))
 599                 return pci_legacy_resume_early(dev);
 600
 601         if (drv && drv->pm && drv->pm->resume_noirq)
 602                 error = drv->pm->resume_noirq(dev);
 603
 604         return error;
 605 }
 606
 607 static int pci_pm_resume(struct device *dev)
 608 {
 609         struct pci_dev *pci_dev = to_pci_dev(dev);
 610         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 611         int error = 0;
 612
 613         /*
 614          * This is necessary for the suspend error path in which resume is
 615          * called without restoring the standard config registers of the device.
 616          */
 617         if (pci_dev->state_saved)
 618                 pci_restore_standard_config(pci_dev);
 619
 620         if (pci_has_legacy_pm_support(pci_dev))
 621                 return pci_legacy_resume(dev);
 622
 623         pci_pm_default_resume(pci_dev);
 624
 625         if (pm) {
 626                 if (pm->resume)
 627                         error = pm->resume(dev);
 628         } else {
 629                 pci_pm_reenable_device(pci_dev);
 630         }
 631
 632         return 0;
 633 }
 634
 635 #else /* !CONFIG_SUSPEND */
 636
 637 #define pci_pm_suspend          NULL
 638 #define pci_pm_suspend_noirq    NULL
 639 #define pci_pm_resume           NULL
 640 #define pci_pm_resume_noirq     NULL
 641
 642 #endif /* !CONFIG_SUSPEND */
 643
 644 #ifdef CONFIG_HIBERNATION
 645
 646 static int pci_pm_freeze(struct device *dev)
 647 {
 648         struct pci_dev *pci_dev = to_pci_dev(dev);
 649         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 650
 651         if (pci_has_legacy_pm_support(pci_dev))
 652                 return pci_legacy_suspend(dev, PMSG_FREEZE);
 653
 654         pci_dev->state_saved = false;
 655
 656         if (!pm) {
 657                 pci_pm_default_suspend(pci_dev);
 658                 return 0;
 659         }
 660
 661         if (pm->freeze) {
 662                 int error;
 663
 664                 error = pm->freeze(dev);
 665                 suspend_report_result(pm->freeze, error);
 666                 if (error)
 667                         return error;
 668         }
 669
 670         return 0;
 671 }
 672
 673 static int pci_pm_freeze_noirq(struct device *dev)
 674 {
 675         struct pci_dev *pci_dev = to_pci_dev(dev);
 676         struct device_driver *drv = dev->driver;
 677
 678         if (pci_has_legacy_pm_support(pci_dev))
 679                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
 680
 681         if (drv && drv->pm && drv->pm->freeze_noirq) {
 682                 int error;
 683
 684                 error = drv->pm->freeze_noirq(dev);
 685                 suspend_report_result(drv->pm->freeze_noirq, error);
 686                 if (error)
 687                         return error;
 688         }
 689
 690         if (!pci_dev->state_saved)
 691                 pci_save_state(pci_dev);
 692
 693         pci_pm_set_unknown_state(pci_dev);
 694
 695         return 0;
 696 }
 697
 698 static int pci_pm_thaw_noirq(struct device *dev)
 699 {
 700         struct pci_dev *pci_dev = to_pci_dev(dev);
 701         struct device_driver *drv = dev->driver;
 702         int error = 0;
 703
 704         if (pci_has_legacy_pm_support(pci_dev))
 705                 return pci_legacy_resume_early(dev);
 706
 707         pci_update_current_state(pci_dev, PCI_D0);
 708
 709         if (drv && drv->pm && drv->pm->thaw_noirq)
 710                 error = drv->pm->thaw_noirq(dev);
 711
 712         return error;
 713 }
 714
 715 static int pci_pm_thaw(struct device *dev)
 716 {
 717         struct pci_dev *pci_dev = to_pci_dev(dev);
 718         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 719         int error = 0;
 720
 721         if (pci_has_legacy_pm_support(pci_dev))
 722                 return pci_legacy_resume(dev);
 723
 724         if (pm) {
 725                 if (pm->thaw)
 726                         error = pm->thaw(dev);
 727         } else {
 728                 pci_pm_reenable_device(pci_dev);
 729         }
 730
 731         return error;
 732 }
 733
 734 static int pci_pm_poweroff(struct device *dev)
 735 {
 736         struct pci_dev *pci_dev = to_pci_dev(dev);
 737         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 738
 739         if (pci_has_legacy_pm_support(pci_dev))
 740                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
 741
 742         pci_dev->state_saved = false;
 743
 744         if (!pm) {
 745                 pci_pm_default_suspend(pci_dev);
 746                 goto Fixup;
 747         }
 748
 749         if (pm->poweroff) {
 750                 int error;
 751
 752                 error = pm->poweroff(dev);
 753                 suspend_report_result(pm->poweroff, error);
 754                 if (error)
 755                         return error;
 756         }
 757
 758  Fixup:
 759         pci_fixup_device(pci_fixup_suspend, pci_dev);
 760
 761         return 0;
 762 }
 763
 764 static int pci_pm_poweroff_noirq(struct device *dev)
 765 {
 766         struct pci_dev *pci_dev = to_pci_dev(dev);
 767         struct device_driver *drv = dev->driver;
 768
 769         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
 770                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 771
 772         if (!drv || !drv->pm)
 773                 return 0;
 774
 775         if (drv->pm->poweroff_noirq) {
 776                 int error;
 777
 778                 error = drv->pm->poweroff_noirq(dev);
 779                 suspend_report_result(drv->pm->poweroff_noirq, error);
 780                 if (error)
 781                         return error;
 782         }
 783
 784         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
 785                 pci_prepare_to_sleep(pci_dev);
 786
 787         return 0;
 788 }
 789
 790 static int pci_pm_restore_noirq(struct device *dev)
 791 {
 792         struct pci_dev *pci_dev = to_pci_dev(dev);
 793         struct device_driver *drv = dev->driver;
 794         int error = 0;
 795
 796         pci_pm_default_resume_noirq(pci_dev);
 797
 798         if (pci_has_legacy_pm_support(pci_dev))
 799                 return pci_legacy_resume_early(dev);
 800
 801         if (drv && drv->pm && drv->pm->restore_noirq)
 802                 error = drv->pm->restore_noirq(dev);
 803
 804         return error;
 805 }
 806
 807 static int pci_pm_restore(struct device *dev)
 808 {
 809         struct pci_dev *pci_dev = to_pci_dev(dev);
 810         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 811         int error = 0;
 812
 813         /*
 814          * This is necessary for the hibernation error path in which restore is
 815          * called without restoring the standard config registers of the device.
 816          */
 817         if (pci_dev->state_saved)
 818                 pci_restore_standard_config(pci_dev);
 819
 820         if (pci_has_legacy_pm_support(pci_dev))
 821                 return pci_legacy_resume(dev);
 822
 823         pci_pm_default_resume(pci_dev);
 824
 825         if (pm) {
 826                 if (pm->restore)
 827                         error = pm->restore(dev);
 828         } else {
 829                 pci_pm_reenable_device(pci_dev);
 830         }
 831
 832         return error;
 833 }
 834
 835 #else /* !CONFIG_HIBERNATION */
 836
 837 #define pci_pm_freeze           NULL
 838 #define pci_pm_freeze_noirq     NULL
 839 #define pci_pm_thaw             NULL
 840 #define pci_pm_thaw_noirq       NULL
 841 #define pci_pm_poweroff         NULL
 842 #define pci_pm_poweroff_noirq   NULL
 843 #define pci_pm_restore          NULL
 844 #define pci_pm_restore_noirq    NULL
 845
 846 #endif /* !CONFIG_HIBERNATION */
 847
 848 struct dev_pm_ops pci_dev_pm_ops = {
 849         .prepare = pci_pm_prepare,
 850         .complete = pci_pm_complete,
 851         .suspend = pci_pm_suspend,
 852         .resume = pci_pm_resume,
 853         .freeze = pci_pm_freeze,
 854         .thaw = pci_pm_thaw,
 855         .poweroff = pci_pm_poweroff,
 856         .restore = pci_pm_restore,
 857         .suspend_noirq = pci_pm_suspend_noirq,
 858         .resume_noirq = pci_pm_resume_noirq,
 859         .freeze_noirq = pci_pm_freeze_noirq,
 860         .thaw_noirq = pci_pm_thaw_noirq,
 861         .poweroff_noirq = pci_pm_poweroff_noirq,
 862         .restore_noirq = pci_pm_restore_noirq,
 863 };
 864
 865 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
 866
 867 #else /* !CONFIG_PM_SLEEP */
 868
 869 #define PCI_PM_OPS_PTR  NULL
 870
 871 #endif /* !CONFIG_PM_SLEEP */
 872
 873 /**
 874  * __pci_register_driver - register a new pci driver
 875  * @drv: the driver structure to register
 876  * @owner: owner module of drv
 877  * @mod_name: module name string
 878  *
 879  * Adds the driver structure to the list of registered drivers.
 880  * Returns a negative value on error, otherwise 0.
 881  * If no error occurred, the driver remains registered even if
 882  * no device was claimed during registration.
 883  */
 884 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
 885                           const char *mod_name)
 886 {
 887         int error;
 888
 889         /* initialize common driver fields */
 890         drv->driver.name = drv->name;
 891         drv->driver.bus = &pci_bus_type;
 892         drv->driver.owner = owner;
 893         drv->driver.mod_name = mod_name;
 894
 895         spin_lock_init(&drv->dynids.lock);
 896         INIT_LIST_HEAD(&drv->dynids.list);
 897
 898         /* register with core */
 899         error = driver_register(&drv->driver);
 900         if (error)
 901                 return error;
 902
 903         error = pci_create_newid_file(drv);
 904         if (error)
 905                 driver_unregister(&drv->driver);
 906
 907         return error;
 908 }
 909
 910 /**
 911  * pci_unregister_driver - unregister a pci driver
 912  * @drv: the driver structure to unregister
 913  *
 914  * Deletes the driver structure from the list of registered PCI drivers,
 915  * gives it a chance to clean up by calling its remove() function for
 916  * each device it was responsible for, and marks those devices as
 917  * driverless.
 918  */
 919
 920 void
 921 pci_unregister_driver(struct pci_driver *drv)
 922 {
 923         pci_remove_newid_file(drv);
 924         driver_unregister(&drv->driver);
 925         pci_free_dynids(drv);
 926 }
 927
 928 static struct pci_driver pci_compat_driver = {
 929         .name = "compat"
 930 };
 931
 932 /**
 933  * pci_dev_driver - get the pci_driver of a device
 934  * @dev: the device to query
 935  *
 936  * Returns the appropriate pci_driver structure or %NULL if there is no
 937  * registered driver for the device.
 938  */
 939 struct pci_driver *
 940 pci_dev_driver(const struct pci_dev *dev)
 941 {
 942         if (dev->driver)
 943                 return dev->driver;
 944         else {
 945                 int i;
 946                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
 947                         if (dev->resource[i].flags & IORESOURCE_BUSY)
 948                                 return &pci_compat_driver;
 949         }
 950         return NULL;
 951 }
 952
 953 /**
 954  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
 955  * @dev: the PCI device structure to match against
 956  * @drv: the device driver to search for matching PCI device id structures
 957  *
 958  * Used by a driver to check whether a PCI device present in the
 959  * system is in its list of supported devices. Returns the matching
 960  * pci_device_id structure or %NULL if there is no match.
 961  */
 962 static int pci_bus_match(struct device *dev, struct device_driver *drv)
 963 {
 964         struct pci_dev *pci_dev = to_pci_dev(dev);
 965         struct pci_driver *pci_drv = to_pci_driver(drv);
 966         const struct pci_device_id *found_id;
 967
 968         found_id = pci_match_device(pci_drv, pci_dev);
 969         if (found_id)
 970                 return 1;
 971
 972         return 0;
 973 }
 974
 975 /**
 976  * pci_dev_get - increments the reference count of the pci device structure
 977  * @dev: the device being referenced
 978  *
 979  * Each live reference to a device should be refcounted.
 980  *
 981  * Drivers for PCI devices should normally record such references in
 982  * their probe() methods, when they bind to a device, and release
 983  * them by calling pci_dev_put(), in their disconnect() methods.
 984  *
 985  * A pointer to the device with the incremented reference counter is returned.
 986  */
 987 struct pci_dev *pci_dev_get(struct pci_dev *dev)
 988 {
 989         if (dev)
 990                 get_device(&dev->dev);
 991         return dev;
 992 }
 993
 994 /**
 995  * pci_dev_put - release a use of the pci device structure
 996  * @dev: device that's been disconnected
 997  *
 998  * Must be called when a user of a device is finished with it.  When the last
 999  * user of the device calls this function, the memory of the device is freed.
1000  */
1001 void pci_dev_put(struct pci_dev *dev)
1002 {
1003         if (dev)
1004                 put_device(&dev->dev);
1005 }
1006
1007 #ifndef CONFIG_HOTPLUG
1008 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1009 {
1010         return -ENODEV;
1011 }
1012 #endif
1013
1014 struct bus_type pci_bus_type = {
1015         .name           = "pci",
1016         .match          = pci_bus_match,
1017         .uevent         = pci_uevent,
1018         .probe          = pci_device_probe,
1019         .remove         = pci_device_remove,
1020         .shutdown       = pci_device_shutdown,
1021         .dev_attrs      = pci_dev_attrs,
1022         .pm             = PCI_PM_OPS_PTR,
1023 };
1024
1025 static int __init pci_driver_init(void)
1026 {
1027         return bus_register(&pci_bus_type);
1028 }
1029
1030 postcore_initcall(pci_driver_init);
1031
1032 EXPORT_SYMBOL(pci_match_id);
1033 EXPORT_SYMBOL(__pci_register_driver);
1034 EXPORT_SYMBOL(pci_unregister_driver);
1035 EXPORT_SYMBOL(pci_dev_driver);
1036 EXPORT_SYMBOL(pci_bus_type);
1037 EXPORT_SYMBOL(pci_dev_get);
1038 EXPORT_SYMBOL(pci_dev_put);