irq_multilevel.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Meta
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_IRQ_MULTILEVEL_H_
#define ZEPHYR_INCLUDE_IRQ_MULTILEVEL_H_
 
#ifndef _ASMLANGUAGE
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util_macro.h>
#include <zephyr/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(CONFIG_MULTI_LEVEL_INTERRUPTS) || defined(__DOXYGEN__)
static inline unsigned int irq_get_level(unsigned int irq)
{
        const uint32_t mask2 = BIT_MASK(CONFIG_2ND_LEVEL_INTERRUPT_BITS) <<
                CONFIG_1ST_LEVEL_INTERRUPT_BITS;
        const uint32_t mask3 = BIT_MASK(CONFIG_3RD_LEVEL_INTERRUPT_BITS) <<
                (CONFIG_1ST_LEVEL_INTERRUPT_BITS + CONFIG_2ND_LEVEL_INTERRUPT_BITS);
 
        if (IS_ENABLED(CONFIG_3RD_LEVEL_INTERRUPTS) && (irq & mask3) != 0) {
                return 3;
        }
 
        if (IS_ENABLED(CONFIG_2ND_LEVEL_INTERRUPTS) && (irq & mask2) != 0) {
                return 2;
        }
 
        return 1;
}
 
static inline unsigned int irq_from_level_2(unsigned int irq)
{
        if (IS_ENABLED(CONFIG_3RD_LEVEL_INTERRUPTS)) {
                return ((irq >> CONFIG_1ST_LEVEL_INTERRUPT_BITS) &
                        BIT_MASK(CONFIG_2ND_LEVEL_INTERRUPT_BITS)) - 1;
        } else {
                return (irq >> CONFIG_1ST_LEVEL_INTERRUPT_BITS) - 1;
        }
}
 
#define IRQ_TO_L2(irq) ((irq + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS)
 
static inline unsigned int irq_to_level_2(unsigned int irq)
{
        return IRQ_TO_L2(irq);
}
 
static inline unsigned int irq_parent_level_2(unsigned int irq)
{
        return irq & BIT_MASK(CONFIG_1ST_LEVEL_INTERRUPT_BITS);
}
 
static inline unsigned int irq_from_level_3(unsigned int irq)
{
        return (irq >> (CONFIG_1ST_LEVEL_INTERRUPT_BITS + CONFIG_2ND_LEVEL_INTERRUPT_BITS)) - 1;
}
 
#define IRQ_TO_L3(irq)                                                                             \
        ((irq + 1) << (CONFIG_1ST_LEVEL_INTERRUPT_BITS + CONFIG_2ND_LEVEL_INTERRUPT_BITS))
 
static inline unsigned int irq_to_level_3(unsigned int irq)
{
        return IRQ_TO_L3(irq);
}
 
static inline unsigned int irq_parent_level_3(unsigned int irq)
{
        return ((irq >> CONFIG_1ST_LEVEL_INTERRUPT_BITS) &
                BIT_MASK(CONFIG_2ND_LEVEL_INTERRUPT_BITS)) -
               1;
}
 
static inline unsigned int irq_from_level(unsigned int irq, unsigned int level)
{
        if (level == 1) {
                return irq;
        } else if (level == 2) {
                return irq_from_level_2(irq);
        } else if (level == 3) {
                return irq_from_level_3(irq);
        }
 
        /* level is higher than 3 */
        __ASSERT_NO_MSG(false);
        return irq;
}
 
static inline unsigned int irq_to_level(unsigned int irq, unsigned int level)
{
        if (level == 1) {
                return irq;
        } else if (level == 2) {
                return irq_to_level_2(irq);
        } else if (level == 3) {
                return irq_to_level_3(irq);
        }
 
        /* level is higher than 3 */
        __ASSERT_NO_MSG(false);
        return irq;
}
 
static inline unsigned int irq_parent_level(unsigned int irq, unsigned int level)
{
        if (level == 1) {
                /* doesn't really make sense, but return anyway */
                return irq;
        } else if (level == 2) {
                return irq_parent_level_2(irq);
        } else if (level == 3) {
                return irq_parent_level_3(irq);
        }
 
        /* level is higher than 3 */
        __ASSERT_NO_MSG(false);
        return irq;
}
 
static inline unsigned int irq_get_intc_irq(unsigned int irq)
{
        const unsigned int level = irq_get_level(irq);
 
        __ASSERT_NO_MSG(level > 1 && level <= 3);
 
        return irq & BIT_MASK(CONFIG_1ST_LEVEL_INTERRUPT_BITS +
                              (level == 3 ? CONFIG_2ND_LEVEL_INTERRUPT_BITS : 0));
}
 
#endif /* CONFIG_MULTI_LEVEL_INTERRUPTS */
#ifdef __cplusplus
}
#endif
 
#endif /* _ASMLANGUAGE */
#endif /* ZEPHYR_INCLUDE_IRQ_MULTILEVEL_H_ */