arm: more uart async & debug stuff

arm/uart.cc

@@ -1,10 +1,11 @@
 #include "uart.h"
-#include "uart_async.h"
 
 #include "async.h"
 #include "gpio.h"
+#include "lock.h"
 #include "ring_buffer.h"
 #include "trace.h"
+#include "uart_async.h"
 #include "xuartlite.h"
 
 namespace {
@@ -54,38 +55,93 @@ void UartWriteCrash(std::span<const std::byte> data) {
 
 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);
     }
 
-    if (!XUartLite_IsSending(uart0)) {
-        XUartLite_Send(uart0, tx_ring_buffer.RawReadPointer(),
-                       tx_ring_buffer.ContiguousAvailableData());
+    {
+        InterruptLock lock;
+        if (!XUartLite_IsSending(uart0)) {
+            tracing::trace(tracing::TraceEvent::kUartSend);
+            XUartLite_Send(uart0, tx_ring_buffer.RawReadPointer(),
+                           tx_ring_buffer.ContiguousAvailableData());
+        }
     }
 }
 
+#define GCC_HAS_BUG_101133 1  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101133
+#if !GCC_HAS_BUG_101133
+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());
+            }
+        }
+    }
+}
+#endif  // !GCC_HAS_BUG_101133
+
 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) {
+    if (__get_PRIMASK() != 0) {
+        UartWriteCrash("\r\nUartWriteBlocking called with interupts disabled!\r\n");
+        __builtin_trap();
+    }
+
     while (!tx_ring_buffer.Store(data)) {
     }
 
-    if (!XUartLite_IsSending(uart0)) {
-        XUartLite_Send(uart0, tx_ring_buffer.RawReadPointer(),
-                       tx_ring_buffer.ContiguousAvailableData());
+    {
+        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);
     }
@@ -93,9 +149,9 @@ async::task<buffer> UartRead(int size) {
 }
 
 void HandleUartTxFromIsr(void*, unsigned int transmitted) {
-    tracing::trace(tracing::TraceEvent::kUartTxCb);
     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());
     }
@@ -103,8 +159,17 @@ void HandleUartTxFromIsr(void*, unsigned int transmitted) {
 }
 
 void HandleUartRxFromIsr(void*, unsigned int) {
-    tracing::trace(tracing::TraceEvent::kUartRxCb);
     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;
+}