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
);
519 pci_dev
->state_saved
= false;
522 pci_pm_default_suspend(pci_dev
);
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
);
558 pci_save_state(pci_dev
);
562 if (pm
->suspend_noirq
) {
563 pci_power_t prev
= pci_dev
->current_state
;
566 error
= pm
->suspend_noirq(dev
);
567 suspend_report_result(pm
->suspend_noirq
, error
);
571 if (!pci_dev
->state_saved
&& pci_dev
->current_state
!= PCI_D0
572 && pci_dev
->current_state
!= PCI_UNKNOWN
) {
573 WARN_ONCE(pci_dev
->current_state
!= prev
,
574 "PCI PM: State of device not saved by %pF\n",
580 if (!pci_dev
->state_saved
) {
581 pci_save_state(pci_dev
);
582 if (!pci_is_bridge(pci_dev
))
583 pci_prepare_to_sleep(pci_dev
);
586 pci_pm_set_unknown_state(pci_dev
);
591 static int pci_pm_resume_noirq(struct device
*dev
)
593 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
594 struct device_driver
*drv
= dev
->driver
;
597 pci_pm_default_resume_noirq(pci_dev
);
599 if (pci_has_legacy_pm_support(pci_dev
))
600 return pci_legacy_resume_early(dev
);
602 if (drv
&& drv
->pm
&& drv
->pm
->resume_noirq
)
603 error
= drv
->pm
->resume_noirq(dev
);
608 static int pci_pm_resume(struct device
*dev
)
610 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
611 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
615 * This is necessary for the suspend error path in which resume is
616 * called without restoring the standard config registers of the device.
618 if (pci_dev
->state_saved
)
619 pci_restore_standard_config(pci_dev
);
621 if (pci_has_legacy_pm_support(pci_dev
))
622 return pci_legacy_resume(dev
);
624 pci_pm_default_resume(pci_dev
);
628 error
= pm
->resume(dev
);
630 pci_pm_reenable_device(pci_dev
);
636 #else /* !CONFIG_SUSPEND */
638 #define pci_pm_suspend NULL
639 #define pci_pm_suspend_noirq NULL
640 #define pci_pm_resume NULL
641 #define pci_pm_resume_noirq NULL
643 #endif /* !CONFIG_SUSPEND */
645 #ifdef CONFIG_HIBERNATION
647 static int pci_pm_freeze(struct device
*dev
)
649 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
650 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
652 if (pci_has_legacy_pm_support(pci_dev
))
653 return pci_legacy_suspend(dev
, PMSG_FREEZE
);
655 pci_dev
->state_saved
= false;
658 pci_pm_default_suspend(pci_dev
);
665 error
= pm
->freeze(dev
);
666 suspend_report_result(pm
->freeze
, error
);
674 static int pci_pm_freeze_noirq(struct device
*dev
)
676 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
677 struct device_driver
*drv
= dev
->driver
;
679 if (pci_has_legacy_pm_support(pci_dev
))
680 return pci_legacy_suspend_late(dev
, PMSG_FREEZE
);
682 if (drv
&& drv
->pm
&& drv
->pm
->freeze_noirq
) {
685 error
= drv
->pm
->freeze_noirq(dev
);
686 suspend_report_result(drv
->pm
->freeze_noirq
, error
);
691 if (!pci_dev
->state_saved
)
692 pci_save_state(pci_dev
);
694 pci_pm_set_unknown_state(pci_dev
);
699 static int pci_pm_thaw_noirq(struct device
*dev
)
701 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
702 struct device_driver
*drv
= dev
->driver
;
705 if (pci_has_legacy_pm_support(pci_dev
))
706 return pci_legacy_resume_early(dev
);
708 pci_update_current_state(pci_dev
, PCI_D0
);
710 if (drv
&& drv
->pm
&& drv
->pm
->thaw_noirq
)
711 error
= drv
->pm
->thaw_noirq(dev
);
716 static int pci_pm_thaw(struct device
*dev
)
718 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
719 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
722 if (pci_has_legacy_pm_support(pci_dev
))
723 return pci_legacy_resume(dev
);
727 error
= pm
->thaw(dev
);
729 pci_pm_reenable_device(pci_dev
);
735 static int pci_pm_poweroff(struct device
*dev
)
737 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
738 struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
740 if (pci_has_legacy_pm_support(pci_dev
))
741 return pci_legacy_suspend(dev
, PMSG_HIBERNATE
);
743 pci_dev
->state_saved
= false;
746 pci_pm_default_suspend(pci_dev
);
753 error
= pm
->poweroff(dev
);
754 suspend_report_result(pm
->poweroff
, error
);
760 pci_fixup_device(pci_fixup_suspend
, pci_dev
);
765 static int pci_pm_poweroff_noirq(struct device
*dev
)
767 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
768 struct device_driver
*drv
= dev
->driver
;
770 if (pci_has_legacy_pm_support(to_pci_dev(dev
)))
771 return pci_legacy_suspend_late(dev
, PMSG_HIBERNATE
);
773 if (!drv
|| !drv
->pm
)
776 if (drv
->pm
->poweroff_noirq
) {
779 error
= drv
->pm
->poweroff_noirq(dev
);
780 suspend_report_result(drv
->pm
->poweroff_noirq
, error
);
785 if (!pci_dev
->state_saved
&& !pci_is_bridge(pci_dev
))
786 pci_prepare_to_sleep(pci_dev
);
791 static int pci_pm_restore_noirq(struct device
*dev
)
793 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
794 struct device_driver
*drv
= dev
->driver
;
797 pci_pm_default_resume_noirq(pci_dev
);
799 if (pci_has_legacy_pm_support(pci_dev
))
800 return pci_legacy_resume_early(dev
);
802 if (drv
&& drv
->pm
&& drv
->pm
->restore_noirq
)
803 error
= drv
->pm
->restore_noirq(dev
);
808 static int pci_pm_restore(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
;
815 * This is necessary for the hibernation error path in which restore is
816 * called without restoring the standard config registers of the device.
818 if (pci_dev
->state_saved
)
819 pci_restore_standard_config(pci_dev
);
821 if (pci_has_legacy_pm_support(pci_dev
))
822 return pci_legacy_resume(dev
);
824 pci_pm_default_resume(pci_dev
);
828 error
= pm
->restore(dev
);
830 pci_pm_reenable_device(pci_dev
);
836 #else /* !CONFIG_HIBERNATION */
838 #define pci_pm_freeze NULL
839 #define pci_pm_freeze_noirq NULL
840 #define pci_pm_thaw NULL
841 #define pci_pm_thaw_noirq NULL
842 #define pci_pm_poweroff NULL
843 #define pci_pm_poweroff_noirq NULL
844 #define pci_pm_restore NULL
845 #define pci_pm_restore_noirq NULL
847 #endif /* !CONFIG_HIBERNATION */
849 struct dev_pm_ops pci_dev_pm_ops
= {
850 .prepare
= pci_pm_prepare
,
851 .complete
= pci_pm_complete
,
852 .suspend
= pci_pm_suspend
,
853 .resume
= pci_pm_resume
,
854 .freeze
= pci_pm_freeze
,
856 .poweroff
= pci_pm_poweroff
,
857 .restore
= pci_pm_restore
,
858 .suspend_noirq
= pci_pm_suspend_noirq
,
859 .resume_noirq
= pci_pm_resume_noirq
,
860 .freeze_noirq
= pci_pm_freeze_noirq
,
861 .thaw_noirq
= pci_pm_thaw_noirq
,
862 .poweroff_noirq
= pci_pm_poweroff_noirq
,
863 .restore_noirq
= pci_pm_restore_noirq
,
866 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
868 #else /* !CONFIG_PM_SLEEP */
870 #define PCI_PM_OPS_PTR NULL
872 #endif /* !CONFIG_PM_SLEEP */
875 * __pci_register_driver - register a new pci driver
876 * @drv: the driver structure to register
877 * @owner: owner module of drv
878 * @mod_name: module name string
880 * Adds the driver structure to the list of registered drivers.
881 * Returns a negative value on error, otherwise 0.
882 * If no error occurred, the driver remains registered even if
883 * no device was claimed during registration.
885 int __pci_register_driver(struct pci_driver
*drv
, struct module
*owner
,
886 const char *mod_name
)
890 /* initialize common driver fields */
891 drv
->driver
.name
= drv
->name
;
892 drv
->driver
.bus
= &pci_bus_type
;
893 drv
->driver
.owner
= owner
;
894 drv
->driver
.mod_name
= mod_name
;
896 spin_lock_init(&drv
->dynids
.lock
);
897 INIT_LIST_HEAD(&drv
->dynids
.list
);
899 /* register with core */
900 error
= driver_register(&drv
->driver
);
904 error
= pci_create_newid_file(drv
);
906 driver_unregister(&drv
->driver
);
912 * pci_unregister_driver - unregister a pci driver
913 * @drv: the driver structure to unregister
915 * Deletes the driver structure from the list of registered PCI drivers,
916 * gives it a chance to clean up by calling its remove() function for
917 * each device it was responsible for, and marks those devices as
922 pci_unregister_driver(struct pci_driver
*drv
)
924 pci_remove_newid_file(drv
);
925 driver_unregister(&drv
->driver
);
926 pci_free_dynids(drv
);
929 static struct pci_driver pci_compat_driver
= {
934 * pci_dev_driver - get the pci_driver of a device
935 * @dev: the device to query
937 * Returns the appropriate pci_driver structure or %NULL if there is no
938 * registered driver for the device.
941 pci_dev_driver(const struct pci_dev
*dev
)
947 for(i
=0; i
<=PCI_ROM_RESOURCE
; i
++)
948 if (dev
->resource
[i
].flags
& IORESOURCE_BUSY
)
949 return &pci_compat_driver
;
955 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
956 * @dev: the PCI device structure to match against
957 * @drv: the device driver to search for matching PCI device id structures
959 * Used by a driver to check whether a PCI device present in the
960 * system is in its list of supported devices. Returns the matching
961 * pci_device_id structure or %NULL if there is no match.
963 static int pci_bus_match(struct device
*dev
, struct device_driver
*drv
)
965 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
966 struct pci_driver
*pci_drv
= to_pci_driver(drv
);
967 const struct pci_device_id
*found_id
;
969 found_id
= pci_match_device(pci_drv
, pci_dev
);
977 * pci_dev_get - increments the reference count of the pci device structure
978 * @dev: the device being referenced
980 * Each live reference to a device should be refcounted.
982 * Drivers for PCI devices should normally record such references in
983 * their probe() methods, when they bind to a device, and release
984 * them by calling pci_dev_put(), in their disconnect() methods.
986 * A pointer to the device with the incremented reference counter is returned.
988 struct pci_dev
*pci_dev_get(struct pci_dev
*dev
)
991 get_device(&dev
->dev
);
996 * pci_dev_put - release a use of the pci device structure
997 * @dev: device that's been disconnected
999 * Must be called when a user of a device is finished with it. When the last
1000 * user of the device calls this function, the memory of the device is freed.
1002 void pci_dev_put(struct pci_dev
*dev
)
1005 put_device(&dev
->dev
);
1008 #ifndef CONFIG_HOTPLUG
1009 int pci_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
1015 struct bus_type pci_bus_type
= {
1017 .match
= pci_bus_match
,
1018 .uevent
= pci_uevent
,
1019 .probe
= pci_device_probe
,
1020 .remove
= pci_device_remove
,
1021 .shutdown
= pci_device_shutdown
,
1022 .dev_attrs
= pci_dev_attrs
,
1023 .pm
= PCI_PM_OPS_PTR
,
1026 static int __init
pci_driver_init(void)
1028 return bus_register(&pci_bus_type
);
1031 postcore_initcall(pci_driver_init
);
1033 EXPORT_SYMBOL(pci_match_id
);
1034 EXPORT_SYMBOL(__pci_register_driver
);
1035 EXPORT_SYMBOL(pci_unregister_driver
);
1036 EXPORT_SYMBOL(pci_dev_driver
);
1037 EXPORT_SYMBOL(pci_bus_type
);
1038 EXPORT_SYMBOL(pci_dev_get
);
1039 EXPORT_SYMBOL(pci_dev_put
);