IPVS: fix netns if reading ip_vs_* procfs entries
[linux-2.6/linux-mips.git] / drivers / pci / pci-driver.c
blobd86ea8b0113701ecbbcb26de06c20f6d60089510
1 /*
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.
9 */
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 "pci.h"
23 struct pci_dynid {
24 struct list_head node;
25 struct pci_device_id id;
28 /**
29 * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
30 * @drv: target pci driver
31 * @vendor: PCI vendor ID
32 * @device: PCI device ID
33 * @subvendor: PCI subvendor ID
34 * @subdevice: PCI subdevice ID
35 * @class: PCI class
36 * @class_mask: PCI class mask
37 * @driver_data: private driver data
39 * Adds a new dynamic pci device ID to this driver and causes the
40 * driver to probe for all devices again. @drv must have been
41 * registered prior to calling this function.
43 * CONTEXT:
44 * Does GFP_KERNEL allocation.
46 * RETURNS:
47 * 0 on success, -errno on failure.
49 int pci_add_dynid(struct pci_driver *drv,
50 unsigned int vendor, unsigned int device,
51 unsigned int subvendor, unsigned int subdevice,
52 unsigned int class, unsigned int class_mask,
53 unsigned long driver_data)
55 struct pci_dynid *dynid;
56 int retval;
58 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
59 if (!dynid)
60 return -ENOMEM;
62 dynid->id.vendor = vendor;
63 dynid->id.device = device;
64 dynid->id.subvendor = subvendor;
65 dynid->id.subdevice = subdevice;
66 dynid->id.class = class;
67 dynid->id.class_mask = class_mask;
68 dynid->id.driver_data = driver_data;
70 spin_lock(&drv->dynids.lock);
71 list_add_tail(&dynid->node, &drv->dynids.list);
72 spin_unlock(&drv->dynids.lock);
74 get_driver(&drv->driver);
75 retval = driver_attach(&drv->driver);
76 put_driver(&drv->driver);
78 return retval;
81 static void pci_free_dynids(struct pci_driver *drv)
83 struct pci_dynid *dynid, *n;
85 spin_lock(&drv->dynids.lock);
86 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
87 list_del(&dynid->node);
88 kfree(dynid);
90 spin_unlock(&drv->dynids.lock);
94 * Dynamic device ID manipulation via sysfs is disabled for !CONFIG_HOTPLUG
96 #ifdef CONFIG_HOTPLUG
97 /**
98 * store_new_id - sysfs frontend to pci_add_dynid()
99 * @driver: target device driver
100 * @buf: buffer for scanning device ID data
101 * @count: input size
103 * Allow PCI IDs to be added to an existing driver via sysfs.
105 static ssize_t
106 store_new_id(struct device_driver *driver, const char *buf, size_t count)
108 struct pci_driver *pdrv = to_pci_driver(driver);
109 const struct pci_device_id *ids = pdrv->id_table;
110 __u32 vendor, device, subvendor=PCI_ANY_ID,
111 subdevice=PCI_ANY_ID, class=0, class_mask=0;
112 unsigned long driver_data=0;
113 int fields=0;
114 int retval;
116 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
117 &vendor, &device, &subvendor, &subdevice,
118 &class, &class_mask, &driver_data);
119 if (fields < 2)
120 return -EINVAL;
122 /* Only accept driver_data values that match an existing id_table
123 entry */
124 if (ids) {
125 retval = -EINVAL;
126 while (ids->vendor || ids->subvendor || ids->class_mask) {
127 if (driver_data == ids->driver_data) {
128 retval = 0;
129 break;
131 ids++;
133 if (retval) /* No match */
134 return retval;
137 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
138 class, class_mask, driver_data);
139 if (retval)
140 return retval;
141 return count;
143 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
146 * store_remove_id - remove a PCI device ID from this driver
147 * @driver: target device driver
148 * @buf: buffer for scanning device ID data
149 * @count: input size
151 * Removes a dynamic pci device ID to this driver.
153 static ssize_t
154 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
156 struct pci_dynid *dynid, *n;
157 struct pci_driver *pdrv = to_pci_driver(driver);
158 __u32 vendor, device, subvendor = PCI_ANY_ID,
159 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
160 int fields = 0;
161 int retval = -ENODEV;
163 fields = sscanf(buf, "%x %x %x %x %x %x",
164 &vendor, &device, &subvendor, &subdevice,
165 &class, &class_mask);
166 if (fields < 2)
167 return -EINVAL;
169 spin_lock(&pdrv->dynids.lock);
170 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
171 struct pci_device_id *id = &dynid->id;
172 if ((id->vendor == vendor) &&
173 (id->device == device) &&
174 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
175 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
176 !((id->class ^ class) & class_mask)) {
177 list_del(&dynid->node);
178 kfree(dynid);
179 retval = 0;
180 break;
183 spin_unlock(&pdrv->dynids.lock);
185 if (retval)
186 return retval;
187 return count;
189 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
191 static int
192 pci_create_newid_file(struct pci_driver *drv)
194 int error = 0;
195 if (drv->probe != NULL)
196 error = driver_create_file(&drv->driver, &driver_attr_new_id);
197 return error;
200 static void pci_remove_newid_file(struct pci_driver *drv)
202 driver_remove_file(&drv->driver, &driver_attr_new_id);
205 static int
206 pci_create_removeid_file(struct pci_driver *drv)
208 int error = 0;
209 if (drv->probe != NULL)
210 error = driver_create_file(&drv->driver,&driver_attr_remove_id);
211 return error;
214 static void pci_remove_removeid_file(struct pci_driver *drv)
216 driver_remove_file(&drv->driver, &driver_attr_remove_id);
218 #else /* !CONFIG_HOTPLUG */
219 static inline int pci_create_newid_file(struct pci_driver *drv)
221 return 0;
223 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
224 static inline int pci_create_removeid_file(struct pci_driver *drv)
226 return 0;
228 static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
229 #endif
232 * pci_match_id - See if a pci device matches a given pci_id table
233 * @ids: array of PCI device id structures to search in
234 * @dev: the PCI device structure to match against.
236 * Used by a driver to check whether a PCI device present in the
237 * system is in its list of supported devices. Returns the matching
238 * pci_device_id structure or %NULL if there is no match.
240 * Deprecated, don't use this as it will not catch any dynamic ids
241 * that a driver might want to check for.
243 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
244 struct pci_dev *dev)
246 if (ids) {
247 while (ids->vendor || ids->subvendor || ids->class_mask) {
248 if (pci_match_one_device(ids, dev))
249 return ids;
250 ids++;
253 return NULL;
257 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
258 * @drv: the PCI driver to match against
259 * @dev: the PCI device structure to match against
261 * Used by a driver to check whether a PCI device present in the
262 * system is in its list of supported devices. Returns the matching
263 * pci_device_id structure or %NULL if there is no match.
265 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
266 struct pci_dev *dev)
268 struct pci_dynid *dynid;
270 /* Look at the dynamic ids first, before the static ones */
271 spin_lock(&drv->dynids.lock);
272 list_for_each_entry(dynid, &drv->dynids.list, node) {
273 if (pci_match_one_device(&dynid->id, dev)) {
274 spin_unlock(&drv->dynids.lock);
275 return &dynid->id;
278 spin_unlock(&drv->dynids.lock);
280 return pci_match_id(drv->id_table, dev);
283 struct drv_dev_and_id {
284 struct pci_driver *drv;
285 struct pci_dev *dev;
286 const struct pci_device_id *id;
289 static long local_pci_probe(void *_ddi)
291 struct drv_dev_and_id *ddi = _ddi;
292 struct device *dev = &ddi->dev->dev;
293 int rc;
295 /* Unbound PCI devices are always set to disabled and suspended.
296 * During probe, the device is set to enabled and active and the
297 * usage count is incremented. If the driver supports runtime PM,
298 * it should call pm_runtime_put_noidle() in its probe routine and
299 * pm_runtime_get_noresume() in its remove routine.
301 pm_runtime_get_noresume(dev);
302 pm_runtime_set_active(dev);
303 pm_runtime_enable(dev);
305 rc = ddi->drv->probe(ddi->dev, ddi->id);
306 if (rc) {
307 pm_runtime_disable(dev);
308 pm_runtime_set_suspended(dev);
309 pm_runtime_put_noidle(dev);
311 return rc;
314 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
315 const struct pci_device_id *id)
317 int error, node;
318 struct drv_dev_and_id ddi = { drv, dev, id };
320 /* Execute driver initialization on node where the device's
321 bus is attached to. This way the driver likely allocates
322 its local memory on the right node without any need to
323 change it. */
324 node = dev_to_node(&dev->dev);
325 if (node >= 0) {
326 int cpu;
328 get_online_cpus();
329 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
330 if (cpu < nr_cpu_ids)
331 error = work_on_cpu(cpu, local_pci_probe, &ddi);
332 else
333 error = local_pci_probe(&ddi);
334 put_online_cpus();
335 } else
336 error = local_pci_probe(&ddi);
337 return error;
341 * __pci_device_probe - check if a driver wants to claim a specific PCI device
342 * @drv: driver to call to check if it wants the PCI device
343 * @pci_dev: PCI device being probed
345 * returns 0 on success, else error.
346 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
348 static int
349 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
351 const struct pci_device_id *id;
352 int error = 0;
354 if (!pci_dev->driver && drv->probe) {
355 error = -ENODEV;
357 id = pci_match_device(drv, pci_dev);
358 if (id)
359 error = pci_call_probe(drv, pci_dev, id);
360 if (error >= 0) {
361 pci_dev->driver = drv;
362 error = 0;
365 return error;
368 static int pci_device_probe(struct device * dev)
370 int error = 0;
371 struct pci_driver *drv;
372 struct pci_dev *pci_dev;
374 drv = to_pci_driver(dev->driver);
375 pci_dev = to_pci_dev(dev);
376 pci_dev_get(pci_dev);
377 error = __pci_device_probe(drv, pci_dev);
378 if (error)
379 pci_dev_put(pci_dev);
381 return error;
384 static int pci_device_remove(struct device * dev)
386 struct pci_dev * pci_dev = to_pci_dev(dev);
387 struct pci_driver * drv = pci_dev->driver;
389 if (drv) {
390 if (drv->remove) {
391 pm_runtime_get_sync(dev);
392 drv->remove(pci_dev);
393 pm_runtime_put_noidle(dev);
395 pci_dev->driver = NULL;
398 /* Undo the runtime PM settings in local_pci_probe() */
399 pm_runtime_disable(dev);
400 pm_runtime_set_suspended(dev);
401 pm_runtime_put_noidle(dev);
404 * If the device is still on, set the power state as "unknown",
405 * since it might change by the next time we load the driver.
407 if (pci_dev->current_state == PCI_D0)
408 pci_dev->current_state = PCI_UNKNOWN;
411 * We would love to complain here if pci_dev->is_enabled is set, that
412 * the driver should have called pci_disable_device(), but the
413 * unfortunate fact is there are too many odd BIOS and bridge setups
414 * that don't like drivers doing that all of the time.
415 * Oh well, we can dream of sane hardware when we sleep, no matter how
416 * horrible the crap we have to deal with is when we are awake...
419 pci_dev_put(pci_dev);
420 return 0;
423 static void pci_device_shutdown(struct device *dev)
425 struct pci_dev *pci_dev = to_pci_dev(dev);
426 struct pci_driver *drv = pci_dev->driver;
428 if (drv && drv->shutdown)
429 drv->shutdown(pci_dev);
430 pci_msi_shutdown(pci_dev);
431 pci_msix_shutdown(pci_dev);
434 #ifdef CONFIG_PM
436 /* Auxiliary functions used for system resume and run-time resume. */
439 * pci_restore_standard_config - restore standard config registers of PCI device
440 * @pci_dev: PCI device to handle
442 static int pci_restore_standard_config(struct pci_dev *pci_dev)
444 pci_update_current_state(pci_dev, PCI_UNKNOWN);
446 if (pci_dev->current_state != PCI_D0) {
447 int error = pci_set_power_state(pci_dev, PCI_D0);
448 if (error)
449 return error;
452 pci_restore_state(pci_dev);
453 return 0;
456 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
458 pci_restore_standard_config(pci_dev);
459 pci_fixup_device(pci_fixup_resume_early, pci_dev);
462 #endif
464 #ifdef CONFIG_PM_SLEEP
467 * Default "suspend" method for devices that have no driver provided suspend,
468 * or not even a driver at all (second part).
470 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
473 * mark its power state as "unknown", since we don't know if
474 * e.g. the BIOS will change its device state when we suspend.
476 if (pci_dev->current_state == PCI_D0)
477 pci_dev->current_state = PCI_UNKNOWN;
481 * Default "resume" method for devices that have no driver provided resume,
482 * or not even a driver at all (second part).
484 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
486 int retval;
488 /* if the device was enabled before suspend, reenable */
489 retval = pci_reenable_device(pci_dev);
491 * if the device was busmaster before the suspend, make it busmaster
492 * again
494 if (pci_dev->is_busmaster)
495 pci_set_master(pci_dev);
497 return retval;
500 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
502 struct pci_dev * pci_dev = to_pci_dev(dev);
503 struct pci_driver * drv = pci_dev->driver;
505 if (drv && drv->suspend) {
506 pci_power_t prev = pci_dev->current_state;
507 int error;
509 error = drv->suspend(pci_dev, state);
510 suspend_report_result(drv->suspend, error);
511 if (error)
512 return error;
514 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
515 && pci_dev->current_state != PCI_UNKNOWN) {
516 WARN_ONCE(pci_dev->current_state != prev,
517 "PCI PM: Device state not saved by %pF\n",
518 drv->suspend);
522 pci_fixup_device(pci_fixup_suspend, pci_dev);
524 return 0;
527 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
529 struct pci_dev * pci_dev = to_pci_dev(dev);
530 struct pci_driver * drv = pci_dev->driver;
532 if (drv && drv->suspend_late) {
533 pci_power_t prev = pci_dev->current_state;
534 int error;
536 error = drv->suspend_late(pci_dev, state);
537 suspend_report_result(drv->suspend_late, error);
538 if (error)
539 return error;
541 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
542 && pci_dev->current_state != PCI_UNKNOWN) {
543 WARN_ONCE(pci_dev->current_state != prev,
544 "PCI PM: Device state not saved by %pF\n",
545 drv->suspend_late);
546 return 0;
550 if (!pci_dev->state_saved)
551 pci_save_state(pci_dev);
553 pci_pm_set_unknown_state(pci_dev);
555 return 0;
558 static int pci_legacy_resume_early(struct device *dev)
560 struct pci_dev * pci_dev = to_pci_dev(dev);
561 struct pci_driver * drv = pci_dev->driver;
563 return drv && drv->resume_early ?
564 drv->resume_early(pci_dev) : 0;
567 static int pci_legacy_resume(struct device *dev)
569 struct pci_dev * pci_dev = to_pci_dev(dev);
570 struct pci_driver * drv = pci_dev->driver;
572 pci_fixup_device(pci_fixup_resume, pci_dev);
574 return drv && drv->resume ?
575 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
578 /* Auxiliary functions used by the new power management framework */
580 static void pci_pm_default_resume(struct pci_dev *pci_dev)
582 pci_fixup_device(pci_fixup_resume, pci_dev);
584 if (!pci_is_bridge(pci_dev))
585 pci_enable_wake(pci_dev, PCI_D0, false);
588 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
590 /* Disable non-bridge devices without PM support */
591 if (!pci_is_bridge(pci_dev))
592 pci_disable_enabled_device(pci_dev);
595 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
597 struct pci_driver *drv = pci_dev->driver;
598 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
599 || drv->resume_early);
602 * Legacy PM support is used by default, so warn if the new framework is
603 * supported as well. Drivers are supposed to support either the
604 * former, or the latter, but not both at the same time.
606 WARN_ON(ret && drv->driver.pm);
608 return ret;
611 /* New power management framework */
613 static int pci_pm_prepare(struct device *dev)
615 struct device_driver *drv = dev->driver;
616 int error = 0;
619 * PCI devices suspended at run time need to be resumed at this
620 * point, because in general it is necessary to reconfigure them for
621 * system suspend. Namely, if the device is supposed to wake up the
622 * system from the sleep state, we may need to reconfigure it for this
623 * purpose. In turn, if the device is not supposed to wake up the
624 * system from the sleep state, we'll have to prevent it from signaling
625 * wake-up.
627 pm_runtime_resume(dev);
629 if (drv && drv->pm && drv->pm->prepare)
630 error = drv->pm->prepare(dev);
632 return error;
635 static void pci_pm_complete(struct device *dev)
637 struct device_driver *drv = dev->driver;
639 if (drv && drv->pm && drv->pm->complete)
640 drv->pm->complete(dev);
643 #else /* !CONFIG_PM_SLEEP */
645 #define pci_pm_prepare NULL
646 #define pci_pm_complete NULL
648 #endif /* !CONFIG_PM_SLEEP */
650 #ifdef CONFIG_SUSPEND
652 static int pci_pm_suspend(struct device *dev)
654 struct pci_dev *pci_dev = to_pci_dev(dev);
655 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
657 if (pci_has_legacy_pm_support(pci_dev))
658 return pci_legacy_suspend(dev, PMSG_SUSPEND);
660 if (!pm) {
661 pci_pm_default_suspend(pci_dev);
662 goto Fixup;
665 if (pm->suspend) {
666 pci_power_t prev = pci_dev->current_state;
667 int error;
669 error = pm->suspend(dev);
670 suspend_report_result(pm->suspend, error);
671 if (error)
672 return error;
674 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
675 && pci_dev->current_state != PCI_UNKNOWN) {
676 WARN_ONCE(pci_dev->current_state != prev,
677 "PCI PM: State of device not saved by %pF\n",
678 pm->suspend);
682 Fixup:
683 pci_fixup_device(pci_fixup_suspend, pci_dev);
685 return 0;
688 static int pci_pm_suspend_noirq(struct device *dev)
690 struct pci_dev *pci_dev = to_pci_dev(dev);
691 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
693 if (pci_has_legacy_pm_support(pci_dev))
694 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
696 if (!pm) {
697 pci_save_state(pci_dev);
698 return 0;
701 if (pm->suspend_noirq) {
702 pci_power_t prev = pci_dev->current_state;
703 int error;
705 error = pm->suspend_noirq(dev);
706 suspend_report_result(pm->suspend_noirq, error);
707 if (error)
708 return error;
710 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
711 && pci_dev->current_state != PCI_UNKNOWN) {
712 WARN_ONCE(pci_dev->current_state != prev,
713 "PCI PM: State of device not saved by %pF\n",
714 pm->suspend_noirq);
715 return 0;
719 if (!pci_dev->state_saved) {
720 pci_save_state(pci_dev);
721 if (!pci_is_bridge(pci_dev))
722 pci_prepare_to_sleep(pci_dev);
725 pci_pm_set_unknown_state(pci_dev);
727 return 0;
730 static int pci_pm_resume_noirq(struct device *dev)
732 struct pci_dev *pci_dev = to_pci_dev(dev);
733 struct device_driver *drv = dev->driver;
734 int error = 0;
736 pci_pm_default_resume_early(pci_dev);
738 if (pci_has_legacy_pm_support(pci_dev))
739 return pci_legacy_resume_early(dev);
741 if (drv && drv->pm && drv->pm->resume_noirq)
742 error = drv->pm->resume_noirq(dev);
744 return error;
747 static int pci_pm_resume(struct device *dev)
749 struct pci_dev *pci_dev = to_pci_dev(dev);
750 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
751 int error = 0;
754 * This is necessary for the suspend error path in which resume is
755 * called without restoring the standard config registers of the device.
757 if (pci_dev->state_saved)
758 pci_restore_standard_config(pci_dev);
760 if (pci_has_legacy_pm_support(pci_dev))
761 return pci_legacy_resume(dev);
763 pci_pm_default_resume(pci_dev);
765 if (pm) {
766 if (pm->resume)
767 error = pm->resume(dev);
768 } else {
769 pci_pm_reenable_device(pci_dev);
772 return error;
775 #else /* !CONFIG_SUSPEND */
777 #define pci_pm_suspend NULL
778 #define pci_pm_suspend_noirq NULL
779 #define pci_pm_resume NULL
780 #define pci_pm_resume_noirq NULL
782 #endif /* !CONFIG_SUSPEND */
784 #ifdef CONFIG_HIBERNATION
786 static int pci_pm_freeze(struct device *dev)
788 struct pci_dev *pci_dev = to_pci_dev(dev);
789 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
791 if (pci_has_legacy_pm_support(pci_dev))
792 return pci_legacy_suspend(dev, PMSG_FREEZE);
794 if (!pm) {
795 pci_pm_default_suspend(pci_dev);
796 return 0;
799 if (pm->freeze) {
800 int error;
802 error = pm->freeze(dev);
803 suspend_report_result(pm->freeze, error);
804 if (error)
805 return error;
808 return 0;
811 static int pci_pm_freeze_noirq(struct device *dev)
813 struct pci_dev *pci_dev = to_pci_dev(dev);
814 struct device_driver *drv = dev->driver;
816 if (pci_has_legacy_pm_support(pci_dev))
817 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
819 if (drv && drv->pm && drv->pm->freeze_noirq) {
820 int error;
822 error = drv->pm->freeze_noirq(dev);
823 suspend_report_result(drv->pm->freeze_noirq, error);
824 if (error)
825 return error;
828 if (!pci_dev->state_saved)
829 pci_save_state(pci_dev);
831 pci_pm_set_unknown_state(pci_dev);
833 return 0;
836 static int pci_pm_thaw_noirq(struct device *dev)
838 struct pci_dev *pci_dev = to_pci_dev(dev);
839 struct device_driver *drv = dev->driver;
840 int error = 0;
842 if (pci_has_legacy_pm_support(pci_dev))
843 return pci_legacy_resume_early(dev);
845 pci_update_current_state(pci_dev, PCI_D0);
847 if (drv && drv->pm && drv->pm->thaw_noirq)
848 error = drv->pm->thaw_noirq(dev);
850 return error;
853 static int pci_pm_thaw(struct device *dev)
855 struct pci_dev *pci_dev = to_pci_dev(dev);
856 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
857 int error = 0;
859 if (pci_has_legacy_pm_support(pci_dev))
860 return pci_legacy_resume(dev);
862 if (pm) {
863 if (pm->thaw)
864 error = pm->thaw(dev);
865 } else {
866 pci_pm_reenable_device(pci_dev);
869 pci_dev->state_saved = false;
871 return error;
874 static int pci_pm_poweroff(struct device *dev)
876 struct pci_dev *pci_dev = to_pci_dev(dev);
877 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
879 if (pci_has_legacy_pm_support(pci_dev))
880 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
882 if (!pm) {
883 pci_pm_default_suspend(pci_dev);
884 goto Fixup;
887 if (pm->poweroff) {
888 int error;
890 error = pm->poweroff(dev);
891 suspend_report_result(pm->poweroff, error);
892 if (error)
893 return error;
896 Fixup:
897 pci_fixup_device(pci_fixup_suspend, pci_dev);
899 return 0;
902 static int pci_pm_poweroff_noirq(struct device *dev)
904 struct pci_dev *pci_dev = to_pci_dev(dev);
905 struct device_driver *drv = dev->driver;
907 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
908 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
910 if (!drv || !drv->pm)
911 return 0;
913 if (drv->pm->poweroff_noirq) {
914 int error;
916 error = drv->pm->poweroff_noirq(dev);
917 suspend_report_result(drv->pm->poweroff_noirq, error);
918 if (error)
919 return error;
922 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
923 pci_prepare_to_sleep(pci_dev);
925 return 0;
928 static int pci_pm_restore_noirq(struct device *dev)
930 struct pci_dev *pci_dev = to_pci_dev(dev);
931 struct device_driver *drv = dev->driver;
932 int error = 0;
934 pci_pm_default_resume_early(pci_dev);
936 if (pci_has_legacy_pm_support(pci_dev))
937 return pci_legacy_resume_early(dev);
939 if (drv && drv->pm && drv->pm->restore_noirq)
940 error = drv->pm->restore_noirq(dev);
942 return error;
945 static int pci_pm_restore(struct device *dev)
947 struct pci_dev *pci_dev = to_pci_dev(dev);
948 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
949 int error = 0;
952 * This is necessary for the hibernation error path in which restore is
953 * called without restoring the standard config registers of the device.
955 if (pci_dev->state_saved)
956 pci_restore_standard_config(pci_dev);
958 if (pci_has_legacy_pm_support(pci_dev))
959 return pci_legacy_resume(dev);
961 pci_pm_default_resume(pci_dev);
963 if (pm) {
964 if (pm->restore)
965 error = pm->restore(dev);
966 } else {
967 pci_pm_reenable_device(pci_dev);
970 return error;
973 #else /* !CONFIG_HIBERNATION */
975 #define pci_pm_freeze NULL
976 #define pci_pm_freeze_noirq NULL
977 #define pci_pm_thaw NULL
978 #define pci_pm_thaw_noirq NULL
979 #define pci_pm_poweroff NULL
980 #define pci_pm_poweroff_noirq NULL
981 #define pci_pm_restore NULL
982 #define pci_pm_restore_noirq NULL
984 #endif /* !CONFIG_HIBERNATION */
986 #ifdef CONFIG_PM_RUNTIME
988 static int pci_pm_runtime_suspend(struct device *dev)
990 struct pci_dev *pci_dev = to_pci_dev(dev);
991 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
992 pci_power_t prev = pci_dev->current_state;
993 int error;
995 if (!pm || !pm->runtime_suspend)
996 return -ENOSYS;
998 error = pm->runtime_suspend(dev);
999 suspend_report_result(pm->runtime_suspend, error);
1000 if (error)
1001 return error;
1003 pci_fixup_device(pci_fixup_suspend, pci_dev);
1005 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1006 && pci_dev->current_state != PCI_UNKNOWN) {
1007 WARN_ONCE(pci_dev->current_state != prev,
1008 "PCI PM: State of device not saved by %pF\n",
1009 pm->runtime_suspend);
1010 return 0;
1013 if (!pci_dev->state_saved)
1014 pci_save_state(pci_dev);
1016 pci_finish_runtime_suspend(pci_dev);
1018 return 0;
1021 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;
1026 if (!pm || !pm->runtime_resume)
1027 return -ENOSYS;
1029 pci_pm_default_resume_early(pci_dev);
1030 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1031 pci_fixup_device(pci_fixup_resume, pci_dev);
1033 return pm->runtime_resume(dev);
1036 static int pci_pm_runtime_idle(struct device *dev)
1038 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1040 if (!pm)
1041 return -ENOSYS;
1043 if (pm->runtime_idle) {
1044 int ret = pm->runtime_idle(dev);
1045 if (ret)
1046 return ret;
1049 pm_runtime_suspend(dev);
1051 return 0;
1054 #else /* !CONFIG_PM_RUNTIME */
1056 #define pci_pm_runtime_suspend NULL
1057 #define pci_pm_runtime_resume NULL
1058 #define pci_pm_runtime_idle NULL
1060 #endif /* !CONFIG_PM_RUNTIME */
1062 #ifdef CONFIG_PM
1064 const struct dev_pm_ops pci_dev_pm_ops = {
1065 .prepare = pci_pm_prepare,
1066 .complete = pci_pm_complete,
1067 .suspend = pci_pm_suspend,
1068 .resume = pci_pm_resume,
1069 .freeze = pci_pm_freeze,
1070 .thaw = pci_pm_thaw,
1071 .poweroff = pci_pm_poweroff,
1072 .restore = pci_pm_restore,
1073 .suspend_noirq = pci_pm_suspend_noirq,
1074 .resume_noirq = pci_pm_resume_noirq,
1075 .freeze_noirq = pci_pm_freeze_noirq,
1076 .thaw_noirq = pci_pm_thaw_noirq,
1077 .poweroff_noirq = pci_pm_poweroff_noirq,
1078 .restore_noirq = pci_pm_restore_noirq,
1079 .runtime_suspend = pci_pm_runtime_suspend,
1080 .runtime_resume = pci_pm_runtime_resume,
1081 .runtime_idle = pci_pm_runtime_idle,
1084 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1086 #else /* !COMFIG_PM_OPS */
1088 #define PCI_PM_OPS_PTR NULL
1090 #endif /* !COMFIG_PM_OPS */
1093 * __pci_register_driver - register a new pci driver
1094 * @drv: the driver structure to register
1095 * @owner: owner module of drv
1096 * @mod_name: module name string
1098 * Adds the driver structure to the list of registered drivers.
1099 * Returns a negative value on error, otherwise 0.
1100 * If no error occurred, the driver remains registered even if
1101 * no device was claimed during registration.
1103 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1104 const char *mod_name)
1106 int error;
1108 /* initialize common driver fields */
1109 drv->driver.name = drv->name;
1110 drv->driver.bus = &pci_bus_type;
1111 drv->driver.owner = owner;
1112 drv->driver.mod_name = mod_name;
1114 spin_lock_init(&drv->dynids.lock);
1115 INIT_LIST_HEAD(&drv->dynids.list);
1117 /* register with core */
1118 error = driver_register(&drv->driver);
1119 if (error)
1120 goto out;
1122 error = pci_create_newid_file(drv);
1123 if (error)
1124 goto out_newid;
1126 error = pci_create_removeid_file(drv);
1127 if (error)
1128 goto out_removeid;
1129 out:
1130 return error;
1132 out_removeid:
1133 pci_remove_newid_file(drv);
1134 out_newid:
1135 driver_unregister(&drv->driver);
1136 goto out;
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
1146 * driverless.
1149 void
1150 pci_unregister_driver(struct pci_driver *drv)
1152 pci_remove_removeid_file(drv);
1153 pci_remove_newid_file(drv);
1154 driver_unregister(&drv->driver);
1155 pci_free_dynids(drv);
1158 static struct pci_driver pci_compat_driver = {
1159 .name = "compat"
1163 * pci_dev_driver - get the pci_driver of a device
1164 * @dev: the device to query
1166 * Returns the appropriate pci_driver structure or %NULL if there is no
1167 * registered driver for the device.
1169 struct pci_driver *
1170 pci_dev_driver(const struct pci_dev *dev)
1172 if (dev->driver)
1173 return dev->driver;
1174 else {
1175 int i;
1176 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1177 if (dev->resource[i].flags & IORESOURCE_BUSY)
1178 return &pci_compat_driver;
1180 return NULL;
1184 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1185 * @dev: the PCI device structure to match against
1186 * @drv: the device driver to search for matching PCI device id structures
1188 * Used by a driver to check whether a PCI device present in the
1189 * system is in its list of supported devices. Returns the matching
1190 * pci_device_id structure or %NULL if there is no match.
1192 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1194 struct pci_dev *pci_dev = to_pci_dev(dev);
1195 struct pci_driver *pci_drv = to_pci_driver(drv);
1196 const struct pci_device_id *found_id;
1198 found_id = pci_match_device(pci_drv, pci_dev);
1199 if (found_id)
1200 return 1;
1202 return 0;
1206 * pci_dev_get - increments the reference count of the pci device structure
1207 * @dev: the device being referenced
1209 * Each live reference to a device should be refcounted.
1211 * Drivers for PCI devices should normally record such references in
1212 * their probe() methods, when they bind to a device, and release
1213 * them by calling pci_dev_put(), in their disconnect() methods.
1215 * A pointer to the device with the incremented reference counter is returned.
1217 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1219 if (dev)
1220 get_device(&dev->dev);
1221 return dev;
1225 * pci_dev_put - release a use of the pci device structure
1226 * @dev: device that's been disconnected
1228 * Must be called when a user of a device is finished with it. When the last
1229 * user of the device calls this function, the memory of the device is freed.
1231 void pci_dev_put(struct pci_dev *dev)
1233 if (dev)
1234 put_device(&dev->dev);
1237 #ifndef CONFIG_HOTPLUG
1238 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1240 return -ENODEV;
1242 #endif
1244 struct bus_type pci_bus_type = {
1245 .name = "pci",
1246 .match = pci_bus_match,
1247 .uevent = pci_uevent,
1248 .probe = pci_device_probe,
1249 .remove = pci_device_remove,
1250 .shutdown = pci_device_shutdown,
1251 .dev_attrs = pci_dev_attrs,
1252 .bus_attrs = pci_bus_attrs,
1253 .pm = PCI_PM_OPS_PTR,
1256 static int __init pci_driver_init(void)
1258 return bus_register(&pci_bus_type);
1261 postcore_initcall(pci_driver_init);
1263 EXPORT_SYMBOL_GPL(pci_add_dynid);
1264 EXPORT_SYMBOL(pci_match_id);
1265 EXPORT_SYMBOL(__pci_register_driver);
1266 EXPORT_SYMBOL(pci_unregister_driver);
1267 EXPORT_SYMBOL(pci_dev_driver);
1268 EXPORT_SYMBOL(pci_bus_type);
1269 EXPORT_SYMBOL(pci_dev_get);
1270 EXPORT_SYMBOL(pci_dev_put);