From 58f41971b1e801ad2fbcea08e5152afa2b18ca73 Mon Sep 17 00:00:00 2001
From: Uros Majstorovic <majstor@majstor.org>
Date: Mon, 28 Jul 2025 23:27:12 +0200
Subject: sys logging added; power management reimplemented; bugfixes;

---
 fw/fe310/eos/event.c | 107 ++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 85 insertions(+), 22 deletions(-)

(limited to 'fw/fe310/eos/event.c')

diff --git a/fw/fe310/eos/event.c b/fw/fe310/eos/event.c
index f76384a..b21e5ea 100644
--- a/fw/fe310/eos/event.c
+++ b/fw/fe310/eos/event.c
@@ -1,69 +1,110 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <unistd.h>
-#include <stdio.h>
 
 #include "encoding.h"
 #include "platform.h"
 
 #include "eos.h"
+#include "log.h"
 #include "msgq.h"
 #include "event.h"
 
 EOSMsgQ _eos_event_q;
 static EOSMsgItem event_q_array[EOS_EVT_SIZE_Q];
 
-static eos_evt_handler_t evt_handler[EOS_EVT_MAX_EVT + 1];
+static eos_evt_handler_t evt_handler[EOS_EVT_MAX];
+static eos_evt_handler_global_t evt_handler_global;
+static eos_evt_loopf_t evt_loop_f;
 
