mbv: add async app, sorta works

mbv/Makefile

@@ -14,6 +14,10 @@ timer:  ## Build the timer app in docker
 uart:  ## Build the uart app in docker
 	docker build -o . --target export --build-arg TARGET=uart.bin .
 
+.PHONY: async
+async:  ## Build the async app in docker
+	docker build -o . --target export --build-arg TARGET=async.bin .
+
 .PHONY: dev-image
 dev-image:
 	docker build -t mbv-dev --target dev .

mbv/apps/async/async.cc

@@ -0,0 +1,168 @@
+#include "async.h"
+
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <utility>
+
+#include "lock.h"
+#include "trace.h"
+
+namespace async {
+namespace {
+
+using namespace std::literals::chrono_literals;
+
+struct Stuff {
+    std::coroutine_handle<> h;
+    std::chrono::system_clock::time_point expiration;
+
+    Stuff* next;
+};
+
+struct Notification {
+    bool pending;  // can only be true if stuff is nullptr
+    Stuff* stuff;
+};
+
+std::atomic<Stuff*> work = nullptr;
+std::array<Notification, static_cast<size_t>(AwaitableType::kNumTypes)>
+    notifications = {};
+
+}  // namespace
+
+void schedule(std::coroutine_handle<> h, int ms) {
+    InterruptLock lock;
+    TRACE(tracing::TraceEvent::kAsyncSchedule);
+    std::chrono::system_clock::time_point exp =
+        std::chrono::system_clock::now() + std::chrono::milliseconds(ms);
+    Stuff* news = new Stuff{
+        .h = h,
+        .expiration = exp,
+    };
+
+    Stuff* stuff = work;
+
+    if (!stuff || stuff->expiration > exp) {
+        news->next = stuff;
+        work = news;
+        return;
+    }
+
+    Stuff* s = stuff;
+    while (s->next && s->next->expiration <= exp) {
+        s = s->next;
+    }
+
+    news->next = s->next;
+    s->next = news;
+}
+
+void step() {
+    Stuff* stuff;
+    // ensure all previous side effects are visible
+    {
+        InterruptLock lock;
+        stuff = work;
+    };
+
+    if (stuff == nullptr) {
+        return;
+    }
+
+    auto now = std::chrono::system_clock::now();
+    auto dt = stuff->expiration - now;
+
+    if (dt > 0ms) {
+        return;
+    }
+
+    int stuffinqueue = 0;
+    for (Stuff* s = stuff; s; s = s->next) stuffinqueue++;
+
+    TRACE(tracing::TraceEvent::kAsyncTask);
+    stuff->h();
+    TRACE(tracing::TraceEvent::kAsyncTaskDone);
+
+    if (stuff->h.done()) {
+        stuff->h.destroy();
+    }
+
+    {
+        InterruptLock lock;
+        work = stuff->next;
+    }
+    delete stuff;
+}
+
+void reset() {
+    Stuff* stuff = work;
+    while (stuff) {
+        Stuff* byebye = stuff;
+        stuff = stuff->next;
+
+        delete byebye;
+    }
+    work = nullptr;
+}
+
+void main_loop(bool (*idle_function)()) {
+    while (1) {
+        if (idle_function != nullptr) {
+            if (idle_function()) {
+                reset();
+                break;
+            };
+        }
+
+        step();
+    }
+}
+
+void enqueue(std::coroutine_handle<> h, AwaitableType type) {
+    auto ttype = static_cast<size_t>(type);
+
+    {
+        InterruptLock lock;
+        TRACE(tracing::TraceEvent::kAsyncEnqueue);
+
+        const bool was_notified =
+            std::exchange(notifications[ttype].pending, false);
+        if (was_notified) {
+            TRACE(tracing::TraceEvent::kAsyncAwaitWasNotified);
+            schedule(h);
+            return;
+        }
+
+        Stuff* item = new Stuff{.h = h};
+        Stuff* stuff = notifications[ttype].stuff;
+        if (stuff == nullptr) {
+            notifications[ttype].stuff = item;
+            return;
+        }
+        while (stuff->next != nullptr) {
+            stuff = stuff->next;
+        }
+        stuff->next = item;
+    }
+}
+
+void resume(AwaitableType type) {
+    auto ttype = static_cast<size_t>(type);
+    Stuff* stuff = nullptr;
+    {
+        InterruptLock lock;
+
+        stuff = notifications[ttype].stuff;
+        if (stuff == nullptr) {
+            notifications[ttype].pending = true;
+            return;
+        }
+
+        notifications[ttype].stuff = stuff->next;
+        schedule(stuff->h);
+    }
+    delete stuff;
+}
+
+}  // namespace async

