blob: ee9f8d0ac5b5bcb4620f78436d371b3e59656708 [file] [log] [blame]
/*
* Initialize machine setup information and I/O.
*
* After running setup() unit tests may query how many cpus they have
* (nr_cpus), how much memory they have (PHYS_END - PHYS_OFFSET), may
* use dynamic memory allocation (malloc, etc.), printf, and exit.
* Finally, argc and argv are also ready to be passed to main().
*
* Copyright (C) 2014, Red Hat Inc, Andrew Jones <drjones@redhat.com>
*
* This work is licensed under the terms of the GNU LGPL, version 2.
*/
#include <libcflat.h>
#include <libfdt/libfdt.h>
#include <devicetree.h>
#include <alloc.h>
#include <alloc_phys.h>
#include <alloc_page.h>
#include <argv.h>
#include <asm/thread_info.h>
#include <asm/setup.h>
#include <asm/page.h>
#include <asm/processor.h>
#include <asm/smp.h>
#include "io.h"
#define NR_INITIAL_MEM_REGIONS 16
extern unsigned long stacktop;
char *initrd;
u32 initrd_size;
u64 cpus[NR_CPUS] = { [0 ... NR_CPUS-1] = (u64)~0 };
int nr_cpus;
bool is_secondary_vm;
static struct mem_region __initial_mem_regions[NR_INITIAL_MEM_REGIONS + 1];
struct mem_region *mem_regions = __initial_mem_regions;
phys_addr_t __phys_offset, __phys_end;
u32 dcache_line_size;
int mpidr_to_cpu(uint64_t mpidr)
{
int i;
for (i = 0; i < nr_cpus; ++i)
if (cpus[i] == (mpidr & MPIDR_HWID_BITMASK))
return i;
return -1;
}
static void cpu_set(int fdtnode __unused, u64 regval, void *info __unused)
{
int cpu = nr_cpus++;
assert_msg(cpu < NR_CPUS, "Number cpus exceeds maximum supported (%d).", NR_CPUS);
cpus[cpu] = regval;
set_cpu_present(cpu, true);
}
static void cpu_init(void)
{
int ret;
nr_cpus = 0;
ret = dt_for_each_cpu_node(cpu_set, NULL);
assert(ret == 0);
set_cpu_online(0, true);
/*
* DminLine is log2 of the number of words in the smallest cache line; a
* word is 4 bytes.
*/
dcache_line_size = 1 << (CTR_DMINLINE(get_ctr()) + 2);
}
unsigned int mem_region_get_flags(phys_addr_t paddr)
{
struct mem_region *r;
for (r = mem_regions; r->end; ++r) {
if (paddr >= r->start && paddr < r->end)
return r->flags;
}
return MR_F_UNKNOWN;
}
static void mem_init(phys_addr_t freemem_start)
{
struct dt_pbus_reg regs[NR_INITIAL_MEM_REGIONS];
struct mem_region primary, mem = {
.start = (phys_addr_t)-1,
};
phys_addr_t base, top;
int nr_regs, nr_io = 0, i;
/*
* mach-virt I/O regions:
* - The first 1G (arm/arm64)
* - 512M at 256G (arm64, arm uses highmem=off)
* - 512G at 512G (arm64, arm uses highmem=off)
*/
mem_regions[nr_io++] = (struct mem_region){ 0, (1ul << 30), MR_F_IO };
#ifdef __aarch64__
mem_regions[nr_io++] = (struct mem_region){ (1ul << 38), (1ul << 38) | (1ul << 29), MR_F_IO };
mem_regions[nr_io++] = (struct mem_region){ (1ul << 39), (1ul << 40), MR_F_IO };
#endif
nr_regs = dt_get_memory_params(regs, NR_INITIAL_MEM_REGIONS - nr_io);
assert(nr_regs > 0);
primary = (struct mem_region){ 0 };
for (i = 0; i < nr_regs; ++i) {
struct mem_region *r = &mem_regions[nr_io + i];
r->start = regs[i].addr;
r->end = regs[i].addr + regs[i].size;
/*
* pick the region we're in for our primary region
*/
if (freemem_start >= r->start && freemem_start < r->end) {
r->flags |= MR_F_PRIMARY;
primary = *r;
}
/*
* set the lowest and highest addresses found,
* ignoring potential gaps
*/
if (r->start < mem.start)
mem.start = r->start;
if (r->end > mem.end)
mem.end = r->end;
}
assert(primary.end != 0);
assert(!(mem.start & ~PHYS_MASK) && !((mem.end - 1) & ~PHYS_MASK));
__phys_offset = primary.start; /* PHYS_OFFSET */
__phys_end = primary.end; /* PHYS_END */
phys_alloc_init(freemem_start, primary.end - freemem_start);
phys_alloc_set_minimum_alignment(SMP_CACHE_BYTES);
phys_alloc_get_unused(&base, &top);
base = PAGE_ALIGN(base);
top = top & PAGE_MASK;
assert(sizeof(long) == 8 || !(base >> 32));
if (sizeof(long) != 8 && (top >> 32) != 0)
top = ((uint64_t)1 << 32);
free_pages((void *)(unsigned long)base, top - base);
page_alloc_ops_enable();
}
void setup(const void *fdt)
{
void *freemem = &stacktop;
const char *bootargs, *tmp;
u32 fdt_size;
int ret;
/*
* Before calling mem_init we need to move the fdt and initrd
* to safe locations. We move them to construct the memory
* map illustrated below:
*
* +----------------------+ <-- top of physical memory
* | |
* ~ ~
* | |
* +----------------------+ <-- top of initrd
* | |
* +----------------------+ <-- top of FDT
* | |
* +----------------------+ <-- top of cpu0's stack
* | |
* +----------------------+ <-- top of text/data/bss sections,
* | | see arm/flat.lds
* | |
* +----------------------+ <-- load address
* | |
* +----------------------+
*/
fdt_size = fdt_totalsize(fdt);
ret = fdt_move(fdt, freemem, fdt_size);
assert(ret == 0);
ret = dt_init(freemem);
assert(ret == 0);
freemem += fdt_size;
ret = dt_get_initrd(&tmp, &initrd_size);
assert(ret == 0 || ret == -FDT_ERR_NOTFOUND);
if (ret == 0) {
initrd = freemem;
memmove(initrd, tmp, initrd_size);
freemem += initrd_size;
}
/* call init functions */
mem_init(PAGE_ALIGN((unsigned long)freemem));
cpu_init();
/* Check whether this is running as a secondary VM. */
is_secondary_vm = (fdt_node_offset_by_compatible(fdt, -1,
"linux,dummy-virt") >= 0);
/* cpu_init must be called before thread_info_init */
thread_info_init(current_thread_info(), 0);
/* mem_init must be called before io_init */
if (!is_secondary_vm)
io_init();
/* finish setup */
ret = dt_get_bootargs(&bootargs);
assert(ret == 0 || ret == -FDT_ERR_NOTFOUND);
setup_args_progname(bootargs);
if (initrd) {
/* environ is currently the only file in the initrd */
char *env = malloc(initrd_size);
memcpy(env, initrd, initrd_size);
setup_env(env, initrd_size);
}
}