Improve how we use returncode_t vs statuscode_t.

doc/guide.md

@@ -251,12 +251,12 @@ typedef void (*libtock_sensor_callback_reading)(returncode_t, int);
 Define a upcall function to be passed to the kernel:
 
 ```c
-static void sensor_temp_upcall(int                          ret,
+static void sensor_temp_upcall(int                          status,
                                int                          val,
                                __attribute__ ((unused)) int unused0,
                                void*                        opaque) {
   libtock_sensor_callback_reading cb = (libtock_sensor_callback_reading) opaque;
-  cb(ret, val);
+  cb(tock_status_to_returncode((statuscode_t) status), val);
 }
 ```
 
@@ -349,12 +349,15 @@ the function.
 
 ```c
 returncode_t libtocksync_[name]_yield_wait_for(int* value) {
-  yield_waitfor_return_t ret;
-  ret = yield_wait_for(DRIVER_NUM_[NAME], 0);
-  if (ret.data0 != RETURNCODE_SUCCESS) return ret.data0;
+  returncode_t ret;
+  yield_waitfor_return_t ywf;
+
+  ywf = yield_wait_for(DRIVER_NUM_[NAME], 0);
+  ret = tock_status_to_returncode(ywf.data0);
+  if (ret != RETURNCODE_SUCCESS) return ret;
 
-  *value = (int) ret.data1;
-  return RETURNCODE_SUCCESS;
+  *value = (int) ywf.data1;
+  return ret;
 }
 ```
 
