cpu/irq.h

Go to the documentation of this file.

#ifndef CPU_IRQ_H
#define CPU_IRQ_H

#include "detect.h"
#include "types.h"

#include <cfg/compiler.h> /* for uintXX_t */

#if CPU_I196
    #define IRQ_DISABLE             disable_interrupt()
    #define IRQ_ENABLE              enable_interrupt()
#elif CPU_X86

    /* Get IRQ_* definitions from the hosting environment. */
    #include <cfg/os.h>
    #if OS_EMBEDDED
        #define IRQ_DISABLE             FIXME
        #define IRQ_ENABLE              FIXME
        #define IRQ_SAVE_DISABLE(x)     FIXME
        #define IRQ_RESTORE(x)          FIXME
    #endif /* OS_EMBEDDED */


#elif CPU_ARM

    #ifdef __IAR_SYSTEMS_ICC__

        #include <inarm.h>

        #if __CPU_MODE__ == 1 /* Thumb */
            /* Use stubs */
            extern cpu_flags_t get_CPSR(void);
            extern void set_CPSR(cpu_flags_t flags);
        #else
            #define get_CPSR __get_CPSR
            #define set_CPSR __set_CPSR
        #endif

        #define IRQ_DISABLE __disable_interrupt()
        #define IRQ_ENABLE  __enable_interrupt()

        #define IRQ_SAVE_DISABLE(x) \
        do { \
            (x) = get_CPSR(); \
            __disable_interrupt(); \
        } while (0)

        #define IRQ_RESTORE(x) \
        do { \
            set_CPSR(x); \
        } while (0)

        #define IRQ_ENABLED() \
            ((bool)(get_CPSR() & 0xb0))

    #else /* !__IAR_SYSTEMS_ICC__ */

        #define IRQ_DISABLE \
        do { \
            asm volatile ( \
                "mrs r0, cpsr\n\t" \
                "orr r0, r0, #0xc0\n\t" \
                "msr cpsr_c, r0" \
                ::: "r0" \
            ); \
        } while (0)

        #define IRQ_ENABLE \
        do { \
            asm volatile ( \
                "mrs r0, cpsr\n\t" \
                "bic r0, r0, #0xc0\n\t" \
                "msr cpsr_c, r0" \
                ::: "r0" \
            ); \
        } while (0)

        #define IRQ_SAVE_DISABLE(x) \
        do { \
            asm volatile ( \
                "mrs %0, cpsr\n\t" \
                "orr r0, %0, #0xc0\n\t" \
                "msr cpsr_c, r0" \
                : "=r" (x) \
                : /* no inputs */ \
                : "r0" \
            ); \
        } while (0)

        #define IRQ_RESTORE(x) \
        do { \
            asm volatile ( \
                "msr cpsr_c, %0" \
                : /* no outputs */ \
                : "r" (x) \
            ); \
        } while (0)

        #define CPU_READ_FLAGS() \
        ({ \
            cpu_flags_t sreg; \
            asm volatile ( \
                "mrs %0, cpsr\n\t" \
                : "=r" (sreg) \
                : /* no inputs */ \
            ); \
            sreg; \
        })

        #define IRQ_ENABLED() ((CPU_READ_FLAGS() & 0xc0) != 0xc0)

    #endif /* !__IAR_SYSTEMS_ICC_ */

#elif CPU_PPC

    /* Get IRQ_* definitions from the hosting environment. */
    #include <cfg/os.h>
    #if OS_EMBEDDED
        #define IRQ_DISABLE         FIXME
        #define IRQ_ENABLE          FIXME
        #define IRQ_SAVE_DISABLE(x) FIXME
        #define IRQ_RESTORE(x)      FIXME
        #define IRQ_ENABLED()       FIXME
    #endif /* OS_EMBEDDED */

#elif CPU_DSP56K

    #define IRQ_DISABLE             do { asm(bfset #0x0200,SR); asm(nop); } while (0)
    #define IRQ_ENABLE              do { asm(bfclr #0x0200,SR); asm(nop); } while (0)

    #define IRQ_SAVE_DISABLE(x)  \
        do { (void)x; asm(move SR,x); asm(bfset #0x0200,SR); } while (0)
    #define IRQ_RESTORE(x)  \
        do { (void)x; asm(move x,SR); } while (0)

    static inline bool irq_running(void)
    {
        extern void *user_sp;
        return !!user_sp;
    }
    #define IRQ_RUNNING() irq_running()

    static inline bool irq_enabled(void)
    {
        uint16_t x;
        asm(move SR,x);
        return !(x & 0x0200);
    }
    #define IRQ_ENABLED() irq_enabled()

#elif CPU_AVR

    #define IRQ_DISABLE   asm volatile ("cli" ::)
    #define IRQ_ENABLE    asm volatile ("sei" ::)

    #define IRQ_SAVE_DISABLE(x) \
    do { \
        __asm__ __volatile__( \
            "in %0,__SREG__\n\t" \
            "cli" \
            : "=r" (x) : /* no inputs */ : "cc" \
        ); \
    } while (0)

    #define IRQ_RESTORE(x) \
    do { \
        __asm__ __volatile__( \
            "out __SREG__,%0" : /* no outputs */ : "r" (x) : "cc" \
        ); \
    } while (0)

    #define IRQ_ENABLED() \
    ({ \
        uint8_t sreg; \
        __asm__ __volatile__( \
            "in %0,__SREG__\n\t" \
            : "=r" (sreg)  /* no inputs & no clobbers */ \
        ); \
        (bool)(sreg & 0x80); \
    })
#else
    #error No CPU_... defined.
#endif

#ifndef IRQ_ENTRY
    #define IRQ_ENTRY() /* NOP */
#endif

#ifndef IRQ_EXIT
    #define IRQ_EXIT() /* NOP */
#endif

#ifdef IRQ_RUNNING
    #define ASSERT_IRQ_CONTEXT()  ASSERT(IRQ_RUNNING())

    #define ASSERT_USER_CONTEXT() ASSERT(!IRQ_RUNNING())
#else
    #define ASSERT_USER_CONTEXT()  do {} while(0)
    #define ASSERT_IRQ_CONTEXT()   do {} while(0)
#endif

#ifdef IRQ_ENABLED
    #define IRQ_ASSERT_ENABLED()  ASSERT(IRQ_ENABLED())

    #define IRQ_ASSERT_DISABLED() ASSERT(!IRQ_ENABLED())
#else
    #define IRQ_ASSERT_ENABLED() do {} while(0)
    #define IRQ_ASSERT_DISABLED() do {} while(0)
#endif

#define ATOMIC(CODE) \
    do { \
        cpu_flags_t __flags; \
        IRQ_SAVE_DISABLE(__flags); \
        CODE; \
        IRQ_RESTORE(__flags); \
    } while (0)

#endif /* CPU_IRQ_H */