Merge pull request #6 from maholli/samd-sleep-v1

cherry-picked original hierophect commit and merged with my samd `alarm` (deep sleep) work

ports/atmel-samd/boards/pycubed/mpconfigboard.mk

@@ -12,15 +12,25 @@ LONGINT_IMPL = MPZ
 
 CIRCUITPY_DRIVE_LABEL = "PYCUBED"
 
-# Not needed.
+CIRCUITPY_ULAB = 1
+CIRCUITPY_BINASCII = 1
+CIRCUITPY_SDCARDIO = 1
+CIRCUITPY_JSON = 1
+CIRCUITPY_MSGPACK = 1
+CIRCUITPY_ALARM = 1
+
+# no SAMD51 support... yet ;)
+# CIRCUITPY_DUALBANK=1
+
+# Not needed
 CIRCUITPY_AUDIOBUSIO = 0
-CIRCUITPY_BITMAPTOOLS = 0
 CIRCUITPY_DISPLAYIO = 0
 CIRCUITPY_FRAMEBUFFERIO = 0
 CIRCUITPY_KEYPAD = 0
 CIRCUITPY_RGBMATRIX = 0
 CIRCUITPY_PS2IO = 0
+CIRCUITPY_BLEIO_HCI=0
+CIRCUITPY_BLEIO=0
 
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_NeoPixel
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_Register
-FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_SD

ports/atmel-samd/boards/pycubed_v05/mpconfigboard.mk

@@ -11,14 +11,16 @@ EXTERNAL_FLASH_DEVICE_COUNT = 1
 EXTERNAL_FLASH_DEVICES = W25Q80DV
 LONGINT_IMPL = MPZ
 
+CIRCUITPY_DRIVE_LABEL = "PYCUBED"
+
 CIRCUITPY_ULAB = 1
 CIRCUITPY_BINASCII = 1
 CIRCUITPY_SDCARDIO = 1
 CIRCUITPY_JSON = 1
 CIRCUITPY_MSGPACK = 1
+CIRCUITPY_ALARM = 1
 
 # no SAMD51 support... yet ;)
-# CIRCUITPY_ALARM = 1
 # CIRCUITPY_DUALBANK=1
 
 # Not needed

ports/atmel-samd/common-hal/alarm/SleepMemory.c

@@ -28,6 +28,7 @@
 
 #include "py/runtime.h"
 #include "common-hal/alarm/SleepMemory.h"
+#include "shared-bindings/nvm/ByteArray.h"
 
 void alarm_sleep_memory_reset(void) {
 

ports/atmel-samd/common-hal/alarm/SleepMemory.h

@@ -31,6 +31,8 @@
 
 typedef struct {
     mp_obj_base_t base;
+    uint8_t *start_address;
+    uint8_t len;
 } alarm_sleep_memory_obj_t;
 
 extern void alarm_sleep_memory_reset(void);

ports/atmel-samd/common-hal/alarm/__init__.c

@@ -29,6 +29,7 @@
 #include "py/objtuple.h"
 #include "py/runtime.h"
 #include "lib/utils/interrupt_char.h"
+// #include <stdio.h>
 
 #include "shared-bindings/alarm/__init__.h"
 #include "shared-bindings/alarm/SleepMemory.h"
@@ -36,7 +37,7 @@
 #include "shared-bindings/alarm/time/TimeAlarm.h"
 
 #include "shared-bindings/microcontroller/__init__.h"
-
+#include "samd/external_interrupts.h"
 #include "supervisor/port.h"
 #include "supervisor/workflow.h"
 
@@ -46,8 +47,9 @@ const alarm_sleep_memory_obj_t alarm_sleep_memory_obj = {
         .type = &alarm_sleep_memory_type,
     },
 };
-
 // TODO: make a custom enum to avoid weird values like PM_SLEEPCFG_SLEEPMODE_BACKUP_Val?
