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         int i = 0;
 356
 357         if (drv && drv->suspend) {
 358                 pci_power_t prev = pci_dev->current_state;
 359
 360                 pci_dev->state_saved = false;
 361
 362                 i = drv->suspend(pci_dev, state);
 363                 suspend_report_result(drv->suspend, i);
 364                 if (i)
 365                         return i;
 366
 367                 if (pci_dev->state_saved)
 368                         goto Fixup;
 369
 370                 if (pci_dev->current_state != PCI_D0
 371                     && pci_dev->current_state != PCI_UNKNOWN) {
 372                         WARN_ONCE(pci_dev->current_state != prev,
 373                                 "PCI PM: Device state not saved by %pF\n",
 374                                 drv->suspend);
 375                         goto Fixup;
 376                 }
 377         }
 378
 379         pci_save_state(pci_dev);
 380         /*
 381          * This is for compatibility with existing code with legacy PM support.
 382          */
 383         pci_pm_set_unknown_state(pci_dev);
 384
 385  Fixup:
 386         pci_fixup_device(pci_fixup_suspend, pci_dev);
 387
 388         return i;
 389 }
 390
 391 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 392 {
 393         struct pci_dev * pci_dev = to_pci_dev(dev);
 394         struct pci_driver * drv = pci_dev->driver;
 395         int i = 0;
 396
 397         if (drv && drv->suspend_late) {
 398                 i = drv->suspend_late(pci_dev, state);
 399                 suspend_report_result(drv->suspend_late, i);
 400         }
 401         return i;
 402 }
 403
 404 static int pci_legacy_resume_early(struct device *dev)
 405 {
 406         struct pci_dev * pci_dev = to_pci_dev(dev);
 407         struct pci_driver * drv = pci_dev->driver;
 408
 409         return drv && drv->resume_early ?
 410                         drv->resume_early(pci_dev) : 0;
 411 }
 412
 413 static int pci_legacy_resume(struct device *dev)
 414 {
 415         struct pci_dev * pci_dev = to_pci_dev(dev);
 416         struct pci_driver * drv = pci_dev->driver;
 417
 418         pci_fixup_device(pci_fixup_resume, pci_dev);
 419
 420         return drv && drv->resume ?
 421                         drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
 422 }
 423
 424 /* Auxiliary functions used by the new power management framework */
 425
 426 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
 427 {
 428         pci_restore_standard_config(pci_dev);
 429         pci_dev->state_saved = false;
 430         pci_fixup_device(pci_fixup_resume_early, pci_dev);
 431 }
 432
 433 static int pci_pm_default_resume(struct pci_dev *pci_dev)
 434 {
 435         pci_fixup_device(pci_fixup_resume, pci_dev);
 436
 437         if (pci_is_bridge(pci_dev))
 438                 return 0;
 439
 440         pci_enable_wake(pci_dev, PCI_D0, false);
 441         return pci_pm_reenable_device(pci_dev);
 442 }
 443
 444 static void pci_pm_default_suspend_generic(struct pci_dev *pci_dev)
 445 {
 446         /* If a non-bridge device is enabled at this point, disable it */
 447         if (!pci_is_bridge(pci_dev))
 448                 pci_disable_enabled_device(pci_dev);
 449         /*
 450          * Save state with interrupts enabled, because in principle the bus the
 451          * device is on may be put into a low power state after this code runs.
 452          */
 453         pci_save_state(pci_dev);
 454 }
 455
 456 static void pci_pm_default_suspend(struct pci_dev *pci_dev, bool prepare)
 457 {
 458         pci_pm_default_suspend_generic(pci_dev);
 459
 460         if (prepare && !pci_is_bridge(pci_dev))
 461                 pci_prepare_to_sleep(pci_dev);
 462
 463         pci_fixup_device(pci_fixup_suspend, pci_dev);
 464 }
 465
 466 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
 467 {
 468         struct pci_driver *drv = pci_dev->driver;
 469         bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
 470                 || drv->resume_early);
 471
 472         /*
 473          * Legacy PM support is used by default, so warn if the new framework is
 474          * supported as well.  Drivers are supposed to support either the
 475          * former, or the latter, but not both at the same time.
 476          */
 477         WARN_ON(ret && drv->driver.pm);
 478
 479         return ret;
 480 }
 481
 482 /* New power management framework */
 483
 484 static int pci_pm_prepare(struct device *dev)
 485 {
 486         struct device_driver *drv = dev->driver;
 487         int error = 0;
 488
 489         if (drv && drv->pm && drv->pm->prepare)
 490                 error = drv->pm->prepare(dev);
 491
 492         return error;
 493 }
 494
 495 static void pci_pm_complete(struct device *dev)
 496 {
 497         struct device_driver *drv = dev->driver;
 498
 499         if (drv && drv->pm && drv->pm->complete)
 500                 drv->pm->complete(dev);
 501 }
 502
 503 #ifdef CONFIG_SUSPEND
 504
 505 static int pci_pm_suspend(struct device *dev)
 506 {
 507         struct pci_dev *pci_dev = to_pci_dev(dev);
 508         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 509         int error = 0;
 510
 511         if (pci_has_legacy_pm_support(pci_dev))
 512                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
 513
 514         if (pm && pm->suspend) {
 515                 error = pm->suspend(dev);
 516                 suspend_report_result(pm->suspend, error);
 517         }
 518
 519         if (!error)
 520                 pci_pm_default_suspend(pci_dev, !!pm);
 521
 522         return error;
 523 }
 524
 525 static int pci_pm_suspend_noirq(struct device *dev)
 526 {
 527         struct pci_dev *pci_dev = to_pci_dev(dev);
 528         struct device_driver *drv = dev->driver;
 529         int error = 0;
 530
 531         if (pci_has_legacy_pm_support(pci_dev))
 532                 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 533
 534         if (drv && drv->pm && drv->pm->suspend_noirq) {
 535                 error = drv->pm->suspend_noirq(dev);
 536                 suspend_report_result(drv->pm->suspend_noirq, error);
 537         }
 538
 539         if (!error)
 540                 pci_pm_set_unknown_state(pci_dev);
 541
 542         return error;
 543 }
 544
 545 static int pci_pm_resume_noirq(struct device *dev)
 546 {
 547         struct pci_dev *pci_dev = to_pci_dev(dev);
 548         struct device_driver *drv = dev->driver;
 549         int error = 0;
 550
 551         pci_pm_default_resume_noirq(pci_dev);
 552
 553         if (pci_has_legacy_pm_support(pci_dev))
 554                 return pci_legacy_resume_early(dev);
 555
 556         if (drv && drv->pm && drv->pm->resume_noirq)
 557                 error = drv->pm->resume_noirq(dev);
 558
 559         return error;
 560 }
 561
 562 static int pci_pm_resume(struct device *dev)
 563 {
 564         struct pci_dev *pci_dev = to_pci_dev(dev);
 565         struct device_driver *drv = dev->driver;
 566         int error = 0;
 567
 568         /*
 569          * This is necessary for the suspend error path in which resume is
 570          * called without restoring the standard config registers of the device.
 571          */
 572         if (pci_dev->state_saved)
 573                 pci_restore_standard_config(pci_dev);
 574
 575         if (pci_has_legacy_pm_support(pci_dev))
 576                 return pci_legacy_resume(dev);
 577
 578         error = pci_pm_default_resume(pci_dev);
 579
 580         if (!error && drv && drv->pm && drv->pm->resume)
 581                 error = drv->pm->resume(dev);
 582
 583         return error;
 584 }
 585
 586 #else /* !CONFIG_SUSPEND */
 587
 588 #define pci_pm_suspend          NULL
 589 #define pci_pm_suspend_noirq    NULL
 590 #define pci_pm_resume           NULL
 591 #define pci_pm_resume_noirq     NULL
 592
 593 #endif /* !CONFIG_SUSPEND */
 594
 595 #ifdef CONFIG_HIBERNATION
 596
 597 static int pci_pm_freeze(struct device *dev)
 598 {
 599         struct pci_dev *pci_dev = to_pci_dev(dev);
 600         struct device_driver *drv = dev->driver;
 601         int error = 0;
 602
 603         if (pci_has_legacy_pm_support(pci_dev))
 604                 return pci_legacy_suspend(dev, PMSG_FREEZE);
 605
 606         if (drv && drv->pm && drv->pm->freeze) {
 607                 error = drv->pm->freeze(dev);
 608                 suspend_report_result(drv->pm->freeze, error);
 609         }
 610
 611         if (!error)
 612                 pci_pm_default_suspend_generic(pci_dev);
 613
 614         return error;
 615 }
 616
 617 static int pci_pm_freeze_noirq(struct device *dev)
 618 {
 619         struct pci_dev *pci_dev = to_pci_dev(dev);
 620         struct device_driver *drv = dev->driver;
 621         int error = 0;
 622
 623         if (pci_has_legacy_pm_support(pci_dev))
 624                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
 625
 626         if (drv && drv->pm && drv->pm->freeze_noirq) {
 627                 error = drv->pm->freeze_noirq(dev);
 628                 suspend_report_result(drv->pm->freeze_noirq, error);
 629         }
 630
 631         if (!error)
 632                 pci_pm_set_unknown_state(pci_dev);
 633
 634         return error;
 635 }
 636
 637 static int pci_pm_thaw_noirq(struct device *dev)
 638 {
 639         struct pci_dev *pci_dev = to_pci_dev(dev);
 640         struct device_driver *drv = dev->driver;
 641         int error = 0;
 642
 643         if (pci_has_legacy_pm_support(pci_dev))
 644                 return pci_legacy_resume_early(dev);
 645
 646         pci_update_current_state(pci_dev, PCI_D0);
 647
 648         if (drv && drv->pm && drv->pm->thaw_noirq)
 649                 error = drv->pm->thaw_noirq(dev);
 650
 651         return error;
 652 }
 653
 654 static int pci_pm_thaw(struct device *dev)
 655 {
 656         struct pci_dev *pci_dev = to_pci_dev(dev);
 657         struct device_driver *drv = dev->driver;
 658         int error = 0;
 659
 660         if (pci_has_legacy_pm_support(pci_dev))
 661                 return pci_legacy_resume(dev);
 662
 663         pci_pm_reenable_device(pci_dev);
 664
 665         if (drv && drv->pm && drv->pm->thaw)
 666                 error =  drv->pm->thaw(dev);
 667
 668         return error;
 669 }
 670
 671 static int pci_pm_poweroff(struct device *dev)
 672 {
 673         struct pci_dev *pci_dev = to_pci_dev(dev);
 674         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 675         int error = 0;
 676
 677         if (pci_has_legacy_pm_support(pci_dev))
 678                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
 679
 680         if (pm && pm->poweroff) {
 681                 error = pm->poweroff(dev);
 682                 suspend_report_result(pm->poweroff, error);
 683         }
 684
 685         if (!error)
 686                 pci_pm_default_suspend(pci_dev, !!pm);
 687
 688         return error;
 689 }
 690
 691 static int pci_pm_poweroff_noirq(struct device *dev)
 692 {
 693         struct device_driver *drv = dev->driver;
 694         int error = 0;
 695
 696         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
 697                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 698
 699         if (drv && drv->pm && drv->pm->poweroff_noirq) {
 700                 error = drv->pm->poweroff_noirq(dev);
 701                 suspend_report_result(drv->pm->poweroff_noirq, error);
 702         }
 703
 704         return error;
 705 }
 706
 707 static int pci_pm_restore_noirq(struct device *dev)
 708 {
 709         struct pci_dev *pci_dev = to_pci_dev(dev);
 710         struct device_driver *drv = dev->driver;
 711         int error = 0;
 712
 713         pci_pm_default_resume_noirq(pci_dev);
 714
 715         if (pci_has_legacy_pm_support(pci_dev))
 716                 return pci_legacy_resume_early(dev);
 717
 718         if (drv && drv->pm && drv->pm->restore_noirq)
 719                 error = drv->pm->restore_noirq(dev);
 720
 721         return error;
 722 }
 723
 724 static int pci_pm_restore(struct device *dev)
 725 {
 726         struct pci_dev *pci_dev = to_pci_dev(dev);
 727         struct device_driver *drv = dev->driver;
 728         int error = 0;
 729
 730         /*
 731          * This is necessary for the hibernation error path in which restore is
 732          * called without restoring the standard config registers of the device.
 733          */
 734         if (pci_dev->state_saved)
 735                 pci_restore_standard_config(pci_dev);
 736
 737         if (pci_has_legacy_pm_support(pci_dev))
 738                 return pci_legacy_resume(dev);
 739
 740         error = pci_pm_default_resume(pci_dev);
 741
 742         if (!error && drv && drv->pm && drv->pm->restore)
 743                 error = drv->pm->restore(dev);
 744
 745         return error;
 746 }
 747
 748 #else /* !CONFIG_HIBERNATION */
 749
 750 #define pci_pm_freeze           NULL
 751 #define pci_pm_freeze_noirq     NULL
 752 #define pci_pm_thaw             NULL
 753 #define pci_pm_thaw_noirq       NULL
 754 #define pci_pm_poweroff         NULL
 755 #define pci_pm_poweroff_noirq   NULL
 756 #define pci_pm_restore          NULL
 757 #define pci_pm_restore_noirq    NULL
 758
 759 #endif /* !CONFIG_HIBERNATION */
 760
 761 struct dev_pm_ops pci_dev_pm_ops = {
 762         .prepare = pci_pm_prepare,
 763         .complete = pci_pm_complete,
 764         .suspend = pci_pm_suspend,
 765         .resume = pci_pm_resume,
 766         .freeze = pci_pm_freeze,
 767         .thaw = pci_pm_thaw,
 768         .poweroff = pci_pm_poweroff,
 769         .restore = pci_pm_restore,
 770         .suspend_noirq = pci_pm_suspend_noirq,
 771         .resume_noirq = pci_pm_resume_noirq,
 772         .freeze_noirq = pci_pm_freeze_noirq,
 773         .thaw_noirq = pci_pm_thaw_noirq,
 774         .poweroff_noirq = pci_pm_poweroff_noirq,
 775         .restore_noirq = pci_pm_restore_noirq,
 776 };
 777
 778 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
 779
 780 #else /* !CONFIG_PM_SLEEP */
 781
 782 #define PCI_PM_OPS_PTR  NULL
 783
 784 #endif /* !CONFIG_PM_SLEEP */
 785
 786 /**
 787  * __pci_register_driver - register a new pci driver
 788  * @drv: the driver structure to register
 789  * @owner: owner module of drv
 790  * @mod_name: module name string
 791  *
 792  * Adds the driver structure to the list of registered drivers.
 793  * Returns a negative value on error, otherwise 0.
 794  * If no error occurred, the driver remains registered even if
 795  * no device was claimed during registration.
 796  */
 797 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
 798                           const char *mod_name)
 799 {
 800         int error;
 801
 802         /* initialize common driver fields */
 803         drv->driver.name = drv->name;
 804         drv->driver.bus = &pci_bus_type;
 805         drv->driver.owner = owner;
 806         drv->driver.mod_name = mod_name;
 807
 808         spin_lock_init(&drv->dynids.lock);
 809         INIT_LIST_HEAD(&drv->dynids.list);
 810
 811         /* register with core */
 812         error = driver_register(&drv->driver);
 813         if (error)
 814                 return error;
 815
 816         error = pci_create_newid_file(drv);
 817         if (error)
 818                 driver_unregister(&drv->driver);
 819
 820         return error;
 821 }
 822
 823 /**
 824  * pci_unregister_driver - unregister a pci driver
 825  * @drv: the driver structure to unregister
 826  *
 827  * Deletes the driver structure from the list of registered PCI drivers,
 828  * gives it a chance to clean up by calling its remove() function for
 829  * each device it was responsible for, and marks those devices as
 830  * driverless.
 831  */
 832
 833 void
 834 pci_unregister_driver(struct pci_driver *drv)
 835 {
 836         pci_remove_newid_file(drv);
 837         driver_unregister(&drv->driver);
 838         pci_free_dynids(drv);
 839 }
 840
 841 static struct pci_driver pci_compat_driver = {
 842         .name = "compat"
 843 };
 844
 845 /**
 846  * pci_dev_driver - get the pci_driver of a device
 847  * @dev: the device to query
 848  *
 849  * Returns the appropriate pci_driver structure or %NULL if there is no
 850  * registered driver for the device.
 851  */
 852 struct pci_driver *
 853 pci_dev_driver(const struct pci_dev *dev)
 854 {
 855         if (dev->driver)
 856                 return dev->driver;
 857         else {
 858                 int i;
 859                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
 860                         if (dev->resource[i].flags & IORESOURCE_BUSY)
 861                                 return &pci_compat_driver;
 862         }
 863         return NULL;
 864 }
 865
 866 /**
 867  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
 868  * @dev: the PCI device structure to match against
 869  * @drv: the device driver to search for matching PCI device id structures
 870  *
 871  * Used by a driver to check whether a PCI device present in the
 872  * system is in its list of supported devices. Returns the matching
 873  * pci_device_id structure or %NULL if there is no match.
 874  */
 875 static int pci_bus_match(struct device *dev, struct device_driver *drv)
 876 {
 877         struct pci_dev *pci_dev = to_pci_dev(dev);
 878         struct pci_driver *pci_drv = to_pci_driver(drv);
 879         const struct pci_device_id *found_id;
 880
 881         found_id = pci_match_device(pci_drv, pci_dev);
 882         if (found_id)
 883                 return 1;
 884
 885         return 0;
 886 }
 887
 888 /**
 889  * pci_dev_get - increments the reference count of the pci device structure
 890  * @dev: the device being referenced
 891  *
 892  * Each live reference to a device should be refcounted.
 893  *
 894  * Drivers for PCI devices should normally record such references in
 895  * their probe() methods, when they bind to a device, and release
 896  * them by calling pci_dev_put(), in their disconnect() methods.
 897  *
 898  * A pointer to the device with the incremented reference counter is returned.
 899  */
 900 struct pci_dev *pci_dev_get(struct pci_dev *dev)
 901 {
 902         if (dev)
 903                 get_device(&dev->dev);
 904         return dev;
 905 }
 906
 907 /**
 908  * pci_dev_put - release a use of the pci device structure
 909  * @dev: device that's been disconnected
 910  *
 911  * Must be called when a user of a device is finished with it.  When the last
 912  * user of the device calls this function, the memory of the device is freed.
 913  */
 914 void pci_dev_put(struct pci_dev *dev)
 915 {
 916         if (dev)
 917                 put_device(&dev->dev);
 918 }
 919
 920 #ifndef CONFIG_HOTPLUG
 921 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
 922 {
 923         return -ENODEV;
 924 }
 925 #endif
 926
 927 struct bus_type pci_bus_type = {
 928         .name           = "pci",
 929         .match          = pci_bus_match,
 930         .uevent         = pci_uevent,
 931         .probe          = pci_device_probe,
 932         .remove         = pci_device_remove,
 933         .shutdown       = pci_device_shutdown,
 934         .dev_attrs      = pci_dev_attrs,
 935         .pm             = PCI_PM_OPS_PTR,
 936 };
 937
 938 static int __init pci_driver_init(void)
 939 {
 940         return bus_register(&pci_bus_type);
 941 }
 942
 943 postcore_initcall(pci_driver_init);
 944
 945 EXPORT_SYMBOL(pci_match_id);
 946 EXPORT_SYMBOL(__pci_register_driver);
 947 EXPORT_SYMBOL(pci_unregister_driver);
 948 EXPORT_SYMBOL(pci_dev_driver);
 949 EXPORT_SYMBOL(pci_bus_type);
 950 EXPORT_SYMBOL(pci_dev_get);
 951 EXPORT_SYMBOL(pci_dev_put);