148 lines
4.2 KiB
C
148 lines
4.2 KiB
C
/*
|
|
* Copyright (c) 2022 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include <zephyr/device.h>
|
|
#include <zephyr/devicetree.h>
|
|
#include <zephyr/irq_nextlevel.h>
|
|
#ifdef CONFIG_DYNAMIC_INTERRUPTS
|
|
#include <zephyr/sw_isr_table.h>
|
|
#endif
|
|
#include <zephyr/drivers/interrupt_controller/dw_ace_v1x.h>
|
|
#include <soc.h>
|
|
#include <ace_v1x-regs.h>
|
|
|
|
/* MTL device interrupts are all packed into a single line on Xtensa's
|
|
* architectural IRQ 4 (see below), run by a Designware interrupt
|
|
* controller with 28 lines instantiated. They get numbered
|
|
* immediately after the Xtensa interrupt space in the numbering
|
|
* (i.e. interrupts 0-31 are Xtensa IRQs, 32 represents DW input 0,
|
|
* etc...).
|
|
*
|
|
* That IRQ 4 indeed has an interrupt type of "EXTERN_LEVEL" and an
|
|
* interrupt level of 2. The CPU has a level 1 external interrupt on
|
|
* IRQ 1 and a level 3 on IRQ 6, but nothing seems wired there. Note
|
|
* that this level 2 ISR is also shared with the CCOUNT timer on IRQ3.
|
|
* This interrupt is a very busy place!
|
|
*
|
|
* But, because there can never be a situation where all interrupts on
|
|
* the Synopsys controller are disabled (such a system would halt
|
|
* forever if it reached idle!), we at least can take advantage to
|
|
* implement a simplified masking architecture. Xtensa INTENABLE
|
|
* always has the line active, and we do all masking of external
|
|
* interrupts on the single controller.
|
|
*
|
|
* Finally: note that there is an extra layer of masking on MTL. The
|
|
* MTL_DINT registers provide separately maskable interrupt delivery
|
|
* for each core, and with some devices for different internal
|
|
* interrupt sources. Responsibility for these mask bits is left with
|
|
* the driver.
|
|
*
|
|
* Thus, the masking architecture picked here is:
|
|
*
|
|
* + Drivers manage MTL_DINT themselves, as there are device-specific
|
|
* mask indexes that only the driver can interpret. If
|
|
* core-asymmetric interrupt routing needs to happen, it happens
|
|
* here.
|
|
*
|
|
* + The DW layer is en/disabled uniformly across all cores. This is
|
|
* the layer toggled by arch_irq_en/disable().
|
|
*
|
|
* + Index 4 in the INTENABLE SR is set at core startup and stays
|
|
* enabled always.
|
|
*/
|
|
|
|
#define IS_DW(irq) ((irq) >= XCHAL_NUM_INTERRUPTS)
|
|
|
|
void dw_ace_v1x_irq_enable(const struct device *dev, uint32_t irq)
|
|
{
|
|
ARG_UNUSED(dev);
|
|
|
|
if (IS_DW(irq)) {
|
|
for (int i = 0; i < CONFIG_MP_NUM_CPUS; i++) {
|
|
ACE_INTC[i].inten |= BIT(MTL_IRQ_FROM_ZEPHYR(irq));
|
|
}
|
|
} else {
|
|
z_xtensa_irq_enable(irq);
|
|
}
|
|
}
|
|
|
|
void dw_ace_v1x_irq_disable(const struct device *dev, uint32_t irq)
|
|
{
|
|
ARG_UNUSED(dev);
|
|
|
|
if (IS_DW(irq)) {
|
|
for (int i = 0; i < CONFIG_MP_NUM_CPUS; i++) {
|
|
ACE_INTC[i].inten &= ~BIT(MTL_IRQ_FROM_ZEPHYR(irq));
|
|
}
|
|
} else {
|
|
z_xtensa_irq_disable(irq);
|
|
}
|
|
}
|
|
|
|
int dw_ace_v1x_irq_is_enabled(const struct device *dev, unsigned int irq)
|
|
{
|
|
ARG_UNUSED(dev);
|
|
|
|
if (IS_DW(irq)) {
|
|
return ACE_INTC[0].inten & BIT(MTL_IRQ_FROM_ZEPHYR(irq));
|
|
} else {
|
|
return z_xtensa_irq_is_enabled(irq);
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_DYNAMIC_INTERRUPTS
|
|
int dw_ace_v1x_irq_connect_dynamic(const struct device *dev, unsigned int irq,
|
|
unsigned int priority,
|
|
void (*routine)(const void *parameter),
|
|
const void *parameter, uint32_t flags)
|
|
{
|
|
/* Simple architecture means that the Zephyr irq number and
|
|
* the index into the ISR table are identical.
|
|
*/
|
|
ARG_UNUSED(dev);
|
|
ARG_UNUSED(flags);
|
|
ARG_UNUSED(priority);
|
|
z_isr_install(irq, routine, parameter);
|
|
return irq;
|
|
}
|
|
#endif
|
|
|
|
static void dwint_isr(const void *arg)
|
|
{
|
|
uint32_t fs = ACE_INTC[arch_proc_id()].finalstatus;
|
|
|
|
while (fs) {
|
|
uint32_t bit = find_lsb_set(fs) - 1;
|
|
struct _isr_table_entry *ent = &_sw_isr_table[MTL_IRQ_TO_ZEPHYR(bit)];
|
|
|
|
fs &= ~BIT(bit);
|
|
ent->isr(ent->arg);
|
|
}
|
|
}
|
|
|
|
static int dw_ace_v1x_init(const struct device *dev)
|
|
{
|
|
ARG_UNUSED(dev);
|
|
|
|
IRQ_CONNECT(ACE_INTC_IRQ, 0, dwint_isr, 0, 0);
|
|
z_xtensa_irq_enable(ACE_INTC_IRQ);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct dw_ace_v1_ictl_driver_api dw_ictl_ace_v1x_apis = {
|
|
.intr_enable = dw_ace_v1x_irq_enable,
|
|
.intr_disable = dw_ace_v1x_irq_disable,
|
|
.intr_is_enabled = dw_ace_v1x_irq_is_enabled,
|
|
#ifdef CONFIG_DYNAMIC_INTERRUPTS
|
|
.intr_connect_dynamic = dw_ace_v1x_irq_connect_dynamic,
|
|
#endif
|
|
};
|
|
|
|
DEVICE_DT_DEFINE(DT_NODELABEL(ace_intc), dw_ace_v1x_init, NULL, NULL, NULL,
|
|
PRE_KERNEL_1, CONFIG_INTC_INIT_PRIORITY,
|
|
&dw_ictl_ace_v1x_apis);
|