1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * linux/arch/m68k/sun3/sun3dvma.c
4 *
5 * Copyright (C) 2000 Sam Creasey
6 *
7 * Contains common routines for sun3/sun3x DVMA management.
8 */
9
10 #include <linux/memblock.h>
11 #include <linux/init.h>
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/gfp.h>
15 #include <linux/mm.h>
16 #include <linux/list.h>
17
18 #include <asm/page.h>
19 #include <asm/dvma.h>
20
21 #undef DVMA_DEBUG
22
23 static unsigned long *iommu_use;
24
25 #define dvma_index(baddr) ((baddr - DVMA_START) >> DVMA_PAGE_SHIFT)
26
27 #define dvma_entry_use(baddr) (iommu_use[dvma_index(baddr)])
28
29 struct hole {
30 unsigned long start;
31 unsigned long end;
32 unsigned long size;
33 struct list_head list;
34 };
35
36 static struct list_head hole_list;
37 static struct list_head hole_cache;
38 static struct hole initholes[64];
39
40 #ifdef DVMA_DEBUG
41
42 static unsigned long dvma_allocs;
43 static unsigned long dvma_frees;
44 static unsigned long long dvma_alloc_bytes;
45 static unsigned long long dvma_free_bytes;
46
47 static void print_use(void)
48 {
49
50 int i;
51 int j = 0;
52
53 pr_info("dvma entry usage:\n");
54
55 for(i = 0; i < IOMMU_TOTAL_ENTRIES; i++) {
56 if(!iommu_use[i])
57 continue;
58
59 j++;
60
61 pr_info("dvma entry: %08x len %08lx\n",
62 (i << DVMA_PAGE_SHIFT) + DVMA_START, iommu_use[i]);
63 }
64
65 pr_info("%d entries in use total\n", j);
66
67 pr_info("allocation/free calls: %lu/%lu\n", dvma_allocs, dvma_frees);
68 pr_info("allocation/free bytes: %Lx/%Lx\n", dvma_alloc_bytes,
69 dvma_free_bytes);
70 }
71
72 static void print_holes(struct list_head *holes)
73 {
74
75 struct list_head *cur;
76 struct hole *hole;
77
78 pr_info("listing dvma holes\n");
79 list_for_each(cur, holes) {
80 hole = list_entry(cur, struct hole, list);
81
82 if((hole->start == 0) && (hole->end == 0) && (hole->size == 0))
83 continue;
84
85 pr_info("hole: start %08lx end %08lx size %08lx\n",
86 hole->start, hole->end, hole->size);
87 }
88
89 pr_info("end of hole listing...\n");
90 }
91 #endif /* DVMA_DEBUG */
92
93 static inline int refill(void)
94 {
95
96 struct hole *hole;
97 struct hole *prev = NULL;
98 struct list_head *cur;
99 int ret = 0;
100
101 list_for_each(cur, &hole_list) {
102 hole = list_entry(cur, struct hole, list);
103
104 if(!prev) {
105 prev = hole;
106 continue;
107 }
108
109 if(hole->end == prev->start) {
110 hole->size += prev->size;
111 hole->end = prev->end;
112 list_move(&(prev->list), &hole_cache);
113 ret++;
114 }
115
116 }
117
118 return ret;
119 }
120
121 static inline struct hole *rmcache(void)
122 {
123 struct hole *ret;
124
125 if(list_empty(&hole_cache)) {
126 if(!refill()) {
127 pr_crit("out of dvma hole cache!\n");
128 BUG();
129 }
130 }
131
132 ret = list_entry(hole_cache.next, struct hole, list);
133 list_del(&(ret->list));
134
135 return ret;
136
137 }
138
139 static inline unsigned long get_baddr(int len, unsigned long align)
140 {
141
142 struct list_head *cur;
143 struct hole *hole;
144
145 if(list_empty(&hole_list)) {
146 #ifdef DVMA_DEBUG
147 pr_crit("out of dvma holes! (printing hole cache)\n");
148 print_holes(&hole_cache);
149 print_use();
150 #endif
151 BUG();
152 }
153
154 list_for_each(cur, &hole_list) {
155 unsigned long newlen;
156
157 hole = list_entry(cur, struct hole, list);
158
159 if(align > DVMA_PAGE_SIZE)
160 newlen = len + ((hole->end - len) & (align-1));
161 else
162 newlen = len;
163
164 if(hole->size > newlen) {
165 hole->end -= newlen;
166 hole->size -= newlen;
167 dvma_entry_use(hole->end) = newlen;
168 #ifdef DVMA_DEBUG
169 dvma_allocs++;
170 dvma_alloc_bytes += newlen;
171 #endif
172 return hole->end;
173 } else if(hole->size == newlen) {
174 list_move(&(hole->list), &hole_cache);
175 dvma_entry_use(hole->start) = newlen;
176 #ifdef DVMA_DEBUG
177 dvma_allocs++;
178 dvma_alloc_bytes += newlen;
179 #endif
180 return hole->start;
181 }
182
183 }
184
185 pr_crit("unable to find dvma hole!\n");
186 BUG();
187 return 0;
188 }
189
190 static inline int free_baddr(unsigned long baddr)
191 {
192
193 unsigned long len;
194 struct hole *hole;
195 struct list_head *cur;
196
197 len = dvma_entry_use(baddr);
198 dvma_entry_use(baddr) = 0;
199 baddr &= DVMA_PAGE_MASK;
200 dvma_unmap_iommu(baddr, len);
201
202 #ifdef DVMA_DEBUG
203 dvma_frees++;
204 dvma_free_bytes += len;
205 #endif
206
207 list_for_each(cur, &hole_list) {
208 hole = list_entry(cur, struct hole, list);
209
210 if(hole->end == baddr) {
211 hole->end += len;
212 hole->size += len;
213 return 0;
214 } else if(hole->start == (baddr + len)) {
215 hole->start = baddr;
216 hole->size += len;
217 return 0;
218 }
219
220 }
221
222 hole = rmcache();
223
224 hole->start = baddr;
225 hole->end = baddr + len;
226 hole->size = len;
227
228 // list_add_tail(&(hole->list), cur);
229 list_add(&(hole->list), cur);
230
231 return 0;
232
233 }
234
235 void __init dvma_init(void)
236 {
237
238 struct hole *hole;
239 int i;
240
241 INIT_LIST_HEAD(&hole_list);
242 INIT_LIST_HEAD(&hole_cache);
243
244 /* prepare the hole cache */
245 for(i = 0; i < 64; i++)
246 list_add(&(initholes[i].list), &hole_cache);
247
248 hole = rmcache();
249 hole->start = DVMA_START;
250 hole->end = DVMA_END;
251 hole->size = DVMA_SIZE;
252
253 list_add(&(hole->list), &hole_list);
254
255 iommu_use = memblock_alloc(IOMMU_TOTAL_ENTRIES * sizeof(unsigned long),
256 SMP_CACHE_BYTES);
257 if (!iommu_use)
258 panic("%s: Failed to allocate %zu bytes\n", __func__,
259 IOMMU_TOTAL_ENTRIES * sizeof(unsigned long));
260
261 dvma_unmap_iommu(DVMA_START, DVMA_SIZE);
262
263 sun3_dvma_init();
264 }
265
266 unsigned long dvma_map_align(unsigned long kaddr, int len, int align)
267 {
268
269 unsigned long baddr;
270 unsigned long off;
271
272 if(!len)
273 len = 0x800;
274
275 if(!kaddr || !len) {
276 // pr_err("error: kaddr %lx len %x\n", kaddr, len);
277 // *(int *)4 = 0;
278 return 0;
279 }
280
281 pr_debug("dvma_map request %08x bytes from %08lx\n", len, kaddr);
282 off = kaddr & ~DVMA_PAGE_MASK;
283 kaddr &= PAGE_MASK;
284 len += off;
285 len = ((len + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
286
287 if(align == 0)
288 align = DVMA_PAGE_SIZE;
289 else
290 align = ((align + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
291
292 baddr = get_baddr(len, align);
293 // pr_info("using baddr %lx\n", baddr);
294
295 if(!dvma_map_iommu(kaddr, baddr, len))
296 return (baddr + off);
297
298 pr_crit("dvma_map failed kaddr %lx baddr %lx len %x\n", kaddr, baddr,
299 len);
300 BUG();
301 return 0;
302 }
303 EXPORT_SYMBOL(dvma_map_align);
304
305 void dvma_unmap(void *baddr)
306 {
307 unsigned long addr;
308
309 addr = (unsigned long)baddr;
310 /* check if this is a vme mapping */
311 if(!(addr & 0x00f00000))
312 addr |= 0xf00000;
313
314 free_baddr(addr);
315
316 return;
317
318 }
319 EXPORT_SYMBOL(dvma_unmap);
320
321 void *dvma_malloc_align(unsigned long len, unsigned long align)
322 {
323 unsigned long kaddr;
324 unsigned long baddr;
325 unsigned long vaddr;
326
327 if(!len)
328 return NULL;
329
330 pr_debug("dvma_malloc request %lx bytes\n", len);
331 len = ((len + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
332
333 if((kaddr = __get_free_pages(GFP_ATOMIC, get_order(len))) == 0)
334 return NULL;
335
336 if((baddr = (unsigned long)dvma_map_align(kaddr, len, align)) == 0) {
337 free_pages(kaddr, get_order(len));
338 return NULL;
339 }
340
341 vaddr = dvma_btov(baddr);
342
343 if(dvma_map_cpu(kaddr, vaddr, len) < 0) {
344 dvma_unmap((void *)baddr);
345 free_pages(kaddr, get_order(len));
346 return NULL;
347 }
348
349 pr_debug("mapped %08lx bytes %08lx kern -> %08lx bus\n", len, kaddr,
350 baddr);
351
352 return (void *)vaddr;
353
354 }
355 EXPORT_SYMBOL(dvma_malloc_align);
356
357 void dvma_free(void *vaddr)
358 {
359
360 return;
361
362 }
363 EXPORT_SYMBOL(dvma_free);
364
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.