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 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
27 struct list_head node;
28 struct pci_device_id id;
34 * store_new_id - add a new PCI device ID to this driver and re-probe devices
35 * @driver: target device driver
36 * @buf: buffer for scanning device ID data
39 * Adds a new dynamic pci device ID to this driver,
40 * and causes the driver to probe for all devices again.
43 store_new_id(struct device_driver *driver, const char *buf, size_t count)
45 struct pci_dynid *dynid;
46 struct pci_driver *pdrv = to_pci_driver(driver);
47 const struct pci_device_id *ids = pdrv->id_table;
48 __u32 vendor, device, subvendor=PCI_ANY_ID,
49 subdevice=PCI_ANY_ID, class=0, class_mask=0;
50 unsigned long driver_data=0;
54 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
55 &vendor, &device, &subvendor, &subdevice,
56 &class, &class_mask, &driver_data);
60 /* Only accept driver_data values that match an existing id_table
64 while (ids->vendor || ids->subvendor || ids->class_mask) {
65 if (driver_data == ids->driver_data) {
71 if (retval) /* No match */
75 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
79 dynid->id.vendor = vendor;
80 dynid->id.device = device;
81 dynid->id.subvendor = subvendor;
82 dynid->id.subdevice = subdevice;
83 dynid->id.class = class;
84 dynid->id.class_mask = class_mask;
85 dynid->id.driver_data = driver_data;
87 spin_lock(&pdrv->dynids.lock);
88 list_add_tail(&dynid->node, &pdrv->dynids.list);
89 spin_unlock(&pdrv->dynids.lock);
91 if (get_driver(&pdrv->driver)) {
92 retval = driver_attach(&pdrv->driver);
93 put_driver(&pdrv->driver);
100 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
103 pci_free_dynids(struct pci_driver *drv)
105 struct pci_dynid *dynid, *n;
107 spin_lock(&drv->dynids.lock);
108 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
109 list_del(&dynid->node);
112 spin_unlock(&drv->dynids.lock);
116 pci_create_newid_file(struct pci_driver *drv)
119 if (drv->probe != NULL)
120 error = driver_create_file(&drv->driver, &driver_attr_new_id);
124 static void pci_remove_newid_file(struct pci_driver *drv)
126 driver_remove_file(&drv->driver, &driver_attr_new_id);
128 #else /* !CONFIG_HOTPLUG */
129 static inline void pci_free_dynids(struct pci_driver *drv) {}
130 static inline int pci_create_newid_file(struct pci_driver *drv)
134 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
138 * pci_match_id - See if a pci device matches a given pci_id table
139 * @ids: array of PCI device id structures to search in
140 * @dev: the PCI device structure to match against.
142 * Used by a driver to check whether a PCI device present in the
143 * system is in its list of supported devices. Returns the matching
144 * pci_device_id structure or %NULL if there is no match.
146 * Deprecated, don't use this as it will not catch any dynamic ids
147 * that a driver might want to check for.
149 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
153 while (ids->vendor || ids->subvendor || ids->class_mask) {
154 if (pci_match_one_device(ids, dev))
163 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
164 * @drv: the PCI driver to match against
165 * @dev: the PCI device structure to match against
167 * Used by a driver to check whether a PCI device present in the
168 * system is in its list of supported devices. Returns the matching
169 * pci_device_id structure or %NULL if there is no match.
171 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
174 struct pci_dynid *dynid;
176 /* Look at the dynamic ids first, before the static ones */
177 spin_lock(&drv->dynids.lock);
178 list_for_each_entry(dynid, &drv->dynids.list, node) {
179 if (pci_match_one_device(&dynid->id, dev)) {
180 spin_unlock(&drv->dynids.lock);
184 spin_unlock(&drv->dynids.lock);
186 return pci_match_id(drv->id_table, dev);
189 struct drv_dev_and_id {
190 struct pci_driver *drv;
192 const struct pci_device_id *id;
195 static long local_pci_probe(void *_ddi)
197 struct drv_dev_and_id *ddi = _ddi;
199 return ddi->drv->probe(ddi->dev, ddi->id);
202 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
203 const struct pci_device_id *id)
206 struct drv_dev_and_id ddi = { drv, dev, id };
208 /* Execute driver initialization on node where the device's
209 bus is attached to. This way the driver likely allocates
210 its local memory on the right node without any need to
212 node = dev_to_node(&dev->dev);
215 node_to_cpumask_ptr(nodecpumask, node);
218 cpu = cpumask_any_and(nodecpumask, cpu_online_mask);
219 if (cpu < nr_cpu_ids)
220 error = work_on_cpu(cpu, local_pci_probe, &ddi);
222 error = local_pci_probe(&ddi);
225 error = local_pci_probe(&ddi);
230 * __pci_device_probe()
231 * @drv: driver to call to check if it wants the PCI device
232 * @pci_dev: PCI device being probed
234 * returns 0 on success, else error.
235 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
238 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
240 const struct pci_device_id *id;
243 if (!pci_dev->driver && drv->probe) {
246 id = pci_match_device(drv, pci_dev);
248 error = pci_call_probe(drv, pci_dev, id);
250 pci_dev->driver = drv;
257 static int pci_device_probe(struct device * dev)
260 struct pci_driver *drv;
261 struct pci_dev *pci_dev;
263 drv = to_pci_driver(dev->driver);
264 pci_dev = to_pci_dev(dev);
265 pci_dev_get(pci_dev);
266 error = __pci_device_probe(drv, pci_dev);
268 pci_dev_put(pci_dev);
273 static int pci_device_remove(struct device * dev)
275 struct pci_dev * pci_dev = to_pci_dev(dev);
276 struct pci_driver * drv = pci_dev->driver;
280 drv->remove(pci_dev);
281 pci_dev->driver = NULL;
285 * If the device is still on, set the power state as "unknown",
286 * since it might change by the next time we load the driver.
288 if (pci_dev->current_state == PCI_D0)
289 pci_dev->current_state = PCI_UNKNOWN;
292 * We would love to complain here if pci_dev->is_enabled is set, that
293 * the driver should have called pci_disable_device(), but the
294 * unfortunate fact is there are too many odd BIOS and bridge setups
295 * that don't like drivers doing that all of the time.
296 * Oh well, we can dream of sane hardware when we sleep, no matter how
297 * horrible the crap we have to deal with is when we are awake...
300 pci_dev_put(pci_dev);
304 static void pci_device_shutdown(struct device *dev)
306 struct pci_dev *pci_dev = to_pci_dev(dev);
307 struct pci_driver *drv = pci_dev->driver;
309 if (drv && drv->shutdown)
310 drv->shutdown(pci_dev);
311 pci_msi_shutdown(pci_dev);
312 pci_msix_shutdown(pci_dev);
315 #ifdef CONFIG_PM_SLEEP
318 * Default "suspend" method for devices that have no driver provided suspend,
319 * or not even a driver at all (second part).
321 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
324 * mark its power state as "unknown", since we don't know if
325 * e.g. the BIOS will change its device state when we suspend.
327 if (pci_dev->current_state == PCI_D0)
328 pci_dev->current_state = PCI_UNKNOWN;
332 * Default "resume" method for devices that have no driver provided resume,
333 * or not even a driver at all (second part).
335 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
339 /* if the device was enabled before suspend, reenable */
340 retval = pci_reenable_device(pci_dev);
342 * if the device was busmaster before the suspend, make it busmaster
345 if (pci_dev->is_busmaster)
346 pci_set_master(pci_dev);
351 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
353 struct pci_dev * pci_dev = to_pci_dev(dev);
354 struct pci_driver * drv = pci_dev->driver;
356 pci_dev->state_saved = false;
358 if (drv && drv->suspend) {
359 pci_power_t prev = pci_dev->current_state;
362 error = drv->suspend(pci_dev, state);
363 suspend_report_result(drv->suspend, error);
367 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
368 && pci_dev->current_state != PCI_UNKNOWN) {
369 WARN_ONCE(pci_dev->current_state != prev,
370 "PCI PM: Device state not saved by %pF\n",
375 pci_fixup_device(pci_fixup_suspend, pci_dev);
380 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
382 struct pci_dev * pci_dev = to_pci_dev(dev);
383 struct pci_driver * drv = pci_dev->driver;
385 if (drv && drv->suspend_late) {
386 pci_power_t prev = pci_dev->current_state;
389 error = drv->suspend_late(pci_dev, state);
390 suspend_report_result(drv->suspend_late, error);
394 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
395 && pci_dev->current_state != PCI_UNKNOWN) {
396 WARN_ONCE(pci_dev->current_state != prev,
397 "PCI PM: Device state not saved by %pF\n",
403 if (!pci_dev->state_saved)
404 pci_save_state(pci_dev);
406 pci_pm_set_unknown_state(pci_dev);
411 static int pci_legacy_resume_early(struct device *dev)
413 struct pci_dev * pci_dev = to_pci_dev(dev);
414 struct pci_driver * drv = pci_dev->driver;
416 return drv && drv->resume_early ?
417 drv->resume_early(pci_dev) : 0;
420 static int pci_legacy_resume(struct device *dev)
422 struct pci_dev * pci_dev = to_pci_dev(dev);
423 struct pci_driver * drv = pci_dev->driver;
425 pci_fixup_device(pci_fixup_resume, pci_dev);
427 return drv && drv->resume ?
428 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
431 /* Auxiliary functions used by the new power management framework */
434 * pci_restore_standard_config - restore standard config registers of PCI device
435 * @pci_dev: PCI device to handle
437 static int pci_restore_standard_config(struct pci_dev *pci_dev)
439 pci_update_current_state(pci_dev, PCI_UNKNOWN);
441 if (pci_dev->current_state != PCI_D0) {
442 int error = pci_set_power_state(pci_dev, PCI_D0);
447 return pci_dev->state_saved ? pci_restore_state(pci_dev) : 0;
450 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
452 pci_restore_standard_config(pci_dev);
453 pci_dev->state_saved = false;
454 pci_fixup_device(pci_fixup_resume_early, pci_dev);
457 static void pci_pm_default_resume(struct pci_dev *pci_dev)
459 pci_fixup_device(pci_fixup_resume, pci_dev);
461 if (!pci_is_bridge(pci_dev))
462 pci_enable_wake(pci_dev, PCI_D0, false);
465 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
467 /* Disable non-bridge devices without PM support */
468 if (!pci_is_bridge(pci_dev))
469 pci_disable_enabled_device(pci_dev);
472 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
474 struct pci_driver *drv = pci_dev->driver;
475 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
476 || drv->resume_early);
479 * Legacy PM support is used by default, so warn if the new framework is
480 * supported as well. Drivers are supposed to support either the
481 * former, or the latter, but not both at the same time.
483 WARN_ON(ret && drv->driver.pm);
488 /* New power management framework */
490 static int pci_pm_prepare(struct device *dev)
492 struct device_driver *drv = dev->driver;
495 if (drv && drv->pm && drv->pm->prepare)
496 error = drv->pm->prepare(dev);
501 static void pci_pm_complete(struct device *dev)
503 struct device_driver *drv = dev->driver;
505 if (drv && drv->pm && drv->pm->complete)
506 drv->pm->complete(dev);
509 #ifdef CONFIG_SUSPEND
511 static int pci_pm_suspend(struct device *dev)
513 struct pci_dev *pci_dev = to_pci_dev(dev);
514 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
516 if (pci_has_legacy_pm_support(pci_dev))
517 return pci_legacy_suspend(dev, PMSG_SUSPEND);
520 pci_pm_default_suspend(pci_dev);
524 pci_dev->state_saved = false;
527 pci_power_t prev = pci_dev->current_state;
530 error = pm->suspend(dev);
531 suspend_report_result(pm->suspend, error);
535 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
536 && pci_dev->current_state != PCI_UNKNOWN) {
537 WARN_ONCE(pci_dev->current_state != prev,
538 "PCI PM: State of device not saved by %pF\n",
544 pci_fixup_device(pci_fixup_suspend, pci_dev);
549 static int pci_pm_suspend_noirq(struct device *dev)
551 struct pci_dev *pci_dev = to_pci_dev(dev);
552 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
554 if (pci_has_legacy_pm_support(pci_dev))
555 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
560 if (pm->suspend_noirq) {
561 pci_power_t prev = pci_dev->current_state;
564 error = pm->suspend_noirq(dev);
565 suspend_report_result(pm->suspend_noirq, error);
569 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
570 && pci_dev->current_state != PCI_UNKNOWN) {
571 WARN_ONCE(pci_dev->current_state != prev,
572 "PCI PM: State of device not saved by %pF\n",
578 if (!pci_dev->state_saved) {
579 pci_save_state(pci_dev);
580 if (!pci_is_bridge(pci_dev))
581 pci_prepare_to_sleep(pci_dev);
584 pci_pm_set_unknown_state(pci_dev);
589 static int pci_pm_resume_noirq(struct device *dev)
591 struct pci_dev *pci_dev = to_pci_dev(dev);
592 struct device_driver *drv = dev->driver;
595 pci_pm_default_resume_noirq(pci_dev);
597 if (pci_has_legacy_pm_support(pci_dev))
598 return pci_legacy_resume_early(dev);
600 if (drv && drv->pm && drv->pm->resume_noirq)
601 error = drv->pm->resume_noirq(dev);
606 static int pci_pm_resume(struct device *dev)
608 struct pci_dev *pci_dev = to_pci_dev(dev);
609 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
613 * This is necessary for the suspend error path in which resume is
614 * called without restoring the standard config registers of the device.
616 if (pci_dev->state_saved)
617 pci_restore_standard_config(pci_dev);
619 if (pci_has_legacy_pm_support(pci_dev))
620 return pci_legacy_resume(dev);
622 pci_pm_default_resume(pci_dev);
626 error = pm->resume(dev);
628 pci_pm_reenable_device(pci_dev);
634 #else /* !CONFIG_SUSPEND */
636 #define pci_pm_suspend NULL
637 #define pci_pm_suspend_noirq NULL
638 #define pci_pm_resume NULL
639 #define pci_pm_resume_noirq NULL
641 #endif /* !CONFIG_SUSPEND */
643 #ifdef CONFIG_HIBERNATION
645 static int pci_pm_freeze(struct device *dev)
647 struct pci_dev *pci_dev = to_pci_dev(dev);
648 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
650 if (pci_has_legacy_pm_support(pci_dev))
651 return pci_legacy_suspend(dev, PMSG_FREEZE);
654 pci_pm_default_suspend(pci_dev);
658 pci_dev->state_saved = false;
663 error = pm->freeze(dev);
664 suspend_report_result(pm->freeze, error);
672 static int pci_pm_freeze_noirq(struct device *dev)
674 struct pci_dev *pci_dev = to_pci_dev(dev);
675 struct device_driver *drv = dev->driver;
677 if (pci_has_legacy_pm_support(pci_dev))
678 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
680 if (drv && drv->pm && drv->pm->freeze_noirq) {
683 error = drv->pm->freeze_noirq(dev);
684 suspend_report_result(drv->pm->freeze_noirq, error);
689 if (!pci_dev->state_saved)
690 pci_save_state(pci_dev);
692 pci_pm_set_unknown_state(pci_dev);
697 static int pci_pm_thaw_noirq(struct device *dev)
699 struct pci_dev *pci_dev = to_pci_dev(dev);
700 struct device_driver *drv = dev->driver;
703 if (pci_has_legacy_pm_support(pci_dev))
704 return pci_legacy_resume_early(dev);
706 pci_update_current_state(pci_dev, PCI_D0);
708 if (drv && drv->pm && drv->pm->thaw_noirq)
709 error = drv->pm->thaw_noirq(dev);
714 static int pci_pm_thaw(struct device *dev)
716 struct pci_dev *pci_dev = to_pci_dev(dev);
717 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
720 if (pci_has_legacy_pm_support(pci_dev))
721 return pci_legacy_resume(dev);
725 error = pm->thaw(dev);
727 pci_pm_reenable_device(pci_dev);
733 static int pci_pm_poweroff(struct device *dev)
735 struct pci_dev *pci_dev = to_pci_dev(dev);
736 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
738 if (pci_has_legacy_pm_support(pci_dev))
739 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
742 pci_pm_default_suspend(pci_dev);
746 pci_dev->state_saved = false;
751 error = pm->poweroff(dev);
752 suspend_report_result(pm->poweroff, error);
758 pci_fixup_device(pci_fixup_suspend, pci_dev);
763 static int pci_pm_poweroff_noirq(struct device *dev)
765 struct pci_dev *pci_dev = to_pci_dev(dev);
766 struct device_driver *drv = dev->driver;
768 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
769 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
771 if (!drv || !drv->pm)
774 if (drv->pm->poweroff_noirq) {
777 error = drv->pm->poweroff_noirq(dev);
778 suspend_report_result(drv->pm->poweroff_noirq, error);
783 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
784 pci_prepare_to_sleep(pci_dev);
789 static int pci_pm_restore_noirq(struct device *dev)
791 struct pci_dev *pci_dev = to_pci_dev(dev);
792 struct device_driver *drv = dev->driver;
795 pci_pm_default_resume_noirq(pci_dev);
797 if (pci_has_legacy_pm_support(pci_dev))
798 return pci_legacy_resume_early(dev);
800 if (drv && drv->pm && drv->pm->restore_noirq)
801 error = drv->pm->restore_noirq(dev);
806 static int pci_pm_restore(struct device *dev)
808 struct pci_dev *pci_dev = to_pci_dev(dev);
809 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
813 * This is necessary for the hibernation error path in which restore is
814 * called without restoring the standard config registers of the device.
816 if (pci_dev->state_saved)
817 pci_restore_standard_config(pci_dev);
819 if (pci_has_legacy_pm_support(pci_dev))
820 return pci_legacy_resume(dev);
822 pci_pm_default_resume(pci_dev);
826 error = pm->restore(dev);
828 pci_pm_reenable_device(pci_dev);
834 #else /* !CONFIG_HIBERNATION */
836 #define pci_pm_freeze NULL
837 #define pci_pm_freeze_noirq NULL
838 #define pci_pm_thaw NULL
839 #define pci_pm_thaw_noirq NULL
840 #define pci_pm_poweroff NULL
841 #define pci_pm_poweroff_noirq NULL
842 #define pci_pm_restore NULL
843 #define pci_pm_restore_noirq NULL
845 #endif /* !CONFIG_HIBERNATION */
847 struct dev_pm_ops pci_dev_pm_ops = {
848 .prepare = pci_pm_prepare,
849 .complete = pci_pm_complete,
850 .suspend = pci_pm_suspend,
851 .resume = pci_pm_resume,
852 .freeze = pci_pm_freeze,
854 .poweroff = pci_pm_poweroff,
855 .restore = pci_pm_restore,
856 .suspend_noirq = pci_pm_suspend_noirq,
857 .resume_noirq = pci_pm_resume_noirq,
858 .freeze_noirq = pci_pm_freeze_noirq,
859 .thaw_noirq = pci_pm_thaw_noirq,
860 .poweroff_noirq = pci_pm_poweroff_noirq,
861 .restore_noirq = pci_pm_restore_noirq,
864 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
866 #else /* !CONFIG_PM_SLEEP */
868 #define PCI_PM_OPS_PTR NULL
870 #endif /* !CONFIG_PM_SLEEP */
873 * __pci_register_driver - register a new pci driver
874 * @drv: the driver structure to register
875 * @owner: owner module of drv
876 * @mod_name: module name string
878 * Adds the driver structure to the list of registered drivers.
879 * Returns a negative value on error, otherwise 0.
880 * If no error occurred, the driver remains registered even if
881 * no device was claimed during registration.
883 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
884 const char *mod_name)
888 /* initialize common driver fields */
889 drv->driver.name = drv->name;
890 drv->driver.bus = &pci_bus_type;
891 drv->driver.owner = owner;
892 drv->driver.mod_name = mod_name;
894 spin_lock_init(&drv->dynids.lock);
895 INIT_LIST_HEAD(&drv->dynids.list);
897 /* register with core */
898 error = driver_register(&drv->driver);
902 error = pci_create_newid_file(drv);
904 driver_unregister(&drv->driver);
910 * pci_unregister_driver - unregister a pci driver
911 * @drv: the driver structure to unregister
913 * Deletes the driver structure from the list of registered PCI drivers,
914 * gives it a chance to clean up by calling its remove() function for
915 * each device it was responsible for, and marks those devices as
920 pci_unregister_driver(struct pci_driver *drv)
922 pci_remove_newid_file(drv);
923 driver_unregister(&drv->driver);
924 pci_free_dynids(drv);
927 static struct pci_driver pci_compat_driver = {
932 * pci_dev_driver - get the pci_driver of a device
933 * @dev: the device to query
935 * Returns the appropriate pci_driver structure or %NULL if there is no
936 * registered driver for the device.
939 pci_dev_driver(const struct pci_dev *dev)
945 for(i=0; i<=PCI_ROM_RESOURCE; i++)
946 if (dev->resource[i].flags & IORESOURCE_BUSY)
947 return &pci_compat_driver;
953 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
954 * @dev: the PCI device structure to match against
955 * @drv: the device driver to search for matching PCI device id structures
957 * Used by a driver to check whether a PCI device present in the
958 * system is in its list of supported devices. Returns the matching
959 * pci_device_id structure or %NULL if there is no match.
961 static int pci_bus_match(struct device *dev, struct device_driver *drv)
963 struct pci_dev *pci_dev = to_pci_dev(dev);
964 struct pci_driver *pci_drv = to_pci_driver(drv);
965 const struct pci_device_id *found_id;
967 found_id = pci_match_device(pci_drv, pci_dev);
975 * pci_dev_get - increments the reference count of the pci device structure
976 * @dev: the device being referenced
978 * Each live reference to a device should be refcounted.
980 * Drivers for PCI devices should normally record such references in
981 * their probe() methods, when they bind to a device, and release
982 * them by calling pci_dev_put(), in their disconnect() methods.
984 * A pointer to the device with the incremented reference counter is returned.
986 struct pci_dev *pci_dev_get(struct pci_dev *dev)
989 get_device(&dev->dev);
994 * pci_dev_put - release a use of the pci device structure
995 * @dev: device that's been disconnected
997 * Must be called when a user of a device is finished with it. When the last
998 * user of the device calls this function, the memory of the device is freed.
1000 void pci_dev_put(struct pci_dev *dev)
1003 put_device(&dev->dev);
1006 #ifndef CONFIG_HOTPLUG
1007 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1013 struct bus_type pci_bus_type = {
1015 .match = pci_bus_match,
1016 .uevent = pci_uevent,
1017 .probe = pci_device_probe,
1018 .remove = pci_device_remove,
1019 .shutdown = pci_device_shutdown,
1020 .dev_attrs = pci_dev_attrs,
1021 .pm = PCI_PM_OPS_PTR,
1024 static int __init pci_driver_init(void)
1026 return bus_register(&pci_bus_type);
1029 postcore_initcall(pci_driver_init);
1031 EXPORT_SYMBOL(pci_match_id);
1032 EXPORT_SYMBOL(__pci_register_driver);
1033 EXPORT_SYMBOL(pci_unregister_driver);
1034 EXPORT_SYMBOL(pci_dev_driver);
1035 EXPORT_SYMBOL(pci_bus_type);
1036 EXPORT_SYMBOL(pci_dev_get);
1037 EXPORT_SYMBOL(pci_dev_put);