ports/cheriot-rtos: Added timeout functionality to UART peripheral.

Signed-off-by: Jacob Trevor <[email protected]>

Author: JakeTrevor

ports/cheriot-rtos/Makefile

@@ -54,7 +54,7 @@ SRC_C = mp_entry.c \
 	machine_spi.c \
 	machine_i2c.c
 
-SRC_CXX = hal/i2c.cpp
+SRC_CXX = hal/i2c.cpp hal/uart.cpp hal/timer.cpp
 
 SRC_QSTR += shared/readline/readline.c shared/runtime/pyexec.c mp_entry.c machine_pin.c machine_spi.c machine_i2c.c
 

ports/cheriot-rtos/hal/timer.cpp

@@ -0,0 +1,6 @@
+#include <platform-timer.hh>
+
+uint64_t get_time() {
+    StandardClint::init();
+    return StandardClint::time();
+}

ports/cheriot-rtos/hal/uart.cpp

@@ -1,6 +1,9 @@
 #include <platform-uart.hh>
 
-#define UART_TX_FIFO_SIZE (32)
+extern uint64_t get_time();
+
+#define CLOCK_FREQ_KHZ (50000)
+#define MS_TO_CLOCK_CYCLES(x) (x * CLOCK_FREQ_KHZ) // clock 50mHz
 
 extern "C" uint8_t uart_get_rx_level(volatile OpenTitanUart<115'200> *block) {
     return (block->fifoStatus >> 16) & 0xff;
@@ -18,12 +21,23 @@ extern "C" bool uart_is_writable(volatile OpenTitanUart<115'200> *block) {
     return block->can_write();
 }
 
-extern "C" uint8_t uart_read(volatile OpenTitanUart<115'200> *block) {
-    return block->blocking_read();
+extern "C" bool uart_read(volatile OpenTitanUart<115'200> *block, uint8_t *out, uint32_t timeout_ms) {
+    uint32_t t_end = get_time() + MS_TO_CLOCK_CYCLES(timeout_ms);
+
+    while (!block->can_read()) {
+        if (get_time() > t_end) {
+            return false;
+        }
+    }
+
+    *out = block->rData;
+    return true;
 }
 
 extern "C" void uart_write(volatile OpenTitanUart<115'200> *block, uint8_t data) {
-    block->blocking_write(data);
+    while (!block->can_write()) {
+    }
+    block->wData = data;
 }
 
 extern "C" void uart_init(volatile OpenTitanUart<115'200> *block, uint32_t baudrate) {

ports/cheriot-rtos/machine_uart.c

@@ -8,16 +8,18 @@ typedef struct OpenTitanUart open_titan_uart_t;
 typedef struct _machine_uart_obj_t {
     mp_obj_base_t base;
     volatile open_titan_uart_t *uart_block;
+    uint32_t timeout_ms;
+    uint32_t char_timeout_ms;
 } machine_uart_obj_t;
 
 
+extern void uart_init(volatile open_titan_uart_t *block, uint32_t baudrate);
 extern uint8_t uart_get_rx_level(volatile open_titan_uart_t *block);
 extern uint8_t uart_get_tx_level(volatile open_titan_uart_t *block);
 extern bool uart_is_readable(volatile open_titan_uart_t *block);
 extern bool uart_is_writable(volatile open_titan_uart_t *block);
-extern uint8_t uart_read(volatile open_titan_uart_t *block);
+extern bool uart_read(volatile open_titan_uart_t *block, uint8_t *out, uint32_t timeout_ms);
 extern void uart_write(volatile open_titan_uart_t *block, uint8_t data);
-extern void uart_init(volatile open_titan_uart_t *block, uint32_t baudrate);
 
 volatile open_titan_uart_t *get_uart_block(uint32_t id) {
     switch (id)
@@ -49,8 +51,8 @@ static void mp_machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args,
         { MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_cts, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_rts, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
-        { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 100} },
+        { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 100} },
         { MP_QSTR_invert, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_flow, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_txbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 32} },
@@ -84,11 +86,6 @@ static void mp_machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args,
         mp_raise_ValueError("rx buffer is 64 bytes long");
     }
 
-    if (args[ARG_timeout].u_int != -1 ||
-        args[ARG_timeout_char].u_int != -1) {
-        mp_raise_NotImplementedError("UART Timeouts not implemented");
-    }
-
     if (args[ARG_invert].u_int != -1) {
         mp_raise_NotImplementedError("UART invert not implemented");
     }
@@ -103,6 +100,9 @@ static void mp_machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args,
         // parity = mp_obj_get_int(args[ARG_parity].u_obj);
     }
 
