ywf: console

Author: bradjc

examples/tests/console/console/main.c

@@ -7,7 +7,7 @@
 
 static int getch(void) {
   uint8_t buffer[1];
-  int number_read;
+  uint32_t number_read;
   libtocksync_console_read(buffer, 1, &number_read);
   return buffer[0];
 }

examples/tests/console/console_recv_long/main.c

@@ -5,15 +5,15 @@
 uint8_t buf[100];
 
 int main(void) {
-  int number_read;
+  uint32_t number_read;
   int ret = libtocksync_console_read(buf, 61, &number_read);
   if (ret != RETURNCODE_SUCCESS) {
     printf("[SHORT] Error doing UART receive: %i\n", ret);
     return -1;
   }
 
   printf("\n\nconsole_recv_long: ");
-  for (int i = 0; i < number_read; i++) {
+  for (uint32_t i = 0; i < number_read; i++) {
     printf("%c", buf[i]);
   }
   printf("\n");

examples/tests/console/console_recv_short/main.c

@@ -5,15 +5,15 @@
 uint8_t buf[100];
 
 int main(void) {
-  int number_read;
+  uint32_t number_read;
   int ret = libtocksync_console_read(buf, 11, &number_read);
   if (ret != RETURNCODE_SUCCESS) {
     printf("[SHORT] Error doing UART receive: %i\n", ret);
     return -1;
   }
 
   printf("\n\nconsole_recv_short: ");
-  for (int i = 0; i < number_read; i++) {
+  for (uint32_t i = 0; i < number_read; i++) {
     printf("%c", buf[i]);
   }
   printf("\n");

libtock-sync/interface/console.c

@@ -1,51 +1,41 @@
+#include <libtock/defer.h>
 #include <libtock/interface/syscalls/console_syscalls.h>
 
 #include "console.h"
 
-struct console_result {
-  bool fired;
-  int length;
-  returncode_t result;
-};
-
-static struct console_result result = { .fired = false };
-
-static void generic_cb(returncode_t ret, uint32_t length) {
-  result.length = length;
-  result.fired  = true;
-  result.result = ret;
-}
+#include "syscalls/console_syscalls.h"
 
 bool libtocksync_console_exists(void) {
   return libtock_console_driver_exists();
 }
 
-returncode_t libtocksync_console_write(const uint8_t* buffer, uint32_t length, int* written) {
-  int err;
-  result.fired = false;
+returncode_t libtocksync_console_write(const uint8_t* buffer, uint32_t length, uint32_t* written) {
+  returncode_t ret;
 
-  err = libtock_console_write(buffer, length, &generic_cb);
-  if (err != RETURNCODE_SUCCESS) return err;
+  ret = libtock_console_set_read_allow(buffer, length);
+  if (ret != RETURNCODE_SUCCESS) return ret;
+  defer { libtock_console_set_read_allow(NULL, 0);
+  };
 
-  // Wait for the callback.
-  yield_for(&result.fired);
-  if (result.result != RETURNCODE_SUCCESS) return result.result;
+  ret = libtock_console_command_write(length);
+  if (ret != RETURNCODE_SUCCESS) return ret;
 
-  *written = result.length;
-  return RETURNCODE_SUCCESS;
+  ret = libtocksync_console_yield_wait_for_write(written);
+  return ret;
 }
 
-returncode_t libtocksync_console_read(uint8_t* buffer, uint32_t length, int* read) {
-  int err;
-  result.fired = false;
 
-  err = libtock_console_read(buffer, length, &generic_cb);
-  if (err != RETURNCODE_SUCCESS) return err;
+returncode_t libtocksync_console_read(uint8_t* buffer, uint32_t length, uint32_t* read) {
+  returncode_t ret;
+
+  ret = libtock_console_set_readwrite_allow(buffer, length);
+  if (ret != RETURNCODE_SUCCESS) return ret;
+  defer { libtock_console_set_readwrite_allow(NULL, 0);
+  };
 
-  // Wait for the callback.
-  yield_for(&result.fired);
-  if (result.result != RETURNCODE_SUCCESS) return result.result;
+  ret = libtock_console_command_read(length);
+  if (ret != RETURNCODE_SUCCESS) return ret;
 
-  *read = result.length;
-  return RETURNCODE_SUCCESS;
+  ret = libtocksync_console_yield_wait_for_write(read);
+  return ret;
 }

libtock-sync/interface/console.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <libtock/interface/console.h>
 #include <libtock/tock.h>
 
 #ifdef __cplusplus
@@ -9,9 +8,9 @@ extern "C" {
 
 bool libtocksync_console_exists(void);
 
-returncode_t libtocksync_console_write(const uint8_t* buffer, uint32_t length, int* written);
+returncode_t libtocksync_console_write(const uint8_t* buffer, uint32_t length, uint32_t* written);
 
-returncode_t libtocksync_console_read(uint8_t* buffer, uint32_t length, int* read);
+returncode_t libtocksync_console_read(uint8_t* buffer, uint32_t length, uint32_t* read);
 
 #ifdef __cplusplus
 }

libtock-sync/interface/syscalls/console_syscalls.c

@@ -0,0 +1,19 @@
+#include "console_syscalls.h"
+
+returncode_t libtocksync_console_yield_wait_for_write(uint32_t* bytes_written) {
+  yield_waitfor_return_t ret;
+  ret = yield_wait_for(DRIVER_NUM_CONSOLE, 1);
+
+  *bytes_written = ret.data1;
+
+  return (returncode_t) ret.data0;
+}
+
+returncode_t libtocksync_console_yield_wait_for_read(uint32_t* bytes_read) {
+  yield_waitfor_return_t ret;
+  ret = yield_wait_for(DRIVER_NUM_CONSOLE, 2);
+
+  *bytes_read = ret.data1;
+
+  return (returncode_t) ret.data0;
+}

libtock-sync/interface/syscalls/console_syscalls.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <libtock/interface/syscalls/console_syscalls.h>
+#include <libtock/tock.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+returncode_t libtocksync_console_yield_wait_for_write(uint32_t* bytes_written);
+returncode_t libtocksync_console_yield_wait_for_read(uint32_t* bytes_read);
+
+#ifdef __cplusplus
+}
+#endif

libtock-sync/sys.c

@@ -12,7 +12,7 @@
 // ------------------------------
 
 int _write(__attribute__ ((unused)) int fd, const void* buf, uint32_t count) {
-  int written;
+  uint32_t written;
   libtocksync_console_write((const uint8_t*) buf, count, &written);
-  return written;
+  return (int) written;
 }

libtock/interface/console.h

@@ -8,12 +8,12 @@ extern "C" {
 
 // Function signature for write done callbacks.
 //
-// - `length` (`int`): Number of bytes written
+// - `length` (`uint32_t`): Number of bytes written
 typedef void (*libtock_console_callback_write)(returncode_t, uint32_t);
 
 // Function signature for read done callbacks.
 //
-// - `length` (`int`): Number of bytes read
+// - `length` (`uint32_t`): Number of bytes read
 typedef void (*libtock_console_callback_read)(returncode_t, uint32_t);
 
 // Check if the driver exists.