/** * @brief Main program. * @param None * @retval None */ int main(void) { /* STM32F4xx HAL library initialization: - Configure the Flash prefetch - Systick timer is configured by default as source of time base, but user can eventually implement his proper time base source (a general purpose timer for example or other time source), keeping in mind that Time base duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and handled in milliseconds basis. - Set NVIC Group Priority to 4 - Low Level Initialization */ HAL_Init(); /* Configure the system clock to have a system clock = 180 MHz */ SystemClock_Config(); /* Configure LED1*/ BSP_LED_Init(LED1); /* Switch Thread mode Stack from Main to Process -----------------------------*/ /* Initialize memory reserved for Process Stack */ for(Index = 0; Index < SP_PROCESS_SIZE; Index++) { PSPMemAlloc[Index] = 0x00; } /* Set Process stack value */ __set_PSP((uint32_t)PSPMemAlloc + SP_PROCESS_SIZE); /* Select Process Stack as Thread mode Stack */ __set_CONTROL(SP_PROCESS); /* Execute ISB instruction to flush pipeline as recommended by Arm */ __ISB(); /* Get the Thread mode stack used */ if((__get_CONTROL() & 0x02) == SP_MAIN) { /* Main stack is used as the current stack */ CurrentStack = SP_MAIN; } else { /* Process stack is used as the current stack */ CurrentStack = SP_PROCESS; /* Get process stack pointer value */ PSPValue = __get_PSP(); } /* Switch Thread mode from privileged to unprivileged ------------------------*/ /* Thread mode has unprivileged access */ __set_CONTROL(THREAD_MODE_UNPRIVILEGED | SP_PROCESS); /* Execute ISB instruction to flush pipeline as recommended by Arm */ __ISB(); /* Unprivileged access mainly affect ability to: - Use or not use certain instructions such as MSR fields - Access System Control Space (SCS) registers such as NVIC and SysTick */ /* Check Thread mode privilege status */ if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED) { /* Thread mode has privileged access */ ThreadMode = THREAD_MODE_PRIVILEGED; } else { /* Thread mode has unprivileged access*/ ThreadMode = THREAD_MODE_UNPRIVILEGED; } /* Switch back Thread mode from unprivileged to privileged -------------------*/ /* Try to switch back Thread mode to privileged (Not possible, this can be done only in Handler mode) */ __set_CONTROL(THREAD_MODE_PRIVILEGED | SP_PROCESS); /* Execute ISB instruction to flush pipeline as recommended by Arm */ __ISB(); /* Generate a system call exception, and in the ISR switch back Thread mode to privileged */ __SVC(); /* Check Thread mode privilege status */ if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED) { /* Thread mode has privileged access */ ThreadMode = THREAD_MODE_PRIVILEGED; } else { /* Thread mode has unprivileged access*/ ThreadMode = THREAD_MODE_UNPRIVILEGED; } /* Infinite loop */ while (1) { /* Turn ON LED once test finished */ BSP_LED_On(LED1); } }
/** * @brief Main program. * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup file (startup_stm32f10x_xx.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f10x.c file */ /* Switch Thread mode Stack from Main to Process -----------------------------*/ /* Initialize memory reserved for Process Stack */ for(Index = 0; Index < SP_PROCESS_SIZE; Index++) { PSPMemAlloc[Index] = 0x00; } /* Set Process stack value */ __set_PSP((uint32_t)PSPMemAlloc + SP_PROCESS_SIZE); /* Select Process Stack as Thread mode Stack */ __set_CONTROL(SP_PROCESS); /* Get the Thread mode stack used */ if((__get_CONTROL() & 0x02) == SP_MAIN) { /* Main stack is used as the current stack */ CurrentStack = SP_MAIN; } else { /* Process stack is used as the current stack */ CurrentStack = SP_PROCESS; /* Get process stack pointer value */ PSPValue = __get_PSP(); } /* Switch Thread mode from privileged to unprivileged ------------------------*/ /* Thread mode has unprivileged access */ __set_CONTROL(THREAD_MODE_UNPRIVILEGED | SP_PROCESS); /* Unprivileged access mainly affect ability to: - Use or not use certain instructions such as MSR fields - Access System Control Space (SCS) registers such as NVIC and SysTick */ /* Check Thread mode privilege status */ if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED) { /* Thread mode has privileged access */ ThreadMode = THREAD_MODE_PRIVILEGED; } else { /* Thread mode has unprivileged access*/ ThreadMode = THREAD_MODE_UNPRIVILEGED; } /* Switch back Thread mode from unprivileged to privileged -------------------*/ /* Try to switch back Thread mode to privileged (Not possible, this can be done only in Handler mode) */ __set_CONTROL(THREAD_MODE_PRIVILEGED | SP_PROCESS); /* Generate a system call exception, and in the ISR switch back Thread mode to privileged */ __SVC(); /* Check Thread mode privilege status */ if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED) { /* Thread mode has privileged access */ ThreadMode = THREAD_MODE_PRIVILEGED; } else { /* Thread mode has unprivileged access*/ ThreadMode = THREAD_MODE_UNPRIVILEGED; } while (1) { } }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* STM32F4xx HAL library initialization: - Configure the Flash prefetch, instruction and Data caches - Configure the Systick to generate an interrupt each 1 msec - Set NVIC Group Priority to 4 - Global MSP (MCU Support Package) initialization */ HAL_Init(); /* Configure the system clock to 180 MHz */ SystemClock_Config(); /* Switch Thread mode Stack from Main to Process ###########################*/ /* Initialize memory reserved for Process Stack */ for(Index = 0; Index < SP_PROCESS_SIZE; Index++) { PSPMemAlloc[Index] = 0x00; } /* Set Process stack value */ __set_PSP((uint32_t)PSPMemAlloc + SP_PROCESS_SIZE); /* Select Process Stack as Thread mode Stack */ __set_CONTROL(SP_PROCESS); /* Execute ISB instruction to flush pipeline as recommended by Arm */ __ISB(); /* Get the Thread mode stack used */ if((__get_CONTROL() & 0x02) == SP_MAIN) { /* Main stack is used as the current stack */ CurrentStack = SP_MAIN; } else { /* Process stack is used as the current stack */ CurrentStack = SP_PROCESS; /* Get process stack pointer value */ PSPValue = __get_PSP(); } /* Switch Thread mode from privileged to unprivileged ######################*/ /* Thread mode has unprivileged access */ __set_CONTROL(THREAD_MODE_UNPRIVILEGED | SP_PROCESS); /* Execute ISB instruction to flush pipeline as recommended by Arm */ __ISB(); /* Unprivileged access mainly affect ability to: - Use or not use certain instructions such as MSR fields - Access System Control Space (SCS) registers such as NVIC and SysTick */ /* Check Thread mode privilege status */ if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED) { /* Thread mode has privileged access */ ThreadMode = THREAD_MODE_PRIVILEGED; } else { /* Thread mode has unprivileged access*/ ThreadMode = THREAD_MODE_UNPRIVILEGED; } /* Switch back Thread mode from unprivileged to privileged #################*/ /* Try to switch back Thread mode to privileged (Not possible, this can be done only in Handler mode) */ __set_CONTROL(THREAD_MODE_PRIVILEGED | SP_PROCESS); /* Execute ISB instruction to flush pipeline as recommended by Arm */ __ISB(); /* Generate a system call exception, and in the ISR switch back Thread mode to privileged */ __SVC(); /* Check Thread mode privilege status */ if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED) { /* Thread mode has privileged access */ ThreadMode = THREAD_MODE_PRIVILEGED; } else { /* Thread mode has unprivileged access */ ThreadMode = THREAD_MODE_UNPRIVILEGED; } /* Infinite loop */ while (1) { } }
/** * @brief Main program. * @param None * @retval None */ int main(void) { /* STM32F0xx HAL library initialization: - Configure the Flash prefetch - Systick timer is configured by default as source of time base, but user can eventually implement his proper time base source (a general purpose timer for example or other time source), keeping in mind that Time base duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and handled in milliseconds basis. - Low Level Initialization */ HAL_Init(); /* Configure LED2*/ BSP_LED_Init(LED2); /* Configure the system clock to have a system clock = 48 MHz */ SystemClock_Config(); /* Switch Thread mode Stack from Main to Process -----------------------------*/ /* Initialize memory reserved for Process Stack */ for(Index = 0; Index < SP_PROCESS_SIZE; Index++) { PSPMemAlloc[Index] = 0x00; } /* Set Process stack value */ __set_PSP((uint32_t)PSPMemAlloc + SP_PROCESS_SIZE); /* Select Process Stack as Thread mode Stack */ __set_CONTROL(SP_PROCESS); /* Execute ISB instruction to flush pipeline as recommended by Arm */ __ISB(); /* Get the Thread mode stack used */ CurrentStack = (__get_CONTROL() & 0x02); /* Get process stack pointer value */ PSPValue = __get_PSP(); /* Check is mode has been well applied */ if(CurrentStack != SP_PROCESS) { Error_Handler(); } /* Generate a system call exception: Main Stack pointer should be automaticcaly when entering in ISR context */ __SVC(); /* Check is Main stack was used under ISR*/ if(IsrStack != SP_MAIN) { Error_Handler(); } /* Get the Thread mode stack used to verify we have switched back automatically to Process Stack */ CurrentStack = (__get_CONTROL() & 0x02); /* Check is mode has been well applied */ if(CurrentStack != SP_PROCESS) { Error_Handler(); } else { /* Turn LED2 On*/ BSP_LED_On(LED2); } /* Infinite loop */ while (1) { } }
/*********************************************************************//** * @brief c_entry: main function * @param[in] none * @return int **********************************************************************/ int c_entry(void) /* Main Program */ { uint32_t priviledge_status; /* Initialize debug via UART0 * – 115200bps * – 8 data bit * – No parity * – 1 stop bit * – No flow control */ debug_frmwrk_init(); LED_Init(); //print menu _DBG(menu); _DBG_(menu2); /* Thread mode is privilege out of reset */ /* First checking Thread mode is privilege or un-privilege */ priviledge_status = __get_CONTROL(); if((priviledge_status & (~THREAD_PRIVILEDGED_MASK))==THREAD_PRIVILEGED) { _DBG_("Thread mode is privileged!"); Turn_on_LED(PRIVILEGE_LED); } else { _DBG_("Theard mode is unprivileged! It's not compliant with Cortex-M3 Technical"); while(1); //Error loop } /* Wait user press '1' character to change to un-privilege mode */ _DBG_("Press '1' to change to unprivilege mode ...\n\r"); while(_DG !='1'); /* Changing to un-privilege mode */ __set_CONTROL((priviledge_status & THREAD_PRIVILEDGED_MASK)|THREAD_UNPRIVILEGED); _DBG_("Changed to unprivilege mode!"); /* Check */ priviledge_status = __get_CONTROL(); if((priviledge_status & ~THREAD_PRIVILEDGED_MASK)==THREAD_UNPRIVILEGED) { _DBG_("Check: Thread mode change to unprivilege successful!"); Turn_off_LED(PRIVILEGE_LED); Turn_on_LED(UNPRIVILEGE_LED); } else { _DBG_("Check: Thread mode is still privileged! ERROR..."); while(1); //Error loop } /* Wait user press '1' character to change to un-privilege mode */ _DBG_("Press '2' to change to privilege mode by calling system call exception...\n\r"); while(_DG !='2'); /* Call system call exception to re-change Thread mode into privilege */ __SVC(); _DBG_("Called system call exception!"); /* Check */ priviledge_status = __get_CONTROL(); if((priviledge_status & ~THREAD_PRIVILEDGED_MASK)==THREAD_PRIVILEGED) { _DBG_("Check: Thread mode change to privilege successful!"); Turn_off_LED(UNPRIVILEGE_LED); Turn_on_LED(PRIVILEGE_LED); } else { _DBG_("Check: Theard mode is still unprivileged! ERROR..."); while(1); //Error loop } _DBG_("Demo terminate!"); while (1); return 0; }
/** * @brief Main program. * @param None * @retval None */ int main(void) { /* Clock configuration */ RCC_Configuration(); /* Switch Thread mode Stack from Main to Process -----------------------------*/ /* Initialize memory reserved for Process Stack */ for(Index = 0; Index < SP_PROCESS_SIZE; Index++) { PSPMemAlloc[Index] = 0x00; } /* Set Process stack value */ __set_PSP((uint32_t)PSPMemAlloc + SP_PROCESS_SIZE); /* Select Process Stack as Thread mode Stack */ __set_CONTROL(SP_PROCESS); /* Get the Thread mode stack used */ if((__get_CONTROL() & 0x02) == SP_MAIN) { /* Main stack is used as the current stack */ CurrentStack = SP_MAIN; } else { /* Process stack is used as the current stack */ CurrentStack = SP_PROCESS; /* Get process stack pointer value */ PSPValue = __get_PSP(); } /* Switch Thread mode from privileged to unprivileged ------------------------*/ /* Thread mode has unprivileged access */ __set_CONTROL(THREAD_MODE_UNPRIVILEGED | SP_PROCESS); /* Unprivileged access mainly affect ability to: - Use or not use certain instructions such as MSR fields - Access System Control Space (SCS) registers such as NVIC and SysTick */ /* Check Thread mode privilege status */ if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED) { /* Thread mode has privileged access */ ThreadMode = THREAD_MODE_PRIVILEGED; } else { /* Thread mode has unprivileged access*/ ThreadMode = THREAD_MODE_UNPRIVILEGED; } /* Switch back Thread mode from unprivileged to privileged -------------------*/ /* Try to switch back Thread mode to privileged (Not possible, this can be done only in Handler mode) */ __set_CONTROL(THREAD_MODE_PRIVILEGED | SP_PROCESS); /* Generate a system call exception, and in the ISR switch back Thread mode to privileged */ __SVC(); /* Check Thread mode privilege status */ if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED) { /* Thread mode has privileged access */ ThreadMode = THREAD_MODE_PRIVILEGED; } else { /* Thread mode has unprivileged access*/ ThreadMode = THREAD_MODE_UNPRIVILEGED; } while (1) { } }
/******************************************************************************* * Function Name : SysTickHandler * Description : This function handles SysTick Handler. * Input : None * Output : None * Return : None *******************************************************************************/ void SysTickHandler(void) { __SVC(); /* Toggle GPIO_LED pin 6 */ GPIO_WriteBit(GPIO_LED, GPIO_Pin_6, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIO_LED, GPIO_Pin_6))); }