1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/genalloc.h>
17#include <linux/init.h>
18#include <linux/list.h>
19#include <linux/of_device.h>
20#include <linux/spinlock.h>
21#include <linux/export.h>
22#include <linux/of.h>
23#include <linux/of_address.h>
24#include <linux/slab.h>
25#include <linux/io.h>
26#include <soc/fsl/qe/qe.h>
27
28static struct gen_pool *muram_pool;
29static DEFINE_SPINLOCK(cpm_muram_lock);
30static void __iomem *muram_vbase;
31static phys_addr_t muram_pbase;
32
33struct muram_block {
34 struct list_head head;
35 s32 start;
36 int size;
37};
38
39static LIST_HEAD(muram_block_list);
40
41
42#define OF_MAX_ADDR_CELLS 4
43#define GENPOOL_OFFSET (4096 * 8)
44
45int cpm_muram_init(void)
46{
47 struct device_node *np;
48 struct resource r;
49 __be32 zero[OF_MAX_ADDR_CELLS] = {};
50 resource_size_t max = 0;
51 int i = 0;
52 int ret = 0;
53
54 if (muram_pbase)
55 return 0;
56
57 np = of_find_compatible_node(NULL, NULL, "fsl,cpm-muram-data");
58 if (!np) {
59
60 np = of_find_node_by_name(NULL, "data-only");
61 if (!np) {
62 pr_err("Cannot find CPM muram data node");
63 ret = -ENODEV;
64 goto out_muram;
65 }
66 }
67
68 muram_pool = gen_pool_create(0, -1);
69 if (!muram_pool) {
70 pr_err("Cannot allocate memory pool for CPM/QE muram");
71 ret = -ENOMEM;
72 goto out_muram;
73 }
74 muram_pbase = of_translate_address(np, zero);
75 if (muram_pbase == (phys_addr_t)OF_BAD_ADDR) {
76 pr_err("Cannot translate zero through CPM muram node");
77 ret = -ENODEV;
78 goto out_pool;
79 }
80
81 while (of_address_to_resource(np, i++, &r) == 0) {
82 if (r.end > max)
83 max = r.end;
84 ret = gen_pool_add(muram_pool, r.start - muram_pbase +
85 GENPOOL_OFFSET, resource_size(&r), -1);
86 if (ret) {
87 pr_err("QE: couldn't add muram to pool!\n");
88 goto out_pool;
89 }
90 }
91
92 muram_vbase = ioremap(muram_pbase, max - muram_pbase + 1);
93 if (!muram_vbase) {
94 pr_err("Cannot map QE muram");
95 ret = -ENOMEM;
96 goto out_pool;
97 }
98 goto out_muram;
99out_pool:
100 gen_pool_destroy(muram_pool);
101out_muram:
102 of_node_put(np);
103 return ret;
104}
105
106
107
108
109
110
111
112
113
114
115static s32 cpm_muram_alloc_common(unsigned long size,
116 genpool_algo_t algo, void *data)
117{
118 struct muram_block *entry;
119 s32 start;
120
121 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
122 if (!entry)
123 return -ENOMEM;
124 start = gen_pool_alloc_algo(muram_pool, size, algo, data);
125 if (!start) {
126 kfree(entry);
127 return -ENOMEM;
128 }
129 start = start - GENPOOL_OFFSET;
130 memset_io(cpm_muram_addr(start), 0, size);
131 entry->start = start;
132 entry->size = size;
133 list_add(&entry->head, &muram_block_list);
134
135 return start;
136}
137
138
139
140
141
142
143
144
145
146
147
148s32 cpm_muram_alloc(unsigned long size, unsigned long align)
149{
150 s32 start;
151 unsigned long flags;
152 struct genpool_data_align muram_pool_data;
153
154 spin_lock_irqsave(&cpm_muram_lock, flags);
155 muram_pool_data.align = align;
156 start = cpm_muram_alloc_common(size, gen_pool_first_fit_align,
157 &muram_pool_data);
158 spin_unlock_irqrestore(&cpm_muram_lock, flags);
159 return start;
160}
161EXPORT_SYMBOL(cpm_muram_alloc);
162
163
164
165
166
167void cpm_muram_free(s32 offset)
168{
169 unsigned long flags;
170 int size;
171 struct muram_block *tmp;
172
173 if (offset < 0)
174 return;
175
176 size = 0;
177 spin_lock_irqsave(&cpm_muram_lock, flags);
178 list_for_each_entry(tmp, &muram_block_list, head) {
179 if (tmp->start == offset) {
180 size = tmp->size;
181 list_del(&tmp->head);
182 kfree(tmp);
183 break;
184 }
185 }
186 gen_pool_free(muram_pool, offset + GENPOOL_OFFSET, size);
187 spin_unlock_irqrestore(&cpm_muram_lock, flags);
188}
189EXPORT_SYMBOL(cpm_muram_free);
190
191
192
193
194
195
196
197
198
199
200s32 cpm_muram_alloc_fixed(unsigned long offset, unsigned long size)
201{
202 s32 start;
203 unsigned long flags;
204 struct genpool_data_fixed muram_pool_data_fixed;
205
206 spin_lock_irqsave(&cpm_muram_lock, flags);
207 muram_pool_data_fixed.offset = offset + GENPOOL_OFFSET;
208 start = cpm_muram_alloc_common(size, gen_pool_fixed_alloc,
209 &muram_pool_data_fixed);
210 spin_unlock_irqrestore(&cpm_muram_lock, flags);
211 return start;
212}
213EXPORT_SYMBOL(cpm_muram_alloc_fixed);
214
215
216
217
218
219void __iomem *cpm_muram_addr(unsigned long offset)
220{
221 return muram_vbase + offset;
222}
223EXPORT_SYMBOL(cpm_muram_addr);
224
225unsigned long cpm_muram_offset(const void __iomem *addr)
226{
227 return addr - muram_vbase;
228}
229EXPORT_SYMBOL(cpm_muram_offset);
230
231
232
233
234
235dma_addr_t cpm_muram_dma(void __iomem *addr)
236{
237 return muram_pbase + (addr - muram_vbase);
238}
239EXPORT_SYMBOL(cpm_muram_dma);
240
241
242
243
244
245void cpm_muram_free_addr(const void __iomem *addr)
246{
247 if (!addr)
248 return;
249 cpm_muram_free(cpm_muram_offset(addr));
250}
251EXPORT_SYMBOL(cpm_muram_free_addr);
252