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