1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/string.h> 3 #include <linux/kernel.h> 4 #include <linux/of.h> 5 #include <linux/of_device.h> 6 #include <linux/of_address.h> 7 #include <linux/of_iommu.h> 8 #include <linux/of_reserved_mem.h> 9 #include <linux/dma-direct.h> /* for bus_dma_region */ 10 #include <linux/dma-map-ops.h> 11 #include <linux/init.h> 12 #include <linux/module.h> 13 #include <linux/mod_devicetable.h> 14 #include <linux/slab.h> 15 #include <linux/platform_device.h> 16 17 #include <asm/errno.h> 18 #include "of_private.h" 19 20 /** 21 * of_match_device - Tell if a struct device matches an of_device_id list 22 * @matches: array of of device match structures to search in 23 * @dev: the of device structure to match against 24 * 25 * Used by a driver to check whether an platform_device present in the 26 * system is in its list of supported devices. 27 */ 28 const struct of_device_id *of_match_device(const struct of_device_id *matches, 29 const struct device *dev) 30 { 31 if (!matches || !dev->of_node || dev->of_node_reused) 32 return NULL; 33 return of_match_node(matches, dev->of_node); 34 } 35 EXPORT_SYMBOL(of_match_device); 36 37 int of_device_add(struct platform_device *ofdev) 38 { 39 BUG_ON(ofdev->dev.of_node == NULL); 40 41 /* name and id have to be set so that the platform bus doesn't get 42 * confused on matching */ 43 ofdev->name = dev_name(&ofdev->dev); 44 ofdev->id = PLATFORM_DEVID_NONE; 45 46 /* 47 * If this device has not binding numa node in devicetree, that is 48 * of_node_to_nid returns NUMA_NO_NODE. device_add will assume that this 49 * device is on the same node as the parent. 50 */ 51 set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node)); 52 53 return device_add(&ofdev->dev); 54 } 55 56 static void 57 of_dma_set_restricted_buffer(struct device *dev, struct device_node *np) 58 { 59 struct device_node *node, *of_node = dev->of_node; 60 int count, i; 61 62 if (!IS_ENABLED(CONFIG_DMA_RESTRICTED_POOL)) 63 return; 64 65 count = of_property_count_elems_of_size(of_node, "memory-region", 66 sizeof(u32)); 67 /* 68 * If dev->of_node doesn't exist or doesn't contain memory-region, try 69 * the OF node having DMA configuration. 70 */ 71 if (count <= 0) { 72 of_node = np; 73 count = of_property_count_elems_of_size( 74 of_node, "memory-region", sizeof(u32)); 75 } 76 77 for (i = 0; i < count; i++) { 78 node = of_parse_phandle(of_node, "memory-region", i); 79 /* 80 * There might be multiple memory regions, but only one 81 * restricted-dma-pool region is allowed. 82 */ 83 if (of_device_is_compatible(node, "restricted-dma-pool") && 84 of_device_is_available(node)) 85 break; 86 } 87 88 /* 89 * Attempt to initialize a restricted-dma-pool region if one was found. 90 * Note that count can hold a negative error code. 91 */ 92 if (i < count && of_reserved_mem_device_init_by_idx(dev, of_node, i)) 93 dev_warn(dev, "failed to initialise \"restricted-dma-pool\" memory node\n"); 94 } 95 96 /** 97 * of_dma_configure_id - Setup DMA configuration 98 * @dev: Device to apply DMA configuration 99 * @np: Pointer to OF node having DMA configuration 100 * @force_dma: Whether device is to be set up by of_dma_configure() even if 101 * DMA capability is not explicitly described by firmware. 102 * @id: Optional const pointer value input id 103 * 104 * Try to get devices's DMA configuration from DT and update it 105 * accordingly. 106 * 107 * If platform code needs to use its own special DMA configuration, it 108 * can use a platform bus notifier and handle BUS_NOTIFY_ADD_DEVICE events 109 * to fix up DMA configuration. 110 */ 111 int of_dma_configure_id(struct device *dev, struct device_node *np, 112 bool force_dma, const u32 *id) 113 { 114 const struct iommu_ops *iommu; 115 const struct bus_dma_region *map = NULL; 116 u64 dma_start = 0; 117 u64 mask, end, size = 0; 118 bool coherent; 119 int ret; 120 121 ret = of_dma_get_range(np, &map); 122 if (ret < 0) { 123 /* 124 * For legacy reasons, we have to assume some devices need 125 * DMA configuration regardless of whether "dma-ranges" is 126 * correctly specified or not. 127 */ 128 if (!force_dma) 129 return ret == -ENODEV ? 0 : ret; 130 } else { 131 const struct bus_dma_region *r = map; 132 u64 dma_end = 0; 133 134 /* Determine the overall bounds of all DMA regions */ 135 for (dma_start = ~0; r->size; r++) { 136 /* Take lower and upper limits */ 137 if (r->dma_start < dma_start) 138 dma_start = r->dma_start; 139 if (r->dma_start + r->size > dma_end) 140 dma_end = r->dma_start + r->size; 141 } 142 size = dma_end - dma_start; 143 144 /* 145 * Add a work around to treat the size as mask + 1 in case 146 * it is defined in DT as a mask. 147 */ 148 if (size & 1) { 149 dev_warn(dev, "Invalid size 0x%llx for dma-range(s)\n", 150 size); 151 size = size + 1; 152 } 153 154 if (!size) { 155 dev_err(dev, "Adjusted size 0x%llx invalid\n", size); 156 kfree(map); 157 return -EINVAL; 158 } 159 } 160 161 /* 162 * If @dev is expected to be DMA-capable then the bus code that created 163 * it should have initialised its dma_mask pointer by this point. For 164 * now, we'll continue the legacy behaviour of coercing it to the 165 * coherent mask if not, but we'll no longer do so quietly. 166 */ 167 if (!dev->dma_mask) { 168 dev_warn(dev, "DMA mask not set\n"); 169 dev->dma_mask = &dev->coherent_dma_mask; 170 } 171 172 if (!size && dev->coherent_dma_mask) 173 size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1); 174 else if (!size) 175 size = 1ULL << 32; 176 177 /* 178 * Limit coherent and dma mask based on size and default mask 179 * set by the driver. 180 */ 181 end = dma_start + size - 1; 182 mask = DMA_BIT_MASK(ilog2(end) + 1); 183 dev->coherent_dma_mask &= mask; 184 *dev->dma_mask &= mask; 185 /* ...but only set bus limit and range map if we found valid dma-ranges earlier */ 186 if (!ret) { 187 dev->bus_dma_limit = end; 188 dev->dma_range_map = map; 189 } 190 191 coherent = of_dma_is_coherent(np); 192 dev_dbg(dev, "device is%sdma coherent\n", 193 coherent ? " " : " not "); 194 195 iommu = of_iommu_configure(dev, np, id); 196 if (PTR_ERR(iommu) == -EPROBE_DEFER) { 197 /* Don't touch range map if it wasn't set from a valid dma-ranges */ 198 if (!ret) 199 dev->dma_range_map = NULL; 200 kfree(map); 201 return -EPROBE_DEFER; 202 } 203 204 dev_dbg(dev, "device is%sbehind an iommu\n", 205 iommu ? " " : " not "); 206 207 arch_setup_dma_ops(dev, dma_start, size, iommu, coherent); 208 209 if (!iommu) 210 of_dma_set_restricted_buffer(dev, np); 211 212 return 0; 213 } 214 EXPORT_SYMBOL_GPL(of_dma_configure_id); 215 216 int of_device_register(struct platform_device *pdev) 217 { 218 device_initialize(&pdev->dev); 219 return of_device_add(pdev); 220 } 221 EXPORT_SYMBOL(of_device_register); 222 223 void of_device_unregister(struct platform_device *ofdev) 224 { 225 device_unregister(&ofdev->dev); 226 } 227 EXPORT_SYMBOL(of_device_unregister); 228 229 const void *of_device_get_match_data(const struct device *dev) 230 { 231 const struct of_device_id *match; 232 233 match = of_match_device(dev->driver->of_match_table, dev); 234 if (!match) 235 return NULL; 236 237 return match->data; 238 } 239 EXPORT_SYMBOL(of_device_get_match_data); 240 241 static ssize_t of_device_get_modalias(struct device *dev, char *str, ssize_t len) 242 { 243 const char *compat; 244 char *c; 245 struct property *p; 246 ssize_t csize; 247 ssize_t tsize; 248 249 if ((!dev) || (!dev->of_node)) 250 return -ENODEV; 251 252 /* Name & Type */ 253 /* %p eats all alphanum characters, so %c must be used here */ 254 csize = snprintf(str, len, "of:N%pOFn%c%s", dev->of_node, 'T', 255 of_node_get_device_type(dev->of_node)); 256 tsize = csize; 257 len -= csize; 258 if (str) 259 str += csize; 260 261 of_property_for_each_string(dev->of_node, "compatible", p, compat) { 262 csize = strlen(compat) + 1; 263 tsize += csize; 264 if (csize > len) 265 continue; 266 267 csize = snprintf(str, len, "C%s", compat); 268 for (c = str; c; ) { 269 c = strchr(c, ' '); 270 if (c) 271 *c++ = '_'; 272 } 273 len -= csize; 274 str += csize; 275 } 276 277 return tsize; 278 } 279 280 int of_device_request_module(struct device *dev) 281 { 282 char *str; 283 ssize_t size; 284 int ret; 285 286 size = of_device_get_modalias(dev, NULL, 0); 287 if (size < 0) 288 return size; 289 290 str = kmalloc(size + 1, GFP_KERNEL); 291 if (!str) 292 return -ENOMEM; 293 294 of_device_get_modalias(dev, str, size); 295 str[size] = '\0'; 296 ret = request_module(str); 297 kfree(str); 298 299 return ret; 300 } 301 EXPORT_SYMBOL_GPL(of_device_request_module); 302 303 /** 304 * of_device_modalias - Fill buffer with newline terminated modalias string 305 * @dev: Calling device 306 * @str: Modalias string 307 * @len: Size of @str 308 */ 309 ssize_t of_device_modalias(struct device *dev, char *str, ssize_t len) 310 { 311 ssize_t sl = of_device_get_modalias(dev, str, len - 2); 312 if (sl < 0) 313 return sl; 314 if (sl > len - 2) 315 return -ENOMEM; 316 317 str[sl++] = '\n'; 318 str[sl] = 0; 319 return sl; 320 } 321 EXPORT_SYMBOL_GPL(of_device_modalias); 322 323 /** 324 * of_device_uevent - Display OF related uevent information 325 * @dev: Device to apply DMA configuration 326 * @env: Kernel object's userspace event reference 327 */ 328 void of_device_uevent(struct device *dev, struct kobj_uevent_env *env) 329 { 330 const char *compat, *type; 331 struct alias_prop *app; 332 struct property *p; 333 int seen = 0; 334 335 if ((!dev) || (!dev->of_node)) 336 return; 337 338 add_uevent_var(env, "OF_NAME=%pOFn", dev->of_node); 339 add_uevent_var(env, "OF_FULLNAME=%pOF", dev->of_node); 340 type = of_node_get_device_type(dev->of_node); 341 if (type) 342 add_uevent_var(env, "OF_TYPE=%s", type); 343 344 /* Since the compatible field can contain pretty much anything 345 * it's not really legal to split it out with commas. We split it 346 * up using a number of environment variables instead. */ 347 of_property_for_each_string(dev->of_node, "compatible", p, compat) { 348 add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat); 349 seen++; 350 } 351 add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen); 352 353 seen = 0; 354 mutex_lock(&of_mutex); 355 list_for_each_entry(app, &aliases_lookup, link) { 356 if (dev->of_node == app->np) { 357 add_uevent_var(env, "OF_ALIAS_%d=%s", seen, 358 app->alias); 359 seen++; 360 } 361 } 362 mutex_unlock(&of_mutex); 363 } 364 365 int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env) 366 { 367 int sl; 368 369 if ((!dev) || (!dev->of_node)) 370 return -ENODEV; 371 372 /* Devicetree modalias is tricky, we add it in 2 steps */ 373 if (add_uevent_var(env, "MODALIAS=")) 374 return -ENOMEM; 375 376 sl = of_device_get_modalias(dev, &env->buf[env->buflen-1], 377 sizeof(env->buf) - env->buflen); 378 if (sl >= (sizeof(env->buf) - env->buflen)) 379 return -ENOMEM; 380 env->buflen += sl; 381 382 return 0; 383 } 384 EXPORT_SYMBOL_GPL(of_device_uevent_modalias); 385