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;
357 if (drv && drv->suspend) {
358 i = drv->suspend(pci_dev, state);
359 suspend_report_result(drv->suspend, i);
361 pci_save_state(pci_dev);
363 * This is for compatibility with existing code with legacy PM
366 pci_pm_set_unknown_state(pci_dev);
369 pci_fixup_device(pci_fixup_suspend, pci_dev);
374 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
376 struct pci_dev * pci_dev = to_pci_dev(dev);
377 struct pci_driver * drv = pci_dev->driver;
380 if (drv && drv->suspend_late) {
381 i = drv->suspend_late(pci_dev, state);
382 suspend_report_result(drv->suspend_late, i);
387 static int pci_legacy_resume(struct device *dev)
390 struct pci_dev * pci_dev = to_pci_dev(dev);
391 struct pci_driver * drv = pci_dev->driver;
393 pci_fixup_device(pci_fixup_resume, pci_dev);
395 if (drv && drv->resume) {
396 error = drv->resume(pci_dev);
398 /* restore the PCI config space */
399 pci_restore_state(pci_dev);
400 error = pci_pm_reenable_device(pci_dev);
405 static int pci_legacy_resume_early(struct device *dev)
408 struct pci_dev * pci_dev = to_pci_dev(dev);
409 struct pci_driver * drv = pci_dev->driver;
411 pci_fixup_device(pci_fixup_resume_early, pci_dev);
413 if (drv && drv->resume_early)
414 error = drv->resume_early(pci_dev);
418 /* Auxiliary functions used by the new power management framework */
420 static int pci_restore_standard_config(struct pci_dev *pci_dev)
422 struct pci_dev *parent = pci_dev->bus->self;
425 /* Check if the device's bus is operational */
426 if (!parent || parent->current_state == PCI_D0) {
427 pci_restore_state(pci_dev);
428 pci_update_current_state(pci_dev, PCI_D0);
430 dev_warn(&pci_dev->dev, "unable to restore config, "
431 "bridge %s in low power state D%d\n", pci_name(parent),
432 parent->current_state);
433 pci_dev->current_state = PCI_UNKNOWN;
440 static bool pci_is_bridge(struct pci_dev *pci_dev)
442 return !!(pci_dev->subordinate);
445 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
447 if (pci_restore_standard_config(pci_dev))
448 pci_fixup_device(pci_fixup_resume_early, pci_dev);
451 static int pci_pm_default_resume(struct pci_dev *pci_dev)
454 * pci_restore_standard_config() should have been called once already,
455 * but it would have failed if the device's parent bridge had not been
456 * in power state D0 at that time. Check it and try again if necessary.
458 if (pci_dev->current_state == PCI_UNKNOWN) {
459 int error = pci_restore_standard_config(pci_dev);
464 pci_fixup_device(pci_fixup_resume, pci_dev);
466 if (!pci_is_bridge(pci_dev))
467 pci_enable_wake(pci_dev, PCI_D0, false);
469 return pci_pm_reenable_device(pci_dev);
472 static void pci_pm_default_suspend_generic(struct pci_dev *pci_dev)
474 /* If device is enabled at this point, disable it */
475 pci_disable_enabled_device(pci_dev);
477 * Save state with interrupts enabled, because in principle the bus the
478 * device is on may be put into a low power state after this code runs.
480 pci_save_state(pci_dev);
483 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
485 pci_pm_default_suspend_generic(pci_dev);
487 if (!pci_is_bridge(pci_dev))
488 pci_prepare_to_sleep(pci_dev);
491 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
493 struct pci_driver *drv = pci_dev->driver;
494 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
495 || drv->resume_early);
498 * Legacy PM support is used by default, so warn if the new framework is
499 * supported as well. Drivers are supposed to support either the
500 * former, or the latter, but not both at the same time.
502 WARN_ON(ret && drv->driver.pm);
507 /* New power management framework */
509 static int pci_pm_prepare(struct device *dev)
511 struct device_driver *drv = dev->driver;
514 if (drv && drv->pm && drv->pm->prepare)
515 error = drv->pm->prepare(dev);
520 static void pci_pm_complete(struct device *dev)
522 struct device_driver *drv = dev->driver;
524 if (drv && drv->pm && drv->pm->complete)
525 drv->pm->complete(dev);
528 #ifdef CONFIG_SUSPEND
530 static int pci_pm_suspend(struct device *dev)
532 struct pci_dev *pci_dev = to_pci_dev(dev);
533 struct device_driver *drv = dev->driver;
536 if (pci_has_legacy_pm_support(pci_dev))
537 return pci_legacy_suspend(dev, PMSG_SUSPEND);
539 if (drv && drv->pm) {
540 if (drv->pm->suspend) {
541 error = drv->pm->suspend(dev);
542 suspend_report_result(drv->pm->suspend, error);
545 pci_pm_default_suspend(pci_dev);
548 pci_fixup_device(pci_fixup_suspend, pci_dev);
553 static int pci_pm_suspend_noirq(struct device *dev)
555 struct pci_dev *pci_dev = to_pci_dev(dev);
556 struct device_driver *drv = dev->driver;
559 if (pci_has_legacy_pm_support(pci_dev))
560 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
562 if (drv && drv->pm) {
563 if (drv->pm->suspend_noirq) {
564 error = drv->pm->suspend_noirq(dev);
565 suspend_report_result(drv->pm->suspend_noirq, error);
568 pci_pm_set_unknown_state(pci_dev);
574 static int pci_pm_resume(struct device *dev)
576 struct pci_dev *pci_dev = to_pci_dev(dev);
577 struct device_driver *drv = dev->driver;
580 if (pci_has_legacy_pm_support(pci_dev))
581 return pci_legacy_resume(dev);
583 if (drv && drv->pm) {
584 pci_fixup_device(pci_fixup_resume, pci_dev);
587 error = drv->pm->resume(dev);
589 error = pci_pm_default_resume(pci_dev);
595 static int pci_pm_resume_noirq(struct device *dev)
597 struct pci_dev *pci_dev = to_pci_dev(dev);
598 struct device_driver *drv = dev->driver;
601 if (pci_has_legacy_pm_support(pci_dev))
602 return pci_legacy_resume_early(dev);
604 if (drv && drv->pm) {
605 pci_fixup_device(pci_fixup_resume_early, pci_dev);
607 if (drv->pm->resume_noirq)
608 error = drv->pm->resume_noirq(dev);
610 pci_pm_default_resume_noirq(pci_dev);
616 #else /* !CONFIG_SUSPEND */
618 #define pci_pm_suspend NULL
619 #define pci_pm_suspend_noirq NULL
620 #define pci_pm_resume NULL
621 #define pci_pm_resume_noirq NULL
623 #endif /* !CONFIG_SUSPEND */
625 #ifdef CONFIG_HIBERNATION
627 static int pci_pm_freeze(struct device *dev)
629 struct pci_dev *pci_dev = to_pci_dev(dev);
630 struct device_driver *drv = dev->driver;
633 if (pci_has_legacy_pm_support(pci_dev))
634 return pci_legacy_suspend(dev, PMSG_FREEZE);
636 if (drv && drv->pm) {
637 if (drv->pm->freeze) {
638 error = drv->pm->freeze(dev);
639 suspend_report_result(drv->pm->freeze, error);
642 pci_pm_default_suspend_generic(pci_dev);
648 static int pci_pm_freeze_noirq(struct device *dev)
650 struct pci_dev *pci_dev = to_pci_dev(dev);
651 struct device_driver *drv = dev->driver;
654 if (pci_has_legacy_pm_support(pci_dev))
655 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
657 if (drv && drv->pm) {
658 if (drv->pm->freeze_noirq) {
659 error = drv->pm->freeze_noirq(dev);
660 suspend_report_result(drv->pm->freeze_noirq, error);
663 pci_pm_set_unknown_state(pci_dev);
669 static int pci_pm_thaw(struct device *dev)
671 struct pci_dev *pci_dev = to_pci_dev(dev);
672 struct device_driver *drv = dev->driver;
675 if (pci_has_legacy_pm_support(pci_dev))
676 return pci_legacy_resume(dev);
678 if (drv && drv->pm) {
680 error = drv->pm->thaw(dev);
682 pci_pm_reenable_device(pci_dev);
688 static int pci_pm_thaw_noirq(struct device *dev)
690 struct pci_dev *pci_dev = to_pci_dev(dev);
691 struct device_driver *drv = dev->driver;
694 if (pci_has_legacy_pm_support(pci_dev))
695 return pci_legacy_resume_early(dev);
697 if (drv && drv->pm) {
698 if (drv->pm->thaw_noirq)
699 error = drv->pm->thaw_noirq(dev);
701 pci_update_current_state(pci_dev, PCI_D0);
707 static int pci_pm_poweroff(struct device *dev)
709 struct pci_dev *pci_dev = to_pci_dev(dev);
710 struct device_driver *drv = dev->driver;
713 if (pci_has_legacy_pm_support(pci_dev))
714 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
716 if (drv && drv->pm) {
717 if (drv->pm->poweroff) {
718 error = drv->pm->poweroff(dev);
719 suspend_report_result(drv->pm->poweroff, error);
722 pci_pm_default_suspend(pci_dev);
725 pci_fixup_device(pci_fixup_suspend, pci_dev);
730 static int pci_pm_poweroff_noirq(struct device *dev)
732 struct device_driver *drv = dev->driver;
735 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
736 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
738 if (drv && drv->pm) {
739 if (drv->pm->poweroff_noirq) {
740 error = drv->pm->poweroff_noirq(dev);
741 suspend_report_result(drv->pm->poweroff_noirq, error);
748 static int pci_pm_restore(struct device *dev)
750 struct pci_dev *pci_dev = to_pci_dev(dev);
751 struct device_driver *drv = dev->driver;
754 if (pci_has_legacy_pm_support(pci_dev))
755 return pci_legacy_resume(dev);
757 if (drv && drv->pm) {
758 pci_fixup_device(pci_fixup_resume, pci_dev);
760 if (drv->pm->restore)
761 error = drv->pm->restore(dev);
763 error = pci_pm_default_resume(pci_dev);
769 static int pci_pm_restore_noirq(struct device *dev)
771 struct pci_dev *pci_dev = to_pci_dev(dev);
772 struct device_driver *drv = dev->driver;
775 if (pci_has_legacy_pm_support(pci_dev))
776 return pci_legacy_resume_early(dev);
778 if (drv && drv->pm) {
779 pci_fixup_device(pci_fixup_resume_early, pci_dev);
781 if (drv->pm->restore_noirq)
782 error = drv->pm->restore_noirq(dev);
784 pci_pm_default_resume_noirq(pci_dev);
790 #else /* !CONFIG_HIBERNATION */
792 #define pci_pm_freeze NULL
793 #define pci_pm_freeze_noirq NULL
794 #define pci_pm_thaw NULL
795 #define pci_pm_thaw_noirq NULL
796 #define pci_pm_poweroff NULL
797 #define pci_pm_poweroff_noirq NULL
798 #define pci_pm_restore NULL
799 #define pci_pm_restore_noirq NULL
801 #endif /* !CONFIG_HIBERNATION */
803 struct dev_pm_ops pci_dev_pm_ops = {
804 .prepare = pci_pm_prepare,
805 .complete = pci_pm_complete,
806 .suspend = pci_pm_suspend,
807 .resume = pci_pm_resume,
808 .freeze = pci_pm_freeze,
810 .poweroff = pci_pm_poweroff,
811 .restore = pci_pm_restore,
812 .suspend_noirq = pci_pm_suspend_noirq,
813 .resume_noirq = pci_pm_resume_noirq,
814 .freeze_noirq = pci_pm_freeze_noirq,
815 .thaw_noirq = pci_pm_thaw_noirq,
816 .poweroff_noirq = pci_pm_poweroff_noirq,
817 .restore_noirq = pci_pm_restore_noirq,
820 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
822 #else /* !CONFIG_PM_SLEEP */
824 #define PCI_PM_OPS_PTR NULL
826 #endif /* !CONFIG_PM_SLEEP */
829 * __pci_register_driver - register a new pci driver
830 * @drv: the driver structure to register
831 * @owner: owner module of drv
832 * @mod_name: module name string
834 * Adds the driver structure to the list of registered drivers.
835 * Returns a negative value on error, otherwise 0.
836 * If no error occurred, the driver remains registered even if
837 * no device was claimed during registration.
839 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
840 const char *mod_name)
844 /* initialize common driver fields */
845 drv->driver.name = drv->name;
846 drv->driver.bus = &pci_bus_type;
847 drv->driver.owner = owner;
848 drv->driver.mod_name = mod_name;
850 spin_lock_init(&drv->dynids.lock);
851 INIT_LIST_HEAD(&drv->dynids.list);
853 /* register with core */
854 error = driver_register(&drv->driver);
858 error = pci_create_newid_file(drv);
860 driver_unregister(&drv->driver);
866 * pci_unregister_driver - unregister a pci driver
867 * @drv: the driver structure to unregister
869 * Deletes the driver structure from the list of registered PCI drivers,
870 * gives it a chance to clean up by calling its remove() function for
871 * each device it was responsible for, and marks those devices as
876 pci_unregister_driver(struct pci_driver *drv)
878 pci_remove_newid_file(drv);
879 driver_unregister(&drv->driver);
880 pci_free_dynids(drv);
883 static struct pci_driver pci_compat_driver = {
888 * pci_dev_driver - get the pci_driver of a device
889 * @dev: the device to query
891 * Returns the appropriate pci_driver structure or %NULL if there is no
892 * registered driver for the device.
895 pci_dev_driver(const struct pci_dev *dev)
901 for(i=0; i<=PCI_ROM_RESOURCE; i++)
902 if (dev->resource[i].flags & IORESOURCE_BUSY)
903 return &pci_compat_driver;
909 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
910 * @dev: the PCI device structure to match against
911 * @drv: the device driver to search for matching PCI device id structures
913 * Used by a driver to check whether a PCI device present in the
914 * system is in its list of supported devices. Returns the matching
915 * pci_device_id structure or %NULL if there is no match.
917 static int pci_bus_match(struct device *dev, struct device_driver *drv)
919 struct pci_dev *pci_dev = to_pci_dev(dev);
920 struct pci_driver *pci_drv = to_pci_driver(drv);
921 const struct pci_device_id *found_id;
923 found_id = pci_match_device(pci_drv, pci_dev);
931 * pci_dev_get - increments the reference count of the pci device structure
932 * @dev: the device being referenced
934 * Each live reference to a device should be refcounted.
936 * Drivers for PCI devices should normally record such references in
937 * their probe() methods, when they bind to a device, and release
938 * them by calling pci_dev_put(), in their disconnect() methods.
940 * A pointer to the device with the incremented reference counter is returned.
942 struct pci_dev *pci_dev_get(struct pci_dev *dev)
945 get_device(&dev->dev);
950 * pci_dev_put - release a use of the pci device structure
951 * @dev: device that's been disconnected
953 * Must be called when a user of a device is finished with it. When the last
954 * user of the device calls this function, the memory of the device is freed.
956 void pci_dev_put(struct pci_dev *dev)
959 put_device(&dev->dev);
962 #ifndef CONFIG_HOTPLUG
963 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
969 struct bus_type pci_bus_type = {
971 .match = pci_bus_match,
972 .uevent = pci_uevent,
973 .probe = pci_device_probe,
974 .remove = pci_device_remove,
975 .shutdown = pci_device_shutdown,
976 .dev_attrs = pci_dev_attrs,
977 .pm = PCI_PM_OPS_PTR,
980 static int __init pci_driver_init(void)
982 return bus_register(&pci_bus_type);
985 postcore_initcall(pci_driver_init);
987 EXPORT_SYMBOL(pci_match_id);
988 EXPORT_SYMBOL(__pci_register_driver);
989 EXPORT_SYMBOL(pci_unregister_driver);
990 EXPORT_SYMBOL(pci_dev_driver);
991 EXPORT_SYMBOL(pci_bus_type);
992 EXPORT_SYMBOL(pci_dev_get);
993 EXPORT_SYMBOL(pci_dev_put);