1/* 2 * linux/arch/h8300/mm/init.c 3 * 4 * Copyright (C) 1998 D. Jeff Dionne <jeff@lineo.ca>, 5 * Kenneth Albanowski <kjahds@kjahds.com>, 6 * Copyright (C) 2000 Lineo, Inc. (www.lineo.com) 7 * 8 * Based on: 9 * 10 * linux/arch/m68knommu/mm/init.c 11 * linux/arch/m68k/mm/init.c 12 * 13 * Copyright (C) 1995 Hamish Macdonald 14 * 15 * JAN/1999 -- hacked to support ColdFire (gerg@snapgear.com) 16 * DEC/2000 -- linux 2.4 support <davidm@snapgear.com> 17 */ 18 19#include <linux/signal.h> 20#include <linux/sched.h> 21#include <linux/kernel.h> 22#include <linux/errno.h> 23#include <linux/string.h> 24#include <linux/types.h> 25#include <linux/ptrace.h> 26#include <linux/mman.h> 27#include <linux/mm.h> 28#include <linux/swap.h> 29#include <linux/init.h> 30#include <linux/highmem.h> 31#include <linux/pagemap.h> 32#include <linux/bootmem.h> 33#include <linux/slab.h> 34 35#include <asm/setup.h> 36#include <asm/segment.h> 37#include <asm/page.h> 38#include <asm/pgtable.h> 39#include <asm/system.h> 40 41#undef DEBUG 42 43extern void die_if_kernel(char *,struct pt_regs *,long); 44extern void free_initmem(void); 45 46/* 47 * BAD_PAGE is the page that is used for page faults when linux 48 * is out-of-memory. Older versions of linux just did a 49 * do_exit(), but using this instead means there is less risk 50 * for a process dying in kernel mode, possibly leaving a inode 51 * unused etc.. 52 * 53 * BAD_PAGETABLE is the accompanying page-table: it is initialized 54 * to point to BAD_PAGE entries. 55 * 56 * ZERO_PAGE is a special page that is used for zero-initialized 57 * data and COW. 58 */ 59static unsigned long empty_bad_page_table; 60 61static unsigned long empty_bad_page; 62 63unsigned long empty_zero_page; 64 65extern unsigned long rom_length; 66 67void show_mem(void) 68{ 69 unsigned long i; 70 int free = 0, total = 0, reserved = 0, shared = 0; 71 int cached = 0; 72 73 printk("\nMem-info:\n"); 74 show_free_areas(); 75 i = max_mapnr; 76 while (i-- > 0) { 77 total++; 78 if (PageReserved(mem_map+i)) 79 reserved++; 80 else if (PageSwapCache(mem_map+i)) 81 cached++; 82 else if (!page_count(mem_map+i)) 83 free++; 84 else 85 shared += page_count(mem_map+i) - 1; 86 } 87 printk("%d pages of RAM\n",total); 88 printk("%d free pages\n",free); 89 printk("%d reserved pages\n",reserved); 90 printk("%d pages shared\n",shared); 91 printk("%d pages swap cached\n",cached); 92} 93 94extern unsigned long memory_start; 95extern unsigned long memory_end; 96 97/* 98 * paging_init() continues the virtual memory environment setup which 99 * was begun by the code in arch/head.S. 100 * The parameters are pointers to where to stick the starting and ending 101 * addresses of available kernel virtual memory. 102 */ 103void paging_init(void) 104{ 105 /* 106 * Make sure start_mem is page aligned, otherwise bootmem and 107 * page_alloc get different views og the world. 108 */ 109#ifdef DEBUG 110 unsigned long start_mem = PAGE_ALIGN(memory_start); 111#endif 112 unsigned long end_mem = memory_end & PAGE_MASK; 113 114#ifdef DEBUG 115 printk ("start_mem is %#lx\nvirtual_end is %#lx\n", 116 start_mem, end_mem); 117#endif 118 119 /* 120 * Initialize the bad page table and bad page to point 121 * to a couple of allocated pages. 122 */ 123 empty_bad_page_table = (unsigned long)alloc_bootmem_pages(PAGE_SIZE); 124 empty_bad_page = (unsigned long)alloc_bootmem_pages(PAGE_SIZE); 125 empty_zero_page = (unsigned long)alloc_bootmem_pages(PAGE_SIZE); 126 memset((void *)empty_zero_page, 0, PAGE_SIZE); 127 128 /* 129 * Set up SFC/DFC registers (user data space). 130 */ 131 set_fs (USER_DS); 132 133#ifdef DEBUG 134 printk ("before free_area_init\n"); 135 136 printk ("free_area_init -> start_mem is %#lx\nvirtual_end is %#lx\n", 137 start_mem, end_mem); 138#endif 139 140 { 141 unsigned long zones_size[MAX_NR_ZONES] = {0, }; 142 143 zones_size[ZONE_DMA] = 0 >> PAGE_SHIFT; 144 zones_size[ZONE_NORMAL] = (end_mem - PAGE_OFFSET) >> PAGE_SHIFT; 145#ifdef CONFIG_HIGHMEM 146 zones_size[ZONE_HIGHMEM] = 0; 147#endif 148 free_area_init(zones_size); 149 } 150} 151 152void mem_init(void) 153{ 154 int codek = 0, datak = 0, initk = 0; 155 /* DAVIDM look at setup memory map generically with reserved area */ 156 unsigned long tmp; 157 extern char _etext, _stext, _sdata, _ebss, __init_begin, __init_end; 158 extern unsigned long _ramend, _ramstart; 159 unsigned long len = &_ramend - &_ramstart; 160 unsigned long start_mem = memory_start; /* DAVIDM - these must start at end of kernel */ 161 unsigned long end_mem = memory_end; /* DAVIDM - this must not include kernel stack at top */ 162 163#ifdef DEBUG 164 printk(KERN_DEBUG "Mem_init: start=%lx, end=%lx\n", start_mem, end_mem); 165#endif 166 167 end_mem &= PAGE_MASK; 168 high_memory = (void *) end_mem; 169 170 start_mem = PAGE_ALIGN(start_mem); 171 max_mapnr = num_physpages = MAP_NR(high_memory); 172 173 /* this will put all memory onto the freelists */ 174 totalram_pages = free_all_bootmem(); 175 176 codek = (&_etext - &_stext) >> 10; 177 datak = (&_ebss - &_sdata) >> 10; 178 initk = (&__init_begin - &__init_end) >> 10; 179 180 tmp = nr_free_pages() << PAGE_SHIFT; 181 printk(KERN_INFO "Memory available: %luk/%luk RAM, %luk/%luk ROM (%dk kernel code, %dk data)\n", 182 tmp >> 10, 183 len >> 10, 184 (rom_length > 0) ? ((rom_length >> 10) - codek) : 0, 185 rom_length >> 10, 186 codek, 187 datak 188 ); 189} 190 191 192#ifdef CONFIG_BLK_DEV_INITRD 193void free_initrd_mem(unsigned long start, unsigned long end) 194{ 195 int pages = 0; 196 for (; start < end; start += PAGE_SIZE) { 197 ClearPageReserved(virt_to_page(start)); 198 init_page_count(virt_to_page(start)); 199 free_page(start); 200 totalram_pages++; 201 pages++; 202 } 203 printk ("Freeing initrd memory: %dk freed\n", pages); 204} 205#endif 206 207void 208free_initmem() 209{ 210#ifdef CONFIG_RAMKERNEL 211 unsigned long addr; 212 extern char __init_begin, __init_end; 213/* 214 * the following code should be cool even if these sections 215 * are not page aligned. 216 */ 217 addr = PAGE_ALIGN((unsigned long)(&__init_begin)); 218 /* next to check that the page we free is not a partial page */ 219 for (; addr + PAGE_SIZE < (unsigned long)(&__init_end); addr +=PAGE_SIZE) { 220 ClearPageReserved(virt_to_page(addr)); 221 init_page_count(virt_to_page(addr)); 222 free_page(addr); 223 totalram_pages++; 224 } 225 printk(KERN_INFO "Freeing unused kernel memory: %ldk freed (0x%x - 0x%x)\n", 226 (addr - PAGE_ALIGN((long) &__init_begin)) >> 10, 227 (int)(PAGE_ALIGN((unsigned long)(&__init_begin))), 228 (int)(addr - PAGE_SIZE)); 229#endif 230} 231