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);
142 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
145 * store_remove_id - remove a PCI device ID from this driver
146 * @driver: target device driver
147 * @buf: buffer for scanning device ID data
150 * Removes a dynamic pci device ID to this driver.
153 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
155 struct pci_dynid *dynid, *n;
156 struct pci_driver *pdrv = to_pci_driver(driver);
157 __u32 vendor, device, subvendor = PCI_ANY_ID,
158 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
160 int retval = -ENODEV;
162 fields = sscanf(buf, "%x %x %x %x %x %x",
163 &vendor, &device, &subvendor, &subdevice,
164 &class, &class_mask);
168 spin_lock(&pdrv->dynids.lock);
169 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
170 struct pci_device_id *id = &dynid->id;
171 if ((id->vendor == vendor) &&
172 (id->device == device) &&
173 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
174 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
175 !((id->class ^ class) & class_mask)) {
176 list_del(&dynid->node);
182 spin_unlock(&pdrv->dynids.lock);
188 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
191 pci_create_newid_files(struct pci_driver *drv)
195 if (drv->probe != NULL) {
196 error = driver_create_file(&drv->driver, &driver_attr_new_id);
198 error = driver_create_file(&drv->driver,
199 &driver_attr_remove_id);
201 driver_remove_file(&drv->driver,
202 &driver_attr_new_id);
208 static void pci_remove_newid_files(struct pci_driver *drv)
210 driver_remove_file(&drv->driver, &driver_attr_remove_id);
211 driver_remove_file(&drv->driver, &driver_attr_new_id);
213 #else /* !CONFIG_HOTPLUG */
214 static inline int pci_create_newid_files(struct pci_driver *drv)
218 static inline void pci_remove_newid_files(struct pci_driver *drv) {}
222 * pci_match_id - See if a pci device matches a given pci_id table
223 * @ids: array of PCI device id structures to search in
224 * @dev: the PCI device structure to match against.
226 * Used by a driver to check whether a PCI device present in the
227 * system is in its list of supported devices. Returns the matching
228 * pci_device_id structure or %NULL if there is no match.
230 * Deprecated, don't use this as it will not catch any dynamic ids
231 * that a driver might want to check for.
233 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
237 while (ids->vendor || ids->subvendor || ids->class_mask) {
238 if (pci_match_one_device(ids, dev))
247 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
248 * @drv: the PCI driver to match against
249 * @dev: the PCI device structure to match against
251 * Used by a driver to check whether a PCI device present in the
252 * system is in its list of supported devices. Returns the matching
253 * pci_device_id structure or %NULL if there is no match.
255 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
258 struct pci_dynid *dynid;
260 /* Look at the dynamic ids first, before the static ones */
261 spin_lock(&drv->dynids.lock);
262 list_for_each_entry(dynid, &drv->dynids.list, node) {
263 if (pci_match_one_device(&dynid->id, dev)) {
264 spin_unlock(&drv->dynids.lock);
268 spin_unlock(&drv->dynids.lock);
270 return pci_match_id(drv->id_table, dev);
273 struct drv_dev_and_id {
274 struct pci_driver *drv;
276 const struct pci_device_id *id;
279 static long local_pci_probe(void *_ddi)
281 struct drv_dev_and_id *ddi = _ddi;
282 struct device *dev = &ddi->dev->dev;
283 struct device *parent = dev->parent;
286 /* The parent bridge must be in active state when probing */
288 pm_runtime_get_sync(parent);
289 /* Unbound PCI devices are always set to disabled and suspended.
290 * During probe, the device is set to enabled and active and the
291 * usage count is incremented. If the driver supports runtime PM,
292 * it should call pm_runtime_put_noidle() in its probe routine and
293 * pm_runtime_get_noresume() in its remove routine.
295 pm_runtime_get_noresume(dev);
296 pm_runtime_set_active(dev);
297 pm_runtime_enable(dev);
299 rc = ddi->drv->probe(ddi->dev, ddi->id);
301 pm_runtime_disable(dev);
302 pm_runtime_set_suspended(dev);
303 pm_runtime_put_noidle(dev);
306 pm_runtime_put(parent);
310 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
311 const struct pci_device_id *id)
314 struct drv_dev_and_id ddi = { drv, dev, id };
316 /* Execute driver initialization on node where the device's
317 bus is attached to. This way the driver likely allocates
318 its local memory on the right node without any need to
320 node = dev_to_node(&dev->dev);
325 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
326 if (cpu < nr_cpu_ids)
327 error = work_on_cpu(cpu, local_pci_probe, &ddi);
329 error = local_pci_probe(&ddi);
332 error = local_pci_probe(&ddi);
337 * __pci_device_probe - check if a driver wants to claim a specific PCI device
338 * @drv: driver to call to check if it wants the PCI device
339 * @pci_dev: PCI device being probed
341 * returns 0 on success, else error.
342 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
345 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
347 const struct pci_device_id *id;
350 if (!pci_dev->driver && drv->probe) {
353 id = pci_match_device(drv, pci_dev);
355 error = pci_call_probe(drv, pci_dev, id);
357 pci_dev->driver = drv;
364 static int pci_device_probe(struct device * dev)
367 struct pci_driver *drv;
368 struct pci_dev *pci_dev;
370 drv = to_pci_driver(dev->driver);
371 pci_dev = to_pci_dev(dev);
372 pci_dev_get(pci_dev);
373 error = __pci_device_probe(drv, pci_dev);
375 pci_dev_put(pci_dev);
380 static int pci_device_remove(struct device * dev)
382 struct pci_dev * pci_dev = to_pci_dev(dev);
383 struct pci_driver * drv = pci_dev->driver;
387 pm_runtime_get_sync(dev);
388 drv->remove(pci_dev);
389 pm_runtime_put_noidle(dev);
391 pci_dev->driver = NULL;
394 /* Undo the runtime PM settings in local_pci_probe() */
395 pm_runtime_disable(dev);
396 pm_runtime_set_suspended(dev);
397 pm_runtime_put_noidle(dev);
400 * If the device is still on, set the power state as "unknown",
401 * since it might change by the next time we load the driver.
403 if (pci_dev->current_state == PCI_D0)
404 pci_dev->current_state = PCI_UNKNOWN;
407 * We would love to complain here if pci_dev->is_enabled is set, that
408 * the driver should have called pci_disable_device(), but the
409 * unfortunate fact is there are too many odd BIOS and bridge setups
410 * that don't like drivers doing that all of the time.
411 * Oh well, we can dream of sane hardware when we sleep, no matter how
412 * horrible the crap we have to deal with is when we are awake...
415 pci_dev_put(pci_dev);
419 static void pci_device_shutdown(struct device *dev)
421 struct pci_dev *pci_dev = to_pci_dev(dev);
422 struct pci_driver *drv = pci_dev->driver;
424 if (drv && drv->shutdown)
425 drv->shutdown(pci_dev);
426 pci_msi_shutdown(pci_dev);
427 pci_msix_shutdown(pci_dev);
430 * Turn off Bus Master bit on the device to tell it to not
433 pci_disable_device(pci_dev);
436 * Devices may be enabled to wake up by runtime PM, but they need not
437 * be supposed to wake up the system from its "power off" state (e.g.
438 * ACPI S5). Therefore disable wakeup for all devices that aren't
439 * supposed to wake up the system at this point. The state argument
440 * will be ignored by pci_enable_wake().
442 if (!device_may_wakeup(dev))
443 pci_enable_wake(pci_dev, PCI_UNKNOWN, false);
448 /* Auxiliary functions used for system resume and run-time resume. */
451 * pci_restore_standard_config - restore standard config registers of PCI device
452 * @pci_dev: PCI device to handle
454 static int pci_restore_standard_config(struct pci_dev *pci_dev)
456 pci_update_current_state(pci_dev, PCI_UNKNOWN);
458 if (pci_dev->current_state != PCI_D0) {
459 int error = pci_set_power_state(pci_dev, PCI_D0);
464 pci_restore_state(pci_dev);
470 #ifdef CONFIG_PM_SLEEP
472 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
474 pci_power_up(pci_dev);
475 pci_restore_state(pci_dev);
476 pci_fixup_device(pci_fixup_resume_early, pci_dev);
480 * Default "suspend" method for devices that have no driver provided suspend,
481 * or not even a driver at all (second part).
483 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
486 * mark its power state as "unknown", since we don't know if
487 * e.g. the BIOS will change its device state when we suspend.
489 if (pci_dev->current_state == PCI_D0)
490 pci_dev->current_state = PCI_UNKNOWN;
494 * Default "resume" method for devices that have no driver provided resume,
495 * or not even a driver at all (second part).
497 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
501 /* if the device was enabled before suspend, reenable */
502 retval = pci_reenable_device(pci_dev);
504 * if the device was busmaster before the suspend, make it busmaster
507 if (pci_dev->is_busmaster)
508 pci_set_master(pci_dev);
513 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
515 struct pci_dev * pci_dev = to_pci_dev(dev);
516 struct pci_driver * drv = pci_dev->driver;
518 if (drv && drv->suspend) {
519 pci_power_t prev = pci_dev->current_state;
522 error = drv->suspend(pci_dev, state);
523 suspend_report_result(drv->suspend, error);
527 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
528 && pci_dev->current_state != PCI_UNKNOWN) {
529 WARN_ONCE(pci_dev->current_state != prev,
530 "PCI PM: Device state not saved by %pF\n",
535 pci_fixup_device(pci_fixup_suspend, pci_dev);
540 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
542 struct pci_dev * pci_dev = to_pci_dev(dev);
543 struct pci_driver * drv = pci_dev->driver;
545 if (drv && drv->suspend_late) {
546 pci_power_t prev = pci_dev->current_state;
549 error = drv->suspend_late(pci_dev, state);
550 suspend_report_result(drv->suspend_late, error);
554 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
555 && pci_dev->current_state != PCI_UNKNOWN) {
556 WARN_ONCE(pci_dev->current_state != prev,
557 "PCI PM: Device state not saved by %pF\n",
563 if (!pci_dev->state_saved)
564 pci_save_state(pci_dev);
566 pci_pm_set_unknown_state(pci_dev);
571 static int pci_legacy_resume_early(struct device *dev)
573 struct pci_dev * pci_dev = to_pci_dev(dev);
574 struct pci_driver * drv = pci_dev->driver;
576 return drv && drv->resume_early ?
577 drv->resume_early(pci_dev) : 0;
580 static int pci_legacy_resume(struct device *dev)
582 struct pci_dev * pci_dev = to_pci_dev(dev);
583 struct pci_driver * drv = pci_dev->driver;
585 pci_fixup_device(pci_fixup_resume, pci_dev);
587 return drv && drv->resume ?
588 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
591 /* Auxiliary functions used by the new power management framework */
593 static void pci_pm_default_resume(struct pci_dev *pci_dev)
595 pci_fixup_device(pci_fixup_resume, pci_dev);
597 if (!pci_is_bridge(pci_dev))
598 pci_enable_wake(pci_dev, PCI_D0, false);
601 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
603 /* Disable non-bridge devices without PM support */
604 if (!pci_is_bridge(pci_dev))
605 pci_disable_enabled_device(pci_dev);
608 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
610 struct pci_driver *drv = pci_dev->driver;
611 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
612 || drv->resume_early);
615 * Legacy PM support is used by default, so warn if the new framework is
616 * supported as well. Drivers are supposed to support either the
617 * former, or the latter, but not both at the same time.
619 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
620 drv->name, pci_dev->vendor, pci_dev->device);
625 /* New power management framework */
627 static int pci_pm_prepare(struct device *dev)
629 struct device_driver *drv = dev->driver;
633 * If a PCI device configured to wake up the system from sleep states
634 * has been suspended at run time and there's a resume request pending
635 * for it, this is equivalent to the device signaling wakeup, so the
636 * system suspend operation should be aborted.
638 pm_runtime_get_noresume(dev);
639 if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
640 pm_wakeup_event(dev, 0);
642 if (pm_wakeup_pending()) {
643 pm_runtime_put_sync(dev);
648 * PCI devices suspended at run time need to be resumed at this
649 * point, because in general it is necessary to reconfigure them for
650 * system suspend. Namely, if the device is supposed to wake up the
651 * system from the sleep state, we may need to reconfigure it for this
652 * purpose. In turn, if the device is not supposed to wake up the
653 * system from the sleep state, we'll have to prevent it from signaling
656 pm_runtime_resume(dev);
658 if (drv && drv->pm && drv->pm->prepare)
659 error = drv->pm->prepare(dev);
664 static void pci_pm_complete(struct device *dev)
666 struct device_driver *drv = dev->driver;
668 if (drv && drv->pm && drv->pm->complete)
669 drv->pm->complete(dev);
671 pm_runtime_put_sync(dev);
674 #else /* !CONFIG_PM_SLEEP */
676 #define pci_pm_prepare NULL
677 #define pci_pm_complete NULL
679 #endif /* !CONFIG_PM_SLEEP */
681 #ifdef CONFIG_SUSPEND
683 static int pci_pm_suspend(struct device *dev)
685 struct pci_dev *pci_dev = to_pci_dev(dev);
686 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
688 if (pci_has_legacy_pm_support(pci_dev))
689 return pci_legacy_suspend(dev, PMSG_SUSPEND);
692 pci_pm_default_suspend(pci_dev);
697 pci_power_t prev = pci_dev->current_state;
700 error = pm->suspend(dev);
701 suspend_report_result(pm->suspend, error);
705 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
706 && pci_dev->current_state != PCI_UNKNOWN) {
707 WARN_ONCE(pci_dev->current_state != prev,
708 "PCI PM: State of device not saved by %pF\n",
714 pci_fixup_device(pci_fixup_suspend, pci_dev);
719 static int pci_pm_suspend_noirq(struct device *dev)
721 struct pci_dev *pci_dev = to_pci_dev(dev);
722 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
724 if (pci_has_legacy_pm_support(pci_dev))
725 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
728 pci_save_state(pci_dev);
732 if (pm->suspend_noirq) {
733 pci_power_t prev = pci_dev->current_state;
736 error = pm->suspend_noirq(dev);
737 suspend_report_result(pm->suspend_noirq, error);
741 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
742 && pci_dev->current_state != PCI_UNKNOWN) {
743 WARN_ONCE(pci_dev->current_state != prev,
744 "PCI PM: State of device not saved by %pF\n",
750 if (!pci_dev->state_saved) {
751 pci_save_state(pci_dev);
752 if (!pci_is_bridge(pci_dev))
753 pci_prepare_to_sleep(pci_dev);
756 pci_pm_set_unknown_state(pci_dev);
759 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
760 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
761 * hasn't been quiesced and tries to turn it off. If the controller
762 * is already in D3, this can hang or cause memory corruption.
764 * Since the value of the COMMAND register doesn't matter once the
765 * device has been suspended, we can safely set it to 0 here.
767 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
768 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
773 static int pci_pm_resume_noirq(struct device *dev)
775 struct pci_dev *pci_dev = to_pci_dev(dev);
776 struct device_driver *drv = dev->driver;
779 pci_pm_default_resume_early(pci_dev);
781 if (pci_has_legacy_pm_support(pci_dev))
782 return pci_legacy_resume_early(dev);
784 if (drv && drv->pm && drv->pm->resume_noirq)
785 error = drv->pm->resume_noirq(dev);
790 static int pci_pm_resume(struct device *dev)
792 struct pci_dev *pci_dev = to_pci_dev(dev);
793 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
797 * This is necessary for the suspend error path in which resume is
798 * called without restoring the standard config registers of the device.
800 if (pci_dev->state_saved)
801 pci_restore_standard_config(pci_dev);
803 if (pci_has_legacy_pm_support(pci_dev))
804 return pci_legacy_resume(dev);
806 pci_pm_default_resume(pci_dev);
810 error = pm->resume(dev);
812 pci_pm_reenable_device(pci_dev);
818 #else /* !CONFIG_SUSPEND */
820 #define pci_pm_suspend NULL
821 #define pci_pm_suspend_noirq NULL
822 #define pci_pm_resume NULL
823 #define pci_pm_resume_noirq NULL
825 #endif /* !CONFIG_SUSPEND */
827 #ifdef CONFIG_HIBERNATE_CALLBACKS
829 static int pci_pm_freeze(struct device *dev)
831 struct pci_dev *pci_dev = to_pci_dev(dev);
832 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
834 if (pci_has_legacy_pm_support(pci_dev))
835 return pci_legacy_suspend(dev, PMSG_FREEZE);
838 pci_pm_default_suspend(pci_dev);
845 error = pm->freeze(dev);
846 suspend_report_result(pm->freeze, error);
854 static int pci_pm_freeze_noirq(struct device *dev)
856 struct pci_dev *pci_dev = to_pci_dev(dev);
857 struct device_driver *drv = dev->driver;
859 if (pci_has_legacy_pm_support(pci_dev))
860 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
862 if (drv && drv->pm && drv->pm->freeze_noirq) {
865 error = drv->pm->freeze_noirq(dev);
866 suspend_report_result(drv->pm->freeze_noirq, error);
871 if (!pci_dev->state_saved)
872 pci_save_state(pci_dev);
874 pci_pm_set_unknown_state(pci_dev);
879 static int pci_pm_thaw_noirq(struct device *dev)
881 struct pci_dev *pci_dev = to_pci_dev(dev);
882 struct device_driver *drv = dev->driver;
885 if (pci_has_legacy_pm_support(pci_dev))
886 return pci_legacy_resume_early(dev);
888 pci_update_current_state(pci_dev, PCI_D0);
890 if (drv && drv->pm && drv->pm->thaw_noirq)
891 error = drv->pm->thaw_noirq(dev);
896 static int pci_pm_thaw(struct device *dev)
898 struct pci_dev *pci_dev = to_pci_dev(dev);
899 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
902 if (pci_has_legacy_pm_support(pci_dev))
903 return pci_legacy_resume(dev);
907 error = pm->thaw(dev);
909 pci_pm_reenable_device(pci_dev);
912 pci_dev->state_saved = false;
917 static int pci_pm_poweroff(struct device *dev)
919 struct pci_dev *pci_dev = to_pci_dev(dev);
920 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
922 if (pci_has_legacy_pm_support(pci_dev))
923 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
926 pci_pm_default_suspend(pci_dev);
933 error = pm->poweroff(dev);
934 suspend_report_result(pm->poweroff, error);
940 pci_fixup_device(pci_fixup_suspend, pci_dev);
945 static int pci_pm_poweroff_noirq(struct device *dev)
947 struct pci_dev *pci_dev = to_pci_dev(dev);
948 struct device_driver *drv = dev->driver;
950 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
951 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
953 if (!drv || !drv->pm)
956 if (drv->pm->poweroff_noirq) {
959 error = drv->pm->poweroff_noirq(dev);
960 suspend_report_result(drv->pm->poweroff_noirq, error);
965 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
966 pci_prepare_to_sleep(pci_dev);
969 * The reason for doing this here is the same as for the analogous code
970 * in pci_pm_suspend_noirq().
972 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
973 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
978 static int pci_pm_restore_noirq(struct device *dev)
980 struct pci_dev *pci_dev = to_pci_dev(dev);
981 struct device_driver *drv = dev->driver;
984 pci_pm_default_resume_early(pci_dev);
986 if (pci_has_legacy_pm_support(pci_dev))
987 return pci_legacy_resume_early(dev);
989 if (drv && drv->pm && drv->pm->restore_noirq)
990 error = drv->pm->restore_noirq(dev);
995 static int pci_pm_restore(struct device *dev)
997 struct pci_dev *pci_dev = to_pci_dev(dev);
998 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1002 * This is necessary for the hibernation error path in which restore is
1003 * called without restoring the standard config registers of the device.
1005 if (pci_dev->state_saved)
1006 pci_restore_standard_config(pci_dev);
1008 if (pci_has_legacy_pm_support(pci_dev))
1009 return pci_legacy_resume(dev);
1011 pci_pm_default_resume(pci_dev);
1015 error = pm->restore(dev);
1017 pci_pm_reenable_device(pci_dev);
1023 #else /* !CONFIG_HIBERNATE_CALLBACKS */
1025 #define pci_pm_freeze NULL
1026 #define pci_pm_freeze_noirq NULL
1027 #define pci_pm_thaw NULL
1028 #define pci_pm_thaw_noirq NULL
1029 #define pci_pm_poweroff NULL
1030 #define pci_pm_poweroff_noirq NULL
1031 #define pci_pm_restore NULL
1032 #define pci_pm_restore_noirq NULL
1034 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
1036 #ifdef CONFIG_PM_RUNTIME
1038 static int pci_pm_runtime_suspend(struct device *dev)
1040 struct pci_dev *pci_dev = to_pci_dev(dev);
1041 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1042 pci_power_t prev = pci_dev->current_state;
1045 if (!pm || !pm->runtime_suspend)
1048 pci_dev->no_d3cold = false;
1049 error = pm->runtime_suspend(dev);
1050 suspend_report_result(pm->runtime_suspend, error);
1053 if (!pci_dev->d3cold_allowed)
1054 pci_dev->no_d3cold = true;
1056 pci_fixup_device(pci_fixup_suspend, pci_dev);
1058 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1059 && pci_dev->current_state != PCI_UNKNOWN) {
1060 WARN_ONCE(pci_dev->current_state != prev,
1061 "PCI PM: State of device not saved by %pF\n",
1062 pm->runtime_suspend);
1066 if (!pci_dev->state_saved)
1067 pci_save_state(pci_dev);
1069 pci_finish_runtime_suspend(pci_dev);
1074 static int pci_pm_runtime_resume(struct device *dev)
1077 struct pci_dev *pci_dev = to_pci_dev(dev);
1078 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1080 if (!pm || !pm->runtime_resume)
1083 pci_restore_standard_config(pci_dev);
1084 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1085 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1086 pci_fixup_device(pci_fixup_resume, pci_dev);
1088 rc = pm->runtime_resume(dev);
1090 pci_dev->runtime_d3cold = false;
1095 static int pci_pm_runtime_idle(struct device *dev)
1097 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1102 if (pm->runtime_idle) {
1103 int ret = pm->runtime_idle(dev);
1108 pm_runtime_suspend(dev);
1113 #else /* !CONFIG_PM_RUNTIME */
1115 #define pci_pm_runtime_suspend NULL
1116 #define pci_pm_runtime_resume NULL
1117 #define pci_pm_runtime_idle NULL
1119 #endif /* !CONFIG_PM_RUNTIME */
1123 const struct dev_pm_ops pci_dev_pm_ops = {
1124 .prepare = pci_pm_prepare,
1125 .complete = pci_pm_complete,
1126 .suspend = pci_pm_suspend,
1127 .resume = pci_pm_resume,
1128 .freeze = pci_pm_freeze,
1129 .thaw = pci_pm_thaw,
1130 .poweroff = pci_pm_poweroff,
1131 .restore = pci_pm_restore,
1132 .suspend_noirq = pci_pm_suspend_noirq,
1133 .resume_noirq = pci_pm_resume_noirq,
1134 .freeze_noirq = pci_pm_freeze_noirq,
1135 .thaw_noirq = pci_pm_thaw_noirq,
1136 .poweroff_noirq = pci_pm_poweroff_noirq,
1137 .restore_noirq = pci_pm_restore_noirq,
1138 .runtime_suspend = pci_pm_runtime_suspend,
1139 .runtime_resume = pci_pm_runtime_resume,
1140 .runtime_idle = pci_pm_runtime_idle,
1143 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1145 #else /* !COMFIG_PM_OPS */
1147 #define PCI_PM_OPS_PTR NULL
1149 #endif /* !COMFIG_PM_OPS */
1152 * __pci_register_driver - register a new pci driver
1153 * @drv: the driver structure to register
1154 * @owner: owner module of drv
1155 * @mod_name: module name string
1157 * Adds the driver structure to the list of registered drivers.
1158 * Returns a negative value on error, otherwise 0.
1159 * If no error occurred, the driver remains registered even if
1160 * no device was claimed during registration.
1162 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1163 const char *mod_name)
1167 /* initialize common driver fields */
1168 drv->driver.name = drv->name;
1169 drv->driver.bus = &pci_bus_type;
1170 drv->driver.owner = owner;
1171 drv->driver.mod_name = mod_name;
1173 spin_lock_init(&drv->dynids.lock);
1174 INIT_LIST_HEAD(&drv->dynids.list);
1176 /* register with core */
1177 error = driver_register(&drv->driver);
1181 error = pci_create_newid_files(drv);
1188 driver_unregister(&drv->driver);
1193 * pci_unregister_driver - unregister a pci driver
1194 * @drv: the driver structure to unregister
1196 * Deletes the driver structure from the list of registered PCI drivers,
1197 * gives it a chance to clean up by calling its remove() function for
1198 * each device it was responsible for, and marks those devices as
1203 pci_unregister_driver(struct pci_driver *drv)
1205 pci_remove_newid_files(drv);
1206 driver_unregister(&drv->driver);
1207 pci_free_dynids(drv);
1210 static struct pci_driver pci_compat_driver = {
1215 * pci_dev_driver - get the pci_driver of a device
1216 * @dev: the device to query
1218 * Returns the appropriate pci_driver structure or %NULL if there is no
1219 * registered driver for the device.
1222 pci_dev_driver(const struct pci_dev *dev)
1228 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1229 if (dev->resource[i].flags & IORESOURCE_BUSY)
1230 return &pci_compat_driver;
1236 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1237 * @dev: the PCI device structure to match against
1238 * @drv: the device driver to search for matching PCI device id structures
1240 * Used by a driver to check whether a PCI device present in the
1241 * system is in its list of supported devices. Returns the matching
1242 * pci_device_id structure or %NULL if there is no match.
1244 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1246 struct pci_dev *pci_dev = to_pci_dev(dev);
1247 struct pci_driver *pci_drv = to_pci_driver(drv);
1248 const struct pci_device_id *found_id;
1250 found_id = pci_match_device(pci_drv, pci_dev);
1258 * pci_dev_get - increments the reference count of the pci device structure
1259 * @dev: the device being referenced
1261 * Each live reference to a device should be refcounted.
1263 * Drivers for PCI devices should normally record such references in
1264 * their probe() methods, when they bind to a device, and release
1265 * them by calling pci_dev_put(), in their disconnect() methods.
1267 * A pointer to the device with the incremented reference counter is returned.
1269 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1272 get_device(&dev->dev);
1277 * pci_dev_put - release a use of the pci device structure
1278 * @dev: device that's been disconnected
1280 * Must be called when a user of a device is finished with it. When the last
1281 * user of the device calls this function, the memory of the device is freed.
1283 void pci_dev_put(struct pci_dev *dev)
1286 put_device(&dev->dev);
1289 #ifndef CONFIG_HOTPLUG
1290 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1296 struct bus_type pci_bus_type = {
1298 .match = pci_bus_match,
1299 .uevent = pci_uevent,
1300 .probe = pci_device_probe,
1301 .remove = pci_device_remove,
1302 .shutdown = pci_device_shutdown,
1303 .dev_attrs = pci_dev_attrs,
1304 .bus_attrs = pci_bus_attrs,
1305 .pm = PCI_PM_OPS_PTR,
1308 static int __init pci_driver_init(void)
1310 return bus_register(&pci_bus_type);
1313 postcore_initcall(pci_driver_init);
1315 EXPORT_SYMBOL_GPL(pci_add_dynid);
1316 EXPORT_SYMBOL(pci_match_id);
1317 EXPORT_SYMBOL(__pci_register_driver);
1318 EXPORT_SYMBOL(pci_unregister_driver);
1319 EXPORT_SYMBOL(pci_dev_driver);
1320 EXPORT_SYMBOL(pci_bus_type);
1321 EXPORT_SYMBOL(pci_dev_get);
1322 EXPORT_SYMBOL(pci_dev_put);