#include "tx_port.h"

Classes
struct	TX_TIMER_INTERNAL_STRUCT

struct	TX_TIMER_STRUCT

struct	TX_THREAD_STRUCT

struct	TX_BLOCK_POOL_STRUCT

struct	TX_BYTE_POOL_STRUCT

struct	TX_EVENT_FLAGS_GROUP_STRUCT

struct	TX_MUTEX_STRUCT

struct	TX_QUEUE_STRUCT

struct	TX_SEMAPHORE_STRUCT

Macros
#define	TX_PARAMETER_NOT_USED(p) ((void)(p))
	ThreadX Component More...

#define	AZURE_RTOS_THREADX

#define	THREADX_MAJOR_VERSION 6

#define	THREADX_MINOR_VERSION 1

#define	THREADX_PATCH_VERSION 11

#define	EL_PRODUCT_THREADX

#define	TX_NO_WAIT ((ULONG) 0)

#define	TX_WAIT_FOREVER ((ULONG) 0xFFFFFFFFUL)

#define	TX_AND ((UINT) 2)

#define	TX_AND_CLEAR ((UINT) 3)

#define	TX_OR ((UINT) 0)

#define	TX_OR_CLEAR ((UINT) 1)

#define	TX_1_ULONG ((UINT) 1)

#define	TX_2_ULONG ((UINT) 2)

#define	TX_4_ULONG ((UINT) 4)

#define	TX_8_ULONG ((UINT) 8)

#define	TX_16_ULONG ((UINT) 16)

#define	TX_NO_TIME_SLICE ((ULONG) 0)

#define	TX_AUTO_START ((UINT) 1)

#define	TX_DONT_START ((UINT) 0)

#define	TX_AUTO_ACTIVATE ((UINT) 1)

#define	TX_NO_ACTIVATE ((UINT) 0)

#define	TX_TRUE ((UINT) 1)

#define	TX_FALSE ((UINT) 0)

#define	TX_NULL ((void *) 0)

#define	TX_INHERIT ((UINT) 1)

#define	TX_NO_INHERIT ((UINT) 0)

#define	TX_THREAD_ENTRY ((UINT) 0)

#define	TX_THREAD_EXIT ((UINT) 1)

#define	TX_NO_SUSPENSIONS ((UINT) 0)

#define	TX_NO_MESSAGES ((UINT) 0)

#define	TX_EMPTY ((ULONG) 0)

#define	TX_CLEAR_ID ((ULONG) 0)

#define	TX_STACK_FILL ((ULONG) 0xEFEFEFEFUL)

#define	TX_READY ((UINT) 0)

#define	TX_COMPLETED ((UINT) 1)

#define	TX_TERMINATED ((UINT) 2)

#define	TX_SUSPENDED ((UINT) 3)

#define	TX_SLEEP ((UINT) 4)

#define	TX_QUEUE_SUSP ((UINT) 5)

#define	TX_SEMAPHORE_SUSP ((UINT) 6)

#define	TX_EVENT_FLAG ((UINT) 7)

#define	TX_BLOCK_MEMORY ((UINT) 8)

#define	TX_BYTE_MEMORY ((UINT) 9)

#define	TX_IO_DRIVER ((UINT) 10)

#define	TX_FILE ((UINT) 11)

#define	TX_TCP_IP ((UINT) 12)

#define	TX_MUTEX_SUSP ((UINT) 13)

#define	TX_PRIORITY_CHANGE ((UINT) 14)

#define	TX_SUCCESS ((UINT) 0x00)

#define	TX_DELETED ((UINT) 0x01)

#define	TX_POOL_ERROR ((UINT) 0x02)

#define	TX_PTR_ERROR ((UINT) 0x03)

#define	TX_WAIT_ERROR ((UINT) 0x04)

#define	TX_SIZE_ERROR ((UINT) 0x05)

#define	TX_GROUP_ERROR ((UINT) 0x06)

#define	TX_NO_EVENTS ((UINT) 0x07)

#define	TX_OPTION_ERROR ((UINT) 0x08)

#define	TX_QUEUE_ERROR ((UINT) 0x09)

#define	TX_QUEUE_EMPTY ((UINT) 0x0A)

#define	TX_QUEUE_FULL ((UINT) 0x0B)

#define	TX_SEMAPHORE_ERROR ((UINT) 0x0C)

#define	TX_NO_INSTANCE ((UINT) 0x0D)

#define	TX_THREAD_ERROR ((UINT) 0x0E)

#define	TX_PRIORITY_ERROR ((UINT) 0x0F)

#define	TX_NO_MEMORY ((UINT) 0x10)

#define	TX_START_ERROR ((UINT) 0x10)

#define	TX_DELETE_ERROR ((UINT) 0x11)

#define	TX_RESUME_ERROR ((UINT) 0x12)

#define	TX_CALLER_ERROR ((UINT) 0x13)

#define	TX_SUSPEND_ERROR ((UINT) 0x14)

#define	TX_TIMER_ERROR ((UINT) 0x15)

#define	TX_TICK_ERROR ((UINT) 0x16)

#define	TX_ACTIVATE_ERROR ((UINT) 0x17)

#define	TX_THRESH_ERROR ((UINT) 0x18)

#define	TX_SUSPEND_LIFTED ((UINT) 0x19)

#define	TX_WAIT_ABORTED ((UINT) 0x1A)

#define	TX_WAIT_ABORT_ERROR ((UINT) 0x1B)

#define	TX_MUTEX_ERROR ((UINT) 0x1C)

#define	TX_NOT_AVAILABLE ((UINT) 0x1D)

#define	TX_NOT_OWNED ((UINT) 0x1E)

#define	TX_INHERIT_ERROR ((UINT) 0x1F)

#define	TX_NOT_DONE ((UINT) 0x20)

#define	TX_CEILING_EXCEEDED ((UINT) 0x21)

#define	TX_INVALID_CEILING ((UINT) 0x22)

#define	TX_FEATURE_NOT_ENABLED ((UINT) 0xFF)

#define	TX_TIMER_TICKS_PER_SECOND (100UL)

#define	TX_TRACE_USER_EVENT_START 4096 /* I1, I2, I3, I4 are user defined */

#define	TX_TRACE_USER_EVENT_END 65535 /* I1, I2, I3, I4 are user defined */

#define	TX_TRACE_ALL_EVENTS 0x000007FF /* All ThreadX events */

#define	TX_TRACE_INTERNAL_EVENTS 0x00000001 /* ThreadX internal events */

#define	TX_TRACE_BLOCK_POOL_EVENTS 0x00000002 /* ThreadX Block Pool events */

#define	TX_TRACE_BYTE_POOL_EVENTS 0x00000004 /* ThreadX Byte Pool events */

#define	TX_TRACE_EVENT_FLAGS_EVENTS 0x00000008 /* ThreadX Event Flags events */

#define	TX_TRACE_INTERRUPT_CONTROL_EVENT 0x00000010 /* ThreadX Interrupt Control events */

#define	TX_TRACE_MUTEX_EVENTS 0x00000020 /* ThreadX Mutex events */

#define	TX_TRACE_QUEUE_EVENTS 0x00000040 /* ThreadX Queue events */

#define	TX_TRACE_SEMAPHORE_EVENTS 0x00000080 /* ThreadX Semaphore events */

#define	TX_TRACE_THREAD_EVENTS 0x00000100 /* ThreadX Thread events */

#define	TX_TRACE_TIME_EVENTS 0x00000200 /* ThreadX Time events */

#define	TX_TRACE_TIMER_EVENTS 0x00000400 /* ThreadX Timer events */

#define	TX_TRACE_USER_EVENTS 0x80000000UL /* ThreadX User Events */

#define	ALIGN_TYPE ULONG

#define	TX_TIMER_INTERNAL_EXTENSION

#define	TX_TIMER_EXTENSION

#define	TX_BYTE_ALLOCATE_EXTENSION

#define	TX_BYTE_RELEASE_EXTENSION

#define	TX_MUTEX_PUT_EXTENSION_1

#define	TX_MUTEX_PUT_EXTENSION_2

#define	TX_MUTEX_PRIORITY_CHANGE_EXTENSION

#define	tx_kernel_enter _tx_initialize_kernel_enter

#define	tx_block_allocate _txe_block_allocate

#define	tx_block_pool_create(p, n, b, s, l) _txe_block_pool_create((p),(n),(b),(s),(l),(sizeof(TX_BLOCK_POOL)))

#define	tx_block_pool_delete _txe_block_pool_delete

#define	tx_block_pool_info_get _txe_block_pool_info_get

#define	tx_block_pool_performance_info_get _tx_block_pool_performance_info_get

#define	tx_block_pool_performance_system_info_get _tx_block_pool_performance_system_info_get

#define	tx_block_pool_prioritize _txe_block_pool_prioritize

#define	tx_block_release _txe_block_release

#define	tx_byte_allocate _txe_byte_allocate

#define	tx_byte_pool_create(p, n, s, l) _txe_byte_pool_create((p),(n),(s),(l),(sizeof(TX_BYTE_POOL)))

#define	tx_byte_pool_delete _txe_byte_pool_delete

#define	tx_byte_pool_info_get _txe_byte_pool_info_get

#define	tx_byte_pool_performance_info_get _tx_byte_pool_performance_info_get

#define	tx_byte_pool_performance_system_info_get _tx_byte_pool_performance_system_info_get

#define	tx_byte_pool_prioritize _txe_byte_pool_prioritize

#define	tx_byte_release _txe_byte_release

#define	tx_event_flags_create(g, n) _txe_event_flags_create((g),(n),(sizeof(TX_EVENT_FLAGS_GROUP)))

#define	tx_event_flags_delete _txe_event_flags_delete

#define	tx_event_flags_get _txe_event_flags_get

#define	tx_event_flags_info_get _txe_event_flags_info_get

#define	tx_event_flags_performance_info_get _tx_event_flags_performance_info_get

#define	tx_event_flags_performance_system_info_get _tx_event_flags_performance_system_info_get

#define	tx_event_flags_set _txe_event_flags_set

#define	tx_event_flags_set_notify _txe_event_flags_set_notify

#define	tx_interrupt_control _tx_thread_interrupt_control

#define	tx_mutex_create(m, n, i) _txe_mutex_create((m),(n),(i),(sizeof(TX_MUTEX)))

#define	tx_mutex_delete _txe_mutex_delete

#define	tx_mutex_get _txe_mutex_get

#define	tx_mutex_info_get _txe_mutex_info_get

#define	tx_mutex_performance_info_get _tx_mutex_performance_info_get

#define	tx_mutex_performance_system_info_get _tx_mutex_performance_system_info_get

#define	tx_mutex_prioritize _txe_mutex_prioritize

#define	tx_mutex_put _txe_mutex_put

#define	tx_queue_create(q, n, m, s, l) _txe_queue_create((q),(n),(m),(s),(l),(sizeof(TX_QUEUE)))

#define	tx_queue_delete _txe_queue_delete

#define	tx_queue_flush _txe_queue_flush

#define	tx_queue_info_get _txe_queue_info_get

#define	tx_queue_performance_info_get _tx_queue_performance_info_get

#define	tx_queue_performance_system_info_get _tx_queue_performance_system_info_get

#define	tx_queue_receive _txe_queue_receive

#define	tx_queue_send _txe_queue_send

#define	tx_queue_send_notify _txe_queue_send_notify

#define	tx_queue_front_send _txe_queue_front_send

#define	tx_queue_prioritize _txe_queue_prioritize

#define	tx_semaphore_ceiling_put _txe_semaphore_ceiling_put

#define	tx_semaphore_create(s, n, i) _txe_semaphore_create((s),(n),(i),(sizeof(TX_SEMAPHORE)))

#define	tx_semaphore_delete _txe_semaphore_delete

#define	tx_semaphore_get _txe_semaphore_get

#define	tx_semaphore_info_get _txe_semaphore_info_get

#define	tx_semaphore_performance_info_get _tx_semaphore_performance_info_get

#define	tx_semaphore_performance_system_info_get _tx_semaphore_performance_system_info_get

#define	tx_semaphore_prioritize _txe_semaphore_prioritize

#define	tx_semaphore_put _txe_semaphore_put

#define	tx_semaphore_put_notify _txe_semaphore_put_notify

#define	tx_thread_create(t, n, e, i, s, l, p, r, c, a) _txe_thread_create((t),(n),(e),(i),(s),(l),(p),(r),(c),(a),(sizeof(TX_THREAD)))

#define	tx_thread_delete _txe_thread_delete

#define	tx_thread_entry_exit_notify _txe_thread_entry_exit_notify

#define	tx_thread_identify _tx_thread_identify

#define	tx_thread_info_get _txe_thread_info_get

#define	tx_thread_performance_info_get _tx_thread_performance_info_get

#define	tx_thread_performance_system_info_get _tx_thread_performance_system_info_get

#define	tx_thread_preemption_change _txe_thread_preemption_change

#define	tx_thread_priority_change _txe_thread_priority_change

#define	tx_thread_relinquish _txe_thread_relinquish

#define	tx_thread_reset _txe_thread_reset

#define	tx_thread_resume _txe_thread_resume

#define	tx_thread_sleep _tx_thread_sleep

#define	tx_thread_stack_error_notify _tx_thread_stack_error_notify

#define	tx_thread_suspend _txe_thread_suspend

#define	tx_thread_terminate _txe_thread_terminate

#define	tx_thread_time_slice_change _txe_thread_time_slice_change

#define	tx_thread_wait_abort _txe_thread_wait_abort

#define	tx_time_get _tx_time_get

#define	tx_time_set _tx_time_set

#define	tx_timer_activate _txe_timer_activate

#define	tx_timer_change _txe_timer_change

#define	tx_timer_create(t, n, e, i, c, r, a) _txe_timer_create((t),(n),(e),(i),(c),(r),(a),(sizeof(TX_TIMER)))

#define	tx_timer_deactivate _txe_timer_deactivate

#define	tx_timer_delete _txe_timer_delete

#define	tx_timer_info_get _txe_timer_info_get

#define	tx_timer_performance_info_get _tx_timer_performance_info_get

#define	tx_timer_performance_system_info_get _tx_timer_performance_system_info_get

#define	tx_trace_enable _tx_trace_enable

#define	tx_trace_event_filter _tx_trace_event_filter

#define	tx_trace_event_unfilter _tx_trace_event_unfilter

#define	tx_trace_disable _tx_trace_disable

#define	tx_trace_isr_enter_insert _tx_trace_isr_enter_insert

#define	tx_trace_isr_exit_insert _tx_trace_isr_exit_insert

#define	tx_trace_buffer_full_notify _tx_trace_buffer_full_notify

#define	tx_trace_user_event_insert _tx_trace_user_event_insert

