pbio/drv/clock: Add hooks for mphal.

By abstracting away the requirements for mp_hal_delay_ms we should be able to share the definition of mp_hal_delay_ms between platforms.

The clock driver is a good place for this since most implementations already have their own blocking wait for when IRQs are disabled.

Author: laurensvalk

bricks/_common/sources.mk

@@ -144,7 +144,6 @@ PBIO_SRC_C = $(addprefix lib/pbio/,\
 	drv/clock/clock_stm32.c \
 	drv/clock/clock_test.c \
 	drv/clock/clock_ev3.c \
-	drv/clock/clock_virtual.c \
 	drv/core.c \
 	drv/counter/counter_ev3.c \
 	drv/counter/counter_stm32f0_gpio_quad_enc.c \

bricks/_common_stm32/mphalport.c

@@ -8,6 +8,7 @@
 
 #include <contiki.h>
 
+#include <pbdrv/clock.h>
 #include <pbdrv/config.h>
 #include <pbio/main.h>
 #include <pbsys/bluetooth.h>
@@ -23,7 +24,7 @@ extern volatile uint32_t pbdrv_clock_ticks;
 // Core delay function that does an efficient sleep and may switch thread context.
 // If IRQs are enabled then we must have the GIL.
 void mp_hal_delay_ms(mp_uint_t Delay) {
-    if (__get_PRIMASK() == 0) {
+    if (pbdrv_clock_is_ticking()) {
         // IRQs enabled, so can use systick counter to do the delay
         uint32_t start = pbdrv_clock_ticks;
         // Wraparound of tick is taken care of by 2's complement arithmetic.
@@ -35,12 +36,7 @@ void mp_hal_delay_ms(mp_uint_t Delay) {
         } while (pbdrv_clock_ticks - start < Delay);
     } else {
         // IRQs disabled, so need to use a busy loop for the delay.
-        // To prevent possible overflow of the counter we use a double loop.
-        const uint32_t count_1ms = PBDRV_CONFIG_SYS_CLOCK_RATE / 4000;
-        for (mp_uint_t i = 0; i < Delay; i++) {
-            for (uint32_t count = 0; ++count <= count_1ms;) {
-            }
-        }
+        pbdrv_clock_busy_delay_ms(Delay);
     }
 }
 

lib/pbio/drv/clock/clock_ev3.c

@@ -119,4 +119,13 @@ uint32_t pbdrv_clock_get_100us(void) {
     return pbdrv_clock_get_ms() * 10;
 }
 
+void pbdrv_clock_busy_delay_ms(uint32_t ms) {
+    // TODO
+}
+
+bool pbdrv_clock_is_ticking(void) {
+    // TODO
+    return true;
+}
+
 #endif // PBDRV_CONFIG_CLOCK_TIAM1808

lib/pbio/drv/clock/clock_linux.c

@@ -112,4 +112,14 @@ uint32_t pbdrv_clock_get_us(void) {
     return time_val.tv_sec * 1000000 + time_val.tv_nsec / 1000;
 }
 
+void pbdrv_clock_busy_delay_ms(uint32_t ms) {
+    uint32_t start = pbdrv_clock_get_ms();
+    while (pbdrv_clock_get_ms() - start < ms) {
+    }
+}
+
+bool pbdrv_clock_is_ticking(void) {
+    return true;
+}
+
 #endif // PBDRV_CONFIG_CLOCK_LINUX

lib/pbio/drv/clock/clock_none.c

@@ -22,4 +22,11 @@ uint32_t pbdrv_clock_get_100us(void) {
     return 0;
 }
 
+void pbdrv_clock_busy_delay_ms(uint32_t ms) {
+}
+
+bool pbdrv_clock_is_ticking(void) {
+    return false;
+}
+
 #endif // PBDRV_CONFIG_CLOCK_NONE

lib/pbio/drv/clock/clock_nxt.c

@@ -98,6 +98,10 @@ void nx_systick_wait_ms(uint32_t ms) {
     }
 }
 
+void pbdrv_clock_busy_delay_ms(uint32_t ms) {
+    nx_systick_wait_ms(ms);
+}
+
 void nx_systick_wait_ns(uint32_t ns) {
     volatile uint32_t x = (ns >> 7) + 1;
 
@@ -106,4 +110,9 @@ void nx_systick_wait_ns(uint32_t ns) {
     }
 }
 
+bool pbdrv_clock_is_ticking(void) {
+    // TODO
+    return true;
+}
+
 #endif // PBDRV_CONFIG_CLOCK_NXT

lib/pbio/drv/clock/clock_stm32.c

@@ -112,4 +112,14 @@ void HAL_Delay(uint32_t Delay) {
     }
 }
 
+void pbdrv_clock_busy_delay_ms(uint32_t ms) {
+    HAL_Delay(ms);
+}
+
+bool pbdrv_clock_is_ticking(void) {
+    // Init already completed in SystemInit(), so we just need to check if
+    // interrupts are enabled.
+    return __get_PRIMASK() == 0;
+}
+
 #endif // PBDRV_CONFIG_CLOCK_STM32

lib/pbio/drv/clock/clock_test.c

@@ -41,5 +41,12 @@ uint32_t pbdrv_clock_get_us(void) {
     return clock_ticks * 1000;
 }
 
+void pbdrv_clock_busy_delay_ms(uint32_t ms) {
+}
+
+bool pbdrv_clock_is_ticking(void) {
+    return true;
+}
+
 
 #endif // PBDRV_CONFIG_CLOCK_TEST

lib/pbio/drv/clock/clock_virtual.c

@@ -9,6 +9,7 @@
 #ifndef _PBDRV_CLOCK_H_
 #define _PBDRV_CLOCK_H_
 
+#include <stdbool.h>
 #include <stdint.h>
 
 /**
@@ -36,6 +37,26 @@ uint32_t pbdrv_clock_get_us(void);
  */
 void pbdrv_clock_busy_delay_us(uint32_t us);
 
+/**
+ * Busy wait delay for several milliseconds. May not be accurate.
+ *
+ * NB: Should not be used in any driver code. This exists only as a hook for
+ * APIs that need a blocking delay to work when interrupts could be disabled.
+ *
+ * @param [in]  ms  The number of milliseconds to delay.
+ */
+void pbdrv_clock_busy_delay_ms(uint32_t ms);
+
+/**
+ * Tests if the millisecond clock is ticking.
+ *
+ * On embedded systems, this means that the clock was initialized and IRQs are
+ * enabled.
+ *
+ * @return True if the clock is ticking, false otherwise.
+ */
+bool pbdrv_clock_is_ticking(void);
+
 #endif /* _PBDRV_CLOCK_H_ */
 
 /** @} */