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

add SMP, Modules, and more processor/tools releases

Browse Source
This commit is contained in:
Scott Larson
2020-08-07 16:56:45 -07:00
parent 49e3c27f3f
commit 6f61053f2a
1858 changed files with 617131 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

684
common_modules/inc/txm_module.h Normal file
View File

@@ -0,0 +1,684 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module Interface (API) */
/** */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/* */
/* APPLICATION INTERFACE DEFINITION RELEASE */
/* */
/* txm_module.h PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This file defines the basic module constants, interface structures, */
/* and function prototypes. */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
#ifndef TXM_MODULE_H
#define TXM_MODULE_H
/* Include the standard ThreadX API file. */
#include "tx_api.h"
/* Include the module port specific file. */
#include "txm_module_port.h"
/* Include any supported external component include files. */
#ifdef TXM_MODULE_ENABLE_FILEX
#include "txm_module_filex.h"
#endif
#ifdef TXM_MODULE_ENABLE_GUIX
#include "txm_module_guix.h"
#endif
#ifdef TXM_MODULE_ENABLE_NETX
#include "txm_module_netx.h"
#endif
#ifdef TXM_MODULE_ENABLE_NETXDUO
#include "txm_module_netxduo.h"
#endif
#ifdef TXM_MODULE_ENABLE_USBX
#include "txm_module_usbx.h"
#endif
#ifdef FX_FILEX_PRESENT
#include "fx_api.h"
#endif
/* Determine if a C++ compiler is being used. If so, ensure that standard
C is used to process the API information. */
#ifdef __cplusplus
/* Yes, C++ compiler is present. Use standard C. */
extern "C" {
#endif
/* Define the Module ID, which is used to indicate a module is valid. */
#define TXM_MODULE_ID 0x4D4F4455
/* Define valid module states. */
#define TXM_MODULE_LOADED 1
#define TXM_MODULE_STARTED 2
#define TXM_MODULE_STOPPING 3
#define TXM_MODULE_STOPPED 4
#define TXM_MODULE_UNLOADED 5
/* Define module manager error codes. */
#define TXM_MODULE_ALIGNMENT_ERROR 0xF0
#define TXM_MODULE_ALREADY_LOADED 0xF1
#define TXM_MODULE_INVALID 0xF2
#define TXM_MODULE_INVALID_PROPERTIES 0xF3
#define TXM_MODULE_INVALID_MEMORY 0xF4
#define TXM_MODULE_INVALID_CALLBACK 0xF5
#define TXM_MODULE_INVALID_STACK_SIZE 0xF6
#define TXM_MODULE_FILEX_INVALID_BYTES_READ 0xF7
#define TXM_MODULE_MATH_OVERFLOW 0xF8
/* Define the data area alignment mask, must be a power of 2. */
#ifndef TXM_MODULE_DATA_ALIGNMENT
#define TXM_MODULE_DATA_ALIGNMENT 4
#endif
/* Define the code area alignment mask, must be a power of 2. */
#ifndef TXM_MODULE_CODE_ALIGNMENT
#define TXM_MODULE_CODE_ALIGNMENT 4
#endif
/* Define module timeout for waiting for module to finish. */
#ifndef TXM_MODULE_TIMEOUT
#define TXM_MODULE_TIMEOUT 100
#endif
/* Define module thread time-slice default. */
#ifndef TXM_MODULE_TIME_SLICE
#define TXM_MODULE_TIME_SLICE 4
#endif
/* Define each module's callback queue depth. This is used to queue up incoming call back requests. */
#ifndef TXM_MODULE_CALLBACKS_QUEUE_DEPTH
#define TXM_MODULE_CALLBACKS_QUEUE_DEPTH 8 /* Number queued callback requests. */
#endif
/* Define the module manager thread's stack size. */
#ifndef TXM_MODULE_MANAGER_THREAD_STACK_SIZE
#define TXM_MODULE_MANAGER_THREAD_STACK_SIZE 1024
#endif
/* Define the module manager thread's priority. */
#ifndef TXM_MODULE_MANAGER_THREAD_PRIORITY
#define TXM_MODULE_MANAGER_THREAD_PRIORITY 1
#endif
/* Define the module's callback handler thread's stack size. */
#ifndef TXM_MODULE_CALLBACK_THREAD_STACK_SIZE
#define TXM_MODULE_CALLBACK_THREAD_STACK_SIZE 1024
#endif
/* Define the default port-specific macro for resetting the thread. */
#ifndef TXM_MODULE_MANAGER_THREAD_RESET_PORT_COMPLETION
#define TXM_MODULE_MANAGER_THREAD_RESET_PORT_COMPLETION(thread_ptr, module_instance)
#endif
/* Define object types for object search requests. */
#define TXM_BLOCK_POOL_OBJECT 1
#define TXM_BYTE_POOL_OBJECT 2
#define TXM_EVENT_FLAGS_OBJECT 3
#define TXM_MUTEX_OBJECT 4
#define TXM_QUEUE_OBJECT 5
#define TXM_SEMAPHORE_OBJECT 6
#define TXM_THREAD_OBJECT 7
#define TXM_TIMER_OBJECT 8
#define TXM_THREAD_KERNEL_STACK_OBJECT 77
#define TXM_FILEX_OBJECTS_START 100
#define TXM_FILEX_OBJECTS_END 199
#define TXM_NETX_OBJECTS_START 200
#define TXM_NETX_OBJECTS_END 299
#define TXM_NETXDUO_OBJECTS_START 300
#define TXM_NETXDUO_OBJECTS_END 399
#define TXM_USBX_OBJECTS_START 400
#define TXM_USBX_OBJECTS_END 499
#define TXM_GUIX_OBJECTS_START 500
#define TXM_GUIX_OBJECT_END 599
/* Define callback types. */
#define TXM_THREADX_CALLBACKS_START 0
#define TXM_THREADX_CALLBACKS_END 99
#define TXM_FILEX_CALLBACKS_START 100
#define TXM_FILEX_CALLBACKS_END 199
#define TXM_NETX_CALLBACKS_START 200
#define TXM_NETX_CALLBACKS_END 299
#define TXM_NETXDUO_CALLBACKS_START 300
#define TXM_NETXDUO_CALLBACKS_END 399
#define TXM_USBX_CALLBACKS_START 400
#define TXM_USBX_CALLBACKS_END 499
#define TXM_GUIX_CALLBACKS_START 500
#define TXM_GUIX_CALLBACKS_END 599
#define TXM_TIMER_CALLBACK 0
#define TXM_EVENTS_SET_CALLBACK 1
#define TXM_QUEUE_SEND_CALLBACK 2
#define TXM_SEMAPHORE_PUT_CALLBACK 3
#define TXM_THREAD_ENTRY_EXIT_CALLBACK 4
/* Determine the ThreadX kernel API call IDs. */
#define TXM_BLOCK_ALLOCATE_CALL 1
#define TXM_BLOCK_POOL_CREATE_CALL 2
#define TXM_BLOCK_POOL_DELETE_CALL 3
#define TXM_BLOCK_POOL_INFO_GET_CALL 4
#define TXM_BLOCK_POOL_PERFORMANCE_INFO_GET_CALL 5
#define TXM_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL 6
#define TXM_BLOCK_POOL_PRIORITIZE_CALL 7
#define TXM_BLOCK_RELEASE_CALL 8
#define TXM_BYTE_ALLOCATE_CALL 9
#define TXM_BYTE_POOL_CREATE_CALL 10
#define TXM_BYTE_POOL_DELETE_CALL 11
#define TXM_BYTE_POOL_INFO_GET_CALL 12
#define TXM_BYTE_POOL_PERFORMANCE_INFO_GET_CALL 13
#define TXM_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL 14
#define TXM_BYTE_POOL_PRIORITIZE_CALL 15
#define TXM_BYTE_RELEASE_CALL 16
#define TXM_EVENT_FLAGS_CREATE_CALL 17
#define TXM_EVENT_FLAGS_DELETE_CALL 18
#define TXM_EVENT_FLAGS_GET_CALL 19
#define TXM_EVENT_FLAGS_INFO_GET_CALL 20
#define TXM_EVENT_FLAGS_PERFORMANCE_INFO_GET_CALL 21
#define TXM_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_CALL 22
#define TXM_EVENT_FLAGS_SET_CALL 23
#define TXM_EVENT_FLAGS_SET_NOTIFY_CALL 24
#define TXM_THREAD_INTERRUPT_CONTROL_CALL 25
#define TXM_MUTEX_CREATE_CALL 26
#define TXM_MUTEX_DELETE_CALL 27
#define TXM_MUTEX_GET_CALL 28
#define TXM_MUTEX_INFO_GET_CALL 29
#define TXM_MUTEX_PERFORMANCE_INFO_GET_CALL 30
#define TXM_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_CALL 31
#define TXM_MUTEX_PRIORITIZE_CALL 32
#define TXM_MUTEX_PUT_CALL 33
#define TXM_QUEUE_CREATE_CALL 34
#define TXM_QUEUE_DELETE_CALL 35
#define TXM_QUEUE_FLUSH_CALL 36
#define TXM_QUEUE_FRONT_SEND_CALL 37
#define TXM_QUEUE_INFO_GET_CALL 38
#define TXM_QUEUE_PERFORMANCE_INFO_GET_CALL 39
#define TXM_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_CALL 40
#define TXM_QUEUE_PRIORITIZE_CALL 41
#define TXM_QUEUE_RECEIVE_CALL 42
#define TXM_QUEUE_SEND_CALL 43
#define TXM_QUEUE_SEND_NOTIFY_CALL 44
#define TXM_SEMAPHORE_CEILING_PUT_CALL 45
#define TXM_SEMAPHORE_CREATE_CALL 46
#define TXM_SEMAPHORE_DELETE_CALL 47
#define TXM_SEMAPHORE_GET_CALL 48
#define TXM_SEMAPHORE_INFO_GET_CALL 49
#define TXM_SEMAPHORE_PERFORMANCE_INFO_GET_CALL 50
#define TXM_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_CALL 51
#define TXM_SEMAPHORE_PRIORITIZE_CALL 52
#define TXM_SEMAPHORE_PUT_CALL 53
#define TXM_SEMAPHORE_PUT_NOTIFY_CALL 54
#define TXM_THREAD_CREATE_CALL 55
#define TXM_THREAD_DELETE_CALL 56
#define TXM_THREAD_ENTRY_EXIT_NOTIFY_CALL 57
#define TXM_THREAD_IDENTIFY_CALL 58
#define TXM_THREAD_INFO_GET_CALL 59
#define TXM_THREAD_PERFORMANCE_INFO_GET_CALL 60
#define TXM_THREAD_PERFORMANCE_SYSTEM_INFO_GET_CALL 61
#define TXM_THREAD_PREEMPTION_CHANGE_CALL 62
#define TXM_THREAD_PRIORITY_CHANGE_CALL 63
#define TXM_THREAD_RELINQUISH_CALL 64
#define TXM_THREAD_RESET_CALL 65
#define TXM_THREAD_RESUME_CALL 66
#define TXM_THREAD_SLEEP_CALL 67
#define TXM_THREAD_STACK_ERROR_NOTIFY_CALL 68
#define TXM_THREAD_SUSPEND_CALL 69
#define TXM_THREAD_TERMINATE_CALL 70
#define TXM_THREAD_TIME_SLICE_CHANGE_CALL 71
#define TXM_THREAD_WAIT_ABORT_CALL 72
#define TXM_TIME_GET_CALL 73
#define TXM_TIME_SET_CALL 74
#define TXM_TIMER_ACTIVATE_CALL 75
#define TXM_TIMER_CHANGE_CALL 76
#define TXM_TIMER_CREATE_CALL 77
#define TXM_TIMER_DEACTIVATE_CALL 78
#define TXM_TIMER_DELETE_CALL 79
#define TXM_TIMER_INFO_GET_CALL 80
#define TXM_TIMER_PERFORMANCE_INFO_GET_CALL 81
#define TXM_TIMER_PERFORMANCE_SYSTEM_INFO_GET_CALL 82
#define TXM_TRACE_ENABLE_CALL 83
#define TXM_TRACE_EVENT_FILTER_CALL 84
#define TXM_TRACE_EVENT_UNFILTER_CALL 85
#define TXM_TRACE_DISABLE_CALL 86
#define TXM_TRACE_INTERRUPT_CONTROL_CALL 87
#define TXM_TRACE_ISR_ENTER_INSERT_CALL 88
#define TXM_TRACE_ISR_EXIT_INSERT_CALL 89
#define TXM_TRACE_BUFFER_FULL_NOTIFY_CALL 90
#define TXM_TRACE_USER_EVENT_INSERT_CALL 91
#define TXM_THREAD_SYSTEM_SUSPEND_CALL 92
#define TXM_MODULE_OBJECT_POINTER_GET_CALL 93
#define TXM_MODULE_OBJECT_POINTER_GET_EXTENDED_CALL 94
#define TXM_MODULE_OBJECT_ALLOCATE_CALL 95
#define TXM_MODULE_OBJECT_DEALLOCATE_CALL 96
/* Determine the API call IDs for other components. */
#define TXM_FILEX_API_ID_START 1000
#define TXM_FILEX_API_ID_END 1999
#define TXM_NETX_API_ID_START 2000
#define TXM_NETX_API_ID_END 2999
#define TXM_NETXDUO_API_ID_START 3000
#define TXM_NETXDUO_API_ID_END 3999
#define TXM_USBX_API_ID_START 4000
#define TXM_USBX_API_ID_END 4999
#define TXM_GUIX_API_ID_START 5000
#define TXM_GUIX_API_ID_END 5999
/* Determine the application's IDs for calling application code in the resident area. */
#define TXM_APPLICATION_REQUEST_ID_BASE 0x10000
/* Define the overlay for the module's preamble. */
typedef struct TXM_MODULE_PREAMBLE_STRUCT
{
/* Meaning */
ULONG txm_module_preamble_id; /* Download Module ID (0x54584D44) */
ULONG txm_module_preamble_version_major; /* Major Version ID */
ULONG txm_module_preamble_version_minor; /* Minor Version ID */
ULONG txm_module_preamble_preamble_size; /* Module Preamble Size, in 32-bit words */
ULONG txm_module_preamble_application_module_id; /* Module ID (application defined) */
ULONG txm_module_preamble_property_flags; /* Properties Bit Map */
ULONG txm_module_preamble_shell_entry_function; /* Module shell Entry Function */
ULONG txm_module_preamble_start_function; /* Module Thread Start Function */
ULONG txm_module_preamble_stop_function; /* Module Thread Stop Function */
ULONG txm_module_preamble_start_stop_priority; /* Module Start/Stop Thread Priority */
ULONG txm_module_preamble_start_stop_stack_size; /* Module Start/Stop Thread Priority */
ULONG txm_module_preamble_callback_function; /* Module Callback Thread Function */
ULONG txm_module_preamble_callback_priority; /* Module Callback Thread Priority */
ULONG txm_module_preamble_callback_stack_size; /* Module Callback Thread Stack Size */
ULONG txm_module_preamble_code_size; /* Module Instruction Area Size */
ULONG txm_module_preamble_data_size; /* Module Data Area Size */
ULONG txm_module_preamble_reserved_0; /* Reserved */
ULONG txm_module_preamble_reserved_1; /* Reserved */
ULONG txm_module_preamble_reserved_2; /* Reserved */
ULONG txm_module_preamble_reserved_3; /* Reserved */
ULONG txm_module_preamble_reserved_4; /* Reserved */
ULONG txm_module_preamble_reserved_5; /* Reserved */
ULONG txm_module_preamble_reserved_6; /* Reserved */
ULONG txm_module_preamble_reserved_7; /* Reserved */
ULONG txm_module_preamble_reserved_8; /* Reserved */
ULONG txm_module_preamble_reserved_9; /* Reserved */
ULONG txm_module_preamble_reserved_10; /* Reserved */
ULONG txm_module_preamble_reserved_11; /* Reserved */
ULONG txm_module_preamble_reserved_12; /* Reserved */
ULONG txm_module_preamble_reserved_13; /* Reserved */
ULONG txm_module_preamble_reserved_14; /* Reserved */
ULONG txm_module_preamble_checksum; /* Module Instruction Area Checksum [Optional] */
} TXM_MODULE_PREAMBLE;
struct TXM_MODULE_ALLOCATED_OBJECT_STRUCT;
/* Define the callback notification structure used to communicate between the module's callback handling thread
and the module manager. */
typedef struct TXM_MODULE_CALLBACK_MESSAGE_STRUCT
{
ULONG txm_module_callback_message_type;
ULONG txm_module_callback_message_activation_count;
VOID (*txm_module_callback_message_application_function)(VOID);
ALIGN_TYPE txm_module_callback_message_param_1;
ALIGN_TYPE txm_module_callback_message_param_2;
ALIGN_TYPE txm_module_callback_message_param_3;
ALIGN_TYPE txm_module_callback_message_param_4;
ALIGN_TYPE txm_module_callback_message_param_5;
ALIGN_TYPE txm_module_callback_message_param_6;
ALIGN_TYPE txm_module_callback_message_param_7;
ALIGN_TYPE txm_module_callback_message_param_8;
ALIGN_TYPE txm_module_callback_message_reserved1;
ALIGN_TYPE txm_module_callback_message_reserved2;
} TXM_MODULE_CALLBACK_MESSAGE;
/* Define the module's instance for the manager. */
typedef struct TXM_MODULE_INSTANCE_STRUCT
{
ULONG txm_module_instance_id;
CHAR *txm_module_instance_name;
ULONG txm_module_instance_state;
ULONG txm_module_instance_property_flags;
VOID *txm_module_instance_code_allocation_ptr;
ULONG txm_module_instance_code_allocation_size;
VOID *txm_module_instance_code_start;
VOID *txm_module_instance_code_end;
ULONG txm_module_instance_code_size;
VOID *txm_module_instance_data_allocation_ptr;
ULONG txm_module_instance_data_allocation_size;
VOID *txm_module_instance_data_start;
VOID *txm_module_instance_data_end;
VOID *txm_module_instance_module_data_base_address;
ULONG txm_module_instance_data_size;
ULONG txm_module_instance_total_ram_usage;
VOID *txm_module_instance_start_stop_stack_start_address;
VOID *txm_module_instance_start_stop_stack_end_address;
VOID *txm_module_instance_callback_stack_start_address;
VOID *txm_module_instance_callback_stack_end_address;
TXM_MODULE_PREAMBLE *txm_module_instance_preamble_ptr;
VOID (*txm_module_instance_shell_entry_function)(TX_THREAD *, struct TXM_MODULE_INSTANCE_STRUCT *);
VOID (*txm_module_instance_start_thread_entry)(ULONG);
VOID (*txm_module_instance_stop_thread_entry)(ULONG);
VOID (*txm_module_instance_callback_request_thread_entry)(ULONG);
/* Define the port extention to the module manager structure. */
TXM_MODULE_MANAGER_PORT_EXTENSION
TX_THREAD txm_module_instance_start_stop_thread;
TX_THREAD txm_module_instance_callback_request_thread;
TX_QUEUE txm_module_instance_callback_request_queue;
ULONG txm_module_instance_callback_request_queue_area[TXM_MODULE_CALLBACKS_QUEUE_DEPTH * (sizeof(TXM_MODULE_CALLBACK_MESSAGE)/sizeof(ULONG))];
ULONG txm_module_instance_start_stop_stack_size;
ULONG txm_module_instance_start_stop_priority;
ULONG txm_module_instance_callback_stack_size;
ULONG txm_module_instance_callback_priority;
ULONG txm_module_instance_application_module_id;
UINT txm_module_instance_maximum_priority;
/* Define the head pointer of the list of objects allocated by the module. */
struct TXM_MODULE_ALLOCATED_OBJECT_STRUCT
*txm_module_instance_object_list_head;
ULONG txm_module_instance_object_list_count;
struct TXM_MODULE_INSTANCE_STRUCT
*txm_module_instance_loaded_next,
*txm_module_instance_loaded_previous;
} TXM_MODULE_INSTANCE;
/* Determine if the thread entry info control block has an extension defined. If not, define the extension to
whitespace. */
#ifndef TXM_MODULE_THREAD_ENTRY_INFO_USER_EXTENSION
#define TXM_MODULE_THREAD_ENTRY_INFO_USER_EXTENSION
#endif
/* Define the thread entry information structure. This structure is placed on the thread's stack such that the
module's _txm_thread_shell_entry function does not need to access anything in the thread control block. */
typedef struct TXM_MODULE_THREAD_ENTRY_INFO_STRUCT
{
TX_THREAD *txm_module_thread_entry_info_thread;
TXM_MODULE_INSTANCE *txm_module_thread_entry_info_module;
VOID *txm_module_thread_entry_info_data_base_address; /* Don't move this, referenced in stack build to setup module data base register. */
VOID *txm_module_thread_entry_info_code_base_address;
VOID (*txm_module_thread_entry_info_entry)(ULONG);
ULONG txm_module_thread_entry_info_parameter;
VOID (*txm_module_thread_entry_info_exit_notify)(struct TX_THREAD_STRUCT *, UINT);
UINT txm_module_thread_entry_info_start_thread;
TX_THREAD *txm_module_thread_entry_info_callback_request_thread;
TX_QUEUE *txm_module_thread_entry_info_callback_request_queue;
VOID *txm_module_thread_entry_info_reserved;
ALIGN_TYPE (*txm_module_thread_entry_info_kernel_call_dispatcher)(ULONG kernel_request, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param_3);
TXM_MODULE_THREAD_ENTRY_INFO_USER_EXTENSION
} TXM_MODULE_THREAD_ENTRY_INFO;
/* Define the linked-list structure used to maintain the module's object allocation. */
typedef struct TXM_MODULE_ALLOCATED_OBJECT_STRUCT
{
TXM_MODULE_INSTANCE *txm_module_allocated_object_module_instance;
struct TXM_MODULE_ALLOCATED_OBJECT_STRUCT
*txm_module_allocated_object_next,
*txm_module_allocated_object_previous;
ULONG txm_module_object_size;
} TXM_MODULE_ALLOCATED_OBJECT;
/* Determine if module code is being compiled. If so, remap the ThreadX API to
the module shell functions that will go through the module <-> module manager
interface. */
#ifdef TXM_MODULE
/* Define the external reference to the module manager kernel dispatcher function pointer. This is supplied to the module by the module
manager when the module is created and started. */
extern ALIGN_TYPE (*_txm_module_kernel_call_dispatcher)(ULONG type, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param3);
/* Define specific module function prototypes. */
#define txm_module_application_request _txm_module_application_request
#define txm_module_object_allocate _txm_module_object_allocate
#define txm_module_object_deallocate _txm_module_object_deallocate
#define txm_module_object_pointer_get _txm_module_object_pointer_get
#define txm_module_object_pointer_get_extended _txm_module_object_pointer_get_extended
VOID _txm_module_thread_shell_entry(TX_THREAD *thread_ptr, TXM_MODULE_THREAD_ENTRY_INFO *thread_info);
UINT _txm_module_thread_system_suspend(TX_THREAD *thread_ptr);
UINT _txm_module_application_request(ULONG request, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param_3);
UINT _txm_module_object_allocate(VOID **object_ptr, ULONG object_size);
UINT _txm_module_object_deallocate(VOID *object_ptr);
UINT _txm_module_object_pointer_get(UINT object_type, CHAR *name, VOID **object_ptr);
UINT _txm_module_object_pointer_get_extended(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr);
/* Module callback functions. */
#ifdef TXM_MODULE_ENABLE_NETX
VOID _txm_module_netx_callback_request(TXM_MODULE_CALLBACK_MESSAGE *callback_message);
#endif
#ifdef TXM_MODULE_ENABLE_NETXDUO
VOID _txm_module_netxduo_callback_request(TXM_MODULE_CALLBACK_MESSAGE *callback_message);
#endif
#ifdef TXM_MODULE_ENABLE_FILEX
VOID _txm_module_filex_callback_request(TXM_MODULE_CALLBACK_MESSAGE *callback_message);
#endif
#ifdef TXM_MODULE_ENABLE_GUIX
VOID _txm_module_guix_duo_callback_request(TXM_MODULE_CALLBACK_MESSAGE *callback_message);
#endif
#ifdef TXM_MODULE_ENABLE_USBX
VOID _txm_module_usbx_duo_callback_request(TXM_MODULE_CALLBACK_MESSAGE *callback_message);
#endif
/* Define the module's thread shell entry function macros. */
#define TXM_THREAD_COMPLETED_EXTENSION(a)
#define TXM_THREAD_STATE_CHANGE(a, b)
#else
/* Map the module manager APIs just in case this is being included from the module manager in the
resident portion of the application. */
#define txm_module_manager_initialize _txm_module_manager_initialize
#define txm_module_manager_in_place_load _txm_module_manager_in_place_load
#define txm_module_manager_file_load _txm_module_manager_file_load
#define txm_module_manager_memory_load _txm_module_manager_memory_load
#define txm_module_manager_object_pointer_get _txm_module_manager_object_pointer_get
#define txm_module_manager_object_pointer_get_extended _txm_module_manager_object_pointer_get_extended
#define txm_module_manager_object_pool_create _txm_module_manager_object_pool_create
#define txm_module_manager_properties_get _txm_module_manager_properties_get
#define txm_module_manager_start _txm_module_manager_start
#define txm_module_manager_stop _txm_module_manager_stop
#define txm_module_manager_unload _txm_module_manager_unload
#define txm_module_manager_maximum_module_priority_set _txm_module_manager_maximum_module_priority_set
#define txm_module_manager_external_memory_enable _txm_module_manager_external_memory_enable
/* Define external variables used by module manager functions. */
#ifndef TX_MODULE_MANAGER_INIT
extern ULONG _txm_module_manager_properties_supported;
extern ULONG _txm_module_manager_properties_required;
extern TX_BYTE_POOL _txm_module_manager_byte_pool;
extern TX_BYTE_POOL _txm_module_manager_object_pool;
extern UINT _txm_module_manager_object_pool_created;
extern TXM_MODULE_INSTANCE *_txm_module_manager_loaded_list_ptr;
extern ULONG _txm_module_manger_loaded_count;
extern UINT _txm_module_manager_ready;
extern TX_MUTEX _txm_module_manager_mutex;
extern ULONG _txm_module_manager_callback_total_count;
extern ULONG _txm_module_manager_callback_error_count;
#endif
/* Define internal module manager function prototypes. */
UINT _txm_module_manager_application_request(ULONG request, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param_3);
#ifdef FX_FILEX_PRESENT
UINT _txm_module_manager_file_load(TXM_MODULE_INSTANCE *module_instance, CHAR *module_name, FX_MEDIA *media_ptr, CHAR *file_name);
#endif
UINT _txm_module_manager_initialize(VOID *module_memory_start, ULONG module_memory_size);
UINT _txm_module_manager_in_place_load(TXM_MODULE_INSTANCE *module_instance, CHAR *name, VOID *module_location);
UINT _txm_module_manager_internal_load(TXM_MODULE_INSTANCE *module_instance, CHAR *name, VOID *module_location,
ULONG code_size, VOID *code_allocation_ptr, ULONG code_allocation_size);
ALIGN_TYPE _txm_module_manager_kernel_dispatch(ULONG kernel_request, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2);
UINT _txm_module_manager_object_allocate(VOID **object_ptr_ptr, ULONG object_size, TXM_MODULE_INSTANCE *module_instance);
UINT _txm_module_manager_object_deallocate(VOID *object_ptr);
UINT _txm_module_manager_object_pointer_get(UINT object_type, CHAR *name, VOID **object_ptr);
UINT _txm_module_manager_object_pointer_get_extended(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr);
UINT _txm_module_manager_object_pool_create(VOID *object_memory, ULONG object_memory_size);
VOID _txm_module_manager_object_type_set(ULONG object_ptr, ULONG object_size, ULONG object_type);
UINT _txm_module_manager_memory_load(TXM_MODULE_INSTANCE *module_instance, CHAR *module_name, VOID *module_location);
UINT _txm_module_manager_properties_get(TXM_MODULE_INSTANCE *module_instance, ULONG *module_properties_ptr);
UINT _txm_module_manager_start(TXM_MODULE_INSTANCE *module_instance);
UINT _txm_module_manager_stop(TXM_MODULE_INSTANCE *module_instance);
UINT _txm_module_manager_thread_create(TX_THREAD *thread_ptr, CHAR *name, VOID (*shell_function)(TX_THREAD *, TXM_MODULE_INSTANCE *),
VOID (*entry_function)(ULONG), 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, TXM_MODULE_INSTANCE *module_instance);
UINT _txm_module_manager_thread_reset(TX_THREAD *thread_ptr);
VOID _txm_module_manager_name_build(CHAR *module_name, CHAR *thread_name, CHAR *combined_name);
VOID _txm_module_manager_thread_stack_build(TX_THREAD *thread_ptr, VOID (*shell_function)(TX_THREAD *, TXM_MODULE_INSTANCE *));
UINT _txm_module_manager_unload(TXM_MODULE_INSTANCE *module_instance);
ALIGN_TYPE _txm_module_manager_user_mode_entry(ULONG kernel_request, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param_3);
UINT _txm_module_manager_maximum_module_priority_set(TXM_MODULE_INSTANCE *module_instance, UINT priority);
UINT _txm_module_manager_external_memory_enable(TXM_MODULE_INSTANCE *module_instance, VOID *start_address, ULONG length, UINT attributes);
#ifdef TXM_MODULE_ENABLE_NETX
ULONG _txm_module_manager_netx_dispatch(TXM_MODULE_INSTANCE *module_instance, ULONG kernel_request, ULONG param_1, ULONG param_2, ULONG param_3);
UINT _txm_module_manager_netx_object_pointer_get(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr);
#endif
#ifdef TXM_MODULE_ENABLE_NETXDUO
ALIGN_TYPE _txm_module_manager_netxduo_dispatch(TXM_MODULE_INSTANCE *module_instance, ULONG kernel_request, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param_3);
UINT _txm_module_manager_netxduo_object_pointer_get(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr);
#endif
#ifdef TXM_MODULE_ENABLE_FILEX
ALIGN_TYPE _txm_module_manager_filex_dispatch(TXM_MODULE_INSTANCE *module_instance, ULONG kernel_request, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2);
UINT _txm_module_manager_filex_object_pointer_get(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr);
#endif
#ifdef TXM_MODULE_ENABLE_GUIX
ULONG _txm_module_manager_guix_dispatch(TXM_MODULE_INSTANCE *module_instance, ULONG kernel_request, ULONG param_1, ULONG param_2, ULONG param_3);
UINT _txm_module_manager_guix_object_pointer_get(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr);
#endif
#ifdef TXM_MODULE_ENABLE_USBX
ULONG _txm_module_manager_usbx_dispatch(TXM_MODULE_INSTANCE *module_instance, ULONG kernel_request, ULONG param_1, ULONG param_2, ULONG param_3);
UINT _txm_module_manager_usbx_object_pointer_get(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr);
#endif
/* Define the callback deferred processing routines necessary for executing callbacks in the module code. */
VOID _txm_module_manager_callback_request(TX_QUEUE *module_callback_queue, TXM_MODULE_CALLBACK_MESSAGE *callback_request);
VOID _txm_module_manager_event_flags_notify_trampoline(TX_EVENT_FLAGS_GROUP *group_ptr);
VOID _txm_module_manager_queue_notify_trampoline(TX_QUEUE *queue_ptr);
VOID _txm_module_manager_semaphore_notify_trampoline(TX_SEMAPHORE *semaphore_ptr);
VOID _txm_module_manager_thread_notify_trampoline(TX_THREAD *thread_ptr, UINT type);
VOID _txm_module_manager_timer_notify_trampoline(ULONG id);
/* Define port specific module manager prototypes. */
TXM_MODULE_MANAGER_ADDITIONAL_PROTOTYPES
#endif
/* Determine if a C++ compiler is being used. If so, complete the standard
C conditional started above. */
#ifdef __cplusplus
}
#endif
#endif

