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