476 lines
21 KiB
C
476 lines
21 KiB
C
/*
|
|
* Copyright (c) 2013-2017 ARM Limited. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the License); you may
|
|
* not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* -----------------------------------------------------------------------------
|
|
*
|
|
* Project: CMSIS-RTOS RTX
|
|
* Title: RTX OS definitions
|
|
*
|
|
* -----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#ifndef RTX_OS_H_
|
|
#define RTX_OS_H_
|
|
|
|
#include <stdint.h>
|
|
#include <stddef.h>
|
|
#include "cmsis_os2.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
|
|
|
|
/// Kernel Information
|
|
#define osRtxVersionAPI 20010000 ///< API version (2.1.0)
|
|
#define osRtxVersionKernel 50010000 ///< Kernel version (5.1.0)
|
|
#define osRtxKernelId "RTX V5.1.0" ///< Kernel identification string
|
|
|
|
|
|
// ==== Common definitions ====
|
|
|
|
/// Object Identifier definitions
|
|
#define osRtxIdInvalid 0x00U
|
|
#define osRtxIdThread 0x01U
|
|
#define osRtxIdTimer 0x02U
|
|
#define osRtxIdEventFlags 0x03U
|
|
#define osRtxIdMutex 0x04U
|
|
#define osRtxIdSemaphore 0x05U
|
|
#define osRtxIdMemoryPool 0x06U
|
|
#define osRtxIdMessage 0x07U
|
|
#define osRtxIdMessageQueue 0x08U
|
|
|
|
/// Object State definitions (except for Threads and Timers)
|
|
#define osRtxObjectInactive 0x00U
|
|
#define osRtxObjectActive 0x01U
|
|
|
|
/// Object Flags definitions
|
|
#define osRtxFlagSystemObject 0x01U
|
|
#define osRtxFlagSystemMemory 0x02U
|
|
|
|
|
|
// ==== Kernel definitions ====
|
|
|
|
/// Kernel State definitions
|
|
#define osRtxKernelInactive ((uint8_t)osKernelInactive)
|
|
#define osRtxKernelReady ((uint8_t)osKernelReady)
|
|
#define osRtxKernelRunning ((uint8_t)osKernelRunning)
|
|
#define osRtxKernelLocked ((uint8_t)osKernelLocked)
|
|
#define osRtxKernelSuspended ((uint8_t)osKernelSuspended)
|
|
|
|
|
|
// ==== Thread definitions ====
|
|
|
|
/// Thread State definitions (extending osThreadState)
|
|
#define osRtxThreadStateMask 0x0FU
|
|
|
|
#define osRtxThreadInactive ((uint8_t)osThreadInactive)
|
|
#define osRtxThreadReady ((uint8_t)osThreadReady)
|
|
#define osRtxThreadRunning ((uint8_t)osThreadRunning)
|
|
#define osRtxThreadBlocked ((uint8_t)osThreadBlocked)
|
|
#define osRtxThreadTerminated ((uint8_t)osThreadTerminated)
|
|
|
|
#define osRtxThreadWaitingDelay (osRtxThreadBlocked | 0x10U)
|
|
#define osRtxThreadWaitingJoin (osRtxThreadBlocked | 0x20U)
|
|
#define osRtxThreadWaitingThreadFlags (osRtxThreadBlocked | 0x30U)
|
|
#define osRtxThreadWaitingEventFlags (osRtxThreadBlocked | 0x40U)
|
|
#define osRtxThreadWaitingMutex (osRtxThreadBlocked | 0x50U)
|
|
#define osRtxThreadWaitingSemaphore (osRtxThreadBlocked | 0x60U)
|
|
#define osRtxThreadWaitingMemoryPool (osRtxThreadBlocked | 0x70U)
|
|
#define osRtxThreadWaitingMessageGet (osRtxThreadBlocked | 0x80U)
|
|
#define osRtxThreadWaitingMessagePut (osRtxThreadBlocked | 0x90U)
|
|
|
|
/// Thread Flags definitions
|
|
#define osRtxThreadFlagDefStack 0x10U ///< Default Stack flag
|
|
|
|
/// Stack Marker definitions
|
|
#define osRtxStackMagicWord 0xE25A2EA5U ///< Stack Magic Word (Stack Base)
|
|
#define osRtxStackFillPattern 0xCCCCCCCCU ///< Stack Fill Pattern
|
|
|
|
/// Thread Control Block
|
|
typedef struct osRtxThread_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t attr; ///< Object Attributes
|
|
const char *name; ///< Object Name
|
|
struct osRtxThread_s *thread_next; ///< Link pointer to next Thread in Object list
|
|
struct osRtxThread_s *thread_prev; ///< Link pointer to previous Thread in Object list
|
|
struct osRtxThread_s *delay_next; ///< Link pointer to next Thread in Delay list
|
|
struct osRtxThread_s *delay_prev; ///< Link pointer to previous Thread in Delay list
|
|
struct osRtxThread_s *thread_join; ///< Thread waiting to Join
|
|
uint32_t delay; ///< Delay Time
|
|
int8_t priority; ///< Thread Priority
|
|
int8_t priority_base; ///< Base Priority
|
|
uint8_t stack_frame; ///< Stack Frame (EXC_RETURN[7..0])
|
|
uint8_t flags_options; ///< Thread/Event Flags Options
|
|
uint32_t wait_flags; ///< Waiting Thread/Event Flags
|
|
uint32_t thread_flags; ///< Thread Flags
|
|
struct osRtxMutex_s *mutex_list; ///< Link pointer to list of owned Mutexes
|
|
void *stack_mem; ///< Stack Memory
|
|
uint32_t stack_size; ///< Stack Size
|
|
uint32_t sp; ///< Current Stack Pointer
|
|
uint32_t thread_addr; ///< Thread entry address
|
|
uint32_t tz_memory; ///< TrustZone Memory Identifier
|
|
} osRtxThread_t;
|
|
|
|
|
|
// ==== Timer definitions ====
|
|
|
|
/// Timer State definitions
|
|
#define osRtxTimerInactive 0x00U ///< Timer Inactive
|
|
#define osRtxTimerStopped 0x01U ///< Timer Stopped
|
|
#define osRtxTimerRunning 0x02U ///< Timer Running
|
|
|
|
/// Timer Type definitions
|
|
#define osRtxTimerPeriodic ((uint8_t)osTimerPeriodic)
|
|
|
|
/// Timer Function Information
|
|
typedef struct {
|
|
void *fp; ///< Function Pointer
|
|
void *arg; ///< Function Argument
|
|
} osRtxTimerFinfo_t;
|
|
|
|
/// Timer Control Block
|
|
typedef struct osRtxTimer_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t type; ///< Timer Type (Periodic/One-shot)
|
|
const char *name; ///< Object Name
|
|
struct osRtxTimer_s *prev; ///< Pointer to previous active Timer
|
|
struct osRtxTimer_s *next; ///< Pointer to next active Timer
|
|
uint32_t tick; ///< Timer current Tick
|
|
uint32_t load; ///< Timer Load value
|
|
osRtxTimerFinfo_t finfo; ///< Timer Function Info
|
|
} osRtxTimer_t;
|
|
|
|
|
|
// ==== Event Flags definitions ====
|
|
|
|
/// Event Flags Control Block
|
|
typedef struct osRtxEventFlags_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t reserved;
|
|
const char *name; ///< Object Name
|
|
osRtxThread_t *thread_list; ///< Waiting Threads List
|
|
uint32_t event_flags; ///< Event Flags
|
|
} osRtxEventFlags_t;
|
|
|
|
|
|
// ==== Mutex definitions ====
|
|
|
|
/// Mutex Control Block
|
|
typedef struct osRtxMutex_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t attr; ///< Object Attributes
|
|
const char *name; ///< Object Name
|
|
osRtxThread_t *thread_list; ///< Waiting Threads List
|
|
osRtxThread_t *owner_thread; ///< Owner Thread
|
|
struct osRtxMutex_s *owner_prev; ///< Pointer to previous owned Mutex
|
|
struct osRtxMutex_s *owner_next; ///< Pointer to next owned Mutex
|
|
uint8_t lock; ///< Lock counter
|
|
uint8_t padding[3];
|
|
} osRtxMutex_t;
|
|
|
|
|
|
// ==== Semaphore definitions ====
|
|
|
|
/// Semaphore Control Block
|
|
typedef struct osRtxSemaphore_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t reserved;
|
|
const char *name; ///< Object Name
|
|
osRtxThread_t *thread_list; ///< Waiting Threads List
|
|
uint16_t tokens; ///< Current number of tokens
|
|
uint16_t max_tokens; ///< Maximum number of tokens
|
|
} osRtxSemaphore_t;
|
|
|
|
|
|
// ==== Memory Pool definitions ====
|
|
|
|
/// Memory Pool Information
|
|
typedef struct osRtxMpInfo_s {
|
|
uint32_t max_blocks; ///< Maximum number of Blocks
|
|
uint32_t used_blocks; ///< Number of used Blocks
|
|
uint32_t block_size; ///< Block Size
|
|
void *block_base; ///< Block Memory Base Address
|
|
void *block_lim; ///< Block Memory Limit Address
|
|
void *block_free; ///< First free Block Address
|
|
} osRtxMpInfo_t;
|
|
|
|
/// Memory Pool Control Block
|
|
typedef struct osRtxMemoryPool_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t reserved;
|
|
const char *name; ///< Object Name
|
|
osRtxThread_t *thread_list; ///< Waiting Threads List
|
|
osRtxMpInfo_t mp_info; ///< Memory Pool Info
|
|
} osRtxMemoryPool_t;
|
|
|
|
|
|
// ==== Message Queue definitions ====
|
|
|
|
/// Message Control Block
|
|
typedef struct osRtxMessage_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t priority; ///< Message Priority
|
|
struct osRtxMessage_s *prev; ///< Pointer to previous Message
|
|
struct osRtxMessage_s *next; ///< Pointer to next Message
|
|
} osRtxMessage_t;
|
|
|
|
/// Message Queue Control Block
|
|
typedef struct osRtxMessageQueue_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t reserved;
|
|
const char *name; ///< Object Name
|
|
osRtxThread_t *thread_list; ///< Waiting Threads List
|
|
osRtxMpInfo_t mp_info; ///< Memory Pool Info
|
|
uint32_t msg_size; ///< Message Size
|
|
uint32_t msg_count; ///< Number of queued Messages
|
|
osRtxMessage_t *msg_first; ///< Pointer to first Message
|
|
osRtxMessage_t *msg_last; ///< Pointer to last Message
|
|
} osRtxMessageQueue_t;
|
|
|
|
|
|
// ==== Generic Object definitions ====
|
|
|
|
/// Generic Object Control Block
|
|
typedef struct osRtxObject_s {
|
|
uint8_t id; ///< Object Identifier
|
|
uint8_t state; ///< Object State
|
|
uint8_t flags; ///< Object Flags
|
|
uint8_t reserved;
|
|
const char *name; ///< Object Name
|
|
osRtxThread_t *thread_list; ///< Threads List
|
|
} osRtxObject_t;
|
|
|
|
|
|
// ==== OS Runtime Information definitions ====
|
|
|
|
/// OS Runtime Information structure
|
|
typedef struct {
|
|
const char *os_id; ///< OS Identification
|
|
uint32_t version; ///< OS Version
|
|
struct { ///< Kernel Info
|
|
uint8_t state; ///< State
|
|
volatile uint8_t blocked; ///< Blocked
|
|
uint8_t pendISR; ///< Pending ISR (SV and SysTick)
|
|
uint8_t pendSV; ///< Pending SV
|
|
uint32_t sys_freq; ///< System Frequency
|
|
uint64_t tick; ///< Tick counter
|
|
} kernel;
|
|
int32_t tick_irqn; ///< Tick Timer IRQ Number
|
|
struct { ///< Thread Info
|
|
struct { ///< Thread Run Info
|
|
osRtxThread_t *curr; ///< Current running Thread
|
|
osRtxThread_t *next; ///< Next Thread to Run
|
|
} run;
|
|
volatile osRtxObject_t ready; ///< Ready List Object
|
|
osRtxThread_t *idle; ///< Idle Thread
|
|
osRtxThread_t *delay_list; ///< Delay List
|
|
osRtxThread_t *wait_list; ///< Wait List (no Timeout)
|
|
osRtxThread_t *terminate_list; ///< Terminate Thread List
|
|
struct { ///< Thread Round Robin Info
|
|
osRtxThread_t *thread; ///< Round Robin Thread
|
|
uint32_t tick; ///< Round Robin Time Tick
|
|
uint32_t timeout; ///< Round Robin Timeout
|
|
} robin;
|
|
} thread;
|
|
struct { ///< Timer Info
|
|
osRtxTimer_t *list; ///< Active Timer List
|
|
osRtxThread_t *thread; ///< Timer Thread
|
|
osRtxMessageQueue_t *mq; ///< Timer Message Queue
|
|
} timer;
|
|
struct { ///< ISR Post Processing Queue
|
|
uint16_t max; ///< Maximum Items
|
|
uint16_t cnt; ///< Item Count
|
|
uint16_t in; ///< Incoming Item Index
|
|
uint16_t out; ///< Outgoing Item Index
|
|
void **data; ///< Queue Data
|
|
} isr_queue;
|
|
struct { ///< ISR Post Processing functions
|
|
void (*thread)(osRtxThread_t*); ///< Thread Post Processing function
|
|
void (*event_flags)(osRtxEventFlags_t*); ///< Event Flags Post Processing function
|
|
void (*semaphore)(osRtxSemaphore_t*); ///< Semaphore Post Processing function
|
|
void (*memory_pool)(osRtxMemoryPool_t*); ///< Memory Pool Post Processing function
|
|
void (*message_queue)(osRtxMessage_t*); ///< Message Queue Post Processing function
|
|
} post_process;
|
|
struct { ///< Memory Pools (Variable Block Size)
|
|
void *stack; ///< Stack Memory
|
|
void *mp_data; ///< Memory Pool Data Memory
|
|
void *mq_data; ///< Message Queue Data Memory
|
|
void *common; ///< Common Memory
|
|
} mem;
|
|
struct { ///< Memory Pools (Fixed Block Size)
|
|
osRtxMpInfo_t *stack; ///< Stack for Threads
|
|
osRtxMpInfo_t *thread; ///< Thread Control Blocks
|
|
osRtxMpInfo_t *timer; ///< Timer Control Blocks
|
|
osRtxMpInfo_t *event_flags; ///< Event Flags Control Blocks
|
|
osRtxMpInfo_t *mutex; ///< Mutex Control Blocks
|
|
osRtxMpInfo_t *semaphore; ///< Semaphore Control Blocks
|
|
osRtxMpInfo_t *memory_pool; ///< Memory Pool Control Blocks
|
|
osRtxMpInfo_t *message_queue; ///< Message Queue Control Blocks
|
|
} mpi;
|
|
} osRtxInfo_t;
|
|
|
|
extern osRtxInfo_t osRtxInfo; ///< OS Runtime Information
|
|
|
|
|
|
// ==== OS API definitions ====
|
|
|
|
/// Object Limits definitions
|
|
#define osRtxThreadFlagsLimit 31U ///< number of Thread Flags available per thread
|
|
#define osRtxEventFlagsLimit 31U ///< number of Event Flags available per object
|
|
#define osRtxMutexLockLimit 255U ///< maximum number of recursive mutex locks
|
|
#define osRtxSemaphoreTokenLimit 65535U ///< maximum number of tokens per semaphore
|
|
|
|
/// Control Block sizes
|
|
#define osRtxThreadCbSize sizeof(osRtxThread_t)
|
|
#define osRtxTimerCbSize sizeof(osRtxTimer_t)
|
|
#define osRtxEventFlagsCbSize sizeof(osRtxEventFlags_t)
|
|
#define osRtxMutexCbSize sizeof(osRtxMutex_t)
|
|
#define osRtxSemaphoreCbSize sizeof(osRtxSemaphore_t)
|
|
#define osRtxMemoryPoolCbSize sizeof(osRtxMemoryPool_t)
|
|
#define osRtxMessageQueueCbSize sizeof(osRtxMessageQueue_t)
|
|
|
|
/// Memory size in bytes for Memory Pool storage.
|
|
/// \param block_count maximum number of memory blocks in memory pool.
|
|
/// \param block_size memory block size in bytes.
|
|
#define osRtxMemoryPoolMemSize(block_count, block_size) \
|
|
(4*(block_count)*(((block_size)+3)/4))
|
|
|
|
/// Memory size in bytes for Message Queue storage.
|
|
/// \param msg_count maximum number of messages in queue.
|
|
/// \param msg_size maximum message size in bytes.
|
|
#define osRtxMessageQueueMemSize(msg_count, msg_size) \
|
|
(4*(msg_count)*(3+(((msg_size)+3)/4)))
|
|
|
|
|
|
// ==== OS External Functions ====
|
|
|
|
/// OS Error Codes
|
|
#define osRtxErrorStackUnderflow 1U
|
|
#define osRtxErrorISRQueueOverflow 2U
|
|
#define osRtxErrorTimerQueueOverflow 3U
|
|
#define osRtxErrorClibSpace 4U
|
|
#define osRtxErrorClibMutex 5U
|
|
|
|
/// OS Error Callback function
|
|
extern uint32_t osRtxErrorNotify (uint32_t code, void *object_id);
|
|
|
|
/// OS Idle Thread
|
|
extern void osRtxIdleThread (void *argument);
|
|
|
|
/// OS Exception handlers
|
|
extern void SVC_Handler (void);
|
|
extern void PendSV_Handler (void);
|
|
extern void SysTick_Handler (void);
|
|
|
|
|
|
/// OS System Timer functions (default implementation uses SysTick)
|
|
|
|
/// Setup System Timer.
|
|
/// \return system timer IRQ number.
|
|
extern int32_t osRtxSysTimerSetup (void);
|
|
|
|
/// Enable System Timer.
|
|
extern void osRtxSysTimerEnable (void);
|
|
|
|
/// Disable System Timer.
|
|
extern void osRtxSysTimerDisable (void);
|
|
|
|
/// Acknowledge System Timer IRQ.
|
|
extern void osRtxSysTimerAckIRQ (void);
|
|
|
|
/// Get System Timer count.
|
|
/// \return system timer count.
|
|
extern uint32_t osRtxSysTimerGetCount (void);
|
|
|
|
/// Get System Timer frequency.
|
|
/// \return system timer frequency.
|
|
extern uint32_t osRtxSysTimerGetFreq (void);
|
|
|
|
|
|
// ==== OS External Configuration ====
|
|
|
|
/// OS Configuration flags
|
|
#define osRtxConfigPrivilegedMode (1UL<<0) ///< Threads in Privileged mode
|
|
#define osRtxConfigStackCheck (1UL<<1) ///< Stack overrun checking
|
|
#define osRtxConfigStackWatermark (1UL<<2) ///< Stack usage Watermark
|
|
|
|
/// OS Configuration structure
|
|
typedef struct {
|
|
uint32_t flags; ///< OS Configuration Flags
|
|
uint32_t tick_freq; ///< Kernel Tick Frequency
|
|
uint32_t robin_timeout; ///< Round Robin Timeout Tick
|
|
struct { ///< ISR Post Processing Queue
|
|
void **data; ///< Queue Data
|
|
uint16_t max; ///< Maximum Items
|
|
uint16_t padding;
|
|
} isr_queue;
|
|
struct { ///< Memory Pools (Variable Block Size)
|
|
void *stack_addr; ///< Stack Memory Address
|
|
uint32_t stack_size; ///< Stack Memory Size
|
|
void *mp_data_addr; ///< Memory Pool Memory Address
|
|
uint32_t mp_data_size; ///< Memory Pool Memory Size
|
|
void *mq_data_addr; ///< Message Queue Data Memory Address
|
|
uint32_t mq_data_size; ///< Message Queue Data Memory Size
|
|
void *common_addr; ///< Common Memory Address
|
|
uint32_t common_size; ///< Common Memory Size
|
|
} mem;
|
|
struct { ///< Memory Pools (Fixed Block Size)
|
|
osRtxMpInfo_t *stack; ///< Stack for Threads
|
|
osRtxMpInfo_t *thread; ///< Thread Control Blocks
|
|
osRtxMpInfo_t *timer; ///< Timer Control Blocks
|
|
osRtxMpInfo_t *event_flags; ///< Event Flags Control Blocks
|
|
osRtxMpInfo_t *mutex; ///< Mutex Control Blocks
|
|
osRtxMpInfo_t *semaphore; ///< Semaphore Control Blocks
|
|
osRtxMpInfo_t *memory_pool; ///< Memory Pool Control Blocks
|
|
osRtxMpInfo_t *message_queue; ///< Message Queue Control Blocks
|
|
} mpi;
|
|
uint32_t thread_stack_size; ///< Default Thread Stack Size
|
|
const
|
|
osThreadAttr_t *idle_thread_attr; ///< Idle Thread Attributes
|
|
const
|
|
osThreadAttr_t *timer_thread_attr; ///< Timer Thread Attributes
|
|
const
|
|
osMessageQueueAttr_t *timer_mq_attr; ///< Timer Message Queue Attributes
|
|
uint32_t timer_mq_mcnt; ///< Timer Message Queue maximum Messages
|
|
} osRtxConfig_t;
|
|
|
|
extern const osRtxConfig_t osRtxConfig; ///< OS Configuration
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // RTX_OS_H_
|