mbv/apps/async/async.h

@@ -0,0 +1,208 @@
+#pragma once
+
+#include <chrono>
+#include <coroutine>
+#include <utility>
+
+#include "trace.h"
+
+namespace async {
+
+struct task_final_suspend {
+    bool await_ready() noexcept(true) { return false; }
+    void await_suspend(std::coroutine_handle<> h) noexcept(true) {
+        if (parent) {
+            TRACE(tracing::TraceEvent::kAsyncCallParent);
+            parent();
+            TRACE(tracing::TraceEvent::kAsyncCallParentDone);
+
+            if (parent && parent.done()) {
+                TRACE(tracing::TraceEvent::kAsyncDestroy);
+                parent.destroy();
+            }
+        }
+    }
+    void await_resume() noexcept(true) {}
+
+    std::coroutine_handle<> parent;
+};
+
+template <typename T>
+struct gimme {
+    // child interface
+    bool await_ready() { return false; }
+    void await_suspend(std::coroutine_handle<> h) {
+        ha = h;
+        waiting = true;
+        TRACE(tracing::TraceEvent::kAsyncGimmeWaiting);
+    }
+    T await_resume() {
+        waiting = false;
+        TRACE(tracing::TraceEvent::kAsyncGimmeResume);
+        return std::move(stuff);
+    }
+
+    // parent interface
+    void feed(T&& s) {
+        if (!waiting) {
+            __builtin_trap();
+        }
+        if (!ha) {
+            __builtin_trap();
+        }
+        stuff = s;
+        ha.resume();
+    }
+
+    bool waiting = false;
+    std::coroutine_handle<> ha;
+    T stuff;
+};
+
+template <typename T = void>
+struct task;
+
+template <>
+struct task<void> {
+    struct promise_type;
+    using handle_type = std::coroutine_handle<promise_type>;
+
+    struct promise_type {
+        task get_return_object() {
+            return {.h = handle_type::from_promise(*this)};
+        }
+        std::suspend_always initial_suspend() noexcept { return {}; }
+        task_final_suspend final_suspend() noexcept {
+            return {.parent = parent};
+        }
+        void return_void() {}
+        void unhandled_exception() {
+            TRACE(tracing::TraceEvent::kAsyncException);
+        }
+
+        std::coroutine_handle<> parent;
+    };
+
+    // awaitable
+    bool await_ready() {
+        TRACE(tracing::TraceEvent::kAsyncCoAwait);
+        h();
+        if (h.done()) {
+            TRACE(tracing::TraceEvent::kAsyncDestroy);
+            h.destroy();
+            return true;
+        }
+        return false;
+    }
+    void await_suspend(std::coroutine_handle<> ha) {
+        TRACE(tracing::TraceEvent::kAsyncSuspend);
+        h.promise().parent = ha;
+    }
+    void await_resume() {}
+
+    std::coroutine_handle<promise_type> h;
+};
+
+template <typename T>
+struct task {
+    struct promise_type;
+    using handle_type = std::coroutine_handle<promise_type>;
+
+    struct promise_type {
+        task get_return_object() {
+            return {.h = handle_type::from_promise(*this)};
+        }
+        std::suspend_always initial_suspend() noexcept { return {}; }
+        task_final_suspend final_suspend() noexcept {
+            return {.parent = parent};
+        }
+        void return_value(T&& value) { ret_value = std::move(value); }
+        void unhandled_exception() {
+            TRACE(tracing::TraceEvent::kAsyncException);
+        }
+        template <std::convertible_to<T> From>
+        task_final_suspend yield_value(From&& value) {
+            ret_value = std::forward<From>(value);
+            result_ready = true;
+            return {.parent = parent};
+        }
+
+        T ret_value;
+        bool result_ready = false;
+        std::coroutine_handle<> parent;
+    };
+
+    // awaitable
+    bool await_ready() {
+        h.promise().parent = {};
+        TRACE(tracing::TraceEvent::kAsyncCoAwait);
+        h();
+        if (h.promise().result_ready) {
+            return true;
+        }
+        if (h.done()) {
+            destroyed = true;
+            ret_value = std::move(h.promise().ret_value);
+            TRACE(tracing::TraceEvent::kAsyncDestroy);
+            h.destroy();
+            return true;
+        }
+        return false;
+    }
+    void await_suspend(std::coroutine_handle<> ha) {
+        TRACE(tracing::TraceEvent::kAsyncSuspend);
+        h.promise().parent = ha;
+    }
+    T await_resume() {
+        if (!destroyed) {
+            h.promise().result_ready = false;
+            return std::move(h.promise().ret_value);
+        }
+        return std::move(ret_value);
+    }
+
+    bool destroyed = false;
+    T ret_value;
+    std::coroutine_handle<promise_type> h;
+};
+
+enum class AwaitableType {
+    kUnknown = 0,
+    kUartRx = 1,
+    kUartTx = 2,
+
+    kNumTypes
+};
+
+void schedule(std::coroutine_handle<> h, int ms = 0);
+void enqueue(std::coroutine_handle<> h, AwaitableType type);
+void resume(AwaitableType type);  // typically called from an ISR
+
+void main_loop(bool (*idle_function)());
+void step();
+
+inline auto await(AwaitableType type) {
+    struct awaitable {
+        AwaitableType type;
+
+        bool await_ready() { return false; };
+        void await_suspend(std::coroutine_handle<> h) { enqueue(h, type); }
+        void await_resume() {}
+    };
+
+    return awaitable{type};
+}
+
+inline auto delay(int ms) {
+    struct awaitable {
+        int ms;
+
+        bool await_ready() { return false; };
+        void await_suspend(std::coroutine_handle<> h) { schedule(h, ms); }
+        void await_resume() {}
+    };
+
+    return awaitable{ms};
+}
+
+}  // namespace async

