1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Simple memory allocator for on-board SRAM
4  *
5  * Maintainer : Sylvain Munaut <tnt@246tNt.com>
6  *
7  * Copyright (C) 2005 Sylvain Munaut <tnt@246tNt.com>
8  */
9 
10 #include <linux/err.h>
11 #include <linux/kernel.h>
12 #include <linux/export.h>
13 #include <linux/slab.h>
14 #include <linux/spinlock.h>
15 #include <linux/string.h>
16 #include <linux/ioport.h>
17 #include <linux/of.h>
18 #include <linux/of_address.h>
19 
20 #include <asm/io.h>
21 #include <asm/mmu.h>
22 
23 #include <linux/fsl/bestcomm/sram.h>
24 
25 
26 /* Struct keeping our 'state' */
27 struct bcom_sram *bcom_sram = NULL;
28 EXPORT_SYMBOL_GPL(bcom_sram);	/* needed for inline functions */
29 
30 
31 /* ======================================================================== */
32 /* Public API                                                               */
33 /* ======================================================================== */
34 /* DO NOT USE in interrupts, if needed in irq handler, we should use the
35    _irqsave version of the spin_locks */
36 
bcom_sram_init(struct device_node * sram_node,char * owner)37 int bcom_sram_init(struct device_node *sram_node, char *owner)
38 {
39 	int rv;
40 	const u32 *regaddr_p;
41 	u64 regaddr64, size64;
42 	unsigned int psize;
43 
44 	/* Create our state struct */
45 	if (bcom_sram) {
46 		printk(KERN_ERR "%s: bcom_sram_init: "
47 			"Already initialized !\n", owner);
48 		return -EBUSY;
49 	}
50 
51 	bcom_sram = kmalloc(sizeof(struct bcom_sram), GFP_KERNEL);
52 	if (!bcom_sram) {
53 		printk(KERN_ERR "%s: bcom_sram_init: "
54 			"Couldn't allocate internal state !\n", owner);
55 		return -ENOMEM;
56 	}
57 
58 	/* Get address and size of the sram */
59 	regaddr_p = of_get_address(sram_node, 0, &size64, NULL);
60 	if (!regaddr_p) {
61 		printk(KERN_ERR "%s: bcom_sram_init: "
62 			"Invalid device node !\n", owner);
63 		rv = -EINVAL;
64 		goto error_free;
65 	}
66 
67 	regaddr64 = of_translate_address(sram_node, regaddr_p);
68 
69 	bcom_sram->base_phys = (phys_addr_t) regaddr64;
70 	bcom_sram->size = (unsigned int) size64;
71 
72 	/* Request region */
73 	if (!request_mem_region(bcom_sram->base_phys, bcom_sram->size, owner)) {
74 		printk(KERN_ERR "%s: bcom_sram_init: "
75 			"Couldn't request region !\n", owner);
76 		rv = -EBUSY;
77 		goto error_free;
78 	}
79 
80 	/* Map SRAM */
81 		/* sram is not really __iomem */
82 	bcom_sram->base_virt = (void*) ioremap(bcom_sram->base_phys, bcom_sram->size);
83 
84 	if (!bcom_sram->base_virt) {
85 		printk(KERN_ERR "%s: bcom_sram_init: "
86 			"Map error SRAM zone 0x%08lx (0x%0x)!\n",
87 			owner, (long)bcom_sram->base_phys, bcom_sram->size );
88 		rv = -ENOMEM;
89 		goto error_release;
90 	}
91 
92 	/* Create an rheap (defaults to 32 bits word alignment) */
93 	bcom_sram->rh = rh_create(4);
94 
95 	/* Attach the free zones */
96 #if 0
97 	/* Currently disabled ... for future use only */
98 	reg_addr_p = of_get_property(sram_node, "available", &psize);
99 #else
100 	regaddr_p = NULL;
101 	psize = 0;
102 #endif
103 
104 	if (!regaddr_p || !psize) {
105 		/* Attach the whole zone */
106 		rh_attach_region(bcom_sram->rh, 0, bcom_sram->size);
107 	} else {
108 		/* Attach each zone independently */
109 		while (psize >= 2 * sizeof(u32)) {
110 			phys_addr_t zbase = of_translate_address(sram_node, regaddr_p);
111 			rh_attach_region(bcom_sram->rh, zbase - bcom_sram->base_phys, regaddr_p[1]);
112 			regaddr_p += 2;
113 			psize -= 2 * sizeof(u32);
114 		}
115 	}
116 
117 	/* Init our spinlock */
118 	spin_lock_init(&bcom_sram->lock);
119 
120 	return 0;
121 
122 error_release:
123 	release_mem_region(bcom_sram->base_phys, bcom_sram->size);
124 error_free:
125 	kfree(bcom_sram);
126 	bcom_sram = NULL;
127 
128 	return rv;
129 }
130 EXPORT_SYMBOL_GPL(bcom_sram_init);
131 
bcom_sram_cleanup(void)132 void bcom_sram_cleanup(void)
133 {
134 	/* Free resources */
135 	if (bcom_sram) {
136 		rh_destroy(bcom_sram->rh);
137 		iounmap((void __iomem *)bcom_sram->base_virt);
138 		release_mem_region(bcom_sram->base_phys, bcom_sram->size);
139 		kfree(bcom_sram);
140 		bcom_sram = NULL;
141 	}
142 }
143 EXPORT_SYMBOL_GPL(bcom_sram_cleanup);
144 
bcom_sram_alloc(int size,int align,phys_addr_t * phys)145 void* bcom_sram_alloc(int size, int align, phys_addr_t *phys)
146 {
147 	unsigned long offset;
148 
149 	spin_lock(&bcom_sram->lock);
150 	offset = rh_alloc_align(bcom_sram->rh, size, align, NULL);
151 	spin_unlock(&bcom_sram->lock);
152 
153 	if (IS_ERR_VALUE(offset))
154 		return NULL;
155 
156 	*phys = bcom_sram->base_phys + offset;
157 	return bcom_sram->base_virt + offset;
158 }
159 EXPORT_SYMBOL_GPL(bcom_sram_alloc);
160 
bcom_sram_free(void * ptr)161 void bcom_sram_free(void *ptr)
162 {
163 	unsigned long offset;
164 
165 	if (!ptr)
166 		return;
167 
168 	offset = ptr - bcom_sram->base_virt;
169 
170 	spin_lock(&bcom_sram->lock);
171 	rh_free(bcom_sram->rh, offset);
172 	spin_unlock(&bcom_sram->lock);
173 }
174 EXPORT_SYMBOL_GPL(bcom_sram_free);
175