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