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