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.
329 static void pci_default_pm_suspend(struct pci_dev *pci_dev)
331 pci_save_state(pci_dev);
333 * mark its power state as "unknown", since we don't know if
334 * e.g. the BIOS will change its device state when we suspend.
336 if (pci_dev->current_state == PCI_D0)
337 pci_dev->current_state = PCI_UNKNOWN;
341 * Default "resume" method for devices that have no driver provided resume,
342 * or not even a driver at all (first part).
344 static void pci_default_pm_resume_early(struct pci_dev *pci_dev)
346 /* restore the PCI config space */
347 pci_restore_state(pci_dev);
351 * Default "resume" method for devices that have no driver provided resume,
352 * or not even a driver at all (second part).
354 static int pci_default_pm_resume_late(struct pci_dev *pci_dev)
358 /* if the device was enabled before suspend, reenable */
359 retval = pci_reenable_device(pci_dev);
361 * if the device was busmaster before the suspend, make it busmaster
364 if (pci_dev->is_busmaster)
365 pci_set_master(pci_dev);
370 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
372 struct pci_dev * pci_dev = to_pci_dev(dev);
373 struct pci_driver * drv = pci_dev->driver;
376 if (drv && drv->suspend) {
377 i = drv->suspend(pci_dev, state);
378 suspend_report_result(drv->suspend, i);
380 pci_default_pm_suspend(pci_dev);
385 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
387 struct pci_dev * pci_dev = to_pci_dev(dev);
388 struct pci_driver * drv = pci_dev->driver;
391 if (drv && drv->suspend_late) {
392 i = drv->suspend_late(pci_dev, state);
393 suspend_report_result(drv->suspend_late, i);
398 static int pci_legacy_resume(struct device *dev)
401 struct pci_dev * pci_dev = to_pci_dev(dev);
402 struct pci_driver * drv = pci_dev->driver;
404 if (drv && drv->resume) {
405 error = drv->resume(pci_dev);
407 pci_default_pm_resume_early(pci_dev);
408 error = pci_default_pm_resume_late(pci_dev);
413 static int pci_legacy_resume_early(struct device *dev)
416 struct pci_dev * pci_dev = to_pci_dev(dev);
417 struct pci_driver * drv = pci_dev->driver;
419 if (drv && drv->resume_early)
420 error = drv->resume_early(pci_dev);
424 static int pci_pm_prepare(struct device *dev)
426 struct device_driver *drv = dev->driver;
429 if (drv && drv->pm && drv->pm->prepare)
430 error = drv->pm->prepare(dev);
435 static void pci_pm_complete(struct device *dev)
437 struct device_driver *drv = dev->driver;
439 if (drv && drv->pm && drv->pm->complete)
440 drv->pm->complete(dev);
443 #ifdef CONFIG_SUSPEND
445 static int pci_pm_suspend(struct device *dev)
447 struct pci_dev *pci_dev = to_pci_dev(dev);
448 struct device_driver *drv = dev->driver;
451 if (drv && drv->pm) {
452 if (drv->pm->suspend) {
453 error = drv->pm->suspend(dev);
454 suspend_report_result(drv->pm->suspend, error);
456 } else if (pci_has_legacy_pm_support(pci_dev)) {
457 error = pci_legacy_suspend(dev, PMSG_SUSPEND);
459 pci_fixup_device(pci_fixup_suspend, pci_dev);
464 static int pci_pm_suspend_noirq(struct device *dev)
466 struct pci_dev *pci_dev = to_pci_dev(dev);
467 struct device_driver *drv = dev->driver;
470 if (drv && drv->pm) {
471 if (drv->pm->suspend_noirq) {
472 error = drv->pm->suspend_noirq(dev);
473 suspend_report_result(drv->pm->suspend_noirq, error);
475 } else if (pci_has_legacy_pm_support(pci_dev)) {
476 error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
478 pci_default_pm_suspend(pci_dev);
484 static int pci_pm_resume(struct device *dev)
486 struct pci_dev *pci_dev = to_pci_dev(dev);
487 struct device_driver *drv = dev->driver;
490 pci_fixup_device(pci_fixup_resume, pci_dev);
492 if (drv && drv->pm) {
494 error = drv->pm->resume(dev);
495 } else if (pci_has_legacy_pm_support(pci_dev)) {
496 error = pci_legacy_resume(dev);
498 error = pci_default_pm_resume_late(pci_dev);
504 static int pci_pm_resume_noirq(struct device *dev)
506 struct pci_dev *pci_dev = to_pci_dev(dev);
507 struct device_driver *drv = dev->driver;
510 pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
512 if (drv && drv->pm) {
513 if (drv->pm->resume_noirq)
514 error = drv->pm->resume_noirq(dev);
515 } else if (pci_has_legacy_pm_support(pci_dev)) {
516 error = pci_legacy_resume_early(dev);
518 pci_default_pm_resume_early(pci_dev);
524 #else /* !CONFIG_SUSPEND */
526 #define pci_pm_suspend NULL
527 #define pci_pm_suspend_noirq NULL
528 #define pci_pm_resume NULL
529 #define pci_pm_resume_noirq NULL
531 #endif /* !CONFIG_SUSPEND */
533 #ifdef CONFIG_HIBERNATION
535 static int pci_pm_freeze(struct device *dev)
537 struct pci_dev *pci_dev = to_pci_dev(dev);
538 struct device_driver *drv = dev->driver;
541 if (drv && drv->pm) {
542 if (drv->pm->freeze) {
543 error = drv->pm->freeze(dev);
544 suspend_report_result(drv->pm->freeze, error);
546 } else if (pci_has_legacy_pm_support(pci_dev)) {
547 error = pci_legacy_suspend(dev, PMSG_FREEZE);
548 pci_fixup_device(pci_fixup_suspend, pci_dev);
554 static int pci_pm_freeze_noirq(struct device *dev)
556 struct pci_dev *pci_dev = to_pci_dev(dev);
557 struct device_driver *drv = dev->driver;
560 if (drv && drv->pm) {
561 if (drv->pm->freeze_noirq) {
562 error = drv->pm->freeze_noirq(dev);
563 suspend_report_result(drv->pm->freeze_noirq, error);
565 } else if (pci_has_legacy_pm_support(pci_dev)) {
566 error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
568 pci_default_pm_suspend(pci_dev);
574 static int pci_pm_thaw(struct device *dev)
576 struct pci_dev *pci_dev = to_pci_dev(dev);
577 struct device_driver *drv = dev->driver;
580 if (drv && drv->pm) {
582 error = drv->pm->thaw(dev);
583 } else if (pci_has_legacy_pm_support(pci_dev)) {
584 pci_fixup_device(pci_fixup_resume, pci_dev);
585 error = pci_legacy_resume(dev);
591 static int pci_pm_thaw_noirq(struct device *dev)
593 struct pci_dev *pci_dev = to_pci_dev(dev);
594 struct device_driver *drv = dev->driver;
597 if (drv && drv->pm) {
598 if (drv->pm->thaw_noirq)
599 error = drv->pm->thaw_noirq(dev);
600 } else if (pci_has_legacy_pm_support(pci_dev)) {
601 pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
602 error = pci_legacy_resume_early(dev);
608 static int pci_pm_poweroff(struct device *dev)
610 struct pci_dev *pci_dev = to_pci_dev(dev);
611 struct device_driver *drv = dev->driver;
614 pci_fixup_device(pci_fixup_suspend, pci_dev);
616 if (drv && drv->pm) {
617 if (drv->pm->poweroff) {
618 error = drv->pm->poweroff(dev);
619 suspend_report_result(drv->pm->poweroff, error);
621 } else if (pci_has_legacy_pm_support(pci_dev)) {
622 error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
628 static int pci_pm_poweroff_noirq(struct device *dev)
630 struct device_driver *drv = dev->driver;
633 if (drv && drv->pm) {
634 if (drv->pm->poweroff_noirq) {
635 error = drv->pm->poweroff_noirq(dev);
636 suspend_report_result(drv->pm->poweroff_noirq, error);
638 } else if (pci_has_legacy_pm_support(to_pci_dev(dev))) {
639 error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
645 static int pci_pm_restore(struct device *dev)
647 struct pci_dev *pci_dev = to_pci_dev(dev);
648 struct device_driver *drv = dev->driver;
651 if (drv && drv->pm) {
652 if (drv->pm->restore)
653 error = drv->pm->restore(dev);
654 } else if (pci_has_legacy_pm_support(pci_dev)) {
655 error = pci_legacy_resume(dev);
657 error = pci_default_pm_resume_late(pci_dev);
659 pci_fixup_device(pci_fixup_resume, pci_dev);
664 static int pci_pm_restore_noirq(struct device *dev)
666 struct pci_dev *pci_dev = to_pci_dev(dev);
667 struct device_driver *drv = dev->driver;
670 pci_fixup_device(pci_fixup_resume, pci_dev);
672 if (drv && drv->pm) {
673 if (drv->pm->restore_noirq)
674 error = drv->pm->restore_noirq(dev);
675 } else if (pci_has_legacy_pm_support(pci_dev)) {
676 error = pci_legacy_resume_early(dev);
678 pci_default_pm_resume_early(pci_dev);
680 pci_fixup_device(pci_fixup_resume_early, pci_dev);
685 #else /* !CONFIG_HIBERNATION */
687 #define pci_pm_freeze NULL
688 #define pci_pm_freeze_noirq NULL
689 #define pci_pm_thaw NULL
690 #define pci_pm_thaw_noirq NULL
691 #define pci_pm_poweroff NULL
692 #define pci_pm_poweroff_noirq NULL
693 #define pci_pm_restore NULL
694 #define pci_pm_restore_noirq NULL
696 #endif /* !CONFIG_HIBERNATION */
698 struct dev_pm_ops pci_dev_pm_ops = {
699 .prepare = pci_pm_prepare,
700 .complete = pci_pm_complete,
701 .suspend = pci_pm_suspend,
702 .resume = pci_pm_resume,
703 .freeze = pci_pm_freeze,
705 .poweroff = pci_pm_poweroff,
706 .restore = pci_pm_restore,
707 .suspend_noirq = pci_pm_suspend_noirq,
708 .resume_noirq = pci_pm_resume_noirq,
709 .freeze_noirq = pci_pm_freeze_noirq,
710 .thaw_noirq = pci_pm_thaw_noirq,
711 .poweroff_noirq = pci_pm_poweroff_noirq,
712 .restore_noirq = pci_pm_restore_noirq,
715 #define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
717 #else /* !CONFIG_PM_SLEEP */
719 #define PCI_PM_OPS_PTR NULL
721 #endif /* !CONFIG_PM_SLEEP */
724 * __pci_register_driver - register a new pci driver
725 * @drv: the driver structure to register
726 * @owner: owner module of drv
727 * @mod_name: module name string
729 * Adds the driver structure to the list of registered drivers.
730 * Returns a negative value on error, otherwise 0.
731 * If no error occurred, the driver remains registered even if
732 * no device was claimed during registration.
734 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
735 const char *mod_name)
739 /* initialize common driver fields */
740 drv->driver.name = drv->name;
741 drv->driver.bus = &pci_bus_type;
742 drv->driver.owner = owner;
743 drv->driver.mod_name = mod_name;
745 spin_lock_init(&drv->dynids.lock);
746 INIT_LIST_HEAD(&drv->dynids.list);
748 /* register with core */
749 error = driver_register(&drv->driver);
753 error = pci_create_newid_file(drv);
755 driver_unregister(&drv->driver);
761 * pci_unregister_driver - unregister a pci driver
762 * @drv: the driver structure to unregister
764 * Deletes the driver structure from the list of registered PCI drivers,
765 * gives it a chance to clean up by calling its remove() function for
766 * each device it was responsible for, and marks those devices as
771 pci_unregister_driver(struct pci_driver *drv)
773 pci_remove_newid_file(drv);
774 driver_unregister(&drv->driver);
775 pci_free_dynids(drv);
778 static struct pci_driver pci_compat_driver = {
783 * pci_dev_driver - get the pci_driver of a device
784 * @dev: the device to query
786 * Returns the appropriate pci_driver structure or %NULL if there is no
787 * registered driver for the device.
790 pci_dev_driver(const struct pci_dev *dev)
796 for(i=0; i<=PCI_ROM_RESOURCE; i++)
797 if (dev->resource[i].flags & IORESOURCE_BUSY)
798 return &pci_compat_driver;
804 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
805 * @dev: the PCI device structure to match against
806 * @drv: the device driver to search for matching PCI device id structures
808 * Used by a driver to check whether a PCI device present in the
809 * system is in its list of supported devices. Returns the matching
810 * pci_device_id structure or %NULL if there is no match.
812 static int pci_bus_match(struct device *dev, struct device_driver *drv)
814 struct pci_dev *pci_dev = to_pci_dev(dev);
815 struct pci_driver *pci_drv = to_pci_driver(drv);
816 const struct pci_device_id *found_id;
818 found_id = pci_match_device(pci_drv, pci_dev);
826 * pci_dev_get - increments the reference count of the pci device structure
827 * @dev: the device being referenced
829 * Each live reference to a device should be refcounted.
831 * Drivers for PCI devices should normally record such references in
832 * their probe() methods, when they bind to a device, and release
833 * them by calling pci_dev_put(), in their disconnect() methods.
835 * A pointer to the device with the incremented reference counter is returned.
837 struct pci_dev *pci_dev_get(struct pci_dev *dev)
840 get_device(&dev->dev);
845 * pci_dev_put - release a use of the pci device structure
846 * @dev: device that's been disconnected
848 * Must be called when a user of a device is finished with it. When the last
849 * user of the device calls this function, the memory of the device is freed.
851 void pci_dev_put(struct pci_dev *dev)
854 put_device(&dev->dev);
857 #ifndef CONFIG_HOTPLUG
858 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
864 struct bus_type pci_bus_type = {
866 .match = pci_bus_match,
867 .uevent = pci_uevent,
868 .probe = pci_device_probe,
869 .remove = pci_device_remove,
870 .shutdown = pci_device_shutdown,
871 .dev_attrs = pci_dev_attrs,
872 .pm = PCI_PM_OPS_PTR,
875 static int __init pci_driver_init(void)
877 return bus_register(&pci_bus_type);
880 postcore_initcall(pci_driver_init);
882 EXPORT_SYMBOL(pci_match_id);
883 EXPORT_SYMBOL(__pci_register_driver);
884 EXPORT_SYMBOL(pci_unregister_driver);
885 EXPORT_SYMBOL(pci_dev_driver);
886 EXPORT_SYMBOL(pci_bus_type);
887 EXPORT_SYMBOL(pci_dev_get);
888 EXPORT_SYMBOL(pci_dev_put);