mbv/apps/async/buffer.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <span>
+#include <utility>
+
+struct buffer {
+    std::span<std::byte> data;
+
+    buffer() = default;
+    buffer(std::span<std::byte> d) : data(d) {}
+
+    static buffer make(size_t size) {
+        return buffer({new std::byte[size], size});
+    }
+
+    buffer(buffer& other) = delete;
+    buffer& operator=(buffer& other) = delete;
+
+    buffer(buffer&& other) : data(std::exchange(other.data, {})) {}
+    buffer& operator=(buffer&& other) {
+        data = std::exchange(other.data, {});
+        return *this;
+    }
+
+    ~buffer() {
+        if (data.data()) {
+            delete[] data.data();
+        };
+    }
+};

mbv/apps/async/gpio.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+
+struct Gpio {
+    volatile uint32_t data;
+};
+
+#define gpio0 ((Gpio*)0x40000000)
+
+inline void ToggleLed(int which) {
+    uint8_t data = gpio0->data;
+    data ^= (0x1 << which);
+    gpio0->data = data;
+}
+
+inline void SetLed(int which) {
+    uint8_t data = gpio0->data;
+    data |= (0x1 << which);
+    gpio0->data = data;
+}
+
+inline void ClearLed(int which) {
+    uint8_t data = gpio0->data;
+    data &= ~(0x1 << which);
+    gpio0->data = data;
+}

mbv/apps/async/itoa.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// out must be at least 8 bytes long
+inline void itoa(int val, char* out) {
+    for (int i = 0; i < 8; i++) {
+        uint8_t digit = (val >> (28 - 4 * i)) & 0xf;
+        if (digit < 0xa) {
+            out[i] = '0' + digit;
+        } else {
+            out[i] = 'a' + digit - 0xa;
+        }
+    }
+}

mbv/apps/async/lock.cc

