preempt - Abstract away blob ticks (#4063)

* Fix sleep

* Remove unused timeout from mutex_lock

* Abstract away blob ticks

* Update esp-radio/src/time.rs

Co-authored-by: Copilot <[email protected]>

* Don't sleep for 10s

---------

Co-authored-by: Copilot <[email protected]>

Author: bugadani

esp-radio/src/ble/npl.rs

@@ -10,6 +10,7 @@ use super::*;
 use crate::{
     binary::{c_types::*, include::*},
     compat::{self, OSI_FUNCS_TIME_BLOCKING, common::str_from_c, queue},
+    time::{blob_ticks_to_micros, blob_ticks_to_millis, millis_to_blob_ticks},
 };
 
 #[cfg_attr(esp32c2, path = "os_adapter_esp32c2.rs")]
@@ -633,36 +634,27 @@ unsafe extern "C" fn ble_npl_hw_set_isr(_no: i32, _mask: u32) {
     todo!()
 }
 
-// NPL counts in milliseconds. Let's not lose range by using micros for our tick rate.
-const fn npl_time_to_ms(time: ble_npl_time_t) -> u32 {
-    time
-}
-
-const fn npl_ms_to_time(ms: u32) -> ble_npl_time_t {
-    ms
-}
-
 unsafe extern "C" fn ble_npl_time_delay(time: ble_npl_time_t) {
-    let time = npl_time_to_ms(time);
-    crate::preempt::usleep(time * 1000);
+    let time = blob_ticks_to_micros(time);
+    crate::preempt::usleep(time);
 }
 
 unsafe extern "C" fn ble_npl_time_ticks_to_ms32(time: ble_npl_time_t) -> u32 {
     trace!("ble_npl_time_ticks_to_ms32 {}", time);
-    npl_time_to_ms(time)
+    blob_ticks_to_millis(time)
 }
 
 unsafe extern "C" fn ble_npl_time_ms_to_ticks32(ms: u32) -> ble_npl_time_t {
     trace!("ble_npl_time_ms_to_ticks32 {}", ms);
-    npl_ms_to_time(ms)
+    millis_to_blob_ticks(ms)
 }
 
 unsafe extern "C" fn ble_npl_time_ticks_to_ms(
     time: ble_npl_time_t,
     p_ms: *mut u32,
 ) -> ble_npl_error_t {
     trace!("ble_npl_time_ticks_to_ms {}", time);
-    unsafe { *p_ms = npl_time_to_ms(time) };
+    unsafe { *p_ms = blob_ticks_to_millis(time) };
     0
 }
 
@@ -671,7 +663,7 @@ unsafe extern "C" fn ble_npl_time_ms_to_ticks(
     p_time: *mut ble_npl_time_t,
 ) -> ble_npl_error_t {
     trace!("ble_npl_time_ms_to_ticks {}", ms);
-    unsafe { *p_time = npl_ms_to_time(ms) };
+    unsafe { *p_time = millis_to_blob_ticks(ms) };
     0
 }
 
@@ -724,7 +716,7 @@ unsafe extern "C" fn ble_npl_callout_stop(callout: *const ble_npl_callout) {
     unsafe {
         let co = (*callout).dummy as *mut Callout;
         // stop timer
-        compat::timer_compat::compat_timer_disarm(addr_of_mut!((*co).timer_handle));
+        compat::timer_compat::compat_timer_disarm(&raw mut (*co).timer_handle);
     }
 }
 
@@ -737,7 +729,11 @@ unsafe extern "C" fn ble_npl_callout_reset(
     let co = unsafe { (*callout).dummy } as *mut Callout;
     unsafe {
         // start timer
-        compat::timer_compat::compat_timer_arm(addr_of_mut!((*co).timer_handle), time, false);
+        compat::timer_compat::compat_timer_arm(
+            &raw mut (*co).timer_handle,
+            blob_ticks_to_millis(time),
+            false,
+        );
     }
     0
 }
@@ -942,7 +938,12 @@ unsafe extern "C" fn ble_npl_eventq_get(
     let mut evt = core::ptr::null_mut::<ble_npl_event>();
     let wrapper = unwrap!(unsafe { queue.as_mut() }, "queue wrapper is null");
 
-    if queue::queue_receive(wrapper.dummy as _, (&raw mut evt).cast(), timeout) == 1 {
+    if queue::queue_receive(
+        wrapper.dummy as _,
+        (&raw mut evt).cast(),
+        blob_ticks_to_micros(timeout),
+    ) == 1
+    {
         trace!("got {:x}", evt as usize);
         unsafe {
             let evt = (*evt).dummy as *mut Event;
@@ -1227,7 +1228,7 @@ pub(crate) fn ble_init() {
 
         // this is to avoid (ASSERT r_ble_hci_ram_hs_cmd_tx:34 0 0)
         // we wait a bit to make sure the ble task initialized everything
-        crate::compat::common::sleep(10);
+        crate::preempt::usleep(10_000);
     }
 
     // At some point the "High-speed ADC" entropy source became available.
@@ -1245,7 +1246,7 @@ pub(crate) fn ble_deinit() {
         // Prevent ASSERT r_ble_ll_reset:1069 ... ...
         // TODO: the cause of the issue is that the BLE controller can be dropped while the driver
         // is in the process of handling a HCI command.
-        crate::compat::common::sleep(10);
+        crate::preempt::usleep(10_000);
         // HCI deinit
         npl::r_ble_hci_trans_cfg_hs(None, core::ptr::null(), None, core::ptr::null());
 

esp-radio/src/common_adapter/mod.rs

@@ -16,10 +16,11 @@ use portable_atomic::{AtomicU32, Ordering};
 use crate::{
     binary::{
         c_types::{c_int, c_ulong, c_void},
-        include::{esp_event_base_t, esp_timer_get_time},
+        include::esp_event_base_t,
     },
     compat::{common::*, semaphore::*},
     hal::{self, clock::ModemClockController, ram},
+    time::blob_ticks_to_micros,
 };
 
 #[cfg_attr(esp32c3, path = "common_adapter_esp32c3.rs")]
@@ -121,7 +122,7 @@ pub unsafe extern "C" fn semphr_delete(semphr: *mut c_void) {
 #[ram]
 pub unsafe extern "C" fn semphr_take(semphr: *mut c_void, tick: u32) -> i32 {
     trace!(">>>> semphr_take {:?} block_time_tick {}", semphr, tick);
-    sem_take(semphr, tick)
+    sem_take(semphr, blob_ticks_to_micros(tick))
 }
 
 #[ram]
@@ -198,9 +199,11 @@ pub unsafe extern "C" fn read_mac(mac: *mut u8, type_: u32) -> c_int {
         }
     }
 
+    const ESP_MAC_WIFI_SOFTAP: u32 = 1;
+    const ESP_MAC_BT: u32 = 2;
+
     unsafe {
-        // ESP_MAC_WIFI_SOFTAP
-        if type_ == 1 {
+        if type_ == ESP_MAC_WIFI_SOFTAP {
             let tmp = mac.offset(0).read_volatile();
             for i in 0..64 {
                 mac.offset(0).write_volatile(tmp | 0x02);
@@ -211,10 +214,7 @@ pub unsafe extern "C" fn read_mac(mac: *mut u8, type_: u32) -> c_int {
                     break;
                 }
             }
-        }
-
-        // ESP_MAC_BT
-        if type_ == 2 {
+        } else if type_ == ESP_MAC_BT {
             let tmp = mac.offset(0).read_volatile();
             for i in 0..64 {
                 mac.offset(0).write_volatile(tmp | 0x02);
@@ -228,6 +228,8 @@ pub unsafe extern "C" fn read_mac(mac: *mut u8, type_: u32) -> c_int {
 
             mac.offset(5)
                 .write_volatile(mac.offset(5).read_volatile() + 1);
+        } else {
+            return -1;
         }
     }
 
@@ -273,20 +275,20 @@ pub unsafe extern "C" fn ets_timer_setfn(
 }
 
 #[cfg(feature = "wifi")]
-pub unsafe extern "C" fn ets_timer_arm(timer: *mut c_void, tmout: u32, repeat: bool) {
-    crate::compat::timer_compat::compat_timer_arm(timer.cast(), tmout, repeat);
+pub unsafe extern "C" fn ets_timer_arm(timer: *mut c_void, ms: u32, repeat: bool) {
+    crate::compat::timer_compat::compat_timer_arm(timer.cast(), ms, repeat);
 }
 
 #[cfg(feature = "wifi")]
-pub unsafe extern "C" fn ets_timer_arm_us(timer: *mut c_void, tmout: u32, repeat: bool) {
-    crate::compat::timer_compat::compat_timer_arm_us(timer.cast(), tmout, repeat);
+pub unsafe extern "C" fn ets_timer_arm_us(timer: *mut c_void, us: u32, repeat: bool) {
+    crate::compat::timer_compat::compat_timer_arm_us(timer.cast(), us, repeat);
 }
 
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn __esp_radio_gettimeofday(tv: *mut timeval, _tz: *mut ()) -> i32 {
     if !tv.is_null() {
         unsafe {
-            let microseconds = esp_timer_get_time();
+            let microseconds = __esp_radio_esp_timer_get_time();
             (*tv).tv_sec = (microseconds / 1_000_000) as u64;
             (*tv).tv_usec = (microseconds % 1_000_000) as u32;
         }
@@ -312,9 +314,10 @@ pub unsafe extern "C" fn __esp_radio_esp_timer_get_time() -> i64 {
     // will not need to have a scheduler in their firmware.
     cfg_if::cfg_if! {
         if #[cfg(any(feature = "wifi", feature = "ble"))] {
-            crate::time::ticks_to_micros(crate::preempt::now()) as i64
+            crate::preempt::now() as i64
         } else {
-            unreachable!()
+            // In this case we don't have a scheduler, we can return esp-hal's timestamp.
+            esp_hal::time::Instant::now().duration_since_epoch().as_micros() as i64
         }
     }
 }
@@ -492,7 +495,11 @@ pub unsafe extern "C" fn queue_send(
     item: *mut c_void,
     block_time_tick: u32,
 ) -> i32 {
-    crate::compat::queue::queue_send_to_back(queue.cast(), item.cast_const(), block_time_tick)
+    crate::compat::queue::queue_send_to_back(
+        queue.cast(),
+        item.cast_const(),
+        blob_ticks_to_micros(block_time_tick),
+    )
 }
 
 /// **************************************************************************
@@ -539,7 +546,11 @@ pub unsafe extern "C" fn queue_send_to_back(
     item: *mut c_void,
     block_time_tick: u32,
 ) -> i32 {
-    crate::compat::queue::queue_send_to_back(queue.cast(), item, block_time_tick)
+    crate::compat::queue::queue_send_to_back(
+        queue.cast(),
+        item,
+        blob_ticks_to_micros(block_time_tick),
+    )
 }
 
 /// **************************************************************************
@@ -562,7 +573,11 @@ pub unsafe extern "C" fn queue_send_to_front(
     item: *mut c_void,
     block_time_tick: u32,
 ) -> i32 {
-    crate::compat::queue::queue_send_to_front(queue.cast(), item, block_time_tick)
+    crate::compat::queue::queue_send_to_front(
+        queue.cast(),
+        item,
+        blob_ticks_to_micros(block_time_tick),
+    )
 }
 
 /// **************************************************************************
@@ -583,9 +598,9 @@ pub unsafe extern "C" fn queue_send_to_front(
 pub unsafe extern "C" fn queue_recv(
     queue: *mut c_void,
     item: *mut c_void,
-    block_time_tick: u32,
+    block_time_ms: u32,
 ) -> i32 {
-    crate::compat::queue::queue_receive(queue.cast(), item, block_time_tick)
+    crate::compat::queue::queue_receive(queue.cast(), item, blob_ticks_to_micros(block_time_ms))
 }
 
 pub unsafe extern "C" fn queue_recv_from_isr(

esp-radio/src/compat/common.rs

@@ -15,7 +15,7 @@ use esp_wifi_sys::{c_types::c_char, include::malloc};
 use super::{OSI_FUNCS_TIME_BLOCKING, malloc::free};
 use crate::{
     ESP_RADIO_LOCK,
-    binary::c_types::{c_int, c_void},
+    binary::c_types::{c_int, c_uint, c_void},
     memory_fence::memory_fence,
     preempt::{current_task, yield_task},
 };
@@ -44,14 +44,10 @@ pub(crate) fn thread_sem_get() -> *mut c_void {
 /// Implementation of sleep() from newlib in esp-idf.
 /// components/newlib/time.c
 #[unsafe(no_mangle)]
-pub(crate) unsafe extern "C" fn sleep(
-    millis: crate::binary::c_types::c_uint,
-) -> crate::binary::c_types::c_uint {
+pub(crate) unsafe extern "C" fn sleep(seconds: c_uint) -> c_uint {
     trace!("sleep");
 
-    unsafe {
-        usleep(millis * 1_000);
-    }
+    unsafe { usleep(seconds * 1_000_000) };
     0
 }
 

esp-radio/src/compat/mutex.rs

@@ -1,9 +1,6 @@
 use esp_wifi_sys::c_types::c_void;
 
-use crate::{
-    compat::OSI_FUNCS_TIME_BLOCKING,
-    preempt::mutex::{MutexHandle, MutexPtr},
-};
+use crate::preempt::mutex::{MutexHandle, MutexPtr};
 
 pub(crate) fn mutex_create(recursive: bool) -> *mut c_void {
     MutexHandle::new(recursive).leak().as_ptr().cast()
@@ -16,18 +13,12 @@ pub(crate) fn mutex_delete(mutex: *mut c_void) {
     core::mem::drop(handle);
 }
 
-pub(crate) fn mutex_lock(mutex: *mut c_void, tick: u32) -> i32 {
+pub(crate) fn mutex_lock(mutex: *mut c_void) -> i32 {
     let ptr = unwrap!(MutexPtr::new(mutex.cast()), "mutex is null");
 
     let handle = unsafe { MutexHandle::ref_from_ptr(&ptr) };
-    // Assuming `tick` is in microseconds
-    let timeout = if tick == OSI_FUNCS_TIME_BLOCKING {
-        None
-    } else {
-        Some(tick)
-    };
-
-    handle.lock(timeout) as i32
+
+    handle.lock(None) as i32
 }
 
 pub(crate) fn mutex_unlock(mutex: *mut c_void) -> i32 {

esp-radio/src/compat/timer_compat.rs

@@ -8,15 +8,15 @@ use crate::{
 };
 
 pub(crate) fn compat_timer_arm(ets_timer: *mut ets_timer, tmout_ms: u32, repeat: bool) {
-    compat_timer_arm_us(ets_timer, tmout_ms * 1000, repeat);
+    compat_timer_arm_us(ets_timer, tmout_ms.saturating_mul(1000), repeat);
 }
 
 pub(crate) fn compat_timer_arm_us(ets_timer: *mut ets_timer, us: u32, repeat: bool) {
     trace!(
-        "timer_arm_us {:x} current: {} ticks: {} repeat: {}",
+        "timer_arm_us {:x} current: {} micros: {} repeat: {}",
         ets_timer as usize,
         crate::preempt::now(),
-        crate::time::micros_to_ticks(us as u64),
+        us,
         repeat
     );
 

esp-radio/src/time.rs

@@ -1,19 +1,21 @@
 //! Time conversions
+//!
+//! We're using 1ms per tick, to offer a decent-ish timeout range on u32.
+
 #![allow(unused)]
-pub const TICKS_PER_SECOND: u64 = 1_000_000;
 
-pub(crate) fn micros_to_ticks(us: u64) -> u64 {
-    us * (TICKS_PER_SECOND / 1_000_000)
+pub(crate) const fn blob_ticks_to_micros(ticks: u32) -> u32 {
+    ticks.saturating_mul(1_000)
 }
 
-pub(crate) fn millis_to_ticks(ms: u64) -> u64 {
-    ms * (TICKS_PER_SECOND / 1_000)
+pub(crate) const fn micros_to_blob_ticks(micros: u32) -> u32 {
+    micros / 1_000
 }
 
-pub(crate) fn ticks_to_micros(ticks: u64) -> u64 {
-    ticks / (TICKS_PER_SECOND / 1_000_000)
+pub(crate) const fn blob_ticks_to_millis(ticks: u32) -> u32 {
+    ticks
 }
 
-pub(crate) fn ticks_to_millis(ticks: u64) -> u64 {
-    ticks / (TICKS_PER_SECOND / 1_000)
+pub(crate) const fn millis_to_blob_ticks(millis: u32) -> u32 {
+    millis
 }