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
317 static bool pci_has_legacy_pm_support(struct pci_dev
*pci_dev
)
319 struct pci_driver
*drv
= pci_dev
->driver
;
321 return drv
&& (drv
->suspend
|| drv
->suspend_late
|| drv
->resume
322 || drv
->resume_early
);
326 * Default "suspend" method for devices that have no driver provided suspend,
327 * or not even a driver at all (first part).
329 static void pci_default_pm_suspend_early(struct pci_dev
*pci_dev
)
331 /* If device is enabled at this point, disable it */
332 pci_disable_enabled_device(pci_dev
);
336 * Default "suspend" method for devices that have no driver provided suspend,
337 * or not even a driver at all (second part).
339 static void pci_default_pm_suspend_late(struct pci_dev
*pci_dev
)
341 pci_save_state(pci_dev
);
343 * mark its power state as "unknown", since we don't know if
344 * e.g. the BIOS will change its device state when we suspend.
346 if (pci_dev
->current_state
== PCI_D0
)
347 pci_dev
->current_state
= PCI_UNKNOWN
;
351 * Default "resume" method for devices that have no driver provided resume,
352 * or not even a driver at all (first part).
354 static void pci_default_pm_resume_early(struct pci_dev
*pci_dev
)
356 /* restore the PCI config space */
357 pci_restore_state(pci_dev
);
361 * Default "resume" method for devices that have no driver provided resume,
362 * or not even a driver at all (second part).
364 static int pci_default_pm_resume_late(struct pci_dev
*pci_dev
)
368 /* if the device was enabled before suspend, reenable */
369 retval
= pci_reenable_device(pci_dev
);
371 * if the device was busmaster before the suspend, make it busmaster
374 if (pci_dev
->is_busmaster
)
375 pci_set_master(pci_dev
);
380 static int pci_legacy_suspend(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
;
386 if (drv
&& drv
->suspend
) {
387 i
= drv
->suspend(pci_dev
, state
);
388 suspend_report_result(drv
->suspend
, i
);
391 * For compatibility with existing code with legacy PM support
392 * don't call pci_default_pm_suspend_early() here.
394 pci_default_pm_suspend_late(pci_dev
);
399 static int pci_legacy_suspend_late(struct device
*dev
, pm_message_t state
)
401 struct pci_dev
* pci_dev
= to_pci_dev(dev
);
402 struct pci_driver
* drv
= pci_dev
->driver
;
405 if (drv
&& drv
->suspend_late
) {
406 i
= drv
->suspend_late(pci_dev
, state
);
407 suspend_report_result(drv
->suspend_late
, i
);
412 static int pci_legacy_resume(struct device
*dev
)
415 struct pci_dev
* pci_dev
= to_pci_dev(dev
);
416 struct pci_driver
* drv
= pci_dev
->driver
;
418 if (drv
&& drv
->resume
) {
419 error
= drv
->resume(pci_dev
);
421 pci_default_pm_resume_early(pci_dev
);
422 error
= pci_default_pm_resume_late(pci_dev
);
427 static int pci_legacy_resume_early(struct device
*dev
)
430 struct pci_dev
* pci_dev
= to_pci_dev(dev
);
431 struct pci_driver
* drv
= pci_dev
->driver
;
433 if (drv
&& drv
->resume_early
)
434 error
= drv
->resume_early(pci_dev
);
438 /* Auxiliary functions used by the new power management framework */
440 static bool pci_is_bridge(struct pci_dev
*pci_dev
)
442 return !!(pci_dev
->subordinate
);
445 static int pci_pm_default_resume(struct pci_dev
*pci_dev
)
447 if (!pci_is_bridge(pci_dev
))
448 pci_enable_wake(pci_dev
, PCI_D0
, false);
450 return pci_default_pm_resume_late(pci_dev
);
453 static void pci_pm_default_suspend(struct pci_dev
*pci_dev
)
455 pci_default_pm_suspend_early(pci_dev
);
457 if (!pci_is_bridge(pci_dev
))
458 pci_prepare_to_sleep(pci_dev
);
461 /* New power management framework */
463 static int pci_pm_prepare(struct device
*dev
)
465 struct device_driver
*drv
= dev
->driver
;
468 if (drv
&& drv
->pm
&& drv
->pm
->prepare
)
469 error
= drv
->pm
->prepare(dev
);
474 static void pci_pm_complete(struct device
*dev
)
476 struct device_driver
*drv
= dev
->driver
;
478 if (drv
&& drv
->pm
&& drv
->pm
->complete
)
479 drv
->pm
->complete(dev
);
482 #ifdef CONFIG_SUSPEND
484 static int pci_pm_suspend(struct device
*dev
)
486 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
487 struct device_driver
*drv
= dev
->driver
;
490 if (drv
&& drv
->pm
) {
491 if (drv
->pm
->suspend
) {
492 error
= drv
->pm
->suspend(dev
);
493 suspend_report_result(drv
->pm
->suspend
, error
);
495 } else if (pci_has_legacy_pm_support(pci_dev
)) {
496 error
= pci_legacy_suspend(dev
, PMSG_SUSPEND
);
498 pci_pm_default_suspend(pci_dev
);
501 pci_fixup_device(pci_fixup_suspend
, pci_dev
);
506 static int pci_pm_suspend_noirq(struct device
*dev
)
508 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
509 struct device_driver
*drv
= dev
->driver
;
512 if (drv
&& drv
->pm
) {
513 if (drv
->pm
->suspend_noirq
) {
514 error
= drv
->pm
->suspend_noirq(dev
);
515 suspend_report_result(drv
->pm
->suspend_noirq
, error
);
517 } else if (pci_has_legacy_pm_support(pci_dev
)) {
518 error
= pci_legacy_suspend_late(dev
, PMSG_SUSPEND
);
520 pci_default_pm_suspend_late(pci_dev
);
526 static int pci_pm_resume(struct device
*dev
)
528 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
529 struct device_driver
*drv
= dev
->driver
;
532 pci_fixup_device(pci_fixup_resume
, pci_dev
);
534 if (drv
&& drv
->pm
) {
536 error
= drv
->pm
->resume(dev
);
537 } else if (pci_has_legacy_pm_support(pci_dev
)) {
538 error
= pci_legacy_resume(dev
);
540 error
= pci_pm_default_resume(pci_dev
);
546 static int pci_pm_resume_noirq(struct device
*dev
)
548 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
549 struct device_driver
*drv
= dev
->driver
;
552 pci_fixup_device(pci_fixup_resume_early
, to_pci_dev(dev
));
554 if (drv
&& drv
->pm
) {
555 if (drv
->pm
->resume_noirq
)
556 error
= drv
->pm
->resume_noirq(dev
);
557 } else if (pci_has_legacy_pm_support(pci_dev
)) {
558 error
= pci_legacy_resume_early(dev
);
560 pci_default_pm_resume_early(pci_dev
);
566 #else /* !CONFIG_SUSPEND */
568 #define pci_pm_suspend NULL
569 #define pci_pm_suspend_noirq NULL
570 #define pci_pm_resume NULL
571 #define pci_pm_resume_noirq NULL
573 #endif /* !CONFIG_SUSPEND */
575 #ifdef CONFIG_HIBERNATION
577 static int pci_pm_freeze(struct device
*dev
)
579 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
580 struct device_driver
*drv
= dev
->driver
;
583 if (drv
&& drv
->pm
) {
584 if (drv
->pm
->freeze
) {
585 error
= drv
->pm
->freeze(dev
);
586 suspend_report_result(drv
->pm
->freeze
, error
);
588 } else if (pci_has_legacy_pm_support(pci_dev
)) {
589 error
= pci_legacy_suspend(dev
, PMSG_FREEZE
);
590 pci_fixup_device(pci_fixup_suspend
, pci_dev
);
592 pci_default_pm_suspend_early(pci_dev
);
598 static int pci_pm_freeze_noirq(struct device
*dev
)
600 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
601 struct device_driver
*drv
= dev
->driver
;
604 if (drv
&& drv
->pm
) {
605 if (drv
->pm
->freeze_noirq
) {
606 error
= drv
->pm
->freeze_noirq(dev
);
607 suspend_report_result(drv
->pm
->freeze_noirq
, error
);
609 } else if (pci_has_legacy_pm_support(pci_dev
)) {
610 error
= pci_legacy_suspend_late(dev
, PMSG_FREEZE
);
612 pci_default_pm_suspend_late(pci_dev
);
618 static int pci_pm_thaw(struct device
*dev
)
620 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
621 struct device_driver
*drv
= dev
->driver
;
624 if (drv
&& drv
->pm
) {
626 error
= drv
->pm
->thaw(dev
);
627 } else if (pci_has_legacy_pm_support(pci_dev
)) {
628 pci_fixup_device(pci_fixup_resume
, pci_dev
);
629 error
= pci_legacy_resume(dev
);
631 pci_default_pm_resume_late(pci_dev
);
637 static int pci_pm_thaw_noirq(struct device
*dev
)
639 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
640 struct device_driver
*drv
= dev
->driver
;
643 if (drv
&& drv
->pm
) {
644 if (drv
->pm
->thaw_noirq
)
645 error
= drv
->pm
->thaw_noirq(dev
);
646 } else if (pci_has_legacy_pm_support(pci_dev
)) {
647 pci_fixup_device(pci_fixup_resume_early
, to_pci_dev(dev
));
648 error
= pci_legacy_resume_early(dev
);
650 pci_default_pm_resume_early(pci_dev
);
656 static int pci_pm_poweroff(struct device
*dev
)
658 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
659 struct device_driver
*drv
= dev
->driver
;
662 if (drv
&& drv
->pm
) {
663 if (drv
->pm
->poweroff
) {
664 error
= drv
->pm
->poweroff(dev
);
665 suspend_report_result(drv
->pm
->poweroff
, error
);
667 } else if (pci_has_legacy_pm_support(pci_dev
)) {
668 error
= pci_legacy_suspend(dev
, PMSG_HIBERNATE
);
670 pci_pm_default_suspend(pci_dev
);
673 pci_fixup_device(pci_fixup_suspend
, pci_dev
);
678 static int pci_pm_poweroff_noirq(struct device
*dev
)
680 struct device_driver
*drv
= dev
->driver
;
683 if (drv
&& drv
->pm
) {
684 if (drv
->pm
->poweroff_noirq
) {
685 error
= drv
->pm
->poweroff_noirq(dev
);
686 suspend_report_result(drv
->pm
->poweroff_noirq
, error
);
688 } else if (pci_has_legacy_pm_support(to_pci_dev(dev
))) {
689 error
= pci_legacy_suspend_late(dev
, PMSG_HIBERNATE
);
695 static int pci_pm_restore(struct device
*dev
)
697 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
698 struct device_driver
*drv
= dev
->driver
;
701 pci_fixup_device(pci_fixup_resume
, pci_dev
);
703 if (drv
&& drv
->pm
) {
704 if (drv
->pm
->restore
)
705 error
= drv
->pm
->restore(dev
);
706 } else if (pci_has_legacy_pm_support(pci_dev
)) {
707 error
= pci_legacy_resume(dev
);
709 error
= pci_pm_default_resume(pci_dev
);
715 static int pci_pm_restore_noirq(struct device
*dev
)
717 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
718 struct device_driver
*drv
= dev
->driver
;
721 pci_fixup_device(pci_fixup_resume_early
, pci_dev
);
723 if (drv
&& drv
->pm
) {
724 if (drv
->pm
->restore_noirq
)
725 error
= drv
->pm
->restore_noirq(dev
);
726 } else if (pci_has_legacy_pm_support(pci_dev
)) {
727 error
= pci_legacy_resume_early(dev
);
729 pci_default_pm_resume_early(pci_dev
);
735 #else /* !CONFIG_HIBERNATION */
737 #define pci_pm_freeze NULL
738 #define pci_pm_freeze_noirq NULL
739 #define pci_pm_thaw NULL
740 #define pci_pm_thaw_noirq NULL
741 #define pci_pm_poweroff NULL
742 #define pci_pm_poweroff_noirq NULL
743 #define pci_pm_restore NULL
744 #define pci_pm_restore_noirq NULL
746 #endif /* !CONFIG_HIBERNATION */
748 struct dev_pm_ops pci_dev_pm_ops
= {
749 .prepare
= pci_pm_prepare
,
750 .complete
= pci_pm_complete
,
751 .suspend
= pci_pm_suspend
,
752 .resume
= pci_pm_resume
,
753 .freeze
= pci_pm_freeze
,
755 .poweroff
= pci_pm_poweroff
,
756 .restore
= pci_pm_restore
,
757 .suspend_noirq
= pci_pm_suspend_noirq
,
758 .resume_noirq
= pci_pm_resume_noirq
,
759 .freeze_noirq
= pci_pm_freeze_noirq
,
760 .thaw_noirq
= pci_pm_thaw_noirq
,
761 .poweroff_noirq
= pci_pm_poweroff_noirq
,
762 .restore_noirq
= pci_pm_restore_noirq
,
765 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
767 #else /* !CONFIG_PM_SLEEP */
769 #define PCI_PM_OPS_PTR NULL
771 #endif /* !CONFIG_PM_SLEEP */
774 * __pci_register_driver - register a new pci driver
775 * @drv: the driver structure to register
776 * @owner: owner module of drv
777 * @mod_name: module name string
779 * Adds the driver structure to the list of registered drivers.
780 * Returns a negative value on error, otherwise 0.
781 * If no error occurred, the driver remains registered even if
782 * no device was claimed during registration.
784 int __pci_register_driver(struct pci_driver
*drv
, struct module
*owner
,
785 const char *mod_name
)
789 /* initialize common driver fields */
790 drv
->driver
.name
= drv
->name
;
791 drv
->driver
.bus
= &pci_bus_type
;
792 drv
->driver
.owner
= owner
;
793 drv
->driver
.mod_name
= mod_name
;
795 spin_lock_init(&drv
->dynids
.lock
);
796 INIT_LIST_HEAD(&drv
->dynids
.list
);
798 /* register with core */
799 error
= driver_register(&drv
->driver
);
803 error
= pci_create_newid_file(drv
);
805 driver_unregister(&drv
->driver
);
811 * pci_unregister_driver - unregister a pci driver
812 * @drv: the driver structure to unregister
814 * Deletes the driver structure from the list of registered PCI drivers,
815 * gives it a chance to clean up by calling its remove() function for
816 * each device it was responsible for, and marks those devices as
821 pci_unregister_driver(struct pci_driver
*drv
)
823 pci_remove_newid_file(drv
);
824 driver_unregister(&drv
->driver
);
825 pci_free_dynids(drv
);
828 static struct pci_driver pci_compat_driver
= {
833 * pci_dev_driver - get the pci_driver of a device
834 * @dev: the device to query
836 * Returns the appropriate pci_driver structure or %NULL if there is no
837 * registered driver for the device.
840 pci_dev_driver(const struct pci_dev
*dev
)
846 for(i
=0; i
<=PCI_ROM_RESOURCE
; i
++)
847 if (dev
->resource
[i
].flags
& IORESOURCE_BUSY
)
848 return &pci_compat_driver
;
854 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
855 * @dev: the PCI device structure to match against
856 * @drv: the device driver to search for matching PCI device id structures
858 * Used by a driver to check whether a PCI device present in the
859 * system is in its list of supported devices. Returns the matching
860 * pci_device_id structure or %NULL if there is no match.
862 static int pci_bus_match(struct device
*dev
, struct device_driver
*drv
)
864 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
865 struct pci_driver
*pci_drv
= to_pci_driver(drv
);
866 const struct pci_device_id
*found_id
;
868 found_id
= pci_match_device(pci_drv
, pci_dev
);
876 * pci_dev_get - increments the reference count of the pci device structure
877 * @dev: the device being referenced
879 * Each live reference to a device should be refcounted.
881 * Drivers for PCI devices should normally record such references in
882 * their probe() methods, when they bind to a device, and release
883 * them by calling pci_dev_put(), in their disconnect() methods.
885 * A pointer to the device with the incremented reference counter is returned.
887 struct pci_dev
*pci_dev_get(struct pci_dev
*dev
)
890 get_device(&dev
->dev
);
895 * pci_dev_put - release a use of the pci device structure
896 * @dev: device that's been disconnected
898 * Must be called when a user of a device is finished with it. When the last
899 * user of the device calls this function, the memory of the device is freed.
901 void pci_dev_put(struct pci_dev
*dev
)
904 put_device(&dev
->dev
);
907 #ifndef CONFIG_HOTPLUG
908 int pci_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
914 struct bus_type pci_bus_type
= {
916 .match
= pci_bus_match
,
917 .uevent
= pci_uevent
,
918 .probe
= pci_device_probe
,
919 .remove
= pci_device_remove
,
920 .shutdown
= pci_device_shutdown
,
921 .dev_attrs
= pci_dev_attrs
,
922 .pm
= PCI_PM_OPS_PTR
,
925 static int __init
pci_driver_init(void)
927 return bus_register(&pci_bus_type
);
930 postcore_initcall(pci_driver_init
);
932 EXPORT_SYMBOL(pci_match_id
);
933 EXPORT_SYMBOL(__pci_register_driver
);
934 EXPORT_SYMBOL(pci_unregister_driver
);
935 EXPORT_SYMBOL(pci_dev_driver
);
936 EXPORT_SYMBOL(pci_bus_type
);
937 EXPORT_SYMBOL(pci_dev_get
);
938 EXPORT_SYMBOL(pci_dev_put
);