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