MP Timer interrupt hanging

[cve2022]

A while ago I posted a question on getting the address of a function (#10780) to implement an ISR in MP. I huge thank you to @rkompass for the inspect() function.

Below is my attempt of doing it. Unfortunately, it does not work as intended.

The interrupt is generated but, once it occurrs, MP just hangs. In the test code, I programmed the alarm to occur after 3 seconds. Once I run the tst_irq() function, the REPL is active for the three seconds programmed and then, nothing. My first attempt was with the timer_isr() function calling an MP callback function, but I figured the MP VM was interrupted in the middle of a bytecode processing so I just tried the version below that is just supposed to rearm the alarm, but the same happenend. Then I tried an empty viper function and an empty arm_thumb function to no avail. The latter two should just return and, as the alarm is not rearmed, no interrupt would happen again.

Any idea of what I could be missing?

Below is the class that installs the ISR. The init() and, especially, the set_exclusive_handler() methods are based on this code.
EDIT: line 81 changed. More correct but still not working

from micropython import const
from machine import mem32, disable_irq, enable_irq

PPB_BASE = const(0xE0000000)
ICSR = const (PPB_BASE + 0xED04)
VTOR = const (PPB_BASE + 0xED08)
NVIC_ISER = const (PPB_BASE + 0xE100)
NVIC_ICER = const (PPB_BASE + 0xE180)
NVIC_ISPR = const (PPB_BASE + 0xE200)
NVIC_ICPR = const (PPB_BASE + 0xE280)
NVIC_IPR0 = const (PPB_BASE + 0xE400)
NVIC_IPR1 = const (PPB_BASE + 0xE404)
NVIC_IPR2 = const (PPB_BASE + 0xE408)
NVIC_IPR3 = const (PPB_BASE + 0xE40C)
NVIC_IPR4 = const (PPB_BASE + 0xE410)
NVIC_IPR5 = const (PPB_BASE + 0xE414)
NVIC_IPR6 = const (PPB_BASE + 0xE418)
NVIC_IPR7 = const (PPB_BASE + 0xE41C)

VTABLE_FIRST_IRQ = const (16)
NUM_IRQS = const (26)
LAST_IRQ = const (NUM_IRQS - 1)

def check_irq_param(num):
    if not (type(num) is int and (0 <= num <= LAST_IRQ)):
        raise ValueError('Invalid num argument {} {}'.format(type(num), num))

def get_irq_hdlr_address(irq_hdlr):
    @micropython.asm_thumb
    def dummy_asm():
        pass
    @micropython.viper
    def dummy_vip():
        pass
    if type(irq_hdlr) == type(dummy_asm):
    #    print('type is asm')
        offs = 0
    elif type(irq_hdlr) == type(dummy_vip):
    #    print('type is viper')
        offs = 4
    else:
        raise ValueError('expecting an asm_thumb or viper function')

    addr = id(irq_hdlr)
    return mem32[addr + offs + 8]

def check_irq_free (num):
    irqs = mem32[NVIC_ISER]
    if irqs & (1<<num):
        raise ValueError('IRQ already in use: {}'.format(num))

@micropython.asm_thumb
def dmb():
    data(2, 0xF3BF, 0x8F5F) # dmb sy

class Irq:
    def __init__(self):
        self.hdlr_addr = 0
        self.old_hdlr_addr = 0
        self.num = 0
        self.mask = 0

    def init(self, num, hdlr):
        if not self.hdlr_addr:
            check_irq_param(num)
            check_irq_free(num)
            self.hdlr_addr = get_irq_hdlr_address(hdlr)
            self.num = num
            self.set_exclusive_handler(self.num, self.hdlr_addr, True)

    def deinit(self):
        if self.hdlr_addr:
            self.set_exclusive_handler(self.num, self.old_hdlr_addr, False)
            self.hdlr_addr = 0

    def set_exclusive_handler(self, num, hdlr, en):
        self.mask = 1<<(num)
        vector_addr = mem32[VTOR] + (VTABLE_FIRST_IRQ + num)*4
        state = disable_irq()
        self.old_hdlr_addr = mem32[vector_addr]
        mem32[vector_addr] = hdlr+1 # ls bit of arm thumb is always 1
        dmb() # TODO: check if there is an inline asm way to do it
        if en:
            mem32[NVIC_ICPR] = self.mask # clear pending
            mem32[NVIC_ISER] = self.mask # enable
        else:
            mem32[NVIC_ICER] = self.mask # disable
        enable_irq(state)

The test is based on this example:

from rp2_irq import Irq
import micropython
from machine import mem32, Pin
from micropython import const
micropython.alloc_emergency_exception_buf(100)

irq = Irq()
alarm_interval = 3_000_000 # 100000
next_alarm = 0
led = Pin(25, Pin.OUT)

TIMER_BASE = const(0x40054000)
TIMER_TIMEHW = const(TIMER_BASE + 0x00)
TIMER_TIMELW = const(TIMER_BASE + 0x04)
TIMER_TIMEHR = const(TIMER_BASE + 0x08)
TIMER_TIMELR = const(TIMER_BASE + 0x0C)
TIMER_ALARM0 = const(TIMER_BASE + 0x10)
TIMER_ALARM1 = const(TIMER_BASE + 0x14)
TIMER_ALARM2 = const(TIMER_BASE + 0x18)
TIMER_ALARM3 = const(TIMER_BASE + 0x1C)
TIMER_ARMED  = const(TIMER_BASE + 0x20)
TIMER_TIMERAWH  = const(TIMER_BASE + 0x24)
TIMER_TIMERAWL  = const(TIMER_BASE + 0x28)
TIMER_DBGPAUSE  = const(TIMER_BASE + 0x2C)
TIMER_PAUSE  = const(TIMER_BASE + 0x30)
TIMER_INTR  = const(TIMER_BASE + 0x34)
TIMER_INTE  = const(TIMER_BASE + 0x38)
TIMER_INTF  = const(TIMER_BASE + 0x3C)
TIMER_INTS  = const(TIMER_BASE + 0x40)


@micropython.asm_thumb
def fn_asm():
    nop()

@micropython.viper # EDIT: was asm_thumb
def fn_vip():
    pass

@micropython.viper
def timer_isr():
    global alarm_interval, next_alarm
    next_alarm = (next_alarm + alarm_interval) & 0xFFFFFFFF
    #mem32[TIMER_ALARM0] = next_alarm
    ptr32(TIMER_ALARM0)[0] = uint(next_alarm)
    #led.toggle()

def tst_irq():
    #irq.init(0, timer_isr)
    #irq.init(0, fn_asm)
    irq.init(0, fn_vip)
    next_alarm = (mem32[TIMER_TIMERAWL] + alarm_interval) & 0xFFFFFFFF
    mem32[TIMER_ALARM0] = next_alarm
    mem32[TIMER_INTE] = 1

if __name__ == '__main__':
    tst_irq()

[cve2022]

I am closing this thread.

After several trial and error tests, I am throwing the towel, so to speak.

I could not find the cause of the hang. One possibility that occurred to me was the hang has to do with an exception beeing thrown by the memory protection of the Cortex-M0+ core. I suppose interrupts run in privileged mode whereas the regular code, Micropython included run in user mode. I am not sure about it though.

Another possibility (more probable) is the ISR coded with Viper is lacking something that the C version has that is essential for it to work correctly. It is not clear to me, though, looking at the source codes of the SDK and timer.c of the examples what exactly it could be. I tried just lighting the onboard LED to see if at least the Viper function was called and nothing.

I decided to pursue a different approach. I will try to extend the Pico's/RP2's Timer class to support hard-interrupts.