source: src/linux/universal/linux-3.18/arch/mips/mm/tlbex.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

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