-static void evtq_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
+static void evtq_handler(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t _idx) {
     unsigned char idx = (type & EOS_EVT_MASK) >> 4;
 
-    if (idx && (idx <= EOS_EVT_MAX_EVT)) {
-        evt_handler[idx](type, buffer, len);
+    if (idx && (idx <= EOS_EVT_MAX)) {
+        evt_handler[idx - 1](type, buffer, len);
     } else {
         eos_evtq_bad_handler(type, buffer, len);
     }
 }
 
-int eos_evtq_init(uint8_t wakeup_cause) {
+int eos_evtq_init(void) {
     int i;
 
-    evt_handler[0] = evtq_handler;
-    for (i=0; i<EOS_EVT_MAX_EVT; i++) {
-        evt_handler[i + 1] = eos_evtq_bad_handler;
+    evt_handler_global = evtq_handler;
+    for (i=0; i<EOS_EVT_MAX; i++) {
+        evt_handler[i] = eos_evtq_bad_handler;
     }
     eos_msgq_init(&_eos_event_q, event_q_array, EOS_EVT_SIZE_Q);
 
     return EOS_OK;
 }
 
+int eos_evtq_len(void) {
+    int rv;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    rv = eos_msgq_len(&_eos_event_q);
+    set_csr(mstatus, MSTATUS_MIE);
+
+    return rv;
+}
+
 int eos_evtq_push(unsigned char type, unsigned char *buffer, uint16_t len) {
+    int rv;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    rv = eos_msgq_push(&_eos_event_q, type, buffer, len);
+    set_csr(mstatus, MSTATUS_MIE);
+
+    return rv;
+}
+
+int eos_evtq_push_widx(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t *idx) {
+    int rv;
+
     clear_csr(mstatus, MSTATUS_MIE);
-    int ret = eos_msgq_push(&_eos_event_q, type, buffer, len);
+    rv = eos_msgq_push_widx(&_eos_event_q, type, buffer, len, idx);
     set_csr(mstatus, MSTATUS_MIE);
-    return ret;
+
+    return rv;
 }
 
 int eos_evtq_push_isr(unsigned char type, unsigned char *buffer, uint16_t len) {
     return eos_msgq_push(&_eos_event_q, type, buffer, len);
 }
 
+int eos_evtq_push_widx_isr(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t *idx) {
+    return eos_msgq_push_widx(&_eos_event_q, type, buffer, len, idx);
+}
+
 void eos_evtq_pop(unsigned char *type, unsigned char **buffer, uint16_t *len) {
     clear_csr(mstatus, MSTATUS_MIE);
     eos_msgq_pop(&_eos_event_q, type, buffer, len);
     set_csr(mstatus, MSTATUS_MIE);
 }
 
+void eos_evtq_pop_widx(unsigned char *type, unsigned char **buffer, uint16_t *len, uint8_t *idx) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    eos_msgq_pop_widx(&_eos_event_q, type, buffer, len, idx);
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
 void eos_evtq_pop_isr(unsigned char *type, unsigned char **buffer, uint16_t *len) {
     eos_msgq_pop(&_eos_event_q, type, buffer, len);
 }
 
+void eos_evtq_pop_widx_isr(unsigned char *type, unsigned char **buffer, uint16_t *len, uint8_t *idx) {
+    eos_msgq_pop_widx(&_eos_event_q, type, buffer, len, idx);
+}
+
 int eos_evtq_get(unsigned char type, unsigned char **buffer, uint16_t *len) {
     int rv = 0;
 
     clear_csr(mstatus, MSTATUS_MIE);
     rv = eos_msgq_find(&_eos_event_q, type, NULL, 0, buffer, len);
     set_csr(mstatus, MSTATUS_MIE);
+
+    return rv;
 }
 
 int eos_evtq_find(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len) {
@@ -72,23 +113,30 @@ int eos_evtq_find(unsigned char type, unsigned char *selector, uint16_t sel_len,
     clear_csr(mstatus, MSTATUS_MIE);
     rv = eos_msgq_find(&_eos_event_q, type, selector, sel_len, buffer, len);
     set_csr(mstatus, MSTATUS_MIE);
+
+    return rv;
 }
 
-void eos_evtq_wait(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len) {
+int eos_evtq_wait(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len) {
     int rv = 0;
 
     while(!rv) {
         clear_csr(mstatus, MSTATUS_MIE);
         rv = eos_msgq_find(&_eos_event_q, type, selector, sel_len, buffer, len);
-        if (!rv) {
+        if (rv && (rv != EOS_ERR_NOTFOUND)) {
+            set_csr(mstatus, MSTATUS_MIE);
+            return rv;
+        }
+        if (rv) {
             unsigned char _type;
             unsigned char *_buffer;
             uint16_t _len;
+            uint8_t idx;
 
-            eos_msgq_pop(&_eos_event_q, &_type, &_buffer, &_len);
+            eos_msgq_pop_widx(&_eos_event_q, &_type, &_buffer, &_len, &idx);
             if (_type) {
                 set_csr(mstatus, MSTATUS_MIE);
-                evt_handler[0](_type, _buffer, _len);
+                evt_handler_global(_type, _buffer, _len, idx);
             } else {
                 asm volatile ("wfi");
                 set_csr(mstatus, MSTATUS_MIE);
@@ -109,12 +157,13 @@ void eos_evtq_flush_isr(void) {
     unsigned char type;
     unsigned char *buffer;
     uint16_t len;
+    uint8_t idx;
 
     do {
-        eos_msgq_pop(&_eos_event_q, &type, &buffer, &len);
+        eos_msgq_pop_widx(&_eos_event_q, &type, &buffer, &len, &idx);
         if (type) {
             set_csr(mstatus, MSTATUS_MIE);
-            evt_handler[0](type, buffer, len);
+            evt_handler_global(type, buffer, len, idx);
             clear_csr(mstatus, MSTATUS_MIE);
         }
     } while (type);
@@ -125,6 +174,7 @@ void eos_evtq_loop(void) {
 
     while(foo) {
         eos_evtq_exec();
+        if (evt_loop_f) evt_loop_f();
     }
 }
 
@@ -132,33 +182,46 @@ void eos_evtq_exec(void) {
     unsigned char type;
     unsigned char *buffer;
     uint16_t len;
+    uint8_t idx;
 
     clear_csr(mstatus, MSTATUS_MIE);
-    eos_msgq_pop(&_eos_event_q, &type, &buffer, &len);
+    eos_msgq_pop_widx(&_eos_event_q, &type, &buffer, &len, &idx);
     if (type) {
         set_csr(mstatus, MSTATUS_MIE);
-        evt_handler[0](type, buffer, len);
+        evt_handler_global(type, buffer, len, idx);
     } else {
         asm volatile ("wfi");
         set_csr(mstatus, MSTATUS_MIE);
     }
+}
 
+void eos_evtq_set_loopf(eos_evt_loopf_t loop_f) {
+    evt_loop_f = loop_f;
 }
 
+
 void eos_evtq_bad_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
-    printf("EVT BAD HANDLER:0x%x\n", type);
+    EOS_LOG(EOS_LOG_ERR, "EVT BAD HANDLER:0x%.2X\n", type);
 }
 
 void eos_evtq_set_handler(unsigned char type, eos_evt_handler_t handler) {
     unsigned char idx = (type & EOS_EVT_MASK) >> 4;
 
     if (handler == NULL) handler = eos_evtq_bad_handler;
-    if (idx <= EOS_EVT_MAX_EVT) evt_handler[idx] = handler;
+    if (idx && (idx <= EOS_EVT_MAX)) evt_handler[idx - 1] = handler;
 }
 
 eos_evt_handler_t eos_evtq_get_handler(unsigned char type) {
     unsigned char idx = (type & EOS_EVT_MASK) >> 4;
 
-    if (idx <= EOS_EVT_MAX_EVT) return evt_handler[idx];
+    if (idx && (idx <= EOS_EVT_MAX)) return evt_handler[idx - 1];
     return NULL;
 }
+
+void eos_evtq_set_handler_global(eos_evt_handler_global_t handler) {
+    evt_handler_global = handler;
+}
+
+eos_evt_handler_global_t eos_evtq_get_handler_global(void) {
+    return evt_handler_global;
+}
-- 
cgit v1.2.3