WIP - Make FreeRTOS a first-class citizen

With the expanded performance and memory of the Pico 2, having a full
operating system with threads could really improve developer life and
get the best possible algorithm performance.

Start by moving FreeRTOS checks from a global bool set by weak function
linkage checks to a compiler definition.  This can allow the build process
to differ between bare metal and FreeRTOS builds (i.e. async_context
implementations) and save a few bytes of program space.

Author: earlephilhower

boards.txt

@@ -109,9 +109,6 @@ void analogWriteResolution(int res);
 } // extern "C"
 #endif
 
-// FreeRTOS potential calls
-extern bool __isFreeRTOS;
-
 // Ancient AVR defines
 #define HAVE_HWSERIAL0
 #define HAVE_HWSERIAL1

cores/rp2040/Arduino.h

@@ -26,9 +26,9 @@ static bool __no_inline_not_in_flash_func(get_bootsel_button)() {
 
     // Must disable interrupts, as interrupt handlers may be in flash, and we
     // are about to temporarily disable flash access!
-    if (!__isFreeRTOS) {
-        noInterrupts();
-    }
+#ifndef __FREERTOS
+    noInterrupts();
+#endif
     rp2040.idleOtherCore();
 
     // Set chip select to Hi-Z
@@ -55,9 +55,9 @@ static bool __no_inline_not_in_flash_func(get_bootsel_button)() {
                     IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_BITS);
 
     rp2040.resumeOtherCore();
-    if (!__isFreeRTOS) {
-        interrupts();
-    }
+#ifndef __FREERTOS
+    interrupts();
+#endif
 
     return button_state;
 }

cores/rp2040/Bootsel.cpp