60
common_modules/inc/txm_module_user.h Normal file
View File

@@ -0,0 +1,60 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** User Specific */
/** */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/* */
/* APPLICATION INTERFACE DEFINITION RELEASE */
/* */
/* txm_module_user.h PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This file contains user defines for configuring the Module Manager */
/* in specific ways. This file will have an effect only if the Module */
/* Manager library is built with TXM_MODULE_INCLUDE_USER_DEFINE_FILE */
/* defined. Note that all the defines in this file may also be made on */
/* the command line when building Modules library and application */
/* objects. */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
#ifndef TXM_MODULE_USER_H
#define TXM_MODULE_USER_H
/* Defines the kernel stack size for a module thread. The default is 512, which is
sufficient for applications only using ThreadX, however, if other libraries are
used i.e. FileX, NetX, etc., then this value will most likely need to be increased. */
/* #define TXM_MODULE_KERNEL_STACK_SIZE 2048 */
#endif

80
common_modules/module_lib/src/txm_block_allocate.c Normal file
View File

@@ -0,0 +1,80 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_block_allocate PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the allocate block memory */
/* function call. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to pool control block */
/* block_ptr Pointer to place allocated block */
/* pointer */
/* wait_option Suspension option */
/* */
/* OUTPUT */
/* */
/* TX_POOL_ERROR Invalid pool pointer */
/* TX_PTR_ERROR Invalid destination pointer */
/* TX_WAIT_ERROR Invalid wait option */
/* status Actual Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG wait_option)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BLOCK_ALLOCATE_CALL, (ALIGN_TYPE) pool_ptr, (ALIGN_TYPE) block_ptr, (ALIGN_TYPE) wait_option);
/* Return value to the caller. */
return(return_value);
}

