381 lines
6.8 KiB
C
381 lines
6.8 KiB
C
/*
|
|
* linux/arch/m68k/sun3/sun3dvma.c
|
|
*
|
|
* Copyright (C) 2000 Sam Creasey
|
|
*
|
|
* Contains common routines for sun3/sun3x DVMA management.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/list.h>
|
|
|
|
#include <asm/page.h>
|
|
#include <asm/pgtable.h>
|
|
#include <asm/dvma.h>
|
|
|
|
#undef DVMA_DEBUG
|
|
|
|
#ifdef CONFIG_SUN3X
|
|
extern void dvma_unmap_iommu(unsigned long baddr, int len);
|
|
#else
|
|
static inline void dvma_unmap_iommu(unsigned long a, int b)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_SUN3
|
|
extern void sun3_dvma_init(void);
|
|
#endif
|
|
|
|
static unsigned long iommu_use[IOMMU_TOTAL_ENTRIES];
|
|
|
|
#define dvma_index(baddr) ((baddr - DVMA_START) >> DVMA_PAGE_SHIFT)
|
|
|
|
#define dvma_entry_use(baddr) (iommu_use[dvma_index(baddr)])
|
|
|
|
struct hole {
|
|
unsigned long start;
|
|
unsigned long end;
|
|
unsigned long size;
|
|
struct list_head list;
|
|
};
|
|
|
|
static struct list_head hole_list;
|
|
static struct list_head hole_cache;
|
|
static struct hole initholes[64];
|
|
|
|
#ifdef DVMA_DEBUG
|
|
|
|
static unsigned long dvma_allocs;
|
|
static unsigned long dvma_frees;
|
|
static unsigned long long dvma_alloc_bytes;
|
|
static unsigned long long dvma_free_bytes;
|
|
|
|
static void print_use(void)
|
|
{
|
|
|
|
int i;
|
|
int j = 0;
|
|
|
|
printk("dvma entry usage:\n");
|
|
|
|
for(i = 0; i < IOMMU_TOTAL_ENTRIES; i++) {
|
|
if(!iommu_use[i])
|
|
continue;
|
|
|
|
j++;
|
|
|
|
printk("dvma entry: %08lx len %08lx\n",
|
|
( i << DVMA_PAGE_SHIFT) + DVMA_START,
|
|
iommu_use[i]);
|
|
}
|
|
|
|
printk("%d entries in use total\n", j);
|
|
|
|
printk("allocation/free calls: %lu/%lu\n", dvma_allocs, dvma_frees);
|
|
printk("allocation/free bytes: %Lx/%Lx\n", dvma_alloc_bytes,
|
|
dvma_free_bytes);
|
|
}
|
|
|
|
static void print_holes(struct list_head *holes)
|
|
{
|
|
|
|
struct list_head *cur;
|
|
struct hole *hole;
|
|
|
|
printk("listing dvma holes\n");
|
|
list_for_each(cur, holes) {
|
|
hole = list_entry(cur, struct hole, list);
|
|
|
|
if((hole->start == 0) && (hole->end == 0) && (hole->size == 0))
|
|
continue;
|
|
|
|
printk("hole: start %08lx end %08lx size %08lx\n", hole->start, hole->end, hole->size);
|
|
}
|
|
|
|
printk("end of hole listing...\n");
|
|
|
|
}
|
|
#endif /* DVMA_DEBUG */
|
|
|
|
static inline int refill(void)
|
|
{
|
|
|
|
struct hole *hole;
|
|
struct hole *prev = NULL;
|
|
struct list_head *cur;
|
|
int ret = 0;
|
|
|
|
list_for_each(cur, &hole_list) {
|
|
hole = list_entry(cur, struct hole, list);
|
|
|
|
if(!prev) {
|
|
prev = hole;
|
|
continue;
|
|
}
|
|
|
|
if(hole->end == prev->start) {
|
|
hole->size += prev->size;
|
|
hole->end = prev->end;
|
|
list_move(&(prev->list), &hole_cache);
|
|
ret++;
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline struct hole *rmcache(void)
|
|
{
|
|
struct hole *ret;
|
|
|
|
if(list_empty(&hole_cache)) {
|
|
if(!refill()) {
|
|
printk("out of dvma hole cache!\n");
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
ret = list_entry(hole_cache.next, struct hole, list);
|
|
list_del(&(ret->list));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
static inline unsigned long get_baddr(int len, unsigned long align)
|
|
{
|
|
|
|
struct list_head *cur;
|
|
struct hole *hole;
|
|
|
|
if(list_empty(&hole_list)) {
|
|
#ifdef DVMA_DEBUG
|
|
printk("out of dvma holes! (printing hole cache)\n");
|
|
print_holes(&hole_cache);
|
|
print_use();
|
|
#endif
|
|
BUG();
|
|
}
|
|
|
|
list_for_each(cur, &hole_list) {
|
|
unsigned long newlen;
|
|
|
|
hole = list_entry(cur, struct hole, list);
|
|
|
|
if(align > DVMA_PAGE_SIZE)
|
|
newlen = len + ((hole->end - len) & (align-1));
|
|
else
|
|
newlen = len;
|
|
|
|
if(hole->size > newlen) {
|
|
hole->end -= newlen;
|
|
hole->size -= newlen;
|
|
dvma_entry_use(hole->end) = newlen;
|
|
#ifdef DVMA_DEBUG
|
|
dvma_allocs++;
|
|
dvma_alloc_bytes += newlen;
|
|
#endif
|
|
return hole->end;
|
|
} else if(hole->size == newlen) {
|
|
list_move(&(hole->list), &hole_cache);
|
|
dvma_entry_use(hole->start) = newlen;
|
|
#ifdef DVMA_DEBUG
|
|
dvma_allocs++;
|
|
dvma_alloc_bytes += newlen;
|
|
#endif
|
|
return hole->start;
|
|
}
|
|
|
|
}
|
|
|
|
printk("unable to find dvma hole!\n");
|
|
BUG();
|
|
return 0;
|
|
}
|
|
|
|
static inline int free_baddr(unsigned long baddr)
|
|
{
|
|
|
|
unsigned long len;
|
|
struct hole *hole;
|
|
struct list_head *cur;
|
|
unsigned long orig_baddr;
|
|
|
|
orig_baddr = baddr;
|
|
len = dvma_entry_use(baddr);
|
|
dvma_entry_use(baddr) = 0;
|
|
baddr &= DVMA_PAGE_MASK;
|
|
dvma_unmap_iommu(baddr, len);
|
|
|
|
#ifdef DVMA_DEBUG
|
|
dvma_frees++;
|
|
dvma_free_bytes += len;
|
|
#endif
|
|
|
|
list_for_each(cur, &hole_list) {
|
|
hole = list_entry(cur, struct hole, list);
|
|
|
|
if(hole->end == baddr) {
|
|
hole->end += len;
|
|
hole->size += len;
|
|
return 0;
|
|
} else if(hole->start == (baddr + len)) {
|
|
hole->start = baddr;
|
|
hole->size += len;
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
hole = rmcache();
|
|
|
|
hole->start = baddr;
|
|
hole->end = baddr + len;
|
|
hole->size = len;
|
|
|
|
// list_add_tail(&(hole->list), cur);
|
|
list_add(&(hole->list), cur);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
void dvma_init(void)
|
|
{
|
|
|
|
struct hole *hole;
|
|
int i;
|
|
|
|
INIT_LIST_HEAD(&hole_list);
|
|
INIT_LIST_HEAD(&hole_cache);
|
|
|
|
/* prepare the hole cache */
|
|
for(i = 0; i < 64; i++)
|
|
list_add(&(initholes[i].list), &hole_cache);
|
|
|
|
hole = rmcache();
|
|
hole->start = DVMA_START;
|
|
hole->end = DVMA_END;
|
|
hole->size = DVMA_SIZE;
|
|
|
|
list_add(&(hole->list), &hole_list);
|
|
|
|
memset(iommu_use, 0, sizeof(iommu_use));
|
|
|
|
dvma_unmap_iommu(DVMA_START, DVMA_SIZE);
|
|
|
|
#ifdef CONFIG_SUN3
|
|
sun3_dvma_init();
|
|
#endif
|
|
|
|
}
|
|
|
|
inline unsigned long dvma_map_align(unsigned long kaddr, int len, int align)
|
|
{
|
|
|
|
unsigned long baddr;
|
|
unsigned long off;
|
|
|
|
if(!len)
|
|
len = 0x800;
|
|
|
|
if(!kaddr || !len) {
|
|
// printk("error: kaddr %lx len %x\n", kaddr, len);
|
|
// *(int *)4 = 0;
|
|
return 0;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
printk("dvma_map request %08lx bytes from %08lx\n",
|
|
len, kaddr);
|
|
#endif
|
|
off = kaddr & ~DVMA_PAGE_MASK;
|
|
kaddr &= PAGE_MASK;
|
|
len += off;
|
|
len = ((len + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
|
|
|
|
if(align == 0)
|
|
align = DVMA_PAGE_SIZE;
|
|
else
|
|
align = ((align + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
|
|
|
|
baddr = get_baddr(len, align);
|
|
// printk("using baddr %lx\n", baddr);
|
|
|
|
if(!dvma_map_iommu(kaddr, baddr, len))
|
|
return (baddr + off);
|
|
|
|
printk("dvma_map failed kaddr %lx baddr %lx len %x\n", kaddr, baddr, len);
|
|
BUG();
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(dvma_map_align);
|
|
|
|
void dvma_unmap(void *baddr)
|
|
{
|
|
unsigned long addr;
|
|
|
|
addr = (unsigned long)baddr;
|
|
/* check if this is a vme mapping */
|
|
if(!(addr & 0x00f00000))
|
|
addr |= 0xf00000;
|
|
|
|
free_baddr(addr);
|
|
|
|
return;
|
|
|
|
}
|
|
EXPORT_SYMBOL(dvma_unmap);
|
|
|
|
void *dvma_malloc_align(unsigned long len, unsigned long align)
|
|
{
|
|
unsigned long kaddr;
|
|
unsigned long baddr;
|
|
unsigned long vaddr;
|
|
|
|
if(!len)
|
|
return NULL;
|
|
|
|
#ifdef DEBUG
|
|
printk("dvma_malloc request %lx bytes\n", len);
|
|
#endif
|
|
len = ((len + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
|
|
|
|
if((kaddr = __get_free_pages(GFP_ATOMIC, get_order(len))) == 0)
|
|
return NULL;
|
|
|
|
if((baddr = (unsigned long)dvma_map_align(kaddr, len, align)) == 0) {
|
|
free_pages(kaddr, get_order(len));
|
|
return NULL;
|
|
}
|
|
|
|
vaddr = dvma_btov(baddr);
|
|
|
|
if(dvma_map_cpu(kaddr, vaddr, len) < 0) {
|
|
dvma_unmap((void *)baddr);
|
|
free_pages(kaddr, get_order(len));
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
printk("mapped %08lx bytes %08lx kern -> %08lx bus\n",
|
|
len, kaddr, baddr);
|
|
#endif
|
|
|
|
return (void *)vaddr;
|
|
|
|
}
|
|
EXPORT_SYMBOL(dvma_malloc_align);
|
|
|
|
void dvma_free(void *vaddr)
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
EXPORT_SYMBOL(dvma_free);
|