+STATIC volatile uint32_t _target;
+STATIC bool fake_sleep;
 
 void alarm_reset(void) {
     // Reset the alarm flag
@@ -64,8 +66,14 @@ samd_sleep_source_t alarm_get_wakeup_cause(void) {
     if (alarm_time_timealarm_woke_this_cycle()) {
         return SAMD_WAKEUP_RTC;
     }
-    // TODO: for deep sleep, manually determine how the chip woke up
+    if (RSTC->RCAUSE.bit.BACKUP) {
-    // TODO: try checking the interrupt flag tables for RTC TAMPER vs COMPARE
+        // not able to detect PinAlarm wake since registers are getting reset
+        // TODO: come up with a way to detect a TAMPER
+        if (RTC->MODE0.TAMPID.reg || RTC->MODE0.INTFLAG.bit.TAMPER) {
+            return SAMD_WAKEUP_GPIO;
+        }
+        return SAMD_WAKEUP_RTC;
+    }
     return SAMD_WAKEUP_UNDEF;
 }
 
@@ -96,6 +104,7 @@ mp_obj_t common_hal_alarm_create_wake_alarm(void) {
 STATIC void _setup_sleep_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
     alarm_pin_pinalarm_set_alarms(deep_sleep, n_alarms, alarms);
     alarm_time_timealarm_set_alarms(deep_sleep, n_alarms, alarms);
+    fake_sleep = false;
 }
 
 mp_obj_t common_hal_alarm_light_sleep_until_alarms(size_t n_alarms, const mp_obj_t *alarms) {
@@ -126,10 +135,34 @@ mp_obj_t common_hal_alarm_light_sleep_until_alarms(size_t n_alarms, const mp_obj
         // TODO: the SAMD implementation of this (purportedly) disables interrupts
         //       Presumably this doesn't impact the RTC interrupts, somehow, or it would never wake up?
         //       Will it prevent an external interrupt from waking?
-        port_idle_until_interrupt();
+        // port_idle_until_interrupt();
         //       Alternative would be `sleep(PM_SLEEPCFG_SLEEPMODE_IDLE2_Val)`, I think?
-    }
 
+        // ATTEMPT ------------------------------
+        // This works but achieves same power consumption as time.sleep()
+
+        // Clear the FPU interrupt because it can prevent us from sleeping.
+        if (__get_FPSCR() & ~(0x9f)) {
+        __set_FPSCR(__get_FPSCR() & ~(0x9f));
+        (void)__get_FPSCR();
+        }
+
+        // Disable RTC interrupts
+        NVIC_DisableIRQ(RTC_IRQn);
+        // Set standby power domain stuff
+        PM->STDBYCFG.reg = PM_STDBYCFG_RAMCFG_OFF;
+        // Set-up Sleep Mode
+        PM->SLEEPCFG.reg = PM_SLEEPCFG_SLEEPMODE_STANDBY;
+        while(PM->SLEEPCFG.bit.SLEEPMODE != PM_SLEEPCFG_SLEEPMODE_STANDBY_Val);
+
+        __DSB(); // Data Synchronization Barrier
+        __WFI(); // Wait For Interrupt
+        // Enable RTC interrupts
+        NVIC_EnableIRQ(RTC_IRQn);
+
+
+    // END ATTEMPT ------------------------------
+        }
     if (mp_hal_is_interrupted()) {
         return mp_const_none; // Shouldn't be given to python code because exception handling should kick in.
     }
@@ -145,25 +178,98 @@ void common_hal_alarm_set_deep_sleep_alarms(size_t n_alarms, const mp_obj_t *ala
 void NORETURN common_hal_alarm_enter_deep_sleep(void) {
     alarm_pin_pinalarm_prepare_for_deep_sleep();
     alarm_time_timealarm_prepare_for_deep_sleep();
+    _target = RTC->MODE0.COMP[1].reg;
     port_disable_tick(); // TODO: Required for SAMD?
 
     // Set a flag in the backup registers to indicate sleep wakeup
     SAMD_ALARM_FLAG = 0x01;
 
-    // TODO: make sure this actually works, or replace with extracted register version
+    // Clear the FPU interrupt because it can prevent us from sleeping.
-    // sleep(PM_SLEEPCFG_SLEEPMODE_BACKUP_Val);
+    if (__get_FPSCR() & ~(0x9f)) {
+    __set_FPSCR(__get_FPSCR() & ~(0x9f));
+    (void)__get_FPSCR();
+    }
 
-    // The above shuts down RAM, so we should never hit this
+    // PinAlarm (hacky way of checking if time alarm or pin alarm)
+    if (RTC->MODE0.INTENSET.bit.TAMPER) {
+        // Disable interrupts
+        NVIC_DisableIRQ(RTC_IRQn);
+        // Must disable the RTC before writing to EVCTRL and TMPCTRL
+        RTC->MODE0.CTRLA.bit.ENABLE = 0;                     // Disable the RTC
+        while (RTC->MODE0.SYNCBUSY.bit.ENABLE);              // Wait for synchronization
+        RTC->MODE0.CTRLA.bit.SWRST = 1;                      // Software reset the RTC
+        while (RTC->MODE0.SYNCBUSY.bit.SWRST);               // Wait for synchronization
+        RTC->MODE0.CTRLA.reg = RTC_MODE0_CTRLA_PRESCALER_DIV1024 |   // Set prescaler to 1024
+                              RTC_MODE0_CTRLA_MODE_COUNT32;         // Set RTC to mode 0, 32-bit timer
+
+        // TODO: map requested pin to limited selection of TAMPER pins
+        RTC->MODE0.TAMPCTRL.bit.DEBNC2 = 1;  // Edge triggered when INn is stable for 4 CLK_RTC_DEB periods
+        RTC->MODE0.TAMPCTRL.bit.TAMLVL2 = 1; // rising edge
+        //PA02 = IN2
+        RTC->MODE0.TAMPCTRL.bit.IN2ACT = 1;  // WAKE on IN2 (doesn't save timestamp)
+
+        // Enable interrupts
+        NVIC_SetPriority(RTC_IRQn, 0);
+        NVIC_EnableIRQ(RTC_IRQn);
+        // Set interrupts for TAMPER or overflow
+        RTC->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_TAMPER;
+    // TimeAlarm
+    } else {
+        // Retrieve COMP1 value before resetting RTC
+        // Disable interrupts
+        NVIC_DisableIRQ(RTC_IRQn);
+
+        // Must disable the RTC before writing to EVCTRL and TMPCTRL
+        RTC->MODE0.CTRLA.bit.ENABLE = 0;                     // Disable the RTC
+        while (RTC->MODE0.SYNCBUSY.bit.ENABLE);              // Wait for synchronization
+
+        RTC->MODE0.CTRLA.bit.SWRST = 1;                      // Software reset the RTC
+        while (RTC->MODE0.SYNCBUSY.bit.SWRST);               // Wait for synchronization
+
+        RTC->MODE0.CTRLA.reg = RTC_MODE0_CTRLA_PRESCALER_DIV1024 |   // Set prescaler to 1024
+                              RTC_MODE0_CTRLA_MODE_COUNT32;         // Set RTC to mode 0, 32-bit timer
+
+        RTC->MODE0.COMP[1].reg = (_target/1024) * 32;
+        while(RTC->MODE0.SYNCBUSY.reg);
+
+        // Enable interrupts
+        NVIC_SetPriority(RTC_IRQn, 0);
+        NVIC_EnableIRQ(RTC_IRQn);
+        // Set interrupts for COMPARE1 or overflow
+        RTC->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_CMP1 | RTC_MODE1_INTENSET_OVF;
+        }
+    // Set-up Deep Sleep Mode
+    // RAM retention
+    PM->BKUPCFG.reg = PM_BKUPCFG_BRAMCFG(0x2);       // No RAM retention 0x2 partial:0x1
+    while (PM->BKUPCFG.bit.BRAMCFG != 0x2);          // Wait for synchronization
+    PM->SLEEPCFG.reg = PM_SLEEPCFG_SLEEPMODE_BACKUP;
+    while(PM->SLEEPCFG.bit.SLEEPMODE != PM_SLEEPCFG_SLEEPMODE_BACKUP_Val);
+
+    RTC->MODE0.CTRLA.bit.ENABLE = 1;                      // Enable the RTC
+    while (RTC->MODE0.SYNCBUSY.bit.ENABLE);               // Wait for synchronization
+
+    __DSB(); // Data Synchronization Barrier
+    __WFI(); // Wait For Interrupt
+
+    // The above shuts down RAM and triggers a reset, so we should never hit this
     while (1) {
         ;
     }
 }
 
-void common_hal_alarm_pretending_deep_sleep(void) {
+MP_NOINLINE void common_hal_alarm_pretending_deep_sleep(void) {
     // TODO:
     //      If tamper detect interrupts cannot be used to wake from the Idle tier of sleep,
     //      This section will need to re-initialize the pins to allow the PORT peripheral
     //      to generate external interrupts again. See STM32 for reference.
+
+    if (!fake_sleep) {
+        SAMD_ALARM_FLAG = 1;
+        while(RTC->MODE0.SYNCBUSY.reg);
+        fake_sleep = true;
+    } else {
+        port_idle_until_interrupt();
+    }
 }
 
 void common_hal_alarm_gc_collect(void) {

ports/atmel-samd/common-hal/alarm/pin/PinAlarm.c

@@ -25,6 +25,12 @@
  */
 
 #include "py/runtime.h"
+#include "samd/external_interrupts.h"
+#include "eic_handler.h"
+#include "atmel_start_pins.h"
+#include "hal/include/hal_gpio.h"
+#include <stdio.h>
+
 
 #include "shared-bindings/alarm/pin/PinAlarm.h"
 #include "shared-bindings/microcontroller/__init__.h"
@@ -33,34 +39,63 @@
 // This variable stores whether a PinAlarm woke in light sleep or fake deep sleep
 // It CANNOT detect if the program woke from deep sleep.
 STATIC bool woke_up;
+STATIC bool deep_wkup_enabled;
 
 // TODO: Create tables here reserving IRQ instances, and for the IRQ
 //       callback to store what pin triggered the interrupt
 // STATIC bool reserved_alarms[SOME_VAL];
 // STATIC uint16_t triggered_pins[SOME_VAL];
 
-STATIC void pin_alarm_callback(uint8_t num) { // parameters can be changed
+void pin_alarm_callback(uint8_t num) { // parameters can be changed
     // TODO: This is responsible for resetting the IRQ (so it doesn't
     //       go off constantly, and recording what pin was responsible for
     //       the trigger. This will only work for light sleep/fake deep
     //       sleep, in conjunction with the find_triggered_alarm function
+
+    // Turn off interrupts while in handler
+    // printf("Woke up from pin!!\n");
+    // printf("EIC Flags: %lu\n",EIC->INTFLAG.reg);
+
+    // QUESTION: How to reference the correct EIC?
+    // set_eic_handler(self->channel, EIC_HANDLER_NO_INTERRUPT);
+    // turn_off_eic_channel(self->channel);
+    // reset_pin_number(self->pin);
+    woke_up = true;
 }
 
 void common_hal_alarm_pin_pinalarm_construct(alarm_pin_pinalarm_obj_t *self, const mcu_pin_obj_t *pin, bool value, bool edge, bool pull) {
-    mp_raise_NotImplementedError(translate("PinAlarms not available"));
+    // Tamper Pins: IN0:PB00; IN1:PB02; IN2:PA02; IN3:PC00; IN4:PC01; OUT:PB01
     // TODO: Catch edge or level mode if not supported
-    // if (!edge) {
+    if (!pin->has_extint) {
-    //     mp_raise_NotImplementedError(translate("Only edge detection is available on this hardware"));
+        mp_raise_RuntimeError(translate("No hardware support on pin"));
-    // }
+    }
+    if (eic_get_enable()) {
+        if (!eic_channel_free(pin->extint_channel)) {
+            mp_raise_RuntimeError(translate("A hardware interrupt channel is already in use"));
+        }
+    } else {
+        turn_on_external_interrupt_controller();
+    }
 
     // TODO: determine if pin has an interrupt channel available
     // TODO: set pin pull settings, input/output, etc
     // QUESTION: can PORT/EVSYS interrupts (lightsleep) coexist with RTC->TAMPER (deepsleep) settings?
     // Actual initialization of the interrupt should be delayed until set_alarm
 
+    self->channel = pin->extint_channel;
     self->pin = pin;
     self->value = value;
     self->pull = pull;
+
+    gpio_set_pin_function(pin->number, GPIO_PIN_FUNCTION_A);
+    if (self->pull) {
+        gpio_set_pin_pull_mode(pin->number, GPIO_PULL_UP);
+    }  else {
+        gpio_set_pin_pull_mode(pin->number, GPIO_PULL_DOWN);
+    }
+    set_eic_channel_data(self->channel, (void *)self);
+
+    claim_pin(self->pin);
 }
 
 const mcu_pin_obj_t *common_hal_alarm_pin_pinalarm_get_pin(alarm_pin_pinalarm_obj_t *self) {
@@ -81,6 +116,10 @@ bool common_hal_alarm_pin_pinalarm_get_pull(alarm_pin_pinalarm_obj_t *self) {
 }
 
 bool alarm_pin_pinalarm_woke_this_cycle(void) {
+    if (RTC->MODE0.INTFLAG.bit.TAMPER){
+        woke_up = true;
+        RTC->MODE0.INTENCLR.bit.TAMPER = 1; // clear flag and interrupt setting
+    }
     return woke_up;
 }
 
@@ -90,10 +129,15 @@ mp_obj_t alarm_pin_pinalarm_find_triggered_alarm(size_t n_alarms, const mp_obj_t
             continue;
         }
         alarm_pin_pinalarm_obj_t *alarm = MP_OBJ_TO_PTR(alarms[i]);
+        (void)alarm;
+
 
         // TODO: Determine whether any pins have been marked as
         //       triggering the alarm (using the static vars at
         //       start of file) and if so return that alarm.
+
+
+
     }
     // Return nothing if no matching alarms are found.
     return mp_const_none;
@@ -115,6 +159,9 @@ void alarm_pin_pinalarm_reset(void) {
     //       sure to clear any reserved tables, deinit both PORT and TAMPER
     //       settings, etc. If flags are set to indicate this module is in
     //       use, reset them.
+
+    // Disable TAMPER interrupt
+    RTC->MODE0.INTENCLR.bit.TAMPER = 1;
 }
 
 void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
@@ -124,6 +171,15 @@ void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_ob
         if (mp_obj_is_type(alarms[i], &alarm_pin_pinalarm_type)) {
             alarm_pin_pinalarm_obj_t *alarm = MP_OBJ_TO_PTR(alarms[i]);
             if (deep_sleep) {
+                // Tamper Pins: IN0:PB00; IN1:PB02; IN2:PA02; IN3:PC00; IN4:PC01; OUT:PB01
+                // Only these pins can do TAMPER
+                if (alarm->pin != &pin_PB00 && alarm->pin != &pin_PB02 &&
+                    alarm->pin != &pin_PA02) {
+                    mp_raise_ValueError(translate("Pin cannot wake from Deep Sleep"));
+                }
+                deep_wkup_enabled = true;
+                // Set tamper interrupt so deep sleep knows that's the intent
+                RTC->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_TAMPER;
                 // TODO: Set up deep sleep alarms.
                 //       For deep sleep alarms, first check if the
                 //       alarm pin value is valid for RTC->TAMPER. Ensure
@@ -138,6 +194,11 @@ void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_ob
                 //       `alarm_pin_pinalarm_prepare_for_deep_sleep`
                 //       below.
             } // use else-if here if RTC-TAMPER can wake from IDLE
+            else {
+                // Light sleep so turn on EIC channel
+                set_eic_handler(alarm->channel, EIC_HANDLER_ALARM);
+                turn_on_eic_channel(alarm->channel, EIC_CONFIG_SENSE0_RISE_Val);
+            }
 
             // TODO: Set up light sleep / fake deep sleep alarms.
             //       PORT/EVSYS should have more valid pin combinations

ports/atmel-samd/common-hal/alarm/pin/PinAlarm.h

@@ -35,11 +35,13 @@ typedef struct {
     const mcu_pin_obj_t *pin;
     bool value;
     bool pull;
+    uint8_t channel;
 } alarm_pin_pinalarm_obj_t;
 
 mp_obj_t alarm_pin_pinalarm_find_triggered_alarm(size_t n_alarms, const mp_obj_t *alarms);
 mp_obj_t alarm_pin_pinalarm_create_wakeup_alarm(void);
 
+void pin_alarm_callback(uint8_t num);
 void alarm_pin_pinalarm_reset(void);
 void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms);
 void alarm_pin_pinalarm_prepare_for_deep_sleep(void);

ports/atmel-samd/common-hal/alarm/time/TimeAlarm.c

@@ -25,6 +25,9 @@
  */
 
 #include "py/runtime.h"
+#include "hpl/pm/hpl_pm_base.h"
+// #include <stdio.h>
+// #include "shared-bindings/microcontroller/__init__.h"
 
 #include "shared-bindings/alarm/time/TimeAlarm.h"
 #include "shared-bindings/time/__init__.h"
@@ -37,6 +40,10 @@ void common_hal_alarm_time_timealarm_construct(alarm_time_timealarm_obj_t *self,
     // TODO: throw a ValueError if the input time exceeds the maximum
     //       value of the Compare register. This must be calculated from the
     //       setup values in port.c. Should be ~3 days. Give it some margin.
+    //
+    //       UPDATE: for deep sleep at least, it's far more than 3 days since
+    //               prescalar is set to 1024. (2^32)/32 seconds so >1500 days?
+
     self->monotonic_time = monotonic_time;
 }
 
@@ -64,7 +71,8 @@ mp_obj_t alarm_time_timealarm_create_wakeup_alarm(void) {
     return timer;
 }
 
-STATIC void timer_callback(void) {
+void timer_callback(void) {
+    RTC->MODE0.INTENCLR.reg = RTC_MODE0_INTENCLR_CMP1 | RTC_MODE0_INTENCLR_CMP0 | RTC_MODE0_INTENCLR_OVF; // clear flags
     woke_up = true;
 }
 
@@ -77,6 +85,8 @@ void alarm_time_timealarm_reset(void) {
 }
 
 void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
+    // Turn on debug control
+    RTC->MODE0.DBGCTRL.bit.DBGRUN = 1;
     // Search through alarms for TimeAlarm instances, and check that there's only one
     bool timealarm_set = false;
     alarm_time_timealarm_obj_t *timealarm = MP_OBJ_NULL;
@@ -100,13 +110,20 @@ void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_
     uint32_t wakeup_in_ticks = wakeup_in_secs * 1024;
 
     // In the deep sleep case, we can't start the timer until the USB delay has finished
-    // (othersise it will go off while USB enumerates, and we'll risk entering deep sleep
+    // (otherwise it will go off while USB enumerates, and we'll risk entering deep sleep
     // without any way to wake up again)
     if (deep_sleep) {
         deep_sleep_ticks = wakeup_in_ticks;
     } else {
         deep_sleep_ticks = 0;
     }
+    // Set COMP1 for fake sleep. This will be reset for real deep sleep anyways.
+    RTC->MODE0.COMP[1].reg = wakeup_in_ticks;
+    while (RTC->MODE0.SYNCBUSY.reg);
+
+    // This is set for fake sleep. Max fake sleep time is ~72 hours
+    // True deep sleep isn't limited by this
+    port_interrupt_after_ticks(wakeup_in_ticks);
 
     // TODO: set up RTC->COMP[1] and create a callback pointing to
     //       timer_callback. See atmel-samd/supervisor/port.c -> _port_interrupt_after_ticks()
@@ -116,6 +133,8 @@ void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_
 
     // If true deep sleep is called, it will either ignore or overwrite the above setup depending on
     // whether it is shorter or longer than the USB delay
+    // printf("set deep alarm finished\n");
+
 }
 
 void alarm_time_timealarm_prepare_for_deep_sleep(void) {
@@ -124,6 +143,10 @@ void alarm_time_timealarm_prepare_for_deep_sleep(void) {
         //       Just do the exact same setup as alarm_time_timealarm_set_alarms(). Note, this
         //       is used for both fake and real deep sleep, so it still needs the callback.
         //       See STM32 for reference.
+
+        // RTC->MODE0.COMP[1].reg = deep_sleep_ticks;
+        // while ((RTC->MODE0.SYNCBUSY.reg & (RTC_MODE0_SYNCBUSY_COMP1)) != 0) {
+        // }
         deep_sleep_ticks = 0;
     }
 }

ports/atmel-samd/common-hal/alarm/time/TimeAlarm.h

@@ -36,11 +36,11 @@ typedef struct {
 
 mp_obj_t alarm_time_timealarm_find_triggered_alarm(size_t n_alarms, const mp_obj_t *alarms);
 mp_obj_t alarm_time_timealarm_create_wakeup_alarm(void);
-
+void timer_callback(void);
 bool alarm_time_timealarm_woke_this_cycle(void);
-void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms);
+uint32_t alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms);
 void alarm_time_timealarm_reset(void);
 
-void alarm_time_timealarm_prepare_for_deep_sleep(void);
+uint32_t alarm_time_timealarm_prepare_for_deep_sleep(void);
 
 #endif  // MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_ALARM_TIMEALARM_H

ports/atmel-samd/eic_handler.c

@@ -29,6 +29,7 @@
 #include "common-hal/rotaryio/IncrementalEncoder.h"
 #include "common-hal/countio/Counter.h"
 #include "shared-bindings/microcontroller/__init__.h"
+#include "common-hal/alarm/pin/PinAlarm.h"
 // #include "samd/external_interrupts.h"
 #include "eic_handler.h"
 
@@ -66,6 +67,12 @@ void shared_eic_handler(uint8_t channel) {
             break;
         #endif
 
+        #if CIRCUITPY_ALARM
+        case EIC_HANDLER_ALARM:
+            pin_alarm_callback(channel);
+            break;
+        #endif
+
         default:
             break;
     }

ports/atmel-samd/mpconfigport.mk

@@ -98,8 +98,9 @@ CIRCUITPY_TOUCHIO_USE_NATIVE = 0
 
 # The ?='s allow overriding in mpconfigboard.mk.
 
+
 CIRCUITPY_ALARM ?= 0
-CIRCUITPY_PS2IO ?= 1
+PY_PS2IO ?= 1
 CIRCUITPY_SAMD ?= 1
 CIRCUITPY_RGBMATRIX ?= $(CIRCUITPY_FULL_BUILD)
 CIRCUITPY_FRAMEBUFFERIO ?= $(CIRCUITPY_FULL_BUILD)

ports/atmel-samd/supervisor/port.c

@@ -53,6 +53,7 @@
 #error Unknown chip family
 #endif
 
+#include "common-hal/alarm/__init__.h"
 #include "common-hal/analogio/AnalogIn.h"
 #include "common-hal/analogio/AnalogOut.h"
 #include "common-hal/audiobusio/PDMIn.h"
@@ -77,6 +78,7 @@
 #include "samd/dma.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/rtc/__init__.h"
+#include "shared-bindings/alarm/time/TimeAlarm.h"
 #include "shared_timers.h"
 #include "reset.h"
 
@@ -496,6 +498,11 @@ void RTC_Handler(void) {
         // SAMD21 ticks are handled by EVSYS
         #ifdef SAM_D5X_E5X
         RTC->MODE0.INTENCLR.reg = RTC_MODE0_INTENCLR_CMP0;
+        // Check if we're sleeping
+        if (SAMD_ALARM_FLAG){
+            timer_callback();
+            SAMD_ALARM_FLAG = 0;
+        }
         #endif
     }
 }