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 /**
 103  * store_remove_id - remove a PCI device ID from this driver
 104  * @driver: target device driver
 105  * @buf: buffer for scanning device ID data
 106  * @count: input size
 107  *
 108  * Removes a dynamic pci device ID to this driver.
 109  */
 110 static ssize_t
 111 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
 112 {
 113         struct pci_dynid *dynid, *n;
 114         struct pci_driver *pdrv = to_pci_driver(driver);
 115         __u32 vendor, device, subvendor = PCI_ANY_ID,
 116                 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
 117         int fields = 0;
 118         int retval = -ENODEV;
 119
 120         fields = sscanf(buf, "%x %x %x %x %x %x",
 121                         &vendor, &device, &subvendor, &subdevice,
 122                         &class, &class_mask);
 123         if (fields < 2)
 124                 return -EINVAL;
 125
 126         spin_lock(&pdrv->dynids.lock);
 127         list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
 128                 struct pci_device_id *id = &dynid->id;
 129                 if ((id->vendor == vendor) &&
 130                     (id->device == device) &&
 131                     (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
 132                     (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
 133                     !((id->class ^ class) & class_mask)) {
 134                         list_del(&dynid->node);
 135                         kfree(dynid);
 136                         retval = 0;
 137                         break;
 138                 }
 139         }
 140         spin_unlock(&pdrv->dynids.lock);
 141
 142         if (retval)
 143                 return retval;
 144         return count;
 145 }
 146 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
 147
 148 static void
 149 pci_free_dynids(struct pci_driver *drv)
 150 {
 151         struct pci_dynid *dynid, *n;
 152
 153         spin_lock(&drv->dynids.lock);
 154         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
 155                 list_del(&dynid->node);
 156                 kfree(dynid);
 157         }
 158         spin_unlock(&drv->dynids.lock);
 159 }
 160
 161 static int
 162 pci_create_newid_file(struct pci_driver *drv)
 163 {
 164         int error = 0;
 165         if (drv->probe != NULL)
 166                 error = driver_create_file(&drv->driver, &driver_attr_new_id);
 167         return error;
 168 }
 169
 170 static void pci_remove_newid_file(struct pci_driver *drv)
 171 {
 172         driver_remove_file(&drv->driver, &driver_attr_new_id);
 173 }
 174
 175 static int
 176 pci_create_removeid_file(struct pci_driver *drv)
 177 {
 178         int error = 0;
 179         if (drv->probe != NULL)
 180                 error = driver_create_file(&drv->driver,&driver_attr_remove_id);
 181         return error;
 182 }
 183
 184 static void pci_remove_removeid_file(struct pci_driver *drv)
 185 {
 186         driver_remove_file(&drv->driver, &driver_attr_remove_id);
 187 }
 188 #else /* !CONFIG_HOTPLUG */
 189 static inline void pci_free_dynids(struct pci_driver *drv) {}
 190 static inline int pci_create_newid_file(struct pci_driver *drv)
 191 {
 192         return 0;
 193 }
 194 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
 195 static inline int pci_create_removeid_file(struct pci_driver *drv)
 196 {
 197         return 0;
 198 }
 199 static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
 200 #endif
 201
 202 /**
 203  * pci_match_id - See if a pci device matches a given pci_id table
 204  * @ids: array of PCI device id structures to search in
 205  * @dev: the PCI device structure to match against.
 206  *
 207  * Used by a driver to check whether a PCI device present in the
 208  * system is in its list of supported devices.  Returns the matching
 209  * pci_device_id structure or %NULL if there is no match.
 210  *
 211  * Deprecated, don't use this as it will not catch any dynamic ids
 212  * that a driver might want to check for.
 213  */
 214 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
 215                                          struct pci_dev *dev)
 216 {
 217         if (ids) {
 218                 while (ids->vendor || ids->subvendor || ids->class_mask) {
 219                         if (pci_match_one_device(ids, dev))
 220                                 return ids;
 221                         ids++;
 222                 }
 223         }
 224         return NULL;
 225 }
 226
 227 /**
 228  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
 229  * @drv: the PCI driver to match against
 230  * @dev: the PCI device structure to match against
 231  *
 232  * Used by a driver to check whether a PCI device present in the
 233  * system is in its list of supported devices.  Returns the matching
 234  * pci_device_id structure or %NULL if there is no match.
 235  */
 236 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
 237                                                     struct pci_dev *dev)
 238 {
 239         struct pci_dynid *dynid;
 240
 241         /* Look at the dynamic ids first, before the static ones */
 242         spin_lock(&drv->dynids.lock);
 243         list_for_each_entry(dynid, &drv->dynids.list, node) {
 244                 if (pci_match_one_device(&dynid->id, dev)) {
 245                         spin_unlock(&drv->dynids.lock);
 246                         return &dynid->id;
 247                 }
 248         }
 249         spin_unlock(&drv->dynids.lock);
 250
 251         return pci_match_id(drv->id_table, dev);
 252 }
 253
 254 struct drv_dev_and_id {
 255         struct pci_driver *drv;
 256         struct pci_dev *dev;
 257         const struct pci_device_id *id;
 258 };
 259
 260 static long local_pci_probe(void *_ddi)
 261 {
 262         struct drv_dev_and_id *ddi = _ddi;
 263
 264         return ddi->drv->probe(ddi->dev, ddi->id);
 265 }
 266
 267 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
 268                           const struct pci_device_id *id)
 269 {
 270         int error, node;
 271         struct drv_dev_and_id ddi = { drv, dev, id };
 272
 273         /* Execute driver initialization on node where the device's
 274            bus is attached to.  This way the driver likely allocates
 275            its local memory on the right node without any need to
 276            change it. */
 277         node = dev_to_node(&dev->dev);
 278         if (node >= 0) {
 279                 int cpu;
 280
 281                 get_online_cpus();
 282                 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
 283                 if (cpu < nr_cpu_ids)
 284                         error = work_on_cpu(cpu, local_pci_probe, &ddi);
 285                 else
 286                         error = local_pci_probe(&ddi);
 287                 put_online_cpus();
 288         } else
 289                 error = local_pci_probe(&ddi);
 290         return error;
 291 }
 292
 293 /**
 294  * __pci_device_probe()
 295  * @drv: driver to call to check if it wants the PCI device
 296  * @pci_dev: PCI device being probed
 297  *
 298  * returns 0 on success, else error.
 299  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
 300  */
 301 static int
 302 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
 303 {
 304         const struct pci_device_id *id;
 305         int error = 0;
 306
 307         if (!pci_dev->driver && drv->probe) {
 308                 error = -ENODEV;
 309
 310                 id = pci_match_device(drv, pci_dev);
 311                 if (id)
 312                         error = pci_call_probe(drv, pci_dev, id);
 313                 if (error >= 0) {
 314                         pci_dev->driver = drv;
 315                         error = 0;
 316                 }
 317         }
 318         return error;
 319 }
 320
 321 static int pci_device_probe(struct device * dev)
 322 {
 323         int error = 0;
 324         struct pci_driver *drv;
 325         struct pci_dev *pci_dev;
 326
 327         drv = to_pci_driver(dev->driver);
 328         pci_dev = to_pci_dev(dev);
 329         pci_dev_get(pci_dev);
 330         error = __pci_device_probe(drv, pci_dev);
 331         if (error)
 332                 pci_dev_put(pci_dev);
 333
 334         return error;
 335 }
 336
 337 static int pci_device_remove(struct device * dev)
 338 {
 339         struct pci_dev * pci_dev = to_pci_dev(dev);
 340         struct pci_driver * drv = pci_dev->driver;
 341
 342         if (drv) {
 343                 if (drv->remove)
 344                         drv->remove(pci_dev);
 345                 pci_dev->driver = NULL;
 346         }
 347
 348         /*
 349          * If the device is still on, set the power state as "unknown",
 350          * since it might change by the next time we load the driver.
 351          */
 352         if (pci_dev->current_state == PCI_D0)
 353                 pci_dev->current_state = PCI_UNKNOWN;
 354
 355         /*
 356          * We would love to complain here if pci_dev->is_enabled is set, that
 357          * the driver should have called pci_disable_device(), but the
 358          * unfortunate fact is there are too many odd BIOS and bridge setups
 359          * that don't like drivers doing that all of the time.
 360          * Oh well, we can dream of sane hardware when we sleep, no matter how
 361          * horrible the crap we have to deal with is when we are awake...
 362          */
 363
 364         pci_dev_put(pci_dev);
 365         return 0;
 366 }
 367
 368 static void pci_device_shutdown(struct device *dev)
 369 {
 370         struct pci_dev *pci_dev = to_pci_dev(dev);
 371         struct pci_driver *drv = pci_dev->driver;
 372
 373         if (drv && drv->shutdown)
 374                 drv->shutdown(pci_dev);
 375         pci_msi_shutdown(pci_dev);
 376         pci_msix_shutdown(pci_dev);
 377 }
 378
 379 #ifdef CONFIG_PM_SLEEP
 380
 381 /*
 382  * Default "suspend" method for devices that have no driver provided suspend,
 383  * or not even a driver at all (second part).
 384  */
 385 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
 386 {
 387         /*
 388          * mark its power state as "unknown", since we don't know if
 389          * e.g. the BIOS will change its device state when we suspend.
 390          */
 391         if (pci_dev->current_state == PCI_D0)
 392                 pci_dev->current_state = PCI_UNKNOWN;
 393 }
 394
 395 /*
 396  * Default "resume" method for devices that have no driver provided resume,
 397  * or not even a driver at all (second part).
 398  */
 399 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
 400 {
 401         int retval;
 402
 403         /* if the device was enabled before suspend, reenable */
 404         retval = pci_reenable_device(pci_dev);
 405         /*
 406          * if the device was busmaster before the suspend, make it busmaster
 407          * again
 408          */
 409         if (pci_dev->is_busmaster)
 410                 pci_set_master(pci_dev);
 411
 412         return retval;
 413 }
 414
 415 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
 416 {
 417         struct pci_dev * pci_dev = to_pci_dev(dev);
 418         struct pci_driver * drv = pci_dev->driver;
 419
 420         pci_dev->state_saved = false;
 421
 422         if (drv && drv->suspend) {
 423                 pci_power_t prev = pci_dev->current_state;
 424                 int error;
 425
 426                 error = drv->suspend(pci_dev, state);
 427                 suspend_report_result(drv->suspend, error);
 428                 if (error)
 429                         return error;
 430
 431                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 432                     && pci_dev->current_state != PCI_UNKNOWN) {
 433                         WARN_ONCE(pci_dev->current_state != prev,
 434                                 "PCI PM: Device state not saved by %pF\n",
 435                                 drv->suspend);
 436                 }
 437         }
 438
 439         pci_fixup_device(pci_fixup_suspend, pci_dev);
 440
 441         return 0;
 442 }
 443
 444 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 445 {
 446         struct pci_dev * pci_dev = to_pci_dev(dev);
 447         struct pci_driver * drv = pci_dev->driver;
 448
 449         if (drv && drv->suspend_late) {
 450                 pci_power_t prev = pci_dev->current_state;
 451                 int error;
 452
 453                 error = drv->suspend_late(pci_dev, state);
 454                 suspend_report_result(drv->suspend_late, error);
 455                 if (error)
 456                         return error;
 457
 458                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 459                     && pci_dev->current_state != PCI_UNKNOWN) {
 460                         WARN_ONCE(pci_dev->current_state != prev,
 461                                 "PCI PM: Device state not saved by %pF\n",
 462                                 drv->suspend_late);
 463                         return 0;
 464                 }
 465         }
 466
 467         if (!pci_dev->state_saved)
 468                 pci_save_state(pci_dev);
 469
 470         pci_pm_set_unknown_state(pci_dev);
 471
 472         return 0;
 473 }
 474
 475 static int pci_legacy_resume_early(struct device *dev)
 476 {
 477         struct pci_dev * pci_dev = to_pci_dev(dev);
 478         struct pci_driver * drv = pci_dev->driver;
 479
 480         return drv && drv->resume_early ?
 481                         drv->resume_early(pci_dev) : 0;
 482 }
 483
 484 static int pci_legacy_resume(struct device *dev)
 485 {
 486         struct pci_dev * pci_dev = to_pci_dev(dev);
 487         struct pci_driver * drv = pci_dev->driver;
 488
 489         pci_fixup_device(pci_fixup_resume, pci_dev);
 490
 491         return drv && drv->resume ?
 492                         drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
 493 }
 494
 495 /* Auxiliary functions used by the new power management framework */
 496
 497 /**
 498  * pci_restore_standard_config - restore standard config registers of PCI device
 499  * @pci_dev: PCI device to handle
 500  */
 501 static int pci_restore_standard_config(struct pci_dev *pci_dev)
 502 {
 503         pci_update_current_state(pci_dev, PCI_UNKNOWN);
 504
 505         if (pci_dev->current_state != PCI_D0) {
 506                 int error = pci_set_power_state(pci_dev, PCI_D0);
 507                 if (error)
 508                         return error;
 509         }
 510
 511         return pci_dev->state_saved ? pci_restore_state(pci_dev) : 0;
 512 }
 513
 514 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
 515 {
 516         pci_restore_standard_config(pci_dev);
 517         pci_dev->state_saved = false;
 518         pci_fixup_device(pci_fixup_resume_early, pci_dev);
 519 }
 520
 521 static void pci_pm_default_resume(struct pci_dev *pci_dev)
 522 {
 523         pci_fixup_device(pci_fixup_resume, pci_dev);
 524
 525         if (!pci_is_bridge(pci_dev))
 526                 pci_enable_wake(pci_dev, PCI_D0, false);
 527 }
 528
 529 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
 530 {
 531         /* Disable non-bridge devices without PM support */
 532         if (!pci_is_bridge(pci_dev))
 533                 pci_disable_enabled_device(pci_dev);
 534 }
 535
 536 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
 537 {
 538         struct pci_driver *drv = pci_dev->driver;
 539         bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
 540                 || drv->resume_early);
 541
 542         /*
 543          * Legacy PM support is used by default, so warn if the new framework is
 544          * supported as well.  Drivers are supposed to support either the
 545          * former, or the latter, but not both at the same time.
 546          */
 547         WARN_ON(ret && drv->driver.pm);
 548
 549         return ret;
 550 }
 551
 552 /* New power management framework */
 553
 554 static int pci_pm_prepare(struct device *dev)
 555 {
 556         struct device_driver *drv = dev->driver;
 557         int error = 0;
 558
 559         if (drv && drv->pm && drv->pm->prepare)
 560                 error = drv->pm->prepare(dev);
 561
 562         return error;
 563 }
 564
 565 static void pci_pm_complete(struct device *dev)
 566 {
 567         struct device_driver *drv = dev->driver;
 568
 569         if (drv && drv->pm && drv->pm->complete)
 570                 drv->pm->complete(dev);
 571 }
 572
 573 #ifdef CONFIG_SUSPEND
 574
 575 static int pci_pm_suspend(struct device *dev)
 576 {
 577         struct pci_dev *pci_dev = to_pci_dev(dev);
 578         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 579
 580         if (pci_has_legacy_pm_support(pci_dev))
 581                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
 582
 583         pci_dev->state_saved = false;
 584
 585         if (!pm) {
 586                 pci_pm_default_suspend(pci_dev);
 587                 goto Fixup;
 588         }
 589
 590         if (pm->suspend) {
 591                 pci_power_t prev = pci_dev->current_state;
 592                 int error;
 593
 594                 error = pm->suspend(dev);
 595                 suspend_report_result(pm->suspend, error);
 596                 if (error)
 597                         return error;
 598
 599                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 600                     && pci_dev->current_state != PCI_UNKNOWN) {
 601                         WARN_ONCE(pci_dev->current_state != prev,
 602                                 "PCI PM: State of device not saved by %pF\n",
 603                                 pm->suspend);
 604                 }
 605         }
 606
 607  Fixup:
 608         pci_fixup_device(pci_fixup_suspend, pci_dev);
 609
 610         return 0;
 611 }
 612
 613 static int pci_pm_suspend_noirq(struct device *dev)
 614 {
 615         struct pci_dev *pci_dev = to_pci_dev(dev);
 616         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 617
 618         if (pci_has_legacy_pm_support(pci_dev))
 619                 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 620
 621         if (!pm) {
 622                 pci_save_state(pci_dev);
 623                 return 0;
 624         }
 625
 626         if (pm->suspend_noirq) {
 627                 pci_power_t prev = pci_dev->current_state;
 628                 int error;
 629
 630                 error = pm->suspend_noirq(dev);
 631                 suspend_report_result(pm->suspend_noirq, error);
 632                 if (error)
 633                         return error;
 634
 635                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
 636                     && pci_dev->current_state != PCI_UNKNOWN) {
 637                         WARN_ONCE(pci_dev->current_state != prev,
 638                                 "PCI PM: State of device not saved by %pF\n",
 639                                 pm->suspend_noirq);
 640                         return 0;
 641                 }
 642         }
 643
 644         if (!pci_dev->state_saved) {
 645                 pci_save_state(pci_dev);
 646                 if (!pci_is_bridge(pci_dev))
 647                         pci_prepare_to_sleep(pci_dev);
 648         }
 649
 650         pci_pm_set_unknown_state(pci_dev);
 651
 652         return 0;
 653 }
 654
 655 static int pci_pm_resume_noirq(struct device *dev)
 656 {
 657         struct pci_dev *pci_dev = to_pci_dev(dev);
 658         struct device_driver *drv = dev->driver;
 659         int error = 0;
 660
 661         pci_pm_default_resume_noirq(pci_dev);
 662
 663         if (pci_has_legacy_pm_support(pci_dev))
 664                 return pci_legacy_resume_early(dev);
 665
 666         if (drv && drv->pm && drv->pm->resume_noirq)
 667                 error = drv->pm->resume_noirq(dev);
 668
 669         return error;
 670 }
 671
 672 static int pci_pm_resume(struct device *dev)
 673 {
 674         struct pci_dev *pci_dev = to_pci_dev(dev);
 675         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 676         int error = 0;
 677
 678         /*
 679          * This is necessary for the suspend error path in which resume is
 680          * called without restoring the standard config registers of the device.
 681          */
 682         if (pci_dev->state_saved)
 683                 pci_restore_standard_config(pci_dev);
 684
 685         if (pci_has_legacy_pm_support(pci_dev))
 686                 return pci_legacy_resume(dev);
 687
 688         pci_pm_default_resume(pci_dev);
 689
 690         if (pm) {
 691                 if (pm->resume)
 692                         error = pm->resume(dev);
 693         } else {
 694                 pci_pm_reenable_device(pci_dev);
 695         }
 696
 697         return 0;
 698 }
 699
 700 #else /* !CONFIG_SUSPEND */
 701
 702 #define pci_pm_suspend          NULL
 703 #define pci_pm_suspend_noirq    NULL
 704 #define pci_pm_resume           NULL
 705 #define pci_pm_resume_noirq     NULL
 706
 707 #endif /* !CONFIG_SUSPEND */
 708
 709 #ifdef CONFIG_HIBERNATION
 710
 711 static int pci_pm_freeze(struct device *dev)
 712 {
 713         struct pci_dev *pci_dev = to_pci_dev(dev);
 714         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 715
 716         if (pci_has_legacy_pm_support(pci_dev))
 717                 return pci_legacy_suspend(dev, PMSG_FREEZE);
 718
 719         pci_dev->state_saved = false;
 720
 721         if (!pm) {
 722                 pci_pm_default_suspend(pci_dev);
 723                 return 0;
 724         }
 725
 726         if (pm->freeze) {
 727                 int error;
 728
 729                 error = pm->freeze(dev);
 730                 suspend_report_result(pm->freeze, error);
 731                 if (error)
 732                         return error;
 733         }
 734
 735         return 0;
 736 }
 737
 738 static int pci_pm_freeze_noirq(struct device *dev)
 739 {
 740         struct pci_dev *pci_dev = to_pci_dev(dev);
 741         struct device_driver *drv = dev->driver;
 742
 743         if (pci_has_legacy_pm_support(pci_dev))
 744                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
 745
 746         if (drv && drv->pm && drv->pm->freeze_noirq) {
 747                 int error;
 748
 749                 error = drv->pm->freeze_noirq(dev);
 750                 suspend_report_result(drv->pm->freeze_noirq, error);
 751                 if (error)
 752                         return error;
 753         }
 754
 755         if (!pci_dev->state_saved)
 756                 pci_save_state(pci_dev);
 757
 758         pci_pm_set_unknown_state(pci_dev);
 759
 760         return 0;
 761 }
 762
 763 static int pci_pm_thaw_noirq(struct device *dev)
 764 {
 765         struct pci_dev *pci_dev = to_pci_dev(dev);
 766         struct device_driver *drv = dev->driver;
 767         int error = 0;
 768
 769         if (pci_has_legacy_pm_support(pci_dev))
 770                 return pci_legacy_resume_early(dev);
 771
 772         pci_update_current_state(pci_dev, PCI_D0);
 773
 774         if (drv && drv->pm && drv->pm->thaw_noirq)
 775                 error = drv->pm->thaw_noirq(dev);
 776
 777         return error;
 778 }
 779
 780 static int pci_pm_thaw(struct device *dev)
 781 {
 782         struct pci_dev *pci_dev = to_pci_dev(dev);
 783         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 784         int error = 0;
 785
 786         if (pci_has_legacy_pm_support(pci_dev))
 787                 return pci_legacy_resume(dev);
 788
 789         if (pm) {
 790                 if (pm->thaw)
 791                         error = pm->thaw(dev);
 792         } else {
 793                 pci_pm_reenable_device(pci_dev);
 794         }
 795
 796         return error;
 797 }
 798
 799 static int pci_pm_poweroff(struct device *dev)
 800 {
 801         struct pci_dev *pci_dev = to_pci_dev(dev);
 802         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 803
 804         if (pci_has_legacy_pm_support(pci_dev))
 805                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
 806
 807         pci_dev->state_saved = false;
 808
 809         if (!pm) {
 810                 pci_pm_default_suspend(pci_dev);
 811                 goto Fixup;
 812         }
 813
 814         if (pm->poweroff) {
 815                 int error;
 816
 817                 error = pm->poweroff(dev);
 818                 suspend_report_result(pm->poweroff, error);
 819                 if (error)
 820                         return error;
 821         }
 822
 823  Fixup:
 824         pci_fixup_device(pci_fixup_suspend, pci_dev);
 825
 826         return 0;
 827 }
 828
 829 static int pci_pm_poweroff_noirq(struct device *dev)
 830 {
 831         struct pci_dev *pci_dev = to_pci_dev(dev);
 832         struct device_driver *drv = dev->driver;
 833
 834         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
 835                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 836
 837         if (!drv || !drv->pm)
 838                 return 0;
 839
 840         if (drv->pm->poweroff_noirq) {
 841                 int error;
 842
 843                 error = drv->pm->poweroff_noirq(dev);
 844                 suspend_report_result(drv->pm->poweroff_noirq, error);
 845                 if (error)
 846                         return error;
 847         }
 848
 849         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
 850                 pci_prepare_to_sleep(pci_dev);
 851
 852         return 0;
 853 }
 854
 855 static int pci_pm_restore_noirq(struct device *dev)
 856 {
 857         struct pci_dev *pci_dev = to_pci_dev(dev);
 858         struct device_driver *drv = dev->driver;
 859         int error = 0;
 860
 861         pci_pm_default_resume_noirq(pci_dev);
 862
 863         if (pci_has_legacy_pm_support(pci_dev))
 864                 return pci_legacy_resume_early(dev);
 865
 866         if (drv && drv->pm && drv->pm->restore_noirq)
 867                 error = drv->pm->restore_noirq(dev);
 868
 869         return error;
 870 }
 871
 872 static int pci_pm_restore(struct device *dev)
 873 {
 874         struct pci_dev *pci_dev = to_pci_dev(dev);
 875         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 876         int error = 0;
 877
 878         /*
 879          * This is necessary for the hibernation error path in which restore is
 880          * called without restoring the standard config registers of the device.
 881          */
 882         if (pci_dev->state_saved)
 883                 pci_restore_standard_config(pci_dev);
 884
 885         if (pci_has_legacy_pm_support(pci_dev))
 886                 return pci_legacy_resume(dev);
 887
 888         pci_pm_default_resume(pci_dev);
 889
 890         if (pm) {
 891                 if (pm->restore)
 892                         error = pm->restore(dev);
 893         } else {
 894                 pci_pm_reenable_device(pci_dev);
 895         }
 896
 897         return error;
 898 }
 899
 900 #else /* !CONFIG_HIBERNATION */
 901
 902 #define pci_pm_freeze           NULL
 903 #define pci_pm_freeze_noirq     NULL
 904 #define pci_pm_thaw             NULL
 905 #define pci_pm_thaw_noirq       NULL
 906 #define pci_pm_poweroff         NULL
 907 #define pci_pm_poweroff_noirq   NULL
 908 #define pci_pm_restore          NULL
 909 #define pci_pm_restore_noirq    NULL
 910
 911 #endif /* !CONFIG_HIBERNATION */
 912
 913 struct dev_pm_ops pci_dev_pm_ops = {
 914         .prepare = pci_pm_prepare,
 915         .complete = pci_pm_complete,
 916         .suspend = pci_pm_suspend,
 917         .resume = pci_pm_resume,
 918         .freeze = pci_pm_freeze,
 919         .thaw = pci_pm_thaw,
 920         .poweroff = pci_pm_poweroff,
 921         .restore = pci_pm_restore,
 922         .suspend_noirq = pci_pm_suspend_noirq,
 923         .resume_noirq = pci_pm_resume_noirq,
 924         .freeze_noirq = pci_pm_freeze_noirq,
 925         .thaw_noirq = pci_pm_thaw_noirq,
 926         .poweroff_noirq = pci_pm_poweroff_noirq,
 927         .restore_noirq = pci_pm_restore_noirq,
 928 };
 929
 930 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
 931
 932 #else /* !CONFIG_PM_SLEEP */
 933
 934 #define PCI_PM_OPS_PTR  NULL
 935
 936 #endif /* !CONFIG_PM_SLEEP */
 937
 938 /**
 939  * __pci_register_driver - register a new pci driver
 940  * @drv: the driver structure to register
 941  * @owner: owner module of drv
 942  * @mod_name: module name string
 943  *
 944  * Adds the driver structure to the list of registered drivers.
 945  * Returns a negative value on error, otherwise 0.
 946  * If no error occurred, the driver remains registered even if
 947  * no device was claimed during registration.
 948  */
 949 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
 950                           const char *mod_name)
 951 {
 952         int error;
 953
 954         /* initialize common driver fields */
 955         drv->driver.name = drv->name;
 956         drv->driver.bus = &pci_bus_type;
 957         drv->driver.owner = owner;
 958         drv->driver.mod_name = mod_name;
 959
 960         spin_lock_init(&drv->dynids.lock);
 961         INIT_LIST_HEAD(&drv->dynids.list);
 962
 963         /* register with core */
 964         error = driver_register(&drv->driver);
 965         if (error)
 966                 goto out;
 967
 968         error = pci_create_newid_file(drv);
 969         if (error)
 970                 goto out_newid;
 971
 972         error = pci_create_removeid_file(drv);
 973         if (error)
 974                 goto out_removeid;
 975 out:
 976         return error;
 977
 978 out_removeid:
 979         pci_remove_newid_file(drv);
 980 out_newid:
 981         driver_unregister(&drv->driver);
 982         goto out;
 983 }
 984
 985 /**
 986  * pci_unregister_driver - unregister a pci driver
 987  * @drv: the driver structure to unregister
 988  *
 989  * Deletes the driver structure from the list of registered PCI drivers,
 990  * gives it a chance to clean up by calling its remove() function for
 991  * each device it was responsible for, and marks those devices as
 992  * driverless.
 993  */
 994
 995 void
 996 pci_unregister_driver(struct pci_driver *drv)
 997 {
 998         pci_remove_removeid_file(drv);
 999         pci_remove_newid_file(drv);
1000         driver_unregister(&drv->driver);
1001         pci_free_dynids(drv);
1002 }
1003
1004 static struct pci_driver pci_compat_driver = {
1005         .name = "compat"
1006 };
1007
1008 /**
1009  * pci_dev_driver - get the pci_driver of a device
1010  * @dev: the device to query
1011  *
1012  * Returns the appropriate pci_driver structure or %NULL if there is no
1013  * registered driver for the device.
1014  */
1015 struct pci_driver *
1016 pci_dev_driver(const struct pci_dev *dev)
1017 {
1018         if (dev->driver)
1019                 return dev->driver;
1020         else {
1021                 int i;
1022                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1023                         if (dev->resource[i].flags & IORESOURCE_BUSY)
1024                                 return &pci_compat_driver;
1025         }
1026         return NULL;
1027 }
1028
1029 /**
1030  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1031  * @dev: the PCI device structure to match against
1032  * @drv: the device driver to search for matching PCI device id structures
1033  *
1034  * Used by a driver to check whether a PCI device present in the
1035  * system is in its list of supported devices. Returns the matching
1036  * pci_device_id structure or %NULL if there is no match.
1037  */
1038 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1039 {
1040         struct pci_dev *pci_dev = to_pci_dev(dev);
1041         struct pci_driver *pci_drv = to_pci_driver(drv);
1042         const struct pci_device_id *found_id;
1043
1044         found_id = pci_match_device(pci_drv, pci_dev);
1045         if (found_id)
1046                 return 1;
1047
1048         return 0;
1049 }
1050
1051 /**
1052  * pci_dev_get - increments the reference count of the pci device structure
1053  * @dev: the device being referenced
1054  *
1055  * Each live reference to a device should be refcounted.
1056  *
1057  * Drivers for PCI devices should normally record such references in
1058  * their probe() methods, when they bind to a device, and release
1059  * them by calling pci_dev_put(), in their disconnect() methods.
1060  *
1061  * A pointer to the device with the incremented reference counter is returned.
1062  */
1063 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1064 {
1065         if (dev)
1066                 get_device(&dev->dev);
1067         return dev;
1068 }
1069
1070 /**
1071  * pci_dev_put - release a use of the pci device structure
1072  * @dev: device that's been disconnected
1073  *
1074  * Must be called when a user of a device is finished with it.  When the last
1075  * user of the device calls this function, the memory of the device is freed.
1076  */
1077 void pci_dev_put(struct pci_dev *dev)
1078 {
1079         if (dev)
1080                 put_device(&dev->dev);
1081 }
1082
1083 #ifndef CONFIG_HOTPLUG
1084 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1085 {
1086         return -ENODEV;
1087 }
1088 #endif
1089
1090 struct bus_type pci_bus_type = {
1091         .name           = "pci",
1092         .match          = pci_bus_match,
1093         .uevent         = pci_uevent,
1094         .probe          = pci_device_probe,
1095         .remove         = pci_device_remove,
1096         .shutdown       = pci_device_shutdown,
1097         .dev_attrs      = pci_dev_attrs,
1098         .bus_attrs      = pci_bus_attrs,
1099         .pm             = PCI_PM_OPS_PTR,
1100 };
1101
1102 static int __init pci_driver_init(void)
1103 {
1104         return bus_register(&pci_bus_type);
1105 }
1106
1107 postcore_initcall(pci_driver_init);
1108
1109 EXPORT_SYMBOL(pci_match_id);
1110 EXPORT_SYMBOL(__pci_register_driver);
1111 EXPORT_SYMBOL(pci_unregister_driver);
1112 EXPORT_SYMBOL(pci_dev_driver);
1113 EXPORT_SYMBOL(pci_bus_type);
1114 EXPORT_SYMBOL(pci_dev_get);
1115 EXPORT_SYMBOL(pci_dev_put);