]>
Commit | Line | Data |
---|---|---|
14cf11af | 1 | /* |
4c8d3d99 | 2 | * Modifications by Kumar Gala (galak@kernel.crashing.org) to support |
14cf11af PM |
3 | * E500 Book E processors. |
4 | * | |
5 | * Copyright 2004 Freescale Semiconductor, Inc | |
6 | * | |
7 | * This file contains the routines for initializing the MMU | |
8 | * on the 4xx series of chips. | |
9 | * -- paulus | |
10 | * | |
11 | * Derived from arch/ppc/mm/init.c: | |
12 | * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) | |
13 | * | |
14 | * Modifications by Paul Mackerras (PowerMac) (paulus@cs.anu.edu.au) | |
15 | * and Cort Dougan (PReP) (cort@cs.nmt.edu) | |
16 | * Copyright (C) 1996 Paul Mackerras | |
17 | * Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk). | |
18 | * | |
19 | * Derived from "arch/i386/mm/init.c" | |
20 | * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds | |
21 | * | |
22 | * This program is free software; you can redistribute it and/or | |
23 | * modify it under the terms of the GNU General Public License | |
24 | * as published by the Free Software Foundation; either version | |
25 | * 2 of the License, or (at your option) any later version. | |
26 | * | |
27 | */ | |
28 | ||
29 | #include <linux/config.h> | |
30 | #include <linux/signal.h> | |
31 | #include <linux/sched.h> | |
32 | #include <linux/kernel.h> | |
33 | #include <linux/errno.h> | |
34 | #include <linux/string.h> | |
35 | #include <linux/types.h> | |
36 | #include <linux/ptrace.h> | |
37 | #include <linux/mman.h> | |
38 | #include <linux/mm.h> | |
39 | #include <linux/swap.h> | |
40 | #include <linux/stddef.h> | |
41 | #include <linux/vmalloc.h> | |
42 | #include <linux/init.h> | |
43 | #include <linux/delay.h> | |
44 | #include <linux/highmem.h> | |
45 | ||
46 | #include <asm/pgalloc.h> | |
47 | #include <asm/prom.h> | |
48 | #include <asm/io.h> | |
49 | #include <asm/mmu_context.h> | |
50 | #include <asm/pgtable.h> | |
51 | #include <asm/mmu.h> | |
52 | #include <asm/uaccess.h> | |
53 | #include <asm/smp.h> | |
54 | #include <asm/bootx.h> | |
55 | #include <asm/machdep.h> | |
56 | #include <asm/setup.h> | |
57 | ||
58 | extern void loadcam_entry(unsigned int index); | |
59 | unsigned int tlbcam_index; | |
60 | unsigned int num_tlbcam_entries; | |
61 | static unsigned long __cam0, __cam1, __cam2; | |
62 | extern unsigned long total_lowmem; | |
63 | extern unsigned long __max_low_memory; | |
64 | #define MAX_LOW_MEM CONFIG_LOWMEM_SIZE | |
65 | ||
66 | #define NUM_TLBCAMS (16) | |
67 | ||
68 | struct tlbcam { | |
69 | u32 MAS0; | |
70 | u32 MAS1; | |
71 | u32 MAS2; | |
72 | u32 MAS3; | |
73 | u32 MAS7; | |
74 | } TLBCAM[NUM_TLBCAMS]; | |
75 | ||
76 | struct tlbcamrange { | |
77 | unsigned long start; | |
78 | unsigned long limit; | |
79 | phys_addr_t phys; | |
80 | } tlbcam_addrs[NUM_TLBCAMS]; | |
81 | ||
82 | extern unsigned int tlbcam_index; | |
83 | ||
84 | /* | |
85 | * Return PA for this VA if it is mapped by a CAM, or 0 | |
86 | */ | |
87 | unsigned long v_mapped_by_tlbcam(unsigned long va) | |
88 | { | |
89 | int b; | |
90 | for (b = 0; b < tlbcam_index; ++b) | |
91 | if (va >= tlbcam_addrs[b].start && va < tlbcam_addrs[b].limit) | |
92 | return tlbcam_addrs[b].phys + (va - tlbcam_addrs[b].start); | |
93 | return 0; | |
94 | } | |
95 | ||
96 | /* | |
97 | * Return VA for a given PA or 0 if not mapped | |
98 | */ | |
99 | unsigned long p_mapped_by_tlbcam(unsigned long pa) | |
100 | { | |
101 | int b; | |
102 | for (b = 0; b < tlbcam_index; ++b) | |
103 | if (pa >= tlbcam_addrs[b].phys | |
104 | && pa < (tlbcam_addrs[b].limit-tlbcam_addrs[b].start) | |
105 | +tlbcam_addrs[b].phys) | |
106 | return tlbcam_addrs[b].start+(pa-tlbcam_addrs[b].phys); | |
107 | return 0; | |
108 | } | |
109 | ||
110 | /* | |
111 | * Set up one of the I/D BAT (block address translation) register pairs. | |
112 | * The parameters are not checked; in particular size must be a power | |
113 | * of 4 between 4k and 256M. | |
114 | */ | |
115 | void settlbcam(int index, unsigned long virt, phys_addr_t phys, | |
116 | unsigned int size, int flags, unsigned int pid) | |
117 | { | |
118 | unsigned int tsize, lz; | |
119 | ||
120 | asm ("cntlzw %0,%1" : "=r" (lz) : "r" (size)); | |
121 | tsize = (21 - lz) / 2; | |
122 | ||
123 | #ifdef CONFIG_SMP | |
124 | if ((flags & _PAGE_NO_CACHE) == 0) | |
125 | flags |= _PAGE_COHERENT; | |
126 | #endif | |
127 | ||
128 | TLBCAM[index].MAS0 = MAS0_TLBSEL(1) | MAS0_ESEL(index) | MAS0_NV(index+1); | |
129 | TLBCAM[index].MAS1 = MAS1_VALID | MAS1_IPROT | MAS1_TSIZE(tsize) | MAS1_TID(pid); | |
130 | TLBCAM[index].MAS2 = virt & PAGE_MASK; | |
131 | ||
132 | TLBCAM[index].MAS2 |= (flags & _PAGE_WRITETHRU) ? MAS2_W : 0; | |
133 | TLBCAM[index].MAS2 |= (flags & _PAGE_NO_CACHE) ? MAS2_I : 0; | |
134 | TLBCAM[index].MAS2 |= (flags & _PAGE_COHERENT) ? MAS2_M : 0; | |
135 | TLBCAM[index].MAS2 |= (flags & _PAGE_GUARDED) ? MAS2_G : 0; | |
136 | TLBCAM[index].MAS2 |= (flags & _PAGE_ENDIAN) ? MAS2_E : 0; | |
137 | ||
138 | TLBCAM[index].MAS3 = (phys & PAGE_MASK) | MAS3_SX | MAS3_SR; | |
139 | TLBCAM[index].MAS3 |= ((flags & _PAGE_RW) ? MAS3_SW : 0); | |
140 | ||
141 | #ifndef CONFIG_KGDB /* want user access for breakpoints */ | |
142 | if (flags & _PAGE_USER) { | |
143 | TLBCAM[index].MAS3 |= MAS3_UX | MAS3_UR; | |
144 | TLBCAM[index].MAS3 |= ((flags & _PAGE_RW) ? MAS3_UW : 0); | |
145 | } | |
146 | #else | |
147 | TLBCAM[index].MAS3 |= MAS3_UX | MAS3_UR; | |
148 | TLBCAM[index].MAS3 |= ((flags & _PAGE_RW) ? MAS3_UW : 0); | |
149 | #endif | |
150 | ||
151 | tlbcam_addrs[index].start = virt; | |
152 | tlbcam_addrs[index].limit = virt + size - 1; | |
153 | tlbcam_addrs[index].phys = phys; | |
154 | ||
155 | loadcam_entry(index); | |
156 | } | |
157 | ||
158 | void invalidate_tlbcam_entry(int index) | |
159 | { | |
160 | TLBCAM[index].MAS0 = MAS0_TLBSEL(1) | MAS0_ESEL(index); | |
161 | TLBCAM[index].MAS1 = ~MAS1_VALID; | |
162 | ||
163 | loadcam_entry(index); | |
164 | } | |
165 | ||
166 | void __init cam_mapin_ram(unsigned long cam0, unsigned long cam1, | |
167 | unsigned long cam2) | |
168 | { | |
169 | settlbcam(0, KERNELBASE, PPC_MEMSTART, cam0, _PAGE_KERNEL, 0); | |
170 | tlbcam_index++; | |
171 | if (cam1) { | |
172 | tlbcam_index++; | |
173 | settlbcam(1, KERNELBASE+cam0, PPC_MEMSTART+cam0, cam1, _PAGE_KERNEL, 0); | |
174 | } | |
175 | if (cam2) { | |
176 | tlbcam_index++; | |
177 | settlbcam(2, KERNELBASE+cam0+cam1, PPC_MEMSTART+cam0+cam1, cam2, _PAGE_KERNEL, 0); | |
178 | } | |
179 | } | |
180 | ||
181 | /* | |
182 | * MMU_init_hw does the chip-specific initialization of the MMU hardware. | |
183 | */ | |
184 | void __init MMU_init_hw(void) | |
185 | { | |
186 | flush_instruction_cache(); | |
187 | } | |
188 | ||
189 | unsigned long __init mmu_mapin_ram(void) | |
190 | { | |
191 | cam_mapin_ram(__cam0, __cam1, __cam2); | |
192 | ||
193 | return __cam0 + __cam1 + __cam2; | |
194 | } | |
195 | ||
196 | ||
197 | void __init | |
198 | adjust_total_lowmem(void) | |
199 | { | |
200 | unsigned long max_low_mem = MAX_LOW_MEM; | |
201 | unsigned long cam_max = 0x10000000; | |
202 | unsigned long ram; | |
203 | ||
204 | /* adjust CAM size to max_low_mem */ | |
205 | if (max_low_mem < cam_max) | |
206 | cam_max = max_low_mem; | |
207 | ||
208 | /* adjust lowmem size to max_low_mem */ | |
209 | if (max_low_mem < total_lowmem) | |
210 | ram = max_low_mem; | |
211 | else | |
212 | ram = total_lowmem; | |
213 | ||
214 | /* Calculate CAM values */ | |
215 | __cam0 = 1UL << 2 * (__ilog2(ram) / 2); | |
216 | if (__cam0 > cam_max) | |
217 | __cam0 = cam_max; | |
218 | ram -= __cam0; | |
219 | if (ram) { | |
220 | __cam1 = 1UL << 2 * (__ilog2(ram) / 2); | |
221 | if (__cam1 > cam_max) | |
222 | __cam1 = cam_max; | |
223 | ram -= __cam1; | |
224 | } | |
225 | if (ram) { | |
226 | __cam2 = 1UL << 2 * (__ilog2(ram) / 2); | |
227 | if (__cam2 > cam_max) | |
228 | __cam2 = cam_max; | |
229 | ram -= __cam2; | |
230 | } | |
231 | ||
232 | printk(KERN_INFO "Memory CAM mapping: CAM0=%ldMb, CAM1=%ldMb," | |
233 | " CAM2=%ldMb residual: %ldMb\n", | |
234 | __cam0 >> 20, __cam1 >> 20, __cam2 >> 20, | |
235 | (total_lowmem - __cam0 - __cam1 - __cam2) >> 20); | |
236 | __max_low_memory = max_low_mem = __cam0 + __cam1 + __cam2; | |
237 | } |