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
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	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
85static 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
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			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
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		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
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//		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}
319EXPORT_SYMBOL(dvma_map_align);
320
321void 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}
335EXPORT_SYMBOL(dvma_unmap);
336
337void *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}
375EXPORT_SYMBOL(dvma_malloc_align);
376
377void dvma_free(void *vaddr)
378{
379
380	return;
381
382}
383EXPORT_SYMBOL(dvma_free);
384