From 9dd9e0b37c5ccb1549f97cda91ec4f0247b0df22 Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Wed, 9 Jul 2025 20:38:52 -0400 Subject: [PATCH 1/9] ywf: sha --- libtock-sync/crypto/sha.c | 38 +++++++++------------ libtock-sync/crypto/sha.h | 4 ++- libtock-sync/crypto/syscalls/sha_syscalls.c | 8 +++++ libtock-sync/crypto/syscalls/sha_syscalls.h | 15 ++++++++ libtock/crypto/sha.h | 8 +---- libtock/crypto/sha_types.h | 17 +++++++++ 6 files changed, 60 insertions(+), 30 deletions(-) create mode 100644 libtock-sync/crypto/syscalls/sha_syscalls.c create mode 100644 libtock-sync/crypto/syscalls/sha_syscalls.h create mode 100644 libtock/crypto/sha_types.h diff --git a/libtock-sync/crypto/sha.c b/libtock-sync/crypto/sha.c index b3b237b84..fe6eacf05 100644 --- a/libtock-sync/crypto/sha.c +++ b/libtock-sync/crypto/sha.c @@ -1,36 +1,30 @@ #include "sha.h" -struct sha_data { - bool fired; - returncode_t ret; -}; - -static struct sha_data result = {.fired = false}; - -static void sha_cb_hash(returncode_t ret) { - result.fired = true; - result.ret = ret; -} - returncode_t libtocksync_sha_simple_hash(libtock_sha_algorithm_t hash_type, uint8_t* input_buffer, uint32_t input_length, uint8_t* hash_buffer, uint32_t hash_length) { returncode_t ret; - result.fired = false; + ret = libtock_sha_command_set_algorithm((uint8_t) hash_type); + if (ret != RETURNCODE_SUCCESS) return ret; - ret = libtock_sha_simple_hash(hash_type, input_buffer, input_length, hash_buffer, hash_length, sha_cb_hash); + ret = libtock_sha_set_readonly_allow_data_buffer(input_buffer, input_length); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + ret = libtock_sha_set_readwrite_allow_destination_buffer(hash_buffer, hash_length); + if (ret != RETURNCODE_SUCCESS) goto exit1; - ret = libtock_sha_set_readonly_allow_data_buffer(NULL, 0); - if (ret != RETURNCODE_SUCCESS) return ret; + ret = libtock_sha_command_run(); + if (ret != RETURNCODE_SUCCESS) goto exit2; - ret = libtock_sha_set_readwrite_allow_destination_buffer(NULL, 0); - if (ret != RETURNCODE_SUCCESS) return ret; + // Wait for the operation. + ret = libtocksync_sha_yield_wait_for(); + +exit2: + libtock_sha_set_readwrite_allow_destination_buffer(NULL, 0); + +exit1: + libtock_sha_set_readonly_allow_data_buffer(NULL, 0); - return RETURNCODE_SUCCESS; + return ret; } diff --git a/libtock-sync/crypto/sha.h b/libtock-sync/crypto/sha.h index 4c30e1540..c1e729941 100644 --- a/libtock-sync/crypto/sha.h +++ b/libtock-sync/crypto/sha.h @@ -1,8 +1,10 @@ #pragma once -#include +#include #include +#include "syscalls/sha_syscalls.h" + #ifdef __cplusplus extern "C" { #endif diff --git a/libtock-sync/crypto/syscalls/sha_syscalls.c b/libtock-sync/crypto/syscalls/sha_syscalls.c new file mode 100644 index 000000000..9dcbca6a7 --- /dev/null +++ b/libtock-sync/crypto/syscalls/sha_syscalls.c @@ -0,0 +1,8 @@ +#include "sha_syscalls.h" + +returncode_t libtocksync_sha_yield_wait_for(void) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_SHA, 0); + + return (returncode_t) ret.data0; +} diff --git a/libtock-sync/crypto/syscalls/sha_syscalls.h b/libtock-sync/crypto/syscalls/sha_syscalls.h new file mode 100644 index 000000000..5a607155a --- /dev/null +++ b/libtock-sync/crypto/syscalls/sha_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for an SHA hash to finish. +returncode_t libtocksync_sha_yield_wait_for(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock/crypto/sha.h b/libtock/crypto/sha.h index 015f8253c..8545be469 100644 --- a/libtock/crypto/sha.h +++ b/libtock/crypto/sha.h @@ -2,6 +2,7 @@ #include "../tock.h" #include "syscalls/sha_syscalls.h" +#include "sha_types.h" #ifdef __cplusplus extern "C" { @@ -12,13 +13,6 @@ extern "C" { // - `arg1` (`returncode_t`): Status from computing the hash. typedef void (*libtock_sha_callback_hash)(returncode_t); -typedef enum { - LIBTOCK_SHA256 = 0, - LIBTOCK_SHA384 = 1, - LIBTOCK_SHA512 = 2, -} libtock_sha_algorithm_t; - - // Compute a SHA hash over `input_buffer` and store the hash in `hash_buffer`. // diff --git a/libtock/crypto/sha_types.h b/libtock/crypto/sha_types.h new file mode 100644 index 000000000..de5c32b53 --- /dev/null +++ b/libtock/crypto/sha_types.h @@ -0,0 +1,17 @@ +#pragma once + +#include "../tock.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + LIBTOCK_SHA256 = 0, + LIBTOCK_SHA384 = 1, + LIBTOCK_SHA512 = 2, +} libtock_sha_algorithm_t; + +#ifdef __cplusplus +} +#endif From e3cc87394d605c5c193574a1b16fdb9b740c80e2 Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Wed, 9 Jul 2025 21:18:57 -0400 Subject: [PATCH 2/9] ywf: screen --- libtock-sync/display/screen.c | 145 ++++++------------ libtock-sync/display/screen.h | 7 +- .../display/syscalls/screen_syscalls.c | 29 ++++ .../display/syscalls/screen_syscalls.h | 17 ++ libtock/display/screen.h | 18 +-- libtock/display/screen_types.h | 26 ++++ 6 files changed, 130 insertions(+), 112 deletions(-) create mode 100644 libtock-sync/display/syscalls/screen_syscalls.c create mode 100644 libtock-sync/display/syscalls/screen_syscalls.h create mode 100644 libtock/display/screen_types.h diff --git a/libtock-sync/display/screen.c b/libtock-sync/display/screen.c index 6fef20819..7b072184e 100644 --- a/libtock-sync/display/screen.c +++ b/libtock-sync/display/screen.c @@ -1,167 +1,124 @@ #include "screen.h" -struct screen_done { - returncode_t ret; - bool fired; -}; -struct screen_format { - libtock_screen_format_t format; - returncode_t ret; - bool fired; -}; -struct screen_rotation { - int rotation; - returncode_t ret; - bool fired; -}; - -static struct screen_done result; -static struct screen_format result_format; -static struct screen_rotation result_rotation; - - -static void screen_cb_done(returncode_t ret) { - result.ret = ret; - result.fired = true; -} - -static void screen_cb_format(returncode_t ret, libtock_screen_format_t format) { - result_format.ret = ret; - result_format.format = format; - result_format.fired = true; +static returncode_t screen_set_color(uint8_t* buffer, int buffer_len, int position, size_t color) { + // TODO color mode + if (position < buffer_len - 2) { + buffer[position * 2] = (color >> 8) & 0xFF; + buffer[position * 2 + 1] = color & 0xFF; + return RETURNCODE_SUCCESS; + } else { + return RETURNCODE_ESIZE; + } } -static void screen_cb_rotation(returncode_t ret, libtock_screen_rotation_t rotation) { - result_rotation.ret = ret; - result_rotation.rotation = rotation; - result_rotation.fired = true; -} returncode_t libtocksync_screen_set_brightness(uint32_t brightness) { returncode_t ret; - result.fired = false; - - ret = libtock_screen_set_brightness(brightness, screen_cb_done); + ret = libtock_screen_command_set_brightness(brightness); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - return result.ret; + ret = libtocksync_screen_yield_wait_for(); + return ret; } returncode_t libtocksync_screen_invert_on(void) { returncode_t ret; - result.fired = false; - - ret = libtock_screen_invert_on(screen_cb_done); + ret = libtock_screen_command_invert_on(); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - return result.ret; + ret = libtocksync_screen_yield_wait_for(); + return ret; } returncode_t libtocksync_screen_invert_off(void) { returncode_t ret; - result.fired = false; - - ret = libtock_screen_invert_on(screen_cb_done); + ret = libtock_screen_command_invert_off(); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - return result.ret; + ret = libtocksync_screen_yield_wait_for(); + return ret; } returncode_t libtocksync_screen_get_pixel_format(libtock_screen_format_t* format) { returncode_t ret; - result_format.fired = false; - - ret = libtock_screen_get_pixel_format(screen_cb_format); + ret = libtock_screen_command_get_pixel_format(); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result_format.fired); - if (result_format.ret != RETURNCODE_SUCCESS) return result_format.ret; + ret = libtocksync_screen_yield_wait_for_format(format); + return ret; +} - *format = result_format.format; - return RETURNCODE_SUCCESS; +returncode_t libtocksync_screen_get_resolution(uint32_t* width, uint32_t* height) { + return libtock_screen_command_get_resolution(width, height); } returncode_t libtocksync_screen_get_rotation(libtock_screen_rotation_t* rotation) { returncode_t ret; - result_rotation.fired = false; - - ret = libtock_screen_get_rotation(screen_cb_rotation); + ret = libtock_screen_command_get_rotation(); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result_rotation.fired); - if (result_rotation.ret != RETURNCODE_SUCCESS) return result_rotation.ret; - - *rotation = result_rotation.rotation; - return RETURNCODE_SUCCESS; + ret = libtocksync_screen_yield_wait_for_rotation(rotation); + return ret; } returncode_t libtocksync_screen_set_rotation(libtock_screen_rotation_t rotation) { returncode_t ret; - result.fired = false; - - ret = libtock_screen_set_rotation(rotation, screen_cb_done); + ret = libtock_screen_command_set_rotation(rotation); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - return result.ret; + ret = libtocksync_screen_yield_wait_for(); + return ret; } returncode_t libtocksync_screen_set_frame(uint16_t x, uint16_t y, uint16_t width, uint16_t height) { returncode_t ret; - result.fired = false; - - ret = libtock_screen_set_frame(x, y, width, height, screen_cb_done); + ret = libtock_screen_command_set_frame(x, y, width, height); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - return result.ret; + ret = libtocksync_screen_yield_wait_for(); + return ret; } returncode_t libtocksync_screen_fill(uint8_t* buffer, int buffer_len, size_t color) { returncode_t ret; - result.fired = false; + ret = screen_set_color(buffer, buffer_len, 0, color); + if (ret != RETURNCODE_SUCCESS) return ret; - ret = libtock_screen_fill(buffer, buffer_len, color, screen_cb_done); + ret = libtock_screen_set_readonly_allow(buffer, buffer_len); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + ret = libtock_screen_command_fill(); + if (ret != RETURNCODE_SUCCESS) goto exit; + + ret = libtocksync_screen_yield_wait_for(); + +exit: + libtock_screen_set_readonly_allow(NULL, 0); - ret = libtock_screen_set_readonly_allow(NULL, 0); return ret; } returncode_t libtocksync_screen_write(uint8_t* buffer, int buffer_len, size_t length) { returncode_t ret; - result.fired = false; - - ret = libtock_screen_write(buffer, buffer_len, length, screen_cb_done); + ret = libtock_screen_set_readonly_allow(buffer, buffer_len); if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + ret = libtock_screen_command_write(length); + if (ret != RETURNCODE_SUCCESS) goto exit; + + ret = libtocksync_screen_yield_wait_for(); + +exit: + libtock_screen_set_readonly_allow(NULL, 0); - ret = libtock_screen_set_readonly_allow(NULL, 0); return ret; } diff --git a/libtock-sync/display/screen.h b/libtock-sync/display/screen.h index de0f1d800..3a5fa38e9 100644 --- a/libtock-sync/display/screen.h +++ b/libtock-sync/display/screen.h @@ -1,8 +1,10 @@ #pragma once -#include +#include #include +#include "syscalls/screen_syscalls.h" + #ifdef __cplusplus extern "C" { #endif @@ -19,6 +21,9 @@ returncode_t libtocksync_screen_invert_off(void); // Get the current pixel format used by the screen. returncode_t libtocksync_screen_get_pixel_format(libtock_screen_format_t* format); +// Get the current screen resolution. +returncode_t libtocksync_screen_get_resolution(uint32_t* width, uint32_t* height); + // Get the current screen rotation. returncode_t libtocksync_screen_get_rotation(libtock_screen_rotation_t* rotation); diff --git a/libtock-sync/display/syscalls/screen_syscalls.c b/libtock-sync/display/syscalls/screen_syscalls.c new file mode 100644 index 000000000..8e9383c5e --- /dev/null +++ b/libtock-sync/display/syscalls/screen_syscalls.c @@ -0,0 +1,29 @@ +#include "screen_syscalls.h" + +returncode_t libtocksync_screen_yield_wait_for(void) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_SCREEN, 0); + + int status = tock_status_to_returncode((statuscode_t) ret.data0); + return (returncode_t) status; +} + +returncode_t libtocksync_screen_yield_wait_for_format(libtock_screen_format_t* format) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_SCREEN, 0); + + *format = (libtock_screen_format_t) ret.data1; + + int status = tock_status_to_returncode((statuscode_t) ret.data0); + return (returncode_t) status; +} + +returncode_t libtocksync_screen_yield_wait_for_rotation(libtock_screen_rotation_t* rotation) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_SCREEN, 0); + + *rotation = (libtock_screen_rotation_t) ret.data1; + + int status = tock_status_to_returncode((statuscode_t) ret.data0); + return (returncode_t) status; +} diff --git a/libtock-sync/display/syscalls/screen_syscalls.h b/libtock-sync/display/syscalls/screen_syscalls.h new file mode 100644 index 000000000..ff8f5b823 --- /dev/null +++ b/libtock-sync/display/syscalls/screen_syscalls.h @@ -0,0 +1,17 @@ +#pragma once + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +returncode_t libtocksync_screen_yield_wait_for(void); +returncode_t libtocksync_screen_yield_wait_for_format(libtock_screen_format_t* format); +returncode_t libtocksync_screen_yield_wait_for_rotation(libtock_screen_rotation_t* rotation); + +#ifdef __cplusplus +} +#endif diff --git a/libtock/display/screen.h b/libtock/display/screen.h index 6a0408717..a46e80f38 100644 --- a/libtock/display/screen.h +++ b/libtock/display/screen.h @@ -2,6 +2,7 @@ #include "../tock.h" #include "syscalls/screen_syscalls.h" +#include "screen_types.h" #ifdef __cplusplus extern "C" { @@ -9,23 +10,6 @@ extern "C" { #define DRIVER_NUM_SCREEN 0x90001 -// Supported pixel formats. -typedef enum { - MONO =0, - RGB_233 =1, - RGB_565 =2, - RGB_888 =3, - ARGB_8888=4, -} libtock_screen_format_t; - -// Supported screen rotations. -typedef enum { - ROTATION_NORMAL=0, - ROTATION_90 =1, - ROTATION_180 =2, - ROTATION_270 =3, -} libtock_screen_rotation_t; - // Callback when an operation has completed. // // This callback is used for several operations, but is generic as it only diff --git a/libtock/display/screen_types.h b/libtock/display/screen_types.h new file mode 100644 index 000000000..a1d362b93 --- /dev/null +++ b/libtock/display/screen_types.h @@ -0,0 +1,26 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +// Supported pixel formats. +typedef enum { + MONO =0, + RGB_233 =1, + RGB_565 =2, + RGB_888 =3, + ARGB_8888=4, +} libtock_screen_format_t; + +// Supported screen rotations. +typedef enum { + ROTATION_NORMAL=0, + ROTATION_90 =1, + ROTATION_180 =2, + ROTATION_270 =3, +} libtock_screen_rotation_t; + +#ifdef __cplusplus +} +#endif From b2a2e2007a80f0f57345b55a97bcc4654956676f Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Wed, 9 Jul 2025 21:19:10 -0400 Subject: [PATCH 3/9] examples: screen: update to new libtock-sync --- examples/tests/screen/sierpinski_carpet/main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/tests/screen/sierpinski_carpet/main.c b/examples/tests/screen/sierpinski_carpet/main.c index 67dad4ca9..f2a0a802f 100644 --- a/examples/tests/screen/sierpinski_carpet/main.c +++ b/examples/tests/screen/sierpinski_carpet/main.c @@ -42,7 +42,7 @@ int main(void) { uint32_t width, height; - err = libtock_screen_get_resolution(&width, &height); + err = libtocksync_screen_get_resolution(&width, &height); if (err != RETURNCODE_SUCCESS) return -1; // Make width smaller of width and height. From 3a009591453f870c07adb6a809c85d69e59e7c77 Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Thu, 10 Jul 2025 17:22:09 -0400 Subject: [PATCH 4/9] ywf: buttons --- libtock-sync/interface/button.c | 33 +++++-------------- libtock-sync/interface/button.h | 3 +- .../interface/syscalls/button_syscalls.c | 11 +++++++ .../interface/syscalls/button_syscalls.h | 18 ++++++++++ 4 files changed, 39 insertions(+), 26 deletions(-) create mode 100644 libtock-sync/interface/syscalls/button_syscalls.c create mode 100644 libtock-sync/interface/syscalls/button_syscalls.h diff --git a/libtock-sync/interface/button.c b/libtock-sync/interface/button.c index 201701e0d..715a47ba2 100644 --- a/libtock-sync/interface/button.c +++ b/libtock-sync/interface/button.c @@ -1,36 +1,19 @@ #include "button.h" -struct data { - bool fired; - bool pressed; - int button_num; - returncode_t result; -}; - -static struct data result = { .fired = false }; - - -static void button_cb(returncode_t ret, int button_num, bool pressed) { - result.fired = true; - result.pressed = pressed; - result.button_num = button_num; - result.result = ret; -} - - returncode_t libtocksync_button_wait_for_press(int button_num) { - returncode_t err; - result.fired = false; + returncode_t ret; - err = libtock_button_notify_on_press(button_num, button_cb); - if (err != RETURNCODE_SUCCESS) return err; + ret = libtock_button_command_enable_interrupt(button_num); + if (ret != RETURNCODE_SUCCESS) return ret; // Wait for the callback and for the button to be pressed. + int index; + bool pressed; while (true) { - yield_for(&result.fired); - if (result.result != RETURNCODE_SUCCESS) return result.result; + ret = libtocksync_button_yield_wait_for(&index, &pressed); + if (ret != RETURNCODE_SUCCESS) return ret; - if (result.pressed && result.button_num == button_num) { + if (pressed && index == button_num) { break; } } diff --git a/libtock-sync/interface/button.h b/libtock-sync/interface/button.h index e6c17a47e..8c1897eae 100644 --- a/libtock-sync/interface/button.h +++ b/libtock-sync/interface/button.h @@ -1,8 +1,9 @@ #pragma once -#include #include +#include "syscalls/button_syscalls.h" + #ifdef __cplusplus extern "C" { #endif diff --git a/libtock-sync/interface/syscalls/button_syscalls.c b/libtock-sync/interface/syscalls/button_syscalls.c new file mode 100644 index 000000000..af848313a --- /dev/null +++ b/libtock-sync/interface/syscalls/button_syscalls.c @@ -0,0 +1,11 @@ +#include "button_syscalls.h" + +returncode_t libtocksync_button_yield_wait_for(int* button_index, bool* pressed) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_BUTTON, 0); + + *button_index = (int) ret.data0; + *pressed = ret.data1 == 1; + + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/interface/syscalls/button_syscalls.h b/libtock-sync/interface/syscalls/button_syscalls.h new file mode 100644 index 000000000..3db9b2481 --- /dev/null +++ b/libtock-sync/interface/syscalls/button_syscalls.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a button upcall. +// +// - `button_index`: Button index. +// - `pressed`: True if pressed, false otherwise. +returncode_t libtocksync_button_yield_wait_for(int* button_index, bool* pressed); + +#ifdef __cplusplus +} +#endif From de470b81c68c09f36d130dc374f1d4fe9570545f Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Thu, 10 Jul 2025 17:32:15 -0400 Subject: [PATCH 5/9] ywf: buzzer --- libtock-sync/interface/buzzer.c | 20 +--- libtock-sync/interface/buzzer.h | 5 +- .../interface/syscalls/buzzer_syscalls.c | 6 ++ .../interface/syscalls/buzzer_syscalls.h | 15 +++ libtock/interface/buzzer.h | 1 + libtock/interface/buzzer_types.h | 99 +++++++++++++++++++ 6 files changed, 129 insertions(+), 17 deletions(-) create mode 100644 libtock-sync/interface/syscalls/buzzer_syscalls.c create mode 100644 libtock-sync/interface/syscalls/buzzer_syscalls.h create mode 100644 libtock/interface/buzzer_types.h diff --git a/libtock-sync/interface/buzzer.c b/libtock-sync/interface/buzzer.c index ae08e4a8e..45e17ff44 100644 --- a/libtock-sync/interface/buzzer.c +++ b/libtock-sync/interface/buzzer.c @@ -1,24 +1,12 @@ #include "buzzer.h" -struct data { - bool fired; -}; - -static struct data result = { .fired = false }; - - -static void buzzer_cb(void) { - result.fired = true; -} - returncode_t libtocksync_buzzer_tone(uint32_t frequency_hz, uint32_t duration_ms) { - int err; - result.fired = false; + returncode_t ret; - err = libtock_buzzer_tone(frequency_hz, duration_ms, buzzer_cb); - if (err != RETURNCODE_SUCCESS) return err; + ret = libtock_buzzer_command_tone(frequency_hz, duration_ms); + if (ret != RETURNCODE_SUCCESS) return ret; // Wait for the callback meaning the tone is finished. - yield_for(&result.fired); + libtocksync_buzzer_yield_wait_for(); return RETURNCODE_SUCCESS; } diff --git a/libtock-sync/interface/buzzer.h b/libtock-sync/interface/buzzer.h index 2b775acb6..63424e2a6 100644 --- a/libtock-sync/interface/buzzer.h +++ b/libtock-sync/interface/buzzer.h @@ -1,8 +1,11 @@ #pragma once -#include +#include +#include #include +#include "syscalls/buzzer_syscalls.h" + #ifdef __cplusplus extern "C" { #endif diff --git a/libtock-sync/interface/syscalls/buzzer_syscalls.c b/libtock-sync/interface/syscalls/buzzer_syscalls.c new file mode 100644 index 000000000..9a9faac98 --- /dev/null +++ b/libtock-sync/interface/syscalls/buzzer_syscalls.c @@ -0,0 +1,6 @@ +#include "buzzer_syscalls.h" + +returncode_t libtocksync_buzzer_yield_wait_for(void) { + yield_wait_for(DRIVER_NUM_BUZZER, 0); + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/interface/syscalls/buzzer_syscalls.h b/libtock-sync/interface/syscalls/buzzer_syscalls.h new file mode 100644 index 000000000..f65c55e2c --- /dev/null +++ b/libtock-sync/interface/syscalls/buzzer_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for buzzer event to start. +returncode_t libtocksync_buzzer_yield_wait_for(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock/interface/buzzer.h b/libtock/interface/buzzer.h index a96056747..0e4cc08d7 100644 --- a/libtock/interface/buzzer.h +++ b/libtock/interface/buzzer.h @@ -2,6 +2,7 @@ #include "../tock.h" #include "syscalls/buzzer_syscalls.h" +#include "buzzer_types.h" #ifdef __cplusplus extern "C" { diff --git a/libtock/interface/buzzer_types.h b/libtock/interface/buzzer_types.h new file mode 100644 index 000000000..e6aed4a7b --- /dev/null +++ b/libtock/interface/buzzer_types.h @@ -0,0 +1,99 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#define NOTE_B0 31 +#define NOTE_C1 33 +#define NOTE_CS1 35 +#define NOTE_D1 37 +#define NOTE_DS1 39 +#define NOTE_E1 41 +#define NOTE_F1 44 +#define NOTE_FS1 46 +#define NOTE_G1 49 +#define NOTE_GS1 52 +#define NOTE_A1 55 +#define NOTE_AS1 58 +#define NOTE_B1 62 +#define NOTE_C2 65 +#define NOTE_CS2 69 +#define NOTE_D2 73 +#define NOTE_DS2 78 +#define NOTE_E2 82 +#define NOTE_F2 87 +#define NOTE_FS2 93 +#define NOTE_G2 98 +#define NOTE_GS2 104 +#define NOTE_A2 110 +#define NOTE_AS2 117 +#define NOTE_B2 123 +#define NOTE_C3 131 +#define NOTE_CS3 139 +#define NOTE_D3 147 +#define NOTE_DS3 156 +#define NOTE_E3 165 +#define NOTE_F3 175 +#define NOTE_FS3 185 +#define NOTE_G3 196 +#define NOTE_GS3 208 +#define NOTE_A3 220 +#define NOTE_AS3 233 +#define NOTE_B3 247 +#define NOTE_C4 262 +#define NOTE_CS4 277 +#define NOTE_D4 294 +#define NOTE_DS4 311 +#define NOTE_E4 330 +#define NOTE_F4 349 +#define NOTE_FS4 370 +#define NOTE_G4 392 +#define NOTE_GS4 415 +#define NOTE_A4 440 +#define NOTE_AS4 466 +#define NOTE_B4 494 +#define NOTE_C5 523 +#define NOTE_CS5 554 +#define NOTE_D5 587 +#define NOTE_DS5 622 +#define NOTE_E5 659 +#define NOTE_F5 698 +#define NOTE_FS5 740 +#define NOTE_G5 784 +#define NOTE_GS5 831 +#define NOTE_A5 880 +#define NOTE_AS5 932 +#define NOTE_B5 988 +#define NOTE_C6 1047 +#define NOTE_CS6 1109 +#define NOTE_D6 1175 +#define NOTE_DS6 1245 +#define NOTE_E6 1319 +#define NOTE_F6 1397 +#define NOTE_FS6 1480 +#define NOTE_G6 1568 +#define NOTE_GS6 1661 +#define NOTE_A6 1760 +#define NOTE_AS6 1865 +#define NOTE_B6 1976 +#define NOTE_C7 2093 +#define NOTE_CS7 2217 +#define NOTE_D7 2349 +#define NOTE_DS7 2489 +#define NOTE_E7 2637 +#define NOTE_F7 2794 +#define NOTE_FS7 2960 +#define NOTE_G7 3136 +#define NOTE_GS7 3322 +#define NOTE_A7 3520 +#define NOTE_AS7 3729 +#define NOTE_B7 3951 +#define NOTE_C8 4186 +#define NOTE_CS8 4435 +#define NOTE_D8 4699 +#define NOTE_DS8 4978 + +#ifdef __cplusplus +} +#endif From 2898a2d34662df6b04e4f4ab1aa2f1c9bee8d8b0 Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Thu, 10 Jul 2025 17:45:14 -0400 Subject: [PATCH 6/9] ywf: console --- libtock-sync/interface/console.c | 57 ++++++++----------- libtock-sync/interface/console.h | 5 +- .../interface/syscalls/console_syscalls.c | 19 +++++++ .../interface/syscalls/console_syscalls.h | 15 +++++ libtock-sync/sys.c | 4 +- libtock/interface/console.h | 4 +- 6 files changed, 64 insertions(+), 40 deletions(-) create mode 100644 libtock-sync/interface/syscalls/console_syscalls.c create mode 100644 libtock-sync/interface/syscalls/console_syscalls.h diff --git a/libtock-sync/interface/console.c b/libtock-sync/interface/console.c index ec4ef2e28..510ef1ba6 100644 --- a/libtock-sync/interface/console.c +++ b/libtock-sync/interface/console.c @@ -1,45 +1,36 @@ -#include "console.h" +#include -struct console_result { - bool fired; - int length; - returncode_t result; -}; +#include "console.h" +#include "syscalls/console_syscalls.h" -static struct console_result result = { .fired = false }; +returncode_t libtocksync_console_write(const uint8_t* buffer, uint32_t length, uint32_t* written) { + returncode_t ret; -static void generic_cb(returncode_t ret, uint32_t length) { - result.length = length; - result.fired = true; - result.result = ret; -} + ret = libtock_console_set_read_allow(buffer, length); + if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_console_set_read_allow(NULL, 0); + }; -returncode_t libtocksync_console_write(const uint8_t* buffer, uint32_t length, int* written) { - int err; - result.fired = false; + ret = libtock_console_command_write(length); + if (ret != RETURNCODE_SUCCESS) return ret; - err = libtock_console_write(buffer, length, &generic_cb); - if (err != RETURNCODE_SUCCESS) return err; + ret = libtocksync_console_yield_wait_for_write(written); - // Wait for the callback. - yield_for(&result.fired); - if (result.result != RETURNCODE_SUCCESS) return result.result; - - *written = result.length; - return RETURNCODE_SUCCESS; + return ret; } -returncode_t libtocksync_console_read(uint8_t* buffer, uint32_t length, int* read) { - int err; - result.fired = false; +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); + }; - err = libtock_console_read(buffer, length, &generic_cb); - if (err != RETURNCODE_SUCCESS) return err; + ret = libtock_console_command_read(length); + if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - if (result.result != RETURNCODE_SUCCESS) return result.result; + ret = libtocksync_console_yield_wait_for_write(read); - *read = result.length; - return RETURNCODE_SUCCESS; + return ret; } diff --git a/libtock-sync/interface/console.h b/libtock-sync/interface/console.h index 7135e5a11..03c8b961a 100644 --- a/libtock-sync/interface/console.h +++ b/libtock-sync/interface/console.h @@ -1,15 +1,14 @@ #pragma once -#include #include #ifdef __cplusplus extern "C" { #endif -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 } diff --git a/libtock-sync/interface/syscalls/console_syscalls.c b/libtock-sync/interface/syscalls/console_syscalls.c new file mode 100644 index 000000000..88ee29a3e --- /dev/null +++ b/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; +} diff --git a/libtock-sync/interface/syscalls/console_syscalls.h b/libtock-sync/interface/syscalls/console_syscalls.h new file mode 100644 index 000000000..44365ba71 --- /dev/null +++ b/libtock-sync/interface/syscalls/console_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#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 diff --git a/libtock-sync/sys.c b/libtock-sync/sys.c index a26a1cafd..45c59e356 100644 --- a/libtock-sync/sys.c +++ b/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; } diff --git a/libtock/interface/console.h b/libtock/interface/console.h index 1a7084c2f..0860303d1 100644 --- a/libtock/interface/console.h +++ b/libtock/interface/console.h @@ -9,12 +9,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); returncode_t libtock_console_write(const uint8_t* buffer, uint32_t len, libtock_console_callback_write cb); From bb7d92a0e32ffeb19ea81d2268caeaa0f0c1acd6 Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Tue, 15 Jul 2025 11:58:55 -0700 Subject: [PATCH 7/9] ywf: usb_keyboard_hid --- .../syscalls/usb_keyboard_hid_syscalls.c | 10 ++++++ .../syscalls/usb_keyboard_hid_syscalls.h | 13 ++++++++ libtock-sync/interface/usb_keyboard_hid.c | 33 +++++++------------ 3 files changed, 35 insertions(+), 21 deletions(-) create mode 100644 libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.c create mode 100644 libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.h diff --git a/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.c b/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.c new file mode 100644 index 000000000..849cc1c5b --- /dev/null +++ b/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.c @@ -0,0 +1,10 @@ +#include + +#include "usb_keyboard_hid_syscalls.h" + +returncode_t libtocksync_usb_keyboard_hid_yield_wait_for(void) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_USB_KEYBOARD_HID, 0); + + return (returncode_t) ret.data0; +} diff --git a/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.h b/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.h new file mode 100644 index 000000000..ac85f4978 --- /dev/null +++ b/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.h @@ -0,0 +1,13 @@ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +returncode_t libtocksync_usb_keyboard_hid_yield_wait_for(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/interface/usb_keyboard_hid.c b/libtock-sync/interface/usb_keyboard_hid.c index ff411d4e1..6613d2a25 100644 --- a/libtock-sync/interface/usb_keyboard_hid.c +++ b/libtock-sync/interface/usb_keyboard_hid.c @@ -1,33 +1,24 @@ #include #include "usb_keyboard_hid.h" +#include "syscalls/usb_keyboard_hid_syscalls.h" -struct usb_keyboard_hid_result { - bool fired; - returncode_t ret; -}; - -static struct usb_keyboard_hid_result result = {.fired = false}; - -static void usb_keyboard_hil_cb(returncode_t ret) { - result.fired = true; - result.ret = ret; -} - returncode_t libtocksync_usb_keyboard_hid_send(uint8_t* buffer, uint32_t len) { - int err; - result.fired = false; + int ret; - err = libtock_usb_keyboard_hid_send(buffer, len, usb_keyboard_hil_cb); - if (err != RETURNCODE_SUCCESS) return err; + ret = libtock_usb_keyboard_hid_set_readwrite_allow_send_buffer(buffer, len); + if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_usb_keyboard_hid_set_readwrite_allow_send_buffer(NULL, 0); + }; + + ret = libtock_usb_keyboard_hid_command_send(); + if (ret != RETURNCODE_SUCCESS) return ret; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + // Wait for the operation. + ret = libtocksync_usb_keyboard_hid_yield_wait_for(); - err = libtock_usb_keyboard_hid_set_readwrite_allow_send_buffer(NULL, 0); - return err; + return ret; } static int to_hid_keycode(char c, uint8_t* modifier, uint8_t* key) { From b1f222aa337f2477cc20ae1c3ad99a5fc8bf0f83 Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Thu, 14 Aug 2025 15:42:37 +0200 Subject: [PATCH 8/9] ywf: ieee802154 --- libtock-sync/net/ieee802154.c | 102 ++++++++---------- libtock-sync/net/ieee802154.h | 7 +- .../net/syscalls/ieee802154_syscalls.c | 24 +++++ .../net/syscalls/ieee802154_syscalls.h | 14 +++ 4 files changed, 89 insertions(+), 58 deletions(-) create mode 100644 libtock-sync/net/syscalls/ieee802154_syscalls.c create mode 100644 libtock-sync/net/syscalls/ieee802154_syscalls.h diff --git a/libtock-sync/net/ieee802154.c b/libtock-sync/net/ieee802154.c index 0a9d0ae5d..1b79ea285 100644 --- a/libtock-sync/net/ieee802154.c +++ b/libtock-sync/net/ieee802154.c @@ -3,86 +3,78 @@ #include #include "ieee802154.h" -struct ieee802154_receive_data { - bool fired; - int pan; - int src_addr; - int dest_addr; -}; - -static struct ieee802154_receive_data receive_result = { .fired = false }; - -struct ieee802154_send_data { - bool fired; - bool acked; - returncode_t ret; -}; - -static struct ieee802154_send_data send_result = { .fired = false }; -static struct ieee802154_send_data send_result_raw = { .fired = false }; -static void ieee802154_receive_done_cb(int pan, int src_addr, int dest_addr) { - receive_result.fired = true; - receive_result.pan = pan; - receive_result.src_addr = src_addr; - receive_result.dest_addr = dest_addr; -} - -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(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, security_level_t level, key_id_mode_t key_id_mode, uint8_t* key_id, const uint8_t* payload, - uint8_t len) { - send_result.fired = false; + uint8_t len, + bool* acked) { + // Setup parameters in CFG + BUF_CFG[0] = level; + BUF_CFG[1] = key_id_mode; + int bytes = libtock_ieee802154_key_id_bytes(key_id_mode); + if (bytes > 0) { + memcpy(BUF_CFG + 2, key_id, bytes); + } - returncode_t ret = libtock_ieee802154_send(addr, level, key_id_mode, key_id, payload, len, ieee802154_send_done_cb); + // Allow CFG buffer to the kernel + returncode_t ret = libtock_ieee802154_set_readwrite_allow_cfg((void*) BUF_CFG, 11); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_ieee802154_set_readwrite_allow_cfg(NULL, 0); + }; - // Wait for the frame to be sent - yield_for(&send_result.fired); + // Allow payload buffer to the kernel + ret = libtock_ieee802154_set_readonly_allow((void*) payload, len); + if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_ieee802154_set_readonly_allow(NULL, 0); + }; + + // Issue the send command and wait for the transmission to be done. + ret = libtock_ieee802154_command_send(addr); + if (ret != RETURNCODE_SUCCESS) return ret; - return send_result.ret; + ret = libtocksync_ieee802154_yield_wait_for_transmit(acked); + return ret; } -returncode_t libtocksync_ieee802154_send_raw( - const uint8_t* payload, - uint8_t len) { - send_result_raw.fired = false; +returncode_t libtocksync_ieee802154_send_raw(const uint8_t* payload, + uint8_t len, + bool* acked) { + returncode_t ret; - returncode_t ret = libtock_ieee802154_send_raw(payload, len, ieee802154_send_raw_done_cb); + // Setup parameters in ALLOW_RO_TX. + ret = libtock_ieee802154_set_readonly_allow((void*) payload, len); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_ieee802154_set_readonly_allow(NULL, 0); + }; - yield_for(&send_result_raw.fired); + ret = libtock_ieee802154_command_send_raw(); + if (ret != RETURNCODE_SUCCESS) return ret; - return send_result_raw.ret; + ret = libtocksync_ieee802154_yield_wait_for_transmit(acked); + return ret; } + returncode_t libtocksync_ieee802154_receive(const libtock_ieee802154_rxbuf* frame) { - receive_result.fired = false; + returncode_t ret; - returncode_t ret = libtock_ieee802154_receive(frame, ieee802154_receive_done_cb); + // Provide the ring buffer to the kernel + ret = libtock_ieee802154_set_readwrite_allow_rx((uint8_t*) frame, libtock_ieee802154_RING_BUFFER_LEN); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_ieee802154_set_readwrite_allow_rx(NULL, 0); + }; - // Wait for a frame - yield_for(&receive_result.fired); - - // receive upcall is only scheduled by the kernel if a frame is successfully received - return RETURNCODE_SUCCESS; + int pans; + int dst_addr; + int src_addr; + ret = libtocksync_ieee802154_yield_wait_for_receive(&pans, &dst_addr, &src_addr); + return ret; } returncode_t libtocksync_ieee802154_up(void) { diff --git a/libtock-sync/net/ieee802154.h b/libtock-sync/net/ieee802154.h index ce8892357..f6b2c2de6 100644 --- a/libtock-sync/net/ieee802154.h +++ b/libtock-sync/net/ieee802154.h @@ -1,6 +1,5 @@ #pragma once -#include #include #ifdef __cplusplus @@ -25,7 +24,8 @@ returncode_t libtocksync_ieee802154_send(uint16_t addr, key_id_mode_t key_id_mode, uint8_t* key_id, const uint8_t* payload, - uint8_t len); + uint8_t len, + bool* acked); // Sends an IEEE 802.15.4 frame synchronously. This is an alternative and contemporary // to the `libtock_ieee802154_send` function. This provides an interface for userprocesses to @@ -35,7 +35,8 @@ returncode_t libtocksync_ieee802154_send(uint16_t addr, // `payload` (in): Buffer containing the desired frame payload. // `len` (in): Length of frame payload. returncode_t libtocksync_ieee802154_send_raw(const uint8_t* payload, - uint8_t len); + uint8_t len, + bool* acked); // Waits synchronously for an IEEE 802.15.4 frame. // `frame` (in): Buffer in which to put the full IEEE 802.15.4 frame data. Note diff --git a/libtock-sync/net/syscalls/ieee802154_syscalls.c b/libtock-sync/net/syscalls/ieee802154_syscalls.c new file mode 100644 index 000000000..a88bff45a --- /dev/null +++ b/libtock-sync/net/syscalls/ieee802154_syscalls.c @@ -0,0 +1,24 @@ +#include + +#include "ieee802154_syscalls.h" + + +returncode_t libtocksync_ieee802154_yield_wait_for_receive(int* pans, int* dst_addr, int* src_addr) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_IEEE802154, 0); + + *pans = ret.data0; + *dst_addr = ret.data1; + *src_addr = ret.data2; + + return RETURNCODE_SUCCESS; +} + +returncode_t libtocksync_ieee802154_yield_wait_for_transmit(bool* acked) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_IEEE802154, 1); + + *acked = ret.data1 == 1; + + return tock_status_to_returncode(ret.data0); +} diff --git a/libtock-sync/net/syscalls/ieee802154_syscalls.h b/libtock-sync/net/syscalls/ieee802154_syscalls.h new file mode 100644 index 000000000..965014527 --- /dev/null +++ b/libtock-sync/net/syscalls/ieee802154_syscalls.h @@ -0,0 +1,14 @@ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +returncode_t libtocksync_ieee802154_yield_wait_for_receive(int* pans, int* dst_addr, int* src_addr); +returncode_t libtocksync_ieee802154_yield_wait_for_transmit(bool* acked); + +#ifdef __cplusplus +} +#endif From d0b59eae82a66cd47774863b40729554c412d813 Mon Sep 17 00:00:00 2001 From: Brad Campbell Date: Thu, 14 Aug 2025 16:05:52 +0200 Subject: [PATCH 9/9] ywf: lora_phy --- libtock-sync/net/lora_phy.c | 41 ++++++++++--------- libtock-sync/net/lora_phy.h | 1 - libtock-sync/net/syscalls/lora_phy_syscalls.c | 12 ++++++ libtock-sync/net/syscalls/lora_phy_syscalls.h | 13 ++++++ 4 files changed, 46 insertions(+), 21 deletions(-) create mode 100644 libtock-sync/net/syscalls/lora_phy_syscalls.c create mode 100644 libtock-sync/net/syscalls/lora_phy_syscalls.h diff --git a/libtock-sync/net/lora_phy.c b/libtock-sync/net/lora_phy.c index 30288045e..d71419f84 100644 --- a/libtock-sync/net/lora_phy.c +++ b/libtock-sync/net/lora_phy.c @@ -1,38 +1,39 @@ #include "lora_phy.h" -struct lora_phy_spi_data { - bool fired; - returncode_t ret; -}; - -static struct lora_phy_spi_data result = {.fired = false}; - -static void lora_phy_spi_cb(returncode_t ret) { - result.fired = true; - result.ret = ret; -} - returncode_t libtocksync_lora_phy_write(const uint8_t* write, uint32_t len) { - result.fired = false; returncode_t ret; - ret = libtock_lora_phy_write(write, len, lora_phy_spi_cb); + ret = libtock_lora_phy_set_readonly_allow_master_write_buffer(buf, len); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_lora_phy_set_readonly_allow_master_write_buffer(NULL, 0); + }; - yield_for(&result.fired); - return result.ret; + ret = libtock_lora_phy_command_read_write(len); + if (ret != RETURNCODE_SUCCESS) return ret; + + ret = libtocksync_lora_phy_yield_wait_for(); + return ret; } returncode_t libtocksync_lora_phy_read_write(const uint8_t* write, uint8_t* read, uint32_t len) { - result.fired = false; returncode_t ret; - ret = libtock_lora_phy_read_write(write, read, len, lora_phy_spi_cb); + ret = libtock_lora_phy_set_readwrite_allow_master_read_buffer(read, len); + if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_lora_phy_set_readwrite_allow_master_read_buffer(NULL, 0); + }; + + ret = libtock_lora_phy_set_readonly_allow_master_write_buffer(buf, len); + if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_lora_phy_set_readonly_allow_master_write_buffer(NULL, 0); + }; + + ret = libtock_lora_phy_command_read_write(len); if (ret != RETURNCODE_SUCCESS) return ret; - yield_for(&result.fired); - return result.ret; + ret = libtocksync_lora_phy_yield_wait_for(); + return ret; } diff --git a/libtock-sync/net/lora_phy.h b/libtock-sync/net/lora_phy.h index 5ecd7e1a2..3dee2088e 100644 --- a/libtock-sync/net/lora_phy.h +++ b/libtock-sync/net/lora_phy.h @@ -1,6 +1,5 @@ #pragma once -#include #include #ifdef __cplusplus diff --git a/libtock-sync/net/syscalls/lora_phy_syscalls.c b/libtock-sync/net/syscalls/lora_phy_syscalls.c new file mode 100644 index 000000000..e61269b62 --- /dev/null +++ b/libtock-sync/net/syscalls/lora_phy_syscalls.c @@ -0,0 +1,12 @@ +#include + +#include "lora_phy_syscalls.h" + + +returncode_t libtocksync_lora_phy_yield_wait_for(void) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_LORA_PHY_SPI, 0); + + return RETURNCODE_SUCCESS; +} + diff --git a/libtock-sync/net/syscalls/lora_phy_syscalls.h b/libtock-sync/net/syscalls/lora_phy_syscalls.h new file mode 100644 index 000000000..df79520e0 --- /dev/null +++ b/libtock-sync/net/syscalls/lora_phy_syscalls.h @@ -0,0 +1,13 @@ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +returncode_t libtocksync_lora_phy_yield_wait_for(void); + +#ifdef __cplusplus +} +#endif