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