arch/mips/mm/tlbex-mips32.S

   1 /*
   2  * TLB exception handling code for MIPS32 CPUs.
   3  *
   4  * Copyright (C) 1994, 1995, 1996 by Ralf Baechle and Andreas Busse
   5  *
   6  * Multi-cpu abstraction and reworking:
   7  * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
   8  *
   9  * Carsten Langgaard, carstenl@mips.com
  10  * Copyright (C) 2000 MIPS Technologies, Inc.  All rights reserved.
  11  *
  12  * Pete Popov, ppopov@pacbell.net
  13  * Added 36 bit phys address support.
  14  * Copyright (C) 2002 MontaVista Software, Inc.
  15  */
  16 #include <linux/init.h>
  17
  18 #include <asm/asm.h>
  19 #include <asm/current.h>
  20 #include <asm/offset.h>
  21 #include <asm/cachectl.h>
  22 #include <asm/fpregdef.h>
  23 #include <asm/mipsregs.h>
  24 #include <asm/page.h>
  25 #include <asm/pgtable.h>
  26 #include <asm/processor.h>
  27 #include <asm/regdef.h>
  28 #include <asm/stackframe.h>
  29
  30 #define TLB_OPTIMIZE /* If you are paranoid, disable this. */
  31
  32 #ifdef CONFIG_64BIT_PHYS_ADDR
  33
  34 /* We really only support 36 bit physical addresses on MIPS32 */
  35 #define PTE_L           lw
  36 #define PTE_S           sw
  37 #define PTE_SRL         srl
  38 #define P_MTC0          mtc0
  39 #define PTE_HALF        4 /* pte_high contains pre-shifted, ready to go entry */
  40 #define PTE_SIZE        8
  41 #define PTEP_INDX_MSK   0xff0
  42 #define PTE_INDX_MSK    0xff8
  43 #define PTE_INDX_SHIFT 9
  44 #define CONVERT_PTE(pte)
  45 #define PTE_MAKEWRITE_HIGH(pte, ptr) \
  46         lw      pte, 4(ptr); \
  47         ori     pte, (_PAGE_VALID | _PAGE_DIRTY); \
  48         sw      pte, 4(ptr); \
  49         lw      pte, 0(ptr);
  50
  51 #define PTE_MAKEVALID_HIGH(pte, ptr) \
  52         lw      pte, 4(ptr); \
  53         ori     pte, pte, _PAGE_VALID; \
  54         sw      pte, 4(ptr); \
  55         lw      pte, 0(ptr);
  56
  57 #else
  58
  59 #define PTE_L           lw
  60 #define PTE_S           sw
  61 #define PTE_SRL         srl
  62 #define P_MTC0          mtc0
  63 #define PTE_HALF        0
  64 #define PTE_SIZE        4
  65 #define PTEP_INDX_MSK   0xff8
  66 #define PTE_INDX_MSK    0xffc
  67 #define PTE_INDX_SHIFT  10
  68 #define CONVERT_PTE(pte) srl pte, pte, 6
  69 #define PTE_MAKEWRITE_HIGH(pte, ptr)
  70 #define PTE_MAKEVALID_HIGH(pte, ptr)
  71
  72 #endif  /* CONFIG_64BIT_PHYS_ADDR */
  73
  74         __INIT
  75
  76 #ifdef CONFIG_64BIT_PHYS_ADDR
  77 #define GET_PTE_OFF(reg)
  78 #else
  79 #define GET_PTE_OFF(reg)        srl     reg, reg, 1
  80 #endif
  81
  82 /*
  83  * These handlers much be written in a relocatable manner
  84  * because based upon the cpu type an arbitrary one of the
  85  * following pieces of code will be copied to the KSEG0
  86  * vector location.
  87  */
  88         /* TLB refill, EXL == 0, MIPS32 version */
  89         .set    noreorder
  90         .set    noat
  91         LEAF(except_vec0_r4000)
  92         .set    mips3
  93 #ifdef CONFIG_SMP
  94         mfc0    k1, CP0_CONTEXT
  95         la      k0, pgd_current
  96         srl     k1, 23
  97         sll     k1, 2                           # log2(sizeof(pgd_t)
  98         addu    k1, k0, k1
  99         lw      k1, (k1)
 100 #else
 101         lw      k1, pgd_current                 # get pgd pointer
 102 #endif
 103         nop
 104         mfc0    k0, CP0_BADVADDR                # Get faulting address
 105         srl     k0, k0, _PGDIR_SHIFT            # get pgd only bits
 106
 107         sll     k0, k0, 2
 108         addu    k1, k1, k0                      # add in pgd offset
 109         mfc0    k0, CP0_CONTEXT                 # get context reg
 110         lw      k1, (k1)
 111         GET_PTE_OFF(k0)                         # get pte offset
 112         and     k0, k0, PTEP_INDX_MSK
 113         addu    k1, k1, k0                      # add in offset
 114
 115         PTE_L   k0, PTE_HALF(k1)                # get even pte
 116         CONVERT_PTE(k0)
 117         P_MTC0  k0, CP0_ENTRYLO0                # load it
 118         PTE_L   k1, (PTE_HALF+PTE_SIZE)(k1)     # get odd pte
 119         CONVERT_PTE(k1)
 120         P_MTC0  k1, CP0_ENTRYLO1                # load it
 121         b       1f
 122         tlbwr                                   # write random tlb entry
 123 1:
 124         nop
 125         eret                                    # return from trap
 126         END(except_vec0_r4000)
 127
 128 /*
 129  * These are here to avoid putting ifdefs in tlb-r4k.c
 130  */
 131         .set    noreorder
 132         .set    noat
 133         LEAF(except_vec0_nevada)
 134         .set    mips3
 135         PANIC("Nevada Exception Vec 0 called")
 136         END(except_vec0_nevada)
 137
 138         .set    noreorder
 139         .set    noat
 140         LEAF(except_vec0_r4600)
 141         .set    mips3
 142         PANIC("R4600 Exception Vec 0 called")
 143         END(except_vec0_r4600)
 144
 145         __FINIT
 146
 147 /*
 148  * ABUSE of CPP macros 101.
 149  *
 150  * After this macro runs, the pte faulted on is
 151  * in register PTE, a ptr into the table in which
 152  * the pte belongs is in PTR.
 153  */
 154
 155 #ifdef CONFIG_SMP
 156 #define GET_PGD(scratch, ptr)        \
 157         mfc0    ptr, CP0_CONTEXT;    \
 158         la      scratch, pgd_current;\
 159         srl     ptr, 23;             \
 160         sll     ptr, 2;              \
 161         addu    ptr, scratch, ptr;   \
 162         lw      ptr, (ptr);
 163 #else
 164 #define GET_PGD(scratch, ptr)    \
 165         lw      ptr, pgd_current;
 166 #endif
 167
 168 #define LOAD_PTE(pte, ptr) \
 169         GET_PGD(pte, ptr)          \
 170         mfc0    pte, CP0_BADVADDR; \
 171         srl     pte, pte, _PGDIR_SHIFT; \
 172         sll     pte, pte, 2; \
 173         addu    ptr, ptr, pte; \
 174         mfc0    pte, CP0_BADVADDR; \
 175         lw      ptr, (ptr); \
 176         srl     pte, pte, PTE_INDX_SHIFT; \
 177         and     pte, pte, PTE_INDX_MSK; \
 178         addu    ptr, ptr, pte; \
 179         PTE_L   pte, (ptr);
 180
 181         /* This places the even/odd pte pair in the page
 182          * table at PTR into ENTRYLO0 and ENTRYLO1 using
 183          * TMP as a scratch register.
 184          */
 185 #define PTE_RELOAD(ptr, tmp) \
 186         ori     ptr, ptr, PTE_SIZE; \
 187         xori    ptr, ptr, PTE_SIZE; \
 188         PTE_L   tmp, (PTE_HALF+PTE_SIZE)(ptr); \
 189         CONVERT_PTE(tmp); \
 190         P_MTC0  tmp, CP0_ENTRYLO1; \
 191         PTE_L   ptr, PTE_HALF(ptr); \
 192         CONVERT_PTE(ptr); \
 193         P_MTC0  ptr, CP0_ENTRYLO0;
 194
 195 #define DO_FAULT(write) \
 196         .set    noat; \
 197         SAVE_ALL; \
 198         mfc0    a2, CP0_BADVADDR; \
 199         STI; \
 200         .set    at; \
 201         move    a0, sp; \
 202         jal     do_page_fault; \
 203          li     a1, write; \
 204         j       ret_from_exception; \
 205          nop; \
 206         .set    noat;
 207
 208         /* Check is PTE is present, if not then jump to LABEL.
 209          * PTR points to the page table where this PTE is located,
 210          * when the macro is done executing PTE will be restored
 211          * with it's original value.
 212          */
 213 #define PTE_PRESENT(pte, ptr, label) \
 214         andi    pte, pte, (_PAGE_PRESENT | _PAGE_READ); \
 215         xori    pte, pte, (_PAGE_PRESENT | _PAGE_READ); \
 216         bnez    pte, label; \
 217         PTE_L   pte, (ptr);
 218
 219         /* Make PTE valid, store result in PTR. */
 220 #define PTE_MAKEVALID(pte, ptr) \
 221         ori     pte, pte, (_PAGE_VALID | _PAGE_ACCESSED); \
 222         PTE_S   pte, (ptr);
 223
 224         /* Check if PTE can be written to, if not branch to LABEL.
 225          * Regardless restore PTE with value from PTR when done.
 226          */
 227 #define PTE_WRITABLE(pte, ptr, label) \
 228         andi    pte, pte, (_PAGE_PRESENT | _PAGE_WRITE); \
 229         xori    pte, pte, (_PAGE_PRESENT | _PAGE_WRITE); \
 230         bnez    pte, label; \
 231         PTE_L   pte, (ptr);
 232
 233         /* Make PTE writable, update software status bits as well,
 234          * then store at PTR.
 235          */
 236 #define PTE_MAKEWRITE(pte, ptr) \
 237         ori     pte, pte, (_PAGE_ACCESSED | _PAGE_MODIFIED | \
 238                            _PAGE_VALID | _PAGE_DIRTY); \
 239         PTE_S   pte, (ptr);
 240
 241         .set    noreorder
 242
 243 #define R5K_HAZARD nop
 244
 245         .align  5
 246         NESTED(handle_tlbl, PT_SIZE, sp)
 247         .set    noat
 248 invalid_tlbl:
 249 #ifdef TLB_OPTIMIZE
 250         /* Test present bit in entry. */
 251         LOAD_PTE(k0, k1)
 252         R5K_HAZARD
 253         tlbp
 254         PTE_PRESENT(k0, k1, nopage_tlbl)
 255         PTE_MAKEVALID_HIGH(k0, k1)
 256         PTE_MAKEVALID(k0, k1)
 257         PTE_RELOAD(k1, k0)
 258         nop
 259         b       1f
 260          tlbwi
 261 1:
 262         nop
 263         .set    mips3
 264         eret
 265         .set    mips0
 266 #endif
 267
 268 nopage_tlbl:
 269         DO_FAULT(0)
 270         END(handle_tlbl)
 271
 272         .align  5
 273         NESTED(handle_tlbs, PT_SIZE, sp)
 274         .set    noat
 275 #ifdef TLB_OPTIMIZE
 276         .set    mips3
 277         li      k0,0
 278         LOAD_PTE(k0, k1)
 279         R5K_HAZARD
 280         tlbp                            # find faulting entry
 281         PTE_WRITABLE(k0, k1, nopage_tlbs)
 282         PTE_MAKEWRITE(k0, k1)
 283         PTE_MAKEWRITE_HIGH(k0, k1)
 284         PTE_RELOAD(k1, k0)
 285         nop
 286         b       1f
 287          tlbwi
 288 1:
 289         nop
 290         .set    mips3
 291         eret
 292         .set    mips0
 293 #endif
 294
 295 nopage_tlbs:
 296         DO_FAULT(1)
 297         END(handle_tlbs)
 298
 299         .align  5
 300         NESTED(handle_mod, PT_SIZE, sp)
 301         .set    noat
 302 #ifdef TLB_OPTIMIZE
 303         .set    mips3
 304         LOAD_PTE(k0, k1)
 305         R5K_HAZARD
 306         tlbp                                    # find faulting entry
 307         andi    k0, k0, _PAGE_WRITE
 308         beqz    k0, nowrite_mod
 309         PTE_L   k0, (k1)
 310
 311         /* Present and writable bits set, set accessed and dirty bits. */
 312         PTE_MAKEWRITE(k0, k1)
 313         PTE_MAKEWRITE_HIGH(k0, k1)
 314         /* Now reload the entry into the tlb. */
 315         PTE_RELOAD(k1, k0)
 316         nop
 317         b       1f
 318          tlbwi
 319 1:
 320         nop
 321         .set    mips3
 322         eret
 323         .set    mips0
 324 #endif
 325
 326 nowrite_mod:
 327         DO_FAULT(1)
 328         END(handle_mod)
 329