kunlun/driver/src/hal/irq.c

/****************************************************************************

Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.

This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.

****************************************************************************/
/* os shim includes */
#include "os_types.h"
#include "os_mem.h"
#include "iot_io.h"
#include "iot_irq.h"
#include "intc.h"
#include "cpu.h"

volatile iot_addr_t     hal_interrupt_handlers[HAL_VECTOR_COUNT];
volatile iot_addrword_t hal_interrupt_data    [HAL_VECTOR_COUNT];

volatile iot_interrupt   g_intr_info[HAL_VECTOR_COUNT];

uint32_t IRAM_ATTR hal_default_isr(uint32_t vector, iot_addrword_t data)
{
    (void)vector;
    (void)data;
    return 0;
}

void IRAM_ATTR hal_deliver_interrupt( uint32_t vector )
{
    iot_isr_t *isr;
    iot_addrword_t data;

    isr = (iot_isr_t *)hal_interrupt_handlers[vector];
    data = hal_interrupt_data[vector];

    // Call the ISR
    isr( vector, data);
}

iot_irq_t iot_interrupt_create(uint32_t vector,
                               uint32_t priority,
                               iot_addrword_t data,
                               iot_isr_t *isr)
{

    volatile iot_interrupt *intr;

    intr = &g_intr_info[vector];

    os_mem_set((void*)intr, 0x0, sizeof(iot_interrupt));

    intr->vector = (uint8_t)vector;
    intr->priority = (uint8_t)priority;
    intr->cpu = cpu_get_mhartid();
    intr->isr = isr;
    intr->data = data;

    return (iot_irq_t)intr;
}


void iot_interrupt_delete( iot_irq_t interrupt )
{
    iot_interrupt_detach( interrupt );
}

void iot_interrupt_attach( iot_irq_t interrupt )
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;
    uint32_t vector = intr->vector;
    uint32_t cpu = intr->cpu;
    uint32_t priority = intr->priority;

    intc_set_priority( cpu, vector, priority );

    if( hal_interrupt_handlers[vector] == (iot_addr_t)hal_default_isr ) {
        hal_interrupt_handlers[vector] = (iot_addr_t)intr->isr;
        hal_interrupt_data[vector] = (iot_addrword_t)intr->data;
    }
}

void iot_interrupt_detach( iot_irq_t interrupt )
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;
    uint32_t vector = intr->vector;

    if( hal_interrupt_handlers[vector] == (iot_addr_t)intr->isr ) {
        hal_interrupt_handlers[vector] = (iot_addr_t)hal_default_isr;
        hal_interrupt_data[vector] = 0;
    }
}

void IRAM_ATTR iot_interrupt_mask( iot_irq_t interrupt )
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;
    uint32_t vector = intr->vector;
    uint32_t cpu = intr->cpu;
    uint32_t old_ints;

    old_ints = cpu_disable_irq();
    intc_mask(cpu, vector);
    cpu_enable_irq(old_ints);

}

void IRAM_ATTR iot_interrupt_unmask( iot_irq_t interrupt )
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;
    uint32_t vector = intr->vector;
    uint32_t cpu = intr->cpu;
    uint32_t old_ints;

    old_ints = cpu_disable_irq();
    intc_unmask(cpu, vector);
    cpu_enable_irq(old_ints);
}

void iot_interrupt_acknowledge( iot_irq_t interrupt )
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;
    uint32_t vector = intr->vector;
    uint32_t cpu = intr->cpu;

    intc_ack(cpu, vector);
}

void iot_interrupt_configure( iot_irq_t interrupt, uint32_t level, uint32_t up)
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;
    uint32_t vector = intr->vector;
    uint32_t cpu = intr->cpu;

    intc_config( cpu, vector, level, up);
}

void iot_interrupt_priority( iot_irq_t interrupt, uint32_t priority )
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;
    uint32_t vector = intr->vector;
    uint32_t cpu = intr->cpu;

    intc_set_priority( cpu, vector, priority);
}

void iot_interrupt_set_cpu( iot_irq_t interrupt, uint32_t cpu )
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;

    intr->cpu = (uint8_t)cpu;
}

uint32_t iot_interrupt_get_cpu( iot_irq_t interrupt )
{
    iot_interrupt *intr = (iot_interrupt *)interrupt;

    return intr->cpu;
}

uint32_t iot_interrupt_init(uint32_t cpu)
{
    uint32_t i;
    intc_init(cpu);
    for( i = 0; i < HAL_VECTOR_COUNT; i++ ){
        hal_interrupt_handlers[i] = (iot_addr_t)hal_default_isr;
    }
    return 0;
}