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