347 headers said "Licensed under the StarForth License, Version 1.0" -- a shortening (Captain Bob, 2026-11-08: "License file SL I think I shortened accidently"); LICENSE is, and has been since the first commit, the Starship License 1.0 (SL-1.0, SPDX LicenseRef-Starship-1.0). 349 files, 566 occurrences, now "Starship License, Version 1.0 (SL-1.0)". Left as they are, pending a ruling: docs/patent/ (the patent figures), docs/formal/ (the citable volumes) and the generated reports under docs/working/experiments/ (32 files). Comments and license text only: the amd64 kernel builds, every changed script parses. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01GE3SDvQn5EoxdGufk84zz2
172 lines
6.6 KiB
C
172 lines
6.6 KiB
C
/*
|
||
StarForth — Steady-State Virtual Machine Runtime
|
||
Copyright (c) 2023–2025 Robert A. James. All rights reserved.
|
||
Licensed under the Starship License, Version 1.0 (SL-1.0).
|
||
*/
|
||
|
||
/**
|
||
* fdt_uart.c - the console's serial line, as a board's devicetree names it.
|
||
* See fdt_uart.h.
|
||
*
|
||
* The node is reached a component of its path at a time from the root, so
|
||
* that each bus on the way is in hand: a node's "reg" is an address on its
|
||
* parent's bus, and is carried up to the CPU's own addresses through the
|
||
* "ranges" of every bus above it (DT spec 2.3.8). A bus with an empty
|
||
* "ranges" passes addresses on unchanged; one with none at all has no
|
||
* mapping, and the line is not found.
|
||
*/
|
||
#include "starkernel/fdt_uart.h"
|
||
#include "starkernel/fdt.h"
|
||
|
||
#define PATH_DEPTH 8 /* nodes from the root to the UART, the root counted */
|
||
|
||
static uint32_t be32(const unsigned char* b)
|
||
{
|
||
return ((uint32_t)b[0] << 24) | ((uint32_t)b[1] << 16) | ((uint32_t)b[2] << 8) | (uint32_t)b[3];
|
||
}
|
||
|
||
/* a property that is one cell, or `otherwise` */
|
||
static uint32_t cell_prop(const void* fdt, const void* node, const char* name, uint32_t otherwise)
|
||
{
|
||
uint32_t len;
|
||
const void* v = fdt_find_prop_in_node(fdt, node, name, &len);
|
||
return (v && len == 4) ? be32((const unsigned char*)v) : otherwise;
|
||
}
|
||
|
||
/* one or two cells as a number; 0 cells is 0 */
|
||
static uint64_t cells(const unsigned char* p, uint32_t n)
|
||
{
|
||
uint64_t v = 0;
|
||
while (n--) { v = (v << 32) | be32(p); p += 4; }
|
||
return v;
|
||
}
|
||
|
||
/* is `want` one of the strings of a "compatible" list? */
|
||
static int compatible_has(const char* list, uint32_t len, const char* want)
|
||
{
|
||
uint32_t i = 0;
|
||
while (i < len)
|
||
{
|
||
uint32_t j = 0;
|
||
while (i + j < len && list[i + j] && want[j] && list[i + j] == want[j]) j++;
|
||
if (i + j < len && !list[i + j] && !want[j]) return 1;
|
||
while (i < len && list[i]) i++;
|
||
i++;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int fdt_console_uart(const void* fdt, fdt_uart_t* out)
|
||
{
|
||
const void* node[PATH_DEPTH];
|
||
const void* root;
|
||
const char *path, *v;
|
||
uint32_t len, path_len, depth, i, ac, sc;
|
||
uint64_t addr;
|
||
|
||
if (!out) return 0;
|
||
out->kind = FDT_UART_NONE; out->base = 0; out->reg_shift = 0; out->io_width = 1;
|
||
|
||
if (!fdt_complete(fdt)) return 0; /* an absent property means its default: not in half a tree */
|
||
root = fdt_root_node(fdt);
|
||
if (!root) return 0;
|
||
|
||
/* /chosen/stdout-path: a path, or an alias, and then perhaps ":115200n8" */
|
||
path = (const char*)fdt_find_prop_in_node(fdt, fdt_find_child(fdt, root, "chosen", 6), "stdout-path", &len);
|
||
if (!path || len == 0) return 0;
|
||
for (path_len = 0; path_len < len && path[path_len] && path[path_len] != ':'; path_len++) { }
|
||
if (path_len == 0) return 0;
|
||
|
||
if (path[0] != '/')
|
||
{
|
||
char alias[32];
|
||
if (path_len >= sizeof alias) return 0;
|
||
for (i = 0; i < path_len; i++) alias[i] = path[i];
|
||
alias[path_len] = '\0';
|
||
path = (const char*)fdt_find_prop_in_node(fdt, fdt_find_child(fdt, root, "aliases", 7), alias, &len);
|
||
if (!path || len == 0 || path[0] != '/') return 0;
|
||
for (path_len = 0; path_len < len && path[path_len]; path_len++) { }
|
||
}
|
||
|
||
/* down the path, keeping every node on the way */
|
||
node[0] = root;
|
||
depth = 1;
|
||
i = 0;
|
||
while (i < path_len)
|
||
{
|
||
uint32_t from;
|
||
while (i < path_len && path[i] == '/') i++;
|
||
from = i;
|
||
while (i < path_len && path[i] != '/') i++;
|
||
if (i == from) break;
|
||
if (depth == PATH_DEPTH) return 0;
|
||
node[depth] = fdt_find_child(fdt, node[depth - 1], path + from, i - from);
|
||
if (!node[depth]) return 0;
|
||
depth++;
|
||
}
|
||
if (depth < 2) return 0; /* the root is not a UART */
|
||
|
||
v = (const char*)fdt_find_prop_in_node(fdt, node[depth - 1], "status", &len);
|
||
if (v && !compatible_has(v, len, "okay") && !compatible_has(v, len, "ok")) return 0;
|
||
|
||
/* its address on its parent's bus */
|
||
ac = cell_prop(fdt, node[depth - 2], "#address-cells", 2);
|
||
sc = cell_prop(fdt, node[depth - 2], "#size-cells", 1);
|
||
if (ac < 1 || ac > 2 || sc > 2) return 0;
|
||
v = (const char*)fdt_find_prop_in_node(fdt, node[depth - 1], "reg", &len);
|
||
if (!v || len < 4 * (ac + sc)) return 0;
|
||
addr = cells((const unsigned char*)v, ac);
|
||
|
||
/* and up through each bus to the CPU's addresses */
|
||
for (i = depth - 2; i >= 1; i--)
|
||
{
|
||
uint32_t child_ac = cell_prop(fdt, node[i], "#address-cells", 2);
|
||
uint32_t child_sc = cell_prop(fdt, node[i], "#size-cells", 1);
|
||
uint32_t parent_ac = cell_prop(fdt, node[i - 1], "#address-cells", 2);
|
||
uint32_t entry, at;
|
||
int carried = 0;
|
||
|
||
v = (const char*)fdt_find_prop_in_node(fdt, node[i], "ranges", &len);
|
||
if (!v) return 0; /* no mapping to the bus above */
|
||
if (len == 0) continue; /* the same addresses above */
|
||
if (child_ac < 1 || child_ac > 2 || parent_ac < 1 || parent_ac > 2 || child_sc < 1 || child_sc > 2) return 0;
|
||
entry = 4 * (child_ac + parent_ac + child_sc);
|
||
for (at = 0; at + entry <= len; at += entry)
|
||
{
|
||
const unsigned char* e = (const unsigned char*)v + at;
|
||
uint64_t from = cells(e, child_ac);
|
||
uint64_t to = cells(e + 4 * child_ac, parent_ac);
|
||
uint64_t size = cells(e + 4 * (child_ac + parent_ac), child_sc);
|
||
if (addr >= from && addr - from < size) { addr = to + (addr - from); carried = 1; break; }
|
||
}
|
||
if (!carried) return 0;
|
||
}
|
||
|
||
v = (const char*)fdt_find_prop_in_node(fdt, node[depth - 1], "compatible", &len);
|
||
if (!v) return 0;
|
||
if (compatible_has(v, len, "arm,pl011") || compatible_has(v, len, "arm,pl011-axi"))
|
||
{
|
||
/* A PL011's registers are 32-bit words: register n is at n << 2.
|
||
* (0 until 2026-10-14, which put the flag register at +6 instead
|
||
* of +0x18 -- an alignment fault on Device memory, found
|
||
* rehearsing the Pi 5's native path; FABRIC-3.md SXXXIX.) */
|
||
out->reg_shift = 2;
|
||
out->io_width = 4;
|
||
out->base = addr;
|
||
out->kind = FDT_UART_PL011;
|
||
return 1;
|
||
}
|
||
if (compatible_has(v, len, "ns16550a") || compatible_has(v, len, "ns16550") || compatible_has(v, len, "snps,dw-apb-uart"))
|
||
{
|
||
uint32_t shift = cell_prop(fdt, node[depth - 1], "reg-shift", 0);
|
||
uint32_t width = cell_prop(fdt, node[depth - 1], "reg-io-width", 1);
|
||
if (shift > 2 || (width != 1 && width != 4)) return 0;
|
||
out->reg_shift = shift;
|
||
out->io_width = width;
|
||
out->base = addr;
|
||
out->kind = FDT_UART_16550;
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|