Start working on console

Author: tannewt

main.c

@@ -975,6 +975,8 @@ static int run_repl(safe_mode_t safe_mode) {
 }
 
 #if defined(__ZEPHYR__) && __ZEPHYR__ == 1
+#include <zephyr/console/console.h>
+
 int circuitpython_main(void) {
 #else
 int __attribute__((used)) main(void) {
@@ -997,12 +999,18 @@ int __attribute__((used)) main(void) {
 
     // Start the debug serial
     serial_early_init();
+    console_write(NULL, "serial_early_init\r\n", strlen("serial_early_init\r\n"));
+
     mp_hal_stdout_tx_str(line_clear);
 
     // Wait briefly to give a reset window where we'll enter safe mode after the reset.
     if (get_safe_mode() == SAFE_MODE_NONE) {
+        console_write(NULL, "wait_for_safe_mode_reset\r\n", strlen("wait_for_safe_mode_reset\r\n"));
         set_safe_mode(wait_for_safe_mode_reset());
     }
+    printk("safe_mode: %d\r\n", get_safe_mode());
+
+    console_write(NULL, "stack_init\r\n", strlen("stack_init\r\n"));
 
     stack_init();
 

ports/nordic/common-hal/microcontroller/Pin.c

@@ -34,19 +34,19 @@ static void reset_speaker_enable_pin(void) {
 }
 
 void reset_all_pins(void) {
-    for (size_t i = 0; i < GPIO_COUNT; i++) {
-        claimed_pins[i] = never_reset_pins[i];
-    }
-
-    for (uint32_t pin = 0; pin < NUMBER_OF_PINS; ++pin) {
-        if ((never_reset_pins[nrf_pin_port(pin)] & (1 << nrf_relative_pin_number(pin))) != 0) {
-            continue;
-        }
-        nrf_gpio_cfg_default(pin);
-    }
-
-    // After configuring SWD because it may be shared.
-    reset_speaker_enable_pin();
+    // for (size_t i = 0; i < GPIO_COUNT; i++) {
+    //     claimed_pins[i] = never_reset_pins[i];
+    // }
+
+    // for (uint32_t pin = 0; pin < NUMBER_OF_PINS; ++pin) {
+    //     if ((never_reset_pins[nrf_pin_port(pin)] & (1 << nrf_relative_pin_number(pin))) != 0) {
+    //         continue;
+    //     }
+    //     nrf_gpio_cfg_default(pin);
+    // }
+
+    // // After configuring SWD because it may be shared.
+    // reset_speaker_enable_pin();
 }
 
 // Mark pin as free and return it to a quiescent state.

prj.conf

@@ -1 +1,6 @@
 CONFIG_HEAP_MEM_POOL_SIZE=65536
+CONFIG_CONSOLE_SUBSYS=y
+CONFIG_CONSOLE_GETCHAR=y
+CONFIG_LOG=y
+
+CONFIG_RING_BUFFER=y

supervisor/shared/serial.c

@@ -113,28 +113,28 @@ MP_WEAK void board_serial_write_substring(const char *text, uint32_t length) {
     (void)length;
 }
 
-MP_WEAK void port_serial_early_init(void) {
-}
+// MP_WEAK void port_serial_early_init(void) {
+// }
 
-MP_WEAK void port_serial_init(void) {
-}
+// MP_WEAK void port_serial_init(void) {
+// }
 
-MP_WEAK bool port_serial_connected(void) {
-    return false;
-}
+// MP_WEAK bool port_serial_connected(void) {
+//     return false;
+// }
 
-MP_WEAK char port_serial_read(void) {
-    return -1;
-}
+// MP_WEAK char port_serial_read(void) {
+//     return -1;
+// }
 
-MP_WEAK uint32_t port_serial_bytes_available(void) {
-    return 0;
-}
+// MP_WEAK uint32_t port_serial_bytes_available(void) {
+//     return 0;
+// }
 
-MP_WEAK void port_serial_write_substring(const char *text, uint32_t length) {
-    (void)text;
-    (void)length;
-}
+// MP_WEAK void port_serial_write_substring(const char *text, uint32_t length) {
+//     (void)text;
+//     (void)length;
+// }
 
 void serial_early_init(void) {
     // Set up console UART, if enabled.

supervisor/shared/stack.c

@@ -13,17 +13,24 @@
 #include "supervisor/shared/safe_mode.h"
 
 void stack_init(void) {
+    // Zephyr has a stack canary of its own.
+    #ifndef __ZEPHYR__
     uint32_t *stack_limit = port_stack_get_limit();
     *stack_limit = STACK_CANARY_VALUE;
+    #endif
 }
 
 inline bool stack_ok(void) {
+    #ifndef __ZEPHYR__
     uint32_t *stack_limit = port_stack_get_limit();
     return *stack_limit == STACK_CANARY_VALUE;
+    #endif
 }
 
 inline void assert_heap_ok(void) {
+    #ifndef __ZEPHYR__
     if (!stack_ok()) {
         reset_into_safe_mode(SAFE_MODE_STACK_OVERFLOW);
     }
+    #endif
 }

supervisor/zephyr/port.c

@@ -6,6 +6,7 @@
 
 #include "supervisor/port.h"
 
+#include <zephyr/autoconf.h>
 #include <zephyr/kernel.h>
 
 safe_mode_t port_init(void) {
@@ -39,6 +40,7 @@ void port_heap_init(void) {
 
 // Get stack limit address
 uint32_t *port_stack_get_limit(void) {
+    k_tid_t current_thread_id = k_current_get();
     return NULL;
 }
 
@@ -66,7 +68,14 @@ uint32_t port_get_saved_word(void) {
 }
 
 uint64_t port_get_raw_ticks(uint8_t *subticks) {
-    return 0;
+    #if CONFIG_SYS_CLOCK_TICKS_PER_SEC != 32768
+    #error "This code assumes 32768 Hz system clock"
+    #endif
+    int64_t uptime = k_uptime_ticks();
+    if (subticks != NULL) {
+        *subticks = uptime % 32;
+    }
+    return uptime / 32;
 }
 
 // Enable 1/1024 second tick.

supervisor/zephyr/serial.c

@@ -0,0 +1,81 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
+//
+// SPDX-License-Identifier: MIT
+
+#include "supervisor/shared/serial.h"
+#include "py/ringbuf.h"
+
+#include <zephyr/autoconf.h>
+
+// #if defined(CONFIG_CONSOLE_SUBSYS)
+
+#include <zephyr/console/console.h>
+#include <zephyr/sys/ring_buffer.h>
+
+// init the console ourselves so we can set the timeout to zero.
+static struct tty_serial console_serial;
+
+static uint8_t console_rxbuf[CONFIG_CONSOLE_GETCHAR_BUFSIZE];
+static uint8_t console_txbuf[CONFIG_CONSOLE_PUTCHAR_BUFSIZE];
+
+void port_serial_early_init(void) {
+    const struct device *uart_dev;
+    int ret;
+
+    uart_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_console));
+    if (!device_is_ready(uart_dev)) {
+        return -ENODEV;
+    }
+
+    ret = tty_init(&console_serial, uart_dev);
+
+    if (ret) {
+        return ret;
+    }
+
+    /* Checks device driver supports for interrupt driven data transfers. */
+    if (CONFIG_CONSOLE_GETCHAR_BUFSIZE + CONFIG_CONSOLE_PUTCHAR_BUFSIZE) {
+        const struct uart_driver_api *api =
+            (const struct uart_driver_api *)uart_dev->api;
+        if (!api->irq_callback_set) {
+            return -ENOTSUP;
+        }
+    }
+
+    tty_set_tx_buf(&console_serial, console_txbuf, sizeof(console_txbuf));
+    tty_set_rx_buf(&console_serial, console_rxbuf, sizeof(console_rxbuf));
+
+    printk("port_serial_early_init done");
+}
+
+void port_serial_init(void) {
+}
+
+bool port_serial_connected(void) {
+    return true;
+}
+
+char port_serial_read(void) {
+    char buf[1];
+    ssize_t read = tty_read(&console_serial, buf, 1);
+    if (read == 0) {
+        return -1;
+    }
+    return buf[0];
+}
+
+uint32_t port_serial_bytes_available(void) {
+    _fill_ring_buf();
+    return ring_buf_size_get(&rb);
+}
+
+void port_serial_write_substring(const char *text, uint32_t length) {
+    uint32_t total_written = 0;
+    while (total_written < length) {
+        total_written += tty_write(NULL, text + total_written, length - total_written);
+    }
+}
+
+// #endif

tools/cpbuild/build_circuitpython.py

@@ -296,6 +296,7 @@ async def build_circuitpython():
     # These files don't include unique QSTRs. They just need to be compiled.
     source_files.append(srcdir / "supervisor" / "zephyr" / "flash.c")
     source_files.append(srcdir / "supervisor" / "zephyr" / "port.c")
+    source_files.append(srcdir / "supervisor" / "zephyr" / "serial.c")
     source_files.append(srcdir / "lib" / "oofatfs" / "ff.c")
     source_files.append(srcdir / "lib" / "oofatfs" / "ffunicode.c")
     source_files.append(srcdir / "extmod" / "vfs_fat_diskio.c")