Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 Ralf Baechle |
| 7 | * Copyright (C) 1999, 2000 Silicon Graphics, Inc. |
| 8 | * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com |
| 9 | * Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved. |
| 10 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include <linux/init.h> |
| 12 | #include <linux/module.h> |
| 13 | #include <linux/signal.h> |
| 14 | #include <linux/sched.h> |
| 15 | #include <linux/kernel.h> |
| 16 | #include <linux/errno.h> |
| 17 | #include <linux/string.h> |
| 18 | #include <linux/types.h> |
| 19 | #include <linux/pagemap.h> |
| 20 | #include <linux/ptrace.h> |
| 21 | #include <linux/mman.h> |
| 22 | #include <linux/mm.h> |
| 23 | #include <linux/bootmem.h> |
| 24 | #include <linux/highmem.h> |
| 25 | #include <linux/swap.h> |
Daniel Jacobowitz | 3d50375 | 2005-01-20 19:59:54 -0500 | [diff] [blame] | 26 | #include <linux/proc_fs.h> |
Dave Hansen | 22a9835 | 2006-03-27 01:16:04 -0800 | [diff] [blame] | 27 | #include <linux/pfn.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | |
| 29 | #include <asm/bootinfo.h> |
| 30 | #include <asm/cachectl.h> |
| 31 | #include <asm/cpu.h> |
| 32 | #include <asm/dma.h> |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 33 | #include <asm/kmap_types.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #include <asm/mmu_context.h> |
| 35 | #include <asm/sections.h> |
| 36 | #include <asm/pgtable.h> |
| 37 | #include <asm/pgalloc.h> |
| 38 | #include <asm/tlb.h> |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 39 | #include <asm/fixmap.h> |
| 40 | |
| 41 | /* Atomicity and interruptability */ |
| 42 | #ifdef CONFIG_MIPS_MT_SMTC |
| 43 | |
| 44 | #include <asm/mipsmtregs.h> |
| 45 | |
| 46 | #define ENTER_CRITICAL(flags) \ |
| 47 | { \ |
| 48 | unsigned int mvpflags; \ |
| 49 | local_irq_save(flags);\ |
| 50 | mvpflags = dvpe() |
| 51 | #define EXIT_CRITICAL(flags) \ |
| 52 | evpe(mvpflags); \ |
| 53 | local_irq_restore(flags); \ |
| 54 | } |
| 55 | #else |
| 56 | |
| 57 | #define ENTER_CRITICAL(flags) local_irq_save(flags) |
| 58 | #define EXIT_CRITICAL(flags) local_irq_restore(flags) |
| 59 | |
| 60 | #endif /* CONFIG_MIPS_MT_SMTC */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | |
| 62 | DEFINE_PER_CPU(struct mmu_gather, mmu_gathers); |
| 63 | |
| 64 | unsigned long highstart_pfn, highend_pfn; |
| 65 | |
| 66 | /* |
| 67 | * We have up to 8 empty zeroed pages so we can map one of the right colour |
| 68 | * when needed. This is necessary only on R4000 / R4400 SC and MC versions |
| 69 | * where we have to avoid VCED / VECI exceptions for good performance at |
| 70 | * any price. Since page is never written to after the initialization we |
| 71 | * don't have to care about aliases on other CPUs. |
| 72 | */ |
| 73 | unsigned long empty_zero_page, zero_page_mask; |
| 74 | |
| 75 | /* |
| 76 | * Not static inline because used by IP27 special magic initialization code |
| 77 | */ |
| 78 | unsigned long setup_zero_pages(void) |
| 79 | { |
Nick Piggin | 8dfcc9b | 2006-03-22 00:08:05 -0800 | [diff] [blame] | 80 | unsigned int order; |
| 81 | unsigned long size; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | struct page *page; |
| 83 | |
| 84 | if (cpu_has_vce) |
| 85 | order = 3; |
| 86 | else |
| 87 | order = 0; |
| 88 | |
| 89 | empty_zero_page = __get_free_pages(GFP_KERNEL | __GFP_ZERO, order); |
| 90 | if (!empty_zero_page) |
| 91 | panic("Oh boy, that early out of memory?"); |
| 92 | |
| 93 | page = virt_to_page(empty_zero_page); |
Nick Piggin | 8dfcc9b | 2006-03-22 00:08:05 -0800 | [diff] [blame] | 94 | split_page(page, order); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | while (page < virt_to_page(empty_zero_page + (PAGE_SIZE << order))) { |
Hugh Dickins | 68352e6 | 2005-12-12 00:37:23 -0800 | [diff] [blame] | 96 | SetPageReserved(page); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | page++; |
| 98 | } |
| 99 | |
| 100 | size = PAGE_SIZE << order; |
| 101 | zero_page_mask = (size - 1) & PAGE_MASK; |
| 102 | |
| 103 | return 1UL << order; |
| 104 | } |
| 105 | |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 106 | /* |
| 107 | * These are almost like kmap_atomic / kunmap_atmic except they take an |
| 108 | * additional address argument as the hint. |
| 109 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | |
| 111 | #define kmap_get_fixmap_pte(vaddr) \ |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 112 | pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr)), (vaddr)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 114 | #ifdef CONFIG_MIPS_MT_SMTC |
| 115 | static pte_t *kmap_coherent_pte; |
| 116 | static void __init kmap_coherent_init(void) |
| 117 | { |
| 118 | unsigned long vaddr; |
| 119 | |
| 120 | /* cache the first coherent kmap pte */ |
| 121 | vaddr = __fix_to_virt(FIX_CMAP_BEGIN); |
| 122 | kmap_coherent_pte = kmap_get_fixmap_pte(vaddr); |
| 123 | } |
| 124 | #else |
| 125 | static inline void kmap_coherent_init(void) {} |
| 126 | #endif |
| 127 | |
| 128 | static inline void *kmap_coherent(struct page *page, unsigned long addr) |
| 129 | { |
| 130 | enum fixed_addresses idx; |
| 131 | unsigned long vaddr, flags, entrylo; |
| 132 | unsigned long old_ctx; |
| 133 | pte_t pte; |
| 134 | int tlbidx; |
| 135 | |
| 136 | inc_preempt_count(); |
| 137 | idx = (addr >> PAGE_SHIFT) & (FIX_N_COLOURS - 1); |
| 138 | #ifdef CONFIG_MIPS_MT_SMTC |
| 139 | idx += FIX_N_COLOURS * smp_processor_id(); |
| 140 | #endif |
| 141 | vaddr = __fix_to_virt(FIX_CMAP_END - idx); |
| 142 | pte = mk_pte(page, PAGE_KERNEL); |
| 143 | #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32_R1) |
| 144 | entrylo = pte.pte_high; |
| 145 | #else |
| 146 | entrylo = pte_val(pte) >> 6; |
| 147 | #endif |
| 148 | |
| 149 | ENTER_CRITICAL(flags); |
| 150 | old_ctx = read_c0_entryhi(); |
| 151 | write_c0_entryhi(vaddr & (PAGE_MASK << 1)); |
| 152 | write_c0_entrylo0(entrylo); |
| 153 | write_c0_entrylo1(entrylo); |
| 154 | #ifdef CONFIG_MIPS_MT_SMTC |
| 155 | set_pte(kmap_coherent_pte - (FIX_CMAP_END - idx), pte); |
| 156 | /* preload TLB instead of local_flush_tlb_one() */ |
| 157 | mtc0_tlbw_hazard(); |
| 158 | tlb_probe(); |
| 159 | tlb_probe_hazard(); |
| 160 | tlbidx = read_c0_index(); |
| 161 | mtc0_tlbw_hazard(); |
| 162 | if (tlbidx < 0) |
| 163 | tlb_write_random(); |
| 164 | else |
| 165 | tlb_write_indexed(); |
| 166 | #else |
| 167 | tlbidx = read_c0_wired(); |
| 168 | write_c0_wired(tlbidx + 1); |
| 169 | write_c0_index(tlbidx); |
| 170 | mtc0_tlbw_hazard(); |
| 171 | tlb_write_indexed(); |
| 172 | #endif |
| 173 | tlbw_use_hazard(); |
| 174 | write_c0_entryhi(old_ctx); |
| 175 | EXIT_CRITICAL(flags); |
| 176 | |
| 177 | return (void*) vaddr; |
| 178 | } |
| 179 | |
| 180 | #define UNIQUE_ENTRYHI(idx) (CKSEG0 + ((idx) << (PAGE_SHIFT + 1))) |
| 181 | |
| 182 | static inline void kunmap_coherent(struct page *page) |
| 183 | { |
| 184 | #ifndef CONFIG_MIPS_MT_SMTC |
| 185 | unsigned int wired; |
| 186 | unsigned long flags, old_ctx; |
| 187 | |
| 188 | ENTER_CRITICAL(flags); |
| 189 | old_ctx = read_c0_entryhi(); |
| 190 | wired = read_c0_wired() - 1; |
| 191 | write_c0_wired(wired); |
| 192 | write_c0_index(wired); |
| 193 | write_c0_entryhi(UNIQUE_ENTRYHI(wired)); |
| 194 | write_c0_entrylo0(0); |
| 195 | write_c0_entrylo1(0); |
| 196 | mtc0_tlbw_hazard(); |
| 197 | tlb_write_indexed(); |
| 198 | tlbw_use_hazard(); |
| 199 | write_c0_entryhi(old_ctx); |
| 200 | EXIT_CRITICAL(flags); |
| 201 | #endif |
| 202 | dec_preempt_count(); |
| 203 | preempt_check_resched(); |
| 204 | } |
| 205 | |
| 206 | void copy_to_user_page(struct vm_area_struct *vma, |
| 207 | struct page *page, unsigned long vaddr, void *dst, const void *src, |
| 208 | unsigned long len) |
| 209 | { |
| 210 | if (cpu_has_dc_aliases) { |
| 211 | void *vto = kmap_coherent(page, vaddr) + (vaddr & ~PAGE_MASK); |
| 212 | memcpy(vto, src, len); |
| 213 | kunmap_coherent(page); |
| 214 | } else |
| 215 | memcpy(dst, src, len); |
| 216 | if ((vma->vm_flags & VM_EXEC) && !cpu_has_ic_fills_f_dc) |
| 217 | flush_cache_page(vma, vaddr, page_to_pfn(page)); |
| 218 | } |
| 219 | |
| 220 | EXPORT_SYMBOL(copy_to_user_page); |
| 221 | |
| 222 | void copy_from_user_page(struct vm_area_struct *vma, |
| 223 | struct page *page, unsigned long vaddr, void *dst, const void *src, |
| 224 | unsigned long len) |
| 225 | { |
| 226 | if (cpu_has_dc_aliases) { |
| 227 | void *vfrom = |
| 228 | kmap_coherent(page, vaddr) + (vaddr & ~PAGE_MASK); |
| 229 | memcpy(dst, vfrom, len); |
| 230 | kunmap_coherent(page); |
| 231 | } else |
| 232 | memcpy(dst, src, len); |
| 233 | } |
| 234 | |
| 235 | EXPORT_SYMBOL(copy_from_user_page); |
| 236 | |
| 237 | |
| 238 | #ifdef CONFIG_HIGHMEM |
| 239 | pte_t *kmap_pte; |
| 240 | pgprot_t kmap_prot; |
| 241 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | static void __init kmap_init(void) |
| 243 | { |
| 244 | unsigned long kmap_vstart; |
| 245 | |
| 246 | /* cache the first kmap pte */ |
| 247 | kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN); |
| 248 | kmap_pte = kmap_get_fixmap_pte(kmap_vstart); |
| 249 | |
| 250 | kmap_prot = PAGE_KERNEL; |
| 251 | } |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 252 | #endif /* CONFIG_HIGHMEM */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | |
Ralf Baechle | 84fd089 | 2005-02-07 16:13:07 +0000 | [diff] [blame] | 254 | void __init fixrange_init(unsigned long start, unsigned long end, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | pgd_t *pgd_base) |
| 256 | { |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 257 | #if defined(CONFIG_HIGHMEM) || defined(CONFIG_MIPS_MT_SMTC) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | pgd_t *pgd; |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 259 | pud_t *pud; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | pmd_t *pmd; |
| 261 | pte_t *pte; |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 262 | int i, j, k; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | unsigned long vaddr; |
| 264 | |
| 265 | vaddr = start; |
| 266 | i = __pgd_offset(vaddr); |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 267 | j = __pud_offset(vaddr); |
| 268 | k = __pmd_offset(vaddr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | pgd = pgd_base + i; |
| 270 | |
| 271 | for ( ; (i < PTRS_PER_PGD) && (vaddr != end); pgd++, i++) { |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 272 | pud = (pud_t *)pgd; |
| 273 | for ( ; (j < PTRS_PER_PUD) && (vaddr != end); pud++, j++) { |
| 274 | pmd = (pmd_t *)pud; |
| 275 | for (; (k < PTRS_PER_PMD) && (vaddr != end); pmd++, k++) { |
| 276 | if (pmd_none(*pmd)) { |
| 277 | pte = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE); |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 278 | set_pmd(pmd, __pmd((unsigned long)pte)); |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 279 | if (pte != pte_offset_kernel(pmd, 0)) |
| 280 | BUG(); |
| 281 | } |
| 282 | vaddr += PMD_SIZE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | } |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 284 | k = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 285 | } |
| 286 | j = 0; |
| 287 | } |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 288 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | |
Yoichi Yuasa | b4819b5 | 2005-06-25 14:54:31 -0700 | [diff] [blame] | 291 | #ifndef CONFIG_NEED_MULTIPLE_NODES |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | extern void pagetable_init(void); |
| 293 | |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 294 | static int __init page_is_ram(unsigned long pagenr) |
| 295 | { |
| 296 | int i; |
| 297 | |
| 298 | for (i = 0; i < boot_mem_map.nr_map; i++) { |
| 299 | unsigned long addr, end; |
| 300 | |
| 301 | if (boot_mem_map.map[i].type != BOOT_MEM_RAM) |
| 302 | /* not usable memory */ |
| 303 | continue; |
| 304 | |
| 305 | addr = PFN_UP(boot_mem_map.map[i].addr); |
| 306 | end = PFN_DOWN(boot_mem_map.map[i].addr + |
| 307 | boot_mem_map.map[i].size); |
| 308 | |
| 309 | if (pagenr >= addr && pagenr < end) |
| 310 | return 1; |
| 311 | } |
| 312 | |
| 313 | return 0; |
| 314 | } |
| 315 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 316 | void __init paging_init(void) |
| 317 | { |
Atsushi Nemoto | b58e5d0 | 2006-09-30 03:34:06 +0900 | [diff] [blame] | 318 | unsigned long zones_size[MAX_NR_ZONES] = { 0, }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | unsigned long max_dma, high, low; |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 320 | #ifndef CONFIG_FLATMEM |
Atsushi Nemoto | b58e5d0 | 2006-09-30 03:34:06 +0900 | [diff] [blame] | 321 | unsigned long zholes_size[MAX_NR_ZONES] = { 0, }; |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 322 | unsigned long i, j, pfn; |
| 323 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | |
| 325 | pagetable_init(); |
| 326 | |
| 327 | #ifdef CONFIG_HIGHMEM |
| 328 | kmap_init(); |
| 329 | #endif |
Ralf Baechle | f8829ca | 2006-10-21 23:17:35 +0100 | [diff] [blame] | 330 | kmap_coherent_init(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | |
| 332 | max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT; |
| 333 | low = max_low_pfn; |
| 334 | high = highend_pfn; |
| 335 | |
| 336 | #ifdef CONFIG_ISA |
| 337 | if (low < max_dma) |
| 338 | zones_size[ZONE_DMA] = low; |
| 339 | else { |
| 340 | zones_size[ZONE_DMA] = max_dma; |
| 341 | zones_size[ZONE_NORMAL] = low - max_dma; |
| 342 | } |
| 343 | #else |
| 344 | zones_size[ZONE_DMA] = low; |
| 345 | #endif |
| 346 | #ifdef CONFIG_HIGHMEM |
| 347 | if (cpu_has_dc_aliases) { |
| 348 | printk(KERN_WARNING "This processor doesn't support highmem."); |
| 349 | if (high - low) |
| 350 | printk(" %ldk highmem ignored", high - low); |
| 351 | printk("\n"); |
| 352 | } else |
| 353 | zones_size[ZONE_HIGHMEM] = high - low; |
| 354 | #endif |
| 355 | |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 356 | #ifdef CONFIG_FLATMEM |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | free_area_init(zones_size); |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 358 | #else |
| 359 | pfn = 0; |
| 360 | for (i = 0; i < MAX_NR_ZONES; i++) |
| 361 | for (j = 0; j < zones_size[i]; j++, pfn++) |
| 362 | if (!page_is_ram(pfn)) |
| 363 | zholes_size[i]++; |
| 364 | free_area_init_node(0, NODE_DATA(0), zones_size, 0, zholes_size); |
| 365 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 366 | } |
| 367 | |
Daniel Jacobowitz | 3d50375 | 2005-01-20 19:59:54 -0500 | [diff] [blame] | 368 | static struct kcore_list kcore_mem, kcore_vmalloc; |
| 369 | #ifdef CONFIG_64BIT |
| 370 | static struct kcore_list kcore_kseg0; |
| 371 | #endif |
| 372 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 373 | void __init mem_init(void) |
| 374 | { |
| 375 | unsigned long codesize, reservedpages, datasize, initsize; |
| 376 | unsigned long tmp, ram; |
| 377 | |
| 378 | #ifdef CONFIG_HIGHMEM |
| 379 | #ifdef CONFIG_DISCONTIGMEM |
| 380 | #error "CONFIG_HIGHMEM and CONFIG_DISCONTIGMEM dont work together yet" |
| 381 | #endif |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 382 | max_mapnr = highend_pfn; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | #else |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 384 | max_mapnr = max_low_pfn; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | #endif |
| 386 | high_memory = (void *) __va(max_low_pfn << PAGE_SHIFT); |
| 387 | |
| 388 | totalram_pages += free_all_bootmem(); |
| 389 | totalram_pages -= setup_zero_pages(); /* Setup zeroed pages. */ |
| 390 | |
| 391 | reservedpages = ram = 0; |
| 392 | for (tmp = 0; tmp < max_low_pfn; tmp++) |
| 393 | if (page_is_ram(tmp)) { |
| 394 | ram++; |
Chad Reese | b1c231f | 2006-05-30 17:16:49 -0700 | [diff] [blame] | 395 | if (PageReserved(pfn_to_page(tmp))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | reservedpages++; |
| 397 | } |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 398 | num_physpages = ram; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | |
| 400 | #ifdef CONFIG_HIGHMEM |
| 401 | for (tmp = highstart_pfn; tmp < highend_pfn; tmp++) { |
| 402 | struct page *page = mem_map + tmp; |
| 403 | |
| 404 | if (!page_is_ram(tmp)) { |
| 405 | SetPageReserved(page); |
| 406 | continue; |
| 407 | } |
| 408 | ClearPageReserved(page); |
| 409 | #ifdef CONFIG_LIMITED_DMA |
| 410 | set_page_address(page, lowmem_page_address(page)); |
| 411 | #endif |
Nick Piggin | 7835e98 | 2006-03-22 00:08:40 -0800 | [diff] [blame] | 412 | init_page_count(page); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 413 | __free_page(page); |
| 414 | totalhigh_pages++; |
| 415 | } |
| 416 | totalram_pages += totalhigh_pages; |
Atsushi Nemoto | 565200a | 2006-07-07 00:26:02 +0900 | [diff] [blame] | 417 | num_physpages += totalhigh_pages; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 418 | #endif |
| 419 | |
| 420 | codesize = (unsigned long) &_etext - (unsigned long) &_text; |
| 421 | datasize = (unsigned long) &_edata - (unsigned long) &_etext; |
| 422 | initsize = (unsigned long) &__init_end - (unsigned long) &__init_begin; |
| 423 | |
Daniel Jacobowitz | 3d50375 | 2005-01-20 19:59:54 -0500 | [diff] [blame] | 424 | #ifdef CONFIG_64BIT |
| 425 | if ((unsigned long) &_text > (unsigned long) CKSEG0) |
| 426 | /* The -4 is a hack so that user tools don't have to handle |
| 427 | the overflow. */ |
| 428 | kclist_add(&kcore_kseg0, (void *) CKSEG0, 0x80000000 - 4); |
| 429 | #endif |
| 430 | kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT); |
| 431 | kclist_add(&kcore_vmalloc, (void *)VMALLOC_START, |
| 432 | VMALLOC_END-VMALLOC_START); |
| 433 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 434 | printk(KERN_INFO "Memory: %luk/%luk available (%ldk kernel code, " |
| 435 | "%ldk reserved, %ldk data, %ldk init, %ldk highmem)\n", |
| 436 | (unsigned long) nr_free_pages() << (PAGE_SHIFT-10), |
| 437 | ram << (PAGE_SHIFT-10), |
| 438 | codesize >> 10, |
| 439 | reservedpages << (PAGE_SHIFT-10), |
| 440 | datasize >> 10, |
| 441 | initsize >> 10, |
| 442 | (unsigned long) (totalhigh_pages << (PAGE_SHIFT-10))); |
| 443 | } |
Yoichi Yuasa | b4819b5 | 2005-06-25 14:54:31 -0700 | [diff] [blame] | 444 | #endif /* !CONFIG_NEED_MULTIPLE_NODES */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 445 | |
Ralf Baechle | 6fd11a2 | 2006-03-24 13:21:50 +0000 | [diff] [blame] | 446 | void free_init_pages(char *what, unsigned long begin, unsigned long end) |
| 447 | { |
| 448 | unsigned long addr; |
| 449 | |
| 450 | for (addr = begin; addr < end; addr += PAGE_SIZE) { |
| 451 | ClearPageReserved(virt_to_page(addr)); |
| 452 | init_page_count(virt_to_page(addr)); |
| 453 | memset((void *)addr, 0xcc, PAGE_SIZE); |
| 454 | free_page(addr); |
| 455 | totalram_pages++; |
| 456 | } |
| 457 | printk(KERN_INFO "Freeing %s: %ldk freed\n", what, (end - begin) >> 10); |
| 458 | } |
| 459 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | #ifdef CONFIG_BLK_DEV_INITRD |
| 461 | void free_initrd_mem(unsigned long start, unsigned long end) |
| 462 | { |
Ralf Baechle | 875d43e | 2005-09-03 15:56:16 -0700 | [diff] [blame] | 463 | #ifdef CONFIG_64BIT |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | /* Switch from KSEG0 to XKPHYS addresses */ |
| 465 | start = (unsigned long)phys_to_virt(CPHYSADDR(start)); |
| 466 | end = (unsigned long)phys_to_virt(CPHYSADDR(end)); |
| 467 | #endif |
Ralf Baechle | 6fd11a2 | 2006-03-24 13:21:50 +0000 | [diff] [blame] | 468 | free_init_pages("initrd memory", start, end); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 469 | } |
| 470 | #endif |
| 471 | |
| 472 | extern unsigned long prom_free_prom_memory(void); |
| 473 | |
| 474 | void free_initmem(void) |
| 475 | { |
Ralf Baechle | 6fd11a2 | 2006-03-24 13:21:50 +0000 | [diff] [blame] | 476 | unsigned long start, end, freed; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | |
| 478 | freed = prom_free_prom_memory(); |
Ralf Baechle | 6fd11a2 | 2006-03-24 13:21:50 +0000 | [diff] [blame] | 479 | if (freed) |
| 480 | printk(KERN_INFO "Freeing firmware memory: %ldk freed\n",freed); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 481 | |
Ralf Baechle | 6fd11a2 | 2006-03-24 13:21:50 +0000 | [diff] [blame] | 482 | start = (unsigned long)(&__init_begin); |
| 483 | end = (unsigned long)(&__init_end); |
Ralf Baechle | 875d43e | 2005-09-03 15:56:16 -0700 | [diff] [blame] | 484 | #ifdef CONFIG_64BIT |
Ralf Baechle | 6fd11a2 | 2006-03-24 13:21:50 +0000 | [diff] [blame] | 485 | start = PAGE_OFFSET | CPHYSADDR(start); |
| 486 | end = PAGE_OFFSET | CPHYSADDR(end); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 487 | #endif |
Ralf Baechle | 6fd11a2 | 2006-03-24 13:21:50 +0000 | [diff] [blame] | 488 | free_init_pages("unused kernel memory", start, end); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 489 | } |