drivers/firmware/arm_scmi/bus.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * System Control and Management Interface (SCMI) Message Protocol bus layer
   4  *
   5  * Copyright (C) 2018 ARM Ltd.
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/types.h>
  11 #include <linux/module.h>
  12 #include <linux/kernel.h>
  13 #include <linux/slab.h>
  14 #include <linux/device.h>
  15
  16 #include "common.h"
  17
  18 static DEFINE_IDA(scmi_bus_id);
  19 static DEFINE_IDR(scmi_protocols);
  20 static DEFINE_SPINLOCK(protocol_lock);
  21
  22 static const struct scmi_device_id *
  23 scmi_dev_match_id(struct scmi_device *scmi_dev, struct scmi_driver *scmi_drv)
  24 {
  25         const struct scmi_device_id *id = scmi_drv->id_table;
  26
  27         if (!id)
  28                 return NULL;
  29
  30         for (; id->protocol_id; id++)
  31                 if (id->protocol_id == scmi_dev->protocol_id)
  32                         return id;
  33
  34         return NULL;
  35 }
  36
  37 static int scmi_dev_match(struct device *dev, struct device_driver *drv)
  38 {
  39         struct scmi_driver *scmi_drv = to_scmi_driver(drv);
  40         struct scmi_device *scmi_dev = to_scmi_dev(dev);
  41         const struct scmi_device_id *id;
  42
  43         id = scmi_dev_match_id(scmi_dev, scmi_drv);
  44         if (id)
  45                 return 1;
  46
  47         return 0;
  48 }
  49
  50 static int scmi_protocol_init(int protocol_id, struct scmi_handle *handle)
  51 {
  52         scmi_prot_init_fn_t fn = idr_find(&scmi_protocols, protocol_id);
  53
  54         if (unlikely(!fn))
  55                 return -EINVAL;
  56         return fn(handle);
  57 }
  58
  59 static int scmi_dev_probe(struct device *dev)
  60 {
  61         struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);
  62         struct scmi_device *scmi_dev = to_scmi_dev(dev);
  63         const struct scmi_device_id *id;
  64         int ret;
  65
  66         id = scmi_dev_match_id(scmi_dev, scmi_drv);
  67         if (!id)
  68                 return -ENODEV;
  69
  70         if (!scmi_dev->handle)
  71                 return -EPROBE_DEFER;
  72
  73         ret = scmi_protocol_init(scmi_dev->protocol_id, scmi_dev->handle);
  74         if (ret)
  75                 return ret;
  76
  77         return scmi_drv->probe(scmi_dev);
  78 }
  79
  80 static int scmi_dev_remove(struct device *dev)
  81 {
  82         struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);
  83         struct scmi_device *scmi_dev = to_scmi_dev(dev);
  84
  85         if (scmi_drv->remove)
  86                 scmi_drv->remove(scmi_dev);
  87
  88         return 0;
  89 }
  90
  91 static struct bus_type scmi_bus_type = {
  92         .name = "scmi_protocol",
  93         .match = scmi_dev_match,
  94         .probe = scmi_dev_probe,
  95         .remove = scmi_dev_remove,
  96 };
  97
  98 int scmi_driver_register(struct scmi_driver *driver, struct module *owner,
  99                          const char *mod_name)
 100 {
 101         int retval;
 102
 103         driver->driver.bus = &scmi_bus_type;
 104         driver->driver.name = driver->name;
 105         driver->driver.owner = owner;
 106         driver->driver.mod_name = mod_name;
 107
 108         retval = driver_register(&driver->driver);
 109         if (!retval)
 110                 pr_debug("registered new scmi driver %s\n", driver->name);
 111
 112         return retval;
 113 }
 114 EXPORT_SYMBOL_GPL(scmi_driver_register);
 115
 116 void scmi_driver_unregister(struct scmi_driver *driver)
 117 {
 118         driver_unregister(&driver->driver);
 119 }
 120 EXPORT_SYMBOL_GPL(scmi_driver_unregister);
 121
 122 struct scmi_device *
 123 scmi_device_create(struct device_node *np, struct device *parent, int protocol)
 124 {
 125         int id, retval;
 126         struct scmi_device *scmi_dev;
 127
 128         scmi_dev = kzalloc(sizeof(*scmi_dev), GFP_KERNEL);
 129         if (!scmi_dev)
 130                 return NULL;
 131
 132         id = ida_simple_get(&scmi_bus_id, 1, 0, GFP_KERNEL);
 133         if (id < 0)
 134                 goto free_mem;
 135
 136         scmi_dev->id = id;
 137         scmi_dev->protocol_id = protocol;
 138         scmi_dev->dev.parent = parent;
 139         scmi_dev->dev.of_node = np;
 140         scmi_dev->dev.bus = &scmi_bus_type;
 141         dev_set_name(&scmi_dev->dev, "scmi_dev.%d", id);
 142
 143         retval = device_register(&scmi_dev->dev);
 144         if (retval)
 145                 goto put_dev;
 146
 147         return scmi_dev;
 148 put_dev:
 149         put_device(&scmi_dev->dev);
 150         ida_simple_remove(&scmi_bus_id, id);
 151 free_mem:
 152         kfree(scmi_dev);
 153         return NULL;
 154 }
 155
 156 void scmi_device_destroy(struct scmi_device *scmi_dev)
 157 {
 158         scmi_handle_put(scmi_dev->handle);
 159         device_unregister(&scmi_dev->dev);
 160         ida_simple_remove(&scmi_bus_id, scmi_dev->id);
 161         kfree(scmi_dev);
 162 }
 163
 164 void scmi_set_handle(struct scmi_device *scmi_dev)
 165 {
 166         scmi_dev->handle = scmi_handle_get(&scmi_dev->dev);
 167 }
 168
 169 int scmi_protocol_register(int protocol_id, scmi_prot_init_fn_t fn)
 170 {
 171         int ret;
 172
 173         spin_lock(&protocol_lock);
 174         ret = idr_alloc(&scmi_protocols, fn, protocol_id, protocol_id + 1,
 175                         GFP_ATOMIC);
 176         spin_unlock(&protocol_lock);
 177         if (ret != protocol_id)
 178                 pr_err("unable to allocate SCMI idr slot, err %d\n", ret);
 179
 180         return ret;
 181 }
 182 EXPORT_SYMBOL_GPL(scmi_protocol_register);
 183
 184 void scmi_protocol_unregister(int protocol_id)
 185 {
 186         spin_lock(&protocol_lock);
 187         idr_remove(&scmi_protocols, protocol_id);
 188         spin_unlock(&protocol_lock);
 189 }
 190 EXPORT_SYMBOL_GPL(scmi_protocol_unregister);
 191
 192 static int __scmi_devices_unregister(struct device *dev, void *data)
 193 {
 194         struct scmi_device *scmi_dev = to_scmi_dev(dev);
 195
 196         scmi_device_destroy(scmi_dev);
 197         return 0;
 198 }
 199
 200 static void scmi_devices_unregister(void)
 201 {
 202         bus_for_each_dev(&scmi_bus_type, NULL, NULL, __scmi_devices_unregister);
 203 }
 204
 205 static int __init scmi_bus_init(void)
 206 {
 207         int retval;
 208
 209         retval = bus_register(&scmi_bus_type);
 210         if (retval)
 211                 pr_err("scmi protocol bus register failed (%d)\n", retval);
 212
 213         return retval;
 214 }
 215 subsys_initcall(scmi_bus_init);
 216
 217 static void __exit scmi_bus_exit(void)
 218 {
 219         scmi_devices_unregister();
 220         bus_unregister(&scmi_bus_type);
 221         ida_destroy(&scmi_bus_id);
 222 }
 223 module_exit(scmi_bus_exit);