562 lines
14 KiB
C
562 lines
14 KiB
C
/* $NetBSD: fdt_machdep.c,v 1.19 2017/12/21 08:28:55 skrll Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2015-2017 Jared McNeill <jmcneill@invisible.ca>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: fdt_machdep.c,v 1.19 2017/12/21 08:28:55 skrll Exp $");
|
|
|
|
#include "opt_machdep.h"
|
|
#include "opt_ddb.h"
|
|
#include "opt_md.h"
|
|
#include "opt_arm_debug.h"
|
|
#include "opt_multiprocessor.h"
|
|
#include "opt_cpuoptions.h"
|
|
|
|
#include "ukbd.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/atomic.h>
|
|
#include <sys/cpu.h>
|
|
#include <sys/device.h>
|
|
#include <sys/exec.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/kmem.h>
|
|
#include <sys/ksyms.h>
|
|
#include <sys/msgbuf.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/reboot.h>
|
|
#include <sys/termios.h>
|
|
#include <sys/extent.h>
|
|
|
|
#include <uvm/uvm_extern.h>
|
|
|
|
#include <sys/conf.h>
|
|
|
|
#include <machine/db_machdep.h>
|
|
#include <ddb/db_sym.h>
|
|
#include <ddb/db_extern.h>
|
|
|
|
#include <machine/bootconfig.h>
|
|
#include <arm/armreg.h>
|
|
|
|
#include <arm/arm32/machdep.h>
|
|
|
|
#include <evbarm/include/autoconf.h>
|
|
#include <evbarm/fdt/platform.h>
|
|
|
|
#include <arm/fdt/arm_fdtvar.h>
|
|
|
|
#if NUKBD > 0
|
|
#include <dev/usb/ukbdvar.h>
|
|
#endif
|
|
|
|
#ifdef MEMORY_DISK_DYNAMIC
|
|
#include <dev/md.h>
|
|
#endif
|
|
|
|
#ifndef FDT_MAX_BOOT_STRING
|
|
#define FDT_MAX_BOOT_STRING 1024
|
|
#endif
|
|
|
|
BootConfig bootconfig;
|
|
char bootargs[FDT_MAX_BOOT_STRING] = "";
|
|
char *boot_args = NULL;
|
|
u_int uboot_args[4] = { 0 }; /* filled in by xxx_start.S (not in bss) */
|
|
|
|
static char fdt_memory_ext_storage[EXTENT_FIXED_STORAGE_SIZE(DRAM_BLOCKS)];
|
|
static struct extent *fdt_memory_ext;
|
|
|
|
static uint64_t initrd_start, initrd_end;
|
|
|
|
#include <libfdt.h>
|
|
#include <dev/fdt/fdtvar.h>
|
|
#define FDT_BUF_SIZE (128*1024)
|
|
static uint8_t fdt_data[FDT_BUF_SIZE];
|
|
|
|
extern char KERNEL_BASE_phys[];
|
|
#define KERNEL_BASE_PHYS ((paddr_t)KERNEL_BASE_phys)
|
|
|
|
static void fdt_update_stdout_path(void);
|
|
static void fdt_device_register(device_t, void *);
|
|
static void fdt_reset(void);
|
|
static void fdt_powerdown(void);
|
|
|
|
#ifdef VERBOSE_INIT_ARM
|
|
static void
|
|
fdt_putchar(char c)
|
|
{
|
|
const struct arm_platform *plat = arm_fdt_platform();
|
|
if (plat && plat->early_putchar)
|
|
plat->early_putchar(c);
|
|
}
|
|
|
|
static void
|
|
fdt_putstr(const char *s)
|
|
{
|
|
for (const char *p = s; *p; p++)
|
|
fdt_putchar(*p);
|
|
}
|
|
|
|
static void
|
|
fdt_printn(u_int n, int base)
|
|
{
|
|
char *p, buf[(sizeof(u_int) * NBBY / 3) + 1 + 2 /* ALT + SIGN */];
|
|
|
|
p = buf;
|
|
do {
|
|
*p++ = hexdigits[n % base];
|
|
} while (n /= base);
|
|
|
|
do {
|
|
fdt_putchar(*--p);
|
|
} while (p > buf);
|
|
}
|
|
#define DPRINTF(...) printf(__VA_ARGS__)
|
|
#define DPRINT(x) fdt_putstr(x)
|
|
#define DPRINTN(x,b) fdt_printn((x), (b))
|
|
#else
|
|
#define DPRINTF(...)
|
|
#define DPRINT(x)
|
|
#define DPRINTN(x,b)
|
|
#endif
|
|
|
|
/*
|
|
* Get the first physically contiguous region of memory.
|
|
*/
|
|
static void
|
|
fdt_get_memory(uint64_t *paddr, uint64_t *psize)
|
|
{
|
|
const int memory = OF_finddevice("/memory");
|
|
uint64_t cur_addr, cur_size;
|
|
int index;
|
|
|
|
/* Assume the first entry is the start of memory */
|
|
if (fdtbus_get_reg64(memory, 0, paddr, psize) != 0)
|
|
panic("Cannot determine memory size");
|
|
|
|
DPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",
|
|
0, *paddr, *psize);
|
|
|
|
/* If subsequent entries follow the previous one, append them. */
|
|
for (index = 1;
|
|
fdtbus_get_reg64(memory, index, &cur_addr, &cur_size) == 0;
|
|
index++) {
|
|
DPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",
|
|
index, cur_addr, cur_size);
|
|
if (*paddr + *psize == cur_addr)
|
|
*psize += cur_size;
|
|
}
|
|
}
|
|
|
|
void
|
|
fdt_add_reserved_memory_range(uint64_t addr, uint64_t size)
|
|
{
|
|
uint64_t start = trunc_page(addr);
|
|
uint64_t end = round_page(addr + size);
|
|
|
|
int error = extent_free(fdt_memory_ext, start,
|
|
end - start, EX_NOWAIT);
|
|
if (error != 0)
|
|
printf("MEM ERROR: res %llx-%llx failed: %d\n",
|
|
start, end, error);
|
|
else
|
|
DPRINTF("MEM: res %llx-%llx\n", start, end);
|
|
}
|
|
|
|
/*
|
|
* Exclude memory ranges from memory config from the device tree
|
|
*/
|
|
static void
|
|
fdt_add_reserved_memory(uint64_t max_addr)
|
|
{
|
|
uint64_t addr, size;
|
|
int index, error;
|
|
|
|
const int num = fdt_num_mem_rsv(fdtbus_get_data());
|
|
for (index = 0; index <= num; index++) {
|
|
error = fdt_get_mem_rsv(fdtbus_get_data(), index,
|
|
&addr, &size);
|
|
if (error != 0 || size == 0)
|
|
continue;
|
|
if (addr >= max_addr)
|
|
continue;
|
|
if (addr + size > max_addr)
|
|
size = max_addr - addr;
|
|
fdt_add_reserved_memory_range(addr, size);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Define usable memory regions.
|
|
*/
|
|
static void
|
|
fdt_build_bootconfig(uint64_t mem_addr, uint64_t mem_size)
|
|
{
|
|
const int memory = OF_finddevice("/memory");
|
|
const uint64_t max_addr = mem_addr + mem_size;
|
|
BootConfig *bc = &bootconfig;
|
|
struct extent_region *er;
|
|
uint64_t addr, size;
|
|
int index, error;
|
|
|
|
fdt_memory_ext = extent_create("FDT Memory", mem_addr, max_addr,
|
|
fdt_memory_ext_storage, sizeof(fdt_memory_ext_storage), EX_EARLY);
|
|
|
|
for (index = 0;
|
|
fdtbus_get_reg64(memory, index, &addr, &size) == 0;
|
|
index++) {
|
|
if (addr >= max_addr || size == 0)
|
|
continue;
|
|
if (addr + size > max_addr)
|
|
size = max_addr - addr;
|
|
|
|
error = extent_alloc_region(fdt_memory_ext, addr, size,
|
|
EX_NOWAIT);
|
|
if (error != 0)
|
|
printf("MEM ERROR: add %llx-%llx failed: %d\n",
|
|
addr, addr + size, error);
|
|
DPRINTF("MEM: add %llx-%llx\n", addr, addr + size);
|
|
}
|
|
|
|
fdt_add_reserved_memory(max_addr);
|
|
|
|
const uint64_t initrd_size = initrd_end - initrd_start;
|
|
if (initrd_size > 0)
|
|
fdt_add_reserved_memory_range(initrd_start, initrd_size);
|
|
|
|
DPRINTF("Usable memory:\n");
|
|
bc->dramblocks = 0;
|
|
LIST_FOREACH(er, &fdt_memory_ext->ex_regions, er_link) {
|
|
DPRINTF(" %lx - %lx\n", er->er_start, er->er_end);
|
|
bc->dram[bc->dramblocks].address = er->er_start;
|
|
bc->dram[bc->dramblocks].pages =
|
|
(er->er_end - er->er_start) / PAGE_SIZE;
|
|
bc->dramblocks++;
|
|
}
|
|
}
|
|
|
|
static void
|
|
fdt_probe_initrd(uint64_t *pstart, uint64_t *pend)
|
|
{
|
|
*pstart = *pend = 0;
|
|
|
|
#ifdef MEMORY_DISK_DYNAMIC
|
|
const int chosen = OF_finddevice("/chosen");
|
|
if (chosen < 0)
|
|
return;
|
|
|
|
int len;
|
|
const void *start_data = fdtbus_get_prop(chosen,
|
|
"linux,initrd-start", &len);
|
|
const void *end_data = fdtbus_get_prop(chosen,
|
|
"linux,initrd-end", NULL);
|
|
if (start_data == NULL || end_data == NULL)
|
|
return;
|
|
|
|
switch (len) {
|
|
case 4:
|
|
*pstart = be32dec(start_data);
|
|
*pend = be32dec(end_data);
|
|
break;
|
|
case 8:
|
|
*pstart = be64dec(start_data);
|
|
*pend = be64dec(end_data);
|
|
break;
|
|
default:
|
|
printf("Unsupported len %d for /chosen/initrd-start\n", len);
|
|
return;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
fdt_setup_initrd(void)
|
|
{
|
|
#ifdef MEMORY_DISK_DYNAMIC
|
|
const uint64_t initrd_size = initrd_end - initrd_start;
|
|
paddr_t startpa = trunc_page(initrd_start);
|
|
paddr_t endpa = round_page(initrd_end);
|
|
paddr_t pa;
|
|
vaddr_t va;
|
|
void *md_start;
|
|
|
|
if (initrd_size == 0)
|
|
return;
|
|
|
|
va = uvm_km_alloc(kernel_map, initrd_size, 0,
|
|
UVM_KMF_VAONLY | UVM_KMF_NOWAIT);
|
|
if (va == 0) {
|
|
printf("Failed to allocate VA for initrd\n");
|
|
return;
|
|
}
|
|
|
|
md_start = (void *)va;
|
|
|
|
for (pa = startpa; pa < endpa; pa += PAGE_SIZE, va += PAGE_SIZE)
|
|
pmap_kenter_pa(va, pa, VM_PROT_READ|VM_PROT_WRITE, 0);
|
|
pmap_update(pmap_kernel());
|
|
|
|
md_root_setconf(md_start, initrd_size);
|
|
#endif
|
|
}
|
|
|
|
u_int
|
|
initarm(void *arg)
|
|
{
|
|
const struct arm_platform *plat;
|
|
uint64_t memory_addr, memory_size;
|
|
|
|
/* Load FDT */
|
|
const uint8_t *fdt_addr_r = (const uint8_t *)uboot_args[2];
|
|
int error = fdt_check_header(fdt_addr_r);
|
|
if (error == 0) {
|
|
error = fdt_move(fdt_addr_r, fdt_data, sizeof(fdt_data));
|
|
if (error != 0)
|
|
panic("fdt_move failed: %s", fdt_strerror(error));
|
|
fdtbus_set_data(fdt_data);
|
|
} else {
|
|
panic("fdt_check_header failed: %s", fdt_strerror(error));
|
|
}
|
|
|
|
/* Lookup platform specific backend */
|
|
plat = arm_fdt_platform();
|
|
if (plat == NULL)
|
|
panic("Kernel does not support this device");
|
|
|
|
/* Early console may be available, announce ourselves. */
|
|
DPRINT("FDT<");
|
|
DPRINTN((uintptr_t)fdt_addr_r, 16);
|
|
DPRINT(">");
|
|
|
|
const int chosen = OF_finddevice("/chosen");
|
|
if (chosen >= 0)
|
|
OF_getprop(chosen, "bootargs", bootargs, sizeof(bootargs));
|
|
boot_args = bootargs;
|
|
|
|
DPRINT(" devmap");
|
|
pmap_devmap_register(plat->devmap());
|
|
|
|
/* Heads up ... Setup the CPU / MMU / TLB functions. */
|
|
DPRINT(" cpufunc");
|
|
if (set_cpufuncs())
|
|
panic("cpu not recognized!");
|
|
|
|
DPRINT(" bootstrap");
|
|
plat->bootstrap();
|
|
|
|
/*
|
|
* If stdout-path is specified on the command line, override the
|
|
* value in /chosen/stdout-path before initializing console.
|
|
*/
|
|
fdt_update_stdout_path();
|
|
|
|
DPRINT(" consinit");
|
|
consinit();
|
|
|
|
DPRINTF(" ok\n");
|
|
|
|
DPRINTF("uboot: args %#x, %#x, %#x, %#x\n",
|
|
uboot_args[0], uboot_args[1], uboot_args[2], uboot_args[3]);
|
|
|
|
cpu_reset_address = fdt_reset;
|
|
cpu_powerdown_address = fdt_powerdown;
|
|
evbarm_device_register = fdt_device_register;
|
|
|
|
/* Talk to the user */
|
|
DPRINTF("\nNetBSD/evbarm (fdt) booting ...\n");
|
|
|
|
#ifdef BOOT_ARGS
|
|
char mi_bootargs[] = BOOT_ARGS;
|
|
parse_mi_bootargs(mi_bootargs);
|
|
#endif
|
|
|
|
DPRINTF("KERNEL_BASE=0x%x, "
|
|
"KERNEL_VM_BASE=0x%x, "
|
|
"KERNEL_VM_BASE - KERNEL_BASE=0x%x, "
|
|
"KERNEL_BASE_VOFFSET=0x%x\n",
|
|
KERNEL_BASE,
|
|
KERNEL_VM_BASE,
|
|
KERNEL_VM_BASE - KERNEL_BASE,
|
|
KERNEL_BASE_VOFFSET);
|
|
|
|
fdt_get_memory(&memory_addr, &memory_size);
|
|
|
|
#if !defined(_LP64)
|
|
/* Cannot map memory above 4GB */
|
|
if (memory_addr + memory_size >= 0x100000000)
|
|
memory_size = 0x100000000 - memory_addr - PAGE_SIZE;
|
|
#endif
|
|
|
|
#ifdef __HAVE_MM_MD_DIRECT_MAPPED_PHYS
|
|
const bool mapallmem_p = true;
|
|
#ifndef PMAP_NEED_ALLOC_POOLPAGE
|
|
if (memory_size > KERNEL_VM_BASE - KERNEL_BASE) {
|
|
DPRINTF("%s: dropping RAM size from %luMB to %uMB\n",
|
|
__func__, (unsigned long) (memory_size >> 20),
|
|
(KERNEL_VM_BASE - KERNEL_BASE) >> 20);
|
|
memory_size = KERNEL_VM_BASE - KERNEL_BASE;
|
|
}
|
|
#endif
|
|
#else
|
|
const bool mapallmem_p = false;
|
|
#endif
|
|
|
|
/* Parse ramdisk info */
|
|
fdt_probe_initrd(&initrd_start, &initrd_end);
|
|
|
|
/*
|
|
* Populate bootconfig structure for the benefit of
|
|
* dodumpsys
|
|
*/
|
|
fdt_build_bootconfig(memory_addr, memory_size);
|
|
|
|
arm32_bootmem_init(memory_addr, memory_size, KERNEL_BASE_PHYS);
|
|
arm32_kernel_vm_init(KERNEL_VM_BASE, ARM_VECTORS_HIGH, 0,
|
|
plat->devmap(), mapallmem_p);
|
|
|
|
DPRINTF("bootargs: %s\n", bootargs);
|
|
|
|
parse_mi_bootargs(boot_args);
|
|
|
|
#define MAX_PHYSMEM 16
|
|
static struct boot_physmem fdt_physmem[MAX_PHYSMEM];
|
|
int nfdt_physmem = 0;
|
|
struct extent_region *er;
|
|
|
|
LIST_FOREACH(er, &fdt_memory_ext->ex_regions, er_link) {
|
|
DPRINTF(" %lx - %lx\n", er->er_start, er->er_end);
|
|
struct boot_physmem *bp = &fdt_physmem[nfdt_physmem++];
|
|
|
|
KASSERT(nfdt_physmem <= MAX_PHYSMEM);
|
|
bp->bp_start = atop(er->er_start);
|
|
bp->bp_pages = atop(er->er_end - er->er_start);
|
|
bp->bp_freelist = VM_FREELIST_DEFAULT;
|
|
|
|
#ifdef PMAP_NEED_ALLOC_POOLPAGE
|
|
if (atop(memory_size) > bp->bp_pages) {
|
|
arm_poolpage_vmfreelist = VM_FREELIST_DIRECTMAP;
|
|
bp->bp_freelist = VM_FREELIST_DIRECTMAP;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem,
|
|
nfdt_physmem);
|
|
}
|
|
|
|
static void
|
|
fdt_update_stdout_path(void)
|
|
{
|
|
char *stdout_path, *ep;
|
|
int stdout_path_len;
|
|
char buf[256];
|
|
|
|
const int chosen_off = fdt_path_offset(fdt_data, "/chosen");
|
|
if (chosen_off == -1)
|
|
return;
|
|
|
|
if (get_bootconf_option(boot_args, "stdout-path",
|
|
BOOTOPT_TYPE_STRING, &stdout_path) == 0)
|
|
return;
|
|
|
|
ep = strchr(stdout_path, ' ');
|
|
stdout_path_len = ep ? (ep - stdout_path) : strlen(stdout_path);
|
|
if (stdout_path_len >= sizeof(buf))
|
|
return;
|
|
|
|
strncpy(buf, stdout_path, stdout_path_len);
|
|
buf[stdout_path_len] = '\0';
|
|
fdt_setprop(fdt_data, chosen_off, "stdout-path",
|
|
buf, stdout_path_len + 1);
|
|
}
|
|
|
|
void
|
|
consinit(void)
|
|
{
|
|
static bool initialized = false;
|
|
const struct arm_platform *plat = arm_fdt_platform();
|
|
const struct fdt_console *cons = fdtbus_get_console();
|
|
struct fdt_attach_args faa;
|
|
u_int uart_freq = 0;
|
|
|
|
if (initialized || cons == NULL)
|
|
return;
|
|
|
|
plat->init_attach_args(&faa);
|
|
faa.faa_phandle = fdtbus_get_stdout_phandle();
|
|
|
|
if (plat->uart_freq != NULL)
|
|
uart_freq = plat->uart_freq();
|
|
|
|
cons->consinit(&faa, uart_freq);
|
|
|
|
#if NUKBD > 0
|
|
ukbd_cnattach(); /* allow USB keyboard to become console */
|
|
#endif
|
|
|
|
initialized = true;
|
|
}
|
|
|
|
void
|
|
delay(u_int us)
|
|
{
|
|
const struct arm_platform *plat = arm_fdt_platform();
|
|
|
|
plat->delay(us);
|
|
}
|
|
|
|
static void
|
|
fdt_device_register(device_t self, void *aux)
|
|
{
|
|
const struct arm_platform *plat = arm_fdt_platform();
|
|
|
|
if (device_is_a(self, "armfdt"))
|
|
fdt_setup_initrd();
|
|
|
|
if (plat && plat->device_register)
|
|
plat->device_register(self, aux);
|
|
}
|
|
|
|
static void
|
|
fdt_reset(void)
|
|
{
|
|
const struct arm_platform *plat = arm_fdt_platform();
|
|
|
|
fdtbus_power_reset();
|
|
|
|
if (plat && plat->reset)
|
|
plat->reset();
|
|
}
|
|
|
|
static void
|
|
fdt_powerdown(void)
|
|
{
|
|
fdtbus_power_poweroff();
|
|
}
|