src/sys/arch/evbarm/fdt/fdt_machdep.c - diff

Return to fdt_machdep.c CVS log

Up to [cvs.NetBSD.org] / src / sys / arch / evbarm / fdt

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/arch/evbarm/fdt/fdt_machdep.c between version 1.63 and 1.81

version 1.63, 2019/07/15 08:44:33

version 1.81, 2020/11/26 08:37:54

Line 38 __KERNEL_RCSID(0, "$NetBSD$");

#include "opt_cpuoptions.h"

#include "opt_efi.h"

#include "genfb.h"

#include "ukbd.h"

#include "wsdisplay.h"

Line 47 __KERNEL_RCSID(0, "$NetBSD$");

Line 48 __KERNEL_RCSID(0, "$NetBSD$");

#include <sys/atomic.h>

#include <sys/cpu.h>

#include <sys/device.h>

#include <sys/endian.h>

#include <sys/exec.h>

#include <sys/kernel.h>

#include <sys/kmem.h>

Line 64 __KERNEL_RCSID(0, "$NetBSD$");

Line 66 __KERNEL_RCSID(0, "$NetBSD$");

#include <sys/disk.h>

#include <sys/md5.h>

#include <sys/pserialize.h>

#include <sys/rnd.h>

#include <sys/rndsource.h>

#include <net/if.h>

#include <net/if_dl.h>

Line 88 __KERNEL_RCSID(0, "$NetBSD$");

Line 92 __KERNEL_RCSID(0, "$NetBSD$");

#include <evbarm/fdt/fdt_memory.h>

#include <arm/fdt/arm_fdtvar.h>

#include <dev/fdt/fdt_private.h>

#ifdef EFI_RUNTIME

#include <arm/arm/efi_runtime.h>

#endif

#if NWSDISPLAY > 0 && NGENFB > 0

#include <arm/fdt/arm_simplefb.h>

#endif

#if NUKBD > 0

#include <dev/usb/ukbdvar.h>

#endif

