Add FreeRTOS support thanks to @hfellner (#533)

Using all the work from @hfellner and others, add FreeRTOS
SMP support.

Allow idling cores through the FreeRTOS FIFO queue to
allow for file system and EEPROM support.

Make delay a weak function so FreeRTOS can override.

Add cycle count support under FreeRTOS using a PIO SM.

Use a task-based approach for handling the USB periodic work
instead of the IRQ-based one in the main core.

Set 8 prio levels so it fits in 3 bits nicely (0..7).

Author: earlephilhower

.github/workflows/pull-request.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Run codespell
       uses: codespell-project/actions-codespell@master
       with:
-        skip: ./pico-extras,./ArduinoCore-API,./libraries/ESP8266SdFat,./libraries/Adafruit_TinyUSB_Arduino,./libraries/LittleFS/lib,./tools/pyserial,./pico-sdk,./.github,./docs/i2s.rst,./cores/rp2040/api
+        skip: ./pico-extras,./ArduinoCore-API,./libraries/ESP8266SdFat,./libraries/Adafruit_TinyUSB_Arduino,./libraries/LittleFS/lib,./tools/pyserial,./pico-sdk,./.github,./docs/i2s.rst,./cores/rp2040/api,./libraries/FreeRTOS
         ignore_words_list: ser,DOUT
 
 # Consistent style

.gitmodules

@@ -25,3 +25,6 @@
 [submodule "libraries/Adafruit_TinyUSB_Arduino"]
 	path = libraries/Adafruit_TinyUSB_Arduino
 	url = https://github.com/adafruit/Adafruit_TinyUSB_Arduino.git
+[submodule "libraries/FreeRTOS/lib/FreeRTOS-Kernel"]
+	path = libraries/FreeRTOS/lib/FreeRTOS-Kernel
+	url = https://github.com/earlephilhower/FreeRTOS-Kernel.git

README.md

@@ -173,6 +173,7 @@ If you want to contribute or have bugfixes, drop me a note at <earlephilhower@ya
 * [LittleFS](https://github.com/ARMmbed/littlefs) library written by ARM Limited and released under the [BSD 3-clause license](https://github.com/ARMmbed/littlefs/blob/master/LICENSE.md).
 * [UF2CONV.PY](https://github.com/microsoft/uf2) is by Microsoft Corporation and licensed under the MIT license.
 * Some filesystem code taken from the [ESP8266 Arduino Core](https://github.com/esp8266/Arduino) and licensed under the LGPL.
+* [FreeRTOS](https://freertos.org) is Copyright Amazon.com, Inc. or its affiliates, and distributed under the MIT license.
 
 -Earle F. Philhower, III
  [email protected]

cores/rp2040/Arduino.h

@@ -79,6 +79,9 @@ void analogWriteFreq(uint32_t freq);
 void analogWriteRange(uint32_t range);
 void analogWriteResolution(int res);
 
+// FreeRTOS potential calls
+extern bool __isFreeRTOS;
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

cores/rp2040/RP2040Support.h

@@ -25,7 +25,11 @@
 #include <hardware/structs/systick.h>
 #include <pico/multicore.h>
 #include <pico/util/queue.h>
-#include <CoreMutex.h>
+#include "CoreMutex.h"
+#include "ccount.pio.h"
+
+
+extern "C" volatile bool __otherCoreIdled;
 
 class _MFIFO {
 public:
@@ -45,9 +49,12 @@ class _MFIFO {
     }
 
     void registerCore() {
-        multicore_fifo_clear_irq();
-        irq_set_exclusive_handler(SIO_IRQ_PROC0 + get_core_num(), _irq);
-        irq_set_enabled(SIO_IRQ_PROC0 + get_core_num(), true);
+        if (!__isFreeRTOS) {
+            multicore_fifo_clear_irq();
+            irq_set_exclusive_handler(SIO_IRQ_PROC0 + get_core_num(), _irq);
+            irq_set_enabled(SIO_IRQ_PROC0 + get_core_num(), true);
+        }
+        // FreeRTOS port.c will handle the IRQ hooking
     }
 
     void push(uint32_t val) {
@@ -79,19 +86,19 @@ class _MFIFO {
             return;
         }
         mutex_enter_blocking(&_idleMutex);
-        _otherIdled = false;
+        __otherCoreIdled = false;
         multicore_fifo_push_blocking(_GOTOSLEEP);
-        while (!_otherIdled) { /* noop */ }
+        while (!__otherCoreIdled) { /* noop */ }
     }
 
     void resumeOtherCore() {
         if (!_multicore) {
             return;
         }
         mutex_exit(&_idleMutex);
-        _otherIdled = false;
+        __otherCoreIdled = false;
         // Other core will exit busy-loop and return to operation
-        // once otherIdled == false.
+        // once __otherCoreIdled == false.
     }
 
     void clear() {
@@ -108,98 +115,31 @@ class _MFIFO {
 
 private:
     static void __no_inline_not_in_flash_func(_irq)() {
-        multicore_fifo_clear_irq();
-        noInterrupts(); // We need total control, can't run anything
-        while (multicore_fifo_rvalid()) {
-            if (_GOTOSLEEP == multicore_fifo_pop_blocking()) {
-                _otherIdled = true;
-                while (_otherIdled) { /* noop */ }
-                break;
+        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;
+                }
             }
+            interrupts();
         }
-        interrupts();
     }
-    bool _multicore = false;
 
+    bool _multicore = false;
     mutex_t _idleMutex;
-    static volatile bool _otherIdled;
     queue_t _queue[2];
-
-    static constexpr int _GOTOSLEEP = 0x66666666;
+    static constexpr uint32_t _GOTOSLEEP = 0xC0DED02E;
 };
 
+
 class RP2040;
 extern RP2040 rp2040;
 extern "C" void main1();
-
-class RP2040 {
-public:
-    RP2040() {
-        _epoch = 0;
-        // Enable SYSTICK exception
-        exception_set_exclusive_handler(SYSTICK_EXCEPTION, _SystickHandler);
-        systick_hw->csr = 0x7;
-        systick_hw->rvr = 0x00FFFFFF;
-    }
-
-    ~RP2040() { /* noop */ }
-
-
-    // Convert from microseconds to PIO clock cycles
-    static int usToPIOCycles(int us) {
-        // Parenthesis needed to guarantee order of operations to avoid 32bit overflow
-        return (us * (clock_get_hz(clk_sys) / 1000000));
-    }
-
-    // Get current clock frequency
-    static int f_cpu() {
-        return clock_get_hz(clk_sys);
-    }
-
-    // Get CPU cycle count.  Needs to do magic to extens 24b HW to something longer
-    volatile uint64_t _epoch = 0;
-    inline uint32_t getCycleCount() {
-        uint32_t epoch;
-        uint32_t ctr;
-        do {
-            epoch = (uint32_t)_epoch;
-            ctr = systick_hw->cvr;
-        } while (epoch != (uint32_t)_epoch);
-        return epoch + (1 << 24) - ctr; /* CTR counts down from 1<<24-1 */
-    }
-
-    inline uint64_t getCycleCount64() {
-        uint64_t epoch;
-        uint64_t ctr;
-        do {
-            epoch = _epoch;
-            ctr = systick_hw->cvr;
-        } while (epoch != _epoch);
-        return epoch + (1LL << 24) - ctr;
-    }
-
-    void idleOtherCore() {
-        fifo.idleOtherCore();
-    }
-
-    void resumeOtherCore() {
-        fifo.resumeOtherCore();
-    }
-
-    void restartCore1() {
-        multicore_reset_core1();
-        fifo.clear();
-        multicore_launch_core1(main1);
-    }
-
-    // Multicore comms FIFO
-    _MFIFO fifo;
-
-private:
-    static void _SystickHandler() {
-        rp2040._epoch += 1LL << 24;
-    }
-};
+class PIOProgram;
 
 // Wrapper class for PIO programs, abstracting common operations out
 // TODO - Add unload/destructor
@@ -255,3 +195,90 @@ class PIOProgram {
     const pio_program_t *_pgm;
 };
 
+class RP2040 {
+public:
+    RP2040()  { /* noop */ }
+    ~RP2040() { /* noop */ }
+
+    void begin() {
+        _epoch = 0;
+        if (!__isFreeRTOS) {
+            // Enable SYSTICK exception
+            exception_set_exclusive_handler(SYSTICK_EXCEPTION, _SystickHandler);
+            systick_hw->csr = 0x7;
+            systick_hw->rvr = 0x00FFFFFF;
+        } else {
+            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);
+        }
+    }
+
+    // Convert from microseconds to PIO clock cycles
+    static int usToPIOCycles(int us) {
+        // Parenthesis needed to guarantee order of operations to avoid 32bit overflow
+        return (us * (clock_get_hz(clk_sys) / 1000000));
+    }
+
+    // Get current clock frequency
+    static int f_cpu() {
+        return clock_get_hz(clk_sys);
+    }
+
+    // Get CPU cycle count.  Needs to do magic to extens 24b HW to something longer
+    volatile uint64_t _epoch = 0;
+    inline uint32_t getCycleCount() {
+        if (!__isFreeRTOS) {
+            uint32_t epoch;
+            uint32_t ctr;
+            do {
+                epoch = (uint32_t)_epoch;
+                ctr = systick_hw->cvr;
+            } while (epoch != (uint32_t)_epoch);
+            return epoch + (1 << 24) - ctr; /* CTR counts down from 1<<24-1 */
+        } else {
+            return ccount_read(_pio, _sm);
+        }
+    }
+
+    inline uint64_t getCycleCount64() {
+        if (!__isFreeRTOS) {
+            uint64_t epoch;
+            uint64_t ctr;
+            do {
+                epoch = _epoch;
+                ctr = systick_hw->cvr;
+            } while (epoch != _epoch);
+            return epoch + (1LL << 24) - ctr;
+        } else {
+            return ccount_read(_pio, _sm);
+        }
+    }
+
+    void idleOtherCore() {
+        fifo.idleOtherCore();
+    }
+
+    void resumeOtherCore() {
+        fifo.resumeOtherCore();
+    }
+
+    void restartCore1() {
+        multicore_reset_core1();
+        fifo.clear();
+        multicore_launch_core1(main1);
+    }
+
+    // Multicore comms FIFO
+    _MFIFO fifo;
+
+private:
+    static void _SystickHandler() {
+        rp2040._epoch += 1LL << 24;
+    }
+    PIO _pio;
+    int _sm;
+    PIOProgram *_ccountPgm;
+};

cores/rp2040/RP2040USB.cpp

@@ -287,6 +287,8 @@ static int64_t timer_task(__unused alarm_id_t id, __unused void *user_data) {
     return USB_TASK_INTERVAL;
 }
 
+void __USBStart() __attribute__((weak));
+
 void __USBStart() {
     if (tusb_inited()) {
         // Already called

cores/rp2040/ccount.pio

@@ -0,0 +1,62 @@
+; Cycle Count for the Raspberry Pi Pico RP2040
+;
+; Copyright (c) 2022 Earle F. Philhower, III <[email protected]>
+;
+; This library is free software; you can redistribute it and/or
+; modify it under the terms of the GNU Lesser General Public
+; License as published by the Free Software Foundation; either
+; version 2.1 of the License, or (at your option) any later version.
+;
+; This library is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; Lesser General Public License for more details.
+;
+; You should have received a copy of the GNU Lesser General Public
+; License along with this library; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+; Cycle count is stored in {-y, -x}
+
+.program ccount
+cnt:
+    jmp x-- cnt
+epoch:
+    jmp y-- cnt
+
+% c-sdk {
+static inline void ccount_program_init(PIO pio, uint sm, uint offset) {
+    pio_sm_config c = ccount_program_get_default_config(offset);
+    pio_sm_init(pio, sm, offset, &c);
+    pio_sm_exec(pio, sm, pio_encode_set(pio_x, 0));
+    pio_sm_exec(pio, sm, pio_encode_set(pio_y, 0));
+}
+
+static inline uint64_t ccount_read(PIO pio, uint sm) {
+    static uint64_t extra = 0;
+    // Guard against having the epoch rollover while we're reading the time.
+    // If epoch2 != epoch1, we looped in middle and get new LSW
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_y));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_x));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_y));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_x));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    extra += 8;
+    uint32_t y1 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t x1 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t y2 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t x2 = -((int)pio_sm_get_blocking(pio, sm));
+    uint64_t val;
+    if (y2 != y1) {
+        val = ((((uint64_t)y2) << 32LL) | x2) + y2 /* adjust for missed cycle every epoch increment */;
+    } else {
+        val = ((((uint64_t)y1) << 32LL) | x1) + y1 /* adjust for missed cycle every epoch increment */;
+    }
+    return val + extra;
+}
+
+%}
+