drivers/base/isa.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * ISA bus.
0004  */
0005
0006 #include <linux/device.h>
0007 #include <linux/kernel.h>
0008 #include <linux/slab.h>
0009 #include <linux/module.h>
0010 #include <linux/init.h>
0011 #include <linux/dma-mapping.h>
0012 #include <linux/isa.h>
0013
0014 static struct device isa_bus = {
0015     .init_name  = "isa"
0016 };
0017
0018 struct isa_dev {
0019     struct device dev;
0020     struct device *next;
0021     unsigned int id;
0022 };
0023
0024 #define to_isa_dev(x) container_of((x), struct isa_dev, dev)
0025
0026 static int isa_bus_match(struct device *dev, struct device_driver *driver)
0027 {
0028     struct isa_driver *isa_driver = to_isa_driver(driver);
0029
0030     if (dev->platform_data == isa_driver) {
0031         if (!isa_driver->match ||
0032             isa_driver->match(dev, to_isa_dev(dev)->id))
0033             return 1;
0034         dev->platform_data = NULL;
0035     }
0036     return 0;
0037 }
0038
0039 static int isa_bus_probe(struct device *dev)
0040 {
0041     struct isa_driver *isa_driver = dev->platform_data;
0042
0043     if (isa_driver && isa_driver->probe)
0044         return isa_driver->probe(dev, to_isa_dev(dev)->id);
0045
0046     return 0;
0047 }
0048
0049 static void isa_bus_remove(struct device *dev)
0050 {
0051     struct isa_driver *isa_driver = dev->platform_data;
0052
0053     if (isa_driver && isa_driver->remove)
0054         isa_driver->remove(dev, to_isa_dev(dev)->id);
0055 }
0056
0057 static void isa_bus_shutdown(struct device *dev)
0058 {
0059     struct isa_driver *isa_driver = dev->platform_data;
0060
0061     if (isa_driver && isa_driver->shutdown)
0062         isa_driver->shutdown(dev, to_isa_dev(dev)->id);
0063 }
0064
0065 static int isa_bus_suspend(struct device *dev, pm_message_t state)
0066 {
0067     struct isa_driver *isa_driver = dev->platform_data;
0068
0069     if (isa_driver && isa_driver->suspend)
0070         return isa_driver->suspend(dev, to_isa_dev(dev)->id, state);
0071
0072     return 0;
0073 }
0074
0075 static int isa_bus_resume(struct device *dev)
0076 {
0077     struct isa_driver *isa_driver = dev->platform_data;
0078
0079     if (isa_driver && isa_driver->resume)
0080         return isa_driver->resume(dev, to_isa_dev(dev)->id);
0081
0082     return 0;
0083 }
0084
0085 static struct bus_type isa_bus_type = {
0086     .name       = "isa",
0087     .match      = isa_bus_match,
0088     .probe      = isa_bus_probe,
0089     .remove     = isa_bus_remove,
0090     .shutdown   = isa_bus_shutdown,
0091     .suspend    = isa_bus_suspend,
0092     .resume     = isa_bus_resume
0093 };
0094
0095 static void isa_dev_release(struct device *dev)
0096 {
0097     kfree(to_isa_dev(dev));
0098 }
0099
0100 void isa_unregister_driver(struct isa_driver *isa_driver)
0101 {
0102     struct device *dev = isa_driver->devices;
0103
0104     while (dev) {
0105         struct device *tmp = to_isa_dev(dev)->next;
0106         device_unregister(dev);
0107         dev = tmp;
0108     }
0109     driver_unregister(&isa_driver->driver);
0110 }
0111 EXPORT_SYMBOL_GPL(isa_unregister_driver);
0112
0113 int isa_register_driver(struct isa_driver *isa_driver, unsigned int ndev)
0114 {
0115     int error;
0116     unsigned int id;
0117
0118     isa_driver->driver.bus  = &isa_bus_type;
0119     isa_driver->devices = NULL;
0120
0121     error = driver_register(&isa_driver->driver);
0122     if (error)
0123         return error;
0124
0125     for (id = 0; id < ndev; id++) {
0126         struct isa_dev *isa_dev;
0127
0128         isa_dev = kzalloc(sizeof *isa_dev, GFP_KERNEL);
0129         if (!isa_dev) {
0130             error = -ENOMEM;
0131             break;
0132         }
0133
0134         isa_dev->dev.parent = &isa_bus;
0135         isa_dev->dev.bus    = &isa_bus_type;
0136
0137         dev_set_name(&isa_dev->dev, "%s.%u",
0138                  isa_driver->driver.name, id);
0139         isa_dev->dev.platform_data  = isa_driver;
0140         isa_dev->dev.release        = isa_dev_release;
0141         isa_dev->id         = id;
0142
0143         isa_dev->dev.coherent_dma_mask = DMA_BIT_MASK(24);
0144         isa_dev->dev.dma_mask = &isa_dev->dev.coherent_dma_mask;
0145
0146         error = device_register(&isa_dev->dev);
0147         if (error) {
0148             put_device(&isa_dev->dev);
0149             break;
0150         }
0151
0152         if (isa_dev->dev.platform_data) {
0153             isa_dev->next = isa_driver->devices;
0154             isa_driver->devices = &isa_dev->dev;
0155         } else
0156             device_unregister(&isa_dev->dev);
0157     }
0158
0159     if (!error && !isa_driver->devices)
0160         error = -ENODEV;
0161
0162     if (error)
0163         isa_unregister_driver(isa_driver);
0164
0165     return error;
0166 }
0167 EXPORT_SYMBOL_GPL(isa_register_driver);
0168
0169 static int __init isa_bus_init(void)
0170 {
0171     int error;
0172
0173     error = bus_register(&isa_bus_type);
0174     if (!error) {
0175         error = device_register(&isa_bus);
0176         if (error)
0177             bus_unregister(&isa_bus_type);
0178     }
0179     return error;
0180 }
0181
0182 postcore_initcall(isa_bus_init);