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 pci_power_t prev
= pci_dev
->current_state
;
360 pci_dev
->state_saved
= false;
362 error
= drv
->suspend(pci_dev
, state
);
363 suspend_report_result(drv
->suspend
, error
);
367 if (pci_dev
->state_saved
)
370 if (pci_dev
->current_state
!= PCI_D0
371 && pci_dev
->current_state
!= PCI_UNKNOWN
) {
372 WARN_ONCE(pci_dev
->current_state
!= prev
,
373 "PCI PM: Device state not saved by %pF\n",
379 pci_save_state(pci_dev
);
381 * This is for compatibility with existing code with legacy PM support.
383 pci_pm_set_unknown_state(pci_dev
);
386 pci_fixup_device(pci_fixup_suspend
, pci_dev
);
391 static int pci_legacy_suspend_late(struct device
*dev
, pm_message_t state
)
393 struct pci_dev
* pci_dev
= to_pci_dev(dev
);
394 struct pci_driver
* drv
= pci_dev
->driver
;
397 if (drv
&& drv
->suspend_late
) {
398 error
= drv
->suspend_late(pci_dev
, state
);
399 suspend_report_result(drv
->suspend_late
, error
);
404 static int pci_legacy_resume_early(struct device
*dev
)
406 struct pci_dev
* pci_dev
= to_pci_dev(dev
);
407 struct pci_driver
* drv
= pci_dev
->driver
;
409 return drv
&& drv
->resume_early
?
410 drv
->resume_early(pci_dev
) : 0;
413 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 pci_fixup_device(pci_fixup_resume
, pci_dev
);
420 return drv
&& drv
->resume
?
421 drv
->resume(pci_dev
) : pci_pm_reenable_device(pci_dev
);
424 /* Auxiliary functions used by the new power management framework */
427 * pci_restore_standard_config - restore standard config registers of PCI device
428 * @pci_dev: PCI device to handle
430 static int pci_restore_standard_config(struct pci_dev
*pci_dev
)
432 pci_update_current_state(pci_dev
, PCI_UNKNOWN
);
434 if (pci_dev
->current_state
!= PCI_D0
) {
435 int error
= pci_set_power_state(pci_dev
, PCI_D0
);
440 return pci_dev
->state_saved
? pci_restore_state(pci_dev
) : 0;
443 static void pci_pm_default_resume_noirq(struct pci_dev
*pci_dev
)
445 pci_restore_standard_config(pci_dev
);
446 pci_dev
->state_saved
= false;
447 pci_fixup_device(pci_fixup_resume_early
, pci_dev
);
450 static void pci_pm_default_resume(struct pci_dev
*pci_dev
)
452 pci_fixup_device(pci_fixup_resume
, pci_dev
);
454 if (!pci_is_bridge(pci_dev
))
455 pci_enable_wake(pci_dev
, PCI_D0
, false);
458 static void pci_pm_default_suspend(struct pci_dev
*pci_dev
)
460 /* Disable non-bridge devices without PM support */
461 if (!pci_is_bridge(pci_dev
))
462 pci_disable_enabled_device(pci_dev
);
463 pci_save_state(pci_dev
);
466 static bool pci_has_legacy_pm_support(struct pci_dev
*pci_dev
)
468 struct pci_driver
*drv
= pci_dev
->driver
;
469 bool ret
= drv
&& (drv
->suspend
|| drv
->suspend_late
|| drv
->resume
470 || drv
->resume_early
);
473 * Legacy PM support is used by default, so warn if the new framework is
474 * supported as well. Drivers are supposed to support either the
475 * former, or the latter, but not both at the same time.
477 WARN_ON(ret
&& drv
->driver
.pm
);
482 /* New power management framework */
484 static int pci_pm_prepare(struct device
*dev
)
486 struct device_driver
*drv
= dev
->driver
;
489 if (drv
&& drv
->pm
&& drv
->pm
->prepare
)
490 error
= drv
->pm
->prepare(dev
);
495 static void pci_pm_complete(struct device
*dev
)
497 struct device_driver
*drv
= dev
->driver
;
499 if (drv
&& drv
->pm
&& drv
->pm
->complete
)
500 drv
->pm
->complete(dev
);
503 #ifdef CONFIG_SUSPEND
505 static int pci_pm_suspend(struct device
*dev
)
507 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
508 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
510 if (pci_has_legacy_pm_support(pci_dev
))
511 return pci_legacy_suspend(dev
, PMSG_SUSPEND
);
514 pci_pm_default_suspend(pci_dev
);
518 pci_dev
->state_saved
= false;
521 pci_power_t prev
= pci_dev
->current_state
;
524 error
= pm
->suspend(dev
);
525 suspend_report_result(pm
->suspend
, error
);
529 if (pci_dev
->state_saved
)
532 if (pci_dev
->current_state
!= PCI_D0
533 && pci_dev
->current_state
!= PCI_UNKNOWN
) {
534 WARN_ONCE(pci_dev
->current_state
!= prev
,
535 "PCI PM: State of device not saved by %pF\n",
541 if (!pci_dev
->state_saved
) {
542 pci_save_state(pci_dev
);
543 if (!pci_is_bridge(pci_dev
))
544 pci_prepare_to_sleep(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
&& drv
->pm
->suspend_noirq
) {
563 error
= drv
->pm
->suspend_noirq(dev
);
564 suspend_report_result(drv
->pm
->suspend_noirq
, error
);
568 pci_pm_set_unknown_state(pci_dev
);
573 static int pci_pm_resume_noirq(struct device
*dev
)
575 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
576 struct device_driver
*drv
= dev
->driver
;
579 pci_pm_default_resume_noirq(pci_dev
);
581 if (pci_has_legacy_pm_support(pci_dev
))
582 return pci_legacy_resume_early(dev
);
584 if (drv
&& drv
->pm
&& drv
->pm
->resume_noirq
)
585 error
= drv
->pm
->resume_noirq(dev
);
590 static int pci_pm_resume(struct device
*dev
)
592 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
593 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
597 * This is necessary for the suspend error path in which resume is
598 * called without restoring the standard config registers of the device.
600 if (pci_dev
->state_saved
)
601 pci_restore_standard_config(pci_dev
);
603 if (pci_has_legacy_pm_support(pci_dev
))
604 return pci_legacy_resume(dev
);
606 pci_pm_default_resume(pci_dev
);
610 error
= pm
->resume(dev
);
612 pci_pm_reenable_device(pci_dev
);
618 #else /* !CONFIG_SUSPEND */
620 #define pci_pm_suspend NULL
621 #define pci_pm_suspend_noirq NULL
622 #define pci_pm_resume NULL
623 #define pci_pm_resume_noirq NULL
625 #endif /* !CONFIG_SUSPEND */
627 #ifdef CONFIG_HIBERNATION
629 static int pci_pm_freeze(struct device
*dev
)
631 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
632 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
634 if (pci_has_legacy_pm_support(pci_dev
))
635 return pci_legacy_suspend(dev
, PMSG_FREEZE
);
638 pci_pm_default_suspend(pci_dev
);
642 pci_dev
->state_saved
= false;
647 error
= pm
->freeze(dev
);
648 suspend_report_result(pm
->freeze
, error
);
653 if (!pci_dev
->state_saved
)
654 pci_save_state(pci_dev
);
659 static int pci_pm_freeze_noirq(struct device
*dev
)
661 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
662 struct device_driver
*drv
= dev
->driver
;
665 if (pci_has_legacy_pm_support(pci_dev
))
666 return pci_legacy_suspend_late(dev
, PMSG_FREEZE
);
668 if (drv
&& drv
->pm
&& drv
->pm
->freeze_noirq
) {
669 error
= drv
->pm
->freeze_noirq(dev
);
670 suspend_report_result(drv
->pm
->freeze_noirq
, error
);
674 pci_pm_set_unknown_state(pci_dev
);
679 static int pci_pm_thaw_noirq(struct device
*dev
)
681 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
682 struct device_driver
*drv
= dev
->driver
;
685 if (pci_has_legacy_pm_support(pci_dev
))
686 return pci_legacy_resume_early(dev
);
688 pci_update_current_state(pci_dev
, PCI_D0
);
690 if (drv
&& drv
->pm
&& drv
->pm
->thaw_noirq
)
691 error
= drv
->pm
->thaw_noirq(dev
);
696 static int pci_pm_thaw(struct device
*dev
)
698 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
699 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
702 if (pci_has_legacy_pm_support(pci_dev
))
703 return pci_legacy_resume(dev
);
707 error
= pm
->thaw(dev
);
709 pci_pm_reenable_device(pci_dev
);
715 static int pci_pm_poweroff(struct device
*dev
)
717 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
718 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
721 if (pci_has_legacy_pm_support(pci_dev
))
722 return pci_legacy_suspend(dev
, PMSG_HIBERNATE
);
725 pci_pm_default_suspend(pci_dev
);
729 pci_dev
->state_saved
= false;
732 error
= pm
->poweroff(dev
);
733 suspend_report_result(pm
->poweroff
, error
);
736 if (!pci_dev
->state_saved
&& !pci_is_bridge(pci_dev
))
737 pci_prepare_to_sleep(pci_dev
);
740 pci_fixup_device(pci_fixup_suspend
, pci_dev
);
745 static int pci_pm_poweroff_noirq(struct device
*dev
)
747 struct device_driver
*drv
= dev
->driver
;
750 if (pci_has_legacy_pm_support(to_pci_dev(dev
)))
751 return pci_legacy_suspend_late(dev
, PMSG_HIBERNATE
);
753 if (drv
&& drv
->pm
&& drv
->pm
->poweroff_noirq
) {
754 error
= drv
->pm
->poweroff_noirq(dev
);
755 suspend_report_result(drv
->pm
->poweroff_noirq
, error
);
761 static int pci_pm_restore_noirq(struct device
*dev
)
763 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
764 struct device_driver
*drv
= dev
->driver
;
767 pci_pm_default_resume_noirq(pci_dev
);
769 if (pci_has_legacy_pm_support(pci_dev
))
770 return pci_legacy_resume_early(dev
);
772 if (drv
&& drv
->pm
&& drv
->pm
->restore_noirq
)
773 error
= drv
->pm
->restore_noirq(dev
);
778 static int pci_pm_restore(struct device
*dev
)
780 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
781 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
785 * This is necessary for the hibernation error path in which restore is
786 * called without restoring the standard config registers of the device.
788 if (pci_dev
->state_saved
)
789 pci_restore_standard_config(pci_dev
);
791 if (pci_has_legacy_pm_support(pci_dev
))
792 return pci_legacy_resume(dev
);
794 pci_pm_default_resume(pci_dev
);
798 error
= pm
->restore(dev
);
800 pci_pm_reenable_device(pci_dev
);
806 #else /* !CONFIG_HIBERNATION */
808 #define pci_pm_freeze NULL
809 #define pci_pm_freeze_noirq NULL
810 #define pci_pm_thaw NULL
811 #define pci_pm_thaw_noirq NULL
812 #define pci_pm_poweroff NULL
813 #define pci_pm_poweroff_noirq NULL
814 #define pci_pm_restore NULL
815 #define pci_pm_restore_noirq NULL
817 #endif /* !CONFIG_HIBERNATION */
819 struct dev_pm_ops pci_dev_pm_ops
= {
820 .prepare
= pci_pm_prepare
,
821 .complete
= pci_pm_complete
,
822 .suspend
= pci_pm_suspend
,
823 .resume
= pci_pm_resume
,
824 .freeze
= pci_pm_freeze
,
826 .poweroff
= pci_pm_poweroff
,
827 .restore
= pci_pm_restore
,
828 .suspend_noirq
= pci_pm_suspend_noirq
,
829 .resume_noirq
= pci_pm_resume_noirq
,
830 .freeze_noirq
= pci_pm_freeze_noirq
,
831 .thaw_noirq
= pci_pm_thaw_noirq
,
832 .poweroff_noirq
= pci_pm_poweroff_noirq
,
833 .restore_noirq
= pci_pm_restore_noirq
,
836 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
838 #else /* !CONFIG_PM_SLEEP */
840 #define PCI_PM_OPS_PTR NULL
842 #endif /* !CONFIG_PM_SLEEP */
845 * __pci_register_driver - register a new pci driver
846 * @drv: the driver structure to register
847 * @owner: owner module of drv
848 * @mod_name: module name string
850 * Adds the driver structure to the list of registered drivers.
851 * Returns a negative value on error, otherwise 0.
852 * If no error occurred, the driver remains registered even if
853 * no device was claimed during registration.
855 int __pci_register_driver(struct pci_driver
*drv
, struct module
*owner
,
856 const char *mod_name
)
860 /* initialize common driver fields */
861 drv
->driver
.name
= drv
->name
;
862 drv
->driver
.bus
= &pci_bus_type
;
863 drv
->driver
.owner
= owner
;
864 drv
->driver
.mod_name
= mod_name
;
866 spin_lock_init(&drv
->dynids
.lock
);
867 INIT_LIST_HEAD(&drv
->dynids
.list
);
869 /* register with core */
870 error
= driver_register(&drv
->driver
);
874 error
= pci_create_newid_file(drv
);
876 driver_unregister(&drv
->driver
);
882 * pci_unregister_driver - unregister a pci driver
883 * @drv: the driver structure to unregister
885 * Deletes the driver structure from the list of registered PCI drivers,
886 * gives it a chance to clean up by calling its remove() function for
887 * each device it was responsible for, and marks those devices as
892 pci_unregister_driver(struct pci_driver
*drv
)
894 pci_remove_newid_file(drv
);
895 driver_unregister(&drv
->driver
);
896 pci_free_dynids(drv
);
899 static struct pci_driver pci_compat_driver
= {
904 * pci_dev_driver - get the pci_driver of a device
905 * @dev: the device to query
907 * Returns the appropriate pci_driver structure or %NULL if there is no
908 * registered driver for the device.
911 pci_dev_driver(const struct pci_dev
*dev
)
917 for(i
=0; i
<=PCI_ROM_RESOURCE
; i
++)
918 if (dev
->resource
[i
].flags
& IORESOURCE_BUSY
)
919 return &pci_compat_driver
;
925 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
926 * @dev: the PCI device structure to match against
927 * @drv: the device driver to search for matching PCI device id structures
929 * Used by a driver to check whether a PCI device present in the
930 * system is in its list of supported devices. Returns the matching
931 * pci_device_id structure or %NULL if there is no match.
933 static int pci_bus_match(struct device
*dev
, struct device_driver
*drv
)
935 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
936 struct pci_driver
*pci_drv
= to_pci_driver(drv
);
937 const struct pci_device_id
*found_id
;
939 found_id
= pci_match_device(pci_drv
, pci_dev
);
947 * pci_dev_get - increments the reference count of the pci device structure
948 * @dev: the device being referenced
950 * Each live reference to a device should be refcounted.
952 * Drivers for PCI devices should normally record such references in
953 * their probe() methods, when they bind to a device, and release
954 * them by calling pci_dev_put(), in their disconnect() methods.
956 * A pointer to the device with the incremented reference counter is returned.
958 struct pci_dev
*pci_dev_get(struct pci_dev
*dev
)
961 get_device(&dev
->dev
);
966 * pci_dev_put - release a use of the pci device structure
967 * @dev: device that's been disconnected
969 * Must be called when a user of a device is finished with it. When the last
970 * user of the device calls this function, the memory of the device is freed.
972 void pci_dev_put(struct pci_dev
*dev
)
975 put_device(&dev
->dev
);
978 #ifndef CONFIG_HOTPLUG
979 int pci_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
985 struct bus_type pci_bus_type
= {
987 .match
= pci_bus_match
,
988 .uevent
= pci_uevent
,
989 .probe
= pci_device_probe
,
990 .remove
= pci_device_remove
,
991 .shutdown
= pci_device_shutdown
,
992 .dev_attrs
= pci_dev_attrs
,
993 .pm
= PCI_PM_OPS_PTR
,
996 static int __init
pci_driver_init(void)
998 return bus_register(&pci_bus_type
);
1001 postcore_initcall(pci_driver_init
);
1003 EXPORT_SYMBOL(pci_match_id
);
1004 EXPORT_SYMBOL(__pci_register_driver
);
1005 EXPORT_SYMBOL(pci_unregister_driver
);
1006 EXPORT_SYMBOL(pci_dev_driver
);
1007 EXPORT_SYMBOL(pci_bus_type
);
1008 EXPORT_SYMBOL(pci_dev_get
);
1009 EXPORT_SYMBOL(pci_dev_put
);