arch/m68k/sun3/mmu_emu.c

   1 /*
   2 ** Tablewalk MMU emulator
   3 **
   4 ** by Toshiyasu Morita
   5 **
   6 ** Started 1/16/98 @ 2:22 am
   7 */
   8
   9 #include <linux/mman.h>
  10 #include <linux/mm.h>
  11 #include <linux/kernel.h>
  12 #include <linux/ptrace.h>
  13 #include <linux/delay.h>
  14 #include <linux/bootmem.h>
  15
  16 #include <asm/setup.h>
  17 #include <asm/traps.h>
  18 #include <asm/system.h>
  19 #include <asm/uaccess.h>
  20 #include <asm/page.h>
  21 #include <asm/pgtable.h>
  22 #include <asm/sun3mmu.h>
  23 #include <asm/segment.h>
  24 #include <asm/bitops.h>
  25 #include <asm/oplib.h>
  26 #include <asm/mmu_context.h>
  27 #include <asm/dvma.h>
  28
  29 extern void prom_reboot (char *) __attribute__ ((__noreturn__));
  30
  31 #undef DEBUG_MMU_EMU
  32 #define DEBUG_PROM_MAPS
  33
  34 /*
  35 ** Defines
  36 */
  37
  38 #define CONTEXTS_NUM            8
  39 #define SEGMAPS_PER_CONTEXT_NUM 2048
  40 #define PAGES_PER_SEGMENT       16
  41 #define PMEGS_NUM               256
  42 #define PMEG_MASK               0xFF
  43
  44 /*
  45 ** Globals
  46 */
  47
  48 unsigned long vmalloc_end;
  49 unsigned long pmeg_vaddr[PMEGS_NUM];
  50 unsigned char pmeg_alloc[PMEGS_NUM];
  51 unsigned char pmeg_ctx[PMEGS_NUM];
  52
  53 /* pointers to the mm structs for each task in each
  54    context. 0xffffffff is a marker for kernel context */
  55 struct mm_struct *ctx_alloc[CONTEXTS_NUM] = {
  56     [0] = (struct mm_struct *)0xffffffff
  57 };
  58
  59 /* has this context been mmdrop'd? */
  60 static unsigned char ctx_avail = CONTEXTS_NUM-1;
  61
  62 /* array of pages to be marked off for the rom when we do mem_init later */
  63 /* 256 pages lets the rom take up to 2mb of physical ram..  I really
  64    hope it never wants mote than that. */
  65 unsigned long rom_pages[256];
  66
  67 /* Print a PTE value in symbolic form. For debugging. */
  68 void print_pte (pte_t pte)
  69 {
  70 #if 0
  71         /* Verbose version. */
  72         unsigned long val = pte_val (pte);
  73         printk (" pte=%lx [addr=%lx",
  74                 val, (val & SUN3_PAGE_PGNUM_MASK) << PAGE_SHIFT);
  75         if (val & SUN3_PAGE_VALID)      printk (" valid");
  76         if (val & SUN3_PAGE_WRITEABLE)  printk (" write");
  77         if (val & SUN3_PAGE_SYSTEM)     printk (" sys");
  78         if (val & SUN3_PAGE_NOCACHE)    printk (" nocache");
  79         if (val & SUN3_PAGE_ACCESSED)   printk (" accessed");
  80         if (val & SUN3_PAGE_MODIFIED)   printk (" modified");
  81         switch (val & SUN3_PAGE_TYPE_MASK) {
  82                 case SUN3_PAGE_TYPE_MEMORY: printk (" memory"); break;
  83                 case SUN3_PAGE_TYPE_IO:     printk (" io");     break;
  84                 case SUN3_PAGE_TYPE_VME16:  printk (" vme16");  break;
  85                 case SUN3_PAGE_TYPE_VME32:  printk (" vme32");  break;
  86         }
  87         printk ("]\n");
  88 #else
  89         /* Terse version. More likely to fit on a line. */
  90         unsigned long val = pte_val (pte);
  91         char flags[7], *type;
  92
  93         flags[0] = (val & SUN3_PAGE_VALID)     ? 'v' : '-';
  94         flags[1] = (val & SUN3_PAGE_WRITEABLE) ? 'w' : '-';
  95         flags[2] = (val & SUN3_PAGE_SYSTEM)    ? 's' : '-';
  96         flags[3] = (val & SUN3_PAGE_NOCACHE)   ? 'x' : '-';
  97         flags[4] = (val & SUN3_PAGE_ACCESSED)  ? 'a' : '-';
  98         flags[5] = (val & SUN3_PAGE_MODIFIED)  ? 'm' : '-';
  99         flags[6] = '\0';
 100
 101         switch (val & SUN3_PAGE_TYPE_MASK) {
 102                 case SUN3_PAGE_TYPE_MEMORY: type = "memory"; break;
 103                 case SUN3_PAGE_TYPE_IO:     type = "io"    ; break;
 104                 case SUN3_PAGE_TYPE_VME16:  type = "vme16" ; break;
 105                 case SUN3_PAGE_TYPE_VME32:  type = "vme32" ; break;
 106                 default: type = "unknown?"; break;
 107         }
 108
 109         printk (" pte=%08lx [%07lx %s %s]\n",
 110                 val, (val & SUN3_PAGE_PGNUM_MASK) << PAGE_SHIFT, flags, type);
 111 #endif
 112 }
 113
 114 /* Print the PTE value for a given virtual address. For debugging. */
 115 void print_pte_vaddr (unsigned long vaddr)
 116 {
 117         printk (" vaddr=%lx [%02lx]", vaddr, sun3_get_segmap (vaddr));
 118         print_pte (__pte (sun3_get_pte (vaddr)));
 119 }
 120
 121 /*
 122  * Initialise the MMU emulator.
 123  */
 124 void mmu_emu_init(unsigned long bootmem_end)
 125 {
 126         unsigned long seg, num;
 127         int i,j;
 128
 129         memset(rom_pages, 0, sizeof(rom_pages));
 130         memset(pmeg_vaddr, 0, sizeof(pmeg_vaddr));
 131         memset(pmeg_alloc, 0, sizeof(pmeg_alloc));
 132         memset(pmeg_ctx, 0, sizeof(pmeg_ctx));
 133
 134         /* pmeg align the end of bootmem, adding another pmeg,
 135          * later bootmem allocations will likely need it */
 136         bootmem_end = (bootmem_end + (2 * SUN3_PMEG_SIZE)) & ~SUN3_PMEG_MASK;
 137
 138         /* mark all of the pmegs used thus far as reserved */
 139         for (i=0; i < __pa(bootmem_end) / SUN3_PMEG_SIZE ; ++i)
 140                 pmeg_alloc[i] = 2;
 141
 142
 143         /* I'm thinking that most of the top pmeg's are going to be
 144            used for something, and we probably shouldn't risk it */
 145         for(num = 0xf0; num <= 0xff; num++)
 146                 pmeg_alloc[num] = 2;
 147
 148         /* liberate all existing mappings in the rest of kernel space */
 149         for(seg = bootmem_end; seg < 0x0f800000; seg += SUN3_PMEG_SIZE) {
 150                 i = sun3_get_segmap(seg);
 151
 152                 if(!pmeg_alloc[i]) {
 153 #ifdef DEBUG_MMU_EMU
 154                         printk("freed: ");
 155                         print_pte_vaddr (seg);
 156 #endif
 157                         sun3_put_segmap(seg, SUN3_INVALID_PMEG);
 158                 }
 159         }
 160
 161         j = 0;
 162         for (num=0, seg=0x0F800000; seg<0x10000000; seg+=16*PAGE_SIZE) {
 163                 if (sun3_get_segmap (seg) != SUN3_INVALID_PMEG) {
 164 #ifdef DEBUG_PROM_MAPS
 165                         for(i = 0; i < 16; i++) {
 166                                 printk ("mapped:");
 167                                 print_pte_vaddr (seg + (i*PAGE_SIZE));
 168                                 break;
 169                         }
 170 #endif
 171                         // the lowest mapping here is the end of our
 172                         // vmalloc region
 173                         if(!vmalloc_end)
 174                                 vmalloc_end = seg;
 175
 176                         // mark the segmap alloc'd, and reserve any
 177                         // of the first 0xbff pages the hardware is
 178                         // already using...  does any sun3 support > 24mb?
 179                         pmeg_alloc[sun3_get_segmap(seg)] = 2;
 180                 }
 181         }
 182
 183         dvma_init();
 184
 185
 186         /* blank everything below the kernel, and we've got the base
 187            mapping to start all the contexts off with... */
 188         for(seg = 0; seg < PAGE_OFFSET; seg += SUN3_PMEG_SIZE)
 189                 sun3_put_segmap(seg, SUN3_INVALID_PMEG);
 190
 191         set_fs(MAKE_MM_SEG(3));
 192         for(seg = 0; seg < 0x10000000; seg += SUN3_PMEG_SIZE) {
 193                 i = sun3_get_segmap(seg);
 194                 for(j = 1; j < CONTEXTS_NUM; j++)
 195                         (*(romvec->pv_setctxt))(j, (void *)seg, i);
 196         }
 197         set_fs(KERNEL_DS);
 198
 199 }
 200
 201 /* erase the mappings for a dead context.  Uses the pg_dir for hints
 202    as the pmeg tables proved somewhat unreliable, and unmapping all of
 203    TASK_SIZE was much slower and no more stable. */
 204 /* todo: find a better way to keep track of the pmegs used by a
 205    context for when they're cleared */
 206 void clear_context(unsigned long context)
 207 {
 208      unsigned char oldctx;
 209      unsigned long i;
 210
 211      if(context) {
 212              if(!ctx_alloc[context])
 213                      panic("clear_context: context not allocated\n");
 214
 215              ctx_alloc[context]->context = SUN3_INVALID_CONTEXT;
 216              ctx_alloc[context] = (struct mm_struct *)0;
 217              ctx_avail++;
 218      }
 219
 220      oldctx = sun3_get_context();
 221
 222      sun3_put_context(context);
 223
 224      for(i = 0; i < SUN3_INVALID_PMEG; i++) {
 225              if((pmeg_ctx[i] == context) && (pmeg_alloc[i] == 1)) {
 226                      sun3_put_segmap(pmeg_vaddr[i], SUN3_INVALID_PMEG);
 227                      pmeg_ctx[i] = 0;
 228                      pmeg_alloc[i] = 0;
 229                      pmeg_vaddr[i] = 0;
 230              }
 231      }
 232
 233      sun3_put_context(oldctx);
 234 }
 235
 236 /* gets an empty context.  if full, kills the next context listed to
 237    die first */
 238 /* This context invalidation scheme is, well, totally arbitrary, I'm
 239    sure it could be much more intellegent...  but it gets the job done
 240    for now without much overhead in making it's decision. */
 241 /* todo: come up with optimized scheme for flushing contexts */
 242 unsigned long get_free_context(struct mm_struct *mm)
 243 {
 244         unsigned long new = 1;
 245         static unsigned char next_to_die = 1;
 246
 247         if(!ctx_avail) {
 248                 /* kill someone to get our context */
 249                 new = next_to_die;
 250                 clear_context(new);
 251                 next_to_die = (next_to_die + 1) & 0x7;
 252                 if(!next_to_die)
 253                         next_to_die++;
 254         } else {
 255                 while(new < CONTEXTS_NUM) {
 256                         if(ctx_alloc[new])
 257                                 new++;
 258                         else
 259                                 break;
 260                 }
 261                 // check to make sure one was really free...
 262                 if(new == CONTEXTS_NUM)
 263                         panic("get_free_context: failed to find free context");
 264         }
 265
 266         ctx_alloc[new] = mm;
 267         ctx_avail--;
 268
 269         return new;
 270 }
 271
 272 /*
 273  * Dynamically select a `spare' PMEG and use it to map virtual `vaddr' in
 274  * `context'. Maintain internal PMEG management structures. This doesn't
 275  * actually map the physical address, but does clear the old mappings.
 276  */
 277 //todo: better allocation scheme? but is extra complexity worthwhile?
 278 //todo: only clear old entries if necessary? how to tell?
 279
 280 inline void mmu_emu_map_pmeg (int context, int vaddr)
 281 {
 282         static unsigned char curr_pmeg = 128;
 283         int i;
 284
 285         /* Round address to PMEG boundary. */
 286         vaddr &= ~SUN3_PMEG_MASK;
 287
 288         /* Find a spare one. */
 289         while (pmeg_alloc[curr_pmeg] == 2)
 290                 ++curr_pmeg;
 291
 292
 293 #ifdef DEBUG_MMU_EMU
 294 printk("mmu_emu_map_pmeg: pmeg %x to context %d vaddr %x\n",
 295        curr_pmeg, context, vaddr);
 296 #endif
 297
 298         /* Invalidate old mapping for the pmeg, if any */
 299         if (pmeg_alloc[curr_pmeg] == 1) {
 300                 sun3_put_context(pmeg_ctx[curr_pmeg]);
 301                 sun3_put_segmap (pmeg_vaddr[curr_pmeg], SUN3_INVALID_PMEG);
 302                 sun3_put_context(context);
 303         }
 304
 305         /* Update PMEG management structures. */
 306         // don't take pmeg's away from the kernel...
 307         if(vaddr >= PAGE_OFFSET) {
 308                 /* map kernel pmegs into all contexts */
 309                 unsigned char i;
 310
 311                 for(i = 0; i < CONTEXTS_NUM; i++) {
 312                         sun3_put_context(i);
 313                         sun3_put_segmap (vaddr, curr_pmeg);
 314                 }
 315                 sun3_put_context(context);
 316                 pmeg_alloc[curr_pmeg] = 2;
 317                 pmeg_ctx[curr_pmeg] = 0;
 318
 319         }
 320         else {
 321                 pmeg_alloc[curr_pmeg] = 1;
 322                 pmeg_ctx[curr_pmeg] = context;
 323                 sun3_put_segmap (vaddr, curr_pmeg);
 324
 325         }
 326         pmeg_vaddr[curr_pmeg] = vaddr;
 327
 328         /* Set hardware mapping and clear the old PTE entries. */
 329         for (i=0; i<SUN3_PMEG_SIZE; i+=SUN3_PTE_SIZE)
 330                 sun3_put_pte (vaddr + i, SUN3_PAGE_SYSTEM);
 331
 332         /* Consider a different one next time. */
 333         ++curr_pmeg;
 334 }
 335
 336 /*
 337  * Handle a pagefault at virtual address `vaddr'; check if there should be a
 338  * page there (specifically, whether the software pagetables indicate that
 339  * there is). This is necessary due to the limited size of the second-level
 340  * Sun3 hardware pagetables (256 groups of 16 pages). If there should be a
 341  * mapping present, we select a `spare' PMEG and use it to create a mapping.
 342  * `read_flag' is nonzero for a read fault; zero for a write. Returns nonzero
 343  * if we successfully handled the fault.
 344  */
 345 //todo: should we bump minor pagefault counter? if so, here or in caller?
 346 //todo: possibly inline this into bus_error030 in <asm/buserror.h> ?
 347
 348 // kernel_fault is set when a kernel page couldn't be demand mapped,
 349 // and forces another try using the kernel page table.  basically a
 350 // hack so that vmalloc would work correctly.
 351
 352 int mmu_emu_handle_fault (unsigned long vaddr, int read_flag, int kernel_fault)
 353 {
 354         unsigned long segment, offset;
 355         unsigned char context;
 356         pte_t *pte;
 357         pgd_t * crp;
 358
 359         if(current->mm == NULL) {
 360                 crp = swapper_pg_dir;
 361                 context = 0;
 362         } else {
 363                 context = current->mm->context;
 364                 if(kernel_fault)
 365                         crp = swapper_pg_dir;
 366                 else
 367                         crp = current->mm->pgd;
 368         }
 369
 370 #ifdef DEBUG_MMU_EMU
 371         printk ("mmu_emu_handle_fault: vaddr=%lx type=%s crp=%p\n",
 372                 vaddr, read_flag ? "read" : "write", crp);
 373 #endif
 374
 375         segment = (vaddr >> SUN3_PMEG_SIZE_BITS) & 0x7FF;
 376         offset  = (vaddr >> SUN3_PTE_SIZE_BITS) & 0xF;
 377
 378 #ifdef DEBUG_MMU_EMU
 379         printk ("mmu_emu_handle_fault: segment=%lx offset=%lx\n", segment, offset);
 380 #endif
 381
 382         pte = (pte_t *) pgd_val (*(crp + segment));
 383
 384 //todo: next line should check for valid pmd properly.
 385         if (!pte) {
 386 //                printk ("mmu_emu_handle_fault: invalid pmd\n");
 387                 return 0;
 388         }
 389
 390         pte = (pte_t *) __va ((unsigned long)(pte + offset));
 391
 392         /* Make sure this is a valid page */
 393         if (!(pte_val (*pte) & SUN3_PAGE_VALID))
 394                 return 0;
 395
 396         /* Make sure there's a pmeg allocated for the page */
 397         if (sun3_get_segmap (vaddr&~SUN3_PMEG_MASK) == SUN3_INVALID_PMEG)
 398                 mmu_emu_map_pmeg (context, vaddr);
 399
 400         /* Write the pte value to hardware MMU */
 401         sun3_put_pte (vaddr&PAGE_MASK, pte_val (*pte));
 402
 403         /* Update software copy of the pte value */
 404 // I'm not sure this is necessary. If this is required, we ought to simply
 405 // copy this out when we reuse the PMEG or at some other convenient time.
 406 // Doing it here is fairly meaningless, anyway, as we only know about the
 407 // first access to a given page. --m
 408         if (!read_flag) {
 409                 if (pte_val (*pte) & SUN3_PAGE_WRITEABLE)
 410                         pte_val (*pte) |= (SUN3_PAGE_ACCESSED
 411                                            | SUN3_PAGE_MODIFIED);
 412                 else
 413                         return 0;       /* Write-protect error. */
 414         } else
 415                 pte_val (*pte) |= SUN3_PAGE_ACCESSED;
 416
 417 #ifdef DEBUG_MMU_EMU
 418         printk ("seg:%d crp:%p ->", get_fs().seg, crp);
 419         print_pte_vaddr (vaddr);
 420         printk ("\n");
 421 #endif
 422
 423         return 1;
 424 }