arch/m68k/sun3/sun3dvma.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * linux/arch/m68k/sun3/sun3dvma.c
   4  *
   5  * Copyright (C) 2000 Sam Creasey
   6  *
   7  * Contains common routines for sun3/sun3x DVMA management.
   8  */
   9
  10 #include <linux/memblock.h>
  11 #include <linux/init.h>
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/gfp.h>
  15 #include <linux/mm.h>
  16 #include <linux/list.h>
  17
  18 #include <asm/page.h>
  19 #include <asm/pgtable.h>
  20 #include <asm/dvma.h>
  21
  22 #undef DVMA_DEBUG
  23
  24 #ifdef CONFIG_SUN3X
  25 extern void dvma_unmap_iommu(unsigned long baddr, int len);
  26 #else
  27 static inline void dvma_unmap_iommu(unsigned long a, int b)
  28 {
  29 }
  30 #endif
  31
  32 #ifdef CONFIG_SUN3
  33 extern void sun3_dvma_init(void);
  34 #endif
  35
  36 static unsigned long *iommu_use;
  37
  38 #define dvma_index(baddr) ((baddr - DVMA_START) >> DVMA_PAGE_SHIFT)
  39
  40 #define dvma_entry_use(baddr)           (iommu_use[dvma_index(baddr)])
  41
  42 struct hole {
  43         unsigned long start;
  44         unsigned long end;
  45         unsigned long size;
  46         struct list_head list;
  47 };
  48
  49 static struct list_head hole_list;
  50 static struct list_head hole_cache;
  51 static struct hole initholes[64];
  52
  53 #ifdef DVMA_DEBUG
  54
  55 static unsigned long dvma_allocs;
  56 static unsigned long dvma_frees;
  57 static unsigned long long dvma_alloc_bytes;
  58 static unsigned long long dvma_free_bytes;
  59
  60 static void print_use(void)
  61 {
  62
  63         int i;
  64         int j = 0;
  65
  66         pr_info("dvma entry usage:\n");
  67
  68         for(i = 0; i < IOMMU_TOTAL_ENTRIES; i++) {
  69                 if(!iommu_use[i])
  70                         continue;
  71
  72                 j++;
  73
  74                 pr_info("dvma entry: %08x len %08lx\n",
  75                         (i << DVMA_PAGE_SHIFT) + DVMA_START, iommu_use[i]);
  76         }
  77
  78         pr_info("%d entries in use total\n", j);
  79
  80         pr_info("allocation/free calls: %lu/%lu\n", dvma_allocs, dvma_frees);
  81         pr_info("allocation/free bytes: %Lx/%Lx\n", dvma_alloc_bytes,
  82                 dvma_free_bytes);
  83 }
  84
  85 static void print_holes(struct list_head *holes)
  86 {
  87
  88         struct list_head *cur;
  89         struct hole *hole;
  90
  91         pr_info("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                 pr_info("hole: start %08lx end %08lx size %08lx\n",
  99                         hole->start, hole->end, hole->size);
 100         }
 101
 102         pr_info("end of hole listing...\n");
 103 }
 104 #endif /* DVMA_DEBUG */
 105
 106 static 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
 134 static inline struct hole *rmcache(void)
 135 {
 136         struct hole *ret;
 137
 138         if(list_empty(&hole_cache)) {
 139                 if(!refill()) {
 140                         pr_crit("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
 152 static 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                 pr_crit("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         pr_crit("unable to find dvma hole!\n");
 199         BUG();
 200         return 0;
 201 }
 202
 203 static 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
 250 void __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 = memblock_alloc(IOMMU_TOTAL_ENTRIES * sizeof(unsigned long),
 271                                    SMP_CACHE_BYTES);
 272         if (!iommu_use)
 273                 panic("%s: Failed to allocate %zu bytes\n", __func__,
 274                       IOMMU_TOTAL_ENTRIES * sizeof(unsigned long));
 275
 276         dvma_unmap_iommu(DVMA_START, DVMA_SIZE);
 277
 278 #ifdef CONFIG_SUN3
 279         sun3_dvma_init();
 280 #endif
 281
 282 }
 283
 284 unsigned long dvma_map_align(unsigned long kaddr, int len, int align)
 285 {
 286
 287         unsigned long baddr;
 288         unsigned long off;
 289
 290         if(!len)
 291                 len = 0x800;
 292
 293         if(!kaddr || !len) {
 294 //              pr_err("error: kaddr %lx len %x\n", kaddr, len);
 295 //              *(int *)4 = 0;
 296                 return 0;
 297         }
 298
 299         pr_debug("dvma_map request %08x bytes from %08lx\n", len, kaddr);
 300         off = kaddr & ~DVMA_PAGE_MASK;
 301         kaddr &= PAGE_MASK;
 302         len += off;
 303         len = ((len + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
 304
 305         if(align == 0)
 306                 align = DVMA_PAGE_SIZE;
 307         else
 308                 align = ((align + (DVMA_PAGE_SIZE-1)) & DVMA_PAGE_MASK);
 309
 310         baddr = get_baddr(len, align);
 311 //      pr_info("using baddr %lx\n", baddr);
 312
 313         if(!dvma_map_iommu(kaddr, baddr, len))
 314                 return (baddr + off);
 315
 316         pr_crit("dvma_map failed kaddr %lx baddr %lx len %x\n", kaddr, baddr,
 317         len);
 318         BUG();
 319         return 0;
 320 }
 321 EXPORT_SYMBOL(dvma_map_align);
 322
 323 void dvma_unmap(void *baddr)
 324 {
 325         unsigned long addr;
 326
 327         addr = (unsigned long)baddr;
 328         /* check if this is a vme mapping */
 329         if(!(addr & 0x00f00000))
 330                 addr |= 0xf00000;
 331
 332         free_baddr(addr);
 333
 334         return;
 335
 336 }
 337 EXPORT_SYMBOL(dvma_unmap);
 338
 339 void *dvma_malloc_align(unsigned long len, unsigned long align)
 340 {
 341         unsigned long kaddr;
 342         unsigned long baddr;
 343         unsigned long vaddr;
 344
 345         if(!len)
 346                 return NULL;
 347
 348         pr_debug("dvma_malloc request %lx bytes\n", len);
 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         pr_debug("mapped %08lx bytes %08lx kern -> %08lx bus\n", len, kaddr,
 368                  baddr);
 369
 370         return (void *)vaddr;
 371
 372 }
 373 EXPORT_SYMBOL(dvma_malloc_align);
 374
 375 void dvma_free(void *vaddr)
 376 {
 377
 378         return;
 379
 380 }
 381 EXPORT_SYMBOL(dvma_free);