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