#define	TX_THREAD_STARTED_EXTENSION(thread_ptr)

#define	TX_THREAD_STACK_ANALYZE_EXTENSION

#define	TX_INITIALIZE_KERNEL_ENTER_EXTENSION

#define	TX_MEMSET(a, b, c) memset((a),(b),(c))

#define	TX_UCHAR_POINTER_ADD(a, b) (((UCHAR *) (a)) + ((UINT) (b)))

#define	TX_UCHAR_POINTER_SUB(a, b) (((UCHAR *) (a)) - ((UINT) (b)))

#define	TX_UCHAR_POINTER_DIF(a, b) ((ULONG)(((UCHAR ) (a)) - ((UCHAR ) (b))))

#define	TX_ULONG_POINTER_ADD(a, b) (((ULONG *) (a)) + ((UINT) (b)))

#define	TX_ULONG_POINTER_SUB(a, b) (((ULONG *) (a)) - ((UINT) (b)))

#define	TX_ULONG_POINTER_DIF(a, b) ((ULONG)(((ULONG ) (a)) - ((ULONG ) (b))))

#define	TX_POINTER_TO_ULONG_CONVERT(a) ((ULONG) ((VOID *) (a)))

#define	TX_ULONG_TO_POINTER_CONVERT(a) ((VOID *) ((ULONG) (a)))

#define	TX_POINTER_TO_ALIGN_TYPE_CONVERT(a) ((ALIGN_TYPE) ((VOID *) (a)))

#define	TX_ALIGN_TYPE_TO_POINTER_CONVERT(a) ((VOID *) ((ALIGN_TYPE) (a)))

#define	TX_TIMER_POINTER_DIF(a, b) ((ULONG)(((TX_TIMER_INTERNAL ) (a)) - ((TX_TIMER_INTERNAL ) (b))))

#define	TX_TIMER_POINTER_ADD(a, b) (((TX_TIMER_INTERNAL **) (a)) + ((ULONG) (b)))

#define	TX_USER_TIMER_POINTER_GET(a, b)

#define	TX_LOOP_FOREVER ((UINT) 1)

#define	TX_INDIRECT_VOID_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR *) ((VOID ) (a)))

#define	TX_UCHAR_TO_INDIRECT_UCHAR_POINTER_CONVERT(a) ((UCHAR *) ((VOID ) (a)))

#define	TX_BLOCK_POOL_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR ) ((VOID ) (a)))

#define	TX_VOID_TO_BLOCK_POOL_POINTER_CONVERT(a) ((TX_BLOCK_POOL ) ((VOID ) (a)))

#define	TX_VOID_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR ) ((VOID ) (a)))

#define	TX_UCHAR_TO_BLOCK_POOL_POINTER_CONVERT(a) ((TX_BLOCK_POOL ) ((VOID ) (a)))

#define	TX_VOID_TO_INDIRECT_UCHAR_POINTER_CONVERT(a) ((UCHAR *) ((VOID ) (a)))

#define	TX_VOID_TO_BYTE_POOL_POINTER_CONVERT(a) ((TX_BYTE_POOL ) ((VOID ) (a)))

#define	TX_BYTE_POOL_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR ) ((VOID ) (a)))

#define	TX_UCHAR_TO_ALIGN_TYPE_POINTER_CONVERT(a) ((ALIGN_TYPE ) ((VOID ) (a)))

#define	TX_UCHAR_TO_INDIRECT_BYTE_POOL_POINTER(a) ((TX_BYTE_POOL *) ((VOID ) (a)))

#define	TX_VOID_TO_EVENT_FLAGS_POINTER_CONVERT(a) ((TX_EVENT_FLAGS_GROUP ) ((VOID ) (a)))

#define	TX_VOID_TO_ULONG_POINTER_CONVERT(a) ((ULONG ) ((VOID ) (a)))

#define	TX_VOID_TO_MUTEX_POINTER_CONVERT(a) ((TX_MUTEX ) ((VOID ) (a)))

#define	TX_VOID_TO_QUEUE_POINTER_CONVERT(a) ((TX_QUEUE ) ((VOID ) (a)))

#define	TX_VOID_TO_SEMAPHORE_POINTER_CONVERT(a) ((TX_SEMAPHORE ) ((VOID ) (a)))

#define	TX_UCHAR_TO_VOID_POINTER_CONVERT(a) ((VOID *) (a))

#define	TX_ULONG_TO_THREAD_POINTER_CONVERT(a) ((TX_THREAD ) ((VOID ) (a)))

#define	TX_TIMER_INDIRECT_TO_VOID_POINTER_CONVERT(a) ((VOID *) (a))

#define	TX_TIMER_INITIALIZE_EXTENSION(a)

#define	TX_CONST_CHAR_TO_CHAR_POINTER_CONVERT(a) ((CHAR ) ((VOID ) (a)))

#define	TX_VOID_TO_THREAD_POINTER_CONVERT(a) ((TX_THREAD ) ((VOID ) (a)))

#define	TX_CHAR_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR ) ((VOID ) (a)))

#define	TX_EVENT_FLAGS_GROUP_NOT_USED(a) ((void)(a))

#define	TX_EVENT_FLAGS_SET_NOTIFY_NOT_USED(a) ((void)(a))

#define	TX_QUEUE_NOT_USED(a) ((void)(a))

#define	TX_QUEUE_SEND_NOTIFY_NOT_USED(a) ((void)(a))

#define	TX_SEMAPHORE_NOT_USED(a) ((void)(a))

#define	TX_SEMAPHORE_PUT_NOTIFY_NOT_USED(a) ((void)(a))

#define	TX_THREAD_NOT_USED(a) ((void)(a))

#define	TX_THREAD_ENTRY_EXIT_NOTIFY_NOT_USED(a) ((void)(a))

#define	_tx_el_user_event_insert(a, b, c, d, e)

#define	TX_EL_INITIALIZE

#define	TX_EL_THREAD_REGISTER(a)

#define	TX_EL_THREAD_UNREGISTER(a)

#define	TX_EL_THREAD_STATUS_CHANGE_INSERT(a, b)

#define	TX_EL_BYTE_ALLOCATE_INSERT

#define	TX_EL_BYTE_POOL_CREATE_INSERT

#define	TX_EL_BYTE_POOL_DELETE_INSERT

#define	TX_EL_BYTE_RELEASE_INSERT

#define	TX_EL_BLOCK_ALLOCATE_INSERT

#define	TX_EL_BLOCK_POOL_CREATE_INSERT

#define	TX_EL_BLOCK_POOL_DELETE_INSERT

#define	TX_EL_BLOCK_RELEASE_INSERT

#define	TX_EL_EVENT_FLAGS_CREATE_INSERT

#define	TX_EL_EVENT_FLAGS_DELETE_INSERT

#define	TX_EL_EVENT_FLAGS_GET_INSERT

#define	TX_EL_EVENT_FLAGS_SET_INSERT

#define	TX_EL_INTERRUPT_CONTROL_INSERT

#define	TX_EL_QUEUE_CREATE_INSERT

#define	TX_EL_QUEUE_DELETE_INSERT

#define	TX_EL_QUEUE_FLUSH_INSERT

#define	TX_EL_QUEUE_RECEIVE_INSERT

#define	TX_EL_QUEUE_SEND_INSERT

#define	TX_EL_SEMAPHORE_CREATE_INSERT

#define	TX_EL_SEMAPHORE_DELETE_INSERT

#define	TX_EL_SEMAPHORE_GET_INSERT

#define	TX_EL_SEMAPHORE_PUT_INSERT

#define	TX_EL_THREAD_CREATE_INSERT

#define	TX_EL_THREAD_DELETE_INSERT

#define	TX_EL_THREAD_IDENTIFY_INSERT

#define	TX_EL_THREAD_PREEMPTION_CHANGE_INSERT

#define	TX_EL_THREAD_PRIORITY_CHANGE_INSERT

#define	TX_EL_THREAD_RELINQUISH_INSERT

#define	TX_EL_THREAD_RESUME_INSERT

#define	TX_EL_THREAD_SLEEP_INSERT

#define	TX_EL_THREAD_SUSPEND_INSERT

#define	TX_EL_THREAD_TERMINATE_INSERT

#define	TX_EL_THREAD_TIME_SLICE_CHANGE_INSERT

#define	TX_EL_TIME_GET_INSERT

#define	TX_EL_TIME_SET_INSERT

#define	TX_EL_TIMER_ACTIVATE_INSERT

#define	TX_EL_TIMER_CHANGE_INSERT

#define	TX_EL_TIMER_CREATE_INSERT

#define	TX_EL_TIMER_DEACTIVATE_INSERT

#define	TX_EL_TIMER_DELETE_INSERT

#define	TX_EL_BLOCK_POOL_INFO_GET_INSERT

#define	TX_EL_BLOCK_POOL_PRIORITIZE_INSERT

#define	TX_EL_BYTE_POOL_INFO_GET_INSERT

#define	TX_EL_BYTE_POOL_PRIORITIZE_INSERT

#define	TX_EL_EVENT_FLAGS_INFO_GET_INSERT

#define	TX_EL_MUTEX_CREATE_INSERT

#define	TX_EL_MUTEX_DELETE_INSERT

#define	TX_EL_MUTEX_GET_INSERT

#define	TX_EL_MUTEX_INFO_GET_INSERT

#define	TX_EL_MUTEX_PRIORITIZE_INSERT

#define	TX_EL_MUTEX_PUT_INSERT

#define	TX_EL_QUEUE_INFO_GET_INSERT

#define	TX_EL_QUEUE_FRONT_SEND_INSERT

#define	TX_EL_QUEUE_PRIORITIZE_INSERT

#define	TX_EL_SEMAPHORE_INFO_GET_INSERT

#define	TX_EL_SEMAPHORE_PRIORITIZE_INSERT

#define	TX_EL_THREAD_INFO_GET_INSERT

#define	TX_EL_THREAD_WAIT_ABORT_INSERT

#define	TX_EL_TIMER_INFO_GET_INSERT

#define	TX_EL_BLOCK_POOL_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_BYTE_POOL_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_EVENT_FLAGS_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_EVENT_FLAGS__PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_EVENT_FLAGS_SET_NOTIFY_INSERT

#define	TX_EL_MUTEX_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_QUEUE_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_QUEUE_SEND_NOTIFY_INSERT

#define	TX_EL_SEMAPHORE_CEILING_PUT_INSERT

#define	TX_EL_SEMAPHORE_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_SEMAPHORE_PUT_NOTIFY_INSERT

#define	TX_EL_THREAD_ENTRY_EXIT_NOTIFY_INSERT

#define	TX_EL_THREAD_RESET_INSERT

#define	TX_EL_THREAD_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_THREAD_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_THREAD_STACK_ERROR_NOTIFY_INSERT

#define	TX_EL_TIMER_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_TIMER_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_THREAD_GET_SYSTEM_STATE() _tx_thread_system_state

Typedefs
typedef struct TX_TIMER_INTERNAL_STRUCT	TX_TIMER_INTERNAL

typedef struct TX_TIMER_STRUCT	TX_TIMER

typedef struct TX_THREAD_STRUCT	TX_THREAD

typedef struct TX_BLOCK_POOL_STRUCT	TX_BLOCK_POOL

typedef struct TX_BYTE_POOL_STRUCT	TX_BYTE_POOL

typedef struct TX_EVENT_FLAGS_GROUP_STRUCT	TX_EVENT_FLAGS_GROUP

typedef struct TX_MUTEX_STRUCT	TX_MUTEX

typedef struct TX_QUEUE_STRUCT	TX_QUEUE

typedef struct TX_SEMAPHORE_STRUCT	TX_SEMAPHORE

Functions
VOID	tx_application_define (VOID *first_unused_memory)

UINT	_tx_block_allocate (TX_BLOCK_POOL pool_ptr, VOID *block_ptr, ULONG wait_option)

UINT	_tx_block_pool_create (TX_BLOCK_POOL pool_ptr, CHAR name_ptr, ULONG block_size, VOID *pool_start, ULONG pool_size)

UINT	_tx_block_pool_delete (TX_BLOCK_POOL *pool_ptr)

UINT	_tx_block_pool_info_get (TX_BLOCK_POOL pool_ptr, CHAR name, ULONG available_blocks, ULONG total_blocks, TX_THREAD first_suspended, ULONG suspended_count, TX_BLOCK_POOL **next_pool)

UINT	_tx_block_pool_performance_info_get (TX_BLOCK_POOL pool_ptr, ULONG allocates, ULONG releases, ULONG suspensions, ULONG *timeouts)

UINT	_tx_block_pool_performance_system_info_get (ULONG allocates, ULONG releases, ULONG suspensions, ULONG timeouts)

UINT	_tx_block_pool_prioritize (TX_BLOCK_POOL *pool_ptr)

UINT	_tx_block_release (VOID *block_ptr)

UINT	_txe_block_allocate (TX_BLOCK_POOL pool_ptr, VOID *block_ptr, ULONG wait_option)

UINT	_txe_block_pool_create (TX_BLOCK_POOL pool_ptr, CHAR name_ptr, ULONG block_size, VOID *pool_start, ULONG pool_size, UINT pool_control_block_size)

UINT	_txe_block_pool_delete (TX_BLOCK_POOL *pool_ptr)

UINT	_txe_block_pool_info_get (TX_BLOCK_POOL pool_ptr, CHAR name, ULONG available_blocks, ULONG total_blocks, TX_THREAD first_suspended, ULONG suspended_count, TX_BLOCK_POOL **next_pool)

UINT	_txe_block_pool_prioritize (TX_BLOCK_POOL *pool_ptr)

UINT	_txe_block_release (VOID *block_ptr)

UINT	_tx_byte_allocate (TX_BYTE_POOL pool_ptr, VOID *memory_ptr, ULONG memory_size, ULONG wait_option)

UINT	_tx_byte_pool_create (TX_BYTE_POOL pool_ptr, CHAR name_ptr, VOID *pool_start, ULONG pool_size)

UINT	_tx_byte_pool_delete (TX_BYTE_POOL *pool_ptr)

UINT	_tx_byte_pool_info_get (TX_BYTE_POOL pool_ptr, CHAR name, ULONG available_bytes, ULONG fragments, TX_THREAD first_suspended, ULONG suspended_count, TX_BYTE_POOL **next_pool)

UINT	_tx_byte_pool_performance_info_get (TX_BYTE_POOL pool_ptr, ULONG allocates, ULONG releases, ULONG fragments_searched, ULONG merges, ULONG splits, ULONG suspensions, ULONG timeouts)

UINT	_tx_byte_pool_performance_system_info_get (ULONG allocates, ULONG releases, ULONG fragments_searched, ULONG merges, ULONG splits, ULONG suspensions, ULONG *timeouts)

