diff --git a/examples/ble-uart/main.c b/examples/ble-uart/main.c index 2a1db7bf2..b00479a3a 100644 --- a/examples/ble-uart/main.c +++ b/examples/ble-uart/main.c @@ -12,9 +12,7 @@ #include #include -#include #include -#include #include "ble_nus.h" #include "nrf.h" @@ -62,7 +60,7 @@ void ble_evt_user_handler(ble_evt_t* p_ble_evt) { // This gets called with the serial data from the BLE central. static void nus_data_handler(ble_nus_t* p_nus, uint8_t* p_data, uint16_t length) { UNUSED_PARAMETER(p_nus); - int bytes_written; + uint32_t bytes_written; // In this app, just print it to the console. libtocksync_console_write(p_data, length, &bytes_written); diff --git a/examples/buttons/main.c b/examples/buttons/main.c index 23339d75b..0d94fb984 100644 --- a/examples/buttons/main.c +++ b/examples/buttons/main.c @@ -1,3 +1,4 @@ +#include #include #include @@ -13,7 +14,7 @@ int main(void) { // Enable interrupts on each button. int count; - err = libtock_button_count(&count); + err = libtocksync_button_count(&count); if (err < 0) return err; for (int i = 0; i < count; i++) { diff --git a/examples/i2c-usb-bridge/main.c b/examples/i2c-usb-bridge/main.c index b0771ee30..0b6aad3d1 100644 --- a/examples/i2c-usb-bridge/main.c +++ b/examples/i2c-usb-bridge/main.c @@ -14,13 +14,13 @@ uint8_t send_buf[DATA_LEN]; 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]; } -static int putnstr(char* str, int len) { - int number_written; +static uint32_t putnstr(char* str, int len) { + uint32_t number_written; libtocksync_console_read((uint8_t*) str, len, &number_written); return number_written; } diff --git a/examples/security_app/main.c b/examples/security_app/main.c index 03f70cf66..04c697fb3 100644 --- a/examples/security_app/main.c +++ b/examples/security_app/main.c @@ -4,10 +4,9 @@ #include #include -#include +#include #include #include -#include typedef struct { bool pir; @@ -44,9 +43,9 @@ int main(void) { // configure pins libtock_gpio_set_interrupt_callback(gpio_cb); - libtock_gpio_enable_input(0, libtock_pull_none); + libtocksync_gpio_enable_input(0, libtock_pull_none); libtock_gpio_enable_interrupt(0, libtock_change); - libtock_gpio_enable_input(1, libtock_pull_up); + libtocksync_gpio_enable_input(1, libtock_pull_up); libtock_gpio_enable_interrupt(1, libtock_change); // configure accelerometer diff --git a/examples/sensors/main.c b/examples/sensors/main.c index bb926a7c1..14545adec 100644 --- a/examples/sensors/main.c +++ b/examples/sensors/main.c @@ -10,7 +10,6 @@ #include #include #include -#include static libtock_alarm_t alarm; static bool light = false; diff --git a/examples/servo/main.c b/examples/servo/main.c index 43ac003bd..ce65618fd 100644 --- a/examples/servo/main.c +++ b/examples/servo/main.c @@ -3,7 +3,6 @@ #include #include -#include int main(void) { diff --git a/examples/tests/console/console/main.c b/examples/tests/console/console/main.c index 61b5f43bc..44a87f3a5 100644 --- a/examples/tests/console/console/main.c +++ b/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]; } diff --git a/examples/tests/console/console_recv_long/main.c b/examples/tests/console/console_recv_long/main.c index 2a3d5afa6..6f53fdf16 100644 --- a/examples/tests/console/console_recv_long/main.c +++ b/examples/tests/console/console_recv_long/main.c @@ -5,7 +5,7 @@ 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); @@ -13,7 +13,7 @@ int main(void) { } 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"); diff --git a/examples/tests/console/console_recv_short/main.c b/examples/tests/console/console_recv_short/main.c index 97a3569ca..5c74a7934 100644 --- a/examples/tests/console/console_recv_short/main.c +++ b/examples/tests/console/console_recv_short/main.c @@ -5,7 +5,7 @@ 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); @@ -13,7 +13,7 @@ int main(void) { } 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"); diff --git a/examples/tests/keyboard_hid/main.c b/examples/tests/keyboard_hid/main.c index 96ef6b518..9a6c05589 100644 --- a/examples/tests/keyboard_hid/main.c +++ b/examples/tests/keyboard_hid/main.c @@ -10,7 +10,7 @@ int main(void) { returncode_t ret; printf("[TEST] USB Keyboard HID\n"); - if (!libtock_usb_keyboard_hid_exists()) { + if (!libtocksync_usb_keyboard_hid_exists()) { printf("No USB keyboard HID on this board!\n"); return -2; } diff --git a/examples/tests/kv/kv_interactive/main.c b/examples/tests/kv/kv_interactive/main.c index 42b4c319f..8cfc16521 100644 --- a/examples/tests/kv/kv_interactive/main.c +++ b/examples/tests/kv/kv_interactive/main.c @@ -4,7 +4,6 @@ #include #include -#include #define KEY_LEN 64 #define DATA_LEN 64 @@ -17,7 +16,7 @@ char read_buf[DATA_LEN]; 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]; } diff --git a/examples/tests/number_guess_game/main.c b/examples/tests/number_guess_game/main.c index 394db999d..686154f6b 100644 --- a/examples/tests/number_guess_game/main.c +++ b/examples/tests/number_guess_game/main.c @@ -8,13 +8,13 @@ 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]; } static int putnstr(const char* str, int len) { - int number_written; + uint32_t number_written; libtocksync_console_read((uint8_t*) str, len, &number_written); return number_written; } diff --git a/examples/tutorials/hotp/hotp_milestone_one/main.c b/examples/tutorials/hotp/hotp_milestone_one/main.c index 5830c38f8..49462ca56 100644 --- a/examples/tutorials/hotp/hotp_milestone_one/main.c +++ b/examples/tutorials/hotp/hotp_milestone_one/main.c @@ -18,6 +18,7 @@ #include // Libtock includes +#include #include #include #include @@ -52,7 +53,7 @@ static void program_new_secret(hotp_key_t* hotp_key) { while (i < 127) { // read next character char c; - int number_read, number_written; + uint32_t number_read, number_written; libtocksync_console_read((uint8_t*) &c, 1, &number_read); // break on enter @@ -121,7 +122,7 @@ int main(void) { // Delay and check if button is still pressed, signalling a "hold" libtocksync_alarm_delay_ms(500); int new_val = 0; - libtock_button_read(btn_num, &new_val); + libtocksync_button_read(btn_num, &new_val); // Handle long presses (program new secret) if (new_val) { diff --git a/examples/tutorials/hotp/hotp_milestone_three/main.c b/examples/tutorials/hotp/hotp_milestone_three/main.c index 33b1065b2..ffb9f912b 100644 --- a/examples/tutorials/hotp/hotp_milestone_three/main.c +++ b/examples/tutorials/hotp/hotp_milestone_three/main.c @@ -12,6 +12,7 @@ #include // Libtock includes +#include #include #include @@ -78,7 +79,7 @@ int main(void) { // Delay and check if button is still pressed, signalling a "hold" libtocksync_alarm_delay_ms(500); int new_val = 0; - libtock_button_read(btn_num, &new_val); + libtocksync_button_read(btn_num, &new_val); // Handle long presses (program new secret) if (new_val) { diff --git a/examples/tutorials/hotp/hotp_milestone_two/main.c b/examples/tutorials/hotp/hotp_milestone_two/main.c index d883b5460..c7a5b14a9 100644 --- a/examples/tutorials/hotp/hotp_milestone_two/main.c +++ b/examples/tutorials/hotp/hotp_milestone_two/main.c @@ -18,10 +18,10 @@ #include // Libtock includes +#include #include #include #include -#include // Local includes #include "base32.h" @@ -120,7 +120,7 @@ int main(void) { // Delay and check if button is still pressed, signalling a "hold" libtocksync_alarm_delay_ms(500); int new_val = 0; - libtock_button_read(btn_num, &new_val); + libtocksync_button_read(btn_num, &new_val); // Handle long presses (program new secret) if (new_val) { diff --git a/examples/tutorials/hotp/hotp_milestone_two/step1.c b/examples/tutorials/hotp/hotp_milestone_two/step1.c index 9167cbba8..5f846732f 100644 --- a/examples/tutorials/hotp/hotp_milestone_two/step1.c +++ b/examples/tutorials/hotp/hotp_milestone_two/step1.c @@ -21,7 +21,7 @@ void program_new_secret(hotp_key_t* hotp_key) { while (i < 127) { // read next character char c; - int number_read, number_written; + uint32_t number_read, number_written; libtocksync_console_read((uint8_t*) &c, 1, &number_read); // break on enter diff --git a/examples/tutorials/hotp/hotp_oracle_complete/main.c b/examples/tutorials/hotp/hotp_oracle_complete/main.c index 0ac0fc959..87d3ea813 100644 --- a/examples/tutorials/hotp/hotp_oracle_complete/main.c +++ b/examples/tutorials/hotp/hotp_oracle_complete/main.c @@ -17,6 +17,7 @@ #include // Libtock includes +#include #include #include #include @@ -153,7 +154,7 @@ static void program_new_secret(int slot_num) { while (i < 127) { // read next character char c; - int number_read, number_written; + uint32_t number_read, number_written; libtocksync_console_read((uint8_t*) &c, 1, &number_read); // break on enter @@ -229,7 +230,7 @@ static void get_next_code_encrypted(int slot_num) { len = 16; } - if (libtock_usb_keyboard_hid_exists()) { + if (libtocksync_usb_keyboard_hid_exists()) { // Write the value to the USB keyboard. int ret = libtocksync_usb_keyboard_hid_send_string(hotp_format_buffer, len); if (ret < 0) { @@ -279,7 +280,7 @@ int main(void) { // Delay and check if button is still pressed, signalling a "hold" libtocksync_alarm_delay_ms(500); int new_val = 0; - libtock_button_read(btn_num, &new_val); + libtocksync_button_read(btn_num, &new_val); // Handle long presses (program new secret) if (new_val) { diff --git a/examples/tutorials/root_of_trust/encryption_service_milestone_three/main.c b/examples/tutorials/root_of_trust/encryption_service_milestone_three/main.c index 899e43688..1a2486923 100644 --- a/examples/tutorials/root_of_trust/encryption_service_milestone_three/main.c +++ b/examples/tutorials/root_of_trust/encryption_service_milestone_three/main.c @@ -10,7 +10,6 @@ #include #include -#include #include "oracle.h" @@ -86,7 +85,7 @@ static int log_to_screen(const char* message) { static size_t request_plaintext(uint8_t* plaintext, size_t size) { char c; - int number_read, number_written; + uint32_t number_read, number_written; printf("Enter plaintext to encrypt:\n"); diff --git a/examples/tutorials/root_of_trust/encryption_service_milestone_two/main.c b/examples/tutorials/root_of_trust/encryption_service_milestone_two/main.c index 9621e3c4b..d64a46eb7 100644 --- a/examples/tutorials/root_of_trust/encryption_service_milestone_two/main.c +++ b/examples/tutorials/root_of_trust/encryption_service_milestone_two/main.c @@ -10,7 +10,6 @@ #include #include -#include #define LOG_WIDTH 32 @@ -83,7 +82,7 @@ static int log_to_screen(const char* message) { static size_t request_plaintext(uint8_t* plaintext, size_t size) { char c; - int number_read, number_written; + uint32_t number_read, number_written; printf("Enter plaintext to encrypt:\n"); diff --git a/examples/witenergy/main.c b/examples/witenergy/main.c index be898f925..1470e0ba8 100644 --- a/examples/witenergy/main.c +++ b/examples/witenergy/main.c @@ -19,7 +19,6 @@ #include #include #include -#include /******************************************************************************* diff --git a/libtock-sync/display/syscalls/text_screen_syscalls.c b/libtock-sync/display/syscalls/text_screen_syscalls.c new file mode 100644 index 000000000..2a1f83b9f --- /dev/null +++ b/libtock-sync/display/syscalls/text_screen_syscalls.c @@ -0,0 +1,18 @@ +#include "text_screen_syscalls.h" + +returncode_t libtocksync_text_screen_yield_wait_for_done(void) { + yield_waitfor_return_t ywf; + ywf = yield_wait_for(DRIVER_NUM_TEXT_SCREEN, 0); + return (returncode_t) ywf.data0; +} + +returncode_t libtocksync_text_screen_yield_wait_for_size(uint32_t* width, uint32_t* height) { + yield_waitfor_return_t ywf; + returncode_t ret; + ywf = yield_wait_for(DRIVER_NUM_TEXT_SCREEN, 0); + ret = (returncode_t) ywf.data0; + if (ret != RETURNCODE_SUCCESS) return ret; + *width = (uint32_t) ywf.data1; + *height = (uint32_t) ywf.data2; + return ret; +} diff --git a/libtock-sync/display/syscalls/text_screen_syscalls.h b/libtock-sync/display/syscalls/text_screen_syscalls.h new file mode 100644 index 000000000..7c1e48221 --- /dev/null +++ b/libtock-sync/display/syscalls/text_screen_syscalls.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a text screen operation to complete. +returncode_t libtocksync_text_screen_yield_wait_for_done(void); + +// Wait for a text screen get size operation to complete. +returncode_t libtocksync_text_screen_yield_wait_for_size(uint32_t* width, uint32_t* height); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/display/text_screen.c b/libtock-sync/display/text_screen.c index 83d001a74..d3ee5445a 100644 --- a/libtock-sync/display/text_screen.c +++ b/libtock-sync/display/text_screen.c @@ -1,119 +1,93 @@ +#include #include +#include "syscalls/text_screen_syscalls.h" #include "text_screen.h" -struct text_screen_data { - bool fired; - returncode_t ret; -}; - -struct text_screen_size_data { - bool fired; - returncode_t ret; - uint32_t width; - uint32_t height; -}; - -static struct text_screen_data result = {.fired = false}; -static struct text_screen_size_data result_size = {.fired = false}; - -static void text_screen_cb(returncode_t ret) { - result.fired = true; - result.ret = ret; -} - -static void text_screen_size_cb(returncode_t ret, uint32_t width, uint32_t height) { - result_size.fired = true; - result_size.ret = ret; - result_size.width = width; - result_size.height = height; -} - -static returncode_t text_screen_op(returncode_t (*op)(void (*)(returncode_t))) { - returncode_t ret; - result.fired = false; - - ret = op(text_screen_cb); - if (ret != RETURNCODE_SUCCESS) return ret; - - yield_for(&result.fired); - return result.ret; -} - bool libtocksync_text_screen_exists(void) { return libtock_text_screen_driver_exists(); } returncode_t libtocksync_text_screen_display_on(void) { - return text_screen_op(libtock_text_screen_display_on); + returncode_t ret; + ret = libtock_text_screen_command_on(); + if (ret != RETURNCODE_SUCCESS) return ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_display_off(void) { - return text_screen_op(libtock_text_screen_display_off); + returncode_t ret; + ret = libtock_text_screen_command_off(); + if (ret != RETURNCODE_SUCCESS) return ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_blink_on(void) { - return text_screen_op(libtock_text_screen_blink_on); + returncode_t ret; + ret = libtock_text_screen_command_blink_on(); + if (ret != RETURNCODE_SUCCESS) return ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_blink_off(void) { - return text_screen_op(libtock_text_screen_blink_off); + returncode_t ret; + ret = libtock_text_screen_command_blink_off(); + if (ret != RETURNCODE_SUCCESS) return ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_show_cursor(void) { - return text_screen_op(libtock_text_screen_show_cursor); + returncode_t ret; + ret = libtock_text_screen_command_show_cursor(); + if (ret != RETURNCODE_SUCCESS) return ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_hide_cursor(void) { - return text_screen_op(libtock_text_screen_hide_cursor); + returncode_t ret; + ret = libtock_text_screen_command_hide_cursor(); + if (ret != RETURNCODE_SUCCESS) return ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_clear(void) { - return text_screen_op(libtock_text_screen_clear); + returncode_t ret; + ret = libtock_text_screen_command_clear(); + if (ret != RETURNCODE_SUCCESS) return ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_home(void) { - return text_screen_op(libtock_text_screen_home); + returncode_t ret; + ret = libtock_text_screen_command_home(); + if (ret != RETURNCODE_SUCCESS) return ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_set_cursor(uint8_t col, uint8_t row) { returncode_t ret; - result.fired = false; - - ret = libtock_text_screen_set_cursor(col, row, text_screen_cb); + ret = libtock_text_screen_command_set_cursor((uint32_t) col, (uint32_t) row); if (ret != RETURNCODE_SUCCESS) return ret; - - yield_for(&result.fired); - return result.ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_write(uint8_t* buffer, uint32_t buffer_len, uint32_t write_len) { returncode_t ret; - result.fired = false; - ret = libtock_text_screen_write(buffer, buffer_len, write_len, text_screen_cb); + ret = libtock_text_screen_set_readonly_allow(buffer, buffer_len); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_text_screen_set_readonly_allow(NULL, 0); + } - yield_for(&result.fired); - - ret = libtock_text_screen_set_readonly_allow(NULL, 0); + ret = libtock_text_screen_command_write(write_len); if (ret != RETURNCODE_SUCCESS) return ret; - return result.ret; + return libtocksync_text_screen_yield_wait_for_done(); } returncode_t libtocksync_text_screen_get_size(uint32_t* width, uint32_t* height) { returncode_t ret; - result.fired = false; - - ret = libtock_text_screen_get_size(text_screen_size_cb); + ret = libtock_text_screen_command_get_size(); if (ret != RETURNCODE_SUCCESS) return ret; - - yield_for(&result_size.fired); - if (result_size.ret != RETURNCODE_SUCCESS) return result_size.ret; - - *width = result_size.width; - *height = result_size.height; - - return result_size.ret; + return libtocksync_text_screen_yield_wait_for_size(width, height); } diff --git a/libtock-sync/display/text_screen.h b/libtock-sync/display/text_screen.h index 56c7680a2..d9313320e 100644 --- a/libtock-sync/display/text_screen.h +++ b/libtock-sync/display/text_screen.h @@ -1,6 +1,5 @@ #pragma once -#include #include #ifdef __cplusplus diff --git a/libtock-sync/interface/button.c b/libtock-sync/interface/button.c index a690e6938..ac5c37535 100644 --- a/libtock-sync/interface/button.c +++ b/libtock-sync/interface/button.c @@ -6,6 +6,14 @@ bool libtocksync_button_exists(void) { return libtock_button_driver_exists(); } +returncode_t libtocksync_button_count(int* count) { + return libtock_button_command_count(count); +} + +returncode_t libtocksync_button_read(int button_num, int* button_value) { + return libtock_button_command_read(button_num, button_value); +} + returncode_t libtocksync_button_wait_for_press(int button_num) { returncode_t ret; diff --git a/libtock-sync/interface/button.h b/libtock-sync/interface/button.h index 3b533b135..049387fb6 100644 --- a/libtock-sync/interface/button.h +++ b/libtock-sync/interface/button.h @@ -10,6 +10,17 @@ extern "C" { bool libtocksync_button_exists(void); +// Set `count` to the number of buttons. +returncode_t libtocksync_button_count(int* count); + +// Read the current button state into `button_value`. +// +// ## Arguments +// +// - `button_num`: The index of the button. +// - `button_value`: Will be set to 1 if button is pressed, 0 otherwise. +returncode_t libtocksync_button_read(int button_num, int* button_value); + // Wait for a specific button to be pressed. // // This blocks until the button has been pressed. Note, this will not return if diff --git a/libtock-sync/interface/console.c b/libtock-sync/interface/console.c index 28945d424..382a9272e 100644 --- a/libtock-sync/interface/console.c +++ b/libtock-sync/interface/console.c @@ -1,51 +1,40 @@ +#include #include #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) { +returncode_t libtocksync_console_write(const uint8_t* buffer, uint32_t length, uint32_t* written) { int err; - result.fired = false; - err = libtock_console_write(buffer, length, &generic_cb); + err = libtock_console_set_read_allow(buffer, length); if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_console_set_read_allow(NULL, 0); + } - // Wait for the callback. - yield_for(&result.fired); - if (result.result != RETURNCODE_SUCCESS) return result.result; + err = libtock_console_command_write((int) length); + if (err != RETURNCODE_SUCCESS) return err; - *written = result.length; - return RETURNCODE_SUCCESS; + err = libtocksync_console_yield_wait_for_write(written); + return err; } -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) { int err; - result.fired = false; - err = libtock_console_read(buffer, length, &generic_cb); + err = libtock_console_set_readwrite_allow(buffer, length); if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_console_set_readwrite_allow(NULL, 0); + } - // Wait for the callback. - yield_for(&result.fired); - if (result.result != RETURNCODE_SUCCESS) return result.result; + err = libtock_console_command_read((int) length); + if (err != RETURNCODE_SUCCESS) return err; - *read = result.length; - return RETURNCODE_SUCCESS; + err = libtocksync_console_yield_wait_for_read(read); + return err; } diff --git a/libtock-sync/interface/console.h b/libtock-sync/interface/console.h index c752000d2..f492523b7 100644 --- a/libtock-sync/interface/console.h +++ b/libtock-sync/interface/console.h @@ -9,9 +9,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 } 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/interface/syscalls/usb_keyboard_hid_syscalls.c b/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.c new file mode 100644 index 000000000..035556262 --- /dev/null +++ b/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.c @@ -0,0 +1,6 @@ +#include "usb_keyboard_hid_syscalls.h" + +returncode_t libtocksync_usb_keyboard_hid_yield_wait_for(void) { + yield_wait_for(DRIVER_NUM_USB_KEYBOARD_HID, 0); + return RETURNCODE_SUCCESS; +} 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..57f92999b --- /dev/null +++ b/libtock-sync/interface/syscalls/usb_keyboard_hid_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a USB keyboard HID send upcall. +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 e2b034c04..f39458411 100644 --- a/libtock-sync/interface/usb_keyboard_hid.c +++ b/libtock-sync/interface/usb_keyboard_hid.c @@ -1,38 +1,27 @@ #include +#include #include +#include "syscalls/usb_keyboard_hid_syscalls.h" #include "usb_keyboard_hid.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; -} - bool libtocksync_usb_keyboard_hid_exists(void) { return libtock_usb_keyboard_hid_driver_exists(); } returncode_t libtocksync_usb_keyboard_hid_send(uint8_t* buffer, uint32_t len) { int err; - result.fired = false; - err = libtock_usb_keyboard_hid_send(buffer, len, usb_keyboard_hil_cb); + err = libtock_usb_keyboard_hid_set_readwrite_allow_send_buffer(buffer, len); if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_usb_keyboard_hid_set_readwrite_allow_send_buffer(NULL, 0); + } - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + err = libtock_usb_keyboard_hid_command_send(); + if (err != RETURNCODE_SUCCESS) return err; - err = libtock_usb_keyboard_hid_set_readwrite_allow_send_buffer(NULL, 0); + err = libtocksync_usb_keyboard_hid_yield_wait_for(); return err; } diff --git a/libtock-sync/interface/usb_keyboard_hid.h b/libtock-sync/interface/usb_keyboard_hid.h index 22180b831..a181bc7b7 100644 --- a/libtock-sync/interface/usb_keyboard_hid.h +++ b/libtock-sync/interface/usb_keyboard_hid.h @@ -1,6 +1,5 @@ #pragma once -#include #include #ifdef __cplusplus diff --git a/libtock-sync/net/ieee802154.c b/libtock-sync/net/ieee802154.c index 86a599090..8ffc18912 100644 --- a/libtock-sync/net/ieee802154.c +++ b/libtock-sync/net/ieee802154.c @@ -1,46 +1,14 @@ #include +#include #include +#include +#include #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; -} +#include "syscalls/ieee802154_syscalls.h" bool libtocksync_ieee802154_exists(void) { return libtock_ieee802154_driver_exists(); @@ -52,42 +20,62 @@ returncode_t libtocksync_ieee802154_send(uint16_t addr, uint8_t* key_id, const uint8_t* payload, uint8_t len) { - send_result.fired = false; + returncode_t ret; + bool acked; + + // Setup the CFG buffer with security parameters. + uint8_t buf_cfg[11]; + 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); + ret = libtock_ieee802154_set_readwrite_allow_cfg(buf_cfg, sizeof(buf_cfg)); 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); + ret = libtock_ieee802154_set_readonly_allow(payload, len); + if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_ieee802154_set_readonly_allow(NULL, 0); + } - return send_result.ret; -} + ret = libtock_ieee802154_command_send(addr); + if (ret != RETURNCODE_SUCCESS) return ret; + ret = libtocksync_ieee802154_yield_wait_for_send(&acked); + return ret; +} returncode_t libtocksync_ieee802154_send_raw( const uint8_t* payload, uint8_t len) { - send_result_raw.fired = false; + returncode_t ret; + bool acked; - returncode_t ret = libtock_ieee802154_send_raw(payload, len, ieee802154_send_raw_done_cb); + ret = libtock_ieee802154_set_readonly_allow(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_send(&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); + ret = libtock_ieee802154_set_readwrite_allow_rx((uint8_t*) frame, libtock_ieee802154_RING_BUFFER_LEN); if (ret != RETURNCODE_SUCCESS) return ret; - // 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; + ret = libtocksync_ieee802154_yield_wait_for_recv(); + return ret; } returncode_t libtocksync_ieee802154_up(void) { diff --git a/libtock-sync/net/lora_phy.c b/libtock-sync/net/lora_phy.c index 8fa8f71e5..4d8b82734 100644 --- a/libtock-sync/net/lora_phy.c +++ b/libtock-sync/net/lora_phy.c @@ -1,18 +1,9 @@ +#include #include #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; -} +#include "syscalls/lora_phy_syscalls.h" bool libtocksync_lora_phy_exists(void) { return libtock_lora_phy_driver_exists(); @@ -20,25 +11,38 @@ bool libtocksync_lora_phy_exists(void) { 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(write, 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; } 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(write, 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/syscalls/ieee802154_syscalls.c b/libtock-sync/net/syscalls/ieee802154_syscalls.c new file mode 100644 index 000000000..f7d83bdf3 --- /dev/null +++ b/libtock-sync/net/syscalls/ieee802154_syscalls.c @@ -0,0 +1,16 @@ +#include "ieee802154_syscalls.h" + +returncode_t libtocksync_ieee802154_yield_wait_for_send(bool* acked) { + yield_waitfor_return_t ywf; + returncode_t ret; + ywf = yield_wait_for(DRIVER_NUM_IEEE802154, SUBSCRIBE_TX); + ret = (returncode_t) ywf.data0; + if (ret != RETURNCODE_SUCCESS) return ret; + *acked = (bool) ywf.data1; + return ret; +} + +returncode_t libtocksync_ieee802154_yield_wait_for_recv(void) { + yield_wait_for(DRIVER_NUM_IEEE802154, SUBSCRIBE_RX); + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/net/syscalls/ieee802154_syscalls.h b/libtock-sync/net/syscalls/ieee802154_syscalls.h new file mode 100644 index 000000000..9288a20d9 --- /dev/null +++ b/libtock-sync/net/syscalls/ieee802154_syscalls.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for an IEEE 802.15.4 frame transmission to complete. +returncode_t libtocksync_ieee802154_yield_wait_for_send(bool* acked); + +// Wait for an IEEE 802.15.4 frame to be received. +returncode_t libtocksync_ieee802154_yield_wait_for_recv(void); + +#ifdef __cplusplus +} +#endif 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..e42f9ccbc --- /dev/null +++ b/libtock-sync/net/syscalls/lora_phy_syscalls.c @@ -0,0 +1,6 @@ +#include "lora_phy_syscalls.h" + +returncode_t libtocksync_lora_phy_yield_wait_for(void) { + 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..4b47606c9 --- /dev/null +++ b/libtock-sync/net/syscalls/lora_phy_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a LoRa PHY SPI operation to complete. +returncode_t libtocksync_lora_phy_yield_wait_for(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/net/syscalls/udp_syscalls.c b/libtock-sync/net/syscalls/udp_syscalls.c new file mode 100644 index 000000000..3c5250ee6 --- /dev/null +++ b/libtock-sync/net/syscalls/udp_syscalls.c @@ -0,0 +1,14 @@ +#include "udp_syscalls.h" + +returncode_t libtocksync_udp_yield_wait_for_send(void) { + yield_waitfor_return_t ywf; + ywf = yield_wait_for(DRIVER_NUM_UDP, SUBSCRIBE_TX); + return (returncode_t) ywf.data0; +} + +returncode_t libtocksync_udp_yield_wait_for_recv(size_t* length) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_UDP, SUBSCRIBE_RX); + *length = (size_t) ret.data0; + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/net/syscalls/udp_syscalls.h b/libtock-sync/net/syscalls/udp_syscalls.h new file mode 100644 index 000000000..381414a17 --- /dev/null +++ b/libtock-sync/net/syscalls/udp_syscalls.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a UDP send to complete. +returncode_t libtocksync_udp_yield_wait_for_send(void); + +// Wait for a UDP frame to be received. +returncode_t libtocksync_udp_yield_wait_for_recv(size_t* length); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/net/udp.c b/libtock-sync/net/udp.c index bca34568a..1004ae9b8 100644 --- a/libtock-sync/net/udp.c +++ b/libtock-sync/net/udp.c @@ -1,59 +1,36 @@ #include +#include #include +#include "syscalls/udp_syscalls.h" #include "udp.h" -struct recv_data { - bool fired; - int val; - returncode_t ret; -}; - -struct send_data { - bool fired; - 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(returncode_t ret) { - send_sync_result.fired = true; - send_sync_result.ret = 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; -} - bool libtocksync_udp_exists(void) { return libtock_udp_driver_exists(); } returncode_t libtocksync_udp_send(void* buf, size_t len, - sock_addr_t* dst_addr) { + __attribute__ ((unused)) sock_addr_t* dst_addr) { returncode_t ret; - send_sync_result.fired = false; - ret = libtock_udp_send(buf, len, dst_addr, send_callback); + ret = libtock_udp_set_readonly_allow(buf, len); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_udp_set_readonly_allow(NULL, 0); + } - yield_for(&send_sync_result.fired); - return send_sync_result.ret; + ret = libtocksync_udp_yield_wait_for_send(); + return ret; } returncode_t libtocksync_udp_recv(void* buf, size_t len, size_t* received_len) { returncode_t ret; - recv_sync_result.fired = false; - ret = libtock_udp_recv(buf, len, recv_callback); + ret = libtock_udp_set_readwrite_allow_rx(buf, len); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_udp_set_readwrite_allow_rx(NULL, 0); + } - yield_for(&recv_sync_result.fired); - - *received_len = recv_sync_result.val; - return recv_sync_result.ret; + ret = libtocksync_udp_yield_wait_for_recv(received_len); + return ret; } diff --git a/libtock-sync/sensors/ambient_light.c b/libtock-sync/sensors/ambient_light.c index 1a5ad802f..83b1238ae 100644 --- a/libtock-sync/sensors/ambient_light.c +++ b/libtock-sync/sensors/ambient_light.c @@ -1,21 +1,6 @@ -#include - #include "ambient_light.h" -typedef struct { - int intensity; - returncode_t ret; - bool fired; -} ambient_light_data_t; - -static ambient_light_data_t result = {.fired = false}; - -// callback for synchronous reads -static void ambient_light_callback(returncode_t ret, int intensity) { - result.intensity = intensity; - result.ret = ret; - result.fired = true; -} +#include "syscalls/ambient_light_syscalls.h" bool libtocksync_ambient_light_exists(void) { return libtock_ambient_light_driver_exists(); @@ -24,15 +9,9 @@ bool libtocksync_ambient_light_exists(void) { returncode_t libtocksync_ambient_light_read_intensity(int* lux_value) { returncode_t err; - result.fired = false; - - err = libtock_ambient_light_read_intensity(ambient_light_callback); + err = libtock_ambient_light_command_start_intensity_reading(); if (err != RETURNCODE_SUCCESS) return err; - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *lux_value = result.intensity; - - return RETURNCODE_SUCCESS; + err = libtocksync_ambient_light_yield_wait_for(lux_value); + return err; } diff --git a/libtock-sync/sensors/humidity.c b/libtock-sync/sensors/humidity.c index fea3d80ae..de2d19f31 100644 --- a/libtock-sync/sensors/humidity.c +++ b/libtock-sync/sensors/humidity.c @@ -1,21 +1,6 @@ -#include - #include "humidity.h" -typedef struct { - int humidity; - returncode_t ret; - bool fired; -} humidity_result_t; - -static humidity_result_t result = {.fired = false}; - -// callback for synchronous reads -static void humidity_callback(returncode_t ret, int humidity) { - result.humidity = humidity; - result.ret = ret; - result.fired = true; -} +#include "syscalls/humidity_syscalls.h" bool libtocksync_humidity_exists(void) { return libtock_humidity_driver_exists(); @@ -24,15 +9,9 @@ bool libtocksync_humidity_exists(void) { returncode_t libtocksync_humidity_read(int* humidity) { returncode_t err; - result.fired = false; - - err = libtock_humidity_read(humidity_callback); + err = libtock_humidity_command_read(); if (err != RETURNCODE_SUCCESS) return err; - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *humidity = result.humidity; - - return RETURNCODE_SUCCESS; + err = libtocksync_humidity_yield_wait_for(humidity); + return err; } diff --git a/libtock-sync/sensors/moisture.c b/libtock-sync/sensors/moisture.c index 6561611b2..e27e64923 100644 --- a/libtock-sync/sensors/moisture.c +++ b/libtock-sync/sensors/moisture.c @@ -1,21 +1,6 @@ -#include - #include "moisture.h" -typedef struct { - int moisture; - returncode_t ret; - bool fired; -} moisture_result_t; - -static moisture_result_t result = {.fired = false}; - -// callback for synchronous reads -static void moisture_callback(returncode_t ret, int moisture) { - result.moisture = moisture; - result.ret = ret; - result.fired = true; -} +#include "syscalls/moisture_syscalls.h" bool libtocksync_moisture_exists(void) { return libtock_moisture_driver_exists(); @@ -24,15 +9,9 @@ bool libtocksync_moisture_exists(void) { returncode_t libtocksync_moisture_read(int* moisture) { returncode_t err; - result.fired = false; - - err = libtock_moisture_read(moisture_callback); + err = libtock_moisture_command_read(); if (err != RETURNCODE_SUCCESS) return err; - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *moisture = result.moisture; - - return RETURNCODE_SUCCESS; + err = libtocksync_moisture_yield_wait_for(moisture); + return err; } diff --git a/libtock-sync/sensors/ninedof.c b/libtock-sync/sensors/ninedof.c index 297f87a4d..5135c024c 100644 --- a/libtock-sync/sensors/ninedof.c +++ b/libtock-sync/sensors/ninedof.c @@ -1,30 +1,8 @@ #include -#include - -#include #include "ninedof.h" -struct ninedof_data { - int x; - int y; - int z; - bool fired; - returncode_t ret; -}; - -static struct ninedof_data result = { .fired = false }; - - - -static void ninedof_cb(returncode_t ret, int x, int y, int z) { - result.x = x; - result.y = y; - result.z = z; - result.fired = true; - result.ret = ret; -} - +#include "syscalls/ninedof_syscalls.h" bool libtocksync_ninedof_exists(void) { return libtock_ninedof_driver_exists(); @@ -33,20 +11,11 @@ bool libtocksync_ninedof_exists(void) { returncode_t libtocksync_ninedof_read_accelerometer(int* x, int* y, int* z) { returncode_t err; - result.fired = false; - - err = libtock_ninedof_read_accelerometer(ninedof_cb); + err = libtock_ninedof_command_start_accelerometer_reading(); if (err != RETURNCODE_SUCCESS) return err; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *x = result.x; - *y = result.y; - *z = result.z; - - return RETURNCODE_SUCCESS; + err = libtocksync_ninedof_yield_wait_for(x, y, z); + return err; } returncode_t libtocksync_ninedof_read_accelerometer_magnitude(double* magnitude) { @@ -56,7 +25,7 @@ returncode_t libtocksync_ninedof_read_accelerometer_magnitude(double* magnitude) err = libtocksync_ninedof_read_accelerometer(&x, &y, &z); if (err != RETURNCODE_SUCCESS) return err; - *magnitude = sqrt(result.x * result.x + result.y * result.y + result.z * result.z); + *magnitude = sqrt(x * x + y * y + z * z); return RETURNCODE_SUCCESS; } @@ -64,37 +33,19 @@ returncode_t libtocksync_ninedof_read_accelerometer_magnitude(double* magnitude) returncode_t libtocksync_ninedof_read_magnetometer(int* x, int* y, int* z) { returncode_t err; - result.fired = false; - - err = libtock_ninedof_read_magnetometer(ninedof_cb); + err = libtock_ninedof_command_start_magnetometer_reading(); if (err != RETURNCODE_SUCCESS) return err; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *x = result.x; - *y = result.y; - *z = result.z; - - return RETURNCODE_SUCCESS; + err = libtocksync_ninedof_yield_wait_for(x, y, z); + return err; } returncode_t libtocksync_ninedof_read_gyroscope(int* x, int* y, int* z) { returncode_t err; - result.fired = false; - - err = libtock_ninedof_read_gyroscope(ninedof_cb); + err = libtock_ninedof_command_start_gyroscope_reading(); if (err != RETURNCODE_SUCCESS) return err; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *x = result.x; - *y = result.y; - *z = result.z; - - return RETURNCODE_SUCCESS; + err = libtocksync_ninedof_yield_wait_for(x, y, z); + return err; } diff --git a/libtock-sync/sensors/pressure.c b/libtock-sync/sensors/pressure.c index 57eeaa65d..f974f24dd 100644 --- a/libtock-sync/sensors/pressure.c +++ b/libtock-sync/sensors/pressure.c @@ -1,20 +1,6 @@ -#include - #include "pressure.h" -struct pressure_data { - bool fired; - int pressure; - returncode_t ret; -}; - -static struct pressure_data result = { .fired = false }; - -static void pressure_cb(returncode_t ret, int pressure) { - result.pressure = pressure; - result.fired = true; - result.ret = ret; -} +#include "syscalls/pressure_syscalls.h" bool libtocksync_pressure_exists(void) { return libtock_pressure_driver_exists(); @@ -23,16 +9,9 @@ bool libtocksync_pressure_exists(void) { returncode_t libtocksync_pressure_read(int* pressure) { returncode_t err; - result.fired = false; - - err = libtock_pressure_read(pressure_cb); + err = libtock_pressure_command_read(); if (err != RETURNCODE_SUCCESS) return err; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *pressure = result.pressure; - - return RETURNCODE_SUCCESS; + err = libtocksync_pressure_yield_wait_for(pressure); + return err; } diff --git a/libtock-sync/sensors/proximity.c b/libtock-sync/sensors/proximity.c index 88f05ff4c..848a36293 100644 --- a/libtock-sync/sensors/proximity.c +++ b/libtock-sync/sensors/proximity.c @@ -1,20 +1,6 @@ -#include - #include "proximity.h" -struct data { - bool fired; - uint8_t proximity; - returncode_t ret; -}; - -static struct data result = {.fired = false}; - -static void proximity_cb(returncode_t ret, uint8_t proximity) { - result.proximity = proximity; - result.ret = ret; - result.fired = true; -} +#include "syscalls/proximity_syscalls.h" bool libtocksync_proximity_exists(void) { return libtock_proximity_driver_exists(); @@ -22,31 +8,21 @@ bool libtocksync_proximity_exists(void) { returncode_t libtocksync_proximity_read(uint8_t* proximity) { returncode_t err; - result.fired = false; - err = libtock_proximity_read(proximity_cb); + err = libtock_proximity_command_read(); if (err != RETURNCODE_SUCCESS) return err; - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *proximity = result.proximity; - - return RETURNCODE_SUCCESS; + err = libtocksync_proximity_yield_wait_for(proximity); + return err; } returncode_t libtocksync_proximity_read_on_interrupt(uint32_t lower_threshold, uint32_t higher_threshold, uint8_t* proximity) { returncode_t err; - result.fired = false; - err = libtock_proximity_read_on_interrupt(lower_threshold, higher_threshold, proximity_cb); + err = libtock_proximity_command_read_on_interrupt(lower_threshold, higher_threshold); if (err != RETURNCODE_SUCCESS) return err; - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *proximity = result.proximity; - - return RETURNCODE_SUCCESS; + err = libtocksync_proximity_yield_wait_for(proximity); + return err; } diff --git a/libtock-sync/sensors/rainfall.c b/libtock-sync/sensors/rainfall.c index 0debc03be..d77cdf2c5 100644 --- a/libtock-sync/sensors/rainfall.c +++ b/libtock-sync/sensors/rainfall.c @@ -1,21 +1,6 @@ -#include - #include "rainfall.h" -typedef struct { - uint32_t rainfall; - returncode_t ret; - bool fired; -} rainfall_result_t; - -static rainfall_result_t result = {.fired = false}; - -// callback for synchronous reads -static void rainfall_callback(returncode_t ret, uint32_t rainfall) { - result.rainfall = rainfall; - result.ret = ret; - result.fired = true; -} +#include "syscalls/rainfall_syscalls.h" bool libtocksync_rainfall_exists(void) { return libtock_rainfall_driver_exists(); @@ -24,15 +9,9 @@ bool libtocksync_rainfall_exists(void) { returncode_t libtocksync_rainfall_read(uint32_t* rainfall, int hours) { returncode_t err; - result.fired = false; - - err = libtock_rainfall_read(rainfall_callback, hours); + err = libtock_rainfall_command_read(hours); if (err != RETURNCODE_SUCCESS) return err; - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *rainfall = result.rainfall; - - return RETURNCODE_SUCCESS; + err = libtocksync_rainfall_yield_wait_for(rainfall); + return err; } diff --git a/libtock-sync/sensors/sound_pressure.c b/libtock-sync/sensors/sound_pressure.c index 720f47f59..82c2a85f4 100644 --- a/libtock-sync/sensors/sound_pressure.c +++ b/libtock-sync/sensors/sound_pressure.c @@ -1,22 +1,6 @@ -#include - #include "sound_pressure.h" -struct sound_pressure_data { - bool fired; - int sound_pressure; - returncode_t ret; -}; - -static struct sound_pressure_data result = { .fired = false }; - -// Internal callback for faking synchronous reads -static void cb(returncode_t ret, uint8_t sound_pressure) { - result.sound_pressure = sound_pressure; - result.fired = true; - result.ret = ret; -} - +#include "syscalls/sound_pressure_syscalls.h" bool libtocksync_sound_pressure_exists(void) { return libtock_sound_pressure_driver_exists(); @@ -32,16 +16,10 @@ returncode_t libtocksync_sound_pressure_disable(void) { returncode_t libtocksync_sound_pressure_read(uint8_t* sound_pressure) { returncode_t err; - result.fired = false; - err = libtock_sound_pressure_read(cb); + err = libtock_sound_pressure_command_read(); if (err != RETURNCODE_SUCCESS) return err; - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *sound_pressure = result.sound_pressure; - - return RETURNCODE_SUCCESS; + err = libtocksync_sound_pressure_yield_wait_for(sound_pressure); + return err; } diff --git a/libtock-sync/sensors/syscalls/ambient_light_syscalls.c b/libtock-sync/sensors/syscalls/ambient_light_syscalls.c new file mode 100644 index 000000000..4a165e57a --- /dev/null +++ b/libtock-sync/sensors/syscalls/ambient_light_syscalls.c @@ -0,0 +1,8 @@ +#include "ambient_light_syscalls.h" + +returncode_t libtocksync_ambient_light_yield_wait_for(int* intensity) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_AMBIENT_LIGHT, 0); + *intensity = (int) ret.data0; + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/sensors/syscalls/ambient_light_syscalls.h b/libtock-sync/sensors/syscalls/ambient_light_syscalls.h new file mode 100644 index 000000000..ce69d0aab --- /dev/null +++ b/libtock-sync/sensors/syscalls/ambient_light_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for an ambient light intensity reading to complete. +returncode_t libtocksync_ambient_light_yield_wait_for(int* intensity); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/sensors/syscalls/humidity_syscalls.c b/libtock-sync/sensors/syscalls/humidity_syscalls.c new file mode 100644 index 000000000..da1138afc --- /dev/null +++ b/libtock-sync/sensors/syscalls/humidity_syscalls.c @@ -0,0 +1,8 @@ +#include "humidity_syscalls.h" + +returncode_t libtocksync_humidity_yield_wait_for(int* humidity) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_HUMIDITY, 0); + *humidity = (int) ret.data0; + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/sensors/syscalls/humidity_syscalls.h b/libtock-sync/sensors/syscalls/humidity_syscalls.h new file mode 100644 index 000000000..20c00716a --- /dev/null +++ b/libtock-sync/sensors/syscalls/humidity_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a humidity reading to complete. +returncode_t libtocksync_humidity_yield_wait_for(int* humidity); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/sensors/syscalls/moisture_syscalls.c b/libtock-sync/sensors/syscalls/moisture_syscalls.c new file mode 100644 index 000000000..c07805e21 --- /dev/null +++ b/libtock-sync/sensors/syscalls/moisture_syscalls.c @@ -0,0 +1,11 @@ +#include "moisture_syscalls.h" + +returncode_t libtocksync_moisture_yield_wait_for(int* moisture) { + yield_waitfor_return_t ywf; + returncode_t ret; + ywf = yield_wait_for(DRIVER_NUM_MOISTURE, 0); + ret = (returncode_t) ywf.data0; + if (ret != RETURNCODE_SUCCESS) return ret; + *moisture = (int) ywf.data1; + return ret; +} diff --git a/libtock-sync/sensors/syscalls/moisture_syscalls.h b/libtock-sync/sensors/syscalls/moisture_syscalls.h new file mode 100644 index 000000000..53ee187d4 --- /dev/null +++ b/libtock-sync/sensors/syscalls/moisture_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a moisture reading to complete. +returncode_t libtocksync_moisture_yield_wait_for(int* moisture); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/sensors/syscalls/ninedof_syscalls.c b/libtock-sync/sensors/syscalls/ninedof_syscalls.c new file mode 100644 index 000000000..714066312 --- /dev/null +++ b/libtock-sync/sensors/syscalls/ninedof_syscalls.c @@ -0,0 +1,10 @@ +#include "ninedof_syscalls.h" + +returncode_t libtocksync_ninedof_yield_wait_for(int* x, int* y, int* z) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_NINEDOF, 0); + *x = (int) ret.data0; + *y = (int) ret.data1; + *z = (int) ret.data2; + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/sensors/syscalls/ninedof_syscalls.h b/libtock-sync/sensors/syscalls/ninedof_syscalls.h new file mode 100644 index 000000000..b3a47e25b --- /dev/null +++ b/libtock-sync/sensors/syscalls/ninedof_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a ninedof sensor reading to complete (accelerometer, magnetometer, or gyroscope). +returncode_t libtocksync_ninedof_yield_wait_for(int* x, int* y, int* z); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/sensors/syscalls/pressure_syscalls.c b/libtock-sync/sensors/syscalls/pressure_syscalls.c new file mode 100644 index 000000000..b210bb534 --- /dev/null +++ b/libtock-sync/sensors/syscalls/pressure_syscalls.c @@ -0,0 +1,8 @@ +#include "pressure_syscalls.h" + +returncode_t libtocksync_pressure_yield_wait_for(int* pressure) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_PRESSURE, 0); + *pressure = (int) ret.data0; + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/sensors/syscalls/pressure_syscalls.h b/libtock-sync/sensors/syscalls/pressure_syscalls.h new file mode 100644 index 000000000..f01089e72 --- /dev/null +++ b/libtock-sync/sensors/syscalls/pressure_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a pressure reading to complete. +returncode_t libtocksync_pressure_yield_wait_for(int* pressure); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/sensors/syscalls/proximity_syscalls.c b/libtock-sync/sensors/syscalls/proximity_syscalls.c new file mode 100644 index 000000000..f235eb9bb --- /dev/null +++ b/libtock-sync/sensors/syscalls/proximity_syscalls.c @@ -0,0 +1,8 @@ +#include "proximity_syscalls.h" + +returncode_t libtocksync_proximity_yield_wait_for(uint8_t* proximity) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_PROXIMITY, 0); + *proximity = (uint8_t) ret.data0; + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/sensors/syscalls/proximity_syscalls.h b/libtock-sync/sensors/syscalls/proximity_syscalls.h new file mode 100644 index 000000000..b2bfbae49 --- /dev/null +++ b/libtock-sync/sensors/syscalls/proximity_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a proximity reading to complete. +returncode_t libtocksync_proximity_yield_wait_for(uint8_t* proximity); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/sensors/syscalls/rainfall_syscalls.c b/libtock-sync/sensors/syscalls/rainfall_syscalls.c new file mode 100644 index 000000000..748ca8f8f --- /dev/null +++ b/libtock-sync/sensors/syscalls/rainfall_syscalls.c @@ -0,0 +1,11 @@ +#include "rainfall_syscalls.h" + +returncode_t libtocksync_rainfall_yield_wait_for(uint32_t* rainfall) { + yield_waitfor_return_t ywf; + returncode_t ret; + ywf = yield_wait_for(DRIVER_NUM_RAINFALL, 0); + ret = (returncode_t) ywf.data0; + if (ret != RETURNCODE_SUCCESS) return ret; + *rainfall = (uint32_t) ywf.data1; + return ret; +} diff --git a/libtock-sync/sensors/syscalls/rainfall_syscalls.h b/libtock-sync/sensors/syscalls/rainfall_syscalls.h new file mode 100644 index 000000000..d77e72fdb --- /dev/null +++ b/libtock-sync/sensors/syscalls/rainfall_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a rainfall reading to complete. +returncode_t libtocksync_rainfall_yield_wait_for(uint32_t* rainfall); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/sensors/syscalls/sound_pressure_syscalls.c b/libtock-sync/sensors/syscalls/sound_pressure_syscalls.c new file mode 100644 index 000000000..dc4f06f10 --- /dev/null +++ b/libtock-sync/sensors/syscalls/sound_pressure_syscalls.c @@ -0,0 +1,8 @@ +#include "sound_pressure_syscalls.h" + +returncode_t libtocksync_sound_pressure_yield_wait_for(uint8_t* sound_pressure) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_SOUND_PRESSURE, 0); + *sound_pressure = (uint8_t) ret.data0; + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/sensors/syscalls/sound_pressure_syscalls.h b/libtock-sync/sensors/syscalls/sound_pressure_syscalls.h new file mode 100644 index 000000000..0bfd74c75 --- /dev/null +++ b/libtock-sync/sensors/syscalls/sound_pressure_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a sound pressure reading to complete. +returncode_t libtocksync_sound_pressure_yield_wait_for(uint8_t* sound_pressure); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/services/alarm.c b/libtock-sync/services/alarm.c index 7eff3c24d..8c81f43ff 100644 --- a/libtock-sync/services/alarm.c +++ b/libtock-sync/services/alarm.c @@ -1,31 +1,25 @@ #include "alarm.h" -struct alarm_cb_data { - bool fired; -}; - -static struct alarm_cb_data delay_data = { .fired = false }; +#include "syscalls/alarm_syscalls.h" -static void delay_cb(__attribute__ ((unused)) uint32_t now, - __attribute__ ((unused)) uint32_t scheduled, - __attribute__ ((unused)) void* opaque) { - delay_data.fired = true; -} +static void alarm_noop_cb(__attribute__ ((unused)) uint32_t now, + __attribute__ ((unused)) uint32_t scheduled, + __attribute__ ((unused)) void* opaque) {} int libtocksync_alarm_delay_ms(uint32_t ms) { - delay_data.fired = false; libtock_alarm_t alarm; int rc; - if ((rc = libtock_alarm_in_ms(ms, delay_cb, NULL, &alarm)) != RETURNCODE_SUCCESS) { + if ((rc = libtock_alarm_in_ms(ms, alarm_noop_cb, NULL, &alarm)) != RETURNCODE_SUCCESS) { return rc; } - yield_for(&delay_data.fired); - return rc; + return libtocksync_alarm_yield_wait_for(); } -static struct alarm_cb_data yf_timeout_data = { .fired = false }; +static struct alarm_cb_data { + bool fired; +} yf_timeout_data = { .fired = false }; static void yf_timeout_cb(__attribute__ ((unused)) uint32_t now, __attribute__ ((unused)) uint32_t scheduled, diff --git a/libtock-sync/services/syscalls/alarm_syscalls.c b/libtock-sync/services/syscalls/alarm_syscalls.c new file mode 100644 index 000000000..3104ff4ab --- /dev/null +++ b/libtock-sync/services/syscalls/alarm_syscalls.c @@ -0,0 +1,6 @@ +#include "alarm_syscalls.h" + +returncode_t libtocksync_alarm_yield_wait_for(void) { + yield_wait_for(DRIVER_NUM_ALARM, 0); + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/services/syscalls/alarm_syscalls.h b/libtock-sync/services/syscalls/alarm_syscalls.h new file mode 100644 index 000000000..00fdc560c --- /dev/null +++ b/libtock-sync/services/syscalls/alarm_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for an alarm upcall. +returncode_t libtocksync_alarm_yield_wait_for(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/storage/app_state.c b/libtock-sync/storage/app_state.c index a39eb5a57..d674a49d2 100644 --- a/libtock-sync/storage/app_state.c +++ b/libtock-sync/storage/app_state.c @@ -1,18 +1,10 @@ -#include +#include #include "app_state.h" -struct app_state_data { - bool fired; - returncode_t ret; -}; +#include "syscalls/app_state_syscalls.h" -static struct app_state_data result = {.fired = false}; - -static void app_state_cb(returncode_t ret) { - result.fired = true; - result.ret = ret; -} +static void app_state_noop_cb(__attribute__ ((unused)) returncode_t ret) {} bool libtocksync_app_state_exists(void) { return libtock_app_state_driver_exists(); @@ -21,13 +13,8 @@ bool libtocksync_app_state_exists(void) { returncode_t libtocksync_app_state_save(void) { returncode_t err; - result.fired = false; - - err = libtock_app_state_save(app_state_cb); + err = libtock_app_state_save(app_state_noop_cb); if (err != RETURNCODE_SUCCESS) return err; - // Wait for the callback. - yield_for(&result.fired); - - return result.ret; + return libtocksync_app_state_yield_wait_for(); } diff --git a/libtock-sync/storage/isolated_nonvolatile_storage.c b/libtock-sync/storage/isolated_nonvolatile_storage.c index 3b34972e6..1fec73ddb 100644 --- a/libtock-sync/storage/isolated_nonvolatile_storage.c +++ b/libtock-sync/storage/isolated_nonvolatile_storage.c @@ -1,32 +1,9 @@ -#include - +#include #include #include "isolated_nonvolatile_storage.h" -struct nv_data { - bool fired; - returncode_t ret; - uint64_t storage_size; -}; - -static struct nv_data result = {.fired = false}; - -static void get_number_bytes_cb(returncode_t ret, uint64_t number_bytes) { - result.fired = true; - result.ret = ret; - result.storage_size = number_bytes; -} - -static void write_cb(returncode_t ret) { - result.fired = true; - result.ret = ret; -} - -static void read_cb(returncode_t ret) { - result.fired = true; - result.ret = ret; -} +#include "syscalls/isolated_nonvolatile_storage_syscalls.h" bool libtocksync_isolated_nonvolatile_storage_exists(void) { return libtock_isolated_nonvolatile_storage_driver_exists(); @@ -34,48 +11,42 @@ bool libtocksync_isolated_nonvolatile_storage_exists(void) { returncode_t libtocksync_isolated_nonvolatile_storage_get_number_bytes(uint64_t* number_bytes) { returncode_t ret; - result.fired = false; - ret = libtock_isolated_nonvolatile_storage_get_number_bytes(get_number_bytes_cb); + ret = libtock_isolated_nonvolatile_storage_command_get_number_bytes(); if (ret != RETURNCODE_SUCCESS) return ret; - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - *number_bytes = result.storage_size; - return RETURNCODE_SUCCESS; + ret = libtocksync_isolated_nonvolatile_storage_yield_wait_for_get_number_bytes(number_bytes); + return ret; } returncode_t libtocksync_isolated_nonvolatile_storage_write(uint64_t offset, uint8_t* buffer, uint32_t buffer_length) { returncode_t ret; - result.fired = false; - ret = libtock_isolated_nonvolatile_storage_write(offset, buffer, buffer_length, write_cb); + ret = libtock_isolated_nonvolatile_storage_set_allow_readonly_write_buffer(buffer, buffer_length); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_isolated_nonvolatile_storage_set_allow_readonly_write_buffer(NULL, 0); + } - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - ret = libtock_isolated_nonvolatile_storage_set_allow_readonly_write_buffer(NULL, 0); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + ret = libtock_isolated_nonvolatile_storage_command_write(offset); + if (ret != RETURNCODE_SUCCESS) return ret; - return RETURNCODE_SUCCESS; + ret = libtocksync_isolated_nonvolatile_storage_yield_wait_for_write(); + return ret; } returncode_t libtocksync_isolated_nonvolatile_storage_read(uint64_t offset, uint8_t* buffer, uint32_t buffer_length) { returncode_t ret; - result.fired = false; - ret = libtock_isolated_nonvolatile_storage_read(offset, buffer, buffer_length, read_cb); + ret = libtock_isolated_nonvolatile_storage_set_allow_readwrite_read_buffer(buffer, buffer_length); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_isolated_nonvolatile_storage_set_allow_readwrite_read_buffer(NULL, 0); + } - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - ret = libtock_isolated_nonvolatile_storage_set_allow_readwrite_read_buffer(NULL, 0); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + ret = libtock_isolated_nonvolatile_storage_command_read(offset); + if (ret != RETURNCODE_SUCCESS) return ret; - return RETURNCODE_SUCCESS; + ret = libtocksync_isolated_nonvolatile_storage_yield_wait_for_read(); + return ret; } diff --git a/libtock-sync/storage/kv.c b/libtock-sync/storage/kv.c index 2d13f550c..f5ccb8869 100644 --- a/libtock-sync/storage/kv.c +++ b/libtock-sync/storage/kv.c @@ -1,25 +1,9 @@ +#include #include #include "kv.h" -struct kv_data { - bool fired; - int length; - returncode_t ret; -}; - -static struct kv_data result = {.fired = false}; - -static void kv_cb_get(returncode_t ret, int length) { - result.fired = true; - result.length = length; - result.ret = ret; -} - -static void kv_cb_done(returncode_t ret) { - result.fired = true; - result.ret = ret; -} +#include "syscalls/kv_syscalls.h" bool libtocksync_kv_exists(void) { return libtock_kv_driver_exists(); @@ -28,71 +12,107 @@ bool libtocksync_kv_exists(void) { returncode_t libtocksync_kv_get(const uint8_t* key_buffer, uint32_t key_len, uint8_t* ret_buffer, uint32_t ret_len, uint32_t* value_len) { returncode_t err; - result.fired = false; + int length; - err = libtock_kv_get(key_buffer, key_len, ret_buffer, ret_len, kv_cb_get); + err = libtock_kv_set_readonly_allow_key_buffer(key_buffer, key_len); if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readonly_allow_key_buffer(NULL, 0); + } - // Wait for the callback. - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + err = libtock_kv_set_readwrite_allow_output_buffer(ret_buffer, ret_len); + if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readwrite_allow_output_buffer(NULL, 0); + } - // Return the length of the retrieved value. - *value_len = result.length; + err = libtock_kv_command_get(); + if (err != RETURNCODE_SUCCESS) return err; + err = libtocksync_kv_yield_wait_for_get(&length); + if (err != RETURNCODE_SUCCESS) return err; + + *value_len = (uint32_t) length; return RETURNCODE_SUCCESS; } -static returncode_t kv_insert(const uint8_t* key_buffer, uint32_t key_len, const uint8_t* val_buffer, - uint32_t val_len, returncode_t (*op_fn)(const uint8_t*, uint32_t, const uint8_t*, - uint32_t, libtock_kv_callback_done)) { +returncode_t libtocksync_kv_set(const uint8_t* key_buffer, uint32_t key_len, const uint8_t* val_buffer, + uint32_t val_len) { returncode_t err; - result.fired = false; - // Do the requested set/add/update operation. - err = op_fn(key_buffer, key_len, val_buffer, val_len, kv_cb_done); + err = libtock_kv_set_readonly_allow_key_buffer(key_buffer, key_len); if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readonly_allow_key_buffer(NULL, 0); + } - // Wait for the callback. - yield_for(&result.fired); - return result.ret; -} + err = libtock_kv_set_readonly_allow_input_buffer(val_buffer, val_len); + if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readonly_allow_input_buffer(NULL, 0); + } -returncode_t libtocksync_kv_set(const uint8_t* key_buffer, uint32_t key_len, const uint8_t* val_buffer, - uint32_t val_len) { - return kv_insert(key_buffer, key_len, val_buffer, val_len, libtock_kv_set); + err = libtock_kv_command_set(); + if (err != RETURNCODE_SUCCESS) return err; + + return libtocksync_kv_yield_wait_for_done(); } returncode_t libtocksync_kv_add(const uint8_t* key_buffer, uint32_t key_len, const uint8_t* val_buffer, uint32_t val_len) { - return kv_insert(key_buffer, key_len, val_buffer, val_len, libtock_kv_add); + returncode_t err; + + err = libtock_kv_set_readonly_allow_key_buffer(key_buffer, key_len); + if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readonly_allow_key_buffer(NULL, 0); + } + + err = libtock_kv_set_readonly_allow_input_buffer(val_buffer, val_len); + if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readonly_allow_input_buffer(NULL, 0); + } + + err = libtock_kv_command_add(); + if (err != RETURNCODE_SUCCESS) return err; + + return libtocksync_kv_yield_wait_for_done(); } returncode_t libtocksync_kv_update(const uint8_t* key_buffer, uint32_t key_len, const uint8_t* val_buffer, uint32_t val_len) { - return kv_insert(key_buffer, key_len, val_buffer, val_len, libtock_kv_update); + returncode_t err; + + err = libtock_kv_set_readonly_allow_key_buffer(key_buffer, key_len); + if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readonly_allow_key_buffer(NULL, 0); + } + + err = libtock_kv_set_readonly_allow_input_buffer(val_buffer, val_len); + if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readonly_allow_input_buffer(NULL, 0); + } + + err = libtock_kv_command_update(); + if (err != RETURNCODE_SUCCESS) return err; + + return libtocksync_kv_yield_wait_for_done(); } returncode_t libtocksync_kv_delete(const uint8_t* key_buffer, uint32_t key_len) { returncode_t err; - result.fired = false; - err = libtock_kv_delete(key_buffer, key_len, kv_cb_done); + err = libtock_kv_set_readonly_allow_key_buffer(key_buffer, key_len); + if (err != RETURNCODE_SUCCESS) return err; + defer { libtock_kv_set_readonly_allow_key_buffer(NULL, 0); + } + + err = libtock_kv_command_delete(); if (err != RETURNCODE_SUCCESS) return err; - // Wait for the callback. - yield_for(&result.fired); - return result.ret; + return libtocksync_kv_yield_wait_for_done(); } returncode_t libtocksync_kv_garbage_collect(void) { returncode_t err; - result.fired = false; - err = libtock_kv_garbage_collect(kv_cb_done); + err = libtock_kv_command_garbage_collect(); if (err != RETURNCODE_SUCCESS) return err; - // Wait for the callback. - yield_for(&result.fired); - return result.ret; + return libtocksync_kv_yield_wait_for_done(); } diff --git a/libtock-sync/storage/nonvolatile_storage.c b/libtock-sync/storage/nonvolatile_storage.c index cdd7875fb..7b00bab73 100644 --- a/libtock-sync/storage/nonvolatile_storage.c +++ b/libtock-sync/storage/nonvolatile_storage.c @@ -1,26 +1,9 @@ +#include #include #include "nonvolatile_storage.h" -struct nv_data { - bool fired; - returncode_t ret; - int length; -}; - -static struct nv_data result = {.fired = false}; - -static void write_cb(returncode_t ret, int length) { - result.fired = true; - result.ret = ret; - result.length = length; -} - -static void read_cb(returncode_t ret, int length) { - result.fired = true; - result.ret = ret; - result.length = length; -} +#include "syscalls/nonvolatile_storage_syscalls.h" bool libtocksync_nonvolatile_storage_exists(void) { return libtock_nonvolatile_storage_driver_exists(); @@ -29,35 +12,31 @@ bool libtocksync_nonvolatile_storage_exists(void) { returncode_t libtocksync_nonvolatile_storage_write(uint32_t offset, uint32_t length, uint8_t* buffer, uint32_t buffer_length, int* length_written) { returncode_t ret; - result.fired = false; - ret = libtock_nonvolatile_storage_write(offset, length, buffer, buffer_length, write_cb); + ret = libtock_nonvolatile_storage_set_allow_readonly_write_buffer(buffer, buffer_length); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_nonvolatile_storage_set_allow_readonly_write_buffer(NULL, 0); + } - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - ret = libtock_nonvolatile_storage_set_allow_readonly_write_buffer(NULL, 0); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + ret = libtock_nonvolatile_storage_command_write(offset, length); + if (ret != RETURNCODE_SUCCESS) return ret; - *length_written = result.length; - return RETURNCODE_SUCCESS; + ret = libtocksync_nonvolatile_storage_yield_wait_for_write(length_written); + return ret; } returncode_t libtocksync_nonvolatile_storage_read(uint32_t offset, uint32_t length, uint8_t* buffer, uint32_t buffer_length, int* length_read) { returncode_t ret; - result.fired = false; - ret = libtock_nonvolatile_storage_read(offset, length, buffer, buffer_length, read_cb); + ret = libtock_nonvolatile_storage_set_allow_readwrite_read_buffer(buffer, buffer_length); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_nonvolatile_storage_set_allow_readwrite_read_buffer(NULL, 0); + } - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - ret = libtock_nonvolatile_storage_set_allow_readwrite_read_buffer(NULL, 0); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; + ret = libtock_nonvolatile_storage_command_read(offset, length); + if (ret != RETURNCODE_SUCCESS) return ret; - *length_read = result.length; - return RETURNCODE_SUCCESS; + ret = libtocksync_nonvolatile_storage_yield_wait_for_read(length_read); + return ret; } diff --git a/libtock-sync/storage/sdcard.c b/libtock-sync/storage/sdcard.c index 141ac3070..82c08df46 100644 --- a/libtock-sync/storage/sdcard.c +++ b/libtock-sync/storage/sdcard.c @@ -1,34 +1,9 @@ +#include #include #include "sdcard.h" -// used for creating synchronous versions of functions -// -// - `fired` - set when callback has been called -// - `block_size` - block size of SD card, set upon initialization complete -// - `size_in_kB` - size in kilobytes of SD card, set upon initialization complete -// - `error` - error code signaled in callback, 0 if successful -struct sdcard_data { - bool fired; - uint32_t block_size; - uint32_t size_in_kB; - returncode_t ret; -}; - -static struct sdcard_data result = {.fired = false}; - -static void sdcard_cb_init(returncode_t ret, uint32_t block_size, uint32_t size_in_kB) { - result.fired = true; - result.block_size = block_size; - result.size_in_kB = size_in_kB; - result.ret = ret; -} - -static void sdcard_cb_general(returncode_t ret) { - result.fired = true; - result.ret = ret; -} - +#include "syscalls/sdcard_syscalls.h" bool libtocksync_sdcard_exists(void) { return libtock_sdcard_driver_exists(); @@ -36,56 +11,40 @@ bool libtocksync_sdcard_exists(void) { returncode_t libtocksync_sdcard_initialize(uint32_t* block_size, uint32_t* size_in_kB) { returncode_t ret; - result.fired = false; - ret = libtock_sdcard_initialize(sdcard_cb_init); + ret = libtock_sdcard_command_initialize(); if (ret != RETURNCODE_SUCCESS) return ret; - // wait for callback - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - // copy args - if (block_size != NULL) { - *block_size = result.block_size; - } - if (size_in_kB != NULL) { - *size_in_kB = result.size_in_kB; - } - - return RETURNCODE_SUCCESS; + ret = libtocksync_sdcard_yield_wait_for_initialize(block_size, size_in_kB); + return ret; } returncode_t libtocksync_sdcard_read_block(uint32_t sector, uint8_t* buffer, uint32_t len) { returncode_t ret; - result.fired = false; - ret = libtock_sdcard_read_block(sector, buffer, len, sdcard_cb_general); + ret = libtock_sdcard_set_readwrite_allow_read_buffer(buffer, len); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_sdcard_set_readwrite_allow_read_buffer(NULL, 0); + } - // wait for callback - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - ret = libtock_sdcard_set_readwrite_allow_read_buffer(NULL, 0); + ret = libtock_sdcard_command_read_block(sector); if (ret != RETURNCODE_SUCCESS) return ret; - return RETURNCODE_SUCCESS; + ret = libtocksync_sdcard_yield_wait_for_operation(); + return ret; } returncode_t libtocksync_sdcard_write_block(uint32_t sector, uint8_t* buffer, uint32_t len) { returncode_t ret; - result.fired = false; - ret = libtock_sdcard_write_block(sector, buffer, len, sdcard_cb_general); + ret = libtock_sdcard_set_readonly_allow_write_buffer(buffer, len); if (ret != RETURNCODE_SUCCESS) return ret; + defer { libtock_sdcard_set_readonly_allow_write_buffer(NULL, 0); + } - // wait for callback - yield_for(&result.fired); - if (result.ret != RETURNCODE_SUCCESS) return result.ret; - - ret = libtock_sdcard_set_readonly_allow_write_buffer(NULL, 0); + ret = libtock_sdcard_command_write_block(sector); if (ret != RETURNCODE_SUCCESS) return ret; - return RETURNCODE_SUCCESS; + ret = libtocksync_sdcard_yield_wait_for_operation(); + return ret; } diff --git a/libtock-sync/storage/syscalls/app_state_syscalls.c b/libtock-sync/storage/syscalls/app_state_syscalls.c new file mode 100644 index 000000000..cb5939f61 --- /dev/null +++ b/libtock-sync/storage/syscalls/app_state_syscalls.c @@ -0,0 +1,6 @@ +#include "app_state_syscalls.h" + +returncode_t libtocksync_app_state_yield_wait_for(void) { + yield_wait_for(DRIVER_NUM_APP_STATE, 0); + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/storage/syscalls/app_state_syscalls.h b/libtock-sync/storage/syscalls/app_state_syscalls.h new file mode 100644 index 000000000..14b91442d --- /dev/null +++ b/libtock-sync/storage/syscalls/app_state_syscalls.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for an app state save to complete. +returncode_t libtocksync_app_state_yield_wait_for(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/storage/syscalls/isolated_nonvolatile_storage_syscalls.c b/libtock-sync/storage/syscalls/isolated_nonvolatile_storage_syscalls.c new file mode 100644 index 000000000..26dc21190 --- /dev/null +++ b/libtock-sync/storage/syscalls/isolated_nonvolatile_storage_syscalls.c @@ -0,0 +1,23 @@ +#include "isolated_nonvolatile_storage_syscalls.h" + +returncode_t libtocksync_isolated_nonvolatile_storage_yield_wait_for_get_number_bytes(uint64_t* number_bytes) { + yield_waitfor_return_t ywf; + returncode_t ret; + ywf = yield_wait_for(DRIVER_NUM_ISOLATED_NONVOLATILE_STORAGE, 0); + ret = (returncode_t) ywf.data0; + if (ret != RETURNCODE_SUCCESS) return ret; + *number_bytes = ((uint64_t) ywf.data2 << 32) | (uint64_t) ywf.data1; + return ret; +} + +returncode_t libtocksync_isolated_nonvolatile_storage_yield_wait_for_read(void) { + yield_waitfor_return_t ywf; + ywf = yield_wait_for(DRIVER_NUM_ISOLATED_NONVOLATILE_STORAGE, 1); + return (returncode_t) ywf.data0; +} + +returncode_t libtocksync_isolated_nonvolatile_storage_yield_wait_for_write(void) { + yield_waitfor_return_t ywf; + ywf = yield_wait_for(DRIVER_NUM_ISOLATED_NONVOLATILE_STORAGE, 2); + return (returncode_t) ywf.data0; +} diff --git a/libtock-sync/storage/syscalls/isolated_nonvolatile_storage_syscalls.h b/libtock-sync/storage/syscalls/isolated_nonvolatile_storage_syscalls.h new file mode 100644 index 000000000..1480af565 --- /dev/null +++ b/libtock-sync/storage/syscalls/isolated_nonvolatile_storage_syscalls.h @@ -0,0 +1,21 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for an isolated nonvolatile storage get_number_bytes to complete. +returncode_t libtocksync_isolated_nonvolatile_storage_yield_wait_for_get_number_bytes(uint64_t* number_bytes); + +// Wait for an isolated nonvolatile storage read to complete. +returncode_t libtocksync_isolated_nonvolatile_storage_yield_wait_for_read(void); + +// Wait for an isolated nonvolatile storage write to complete. +returncode_t libtocksync_isolated_nonvolatile_storage_yield_wait_for_write(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/storage/syscalls/kv_syscalls.c b/libtock-sync/storage/syscalls/kv_syscalls.c new file mode 100644 index 000000000..4c3cb968a --- /dev/null +++ b/libtock-sync/storage/syscalls/kv_syscalls.c @@ -0,0 +1,17 @@ +#include "kv_syscalls.h" + +returncode_t libtocksync_kv_yield_wait_for_get(int* length) { + yield_waitfor_return_t ywf; + returncode_t ret; + ywf = yield_wait_for(DRIVER_NUM_KV, 0); + ret = (returncode_t) ywf.data0; + if (ret != RETURNCODE_SUCCESS) return ret; + *length = (int) ywf.data1; + return ret; +} + +returncode_t libtocksync_kv_yield_wait_for_done(void) { + yield_waitfor_return_t ywf; + ywf = yield_wait_for(DRIVER_NUM_KV, 0); + return (returncode_t) ywf.data0; +} diff --git a/libtock-sync/storage/syscalls/kv_syscalls.h b/libtock-sync/storage/syscalls/kv_syscalls.h new file mode 100644 index 000000000..93e947bbf --- /dev/null +++ b/libtock-sync/storage/syscalls/kv_syscalls.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a KV get operation to complete. +returncode_t libtocksync_kv_yield_wait_for_get(int* length); + +// Wait for a KV done operation to complete (set, add, update, delete, gc). +returncode_t libtocksync_kv_yield_wait_for_done(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/storage/syscalls/nonvolatile_storage_syscalls.c b/libtock-sync/storage/syscalls/nonvolatile_storage_syscalls.c new file mode 100644 index 000000000..d39de7f83 --- /dev/null +++ b/libtock-sync/storage/syscalls/nonvolatile_storage_syscalls.c @@ -0,0 +1,15 @@ +#include "nonvolatile_storage_syscalls.h" + +returncode_t libtocksync_nonvolatile_storage_yield_wait_for_read(int* length) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_NONVOLATILE_STORAGE, 0); + *length = (int) ret.data0; + return RETURNCODE_SUCCESS; +} + +returncode_t libtocksync_nonvolatile_storage_yield_wait_for_write(int* length) { + yield_waitfor_return_t ret; + ret = yield_wait_for(DRIVER_NUM_NONVOLATILE_STORAGE, 1); + *length = (int) ret.data0; + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/storage/syscalls/nonvolatile_storage_syscalls.h b/libtock-sync/storage/syscalls/nonvolatile_storage_syscalls.h new file mode 100644 index 000000000..4002be972 --- /dev/null +++ b/libtock-sync/storage/syscalls/nonvolatile_storage_syscalls.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for a nonvolatile storage read to complete. +returncode_t libtocksync_nonvolatile_storage_yield_wait_for_read(int* length); + +// Wait for a nonvolatile storage write to complete. +returncode_t libtocksync_nonvolatile_storage_yield_wait_for_write(int* length); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/storage/syscalls/sdcard_syscalls.c b/libtock-sync/storage/syscalls/sdcard_syscalls.c new file mode 100644 index 000000000..ba290dcf8 --- /dev/null +++ b/libtock-sync/storage/syscalls/sdcard_syscalls.c @@ -0,0 +1,27 @@ +#include "sdcard_syscalls.h" + +returncode_t libtocksync_sdcard_yield_wait_for_initialize(uint32_t* block_size, uint32_t* size_in_kB) { + yield_waitfor_return_t ywf; + ywf = yield_wait_for(DRIVER_NUM_SDCARD, 0); + + // callback_type=4 indicates an error + if (ywf.data0 == 4) return RETURNCODE_FAIL; + + if (block_size != NULL) { + *block_size = (uint32_t) ywf.data1; + } + if (size_in_kB != NULL) { + *size_in_kB = (uint32_t) ywf.data2; + } + return RETURNCODE_SUCCESS; +} + +returncode_t libtocksync_sdcard_yield_wait_for_operation(void) { + yield_waitfor_return_t ywf; + ywf = yield_wait_for(DRIVER_NUM_SDCARD, 0); + + // callback_type=4 indicates an error + if (ywf.data0 == 4) return RETURNCODE_FAIL; + + return RETURNCODE_SUCCESS; +} diff --git a/libtock-sync/storage/syscalls/sdcard_syscalls.h b/libtock-sync/storage/syscalls/sdcard_syscalls.h new file mode 100644 index 000000000..3afbc1ec0 --- /dev/null +++ b/libtock-sync/storage/syscalls/sdcard_syscalls.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wait for an SD card initialization to complete. +returncode_t libtocksync_sdcard_yield_wait_for_initialize(uint32_t* block_size, uint32_t* size_in_kB); + +// Wait for an SD card read or write operation to complete. +returncode_t libtocksync_sdcard_yield_wait_for_operation(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock-sync/sys.c b/libtock-sync/sys.c index a26a1cafd..765fe8713 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; }