arch/mips/mm/tlbex32-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 #include <asm/asm.h>
  18 #include <asm/cachectl.h>
  19 #include <asm/fpregdef.h>
  20 #include <asm/mipsregs.h>
  21 #include <asm/page.h>
  22 #include <asm/pgtable-bits.h>
  23 #include <asm/regdef.h>
  24 #include <asm/stackframe.h>
  25
  26 #define TLB_OPTIMIZE /* If you are paranoid, disable this. */
  27
  28 #ifdef CONFIG_64BIT_PHYS_ADDR
  29
  30 /* We really only support 36 bit physical addresses on MIPS32 */
  31 #define PTE_L           lw
  32 #define PTE_S           sw
  33 #define PTE_SRL         srl
  34 #define P_MTC0          mtc0
  35 #define PTE_HALF        4 /* pte_high contains pre-shifted, ready to go entry */
  36 #define PTE_SIZE        8
  37 #define PTEP_INDX_MSK   0xff0
  38 #define PTE_INDX_MSK    0xff8
  39 #define PTE_INDX_SHIFT 9
  40 #define CONVERT_PTE(pte)
  41 #define PTE_MAKEWRITE_HIGH(pte, ptr) \
  42         lw      pte, PTE_HALF(ptr); \
  43         ori     pte, (_PAGE_VALID | _PAGE_DIRTY); \
  44         sw      pte, PTE_HALF(ptr); \
  45         lw      pte, 0(ptr);
  46
  47 #define PTE_MAKEVALID_HIGH(pte, ptr) \
  48         lw      pte, PTE_HALF(ptr); \
  49         ori     pte, pte, _PAGE_VALID; \
  50         sw      pte, PTE_HALF(ptr); \
  51         lw      pte, 0(ptr);
  52
  53 #else
  54
  55 #define PTE_L           lw
  56 #define PTE_S           sw
  57 #define PTE_SRL         srl
  58 #define P_MTC0          mtc0
  59 #define PTE_HALF        0
  60 #define PTE_SIZE        4
  61 #define PTEP_INDX_MSK   0xff8
  62 #define PTE_INDX_MSK    0xffc
  63 #define PTE_INDX_SHIFT  10
  64 #define CONVERT_PTE(pte) srl pte, pte, 6
  65 #define PTE_MAKEWRITE_HIGH(pte, ptr)
  66 #define PTE_MAKEVALID_HIGH(pte, ptr)
  67
  68 #endif  /* CONFIG_64BIT_PHYS_ADDR */
  69
  70 #ifdef CONFIG_64BIT_PHYS_ADDR
  71 #define GET_PTE_OFF(reg)
  72 #else
  73 #define GET_PTE_OFF(reg)        srl     reg, reg, 1
  74 #endif
  75
  76 /*
  77  * ABUSE of CPP macros 101.
  78  *
  79  * After this macro runs, the pte faulted on is
  80  * in register PTE, a ptr into the table in which
  81  * the pte belongs is in PTR.
  82  */
  83
  84 #ifdef CONFIG_SMP
  85 #define GET_PGD(scratch, ptr)        \
  86         mfc0    ptr, CP0_CONTEXT;    \
  87         la      scratch, pgd_current;\
  88         srl     ptr, 23;             \
  89         sll     ptr, 2;              \
  90         addu    ptr, scratch, ptr;   \
  91         lw      ptr, (ptr);
  92 #else
  93 #define GET_PGD(scratch, ptr)    \
  94         lw      ptr, pgd_current;
  95 #endif
  96
  97 #define LOAD_PTE(pte, ptr) \
  98         GET_PGD(pte, ptr)          \
  99         mfc0    pte, CP0_BADVADDR; \
 100         srl     pte, pte, _PGDIR_SHIFT; \
 101         sll     pte, pte, 2; \
 102         addu    ptr, ptr, pte; \
 103         mfc0    pte, CP0_BADVADDR; \
 104         lw      ptr, (ptr); \
 105         srl     pte, pte, PTE_INDX_SHIFT; \
 106         and     pte, pte, PTE_INDX_MSK; \
 107         addu    ptr, ptr, pte; \
 108         PTE_L   pte, (ptr);
 109
 110         /* This places the even/odd pte pair in the page
 111          * table at PTR into ENTRYLO0 and ENTRYLO1 using
 112          * TMP as a scratch register.
 113          */
 114 #define PTE_RELOAD(ptr, tmp) \
 115         ori     ptr, ptr, PTE_SIZE; \
 116         xori    ptr, ptr, PTE_SIZE; \
 117         PTE_L   tmp, (PTE_HALF+PTE_SIZE)(ptr); \
 118         CONVERT_PTE(tmp); \
 119         P_MTC0  tmp, CP0_ENTRYLO1; \
 120         PTE_L   ptr, PTE_HALF(ptr); \
 121         CONVERT_PTE(ptr); \
 122         P_MTC0  ptr, CP0_ENTRYLO0;
 123
 124 #define DO_FAULT(write) \
 125         .set    noat; \
 126         SAVE_ALL; \
 127         mfc0    a2, CP0_BADVADDR; \
 128         KMODE; \
 129         .set    at; \
 130         move    a0, sp; \
 131         jal     do_page_fault; \
 132          li     a1, write; \
 133         j       ret_from_exception; \
 134          nop; \
 135         .set    noat;
 136
 137         /* Check is PTE is present, if not then jump to LABEL.
 138          * PTR points to the page table where this PTE is located,
 139          * when the macro is done executing PTE will be restored
 140          * with it's original value.
 141          */
 142 #define PTE_PRESENT(pte, ptr, label) \
 143         andi    pte, pte, (_PAGE_PRESENT | _PAGE_READ); \
 144         xori    pte, pte, (_PAGE_PRESENT | _PAGE_READ); \
 145         bnez    pte, label; \
 146         PTE_L   pte, (ptr);
 147
 148         /* Make PTE valid, store result in PTR. */
 149 #define PTE_MAKEVALID(pte, ptr) \
 150         ori     pte, pte, (_PAGE_VALID | _PAGE_ACCESSED); \
 151         PTE_S   pte, (ptr);
 152
 153         /* Check if PTE can be written to, if not branch to LABEL.
 154          * Regardless restore PTE with value from PTR when done.
 155          */
 156 #define PTE_WRITABLE(pte, ptr, label) \
 157         andi    pte, pte, (_PAGE_PRESENT | _PAGE_WRITE); \
 158         xori    pte, pte, (_PAGE_PRESENT | _PAGE_WRITE); \
 159         bnez    pte, label; \
 160         PTE_L   pte, (ptr);
 161
 162         /* Make PTE writable, update software status bits as well,
 163          * then store at PTR.
 164          */
 165 #define PTE_MAKEWRITE(pte, ptr) \
 166         ori     pte, pte, (_PAGE_ACCESSED | _PAGE_MODIFIED | \
 167                            _PAGE_VALID | _PAGE_DIRTY); \
 168         PTE_S   pte, (ptr);
 169
 170         .set    noreorder
 171
 172         .align  5
 173         NESTED(handle_tlbl, PT_SIZE, sp)
 174         .set    noat
 175 invalid_tlbl:
 176 #ifdef TLB_OPTIMIZE
 177         /* Test present bit in entry. */
 178         LOAD_PTE(k0, k1)
 179         tlbp
 180         PTE_PRESENT(k0, k1, nopage_tlbl)
 181         PTE_MAKEVALID_HIGH(k0, k1)
 182         PTE_MAKEVALID(k0, k1)
 183         PTE_RELOAD(k1, k0)
 184         nop
 185         b       1f
 186          tlbwi
 187 1:
 188         nop
 189         .set    mips3
 190         eret
 191         .set    mips0
 192 #endif
 193
 194 nopage_tlbl:
 195         DO_FAULT(0)
 196         END(handle_tlbl)
 197
 198         .align  5
 199         NESTED(handle_tlbs, PT_SIZE, sp)
 200         .set    noat
 201 #ifdef TLB_OPTIMIZE
 202         .set    mips3
 203         li      k0,0
 204         LOAD_PTE(k0, k1)
 205         tlbp                            # find faulting entry
 206         PTE_WRITABLE(k0, k1, nopage_tlbs)
 207         PTE_MAKEWRITE(k0, k1)
 208         PTE_MAKEWRITE_HIGH(k0, k1)
 209         PTE_RELOAD(k1, k0)
 210         nop
 211         b       1f
 212          tlbwi
 213 1:
 214         nop
 215         .set    mips3
 216         eret
 217         .set    mips0
 218 #endif
 219
 220 nopage_tlbs:
 221         DO_FAULT(1)
 222         END(handle_tlbs)
 223
 224         .align  5
 225         NESTED(handle_mod, PT_SIZE, sp)
 226         .set    noat
 227 #ifdef TLB_OPTIMIZE
 228         .set    mips3
 229         LOAD_PTE(k0, k1)
 230         tlbp                                    # find faulting entry
 231         andi    k0, k0, _PAGE_WRITE
 232         beqz    k0, nowrite_mod
 233         PTE_L   k0, (k1)
 234
 235         /* Present and writable bits set, set accessed and dirty bits. */
 236         PTE_MAKEWRITE(k0, k1)
 237         PTE_MAKEWRITE_HIGH(k0, k1)
 238         /* Now reload the entry into the tlb. */
 239         PTE_RELOAD(k1, k0)
 240         nop
 241         b       1f
 242          tlbwi
 243 1:
 244         nop
 245         .set    mips3
 246         eret
 247         .set    mips0
 248 #endif
 249
 250 nowrite_mod:
 251         DO_FAULT(1)
 252         END(handle_mod)
 253