1 /*
2 * linux/arch/m68k/sun3/sun3dvma.c
3 *
4 * Copyright (C) 2000 Sam Creasey
5 *
6 * Contains common routines for sun3/sun3x DVMA management.
7 */
8
9 #include <linux/bootmem.h>
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/gfp.h>
14 #include <linux/mm.h>
15 #include <linux/list.h>
16
17 #include <asm/page.h>
18 #include <asm/pgtable.h>
19 #include <asm/dvma.h>
20
21 #undef DVMA_DEBUG
22
23 #ifdef CONFIG_SUN3X
24 extern void dvma_unmap_iommu(unsigned long baddr, int len);
25 #else
dvma_unmap_iommu(unsigned long a,int b)26 static inline void dvma_unmap_iommu(unsigned long a, int b)
27 {
28 }
29 #endif
30
31 #ifdef CONFIG_SUN3
32 extern void sun3_dvma_init(void);
33 #endif
34
35 static 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
41 struct hole {
42 unsigned long start;
43 unsigned long end;
44 unsigned long size;
45 struct list_head list;
46 };
47
48 static struct list_head hole_list;
49 static struct list_head hole_cache;
50 static struct hole initholes[64];
51
52 #ifdef DVMA_DEBUG
53
54 static unsigned long dvma_allocs;
55 static unsigned long dvma_frees;
56 static unsigned long long dvma_alloc_bytes;
57 static unsigned long long dvma_free_bytes;
58
print_use(void)59 static void print_use(void)
60 {
61
62 int i;
63 int j = 0;
64
65 printk("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 printk("dvma entry: %08lx len %08lx\n",
74 ( i << DVMA_PAGE_SHIFT) + DVMA_START,
75 iommu_use[i]);
76 }
77
78 printk("%d entries in use total\n", j);
79
80 printk("allocation/free calls: %lu/%lu\n", dvma_allocs, dvma_frees);
81 printk("allocation/free bytes: %Lx/%Lx\n", dvma_alloc_bytes,
82 dvma_free_bytes);
83 }
84
print_holes(struct list_head * holes)85 static void print_holes(struct list_head *holes)
86 {
87
88 struct list_head *cur;
89 struct hole *hole;
90
91 printk("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 printk("hole: start %08lx end %08lx size %08lx\n", hole->start, hole->end, hole->size);
99 }
100
101 printk("end of hole listing...\n");
102
103 }
104 #endif /* DVMA_DEBUG */
105
refill(void)106 static 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
rmcache(void)134 static inline struct hole *rmcache(void)
135 {
136 struct hole *ret;
137
138 if(list_empty(&hole_cache)) {
139 if(!refill()) {
140 printk("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
get_baddr(int len,unsigned long align)152 static 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 printk("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 printk("unable to find dvma hole!\n");
199 BUG();
200 return 0;
201 }
202
free_baddr(unsigned long baddr)203 static 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
dvma_init(void)250 void __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
dvma_map_align(unsigned long kaddr,int len,int align)280 unsigned 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 // printk("error: kaddr %lx len %x\n", kaddr, len);
291 // *(int *)4 = 0;
292 return 0;
293 }
294
295 #ifdef DEBUG
296 printk("dvma_map request %08lx bytes from %08lx\n",
297 len, kaddr);
298 #endif
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 // printk("using baddr %lx\n", baddr);
311
312 if(!dvma_map_iommu(kaddr, baddr, len))
313 return (baddr + off);
314
315 printk("dvma_map failed kaddr %lx baddr %lx len %x\n", kaddr, baddr, len);
316 BUG();
317 return 0;
318 }
319 EXPORT_SYMBOL(dvma_map_align);
320
dvma_unmap(void * baddr)321 void dvma_unmap(void *baddr)
322 {
323 unsigned long addr;
324
325 addr = (unsigned long)baddr;
326 /* check if this is a vme mapping */
327 if(!(addr & 0x00f00000))
328 addr |= 0xf00000;
329
330 free_baddr(addr);
331
332 return;
333
334 }
335 EXPORT_SYMBOL(dvma_unmap);
336
dvma_malloc_align(unsigned long len,unsigned long align)337 void *dvma_malloc_align(unsigned long len, unsigned long align)
338 {
339 unsigned long kaddr;
340 unsigned long baddr;
341 unsigned long vaddr;
342
343 if(!len)
344 return NULL;
345
346 #ifdef DEBUG
347 printk("dvma_malloc request %lx bytes\n", len);
348 #endif
349 len = ((len + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
350
351 if((kaddr = __get_free_pages(GFP_ATOMIC, get_order(len))) == 0)
352 return NULL;
353
354 if((baddr = (unsigned long)dvma_map_align(kaddr, len, align)) == 0) {
355 free_pages(kaddr, get_order(len));
356 return NULL;
357 }
358
359 vaddr = dvma_btov(baddr);
360
361 if(dvma_map_cpu(kaddr, vaddr, len) < 0) {
362 dvma_unmap((void *)baddr);
363 free_pages(kaddr, get_order(len));
364 return NULL;
365 }
366
367 #ifdef DEBUG
368 printk("mapped %08lx bytes %08lx kern -> %08lx bus\n",
369 len, kaddr, baddr);
370 #endif
371
372 return (void *)vaddr;
373
374 }
375 EXPORT_SYMBOL(dvma_malloc_align);
376
dvma_free(void * vaddr)377 void dvma_free(void *vaddr)
378 {
379
380 return;
381
382 }
383 EXPORT_SYMBOL(dvma_free);
384