3a109b1f00
Moving many of the functions from the old format of inline comments to the newer doxygen format. Change-Id: Ib0fe0d8627d7cd90219385a3ab627da8f9637d98 Signed-off-by: Dan Kalowsky <daniel.kalowsky@intel.com>
233 lines
6.9 KiB
C
233 lines
6.9 KiB
C
/*
|
|
* Copyright (c) 2013-2015, Wind River Systems, Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* @file
|
|
* @brief system module for variants with LOAPIC
|
|
*
|
|
* This module provides routines to initialize and support
|
|
* board-level hardware for the basic_atom configuration of
|
|
* ia32 platform.
|
|
*/
|
|
|
|
#include <misc/__assert.h>
|
|
#include "board.h"
|
|
#include <nanokernel.h>
|
|
#include <arch/cpu.h>
|
|
#include <drivers/ioapic.h>
|
|
#include <drivers/loapic.h>
|
|
|
|
/**
|
|
*
|
|
* @brief Allocate interrupt vector
|
|
*
|
|
* This routine is used by the x86's irq_connect(). It performs the following
|
|
* functions:
|
|
*
|
|
* a) Allocates a vector satisfying the requested priority. The utility
|
|
* routine _IntVecAlloc() provided by the nanokernel will be used to
|
|
* perform the the allocation since the local APIC prioritizes interrupts
|
|
* as assumed by _IntVecAlloc().
|
|
* b) Provides End of Interrupt (EOI) and Beginning of Interrupt (BOI) related
|
|
* information to be used when generating the interrupt stub code.
|
|
* c) If an interrupt vector can be allocated, and the <irq> argument is not
|
|
* equal to NANO_SOFT_IRQ, the IOAPIC redirection table (RED) or the
|
|
* LOAPIC local vector table (LVT) will be updated with the allocated
|
|
* interrupt vector.
|
|
*
|
|
* The board virtualizes IRQs as follows:
|
|
*
|
|
* - The first CONFIG_IOAPIC_NUM_RTES IRQs are provided by the IOAPIC
|
|
* - The remaining IRQs are provided by the LOAPIC.
|
|
*
|
|
* Thus, for example, if the IOAPIC supports 24 IRQs:
|
|
*
|
|
* - IRQ0 to IRQ23 map to IOAPIC IRQ0 to IRQ23
|
|
* - IRQ24 to IRQ29 map to LOAPIC LVT entries as follows:
|
|
*
|
|
* IRQ24 -> LOAPIC_TIMER
|
|
* IRQ25 -> LOAPIC_THERMAL
|
|
* IRQ26 -> LOAPIC_PMC
|
|
* IRQ27 -> LOAPIC_LINT0
|
|
* IRQ28 -> LOAPIC_LINT1
|
|
* IRQ29 -> LOAPIC_ERROR
|
|
*
|
|
* @param irq virtualized IRQ
|
|
* @param priority get vector from <priority> group
|
|
* @param boiRtn pointer to the BOI routine; NULL if none
|
|
* @param eoiRtn pointer to the EOI routine; NULL if none
|
|
* @param boiRtnParm the BOI routine parameter if any
|
|
* @param eoiRtnParm the EOI routine parameter if any
|
|
* @param boiParamRequired the BOI routine parameter req?
|
|
* @param eoiParamRequired the EOI routine parameter req?
|
|
*
|
|
* @return the allocated interrupt vector
|
|
*
|
|
* @internal
|
|
* For debug kernels, this routine will return -1 if there are no vectors
|
|
* remaining in the specified <priority> level, or if the <priority> or <irq>
|
|
* parameters are invalid.
|
|
* @endinternal
|
|
*/
|
|
int _SysIntVecAlloc(unsigned int irq, unsigned int priority,
|
|
NANO_EOI_GET_FUNC * boiRtn, NANO_EOI_GET_FUNC * eoiRtn,
|
|
void **boiRtnParm, void **eoiRtnParm,
|
|
unsigned char *boiParamRequired, unsigned char *eoiParamRequired)
|
|
{
|
|
int vector;
|
|
|
|
ARG_UNUSED(boiRtnParm);
|
|
ARG_UNUSED(boiParamRequired);
|
|
|
|
#if defined(CONFIG_LOAPIC_DEBUG)
|
|
if ((priority > 15) ||
|
|
((irq > (CONFIG_IOAPIC_NUM_RTES + 5)) && (irq != NANO_SOFT_IRQ)))
|
|
return -1;
|
|
#endif
|
|
|
|
/*
|
|
* Use the nanokernel utility function _IntVecAlloc(). A value of
|
|
* -1 will be returned if there are no free vectors in the requested
|
|
* priority.
|
|
*/
|
|
|
|
vector = _IntVecAlloc(priority);
|
|
__ASSERT(vector != -1, "No free vectors in the requested priority");
|
|
|
|
/*
|
|
* Set up the appropriate interrupt controller to generate the allocated
|
|
* interrupt vector for the specified IRQ. Also, provide the required
|
|
* EOI and BOI related information for the interrupt stub code
|
|
* generation step.
|
|
*
|
|
* For software interrupts (NANO_SOFT_IRQ), skip the interrupt
|
|
* controller programming step, and indicate that a BOI and EOI handler
|
|
* is not required.
|
|
*
|
|
* Skip both steps if a vector could not be allocated.
|
|
*/
|
|
|
|
*boiRtn = (NANO_EOI_GET_FUNC)NULL; /* a BOI handler is never required */
|
|
*eoiRtn = (NANO_EOI_GET_FUNC)NULL; /* assume NANO_SOFT_IRQ */
|
|
|
|
#if defined(CONFIG_LOAPIC_DEBUG)
|
|
if ((vector != -1) && (irq != NANO_SOFT_IRQ))
|
|
#else
|
|
if (irq != NANO_SOFT_IRQ)
|
|
#endif
|
|
{
|
|
if (irq < CONFIG_IOAPIC_NUM_RTES) {
|
|
_ioapic_int_vec_set(irq, vector);
|
|
|
|
/*
|
|
* query IOAPIC driver to obtain EOI handler information
|
|
* for the interrupt vector that was just assigned to
|
|
* the specified IRQ
|
|
*/
|
|
|
|
*eoiRtn = (NANO_EOI_GET_FUNC)_ioapic_eoi_get(
|
|
irq, (char *)eoiParamRequired, eoiRtnParm);
|
|
} else {
|
|
_loapic_int_vec_set(irq - CONFIG_IOAPIC_NUM_RTES, vector);
|
|
|
|
/* specify that the EOI handler in loApicIntr.c driver
|
|
* be invoked */
|
|
|
|
*eoiRtn = (NANO_EOI_GET_FUNC)_loapic_eoi;
|
|
*eoiParamRequired = 0;
|
|
}
|
|
}
|
|
|
|
return vector;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @brief Program interrupt controller
|
|
*
|
|
* This routine programs the interrupt controller with the given vector
|
|
* based on the given IRQ parameter.
|
|
*
|
|
* Drivers call this routine instead of irq_connect() when interrupts are
|
|
* configured statically.
|
|
*
|
|
* The Clanton board virtualizes IRQs as follows:
|
|
*
|
|
* - The first CONFIG_IOAPIC_NUM_RTES IRQs are provided by the IOAPIC so the
|
|
* IOAPIC is programmed for these IRQs
|
|
* - The remaining IRQs are provided by the LOAPIC and hence the LOAPIC is
|
|
* programmed.
|
|
*
|
|
* @param vector the vector number
|
|
* @param irq the virtualized IRQ
|
|
*
|
|
*/
|
|
void _SysIntVecProgram(unsigned int vector, unsigned int irq)
|
|
{
|
|
|
|
if (irq < CONFIG_IOAPIC_NUM_RTES) {
|
|
_ioapic_int_vec_set(irq, vector);
|
|
} else {
|
|
_loapic_int_vec_set(irq - CONFIG_IOAPIC_NUM_RTES, vector);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @brief Enable an individual interrupt (IRQ)
|
|
*
|
|
* The public interface for enabling/disabling a specific IRQ for the IA-32
|
|
* architecture is defined as follows in include/arch/x86/arch.h
|
|
*
|
|
* extern void irq_enable (unsigned int irq);
|
|
* extern void irq_disable (unsigned int irq);
|
|
*
|
|
* The irq_enable() routine is provided by the interrupt controller driver due
|
|
* to the IRQ virtualization that is performed by this platform. See the
|
|
* comments in _SysIntVecAlloc() for more information regarding IRQ
|
|
* virtualization.
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void irq_enable(unsigned int irq)
|
|
{
|
|
if (irq < CONFIG_IOAPIC_NUM_RTES) {
|
|
_ioapic_irq_enable(irq);
|
|
} else {
|
|
_loapic_irq_enable(irq - CONFIG_IOAPIC_NUM_RTES);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @brief Disable an individual interrupt (IRQ)
|
|
*
|
|
* The irq_disable() routine is provided by the interrupt controller driver due
|
|
* to the IRQ virtualization that is performed by this platform. See the
|
|
* comments in _SysIntVecAlloc() for more information regarding IRQ
|
|
* virtualization.
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void irq_disable(unsigned int irq)
|
|
{
|
|
if (irq < CONFIG_IOAPIC_NUM_RTES) {
|
|
_ioapic_irq_disable(irq);
|
|
} else {
|
|
_loapic_irq_disable(irq - CONFIG_IOAPIC_NUM_RTES);
|
|
}
|
|
}
|