UINT	_tx_byte_pool_prioritize (TX_BYTE_POOL *pool_ptr)

UINT	_tx_byte_release (VOID *memory_ptr)

UINT	_txe_byte_allocate (TX_BYTE_POOL pool_ptr, VOID *memory_ptr, ULONG memory_size, ULONG wait_option)

UINT	_txe_byte_pool_create (TX_BYTE_POOL pool_ptr, CHAR name_ptr, VOID *pool_start, ULONG pool_size, UINT pool_control_block_size)

UINT	_txe_byte_pool_delete (TX_BYTE_POOL *pool_ptr)

UINT	_txe_byte_pool_info_get (TX_BYTE_POOL pool_ptr, CHAR name, ULONG available_bytes, ULONG fragments, TX_THREAD first_suspended, ULONG suspended_count, TX_BYTE_POOL **next_pool)

UINT	_txe_byte_pool_prioritize (TX_BYTE_POOL *pool_ptr)

UINT	_txe_byte_release (VOID *memory_ptr)

UINT	_tx_event_flags_create (TX_EVENT_FLAGS_GROUP group_ptr, CHAR name_ptr)

UINT	_tx_event_flags_delete (TX_EVENT_FLAGS_GROUP *group_ptr)

UINT	_tx_event_flags_get (TX_EVENT_FLAGS_GROUP group_ptr, ULONG requested_flags, UINT get_option, ULONG actual_flags_ptr, ULONG wait_option)

UINT	_tx_event_flags_info_get (TX_EVENT_FLAGS_GROUP group_ptr, CHAR name, ULONG current_flags, TX_THREAD *first_suspended, ULONG suspended_count, TX_EVENT_FLAGS_GROUP **next_group)

UINT	_tx_event_flags_performance_info_get (TX_EVENT_FLAGS_GROUP group_ptr, ULONG sets, ULONG gets, ULONG suspensions, ULONG *timeouts)

UINT	_tx_event_flags_performance_system_info_get (ULONG sets, ULONG gets, ULONG suspensions, ULONG timeouts)

UINT	_tx_event_flags_set (TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set, UINT set_option)

UINT	_tx_event_flags_set_notify (TX_EVENT_FLAGS_GROUP group_ptr, VOID(events_set_notify)(TX_EVENT_FLAGS_GROUP *notify_group_ptr))

UINT	_txe_event_flags_create (TX_EVENT_FLAGS_GROUP group_ptr, CHAR name_ptr, UINT event_control_block_size)

UINT	_txe_event_flags_delete (TX_EVENT_FLAGS_GROUP *group_ptr)

UINT	_txe_event_flags_get (TX_EVENT_FLAGS_GROUP group_ptr, ULONG requested_flags, UINT get_option, ULONG actual_flags_ptr, ULONG wait_option)

UINT	_txe_event_flags_info_get (TX_EVENT_FLAGS_GROUP group_ptr, CHAR name, ULONG current_flags, TX_THREAD *first_suspended, ULONG suspended_count, TX_EVENT_FLAGS_GROUP **next_group)

UINT	_txe_event_flags_set (TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set, UINT set_option)

UINT	_txe_event_flags_set_notify (TX_EVENT_FLAGS_GROUP group_ptr, VOID(events_set_notify)(TX_EVENT_FLAGS_GROUP *notify_group_ptr))

VOID	_tx_initialize_kernel_enter (VOID)

UINT	_tx_mutex_create (TX_MUTEX mutex_ptr, CHAR name_ptr, UINT inherit)

UINT	_tx_mutex_delete (TX_MUTEX *mutex_ptr)

UINT	_tx_mutex_get (TX_MUTEX *mutex_ptr, ULONG wait_option)

UINT	_tx_mutex_info_get (TX_MUTEX mutex_ptr, CHAR name, ULONG count, TX_THREAD owner, TX_THREAD first_suspended, ULONG suspended_count, TX_MUTEX *next_mutex)

UINT	_tx_mutex_performance_info_get (TX_MUTEX mutex_ptr, ULONG puts, ULONG gets, ULONG suspensions, ULONG timeouts, ULONG inversions, ULONG *inheritances)

UINT	_tx_mutex_performance_system_info_get (ULONG puts, ULONG gets, ULONG suspensions, ULONG timeouts, ULONG inversions, ULONG inheritances)

UINT	_tx_mutex_prioritize (TX_MUTEX *mutex_ptr)

UINT	_tx_mutex_put (TX_MUTEX *mutex_ptr)

UINT	_txe_mutex_create (TX_MUTEX mutex_ptr, CHAR name_ptr, UINT inherit, UINT mutex_control_block_size)

UINT	_txe_mutex_delete (TX_MUTEX *mutex_ptr)

UINT	_txe_mutex_get (TX_MUTEX *mutex_ptr, ULONG wait_option)

UINT	_txe_mutex_info_get (TX_MUTEX mutex_ptr, CHAR name, ULONG count, TX_THREAD owner, TX_THREAD first_suspended, ULONG suspended_count, TX_MUTEX *next_mutex)

UINT	_txe_mutex_prioritize (TX_MUTEX *mutex_ptr)

UINT	_txe_mutex_put (TX_MUTEX *mutex_ptr)

UINT	_tx_queue_create (TX_QUEUE queue_ptr, CHAR name_ptr, UINT message_size, VOID *queue_start, ULONG queue_size)

UINT	_tx_queue_delete (TX_QUEUE *queue_ptr)

UINT	_tx_queue_flush (TX_QUEUE *queue_ptr)

UINT	_tx_queue_info_get (TX_QUEUE queue_ptr, CHAR name, ULONG enqueued, ULONG available_storage, TX_THREAD first_suspended, ULONG suspended_count, TX_QUEUE **next_queue)

UINT	_tx_queue_performance_info_get (TX_QUEUE queue_ptr, ULONG messages_sent, ULONG messages_received, ULONG empty_suspensions, ULONG full_suspensions, ULONG full_errors, ULONG *timeouts)

UINT	_tx_queue_performance_system_info_get (ULONG messages_sent, ULONG messages_received, ULONG empty_suspensions, ULONG full_suspensions, ULONG full_errors, ULONG timeouts)

UINT	_tx_queue_prioritize (TX_QUEUE *queue_ptr)

UINT	_tx_queue_receive (TX_QUEUE queue_ptr, VOID destination_ptr, ULONG wait_option)

UINT	_tx_queue_send (TX_QUEUE queue_ptr, VOID source_ptr, ULONG wait_option)

UINT	_tx_queue_send_notify (TX_QUEUE queue_ptr, VOID(queue_send_notify)(TX_QUEUE *notify_queue_ptr))

UINT	_tx_queue_front_send (TX_QUEUE queue_ptr, VOID source_ptr, ULONG wait_option)

UINT	_txe_queue_create (TX_QUEUE queue_ptr, CHAR name_ptr, UINT message_size, VOID *queue_start, ULONG queue_size, UINT queue_control_block_size)

UINT	_txe_queue_delete (TX_QUEUE *queue_ptr)

UINT	_txe_queue_flush (TX_QUEUE *queue_ptr)

UINT	_txe_queue_info_get (TX_QUEUE queue_ptr, CHAR name, ULONG enqueued, ULONG available_storage, TX_THREAD first_suspended, ULONG suspended_count, TX_QUEUE **next_queue)

UINT	_txe_queue_prioritize (TX_QUEUE *queue_ptr)

UINT	_txe_queue_receive (TX_QUEUE queue_ptr, VOID destination_ptr, ULONG wait_option)

UINT	_txe_queue_send (TX_QUEUE queue_ptr, VOID source_ptr, ULONG wait_option)

UINT	_txe_queue_send_notify (TX_QUEUE queue_ptr, VOID(queue_send_notify)(TX_QUEUE *notify_queue_ptr))

UINT	_txe_queue_front_send (TX_QUEUE queue_ptr, VOID source_ptr, ULONG wait_option)

UINT	_tx_semaphore_ceiling_put (TX_SEMAPHORE *semaphore_ptr, ULONG ceiling)

UINT	_tx_semaphore_create (TX_SEMAPHORE semaphore_ptr, CHAR name_ptr, ULONG initial_count)

UINT	_tx_semaphore_delete (TX_SEMAPHORE *semaphore_ptr)

UINT	_tx_semaphore_get (TX_SEMAPHORE *semaphore_ptr, ULONG wait_option)

UINT	_tx_semaphore_info_get (TX_SEMAPHORE semaphore_ptr, CHAR name, ULONG current_value, TX_THREAD *first_suspended, ULONG suspended_count, TX_SEMAPHORE **next_semaphore)

UINT	_tx_semaphore_performance_info_get (TX_SEMAPHORE semaphore_ptr, ULONG puts, ULONG gets, ULONG suspensions, ULONG *timeouts)

UINT	_tx_semaphore_performance_system_info_get (ULONG puts, ULONG gets, ULONG suspensions, ULONG timeouts)

UINT	_tx_semaphore_prioritize (TX_SEMAPHORE *semaphore_ptr)

UINT	_tx_semaphore_put (TX_SEMAPHORE *semaphore_ptr)

UINT	_tx_semaphore_put_notify (TX_SEMAPHORE semaphore_ptr, VOID(semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr))

UINT	_txe_semaphore_ceiling_put (TX_SEMAPHORE *semaphore_ptr, ULONG ceiling)

UINT	_txe_semaphore_create (TX_SEMAPHORE semaphore_ptr, CHAR name_ptr, ULONG initial_count, UINT semaphore_control_block_size)

UINT	_txe_semaphore_delete (TX_SEMAPHORE *semaphore_ptr)

UINT	_txe_semaphore_get (TX_SEMAPHORE *semaphore_ptr, ULONG wait_option)

UINT	_txe_semaphore_info_get (TX_SEMAPHORE semaphore_ptr, CHAR name, ULONG current_value, TX_THREAD *first_suspended, ULONG suspended_count, TX_SEMAPHORE **next_semaphore)

UINT	_txe_semaphore_prioritize (TX_SEMAPHORE *semaphore_ptr)

UINT	_txe_semaphore_put (TX_SEMAPHORE *semaphore_ptr)

UINT	_txe_semaphore_put_notify (TX_SEMAPHORE semaphore_ptr, VOID(semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr))

VOID	_tx_thread_context_save (VOID)

VOID	_tx_thread_context_restore (VOID)

UINT	_tx_thread_create (TX_THREAD thread_ptr, CHAR name_ptr, VOID(entry_function)(ULONG entry_input), ULONG entry_input, VOID stack_start, ULONG stack_size, UINT priority, UINT preempt_threshold, ULONG time_slice, UINT auto_start)

UINT	_tx_thread_delete (TX_THREAD *thread_ptr)

UINT	_tx_thread_entry_exit_notify (TX_THREAD thread_ptr, VOID(thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type))

TX_THREAD *	_tx_thread_identify (VOID)

UINT	_tx_thread_info_get (TX_THREAD thread_ptr, CHAR name, UINT state, ULONG run_count, UINT priority, UINT preemption_threshold, ULONG time_slice, TX_THREAD next_thread, TX_THREAD next_suspended_thread)

UINT	_tx_thread_interrupt_control (UINT new_posture)

UINT	_tx_thread_performance_info_get (TX_THREAD thread_ptr, ULONG resumptions, ULONG suspensions, ULONG solicited_preemptions, ULONG interrupt_preemptions, ULONG priority_inversions, ULONG time_slices, ULONG relinquishes, ULONG timeouts, ULONG wait_aborts, TX_THREAD **last_preempted_by)

UINT	_tx_thread_performance_system_info_get (ULONG resumptions, ULONG suspensions, ULONG solicited_preemptions, ULONG interrupt_preemptions, ULONG priority_inversions, ULONG time_slices, ULONG relinquishes, ULONG timeouts, ULONG wait_aborts, ULONG non_idle_returns, ULONG *idle_returns)

UINT	_tx_thread_preemption_change (TX_THREAD thread_ptr, UINT new_threshold, UINT old_threshold)

UINT	_tx_thread_priority_change (TX_THREAD thread_ptr, UINT new_priority, UINT old_priority)

VOID	_tx_thread_relinquish (VOID)

UINT	_tx_thread_reset (TX_THREAD *thread_ptr)

UINT	_tx_thread_resume (TX_THREAD *thread_ptr)

UINT	_tx_thread_sleep (ULONG timer_ticks)

UINT	_tx_thread_stack_error_notify (VOID(stack_error_handler)(TX_THREAD thread_ptr))

UINT	_tx_thread_suspend (TX_THREAD *thread_ptr)

UINT	_tx_thread_terminate (TX_THREAD *thread_ptr)

UINT	_tx_thread_time_slice_change (TX_THREAD thread_ptr, ULONG new_time_slice, ULONG old_time_slice)

UINT	_tx_thread_wait_abort (TX_THREAD *thread_ptr)

UINT	_txe_thread_create (TX_THREAD thread_ptr, CHAR name_ptr, VOID(entry_function)(ULONG entry_input), ULONG entry_input, VOID stack_start, ULONG stack_size, UINT priority, UINT preempt_threshold, ULONG time_slice, UINT auto_start, UINT thread_control_block_size)

UINT	_txe_thread_delete (TX_THREAD *thread_ptr)

UINT	_txe_thread_entry_exit_notify (TX_THREAD thread_ptr, VOID(thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type))

UINT	_txe_thread_info_get (TX_THREAD thread_ptr, CHAR name, UINT state, ULONG run_count, UINT priority, UINT preemption_threshold, ULONG time_slice, TX_THREAD next_thread, TX_THREAD next_suspended_thread)

UINT	_txe_thread_preemption_change (TX_THREAD thread_ptr, UINT new_threshold, UINT old_threshold)

UINT	_txe_thread_priority_change (TX_THREAD thread_ptr, UINT new_priority, UINT old_priority)

VOID	_txe_thread_relinquish (VOID)

UINT	_txe_thread_reset (TX_THREAD *thread_ptr)

UINT	_txe_thread_resume (TX_THREAD *thread_ptr)

UINT	_txe_thread_suspend (TX_THREAD *thread_ptr)

UINT	_txe_thread_terminate (TX_THREAD *thread_ptr)

UINT	_txe_thread_time_slice_change (TX_THREAD thread_ptr, ULONG new_time_slice, ULONG old_time_slice)

UINT	_txe_thread_wait_abort (TX_THREAD *thread_ptr)

UINT	_tx_timer_activate (TX_TIMER *timer_ptr)

UINT	_tx_timer_change (TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks)

UINT	_tx_timer_create (TX_TIMER timer_ptr, CHAR name_ptr, VOID(*expiration_function)(ULONG input), ULONG expiration_input, ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate)

UINT	_tx_timer_deactivate (TX_TIMER *timer_ptr)

