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