arch/sh/mm/init.c

   1 /*
   2  * linux/arch/sh/mm/init.c
   3  *
   4  *  Copyright (C) 1999  Niibe Yutaka
   5  *  Copyright (C) 2002 - 2007  Paul Mundt
   6  *
   7  *  Based on linux/arch/i386/mm/init.c:
   8  *   Copyright (C) 1995  Linus Torvalds
   9  */
  10 #include <linux/mm.h>
  11 #include <linux/swap.h>
  12 #include <linux/init.h>
  13 #include <linux/bootmem.h>
  14 #include <linux/proc_fs.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/percpu.h>
  17 #include <linux/io.h>
  18 #include <asm/mmu_context.h>
  19 #include <asm/tlb.h>
  20 #include <asm/cacheflush.h>
  21 #include <asm/cache.h>
  22
  23 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
  24 pgd_t swapper_pg_dir[PTRS_PER_PGD];
  25
  26 void (*copy_page)(void *from, void *to);
  27 void (*clear_page)(void *to);
  28
  29 void show_mem(void)
  30 {
  31         int total = 0, reserved = 0, free = 0;
  32         int shared = 0, cached = 0, slab = 0;
  33         pg_data_t *pgdat;
  34
  35         printk("Mem-info:\n");
  36         show_free_areas();
  37
  38         for_each_online_pgdat(pgdat) {
  39                 struct page *page, *end;
  40                 unsigned long flags;
  41
  42                 pgdat_resize_lock(pgdat, &flags);
  43                 page = pgdat->node_mem_map;
  44                 end = page + pgdat->node_spanned_pages;
  45
  46                 do {
  47                         total++;
  48                         if (PageReserved(page))
  49                                 reserved++;
  50                         else if (PageSwapCache(page))
  51                                 cached++;
  52                         else if (PageSlab(page))
  53                                 slab++;
  54                         else if (!page_count(page))
  55                                 free++;
  56                         else
  57                                 shared += page_count(page) - 1;
  58                         page++;
  59                 } while (page < end);
  60
  61                 pgdat_resize_unlock(pgdat, &flags);
  62         }
  63
  64         printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
  65         printk("%d pages of RAM\n", total);
  66         printk("%d free pages\n", free);
  67         printk("%d reserved pages\n", reserved);
  68         printk("%d slab pages\n", slab);
  69         printk("%d pages shared\n", shared);
  70         printk("%d pages swap cached\n", cached);
  71         printk(KERN_INFO "Total of %ld pages in page table cache\n",
  72                quicklist_total_size());
  73 }
  74
  75 #ifdef CONFIG_MMU
  76 static void set_pte_phys(unsigned long addr, unsigned long phys, pgprot_t prot)
  77 {
  78         pgd_t *pgd;
  79         pud_t *pud;
  80         pmd_t *pmd;
  81         pte_t *pte;
  82
  83         pgd = pgd_offset_k(addr);
  84         if (pgd_none(*pgd)) {
  85                 pgd_ERROR(*pgd);
  86                 return;
  87         }
  88
  89         pud = pud_alloc(NULL, pgd, addr);
  90         if (unlikely(!pud)) {
  91                 pud_ERROR(*pud);
  92                 return;
  93         }
  94
  95         pmd = pmd_alloc(NULL, pud, addr);
  96         if (unlikely(!pmd)) {
  97                 pmd_ERROR(*pmd);
  98                 return;
  99         }
 100
 101         pte = pte_offset_kernel(pmd, addr);
 102         if (!pte_none(*pte)) {
 103                 pte_ERROR(*pte);
 104                 return;
 105         }
 106
 107         set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, prot));
 108
 109         flush_tlb_one(get_asid(), addr);
 110 }
 111
 112 /*
 113  * As a performance optimization, other platforms preserve the fixmap mapping
 114  * across a context switch, we don't presently do this, but this could be done
 115  * in a similar fashion as to the wired TLB interface that sh64 uses (by way
 116  * of the memory mapped UTLB configuration) -- this unfortunately forces us to
 117  * give up a TLB entry for each mapping we want to preserve. While this may be
 118  * viable for a small number of fixmaps, it's not particularly useful for
 119  * everything and needs to be carefully evaluated. (ie, we may want this for
 120  * the vsyscall page).
 121  *
 122  * XXX: Perhaps add a _PAGE_WIRED flag or something similar that we can pass
 123  * in at __set_fixmap() time to determine the appropriate behavior to follow.
 124  *
 125  *                                       -- PFM.
 126  */
 127 void __set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
 128 {
 129         unsigned long address = __fix_to_virt(idx);
 130
 131         if (idx >= __end_of_fixed_addresses) {
 132                 BUG();
 133                 return;
 134         }
 135
 136         set_pte_phys(address, phys, prot);
 137 }
 138 #endif  /* CONFIG_MMU */
 139
 140 /* References to section boundaries */
 141
 142 extern char _text, _etext, _edata, __bss_start, _end;
 143 extern char __init_begin, __init_end;
 144
 145 /*
 146  * paging_init() sets up the page tables
 147  */
 148 void __init paging_init(void)
 149 {
 150         int nid;
 151
 152         /* We don't need to map the kernel through the TLB, as
 153          * it is permanatly mapped using P1. So clear the
 154          * entire pgd. */
 155         memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir));
 156
 157         /* Set an initial value for the MMU.TTB so we don't have to
 158          * check for a null value. */
 159         set_TTB(swapper_pg_dir);
 160
 161         for_each_online_node(nid) {
 162                 pg_data_t *pgdat = NODE_DATA(nid);
 163                 unsigned long max_zone_pfns[MAX_NR_ZONES];
 164                 unsigned long low, start_pfn;
 165
 166                 memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
 167
 168                 start_pfn = pgdat->bdata->node_boot_start >> PAGE_SHIFT;
 169                 low = pgdat->bdata->node_low_pfn;
 170
 171                 max_zone_pfns[ZONE_NORMAL] = low;
 172                 add_active_range(nid, start_pfn, low);
 173
 174                 printk("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
 175                        nid, start_pfn, low);
 176
 177                 free_area_init_nodes(max_zone_pfns);
 178
 179                 printk("Node %u: mem_map starts at %p\n",
 180                        pgdat->node_id, pgdat->node_mem_map);
 181         }
 182 }
 183
 184 static struct kcore_list kcore_mem, kcore_vmalloc;
 185
 186 void __init mem_init(void)
 187 {
 188         int codesize, reservedpages, datasize, initsize;
 189         int nid;
 190
 191         reservedpages = 0;
 192
 193         for_each_online_node(nid) {
 194                 pg_data_t *pgdat = NODE_DATA(nid);
 195                 unsigned long node_pages = 0;
 196                 void *node_high_memory;
 197                 int i;
 198
 199                 num_physpages += pgdat->node_present_pages;
 200
 201                 if (pgdat->node_spanned_pages)
 202                         node_pages = free_all_bootmem_node(pgdat);
 203
 204                 totalram_pages += node_pages;
 205
 206                 for (i = 0; i < node_pages; i++)
 207                         if (PageReserved(pgdat->node_mem_map + i))
 208                                 reservedpages++;
 209
 210                 node_high_memory = (void *)((pgdat->node_start_pfn +
 211                                              pgdat->node_spanned_pages) <<
 212                                                 PAGE_SHIFT);
 213                 if (node_high_memory > high_memory)
 214                         high_memory = node_high_memory;
 215         }
 216
 217         /* clear the zero-page */
 218         memset(empty_zero_page, 0, PAGE_SIZE);
 219         __flush_wback_region(empty_zero_page, PAGE_SIZE);
 220
 221         /*
 222          * Setup wrappers for copy/clear_page(), these will get overridden
 223          * later in the boot process if a better method is available.
 224          */
 225 #ifdef CONFIG_MMU
 226         copy_page = copy_page_slow;
 227         clear_page = clear_page_slow;
 228 #else
 229         copy_page = copy_page_nommu;
 230         clear_page = clear_page_nommu;
 231 #endif
 232
 233         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 234         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 235         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 236
 237         kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 238         kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 239                    VMALLOC_END - VMALLOC_START);
 240
 241         printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, "
 242                "%dk reserved, %dk data, %dk init)\n",
 243                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 244                 totalram_pages << (PAGE_SHIFT-10),
 245                 codesize >> 10,
 246                 reservedpages << (PAGE_SHIFT-10),
 247                 datasize >> 10,
 248                 initsize >> 10);
 249
 250         p3_cache_init();
 251
 252         /* Initialize the vDSO */
 253         vsyscall_init();
 254 }
 255
 256 void free_initmem(void)
 257 {
 258         unsigned long addr;
 259
 260         addr = (unsigned long)(&__init_begin);
 261         for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
 262                 ClearPageReserved(virt_to_page(addr));
 263                 init_page_count(virt_to_page(addr));
 264                 free_page(addr);
 265                 totalram_pages++;
 266         }
 267         printk ("Freeing unused kernel memory: %dk freed\n", (&__init_end - &__init_begin) >> 10);
 268 }
 269
 270 #ifdef CONFIG_BLK_DEV_INITRD
 271 void free_initrd_mem(unsigned long start, unsigned long end)
 272 {
 273         unsigned long p;
 274         for (p = start; p < end; p += PAGE_SIZE) {
 275                 ClearPageReserved(virt_to_page(p));
 276                 init_page_count(virt_to_page(p));
 277                 free_page(p);
 278                 totalram_pages++;
 279         }
 280         printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
 281 }
 282 #endif