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>
23 struct list_head node;
24 struct pci_device_id id;
28 * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
29 * @drv: target pci driver
30 * @vendor: PCI vendor ID
31 * @device: PCI device ID
32 * @subvendor: PCI subvendor ID
33 * @subdevice: PCI subdevice ID
35 * @class_mask: PCI class mask
36 * @driver_data: private driver data
38 * Adds a new dynamic pci device ID to this driver and causes the
39 * driver to probe for all devices again. @drv must have been
40 * registered prior to calling this function.
43 * Does GFP_KERNEL allocation.
46 * 0 on success, -errno on failure.
48 int pci_add_dynid(struct pci_driver *drv,
49 unsigned int vendor, unsigned int device,
50 unsigned int subvendor, unsigned int subdevice,
51 unsigned int class, unsigned int class_mask,
52 unsigned long driver_data)
54 struct pci_dynid *dynid;
57 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
61 dynid->id.vendor = vendor;
62 dynid->id.device = device;
63 dynid->id.subvendor = subvendor;
64 dynid->id.subdevice = subdevice;
65 dynid->id.class = class;
66 dynid->id.class_mask = class_mask;
67 dynid->id.driver_data = driver_data;
69 spin_lock(&drv->dynids.lock);
70 list_add_tail(&dynid->node, &drv->dynids.list);
71 spin_unlock(&drv->dynids.lock);
73 get_driver(&drv->driver);
74 retval = driver_attach(&drv->driver);
75 put_driver(&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_file(struct pci_driver *drv)
194 if (drv->probe != NULL)
195 error = driver_create_file(&drv->driver, &driver_attr_new_id);
199 static void pci_remove_newid_file(struct pci_driver *drv)
201 driver_remove_file(&drv->driver, &driver_attr_new_id);
205 pci_create_removeid_file(struct pci_driver *drv)
208 if (drv->probe != NULL)
209 error = driver_create_file(&drv->driver,&driver_attr_remove_id);
213 static void pci_remove_removeid_file(struct pci_driver *drv)
215 driver_remove_file(&drv->driver, &driver_attr_remove_id);
217 #else /* !CONFIG_HOTPLUG */
218 static inline int pci_create_newid_file(struct pci_driver *drv)
222 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
223 static inline int pci_create_removeid_file(struct pci_driver *drv)
227 static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
231 * pci_match_id - See if a pci device matches a given pci_id table
232 * @ids: array of PCI device id structures to search in
233 * @dev: the PCI device structure to match against.
235 * Used by a driver to check whether a PCI device present in the
236 * system is in its list of supported devices. Returns the matching
237 * pci_device_id structure or %NULL if there is no match.
239 * Deprecated, don't use this as it will not catch any dynamic ids
240 * that a driver might want to check for.
242 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
246 while (ids->vendor || ids->subvendor || ids->class_mask) {
247 if (pci_match_one_device(ids, dev))
256 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
257 * @drv: the PCI driver to match against
258 * @dev: the PCI device structure to match against
260 * Used by a driver to check whether a PCI device present in the
261 * system is in its list of supported devices. Returns the matching
262 * pci_device_id structure or %NULL if there is no match.
264 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
267 struct pci_dynid *dynid;
269 /* Look at the dynamic ids first, before the static ones */
270 spin_lock(&drv->dynids.lock);
271 list_for_each_entry(dynid, &drv->dynids.list, node) {
272 if (pci_match_one_device(&dynid->id, dev)) {
273 spin_unlock(&drv->dynids.lock);
277 spin_unlock(&drv->dynids.lock);
279 return pci_match_id(drv->id_table, dev);
282 struct drv_dev_and_id {
283 struct pci_driver *drv;
285 const struct pci_device_id *id;
288 static long local_pci_probe(void *_ddi)
290 struct drv_dev_and_id *ddi = _ddi;
292 return ddi->drv->probe(ddi->dev, ddi->id);
295 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
296 const struct pci_device_id *id)
299 struct drv_dev_and_id ddi = { drv, dev, id };
301 /* Execute driver initialization on node where the device's
302 bus is attached to. This way the driver likely allocates
303 its local memory on the right node without any need to
305 node = dev_to_node(&dev->dev);
310 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
311 if (cpu < nr_cpu_ids)
312 error = work_on_cpu(cpu, local_pci_probe, &ddi);
314 error = local_pci_probe(&ddi);
317 error = local_pci_probe(&ddi);
322 * __pci_device_probe()
323 * @drv: driver to call to check if it wants the PCI device
324 * @pci_dev: PCI device being probed
326 * returns 0 on success, else error.
327 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
330 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
332 const struct pci_device_id *id;
335 if (!pci_dev->driver && drv->probe) {
338 id = pci_match_device(drv, pci_dev);
340 error = pci_call_probe(drv, pci_dev, id);
342 pci_dev->driver = drv;
349 static int pci_device_probe(struct device * dev)
352 struct pci_driver *drv;
353 struct pci_dev *pci_dev;
355 drv = to_pci_driver(dev->driver);
356 pci_dev = to_pci_dev(dev);
357 pci_dev_get(pci_dev);
358 error = __pci_device_probe(drv, pci_dev);
360 pci_dev_put(pci_dev);
365 static int pci_device_remove(struct device * dev)
367 struct pci_dev * pci_dev = to_pci_dev(dev);
368 struct pci_driver * drv = pci_dev->driver;
372 drv->remove(pci_dev);
373 pci_dev->driver = NULL;
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 #ifdef CONFIG_PM_SLEEP
410 * Default "suspend" method for devices that have no driver provided suspend,
411 * or not even a driver at all (second part).
413 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
416 * mark its power state as "unknown", since we don't know if
417 * e.g. the BIOS will change its device state when we suspend.
419 if (pci_dev->current_state == PCI_D0)
420 pci_dev->current_state = PCI_UNKNOWN;
424 * Default "resume" method for devices that have no driver provided resume,
425 * or not even a driver at all (second part).
427 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
431 /* if the device was enabled before suspend, reenable */
432 retval = pci_reenable_device(pci_dev);
434 * if the device was busmaster before the suspend, make it busmaster
437 if (pci_dev->is_busmaster)
438 pci_set_master(pci_dev);
443 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
445 struct pci_dev * pci_dev = to_pci_dev(dev);
446 struct pci_driver * drv = pci_dev->driver;
448 pci_dev->state_saved = false;
450 if (drv && drv->suspend) {
451 pci_power_t prev = pci_dev->current_state;
454 error = drv->suspend(pci_dev, state);
455 suspend_report_result(drv->suspend, error);
459 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
460 && pci_dev->current_state != PCI_UNKNOWN) {
461 WARN_ONCE(pci_dev->current_state != prev,
462 "PCI PM: Device state not saved by %pF\n",
467 pci_fixup_device(pci_fixup_suspend, pci_dev);
472 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
474 struct pci_dev * pci_dev = to_pci_dev(dev);
475 struct pci_driver * drv = pci_dev->driver;
477 if (drv && drv->suspend_late) {
478 pci_power_t prev = pci_dev->current_state;
481 error = drv->suspend_late(pci_dev, state);
482 suspend_report_result(drv->suspend_late, error);
486 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
487 && pci_dev->current_state != PCI_UNKNOWN) {
488 WARN_ONCE(pci_dev->current_state != prev,
489 "PCI PM: Device state not saved by %pF\n",
495 if (!pci_dev->state_saved)
496 pci_save_state(pci_dev);
498 pci_pm_set_unknown_state(pci_dev);
503 static int pci_legacy_resume_early(struct device *dev)
505 struct pci_dev * pci_dev = to_pci_dev(dev);
506 struct pci_driver * drv = pci_dev->driver;
508 return drv && drv->resume_early ?
509 drv->resume_early(pci_dev) : 0;
512 static int pci_legacy_resume(struct device *dev)
514 struct pci_dev * pci_dev = to_pci_dev(dev);
515 struct pci_driver * drv = pci_dev->driver;
517 pci_fixup_device(pci_fixup_resume, pci_dev);
519 return drv && drv->resume ?
520 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
523 /* Auxiliary functions used by the new power management framework */
526 * pci_restore_standard_config - restore standard config registers of PCI device
527 * @pci_dev: PCI device to handle
529 static int pci_restore_standard_config(struct pci_dev *pci_dev)
531 pci_update_current_state(pci_dev, PCI_UNKNOWN);
533 if (pci_dev->current_state != PCI_D0) {
534 int error = pci_set_power_state(pci_dev, PCI_D0);
539 return pci_restore_state(pci_dev);
542 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
544 pci_restore_standard_config(pci_dev);
545 pci_dev->state_saved = false;
546 pci_fixup_device(pci_fixup_resume_early, pci_dev);
549 static void pci_pm_default_resume(struct pci_dev *pci_dev)
551 pci_fixup_device(pci_fixup_resume, pci_dev);
553 if (!pci_is_bridge(pci_dev))
554 pci_enable_wake(pci_dev, PCI_D0, false);
557 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
559 /* Disable non-bridge devices without PM support */
560 if (!pci_is_bridge(pci_dev))
561 pci_disable_enabled_device(pci_dev);
564 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
566 struct pci_driver *drv = pci_dev->driver;
567 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
568 || drv->resume_early);
571 * Legacy PM support is used by default, so warn if the new framework is
572 * supported as well. Drivers are supposed to support either the
573 * former, or the latter, but not both at the same time.
575 WARN_ON(ret && drv->driver.pm);
580 /* New power management framework */
582 static int pci_pm_prepare(struct device *dev)
584 struct device_driver *drv = dev->driver;
587 if (drv && drv->pm && drv->pm->prepare)
588 error = drv->pm->prepare(dev);
593 static void pci_pm_complete(struct device *dev)
595 struct device_driver *drv = dev->driver;
597 if (drv && drv->pm && drv->pm->complete)
598 drv->pm->complete(dev);
601 #ifdef CONFIG_SUSPEND
603 static int pci_pm_suspend(struct device *dev)
605 struct pci_dev *pci_dev = to_pci_dev(dev);
606 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
608 if (pci_has_legacy_pm_support(pci_dev))
609 return pci_legacy_suspend(dev, PMSG_SUSPEND);
611 pci_dev->state_saved = false;
614 pci_pm_default_suspend(pci_dev);
619 pci_power_t prev = pci_dev->current_state;
622 error = pm->suspend(dev);
623 suspend_report_result(pm->suspend, error);
627 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
628 && pci_dev->current_state != PCI_UNKNOWN) {
629 WARN_ONCE(pci_dev->current_state != prev,
630 "PCI PM: State of device not saved by %pF\n",
636 pci_fixup_device(pci_fixup_suspend, pci_dev);
641 static int pci_pm_suspend_noirq(struct device *dev)
643 struct pci_dev *pci_dev = to_pci_dev(dev);
644 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
646 if (pci_has_legacy_pm_support(pci_dev))
647 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
650 pci_save_state(pci_dev);
654 if (pm->suspend_noirq) {
655 pci_power_t prev = pci_dev->current_state;
658 error = pm->suspend_noirq(dev);
659 suspend_report_result(pm->suspend_noirq, error);
663 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
664 && pci_dev->current_state != PCI_UNKNOWN) {
665 WARN_ONCE(pci_dev->current_state != prev,
666 "PCI PM: State of device not saved by %pF\n",
672 if (!pci_dev->state_saved) {
673 pci_save_state(pci_dev);
674 if (!pci_is_bridge(pci_dev))
675 pci_prepare_to_sleep(pci_dev);
678 pci_pm_set_unknown_state(pci_dev);
683 static int pci_pm_resume_noirq(struct device *dev)
685 struct pci_dev *pci_dev = to_pci_dev(dev);
686 struct device_driver *drv = dev->driver;
689 pci_pm_default_resume_noirq(pci_dev);
691 if (pci_has_legacy_pm_support(pci_dev))
692 return pci_legacy_resume_early(dev);
694 if (drv && drv->pm && drv->pm->resume_noirq)
695 error = drv->pm->resume_noirq(dev);
700 static int pci_pm_resume(struct device *dev)
702 struct pci_dev *pci_dev = to_pci_dev(dev);
703 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
707 * This is necessary for the suspend error path in which resume is
708 * called without restoring the standard config registers of the device.
710 if (pci_dev->state_saved)
711 pci_restore_standard_config(pci_dev);
713 if (pci_has_legacy_pm_support(pci_dev))
714 return pci_legacy_resume(dev);
716 pci_pm_default_resume(pci_dev);
720 error = pm->resume(dev);
722 pci_pm_reenable_device(pci_dev);
728 #else /* !CONFIG_SUSPEND */
730 #define pci_pm_suspend NULL
731 #define pci_pm_suspend_noirq NULL
732 #define pci_pm_resume NULL
733 #define pci_pm_resume_noirq NULL
735 #endif /* !CONFIG_SUSPEND */
737 #ifdef CONFIG_HIBERNATION
739 static int pci_pm_freeze(struct device *dev)
741 struct pci_dev *pci_dev = to_pci_dev(dev);
742 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
744 if (pci_has_legacy_pm_support(pci_dev))
745 return pci_legacy_suspend(dev, PMSG_FREEZE);
747 pci_dev->state_saved = false;
750 pci_pm_default_suspend(pci_dev);
757 error = pm->freeze(dev);
758 suspend_report_result(pm->freeze, error);
766 static int pci_pm_freeze_noirq(struct device *dev)
768 struct pci_dev *pci_dev = to_pci_dev(dev);
769 struct device_driver *drv = dev->driver;
771 if (pci_has_legacy_pm_support(pci_dev))
772 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
774 if (drv && drv->pm && drv->pm->freeze_noirq) {
777 error = drv->pm->freeze_noirq(dev);
778 suspend_report_result(drv->pm->freeze_noirq, error);
783 if (!pci_dev->state_saved)
784 pci_save_state(pci_dev);
786 pci_pm_set_unknown_state(pci_dev);
791 static int pci_pm_thaw_noirq(struct device *dev)
793 struct pci_dev *pci_dev = to_pci_dev(dev);
794 struct device_driver *drv = dev->driver;
797 if (pci_has_legacy_pm_support(pci_dev))
798 return pci_legacy_resume_early(dev);
800 pci_update_current_state(pci_dev, PCI_D0);
802 if (drv && drv->pm && drv->pm->thaw_noirq)
803 error = drv->pm->thaw_noirq(dev);
808 static int pci_pm_thaw(struct device *dev)
810 struct pci_dev *pci_dev = to_pci_dev(dev);
811 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
814 if (pci_has_legacy_pm_support(pci_dev))
815 return pci_legacy_resume(dev);
819 error = pm->thaw(dev);
821 pci_pm_reenable_device(pci_dev);
827 static int pci_pm_poweroff(struct device *dev)
829 struct pci_dev *pci_dev = to_pci_dev(dev);
830 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
832 if (pci_has_legacy_pm_support(pci_dev))
833 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
835 pci_dev->state_saved = false;
838 pci_pm_default_suspend(pci_dev);
845 error = pm->poweroff(dev);
846 suspend_report_result(pm->poweroff, error);
852 pci_fixup_device(pci_fixup_suspend, pci_dev);
857 static int pci_pm_poweroff_noirq(struct device *dev)
859 struct pci_dev *pci_dev = to_pci_dev(dev);
860 struct device_driver *drv = dev->driver;
862 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
863 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
865 if (!drv || !drv->pm)
868 if (drv->pm->poweroff_noirq) {
871 error = drv->pm->poweroff_noirq(dev);
872 suspend_report_result(drv->pm->poweroff_noirq, error);
877 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
878 pci_prepare_to_sleep(pci_dev);
883 static int pci_pm_restore_noirq(struct device *dev)
885 struct pci_dev *pci_dev = to_pci_dev(dev);
886 struct device_driver *drv = dev->driver;
889 pci_pm_default_resume_noirq(pci_dev);
891 if (pci_has_legacy_pm_support(pci_dev))
892 return pci_legacy_resume_early(dev);
894 if (drv && drv->pm && drv->pm->restore_noirq)
895 error = drv->pm->restore_noirq(dev);
900 static int pci_pm_restore(struct device *dev)
902 struct pci_dev *pci_dev = to_pci_dev(dev);
903 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
907 * This is necessary for the hibernation error path in which restore is
908 * called without restoring the standard config registers of the device.
910 if (pci_dev->state_saved)
911 pci_restore_standard_config(pci_dev);
913 if (pci_has_legacy_pm_support(pci_dev))
914 return pci_legacy_resume(dev);
916 pci_pm_default_resume(pci_dev);
920 error = pm->restore(dev);
922 pci_pm_reenable_device(pci_dev);
928 #else /* !CONFIG_HIBERNATION */
930 #define pci_pm_freeze NULL
931 #define pci_pm_freeze_noirq NULL
932 #define pci_pm_thaw NULL
933 #define pci_pm_thaw_noirq NULL
934 #define pci_pm_poweroff NULL
935 #define pci_pm_poweroff_noirq NULL
936 #define pci_pm_restore NULL
937 #define pci_pm_restore_noirq NULL
939 #endif /* !CONFIG_HIBERNATION */
941 struct dev_pm_ops pci_dev_pm_ops = {
942 .prepare = pci_pm_prepare,
943 .complete = pci_pm_complete,
944 .suspend = pci_pm_suspend,
945 .resume = pci_pm_resume,
946 .freeze = pci_pm_freeze,
948 .poweroff = pci_pm_poweroff,
949 .restore = pci_pm_restore,
950 .suspend_noirq = pci_pm_suspend_noirq,
951 .resume_noirq = pci_pm_resume_noirq,
952 .freeze_noirq = pci_pm_freeze_noirq,
953 .thaw_noirq = pci_pm_thaw_noirq,
954 .poweroff_noirq = pci_pm_poweroff_noirq,
955 .restore_noirq = pci_pm_restore_noirq,
958 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
960 #else /* !CONFIG_PM_SLEEP */
962 #define PCI_PM_OPS_PTR NULL
964 #endif /* !CONFIG_PM_SLEEP */
967 * __pci_register_driver - register a new pci driver
968 * @drv: the driver structure to register
969 * @owner: owner module of drv
970 * @mod_name: module name string
972 * Adds the driver structure to the list of registered drivers.
973 * Returns a negative value on error, otherwise 0.
974 * If no error occurred, the driver remains registered even if
975 * no device was claimed during registration.
977 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
978 const char *mod_name)
982 /* initialize common driver fields */
983 drv->driver.name = drv->name;
984 drv->driver.bus = &pci_bus_type;
985 drv->driver.owner = owner;
986 drv->driver.mod_name = mod_name;
988 spin_lock_init(&drv->dynids.lock);
989 INIT_LIST_HEAD(&drv->dynids.list);
991 /* register with core */
992 error = driver_register(&drv->driver);
996 error = pci_create_newid_file(drv);
1000 error = pci_create_removeid_file(drv);
1007 pci_remove_newid_file(drv);
1009 driver_unregister(&drv->driver);
1014 * pci_unregister_driver - unregister a pci driver
1015 * @drv: the driver structure to unregister
1017 * Deletes the driver structure from the list of registered PCI drivers,
1018 * gives it a chance to clean up by calling its remove() function for
1019 * each device it was responsible for, and marks those devices as
1024 pci_unregister_driver(struct pci_driver *drv)
1026 pci_remove_removeid_file(drv);
1027 pci_remove_newid_file(drv);
1028 driver_unregister(&drv->driver);
1029 pci_free_dynids(drv);
1032 static struct pci_driver pci_compat_driver = {
1037 * pci_dev_driver - get the pci_driver of a device
1038 * @dev: the device to query
1040 * Returns the appropriate pci_driver structure or %NULL if there is no
1041 * registered driver for the device.
1044 pci_dev_driver(const struct pci_dev *dev)
1050 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1051 if (dev->resource[i].flags & IORESOURCE_BUSY)
1052 return &pci_compat_driver;
1058 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1059 * @dev: the PCI device structure to match against
1060 * @drv: the device driver to search for matching PCI device id structures
1062 * Used by a driver to check whether a PCI device present in the
1063 * system is in its list of supported devices. Returns the matching
1064 * pci_device_id structure or %NULL if there is no match.
1066 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1068 struct pci_dev *pci_dev = to_pci_dev(dev);
1069 struct pci_driver *pci_drv = to_pci_driver(drv);
1070 const struct pci_device_id *found_id;
1072 found_id = pci_match_device(pci_drv, pci_dev);
1080 * pci_dev_get - increments the reference count of the pci device structure
1081 * @dev: the device being referenced
1083 * Each live reference to a device should be refcounted.
1085 * Drivers for PCI devices should normally record such references in
1086 * their probe() methods, when they bind to a device, and release
1087 * them by calling pci_dev_put(), in their disconnect() methods.
1089 * A pointer to the device with the incremented reference counter is returned.
1091 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1094 get_device(&dev->dev);
1099 * pci_dev_put - release a use of the pci device structure
1100 * @dev: device that's been disconnected
1102 * Must be called when a user of a device is finished with it. When the last
1103 * user of the device calls this function, the memory of the device is freed.
1105 void pci_dev_put(struct pci_dev *dev)
1108 put_device(&dev->dev);
1111 #ifndef CONFIG_HOTPLUG
1112 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1118 struct bus_type pci_bus_type = {
1120 .match = pci_bus_match,
1121 .uevent = pci_uevent,
1122 .probe = pci_device_probe,
1123 .remove = pci_device_remove,
1124 .shutdown = pci_device_shutdown,
1125 .dev_attrs = pci_dev_attrs,
1126 .bus_attrs = pci_bus_attrs,
1127 .pm = PCI_PM_OPS_PTR,
1130 static int __init pci_driver_init(void)
1132 return bus_register(&pci_bus_type);
1135 postcore_initcall(pci_driver_init);
1137 EXPORT_SYMBOL_GPL(pci_add_dynid);
1138 EXPORT_SYMBOL(pci_match_id);
1139 EXPORT_SYMBOL(__pci_register_driver);
1140 EXPORT_SYMBOL(pci_unregister_driver);
1141 EXPORT_SYMBOL(pci_dev_driver);
1142 EXPORT_SYMBOL(pci_bus_type);
1143 EXPORT_SYMBOL(pci_dev_get);
1144 EXPORT_SYMBOL(pci_dev_put);