drivers/of/device.c

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