add generic ring buffer lib, used for log buffer and new uart tx buffer. uart as second console option for nicer debugging.

CMakeLists.txt

@@ -61,6 +61,8 @@ target_sources(gadget PUBLIC
     src/image.c
     src/state.c
     src/volcano.c
+    src/serial.c
+    src/ring.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

README.md

@@ -54,12 +54,16 @@ For this you need to compile the `picoprobe` firmware, like this.
 
     git clone https://github.com/raspberrypi/picoprobe.git
     cd picoprobe
+
     git submodule update --init
     mkdir build
     cd build
+
     PICO_SDK_PATH=../../../pico-sdk cmake ..
     make -j4
 
+    cd ../.. # back to build_debug directory from before
+
 And flash the resulting `picoprobe.uf2` to your probe.
 Connect `GP2` of the probe to `SWCLK` of the target and `GP3` of the probe to `SWDIO` of the target.
 Of course you also need to connect GND between both.
@@ -69,8 +73,6 @@ You need some dependencies, mainly `gdb-multiarch` and the RP2040 fork of `OpenO
     sudo apt install gdb-multiarch   # Debian / Ubuntu
     sudo pacman -S arm-none-eabi-gdb # Arch Linux
 
-    cd ../.. # back to build_debug directory from before
-
     git clone https://github.com/raspberrypi/openocd.git --branch rp2040 --recursive --depth=1
     cd openocd
 
@@ -82,6 +84,8 @@ You need some dependencies, mainly `gdb-multiarch` and the RP2040 fork of `OpenO
     ./configure --enable-ftdi --enable-sysfsgpio --enable-bcm2835gpio
     make -j4
 
+    cd .. # back to build_debug directory from before
+
 Now we can flash a firmware image via OpenOCD.
 
     ./openocd/src/openocd -s openocd/tcl -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000" -c "cmsis_dap_vid_pid 0x2e8a 0x000c" -c "program gadget.elf verify reset exit"
@@ -92,6 +96,10 @@ And also start a GDB debugging session.
     arm-none-eabi-gdb gadget.elf
     target extended-remote localhost:3333
 
+    load # program elf into flash
+    monitor reset init # put into clean initial state
+    continue # start program
+
 These commands have also been put in the `flash_swd.sh` and `debug_swd.sh` scripts, respectively.
 Call them from the `build_debug` folder where you checked out and built OpenOCD.
 

debug_swd.sh

@@ -15,7 +15,14 @@ while ! netstat -tna | grep 'LISTEN\>' | grep -q ':3333\>'; do
 done
 
 echo Starting GDB
-arm-none-eabi-gdb -ex "set history save" -ex "show print pretty" -ex "target extended-remote localhost:3333" $1
+arm-none-eabi-gdb \
+-ex "set history save" \
+-ex "show print pretty" \
+-ex "target extended-remote localhost:3333" \
+-ex "tui new-layout default asm 1 src 2 status 0 cmd 1" \
+-ex "tui layout default" \
+-ex "tui enable" \
+$1
 
 echo Killing OpenOCD instance in background
 kill $OPENOCD_PID

include/config.h

@@ -19,6 +19,9 @@
 #ifndef __CONFIG_H__
 #define __CONFIG_H__
 
+// ASCII 0x18 = CAN (cancel)
+#define ENTER_BOOTLOADER_MAGIC 0x18
+
 //#define DISABLE_CDC_DTR_CHECK
 #define DEBOUNCE_DELAY_MS 5
 
@@ -29,7 +32,7 @@
 #ifdef DEBUG_DISK_WRITE_SOURCES
 #define DISK_BLOCK_COUNT (256 + 128)
 #else // DEBUG_DISK_WRITE_SOURCES
-#define DISK_BLOCK_COUNT 128 // 128 is minimum size for fatfs lib
+#define DISK_BLOCK_COUNT 256
 #endif // DEBUG_DISK_WRITE_SOURCES
 
 #endif // __CONFIG_H__

include/log.h

@@ -40,6 +40,7 @@ void debug_wait_input(const char *format, ...) __attribute__((format(printf, 1,
 void debug_log_va(bool log, const char *format, va_list args);
 
 void log_dump_to_usb(void);
+void log_dump_to_uart(void);
 void log_dump_to_disk(void);
 
 void debug_handle_input(char *buff, uint32_t len);

include/ring.h

@@ -0,0 +1,39 @@
+/*
+ * ring.h
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __RING_BUFFER_H__
+#define __RING_BUFFER_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+struct ring_buffer {
+    uint8_t *buffer;
+    size_t size;
+    size_t head, tail;
+    bool full;
+};
+#define RB_INIT(b, s) { .buffer = b, .size = s, .head = 0, .tail = 0, .full = false }
+
+void rb_add(struct ring_buffer *rb, const uint8_t *data, size_t length);
+size_t rb_len(struct ring_buffer *rb);
+void rb_dump(struct ring_buffer *rb, void (*write)(const uint8_t *, size_t));
+uint8_t rb_pop(struct ring_buffer *rb);
+
+#endif // __RING_BUFFER_H__

include/serial.h

@@ -0,0 +1,30 @@
+/*
+ * serial.h
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SERIAL_H__
+#define __SERIAL_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+void serial_init(void);
+void serial_write(const uint8_t *buf, size_t count);
+void serial_set_reroute(bool reroute);
+
+#endif // __SERIAL_H__

include/usb_cdc.h

@@ -19,7 +19,11 @@
 #ifndef __USB_CDC_H__
 #define __USB_CDC_H__
 
-void usb_cdc_write(const char *buf, uint32_t count);
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+void usb_cdc_write(const uint8_t *buf, size_t count);
 void usb_cdc_set_reroute(bool reroute);
 
 #endif // __USB_CDC_H__

src/console.c

@@ -329,12 +329,12 @@ void cnsl_handle_input(const char *buf, uint32_t len) {
                 cnsl_buff_pos -= 1;
             }
 
-            usb_cdc_write("\b \b", 3);
+            usb_cdc_write((const uint8_t *)"\b \b", 3);
 
             // check for another backspace in this space
             i--;
         } else {
-            usb_cdc_write(cnsl_line_buff + i, 1);
+            usb_cdc_write((const uint8_t *)(cnsl_line_buff + i), 1);
         }
     }
 

src/log.c

@@ -24,96 +24,79 @@
 #include "config.h"
 #include "usb.h"
 #include "usb_cdc.h"
+#include "serial.h"
+#include "ring.h"
 #include "log.h"
 
-static char log_buff[4096];
-static char line_buff[512];
-static size_t head = 0, tail = 0;
-static bool full = false;
-static bool got_input = false;
+static uint8_t log_buff[4096] = {0};
+static struct ring_buffer log = RB_INIT(log_buff, sizeof(log_buff));
 
-static void add_to_log(const char *buff, int len) {
-    for (int i = 0; i < len; i++) {
-        log_buff[head] = buff[i];
+static uint8_t line_buff[128] = {0};
+static volatile bool got_input = false;
+static FIL log_file_fat;
 
-        if (full && (++tail == sizeof(log_buff))) {
-            tail = 0;
-        }
-
-        if (++(head) == sizeof(log_buff)) {
-            head = 0;
-        }
-
-        full = (head == tail);
-    }
+static void add_to_log(const uint8_t *buff, size_t len) {
+    rb_add(&log, buff, len);
 }
 
-void log_dump_to_usb(void) {
-    if (head == tail) {
+static void log_dump_to_x(void (*write)(const uint8_t *, size_t)) {
+    if (rb_len(&log) == 0) {
         return;
     }
 
-    char buff[32];
-    int l = snprintf(buff, sizeof(buff), "\r\n\r\nbuffered log output:\r\n");
-    if ((l > 0) && (l <= (int)sizeof(buff))) {
-        usb_cdc_write(buff, l);
+    int l = snprintf((char *)line_buff, sizeof(line_buff), "\r\n\r\nbuffered log output:\r\n");
+    if ((l > 0) && (l <= (int)sizeof(line_buff))) {
+        write(line_buff, l);
     }
 
-    if (head > tail) {
-        usb_cdc_write(log_buff + tail, head - tail);
-    } else {
-        usb_cdc_write(log_buff + tail, sizeof(log_buff) - tail);
-        usb_cdc_write(log_buff, head);
+    rb_dump(&log, write);
+
+    l = snprintf((char *)line_buff, sizeof(line_buff), "\r\n\r\nlive log:\r\n");
+    if ((l > 0) && (l <= (int)sizeof(line_buff))) {
+        write(line_buff, l);
     }
+}
 
-    l = snprintf(buff, sizeof(buff), "\r\n\r\nlive log:\r\n");
-    if ((l > 0) && (l <= (int)sizeof(buff))) {
-        usb_cdc_write(buff, l);
+void log_dump_to_usb(void) {
+    log_dump_to_x(usb_cdc_write);
+}
+
+void log_dump_to_uart(void) {
+    log_dump_to_x(serial_write);
+}
+
+static void log_file_write_callback(const uint8_t *data, size_t len) {
+    UINT bw;
+    FRESULT res = f_write(&log_file_fat, data, len, &bw);
+    if ((res != FR_OK) || (bw != len)) {
+        debug("error: f_write %u returned %d", len, res);
     }
 }
 
 void log_dump_to_disk(void) {
-    FIL file;
-    FRESULT res = f_open(&file, "log.txt", FA_CREATE_ALWAYS | FA_WRITE);
+    FRESULT res = f_open(&log_file_fat, "log.txt", FA_CREATE_ALWAYS | FA_WRITE);
     if (res != FR_OK) {
         debug("error: f_open returned %d", res);
         return;
     }
 
-    UINT bw;
-
-    if (head > tail) {
-        res = f_write(&file, log_buff + tail, head - tail, &bw);
-        if ((res != FR_OK) || (bw != head - tail)) {
-            debug("error: f_write (A) returned %d", res);
-        }
-    } else if (head < tail) {
-        res = f_write(&file, log_buff + tail, sizeof(log_buff) - tail, &bw);
-        if ((res != FR_OK) || (bw != sizeof(log_buff) - tail)) {
-            debug("error: f_write (B) returned %d", res);
-        } else {
-            res = f_write(&file, log_buff, head, &bw);
-            if ((res != FR_OK) || (bw != head)) {
-                debug("error: f_write (C) returned %d", res);
-            }
-        }
-    }
+    rb_dump(&log, log_file_write_callback);
 
-    res = f_close(&file);
+    res = f_close(&log_file_fat);
     if (res != FR_OK) {
         debug("error: f_close returned %d", res);
     }
 }
 
 void debug_log_va(bool log, const char *format, va_list args) {
-    int l = vsnprintf(line_buff, sizeof(line_buff), format, args);
+    int l = vsnprintf((char *)line_buff, sizeof(line_buff), format, args);
 
     if (l < 0) {
         // encoding error
-        l = snprintf(line_buff, sizeof(line_buff), "%s: encoding error\r\n", __func__);
+        l = snprintf((char *)line_buff, sizeof(line_buff), "%s: encoding error\r\n", __func__);
     } else if (l >= (ssize_t)sizeof(line_buff)) {
         // not enough space for string
-        l = snprintf(line_buff, sizeof(line_buff), "%s: message too long (%d)\r\n", __func__, l);
+        l = snprintf((char *)line_buff, sizeof(line_buff), "%s: message too long (%d)\r\n", __func__, l);
     }
     if ((l > 0) && (l <= (int)sizeof(line_buff))) {
         usb_cdc_write(line_buff, l);
@@ -147,6 +130,7 @@ void debug_wait_input(const char *format, ...) {
 
     got_input = false;
     usb_cdc_set_reroute(true);
+    serial_set_reroute(true);
 
     while (!got_input) {
         watchdog_update();
@@ -154,4 +138,5 @@ void debug_wait_input(const char *format, ...) {
     }
 
     usb_cdc_set_reroute(false);
+    serial_set_reroute(false);
 }

src/main.c

@@ -34,10 +34,12 @@
 #include "text.h"
 #include "image.h"
 #include "state.h"
+#include "serial.h"
 
 int main(void) {
     // required for debug console
     cnsl_init();
+    serial_init();
     usb_init();
 
     debug("lcd_init");

src/ring.c

@@ -0,0 +1,76 @@
+/*
+ * ring.c
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "ring.h"
+
+void rb_add(struct ring_buffer *rb, const uint8_t *data, size_t length) {
+    for (size_t i = 0; i < length; i++) {
+        rb->buffer[rb->head] = data[i];
+
+        if (rb->full && (++(rb->tail) == rb->size)) {
+            rb->tail = 0;
+        }
+
+        if (++(rb->head) == rb->size) {
+            rb->head = 0;
+        }
+
+        rb->full = ((rb->head) == (rb->tail));
+    }
+}
+
+size_t rb_len(struct ring_buffer *rb) {
+    if (rb->head == rb->tail) {
+        if (rb->full) {
+            return rb->size;
+        } else {
+            return 0;
+        }
+    } else if (rb->head > rb->tail) {
+        return rb->head - rb->tail;
+    } else {
+        return rb->size - rb->tail + rb->head;
+    }
+}
+
+void rb_dump(struct ring_buffer *rb, void (*write)(const uint8_t *, size_t)) {
+    if (rb_len(rb) == 0) {
+        return;
+    }
+
+    if (rb->head > rb->tail) {
+        write(rb->buffer + rb->tail, rb->head - rb->tail);
+    } else {
+        write(rb->buffer + rb->tail, rb->size - rb->tail);
+        write(rb->buffer, rb->head);
+    }
+}
+
+uint8_t rb_pop(struct ring_buffer *rb) {
+    if (rb_len(rb) == 0) {
+        return 0;
+    }
+
+    uint8_t v = rb->buffer[rb->tail++];
+    if (rb->tail >= rb->size) {
+        rb->tail = 0;
+    }
+
+    return v;
+}

src/serial.c

@@ -0,0 +1,97 @@
+/*
+ * serial.c
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+// UART0, Tx GP0, Rx GP1
+#define UART_ID uart0
+#define UART_IRQ UART0_IRQ
+#define UART_TX_PIN 0
+#define UART_RX_PIN 1
+
+// Serial port parameters
+#define BAUD_RATE 115200
+#define DATA_BITS 8
+#define PARITY UART_PARITY_NONE
+#define STOP_BITS 1
+
+#define UART_HW_FIFO_LEN 32
+#define UART_TX_BUFF_LEN 128
+
+#include "hardware/uart.h"
+#include "hardware/gpio.h"
+
+#include "config.h"
+#include "console.h"
+#include "log.h"
+#include "util.h"
+#include "ring.h"
+#include "serial.h"
+
+static uint8_t tx_buff[UART_TX_BUFF_LEN] = {0};
+static struct ring_buffer tx = RB_INIT(tx_buff, sizeof(tx_buff));
+static bool reroute_serial_debug = false;
+
+static void serial_irq(void) {
+    uint8_t buf[UART_HW_FIFO_LEN];
+    uint16_t count = 0;
+
+    // Rx - read from UART FIFO to local buffer
+    while (uart_is_readable(UART_ID)) {
+        uint8_t ch = uart_getc(UART_ID);
+        buf[count++] = ch;
+
+        if (count >= UART_HW_FIFO_LEN) {
+            break;
+        }
+    }
+
+    // Rx - pass local buffer to further processing
+    if ((count >= 1) && (buf[0] == ENTER_BOOTLOADER_MAGIC)) {
+        reset_to_bootloader();
+    } else if (reroute_serial_debug) {
+        debug_handle_input((char *)buf, count);
+    } else {
+        cnsl_handle_input((char *)buf, count);
+    }
+
+    // Tx - write to UART FIFO if needed
+    while (uart_is_writable(UART_ID) && (rb_len(&tx) > 0)) {
+        uart_putc_raw(UART_ID, rb_pop(&tx));
+    }
+}
+
+void serial_init(void) {
+    uart_init(UART_ID, BAUD_RATE);
+    gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
+    gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);
+    uart_set_hw_flow(UART_ID, false, false);
+    uart_set_format(UART_ID, DATA_BITS, STOP_BITS, PARITY);
+    uart_set_fifo_enabled(UART_ID, true);
+
+    irq_set_exclusive_handler(UART_IRQ, serial_irq);
+    irq_set_enabled(UART_IRQ, true);
+
+    uart_set_irq_enables(UART_ID, true, false);
+}
+
+void serial_write(const uint8_t *buf, size_t count) {
+    rb_add(&tx, buf, count);
+}
+
+void serial_set_reroute(bool reroute) {
+    reroute_serial_debug = reroute;
+}

src/usb_cdc.c

@@ -39,7 +39,7 @@
 
 static bool reroute_cdc_debug = false;
 
-void usb_cdc_write(const char *buf, uint32_t count) {
+void usb_cdc_write(const uint8_t *buf, size_t count) {
 #ifndef DISABLE_CDC_DTR_CHECK
     if (!tud_cdc_connected()) {
         return;
@@ -69,16 +69,14 @@ void usb_cdc_set_reroute(bool reroute) {
     reroute_cdc_debug = reroute;
 }
 
-void cdc_task(void) {
+static void cdc_task(void) {
     const uint32_t cdc_buf_len = 64;
 
     if (tud_cdc_available()) {
         char buf[cdc_buf_len + 1];
         uint32_t count = tud_cdc_read(buf, cdc_buf_len);
 
-        if ((count >= 1) && (buf[0] == 0x18)) {
-            // ASCII 0x18 = CAN (cancel)
-            debug("switching to bootloader");
+        if ((count >= 1) && (buf[0] == ENTER_BOOTLOADER_MAGIC)) {
             reset_to_bootloader();
         } else if (reroute_cdc_debug) {
             debug_handle_input(buf, count);