arch/mips/mm/tlbex32-r4k.S

   1 /*
   2  * TLB exception handling code for r4k.
   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 #include <linux/init.h>
  13 #include <linux/config.h>
  14
  15 #include <asm/asm.h>
  16 #include <asm/offset.h>
  17 #include <asm/cachectl.h>
  18 #include <asm/fpregdef.h>
  19 #include <asm/mipsregs.h>
  20 #include <asm/page.h>
  21 #include <asm/pgtable-bits.h>
  22 #include <asm/regdef.h>
  23 #include <asm/stackframe.h>
  24 #include <asm/war.h>
  25
  26 #define TLB_OPTIMIZE /* If you are paranoid, disable this. */
  27
  28 #ifdef CONFIG_64BIT_PHYS_ADDR
  29 #define PTE_L           ld
  30 #define PTE_S           sd
  31 #define PTE_SRL         dsrl
  32 #define P_MTC0          dmtc0
  33 #define PTE_SIZE        8
  34 #define PTEP_INDX_MSK   0xff0
  35 #define PTE_INDX_MSK    0xff8
  36 #define PTE_INDX_SHIFT  9
  37 #else
  38 #define PTE_L           lw
  39 #define PTE_S           sw
  40 #define PTE_SRL         srl
  41 #define P_MTC0          mtc0
  42 #define PTE_SIZE        4
  43 #define PTEP_INDX_MSK   0xff8
  44 #define PTE_INDX_MSK    0xffc
  45 #define PTE_INDX_SHIFT  10
  46 #endif
  47
  48 /*
  49  * ABUSE of CPP macros 101.
  50  *
  51  * After this macro runs, the pte faulted on is
  52  * in register PTE, a ptr into the table in which
  53  * the pte belongs is in PTR.
  54  */
  55
  56 #ifdef CONFIG_SMP
  57 #define GET_PGD(scratch, ptr)        \
  58         mfc0    ptr, CP0_CONTEXT;    \
  59         la      scratch, pgd_current;\
  60         srl     ptr, 23;             \
  61         sll     ptr, 2;              \
  62         addu    ptr, scratch, ptr;   \
  63         lw      ptr, (ptr);
  64 #else
  65 #define GET_PGD(scratch, ptr)    \
  66         lw      ptr, pgd_current;
  67 #endif
  68
  69 #define LOAD_PTE(pte, ptr) \
  70         GET_PGD(pte, ptr)          \
  71         mfc0    pte, CP0_BADVADDR; \
  72         srl     pte, pte, _PGDIR_SHIFT; \
  73         sll     pte, pte, 2; \
  74         addu    ptr, ptr, pte; \
  75         mfc0    pte, CP0_BADVADDR; \
  76         lw      ptr, (ptr); \
  77         srl     pte, pte, PTE_INDX_SHIFT; \
  78         and     pte, pte, PTE_INDX_MSK; \
  79         addu    ptr, ptr, pte; \
  80         PTE_L   pte, (ptr);
  81
  82         /* This places the even/odd pte pair in the page
  83          * table at PTR into ENTRYLO0 and ENTRYLO1 using
  84          * TMP as a scratch register.
  85          */
  86 #define PTE_RELOAD(ptr, tmp) \
  87         ori     ptr, ptr, PTE_SIZE; \
  88         xori    ptr, ptr, PTE_SIZE; \
  89         PTE_L   tmp, PTE_SIZE(ptr); \
  90         PTE_L   ptr, 0(ptr); \
  91         PTE_SRL tmp, tmp, 6; \
  92         P_MTC0  tmp, CP0_ENTRYLO1; \
  93         PTE_SRL ptr, ptr, 6; \
  94         P_MTC0  ptr, CP0_ENTRYLO0;
  95
  96 #define DO_FAULT(write) \
  97         .set    noat; \
  98         SAVE_ALL; \
  99         mfc0    a2, CP0_BADVADDR; \
 100         KMODE; \
 101         .set    at; \
 102         move    a0, sp; \
 103         jal     do_page_fault; \
 104          li     a1, write; \
 105         j       ret_from_exception; \
 106          nop; \
 107         .set    noat;
 108
 109         /* Check is PTE is present, if not then jump to LABEL.
 110          * PTR points to the page table where this PTE is located,
 111          * when the macro is done executing PTE will be restored
 112          * with it's original value.
 113          */
 114 #define PTE_PRESENT(pte, ptr, label) \
 115         andi    pte, pte, (_PAGE_PRESENT | _PAGE_READ); \
 116         xori    pte, pte, (_PAGE_PRESENT | _PAGE_READ); \
 117         bnez    pte, label; \
 118          PTE_L  pte, (ptr);
 119
 120         /* Make PTE valid, store result in PTR. */
 121 #define PTE_MAKEVALID(pte, ptr) \
 122         ori     pte, pte, (_PAGE_VALID | _PAGE_ACCESSED); \
 123         PTE_S   pte, (ptr);
 124
 125         /* Check if PTE can be written to, if not branch to LABEL.
 126          * Regardless restore PTE with value from PTR when done.
 127          */
 128 #define PTE_WRITABLE(pte, ptr, label) \
 129         andi    pte, pte, (_PAGE_PRESENT | _PAGE_WRITE); \
 130         xori    pte, pte, (_PAGE_PRESENT | _PAGE_WRITE); \
 131         bnez    pte, label; \
 132          PTE_L  pte, (ptr);
 133
 134         /* Make PTE writable, update software status bits as well,
 135          * then store at PTR.
 136          */
 137 #define PTE_MAKEWRITE(pte, ptr) \
 138         ori     pte, pte, (_PAGE_ACCESSED | _PAGE_MODIFIED | \
 139                            _PAGE_VALID | _PAGE_DIRTY); \
 140         PTE_S   pte, (ptr);
 141
 142         __INIT
 143
 144 #ifdef CONFIG_64BIT_PHYS_ADDR
 145 #define GET_PTE_OFF(reg)
 146 #elif CONFIG_CPU_VR41XX
 147 #define GET_PTE_OFF(reg)        srl     reg, reg, 3
 148 #else
 149 #define GET_PTE_OFF(reg)        srl     reg, reg, 1
 150 #endif
 151
 152 /*
 153  * These handlers much be written in a relocatable manner
 154  * because based upon the cpu type an arbitrary one of the
 155  * following pieces of code will be copied to the KSEG0
 156  * vector location.
 157  */
 158         /* TLB refill, EXL == 0, R4xx0, non-R4600 version */
 159         .set    noreorder
 160         .set    noat
 161         LEAF(except_vec0_r4000)
 162         .set    mips3
 163         GET_PGD(k0, k1)                         # get pgd pointer
 164         mfc0    k0, CP0_BADVADDR                # Get faulting address
 165         srl     k0, k0, _PGDIR_SHIFT            # get pgd only bits
 166
 167         sll     k0, k0, 2
 168         addu    k1, k1, k0                      # add in pgd offset
 169         mfc0    k0, CP0_CONTEXT                 # get context reg
 170         lw      k1, (k1)
 171         GET_PTE_OFF(k0)                         # get pte offset
 172         and     k0, k0, PTEP_INDX_MSK
 173         addu    k1, k1, k0                      # add in offset
 174         PTE_L   k0, 0(k1)                       # get even pte
 175         PTE_L   k1, PTE_SIZE(k1)                # get odd pte
 176         PTE_SRL k0, k0, 6                       # convert to entrylo0
 177         P_MTC0  k0, CP0_ENTRYLO0                # load it
 178         PTE_SRL k1, k1, 6                       # convert to entrylo1
 179         P_MTC0  k1, CP0_ENTRYLO1                # load it
 180         mtc0_tlbw_hazard
 181         tlbwr                                   # write random tlb entry
 182         tlbw_eret_hazard
 183         eret                                    # return from trap
 184         END(except_vec0_r4000)
 185
 186         /* TLB refill, EXL == 0, R4600 version */
 187         LEAF(except_vec0_r4600)
 188         .set    mips3
 189         GET_PGD(k0, k1)                         # get pgd pointer
 190         mfc0    k0, CP0_BADVADDR
 191         srl     k0, k0, _PGDIR_SHIFT
 192         sll     k0, k0, 2                       # log2(sizeof(pgd_t)
 193         addu    k1, k1, k0
 194         mfc0    k0, CP0_CONTEXT
 195         lw      k1, (k1)
 196         GET_PTE_OFF(k0)                         # get pte offset
 197         and     k0, k0, PTEP_INDX_MSK
 198         addu    k1, k1, k0
 199         PTE_L   k0, 0(k1)
 200         PTE_L   k1, PTE_SIZE(k1)
 201         PTE_SRL k0, k0, 6
 202         P_MTC0  k0, CP0_ENTRYLO0
 203         PTE_SRL k1, k1, 6
 204         P_MTC0  k1, CP0_ENTRYLO1
 205         nop
 206         tlbwr
 207         nop
 208         eret
 209         END(except_vec0_r4600)
 210
 211         /* TLB refill, EXL == 0, R52x0 "Nevada" version */
 212         /*
 213          * This version has a bug workaround for the Nevada.  It seems
 214          * as if under certain circumstances the move from cp0_context
 215          * might produce a bogus result when the mfc0 instruction and
 216          * it's consumer are in a different cacheline or a load instruction,
 217          * probably any memory reference, is between them.  This is
 218          * potencially slower than the R4000 version, so we use this
 219          * special version.
 220          */
 221         .set    noreorder
 222         .set    noat
 223         LEAF(except_vec0_nevada)
 224         .set    mips3
 225         mfc0    k0, CP0_BADVADDR                # Get faulting address
 226         srl     k0, k0, _PGDIR_SHIFT            # get pgd only bits
 227         lw      k1, pgd_current                 # get pgd pointer
 228         sll     k0, k0, 2                       # log2(sizeof(pgd_t)
 229         addu    k1, k1, k0                      # add in pgd offset
 230         lw      k1, (k1)
 231         mfc0    k0, CP0_CONTEXT                 # get context reg
 232         GET_PTE_OFF(k0)                         # get pte offset
 233         and     k0, k0, PTEP_INDX_MSK
 234         addu    k1, k1, k0                      # add in offset
 235         PTE_L   k0, 0(k1)                       # get even pte
 236         PTE_L   k1, PTE_SIZE(k1)                # get odd pte
 237         PTE_SRL k0, k0, 6                       # convert to entrylo0
 238         P_MTC0  k0, CP0_ENTRYLO0                # load it
 239         PTE_SRL k1, k1, 6                       # convert to entrylo1
 240         P_MTC0  k1, CP0_ENTRYLO1                # load it
 241         nop                                     # QED specified nops
 242         nop
 243         tlbwr                                   # write random tlb entry
 244         nop                                     # traditional nop
 245         eret                                    # return from trap
 246         END(except_vec0_nevada)
 247
 248         /* TLB refill, EXL == 0, SB1 with M3 errata handling version */
 249         LEAF(except_vec0_sb1)
 250 #if BCM1250_M3_WAR
 251         mfc0    k0, CP0_BADVADDR
 252         mfc0    k1, CP0_ENTRYHI
 253         xor     k0, k1
 254         srl     k0, k0, PAGE_SHIFT+1
 255         bnez    k0, 1f
 256 #endif
 257         GET_PGD(k0, k1)                         # get pgd pointer
 258         mfc0    k0, CP0_BADVADDR                # Get faulting address
 259         srl     k0, k0, _PGDIR_SHIFT            # get pgd only bits
 260         sll     k0, k0, 2
 261         addu    k1, k1, k0                      # add in pgd offset
 262         mfc0    k0, CP0_CONTEXT                 # get context reg
 263         lw      k1, (k1)
 264         GET_PTE_OFF(k0)                         # get pte offset
 265         and     k0, k0, PTEP_INDX_MSK
 266         addu    k1, k1, k0                      # add in offset
 267         PTE_L   k0, 0(k1)                       # get even pte
 268         PTE_L   k1, PTE_SIZE(k1)                # get odd pte
 269         PTE_SRL k0, k0, 6                       # convert to entrylo0
 270         P_MTC0  k0, CP0_ENTRYLO0                # load it
 271         PTE_SRL k1, k1, 6                       # convert to entrylo1
 272         P_MTC0  k1, CP0_ENTRYLO1                # load it
 273         tlbwr                                   # write random tlb entry
 274 1:      eret                                    # return from trap
 275         END(except_vec0_sb1)
 276
 277         /* TLB refill, EXL == 0, R4[40]00/R5000 badvaddr hwbug version */
 278         LEAF(except_vec0_r45k_bvahwbug)
 279         .set    mips3
 280         GET_PGD(k0, k1)                         # get pgd pointer
 281         mfc0    k0, CP0_BADVADDR
 282         srl     k0, k0, _PGDIR_SHIFT
 283         sll     k0, k0, 2                       # log2(sizeof(pgd_t)
 284         addu    k1, k1, k0
 285         mfc0    k0, CP0_CONTEXT
 286         lw      k1, (k1)
 287 #ifndef CONFIG_64BIT_PHYS_ADDR
 288         srl     k0, k0, 1
 289 #endif
 290         and     k0, k0, PTEP_INDX_MSK
 291         addu    k1, k1, k0
 292         PTE_L   k0, 0(k1)
 293         PTE_L   k1, PTE_SIZE(k1)
 294         nop                             /* XXX */
 295         tlbp
 296         PTE_SRL k0, k0, 6
 297         P_MTC0  k0, CP0_ENTRYLO0
 298         PTE_SRL k1, k1, 6
 299         mfc0    k0, CP0_INDEX
 300         P_MTC0  k1, CP0_ENTRYLO1
 301         bltzl   k0, 1f
 302         tlbwr
 303 1:
 304         nop
 305         eret
 306         END(except_vec0_r45k_bvahwbug)
 307
 308 #ifdef CONFIG_SMP
 309         /* TLB refill, EXL == 0, R4000 MP badvaddr hwbug version */
 310         LEAF(except_vec0_r4k_mphwbug)
 311         .set    mips3
 312         GET_PGD(k0, k1)                         # get pgd pointer
 313         mfc0    k0, CP0_BADVADDR
 314         srl     k0, k0, _PGDIR_SHIFT
 315         sll     k0, k0, 2                       # log2(sizeof(pgd_t)
 316         addu    k1, k1, k0
 317         mfc0    k0, CP0_CONTEXT
 318         lw      k1, (k1)
 319 #ifndef CONFIG_64BIT_PHYS_ADDR
 320         srl     k0, k0, 1
 321 #endif
 322         and     k0, k0, PTEP_INDX_MSK
 323         addu    k1, k1, k0
 324         PTE_L   k0, 0(k1)
 325         PTE_L   k1, PTE_SIZE(k1)
 326         nop                             /* XXX */
 327         tlbp
 328         PTE_SRL k0, k0, 6
 329         P_MTC0  k0, CP0_ENTRYLO0
 330         PTE_SRL k1, k1, 6
 331         mfc0    k0, CP0_INDEX
 332         P_MTC0  k1, CP0_ENTRYLO1
 333         bltzl   k0, 1f
 334         tlbwr
 335 1:
 336         nop
 337         eret
 338         END(except_vec0_r4k_mphwbug)
 339 #endif
 340
 341         /* TLB refill, EXL == 0, R4000 UP 250MHZ entrylo[01] hwbug version */
 342         LEAF(except_vec0_r4k_250MHZhwbug)
 343         .set    mips3
 344         GET_PGD(k0, k1)                         # get pgd pointer
 345         mfc0    k0, CP0_BADVADDR
 346         srl     k0, k0, _PGDIR_SHIFT
 347         sll     k0, k0, 2                       # log2(sizeof(pgd_t)
 348         addu    k1, k1, k0
 349         mfc0    k0, CP0_CONTEXT
 350         lw      k1, (k1)
 351 #ifndef CONFIG_64BIT_PHYS_ADDR
 352         srl     k0, k0, 1
 353 #endif
 354         and     k0, k0, PTEP_INDX_MSK
 355         addu    k1, k1, k0
 356         PTE_L   k0, 0(k1)
 357         PTE_L   k1, PTE_SIZE(k1)
 358         PTE_SRL k0, k0, 6
 359         P_MTC0  zero, CP0_ENTRYLO0
 360         P_MTC0  k0, CP0_ENTRYLO0
 361         PTE_SRL k1, k1, 6
 362         P_MTC0  zero, CP0_ENTRYLO1
 363         P_MTC0  k1, CP0_ENTRYLO1
 364         b       1f
 365         tlbwr
 366 1:
 367         nop
 368         eret
 369         END(except_vec0_r4k_250MHZhwbug)
 370
 371 #ifdef CONFIG_SMP
 372         /* TLB refill, EXL == 0, R4000 MP 250MHZ entrylo[01]+badvaddr bug version */
 373         LEAF(except_vec0_r4k_MP250MHZhwbug)
 374         .set    mips3
 375         GET_PGD(k0, k1)                         # get pgd pointer
 376         mfc0    k0, CP0_BADVADDR
 377         srl     k0, k0, _PGDIR_SHIFT
 378         sll     k0, k0, 2                       # log2(sizeof(pgd_t)
 379         addu    k1, k1, k0
 380         mfc0    k0, CP0_CONTEXT
 381         lw      k1, (k1)
 382 #ifndef CONFIG_64BIT_PHYS_ADDR
 383         srl     k0, k0, 1
 384 #endif
 385         and     k0, k0, PTEP_INDX_MSK
 386         addu    k1, k1, k0
 387         PTE_L   k0, 0(k1)
 388         PTE_L   k1, PTE_SIZE(k1)
 389         nop                             /* XXX */
 390         tlbp
 391         PTE_SRL k0, k0, 6
 392         P_MTC0  zero, CP0_ENTRYLO0
 393         P_MTC0  k0, CP0_ENTRYLO0
 394         mfc0    k0, CP0_INDEX
 395         PTE_SRL k1, k1, 6
 396         P_MTC0  zero, CP0_ENTRYLO1
 397         P_MTC0  k1, CP0_ENTRYLO1
 398         bltzl   k0, 1f
 399         tlbwr
 400 1:
 401         nop
 402         eret
 403         END(except_vec0_r4k_MP250MHZhwbug)
 404 #endif
 405
 406         __FINIT
 407
 408         .set    noreorder
 409
 410 /*
 411  * From the IDT errata for the QED RM5230 (Nevada), processor revision 1.0:
 412  * 2. A timing hazard exists for the TLBP instruction.
 413  *
 414  *      stalling_instruction
 415  *      TLBP
 416  *
 417  * The JTLB is being read for the TLBP throughout the stall generated by the
 418  * previous instruction. This is not really correct as the stalling instruction
 419  * can modify the address used to access the JTLB.  The failure symptom is that
 420  * the TLBP instruction will use an address created for the stalling instruction
 421  * and not the address held in C0_ENHI and thus report the wrong results.
 422  *
 423  * The software work-around is to not allow the instruction preceding the TLBP
 424  * to stall - make it an NOP or some other instruction guaranteed not to stall.
 425  *
 426  * Errata 2 will not be fixed.  This errata is also on the R5000.
 427  *
 428  * As if we MIPS hackers wouldn't know how to nop pipelines happy ...
 429  */
 430 #define R5K_HAZARD nop
 431
 432         /*
 433          * Note for many R4k variants tlb probes cannot be executed out
 434          * of the instruction cache else you get bogus results.
 435          */
 436         .align  5
 437         NESTED(handle_tlbl, PT_SIZE, sp)
 438         .set    noat
 439 #if BCM1250_M3_WAR
 440         mfc0    k0, CP0_BADVADDR
 441         mfc0    k1, CP0_ENTRYHI
 442         xor     k0, k1
 443         srl     k0, k0, PAGE_SHIFT+1
 444         beqz    k0, 1f
 445          nop
 446         .set    mips3
 447         eret
 448         .set    mips0
 449 1:
 450 #endif
 451 invalid_tlbl:
 452 #ifdef TLB_OPTIMIZE
 453         .set    mips3
 454         /* Test present bit in entry. */
 455         LOAD_PTE(k0, k1)
 456         R5K_HAZARD
 457         tlbp
 458         PTE_PRESENT(k0, k1, nopage_tlbl)
 459         PTE_MAKEVALID(k0, k1)
 460         PTE_RELOAD(k1, k0)
 461         mtc0_tlbw_hazard
 462         tlbwi
 463         tlbw_eret_hazard
 464         .set    mips3
 465         eret
 466         .set    mips0
 467 #endif
 468
 469 nopage_tlbl:
 470         DO_FAULT(0)
 471         END(handle_tlbl)
 472
 473         .align  5
 474         NESTED(handle_tlbs, PT_SIZE, sp)
 475         .set    noat
 476 #ifdef TLB_OPTIMIZE
 477         .set    mips3
 478         li      k0,0
 479         LOAD_PTE(k0, k1)
 480         R5K_HAZARD
 481         tlbp                            # find faulting entry
 482         PTE_WRITABLE(k0, k1, nopage_tlbs)
 483         PTE_MAKEWRITE(k0, k1)
 484         PTE_RELOAD(k1, k0)
 485         mtc0_tlbw_hazard
 486         tlbwi
 487         tlbw_eret_hazard
 488         .set    mips3
 489         eret
 490         .set    mips0
 491 #endif
 492
 493 nopage_tlbs:
 494         DO_FAULT(1)
 495         END(handle_tlbs)
 496
 497         .align  5
 498         NESTED(handle_mod, PT_SIZE, sp)
 499         .set    noat
 500 #ifdef TLB_OPTIMIZE
 501         .set    mips3
 502         LOAD_PTE(k0, k1)
 503         R5K_HAZARD
 504         tlbp                                    # find faulting entry
 505         andi    k0, k0, _PAGE_WRITE
 506         beqz    k0, nowrite_mod
 507          PTE_L  k0, (k1)
 508
 509         /* Present and writable bits set, set accessed and dirty bits. */
 510         PTE_MAKEWRITE(k0, k1)
 511
 512         /* Now reload the entry into the tlb. */
 513         PTE_RELOAD(k1, k0)
 514         mtc0_tlbw_hazard
 515         tlbwi
 516         tlbw_eret_hazard
 517         .set    mips3
 518         eret
 519         .set    mips0
 520 #endif
 521
 522 nowrite_mod:
 523         DO_FAULT(1)
 524         END(handle_mod)