PCI: PCIe portdrv: Simplify suspend and resume
[linux-2.6/mini2440.git] / drivers / pci / pci-driver.c
blobfdb6a697e05abdf5f7998c25199d6b8dddf7a6da
1 /*
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.
9 */
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>
20 #include "pci.h"
23 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
26 struct pci_dynid {
27 struct list_head node;
28 struct pci_device_id id;
31 #ifdef CONFIG_HOTPLUG
33 /**
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
37 * @count: input size
39 * Adds a new dynamic pci device ID to this driver,
40 * and causes the driver to probe for all devices again.
42 static ssize_t
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;
51 int fields=0;
52 int retval=0;
54 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
55 &vendor, &device, &subvendor, &subdevice,
56 &class, &class_mask, &driver_data);
57 if (fields < 2)
58 return -EINVAL;
60 /* Only accept driver_data values that match an existing id_table
61 entry */
62 if (ids) {
63 retval = -EINVAL;
64 while (ids->vendor || ids->subvendor || ids->class_mask) {
65 if (driver_data == ids->driver_data) {
66 retval = 0;
67 break;
69 ids++;
71 if (retval) /* No match */
72 return retval;
75 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
76 if (!dynid)
77 return -ENOMEM;
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);
96 if (retval)
97 return retval;
98 return count;
100 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
102 static void
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);
110 kfree(dynid);
112 spin_unlock(&drv->dynids.lock);
115 static int
116 pci_create_newid_file(struct pci_driver *drv)
118 int error = 0;
119 if (drv->probe != NULL)
120 error = driver_create_file(&drv->driver, &driver_attr_new_id);
121 return error;
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)
132 return 0;
134 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
135 #endif
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,
150 struct pci_dev *dev)
152 if (ids) {
153 while (ids->vendor || ids->subvendor || ids->class_mask) {
154 if (pci_match_one_device(ids, dev))
155 return ids;
156 ids++;
159 return NULL;
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,
172 struct pci_dev *dev)
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);
181 return &dynid->id;
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;
191 struct pci_dev *dev;
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)
205 int error, node;
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
211 change it. */
212 node = dev_to_node(&dev->dev);
213 if (node >= 0) {
214 int cpu;
215 node_to_cpumask_ptr(nodecpumask, node);
217 get_online_cpus();
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);
221 else
222 error = local_pci_probe(&ddi);
223 put_online_cpus();
224 } else
225 error = local_pci_probe(&ddi);
226 return error;
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.
237 static int
238 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
240 const struct pci_device_id *id;
241 int error = 0;
243 if (!pci_dev->driver && drv->probe) {
244 error = -ENODEV;
246 id = pci_match_device(drv, pci_dev);
247 if (id)
248 error = pci_call_probe(drv, pci_dev, id);
249 if (error >= 0) {
250 pci_dev->driver = drv;
251 error = 0;
254 return error;
257 static int pci_device_probe(struct device * dev)
259 int error = 0;
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);
267 if (error)
268 pci_dev_put(pci_dev);
270 return error;
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;
278 if (drv) {
279 if (drv->remove)
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);
301 return 0;
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)
337 int retval;
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
343 * again
345 if (pci_dev->is_busmaster)
346 pci_set_master(pci_dev);
348 return retval;
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;
355 int i = 0;
357 if (drv && drv->suspend) {
358 pci_power_t prev = pci_dev->current_state;
360 pci_dev->state_saved = false;
362 i = drv->suspend(pci_dev, state);
363 suspend_report_result(drv->suspend, i);
364 if (i)
365 return i;
367 if (pci_dev->state_saved)
368 goto Fixup;
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",
374 drv->suspend);
375 goto Fixup;
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);
385 Fixup:
386 pci_fixup_device(pci_fixup_suspend, pci_dev);
388 return i;
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;
395 int i = 0;
397 if (drv && drv->suspend_late) {
398 i = drv->suspend_late(pci_dev, state);
399 suspend_report_result(drv->suspend_late, i);
401 return i;
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 */
426 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
428 pci_restore_standard_config(pci_dev);
429 pci_dev->state_saved = false;
430 pci_fixup_device(pci_fixup_resume_early, pci_dev);
433 static int pci_pm_default_resume(struct pci_dev *pci_dev)
435 pci_fixup_device(pci_fixup_resume, pci_dev);
437 if (!pci_is_bridge(pci_dev))
438 pci_enable_wake(pci_dev, PCI_D0, false);
440 return pci_pm_reenable_device(pci_dev);
443 static void pci_pm_default_suspend_generic(struct pci_dev *pci_dev)
445 /* If device is enabled at this point, disable it */
446 pci_disable_enabled_device(pci_dev);
448 * Save state with interrupts enabled, because in principle the bus the
449 * device is on may be put into a low power state after this code runs.
451 pci_save_state(pci_dev);
454 static void pci_pm_default_suspend(struct pci_dev *pci_dev, bool prepare)
456 pci_pm_default_suspend_generic(pci_dev);
458 if (prepare && !pci_is_bridge(pci_dev))
459 pci_prepare_to_sleep(pci_dev);
461 pci_fixup_device(pci_fixup_suspend, pci_dev);
464 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
466 struct pci_driver *drv = pci_dev->driver;
467 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
468 || drv->resume_early);
471 * Legacy PM support is used by default, so warn if the new framework is
472 * supported as well. Drivers are supposed to support either the
473 * former, or the latter, but not both at the same time.
475 WARN_ON(ret && drv->driver.pm);
477 return ret;
480 /* New power management framework */
482 static int pci_pm_prepare(struct device *dev)
484 struct device_driver *drv = dev->driver;
485 int error = 0;
487 if (drv && drv->pm && drv->pm->prepare)
488 error = drv->pm->prepare(dev);
490 return error;
493 static void pci_pm_complete(struct device *dev)
495 struct device_driver *drv = dev->driver;
497 if (drv && drv->pm && drv->pm->complete)
498 drv->pm->complete(dev);
501 #ifdef CONFIG_SUSPEND
503 static int pci_pm_suspend(struct device *dev)
505 struct pci_dev *pci_dev = to_pci_dev(dev);
506 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
507 int error = 0;
509 if (pci_has_legacy_pm_support(pci_dev))
510 return pci_legacy_suspend(dev, PMSG_SUSPEND);
512 if (pm && pm->suspend) {
513 error = pm->suspend(dev);
514 suspend_report_result(pm->suspend, error);
517 if (!error)
518 pci_pm_default_suspend(pci_dev, !!pm);
520 return error;
523 static int pci_pm_suspend_noirq(struct device *dev)
525 struct pci_dev *pci_dev = to_pci_dev(dev);
526 struct device_driver *drv = dev->driver;
527 int error = 0;
529 if (pci_has_legacy_pm_support(pci_dev))
530 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
532 if (drv && drv->pm && drv->pm->suspend_noirq) {
533 error = drv->pm->suspend_noirq(dev);
534 suspend_report_result(drv->pm->suspend_noirq, error);
537 if (!error)
538 pci_pm_set_unknown_state(pci_dev);
540 return error;
543 static int pci_pm_resume_noirq(struct device *dev)
545 struct pci_dev *pci_dev = to_pci_dev(dev);
546 struct device_driver *drv = dev->driver;
547 int error = 0;
549 pci_pm_default_resume_noirq(pci_dev);
551 if (pci_has_legacy_pm_support(pci_dev))
552 return pci_legacy_resume_early(dev);
554 if (drv && drv->pm && drv->pm->resume_noirq)
555 error = drv->pm->resume_noirq(dev);
557 return error;
560 static int pci_pm_resume(struct device *dev)
562 struct pci_dev *pci_dev = to_pci_dev(dev);
563 struct device_driver *drv = dev->driver;
564 int error = 0;
567 * This is necessary for the suspend error path in which resume is
568 * called without restoring the standard config registers of the device.
570 if (pci_dev->state_saved)
571 pci_restore_standard_config(pci_dev);
573 if (pci_has_legacy_pm_support(pci_dev))
574 return pci_legacy_resume(dev);
576 error = pci_pm_default_resume(pci_dev);
578 if (!error && drv && drv->pm && drv->pm->resume)
579 error = drv->pm->resume(dev);
581 return error;
584 #else /* !CONFIG_SUSPEND */
586 #define pci_pm_suspend NULL
587 #define pci_pm_suspend_noirq NULL
588 #define pci_pm_resume NULL
589 #define pci_pm_resume_noirq NULL
591 #endif /* !CONFIG_SUSPEND */
593 #ifdef CONFIG_HIBERNATION
595 static int pci_pm_freeze(struct device *dev)
597 struct pci_dev *pci_dev = to_pci_dev(dev);
598 struct device_driver *drv = dev->driver;
599 int error = 0;
601 if (pci_has_legacy_pm_support(pci_dev))
602 return pci_legacy_suspend(dev, PMSG_FREEZE);
604 if (drv && drv->pm && drv->pm->freeze) {
605 error = drv->pm->freeze(dev);
606 suspend_report_result(drv->pm->freeze, error);
609 if (!error)
610 pci_pm_default_suspend_generic(pci_dev);
612 return error;
615 static int pci_pm_freeze_noirq(struct device *dev)
617 struct pci_dev *pci_dev = to_pci_dev(dev);
618 struct device_driver *drv = dev->driver;
619 int error = 0;
621 if (pci_has_legacy_pm_support(pci_dev))
622 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
624 if (drv && drv->pm && drv->pm->freeze_noirq) {
625 error = drv->pm->freeze_noirq(dev);
626 suspend_report_result(drv->pm->freeze_noirq, error);
629 if (!error)
630 pci_pm_set_unknown_state(pci_dev);
632 return error;
635 static int pci_pm_thaw_noirq(struct device *dev)
637 struct pci_dev *pci_dev = to_pci_dev(dev);
638 struct device_driver *drv = dev->driver;
639 int error = 0;
641 if (pci_has_legacy_pm_support(pci_dev))
642 return pci_legacy_resume_early(dev);
644 pci_update_current_state(pci_dev, PCI_D0);
646 if (drv && drv->pm && drv->pm->thaw_noirq)
647 error = drv->pm->thaw_noirq(dev);
649 return error;
652 static int pci_pm_thaw(struct device *dev)
654 struct pci_dev *pci_dev = to_pci_dev(dev);
655 struct device_driver *drv = dev->driver;
656 int error = 0;
658 if (pci_has_legacy_pm_support(pci_dev))
659 return pci_legacy_resume(dev);
661 pci_pm_reenable_device(pci_dev);
663 if (drv && drv->pm && drv->pm->thaw)
664 error = drv->pm->thaw(dev);
666 return error;
669 static int pci_pm_poweroff(struct device *dev)
671 struct pci_dev *pci_dev = to_pci_dev(dev);
672 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
673 int error = 0;
675 if (pci_has_legacy_pm_support(pci_dev))
676 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
678 if (pm && pm->poweroff) {
679 error = pm->poweroff(dev);
680 suspend_report_result(pm->poweroff, error);
683 if (!error)
684 pci_pm_default_suspend(pci_dev, !!pm);
686 return error;
689 static int pci_pm_poweroff_noirq(struct device *dev)
691 struct device_driver *drv = dev->driver;
692 int error = 0;
694 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
695 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
697 if (drv && drv->pm && drv->pm->poweroff_noirq) {
698 error = drv->pm->poweroff_noirq(dev);
699 suspend_report_result(drv->pm->poweroff_noirq, error);
702 return error;
705 static int pci_pm_restore_noirq(struct device *dev)
707 struct pci_dev *pci_dev = to_pci_dev(dev);
708 struct device_driver *drv = dev->driver;
709 int error = 0;
711 pci_pm_default_resume_noirq(pci_dev);
713 if (pci_has_legacy_pm_support(pci_dev))
714 return pci_legacy_resume_early(dev);
716 if (drv && drv->pm && drv->pm->restore_noirq)
717 error = drv->pm->restore_noirq(dev);
719 return error;
722 static int pci_pm_restore(struct device *dev)
724 struct pci_dev *pci_dev = to_pci_dev(dev);
725 struct device_driver *drv = dev->driver;
726 int error = 0;
729 * This is necessary for the hibernation error path in which restore is
730 * called without restoring the standard config registers of the device.
732 if (pci_dev->state_saved)
733 pci_restore_standard_config(pci_dev);
735 if (pci_has_legacy_pm_support(pci_dev))
736 return pci_legacy_resume(dev);
738 error = pci_pm_default_resume(pci_dev);
740 if (!error && drv && drv->pm && drv->pm->restore)
741 error = drv->pm->restore(dev);
743 return error;
746 #else /* !CONFIG_HIBERNATION */
748 #define pci_pm_freeze NULL
749 #define pci_pm_freeze_noirq NULL
750 #define pci_pm_thaw NULL
751 #define pci_pm_thaw_noirq NULL
752 #define pci_pm_poweroff NULL
753 #define pci_pm_poweroff_noirq NULL
754 #define pci_pm_restore NULL
755 #define pci_pm_restore_noirq NULL
757 #endif /* !CONFIG_HIBERNATION */
759 struct dev_pm_ops pci_dev_pm_ops = {
760 .prepare = pci_pm_prepare,
761 .complete = pci_pm_complete,
762 .suspend = pci_pm_suspend,
763 .resume = pci_pm_resume,
764 .freeze = pci_pm_freeze,
765 .thaw = pci_pm_thaw,
766 .poweroff = pci_pm_poweroff,
767 .restore = pci_pm_restore,
768 .suspend_noirq = pci_pm_suspend_noirq,
769 .resume_noirq = pci_pm_resume_noirq,
770 .freeze_noirq = pci_pm_freeze_noirq,
771 .thaw_noirq = pci_pm_thaw_noirq,
772 .poweroff_noirq = pci_pm_poweroff_noirq,
773 .restore_noirq = pci_pm_restore_noirq,
776 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
778 #else /* !CONFIG_PM_SLEEP */
780 #define PCI_PM_OPS_PTR NULL
782 #endif /* !CONFIG_PM_SLEEP */
785 * __pci_register_driver - register a new pci driver
786 * @drv: the driver structure to register
787 * @owner: owner module of drv
788 * @mod_name: module name string
790 * Adds the driver structure to the list of registered drivers.
791 * Returns a negative value on error, otherwise 0.
792 * If no error occurred, the driver remains registered even if
793 * no device was claimed during registration.
795 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
796 const char *mod_name)
798 int error;
800 /* initialize common driver fields */
801 drv->driver.name = drv->name;
802 drv->driver.bus = &pci_bus_type;
803 drv->driver.owner = owner;
804 drv->driver.mod_name = mod_name;
806 spin_lock_init(&drv->dynids.lock);
807 INIT_LIST_HEAD(&drv->dynids.list);
809 /* register with core */
810 error = driver_register(&drv->driver);
811 if (error)
812 return error;
814 error = pci_create_newid_file(drv);
815 if (error)
816 driver_unregister(&drv->driver);
818 return error;
822 * pci_unregister_driver - unregister a pci driver
823 * @drv: the driver structure to unregister
825 * Deletes the driver structure from the list of registered PCI drivers,
826 * gives it a chance to clean up by calling its remove() function for
827 * each device it was responsible for, and marks those devices as
828 * driverless.
831 void
832 pci_unregister_driver(struct pci_driver *drv)
834 pci_remove_newid_file(drv);
835 driver_unregister(&drv->driver);
836 pci_free_dynids(drv);
839 static struct pci_driver pci_compat_driver = {
840 .name = "compat"
844 * pci_dev_driver - get the pci_driver of a device
845 * @dev: the device to query
847 * Returns the appropriate pci_driver structure or %NULL if there is no
848 * registered driver for the device.
850 struct pci_driver *
851 pci_dev_driver(const struct pci_dev *dev)
853 if (dev->driver)
854 return dev->driver;
855 else {
856 int i;
857 for(i=0; i<=PCI_ROM_RESOURCE; i++)
858 if (dev->resource[i].flags & IORESOURCE_BUSY)
859 return &pci_compat_driver;
861 return NULL;
865 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
866 * @dev: the PCI device structure to match against
867 * @drv: the device driver to search for matching PCI device id structures
869 * Used by a driver to check whether a PCI device present in the
870 * system is in its list of supported devices. Returns the matching
871 * pci_device_id structure or %NULL if there is no match.
873 static int pci_bus_match(struct device *dev, struct device_driver *drv)
875 struct pci_dev *pci_dev = to_pci_dev(dev);
876 struct pci_driver *pci_drv = to_pci_driver(drv);
877 const struct pci_device_id *found_id;
879 found_id = pci_match_device(pci_drv, pci_dev);
880 if (found_id)
881 return 1;
883 return 0;
887 * pci_dev_get - increments the reference count of the pci device structure
888 * @dev: the device being referenced
890 * Each live reference to a device should be refcounted.
892 * Drivers for PCI devices should normally record such references in
893 * their probe() methods, when they bind to a device, and release
894 * them by calling pci_dev_put(), in their disconnect() methods.
896 * A pointer to the device with the incremented reference counter is returned.
898 struct pci_dev *pci_dev_get(struct pci_dev *dev)
900 if (dev)
901 get_device(&dev->dev);
902 return dev;
906 * pci_dev_put - release a use of the pci device structure
907 * @dev: device that's been disconnected
909 * Must be called when a user of a device is finished with it. When the last
910 * user of the device calls this function, the memory of the device is freed.
912 void pci_dev_put(struct pci_dev *dev)
914 if (dev)
915 put_device(&dev->dev);
918 #ifndef CONFIG_HOTPLUG
919 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
921 return -ENODEV;
923 #endif
925 struct bus_type pci_bus_type = {
926 .name = "pci",
927 .match = pci_bus_match,
928 .uevent = pci_uevent,
929 .probe = pci_device_probe,
930 .remove = pci_device_remove,
931 .shutdown = pci_device_shutdown,
932 .dev_attrs = pci_dev_attrs,
933 .pm = PCI_PM_OPS_PTR,
936 static int __init pci_driver_init(void)
938 return bus_register(&pci_bus_type);
941 postcore_initcall(pci_driver_init);
943 EXPORT_SYMBOL(pci_match_id);
944 EXPORT_SYMBOL(__pci_register_driver);
945 EXPORT_SYMBOL(pci_unregister_driver);
946 EXPORT_SYMBOL(pci_dev_driver);
947 EXPORT_SYMBOL(pci_bus_type);
948 EXPORT_SYMBOL(pci_dev_get);
949 EXPORT_SYMBOL(pci_dev_put);