1/*
2 * linux/arch/m68k/mm/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
20extern void dvma_unmap_iommu(unsigned long baddr, int len);
21#else
22static inline void dvma_unmap_iommu(unsigned long a, int b)
23{
24}
25#endif
26
27#ifdef CONFIG_SUN3
28extern void sun3_dvma_init(void);
29#endif
30
31unsigned 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
37struct hole {
38	unsigned long start;
39	unsigned long end;
40	unsigned long size;
41	struct list_head list;
42};
43
44static struct list_head hole_list;
45static struct list_head hole_cache;
46static struct hole initholes[64];
47
48#ifdef DVMA_DEBUG
49
50static unsigned long dvma_allocs = 0;
51static unsigned long dvma_frees = 0;
52static unsigned long long dvma_alloc_bytes = 0;
53static unsigned long long dvma_free_bytes = 0;
54
55static 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
81static 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
102static 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_del(&(prev->list));
122			list_add(&(prev->list), &hole_cache);
123			ret++;
124		}
125
126	}
127
128	return ret;
129}
130
131static inline struct hole *rmcache(void)
132{
133	struct hole *ret;
134
135	if(list_empty(&hole_cache)) {
136		if(!refill()) {
137			printk("out of dvma hole cache!\n");
138			BUG();
139		}
140	}
141
142	ret = list_entry(hole_cache.next, struct hole, list);
143	list_del(&(ret->list));
144
145	return ret;
146
147}
148
149static inline unsigned long get_baddr(int len, unsigned long align)
150{
151
152	struct list_head *cur;
153	struct hole *hole;
154
155	if(list_empty(&hole_list)) {
156#ifdef DVMA_DEBUG
157		printk("out of dvma holes! (printing hole cache)\n");
158		print_holes(&hole_cache);
159		print_use();
160#endif
161		BUG();
162	}
163
164	list_for_each(cur, &hole_list) {
165		unsigned long newlen;
166
167		hole = list_entry(cur, struct hole, list);
168
169		if(align > DVMA_PAGE_SIZE)
170			newlen = len + ((hole->end - len) & (align-1));
171		else
172			newlen = len;
173
174		if(hole->size > newlen) {
175			hole->end -= newlen;
176			hole->size -= newlen;
177			dvma_entry_use(hole->end) = newlen;
178#ifdef DVMA_DEBUG
179			dvma_allocs++;
180			dvma_alloc_bytes += newlen;
181#endif
182			return hole->end;
183		} else if(hole->size == newlen) {
184			list_del(&(hole->list));
185			list_add(&(hole->list), &hole_cache);
186			dvma_entry_use(hole->start) = newlen;
187#ifdef DVMA_DEBUG
188			dvma_allocs++;
189			dvma_alloc_bytes += newlen;
190#endif
191			return hole->start;
192		}
193
194	}
195
196	printk("unable to find dvma hole!\n");
197	BUG();
198	return 0;
199}
200
201static inline int free_baddr(unsigned long baddr)
202{
203
204	unsigned long len;
205	struct hole *hole;
206	struct list_head *cur;
207	unsigned long orig_baddr;
208
209	orig_baddr = baddr;
210	len = dvma_entry_use(baddr);
211	dvma_entry_use(baddr) = 0;
212	baddr &= DVMA_PAGE_MASK;
213	dvma_unmap_iommu(baddr, len);
214
215#ifdef DVMA_DEBUG
216	dvma_frees++;
217	dvma_free_bytes += len;
218#endif
219
220	list_for_each(cur, &hole_list) {
221		hole = list_entry(cur, struct hole, list);
222
223		if(hole->end == baddr) {
224			hole->end += len;
225			hole->size += len;
226			return 0;
227		} else if(hole->start == (baddr + len)) {
228			hole->start = baddr;
229			hole->size += len;
230			return 0;
231		}
232
233	}
234
235	hole = rmcache();
236
237	hole->start = baddr;
238	hole->end = baddr + len;
239	hole->size = len;
240
241//	list_add_tail(&(hole->list), cur);
242	list_add(&(hole->list), cur);
243
244	return 0;
245
246}
247
248void dvma_init(void)
249{
250
251	struct hole *hole;
252	int i;
253
254	INIT_LIST_HEAD(&hole_list);
255	INIT_LIST_HEAD(&hole_cache);
256
257	/* prepare the hole cache */
258	for(i = 0; i < 64; i++)
259		list_add(&(initholes[i].list), &hole_cache);
260
261	hole = rmcache();
262	hole->start = DVMA_START;
263	hole->end = DVMA_END;
264	hole->size = DVMA_SIZE;
265
266	list_add(&(hole->list), &hole_list);
267
268	memset(iommu_use, 0, sizeof(iommu_use));
269
270	dvma_unmap_iommu(DVMA_START, DVMA_SIZE);
271
272#ifdef CONFIG_SUN3
273	sun3_dvma_init();
274#endif
275
276}
277
278inline unsigned long dvma_map_align(unsigned long kaddr, int len, int align)
279{
280
281	unsigned long baddr;
282	unsigned long off;
283
284	if(!len)
285		len = 0x800;
286
287	if(!kaddr || !len) {
288//		printk("error: kaddr %lx len %x\n", kaddr, len);
289//		*(int *)4 = 0;
290		return 0;
291	}
292
293#ifdef DEBUG
294	printk("dvma_map request %08lx bytes from %08lx\n",
295	       len, kaddr);
296#endif
297	off = kaddr & ~DVMA_PAGE_MASK;
298	kaddr &= PAGE_MASK;
299	len += off;
300	len = ((len + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
301
302	if(align == 0)
303		align = DVMA_PAGE_SIZE;
304	else
305		align = ((align + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
306
307	baddr = get_baddr(len, align);
308//	printk("using baddr %lx\n", baddr);
309
310	if(!dvma_map_iommu(kaddr, baddr, len))
311		return (baddr + off);
312
313	printk("dvma_map failed kaddr %lx baddr %lx len %x\n", kaddr, baddr, len);
314	BUG();
315	return 0;
316}
317
318void dvma_unmap(void *baddr)
319{
320
321	free_baddr((unsigned long)baddr);
322
323	return;
324
325}
326
327
328void *dvma_malloc_align(unsigned long len, unsigned long align)
329{
330	unsigned long kaddr;
331	unsigned long baddr;
332	unsigned long vaddr;
333
334	if(!len)
335		return NULL;
336
337#ifdef DEBUG
338	printk("dvma_malloc request %lx bytes\n", len);
339#endif
340	len = ((len + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
341
342        if((kaddr = __get_free_pages(GFP_ATOMIC, get_order(len))) == 0)
343		return NULL;
344
345	if((baddr = (unsigned long)dvma_map_align(kaddr, len, align)) == 0) {
346		free_pages(kaddr, get_order(len));
347		return NULL;
348	}
349
350	vaddr = dvma_btov(baddr);
351
352	if(dvma_map_cpu(kaddr, vaddr, len) < 0) {
353		dvma_unmap((void *)baddr);
354		free_pages(kaddr, get_order(len));
355		return NULL;
356	}
357
358#ifdef DEBUG
359	printk("mapped %08lx bytes %08lx kern -> %08lx bus\n",
360	       len, kaddr, baddr);
361#endif
362
363	return (void *)vaddr;
364
365}
366
367void dvma_free(void *vaddr)
368{
369
370	return;
371
372}
373