OrgZephyr/zephyr
OrgZephyr
/
zephyr
mirror of https://github.com/zephyrproject-rtos/zephyr.git
1
0
Fork 0
Code Issues Releases Wiki Activity
zephyr/arch/arm/include/kernel_arch_func.h

104 lines
2.2 KiB
C
Raw Normal View History

kernel/arch: consolidate tTCS and TNANO definitions There was a lot of duplication between architectures for the definition of threads and the "nanokernel" guts. These have been consolidated. Now, a common file kernel/unified/include/kernel_structs.h holds the common definitions. Architectures provide two files to complement it: kernel_arch_data.h and kernel_arch_func.h. The first one contains at least the struct _thread_arch and struct _kernel_arch data structures, as well as the struct _callee_saved and struct _caller_saved register layouts. The second file contains anything that needs what is provided by the common stuff in kernel_structs.h. Those two files are only meant to be included in kernel_structs.h in very specific locations. The thread data structure has been separated into three major parts: common struct _thread_base and struct k_thread, and arch-specific struct _thread_arch. The first and third ones are included in the second. The struct s_NANO data structure has been split into two: common struct _kernel and arch-specific struct _kernel_arch. The latter is included in the former. Offsets files have also changed: nano_offsets.h has been renamed kernel_offsets.h and is still included by the arch-specific offsets.c. Also, since the thread and kernel data structures are now made of sub-structures, offsets have to be added to make up the full offset. Some of these additions have been consolidated in shorter symbols, available from kernel/unified/include/offsets_short.h, which includes an arch-specific offsets_arch_short.h. Most of the code include offsets_short.h now instead of offsets.h. Change-Id: I084645cb7e6db8db69aeaaf162963fe157045d5a Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-08 23:36:50 +08:00
/*
* Copyright (c) 2013-2016 Wind River Systems, Inc.
*
license: Replace Apache boilerplate with SPDX tag Replace the existing Apache 2.0 boilerplate header with an SPDX tag throughout the zephyr code tree. This patch was generated via a script run over the master branch. Also updated doc/porting/application.rst that had a dependency on line numbers in a literal include. Manually updated subsys/logging/sys_log.c that had a malformed header in the original file. Also cleanup several cases that already had a SPDX tag and we either got a duplicate or missed updating. Jira: ZEP-1457 Change-Id: I6131a1d4ee0e58f5b938300c2d2fc77d2e69572c Signed-off-by: David B. Kinder <david.b.kinder@intel.com> Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2017-01-19 09:01:01 +08:00
* SPDX-License-Identifier: Apache-2.0
kernel/arch: consolidate tTCS and TNANO definitions There was a lot of duplication between architectures for the definition of threads and the "nanokernel" guts. These have been consolidated. Now, a common file kernel/unified/include/kernel_structs.h holds the common definitions. Architectures provide two files to complement it: kernel_arch_data.h and kernel_arch_func.h. The first one contains at least the struct _thread_arch and struct _kernel_arch data structures, as well as the struct _callee_saved and struct _caller_saved register layouts. The second file contains anything that needs what is provided by the common stuff in kernel_structs.h. Those two files are only meant to be included in kernel_structs.h in very specific locations. The thread data structure has been separated into three major parts: common struct _thread_base and struct k_thread, and arch-specific struct _thread_arch. The first and third ones are included in the second. The struct s_NANO data structure has been split into two: common struct _kernel and arch-specific struct _kernel_arch. The latter is included in the former. Offsets files have also changed: nano_offsets.h has been renamed kernel_offsets.h and is still included by the arch-specific offsets.c. Also, since the thread and kernel data structures are now made of sub-structures, offsets have to be added to make up the full offset. Some of these additions have been consolidated in shorter symbols, available from kernel/unified/include/offsets_short.h, which includes an arch-specific offsets_arch_short.h. Most of the code include offsets_short.h now instead of offsets.h. Change-Id: I084645cb7e6db8db69aeaaf162963fe157045d5a Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-08 23:36:50 +08:00
*/
/**
* @file
* @brief Private kernel definitions (ARM)
*
* This file contains private kernel function definitions and various
* other definitions for the ARM Cortex-M3 processor architecture.
*
* This file is also included by assembly language files which must #define
* _ASMLANGUAGE before including this header file. Note that kernel
* assembly source files obtains structure offset values via "absolute symbols"
* in the offsets.o module.
*/
/* this file is only meant to be included by kernel_structs.h */
#ifndef _kernel_arch_func__h_
#define _kernel_arch_func__h_
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _ASMLANGUAGE
extern void _FaultInit(void);
extern void _CpuIdleInit(void);
static ALWAYS_INLINE void nanoArchInit(void)
{
_InterruptStackSetup();
_ExcSetup();
_FaultInit();
_CpuIdleInit();
}
arm: use interrupt stack during early init The ARM Cortex-M early boot was using a custom stack at the end of the SRAM instead of the interrupt stack. This works as long as no static data that needs a known initial value occupies that stack space. This has probably not been an issue because the .noinit section is at the very end of the image, but it was still wrong to use that region of memory for that initial stack. To be able to use the interrupt stack during early boot, the stack has to be released before an interrupt can happen. Since ARM Cortex-M uses PendSV as a very low priority exception for context switching, if a device driver installs and enables an interrupt during the PRE_KERNEL initialization points, an interrupt could take precedence over PendSV while the initial dummy thread has not yet been context switched of and thus released the interrupt stack. To address this, rather than using _Swap() and thus triggering PendSV, the initialization logic switches to the main stack and branches to _main() directly instead. Fixes ZEP-1309 Change-Id: If0b62cc66470b45b601e63826b5b3306e6a25ae9 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-21 00:08:53 +08:00
static ALWAYS_INLINE void
_arch_switch_to_main_thread(char *main_stack, size_t main_stack_size,
_thread_entry_t _main)
{
/* get high address of the stack, i.e. its start (stack grows down) */
char *start_of_main_stack;
start_of_main_stack = main_stack + main_stack_size;
start_of_main_stack = (void *)STACK_ROUND_DOWN(start_of_main_stack);
_current = (void *)main_stack;
kernel/arch: enhance the "ready thread" cache The way the ready thread cache was implemented caused it to not always be "hot", i.e. there could be some misses, which happened when the cached thread was taken out of the ready queue. When that happened, it was not replaced immediately, since doing so could mean that the replacement might not run because the flow could be interrupted and another thread could take its place. This was the more conservative approach that insured that moving a thread to the cache would never be wasted. However, this caused two problems: 1. The cache could not be refilled until another thread context-switched in, since there was no thread in the cache to compare priorities against. 2. Interrupt exit code would always have to call into C to find what thread to run when the current thread was not coop and did not have the scheduler locked. Furthermore, it was possible for this code path to encounter a cold cache and then it had to find out what thread to run the long way. To fix this, filling the cache is now more aggressive, i.e. the next thread to put in the cache is found even in the case the current cached thread is context-switched out. This ensures the interrupt exit code is much faster on the slow path. In addition, since finding the next thread to run is now always "get it from the cache", which is a simple fetch from memory (_kernel.ready_q.cache), there is no need to call the more complex C code. On the ARM FRDM K64F board, this improvement is seen: Before: 1- Measure time to switch from ISR back to interrupted task switching time is 215 tcs = 1791 nsec 2- Measure time from ISR to executing a different task (rescheduled) switch time is 315 tcs = 2625 nsec After: 1- Measure time to switch from ISR back to interrupted task switching time is 130 tcs = 1083 nsec 2- Measure time from ISR to executing a different task (rescheduled) switch time is 225 tcs = 1875 nsec These are the most dramatic improvements, but most of the numbers generated by the latency_measure test are improved. Fixes ZEP-1401. Change-Id: I2eaac147048b1ec71a93bd0a285e743a39533973 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-12-02 23:37:27 +08:00
/* the ready queue cache already contains the main thread */
arm: use interrupt stack during early init The ARM Cortex-M early boot was using a custom stack at the end of the SRAM instead of the interrupt stack. This works as long as no static data that needs a known initial value occupies that stack space. This has probably not been an issue because the .noinit section is at the very end of the image, but it was still wrong to use that region of memory for that initial stack. To be able to use the interrupt stack during early boot, the stack has to be released before an interrupt can happen. Since ARM Cortex-M uses PendSV as a very low priority exception for context switching, if a device driver installs and enables an interrupt during the PRE_KERNEL initialization points, an interrupt could take precedence over PendSV while the initial dummy thread has not yet been context switched of and thus released the interrupt stack. To address this, rather than using _Swap() and thus triggering PendSV, the initialization logic switches to the main stack and branches to _main() directly instead. Fixes ZEP-1309 Change-Id: If0b62cc66470b45b601e63826b5b3306e6a25ae9 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-21 00:08:53 +08:00
__asm__ __volatile__(
/* move to main() thread stack */
"msr PSP, %0 \t\n"
/* unlock interrupts */
arm: Replace CONFIG_CPU_CORTEX_M0_M0PLUS with CONFIG_ARMV6_M Precursor patches have arranged all conditional compilation hanging on CONFIG_CPU_CORTEX_M0_M0PLUS such that it actually represents support for ARM ARMv6-M, rename the config variable to reflect this. Change-Id: I553fcf3e606b350a9e823df31bac96636be1504f Signed-off-by: Marcus Shawcroft <marcus.shawcroft@arm.com>
2016-12-31 22:09:41 +08:00
#ifdef CONFIG_ARMV6_M
arm: use interrupt stack during early init The ARM Cortex-M early boot was using a custom stack at the end of the SRAM instead of the interrupt stack. This works as long as no static data that needs a known initial value occupies that stack space. This has probably not been an issue because the .noinit section is at the very end of the image, but it was still wrong to use that region of memory for that initial stack. To be able to use the interrupt stack during early boot, the stack has to be released before an interrupt can happen. Since ARM Cortex-M uses PendSV as a very low priority exception for context switching, if a device driver installs and enables an interrupt during the PRE_KERNEL initialization points, an interrupt could take precedence over PendSV while the initial dummy thread has not yet been context switched of and thus released the interrupt stack. To address this, rather than using _Swap() and thus triggering PendSV, the initialization logic switches to the main stack and branches to _main() directly instead. Fixes ZEP-1309 Change-Id: If0b62cc66470b45b601e63826b5b3306e6a25ae9 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-21 00:08:53 +08:00
"cpsie i \t\n"
arm: Adjust cortex-m7 support to reflect its ARMv7-M architecture. The cortex-m7 is an implementation of armv7-m. Adjust the Kconfig support for cortex-m7 to reflect this and drop the unnecessary, explicit, conditional compilation. Change-Id: I6ec20e69c8c83c5a80b1f714506f7f9e295b15d5 Signed-off-by: Marcus Shawcroft <marcus.shawcroft@arm.com>
2016-12-31 22:41:19 +08:00
#elif defined(CONFIG_ARMV7_M)
arm: use interrupt stack during early init The ARM Cortex-M early boot was using a custom stack at the end of the SRAM instead of the interrupt stack. This works as long as no static data that needs a known initial value occupies that stack space. This has probably not been an issue because the .noinit section is at the very end of the image, but it was still wrong to use that region of memory for that initial stack. To be able to use the interrupt stack during early boot, the stack has to be released before an interrupt can happen. Since ARM Cortex-M uses PendSV as a very low priority exception for context switching, if a device driver installs and enables an interrupt during the PRE_KERNEL initialization points, an interrupt could take precedence over PendSV while the initial dummy thread has not yet been context switched of and thus released the interrupt stack. To address this, rather than using _Swap() and thus triggering PendSV, the initialization logic switches to the main stack and branches to _main() directly instead. Fixes ZEP-1309 Change-Id: If0b62cc66470b45b601e63826b5b3306e6a25ae9 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-21 00:08:53 +08:00
"movs %%r1, #0 \n\t"
"msr BASEPRI, %%r1 \n\t"
arm: Restructure ARM cpu related preprocessor conditionals. The ARM code base provides for three mutually exclusive ARM architecture related conditional compilation choices. M0_M0PLUS, M3_M4 and M7. Throughout the code base we have conditional compilation gated around these three choices. Adjust the form of this conditional compilation to adopt a uniform structure. The uniform structure always selects code based on the definition of an appropriate config option rather the the absence of a definition. Removing the extensive use of #else ensures that when support for other ARM architecture versions is added we get hard compilation failures rather than attempting to compile inappropriate code for the added architecture with unexpected runtime consequences. Adopting this uniform structure makes it straight forward to replace the adhoc CPU_CORTEX_M3_M4 and CPU_CORTEX_M0_M0PLUS configuration variables with ones that directly represent the actual underlying ARM architectures we provide support for. This change also paves the way for folding adhoc conditional compilation related to CPU_CORTEX_M7 directly in support for ARMv7-M. This change is mechanical in nature involving two transforms: 1) #if !defined(CONFIG_CPU_CORTEX_M0_M0PLUS) ... is transformed to: #if defined(CONFIG_CPU_CORTEX_M0_M0PLUS) #elif defined(CONFIG_CPU_CORTEX_M3_M4) || defined(CONFIG_CPU_CORTEX_M7) ... 2) #if defined(CONFIG_CPU_CORTEX_M0_M0PLUS) ... #else ... #endif is transformed to: #if defined(CONFIG_CPU_CORTEX_M0_M0PLUS) ... #elif defined(CONFIG_CPU_CORTEX_M3_M4) || defined(CONFIG_CPU_CORTEX_M7) ... #else #error Unknown ARM architecture #endif Change-Id: I7229029b174da3a8b3c6fb2eec63d776f1d11e24 Signed-off-by: Marcus Shawcroft <marcus.shawcroft@arm.com>
2016-12-31 21:18:25 +08:00
#else
#error Unknown ARM architecture
arm: Replace CONFIG_CPU_CORTEX_M0_M0PLUS with CONFIG_ARMV6_M Precursor patches have arranged all conditional compilation hanging on CONFIG_CPU_CORTEX_M0_M0PLUS such that it actually represents support for ARM ARMv6-M, rename the config variable to reflect this. Change-Id: I553fcf3e606b350a9e823df31bac96636be1504f Signed-off-by: Marcus Shawcroft <marcus.shawcroft@arm.com>
2016-12-31 22:09:41 +08:00
#endif /* CONFIG_ARMV6_M */
arm: use interrupt stack during early init The ARM Cortex-M early boot was using a custom stack at the end of the SRAM instead of the interrupt stack. This works as long as no static data that needs a known initial value occupies that stack space. This has probably not been an issue because the .noinit section is at the very end of the image, but it was still wrong to use that region of memory for that initial stack. To be able to use the interrupt stack during early boot, the stack has to be released before an interrupt can happen. Since ARM Cortex-M uses PendSV as a very low priority exception for context switching, if a device driver installs and enables an interrupt during the PRE_KERNEL initialization points, an interrupt could take precedence over PendSV while the initial dummy thread has not yet been context switched of and thus released the interrupt stack. To address this, rather than using _Swap() and thus triggering PendSV, the initialization logic switches to the main stack and branches to _main() directly instead. Fixes ZEP-1309 Change-Id: If0b62cc66470b45b601e63826b5b3306e6a25ae9 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-21 00:08:53 +08:00
/* branch to _thread_entry(_main, 0, 0, 0) */
"mov %%r0, %1 \n\t"
"bx %2 \t\n"
/* never gets here */
:
: "r"(start_of_main_stack),
"r"(_main), "r"(_thread_entry)
: "r0", "r1", "sp"
);
CODE_UNREACHABLE;
}
kernel/arch: consolidate tTCS and TNANO definitions There was a lot of duplication between architectures for the definition of threads and the "nanokernel" guts. These have been consolidated. Now, a common file kernel/unified/include/kernel_structs.h holds the common definitions. Architectures provide two files to complement it: kernel_arch_data.h and kernel_arch_func.h. The first one contains at least the struct _thread_arch and struct _kernel_arch data structures, as well as the struct _callee_saved and struct _caller_saved register layouts. The second file contains anything that needs what is provided by the common stuff in kernel_structs.h. Those two files are only meant to be included in kernel_structs.h in very specific locations. The thread data structure has been separated into three major parts: common struct _thread_base and struct k_thread, and arch-specific struct _thread_arch. The first and third ones are included in the second. The struct s_NANO data structure has been split into two: common struct _kernel and arch-specific struct _kernel_arch. The latter is included in the former. Offsets files have also changed: nano_offsets.h has been renamed kernel_offsets.h and is still included by the arch-specific offsets.c. Also, since the thread and kernel data structures are now made of sub-structures, offsets have to be added to make up the full offset. Some of these additions have been consolidated in shorter symbols, available from kernel/unified/include/offsets_short.h, which includes an arch-specific offsets_arch_short.h. Most of the code include offsets_short.h now instead of offsets.h. Change-Id: I084645cb7e6db8db69aeaaf162963fe157045d5a Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-08 23:36:50 +08:00
static ALWAYS_INLINE void
_set_thread_return_value(struct k_thread *thread, unsigned int value)
{
kernel/arm: fix race condition when setting _Swap() return value There was a possible race condition when setting the return value of a thread that is pending, from an ISR. A kernel function causes a thread to pend, with the following series of steps: - disable interrupts - move current thread to wait_q - call _Swap Depending if running on M3/4 or M0+, _Swap will either issue a svc #0, or pend PendSV directly. The same problem exists in both cases. M3/4: __svc will: - enable interrupts - trigger __pendsv M0+: _Swap() will enable interrupts. __pendsv will: - save register context including PSP into the thread struct If an interrupt occurs between interrupts being enabled them and __pendsv saving PSP, and the ISR sets the pending thread's return value, this will happen: - sees the thread in a wait_q - removes it - makes it ready - calls _set_thread_return_value - _set_thread_return_value looks at the thread's saved PSP to poke the value In this scenario, PSP hasn't yet been updated by __pendsv so it's a stale value from the previous context switch, resulting in unpredictable word on the stack getting set to the return value. There is no way to fix this issue and still have the return value being delivered directly in the pending thread's exception stack frame, in the M0+ case. There will always be a window between the unlocking of interrupts and PendSV being handled. On M3/4, it could be possible with the mix of SVC and PendSV, since the exception stack frame is created in the __svc handler. However, because we want to keep the two implementations as close as possible, and there were talks of moving M3/4 to using PendSV only, to save an exception, the approach taken solves both cases. The approach taken is similar to the ARC and Nios2 ports, where there is a field in the thread structure that holds the return value. _Swap() then loads r0/a1 with that value just before returning. Fixes ZEP-1289. Change-Id: Iee7e06fe3f8ded84aff918fd43408c7f589344d9 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-16 07:45:43 +08:00
thread->arch.swap_return_value = value;
kernel/arch: consolidate tTCS and TNANO definitions There was a lot of duplication between architectures for the definition of threads and the "nanokernel" guts. These have been consolidated. Now, a common file kernel/unified/include/kernel_structs.h holds the common definitions. Architectures provide two files to complement it: kernel_arch_data.h and kernel_arch_func.h. The first one contains at least the struct _thread_arch and struct _kernel_arch data structures, as well as the struct _callee_saved and struct _caller_saved register layouts. The second file contains anything that needs what is provided by the common stuff in kernel_structs.h. Those two files are only meant to be included in kernel_structs.h in very specific locations. The thread data structure has been separated into three major parts: common struct _thread_base and struct k_thread, and arch-specific struct _thread_arch. The first and third ones are included in the second. The struct s_NANO data structure has been split into two: common struct _kernel and arch-specific struct _kernel_arch. The latter is included in the former. Offsets files have also changed: nano_offsets.h has been renamed kernel_offsets.h and is still included by the arch-specific offsets.c. Also, since the thread and kernel data structures are now made of sub-structures, offsets have to be added to make up the full offset. Some of these additions have been consolidated in shorter symbols, available from kernel/unified/include/offsets_short.h, which includes an arch-specific offsets_arch_short.h. Most of the code include offsets_short.h now instead of offsets.h. Change-Id: I084645cb7e6db8db69aeaaf162963fe157045d5a Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-08 23:36:50 +08:00
}
kernel: add k_cpu_idle/k_cpu_atomic_idle() nano_cpu_idle/nano_cpu_atomic_idle were not ported to the unified kernel, and only the old APIs were available. There was no real impact since, in the unified kernel, only the idle thread should really be doing power management. However, with a single-threaded kernel, these functions can be useful again. The kernel internals now make use of these APIs instead of the legacy ones. Change-Id: Ie8a6396ba378d3ddda27b8dd32fa4711bf53eb36 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-12-15 02:04:36 +08:00
extern void k_cpu_atomic_idle(unsigned int key);
kernel/arch: consolidate tTCS and TNANO definitions There was a lot of duplication between architectures for the definition of threads and the "nanokernel" guts. These have been consolidated. Now, a common file kernel/unified/include/kernel_structs.h holds the common definitions. Architectures provide two files to complement it: kernel_arch_data.h and kernel_arch_func.h. The first one contains at least the struct _thread_arch and struct _kernel_arch data structures, as well as the struct _callee_saved and struct _caller_saved register layouts. The second file contains anything that needs what is provided by the common stuff in kernel_structs.h. Those two files are only meant to be included in kernel_structs.h in very specific locations. The thread data structure has been separated into three major parts: common struct _thread_base and struct k_thread, and arch-specific struct _thread_arch. The first and third ones are included in the second. The struct s_NANO data structure has been split into two: common struct _kernel and arch-specific struct _kernel_arch. The latter is included in the former. Offsets files have also changed: nano_offsets.h has been renamed kernel_offsets.h and is still included by the arch-specific offsets.c. Also, since the thread and kernel data structures are now made of sub-structures, offsets have to be added to make up the full offset. Some of these additions have been consolidated in shorter symbols, available from kernel/unified/include/offsets_short.h, which includes an arch-specific offsets_arch_short.h. Most of the code include offsets_short.h now instead of offsets.h. Change-Id: I084645cb7e6db8db69aeaaf162963fe157045d5a Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-11-08 23:36:50 +08:00
#define _is_in_isr() _IsInIsr()
extern void _IntLibInit(void);
#endif /* _ASMLANGUAGE */
#ifdef __cplusplus
}
#endif
#endif /* _kernel_arch_func__h_ */