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/initrd.h>
  25
  26 #include <asm/bootinfo.h>
  27 #include <asm/cachectl.h>
  28 #include <asm/dma.h>
  29 #include <asm/system.h>
  30 #include <asm/sections.h>
  31 #include <asm/pgtable.h>
  32 #include <asm/pgalloc.h>
  33 #include <asm/mmu_context.h>
  34 #include <asm/tlb.h>
  35 #include <asm/cpu.h>
  36
  37 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
  38
  39 void pgd_init(unsigned long page)
  40 {
  41         unsigned long *p, *end;
  42
  43         p = (unsigned long *) page;
  44         end = p + PTRS_PER_PGD;
  45
  46         while (p < end) {
  47                 p[0] = (unsigned long) invalid_pmd_table;
  48                 p[1] = (unsigned long) invalid_pmd_table;
  49                 p[2] = (unsigned long) invalid_pmd_table;
  50                 p[3] = (unsigned long) invalid_pmd_table;
  51                 p[4] = (unsigned long) invalid_pmd_table;
  52                 p[5] = (unsigned long) invalid_pmd_table;
  53                 p[6] = (unsigned long) invalid_pmd_table;
  54                 p[7] = (unsigned long) invalid_pmd_table;
  55                 p += 8;
  56         }
  57 }
  58
  59 void pmd_init(unsigned long addr, unsigned long pagetable)
  60 {
  61         unsigned long *p, *end;
  62
  63         p = (unsigned long *) addr;
  64         end = p + PTRS_PER_PMD;
  65
  66         while (p < end) {
  67                 p[0] = (unsigned long)pagetable;
  68                 p[1] = (unsigned long)pagetable;
  69                 p[2] = (unsigned long)pagetable;
  70                 p[3] = (unsigned long)pagetable;
  71                 p[4] = (unsigned long)pagetable;
  72                 p[5] = (unsigned long)pagetable;
  73                 p[6] = (unsigned long)pagetable;
  74                 p[7] = (unsigned long)pagetable;
  75                 p += 8;
  76         }
  77 }
  78
  79 /*
  80  * We have up to 8 empty zeroed pages so we can map one of the right colour
  81  * when needed.  This is necessary only on R4000 / R4400 SC and MC versions
  82  * where we have to avoid VCED / VECI exceptions for good performance at
  83  * any price.  Since page is never written to after the initialization we
  84  * don't have to care about aliases on other CPUs.
  85  */
  86 unsigned long empty_zero_page, zero_page_mask;
  87
  88 unsigned long setup_zero_pages(void)
  89 {
  90         unsigned long order, size;
  91         struct page *page;
  92
  93         if (cpu_has_vce)
  94                 order = 3;
  95         else
  96                 order = 0;
  97
  98         empty_zero_page = __get_free_pages(GFP_KERNEL, order);
  99         if (!empty_zero_page)
 100                 panic("Oh boy, that early out of memory?");
 101
 102         page = virt_to_page(empty_zero_page);
 103         while (page < virt_to_page(empty_zero_page + (PAGE_SIZE << order))) {
 104                 set_bit(PG_reserved, &page->flags);
 105                 set_page_count(page, 0);
 106                 page++;
 107         }
 108
 109         size = PAGE_SIZE << order;
 110         zero_page_mask = (size - 1) & PAGE_MASK;
 111         memset((void *)empty_zero_page, 0, size);
 112
 113         return 1UL << order;
 114 }
 115
 116 #ifndef CONFIG_DISCONTIGMEM
 117 /* References to section boundaries */
 118
 119 extern char _stext, _etext, _fdata, _edata;
 120 extern char __init_begin, __init_end;
 121
 122 void __init paging_init(void)
 123 {
 124         pmd_t *pmd = kpmdtbl;
 125         pte_t *pte = kptbl;
 126
 127         unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
 128         unsigned long max_dma, low;
 129         int i;
 130
 131         /* Initialize the entire pgd.  */
 132         pgd_init((unsigned long)swapper_pg_dir);
 133         pmd_init((unsigned long)invalid_pmd_table, (unsigned long)invalid_pte_table);
 134         memset((void *)invalid_pte_table, 0, sizeof(pte_t) * PTRS_PER_PTE);
 135
 136         max_dma =  virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
 137         low = max_low_pfn;
 138
 139 #ifdef CONFIG_ISA
 140         if (low < max_dma)
 141                 zones_size[ZONE_DMA] = low;
 142         else {
 143                 zones_size[ZONE_DMA] = max_dma;
 144                 zones_size[ZONE_NORMAL] = low - max_dma;
 145         }
 146 #else
 147         zones_size[ZONE_DMA] = low;
 148 #endif
 149
 150         free_area_init(zones_size);
 151
 152         memset((void *)kptbl, 0, PAGE_SIZE << PGD_ORDER);
 153         memset((void *)kpmdtbl, 0, PAGE_SIZE);
 154         set_pgd(swapper_pg_dir, __pgd(kpmdtbl));
 155         for (i = 0; i < (1 << PGD_ORDER); pmd++,i++,pte+=PTRS_PER_PTE)
 156                 pmd_val(*pmd) = (unsigned long)pte;
 157 }
 158
 159 #define PFN_UP(x)       (((x) + PAGE_SIZE - 1) >> PAGE_SHIFT)
 160 #define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
 161
 162 static inline int page_is_ram(unsigned long pagenr)
 163 {
 164         int i;
 165
 166         for (i = 0; i < boot_mem_map.nr_map; i++) {
 167                 unsigned long addr, end;
 168
 169                 if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
 170                         /* not usable memory */
 171                         continue;
 172
 173                 addr = PFN_UP(boot_mem_map.map[i].addr);
 174                 end = PFN_DOWN(boot_mem_map.map[i].addr +
 175                                boot_mem_map.map[i].size);
 176
 177                 if (pagenr >= addr && pagenr < end)
 178                         return 1;
 179         }
 180
 181         return 0;
 182 }
 183
 184 void __init mem_init(void)
 185 {
 186         unsigned long codesize, reservedpages, datasize, initsize;
 187         unsigned long tmp, ram;
 188
 189         max_mapnr = num_physpages = max_low_pfn;
 190         high_memory = (void *) __va(max_mapnr << PAGE_SHIFT);
 191
 192         totalram_pages += free_all_bootmem();
 193         totalram_pages -= setup_zero_pages();   /* Setup zeroed pages.  */
 194
 195         reservedpages = ram = 0;
 196         for (tmp = 0; tmp < max_low_pfn; tmp++)
 197                 if (page_is_ram(tmp)) {
 198                         ram++;
 199                         if (PageReserved(mem_map+tmp))
 200                                 reservedpages++;
 201                 }
 202
 203         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 204         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 205         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 206
 207         printk(KERN_INFO "Memory: %luk/%luk available (%ldk kernel code, "
 208                "%ldk reserved, %ldk data, %ldk init)\n",
 209                (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 210                ram << (PAGE_SHIFT-10),
 211                codesize >> 10,
 212                reservedpages << (PAGE_SHIFT-10),
 213                datasize >> 10,
 214                initsize >> 10);
 215 }
 216 #endif /* !CONFIG_DISCONTIGMEM */
 217
 218 #ifdef CONFIG_BLK_DEV_INITRD
 219 void free_initrd_mem(unsigned long start, unsigned long end)
 220 {
 221         /* Switch from KSEG0 to XKPHYS addresses */
 222         start = (unsigned long)phys_to_virt(CPHYSADDR(start));
 223         end = (unsigned long)phys_to_virt(CPHYSADDR(end));
 224         if (start < end)
 225                 printk(KERN_INFO "Freeing initrd memory: %ldk freed\n",
 226                        (end - start) >> 10);
 227
 228         for (; start < end; start += PAGE_SIZE) {
 229                 ClearPageReserved(virt_to_page(start));
 230                 set_page_count(virt_to_page(start), 1);
 231                 free_page(start);
 232                 totalram_pages++;
 233         }
 234 }
 235 #endif
 236
 237 extern void prom_free_prom_memory(void) __init;
 238
 239 void free_initmem(void)
 240 {
 241         unsigned long addr, page;
 242
 243         prom_free_prom_memory();
 244
 245         addr = (unsigned long)(&__init_begin);
 246         while (addr < (unsigned long)&__init_end) {
 247                 page = PAGE_OFFSET | CPHYSADDR(addr);
 248                 ClearPageReserved(virt_to_page(page));
 249                 set_page_count(virt_to_page(page), 1);
 250                 free_page(page);
 251                 totalram_pages++;
 252                 addr += PAGE_SIZE;
 253         }
 254         printk(KERN_INFO "Freeing unused kernel memory: %ldk freed\n",
 255                (&__init_end - &__init_begin) >> 10);
 256 }