Merge pull request #11434 from mikeysklar/rp2350-alarm

Add sleep and alarms for RP2350 boards

Author: tannewt

ports/raspberrypi/Makefile

@@ -482,12 +482,17 @@ UF2_ID = 0xe48bff59
 # Double coprocessor is only available on the ARM core.
 DOUBLE_EABI = dcp
 INC += \
-	-isystem sdk/src/rp2_common/hardware_dcp/include/
+	-isystem sdk/src/rp2_common/hardware_dcp/include/ \
+	-isystem sdk/src/rp2_common/hardware_rosc/include/ \
+	-isystem sdk/src/rp2_common/pico_low_power/include/
 
 CFLAGS += -DPICO_RP2040=0 -DPICO_RP2350=1
 
 SRC_SDK_CHIP_VARIANT := \
+	src/common/pico_util/fixed_bitset.c \
 	src/rp2_common/hardware_powman/powman.c \
+	src/rp2_common/hardware_rosc/rosc.c \
+	src/rp2_common/pico_low_power/low_power.c \
 
 SRC_S_UPPER_CHIP_VARIANT := \
 	sdk/src/rp2_common/pico_double/double_conv_m33.S \

ports/raspberrypi/common-hal/alarm/__init__.c

@@ -34,16 +34,21 @@
 #include "hardware/structs/watchdog.h"
 
 // XOSC shutdown
-#include "hardware/rtc.h"
 #include "hardware/pll.h"
 #include "hardware/regs/io_bank0.h"
 
+#if PICO_RP2350
+#include "hardware/powman.h"
+#include "pico/low_power.h"
+#endif
+
 // Watchdog scratch register
 // Not used elsewhere in the SDK for now, keep an eye on it
 #define RP_WKUP_SCRATCH_REG 0
 
 // Light sleep turns off nonvolatile Busio and other wake-only peripherals
 // TODO: this only saves about 2mA right now, expand with other non-essentials
