Logo Search packages:      
Sourcecode: linux version File versions  Download package

sun3dvma.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

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);

Generated by  Doxygen 1.6.0   Back to index