89
common_modules/module_lib/src/txm_block_pool_create.c Normal file
View File

@@ -0,0 +1,89 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_block_pool_create PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the create block memory pool */
/* function call. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to pool control block */
/* name_ptr Pointer to block pool name */
/* block_size Number of bytes in each block */
/* pool_start Address of beginning of pool area */
/* pool_size Number of bytes in the block pool */
/* pool_control_block_size Size of block pool control block */
/* */
/* OUTPUT */
/* */
/* TX_POOL_ERROR Invalid pool pointer */
/* TX_PTR_ERROR Invalid starting address */
/* TX_SIZE_ERROR Invalid pool size */
/* TX_CALLER_ERROR Invalid caller of pool */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[4];
extra_parameters[0] = (ALIGN_TYPE) block_size;
extra_parameters[1] = (ALIGN_TYPE) pool_start;
extra_parameters[2] = (ALIGN_TYPE) pool_size;
extra_parameters[3] = (ALIGN_TYPE) pool_control_block_size;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BLOCK_POOL_CREATE_CALL, (ALIGN_TYPE) pool_ptr, (ALIGN_TYPE) name_ptr, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_block_pool_delete.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_block_pool_delete PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the delete block pool memory */
/* function call. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to pool control block */
/* */
/* OUTPUT */
/* */
/* TX_POOL_ERROR Invalid memory block pool pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual delete function status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_block_pool_delete(TX_BLOCK_POOL *pool_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BLOCK_POOL_DELETE_CALL, (ALIGN_TYPE) pool_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

90
common_modules/module_lib/src/txm_block_pool_info_get.c Normal file
View File

@@ -0,0 +1,90 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_block_pool_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the block pool information get */
/* service. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to block pool control blk */
/* name Destination for the pool name */
/* available_blocks Number of free blocks in pool */
/* total_blocks Total number of blocks in pool */
/* first_suspended Destination for pointer of first */
/* thread suspended on block pool */
/* suspended_count Destination for suspended count */
/* next_pool Destination for pointer to next */
/* block pool on the created list */
/* */
/* OUTPUT */
/* */
/* TX_POOL_ERROR Invalid block pool pointer */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[5];
extra_parameters[0] = (ALIGN_TYPE) available_blocks;
extra_parameters[1] = (ALIGN_TYPE) total_blocks;
extra_parameters[2] = (ALIGN_TYPE) first_suspended;
extra_parameters[3] = (ALIGN_TYPE) suspended_count;
extra_parameters[4] = (ALIGN_TYPE) next_pool;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BLOCK_POOL_INFO_GET_CALL, (ALIGN_TYPE) pool_ptr, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

87
common_modules/module_lib/src/txm_block_pool_performance_info_get.c Normal file
View File

