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 if (drv && drv->shutdown)
402 drv->shutdown(pci_dev);
403 pci_msi_shutdown(pci_dev);
404 pci_msix_shutdown(pci_dev);
407 * Turn off Bus Master bit on the device to tell it to not
410 pci_disable_device(pci_dev);
413 * Devices may be enabled to wake up by runtime PM, but they need not
414 * be supposed to wake up the system from its "power off" state (e.g.
415 * ACPI S5). Therefore disable wakeup for all devices that aren't
416 * supposed to wake up the system at this point. The state argument
417 * will be ignored by pci_enable_wake().
419 if (!device_may_wakeup(dev))
420 pci_enable_wake(pci_dev, PCI_UNKNOWN, false);
425 /* Auxiliary functions used for system resume and run-time resume. */
428 * pci_restore_standard_config - restore standard config registers of PCI device
429 * @pci_dev: PCI device to handle
431 static int pci_restore_standard_config(struct pci_dev *pci_dev)
433 pci_update_current_state(pci_dev, PCI_UNKNOWN);
435 if (pci_dev->current_state != PCI_D0) {
436 int error = pci_set_power_state(pci_dev, PCI_D0);
441 pci_restore_state(pci_dev);
447 #ifdef CONFIG_PM_SLEEP
449 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
451 pci_power_up(pci_dev);
452 pci_restore_state(pci_dev);
453 pci_fixup_device(pci_fixup_resume_early, pci_dev);
457 * Default "suspend" method for devices that have no driver provided suspend,
458 * or not even a driver at all (second part).
460 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
463 * mark its power state as "unknown", since we don't know if
464 * e.g. the BIOS will change its device state when we suspend.
466 if (pci_dev->current_state == PCI_D0)
467 pci_dev->current_state = PCI_UNKNOWN;
471 * Default "resume" method for devices that have no driver provided resume,
472 * or not even a driver at all (second part).
474 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
478 /* if the device was enabled before suspend, reenable */
479 retval = pci_reenable_device(pci_dev);
481 * if the device was busmaster before the suspend, make it busmaster
484 if (pci_dev->is_busmaster)
485 pci_set_master(pci_dev);
490 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
492 struct pci_dev * pci_dev = to_pci_dev(dev);
493 struct pci_driver * drv = pci_dev->driver;
495 if (drv && drv->suspend) {
496 pci_power_t prev = pci_dev->current_state;
499 error = drv->suspend(pci_dev, state);
500 suspend_report_result(drv->suspend, error);
504 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
505 && pci_dev->current_state != PCI_UNKNOWN) {
506 WARN_ONCE(pci_dev->current_state != prev,
507 "PCI PM: Device state not saved by %pF\n",
512 pci_fixup_device(pci_fixup_suspend, pci_dev);
517 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
519 struct pci_dev * pci_dev = to_pci_dev(dev);
520 struct pci_driver * drv = pci_dev->driver;
522 if (drv && drv->suspend_late) {
523 pci_power_t prev = pci_dev->current_state;
526 error = drv->suspend_late(pci_dev, state);
527 suspend_report_result(drv->suspend_late, error);
531 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
532 && pci_dev->current_state != PCI_UNKNOWN) {
533 WARN_ONCE(pci_dev->current_state != prev,
534 "PCI PM: Device state not saved by %pF\n",
540 if (!pci_dev->state_saved)
541 pci_save_state(pci_dev);
543 pci_pm_set_unknown_state(pci_dev);
548 static int pci_legacy_resume_early(struct device *dev)
550 struct pci_dev * pci_dev = to_pci_dev(dev);
551 struct pci_driver * drv = pci_dev->driver;
553 return drv && drv->resume_early ?
554 drv->resume_early(pci_dev) : 0;
557 static int pci_legacy_resume(struct device *dev)
559 struct pci_dev * pci_dev = to_pci_dev(dev);
560 struct pci_driver * drv = pci_dev->driver;
562 pci_fixup_device(pci_fixup_resume, pci_dev);
564 return drv && drv->resume ?
565 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
568 /* Auxiliary functions used by the new power management framework */
570 static void pci_pm_default_resume(struct pci_dev *pci_dev)
572 pci_fixup_device(pci_fixup_resume, pci_dev);
574 if (!pci_is_bridge(pci_dev))
575 pci_enable_wake(pci_dev, PCI_D0, false);
578 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
580 /* Disable non-bridge devices without PM support */
581 if (!pci_is_bridge(pci_dev))
582 pci_disable_enabled_device(pci_dev);
585 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
587 struct pci_driver *drv = pci_dev->driver;
588 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
589 || drv->resume_early);
592 * Legacy PM support is used by default, so warn if the new framework is
593 * supported as well. Drivers are supposed to support either the
594 * former, or the latter, but not both at the same time.
596 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
597 drv->name, pci_dev->vendor, pci_dev->device);
602 /* New power management framework */
604 static int pci_pm_prepare(struct device *dev)
606 struct device_driver *drv = dev->driver;
610 * PCI devices suspended at run time need to be resumed at this
611 * point, because in general it is necessary to reconfigure them for
612 * system suspend. Namely, if the device is supposed to wake up the
613 * system from the sleep state, we may need to reconfigure it for this
614 * purpose. In turn, if the device is not supposed to wake up the
615 * system from the sleep state, we'll have to prevent it from signaling
618 pm_runtime_resume(dev);
620 if (drv && drv->pm && drv->pm->prepare)
621 error = drv->pm->prepare(dev);
626 static void pci_pm_complete(struct device *dev)
628 struct device_driver *drv = dev->driver;
630 if (drv && drv->pm && drv->pm->complete)
631 drv->pm->complete(dev);
634 #else /* !CONFIG_PM_SLEEP */
636 #define pci_pm_prepare NULL
637 #define pci_pm_complete NULL
639 #endif /* !CONFIG_PM_SLEEP */
641 #ifdef CONFIG_SUSPEND
643 static int pci_pm_suspend(struct device *dev)
645 struct pci_dev *pci_dev = to_pci_dev(dev);
646 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
648 if (pci_has_legacy_pm_support(pci_dev))
649 return pci_legacy_suspend(dev, PMSG_SUSPEND);
652 pci_pm_default_suspend(pci_dev);
657 pci_power_t prev = pci_dev->current_state;
660 error = pm->suspend(dev);
661 suspend_report_result(pm->suspend, error);
665 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
666 && pci_dev->current_state != PCI_UNKNOWN) {
667 WARN_ONCE(pci_dev->current_state != prev,
668 "PCI PM: State of device not saved by %pF\n",
674 pci_fixup_device(pci_fixup_suspend, pci_dev);
679 static int pci_pm_suspend_noirq(struct device *dev)
681 struct pci_dev *pci_dev = to_pci_dev(dev);
682 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
684 if (pci_has_legacy_pm_support(pci_dev))
685 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
688 pci_save_state(pci_dev);
692 if (pm->suspend_noirq) {
693 pci_power_t prev = pci_dev->current_state;
696 error = pm->suspend_noirq(dev);
697 suspend_report_result(pm->suspend_noirq, error);
701 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
702 && pci_dev->current_state != PCI_UNKNOWN) {
703 WARN_ONCE(pci_dev->current_state != prev,
704 "PCI PM: State of device not saved by %pF\n",
710 if (!pci_dev->state_saved) {
711 pci_save_state(pci_dev);
712 if (!pci_is_bridge(pci_dev))
713 pci_prepare_to_sleep(pci_dev);
716 pci_pm_set_unknown_state(pci_dev);
719 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
720 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
721 * hasn't been quiesced and tries to turn it off. If the controller
722 * is already in D3, this can hang or cause memory corruption.
724 * Since the value of the COMMAND register doesn't matter once the
725 * device has been suspended, we can safely set it to 0 here.
727 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
728 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
733 static int pci_pm_resume_noirq(struct device *dev)
735 struct pci_dev *pci_dev = to_pci_dev(dev);
736 struct device_driver *drv = dev->driver;
739 pci_pm_default_resume_early(pci_dev);
741 if (pci_has_legacy_pm_support(pci_dev))
742 return pci_legacy_resume_early(dev);
744 if (drv && drv->pm && drv->pm->resume_noirq)
745 error = drv->pm->resume_noirq(dev);
750 static int pci_pm_resume(struct device *dev)
752 struct pci_dev *pci_dev = to_pci_dev(dev);
753 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
757 * This is necessary for the suspend error path in which resume is
758 * called without restoring the standard config registers of the device.
760 if (pci_dev->state_saved)
761 pci_restore_standard_config(pci_dev);
763 if (pci_has_legacy_pm_support(pci_dev))
764 return pci_legacy_resume(dev);
766 pci_pm_default_resume(pci_dev);
770 error = pm->resume(dev);
772 pci_pm_reenable_device(pci_dev);
778 #else /* !CONFIG_SUSPEND */
780 #define pci_pm_suspend NULL
781 #define pci_pm_suspend_noirq NULL
782 #define pci_pm_resume NULL
783 #define pci_pm_resume_noirq NULL
785 #endif /* !CONFIG_SUSPEND */
787 #ifdef CONFIG_HIBERNATE_CALLBACKS
789 static int pci_pm_freeze(struct device *dev)
791 struct pci_dev *pci_dev = to_pci_dev(dev);
792 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
794 if (pci_has_legacy_pm_support(pci_dev))
795 return pci_legacy_suspend(dev, PMSG_FREEZE);
798 pci_pm_default_suspend(pci_dev);
805 error = pm->freeze(dev);
806 suspend_report_result(pm->freeze, error);
814 static int pci_pm_freeze_noirq(struct device *dev)
816 struct pci_dev *pci_dev = to_pci_dev(dev);
817 struct device_driver *drv = dev->driver;
819 if (pci_has_legacy_pm_support(pci_dev))
820 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
822 if (drv && drv->pm && drv->pm->freeze_noirq) {
825 error = drv->pm->freeze_noirq(dev);
826 suspend_report_result(drv->pm->freeze_noirq, error);
831 if (!pci_dev->state_saved)
832 pci_save_state(pci_dev);
834 pci_pm_set_unknown_state(pci_dev);
839 static int pci_pm_thaw_noirq(struct device *dev)
841 struct pci_dev *pci_dev = to_pci_dev(dev);
842 struct device_driver *drv = dev->driver;
845 if (pci_has_legacy_pm_support(pci_dev))
846 return pci_legacy_resume_early(dev);
848 pci_update_current_state(pci_dev, PCI_D0);
850 if (drv && drv->pm && drv->pm->thaw_noirq)
851 error = drv->pm->thaw_noirq(dev);
856 static int pci_pm_thaw(struct device *dev)
858 struct pci_dev *pci_dev = to_pci_dev(dev);
859 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
862 if (pci_has_legacy_pm_support(pci_dev))
863 return pci_legacy_resume(dev);
867 error = pm->thaw(dev);
869 pci_pm_reenable_device(pci_dev);
872 pci_dev->state_saved = false;
877 static int pci_pm_poweroff(struct device *dev)
879 struct pci_dev *pci_dev = to_pci_dev(dev);
880 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
882 if (pci_has_legacy_pm_support(pci_dev))
883 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
886 pci_pm_default_suspend(pci_dev);
893 error = pm->poweroff(dev);
894 suspend_report_result(pm->poweroff, error);
900 pci_fixup_device(pci_fixup_suspend, pci_dev);
905 static int pci_pm_poweroff_noirq(struct device *dev)
907 struct pci_dev *pci_dev = to_pci_dev(dev);
908 struct device_driver *drv = dev->driver;
910 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
911 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
913 if (!drv || !drv->pm)
916 if (drv->pm->poweroff_noirq) {
919 error = drv->pm->poweroff_noirq(dev);
920 suspend_report_result(drv->pm->poweroff_noirq, error);
925 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
926 pci_prepare_to_sleep(pci_dev);
929 * The reason for doing this here is the same as for the analogous code
930 * in pci_pm_suspend_noirq().
932 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
933 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
938 static int pci_pm_restore_noirq(struct device *dev)
940 struct pci_dev *pci_dev = to_pci_dev(dev);
941 struct device_driver *drv = dev->driver;
944 pci_pm_default_resume_early(pci_dev);
946 if (pci_has_legacy_pm_support(pci_dev))
947 return pci_legacy_resume_early(dev);
949 if (drv && drv->pm && drv->pm->restore_noirq)
950 error = drv->pm->restore_noirq(dev);
955 static int pci_pm_restore(struct device *dev)
957 struct pci_dev *pci_dev = to_pci_dev(dev);
958 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
962 * This is necessary for the hibernation error path in which restore is
963 * called without restoring the standard config registers of the device.
965 if (pci_dev->state_saved)
966 pci_restore_standard_config(pci_dev);
968 if (pci_has_legacy_pm_support(pci_dev))
969 return pci_legacy_resume(dev);
971 pci_pm_default_resume(pci_dev);
975 error = pm->restore(dev);
977 pci_pm_reenable_device(pci_dev);
983 #else /* !CONFIG_HIBERNATE_CALLBACKS */
985 #define pci_pm_freeze NULL
986 #define pci_pm_freeze_noirq NULL
987 #define pci_pm_thaw NULL
988 #define pci_pm_thaw_noirq NULL
989 #define pci_pm_poweroff NULL
990 #define pci_pm_poweroff_noirq NULL
991 #define pci_pm_restore NULL
992 #define pci_pm_restore_noirq NULL
994 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
996 #ifdef CONFIG_PM_RUNTIME
998 static int pci_pm_runtime_suspend(struct device *dev)
1000 struct pci_dev *pci_dev = to_pci_dev(dev);
1001 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1002 pci_power_t prev = pci_dev->current_state;
1005 if (!pm || !pm->runtime_suspend)
1008 pci_dev->no_d3cold = false;
1009 error = pm->runtime_suspend(dev);
1010 suspend_report_result(pm->runtime_suspend, error);
1013 if (!pci_dev->d3cold_allowed)
1014 pci_dev->no_d3cold = true;
1016 pci_fixup_device(pci_fixup_suspend, pci_dev);
1018 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1019 && pci_dev->current_state != PCI_UNKNOWN) {
1020 WARN_ONCE(pci_dev->current_state != prev,
1021 "PCI PM: State of device not saved by %pF\n",
1022 pm->runtime_suspend);
1026 if (!pci_dev->state_saved)
1027 pci_save_state(pci_dev);
1029 pci_finish_runtime_suspend(pci_dev);
1034 static int pci_pm_runtime_resume(struct device *dev)
1037 struct pci_dev *pci_dev = to_pci_dev(dev);
1038 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1040 if (!pm || !pm->runtime_resume)
1043 pci_restore_standard_config(pci_dev);
1044 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1045 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1046 pci_fixup_device(pci_fixup_resume, pci_dev);
1048 rc = pm->runtime_resume(dev);
1050 pci_dev->runtime_d3cold = false;
1055 static int pci_pm_runtime_idle(struct device *dev)
1057 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1062 if (pm->runtime_idle) {
1063 int ret = pm->runtime_idle(dev);
1068 pm_runtime_suspend(dev);
1073 #else /* !CONFIG_PM_RUNTIME */
1075 #define pci_pm_runtime_suspend NULL
1076 #define pci_pm_runtime_resume NULL
1077 #define pci_pm_runtime_idle NULL
1079 #endif /* !CONFIG_PM_RUNTIME */
1083 const struct dev_pm_ops pci_dev_pm_ops = {
1084 .prepare = pci_pm_prepare,
1085 .complete = pci_pm_complete,
1086 .suspend = pci_pm_suspend,
1087 .resume = pci_pm_resume,
1088 .freeze = pci_pm_freeze,
1089 .thaw = pci_pm_thaw,
1090 .poweroff = pci_pm_poweroff,
1091 .restore = pci_pm_restore,
1092 .suspend_noirq = pci_pm_suspend_noirq,
1093 .resume_noirq = pci_pm_resume_noirq,
1094 .freeze_noirq = pci_pm_freeze_noirq,
1095 .thaw_noirq = pci_pm_thaw_noirq,
1096 .poweroff_noirq = pci_pm_poweroff_noirq,
1097 .restore_noirq = pci_pm_restore_noirq,
1098 .runtime_suspend = pci_pm_runtime_suspend,
1099 .runtime_resume = pci_pm_runtime_resume,
1100 .runtime_idle = pci_pm_runtime_idle,
1103 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1105 #else /* !COMFIG_PM_OPS */
1107 #define PCI_PM_OPS_PTR NULL
1109 #endif /* !COMFIG_PM_OPS */
1112 * __pci_register_driver - register a new pci driver
1113 * @drv: the driver structure to register
1114 * @owner: owner module of drv
1115 * @mod_name: module name string
1117 * Adds the driver structure to the list of registered drivers.
1118 * Returns a negative value on error, otherwise 0.
1119 * If no error occurred, the driver remains registered even if
1120 * no device was claimed during registration.
1122 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1123 const char *mod_name)
1125 /* initialize common driver fields */
1126 drv->driver.name = drv->name;
1127 drv->driver.bus = &pci_bus_type;
1128 drv->driver.owner = owner;
1129 drv->driver.mod_name = mod_name;
1131 spin_lock_init(&drv->dynids.lock);
1132 INIT_LIST_HEAD(&drv->dynids.list);
1134 /* register with core */
1135 return driver_register(&drv->driver);
1139 * pci_unregister_driver - unregister a pci driver
1140 * @drv: the driver structure to unregister
1142 * Deletes the driver structure from the list of registered PCI drivers,
1143 * gives it a chance to clean up by calling its remove() function for
1144 * each device it was responsible for, and marks those devices as
1149 pci_unregister_driver(struct pci_driver *drv)
1151 driver_unregister(&drv->driver);
1152 pci_free_dynids(drv);
1155 static struct pci_driver pci_compat_driver = {
1160 * pci_dev_driver - get the pci_driver of a device
1161 * @dev: the device to query
1163 * Returns the appropriate pci_driver structure or %NULL if there is no
1164 * registered driver for the device.
1167 pci_dev_driver(const struct pci_dev *dev)
1173 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1174 if (dev->resource[i].flags & IORESOURCE_BUSY)
1175 return &pci_compat_driver;
1181 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1182 * @dev: the PCI device structure to match against
1183 * @drv: the device driver to search for matching PCI device id structures
1185 * Used by a driver to check whether a PCI device present in the
1186 * system is in its list of supported devices. Returns the matching
1187 * pci_device_id structure or %NULL if there is no match.
1189 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1191 struct pci_dev *pci_dev = to_pci_dev(dev);
1192 struct pci_driver *pci_drv = to_pci_driver(drv);
1193 const struct pci_device_id *found_id;
1195 found_id = pci_match_device(pci_drv, pci_dev);
1203 * pci_dev_get - increments the reference count of the pci device structure
1204 * @dev: the device being referenced
1206 * Each live reference to a device should be refcounted.
1208 * Drivers for PCI devices should normally record such references in
1209 * their probe() methods, when they bind to a device, and release
1210 * them by calling pci_dev_put(), in their disconnect() methods.
1212 * A pointer to the device with the incremented reference counter is returned.
1214 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1217 get_device(&dev->dev);
1222 * pci_dev_put - release a use of the pci device structure
1223 * @dev: device that's been disconnected
1225 * Must be called when a user of a device is finished with it. When the last
1226 * user of the device calls this function, the memory of the device is freed.
1228 void pci_dev_put(struct pci_dev *dev)
1231 put_device(&dev->dev);
1234 #ifndef CONFIG_HOTPLUG
1235 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1241 struct bus_type pci_bus_type = {
1243 .match = pci_bus_match,
1244 .uevent = pci_uevent,
1245 .probe = pci_device_probe,
1246 .remove = pci_device_remove,
1247 .shutdown = pci_device_shutdown,
1248 .dev_attrs = pci_dev_attrs,
1249 .bus_attrs = pci_bus_attrs,
1250 .drv_attrs = pci_drv_attrs,
1251 .pm = PCI_PM_OPS_PTR,
1254 static int __init pci_driver_init(void)
1256 return bus_register(&pci_bus_type);
1259 postcore_initcall(pci_driver_init);
1261 EXPORT_SYMBOL_GPL(pci_add_dynid);
1262 EXPORT_SYMBOL(pci_match_id);
1263 EXPORT_SYMBOL(__pci_register_driver);
1264 EXPORT_SYMBOL(pci_unregister_driver);
1265 EXPORT_SYMBOL(pci_dev_driver);
1266 EXPORT_SYMBOL(pci_bus_type);
1267 EXPORT_SYMBOL(pci_dev_get);
1268 EXPORT_SYMBOL(pci_dev_put);