/**
* @brief initialization of the interrupt driven driver
*
* calls tms570_sci_poll_first_open function.
* install and enables interrupts.
*
* @param[in] tty Termios control
* @param[in] base context of the driver
* @param[in] args
* @retval false Error occured during initialization
* @retval true Driver is open and ready
*/
static bool tms570_sci_interrupt_first_open(
rtems_termios_tty *tty,
rtems_termios_device_context *base,
struct termios *term,
rtems_libio_open_close_args_t *args
)
{
tms570_sci_context *ctx = (tms570_sci_context *) base;
rtems_status_code sc;
bool ret;
ret = tms570_sci_poll_first_open(tty, base, term, args);
if ( ret == false ) {
return false;
}
ctx->regs->SETINTLVL = 0;
/* Register Interrupt handler */
sc = rtems_interrupt_handler_install(ctx->irq,
ctx->device_name,
RTEMS_INTERRUPT_SHARED,
tms570_sci_interrupt_handler,
tty
);
if ( sc != RTEMS_SUCCESSFUL ) {
return false;
}
tms570_sci_enable_interrupts(ctx);
return true;
}
static int pl050_first_open(int major, int minor, void *arg)
{
rtems_libio_open_close_args_t *oc = (rtems_libio_open_close_args_t *) arg;
struct rtems_termios_tty *tty = (struct rtems_termios_tty *) oc->iop->data1;
console_data *cd = &Console_Port_Data[minor];
const console_tbl *ct = Console_Port_Tbl[minor];
volatile pl050 *regs = pl050_get_regs(minor);
rtems_status_code sc;
cd->termios_data = tty;
rtems_termios_set_initial_baud(tty, (rtems_termios_baud_t) ct->pDeviceParams);
regs->kmicr = PL050_KMICR_KMIEN | PL050_KMICR_KMIRXINTREN;
sc = rtems_interrupt_handler_install(
ct->ulIntVector,
ct->sDeviceName,
RTEMS_INTERRUPT_UNIQUE,
pl050_interrupt,
(void *) minor
);
assert(sc == RTEMS_SUCCESSFUL);
return 0;
}
/**
* Initial task.
*
* Enables interrupts, runs calibration and starts up new tasks.
*
* Delete itself after completion.
*/
rtems_task Init(rtems_task_argument ignored) {
position_isr.x = 0;
position_isr.y = 0;
rtems_name name;
rtems_status_code status;
name = rtems_build_name('Q','U','E','1');
status = rtems_message_queue_create(name, 1, sizeof(position_t), RTEMS_LOCAL, &msg_queue);
assert( status == RTEMS_SUCCESSFUL );
// setup IRQ handler
status = rtems_interrupt_handler_install(5, NULL, RTEMS_INTERRUPT_UNIQUE, isr, NULL);
assert( status == RTEMS_SUCCESSFUL );
// calibrate
calibrate();
// create semaphore
name = rtems_build_name('S','E','M','1');
status = rtems_semaphore_create(name,1,RTEMS_SIMPLE_BINARY_SEMAPHORE,0,&state_semaphore_id);
assert(status == RTEMS_SUCCESSFUL);
set_status(STATE_READY);
create_and_start_tasks();
// all done. delete itself.
rtems_task_delete(RTEMS_SELF);
}
static bool apbuart_first_open_interrupt(
rtems_termios_tty *tty,
rtems_termios_device_context *base,
struct termios *term,
rtems_libio_open_close_args_t *args
)
{
struct apbuart_context *uart = (struct apbuart_context *) base;
rtems_status_code sc;
apbuart_set_best_baud(uart, term);
/* Register Interrupt handler */
sc = rtems_interrupt_handler_install(uart->irq, "console",
RTEMS_INTERRUPT_SHARED,
apbuart_isr,
tty);
if (sc != RTEMS_SUCCESSFUL)
return false;
uart->sending = 0;
/* Enable Receiver and transmitter and Turn on RX interrupts */
uart->regs->ctrl |= APBUART_CTRL_RE | APBUART_CTRL_TE |
APBUART_CTRL_RI;
/* Initialize UART on opening */
uart->regs->ctrl |= APBUART_CTRL_RE | APBUART_CTRL_TE;
uart->regs->status = 0;
return true;
}
static int leon3_console_first_open(int major, int minor, void *arg)
{
struct apbuart_priv *uart = leon3_console_get_uart(minor);
#if CONSOLE_USE_INTERRUPTS
rtems_status_code sc;
uart->cookie = leon3_console_get_tty(arg);
/* Register Interrupt handler */
sc = rtems_interrupt_handler_install(uart->irq, "console",
RTEMS_INTERRUPT_SHARED,
leon3_console_isr,
uart);
if (sc != RTEMS_SUCCESSFUL)
return -1;
uart->sending = 0;
/* Enable Receiver and transmitter and Turn on RX interrupts */
uart->regs->ctrl |= LEON_REG_UART_CTRL_RE | LEON_REG_UART_CTRL_TE |
LEON_REG_UART_CTRL_RI;
#else
/* Initialize UART on opening */
uart->regs->ctrl |= LEON_REG_UART_CTRL_RE | LEON_REG_UART_CTRL_TE;
#endif
uart->regs->status = 0;
return 0;
}
static void qoriq_clock_handler_install(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
#if defined(RTEMS_MULTIPROCESSING) && !defined(RTEMS_SMP)
{
Processor_mask affinity;
_Processor_mask_From_index(&affinity, ppc_processor_id());
bsp_interrupt_set_affinity(CLOCK_INTERRUPT, &affinity);
}
#endif
sc = qoriq_pic_set_priority(
CLOCK_INTERRUPT,
QORIQ_PIC_PRIORITY_LOWEST,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
sc = rtems_interrupt_handler_install(
CLOCK_INTERRUPT,
"Clock",
RTEMS_INTERRUPT_UNIQUE,
Clock_isr,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
}
static void qoriq_clock_handler_install(rtems_isr_entry *old_isr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
*old_isr = NULL;
sc = qoriq_pic_set_affinity(
CLOCK_INTERRUPT,
ppc_processor_id()
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
sc = qoriq_pic_set_priority(
CLOCK_INTERRUPT,
QORIQ_PIC_PRIORITY_LOWEST,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
sc = rtems_interrupt_handler_install(
CLOCK_INTERRUPT,
"Clock",
RTEMS_INTERRUPT_UNIQUE,
(rtems_interrupt_handler) Clock_isr,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
}
bool vgacons_probe(
int minor
)
{
rtems_status_code status;
static bool firstTime = true;
if ((*(unsigned char*) NB_MAX_ROW_ADDR == 0) &&
(*(unsigned short*)NB_MAX_COL_ADDR == 0)) {
return false;
}
/*
* If there is a video card, let's assume there is also a keyboard.
* The means that we need the ISR installed in case someone wants to
* use the Keyboard or PS2 Mouse. With Microwindows, the console
* can be COM1 and you can still use the mouse/VGA for graphics.
*/
if ( firstTime ) {
status = rtems_interrupt_handler_install(
BSP_KEYBOARD,
"vgacons",
RTEMS_INTERRUPT_UNIQUE,
keyboard_interrupt,
NULL
);
assert(status == RTEMS_SUCCESSFUL);
}
firstTime = false;
return true;
}
/*
* ns16550_initialize_interrupts
*
* This routine initializes the port to operate in interrupt driver mode.
*/
NS16550_STATIC void ns16550_initialize_interrupts( int minor)
{
#if defined(BSP_FEATURE_IRQ_EXTENSION) || defined(BSP_FEATURE_IRQ_LEGACY)
console_tbl *c = Console_Port_Tbl [minor];
#endif
console_data *d = &Console_Port_Data [minor];
d->bActive = false;
#ifdef BSP_FEATURE_IRQ_EXTENSION
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_install(
c->ulIntVector,
"NS16550",
RTEMS_INTERRUPT_SHARED,
ns16550_isr,
(void *) minor
);
if (sc != RTEMS_SUCCESSFUL) {
/* FIXME */
printk( "%s: Error: Install interrupt handler\n", __func__);
rtems_fatal_error_occurred( 0xdeadbeef);
}
}
#elif defined(BSP_FEATURE_IRQ_LEGACY)
{
int rv = 0;
#ifdef BSP_FEATURE_IRQ_LEGACY_SHARED_HANDLER_SUPPORT
rtems_irq_connect_data cd = {
c->ulIntVector,
ns16550_isr,
(void *) minor,
NULL,
NULL,
NULL,
NULL
};
rv = BSP_install_rtems_shared_irq_handler( &cd);
#else
rtems_irq_connect_data cd = {
c->ulIntVector,
ns16550_isr,
(void *) minor,
NULL,
NULL,
NULL
};
rv = BSP_install_rtems_irq_handler( &cd);
#endif
if (rv == 0) {
/* FIXME */
printk( "%s: Error: Install interrupt handler\n", __func__);
rtems_fatal_error_occurred( 0xdeadbeef);
}
}
#endif
}
/**
* @brief Installs the interrupt handler in rtems.
*/
static inline rtems_status_code can_initialize( void )
{
return rtems_interrupt_handler_install(
LPC176X_IRQ_CAN,
"can_interrupt",
RTEMS_INTERRUPT_UNIQUE,
can_isr,
NULL
);
}
void HAL_ETH_MspInit( ETH_HandleTypeDef *heth )
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOs clocks */
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
/* Ethernet pins configuration ************************************************/
/*
RMII_REF_CLK ----------------------> PA1
RMII_MDIO -------------------------> PA2
RMII_MDC --------------------------> PC1
RMII_MII_CRS_DV -------------------> PA7
RMII_MII_RXD0 ---------------------> PC4
RMII_MII_RXD1 ---------------------> PC5
RMII_MII_RXER ---------------------> PG2
RMII_MII_TX_EN --------------------> uint32_t stm32f_ethernet_get_num_tx_msg(void)
{
return num_ethernet_tx_msg;
}PG11
RMII_MII_TXD0 ---------------------> PG13
RMII_MII_TXD1 ---------------------> PG14
*/
/* Configure PA1, PA2 and PA7 */
GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Alternate = GPIO_AF11_ETH;
GPIO_InitStructure.Pin = GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_7;
HAL_GPIO_Init( GPIOA, &GPIO_InitStructure );
/* Configure PC1, PC4 and PC5 */
GPIO_InitStructure.Pin = GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5;
HAL_GPIO_Init( GPIOC, &GPIO_InitStructure );
/* Configure PG2, PG11, PG13 and PG14 */
GPIO_InitStructure.Pin = GPIO_PIN_2 | GPIO_PIN_11 | GPIO_PIN_13 |
GPIO_PIN_14;
HAL_GPIO_Init( GPIOG, &GPIO_InitStructure );
// Install HAL Ethernet ISR
rtems_interrupt_handler_install(
ETH_IRQn,
NULL,
0,
stm32f_ethernet_isr,
heth );
/* Enable ETHERNET clock */
__HAL_RCC_ETH_CLK_ENABLE();
}
void cs8900_attach_interrupt (cs8900_device *cs)
{
rtems_status_code status = RTEMS_SUCCESSFUL;
status = rtems_interrupt_handler_install(
LPC22xx_INTERRUPT_EINT2,
"Network",
RTEMS_INTERRUPT_UNIQUE,
cs8900_isr,
cs
);
assert(status == RTEMS_SUCCESSFUL);
}
rtems_status_code lpc24xx_dma_copy_initialize(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id id0 = RTEMS_ID_NONE;
rtems_id id1 = RTEMS_ID_NONE;
/* Create semaphore for channel 0 */
sc = rtems_semaphore_create(
rtems_build_name('D', 'M', 'A', '0'),
0,
RTEMS_LOCAL | RTEMS_FIFO | RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&id0
);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Create semaphore for channel 1 */
sc = rtems_semaphore_create(
rtems_build_name('D', 'M', 'A', '1'),
0,
RTEMS_LOCAL | RTEMS_FIFO | RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&id1
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(id0);
return sc;
}
/* Install DMA interrupt handler */
sc = rtems_interrupt_handler_install(
LPC24XX_IRQ_DMA,
"DMA copy",
RTEMS_INTERRUPT_UNIQUE,
lpc24xx_dma_copy_handler,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(id0);
rtems_semaphore_delete(id1);
return sc;
}
/* Initialize global data */
lpc24xx_dma_sema_table [0] = id0;
lpc24xx_dma_sema_table [1] = id1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code stm32f4_i2c_init(stm32f4_i2c_bus_entry *e)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
volatile stm32f4_i2c *regs = e->regs;
stm32f4_rcc_index rcc_index = i2c_get_rcc_index(e);
uint32_t pclk = i2c_get_pclk(e);
uint32_t cr1 = 0;
uint32_t cr2 = 0;
assert(pclk >= 2000000);
/* Create mutex */
sc = rtems_semaphore_create (
rtems_build_name ('I', '2', 'C', '1' + e->index),
0,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
0,
&e->mutex
);
RTEMS_CHECK_SC(sc, "create mutex");
/* Install interrupt handler and disable this vector */
sc = rtems_interrupt_handler_install(
e->vector,
"I2C",
RTEMS_INTERRUPT_UNIQUE,
stm32f4_i2c_handler,
e
);
RTEMS_CHECK_SC(sc, "install interrupt handler");
bsp_interrupt_vector_disable(e->vector);
/* Enable module clock */
stm32f4_rcc_set_clock(rcc_index, true);
/* Setup initial bit rate */
sc = stm32f4_i2c_set_bitrate(e, STM32F4_I2C_INITIAL_BITRATE);
RTEMS_CHECK_SC(sc, "set bitrate");
/* Set config registers */
cr2 = regs->cr2;
cr2 = STM32F4_I2C_CR2_FREQ_SET(cr2, pclk / 1000000);
cr2 |= STM32F4_I2C_CR2_ITEVTEN;
cr2 |= STM32F4_I2C_CR2_ITBUFEN;
regs->cr2 = cr2;
cr1 = regs->cr1;
cr1 |= STM32F4_I2C_CR1_PE;
regs->cr1 = cr1;
return RTEMS_SUCCESSFUL;
}
/**
* @brief Sets up the ARM Interrupt Controller for generating timer interrupt.
*/
static void interruptSetup(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_install(
AM335X_INT_3PGSWRXINT0,
"EthRX",
RTEMS_INTERRUPT_UNIQUE,
CPSWCore0RxIsr,
(void*)DEFAULT_INST_NUM
);
LWIP_ASSERT("Install interrupt handler rx", sc == RTEMS_SUCCESSFUL);
sc = rtems_interrupt_handler_install(
AM335X_INT_3PGSWTXINT0,
"EthTX",
RTEMS_INTERRUPT_UNIQUE,
CPSWCore0TxIsr,
(void*)DEFAULT_INST_NUM
);
LWIP_ASSERT("Install interrupt handler tx", sc == RTEMS_SUCCESSFUL);
}
static void timer_interrupt_handler_install( int number ) {
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_install(
number,
"my_isr",
RTEMS_INTERRUPT_UNIQUE,
(rtems_interrupt_handler) my_isr,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
}
int BSP_connect_clock_handler (rtems_irq_hdl hdl)
{
rtems_status_code sc;
/*
* install interrupt handler
*/
sc = rtems_interrupt_handler_install(BSP_PERIODIC_TIMER,
"PIT clock",0,
BSP_clock_hdl,NULL);
if (sc == RTEMS_SUCCESSFUL) {
clockOn(NULL);
}
return sc == RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_interrupt_server_handler_install(
rtems_id server,
rtems_vector_number vector,
const char *info,
rtems_option options,
rtems_interrupt_handler handler,
void *arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bsp_interrupt_server_entry *e = NULL;
sc = bsp_interrupt_server_is_initialized();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
if (server != RTEMS_ID_NONE) {
return RTEMS_NOT_IMPLEMENTED;
}
if (RTEMS_INTERRUPT_IS_SHARED(options)) {
return RTEMS_NOT_IMPLEMENTED;
}
e = calloc(1, sizeof(*e));
if (e == NULL) {
return RTEMS_NO_MEMORY;
}
e->vector = vector;
e->handler = handler;
e->arg = arg;
sc = rtems_interrupt_handler_install(
vector,
info,
options,
bsp_interrupt_server_trigger,
e
);
if (sc != RTEMS_SUCCESSFUL) {
free(e);
return sc;
}
return RTEMS_SUCCESSFUL;
}
void _CPU_SMP_Finalize_initialization(uint32_t cpu_count)
{
if (cpu_count > 0) {
rtems_status_code sc;
sc = rtems_interrupt_handler_install(
ARM_GIC_IRQ_SGI_0,
"IPI",
RTEMS_INTERRUPT_UNIQUE,
bsp_inter_processor_interrupt,
NULL
);
assert(sc == RTEMS_SUCCESSFUL);
}
}
static void raspberrypi_clock_handler_install(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_install(
BCM2835_IRQ_ID_TIMER_0,
"Clock",
RTEMS_INTERRUPT_UNIQUE,
(rtems_interrupt_handler) Clock_isr,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
}
static void lpc_clock_handler_install(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_install(
LPC_CLOCK_INTERRUPT,
"Clock",
RTEMS_INTERRUPT_UNIQUE,
(rtems_interrupt_handler) Clock_isr,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void Install_clock(
rtems_isr_entry clock_isr
)
{
/*
* Initialize the clock tick device driver variables
*/
Clock_driver_ticks = 0;
Clock_isrs = rtems_configuration_get_milliseconds_per_tick();
mips_timer_rate = rtems_configuration_get_microseconds_per_tick() *
bsp_clicks_per_microsecond;
/*
* Hardware specific initialize goes here
*/
/* Set up USC heartbeat timer to generate interrupts */
disable_hbi(); /* Disable heartbeat interrupt in USC */
/* Install interrupt handler */
rtems_interrupt_handler_install(
CLOCK_VECTOR,
"clock",
0,
USC_isr,
NULL
);
init_hbt(); /* Initialize heartbeat timer */
reset_wdt(); /* Reset watchdog timer */
enable_wdi(); /* Enable watchdog interrupt in USC */
enable_hbi(); /* Enable heartbeat interrupt in USC */
/* Enable USC interrupt in MIPS processor */
mips_enable_in_interrupt_mask(CLOCK_VECTOR_MASK);
/*
* Schedule the clock cleanup routine to execute if the application exits.
*/
atexit( Clock_exit );
}
/**
* @brief registers RTI interrupt handler
*
* @param[in] Clock_isr new ISR handler
* @param[in] Old_ticker old ISR handler (unused and type broken)
*
* @retval Void
*/
static void tms570_clock_driver_support_install_isr(
rtems_isr_entry Clock_isr
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_install(
TMS570_IRQ_TIMER_0,
"Clock",
RTEMS_INTERRUPT_UNIQUE,
(rtems_interrupt_handler) Clock_isr,
NULL
);
if ( sc != RTEMS_SUCCESSFUL ) {
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void _CPU_SMP_Finalize_initialization(uint32_t cpu_count)
{
if (cpu_count > 1) {
rtems_status_code sc;
sc = rtems_interrupt_handler_install(
QORIQ_IRQ_IPI_0 + IPI_INDEX,
"IPI",
RTEMS_INTERRUPT_UNIQUE,
bsp_inter_processor_interrupt,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
bsp_fatal(QORIQ_FATAL_SMP_IPI_HANDLER_INSTALL);
}
}
}
void gpio_init(GPIO_INT_PATA *para)
{
int status;
unsigned int int_src;
unsigned int pin;
pin = para->pin_int;
switch(pin)
{
case GPIO_PIN0:
case GPIO_PIN1:
case GPIO_PIN2:
int_src = BSP_INT_GPIO_0_1_2_11;
break;
case GPIO_PIN3:
case GPIO_PIN4:
case GPIO_PIN5:
int_src = BSP_INT_GPIO_3_4_5_10;
break;
case GPIO_PIN6:
case GPIO_PIN7:
int_src = BSP_INT_GPIO_6_7_8_9;
break;
default:
int_src = BSP_INT_GPIO_0_1_2_11;
break;
}
status = rtems_interrupt_handler_install(
int_src,
"GPIO",
RTEMS_INTERRUPT_UNIQUE,
(rtems_interrupt_handler) gpio_isr,
NULL
);
if(status != RTEMS_SUCCESSFUL){
printk("gpio install interrupt handler failed!\n");
return -1;
}
hi_gpio_int_config(para);
}
void _CPU_SMP_Finalize_initialization(uint32_t cpu_count)
{
if (cpu_count > 0) {
rtems_status_code sc;
sc = rtems_interrupt_handler_install(
ARM_GIC_IRQ_SGI_0,
"IPI",
RTEMS_INTERRUPT_UNIQUE,
bsp_inter_processor_interrupt,
NULL
);
assert(sc == RTEMS_SUCCESSFUL);
#if defined(BSP_DATA_CACHE_ENABLED) || defined(BSP_INSTRUCTION_CACHE_ENABLED)
/* Enable unified L2 cache */
rtems_cache_enable_data();
#endif
}
}
void rx_init(void)
{
rtems_semaphore_create(rtems_build_name('s', 'R', 'X', ' '), 0,
RTEMS_DEFAULT_ATTRIBUTES, 1, &rx_sem);
rtems_status_code sc = rtems_interrupt_handler_install(LM3S69XX_IRQ_GPIO_PORT_D,
"PORT D",
RTEMS_INTERRUPT_UNIQUE,
rx_irq_handler,
NULL);
if (sc != RTEMS_SUCCESSFUL)
rtems_panic("failed to install handler!\n");
rtems_interrupt_level level;
rtems_interrupt_disable(level);
volatile lm3s69xx_gpio *portd = LM3S69XX_GPIO(LM3S69XX_PORT_D);
portd->im |= (1U << 3);
rtems_interrupt_enable(level);
}
/**
* @brief Installs interrupt handler and sets priority.
*/
rtems_status_code mpc55xx_interrupt_handler_install(
rtems_vector_number vector,
const char *info,
rtems_option options,
unsigned priority,
rtems_interrupt_handler handler,
void *arg
)
{
if (MPC55XX_IRQ_IS_VALID( vector) && MPC55XX_INTC_IS_VALID_PRIORITY( priority)) {
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_install( vector, info, options, handler, arg);
RTEMS_CHECK_SC( sc, "Install interrupt handler");
return mpc55xx_intc_set_priority( vector, priority);
} else {
return RTEMS_INVALID_NUMBER;
}
}
static int imx_i2c_init(imx_i2c_bus *bus)
{
rtems_status_code sc;
imx_i2c_set_clock(&bus->base, I2C_BUS_CLOCK_DEFAULT);
bus->regs->i2cr = IMX_I2C_I2CR_IEN;
sc = rtems_interrupt_handler_install(
bus->irq,
"I2C",
RTEMS_INTERRUPT_UNIQUE,
imx_i2c_interrupt,
bus
);
if (sc != RTEMS_SUCCESSFUL) {
return EAGAIN;
}
return 0;
}
/**
* @deprecated Use rtems_interrupt_handler_install() instead.
*/
int BSP_install_rtems_shared_irq_handler(const rtems_irq_connect_data *cd)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_install(
cd->name,
"LEGACY INSTALLED",
RTEMS_INTERRUPT_SHARED,
cd->hdl,
cd->handle
);
if (sc != RTEMS_SUCCESSFUL) {
return 0;
}
if (cd->on != NULL) {
(*cd->on)(cd);
}
return 1;
}