@@ -0,0 +1,87 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_block_pool_performance_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves performance information from the specified */
/* block pool. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to block pool control blk */
/* allocates Destination for the number of */
/* allocations from this pool */
/* releases Destination for the number of */
/* blocks released back to pool */
/* suspensions Destination for number of */
/* suspensions on this pool */
/* timeouts Destination for number of timeouts*/
/* on this pool */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_block_pool_performance_info_get(TX_BLOCK_POOL *pool_ptr, ULONG *allocates, ULONG *releases, ULONG *suspensions, ULONG *timeouts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[3];
extra_parameters[0] = (ALIGN_TYPE) releases;
extra_parameters[1] = (ALIGN_TYPE) suspensions;
extra_parameters[2] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BLOCK_POOL_PERFORMANCE_INFO_GET_CALL, (ALIGN_TYPE) pool_ptr, (ALIGN_TYPE) allocates, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

84
common_modules/module_lib/src/txm_block_pool_performance_system_info_get.c Normal file
View File

@@ -0,0 +1,84 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_block_pool_performance_system_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves block pool performance information. */
/* */
/* INPUT */
/* */
/* allocates Destination for the total number */
/* of block allocations */
/* releases Destination for the total number */
/* of blocks released */
/* suspensions Destination for the total number */
/* of suspensions */
/* timeouts Destination for total number of */
/* timeouts */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_block_pool_performance_system_info_get(ULONG *allocates, ULONG *releases, ULONG *suspensions, ULONG *timeouts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[2];
extra_parameters[0] = (ALIGN_TYPE) suspensions;
extra_parameters[1] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL, (ALIGN_TYPE) allocates, (ALIGN_TYPE) releases, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

73
common_modules/module_lib/src/txm_block_pool_prioritize.c Normal file
View File

@@ -0,0 +1,73 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_block_pool_prioritize PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the block pool prioritize call. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to pool control block */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BLOCK_POOL_PRIORITIZE_CALL, (ALIGN_TYPE) pool_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_block_release.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_block_release PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the block release function call. */
/* */
/* INPUT */
/* */
/* block_ptr Pointer to memory block */
/* */
/* OUTPUT */
/* */
/* TX_PTR_ERROR Invalid memory block pointer */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_block_release(VOID *block_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BLOCK_RELEASE_CALL, (ALIGN_TYPE) block_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

86
common_modules/module_lib/src/txm_byte_allocate.c Normal file
View File

@@ -0,0 +1,86 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_byte_allocate PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in allocate bytes function call. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to pool control block */
/* memory_ptr Pointer to place allocated bytes */
/* pointer */
/* memory_size Number of bytes to allocate */
/* wait_option Suspension option */
/* */
/* OUTPUT */
/* */
/* TX_POOL_ERROR Invalid memory pool pointer */
/* TX_PTR_ERROR Invalid destination pointer */
/* TX_WAIT_ERROR Invalid wait option */
/* TX_CALLER_ERROR Invalid caller of this function */
/* TX_SIZE_ERROR Invalid size of memory request */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG memory_size, ULONG wait_option)
{
UINT return_value;
ALIGN_TYPE extra_parameters[2];
extra_parameters[0] = (ALIGN_TYPE) memory_size;
extra_parameters[1] = (ALIGN_TYPE) wait_option;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BYTE_ALLOCATE_CALL, (ALIGN_TYPE) pool_ptr, (ALIGN_TYPE) memory_ptr, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

87
common_modules/module_lib/src/txm_byte_pool_create.c Normal file
View File

@@ -0,0 +1,87 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_byte_pool_create PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the create byte pool memory */
/* function. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to pool control block */
/* name_ptr Pointer to byte pool name */
/* pool_start Address of beginning of pool area */
/* pool_size Number of bytes in the byte pool */
/* pool_control_block_size Size of byte pool control block */
/* */
/* OUTPUT */
/* */
/* TX_POOL_ERROR Invalid byte pool pointer */
/* TX_PTR_ERROR Invalid pool starting address */
/* TX_SIZE_ERROR Invalid pool size */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[3];
extra_parameters[0] = (ALIGN_TYPE) pool_start;
extra_parameters[1] = (ALIGN_TYPE) pool_size;
extra_parameters[2] = (ALIGN_TYPE) pool_control_block_size;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BYTE_POOL_CREATE_CALL, (ALIGN_TYPE) pool_ptr, (ALIGN_TYPE) name_ptr, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_byte_pool_delete.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_byte_pool_delete PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the delete byte pool function */
/* call. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to pool control block */
/* */
/* OUTPUT */
/* */
/* TX_POOL_ERROR Invalid pool pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_byte_pool_delete(TX_BYTE_POOL *pool_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BYTE_POOL_DELETE_CALL, (ALIGN_TYPE) pool_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

90
common_modules/module_lib/src/txm_byte_pool_info_get.c Normal file
View File

@@ -0,0 +1,90 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_byte_pool_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the byte pool information get */
/* service. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to byte pool control block*/
/* name Destination for the pool name */
/* available_bytes Number of free bytes in byte pool */
/* fragments Number of fragments in byte pool */
/* first_suspended Destination for pointer of first */
/* thread suspended on byte pool */
/* suspended_count Destination for suspended count */
/* next_pool Destination for pointer to next */
/* byte pool on the created list */
/* */
/* OUTPUT */
/* */
/* TX_POOL_ERROR Invalid byte pool pointer */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[5];
extra_parameters[0] = (ALIGN_TYPE) available_bytes;
extra_parameters[1] = (ALIGN_TYPE) fragments;
extra_parameters[2] = (ALIGN_TYPE) first_suspended;
extra_parameters[3] = (ALIGN_TYPE) suspended_count;
extra_parameters[4] = (ALIGN_TYPE) next_pool;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BYTE_POOL_INFO_GET_CALL, (ALIGN_TYPE) pool_ptr, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

98
common_modules/module_lib/src/txm_byte_pool_performance_info_get.c Normal file
View File

@@ -0,0 +1,98 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_byte_pool_performance_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves performance information from the specified */
/* byte pool. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to byte pool control block*/
/* allocates Destination for number of */
/* allocates on this pool */
/* releases Destination for number of */
/* releases on this pool */
/* fragments_searched Destination for number of */
/* fragments searched during */
/* allocation */
/* merges Destination for number of adjacent*/
/* free fragments merged */
/* splits Destination for number of */
/* fragments split during */
/* allocation */
/* suspensions Destination for number of */
/* suspensions on this pool */
/* timeouts Destination for number of timeouts*/
/* on this byte pool */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[6];
extra_parameters[0] = (ALIGN_TYPE) releases;
extra_parameters[1] = (ALIGN_TYPE) fragments_searched;
extra_parameters[2] = (ALIGN_TYPE) merges;
extra_parameters[3] = (ALIGN_TYPE) splits;
extra_parameters[4] = (ALIGN_TYPE) suspensions;
extra_parameters[5] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BYTE_POOL_PERFORMANCE_INFO_GET_CALL, (ALIGN_TYPE) pool_ptr, (ALIGN_TYPE) allocates, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

95
common_modules/module_lib/src/txm_byte_pool_performance_system_info_get.c Normal file
View File

@@ -0,0 +1,95 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_byte_pool_performance_system_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves byte pool performance information. */
/* */
/* INPUT */
/* */
/* allocates Destination for total number of */
/* allocates */
/* releases Destination for total number of */
/* releases */
/* fragments_searched Destination for total number of */
/* fragments searched during */
/* allocation */
/* merges Destination for total number of */
/* adjacent free fragments merged */
/* splits Destination for total number of */
/* fragments split during */
/* allocation */
/* suspensions Destination for total number of */
/* suspensions */
/* timeouts Destination for total number of */
/* timeouts */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_byte_pool_performance_system_info_get(ULONG *allocates, ULONG *releases, ULONG *fragments_searched, ULONG *merges, ULONG *splits, ULONG *suspensions, ULONG *timeouts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[5];
extra_parameters[0] = (ALIGN_TYPE) fragments_searched;
extra_parameters[1] = (ALIGN_TYPE) merges;
extra_parameters[2] = (ALIGN_TYPE) splits;
extra_parameters[3] = (ALIGN_TYPE) suspensions;
extra_parameters[4] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL, (ALIGN_TYPE) allocates, (ALIGN_TYPE) releases, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

73
common_modules/module_lib/src/txm_byte_pool_prioritize.c Normal file
View File

@@ -0,0 +1,73 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_byte_pool_prioritize PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the byte pool prioritize call. */
/* */
/* INPUT */
/* */
/* pool_ptr Pointer to pool control block */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BYTE_POOL_PRIORITIZE_CALL, (ALIGN_TYPE) pool_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

75
common_modules/module_lib/src/txm_byte_release.c Normal file
View File

@@ -0,0 +1,75 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_byte_release PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the release byte function call. */
/* */
/* INPUT */
/* */
/* memory_ptr Pointer to allocated memory */
/* */
/* OUTPUT */
/* */
/* TX_PTR_ERROR Invalid memory pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_byte_release(VOID *memory_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_BYTE_RELEASE_CALL, (ALIGN_TYPE) memory_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

79
common_modules/module_lib/src/txm_event_flags_create.c Normal file
View File

@@ -0,0 +1,79 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_event_flags_create PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the event flag creation function */
/* call. */
/* */
/* INPUT */
/* */
/* group_ptr Pointer to event flags group */
/* control block */
/* name_ptr Pointer to event flags name */
/* event_control_block_size Size of event flags control block */
/* */
/* OUTPUT */
/* */
/* TX_GROUP_ERROR Invalid event flag group pointer */
/* TX_CALLER_ERROR Invalid calling function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_event_flags_create(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR *name_ptr, UINT event_control_block_size)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_EVENT_FLAGS_CREATE_CALL, (ALIGN_TYPE) group_ptr, (ALIGN_TYPE) name_ptr, (ALIGN_TYPE) event_control_block_size);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_event_flags_delete.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_event_flags_delete PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the delete event flags group */
/* function call. */
/* */
/* INPUT */
/* */
/* group_ptr Pointer to group control block */
/* */
/* OUTPUT */
/* */
/* TX_GROUP_ERROR Invalid event flag group pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_EVENT_FLAGS_DELETE_CALL, (ALIGN_TYPE) group_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

89
common_modules/module_lib/src/txm_event_flags_get.c Normal file
View File

@@ -0,0 +1,89 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_event_flags_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the event flags get function */
/* call. */
/* */
/* INPUT */
/* */
/* group_ptr Pointer to group control block */
/* requested_event_flags Event flags requested */
/* get_option Specifies and/or and clear options*/
/* actual_flags_ptr Pointer to place the actual flags */
/* the service retrieved */
/* wait_option Suspension option */
/* */
/* OUTPUT */
/* */
/* TX_GROUP_ERROR Invalid event flags group pointer */
/* TX_PTR_ERROR Invalid actual flags pointer */
/* TX_WAIT_ERROR Invalid wait option */
/* TX_OPTION_ERROR Invalid get option */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[3];
extra_parameters[0] = (ALIGN_TYPE) get_option;
extra_parameters[1] = (ALIGN_TYPE) actual_flags_ptr;
extra_parameters[2] = (ALIGN_TYPE) wait_option;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_EVENT_FLAGS_GET_CALL, (ALIGN_TYPE) group_ptr, (ALIGN_TYPE) requested_flags, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

90
common_modules/module_lib/src/txm_event_flags_info_get.c Normal file
View File

@@ -0,0 +1,90 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_event_flags_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the event flag information get */
/* service. */
/* */
/* INPUT */
/* */
/* group_ptr Pointer to event flag group */
/* name Destination for the event flags */
/* group name */
/* current_flags Current event flags */
/* first_suspended Destination for pointer of first */
/* thread suspended on event flags */
/* suspended_count Destination for suspended count */
/* next_group Destination for pointer to next */
/* event flag group on the created */
/* list */
/* */
/* OUTPUT */
/* */
/* TX_GROUP_ERROR Invalid event flag group pointer */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[4];
extra_parameters[0] = (ALIGN_TYPE) current_flags;
extra_parameters[1] = (ALIGN_TYPE) first_suspended;
extra_parameters[2] = (ALIGN_TYPE) suspended_count;
extra_parameters[3] = (ALIGN_TYPE) next_group;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_EVENT_FLAGS_INFO_GET_CALL, (ALIGN_TYPE) group_ptr, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

88
common_modules/module_lib/src/txm_event_flags_performance_info_get.c Normal file
View File

@@ -0,0 +1,88 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_event_flags_performance_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves performance information from the specified */
/* event flag group. */
/* */
/* INPUT */
/* */
/* group_ptr Pointer to event flag group */
/* sets Destination for the number of */
/* event flag sets on this group */
/* gets Destination for the number of */
/* event flag gets on this group */
/* suspensions Destination for the number of */
/* event flag suspensions on this */
/* group */
/* timeouts Destination for number of timeouts*/
/* on this event flag group */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_event_flags_performance_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG *sets, ULONG *gets, ULONG *suspensions, ULONG *timeouts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[3];
extra_parameters[0] = (ALIGN_TYPE) gets;
extra_parameters[1] = (ALIGN_TYPE) suspensions;
extra_parameters[2] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_EVENT_FLAGS_PERFORMANCE_INFO_GET_CALL, (ALIGN_TYPE) group_ptr, (ALIGN_TYPE) sets, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

84
common_modules/module_lib/src/txm_event_flags_performance_system_info_get.c Normal file
View File

@@ -0,0 +1,84 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_event_flags_performance_system_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves system event flag performance information. */
/* */
/* INPUT */
/* */
/* sets Destination for total number of */
/* event flag sets */
/* gets Destination for total number of */
/* event flag gets */
/* suspensions Destination for total number of */
/* event flag suspensions */
/* timeouts Destination for total number of */
/* timeouts */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_event_flags_performance_system_info_get(ULONG *sets, ULONG *gets, ULONG *suspensions, ULONG *timeouts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[2];
extra_parameters[0] = (ALIGN_TYPE) suspensions;
extra_parameters[1] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_CALL, (ALIGN_TYPE) sets, (ALIGN_TYPE) gets, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

79
common_modules/module_lib/src/txm_event_flags_set.c Normal file
View File

@@ -0,0 +1,79 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_event_flags_set PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the set event flags function */
/* call. */
/* */
/* INPUT */
/* */
/* group_ptr Pointer to group control block */
/* flags_to_set Event flags to set */
/* set_option Specified either AND or OR */
/* operation on the event flags */
/* */
/* OUTPUT */
/* */
/* TX_GROUP_ERROR Invalid event flags group pointer */
/* TX_OPTION_ERROR Invalid set option */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set, UINT set_option)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_EVENT_FLAGS_SET_CALL, (ALIGN_TYPE) group_ptr, (ALIGN_TYPE) flags_to_set, (ALIGN_TYPE) set_option);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_event_flags_set_notify.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_event_flags_set_notify PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the event flags set notify */
/* callback function call. */
/* */
/* INPUT */
/* */
/* group_ptr Pointer to group control block*/
/* group_put_notify Application callback function */
/* (TX_NULL disables notify) */
/* */
/* OUTPUT */
/* */
/* status Service return status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_event_flags_set_notify(TX_EVENT_FLAGS_GROUP *group_ptr, VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *))
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_EVENT_FLAGS_SET_NOTIFY_CALL, (ALIGN_TYPE) group_ptr, (ALIGN_TYPE) events_set_notify, 0);
/* Return value to the caller. */
return(return_value);
}

78
common_modules/module_lib/src/txm_module_application_request.c Normal file
View File

@@ -0,0 +1,78 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* txm_module_application_request PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function sends an application-specific request to the resident */
/* code. */
/* */
/* INPUT */
/* */
/* request Request ID (application defined) */
/* param_1 First parameter */
/* param_2 Second parameter */
/* param_3 Third parameter */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT txm_module_application_request(ULONG request, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param_3)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT)(_txm_module_kernel_call_dispatcher)(TXM_APPLICATION_REQUEST_ID_BASE+request, param_1, param_2, param_3);
/* Return value to the caller. */
return(return_value);
}

244
common_modules/module_lib/src/txm_module_callback_request_thread_entry.c Normal file
View File

@@ -0,0 +1,244 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#ifndef TXM_MODULE
#define TXM_MODULE
#endif
#ifndef TX_SOURCE_CODE
#define TX_SOURCE_CODE
#endif
/* Include necessary system files. */
#include "txm_module.h"
#include "tx_queue.h"
/* Define the global module entry pointer from the start thread of the module.
This structure contains the pointer to the request queue as well as the
pointer to the callback response queue. */
extern TXM_MODULE_THREAD_ENTRY_INFO *_txm_module_entry_info;
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txm_module_callback_request_thread_entry PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function processes all module callback requests, transferred */
/* by the resident code via the callback queue. When the callback is */
/* complete, the response is sent back to the resident code to */
/* acknowledge it. */
/* */
/* INPUT */
/* */
/* id Module thread ID */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* tx_queue_receive Receive callback request */
/* */
/* CALLED BY */
/* */
/* Initial thread stack frame */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
VOID _txm_module_callback_request_thread_entry(ULONG id)
{
TX_QUEUE *request_queue;
TXM_MODULE_CALLBACK_MESSAGE callback_message;
ULONG activation_count;
VOID (*timer_callback)(ULONG);
VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *);
VOID (*semaphore_put_notify)(TX_SEMAPHORE *);
VOID (*queue_send_notify)(TX_QUEUE *);
VOID (*thread_entry_exit_notify)(TX_THREAD *, UINT);
UINT status;
/* Pickup pointer to the request queue. */
request_queue = _txm_module_entry_info -> txm_module_thread_entry_info_callback_request_queue;
/* Loop to process callback messages from the module manager. */
while(1)
{
/* Wait for the callback request for the module. */
status = _txe_queue_receive(request_queue, (VOID *) &callback_message, TX_WAIT_FOREVER);
/* Check to see if a request was received. */
if (status != TX_SUCCESS)
{
/* This should not happen - get out of the loop. */
break;
}
/* Pickup the activation count in the message. */
activation_count = callback_message.txm_module_callback_message_activation_count;
/* Loop to call the callback function the correct number of times. */
while (activation_count)
{
/* Decrement the activation count. */
activation_count--;
/* Now dispatch the callback function. */
switch (callback_message.txm_module_callback_message_type)
{
case TXM_TIMER_CALLBACK:
/* Setup timer callback pointer. */
timer_callback = (void (*)(ULONG)) callback_message.txm_module_callback_message_application_function;
/* Call application's timer callback. */
(timer_callback)((ULONG) callback_message.txm_module_callback_message_param_1);
break;
case TXM_EVENTS_SET_CALLBACK:
/* Setup events set callback pointer. */
events_set_notify = (void (*)(TX_EVENT_FLAGS_GROUP *)) callback_message.txm_module_callback_message_application_function;
/* Call events set notify callback. */
(events_set_notify)((TX_EVENT_FLAGS_GROUP *) callback_message.txm_module_callback_message_param_1);
break;
case TXM_QUEUE_SEND_CALLBACK:
/* Setup queue send callback pointer. */
queue_send_notify = (void (*)(TX_QUEUE *)) callback_message.txm_module_callback_message_application_function;
/* Call queue send notify callback. */
(queue_send_notify)((TX_QUEUE *) callback_message.txm_module_callback_message_param_1);
break;
case TXM_SEMAPHORE_PUT_CALLBACK:
/* Setup semaphore put callback pointer. */
semaphore_put_notify = (void (*)(TX_SEMAPHORE *)) callback_message.txm_module_callback_message_application_function;
/* Call semaphore put notify callback. */
(semaphore_put_notify)((TX_SEMAPHORE *) callback_message.txm_module_callback_message_param_1);
break;
case TXM_THREAD_ENTRY_EXIT_CALLBACK:
/* Setup thread entry/exit callback pointer. */
thread_entry_exit_notify = (void (*)(TX_THREAD *, UINT)) callback_message.txm_module_callback_message_application_function;
/* Call thread entry/exit notify callback. */
(thread_entry_exit_notify)((TX_THREAD *) callback_message.txm_module_callback_message_param_1, (UINT) callback_message.txm_module_callback_message_param_2);
break;
default:
#ifdef TXM_MODULE_ENABLE_NETX
/* Determine if there is a NetX callback. */
if ((callback_message.txm_module_callback_message_type >= TXM_NETX_CALLBACKS_START) && (callback_message.txm_module_callback_message_type < TXM_NETX_CALLBACKS_END))
{
/* Call the NetX module callback function. */
_txm_module_netx_callback_request(&callback_message);
}
#endif
#ifdef TXM_MODULE_ENABLE_NETXDUO
/* Determine if there is a NetX Duo callback. */
if ((callback_message.txm_module_callback_message_type >= TXM_NETXDUO_CALLBACKS_START) && (callback_message.txm_module_callback_message_type < TXM_NETXDUO_CALLBACKS_END))
{
/* Call the NetX Duo module callback function. */
_txm_module_netxduo_callback_request(&callback_message);
}
#endif
#ifdef TXM_MODULE_ENABLE_FILEX
/* Determine if there is a FileX callback. */
if ((callback_message.txm_module_callback_message_type >= TXM_FILEX_CALLBACKS_START) && (callback_message.txm_module_callback_message_type < TXM_FILEX_CALLBACKS_END))
{
/* Call the FileX module callback function. */
_txm_module_filex_callback_request(&callback_message);
}
#endif
#ifdef TXM_MODULE_ENABLE_GUIX
/* Determine if there is a GUIX callback. */
if ((callback_message.txm_module_callback_message_type >= TXM_GUIX_CALLBACKS_START) && (callback_message.txm_module_callback_message_type < TXM_GUIX_CALLBACKS_END))
{
/* Call the GUIX module callback function. */
_txm_module_guix_callback_request(&callback_message);
}
#endif
#ifdef TXM_MODULE_ENABLE_USBX
/* Determine if there is a USBX callback. */
if ((callback_message.txm_module_callback_message_type >= TXM_USBX_CALLBACKS_START) && (callback_message.txm_module_callback_message_type < TXM_USBX_CALLBACKS_END))
{
/* Call the USBX callback function. */
_txm_module_usbx_callback_request(&callback_message);
}
#endif
break;
}
}
}
}