UINT	_tx_timer_delete (TX_TIMER *timer_ptr)

UINT	_tx_timer_info_get (TX_TIMER timer_ptr, CHAR name, UINT active, ULONG remaining_ticks, ULONG reschedule_ticks, TX_TIMER **next_timer)

UINT	_tx_timer_performance_info_get (TX_TIMER timer_ptr, ULONG activates, ULONG reactivates, ULONG deactivates, ULONG expirations, ULONG expiration_adjusts)

UINT	_tx_timer_performance_system_info_get (ULONG activates, ULONG reactivates, ULONG deactivates, ULONG expirations, ULONG *expiration_adjusts)

ULONG	_tx_time_get (VOID)

VOID	_tx_time_set (ULONG new_time)

UINT	_txe_timer_activate (TX_TIMER *timer_ptr)

UINT	_txe_timer_change (TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks)

UINT	_txe_timer_create (TX_TIMER timer_ptr, CHAR name_ptr, VOID(*expiration_function)(ULONG input), ULONG expiration_input, ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate, UINT timer_control_block_size)

UINT	_txe_timer_deactivate (TX_TIMER *timer_ptr)

UINT	_txe_timer_delete (TX_TIMER *timer_ptr)

UINT	_txe_timer_info_get (TX_TIMER timer_ptr, CHAR name, UINT active, ULONG remaining_ticks, ULONG reschedule_ticks, TX_TIMER **next_timer)

UINT	_tx_trace_enable (VOID *trace_buffer_start, ULONG trace_buffer_size, ULONG registry_entries)

UINT	_tx_trace_event_filter (ULONG event_filter_bits)

UINT	_tx_trace_event_unfilter (ULONG event_unfilter_bits)

UINT	_tx_trace_disable (VOID)

VOID	_tx_trace_isr_enter_insert (ULONG isr_id)

VOID	_tx_trace_isr_exit_insert (ULONG isr_id)

UINT	_tx_trace_buffer_full_notify (VOID(full_buffer_callback)(VOID buffer))

UINT	_tx_trace_user_event_insert (ULONG event_id, ULONG info_field_1, ULONG info_field_2, ULONG info_field_3, ULONG info_field_4)

UINT	_tx_trace_interrupt_control (UINT new_posture)

Macro Definition Documentation

◆ _tx_el_user_event_insert

#define _tx_el_user_event_insert	(	a,
		b,
		c,
		d,
		e
	)

◆ ALIGN_TYPE

#define ALIGN_TYPE ULONG

◆ AZURE_RTOS_THREADX

#define AZURE_RTOS_THREADX

◆ EL_PRODUCT_THREADX

#define EL_PRODUCT_THREADX

◆ THREADX_MAJOR_VERSION

#define THREADX_MAJOR_VERSION 6

◆ THREADX_MINOR_VERSION

#define THREADX_MINOR_VERSION 1

◆ THREADX_PATCH_VERSION

#define THREADX_PATCH_VERSION 11

◆ TX_16_ULONG

#define TX_16_ULONG ((UINT) 16)

◆ TX_1_ULONG

#define TX_1_ULONG ((UINT) 1)

◆ TX_2_ULONG

#define TX_2_ULONG ((UINT) 2)

◆ TX_4_ULONG

#define TX_4_ULONG ((UINT) 4)

◆ TX_8_ULONG

#define TX_8_ULONG ((UINT) 8)

◆ TX_ACTIVATE_ERROR

#define TX_ACTIVATE_ERROR ((UINT) 0x17)

◆ TX_ALIGN_TYPE_TO_POINTER_CONVERT

#define TX_ALIGN_TYPE_TO_POINTER_CONVERT ( a ) ((VOID *) ((ALIGN_TYPE) (a)))

◆ TX_AND

#define TX_AND ((UINT) 2)

◆ TX_AND_CLEAR

#define TX_AND_CLEAR ((UINT) 3)

◆ TX_AUTO_ACTIVATE

#define TX_AUTO_ACTIVATE ((UINT) 1)

◆ TX_AUTO_START

#define TX_AUTO_START ((UINT) 1)

◆ tx_block_allocate

#define tx_block_allocate _txe_block_allocate

◆ TX_BLOCK_MEMORY

#define TX_BLOCK_MEMORY ((UINT) 8)

◆ tx_block_pool_create

#define tx_block_pool_create	(	p,
		n,
		b,
		s,
		l
	)	_txe_block_pool_create((p),(n),(b),(s),(l),(sizeof(TX_BLOCK_POOL)))

◆ tx_block_pool_delete

#define tx_block_pool_delete _txe_block_pool_delete

◆ tx_block_pool_info_get

#define tx_block_pool_info_get _txe_block_pool_info_get

◆ tx_block_pool_performance_info_get

#define tx_block_pool_performance_info_get _tx_block_pool_performance_info_get

◆ tx_block_pool_performance_system_info_get

#define tx_block_pool_performance_system_info_get _tx_block_pool_performance_system_info_get

◆ tx_block_pool_prioritize

#define tx_block_pool_prioritize _txe_block_pool_prioritize

◆ TX_BLOCK_POOL_TO_UCHAR_POINTER_CONVERT

#define TX_BLOCK_POOL_TO_UCHAR_POINTER_CONVERT ( a ) ((UCHAR *) ((VOID *) (a)))

◆ tx_block_release

#define tx_block_release _txe_block_release

◆ tx_byte_allocate

#define tx_byte_allocate _txe_byte_allocate

◆ TX_BYTE_ALLOCATE_EXTENSION

#define TX_BYTE_ALLOCATE_EXTENSION

◆ TX_BYTE_MEMORY

#define TX_BYTE_MEMORY ((UINT) 9)

◆ tx_byte_pool_create

#define tx_byte_pool_create	(	p,
		n,
		s,
		l
	)	_txe_byte_pool_create((p),(n),(s),(l),(sizeof(TX_BYTE_POOL)))

◆ tx_byte_pool_delete

#define tx_byte_pool_delete _txe_byte_pool_delete

◆ tx_byte_pool_info_get

#define tx_byte_pool_info_get _txe_byte_pool_info_get

◆ tx_byte_pool_performance_info_get

#define tx_byte_pool_performance_info_get _tx_byte_pool_performance_info_get

◆ tx_byte_pool_performance_system_info_get

#define tx_byte_pool_performance_system_info_get _tx_byte_pool_performance_system_info_get

◆ tx_byte_pool_prioritize

#define tx_byte_pool_prioritize _txe_byte_pool_prioritize

◆ TX_BYTE_POOL_TO_UCHAR_POINTER_CONVERT

#define TX_BYTE_POOL_TO_UCHAR_POINTER_CONVERT ( a ) ((UCHAR *) ((VOID *) (a)))

◆ tx_byte_release

#define tx_byte_release _txe_byte_release

◆ TX_BYTE_RELEASE_EXTENSION

#define TX_BYTE_RELEASE_EXTENSION

◆ TX_CALLER_ERROR

#define TX_CALLER_ERROR ((UINT) 0x13)

◆ TX_CEILING_EXCEEDED

#define TX_CEILING_EXCEEDED ((UINT) 0x21)

◆ TX_CHAR_TO_UCHAR_POINTER_CONVERT

#define TX_CHAR_TO_UCHAR_POINTER_CONVERT ( a ) ((UCHAR *) ((VOID *) (a)))

◆ TX_CLEAR_ID

#define TX_CLEAR_ID ((ULONG) 0)

◆ TX_COMPLETED

#define TX_COMPLETED ((UINT) 1)

◆ TX_CONST_CHAR_TO_CHAR_POINTER_CONVERT

#define TX_CONST_CHAR_TO_CHAR_POINTER_CONVERT ( a ) ((CHAR *) ((VOID *) (a)))

◆ TX_DELETE_ERROR

#define TX_DELETE_ERROR ((UINT) 0x11)

◆ TX_DELETED

#define TX_DELETED ((UINT) 0x01)

◆ TX_DONT_START

#define TX_DONT_START ((UINT) 0)

◆ TX_EL_BLOCK_ALLOCATE_INSERT

#define TX_EL_BLOCK_ALLOCATE_INSERT

◆ TX_EL_BLOCK_POOL_CREATE_INSERT

#define TX_EL_BLOCK_POOL_CREATE_INSERT

◆ TX_EL_BLOCK_POOL_DELETE_INSERT

#define TX_EL_BLOCK_POOL_DELETE_INSERT

◆ TX_EL_BLOCK_POOL_INFO_GET_INSERT

#define TX_EL_BLOCK_POOL_INFO_GET_INSERT

◆ TX_EL_BLOCK_POOL_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_BLOCK_POOL_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_BLOCK_POOL_PRIORITIZE_INSERT

#define TX_EL_BLOCK_POOL_PRIORITIZE_INSERT

◆ TX_EL_BLOCK_RELEASE_INSERT

#define TX_EL_BLOCK_RELEASE_INSERT

◆ TX_EL_BYTE_ALLOCATE_INSERT

#define TX_EL_BYTE_ALLOCATE_INSERT

◆ TX_EL_BYTE_POOL_CREATE_INSERT

#define TX_EL_BYTE_POOL_CREATE_INSERT

◆ TX_EL_BYTE_POOL_DELETE_INSERT

#define TX_EL_BYTE_POOL_DELETE_INSERT

◆ TX_EL_BYTE_POOL_INFO_GET_INSERT

#define TX_EL_BYTE_POOL_INFO_GET_INSERT

◆ TX_EL_BYTE_POOL_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_BYTE_POOL_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_BYTE_POOL_PRIORITIZE_INSERT

#define TX_EL_BYTE_POOL_PRIORITIZE_INSERT

◆ TX_EL_BYTE_RELEASE_INSERT

#define TX_EL_BYTE_RELEASE_INSERT

◆ TX_EL_EVENT_FLAGS__PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_EVENT_FLAGS__PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_EVENT_FLAGS_CREATE_INSERT

#define TX_EL_EVENT_FLAGS_CREATE_INSERT

◆ TX_EL_EVENT_FLAGS_DELETE_INSERT

#define TX_EL_EVENT_FLAGS_DELETE_INSERT

◆ TX_EL_EVENT_FLAGS_GET_INSERT

#define TX_EL_EVENT_FLAGS_GET_INSERT

◆ TX_EL_EVENT_FLAGS_INFO_GET_INSERT

#define TX_EL_EVENT_FLAGS_INFO_GET_INSERT

◆ TX_EL_EVENT_FLAGS_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_EVENT_FLAGS_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_EVENT_FLAGS_SET_INSERT

#define TX_EL_EVENT_FLAGS_SET_INSERT

◆ TX_EL_EVENT_FLAGS_SET_NOTIFY_INSERT

#define TX_EL_EVENT_FLAGS_SET_NOTIFY_INSERT

◆ TX_EL_INITIALIZE

#define TX_EL_INITIALIZE

◆ TX_EL_INTERRUPT_CONTROL_INSERT

#define TX_EL_INTERRUPT_CONTROL_INSERT

◆ TX_EL_MUTEX_CREATE_INSERT

#define TX_EL_MUTEX_CREATE_INSERT

◆ TX_EL_MUTEX_DELETE_INSERT

#define TX_EL_MUTEX_DELETE_INSERT

◆ TX_EL_MUTEX_GET_INSERT

#define TX_EL_MUTEX_GET_INSERT

◆ TX_EL_MUTEX_INFO_GET_INSERT

#define TX_EL_MUTEX_INFO_GET_INSERT

◆ TX_EL_MUTEX_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_MUTEX_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_MUTEX_PRIORITIZE_INSERT

#define TX_EL_MUTEX_PRIORITIZE_INSERT

◆ TX_EL_MUTEX_PUT_INSERT

#define TX_EL_MUTEX_PUT_INSERT

◆ TX_EL_QUEUE_CREATE_INSERT

#define TX_EL_QUEUE_CREATE_INSERT

◆ TX_EL_QUEUE_DELETE_INSERT

#define TX_EL_QUEUE_DELETE_INSERT

◆ TX_EL_QUEUE_FLUSH_INSERT

#define TX_EL_QUEUE_FLUSH_INSERT

◆ TX_EL_QUEUE_FRONT_SEND_INSERT

#define TX_EL_QUEUE_FRONT_SEND_INSERT

◆ TX_EL_QUEUE_INFO_GET_INSERT

#define TX_EL_QUEUE_INFO_GET_INSERT

◆ TX_EL_QUEUE_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_QUEUE_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_QUEUE_PRIORITIZE_INSERT

#define TX_EL_QUEUE_PRIORITIZE_INSERT

◆ TX_EL_QUEUE_RECEIVE_INSERT

#define TX_EL_QUEUE_RECEIVE_INSERT

◆ TX_EL_QUEUE_SEND_INSERT

#define TX_EL_QUEUE_SEND_INSERT

◆ TX_EL_QUEUE_SEND_NOTIFY_INSERT

#define TX_EL_QUEUE_SEND_NOTIFY_INSERT

◆ TX_EL_SEMAPHORE_CEILING_PUT_INSERT

#define TX_EL_SEMAPHORE_CEILING_PUT_INSERT

◆ TX_EL_SEMAPHORE_CREATE_INSERT

#define TX_EL_SEMAPHORE_CREATE_INSERT

◆ TX_EL_SEMAPHORE_DELETE_INSERT

#define TX_EL_SEMAPHORE_DELETE_INSERT

◆ TX_EL_SEMAPHORE_GET_INSERT

#define TX_EL_SEMAPHORE_GET_INSERT

◆ TX_EL_SEMAPHORE_INFO_GET_INSERT

#define TX_EL_SEMAPHORE_INFO_GET_INSERT

◆ TX_EL_SEMAPHORE_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_SEMAPHORE_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_SEMAPHORE_PRIORITIZE_INSERT

#define TX_EL_SEMAPHORE_PRIORITIZE_INSERT

◆ TX_EL_SEMAPHORE_PUT_INSERT

#define TX_EL_SEMAPHORE_PUT_INSERT

◆ TX_EL_SEMAPHORE_PUT_NOTIFY_INSERT

#define TX_EL_SEMAPHORE_PUT_NOTIFY_INSERT

◆ TX_EL_THREAD_CREATE_INSERT

#define TX_EL_THREAD_CREATE_INSERT

◆ TX_EL_THREAD_DELETE_INSERT

#define TX_EL_THREAD_DELETE_INSERT

◆ TX_EL_THREAD_ENTRY_EXIT_NOTIFY_INSERT

#define TX_EL_THREAD_ENTRY_EXIT_NOTIFY_INSERT

◆ TX_EL_THREAD_IDENTIFY_INSERT

#define TX_EL_THREAD_IDENTIFY_INSERT

◆ TX_EL_THREAD_INFO_GET_INSERT

