1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Generic on-chip SRAM allocation driver
5 * Copyright (C) 2012 Philipp Zabel, Pengutronix
9 #include <linux/delay.h>
10 #include <linux/genalloc.h>
12 #include <linux/list_sort.h>
13 #include <linux/of_address.h>
14 #include <linux/of_device.h>
15 #include <linux/platform_device.h>
16 #include <linux/regmap.h>
17 #include <linux/slab.h>
18 #include <linux/mfd/syscon.h>
19 #include <soc/at91/atmel-secumod.h>
23 #define SRAM_GRANULARITY 32
25 static ssize_t
sram_read(struct file
*filp
, struct kobject
*kobj
,
26 struct bin_attribute
*attr
,
27 char *buf
, loff_t pos
, size_t count
)
29 struct sram_partition
*part
;
31 part
= container_of(attr
, struct sram_partition
, battr
);
33 mutex_lock(&part
->lock
);
34 memcpy_fromio(buf
, part
->base
+ pos
, count
);
35 mutex_unlock(&part
->lock
);
40 static ssize_t
sram_write(struct file
*filp
, struct kobject
*kobj
,
41 struct bin_attribute
*attr
,
42 char *buf
, loff_t pos
, size_t count
)
44 struct sram_partition
*part
;
46 part
= container_of(attr
, struct sram_partition
, battr
);
48 mutex_lock(&part
->lock
);
49 memcpy_toio(part
->base
+ pos
, buf
, count
);
50 mutex_unlock(&part
->lock
);
55 static int sram_add_pool(struct sram_dev
*sram
, struct sram_reserve
*block
,
56 phys_addr_t start
, struct sram_partition
*part
)
60 part
->pool
= devm_gen_pool_create(sram
->dev
, ilog2(SRAM_GRANULARITY
),
61 NUMA_NO_NODE
, block
->label
);
62 if (IS_ERR(part
->pool
))
63 return PTR_ERR(part
->pool
);
65 ret
= gen_pool_add_virt(part
->pool
, (unsigned long)part
->base
, start
,
66 block
->size
, NUMA_NO_NODE
);
68 dev_err(sram
->dev
, "failed to register subpool: %d\n", ret
);
75 static int sram_add_export(struct sram_dev
*sram
, struct sram_reserve
*block
,
76 phys_addr_t start
, struct sram_partition
*part
)
78 sysfs_bin_attr_init(&part
->battr
);
79 part
->battr
.attr
.name
= devm_kasprintf(sram
->dev
, GFP_KERNEL
,
81 (unsigned long long)start
);
82 if (!part
->battr
.attr
.name
)
85 part
->battr
.attr
.mode
= S_IRUSR
| S_IWUSR
;
86 part
->battr
.read
= sram_read
;
87 part
->battr
.write
= sram_write
;
88 part
->battr
.size
= block
->size
;
90 return device_create_bin_file(sram
->dev
, &part
->battr
);
93 static int sram_add_partition(struct sram_dev
*sram
, struct sram_reserve
*block
,
97 struct sram_partition
*part
= &sram
->partition
[sram
->partitions
];
99 mutex_init(&part
->lock
);
101 if (sram
->config
&& sram
->config
->map_only_reserved
) {
102 void __iomem
*virt_base
;
104 if (sram
->no_memory_wc
)
105 virt_base
= devm_ioremap_resource(sram
->dev
, &block
->res
);
107 virt_base
= devm_ioremap_resource_wc(sram
->dev
, &block
->res
);
109 if (IS_ERR(virt_base
)) {
110 dev_err(sram
->dev
, "could not map SRAM at %pr\n", &block
->res
);
111 return PTR_ERR(virt_base
);
114 part
->base
= virt_base
;
116 part
->base
= sram
->virt_base
+ block
->start
;
120 ret
= sram_add_pool(sram
, block
, start
, part
);
125 ret
= sram_add_export(sram
, block
, start
, part
);
129 if (block
->protect_exec
) {
130 ret
= sram_check_protect_exec(sram
, block
, part
);
134 ret
= sram_add_pool(sram
, block
, start
, part
);
138 sram_add_protect_exec(part
);
146 static void sram_free_partitions(struct sram_dev
*sram
)
148 struct sram_partition
*part
;
150 if (!sram
->partitions
)
153 part
= &sram
->partition
[sram
->partitions
- 1];
154 for (; sram
->partitions
; sram
->partitions
--, part
--) {
155 if (part
->battr
.size
)
156 device_remove_bin_file(sram
->dev
, &part
->battr
);
159 gen_pool_avail(part
->pool
) < gen_pool_size(part
->pool
))
160 dev_err(sram
->dev
, "removed pool while SRAM allocated\n");
164 static int sram_reserve_cmp(void *priv
, const struct list_head
*a
,
165 const struct list_head
*b
)
167 struct sram_reserve
*ra
= list_entry(a
, struct sram_reserve
, list
);
168 struct sram_reserve
*rb
= list_entry(b
, struct sram_reserve
, list
);
170 return ra
->start
- rb
->start
;
173 static int sram_reserve_regions(struct sram_dev
*sram
, struct resource
*res
)
175 struct device_node
*np
= sram
->dev
->of_node
, *child
;
176 unsigned long size
, cur_start
, cur_size
;
177 struct sram_reserve
*rblocks
, *block
;
178 struct list_head reserve_list
;
179 unsigned int nblocks
, exports
= 0;
183 INIT_LIST_HEAD(&reserve_list
);
185 size
= resource_size(res
);
188 * We need an additional block to mark the end of the memory region
189 * after the reserved blocks from the dt are processed.
191 nblocks
= (np
) ? of_get_available_child_count(np
) + 1 : 1;
192 rblocks
= kcalloc(nblocks
, sizeof(*rblocks
), GFP_KERNEL
);
197 for_each_available_child_of_node(np
, child
) {
198 struct resource child_res
;
200 ret
= of_address_to_resource(child
, 0, &child_res
);
203 "could not get address for node %pOF\n",
208 if (child_res
.start
< res
->start
|| child_res
.end
> res
->end
) {
210 "reserved block %pOF outside the sram area\n",
216 block
->start
= child_res
.start
- res
->start
;
217 block
->size
= resource_size(&child_res
);
218 block
->res
= child_res
;
219 list_add_tail(&block
->list
, &reserve_list
);
221 if (of_find_property(child
, "export", NULL
))
222 block
->export
= true;
224 if (of_find_property(child
, "pool", NULL
))
227 if (of_find_property(child
, "protect-exec", NULL
))
228 block
->protect_exec
= true;
230 if ((block
->export
|| block
->pool
|| block
->protect_exec
) &&
235 ret
= of_property_read_string(child
, "label", &label
);
236 if (ret
&& ret
!= -EINVAL
) {
238 "%pOF has invalid label name\n",
245 block
->label
= devm_kstrdup(sram
->dev
,
252 dev_dbg(sram
->dev
, "found %sblock '%s' 0x%x-0x%x\n",
253 block
->export
? "exported " : "", block
->label
,
254 block
->start
, block
->start
+ block
->size
);
256 dev_dbg(sram
->dev
, "found reserved block 0x%x-0x%x\n",
257 block
->start
, block
->start
+ block
->size
);
264 /* the last chunk marks the end of the region */
265 rblocks
[nblocks
- 1].start
= size
;
266 rblocks
[nblocks
- 1].size
= 0;
267 list_add_tail(&rblocks
[nblocks
- 1].list
, &reserve_list
);
269 list_sort(NULL
, &reserve_list
, sram_reserve_cmp
);
272 sram
->partition
= devm_kcalloc(sram
->dev
,
273 exports
, sizeof(*sram
->partition
),
275 if (!sram
->partition
) {
282 list_for_each_entry(block
, &reserve_list
, list
) {
283 /* can only happen if sections overlap */
284 if (block
->start
< cur_start
) {
286 "block at 0x%x starts after current offset 0x%lx\n",
287 block
->start
, cur_start
);
289 sram_free_partitions(sram
);
293 if ((block
->export
|| block
->pool
|| block
->protect_exec
) &&
295 ret
= sram_add_partition(sram
, block
,
296 res
->start
+ block
->start
);
298 sram_free_partitions(sram
);
303 /* current start is in a reserved block, so continue after it */
304 if (block
->start
== cur_start
) {
305 cur_start
= block
->start
+ block
->size
;
310 * allocate the space between the current starting
311 * address and the following reserved block, or the
314 cur_size
= block
->start
- cur_start
;
317 dev_dbg(sram
->dev
, "adding chunk 0x%lx-0x%lx\n",
318 cur_start
, cur_start
+ cur_size
);
320 ret
= gen_pool_add_virt(sram
->pool
,
321 (unsigned long)sram
->virt_base
+ cur_start
,
322 res
->start
+ cur_start
, cur_size
, -1);
324 sram_free_partitions(sram
);
329 /* next allocation after this reserved block */
330 cur_start
= block
->start
+ block
->size
;
340 static int atmel_securam_wait(void)
342 struct regmap
*regmap
;
345 regmap
= syscon_regmap_lookup_by_compatible("atmel,sama5d2-secumod");
349 return regmap_read_poll_timeout(regmap
, AT91_SECUMOD_RAMRDY
, val
,
350 val
& AT91_SECUMOD_RAMRDY_READY
,
354 static const struct sram_config atmel_securam_config
= {
355 .init
= atmel_securam_wait
,
359 * SYSRAM contains areas that are not accessible by the
360 * kernel, such as the first 256K that is reserved for TZ.
361 * Accesses to those areas (including speculative accesses)
362 * trigger SErrors. As such we must map only the areas of
363 * SYSRAM specified in the device tree.
365 static const struct sram_config tegra_sysram_config
= {
366 .map_only_reserved
= true,
369 static const struct of_device_id sram_dt_ids
[] = {
370 { .compatible
= "mmio-sram" },
371 { .compatible
= "atmel,sama5d2-securam", .data
= &atmel_securam_config
},
372 { .compatible
= "nvidia,tegra186-sysram", .data
= &tegra_sysram_config
},
373 { .compatible
= "nvidia,tegra194-sysram", .data
= &tegra_sysram_config
},
377 static int sram_probe(struct platform_device
*pdev
)
379 const struct sram_config
*config
;
380 struct sram_dev
*sram
;
382 struct resource
*res
;
384 config
= of_device_get_match_data(&pdev
->dev
);
386 sram
= devm_kzalloc(&pdev
->dev
, sizeof(*sram
), GFP_KERNEL
);
390 sram
->dev
= &pdev
->dev
;
391 sram
->no_memory_wc
= of_property_read_bool(pdev
->dev
.of_node
, "no-memory-wc");
392 sram
->config
= config
;
394 if (!config
|| !config
->map_only_reserved
) {
395 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
396 if (sram
->no_memory_wc
)
397 sram
->virt_base
= devm_ioremap_resource(&pdev
->dev
, res
);
399 sram
->virt_base
= devm_ioremap_resource_wc(&pdev
->dev
, res
);
400 if (IS_ERR(sram
->virt_base
)) {
401 dev_err(&pdev
->dev
, "could not map SRAM registers\n");
402 return PTR_ERR(sram
->virt_base
);
405 sram
->pool
= devm_gen_pool_create(sram
->dev
, ilog2(SRAM_GRANULARITY
),
407 if (IS_ERR(sram
->pool
))
408 return PTR_ERR(sram
->pool
);
411 sram
->clk
= devm_clk_get(sram
->dev
, NULL
);
412 if (IS_ERR(sram
->clk
))
415 clk_prepare_enable(sram
->clk
);
417 ret
= sram_reserve_regions(sram
,
418 platform_get_resource(pdev
, IORESOURCE_MEM
, 0));
420 goto err_disable_clk
;
422 platform_set_drvdata(pdev
, sram
);
424 if (config
&& config
->init
) {
425 ret
= config
->init();
427 goto err_free_partitions
;
431 dev_dbg(sram
->dev
, "SRAM pool: %zu KiB @ 0x%p\n",
432 gen_pool_size(sram
->pool
) / 1024, sram
->virt_base
);
437 sram_free_partitions(sram
);
440 clk_disable_unprepare(sram
->clk
);
445 static int sram_remove(struct platform_device
*pdev
)
447 struct sram_dev
*sram
= platform_get_drvdata(pdev
);
449 sram_free_partitions(sram
);
451 if (sram
->pool
&& gen_pool_avail(sram
->pool
) < gen_pool_size(sram
->pool
))
452 dev_err(sram
->dev
, "removed while SRAM allocated\n");
455 clk_disable_unprepare(sram
->clk
);
460 static struct platform_driver sram_driver
= {
463 .of_match_table
= sram_dt_ids
,
466 .remove
= sram_remove
,
469 static int __init
sram_init(void)
471 return platform_driver_register(&sram_driver
);
474 postcore_initcall(sram_init
);