]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * linux/arch/alpha/mm/init.c | |
4 | * | |
5 | * Copyright (C) 1995 Linus Torvalds | |
6 | */ | |
7 | ||
8 | /* 2.3.x zone allocator, 1999 Andrea Arcangeli <andrea@suse.de> */ | |
9 | ||
df2e71fb | 10 | #include <linux/pagemap.h> |
1da177e4 LT |
11 | #include <linux/signal.h> |
12 | #include <linux/sched.h> | |
13 | #include <linux/kernel.h> | |
14 | #include <linux/errno.h> | |
15 | #include <linux/string.h> | |
16 | #include <linux/types.h> | |
17 | #include <linux/ptrace.h> | |
18 | #include <linux/mman.h> | |
19 | #include <linux/mm.h> | |
20 | #include <linux/swap.h> | |
21 | #include <linux/init.h> | |
57c8a661 | 22 | #include <linux/memblock.h> /* max_low_pfn */ |
1da177e4 | 23 | #include <linux/vmalloc.h> |
5a0e3ad6 | 24 | #include <linux/gfp.h> |
1da177e4 | 25 | |
7c0f6ba6 | 26 | #include <linux/uaccess.h> |
1da177e4 LT |
27 | #include <asm/pgtable.h> |
28 | #include <asm/pgalloc.h> | |
29 | #include <asm/hwrpb.h> | |
30 | #include <asm/dma.h> | |
31 | #include <asm/mmu_context.h> | |
32 | #include <asm/console.h> | |
33 | #include <asm/tlb.h> | |
ec221208 | 34 | #include <asm/setup.h> |
f3beeb4a | 35 | #include <asm/sections.h> |
1da177e4 | 36 | |
1da177e4 LT |
37 | extern void die_if_kernel(char *,struct pt_regs *,long); |
38 | ||
39 | static struct pcb_struct original_pcb; | |
40 | ||
41 | pgd_t * | |
42 | pgd_alloc(struct mm_struct *mm) | |
43 | { | |
44 | pgd_t *ret, *init; | |
45 | ||
46 | ret = (pgd_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO); | |
47 | init = pgd_offset(&init_mm, 0UL); | |
48 | if (ret) { | |
49 | #ifdef CONFIG_ALPHA_LARGE_VMALLOC | |
50 | memcpy (ret + USER_PTRS_PER_PGD, init + USER_PTRS_PER_PGD, | |
51 | (PTRS_PER_PGD - USER_PTRS_PER_PGD - 1)*sizeof(pgd_t)); | |
52 | #else | |
53 | pgd_val(ret[PTRS_PER_PGD-2]) = pgd_val(init[PTRS_PER_PGD-2]); | |
54 | #endif | |
55 | ||
56 | /* The last PGD entry is the VPTB self-map. */ | |
57 | pgd_val(ret[PTRS_PER_PGD-1]) | |
58 | = pte_val(mk_pte(virt_to_page(ret), PAGE_KERNEL)); | |
59 | } | |
60 | return ret; | |
61 | } | |
62 | ||
1da177e4 LT |
63 | |
64 | /* | |
65 | * BAD_PAGE is the page that is used for page faults when linux | |
66 | * is out-of-memory. Older versions of linux just did a | |
67 | * do_exit(), but using this instead means there is less risk | |
68 | * for a process dying in kernel mode, possibly leaving an inode | |
69 | * unused etc.. | |
70 | * | |
71 | * BAD_PAGETABLE is the accompanying page-table: it is initialized | |
72 | * to point to BAD_PAGE entries. | |
73 | * | |
74 | * ZERO_PAGE is a special page that is used for zero-initialized | |
75 | * data and COW. | |
76 | */ | |
77 | pmd_t * | |
78 | __bad_pagetable(void) | |
79 | { | |
80 | memset((void *) EMPTY_PGT, 0, PAGE_SIZE); | |
81 | return (pmd_t *) EMPTY_PGT; | |
82 | } | |
83 | ||
84 | pte_t | |
85 | __bad_page(void) | |
86 | { | |
87 | memset((void *) EMPTY_PGE, 0, PAGE_SIZE); | |
88 | return pte_mkdirty(mk_pte(virt_to_page(EMPTY_PGE), PAGE_SHARED)); | |
89 | } | |
90 | ||
1da177e4 LT |
91 | static inline unsigned long |
92 | load_PCB(struct pcb_struct *pcb) | |
93 | { | |
94 | register unsigned long sp __asm__("$30"); | |
95 | pcb->ksp = sp; | |
96 | return __reload_thread(pcb); | |
97 | } | |
98 | ||
99 | /* Set up initial PCB, VPTB, and other such nicities. */ | |
100 | ||
101 | static inline void | |
102 | switch_to_system_map(void) | |
103 | { | |
104 | unsigned long newptbr; | |
105 | unsigned long original_pcb_ptr; | |
106 | ||
107 | /* Initialize the kernel's page tables. Linux puts the vptb in | |
108 | the last slot of the L1 page table. */ | |
109 | memset(swapper_pg_dir, 0, PAGE_SIZE); | |
110 | newptbr = ((unsigned long) swapper_pg_dir - PAGE_OFFSET) >> PAGE_SHIFT; | |
111 | pgd_val(swapper_pg_dir[1023]) = | |
112 | (newptbr << 32) | pgprot_val(PAGE_KERNEL); | |
113 | ||
114 | /* Set the vptb. This is often done by the bootloader, but | |
115 | shouldn't be required. */ | |
116 | if (hwrpb->vptb != 0xfffffffe00000000UL) { | |
117 | wrvptptr(0xfffffffe00000000UL); | |
118 | hwrpb->vptb = 0xfffffffe00000000UL; | |
119 | hwrpb_update_checksum(hwrpb); | |
120 | } | |
121 | ||
122 | /* Also set up the real kernel PCB while we're at it. */ | |
123 | init_thread_info.pcb.ptbr = newptbr; | |
124 | init_thread_info.pcb.flags = 1; /* set FEN, clear everything else */ | |
125 | original_pcb_ptr = load_PCB(&init_thread_info.pcb); | |
126 | tbia(); | |
127 | ||
128 | /* Save off the contents of the original PCB so that we can | |
129 | restore the original console's page tables for a clean reboot. | |
130 | ||
131 | Note that the PCB is supposed to be a physical address, but | |
132 | since KSEG values also happen to work, folks get confused. | |
133 | Check this here. */ | |
134 | ||
135 | if (original_pcb_ptr < PAGE_OFFSET) { | |
136 | original_pcb_ptr = (unsigned long) | |
137 | phys_to_virt(original_pcb_ptr); | |
138 | } | |
139 | original_pcb = *(struct pcb_struct *) original_pcb_ptr; | |
140 | } | |
141 | ||
142 | int callback_init_done; | |
143 | ||
144 | void * __init | |
145 | callback_init(void * kernel_end) | |
146 | { | |
147 | struct crb_struct * crb; | |
148 | pgd_t *pgd; | |
149 | pmd_t *pmd; | |
150 | void *two_pages; | |
151 | ||
152 | /* Starting at the HWRPB, locate the CRB. */ | |
153 | crb = (struct crb_struct *)((char *)hwrpb + hwrpb->crb_offset); | |
154 | ||
155 | if (alpha_using_srm) { | |
156 | /* Tell the console whither it is to be remapped. */ | |
157 | if (srm_fixup(VMALLOC_START, (unsigned long)hwrpb)) | |
158 | __halt(); /* "We're boned." --Bender */ | |
159 | ||
160 | /* Edit the procedure descriptors for DISPATCH and FIXUP. */ | |
161 | crb->dispatch_va = (struct procdesc_struct *) | |
162 | (VMALLOC_START + (unsigned long)crb->dispatch_va | |
163 | - crb->map[0].va); | |
164 | crb->fixup_va = (struct procdesc_struct *) | |
165 | (VMALLOC_START + (unsigned long)crb->fixup_va | |
166 | - crb->map[0].va); | |
167 | } | |
168 | ||
169 | switch_to_system_map(); | |
170 | ||
171 | /* Allocate one PGD and one PMD. In the case of SRM, we'll need | |
172 | these to actually remap the console. There is an assumption | |
173 | here that only one of each is needed, and this allows for 8MB. | |
174 | On systems with larger consoles, additional pages will be | |
175 | allocated as needed during the mapping process. | |
176 | ||
177 | In the case of not SRM, but not CONFIG_ALPHA_LARGE_VMALLOC, | |
178 | we need to allocate the PGD we use for vmalloc before we start | |
179 | forking other tasks. */ | |
180 | ||
181 | two_pages = (void *) | |
182 | (((unsigned long)kernel_end + ~PAGE_MASK) & PAGE_MASK); | |
183 | kernel_end = two_pages + 2*PAGE_SIZE; | |
184 | memset(two_pages, 0, 2*PAGE_SIZE); | |
185 | ||
186 | pgd = pgd_offset_k(VMALLOC_START); | |
187 | pgd_set(pgd, (pmd_t *)two_pages); | |
188 | pmd = pmd_offset(pgd, VMALLOC_START); | |
189 | pmd_set(pmd, (pte_t *)(two_pages + PAGE_SIZE)); | |
190 | ||
191 | if (alpha_using_srm) { | |
192 | static struct vm_struct console_remap_vm; | |
f0aa6617 TH |
193 | unsigned long nr_pages = 0; |
194 | unsigned long vaddr; | |
1da177e4 LT |
195 | unsigned long i, j; |
196 | ||
f0aa6617 TH |
197 | /* calculate needed size */ |
198 | for (i = 0; i < crb->map_entries; ++i) | |
199 | nr_pages += crb->map[i].count; | |
200 | ||
201 | /* register the vm area */ | |
202 | console_remap_vm.flags = VM_ALLOC; | |
203 | console_remap_vm.size = nr_pages << PAGE_SHIFT; | |
c0c0a293 | 204 | vm_area_register_early(&console_remap_vm, PAGE_SIZE); |
f0aa6617 | 205 | |
af6326d7 | 206 | vaddr = (unsigned long)console_remap_vm.addr; |
f0aa6617 | 207 | |
1da177e4 LT |
208 | /* Set up the third level PTEs and update the virtual |
209 | addresses of the CRB entries. */ | |
210 | for (i = 0; i < crb->map_entries; ++i) { | |
211 | unsigned long pfn = crb->map[i].pa >> PAGE_SHIFT; | |
212 | crb->map[i].va = vaddr; | |
213 | for (j = 0; j < crb->map[i].count; ++j) { | |
c3a2ddee | 214 | /* Newer consoles (especially on larger |
1da177e4 LT |
215 | systems) may require more pages of |
216 | PTEs. Grab additional pages as needed. */ | |
217 | if (pmd != pmd_offset(pgd, vaddr)) { | |
218 | memset(kernel_end, 0, PAGE_SIZE); | |
219 | pmd = pmd_offset(pgd, vaddr); | |
220 | pmd_set(pmd, (pte_t *)kernel_end); | |
221 | kernel_end += PAGE_SIZE; | |
222 | } | |
223 | set_pte(pte_offset_kernel(pmd, vaddr), | |
224 | pfn_pte(pfn, PAGE_KERNEL)); | |
225 | pfn++; | |
226 | vaddr += PAGE_SIZE; | |
227 | } | |
228 | } | |
1da177e4 LT |
229 | } |
230 | ||
231 | callback_init_done = 1; | |
232 | return kernel_end; | |
233 | } | |
234 | ||
235 | ||
236 | #ifndef CONFIG_DISCONTIGMEM | |
237 | /* | |
238 | * paging_init() sets up the memory map. | |
239 | */ | |
64d158bc | 240 | void __init paging_init(void) |
1da177e4 | 241 | { |
f06a9684 | 242 | unsigned long zones_size[MAX_NR_ZONES] = {0, }; |
1da177e4 LT |
243 | unsigned long dma_pfn, high_pfn; |
244 | ||
245 | dma_pfn = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT; | |
246 | high_pfn = max_pfn = max_low_pfn; | |
247 | ||
248 | if (dma_pfn >= high_pfn) | |
249 | zones_size[ZONE_DMA] = high_pfn; | |
250 | else { | |
251 | zones_size[ZONE_DMA] = dma_pfn; | |
252 | zones_size[ZONE_NORMAL] = high_pfn - dma_pfn; | |
253 | } | |
254 | ||
255 | /* Initialize mem_map[]. */ | |
256 | free_area_init(zones_size); | |
257 | ||
258 | /* Initialize the kernel's ZERO_PGE. */ | |
259 | memset((void *)ZERO_PGE, 0, PAGE_SIZE); | |
260 | } | |
261 | #endif /* CONFIG_DISCONTIGMEM */ | |
262 | ||
263 | #if defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_SRM) | |
264 | void | |
265 | srm_paging_stop (void) | |
266 | { | |
267 | /* Move the vptb back to where the SRM console expects it. */ | |
268 | swapper_pg_dir[1] = swapper_pg_dir[1023]; | |
269 | tbia(); | |
270 | wrvptptr(0x200000000UL); | |
271 | hwrpb->vptb = 0x200000000UL; | |
272 | hwrpb_update_checksum(hwrpb); | |
273 | ||
274 | /* Reload the page tables that the console had in use. */ | |
275 | load_PCB(&original_pcb); | |
276 | tbia(); | |
277 | } | |
278 | #endif | |
279 | ||
1da177e4 LT |
280 | void __init |
281 | mem_init(void) | |
282 | { | |
2fb1cd5a | 283 | set_max_mapnr(max_low_pfn); |
1da177e4 | 284 | high_memory = (void *) __va(max_low_pfn * PAGE_SIZE); |
c6ffc5ca | 285 | memblock_free_all(); |
d385d9ee | 286 | mem_init_print_info(NULL); |
1da177e4 | 287 | } |