#define TX_EL_THREAD_INFO_GET_INSERT

◆ TX_EL_THREAD_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_THREAD_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_THREAD_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_THREAD_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_THREAD_PREEMPTION_CHANGE_INSERT

#define TX_EL_THREAD_PREEMPTION_CHANGE_INSERT

◆ TX_EL_THREAD_PRIORITY_CHANGE_INSERT

#define TX_EL_THREAD_PRIORITY_CHANGE_INSERT

◆ TX_EL_THREAD_REGISTER

#define TX_EL_THREAD_REGISTER ( a )

◆ TX_EL_THREAD_RELINQUISH_INSERT

#define TX_EL_THREAD_RELINQUISH_INSERT

◆ TX_EL_THREAD_RESET_INSERT

#define TX_EL_THREAD_RESET_INSERT

◆ TX_EL_THREAD_RESUME_INSERT

#define TX_EL_THREAD_RESUME_INSERT

◆ TX_EL_THREAD_SLEEP_INSERT

#define TX_EL_THREAD_SLEEP_INSERT

◆ TX_EL_THREAD_STACK_ERROR_NOTIFY_INSERT

#define TX_EL_THREAD_STACK_ERROR_NOTIFY_INSERT

◆ TX_EL_THREAD_STATUS_CHANGE_INSERT

#define TX_EL_THREAD_STATUS_CHANGE_INSERT	(	a,
		b
	)

◆ TX_EL_THREAD_SUSPEND_INSERT

#define TX_EL_THREAD_SUSPEND_INSERT

◆ TX_EL_THREAD_TERMINATE_INSERT

#define TX_EL_THREAD_TERMINATE_INSERT

◆ TX_EL_THREAD_TIME_SLICE_CHANGE_INSERT

#define TX_EL_THREAD_TIME_SLICE_CHANGE_INSERT

◆ TX_EL_THREAD_UNREGISTER

#define TX_EL_THREAD_UNREGISTER ( a )

◆ TX_EL_THREAD_WAIT_ABORT_INSERT

#define TX_EL_THREAD_WAIT_ABORT_INSERT

◆ TX_EL_TIME_GET_INSERT

#define TX_EL_TIME_GET_INSERT

◆ TX_EL_TIME_SET_INSERT

#define TX_EL_TIME_SET_INSERT

◆ TX_EL_TIMER_ACTIVATE_INSERT

#define TX_EL_TIMER_ACTIVATE_INSERT

◆ TX_EL_TIMER_CHANGE_INSERT

#define TX_EL_TIMER_CHANGE_INSERT

◆ TX_EL_TIMER_CREATE_INSERT

#define TX_EL_TIMER_CREATE_INSERT

◆ TX_EL_TIMER_DEACTIVATE_INSERT

#define TX_EL_TIMER_DEACTIVATE_INSERT

◆ TX_EL_TIMER_DELETE_INSERT

#define TX_EL_TIMER_DELETE_INSERT

◆ TX_EL_TIMER_INFO_GET_INSERT

#define TX_EL_TIMER_INFO_GET_INSERT

◆ TX_EL_TIMER_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_TIMER_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_TIMER_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_TIMER_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EMPTY

#define TX_EMPTY ((ULONG) 0)

◆ TX_EVENT_FLAG

#define TX_EVENT_FLAG ((UINT) 7)

◆ tx_event_flags_create

#define tx_event_flags_create	(	g,
		n
	)	_txe_event_flags_create((g),(n),(sizeof(TX_EVENT_FLAGS_GROUP)))

◆ tx_event_flags_delete

#define tx_event_flags_delete _txe_event_flags_delete

◆ tx_event_flags_get

#define tx_event_flags_get _txe_event_flags_get

◆ TX_EVENT_FLAGS_GROUP_NOT_USED

#define TX_EVENT_FLAGS_GROUP_NOT_USED ( a ) ((void)(a))

◆ tx_event_flags_info_get

#define tx_event_flags_info_get _txe_event_flags_info_get

◆ tx_event_flags_performance_info_get

#define tx_event_flags_performance_info_get _tx_event_flags_performance_info_get

◆ tx_event_flags_performance_system_info_get

#define tx_event_flags_performance_system_info_get _tx_event_flags_performance_system_info_get

◆ tx_event_flags_set

#define tx_event_flags_set _txe_event_flags_set

◆ tx_event_flags_set_notify

#define tx_event_flags_set_notify _txe_event_flags_set_notify

◆ TX_EVENT_FLAGS_SET_NOTIFY_NOT_USED

#define TX_EVENT_FLAGS_SET_NOTIFY_NOT_USED ( a ) ((void)(a))

◆ TX_FALSE

#define TX_FALSE ((UINT) 0)

◆ TX_FEATURE_NOT_ENABLED

#define TX_FEATURE_NOT_ENABLED ((UINT) 0xFF)

◆ TX_FILE

#define TX_FILE ((UINT) 11)

◆ TX_GROUP_ERROR

#define TX_GROUP_ERROR ((UINT) 0x06)

◆ TX_INDIRECT_VOID_TO_UCHAR_POINTER_CONVERT

#define TX_INDIRECT_VOID_TO_UCHAR_POINTER_CONVERT ( a ) ((UCHAR **) ((VOID *) (a)))

◆ TX_INHERIT

#define TX_INHERIT ((UINT) 1)

◆ TX_INHERIT_ERROR

#define TX_INHERIT_ERROR ((UINT) 0x1F)

◆ TX_INITIALIZE_KERNEL_ENTER_EXTENSION

#define TX_INITIALIZE_KERNEL_ENTER_EXTENSION

◆ tx_interrupt_control

#define tx_interrupt_control _tx_thread_interrupt_control

◆ TX_INVALID_CEILING

#define TX_INVALID_CEILING ((UINT) 0x22)

◆ TX_IO_DRIVER

#define TX_IO_DRIVER ((UINT) 10)

◆ tx_kernel_enter

#define tx_kernel_enter _tx_initialize_kernel_enter

◆ TX_LOOP_FOREVER

#define TX_LOOP_FOREVER ((UINT) 1)

◆ TX_MEMSET

#define TX_MEMSET	(	a,
		b,
		c
	)	memset((a),(b),(c))

◆ tx_mutex_create

#define tx_mutex_create	(	m,
		n,
		i
	)	_txe_mutex_create((m),(n),(i),(sizeof(TX_MUTEX)))

◆ tx_mutex_delete

#define tx_mutex_delete _txe_mutex_delete

◆ TX_MUTEX_ERROR

#define TX_MUTEX_ERROR ((UINT) 0x1C)

◆ tx_mutex_get

#define tx_mutex_get _txe_mutex_get

◆ tx_mutex_info_get

#define tx_mutex_info_get _txe_mutex_info_get

◆ tx_mutex_performance_info_get

#define tx_mutex_performance_info_get _tx_mutex_performance_info_get

◆ tx_mutex_performance_system_info_get

#define tx_mutex_performance_system_info_get _tx_mutex_performance_system_info_get

◆ tx_mutex_prioritize

#define tx_mutex_prioritize _txe_mutex_prioritize

◆ TX_MUTEX_PRIORITY_CHANGE_EXTENSION

#define TX_MUTEX_PRIORITY_CHANGE_EXTENSION

◆ tx_mutex_put

#define tx_mutex_put _txe_mutex_put

◆ TX_MUTEX_PUT_EXTENSION_1

#define TX_MUTEX_PUT_EXTENSION_1

◆ TX_MUTEX_PUT_EXTENSION_2

#define TX_MUTEX_PUT_EXTENSION_2

◆ TX_MUTEX_SUSP

#define TX_MUTEX_SUSP ((UINT) 13)

◆ TX_NO_ACTIVATE

#define TX_NO_ACTIVATE ((UINT) 0)

◆ TX_NO_EVENTS

#define TX_NO_EVENTS ((UINT) 0x07)

◆ TX_NO_INHERIT

#define TX_NO_INHERIT ((UINT) 0)

◆ TX_NO_INSTANCE

#define TX_NO_INSTANCE ((UINT) 0x0D)

◆ TX_NO_MEMORY

#define TX_NO_MEMORY ((UINT) 0x10)

◆ TX_NO_MESSAGES

#define TX_NO_MESSAGES ((UINT) 0)

◆ TX_NO_SUSPENSIONS

#define TX_NO_SUSPENSIONS ((UINT) 0)

◆ TX_NO_TIME_SLICE

#define TX_NO_TIME_SLICE ((ULONG) 0)

◆ TX_NO_WAIT

#define TX_NO_WAIT ((ULONG) 0)

◆ TX_NOT_AVAILABLE

#define TX_NOT_AVAILABLE ((UINT) 0x1D)

◆ TX_NOT_DONE

#define TX_NOT_DONE ((UINT) 0x20)

◆ TX_NOT_OWNED

#define TX_NOT_OWNED ((UINT) 0x1E)

◆ TX_NULL

#define TX_NULL ((void *) 0)

◆ TX_OPTION_ERROR

#define TX_OPTION_ERROR ((UINT) 0x08)

◆ TX_OR

#define TX_OR ((UINT) 0)

◆ TX_OR_CLEAR

#define TX_OR_CLEAR ((UINT) 1)

◆ TX_PARAMETER_NOT_USED

#define TX_PARAMETER_NOT_USED ( p ) ((void)(p))

ThreadX Component

Application Interface (API)

◆ TX_POINTER_TO_ALIGN_TYPE_CONVERT

#define TX_POINTER_TO_ALIGN_TYPE_CONVERT ( a ) ((ALIGN_TYPE) ((VOID *) (a)))

◆ TX_POINTER_TO_ULONG_CONVERT

#define TX_POINTER_TO_ULONG_CONVERT ( a ) ((ULONG) ((VOID *) (a)))

◆ TX_POOL_ERROR

#define TX_POOL_ERROR ((UINT) 0x02)

◆ TX_PRIORITY_CHANGE

#define TX_PRIORITY_CHANGE ((UINT) 14)

◆ TX_PRIORITY_ERROR

#define TX_PRIORITY_ERROR ((UINT) 0x0F)

◆ TX_PTR_ERROR

#define TX_PTR_ERROR ((UINT) 0x03)

◆ tx_queue_create

#define tx_queue_create	(	q,
		n,
		m,
		s,
		l
	)	_txe_queue_create((q),(n),(m),(s),(l),(sizeof(TX_QUEUE)))

◆ tx_queue_delete

#define tx_queue_delete _txe_queue_delete

◆ TX_QUEUE_EMPTY

#define TX_QUEUE_EMPTY ((UINT) 0x0A)

◆ TX_QUEUE_ERROR

#define TX_QUEUE_ERROR ((UINT) 0x09)

◆ tx_queue_flush

#define tx_queue_flush _txe_queue_flush

◆ tx_queue_front_send

#define tx_queue_front_send _txe_queue_front_send

◆ TX_QUEUE_FULL

#define TX_QUEUE_FULL ((UINT) 0x0B)

◆ tx_queue_info_get

#define tx_queue_info_get _txe_queue_info_get

◆ TX_QUEUE_NOT_USED

#define TX_QUEUE_NOT_USED ( a ) ((void)(a))

◆ tx_queue_performance_info_get

#define tx_queue_performance_info_get _tx_queue_performance_info_get

◆ tx_queue_performance_system_info_get

#define tx_queue_performance_system_info_get _tx_queue_performance_system_info_get

◆ tx_queue_prioritize

#define tx_queue_prioritize _txe_queue_prioritize

◆ tx_queue_receive

#define tx_queue_receive _txe_queue_receive

◆ tx_queue_send

#define tx_queue_send _txe_queue_send

◆ tx_queue_send_notify

#define tx_queue_send_notify _txe_queue_send_notify

◆ TX_QUEUE_SEND_NOTIFY_NOT_USED

#define TX_QUEUE_SEND_NOTIFY_NOT_USED ( a ) ((void)(a))

◆ TX_QUEUE_SUSP

#define TX_QUEUE_SUSP ((UINT) 5)

◆ TX_READY

#define TX_READY ((UINT) 0)

◆ TX_RESUME_ERROR

#define TX_RESUME_ERROR ((UINT) 0x12)

◆ tx_semaphore_ceiling_put

#define tx_semaphore_ceiling_put _txe_semaphore_ceiling_put

◆ tx_semaphore_create

#define tx_semaphore_create	(	s,
		n,
		i
	)	_txe_semaphore_create((s),(n),(i),(sizeof(TX_SEMAPHORE)))

◆ tx_semaphore_delete

#define tx_semaphore_delete _txe_semaphore_delete

◆ TX_SEMAPHORE_ERROR

#define TX_SEMAPHORE_ERROR ((UINT) 0x0C)

◆ tx_semaphore_get

#define tx_semaphore_get _txe_semaphore_get

◆ tx_semaphore_info_get

#define tx_semaphore_info_get _txe_semaphore_info_get

◆ TX_SEMAPHORE_NOT_USED

#define TX_SEMAPHORE_NOT_USED ( a ) ((void)(a))

◆ tx_semaphore_performance_info_get

#define tx_semaphore_performance_info_get _tx_semaphore_performance_info_get

◆ tx_semaphore_performance_system_info_get

#define tx_semaphore_performance_system_info_get _tx_semaphore_performance_system_info_get

◆ tx_semaphore_prioritize

#define tx_semaphore_prioritize _txe_semaphore_prioritize

◆ tx_semaphore_put

#define tx_semaphore_put _txe_semaphore_put

◆ tx_semaphore_put_notify

#define tx_semaphore_put_notify _txe_semaphore_put_notify

◆ TX_SEMAPHORE_PUT_NOTIFY_NOT_USED

#define TX_SEMAPHORE_PUT_NOTIFY_NOT_USED ( a ) ((void)(a))

◆ TX_SEMAPHORE_SUSP

#define TX_SEMAPHORE_SUSP ((UINT) 6)

◆ TX_SIZE_ERROR

#define TX_SIZE_ERROR ((UINT) 0x05)

◆ TX_SLEEP

#define TX_SLEEP ((UINT) 4)

◆ TX_STACK_FILL

#define TX_STACK_FILL ((ULONG) 0xEFEFEFEFUL)

◆ TX_START_ERROR

#define TX_START_ERROR ((UINT) 0x10)

◆ TX_SUCCESS

#define TX_SUCCESS ((UINT) 0x00)

◆ TX_SUSPEND_ERROR

#define TX_SUSPEND_ERROR ((UINT) 0x14)

◆ TX_SUSPEND_LIFTED

#define TX_SUSPEND_LIFTED ((UINT) 0x19)

◆ TX_SUSPENDED

#define TX_SUSPENDED ((UINT) 3)

◆ TX_TCP_IP

#define TX_TCP_IP ((UINT) 12)

