irq-generic.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-2-Clause */
 
/*
 * Copyright (C) 2016 Chris Johns <chrisj@rtems.org>
 *
 * Copyright (C) 2008, 2024 embedded brains GmbH & Co. KG
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
/*
 * The API is based on concepts of Pavel Pisa, Till Straumann and Eric Valette.
 */
 
#ifndef LIBBSP_SHARED_IRQ_GENERIC_H
#define LIBBSP_SHARED_IRQ_GENERIC_H
 
#include <stdbool.h>
 
#include <rtems/irq-extension.h>
#include <rtems/score/assert.h>
#include <rtems/score/processormask.h>
 
#ifdef RTEMS_SMP
  #include <rtems/score/atomic.h>
#endif
 
#include <bsp/irq.h>
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#if !defined(BSP_INTERRUPT_VECTOR_COUNT)
  #error "BSP_INTERRUPT_VECTOR_COUNT shall be defined"
#endif
 
#if defined(BSP_INTERRUPT_USE_INDEX_TABLE) && !defined(BSP_INTERRUPT_DISPATCH_TABLE_SIZE)
  #error "if you define BSP_INTERRUPT_USE_INDEX_TABLE, you have to define BSP_INTERRUPT_DISPATCH_TABLE_SIZE etc. as well"
#endif
 
#ifndef BSP_INTERRUPT_DISPATCH_TABLE_SIZE
  #define BSP_INTERRUPT_DISPATCH_TABLE_SIZE BSP_INTERRUPT_VECTOR_COUNT
#endif
 
#if !defined(BSP_IRQ_HAVE_GET_SET_AFFINITY) && defined(RTEMS_SMP)
  #define BSP_IRQ_HAVE_GET_SET_AFFINITY
#endif
 
#define bsp_interrupt_assert(e) _Assert(e)
 
extern rtems_interrupt_entry *bsp_interrupt_dispatch_table[];
 
#ifdef BSP_INTERRUPT_USE_INDEX_TABLE
  #if BSP_INTERRUPT_DISPATCH_TABLE_SIZE < 0x100
    typedef uint8_t bsp_interrupt_dispatch_index_type;
  #elif BSP_INTERRUPT_DISPATCH_TABLE_SIZE < 0x10000
    typedef uint16_t bsp_interrupt_dispatch_index_type;
  #else
    typedef uint32_t bsp_interrupt_dispatch_index_type;
  #endif
  extern bsp_interrupt_dispatch_index_type bsp_interrupt_dispatch_index_table [];
#endif
 
static inline rtems_vector_number bsp_interrupt_dispatch_index(
  rtems_vector_number vector
)
{
  #ifdef BSP_INTERRUPT_USE_INDEX_TABLE
    return bsp_interrupt_dispatch_index_table [vector];
  #else
    return vector;
  #endif
}
 
#ifdef BSP_INTERRUPT_CUSTOM_VALID_VECTOR
  bool bsp_interrupt_is_valid_vector(rtems_vector_number vector);
#else
  static inline bool bsp_interrupt_is_valid_vector(rtems_vector_number vector)
  {
    return vector < (rtems_vector_number) BSP_INTERRUPT_VECTOR_COUNT;
  }
#endif
 
void bsp_interrupt_handler_default(rtems_vector_number vector);
 
void bsp_interrupt_initialize(void);
 
void bsp_interrupt_facility_initialize(void);
 
rtems_status_code bsp_interrupt_get_attributes(
  rtems_vector_number         vector,
  rtems_interrupt_attributes *attributes
);
 
rtems_status_code bsp_interrupt_vector_is_enabled(
  rtems_vector_number vector,
  bool               *enabled
);
 
rtems_status_code bsp_interrupt_vector_enable( rtems_vector_number vector );
 
rtems_status_code bsp_interrupt_vector_disable( rtems_vector_number vector );
 
rtems_status_code bsp_interrupt_is_pending(
  rtems_vector_number vector,
  bool               *pending
);
 
rtems_status_code bsp_interrupt_raise( rtems_vector_number vector );
 
#if defined(RTEMS_SMP)
rtems_status_code bsp_interrupt_raise_on(
  rtems_vector_number vector,
  uint32_t            cpu_index
);
#endif
 
rtems_status_code bsp_interrupt_clear( rtems_vector_number vector );
 
rtems_status_code bsp_interrupt_get_priority(
  rtems_vector_number vector,
  uint32_t           *priority
);
 
rtems_status_code bsp_interrupt_set_priority(
  rtems_vector_number vector,
  uint32_t            priority
);
 
rtems_status_code bsp_interrupt_get_affinity(
  rtems_vector_number  vector,
  Processor_mask      *affinity
);
 
rtems_status_code bsp_interrupt_set_affinity(
  rtems_vector_number   vector,
  const Processor_mask *affinity
);
 
#if defined(RTEMS_SMP)
void bsp_interrupt_spurious( rtems_vector_number vector );
#endif
 
