/* Handle a platform-reserved IRQ. */
void handleReservedIRQ(irq_t irq)
{
/* We shouldn't be receiving any reserved IRQs anyway. */
maskInterrupt(true, irq);
return;
}
/**
DONT_TRANSLATE
*/
BOOT_CODE void
initTimer(void)
{
int timeout;
disableWatchdog();
enableTimers();
timer->cfg = TIOCP_CFG_SOFTRESET;
for (timeout = 10000; (timer->cfg & TIOCP_CFG_SOFTRESET) && timeout > 0; timeout--)
;
if (!timeout) {
printf("init timer failed\n");
return;
}
maskInterrupt(/*disable*/ true, DMTIMER0_IRQ);
/* Set the reload value */
timer->tldr = 0xFFFFFFFFUL - TIMER_INTERVAL_TICKS;
/* Enables interrupt on overflow */
timer->tier = TIER_OVERFLOWENABLE;
/* Clear the read register */
timer->tcrr = 0xFFFFFFFFUL - TIMER_INTERVAL_TICKS;
/* Set autoreload and start the timer */
timer->tclr = TCLR_AUTORELOAD | TCLR_STARTTIMER;
}
BOOT_CODE static bool_t try_init_kernel_secondary_core(void)
{
/* need to first wait until some kernel init has been done */
while (!node_boot_lock);
/* Perform cpu init */
init_cpu();
/* Enable per-CPU timer interrupts */
maskInterrupt(false, KERNEL_TIMER_IRQ);
NODE_LOCK_SYS;
ksNumCPUs++;
init_core_state(SchedulerAction_ResumeCurrentThread);
return true;
}
/**
DONT_TRANSLATE
*/
BOOT_CODE void
initTimer(void)
{
timer->cfg = TIOCP_CFG_SOFTRESET;
while (!timer->tistat);
maskInterrupt(/*disable*/ true, GPT11_IRQ);
/* Set the reload value */
timer->tldr = 0xFFFFFFFFUL - TIMER_INTERVAL_TICKS;
/* Enables interrupt on overflow */
timer->tier = TIER_OVERFLOWENABLE;
/* Clear the read register */
timer->tcrr = 0xFFFFFFFFUL - TIMER_INTERVAL_TICKS;
/* Set autoreload and start the timer */
timer->tclr = TCLR_AUTORELOAD | TCLR_STARTTIMER;
}
void
setIRQState(irq_state_t irqState, irq_t irq)
{
intStateIRQTable[irq] = irqState;
maskInterrupt(irqState == IRQInactive, irq);
}
void
handleInterrupt(irq_t irq)
{
if (unlikely(irq > maxIRQ)) {
/* mask, ack and pretend it didn't happen. We assume that because
* the interrupt controller for the platform returned this IRQ that
* it is safe to use in mask and ack operations, even though it is
* above the claimed maxIRQ. i.e. we're assuming maxIRQ is wrong */
printf("Received IRQ %d, which is above the platforms maxIRQ of %d\n", (int)irq, (int)maxIRQ);
maskInterrupt(true, irq);
ackInterrupt(irq);
return;
}
switch (intStateIRQTable[irq]) {
case IRQSignal: {
cap_t cap;
cap = intStateIRQNode[irq].cap;
if (cap_get_capType(cap) == cap_notification_cap &&
cap_notification_cap_get_capNtfnCanSend(cap)) {
sendSignal(NTFN_PTR(cap_notification_cap_get_capNtfnPtr(cap)),
cap_notification_cap_get_capNtfnBadge(cap));
} else {
#ifdef CONFIG_IRQ_REPORTING
printf("Undelivered IRQ: %d\n", (int)irq);
#endif
}
maskInterrupt(true, irq);
break;
}
case IRQTimer:
timerTick();
resetTimer();
break;
case IRQReserved:
#ifdef CONFIG_IRQ_REPORTING
printf("Received reserved IRQ: %d", (int)irq);
#endif
handleReservedIRQ(irq);
break;
case IRQInactive:
/*
* This case shouldn't happen anyway unless the hardware or
* platform code is broken. Hopefully masking it again should make
* the interrupt go away.
*/
maskInterrupt(true, irq);
#ifdef CONFIG_IRQ_REPORTING
printf("Received disabled IRQ: %d\n", (int)irq);
#endif
break;
default:
/* No corresponding haskell error */
fail("Invalid IRQ state");
}
ackInterrupt(irq);
}
void
invokeIRQHandler_AckIRQ(irq_t irq)
{
maskInterrupt(false, irq);
}