79
common_modules/module_lib/src/txm_module_object_allocate.c Normal file
View File

@@ -0,0 +1,79 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txm_module_manager_object_allocate PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function allocates memory for an object from the memory pool */
/* supplied to txm_module_manager_initialize. */
/* */
/* INPUT */
/* */
/* object_ptr Destination of object pointer on */
/* successful allocation */
/* object_size Size in bytes of the object to be */
/* allocated */
/* module_instance The module instance that the */
/* object belongs to */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txm_module_object_allocate(VOID **object_ptr, ULONG object_size)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MODULE_OBJECT_ALLOCATE_CALL, (ALIGN_TYPE) object_ptr, (ALIGN_TYPE) object_size, 0);
/* Return value to the caller. */
return(return_value);
}

73
common_modules/module_lib/src/txm_module_object_deallocate.c Normal file
View File

@@ -0,0 +1,73 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txm_module_manager_object_deallocate PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function deallocates a previously allocated object. */
/* */
/* INPUT */
/* */
/* object_ptr Object pointer to deallocate */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txm_module_object_deallocate(VOID *object_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MODULE_OBJECT_DEALLOCATE_CALL, (ALIGN_TYPE) object_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

89
common_modules/module_lib/src/txm_module_object_pointer_get.c Normal file
View File

@@ -0,0 +1,89 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txm_module_manager_object_pointer_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function is deprecated and calls the secure version of this */
/* function (_txm_module_manager_object_pointer_get_extended) with the */
/* maximum possible name length since none was passed. */
/* */
/* INPUT */
/* */
/* object_type Type of object, as follows: */
/* */
/* TXM_BLOCK_POOL_OBJECT */
/* TXM_BYTE_POOL_OBJECT */
/* TXM_EVENT_FLAGS_OBJECT */
/* TXM_MUTEX_OBJECT */
/* TXM_QUEUE_OBJECT */
/* TXM_SEMAPHORE_OBJECT */
/* TXM_THREAD_OBJECT */
/* TXM_TIMER_OBJECT */
/* name Name to search for */
/* object_ptr Pointer to the object */
/* */
/* OUTPUT */
/* */
/* TX_SUCCESS Successful completion */
/* TX_PTR_ERROR Invalid name or object ptr */
/* TX_OPTION_ERROR Invalid option type */
/* TX_NO_INSTANCE Object not found */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txm_module_object_pointer_get(UINT object_type, CHAR *name, VOID **object_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MODULE_OBJECT_POINTER_GET_CALL, (ALIGN_TYPE) object_type, (ALIGN_TYPE) name, (ALIGN_TYPE) object_ptr);
/* Return value to the caller. */
return(return_value);
}

96
common_modules/module_lib/src/txm_module_object_pointer_get_extended.c Normal file
View File

@@ -0,0 +1,96 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txm_module_manager_object_pointer_get_extended PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves the object pointer of a particular type */
/* with a particular name. If the object is not found, an error is */
/* returned. Otherwise, if the object is found, the address of that */
/* object is placed in object_ptr. */
/* */
/* INPUT */
/* */
/* object_type Type of object, as follows: */
/* */
/* TXM_BLOCK_POOL_OBJECT */
/* TXM_BYTE_POOL_OBJECT */
/* TXM_EVENT_FLAGS_OBJECT */
/* TXM_MUTEX_OBJECT */
/* TXM_QUEUE_OBJECT */
/* TXM_SEMAPHORE_OBJECT */
/* TXM_THREAD_OBJECT */
/* TXM_TIMER_OBJECT */
/* name Name to search for */
/* name_length Length of the name excluding */
/* null-terminator */
/* object_ptr Pointer to the object */
/* */
/* OUTPUT */
/* */
/* TX_SUCCESS Successful completion */
/* TX_PTR_ERROR Invalid name or object ptr */
/* TX_OPTION_ERROR Invalid option type */
/* TX_NO_INSTANCE Object not found */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txm_module_object_pointer_get_extended(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr)
{
UINT return_value;
ALIGN_TYPE extra_parameters[2];
extra_parameters[0] = (ALIGN_TYPE) name_length;
extra_parameters[1] = (ALIGN_TYPE) object_ptr;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MODULE_OBJECT_POINTER_GET_EXTENDED_CALL, (ALIGN_TYPE) object_type, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

81
common_modules/module_lib/src/txm_module_thread_system_suspend.c Normal file
View File

@@ -0,0 +1,81 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_thread_system_suspend PORTABLE C */
/* 6.0.1 */
/* */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function suspends the specified thread and changes the thread */
/* state to the value specified. Note: delayed suspension processing */
/* is handled outside of this routine. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread to suspend */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* _tx_thread_priority_change Thread priority change */
/* _tx_thread_shell_entry Thread shell function */
/* _tx_thread_sleep Thread sleep */
/* _tx_thread_suspend Application thread suspend */
/* _tx_thread_terminate Thread terminate */
/* Other ThreadX Components */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txm_module_thread_system_suspend(TX_THREAD *thread_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_SYSTEM_SUSPEND_CALL, (ALIGN_TYPE) thread_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

84
common_modules/module_lib/src/txm_mutex_create.c Normal file
View File

@@ -0,0 +1,84 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_mutex_create PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the create mutex function */
/* call. */
/* */
/* INPUT */
/* */
/* mutex_ptr Pointer to mutex control block */
/* name_ptr Pointer to mutex name */
/* inherit Initial mutex count */
/* mutex_control_block_size Size of mutex control block */
/* */
/* OUTPUT */
/* */
/* TX_MUTEX_ERROR Invalid mutex pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* TX_INHERIT_ERROR Invalid inherit option */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_mutex_create(TX_MUTEX *mutex_ptr, CHAR *name_ptr, UINT inherit, UINT mutex_control_block_size)
{
UINT return_value;
ALIGN_TYPE extra_parameters[2];
extra_parameters[0] = (ALIGN_TYPE) inherit;
extra_parameters[1] = (ALIGN_TYPE) mutex_control_block_size;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MUTEX_CREATE_CALL, (ALIGN_TYPE) mutex_ptr, (ALIGN_TYPE) name_ptr, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_mutex_delete.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_mutex_delete PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the mutex delete function */
/* call. */
/* */
/* INPUT */
/* */
/* mutex_ptr Pointer to mutex control block */
/* */
/* OUTPUT */
/* */
/* TX_MUTEX_ERROR Invalid mutex pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_mutex_delete(TX_MUTEX *mutex_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MUTEX_DELETE_CALL, (ALIGN_TYPE) mutex_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_mutex_get.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_mutex_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the mutex get function call. */
/* */
/* INPUT */
/* */
/* mutex_ptr Pointer to mutex control block */
/* wait_option Suspension option */
/* */
/* OUTPUT */
/* */
/* TX_MUTEX_ERROR Invalid mutex pointer */
/* TX_WAIT_ERROR Invalid wait option */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MUTEX_GET_CALL, (ALIGN_TYPE) mutex_ptr, (ALIGN_TYPE) wait_option, 0);
/* Return value to the caller. */
return(return_value);
}

91
common_modules/module_lib/src/txm_mutex_info_get.c Normal file
View File

@@ -0,0 +1,91 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_mutex_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the mutex information get */
/* service. */
/* */
/* INPUT */
/* */
/* mutex_ptr Pointer to mutex control block */
/* name Destination for the mutex name */
/* count Destination for the owner count */
/* owner Destination for the owner's */
/* thread control block pointer */
/* first_suspended Destination for pointer of first */
/* thread suspended on the mutex */
/* suspended_count Destination for suspended count */
/* next_mutex Destination for pointer to next */
/* mutex on the created list */
/* */
/* OUTPUT */
/* */
/* TX_MUTEX_ERROR Invalid mutex pointer */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[5];
extra_parameters[0] = (ALIGN_TYPE) count;
extra_parameters[1] = (ALIGN_TYPE) owner;
extra_parameters[2] = (ALIGN_TYPE) first_suspended;
extra_parameters[3] = (ALIGN_TYPE) suspended_count;
extra_parameters[4] = (ALIGN_TYPE) next_mutex;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MUTEX_INFO_GET_CALL, (ALIGN_TYPE) mutex_ptr, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

93
common_modules/module_lib/src/txm_mutex_performance_info_get.c Normal file
View File

@@ -0,0 +1,93 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_mutex_performance_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves performance information from the specified */
/* mutex. */
/* */
/* INPUT */
/* */
/* mutex_ptr Pointer to mutex control block */
/* puts Destination for the number of */
/* puts on to this mutex */
/* gets Destination for the number of */
/* gets on this mutex */
/* suspensions Destination for the number of */
/* suspensions on this mutex */
/* timeouts Destination for number of timeouts*/
/* on this mutex */
/* inversions Destination for number of priority*/
/* inversions on this mutex */
/* inheritances Destination for number of priority*/
/* inheritances on this mutex */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_mutex_performance_info_get(TX_MUTEX *mutex_ptr, ULONG *puts, ULONG *gets, ULONG *suspensions, ULONG *timeouts, ULONG *inversions, ULONG *inheritances)
{
UINT return_value;
ALIGN_TYPE extra_parameters[5];
extra_parameters[0] = (ALIGN_TYPE) gets;
extra_parameters[1] = (ALIGN_TYPE) suspensions;
extra_parameters[2] = (ALIGN_TYPE) timeouts;
extra_parameters[3] = (ALIGN_TYPE) inversions;
extra_parameters[4] = (ALIGN_TYPE) inheritances;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MUTEX_PERFORMANCE_INFO_GET_CALL, (ALIGN_TYPE) mutex_ptr, (ALIGN_TYPE) puts, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

90
common_modules/module_lib/src/txm_mutex_performance_system_info_get.c Normal file
View File

@@ -0,0 +1,90 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_mutex_performance_system_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves system mutex performance information. */
/* */
/* INPUT */
/* */
/* puts Destination for total number of */
/* mutex puts */
/* gets Destination for total number of */
/* mutex gets */
/* suspensions Destination for total number of */
/* mutex suspensions */
/* timeouts Destination for total number of */
/* mutex timeouts */
/* inversions Destination for total number of */
/* mutex priority inversions */
/* inheritances Destination for total number of */
/* mutex priority inheritances */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_mutex_performance_system_info_get(ULONG *puts, ULONG *gets, ULONG *suspensions, ULONG *timeouts, ULONG *inversions, ULONG *inheritances)
{
UINT return_value;
ALIGN_TYPE extra_parameters[4];
extra_parameters[0] = (ALIGN_TYPE) suspensions;
extra_parameters[1] = (ALIGN_TYPE) timeouts;
extra_parameters[2] = (ALIGN_TYPE) inversions;
extra_parameters[3] = (ALIGN_TYPE) inheritances;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_CALL, (ALIGN_TYPE) puts, (ALIGN_TYPE) gets, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

73
common_modules/module_lib/src/txm_mutex_prioritize.c Normal file
View File

@@ -0,0 +1,73 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_mutex_prioritize PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the mutex prioritize call. */
/* */
/* INPUT */
/* */
/* mutex_ptr Pointer to mutex control block */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_mutex_prioritize(TX_MUTEX *mutex_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MUTEX_PRIORITIZE_CALL, (ALIGN_TYPE) mutex_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_mutex_put.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_mutex_put PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the mutex put function call. */
/* */
/* INPUT */
/* */
/* mutex_ptr Pointer to mutex control block */
/* */
/* OUTPUT */
/* */
/* TX_MUTEX_ERROR Invalid mutex pointer */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_mutex_put(TX_MUTEX *mutex_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_MUTEX_PUT_CALL, (ALIGN_TYPE) mutex_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

87
common_modules/module_lib/src/txm_queue_create.c Normal file
View File

@@ -0,0 +1,87 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_create PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue create function call. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* name_ptr Pointer to queue name */
/* message_size Size of each queue message */
/* queue_start Starting address of the queue area*/
/* queue_size Number of bytes in the queue */
/* queue_control_block_size Size of queue control block */
/* */
/* OUTPUT */
/* */
/* TX_QUEUE_ERROR Invalid queue pointer */
/* TX_PTR_ERROR Invalid starting address of queue */
/* TX_SIZE_ERROR Invalid message queue size */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[4];
extra_parameters[0] = (ALIGN_TYPE) message_size;
extra_parameters[1] = (ALIGN_TYPE) queue_start;
extra_parameters[2] = (ALIGN_TYPE) queue_size;
extra_parameters[3] = (ALIGN_TYPE) queue_control_block_size;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_CREATE_CALL, (ALIGN_TYPE) queue_ptr, (ALIGN_TYPE) name_ptr, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

75
common_modules/module_lib/src/txm_queue_delete.c Normal file
View File

@@ -0,0 +1,75 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_delete PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue delete function call. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* */
/* OUTPUT */
/* */
/* TX_QUEUE_ERROR Invalid queue pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_queue_delete(TX_QUEUE *queue_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_DELETE_CALL, (ALIGN_TYPE) queue_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

75
common_modules/module_lib/src/txm_queue_flush.c Normal file
View File

@@ -0,0 +1,75 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_flush PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue flush function call. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* */
/* OUTPUT */
/* */
/* TX_QUEUE_ERROR Invalid queue pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_queue_flush(TX_QUEUE *queue_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_FLUSH_CALL, (ALIGN_TYPE) queue_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

78
common_modules/module_lib/src/txm_queue_front_send.c Normal file
View File

@@ -0,0 +1,78 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_front_send PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue send function call. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* source_ptr Pointer to message source */
/* wait_option Suspension option */
/* */
/* OUTPUT */
/* */
/* TX_QUEUE_ERROR Invalid queue pointer */
/* TX_PTR_ERROR Invalid source pointer - NULL */
/* TX_WAIT_ERROR Invalid wait option - non thread */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_queue_front_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_FRONT_SEND_CALL, (ALIGN_TYPE) queue_ptr, (ALIGN_TYPE) source_ptr, (ALIGN_TYPE) wait_option);
/* Return value to the caller. */
return(return_value);
}

90
common_modules/module_lib/src/txm_queue_info_get.c Normal file
View File

@@ -0,0 +1,90 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue information get */
/* service. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* name Destination for the queue name */
/* enqueued Destination for enqueued count */
/* available_storage Destination for available storage */
/* first_suspended Destination for pointer of first */
/* thread suspended on this queue */
/* suspended_count Destination for suspended count */
/* next_queue Destination for pointer to next */
/* queue on the created list */
/* */
/* OUTPUT */
/* */
/* TX_QUEUE_ERROR Invalid queue pointer */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[5];
extra_parameters[0] = (ALIGN_TYPE) enqueued;
extra_parameters[1] = (ALIGN_TYPE) available_storage;
extra_parameters[2] = (ALIGN_TYPE) first_suspended;
extra_parameters[3] = (ALIGN_TYPE) suspended_count;
extra_parameters[4] = (ALIGN_TYPE) next_queue;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_INFO_GET_CALL, (ALIGN_TYPE) queue_ptr, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

91
common_modules/module_lib/src/txm_queue_performance_info_get.c Normal file
View File

@@ -0,0 +1,91 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_queue_performance_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves performance information from the specified */
/* queue. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* messages_sent Destination for messages sent */
/* messages_received Destination for messages received */
/* empty_suspensions Destination for number of empty */
/* queue suspensions */
/* full_suspensions Destination for number of full */
/* queue suspensions */
/* full_errors Destination for queue full errors */
/* returned - no suspension */
/* timeouts Destination for number of timeouts*/
/* on this queue */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[5];
extra_parameters[0] = (ALIGN_TYPE) messages_received;
extra_parameters[1] = (ALIGN_TYPE) empty_suspensions;
extra_parameters[2] = (ALIGN_TYPE) full_suspensions;
extra_parameters[3] = (ALIGN_TYPE) full_errors;
extra_parameters[4] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_PERFORMANCE_INFO_GET_CALL, (ALIGN_TYPE) queue_ptr, (ALIGN_TYPE) messages_sent, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

90
common_modules/module_lib/src/txm_queue_performance_system_info_get.c Normal file
View File

@@ -0,0 +1,90 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_queue_performance_system_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves queue system performance information. */
/* */
/* INPUT */
/* */
/* messages_sent Destination for total messages */
/* sent */
/* messages_received Destination for total messages */
/* received */
/* empty_suspensions Destination for total empty */
/* queue suspensions */
/* full_suspensions Destination for total full */
/* queue suspensions */
/* full_errors Destination for total queue full */
/* errors returned - no suspension */
/* timeouts Destination for total number of */
/* timeouts */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[4];
extra_parameters[0] = (ALIGN_TYPE) empty_suspensions;
extra_parameters[1] = (ALIGN_TYPE) full_suspensions;
extra_parameters[2] = (ALIGN_TYPE) full_errors;
extra_parameters[3] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_CALL, (ALIGN_TYPE) messages_sent, (ALIGN_TYPE) messages_received, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

73
common_modules/module_lib/src/txm_queue_prioritize.c Normal file
View File

@@ -0,0 +1,73 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_prioritize PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue prioritize call. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_queue_prioritize(TX_QUEUE *queue_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_PRIORITIZE_CALL, (ALIGN_TYPE) queue_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

80
common_modules/module_lib/src/txm_queue_receive.c Normal file
View File

@@ -0,0 +1,80 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_receive PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue receive function call. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* destination_ptr Pointer to message destination */
/* **** MUST BE LARGE ENOUGH TO */
/* HOLD MESSAGE **** */
/* wait_option Suspension option */
/* */
/* OUTPUT */
/* */
/* TX_QUEUE_ERROR Invalid queue pointer */
/* TX_PTR_ERROR Invalid destination pointer (NULL)*/
/* TX_WAIT_ERROR Invalid wait option */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_queue_receive(TX_QUEUE *queue_ptr, VOID *destination_ptr, ULONG wait_option)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_RECEIVE_CALL, (ALIGN_TYPE) queue_ptr, (ALIGN_TYPE) destination_ptr, (ALIGN_TYPE) wait_option);
/* Return value to the caller. */
return(return_value);
}

78
common_modules/module_lib/src/txm_queue_send.c Normal file
View File

@@ -0,0 +1,78 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_send PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue send function call. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block */
/* source_ptr Pointer to message source */
/* wait_option Suspension option */
/* */
/* OUTPUT */
/* */
/* TX_QUEUE_ERROR Invalid queue pointer */
/* TX_PTR_ERROR Invalid source pointer - NULL */
/* TX_WAIT_ERROR Invalid wait option */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_queue_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_SEND_CALL, (ALIGN_TYPE) queue_ptr, (ALIGN_TYPE) source_ptr, (ALIGN_TYPE) wait_option);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_queue_send_notify.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_queue_send_notify PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the queue send notify */
/* callback function call. */
/* */
/* INPUT */
/* */
/* queue_ptr Pointer to queue control block*/
/* queue_send_notify Application callback function */
/* (TX_NULL disables notify) */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_queue_send_notify(TX_QUEUE *queue_ptr, VOID (*queue_send_notify)(TX_QUEUE *notify_queue_ptr))
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_QUEUE_SEND_NOTIFY_CALL, (ALIGN_TYPE) queue_ptr, (ALIGN_TYPE) queue_send_notify, 0);
/* Return value to the caller. */
return(return_value);
}