+    self->timeout_ms = args[ARG_timeout].u_int;
+    self->char_timeout_ms = args[ARG_timeout_char].u_int;
+
     uint32_t baudrate = args[ARG_baudrate].u_int;
     uart_init(self->uart_block, baudrate);
 }
@@ -141,24 +141,34 @@ static bool mp_machine_uart_txdone(machine_uart_obj_t *self) {
 
 static mp_uint_t mp_machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
-
-    uint8_t *dest = buf_in;
+    uint8_t *dest = (uint8_t *)buf_in;
 
     for (size_t i = 0; i < size; i++) {
-        dest[i] = uart_read(self->uart_block);
+        uint32_t timeout = (i == 0? self->timeout_ms:self->char_timeout_ms);
+        if (!uart_read(self->uart_block, &dest[i], timeout)) {
+            for (size_t x = 0; x < size; x++) {
+            }
+            if (i <= 0) {
+                *errcode = MP_EAGAIN;
+                return MP_STREAM_ERROR;
+            } else {
+                return i;
+            }
+        }
+
     }
     return size;
 }
 
 
 static mp_uint_t mp_machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
-
     uint8_t *data = (uint8_t *)buf_in;
 
     for (size_t i = 0; i < size; i++) {
         uart_write(self->uart_block, data[i]);
     }
+
     return size;
 }
 

ports/cheriot-rtos/mpconfigport.h

@@ -11,7 +11,7 @@ enum { SPI_MSB_FIRST, SPI_LSB_FIRST };
 
 // Use the minimal starting configuration (disables all optional features).
 #define MICROPY_CONFIG_ROM_LEVEL \
-    (MICROPY_CONFIG_ROM_LEVEL_CORE_FEATURES) // MINIMUM)
+        (MICROPY_CONFIG_ROM_LEVEL_CORE_FEATURES) // MINIMUM)
 
 // You can disable the built-in MicroPython compiler by setting the following
 // config option to 0.  If you do this then you won't get a REPL prompt, but you
@@ -31,6 +31,8 @@ enum { SPI_MSB_FIRST, SPI_LSB_FIRST };
 #define MICROPY_PY_IO                       (0)
 #define MICROPY_PY_BUILTINS_MEMORYVIEW      (1)
 
+#define MICROPY_STREAMS_NON_BLOCK           (1)
+
 #define MICROPY_LONGINT_IMPL                (MICROPY_LONGINT_IMPL_MPZ)
 
 #define MICROPY_ALLOC_PATH_MAX              (256)
@@ -42,7 +44,8 @@ enum { SPI_MSB_FIRST, SPI_LSB_FIRST };
 #define MICROPY_PY_MACHINE_SPI_MSB          (SPI_MSB_FIRST)
 #define MICROPY_PY_MACHINE_SPI_LSB          (SPI_LSB_FIRST)
 #define MICROPY_PY_MACHINE_I2C              (1)
-
+#define MICROPY_PY_MACHINE_UART             (1)
+#define MICROPY_PY_MACHINE_UART_INCLUDEFILE "ports/cheriot-rtos/machine_uart.c"
 // Use the minimum headroom in the chunk allocator for parse nodes.
 #define MICROPY_ALLOC_PARSE_CHUNK_INIT      (16)