◆ TX_TERMINATED

#define TX_TERMINATED ((UINT) 2)

◆ tx_thread_create

#define tx_thread_create	(	t,
		n,
		e,
		i,
		s,
		l,
		p,
		r,
		c,
		a
	)	_txe_thread_create((t),(n),(e),(i),(s),(l),(p),(r),(c),(a),(sizeof(TX_THREAD)))

◆ tx_thread_delete

#define tx_thread_delete _txe_thread_delete

◆ TX_THREAD_ENTRY

#define TX_THREAD_ENTRY ((UINT) 0)

◆ tx_thread_entry_exit_notify

#define tx_thread_entry_exit_notify _txe_thread_entry_exit_notify

◆ TX_THREAD_ENTRY_EXIT_NOTIFY_NOT_USED

#define TX_THREAD_ENTRY_EXIT_NOTIFY_NOT_USED ( a ) ((void)(a))

◆ TX_THREAD_ERROR

#define TX_THREAD_ERROR ((UINT) 0x0E)

◆ TX_THREAD_EXIT

#define TX_THREAD_EXIT ((UINT) 1)

◆ TX_THREAD_GET_SYSTEM_STATE

#define TX_THREAD_GET_SYSTEM_STATE ( ) _tx_thread_system_state

◆ tx_thread_identify

#define tx_thread_identify _tx_thread_identify

◆ tx_thread_info_get

#define tx_thread_info_get _txe_thread_info_get

◆ TX_THREAD_NOT_USED

#define TX_THREAD_NOT_USED ( a ) ((void)(a))

◆ tx_thread_performance_info_get

#define tx_thread_performance_info_get _tx_thread_performance_info_get

◆ tx_thread_performance_system_info_get

#define tx_thread_performance_system_info_get _tx_thread_performance_system_info_get

◆ tx_thread_preemption_change

#define tx_thread_preemption_change _txe_thread_preemption_change

◆ tx_thread_priority_change

#define tx_thread_priority_change _txe_thread_priority_change

◆ tx_thread_relinquish

#define tx_thread_relinquish _txe_thread_relinquish

◆ tx_thread_reset

#define tx_thread_reset _txe_thread_reset

◆ tx_thread_resume

#define tx_thread_resume _txe_thread_resume

◆ tx_thread_sleep

#define tx_thread_sleep _tx_thread_sleep

◆ TX_THREAD_STACK_ANALYZE_EXTENSION

#define TX_THREAD_STACK_ANALYZE_EXTENSION

◆ tx_thread_stack_error_notify

#define tx_thread_stack_error_notify _tx_thread_stack_error_notify

◆ TX_THREAD_STARTED_EXTENSION

#define TX_THREAD_STARTED_EXTENSION ( thread_ptr )

◆ tx_thread_suspend

#define tx_thread_suspend _txe_thread_suspend

◆ tx_thread_terminate

#define tx_thread_terminate _txe_thread_terminate

◆ tx_thread_time_slice_change

#define tx_thread_time_slice_change _txe_thread_time_slice_change

◆ tx_thread_wait_abort

#define tx_thread_wait_abort _txe_thread_wait_abort

◆ TX_THRESH_ERROR

#define TX_THRESH_ERROR ((UINT) 0x18)

◆ TX_TICK_ERROR

#define TX_TICK_ERROR ((UINT) 0x16)

◆ tx_time_get

#define tx_time_get _tx_time_get

◆ tx_time_set

#define tx_time_set _tx_time_set

◆ tx_timer_activate

#define tx_timer_activate _txe_timer_activate

◆ tx_timer_change

#define tx_timer_change _txe_timer_change

◆ tx_timer_create

#define tx_timer_create	(	t,
		n,
		e,
		i,
		c,
		r,
		a
	)	_txe_timer_create((t),(n),(e),(i),(c),(r),(a),(sizeof(TX_TIMER)))

◆ tx_timer_deactivate

#define tx_timer_deactivate _txe_timer_deactivate

◆ tx_timer_delete

#define tx_timer_delete _txe_timer_delete

◆ TX_TIMER_ERROR

#define TX_TIMER_ERROR ((UINT) 0x15)

◆ TX_TIMER_EXTENSION

#define TX_TIMER_EXTENSION

◆ TX_TIMER_INDIRECT_TO_VOID_POINTER_CONVERT

#define TX_TIMER_INDIRECT_TO_VOID_POINTER_CONVERT ( a ) ((VOID *) (a))

◆ tx_timer_info_get

#define tx_timer_info_get _txe_timer_info_get

◆ TX_TIMER_INITIALIZE_EXTENSION

#define TX_TIMER_INITIALIZE_EXTENSION ( a )

◆ TX_TIMER_INTERNAL_EXTENSION

#define TX_TIMER_INTERNAL_EXTENSION

◆ tx_timer_performance_info_get

#define tx_timer_performance_info_get _tx_timer_performance_info_get

◆ tx_timer_performance_system_info_get

#define tx_timer_performance_system_info_get _tx_timer_performance_system_info_get

◆ TX_TIMER_POINTER_ADD

#define TX_TIMER_POINTER_ADD	(	a,
		b
	)	(((TX_TIMER_INTERNAL **) (a)) + ((ULONG) (b)))

◆ TX_TIMER_POINTER_DIF

#define TX_TIMER_POINTER_DIF	(	a,
		b
	)	((ULONG)(((TX_TIMER_INTERNAL ) (a)) - ((TX_TIMER_INTERNAL ) (b))))

◆ TX_TIMER_TICKS_PER_SECOND

#define TX_TIMER_TICKS_PER_SECOND (100UL)

◆ TX_TRACE_ALL_EVENTS

#define TX_TRACE_ALL_EVENTS 0x000007FF /* All ThreadX events */

◆ TX_TRACE_BLOCK_POOL_EVENTS

#define TX_TRACE_BLOCK_POOL_EVENTS 0x00000002 /* ThreadX Block Pool events */

◆ tx_trace_buffer_full_notify

#define tx_trace_buffer_full_notify _tx_trace_buffer_full_notify

◆ TX_TRACE_BYTE_POOL_EVENTS

#define TX_TRACE_BYTE_POOL_EVENTS 0x00000004 /* ThreadX Byte Pool events */

◆ tx_trace_disable

#define tx_trace_disable _tx_trace_disable

◆ tx_trace_enable

#define tx_trace_enable _tx_trace_enable

◆ tx_trace_event_filter

#define tx_trace_event_filter _tx_trace_event_filter

◆ TX_TRACE_EVENT_FLAGS_EVENTS

#define TX_TRACE_EVENT_FLAGS_EVENTS 0x00000008 /* ThreadX Event Flags events */

◆ tx_trace_event_unfilter

#define tx_trace_event_unfilter _tx_trace_event_unfilter

◆ TX_TRACE_INTERNAL_EVENTS

#define TX_TRACE_INTERNAL_EVENTS 0x00000001 /* ThreadX internal events */

◆ TX_TRACE_INTERRUPT_CONTROL_EVENT

#define TX_TRACE_INTERRUPT_CONTROL_EVENT 0x00000010 /* ThreadX Interrupt Control events */

◆ tx_trace_isr_enter_insert

#define tx_trace_isr_enter_insert _tx_trace_isr_enter_insert

◆ tx_trace_isr_exit_insert

#define tx_trace_isr_exit_insert _tx_trace_isr_exit_insert

◆ TX_TRACE_MUTEX_EVENTS

#define TX_TRACE_MUTEX_EVENTS 0x00000020 /* ThreadX Mutex events */

◆ TX_TRACE_QUEUE_EVENTS

#define TX_TRACE_QUEUE_EVENTS 0x00000040 /* ThreadX Queue events */

◆ TX_TRACE_SEMAPHORE_EVENTS

#define TX_TRACE_SEMAPHORE_EVENTS 0x00000080 /* ThreadX Semaphore events */

◆ TX_TRACE_THREAD_EVENTS

#define TX_TRACE_THREAD_EVENTS 0x00000100 /* ThreadX Thread events */

◆ TX_TRACE_TIME_EVENTS

#define TX_TRACE_TIME_EVENTS 0x00000200 /* ThreadX Time events */

◆ TX_TRACE_TIMER_EVENTS

#define TX_TRACE_TIMER_EVENTS 0x00000400 /* ThreadX Timer events */

◆ TX_TRACE_USER_EVENT_END

#define TX_TRACE_USER_EVENT_END 65535 /* I1, I2, I3, I4 are user defined */

◆ tx_trace_user_event_insert

#define tx_trace_user_event_insert _tx_trace_user_event_insert

◆ TX_TRACE_USER_EVENT_START

#define TX_TRACE_USER_EVENT_START 4096 /* I1, I2, I3, I4 are user defined */

◆ TX_TRACE_USER_EVENTS

#define TX_TRACE_USER_EVENTS 0x80000000UL /* ThreadX User Events */

◆ TX_TRUE

#define TX_TRUE ((UINT) 1)

◆ TX_UCHAR_POINTER_ADD

#define TX_UCHAR_POINTER_ADD	(	a,
		b
	)	(((UCHAR *) (a)) + ((UINT) (b)))

◆ TX_UCHAR_POINTER_DIF

#define TX_UCHAR_POINTER_DIF	(	a,
		b
	)	((ULONG)(((UCHAR ) (a)) - ((UCHAR ) (b))))

◆ TX_UCHAR_POINTER_SUB

#define TX_UCHAR_POINTER_SUB	(	a,
		b
	)	(((UCHAR *) (a)) - ((UINT) (b)))

◆ TX_UCHAR_TO_ALIGN_TYPE_POINTER_CONVERT

#define TX_UCHAR_TO_ALIGN_TYPE_POINTER_CONVERT ( a ) ((ALIGN_TYPE *) ((VOID *) (a)))

◆ TX_UCHAR_TO_BLOCK_POOL_POINTER_CONVERT

#define TX_UCHAR_TO_BLOCK_POOL_POINTER_CONVERT ( a ) ((TX_BLOCK_POOL *) ((VOID *) (a)))

◆ TX_UCHAR_TO_INDIRECT_BYTE_POOL_POINTER

#define TX_UCHAR_TO_INDIRECT_BYTE_POOL_POINTER ( a ) ((TX_BYTE_POOL **) ((VOID *) (a)))

◆ TX_UCHAR_TO_INDIRECT_UCHAR_POINTER_CONVERT

#define TX_UCHAR_TO_INDIRECT_UCHAR_POINTER_CONVERT ( a ) ((UCHAR **) ((VOID *) (a)))

◆ TX_UCHAR_TO_VOID_POINTER_CONVERT

#define TX_UCHAR_TO_VOID_POINTER_CONVERT ( a ) ((VOID *) (a))

◆ TX_ULONG_POINTER_ADD

#define TX_ULONG_POINTER_ADD	(	a,
		b
	)	(((ULONG *) (a)) + ((UINT) (b)))

◆ TX_ULONG_POINTER_DIF

#define TX_ULONG_POINTER_DIF	(	a,
		b
	)	((ULONG)(((ULONG ) (a)) - ((ULONG ) (b))))

◆ TX_ULONG_POINTER_SUB

#define TX_ULONG_POINTER_SUB	(	a,
		b
	)	(((ULONG *) (a)) - ((UINT) (b)))

◆ TX_ULONG_TO_POINTER_CONVERT

#define TX_ULONG_TO_POINTER_CONVERT ( a ) ((VOID *) ((ULONG) (a)))

◆ TX_ULONG_TO_THREAD_POINTER_CONVERT

#define TX_ULONG_TO_THREAD_POINTER_CONVERT ( a ) ((TX_THREAD *) ((VOID *) (a)))

◆ TX_USER_TIMER_POINTER_GET

#define TX_USER_TIMER_POINTER_GET	(	a,
		b
	)

Value:

                                                            { \
                                                            UCHAR   *working_ptr; \
                                                            working_ptr =  (UCHAR *) (a);   \
                                                            (b) =  (TX_TIMER *) working_ptr; \
                                                            working_ptr =  working_ptr - (((UCHAR *) &(b) -> tx_timer_internal) - ((UCHAR *) &(b) -> tx_timer_id)); \
                                                            (b) =  (TX_TIMER *) working_ptr; \
                                                        }

◆ TX_VOID_TO_BLOCK_POOL_POINTER_CONVERT

#define TX_VOID_TO_BLOCK_POOL_POINTER_CONVERT ( a ) ((TX_BLOCK_POOL *) ((VOID *) (a)))

◆ TX_VOID_TO_BYTE_POOL_POINTER_CONVERT

#define TX_VOID_TO_BYTE_POOL_POINTER_CONVERT ( a ) ((TX_BYTE_POOL *) ((VOID *) (a)))

◆ TX_VOID_TO_EVENT_FLAGS_POINTER_CONVERT

#define TX_VOID_TO_EVENT_FLAGS_POINTER_CONVERT ( a ) ((TX_EVENT_FLAGS_GROUP *) ((VOID *) (a)))

◆ TX_VOID_TO_INDIRECT_UCHAR_POINTER_CONVERT

#define TX_VOID_TO_INDIRECT_UCHAR_POINTER_CONVERT ( a ) ((UCHAR **) ((VOID *) (a)))

◆ TX_VOID_TO_MUTEX_POINTER_CONVERT

#define TX_VOID_TO_MUTEX_POINTER_CONVERT ( a ) ((TX_MUTEX *) ((VOID *) (a)))

◆ TX_VOID_TO_QUEUE_POINTER_CONVERT

#define TX_VOID_TO_QUEUE_POINTER_CONVERT ( a ) ((TX_QUEUE *) ((VOID *) (a)))

◆ TX_VOID_TO_SEMAPHORE_POINTER_CONVERT

#define TX_VOID_TO_SEMAPHORE_POINTER_CONVERT ( a ) ((TX_SEMAPHORE *) ((VOID *) (a)))

◆ TX_VOID_TO_THREAD_POINTER_CONVERT

#define TX_VOID_TO_THREAD_POINTER_CONVERT ( a ) ((TX_THREAD *) ((VOID *) (a)))

◆ TX_VOID_TO_UCHAR_POINTER_CONVERT

#define TX_VOID_TO_UCHAR_POINTER_CONVERT ( a ) ((UCHAR *) ((VOID *) (a)))

◆ TX_VOID_TO_ULONG_POINTER_CONVERT

#define TX_VOID_TO_ULONG_POINTER_CONVERT ( a ) ((ULONG *) ((VOID *) (a)))

◆ TX_WAIT_ABORT_ERROR

#define TX_WAIT_ABORT_ERROR ((UINT) 0x1B)

◆ TX_WAIT_ABORTED

#define TX_WAIT_ABORTED ((UINT) 0x1A)

◆ TX_WAIT_ERROR

#define TX_WAIT_ERROR ((UINT) 0x04)