77
common_modules/module_lib/src/txm_semaphore_ceiling_put.c Normal file
View File

@@ -0,0 +1,77 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_semaphore_ceiling_put PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the semaphore ceiling put */
/* function call. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore */
/* ceiling Maximum value of semaphore */
/* */
/* OUTPUT */
/* */
/* TX_SEMAPHORE_ERROR Invalid semaphore pointer */
/* TX_INVALID_CEILING Invalid semaphore ceiling */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_semaphore_ceiling_put(TX_SEMAPHORE *semaphore_ptr, ULONG ceiling)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_CEILING_PUT_CALL, (ALIGN_TYPE) semaphore_ptr, (ALIGN_TYPE) ceiling, 0);
/* Return value to the caller. */
return(return_value);
}

83
common_modules/module_lib/src/txm_semaphore_create.c Normal file
View File

@@ -0,0 +1,83 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_semaphore_create PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the create semaphore function */
/* call. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore control block*/
/* name_ptr Pointer to semaphore name */
/* initial_count Initial semaphore count */
/* semaphore_control_block_size Size of semaphore control block */
/* */
/* OUTPUT */
/* */
/* TX_SEMAPHORE_ERROR Invalid semaphore pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_semaphore_create(TX_SEMAPHORE *semaphore_ptr, CHAR *name_ptr, ULONG initial_count, UINT semaphore_control_block_size)
{
UINT return_value;
ALIGN_TYPE extra_parameters[2];
extra_parameters[0] = (ALIGN_TYPE) initial_count;
extra_parameters[1] = (ALIGN_TYPE) semaphore_control_block_size;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_CREATE_CALL, (ALIGN_TYPE) semaphore_ptr, (ALIGN_TYPE) name_ptr, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_semaphore_delete.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_semaphore_delete PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the semaphore delete function */
/* call. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore control block*/
/* */
/* OUTPUT */
/* */
/* TX_SEMAPHORE_ERROR Invalid semaphore pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_semaphore_delete(TX_SEMAPHORE *semaphore_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_DELETE_CALL, (ALIGN_TYPE) semaphore_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_semaphore_get.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_semaphore_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the semaphore get function call. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore control block*/
/* wait_option Suspension option */
/* */
/* OUTPUT */
/* */
/* TX_SEMAPHORE_ERROR Invalid semaphore pointer */
/* TX_WAIT_ERROR Invalid wait option */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_GET_CALL, (ALIGN_TYPE) semaphore_ptr, (ALIGN_TYPE) wait_option, 0);
/* Return value to the caller. */
return(return_value);
}

89
common_modules/module_lib/src/txm_semaphore_info_get.c Normal file
View File

@@ -0,0 +1,89 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_semaphore_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the semaphore information get */
/* service. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore control block*/
/* name Destination for the semaphore name*/
/* current_value Destination for current value of */
/* the semaphore */
/* first_suspended Destination for pointer of first */
/* thread suspended on semaphore */
/* suspended_count Destination for suspended count */
/* next_semaphore Destination for pointer to next */
/* semaphore on the created list */
/* */
/* OUTPUT */
/* */
/* TX_SEMAPHORE_ERROR Invalid semaphore pointer */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[4];
extra_parameters[0] = (ALIGN_TYPE) current_value;
extra_parameters[1] = (ALIGN_TYPE) first_suspended;
extra_parameters[2] = (ALIGN_TYPE) suspended_count;
extra_parameters[3] = (ALIGN_TYPE) next_semaphore;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_INFO_GET_CALL, (ALIGN_TYPE) semaphore_ptr, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

87
common_modules/module_lib/src/txm_semaphore_performance_info_get.c Normal file
View File

