287 lines
6.7 KiB
C
287 lines
6.7 KiB
C
|
// SPDX-License-Identifier: GPL-2.0-only
|
||
|
|
/*
|
||
|
|
* linux/arch/unicore32/mm/init.c
|
||
|
|
*
|
||
|
|
* Copyright (C) 2010 GUAN Xue-tao
|
||
|
|
*/
|
||
|
|
#include <linux/kernel.h>
|
||
|
|
#include <linux/errno.h>
|
||
|
|
#include <linux/swap.h>
|
||
|
|
#include <linux/init.h>
|
||
|
|
#include <linux/memblock.h>
|
||
|
|
#include <linux/mman.h>
|
||
|
|
#include <linux/nodemask.h>
|
||
|
|
#include <linux/initrd.h>
|
||
|
|
#include <linux/highmem.h>
|
||
|
|
#include <linux/gfp.h>
|
||
|
|
#include <linux/sort.h>
|
||
|
|
#include <linux/dma-mapping.h>
|
||
|
|
#include <linux/export.h>
|
||
|
|
|
||
|
|
#include <asm/sections.h>
|
||
|
|
#include <asm/setup.h>
|
||
|
|
#include <linux/sizes.h>
|
||
|
|
#include <asm/tlb.h>
|
||
|
|
#include <asm/memblock.h>
|
||
|
|
#include <mach/map.h>
|
||
|
|
|
||
|
|
#include "mm.h"
|
||
|
|
|
||
|
|
/*
|
||
|
|
* This keeps memory configuration data used by a couple memory
|
||
|
|
* initialization functions, as well as show_mem() for the skipping
|
||
|
|
* of holes in the memory map. It is populated by uc32_add_memory().
|
||
|
|
*/
|
||
|
|
struct meminfo meminfo;
|
||
|
|
|
||
|
|
static void __init find_limits(unsigned long *min, unsigned long *max_low,
|
||
|
|
unsigned long *max_high)
|
||
|
|
{
|
||
|
|
struct meminfo *mi = &meminfo;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
*min = -1UL;
|
||
|
|
*max_low = *max_high = 0;
|
||
|
|
|
||
|
|
for_each_bank(i, mi) {
|
||
|
|
struct membank *bank = &mi->bank[i];
|
||
|
|
unsigned long start, end;
|
||
|
|
|
||
|
|
start = bank_pfn_start(bank);
|
||
|
|
end = bank_pfn_end(bank);
|
||
|
|
|
||
|
|
if (*min > start)
|
||
|
|
*min = start;
|
||
|
|
if (*max_high < end)
|
||
|
|
*max_high = end;
|
||
|
|
if (bank->highmem)
|
||
|
|
continue;
|
||
|
|
if (*max_low < end)
|
||
|
|
*max_low = end;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void __init uc32_bootmem_free(unsigned long min, unsigned long max_low,
|
||
|
|
unsigned long max_high)
|
||
|
|
{
|
||
|
|
unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
|
||
|
|
struct memblock_region *reg;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* initialise the zones.
|
||
|
|
*/
|
||
|
|
memset(zone_size, 0, sizeof(zone_size));
|
||
|
|
|
||
|
|
/*
|
||
|
|
* The memory size has already been determined. If we need
|
||
|
|
* to do anything fancy with the allocation of this memory
|
||
|
|
* to the zones, now is the time to do it.
|
||
|
|
*/
|
||
|
|
zone_size[0] = max_low - min;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Calculate the size of the holes.
|
||
|
|
* holes = node_size - sum(bank_sizes)
|
||
|
|
*/
|
||
|
|
memcpy(zhole_size, zone_size, sizeof(zhole_size));
|
||
|
|
for_each_memblock(memory, reg) {
|
||
|
|
unsigned long start = memblock_region_memory_base_pfn(reg);
|
||
|
|
unsigned long end = memblock_region_memory_end_pfn(reg);
|
||
|
|
|
||
|
|
if (start < max_low) {
|
||
|
|
unsigned long low_end = min(end, max_low);
|
||
|
|
zhole_size[0] -= low_end - start;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Adjust the sizes according to any special requirements for
|
||
|
|
* this machine type.
|
||
|
|
*/
|
||
|
|
arch_adjust_zones(zone_size, zhole_size);
|
||
|
|
|
||
|
|
free_area_init_node(0, zone_size, min, zhole_size);
|
||
|
|
}
|
||
|
|
|
||
|
|
int pfn_valid(unsigned long pfn)
|
||
|
|
{
|
||
|
|
return memblock_is_memory(pfn << PAGE_SHIFT);
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL(pfn_valid);
|
||
|
|
|
||
|
|
static void uc32_memory_present(void)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static int __init meminfo_cmp(const void *_a, const void *_b)
|
||
|
|
{
|
||
|
|
const struct membank *a = _a, *b = _b;
|
||
|
|
long cmp = bank_pfn_start(a) - bank_pfn_start(b);
|
||
|
|
return cmp < 0 ? -1 : cmp > 0 ? 1 : 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void __init uc32_memblock_init(struct meminfo *mi)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
|
||
|
|
sort(&meminfo.bank, meminfo.nr_banks, sizeof(meminfo.bank[0]),
|
||
|
|
meminfo_cmp, NULL);
|
||
|
|
|
||
|
|
for (i = 0; i < mi->nr_banks; i++)
|
||
|
|
memblock_add(mi->bank[i].start, mi->bank[i].size);
|
||
|
|
|
||
|
|
/* Register the kernel text, kernel data and initrd with memblock. */
|
||
|
|
memblock_reserve(__pa(_text), _end - _text);
|
||
|
|
|
||
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
||
|
|
if (!phys_initrd_size) {
|
||
|
|
phys_initrd_start = 0x01000000;
|
||
|
|
phys_initrd_size = SZ_8M;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (phys_initrd_size) {
|
||
|
|
memblock_reserve(phys_initrd_start, phys_initrd_size);
|
||
|
|
|
||
|
|
/* Now convert initrd to virtual addresses */
|
||
|
|
initrd_start = __phys_to_virt(phys_initrd_start);
|
||
|
|
initrd_end = initrd_start + phys_initrd_size;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
uc32_mm_memblock_reserve();
|
||
|
|
|
||
|
|
memblock_allow_resize();
|
||
|
|
memblock_dump_all();
|
||
|
|
}
|
||
|
|
|
||
|
|
void __init bootmem_init(void)
|
||
|
|
{
|
||
|
|
unsigned long min, max_low, max_high;
|
||
|
|
|
||
|
|
max_low = max_high = 0;
|
||
|
|
|
||
|
|
find_limits(&min, &max_low, &max_high);
|
||
|
|
|
||
|
|
node_set_online(0);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Sparsemem tries to allocate bootmem in memory_present(),
|
||
|
|
* so must be done after the fixed reservations
|
||
|
|
*/
|
||
|
|
uc32_memory_present();
|
||
|
|
|
||
|
|
/*
|
||
|
|
* sparse_init() needs the bootmem allocator up and running.
|
||
|
|
*/
|
||
|
|
sparse_init();
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Now free the memory - free_area_init_node needs
|
||
|
|
* the sparse mem_map arrays initialized by sparse_init()
|
||
|
|
* for memmap_init_zone(), otherwise all PFNs are invalid.
|
||
|
|
*/
|
||
|
|
uc32_bootmem_free(min, max_low, max_high);
|
||
|
|
|
||
|
|
high_memory = __va((max_low << PAGE_SHIFT) - 1) + 1;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* This doesn't seem to be used by the Linux memory manager any
|
||
|
|
* more, but is used by ll_rw_block. If we can get rid of it, we
|
||
|
|
* also get rid of some of the stuff above as well.
|
||
|
|
*
|
||
|
|
* Note: max_low_pfn and max_pfn reflect the number of _pages_ in
|
||
|
|
* the system, not the maximum PFN.
|
||
|
|
*/
|
||
|
|
max_low_pfn = max_low - PHYS_PFN_OFFSET;
|
||
|
|
max_pfn = max_high - PHYS_PFN_OFFSET;
|
||
|
|
}
|
||
|
|
|
||
|
|
static inline void
|
||
|
|
free_memmap(unsigned long start_pfn, unsigned long end_pfn)
|
||
|
|
{
|
||
|
|
struct page *start_pg, *end_pg;
|
||
|
|
unsigned long pg, pgend;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Convert start_pfn/end_pfn to a struct page pointer.
|
||
|
|
*/
|
||
|
|
start_pg = pfn_to_page(start_pfn - 1) + 1;
|
||
|
|
end_pg = pfn_to_page(end_pfn);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Convert to physical addresses, and
|
||
|
|
* round start upwards and end downwards.
|
||
|
|
*/
|
||
|
|
pg = PAGE_ALIGN(__pa(start_pg));
|
||
|
|
pgend = __pa(end_pg) & PAGE_MASK;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* If there are free pages between these,
|
||
|
|
* free the section of the memmap array.
|
||
|
|
*/
|
||
|
|
if (pg < pgend)
|
||
|
|
memblock_free(pg, pgend - pg);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* The mem_map array can get very big. Free the unused area of the memory map.
|
||
|
|
*/
|
||
|
|
static void __init free_unused_memmap(struct meminfo *mi)
|
||
|
|
{
|
||
|
|
unsigned long bank_start, prev_bank_end = 0;
|
||
|
|
unsigned int i;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* This relies on each bank being in address order.
|
||
|
|
* The banks are sorted previously in bootmem_init().
|
||
|
|
*/
|
||
|
|
for_each_bank(i, mi) {
|
||
|
|
struct membank *bank = &mi->bank[i];
|
||
|
|
|
||
|
|
bank_start = bank_pfn_start(bank);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* If we had a previous bank, and there is a space
|
||
|
|
* between the current bank and the previous, free it.
|
||
|
|
*/
|
||
|
|
if (prev_bank_end && prev_bank_end < bank_start)
|
||
|
|
free_memmap(prev_bank_end, bank_start);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Align up here since the VM subsystem insists that the
|
||
|
|
* memmap entries are valid from the bank end aligned to
|
||
|
|
* MAX_ORDER_NR_PAGES.
|
||
|
|
*/
|
||
|
|
prev_bank_end = ALIGN(bank_pfn_end(bank), MAX_ORDER_NR_PAGES);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* mem_init() marks the free areas in the mem_map and tells us how much
|
||
|
|
* memory is free. This is done after various parts of the system have
|
||
|
|
* claimed their memory after the kernel image.
|
||
|
|
*/
|
||
|
|
void __init mem_init(void)
|
||
|
|
{
|
||
|
|
max_mapnr = pfn_to_page(max_pfn + PHYS_PFN_OFFSET) - mem_map;
|
||
|
|
|
||
|
|
free_unused_memmap(&meminfo);
|
||
|
|
|
||
|
|
/* this will put all unused low memory onto the freelists */
|
||
|
|
memblock_free_all();
|
||
|
|
|
||
|
|
mem_init_print_info(NULL);
|
||
|
|
|
||
|
|
BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR);
|
||
|
|
BUG_ON(TASK_SIZE > MODULES_VADDR);
|
||
|
|
|
||
|
|
if (PAGE_SIZE >= 16384 && get_num_physpages() <= 128) {
|
||
|
|
/*
|
||
|
|
* On a machine this small we won't get
|
||
|
|
* anywhere without overcommit, so turn
|
||
|
|
* it on by default.
|
||
|
|
*/
|
||
|
|
sysctl_overcommit_memory = OVERCOMMIT_ALWAYS;
|
||
|
|
}
|
||
|
|
}
|