@@ -0,0 +1,5 @@
+#include "lock.h"
+
+#ifdef __x86_64__
+std::recursive_mutex InterruptLock::m;
+#endif

mbv/apps/async/lock.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#ifndef __x86_64__
+#include "interrupts.h"
+
+struct InterruptLock {
+    bool was_on;
+
+    InterruptLock() : was_on(EnableInterrupts(false)) {}
+
+    ~InterruptLock() { EnableInterrupts(was_on); }
+};
+#else  // __x86_64__
+#include <mutex>
+
+struct InterruptLock {
+    static std::recursive_mutex m;
+    InterruptLock() { m.lock(); }
+    ~InterruptLock() { m.unlock(); }
+};
+#endif  // __x86_64__

mbv/apps/async/main.cc

@@ -0,0 +1,141 @@
+#include "async.h"
+#include "buffer.h"
+#include "gpio.h"
+#include "intc.h"
+#include "interrupts.h"
+#include "pol0.h"
+#include "timer.h"
+#include "trace.h"
+#include "uart.h"
+#include "uart_async.h"
+
+namespace {
+
+using async::AwaitableType;
+Timer* timer0;
+
+void Uart0Isr() {
+    ToggleLed(7);
+    HandleUartIsr();
+}
+
+void Timer0Isr() {
+    SetLed(6);
+    __builtin_trap();
+}
+
+void SetupUart() {
+    InitUarts();
+
+    intc::SetIsr(UART0_IRQN, Uart0Isr);
+    intc::SetIrqEnabled(UART0_IRQN, true);
+}
+
+void SetupTimer() {
+    timer0 = Timer::Instance(TIMER0_BASE);
+    timer0->SetupAsWdt(100'000 * 1000);
+    timer0->EnableT1();
+
+    intc::SetIsr(TIMER0_IRQN, Timer0Isr);
+    intc::SetIrqEnabled(TIMER0_IRQN, true);
+}
+
+void SetupInterrupts() {
+    intc::EnableInterrupts();
+    SetExternalInterruptHandler(intc::InterruptHandler);
+    EnableExternalInterrupts();
+    EnableInterrupts(true);
+}
+
+async::task<> echo() {
+    async::task<uint8_t> reader = UartReadLoop();
+    async::gimme<std::span<const std::byte>> feeder;
+    async::task<> writer = UartWriteLoop(feeder);
+    writer.h.resume();  // advance to first yield
+    while (1) {
+        SetLed(1);
+        uint8_t c = co_await reader;
+        ClearLed(1);
+        ToggleLed(2);
+        feeder.feed(std::as_bytes(std::span{&c, 1}));
+    }
+}
+
+}  // namespace
+
+#define XUL_SR_RX_FIFO_FULL 0x02       /* receive FIFO full */
+#define XUL_SR_RX_FIFO_VALID_DATA 0x01 /* data in receive FIFO */
+
+int main() {
+    SetupUart();
+    UartWriteCrash("uart setup done\r\n");
+    SetupTimer();
+    UartWriteCrash("timer setup done\r\n");
+
+    gpio0->data = 0;
+    SetupInterrupts();
+
+    async::schedule(echo().h);
+
+    UartWriteCrash("init done. starting main loop\r\n");
+
+    async::main_loop([]() {
+        static int cnt = 0;
+        timer0->Pet();
+        if ((cnt++ % 100000) == 0) {
+            ToggleLed(0);
+        }
+        return false;
+    });
+    // should never get here
+}
+
+/// stdlib stuff
+
+#include <sys/time.h>
+
+#include <cstdint>
+
+#include "itoa.h"
+#include "lock.h"
+
+#ifndef SBRK_STATS
+#define SBRK_STATS 0
+#endif
+
+extern unsigned char _heap_begin, _heap_end;
+
+extern "C" void* _sbrk(int increment) {
+    static unsigned char* heap = &_heap_begin;
+    unsigned char* prev_heap = heap;
+    if (heap + increment >= &_heap_end) {
+        UartWriteCrash("Heap overflow!\r\n");
+        return reinterpret_cast<void*>(-1);
+    }
+    heap += increment;
+    return prev_heap;
+}
+
+extern "C" int _gettimeofday(struct timeval* tv, void* tzvp) {
+    (void)tzvp;
+    uint32_t ticks = timer0->GetT1Ticks();
+    tv->tv_sec = ticks / 100000000;
+    tv->tv_usec = (ticks % 100000000) / 100;
+
+    return 0;
+}
+
+extern "C" uint8_t __atomic_exchange_1(volatile void* ptr, uint8_t val,
+                                       int memorder) {
+    (void)memorder;
+    auto* dest = reinterpret_cast<volatile uint8_t*>(ptr);
+    bool ret;
+
+    {
+        InterruptLock lock;
+        ret = *dest;
+        *dest = val;
+    }
+
+    return ret;
+}

mbv/apps/async/ring_buffer.h

@@ -0,0 +1,108 @@
+#pragma once
+
+#include <atomic>
+#include <span>
+
+#include "lock.h"
+
+struct RingBuffer {
+    std::span<std::byte> buffer;
+
+    std::atomic<size_t> read_ptr = 0;
+    std::atomic<size_t> write_ptr = 0;
+    std::atomic<bool> full = 0;
+
+    bool Store(std::span<const std::byte> data) {
+        InterruptLock lock;
+
+        if (data.size() > FreeSpace()) {
+            return false;
+        }
+        const size_t to_copy = std::min(buffer.size() - write_ptr, data.size());
+        std::copy(data.begin(), data.begin() + to_copy,
+                  buffer.begin() + write_ptr);
+        if (to_copy < data.size()) {
+            std::copy(data.begin() + to_copy, data.end(), buffer.begin());
+        }
+        Push(data.size());
+
+        return true;
+    }
+
+    bool Load(std::span<std::byte> out) {
+        InterruptLock lock;
+
+        if (out.size() > AvailableData()) {
+            return false;
+        }
+        const size_t to_copy = std::min(buffer.size() - read_ptr, out.size());
+        std::copy(buffer.begin() + read_ptr,
+                  buffer.begin() + read_ptr + to_copy, out.begin());
+        if (to_copy < out.size()) {
+            std::copy(buffer.begin(), buffer.begin() + out.size() - to_copy,
+                      out.begin() + to_copy);
+        }
+        Pop(out.size());
+        return true;
+    }
+
+    bool Push(size_t amount) {
+        InterruptLock lock;
+
+        if (amount > FreeSpace()) {
+            return false;
+        }
+        write_ptr = (write_ptr + amount) % buffer.size();
+        if (read_ptr == write_ptr) {
+            full = true;
+        }
+        return true;
+    }
+
+    bool Pop(size_t amount) {
+        InterruptLock lock;
+
+        if (amount > AvailableData()) {
+            return false;
+        }
+        read_ptr = (read_ptr + amount) % buffer.size();
+        if (amount > 0) {
+            full = false;
+        }
+        return true;
+    }
+
+    size_t FreeSpace() const {
+        InterruptLock lock;
+
+        return buffer.size() - AvailableData();
+    }
+
+    size_t AvailableData() const {
+        InterruptLock lock;
+
+        if (read_ptr == write_ptr) {
+            return full ? buffer.size() : 0;
+        }
+        return (buffer.size() + write_ptr - read_ptr) % buffer.size();
+    }
+
+    uint8_t* RawReadPointer() const {
+        InterruptLock lock;
+
+        return reinterpret_cast<uint8_t*>(buffer.data() + read_ptr);
+    }
+
+    size_t ContiguousAvailableData() const {
+        InterruptLock lock;
+
+        if (read_ptr < write_ptr) {
+            return AvailableData();
+        }
+        if (full) {
+            return 0;
+        }
+
+        return buffer.size() - read_ptr;
+    }
+};

mbv/apps/async/trace.cc

@@ -0,0 +1,71 @@
+#include "trace.h"
+
+#include <algorithm>
+#include <chrono>
+
+#include "itoa.h"
+#include "lock.h"
+#include "uart.h"
+
+namespace tracing {
+namespace {
+
+struct Event {
+    uint32_t timestamp;
+    TraceEvent event;
+};
+
+constexpr size_t kTraceBufferSize = 256;
+std::array<Event, kTraceBufferSize> buffer;
+size_t write_ptr = 0;
+size_t size = 0;
+
+}  // namespace
+
+void trace(int raw_event) { trace(static_cast<TraceEvent>(raw_event)); }
+
+void trace(TraceEvent event) {
+    const std::chrono::system_clock::time_point now =
+        std::chrono::system_clock::now();
+    const uint32_t uptime_ticks = now.time_since_epoch().count();
+
+    {
+        InterruptLock lock;
+
+        buffer[write_ptr] = {.timestamp = uptime_ticks, .event = event};
+
+        write_ptr = (write_ptr + 1) % buffer.size();
+        size = std::min(size + 1, kTraceBufferSize);
+
+#if TRACE_DUMP_WHEN_FULL
+        if (size == kTraceBufferSize) {
+            dump();
+        }
+#endif  // TRACE_DUMP_WHEN_FULL
+    }
+}
+
+void dump() {
+    InterruptLock lock;
+
+    if (size == kTraceBufferSize) {
+        std::rotate(buffer.begin(), buffer.begin() + write_ptr, buffer.end());
+    }
+
+    char number[] = "00000000";
+
+    UartWriteCrash("----\r\n");
+    for (Event event : std::span{buffer}.subspan(0, size)) {
+        itoa(static_cast<int>(event.timestamp), number);
+        UartWriteCrash(number);
+        UartWriteCrash(" ");
+        itoa(static_cast<int>(event.event), number);
+        UartWriteCrash(number);
+        UartWriteCrash("\r\n");
+    }
+    UartWriteCrash("----\r\n");
+
+    size = 0;
+    write_ptr = 0;
+}
+}  // namespace tracing

mbv/apps/async/trace.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#define TRACE_DUMP_WHEN_FULL 0
+
+#ifdef __x86_64__
+#include <cstdio>
+#define TRACE(x) printf(#x "\n")
+#else  // __x86_64__
+#define TRACE(...) tracing::trace(__VA_ARGS__)
+#endif  // __x86_64__
+
+#include <cstdint>
+
+namespace tracing {
+enum class TraceEvent : uint8_t {
+    kUnknown = 0,
+
+    kUartIsr = 1,
+    kUartRxCb = 2,
+    kUartTxCb = 3,
+
+    kUartSend = 10,
+    kUartRecv = 11,
+    kUartTxBufferFull = 12,
+    kUartTxBufferNotFull = 13,
+
+    kUartWriteDone = 20,
+
+    kAsyncResume = 4,
+    kAsyncEnqueue = 5,
+    kAsyncTask = 6,
+    kAsyncResumeSetPending = 7,
+    kAsyncAwaitWasNotified = 8,
+    kAsyncSchedule = 9,
+
+    kAsyncTaskDone = 14,
+    kAsyncException = 15,
+    kAsyncCallParent = 16,
+    kAsyncCallParentDone = 17,
+    kAsyncCoAwait = 18,
+    kAsyncSuspend = 19,
+    kAsyncDestroy = 21,
+
+    kAsyncGimmeWaiting = 22,
+    kAsyncGimmeResume = 23,
+};
+
+void trace(TraceEvent event);
+void trace(int raw_event);
+void dump();
+}  // namespace tracing

mbv/apps/async/uart.cc

@@ -0,0 +1,165 @@
+#include "uart.h"
+
+#include "async.h"
+#include "gpio.h"
+#include "lock.h"
+#include "pol0.h"
+#include "ring_buffer.h"
+#include "trace.h"
+#include "uart_async.h"
+#include "xuartlite.h"
+
+namespace {
+using async::AwaitableType;
+
+constexpr uintptr_t kUart0BaseAddress = UART0_BASE;
+XUartLite uart0_inst;
+XUartLite_Config uart0_config = {
+    .DeviceId = 0,
+    .RegBaseAddr = kUart0BaseAddress,
+    .BaudRate = 115200,
+    .UseParity = false,
+    .DataBits = 8,
+};
+
+constexpr size_t kUartTxBufferSize = 256;
+std::array<std::byte, kUartTxBufferSize> tx_buffer = {};
+RingBuffer tx_ring_buffer{.buffer = tx_buffer};
+
+XUartLite* uart0 = &uart0_inst;
+}  // namespace
+
+void InitUarts() {
+    XUartLite_CfgInitialize(uart0, &uart0_config, uart0_config.RegBaseAddr);
+
+    XUartLite_SetSendHandler(uart0, HandleUartTxFromIsr, nullptr);
+    XUartLite_SetRecvHandler(uart0, HandleUartRxFromIsr, nullptr);
+    XUartLite_EnableInterrupt(uart0);
+}
+
+void UartWriteCrash(std::span<const std::byte> data) {
+    while (data.size() > 0) {
+        while (XUartLite_IsSending(uart0)) {
+        }
+        auto* dat =
+            reinterpret_cast<uint8_t*>(const_cast<std::byte*>(data.data()));
+        uint8_t sent = XUartLite_Send(uart0, dat, data.size());
+        data = data.subspan(sent);
+    }
+    while (XUartLite_IsSending(uart0)) {
+    }
+}
+
+async::task<> UartWrite(std::span<const std::byte> data) {
+    while (!tx_ring_buffer.Store(data)) {
+        tracing::trace(tracing::TraceEvent::kUartTxBufferFull);
+        co_await async::await(AwaitableType::kUartTx);
+        tracing::trace(tracing::TraceEvent::kUartTxBufferNotFull);
+    }
+
+    {
+        InterruptLock lock;
+        if (!XUartLite_IsSending(uart0)) {
+            tracing::trace(tracing::TraceEvent::kUartSend);
+            XUartLite_Send(uart0, tx_ring_buffer.RawReadPointer(),
+                           tx_ring_buffer.ContiguousAvailableData());
+        }
+    }
+}
+
+async::task<> UartWriteLoop(
+    async::gimme<std::span<const std::byte>>& data_gen) {
+    while (1) {
+        auto data = co_await data_gen;
+        while (!tx_ring_buffer.Store(data)) {
+            tracing::trace(tracing::TraceEvent::kUartTxBufferFull);
+            co_await async::await(AwaitableType::kUartTx);
+            tracing::trace(tracing::TraceEvent::kUartTxBufferNotFull);
+        }
+
+        {
+            InterruptLock lock;
+            if (!XUartLite_IsSending(uart0)) {
+                tracing::trace(tracing::TraceEvent::kUartSend);
+                XUartLite_Send(uart0, tx_ring_buffer.RawReadPointer(),
+                               tx_ring_buffer.ContiguousAvailableData());
+            }
+        }
+    }
+}
+
+void UartReadBlocking(std::span<std::byte> data) {
+    size_t bytes_received = 0;
+    while (bytes_received < data.size()) {
+        auto* buffer = reinterpret_cast<uint8_t*>(data.data() + bytes_received);
+        tracing::trace(tracing::TraceEvent::kUartRecv);
+        bytes_received +=
+            XUartLite_Recv(uart0, buffer, data.size() - bytes_received);
+    }
+}
+
+void UartWriteBlocking(std::span<const std::byte> data) {
+    while (!tx_ring_buffer.Store(data)) {
+    }
+
+    {
+        InterruptLock lock;
+        if (!XUartLite_IsSending(uart0)) {
+            tracing::trace(tracing::TraceEvent::kUartSend);
+            XUartLite_Send(uart0, tx_ring_buffer.RawReadPointer(),
+                           tx_ring_buffer.ContiguousAvailableData());
+        }
+    }
+}
+
+async::task<uint8_t> UartReadLoop() {
+    uint8_t c;
+    while (1) {
+        tracing::trace(tracing::TraceEvent::kUartRecv);
+        size_t received = XUartLite_Recv(uart0, &c, 1);
+        // some data may already be in the fifo, but if not, wait:
+        if (received < 1) {
+            co_await async::await(AwaitableType::kUartRx);
+        }
+
+        co_yield c;
+    }
+}
+
+async::task<buffer> UartRead(int size) {
+    auto buff = buffer::make(size);
+    auto* data = reinterpret_cast<uint8_t*>(buff.data.data());
+    tracing::trace(tracing::TraceEvent::kUartRecv);
+    size_t received = XUartLite_Recv(uart0, data, buff.data.size());
+    // some data may already be in the fifo, but if not, wait:
+    if (received < buff.data.size()) {
+        co_await async::await(AwaitableType::kUartRx);
+    }
+    co_return buff;
+}
+
+void HandleUartTxFromIsr(void*, unsigned int transmitted) {
+    tx_ring_buffer.Pop(transmitted);
+    if (tx_ring_buffer.AvailableData() > 0) {
+        tracing::trace(tracing::TraceEvent::kUartSend);
+        XUartLite_Send(uart0, tx_ring_buffer.RawReadPointer(),
+                       tx_ring_buffer.ContiguousAvailableData());
+    }
+    async::resume(AwaitableType::kUartTx);
+}
+
+void HandleUartRxFromIsr(void*, unsigned int) {
+    async::resume(AwaitableType::kUartRx);
+}
+
+void HandleUartIsr() { XUartLite_InterruptHandler(uart0); }
+
+extern "C" uint8_t XUartLite_GetSR(XUartLite*);
+
+uint8_t UartStatus() { return XUartLite_GetSR(uart0); }
+
+void LogStuff() {
+    uint8_t data = gpio0->data;
+    data |= (uart0->ReceiveBuffer.RemainingBytes & 0xf) << 4;
+    gpio0->data = data;
+}

mbv/apps/async/uart.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <cstdint>
+#include <span>
+#include <string_view>
+
+void InitUarts();
+
+// block until the provided buffer is full
+void UartReadBlocking(std::span<std::byte> data);
+inline uint8_t UartReadByteBlocking() {
+    std::byte byte;
+    UartReadBlocking(std::span{&byte, 1});
+    return static_cast<uint8_t>(byte);
+}
+
+// send and poll the uart until transmitted
+void UartWriteCrash(std::span<const std::byte> data);
+inline void UartWriteCrash(std::string_view s) {
+    return UartWriteCrash(std::as_bytes(std::span{s.data(), s.size()}));
+}
+
+// block until room is available in tx fifo, then send
+void UartWriteBlocking(std::span<const std::byte> data);
+inline void UartWriteBlocking(std::string_view s) {
+    return UartWriteBlocking(std::as_bytes(std::span{s.data(), s.size()}));
+}
+
+void HandleUartTxFromIsr(void*, unsigned int transmitted);
+void HandleUartRxFromIsr(void*, unsigned int);
+void HandleUartIsr();
+
+uint8_t UartStatus();
+
+void LogStuff();

mbv/apps/async/uart_async.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <span>
+#include <string_view>
+
+#include "async.h"
+#include "buffer.h"
+
+async::task<buffer> UartRead(int size);
+async::task<uint8_t> UartReadLoop();
+async::task<> UartWrite(std::span<const std::byte> data);
+inline async::task<> UartWrite(std::string_view s) {
+    co_await UartWrite(std::as_bytes(std::span{s.data(), s.size()}));
+}
+async::task<> UartWriteLoop(async::gimme<std::span<const std::byte>>& data);

mbv/configure

@@ -283,9 +283,11 @@ bootloader_image = build_image(
     linker_script="bootloader/bootloader.ld",
 )
 
-def app_image(app):
+def app_image(app, sources=None):
+    if sources is None:
+        sources = glob.glob(f"./apps/{app}/**/*.cc", recursive=True)
     return build_image(
-            source_set(app, glob.glob(f"./apps/{app}/**/*.cc", recursive=True)),
+            source_set(app, sources),
             linker_script="apps/app.ld",
             dependencies=[hal],
             elf_out=f"{app}.elf",
@@ -299,6 +301,13 @@ all = [
         app_image("helloworld"),
         app_image("timer"),
         app_image("uart"),
+        app_image("async", sources=[
+            "apps/async/async.cc",
+            "apps/async/lock.cc",
+            "apps/async/main.cc",
+            "apps/async/trace.cc",
+            "apps/async/uart.cc",
+            ]),
 ]