static inline rtems_interrupt_entry *bsp_interrupt_entry_load_acquire(
  rtems_interrupt_entry * const *ptr
)
{
#if defined(RTEMS_SMP)
  return (rtems_interrupt_entry *) _Atomic_Load_uintptr(
    (const Atomic_Uintptr *) ptr,
    ATOMIC_ORDER_ACQUIRE
  );
#else
  return *ptr;
#endif
}
 
static inline void bsp_interrupt_entry_store_release(
  rtems_interrupt_entry **ptr,
  rtems_interrupt_entry  *value
)
{
#if defined(RTEMS_SMP)
  _Atomic_Store_uintptr(
    (Atomic_Uintptr *) ptr,
    (uintptr_t) value,
    ATOMIC_ORDER_RELEASE
  );
#else
  rtems_interrupt_level level;
 
  rtems_interrupt_local_disable( level );
  *ptr = value;
  rtems_interrupt_local_enable( level );
#endif
}
 
static inline rtems_interrupt_entry *bsp_interrupt_entry_load_first(
  rtems_vector_number vector
)
{
  rtems_vector_number index;
 
  index = bsp_interrupt_dispatch_index( vector );
 
  return bsp_interrupt_entry_load_acquire(
    &bsp_interrupt_dispatch_table[ index ]
  );
}
 
static inline void bsp_interrupt_dispatch_entries(
  const rtems_interrupt_entry *entry
)
{
  do {
    ( *entry->handler )( entry->arg );
    entry = bsp_interrupt_entry_load_acquire( &entry->next );
  } while ( RTEMS_PREDICT_FALSE( entry != NULL ) );
}
 
static inline void bsp_interrupt_handler_dispatch_unlikely(
  rtems_vector_number vector
)
{
  const rtems_interrupt_entry *entry;
 
  entry = bsp_interrupt_entry_load_first( vector );
 
  if ( RTEMS_PREDICT_FALSE( entry != NULL ) ) {
    bsp_interrupt_dispatch_entries( entry );
  }
}
 
static inline void bsp_interrupt_handler_dispatch_unchecked(
  rtems_vector_number vector
)
{
  const rtems_interrupt_entry *entry;
 
  entry = bsp_interrupt_entry_load_first( vector );
 
  if ( RTEMS_PREDICT_TRUE( entry != NULL ) ) {
    bsp_interrupt_dispatch_entries( entry );
  } else {
#if defined(RTEMS_SMP)
    bsp_interrupt_spurious( vector );
#else
    bsp_interrupt_handler_default( vector );
#endif
  }
}
 
static inline void bsp_interrupt_handler_dispatch( rtems_vector_number vector )
{
  if ( bsp_interrupt_is_valid_vector( vector ) ) {
    bsp_interrupt_handler_dispatch_unchecked( vector );
  } else {
    bsp_interrupt_handler_default( vector );
  }
}
 
void bsp_interrupt_lock(void);
 
void bsp_interrupt_unlock(void);
 
rtems_status_code bsp_interrupt_check_and_lock(
  rtems_vector_number     vector,
  rtems_interrupt_handler handler
);
 
/* For internal use only */
rtems_interrupt_entry *bsp_interrupt_entry_find(
  rtems_vector_number      vector,
  rtems_interrupt_handler  routine,
  void                    *arg,
  rtems_interrupt_entry ***previous_next
);
 
/* For internal use only */
void bsp_interrupt_entry_remove(
  rtems_vector_number     vector,
  rtems_interrupt_entry  *entry,
  rtems_interrupt_entry **previous_next
);
 
extern uint8_t bsp_interrupt_handler_unique_table[];
 
static inline bool bsp_interrupt_is_handler_unique( rtems_vector_number index )
{
  rtems_vector_number table_index;
  uint8_t             bit;
 
  table_index = index / 8;
  bit = (uint8_t) ( 1U << ( index % 8 ) );
 
  return ( bsp_interrupt_handler_unique_table[ table_index ] & bit ) != 0;
}
 
static inline void bsp_interrupt_set_handler_unique(
  rtems_vector_number index,
  bool                unique
)
{
  rtems_vector_number table_index;
  uint8_t             bit;
 
  table_index = index / 8;
  bit = (uint8_t) ( 1U << ( index % 8 ) );
 
  if (unique) {
    bsp_interrupt_handler_unique_table[ table_index ] |= bit;
  } else {
    bsp_interrupt_handler_unique_table[ table_index ] &= ~bit;
  }
}
 
static inline bool bsp_interrupt_is_initialized( void )
{
  return bsp_interrupt_is_handler_unique( BSP_INTERRUPT_DISPATCH_TABLE_SIZE );
}
 
rtems_interrupt_entry **bsp_interrupt_get_dispatch_table_slot(
  rtems_vector_number index
);
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* LIBBSP_SHARED_IRQ_GENERIC_H */