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_disable_device(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);
632 pci_power_t prev = pci_dev->current_state;
635 error = pm->suspend(dev);
636 suspend_report_result(pm->suspend, error);
640 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
641 && pci_dev->current_state != PCI_UNKNOWN) {
642 WARN_ONCE(pci_dev->current_state != prev,
643 "PCI PM: State of device not saved by %pF\n",
649 pci_fixup_device(pci_fixup_suspend, pci_dev);
654 static int pci_pm_suspend_noirq(struct device *dev)
656 struct pci_dev *pci_dev = to_pci_dev(dev);
657 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
659 if (pci_has_legacy_pm_support(pci_dev))
660 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
663 pci_save_state(pci_dev);
667 if (pm->suspend_noirq) {
668 pci_power_t prev = pci_dev->current_state;
671 error = pm->suspend_noirq(dev);
672 suspend_report_result(pm->suspend_noirq, error);
676 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
677 && pci_dev->current_state != PCI_UNKNOWN) {
678 WARN_ONCE(pci_dev->current_state != prev,
679 "PCI PM: State of device not saved by %pF\n",
685 if (!pci_dev->state_saved) {
686 pci_save_state(pci_dev);
687 if (!pci_is_bridge(pci_dev))
688 pci_prepare_to_sleep(pci_dev);
691 pci_pm_set_unknown_state(pci_dev);
694 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
695 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
696 * hasn't been quiesced and tries to turn it off. If the controller
697 * is already in D3, this can hang or cause memory corruption.
699 * Since the value of the COMMAND register doesn't matter once the
700 * device has been suspended, we can safely set it to 0 here.
702 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
703 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
708 static int pci_pm_resume_noirq(struct device *dev)
710 struct pci_dev *pci_dev = to_pci_dev(dev);
711 struct device_driver *drv = dev->driver;
714 pci_pm_default_resume_early(pci_dev);
716 if (pci_has_legacy_pm_support(pci_dev))
717 return pci_legacy_resume_early(dev);
719 if (drv && drv->pm && drv->pm->resume_noirq)
720 error = drv->pm->resume_noirq(dev);
725 static int pci_pm_resume(struct device *dev)
727 struct pci_dev *pci_dev = to_pci_dev(dev);
728 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
732 * This is necessary for the suspend error path in which resume is
733 * called without restoring the standard config registers of the device.
735 if (pci_dev->state_saved)
736 pci_restore_standard_config(pci_dev);
738 if (pci_has_legacy_pm_support(pci_dev))
739 return pci_legacy_resume(dev);
741 pci_pm_default_resume(pci_dev);
745 error = pm->resume(dev);
747 pci_pm_reenable_device(pci_dev);
753 #else /* !CONFIG_SUSPEND */
755 #define pci_pm_suspend NULL
756 #define pci_pm_suspend_noirq NULL
757 #define pci_pm_resume NULL
758 #define pci_pm_resume_noirq NULL
760 #endif /* !CONFIG_SUSPEND */
762 #ifdef CONFIG_HIBERNATE_CALLBACKS
764 static int pci_pm_freeze(struct device *dev)
766 struct pci_dev *pci_dev = to_pci_dev(dev);
767 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
769 if (pci_has_legacy_pm_support(pci_dev))
770 return pci_legacy_suspend(dev, PMSG_FREEZE);
773 pci_pm_default_suspend(pci_dev);
780 error = pm->freeze(dev);
781 suspend_report_result(pm->freeze, error);
789 static int pci_pm_freeze_noirq(struct device *dev)
791 struct pci_dev *pci_dev = to_pci_dev(dev);
792 struct device_driver *drv = dev->driver;
794 if (pci_has_legacy_pm_support(pci_dev))
795 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
797 if (drv && drv->pm && drv->pm->freeze_noirq) {
800 error = drv->pm->freeze_noirq(dev);
801 suspend_report_result(drv->pm->freeze_noirq, error);
806 if (!pci_dev->state_saved)
807 pci_save_state(pci_dev);
809 pci_pm_set_unknown_state(pci_dev);
814 static int pci_pm_thaw_noirq(struct device *dev)
816 struct pci_dev *pci_dev = to_pci_dev(dev);
817 struct device_driver *drv = dev->driver;
820 if (pci_has_legacy_pm_support(pci_dev))
821 return pci_legacy_resume_early(dev);
823 pci_update_current_state(pci_dev, PCI_D0);
825 if (drv && drv->pm && drv->pm->thaw_noirq)
826 error = drv->pm->thaw_noirq(dev);
831 static int pci_pm_thaw(struct device *dev)
833 struct pci_dev *pci_dev = to_pci_dev(dev);
834 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
837 if (pci_has_legacy_pm_support(pci_dev))
838 return pci_legacy_resume(dev);
842 error = pm->thaw(dev);
844 pci_pm_reenable_device(pci_dev);
847 pci_dev->state_saved = false;
852 static int pci_pm_poweroff(struct device *dev)
854 struct pci_dev *pci_dev = to_pci_dev(dev);
855 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
857 if (pci_has_legacy_pm_support(pci_dev))
858 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
861 pci_pm_default_suspend(pci_dev);
868 error = pm->poweroff(dev);
869 suspend_report_result(pm->poweroff, error);
875 pci_fixup_device(pci_fixup_suspend, pci_dev);
880 static int pci_pm_poweroff_noirq(struct device *dev)
882 struct pci_dev *pci_dev = to_pci_dev(dev);
883 struct device_driver *drv = dev->driver;
885 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
886 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
888 if (!drv || !drv->pm)
891 if (drv->pm->poweroff_noirq) {
894 error = drv->pm->poweroff_noirq(dev);
895 suspend_report_result(drv->pm->poweroff_noirq, error);
900 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
901 pci_prepare_to_sleep(pci_dev);
904 * The reason for doing this here is the same as for the analogous code
905 * in pci_pm_suspend_noirq().
907 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
908 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
913 static int pci_pm_restore_noirq(struct device *dev)
915 struct pci_dev *pci_dev = to_pci_dev(dev);
916 struct device_driver *drv = dev->driver;
919 pci_pm_default_resume_early(pci_dev);
921 if (pci_has_legacy_pm_support(pci_dev))
922 return pci_legacy_resume_early(dev);
924 if (drv && drv->pm && drv->pm->restore_noirq)
925 error = drv->pm->restore_noirq(dev);
930 static int pci_pm_restore(struct device *dev)
932 struct pci_dev *pci_dev = to_pci_dev(dev);
933 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
937 * This is necessary for the hibernation error path in which restore is
938 * called without restoring the standard config registers of the device.
940 if (pci_dev->state_saved)
941 pci_restore_standard_config(pci_dev);
943 if (pci_has_legacy_pm_support(pci_dev))
944 return pci_legacy_resume(dev);
946 pci_pm_default_resume(pci_dev);
950 error = pm->restore(dev);
952 pci_pm_reenable_device(pci_dev);
958 #else /* !CONFIG_HIBERNATE_CALLBACKS */
960 #define pci_pm_freeze NULL
961 #define pci_pm_freeze_noirq NULL
962 #define pci_pm_thaw NULL
963 #define pci_pm_thaw_noirq NULL
964 #define pci_pm_poweroff NULL
965 #define pci_pm_poweroff_noirq NULL
966 #define pci_pm_restore NULL
967 #define pci_pm_restore_noirq NULL
969 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
971 #ifdef CONFIG_PM_RUNTIME
973 static int pci_pm_runtime_suspend(struct device *dev)
975 struct pci_dev *pci_dev = to_pci_dev(dev);
976 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
977 pci_power_t prev = pci_dev->current_state;
981 * If pci_dev->driver is not set (unbound), the device should
982 * always remain in D0 regardless of the runtime PM status
984 if (!pci_dev->driver)
987 if (!pm || !pm->runtime_suspend)
990 pci_dev->no_d3cold = false;
991 error = pm->runtime_suspend(dev);
992 suspend_report_result(pm->runtime_suspend, error);
995 if (!pci_dev->d3cold_allowed)
996 pci_dev->no_d3cold = true;
998 pci_fixup_device(pci_fixup_suspend, pci_dev);
1000 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1001 && pci_dev->current_state != PCI_UNKNOWN) {
1002 WARN_ONCE(pci_dev->current_state != prev,
1003 "PCI PM: State of device not saved by %pF\n",
1004 pm->runtime_suspend);
1008 if (!pci_dev->state_saved) {
1009 pci_save_state(pci_dev);
1010 pci_finish_runtime_suspend(pci_dev);
1016 static int pci_pm_runtime_resume(struct device *dev)
1019 struct pci_dev *pci_dev = to_pci_dev(dev);
1020 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1023 * If pci_dev->driver is not set (unbound), the device should
1024 * always remain in D0 regardless of the runtime PM status
1026 if (!pci_dev->driver)
1029 if (!pm || !pm->runtime_resume)
1032 pci_restore_standard_config(pci_dev);
1033 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1034 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1035 pci_fixup_device(pci_fixup_resume, pci_dev);
1037 rc = pm->runtime_resume(dev);
1039 pci_dev->runtime_d3cold = false;
1044 static int pci_pm_runtime_idle(struct device *dev)
1046 struct pci_dev *pci_dev = to_pci_dev(dev);
1047 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1050 * If pci_dev->driver is not set (unbound), the device should
1051 * always remain in D0 regardless of the runtime PM status
1053 if (!pci_dev->driver)
1059 if (pm->runtime_idle) {
1060 int ret = pm->runtime_idle(dev);
1066 pm_runtime_suspend(dev);
1070 #else /* !CONFIG_PM_RUNTIME */
1072 #define pci_pm_runtime_suspend NULL
1073 #define pci_pm_runtime_resume NULL
1074 #define pci_pm_runtime_idle NULL
1076 #endif /* !CONFIG_PM_RUNTIME */
1080 const struct dev_pm_ops pci_dev_pm_ops = {
1081 .prepare = pci_pm_prepare,
1082 .complete = pci_pm_complete,
1083 .suspend = pci_pm_suspend,
1084 .resume = pci_pm_resume,
1085 .freeze = pci_pm_freeze,
1086 .thaw = pci_pm_thaw,
1087 .poweroff = pci_pm_poweroff,
1088 .restore = pci_pm_restore,
1089 .suspend_noirq = pci_pm_suspend_noirq,
1090 .resume_noirq = pci_pm_resume_noirq,
1091 .freeze_noirq = pci_pm_freeze_noirq,
1092 .thaw_noirq = pci_pm_thaw_noirq,
1093 .poweroff_noirq = pci_pm_poweroff_noirq,
1094 .restore_noirq = pci_pm_restore_noirq,
1095 .runtime_suspend = pci_pm_runtime_suspend,
1096 .runtime_resume = pci_pm_runtime_resume,
1097 .runtime_idle = pci_pm_runtime_idle,
1100 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1102 #else /* !COMFIG_PM_OPS */
1104 #define PCI_PM_OPS_PTR NULL
1106 #endif /* !COMFIG_PM_OPS */
1109 * __pci_register_driver - register a new pci driver
1110 * @drv: the driver structure to register
1111 * @owner: owner module of drv
1112 * @mod_name: module name string
1114 * Adds the driver structure to the list of registered drivers.
1115 * Returns a negative value on error, otherwise 0.
1116 * If no error occurred, the driver remains registered even if
1117 * no device was claimed during registration.
1119 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1120 const char *mod_name)
1122 /* initialize common driver fields */
1123 drv->driver.name = drv->name;
1124 drv->driver.bus = &pci_bus_type;
1125 drv->driver.owner = owner;
1126 drv->driver.mod_name = mod_name;
1128 spin_lock_init(&drv->dynids.lock);
1129 INIT_LIST_HEAD(&drv->dynids.list);
1131 /* register with core */
1132 return driver_register(&drv->driver);
1136 * pci_unregister_driver - unregister a pci driver
1137 * @drv: the driver structure to unregister
1139 * Deletes the driver structure from the list of registered PCI drivers,
1140 * gives it a chance to clean up by calling its remove() function for
1141 * each device it was responsible for, and marks those devices as
1146 pci_unregister_driver(struct pci_driver *drv)
1148 driver_unregister(&drv->driver);
1149 pci_free_dynids(drv);
1152 static struct pci_driver pci_compat_driver = {
1157 * pci_dev_driver - get the pci_driver of a device
1158 * @dev: the device to query
1160 * Returns the appropriate pci_driver structure or %NULL if there is no
1161 * registered driver for the device.
1164 pci_dev_driver(const struct pci_dev *dev)
1170 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1171 if (dev->resource[i].flags & IORESOURCE_BUSY)
1172 return &pci_compat_driver;
1178 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1179 * @dev: the PCI device structure to match against
1180 * @drv: the device driver to search for matching PCI device id structures
1182 * Used by a driver to check whether a PCI device present in the
1183 * system is in its list of supported devices. Returns the matching
1184 * pci_device_id structure or %NULL if there is no match.
1186 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1188 struct pci_dev *pci_dev = to_pci_dev(dev);
1189 struct pci_driver *pci_drv = to_pci_driver(drv);
1190 const struct pci_device_id *found_id;
1192 found_id = pci_match_device(pci_drv, pci_dev);
1200 * pci_dev_get - increments the reference count of the pci device structure
1201 * @dev: the device being referenced
1203 * Each live reference to a device should be refcounted.
1205 * Drivers for PCI devices should normally record such references in
1206 * their probe() methods, when they bind to a device, and release
1207 * them by calling pci_dev_put(), in their disconnect() methods.
1209 * A pointer to the device with the incremented reference counter is returned.
1211 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1214 get_device(&dev->dev);
1219 * pci_dev_put - release a use of the pci device structure
1220 * @dev: device that's been disconnected
1222 * Must be called when a user of a device is finished with it. When the last
1223 * user of the device calls this function, the memory of the device is freed.
1225 void pci_dev_put(struct pci_dev *dev)
1228 put_device(&dev->dev);
1231 static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1233 struct pci_dev *pdev;
1238 pdev = to_pci_dev(dev);
1242 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1245 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1248 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1249 pdev->subsystem_device))
1252 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1255 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
1256 pdev->vendor, pdev->device,
1257 pdev->subsystem_vendor, pdev->subsystem_device,
1258 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1264 struct bus_type pci_bus_type = {
1266 .match = pci_bus_match,
1267 .uevent = pci_uevent,
1268 .probe = pci_device_probe,
1269 .remove = pci_device_remove,
1270 .shutdown = pci_device_shutdown,
1271 .dev_attrs = pci_dev_attrs,
1272 .bus_attrs = pci_bus_attrs,
1273 .drv_attrs = pci_drv_attrs,
1274 .pm = PCI_PM_OPS_PTR,
1277 static int __init pci_driver_init(void)
1279 return bus_register(&pci_bus_type);
1282 postcore_initcall(pci_driver_init);
1284 EXPORT_SYMBOL_GPL(pci_add_dynid);
1285 EXPORT_SYMBOL(pci_match_id);
1286 EXPORT_SYMBOL(__pci_register_driver);
1287 EXPORT_SYMBOL(pci_unregister_driver);
1288 EXPORT_SYMBOL(pci_dev_driver);
1289 EXPORT_SYMBOL(pci_bus_type);
1290 EXPORT_SYMBOL(pci_dev_get);
1291 EXPORT_SYMBOL(pci_dev_put);