Pull bugfix into test branch
[linux-2.6] / arch / mips / mm / pg-r4k.c
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  * Copyright (C) 2003, 04, 05 Ralf Baechle (ralf@linux-mips.org)
7  */
8 #include <linux/init.h>
9 #include <linux/kernel.h>
10 #include <linux/sched.h>
11 #include <linux/mm.h>
12 #include <linux/module.h>
13 #include <linux/proc_fs.h>
14
15 #include <asm/cacheops.h>
16 #include <asm/inst.h>
17 #include <asm/io.h>
18 #include <asm/page.h>
19 #include <asm/pgtable.h>
20 #include <asm/prefetch.h>
21 #include <asm/system.h>
22 #include <asm/bootinfo.h>
23 #include <asm/mipsregs.h>
24 #include <asm/mmu_context.h>
25 #include <asm/cpu.h>
26 #include <asm/war.h>
27
28 #define half_scache_line_size() (cpu_scache_line_size() >> 1)
29 #define cpu_is_r4600_v1_x()     ((read_c0_prid() & 0xfffffff0) == 0x00002010)
30 #define cpu_is_r4600_v2_x()     ((read_c0_prid() & 0xfffffff0) == 0x00002020)
31
32
33 /*
34  * Maximum sizes:
35  *
36  * R4000 128 bytes S-cache:             0x58 bytes
37  * R4600 v1.7:                          0x5c bytes
38  * R4600 v2.0:                          0x60 bytes
39  * With prefetching, 16 byte strides    0xa0 bytes
40  */
41
42 static unsigned int clear_page_array[0x130 / 4];
43
44 void clear_page(void * page) __attribute__((alias("clear_page_array")));
45
46 EXPORT_SYMBOL(clear_page);
47
48 /*
49  * Maximum sizes:
50  *
51  * R4000 128 bytes S-cache:             0x11c bytes
52  * R4600 v1.7:                          0x080 bytes
53  * R4600 v2.0:                          0x07c bytes
54  * With prefetching, 16 byte strides    0x0b8 bytes
55  */
56 static unsigned int copy_page_array[0x148 / 4];
57
58 void copy_page(void *to, void *from) __attribute__((alias("copy_page_array")));
59
60 EXPORT_SYMBOL(copy_page);
61
62 /*
63  * This is suboptimal for 32-bit kernels; we assume that R10000 is only used
64  * with 64-bit kernels.  The prefetch offsets have been experimentally tuned
65  * an Origin 200.
66  */
67 static int pref_offset_clear __initdata = 512;
68 static int pref_offset_copy  __initdata = 256;
69
70 static unsigned int pref_src_mode __initdata;
71 static unsigned int pref_dst_mode __initdata;
72
73 static int load_offset __initdata;
74 static int store_offset __initdata;
75
76 static unsigned int __initdata *dest, *epc;
77
78 static unsigned int instruction_pending;
79 static union mips_instruction delayed_mi;
80
81 static void __init emit_instruction(union mips_instruction mi)
82 {
83         if (instruction_pending)
84                 *epc++ = delayed_mi.word;
85
86         instruction_pending = 1;
87         delayed_mi = mi;
88 }
89
90 static inline void flush_delay_slot_or_nop(void)
91 {
92         if (instruction_pending) {
93                 *epc++ = delayed_mi.word;
94                 instruction_pending = 0;
95                 return;
96         }
97
98         *epc++ = 0;
99 }
100
101 static inline unsigned int *label(void)
102 {
103         if (instruction_pending) {
104                 *epc++ = delayed_mi.word;
105                 instruction_pending = 0;
106         }
107
108         return epc;
109 }
110
111 static inline void build_insn_word(unsigned int word)
112 {
113         union mips_instruction mi;
114
115         mi.word          = word;
116
117         emit_instruction(mi);
118 }
119
120 static inline void build_nop(void)
121 {
122         build_insn_word(0);                     /* nop */
123 }
124
125 static inline void build_src_pref(int advance)
126 {
127         if (!(load_offset & (cpu_dcache_line_size() - 1)) && advance) {
128                 union mips_instruction mi;
129
130                 mi.i_format.opcode     = pref_op;
131                 mi.i_format.rs         = 5;             /* $a1 */
132                 mi.i_format.rt         = pref_src_mode;
133                 mi.i_format.simmediate = load_offset + advance;
134
135                 emit_instruction(mi);
136         }
137 }
138
139 static inline void __build_load_reg(int reg)
140 {
141         union mips_instruction mi;
142         unsigned int width;
143
144         if (cpu_has_64bit_gp_regs) {
145                 mi.i_format.opcode     = ld_op;
146                 width = 8;
147         } else {
148                 mi.i_format.opcode     = lw_op;
149                 width = 4;
150         }
151         mi.i_format.rs         = 5;             /* $a1 */
152         mi.i_format.rt         = reg;           /* $reg */
153         mi.i_format.simmediate = load_offset;
154
155         load_offset += width;
156         emit_instruction(mi);
157 }
158
159 static inline void build_load_reg(int reg)
160 {
161         if (cpu_has_prefetch)
162                 build_src_pref(pref_offset_copy);
163
164         __build_load_reg(reg);
165 }
166
167 static inline void build_dst_pref(int advance)
168 {
169         if (!(store_offset & (cpu_dcache_line_size() - 1)) && advance) {
170                 union mips_instruction mi;
171
172                 mi.i_format.opcode     = pref_op;
173                 mi.i_format.rs         = 4;             /* $a0 */
174                 mi.i_format.rt         = pref_dst_mode;
175                 mi.i_format.simmediate = store_offset + advance;
176
177                 emit_instruction(mi);
178         }
179 }
180
181 static inline void build_cdex_s(void)
182 {
183         union mips_instruction mi;
184
185         if ((store_offset & (cpu_scache_line_size() - 1)))
186                 return;
187
188         mi.c_format.opcode     = cache_op;
189         mi.c_format.rs         = 4;             /* $a0 */
190         mi.c_format.c_op       = 3;             /* Create Dirty Exclusive */
191         mi.c_format.cache      = 3;             /* Secondary Data Cache */
192         mi.c_format.simmediate = store_offset;
193
194         emit_instruction(mi);
195 }
196
197 static inline void build_cdex_p(void)
198 {
199         union mips_instruction mi;
200
201         if (store_offset & (cpu_dcache_line_size() - 1))
202                 return;
203
204         if (R4600_V1_HIT_CACHEOP_WAR && cpu_is_r4600_v1_x()) {
205                 build_nop();
206                 build_nop();
207                 build_nop();
208                 build_nop();
209         }
210
211         if (R4600_V2_HIT_CACHEOP_WAR && cpu_is_r4600_v2_x())
212                 build_insn_word(0x3c01a000);    /* lui     $at, 0xa000  */
213
214         mi.c_format.opcode     = cache_op;
215         mi.c_format.rs         = 4;             /* $a0 */
216         mi.c_format.c_op       = 3;             /* Create Dirty Exclusive */
217         mi.c_format.cache      = 1;             /* Data Cache */
218         mi.c_format.simmediate = store_offset;
219
220         emit_instruction(mi);
221 }
222
223 static void __init __build_store_reg(int reg)
224 {
225         union mips_instruction mi;
226         unsigned int width;
227
228         if (cpu_has_64bit_gp_regs ||
229             (cpu_has_64bit_zero_reg && reg == 0)) {
230                 mi.i_format.opcode     = sd_op;
231                 width = 8;
232         } else {
233                 mi.i_format.opcode     = sw_op;
234                 width = 4;
235         }
236         mi.i_format.rs         = 4;             /* $a0 */
237         mi.i_format.rt         = reg;           /* $reg */
238         mi.i_format.simmediate = store_offset;
239
240         store_offset += width;
241         emit_instruction(mi);
242 }
243
244 static inline void build_store_reg(int reg)
245 {
246         if (cpu_has_prefetch)
247                 if (reg)
248                         build_dst_pref(pref_offset_copy);
249                 else
250                         build_dst_pref(pref_offset_clear);
251         else if (cpu_has_cache_cdex_s)
252                 build_cdex_s();
253         else if (cpu_has_cache_cdex_p)
254                 build_cdex_p();
255
256         __build_store_reg(reg);
257 }
258
259 static inline void build_addiu_a2_a0(unsigned long offset)
260 {
261         union mips_instruction mi;
262
263         BUG_ON(offset > 0x7fff);
264
265         mi.i_format.opcode     = cpu_has_64bit_gp_regs ? daddiu_op : addiu_op;
266         mi.i_format.rs         = 4;             /* $a0 */
267         mi.i_format.rt         = 6;             /* $a2 */
268         mi.i_format.simmediate = offset;
269
270         emit_instruction(mi);
271 }
272
273 static inline void build_addiu_a2(unsigned long offset)
274 {
275         union mips_instruction mi;
276
277         BUG_ON(offset > 0x7fff);
278
279         mi.i_format.opcode     = cpu_has_64bit_gp_regs ? daddiu_op : addiu_op;
280         mi.i_format.rs         = 6;             /* $a2 */
281         mi.i_format.rt         = 6;             /* $a2 */
282         mi.i_format.simmediate = offset;
283
284         emit_instruction(mi);
285 }
286
287 static inline void build_addiu_a1(unsigned long offset)
288 {
289         union mips_instruction mi;
290
291         BUG_ON(offset > 0x7fff);
292
293         mi.i_format.opcode     = cpu_has_64bit_gp_regs ? daddiu_op : addiu_op;
294         mi.i_format.rs         = 5;             /* $a1 */
295         mi.i_format.rt         = 5;             /* $a1 */
296         mi.i_format.simmediate = offset;
297
298         load_offset -= offset;
299
300         emit_instruction(mi);
301 }
302
303 static inline void build_addiu_a0(unsigned long offset)
304 {
305         union mips_instruction mi;
306
307         BUG_ON(offset > 0x7fff);
308
309         mi.i_format.opcode     = cpu_has_64bit_gp_regs ? daddiu_op : addiu_op;
310         mi.i_format.rs         = 4;             /* $a0 */
311         mi.i_format.rt         = 4;             /* $a0 */
312         mi.i_format.simmediate = offset;
313
314         store_offset -= offset;
315
316         emit_instruction(mi);
317 }
318
319 static inline void build_bne(unsigned int *dest)
320 {
321         union mips_instruction mi;
322
323         mi.i_format.opcode = bne_op;
324         mi.i_format.rs     = 6;                 /* $a2 */
325         mi.i_format.rt     = 4;                 /* $a0 */
326         mi.i_format.simmediate = dest - epc - 1;
327
328         *epc++ = mi.word;
329         flush_delay_slot_or_nop();
330 }
331
332 static inline void build_jr_ra(void)
333 {
334         union mips_instruction mi;
335
336         mi.r_format.opcode = spec_op;
337         mi.r_format.rs     = 31;
338         mi.r_format.rt     = 0;
339         mi.r_format.rd     = 0;
340         mi.r_format.re     = 0;
341         mi.r_format.func   = jr_op;
342
343         *epc++ = mi.word;
344         flush_delay_slot_or_nop();
345 }
346
347 void __init build_clear_page(void)
348 {
349         unsigned int loop_start;
350         unsigned long off;
351
352         epc = (unsigned int *) &clear_page_array;
353         instruction_pending = 0;
354         store_offset = 0;
355
356         if (cpu_has_prefetch) {
357                 switch (current_cpu_data.cputype) {
358                 case CPU_TX49XX:
359                         /* TX49 supports only Pref_Load */
360                         pref_offset_clear = 0;
361                         pref_offset_copy = 0;
362                         break;
363
364                 case CPU_RM9000:
365                         /*
366                          * As a workaround for erratum G105 which make the
367                          * PrepareForStore hint unusable we fall back to
368                          * StoreRetained on the RM9000.  Once it is known which
369                          * versions of the RM9000 we'll be able to condition-
370                          * alize this.
371                          */
372
373                 case CPU_R10000:
374                 case CPU_R12000:
375                 case CPU_R14000:
376                         pref_src_mode = Pref_LoadStreamed;
377                         pref_dst_mode = Pref_StoreStreamed;
378                         break;
379
380                 default:
381                         pref_src_mode = Pref_LoadStreamed;
382                         pref_dst_mode = Pref_PrepareForStore;
383                         break;
384                 }
385         }
386
387         off = PAGE_SIZE - (cpu_has_prefetch ? pref_offset_clear : 0);
388         if (off > 0x7fff) {
389                 build_addiu_a2_a0(off >> 1);
390                 build_addiu_a2(off >> 1);
391         } else
392                 build_addiu_a2_a0(off);
393
394         if (R4600_V2_HIT_CACHEOP_WAR && cpu_is_r4600_v2_x())
395                 build_insn_word(0x3c01a000);    /* lui     $at, 0xa000  */
396
397 dest = label();
398         do {
399                 build_store_reg(0);
400                 build_store_reg(0);
401                 build_store_reg(0);
402                 build_store_reg(0);
403         } while (store_offset < half_scache_line_size());
404         build_addiu_a0(2 * store_offset);
405         loop_start = store_offset;
406         do {
407                 build_store_reg(0);
408                 build_store_reg(0);
409                 build_store_reg(0);
410                 build_store_reg(0);
411         } while ((store_offset - loop_start) < half_scache_line_size());
412         build_bne(dest);
413
414         if (cpu_has_prefetch && pref_offset_clear) {
415                 build_addiu_a2_a0(pref_offset_clear);
416         dest = label();
417                 loop_start = store_offset;
418                 do {
419                         __build_store_reg(0);
420                         __build_store_reg(0);
421                         __build_store_reg(0);
422                         __build_store_reg(0);
423                 } while ((store_offset - loop_start) < half_scache_line_size());
424                 build_addiu_a0(2 * store_offset);
425                 loop_start = store_offset;
426                 do {
427                         __build_store_reg(0);
428                         __build_store_reg(0);
429                         __build_store_reg(0);
430                         __build_store_reg(0);
431                 } while ((store_offset - loop_start) < half_scache_line_size());
432                 build_bne(dest);
433         }
434
435         build_jr_ra();
436
437         BUG_ON(epc > clear_page_array + ARRAY_SIZE(clear_page_array));
438 }
439
440 void __init build_copy_page(void)
441 {
442         unsigned int loop_start;
443         unsigned long off;
444
445         epc = (unsigned int *) &copy_page_array;
446         store_offset = load_offset = 0;
447         instruction_pending = 0;
448
449         off = PAGE_SIZE - (cpu_has_prefetch ? pref_offset_copy : 0);
450         if (off > 0x7fff) {
451                 build_addiu_a2_a0(off >> 1);
452                 build_addiu_a2(off >> 1);
453         } else
454                 build_addiu_a2_a0(off);
455
456         if (R4600_V2_HIT_CACHEOP_WAR && cpu_is_r4600_v2_x())
457                 build_insn_word(0x3c01a000);    /* lui     $at, 0xa000  */
458
459 dest = label();
460         loop_start = store_offset;
461         do {
462                 build_load_reg( 8);
463                 build_load_reg( 9);
464                 build_load_reg(10);
465                 build_load_reg(11);
466                 build_store_reg( 8);
467                 build_store_reg( 9);
468                 build_store_reg(10);
469                 build_store_reg(11);
470         } while ((store_offset - loop_start) < half_scache_line_size());
471         build_addiu_a0(2 * store_offset);
472         build_addiu_a1(2 * load_offset);
473         loop_start = store_offset;
474         do {
475                 build_load_reg( 8);
476                 build_load_reg( 9);
477                 build_load_reg(10);
478                 build_load_reg(11);
479                 build_store_reg( 8);
480                 build_store_reg( 9);
481                 build_store_reg(10);
482                 build_store_reg(11);
483         } while ((store_offset - loop_start) < half_scache_line_size());
484         build_bne(dest);
485
486         if (cpu_has_prefetch && pref_offset_copy) {
487                 build_addiu_a2_a0(pref_offset_copy);
488         dest = label();
489                 loop_start = store_offset;
490                 do {
491                         __build_load_reg( 8);
492                         __build_load_reg( 9);
493                         __build_load_reg(10);
494                         __build_load_reg(11);
495                         __build_store_reg( 8);
496                         __build_store_reg( 9);
497                         __build_store_reg(10);
498                         __build_store_reg(11);
499                 } while ((store_offset - loop_start) < half_scache_line_size());
500                 build_addiu_a0(2 * store_offset);
501                 build_addiu_a1(2 * load_offset);
502                 loop_start = store_offset;
503                 do {
504                         __build_load_reg( 8);
505                         __build_load_reg( 9);
506                         __build_load_reg(10);
507                         __build_load_reg(11);
508                         __build_store_reg( 8);
509                         __build_store_reg( 9);
510                         __build_store_reg(10);
511                         __build_store_reg(11);
512                 } while ((store_offset - loop_start) < half_scache_line_size());
513                 build_bne(dest);
514         }
515
516         build_jr_ra();
517
518         BUG_ON(epc > copy_page_array + ARRAY_SIZE(copy_page_array));
519 }