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;
285 /* Unbound PCI devices are always set to disabled and suspended.
286 * During probe, the device is set to enabled and active and the
287 * usage count is incremented. If the driver supports runtime PM,
288 * it should call pm_runtime_put_noidle() in its probe routine and
289 * pm_runtime_get_noresume() in its remove routine.
291 pm_runtime_get_noresume(dev);
292 pm_runtime_set_active(dev);
293 pm_runtime_enable(dev);
295 rc = ddi->drv->probe(ddi->dev, ddi->id);
297 pm_runtime_disable(dev);
298 pm_runtime_set_suspended(dev);
299 pm_runtime_put_noidle(dev);
304 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
305 const struct pci_device_id *id)
308 struct drv_dev_and_id ddi = { drv, dev, id };
310 /* Execute driver initialization on node where the device's
311 bus is attached to. This way the driver likely allocates
312 its local memory on the right node without any need to
314 node = dev_to_node(&dev->dev);
319 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
320 if (cpu < nr_cpu_ids)
321 error = work_on_cpu(cpu, local_pci_probe, &ddi);
323 error = local_pci_probe(&ddi);
326 error = local_pci_probe(&ddi);
331 * __pci_device_probe - check if a driver wants to claim a specific PCI device
332 * @drv: driver to call to check if it wants the PCI device
333 * @pci_dev: PCI device being probed
335 * returns 0 on success, else error.
336 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
339 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
341 const struct pci_device_id *id;
344 if (!pci_dev->driver && drv->probe) {
347 id = pci_match_device(drv, pci_dev);
349 error = pci_call_probe(drv, pci_dev, id);
351 pci_dev->driver = drv;
358 static int pci_device_probe(struct device * dev)
361 struct pci_driver *drv;
362 struct pci_dev *pci_dev;
364 drv = to_pci_driver(dev->driver);
365 pci_dev = to_pci_dev(dev);
366 pci_dev_get(pci_dev);
367 error = __pci_device_probe(drv, pci_dev);
369 pci_dev_put(pci_dev);
374 static int pci_device_remove(struct device * dev)
376 struct pci_dev * pci_dev = to_pci_dev(dev);
377 struct pci_driver * drv = pci_dev->driver;
381 pm_runtime_get_sync(dev);
382 drv->remove(pci_dev);
383 pm_runtime_put_noidle(dev);
385 pci_dev->driver = NULL;
388 /* Undo the runtime PM settings in local_pci_probe() */
389 pm_runtime_disable(dev);
390 pm_runtime_set_suspended(dev);
391 pm_runtime_put_noidle(dev);
394 * If the device is still on, set the power state as "unknown",
395 * since it might change by the next time we load the driver.
397 if (pci_dev->current_state == PCI_D0)
398 pci_dev->current_state = PCI_UNKNOWN;
401 * We would love to complain here if pci_dev->is_enabled is set, that
402 * the driver should have called pci_disable_device(), but the
403 * unfortunate fact is there are too many odd BIOS and bridge setups
404 * that don't like drivers doing that all of the time.
405 * Oh well, we can dream of sane hardware when we sleep, no matter how
406 * horrible the crap we have to deal with is when we are awake...
409 pci_dev_put(pci_dev);
413 static void pci_device_shutdown(struct device *dev)
415 struct pci_dev *pci_dev = to_pci_dev(dev);
416 struct pci_driver *drv = pci_dev->driver;
418 if (drv && drv->shutdown)
419 drv->shutdown(pci_dev);
420 pci_msi_shutdown(pci_dev);
421 pci_msix_shutdown(pci_dev);
424 * Turn off Bus Master bit on the device to tell it to not
427 pci_disable_device(pci_dev);
430 * Devices may be enabled to wake up by runtime PM, but they need not
431 * be supposed to wake up the system from its "power off" state (e.g.
432 * ACPI S5). Therefore disable wakeup for all devices that aren't
433 * supposed to wake up the system at this point. The state argument
434 * will be ignored by pci_enable_wake().
436 if (!device_may_wakeup(dev))
437 pci_enable_wake(pci_dev, PCI_UNKNOWN, false);
442 /* Auxiliary functions used for system resume and run-time resume. */
445 * pci_restore_standard_config - restore standard config registers of PCI device
446 * @pci_dev: PCI device to handle
448 static int pci_restore_standard_config(struct pci_dev *pci_dev)
450 pci_update_current_state(pci_dev, PCI_UNKNOWN);
452 if (pci_dev->current_state != PCI_D0) {
453 int error = pci_set_power_state(pci_dev, PCI_D0);
458 pci_restore_state(pci_dev);
464 #ifdef CONFIG_PM_SLEEP
466 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
468 pci_power_up(pci_dev);
469 pci_restore_state(pci_dev);
470 pci_fixup_device(pci_fixup_resume_early, pci_dev);
474 * Default "suspend" method for devices that have no driver provided suspend,
475 * or not even a driver at all (second part).
477 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
480 * mark its power state as "unknown", since we don't know if
481 * e.g. the BIOS will change its device state when we suspend.
483 if (pci_dev->current_state == PCI_D0)
484 pci_dev->current_state = PCI_UNKNOWN;
488 * Default "resume" method for devices that have no driver provided resume,
489 * or not even a driver at all (second part).
491 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
495 /* if the device was enabled before suspend, reenable */
496 retval = pci_reenable_device(pci_dev);
498 * if the device was busmaster before the suspend, make it busmaster
501 if (pci_dev->is_busmaster)
502 pci_set_master(pci_dev);
507 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
509 struct pci_dev * pci_dev = to_pci_dev(dev);
510 struct pci_driver * drv = pci_dev->driver;
512 if (drv && drv->suspend) {
513 pci_power_t prev = pci_dev->current_state;
516 error = drv->suspend(pci_dev, state);
517 suspend_report_result(drv->suspend, error);
521 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
522 && pci_dev->current_state != PCI_UNKNOWN) {
523 WARN_ONCE(pci_dev->current_state != prev,
524 "PCI PM: Device state not saved by %pF\n",
529 pci_fixup_device(pci_fixup_suspend, pci_dev);
534 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
536 struct pci_dev * pci_dev = to_pci_dev(dev);
537 struct pci_driver * drv = pci_dev->driver;
539 if (drv && drv->suspend_late) {
540 pci_power_t prev = pci_dev->current_state;
543 error = drv->suspend_late(pci_dev, state);
544 suspend_report_result(drv->suspend_late, error);
548 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
549 && pci_dev->current_state != PCI_UNKNOWN) {
550 WARN_ONCE(pci_dev->current_state != prev,
551 "PCI PM: Device state not saved by %pF\n",
557 if (!pci_dev->state_saved)
558 pci_save_state(pci_dev);
560 pci_pm_set_unknown_state(pci_dev);
565 static int pci_legacy_resume_early(struct device *dev)
567 struct pci_dev * pci_dev = to_pci_dev(dev);
568 struct pci_driver * drv = pci_dev->driver;
570 return drv && drv->resume_early ?
571 drv->resume_early(pci_dev) : 0;
574 static int pci_legacy_resume(struct device *dev)
576 struct pci_dev * pci_dev = to_pci_dev(dev);
577 struct pci_driver * drv = pci_dev->driver;
579 pci_fixup_device(pci_fixup_resume, pci_dev);
581 return drv && drv->resume ?
582 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
585 /* Auxiliary functions used by the new power management framework */
587 static void pci_pm_default_resume(struct pci_dev *pci_dev)
589 pci_fixup_device(pci_fixup_resume, pci_dev);
591 if (!pci_is_bridge(pci_dev))
592 pci_enable_wake(pci_dev, PCI_D0, false);
595 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
597 /* Disable non-bridge devices without PM support */
598 if (!pci_is_bridge(pci_dev))
599 pci_disable_enabled_device(pci_dev);
602 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
604 struct pci_driver *drv = pci_dev->driver;
605 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
606 || drv->resume_early);
609 * Legacy PM support is used by default, so warn if the new framework is
610 * supported as well. Drivers are supposed to support either the
611 * former, or the latter, but not both at the same time.
613 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
614 drv->name, pci_dev->vendor, pci_dev->device);
619 /* New power management framework */
621 static int pci_pm_prepare(struct device *dev)
623 struct device_driver *drv = dev->driver;
627 * If a PCI device configured to wake up the system from sleep states
628 * has been suspended at run time and there's a resume request pending
629 * for it, this is equivalent to the device signaling wakeup, so the
630 * system suspend operation should be aborted.
632 pm_runtime_get_noresume(dev);
633 if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
634 pm_wakeup_event(dev, 0);
636 if (pm_wakeup_pending()) {
637 pm_runtime_put_sync(dev);
642 * PCI devices suspended at run time need to be resumed at this
643 * point, because in general it is necessary to reconfigure them for
644 * system suspend. Namely, if the device is supposed to wake up the
645 * system from the sleep state, we may need to reconfigure it for this
646 * purpose. In turn, if the device is not supposed to wake up the
647 * system from the sleep state, we'll have to prevent it from signaling
650 pm_runtime_resume(dev);
652 if (drv && drv->pm && drv->pm->prepare)
653 error = drv->pm->prepare(dev);
658 static void pci_pm_complete(struct device *dev)
660 struct device_driver *drv = dev->driver;
662 if (drv && drv->pm && drv->pm->complete)
663 drv->pm->complete(dev);
665 pm_runtime_put_sync(dev);
668 #else /* !CONFIG_PM_SLEEP */
670 #define pci_pm_prepare NULL
671 #define pci_pm_complete NULL
673 #endif /* !CONFIG_PM_SLEEP */
675 #ifdef CONFIG_SUSPEND
677 static int pci_pm_suspend(struct device *dev)
679 struct pci_dev *pci_dev = to_pci_dev(dev);
680 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
682 if (pci_has_legacy_pm_support(pci_dev))
683 return pci_legacy_suspend(dev, PMSG_SUSPEND);
686 pci_pm_default_suspend(pci_dev);
691 pci_power_t prev = pci_dev->current_state;
694 error = pm->suspend(dev);
695 suspend_report_result(pm->suspend, error);
699 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
700 && pci_dev->current_state != PCI_UNKNOWN) {
701 WARN_ONCE(pci_dev->current_state != prev,
702 "PCI PM: State of device not saved by %pF\n",
708 pci_fixup_device(pci_fixup_suspend, pci_dev);
713 static int pci_pm_suspend_noirq(struct device *dev)
715 struct pci_dev *pci_dev = to_pci_dev(dev);
716 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
718 if (pci_has_legacy_pm_support(pci_dev))
719 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
722 pci_save_state(pci_dev);
726 if (pm->suspend_noirq) {
727 pci_power_t prev = pci_dev->current_state;
730 error = pm->suspend_noirq(dev);
731 suspend_report_result(pm->suspend_noirq, error);
735 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
736 && pci_dev->current_state != PCI_UNKNOWN) {
737 WARN_ONCE(pci_dev->current_state != prev,
738 "PCI PM: State of device not saved by %pF\n",
744 if (!pci_dev->state_saved) {
745 pci_save_state(pci_dev);
746 if (!pci_is_bridge(pci_dev))
747 pci_prepare_to_sleep(pci_dev);
750 pci_pm_set_unknown_state(pci_dev);
753 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
754 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
755 * hasn't been quiesced and tries to turn it off. If the controller
756 * is already in D3, this can hang or cause memory corruption.
758 * Since the value of the COMMAND register doesn't matter once the
759 * device has been suspended, we can safely set it to 0 here.
761 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
762 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
767 static int pci_pm_resume_noirq(struct device *dev)
769 struct pci_dev *pci_dev = to_pci_dev(dev);
770 struct device_driver *drv = dev->driver;
773 pci_pm_default_resume_early(pci_dev);
775 if (pci_has_legacy_pm_support(pci_dev))
776 return pci_legacy_resume_early(dev);
778 if (drv && drv->pm && drv->pm->resume_noirq)
779 error = drv->pm->resume_noirq(dev);
784 static int pci_pm_resume(struct device *dev)
786 struct pci_dev *pci_dev = to_pci_dev(dev);
787 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
791 * This is necessary for the suspend error path in which resume is
792 * called without restoring the standard config registers of the device.
794 if (pci_dev->state_saved)
795 pci_restore_standard_config(pci_dev);
797 if (pci_has_legacy_pm_support(pci_dev))
798 return pci_legacy_resume(dev);
800 pci_pm_default_resume(pci_dev);
804 error = pm->resume(dev);
806 pci_pm_reenable_device(pci_dev);
812 #else /* !CONFIG_SUSPEND */
814 #define pci_pm_suspend NULL
815 #define pci_pm_suspend_noirq NULL
816 #define pci_pm_resume NULL
817 #define pci_pm_resume_noirq NULL
819 #endif /* !CONFIG_SUSPEND */
821 #ifdef CONFIG_HIBERNATE_CALLBACKS
823 static int pci_pm_freeze(struct device *dev)
825 struct pci_dev *pci_dev = to_pci_dev(dev);
826 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
828 if (pci_has_legacy_pm_support(pci_dev))
829 return pci_legacy_suspend(dev, PMSG_FREEZE);
832 pci_pm_default_suspend(pci_dev);
839 error = pm->freeze(dev);
840 suspend_report_result(pm->freeze, error);
848 static int pci_pm_freeze_noirq(struct device *dev)
850 struct pci_dev *pci_dev = to_pci_dev(dev);
851 struct device_driver *drv = dev->driver;
853 if (pci_has_legacy_pm_support(pci_dev))
854 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
856 if (drv && drv->pm && drv->pm->freeze_noirq) {
859 error = drv->pm->freeze_noirq(dev);
860 suspend_report_result(drv->pm->freeze_noirq, error);
865 if (!pci_dev->state_saved)
866 pci_save_state(pci_dev);
868 pci_pm_set_unknown_state(pci_dev);
873 static int pci_pm_thaw_noirq(struct device *dev)
875 struct pci_dev *pci_dev = to_pci_dev(dev);
876 struct device_driver *drv = dev->driver;
879 if (pci_has_legacy_pm_support(pci_dev))
880 return pci_legacy_resume_early(dev);
882 pci_update_current_state(pci_dev, PCI_D0);
884 if (drv && drv->pm && drv->pm->thaw_noirq)
885 error = drv->pm->thaw_noirq(dev);
890 static int pci_pm_thaw(struct device *dev)
892 struct pci_dev *pci_dev = to_pci_dev(dev);
893 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
896 if (pci_has_legacy_pm_support(pci_dev))
897 return pci_legacy_resume(dev);
901 error = pm->thaw(dev);
903 pci_pm_reenable_device(pci_dev);
906 pci_dev->state_saved = false;
911 static int pci_pm_poweroff(struct device *dev)
913 struct pci_dev *pci_dev = to_pci_dev(dev);
914 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
916 if (pci_has_legacy_pm_support(pci_dev))
917 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
920 pci_pm_default_suspend(pci_dev);
927 error = pm->poweroff(dev);
928 suspend_report_result(pm->poweroff, error);
934 pci_fixup_device(pci_fixup_suspend, pci_dev);
939 static int pci_pm_poweroff_noirq(struct device *dev)
941 struct pci_dev *pci_dev = to_pci_dev(dev);
942 struct device_driver *drv = dev->driver;
944 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
945 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
947 if (!drv || !drv->pm)
950 if (drv->pm->poweroff_noirq) {
953 error = drv->pm->poweroff_noirq(dev);
954 suspend_report_result(drv->pm->poweroff_noirq, error);
959 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
960 pci_prepare_to_sleep(pci_dev);
965 static int pci_pm_restore_noirq(struct device *dev)
967 struct pci_dev *pci_dev = to_pci_dev(dev);
968 struct device_driver *drv = dev->driver;
971 pci_pm_default_resume_early(pci_dev);
973 if (pci_has_legacy_pm_support(pci_dev))
974 return pci_legacy_resume_early(dev);
976 if (drv && drv->pm && drv->pm->restore_noirq)
977 error = drv->pm->restore_noirq(dev);
982 static int pci_pm_restore(struct device *dev)
984 struct pci_dev *pci_dev = to_pci_dev(dev);
985 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
989 * This is necessary for the hibernation error path in which restore is
990 * called without restoring the standard config registers of the device.
992 if (pci_dev->state_saved)
993 pci_restore_standard_config(pci_dev);
995 if (pci_has_legacy_pm_support(pci_dev))
996 return pci_legacy_resume(dev);
998 pci_pm_default_resume(pci_dev);
1002 error = pm->restore(dev);
1004 pci_pm_reenable_device(pci_dev);
1010 #else /* !CONFIG_HIBERNATE_CALLBACKS */
1012 #define pci_pm_freeze NULL
1013 #define pci_pm_freeze_noirq NULL
1014 #define pci_pm_thaw NULL
1015 #define pci_pm_thaw_noirq NULL
1016 #define pci_pm_poweroff NULL
1017 #define pci_pm_poweroff_noirq NULL
1018 #define pci_pm_restore NULL
1019 #define pci_pm_restore_noirq NULL
1021 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
1023 #ifdef CONFIG_PM_RUNTIME
1025 static int pci_pm_runtime_suspend(struct device *dev)
1027 struct pci_dev *pci_dev = to_pci_dev(dev);
1028 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1029 pci_power_t prev = pci_dev->current_state;
1032 if (!pm || !pm->runtime_suspend)
1035 pci_dev->no_d3cold = false;
1036 error = pm->runtime_suspend(dev);
1037 suspend_report_result(pm->runtime_suspend, error);
1040 if (!pci_dev->d3cold_allowed)
1041 pci_dev->no_d3cold = true;
1043 pci_fixup_device(pci_fixup_suspend, pci_dev);
1045 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1046 && pci_dev->current_state != PCI_UNKNOWN) {
1047 WARN_ONCE(pci_dev->current_state != prev,
1048 "PCI PM: State of device not saved by %pF\n",
1049 pm->runtime_suspend);
1053 if (!pci_dev->state_saved)
1054 pci_save_state(pci_dev);
1056 pci_finish_runtime_suspend(pci_dev);
1061 static int pci_pm_runtime_resume(struct device *dev)
1064 struct pci_dev *pci_dev = to_pci_dev(dev);
1065 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1067 if (!pm || !pm->runtime_resume)
1070 pci_restore_standard_config(pci_dev);
1071 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1072 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1073 pci_fixup_device(pci_fixup_resume, pci_dev);
1075 rc = pm->runtime_resume(dev);
1077 pci_dev->runtime_d3cold = false;
1082 static int pci_pm_runtime_idle(struct device *dev)
1084 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1089 if (pm->runtime_idle) {
1090 int ret = pm->runtime_idle(dev);
1095 pm_runtime_suspend(dev);
1100 #else /* !CONFIG_PM_RUNTIME */
1102 #define pci_pm_runtime_suspend NULL
1103 #define pci_pm_runtime_resume NULL
1104 #define pci_pm_runtime_idle NULL
1106 #endif /* !CONFIG_PM_RUNTIME */
1110 const struct dev_pm_ops pci_dev_pm_ops = {
1111 .prepare = pci_pm_prepare,
1112 .complete = pci_pm_complete,
1113 .suspend = pci_pm_suspend,
1114 .resume = pci_pm_resume,
1115 .freeze = pci_pm_freeze,
1116 .thaw = pci_pm_thaw,
1117 .poweroff = pci_pm_poweroff,
1118 .restore = pci_pm_restore,
1119 .suspend_noirq = pci_pm_suspend_noirq,
1120 .resume_noirq = pci_pm_resume_noirq,
1121 .freeze_noirq = pci_pm_freeze_noirq,
1122 .thaw_noirq = pci_pm_thaw_noirq,
1123 .poweroff_noirq = pci_pm_poweroff_noirq,
1124 .restore_noirq = pci_pm_restore_noirq,
1125 .runtime_suspend = pci_pm_runtime_suspend,
1126 .runtime_resume = pci_pm_runtime_resume,
1127 .runtime_idle = pci_pm_runtime_idle,
1130 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1132 #else /* !COMFIG_PM_OPS */
1134 #define PCI_PM_OPS_PTR NULL
1136 #endif /* !COMFIG_PM_OPS */
1139 * __pci_register_driver - register a new pci driver
1140 * @drv: the driver structure to register
1141 * @owner: owner module of drv
1142 * @mod_name: module name string
1144 * Adds the driver structure to the list of registered drivers.
1145 * Returns a negative value on error, otherwise 0.
1146 * If no error occurred, the driver remains registered even if
1147 * no device was claimed during registration.
1149 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1150 const char *mod_name)
1154 /* initialize common driver fields */
1155 drv->driver.name = drv->name;
1156 drv->driver.bus = &pci_bus_type;
1157 drv->driver.owner = owner;
1158 drv->driver.mod_name = mod_name;
1160 spin_lock_init(&drv->dynids.lock);
1161 INIT_LIST_HEAD(&drv->dynids.list);
1163 /* register with core */
1164 error = driver_register(&drv->driver);
1168 error = pci_create_newid_files(drv);
1175 driver_unregister(&drv->driver);
1180 * pci_unregister_driver - unregister a pci driver
1181 * @drv: the driver structure to unregister
1183 * Deletes the driver structure from the list of registered PCI drivers,
1184 * gives it a chance to clean up by calling its remove() function for
1185 * each device it was responsible for, and marks those devices as
1190 pci_unregister_driver(struct pci_driver *drv)
1192 pci_remove_newid_files(drv);
1193 driver_unregister(&drv->driver);
1194 pci_free_dynids(drv);
1197 static struct pci_driver pci_compat_driver = {
1202 * pci_dev_driver - get the pci_driver of a device
1203 * @dev: the device to query
1205 * Returns the appropriate pci_driver structure or %NULL if there is no
1206 * registered driver for the device.
1209 pci_dev_driver(const struct pci_dev *dev)
1215 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1216 if (dev->resource[i].flags & IORESOURCE_BUSY)
1217 return &pci_compat_driver;
1223 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1224 * @dev: the PCI device structure to match against
1225 * @drv: the device driver to search for matching PCI device id structures
1227 * Used by a driver to check whether a PCI device present in the
1228 * system is in its list of supported devices. Returns the matching
1229 * pci_device_id structure or %NULL if there is no match.
1231 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1233 struct pci_dev *pci_dev = to_pci_dev(dev);
1234 struct pci_driver *pci_drv = to_pci_driver(drv);
1235 const struct pci_device_id *found_id;
1237 found_id = pci_match_device(pci_drv, pci_dev);
1245 * pci_dev_get - increments the reference count of the pci device structure
1246 * @dev: the device being referenced
1248 * Each live reference to a device should be refcounted.
1250 * Drivers for PCI devices should normally record such references in
1251 * their probe() methods, when they bind to a device, and release
1252 * them by calling pci_dev_put(), in their disconnect() methods.
1254 * A pointer to the device with the incremented reference counter is returned.
1256 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1259 get_device(&dev->dev);
1264 * pci_dev_put - release a use of the pci device structure
1265 * @dev: device that's been disconnected
1267 * Must be called when a user of a device is finished with it. When the last
1268 * user of the device calls this function, the memory of the device is freed.
1270 void pci_dev_put(struct pci_dev *dev)
1273 put_device(&dev->dev);
1276 #ifndef CONFIG_HOTPLUG
1277 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1283 struct bus_type pci_bus_type = {
1285 .match = pci_bus_match,
1286 .uevent = pci_uevent,
1287 .probe = pci_device_probe,
1288 .remove = pci_device_remove,
1289 .shutdown = pci_device_shutdown,
1290 .dev_attrs = pci_dev_attrs,
1291 .bus_attrs = pci_bus_attrs,
1292 .pm = PCI_PM_OPS_PTR,
1295 static int __init pci_driver_init(void)
1297 return bus_register(&pci_bus_type);
1300 postcore_initcall(pci_driver_init);
1302 EXPORT_SYMBOL_GPL(pci_add_dynid);
1303 EXPORT_SYMBOL(pci_match_id);
1304 EXPORT_SYMBOL(__pci_register_driver);
1305 EXPORT_SYMBOL(pci_unregister_driver);
1306 EXPORT_SYMBOL(pci_dev_driver);
1307 EXPORT_SYMBOL(pci_bus_type);
1308 EXPORT_SYMBOL(pci_dev_get);
1309 EXPORT_SYMBOL(pci_dev_put);