Imagelibrary/threadx
1
0
Fork 1
mirror of https://github.com/eclipse-threadx/threadx.git synced 2025-11-16 12:34:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Release 6.1.9

Browse Source
This commit is contained in:
Yuxin Zhou
2021-10-14 00:51:26 +00:00
parent 215df45d4b
commit 1af8404c54
1812 changed files with 60698 additions and 249862 deletions
Download Patch File Download Diff File Expand all files Collapse all files

265
common/inc/tx_api.h
View File

@@ -26,7 +26,7 @@
/* APPLICATION INTERFACE DEFINITION RELEASE */
/* */
/* tx_api.h PORTABLE C */
/* 6.1.8 */
/* 6.1.9 */
/* AUTHOR */
/* */
/* William E. Lamie, Microsoft Corporation */
@@ -71,10 +71,13 @@
/* resulting in version 6.1.6 */
/* 06-02-2021 Yuxin Zhou Modified comment(s), added */
/* Execution Profile support, */
/* resulting in version 6.1.7 */
/* resulting in version 6.1.7 */
/* 08-02-2021 Scott Larson Modified comment(s), and */
/* update patch number, */
/* resulting in version 6.1.8 */
/* 10-15-2021 Yuxin Zhou Modified comment(s), */
/* update patch number, */
/* resulting in version 6.1.9 */
/* */
/**************************************************************************/
@@ -101,13 +104,13 @@ extern "C" {
/* Define basic constants for the ThreadX kernel. */
/* Define the major/minor version information that can be used by the application
/* Define the major/minor version information that can be used by the application
and the ThreadX source as well. */
#define AZURE_RTOS_THREADX
#define THREADX_MAJOR_VERSION 6
#define THREADX_MINOR_VERSION 1
#define THREADX_PATCH_VERSION 8
#define THREADX_PATCH_VERSION 9
/* Define the following symbol for backward compatibility */
#define EL_PRODUCT_THREADX
@@ -214,16 +217,16 @@ extern "C" {
#endif
/* Event numbers 0 through 4095 are reserved by Azure RTOS. Specific event assignments are:
ThreadX events: 1-199
/* Event numbers 0 through 4095 are reserved by Azure RTOS. Specific event assignments are:
ThreadX events: 1-199
FileX events: 200-299
NetX events: 300-599
USBX events: 600-999
GUIX events: 1000-1500
User-defined event numbers start at 4096 and continue through 65535, as defined by the constants
TX_TRACE_USER_EVENT_START and TX_TRACE_USER_EVENT_END, respectively. User events should be based
User-defined event numbers start at 4096 and continue through 65535, as defined by the constants
TX_TRACE_USER_EVENT_START and TX_TRACE_USER_EVENT_END, respectively. User events should be based
on these constants in case the user event number assignment is changed in future releases. */
#define TX_TRACE_USER_EVENT_START 4096 /* I1, I2, I3, I4 are user defined */
@@ -249,7 +252,7 @@ extern "C" {
/* Define basic alignment type used in block and byte pool operations. This data type must
be at least 32-bits in size and also be large enough to hold a pointer type. */
#ifndef ALIGN_TYPE_DEFINED
#define ALIGN_TYPE ULONG
#endif
@@ -258,10 +261,10 @@ extern "C" {
/* Define the control block definitions for all system objects. */
/* Define the basic timer management structures. These are the structures
/* Define the basic timer management structures. These are the structures
used to manage thread sleep, timeout, and user timer requests. */
/* Determine if the internal timer control block has an extension defined. If not,
/* Determine if the internal timer control block has an extension defined. If not,
define the extension to whitespace. */
#ifndef TX_TIMER_INTERNAL_EXTENSION
@@ -299,7 +302,7 @@ typedef struct TX_TIMER_INTERNAL_STRUCT
} TX_TIMER_INTERNAL;
/* Determine if the timer control block has an extension defined. If not,
/* Determine if the timer control block has an extension defined. If not,
define the extension to whitespace. */
#ifndef TX_TIMER_EXTENSION
@@ -358,7 +361,7 @@ typedef struct TX_TIMER_STRUCT
typedef struct TX_THREAD_STRUCT
{
/* The first section of the control block contains critical
information that is referenced by the port-specific
information that is referenced by the port-specific
assembly language code. Any changes in this section could
necessitate changes in the assembly language. */
@@ -378,38 +381,38 @@ typedef struct TX_THREAD_STRUCT
/***************************************************************/
/* Define the first port extension in the thread control block. This
/* Define the first port extension in the thread control block. This
is typically defined to whitespace or a pointer type in tx_port.h. */
TX_THREAD_EXTENSION_0
CHAR *tx_thread_name; /* Pointer to thread's name */
UINT tx_thread_priority; /* Priority of thread (0-1023) */
UINT tx_thread_state; /* Thread's execution state */
UINT tx_thread_delayed_suspend; /* Delayed suspend flag */
UINT tx_thread_suspending; /* Thread suspending flag */
UINT tx_thread_preempt_threshold; /* Preemption threshold */
/* Define the thread schedule hook. The usage of this is port/application specific,
/* Define the thread schedule hook. The usage of this is port/application specific,
but when used, the function pointer designated is called whenever the thread is
scheduled and unscheduled. */
VOID (*tx_thread_schedule_hook)(struct TX_THREAD_STRUCT *thread_ptr, ULONG id);
/* Nothing after this point is referenced by the target-specific
assembly language. Hence, information after this point can
be added to the control block providing the complete system
assembly language. Hence, information after this point can
be added to the control block providing the complete system
is recompiled. */
/* Define the thread's entry point and input parameter. */
VOID (*tx_thread_entry)(ULONG id);
ULONG tx_thread_entry_parameter;
/* Define the thread's timer block. This is used for thread
/* Define the thread's timer block. This is used for thread
sleep and timeout requests. */
TX_TIMER_INTERNAL tx_thread_timer;
/* Define the thread's cleanup function and associated data. This
is used to cleanup various data structures when a thread
suspension is lifted or terminated either by the user or
is used to cleanup various data structures when a thread
suspension is lifted or terminated either by the user or
a timeout. */
VOID (*tx_thread_suspend_cleanup)(struct TX_THREAD_STRUCT *thread_ptr, ULONG suspension_sequence);
VOID *tx_thread_suspend_control_block;
@@ -421,17 +424,17 @@ typedef struct TX_THREAD_STRUCT
UINT tx_thread_suspend_option;
UINT tx_thread_suspend_status;
/* Define the second port extension in the thread control block. This
/* Define the second port extension in the thread control block. This
is typically defined to whitespace or a pointer type in tx_port.h. */
TX_THREAD_EXTENSION_1
/* Define pointers to the next and previous threads in the
/* Define pointers to the next and previous threads in the
created list. */
struct TX_THREAD_STRUCT
*tx_thread_created_next,
*tx_thread_created_previous;
/* Define the third port extension in the thread control block. This
/* Define the third port extension in the thread control block. This
is typically defined to whitespace in tx_port.h. */
TX_THREAD_EXTENSION_2
@@ -439,14 +442,14 @@ typedef struct TX_THREAD_STRUCT
#ifndef TX_NO_FILEX_POINTER
VOID *tx_thread_filex_ptr;
#endif
/* Define the priority inheritance variables. These will be used
to manage priority inheritance changes applied to this thread
to manage priority inheritance changes applied to this thread
as a result of mutex get operations. */
UINT tx_thread_user_priority;
UINT tx_thread_user_preempt_threshold;
UINT tx_thread_inherit_priority;
/* Define the owned mutex count and list head pointer. */
UINT tx_thread_owned_mutex_count;
struct TX_MUTEX_STRUCT
@@ -460,7 +463,7 @@ typedef struct TX_THREAD_STRUCT
/* Define the number of times this thread suspends. */
ULONG tx_thread_performance_suspend_count;
/* Define the number of times this thread is preempted by calling
/* Define the number of times this thread is preempted by calling
a ThreadX API service. */
ULONG tx_thread_performance_solicited_preemption_count;
@@ -495,33 +498,33 @@ typedef struct TX_THREAD_STRUCT
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
/* Define the application callback routine used to notify the application when
/* Define the application callback routine used to notify the application when
the thread is entered or exits. */
VOID (*tx_thread_entry_exit_notify)(struct TX_THREAD_STRUCT *thread_ptr, UINT type);
#endif
/* Define the fourth port extension in the thread control block. This
/* Define the fourth port extension in the thread control block. This
is typically defined to whitespace in tx_port.h. */
TX_THREAD_EXTENSION_3
/* Define variables for supporting execution profile. */
/* Note that in ThreadX 5.x, user would define TX_ENABLE_EXECUTION_CHANGE_NOTIFY and use TX_THREAD_EXTENSION_3
to define the following two variables.
to define the following two variables.
For Azure RTOS 6, user shall use TX_EXECUTION_PROFILE_ENABLE instead of TX_ENABLE_EXECUTION_CHANGE_NOTIFY,
and SHALL NOT add variables to TX_THREAD_EXTENSION_3. */
#if (defined(TX_EXECUTION_PROFILE_ENABLE) && !defined(TX_ENABLE_EXECUTION_CHANGE_NOTIFY))
unsigned long long tx_thread_execution_time_total;
unsigned long long tx_thread_execution_time_last_start;
unsigned long long tx_thread_execution_time_total;
unsigned long long tx_thread_execution_time_last_start;
#endif
/* Define suspension sequence number. This is used to ensure suspension is still valid when
/* Define suspension sequence number. This is used to ensure suspension is still valid when
cleanup routine executes. */
ULONG tx_thread_suspension_sequence;
/* Define the user extension field. This typically is defined
to white space, but some ports of ThreadX may need to have
additional fields in the thread control block. This is
/* Define the user extension field. This typically is defined
to white space, but some ports of ThreadX may need to have
additional fields in the thread control block. This is
defined in the file tx_port.h. */
TX_THREAD_USER_EXTENSION
@@ -583,14 +586,14 @@ typedef struct TX_BLOCK_POOL_STRUCT
ULONG tx_block_pool_performance_timeout_count;
#endif
/* Define the port extension in the block pool control block. This
/* Define the port extension in the block pool control block. This
is typically defined to whitespace in tx_port.h. */
TX_BLOCK_POOL_EXTENSION
} TX_BLOCK_POOL;
/* Determine if the byte allocate extension is defined. If not, define the
/* Determine if the byte allocate extension is defined. If not, define the
extension to whitespace. */
#ifndef TX_BYTE_ALLOCATE_EXTENSION
@@ -598,7 +601,7 @@ typedef struct TX_BLOCK_POOL_STRUCT
#endif
/* Determine if the byte release extension is defined. If not, define the
/* Determine if the byte release extension is defined. If not, define the
extension to whitespace. */
#ifndef TX_BYTE_RELEASE_EXTENSION
@@ -678,7 +681,7 @@ typedef struct TX_BYTE_POOL_STRUCT
ULONG tx_byte_pool_performance_timeout_count;
#endif
/* Define the port extension in the byte pool control block. This
/* Define the port extension in the byte pool control block. This
is typically defined to whitespace in tx_port.h. */
TX_BYTE_POOL_EXTENSION
@@ -696,7 +699,7 @@ typedef struct TX_EVENT_FLAGS_GROUP_STRUCT
/* Define the event flags group's name. */
CHAR *tx_event_flags_group_name;
/* Define the actual current event flags in this group. A zero in a
/* Define the actual current event flags in this group. A zero in a
particular bit indicates the event flag is not set. */
ULONG tx_event_flags_group_current;
@@ -735,19 +738,19 @@ typedef struct TX_EVENT_FLAGS_GROUP_STRUCT
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
/* Define the application callback routine used to notify the application when
/* Define the application callback routine used to notify the application when
an event flag is set. */
VOID (*tx_event_flags_group_set_notify)(struct TX_EVENT_FLAGS_GROUP_STRUCT *group_ptr);
#endif
/* Define the port extension in the event flags group control block. This
/* Define the port extension in the event flags group control block. This
is typically defined to whitespace in tx_port.h. */
TX_EVENT_FLAGS_GROUP_EXTENSION
} TX_EVENT_FLAGS_GROUP;
/* Determine if the mutex put extension 1 is defined. If not, define the
/* Determine if the mutex put extension 1 is defined. If not, define the
extension to whitespace. */
#ifndef TX_MUTEX_PUT_EXTENSION_1
@@ -755,7 +758,7 @@ typedef struct TX_EVENT_FLAGS_GROUP_STRUCT
#endif
/* Determine if the mutex put extension 2 is defined. If not, define the
/* Determine if the mutex put extension 2 is defined. If not, define the
extension to whitespace. */
#ifndef TX_MUTEX_PUT_EXTENSION_2
@@ -763,7 +766,7 @@ typedef struct TX_EVENT_FLAGS_GROUP_STRUCT
#endif
/* Determine if the mutex priority change extension is defined. If not, define the
/* Determine if the mutex priority change extension is defined. If not, define the
extension to whitespace. */
#ifndef TX_MUTEX_PRIORITY_CHANGE_EXTENSION
@@ -837,7 +840,7 @@ typedef struct TX_MUTEX_STRUCT
ULONG tx_mutex_performance__priority_inheritance_count;
#endif
/* Define the port extension in the mutex control block. This
/* Define the port extension in the mutex control block. This
is typically defined to whitespace in tx_port.h. */
TX_MUTEX_EXTENSION
@@ -866,7 +869,7 @@ typedef struct TX_QUEUE_STRUCT
UINT tx_queue_enqueued;
UINT tx_queue_available_storage;
/* Define pointers that represent the start and end for the queue's
/* Define pointers that represent the start and end for the queue's
message area. */
ULONG *tx_queue_start;
ULONG *tx_queue_end;
@@ -911,12 +914,12 @@ typedef struct TX_QUEUE_STRUCT
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
/* Define the application callback routine used to notify the application when
/* Define the application callback routine used to notify the application when
the a message is sent to the queue. */
VOID (*tx_queue_send_notify)(struct TX_QUEUE_STRUCT *queue_ptr);
#endif
/* Define the port extension in the queue control block. This
/* Define the port extension in the queue control block. This
is typically defined to whitespace in tx_port.h. */
TX_QUEUE_EXTENSION
@@ -966,29 +969,29 @@ typedef struct TX_SEMAPHORE_STRUCT
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
/* Define the application callback routine used to notify the application when
/* Define the application callback routine used to notify the application when
the a semaphore is put. */
VOID (*tx_semaphore_put_notify)(struct TX_SEMAPHORE_STRUCT *semaphore_ptr);
#endif
/* Define the port extension in the semaphore control block. This
/* Define the port extension in the semaphore control block. This
is typically defined to whitespace in tx_port.h. */
TX_SEMAPHORE_EXTENSION
} TX_SEMAPHORE;
/* Define the system API mappings based on the error checking
selected by the user. Note: this section is only applicable to
/* Define the system API mappings based on the error checking
selected by the user. Note: this section is only applicable to
application source code, hence the conditional that turns off this
stuff when the include file is processed by the ThreadX source. */
#ifndef TX_SOURCE_CODE
/* Determine if error checking is desired. If so, map API functions
/* Determine if error checking is desired. If so, map API functions
to the appropriate error checking front-ends. Otherwise, map API
functions to the core functions that actually perform the work.
functions to the core functions that actually perform the work.
Note: error checking is enabled by default. */
#ifdef TX_DISABLE_ERROR_CHECKING
@@ -1362,8 +1365,8 @@ UINT _tx_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG
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,
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);
@@ -1373,15 +1376,15 @@ UINT _tx_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr);
UINT _tx_block_release(VOID *block_ptr);
/* Define error checking shells for API services. These are only referenced by the
/* Define error checking shells for API services. These are only referenced by the
application. */
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,
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);
@@ -1390,8 +1393,8 @@ UINT _txr_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG
UINT _txr_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 _txr_block_pool_delete(TX_BLOCK_POOL *pool_ptr);
UINT _txr_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks,
ULONG *total_blocks, TX_THREAD **first_suspended,
UINT _txr_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 _txr_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr);
UINT _txr_block_release(VOID *block_ptr);
@@ -1405,8 +1408,8 @@ UINT _tx_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG m
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,
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);
@@ -1416,7 +1419,7 @@ UINT _tx_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr);
UINT _tx_byte_release(VOID *memory_ptr);
/* Define error checking shells for API services. These are only referenced by the
/* Define error checking shells for API services. These are only referenced by the
application. */
UINT _txe_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG memory_size,
@@ -1424,8 +1427,8 @@ UINT _txe_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG
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,
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);
@@ -1435,8 +1438,8 @@ UINT _txr_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG
UINT _txr_byte_pool_create(TX_BYTE_POOL *pool_ptr, CHAR *name_ptr, VOID *pool_start,
ULONG pool_size, UINT pool_control_block_size);
UINT _txr_byte_pool_delete(TX_BYTE_POOL *pool_ptr);
UINT _txr_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes,
ULONG *fragments, TX_THREAD **first_suspended,
UINT _txr_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 _txr_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr);
UINT _txr_byte_release(VOID *memory_ptr);
@@ -1449,29 +1452,29 @@ UINT _tx_event_flags_create(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR *name_p
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,
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 _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));
/* Define error checking shells for API services. These are only referenced by the
/* Define error checking shells for API services. These are only referenced by the
application. */
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,
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 _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));
#ifdef TX_ENABLE_MULTI_ERROR_CHECKING
@@ -1479,10 +1482,10 @@ UINT _txr_event_flags_create(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR *name_
UINT _txr_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr);
UINT _txr_event_flags_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG requested_flags,
UINT get_option, ULONG *actual_flags_ptr, ULONG wait_option);
UINT _txr_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags,
TX_THREAD **first_suspended, ULONG *suspended_count,
UINT _txr_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 _txr_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set,
UINT _txr_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set,
UINT set_option);
UINT _txr_event_flags_set_notify(TX_EVENT_FLAGS_GROUP *group_ptr, VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *notify_group_ptr));
#endif
@@ -1498,8 +1501,8 @@ 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,
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);
@@ -1509,14 +1512,14 @@ UINT _tx_mutex_prioritize(TX_MUTEX *mutex_ptr);
UINT _tx_mutex_put(TX_MUTEX *mutex_ptr);
/* Define error checking shells for API services. These are only referenced by the
/* Define error checking shells for API services. These are only referenced by the
application. */
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,
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);
@@ -1524,8 +1527,8 @@ UINT _txe_mutex_put(TX_MUTEX *mutex_ptr);
UINT _txr_mutex_create(TX_MUTEX *mutex_ptr, CHAR *name_ptr, UINT inherit, UINT mutex_control_block_size);
UINT _txr_mutex_delete(TX_MUTEX *mutex_ptr);
UINT _txr_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option);
UINT _txr_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner,
TX_THREAD **first_suspended, ULONG *suspended_count,
UINT _txr_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 _txr_mutex_prioritize(TX_MUTEX *mutex_ptr);
UINT _txr_mutex_put(TX_MUTEX *mutex_ptr);
@@ -1534,7 +1537,7 @@ UINT _txr_mutex_put(TX_MUTEX *mutex_ptr);
/* Define queue management function prototypes. */
UINT _tx_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,
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);
@@ -1551,10 +1554,10 @@ UINT _tx_queue_send_notify(TX_QUEUE *queue_ptr, VOID (*queue_send_notify)
UINT _tx_queue_front_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option);
/* Define error checking shells for API services. These are only referenced by the
/* Define error checking shells for API services. These are only referenced by the
application. */
UINT _txe_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,
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);
@@ -1566,7 +1569,7 @@ UINT _txe_queue_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_op
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);
#ifdef TX_ENABLE_MULTI_ERROR_CHECKING
UINT _txr_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,
UINT _txr_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,
VOID *queue_start, ULONG queue_size, UINT queue_control_block_size);
UINT _txr_queue_delete(TX_QUEUE *queue_ptr);
UINT _txr_queue_flush(TX_QUEUE *queue_ptr);
@@ -1586,8 +1589,8 @@ 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,
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);
@@ -1597,15 +1600,15 @@ 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));
/* Define error checking shells for API services. These are only referenced by the
/* Define error checking shells for API services. These are only referenced by the
application. */
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,
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);
@@ -1615,8 +1618,8 @@ UINT _txr_semaphore_ceiling_put(TX_SEMAPHORE *semaphore_ptr, ULONG ceilin
UINT _txr_semaphore_create(TX_SEMAPHORE *semaphore_ptr, CHAR *name_ptr, ULONG initial_count, UINT semaphore_control_block_size);
UINT _txr_semaphore_delete(TX_SEMAPHORE *semaphore_ptr);
UINT _txr_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option);
UINT _txr_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value,
TX_THREAD **first_suspended, ULONG *suspended_count,
UINT _txr_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value,
TX_THREAD **first_suspended, ULONG *suspended_count,
TX_SEMAPHORE **next_semaphore);
UINT _txr_semaphore_prioritize(TX_SEMAPHORE *semaphore_ptr);
UINT _txr_semaphore_put(TX_SEMAPHORE *semaphore_ptr);
@@ -1628,19 +1631,19 @@ UINT _txr_semaphore_put_notify(TX_SEMAPHORE *semaphore_ptr, VOID (*semaph
VOID _tx_thread_context_save(VOID);
VOID _tx_thread_context_restore(VOID);
UINT _tx_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr,
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,
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,
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,
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,
@@ -1662,18 +1665,18 @@ UINT _tx_thread_time_slice_change(TX_THREAD *thread_ptr, ULONG new_time_s
UINT _tx_thread_wait_abort(TX_THREAD *thread_ptr);
/* Define error checking shells for API services. These are only referenced by the
/* Define error checking shells for API services. These are only referenced by the
application. */
UINT _txe_thread_create(TX_THREAD *thread_ptr, CHAR *name_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,
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,
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);
@@ -1687,15 +1690,15 @@ 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);
#ifdef TX_ENABLE_MULTI_ERROR_CHECKING
UINT _txr_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr,
UINT _txr_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,
VOID *stack_start, ULONG stack_size,
UINT priority, UINT preempt_threshold,
ULONG time_slice, UINT auto_start, UINT thread_control_block_size);
UINT _txr_thread_delete(TX_THREAD *thread_ptr);
UINT _txr_thread_entry_exit_notify(TX_THREAD *thread_ptr, VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type));
UINT _txr_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count,
UINT *priority, UINT *preemption_threshold, ULONG *time_slice,
UINT _txr_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 _txr_thread_preemption_change(TX_THREAD *thread_ptr, UINT new_threshold,
UINT *old_threshold);
@@ -1714,12 +1717,12 @@ UINT _txr_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,
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,
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);
@@ -1730,27 +1733,27 @@ ULONG _tx_time_get(VOID);
VOID _tx_time_set(ULONG new_time);
/* Define error checking shells for API services. These are only referenced by the
/* Define error checking shells for API services. These are only referenced by the
application. */
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,
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,
UINT _txe_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,
ULONG *reschedule_ticks, TX_TIMER **next_timer);
#ifdef TX_ENABLE_MULTI_ERROR_CHECKING
UINT _txr_timer_activate(TX_TIMER *timer_ptr);
UINT _txr_timer_change(TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks);
UINT _txr_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr,
UINT _txr_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 _txr_timer_deactivate(TX_TIMER *timer_ptr);
UINT _txr_timer_delete(TX_TIMER *timer_ptr);
UINT _txr_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,
UINT _txr_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,
ULONG *reschedule_ticks, TX_TIMER **next_timer);
#endif
@@ -1771,13 +1774,13 @@ UINT _tx_trace_interrupt_control(UINT new_posture);
/* Add a default macro that can be re-defined in tx_port.h to add default processing when a thread starts. Common usage
would be for enabling floating point for a thread by default, however, the additional processing could be anything
defined in tx_port.h. */
#ifndef TX_THREAD_STARTED_EXTENSION
#define TX_THREAD_STARTED_EXTENSION(thread_ptr)
#endif
/* Add a default macro that can be re-defined in tx_port.h to add processing to the thread stack analyze function.
/* Add a default macro that can be re-defined in tx_port.h to add processing to the thread stack analyze function.
By default, this is simply defined as whitespace. */
#ifndef TX_THREAD_STACK_ANALYZE_EXTENSION
@@ -1785,7 +1788,7 @@ UINT _tx_trace_interrupt_control(UINT new_posture);
#endif
/* Add a default macro that can be re-defined in tx_port.h to add processing to the initialize kernel enter function.
/* Add a default macro that can be re-defined in tx_port.h to add processing to the initialize kernel enter function.
By default, this is simply defined as whitespace. */
#ifndef TX_INITIALIZE_KERNEL_ENTER_EXTENSION
@@ -2240,7 +2243,7 @@ void __ghs_rnerr(char *errMsg, int stackLevels, int stackTraceDisplay, void *hex
#endif
/* Define the get system state macro. By default, it simply maps to the variable _tx_thread_system_state. */
/* Note that prior to Azure RTOS 6.1, this symbol was defined in tx_thread.h. */
/* Note that prior to Azure RTOS 6.1, this symbol was defined in tx_thread.h. */
#ifndef TX_THREAD_GET_SYSTEM_STATE
#define TX_THREAD_GET_SYSTEM_STATE() _tx_thread_system_state
#endif

4
common/inc/tx_block_pool.h
View File

@@ -56,12 +56,12 @@
#define TX_BLOCK_POOL_ID ((ULONG) 0x424C4F43)
/* Determine if in-line component initialization is supported by the
/* Determine if in-line component initialization is supported by the
caller. */
#ifdef TX_INVOKE_INLINE_INITIALIZATION
/* Yes, in-line initialization is supported, remap the block memory pool
/* Yes, in-line initialization is supported, remap the block memory pool
initialization function. */
#ifndef TX_BLOCK_POOL_ENABLE_PERFORMANCE_INFO

4
common/inc/tx_byte_pool.h
View File

@@ -68,12 +68,12 @@
#endif
/* Determine if in-line component initialization is supported by the
/* Determine if in-line component initialization is supported by the
caller. */
#ifdef TX_INVOKE_INLINE_INITIALIZATION
/* Yes, in-line initialization is supported, remap the byte memory pool
/* Yes, in-line initialization is supported, remap the byte memory pool
initialization function. */
#ifndef TX_BYTE_POOL_ENABLE_PERFORMANCE_INFO

4
common/inc/tx_event_flags.h
View File

@@ -58,11 +58,11 @@
#define TX_EVENT_FLAGS_CLEAR_MASK ((UINT) 0x1)
/* Determine if in-line component initialization is supported by the
/* Determine if in-line component initialization is supported by the
caller. */
#ifdef TX_INVOKE_INLINE_INITIALIZATION
/* Yes, in-line initialization is supported, remap the event flag initialization
/* Yes, in-line initialization is supported, remap the event flag initialization
function. */
#ifndef TX_EVENT_FLAGS_ENABLE_PERFORMANCE_INFO

10
common/inc/tx_initialize.h
View File

@@ -67,15 +67,15 @@ VOID _tx_initialize_low_level(VOID);
/* Define the macro for adding additional port-specific global data. This macro is defined
as white space, unless defined by tx_port.h. */
#ifndef TX_PORT_SPECIFIC_DATA
#define TX_PORT_SPECIFIC_DATA
#endif
/* Define the macro for adding additional port-specific pre and post initialization processing.
/* Define the macro for adding additional port-specific pre and post initialization processing.
These macros is defined as white space, unless defined by tx_port.h. */
#ifndef TX_PORT_SPECIFIC_PRE_INITIALIZATION
#define TX_PORT_SPECIFIC_PRE_INITIALIZATION
#endif
@@ -102,9 +102,9 @@ VOID _tx_initialize_low_level(VOID);
#endif
/* Define the unused memory pointer. The value of the first available
/* Define the unused memory pointer. The value of the first available
memory address is placed in this variable in the low-level
initialization function. The content of this variable is passed
initialization function. The content of this variable is passed
to the application's system definition function. */
INITIALIZE_DECLARE VOID *_tx_initialize_unused_memory;

4
common/inc/tx_mutex.h
View File

@@ -56,12 +56,12 @@
#define TX_MUTEX_ID ((ULONG) 0x4D555445)
/* Determine if in-line component initialization is supported by the
/* Determine if in-line component initialization is supported by the
caller. */
#ifdef TX_INVOKE_INLINE_INITIALIZATION
/* Yes, in-line initialization is supported, remap the mutex initialization
/* Yes, in-line initialization is supported, remap the mutex initialization
function. */
#ifndef TX_MUTEX_ENABLE_PERFORMANCE_INFO

6
common/inc/tx_queue.h
View File

@@ -56,11 +56,11 @@
#define TX_QUEUE_ID ((ULONG) 0x51554555)
/* Determine if in-line component initialization is supported by the
/* Determine if in-line component initialization is supported by the
caller. */
#ifdef TX_INVOKE_INLINE_INITIALIZATION
/* Yes, in-line initialization is supported, remap the queue initialization
/* Yes, in-line initialization is supported, remap the queue initialization
function. */
#ifndef TX_QUEUE_ENABLE_PERFORMANCE_INFO
@@ -85,7 +85,7 @@ VOID _tx_queue_initialize(VOID);
#endif
/* Define the message copy macro. Note that the source and destination
/* Define the message copy macro. Note that the source and destination
pointers must be modified since they are used subsequently. */
#ifndef TX_QUEUE_MESSAGE_COPY

6
common/inc/tx_semaphore.h
View File

@@ -56,10 +56,10 @@
#define TX_SEMAPHORE_ID ((ULONG) 0x53454D41)
/* Determine if in-line component initialization is supported by the
/* Determine if in-line component initialization is supported by the
caller. */
#ifdef TX_INVOKE_INLINE_INITIALIZATION
/* Yes, in-line initialization is supported, remap the
/* Yes, in-line initialization is supported, remap the
semaphore initialization function. */
#ifndef TX_SEMAPHORE_ENABLE_PERFORMANCE_INFO
#define _tx_semaphore_initialize() \
@@ -76,7 +76,7 @@
#endif
#define TX_SEMAPHORE_INIT
#else
/* No in-line initialization is supported, use standard
/* No in-line initialization is supported, use standard
function call. */
VOID _tx_semaphore_initialize(VOID);
#endif

90
common/inc/tx_thread.h
View File

@@ -26,7 +26,7 @@
/* COMPONENT DEFINITION RELEASE */
/* */
/* tx_thread.h PORTABLE C */
/* 6.1.2 */
/* 6.1.9 */
/* AUTHOR */
/* */
/* William E. Lamie, Microsoft Corporation */
@@ -48,6 +48,9 @@
/* moved TX_THREAD_GET_SYSTEM_ */
/* STATE to tx_api.h, */
/* resulting in version 6.1.2 */
/* 10-15-2021 Scott Larson Modified comment(s), improved */
/* stack check error handling, */
/* resulting in version 6.1.9 */
/* */
/**************************************************************************/
@@ -90,32 +93,33 @@
/* Define state change macro that can be used by run-mode debug agents to keep track of thread
state changes. By default, it is mapped to white space. */
#ifndef TX_THREAD_STATE_CHANGE
#define TX_THREAD_STATE_CHANGE(a, b)
#endif
/* Define the macro to get the current thread pointer. This is particularly useful in SMP
/* Define the macro to get the current thread pointer. This is particularly useful in SMP
versions of ThreadX to add additional processing. The default implementation is to simply
access the global current thread pointer directly. */
#ifndef TX_THREAD_GET_CURRENT
#define TX_THREAD_GET_CURRENT(a) (a) = _tx_thread_current_ptr;
#endif
/* Define the macro to set the current thread pointer. This is particularly useful in SMP
/* Define the macro to set the current thread pointer. This is particularly useful in SMP
versions of ThreadX to add additional processing. The default implementation is to simply
access the global current thread pointer directly. */
#ifndef TX_THREAD_SET_CURRENT
#define TX_THREAD_SET_CURRENT(a) _tx_thread_current_ptr = (a);
#endif
/* Define the get system state macro. By default, it simply maps to the variable _tx_thread_system_state. */
/* This symbol is moved to tx_api.h. Therefore removed from this file.
/* This symbol is moved to tx_api.h. Therefore removed from this file.
#ifndef TX_THREAD_GET_SYSTEM_STATE
#define TX_THREAD_GET_SYSTEM_STATE() _tx_thread_system_state
#endif
@@ -144,10 +148,10 @@
#endif
/* Define the lowest bit set macro. Note, that this may be overridden
/* Define the lowest bit set macro. Note, that this may be overridden
by a port specific definition if there is supporting assembly language
instructions in the architecture. */
#ifndef TX_LOWEST_SET_BIT_CALCULATE
#define TX_LOWEST_SET_BIT_CALCULATE(m, b) \
(b) = ((ULONG) 0); \
@@ -212,9 +216,9 @@
#endif
/* Define the default thread stack checking. This can be overridden by
a particular port, which is necessary if the stack growth is from
low address to high address (the default logic is for stacks that
/* Define the default thread stack checking. This can be overridden by
a particular port, which is necessary if the stack growth is from
low address to high address (the default logic is for stacks that
grow from high address to low address. */
#ifndef TX_THREAD_STACK_CHECK
@@ -311,7 +315,7 @@ THREAD_DECLARE TX_THREAD * _tx_thread_current_ptr;
/* Define the variable that holds the next thread to execute. It is important
to remember that this is not necessarily equal to the current thread
to remember that this is not necessarily equal to the current thread
pointer. */
THREAD_DECLARE TX_THREAD * _tx_thread_execute_ptr;
@@ -328,7 +332,7 @@ THREAD_DECLARE ULONG _tx_thread_created_count;
/* Define the current state variable. When this value is 0, a thread
is executing or the system is idle. Other values indicate that
is executing or the system is idle. Other values indicate that
interrupt or initialization processing is active. This variable is
initialized to TX_INITIALIZE_IN_PROGRESS to indicate initialization is
active. */
@@ -337,15 +341,15 @@ THREAD_DECLARE volatile ULONG _tx_thread_system_state;
/* Define the 32-bit priority bit-maps. There is one priority bit map for each
32 priority levels supported. If only 32 priorities are supported there is
only one bit map. Each bit within a priority bit map represents that one
32 priority levels supported. If only 32 priorities are supported there is
only one bit map. Each bit within a priority bit map represents that one
or more threads at the associated thread priority are ready. */
THREAD_DECLARE ULONG _tx_thread_priority_maps[TX_MAX_PRIORITIES/32];
/* Define the priority map active bit map that specifies which of the previously
defined priority maps have something set. This is only necessary if more than
/* Define the priority map active bit map that specifies which of the previously
defined priority maps have something set. This is only necessary if more than
32 priorities are supported. */
#if TX_MAX_PRIORITIES > 32
@@ -355,17 +359,17 @@ THREAD_DECLARE ULONG _tx_thread_priority_map_active;
#ifndef TX_DISABLE_PREEMPTION_THRESHOLD
/* Define the 32-bit preempt priority bit maps. There is one preempt bit map
for each 32 priority levels supported. If only 32 priorities are supported
there is only one bit map. Each set set bit corresponds to a preempted priority
level that had preemption-threshold active to protect against preemption of a
/* Define the 32-bit preempt priority bit maps. There is one preempt bit map
for each 32 priority levels supported. If only 32 priorities are supported
there is only one bit map. Each set set bit corresponds to a preempted priority
level that had preemption-threshold active to protect against preemption of a
range of relatively higher priority threads. */
THREAD_DECLARE ULONG _tx_thread_preempted_maps[TX_MAX_PRIORITIES/32];
/* Define the preempt map active bit map that specifies which of the previously
defined preempt maps have something set. This is only necessary if more than
/* Define the preempt map active bit map that specifies which of the previously
defined preempt maps have something set. This is only necessary if more than
32 priorities are supported. */
#if TX_MAX_PRIORITIES > 32
@@ -373,7 +377,7 @@ THREAD_DECLARE ULONG _tx_thread_preempted_map_active;
#endif
#endif
/* Define the variable that holds the highest priority group ready for
/* Define the variable that holds the highest priority group ready for
execution. It is important to note that this is not necessarily the same
as the priority of the thread pointed to by _tx_execute_thread. */
@@ -389,13 +393,13 @@ THREAD_DECLARE TX_THREAD * _tx_thread_priority_list[TX_MAX_PRIORITIES];
/* Define the global preempt disable variable. If this is non-zero, preemption is
disabled. It is used internally by ThreadX to prevent preemption of a thread in
disabled. It is used internally by ThreadX to prevent preemption of a thread in
the middle of a service that is resuming or suspending another thread. */
THREAD_DECLARE volatile UINT _tx_thread_preempt_disable;
/* Define the global function pointer for mutex cleanup on thread completion or
/* Define the global function pointer for mutex cleanup on thread completion or
termination. This pointer is setup during mutex initialization. */
THREAD_DECLARE VOID (*_tx_thread_mutex_release)(TX_THREAD *thread_ptr);
@@ -407,7 +411,7 @@ THREAD_DECLARE VOID (*_tx_thread_mutex_release)(TX_THREAD *thread_pt
Bit(s) Meaning
31 TX_NOT_INTERRUPTABLE defined
30 TX_INLINE_THREAD_RESUME_SUSPEND define
30 TX_INLINE_THREAD_RESUME_SUSPEND define
29-24 Priority groups 1 -> 32 priorities
2 -> 64 priorities
3 -> 96 priorities
@@ -437,10 +441,10 @@ THREAD_DECLARE VOID (*_tx_thread_mutex_release)(TX_THREAD *thread_pt
THREAD_DECLARE ULONG _tx_build_options;
#ifdef TX_ENABLE_STACK_CHECKING
#if defined(TX_ENABLE_STACK_CHECKING) || defined(TX_PORT_THREAD_STACK_ERROR_HANDLING)
/* Define the global function pointer for stack error handling. If a stack error is
detected and the application has registered a stack error handler, it will be
/* Define the global function pointer for stack error handling. If a stack error is
detected and the application has registered a stack error handler, it will be
called via this function pointer. */
THREAD_DECLARE VOID (*_tx_thread_application_stack_error_handler)(TX_THREAD *thread_ptr);
@@ -455,20 +459,20 @@ THREAD_DECLARE VOID (*_tx_thread_application_stack_error_handler)(TX
THREAD_DECLARE ULONG _tx_thread_performance_resume_count;
/* Define the total number of thread suspensions. Each time a thread enters a
/* Define the total number of thread suspensions. Each time a thread enters a
suspended state this variable is incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_suspend_count;
/* Define the total number of solicited thread preemptions. Each time a thread is
/* Define the total number of solicited thread preemptions. Each time a thread is
preempted by directly calling a ThreadX service, this variable is incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_solicited_preemption_count;
/* Define the total number of interrupt thread preemptions. Each time a thread is
preempted as a result of an ISR calling a ThreadX service, this variable is
/* Define the total number of interrupt thread preemptions. Each time a thread is
preempted as a result of an ISR calling a ThreadX service, this variable is
incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_interrupt_preemption_count;
@@ -480,45 +484,45 @@ THREAD_DECLARE ULONG _tx_thread_performance_interrupt_preemption_coun
THREAD_DECLARE ULONG _tx_thread_performance_priority_inversion_count;
/* Define the total number of time-slices. Each time a time-slice operation is
actually performed (another thread is setup for running) this variable is
/* Define the total number of time-slices. Each time a time-slice operation is
actually performed (another thread is setup for running) this variable is
incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_time_slice_count;
/* Define the total number of thread relinquish operations. Each time a thread
/* Define the total number of thread relinquish operations. Each time a thread
relinquish operation is actually performed (another thread is setup for running)
this variable is incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_relinquish_count;
/* Define the total number of thread timeouts. Each time a thread has a
/* Define the total number of thread timeouts. Each time a thread has a
timeout this variable is incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_timeout_count;
/* Define the total number of thread wait aborts. Each time a thread's suspension
/* Define the total number of thread wait aborts. Each time a thread's suspension
is lifted by the tx_thread_wait_abort call this variable is incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_wait_abort_count;
/* Define the total number of idle system thread returns. Each time a thread returns to
/* Define the total number of idle system thread returns. Each time a thread returns to
an idle system (no other thread is ready to run) this variable is incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_idle_return_count;
/* Define the total number of non-idle system thread returns. Each time a thread returns to
/* Define the total number of non-idle system thread returns. Each time a thread returns to
a non-idle system (another thread is ready to run) this variable is incremented. */
THREAD_DECLARE ULONG _tx_thread_performance_non_idle_return_count;
/* Define the last TX_THREAD_EXECUTE_LOG_SIZE threads scheduled in ThreadX. This
/* Define the last TX_THREAD_EXECUTE_LOG_SIZE threads scheduled in ThreadX. This
is a circular list, where the index points to the oldest entry. */
THREAD_DECLARE ULONG _tx_thread_performance__execute_log_index;

8
common/inc/tx_timer.h
View File

@@ -79,7 +79,7 @@ VOID _tx_timer_thread_entry(ULONG timer_thread_input);
#endif
/* Define the system clock value that is continually incremented by the
/* Define the system clock value that is continually incremented by the
periodic timer interrupt processing. */
TIMER_DECLARE volatile ULONG _tx_timer_system_clock;
@@ -116,7 +116,7 @@ TIMER_DECLARE TX_TIMER_INTERNAL **_tx_timer_list_end;
TIMER_DECLARE TX_TIMER_INTERNAL **_tx_timer_current_ptr;
/* Define the timer expiration flag. This is used to indicate that a timer
/* Define the timer expiration flag. This is used to indicate that a timer
has expired. */
TIMER_DECLARE UINT _tx_timer_expired;
@@ -195,8 +195,8 @@ TIMER_DECLARE ULONG _tx_timer_performance_expiration_count;
/* Define the total number of timer expiration adjustments. These are required
if the expiration time is greater than the size of the timer list. In such
cases, the timer is placed at the end of the list and then reactivated
if the expiration time is greater than the size of the timer list. In such
cases, the timer is placed at the end of the list and then reactivated
as many times as necessary to finally achieve the resulting timeout. */
TIMER_DECLARE ULONG _tx_timer_performance__expiration_adjust_count;

64
common/inc/tx_trace.h
View File

@@ -78,8 +78,8 @@
#endif
/* Define the default clock source for trace event entry time stamp. The following two item are port specific.
For example, if the time source is at the address 0x0a800024 and is 16-bits in size, the clock
/* Define the default clock source for trace event entry time stamp. The following two item are port specific.
For example, if the time source is at the address 0x0a800024 and is 16-bits in size, the clock
source constants would be:
#define TX_TRACE_TIME_SOURCE *((ULONG *) 0x0a800024)
@@ -101,8 +101,8 @@
/* ThreadX Trace Description. The ThreadX Trace feature is designed to capture
events in real-time in a circular event buffer. This buffer may be analyzed by other
tools. The high-level format of the Trace structure is:
events in real-time in a circular event buffer. This buffer may be analyzed by other
tools. The high-level format of the Trace structure is:
[Trace Control Header ]
[Trace Object Registry - Entry 0 ]
@@ -115,23 +115,23 @@
*/
/* Trace Control Header. The Trace Control Header contains information that
defines the format of the Trace Object Registry as well as the location and
current entry of the Trace Buffer itself. The high-level format of the
/* Trace Control Header. The Trace Control Header contains information that
defines the format of the Trace Object Registry as well as the location and
current entry of the Trace Buffer itself. The high-level format of the
Trace Control Header is:
Entry Size Description
[Trace ID] 4 This 4-byte field contains the ThreadX Trace
Identification. If the trace buffer is valid, the
contents are 0x54585442 (TXTB). Since it is written as
contents are 0x54585442 (TXTB). Since it is written as
a 32-bit unsigned word, this value is also used to
determine if the event trace information is in
determine if the event trace information is in
little or big endian format.
[Timer Valid Mask] 4 Mask of valid bits in the 32-bit time stamp. This
[Timer Valid Mask] 4 Mask of valid bits in the 32-bit time stamp. This
enables use of 32, 24, 16, or event 8-bit timers.
If the time source is 32-bits, the mask is
0xFFFFFFFF. If the time source is 16-bits, the
If the time source is 32-bits, the mask is
0xFFFFFFFF. If the time source is 16-bits, the
mask is 0x0000FFFF.
[Trace Base Address] 4 The base address for all trace pointer. Subtracting
the pointer and this address will yield the proper
@@ -143,7 +143,7 @@
[Trace Buffer Start Pointer] 4 Pointer to the start of the Trace Buffer Area
[Trace Buffer End Pointer] 4 Pointer to the end of the Trace Buffer Area
[Trace Buffer Current Pointer] 4 Pointer to the oldest entry in the Trace Buffer.
This entry will be overwritten on the next event and
This entry will be overwritten on the next event and
incremented to the next event (wrapping to the top
if the buffer end pointer is exceeded).
[Reserved] 4 Reserved 4 bytes, should be 0xAAAAAAAA
@@ -173,7 +173,7 @@ typedef struct TX_TRACE_HEADER_STRUCT
} TX_TRACE_HEADER;
/* Trace Object Registry. The Trace Object Registry is used to map the object pointer in the trace buffer to
/* Trace Object Registry. The Trace Object Registry is used to map the object pointer in the trace buffer to
the application's name for the object (defined during object creation in ThreadX). */
#ifndef TX_TRACE_OBJECT_REGISTRY_NAME
@@ -181,7 +181,7 @@ typedef struct TX_TRACE_HEADER_STRUCT
#endif
/* Define the object name types as well as the contents of any additional parameters that might be useful in
/* Define the object name types as well as the contents of any additional parameters that might be useful in
trace analysis. */
#define TX_TRACE_OBJECT_TYPE_NOT_VALID ((UCHAR) 0) /* Object is not valid */
@@ -214,27 +214,27 @@ typedef struct TX_TRACE_OBJECT_ENTRY_STRUCT
Entry Size Description
[Thread Pointer] 4 This 4-byte field contains the pointer to the
ThreadX thread running that caused the event.
[Thread Pointer] 4 This 4-byte field contains the pointer to the
ThreadX thread running that caused the event.
If this field is NULL, the entry hasn't been used
yet. If this field is 0xFFFFFFFF, the event occurred
from within an ISR. If this entry is 0xF0F0F0F0, the
from within an ISR. If this entry is 0xF0F0F0F0, the
event occurred during initialization.
[Thread Priority or 4 This 4-byte field contains the current thread pointer for interrupt
Current Thread events or the thread preemption-threshold/priority for thread events.
Preemption-Threshold/
Priority]
[Event ID] 4 This 4-byte field contains the Event ID of the event. A value of
[Event ID] 4 This 4-byte field contains the Event ID of the event. A value of
0xFFFFFFFF indicates the event is invalid. All events are marked
as invalid during initialization.
[Time Stamp] 4 This 4-byte field contains the time stamp of the event.
[Information Field 1] 4 This 4-byte field contains the first 4-bytes of information
[Information Field 1] 4 This 4-byte field contains the first 4-bytes of information
specific to the event.
[Information Field 2] 4 This 4-byte field contains the second 4-bytes of information
[Information Field 2] 4 This 4-byte field contains the second 4-bytes of information
specific to the event.
[Information Field 3] 4 This 4-byte field contains the third 4-bytes of information
[Information Field 3] 4 This 4-byte field contains the third 4-bytes of information
specific to the event.
[Information Field 4] 4 This 4-byte field contains the fourth 4-bytes of information
[Information Field 4] 4 This 4-byte field contains the fourth 4-bytes of information
specific to the event.
*/
@@ -244,15 +244,15 @@ typedef struct TX_TRACE_OBJECT_ENTRY_STRUCT
/* Define ThreadX Trace Events, along with a brief description of the additional information fields,
where I1 -> Information Field 1, I2 -> Information Field 2, etc. */
/* Event numbers 0 through 4095 are reserved by Azure RTOS. Specific event assignments are:
ThreadX events: 1-199
/* Event numbers 0 through 4095 are reserved by Azure RTOS. Specific event assignments are:
ThreadX events: 1-199
FileX events: 200-299
NetX events: 300-599
USBX events: 600-999
User-defined event numbers start at 4096 and continue through 65535, as defined by the constants
TX_TRACE_USER_EVENT_START and TX_TRACE_USER_EVENT_END, respectively. User events should be based
User-defined event numbers start at 4096 and continue through 65535, as defined by the constants
TX_TRACE_USER_EVENT_START and TX_TRACE_USER_EVENT_END, respectively. User events should be based
on these constants in case the user event number assignment is changed in future releases. */
/* Define the basic ThreadX thread scheduling events first. */
@@ -417,7 +417,7 @@ TRACE_DECLARE TX_TRACE_BUFFER_ENTRY *_tx_trace_buffer_end_ptr;
TRACE_DECLARE TX_TRACE_BUFFER_ENTRY *_tx_trace_buffer_current_ptr;
/* Define the trace event enable bits, where each bit represents a type of event that can be enabled
/* Define the trace event enable bits, where each bit represents a type of event that can be enabled
or disabled dynamically by the application. */
TRACE_DECLARE ULONG _tx_trace_event_enable_bits;
@@ -429,9 +429,9 @@ TRACE_DECLARE ULONG _tx_trace_event_enable_bits;
TRACE_DECLARE ULONG _tx_trace_simulated_time;
/* Define the function pointer used to call the application when the trace buffer wraps. If NULL,
/* Define the function pointer used to call the application when the trace buffer wraps. If NULL,
the application has not registered a callback function. */
TRACE_DECLARE VOID (*_tx_trace_full_notify_function)(VOID *buffer);

76
common/inc/tx_user_sample.h
View File

@@ -26,7 +26,7 @@
/* PORT SPECIFIC C INFORMATION RELEASE */
/* */
/* tx_user.h PORTABLE C */
/* 6.1.5 */
/* 6.1.9 */
/* */
/* AUTHOR */
/* */
@@ -51,6 +51,13 @@
/* added option to remove */
/* FileX pointer, */
/* resulting in version 6.1.5 */
/* 06-02-2021 Scott Larson Added options for multiple */
/* block pool search & delay, */
/* resulting in version 6.1.7 */
/* 10-15-2021 Yuxin Zhou Modified comment(s), added */
/* user-configurable symbol */
/* TX_TIMER_TICKS_PER_SECOND */
/* resulting in version 6.1.9 */
/* */
/**************************************************************************/
@@ -59,9 +66,9 @@
/* Define various build options for the ThreadX port. The application should either make changes
here by commenting or un-commenting the conditional compilation defined OR supply the defines
though the compiler's equivalent of the -D option.
here by commenting or un-commenting the conditional compilation defined OR supply the defines
though the compiler's equivalent of the -D option.
For maximum speed, the following should be defined:
TX_MAX_PRIORITIES 32
@@ -73,9 +80,9 @@
TX_REACTIVATE_INLINE
TX_DISABLE_STACK_FILLING
TX_INLINE_THREAD_RESUME_SUSPEND
For minimum size, the following should be defined:
TX_MAX_PRIORITIES 32
TX_DISABLE_PREEMPTION_THRESHOLD
TX_DISABLE_REDUNDANT_CLEARING
@@ -83,12 +90,12 @@
TX_NO_FILEX_POINTER
TX_NOT_INTERRUPTABLE
TX_TIMER_PROCESS_IN_ISR
Of course, many of these defines reduce functionality and/or change the behavior of the
system in ways that may not be worth the trade-off. For example, the TX_TIMER_PROCESS_IN_ISR
results in faster and smaller code, however, it increases the amount of processing in the ISR.
In addition, some services that are available in timers are not available from ISRs and will
therefore return an error if this option is used. This may or may not be desirable for a
therefore return an error if this option is used. This may or may not be desirable for a
given application. */
@@ -103,19 +110,28 @@
#define TX_TIMER_THREAD_PRIORITY ????
*/
/* Define the common timer tick reference for use by other middleware components. The default
value is 10ms (i.e. 100 ticks, defined in tx_api.h), but may be replaced by a port-specific
version in tx_port.h or here.
Note: the actual hardware timer value may need to be changed (usually in tx_initialize_low_level). */
/*
#define TX_TIMER_TICKS_PER_SECOND ((ULONG) 100)
*/
/* Determine if there is a FileX pointer in the thread control block.
By default, the pointer is there for legacy/backwards compatibility.
By default, the pointer is there for legacy/backwards compatibility.
The pointer must also be there for applications using FileX.
Define this to save space in the thread control block.
Define this to save space in the thread control block.
*/
/*
#define TX_NO_FILEX_POINTER
*/
/* Determine if timer expirations (application timers, timeouts, and tx_thread_sleep calls
should be processed within the a system timer thread or directly in the timer ISR.
By default, the timer thread is used. When the following is defined, the timer expiration
/* Determine if timer expirations (application timers, timeouts, and tx_thread_sleep calls
should be processed within the a system timer thread or directly in the timer ISR.
By default, the timer thread is used. When the following is defined, the timer expiration
processing is done directly from the timer ISR, thereby eliminating the timer thread control
block, stack, and context switching to activate it. */
@@ -140,7 +156,7 @@
#define TX_DISABLE_STACK_FILLING
*/
/* Determine whether or not stack checking is enabled. By default, ThreadX stack checking is
/* Determine whether or not stack checking is enabled. By default, ThreadX stack checking is
disabled. When the following is defined, ThreadX thread stack checking is enabled. If stack
checking is enabled (TX_ENABLE_STACK_CHECKING is defined), the TX_DISABLE_STACK_FILLING
define is negated, thereby forcing the stack fill which is necessary for the stack checking
@@ -150,7 +166,7 @@
#define TX_ENABLE_STACK_CHECKING
*/
/* Determine if preemption-threshold should be disabled. By default, preemption-threshold is
/* Determine if preemption-threshold should be disabled. By default, preemption-threshold is
enabled. If the application does not use preemption-threshold, it may be disabled to reduce
code size and improve performance. */
@@ -158,7 +174,7 @@
#define TX_DISABLE_PREEMPTION_THRESHOLD
*/
/* Determine if global ThreadX variables should be cleared. If the compiler startup code clears
/* Determine if global ThreadX variables should be cleared. If the compiler startup code clears
the .bss section prior to ThreadX running, the define can be used to eliminate unnecessary
clearing of ThreadX global variables. */
@@ -166,9 +182,9 @@
#define TX_DISABLE_REDUNDANT_CLEARING
*/
/* Determine if no timer processing is required. This option will help eliminate the timer
processing when not needed. The user will also have to comment out the call to
tx_timer_interrupt, which is typically made from assembly language in
/* Determine if no timer processing is required. This option will help eliminate the timer
processing when not needed. The user will also have to comment out the call to
tx_timer_interrupt, which is typically made from assembly language in
tx_initialize_low_level. Note: if TX_NO_TIMER is used, the define TX_TIMER_PROCESS_IN_ISR
must also be used and tx_timer_initialize must be removed from ThreadX library. */
@@ -188,8 +204,8 @@
*/
/* Determine if the tx_thread_resume and tx_thread_suspend services should have their internal
code in-line. This results in a larger image, but improves the performance of the thread
/* Determine if the tx_thread_resume and tx_thread_suspend services should have their internal
code in-line. This results in a larger image, but improves the performance of the thread
resume and suspend services. */
/*
@@ -197,7 +213,7 @@
*/
/* Determine if the internal ThreadX code is non-interruptable. This results in smaller code
/* Determine if the internal ThreadX code is non-interruptable. This results in smaller code
size and less processing overhead, but increases the interrupt lockout time. */
/*
@@ -205,8 +221,8 @@
*/
/* Determine if the trace event logging code should be enabled. This causes slight increases in
code size and overhead, but provides the ability to generate system trace information which
/* Determine if the trace event logging code should be enabled. This causes slight increases in
code size and overhead, but provides the ability to generate system trace information which
is available for viewing in TraceX. */
/*
@@ -270,5 +286,17 @@
#define TX_TIMER_ENABLE_PERFORMANCE_INFO
*/
/* Override options for byte pool searches of multiple blocks. */
/*
#define TX_BYTE_POOL_MULTIPLE_BLOCK_SEARCH 20
*/
/* Override options for byte pool search delay to avoid thrashing. */
/*
#define TX_BYTE_POOL_DELAY_VALUE 3
*/
#endif