@@ -0,0 +1,87 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_semaphore_performance_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves performance information from the specified */
/* semaphore. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore control block*/
/* puts Destination for the number of */
/* puts on to this semaphore */
/* gets Destination for the number of */
/* gets on this semaphore */
/* suspensions Destination for the number of */
/* suspensions on this semaphore */
/* timeouts Destination for number of timeouts*/
/* on this semaphore */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_semaphore_performance_info_get(TX_SEMAPHORE *semaphore_ptr, ULONG *puts, ULONG *gets, ULONG *suspensions, ULONG *timeouts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[3];
extra_parameters[0] = (ALIGN_TYPE) gets;
extra_parameters[1] = (ALIGN_TYPE) suspensions;
extra_parameters[2] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_PERFORMANCE_INFO_GET_CALL, (ALIGN_TYPE) semaphore_ptr, (ALIGN_TYPE) puts, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

84
common_modules/module_lib/src/txm_semaphore_performance_system_info_get.c Normal file
View File

@@ -0,0 +1,84 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_semaphore_performance_system_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves system semaphore performance information. */
/* */
/* INPUT */
/* */
/* puts Destination for total number of */
/* semaphore puts */
/* gets Destination for total number of */
/* semaphore gets */
/* suspensions Destination for total number of */
/* semaphore suspensions */
/* timeouts Destination for total number of */
/* timeouts */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_semaphore_performance_system_info_get(ULONG *puts, ULONG *gets, ULONG *suspensions, ULONG *timeouts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[2];
extra_parameters[0] = (ALIGN_TYPE) suspensions;
extra_parameters[1] = (ALIGN_TYPE) timeouts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_CALL, (ALIGN_TYPE) puts, (ALIGN_TYPE) gets, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

73
common_modules/module_lib/src/txm_semaphore_prioritize.c Normal file
View File

@@ -0,0 +1,73 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_semaphore_prioritize PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the semaphore prioritize call. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore control block*/
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_semaphore_prioritize(TX_SEMAPHORE *semaphore_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_PRIORITIZE_CALL, (ALIGN_TYPE) semaphore_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_semaphore_put.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_semaphore_put PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the semaphore put function call. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore control block*/
/* */
/* OUTPUT */
/* */
/* TX_SEMAPHORE_ERROR Invalid semaphore pointer */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_semaphore_put(TX_SEMAPHORE *semaphore_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_PUT_CALL, (ALIGN_TYPE) semaphore_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_semaphore_put_notify.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_semaphore_put_notify PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the semaphore put notify */
/* callback function call. */
/* */
/* INPUT */
/* */
/* semaphore_ptr Pointer to semaphore */
/* semaphore_put_notify Application callback function */
/* (TX_NULL disables notify) */
/* */
/* OUTPUT */
/* */
/* status Service return status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_semaphore_put_notify(TX_SEMAPHORE *semaphore_ptr, VOID (*semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr))
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_SEMAPHORE_PUT_NOTIFY_CALL, (ALIGN_TYPE) semaphore_ptr, (ALIGN_TYPE) semaphore_put_notify, 0);
/* Return value to the caller. */
return(return_value);
}

100
common_modules/module_lib/src/txm_thread_create.c Normal file
View File

@@ -0,0 +1,100 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_create PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the thread create function call. */
/* */
/* INPUT */
/* */
/* thread_ptr Thread control block pointer */
/* name Pointer to thread name string */
/* entry_function Entry function of the thread */
/* entry_input 32-bit input value to thread */
/* stack_start Pointer to start of stack */
/* stack_size Stack size in bytes */
/* priority Priority of thread (0-31) */
/* preempt_threshold Preemption threshold */
/* time_slice Thread time-slice value */
/* auto_start Automatic start selection */
/* thread_control_block_size Size of thread control block */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* TX_PTR_ERROR Invalid entry point or stack */
/* address */
/* TX_SIZE_ERROR Invalid stack size -too small */
/* TX_PRIORITY_ERROR Invalid thread priority */
/* TX_THRESH_ERROR Invalid preemption threshold */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[9];
extra_parameters[0] = (ALIGN_TYPE) entry_function;
extra_parameters[1] = (ALIGN_TYPE) entry_input;
extra_parameters[2] = (ALIGN_TYPE) stack_start;
extra_parameters[3] = (ALIGN_TYPE) stack_size;
extra_parameters[4] = (ALIGN_TYPE) priority;
extra_parameters[5] = (ALIGN_TYPE) preempt_threshold;
extra_parameters[6] = (ALIGN_TYPE) time_slice;
extra_parameters[7] = (ALIGN_TYPE) auto_start;
extra_parameters[8] = (ALIGN_TYPE) thread_control_block_size;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_CREATE_CALL, (ALIGN_TYPE) thread_ptr, (ALIGN_TYPE) name_ptr, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

75
common_modules/module_lib/src/txm_thread_delete.c Normal file
View File

@@ -0,0 +1,75 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_delete PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the thread delete function call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread to suspend */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* TX_CALLER_ERROR Invalid caller of function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_delete(TX_THREAD *thread_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_DELETE_CALL, (ALIGN_TYPE) thread_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_thread_entry_exit_notify.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_entry_exit_notify PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the thread entry/exit notify */
/* callback function call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread */
/* thread_entry_exit_notify Pointer to notify callback */
/* function, TX_NULL to disable*/
/* */
/* OUTPUT */
/* */
/* status Service return status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_entry_exit_notify(TX_THREAD *thread_ptr, VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type))
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_ENTRY_EXIT_NOTIFY_CALL, (ALIGN_TYPE) thread_ptr, (ALIGN_TYPE) thread_entry_exit_notify, 0);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_thread_identify.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_thread_identify PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function returns the control block pointer of the currently */
/* executing thread. If the return value is NULL, no thread is */
/* executing. */
/* */
/* INPUT */
/* */
/* None */
/* */
/* OUTPUT */
/* */
/* TX_THREAD * Pointer to control block of */
/* currently executing thread */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
TX_THREAD *_tx_thread_identify(VOID)
{
TX_THREAD *return_value;
/* Call module manager dispatcher. */
return_value = (TX_THREAD *) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_IDENTIFY_CALL, 0, 0, 0);
/* Return value to the caller. */
return(return_value);
}

95
common_modules/module_lib/src/txm_thread_info_get.c Normal file
View File

@@ -0,0 +1,95 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the thread information get */
/* service. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread control block */
/* name Destination for the thread name */
/* state Destination for thread state */
/* run_count Destination for thread run count */
/* priority Destination for thread priority */
/* preemption_threshold Destination for thread preemption-*/
/* threshold */
/* time_slice Destination for thread time-slice */
/* next_thread Destination for next created */
/* thread */
/* next_suspended_thread Destination for next suspended */
/* thread */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[7];
extra_parameters[0] = (ALIGN_TYPE) state;
extra_parameters[1] = (ALIGN_TYPE) run_count;
extra_parameters[2] = (ALIGN_TYPE) priority;
extra_parameters[3] = (ALIGN_TYPE) preemption_threshold;
extra_parameters[4] = (ALIGN_TYPE) time_slice;
extra_parameters[5] = (ALIGN_TYPE) next_thread;
extra_parameters[6] = (ALIGN_TYPE) next_suspended_thread;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_INFO_GET_CALL, (ALIGN_TYPE) thread_ptr, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_thread_interrupt_control.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_thread_interrupt_control PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function is responsible for changing the interrupt lockout */
/* posture of the system. */
/* */
/* INPUT */
/* */
/* new_posture New interrupt lockout posture */
/* */
/* OUTPUT */
/* */
/* status | old_posture Return status if feature not */
/* enabled, old interrupt lockout */
/* posture if feature enabled. */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_thread_interrupt_control(UINT new_posture)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_INTERRUPT_CONTROL_CALL, (ALIGN_TYPE) new_posture, 0, 0);
/* Return value to the caller. */
return(return_value);
}

110
common_modules/module_lib/src/txm_thread_performance_info_get.c Normal file
View File

@@ -0,0 +1,110 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_thread_performance_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves performance information from the specified */
/* thread. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread control block */
/* resumptions Destination for number of times */
/* thread was resumed */
/* suspensions Destination for number of times */
/* thread was suspended */
/* solicited_preemptions Destination for number of times */
/* thread called another service */
/* that resulted in preemption */
/* interrupt_preemptions Destination for number of times */
/* thread was preempted by another */
/* thread made ready in Interrupt */
/* Service Routine (ISR) */
/* priority_inversions Destination for number of times */
/* a priority inversion was */
/* detected for this thread */
/* time_slices Destination for number of times */
/* thread was time-sliced */
/* relinquishes Destination for number of thread */
/* relinquishes */
/* timeouts Destination for number of timeouts*/
/* for thread */
/* wait_aborts Destination for number of wait */
/* aborts for thread */
/* last_preempted_by Destination for pointer of the */
/* thread that last preempted this */
/* thread */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[9];
extra_parameters[0] = (ALIGN_TYPE) suspensions;
extra_parameters[1] = (ALIGN_TYPE) solicited_preemptions;
extra_parameters[2] = (ALIGN_TYPE) interrupt_preemptions;
extra_parameters[3] = (ALIGN_TYPE) priority_inversions;
extra_parameters[4] = (ALIGN_TYPE) time_slices;
extra_parameters[5] = (ALIGN_TYPE) relinquishes;
extra_parameters[6] = (ALIGN_TYPE) timeouts;
extra_parameters[7] = (ALIGN_TYPE) wait_aborts;
extra_parameters[8] = (ALIGN_TYPE) last_preempted_by;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_PERFORMANCE_INFO_GET_CALL, (ALIGN_TYPE) thread_ptr, (ALIGN_TYPE) resumptions, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

110
common_modules/module_lib/src/txm_thread_performance_system_info_get.c Normal file
View File

@@ -0,0 +1,110 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_thread_performance_system_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves thread system performance information. */
/* */
/* INPUT */
/* */
/* resumptions Destination for total number of */
/* thread resumptions */
/* suspensions Destination for total number of */
/* thread suspensions */
/* solicited_preemptions Destination for total number of */
/* thread preemption from thread */
/* API calls */
/* interrupt_preemptions Destination for total number of */
/* thread preemptions as a result */
/* of threads made ready inside of */
/* Interrupt Service Routines */
/* priority_inversions Destination for total number of */
/* priority inversions */
/* time_slices Destination for total number of */
/* time-slices */
/* relinquishes Destination for total number of */
/* relinquishes */
/* timeouts Destination for total number of */
/* timeouts */
/* wait_aborts Destination for total number of */
/* wait aborts */
/* non_idle_returns Destination for total number of */
/* times threads return when */
/* another thread is ready */
/* idle_returns Destination for total number of */
/* times threads return when no */
/* other thread is ready */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[9];
extra_parameters[0] = (ALIGN_TYPE) solicited_preemptions;
extra_parameters[1] = (ALIGN_TYPE) interrupt_preemptions;
extra_parameters[2] = (ALIGN_TYPE) priority_inversions;
extra_parameters[3] = (ALIGN_TYPE) time_slices;
extra_parameters[4] = (ALIGN_TYPE) relinquishes;
extra_parameters[5] = (ALIGN_TYPE) timeouts;
extra_parameters[6] = (ALIGN_TYPE) wait_aborts;
extra_parameters[7] = (ALIGN_TYPE) non_idle_returns;
extra_parameters[8] = (ALIGN_TYPE) idle_returns;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_PERFORMANCE_SYSTEM_INFO_GET_CALL, (ALIGN_TYPE) resumptions, (ALIGN_TYPE) suspensions, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

79
common_modules/module_lib/src/txm_thread_preemption_change.c Normal file
View File

@@ -0,0 +1,79 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_preemption_change PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the preemption threshold change */
/* function call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread */
/* new_threshold New preemption threshold */
/* old_threshold Old preemption threshold */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* TX_PTR_ERROR Invalid old threshold pointer */
/* TX_CALLER_ERROR Invalid caller of function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_preemption_change(TX_THREAD *thread_ptr, UINT new_threshold, UINT *old_threshold)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_PREEMPTION_CHANGE_CALL, (ALIGN_TYPE) thread_ptr, (ALIGN_TYPE) new_threshold, (ALIGN_TYPE) old_threshold);
/* Return value to the caller. */
return(return_value);
}

79
common_modules/module_lib/src/txm_thread_priority_change.c Normal file
View File

@@ -0,0 +1,79 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_priority_change PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the change priority function */
/* call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread to suspend */
/* new_priority New thread priority */
/* old_priority Old thread priority */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* TX_PTR_ERROR Invalid old priority pointer */
/* TX_CALLER_ERROR Invalid caller of function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_priority_change(TX_THREAD *thread_ptr, UINT new_priority, UINT *old_priority)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_PRIORITY_CHANGE_CALL, (ALIGN_TYPE) thread_ptr, (ALIGN_TYPE) new_priority, (ALIGN_TYPE) old_priority);
/* Return value to the caller. */
return(return_value);
}

70
common_modules/module_lib/src/txm_thread_relinquish.c Normal file
View File

@@ -0,0 +1,70 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_relinquish PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks to make sure a thread is executing before the */
/* relinquish is executed. */
/* */
/* INPUT */
/* */
/* None */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
VOID _txe_thread_relinquish(VOID)
{
/* Call module manager dispatcher. */
(_txm_module_kernel_call_dispatcher)(TXM_THREAD_RELINQUISH_CALL, 0, 0, 0);
}

75
common_modules/module_lib/src/txm_thread_reset.c Normal file
View File

@@ -0,0 +1,75 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_reset PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the thread reset function call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread to reset */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* TX_CALLER_ERROR Invalid caller of function */
/* status Service return status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_reset(TX_THREAD *thread_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_RESET_CALL, (ALIGN_TYPE) thread_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_thread_resume.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_resume PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the resume thread function call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread to resume */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_resume(TX_THREAD *thread_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_RESUME_CALL, (ALIGN_TYPE) thread_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_thread_sleep.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_thread_sleep PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function handles application thread sleep requests. If the */
/* sleep request was called from a non-thread, an error is returned. */
/* */
/* INPUT */
/* */
/* timer_ticks Number of timer ticks to sleep*/
/* */
/* OUTPUT */
/* */
/* status Return completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_thread_sleep(ULONG timer_ticks)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_SLEEP_CALL, (ALIGN_TYPE) timer_ticks, 0, 0);
/* Return value to the caller. */
return(return_value);
}

78
common_modules/module_lib/src/txm_thread_stack_error_notify.c Normal file
View File

