irq.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Intel corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#ifndef ZEPHYR_INCLUDE_IRQ_H_
#define ZEPHYR_INCLUDE_IRQ_H_
 
/* Pull in the arch-specific implementations */
#include <zephyr/arch/cpu.h>
 
#ifndef _ASMLANGUAGE
#include <limits.h>
#include <stdbool.h>
#include <zephyr/toolchain.h>
#include <zephyr/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif


#define IRQ_CONNECT(irq_p, priority_p, isr_p, isr_param_p, flags_p) \
        ARCH_IRQ_CONNECT(irq_p, priority_p, isr_p, isr_param_p, flags_p)

static inline int
irq_connect_dynamic(unsigned int irq, unsigned int priority,
                    void (*routine)(const void *parameter),
                    const void *parameter, uint32_t flags)
{
        return arch_irq_connect_dynamic(irq, priority, routine, parameter,
                                        flags);
}

static inline int
irq_disconnect_dynamic(unsigned int irq, unsigned int priority,
                       void (*routine)(const void *parameter),
                       const void *parameter, uint32_t flags)
{
        return arch_irq_disconnect_dynamic(irq, priority, routine,
                                           parameter, flags);
}
 
/*
 * Direct interrupts are optional; only architectures selecting
 * CONFIG_ARCH_HAS_DIRECT_INTERRUPTS define the ARCH_*_DIRECT_* hooks used
 * below. Without these fallbacks the undefined function-like macros survive
 * preprocessing and misparse as K&R function definitions, which reports a
 * missing return type rather than the missing feature.
 *
 * Only the two API entry points are stubbed: the HEADER/FOOTER/PM hooks are
 * reachable solely from inside a direct ISR body, so the assertion on
 * ARCH_ISR_DIRECT_DECLARE() already covers them, and RX defines the
 * HEADER/FOOTER hooks for its internal ISR accounting without supporting
 * direct interrupts, so stubbing those would collide.
 *
 * The guard cannot test the hooks themselves: the arch-level irq.h headers
 * include this file before defining them. Doxygen is kept out so that the
 * documented stubs in arch_interface.h remain the only visible definitions.
 */
#if !defined(CONFIG_ARCH_HAS_DIRECT_INTERRUPTS) && !defined(__DOXYGEN__)
 
#define Z_ISR_DIRECT_UNSUPPORTED \
        BUILD_ASSERT(0, "direct interrupts are not supported by this architecture")
 
#define ARCH_IRQ_DIRECT_CONNECT(irq_p, priority_p, isr_p, flags_p) \
        Z_ISR_DIRECT_UNSUPPORTED
#define ARCH_ISR_DIRECT_DECLARE(name) \
        Z_ISR_DIRECT_UNSUPPORTED; \
        int name(void)
 
#endif /* !CONFIG_ARCH_HAS_DIRECT_INTERRUPTS && !__DOXYGEN__ */

#define IRQ_DIRECT_CONNECT(irq_p, priority_p, isr_p, flags_p) \
        ARCH_IRQ_DIRECT_CONNECT(irq_p, priority_p, isr_p, flags_p)

#define ISR_DIRECT_HEADER() ARCH_ISR_DIRECT_HEADER()

#define ISR_DIRECT_FOOTER(check_reschedule) \
        ARCH_ISR_DIRECT_FOOTER(check_reschedule)

#define ISR_DIRECT_PM() ARCH_ISR_DIRECT_PM()

#define ISR_DIRECT_DECLARE(name) ARCH_ISR_DIRECT_DECLARE(name)

#ifdef CONFIG_SMP
unsigned int z_smp_global_lock(void);
#define irq_lock() z_smp_global_lock()
#else
#define irq_lock() arch_irq_lock()
#endif

#ifdef CONFIG_SMP
void z_smp_global_unlock(unsigned int key);
#define irq_unlock(key) z_smp_global_unlock(key)
#else
#define irq_unlock(key) arch_irq_unlock(key)
#endif

#define irq_enable(irq) arch_irq_enable(irq)

#define irq_disable(irq) arch_irq_disable(irq)

#define irq_is_enabled(irq) arch_irq_is_enabled(irq)
 
/*
 * Namespaced equivalents of the interrupt APIs above. New code should
 * prefer these. The unprefixed names remain fully supported and must stay
 * function-like macros: vendor HAL headers declare functions with those
 * names, and a macro coexists with such a declaration where a function
 * definition would conflict.
 */

static ALWAYS_INLINE unsigned int k_irq_lock(void)
{
        return irq_lock();
}

static ALWAYS_INLINE void k_irq_unlock(unsigned int key)
{
        irq_unlock(key);
}

static ALWAYS_INLINE void k_irq_enable(unsigned int irq)
{
        irq_enable(irq);
}

static ALWAYS_INLINE void k_irq_disable(unsigned int irq)
{
        irq_disable(irq);
}

static ALWAYS_INLINE int k_irq_is_enabled(unsigned int irq)
{
        return irq_is_enabled(irq);
}

static ALWAYS_INLINE int k_irq_connect_dynamic(unsigned int irq, unsigned int priority,
                                               void (*routine)(const void *parameter),
                                               const void *parameter, uint32_t flags)
{
        return irq_connect_dynamic(irq, priority, routine, parameter, flags);
}

static ALWAYS_INLINE int k_irq_disconnect_dynamic(unsigned int irq, unsigned int priority,
                                                  void (*routine)(const void *parameter),
                                                  const void *parameter, uint32_t flags)
{
        return irq_disconnect_dynamic(irq, priority, routine, parameter, flags);
}
 
#if defined(CONFIG_ARCH_HAS_IRQ_PENDING_OPS) || defined(__DOXYGEN__)
static ALWAYS_INLINE void k_irq_clear_pending(unsigned int irq)
{
        arch_irq_clear_pending(irq);
}

static ALWAYS_INLINE void k_irq_set_pending(unsigned int irq)
{
        arch_irq_set_pending(irq);
}

static ALWAYS_INLINE bool k_irq_is_pending(unsigned int irq)
{
        return arch_irq_is_pending(irq);
}
#endif /* CONFIG_ARCH_HAS_IRQ_PENDING_OPS */
 
#if defined(CONFIG_ARCH_HAS_IRQ_GET_ACTIVE) || defined(__DOXYGEN__)
#define K_IRQ_ACTIVE_NONE UINT_MAX

static ALWAYS_INLINE unsigned int k_irq_get_active(void)
{
        return arch_irq_get_active();
}
#endif /* CONFIG_ARCH_HAS_IRQ_GET_ACTIVE */

 
#ifdef __cplusplus
}
#endif
 
#endif /* ASMLANGUAGE */
#endif /* ZEPHYR_INCLUDE_IRQ_H_ */