Loading...
1/*
2 * r2300.c: R2000 and R3000 specific mmu/cache code.
3 *
4 * Copyright (C) 1996 David S. Miller (davem@davemloft.net)
5 *
6 * with a lot of changes to make this thing work for R3000s
7 * Tx39XX R4k style caches added. HK
8 * Copyright (C) 1998, 1999, 2000 Harald Koerfgen
9 * Copyright (C) 1998 Gleb Raiko & Vladimir Roganov
10 * Copyright (C) 2002 Ralf Baechle
11 * Copyright (C) 2002 Maciej W. Rozycki
12 */
13#include <linux/init.h>
14#include <linux/kernel.h>
15#include <linux/sched.h>
16#include <linux/smp.h>
17#include <linux/mm.h>
18
19#include <asm/page.h>
20#include <asm/pgtable.h>
21#include <asm/mmu_context.h>
22#include <asm/system.h>
23#include <asm/isadep.h>
24#include <asm/io.h>
25#include <asm/bootinfo.h>
26#include <asm/cpu.h>
27
28#undef DEBUG_TLB
29
30extern void build_tlb_refill_handler(void);
31
32/* CP0 hazard avoidance. */
33#define BARRIER \
34 __asm__ __volatile__( \
35 ".set push\n\t" \
36 ".set noreorder\n\t" \
37 "nop\n\t" \
38 ".set pop\n\t")
39
40int r3k_have_wired_reg; /* should be in cpu_data? */
41
42/* TLB operations. */
43void local_flush_tlb_all(void)
44{
45 unsigned long flags;
46 unsigned long old_ctx;
47 int entry;
48
49#ifdef DEBUG_TLB
50 printk("[tlball]");
51#endif
52
53 local_irq_save(flags);
54 old_ctx = read_c0_entryhi() & ASID_MASK;
55 write_c0_entrylo0(0);
56 entry = r3k_have_wired_reg ? read_c0_wired() : 8;
57 for (; entry < current_cpu_data.tlbsize; entry++) {
58 write_c0_index(entry << 8);
59 write_c0_entryhi((entry | 0x80000) << 12);
60 BARRIER;
61 tlb_write_indexed();
62 }
63 write_c0_entryhi(old_ctx);
64 local_irq_restore(flags);
65}
66
67void local_flush_tlb_mm(struct mm_struct *mm)
68{
69 int cpu = smp_processor_id();
70
71 if (cpu_context(cpu, mm) != 0) {
72#ifdef DEBUG_TLB
73 printk("[tlbmm<%lu>]", (unsigned long)cpu_context(cpu, mm));
74#endif
75 drop_mmu_context(mm, cpu);
76 }
77}
78
79void local_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
80 unsigned long end)
81{
82 struct mm_struct *mm = vma->vm_mm;
83 int cpu = smp_processor_id();
84
85 if (cpu_context(cpu, mm) != 0) {
86 unsigned long size, flags;
87
88#ifdef DEBUG_TLB
89 printk("[tlbrange<%lu,0x%08lx,0x%08lx>]",
90 cpu_context(cpu, mm) & ASID_MASK, start, end);
91#endif
92 local_irq_save(flags);
93 size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
94 if (size <= current_cpu_data.tlbsize) {
95 int oldpid = read_c0_entryhi() & ASID_MASK;
96 int newpid = cpu_context(cpu, mm) & ASID_MASK;
97
98 start &= PAGE_MASK;
99 end += PAGE_SIZE - 1;
100 end &= PAGE_MASK;
101 while (start < end) {
102 int idx;
103
104 write_c0_entryhi(start | newpid);
105 start += PAGE_SIZE; /* BARRIER */
106 tlb_probe();
107 idx = read_c0_index();
108 write_c0_entrylo0(0);
109 write_c0_entryhi(KSEG0);
110 if (idx < 0) /* BARRIER */
111 continue;
112 tlb_write_indexed();
113 }
114 write_c0_entryhi(oldpid);
115 } else {
116 drop_mmu_context(mm, cpu);
117 }
118 local_irq_restore(flags);
119 }
120}
121
122void local_flush_tlb_kernel_range(unsigned long start, unsigned long end)
123{
124 unsigned long size, flags;
125
126#ifdef DEBUG_TLB
127 printk("[tlbrange<%lu,0x%08lx,0x%08lx>]", start, end);
128#endif
129 local_irq_save(flags);
130 size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
131 if (size <= current_cpu_data.tlbsize) {
132 int pid = read_c0_entryhi();
133
134 start &= PAGE_MASK;
135 end += PAGE_SIZE - 1;
136 end &= PAGE_MASK;
137
138 while (start < end) {
139 int idx;
140
141 write_c0_entryhi(start);
142 start += PAGE_SIZE; /* BARRIER */
143 tlb_probe();
144 idx = read_c0_index();
145 write_c0_entrylo0(0);
146 write_c0_entryhi(KSEG0);
147 if (idx < 0) /* BARRIER */
148 continue;
149 tlb_write_indexed();
150 }
151 write_c0_entryhi(pid);
152 } else {
153 local_flush_tlb_all();
154 }
155 local_irq_restore(flags);
156}
157
158void local_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
159{
160 int cpu = smp_processor_id();
161
162 if (!vma || cpu_context(cpu, vma->vm_mm) != 0) {
163 unsigned long flags;
164 int oldpid, newpid, idx;
165
166#ifdef DEBUG_TLB
167 printk("[tlbpage<%lu,0x%08lx>]", cpu_context(cpu, vma->vm_mm), page);
168#endif
169 newpid = cpu_context(cpu, vma->vm_mm) & ASID_MASK;
170 page &= PAGE_MASK;
171 local_irq_save(flags);
172 oldpid = read_c0_entryhi() & ASID_MASK;
173 write_c0_entryhi(page | newpid);
174 BARRIER;
175 tlb_probe();
176 idx = read_c0_index();
177 write_c0_entrylo0(0);
178 write_c0_entryhi(KSEG0);
179 if (idx < 0) /* BARRIER */
180 goto finish;
181 tlb_write_indexed();
182
183finish:
184 write_c0_entryhi(oldpid);
185 local_irq_restore(flags);
186 }
187}
188
189void __update_tlb(struct vm_area_struct *vma, unsigned long address, pte_t pte)
190{
191 unsigned long flags;
192 int idx, pid;
193
194 /*
195 * Handle debugger faulting in for debugee.
196 */
197 if (current->active_mm != vma->vm_mm)
198 return;
199
200 pid = read_c0_entryhi() & ASID_MASK;
201
202#ifdef DEBUG_TLB
203 if ((pid != (cpu_context(cpu, vma->vm_mm) & ASID_MASK)) || (cpu_context(cpu, vma->vm_mm) == 0)) {
204 printk("update_mmu_cache: Wheee, bogus tlbpid mmpid=%lu tlbpid=%d\n",
205 (cpu_context(cpu, vma->vm_mm)), pid);
206 }
207#endif
208
209 local_irq_save(flags);
210 address &= PAGE_MASK;
211 write_c0_entryhi(address | pid);
212 BARRIER;
213 tlb_probe();
214 idx = read_c0_index();
215 write_c0_entrylo0(pte_val(pte));
216 write_c0_entryhi(address | pid);
217 if (idx < 0) { /* BARRIER */
218 tlb_write_random();
219 } else {
220 tlb_write_indexed();
221 }
222 write_c0_entryhi(pid);
223 local_irq_restore(flags);
224}
225
226void __init add_wired_entry(unsigned long entrylo0, unsigned long entrylo1,
227 unsigned long entryhi, unsigned long pagemask)
228{
229 unsigned long flags;
230 unsigned long old_ctx;
231 static unsigned long wired = 0;
232
233 if (r3k_have_wired_reg) { /* TX39XX */
234 unsigned long old_pagemask;
235 unsigned long w;
236
237#ifdef DEBUG_TLB
238 printk("[tlbwired<entry lo0 %8x, hi %8x\n, pagemask %8x>]\n",
239 entrylo0, entryhi, pagemask);
240#endif
241
242 local_irq_save(flags);
243 /* Save old context and create impossible VPN2 value */
244 old_ctx = read_c0_entryhi() & ASID_MASK;
245 old_pagemask = read_c0_pagemask();
246 w = read_c0_wired();
247 write_c0_wired(w + 1);
248 write_c0_index(w << 8);
249 write_c0_pagemask(pagemask);
250 write_c0_entryhi(entryhi);
251 write_c0_entrylo0(entrylo0);
252 BARRIER;
253 tlb_write_indexed();
254
255 write_c0_entryhi(old_ctx);
256 write_c0_pagemask(old_pagemask);
257 local_flush_tlb_all();
258 local_irq_restore(flags);
259
260 } else if (wired < 8) {
261#ifdef DEBUG_TLB
262 printk("[tlbwired<entry lo0 %8x, hi %8x\n>]\n",
263 entrylo0, entryhi);
264#endif
265
266 local_irq_save(flags);
267 old_ctx = read_c0_entryhi() & ASID_MASK;
268 write_c0_entrylo0(entrylo0);
269 write_c0_entryhi(entryhi);
270 write_c0_index(wired);
271 wired++; /* BARRIER */
272 tlb_write_indexed();
273 write_c0_entryhi(old_ctx);
274 local_flush_tlb_all();
275 local_irq_restore(flags);
276 }
277}
278
279void __cpuinit tlb_init(void)
280{
281 local_flush_tlb_all();
282
283 build_tlb_refill_handler();
284}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * r2300.c: R2000 and R3000 specific mmu/cache code.
4 *
5 * Copyright (C) 1996 David S. Miller (davem@davemloft.net)
6 *
7 * with a lot of changes to make this thing work for R3000s
8 * Tx39XX R4k style caches added. HK
9 * Copyright (C) 1998, 1999, 2000 Harald Koerfgen
10 * Copyright (C) 1998 Gleb Raiko & Vladimir Roganov
11 * Copyright (C) 2002 Ralf Baechle
12 * Copyright (C) 2002 Maciej W. Rozycki
13 */
14#include <linux/kernel.h>
15#include <linux/sched.h>
16#include <linux/smp.h>
17#include <linux/mm.h>
18
19#include <asm/page.h>
20#include <asm/mmu_context.h>
21#include <asm/tlbmisc.h>
22#include <asm/isadep.h>
23#include <asm/io.h>
24#include <asm/bootinfo.h>
25#include <asm/cpu.h>
26#include <asm/setup.h>
27#include <asm/tlbex.h>
28
29#undef DEBUG_TLB
30
31/* CP0 hazard avoidance. */
32#define BARRIER \
33 __asm__ __volatile__( \
34 ".set push\n\t" \
35 ".set noreorder\n\t" \
36 "nop\n\t" \
37 ".set pop\n\t")
38
39/* TLB operations. */
40static void local_flush_tlb_from(int entry)
41{
42 unsigned long old_ctx;
43
44 old_ctx = read_c0_entryhi() & cpu_asid_mask(¤t_cpu_data);
45 write_c0_entrylo0(0);
46 while (entry < current_cpu_data.tlbsize) {
47 write_c0_index(entry << 8);
48 write_c0_entryhi((entry | 0x80000) << 12);
49 entry++; /* BARRIER */
50 tlb_write_indexed();
51 }
52 write_c0_entryhi(old_ctx);
53}
54
55void local_flush_tlb_all(void)
56{
57 unsigned long flags;
58
59#ifdef DEBUG_TLB
60 printk("[tlball]");
61#endif
62 local_irq_save(flags);
63 local_flush_tlb_from(8);
64 local_irq_restore(flags);
65}
66
67void local_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
68 unsigned long end)
69{
70 unsigned long asid_mask = cpu_asid_mask(¤t_cpu_data);
71 struct mm_struct *mm = vma->vm_mm;
72 int cpu = smp_processor_id();
73
74 if (cpu_context(cpu, mm) != 0) {
75 unsigned long size, flags;
76
77#ifdef DEBUG_TLB
78 printk("[tlbrange<%lu,0x%08lx,0x%08lx>]",
79 cpu_context(cpu, mm) & asid_mask, start, end);
80#endif
81 local_irq_save(flags);
82 size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
83 if (size <= current_cpu_data.tlbsize) {
84 int oldpid = read_c0_entryhi() & asid_mask;
85 int newpid = cpu_context(cpu, mm) & asid_mask;
86
87 start &= PAGE_MASK;
88 end += PAGE_SIZE - 1;
89 end &= PAGE_MASK;
90 while (start < end) {
91 int idx;
92
93 write_c0_entryhi(start | newpid);
94 start += PAGE_SIZE; /* BARRIER */
95 tlb_probe();
96 idx = read_c0_index();
97 write_c0_entrylo0(0);
98 write_c0_entryhi(KSEG0);
99 if (idx < 0) /* BARRIER */
100 continue;
101 tlb_write_indexed();
102 }
103 write_c0_entryhi(oldpid);
104 } else {
105 drop_mmu_context(mm);
106 }
107 local_irq_restore(flags);
108 }
109}
110
111void local_flush_tlb_kernel_range(unsigned long start, unsigned long end)
112{
113 unsigned long size, flags;
114
115#ifdef DEBUG_TLB
116 printk("[tlbrange<%lu,0x%08lx,0x%08lx>]", start, end);
117#endif
118 local_irq_save(flags);
119 size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
120 if (size <= current_cpu_data.tlbsize) {
121 int pid = read_c0_entryhi();
122
123 start &= PAGE_MASK;
124 end += PAGE_SIZE - 1;
125 end &= PAGE_MASK;
126
127 while (start < end) {
128 int idx;
129
130 write_c0_entryhi(start);
131 start += PAGE_SIZE; /* BARRIER */
132 tlb_probe();
133 idx = read_c0_index();
134 write_c0_entrylo0(0);
135 write_c0_entryhi(KSEG0);
136 if (idx < 0) /* BARRIER */
137 continue;
138 tlb_write_indexed();
139 }
140 write_c0_entryhi(pid);
141 } else {
142 local_flush_tlb_all();
143 }
144 local_irq_restore(flags);
145}
146
147void local_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
148{
149 unsigned long asid_mask = cpu_asid_mask(¤t_cpu_data);
150 int cpu = smp_processor_id();
151
152 if (cpu_context(cpu, vma->vm_mm) != 0) {
153 unsigned long flags;
154 int oldpid, newpid, idx;
155
156#ifdef DEBUG_TLB
157 printk("[tlbpage<%lu,0x%08lx>]", cpu_context(cpu, vma->vm_mm), page);
158#endif
159 newpid = cpu_context(cpu, vma->vm_mm) & asid_mask;
160 page &= PAGE_MASK;
161 local_irq_save(flags);
162 oldpid = read_c0_entryhi() & asid_mask;
163 write_c0_entryhi(page | newpid);
164 BARRIER;
165 tlb_probe();
166 idx = read_c0_index();
167 write_c0_entrylo0(0);
168 write_c0_entryhi(KSEG0);
169 if (idx < 0) /* BARRIER */
170 goto finish;
171 tlb_write_indexed();
172
173finish:
174 write_c0_entryhi(oldpid);
175 local_irq_restore(flags);
176 }
177}
178
179void __update_tlb(struct vm_area_struct *vma, unsigned long address, pte_t pte)
180{
181 unsigned long asid_mask = cpu_asid_mask(¤t_cpu_data);
182 unsigned long flags;
183 int idx, pid;
184
185 /*
186 * Handle debugger faulting in for debuggee.
187 */
188 if (current->active_mm != vma->vm_mm)
189 return;
190
191 pid = read_c0_entryhi() & asid_mask;
192
193#ifdef DEBUG_TLB
194 if ((pid != (cpu_context(cpu, vma->vm_mm) & asid_mask)) || (cpu_context(cpu, vma->vm_mm) == 0)) {
195 printk("update_mmu_cache: Wheee, bogus tlbpid mmpid=%lu tlbpid=%d\n",
196 (cpu_context(cpu, vma->vm_mm)), pid);
197 }
198#endif
199
200 local_irq_save(flags);
201 address &= PAGE_MASK;
202 write_c0_entryhi(address | pid);
203 BARRIER;
204 tlb_probe();
205 idx = read_c0_index();
206 write_c0_entrylo0(pte_val(pte));
207 write_c0_entryhi(address | pid);
208 if (idx < 0) { /* BARRIER */
209 tlb_write_random();
210 } else {
211 tlb_write_indexed();
212 }
213 write_c0_entryhi(pid);
214 local_irq_restore(flags);
215}
216
217void add_wired_entry(unsigned long entrylo0, unsigned long entrylo1,
218 unsigned long entryhi, unsigned long pagemask)
219{
220 unsigned long asid_mask = cpu_asid_mask(¤t_cpu_data);
221 unsigned long flags;
222 unsigned long old_ctx;
223 static unsigned long wired = 0;
224
225 if (wired < 8) {
226#ifdef DEBUG_TLB
227 printk("[tlbwired<entry lo0 %8x, hi %8x\n>]\n",
228 entrylo0, entryhi);
229#endif
230
231 local_irq_save(flags);
232 old_ctx = read_c0_entryhi() & asid_mask;
233 write_c0_entrylo0(entrylo0);
234 write_c0_entryhi(entryhi);
235 write_c0_index(wired);
236 wired++; /* BARRIER */
237 tlb_write_indexed();
238 write_c0_entryhi(old_ctx);
239 local_flush_tlb_all();
240 local_irq_restore(flags);
241 }
242}
243
244void tlb_init(void)
245{
246 local_flush_tlb_from(0);
247 build_tlb_refill_handler();
248}