irq.h File Reference

ARCv2 public interrupt handling. More...

#include <zephyr/arch/arc/v2/aux_regs.h>
#include <zephyr/toolchain/common.h>
#include <zephyr/irq.h>
#include <zephyr/sys/util.h>
#include <zephyr/sw_isr_table.h>

Go to the source code of this file.

Macros
#define	ARC_MP_PRIMARY_CPU_ID   0
#define	ARCH_IRQ_CONNECT(irq_p, priority_p, isr_p, isr_param_p, flags_p)
#define	ARCH_IRQ_DIRECT_CONNECT(irq_p, priority_p, isr_p, flags_p)
	Configure a 'direct' static interrupt.
#define	ARCH_ISR_DIRECT_HEADER()
#define	ARCH_ISR_DIRECT_FOOTER(swap)
#define	ARCH_ISR_DIRECT_DECLARE(name)

Functions
void	arch_irq_enable (unsigned int irq)
void	arch_irq_disable (unsigned int irq)
int	arch_irq_is_enabled (unsigned int irq)
static void	arch_isr_direct_header (void)
static void	arch_isr_direct_footer (int maybe_swap)
static ALWAYS_INLINE unsigned int	arch_irq_lock (void)
	Disable all interrupts on the local CPU.
static ALWAYS_INLINE void	arch_irq_unlock (unsigned int key)
static ALWAYS_INLINE bool	arch_irq_unlocked (unsigned int key)
static ALWAYS_INLINE bool	arch_cpu_irqs_are_enabled (void)
	Implementation of arch_cpu_irqs_are_enabled.

Detailed Description

ARCv2 public interrupt handling.

ARCv2 kernel interrupt handling interface. Included by arc/arch.h.

Macro Definition Documentation

ARC_MP_PRIMARY_CPU_ID

#define ARC_MP_PRIMARY_CPU_ID   0

ARCH_IRQ_CONNECT

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

Value:

{ \
        Z_ISR_DECLARE(irq_p, 0, isr_p, isr_param_p); \
        z_irq_priority_set(irq_p, priority_p, flags_p); \
}

ARCH_IRQ_DIRECT_CONNECT

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

Value:

{ \
        Z_ISR_DECLARE_DIRECT(irq_p, ISR_FLAG_DIRECT, isr_p); \
        BUILD_ASSERT(priority_p || !IS_ENABLED(CONFIG_ARC_FIRQ) || \
        (IS_ENABLED(CONFIG_ARC_FIRQ_STACK) && \
        !IS_ENABLED(CONFIG_ARC_STACK_CHECKING)), \
        "irq priority cannot be set to 0 when CONFIG_ARC_FIRQ_STACK" \
        "is not configured or CONFIG_ARC_FIRQ_STACK " \
        "and CONFIG_ARC_STACK_CHECKING are configured together"); \
        z_irq_priority_set(irq_p, priority_p, flags_p); \
}

Configure a 'direct' static interrupt.

When firq has no separate stack(CONFIG_ARC_FIRQ_STACK=N), it's not safe to call C ISR handlers because sp will be switched to bank1's sp which is undefined value. So for this case, the priority cannot be set to 0 but next level 1

When firq has separate stack (CONFIG_ARC_FIRQ_STACK=y) but at the same time stack checking is enabled (CONFIG_ARC_STACK_CHECKING=y) the stack checking can raise stack check exception as sp is switched to firq's stack (bank1's sp). So for this case, the priority cannot be set to 0 but next level 1.

Note that for the above cases, if application still wants to use firq by setting priority to 0. Application can call z_irq_priority_set again. Then it's left to application to handle the details of firq

See include/irq.h for details. All arguments must be computable at build time.

ARCH_ISR_DIRECT_DECLARE

#define ARCH_ISR_DIRECT_DECLARE

(

name

)

Value:

static inline int name##_body(void); \
__attribute__ ((_ARC_DIRECT_ISR_FUNC_ATTRIBUTE))void name(void) \
{ \
        ISR_DIRECT_HEADER(); \
        name##_body(); \
        ISR_DIRECT_FOOTER(0); \
} \
static inline int name##_body(void)

ARCH_ISR_DIRECT_FOOTER

#define ARCH_ISR_DIRECT_FOOTER

(

swap

)

Value:

arch_isr_direct_footer(swap)

ARCH_ISR_DIRECT_HEADER

#define ARCH_ISR_DIRECT_HEADER

(

)

Value:

arch_isr_direct_header()

Function Documentation

arch_cpu_irqs_are_enabled()

ALWAYS_INLINE bool arch_cpu_irqs_are_enabled ( void )

static

Implementation of arch_cpu_irqs_are_enabled.

arch_irq_disable()

void arch_irq_disable ( unsigned int irq )

extern

arch_irq_enable()

void arch_irq_enable ( unsigned int irq )

extern

arch_irq_is_enabled()

int arch_irq_is_enabled ( unsigned int irq )

extern

arch_irq_lock()

ALWAYS_INLINE unsigned int arch_irq_lock ( void )

static

Disable all interrupts on the local CPU.

This routine disables interrupts. It can be called from either interrupt or thread level. This routine returns an architecture-dependent lock-out key representing the "interrupt disable state" prior to the call; this key can be passed to irq_unlock() to re-enable interrupts.

The lock-out key should only be used as the argument to the irq_unlock() API. It should never be used to manually re-enable interrupts or to inspect or manipulate the contents of the source register.

This function can be called recursively: it will return a key to return the state of interrupt locking to the previous level.

WARNINGS Invoking a kernel routine with interrupts locked may result in interrupts being re-enabled for an unspecified period of time. If the called routine blocks, interrupts will be re-enabled while another thread executes, or while the system is idle.

The "interrupt disable state" is an attribute of a thread. Thus, if a thread disables interrupts and subsequently invokes a kernel routine that causes the calling thread to block, the interrupt disable state will be restored when the thread is later rescheduled for execution.

Returns

An architecture-dependent lock-out key representing the "interrupt disable state" prior to the call.

arch_irq_unlock()

ALWAYS_INLINE void arch_irq_unlock ( unsigned int key )

static

arch_irq_unlocked()

ALWAYS_INLINE bool arch_irq_unlocked ( unsigned int key )

static

arch_isr_direct_footer()

void arch_isr_direct_footer ( int maybe_swap )

inlinestatic

arch_isr_direct_header()

void arch_isr_direct_header ( void )

inlinestatic