@@ -28,45 +28,45 @@ CoreMutex::CoreMutex(mutex_t *mutex, uint8_t option) {
     _mutex = mutex;
     _acquired = false;
     _option = option;
+#ifdef __FREERTOS
     _pxHigherPriorityTaskWoken = 0; // pdFALSE
-    if (__isFreeRTOS) {
-        auto m = __get_freertos_mutex_for_ptr(mutex);
+    auto m = __get_freertos_mutex_for_ptr(mutex);
 
-        if (__freertos_check_if_in_isr()) {
-            if (!__freertos_mutex_take_from_isr(m, &_pxHigherPriorityTaskWoken)) {
-                return;
-            }
-            // At this point we have the mutex in ISR
-        } else {
-            // Grab the mutex normally, possibly waking other tasks to get it
-            __freertos_mutex_take(m);
+    if (__freertos_check_if_in_isr()) {
+        if (!__freertos_mutex_take_from_isr(m, &_pxHigherPriorityTaskWoken)) {
+            return;
         }
+        // At this point we have the mutex in ISR
     } else {
-        uint32_t owner;
-        if (!mutex_try_enter(_mutex, &owner)) {
-            if (owner == get_core_num()) { // Deadlock!
-                if (_option & DebugEnable) {
-                    DEBUGCORE("CoreMutex - Deadlock detected!\n");
-                }
-                return;
+        // Grab the mutex normally, possibly waking other tasks to get it
+        __freertos_mutex_take(m);
+    }
+#else
+    uint32_t owner;
+    if (!mutex_try_enter(_mutex, &owner)) {
+        if (owner == get_core_num()) { // Deadlock!
+            if (_option & DebugEnable) {
+                DEBUGCORE("CoreMutex - Deadlock detected!\n");
             }
-            mutex_enter_blocking(_mutex);
+            return;
         }
+        mutex_enter_blocking(_mutex);
     }
+#endif
     _acquired = true;
 }
 
 CoreMutex::~CoreMutex() {
     if (_acquired) {
-        if (__isFreeRTOS) {
-            auto m = __get_freertos_mutex_for_ptr(_mutex);
-            if (__freertos_check_if_in_isr()) {
-                __freertos_mutex_give_from_isr(m, &_pxHigherPriorityTaskWoken);
-            } else {
-                __freertos_mutex_give(m);
-            }
+#ifdef __FREERTOS
+        auto m = __get_freertos_mutex_for_ptr(_mutex);
+        if (__freertos_check_if_in_isr()) {
+            __freertos_mutex_give_from_isr(m, &_pxHigherPriorityTaskWoken);
         } else {
-            mutex_exit(_mutex);
+            __freertos_mutex_give(m);
         }
+#else
+        mutex_exit(_mutex);
+#endif
     }
 }

cores/rp2040/CoreMutex.cpp

@@ -43,5 +43,7 @@ class CoreMutex {
     mutex_t *_mutex;
     bool _acquired;
     uint8_t _option;
+#ifdef __FREERTOS
     BaseType_t _pxHigherPriorityTaskWoken;
+#endif
 };

cores/rp2040/CoreMutex.h

@@ -72,17 +72,18 @@ class _MFIFO {
     }
 
     void registerCore() {
-        if (!__isFreeRTOS) {
-            multicore_fifo_clear_irq();
+#ifndef __FREERTOS
+        multicore_fifo_clear_irq();
 #ifdef PICO_RP2350
-            irq_set_exclusive_handler(SIO_IRQ_FIFO, _irq);
-            irq_set_enabled(SIO_IRQ_FIFO, true);
+        irq_set_exclusive_handler(SIO_IRQ_FIFO, _irq);
+        irq_set_enabled(SIO_IRQ_FIFO, true);
 #else
-            irq_set_exclusive_handler(SIO_IRQ_PROC0 + get_core_num(), _irq);
-            irq_set_enabled(SIO_IRQ_PROC0 + get_core_num(), true);
+        irq_set_exclusive_handler(SIO_IRQ_PROC0 + get_core_num(), _irq);
+        irq_set_enabled(SIO_IRQ_PROC0 + get_core_num(), true);
 #endif
-        }
+#else
         // FreeRTOS port.c will handle the IRQ hooking
+#endif
     }
 
     void push(uint32_t val) {
@@ -113,14 +114,14 @@ class _MFIFO {
         if (!_multicore) {
             return;
         }
-        if (__isFreeRTOS) {
-            __freertos_idle_other_core();
-        } else {
-            mutex_enter_blocking(&_idleMutex);
-            __otherCoreIdled = false;
-            multicore_fifo_push_blocking(_GOTOSLEEP);
-            while (!__otherCoreIdled) { /* noop */ }
-        }
+#ifdef __FREERTOS
+        __freertos_idle_other_core();
+#else
+        mutex_enter_blocking(&_idleMutex);
+        __otherCoreIdled = false;
+        multicore_fifo_push_blocking(_GOTOSLEEP);
+        while (!__otherCoreIdled) { /* noop */ }
+#endif
     }
 
     void resumeOtherCore() {
@@ -129,9 +130,9 @@ class _MFIFO {
         }
         mutex_exit(&_idleMutex);
         __otherCoreIdled = false;
-        if (__isFreeRTOS) {
-            __freertos_resume_other_core();
-        }
+#ifdef __FREERTOS
+        __freertos_resume_other_core();
+#endif
 
         // Other core will exit busy-loop and return to operation
         // once __otherCoreIdled == false.
@@ -151,18 +152,18 @@ class _MFIFO {
 
 private:
     static void __no_inline_not_in_flash_func(_irq)() {
-        if (!__isFreeRTOS) {
-            multicore_fifo_clear_irq();
-            noInterrupts(); // We need total control, can't run anything
-            while (multicore_fifo_rvalid()) {
-                if (_GOTOSLEEP == multicore_fifo_pop_blocking()) {
-                    __otherCoreIdled = true;
-                    while (__otherCoreIdled) { /* noop */ }
-                    break;
-                }
+#ifndef __FREERTOS
+        multicore_fifo_clear_irq();
+        noInterrupts(); // We need total control, can't run anything
+        while (multicore_fifo_rvalid()) {
+            if (_GOTOSLEEP == multicore_fifo_pop_blocking()) {
+                __otherCoreIdled = true;
+                while (__otherCoreIdled) { /* noop */ }
+                break;
             }
-            interrupts();
         }
+        interrupts();
+#endif
     }
 
     bool _multicore = false;
@@ -192,23 +193,19 @@ class RP2040 {
 
     void begin(int cpuid) {
         _epoch[cpuid] = 0;
-#if !defined(__riscv) && !defined(__PROFILE)
-        if (!__isFreeRTOS) {
-            // Enable SYSTICK exception
-            exception_set_exclusive_handler(SYSTICK_EXCEPTION, _SystickHandler);
-            systick_hw->csr = 0x7;
-            systick_hw->rvr = 0x00FFFFFF;
-        } else {
-#endif
-            // Only start 1 instance of the PIO SM
-            if (cpuid == 0) {
-                int off = 0;
-                _ccountPgm = new PIOProgram(&ccount_program);
-                _ccountPgm->prepare(&_pio, &_sm, &off);
-                ccount_program_init(_pio, _sm, off);
-                pio_sm_set_enabled(_pio, _sm, true);
-            }
-#if !defined(__riscv) && !defined(__PROFILE)
+#if !defined(__riscv) && !defined(__PROFILE) && !defined(__FREERTOS)
+        // Enable SYSTICK exception
+        exception_set_exclusive_handler(SYSTICK_EXCEPTION, _SystickHandler);
+        systick_hw->csr = 0x7;
+        systick_hw->rvr = 0x00FFFFFF;
+#else
+        // Only start 1 instance of the PIO SM
+        if (cpuid == 0) {
+            int off = 0;
+            _ccountPgm = new PIOProgram(&ccount_program);
+            _ccountPgm->prepare(&_pio, &_sm, &off);
+            ccount_program_init(_pio, _sm, off);
+            pio_sm_set_enabled(_pio, _sm, true);
         }
 #endif
     }
@@ -255,21 +252,17 @@ class RP2040 {
         @returns CPU clock cycles since power up
     */
     inline uint32_t getCycleCount() {
-#if !defined(__riscv) && !defined(__PROFILE)
+#if !defined(__riscv) && !defined(__PROFILE) && !defined(__FREERTOS)
         // Get CPU cycle count.  Needs to do magic to extend 24b HW to something longer
-        if (!__isFreeRTOS) {
-            uint32_t epoch;
-            uint32_t ctr;
-            do {
-                epoch = (uint32_t)_epoch[sio_hw->cpuid];
-                ctr = systick_hw->cvr;
-            } while (epoch != (uint32_t)_epoch[sio_hw->cpuid]);
-            return epoch + (1 << 24) - ctr; /* CTR counts down from 1<<24-1 */
-        } else {
-#endif
-            return ccount_read(_pio, _sm);
-#if !defined(__riscv) && !defined(__PROFILE)
-        }
+        uint32_t epoch;
+        uint32_t ctr;
+        do {
+            epoch = (uint32_t)_epoch[sio_hw->cpuid];
+            ctr = systick_hw->cvr;
+        } while (epoch != (uint32_t)_epoch[sio_hw->cpuid]);
+        return epoch + (1 << 24) - ctr; /* CTR counts down from 1<<24-1 */
+#else
+        return ccount_read(_pio, _sm);
 #endif
     }
     /**
@@ -278,20 +271,16 @@ class RP2040 {
         @returns CPU clock cycles since power up
     */
     inline uint64_t getCycleCount64() {
-#if !defined(__riscv) && !defined(__PROFILE)
-        if (!__isFreeRTOS) {
-            uint64_t epoch;
-            uint64_t ctr;
-            do {
-                epoch = _epoch[sio_hw->cpuid];
-                ctr = systick_hw->cvr;
-            } while (epoch != _epoch[sio_hw->cpuid]);
-            return epoch + (1LL << 24) - ctr;
-        } else {
-#endif
-            return ccount_read(_pio, _sm);
-#if !defined(__riscv) && !defined(__PROFILE)
-        }
+#if !defined(__riscv) && !defined(__PROFILE) && !defined(__FREERTOS)
+        uint64_t epoch;
+        uint64_t ctr;
+        do {
+            epoch = _epoch[sio_hw->cpuid];
+            ctr = systick_hw->cvr;
+        } while (epoch != _epoch[sio_hw->cpuid]);
+        return epoch + (1LL << 24) - ctr;
+#else
+        return ccount_read(_pio, _sm);
 #endif
     }
 

cores/rp2040/RP2040Support.h

@@ -181,9 +181,9 @@ static int _bps = 115200;
 static bool _rebooting = false;
 static void CheckSerialReset() {
     if (!_rebooting && (_bps == 1200) && (!_dtr)) {
-        if (__isFreeRTOS) {
-            __freertos_idle_other_core();
-        }
+#ifdef __FREERTOS
+        __freertos_idle_other_core();
+#endif
         _rebooting = true;
         // Disable NVIC IRQ, so that we don't get bothered anymore
         irq_set_enabled(USBCTRL_IRQ, false);

cores/rp2040/SerialUSB.cpp

@@ -18,6 +18,8 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#ifdef __FREERTOS
+
 #include "_freertos.h"
 #include <pico/mutex.h>
 #include <stdlib.h>
@@ -60,3 +62,5 @@ SemaphoreHandle_t __get_freertos_mutex_for_ptr(mutex_t *m, bool recursive) {
     }
     return nullptr; // Need to make space for more mutex maps!
 }
+
+#endif

cores/rp2040/_freertos.cpp

@@ -18,15 +18,15 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#ifdef __FREERTOS
+
 #pragma once
 #include <pico/mutex.h>
 
 // Cannot include refs to FreeRTOS's actual semaphore calls because they
 // are implemented as macros, so we have a wrapper in our variant hook
 // to handle it.
 
-extern bool __isFreeRTOS;
-
 // FreeRTOS has been set up
 extern volatile bool __freeRTOSinitted;
 
@@ -63,3 +63,5 @@ extern void __freertos_task_enter_critical() __attribute__((weak));
 }
 extern SemaphoreHandle_t __get_freertos_mutex_for_ptr(mutex_t *m, bool recursive = false);
 #endif // __cplusplus
+
+#endif // __FREERTOS