tlbex.c 68.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Synthesize TLB refill handlers at runtime.
 *
Ralf Baechle's avatar
Ralf Baechle committed
8
9
 * Copyright (C) 2004, 2005, 2006, 2008	 Thiemo Seufer
 * Copyright (C) 2005, 2007, 2008, 2009	 Maciej W. Rozycki
10
 * Copyright (C) 2006  Ralf Baechle (ralf@linux-mips.org)
David Daney's avatar
David Daney committed
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 completely out of my mind.
16
17
18
19
20
21
 *
 * They're coming to take me a away haha
 * they're coming to take me a away hoho hihi haha
 * to the funny farm where code is beautiful all the time ...
 *
 * (Condolences to Napoleon XIV)
Linus Torvalds's avatar
Linus Torvalds committed
22
23
 */

24
#include <linux/bug.h>
Linus Torvalds's avatar
Linus Torvalds committed
25
26
#include <linux/kernel.h>
#include <linux/types.h>
27
#include <linux/smp.h>
Linus Torvalds's avatar
Linus Torvalds committed
28
#include <linux/string.h>
29
#include <linux/cache.h>
Linus Torvalds's avatar
Linus Torvalds committed
30

31
#include <asm/cacheflush.h>
32
#include <asm/cpu-type.h>
33
#include <asm/pgtable.h>
Linus Torvalds's avatar
Linus Torvalds committed
34
#include <asm/war.h>
35
#include <asm/uasm.h>
36
#include <asm/setup.h>
37

38
static int mips_xpa_disabled;
Steven J. Hill's avatar
Steven J. Hill committed
39
40
41
42
43
44
45
46
47
48

static int __init xpa_disable(char *s)
{
	mips_xpa_disabled = 1;

	return 1;
}

__setup("noxpa", xpa_disable);

49
50
51
52
53
54
55
56
57
/*
 * TLB load/store/modify handlers.
 *
 * Only the fastpath gets synthesized at runtime, the slowpath for
 * do_page_fault remains normal asm.
 */
extern void tlb_do_page_fault_0(void);
extern void tlb_do_page_fault_1(void);

58
59
60
61
62
63
64
65
66
67
68
69
struct work_registers {
	int r1;
	int r2;
	int r3;
};

struct tlb_reg_save {
	unsigned long a;
	unsigned long b;
} ____cacheline_aligned_in_smp;

static struct tlb_reg_save handler_reg_save[NR_CPUS];
70

71
static inline int r45k_bvahwbug(void)
Linus Torvalds's avatar
Linus Torvalds committed
72
73
74
75
76
{
	/* XXX: We should probe for the presence of this bug, but we don't. */
	return 0;
}

77
static inline int r4k_250MHZhwbug(void)
Linus Torvalds's avatar
Linus Torvalds committed
78
79
80
81
82
{
	/* XXX: We should probe for the presence of this bug, but we don't. */
	return 0;
}

83
static inline int __maybe_unused bcm1250_m3_war(void)
Linus Torvalds's avatar
Linus Torvalds committed
84
85
86
87
{
	return BCM1250_M3_WAR;
}

88
static inline int __maybe_unused r10000_llsc_war(void)
Linus Torvalds's avatar
Linus Torvalds committed
89
90
91
92
{
	return R10000_LLSC_WAR;
}

93
94
95
96
97
98
static int use_bbit_insns(void)
{
	switch (current_cpu_type()) {
	case CPU_CAVIUM_OCTEON:
	case CPU_CAVIUM_OCTEON_PLUS:
	case CPU_CAVIUM_OCTEON2:
99
	case CPU_CAVIUM_OCTEON3:
100
101
102
103
104
105
		return 1;
	default:
		return 0;
	}
}

106
107
108
109
static int use_lwx_insns(void)
{
	switch (current_cpu_type()) {
	case CPU_CAVIUM_OCTEON2:
110
	case CPU_CAVIUM_OCTEON3:
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
		return 1;
	default:
		return 0;
	}
}
#if defined(CONFIG_CAVIUM_OCTEON_CVMSEG_SIZE) && \
    CONFIG_CAVIUM_OCTEON_CVMSEG_SIZE > 0
static bool scratchpad_available(void)
{
	return true;
}
static int scratchpad_offset(int i)
{
	/*
	 * CVMSEG starts at address -32768 and extends for
	 * CAVIUM_OCTEON_CVMSEG_SIZE 128 byte cache lines.
	 */
	i += 1; /* Kernel use starts at the top and works down. */
	return CONFIG_CAVIUM_OCTEON_CVMSEG_SIZE * 128 - (8 * i) - 32768;
}
#else
static bool scratchpad_available(void)
{
	return false;
}
static int scratchpad_offset(int i)
{
	BUG();
139
140
	/* Really unreachable, but evidently some GCC want this. */
	return 0;
141
142
}
#endif
143
144
145
146
147
148
149
150
151
/*
 * Found by experiment: At least some revisions of the 4kc throw under
 * some circumstances a machine check exception, triggered by invalid
 * values in the index register.  Delaying the tlbp instruction until
 * after the next branch,  plus adding an additional nop in front of
 * tlbwi/tlbwr avoids the invalid index register values. Nobody knows
 * why; it's not an issue caused by the core RTL.
 *
 */
152
static int m4kc_tlbp_war(void)
153
154
155
156
157
{
	return (current_cpu_data.processor_id & 0xffff00) ==
	       (PRID_COMP_MIPS | PRID_IMP_4KC);
}

