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