1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2023, STMicroelectronics - All Rights Reserved 4 */ 5 6 #include <linux/bitfield.h> 7 #include <linux/bits.h> 8 #include <linux/bus/stm32_firewall_device.h> 9 #include <linux/device.h> 10 #include <linux/err.h> 11 #include <linux/init.h> 12 #include <linux/io.h> 13 #include <linux/kernel.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/of_platform.h> 17 #include <linux/platform_device.h> 18 #include <linux/types.h> 19 #include <linux/slab.h> 20 21 #include "stm32_firewall.h" 22 23 /* Corresponds to STM32_FIREWALL_MAX_EXTRA_ARGS + firewall ID */ 24 #define STM32_FIREWALL_MAX_ARGS (STM32_FIREWALL_MAX_EXTRA_ARGS + 1) 25 26 static LIST_HEAD(firewall_controller_list); 27 static DEFINE_MUTEX(firewall_controller_list_lock); 28 29 /* Firewall device API */ 30 31 int stm32_firewall_get_firewall(struct device_node *np, struct stm32_firewall *firewall, 32 unsigned int nb_firewall) 33 { 34 struct stm32_firewall_controller *ctrl; 35 struct of_phandle_iterator it; 36 unsigned int i, j = 0; 37 int err; 38 39 if (!firewall || !nb_firewall) 40 return -EINVAL; 41 42 /* Parse property with phandle parsed out */ 43 of_for_each_phandle(&it, err, np, "access-controllers", "#access-controller-cells", 0) { 44 struct of_phandle_args provider_args; 45 struct device_node *provider = it.node; 46 const char *fw_entry; 47 bool match = false; 48 49 if (err) { 50 pr_err("Unable to get access-controllers property for node %s\n, err: %d", 51 np->full_name, err); 52 of_node_put(provider); 53 return err; 54 } 55 56 if (j >= nb_firewall) { 57 pr_err("Too many firewall controllers"); 58 of_node_put(provider); 59 return -EINVAL; 60 } 61 62 provider_args.args_count = of_phandle_iterator_args(&it, provider_args.args, 63 STM32_FIREWALL_MAX_ARGS); 64 65 /* Check if the parsed phandle corresponds to a registered firewall controller */ 66 mutex_lock(&firewall_controller_list_lock); 67 list_for_each_entry(ctrl, &firewall_controller_list, entry) { 68 if (ctrl->dev->of_node->phandle == it.phandle) { 69 match = true; 70 firewall[j].firewall_ctrl = ctrl; 71 break; 72 } 73 } 74 mutex_unlock(&firewall_controller_list_lock); 75 76 if (!match) { 77 firewall[j].firewall_ctrl = NULL; 78 pr_err("No firewall controller registered for %s\n", np->full_name); 79 of_node_put(provider); 80 return -ENODEV; 81 } 82 83 err = of_property_read_string_index(np, "access-controller-names", j, &fw_entry); 84 if (err == 0) 85 firewall[j].entry = fw_entry; 86 87 /* Handle the case when there are no arguments given along with the phandle */ 88 if (provider_args.args_count < 0 || 89 provider_args.args_count > STM32_FIREWALL_MAX_ARGS) { 90 of_node_put(provider); 91 return -EINVAL; 92 } else if (provider_args.args_count == 0) { 93 firewall[j].extra_args_size = 0; 94 firewall[j].firewall_id = U32_MAX; 95 j++; 96 continue; 97 } 98 99 /* The firewall ID is always the first argument */ 100 firewall[j].firewall_id = provider_args.args[0]; 101 102 /* Extra args start at the second argument */ 103 for (i = 0; i < provider_args.args_count - 1; i++) 104 firewall[j].extra_args[i] = provider_args.args[i + 1]; 105 106 /* Remove the firewall ID arg that is not an extra argument */ 107 firewall[j].extra_args_size = provider_args.args_count - 1; 108 109 j++; 110 } 111 112 return 0; 113 } 114 EXPORT_SYMBOL_GPL(stm32_firewall_get_firewall); 115 116 int stm32_firewall_grant_access(struct stm32_firewall *firewall) 117 { 118 struct stm32_firewall_controller *firewall_controller; 119 120 if (!firewall || firewall->firewall_id == U32_MAX) 121 return -EINVAL; 122 123 firewall_controller = firewall->firewall_ctrl; 124 125 if (!firewall_controller) 126 return -ENODEV; 127 128 return firewall_controller->grant_access(firewall_controller, firewall->firewall_id); 129 } 130 EXPORT_SYMBOL_GPL(stm32_firewall_grant_access); 131 132 int stm32_firewall_grant_access_by_id(struct stm32_firewall *firewall, u32 subsystem_id) 133 { 134 struct stm32_firewall_controller *firewall_controller; 135 136 if (!firewall || subsystem_id == U32_MAX || firewall->firewall_id == U32_MAX) 137 return -EINVAL; 138 139 firewall_controller = firewall->firewall_ctrl; 140 141 if (!firewall_controller) 142 return -ENODEV; 143 144 return firewall_controller->grant_access(firewall_controller, subsystem_id); 145 } 146 EXPORT_SYMBOL_GPL(stm32_firewall_grant_access_by_id); 147 148 void stm32_firewall_release_access(struct stm32_firewall *firewall) 149 { 150 struct stm32_firewall_controller *firewall_controller; 151 152 if (!firewall || firewall->firewall_id == U32_MAX) { 153 pr_debug("Incorrect arguments when releasing a firewall access\n"); 154 return; 155 } 156 157 firewall_controller = firewall->firewall_ctrl; 158 159 if (!firewall_controller) { 160 pr_debug("No firewall controller to release\n"); 161 return; 162 } 163 164 firewall_controller->release_access(firewall_controller, firewall->firewall_id); 165 } 166 EXPORT_SYMBOL_GPL(stm32_firewall_release_access); 167 168 void stm32_firewall_release_access_by_id(struct stm32_firewall *firewall, u32 subsystem_id) 169 { 170 struct stm32_firewall_controller *firewall_controller; 171 172 if (!firewall || subsystem_id == U32_MAX || firewall->firewall_id == U32_MAX) { 173 pr_debug("Incorrect arguments when releasing a firewall access"); 174 return; 175 } 176 177 firewall_controller = firewall->firewall_ctrl; 178 179 if (!firewall_controller) { 180 pr_debug("No firewall controller to release"); 181 return; 182 } 183 184 firewall_controller->release_access(firewall_controller, subsystem_id); 185 } 186 EXPORT_SYMBOL_GPL(stm32_firewall_release_access_by_id); 187 188 /* Firewall controller API */ 189 190 int stm32_firewall_controller_register(struct stm32_firewall_controller *firewall_controller) 191 { 192 struct stm32_firewall_controller *ctrl; 193 194 if (!firewall_controller) 195 return -ENODEV; 196 197 pr_info("Registering %s firewall controller\n", firewall_controller->name); 198 199 mutex_lock(&firewall_controller_list_lock); 200 list_for_each_entry(ctrl, &firewall_controller_list, entry) { 201 if (ctrl == firewall_controller) { 202 pr_debug("%s firewall controller already registered\n", 203 firewall_controller->name); 204 mutex_unlock(&firewall_controller_list_lock); 205 return 0; 206 } 207 } 208 list_add_tail(&firewall_controller->entry, &firewall_controller_list); 209 mutex_unlock(&firewall_controller_list_lock); 210 211 return 0; 212 } 213 EXPORT_SYMBOL_GPL(stm32_firewall_controller_register); 214 215 void stm32_firewall_controller_unregister(struct stm32_firewall_controller *firewall_controller) 216 { 217 struct stm32_firewall_controller *ctrl; 218 bool controller_removed = false; 219 220 if (!firewall_controller) { 221 pr_debug("Null reference while unregistering firewall controller\n"); 222 return; 223 } 224 225 mutex_lock(&firewall_controller_list_lock); 226 list_for_each_entry(ctrl, &firewall_controller_list, entry) { 227 if (ctrl == firewall_controller) { 228 controller_removed = true; 229 list_del_init(&ctrl->entry); 230 break; 231 } 232 } 233 mutex_unlock(&firewall_controller_list_lock); 234 235 if (!controller_removed) 236 pr_debug("There was no firewall controller named %s to unregister\n", 237 firewall_controller->name); 238 } 239 EXPORT_SYMBOL_GPL(stm32_firewall_controller_unregister); 240 241 int stm32_firewall_populate_bus(struct stm32_firewall_controller *firewall_controller) 242 { 243 struct stm32_firewall *firewalls; 244 struct device_node *child; 245 struct device *parent; 246 unsigned int i; 247 int len; 248 int err; 249 250 parent = firewall_controller->dev; 251 252 dev_dbg(parent, "Populating %s system bus\n", dev_name(firewall_controller->dev)); 253 254 for_each_available_child_of_node(dev_of_node(parent), child) { 255 /* The access-controllers property is mandatory for firewall bus devices */ 256 len = of_count_phandle_with_args(child, "access-controllers", 257 "#access-controller-cells"); 258 if (len <= 0) { 259 of_node_put(child); 260 return -EINVAL; 261 } 262 263 firewalls = kcalloc(len, sizeof(*firewalls), GFP_KERNEL); 264 if (!firewalls) { 265 of_node_put(child); 266 return -ENOMEM; 267 } 268 269 err = stm32_firewall_get_firewall(child, firewalls, (unsigned int)len); 270 if (err) { 271 kfree(firewalls); 272 of_node_put(child); 273 return err; 274 } 275 276 for (i = 0; i < len; i++) { 277 if (firewall_controller->grant_access(firewall_controller, 278 firewalls[i].firewall_id)) { 279 /* 280 * Peripheral access not allowed or not defined. 281 * Mark the node as populated so platform bus won't probe it 282 */ 283 of_detach_node(child); 284 dev_err(parent, "%s: Device driver will not be probed\n", 285 child->full_name); 286 } 287 } 288 289 kfree(firewalls); 290 } 291 292 return 0; 293 } 294 EXPORT_SYMBOL_GPL(stm32_firewall_populate_bus); 295