mbv: add async app, sorta works

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;
+}