void main_task
(
uint_32 param
)
{ /* Body */
_task_id tid;
printf("main_task: Task create at 0x%08x..0x%08x\n",
test_task_stack, (uchar_ptr)test_task_stack + TEST_STACK_SIZE);
tid = _task_create_at(0, TEST_TASK1, TEST_TASK1_PARAM, test_task_stack,
TEST_STACK_SIZE);
if (tid == MQX_NULL_TASK_ID) {
printf("task create at failed");
_mqx_fatal_error(MQX_INVALID_TASK_ID);
} /* Endif */
if (test_task_val != 1) {
printf("ERROR: test_task_val != 1\n");
} else {
printf("PASSED\n");
}/* Endif */
_task_block();
} /* Endbody */
/* Start CR 1124: C runtime thread local storage */
_mqx_uint _task_reserve_space
(
/* [IN} Amount of space to reserve */
_mqx_uint size
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
_mqx_uint off, algn;
_GET_KERNEL_DATA(kernel_data);
#if MQX_CHECK_ERRORS
/* Can only be called prior to creating any tasks! */
if (_QUEUE_GET_SIZE(&kernel_data->TD_LIST) != 0) {
_mqx_fatal_error(MQX_EINVAL);
} /* Endif */
#endif
if (size > 7) algn = 7;
else if (size > 3) algn = 3;
else if (size > 1) algn = 1;
else algn = 0;
if (algn > kernel_data->TOS_RESERVED_ALIGN_MASK) {
kernel_data->TOS_RESERVED_ALIGN_MASK = algn;
} /* Endif */
off = (kernel_data->TOS_RESERVED_SIZE + algn) & ~algn;
kernel_data->TOS_RESERVED_SIZE = off + size;
return off;
} /* Endbody */
/*!
* \brief Initialize the mmu and set default properties for regions not mapped by
* the ACR registers.
*
* \param[in] mmu_init default properties
*/
void _mmu_init
(
// [IN] default properties
void *mmu_init
)
{ /* Body */
PSP_MMU_INIT_STRUCT_PTR mmu = mmu_init;
KERNEL_DATA_STRUCT_PTR kernel_data;
PSP_SUPPORT_STRUCT_PTR psp_support_ptr;
uint32_t mode;
uint32_t tmp;
_mqx_int i;
_GET_KERNEL_DATA(kernel_data);
psp_support_ptr = (PSP_SUPPORT_STRUCT_PTR)kernel_data->PSP_SUPPORT_PTR;
if (psp_support_ptr == NULL || mmu == 0) {
_mqx_fatal_error(MQX_INVALID_POINTER);
} /* Endif */
/* Stop and invalidate the cache */
_DCACHE_DISABLE();
_ICACHE_DISABLE();
_mem_zero(psp_support_ptr->ACR_VALS, sizeof(psp_support_ptr->ACR_VALS));
mode = mmu->INITIAL_CACR_ENABLE_BITS & ~(MCF54XX_CACR_EUSP) | MCF54XX_CACR_SPA; // do not remove SPA flag - fn for flush/invalidate cache use phy address features
tmp = _PSP_GET_CACR();
tmp |= mode;
_PSP_SET_CACR(tmp);
} /* Endbody */
/*!
* \brief Enables all ACRs in use
*/
void _mmu_enable
(
void
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
PSP_SUPPORT_STRUCT_PTR psp_support_ptr;
_GET_KERNEL_DATA(kernel_data);
psp_support_ptr = (PSP_SUPPORT_STRUCT_PTR)kernel_data->PSP_SUPPORT_PTR;
if (psp_support_ptr == NULL) {
_mqx_fatal_error(MQX_INVALID_POINTER);
} /* Endif */
__psp_enable_acrs(psp_support_ptr->ACR_VALS);
} /* Endbody */
/*!
* \brief To provide support for exception handlers, applications can use this ISR
* to replace the default ISR. The ISR is specific to the PSP.
*
* An application calls _int_install_exception_isr() to install _int_exception_isr().
* \n The function _int_exception_isr() does the following:
* \n - If an exception occurs when a task is running and a task exception ISR
* exists, MQX runs the ISR; if a task exception ISR does not exist, MQX aborts
* the task by calling _task_abort().
* \n - If an exception occurs when an ISR is running and an ISR exception ISR
* exists, MQX aborts the running ISR and runs the ISR’s exception ISR.
* \n - The function walks the interrupt stack looking for information about the
* ISR or task that was running before the exception occurred. If the function
* determines that the interrupt stack contains incorrect information, it calls
* _mqx_fatal_error() with error code MQX_CORRUPT_INTERRUPT_STACK.
*
* \param[in] parameter Parameter passed to the default ISR (the vector number).
*
* \warning See description.
*
* \see _int_install_exception_isr
* \see _mqx_fatal_error
* \see _task_abort
*/
void _int_exception_isr
(
pointer parameter
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
TD_STRUCT_PTR td_ptr;
PSP_INT_CONTEXT_STRUCT_PTR exception_frame_ptr;
PSP_INT_CONTEXT_STRUCT_PTR isr_frame_ptr;
INTERRUPT_TABLE_STRUCT_PTR table_ptr;
INT_EXCEPTION_FPTR exception_handler;
uint_32 isr_vector;
/* uint_32 exception_vector; */
_GET_KERNEL_DATA(kernel_data);
td_ptr = kernel_data->ACTIVE_PTR;
/* Stop all interrupts */
_PSP_SET_DISABLE_SR(kernel_data->DISABLE_SR);
/*_int_disable(); */
if ( kernel_data->IN_ISR > 1 ) {
/* We have entered this function from an exception that happened
* while an isr was running.
*/
/* Get our current exception frame */
exception_frame_ptr = kernel_data->INTERRUPT_CONTEXT_PTR;
/* the current context contains a pointer to the next one */
isr_frame_ptr = (PSP_INT_CONTEXT_STRUCT_PTR)exception_frame_ptr->PREV_CONTEXT;
if (isr_frame_ptr == NULL) {
/* This is not allowable */
_mqx_fatal_error(MQX_CORRUPT_INTERRUPT_STACK);
}
isr_vector = isr_frame_ptr->EXCEPTION_NUMBER;
/* Call the isr exception handler for the ISR that WAS running */
table_ptr = kernel_data->INTERRUPT_TABLE_PTR;
#if MQX_CHECK_ERRORS
if ((table_ptr != NULL) &&
(isr_vector >= kernel_data->FIRST_USER_ISR_VECTOR) &&
(isr_vector <= kernel_data->LAST_USER_ISR_VECTOR))
{
#endif
/* Call the exception handler for the isr on isr_vector,
* passing the isr_vector, the exception_vector, the isr_data and
* the basic frame pointer for the exception
*/
exception_handler = _int_get_exception_handler(isr_vector);
if (exception_handler) {
(*exception_handler)(isr_vector, (_mqx_uint)parameter, _int_get_isr_data(isr_vector)/*table_ptr->APP_ISR_DATA*/, exception_frame_ptr);
}
#if MQX_CHECK_ERRORS
} else {
/* In this case, the exception occured in this handler */
_mqx_fatal_error(MQX_INVALID_VECTORED_INTERRUPT);
}
#endif
/* Indicate we have popped 1 interrupt stack frame (the exception frame) */
--kernel_data->IN_ISR;
/* Reset the stack to point to the interrupt frame */
/* And off we go. Will never return */
_psp_exception_return( (pointer)isr_frame_ptr );
} else {
/* We have entered this function from an exception that happened
* while a task was running.
*/
if (td_ptr->EXCEPTION_HANDLER_PTR != NULL ) {
(*td_ptr->EXCEPTION_HANDLER_PTR)((_mqx_uint)parameter,
td_ptr->STACK_PTR);
} else {
/* Abort the current task */
_task_abort(MQX_NULL_TASK_ID);
}
}
}
