diff --git a/include/cmsis_rtos_v1/cmsis_os.h b/include/cmsis_rtos_v1/cmsis_os.h index 0025f87a46c..d275490c06f 100644 --- a/include/cmsis_rtos_v1/cmsis_os.h +++ b/include/cmsis_rtos_v1/cmsis_os.h @@ -66,6 +66,7 @@ #include #include +#include #ifdef __cplusplus extern "C" @@ -166,6 +167,8 @@ typedef struct os_thread_def { osPriority tpriority; ///< initial thread priority uint32_t instances; ///< maximum number of instances of that thread function uint32_t stacksize; ///< stack size requirements in bytes; 0 is default stack size + void *stack_mem; ///< pointer to array of stack memory + struct k_thread *cm_thread; ///< pointer to k_thread structure } osThreadDef_t; /// Timer Definition structure contains timer parameters. @@ -276,8 +279,10 @@ uint32_t osKernelSysTick (void); extern const osThreadDef_t os_thread_def_##name #else // define the object #define osThreadDef(name, priority, instances, stacksz) \ -const osThreadDef_t os_thread_def_##name = \ -{ (name), (priority), (instances), (stacksz) } +static K_THREAD_STACK_ARRAY_DEFINE(stacks_##name, instances, CONFIG_CMSIS_THREAD_MAX_STACK_SIZE); \ +static struct k_thread cm_thread_##name[instances]; \ +static osThreadDef_t os_thread_def_##name = \ +{ (name), (priority), (instances), (stacksz), (void *)(stacks_##name), (cm_thread_##name)} #endif /// Access a Thread definition. diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 8d09fa90721..d53371fb9c7 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -8,4 +8,5 @@ add_subdirectory_if_kconfig(ring_buffer) add_subdirectory_if_kconfig(base64) add_subdirectory(mempool) add_subdirectory_ifdef(CONFIG_PTHREAD_IPC posix) +add_subdirectory_ifdef(CONFIG_CMSIS_RTOS_V1 cmsis_rtos_v1) add_subdirectory(rbtree) diff --git a/lib/Kconfig b/lib/Kconfig index e4edc6fdd35..a4203873a19 100644 --- a/lib/Kconfig +++ b/lib/Kconfig @@ -31,4 +31,5 @@ config BASE64 source "lib/posix/Kconfig" +source "lib/cmsis_rtos_v1/Kconfig" endmenu diff --git a/lib/cmsis_rtos_v1/CMakeLists.txt b/lib/cmsis_rtos_v1/CMakeLists.txt new file mode 100644 index 00000000000..4a1fdc4d4a7 --- /dev/null +++ b/lib/cmsis_rtos_v1/CMakeLists.txt @@ -0,0 +1,10 @@ + +add_library(CMSIS INTERFACE) + +target_include_directories(CMSIS INTERFACE ${PROJECT_SOURCE_DIR}/include/cmsis_rtos_v1) + +zephyr_library() +zephyr_library_sources_ifdef(CONFIG_CMSIS_RTOS_V1 cmsis_thread.c) + +zephyr_library_link_libraries(CMSIS) +target_link_libraries(CMSIS INTERFACE zephyr_interface) diff --git a/lib/cmsis_rtos_v1/Kconfig b/lib/cmsis_rtos_v1/Kconfig new file mode 100644 index 00000000000..b55e7d61fb2 --- /dev/null +++ b/lib/cmsis_rtos_v1/Kconfig @@ -0,0 +1,36 @@ +# +# Copyright (c) 2018 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 +# +config CMSIS_RTOS_V1 + bool + prompt "CMSIS RTOS v1 API" + default n + help + This enables CMSIS RTOS v1 API support. This is an OS-integration + layer which allows applications using CMSIS RTOS APIs to build on + Zephyr. + +if CMSIS_RTOS_V1 +config CMSIS_MAX_THREAD_COUNT + int + prompt "Maximum thread count in CMSIS RTOS application" + default 10 + range 0 255 + help + Mention max number of threads in CMSIS RTOS compliant application. + There's a limitation on the number of threads due to memory + related constraints. + +config CMSIS_THREAD_MAX_STACK_SIZE + int + prompt "Max stack size threads can be allocated in CMSIS RTOS application" + default 512 + help + Mention max stack size threads can be allocated in CMSIS RTOS application. + +config NUM_PREEMPT_PRIORITIES + int + default 7 +endif diff --git a/lib/cmsis_rtos_v1/cmsis_thread.c b/lib/cmsis_rtos_v1/cmsis_thread.c new file mode 100644 index 00000000000..b3788ff25a6 --- /dev/null +++ b/lib/cmsis_rtos_v1/cmsis_thread.c @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2018 Intel Corporation + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include + +static inline int _is_thread_cmsis_inactive(struct k_thread *thread) +{ + u8_t state = thread->base.thread_state; + + return state & (_THREAD_PRESTART | _THREAD_DEAD); +} + +static inline s32_t zephyr_to_cmsis_priority(u32_t z_prio) +{ + return(osPriorityRealtime - z_prio); +} + +static inline u32_t cmsis_to_zephyr_priority(s32_t c_prio) +{ + return(osPriorityRealtime - c_prio); +} + +static void zephyr_thread_wrapper(void *arg1, void *arg2, void *arg3) +{ + void * (*fun_ptr)(void *) = arg3; + + fun_ptr(arg1); +} + +/** + * @brief Create a new thread. + */ +osThreadId osThreadCreate(const osThreadDef_t *thread_def, void *arg) +{ + struct k_thread *cm_thread; + u32_t prio; + k_tid_t tid; + u32_t stacksz; + + k_thread_stack_t + (*stk_ptr)[K_THREAD_STACK_LEN(CONFIG_CMSIS_THREAD_MAX_STACK_SIZE)]; + + __ASSERT(thread_def->stacksize >= 0 && + thread_def->stacksize <= CONFIG_CMSIS_THREAD_MAX_STACK_SIZE, + "invalid stack size\n"); + + if (thread_def->instances == 0) { + return NULL; + } + + if (_is_in_isr()) { + return NULL; + } + + stacksz = thread_def->stacksize; + if (stacksz == 0) { + stacksz = CONFIG_CMSIS_THREAD_MAX_STACK_SIZE; + } + + cm_thread = thread_def->cm_thread; + atomic_dec((atomic_t *)&thread_def->instances); + stk_ptr = thread_def->stack_mem; + prio = cmsis_to_zephyr_priority(thread_def->tpriority); + + tid = k_thread_create(&cm_thread[thread_def->instances], + stk_ptr[thread_def->instances], stacksz, + (k_thread_entry_t)zephyr_thread_wrapper, + (void *)arg, NULL, thread_def->pthread, + prio, 0, K_NO_WAIT); + + return ((osThreadId)tid); +} + +/** + * @brief Return the thread ID of the current running thread. + */ +osThreadId osThreadGetId(void) +{ + if (_is_in_isr()) { + return NULL; + } + + return (osThreadId)k_current_get(); +} + +/** + * @brief Get current priority of an active thread. + */ +osPriority osThreadGetPriority(osThreadId thread_id) +{ + k_tid_t thread = (k_tid_t)thread_id; + u32_t priority; + + if (_is_in_isr()) { + return osPriorityError; + } + + priority = k_thread_priority_get(thread); + return zephyr_to_cmsis_priority(priority); +} + +/** + * @brief Change priority of an active thread. + */ +osStatus osThreadSetPriority(osThreadId thread_id, osPriority priority) +{ + if (thread_id == NULL) { + return osErrorParameter; + } + + if (_is_in_isr()) { + return osErrorISR; + } + + if (priority < osPriorityIdle || priority > osPriorityRealtime) { + return osErrorValue; + } + + if (_is_thread_cmsis_inactive((k_tid_t)thread_id)) { + return osErrorResource; + } + + k_thread_priority_set((k_tid_t)thread_id, + cmsis_to_zephyr_priority(priority)); + + return osOK; +} + +/** + * @brief Terminate execution of a thread. + */ +osStatus osThreadTerminate(osThreadId thread_id) +{ + if (thread_id == NULL) { + return osErrorParameter; + } + + if (_is_in_isr()) { + return osErrorISR; + } + + if (_is_thread_cmsis_inactive((k_tid_t)thread_id)) { + return osErrorResource; + } + + k_thread_abort((k_tid_t)thread_id); + return osOK; +} + +/** + * @brief Pass control to next thread that is in READY state. + */ +osStatus osThreadYield(void) +{ + if (_is_in_isr()) { + return osErrorISR; + } + + k_yield(); + return osOK; +}