/*
* ======== Swi_run ========
* Set up and run Swi.
* Enter with Hwi's disabled
* Calls Swi function with interrupts enabled
* Exits with Hwi's enabled
* When no Swis are running, curQ is NULL
*/
Void Swi_run(Swi_Object *swi)
{
UInt saved_curTrigger = Swi_module->curTrigger;
Swi_Object *saved_curSwi = Swi_module->curSwi;
Queue_Handle saved_curQ = Swi_module->curQ;
BIOS_ThreadType prevThreadType;
#ifndef ti_sysbios_knl_Swi_DISABLE_ALL_HOOKS
Int i;
#endif
Swi_module->curQ = swi->readyQ;
Swi_module->curSwi = swi;
Swi_module->curTrigger = swi->trigger;
swi->trigger = swi->initTrigger;
swi->posted = FALSE;
Swi_module->locked = FALSE; /* unlock the scheduler while */
/* Swi is running */
/* set thread type to Swi */
prevThreadType = BIOS_setThreadType(BIOS_ThreadType_Swi);
Hwi_enable();
#ifndef ti_sysbios_knl_Swi_DISABLE_ALL_HOOKS
for (i = 0; i < Swi_hooks.length; i++) {
if (Swi_hooks.elem[i].beginFxn != NULL) {
Swi_hooks.elem[i].beginFxn(swi);
}
}
#endif
Log_write3(Swi_LM_begin, (UArg)swi, (UArg)swi->fxn, (UArg)prevThreadType);
(swi->fxn)(swi->arg0, swi->arg1);
Log_write1(Swi_LD_end, (UArg)swi);
#ifndef ti_sysbios_knl_Swi_DISABLE_ALL_HOOKS
for (i = 0; i < Swi_hooks.length; i++) {
if (Swi_hooks.elem[i].endFxn != NULL) {
Swi_hooks.elem[i].endFxn(swi);
}
}
#endif
Hwi_disable();
/* restore thread type */
BIOS_setThreadType(prevThreadType);
Swi_module->locked = TRUE; /* relock the scheduler */
Swi_module->curQ = saved_curQ;
Swi_module->curSwi = saved_curSwi;
Swi_module->curTrigger = saved_curTrigger;
}
/*
* ======== Task_startup ========
*/
Void Task_startup()
{
Queue_Handle maxQ;
Task_Object *prevTask;
Task_Struct dummyTask;
Int i;
Hwi_disable(); /* re-enabled in Task_enter of first task */
/* Use dummyTask as initial task to swap from */
prevTask = Task_handle(&dummyTask);
/* stall until a task is ready */
while (Task_module->curSet == 0) {
Task_allBlockedFunc();
}
/* Determine current max ready Task priority */
maxQ = (Queue_Handle)((UInt8 *)(Task_module->readyQ) +
(UInt)(Intrinsics_maxbit(Task_module->curSet)*(2*sizeof(Ptr))));
Task_module->curQ = maxQ;
Task_module->curTask = Queue_head(maxQ);
/* we've done the scheduler's work */
Task_module->workFlag = 0;
/* Signal that we are entering task thread mode */
BIOS_setThreadType(BIOS_ThreadType_Task);
/* should be safe to enable intrs here */
Hwi_enable();
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
/* Run switch hooks for first real Task */
for (i = 0; i < Task_hooks.length; i++) {
if (Task_hooks.elem[i].switchFxn != NULL) {
Task_hooks.elem[i].switchFxn(NULL, Task_module->curTask);
}
}
#endif
Log_write4(Task_LM_switch, (UArg)0, (UArg)0,
(UArg)Task_module->curTask,
(UArg)Task_module->curTask->fxn);
/* must leave this function with ints disabled */
Hwi_disable();
/* inform dispatcher that we're running on task stack */
Hwi_switchFromBootStack();
/* start first task by way of enter() */
Task_SupportProxy_swap((Ptr)&prevTask->context,
(Ptr)&Task_module->curTask->context);
}
/*
* ======== BIOS_exit ========
*/
Void BIOS_exit(Int stat)
{
/* remove the RTS lock */
BIOS_removeRTSLock();
/* force thread type to 'Main' */
BIOS_setThreadType(BIOS_ThreadType_Main);
System_exit(stat);
}
/*
* ======== BIOS_errorRaiseHook ========
*/
Void BIOS_errorRaiseHook(Error_Block *eb)
{
/*
* If this is an Assert thread, defang Gate threadtype check
*/
if (eb->id == xdc_runtime_Assert_E_assertFailed) {
/* remove the RTS lock */
BIOS_removeRTSLock();
/* force thread type to 'Main' */
BIOS_setThreadType(BIOS_ThreadType_Main);
}
/* Call the default/user's Error.raiseHook */
BIOS_installedErrorHook(eb);
}
/*
* ======== Exception_excHandler ========
*/
Void Exception_excHandler(UInt *excStack, UInt pc)
{
Exception_ExcContext excContext, *excContextp;
SizeT stackSize = 0;
UInt8 *stack = NULL;
UInt coreId = 0;
#if (ti_sysbios_BIOS_smpEnabled__D)
coreId = Core_getId();
#endif
#if defined(ti_sysbios_family_arm_a8_intcps_Hwi_enableAsidTagging__D) && \
(ti_sysbios_family_arm_a8_intcps_Hwi_enableAsidTagging__D)
Mmu_switchContext(0, Mmu_getMmuTableAddr());
#elif defined(ti_sysbios_family_arm_gic_Hwi_enableAsidTagging__D) && \
(ti_sysbios_family_arm_gic_Hwi_enableAsidTagging__D)
Mmu_switchContext(0, Mmu_getFirstLevelTableAddr());
#endif
Exception_module->excActive[coreId] = TRUE;
if (Exception_module->excContext[coreId] == NULL) {
Exception_module->excContext[coreId] = &excContext;
excContextp = &excContext;
}
else {
excContextp = Exception_module->excContext[coreId];
}
/* copy registers from stack to excContext */
excContextp->r0 = (Ptr)excStack[8]; /* r0 */
excContextp->r1 = (Ptr)excStack[9]; /* r1 */
excContextp->r2 = (Ptr)excStack[10]; /* r2 */
excContextp->r3 = (Ptr)excStack[11]; /* r3 */
excContextp->r4 = (Ptr)excStack[12]; /* r4 */
excContextp->r5 = (Ptr)excStack[13]; /* r5 */
excContextp->r6 = (Ptr)excStack[14]; /* r6 */
excContextp->r7 = (Ptr)excStack[15]; /* r7 */
excContextp->r8 = (Ptr)excStack[16]; /* r8 */
excContextp->r9 = (Ptr)excStack[17]; /* r9 */
excContextp->r10 = (Ptr)excStack[18]; /* r10 */
excContextp->r11 = (Ptr)excStack[19]; /* r11 */
excContextp->r12 = (Ptr)excStack[20]; /* r12 */
excContextp->ifar = (Ptr)excStack[4]; /* IFAR */
excContextp->dfar = (Ptr)excStack[5]; /* DFAR */
excContextp->ifsr = (Ptr)excStack[6]; /* IFSR */
excContextp->dfsr = (Ptr)excStack[7]; /* DFSR */
excContextp->sp = (Ptr)excStack[1]; /* sp */
excContextp->lr = (Ptr)excStack[2]; /* lr */
excContextp->pc = (Ptr)pc; /* pc */
excContextp->psr = (Ptr)excStack[0]; /* psr */
excContextp->type = (Exception_Type)(excStack[3] &0x1f); /* psr */
excContextp->threadType = BIOS_getThreadType();
switch (excContextp->threadType) {
case BIOS_ThreadType_Task: {
if (BIOS_taskEnabled == TRUE) {
excContextp->threadHandle = (Ptr)Task_self();
stack = (UInt8 *)(Task_self())->stack;
stackSize = (Task_self())->stackSize;
}
break;
}
case BIOS_ThreadType_Swi: {
if (BIOS_swiEnabled == TRUE) {
excContextp->threadHandle = (Ptr)Swi_self();
stack = STACK_BASE;
stackSize = (SizeT)(&__STACK_SIZE);
}
break;
}
case BIOS_ThreadType_Hwi: {
excContextp->threadHandle = NULL;
stack = STACK_BASE;
stackSize = (SizeT)(&__STACK_SIZE);
break;
}
case BIOS_ThreadType_Main: {
excContextp->threadHandle = NULL;
stack = STACK_BASE;
stackSize = (SizeT)(&__STACK_SIZE);
break;
}
}
excContextp->threadStackSize = stackSize;
excContextp->threadStack = (Ptr)stack;
/* copy thread's stack contents if user has provided a buffer */
if (Exception_module->excStackBuffers[coreId] != NULL) {
UInt8 *from, *to;
from = stack;
to = (UInt8 *)Exception_module->excStackBuffers[coreId];
while (stackSize--) {
*to++ = *from++;
}
}
/* Force MAIN threadtype So we can safely call System_printf */
BIOS_setThreadType(BIOS_ThreadType_Main);
if (Exception_enableDecode == TRUE) {
Exception_excDumpContext(pc);
}
/* Call user's exception hook */
if (Exception_excHookFuncs[coreId] != NULL) {
Exception_excHookFuncs[coreId](excContextp);
}
/* raise a corresponding Error */
switch(excContextp->type) {
case Exception_Type_Supervisor:
Error_raise(0, Exception_E_swi, pc, excStack[2]);
break;
case Exception_Type_PreAbort:
Error_raise(0, Exception_E_prefetchAbort, pc, excStack[2]);
break;
case Exception_Type_DataAbort:
Error_raise(0, Exception_E_dataAbort, pc, excStack[2]);
break;
case Exception_Type_UndefInst:
Error_raise(0, Exception_E_undefinedInstruction, pc, excStack[2]);
break;
}
}
/*
* ======== Exception_excHandler ========
*/
Void Exception_excHandler(UInt *excStack, UInt pc)
{
Exception_ExcContext excContext, *excContextp;
SizeT stackSize = 0;
UInt8 *stack = NULL;
Exception_module->excActive = TRUE;
if (Exception_module->excContext == NULL) {
Exception_module->excContext = &excContext;
excContextp = &excContext;
}
else {
excContextp = Exception_module->excContext;
}
/* copy registers from stack to excContext */
excContextp->r0 = (Ptr)excStack[4]; /* r0 */
excContextp->r1 = (Ptr)excStack[5]; /* r1 */
excContextp->r2 = (Ptr)excStack[6]; /* r2 */
excContextp->r3 = (Ptr)excStack[7]; /* r3 */
excContextp->r4 = (Ptr)excStack[8]; /* r4 */
excContextp->r5 = (Ptr)excStack[9]; /* r5 */
excContextp->r6 = (Ptr)excStack[10]; /* r6 */
excContextp->r7 = (Ptr)excStack[11]; /* r7 */
excContextp->r8 = (Ptr)excStack[12]; /* r8 */
excContextp->r9 = (Ptr)excStack[13]; /* r9 */
excContextp->r10 = (Ptr)excStack[14]; /* r10 */
excContextp->r11 = (Ptr)excStack[15]; /* r11 */
excContextp->r12 = (Ptr)excStack[16]; /* r12 */
excContextp->sp = (Ptr)excStack[1]; /* sp */
excContextp->lr = (Ptr)excStack[2]; /* lr */
excContextp->pc = (Ptr)pc; /* pc */
excContextp->psr = (Ptr)excStack[0]; /* psr */
excContextp->type = (Exception_Type)(excStack[3] &0x1f); /* psr */
excContextp->threadType = BIOS_getThreadType();
switch (excContextp->threadType) {
case BIOS_ThreadType_Task: {
if (BIOS_taskEnabled == TRUE) {
excContextp->threadHandle = (Ptr)Task_self();
stack = (UInt8 *)(Task_self())->stack;
stackSize = (Task_self())->stackSize;
}
break;
}
case BIOS_ThreadType_Swi: {
if (BIOS_swiEnabled == TRUE) {
excContextp->threadHandle = (Ptr)Swi_self();
stack = STACK_BASE;
stackSize = (SizeT)(&__STACK_SIZE);
}
break;
}
case BIOS_ThreadType_Hwi: {
excContextp->threadHandle = NULL;
stack = STACK_BASE;
stackSize = (SizeT)(&__STACK_SIZE);
break;
}
case BIOS_ThreadType_Main: {
excContextp->threadHandle = NULL;
stack = STACK_BASE;
stackSize = (SizeT)(&__STACK_SIZE);
break;
}
}
excContextp->threadStackSize = stackSize;
excContextp->threadStack = (Ptr)stack;
/* copy thread's stack contents if user has provided a buffer */
if (Exception_module->excStackBuffer != NULL) {
UInt8 *from, *to;
from = stack;
to = (UInt8 *)Exception_module->excStackBuffer;
while (stackSize--) {
*to++ = *from++;
}
}
/* Force MAIN threadtype So we can safely call System_printf */
BIOS_setThreadType(BIOS_ThreadType_Main);
if (Exception_enableDecode == TRUE) {
Exception_excDumpContext(pc);
}
/* Call user's exception hook */
if (Exception_excHookFunc != NULL) {
Exception_excHookFunc(excContextp);
}
/* raise a corresponding Error */
switch(excContextp->type) {
case Exception_Type_Supervisor:
Error_raise(0, Exception_E_swi, pc, excStack[2]);
break;
case Exception_Type_PreAbort:
Error_raise(0, Exception_E_prefetchAbort, pc, excStack[2]);
break;
case Exception_Type_DataAbort:
Error_raise(0, Exception_E_dataAbort, pc, excStack[2]);
break;
case Exception_Type_UndefInst:
Error_raise(0, Exception_E_undefinedInstruction, pc, excStack[2]);
break;
}
}
/*
* ======== Hwi_dispatchIRQC ========
* Configurable IRQ interrupt dispatcher.
*/
Void Hwi_dispatchIRQC(Hwi_Irp irp)
{
/*
* Enough room is reserved above the isr stack to handle
* as many as 16 32-bit stack resident local variables.
* If the dispatcher requires more than this, you must
* handle this in Hwi_Module_startup().
*/
Hwi_Object *hwi;
BIOS_ThreadType prevThreadType;
UInt intNum;
Char *oldTaskSP;
Int tskKey;
Int swiKey;
Int i;
/* save irp somewhere that survives the stack switch */
Hwi_module->irp = irp;
if (Hwi_dispatcherTaskSupport) {
tskKey = TASK_DISABLE();
/*
* If this is a non-nested interrupt,
* tskkey is saved on the task stack.
* It must not be referenced again until
* switching back to the task stack!!!!
* All other local variables will be
* on the isr stack.
*/
}
/*
* Switch to Hwi stack if not already on it.
* This step, and the corresponding switch back to the task
* stack are performed outside the "if (Hwi_dispatcherTaskSupport)"
* conditionals because sometimes the generated code placed a copy
* of Hwi_dispatcherTaskSupport on the task stack for use below.
*/
oldTaskSP = Hwi_switchToIsrStack();
/*
* all references to local variables beyond this point
* will be on the isr stack
*/
if (Hwi_dispatcherSwiSupport) {
swiKey = SWI_DISABLE();
}
/* set thread type to Hwi */
prevThreadType = BIOS_setThreadType(BIOS_ThreadType_Hwi);
/* Porcess ALL pending and enabled interrupts */
do {
intNum = Hwi_l1Intc.SIR_IRQ; /* get current L1 int num */
if (intNum == 0) { /* is from L2? */
intNum = Hwi_l2Intc.SIR_IRQ; /* get current L2 int num */
intNum += 32; /* force to linear index */
}
hwi = Hwi_module->dispatchTable[intNum];
hwi->irp = Hwi_module->irp;
#ifndef ti_sysbios_hal_Hwi_DISABLE_ALL_HOOKS
/* call the begin hooks */
for (i = 0; i < Hwi_hooks.length; i++) {
if (Hwi_hooks.elem[i].beginFxn != NULL) {
Hwi_hooks.elem[i].beginFxn((IHwi_Handle)hwi);
}
}
#endif
Log_write5(Hwi_LM_begin, (IArg)hwi, (IArg)hwi->fxn,
(IArg)prevThreadType, (IArg)intNum, hwi->irp);
(hwi->fxn)(hwi->arg);
Hwi_disable();
Log_write1(Hwi_LD_end, (IArg)hwi);
#ifndef ti_sysbios_hal_Hwi_DISABLE_ALL_HOOKS
/* call the end hooks */
for (i = 0; i < Hwi_hooks.length; i++) {
if (Hwi_hooks.elem[i].endFxn != NULL) {
Hwi_hooks.elem[i].endFxn((IHwi_Handle)hwi);
}
}
#endif
if (intNum > 31) { /* is from L2? */
Hwi_l2Intc.CONTROL = L2_NEW_IRQ_AGR;/* force NEW_IRQ_AGR */
}
Hwi_l1Intc.CONTROL = L1_NEW_IRQ_AGR; /* force NEW_IRQ_AGR */
}
/* loop thru all active and enabled IRQ ints */
while (Hwi_l1Intc.ITR & ~Hwi_l1Intc.MIR & Hwi_module->irq0Mask);
/* Run Swi scheduler */
if (Hwi_dispatcherSwiSupport) {
SWI_RESTORE(swiKey);
}
/* restore thread type */
BIOS_setThreadType(prevThreadType);
/*
* Switch back to Task stack if at bottom of Hwi stack
* While it seems that this step should be placed in the
* "if (Hwi_dispatcherTaskSupport)" conditional below,
* some code generators placed a copy of the Hwi_dispatcherTaskSupport
* constant on the task stack (see above comment), which would
* make the test below bogus as it would be being performed on
* on the ISR stack...
*/
Hwi_switchToTaskStack(oldTaskSP);
/* Run Task scheduler */
if (Hwi_dispatcherTaskSupport) {
/* tskKey fetched from task stack if this is a non-nested interrupt */
TASK_RESTORE(tskKey); /* returns with ints disabled */
}
}
/*
* ======== Hwi_dispatchIRQC ========
* Configurable IRQ interrupt dispatcher.
*/
Void Hwi_dispatchIRQC()
{
/*
* Enough room is reserved above the isr stack to handle
* as many as 16 32-bit stack resident local variables.
* If the dispatcher requires more than this, you must
* handle this in Hwi_Module_startup().
*/
Hwi_Object *hwi;
BIOS_ThreadType prevThreadType;
Int intNum;
Char *oldTaskSP;
Int tskKey;
Int swiKey;
Int i;
if (Hwi_dispatcherTaskSupport) {
tskKey = TASK_DISABLE();
/*
* If this is a non-nested interrupt,
* tskkey is saved on the task stack.
* It must not be referenced again until
* switching back to the task stack!!!!
* All other local variables will be
* on the isr stack.
*/
}
/*
* Switch to Hwi stack if not already on it.
* This step, and the corresponding switch back to the task
* stack are performed outside the "if (Hwi_dispatcherTaskSupport)"
* conditionals because sometimes the generated code placed a copy
* of Hwi_dispatcherTaskSupport on the task stack for use below.
*/
oldTaskSP = Hwi_switchToIsrStack();
/*
* all references to local variables beyond this point
* will be on the isr stack
*/
if (Hwi_dispatcherSwiSupport) {
swiKey = SWI_DISABLE();
}
/* set thread type to Hwi */
prevThreadType = BIOS_setThreadType(BIOS_ThreadType_Hwi);
/* read interrupt index */
intNum = Hwi_cpIntc.HIPIR[1];
/* disable host interrupt 1 (IRQ) */
Hwi_cpIntc.HIDISR = 1;
hwi = Hwi_module->dispatchTable[intNum];
hwi->irp = Hwi_module->irp;
#ifndef ti_sysbios_hal_Hwi_DISABLE_ALL_HOOKS
/* call the begin hooks */
for (i = 0; i < Hwi_hooks.length; i++) {
if (Hwi_hooks.elem[i].beginFxn != NULL) {
Hwi_hooks.elem[i].beginFxn((IHwi_Handle)hwi);
}
}
#endif
Log_write5(Hwi_LM_begin, (IArg)hwi, (IArg)hwi->fxn,
(IArg)prevThreadType, (IArg)intNum, hwi->irp);
/* call the user's isr */
if (Hwi_dispatcherAutoNestingSupport) {
(hwi->handler)(hwi, intNum);
}
else {
/* clear the interrupt status for this int */
Hwi_cpIntc.SICR = intNum;
(hwi->fxn)(hwi->arg);
/* re-enable IRQ */
Hwi_cpIntc.HIEISR = 1;
}
Log_write1(Hwi_LD_end, (IArg)hwi);
#ifndef ti_sysbios_hal_Hwi_DISABLE_ALL_HOOKS
/* call the end hooks */
for (i = 0; i < Hwi_hooks.length; i++) {
if (Hwi_hooks.elem[i].endFxn != NULL) {
Hwi_hooks.elem[i].endFxn((IHwi_Handle)hwi);
}
}
#endif
/* Run Swi scheduler */
if (Hwi_dispatcherSwiSupport) {
SWI_RESTORE(swiKey);
}
/* restore thread type */
BIOS_setThreadType(prevThreadType);
/*
* Switch back to Task stack if at bottom of Hwi stack
* While it seems that this step should be placed in the
* "if (Hwi_dispatcherTaskSupport)" conditional below,
* some code generators placed a copy of the Hwi_dispatcherTaskSupport
* constant on the task stack (see above comment), which would
* make the test below bogus as it would be being performed on
* on the ISR stack...
*/
Hwi_switchToTaskStack(oldTaskSP);
/* Run Task scheduler */
if (Hwi_dispatcherTaskSupport) {
/* tskKey fetched from task stack if this is a non-nested interrupt */
TASK_RESTORE(tskKey); /* returns with ints disabled */
}
}
/*
* ======== Hwi_dispatchIRQC ========
* Configurable IRQ interrupt dispatcher.
*/
Void Hwi_dispatchIRQC(Hwi_Irp irp)
{
/*
* Enough room is reserved above the isr stack to handle
* as many as 16 32-bit stack resident local variables.
* This space is reserved for the Swi scheduler.
*
* If the swi scheduler requires more than this, you must
* handle this in Hwi_Module_startup().
*/
Hwi_Object *hwi;
BIOS_ThreadType prevThreadType;
UInt intNum;
Int swiKey;
Int i;
/* save irp for ROV call stack view */
Hwi_module->irp = irp;
if (Hwi_dispatcherSwiSupport) {
swiKey = SWI_DISABLE();
}
/* set thread type to Hwi */
prevThreadType = BIOS_setThreadType(BIOS_ThreadType_Hwi);
/* Porcess ALL pending and enabled interrupts */
do {
intNum = Hwi_l1Intc.SIR_IRQ; /* get current L1 int num */
if (intNum == 0) { /* is from L2? */
intNum = Hwi_l2Intc.SIR_IRQ; /* get current L2 int num */
intNum += 32; /* force to linear index */
}
hwi = Hwi_module->dispatchTable[intNum];
hwi->irp = Hwi_module->irp;
#ifndef ti_sysbios_hal_Hwi_DISABLE_ALL_HOOKS
/* call the begin hooks */
for (i = 0; i < Hwi_hooks.length; i++) {
if (Hwi_hooks.elem[i].beginFxn != NULL) {
Hwi_hooks.elem[i].beginFxn((IHwi_Handle)hwi);
}
}
#endif
Log_write5(Hwi_LM_begin, (IArg)hwi, (IArg)hwi->fxn,
(IArg)prevThreadType, (IArg)intNum, hwi->irp);
(hwi->fxn)(hwi->arg);
Hwi_disable();
Log_write1(Hwi_LD_end, (IArg)hwi);
#ifndef ti_sysbios_hal_Hwi_DISABLE_ALL_HOOKS
/* call the end hooks */
for (i = 0; i < Hwi_hooks.length; i++) {
if (Hwi_hooks.elem[i].endFxn != NULL) {
Hwi_hooks.elem[i].endFxn((IHwi_Handle)hwi);
}
}
#endif
if (intNum > 31) { /* is from L2? */
Hwi_l2Intc.CONTROL = L2_NEW_IRQ_AGR;/* force NEW_IRQ_AGR */
}
Hwi_l1Intc.CONTROL = L1_NEW_IRQ_AGR; /* force NEW_IRQ_AGR */
}
/* loop thru all active and enabled IRQ ints */
while (Hwi_l1Intc.ITR & ~Hwi_l1Intc.MIR & Hwi_module->irq0Mask);
/* Run Swi scheduler */
if (Hwi_dispatcherSwiSupport) {
SWI_RESTORE(swiKey);
}
/* restore thread type */
BIOS_setThreadType(prevThreadType);
}
/*
* ======== Hwi_dispatchCore ========
* Configurable dispatcher.
*/
Void Hwi_dispatchCore(Int intNum)
{
/*
* Enough room is reserved above the isr stack to handle
* as many as 16 32-bit stack resident local variables.
* If the dispatcher requires more than this, you must
* handle this in Hwi_Module_startup().
*/
Hwi_Object *hwi;
BIOS_ThreadType prevThreadType;
UInt16 oldIER, disableMask, restoreMask;
Int swiKey;
Int i;
Hwi_FuncPtr fxn;
UArg arg;
/* save away intNum in module state because it might be saved on stack */
Hwi_module->intNum = intNum;
/*
* pre-read local copies of the variables used
* within to eliminate memory fetch nops
*/
hwi = Hwi_module->dispatchTable[intNum];
fxn = hwi->fxn;
arg = hwi->arg;
if (Hwi_dispatcherIrpTrackingSupport) {
hwi->irp = IRP;
}
if (Hwi_dispatcherAutoNestingSupport) {
disableMask = hwi->disableMask;
restoreMask = hwi->restoreMask;
}
if (Hwi_dispatcherSwiSupport) {
swiKey = SWI_DISABLE();
}
/* set thread type to Hwi */
prevThreadType = BIOS_setThreadType(BIOS_ThreadType_Hwi);
#ifndef ti_sysbios_hal_Hwi_DISABLE_ALL_HOOKS
/* call the begin hooks */
for (i = 0; i < Hwi_hooks.length; i++) {
if (Hwi_hooks.elem[i].beginFxn != NULL) {
Hwi_hooks.elem[i].beginFxn((IHwi_Handle)hwi);
}
}
#endif
Log_write5(Hwi_LM_begin, (IArg)hwi, (IArg)hwi->fxn,
(IArg)prevThreadType, (IArg)intNum, hwi->irp);
/* call the user's isr */
if (Hwi_dispatcherAutoNestingSupport) {
oldIER = IER;
IER &= ~disableMask;
_enable_interrupts();
(fxn)(arg);
_disable_interrupts();
IER |= (restoreMask & oldIER);
}
else {
(fxn)(arg);
}
Log_write1(Hwi_LD_end, (IArg)hwi);
#ifndef ti_sysbios_hal_Hwi_DISABLE_ALL_HOOKS
/* call the end hooks */
for (i = 0; i < Hwi_hooks.length; i++) {
if (Hwi_hooks.elem[i].endFxn != NULL) {
Hwi_hooks.elem[i].endFxn((IHwi_Handle)hwi);
}
}
#endif
/* Run Swi scheduler */
if (Hwi_dispatcherSwiSupport) {
SWI_RESTORE(swiKey);
}
/* restore thread type */
BIOS_setThreadType(prevThreadType);
}
/*
* ======== Exception_handler ========
* This handler is called by the dispatch function. It calls the various
* exception hook functions.
*/
Void Exception_handler(Bool abortFlag)
{
extern volatile cregister unsigned EFR;
extern volatile cregister unsigned ECR;
extern volatile cregister unsigned NRP;
extern volatile cregister unsigned NTSR;
Exception_Context *excp;
unsigned efr;
efr = EFR;
Exception_module->efr = efr; /* record EFR in Exception_Status */
Exception_module->nrp = NRP; /* record NRP in Exception_Status */
Exception_module->ntsr = NTSR; /* record NTSR in Exception_Status */
/* set exception context */
excp = Exception_module->excContext;
if (Exception_enablePrint) {
/* Force MAIN threadtype So we can safely call System_printf */
BIOS_setThreadType(BIOS_ThreadType_Main);
System_printf("A0=0x%x A1=0x%x\n", excp->A0, excp->A1);
System_printf("A2=0x%x A3=0x%x\n", excp->A2, excp->A3);
System_printf("A4=0x%x A5=0x%x\n", excp->A4, excp->A5);
System_printf("A6=0x%x A7=0x%x\n", excp->A6, excp->A7);
System_printf("A8=0x%x A9=0x%x\n", excp->A8, excp->A9);
System_printf("A10=0x%x A11=0x%x\n", excp->A10, excp->A11);
System_printf("A12=0x%x A13=0x%x\n", excp->A12, excp->A13);
System_printf("A14=0x%x A15=0x%x\n", excp->A14, excp->A15);
System_printf("A16=0x%x A17=0x%x\n", excp->A16, excp->A17);
System_printf("A18=0x%x A19=0x%x\n", excp->A18, excp->A19);
System_printf("A20=0x%x A21=0x%x\n", excp->A20, excp->A21);
System_printf("A22=0x%x A23=0x%x\n", excp->A22, excp->A23);
System_printf("A24=0x%x A25=0x%x\n", excp->A24, excp->A25);
System_printf("A26=0x%x A27=0x%x\n", excp->A26, excp->A27);
System_printf("A28=0x%x A29=0x%x\n", excp->A28, excp->A29);
System_printf("A30=0x%x A31=0x%x\n", excp->A30, excp->A31);
System_printf("B0=0x%x B1=0x%x\n", excp->B0, excp->B1);
System_printf("B2=0x%x B3=0x%x\n", excp->B2, excp->B3);
System_printf("B4=0x%x B5=0x%x\n", excp->B4, excp->B5);
System_printf("B6=0x%x B7=0x%x\n", excp->B6, excp->B7);
System_printf("B8=0x%x B9=0x%x\n", excp->B8, excp->B9);
System_printf("B10=0x%x B11=0x%x\n", excp->B10, excp->B11);
System_printf("B12=0x%x B13=0x%x\n", excp->B12, excp->B13);
System_printf("B14=0x%x B15=0x%x\n", excp->B14, excp->B15);
System_printf("B16=0x%x B17=0x%x\n", excp->B16, excp->B17);
System_printf("B18=0x%x B19=0x%x\n", excp->B18, excp->B19);
System_printf("B20=0x%x B21=0x%x\n", excp->B20, excp->B21);
System_printf("B22=0x%x B23=0x%x\n", excp->B22, excp->B23);
System_printf("B24=0x%x B25=0x%x\n", excp->B24, excp->B25);
System_printf("B26=0x%x B27=0x%x\n", excp->B26, excp->B27);
System_printf("B28=0x%x B29=0x%x\n", excp->B28, excp->B29);
System_printf("B30=0x%x B31=0x%x\n", excp->B30, excp->B31);
System_printf("NTSR=0x%x\n", excp->NTSR);
System_printf("ITSR=0x%x\n", excp->ITSR);
System_printf("IRP=0x%x\n", excp->IRP);
System_printf("SSR=0x%x\n", excp->SSR);
System_printf("AMR=0x%x\n", excp->AMR);
System_printf("RILC=0x%x\n", excp->RILC);
System_printf("ILC=0x%x\n", excp->ILC);
}
/* print general exception info */
if (Exception_enablePrint) {
System_printf("Exception at 0x%x\n",
(IArg)Exception_module->nrp);
System_printf("EFR=0x%x NRP=0x%x\n",
(IArg)Exception_module->efr,
(IArg)Exception_module->nrp);
}
if (*Exception_exceptionHook != NULL) {
(*Exception_exceptionHook)();
}
/* clear flags in EFR */
ECR = efr;
/* process all possible causes of exception */
if (efr & Exception_EFRIXF) {
/* internal exception */
efr ^= Exception_EFRIXF;
Exception_internalHandler();
}
if (efr & Exception_EFREXF) {
/* external exception */
efr ^= Exception_EFREXF;
Exception_externalHandler();
}
if (efr & Exception_EFRNXF) {
/* legacy NMI exception */
efr ^= Exception_EFRNXF;
Exception_nmiHandler();
}
if (abortFlag) {
if (Exception_enablePrint) {
Error_raise(0, Exception_E_exceptionMax, excp->NRP, excp->B15);
}
else {
Error_raise(0, Exception_E_exceptionMin, excp->NRP, excp->B15);
}
}
}
/*
* ======== Deh_excHandler ========
* Read data from HWI exception handler and print it to crash dump buffer.
* Notify host that exception has occurred.
*/
Void Deh_excHandler(UInt *excStack, UInt lr)
{
Hwi_ExcContext exc;
Deh_ExcRegs *excRegs;
Char *ttype;
UInt excNum;
Char *etype;
Char *name;
UInt sCnt = 0;
excRegs = (Deh_ExcRegs *) Deh_module->outbuf;
/* Copy registers from stack to excContext */
excRegs->r0 = exc.r0 = (Ptr)excStack[8]; /* r0 */
excRegs->r1 = exc.r1 = (Ptr)excStack[9]; /* r1 */
excRegs->r2 = exc.r2 = (Ptr)excStack[10]; /* r2 */
excRegs->r3 = exc.r3 = (Ptr)excStack[11]; /* r3 */
excRegs->r4 = exc.r4 = (Ptr)excStack[0]; /* r4 */
excRegs->r5 = exc.r5 = (Ptr)excStack[1]; /* r5 */
excRegs->r6 = exc.r6 = (Ptr)excStack[2]; /* r6 */
excRegs->r7 = exc.r7 = (Ptr)excStack[3]; /* r7 */
excRegs->r8 = exc.r8 = (Ptr)excStack[4]; /* r8 */
excRegs->r9 = exc.r9 = (Ptr)excStack[5]; /* r9 */
excRegs->r10 = exc.r10 = (Ptr)excStack[6]; /* r10 */
excRegs->r11 = exc.r11 = (Ptr)excStack[7]; /* r11 */
excRegs->r12 = exc.r12 = (Ptr)excStack[12]; /* r12 */
excRegs->sp = exc.sp = (Ptr)(UInt32)(excStack+16); /* sp */
excRegs->lr = exc.lr = (Ptr)excStack[13]; /* lr */
excRegs->pc = exc.pc = (Ptr)excStack[14]; /* pc */
excRegs->psr = exc.psr = (Ptr)excStack[15]; /* psr */
exc.threadType = BIOS_getThreadType();
switch (exc.threadType) {
case BIOS_ThreadType_Task:
if (BIOS_taskEnabled == TRUE) {
exc.threadHandle = (Ptr)Task_self();
exc.threadStack = (Task_self())->stack;
exc.threadStackSize = (Task_self())->stackSize;
}
break;
case BIOS_ThreadType_Swi:
if (BIOS_swiEnabled == TRUE) {
exc.threadHandle = (Ptr)Swi_self();
exc.threadStack = Deh_module->isrStackBase;
exc.threadStackSize = Deh_module->isrStackSize;
}
break;
case BIOS_ThreadType_Hwi:
case BIOS_ThreadType_Main:
exc.threadHandle = NULL;
exc.threadStack = Deh_module->isrStackBase;
exc.threadStackSize = Deh_module->isrStackSize;
break;
default:
exc.threadHandle = NULL;
exc.threadStack = NULL;
exc.threadStackSize = 0;
break;
}
excRegs->ICSR = exc.ICSR = (Ptr)Hwi_nvic.ICSR;
excRegs->MMFSR = exc.MMFSR = (Ptr)Hwi_nvic.MMFSR;
excRegs->BFSR = exc.BFSR = (Ptr)Hwi_nvic.BFSR;
excRegs->UFSR = exc.UFSR = (Ptr)Hwi_nvic.UFSR;
excRegs->HFSR = exc.HFSR = (Ptr)Hwi_nvic.HFSR;
excRegs->DFSR = exc.DFSR = (Ptr)Hwi_nvic.DFSR;
excRegs->MMAR = exc.MMAR = (Ptr)Hwi_nvic.MMAR;
excRegs->BFAR = exc.BFAR = (Ptr)Hwi_nvic.BFAR;
excRegs->AFSR = exc.AFSR = (Ptr)Hwi_nvic.AFSR;
/* Force MAIN threadtype So we can safely call System_printf */
BIOS_setThreadType(BIOS_ThreadType_Main);
excNum = Hwi_nvic.ICSR & 0xff;
if (Watchdog_isException(excNum)) {
etype = "Watchdog fired";
}
else {
VirtQueue_postCrashToMailbox();
etype = "Exception occurred";
}
System_printf("%s at (PC) = %08x\n", etype, exc.pc);
switch (lr) {
case 0xfffffff1:
System_printf("CPU context: ISR\n");
break;
case 0xfffffff9:
case 0xfffffffd:
System_printf("CPU context: thread\n");
break;
default:
System_printf("CPU context: unknown. LR: %08x\n", lr);
break;
}
switch (exc.threadType) {
case BIOS_ThreadType_Task: {
ttype = "Task";
break;
}
case BIOS_ThreadType_Swi: {
ttype = "Swi";
break;
}
case BIOS_ThreadType_Hwi: {
ttype = "Hwi";
break;
}
case BIOS_ThreadType_Main: {
ttype = "Main";
break;
}
default:
ttype = "Invalid!";
break;
}
if (exc.threadHandle) {
name = Task_Handle_name(exc.threadHandle);
if (!name) {
name = "(unnamed)";
}
}
else {
name = "(null task)";
}
System_printf("BIOS %s name: %s handle: 0x%x.\n", ttype, name,
exc.threadHandle);
System_printf("BIOS %s stack base: 0x%x.\n", ttype, exc.threadStack);
System_printf("BIOS %s stack size: 0x%x.\n", ttype, exc.threadStackSize);
switch (excNum) {
case 2:
ti_sysbios_family_arm_m3_Hwi_excNmi(excStack);
break;
case 3:
ti_sysbios_family_arm_m3_Hwi_excHardFault(excStack);
break;
case 4:
ti_sysbios_family_arm_m3_Hwi_excMemFault(excStack);
break;
case 5:
ti_sysbios_family_arm_m3_Hwi_excBusFault(excStack);
break;
case 6:
ti_sysbios_family_arm_m3_Hwi_excUsageFault(excStack);
break;
case 11:
ti_sysbios_family_arm_m3_Hwi_excSvCall(excStack);
break;
case 12:
ti_sysbios_family_arm_m3_Hwi_excDebugMon(excStack);
break;
case 7:
case 8:
case 9:
case 10:
case 13:
ti_sysbios_family_arm_m3_Hwi_excReserved(excStack, excNum);
break;
default:
if (!Watchdog_isException(excNum)) {
ti_sysbios_family_arm_m3_Hwi_excNoIsr(excStack, excNum);
}
break;
}
System_printf ("R0 = 0x%08x R8 = 0x%08x\n", exc.r0, exc.r8);
System_printf ("R1 = 0x%08x R9 = 0x%08x\n", exc.r1, exc.r9);
System_printf ("R2 = 0x%08x R10 = 0x%08x\n", exc.r2, exc.r10);
System_printf ("R3 = 0x%08x R11 = 0x%08x\n", exc.r3, exc.r11);
System_printf ("R4 = 0x%08x R12 = 0x%08x\n", exc.r4, exc.r12);
System_printf ("R5 = 0x%08x SP(R13) = 0x%08x\n", exc.r5, exc.sp);
System_printf ("R6 = 0x%08x LR(R14) = 0x%08x\n", exc.r6, exc.lr);
System_printf ("R7 = 0x%08x PC(R15) = 0x%08x\n", exc.r7, exc.pc);
System_printf ("PSR = 0x%08x\n", exc.psr);
System_printf ("ICSR = 0x%08x\n", Hwi_nvic.ICSR);
System_printf ("MMFSR = 0x%02x\n", Hwi_nvic.MMFSR);
System_printf ("BFSR = 0x%02x\n", Hwi_nvic.BFSR);
System_printf ("UFSR = 0x%04x\n", Hwi_nvic.UFSR);
System_printf ("HFSR = 0x%08x\n", Hwi_nvic.HFSR);
System_printf ("DFSR = 0x%08x\n", Hwi_nvic.DFSR);
System_printf ("MMAR = 0x%08x\n", Hwi_nvic.MMAR);
System_printf ("BFAR = 0x%08x\n", Hwi_nvic.BFAR);
System_printf ("AFSR = 0x%08x\n", Hwi_nvic.AFSR);
System_printf ("Stack trace\n");
StackDbg_walkStack((UInt)exc.threadStack, (UInt)exc.threadStackSize,
(UInt)exc.sp, printStackEntry, &sCnt);
System_printf ("Stack dump base %08x size %ld sp %08x:\n", exc.threadStack,
exc.threadStackSize, exc.sp);
dump_hex((UInt)exc.threadStack, exc.threadStackSize / sizeof(UInt),
(UInt)exc.sp);
System_abort("Terminating execution...\n");
}