◆ TX_WAIT_FOREVER

#define TX_WAIT_FOREVER ((ULONG) 0xFFFFFFFFUL)

Typedef Documentation

◆ TX_BLOCK_POOL

typedef struct TX_BLOCK_POOL_STRUCT TX_BLOCK_POOL

◆ TX_BYTE_POOL

typedef struct TX_BYTE_POOL_STRUCT TX_BYTE_POOL

◆ TX_EVENT_FLAGS_GROUP

typedef struct TX_EVENT_FLAGS_GROUP_STRUCT TX_EVENT_FLAGS_GROUP

◆ TX_MUTEX

typedef struct TX_MUTEX_STRUCT TX_MUTEX

◆ TX_QUEUE

typedef struct TX_QUEUE_STRUCT TX_QUEUE

◆ TX_SEMAPHORE

typedef struct TX_SEMAPHORE_STRUCT TX_SEMAPHORE

◆ TX_THREAD

typedef struct TX_THREAD_STRUCT TX_THREAD

◆ TX_TIMER

typedef struct TX_TIMER_STRUCT TX_TIMER

◆ TX_TIMER_INTERNAL

typedef struct TX_TIMER_INTERNAL_STRUCT TX_TIMER_INTERNAL

Function Documentation

◆ _tx_block_allocate()

UINT _tx_block_allocate	(	TX_BLOCK_POOL *	pool_ptr,
		VOID **	block_ptr,
		ULONG	wait_option
	)

◆ _tx_block_pool_create()

UINT _tx_block_pool_create	(	TX_BLOCK_POOL *	pool_ptr,
		CHAR *	name_ptr,
		ULONG	block_size,
		VOID *	pool_start,
		ULONG	pool_size
	)

◆ _tx_block_pool_delete()

UINT _tx_block_pool_delete ( TX_BLOCK_POOL * pool_ptr )

◆ _tx_block_pool_info_get()

UINT _tx_block_pool_info_get	(	TX_BLOCK_POOL *	pool_ptr,
		CHAR **	name,
		ULONG *	available_blocks,
		ULONG *	total_blocks,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_BLOCK_POOL **	next_pool
	)

◆ _tx_block_pool_performance_info_get()

UINT _tx_block_pool_performance_info_get	(	TX_BLOCK_POOL *	pool_ptr,
		ULONG *	allocates,
		ULONG *	releases,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ _tx_block_pool_performance_system_info_get()

UINT _tx_block_pool_performance_system_info_get	(	ULONG *	allocates,
		ULONG *	releases,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ _tx_block_pool_prioritize()

UINT _tx_block_pool_prioritize ( TX_BLOCK_POOL * pool_ptr )

◆ _tx_block_release()

UINT _tx_block_release ( VOID * block_ptr )

◆ _tx_byte_allocate()

UINT _tx_byte_allocate	(	TX_BYTE_POOL *	pool_ptr,
		VOID **	memory_ptr,
		ULONG	memory_size,
		ULONG	wait_option
	)

◆ _tx_byte_pool_create()

UINT _tx_byte_pool_create	(	TX_BYTE_POOL *	pool_ptr,
		CHAR *	name_ptr,
		VOID *	pool_start,
		ULONG	pool_size
	)

◆ _tx_byte_pool_delete()

UINT _tx_byte_pool_delete ( TX_BYTE_POOL * pool_ptr )

◆ _tx_byte_pool_info_get()

UINT _tx_byte_pool_info_get	(	TX_BYTE_POOL *	pool_ptr,
		CHAR **	name,
		ULONG *	available_bytes,
		ULONG *	fragments,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_BYTE_POOL **	next_pool
	)

◆ _tx_byte_pool_performance_info_get()

UINT _tx_byte_pool_performance_info_get	(	TX_BYTE_POOL *	pool_ptr,
		ULONG *	allocates,
		ULONG *	releases,
		ULONG *	fragments_searched,
		ULONG *	merges,
		ULONG *	splits,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ _tx_byte_pool_performance_system_info_get()

UINT _tx_byte_pool_performance_system_info_get	(	ULONG *	allocates,
		ULONG *	releases,
		ULONG *	fragments_searched,
		ULONG *	merges,
		ULONG *	splits,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ _tx_byte_pool_prioritize()

UINT _tx_byte_pool_prioritize ( TX_BYTE_POOL * pool_ptr )

◆ _tx_byte_release()

UINT _tx_byte_release ( VOID * memory_ptr )

◆ _tx_event_flags_create()

UINT _tx_event_flags_create	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		CHAR *	name_ptr
	)

◆ _tx_event_flags_delete()

UINT _tx_event_flags_delete ( TX_EVENT_FLAGS_GROUP * group_ptr )

◆ _tx_event_flags_get()

UINT _tx_event_flags_get	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		ULONG	requested_flags,
		UINT	get_option,
		ULONG *	actual_flags_ptr,
		ULONG	wait_option
	)

◆ _tx_event_flags_info_get()

UINT _tx_event_flags_info_get	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		CHAR **	name,
		ULONG *	current_flags,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_EVENT_FLAGS_GROUP **	next_group
	)

◆ _tx_event_flags_performance_info_get()

UINT _tx_event_flags_performance_info_get	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		ULONG *	sets,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ _tx_event_flags_performance_system_info_get()

UINT _tx_event_flags_performance_system_info_get	(	ULONG *	sets,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ _tx_event_flags_set()

UINT _tx_event_flags_set	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		ULONG	flags_to_set,
		UINT	set_option
	)

◆ _tx_event_flags_set_notify()

UINT _tx_event_flags_set_notify	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		VOID()(TX_EVENT_FLAGS_GROUP notify_group_ptr)	events_set_notify
	)

◆ _tx_initialize_kernel_enter()

VOID _tx_initialize_kernel_enter ( VOID )

◆ _tx_mutex_create()

UINT _tx_mutex_create	(	TX_MUTEX *	mutex_ptr,
		CHAR *	name_ptr,
		UINT	inherit
	)

◆ _tx_mutex_delete()

UINT _tx_mutex_delete ( TX_MUTEX * mutex_ptr )

◆ _tx_mutex_get()

UINT _tx_mutex_get	(	TX_MUTEX *	mutex_ptr,
		ULONG	wait_option
	)

◆ _tx_mutex_info_get()

UINT _tx_mutex_info_get	(	TX_MUTEX *	mutex_ptr,
		CHAR **	name,
		ULONG *	count,
		TX_THREAD **	owner,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_MUTEX **	next_mutex
	)

◆ _tx_mutex_performance_info_get()

UINT _tx_mutex_performance_info_get	(	TX_MUTEX *	mutex_ptr,
		ULONG *	puts,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts,
		ULONG *	inversions,
		ULONG *	inheritances
	)

◆ _tx_mutex_performance_system_info_get()

UINT _tx_mutex_performance_system_info_get	(	ULONG *	puts,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts,
		ULONG *	inversions,
		ULONG *	inheritances
	)

◆ _tx_mutex_prioritize()

UINT _tx_mutex_prioritize ( TX_MUTEX * mutex_ptr )

◆ _tx_mutex_put()

UINT _tx_mutex_put ( TX_MUTEX * mutex_ptr )

◆ _tx_queue_create()

UINT _tx_queue_create	(	TX_QUEUE *	queue_ptr,
		CHAR *	name_ptr,
		UINT	message_size,
		VOID *	queue_start,
		ULONG	queue_size
	)

◆ _tx_queue_delete()

UINT _tx_queue_delete ( TX_QUEUE * queue_ptr )

◆ _tx_queue_flush()

UINT _tx_queue_flush ( TX_QUEUE * queue_ptr )

◆ _tx_queue_front_send()

UINT _tx_queue_front_send	(	TX_QUEUE *	queue_ptr,
		VOID *	source_ptr,
		ULONG	wait_option
	)

◆ _tx_queue_info_get()

UINT _tx_queue_info_get	(	TX_QUEUE *	queue_ptr,
		CHAR **	name,
		ULONG *	enqueued,
		ULONG *	available_storage,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_QUEUE **	next_queue
	)

◆ _tx_queue_performance_info_get()

UINT _tx_queue_performance_info_get	(	TX_QUEUE *	queue_ptr,
		ULONG *	messages_sent,
		ULONG *	messages_received,
		ULONG *	empty_suspensions,
		ULONG *	full_suspensions,
		ULONG *	full_errors,
		ULONG *	timeouts
	)

◆ _tx_queue_performance_system_info_get()

UINT _tx_queue_performance_system_info_get	(	ULONG *	messages_sent,
		ULONG *	messages_received,
		ULONG *	empty_suspensions,
		ULONG *	full_suspensions,
		ULONG *	full_errors,
		ULONG *	timeouts
	)

◆ _tx_queue_prioritize()

UINT _tx_queue_prioritize ( TX_QUEUE * queue_ptr )

◆ _tx_queue_receive()

UINT _tx_queue_receive	(	TX_QUEUE *	queue_ptr,
		VOID *	destination_ptr,
		ULONG	wait_option
	)

◆ _tx_queue_send()

UINT _tx_queue_send	(	TX_QUEUE *	queue_ptr,
		VOID *	source_ptr,
		ULONG	wait_option
	)

◆ _tx_queue_send_notify()

UINT _tx_queue_send_notify	(	TX_QUEUE *	queue_ptr,
		VOID()(TX_QUEUE notify_queue_ptr)	queue_send_notify
	)

◆ _tx_semaphore_ceiling_put()

UINT _tx_semaphore_ceiling_put	(	TX_SEMAPHORE *	semaphore_ptr,
		ULONG	ceiling
	)

◆ _tx_semaphore_create()

UINT _tx_semaphore_create	(	TX_SEMAPHORE *	semaphore_ptr,
		CHAR *	name_ptr,
		ULONG	initial_count
	)

◆ _tx_semaphore_delete()

UINT _tx_semaphore_delete ( TX_SEMAPHORE * semaphore_ptr )

◆ _tx_semaphore_get()

UINT _tx_semaphore_get	(	TX_SEMAPHORE *	semaphore_ptr,
		ULONG	wait_option
	)

◆ _tx_semaphore_info_get()

UINT _tx_semaphore_info_get	(	TX_SEMAPHORE *	semaphore_ptr,
		CHAR **	name,
		ULONG *	current_value,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_SEMAPHORE **	next_semaphore
	)

◆ _tx_semaphore_performance_info_get()

