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 * Dynamic device ID manipulation via sysfs is disabled for !CONFIG_HOTPLUG
97 * store_new_id - sysfs frontend to pci_add_dynid()
98 * @driver: target device driver
99 * @buf: buffer for scanning device ID data
102 * Allow PCI IDs to be added to an existing driver via sysfs.
105 store_new_id(struct device_driver *driver, const char *buf, size_t count)
107 struct pci_driver *pdrv = to_pci_driver(driver);
108 const struct pci_device_id *ids = pdrv->id_table;
109 __u32 vendor, device, subvendor=PCI_ANY_ID,
110 subdevice=PCI_ANY_ID, class=0, class_mask=0;
111 unsigned long driver_data=0;
115 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
116 &vendor, &device, &subvendor, &subdevice,
117 &class, &class_mask, &driver_data);
121 /* Only accept driver_data values that match an existing id_table
125 while (ids->vendor || ids->subvendor || ids->class_mask) {
126 if (driver_data == ids->driver_data) {
132 if (retval) /* No match */
136 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
137 class, class_mask, driver_data);
144 * store_remove_id - remove a PCI device ID from this driver
145 * @driver: target device driver
146 * @buf: buffer for scanning device ID data
149 * Removes a dynamic pci device ID to this driver.
152 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
154 struct pci_dynid *dynid, *n;
155 struct pci_driver *pdrv = to_pci_driver(driver);
156 __u32 vendor, device, subvendor = PCI_ANY_ID,
157 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
159 int retval = -ENODEV;
161 fields = sscanf(buf, "%x %x %x %x %x %x",
162 &vendor, &device, &subvendor, &subdevice,
163 &class, &class_mask);
167 spin_lock(&pdrv->dynids.lock);
168 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
169 struct pci_device_id *id = &dynid->id;
170 if ((id->vendor == vendor) &&
171 (id->device == device) &&
172 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
173 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
174 !((id->class ^ class) & class_mask)) {
175 list_del(&dynid->node);
181 spin_unlock(&pdrv->dynids.lock);
188 static struct driver_attribute pci_drv_attrs[] = {
189 __ATTR(new_id, S_IWUSR, NULL, store_new_id),
190 __ATTR(remove_id, S_IWUSR, NULL, store_remove_id),
195 #define pci_drv_attrs NULL
196 #endif /* CONFIG_HOTPLUG */
199 * pci_match_id - See if a pci device matches a given pci_id table
200 * @ids: array of PCI device id structures to search in
201 * @dev: the PCI device structure to match against.
203 * Used by a driver to check whether a PCI device present in the
204 * system is in its list of supported devices. Returns the matching
205 * pci_device_id structure or %NULL if there is no match.
207 * Deprecated, don't use this as it will not catch any dynamic ids
208 * that a driver might want to check for.
210 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
214 while (ids->vendor || ids->subvendor || ids->class_mask) {
215 if (pci_match_one_device(ids, dev))
224 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
225 * @drv: the PCI driver to match against
226 * @dev: the PCI device structure to match against
228 * Used by a driver to check whether a PCI device present in the
229 * system is in its list of supported devices. Returns the matching
230 * pci_device_id structure or %NULL if there is no match.
232 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
235 struct pci_dynid *dynid;
237 /* Look at the dynamic ids first, before the static ones */
238 spin_lock(&drv->dynids.lock);
239 list_for_each_entry(dynid, &drv->dynids.list, node) {
240 if (pci_match_one_device(&dynid->id, dev)) {
241 spin_unlock(&drv->dynids.lock);
245 spin_unlock(&drv->dynids.lock);
247 return pci_match_id(drv->id_table, dev);
250 struct drv_dev_and_id {
251 struct pci_driver *drv;
253 const struct pci_device_id *id;
256 static long local_pci_probe(void *_ddi)
258 struct drv_dev_and_id *ddi = _ddi;
259 struct device *dev = &ddi->dev->dev;
260 struct device *parent = dev->parent;
263 /* The parent bridge must be in active state when probing */
265 pm_runtime_get_sync(parent);
266 /* Unbound PCI devices are always set to disabled and suspended.
267 * During probe, the device is set to enabled and active and the
268 * usage count is incremented. If the driver supports runtime PM,
269 * it should call pm_runtime_put_noidle() in its probe routine and
270 * pm_runtime_get_noresume() in its remove routine.
272 pm_runtime_get_noresume(dev);
273 pm_runtime_set_active(dev);
274 pm_runtime_enable(dev);
276 rc = ddi->drv->probe(ddi->dev, ddi->id);
278 pm_runtime_disable(dev);
279 pm_runtime_set_suspended(dev);
280 pm_runtime_put_noidle(dev);
283 pm_runtime_put(parent);
287 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
288 const struct pci_device_id *id)
291 struct drv_dev_and_id ddi = { drv, dev, id };
293 /* Execute driver initialization on node where the device's
294 bus is attached to. This way the driver likely allocates
295 its local memory on the right node without any need to
297 node = dev_to_node(&dev->dev);
302 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
303 if (cpu < nr_cpu_ids)
304 error = work_on_cpu(cpu, local_pci_probe, &ddi);
306 error = local_pci_probe(&ddi);
309 error = local_pci_probe(&ddi);
314 * __pci_device_probe - check if a driver wants to claim a specific PCI device
315 * @drv: driver to call to check if it wants the PCI device
316 * @pci_dev: PCI device being probed
318 * returns 0 on success, else error.
319 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
322 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
324 const struct pci_device_id *id;
327 if (!pci_dev->driver && drv->probe) {
330 id = pci_match_device(drv, pci_dev);
332 error = pci_call_probe(drv, pci_dev, id);
334 pci_dev->driver = drv;
341 static int pci_device_probe(struct device * dev)
344 struct pci_driver *drv;
345 struct pci_dev *pci_dev;
347 drv = to_pci_driver(dev->driver);
348 pci_dev = to_pci_dev(dev);
349 pci_dev_get(pci_dev);
350 error = __pci_device_probe(drv, pci_dev);
352 pci_dev_put(pci_dev);
357 static int pci_device_remove(struct device * dev)
359 struct pci_dev * pci_dev = to_pci_dev(dev);
360 struct pci_driver * drv = pci_dev->driver;
364 pm_runtime_get_sync(dev);
365 drv->remove(pci_dev);
366 pm_runtime_put_noidle(dev);
368 pci_dev->driver = NULL;
371 /* Undo the runtime PM settings in local_pci_probe() */
372 pm_runtime_disable(dev);
373 pm_runtime_set_suspended(dev);
374 pm_runtime_put_noidle(dev);
377 * If the device is still on, set the power state as "unknown",
378 * since it might change by the next time we load the driver.
380 if (pci_dev->current_state == PCI_D0)
381 pci_dev->current_state = PCI_UNKNOWN;
384 * We would love to complain here if pci_dev->is_enabled is set, that
385 * the driver should have called pci_disable_device(), but the
386 * unfortunate fact is there are too many odd BIOS and bridge setups
387 * that don't like drivers doing that all of the time.
388 * Oh well, we can dream of sane hardware when we sleep, no matter how
389 * horrible the crap we have to deal with is when we are awake...
392 pci_dev_put(pci_dev);
396 static void pci_device_shutdown(struct device *dev)
398 struct pci_dev *pci_dev = to_pci_dev(dev);
399 struct pci_driver *drv = pci_dev->driver;
401 pm_runtime_resume(dev);
403 if (drv && drv->shutdown)
404 drv->shutdown(pci_dev);
405 pci_msi_shutdown(pci_dev);
406 pci_msix_shutdown(pci_dev);
409 * Turn off Bus Master bit on the device to tell it to not
412 pci_disable_device(pci_dev);
417 /* Auxiliary functions used for system resume and run-time resume. */
420 * pci_restore_standard_config - restore standard config registers of PCI device
421 * @pci_dev: PCI device to handle
423 static int pci_restore_standard_config(struct pci_dev *pci_dev)
425 pci_update_current_state(pci_dev, PCI_UNKNOWN);
427 if (pci_dev->current_state != PCI_D0) {
428 int error = pci_set_power_state(pci_dev, PCI_D0);
433 pci_restore_state(pci_dev);
439 #ifdef CONFIG_PM_SLEEP
441 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
443 pci_power_up(pci_dev);
444 pci_restore_state(pci_dev);
445 pci_fixup_device(pci_fixup_resume_early, pci_dev);
449 * Default "suspend" method for devices that have no driver provided suspend,
450 * or not even a driver at all (second part).
452 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
455 * mark its power state as "unknown", since we don't know if
456 * e.g. the BIOS will change its device state when we suspend.
458 if (pci_dev->current_state == PCI_D0)
459 pci_dev->current_state = PCI_UNKNOWN;
463 * Default "resume" method for devices that have no driver provided resume,
464 * or not even a driver at all (second part).
466 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
470 /* if the device was enabled before suspend, reenable */
471 retval = pci_reenable_device(pci_dev);
473 * if the device was busmaster before the suspend, make it busmaster
476 if (pci_dev->is_busmaster)
477 pci_set_master(pci_dev);
482 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
484 struct pci_dev * pci_dev = to_pci_dev(dev);
485 struct pci_driver * drv = pci_dev->driver;
487 if (drv && drv->suspend) {
488 pci_power_t prev = pci_dev->current_state;
491 error = drv->suspend(pci_dev, state);
492 suspend_report_result(drv->suspend, error);
496 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
497 && pci_dev->current_state != PCI_UNKNOWN) {
498 WARN_ONCE(pci_dev->current_state != prev,
499 "PCI PM: Device state not saved by %pF\n",
504 pci_fixup_device(pci_fixup_suspend, pci_dev);
509 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
511 struct pci_dev * pci_dev = to_pci_dev(dev);
512 struct pci_driver * drv = pci_dev->driver;
514 if (drv && drv->suspend_late) {
515 pci_power_t prev = pci_dev->current_state;
518 error = drv->suspend_late(pci_dev, state);
519 suspend_report_result(drv->suspend_late, error);
523 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
524 && pci_dev->current_state != PCI_UNKNOWN) {
525 WARN_ONCE(pci_dev->current_state != prev,
526 "PCI PM: Device state not saved by %pF\n",
532 if (!pci_dev->state_saved)
533 pci_save_state(pci_dev);
535 pci_pm_set_unknown_state(pci_dev);
540 static int pci_legacy_resume_early(struct device *dev)
542 struct pci_dev * pci_dev = to_pci_dev(dev);
543 struct pci_driver * drv = pci_dev->driver;
545 return drv && drv->resume_early ?
546 drv->resume_early(pci_dev) : 0;
549 static int pci_legacy_resume(struct device *dev)
551 struct pci_dev * pci_dev = to_pci_dev(dev);
552 struct pci_driver * drv = pci_dev->driver;
554 pci_fixup_device(pci_fixup_resume, pci_dev);
556 return drv && drv->resume ?
557 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
560 /* Auxiliary functions used by the new power management framework */
562 static void pci_pm_default_resume(struct pci_dev *pci_dev)
564 pci_fixup_device(pci_fixup_resume, pci_dev);
566 if (!pci_is_bridge(pci_dev))
567 pci_enable_wake(pci_dev, PCI_D0, false);
570 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
572 /* Disable non-bridge devices without PM support */
573 if (!pci_is_bridge(pci_dev))
574 pci_disable_enabled_device(pci_dev);
577 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
579 struct pci_driver *drv = pci_dev->driver;
580 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
581 || drv->resume_early);
584 * Legacy PM support is used by default, so warn if the new framework is
585 * supported as well. Drivers are supposed to support either the
586 * former, or the latter, but not both at the same time.
588 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
589 drv->name, pci_dev->vendor, pci_dev->device);
594 /* New power management framework */
596 static int pci_pm_prepare(struct device *dev)
598 struct device_driver *drv = dev->driver;
602 * PCI devices suspended at run time need to be resumed at this
603 * point, because in general it is necessary to reconfigure them for
604 * system suspend. Namely, if the device is supposed to wake up the
605 * system from the sleep state, we may need to reconfigure it for this
606 * purpose. In turn, if the device is not supposed to wake up the
607 * system from the sleep state, we'll have to prevent it from signaling
610 pm_runtime_resume(dev);
612 if (drv && drv->pm && drv->pm->prepare)
613 error = drv->pm->prepare(dev);
618 static void pci_pm_complete(struct device *dev)
620 struct device_driver *drv = dev->driver;
622 if (drv && drv->pm && drv->pm->complete)
623 drv->pm->complete(dev);
626 #else /* !CONFIG_PM_SLEEP */
628 #define pci_pm_prepare NULL
629 #define pci_pm_complete NULL
631 #endif /* !CONFIG_PM_SLEEP */
633 #ifdef CONFIG_SUSPEND
635 static int pci_pm_suspend(struct device *dev)
637 struct pci_dev *pci_dev = to_pci_dev(dev);
638 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
640 if (pci_has_legacy_pm_support(pci_dev))
641 return pci_legacy_suspend(dev, PMSG_SUSPEND);
644 pci_pm_default_suspend(pci_dev);
649 pci_power_t prev = pci_dev->current_state;
652 error = pm->suspend(dev);
653 suspend_report_result(pm->suspend, error);
657 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
658 && pci_dev->current_state != PCI_UNKNOWN) {
659 WARN_ONCE(pci_dev->current_state != prev,
660 "PCI PM: State of device not saved by %pF\n",
666 pci_fixup_device(pci_fixup_suspend, pci_dev);
671 static int pci_pm_suspend_noirq(struct device *dev)
673 struct pci_dev *pci_dev = to_pci_dev(dev);
674 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
676 if (pci_has_legacy_pm_support(pci_dev))
677 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
680 pci_save_state(pci_dev);
684 if (pm->suspend_noirq) {
685 pci_power_t prev = pci_dev->current_state;
688 error = pm->suspend_noirq(dev);
689 suspend_report_result(pm->suspend_noirq, error);
693 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
694 && pci_dev->current_state != PCI_UNKNOWN) {
695 WARN_ONCE(pci_dev->current_state != prev,
696 "PCI PM: State of device not saved by %pF\n",
702 if (!pci_dev->state_saved) {
703 pci_save_state(pci_dev);
704 if (!pci_is_bridge(pci_dev))
705 pci_prepare_to_sleep(pci_dev);
708 pci_pm_set_unknown_state(pci_dev);
711 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
712 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
713 * hasn't been quiesced and tries to turn it off. If the controller
714 * is already in D3, this can hang or cause memory corruption.
716 * Since the value of the COMMAND register doesn't matter once the
717 * device has been suspended, we can safely set it to 0 here.
719 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
720 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
725 static int pci_pm_resume_noirq(struct device *dev)
727 struct pci_dev *pci_dev = to_pci_dev(dev);
728 struct device_driver *drv = dev->driver;
731 pci_pm_default_resume_early(pci_dev);
733 if (pci_has_legacy_pm_support(pci_dev))
734 return pci_legacy_resume_early(dev);
736 if (drv && drv->pm && drv->pm->resume_noirq)
737 error = drv->pm->resume_noirq(dev);
742 static int pci_pm_resume(struct device *dev)
744 struct pci_dev *pci_dev = to_pci_dev(dev);
745 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
749 * This is necessary for the suspend error path in which resume is
750 * called without restoring the standard config registers of the device.
752 if (pci_dev->state_saved)
753 pci_restore_standard_config(pci_dev);
755 if (pci_has_legacy_pm_support(pci_dev))
756 return pci_legacy_resume(dev);
758 pci_pm_default_resume(pci_dev);
762 error = pm->resume(dev);
764 pci_pm_reenable_device(pci_dev);
770 #else /* !CONFIG_SUSPEND */
772 #define pci_pm_suspend NULL
773 #define pci_pm_suspend_noirq NULL
774 #define pci_pm_resume NULL
775 #define pci_pm_resume_noirq NULL
777 #endif /* !CONFIG_SUSPEND */
779 #ifdef CONFIG_HIBERNATE_CALLBACKS
781 static int pci_pm_freeze(struct device *dev)
783 struct pci_dev *pci_dev = to_pci_dev(dev);
784 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
786 if (pci_has_legacy_pm_support(pci_dev))
787 return pci_legacy_suspend(dev, PMSG_FREEZE);
790 pci_pm_default_suspend(pci_dev);
797 error = pm->freeze(dev);
798 suspend_report_result(pm->freeze, error);
806 static int pci_pm_freeze_noirq(struct device *dev)
808 struct pci_dev *pci_dev = to_pci_dev(dev);
809 struct device_driver *drv = dev->driver;
811 if (pci_has_legacy_pm_support(pci_dev))
812 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
814 if (drv && drv->pm && drv->pm->freeze_noirq) {
817 error = drv->pm->freeze_noirq(dev);
818 suspend_report_result(drv->pm->freeze_noirq, error);
823 if (!pci_dev->state_saved)
824 pci_save_state(pci_dev);
826 pci_pm_set_unknown_state(pci_dev);
831 static int pci_pm_thaw_noirq(struct device *dev)
833 struct pci_dev *pci_dev = to_pci_dev(dev);
834 struct device_driver *drv = dev->driver;
837 if (pci_has_legacy_pm_support(pci_dev))
838 return pci_legacy_resume_early(dev);
840 pci_update_current_state(pci_dev, PCI_D0);
842 if (drv && drv->pm && drv->pm->thaw_noirq)
843 error = drv->pm->thaw_noirq(dev);
848 static int pci_pm_thaw(struct device *dev)
850 struct pci_dev *pci_dev = to_pci_dev(dev);
851 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
854 if (pci_has_legacy_pm_support(pci_dev))
855 return pci_legacy_resume(dev);
859 error = pm->thaw(dev);
861 pci_pm_reenable_device(pci_dev);
864 pci_dev->state_saved = false;
869 static int pci_pm_poweroff(struct device *dev)
871 struct pci_dev *pci_dev = to_pci_dev(dev);
872 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
874 if (pci_has_legacy_pm_support(pci_dev))
875 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
878 pci_pm_default_suspend(pci_dev);
885 error = pm->poweroff(dev);
886 suspend_report_result(pm->poweroff, error);
892 pci_fixup_device(pci_fixup_suspend, pci_dev);
897 static int pci_pm_poweroff_noirq(struct device *dev)
899 struct pci_dev *pci_dev = to_pci_dev(dev);
900 struct device_driver *drv = dev->driver;
902 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
903 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
905 if (!drv || !drv->pm)
908 if (drv->pm->poweroff_noirq) {
911 error = drv->pm->poweroff_noirq(dev);
912 suspend_report_result(drv->pm->poweroff_noirq, error);
917 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
918 pci_prepare_to_sleep(pci_dev);
921 * The reason for doing this here is the same as for the analogous code
922 * in pci_pm_suspend_noirq().
924 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
925 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
930 static int pci_pm_restore_noirq(struct device *dev)
932 struct pci_dev *pci_dev = to_pci_dev(dev);
933 struct device_driver *drv = dev->driver;
936 pci_pm_default_resume_early(pci_dev);
938 if (pci_has_legacy_pm_support(pci_dev))
939 return pci_legacy_resume_early(dev);
941 if (drv && drv->pm && drv->pm->restore_noirq)
942 error = drv->pm->restore_noirq(dev);
947 static int pci_pm_restore(struct device *dev)
949 struct pci_dev *pci_dev = to_pci_dev(dev);
950 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
954 * This is necessary for the hibernation error path in which restore is
955 * called without restoring the standard config registers of the device.
957 if (pci_dev->state_saved)
958 pci_restore_standard_config(pci_dev);
960 if (pci_has_legacy_pm_support(pci_dev))
961 return pci_legacy_resume(dev);
963 pci_pm_default_resume(pci_dev);
967 error = pm->restore(dev);
969 pci_pm_reenable_device(pci_dev);
975 #else /* !CONFIG_HIBERNATE_CALLBACKS */
977 #define pci_pm_freeze NULL
978 #define pci_pm_freeze_noirq NULL
979 #define pci_pm_thaw NULL
980 #define pci_pm_thaw_noirq NULL
981 #define pci_pm_poweroff NULL
982 #define pci_pm_poweroff_noirq NULL
983 #define pci_pm_restore NULL
984 #define pci_pm_restore_noirq NULL
986 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
988 #ifdef CONFIG_PM_RUNTIME
990 static int pci_pm_runtime_suspend(struct device *dev)
992 struct pci_dev *pci_dev = to_pci_dev(dev);
993 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
994 pci_power_t prev = pci_dev->current_state;
997 if (!pm || !pm->runtime_suspend)
1000 pci_dev->no_d3cold = false;
1001 error = pm->runtime_suspend(dev);
1002 suspend_report_result(pm->runtime_suspend, error);
1005 if (!pci_dev->d3cold_allowed)
1006 pci_dev->no_d3cold = true;
1008 pci_fixup_device(pci_fixup_suspend, pci_dev);
1010 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1011 && pci_dev->current_state != PCI_UNKNOWN) {
1012 WARN_ONCE(pci_dev->current_state != prev,
1013 "PCI PM: State of device not saved by %pF\n",
1014 pm->runtime_suspend);
1018 if (!pci_dev->state_saved)
1019 pci_save_state(pci_dev);
1021 pci_finish_runtime_suspend(pci_dev);
1026 static int pci_pm_runtime_resume(struct device *dev)
1029 struct pci_dev *pci_dev = to_pci_dev(dev);
1030 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1032 if (!pm || !pm->runtime_resume)
1035 pci_restore_standard_config(pci_dev);
1036 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1037 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1038 pci_fixup_device(pci_fixup_resume, pci_dev);
1040 rc = pm->runtime_resume(dev);
1042 pci_dev->runtime_d3cold = false;
1047 static int pci_pm_runtime_idle(struct device *dev)
1049 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1054 if (pm->runtime_idle) {
1055 int ret = pm->runtime_idle(dev);
1060 pm_runtime_suspend(dev);
1065 #else /* !CONFIG_PM_RUNTIME */
1067 #define pci_pm_runtime_suspend NULL
1068 #define pci_pm_runtime_resume NULL
1069 #define pci_pm_runtime_idle NULL
1071 #endif /* !CONFIG_PM_RUNTIME */
1075 const struct dev_pm_ops pci_dev_pm_ops = {
1076 .prepare = pci_pm_prepare,
1077 .complete = pci_pm_complete,
1078 .suspend = pci_pm_suspend,
1079 .resume = pci_pm_resume,
1080 .freeze = pci_pm_freeze,
1081 .thaw = pci_pm_thaw,
1082 .poweroff = pci_pm_poweroff,
1083 .restore = pci_pm_restore,
1084 .suspend_noirq = pci_pm_suspend_noirq,
1085 .resume_noirq = pci_pm_resume_noirq,
1086 .freeze_noirq = pci_pm_freeze_noirq,
1087 .thaw_noirq = pci_pm_thaw_noirq,
1088 .poweroff_noirq = pci_pm_poweroff_noirq,
1089 .restore_noirq = pci_pm_restore_noirq,
1090 .runtime_suspend = pci_pm_runtime_suspend,
1091 .runtime_resume = pci_pm_runtime_resume,
1092 .runtime_idle = pci_pm_runtime_idle,
1095 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1097 #else /* !COMFIG_PM_OPS */
1099 #define PCI_PM_OPS_PTR NULL
1101 #endif /* !COMFIG_PM_OPS */
1104 * __pci_register_driver - register a new pci driver
1105 * @drv: the driver structure to register
1106 * @owner: owner module of drv
1107 * @mod_name: module name string
1109 * Adds the driver structure to the list of registered drivers.
1110 * Returns a negative value on error, otherwise 0.
1111 * If no error occurred, the driver remains registered even if
1112 * no device was claimed during registration.
1114 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1115 const char *mod_name)
1117 /* initialize common driver fields */
1118 drv->driver.name = drv->name;
1119 drv->driver.bus = &pci_bus_type;
1120 drv->driver.owner = owner;
1121 drv->driver.mod_name = mod_name;
1123 spin_lock_init(&drv->dynids.lock);
1124 INIT_LIST_HEAD(&drv->dynids.list);
1126 /* register with core */
1127 return driver_register(&drv->driver);
1131 * pci_unregister_driver - unregister a pci driver
1132 * @drv: the driver structure to unregister
1134 * Deletes the driver structure from the list of registered PCI drivers,
1135 * gives it a chance to clean up by calling its remove() function for
1136 * each device it was responsible for, and marks those devices as
1141 pci_unregister_driver(struct pci_driver *drv)
1143 driver_unregister(&drv->driver);
1144 pci_free_dynids(drv);
1147 static struct pci_driver pci_compat_driver = {
1152 * pci_dev_driver - get the pci_driver of a device
1153 * @dev: the device to query
1155 * Returns the appropriate pci_driver structure or %NULL if there is no
1156 * registered driver for the device.
1159 pci_dev_driver(const struct pci_dev *dev)
1165 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1166 if (dev->resource[i].flags & IORESOURCE_BUSY)
1167 return &pci_compat_driver;
1173 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1174 * @dev: the PCI device structure to match against
1175 * @drv: the device driver to search for matching PCI device id structures
1177 * Used by a driver to check whether a PCI device present in the
1178 * system is in its list of supported devices. Returns the matching
1179 * pci_device_id structure or %NULL if there is no match.
1181 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1183 struct pci_dev *pci_dev = to_pci_dev(dev);
1184 struct pci_driver *pci_drv = to_pci_driver(drv);
1185 const struct pci_device_id *found_id;
1187 found_id = pci_match_device(pci_drv, pci_dev);
1195 * pci_dev_get - increments the reference count of the pci device structure
1196 * @dev: the device being referenced
1198 * Each live reference to a device should be refcounted.
1200 * Drivers for PCI devices should normally record such references in
1201 * their probe() methods, when they bind to a device, and release
1202 * them by calling pci_dev_put(), in their disconnect() methods.
1204 * A pointer to the device with the incremented reference counter is returned.
1206 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1209 get_device(&dev->dev);
1214 * pci_dev_put - release a use of the pci device structure
1215 * @dev: device that's been disconnected
1217 * Must be called when a user of a device is finished with it. When the last
1218 * user of the device calls this function, the memory of the device is freed.
1220 void pci_dev_put(struct pci_dev *dev)
1223 put_device(&dev->dev);
1226 #ifndef CONFIG_HOTPLUG
1227 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1233 struct bus_type pci_bus_type = {
1235 .match = pci_bus_match,
1236 .uevent = pci_uevent,
1237 .probe = pci_device_probe,
1238 .remove = pci_device_remove,
1239 .shutdown = pci_device_shutdown,
1240 .dev_attrs = pci_dev_attrs,
1241 .bus_attrs = pci_bus_attrs,
1242 .drv_attrs = pci_drv_attrs,
1243 .pm = PCI_PM_OPS_PTR,
1246 static int __init pci_driver_init(void)
1248 return bus_register(&pci_bus_type);
1251 postcore_initcall(pci_driver_init);
1253 EXPORT_SYMBOL_GPL(pci_add_dynid);
1254 EXPORT_SYMBOL(pci_match_id);
1255 EXPORT_SYMBOL(__pci_register_driver);
1256 EXPORT_SYMBOL(pci_unregister_driver);
1257 EXPORT_SYMBOL(pci_dev_driver);
1258 EXPORT_SYMBOL(pci_bus_type);
1259 EXPORT_SYMBOL(pci_dev_get);
1260 EXPORT_SYMBOL(pci_dev_put);