arch/xtensa/mm/init.c

   1 /*
   2  * arch/xtensa/mm/init.c
   3  *
   4  * Derived from MIPS, PPC.
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file "COPYING" in the main directory of this archive
   8  * for more details.
   9  *
  10  * Copyright (C) 2001 - 2005 Tensilica Inc.
  11  *
  12  * Chris Zankel <chris@zankel.net>
  13  * Joe Taylor   <joe@tensilica.com, joetylr@yahoo.com>
  14  * Marc Gauthier
  15  * Kevin Chea
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/errno.h>
  20 #include <linux/bootmem.h>
  21 #include <linux/gfp.h>
  22 #include <linux/swap.h>
  23 #include <linux/mman.h>
  24 #include <linux/nodemask.h>
  25 #include <linux/mm.h>
  26
  27 #include <asm/bootparam.h>
  28 #include <asm/page.h>
  29 #include <asm/sections.h>
  30
  31 /*
  32  * mem_reserve(start, end, must_exist)
  33  *
  34  * Reserve some memory from the memory pool.
  35  *
  36  * Parameters:
  37  *  start       Start of region,
  38  *  end         End of region,
  39  *  must_exist  Must exist in memory pool.
  40  *
  41  * Returns:
  42  *  0 (memory area couldn't be mapped)
  43  * -1 (success)
  44  */
  45
  46 int __init mem_reserve(unsigned long start, unsigned long end, int must_exist)
  47 {
  48         int i;
  49
  50         if (start == end)
  51                 return 0;
  52
  53         start = start & PAGE_MASK;
  54         end = PAGE_ALIGN(end);
  55
  56         for (i = 0; i < sysmem.nr_banks; i++)
  57                 if (start < sysmem.bank[i].end
  58                     && end >= sysmem.bank[i].start)
  59                         break;
  60
  61         if (i == sysmem.nr_banks) {
  62                 if (must_exist)
  63                         printk (KERN_WARNING "mem_reserve: [0x%0lx, 0x%0lx) "
  64                                 "not in any region!\n", start, end);
  65                 return 0;
  66         }
  67
  68         if (start > sysmem.bank[i].start) {
  69                 if (end < sysmem.bank[i].end) {
  70                         /* split entry */
  71                         if (sysmem.nr_banks >= SYSMEM_BANKS_MAX)
  72                                 panic("meminfo overflow\n");
  73                         sysmem.bank[sysmem.nr_banks].start = end;
  74                         sysmem.bank[sysmem.nr_banks].end = sysmem.bank[i].end;
  75                         sysmem.nr_banks++;
  76                 }
  77                 sysmem.bank[i].end = start;
  78         } else {
  79                 if (end < sysmem.bank[i].end)
  80                         sysmem.bank[i].start = end;
  81                 else {
  82                         /* remove entry */
  83                         sysmem.nr_banks--;
  84                         sysmem.bank[i].start = sysmem.bank[sysmem.nr_banks].start;
  85                         sysmem.bank[i].end   = sysmem.bank[sysmem.nr_banks].end;
  86                 }
  87         }
  88         return -1;
  89 }
  90
  91
  92 /*
  93  * Initialize the bootmem system and give it all the memory we have available.
  94  */
  95
  96 void __init bootmem_init(void)
  97 {
  98         unsigned long pfn;
  99         unsigned long bootmap_start, bootmap_size;
 100         int i;
 101
 102         max_low_pfn = max_pfn = 0;
 103         min_low_pfn = ~0;
 104
 105         for (i=0; i < sysmem.nr_banks; i++) {
 106                 pfn = PAGE_ALIGN(sysmem.bank[i].start) >> PAGE_SHIFT;
 107                 if (pfn < min_low_pfn)
 108                         min_low_pfn = pfn;
 109                 pfn = PAGE_ALIGN(sysmem.bank[i].end - 1) >> PAGE_SHIFT;
 110                 if (pfn > max_pfn)
 111                         max_pfn = pfn;
 112         }
 113
 114         if (min_low_pfn > max_pfn)
 115                 panic("No memory found!\n");
 116
 117         max_low_pfn = max_pfn < MAX_MEM_PFN >> PAGE_SHIFT ?
 118                 max_pfn : MAX_MEM_PFN >> PAGE_SHIFT;
 119
 120         /* Find an area to use for the bootmem bitmap. */
 121
 122         bootmap_size = bootmem_bootmap_pages(max_low_pfn - min_low_pfn);
 123         bootmap_size <<= PAGE_SHIFT;
 124         bootmap_start = ~0;
 125
 126         for (i=0; i<sysmem.nr_banks; i++)
 127                 if (sysmem.bank[i].end - sysmem.bank[i].start >= bootmap_size) {
 128                         bootmap_start = sysmem.bank[i].start;
 129                         break;
 130                 }
 131
 132         if (bootmap_start == ~0UL)
 133                 panic("Cannot find %ld bytes for bootmap\n", bootmap_size);
 134
 135         /* Reserve the bootmem bitmap area */
 136
 137         mem_reserve(bootmap_start, bootmap_start + bootmap_size, 1);
 138         bootmap_size = init_bootmem_node(NODE_DATA(0),
 139                                          bootmap_start >> PAGE_SHIFT,
 140                                          min_low_pfn,
 141                                          max_low_pfn);
 142
 143         /* Add all remaining memory pieces into the bootmem map */
 144
 145         for (i=0; i<sysmem.nr_banks; i++)
 146                 free_bootmem(sysmem.bank[i].start,
 147                              sysmem.bank[i].end - sysmem.bank[i].start);
 148
 149 }
 150
 151
 152 void __init zones_init(void)
 153 {
 154         unsigned long zones_size[MAX_NR_ZONES];
 155         int i;
 156
 157         /* All pages are DMA-able, so we put them all in the DMA zone. */
 158
 159         zones_size[ZONE_DMA] = max_low_pfn - ARCH_PFN_OFFSET;
 160         for (i = 1; i < MAX_NR_ZONES; i++)
 161                 zones_size[i] = 0;
 162
 163 #ifdef CONFIG_HIGHMEM
 164         zones_size[ZONE_HIGHMEM] = max_pfn - max_low_pfn;
 165 #endif
 166
 167         free_area_init_node(0, zones_size, ARCH_PFN_OFFSET, NULL);
 168 }
 169
 170 /*
 171  * Initialize memory pages.
 172  */
 173
 174 void __init mem_init(void)
 175 {
 176         unsigned long codesize, reservedpages, datasize, initsize;
 177         unsigned long highmemsize, tmp, ram;
 178
 179         max_mapnr = num_physpages = max_low_pfn - ARCH_PFN_OFFSET;
 180         high_memory = (void *) __va(max_low_pfn << PAGE_SHIFT);
 181         highmemsize = 0;
 182
 183 #ifdef CONFIG_HIGHMEM
 184 #error HIGHGMEM not implemented in init.c
 185 #endif
 186
 187         totalram_pages += free_all_bootmem();
 188
 189         reservedpages = ram = 0;
 190         for (tmp = 0; tmp < max_mapnr; tmp++) {
 191                 ram++;
 192                 if (PageReserved(mem_map+tmp))
 193                         reservedpages++;
 194         }
 195
 196         codesize =  (unsigned long) _etext - (unsigned long) _stext;
 197         datasize =  (unsigned long) _edata - (unsigned long) _sdata;
 198         initsize =  (unsigned long) __init_end - (unsigned long) __init_begin;
 199
 200         printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, "
 201                "%ldk data, %ldk init %ldk highmem)\n",
 202                nr_free_pages() << (PAGE_SHIFT-10),
 203                ram << (PAGE_SHIFT-10),
 204                codesize >> 10,
 205                reservedpages << (PAGE_SHIFT-10),
 206                datasize >> 10,
 207                initsize >> 10,
 208                highmemsize >> 10);
 209 }
 210
 211 void
 212 free_reserved_mem(void *start, void *end)
 213 {
 214         for (; start < end; start += PAGE_SIZE) {
 215                 ClearPageReserved(virt_to_page(start));
 216                 init_page_count(virt_to_page(start));
 217                 free_page((unsigned long)start);
 218                 totalram_pages++;
 219         }
 220 }
 221
 222 #ifdef CONFIG_BLK_DEV_INITRD
 223 extern int initrd_is_mapped;
 224
 225 void free_initrd_mem(unsigned long start, unsigned long end)
 226 {
 227         if (initrd_is_mapped) {
 228                 free_reserved_mem((void*)start, (void*)end);
 229                 printk ("Freeing initrd memory: %ldk freed\n",(end-start)>>10);
 230         }
 231 }
 232 #endif
 233
 234 void free_initmem(void)
 235 {
 236         free_reserved_mem(__init_begin, __init_end);
 237         printk("Freeing unused kernel memory: %zuk freed\n",
 238                (__init_end - __init_begin) >> 10);
 239 }