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