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