1/* $NetBSD: fdt_machdep.c,v 1.107 2024/01/19 09:09:04 skrll Exp $ */
2
3/*-
4 * Copyright (c) 2015-2017 Jared McNeill <jmcneill@invisible.ca>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__KERNEL_RCSID(0, "$NetBSD: fdt_machdep.c,v 1.107 2024/01/19 09:09:04 skrll Exp $");
31
32#include "opt_arm_debug.h"
33#include "opt_bootconfig.h"
34#include "opt_cpuoptions.h"
35#include "opt_ddb.h"
36#include "opt_efi.h"
37#include "opt_machdep.h"
38#include "opt_multiprocessor.h"
39
40#include "genfb.h"
41#include "ukbd.h"
42#include "wsdisplay.h"
43
44#include <sys/param.h>
45#include <sys/types.h>
46
47#include <sys/atomic.h>
48#include <sys/bootblock.h>
49#include <sys/bus.h>
50#include <sys/conf.h>
51#include <sys/cpu.h>
52#include <sys/device.h>
53#include <sys/disk.h>
54#include <sys/disklabel.h>
55#include <sys/endian.h>
56#include <sys/exec.h>
57#include <sys/fcntl.h>
58#include <sys/kauth.h>
59#include <sys/kernel.h>
60#include <sys/kmem.h>
61#include <sys/ksyms.h>
62#include <sys/md5.h>
63#include <sys/msgbuf.h>
64#include <sys/proc.h>
65#include <sys/pserialize.h>
66#include <sys/reboot.h>
67#include <sys/systm.h>
68#include <sys/termios.h>
69#include <sys/vnode.h>
70#include <sys/uuid.h>
71
72#include <net/if.h>
73#include <net/if_dl.h>
74
75#include <dev/cons.h>
76#include <uvm/uvm_extern.h>
77
78#include <machine/db_machdep.h>
79#include <ddb/db_sym.h>
80#include <ddb/db_extern.h>
81
82#include <machine/bootconfig.h>
83#include <arm/armreg.h>
84
85#include <arm/cpufunc.h>
86
87#include <evbarm/include/autoconf.h>
88#include <evbarm/fdt/machdep.h>
89#include <evbarm/fdt/platform.h>
90
91#include <arm/fdt/arm_fdtvar.h>
92
93#include <dev/fdt/fdtvar.h>
94#include <dev/fdt/fdt_boot.h>
95#include <dev/fdt/fdt_private.h>
96#include <dev/fdt/fdt_memory.h>
97
98#ifdef EFI_RUNTIME
99#include <arm/arm/efi_runtime.h>
100#endif
101
102#if NWSDISPLAY > 0 && NGENFB > 0
103#include <arm/fdt/arm_simplefb.h>
104#endif
105
106#if NUKBD > 0
107#include <dev/usb/ukbdvar.h>
108#endif
109#if NWSDISPLAY > 0
110#include <dev/wscons/wsdisplayvar.h>
111#endif
112
113BootConfig bootconfig;
114char *boot_args = NULL;
115
116/* filled in before cleaning bss. keep in .data */
117u_long uboot_args[4] __attribute__((__section__(".data")));
118const uint8_t *fdt_addr_r __attribute__((__section__(".data")));
119
120#include <libfdt.h>
121#include <dev/fdt/fdtvar.h>
122#define FDT_BUF_SIZE	(512*1024)
123static uint8_t fdt_data[FDT_BUF_SIZE];
124
125extern char KERNEL_BASE_phys[];
126#define KERNEL_BASE_PHYS ((paddr_t)KERNEL_BASE_phys)
127
128static void fdt_device_register(device_t, void *);
129static void fdt_device_register_post_config(device_t, void *);
130static void fdt_reset(void);
131static void fdt_powerdown(void);
132
133#if BYTE_ORDER == BIG_ENDIAN
134static void fdt_update_fb_format(void);
135#endif
136
137static void
138earlyconsputc(dev_t dev, int c)
139{
140	uartputc(c);
141}
142
143static int
144earlyconsgetc(dev_t dev)
145{
146	return -1;
147}
148
149static struct consdev earlycons = {
150	.cn_putc = earlyconsputc,
151	.cn_getc = earlyconsgetc,
152	.cn_pollc = nullcnpollc,
153};
154
155#ifdef VERBOSE_INIT_ARM
156#define VPRINTF(...)	printf(__VA_ARGS__)
157#else
158#define VPRINTF(...)	__nothing
159#endif
160
161static void
162fdt_add_dram_blocks(const struct fdt_memory *m, void *arg)
163{
164	BootConfig *bc = arg;
165
166	VPRINTF("  %" PRIx64 " - %" PRIx64 "\n", m->start, m->end - 1);
167	bc->dram[bc->dramblocks].address = m->start;
168	bc->dram[bc->dramblocks].pages =
169	    (m->end - m->start) / PAGE_SIZE;
170	bc->dramblocks++;
171}
172
173static int nfdt_physmem = 0;
174static struct boot_physmem fdt_physmem[FDT_MEMORY_RANGES];
175
176static void
177fdt_add_boot_physmem(const struct fdt_memory *m, void *arg)
178{
179	const paddr_t saddr = round_page(m->start);
180	const paddr_t eaddr = trunc_page(m->end);
181
182	VPRINTF("  %" PRIx64 " - %" PRIx64, m->start, m->end - 1);
183	if (saddr >= eaddr) {
184		VPRINTF(" skipped\n");
185		return;
186	}
187	VPRINTF("\n");
188
189	struct boot_physmem *bp = &fdt_physmem[nfdt_physmem++];
190
191	KASSERT(nfdt_physmem <= FDT_MEMORY_RANGES);
192
193	bp->bp_start = atop(saddr);
194	bp->bp_pages = atop(eaddr) - bp->bp_start;
195	bp->bp_freelist = VM_FREELIST_DEFAULT;
196
197#ifdef PMAP_NEED_ALLOC_POOLPAGE
198	const uint64_t memory_size = *(uint64_t *)arg;
199	if (atop(memory_size) > bp->bp_pages) {
200		arm_poolpage_vmfreelist = VM_FREELIST_DIRECTMAP;
201		bp->bp_freelist = VM_FREELIST_DIRECTMAP;
202	}
203#endif
204}
205
206
207static void
208fdt_print_memory(const struct fdt_memory *m, void *arg)
209{
210
211	VPRINTF("FDT /memory @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",
212	    m->start, m->end - m->start);
213}
214
215
216/*
217 * Define usable memory regions.
218 */
219static void
220fdt_build_bootconfig(uint64_t mem_start, uint64_t mem_end)
221{
222	BootConfig *bc = &bootconfig;
223
224	uint64_t addr, size;
225	int index;
226
227	/* Reserve pages for ramdisk, rndseed, and firmware's RNG */
228	fdt_reserve_initrd();
229	fdt_reserve_rndseed();
230	fdt_reserve_efirng();
231
232	const int framebuffer = OF_finddevice("/chosen/framebuffer");
233	if (framebuffer >= 0) {
234		for (index = 0;
235		     fdtbus_get_reg64(framebuffer, index, &addr, &size) == 0;
236		     index++) {
237			fdt_memory_remove_range(addr, size);
238		}
239	}
240
241	VPRINTF("Usable memory:\n");
242	bc->dramblocks = 0;
243	fdt_memory_foreach(fdt_add_dram_blocks, bc);
244}
245
246
247vaddr_t
248initarm(void *arg)
249{
250	const struct fdt_platform *plat;
251	uint64_t memory_start, memory_end;
252
253	/* set temporally to work printf()/panic() even before consinit() */
254	cn_tab = &earlycons;
255
256	/* Load FDT */
257	int error = fdt_check_header(fdt_addr_r);
258	if (error != 0)
259		panic("fdt_check_header failed: %s", fdt_strerror(error));
260
261	/* If the DTB is too big, try to pack it in place first. */
262	if (fdt_totalsize(fdt_addr_r) > sizeof(fdt_data))
263		(void)fdt_pack(__UNCONST(fdt_addr_r));
264
265	error = fdt_open_into(fdt_addr_r, fdt_data, sizeof(fdt_data));
266	if (error != 0)
267		panic("fdt_move failed: %s", fdt_strerror(error));
268
269	fdtbus_init(fdt_data);
270
271	/* Lookup platform specific backend */
272	plat = fdt_platform_find();
273	if (plat == NULL)
274		panic("Kernel does not support this device");
275
276	/* Early console may be available, announce ourselves. */
277	VPRINTF("FDT<%p>\n", fdt_addr_r);
278
279	boot_args = fdt_get_bootargs();
280
281	/* Heads up ... Setup the CPU / MMU / TLB functions. */
282	VPRINTF("cpufunc\n");
283	if (set_cpufuncs())
284		panic("cpu not recognized!");
285
286	/*
287	 * Memory is still identity/flat mapped this point so using ttbr for
288	 * l1pt VA is fine
289	 */
290
291	VPRINTF("devmap %p\n", plat->fp_devmap());
292	extern char ARM_BOOTSTRAP_LxPT[];
293	pmap_devmap_bootstrap((vaddr_t)ARM_BOOTSTRAP_LxPT, plat->fp_devmap());
294
295	VPRINTF("bootstrap\n");
296	plat->fp_bootstrap();
297
298	/*
299	 * If stdout-path is specified on the command line, override the
300	 * value in /chosen/stdout-path before initializing console.
301	 */
302	VPRINTF("stdout\n");
303	fdt_update_stdout_path(fdt_data, boot_args);
304
305#if BYTE_ORDER == BIG_ENDIAN
306	/*
307	 * Most boards are configured to little-endian mode initially, and
308	 * switched to big-endian mode after kernel is loaded. In this case,
309	 * framebuffer seems byte-swapped to CPU. Override FDT to let
310	 * drivers know.
311	 */
312	VPRINTF("fb_format\n");
313	fdt_update_fb_format();
314#endif
315
316	/*
317	 * Done making changes to the FDT.
318	 */
319	fdt_pack(fdt_data);
320
321	VPRINTF("consinit ");
322	consinit();
323	VPRINTF("ok\n");
324
325	VPRINTF("uboot: args %#lx, %#lx, %#lx, %#lx\n",
326	    uboot_args[0], uboot_args[1], uboot_args[2], uboot_args[3]);
327
328	cpu_reset_address = fdt_reset;
329	cpu_powerdown_address = fdt_powerdown;
330	evbarm_device_register = fdt_device_register;
331	evbarm_device_register_post_config = fdt_device_register_post_config;
332	evbarm_cpu_rootconf = fdt_cpu_rootconf;
333
334	/* Talk to the user */
335	printf("NetBSD/evbarm (fdt) booting ...\n");
336
337#ifdef BOOT_ARGS
338	char mi_bootargs[] = BOOT_ARGS;
339	parse_mi_bootargs(mi_bootargs);
340#endif
341
342	fdt_memory_get(&memory_start, &memory_end);
343
344	fdt_memory_foreach(fdt_print_memory, NULL);
345
346#if !defined(_LP64)
347	/* Cannot map memory above 4GB (remove last page as well) */
348	const uint64_t memory_limit = 0x100000000ULL - PAGE_SIZE;
349	if (memory_end > memory_limit) {
350		fdt_memory_remove_range(memory_limit , memory_end);
351		memory_end = memory_limit;
352	}
353#endif
354	uint64_t memory_size = memory_end - memory_start;
355
356	VPRINTF("%s: memory start %" PRIx64 " end %" PRIx64 " (len %"
357	    PRIx64 ")\n", __func__, memory_start, memory_end, memory_size);
358
359	/* Parse ramdisk info */
360	fdt_probe_initrd();
361
362	/* Parse our on-disk rndseed and the firmware's RNG from EFI */
363	fdt_probe_rndseed();
364	fdt_probe_efirng();
365
366	fdt_memory_remove_reserved(memory_start, memory_end);
367
368	/*
369	 * Populate bootconfig structure for the benefit of dodumpsys
370	 */
371	VPRINTF("%s: fdt_build_bootconfig\n", __func__);
372	fdt_build_bootconfig(memory_start, memory_end);
373
374	/* Perform PT build and VM init */
375	cpu_kernel_vm_init(memory_start, memory_size);
376
377	VPRINTF("bootargs: %s\n", boot_args);
378
379	parse_mi_bootargs(boot_args);
380
381	VPRINTF("Memory regions:\n");
382
383	/* Populate fdt_physmem / nfdt_physmem for initarm_common */
384	fdt_memory_foreach(fdt_add_boot_physmem, &memory_size);
385
386	vaddr_t sp = initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem,
387	     nfdt_physmem);
388
389	/*
390	 * initarm_common flushes cache if required before AP start
391	 */
392	error = 0;
393	if ((boothowto & RB_MD1) == 0) {
394		VPRINTF("mpstart\n");
395		if (plat->fp_mpstart)
396			error = plat->fp_mpstart();
397	}
398
399	if (error)
400		return sp;
401
402	/*
403	 * Now we have APs started the pages used for stacks and L1PT can
404	 * be given to uvm
405	 */
406	extern char const __start__init_memory[];
407	extern char const __stop__init_memory[] __weak;
408
409	if (&__start__init_memory[0] != &__stop__init_memory[0]) {
410		const paddr_t spa = KERN_VTOPHYS((vaddr_t)__start__init_memory);
411		const paddr_t epa = KERN_VTOPHYS((vaddr_t)__stop__init_memory);
412		const paddr_t spg = atop(spa);
413		const paddr_t epg = atop(epa);
414
415		VPRINTF("         start %08lx  end %08lx... "
416		    "loading in freelist %d\n", spa, epa, VM_FREELIST_DEFAULT);
417
418		uvm_page_physload(spg, epg, spg, epg, VM_FREELIST_DEFAULT);
419	}
420
421	return sp;
422}
423
424void
425consinit(void)
426{
427	static bool initialized = false;
428	const struct fdt_platform *plat = fdt_platform_find();
429	const struct fdt_console *cons = fdtbus_get_console();
430	struct fdt_attach_args faa;
431	u_int uart_freq = 0;
432
433	if (initialized || cons == NULL)
434		return;
435
436	plat->fp_init_attach_args(&faa);
437	faa.faa_phandle = fdtbus_get_stdout_phandle();
438
439	if (plat->fp_uart_freq != NULL)
440		uart_freq = plat->fp_uart_freq();
441
442	cons->consinit(&faa, uart_freq);
443
444	initialized = true;
445}
446
447void
448cpu_startup_hook(void)
449{
450#ifdef EFI_RUNTIME
451	fdt_map_efi_runtime("netbsd,uefi-runtime-code", ARM_EFIRT_MEM_CODE);
452	fdt_map_efi_runtime("netbsd,uefi-runtime-data", ARM_EFIRT_MEM_DATA);
453	fdt_map_efi_runtime("netbsd,uefi-runtime-mmio", ARM_EFIRT_MEM_MMIO);
454#endif
455
456	fdtbus_intr_init();
457
458	fdt_setup_rndseed();
459	fdt_setup_efirng();
460}
461
462void
463delay(u_int us)
464{
465	const struct fdt_platform *plat = fdt_platform_find();
466
467	plat->fp_delay(us);
468}
469static void
470fdt_device_register(device_t self, void *aux)
471{
472	const struct fdt_platform *plat = fdt_platform_find();
473
474	if (device_is_a(self, "armfdt")) {
475		fdt_setup_initrd();
476
477#if NWSDISPLAY > 0 && NGENFB > 0
478		/*
479		 * Setup framebuffer console, if present.
480		 */
481		arm_simplefb_preattach();
482#endif
483	}
484
485#if NWSDISPLAY > 0 && NGENFB > 0
486	if (device_is_a(self, "genfb")) {
487		prop_dictionary_t dict = device_properties(self);
488		prop_dictionary_set_uint64(dict,
489		    "simplefb-physaddr", arm_simplefb_physaddr());
490	}
491#endif
492
493	if (plat && plat->fp_device_register)
494		plat->fp_device_register(self, aux);
495}
496
497static void
498fdt_device_register_post_config(device_t self, void *aux)
499{
500#if NUKBD > 0 && NWSDISPLAY > 0
501	if (device_is_a(self, "wsdisplay")) {
502		struct wsdisplay_softc *sc = device_private(self);
503		if (wsdisplay_isconsole(sc))
504			ukbd_cnattach();
505	}
506#endif
507}
508
509static void
510fdt_reset(void)
511{
512	const struct fdt_platform *plat = fdt_platform_find();
513
514	fdtbus_power_reset();
515
516	if (plat && plat->fp_reset)
517		plat->fp_reset();
518}
519
520static void
521fdt_powerdown(void)
522{
523	fdtbus_power_poweroff();
524}
525
526#if BYTE_ORDER == BIG_ENDIAN
527static void
528fdt_update_fb_format(void)
529{
530	int off, len;
531	const char *format, *replace;
532
533	off = fdt_path_offset(fdt_data, "/chosen");
534	if (off < 0)
535		return;
536
537	for (;;) {
538		off = fdt_node_offset_by_compatible(fdt_data, off,
539		    "simple-framebuffer");
540		if (off < 0)
541			return;
542
543		format = fdt_getprop(fdt_data, off, "format", &len);
544		if (format == NULL)
545			continue;
546
547		replace = NULL;
548		if (strcmp(format, "a8b8g8r8") == 0)
549			replace = "r8g8b8a8";
550		else if (strcmp(format, "x8r8g8b8") == 0)
551			replace = "b8g8r8x8";
552		if (replace != NULL)
553			fdt_setprop(fdt_data, off, "format", replace,
554			    strlen(replace) + 1);
555	}
556}
557#endif
558