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 pci_dev *pci_dev = ddi->dev;
252 struct pci_driver *pci_drv = ddi->drv;
253 struct device *dev = &pci_dev->dev;
257 * Unbound PCI devices are always put in D0, regardless of
258 * runtime PM status. During probe, the device is set to
259 * active and the usage count is incremented. If the driver
260 * supports runtime PM, it should call pm_runtime_put_noidle()
261 * in its probe routine and pm_runtime_get_noresume() in its
264 pm_runtime_get_sync(dev);
265 pci_dev->driver = pci_drv;
266 rc = pci_drv->probe(pci_dev, ddi->id);
268 pci_dev->driver = NULL;
269 pm_runtime_put_sync(dev);
274 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
275 const struct pci_device_id *id)
278 struct drv_dev_and_id ddi = { drv, dev, id };
280 /* Execute driver initialization on node where the device's
281 bus is attached to. This way the driver likely allocates
282 its local memory on the right node without any need to
284 node = dev_to_node(&dev->dev);
289 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
290 if (cpu < nr_cpu_ids)
291 error = work_on_cpu(cpu, local_pci_probe, &ddi);
293 error = local_pci_probe(&ddi);
296 error = local_pci_probe(&ddi);
301 * __pci_device_probe - check if a driver wants to claim a specific PCI device
302 * @drv: driver to call to check if it wants the PCI device
303 * @pci_dev: PCI device being probed
305 * returns 0 on success, else error.
306 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
309 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
311 const struct pci_device_id *id;
314 if (!pci_dev->driver && drv->probe) {
317 id = pci_match_device(drv, pci_dev);
319 error = pci_call_probe(drv, pci_dev, id);
326 static int pci_device_probe(struct device * dev)
329 struct pci_driver *drv;
330 struct pci_dev *pci_dev;
332 drv = to_pci_driver(dev->driver);
333 pci_dev = to_pci_dev(dev);
334 pci_dev_get(pci_dev);
335 error = __pci_device_probe(drv, pci_dev);
337 pci_dev_put(pci_dev);
342 static int pci_device_remove(struct device * dev)
344 struct pci_dev * pci_dev = to_pci_dev(dev);
345 struct pci_driver * drv = pci_dev->driver;
349 pm_runtime_get_sync(dev);
350 drv->remove(pci_dev);
351 pm_runtime_put_noidle(dev);
353 pci_dev->driver = NULL;
356 /* Undo the runtime PM settings in local_pci_probe() */
357 pm_runtime_put_sync(dev);
360 * If the device is still on, set the power state as "unknown",
361 * since it might change by the next time we load the driver.
363 if (pci_dev->current_state == PCI_D0)
364 pci_dev->current_state = PCI_UNKNOWN;
367 * We would love to complain here if pci_dev->is_enabled is set, that
368 * the driver should have called pci_disable_device(), but the
369 * unfortunate fact is there are too many odd BIOS and bridge setups
370 * that don't like drivers doing that all of the time.
371 * Oh well, we can dream of sane hardware when we sleep, no matter how
372 * horrible the crap we have to deal with is when we are awake...
375 pci_dev_put(pci_dev);
379 static void pci_device_shutdown(struct device *dev)
381 struct pci_dev *pci_dev = to_pci_dev(dev);
382 struct pci_driver *drv = pci_dev->driver;
384 pm_runtime_resume(dev);
386 if (drv && drv->shutdown)
387 drv->shutdown(pci_dev);
388 pci_msi_shutdown(pci_dev);
389 pci_msix_shutdown(pci_dev);
392 * Turn off Bus Master bit on the device to tell it to not
395 pci_clear_master(pci_dev);
400 /* Auxiliary functions used for system resume and run-time resume. */
403 * pci_restore_standard_config - restore standard config registers of PCI device
404 * @pci_dev: PCI device to handle
406 static int pci_restore_standard_config(struct pci_dev *pci_dev)
408 pci_update_current_state(pci_dev, PCI_UNKNOWN);
410 if (pci_dev->current_state != PCI_D0) {
411 int error = pci_set_power_state(pci_dev, PCI_D0);
416 pci_restore_state(pci_dev);
422 #ifdef CONFIG_PM_SLEEP
424 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
426 pci_power_up(pci_dev);
427 pci_restore_state(pci_dev);
428 pci_fixup_device(pci_fixup_resume_early, pci_dev);
432 * Default "suspend" method for devices that have no driver provided suspend,
433 * or not even a driver at all (second part).
435 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
438 * mark its power state as "unknown", since we don't know if
439 * e.g. the BIOS will change its device state when we suspend.
441 if (pci_dev->current_state == PCI_D0)
442 pci_dev->current_state = PCI_UNKNOWN;
446 * Default "resume" method for devices that have no driver provided resume,
447 * or not even a driver at all (second part).
449 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
453 /* if the device was enabled before suspend, reenable */
454 retval = pci_reenable_device(pci_dev);
456 * if the device was busmaster before the suspend, make it busmaster
459 if (pci_dev->is_busmaster)
460 pci_set_master(pci_dev);
465 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
467 struct pci_dev * pci_dev = to_pci_dev(dev);
468 struct pci_driver * drv = pci_dev->driver;
470 if (drv && drv->suspend) {
471 pci_power_t prev = pci_dev->current_state;
474 error = drv->suspend(pci_dev, state);
475 suspend_report_result(drv->suspend, error);
479 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
480 && pci_dev->current_state != PCI_UNKNOWN) {
481 WARN_ONCE(pci_dev->current_state != prev,
482 "PCI PM: Device state not saved by %pF\n",
487 pci_fixup_device(pci_fixup_suspend, pci_dev);
492 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
494 struct pci_dev * pci_dev = to_pci_dev(dev);
495 struct pci_driver * drv = pci_dev->driver;
497 if (drv && drv->suspend_late) {
498 pci_power_t prev = pci_dev->current_state;
501 error = drv->suspend_late(pci_dev, state);
502 suspend_report_result(drv->suspend_late, error);
506 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
507 && pci_dev->current_state != PCI_UNKNOWN) {
508 WARN_ONCE(pci_dev->current_state != prev,
509 "PCI PM: Device state not saved by %pF\n",
515 if (!pci_dev->state_saved)
516 pci_save_state(pci_dev);
518 pci_pm_set_unknown_state(pci_dev);
523 static int pci_legacy_resume_early(struct device *dev)
525 struct pci_dev * pci_dev = to_pci_dev(dev);
526 struct pci_driver * drv = pci_dev->driver;
528 return drv && drv->resume_early ?
529 drv->resume_early(pci_dev) : 0;
532 static int pci_legacy_resume(struct device *dev)
534 struct pci_dev * pci_dev = to_pci_dev(dev);
535 struct pci_driver * drv = pci_dev->driver;
537 pci_fixup_device(pci_fixup_resume, pci_dev);
539 return drv && drv->resume ?
540 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
543 /* Auxiliary functions used by the new power management framework */
545 static void pci_pm_default_resume(struct pci_dev *pci_dev)
547 pci_fixup_device(pci_fixup_resume, pci_dev);
549 if (!pci_is_bridge(pci_dev))
550 pci_enable_wake(pci_dev, PCI_D0, false);
553 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
555 /* Disable non-bridge devices without PM support */
556 if (!pci_is_bridge(pci_dev))
557 pci_disable_enabled_device(pci_dev);
560 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
562 struct pci_driver *drv = pci_dev->driver;
563 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
564 || drv->resume_early);
567 * Legacy PM support is used by default, so warn if the new framework is
568 * supported as well. Drivers are supposed to support either the
569 * former, or the latter, but not both at the same time.
571 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
572 drv->name, pci_dev->vendor, pci_dev->device);
577 /* New power management framework */
579 static int pci_pm_prepare(struct device *dev)
581 struct device_driver *drv = dev->driver;
585 * PCI devices suspended at run time need to be resumed at this
586 * point, because in general it is necessary to reconfigure them for
587 * system suspend. Namely, if the device is supposed to wake up the
588 * system from the sleep state, we may need to reconfigure it for this
589 * purpose. In turn, if the device is not supposed to wake up the
590 * system from the sleep state, we'll have to prevent it from signaling
593 pm_runtime_resume(dev);
595 if (drv && drv->pm && drv->pm->prepare)
596 error = drv->pm->prepare(dev);
601 static void pci_pm_complete(struct device *dev)
603 struct device_driver *drv = dev->driver;
605 if (drv && drv->pm && drv->pm->complete)
606 drv->pm->complete(dev);
609 #else /* !CONFIG_PM_SLEEP */
611 #define pci_pm_prepare NULL
612 #define pci_pm_complete NULL
614 #endif /* !CONFIG_PM_SLEEP */
616 #ifdef CONFIG_SUSPEND
618 static int pci_pm_suspend(struct device *dev)
620 struct pci_dev *pci_dev = to_pci_dev(dev);
621 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
623 if (pci_has_legacy_pm_support(pci_dev))
624 return pci_legacy_suspend(dev, PMSG_SUSPEND);
627 pci_pm_default_suspend(pci_dev);
631 pci_dev->state_saved = false;
633 pci_power_t prev = pci_dev->current_state;
636 error = pm->suspend(dev);
637 suspend_report_result(pm->suspend, error);
641 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
642 && pci_dev->current_state != PCI_UNKNOWN) {
643 WARN_ONCE(pci_dev->current_state != prev,
644 "PCI PM: State of device not saved by %pF\n",
650 pci_fixup_device(pci_fixup_suspend, pci_dev);
655 static int pci_pm_suspend_noirq(struct device *dev)
657 struct pci_dev *pci_dev = to_pci_dev(dev);
658 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
660 if (pci_has_legacy_pm_support(pci_dev))
661 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
664 pci_save_state(pci_dev);
668 if (pm->suspend_noirq) {
669 pci_power_t prev = pci_dev->current_state;
672 error = pm->suspend_noirq(dev);
673 suspend_report_result(pm->suspend_noirq, error);
677 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
678 && pci_dev->current_state != PCI_UNKNOWN) {
679 WARN_ONCE(pci_dev->current_state != prev,
680 "PCI PM: State of device not saved by %pF\n",
686 if (!pci_dev->state_saved) {
687 pci_save_state(pci_dev);
688 if (!pci_is_bridge(pci_dev))
689 pci_prepare_to_sleep(pci_dev);
692 pci_pm_set_unknown_state(pci_dev);
695 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
696 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
697 * hasn't been quiesced and tries to turn it off. If the controller
698 * is already in D3, this can hang or cause memory corruption.
700 * Since the value of the COMMAND register doesn't matter once the
701 * device has been suspended, we can safely set it to 0 here.
703 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
704 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
709 static int pci_pm_resume_noirq(struct device *dev)
711 struct pci_dev *pci_dev = to_pci_dev(dev);
712 struct device_driver *drv = dev->driver;
715 pci_pm_default_resume_early(pci_dev);
717 if (pci_has_legacy_pm_support(pci_dev))
718 return pci_legacy_resume_early(dev);
720 if (drv && drv->pm && drv->pm->resume_noirq)
721 error = drv->pm->resume_noirq(dev);
726 static int pci_pm_resume(struct device *dev)
728 struct pci_dev *pci_dev = to_pci_dev(dev);
729 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
733 * This is necessary for the suspend error path in which resume is
734 * called without restoring the standard config registers of the device.
736 if (pci_dev->state_saved)
737 pci_restore_standard_config(pci_dev);
739 if (pci_has_legacy_pm_support(pci_dev))
740 return pci_legacy_resume(dev);
742 pci_pm_default_resume(pci_dev);
746 error = pm->resume(dev);
748 pci_pm_reenable_device(pci_dev);
754 #else /* !CONFIG_SUSPEND */
756 #define pci_pm_suspend NULL
757 #define pci_pm_suspend_noirq NULL
758 #define pci_pm_resume NULL
759 #define pci_pm_resume_noirq NULL
761 #endif /* !CONFIG_SUSPEND */
763 #ifdef CONFIG_HIBERNATE_CALLBACKS
765 static int pci_pm_freeze(struct device *dev)
767 struct pci_dev *pci_dev = to_pci_dev(dev);
768 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
770 if (pci_has_legacy_pm_support(pci_dev))
771 return pci_legacy_suspend(dev, PMSG_FREEZE);
774 pci_pm_default_suspend(pci_dev);
778 pci_dev->state_saved = false;
782 error = pm->freeze(dev);
783 suspend_report_result(pm->freeze, error);
791 static int pci_pm_freeze_noirq(struct device *dev)
793 struct pci_dev *pci_dev = to_pci_dev(dev);
794 struct device_driver *drv = dev->driver;
796 if (pci_has_legacy_pm_support(pci_dev))
797 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
799 if (drv && drv->pm && drv->pm->freeze_noirq) {
802 error = drv->pm->freeze_noirq(dev);
803 suspend_report_result(drv->pm->freeze_noirq, error);
808 if (!pci_dev->state_saved)
809 pci_save_state(pci_dev);
811 pci_pm_set_unknown_state(pci_dev);
816 static int pci_pm_thaw_noirq(struct device *dev)
818 struct pci_dev *pci_dev = to_pci_dev(dev);
819 struct device_driver *drv = dev->driver;
822 if (pci_has_legacy_pm_support(pci_dev))
823 return pci_legacy_resume_early(dev);
825 pci_update_current_state(pci_dev, PCI_D0);
827 if (drv && drv->pm && drv->pm->thaw_noirq)
828 error = drv->pm->thaw_noirq(dev);
833 static int pci_pm_thaw(struct device *dev)
835 struct pci_dev *pci_dev = to_pci_dev(dev);
836 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
839 if (pci_has_legacy_pm_support(pci_dev))
840 return pci_legacy_resume(dev);
844 error = pm->thaw(dev);
846 pci_pm_reenable_device(pci_dev);
849 pci_dev->state_saved = false;
854 static int pci_pm_poweroff(struct device *dev)
856 struct pci_dev *pci_dev = to_pci_dev(dev);
857 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
859 if (pci_has_legacy_pm_support(pci_dev))
860 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
863 pci_pm_default_suspend(pci_dev);
867 pci_dev->state_saved = false;
871 error = pm->poweroff(dev);
872 suspend_report_result(pm->poweroff, error);
878 pci_fixup_device(pci_fixup_suspend, pci_dev);
883 static int pci_pm_poweroff_noirq(struct device *dev)
885 struct pci_dev *pci_dev = to_pci_dev(dev);
886 struct device_driver *drv = dev->driver;
888 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
889 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
891 if (!drv || !drv->pm)
894 if (drv->pm->poweroff_noirq) {
897 error = drv->pm->poweroff_noirq(dev);
898 suspend_report_result(drv->pm->poweroff_noirq, error);
903 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
904 pci_prepare_to_sleep(pci_dev);
907 * The reason for doing this here is the same as for the analogous code
908 * in pci_pm_suspend_noirq().
910 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
911 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
916 static int pci_pm_restore_noirq(struct device *dev)
918 struct pci_dev *pci_dev = to_pci_dev(dev);
919 struct device_driver *drv = dev->driver;
922 pci_pm_default_resume_early(pci_dev);
924 if (pci_has_legacy_pm_support(pci_dev))
925 return pci_legacy_resume_early(dev);
927 if (drv && drv->pm && drv->pm->restore_noirq)
928 error = drv->pm->restore_noirq(dev);
933 static int pci_pm_restore(struct device *dev)
935 struct pci_dev *pci_dev = to_pci_dev(dev);
936 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
940 * This is necessary for the hibernation error path in which restore is
941 * called without restoring the standard config registers of the device.
943 if (pci_dev->state_saved)
944 pci_restore_standard_config(pci_dev);
946 if (pci_has_legacy_pm_support(pci_dev))
947 return pci_legacy_resume(dev);
949 pci_pm_default_resume(pci_dev);
953 error = pm->restore(dev);
955 pci_pm_reenable_device(pci_dev);
961 #else /* !CONFIG_HIBERNATE_CALLBACKS */
963 #define pci_pm_freeze NULL
964 #define pci_pm_freeze_noirq NULL
965 #define pci_pm_thaw NULL
966 #define pci_pm_thaw_noirq NULL
967 #define pci_pm_poweroff NULL
968 #define pci_pm_poweroff_noirq NULL
969 #define pci_pm_restore NULL
970 #define pci_pm_restore_noirq NULL
972 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
974 #ifdef CONFIG_PM_RUNTIME
976 static int pci_pm_runtime_suspend(struct device *dev)
978 struct pci_dev *pci_dev = to_pci_dev(dev);
979 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
980 pci_power_t prev = pci_dev->current_state;
984 * If pci_dev->driver is not set (unbound), the device should
985 * always remain in D0 regardless of the runtime PM status
987 if (!pci_dev->driver)
990 if (!pm || !pm->runtime_suspend)
993 pci_dev->state_saved = false;
994 pci_dev->no_d3cold = false;
995 error = pm->runtime_suspend(dev);
996 suspend_report_result(pm->runtime_suspend, error);
999 if (!pci_dev->d3cold_allowed)
1000 pci_dev->no_d3cold = true;
1002 pci_fixup_device(pci_fixup_suspend, pci_dev);
1004 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1005 && pci_dev->current_state != PCI_UNKNOWN) {
1006 WARN_ONCE(pci_dev->current_state != prev,
1007 "PCI PM: State of device not saved by %pF\n",
1008 pm->runtime_suspend);
1012 if (!pci_dev->state_saved) {
1013 pci_save_state(pci_dev);
1014 pci_finish_runtime_suspend(pci_dev);
1020 static int pci_pm_runtime_resume(struct device *dev)
1023 struct pci_dev *pci_dev = to_pci_dev(dev);
1024 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1027 * If pci_dev->driver is not set (unbound), the device should
1028 * always remain in D0 regardless of the runtime PM status
1030 if (!pci_dev->driver)
1033 if (!pm || !pm->runtime_resume)
1036 pci_restore_standard_config(pci_dev);
1037 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1038 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1039 pci_fixup_device(pci_fixup_resume, pci_dev);
1041 rc = pm->runtime_resume(dev);
1043 pci_dev->runtime_d3cold = false;
1048 static int pci_pm_runtime_idle(struct device *dev)
1050 struct pci_dev *pci_dev = to_pci_dev(dev);
1051 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1054 * If pci_dev->driver is not set (unbound), the device should
1055 * always remain in D0 regardless of the runtime PM status
1057 if (!pci_dev->driver)
1063 if (pm->runtime_idle) {
1064 int ret = pm->runtime_idle(dev);
1070 pm_runtime_suspend(dev);
1074 #else /* !CONFIG_PM_RUNTIME */
1076 #define pci_pm_runtime_suspend NULL
1077 #define pci_pm_runtime_resume NULL
1078 #define pci_pm_runtime_idle NULL
1080 #endif /* !CONFIG_PM_RUNTIME */
1084 const struct dev_pm_ops pci_dev_pm_ops = {
1085 .prepare = pci_pm_prepare,
1086 .complete = pci_pm_complete,
1087 .suspend = pci_pm_suspend,
1088 .resume = pci_pm_resume,
1089 .freeze = pci_pm_freeze,
1090 .thaw = pci_pm_thaw,
1091 .poweroff = pci_pm_poweroff,
1092 .restore = pci_pm_restore,
1093 .suspend_noirq = pci_pm_suspend_noirq,
1094 .resume_noirq = pci_pm_resume_noirq,
1095 .freeze_noirq = pci_pm_freeze_noirq,
1096 .thaw_noirq = pci_pm_thaw_noirq,
1097 .poweroff_noirq = pci_pm_poweroff_noirq,
1098 .restore_noirq = pci_pm_restore_noirq,
1099 .runtime_suspend = pci_pm_runtime_suspend,
1100 .runtime_resume = pci_pm_runtime_resume,
1101 .runtime_idle = pci_pm_runtime_idle,
1104 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1106 #else /* !COMFIG_PM_OPS */
1108 #define PCI_PM_OPS_PTR NULL
1110 #endif /* !COMFIG_PM_OPS */
1113 * __pci_register_driver - register a new pci driver
1114 * @drv: the driver structure to register
1115 * @owner: owner module of drv
1116 * @mod_name: module name string
1118 * Adds the driver structure to the list of registered drivers.
1119 * Returns a negative value on error, otherwise 0.
1120 * If no error occurred, the driver remains registered even if
1121 * no device was claimed during registration.
1123 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1124 const char *mod_name)
1126 /* initialize common driver fields */
1127 drv->driver.name = drv->name;
1128 drv->driver.bus = &pci_bus_type;
1129 drv->driver.owner = owner;
1130 drv->driver.mod_name = mod_name;
1132 spin_lock_init(&drv->dynids.lock);
1133 INIT_LIST_HEAD(&drv->dynids.list);
1135 /* register with core */
1136 return driver_register(&drv->driver);
1140 * pci_unregister_driver - unregister a pci driver
1141 * @drv: the driver structure to unregister
1143 * Deletes the driver structure from the list of registered PCI drivers,
1144 * gives it a chance to clean up by calling its remove() function for
1145 * each device it was responsible for, and marks those devices as
1150 pci_unregister_driver(struct pci_driver *drv)
1152 driver_unregister(&drv->driver);
1153 pci_free_dynids(drv);
1156 static struct pci_driver pci_compat_driver = {
1161 * pci_dev_driver - get the pci_driver of a device
1162 * @dev: the device to query
1164 * Returns the appropriate pci_driver structure or %NULL if there is no
1165 * registered driver for the device.
1168 pci_dev_driver(const struct pci_dev *dev)
1174 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1175 if (dev->resource[i].flags & IORESOURCE_BUSY)
1176 return &pci_compat_driver;
1182 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1183 * @dev: the PCI device structure to match against
1184 * @drv: the device driver to search for matching PCI device id structures
1186 * Used by a driver to check whether a PCI device present in the
1187 * system is in its list of supported devices. Returns the matching
1188 * pci_device_id structure or %NULL if there is no match.
1190 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1192 struct pci_dev *pci_dev = to_pci_dev(dev);
1193 struct pci_driver *pci_drv;
1194 const struct pci_device_id *found_id;
1196 if (!pci_dev->match_driver)
1199 pci_drv = to_pci_driver(drv);
1200 found_id = pci_match_device(pci_drv, pci_dev);
1208 * pci_dev_get - increments the reference count of the pci device structure
1209 * @dev: the device being referenced
1211 * Each live reference to a device should be refcounted.
1213 * Drivers for PCI devices should normally record such references in
1214 * their probe() methods, when they bind to a device, and release
1215 * them by calling pci_dev_put(), in their disconnect() methods.
1217 * A pointer to the device with the incremented reference counter is returned.
1219 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1222 get_device(&dev->dev);
1227 * pci_dev_put - release a use of the pci device structure
1228 * @dev: device that's been disconnected
1230 * Must be called when a user of a device is finished with it. When the last
1231 * user of the device calls this function, the memory of the device is freed.
1233 void pci_dev_put(struct pci_dev *dev)
1236 put_device(&dev->dev);
1239 static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1241 struct pci_dev *pdev;
1246 pdev = to_pci_dev(dev);
1250 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1253 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1256 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1257 pdev->subsystem_device))
1260 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1263 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
1264 pdev->vendor, pdev->device,
1265 pdev->subsystem_vendor, pdev->subsystem_device,
1266 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1272 struct bus_type pci_bus_type = {
1274 .match = pci_bus_match,
1275 .uevent = pci_uevent,
1276 .probe = pci_device_probe,
1277 .remove = pci_device_remove,
1278 .shutdown = pci_device_shutdown,
1279 .dev_attrs = pci_dev_attrs,
1280 .bus_attrs = pci_bus_attrs,
1281 .drv_attrs = pci_drv_attrs,
1282 .pm = PCI_PM_OPS_PTR,
1285 static int __init pci_driver_init(void)
1287 return bus_register(&pci_bus_type);
1290 postcore_initcall(pci_driver_init);
1292 EXPORT_SYMBOL_GPL(pci_add_dynid);
1293 EXPORT_SYMBOL(pci_match_id);
1294 EXPORT_SYMBOL(__pci_register_driver);
1295 EXPORT_SYMBOL(pci_unregister_driver);
1296 EXPORT_SYMBOL(pci_dev_driver);
1297 EXPORT_SYMBOL(pci_bus_type);
1298 EXPORT_SYMBOL(pci_dev_get);
1299 EXPORT_SYMBOL(pci_dev_put);