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; }