Make syscalls bus runtime setable (#149)

Author: bessman

src/platform/h563xx/platform.c

@@ -198,8 +198,7 @@ void PLATFORM_init(void)
 
     system_clock_config();
 
-    LOG_init();
-    LOG_LL_INFO("Platform hardware initialized");
+    LOG_INFO("Platform hardware initialized");
 }
 
 /**

src/system/README.md

@@ -32,12 +32,8 @@
 #include "util/error.h"
 #include "util/util.h"
 
-#include "syscalls_config.h"
 #include "uart.h"
 
-/* syscalls module sets this when claiming its bus */
-extern bool g_SYSCALLS_uart_claim;
-
 /**
  * @brief UART bus handle structure
  */
@@ -247,14 +243,6 @@ UART_Handle *UART_init(
         THROW(ERROR_INVALID_ARGUMENT);
     }
 
-/* Check if syscalls is claiming the UART */
-#if defined(SYSCALLS_UART_BUS) && SYSCALLS_UART_BUS >= 0
-    if (bus == SYSCALLS_UART_BUS && !g_SYSCALLS_uart_claim) {
-        /* Only syscalls can claim this bus */
-        THROW(ERROR_RESOURCE_UNAVAILABLE);
-    }
-#endif
-
     UART_Bus bus_id = (UART_Bus)bus;
 
     /* Check if bus is already initialized */

src/system/bus/uart.c

@@ -14,23 +14,13 @@
  * - _isatty_r: Terminal check (stub - treats stdout/stderr as terminals,
  *   stdin as not a terminal)
  *
- * The UART bus used for I/O can be configured via the SYSCALLS_UART_BUS
- * preprocessor macro:
- * - Define SYSCALLS_UART_BUS to specify the UART bus number (0, 1, 2, etc.)
- * - Define SYSCALLS_UART_BUS as -1 or leave undefined to disable UART I/O
- *   (functions will be no-ops returning error codes)
- *
- * Buffer size for TX can be configured via:
- * - SYSCALLS_UART_TX_BUFFER_SIZE (default: 256)
+ * Usage:
+ * Call syscalls_init() with an initialized UART_Handle pointer to enable
+ * stdout/stderr output. Until syscalls_init() is called, _write_r will
+ * return EBADF.
  *
  * Note: RX functionality is not implemented as this is designed for
- * write-only logging and debugging output. A minimal 1-byte RX buffer
- * is allocated to satisfy the UART driver requirements, but reads will
- * always return ENOSYS.
- *
- * Example configuration:
- * #define SYSCALLS_UART_BUS 0
- * #define SYSCALLS_UART_TX_BUFFER_SIZE 512
+ * write-only logging and debugging output. Reads will always return ENOSYS.
  */
 
 #include <errno.h>
@@ -39,26 +29,14 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include "util/error.h"
 #include "util/util.h"
 
-#include "syscalls_config.h"
-
-// Only include UART headers if UART I/O is enabled
-#if SYSCALLS_UART_BUS >= 0
+// Include UART headers for handle type
 #include "system/bus/uart.h"
 
-// Minimal RX buffer (required by UART driver)
-#define SYSCALLS_UART_RX_BUFFER_SIZE 1
-
-// Static buffers and handle for UART I/O
+// Static handle for UART I/O
 static UART_Handle *g_uart_handle = nullptr;
-static CircularBuffer g_rx_buffer, g_tx_buffer;
-static uint8_t g_rx_data[SYSCALLS_UART_RX_BUFFER_SIZE];
-static uint8_t g_tx_data[SYSCALLS_UART_TX_BUFFER_SIZE];
-static bool g_uart_initialized = false;
-
-// Set to tell UART driver that syscalls is claiming the UART bus
-bool g_SYSCALLS_uart_claim = false;
 
 static int check_args(struct _reent *r, void const *buf, size_t cnt)
 {
@@ -76,43 +54,37 @@ static int check_args(struct _reent *r, void const *buf, size_t cnt)
 }
 
 /**
- * @brief Initialize UART for syscalls (called automatically on first use)
+ * @brief Initialize syscalls with a UART handle
+ *
+ * @param handle Pointer to an initialized UART handle to use for stdout/stderr
+ * @throws ERROR_RESOURCE_BUSY if syscalls is already initialized
  */
