Annotation of src/sys/arch/evbarm/fdt/fdt_machdep.c, Revision 1.4.2.2
1.4.2.2 ! snj 1: /* $NetBSD: fdt_machdep.c,v 1.4.2.1 2017/06/06 16:26:53 snj Exp $ */
1.1 jmcneill 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>
1.4.2.2 ! snj 30: __KERNEL_RCSID(0, "$NetBSD: fdt_machdep.c,v 1.4.2.1 2017/06/06 16:26:53 snj Exp $");
1.1 jmcneill 31:
32: #include "opt_machdep.h"
33: #include "opt_ddb.h"
34: #include "opt_md.h"
35: #include "opt_arm_debug.h"
36: #include "opt_multiprocessor.h"
37: #include "opt_cpuoptions.h"
38:
39: #include <sys/param.h>
40: #include <sys/systm.h>
41: #include <sys/bus.h>
42: #include <sys/atomic.h>
43: #include <sys/cpu.h>
44: #include <sys/device.h>
45: #include <sys/exec.h>
46: #include <sys/kernel.h>
47: #include <sys/kmem.h>
48: #include <sys/ksyms.h>
49: #include <sys/msgbuf.h>
50: #include <sys/proc.h>
51: #include <sys/reboot.h>
52: #include <sys/termios.h>
53:
54: #include <uvm/uvm_extern.h>
55:
56: #include <sys/conf.h>
57:
58: #include <machine/db_machdep.h>
59: #include <ddb/db_sym.h>
60: #include <ddb/db_extern.h>
61:
62: #include <machine/bootconfig.h>
63: #include <arm/armreg.h>
64: #include <arm/undefined.h>
65:
66: #include <arm/arm32/machdep.h>
67:
68: #include <evbarm/include/autoconf.h>
69: #include <evbarm/fdt/platform.h>
70:
71: #include <arm/fdt/arm_fdtvar.h>
72:
73: #ifndef FDT_MAX_BOOT_STRING
74: #define FDT_MAX_BOOT_STRING 1024
75: #endif
76:
77: BootConfig bootconfig;
78: char bootargs[FDT_MAX_BOOT_STRING] = "";
79: char *boot_args = NULL;
80: u_int uboot_args[4] = { 0 }; /* filled in by xxx_start.S (not in bss) */
81:
82: #include <libfdt.h>
83: #include <dev/fdt/fdtvar.h>
84: #define FDT_BUF_SIZE (128*1024)
85: static uint8_t fdt_data[FDT_BUF_SIZE];
86:
87: extern char KERNEL_BASE_phys[];
88: #define KERNEL_BASE_PHYS ((paddr_t)KERNEL_BASE_phys)
89:
1.4.2.1 snj 90: static void fdt_update_stdout_path(void);
1.1 jmcneill 91: static void fdt_device_register(device_t, void *);
92: static void fdt_reset(void);
93: static void fdt_powerdown(void);
94:
95: #ifdef PMAP_NEED_ALLOC_POOLPAGE
96: static struct boot_physmem bp_lowgig = {
97: .bp_pages = (KERNEL_VM_BASE - KERNEL_BASE) / NBPG,
98: .bp_freelist = VM_FREELIST_ISADMA,
99: .bp_flags = 0
100: };
101: #endif
102:
103: #ifdef VERBOSE_INIT_ARM
104: static void
105: fdt_putchar(char c)
106: {
107: const struct arm_platform *plat = arm_fdt_platform();
1.2 jmcneill 108: if (plat && plat->early_putchar)
1.1 jmcneill 109: plat->early_putchar(c);
110: }
111:
112: static void
113: fdt_putstr(const char *s)
114: {
115: for (const char *p = s; *p; p++)
116: fdt_putchar(*p);
117: }
118:
119: static void
120: fdt_printn(u_int n, int base)
121: {
122: char *p, buf[(sizeof(u_int) * NBBY / 3) + 1 + 2 /* ALT + SIGN */];
123:
124: p = buf;
125: do {
126: *p++ = hexdigits[n % base];
127: } while (n /= base);
128:
129: do {
130: fdt_putchar(*--p);
131: } while (p > buf);
132: }
133: #define DPRINTF(...) printf(__VA_ARGS__)
134: #define DPRINT(x) fdt_putstr(x)
135: #define DPRINTN(x,b) fdt_printn((x), (b))
136: #else
137: #define DPRINTF(...)
138: #define DPRINT(x)
139: #define DPRINTN(x,b)
140: #endif
141:
1.4.2.2 ! snj 142: /*
! 143: * Get the first physically contiguous region of memory.
! 144: */
! 145: static void
! 146: fdt_get_memory(uint64_t *paddr, uint64_t *psize)
! 147: {
! 148: const int memory = OF_finddevice("/memory");
! 149: uint64_t cur_addr, cur_size;
! 150: int index;
! 151:
! 152: /* Assume the first entry is the start of memory */
! 153: if (fdtbus_get_reg64(memory, 0, paddr, psize) != 0)
! 154: panic("Cannot determine memory size");
! 155:
! 156: DPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",
! 157: 0, *paddr, *psize);
! 158:
! 159: /* If subsequent entries follow the previous one, append them. */
! 160: for (index = 1;
! 161: fdtbus_get_reg64(memory, index, &cur_addr, &cur_size) == 0;
! 162: index++) {
! 163: DPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n",
! 164: index, cur_addr, cur_size);
! 165: if (*paddr + *psize == cur_addr)
! 166: *psize += cur_size;
! 167: }
! 168: }
! 169:
1.1 jmcneill 170: u_int
171: initarm(void *arg)
172: {
173: const struct arm_platform *plat;
174: uint64_t memory_addr, memory_size;
175: psize_t ram_size = 0;
176:
177: /* Load FDT */
178: const uint8_t *fdt_addr_r = (const uint8_t *)uboot_args[2];
179: int error = fdt_check_header(fdt_addr_r);
180: if (error == 0) {
181: error = fdt_move(fdt_addr_r, fdt_data, sizeof(fdt_data));
182: if (error != 0)
183: panic("fdt_move failed: %s", fdt_strerror(error));
184: fdtbus_set_data(fdt_data);
185: } else {
186: panic("fdt_check_header failed: %s", fdt_strerror(error));
187: }
188:
189: /* Lookup platform specific backend */
190: plat = arm_fdt_platform();
191: if (plat == NULL)
192: panic("Kernel does not support this device");
193:
194: /* Early console may be available, announce ourselves. */
1.2 jmcneill 195: DPRINT("FDT<");
196: DPRINTN((uintptr_t)fdt_addr_r, 16);
197: DPRINT(">");
1.1 jmcneill 198:
1.4.2.1 snj 199: const int chosen = OF_finddevice("/chosen");
200: if (chosen >= 0)
201: OF_getprop(chosen, "bootargs", bootargs, sizeof(bootargs));
202: boot_args = bootargs;
203:
1.1 jmcneill 204: DPRINT(" devmap");
205: pmap_devmap_register(plat->devmap());
206:
207: DPRINT(" bootstrap");
208: plat->bootstrap();
209:
210: /* Heads up ... Setup the CPU / MMU / TLB functions. */
211: DPRINT(" cpufunc");
212: if (set_cpufuncs())
213: panic("cpu not recognized!");
214:
1.4.2.1 snj 215: /*
216: * If stdout-path is specified on the command line, override the
217: * value in /chosen/stdout-path before initializing console.
218: */
219: fdt_update_stdout_path();
220:
1.1 jmcneill 221: DPRINT(" consinit");
222: consinit();
223:
224: DPRINTF(" ok\n");
225:
226: DPRINTF("uboot: args %#x, %#x, %#x, %#x\n",
227: uboot_args[0], uboot_args[1], uboot_args[2], uboot_args[3]);
228:
229: cpu_reset_address = fdt_reset;
230: cpu_powerdown_address = fdt_powerdown;
231: evbarm_device_register = fdt_device_register;
232:
233: /* Talk to the user */
234: DPRINTF("\nNetBSD/evbarm (fdt) booting ...\n");
235:
236: #ifdef BOOT_ARGS
237: char mi_bootargs[] = BOOT_ARGS;
238: parse_mi_bootargs(mi_bootargs);
239: #endif
240:
241: DPRINTF("KERNEL_BASE=0x%x, "
242: "KERNEL_VM_BASE=0x%x, "
243: "KERNEL_VM_BASE - KERNEL_BASE=0x%x, "
244: "KERNEL_BASE_VOFFSET=0x%x\n",
245: KERNEL_BASE,
246: KERNEL_VM_BASE,
247: KERNEL_VM_BASE - KERNEL_BASE,
248: KERNEL_BASE_VOFFSET);
249:
1.4.2.2 ! snj 250: fdt_get_memory(&memory_addr, &memory_size);
1.1 jmcneill 251:
252: #if !defined(_LP64)
253: /* Cannot map memory above 4GB */
254: if (memory_addr + memory_size > 0x100000000)
255: memory_size = 0x100000000 - memory_addr;
256: #endif
257:
258: ram_size = (bus_size_t)memory_size;
259:
260: #ifdef __HAVE_MM_MD_DIRECT_MAPPED_PHYS
261: const bool mapallmem_p = true;
262: #ifndef PMAP_NEED_ALLOC_POOLPAGE
263: if (ram_size > KERNEL_VM_BASE - KERNEL_BASE) {
264: DPRINTF("%s: dropping RAM size from %luMB to %uMB\n",
265: __func__, (unsigned long) (ram_size >> 20),
266: (KERNEL_VM_BASE - KERNEL_BASE) >> 20);
267: ram_size = KERNEL_VM_BASE - KERNEL_BASE;
268: }
269: #endif
270: #else
271: const bool mapallmem_p = false;
272: #endif
273:
274: /* Fake bootconfig structure for the benefit of pmap.c. */
275: bootconfig.dramblocks = 1;
276: bootconfig.dram[0].address = (bus_addr_t)memory_addr;
277: bootconfig.dram[0].pages = ram_size / PAGE_SIZE;
278:
279: arm32_bootmem_init(bootconfig.dram[0].address, ram_size,
280: KERNEL_BASE_PHYS);
281: arm32_kernel_vm_init(KERNEL_VM_BASE, ARM_VECTORS_HIGH, 0,
282: plat->devmap(), mapallmem_p);
283:
284: DPRINTF("bootargs: %s\n", bootargs);
285:
286: parse_mi_bootargs(boot_args);
287:
288: #ifdef PMAP_NEED_ALLOC_POOLPAGE
289: bp_lowgig.bp_start = memory_addr / NBPG;
290: if (atop(ram_size) > bp_lowgig.bp_pages) {
291: arm_poolpage_vmfreelist = bp_lowgig.bp_freelist;
292: return initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE,
293: &bp_lowgig, 1);
294: }
295: #endif
296:
297: return initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, NULL, 0);
298:
299: }
300:
1.4.2.1 snj 301: static void
302: fdt_update_stdout_path(void)
303: {
304: char *stdout_path, *ep;
305: int stdout_path_len;
306: char buf[256];
307:
308: const int chosen_off = fdt_path_offset(fdt_data, "/chosen");
309: if (chosen_off == -1)
310: return;
311:
312: if (get_bootconf_option(boot_args, "stdout-path",
313: BOOTOPT_TYPE_STRING, &stdout_path) == 0)
314: return;
315:
316: ep = strchr(stdout_path, ' ');
317: stdout_path_len = ep ? (ep - stdout_path) : strlen(stdout_path);
318: if (stdout_path_len >= sizeof(buf))
319: return;
320:
321: strncpy(buf, stdout_path, stdout_path_len);
322: buf[stdout_path_len] = '\0';
323: fdt_setprop(fdt_data, chosen_off, "stdout-path",
324: buf, stdout_path_len + 1);
325: }
326:
1.1 jmcneill 327: void
328: consinit(void)
329: {
330: static bool initialized = false;
331: const struct arm_platform *plat = arm_fdt_platform();
332: const struct fdt_console *cons = fdtbus_get_console();
333: struct fdt_attach_args faa;
1.4 jmcneill 334: u_int uart_freq = 0;
1.1 jmcneill 335:
336: if (initialized || cons == NULL)
337: return;
338:
339: plat->init_attach_args(&faa);
340: faa.faa_phandle = fdtbus_get_stdout_phandle();
341:
1.4 jmcneill 342: if (plat->uart_freq != NULL)
343: uart_freq = plat->uart_freq();
344:
345: cons->consinit(&faa, uart_freq);
1.1 jmcneill 346:
347: initialized = true;
348: }
349:
1.3 jmcneill 350: void
351: delay(u_int us)
352: {
353: const struct arm_platform *plat = arm_fdt_platform();
354:
355: plat->delay(us);
356: }
357:
1.1 jmcneill 358: static void
359: fdt_device_register(device_t self, void *aux)
360: {
361: const struct arm_platform *plat = arm_fdt_platform();
362:
363: if (plat && plat->device_register)
364: plat->device_register(self, aux);
365: }
366:
367: static void
368: fdt_reset(void)
369: {
370: const struct arm_platform *plat = arm_fdt_platform();
371:
372: fdtbus_power_reset();
373:
374: if (plat && plat->reset)
375: plat->reset();
376: }
377:
378: static void
379: fdt_powerdown(void)
380: {
381: fdtbus_power_poweroff();
382: }
CVSweb <webmaster@jp.NetBSD.org>