158
/* Handle labels (which must be positive integers). */
Linus Torvalds's avatar
Linus Torvalds committed
159
enum label_id {
160
	label_second_part = 1,
Linus Torvalds's avatar
Linus Torvalds committed
161
162
163
	label_leave,
	label_vmalloc,
	label_vmalloc_done,
164
165
	label_tlbw_hazard_0,
	label_split = label_tlbw_hazard_0 + 8,
166
167
	label_tlbl_goaround1,
	label_tlbl_goaround2,
Linus Torvalds's avatar
Linus Torvalds committed
168
169
170
171
172
	label_nopage_tlbl,
	label_nopage_tlbs,
	label_nopage_tlbm,
	label_smp_pgtable_change,
	label_r3000_write_probe_fail,
173
	label_large_segbits_fault,
174
#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
David Daney's avatar
David Daney committed
175
176
	label_tlb_huge_update,
#endif
Linus Torvalds's avatar
Linus Torvalds committed
177
178
};

179
180
181
182
UASM_L_LA(_second_part)
UASM_L_LA(_leave)
UASM_L_LA(_vmalloc)
UASM_L_LA(_vmalloc_done)
183
/* _tlbw_hazard_x is handled differently.  */
184
UASM_L_LA(_split)
185
186
UASM_L_LA(_tlbl_goaround1)
UASM_L_LA(_tlbl_goaround2)
187
188
189
190
191
UASM_L_LA(_nopage_tlbl)
UASM_L_LA(_nopage_tlbs)
UASM_L_LA(_nopage_tlbm)
UASM_L_LA(_smp_pgtable_change)
UASM_L_LA(_r3000_write_probe_fail)
192
UASM_L_LA(_large_segbits_fault)
193
#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
David Daney's avatar
David Daney committed
194
195
UASM_L_LA(_tlb_huge_update)
#endif
196

197
static int hazard_instance;
198

199
static void uasm_bgezl_hazard(u32 **p, struct uasm_reloc **r, int instance)
200
201
202
203
204
205
206
207
208
209
{
	switch (instance) {
	case 0 ... 7:
		uasm_il_bgezl(p, r, 0, label_tlbw_hazard_0 + instance);
		return;
	default:
		BUG();
	}
}

210
static void uasm_bgezl_label(struct uasm_label **l, u32 **p, int instance)
211
212
213
214
215
216
217
218
219
220
{
	switch (instance) {
	case 0 ... 7:
		uasm_build_label(l, *p, label_tlbw_hazard_0 + instance);
		break;
	default:
		BUG();
	}
}

221
/*
222
223
 * pgtable bits are assigned dynamically depending on processor feature
 * and statically based on kernel configuration.  This spits out the actual
Ralf Baechle's avatar
Ralf Baechle committed
224
 * values the kernel is using.	Required to make sense from disassembled
225
 * TLB exception handlers.
226
 */
