Adrian Bunk | 88278ca | 2008-05-19 16:53:02 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * linux/arch/sparc/mm/init.c |
| 3 | * |
| 4 | * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) |
| 5 | * Copyright (C) 1995 Eddie C. Dost (ecd@skynet.be) |
| 6 | * Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) |
| 7 | * Copyright (C) 2000 Anton Blanchard (anton@samba.org) |
| 8 | */ |
| 9 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | #include <linux/module.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/ptrace.h> |
| 18 | #include <linux/mman.h> |
| 19 | #include <linux/mm.h> |
| 20 | #include <linux/swap.h> |
| 21 | #include <linux/initrd.h> |
| 22 | #include <linux/init.h> |
| 23 | #include <linux/highmem.h> |
| 24 | #include <linux/bootmem.h> |
Robert Reif | f538f3d | 2008-07-14 22:57:29 -0700 | [diff] [blame] | 25 | #include <linux/pagemap.h> |
Robert Reif | 1aa0365 | 2008-09-03 16:29:42 -0700 | [diff] [blame] | 26 | #include <linux/poison.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | |
Sam Ravnborg | 86ed40b | 2008-12-27 00:35:12 -0800 | [diff] [blame^] | 28 | #include <asm/sections.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include <asm/system.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | #include <asm/vac-ops.h> |
| 31 | #include <asm/page.h> |
| 32 | #include <asm/pgtable.h> |
| 33 | #include <asm/vaddrs.h> |
| 34 | #include <asm/pgalloc.h> /* bug in asm-generic/tlb.h: check_pgt_cache */ |
| 35 | #include <asm/tlb.h> |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 36 | #include <asm/prom.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
| 38 | DEFINE_PER_CPU(struct mmu_gather, mmu_gathers); |
| 39 | |
| 40 | unsigned long *sparc_valid_addr_bitmap; |
| 41 | |
| 42 | unsigned long phys_base; |
| 43 | unsigned long pfn_base; |
| 44 | |
| 45 | unsigned long page_kernel; |
| 46 | |
| 47 | struct sparc_phys_banks sp_banks[SPARC_PHYS_BANKS+1]; |
| 48 | unsigned long sparc_unmapped_base; |
| 49 | |
| 50 | struct pgtable_cache_struct pgt_quicklists; |
| 51 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | /* Initial ramdisk setup */ |
| 53 | extern unsigned int sparc_ramdisk_image; |
| 54 | extern unsigned int sparc_ramdisk_size; |
| 55 | |
| 56 | unsigned long highstart_pfn, highend_pfn; |
| 57 | |
| 58 | pte_t *kmap_pte; |
| 59 | pgprot_t kmap_prot; |
| 60 | |
| 61 | #define kmap_get_fixmap_pte(vaddr) \ |
| 62 | pte_offset_kernel(pmd_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr)) |
| 63 | |
| 64 | void __init kmap_init(void) |
| 65 | { |
| 66 | /* cache the first kmap pte */ |
| 67 | kmap_pte = kmap_get_fixmap_pte(__fix_to_virt(FIX_KMAP_BEGIN)); |
| 68 | kmap_prot = __pgprot(SRMMU_ET_PTE | SRMMU_PRIV | SRMMU_CACHE); |
| 69 | } |
| 70 | |
| 71 | void show_mem(void) |
| 72 | { |
| 73 | printk("Mem-info:\n"); |
| 74 | show_free_areas(); |
| 75 | printk("Free swap: %6ldkB\n", |
| 76 | nr_swap_pages << (PAGE_SHIFT-10)); |
| 77 | printk("%ld pages of RAM\n", totalram_pages); |
Al Viro | f0f0d0c | 2007-03-14 09:18:50 +0000 | [diff] [blame] | 78 | printk("%ld free pages\n", nr_free_pages()); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | #if 0 /* undefined pgtable_cache_size, pgd_cache_size */ |
| 80 | printk("%ld pages in page table cache\n",pgtable_cache_size); |
| 81 | #ifndef CONFIG_SMP |
| 82 | if (sparc_cpu_model == sun4m || sparc_cpu_model == sun4d) |
| 83 | printk("%ld entries in page dir cache\n",pgd_cache_size); |
| 84 | #endif |
| 85 | #endif |
| 86 | } |
| 87 | |
| 88 | void __init sparc_context_init(int numctx) |
| 89 | { |
| 90 | int ctx; |
| 91 | |
| 92 | ctx_list_pool = __alloc_bootmem(numctx * sizeof(struct ctx_list), SMP_CACHE_BYTES, 0UL); |
| 93 | |
| 94 | for(ctx = 0; ctx < numctx; ctx++) { |
| 95 | struct ctx_list *clist; |
| 96 | |
| 97 | clist = (ctx_list_pool + ctx); |
| 98 | clist->ctx_number = ctx; |
| 99 | clist->ctx_mm = NULL; |
| 100 | } |
| 101 | ctx_free.next = ctx_free.prev = &ctx_free; |
| 102 | ctx_used.next = ctx_used.prev = &ctx_used; |
| 103 | for(ctx = 0; ctx < numctx; ctx++) |
| 104 | add_to_free_ctxlist(ctx_list_pool + ctx); |
| 105 | } |
| 106 | |
| 107 | extern unsigned long cmdline_memory_size; |
| 108 | unsigned long last_valid_pfn; |
| 109 | |
| 110 | unsigned long calc_highpages(void) |
| 111 | { |
| 112 | int i; |
| 113 | int nr = 0; |
| 114 | |
| 115 | for (i = 0; sp_banks[i].num_bytes != 0; i++) { |
| 116 | unsigned long start_pfn = sp_banks[i].base_addr >> PAGE_SHIFT; |
| 117 | unsigned long end_pfn = (sp_banks[i].base_addr + sp_banks[i].num_bytes) >> PAGE_SHIFT; |
| 118 | |
| 119 | if (end_pfn <= max_low_pfn) |
| 120 | continue; |
| 121 | |
| 122 | if (start_pfn < max_low_pfn) |
| 123 | start_pfn = max_low_pfn; |
| 124 | |
| 125 | nr += end_pfn - start_pfn; |
| 126 | } |
| 127 | |
| 128 | return nr; |
| 129 | } |
| 130 | |
Adrian Bunk | 50215d6 | 2008-06-05 11:41:51 -0700 | [diff] [blame] | 131 | static unsigned long calc_max_low_pfn(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | { |
| 133 | int i; |
| 134 | unsigned long tmp = pfn_base + (SRMMU_MAXMEM >> PAGE_SHIFT); |
| 135 | unsigned long curr_pfn, last_pfn; |
| 136 | |
| 137 | last_pfn = (sp_banks[0].base_addr + sp_banks[0].num_bytes) >> PAGE_SHIFT; |
| 138 | for (i = 1; sp_banks[i].num_bytes != 0; i++) { |
| 139 | curr_pfn = sp_banks[i].base_addr >> PAGE_SHIFT; |
| 140 | |
| 141 | if (curr_pfn >= tmp) { |
| 142 | if (last_pfn < tmp) |
| 143 | tmp = last_pfn; |
| 144 | break; |
| 145 | } |
| 146 | |
| 147 | last_pfn = (sp_banks[i].base_addr + sp_banks[i].num_bytes) >> PAGE_SHIFT; |
| 148 | } |
| 149 | |
| 150 | return tmp; |
| 151 | } |
| 152 | |
| 153 | unsigned long __init bootmem_init(unsigned long *pages_avail) |
| 154 | { |
| 155 | unsigned long bootmap_size, start_pfn; |
| 156 | unsigned long end_of_phys_memory = 0UL; |
| 157 | unsigned long bootmap_pfn, bytes_avail, size; |
| 158 | int i; |
| 159 | |
| 160 | bytes_avail = 0UL; |
| 161 | for (i = 0; sp_banks[i].num_bytes != 0; i++) { |
| 162 | end_of_phys_memory = sp_banks[i].base_addr + |
| 163 | sp_banks[i].num_bytes; |
| 164 | bytes_avail += sp_banks[i].num_bytes; |
| 165 | if (cmdline_memory_size) { |
| 166 | if (bytes_avail > cmdline_memory_size) { |
| 167 | unsigned long slack = bytes_avail - cmdline_memory_size; |
| 168 | |
| 169 | bytes_avail -= slack; |
| 170 | end_of_phys_memory -= slack; |
| 171 | |
| 172 | sp_banks[i].num_bytes -= slack; |
| 173 | if (sp_banks[i].num_bytes == 0) { |
| 174 | sp_banks[i].base_addr = 0xdeadbeef; |
| 175 | } else { |
| 176 | sp_banks[i+1].num_bytes = 0; |
| 177 | sp_banks[i+1].base_addr = 0xdeadbeef; |
| 178 | } |
| 179 | break; |
| 180 | } |
| 181 | } |
| 182 | } |
| 183 | |
| 184 | /* Start with page aligned address of last symbol in kernel |
| 185 | * image. |
| 186 | */ |
| 187 | start_pfn = (unsigned long)__pa(PAGE_ALIGN((unsigned long) &_end)); |
| 188 | |
| 189 | /* Now shift down to get the real physical page frame number. */ |
| 190 | start_pfn >>= PAGE_SHIFT; |
| 191 | |
| 192 | bootmap_pfn = start_pfn; |
| 193 | |
| 194 | max_pfn = end_of_phys_memory >> PAGE_SHIFT; |
| 195 | |
| 196 | max_low_pfn = max_pfn; |
| 197 | highstart_pfn = highend_pfn = max_pfn; |
| 198 | |
| 199 | if (max_low_pfn > pfn_base + (SRMMU_MAXMEM >> PAGE_SHIFT)) { |
| 200 | highstart_pfn = pfn_base + (SRMMU_MAXMEM >> PAGE_SHIFT); |
| 201 | max_low_pfn = calc_max_low_pfn(); |
| 202 | printk(KERN_NOTICE "%ldMB HIGHMEM available.\n", |
| 203 | calc_highpages() >> (20 - PAGE_SHIFT)); |
| 204 | } |
| 205 | |
| 206 | #ifdef CONFIG_BLK_DEV_INITRD |
| 207 | /* Now have to check initial ramdisk, so that bootmap does not overwrite it */ |
| 208 | if (sparc_ramdisk_image) { |
David S. Miller | efb89630 | 2007-08-20 15:52:18 -0700 | [diff] [blame] | 209 | if (sparc_ramdisk_image >= (unsigned long)&_end - 2 * PAGE_SIZE) |
| 210 | sparc_ramdisk_image -= KERNBASE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | initrd_start = sparc_ramdisk_image + phys_base; |
| 212 | initrd_end = initrd_start + sparc_ramdisk_size; |
| 213 | if (initrd_end > end_of_phys_memory) { |
| 214 | printk(KERN_CRIT "initrd extends beyond end of memory " |
| 215 | "(0x%016lx > 0x%016lx)\ndisabling initrd\n", |
| 216 | initrd_end, end_of_phys_memory); |
| 217 | initrd_start = 0; |
| 218 | } |
| 219 | if (initrd_start) { |
| 220 | if (initrd_start >= (start_pfn << PAGE_SHIFT) && |
| 221 | initrd_start < (start_pfn << PAGE_SHIFT) + 2 * PAGE_SIZE) |
| 222 | bootmap_pfn = PAGE_ALIGN (initrd_end) >> PAGE_SHIFT; |
| 223 | } |
| 224 | } |
| 225 | #endif |
| 226 | /* Initialize the boot-time allocator. */ |
| 227 | bootmap_size = init_bootmem_node(NODE_DATA(0), bootmap_pfn, pfn_base, |
| 228 | max_low_pfn); |
| 229 | |
| 230 | /* Now register the available physical memory with the |
| 231 | * allocator. |
| 232 | */ |
| 233 | *pages_avail = 0; |
| 234 | for (i = 0; sp_banks[i].num_bytes != 0; i++) { |
| 235 | unsigned long curr_pfn, last_pfn; |
| 236 | |
| 237 | curr_pfn = sp_banks[i].base_addr >> PAGE_SHIFT; |
| 238 | if (curr_pfn >= max_low_pfn) |
| 239 | break; |
| 240 | |
| 241 | last_pfn = (sp_banks[i].base_addr + sp_banks[i].num_bytes) >> PAGE_SHIFT; |
| 242 | if (last_pfn > max_low_pfn) |
| 243 | last_pfn = max_low_pfn; |
| 244 | |
| 245 | /* |
| 246 | * .. finally, did all the rounding and playing |
| 247 | * around just make the area go away? |
| 248 | */ |
| 249 | if (last_pfn <= curr_pfn) |
| 250 | continue; |
| 251 | |
| 252 | size = (last_pfn - curr_pfn) << PAGE_SHIFT; |
| 253 | *pages_avail += last_pfn - curr_pfn; |
| 254 | |
| 255 | free_bootmem(sp_banks[i].base_addr, size); |
| 256 | } |
| 257 | |
| 258 | #ifdef CONFIG_BLK_DEV_INITRD |
| 259 | if (initrd_start) { |
| 260 | /* Reserve the initrd image area. */ |
| 261 | size = initrd_end - initrd_start; |
Bernhard Walle | 72a7fe3 | 2008-02-07 00:15:17 -0800 | [diff] [blame] | 262 | reserve_bootmem(initrd_start, size, BOOTMEM_DEFAULT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT; |
| 264 | |
| 265 | initrd_start = (initrd_start - phys_base) + PAGE_OFFSET; |
| 266 | initrd_end = (initrd_end - phys_base) + PAGE_OFFSET; |
| 267 | } |
| 268 | #endif |
| 269 | /* Reserve the kernel text/data/bss. */ |
| 270 | size = (start_pfn << PAGE_SHIFT) - phys_base; |
Bernhard Walle | 72a7fe3 | 2008-02-07 00:15:17 -0800 | [diff] [blame] | 271 | reserve_bootmem(phys_base, size, BOOTMEM_DEFAULT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT; |
| 273 | |
| 274 | /* Reserve the bootmem map. We do not account for it |
| 275 | * in pages_avail because we will release that memory |
| 276 | * in free_all_bootmem. |
| 277 | */ |
| 278 | size = bootmap_size; |
Bernhard Walle | 72a7fe3 | 2008-02-07 00:15:17 -0800 | [diff] [blame] | 279 | reserve_bootmem((bootmap_pfn << PAGE_SHIFT), size, BOOTMEM_DEFAULT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT; |
| 281 | |
| 282 | return max_pfn; |
| 283 | } |
| 284 | |
| 285 | /* |
| 286 | * check_pgt_cache |
| 287 | * |
| 288 | * This is called at the end of unmapping of VMA (zap_page_range), |
| 289 | * to rescan the page cache for architecture specific things, |
| 290 | * presumably something like sun4/sun4c PMEGs. Most architectures |
| 291 | * define check_pgt_cache empty. |
| 292 | * |
| 293 | * We simply copy the 2.4 implementation for now. |
| 294 | */ |
Adrian Bunk | 50215d6 | 2008-06-05 11:41:51 -0700 | [diff] [blame] | 295 | static int pgt_cache_water[2] = { 25, 50 }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | |
| 297 | void check_pgt_cache(void) |
| 298 | { |
| 299 | do_check_pgt_cache(pgt_cache_water[0], pgt_cache_water[1]); |
| 300 | } |
| 301 | |
| 302 | /* |
| 303 | * paging_init() sets up the page tables: We call the MMU specific |
| 304 | * init routine based upon the Sun model type on the Sparc. |
| 305 | * |
| 306 | */ |
| 307 | extern void sun4c_paging_init(void); |
| 308 | extern void srmmu_paging_init(void); |
| 309 | extern void device_scan(void); |
| 310 | |
Al Viro | 378e515 | 2007-07-21 19:20:34 -0700 | [diff] [blame] | 311 | pgprot_t PAGE_SHARED __read_mostly; |
| 312 | EXPORT_SYMBOL(PAGE_SHARED); |
| 313 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 314 | void __init paging_init(void) |
| 315 | { |
| 316 | switch(sparc_cpu_model) { |
| 317 | case sun4c: |
| 318 | case sun4e: |
| 319 | case sun4: |
| 320 | sun4c_paging_init(); |
| 321 | sparc_unmapped_base = 0xe0000000; |
| 322 | BTFIXUPSET_SETHI(sparc_unmapped_base, 0xe0000000); |
| 323 | break; |
| 324 | case sun4m: |
| 325 | case sun4d: |
| 326 | srmmu_paging_init(); |
| 327 | sparc_unmapped_base = 0x50000000; |
| 328 | BTFIXUPSET_SETHI(sparc_unmapped_base, 0x50000000); |
| 329 | break; |
| 330 | default: |
| 331 | prom_printf("paging_init: Cannot init paging on this Sparc\n"); |
| 332 | prom_printf("paging_init: sparc_cpu_model = %d\n", sparc_cpu_model); |
| 333 | prom_printf("paging_init: Halting...\n"); |
| 334 | prom_halt(); |
| 335 | }; |
| 336 | |
| 337 | /* Initialize the protection map with non-constant, MMU dependent values. */ |
| 338 | protection_map[0] = PAGE_NONE; |
| 339 | protection_map[1] = PAGE_READONLY; |
| 340 | protection_map[2] = PAGE_COPY; |
| 341 | protection_map[3] = PAGE_COPY; |
| 342 | protection_map[4] = PAGE_READONLY; |
| 343 | protection_map[5] = PAGE_READONLY; |
| 344 | protection_map[6] = PAGE_COPY; |
| 345 | protection_map[7] = PAGE_COPY; |
| 346 | protection_map[8] = PAGE_NONE; |
| 347 | protection_map[9] = PAGE_READONLY; |
| 348 | protection_map[10] = PAGE_SHARED; |
| 349 | protection_map[11] = PAGE_SHARED; |
| 350 | protection_map[12] = PAGE_READONLY; |
| 351 | protection_map[13] = PAGE_READONLY; |
| 352 | protection_map[14] = PAGE_SHARED; |
| 353 | protection_map[15] = PAGE_SHARED; |
| 354 | btfixup(); |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 355 | prom_build_devicetree(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | device_scan(); |
| 357 | } |
| 358 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | static void __init taint_real_pages(void) |
| 360 | { |
| 361 | int i; |
| 362 | |
| 363 | for (i = 0; sp_banks[i].num_bytes; i++) { |
| 364 | unsigned long start, end; |
| 365 | |
| 366 | start = sp_banks[i].base_addr; |
| 367 | end = start + sp_banks[i].num_bytes; |
| 368 | |
| 369 | while (start < end) { |
| 370 | set_bit(start >> 20, sparc_valid_addr_bitmap); |
| 371 | start += PAGE_SIZE; |
| 372 | } |
| 373 | } |
| 374 | } |
| 375 | |
Adrian Bunk | 50215d6 | 2008-06-05 11:41:51 -0700 | [diff] [blame] | 376 | static void map_high_region(unsigned long start_pfn, unsigned long end_pfn) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 377 | { |
| 378 | unsigned long tmp; |
| 379 | |
| 380 | #ifdef CONFIG_DEBUG_HIGHMEM |
| 381 | printk("mapping high region %08lx - %08lx\n", start_pfn, end_pfn); |
| 382 | #endif |
| 383 | |
| 384 | for (tmp = start_pfn; tmp < end_pfn; tmp++) { |
| 385 | struct page *page = pfn_to_page(tmp); |
| 386 | |
| 387 | ClearPageReserved(page); |
Nick Piggin | 7835e98 | 2006-03-22 00:08:40 -0800 | [diff] [blame] | 388 | init_page_count(page); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | __free_page(page); |
| 390 | totalhigh_pages++; |
| 391 | } |
| 392 | } |
| 393 | |
| 394 | void __init mem_init(void) |
| 395 | { |
| 396 | int codepages = 0; |
| 397 | int datapages = 0; |
| 398 | int initpages = 0; |
| 399 | int reservedpages = 0; |
| 400 | int i; |
| 401 | |
| 402 | if (PKMAP_BASE+LAST_PKMAP*PAGE_SIZE >= FIXADDR_START) { |
| 403 | prom_printf("BUG: fixmap and pkmap areas overlap\n"); |
| 404 | prom_printf("pkbase: 0x%lx pkend: 0x%lx fixstart 0x%lx\n", |
| 405 | PKMAP_BASE, |
| 406 | (unsigned long)PKMAP_BASE+LAST_PKMAP*PAGE_SIZE, |
| 407 | FIXADDR_START); |
| 408 | prom_printf("Please mail sparclinux@vger.kernel.org.\n"); |
| 409 | prom_halt(); |
| 410 | } |
| 411 | |
| 412 | |
| 413 | /* Saves us work later. */ |
| 414 | memset((void *)&empty_zero_page, 0, PAGE_SIZE); |
| 415 | |
| 416 | i = last_valid_pfn >> ((20 - PAGE_SHIFT) + 5); |
| 417 | i += 1; |
| 418 | sparc_valid_addr_bitmap = (unsigned long *) |
| 419 | __alloc_bootmem(i << 2, SMP_CACHE_BYTES, 0UL); |
| 420 | |
| 421 | if (sparc_valid_addr_bitmap == NULL) { |
| 422 | prom_printf("mem_init: Cannot alloc valid_addr_bitmap.\n"); |
| 423 | prom_halt(); |
| 424 | } |
| 425 | memset(sparc_valid_addr_bitmap, 0, i << 2); |
| 426 | |
| 427 | taint_real_pages(); |
| 428 | |
| 429 | max_mapnr = last_valid_pfn - pfn_base; |
| 430 | high_memory = __va(max_low_pfn << PAGE_SHIFT); |
| 431 | |
| 432 | totalram_pages = free_all_bootmem(); |
| 433 | |
| 434 | for (i = 0; sp_banks[i].num_bytes != 0; i++) { |
| 435 | unsigned long start_pfn = sp_banks[i].base_addr >> PAGE_SHIFT; |
| 436 | unsigned long end_pfn = (sp_banks[i].base_addr + sp_banks[i].num_bytes) >> PAGE_SHIFT; |
| 437 | |
| 438 | num_physpages += sp_banks[i].num_bytes >> PAGE_SHIFT; |
| 439 | |
| 440 | if (end_pfn <= highstart_pfn) |
| 441 | continue; |
| 442 | |
| 443 | if (start_pfn < highstart_pfn) |
| 444 | start_pfn = highstart_pfn; |
| 445 | |
| 446 | map_high_region(start_pfn, end_pfn); |
| 447 | } |
| 448 | |
| 449 | totalram_pages += totalhigh_pages; |
| 450 | |
Sam Ravnborg | 86ed40b | 2008-12-27 00:35:12 -0800 | [diff] [blame^] | 451 | codepages = (((unsigned long) &_etext) - ((unsigned long)&_start)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 452 | codepages = PAGE_ALIGN(codepages) >> PAGE_SHIFT; |
Sam Ravnborg | 86ed40b | 2008-12-27 00:35:12 -0800 | [diff] [blame^] | 453 | datapages = (((unsigned long) &_edata) - ((unsigned long)&_etext)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | datapages = PAGE_ALIGN(datapages) >> PAGE_SHIFT; |
| 455 | initpages = (((unsigned long) &__init_end) - ((unsigned long) &__init_begin)); |
| 456 | initpages = PAGE_ALIGN(initpages) >> PAGE_SHIFT; |
| 457 | |
| 458 | /* Ignore memory holes for the purpose of counting reserved pages */ |
| 459 | for (i=0; i < max_low_pfn; i++) |
| 460 | if (test_bit(i >> (20 - PAGE_SHIFT), sparc_valid_addr_bitmap) |
| 461 | && PageReserved(pfn_to_page(i))) |
| 462 | reservedpages++; |
| 463 | |
| 464 | printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data, %dk init, %ldk highmem)\n", |
| 465 | (unsigned long) nr_free_pages() << (PAGE_SHIFT-10), |
| 466 | num_physpages << (PAGE_SHIFT - 10), |
| 467 | codepages << (PAGE_SHIFT-10), |
| 468 | reservedpages << (PAGE_SHIFT - 10), |
| 469 | datapages << (PAGE_SHIFT-10), |
| 470 | initpages << (PAGE_SHIFT-10), |
| 471 | totalhigh_pages << (PAGE_SHIFT-10)); |
| 472 | } |
| 473 | |
| 474 | void free_initmem (void) |
| 475 | { |
| 476 | unsigned long addr; |
Sam Ravnborg | 86ed40b | 2008-12-27 00:35:12 -0800 | [diff] [blame^] | 477 | unsigned long freed; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 478 | |
| 479 | addr = (unsigned long)(&__init_begin); |
Sam Ravnborg | 86ed40b | 2008-12-27 00:35:12 -0800 | [diff] [blame^] | 480 | freed = (unsigned long)(&__init_end) - addr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 481 | for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) { |
| 482 | struct page *p; |
| 483 | |
Robert Reif | 1aa0365 | 2008-09-03 16:29:42 -0700 | [diff] [blame] | 484 | memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 485 | p = virt_to_page(addr); |
| 486 | |
| 487 | ClearPageReserved(p); |
Nick Piggin | 7835e98 | 2006-03-22 00:08:40 -0800 | [diff] [blame] | 488 | init_page_count(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 489 | __free_page(p); |
| 490 | totalram_pages++; |
| 491 | num_physpages++; |
| 492 | } |
Sam Ravnborg | 86ed40b | 2008-12-27 00:35:12 -0800 | [diff] [blame^] | 493 | printk(KERN_INFO "Freeing unused kernel memory: %ldk freed\n", |
| 494 | freed >> 10); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | } |
| 496 | |
| 497 | #ifdef CONFIG_BLK_DEV_INITRD |
| 498 | void free_initrd_mem(unsigned long start, unsigned long end) |
| 499 | { |
| 500 | if (start < end) |
Robert Reif | 1aa0365 | 2008-09-03 16:29:42 -0700 | [diff] [blame] | 501 | printk(KERN_INFO "Freeing initrd memory: %ldk freed\n", |
| 502 | (end - start) >> 10); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | for (; start < end; start += PAGE_SIZE) { |
Robert Reif | 1aa0365 | 2008-09-03 16:29:42 -0700 | [diff] [blame] | 504 | struct page *p; |
| 505 | |
| 506 | memset((void *)start, POISON_FREE_INITMEM, PAGE_SIZE); |
| 507 | p = virt_to_page(start); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 508 | |
| 509 | ClearPageReserved(p); |
Nick Piggin | 7835e98 | 2006-03-22 00:08:40 -0800 | [diff] [blame] | 510 | init_page_count(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 511 | __free_page(p); |
Robert Reif | 1aa0365 | 2008-09-03 16:29:42 -0700 | [diff] [blame] | 512 | totalram_pages++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 513 | num_physpages++; |
| 514 | } |
| 515 | } |
| 516 | #endif |
| 517 | |
| 518 | void sparc_flush_page_to_ram(struct page *page) |
| 519 | { |
| 520 | unsigned long vaddr = (unsigned long)page_address(page); |
| 521 | |
| 522 | if (vaddr) |
| 523 | __flush_page_to_ram(vaddr); |
| 524 | } |