-static void syscalls_uart_init(void)
+void syscalls_init(UART_Handle *handle)
 {
-    if (g_uart_initialized) {
-        return;
+    if (g_uart_handle != nullptr) {
+        THROW(ERROR_RESOURCE_BUSY);
     }
-
-    circular_buffer_init(&g_rx_buffer, g_rx_data, SYSCALLS_UART_RX_BUFFER_SIZE);
-    circular_buffer_init(&g_tx_buffer, g_tx_data, SYSCALLS_UART_TX_BUFFER_SIZE);
-
-    g_SYSCALLS_uart_claim = true; // Claim UART for syscalls
-    g_uart_handle = UART_init(SYSCALLS_UART_BUS, &g_rx_buffer, &g_tx_buffer);
-    g_SYSCALLS_uart_claim = false; // Prevent further claims
-    g_uart_initialized = true;
+    g_uart_handle = handle;
 }
 
 /**
- * @brief Deinitialize UART for syscalls
+ * @brief Deinitialize syscalls
  *
- * @note This function is needed by tests.
+ * Clears the UART handle, disabling stdout/stderr output.
+ *
+ * @param handle Pointer to the UART handle that was used to initialize syscalls
+ * @throws ERROR_INVALID_ARGUMENT if handle doesn't match the initialized handle
  */
-void syscalls_uart_deinit(void)
+void syscalls_deinit(UART_Handle *handle)
 {
-    if (g_uart_handle != nullptr) {
-        UART_deinit(g_uart_handle);
-        g_uart_handle = nullptr;
+    if (g_uart_handle != handle) {
+        THROW(ERROR_INVALID_ARGUMENT);
     }
-    g_uart_initialized = false;
+    g_uart_handle = nullptr;
 }
 
 bool syscalls_uart_flush(uint32_t timeout)
 {
-    if (!g_uart_initialized) {
-        syscalls_uart_init();
-    }
-
     if (g_uart_handle == nullptr) {
         return false;
     }
@@ -121,8 +93,6 @@ bool syscalls_uart_flush(uint32_t timeout)
     return UART_flush(g_uart_handle, timeout);
 }
 
-#endif /* SYSCALLS_UART_BUS >= 0 */
-
 /**
  * @brief Read data from file descriptor (stub - reads not supported)
  *
@@ -163,12 +133,7 @@ _ssize_t _write_r(struct _reent *r, int fd, void const *buf, size_t cnt)
         return ret;
     }
 
-#if SYSCALLS_UART_BUS >= 0
     if (fd == STDOUT_FILENO || fd == STDERR_FILENO) {
-        if (!g_uart_initialized) {
-            syscalls_uart_init();
-        }
-
         if (g_uart_handle == nullptr) {
             r->_errno = EIO;
             return -1;
@@ -186,9 +151,6 @@ _ssize_t _write_r(struct _reent *r, int fd, void const *buf, size_t cnt)
 
         return (_ssize_t)bytes_written;
     }
-#else
-    (void)fd;
-#endif
 
     r->_errno = EBADF;
     return -1;

src/system/syscalls.c

@@ -7,22 +7,43 @@
  * other hardware access.
  */
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "platform/platform.h"
 #include "platform/uart_ll.h"
 #include "util/error.h"
 #include "util/logging.h"
 #include "util/si_prefix.h"
+#include "util/util.h"
 
+#include "bus/uart.h"
 #include "led.h"
-#include "syscalls_config.h"
 #include "system.h"
 
+// Global variables for logging
+static UART_Handle *g_logging_uart_handle = nullptr;
+static uint8_t g_log_buf[1024];
+static uint8_t g_log_rx_buf[1];
+static CircularBuffer g_log_cb;
+static CircularBuffer g_log_rx_cb;
+
 void SYSTEM_init(void)
 {
+    // Initialize logging early to capture any log messages during startup
+    LOG_init();
     PLATFORM_init();
-    // Read any logs that were generated during platform initialization
-    unsigned const max_log_entries = 32;
-    LOG_task(max_log_entries);
+
+    // Set up log output
+    circular_buffer_init(&g_log_cb, g_log_buf, sizeof(g_log_buf));
+    circular_buffer_init(&g_log_rx_cb, g_log_rx_buf, sizeof(g_log_rx_buf));
+    uint8_t log_bus = 2;
+    g_logging_uart_handle = UART_init(log_bus, &g_log_rx_cb, &g_log_cb);
+    extern void syscalls_init(UART_Handle * handle);
+    syscalls_init(g_logging_uart_handle);
+    // Buffered log messages can now be output with LOG_task
+    LOG_task(0xFF);
+
     LED_init();
 }
 
@@ -35,8 +56,7 @@ __attribute__((noreturn)) void SYSTEM_reset(void)
     // Flush any pending log messages
     LOG_task(UINT32_MAX);
     unsigned const bits_per_uart_byte = 10;
-    uint64_t const buffer_size_bits =
-        (uint64_t)SYSCALLS_UART_TX_BUFFER_SIZE * bits_per_uart_byte;
+    size_t const buffer_size_bits = sizeof(g_log_buf) * bits_per_uart_byte;
     // Timeout to wait for TX buffer to empty (2x time for safety)
     uint32_t timeout =
         ((buffer_size_bits * SI_MILLI_DIV * 2) / UART_DEFAULT_BAUDRATE);

src/system/syscalls_config.h

@@ -4,17 +4,26 @@
 /**
  * @file errno.h
  * @brief Test replacement for system errno.h
- * 
+ *
  * This file provides minimal error code definitions for testing.
  */
 
 // Error codes
-#define EBADF   9    // Bad file descriptor
-#define EIO     5    // I/O error
-#define ENOSYS  38   // Function not implemented
-#define EAGAIN  11   // Resource temporarily unavailable
-#define EFAULT  14   // Bad address
-#define ENOTTY  25   // Not a terminal
+#define EBADF       9    // Bad file descriptor
+#define EIO         5    // I/O error
+#define ENOSYS      38   // Function not implemented
+#define EAGAIN      11   // Resource temporarily unavailable
+#define EFAULT      14   // Bad address
+#define ENOTTY      25   // Not a terminal
+#define EINVAL      22   // Invalid argument
+#define ENOMEM      12   // Out of memory
+#define ETIMEDOUT   110  // Connection timed out
+#define EBUSY       16   // Device or resource busy
+#define EDOM        33   // Math argument out of domain
+#define ERANGE      34   // Math result not representable
+#define ENODEV      19   // No such device
+#define ENXIO       6    // No such device or address
+#define EWOULDBLOCK EAGAIN // Operation would block
 
 // Forward errno to our fake reent
 #define errno (__impure_ptr->_errno)