File: /usr/src/linux/arch/mips64/mm/init.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) 1994 - 2000 by Ralf Baechle
7 * Copyright (C) 1999, 2000 by Silicon Graphics
8 */
9 #include <linux/config.h>
10 #include <linux/init.h>
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/pagemap.h>
18 #include <linux/ptrace.h>
19 #include <linux/mman.h>
20 #include <linux/mm.h>
21 #include <linux/bootmem.h>
22 #include <linux/highmem.h>
23 #include <linux/swap.h>
24 #include <linux/swapctl.h>
25 #ifdef CONFIG_BLK_DEV_INITRD
26 #include <linux/blk.h>
27 #endif
28
29 #include <asm/bootinfo.h>
30 #include <asm/cachectl.h>
31 #include <asm/dma.h>
32 #include <asm/system.h>
33 #include <asm/pgtable.h>
34 #include <asm/pgalloc.h>
35 #ifdef CONFIG_SGI_IP22
36 #include <asm/sgialib.h>
37 #endif
38 #include <asm/mmu_context.h>
39 #include <asm/tlb.h>
40
41 mmu_gather_t mmu_gathers[NR_CPUS];
42
43 unsigned long totalram_pages;
44
45 void pgd_init(unsigned long page)
46 {
47 unsigned long *p, *end;
48
49 p = (unsigned long *) page;
50 end = p + PTRS_PER_PGD;
51
52 while (p < end) {
53 p[0] = (unsigned long) invalid_pmd_table;
54 p[1] = (unsigned long) invalid_pmd_table;
55 p[2] = (unsigned long) invalid_pmd_table;
56 p[3] = (unsigned long) invalid_pmd_table;
57 p[4] = (unsigned long) invalid_pmd_table;
58 p[5] = (unsigned long) invalid_pmd_table;
59 p[6] = (unsigned long) invalid_pmd_table;
60 p[7] = (unsigned long) invalid_pmd_table;
61 p += 8;
62 }
63 }
64
65 pgd_t *get_pgd_slow(void)
66 {
67 pgd_t *ret, *init;
68
69 ret = (pgd_t *) __get_free_pages(GFP_KERNEL, 1);
70 if (ret) {
71 init = pgd_offset(&init_mm, 0);
72 pgd_init((unsigned long)ret);
73 memcpy(ret + USER_PTRS_PER_PGD, init + USER_PTRS_PER_PGD,
74 (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
75 }
76 return ret;
77 }
78
79 void pmd_init(unsigned long addr, unsigned long pagetable)
80 {
81 unsigned long *p, *end;
82
83 p = (unsigned long *) addr;
84 end = p + PTRS_PER_PMD;
85
86 while (p < end) {
87 p[0] = (unsigned long)pagetable;
88 p[1] = (unsigned long)pagetable;
89 p[2] = (unsigned long)pagetable;
90 p[3] = (unsigned long)pagetable;
91 p[4] = (unsigned long)pagetable;
92 p[5] = (unsigned long)pagetable;
93 p[6] = (unsigned long)pagetable;
94 p[7] = (unsigned long)pagetable;
95 p += 8;
96 }
97 }
98
99 int do_check_pgt_cache(int low, int high)
100 {
101 int freed = 0;
102
103 if (pgtable_cache_size > high) {
104 do {
105 if (pgd_quicklist)
106 free_pgd_slow(get_pgd_fast()), freed++;
107 if (pmd_quicklist)
108 free_pmd_slow(get_pmd_fast()), freed++;
109 if (pte_quicklist)
110 free_pte_slow(get_pte_fast()), freed++;
111 } while (pgtable_cache_size > low);
112 }
113 return freed;
114 }
115
116
117 asmlinkage int sys_cacheflush(void *addr, int bytes, int cache)
118 {
119 /* XXX Just get it working for now... */
120 flush_cache_l1();
121 return 0;
122 }
123
124 /*
125 * We have up to 8 empty zeroed pages so we can map one of the right colour
126 * when needed. This is necessary only on R4000 / R4400 SC and MC versions
127 * where we have to avoid VCED / VECI exceptions for good performance at
128 * any price. Since page is never written to after the initialization we
129 * don't have to care about aliases on other CPUs.
130 */
131 unsigned long empty_zero_page, zero_page_mask;
132
133 unsigned long setup_zero_pages(void)
134 {
135 unsigned long order, size;
136 struct page *page;
137
138 switch (mips_cputype) {
139 case CPU_R4000SC:
140 case CPU_R4000MC:
141 case CPU_R4400SC:
142 case CPU_R4400MC:
143 order = 3;
144 break;
145 default:
146 order = 0;
147 }
148
149 empty_zero_page = __get_free_pages(GFP_KERNEL, order);
150 if (!empty_zero_page)
151 panic("Oh boy, that early out of memory?");
152
153 page = virt_to_page(empty_zero_page);
154 while (page < virt_to_page(empty_zero_page + (PAGE_SIZE << order))) {
155 set_bit(PG_reserved, &page->flags);
156 set_page_count(page, 0);
157 page++;
158 }
159
160 size = PAGE_SIZE << order;
161 zero_page_mask = (size - 1) & PAGE_MASK;
162 memset((void *)empty_zero_page, 0, size);
163
164 return 1UL << order;
165 }
166
167 void __init add_memory_region(unsigned long start, unsigned long size,
168 long type)
169 {
170 int x = boot_mem_map.nr_map;
171
172 if (x == BOOT_MEM_MAP_MAX) {
173 printk("Ooops! Too many entries in the memory map!\n");
174 return;
175 }
176
177 boot_mem_map.map[x].addr = start;
178 boot_mem_map.map[x].size = size;
179 boot_mem_map.map[x].type = type;
180 boot_mem_map.nr_map++;
181 }
182
183 static void __init print_memory_map(void)
184 {
185 int i;
186
187 for (i = 0; i < boot_mem_map.nr_map; i++) {
188 printk(" memory: %08lx @ %08lx ",
189 boot_mem_map.map[i].size, boot_mem_map.map[i].addr);
190 switch (boot_mem_map.map[i].type) {
191 case BOOT_MEM_RAM:
192 printk("(usable)\n");
193 break;
194 case BOOT_MEM_ROM_DATA:
195 printk("(ROM data)\n");
196 break;
197 case BOOT_MEM_RESERVED:
198 printk("(reserved)\n");
199 break;
200 default:
201 printk("type %lu\n", boot_mem_map.map[i].type);
202 break;
203 }
204 }
205 }
206
207 void bootmem_init(void) {
208 #ifdef CONFIG_BLK_DEV_INITRD
209 unsigned long tmp;
210 unsigned long *initrd_header;
211 #endif
212 unsigned long bootmap_size;
213 unsigned long start_pfn, max_pfn;
214 int i;
215 extern int _end;
216
217 #define PFN_UP(x) (((x) + PAGE_SIZE - 1) >> PAGE_SHIFT)
218 #define PFN_DOWN(x) ((x) >> PAGE_SHIFT)
219 #define PFN_PHYS(x) ((x) << PAGE_SHIFT)
220
221 /*
222 * Partially used pages are not usable - thus
223 * we are rounding upwards.
224 */
225 start_pfn = PFN_UP(__pa(&_end));
226
227 /* Find the highest page frame number we have available. */
228 max_pfn = 0;
229 for (i = 0; i < boot_mem_map.nr_map; i++) {
230 unsigned long start, end;
231
232 if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
233 continue;
234
235 start = PFN_UP(boot_mem_map.map[i].addr);
236 end = PFN_DOWN(boot_mem_map.map[i].addr
237 + boot_mem_map.map[i].size);
238
239 if (start >= end)
240 continue;
241 if (end > max_pfn)
242 max_pfn = end;
243 }
244
245 /* Initialize the boot-time allocator. */
246 bootmap_size = init_bootmem(start_pfn, max_pfn);
247
248 /*
249 * Register fully available low RAM pages with the bootmem allocator.
250 */
251 for (i = 0; i < boot_mem_map.nr_map; i++) {
252 unsigned long curr_pfn, last_pfn, size;
253
254 /*
255 * Reserve usable memory.
256 */
257 if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
258 continue;
259
260 /*
261 * We are rounding up the start address of usable memory:
262 */
263 curr_pfn = PFN_UP(boot_mem_map.map[i].addr);
264 if (curr_pfn >= max_pfn)
265 continue;
266 if (curr_pfn < start_pfn)
267 curr_pfn = start_pfn;
268
269 /*
270 * ... and at the end of the usable range downwards:
271 */
272 last_pfn = PFN_DOWN(boot_mem_map.map[i].addr
273 + boot_mem_map.map[i].size);
274
275 if (last_pfn > max_pfn)
276 last_pfn = max_pfn;
277
278 /*
279 * ... finally, did all the rounding and playing
280 * around just make the area go away?
281 */
282 if (last_pfn <= curr_pfn)
283 continue;
284
285 size = last_pfn - curr_pfn;
286 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
287 }
288
289 /* Reserve the bootmap memory. */
290 reserve_bootmem(PFN_PHYS(start_pfn), bootmap_size);
291
292 #ifdef CONFIG_BLK_DEV_INITRD
293 #error "Initrd is broken, please fit it."
294 tmp = (((unsigned long)&_end + PAGE_SIZE-1) & PAGE_MASK) - 8;
295 if (tmp < (unsigned long)&_end)
296 tmp += PAGE_SIZE;
297 initrd_header = (unsigned long *)tmp;
298 if (initrd_header[0] == 0x494E5244) {
299 initrd_start = (unsigned long)&initrd_header[2];
300 initrd_end = initrd_start + initrd_header[1];
301 initrd_below_start_ok = 1;
302 if (initrd_end > memory_end) {
303 printk("initrd extends beyond end of memory "
304 "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
305 initrd_end,memory_end);
306 initrd_start = 0;
307 } else
308 *memory_start_p = initrd_end;
309 }
310 #endif
311
312 #undef PFN_UP
313 #undef PFN_DOWN
314 #undef PFN_PHYS
315
316 }
317
318 void show_mem(void)
319 {
320 int i, free = 0, total = 0, reserved = 0;
321 int shared = 0, cached = 0;
322
323 printk("Mem-info:\n");
324 show_free_areas();
325 printk("Free swap: %6dkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
326 i = max_mapnr;
327 while (i-- > 0) {
328 total++;
329 if (PageReserved(mem_map+i))
330 reserved++;
331 else if (PageSwapCache(mem_map+i))
332 cached++;
333 else if (!page_count(mem_map + i))
334 free++;
335 else
336 shared += page_count(mem_map + i) - 1;
337 }
338 printk("%d pages of RAM\n", total);
339 printk("%d reserved pages\n", reserved);
340 printk("%d pages shared\n", shared);
341 printk("%d pages swap cached\n",cached);
342 printk("%ld pages in page table cache\n", pgtable_cache_size);
343 printk("%d free pages\n", free);
344 show_buffers();
345 }
346
347 #ifndef CONFIG_DISCONTIGMEM
348 /* References to section boundaries */
349
350 extern char _stext, _etext, _fdata, _edata;
351 extern char __init_begin, __init_end;
352
353 void __init paging_init(void)
354 {
355 pmd_t *pmd = kpmdtbl;
356 pte_t *pte = kptbl;
357
358 unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
359 unsigned long max_dma, low;
360 int i;
361
362 /* Initialize the entire pgd. */
363 pgd_init((unsigned long)swapper_pg_dir);
364 pmd_init((unsigned long)invalid_pmd_table, (unsigned long)invalid_pte_table);
365 memset((void *)invalid_pte_table, 0, sizeof(pte_t) * PTRS_PER_PTE);
366
367 max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
368 low = max_low_pfn;
369
370 #if defined(CONFIG_PCI) || defined(CONFIG_ISA)
371 if (low < max_dma)
372 zones_size[ZONE_DMA] = low;
373 else {
374 zones_size[ZONE_DMA] = max_dma;
375 zones_size[ZONE_NORMAL] = low - max_dma;
376 }
377 #else
378 zones_size[ZONE_DMA] = low;
379 #endif
380
381 free_area_init(zones_size);
382
383 memset((void *)kptbl, 0, PAGE_SIZE << KPTBL_PAGE_ORDER);
384 memset((void *)kpmdtbl, 0, PAGE_SIZE);
385 pgd_set(swapper_pg_dir, kpmdtbl);
386 for (i = 0; i < (1 << KPTBL_PAGE_ORDER); pmd++,i++,pte+=PTRS_PER_PTE)
387 pmd_val(*pmd) = (unsigned long)pte;
388 }
389
390 extern int page_is_ram(unsigned long pagenr);
391
392 void __init mem_init(void)
393 {
394 unsigned long codesize, reservedpages, datasize, initsize;
395 unsigned long tmp, ram;
396
397 max_mapnr = num_physpages = max_low_pfn;
398 high_memory = (void *) __va(max_mapnr << PAGE_SHIFT);
399
400 totalram_pages += free_all_bootmem();
401 totalram_pages -= setup_zero_pages(); /* Setup zeroed pages. */
402
403 reservedpages = ram = 0;
404 for (tmp = 0; tmp < max_low_pfn; tmp++)
405 if (page_is_ram(tmp)) {
406 ram++;
407 if (PageReserved(mem_map+tmp))
408 reservedpages++;
409 }
410
411 codesize = (unsigned long) &_etext - (unsigned long) &_stext;
412 datasize = (unsigned long) &_edata - (unsigned long) &_fdata;
413 initsize = (unsigned long) &__init_end - (unsigned long) &__init_begin;
414
415 printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, "
416 "%ldk data, %ldk init)\n",
417 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
418 ram << (PAGE_SHIFT-10),
419 codesize >> 10,
420 reservedpages << (PAGE_SHIFT-10),
421 datasize >> 10,
422 initsize >> 10);
423 }
424 #endif /* !CONFIG_DISCONTIGMEM */
425
426 #ifdef CONFIG_BLK_DEV_INITRD
427 void free_initrd_mem(unsigned long start, unsigned long end)
428 {
429 for (; start < end; start += PAGE_SIZE) {
430 ClearPageReserved(virt_to_page(start));
431 set_page_count(virt_to_page(start), 1);
432 free_page(start);
433 totalram_pages++;
434 }
435 printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
436 }
437 #endif
438
439 extern char __init_begin, __init_end;
440 extern void prom_free_prom_memory(void);
441
442 void
443 free_initmem(void)
444 {
445 unsigned long addr, page;
446
447 prom_free_prom_memory();
448
449 addr = (unsigned long)(&__init_begin);
450 while (addr < (unsigned long)&__init_end) {
451 page = PAGE_OFFSET | CPHYSADDR(addr);
452 ClearPageReserved(virt_to_page(page));
453 set_page_count(virt_to_page(page), 1);
454 free_page(page);
455 totalram_pages++;
456 addr += PAGE_SIZE;
457 }
458 printk("Freeing unused kernel memory: %ldk freed\n",
459 (&__init_end - &__init_begin) >> 10);
460 }
461
462 void
463 si_meminfo(struct sysinfo *val)
464 {
465 val->totalram = totalram_pages;
466 val->sharedram = atomic_read(&shmem_nrpages);
467 val->freeram = nr_free_pages();
468 val->bufferram = atomic_read(&buffermem_pages);
469 val->totalhigh = 0;
470 val->freehigh = nr_free_highpages();
471 val->mem_unit = PAGE_SIZE;
472
473 return;
474 }
475