qemu/roms/openbios/arch/sparc32/lib.c

   1 /* lib.c
   2  * tag: simple function library
   3  *
   4  * Copyright (C) 2003 Stefan Reinauer
   5  *
   6  * See the file "COPYING" for further information about
   7  * the copyright and warranty status of this work.
   8  */
   9
  10 #include "libc/vsprintf.h"
  11 #include "libopenbios/bindings.h"
  12 #include "arch/sparc32/ofmem_sparc32.h"
  13 #include "asm/asi.h"
  14 #include "pgtsrmmu.h"
  15 #include "openprom.h"
  16 #include "libopenbios/sys_info.h"
  17 #include "boot.h"
  18 #include "romvec.h"
  19
  20 #define NCTX_SWIFT  0x100
  21 #define LOWMEMSZ 32 * 1024 * 1024
  22
  23 #ifdef CONFIG_DEBUG_MEM
  24 #define DPRINTF(fmt, args...)                   \
  25     do { printk(fmt , ##args); } while (0)
  26 #else
  27 #define DPRINTF(fmt, args...)
  28 #endif
  29
  30 /* Format a string and print it on the screen, just like the libc
  31  * function printf.
  32  */
  33 int printk( const char *fmt, ... )
  34 {
  35         char *p, buf[512];
  36         va_list args;
  37         int i;
  38
  39         va_start(args, fmt);
  40         i = vsnprintf(buf, sizeof(buf), fmt, args);
  41         va_end(args);
  42
  43         for( p=buf; *p; p++ )
  44                 putchar(*p);
  45         return i;
  46 }
  47
  48 /*
  49  * Allocatable memory chunk.
  50  */
  51 struct mem {
  52     char *start, *uplim;
  53     char *curp;
  54 };
  55
  56 struct mem cdvmem;              /* Current device virtual memory space */
  57
  58 unsigned int va_shift;
  59 unsigned long *l1;
  60 static unsigned long *context_table;
  61
  62 struct linux_mlist_v0 *ptphys;
  63 struct linux_mlist_v0 *ptmap;
  64 struct linux_mlist_v0 *ptavail;
  65
  66 /* Private functions for mapping between physical/virtual addresses */
  67 phys_addr_t
  68 va2pa(unsigned long va)
  69 {
  70     if ((va >= (unsigned long)&_start) &&
  71         (va < (unsigned long)&_end))
  72         return va - va_shift;
  73     else
  74         return va;
  75 }
  76
  77 unsigned long
  78 pa2va(phys_addr_t pa)
  79 {
  80     if ((pa + va_shift >= (unsigned long)&_start) &&
  81         (pa + va_shift < (unsigned long)&_end))
  82         return pa + va_shift;
  83     else
  84         return pa;
  85 }
  86
  87 void *
  88 malloc(int size)
  89 {
  90     return ofmem_malloc(size);
  91 }
  92
  93 void *
  94 realloc( void *ptr, size_t size )
  95 {
  96     return ofmem_realloc(ptr, size);
  97 }
  98
  99 void
 100 free(void *ptr)
 101 {
 102     ofmem_free(ptr);
 103 }
 104
 105 /*
 106  * Allocate memory. This is reusable.
 107  */
 108 void
 109 mem_init(struct mem *t, char *begin, char *limit)
 110 {
 111     t->start = begin;
 112     t->uplim = limit;
 113     t->curp = begin;
 114 }
 115
 116 void *
 117 mem_alloc(struct mem *t, int size, int align)
 118 {
 119     char *p;
 120     unsigned long pa;
 121
 122     // The alignment restrictions refer to physical, not virtual
 123     // addresses
 124     pa = va2pa((unsigned long)t->curp) + (align - 1);
 125     pa &= ~(align - 1);
 126     p = (char *)pa2va(pa);
 127
 128     if ((unsigned long)p >= (unsigned long)t->uplim ||
 129         (unsigned long)p + size > (unsigned long)t->uplim)
 130         return NULL;
 131     t->curp = p + size;
 132
 133     return p;
 134 }
 135
 136 /*
 137  * D5.3 pgmap@ ( va -- pte )
 138  */
 139 static void
 140 pgmap_fetch(void)
 141 {
 142     uint32_t pte;
 143     unsigned long va, pa;
 144
 145     va = POP();
 146
 147     pa = find_pte(va, 0);
 148     if (pa == 1 || pa == 2)
 149         goto error;
 150     pte = *(uint32_t *)pa;
 151     DPRINTF("pgmap@: va 0x%lx pa 0x%lx pte 0x%x\n", va, pa, pte);
 152
 153     PUSH(pte);
 154     return;
 155  error:
 156     PUSH(0);
 157 }
 158
 159 /*
 160  * D5.3 pgmap! ( pte va -- )
 161  */
 162 static void
 163 pgmap_store(void)
 164 {
 165     uint32_t pte;
 166     unsigned long va, pa;
 167
 168     va = POP();
 169     pte = POP();
 170
 171     pa = find_pte(va, 1);
 172     *(uint32_t *)pa = pte;
 173     DPRINTF("pgmap!: va 0x%lx pa 0x%lx pte 0x%x\n", va, pa, pte);
 174 }
 175
 176 /*
 177  * D5.3 map-pages ( pa space va size -- )
 178  */
 179 static void
 180 ob_map_pages(void)
 181 {
 182     unsigned long va;
 183     int size;
 184     uint64_t pa;
 185
 186     size = POP();
 187     va = POP();
 188     pa = POP();
 189     pa <<= 32;
 190     pa |= POP() & 0xffffffff;
 191
 192     ofmem_arch_map_pages(pa, va, size, ofmem_arch_default_translation_mode(pa));
 193 }
 194
 195 char *obp_dumb_mmap(char *va, int which_io, unsigned int pa,
 196                     unsigned int size)
 197 {
 198     uint64_t mpa = ((uint64_t)which_io << 32) | (uint64_t)pa;
 199
 200     ofmem_arch_map_pages(mpa, (unsigned long)va, size, ofmem_arch_default_translation_mode(mpa));
 201     return va;
 202 }
 203
 204 void obp_dumb_munmap(__attribute__((unused)) char *va,
 205                      __attribute__((unused)) unsigned int size)
 206 {
 207     DPRINTF("obp_dumb_munmap: virta 0x%x, sz %d\n", (unsigned int)va, size);
 208 }
 209
 210 char *obp_memalloc(char *va, unsigned int size, unsigned int align)
 211 {
 212     phys_addr_t phys;
 213     ucell virt;
 214
 215     DPRINTF("obp_memalloc: virta 0x%x, sz %d, align %d\n", (unsigned int)va, size, align);
 216
 217     /* Claim physical memory */
 218     phys = ofmem_claim_phys(-1, size, align);
 219
 220     /* Claim virtual memory */
 221     virt = ofmem_claim_virt(pointer2cell(va), size, 0);
 222
 223     /* Map the memory */
 224     ofmem_map(phys, virt, size, ofmem_arch_default_translation_mode(phys));
 225
 226     return cell2pointer(virt);
 227 }
 228
 229 char *obp_dumb_memalloc(char *va, unsigned int size)
 230 {
 231     unsigned long align = size;
 232     phys_addr_t phys;
 233     ucell virt;
 234
 235     DPRINTF("obp_dumb_memalloc: virta 0x%x, sz %d\n", (unsigned int)va, size);
 236
 237     /* Solaris seems to assume that the returned value is physically aligned to size.
 238        e.g. it is used for setting up page tables. */
 239
 240     /* Claim physical memory */
 241     phys = ofmem_claim_phys(-1, size, align);
 242
 243     /* Claim virtual memory - if va == NULL then we choose va address */
 244     if (va == NULL) {
 245         virt = ofmem_claim_virt((ucell)-1, size, align);
 246     } else {
 247         virt = ofmem_claim_virt(pointer2cell(va), size, 0);
 248     }
 249
 250     /* Map the memory */
 251     ofmem_map(phys, virt, size, ofmem_arch_default_translation_mode(phys));
 252
 253     return cell2pointer(virt);
 254 }
 255
 256 void obp_dumb_memfree(char *va, unsigned size)
 257 {
 258     phys_addr_t phys;
 259     ucell cellmode;
 260
 261     DPRINTF("obp_dumb_memfree: virta 0x%x, sz %d\n", (unsigned int)va, size);
 262
 263     phys = ofmem_translate(pointer2cell(va), &cellmode);
 264
 265     ofmem_unmap(pointer2cell(va), size);
 266     ofmem_release_virt(pointer2cell(va), size);
 267     ofmem_release_phys(phys, size);
 268 }
 269
 270 /* Data fault handling routines */
 271
 272 extern unsigned int ignore_dfault;
 273
 274 /* ( -- reg ) */
 275 static void srmmu_get_sfsr(void)
 276 {
 277     PUSH(srmmu_get_fstatus());
 278 }
 279
 280 /* ( -- addr ) */
 281 static void ignore_dfault_addr(void)
 282 {
 283     PUSH(pointer2cell(&ignore_dfault));
 284 }
 285
 286 void
 287 ob_init_mmu(void)
 288 {
 289     ucell *memreg;
 290     ucell *virtreg;
 291     phys_addr_t virtregsize;
 292     ofmem_t *ofmem = ofmem_arch_get_private();
 293
 294     /* Find the phandles for the /memory and /virtual-memory nodes */
 295     push_str("/memory");
 296     fword("find-package");
 297     POP();
 298     s_phandle_memory = POP();
 299
 300     push_str("/virtual-memory");
 301     fword("find-package");
 302     POP();
 303     s_phandle_mmu = POP();
 304
 305     ofmem_register(s_phandle_memory, s_phandle_mmu);
 306
 307     /* Setup /memory:reg (totphys) property */
 308     memreg = malloc(3 * sizeof(ucell));
 309     ofmem_arch_encode_physaddr(memreg, 0); /* physical base */
 310     memreg[2] = (ucell)ofmem->ramsize; /* size */
 311
 312     push_str("/memory");
 313     fword("find-device");
 314     PUSH(pointer2cell(memreg));
 315     PUSH(3 * sizeof(ucell));
 316     push_str("reg");
 317     PUSH_ph(s_phandle_memory);
 318     fword("encode-property");
 319
 320     /* Setup /virtual-memory:reg property */
 321     virtregsize = ((phys_addr_t)((ucell)-1) + 1) / 2;
 322
 323     virtreg = malloc(6 * sizeof(ucell));
 324     ofmem_arch_encode_physaddr(virtreg, 0);
 325     virtreg[2] = virtregsize;
 326     ofmem_arch_encode_physaddr(&virtreg[3], virtregsize);
 327     virtreg[5] = virtregsize;
 328
 329     push_str("/virtual-memory");
 330     fword("find-device");
 331     PUSH(pointer2cell(virtreg));
 332     PUSH(6 * sizeof(ucell));
 333     push_str("reg");
 334     PUSH_ph(s_phandle_mmu);
 335     fword("encode-property");
 336
 337     PUSH(0);
 338     fword("active-package!");
 339     bind_func("pgmap@", pgmap_fetch);
 340     bind_func("pgmap!", pgmap_store);
 341     bind_func("map-pages", ob_map_pages);
 342
 343     /* Install data fault handler words for cpeek etc. */
 344     PUSH_xt(bind_noname_func(srmmu_get_sfsr));
 345     feval("to sfsr@");
 346     PUSH_xt(bind_noname_func(ignore_dfault_addr));
 347     feval("to ignore-dfault");
 348 }
 349
 350 /*
 351  * Switch page tables.
 352  */
 353 void
 354 init_mmu_swift(void)
 355 {
 356     unsigned int addr, i;
 357     unsigned long pa, va;
 358     int size;
 359
 360     ofmem_posix_memalign((void *)&context_table, NCTX_SWIFT * sizeof(int),
 361                    NCTX_SWIFT * sizeof(int));
 362     ofmem_posix_memalign((void *)&l1, 256 * sizeof(int), 256 * sizeof(int));
 363
 364     context_table[0] = (((unsigned long)va2pa((unsigned long)l1)) >> 4) |
 365         SRMMU_ET_PTD;
 366
 367     for (i = 1; i < NCTX_SWIFT; i++) {
 368         context_table[i] = SRMMU_ET_INVALID;
 369     }
 370     for (i = 0; i < 256; i++) {
 371         l1[i] = SRMMU_ET_INVALID;
 372     }
 373
 374     // text, rodata, data, and bss mapped to end of RAM
 375     va = (unsigned long)&_start;
 376     size = (unsigned long)&_end - (unsigned long)&_start;
 377     pa = va2pa(va);
 378     ofmem_arch_map_pages(pa, va, size, ofmem_arch_default_translation_mode(pa));
 379     ofmem_map_page_range(pa, va, size, ofmem_arch_default_translation_mode(pa));
 380
 381     // 1:1 mapping for RAM (don't map page 0 to allow catching of NULL dereferences)
 382     ofmem_arch_map_pages(PAGE_SIZE, PAGE_SIZE, LOWMEMSZ - PAGE_SIZE, ofmem_arch_default_translation_mode(0));
 383     ofmem_map_page_range(PAGE_SIZE, PAGE_SIZE, LOWMEMSZ - PAGE_SIZE, ofmem_arch_default_translation_mode(0));
 384
 385     /*
 386      * Flush cache
 387      */
 388     for (addr = 0; addr < 0x2000; addr += 0x10) {
 389         __asm__ __volatile__ ("sta %%g0, [%0] %1\n\t" : :
 390                               "r" (addr), "i" (ASI_M_DATAC_TAG));
 391         __asm__ __volatile__ ("sta %%g0, [%0] %1\n\t" : :
 392                               "r" (addr<<1), "i" (ASI_M_TXTC_TAG));
 393     }
 394     srmmu_set_context(0);
 395     srmmu_set_ctable_ptr(va2pa((unsigned long)context_table));
 396     srmmu_flush_whole_tlb();
 397 }