@@ -0,0 +1,78 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_thread_stack_error_notify PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function registers an application stack error handler. If */
/* ThreadX detects a stack error, this application handler is called. */
/* */
/* Note: stack checking must be enabled for this routine to serve any */
/* purpose via the TX_ENABLE_STACK_CHECKING define. */
/* */
/* INPUT */
/* */
/* stack_error_handler Pointer to stack error */
/* handler, TX_NULL to disable */
/* */
/* OUTPUT */
/* */
/* status Service return status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_thread_stack_error_notify(VOID (*stack_error_handler)(TX_THREAD *thread_ptr))
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_STACK_ERROR_NOTIFY_CALL, (ALIGN_TYPE) stack_error_handler, 0, 0);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_thread_suspend.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_suspend PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the thread suspend function */
/* call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread to suspend */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* TX_CALLER_ERROR Invalid caller of function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_suspend(TX_THREAD *thread_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_SUSPEND_CALL, (ALIGN_TYPE) thread_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_thread_terminate.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_terminate PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the thread terminate function */
/* call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread to suspend */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* TX_CALLER_ERROR Invalid caller of function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_terminate(TX_THREAD *thread_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_TERMINATE_CALL, (ALIGN_TYPE) thread_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

78
common_modules/module_lib/src/txm_thread_time_slice_change.c Normal file
View File

@@ -0,0 +1,78 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_time_slice_change PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the time slice change function */
/* call. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread */
/* new_time_slice New time slice */
/* old_time_slice Old time slice */
/* */
/* OUTPUT */
/* */
/* TX_THREAD_ERROR Invalid thread pointer */
/* TX_CALLER_ERROR Invalid caller of function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_time_slice_change(TX_THREAD *thread_ptr, ULONG new_time_slice, ULONG *old_time_slice)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_TIME_SLICE_CHANGE_CALL, (ALIGN_TYPE) thread_ptr, (ALIGN_TYPE) new_time_slice, (ALIGN_TYPE) old_time_slice);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_thread_wait_abort.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_thread_wait_abort PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the thread wait abort function */
/* call. */
/* */
/* INPUT */
/* */
/* thread_ptr Thread to abort the wait on */
/* */
/* OUTPUT */
/* */
/* status Return completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_thread_wait_abort(TX_THREAD *thread_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_THREAD_WAIT_ABORT_CALL, (ALIGN_TYPE) thread_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_time_get.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_time_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves the internal, free-running, system clock */
/* and returns it to the caller. */
/* */
/* INPUT */
/* */
/* None */
/* */
/* OUTPUT */
/* */
/* _tx_timer_system_clock Returns the system clock value */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
ULONG _tx_time_get(VOID)
{
ULONG return_value;
/* Call module manager dispatcher. */
return_value = (ULONG) (_txm_module_kernel_call_dispatcher)(TXM_TIME_GET_CALL, 0, 0, 0);
/* Return value to the caller. */
return(return_value);
}

70
common_modules/module_lib/src/txm_time_set.c Normal file
View File

@@ -0,0 +1,70 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_time_set PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function modifies the internal, free-running, system clock */
/* as specified by the caller. */
/* */
/* INPUT */
/* */
/* new_time New time value */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
VOID _tx_time_set(ULONG new_time)
{
/* Call module manager dispatcher. */
(_txm_module_kernel_call_dispatcher)(TXM_TIME_SET_CALL, (ALIGN_TYPE) new_time, 0, 0);
}

76
common_modules/module_lib/src/txm_timer_activate.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_timer_activate PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the activate application timer */
/* function call. */
/* */
/* INPUT */
/* */
/* timer_ptr Pointer to timer control block */
/* */
/* OUTPUT */
/* */
/* TX_TIMER_ERROR Invalid application timer */
/* TX_ACTIVATE_ERROR Application timer already active */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_timer_activate(TX_TIMER *timer_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TIMER_ACTIVATE_CALL, (ALIGN_TYPE) timer_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

79
common_modules/module_lib/src/txm_timer_change.c Normal file
View File

@@ -0,0 +1,79 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_timer_change PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the application timer change */
/* function call. */
/* */
/* INPUT */
/* */
/* timer_ptr Pointer to timer control block */
/* initial_ticks Initial expiration ticks */
/* reschedule_ticks Reschedule ticks */
/* */
/* OUTPUT */
/* */
/* TX_TIMER_ERROR Invalid application timer pointer */
/* TX_TICK_ERROR Invalid initial tick value of 0 */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_timer_change(TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TIMER_CHANGE_CALL, (ALIGN_TYPE) timer_ptr, (ALIGN_TYPE) initial_ticks, (ALIGN_TYPE) reschedule_ticks);
/* Return value to the caller. */
return(return_value);
}

92
common_modules/module_lib/src/txm_timer_create.c Normal file
View File

@@ -0,0 +1,92 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_timer_create PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the create application timer */
/* function call. */
/* */
/* INPUT */
/* */
/* timer_ptr Pointer to timer control block */
/* name_ptr Pointer to timer name */
/* expiration_function Application expiration function */
/* initial_ticks Initial expiration ticks */
/* reschedule_ticks Reschedule ticks */
/* auto_activate Automatic activation flag */
/* timer_control_block_size Size of timer control block */
/* */
/* OUTPUT */
/* */
/* TX_TIMER_ERROR Invalid timer control block */
/* TX_TICK_ERROR Invalid initial expiration count */
/* TX_ACTIVATE_ERROR Invalid timer activation option */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr, VOID (*expiration_function)(ULONG), ULONG expiration_input, ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate, UINT timer_control_block_size)
{
UINT return_value;
ALIGN_TYPE extra_parameters[6];
extra_parameters[0] = (ALIGN_TYPE) expiration_function;
extra_parameters[1] = (ALIGN_TYPE) expiration_input;
extra_parameters[2] = (ALIGN_TYPE) initial_ticks;
extra_parameters[3] = (ALIGN_TYPE) reschedule_ticks;
extra_parameters[4] = (ALIGN_TYPE) auto_activate;
extra_parameters[5] = (ALIGN_TYPE) timer_control_block_size;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TIMER_CREATE_CALL, (ALIGN_TYPE) timer_ptr, (ALIGN_TYPE) name_ptr, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

75
common_modules/module_lib/src/txm_timer_deactivate.c Normal file
View File

@@ -0,0 +1,75 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_timer_deactivate PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the deactivate application timer */
/* function call. */
/* */
/* INPUT */
/* */
/* timer_ptr Pointer to timer control block */
/* */
/* OUTPUT */
/* */
/* TX_TIMER_ERROR Invalid application timer pointer */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_timer_deactivate(TX_TIMER *timer_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TIMER_DEACTIVATE_CALL, (ALIGN_TYPE) timer_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

76
common_modules/module_lib/src/txm_timer_delete.c Normal file
View File

@@ -0,0 +1,76 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_timer_delete PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the delete application timer */
/* function call. */
/* */
/* INPUT */
/* */
/* timer_ptr Pointer to timer control block */
/* */
/* OUTPUT */
/* */
/* TX_TIMER_ERROR Invalid application timer pointer */
/* TX_CALLER_ERROR Invalid caller of this function */
/* status Actual completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_timer_delete(TX_TIMER *timer_ptr)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TIMER_DELETE_CALL, (ALIGN_TYPE) timer_ptr, 0, 0);
/* Return value to the caller. */
return(return_value);
}

88
common_modules/module_lib/src/txm_timer_info_get.c Normal file
View File

@@ -0,0 +1,88 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _txe_timer_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function checks for errors in the timer information get */
/* service. */
/* */
/* INPUT */
/* */
/* timer_ptr Pointer to timer control block */
/* name Destination for the timer name */
/* active Destination for active flag */
/* remaining_ticks Destination for remaining ticks */
/* before expiration */
/* reschedule_ticks Destination for reschedule ticks */
/* next_timer Destination for next timer on the */
/* created list */
/* */
/* OUTPUT */
/* */
/* TX_TIMER_ERROR Invalid timer pointer */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _txe_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks, ULONG *reschedule_ticks, TX_TIMER **next_timer)
{
UINT return_value;
ALIGN_TYPE extra_parameters[4];
extra_parameters[0] = (ALIGN_TYPE) active;
extra_parameters[1] = (ALIGN_TYPE) remaining_ticks;
extra_parameters[2] = (ALIGN_TYPE) reschedule_ticks;
extra_parameters[3] = (ALIGN_TYPE) next_timer;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TIMER_INFO_GET_CALL, (ALIGN_TYPE) timer_ptr, (ALIGN_TYPE) name, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

91
common_modules/module_lib/src/txm_timer_performance_info_get.c Normal file
View File

@@ -0,0 +1,91 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_timer_performance_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves performance information from the specified */
/* timer. */
/* */
/* INPUT */
/* */
/* timer_ptr Pointer to timer control block */
/* activates Destination for the number of */
/* activations of this timer */
/* reactivates Destination for the number of */
/* reactivations of this timer */
/* deactivates Destination for the number of */
/* deactivations of this timer */
/* expirations Destination for the number of */
/* expirations of this timer */
/* expiration_adjusts Destination for the number of */
/* expiration adjustments of this */
/* timer */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_timer_performance_info_get(TX_TIMER *timer_ptr, ULONG *activates, ULONG *reactivates, ULONG *deactivates, ULONG *expirations, ULONG *expiration_adjusts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[4];
extra_parameters[0] = (ALIGN_TYPE) reactivates;
extra_parameters[1] = (ALIGN_TYPE) deactivates;
extra_parameters[2] = (ALIGN_TYPE) expirations;
extra_parameters[3] = (ALIGN_TYPE) expiration_adjusts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TIMER_PERFORMANCE_INFO_GET_CALL, (ALIGN_TYPE) timer_ptr, (ALIGN_TYPE) activates, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

87
common_modules/module_lib/src/txm_timer_performance_system_info_get.c Normal file
View File

@@ -0,0 +1,87 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_timer_performance_system_info_get PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function retrieves timer performance information. */
/* */
/* INPUT */
/* */
/* activates Destination for total number of */
/* activations */
/* reactivates Destination for total number of */
/* reactivations */
/* deactivates Destination for total number of */
/* deactivations */
/* expirations Destination for total number of */
/* expirations */
/* expiration_adjusts Destination for total number of */
/* expiration adjustments */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_timer_performance_system_info_get(ULONG *activates, ULONG *reactivates, ULONG *deactivates, ULONG *expirations, ULONG *expiration_adjusts)
{
UINT return_value;
ALIGN_TYPE extra_parameters[3];
extra_parameters[0] = (ALIGN_TYPE) deactivates;
extra_parameters[1] = (ALIGN_TYPE) expirations;
extra_parameters[2] = (ALIGN_TYPE) expiration_adjusts;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TIMER_PERFORMANCE_SYSTEM_INFO_GET_CALL, (ALIGN_TYPE) activates, (ALIGN_TYPE) reactivates, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

77
common_modules/module_lib/src/txm_trace_buffer_full_notify.c Normal file
View File

@@ -0,0 +1,77 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_buffer_full_notify PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function sets up the application callback function that is */
/* called whenever the trace buffer becomes full. The application */
/* can then swap to a new trace buffer in order not to lose any */
/* events. */
/* */
/* INPUT */
/* */
/* full_buffer_callback Full trace buffer processing */
/* function */
/* */
/* OUTPUT */
/* */
/* Completion Status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_trace_buffer_full_notify(VOID (*full_buffer_callback)(VOID *buffer))
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TRACE_BUFFER_FULL_NOTIFY_CALL, (ALIGN_TYPE) full_buffer_callback, 0, 0);
/* Return value to the caller. */
return(return_value);
}

73
common_modules/module_lib/src/txm_trace_disable.c Normal file
View File

@@ -0,0 +1,73 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_disable PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function disables trace inside of ThreadX. */
/* */
/* INPUT */
/* */
/* None */
/* */
/* OUTPUT */
/* */
/* Completion Status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_trace_disable(VOID)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TRACE_DISABLE_CALL, 0, 0, 0);
/* Return value to the caller. */
return(return_value);
}

77
common_modules/module_lib/src/txm_trace_enable.c Normal file
View File

@@ -0,0 +1,77 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_enable PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function initializes the ThreadX trace buffer and the */
/* associated control variables, enabling it for operation. */
/* */
/* INPUT */
/* */
/* trace_buffer_start Start of trace buffer */
/* trace_buffer_size Size (bytes) of trace buffer */
/* registry_entries Number of object registry */
/* entries. */
/* */
/* OUTPUT */
/* */
/* Completion Status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_trace_enable(VOID *trace_buffer_start, ULONG trace_buffer_size, ULONG registry_entries)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TRACE_ENABLE_CALL, (ALIGN_TYPE) trace_buffer_start, (ALIGN_TYPE) trace_buffer_size, (ALIGN_TYPE) registry_entries);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_trace_event_filter.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_event_filter PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function sets up the event filter, which allows the */
/* application to filter various trace events during run-time. */
/* */
/* INPUT */
/* */
/* event_filter_bits Trace filter event bit(s) */
/* */
/* OUTPUT */
/* */
/* Completion Status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_trace_event_filter(ULONG event_filter_bits)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TRACE_EVENT_FILTER_CALL, (ALIGN_TYPE) event_filter_bits, 0, 0);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_trace_event_unfilter.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_event_unfilter PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function removes the event filter, which allows the */
/* application to un-filter various trace events during run-time. */
/* */
/* INPUT */
/* */
/* event_unfilter_bits Trace un-filter event bit(s) */
/* */
/* OUTPUT */
/* */
/* Completion Status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_trace_event_unfilter(ULONG event_unfilter_bits)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TRACE_EVENT_UNFILTER_CALL, (ALIGN_TYPE) event_unfilter_bits, 0, 0);
/* Return value to the caller. */
return(return_value);
}

74
common_modules/module_lib/src/txm_trace_interrupt_control.c Normal file
View File

@@ -0,0 +1,74 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_interrupt_control PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function provides a shell for the tx_interrupt_control */
/* function so that a trace event can be logged for its use. */
/* */
/* INPUT */
/* */
/* new_posture New interrupt posture */
/* */
/* OUTPUT */
/* */
/* Previous Interrupt Posture */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
UINT _tx_trace_interrupt_control(UINT new_posture)
{
UINT return_value;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TRACE_INTERRUPT_CONTROL_CALL, (ALIGN_TYPE) new_posture, 0, 0);
/* Return value to the caller. */
return(return_value);
}

70
common_modules/module_lib/src/txm_trace_isr_enter_insert.c Normal file
View File

@@ -0,0 +1,70 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_isr_enter_insert PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function provides inserts an ISR entry event into the trace */
/* buffer. */
/* */
/* INPUT */
/* */
/* isr_id User defined ISR ID */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
VOID _tx_trace_isr_enter_insert(ULONG isr_id)
{
/* Call module manager dispatcher. */
(_txm_module_kernel_call_dispatcher)(TXM_TRACE_ISR_ENTER_INSERT_CALL, (ALIGN_TYPE) isr_id, 0, 0);
}

70
common_modules/module_lib/src/txm_trace_isr_exit_insert.c Normal file
View File

@@ -0,0 +1,70 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_isr_exit_insert PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function provides inserts an ISR exit event into the trace */
/* buffer. */
/* */
/* INPUT */
/* */
/* isr_id User defined ISR ID */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
VOID _tx_trace_isr_exit_insert(ULONG isr_id)
{
/* Call module manager dispatcher. */
(_txm_module_kernel_call_dispatcher)(TXM_TRACE_ISR_EXIT_INSERT_CALL, (ALIGN_TYPE) isr_id, 0, 0);
}

82
common_modules/module_lib/src/txm_trace_user_event_insert.c Normal file
View File

@@ -0,0 +1,82 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Module */
/** */
/**************************************************************************/
/**************************************************************************/
#define TXM_MODULE
#include "txm_module.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_trace_user_event_insert PORTABLE C */
/* 6.0.1 */
/* AUTHOR */
/* */
/* Scott Larson, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function inserts a user-defined event into the trace buffer. */
/* */
/* INPUT */
/* */
/* event_id User Event ID */
/* info_field_1 First information field */
/* info_field_2 First information field */
/* info_field_3 First information field */
/* info_field_4 First information field */
/* */
/* OUTPUT */
/* */
/* Completion Status */
/* */
/* CALLS */
/* */
/* _txm_module_kernel_call_dispatcher */
/* */
/* CALLED BY */
/* */
/* Module application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 06-30-2020 Scott Larson Initial Version 6.0.1 */
/* */
/**************************************************************************/
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 return_value;
ALIGN_TYPE extra_parameters[3];
extra_parameters[0] = (ALIGN_TYPE) info_field_2;
extra_parameters[1] = (ALIGN_TYPE) info_field_3;
extra_parameters[2] = (ALIGN_TYPE) info_field_4;
/* Call module manager dispatcher. */
return_value = (UINT) (_txm_module_kernel_call_dispatcher)(TXM_TRACE_USER_EVENT_INSERT_CALL, (ALIGN_TYPE) event_id, (ALIGN_TYPE) info_field_1, (ALIGN_TYPE) extra_parameters);
/* Return value to the caller. */
return(return_value);
}

Some files were not shown because too many files have changed in this diff Show More