2 * drivers/pci/pci-driver.c
4 * (C) Copyright 2002-2004, 2007 Greg Kroah-Hartman <greg@kroah.com>
5 * (C) Copyright 2007 Novell Inc.
7 * Released under the GPL v2 only.
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 <linux/pm_runtime.h>
21 #include <linux/suspend.h>
25 struct list_head node;
26 struct pci_device_id id;
30 * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
31 * @drv: target pci driver
32 * @vendor: PCI vendor ID
33 * @device: PCI device ID
34 * @subvendor: PCI subvendor ID
35 * @subdevice: PCI subdevice ID
37 * @class_mask: PCI class mask
38 * @driver_data: private driver data
40 * Adds a new dynamic pci device ID to this driver and causes the
41 * driver to probe for all devices again. @drv must have been
42 * registered prior to calling this function.
45 * Does GFP_KERNEL allocation.
48 * 0 on success, -errno on failure.
50 int pci_add_dynid(struct pci_driver *drv,
51 unsigned int vendor, unsigned int device,
52 unsigned int subvendor, unsigned int subdevice,
53 unsigned int class, unsigned int class_mask,
54 unsigned long driver_data)
56 struct pci_dynid *dynid;
59 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
63 dynid->id.vendor = vendor;
64 dynid->id.device = device;
65 dynid->id.subvendor = subvendor;
66 dynid->id.subdevice = subdevice;
67 dynid->id.class = class;
68 dynid->id.class_mask = class_mask;
69 dynid->id.driver_data = driver_data;
71 spin_lock(&drv->dynids.lock);
72 list_add_tail(&dynid->node, &drv->dynids.list);
73 spin_unlock(&drv->dynids.lock);
75 retval = driver_attach(&drv->driver);
80 static void pci_free_dynids(struct pci_driver *drv)
82 struct pci_dynid *dynid, *n;
84 spin_lock(&drv->dynids.lock);
85 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
86 list_del(&dynid->node);
89 spin_unlock(&drv->dynids.lock);
93 * store_new_id - sysfs frontend to pci_add_dynid()
94 * @driver: target device driver
95 * @buf: buffer for scanning device ID data
98 * Allow PCI IDs to be added to an existing driver via sysfs.
101 store_new_id(struct device_driver *driver, const char *buf, size_t count)
103 struct pci_driver *pdrv = to_pci_driver(driver);
104 const struct pci_device_id *ids = pdrv->id_table;
105 __u32 vendor, device, subvendor=PCI_ANY_ID,
106 subdevice=PCI_ANY_ID, class=0, class_mask=0;
107 unsigned long driver_data=0;
111 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
112 &vendor, &device, &subvendor, &subdevice,
113 &class, &class_mask, &driver_data);
117 /* Only accept driver_data values that match an existing id_table
121 while (ids->vendor || ids->subvendor || ids->class_mask) {
122 if (driver_data == ids->driver_data) {
128 if (retval) /* No match */
132 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
133 class, class_mask, driver_data);
140 * store_remove_id - remove a PCI device ID from this driver
141 * @driver: target device driver
142 * @buf: buffer for scanning device ID data
145 * Removes a dynamic pci device ID to this driver.
148 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
150 struct pci_dynid *dynid, *n;
151 struct pci_driver *pdrv = to_pci_driver(driver);
152 __u32 vendor, device, subvendor = PCI_ANY_ID,
153 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
155 int retval = -ENODEV;
157 fields = sscanf(buf, "%x %x %x %x %x %x",
158 &vendor, &device, &subvendor, &subdevice,
159 &class, &class_mask);
163 spin_lock(&pdrv->dynids.lock);
164 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
165 struct pci_device_id *id = &dynid->id;
166 if ((id->vendor == vendor) &&
167 (id->device == device) &&
168 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
169 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
170 !((id->class ^ class) & class_mask)) {
171 list_del(&dynid->node);
177 spin_unlock(&pdrv->dynids.lock);
184 static struct driver_attribute pci_drv_attrs[] = {
185 __ATTR(new_id, S_IWUSR, NULL, store_new_id),
186 __ATTR(remove_id, S_IWUSR, NULL, store_remove_id),
191 * pci_match_id - See if a pci device matches a given pci_id table
192 * @ids: array of PCI device id structures to search in
193 * @dev: the PCI device structure to match against.
195 * Used by a driver to check whether a PCI device present in the
196 * system is in its list of supported devices. Returns the matching
197 * pci_device_id structure or %NULL if there is no match.
199 * Deprecated, don't use this as it will not catch any dynamic ids
200 * that a driver might want to check for.
202 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
206 while (ids->vendor || ids->subvendor || ids->class_mask) {
207 if (pci_match_one_device(ids, dev))
216 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
217 * @drv: the PCI driver to match against
218 * @dev: the PCI device structure to match against
220 * Used by a driver to check whether a PCI device present in the
221 * system is in its list of supported devices. Returns the matching
222 * pci_device_id structure or %NULL if there is no match.
224 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
227 struct pci_dynid *dynid;
229 /* Look at the dynamic ids first, before the static ones */
230 spin_lock(&drv->dynids.lock);
231 list_for_each_entry(dynid, &drv->dynids.list, node) {
232 if (pci_match_one_device(&dynid->id, dev)) {
233 spin_unlock(&drv->dynids.lock);
237 spin_unlock(&drv->dynids.lock);
239 return pci_match_id(drv->id_table, dev);
242 struct drv_dev_and_id {
243 struct pci_driver *drv;
245 const struct pci_device_id *id;
248 static long local_pci_probe(void *_ddi)
250 struct drv_dev_and_id *ddi = _ddi;
251 struct device *dev = &ddi->dev->dev;
252 struct device *parent = dev->parent;
255 /* The parent bridge must be in active state when probing */
257 pm_runtime_get_sync(parent);
258 /* Unbound PCI devices are always set to disabled and suspended.
259 * During probe, the device is set to enabled and active and the
260 * usage count is incremented. If the driver supports runtime PM,
261 * it should call pm_runtime_put_noidle() in its probe routine and
262 * pm_runtime_get_noresume() in its remove routine.
264 pm_runtime_get_noresume(dev);
265 pm_runtime_set_active(dev);
266 pm_runtime_enable(dev);
268 rc = ddi->drv->probe(ddi->dev, ddi->id);
270 pm_runtime_disable(dev);
271 pm_runtime_set_suspended(dev);
272 pm_runtime_put_noidle(dev);
275 pm_runtime_put(parent);
279 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
280 const struct pci_device_id *id)
283 struct drv_dev_and_id ddi = { drv, dev, id };
285 /* Execute driver initialization on node where the device's
286 bus is attached to. This way the driver likely allocates
287 its local memory on the right node without any need to
289 node = dev_to_node(&dev->dev);
294 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
295 if (cpu < nr_cpu_ids)
296 error = work_on_cpu(cpu, local_pci_probe, &ddi);
298 error = local_pci_probe(&ddi);
301 error = local_pci_probe(&ddi);
306 * __pci_device_probe - check if a driver wants to claim a specific PCI device
307 * @drv: driver to call to check if it wants the PCI device
308 * @pci_dev: PCI device being probed
310 * returns 0 on success, else error.
311 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
314 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
316 const struct pci_device_id *id;
319 if (!pci_dev->driver && drv->probe) {
322 id = pci_match_device(drv, pci_dev);
324 error = pci_call_probe(drv, pci_dev, id);
326 pci_dev->driver = drv;
333 static int pci_device_probe(struct device * dev)
336 struct pci_driver *drv;
337 struct pci_dev *pci_dev;
339 drv = to_pci_driver(dev->driver);
340 pci_dev = to_pci_dev(dev);
341 pci_dev_get(pci_dev);
342 error = __pci_device_probe(drv, pci_dev);
344 pci_dev_put(pci_dev);
349 static int pci_device_remove(struct device * dev)
351 struct pci_dev * pci_dev = to_pci_dev(dev);
352 struct pci_driver * drv = pci_dev->driver;
356 pm_runtime_get_sync(dev);
357 drv->remove(pci_dev);
358 pm_runtime_put_noidle(dev);
360 pci_dev->driver = NULL;
363 /* Undo the runtime PM settings in local_pci_probe() */
364 pm_runtime_disable(dev);
365 pm_runtime_set_suspended(dev);
366 pm_runtime_put_noidle(dev);
369 * If the device is still on, set the power state as "unknown",
370 * since it might change by the next time we load the driver.
372 if (pci_dev->current_state == PCI_D0)
373 pci_dev->current_state = PCI_UNKNOWN;
376 * We would love to complain here if pci_dev->is_enabled is set, that
377 * the driver should have called pci_disable_device(), but the
378 * unfortunate fact is there are too many odd BIOS and bridge setups
379 * that don't like drivers doing that all of the time.
380 * Oh well, we can dream of sane hardware when we sleep, no matter how
381 * horrible the crap we have to deal with is when we are awake...
384 pci_dev_put(pci_dev);
388 static void pci_device_shutdown(struct device *dev)
390 struct pci_dev *pci_dev = to_pci_dev(dev);
391 struct pci_driver *drv = pci_dev->driver;
393 pm_runtime_resume(dev);
395 if (drv && drv->shutdown)
396 drv->shutdown(pci_dev);
397 pci_msi_shutdown(pci_dev);
398 pci_msix_shutdown(pci_dev);
401 * Turn off Bus Master bit on the device to tell it to not
404 pci_disable_device(pci_dev);
409 /* Auxiliary functions used for system resume and run-time resume. */
412 * pci_restore_standard_config - restore standard config registers of PCI device
413 * @pci_dev: PCI device to handle
415 static int pci_restore_standard_config(struct pci_dev *pci_dev)
417 pci_update_current_state(pci_dev, PCI_UNKNOWN);
419 if (pci_dev->current_state != PCI_D0) {
420 int error = pci_set_power_state(pci_dev, PCI_D0);
425 pci_restore_state(pci_dev);
431 #ifdef CONFIG_PM_SLEEP
433 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
435 pci_power_up(pci_dev);
436 pci_restore_state(pci_dev);
437 pci_fixup_device(pci_fixup_resume_early, pci_dev);
441 * Default "suspend" method for devices that have no driver provided suspend,
442 * or not even a driver at all (second part).
444 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
447 * mark its power state as "unknown", since we don't know if
448 * e.g. the BIOS will change its device state when we suspend.
450 if (pci_dev->current_state == PCI_D0)
451 pci_dev->current_state = PCI_UNKNOWN;
455 * Default "resume" method for devices that have no driver provided resume,
456 * or not even a driver at all (second part).
458 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
462 /* if the device was enabled before suspend, reenable */
463 retval = pci_reenable_device(pci_dev);
465 * if the device was busmaster before the suspend, make it busmaster
468 if (pci_dev->is_busmaster)
469 pci_set_master(pci_dev);
474 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
476 struct pci_dev * pci_dev = to_pci_dev(dev);
477 struct pci_driver * drv = pci_dev->driver;
479 if (drv && drv->suspend) {
480 pci_power_t prev = pci_dev->current_state;
483 error = drv->suspend(pci_dev, state);
484 suspend_report_result(drv->suspend, error);
488 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
489 && pci_dev->current_state != PCI_UNKNOWN) {
490 WARN_ONCE(pci_dev->current_state != prev,
491 "PCI PM: Device state not saved by %pF\n",
496 pci_fixup_device(pci_fixup_suspend, pci_dev);
501 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
503 struct pci_dev * pci_dev = to_pci_dev(dev);
504 struct pci_driver * drv = pci_dev->driver;
506 if (drv && drv->suspend_late) {
507 pci_power_t prev = pci_dev->current_state;
510 error = drv->suspend_late(pci_dev, state);
511 suspend_report_result(drv->suspend_late, error);
515 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
516 && pci_dev->current_state != PCI_UNKNOWN) {
517 WARN_ONCE(pci_dev->current_state != prev,
518 "PCI PM: Device state not saved by %pF\n",
524 if (!pci_dev->state_saved)
525 pci_save_state(pci_dev);
527 pci_pm_set_unknown_state(pci_dev);
532 static int pci_legacy_resume_early(struct device *dev)
534 struct pci_dev * pci_dev = to_pci_dev(dev);
535 struct pci_driver * drv = pci_dev->driver;
537 return drv && drv->resume_early ?
538 drv->resume_early(pci_dev) : 0;
541 static int pci_legacy_resume(struct device *dev)
543 struct pci_dev * pci_dev = to_pci_dev(dev);
544 struct pci_driver * drv = pci_dev->driver;
546 pci_fixup_device(pci_fixup_resume, pci_dev);
548 return drv && drv->resume ?
549 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
552 /* Auxiliary functions used by the new power management framework */
554 static void pci_pm_default_resume(struct pci_dev *pci_dev)
556 pci_fixup_device(pci_fixup_resume, pci_dev);
558 if (!pci_is_bridge(pci_dev))
559 pci_enable_wake(pci_dev, PCI_D0, false);
562 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
564 /* Disable non-bridge devices without PM support */
565 if (!pci_is_bridge(pci_dev))
566 pci_disable_enabled_device(pci_dev);
569 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
571 struct pci_driver *drv = pci_dev->driver;
572 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
573 || drv->resume_early);
576 * Legacy PM support is used by default, so warn if the new framework is
577 * supported as well. Drivers are supposed to support either the
578 * former, or the latter, but not both at the same time.
580 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
581 drv->name, pci_dev->vendor, pci_dev->device);
586 /* New power management framework */
588 static int pci_pm_prepare(struct device *dev)
590 struct device_driver *drv = dev->driver;
594 * PCI devices suspended at run time need to be resumed at this
595 * point, because in general it is necessary to reconfigure them for
596 * system suspend. Namely, if the device is supposed to wake up the
597 * system from the sleep state, we may need to reconfigure it for this
598 * purpose. In turn, if the device is not supposed to wake up the
599 * system from the sleep state, we'll have to prevent it from signaling
602 pm_runtime_resume(dev);
604 if (drv && drv->pm && drv->pm->prepare)
605 error = drv->pm->prepare(dev);
610 static void pci_pm_complete(struct device *dev)
612 struct device_driver *drv = dev->driver;
614 if (drv && drv->pm && drv->pm->complete)
615 drv->pm->complete(dev);
618 #else /* !CONFIG_PM_SLEEP */
620 #define pci_pm_prepare NULL
621 #define pci_pm_complete NULL
623 #endif /* !CONFIG_PM_SLEEP */
625 #ifdef CONFIG_SUSPEND
627 static int pci_pm_suspend(struct device *dev)
629 struct pci_dev *pci_dev = to_pci_dev(dev);
630 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
632 if (pci_has_legacy_pm_support(pci_dev))
633 return pci_legacy_suspend(dev, PMSG_SUSPEND);
636 pci_pm_default_suspend(pci_dev);
641 pci_power_t prev = pci_dev->current_state;
644 error = pm->suspend(dev);
645 suspend_report_result(pm->suspend, error);
649 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
650 && pci_dev->current_state != PCI_UNKNOWN) {
651 WARN_ONCE(pci_dev->current_state != prev,
652 "PCI PM: State of device not saved by %pF\n",
658 pci_fixup_device(pci_fixup_suspend, pci_dev);
663 static int pci_pm_suspend_noirq(struct device *dev)
665 struct pci_dev *pci_dev = to_pci_dev(dev);
666 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
668 if (pci_has_legacy_pm_support(pci_dev))
669 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
672 pci_save_state(pci_dev);
676 if (pm->suspend_noirq) {
677 pci_power_t prev = pci_dev->current_state;
680 error = pm->suspend_noirq(dev);
681 suspend_report_result(pm->suspend_noirq, error);
685 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
686 && pci_dev->current_state != PCI_UNKNOWN) {
687 WARN_ONCE(pci_dev->current_state != prev,
688 "PCI PM: State of device not saved by %pF\n",
694 if (!pci_dev->state_saved) {
695 pci_save_state(pci_dev);
696 if (!pci_is_bridge(pci_dev))
697 pci_prepare_to_sleep(pci_dev);
700 pci_pm_set_unknown_state(pci_dev);
703 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
704 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
705 * hasn't been quiesced and tries to turn it off. If the controller
706 * is already in D3, this can hang or cause memory corruption.
708 * Since the value of the COMMAND register doesn't matter once the
709 * device has been suspended, we can safely set it to 0 here.
711 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
712 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
717 static int pci_pm_resume_noirq(struct device *dev)
719 struct pci_dev *pci_dev = to_pci_dev(dev);
720 struct device_driver *drv = dev->driver;
723 pci_pm_default_resume_early(pci_dev);
725 if (pci_has_legacy_pm_support(pci_dev))
726 return pci_legacy_resume_early(dev);
728 if (drv && drv->pm && drv->pm->resume_noirq)
729 error = drv->pm->resume_noirq(dev);
734 static int pci_pm_resume(struct device *dev)
736 struct pci_dev *pci_dev = to_pci_dev(dev);
737 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
741 * This is necessary for the suspend error path in which resume is
742 * called without restoring the standard config registers of the device.
744 if (pci_dev->state_saved)
745 pci_restore_standard_config(pci_dev);
747 if (pci_has_legacy_pm_support(pci_dev))
748 return pci_legacy_resume(dev);
750 pci_pm_default_resume(pci_dev);
754 error = pm->resume(dev);
756 pci_pm_reenable_device(pci_dev);
762 #else /* !CONFIG_SUSPEND */
764 #define pci_pm_suspend NULL
765 #define pci_pm_suspend_noirq NULL
766 #define pci_pm_resume NULL
767 #define pci_pm_resume_noirq NULL
769 #endif /* !CONFIG_SUSPEND */
771 #ifdef CONFIG_HIBERNATE_CALLBACKS
773 static int pci_pm_freeze(struct device *dev)
775 struct pci_dev *pci_dev = to_pci_dev(dev);
776 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
778 if (pci_has_legacy_pm_support(pci_dev))
779 return pci_legacy_suspend(dev, PMSG_FREEZE);
782 pci_pm_default_suspend(pci_dev);
789 error = pm->freeze(dev);
790 suspend_report_result(pm->freeze, error);
798 static int pci_pm_freeze_noirq(struct device *dev)
800 struct pci_dev *pci_dev = to_pci_dev(dev);
801 struct device_driver *drv = dev->driver;
803 if (pci_has_legacy_pm_support(pci_dev))
804 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
806 if (drv && drv->pm && drv->pm->freeze_noirq) {
809 error = drv->pm->freeze_noirq(dev);
810 suspend_report_result(drv->pm->freeze_noirq, error);
815 if (!pci_dev->state_saved)
816 pci_save_state(pci_dev);
818 pci_pm_set_unknown_state(pci_dev);
823 static int pci_pm_thaw_noirq(struct device *dev)
825 struct pci_dev *pci_dev = to_pci_dev(dev);
826 struct device_driver *drv = dev->driver;
829 if (pci_has_legacy_pm_support(pci_dev))
830 return pci_legacy_resume_early(dev);
832 pci_update_current_state(pci_dev, PCI_D0);
834 if (drv && drv->pm && drv->pm->thaw_noirq)
835 error = drv->pm->thaw_noirq(dev);
840 static int pci_pm_thaw(struct device *dev)
842 struct pci_dev *pci_dev = to_pci_dev(dev);
843 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
846 if (pci_has_legacy_pm_support(pci_dev))
847 return pci_legacy_resume(dev);
851 error = pm->thaw(dev);
853 pci_pm_reenable_device(pci_dev);
856 pci_dev->state_saved = false;
861 static int pci_pm_poweroff(struct device *dev)
863 struct pci_dev *pci_dev = to_pci_dev(dev);
864 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
866 if (pci_has_legacy_pm_support(pci_dev))
867 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
870 pci_pm_default_suspend(pci_dev);
877 error = pm->poweroff(dev);
878 suspend_report_result(pm->poweroff, error);
884 pci_fixup_device(pci_fixup_suspend, pci_dev);
889 static int pci_pm_poweroff_noirq(struct device *dev)
891 struct pci_dev *pci_dev = to_pci_dev(dev);
892 struct device_driver *drv = dev->driver;
894 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
895 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
897 if (!drv || !drv->pm)
900 if (drv->pm->poweroff_noirq) {
903 error = drv->pm->poweroff_noirq(dev);
904 suspend_report_result(drv->pm->poweroff_noirq, error);
909 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
910 pci_prepare_to_sleep(pci_dev);
913 * The reason for doing this here is the same as for the analogous code
914 * in pci_pm_suspend_noirq().
916 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
917 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
922 static int pci_pm_restore_noirq(struct device *dev)
924 struct pci_dev *pci_dev = to_pci_dev(dev);
925 struct device_driver *drv = dev->driver;
928 pci_pm_default_resume_early(pci_dev);
930 if (pci_has_legacy_pm_support(pci_dev))
931 return pci_legacy_resume_early(dev);
933 if (drv && drv->pm && drv->pm->restore_noirq)
934 error = drv->pm->restore_noirq(dev);
939 static int pci_pm_restore(struct device *dev)
941 struct pci_dev *pci_dev = to_pci_dev(dev);
942 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
946 * This is necessary for the hibernation error path in which restore is
947 * called without restoring the standard config registers of the device.
949 if (pci_dev->state_saved)
950 pci_restore_standard_config(pci_dev);
952 if (pci_has_legacy_pm_support(pci_dev))
953 return pci_legacy_resume(dev);
955 pci_pm_default_resume(pci_dev);
959 error = pm->restore(dev);
961 pci_pm_reenable_device(pci_dev);
967 #else /* !CONFIG_HIBERNATE_CALLBACKS */
969 #define pci_pm_freeze NULL
970 #define pci_pm_freeze_noirq NULL
971 #define pci_pm_thaw NULL
972 #define pci_pm_thaw_noirq NULL
973 #define pci_pm_poweroff NULL
974 #define pci_pm_poweroff_noirq NULL
975 #define pci_pm_restore NULL
976 #define pci_pm_restore_noirq NULL
978 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
980 #ifdef CONFIG_PM_RUNTIME
982 static int pci_pm_runtime_suspend(struct device *dev)
984 struct pci_dev *pci_dev = to_pci_dev(dev);
985 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
986 pci_power_t prev = pci_dev->current_state;
989 if (!pm || !pm->runtime_suspend)
992 pci_dev->no_d3cold = false;
993 error = pm->runtime_suspend(dev);
994 suspend_report_result(pm->runtime_suspend, error);
997 if (!pci_dev->d3cold_allowed)
998 pci_dev->no_d3cold = true;
1000 pci_fixup_device(pci_fixup_suspend, pci_dev);
1002 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1003 && pci_dev->current_state != PCI_UNKNOWN) {
1004 WARN_ONCE(pci_dev->current_state != prev,
1005 "PCI PM: State of device not saved by %pF\n",
1006 pm->runtime_suspend);
1010 if (!pci_dev->state_saved)
1011 pci_save_state(pci_dev);
1013 pci_finish_runtime_suspend(pci_dev);
1018 static int pci_pm_runtime_resume(struct device *dev)
1021 struct pci_dev *pci_dev = to_pci_dev(dev);
1022 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1024 if (!pm || !pm->runtime_resume)
1027 pci_restore_standard_config(pci_dev);
1028 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1029 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1030 pci_fixup_device(pci_fixup_resume, pci_dev);
1032 rc = pm->runtime_resume(dev);
1034 pci_dev->runtime_d3cold = false;
1039 static int pci_pm_runtime_idle(struct device *dev)
1041 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1046 if (pm->runtime_idle) {
1047 int ret = pm->runtime_idle(dev);
1052 pm_runtime_suspend(dev);
1057 #else /* !CONFIG_PM_RUNTIME */
1059 #define pci_pm_runtime_suspend NULL
1060 #define pci_pm_runtime_resume NULL
1061 #define pci_pm_runtime_idle NULL
1063 #endif /* !CONFIG_PM_RUNTIME */
1067 const struct dev_pm_ops pci_dev_pm_ops = {
1068 .prepare = pci_pm_prepare,
1069 .complete = pci_pm_complete,
1070 .suspend = pci_pm_suspend,
1071 .resume = pci_pm_resume,
1072 .freeze = pci_pm_freeze,
1073 .thaw = pci_pm_thaw,
1074 .poweroff = pci_pm_poweroff,
1075 .restore = pci_pm_restore,
1076 .suspend_noirq = pci_pm_suspend_noirq,
1077 .resume_noirq = pci_pm_resume_noirq,
1078 .freeze_noirq = pci_pm_freeze_noirq,
1079 .thaw_noirq = pci_pm_thaw_noirq,
1080 .poweroff_noirq = pci_pm_poweroff_noirq,
1081 .restore_noirq = pci_pm_restore_noirq,
1082 .runtime_suspend = pci_pm_runtime_suspend,
1083 .runtime_resume = pci_pm_runtime_resume,
1084 .runtime_idle = pci_pm_runtime_idle,
1087 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1089 #else /* !COMFIG_PM_OPS */
1091 #define PCI_PM_OPS_PTR NULL
1093 #endif /* !COMFIG_PM_OPS */
1096 * __pci_register_driver - register a new pci driver
1097 * @drv: the driver structure to register
1098 * @owner: owner module of drv
1099 * @mod_name: module name string
1101 * Adds the driver structure to the list of registered drivers.
1102 * Returns a negative value on error, otherwise 0.
1103 * If no error occurred, the driver remains registered even if
1104 * no device was claimed during registration.
1106 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1107 const char *mod_name)
1109 /* initialize common driver fields */
1110 drv->driver.name = drv->name;
1111 drv->driver.bus = &pci_bus_type;
1112 drv->driver.owner = owner;
1113 drv->driver.mod_name = mod_name;
1115 spin_lock_init(&drv->dynids.lock);
1116 INIT_LIST_HEAD(&drv->dynids.list);
1118 /* register with core */
1119 return driver_register(&drv->driver);
1123 * pci_unregister_driver - unregister a pci driver
1124 * @drv: the driver structure to unregister
1126 * Deletes the driver structure from the list of registered PCI drivers,
1127 * gives it a chance to clean up by calling its remove() function for
1128 * each device it was responsible for, and marks those devices as
1133 pci_unregister_driver(struct pci_driver *drv)
1135 driver_unregister(&drv->driver);
1136 pci_free_dynids(drv);
1139 static struct pci_driver pci_compat_driver = {
1144 * pci_dev_driver - get the pci_driver of a device
1145 * @dev: the device to query
1147 * Returns the appropriate pci_driver structure or %NULL if there is no
1148 * registered driver for the device.
1151 pci_dev_driver(const struct pci_dev *dev)
1157 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1158 if (dev->resource[i].flags & IORESOURCE_BUSY)
1159 return &pci_compat_driver;
1165 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1166 * @dev: the PCI device structure to match against
1167 * @drv: the device driver to search for matching PCI device id structures
1169 * Used by a driver to check whether a PCI device present in the
1170 * system is in its list of supported devices. Returns the matching
1171 * pci_device_id structure or %NULL if there is no match.
1173 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1175 struct pci_dev *pci_dev = to_pci_dev(dev);
1176 struct pci_driver *pci_drv = to_pci_driver(drv);
1177 const struct pci_device_id *found_id;
1179 found_id = pci_match_device(pci_drv, pci_dev);
1187 * pci_dev_get - increments the reference count of the pci device structure
1188 * @dev: the device being referenced
1190 * Each live reference to a device should be refcounted.
1192 * Drivers for PCI devices should normally record such references in
1193 * their probe() methods, when they bind to a device, and release
1194 * them by calling pci_dev_put(), in their disconnect() methods.
1196 * A pointer to the device with the incremented reference counter is returned.
1198 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1201 get_device(&dev->dev);
1206 * pci_dev_put - release a use of the pci device structure
1207 * @dev: device that's been disconnected
1209 * Must be called when a user of a device is finished with it. When the last
1210 * user of the device calls this function, the memory of the device is freed.
1212 void pci_dev_put(struct pci_dev *dev)
1215 put_device(&dev->dev);
1218 static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1220 struct pci_dev *pdev;
1225 pdev = to_pci_dev(dev);
1229 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1232 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1235 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1236 pdev->subsystem_device))
1239 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1242 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
1243 pdev->vendor, pdev->device,
1244 pdev->subsystem_vendor, pdev->subsystem_device,
1245 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1251 struct bus_type pci_bus_type = {
1253 .match = pci_bus_match,
1254 .uevent = pci_uevent,
1255 .probe = pci_device_probe,
1256 .remove = pci_device_remove,
1257 .shutdown = pci_device_shutdown,
1258 .dev_attrs = pci_dev_attrs,
1259 .bus_attrs = pci_bus_attrs,
1260 .drv_attrs = pci_drv_attrs,
1261 .pm = PCI_PM_OPS_PTR,
1264 static int __init pci_driver_init(void)
1266 return bus_register(&pci_bus_type);
1269 postcore_initcall(pci_driver_init);
1271 EXPORT_SYMBOL_GPL(pci_add_dynid);
1272 EXPORT_SYMBOL(pci_match_id);
1273 EXPORT_SYMBOL(__pci_register_driver);
1274 EXPORT_SYMBOL(pci_unregister_driver);
1275 EXPORT_SYMBOL(pci_dev_driver);
1276 EXPORT_SYMBOL(pci_bus_type);
1277 EXPORT_SYMBOL(pci_dev_get);
1278 EXPORT_SYMBOL(pci_dev_put);