Release 6.1.6v6.1.6_rel

3 files changed, 996 insertions, 0 deletions

diff --git a/ports_module/cortex_m23/ac6/inc/tx_port.h b/ports_module/cortex_m23/ac6/inc/tx_port.h
new file mode 100644
index 00000000..f2604699
--- /dev/null
+++ b/ports_module/cortex_m23/ac6/inc/tx_port.h
@@ -0,0 +1,584 @@
+/**************************************************************************/
+/*                                                                        */
+/*       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                                                     */
+/**                                                                       */
+/**   Port Specific                                                       */
+/**                                                                       */
+/**************************************************************************/
+/**************************************************************************/
+
+
+/**************************************************************************/
+/*                                                                        */
+/*  PORT SPECIFIC C INFORMATION                            RELEASE        */
+/*                                                                        */
+/*    tx_port.h                                         Cortex-M23/AC6    */
+/*                                                            6.1.6       */
+/*                                                                        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    Scott Larson, Microsoft Corporation                                 */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
+/*    This file contains data type definitions that make the ThreadX      */
+/*    real-time kernel function identically on a variety of different     */
+/*    processor architectures.  For example, the size or number of bits   */
+/*    in an "int" data type vary between microprocessor architectures and */
+/*    even C compilers for the same microprocessor.  ThreadX does not     */
+/*    directly use native C data types.  Instead, ThreadX creates its     */
+/*    own special types that can be mapped to actual data types by this   */
+/*    file to guarantee consistency in the interface and functionality.   */
+/*                                                                        */
+/*  RELEASE HISTORY                                                       */
+/*                                                                        */
+/*    DATE              NAME                      DESCRIPTION             */
+/*                                                                        */
+/*  04-02-2021      Scott Larson            Initial Version 6.1.6         */
+/*                                                                        */
+/**************************************************************************/
+
+#ifndef TX_PORT_H
+#define TX_PORT_H
+
+/* Determine if the optional ThreadX user define file should be used.  */
+#ifdef TX_INCLUDE_USER_DEFINE_FILE
+
+/* Yes, include the user defines in tx_user.h. The defines in this file may 
+   alternately be defined on the command line.  */
+
+#include "tx_user.h"
+#endif
+
+/* Define compiler library include files.  */
+
+#include <stdlib.h>
+#include <string.h>
+#include <arm_compat.h>
+#include "ARMCM23_TZ.h"             /* For intrinsic functions. */
+
+/* Define ThreadX basic types for this port.  */
+
+#define VOID                                    void
+typedef char                                    CHAR;
+typedef unsigned char                           UCHAR;
+typedef int                                     INT;
+typedef unsigned int                            UINT;
+typedef long                                    LONG;
+typedef unsigned long                           ULONG;
+typedef unsigned long long                      ULONG64;
+typedef short                                   SHORT;
+typedef unsigned short                          USHORT;
+#define ULONG64_DEFINED
+
+/* Function prototypes for this port. */
+struct  TX_THREAD_STRUCT;
+UINT    _txe_thread_secure_stack_allocate(struct TX_THREAD_STRUCT *thread_ptr, ULONG stack_size);
+UINT    _txe_thread_secure_stack_free(struct TX_THREAD_STRUCT *thread_ptr);
+UINT    _tx_thread_secure_stack_allocate(struct TX_THREAD_STRUCT *tx_thread, ULONG stack_size);
+UINT    _tx_thread_secure_stack_free(struct TX_THREAD_STRUCT *tx_thread);
+
+/* This hardware has stack checking that we take advantage of - do NOT define. */
+#ifdef TX_ENABLE_STACK_CHECKING
+    #error "Do not define TX_ENABLE_STACK_CHECKING"
+#endif
+
+/* If user does not want to terminate thread on stack overflow, 
+   #define the TX_THREAD_NO_TERMINATE_STACK_ERROR symbol.
+   The thread will be rescheduled and continue to cause the exception.
+   It is suggested user code handle this by registering a notification with the
+   tx_thread_stack_error_notify function. */
+/*#define TX_THREAD_NO_TERMINATE_STACK_ERROR */
+
+/* Define the system API mappings based on the error checking 
+   selected by the user.  Note: this section is only applicable to 
+   application source code, hence the conditional that turns off this
+   stuff when the include file is processed by the ThreadX source. */
+
+#ifndef TX_SOURCE_CODE
+
+
+/* Determine if error checking is desired.  If so, map API functions 
+   to the appropriate error checking front-ends.  Otherwise, map API
+   functions to the core functions that actually perform the work. 
+   Note: error checking is enabled by default.  */
+
+#ifdef TX_DISABLE_ERROR_CHECKING
+
+/* Services without error checking.  */
+
+#define tx_thread_secure_stack_allocate   _tx_thread_secure_stack_allocate
+#define tx_thread_secure_stack_free       _tx_thread_secure_stack_free
+
+#else
+
+/* Services with error checking.  */
+
+#define tx_thread_secure_stack_allocate   _txe_thread_secure_stack_allocate
+#define tx_thread_secure_stack_free       _txe_thread_secure_stack_free
+
+#endif
+#endif
+
+
+
+/* Define the priority levels for ThreadX.  Legal values range
+   from 32 to 1024 and MUST be evenly divisible by 32.  */
+
+#ifndef TX_MAX_PRIORITIES
+#define TX_MAX_PRIORITIES                       32
+#endif
+
+
+/* Define the minimum stack for a ThreadX thread on this processor. If the size supplied during
+   thread creation is less than this value, the thread create call will return an error.  */
+
+#ifndef TX_MINIMUM_STACK
+#define TX_MINIMUM_STACK                        200         /* Minimum stack size for this port  */
+#endif
+
+
+/* Define the system timer thread's default stack size and priority.  These are only applicable
+   if TX_TIMER_PROCESS_IN_ISR is not defined.  */
+
+#ifndef TX_TIMER_THREAD_STACK_SIZE
+#define TX_TIMER_THREAD_STACK_SIZE              1024        /* Default timer thread stack size  */
+#endif
+
+#ifndef TX_TIMER_THREAD_PRIORITY    
+#define TX_TIMER_THREAD_PRIORITY                0           /* Default timer thread priority    */
+#endif
+
+
+/* Define various constants for the ThreadX Cortex-M23 port.  */
+
+#define TX_INT_DISABLE                          1           /* Disable interrupts               */
+#define TX_INT_ENABLE                           0           /* Enable interrupts                */
+
+
+/* Define the clock source for trace event entry time stamp. The following two item are port specific.
+   For example, if the time source is at the address 0x0a800024 and is 16-bits in size, the clock 
+   source constants would be:
+
+#define TX_TRACE_TIME_SOURCE                    *((ULONG *) 0x0a800024)
+#define TX_TRACE_TIME_MASK                      0x0000FFFFUL
+
+*/
+
+#ifndef TX_MISRA_ENABLE
+#ifndef TX_TRACE_TIME_SOURCE
+#define TX_TRACE_TIME_SOURCE                    *((ULONG *) 0xE0001004)
+#endif
+#else
+ULONG   _tx_misra_time_stamp_get(VOID);
+#define TX_TRACE_TIME_SOURCE                    _tx_misra_time_stamp_get()
+#endif
+
+#ifndef TX_TRACE_TIME_MASK
+#define TX_TRACE_TIME_MASK                      0xFFFFFFFFUL
+#endif
+
+
+/* Define the port specific options for the _tx_build_options variable. This variable indicates
+   how the ThreadX library was built.  */
+
+#define TX_PORT_SPECIFIC_BUILD_OPTIONS          (0)
+
+
+/* Define the in-line initialization constant so that modules with in-line
+   initialization capabilities can prevent their initialization from being
+   a function call.  */
+
+#ifdef TX_MISRA_ENABLE
+#define TX_DISABLE_INLINE
+#else
+#define TX_INLINE_INITIALIZATION
+#endif
+
+
+/* Determine whether or not stack checking is enabled. By default, ThreadX stack checking is 
+   disabled. When the following is defined, ThreadX thread stack checking is enabled.  If stack
+   checking is enabled (TX_ENABLE_STACK_CHECKING is defined), the TX_DISABLE_STACK_FILLING
+   define is negated, thereby forcing the stack fill which is necessary for the stack checking
+   logic.  */
+
+#ifndef TX_MISRA_ENABLE
+#ifdef TX_ENABLE_STACK_CHECKING
+#undef TX_DISABLE_STACK_FILLING
+#endif
+#endif
+
+
+/* Define the TX_THREAD control block extensions for this port. The main reason
+   for the multiple macros is so that backward compatibility can be maintained with 
+   existing ThreadX kernel awareness modules.  */
+
+#define TX_THREAD_EXTENSION_0
+#define TX_THREAD_EXTENSION_1
+#if !defined(TX_SINGLE_MODE_SECURE) && !defined(TX_SINGLE_MODE_NON_SECURE)
+#define TX_THREAD_EXTENSION_2                   VOID    *tx_thread_module_instance_ptr;         \
+                                                VOID    *tx_thread_module_entry_info_ptr;       \
+                                                ULONG   tx_thread_module_current_user_mode;     \
+                                                ULONG   tx_thread_module_user_mode;             \
+                                                ULONG   tx_thread_module_saved_lr;              \
+                                                VOID    *tx_thread_module_kernel_stack_start;   \
+                                                VOID    *tx_thread_module_kernel_stack_end;     \
+                                                ULONG   tx_thread_module_kernel_stack_size;     \
+                                                VOID    *tx_thread_module_stack_ptr;            \
+                                                VOID    *tx_thread_module_stack_start;          \
+                                                VOID    *tx_thread_module_stack_end;            \
+                                                ULONG   tx_thread_module_stack_size;            \
+                                                VOID    *tx_thread_module_reserved;             \
+                                                VOID   *tx_thread_secure_stack_context;
+#else
+#define TX_THREAD_EXTENSION_2                   VOID    *tx_thread_module_instance_ptr;         \
+                                                VOID    *tx_thread_module_entry_info_ptr;       \
+                                                ULONG   tx_thread_module_current_user_mode;     \
+                                                ULONG   tx_thread_module_user_mode;             \
+                                                ULONG   tx_thread_module_saved_lr;              \
+                                                VOID    *tx_thread_module_kernel_stack_start;   \
+                                                VOID    *tx_thread_module_kernel_stack_end;     \
+                                                ULONG   tx_thread_module_kernel_stack_size;     \
+                                                VOID    *tx_thread_module_stack_ptr;            \
+                                                VOID    *tx_thread_module_stack_start;          \
+                                                VOID    *tx_thread_module_stack_end;            \
+                                                ULONG   tx_thread_module_stack_size;            \
+                                                VOID    *tx_thread_module_reserved;
+#endif
+#define TX_THREAD_EXTENSION_3
+
+
+/* Define the port extensions of the remaining ThreadX objects.  */
+
+#define TX_BLOCK_POOL_EXTENSION
+#define TX_BYTE_POOL_EXTENSION
+#define TX_MUTEX_EXTENSION
+#define TX_EVENT_FLAGS_GROUP_EXTENSION          VOID    *tx_event_flags_group_module_instance; \
+                                                VOID   (*tx_event_flags_group_set_module_notify)(struct TX_EVENT_FLAGS_GROUP_STRUCT *group_ptr);
+
+#define TX_QUEUE_EXTENSION                      VOID    *tx_queue_module_instance; \
+                                                VOID   (*tx_queue_send_module_notify)(struct TX_QUEUE_STRUCT *queue_ptr);
+
+#define TX_SEMAPHORE_EXTENSION                  VOID    *tx_semaphore_module_instance; \
+                                                VOID   (*tx_semaphore_put_module_notify)(struct TX_SEMAPHORE_STRUCT *semaphore_ptr);
+
+#define TX_TIMER_EXTENSION                      VOID    *tx_timer_module_instance; \
+                                                VOID   (*tx_timer_module_expiration_function)(ULONG id);
+
+
+/* Define the user extension field of the thread control block.  Nothing 
+   additional is needed for this port so it is defined as white space.  */
+
+#ifndef TX_THREAD_USER_EXTENSION
+#define TX_THREAD_USER_EXTENSION
+#endif
+
+
+/* Define the macros for processing extensions in tx_thread_create, tx_thread_delete,
+   tx_thread_shell_entry, and tx_thread_terminate.  */
+
+
+#define TX_THREAD_CREATE_EXTENSION(thread_ptr)
+
+#if !defined(TX_SINGLE_MODE_SECURE) && !defined(TX_SINGLE_MODE_NON_SECURE)
+#define TX_THREAD_DELETE_EXTENSION(thread_ptr)  if(thread_ptr -> tx_thread_secure_stack_context){_tx_thread_secure_stack_free(thread_ptr);}
+#else
+#define TX_THREAD_DELETE_EXTENSION(thread_ptr)
+#endif
+
+#if !defined(TX_SINGLE_MODE_SECURE) && !defined(TX_SINGLE_MODE_NON_SECURE)
+/* Define the size of the secure stack for the timer thread and use the extension to allocate the secure stack. */
+#define TX_TIMER_THREAD_SECURE_STACK_SIZE   256
+#define TX_TIMER_INITIALIZE_EXTENSION(status)   _tx_thread_secure_stack_allocate(&_tx_timer_thread, TX_TIMER_THREAD_SECURE_STACK_SIZE);
+#endif
+
+
+#ifndef TX_MISRA_ENABLE
+
+//register unsigned int _ipsr __asm ("MRS %[result], ipsr" : [result] "=r" (_ipsr) : );
+inline static unsigned int _get_ipsr(void);
+inline static unsigned int _get_ipsr(void)
+{
+    unsigned int _ipsr;
+    __asm("MRS %[result], ipsr" : [result] "=r" (_ipsr) : );
+    return _ipsr;
+}
+
+#endif
+
+
+#ifdef __ARM_PCS_VFP
+
+#ifdef TX_MISRA_ENABLE
+
+ULONG  _tx_misra_control_get(void);
+void   _tx_misra_control_set(ULONG value);
+ULONG  _tx_misra_fpccr_get(void);
+void   _tx_misra_vfp_touch(void);
+
+#else
+
+#ifdef TX_SOURCE_CODE
+
+static unsigned int _get_control(void);
+static unsigned int _get_control(void)
+{
+    unsigned int _control;
+    __asm("MRS %[result], control" : [result] "=r" (_control) : );
+    return _control;
+}
+
+static void _set_control(unsigned int _control);
+static void _set_control(unsigned int _control)
+{
+    __asm("MSR control, %[input]" : : [input] "r" (_control));
+}
+
+#endif
+#endif
+
+/* A completed thread falls into _thread_shell_entry and we can simply deactivate the FPU via CONTROL.FPCA
+   in order to ensure no lazy stacking will occur. */
+
+#ifndef TX_MISRA_ENABLE
+
+#define TX_THREAD_COMPLETED_EXTENSION(thread_ptr)                   {                                                                                             \
+                                                                    ULONG  _tx_vfp_state;                                                                         \
+                                                                        _tx_vfp_state =  _get_control();                                                                \
+                                                                        _tx_vfp_state =  _tx_vfp_state & ~((ULONG) 0x4);                                          \
+                                                                        _set_control(_tx_vfp_state);;                                                           \
+                                                                    }
+#else
+
+#define TX_THREAD_COMPLETED_EXTENSION(thread_ptr)                   {                                                                                             \
+                                                                    ULONG  _tx_vfp_state;                                                                         \
+                                                                        _tx_vfp_state =  _tx_misra_control_get();                                                 \
+                                                                        _tx_vfp_state =  _tx_vfp_state & ~((ULONG) 0x4);                                          \
+                                                                        _tx_misra_control_set(_tx_vfp_state);                                                     \
+                                                                    }
+                                                                    
+#endif
+
+/* A thread can be terminated by another thread, so we first check if it's self-terminating and not in an ISR.
+   If so, deactivate the FPU via CONTROL.FPCA. Otherwise we are in an interrupt or another thread is terminating
+   this one, so if the FPCCR.LSPACT bit is set, we need to save the CONTROL.FPCA state, touch the FPU to flush 
+   the lazy FPU save, then restore the CONTROL.FPCA state. */
+
+#ifndef TX_MISRA_ENABLE
+
+void _tx_vfp_access(void);
+
+#define TX_THREAD_TERMINATED_EXTENSION(thread_ptr)                  {                                                                                             \
+                                                                    ULONG  _tx_system_state;                                                                      \
+                                                                        _tx_system_state =  TX_THREAD_GET_SYSTEM_STATE();                                         \
+                                                                        if ((_tx_system_state == ((ULONG) 0)) && ((thread_ptr) == _tx_thread_current_ptr))        \
+                                                                        {                                                                                         \
+                                                                        ULONG  _tx_vfp_state;                                                                     \
+                                                                            _tx_vfp_state =  _get_control();                                                            \
+                                                                            _tx_vfp_state =  _tx_vfp_state & ~((ULONG) 0x4);                                      \
+                                                                            _set_control(_tx_vfp_state);                                                       \
+                                                                        }                                                                                         \
+                                                                        else                                                                                      \
+                                                                        {                                                                                         \
+                                                                        ULONG  _tx_fpccr;                                                                         \
+                                                                            _tx_fpccr =  *((ULONG *) 0xE000EF34);                                                 \
+                                                                            _tx_fpccr =  _tx_fpccr & ((ULONG) 0x01);                                              \
+                                                                            if (_tx_fpccr == ((ULONG) 0x01))                                                      \
+                                                                            {                                                                                     \
+                                                                            ULONG _tx_vfp_state;                                                                  \
+                                                                                _tx_vfp_state =  _get_control();                                                        \
+                                                                                _tx_vfp_state =  _tx_vfp_state & ((ULONG) 0x4);                                   \
+                                                                                _tx_vfp_access();                                                                 \
+                                                                                if (_tx_vfp_state == ((ULONG) 0))                                                 \
+                                                                                {                                                                                 \
+                                                                                    _tx_vfp_state =  _get_control();                                                    \
+                                                                                    _tx_vfp_state =  _tx_vfp_state & ~((ULONG) 0x4);                              \
+                                                                                    _set_control(_tx_vfp_state);                                               \
+                                                                                }                                                                                 \
+                                                                            }                                                                                     \
+                                                                        }                                                                                         \
+                                                                    }
+#else
+
+#define TX_THREAD_TERMINATED_EXTENSION(thread_ptr)                  {                                                                                             \
+                                                                    ULONG  _tx_system_state;                                                                      \
+                                                                        _tx_system_state =  TX_THREAD_GET_SYSTEM_STATE();                                         \
+                                                                        if ((_tx_system_state == ((ULONG) 0)) && ((thread_ptr) == _tx_thread_current_ptr))        \
+                                                                        {                                                                                         \
+                                                                        ULONG  _tx_vfp_state;                                                                     \
+                                                                            _tx_vfp_state =  _tx_misra_control_get();                                             \
+                                                                            _tx_vfp_state =  _tx_vfp_state & ~((ULONG) 0x4);                                      \
+                                                                            _tx_misra_control_set(_tx_vfp_state);                                                 \
+                                                                        }                                                                                         \
+                                                                        else                                                                                      \
+                                                                        {                                                                                         \
+                                                                        ULONG  _tx_fpccr;                                                                         \
+                                                                            _tx_fpccr =  _tx_misra_fpccr_get();                                                   \
+                                                                            _tx_fpccr =  _tx_fpccr & ((ULONG) 0x01);                                              \
+                                                                            if (_tx_fpccr == ((ULONG) 0x01))                                                      \
+                                                                            {                                                                                     \
+                                                                            ULONG _tx_vfp_state;                                                                  \
+                                                                                _tx_vfp_state = _tx_misra_control_get();                                          \
+                                                                                _tx_vfp_state =  _tx_vfp_state & ((ULONG) 0x4);                                   \
+                                                                                _tx_misra_vfp_touch();                                                            \
+                                                                                if (_tx_vfp_state == ((ULONG) 0))                                                 \
+                                                                                {                                                                                 \
+                                                                                    _tx_vfp_state =  _tx_misra_control_get();                                     \
+                                                                                    _tx_vfp_state =  _tx_vfp_state & ~((ULONG) 0x4);                              \
+                                                                                    _tx_misra_control_set(_tx_vfp_state);                                         \
+                                                                                }                                                                                 \
+                                                                            }                                                                                     \
+                                                                        }                                                                                         \
+                                                                    }
+#endif
+
+#else
+
+#define TX_THREAD_COMPLETED_EXTENSION(thread_ptr)
+#define TX_THREAD_TERMINATED_EXTENSION(thread_ptr)
+
+#endif
+
+
+/* Define the ThreadX object creation extensions for the remaining objects.  */
+
+#define TX_BLOCK_POOL_CREATE_EXTENSION(pool_ptr)
+#define TX_BYTE_POOL_CREATE_EXTENSION(pool_ptr)
+#define TX_EVENT_FLAGS_GROUP_CREATE_EXTENSION(group_ptr)
+#define TX_MUTEX_CREATE_EXTENSION(mutex_ptr)
+#define TX_QUEUE_CREATE_EXTENSION(queue_ptr)
+#define TX_SEMAPHORE_CREATE_EXTENSION(semaphore_ptr)
+#define TX_TIMER_CREATE_EXTENSION(timer_ptr)
+
+
+/* Define the ThreadX object deletion extensions for the remaining objects.  */
+
+#define TX_BLOCK_POOL_DELETE_EXTENSION(pool_ptr)
+#define TX_BYTE_POOL_DELETE_EXTENSION(pool_ptr)
+#define TX_EVENT_FLAGS_GROUP_DELETE_EXTENSION(group_ptr)
+#define TX_MUTEX_DELETE_EXTENSION(mutex_ptr)
+#define TX_QUEUE_DELETE_EXTENSION(queue_ptr)
+#define TX_SEMAPHORE_DELETE_EXTENSION(semaphore_ptr)
+#define TX_TIMER_DELETE_EXTENSION(timer_ptr)
+
+
+/* Define the get system state macro.   */
+   
+#ifndef TX_THREAD_GET_SYSTEM_STATE
+#ifndef TX_MISRA_ENABLE
+#define TX_THREAD_GET_SYSTEM_STATE()        (_tx_thread_system_state | _get_ipsr())
+#else
+ULONG   _tx_misra_ipsr_get(VOID);
+#define TX_THREAD_GET_SYSTEM_STATE()        (_tx_thread_system_state | _tx_misra_ipsr_get())
+#endif
+#endif
+
+
+/* Define the check for whether or not to call the _tx_thread_system_return function.  A non-zero value
+   indicates that _tx_thread_system_return should not be called. This overrides the definition in tx_thread.h
+   for Cortex-M since so we don't waste time checking the _tx_thread_system_state variable that is always
+   zero after initialization for Cortex-M ports. */
+
+#ifndef TX_THREAD_SYSTEM_RETURN_CHECK
+#define TX_THREAD_SYSTEM_RETURN_CHECK(c)    (c) = ((ULONG) _tx_thread_preempt_disable);
+#endif
+
+#if !defined(TX_SINGLE_MODE_SECURE) && !defined(TX_SINGLE_MODE_NON_SECURE)
+/* Initialize secure stacks for threads calling secure functions. */
+extern void    _tx_thread_secure_stack_initialize(void);
+#define TX_INITIALIZE_KERNEL_ENTER_EXTENSION            _tx_thread_secure_stack_initialize();
+#endif
+
+/* Define the macro to ensure _tx_thread_preempt_disable is set early in initialization in order to 
+   prevent early scheduling on Cortex-M parts.  */
+   
+#define TX_PORT_SPECIFIC_POST_INITIALIZATION    _tx_thread_preempt_disable++;
+
+
+/* Determine if the ARM architecture has the CLZ instruction. This is available on 
+   architectures v5 and above. If available, redefine the macro for calculating the 
+   lowest bit set.  */
+
+#ifndef TX_DISABLE_INLINE
+
+#define TX_LOWEST_SET_BIT_CALCULATE(m, b)       (b) = (UINT)__clz(__rbit((m)));
+
+#endif
+
+
+/* Define ThreadX interrupt lockout and restore macros for protection on 
+   access of critical kernel information.  The restore interrupt macro must 
+   restore the interrupt posture of the running thread prior to the value 
+   present prior to the disable macro.  In most cases, the save area macro
+   is used to define a local function save area for the disable and restore
+   macros.  */
+
+#ifdef TX_DISABLE_INLINE
+
+UINT                                            _tx_thread_interrupt_disable(VOID);
+VOID                                            _tx_thread_interrupt_restore(UINT previous_posture);
+
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save;
+
+#define TX_DISABLE                              interrupt_save = _tx_thread_interrupt_disable();
+
+#define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
+
+#else
+
+#define TX_INTERRUPT_SAVE_AREA                  UINT was_masked;
+#define TX_DISABLE                              was_masked = __disable_irq();
+#define TX_RESTORE                              if (was_masked == 0) __enable_irq();
+
+#define _tx_thread_system_return                _tx_thread_system_return_inline
+
+
+static void _tx_thread_system_return_inline(void)
+{
+unsigned int          was_masked;
+
+
+    /* Set PendSV to invoke ThreadX scheduler.  */
+    *((ULONG *) 0xE000ED04) = ((ULONG) 0x10000000);
+    if (_get_ipsr() == 0)
+    {
+        was_masked = __disable_irq();
+        __enable_irq();
+        if (was_masked != 0)
+            __disable_irq();
+    }
+}
+#endif
+
+
+/* Define the version ID of ThreadX.  This may be utilized by the application.  */
+
+#ifdef TX_THREAD_INIT
+CHAR                            _tx_version_id[] = 
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M23/AC6 Version 6.1.6 *";
+#else
+#ifdef TX_MISRA_ENABLE
+extern  CHAR                    _tx_version_id[100];
+#else
+extern  CHAR                    _tx_version_id[];
+#endif
+#endif
+
+
+#endif
+
+
+
diff --git a/ports_module/cortex_m23/ac6/inc/tx_secure_interface.h b/ports_module/cortex_m23/ac6/inc/tx_secure_interface.h
new file mode 100644
index 00000000..c2779f40
--- /dev/null
+++ b/ports_module/cortex_m23/ac6/inc/tx_secure_interface.h
@@ -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                                                     */
+/**                                                                       */
+/**   Thread                                                              */
+/**                                                                       */
+/**************************************************************************/
+/**************************************************************************/
+
+
+/**************************************************************************/
+/*                                                                        */
+/*  COMPONENT DEFINITION                                   RELEASE        */
+/*                                                                        */
+/*    tx_secure_interface.h                               PORTABLE C      */
+/*                                                            6.1         */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    Scott Larson, Microsoft Corporation                                 */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
+/*    This file defines the ThreadX secure thread stack components,       */
+/*    including data types and external references.                       */
+/*    It is assumed that tx_api.h and tx_port.h have already been         */
+/*    included.                                                           */
+/*                                                                        */
+/*  RELEASE HISTORY                                                       */
+/*                                                                        */
+/*    DATE              NAME                      DESCRIPTION             */
+/*                                                                        */
+/*  09-30-2020     Scott Larson             Initial Version 6.1           */
+/*                                                                        */
+/**************************************************************************/
+
+#ifndef TX_SECURE_INTERFACE_H
+#define TX_SECURE_INTERFACE_H
+
+/* Define internal secure thread stack function prototypes.  */
+
+extern void    _tx_thread_secure_stack_initialize(void);
+extern UINT    _tx_thread_secure_mode_stack_allocate(TX_THREAD *thread_ptr, ULONG stack_size);
+extern UINT    _tx_thread_secure_mode_stack_free(TX_THREAD *thread_ptr);
+extern void    _tx_thread_secure_stack_context_save(TX_THREAD *thread_ptr);
+extern void    _tx_thread_secure_stack_context_restore(TX_THREAD *thread_ptr);
+
+#endif
diff --git a/ports_module/cortex_m23/ac6/inc/txm_module_port.h b/ports_module/cortex_m23/ac6/inc/txm_module_port.h
new file mode 100644
index 00000000..16645dbb
--- /dev/null
+++ b/ports_module/cortex_m23/ac6/inc/txm_module_port.h
@@ -0,0 +1,352 @@
+/**************************************************************************/
+/*                                                                        */
+/*       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                                                              */
+/**                                                                       */
+/**************************************************************************/
+/**************************************************************************/
+
+
+/**************************************************************************/
+/*                                                                        */
+/*  APPLICATION INTERFACE DEFINITION                       RELEASE        */
+/*                                                                        */
+/*    txm_module_port.h                                 Cortex-M23/AC6    */
+/*                                                           6.1.6        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    Scott Larson, Microsoft Corporation                                 */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
+/*    This file defines the basic module constants, interface structures, */
+/*    and function prototypes.                                            */
+/*                                                                        */
+/*  RELEASE HISTORY                                                       */
+/*                                                                        */
+/*    DATE              NAME                      DESCRIPTION             */
+/*                                                                        */
+/*  04-02-2021      Scott Larson            Initial Version 6.1.6         */
+/*                                                                        */
+/**************************************************************************/
+
+#ifndef TXM_MODULE_PORT_H
+#define TXM_MODULE_PORT_H
+
+/* Determine if the optional Modules user define file should be used.  */
+
+#ifdef TXM_MODULE_INCLUDE_USER_DEFINE_FILE
+
+/* Yes, include the user defines in txm_module_user.h. The defines in this file may
+   alternately be defined on the command line.  */
+
+#include "txm_module_user.h"
+#endif
+
+/* It is assumed that the base ThreadX tx_port.h file has been modified to add the
+  following extensions to the ThreadX thread control block (this code should replace
+  the corresponding macro define in tx_port.h):
+
+#define TX_THREAD_EXTENSION_2                   VOID    *tx_thread_module_instance_ptr;         \
+                                                VOID    *tx_thread_module_entry_info_ptr;       \
+                                                ULONG   tx_thread_module_current_user_mode;     \
+                                                ULONG   tx_thread_module_user_mode;             \
+                                                ULONG   tx_thread_module_saved_lr;              \
+                                                VOID    *tx_thread_module_kernel_stack_start;   \
+                                                VOID    *tx_thread_module_kernel_stack_end;     \
+                                                ULONG   tx_thread_module_kernel_stack_size;     \
+                                                VOID    *tx_thread_module_stack_ptr;            \
+                                                VOID    *tx_thread_module_stack_start;          \
+                                                VOID    *tx_thread_module_stack_end;            \
+                                                ULONG   tx_thread_module_stack_size;            \
+                                                VOID    *tx_thread_module_reserved;
+
+The following extensions must also be defined in tx_port.h:
+
+#define TX_EVENT_FLAGS_GROUP_EXTENSION          VOID    *tx_event_flags_group_module_instance; \
+                                                VOID   (*tx_event_flags_group_set_module_notify)(struct TX_EVENT_FLAGS_GROUP_STRUCT *group_ptr);
+
+#define TX_QUEUE_EXTENSION                      VOID    *tx_queue_module_instance; \
+                                                VOID   (*tx_queue_send_module_notify)(struct TX_QUEUE_STRUCT *queue_ptr);
+
+#define TX_SEMAPHORE_EXTENSION                  VOID    *tx_semaphore_module_instance; \
+                                                VOID   (*tx_semaphore_put_module_notify)(struct TX_SEMAPHORE_STRUCT *semaphore_ptr);
+
+#define TX_TIMER_EXTENSION                      VOID    *tx_timer_module_instance; \
+                                                VOID   (*tx_timer_module_expiration_function)(ULONG id);
+*/
+
+/* Define the kernel stack size for a module thread.  */
+#ifndef TXM_MODULE_KERNEL_STACK_SIZE
+#define TXM_MODULE_KERNEL_STACK_SIZE            768
+#endif
+
+/* Define constants specific to the tools the module can be built with for this particular modules port.  */
+
+#define TXM_MODULE_IAR_COMPILER                 0x00000000
+#define TXM_MODULE_RVDS_COMPILER                0x01000000
+#define TXM_MODULE_GNU_COMPILER                 0x02000000
+#define TXM_MODULE_COMPILER_MASK                0xFF000000
+#define TXM_MODULE_OPTIONS_MASK                 0x000000FF
+
+
+/* Define the properties for this particular module port.  */
+
+#define TXM_MODULE_MEMORY_PROTECTION_ENABLED
+
+#ifdef  TXM_MODULE_MEMORY_PROTECTION_ENABLED
+#define TXM_MODULE_REQUIRE_ALLOCATED_OBJECT_MEMORY
+#else
+#define TXM_MODULE_REQUIRE_LOCAL_OBJECT_MEMORY
+#endif
+
+#define TXM_MODULE_USER_MODE                        0x00000001
+#define TXM_MODULE_MEMORY_PROTECTION                0x00000002
+#define TXM_MODULE_SHARED_EXTERNAL_MEMORY_ACCESS    0x00000004
+
+
+/* Define the supported options for this module.   */
+
+#define TXM_MODULE_MANAGER_SUPPORTED_OPTIONS    (TXM_MODULE_USER_MODE | TXM_MODULE_MEMORY_PROTECTION | TXM_MODULE_SHARED_EXTERNAL_MEMORY_ACCESS)
+#define TXM_MODULE_MANAGER_REQUIRED_OPTIONS     0
+
+
+/* Define offset adjustments according to the compiler used to build the module.  */
+
+#define TXM_MODULE_IAR_SHELL_ADJUST             24
+#define TXM_MODULE_IAR_START_ADJUST             28
+#define TXM_MODULE_IAR_STOP_ADJUST              32
+#define TXM_MODULE_IAR_CALLBACK_ADJUST          44
+
+#define TXM_MODULE_RVDS_SHELL_ADJUST            0
+#define TXM_MODULE_RVDS_START_ADJUST            0
+#define TXM_MODULE_RVDS_STOP_ADJUST             0
+#define TXM_MODULE_RVDS_CALLBACK_ADJUST         0
+
+#define TXM_MODULE_GNU_SHELL_ADJUST             24
+#define TXM_MODULE_GNU_START_ADJUST             28
+#define TXM_MODULE_GNU_STOP_ADJUST              32
+#define TXM_MODULE_GNU_CALLBACK_ADJUST          44
+
+
+/* Define other module port-specific constants.  */
+
+/* Define INLINE_DECLARE to inline for ARM compiler.  */
+
+#define INLINE_DECLARE inline
+
+/* Define the number of MPU entries assigned to the code and data sections.
+   On Cortex-M23 devices, there are 8 total entries. ThreadX uses one for access
+   to the kernel entry function, one for module code protection, one for module data protection,
+   leaving five regions available for shared memory.  */
+#define TXM_MODULE_MPU_TOTAL_ENTRIES            8
+#define TXM_MODULE_MPU_KERNEL_ENTRY_INDEX       0
+#define TXM_MODULE_MPU_CODE_INDEX               1
+#define TXM_MODULE_MPU_DATA_INDEX               2
+
+#define TXM_MODULE_MPU_SHARED_INDEX             3
+#define TXM_MODULE_MPU_SHARED_ENTRIES           5
+
+#define TXM_MODULE_ATTRIBUTE_NON_SHAREABLE      0x00
+#define TXM_MODULE_ATTRIBUTE_OUTER_SHAREABLE    0x10
+#define TXM_MODULE_ATTRIBUTE_INNER_SHAREABLE    0x18
+#define TXM_MODULE_ATTRIBUTE_READ_WRITE         0x02
+#define TXM_MODULE_ATTRIBUTE_READ_ONLY          0x06
+#define TXM_MODULE_ATTRIBUTE_EXECUTE_NEVER      0x01
+#define TXM_MODULE_ATTRIBUTE_REGION_ENABLE      0x01
+#define TXM_MODULE_ATTRIBUTE_MASK               0x1E
+#define TXM_MODULE_ATTRIBUTE_INDEX              0x00
+
+/* MAIR_ATTR settings
+Device-nGnRE : 0b [Outer]0000 [Inner]0100
+Code WT   RA : 0b [Outer]1010 [Inner]1010
+DATA WBWA RA : 0b [Outer]1111 [Inner]1111
+*/
+
+/* Data aligned to 8 bytes (stacks must be 8-byte aligned).  */
+#define TXM_MODULE_DATA_ALIGNMENT               8
+
+/* MPU regions must be 32-byte aligned.  */
+#define TXM_MODULE_MPU_ALIGNMENT                32
+
+#define TXM_THREAD_SECURE_STACK_ALLOCATE_CALL   TXM_MODULE_PORT_EXTENSION_API_ID_START
+#define TXM_THREAD_SECURE_STACK_FREE_CALL       (TXM_MODULE_PORT_EXTENSION_API_ID_START+1)
+
+/* There are 2 registers to set up each MPU region: MPU_RBAR, MPU_RLAR.  */
+typedef struct TXM_MODULE_MPU_INFO_STRUCT
+{
+    ULONG   txm_module_mpu_region_base_address;
+    ULONG   txm_module_mpu_region_limit_address;
+} TXM_MODULE_MPU_INFO;
+
+/* Define the port-extensions to the module manager instance structure.  */
+#define TXM_MODULE_MANAGER_PORT_EXTENSION                                                               \
+    TXM_MODULE_MPU_INFO     txm_module_instance_mpu_registers[TXM_MODULE_MPU_TOTAL_ENTRIES];            \
+    ULONG                   txm_module_instance_shared_memory_count;                                    \
+    ULONG                   txm_module_instance_shared_memory_address[TXM_MODULE_MPU_SHARED_ENTRIES];   \
+    ULONG                   txm_module_instance_shared_memory_length[TXM_MODULE_MPU_SHARED_ENTRIES];
+
+
+/* Define the memory fault information structure that is populated when a memory fault occurs.  */
+
+typedef struct TXM_MODULE_MANAGER_MEMORY_FAULT_INFO_STRUCT
+{
+    TX_THREAD           *txm_module_manager_memory_fault_info_thread_ptr;
+    VOID                *txm_module_manager_memory_fault_info_code_location;
+    ULONG               txm_module_manager_memory_fault_info_shcsr;
+    ULONG               txm_module_manager_memory_fault_info_cfsr;
+    ULONG               txm_module_manager_memory_fault_info_mmfar;
+    ULONG               txm_module_manager_memory_fault_info_bfar;
+    ULONG               txm_module_manager_memory_fault_info_control;
+    ULONG               txm_module_manager_memory_fault_info_sp;
+    ULONG               txm_module_manager_memory_fault_info_r0;
+    ULONG               txm_module_manager_memory_fault_info_r1;
+    ULONG               txm_module_manager_memory_fault_info_r2;
+    ULONG               txm_module_manager_memory_fault_info_r3;
+    ULONG               txm_module_manager_memory_fault_info_r4;
+    ULONG               txm_module_manager_memory_fault_info_r5;
+    ULONG               txm_module_manager_memory_fault_info_r6;
+    ULONG               txm_module_manager_memory_fault_info_r7;
+    ULONG               txm_module_manager_memory_fault_info_r8;
+    ULONG               txm_module_manager_memory_fault_info_r9;
+    ULONG               txm_module_manager_memory_fault_info_r10;
+    ULONG               txm_module_manager_memory_fault_info_r11;
+    ULONG               txm_module_manager_memory_fault_info_r12;
+    ULONG               txm_module_manager_memory_fault_info_lr;
+    ULONG               txm_module_manager_memory_fault_info_xpsr;
+} TXM_MODULE_MANAGER_MEMORY_FAULT_INFO;
+
+
+#define TXM_MODULE_MANAGER_FAULT_INFO                                               \
+    TXM_MODULE_MANAGER_MEMORY_FAULT_INFO    _txm_module_manager_memory_fault_info;
+
+
+/* Define the macro to check the code alignment.  */
+
+#define TXM_MODULE_MANAGER_CHECK_CODE_ALIGNMENT(module_location, code_alignment)    \
+    {                                                                               \
+        ULONG   temp;                                                               \
+        temp =  (ULONG) module_location;                                            \
+        temp =  temp & (code_alignment - 1);                                        \
+        if (temp)                                                                   \
+        {                                                                           \
+            _tx_mutex_put(&_txm_module_manager_mutex);                              \
+            return(TXM_MODULE_ALIGNMENT_ERROR);                                     \
+        }                                                                           \
+    }
+
+
+/* Define the macro to adjust the alignment and size for code/data areas.  */
+
+#define TXM_MODULE_MANAGER_ALIGNMENT_ADJUST(module_preamble, code_size, code_alignment, data_size, data_alignment)   _txm_module_manager_alignment_adjust(module_preamble, &code_size, &code_alignment, &data_size, &data_alignment);
+
+
+/* Define the macro to adjust the symbols in the module preamble.  */
+
+#define TXM_MODULE_MANAGER_CALCULATE_ADJUSTMENTS(properties, shell_function_adjust, start_function_adjust, stop_function_adjust, callback_function_adjust) \
+    if ((properties & TXM_MODULE_COMPILER_MASK) == TXM_MODULE_IAR_COMPILER)         \
+    {                                                                               \
+        shell_function_adjust =     TXM_MODULE_IAR_SHELL_ADJUST;                    \
+        start_function_adjust =     TXM_MODULE_IAR_START_ADJUST;                    \
+        stop_function_adjust =      TXM_MODULE_IAR_STOP_ADJUST;                     \
+        callback_function_adjust =  TXM_MODULE_IAR_CALLBACK_ADJUST;                 \
+    }                                                                               \
+    else if ((properties & TXM_MODULE_COMPILER_MASK) == TXM_MODULE_RVDS_COMPILER)   \
+    {                                                                               \
+        shell_function_adjust =     TXM_MODULE_RVDS_SHELL_ADJUST;                   \
+        start_function_adjust =     TXM_MODULE_RVDS_START_ADJUST;                   \
+        stop_function_adjust =      TXM_MODULE_RVDS_STOP_ADJUST;                    \
+        callback_function_adjust =  TXM_MODULE_RVDS_CALLBACK_ADJUST;                \
+    }                                                                               \
+    else                                                                            \
+    {                                                                               \
+        shell_function_adjust =     TXM_MODULE_GNU_SHELL_ADJUST;                    \
+        start_function_adjust =     TXM_MODULE_GNU_START_ADJUST;                    \
+        stop_function_adjust =      TXM_MODULE_GNU_STOP_ADJUST;                     \
+        callback_function_adjust =  TXM_MODULE_GNU_CALLBACK_ADJUST;                 \
+    }
+
+
+/* Define the macro to populate the thread control block with module port-specific information.
+   Check if the module is in user mode and set up txm_module_thread_entry_info_kernel_call_dispatcher accordingly.
+*/
+
+#define TXM_MODULE_MANAGER_THREAD_SETUP(thread_ptr, module_instance)                                                                    \
+    thread_ptr -> tx_thread_module_current_user_mode =  module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE;   \
+    thread_ptr -> tx_thread_module_user_mode =          module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE;   \
+    if (thread_ptr -> tx_thread_module_user_mode)                                                                                       \
+    {                                                                                                                                   \
+        thread_entry_info -> txm_module_thread_entry_info_kernel_call_dispatcher =   _txm_module_manager_user_mode_entry;               \
+    }                                                                                                                                   \
+    else                                                                                                                                \
+    {                                                                                                                                   \
+        thread_entry_info -> txm_module_thread_entry_info_kernel_call_dispatcher =   _txm_module_manager_kernel_dispatch;               \
+    }
+
+
+/* Define the macro to populate the module control block with module port-specific information.
+   If memory protection is enabled, set up the MPU registers.
+*/
+#define TXM_MODULE_MANAGER_MODULE_SETUP(module_instance)                                            \
+    if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE)               \
+    {                                                                                               \
+        if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)   \
+        {                                                                                           \
+            _txm_module_manager_mm_register_setup(module_instance);                                 \
+        }                                                                                           \
+    }                                                                                               \
+    else                                                                                            \
+    {                                                                                               \
+        /* Do nothing.  */                                                                          \
+    }
+
+/* Define the macro to perform port-specific functions when unloading the module.  */
+/* Nothing needs to be done for this port.  */
+#define TXM_MODULE_MANAGER_MODULE_UNLOAD(module_instance)
+
+
+/* Define the macros to perform port-specific checks when passing pointers to the kernel.  */
+
+/* Define macro to make sure object is inside the module's data.  */
+#define TXM_MODULE_MANAGER_CHECK_INSIDE_DATA(module_instance, obj_ptr, obj_size) \
+    _txm_module_manager_inside_data_check(module_instance, obj_ptr, obj_size)
+
+/* Define some internal prototypes to this module port.  */
+
+#ifndef TX_SOURCE_CODE
+#define txm_module_manager_memory_fault_notify              _txm_module_manager_memory_fault_notify
+#endif
+
+
+#ifdef TX_SOURCE_CODE
+
+#endif
+
+#define TXM_MODULE_MANAGER_ADDITIONAL_PROTOTYPES                                                                                \
+VOID  _txm_module_manager_alignment_adjust(TXM_MODULE_PREAMBLE *module_preamble, ULONG *code_size, ULONG *code_alignment, ULONG *data_size, ULONG *data_alignment);   \
+VOID  _txm_module_manager_memory_fault_handler(VOID);                                                                           \
+UINT  _txm_module_manager_memory_fault_notify(VOID (*notify_function)(TX_THREAD *, TXM_MODULE_INSTANCE *));                     \
+VOID  _txm_module_manager_mm_register_setup(TXM_MODULE_INSTANCE *module_instance);                                              \
+UINT  _txm_module_manager_inside_data_check(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE obj_ptr, UINT obj_size);           \
+ALIGN_TYPE _txm_module_manager_port_dispatch(TXM_MODULE_INSTANCE *module_instance, ULONG kernel_request, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2);
+
+
+#define TXM_MODULE_MANAGER_VERSION_ID   \
+CHAR                            _txm_module_manager_version_id[] =  \
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Module Cortex-M23/AC6 Version 6.1.6 *";
+
+#endif