+#if PICO_RP2040
 const uint32_t RP_LIGHTSLEEP_EN0_MASK = ~(
     CLOCKS_SLEEP_EN0_CLK_SYS_SPI1_BITS |
     CLOCKS_SLEEP_EN0_CLK_PERI_SPI1_BITS |
@@ -59,7 +64,28 @@ const uint32_t RP_LIGHTSLEEP_EN0_MASK = ~(
     );
 // This bank has the USB clocks in it, leave it for now
 const uint32_t RP_LIGHTSLEEP_EN1_MASK = CLOCKS_SLEEP_EN1_RESET;
+#else
+// Same peripherals as RP2040. RP2350 adds PIO2 and moves SPI to the second bank.
+const uint32_t RP_LIGHTSLEEP_EN0_MASK = ~(
+    CLOCKS_SLEEP_EN0_CLK_SYS_PWM_BITS |
+    CLOCKS_SLEEP_EN0_CLK_SYS_PIO2_BITS |
+    CLOCKS_SLEEP_EN0_CLK_SYS_PIO1_BITS |
+    CLOCKS_SLEEP_EN0_CLK_SYS_PIO0_BITS |
+    CLOCKS_SLEEP_EN0_CLK_SYS_I2C1_BITS |
+    CLOCKS_SLEEP_EN0_CLK_SYS_I2C0_BITS |
+    CLOCKS_SLEEP_EN0_CLK_SYS_ADC_BITS |
+    CLOCKS_SLEEP_EN0_CLK_ADC_BITS
+    );
+// This bank has the USB clocks in it, only turn off SPI
+const uint32_t RP_LIGHTSLEEP_EN1_MASK = CLOCKS_SLEEP_EN1_RESET & ~(
+    CLOCKS_SLEEP_EN1_CLK_SYS_SPI1_BITS |
+    CLOCKS_SLEEP_EN1_CLK_PERI_SPI1_BITS |
+    CLOCKS_SLEEP_EN1_CLK_SYS_SPI0_BITS |
+    CLOCKS_SLEEP_EN1_CLK_PERI_SPI0_BITS
+    );
+#endif
 
+#if PICO_RP2040
 // Light sleeps used for TimeAlarm deep sleep turn off almost everything
 const uint32_t RP_LIGHTSLEEP_EN0_MASK_HARSH = (
     CLOCKS_SLEEP_EN0_CLK_RTC_RTC_BITS |
@@ -68,6 +94,7 @@ const uint32_t RP_LIGHTSLEEP_EN0_MASK_HARSH = (
 const uint32_t RP_LIGHTSLEEP_EN1_MASK_HARSH = 0x0;
 
 static void prepare_for_dormant_xosc(void);
+#endif
 
 // Singleton instance of SleepMemory.
 const alarm_sleep_memory_obj_t alarm_sleep_memory_obj = {
@@ -80,13 +107,29 @@ const alarm_sleep_memory_obj_t alarm_sleep_memory_obj = {
 // This object lives across VM instantiations, so none of these objects can contain references to the heap.
 alarm_wake_alarm_union_t alarm_wake_alarm;
 
+#if PICO_RP2350
+// powman remembers what caused the last power up until the next one. Only report
+// it until the first alarm_reset() after boot.
+static bool powman_wakeup_reported;
+
+bool alarm_woke_from_powman(void) {
+    // powman is not reset by a watchdog reboot, so its registers would be stale.
+    return (powman_hw->chip_reset & POWMAN_CHIP_RESET_HAD_SWCORE_PD_BITS) &&
+           !watchdog_caused_reboot() &&
+           (powman_hw->last_swcore_pwrup & (RP_POWMAN_PWRUP_GPIO_BITS | RP_POWMAN_PWRUP_ALARM_BITS));
+}
+#endif
+
 void alarm_reset(void) {
     alarm_sleep_memory_reset();
     alarm_pin_pinalarm_reset();
     alarm_time_timealarm_reset();
 
     // Reset the scratch source
     watchdog_hw->scratch[RP_WKUP_SCRATCH_REG] = RP_SLEEP_WAKEUP_UNDEF;
+    #if PICO_RP2350
+    powman_wakeup_reported = true;
+    #endif
 }
 
 static uint8_t _get_wakeup_cause(void) {
@@ -102,6 +145,14 @@ static uint8_t _get_wakeup_cause(void) {
     if (watchdog_hw->scratch[RP_WKUP_SCRATCH_REG] != RP_SLEEP_WAKEUP_UNDEF) {
         return watchdog_hw->scratch[RP_WKUP_SCRATCH_REG];
     }
+    #if PICO_RP2350
+    if (!powman_wakeup_reported && alarm_woke_from_powman()) {
+        if (powman_hw->last_swcore_pwrup & RP_POWMAN_PWRUP_ALARM_BITS) {
+            return RP_SLEEP_WAKEUP_RTC;
+        }
+        return RP_SLEEP_WAKEUP_GPIO;
+    }
+    #endif
     return RP_SLEEP_WAKEUP_UNDEF;
 }
 
@@ -172,7 +223,7 @@ mp_obj_t common_hal_alarm_light_sleep_until_alarms(size_t n_alarms, const mp_obj
         clocks_hw->sleep_en1 = RP_LIGHTSLEEP_EN1_MASK;
 
         // Enable System Control Block (SCB) deep sleep
-        scb_hw->scr |= M0PLUS_SCR_SLEEPDEEP_BITS;
+        scb_hw->scr |= ARM_CPU_PREFIXED(SCR_SLEEPDEEP_BITS);
 
         __wfi();
     }
@@ -194,7 +245,41 @@ void common_hal_alarm_set_deep_sleep_alarms(size_t n_alarms, const mp_obj_t *ala
     _setup_sleep_alarms(true, n_alarms, alarms);
 }
 
+#if PICO_RP2350
+// Power down with powman. Waking up reboots into main(), so this does not return.
+static void MP_NORETURN rp2350_enter_deep_sleep(void) {
+    #if CIRCUITPY_CYW43
+    cyw43_enter_deep_sleep();
+    #endif
+
+    // pico_low_power arms one wakeup per call and leaves the others alone, so
+    // arm every pin alarm first.
+    alarm_pin_pinalarm_enable_powman_wakeups();
+
+    // A NULL power state keeps only the SRAM that holds .persistent_data powered.
+    // That is where alarm.sleep_memory lives.
+    uint pin_number;
+    bool edge;
+    bool value;
+    if (!alarm_time_timealarm_is_set() &&
+        alarm_pin_pinalarm_first_powman_wakeup(&pin_number, &edge, &value)) {
+        low_power_pstate_until_gpio_pin_state(pin_number, edge, value, NULL, NULL);
+    } else {
+        // With no alarm at all, sleep until a time that never comes.
+        uint64_t wakeup_ms = alarm_time_timealarm_is_set() ? alarm_time_timealarm_get_wakeup_ms() : INT64_MAX / 1000;
+        low_power_pstate_until_aon_timer(from_us_since_boot(wakeup_ms * 1000), NULL, NULL);
+    }
+
+    // Could not power down, most likely because an alarm already fired.
+    watchdog_hw->scratch[RP_WKUP_SCRATCH_REG] = _get_wakeup_cause();
+    reset_cpu();
+}
+#endif
+
 void MP_NORETURN common_hal_alarm_enter_deep_sleep(void) {
+    #if PICO_RP2350
+    rp2350_enter_deep_sleep();
+    #else
     bool timealarm_set = alarm_time_timealarm_is_set();
 
     #if CIRCUITPY_CYW43
@@ -223,12 +308,14 @@ void MP_NORETURN common_hal_alarm_enter_deep_sleep(void) {
     // Just before reset, enable the pinalarm interrupt.
     alarm_pin_pinalarm_entering_deep_sleep();
     reset_cpu();
+    #endif
 }
 
 void common_hal_alarm_gc_collect(void) {
     gc_collect_ptr(shared_alarm_get_wake_alarm());
 }
 
+#if PICO_RP2040
 static void prepare_for_dormant_xosc(void) {
     // TODO: add ROSC support with sleep_run_from_dormant_source when it's added to SDK
     uint src_hz = XOSC_MHZ * MHZ;
@@ -259,3 +346,4 @@ static void prepare_for_dormant_xosc(void) {
     pll_deinit(pll_sys);
     pll_deinit(pll_usb);
 }
+#endif

ports/raspberrypi/common-hal/alarm/__init__.h

@@ -16,6 +16,18 @@
 #define RP_SLEEP_WAKEUP_GPIO    1
 #define RP_SLEEP_WAKEUP_RTC     2
 
+// Bits in powman_hw->last_swcore_pwrup. Bit 0 is a chip reset, bits 1 to 4 are
+// the four GPIO wakeups and bit 6 is the timer alarm.
+#define RP_POWMAN_PWRUP_GPIO_LSB  1
+#define RP_POWMAN_PWRUP_GPIO_BITS 0x1e
+#define RP_POWMAN_PWRUP_ALARM_BITS 0x40
+
+#if PICO_RP2350
+// Returns true when this boot is powman powering the core back up for a deep
+// sleep alarm. Returns false after any other kind of reset.
+bool alarm_woke_from_powman(void);
+#endif
+
 typedef union {
     alarm_pin_pinalarm_obj_t pin_alarm;
     alarm_time_timealarm_obj_t time_alarm;

ports/raspberrypi/common-hal/alarm/pin/PinAlarm.c

@@ -15,6 +15,21 @@
 #include "hardware/gpio.h"
 #include "hardware/structs/iobank0.h"
 
+#if PICO_RP2350
+#include "hardware/powman.h"
+
+// Deep sleep on RP2350 wakes through powman, which has four GPIO wakeup slots.
+// The alarm objects are gone by the time we enter deep sleep, so copy what we need.
+#define POWMAN_WAKEUP_SLOTS (count_of(powman_hw->pwrup))
+typedef struct {
+    uint8_t pin_number;
+    bool edge;
+    bool value;
+} powman_wakeup_t;
+static powman_wakeup_t powman_wakeups[POWMAN_WAKEUP_SLOTS];
+static size_t powman_wakeup_count;
+#endif
+
 static bool woke_up;
 static uint64_t alarm_triggered_pins; // 36 actual pins
 static uint64_t alarm_reserved_pins; // 36 actual pins
@@ -89,6 +104,18 @@ mp_obj_t alarm_pin_pinalarm_record_wake_alarm(void) {
     alarm->base.type = &alarm_pin_pinalarm_type;
     // TODO: how to obtain the correct pin from memory?
     alarm->pin = NULL;
+    #if PICO_RP2350
+    // After a powman wake, the wakeup slot that fired still holds its pin number.
+    if (!woke_up && alarm_woke_from_powman()) {
+        uint32_t pwrup = powman_hw->last_swcore_pwrup & RP_POWMAN_PWRUP_GPIO_BITS;
+        for (size_t i = 0; i < POWMAN_WAKEUP_SLOTS; i++) {
+            if (pwrup & (1u << (i + RP_POWMAN_PWRUP_GPIO_LSB))) {
+                alarm->pin = mcu_get_pin_by_number(powman_hw->pwrup[i] & POWMAN_PWRUP0_SOURCE_BITS);
+                break;
+            }
+        }
+    }
+    #endif
     return alarm;
 }
 
@@ -109,13 +136,35 @@ void alarm_pin_pinalarm_reset(void) {
         }
     }
     alarm_reserved_pins = 0;
+
+    #if PICO_RP2350
+    for (size_t i = 0; i < POWMAN_WAKEUP_SLOTS; i++) {
+        powman_disable_gpio_wakeup(i);
+    }
+    powman_wakeup_count = 0;
+    #endif
 }
 
 void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
+    #if PICO_RP2350
+    powman_wakeup_count = 0;
+    #endif
     for (size_t i = 0; i < n_alarms; i++) {
         if (mp_obj_is_type(alarms[i], &alarm_pin_pinalarm_type)) {
             alarm_pin_pinalarm_obj_t *alarm = MP_OBJ_TO_PTR(alarms[i]);
 
+            #if PICO_RP2350
+            if (deep_sleep) {
+                if (powman_wakeup_count >= POWMAN_WAKEUP_SLOTS) {
+                    mp_raise_ValueError_varg(MP_ERROR_TEXT("Too many %q"), MP_QSTR_PinAlarm);
+                }
+                powman_wakeups[powman_wakeup_count].pin_number = alarm->pin->number;
+                powman_wakeups[powman_wakeup_count].edge = alarm->edge;
+                powman_wakeups[powman_wakeup_count].value = alarm->value;
+                powman_wakeup_count++;
+            }
+            #endif
+
             gpio_init(alarm->pin->number);
             if (alarm->pull) {
                 // If value is high, the pullup should be off, and vice versa
@@ -149,3 +198,24 @@ void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_ob
         }
     }
 }
+
+#if PICO_RP2350
+// Arm the powman GPIO wakeups recorded by alarm_pin_pinalarm_set_alarms().
+// Call this just before powering down for deep sleep.
+void alarm_pin_pinalarm_enable_powman_wakeups(void) {
+    for (size_t i = 0; i < powman_wakeup_count; i++) {
+        powman_enable_gpio_wakeup(i, powman_wakeups[i].pin_number,
+            powman_wakeups[i].edge, powman_wakeups[i].value);
+    }
+}
+
+bool alarm_pin_pinalarm_first_powman_wakeup(uint *pin_number, bool *edge, bool *value) {
+    if (powman_wakeup_count == 0) {
+        return false;
+    }
+    *pin_number = powman_wakeups[0].pin_number;
+    *edge = powman_wakeups[0].edge;
+    *value = powman_wakeups[0].value;
+    return true;
+}
+#endif

ports/raspberrypi/common-hal/alarm/pin/PinAlarm.h

@@ -27,3 +27,11 @@ void alarm_pin_pinalarm_light_reset(void);
 void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms);
 bool alarm_pin_pinalarm_woke_this_cycle(void);
 void alarm_pin_pinalarm_entering_deep_sleep(void);
+#if PICO_RP2350
+// Arms the powman GPIO wakeups for the pin alarms given to
+// alarm_pin_pinalarm_set_alarms() with deep_sleep true.
+void alarm_pin_pinalarm_enable_powman_wakeups(void);
+// Returns false and leaves the outputs alone when no pin alarm was set for deep sleep.
+// Otherwise fills in the pin alarm that uses powman wakeup slot 0 and returns true.
+bool alarm_pin_pinalarm_first_powman_wakeup(uint *pin_number, bool *edge, bool *value);
+#endif