Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Device tree based initialization code for reserved memory. |
| 3 | * |
Liam Mark | 6b6b749 | 2017-04-13 17:11:54 -0700 | [diff] [blame] | 4 | * Copyright (c) 2013, 2015, 2017 The Linux Foundation. All Rights Reserved. |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 5 | * Copyright (c) 2013,2014 Samsung Electronics Co., Ltd. |
| 6 | * http://www.samsung.com |
| 7 | * Author: Marek Szyprowski <m.szyprowski@samsung.com> |
| 8 | * Author: Josh Cartwright <joshc@codeaurora.org> |
| 9 | * |
| 10 | * This program is free software; you can redistribute it and/or |
| 11 | * modify it under the terms of the GNU General Public License as |
| 12 | * published by the Free Software Foundation; either version 2 of the |
| 13 | * License or (at your optional) any later version of the license. |
| 14 | */ |
| 15 | |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 16 | #define pr_fmt(fmt) "OF: reserved mem: " fmt |
| 17 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 18 | #include <linux/err.h> |
| 19 | #include <linux/of.h> |
| 20 | #include <linux/of_fdt.h> |
| 21 | #include <linux/of_platform.h> |
| 22 | #include <linux/mm.h> |
| 23 | #include <linux/sizes.h> |
| 24 | #include <linux/of_reserved_mem.h> |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 25 | #include <linux/sort.h> |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 26 | #include <linux/slab.h> |
Patrick Daly | dc2ffa9 | 2017-09-29 18:04:45 -0700 | [diff] [blame] | 27 | #include <linux/kmemleak.h> |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 28 | |
Liam Mark | 6b6b749 | 2017-04-13 17:11:54 -0700 | [diff] [blame] | 29 | #define MAX_RESERVED_REGIONS 32 |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 30 | static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS]; |
| 31 | static int reserved_mem_count; |
| 32 | |
| 33 | #if defined(CONFIG_HAVE_MEMBLOCK) |
| 34 | #include <linux/memblock.h> |
| 35 | int __init __weak early_init_dt_alloc_reserved_memory_arch(phys_addr_t size, |
| 36 | phys_addr_t align, phys_addr_t start, phys_addr_t end, bool nomap, |
| 37 | phys_addr_t *res_base) |
| 38 | { |
Vinayak Menon | e53b50c | 2016-02-22 19:15:44 +0530 | [diff] [blame] | 39 | phys_addr_t base; |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 40 | /* |
| 41 | * We use __memblock_alloc_base() because memblock_alloc_base() |
| 42 | * panic()s on allocation failure. |
| 43 | */ |
Vinayak Menon | e53b50c | 2016-02-22 19:15:44 +0530 | [diff] [blame] | 44 | end = !end ? MEMBLOCK_ALLOC_ANYWHERE : end; |
| 45 | base = __memblock_alloc_base(size, align, end); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 46 | if (!base) |
| 47 | return -ENOMEM; |
| 48 | |
| 49 | /* |
| 50 | * Check if the allocated region fits in to start..end window |
| 51 | */ |
| 52 | if (base < start) { |
| 53 | memblock_free(base, size); |
| 54 | return -ENOMEM; |
| 55 | } |
| 56 | |
| 57 | *res_base = base; |
Patrick Daly | dc2ffa9 | 2017-09-29 18:04:45 -0700 | [diff] [blame] | 58 | if (nomap) { |
| 59 | kmemleak_ignore_phys(base); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 60 | return memblock_remove(base, size); |
Patrick Daly | dc2ffa9 | 2017-09-29 18:04:45 -0700 | [diff] [blame] | 61 | } |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 62 | return 0; |
| 63 | } |
| 64 | #else |
| 65 | int __init __weak early_init_dt_alloc_reserved_memory_arch(phys_addr_t size, |
| 66 | phys_addr_t align, phys_addr_t start, phys_addr_t end, bool nomap, |
| 67 | phys_addr_t *res_base) |
| 68 | { |
| 69 | pr_err("Reserved memory not supported, ignoring region 0x%llx%s\n", |
| 70 | size, nomap ? " (nomap)" : ""); |
| 71 | return -ENOSYS; |
| 72 | } |
| 73 | #endif |
| 74 | |
| 75 | /** |
| 76 | * res_mem_save_node() - save fdt node for second pass initialization |
| 77 | */ |
| 78 | void __init fdt_reserved_mem_save_node(unsigned long node, const char *uname, |
| 79 | phys_addr_t base, phys_addr_t size) |
| 80 | { |
| 81 | struct reserved_mem *rmem = &reserved_mem[reserved_mem_count]; |
| 82 | |
| 83 | if (reserved_mem_count == ARRAY_SIZE(reserved_mem)) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 84 | pr_err("not enough space all defined regions.\n"); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 85 | return; |
| 86 | } |
| 87 | |
| 88 | rmem->fdt_node = node; |
| 89 | rmem->name = uname; |
| 90 | rmem->base = base; |
| 91 | rmem->size = size; |
| 92 | |
| 93 | reserved_mem_count++; |
| 94 | return; |
| 95 | } |
| 96 | |
| 97 | /** |
| 98 | * res_mem_alloc_size() - allocate reserved memory described by 'size', 'align' |
| 99 | * and 'alloc-ranges' properties |
| 100 | */ |
| 101 | static int __init __reserved_mem_alloc_size(unsigned long node, |
| 102 | const char *uname, phys_addr_t *res_base, phys_addr_t *res_size) |
| 103 | { |
| 104 | int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32); |
| 105 | phys_addr_t start = 0, end = 0; |
| 106 | phys_addr_t base = 0, align = 0, size; |
Rob Herring | 9d0c4df | 2014-04-01 23:49:03 -0500 | [diff] [blame] | 107 | int len; |
| 108 | const __be32 *prop; |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 109 | int nomap; |
| 110 | int ret; |
| 111 | |
| 112 | prop = of_get_flat_dt_prop(node, "size", &len); |
| 113 | if (!prop) |
| 114 | return -EINVAL; |
| 115 | |
| 116 | if (len != dt_root_size_cells * sizeof(__be32)) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 117 | pr_err("invalid size property in '%s' node.\n", uname); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 118 | return -EINVAL; |
| 119 | } |
| 120 | size = dt_mem_next_cell(dt_root_size_cells, &prop); |
| 121 | |
| 122 | nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL; |
| 123 | |
| 124 | prop = of_get_flat_dt_prop(node, "alignment", &len); |
| 125 | if (prop) { |
| 126 | if (len != dt_root_addr_cells * sizeof(__be32)) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 127 | pr_err("invalid alignment property in '%s' node.\n", |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 128 | uname); |
| 129 | return -EINVAL; |
| 130 | } |
| 131 | align = dt_mem_next_cell(dt_root_addr_cells, &prop); |
| 132 | } |
| 133 | |
Jason Liu | 1cc8e34 | 2015-11-10 20:30:26 +0800 | [diff] [blame] | 134 | /* Need adjust the alignment to satisfy the CMA requirement */ |
Jaewon | 7d48281 | 2016-05-25 13:29:50 +0900 | [diff] [blame] | 135 | if (IS_ENABLED(CONFIG_CMA) |
| 136 | && of_flat_dt_is_compatible(node, "shared-dma-pool") |
| 137 | && of_get_flat_dt_prop(node, "reusable", NULL) |
Stephen Rothwell | aaaab56 | 2016-05-31 09:38:56 +1000 | [diff] [blame] | 138 | && !of_get_flat_dt_prop(node, "no-map", NULL)) { |
| 139 | unsigned long order = |
| 140 | max_t(unsigned long, MAX_ORDER - 1, pageblock_order); |
| 141 | |
| 142 | align = max(align, (phys_addr_t)PAGE_SIZE << order); |
| 143 | } |
Jason Liu | 1cc8e34 | 2015-11-10 20:30:26 +0800 | [diff] [blame] | 144 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 145 | prop = of_get_flat_dt_prop(node, "alloc-ranges", &len); |
| 146 | if (prop) { |
| 147 | |
| 148 | if (len % t_len != 0) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 149 | pr_err("invalid alloc-ranges property in '%s', skipping node.\n", |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 150 | uname); |
| 151 | return -EINVAL; |
| 152 | } |
| 153 | |
| 154 | base = 0; |
| 155 | |
| 156 | while (len > 0) { |
| 157 | start = dt_mem_next_cell(dt_root_addr_cells, &prop); |
| 158 | end = start + dt_mem_next_cell(dt_root_size_cells, |
| 159 | &prop); |
| 160 | |
| 161 | ret = early_init_dt_alloc_reserved_memory_arch(size, |
| 162 | align, start, end, nomap, &base); |
| 163 | if (ret == 0) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 164 | pr_debug("allocated memory for '%s' node: base %pa, size %ld MiB\n", |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 165 | uname, &base, |
| 166 | (unsigned long)size / SZ_1M); |
| 167 | break; |
| 168 | } |
| 169 | len -= t_len; |
| 170 | } |
| 171 | |
| 172 | } else { |
| 173 | ret = early_init_dt_alloc_reserved_memory_arch(size, align, |
| 174 | 0, 0, nomap, &base); |
| 175 | if (ret == 0) |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 176 | pr_debug("allocated memory for '%s' node: base %pa, size %ld MiB\n", |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 177 | uname, &base, (unsigned long)size / SZ_1M); |
| 178 | } |
| 179 | |
| 180 | if (base == 0) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 181 | pr_info("failed to allocate memory for node '%s'\n", uname); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 182 | return -ENOMEM; |
| 183 | } |
| 184 | |
| 185 | *res_base = base; |
| 186 | *res_size = size; |
| 187 | |
| 188 | return 0; |
| 189 | } |
| 190 | |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 191 | static const struct of_device_id __rmem_of_table_sentinel |
| 192 | __used __section(__reservedmem_of_table_end); |
| 193 | |
| 194 | /** |
| 195 | * res_mem_init_node() - call region specific reserved memory init code |
| 196 | */ |
| 197 | static int __init __reserved_mem_init_node(struct reserved_mem *rmem) |
| 198 | { |
| 199 | extern const struct of_device_id __reservedmem_of_table[]; |
| 200 | const struct of_device_id *i; |
| 201 | |
| 202 | for (i = __reservedmem_of_table; i < &__rmem_of_table_sentinel; i++) { |
| 203 | reservedmem_of_init_fn initfn = i->data; |
| 204 | const char *compat = i->compatible; |
| 205 | |
| 206 | if (!of_flat_dt_is_compatible(rmem->fdt_node, compat)) |
| 207 | continue; |
| 208 | |
Rob Herring | 9dd3107 | 2014-05-08 16:06:17 -0500 | [diff] [blame] | 209 | if (initfn(rmem) == 0) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 210 | pr_info("initialized node %s, compatible id %s\n", |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 211 | rmem->name, compat); |
| 212 | return 0; |
| 213 | } |
| 214 | } |
| 215 | return -ENOENT; |
| 216 | } |
| 217 | |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 218 | static int __init __rmem_cmp(const void *a, const void *b) |
| 219 | { |
| 220 | const struct reserved_mem *ra = a, *rb = b; |
| 221 | |
Michael Ellerman | 9eb8cd2 | 2015-11-18 21:46:38 +1100 | [diff] [blame] | 222 | if (ra->base < rb->base) |
| 223 | return -1; |
| 224 | |
| 225 | if (ra->base > rb->base) |
| 226 | return 1; |
| 227 | |
| 228 | return 0; |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | static void __init __rmem_check_for_overlap(void) |
| 232 | { |
| 233 | int i; |
| 234 | |
| 235 | if (reserved_mem_count < 2) |
| 236 | return; |
| 237 | |
| 238 | sort(reserved_mem, reserved_mem_count, sizeof(reserved_mem[0]), |
| 239 | __rmem_cmp, NULL); |
| 240 | for (i = 0; i < reserved_mem_count - 1; i++) { |
| 241 | struct reserved_mem *this, *next; |
| 242 | |
| 243 | this = &reserved_mem[i]; |
| 244 | next = &reserved_mem[i + 1]; |
| 245 | if (!(this->base && next->base)) |
| 246 | continue; |
| 247 | if (this->base + this->size > next->base) { |
| 248 | phys_addr_t this_end, next_end; |
| 249 | |
| 250 | this_end = this->base + this->size; |
| 251 | next_end = next->base + next->size; |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 252 | pr_err("OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n", |
Michael Ellerman | 85a1c77 | 2015-11-10 16:08:33 +1100 | [diff] [blame] | 253 | this->name, &this->base, &this_end, |
| 254 | next->name, &next->base, &next_end); |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 255 | } |
| 256 | } |
| 257 | } |
| 258 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 259 | /** |
| 260 | * fdt_init_reserved_mem - allocate and init all saved reserved memory regions |
| 261 | */ |
| 262 | void __init fdt_init_reserved_mem(void) |
| 263 | { |
| 264 | int i; |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 265 | |
| 266 | /* check for overlapping reserved regions */ |
| 267 | __rmem_check_for_overlap(); |
| 268 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 269 | for (i = 0; i < reserved_mem_count; i++) { |
| 270 | struct reserved_mem *rmem = &reserved_mem[i]; |
| 271 | unsigned long node = rmem->fdt_node; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 272 | int len; |
| 273 | const __be32 *prop; |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 274 | int err = 0; |
| 275 | |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 276 | prop = of_get_flat_dt_prop(node, "phandle", &len); |
| 277 | if (!prop) |
| 278 | prop = of_get_flat_dt_prop(node, "linux,phandle", &len); |
| 279 | if (prop) |
| 280 | rmem->phandle = of_read_number(prop, len/4); |
| 281 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 282 | if (rmem->size == 0) |
| 283 | err = __reserved_mem_alloc_size(node, rmem->name, |
| 284 | &rmem->base, &rmem->size); |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 285 | if (err == 0) |
| 286 | __reserved_mem_init_node(rmem); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 287 | } |
| 288 | } |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 289 | |
| 290 | static inline struct reserved_mem *__find_rmem(struct device_node *node) |
| 291 | { |
| 292 | unsigned int i; |
| 293 | |
| 294 | if (!node->phandle) |
| 295 | return NULL; |
| 296 | |
| 297 | for (i = 0; i < reserved_mem_count; i++) |
| 298 | if (reserved_mem[i].phandle == node->phandle) |
| 299 | return &reserved_mem[i]; |
| 300 | return NULL; |
| 301 | } |
| 302 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 303 | struct rmem_assigned_device { |
| 304 | struct device *dev; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 305 | struct reserved_mem *rmem; |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 306 | struct list_head list; |
| 307 | }; |
| 308 | |
| 309 | static LIST_HEAD(of_rmem_assigned_device_list); |
| 310 | static DEFINE_MUTEX(of_rmem_assigned_device_mutex); |
| 311 | |
| 312 | /** |
| 313 | * of_reserved_mem_device_init_by_idx() - assign reserved memory region to |
| 314 | * given device |
| 315 | * @dev: Pointer to the device to configure |
| 316 | * @np: Pointer to the device_node with 'reserved-memory' property |
| 317 | * @idx: Index of selected region |
| 318 | * |
| 319 | * This function assigns respective DMA-mapping operations based on reserved |
| 320 | * memory region specified by 'memory-region' property in @np node to the @dev |
| 321 | * device. When driver needs to use more than one reserved memory region, it |
| 322 | * should allocate child devices and initialize regions by name for each of |
| 323 | * child device. |
| 324 | * |
| 325 | * Returns error code or zero on success. |
| 326 | */ |
| 327 | int of_reserved_mem_device_init_by_idx(struct device *dev, |
| 328 | struct device_node *np, int idx) |
| 329 | { |
| 330 | struct rmem_assigned_device *rd; |
| 331 | struct device_node *target; |
| 332 | struct reserved_mem *rmem; |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 333 | int ret; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 334 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 335 | if (!np || !dev) |
| 336 | return -EINVAL; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 337 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 338 | target = of_parse_phandle(np, "memory-region", idx); |
| 339 | if (!target) |
Marek Szyprowski | 9f5a802 | 2016-06-08 03:51:53 -0300 | [diff] [blame] | 340 | return -ENODEV; |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 341 | |
| 342 | rmem = __find_rmem(target); |
| 343 | of_node_put(target); |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 344 | |
| 345 | if (!rmem || !rmem->ops || !rmem->ops->device_init) |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 346 | return -EINVAL; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 347 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 348 | rd = kmalloc(sizeof(struct rmem_assigned_device), GFP_KERNEL); |
| 349 | if (!rd) |
| 350 | return -ENOMEM; |
| 351 | |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 352 | ret = rmem->ops->device_init(rmem, dev); |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 353 | if (ret == 0) { |
| 354 | rd->dev = dev; |
| 355 | rd->rmem = rmem; |
| 356 | |
| 357 | mutex_lock(&of_rmem_assigned_device_mutex); |
| 358 | list_add(&rd->list, &of_rmem_assigned_device_list); |
| 359 | mutex_unlock(&of_rmem_assigned_device_mutex); |
| 360 | |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 361 | dev_info(dev, "assigned reserved memory node %s\n", rmem->name); |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 362 | } else { |
| 363 | kfree(rd); |
| 364 | } |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 365 | |
| 366 | return ret; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 367 | } |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 368 | EXPORT_SYMBOL_GPL(of_reserved_mem_device_init_by_idx); |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 369 | |
| 370 | /** |
| 371 | * of_reserved_mem_device_release() - release reserved memory device structures |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 372 | * @dev: Pointer to the device to deconfigure |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 373 | * |
| 374 | * This function releases structures allocated for memory region handling for |
| 375 | * the given device. |
| 376 | */ |
| 377 | void of_reserved_mem_device_release(struct device *dev) |
| 378 | { |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 379 | struct rmem_assigned_device *rd; |
| 380 | struct reserved_mem *rmem = NULL; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 381 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 382 | mutex_lock(&of_rmem_assigned_device_mutex); |
| 383 | list_for_each_entry(rd, &of_rmem_assigned_device_list, list) { |
| 384 | if (rd->dev == dev) { |
| 385 | rmem = rd->rmem; |
| 386 | list_del(&rd->list); |
| 387 | kfree(rd); |
| 388 | break; |
| 389 | } |
| 390 | } |
| 391 | mutex_unlock(&of_rmem_assigned_device_mutex); |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 392 | |
| 393 | if (!rmem || !rmem->ops || !rmem->ops->device_release) |
| 394 | return; |
| 395 | |
| 396 | rmem->ops->device_release(rmem, dev); |
| 397 | } |
George G. Davis | 615fde7 | 2015-01-09 09:29:05 -0500 | [diff] [blame] | 398 | EXPORT_SYMBOL_GPL(of_reserved_mem_device_release); |