Files
LithosAnanke/kernel/src/hal/fdt_uart.c
T
Claude 16b9747d33 chore(license): the source headers name the Starship License 1.0 (SL-1.0), as LICENSE does [skip ci]
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
2026-11-08 17:54:24 +00:00

172 lines
6.6 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
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;
}