@@ -400,13 +403,13 @@ space for the sync operation:
 #include "syscalls/temperature_syscalls.h"
 
 returncode_t libtocksync_sensor_read(int* val) {
-  returncode_t err;
+  returncode_t ret;
 
-  err = libtock_sensor_command_read();
-  if (err != RETURNCODE_SUCCESS) return err;
+  ret = libtock_sensor_command_read();
+  if (ret != RETURNCODE_SUCCESS) return ret;
 
   // Wait for the operation to finish.
-  err = libtock_temperature_yield_wait_for(val);
-  return err;
+  ret = libtock_temperature_yield_wait_for(val);
+  return ret;
 }
 ```

examples/lvgl/lvgl_driver.c

@@ -31,7 +31,7 @@ static void screen_lvgl_driver(lv_display_t* disp, const lv_area_t* area,
   lv_display_flush_ready(disp);           /* Indicate you are ready with the flushing*/
 }
 
-static void touch_event(int status, uint16_t x, uint16_t y) {
+static void touch_event(libtock_touch_status_t status, uint16_t x, uint16_t y) {
   touch_status = status;
   touch_x      = x;
   touch_y      = y;

examples/tests/touch/main.c

@@ -7,7 +7,7 @@
 
 libtock_touch_event_t* multi_touch_buffer;
 
-static void touch_event(int status, uint16_t x, uint16_t y) {
+static void touch_event(libtock_touch_status_t status, uint16_t x, uint16_t y) {
   switch (status) {
     case LIBTOCK_TOUCH_STATUS_PRESSED: {
       printf("pressed ");

examples/tests/udp/udp_rx/main.c

@@ -32,10 +32,9 @@ void print_ipv6(ipv6_addr_t* ipv6_addr) {
   printf("%02x%02x", ipv6_addr->addr[14], ipv6_addr->addr[15]);
 }
 
-static void callback(statuscode_t status,
+static void callback(returncode_t ret,
                      int          payload_len) {
 
-  returncode_t ret = tock_status_to_returncode(status);
   if (ret != RETURNCODE_SUCCESS) {
     printf("Error in receiving packet: %d\n", ret);
     return;

examples/tests/udp/udp_virt_rx_tests/app1/main.c

@@ -29,10 +29,9 @@ void print_ipv6(ipv6_addr_t* ipv6_addr) {
   printf("%02x%02x", ipv6_addr->addr[14], ipv6_addr->addr[15]);
 }
 
-static void callback(statuscode_t status,
+static void callback(returncode_t ret,
                      int          payload_len) {
 
-  returncode_t ret = tock_status_to_returncode(status);
   if (ret != RETURNCODE_SUCCESS) {
     printf("Error in receiving packet: %d\n", ret);
     return;

examples/tests/udp/udp_virt_rx_tests/app2/main.c

@@ -29,10 +29,9 @@ void print_ipv6(ipv6_addr_t* ipv6_addr) {
   printf("%02x%02x", ipv6_addr->addr[14], ipv6_addr->addr[15]);
 }
 
-static void callback(statuscode_t status,
+static void callback(returncode_t ret,
                      int          payload_len) {
 
-  returncode_t ret = tock_status_to_returncode(status);
   if (ret != RETURNCODE_SUCCESS) {
     printf("Error in receiving packet: %d\n", ret);
     return;

libopenthread/platform/radio.c

@@ -30,22 +30,22 @@ static otRadioFrame ackFrame_radio = {
 static struct pending_tx_done_callback {
   bool flag;
   bool acked;
-  statuscode_t status;
-} pending_tx_done_callback = {false, false, TOCK_STATUSCODE_FAIL};
+  returncode_t ret;
+} pending_tx_done_callback = {false, false, RETURNCODE_FAIL};
 
-static void tx_done_callback(statuscode_t status, bool acked) {
+static void tx_done_callback(returncode_t ret, bool acked) {
 	pending_tx_done_callback.flag = true;
   pending_tx_done_callback.acked = acked;
-  pending_tx_done_callback.status = status;
+  pending_tx_done_callback.ret = ret;
 }
 
-bool pending_tx_done_callback_status(otRadioFrame *ackFrame, returncode_t *status, otRadioFrame *txFrame) {
+bool pending_tx_done_callback_status(otRadioFrame *ackFrame, returncode_t *ret, otRadioFrame *txFrame) {
   if (pending_tx_done_callback.flag) {
     *ackFrame = ackFrame_radio;
-    *status = tock_status_to_returncode(pending_tx_done_callback.status);
+    *ret = pending_tx_done_callback.ret;
     *txFrame = transmitFrame;
-  } 
-	
+  }
+
   return pending_tx_done_callback.flag;
 }
 

libtock-sync/net/ieee802154.c

@@ -17,7 +17,7 @@ static struct ieee802154_receive_data receive_result = { .fired = false };
 struct ieee802154_send_data {
   bool fired;
   bool acked;
-  statuscode_t status;
+  returncode_t ret;
 };
 
 static struct ieee802154_send_data send_result     = { .fired = false };
@@ -30,16 +30,16 @@ static void ieee802154_receive_done_cb(int pan, int src_addr, int dest_addr) {
   receive_result.dest_addr = dest_addr;
 }
 
-static void ieee802154_send_done_cb(statuscode_t status, bool acked) {
-  send_result.fired  = true;
-  send_result.acked  = acked;
-  send_result.status = status;
+static void ieee802154_send_done_cb(returncode_t ret, bool acked) {
+  send_result.fired = true;
+  send_result.acked = acked;
+  send_result.ret   = ret;
 }
 
-static void ieee802154_send_raw_done_cb(statuscode_t status, bool acked) {
-  send_result_raw.fired  = true;
-  send_result_raw.acked  = acked;
-  send_result_raw.status = status;
+static void ieee802154_send_raw_done_cb(returncode_t ret, bool acked) {
+  send_result_raw.fired = true;
+  send_result_raw.acked = acked;
+  send_result_raw.ret   = ret;
 }
 
 returncode_t libtocksync_ieee802154_send(uint16_t         addr,
@@ -56,7 +56,7 @@ returncode_t libtocksync_ieee802154_send(uint16_t         addr,
   // Wait for the frame to be sent
   yield_for(&send_result.fired);
 
-  return tock_status_to_returncode(send_result.status);
+  return send_result.ret;
 }
 
 
@@ -70,7 +70,7 @@ returncode_t libtocksync_ieee802154_send_raw(
 
   yield_for(&send_result_raw.fired);
 
-  return tock_status_to_returncode(send_result_raw.status);
+  return send_result_raw.ret;
 }
 
 returncode_t libtocksync_ieee802154_receive(const libtock_ieee802154_rxbuf* frame) {

libtock-sync/net/udp.c

@@ -5,26 +5,26 @@
 struct recv_data {
   bool fired;
   int val;
-  statuscode_t status;
+  returncode_t ret;
 };
 
 struct send_data {
   bool fired;
-  statuscode_t status;
+  returncode_t ret;
 };
 
 static struct send_data send_sync_result = { .fired = false };
 static struct recv_data recv_sync_result = { .fired = false };
 
-static void send_callback(statuscode_t ret) {
-  send_sync_result.fired  = true;
-  send_sync_result.status = ret;
+static void send_callback(returncode_t ret) {
+  send_sync_result.fired = true;
+  send_sync_result.ret   = ret;
 }
 
-static void recv_callback(statuscode_t ret, int len) {
-  recv_sync_result.val    = len;
-  recv_sync_result.fired  = true;
-  recv_sync_result.status = ret;
+static void recv_callback(returncode_t ret, int len) {
+  recv_sync_result.val   = len;
+  recv_sync_result.fired = true;
+  recv_sync_result.ret   = ret;
 }
 
 returncode_t libtocksync_udp_send(void* buf, size_t len,
@@ -36,7 +36,7 @@ returncode_t libtocksync_udp_send(void* buf, size_t len,
   if (ret != RETURNCODE_SUCCESS) return ret;
 
   yield_for(&send_sync_result.fired);
-  return tock_status_to_returncode(send_sync_result.status);
+  return send_sync_result.ret;
 }
 
 returncode_t libtocksync_udp_recv(void* buf, size_t len, size_t* received_len) {
@@ -49,5 +49,5 @@ returncode_t libtocksync_udp_recv(void* buf, size_t len, size_t* received_len) {
   yield_for(&recv_sync_result.fired);
 
   *received_len = recv_sync_result.val;
-  return tock_status_to_returncode(recv_sync_result.status);
+  return recv_sync_result.ret;
 }

libtock/crypto/hmac.c

@@ -4,7 +4,7 @@ static void hmac_upcall(int ret,
                         __attribute__ ((unused)) int unused1,
                         __attribute__ ((unused)) int unused2, void* opaque) {
   libtock_hmac_callback_hmac cb = (libtock_hmac_callback_hmac) opaque;
-  cb((returncode_t) ret);
+  cb(tock_status_to_returncode(ret));
 }
 
 

libtock/crypto/sha.c

@@ -1,10 +1,10 @@
 #include "sha.h"
 
-static void sha_upcall(int ret,
+static void sha_upcall(int status,
                        __attribute__ ((unused)) int unused1,
                        __attribute__ ((unused)) int unused2, void* opaque) {
   libtock_sha_callback_hash cb = (libtock_sha_callback_hash) opaque;
-  cb((returncode_t) ret);
+  cb(tock_status_to_returncode(status));
 }
 
 returncode_t libtock_sha_simple_hash(libtock_sha_algorithm_t hash_type,

libtock/interface/console.c

@@ -4,12 +4,12 @@
 
 #include "console.h"
 
-static void generic_upcall(int   ret,
+static void generic_upcall(int   status,
                            int   length,
                            int   _z __attribute__ ((unused)),
                            void* ud) {
   libtock_console_callback_write cb = (libtock_console_callback_write)ud;
-  cb(ret, length);
+  cb(tock_status_to_returncode(status), length);
 }
 
 returncode_t libtock_console_write(const uint8_t* buffer, uint32_t len, libtock_console_callback_write cb) {

libtock/net/ieee802154.c

@@ -332,7 +332,7 @@ static void tx_done_upcall(int                          status,
                            __attribute__ ((unused)) int unused2,
                            void*                        opaque) {
   libtock_ieee802154_callback_send_done cb = (libtock_ieee802154_callback_send_done) opaque;
-  cb(status, acked);
+  cb(tock_status_to_returncode(status), acked);
 }
 
 returncode_t libtock_ieee802154_send(uint32_t                              addr,

libtock/net/ieee802154.h

@@ -25,7 +25,7 @@
 extern "C" {
 #endif
 
-typedef void (*libtock_ieee802154_callback_send_done)(statuscode_t, bool);
+typedef void (*libtock_ieee802154_callback_send_done)(returncode_t, bool);
 typedef void (*libtock_ieee802154_callback_recv_done)(int, int, int);
 
 // Check for presence of the driver

libtock/net/udp.c

@@ -59,7 +59,7 @@ static void udp_send_done_upcall(int                          status,
                                  __attribute__ ((unused)) int unused2,
                                  void*                        opaque) {
   libtock_udp_callback_send_done cb = (libtock_udp_callback_send_done) opaque;
-  cb(status);
+  cb(tock_status_to_returncode(status));
 }
 
 returncode_t libtock_udp_send(void* buf, size_t len,
@@ -85,7 +85,7 @@ static void udp_recv_done_upcall(int                          length,
                                  __attribute__ ((unused)) int unused2,
                                  void*                        opaque) {
   libtock_udp_callback_recv_done cb = (libtock_udp_callback_recv_done) opaque;
-  cb(TOCK_STATUSCODE_SUCCESS, length);
+  cb(RETURNCODE_SUCCESS, length);
 }
 
 returncode_t libtock_udp_recv(void* buf, size_t len, libtock_udp_callback_recv_done cb) {

libtock/net/udp.h

@@ -24,10 +24,10 @@ typedef struct sock_handle {
 
 
 /// Callback for when a tx is completed.
-typedef void (*libtock_udp_callback_send_done) (statuscode_t);
+typedef void (*libtock_udp_callback_send_done) (returncode_t);
 
 /// Callback for when a rx is completed.
-typedef void (*libtock_udp_callback_recv_done) (statuscode_t, int);
+typedef void (*libtock_udp_callback_recv_done) (returncode_t, int);
 
 // Creates a new datagram socket bound to an address.
 // Returns 0 on success, negative on failure.

libtock/peripherals/crc.c

@@ -2,7 +2,7 @@
 
 static void crc_upcall(int status, int v1, __attribute__((unused)) int v2, void* opaque) {
   libtock_crc_callback_computed cb = (libtock_crc_callback_computed) opaque;
-  cb(status, v1);
+  cb(tock_status_to_returncode(status), v1);
 }
 
 returncode_t libtock_crc_compute(const uint8_t* buf, uint32_t buflen, libtock_crc_alg_t algorithm,

libtock/peripherals/rtc.c

@@ -29,15 +29,15 @@ static void rtc_date_cb(int   status,
   libtock_rtc_date_t rtc_date;
 
   rtc_convert_args_to_date((uint32_t) date, (uint32_t) time, &rtc_date);
-  cb(status, rtc_date);
+  cb(tock_status_to_returncode(status), rtc_date);
 }
 
 static void rtc_set_cb(int                          status,
                        __attribute__ ((unused)) int arg1,
                        __attribute__ ((unused)) int arg2,
                        void*                        opaque) {
   libtock_rtc_callback_done cb = (libtock_rtc_callback_done) opaque;
-  cb(status);
+  cb(tock_status_to_returncode(status));
 }
 
 returncode_t libtock_rtc_get_date(libtock_rtc_callback_date cb) {

libtock/sensors/moisture.c

@@ -4,7 +4,7 @@ static void moisture_upcall(int status,
                             int moisture,
                             __attribute__ ((unused)) int unused2, void* opaque) {
   libtock_moisture_callback cb = (libtock_moisture_callback) opaque;
-  cb(status, moisture);
+  cb(tock_status_to_returncode(status), moisture);
 }
 
 returncode_t libtock_moisture_read(libtock_moisture_callback cb) {

libtock/sensors/rainfall.c

@@ -4,7 +4,7 @@ static void rainfall_upcall(int status,
                             int rainfall,
                             __attribute__ ((unused)) int unused2, void* opaque) {
   libtock_rainfall_callback cb = (libtock_rainfall_callback) opaque;
-  cb(status, rainfall);
+  cb(tock_status_to_returncode(status), rainfall);
 }
 
 returncode_t libtock_rainfall_read(libtock_rainfall_callback cb, int hours) {