227
228
229
230
231
232
233
234
235
236
static void output_pgtable_bits_defines(void)
{
#define pr_define(fmt, ...)					\
	pr_debug("#define " fmt, ##__VA_ARGS__)

	pr_debug("#include <asm/asm.h>\n");
	pr_debug("#include <asm/regdef.h>\n");
	pr_debug("\n");

	pr_define("_PAGE_PRESENT_SHIFT %d\n", _PAGE_PRESENT_SHIFT);
237
	pr_define("_PAGE_NO_READ_SHIFT %d\n", _PAGE_NO_READ_SHIFT);
238
239
240
	pr_define("_PAGE_WRITE_SHIFT %d\n", _PAGE_WRITE_SHIFT);
	pr_define("_PAGE_ACCESSED_SHIFT %d\n", _PAGE_ACCESSED_SHIFT);
	pr_define("_PAGE_MODIFIED_SHIFT %d\n", _PAGE_MODIFIED_SHIFT);
241
#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
242
243
244
	pr_define("_PAGE_HUGE_SHIFT %d\n", _PAGE_HUGE_SHIFT);
#endif
#ifdef _PAGE_NO_EXEC_SHIFT
245
	if (cpu_has_rixi)
246
		pr_define("_PAGE_NO_EXEC_SHIFT %d\n", _PAGE_NO_EXEC_SHIFT);
247
#endif
248
249
250
251
252
253
254
255
	pr_define("_PAGE_GLOBAL_SHIFT %d\n", _PAGE_GLOBAL_SHIFT);
	pr_define("_PAGE_VALID_SHIFT %d\n", _PAGE_VALID_SHIFT);
	pr_define("_PAGE_DIRTY_SHIFT %d\n", _PAGE_DIRTY_SHIFT);
	pr_define("_PFN_SHIFT %d\n", _PFN_SHIFT);
	pr_debug("\n");
}

static inline void dump_handler(const char *symbol, const u32 *handler, int count)
256
257
258
{
	int i;

259
260
	pr_debug("LEAF(%s)\n", symbol);

261
262
263
264
	pr_debug("\t.set push\n");
	pr_debug("\t.set noreorder\n");

	for (i = 0; i < count; i++)
265
		pr_debug("\t.word\t0x%08x\t\t# %p\n", handler[i], &handler[i]);
266

267
268
269
	pr_debug("\t.set\tpop\n");

	pr_debug("\tEND(%s)\n", symbol);
270
271
}

Linus Torvalds's avatar
Linus Torvalds committed
272
273
274
275
276
/* The only general purpose registers allowed in TLB handlers. */
#define K0		26
#define K1		27

/* Some CP0 registers */
277
278
279
280
281
#define C0_INDEX	0, 0
#define C0_ENTRYLO0	2, 0
#define C0_TCBIND	2, 2
#define C0_ENTRYLO1	3, 0
#define C0_CONTEXT	4, 0
David Daney's avatar
David Daney committed
282
#define C0_PAGEMASK	5, 0
283
284
285
286
#define C0_PWBASE	5, 5
#define C0_PWFIELD	5, 6
#define C0_PWSIZE	5, 7
#define C0_PWCTL	6, 6
287
#define C0_BADVADDR	8, 0
288
#define C0_PGD		9, 7
289
290
291
#define C0_ENTRYHI	10, 0
#define C0_EPC		14, 0
#define C0_XCONTEXT	20, 0
Linus Torvalds's avatar
Linus Torvalds committed
292

293
#ifdef CONFIG_64BIT
294
# define GET_CONTEXT(buf, reg) UASM_i_MFC0(buf, reg, C0_XCONTEXT)
Linus Torvalds's avatar
Linus Torvalds committed
295
#else
296
# define GET_CONTEXT(buf, reg) UASM_i_MFC0(buf, reg, C0_CONTEXT)
Linus Torvalds's avatar
Linus Torvalds committed
297
298
299
300
301
302
303
304
305
306
#endif

/* The worst case length of the handler is around 18 instructions for
 * R3000-style TLBs and up to 63 instructions for R4000-style TLBs.
 * Maximum space available is 32 instructions for R3000 and 64
 * instructions for R4000.
 *
 * We deliberately chose a buffer size of 128, so we won't scribble
 * over anything important on overflow before we panic.
 */
307
static u32 tlb_handler[128];
Linus Torvalds's avatar
Linus Torvalds committed
308
309

/* simply assume worst case size for labels and relocs */
310
311
static struct uasm_label labels[128];
static struct uasm_reloc relocs[128];
Linus Torvalds's avatar
Linus Torvalds committed
312

313
static int check_for_high_segbits;
314
static bool fill_includes_sw_bits;
315

316
static unsigned int kscratch_used_mask;
317

318
319
320
321
322
323
324
325
326
327
328
static inline int __maybe_unused c0_kscratch(void)
{
	switch (current_cpu_type()) {
	case CPU_XLP:
	case CPU_XLR:
		return 22;
	default:
		return 31;
	}
}

329
static int allocate_kscratch(void)
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
{
	int r;
	unsigned int a = cpu_data[0].kscratch_mask & ~kscratch_used_mask;

	r = ffs(a);

	if (r == 0)
		return -1;

	r--; /* make it zero based */

	kscratch_used_mask |= (1 << r);

	return r;
}

346
347
static int scratch_reg;
static int pgd_reg;
348
349
enum vmalloc64_mode {not_refill, refill_scratch, refill_noscratch};

350
static struct work_registers build_get_work_registers(u32 **p)
351
352
353
{
	struct work_registers r;

354
	if (scratch_reg >= 0) {
355
		/* Save in CPU local C0_KScratch? */
356
		UASM_i_MTC0(p, 1, c0_kscratch(), scratch_reg);
357
358
359
360
361
362
363
364
		r.r1 = K0;
		r.r2 = K1;
		r.r3 = 1;
		return r;
	}

	if (num_possible_cpus() > 1) {
		/* Get smp_processor_id */
365
366
		UASM_i_CPUID_MFC0(p, K0, SMP_CPUID_REG);
		UASM_i_SRL_SAFE(p, K0, K0, SMP_CPUID_REGSHIFT);
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385

		/* handler_reg_save index in K0 */
		UASM_i_SLL(p, K0, K0, ilog2(sizeof(struct tlb_reg_save)));

		UASM_i_LA(p, K1, (long)&handler_reg_save);
		UASM_i_ADDU(p, K0, K0, K1);
	} else {
		UASM_i_LA(p, K0, (long)&handler_reg_save);
	}
	/* K0 now points to save area, save $1 and $2  */
	UASM_i_SW(p, 1, offsetof(struct tlb_reg_save, a), K0);
	UASM_i_SW(p, 2, offsetof(struct tlb_reg_save, b), K0);

	r.r1 = K1;
	r.r2 = 1;
	r.r3 = 2;
	return r;
}

386
static void build_restore_work_registers(u32 **p)
387
{
388
	if (scratch_reg >= 0) {
389
		UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
390
391
392
393
394
395
396
		return;
	}
	/* K0 already points to save area, restore $1 and $2  */
	UASM_i_LW(p, 1, offsetof(struct tlb_reg_save, a), K0);
	UASM_i_LW(p, 2, offsetof(struct tlb_reg_save, b), K0);
}

397
#ifndef CONFIG_MIPS_PGD_C0_CONTEXT
398

399
400
401
/*
 * CONFIG_MIPS_PGD_C0_CONTEXT implies 64 bit and lack of pgd_current,
 * we cannot do r3000 under these circumstances.
402
403
404
 *
 * Declare pgd_current here instead of including mmu_context.h to avoid type
 * conflicts for tlbmiss_handler_setup_pgd
405
 */
406
extern unsigned long pgd_current[];
407

Linus Torvalds's avatar
Linus Torvalds committed
408
409
410
/*
 * The R3000 TLB handler is simple.
 */
411
static void build_r3000_tlb_refill_handler(void)
Linus Torvalds's avatar
Linus Torvalds committed
412
413
414
415
416
417
418
{
	long pgdc = (long)pgd_current;
	u32 *p;

	memset(tlb_handler, 0, sizeof(tlb_handler));
	p = tlb_handler;

419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
	uasm_i_mfc0(&p, K0, C0_BADVADDR);
	uasm_i_lui(&p, K1, uasm_rel_hi(pgdc)); /* cp0 delay */
	uasm_i_lw(&p, K1, uasm_rel_lo(pgdc), K1);
	uasm_i_srl(&p, K0, K0, 22); /* load delay */
	uasm_i_sll(&p, K0, K0, 2);
	uasm_i_addu(&p, K1, K1, K0);
	uasm_i_mfc0(&p, K0, C0_CONTEXT);
	uasm_i_lw(&p, K1, 0, K1); /* cp0 delay */
	uasm_i_andi(&p, K0, K0, 0xffc); /* load delay */
	uasm_i_addu(&p, K1, K1, K0);
	uasm_i_lw(&p, K0, 0, K1);
	uasm_i_nop(&p); /* load delay */
	uasm_i_mtc0(&p, K0, C0_ENTRYLO0);
	uasm_i_mfc0(&p, K1, C0_EPC); /* cp0 delay */
	uasm_i_tlbwr(&p); /* cp0 delay */
	uasm_i_jr(&p, K1);
	uasm_i_rfe(&p); /* branch delay */
Linus Torvalds's avatar
Linus Torvalds committed
436
437
438
439

	if (p > tlb_handler + 32)
		panic("TLB refill handler space exceeded");

440
441
	pr_debug("Wrote TLB refill handler (%u instructions).\n",
		 (unsigned int)(p - tlb_handler));
Linus Torvalds's avatar
Linus Torvalds committed
442

443
	memcpy((void *)ebase, tlb_handler, 0x80);
444
	local_flush_icache_range(ebase, ebase + 0x80);
445

446
	dump_handler("r3000_tlb_refill", (u32 *)ebase, 32);
Linus Torvalds's avatar
Linus Torvalds committed
447
}
448
#endif /* CONFIG_MIPS_PGD_C0_CONTEXT */
Linus Torvalds's avatar
Linus Torvalds committed
449
450
451
452
453
454
455
456

/*
 * The R4000 TLB handler is much more complicated. We have two
 * consecutive handler areas with 32 instructions space each.
 * Since they aren't used at the same time, we can overflow in the
 * other one.To keep things simple, we first assume linear space,
 * then we relocate it to the final handler layout as needed.
 */
457
static u32 final_handler[64];
Linus Torvalds's avatar
Linus Torvalds committed
458
459
460
461
462
463
464

/*
 * Hazards
 *
 * From the IDT errata for the QED RM5230 (Nevada), processor revision 1.0:
 * 2. A timing hazard exists for the TLBP instruction.
 *
Ralf Baechle's avatar
Ralf Baechle committed
465
466
 *	stalling_instruction
 *	TLBP
Linus Torvalds's avatar
Linus Torvalds committed
467
468
469
470
471
472
473
474
475
476
 *
 * The JTLB is being read for the TLBP throughout the stall generated by the
 * previous instruction. This is not really correct as the stalling instruction
 * can modify the address used to access the JTLB.  The failure symptom is that
 * the TLBP instruction will use an address created for the stalling instruction
 * and not the address held in C0_ENHI and thus report the wrong results.
 *
 * The software work-around is to not allow the instruction preceding the TLBP
 * to stall - make it an NOP or some other instruction guaranteed not to stall.
 *
Ralf Baechle's avatar
Ralf Baechle committed
477
 * Errata 2 will not be fixed.	This errata is also on the R5000.
Linus Torvalds's avatar
Linus Torvalds committed
478
479
480
 *
 * As if we MIPS hackers wouldn't know how to nop pipelines happy ...
 */
481
static void __maybe_unused build_tlb_probe_entry(u32 **p)
Linus Torvalds's avatar
Linus Torvalds committed
482
{
483
	switch (current_cpu_type()) {
484
	/* Found by experiment: R4600 v2.0/R4700 needs this, too.  */
485
	case CPU_R4600:
486
	case CPU_R4700:
Linus Torvalds's avatar
Linus Torvalds committed
487
488
	case CPU_R5000:
	case CPU_NEVADA:
489
490
		uasm_i_nop(p);
		uasm_i_tlbp(p);
Linus Torvalds's avatar
Linus Torvalds committed
491
492
493
		break;

	default:
494
		uasm_i_tlbp(p);
Linus Torvalds's avatar
Linus Torvalds committed
495
496
497
498
499
500
		break;
	}
}

/*
 * Write random or indexed TLB entry, and care about the hazards from
Lucas De Marchi's avatar
Lucas De Marchi committed
501
 * the preceding mtc0 and for the following eret.
Linus Torvalds's avatar
Linus Torvalds committed
502
503
504
 */
enum tlb_write_entry { tlb_random, tlb_indexed };

505
506
507
static void build_tlb_write_entry(u32 **p, struct uasm_label **l,
				  struct uasm_reloc **r,
				  enum tlb_write_entry wmode)
Linus Torvalds's avatar
Linus Torvalds committed
508
509
510
511
{
	void(*tlbw)(u32 **) = NULL;

	switch (wmode) {
512
513
	case tlb_random: tlbw = uasm_i_tlbwr; break;
	case tlb_indexed: tlbw = uasm_i_tlbwi; break;
Linus Torvalds's avatar
Linus Torvalds committed
514
515
	}

516
517
	if (cpu_has_mips_r2_r6) {
		if (cpu_has_mips_r2_exec_hazard)
518
			uasm_i_ehb(p);
519
520
521
522
		tlbw(p);
		return;
	}

523
	switch (current_cpu_type()) {
Linus Torvalds's avatar
Linus Torvalds committed
524
525
526
527
528
529
530
531
532
533
	case CPU_R4000PC:
	case CPU_R4000SC:
	case CPU_R4000MC:
	case CPU_R4400PC:
	case CPU_R4400SC:
	case CPU_R4400MC:
		/*
		 * This branch uses up a mtc0 hazard nop slot and saves
		 * two nops after the tlbw instruction.
		 */
534
		uasm_bgezl_hazard(p, r, hazard_instance);
Linus Torvalds's avatar
Linus Torvalds committed
535
		tlbw(p);
536
537
		uasm_bgezl_label(l, p, hazard_instance);
		hazard_instance++;
538
		uasm_i_nop(p);
Linus Torvalds's avatar
Linus Torvalds committed
539
540
541
542
		break;

	case CPU_R4600:
	case CPU_R4700:
543
		uasm_i_nop(p);
544
		tlbw(p);
545
		uasm_i_nop(p);
546
547
		break;

548
549
550
551
552
553
554
	case CPU_R5000:
	case CPU_NEVADA:
		uasm_i_nop(p); /* QED specifies 2 nops hazard */
		uasm_i_nop(p); /* QED specifies 2 nops hazard */
		tlbw(p);
		break;

555
	case CPU_R4300:
Linus Torvalds's avatar
Linus Torvalds committed
556
557
	case CPU_5KC:
	case CPU_TX49XX:
558
	case CPU_PR4450:
559
	case CPU_XLR:
560
		uasm_i_nop(p);
Linus Torvalds's avatar
Linus Torvalds committed
561
562
563
564
565
		tlbw(p);
		break;

	case CPU_R10000:
	case CPU_R12000:
Kumba's avatar
Kumba committed
566
	case CPU_R14000:
Joshua Kinard's avatar
Joshua Kinard committed
567
	case CPU_R16000:
Linus Torvalds's avatar
Linus Torvalds committed
568
	case CPU_4KC:
569
	case CPU_4KEC:
570
	case CPU_M14KC:
571
	case CPU_M14KEC:
Linus Torvalds's avatar
Linus Torvalds committed
572
	case CPU_SB1:
Andrew Isaacson's avatar
Andrew Isaacson committed
573
	case CPU_SB1A:
Linus Torvalds's avatar
Linus Torvalds committed
574
575
576
	case CPU_4KSC:
	case CPU_20KC:
	case CPU_25KF:
577
578
579
580
581
	case CPU_BMIPS32:
	case CPU_BMIPS3300:
	case CPU_BMIPS4350:
	case CPU_BMIPS4380:
	case CPU_BMIPS5000:
582
	case CPU_LOONGSON2:
583
	case CPU_LOONGSON3:
584
	case CPU_R5500:
585
		if (m4kc_tlbp_war())
586
			uasm_i_nop(p);
587
	case CPU_ALCHEMY:
Linus Torvalds's avatar
Linus Torvalds committed
588
589
590
591
		tlbw(p);
		break;

	case CPU_RM7000:
592
593
594
595
		uasm_i_nop(p);
		uasm_i_nop(p);
		uasm_i_nop(p);
		uasm_i_nop(p);
Linus Torvalds's avatar
Linus Torvalds committed
596
597
598
599
600
601
602
603
		tlbw(p);
		break;

	case CPU_VR4111:
	case CPU_VR4121:
	case CPU_VR4122:
	case CPU_VR4181:
	case CPU_VR4181A:
604
605
		uasm_i_nop(p);
		uasm_i_nop(p);
Linus Torvalds's avatar
Linus Torvalds committed
606
		tlbw(p);
607
608
		uasm_i_nop(p);
		uasm_i_nop(p);
Linus Torvalds's avatar
Linus Torvalds committed
609
610
611
612
		break;

	case CPU_VR4131:
	case CPU_VR4133:
613
	case CPU_R5432:
614
615
		uasm_i_nop(p);
		uasm_i_nop(p);
Linus Torvalds's avatar
Linus Torvalds committed
616
617
618
		tlbw(p);
		break;

619
620
621
622
623
	case CPU_JZRISC:
		tlbw(p);
		uasm_i_nop(p);
		break;

Linus Torvalds's avatar
Linus Torvalds committed
624
625
	default:
		panic("No TLB refill handler yet (CPU type: %d)",
626
		      current_cpu_type());
Linus Torvalds's avatar
Linus Torvalds committed
627
628
629
630
		break;
	}
}

631
632
static __maybe_unused void build_convert_pte_to_entrylo(u32 **p,
							unsigned int reg)
David Daney's avatar
David Daney committed
633
{
634
635
636
637
638
	if (_PAGE_GLOBAL_SHIFT == 0) {
		/* pte_t is already in EntryLo format */
		return;
	}

639
640
641
642
643
644
645
646
	if (cpu_has_rixi && _PAGE_NO_EXEC) {
		if (fill_includes_sw_bits) {
			UASM_i_ROTR(p, reg, reg, ilog2(_PAGE_GLOBAL));
		} else {
			UASM_i_SRL(p, reg, reg, ilog2(_PAGE_NO_EXEC));
			UASM_i_ROTR(p, reg, reg,
				    ilog2(_PAGE_GLOBAL) - ilog2(_PAGE_NO_EXEC));
		}
647
	} else {
648
#ifdef CONFIG_PHYS_ADDR_T_64BIT
649
		uasm_i_dsrl_safe(p, reg, reg, ilog2(_PAGE_GLOBAL));
650
651
652
653
654
#else
		UASM_i_SRL(p, reg, reg, ilog2(_PAGE_GLOBAL));
#endif
	}
}
David Daney's avatar
David Daney committed
655

656
#ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
David Daney's avatar
David Daney committed
657

658
659
660
static void build_restore_pagemask(u32 **p, struct uasm_reloc **r,
				   unsigned int tmp, enum label_id lid,
				   int restore_scratch)
661
{
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
	if (restore_scratch) {
		/* Reset default page size */
		if (PM_DEFAULT_MASK >> 16) {
			uasm_i_lui(p, tmp, PM_DEFAULT_MASK >> 16);
			uasm_i_ori(p, tmp, tmp, PM_DEFAULT_MASK & 0xffff);
			uasm_i_mtc0(p, tmp, C0_PAGEMASK);
			uasm_il_b(p, r, lid);
		} else if (PM_DEFAULT_MASK) {
			uasm_i_ori(p, tmp, 0, PM_DEFAULT_MASK);
			uasm_i_mtc0(p, tmp, C0_PAGEMASK);
			uasm_il_b(p, r, lid);
		} else {
			uasm_i_mtc0(p, 0, C0_PAGEMASK);
			uasm_il_b(p, r, lid);
		}
677
		if (scratch_reg >= 0)
678
			UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
679
680
		else
			UASM_i_LW(p, 1, scratchpad_offset(0), 0);
David Daney's avatar
David Daney committed
681
	} else {
682
683
684
685
686
687
688
689
690
691
692
693
694
695
		/* Reset default page size */
		if (PM_DEFAULT_MASK >> 16) {
			uasm_i_lui(p, tmp, PM_DEFAULT_MASK >> 16);
			uasm_i_ori(p, tmp, tmp, PM_DEFAULT_MASK & 0xffff);
			uasm_il_b(p, r, lid);
			uasm_i_mtc0(p, tmp, C0_PAGEMASK);
		} else if (PM_DEFAULT_MASK) {
			uasm_i_ori(p, tmp, 0, PM_DEFAULT_MASK);
			uasm_il_b(p, r, lid);
			uasm_i_mtc0(p, tmp, C0_PAGEMASK);
		} else {
			uasm_il_b(p, r, lid);
			uasm_i_mtc0(p, 0, C0_PAGEMASK);
		}
David Daney's avatar
David Daney committed
696
697
698
	}
}

699
700
701
702
703
static void build_huge_tlb_write_entry(u32 **p, struct uasm_label **l,
				       struct uasm_reloc **r,
				       unsigned int tmp,
				       enum tlb_write_entry wmode,
				       int restore_scratch)
704
705
706
707
708
709
710
711
{
	/* Set huge page tlb entry size */
	uasm_i_lui(p, tmp, PM_HUGE_MASK >> 16);
	uasm_i_ori(p, tmp, tmp, PM_HUGE_MASK & 0xffff);
	uasm_i_mtc0(p, tmp, C0_PAGEMASK);

	build_tlb_write_entry(p, l, r, wmode);

712
	build_restore_pagemask(p, r, tmp, label_leave, restore_scratch);
713
714
}

David Daney's avatar
David Daney committed
715
716
717
/*
 * Check if Huge PTE is present, if so then jump to LABEL.
 */
718
static void
David Daney's avatar
David Daney committed
719
build_is_huge_pte(u32 **p, struct uasm_reloc **r, unsigned int tmp,
720
		  unsigned int pmd, int lid)
David Daney's avatar
David Daney committed
721
722
{
	UASM_i_LW(p, tmp, 0, pmd);
723
724
725
726
727
728
	if (use_bbit_insns()) {
		uasm_il_bbit1(p, r, tmp, ilog2(_PAGE_HUGE), lid);
	} else {
		uasm_i_andi(p, tmp, tmp, _PAGE_HUGE);
		uasm_il_bnez(p, r, tmp, lid);
	}
David Daney's avatar
David Daney committed
729
730
}

731
732
static void build_huge_update_entries(u32 **p, unsigned int pte,
				      unsigned int tmp)
David Daney's avatar
David Daney committed
733
734
735
736
737
738
739
740
741
742
743
744
745
746
{
	int small_sequence;

	/*
	 * A huge PTE describes an area the size of the
	 * configured huge page size. This is twice the
	 * of the large TLB entry size we intend to use.
	 * A TLB entry half the size of the configured
	 * huge page size is configured into entrylo0
	 * and entrylo1 to cover the contiguous huge PTE
	 * address space.
	 */
	small_sequence = (HPAGE_SIZE >> 7) < 0x10000;

Ralf Baechle's avatar
Ralf Baechle committed
747
	/* We can clobber tmp.	It isn't used after this.*/
David Daney's avatar
David Daney committed
748
749
750
	if (!small_sequence)
		uasm_i_lui(p, tmp, HPAGE_SIZE >> (7 + 16));

751
	build_convert_pte_to_entrylo(p, pte);
752
	UASM_i_MTC0(p, pte, C0_ENTRYLO0); /* load it */
David Daney's avatar
David Daney committed
753
754
755
756
757
758
	/* convert to entrylo1 */
	if (small_sequence)
		UASM_i_ADDIU(p, pte, pte, HPAGE_SIZE >> 7);
	else
		UASM_i_ADDU(p, pte, pte, tmp);

759
	UASM_i_MTC0(p, pte, C0_ENTRYLO1); /* load it */
David Daney's avatar
David Daney committed
760
761
}

762
763
764
765
static void build_huge_handler_tail(u32 **p, struct uasm_reloc **r,
				    struct uasm_label **l,
				    unsigned int pte,
				    unsigned int ptr)
David Daney's avatar
David Daney committed
766
767
768
769
770
771
772
773
774
{
#ifdef CONFIG_SMP
	UASM_i_SC(p, pte, 0, ptr);
	uasm_il_beqz(p, r, pte, label_tlb_huge_update);
	UASM_i_LW(p, pte, 0, ptr); /* Needed because SC killed our PTE */
#else
	UASM_i_SW(p, pte, 0, ptr);
#endif
	build_huge_update_entries(p, pte, ptr);
775
	build_huge_tlb_write_entry(p, l, r, pte, tlb_indexed, 0);
David Daney's avatar
David Daney committed
776
}
777
#endif /* CONFIG_MIPS_HUGE_TLB_SUPPORT */
David Daney's avatar
David Daney committed
778

779
#ifdef CONFIG_64BIT
Linus Torvalds's avatar
Linus Torvalds committed
780
781
782
783
/*
 * TMP and PTR are scratch.
 * TMP will be clobbered, PTR will hold the pmd entry.
 */
784
static void
785
build_get_pmde64(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
Linus Torvalds's avatar
Linus Torvalds committed
786
787
		 unsigned int tmp, unsigned int ptr)
{
788
#ifndef CONFIG_MIPS_PGD_C0_CONTEXT
Linus Torvalds's avatar
Linus Torvalds committed
789
	long pgdc = (long)pgd_current;
790
#endif
Linus Torvalds's avatar
Linus Torvalds committed
791
792
793
	/*
	 * The vmalloc handling is not in the hotpath.
	 */
794
	uasm_i_dmfc0(p, tmp, C0_BADVADDR);
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812

	if (check_for_high_segbits) {
		/*
		 * The kernel currently implicitely assumes that the
		 * MIPS SEGBITS parameter for the processor is
		 * (PGDIR_SHIFT+PGDIR_BITS) or less, and will never
		 * allocate virtual addresses outside the maximum
		 * range for SEGBITS = (PGDIR_SHIFT+PGDIR_BITS). But
		 * that doesn't prevent user code from accessing the
		 * higher xuseg addresses.  Here, we make sure that
		 * everything but the lower xuseg addresses goes down
		 * the module_alloc/vmalloc path.
		 */
		uasm_i_dsrl_safe(p, ptr, tmp, PGDIR_SHIFT + PGD_ORDER + PAGE_SHIFT - 3);
		uasm_il_bnez(p, r, ptr, label_vmalloc);
	} else {
		uasm_il_bltz(p, r, tmp, label_vmalloc);
	}
813
	/* No uasm_i_nop needed here, since the next insn doesn't touch TMP. */
Linus Torvalds's avatar
Linus Torvalds committed
814

815
816
	if (pgd_reg != -1) {
		/* pgd is in pgd_reg */
817
818
819
820
		if (cpu_has_ldpte)
			UASM_i_MFC0(p, ptr, C0_PWBASE);
		else
			UASM_i_MFC0(p, ptr, c0_kscratch(), pgd_reg);
821
	} else {
822
#if defined(CONFIG_MIPS_PGD_C0_CONTEXT)
823
824
825
826
827
828
829
830
		/*
		 * &pgd << 11 stored in CONTEXT [23..63].
		 */
		UASM_i_MFC0(p, ptr, C0_CONTEXT);

		/* Clear lower 23 bits of context. */
		uasm_i_dins(p, ptr, 0, 0, 23);

Ralf Baechle's avatar
Ralf Baechle committed
831
		/* 1 0	1 0 1  << 6  xkphys cached */
832
833
		uasm_i_ori(p, ptr, ptr, 0x540);
		uasm_i_drotr(p, ptr, ptr, 11);
834
#elif defined(CONFIG_SMP)
835
836
837
838
839
840
		UASM_i_CPUID_MFC0(p, ptr, SMP_CPUID_REG);
		uasm_i_dsrl_safe(p, ptr, ptr, SMP_CPUID_PTRSHIFT);
		UASM_i_LA_mostly(p, tmp, pgdc);
		uasm_i_daddu(p, ptr, ptr, tmp);
		uasm_i_dmfc0(p, tmp, C0_BADVADDR);
		uasm_i_ld(p, ptr, uasm_rel_lo(pgdc), ptr);
Linus Torvalds's avatar
Linus Torvalds committed
841
#else
842
843
		UASM_i_LA_mostly(p, ptr, pgdc);
		uasm_i_ld(p, ptr, uasm_rel_lo(pgdc), ptr);
Linus Torvalds's avatar
Linus Torvalds committed
844
#endif
845
	}
Linus Torvalds's avatar
Linus Torvalds committed
846

847
	uasm_l_vmalloc_done(l, *p);
848

849
850
	/* get pgd offset in bytes */
	uasm_i_dsrl_safe(p, tmp, tmp, PGDIR_SHIFT - 3);
851
852
853

	uasm_i_andi(p, tmp, tmp, (PTRS_PER_PGD - 1)<<3);
	uasm_i_daddu(p, ptr, ptr, tmp); /* add in pgd offset */
854
#ifndef __PAGETABLE_PMD_FOLDED
855
856
	uasm_i_dmfc0(p, tmp, C0_BADVADDR); /* get faulting address */
	uasm_i_ld(p, ptr, 0, ptr); /* get pmd pointer */
857
	uasm_i_dsrl_safe(p, tmp, tmp, PMD_SHIFT-3); /* get pmd offset in bytes */
858
859
	uasm_i_andi(p, tmp, tmp, (PTRS_PER_PMD - 1)<<3);
	uasm_i_daddu(p, ptr, ptr, tmp); /* add in pmd offset */
860
#endif
Linus Torvalds's avatar
Linus Torvalds committed
861
862
863
864
865
866
}

/*
 * BVADDR is the faulting address, PTR is scratch.
 * PTR will hold the pgd for vmalloc.
 */
867
static void
868
build_get_pgd_vmalloc64(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
869
870
			unsigned int bvaddr, unsigned int ptr,
			enum vmalloc64_mode mode)
Linus Torvalds's avatar
Linus Torvalds committed
871
872
{
	long swpd = (long)swapper_pg_dir;
873
874
875
876
	int single_insn_swpd;
	int did_vmalloc_branch = 0;

	single_insn_swpd = uasm_in_compat_space_p(swpd) && !uasm_rel_lo(swpd);
Linus Torvalds's avatar
Linus Torvalds committed
877

878
	uasm_l_vmalloc(l, *p);
Linus Torvalds's avatar
Linus Torvalds committed
879

880
	if (mode != not_refill && check_for_high_segbits) {
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
		if (single_insn_swpd) {
			uasm_il_bltz(p, r, bvaddr, label_vmalloc_done);
			uasm_i_lui(p, ptr, uasm_rel_hi(swpd));
			did_vmalloc_branch = 1;
			/* fall through */
		} else {
			uasm_il_bgez(p, r, bvaddr, label_large_segbits_fault);
		}
	}
	if (!did_vmalloc_branch) {
		if (uasm_in_compat_space_p(swpd) && !uasm_rel_lo(swpd)) {
			uasm_il_b(p, r, label_vmalloc_done);
			uasm_i_lui(p, ptr, uasm_rel_hi(swpd));
		} else {
			UASM_i_LA_mostly(p, ptr, swpd);
			uasm_il_b(p, r, label_vmalloc_done);
			if (uasm_in_compat_space_p(swpd))
				uasm_i_addiu(p, ptr, ptr, uasm_rel_lo(swpd));
			else
				uasm_i_daddiu(p, ptr, ptr, uasm_rel_lo(swpd));
		}
	}
903
	if (mode != not_refill && check_for_high_segbits) {
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
		uasm_l_large_segbits_fault(l, *p);
		/*
		 * We get here if we are an xsseg address, or if we are
		 * an xuseg address above (PGDIR_SHIFT+PGDIR_BITS) boundary.
		 *
		 * Ignoring xsseg (assume disabled so would generate
		 * (address errors?), the only remaining possibility
		 * is the upper xuseg addresses.  On processors with
		 * TLB_SEGBITS <= PGDIR_SHIFT+PGDIR_BITS, these
		 * addresses would have taken an address error. We try
		 * to mimic that here by taking a load/istream page
		 * fault.
		 */
		UASM_i_LA(p, ptr, (unsigned long)tlb_do_page_fault_0);
		uasm_i_jr(p, ptr);
919
920

		if (mode == refill_scratch) {
921
			if (scratch_reg >= 0)
922
				UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
923
924
925
926
927
			else
				UASM_i_LW(p, 1, scratchpad_offset(0), 0);
		} else {
			uasm_i_nop(p);
		}
Linus Torvalds's avatar
Linus Torvalds committed
928
929
930
	}
}

931
#else /* !CONFIG_64BIT */
Linus Torvalds's avatar
Linus Torvalds committed
932
933
934
935
936

/*
 * TMP and PTR are scratch.
 * TMP will be clobbered, PTR will hold the pgd entry.
 */
937
static void __maybe_unused
Linus Torvalds's avatar
Linus Torvalds committed
938
939
build_get_pgde32(u32 **p, unsigned int tmp, unsigned int ptr)
{
940
941
942
943
944
945
	if (pgd_reg != -1) {
		/* pgd is in pgd_reg */
		uasm_i_mfc0(p, ptr, c0_kscratch(), pgd_reg);
		uasm_i_mfc0(p, tmp, C0_BADVADDR); /* get faulting address */
	} else {
		long pgdc = (long)pgd_current;
Linus Torvalds's avatar
Linus Torvalds committed
946

947
		/* 32 bit SMP has smp_processor_id() stored in CONTEXT. */
Linus Torvalds's avatar
Linus Torvalds committed
948
#ifdef CONFIG_SMP
949
950
951
952
		uasm_i_mfc0(p, ptr, SMP_CPUID_REG);
		UASM_i_LA_mostly(p, tmp, pgdc);
		uasm_i_srl(p, ptr, ptr, SMP_CPUID_PTRSHIFT);
		uasm_i_addu(p, ptr, tmp, ptr);
Linus Torvalds's avatar
Linus Torvalds committed
953
#else
954
		UASM_i_LA_mostly(p, ptr, pgdc);
Linus Torvalds's avatar
Linus Torvalds committed
955
#endif
956
957
958
		uasm_i_mfc0(p, tmp, C0_BADVADDR); /* get faulting address */
		uasm_i_lw(p, ptr, uasm_rel_lo(pgdc), ptr);
	}
959
960
961
	uasm_i_srl(p, tmp, tmp, PGDIR_SHIFT); /* get pgd only bits */
	uasm_i_sll(p, tmp, tmp, PGD_T_LOG2);
	uasm_i_addu(p, ptr, ptr, tmp); /* add in pgd offset */
Linus Torvalds's avatar
Linus Torvalds committed
962
963
}

964
#endif /* !CONFIG_64BIT */
Linus Torvalds's avatar
Linus Torvalds committed
965

966
static void build_adjust_context(u32 **p, unsigned int ctx)
Linus Torvalds's avatar
Linus Torvalds committed
967
{
968
	unsigned int shift = 4 - (PTE_T_LOG2 + 1) + PAGE_SHIFT - 12;
Linus Torvalds's avatar
Linus Torvalds committed
969
970
	unsigned int mask = (PTRS_PER_PTE / 2 - 1) << (PTE_T_LOG2 + 1);

971
	switch (current_cpu_type()) {
Linus Torvalds's avatar
Linus Torvalds committed
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
	case CPU_VR41XX:
	case CPU_VR4111:
	case CPU_VR4121:
	case CPU_VR4122:
	case CPU_VR4131:
	case CPU_VR4181:
	case CPU_VR4181A:
	case CPU_VR4133:
		shift += 2;
		break;

	default:
		break;
	}

	if (shift)
988
989
		UASM_i_SRL(p, ctx, ctx, shift);
	uasm_i_andi(p, ctx, ctx, mask);
Linus Torvalds's avatar
Linus Torvalds committed
990
991
}

992
static void build_get_ptep(u32 **p, unsigned int tmp, unsigned int ptr)
Linus Torvalds's avatar
Linus Torvalds committed
993
994
995
996
997
998
999
1000
{
	/*
	 * Bug workaround for the Nevada. It seems as if under certain
	 * circumstances the move from cp0_context might produce a
	 * bogus result when the mfc0 instruction and its consumer are
	 * in a different cacheline or a load instruction, probably any
	 * memory reference, is between them.
	 */
For faster browsing, not all history is shown. View entire blame