os_error_t
os_arch_os_init(void)
{
os_error_t err;
int i;
/* Cannot be called within an ISR */
err = OS_ERR_IN_ISR;
if (__get_IPSR() == 0) {
err = OS_OK;
/* Drop priority for all interrupts */
for (i = 0; i < sizeof(NVIC->IP); i++) {
NVIC->IP[i] = 0xff;
}
/*
* Install default interrupt handler, which'll print out system
* state at the time of the interrupt, and few other regs which
* should help in trying to figure out what went wrong.
*/
NVIC_SetVector(-13, (uint32_t)os_default_irq_asm); /* Hardfault */
NVIC_SetVector(MemoryManagement_IRQn, (uint32_t)os_default_irq_asm);
NVIC_SetVector(BusFault_IRQn, (uint32_t)os_default_irq_asm);
NVIC_SetVector(UsageFault_IRQn, (uint32_t)os_default_irq_asm);
for (i = 0; i < NVIC_NUM_VECTORS - NVIC_USER_IRQ_OFFSET; i++) {
NVIC_SetVector(i, (uint32_t)os_default_irq_asm);
}
/* Call bsp related OS initializations */
os_bsp_init();
/* Set the PendSV interrupt exception priority to the lowest priority */
NVIC_SetPriority(PendSV_IRQn, PEND_SV_PRIO);
/* Set the SVC interrupt to priority 0 (highest configurable) */
NVIC_SetPriority(SVCall_IRQn, SVC_PRIO);
/*
* Set the os environment. This will set stack pointers and, based
* on the contents of os_flags, will determine if the tasks run in
* priviliged or un-privileged mode.
*/
os_set_env();
/* Check if privileged or not */
if ((__get_CONTROL() & 1) == 0) {
os_arch_init();
} else {
svc_os_arch_init();
}
}
return err;
}
__naked void os_sys_init1 (void) {
/* Initialize system and start up a first task. */
U32 i;
rt_init ();
tsk_lock ();
/* Initialize dynamic memory and task TCB pointers to NULL. */
for (i = 0; i < os_maxtaskrun; i++) {
os_active_TCB[i] = NULL;
}
_init_box (&mp_tcb, mp_tcb_size, sizeof(struct OS_TCB));
_init_box (&mp_stk, mp_stk_size, BOX_ALIGN_8 | (U16)(os_stackinfo));
_init_box ((U32 *)m_tmr, mp_tmr_size, sizeof(struct OS_TMR));
/* Set up TCB of idle demon */
os_idle_TCB.task_id = 255;
os_idle_TCB.priv_stack = 0;
os_init_context (&os_idle_TCB, 0, os_idle_demon, __FALSE);
/* Set up ready list: initially empty */
os_rdy.cb_type = HCB;
os_rdy.p_lnk = NULL;
/* Set up delay list: initially empty */
os_dly.cb_type = HCB;
os_dly.p_dlnk = NULL;
os_dly.p_blnk = NULL;
os_dly.delta_time = 0;
/* Fix SP and system variables to assume idle task is running */
/* Transform main program into idle task by assuming idle TCB */
os_set_env (&os_idle_TCB);
os_runtask = &os_idle_TCB;
os_runtask->state = RUNNING;
/* Initialize ps queue */
os_psq->first = 0;
os_psq->last = 0;
os_psq->size = os_fifo_size;
/* Initialize system clock timer */
os_tmr_init ();
os_init_robin ();
/* Start up first user task before entering the endless loop */
os_sys_run ((FUNCP)os_tsk_create0);
/* Call body of idle task: contains an endless loop */
os_idle_demon();
/* This point never reached if idle task contains endless loop */
for (;;);
}
os_error_t
os_arch_os_init(void)
{
os_error_t err;
/* Cannot be called within an ISR */
err = OS_ERR_IN_ISR;
if (__get_IPSR() == 0) {
err = OS_OK;
/* Call bsp related OS initializations */
os_bsp_init();
/* Set the PendSV interrupt exception priority to the lowest priority */
NVIC_SetPriority(PendSV_IRQn, PEND_SV_PRIO);
/* Set the SVC interrupt to priority 0 (highest configurable) */
NVIC_SetPriority(SVCall_IRQn, SVC_PRIO);
/*
* Set the os environment. This will set stack pointers and, based
* on the contents of os_flags, will determine if the tasks run in
* priviliged or un-privileged mode.
*/
os_set_env();
/* Check if priviliged or not */
if ((__get_CONTROL() & 1) == 0) {
os_arch_init();
} else {
svc_os_arch_init();
}
}
return err;
}
/**
* Start the OS. First check to see if we are running with the correct stack
* pointer set (PSP) and privilege mode (PRIV).
*
* @return os_error_t
*/
os_error_t
os_arch_os_start(void)
{
os_error_t err;
/*
* Set the os environment. This will set stack pointers and, based
* on the contents of os_flags, will determine if the tasks run in
* priviliged or un-privileged mode.
*
* We switch to using "empty" part of idle task's stack until
* the svc_os_arch_start() executes SVC, and we will never return.
*/
os_set_env(g_idle_task.t_stackptr - 1);
err = OS_ERR_IN_ISR;
if (__get_IPSR() == 0) {
/*
* The following switch statement is really just a sanity check to
* insure that the os initialization routine was called prior to the
* os start routine.
*/
err = OS_OK;
switch (__get_CONTROL() & 0x03) {
/*
* These two cases are for completeness. Thread mode should be set
* to use PSP already.
*
* Fall-through intentional!
*/
case 0x00:
case 0x01:
err = OS_ERR_PRIV;
break;
case 0x02:
/*
* We are running in Privileged Thread mode w/SP = PSP but we
* are supposed to be un-privileged.
*/
if ((os_flags & 1) == OS_RUN_UNPRIV) {
err = OS_ERR_PRIV;
}
break;
case 0x03:
/*
* We are running in Unprivileged Thread mode w/SP = PSP but we
* are supposed to be privileged.
*/
if ((os_flags & 1) == OS_RUN_PRIV) {
err = OS_ERR_PRIV;
}
break;
}
if (err == OS_OK) {
/* Always start OS through SVC call */
svc_os_arch_start();
}
}
return err;
}