Line 117 u_long uboot_args[4] __attribute__((__se

Line 126 u_long uboot_args[4] __attribute__((__se

const uint8_t *fdt_addr_r __attribute__((__section__(".data")));

static uint64_t initrd_start, initrd_end;

static uint64_t rndseed_start, rndseed_end; /* our on-disk seed */

static uint64_t efirng_start, efirng_end; /* firmware's EFI RNG output */

#include <libfdt.h>

#include <dev/fdt/fdtvar.h>

Line 133 static void fdt_cpu_rootconf(void);

Line 144 static void fdt_cpu_rootconf(void);

static void fdt_reset(void);

static void fdt_powerdown(void);

#if BYTE_ORDER == BIG_ENDIAN

static void fdt_update_fb_format(void);

#endif

static void

earlyconsputc(dev_t dev, int c)

{

Line 269 fdt_add_boot_physmem(const struct fdt_me

Line 284 fdt_add_boot_physmem(const struct fdt_me

bp->bp_pages = atop(eaddr) - bp->bp_start;

bp->bp_freelist = VM_FREELIST_DEFAULT;

#ifdef _LP64

if (m->end > 0x100000000)

bp->bp_freelist = VM_FREELIST_HIGHMEM;

#endif

#ifdef PMAP_NEED_ALLOC_POOLPAGE

const uint64_t memory_size = *(uint64_t *)arg;

if (atop(memory_size) > bp->bp_pages) {

Line 307 fdt_build_bootconfig(uint64_t mem_start,

Line 317 fdt_build_bootconfig(uint64_t mem_start,

fdt_add_reserved_memory(mem_start, mem_end);

const uint64_t initrd_size = initrd_end - initrd_start;

const uint64_t initrd_size =

round_page(initrd_end) - trunc_page(initrd_start);

if (initrd_size > 0)

fdt_memory_remove_range(initrd_start, initrd_size);

fdt_memory_remove_range(trunc_page(initrd_start), initrd_size);

const uint64_t rndseed_size =

round_page(rndseed_end) - trunc_page(rndseed_start);

if (rndseed_size > 0)

fdt_memory_remove_range(trunc_page(rndseed_start),

rndseed_size);

const uint64_t efirng_size =

round_page(efirng_end) - trunc_page(efirng_start);

if (efirng_size > 0)

fdt_memory_remove_range(trunc_page(efirng_start), efirng_size);

const int framebuffer = OF_finddevice("/chosen/framebuffer");

if (framebuffer >= 0) {

Line 326 fdt_build_bootconfig(uint64_t mem_start,

Line 348 fdt_build_bootconfig(uint64_t mem_start,

}

static void

fdt_probe_initrd(uint64_t *pstart, uint64_t *pend)

fdt_probe_range(const char *startname, const char *endname,

uint64_t *pstart, uint64_t *pend)

{

int chosen, len;

const void *start_data, *end_data;

*pstart = *pend = 0;

#ifdef MEMORY_DISK_DYNAMIC

chosen = OF_finddevice("/chosen");

const int chosen = OF_finddevice("/chosen");

if (chosen < 0)

return;

int len;

start_data = fdtbus_get_prop(chosen, startname, &len);

const void *start_data = fdtbus_get_prop(chosen,

end_data = fdtbus_get_prop(chosen, endname, NULL);

"linux,initrd-start", &len);

const void *end_data = fdtbus_get_prop(chosen,

"linux,initrd-end", NULL);

if (start_data == NULL || end_data == NULL)

return;

Line 353 fdt_probe_initrd(uint64_t *pstart, uint6

Line 375 fdt_probe_initrd(uint64_t *pstart, uint6

*pend = be64dec(end_data);

break;

default:

printf("Unsupported len %d for /chosen/initrd-start\n", len);

printf("Unsupported len %d for /chosen `%s'\n",

len, startname);

return;

}

#endif

}

static void

static void *

fdt_setup_initrd(void)

fdt_map_range(uint64_t start, uint64_t end, uint64_t *psize,

const char *purpose)

{

#ifdef MEMORY_DISK_DYNAMIC

const paddr_t startpa = trunc_page(start);

const uint64_t initrd_size = initrd_end - initrd_start;

const paddr_t endpa = round_page(end);

paddr_t startpa = trunc_page(initrd_start);

paddr_t endpa = round_page(initrd_end);

paddr_t pa;

vaddr_t va;

void *md_start;

void *ptr;

if (initrd_size == 0)

*psize = end - start;

return;

if (*psize == 0)

return NULL;

va = uvm_km_alloc(kernel_map, initrd_size, 0,

const vaddr_t voff = start & PAGE_MASK;

UVM_KMF_VAONLY | UVM_KMF_NOWAIT);

va = uvm_km_alloc(kernel_map, *psize, 0, UVM_KMF_VAONLY|UVM_KMF_NOWAIT);

if (va == 0) {

printf("Failed to allocate VA for initrd\n");

printf("Failed to allocate VA for %s\n", purpose);

return;

return NULL;

}

ptr = (void *)(va + voff);

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());

return ptr;

}

static void

fdt_unmap_range(void *ptr, uint64_t size)

{

const char *start = ptr, *end = start + size;

const vaddr_t startva = trunc_page((vaddr_t)(uintptr_t)start);

const vaddr_t endva = round_page((vaddr_t)(uintptr_t)end);

pmap_kremove(startva, endva - startva);

pmap_update(pmap_kernel());

}

static void

fdt_probe_initrd(uint64_t *pstart, uint64_t *pend)

{

*pstart = *pend = 0;

#ifdef MEMORY_DISK_DYNAMIC

fdt_probe_range("linux,initrd-start", "linux,initrd-end", pstart, pend);

#endif

}

static void

fdt_setup_initrd(void)

{

#ifdef MEMORY_DISK_DYNAMIC

void *md_start;

uint64_t initrd_size;

md_start = fdt_map_range(initrd_start, initrd_end, &initrd_size,

"initrd");

if (md_start == NULL)

return;

md_root_setconf(md_start, initrd_size);

#endif

}

static void

fdt_probe_rndseed(uint64_t *pstart, uint64_t *pend)

{

fdt_probe_range("netbsd,rndseed-start", "netbsd,rndseed-end",

pstart, pend);

}

static void

fdt_setup_rndseed(void)

{

uint64_t rndseed_size;

void *rndseed;

rndseed = fdt_map_range(rndseed_start, rndseed_end, &rndseed_size,

"rndseed");

if (rndseed == NULL)

return;

rnd_seed(rndseed, rndseed_size);

fdt_unmap_range(rndseed, rndseed_size);

}

static void

fdt_probe_efirng(uint64_t *pstart, uint64_t *pend)

{

fdt_probe_range("netbsd,efirng-start", "netbsd,efirng-end",

pstart, pend);

}

static struct krndsource efirng_source;

static void

fdt_setup_efirng(void)

{

uint64_t efirng_size;

void *efirng;

efirng = fdt_map_range(efirng_start, efirng_end, &efirng_size,

"efirng");

if (efirng == NULL)

return;

rnd_attach_source(&efirng_source, "efirng", RND_TYPE_RNG,

RND_FLAG_DEFAULT);

rnd_add_data(&efirng_source, efirng, efirng_size, 0);

explicit_memset(efirng, 0, efirng_size);

fdt_unmap_range(efirng, efirng_size);

}

#ifdef EFI_RUNTIME

static void

fdt_map_efi_runtime(const char *prop, enum arm_efirt_mem_type type)

Line 416 fdt_map_efi_runtime(const char *prop, en

Line 523 fdt_map_efi_runtime(const char *prop, en

}

#endif

u_int initarm(void *arg);

vaddr_t

u_int

initarm(void *arg)

{

const struct arm_platform *plat;

Line 429 initarm(void *arg)

Line 534 initarm(void *arg)

/* Load FDT */

int error = fdt_check_header(fdt_addr_r);

if (error == 0) {

if (error != 0)

/* If the DTB is too big, try to pack it in place first. */

if (fdt_totalsize(fdt_addr_r) > sizeof(fdt_data))

(void)fdt_pack(__UNCONST(fdt_addr_r));

error = fdt_open_into(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));

}

/* If the DTB is too big, try to pack it in place first. */

if (fdt_totalsize(fdt_addr_r) > sizeof(fdt_data))

(void)fdt_pack(__UNCONST(fdt_addr_r));

error = fdt_open_into(fdt_addr_r, fdt_data, sizeof(fdt_data));

if (error != 0)

panic("fdt_move failed: %s", fdt_strerror(error));

fdtbus_init(fdt_data);

/* Lookup platform specific backend */

plat = arm_fdt_platform();

Line 464 initarm(void *arg)

Line 569 initarm(void *arg)

* l1pt VA is fine

VPRINTF("devmap\n");

VPRINTF("devmap %p\n", plat->ap_devmap());

extern char ARM_BOOTSTRAP_LxPT[];

pmap_devmap_bootstrap((vaddr_t)ARM_BOOTSTRAP_LxPT, plat->ap_devmap());

Line 478 initarm(void *arg)

Line 583 initarm(void *arg)

VPRINTF("stdout\n");

fdt_update_stdout_path();

#if BYTE_ORDER == BIG_ENDIAN

* Most boards are configured to little-endian mode in initial, and

* switched to big-endian mode after kernel is loaded. In this case,

* framebuffer seems byte-swapped to CPU. Override FDT to let

* drivers know.

VPRINTF("fb_format\n");

fdt_update_fb_format();

#endif

* Done making changes to the FDT.

Line 507 initarm(void *arg)

Line 623 initarm(void *arg)

fdt_get_memory(&memory_start, &memory_end);

#if !defined(_LP64)

/* Cannot map memory above 4GB */

/* Cannot map memory above 4GB (remove last page as well) */

if (memory_end >= 0x100000000ULL)

const uint64_t memory_limit = 0x100000000ULL - PAGE_SIZE;

memory_end = 0x100000000ULL - PAGE_SIZE;

if (memory_end > memory_limit)

memory_end = memory_limit;

#endif

uint64_t memory_size = memory_end - memory_start;

Line 520 initarm(void *arg)

Line 636 initarm(void *arg)

/* Parse ramdisk info */

fdt_probe_initrd(&initrd_start, &initrd_end);

/* Parse our on-disk rndseed and the firmware's RNG from EFI */

fdt_probe_rndseed(&rndseed_start, &rndseed_end);

fdt_probe_efirng(&efirng_start, &efirng_end);

* Populate bootconfig structure for the benefit of

* Populate bootconfig structure for the benefit of dodumpsys

* dodumpsys

VPRINTF("%s: fdt_build_bootconfig\n", __func__);

fdt_build_bootconfig(memory_start, memory_end);

Line 543 initarm(void *arg)

Line 662 initarm(void *arg)

VPRINTF("Memory regions:\n");

fdt_memory_foreach(fdt_add_boot_physmem, &memory_size);

u_int sp = initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem,

vaddr_t sp = initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem,

nfdt_physmem);

Line 558 initarm(void *arg)

Line 677 initarm(void *arg)

if (error)

return sp;

* Now we have APs started the pages used for stacks and L1PT can

* be given to uvm

Line 631 consinit(void)

Line 751 consinit(void)

}

void

cpu_startup_hook(void)

{

fdtbus_intr_init();

fdt_setup_rndseed();

fdt_setup_efirng();

}

void

delay(u_int us)

{

const struct arm_platform *plat = arm_fdt_platform();

Line 738 fdt_device_register(device_t self, void

Line 868 fdt_device_register(device_t self, void

{

const struct arm_platform *plat = arm_fdt_platform();

if (device_is_a(self, "armfdt"))

if (device_is_a(self, "armfdt")) {

fdt_setup_initrd();

#if NWSDISPLAY > 0 && NGENFB > 0

* Setup framebuffer console, if present.

arm_simplefb_preattach();

#endif

}

#if NWSDISPLAY > 0 && NGENFB > 0

if (device_is_a(self, "genfb")) {

prop_dictionary_t dict = device_properties(self);

prop_dictionary_set_uint64(dict,

"simplefb-physaddr", arm_simplefb_physaddr());

}

#endif

if (plat && plat->ap_device_register)

plat->ap_device_register(self, aux);

}

Line 793 fdt_powerdown(void)

Line 939 fdt_powerdown(void)

{

fdtbus_power_poweroff();

}

#if BYTE_ORDER == BIG_ENDIAN

static void

fdt_update_fb_format(void)

{

int off, len;

const char *format, *replace;

off = fdt_path_offset(fdt_data, "/chosen");

if (off < 0)

return;

for (;;) {

off = fdt_node_offset_by_compatible(fdt_data, off,

"simple-framebuffer");

if (off < 0)

return;

format = fdt_getprop(fdt_data, off, "format", &len);

if (format == NULL)

continue;

replace = NULL;

if (strcmp(format, "a8b8g8r8") == 0)

replace = "r8g8b8a8";

else if (strcmp(format, "x8r8g8b8") == 0)

replace = "b8g8r8x8";

if (replace != NULL)

fdt_setprop(fdt_data, off, "format", replace,

strlen(replace) + 1);

}

#endif

CVSweb <webmaster@jp.NetBSD.org>