UINT _tx_semaphore_performance_info_get	(	TX_SEMAPHORE *	semaphore_ptr,
		ULONG *	puts,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ _tx_semaphore_performance_system_info_get()

UINT _tx_semaphore_performance_system_info_get	(	ULONG *	puts,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ _tx_semaphore_prioritize()

UINT _tx_semaphore_prioritize ( TX_SEMAPHORE * semaphore_ptr )

◆ _tx_semaphore_put()

UINT _tx_semaphore_put ( TX_SEMAPHORE * semaphore_ptr )

◆ _tx_semaphore_put_notify()

UINT _tx_semaphore_put_notify	(	TX_SEMAPHORE *	semaphore_ptr,
		VOID()(TX_SEMAPHORE notify_semaphore_ptr)	semaphore_put_notify
	)

◆ _tx_thread_context_restore()

VOID _tx_thread_context_restore ( VOID )

◆ _tx_thread_context_save()

VOID _tx_thread_context_save ( VOID )

◆ _tx_thread_create()

UINT _tx_thread_create	(	TX_THREAD *	thread_ptr,
		CHAR *	name_ptr,
		VOID(*)(ULONG entry_input)	entry_function,
		ULONG	entry_input,
		VOID *	stack_start,
		ULONG	stack_size,
		UINT	priority,
		UINT	preempt_threshold,
		ULONG	time_slice,
		UINT	auto_start
	)

◆ _tx_thread_delete()

UINT _tx_thread_delete ( TX_THREAD * thread_ptr )

◆ _tx_thread_entry_exit_notify()

UINT _tx_thread_entry_exit_notify	(	TX_THREAD *	thread_ptr,
		VOID()(TX_THREAD notify_thread_ptr, UINT type)	thread_entry_exit_notify
	)

◆ _tx_thread_identify()

TX_THREAD* _tx_thread_identify ( VOID )

◆ _tx_thread_info_get()

UINT _tx_thread_info_get	(	TX_THREAD *	thread_ptr,
		CHAR **	name,
		UINT *	state,
		ULONG *	run_count,
		UINT *	priority,
		UINT *	preemption_threshold,
		ULONG *	time_slice,
		TX_THREAD **	next_thread,
		TX_THREAD **	next_suspended_thread
	)

◆ _tx_thread_interrupt_control()

UINT _tx_thread_interrupt_control ( UINT new_posture )

◆ _tx_thread_performance_info_get()

UINT _tx_thread_performance_info_get	(	TX_THREAD *	thread_ptr,
		ULONG *	resumptions,
		ULONG *	suspensions,
		ULONG *	solicited_preemptions,
		ULONG *	interrupt_preemptions,
		ULONG *	priority_inversions,
		ULONG *	time_slices,
		ULONG *	relinquishes,
		ULONG *	timeouts,
		ULONG *	wait_aborts,
		TX_THREAD **	last_preempted_by
	)

◆ _tx_thread_performance_system_info_get()

UINT _tx_thread_performance_system_info_get	(	ULONG *	resumptions,
		ULONG *	suspensions,
		ULONG *	solicited_preemptions,
		ULONG *	interrupt_preemptions,
		ULONG *	priority_inversions,
		ULONG *	time_slices,
		ULONG *	relinquishes,
		ULONG *	timeouts,
		ULONG *	wait_aborts,
		ULONG *	non_idle_returns,
		ULONG *	idle_returns
	)

◆ _tx_thread_preemption_change()

UINT _tx_thread_preemption_change	(	TX_THREAD *	thread_ptr,
		UINT	new_threshold,
		UINT *	old_threshold
	)

◆ _tx_thread_priority_change()

UINT _tx_thread_priority_change	(	TX_THREAD *	thread_ptr,
		UINT	new_priority,
		UINT *	old_priority
	)

◆ _tx_thread_relinquish()

VOID _tx_thread_relinquish ( VOID )

◆ _tx_thread_reset()

UINT _tx_thread_reset ( TX_THREAD * thread_ptr )

◆ _tx_thread_resume()

UINT _tx_thread_resume ( TX_THREAD * thread_ptr )

◆ _tx_thread_sleep()

UINT _tx_thread_sleep ( ULONG timer_ticks )

◆ _tx_thread_stack_error_notify()

UINT _tx_thread_stack_error_notify ( VOID(*)(TX_THREAD *thread_ptr) stack_error_handler )

◆ _tx_thread_suspend()

UINT _tx_thread_suspend ( TX_THREAD * thread_ptr )

◆ _tx_thread_terminate()

UINT _tx_thread_terminate ( TX_THREAD * thread_ptr )

◆ _tx_thread_time_slice_change()

UINT _tx_thread_time_slice_change	(	TX_THREAD *	thread_ptr,
		ULONG	new_time_slice,
		ULONG *	old_time_slice
	)

◆ _tx_thread_wait_abort()

UINT _tx_thread_wait_abort ( TX_THREAD * thread_ptr )

◆ _tx_time_get()

ULONG _tx_time_get ( VOID )

◆ _tx_time_set()

VOID _tx_time_set ( ULONG new_time )

◆ _tx_timer_activate()

UINT _tx_timer_activate ( TX_TIMER * timer_ptr )

◆ _tx_timer_change()

UINT _tx_timer_change	(	TX_TIMER *	timer_ptr,
		ULONG	initial_ticks,
		ULONG	reschedule_ticks
	)

◆ _tx_timer_create()

UINT _tx_timer_create	(	TX_TIMER *	timer_ptr,
		CHAR *	name_ptr,
		VOID(*)(ULONG input)	expiration_function,
		ULONG	expiration_input,
		ULONG	initial_ticks,
		ULONG	reschedule_ticks,
		UINT	auto_activate
	)

◆ _tx_timer_deactivate()

UINT _tx_timer_deactivate ( TX_TIMER * timer_ptr )

◆ _tx_timer_delete()

UINT _tx_timer_delete ( TX_TIMER * timer_ptr )

◆ _tx_timer_info_get()

UINT _tx_timer_info_get	(	TX_TIMER *	timer_ptr,
		CHAR **	name,
		UINT *	active,
		ULONG *	remaining_ticks,
		ULONG *	reschedule_ticks,
		TX_TIMER **	next_timer
	)

◆ _tx_timer_performance_info_get()

UINT _tx_timer_performance_info_get	(	TX_TIMER *	timer_ptr,
		ULONG *	activates,
		ULONG *	reactivates,
		ULONG *	deactivates,
		ULONG *	expirations,
		ULONG *	expiration_adjusts
	)

◆ _tx_timer_performance_system_info_get()

UINT _tx_timer_performance_system_info_get	(	ULONG *	activates,
		ULONG *	reactivates,
		ULONG *	deactivates,
		ULONG *	expirations,
		ULONG *	expiration_adjusts
	)

◆ _tx_trace_buffer_full_notify()

UINT _tx_trace_buffer_full_notify ( VOID(*)(VOID *buffer) full_buffer_callback )

◆ _tx_trace_disable()

UINT _tx_trace_disable ( VOID )

◆ _tx_trace_enable()

UINT _tx_trace_enable	(	VOID *	trace_buffer_start,
		ULONG	trace_buffer_size,
		ULONG	registry_entries
	)

◆ _tx_trace_event_filter()

UINT _tx_trace_event_filter ( ULONG event_filter_bits )

◆ _tx_trace_event_unfilter()

UINT _tx_trace_event_unfilter ( ULONG event_unfilter_bits )

◆ _tx_trace_interrupt_control()

UINT _tx_trace_interrupt_control ( UINT new_posture )

◆ _tx_trace_isr_enter_insert()

VOID _tx_trace_isr_enter_insert ( ULONG isr_id )

◆ _tx_trace_isr_exit_insert()

VOID _tx_trace_isr_exit_insert ( ULONG isr_id )

◆ _tx_trace_user_event_insert()

UINT _tx_trace_user_event_insert	(	ULONG	event_id,
		ULONG	info_field_1,
		ULONG	info_field_2,
		ULONG	info_field_3,
		ULONG	info_field_4
	)

◆ _txe_block_allocate()

UINT _txe_block_allocate	(	TX_BLOCK_POOL *	pool_ptr,
		VOID **	block_ptr,
		ULONG	wait_option
	)

◆ _txe_block_pool_create()

UINT _txe_block_pool_create	(	TX_BLOCK_POOL *	pool_ptr,
		CHAR *	name_ptr,
		ULONG	block_size,
		VOID *	pool_start,
		ULONG	pool_size,
		UINT	pool_control_block_size
	)

◆ _txe_block_pool_delete()

UINT _txe_block_pool_delete ( TX_BLOCK_POOL * pool_ptr )

◆ _txe_block_pool_info_get()

UINT _txe_block_pool_info_get	(	TX_BLOCK_POOL *	pool_ptr,
		CHAR **	name,
		ULONG *	available_blocks,
		ULONG *	total_blocks,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_BLOCK_POOL **	next_pool
	)

◆ _txe_block_pool_prioritize()

UINT _txe_block_pool_prioritize ( TX_BLOCK_POOL * pool_ptr )

◆ _txe_block_release()

UINT _txe_block_release ( VOID * block_ptr )

◆ _txe_byte_allocate()

UINT _txe_byte_allocate	(	TX_BYTE_POOL *	pool_ptr,
		VOID **	memory_ptr,
		ULONG	memory_size,
		ULONG	wait_option
	)

◆ _txe_byte_pool_create()

UINT _txe_byte_pool_create	(	TX_BYTE_POOL *	pool_ptr,
		CHAR *	name_ptr,
		VOID *	pool_start,
		ULONG	pool_size,
		UINT	pool_control_block_size
	)

◆ _txe_byte_pool_delete()

UINT _txe_byte_pool_delete ( TX_BYTE_POOL * pool_ptr )

◆ _txe_byte_pool_info_get()

UINT _txe_byte_pool_info_get	(	TX_BYTE_POOL *	pool_ptr,
		CHAR **	name,
		ULONG *	available_bytes,
		ULONG *	fragments,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_BYTE_POOL **	next_pool
	)

◆ _txe_byte_pool_prioritize()

UINT _txe_byte_pool_prioritize ( TX_BYTE_POOL * pool_ptr )

◆ _txe_byte_release()

UINT _txe_byte_release ( VOID * memory_ptr )

◆ _txe_event_flags_create()

UINT _txe_event_flags_create	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		CHAR *	name_ptr,
		UINT	event_control_block_size
	)

◆ _txe_event_flags_delete()

UINT _txe_event_flags_delete ( TX_EVENT_FLAGS_GROUP * group_ptr )

◆ _txe_event_flags_get()

UINT _txe_event_flags_get	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		ULONG	requested_flags,
		UINT	get_option,
		ULONG *	actual_flags_ptr,
		ULONG	wait_option
	)

◆ _txe_event_flags_info_get()

UINT _txe_event_flags_info_get	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		CHAR **	name,
		ULONG *	current_flags,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_EVENT_FLAGS_GROUP **	next_group
	)

◆ _txe_event_flags_set()

UINT _txe_event_flags_set	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		ULONG	flags_to_set,
		UINT	set_option
	)

◆ _txe_event_flags_set_notify()

UINT _txe_event_flags_set_notify	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		VOID()(TX_EVENT_FLAGS_GROUP notify_group_ptr)	events_set_notify
	)

◆ _txe_mutex_create()

UINT _txe_mutex_create	(	TX_MUTEX *	mutex_ptr,
		CHAR *	name_ptr,
		UINT	inherit,
		UINT	mutex_control_block_size
	)

◆ _txe_mutex_delete()

UINT _txe_mutex_delete ( TX_MUTEX * mutex_ptr )

◆ _txe_mutex_get()

UINT _txe_mutex_get	(	TX_MUTEX *	mutex_ptr,
		ULONG	wait_option
	)

◆ _txe_mutex_info_get()

UINT _txe_mutex_info_get	(	TX_MUTEX *	mutex_ptr,
		CHAR **	name,
		ULONG *	count,
		TX_THREAD **	owner,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_MUTEX **	next_mutex
	)

◆ _txe_mutex_prioritize()

UINT _txe_mutex_prioritize ( TX_MUTEX * mutex_ptr )

◆ _txe_mutex_put()

UINT _txe_mutex_put ( TX_MUTEX * mutex_ptr )

◆ _txe_queue_create()

UINT _txe_queue_create	(	TX_QUEUE *	queue_ptr,
		CHAR *	name_ptr,
		UINT	message_size,
		VOID *	queue_start,
		ULONG	queue_size,
		UINT	queue_control_block_size
	)

◆ _txe_queue_delete()

UINT _txe_queue_delete ( TX_QUEUE * queue_ptr )

◆ _txe_queue_flush()

UINT _txe_queue_flush ( TX_QUEUE * queue_ptr )

◆ _txe_queue_front_send()

UINT _txe_queue_front_send	(	TX_QUEUE *	queue_ptr,
		VOID *	source_ptr,
		ULONG	wait_option
	)

◆ _txe_queue_info_get()

UINT _txe_queue_info_get	(	TX_QUEUE *	queue_ptr,
		CHAR **	name,
		ULONG *	enqueued,
		ULONG *	available_storage,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_QUEUE **	next_queue
	)

◆ _txe_queue_prioritize()

UINT _txe_queue_prioritize ( TX_QUEUE * queue_ptr )

◆ _txe_queue_receive()

UINT _txe_queue_receive	(	TX_QUEUE *	queue_ptr,
		VOID *	destination_ptr,
		ULONG	wait_option
	)

◆ _txe_queue_send()

UINT _txe_queue_send	(	TX_QUEUE *	queue_ptr,
		VOID *	source_ptr,
		ULONG	wait_option
	)

◆ _txe_queue_send_notify()

UINT _txe_queue_send_notify	(	TX_QUEUE *	queue_ptr,
		VOID()(TX_QUEUE notify_queue_ptr)	queue_send_notify
	)

◆ _txe_semaphore_ceiling_put()

UINT _txe_semaphore_ceiling_put	(	TX_SEMAPHORE *	semaphore_ptr,
		ULONG	ceiling
	)

◆ _txe_semaphore_create()

UINT _txe_semaphore_create	(	TX_SEMAPHORE *	semaphore_ptr,
		CHAR *	name_ptr,
		ULONG	initial_count,
		UINT	semaphore_control_block_size
	)

◆ _txe_semaphore_delete()

UINT _txe_semaphore_delete ( TX_SEMAPHORE * semaphore_ptr )

◆ _txe_semaphore_get()

UINT _txe_semaphore_get	(	TX_SEMAPHORE *	semaphore_ptr,
		ULONG	wait_option
	)

◆ _txe_semaphore_info_get()

UINT _txe_semaphore_info_get	(	TX_SEMAPHORE *	semaphore_ptr,
		CHAR **	name,
		ULONG *	current_value,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_SEMAPHORE **	next_semaphore
	)

◆ _txe_semaphore_prioritize()

UINT _txe_semaphore_prioritize ( TX_SEMAPHORE * semaphore_ptr )

◆ _txe_semaphore_put()

UINT _txe_semaphore_put ( TX_SEMAPHORE * semaphore_ptr )

◆ _txe_semaphore_put_notify()

UINT _txe_semaphore_put_notify	(	TX_SEMAPHORE *	semaphore_ptr,
		VOID()(TX_SEMAPHORE notify_semaphore_ptr)	semaphore_put_notify
	)

◆ _txe_thread_create()

UINT _txe_thread_create	(	TX_THREAD *	thread_ptr,
		CHAR *	name_ptr,
		VOID(*)(ULONG entry_input)	entry_function,
		ULONG	entry_input,
		VOID *	stack_start,
		ULONG	stack_size,
		UINT	priority,
		UINT	preempt_threshold,
		ULONG	time_slice,
		UINT	auto_start,
		UINT	thread_control_block_size
	)

◆ _txe_thread_delete()

UINT _txe_thread_delete ( TX_THREAD * thread_ptr )

◆ _txe_thread_entry_exit_notify()

UINT _txe_thread_entry_exit_notify	(	TX_THREAD *	thread_ptr,
		VOID()(TX_THREAD notify_thread_ptr, UINT type)	thread_entry_exit_notify
	)

◆ _txe_thread_info_get()

UINT _txe_thread_info_get	(	TX_THREAD *	thread_ptr,
		CHAR **	name,
		UINT *	state,
		ULONG *	run_count,
		UINT *	priority,
		UINT *	preemption_threshold,
		ULONG *	time_slice,
		TX_THREAD **	next_thread,
		TX_THREAD **	next_suspended_thread
	)

◆ _txe_thread_preemption_change()

UINT _txe_thread_preemption_change	(	TX_THREAD *	thread_ptr,
		UINT	new_threshold,
		UINT *	old_threshold
	)

◆ _txe_thread_priority_change()

UINT _txe_thread_priority_change	(	TX_THREAD *	thread_ptr,
		UINT	new_priority,
		UINT *	old_priority
	)

◆ _txe_thread_relinquish()

VOID _txe_thread_relinquish ( VOID )

◆ _txe_thread_reset()

UINT _txe_thread_reset ( TX_THREAD * thread_ptr )

◆ _txe_thread_resume()

UINT _txe_thread_resume ( TX_THREAD * thread_ptr )

◆ _txe_thread_suspend()

UINT _txe_thread_suspend ( TX_THREAD * thread_ptr )

◆ _txe_thread_terminate()

UINT _txe_thread_terminate ( TX_THREAD * thread_ptr )

◆ _txe_thread_time_slice_change()

UINT _txe_thread_time_slice_change	(	TX_THREAD *	thread_ptr,
		ULONG	new_time_slice,
		ULONG *	old_time_slice
	)

◆ _txe_thread_wait_abort()

UINT _txe_thread_wait_abort ( TX_THREAD * thread_ptr )

◆ _txe_timer_activate()

UINT _txe_timer_activate ( TX_TIMER * timer_ptr )

◆ _txe_timer_change()

UINT _txe_timer_change	(	TX_TIMER *	timer_ptr,
		ULONG	initial_ticks,
		ULONG	reschedule_ticks
	)

◆ _txe_timer_create()

UINT _txe_timer_create	(	TX_TIMER *	timer_ptr,
		CHAR *	name_ptr,
		VOID(*)(ULONG input)	expiration_function,
		ULONG	expiration_input,
		ULONG	initial_ticks,
		ULONG	reschedule_ticks,
		UINT	auto_activate,
		UINT	timer_control_block_size
	)

◆ _txe_timer_deactivate()

UINT _txe_timer_deactivate ( TX_TIMER * timer_ptr )

◆ _txe_timer_delete()

UINT _txe_timer_delete ( TX_TIMER * timer_ptr )

◆ _txe_timer_info_get()

UINT _txe_timer_info_get	(	TX_TIMER *	timer_ptr,
		CHAR **	name,
		UINT *	active,
		ULONG *	remaining_ticks,
		ULONG *	reschedule_ticks,
		TX_TIMER **	next_timer
	)

◆ tx_application_define()

VOID tx_application_define ( VOID * first_unused_memory )

Classes

Macros

Typedefs

Functions