source: src/linux/universal/linux-4.4/arch/mips/mm/tlbex.c @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 11 days ago

kernel update

File size: 66.1 KB
Line 
1/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License.  See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Synthesize TLB refill handlers at runtime.
7 *
8 * Copyright (C) 2004, 2005, 2006, 2008  Thiemo Seufer
9 * Copyright (C) 2005, 2007, 2008, 2009  Maciej W. Rozycki
10 * Copyright (C) 2006  Ralf Baechle (ralf@linux-mips.org)
11 * Copyright (C) 2008, 2009 Cavium Networks, Inc.
12 * Copyright (C) 2011  MIPS Technologies, Inc.
13 *
14 * ... and the days got worse and worse and now you see
15 * I've gone completly out of my mind.
16 *
17 * They're coming to take me a away haha
18 * they're coming to take me a away hoho hihi haha
19 * to the funny farm where code is beautiful all the time ...
20 *
21 * (Condolences to Napoleon XIV)
22 */
23
24#include <linux/bug.h>
25#include <linux/kernel.h>
26#include <linux/types.h>
27#include <linux/smp.h>
28#include <linux/string.h>
29#include <linux/cache.h>
30
31#include <asm/cacheflush.h>
32#include <asm/cpu-type.h>
33#include <asm/pgtable.h>
34#include <asm/war.h>
35#include <asm/uasm.h>
36#include <asm/setup.h>
37
38static int mips_xpa_disabled;
39
40static int __init xpa_disable(char *s)
41{
42        mips_xpa_disabled = 1;
43
44        return 1;
45}
46
47__setup("noxpa", xpa_disable);
48
49/*
50 * TLB load/store/modify handlers.
51 *
52 * Only the fastpath gets synthesized at runtime, the slowpath for
53 * do_page_fault remains normal asm.
54 */
55extern void tlb_do_page_fault_0(void);
56extern void tlb_do_page_fault_1(void);
57
58struct work_registers {
59        int r1;
60        int r2;
61        int r3;
62};
63
64struct tlb_reg_save {
65        unsigned long a;
66        unsigned long b;
67} ____cacheline_aligned_in_smp;
68
69static struct tlb_reg_save handler_reg_save[NR_CPUS];
70
71static inline int r45k_bvahwbug(void)
72{
73        /* XXX: We should probe for the presence of this bug, but we don't. */
74        return 0;
75}
76
77static inline int r4k_250MHZhwbug(void)
78{
79        /* XXX: We should probe for the presence of this bug, but we don't. */
80        return 0;
81}
82
83static inline int __maybe_unused bcm1250_m3_war(void)
84{
85        return BCM1250_M3_WAR;
86}
87
88static inline int __maybe_unused r10000_llsc_war(void)
89{
90        return R10000_LLSC_WAR;
91}
92
93static int use_bbit_insns(void)
94{
95        switch (current_cpu_type()) {
96        case CPU_CAVIUM_OCTEON:
97        case CPU_CAVIUM_OCTEON_PLUS:
98        case CPU_CAVIUM_OCTEON2:
99        case CPU_CAVIUM_OCTEON3:
100                return 1;
101        default:
102                return 0;
103        }
104}
105
106static int use_lwx_insns(void)
107{
108        switch (current_cpu_type()) {
109        case CPU_CAVIUM_OCTEON2:
110        case CPU_CAVIUM_OCTEON3:
111                return 1;
112        default:
113                return 0;
114        }
115}
116#if defined(CONFIG_CAVIUM_OCTEON_CVMSEG_SIZE) && \
117    CONFIG_CAVIUM_OCTEON_CVMSEG_SIZE > 0
118static bool scratchpad_available(void)
119{
120        return true;
121}
122static int scratchpad_offset(int i)
123{
124        /*
125         * CVMSEG starts at address -32768 and extends for
126         * CAVIUM_OCTEON_CVMSEG_SIZE 128 byte cache lines.
127         */
128        i += 1; /* Kernel use starts at the top and works down. */
129        return CONFIG_CAVIUM_OCTEON_CVMSEG_SIZE * 128 - (8 * i) - 32768;
130}
131#else
132static bool scratchpad_available(void)
133{
134        return false;
135}
136static int scratchpad_offset(int i)
137{
138        BUG();
139        /* Really unreachable, but evidently some GCC want this. */
140        return 0;
141}
142#endif
143/*
144 * Found by experiment: At least some revisions of the 4kc throw under
145 * some circumstances a machine check exception, triggered by invalid
146 * values in the index register.  Delaying the tlbp instruction until
147 * after the next branch,  plus adding an additional nop in front of
148 * tlbwi/tlbwr avoids the invalid index register values. Nobody knows
149 * why; it's not an issue caused by the core RTL.
150 *
151 */
152static int m4kc_tlbp_war(void)
153{
154        return (current_cpu_data.processor_id & 0xffff00) ==
155               (PRID_COMP_MIPS | PRID_IMP_4KC);
156}
157
158/* Handle labels (which must be positive integers). */
159enum label_id {
160        label_second_part = 1,
161        label_leave,
162        label_vmalloc,
163        label_vmalloc_done,
164        label_tlbw_hazard_0,
165        label_split = label_tlbw_hazard_0 + 8,
166        label_tlbl_goaround1,
167        label_tlbl_goaround2,
168        label_nopage_tlbl,
169        label_nopage_tlbs,
170        label_nopage_tlbm,
171        label_smp_pgtable_change,
172        label_r3000_write_probe_fail,
173        label_large_segbits_fault,
174#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
175        label_tlb_huge_update,
176#endif
177};
178
179UASM_L_LA(_second_part)
180UASM_L_LA(_leave)
181UASM_L_LA(_vmalloc)
182UASM_L_LA(_vmalloc_done)
183/* _tlbw_hazard_x is handled differently.  */
184UASM_L_LA(_split)
185UASM_L_LA(_tlbl_goaround1)
186UASM_L_LA(_tlbl_goaround2)
187UASM_L_LA(_nopage_tlbl)
188UASM_L_LA(_nopage_tlbs)
189UASM_L_LA(_nopage_tlbm)
190UASM_L_LA(_smp_pgtable_change)
191UASM_L_LA(_r3000_write_probe_fail)
192UASM_L_LA(_large_segbits_fault)
193#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
194UASM_L_LA(_tlb_huge_update)
195#endif
196
197static int hazard_instance;
198
199static void uasm_bgezl_hazard(u32 **p, struct uasm_reloc **r, int instance)
200{
201        switch (instance) {
202        case 0 ... 7:
203                uasm_il_bgezl(p, r, 0, label_tlbw_hazard_0 + instance);
204                return;
205        default:
206                BUG();
207        }
208}
209
210static void uasm_bgezl_label(struct uasm_label **l, u32 **p, int instance)
211{
212        switch (instance) {
213        case 0 ... 7:
214                uasm_build_label(l, *p, label_tlbw_hazard_0 + instance);
215                break;
216        default:
217                BUG();
218        }
219}
220
221/*
222 * pgtable bits are assigned dynamically depending on processor feature
223 * and statically based on kernel configuration.  This spits out the actual
224 * values the kernel is using.  Required to make sense from disassembled
225 * TLB exception handlers.
226 */
227static void output_pgtable_bits_defines(void)
228{
229#define pr_define(fmt, ...)                                     \
230        pr_debug("#define " fmt, ##__VA_ARGS__)
231
232        pr_debug("#include <asm/asm.h>\n");
233        pr_debug("#include <asm/regdef.h>\n");
234        pr_debug("\n");
235
236        pr_define("_PAGE_PRESENT_SHIFT %d\n", _PAGE_PRESENT_SHIFT);
237        pr_define("_PAGE_READ_SHIFT %d\n", _PAGE_READ_SHIFT);
238        pr_define("_PAGE_WRITE_SHIFT %d\n", _PAGE_WRITE_SHIFT);
239        pr_define("_PAGE_ACCESSED_SHIFT %d\n", _PAGE_ACCESSED_SHIFT);
240        pr_define("_PAGE_MODIFIED_SHIFT %d\n", _PAGE_MODIFIED_SHIFT);
241#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
242        pr_define("_PAGE_HUGE_SHIFT %d\n", _PAGE_HUGE_SHIFT);
243        pr_define("_PAGE_SPLITTING_SHIFT %d\n", _PAGE_SPLITTING_SHIFT);
244#endif
245#if defined(CONFIG_CPU_MIPSR2) || defined(CONFIG_CPU_MIPSR6)
246        if (cpu_has_rixi) {
247#ifdef _PAGE_NO_EXEC_SHIFT
248                pr_define("_PAGE_NO_EXEC_SHIFT %d\n", _PAGE_NO_EXEC_SHIFT);
249                pr_define("_PAGE_NO_READ_SHIFT %d\n", _PAGE_NO_READ_SHIFT);
250#endif
251        }
252#endif
253        pr_define("_PAGE_GLOBAL_SHIFT %d\n", _PAGE_GLOBAL_SHIFT);
254        pr_define("_PAGE_VALID_SHIFT %d\n", _PAGE_VALID_SHIFT);
255        pr_define("_PAGE_DIRTY_SHIFT %d\n", _PAGE_DIRTY_SHIFT);
256        pr_define("_PFN_SHIFT %d\n", _PFN_SHIFT);
257        pr_debug("\n");
258}
259
260static inline void dump_handler(const char *symbol, const u32 *handler, int count)
261{
262        int i;
263
264        pr_debug("LEAF(%s)\n", symbol);
265
266        pr_debug("\t.set push\n");
267        pr_debug("\t.set noreorder\n");
268
269        for (i = 0; i < count; i++)
270                pr_debug("\t.word\t0x%08x\t\t# %p\n", handler[i], &handler[i]);
271
272        pr_debug("\t.set\tpop\n");
273
274        pr_debug("\tEND(%s)\n", symbol);
275}
276
277/* The only general purpose registers allowed in TLB handlers. */
278#define K0              26
279#define K1              27
280
281/* Some CP0 registers */
282#define C0_INDEX        0, 0
283#define C0_ENTRYLO0     2, 0
284#define C0_TCBIND       2, 2
285#define C0_ENTRYLO1     3, 0
286#define C0_CONTEXT      4, 0
287#define C0_PAGEMASK     5, 0
288#define C0_BADVADDR     8, 0
289#define C0_ENTRYHI      10, 0
290#define C0_EPC          14, 0
291#define C0_XCONTEXT     20, 0
292
293#ifdef CONFIG_64BIT
294# define GET_CONTEXT(buf, reg) UASM_i_MFC0(buf, reg, C0_XCONTEXT)
295#else
296# define GET_CONTEXT(buf, reg) UASM_i_MFC0(buf, reg, C0_CONTEXT)
297#endif
298
299/* The worst case length of the handler is around 18 instructions for
300 * R3000-style TLBs and up to 63 instructions for R4000-style TLBs.
301 * Maximum space available is 32 instructions for R3000 and 64
302 * instructions for R4000.
303 *
304 * We deliberately chose a buffer size of 128, so we won't scribble
305 * over anything important on overflow before we panic.
306 */
307static u32 tlb_handler[128];
308
309/* simply assume worst case size for labels and relocs */
310static struct uasm_label labels[128];
311static struct uasm_reloc relocs[128];
312
313static int check_for_high_segbits;
314static bool fill_includes_sw_bits;
315
316static unsigned int kscratch_used_mask;
317
318static inline int __maybe_unused c0_kscratch(void)
319{
320        switch (current_cpu_type()) {
321        case CPU_XLP:
322        case CPU_XLR:
323                return 22;
324        default:
325                return 31;
326        }
327}
328
329static int allocate_kscratch(void)
330{
331        int r;
332        unsigned int a = cpu_data[0].kscratch_mask & ~kscratch_used_mask;
333
334        r = ffs(a);
335
336        if (r == 0)
337                return -1;
338
339        r--; /* make it zero based */
340
341        kscratch_used_mask |= (1 << r);
342
343        return r;
344}
345
346static int scratch_reg;
347static int pgd_reg;
348enum vmalloc64_mode {not_refill, refill_scratch, refill_noscratch};
349
350static struct work_registers build_get_work_registers(u32 **p)
351{
352        struct work_registers r;
353
354        if (scratch_reg >= 0) {
355                /* Save in CPU local C0_KScratch? */
356                UASM_i_MTC0(p, 1, c0_kscratch(), scratch_reg);
357                r.r1 = K0;
358                r.r2 = K1;
359                r.r3 = 1;
360                return r;
361        }
362
363        if (num_possible_cpus() > 1) {
364                /* Get smp_processor_id */
365                UASM_i_CPUID_MFC0(p, K0, SMP_CPUID_REG);
366                UASM_i_SRL_SAFE(p, K0, K0, SMP_CPUID_REGSHIFT);
367
368                /* handler_reg_save index in K0 */
369                UASM_i_SLL(p, K0, K0, ilog2(sizeof(struct tlb_reg_save)));
370
371                UASM_i_LA(p, K1, (long)&handler_reg_save);
372                UASM_i_ADDU(p, K0, K0, K1);
373        } else {
374                UASM_i_LA(p, K0, (long)&handler_reg_save);
375        }
376        /* K0 now points to save area, save $1 and $2  */
377        UASM_i_SW(p, 1, offsetof(struct tlb_reg_save, a), K0);
378        UASM_i_SW(p, 2, offsetof(struct tlb_reg_save, b), K0);
379
380        r.r1 = K1;
381        r.r2 = 1;
382        r.r3 = 2;
383        return r;
384}
385
386static void build_restore_work_registers(u32 **p)
387{
388        if (scratch_reg >= 0) {
389                UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
390                return;
391        }
392        /* K0 already points to save area, restore $1 and $2  */
393        UASM_i_LW(p, 1, offsetof(struct tlb_reg_save, a), K0);
394        UASM_i_LW(p, 2, offsetof(struct tlb_reg_save, b), K0);
395}
396
397#ifndef CONFIG_MIPS_PGD_C0_CONTEXT
398
399/*
400 * CONFIG_MIPS_PGD_C0_CONTEXT implies 64 bit and lack of pgd_current,
401 * we cannot do r3000 under these circumstances.
402 *
403 * Declare pgd_current here instead of including mmu_context.h to avoid type
404 * conflicts for tlbmiss_handler_setup_pgd
405 */
406extern unsigned long pgd_current[];
407
408/*
409 * The R3000 TLB handler is simple.
410 */
411static void build_r3000_tlb_refill_handler(void)
412{
413        long pgdc = (long)pgd_current;
414        u32 *p;
415
416        memset(tlb_handler, 0, sizeof(tlb_handler));
417        p = tlb_handler;
418
419        uasm_i_mfc0(&p, K0, C0_BADVADDR);
420        uasm_i_lui(&p, K1, uasm_rel_hi(pgdc)); /* cp0 delay */
421        uasm_i_lw(&p, K1, uasm_rel_lo(pgdc), K1);
422        uasm_i_srl(&p, K0, K0, 22); /* load delay */
423        uasm_i_sll(&p, K0, K0, 2);
424        uasm_i_addu(&p, K1, K1, K0);
425        uasm_i_mfc0(&p, K0, C0_CONTEXT);
426        uasm_i_lw(&p, K1, 0, K1); /* cp0 delay */
427        uasm_i_andi(&p, K0, K0, 0xffc); /* load delay */
428        uasm_i_addu(&p, K1, K1, K0);
429        uasm_i_lw(&p, K0, 0, K1);
430        uasm_i_nop(&p); /* load delay */
431        uasm_i_mtc0(&p, K0, C0_ENTRYLO0);
432        uasm_i_mfc0(&p, K1, C0_EPC); /* cp0 delay */
433        uasm_i_tlbwr(&p); /* cp0 delay */
434        uasm_i_jr(&p, K1);
435        uasm_i_rfe(&p); /* branch delay */
436
437        if (p > tlb_handler + 32)
438                panic("TLB refill handler space exceeded");
439
440        pr_debug("Wrote TLB refill handler (%u instructions).\n",
441                 (unsigned int)(p - tlb_handler));
442
443        memcpy((void *)ebase, tlb_handler, 0x80);
444        local_flush_icache_range(ebase, ebase + 0x80);
445
446        dump_handler("r3000_tlb_refill", (u32 *)ebase, 32);
447}
448#endif /* CONFIG_MIPS_PGD_C0_CONTEXT */
449
450/*
451 * The R4000 TLB handler is much more complicated. We have two
452 * consecutive handler areas with 32 instructions space each.
453 * Since they aren't used at the same time, we can overflow in the
454 * other one.To keep things simple, we first assume linear space,
455 * then we relocate it to the final handler layout as needed.
456 */
457static u32 final_handler[64];
458
459/*
460 * Hazards
461 *
462 * From the IDT errata for the QED RM5230 (Nevada), processor revision 1.0:
463 * 2. A timing hazard exists for the TLBP instruction.
464 *
465 *      stalling_instruction
466 *      TLBP
467 *
468 * The JTLB is being read for the TLBP throughout the stall generated by the
469 * previous instruction. This is not really correct as the stalling instruction
470 * can modify the address used to access the JTLB.  The failure symptom is that
471 * the TLBP instruction will use an address created for the stalling instruction
472 * and not the address held in C0_ENHI and thus report the wrong results.
473 *
474 * The software work-around is to not allow the instruction preceding the TLBP
475 * to stall - make it an NOP or some other instruction guaranteed not to stall.
476 *
477 * Errata 2 will not be fixed.  This errata is also on the R5000.
478 *
479 * As if we MIPS hackers wouldn't know how to nop pipelines happy ...
480 */
481static void __maybe_unused build_tlb_probe_entry(u32 **p)
482{
483        switch (current_cpu_type()) {
484        /* Found by experiment: R4600 v2.0/R4700 needs this, too.  */
485        case CPU_R4600:
486        case CPU_R4700:
487        case CPU_R5000:
488        case CPU_NEVADA:
489                uasm_i_nop(p);
490                uasm_i_tlbp(p);
491                break;
492
493        default:
494                uasm_i_tlbp(p);
495                break;
496        }
497}
498
499/*
500 * Write random or indexed TLB entry, and care about the hazards from
501 * the preceding mtc0 and for the following eret.
502 */
503enum tlb_write_entry { tlb_random, tlb_indexed };
504
505static void build_tlb_write_entry(u32 **p, struct uasm_label **l,
506                                  struct uasm_reloc **r,
507                                  enum tlb_write_entry wmode)
508{
509        void(*tlbw)(u32 **) = NULL;
510
511        switch (wmode) {
512        case tlb_random: tlbw = uasm_i_tlbwr; break;
513        case tlb_indexed: tlbw = uasm_i_tlbwi; break;
514        }
515
516        if (cpu_has_mips_r2_r6) {
517                if (cpu_has_mips_r2_exec_hazard)
518                        uasm_i_ehb(p);
519                tlbw(p);
520                return;
521        }
522
523        switch (current_cpu_type()) {
524        case CPU_R4000PC:
525        case CPU_R4000SC:
526        case CPU_R4000MC:
527        case CPU_R4400PC:
528        case CPU_R4400SC:
529        case CPU_R4400MC:
530                /*
531                 * This branch uses up a mtc0 hazard nop slot and saves
532                 * two nops after the tlbw instruction.
533                 */
534                uasm_bgezl_hazard(p, r, hazard_instance);
535                tlbw(p);
536                uasm_bgezl_label(l, p, hazard_instance);
537                hazard_instance++;
538                uasm_i_nop(p);
539                break;
540
541        case CPU_R4600:
542        case CPU_R4700:
543                uasm_i_nop(p);
544                tlbw(p);
545                uasm_i_nop(p);
546                break;
547
548        case CPU_R5000:
549        case CPU_NEVADA:
550                uasm_i_nop(p); /* QED specifies 2 nops hazard */
551                uasm_i_nop(p); /* QED specifies 2 nops hazard */
552                tlbw(p);
553                break;
554
555        case CPU_R4300:
556        case CPU_5KC:
557        case CPU_TX49XX:
558        case CPU_PR4450:
559        case CPU_XLR:
560                uasm_i_nop(p);
561                tlbw(p);
562                break;
563
564        case CPU_R10000:
565        case CPU_R12000:
566        case CPU_R14000:
567        case CPU_R16000:
568        case CPU_4KC:
569        case CPU_4KEC:
570        case CPU_M14KC:
571        case CPU_M14KEC:
572        case CPU_SB1:
573        case CPU_SB1A:
574        case CPU_4KSC:
575        case CPU_20KC:
576        case CPU_25KF:
577        case CPU_BMIPS32:
578        case CPU_BMIPS3300:
579        case CPU_BMIPS4350:
580        case CPU_BMIPS4380:
581        case CPU_BMIPS5000:
582        case CPU_LOONGSON2:
583        case CPU_LOONGSON3:
584        case CPU_R5500:
585                if (m4kc_tlbp_war())
586                        uasm_i_nop(p);
587        case CPU_ALCHEMY:
588                tlbw(p);
589                break;
590
591        case CPU_RM7000:
592                uasm_i_nop(p);
593                uasm_i_nop(p);
594                uasm_i_nop(p);
595                uasm_i_nop(p);
596                tlbw(p);
597                break;
598
599        case CPU_VR4111:
600        case CPU_VR4121:
601        case CPU_VR4122:
602        case CPU_VR4181:
603        case CPU_VR4181A:
604                uasm_i_nop(p);
605                uasm_i_nop(p);
606                tlbw(p);
607                uasm_i_nop(p);
608                uasm_i_nop(p);
609                break;
610
611        case CPU_VR4131:
612        case CPU_VR4133:
613        case CPU_R5432:
614                uasm_i_nop(p);
615                uasm_i_nop(p);
616                tlbw(p);
617                break;
618
619        case CPU_JZRISC:
620                tlbw(p);
621                uasm_i_nop(p);
622                break;
623
624        default:
625                panic("No TLB refill handler yet (CPU type: %d)",
626                      current_cpu_type());
627                break;
628        }
629}
630
631static __maybe_unused void build_convert_pte_to_entrylo(u32 **p,
632                                                        unsigned int reg)
633{
634        if (cpu_has_rixi && _PAGE_NO_EXEC) {
635                if (fill_includes_sw_bits) {
636                        UASM_i_ROTR(p, reg, reg, ilog2(_PAGE_GLOBAL));
637                } else {
638                        UASM_i_SRL(p, reg, reg, ilog2(_PAGE_NO_EXEC));
639                        UASM_i_ROTR(p, reg, reg,
640                                    ilog2(_PAGE_GLOBAL) - ilog2(_PAGE_NO_EXEC));
641                }
642        } else {
643#ifdef CONFIG_PHYS_ADDR_T_64BIT
644                uasm_i_dsrl_safe(p, reg, reg, ilog2(_PAGE_GLOBAL));
645#else
646                UASM_i_SRL(p, reg, reg, ilog2(_PAGE_GLOBAL));
647#endif
648        }
649}
650
651#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
652
653static void build_restore_pagemask(u32 **p, struct uasm_reloc **r,
654                                   unsigned int tmp, enum label_id lid,
655                                   int restore_scratch)
656{
657        if (restore_scratch) {
658                /* Reset default page size */
659                if (PM_DEFAULT_MASK >> 16) {
660                        uasm_i_lui(p, tmp, PM_DEFAULT_MASK >> 16);
661                        uasm_i_ori(p, tmp, tmp, PM_DEFAULT_MASK & 0xffff);
662                        uasm_i_mtc0(p, tmp, C0_PAGEMASK);
663                        uasm_il_b(p, r, lid);
664                } else if (PM_DEFAULT_MASK) {
665                        uasm_i_ori(p, tmp, 0, PM_DEFAULT_MASK);
666                        uasm_i_mtc0(p, tmp, C0_PAGEMASK);
667                        uasm_il_b(p, r, lid);
668                } else {
669                        uasm_i_mtc0(p, 0, C0_PAGEMASK);
670                        uasm_il_b(p, r, lid);
671                }
672                if (scratch_reg >= 0)
673                        UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
674                else
675                        UASM_i_LW(p, 1, scratchpad_offset(0), 0);
676        } else {
677                /* Reset default page size */
678                if (PM_DEFAULT_MASK >> 16) {
679                        uasm_i_lui(p, tmp, PM_DEFAULT_MASK >> 16);
680                        uasm_i_ori(p, tmp, tmp, PM_DEFAULT_MASK & 0xffff);
681                        uasm_il_b(p, r, lid);
682                        uasm_i_mtc0(p, tmp, C0_PAGEMASK);
683                } else if (PM_DEFAULT_MASK) {
684                        uasm_i_ori(p, tmp, 0, PM_DEFAULT_MASK);
685                        uasm_il_b(p, r, lid);
686                        uasm_i_mtc0(p, tmp, C0_PAGEMASK);
687                } else {
688                        uasm_il_b(p, r, lid);
689                        uasm_i_mtc0(p, 0, C0_PAGEMASK);
690                }
691        }
692}
693
694static void build_huge_tlb_write_entry(u32 **p, struct uasm_label **l,
695                                       struct uasm_reloc **r,
696                                       unsigned int tmp,
697                                       enum tlb_write_entry wmode,
698                                       int restore_scratch)
699{
700        /* Set huge page tlb entry size */
701        uasm_i_lui(p, tmp, PM_HUGE_MASK >> 16);
702        uasm_i_ori(p, tmp, tmp, PM_HUGE_MASK & 0xffff);
703        uasm_i_mtc0(p, tmp, C0_PAGEMASK);
704
705        build_tlb_write_entry(p, l, r, wmode);
706
707        build_restore_pagemask(p, r, tmp, label_leave, restore_scratch);
708}
709
710/*
711 * Check if Huge PTE is present, if so then jump to LABEL.
712 */
713static void
714build_is_huge_pte(u32 **p, struct uasm_reloc **r, unsigned int tmp,
715                  unsigned int pmd, int lid)
716{
717        UASM_i_LW(p, tmp, 0, pmd);
718        if (use_bbit_insns()) {
719                uasm_il_bbit1(p, r, tmp, ilog2(_PAGE_HUGE), lid);
720        } else {
721                uasm_i_andi(p, tmp, tmp, _PAGE_HUGE);
722                uasm_il_bnez(p, r, tmp, lid);
723        }
724}
725
726static void build_huge_update_entries(u32 **p, unsigned int pte,
727                                      unsigned int tmp)
728{
729        int small_sequence;
730
731        /*
732         * A huge PTE describes an area the size of the
733         * configured huge page size. This is twice the
734         * of the large TLB entry size we intend to use.
735         * A TLB entry half the size of the configured
736         * huge page size is configured into entrylo0
737         * and entrylo1 to cover the contiguous huge PTE
738         * address space.
739         */
740        small_sequence = (HPAGE_SIZE >> 7) < 0x10000;
741
742        /* We can clobber tmp.  It isn't used after this.*/
743        if (!small_sequence)
744                uasm_i_lui(p, tmp, HPAGE_SIZE >> (7 + 16));
745
746        build_convert_pte_to_entrylo(p, pte);
747        UASM_i_MTC0(p, pte, C0_ENTRYLO0); /* load it */
748        /* convert to entrylo1 */
749        if (small_sequence)
750                UASM_i_ADDIU(p, pte, pte, HPAGE_SIZE >> 7);
751        else
752                UASM_i_ADDU(p, pte, pte, tmp);
753
754        UASM_i_MTC0(p, pte, C0_ENTRYLO1); /* load it */
755}
756
757static void build_huge_handler_tail(u32 **p, struct uasm_reloc **r,
758                                    struct uasm_label **l,
759                                    unsigned int pte,
760                                    unsigned int ptr,
761                                    unsigned int flush)
762{
763#ifdef CONFIG_SMP
764        UASM_i_SC(p, pte, 0, ptr);
765        uasm_il_beqz(p, r, pte, label_tlb_huge_update);
766        UASM_i_LW(p, pte, 0, ptr); /* Needed because SC killed our PTE */
767#else
768        UASM_i_SW(p, pte, 0, ptr);
769#endif
770        if (cpu_has_ftlb && flush) {
771                BUG_ON(!cpu_has_tlbinv);
772
773                UASM_i_MFC0(p, ptr, C0_ENTRYHI);
774                uasm_i_ori(p, ptr, ptr, MIPS_ENTRYHI_EHINV);
775                UASM_i_MTC0(p, ptr, C0_ENTRYHI);
776                build_tlb_write_entry(p, l, r, tlb_indexed);
777
778                uasm_i_xori(p, ptr, ptr, MIPS_ENTRYHI_EHINV);
779                UASM_i_MTC0(p, ptr, C0_ENTRYHI);
780                build_huge_update_entries(p, pte, ptr);
781                build_huge_tlb_write_entry(p, l, r, pte, tlb_random, 0);
782
783                return;
784        }
785
786        build_huge_update_entries(p, pte, ptr);
787        build_huge_tlb_write_entry(p, l, r, pte, tlb_indexed, 0);
788}
789#endif /* CONFIG_MIPS_HUGE_TLB_SUPPORT */
790
791#ifdef CONFIG_64BIT
792/*
793 * TMP and PTR are scratch.
794 * TMP will be clobbered, PTR will hold the pmd entry.
795 */
796static void
797build_get_pmde64(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
798                 unsigned int tmp, unsigned int ptr)
799{
800#ifndef CONFIG_MIPS_PGD_C0_CONTEXT
801        long pgdc = (long)pgd_current;
802#endif
803        /*
804         * The vmalloc handling is not in the hotpath.
805         */
806        uasm_i_dmfc0(p, tmp, C0_BADVADDR);
807
808        if (check_for_high_segbits) {
809                /*
810                 * The kernel currently implicitely assumes that the
811                 * MIPS SEGBITS parameter for the processor is
812                 * (PGDIR_SHIFT+PGDIR_BITS) or less, and will never
813                 * allocate virtual addresses outside the maximum
814                 * range for SEGBITS = (PGDIR_SHIFT+PGDIR_BITS). But
815                 * that doesn't prevent user code from accessing the
816                 * higher xuseg addresses.  Here, we make sure that
817                 * everything but the lower xuseg addresses goes down
818                 * the module_alloc/vmalloc path.
819                 */
820                uasm_i_dsrl_safe(p, ptr, tmp, PGDIR_SHIFT + PGD_ORDER + PAGE_SHIFT - 3);
821                uasm_il_bnez(p, r, ptr, label_vmalloc);
822        } else {
823                uasm_il_bltz(p, r, tmp, label_vmalloc);
824        }
825        /* No uasm_i_nop needed here, since the next insn doesn't touch TMP. */
826
827        if (pgd_reg != -1) {
828                /* pgd is in pgd_reg */
829                UASM_i_MFC0(p, ptr, c0_kscratch(), pgd_reg);
830        } else {
831#if defined(CONFIG_MIPS_PGD_C0_CONTEXT)
832                /*
833                 * &pgd << 11 stored in CONTEXT [23..63].
834                 */
835                UASM_i_MFC0(p, ptr, C0_CONTEXT);
836
837                /* Clear lower 23 bits of context. */
838                uasm_i_dins(p, ptr, 0, 0, 23);
839
840                /* 1 0  1 0 1  << 6  xkphys cached */
841                uasm_i_ori(p, ptr, ptr, 0x540);
842                uasm_i_drotr(p, ptr, ptr, 11);
843#elif defined(CONFIG_SMP)
844                UASM_i_CPUID_MFC0(p, ptr, SMP_CPUID_REG);
845                uasm_i_dsrl_safe(p, ptr, ptr, SMP_CPUID_PTRSHIFT);
846                UASM_i_LA_mostly(p, tmp, pgdc);
847                uasm_i_daddu(p, ptr, ptr, tmp);
848                uasm_i_dmfc0(p, tmp, C0_BADVADDR);
849                uasm_i_ld(p, ptr, uasm_rel_lo(pgdc), ptr);
850#else
851                UASM_i_LA_mostly(p, ptr, pgdc);
852                uasm_i_ld(p, ptr, uasm_rel_lo(pgdc), ptr);
853#endif
854        }
855
856        uasm_l_vmalloc_done(l, *p);
857
858        /* get pgd offset in bytes */
859        uasm_i_dsrl_safe(p, tmp, tmp, PGDIR_SHIFT - 3);
860
861        uasm_i_andi(p, tmp, tmp, (PTRS_PER_PGD - 1)<<3);
862        uasm_i_daddu(p, ptr, ptr, tmp); /* add in pgd offset */
863#ifndef __PAGETABLE_PMD_FOLDED
864        uasm_i_dmfc0(p, tmp, C0_BADVADDR); /* get faulting address */
865        uasm_i_ld(p, ptr, 0, ptr); /* get pmd pointer */
866        uasm_i_dsrl_safe(p, tmp, tmp, PMD_SHIFT-3); /* get pmd offset in bytes */
867        uasm_i_andi(p, tmp, tmp, (PTRS_PER_PMD - 1)<<3);
868        uasm_i_daddu(p, ptr, ptr, tmp); /* add in pmd offset */
869#endif
870}
871
872/*
873 * BVADDR is the faulting address, PTR is scratch.
874 * PTR will hold the pgd for vmalloc.
875 */
876static void
877build_get_pgd_vmalloc64(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
878                        unsigned int bvaddr, unsigned int ptr,
879                        enum vmalloc64_mode mode)
880{
881        long swpd = (long)swapper_pg_dir;
882        int single_insn_swpd;
883        int did_vmalloc_branch = 0;
884
885        single_insn_swpd = uasm_in_compat_space_p(swpd) && !uasm_rel_lo(swpd);
886
887        uasm_l_vmalloc(l, *p);
888
889        if (mode != not_refill && check_for_high_segbits) {
890                if (single_insn_swpd) {
891                        uasm_il_bltz(p, r, bvaddr, label_vmalloc_done);
892                        uasm_i_lui(p, ptr, uasm_rel_hi(swpd));
893                        did_vmalloc_branch = 1;
894                        /* fall through */
895                } else {
896                        uasm_il_bgez(p, r, bvaddr, label_large_segbits_fault);
897                }
898        }
899        if (!did_vmalloc_branch) {
900                if (uasm_in_compat_space_p(swpd) && !uasm_rel_lo(swpd)) {
901                        uasm_il_b(p, r, label_vmalloc_done);
902                        uasm_i_lui(p, ptr, uasm_rel_hi(swpd));
903                } else {
904                        UASM_i_LA_mostly(p, ptr, swpd);
905                        uasm_il_b(p, r, label_vmalloc_done);
906                        if (uasm_in_compat_space_p(swpd))
907                                uasm_i_addiu(p, ptr, ptr, uasm_rel_lo(swpd));
908                        else
909                                uasm_i_daddiu(p, ptr, ptr, uasm_rel_lo(swpd));
910                }
911        }
912        if (mode != not_refill && check_for_high_segbits) {
913                uasm_l_large_segbits_fault(l, *p);
914                /*
915                 * We get here if we are an xsseg address, or if we are
916                 * an xuseg address above (PGDIR_SHIFT+PGDIR_BITS) boundary.
917                 *
918                 * Ignoring xsseg (assume disabled so would generate
919                 * (address errors?), the only remaining possibility
920                 * is the upper xuseg addresses.  On processors with
921                 * TLB_SEGBITS <= PGDIR_SHIFT+PGDIR_BITS, these
922                 * addresses would have taken an address error. We try
923                 * to mimic that here by taking a load/istream page
924                 * fault.
925                 */
926                UASM_i_LA(p, ptr, (unsigned long)tlb_do_page_fault_0);
927                uasm_i_jr(p, ptr);
928
929                if (mode == refill_scratch) {
930                        if (scratch_reg >= 0)
931                                UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
932                        else
933                                UASM_i_LW(p, 1, scratchpad_offset(0), 0);
934                } else {
935                        uasm_i_nop(p);
936                }
937        }
938}
939
940#else /* !CONFIG_64BIT */
941
942/*
943 * TMP and PTR are scratch.
944 * TMP will be clobbered, PTR will hold the pgd entry.
945 */
946static void __maybe_unused
947build_get_pgde32(u32 **p, unsigned int tmp, unsigned int ptr)
948{
949        if (pgd_reg != -1) {
950                /* pgd is in pgd_reg */
951                uasm_i_mfc0(p, ptr, c0_kscratch(), pgd_reg);
952                uasm_i_mfc0(p, tmp, C0_BADVADDR); /* get faulting address */
953        } else {
954                long pgdc = (long)pgd_current;
955
956                /* 32 bit SMP has smp_processor_id() stored in CONTEXT. */
957#ifdef CONFIG_SMP
958                uasm_i_mfc0(p, ptr, SMP_CPUID_REG);
959                UASM_i_LA_mostly(p, tmp, pgdc);
960                uasm_i_srl(p, ptr, ptr, SMP_CPUID_PTRSHIFT);
961                uasm_i_addu(p, ptr, tmp, ptr);
962#else
963#ifdef CONFIG_BCM47XX
964                uasm_i_nop(p);
965#endif
966                UASM_i_LA_mostly(p, ptr, pgdc);
967#endif
968                uasm_i_mfc0(p, tmp, C0_BADVADDR); /* get faulting address */
969                uasm_i_lw(p, ptr, uasm_rel_lo(pgdc), ptr);
970        }
971        uasm_i_srl(p, tmp, tmp, PGDIR_SHIFT); /* get pgd only bits */
972        uasm_i_sll(p, tmp, tmp, PGD_T_LOG2);
973        uasm_i_addu(p, ptr, ptr, tmp); /* add in pgd offset */
974}
975
976#endif /* !CONFIG_64BIT */
977
978static void build_adjust_context(u32 **p, unsigned int ctx)
979{
980        unsigned int shift = 4 - (PTE_T_LOG2 + 1) + PAGE_SHIFT - 12;
981        unsigned int mask = (PTRS_PER_PTE / 2 - 1) << (PTE_T_LOG2 + 1);
982
983        switch (current_cpu_type()) {
984        case CPU_VR41XX:
985        case CPU_VR4111:
986        case CPU_VR4121:
987        case CPU_VR4122:
988        case CPU_VR4131:
989        case CPU_VR4181:
990        case CPU_VR4181A:
991        case CPU_VR4133:
992                shift += 2;
993                break;
994
995        default:
996                break;
997        }
998
999        if (shift)
1000                UASM_i_SRL(p, ctx, ctx, shift);
1001        uasm_i_andi(p, ctx, ctx, mask);
1002}
1003
1004static void build_get_ptep(u32 **p, unsigned int tmp, unsigned int ptr)
1005{
1006        /*
1007         * Bug workaround for the Nevada. It seems as if under certain
1008         * circumstances the move from cp0_context might produce a
1009         * bogus result when the mfc0 instruction and its consumer are
1010         * in a different cacheline or a load instruction, probably any
1011         * memory reference, is between them.
1012         */
1013        switch (current_cpu_type()) {
1014        case CPU_NEVADA:
1015                UASM_i_LW(p, ptr, 0, ptr);
1016                GET_CONTEXT(p, tmp); /* get context reg */
1017                break;
1018
1019        default:
1020                GET_CONTEXT(p, tmp); /* get context reg */
1021                UASM_i_LW(p, ptr, 0, ptr);
1022                break;
1023        }
1024
1025        build_adjust_context(p, tmp);
1026        UASM_i_ADDU(p, ptr, ptr, tmp); /* add in offset */
1027}
1028
1029static void build_update_entries(u32 **p, unsigned int tmp, unsigned int ptep)
1030{
1031        /*
1032         * 64bit address support (36bit on a 32bit CPU) in a 32bit
1033         * Kernel is a special case. Only a few CPUs use it.
1034         */
1035        if (config_enabled(CONFIG_PHYS_ADDR_T_64BIT) && !cpu_has_64bits) {
1036                int pte_off_even = sizeof(pte_t) / 2;
1037                int pte_off_odd = pte_off_even + sizeof(pte_t);
1038#ifdef CONFIG_XPA
1039                const int scratch = 1; /* Our extra working register */
1040
1041                uasm_i_addu(p, scratch, 0, ptep);
1042#endif
1043                uasm_i_lw(p, tmp, pte_off_even, ptep); /* even pte */
1044                uasm_i_lw(p, ptep, pte_off_odd, ptep); /* odd pte */
1045                UASM_i_ROTR(p, tmp, tmp, ilog2(_PAGE_GLOBAL));
1046                UASM_i_ROTR(p, ptep, ptep, ilog2(_PAGE_GLOBAL));
1047                UASM_i_MTC0(p, tmp, C0_ENTRYLO0);
1048                UASM_i_MTC0(p, ptep, C0_ENTRYLO1);
1049#ifdef CONFIG_XPA
1050                uasm_i_lw(p, tmp, 0, scratch);
1051                uasm_i_lw(p, ptep, sizeof(pte_t), scratch);
1052                uasm_i_lui(p, scratch, 0xff);
1053                uasm_i_ori(p, scratch, scratch, 0xffff);
1054                uasm_i_and(p, tmp, scratch, tmp);
1055                uasm_i_and(p, ptep, scratch, ptep);
1056                uasm_i_mthc0(p, tmp, C0_ENTRYLO0);
1057                uasm_i_mthc0(p, ptep, C0_ENTRYLO1);
1058#endif
1059                return;
1060        }
1061
1062        UASM_i_LW(p, tmp, 0, ptep); /* get even pte */
1063        UASM_i_LW(p, ptep, sizeof(pte_t), ptep); /* get odd pte */
1064        if (r45k_bvahwbug())
1065                build_tlb_probe_entry(p);
1066        build_convert_pte_to_entrylo(p, tmp);
1067        if (r4k_250MHZhwbug())
1068                UASM_i_MTC0(p, 0, C0_ENTRYLO0);
1069        UASM_i_MTC0(p, tmp, C0_ENTRYLO0); /* load it */
1070        build_convert_pte_to_entrylo(p, ptep);
1071        if (r45k_bvahwbug())
1072                uasm_i_mfc0(p, tmp, C0_INDEX);
1073        if (r4k_250MHZhwbug())
1074                UASM_i_MTC0(p, 0, C0_ENTRYLO1);
1075        UASM_i_MTC0(p, ptep, C0_ENTRYLO1); /* load it */
1076}
1077
1078struct mips_huge_tlb_info {
1079        int huge_pte;
1080        int restore_scratch;
1081        bool need_reload_pte;
1082};
1083
1084static struct mips_huge_tlb_info
1085build_fast_tlb_refill_handler (u32 **p, struct uasm_label **l,
1086                               struct uasm_reloc **r, unsigned int tmp,
1087                               unsigned int ptr, int c0_scratch_reg)
1088{
1089        struct mips_huge_tlb_info rv;
1090        unsigned int even, odd;
1091        int vmalloc_branch_delay_filled = 0;
1092        const int scratch = 1; /* Our extra working register */
1093
1094        rv.huge_pte = scratch;
1095        rv.restore_scratch = 0;
1096        rv.need_reload_pte = false;
1097
1098        if (check_for_high_segbits) {
1099                UASM_i_MFC0(p, tmp, C0_BADVADDR);
1100
1101                if (pgd_reg != -1)
1102                        UASM_i_MFC0(p, ptr, c0_kscratch(), pgd_reg);
1103                else
1104                        UASM_i_MFC0(p, ptr, C0_CONTEXT);
1105
1106                if (c0_scratch_reg >= 0)
1107                        UASM_i_MTC0(p, scratch, c0_kscratch(), c0_scratch_reg);
1108                else
1109                        UASM_i_SW(p, scratch, scratchpad_offset(0), 0);
1110
1111                uasm_i_dsrl_safe(p, scratch, tmp,
1112                                 PGDIR_SHIFT + PGD_ORDER + PAGE_SHIFT - 3);
1113                uasm_il_bnez(p, r, scratch, label_vmalloc);
1114
1115                if (pgd_reg == -1) {
1116                        vmalloc_branch_delay_filled = 1;
1117                        /* Clear lower 23 bits of context. */
1118                        uasm_i_dins(p, ptr, 0, 0, 23);
1119                }
1120        } else {
1121                if (pgd_reg != -1)
1122                        UASM_i_MFC0(p, ptr, c0_kscratch(), pgd_reg);
1123                else
1124                        UASM_i_MFC0(p, ptr, C0_CONTEXT);
1125
1126                UASM_i_MFC0(p, tmp, C0_BADVADDR);
1127
1128                if (c0_scratch_reg >= 0)
1129                        UASM_i_MTC0(p, scratch, c0_kscratch(), c0_scratch_reg);
1130                else
1131                        UASM_i_SW(p, scratch, scratchpad_offset(0), 0);
1132
1133                if (pgd_reg == -1)
1134                        /* Clear lower 23 bits of context. */
1135                        uasm_i_dins(p, ptr, 0, 0, 23);
1136
1137                uasm_il_bltz(p, r, tmp, label_vmalloc);
1138        }
1139
1140        if (pgd_reg == -1) {
1141                vmalloc_branch_delay_filled = 1;
1142                /* 1 0  1 0 1  << 6  xkphys cached */
1143                uasm_i_ori(p, ptr, ptr, 0x540);
1144                uasm_i_drotr(p, ptr, ptr, 11);
1145        }
1146
1147#ifdef __PAGETABLE_PMD_FOLDED
1148#define LOC_PTEP scratch
1149#else
1150#define LOC_PTEP ptr
1151#endif
1152
1153        if (!vmalloc_branch_delay_filled)
1154                /* get pgd offset in bytes */
1155                uasm_i_dsrl_safe(p, scratch, tmp, PGDIR_SHIFT - 3);
1156
1157        uasm_l_vmalloc_done(l, *p);
1158
1159        /*
1160         *                         tmp          ptr
1161         * fall-through case =   badvaddr  *pgd_current
1162         * vmalloc case      =   badvaddr  swapper_pg_dir
1163         */
1164
1165        if (vmalloc_branch_delay_filled)
1166                /* get pgd offset in bytes */
1167                uasm_i_dsrl_safe(p, scratch, tmp, PGDIR_SHIFT - 3);
1168
1169#ifdef __PAGETABLE_PMD_FOLDED
1170        GET_CONTEXT(p, tmp); /* get context reg */
1171#endif
1172        uasm_i_andi(p, scratch, scratch, (PTRS_PER_PGD - 1) << 3);
1173
1174        if (use_lwx_insns()) {
1175                UASM_i_LWX(p, LOC_PTEP, scratch, ptr);
1176        } else {
1177                uasm_i_daddu(p, ptr, ptr, scratch); /* add in pgd offset */
1178                uasm_i_ld(p, LOC_PTEP, 0, ptr); /* get pmd pointer */
1179        }
1180
1181#ifndef __PAGETABLE_PMD_FOLDED
1182        /* get pmd offset in bytes */
1183        uasm_i_dsrl_safe(p, scratch, tmp, PMD_SHIFT - 3);
1184        uasm_i_andi(p, scratch, scratch, (PTRS_PER_PMD - 1) << 3);
1185        GET_CONTEXT(p, tmp); /* get context reg */
1186
1187        if (use_lwx_insns()) {
1188                UASM_i_LWX(p, scratch, scratch, ptr);
1189        } else {
1190                uasm_i_daddu(p, ptr, ptr, scratch); /* add in pmd offset */
1191                UASM_i_LW(p, scratch, 0, ptr);
1192        }
1193#endif
1194        /* Adjust the context during the load latency. */
1195        build_adjust_context(p, tmp);
1196
1197#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
1198        uasm_il_bbit1(p, r, scratch, ilog2(_PAGE_HUGE), label_tlb_huge_update);
1199        /*
1200         * The in the LWX case we don't want to do the load in the
1201         * delay slot.  It cannot issue in the same cycle and may be
1202         * speculative and unneeded.
1203         */
1204        if (use_lwx_insns())
1205                uasm_i_nop(p);
1206#endif /* CONFIG_MIPS_HUGE_TLB_SUPPORT */
1207
1208
1209        /* build_update_entries */
1210        if (use_lwx_insns()) {
1211                even = ptr;
1212                odd = tmp;
1213                UASM_i_LWX(p, even, scratch, tmp);
1214                UASM_i_ADDIU(p, tmp, tmp, sizeof(pte_t));
1215                UASM_i_LWX(p, odd, scratch, tmp);
1216        } else {
1217                UASM_i_ADDU(p, ptr, scratch, tmp); /* add in offset */
1218                even = tmp;
1219                odd = ptr;
1220                UASM_i_LW(p, even, 0, ptr); /* get even pte */
1221                UASM_i_LW(p, odd, sizeof(pte_t), ptr); /* get odd pte */
1222        }
1223        if (cpu_has_rixi) {
1224                uasm_i_drotr(p, even, even, ilog2(_PAGE_GLOBAL));
1225                UASM_i_MTC0(p, even, C0_ENTRYLO0); /* load it */
1226                uasm_i_drotr(p, odd, odd, ilog2(_PAGE_GLOBAL));
1227        } else {
1228                uasm_i_dsrl_safe(p, even, even, ilog2(_PAGE_GLOBAL));
1229                UASM_i_MTC0(p, even, C0_ENTRYLO0); /* load it */
1230                uasm_i_dsrl_safe(p, odd, odd, ilog2(_PAGE_GLOBAL));
1231        }
1232        UASM_i_MTC0(p, odd, C0_ENTRYLO1); /* load it */
1233
1234        if (c0_scratch_reg >= 0) {
1235                UASM_i_MFC0(p, scratch, c0_kscratch(), c0_scratch_reg);
1236                build_tlb_write_entry(p, l, r, tlb_random);
1237                uasm_l_leave(l, *p);
1238                rv.restore_scratch = 1;
1239        } else if (PAGE_SHIFT == 14 || PAGE_SHIFT == 13)  {
1240                build_tlb_write_entry(p, l, r, tlb_random);
1241                uasm_l_leave(l, *p);
1242                UASM_i_LW(p, scratch, scratchpad_offset(0), 0);
1243        } else {
1244                UASM_i_LW(p, scratch, scratchpad_offset(0), 0);
1245                build_tlb_write_entry(p, l, r, tlb_random);
1246                uasm_l_leave(l, *p);
1247                rv.restore_scratch = 1;
1248        }
1249
1250        uasm_i_eret(p); /* return from trap */
1251
1252        return rv;
1253}
1254
1255/*
1256 * For a 64-bit kernel, we are using the 64-bit XTLB refill exception
1257 * because EXL == 0.  If we wrap, we can also use the 32 instruction
1258 * slots before the XTLB refill exception handler which belong to the
1259 * unused TLB refill exception.
1260 */
1261#define MIPS64_REFILL_INSNS 32
1262
1263static void build_r4000_tlb_refill_handler(void)
1264{
1265        u32 *p = tlb_handler;
1266        struct uasm_label *l = labels;
1267        struct uasm_reloc *r = relocs;
1268        u32 *f;
1269        unsigned int final_len;
1270        struct mips_huge_tlb_info htlb_info __maybe_unused;
1271        enum vmalloc64_mode vmalloc_mode __maybe_unused;
1272
1273        memset(tlb_handler, 0, sizeof(tlb_handler));
1274        memset(labels, 0, sizeof(labels));
1275        memset(relocs, 0, sizeof(relocs));
1276        memset(final_handler, 0, sizeof(final_handler));
1277
1278        if (IS_ENABLED(CONFIG_64BIT) && (scratch_reg >= 0 || scratchpad_available()) && use_bbit_insns()) {
1279                htlb_info = build_fast_tlb_refill_handler(&p, &l, &r, K0, K1,
1280                                                          scratch_reg);
1281                vmalloc_mode = refill_scratch;
1282        } else {
1283                htlb_info.huge_pte = K0;
1284                htlb_info.restore_scratch = 0;
1285                htlb_info.need_reload_pte = true;
1286                vmalloc_mode = refill_noscratch;
1287                /*
1288                 * create the plain linear handler
1289                 */
1290                if (bcm1250_m3_war()) {
1291                        unsigned int segbits = 44;
1292
1293                        uasm_i_dmfc0(&p, K0, C0_BADVADDR);
1294                        uasm_i_dmfc0(&p, K1, C0_ENTRYHI);
1295                        uasm_i_xor(&p, K0, K0, K1);
1296                        uasm_i_dsrl_safe(&p, K1, K0, 62);
1297                        uasm_i_dsrl_safe(&p, K0, K0, 12 + 1);
1298                        uasm_i_dsll_safe(&p, K0, K0, 64 + 12 + 1 - segbits);
1299                        uasm_i_or(&p, K0, K0, K1);
1300                        uasm_il_bnez(&p, &r, K0, label_leave);
1301                        /* No need for uasm_i_nop */
1302                }
1303
1304#ifdef CONFIG_64BIT
1305                build_get_pmde64(&p, &l, &r, K0, K1); /* get pmd in K1 */
1306#else
1307# ifdef CONFIG_BCM47XX
1308                uasm_i_nop(&p);
1309# endif
1310                build_get_pgde32(&p, K0, K1); /* get pgd in K1 */
1311#endif
1312
1313#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
1314                build_is_huge_pte(&p, &r, K0, K1, label_tlb_huge_update);
1315#endif
1316
1317                build_get_ptep(&p, K0, K1);
1318                build_update_entries(&p, K0, K1);
1319                build_tlb_write_entry(&p, &l, &r, tlb_random);
1320                uasm_l_leave(&l, p);
1321#ifdef CONFIG_BCM47XX
1322                uasm_i_nop(&p);
1323#endif
1324                uasm_i_eret(&p); /* return from trap */
1325        }
1326#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
1327        uasm_l_tlb_huge_update(&l, p);
1328        if (htlb_info.need_reload_pte)
1329                UASM_i_LW(&p, htlb_info.huge_pte, 0, K1);
1330        build_huge_update_entries(&p, htlb_info.huge_pte, K1);
1331        build_huge_tlb_write_entry(&p, &l, &r, K0, tlb_random,
1332                                   htlb_info.restore_scratch);
1333#endif
1334
1335#ifdef CONFIG_64BIT
1336        build_get_pgd_vmalloc64(&p, &l, &r, K0, K1, vmalloc_mode);
1337#endif
1338
1339        /*
1340         * Overflow check: For the 64bit handler, we need at least one
1341         * free instruction slot for the wrap-around branch. In worst
1342         * case, if the intended insertion point is a delay slot, we
1343         * need three, with the second nop'ed and the third being
1344         * unused.
1345         */
1346        switch (boot_cpu_type()) {
1347        default:
1348                if (sizeof(long) == 4) {
1349        case CPU_LOONGSON2:
1350                /* Loongson2 ebase is different than r4k, we have more space */
1351                        if ((p - tlb_handler) > 64)
1352                                panic("TLB refill handler space exceeded");
1353                        /*
1354                         * Now fold the handler in the TLB refill handler space.
1355                         */
1356                        f = final_handler;
1357                        /* Simplest case, just copy the handler. */
1358                        uasm_copy_handler(relocs, labels, tlb_handler, p, f);
1359                        final_len = p - tlb_handler;
1360                        break;
1361                } else {
1362                        if (((p - tlb_handler) > (MIPS64_REFILL_INSNS * 2) - 1)
1363                            || (((p - tlb_handler) > (MIPS64_REFILL_INSNS * 2) - 3)
1364                                && uasm_insn_has_bdelay(relocs,
1365                                                        tlb_handler + MIPS64_REFILL_INSNS - 3)))
1366                                panic("TLB refill handler space exceeded");
1367                        /*
1368                         * Now fold the handler in the TLB refill handler space.
1369                         */
1370                        f = final_handler + MIPS64_REFILL_INSNS;
1371                        if ((p - tlb_handler) <= MIPS64_REFILL_INSNS) {
1372                                /* Just copy the handler. */
1373                                uasm_copy_handler(relocs, labels, tlb_handler, p, f);
1374                                final_len = p - tlb_handler;
1375                        } else {
1376#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
1377                                const enum label_id ls = label_tlb_huge_update;
1378#else
1379                                const enum label_id ls = label_vmalloc;
1380#endif
1381                                u32 *split;
1382                                int ov = 0;
1383                                int i;
1384
1385                                for (i = 0; i < ARRAY_SIZE(labels) && labels[i].lab != ls; i++)
1386                                        ;
1387                                BUG_ON(i == ARRAY_SIZE(labels));
1388                                split = labels[i].addr;
1389
1390                                /*
1391                                 * See if we have overflown one way or the other.
1392                                 */
1393                                if (split > tlb_handler + MIPS64_REFILL_INSNS ||
1394                                    split < p - MIPS64_REFILL_INSNS)
1395                                        ov = 1;
1396
1397                                if (ov) {
1398                                        /*
1399                                         * Split two instructions before the end.  One
1400                                         * for the branch and one for the instruction
1401                                         * in the delay slot.
1402                                         */
1403                                        split = tlb_handler + MIPS64_REFILL_INSNS - 2;
1404
1405                                        /*
1406                                         * If the branch would fall in a delay slot,
1407                                         * we must back up an additional instruction
1408                                         * so that it is no longer in a delay slot.
1409                                         */
1410                                        if (uasm_insn_has_bdelay(relocs, split - 1))
1411                                                split--;
1412                                }
1413                                /* Copy first part of the handler. */
1414                                uasm_copy_handler(relocs, labels, tlb_handler, split, f);
1415                                f += split - tlb_handler;
1416
1417                                if (ov) {
1418                                        /* Insert branch. */
1419                                        uasm_l_split(&l, final_handler);
1420                                        uasm_il_b(&f, &r, label_split);
1421                                        if (uasm_insn_has_bdelay(relocs, split))
1422                                                uasm_i_nop(&f);
1423                                        else {
1424                                                uasm_copy_handler(relocs, labels,
1425                                                                  split, split + 1, f);
1426                                                uasm_move_labels(labels, f, f + 1, -1);
1427                                                f++;
1428                                                split++;
1429                                        }
1430                                }
1431
1432                                /* Copy the rest of the handler. */
1433                                uasm_copy_handler(relocs, labels, split, p, final_handler);
1434                                final_len = (f - (final_handler + MIPS64_REFILL_INSNS)) +
1435                                            (p - split);
1436                        }
1437                }
1438                break;
1439        }
1440
1441        uasm_resolve_relocs(relocs, labels);
1442        pr_debug("Wrote TLB refill handler (%u instructions).\n",
1443                 final_len);
1444
1445        memcpy((void *)ebase, final_handler, 0x100);
1446        local_flush_icache_range(ebase, ebase + 0x100);
1447
1448        dump_handler("r4000_tlb_refill", (u32 *)ebase, 64);
1449}
1450
1451extern u32 handle_tlbl[], handle_tlbl_end[];
1452extern u32 handle_tlbs[], handle_tlbs_end[];
1453extern u32 handle_tlbm[], handle_tlbm_end[];
1454extern u32 tlbmiss_handler_setup_pgd_start[], tlbmiss_handler_setup_pgd[];
1455extern u32 tlbmiss_handler_setup_pgd_end[];
1456
1457static void build_setup_pgd(void)
1458{
1459        const int a0 = 4;
1460        const int __maybe_unused a1 = 5;
1461        const int __maybe_unused a2 = 6;
1462        u32 *p = tlbmiss_handler_setup_pgd_start;
1463        const int tlbmiss_handler_setup_pgd_size =
1464                tlbmiss_handler_setup_pgd_end - tlbmiss_handler_setup_pgd_start;
1465#ifndef CONFIG_MIPS_PGD_C0_CONTEXT
1466        long pgdc = (long)pgd_current;
1467#endif
1468
1469        memset(tlbmiss_handler_setup_pgd, 0, tlbmiss_handler_setup_pgd_size *
1470                                        sizeof(tlbmiss_handler_setup_pgd[0]));
1471        memset(labels, 0, sizeof(labels));
1472        memset(relocs, 0, sizeof(relocs));
1473        pgd_reg = allocate_kscratch();
1474#ifdef CONFIG_MIPS_PGD_C0_CONTEXT
1475        if (pgd_reg == -1) {
1476                struct uasm_label *l = labels;
1477                struct uasm_reloc *r = relocs;
1478
1479                /* PGD << 11 in c0_Context */
1480                /*
1481                 * If it is a ckseg0 address, convert to a physical
1482                 * address.  Shifting right by 29 and adding 4 will
1483                 * result in zero for these addresses.
1484                 *
1485                 */
1486                UASM_i_SRA(&p, a1, a0, 29);
1487                UASM_i_ADDIU(&p, a1, a1, 4);
1488                uasm_il_bnez(&p, &r, a1, label_tlbl_goaround1);
1489                uasm_i_nop(&p);
1490                uasm_i_dinsm(&p, a0, 0, 29, 64 - 29);
1491                uasm_l_tlbl_goaround1(&l, p);
1492                UASM_i_SLL(&p, a0, a0, 11);
1493                uasm_i_jr(&p, 31);
1494                UASM_i_MTC0(&p, a0, C0_CONTEXT);
1495        } else {
1496                /* PGD in c0_KScratch */
1497                uasm_i_jr(&p, 31);
1498                UASM_i_MTC0(&p, a0, c0_kscratch(), pgd_reg);
1499        }
1500#else
1501#ifdef CONFIG_SMP
1502        /* Save PGD to pgd_current[smp_processor_id()] */
1503        UASM_i_CPUID_MFC0(&p, a1, SMP_CPUID_REG);
1504        UASM_i_SRL_SAFE(&p, a1, a1, SMP_CPUID_PTRSHIFT);
1505        UASM_i_LA_mostly(&p, a2, pgdc);
1506        UASM_i_ADDU(&p, a2, a2, a1);
1507        UASM_i_SW(&p, a0, uasm_rel_lo(pgdc), a2);
1508#else
1509        UASM_i_LA_mostly(&p, a2, pgdc);
1510        UASM_i_SW(&p, a0, uasm_rel_lo(pgdc), a2);
1511#endif /* SMP */
1512        uasm_i_jr(&p, 31);
1513
1514        /* if pgd_reg is allocated, save PGD also to scratch register */
1515        if (pgd_reg != -1)
1516                UASM_i_MTC0(&p, a0, c0_kscratch(), pgd_reg);
1517        else
1518                uasm_i_nop(&p);
1519#endif
1520        if (p >= tlbmiss_handler_setup_pgd_end)
1521                panic("tlbmiss_handler_setup_pgd space exceeded");
1522
1523        uasm_resolve_relocs(relocs, labels);
1524        pr_debug("Wrote tlbmiss_handler_setup_pgd (%u instructions).\n",
1525                 (unsigned int)(p - tlbmiss_handler_setup_pgd));
1526
1527        dump_handler("tlbmiss_handler", tlbmiss_handler_setup_pgd,
1528                                        tlbmiss_handler_setup_pgd_size);
1529}
1530
1531static void
1532iPTE_LW(u32 **p, unsigned int pte, unsigned int ptr)
1533{
1534#ifdef CONFIG_SMP
1535# ifdef CONFIG_PHYS_ADDR_T_64BIT
1536        if (cpu_has_64bits)
1537                uasm_i_lld(p, pte, 0, ptr);
1538        else
1539# endif
1540                UASM_i_LL(p, pte, 0, ptr);
1541#else
1542# ifdef CONFIG_PHYS_ADDR_T_64BIT
1543        if (cpu_has_64bits)
1544                uasm_i_ld(p, pte, 0, ptr);
1545        else
1546# endif
1547                UASM_i_LW(p, pte, 0, ptr);
1548#endif
1549}
1550
1551static void
1552iPTE_SW(u32 **p, struct uasm_reloc **r, unsigned int pte, unsigned int ptr,
1553        unsigned int mode)
1554{
1555#ifdef CONFIG_PHYS_ADDR_T_64BIT
1556        unsigned int hwmode = mode & (_PAGE_VALID | _PAGE_DIRTY);
1557
1558        if (!cpu_has_64bits) {
1559                const int scratch = 1; /* Our extra working register */
1560
1561                uasm_i_lui(p, scratch, (mode >> 16));
1562                uasm_i_or(p, pte, pte, scratch);
1563        } else
1564#endif
1565        uasm_i_ori(p, pte, pte, mode);
1566#ifdef CONFIG_SMP
1567# ifdef CONFIG_PHYS_ADDR_T_64BIT
1568        if (cpu_has_64bits)
1569                uasm_i_scd(p, pte, 0, ptr);
1570        else
1571# endif
1572                UASM_i_SC(p, pte, 0, ptr);
1573
1574        if (r10000_llsc_war())
1575                uasm_il_beqzl(p, r, pte, label_smp_pgtable_change);
1576        else
1577                uasm_il_beqz(p, r, pte, label_smp_pgtable_change);
1578
1579# ifdef CONFIG_PHYS_ADDR_T_64BIT
1580        if (!cpu_has_64bits) {
1581                /* no uasm_i_nop needed */
1582                uasm_i_ll(p, pte, sizeof(pte_t) / 2, ptr);
1583                uasm_i_ori(p, pte, pte, hwmode);
1584                uasm_i_sc(p, pte, sizeof(pte_t) / 2, ptr);
1585                uasm_il_beqz(p, r, pte, label_smp_pgtable_change);
1586                /* no uasm_i_nop needed */
1587                uasm_i_lw(p, pte, 0, ptr);
1588        } else
1589                uasm_i_nop(p);
1590# else
1591        uasm_i_nop(p);
1592# endif
1593#else
1594# ifdef CONFIG_PHYS_ADDR_T_64BIT
1595        if (cpu_has_64bits)
1596                uasm_i_sd(p, pte, 0, ptr);
1597        else
1598# endif
1599                UASM_i_SW(p, pte, 0, ptr);
1600
1601# ifdef CONFIG_PHYS_ADDR_T_64BIT
1602        if (!cpu_has_64bits) {
1603                uasm_i_lw(p, pte, sizeof(pte_t) / 2, ptr);
1604                uasm_i_ori(p, pte, pte, hwmode);
1605                uasm_i_sw(p, pte, sizeof(pte_t) / 2, ptr);
1606                uasm_i_lw(p, pte, 0, ptr);
1607        }
1608# endif
1609#endif
1610}
1611
1612/*
1613 * Check if PTE is present, if not then jump to LABEL. PTR points to
1614 * the page table where this PTE is located, PTE will be re-loaded
1615 * with it's original value.
1616 */
1617static void
1618build_pte_present(u32 **p, struct uasm_reloc **r,
1619                  int pte, int ptr, int scratch, enum label_id lid)
1620{
1621        int t = scratch >= 0 ? scratch : pte;
1622        int cur = pte;
1623
1624        if (cpu_has_rixi) {
1625                if (use_bbit_insns()) {
1626                        uasm_il_bbit0(p, r, pte, ilog2(_PAGE_PRESENT), lid);
1627                        uasm_i_nop(p);
1628                } else {
1629                        if (_PAGE_PRESENT_SHIFT) {
1630                                uasm_i_srl(p, t, cur, _PAGE_PRESENT_SHIFT);
1631                                cur = t;
1632                        }
1633                        uasm_i_andi(p, t, cur, 1);
1634                        uasm_il_beqz(p, r, t, lid);
1635                        if (pte == t)
1636                                /* You lose the SMP race :-(*/
1637                                iPTE_LW(p, pte, ptr);
1638                }
1639        } else {
1640                if (_PAGE_PRESENT_SHIFT) {
1641                        uasm_i_srl(p, t, cur, _PAGE_PRESENT_SHIFT);
1642                        cur = t;
1643                }
1644                uasm_i_andi(p, t, cur,
1645                        (_PAGE_PRESENT | _PAGE_READ) >> _PAGE_PRESENT_SHIFT);
1646                uasm_i_xori(p, t, t,
1647                        (_PAGE_PRESENT | _PAGE_READ) >> _PAGE_PRESENT_SHIFT);
1648                uasm_il_bnez(p, r, t, lid);
1649                if (pte == t)
1650                        /* You lose the SMP race :-(*/
1651                        iPTE_LW(p, pte, ptr);
1652        }
1653}
1654
1655/* Make PTE valid, store result in PTR. */
1656static void
1657build_make_valid(u32 **p, struct uasm_reloc **r, unsigned int pte,
1658                 unsigned int ptr)
1659{
1660        unsigned int mode = _PAGE_VALID | _PAGE_ACCESSED;
1661
1662        iPTE_SW(p, r, pte, ptr, mode);
1663}
1664
1665/*
1666 * Check if PTE can be written to, if not branch to LABEL. Regardless
1667 * restore PTE with value from PTR when done.
1668 */
1669static void
1670build_pte_writable(u32 **p, struct uasm_reloc **r,
1671                   unsigned int pte, unsigned int ptr, int scratch,
1672                   enum label_id lid)
1673{
1674        int t = scratch >= 0 ? scratch : pte;
1675        int cur = pte;
1676
1677        if (_PAGE_PRESENT_SHIFT) {
1678                uasm_i_srl(p, t, cur, _PAGE_PRESENT_SHIFT);
1679                cur = t;
1680        }
1681        uasm_i_andi(p, t, cur,
1682                    (_PAGE_PRESENT | _PAGE_WRITE) >> _PAGE_PRESENT_SHIFT);
1683        uasm_i_xori(p, t, t,
1684                    (_PAGE_PRESENT | _PAGE_WRITE) >> _PAGE_PRESENT_SHIFT);
1685        uasm_il_bnez(p, r, t, lid);
1686        if (pte == t)
1687                /* You lose the SMP race :-(*/
1688                iPTE_LW(p, pte, ptr);
1689        else
1690                uasm_i_nop(p);
1691}
1692
1693/* Make PTE writable, update software status bits as well, then store
1694 * at PTR.
1695 */
1696static void
1697build_make_write(u32 **p, struct uasm_reloc **r, unsigned int pte,
1698                 unsigned int ptr)
1699{
1700        unsigned int mode = (_PAGE_ACCESSED | _PAGE_MODIFIED | _PAGE_VALID
1701                             | _PAGE_DIRTY);
1702
1703        iPTE_SW(p, r, pte, ptr, mode);
1704}
1705
1706/*
1707 * Check if PTE can be modified, if not branch to LABEL. Regardless
1708 * restore PTE with value from PTR when done.
1709 */
1710static void
1711build_pte_modifiable(u32 **p, struct uasm_reloc **r,
1712                     unsigned int pte, unsigned int ptr, int scratch,
1713                     enum label_id lid)
1714{
1715        if (use_bbit_insns()) {
1716                uasm_il_bbit0(p, r, pte, ilog2(_PAGE_WRITE), lid);
1717                uasm_i_nop(p);
1718        } else {
1719                int t = scratch >= 0 ? scratch : pte;
1720                uasm_i_srl(p, t, pte, _PAGE_WRITE_SHIFT);
1721                uasm_i_andi(p, t, t, 1);
1722                uasm_il_beqz(p, r, t, lid);
1723                if (pte == t)
1724                        /* You lose the SMP race :-(*/
1725                        iPTE_LW(p, pte, ptr);
1726        }
1727}
1728
1729#ifndef CONFIG_MIPS_PGD_C0_CONTEXT
1730
1731
1732/*
1733 * R3000 style TLB load/store/modify handlers.
1734 */
1735
1736/*
1737 * This places the pte into ENTRYLO0 and writes it with tlbwi.
1738 * Then it returns.
1739 */
1740static void
1741build_r3000_pte_reload_tlbwi(u32 **p, unsigned int pte, unsigned int tmp)
1742{
1743        uasm_i_mtc0(p, pte, C0_ENTRYLO0); /* cp0 delay */
1744        uasm_i_mfc0(p, tmp, C0_EPC); /* cp0 delay */
1745        uasm_i_tlbwi(p);
1746        uasm_i_jr(p, tmp);
1747        uasm_i_rfe(p); /* branch delay */
1748}
1749
1750/*
1751 * This places the pte into ENTRYLO0 and writes it with tlbwi
1752 * or tlbwr as appropriate.  This is because the index register
1753 * may have the probe fail bit set as a result of a trap on a
1754 * kseg2 access, i.e. without refill.  Then it returns.
1755 */
1756static void
1757build_r3000_tlb_reload_write(u32 **p, struct uasm_label **l,
1758                             struct uasm_reloc **r, unsigned int pte,
1759                             unsigned int tmp)
1760{
1761        uasm_i_mfc0(p, tmp, C0_INDEX);
1762        uasm_i_mtc0(p, pte, C0_ENTRYLO0); /* cp0 delay */
1763        uasm_il_bltz(p, r, tmp, label_r3000_write_probe_fail); /* cp0 delay */
1764        uasm_i_mfc0(p, tmp, C0_EPC); /* branch delay */
1765        uasm_i_tlbwi(p); /* cp0 delay */
1766        uasm_i_jr(p, tmp);
1767        uasm_i_rfe(p); /* branch delay */
1768        uasm_l_r3000_write_probe_fail(l, *p);
1769        uasm_i_tlbwr(p); /* cp0 delay */
1770        uasm_i_jr(p, tmp);
1771        uasm_i_rfe(p); /* branch delay */
1772}
1773
1774static void
1775build_r3000_tlbchange_handler_head(u32 **p, unsigned int pte,
1776                                   unsigned int ptr)
1777{
1778        long pgdc = (long)pgd_current;
1779
1780        uasm_i_mfc0(p, pte, C0_BADVADDR);
1781        uasm_i_lui(p, ptr, uasm_rel_hi(pgdc)); /* cp0 delay */
1782        uasm_i_lw(p, ptr, uasm_rel_lo(pgdc), ptr);
1783        uasm_i_srl(p, pte, pte, 22); /* load delay */
1784        uasm_i_sll(p, pte, pte, 2);
1785        uasm_i_addu(p, ptr, ptr, pte);
1786        uasm_i_mfc0(p, pte, C0_CONTEXT);
1787        uasm_i_lw(p, ptr, 0, ptr); /* cp0 delay */
1788        uasm_i_andi(p, pte, pte, 0xffc); /* load delay */
1789        uasm_i_addu(p, ptr, ptr, pte);
1790        uasm_i_lw(p, pte, 0, ptr);
1791        uasm_i_tlbp(p); /* load delay */
1792}
1793
1794static void build_r3000_tlb_load_handler(void)
1795{
1796        u32 *p = handle_tlbl;
1797        const int handle_tlbl_size = handle_tlbl_end - handle_tlbl;
1798        struct uasm_label *l = labels;
1799        struct uasm_reloc *r = relocs;
1800
1801        memset(handle_tlbl, 0, handle_tlbl_size * sizeof(handle_tlbl[0]));
1802        memset(labels, 0, sizeof(labels));
1803        memset(relocs, 0, sizeof(relocs));
1804
1805        build_r3000_tlbchange_handler_head(&p, K0, K1);
1806        build_pte_present(&p, &r, K0, K1, -1, label_nopage_tlbl);
1807        uasm_i_nop(&p); /* load delay */
1808        build_make_valid(&p, &r, K0, K1);
1809        build_r3000_tlb_reload_write(&p, &l, &r, K0, K1);
1810
1811        uasm_l_nopage_tlbl(&l, p);
1812        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_0 & 0x0fffffff);
1813        uasm_i_nop(&p);
1814
1815        if (p >= handle_tlbl_end)
1816                panic("TLB load handler fastpath space exceeded");
1817
1818        uasm_resolve_relocs(relocs, labels);
1819        pr_debug("Wrote TLB load handler fastpath (%u instructions).\n",
1820                 (unsigned int)(p - handle_tlbl));
1821
1822        dump_handler("r3000_tlb_load", handle_tlbl, handle_tlbl_size);
1823}
1824
1825static void build_r3000_tlb_store_handler(void)
1826{
1827        u32 *p = handle_tlbs;
1828        const int handle_tlbs_size = handle_tlbs_end - handle_tlbs;
1829        struct uasm_label *l = labels;
1830        struct uasm_reloc *r = relocs;
1831
1832        memset(handle_tlbs, 0, handle_tlbs_size * sizeof(handle_tlbs[0]));
1833        memset(labels, 0, sizeof(labels));
1834        memset(relocs, 0, sizeof(relocs));
1835
1836        build_r3000_tlbchange_handler_head(&p, K0, K1);
1837        build_pte_writable(&p, &r, K0, K1, -1, label_nopage_tlbs);
1838        uasm_i_nop(&p); /* load delay */
1839        build_make_write(&p, &r, K0, K1);
1840        build_r3000_tlb_reload_write(&p, &l, &r, K0, K1);
1841
1842        uasm_l_nopage_tlbs(&l, p);
1843        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
1844        uasm_i_nop(&p);
1845
1846        if (p >= handle_tlbs_end)
1847                panic("TLB store handler fastpath space exceeded");
1848
1849        uasm_resolve_relocs(relocs, labels);
1850        pr_debug("Wrote TLB store handler fastpath (%u instructions).\n",
1851                 (unsigned int)(p - handle_tlbs));
1852
1853        dump_handler("r3000_tlb_store", handle_tlbs, handle_tlbs_size);
1854}
1855
1856static void build_r3000_tlb_modify_handler(void)
1857{
1858        u32 *p = handle_tlbm;
1859        const int handle_tlbm_size = handle_tlbm_end - handle_tlbm;
1860        struct uasm_label *l = labels;
1861        struct uasm_reloc *r = relocs;
1862
1863        memset(handle_tlbm, 0, handle_tlbm_size * sizeof(handle_tlbm[0]));
1864        memset(labels, 0, sizeof(labels));
1865        memset(relocs, 0, sizeof(relocs));
1866
1867        build_r3000_tlbchange_handler_head(&p, K0, K1);
1868        build_pte_modifiable(&p, &r, K0, K1,  -1, label_nopage_tlbm);
1869        uasm_i_nop(&p); /* load delay */
1870        build_make_write(&p, &r, K0, K1);
1871        build_r3000_pte_reload_tlbwi(&p, K0, K1);
1872
1873        uasm_l_nopage_tlbm(&l, p);
1874        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
1875        uasm_i_nop(&p);
1876
1877        if (p >= handle_tlbm_end)
1878                panic("TLB modify handler fastpath space exceeded");
1879
1880        uasm_resolve_relocs(relocs, labels);
1881        pr_debug("Wrote TLB modify handler fastpath (%u instructions).\n",
1882                 (unsigned int)(p - handle_tlbm));
1883
1884        dump_handler("r3000_tlb_modify", handle_tlbm, handle_tlbm_size);
1885}
1886#endif /* CONFIG_MIPS_PGD_C0_CONTEXT */
1887
1888/*
1889 * R4000 style TLB load/store/modify handlers.
1890 */
1891static struct work_registers
1892build_r4000_tlbchange_handler_head(u32 **p, struct uasm_label **l,
1893                                   struct uasm_reloc **r)
1894{
1895        struct work_registers wr = build_get_work_registers(p);
1896
1897#ifdef CONFIG_64BIT
1898        build_get_pmde64(p, l, r, wr.r1, wr.r2); /* get pmd in ptr */
1899#else
1900# ifdef CONFIG_BCM47XX
1901        uasm_i_nop(p);
1902# endif
1903        build_get_pgde32(p, wr.r1, wr.r2); /* get pgd in ptr */
1904#endif
1905
1906#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
1907        /*
1908         * For huge tlb entries, pmd doesn't contain an address but
1909         * instead contains the tlb pte. Check the PAGE_HUGE bit and
1910         * see if we need to jump to huge tlb processing.
1911         */
1912        build_is_huge_pte(p, r, wr.r1, wr.r2, label_tlb_huge_update);
1913#endif
1914
1915        UASM_i_MFC0(p, wr.r1, C0_BADVADDR);
1916        UASM_i_LW(p, wr.r2, 0, wr.r2);
1917        UASM_i_SRL(p, wr.r1, wr.r1, PAGE_SHIFT + PTE_ORDER - PTE_T_LOG2);
1918        uasm_i_andi(p, wr.r1, wr.r1, (PTRS_PER_PTE - 1) << PTE_T_LOG2);
1919        UASM_i_ADDU(p, wr.r2, wr.r2, wr.r1);
1920
1921#ifdef CONFIG_SMP
1922        uasm_l_smp_pgtable_change(l, *p);
1923#endif
1924        iPTE_LW(p, wr.r1, wr.r2); /* get even pte */
1925        if (!m4kc_tlbp_war()) {
1926                build_tlb_probe_entry(p);
1927                if (cpu_has_htw) {
1928                        /* race condition happens, leaving */
1929                        uasm_i_ehb(p);
1930                        uasm_i_mfc0(p, wr.r3, C0_INDEX);
1931                        uasm_il_bltz(p, r, wr.r3, label_leave);
1932                        uasm_i_nop(p);
1933                }
1934        }
1935        return wr;
1936}
1937
1938static void
1939build_r4000_tlbchange_handler_tail(u32 **p, struct uasm_label **l,
1940                                   struct uasm_reloc **r, unsigned int tmp,
1941                                   unsigned int ptr)
1942{
1943        uasm_i_ori(p, ptr, ptr, sizeof(pte_t));
1944        uasm_i_xori(p, ptr, ptr, sizeof(pte_t));
1945        build_update_entries(p, tmp, ptr);
1946        build_tlb_write_entry(p, l, r, tlb_indexed);
1947        uasm_l_leave(l, *p);
1948        build_restore_work_registers(p);
1949#ifdef CONFIG_BCM47XX
1950        uasm_i_nop(p);
1951#endif
1952        uasm_i_eret(p); /* return from trap */
1953
1954#ifdef CONFIG_64BIT
1955        build_get_pgd_vmalloc64(p, l, r, tmp, ptr, not_refill);
1956#endif
1957}
1958
1959static void build_r4000_tlb_load_handler(void)
1960{
1961        u32 *p = handle_tlbl;
1962        const int handle_tlbl_size = handle_tlbl_end - handle_tlbl;
1963        struct uasm_label *l = labels;
1964        struct uasm_reloc *r = relocs;
1965        struct work_registers wr;
1966
1967        memset(handle_tlbl, 0, handle_tlbl_size * sizeof(handle_tlbl[0]));
1968        memset(labels, 0, sizeof(labels));
1969        memset(relocs, 0, sizeof(relocs));
1970
1971        if (bcm1250_m3_war()) {
1972                unsigned int segbits = 44;
1973
1974                uasm_i_dmfc0(&p, K0, C0_BADVADDR);
1975                uasm_i_dmfc0(&p, K1, C0_ENTRYHI);
1976                uasm_i_xor(&p, K0, K0, K1);
1977                uasm_i_dsrl_safe(&p, K1, K0, 62);
1978                uasm_i_dsrl_safe(&p, K0, K0, 12 + 1);
1979                uasm_i_dsll_safe(&p, K0, K0, 64 + 12 + 1 - segbits);
1980                uasm_i_or(&p, K0, K0, K1);
1981                uasm_il_bnez(&p, &r, K0, label_leave);
1982                /* No need for uasm_i_nop */
1983        }
1984
1985        wr = build_r4000_tlbchange_handler_head(&p, &l, &r);
1986        build_pte_present(&p, &r, wr.r1, wr.r2, wr.r3, label_nopage_tlbl);
1987        if (m4kc_tlbp_war())
1988                build_tlb_probe_entry(&p);
1989
1990        if (cpu_has_rixi && !cpu_has_rixiex) {
1991                /*
1992                 * If the page is not _PAGE_VALID, RI or XI could not
1993                 * have triggered it.  Skip the expensive test..
1994                 */
1995                if (use_bbit_insns()) {
1996                        uasm_il_bbit0(&p, &r, wr.r1, ilog2(_PAGE_VALID),
1997                                      label_tlbl_goaround1);
1998                } else {
1999                        uasm_i_andi(&p, wr.r3, wr.r1, _PAGE_VALID);
2000                        uasm_il_beqz(&p, &r, wr.r3, label_tlbl_goaround1);
2001                }
2002                uasm_i_nop(&p);
2003
2004                uasm_i_tlbr(&p);
2005
2006                switch (current_cpu_type()) {
2007                default:
2008                        if (cpu_has_mips_r2_exec_hazard) {
2009                                uasm_i_ehb(&p);
2010
2011                case CPU_CAVIUM_OCTEON:
2012                case CPU_CAVIUM_OCTEON_PLUS:
2013                case CPU_CAVIUM_OCTEON2:
2014                                break;
2015                        }
2016                }
2017
2018                /* Examine  entrylo 0 or 1 based on ptr. */
2019                if (use_bbit_insns()) {
2020                        uasm_i_bbit0(&p, wr.r2, ilog2(sizeof(pte_t)), 8);
2021                } else {
2022                        uasm_i_andi(&p, wr.r3, wr.r2, sizeof(pte_t));
2023                        uasm_i_beqz(&p, wr.r3, 8);
2024                }
2025                /* load it in the delay slot*/
2026                UASM_i_MFC0(&p, wr.r3, C0_ENTRYLO0);
2027                /* load it if ptr is odd */
2028                UASM_i_MFC0(&p, wr.r3, C0_ENTRYLO1);
2029                /*
2030                 * If the entryLo (now in wr.r3) is valid (bit 1), RI or
2031                 * XI must have triggered it.
2032                 */
2033                if (use_bbit_insns()) {
2034                        uasm_il_bbit1(&p, &r, wr.r3, 1, label_nopage_tlbl);
2035                        uasm_i_nop(&p);
2036                        uasm_l_tlbl_goaround1(&l, p);
2037                } else {
2038                        uasm_i_andi(&p, wr.r3, wr.r3, 2);
2039                        uasm_il_bnez(&p, &r, wr.r3, label_nopage_tlbl);
2040                        uasm_i_nop(&p);
2041                }
2042                uasm_l_tlbl_goaround1(&l, p);
2043        }
2044        build_make_valid(&p, &r, wr.r1, wr.r2);
2045        build_r4000_tlbchange_handler_tail(&p, &l, &r, wr.r1, wr.r2);
2046
2047#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
2048        /*
2049         * This is the entry point when build_r4000_tlbchange_handler_head
2050         * spots a huge page.
2051         */
2052        uasm_l_tlb_huge_update(&l, p);
2053        iPTE_LW(&p, wr.r1, wr.r2);
2054        build_pte_present(&p, &r, wr.r1, wr.r2, wr.r3, label_nopage_tlbl);
2055        build_tlb_probe_entry(&p);
2056
2057        if (cpu_has_rixi && !cpu_has_rixiex) {
2058                /*
2059                 * If the page is not _PAGE_VALID, RI or XI could not
2060                 * have triggered it.  Skip the expensive test..
2061                 */
2062                if (use_bbit_insns()) {
2063                        uasm_il_bbit0(&p, &r, wr.r1, ilog2(_PAGE_VALID),
2064                                      label_tlbl_goaround2);
2065                } else {
2066                        uasm_i_andi(&p, wr.r3, wr.r1, _PAGE_VALID);
2067                        uasm_il_beqz(&p, &r, wr.r3, label_tlbl_goaround2);
2068                }
2069                uasm_i_nop(&p);
2070
2071                uasm_i_tlbr(&p);
2072
2073                switch (current_cpu_type()) {
2074                default:
2075                        if (cpu_has_mips_r2_exec_hazard) {
2076                                uasm_i_ehb(&p);
2077
2078                case CPU_CAVIUM_OCTEON:
2079                case CPU_CAVIUM_OCTEON_PLUS:
2080                case CPU_CAVIUM_OCTEON2:
2081                                break;
2082                        }
2083                }
2084
2085                /* Examine  entrylo 0 or 1 based on ptr. */
2086                if (use_bbit_insns()) {
2087                        uasm_i_bbit0(&p, wr.r2, ilog2(sizeof(pte_t)), 8);
2088                } else {
2089                        uasm_i_andi(&p, wr.r3, wr.r2, sizeof(pte_t));
2090                        uasm_i_beqz(&p, wr.r3, 8);
2091                }
2092                /* load it in the delay slot*/
2093                UASM_i_MFC0(&p, wr.r3, C0_ENTRYLO0);
2094                /* load it if ptr is odd */
2095                UASM_i_MFC0(&p, wr.r3, C0_ENTRYLO1);
2096                /*
2097                 * If the entryLo (now in wr.r3) is valid (bit 1), RI or
2098                 * XI must have triggered it.
2099                 */
2100                if (use_bbit_insns()) {
2101                        uasm_il_bbit0(&p, &r, wr.r3, 1, label_tlbl_goaround2);
2102                } else {
2103                        uasm_i_andi(&p, wr.r3, wr.r3, 2);
2104                        uasm_il_beqz(&p, &r, wr.r3, label_tlbl_goaround2);
2105                }
2106                if (PM_DEFAULT_MASK == 0)
2107                        uasm_i_nop(&p);
2108                /*
2109                 * We clobbered C0_PAGEMASK, restore it.  On the other branch
2110                 * it is restored in build_huge_tlb_write_entry.
2111                 */
2112                build_restore_pagemask(&p, &r, wr.r3, label_nopage_tlbl, 0);
2113
2114                uasm_l_tlbl_goaround2(&l, p);
2115        }
2116        uasm_i_ori(&p, wr.r1, wr.r1, (_PAGE_ACCESSED | _PAGE_VALID));
2117        build_huge_handler_tail(&p, &r, &l, wr.r1, wr.r2, 1);
2118#endif
2119
2120        uasm_l_nopage_tlbl(&l, p);
2121        build_restore_work_registers(&p);
2122#ifdef CONFIG_CPU_MICROMIPS
2123        if ((unsigned long)tlb_do_page_fault_0 & 1) {
2124                uasm_i_lui(&p, K0, uasm_rel_hi((long)tlb_do_page_fault_0));
2125                uasm_i_addiu(&p, K0, K0, uasm_rel_lo((long)tlb_do_page_fault_0));
2126                uasm_i_jr(&p, K0);
2127        } else
2128#endif
2129        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_0 & 0x0fffffff);
2130        uasm_i_nop(&p);
2131
2132        if (p >= handle_tlbl_end)
2133                panic("TLB load handler fastpath space exceeded");
2134
2135        uasm_resolve_relocs(relocs, labels);
2136        pr_debug("Wrote TLB load handler fastpath (%u instructions).\n",
2137                 (unsigned int)(p - handle_tlbl));
2138
2139        dump_handler("r4000_tlb_load", handle_tlbl, handle_tlbl_size);
2140}
2141
2142static void build_r4000_tlb_store_handler(void)
2143{
2144        u32 *p = handle_tlbs;
2145        const int handle_tlbs_size = handle_tlbs_end - handle_tlbs;
2146        struct uasm_label *l = labels;
2147        struct uasm_reloc *r = relocs;
2148        struct work_registers wr;
2149
2150        memset(handle_tlbs, 0, handle_tlbs_size * sizeof(handle_tlbs[0]));
2151        memset(labels, 0, sizeof(labels));
2152        memset(relocs, 0, sizeof(relocs));
2153
2154        wr = build_r4000_tlbchange_handler_head(&p, &l, &r);
2155        build_pte_writable(&p, &r, wr.r1, wr.r2, wr.r3, label_nopage_tlbs);
2156        if (m4kc_tlbp_war())
2157                build_tlb_probe_entry(&p);
2158        build_make_write(&p, &r, wr.r1, wr.r2);
2159        build_r4000_tlbchange_handler_tail(&p, &l, &r, wr.r1, wr.r2);
2160
2161#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
2162        /*
2163         * This is the entry point when
2164         * build_r4000_tlbchange_handler_head spots a huge page.
2165         */
2166        uasm_l_tlb_huge_update(&l, p);
2167        iPTE_LW(&p, wr.r1, wr.r2);
2168        build_pte_writable(&p, &r, wr.r1, wr.r2, wr.r3, label_nopage_tlbs);
2169        build_tlb_probe_entry(&p);
2170        uasm_i_ori(&p, wr.r1, wr.r1,
2171                   _PAGE_ACCESSED | _PAGE_MODIFIED | _PAGE_VALID | _PAGE_DIRTY);
2172        build_huge_handler_tail(&p, &r, &l, wr.r1, wr.r2, 1);
2173#endif
2174
2175        uasm_l_nopage_tlbs(&l, p);
2176        build_restore_work_registers(&p);
2177#ifdef CONFIG_CPU_MICROMIPS
2178        if ((unsigned long)tlb_do_page_fault_1 & 1) {
2179                uasm_i_lui(&p, K0, uasm_rel_hi((long)tlb_do_page_fault_1));
2180                uasm_i_addiu(&p, K0, K0, uasm_rel_lo((long)tlb_do_page_fault_1));
2181                uasm_i_jr(&p, K0);
2182        } else
2183#endif
2184        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
2185        uasm_i_nop(&p);
2186
2187        if (p >= handle_tlbs_end)
2188                panic("TLB store handler fastpath space exceeded");
2189
2190        uasm_resolve_relocs(relocs, labels);
2191        pr_debug("Wrote TLB store handler fastpath (%u instructions).\n",
2192                 (unsigned int)(p - handle_tlbs));
2193
2194        dump_handler("r4000_tlb_store", handle_tlbs, handle_tlbs_size);
2195}
2196
2197static void build_r4000_tlb_modify_handler(void)
2198{
2199        u32 *p = handle_tlbm;
2200        const int handle_tlbm_size = handle_tlbm_end - handle_tlbm;
2201        struct uasm_label *l = labels;
2202        struct uasm_reloc *r = relocs;
2203        struct work_registers wr;
2204
2205        memset(handle_tlbm, 0, handle_tlbm_size * sizeof(handle_tlbm[0]));
2206        memset(labels, 0, sizeof(labels));
2207        memset(relocs, 0, sizeof(relocs));
2208
2209        wr = build_r4000_tlbchange_handler_head(&p, &l, &r);
2210        build_pte_modifiable(&p, &r, wr.r1, wr.r2, wr.r3, label_nopage_tlbm);
2211        if (m4kc_tlbp_war())
2212                build_tlb_probe_entry(&p);
2213        /* Present and writable bits set, set accessed and dirty bits. */
2214        build_make_write(&p, &r, wr.r1, wr.r2);
2215        build_r4000_tlbchange_handler_tail(&p, &l, &r, wr.r1, wr.r2);
2216
2217#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
2218        /*
2219         * This is the entry point when
2220         * build_r4000_tlbchange_handler_head spots a huge page.
2221         */
2222        uasm_l_tlb_huge_update(&l, p);
2223        iPTE_LW(&p, wr.r1, wr.r2);
2224        build_pte_modifiable(&p, &r, wr.r1, wr.r2,  wr.r3, label_nopage_tlbm);
2225        build_tlb_probe_entry(&p);
2226        uasm_i_ori(&p, wr.r1, wr.r1,
2227                   _PAGE_ACCESSED | _PAGE_MODIFIED | _PAGE_VALID | _PAGE_DIRTY);
2228        build_huge_handler_tail(&p, &r, &l, wr.r1, wr.r2, 0);
2229#endif
2230
2231        uasm_l_nopage_tlbm(&l, p);
2232        build_restore_work_registers(&p);
2233#ifdef CONFIG_CPU_MICROMIPS
2234        if ((unsigned long)tlb_do_page_fault_1 & 1) {
2235                uasm_i_lui(&p, K0, uasm_rel_hi((long)tlb_do_page_fault_1));
2236                uasm_i_addiu(&p, K0, K0, uasm_rel_lo((long)tlb_do_page_fault_1));
2237                uasm_i_jr(&p, K0);
2238        } else
2239#endif
2240        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
2241        uasm_i_nop(&p);
2242
2243        if (p >= handle_tlbm_end)
2244                panic("TLB modify handler fastpath space exceeded");
2245
2246        uasm_resolve_relocs(relocs, labels);
2247        pr_debug("Wrote TLB modify handler fastpath (%u instructions).\n",
2248                 (unsigned int)(p - handle_tlbm));
2249
2250        dump_handler("r4000_tlb_modify", handle_tlbm, handle_tlbm_size);
2251}
2252
2253static void flush_tlb_handlers(void)
2254{
2255        local_flush_icache_range((unsigned long)handle_tlbl,
2256                           (unsigned long)handle_tlbl_end);
2257        local_flush_icache_range((unsigned long)handle_tlbs,
2258                           (unsigned long)handle_tlbs_end);
2259        local_flush_icache_range((unsigned long)handle_tlbm,
2260                           (unsigned long)handle_tlbm_end);
2261        local_flush_icache_range((unsigned long)tlbmiss_handler_setup_pgd,
2262                           (unsigned long)tlbmiss_handler_setup_pgd_end);
2263}
2264
2265static void print_htw_config(void)
2266{
2267        unsigned long config;
2268        unsigned int pwctl;
2269        const int field = 2 * sizeof(unsigned long);
2270
2271        config = read_c0_pwfield();
2272        pr_debug("PWField (0x%0*lx): GDI: 0x%02lx  UDI: 0x%02lx  MDI: 0x%02lx  PTI: 0x%02lx  PTEI: 0x%02lx\n",
2273                field, config,
2274                (config & MIPS_PWFIELD_GDI_MASK) >> MIPS_PWFIELD_GDI_SHIFT,
2275                (config & MIPS_PWFIELD_UDI_MASK) >> MIPS_PWFIELD_UDI_SHIFT,
2276                (config & MIPS_PWFIELD_MDI_MASK) >> MIPS_PWFIELD_MDI_SHIFT,
2277                (config & MIPS_PWFIELD_PTI_MASK) >> MIPS_PWFIELD_PTI_SHIFT,
2278                (config & MIPS_PWFIELD_PTEI_MASK) >> MIPS_PWFIELD_PTEI_SHIFT);
2279
2280        config = read_c0_pwsize();
2281        pr_debug("PWSize  (0x%0*lx): GDW: 0x%02lx  UDW: 0x%02lx  MDW: 0x%02lx  PTW: 0x%02lx  PTEW: 0x%02lx\n",
2282                field, config,
2283                (config & MIPS_PWSIZE_GDW_MASK) >> MIPS_PWSIZE_GDW_SHIFT,
2284                (config & MIPS_PWSIZE_UDW_MASK) >> MIPS_PWSIZE_UDW_SHIFT,
2285                (config & MIPS_PWSIZE_MDW_MASK) >> MIPS_PWSIZE_MDW_SHIFT,
2286                (config & MIPS_PWSIZE_PTW_MASK) >> MIPS_PWSIZE_PTW_SHIFT,
2287                (config & MIPS_PWSIZE_PTEW_MASK) >> MIPS_PWSIZE_PTEW_SHIFT);
2288
2289        pwctl = read_c0_pwctl();
2290        pr_debug("PWCtl   (0x%x): PWEn: 0x%x  DPH: 0x%x  HugePg: 0x%x  Psn: 0x%x\n",
2291                pwctl,
2292                (pwctl & MIPS_PWCTL_PWEN_MASK) >> MIPS_PWCTL_PWEN_SHIFT,
2293                (pwctl & MIPS_PWCTL_DPH_MASK) >> MIPS_PWCTL_DPH_SHIFT,
2294                (pwctl & MIPS_PWCTL_HUGEPG_MASK) >> MIPS_PWCTL_HUGEPG_SHIFT,
2295                (pwctl & MIPS_PWCTL_PSN_MASK) >> MIPS_PWCTL_PSN_SHIFT);
2296}
2297
2298static void config_htw_params(void)
2299{
2300        unsigned long pwfield, pwsize, ptei;
2301        unsigned int config;
2302
2303        /*
2304         * We are using 2-level page tables, so we only need to
2305         * setup GDW and PTW appropriately. UDW and MDW will remain 0.
2306         * The default value of GDI/UDI/MDI/PTI is 0xc. It is illegal to
2307         * write values less than 0xc in these fields because the entire
2308         * write will be dropped. As a result of which, we must preserve
2309         * the original reset values and overwrite only what we really want.
2310         */
2311
2312        pwfield = read_c0_pwfield();
2313        /* re-initialize the GDI field */
2314        pwfield &= ~MIPS_PWFIELD_GDI_MASK;
2315        pwfield |= PGDIR_SHIFT << MIPS_PWFIELD_GDI_SHIFT;
2316        /* re-initialize the PTI field including the even/odd bit */
2317        pwfield &= ~MIPS_PWFIELD_PTI_MASK;
2318        pwfield |= PAGE_SHIFT << MIPS_PWFIELD_PTI_SHIFT;
2319        if (CONFIG_PGTABLE_LEVELS >= 3) {
2320                pwfield &= ~MIPS_PWFIELD_MDI_MASK;
2321                pwfield |= PMD_SHIFT << MIPS_PWFIELD_MDI_SHIFT;
2322        }
2323        /* Set the PTEI right shift */
2324        ptei = _PAGE_GLOBAL_SHIFT << MIPS_PWFIELD_PTEI_SHIFT;
2325        pwfield |= ptei;
2326        write_c0_pwfield(pwfield);
2327        /* Check whether the PTEI value is supported */
2328        back_to_back_c0_hazard();
2329        pwfield = read_c0_pwfield();
2330        if (((pwfield & MIPS_PWFIELD_PTEI_MASK) << MIPS_PWFIELD_PTEI_SHIFT)
2331                != ptei) {
2332                pr_warn("Unsupported PTEI field value: 0x%lx. HTW will not be enabled",
2333                        ptei);
2334                /*
2335                 * Drop option to avoid HTW being enabled via another path
2336                 * (eg htw_reset())
2337                 */
2338                current_cpu_data.options &= ~MIPS_CPU_HTW;
2339                return;
2340        }
2341
2342        pwsize = ilog2(PTRS_PER_PGD) << MIPS_PWSIZE_GDW_SHIFT;
2343        pwsize |= ilog2(PTRS_PER_PTE) << MIPS_PWSIZE_PTW_SHIFT;
2344        if (CONFIG_PGTABLE_LEVELS >= 3)
2345                pwsize |= ilog2(PTRS_PER_PMD) << MIPS_PWSIZE_MDW_SHIFT;
2346
2347        /* If XPA has been enabled, PTEs are 64-bit in size. */
2348        if (config_enabled(CONFIG_64BITS) || (read_c0_pagegrain() & PG_ELPA))
2349                pwsize |= 1;
2350
2351        write_c0_pwsize(pwsize);
2352
2353        /* Make sure everything is set before we enable the HTW */
2354        back_to_back_c0_hazard();
2355
2356        /* Enable HTW and disable the rest of the pwctl fields */
2357        config = 1 << MIPS_PWCTL_PWEN_SHIFT;
2358        write_c0_pwctl(config);
2359        pr_info("Hardware Page Table Walker enabled\n");
2360
2361        print_htw_config();
2362}
2363
2364static void config_xpa_params(void)
2365{
2366#ifdef CONFIG_XPA
2367        unsigned int pagegrain;
2368
2369        if (mips_xpa_disabled) {
2370                pr_info("Extended Physical Addressing (XPA) disabled\n");
2371                return;
2372        }
2373
2374        pagegrain = read_c0_pagegrain();
2375        write_c0_pagegrain(pagegrain | PG_ELPA);
2376        back_to_back_c0_hazard();
2377        pagegrain = read_c0_pagegrain();
2378
2379        if (pagegrain & PG_ELPA)
2380                pr_info("Extended Physical Addressing (XPA) enabled\n");
2381        else
2382                panic("Extended Physical Addressing (XPA) disabled");
2383#endif
2384}
2385
2386static void check_pabits(void)
2387{
2388        unsigned long entry;
2389        unsigned pabits, fillbits;
2390
2391        if (!cpu_has_rixi || !_PAGE_NO_EXEC) {
2392                /*
2393                 * We'll only be making use of the fact that we can rotate bits
2394                 * into the fill if the CPU supports RIXI, so don't bother
2395                 * probing this for CPUs which don't.
2396                 */
2397                return;
2398        }
2399
2400        write_c0_entrylo0(~0ul);
2401        back_to_back_c0_hazard();
2402        entry = read_c0_entrylo0();
2403
2404        /* clear all non-PFN bits */
2405        entry &= ~((1 << MIPS_ENTRYLO_PFN_SHIFT) - 1);
2406        entry &= ~(MIPS_ENTRYLO_RI | MIPS_ENTRYLO_XI);
2407
2408        /* find a lower bound on PABITS, and upper bound on fill bits */
2409        pabits = fls_long(entry) + 6;
2410        fillbits = max_t(int, (int)BITS_PER_LONG - pabits, 0);
2411
2412        /* minus the RI & XI bits */
2413        fillbits -= min_t(unsigned, fillbits, 2);
2414
2415        if (fillbits >= ilog2(_PAGE_NO_EXEC))
2416                fill_includes_sw_bits = true;
2417
2418        pr_debug("Entry* registers contain %u fill bits\n", fillbits);
2419}
2420
2421void build_tlb_refill_handler(void)
2422{
2423        /*
2424         * The refill handler is generated per-CPU, multi-node systems
2425         * may have local storage for it. The other handlers are only
2426         * needed once.
2427         */
2428        static int run_once = 0;
2429
2430        output_pgtable_bits_defines();
2431        check_pabits();
2432
2433#ifdef CONFIG_64BIT
2434        check_for_high_segbits = current_cpu_data.vmbits > (PGDIR_SHIFT + PGD_ORDER + PAGE_SHIFT - 3);
2435#endif
2436
2437        switch (current_cpu_type()) {
2438        case CPU_R2000:
2439        case CPU_R3000:
2440        case CPU_R3000A:
2441        case CPU_R3081E:
2442        case CPU_TX3912:
2443        case CPU_TX3922:
2444        case CPU_TX3927:
2445#ifndef CONFIG_MIPS_PGD_C0_CONTEXT
2446                if (cpu_has_local_ebase)
2447                        build_r3000_tlb_refill_handler();
2448                if (!run_once) {
2449                        if (!cpu_has_local_ebase)
2450                                build_r3000_tlb_refill_handler();
2451                        build_setup_pgd();
2452                        build_r3000_tlb_load_handler();
2453                        build_r3000_tlb_store_handler();
2454                        build_r3000_tlb_modify_handler();
2455                        flush_tlb_handlers();
2456                        run_once++;
2457                }
2458#else
2459                panic("No R3000 TLB refill handler");
2460#endif
2461                break;
2462
2463        case CPU_R6000:
2464        case CPU_R6000A:
2465                panic("No R6000 TLB refill handler yet");
2466                break;
2467
2468        case CPU_R8000:
2469                panic("No R8000 TLB refill handler yet");
2470                break;
2471
2472        default:
2473                if (!run_once) {
2474                        scratch_reg = allocate_kscratch();
2475                        build_setup_pgd();
2476                        build_r4000_tlb_load_handler();
2477                        build_r4000_tlb_store_handler();
2478                        build_r4000_tlb_modify_handler();
2479                        if (!cpu_has_local_ebase)
2480                                build_r4000_tlb_refill_handler();
2481                        flush_tlb_handlers();
2482                        run_once++;
2483                }
2484                if (cpu_has_local_ebase)
2485                        build_r4000_tlb_refill_handler();
2486                if (cpu_has_xpa)
2487                        config_xpa_params();
2488                if (cpu_has_htw)
2489                        config_htw_params();
2490        }
2491}
Note: See TracBrowser for help on using the repository browser.