Release 6.1.6

common/inc/tx_api.h

@@ -26,7 +26,7 @@
 /*  APPLICATION INTERFACE DEFINITION                       RELEASE        */
 /*                                                                        */
 /*    tx_api.h                                            PORTABLE C      */
-/*                                                           6.1.5        */
+/*                                                           6.1.6        */
 /*  AUTHOR                                                                */
 /*                                                                        */
 /*    William E. Lamie, Microsoft Corporation                             */
@@ -66,6 +66,9 @@
 /*                                            add option to remove FileX  */
 /*                                            pointer,                    */
 /*                                            resulting in version 6.1.5  */
+/*  04-02-2021      Scott Larson            Modified comment(s), and      */
+/*                                            update patch number,        */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -98,7 +101,7 @@ extern   "C" {
 #define AZURE_RTOS_THREADX
 #define THREADX_MAJOR_VERSION           6
 #define THREADX_MINOR_VERSION           1
-#define THREADX_PATCH_VERSION           5
+#define THREADX_PATCH_VERSION           6
 
 /* Define the following symbol for backward compatibility */
 #define EL_PRODUCT_THREADX

common/src/tx_mutex_priority_change.c

@@ -35,7 +35,7 @@
 /*  FUNCTION                                               RELEASE        */
 /*                                                                        */
 /*    _tx_mutex_priority_change                           PORTABLE C      */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*  AUTHOR                                                                */
 /*                                                                        */
 /*    William E. Lamie, Microsoft Corporation                             */
@@ -70,14 +70,18 @@
 /*                                                                        */
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
-/*  05-19-2020     William E. Lamie         Initial Version 6.0           */
+/*  05-19-2020      William E. Lamie        Initial Version 6.0           */
-/*  09-30-2020     William E. Lamie         Modified comment(s), and      */
+/*  09-30-2020      William E. Lamie        Modified comment(s), and      */
 /*                                            change thread state from    */
 /*                                            TX_SUSPENDED to             */
 /*                                            TX_PRIORITY_CHANGE before   */
 /*                                            calling                     */
 /*                                            _tx_thread_system_suspend,  */
 /*                                            resulting in version 6.1    */
+/*  04-02-2021      Scott Larson            Modified comments, fixed      */
+/*                                            mapping current thread's    */
+/*                                            priority rather than next,  */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 VOID  _tx_mutex_priority_change(TX_THREAD *thread_ptr, UINT new_priority)
@@ -308,15 +312,15 @@ UINT            map_index;
 #if TX_MAX_PRIORITIES > 32
 
                             /* Calculate the index into the bit map array.  */
-                            map_index =  (next_execute_ptr -> tx_thread_priority)/ ((UINT) 32);
+                            map_index =  (thread_ptr -> tx_thread_priority)/ ((UINT) 32);
 
                             /* Set the active bit to remember that the preempt map has something set.  */
-                            TX_DIV32_BIT_SET(next_execute_ptr -> tx_thread_priority, priority_bit)
+                            TX_DIV32_BIT_SET(thread_ptr -> tx_thread_priority, priority_bit)
                             _tx_thread_preempted_map_active =  _tx_thread_preempted_map_active | priority_bit;
 #endif
 
                             /* Remember that this thread was preempted by a thread above the thread's threshold.  */
-                            TX_MOD32_BIT_SET(next_execute_ptr -> tx_thread_priority, priority_bit)
+                            TX_MOD32_BIT_SET(thread_ptr -> tx_thread_priority, priority_bit)
                             _tx_thread_preempted_maps[MAP_INDEX] =  _tx_thread_preempted_maps[MAP_INDEX] | priority_bit;
                         }
 #endif

common_modules/module_manager/inc/txm_module_manager_dispatch.h

@@ -68,6 +68,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], extra_parameters[2]))
             return(TXM_MODULE_INVALID_MEMORY);
     }
@@ -131,6 +134,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -179,6 +185,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -218,6 +227,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -311,6 +323,9 @@ ALIGN_TYPE return_value;
 
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(VOID *)))
             return(TXM_MODULE_INVALID_MEMORY);
+
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
+            return(TXM_MODULE_INVALID_MEMORY);
     }
 
     return_value = (ALIGN_TYPE) _txe_byte_allocate(
@@ -342,6 +357,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], extra_parameters[1]))
             return(TXM_MODULE_INVALID_MEMORY);
     }
@@ -404,6 +422,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -455,6 +476,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[6])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -509,6 +533,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -668,6 +695,9 @@ ALIGN_TYPE return_value;
 
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
+
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
+            return(TXM_MODULE_INVALID_MEMORY);
     }
 
     return_value = (ALIGN_TYPE) _txe_event_flags_get(
@@ -701,6 +731,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -745,6 +778,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -784,6 +820,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -886,6 +925,9 @@ ALIGN_TYPE return_value;
 
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
             return(TXM_MODULE_INVALID_MEMORY);
+
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
+            return(TXM_MODULE_INVALID_MEMORY);
     }
 
     return_value = (ALIGN_TYPE) _txe_mutex_create(
@@ -967,6 +1009,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1017,6 +1062,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1066,6 +1114,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1151,6 +1202,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], extra_parameters[2]))
             return(TXM_MODULE_INVALID_MEMORY);
     }
@@ -1264,6 +1318,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1314,6 +1371,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1363,6 +1423,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1551,6 +1614,9 @@ ALIGN_TYPE return_value;
 
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
             return(TXM_MODULE_INVALID_MEMORY);
+
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
+            return(TXM_MODULE_INVALID_MEMORY);
     }
 
     return_value = (ALIGN_TYPE) _txe_semaphore_create(
@@ -1631,6 +1697,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1675,6 +1744,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1714,6 +1786,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1840,6 +1915,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[9])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], extra_parameters[3]))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -1977,6 +2055,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[7])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(UINT)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -2056,6 +2137,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[9])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -2126,6 +2210,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[9])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -2535,6 +2622,9 @@ VOID (*expiration_function)(ULONG);
 
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
             return(TXM_MODULE_INVALID_MEMORY);
+
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[6])))
+            return(TXM_MODULE_INVALID_MEMORY);
     }
 
     /* Is it a disable request?  */
@@ -2646,6 +2736,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(UINT)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -2691,6 +2784,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -2735,6 +2831,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
             return(TXM_MODULE_INVALID_MEMORY);
 
@@ -2890,6 +2989,12 @@ static ALIGN_TYPE _txm_module_manager_tx_trace_user_event_insert_dispatch(TXM_MO
 
 ALIGN_TYPE return_value;
 
+    if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
+    {
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
+            return(TXM_MODULE_INVALID_MEMORY);
+    }
+    
     return_value = (ALIGN_TYPE) _tx_trace_user_event_insert(
         (ULONG) param_0,
         (ULONG) param_1,
@@ -3015,6 +3120,9 @@ ALIGN_TYPE return_value;
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
             return(TXM_MODULE_INVALID_MEMORY);
 
+        if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
+            return(TXM_MODULE_INVALID_MEMORY);
+
         if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(VOID *)))
             return(TXM_MODULE_INVALID_MEMORY);
     }

common_modules/module_manager/inc/txm_module_manager_util.h

@@ -10,37 +10,40 @@
 /**************************************************************************/
 
 
-/**************************************************************************/ 
+/**************************************************************************/
-/**************************************************************************/ 
+/**************************************************************************/
-/**                                                                       */ 
+/**                                                                       */
-/** ThreadX Component                                                     */ 
+/** ThreadX Component                                                     */
-/**                                                                       */ 
+/**                                                                       */
-/**   Module Manager                                                      */ 
+/**   Module Manager                                                      */
-/**                                                                       */ 
+/**                                                                       */
-/**************************************************************************/ 
+/**************************************************************************/
-/**************************************************************************/ 
+/**************************************************************************/
 
 
-/**************************************************************************/ 
+/**************************************************************************/
-/*                                                                        */ 
+/*                                                                        */
-/*  COMPONENT DEFINITION                                   RELEASE        */ 
+/*  COMPONENT DEFINITION                                   RELEASE        */
-/*                                                                        */ 
+/*                                                                        */
-/*    txm_module_manager_util.h                           PORTABLE C      */ 
+/*    txm_module_manager_util.h                           PORTABLE C      */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*  AUTHOR                                                                */
 /*                                                                        */
 /*    Scott Larson, Microsoft Corporation                                 */
 /*                                                                        */
-/*  DESCRIPTION                                                           */ 
+/*  DESCRIPTION                                                           */
-/*                                                                        */ 
+/*                                                                        */
-/*    This file declares prototypes of utility functions used by the      */ 
+/*    This file declares prototypes of utility functions used by the      */
-/*    module manager.                                                     */ 
+/*    module manager.                                                     */
-/*                                                                        */ 
+/*                                                                        */
-/*  RELEASE HISTORY                                                       */ 
+/*  RELEASE HISTORY                                                       */
-/*                                                                        */ 
+/*                                                                        */
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
-/*  09-30-2020     Scott Larson             Initial Version 6.1           */
+/*  09-30-2020      Scott Larson            Initial Version 6.1           */
+/*  04-02-2021      Scott Larson            Modified comment(s) and       */
+/*                                            optimized object checks,    */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -53,15 +56,18 @@
     (!(TXM_MODULE_MANAGER_CHECK_INSIDE_DATA(module_instance, obj_ptr, obj_size)))
 
 #define TXM_MODULE_MANAGER_CHECK_INSIDE_CODE(module_instance, obj_ptr, obj_size) \
-    (((obj_ptr) >= (ALIGN_TYPE) module_instance -> txm_module_instance_code_start) && \
+    (((obj_ptr) < ((obj_ptr) + (obj_size))) && \
+     ((obj_ptr) >= (ALIGN_TYPE) module_instance -> txm_module_instance_code_start) && \
      (((obj_ptr) + (obj_size)) <= ((ALIGN_TYPE) module_instance -> txm_module_instance_code_end + 1)))
 
 #define TXM_MODULE_MANAGER_CHECK_OUTSIDE_CODE(module_instance, obj_ptr, obj_size) \
     (!(TXM_MODULE_MANAGER_CHECK_INSIDE_CODE(module_instance, obj_ptr, obj_size)))
 
+/* Add sizeof(TXM_MODULE_ALLOCATED_OBJECT) to pool start because the object can't exist before that. */
 #define TXM_MODULE_MANAGER_CHECK_INSIDE_OBJ_POOL(module_instance, obj_ptr, obj_size) \
     ((_txm_module_manager_object_pool_created == TX_TRUE) && \
-     (((obj_ptr) >= (ALIGN_TYPE) _txm_module_manager_object_pool.tx_byte_pool_start) && \
+     ((obj_ptr) < ((obj_ptr) + (obj_size))) && \
+     (((obj_ptr) >= ((ALIGN_TYPE) _txm_module_manager_object_pool.tx_byte_pool_start + sizeof(TXM_MODULE_ALLOCATED_OBJECT))) && \
       (((obj_ptr) + (obj_size)) <= (ALIGN_TYPE) (_txm_module_manager_object_pool.tx_byte_pool_start + _txm_module_manager_object_pool.tx_byte_pool_size))))
 
 /* Define macros for module.  */
@@ -84,29 +90,29 @@
 
 /* Buffers we read from can be in RW/RO/Shared areas.  */
 #define TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_READ(module_instance, buffer_ptr, buffer_size) \
-    (((void *) (buffer_ptr) == TX_NULL) || \
+    ((TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE(module_instance, buffer_ptr, buffer_size)) || \
-     (TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE(module_instance, buffer_ptr, buffer_size)))
+     ((void *) (buffer_ptr) == TX_NULL))
 
 /* Buffers we write to can only be in RW/Shared areas.  */
 #define TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, buffer_ptr, buffer_size) \
-    (((void *) (buffer_ptr) == TX_NULL) || \
+    ((TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, buffer_ptr, buffer_size)) || \
-     (TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, buffer_ptr, buffer_size)))
+     ((void *) (buffer_ptr) == TX_NULL))
 
 /* Kernel objects should be outside the module at the very least.  */
 #define TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, obj_ptr, obj_size) \
-    (((void *) (obj_ptr) == TX_NULL) || \
+    ((TXM_MODULE_MANAGER_ENSURE_OUTSIDE_MODULE(module_instance, obj_ptr, obj_size)) || \
-     (TXM_MODULE_MANAGER_ENSURE_OUTSIDE_MODULE(module_instance, obj_ptr, obj_size)))
+     ((void *) (obj_ptr) == TX_NULL))
 
 /* When creating an object, the object must be inside the object pool.  */
 #define TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, obj_ptr, obj_size) \
-    (((void *) (obj_ptr) == TX_NULL) || \
+    ((TXM_MODULE_MANAGER_ENSURE_INSIDE_OBJ_POOL(module_instance, obj_ptr, obj_size) && \
-     (TXM_MODULE_MANAGER_ENSURE_INSIDE_OBJ_POOL(module_instance, obj_ptr, obj_size) && \
+      (_txm_module_manager_object_size_check(obj_ptr, obj_size) == TX_SUCCESS)) || \
-      (_txm_module_manager_object_size_check(obj_ptr, obj_size) == TX_SUCCESS)))
+     ((void *) (obj_ptr) == TX_NULL))
 
 /* Strings we dereference can be in RW/RO/Shared areas.  */
 #define TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, string_ptr) \
-    (((void *) (string_ptr) == TX_NULL) || \
+    ((TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE(module_instance, string_ptr, 1)) || \
-     (TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE(module_instance, string_ptr, 1)))
+     ((void *) (string_ptr) == TX_NULL))
 
 #define TXM_MODULE_MANAGER_UTIL_MAX_VALUE_OF_TYPE_UNSIGNED(type) ((1ULL << (sizeof(type) * 8)) - 1)
 

common_modules/module_manager/src/txm_module_manager_kernel_dispatch.c

@@ -41,7 +41,7 @@
 /*  FUNCTION                                               RELEASE        */
 /*                                                                        */
 /*    _txm_module_manager_kernel_dispatch                 PORTABLE C      */
-/*                                                           6.1.3        */
+/*                                                           6.1.6        */
 /*  AUTHOR                                                                */
 /*                                                                        */
 /*    Scott Larson, Microsoft Corporation                                 */
@@ -50,6 +50,8 @@
 /*                                                                        */
 /*    This function dispatches the module's kernel request based upon the */
 /*    ID and parameters specified in the request.                         */
+/*    To disallow modules to use specific ThreadX services, define        */
+/*    TXM_***_CALL_NOT_USED (see #ifndefs surrounding each case).         */
 /*                                                                        */
 /*  INPUT                                                                 */
 /*                                                                        */
@@ -83,6 +85,10 @@
 /*  12-31-2020      Scott Larson            Modified comment(s), added    */
 /*                                            port-specific dispatch,     */
 /*                                            resulting in version 6.1.3  */
+/*  04-02-2021      Scott Larson            Modified comment(s),          */
+/*                                            added optional defines to   */
+/*                                            remove unneeded functions,  */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 ALIGN_TYPE _txm_module_manager_kernel_dispatch(ULONG kernel_request, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
@@ -104,581 +110,773 @@ TXM_MODULE_INSTANCE *module_instance;
 
     switch (kernel_request)
     {
+    #ifndef TXM_BLOCK_ALLOCATE_CALL_NOT_USED
     case TXM_BLOCK_ALLOCATE_CALL:
     {
         return_value = _txm_module_manager_tx_block_allocate_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BLOCK_POOL_CREATE_CALL_NOT_USED
     case TXM_BLOCK_POOL_CREATE_CALL:
     {
         return_value = _txm_module_manager_tx_block_pool_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BLOCK_POOL_DELETE_CALL_NOT_USED
     case TXM_BLOCK_POOL_DELETE_CALL:
     {
         return_value = _txm_module_manager_tx_block_pool_delete_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_BLOCK_POOL_INFO_GET_CALL_NOT_USED
     case TXM_BLOCK_POOL_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_block_pool_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BLOCK_POOL_PERFORMANCE_INFO_GET_CALL_NOT_USED
     case TXM_BLOCK_POOL_PERFORMANCE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_block_pool_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
     case TXM_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_block_pool_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BLOCK_POOL_PRIORITIZE_CALL_NOT_USED
     case TXM_BLOCK_POOL_PRIORITIZE_CALL:
     {
         return_value = _txm_module_manager_tx_block_pool_prioritize_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_BLOCK_RELEASE_CALL_NOT_USED
     case TXM_BLOCK_RELEASE_CALL:
     {
         return_value = _txm_module_manager_tx_block_release_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_BYTE_ALLOCATE_CALL_NOT_USED
     case TXM_BYTE_ALLOCATE_CALL:
     {
         return_value = _txm_module_manager_tx_byte_allocate_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BYTE_POOL_CREATE_CALL_NOT_USED
     case TXM_BYTE_POOL_CREATE_CALL:
     {
         return_value = _txm_module_manager_tx_byte_pool_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BYTE_POOL_DELETE_CALL_NOT_USED
     case TXM_BYTE_POOL_DELETE_CALL:
     {
         return_value = _txm_module_manager_tx_byte_pool_delete_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_BYTE_POOL_INFO_GET_CALL_NOT_USED
     case TXM_BYTE_POOL_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_byte_pool_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BYTE_POOL_PERFORMANCE_INFO_GET_CALL_NOT_USED
     case TXM_BYTE_POOL_PERFORMANCE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_byte_pool_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
     case TXM_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_byte_pool_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_BYTE_POOL_PRIORITIZE_CALL_NOT_USED
     case TXM_BYTE_POOL_PRIORITIZE_CALL:
     {
         return_value = _txm_module_manager_tx_byte_pool_prioritize_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_BYTE_RELEASE_CALL_NOT_USED
     case TXM_BYTE_RELEASE_CALL:
     {
         return_value = _txm_module_manager_tx_byte_release_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_EVENT_FLAGS_CREATE_CALL_NOT_USED
     case TXM_EVENT_FLAGS_CREATE_CALL:
     {
         return_value = _txm_module_manager_tx_event_flags_create_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_EVENT_FLAGS_DELETE_CALL_NOT_USED
     case TXM_EVENT_FLAGS_DELETE_CALL:
     {
         return_value = _txm_module_manager_tx_event_flags_delete_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_EVENT_FLAGS_GET_CALL_NOT_USED
     case TXM_EVENT_FLAGS_GET_CALL:
     {
         return_value = _txm_module_manager_tx_event_flags_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_EVENT_FLAGS_INFO_GET_CALL_NOT_USED
     case TXM_EVENT_FLAGS_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_event_flags_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_EVENT_FLAGS_PERFORMANCE_INFO_GET_CALL_NOT_USED
     case TXM_EVENT_FLAGS_PERFORMANCE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_event_flags_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
     case TXM_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_event_flags_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_EVENT_FLAGS_SET_CALL_NOT_USED
     case TXM_EVENT_FLAGS_SET_CALL:
     {
         return_value = _txm_module_manager_tx_event_flags_set_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_EVENT_FLAGS_SET_NOTIFY_CALL_NOT_USED
     case TXM_EVENT_FLAGS_SET_NOTIFY_CALL:
     {
         return_value = _txm_module_manager_tx_event_flags_set_notify_dispatch(module_instance, param_0, param_1);
         break;
     }
+    #endif
 
+    #ifndef TXM_MUTEX_CREATE_CALL_NOT_USED
     case TXM_MUTEX_CREATE_CALL:
     {
         return_value = _txm_module_manager_tx_mutex_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_MUTEX_DELETE_CALL_NOT_USED
     case TXM_MUTEX_DELETE_CALL:
     {
         return_value = _txm_module_manager_tx_mutex_delete_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_MUTEX_GET_CALL_NOT_USED
     case TXM_MUTEX_GET_CALL:
     {
         return_value = _txm_module_manager_tx_mutex_get_dispatch(module_instance, param_0, param_1);
         break;
     }
+    #endif
 
+    #ifndef TXM_MUTEX_INFO_GET_CALL_NOT_USED
     case TXM_MUTEX_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_mutex_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_MUTEX_PERFORMANCE_INFO_GET_CALL_NOT_USED
     case TXM_MUTEX_PERFORMANCE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_mutex_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
     case TXM_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_mutex_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_MUTEX_PRIORITIZE_CALL_NOT_USED
     case TXM_MUTEX_PRIORITIZE_CALL:
     {
         return_value = _txm_module_manager_tx_mutex_prioritize_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_MUTEX_PUT_CALL_NOT_USED
     case TXM_MUTEX_PUT_CALL:
     {
         return_value = _txm_module_manager_tx_mutex_put_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_CREATE_CALL_NOT_USED
     case TXM_QUEUE_CREATE_CALL:
     {
         return_value = _txm_module_manager_tx_queue_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_DELETE_CALL_NOT_USED
     case TXM_QUEUE_DELETE_CALL:
     {
         return_value = _txm_module_manager_tx_queue_delete_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_FLUSH_CALL_NOT_USED
     case TXM_QUEUE_FLUSH_CALL:
     {
         return_value = _txm_module_manager_tx_queue_flush_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_FRONT_SEND_CALL_NOT_USED
     case TXM_QUEUE_FRONT_SEND_CALL:
     {
         return_value = _txm_module_manager_tx_queue_front_send_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_INFO_GET_CALL_NOT_USED
     case TXM_QUEUE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_queue_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_PERFORMANCE_INFO_GET_CALL_NOT_USED
     case TXM_QUEUE_PERFORMANCE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_queue_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
     case TXM_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_queue_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_PRIORITIZE_CALL_NOT_USED
     case TXM_QUEUE_PRIORITIZE_CALL:
     {
         return_value = _txm_module_manager_tx_queue_prioritize_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_RECEIVE_CALL_NOT_USED
     case TXM_QUEUE_RECEIVE_CALL:
     {
         return_value = _txm_module_manager_tx_queue_receive_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_SEND_CALL_NOT_USED
     case TXM_QUEUE_SEND_CALL:
     {
         return_value = _txm_module_manager_tx_queue_send_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_QUEUE_SEND_NOTIFY_CALL_NOT_USED
     case TXM_QUEUE_SEND_NOTIFY_CALL:
     {
         return_value = _txm_module_manager_tx_queue_send_notify_dispatch(module_instance, param_0, param_1);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_CEILING_PUT_CALL_NOT_USED
     case TXM_SEMAPHORE_CEILING_PUT_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_ceiling_put_dispatch(module_instance, param_0, param_1);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_CREATE_CALL_NOT_USED
     case TXM_SEMAPHORE_CREATE_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_DELETE_CALL_NOT_USED
     case TXM_SEMAPHORE_DELETE_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_delete_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_GET_CALL_NOT_USED
     case TXM_SEMAPHORE_GET_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_get_dispatch(module_instance, param_0, param_1);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_INFO_GET_CALL_NOT_USED
     case TXM_SEMAPHORE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_PERFORMANCE_INFO_GET_CALL_NOT_USED
     case TXM_SEMAPHORE_PERFORMANCE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
     case TXM_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_PRIORITIZE_CALL_NOT_USED
     case TXM_SEMAPHORE_PRIORITIZE_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_prioritize_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_PUT_CALL_NOT_USED
     case TXM_SEMAPHORE_PUT_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_put_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_SEMAPHORE_PUT_NOTIFY_CALL_NOT_USED
     case TXM_SEMAPHORE_PUT_NOTIFY_CALL:
     {
         return_value = _txm_module_manager_tx_semaphore_put_notify_dispatch(module_instance, param_0, param_1);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_CREATE_CALL_NOT_USED
     case TXM_THREAD_CREATE_CALL:
     {
         return_value = _txm_module_manager_tx_thread_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_DELETE_CALL_NOT_USED
     case TXM_THREAD_DELETE_CALL:
     {
         return_value = _txm_module_manager_tx_thread_delete_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_ENTRY_EXIT_NOTIFY_CALL_NOT_USED
     case TXM_THREAD_ENTRY_EXIT_NOTIFY_CALL:
     {
         return_value = _txm_module_manager_tx_thread_entry_exit_notify_dispatch(module_instance, param_0, param_1);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_IDENTIFY_CALL_NOT_USED
     case TXM_THREAD_IDENTIFY_CALL:
     {
         return_value = _txm_module_manager_tx_thread_identify_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_INFO_GET_CALL_NOT_USED
     case TXM_THREAD_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_thread_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_INTERRUPT_CONTROL_CALL_NOT_USED
     case TXM_THREAD_INTERRUPT_CONTROL_CALL:
     {
         return_value = _txm_module_manager_tx_thread_interrupt_control_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_PERFORMANCE_INFO_GET_CALL_NOT_USED
     case TXM_THREAD_PERFORMANCE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_thread_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
     case TXM_THREAD_PERFORMANCE_SYSTEM_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_thread_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_PREEMPTION_CHANGE_CALL_NOT_USED
     case TXM_THREAD_PREEMPTION_CHANGE_CALL:
     {
         return_value = _txm_module_manager_tx_thread_preemption_change_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_PRIORITY_CHANGE_CALL_NOT_USED
     case TXM_THREAD_PRIORITY_CHANGE_CALL:
     {
         return_value = _txm_module_manager_tx_thread_priority_change_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_RELINQUISH_CALL_NOT_USED
     case TXM_THREAD_RELINQUISH_CALL:
     {
         return_value = _txm_module_manager_tx_thread_relinquish_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_RESET_CALL_NOT_USED
     case TXM_THREAD_RESET_CALL:
     {
         return_value = _txm_module_manager_tx_thread_reset_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_RESUME_CALL_NOT_USED
     case TXM_THREAD_RESUME_CALL:
     {
         return_value = _txm_module_manager_tx_thread_resume_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_SLEEP_CALL_NOT_USED
     case TXM_THREAD_SLEEP_CALL:
     {
         return_value = _txm_module_manager_tx_thread_sleep_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_STACK_ERROR_NOTIFY_CALL_NOT_USED
     case TXM_THREAD_STACK_ERROR_NOTIFY_CALL:
     {
         return_value = _txm_module_manager_tx_thread_stack_error_notify_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_SUSPEND_CALL_NOT_USED
     case TXM_THREAD_SUSPEND_CALL:
     {
         return_value = _txm_module_manager_tx_thread_suspend_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_SYSTEM_SUSPEND_CALL_NOT_USED
     case TXM_THREAD_SYSTEM_SUSPEND_CALL:
     {
         return_value = _txm_module_manager_tx_thread_system_suspend_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_TERMINATE_CALL_NOT_USED
     case TXM_THREAD_TERMINATE_CALL:
     {
         return_value = _txm_module_manager_tx_thread_terminate_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_TIME_SLICE_CHANGE_CALL_NOT_USED
     case TXM_THREAD_TIME_SLICE_CHANGE_CALL:
     {
         return_value = _txm_module_manager_tx_thread_time_slice_change_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_THREAD_WAIT_ABORT_CALL_NOT_USED
     case TXM_THREAD_WAIT_ABORT_CALL:
     {
         return_value = _txm_module_manager_tx_thread_wait_abort_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIME_GET_CALL_NOT_USED
     case TXM_TIME_GET_CALL:
     {
         return_value = _txm_module_manager_tx_time_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIME_SET_CALL_NOT_USED
     case TXM_TIME_SET_CALL:
     {
         return_value = _txm_module_manager_tx_time_set_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIMER_ACTIVATE_CALL_NOT_USED
     case TXM_TIMER_ACTIVATE_CALL:
     {
         return_value = _txm_module_manager_tx_timer_activate_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIMER_CHANGE_CALL_NOT_USED
     case TXM_TIMER_CHANGE_CALL:
     {
         return_value = _txm_module_manager_tx_timer_change_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIMER_CREATE_CALL_NOT_USED
     case TXM_TIMER_CREATE_CALL:
     {
         return_value = _txm_module_manager_tx_timer_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIMER_DEACTIVATE_CALL_NOT_USED
     case TXM_TIMER_DEACTIVATE_CALL:
     {
         return_value = _txm_module_manager_tx_timer_deactivate_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIMER_DELETE_CALL_NOT_USED
     case TXM_TIMER_DELETE_CALL:
     {
         return_value = _txm_module_manager_tx_timer_delete_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIMER_INFO_GET_CALL_NOT_USED
     case TXM_TIMER_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_timer_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIMER_PERFORMANCE_INFO_GET_CALL_NOT_USED
     case TXM_TIMER_PERFORMANCE_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_timer_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_TIMER_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
     case TXM_TIMER_PERFORMANCE_SYSTEM_INFO_GET_CALL:
     {
         return_value = _txm_module_manager_tx_timer_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_BUFFER_FULL_NOTIFY_CALL_NOT_USED
     case TXM_TRACE_BUFFER_FULL_NOTIFY_CALL:
     {
         return_value = _txm_module_manager_tx_trace_buffer_full_notify_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_DISABLE_CALL_NOT_USED
     case TXM_TRACE_DISABLE_CALL:
     {
         return_value = _txm_module_manager_tx_trace_disable_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_ENABLE_CALL_NOT_USED
     case TXM_TRACE_ENABLE_CALL:
     {
         return_value = _txm_module_manager_tx_trace_enable_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_EVENT_FILTER_CALL_NOT_USED
     case TXM_TRACE_EVENT_FILTER_CALL:
     {
         return_value = _txm_module_manager_tx_trace_event_filter_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_EVENT_UNFILTER_CALL_NOT_USED
     case TXM_TRACE_EVENT_UNFILTER_CALL:
     {
         return_value = _txm_module_manager_tx_trace_event_unfilter_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_INTERRUPT_CONTROL_CALL_NOT_USED
     case TXM_TRACE_INTERRUPT_CONTROL_CALL:
     {
         return_value = _txm_module_manager_tx_trace_interrupt_control_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_ISR_ENTER_INSERT_CALL_NOT_USED
     case TXM_TRACE_ISR_ENTER_INSERT_CALL:
     {
         return_value = _txm_module_manager_tx_trace_isr_enter_insert_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_ISR_EXIT_INSERT_CALL_NOT_USED
     case TXM_TRACE_ISR_EXIT_INSERT_CALL:
     {
         return_value = _txm_module_manager_tx_trace_isr_exit_insert_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_TRACE_USER_EVENT_INSERT_CALL_NOT_USED
     case TXM_TRACE_USER_EVENT_INSERT_CALL:
     {
         return_value = _txm_module_manager_tx_trace_user_event_insert_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_MODULE_OBJECT_ALLOCATE_CALL_NOT_USED
     case TXM_MODULE_OBJECT_ALLOCATE_CALL:
     {
         return_value = _txm_module_manager_txm_module_object_allocate_dispatch(module_instance, param_0, param_1);
         break;
     }
+    #endif
 
+    #ifndef TXM_MODULE_OBJECT_DEALLOCATE_CALL_NOT_USED
     case TXM_MODULE_OBJECT_DEALLOCATE_CALL:
     {
         return_value = _txm_module_manager_txm_module_object_deallocate_dispatch(module_instance, param_0);
         break;
     }
+    #endif
 
+    #ifndef TXM_MODULE_OBJECT_POINTER_GET_CALL_NOT_USED
     case TXM_MODULE_OBJECT_POINTER_GET_CALL:
     {
         return_value = _txm_module_manager_txm_module_object_pointer_get_dispatch(module_instance, param_0, param_1, param_2);
         break;
     }
+    #endif
 
+    #ifndef TXM_MODULE_OBJECT_POINTER_GET_EXTENDED_CALL_NOT_USED
     case TXM_MODULE_OBJECT_POINTER_GET_EXTENDED_CALL:
     {
         return_value = _txm_module_manager_txm_module_object_pointer_get_extended_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
         break;
     }
+    #endif
 
     default:
     {

common_smp/inc/tx_api.h

@@ -26,7 +26,7 @@
 /*  APPLICATION INTERFACE DEFINITION                       RELEASE        */
 /*                                                                        */
 /*    tx_api.h                                            PORTABLE SMP    */
-/*                                                           6.1.5        */
+/*                                                           6.1.6        */
 /*  AUTHOR                                                                */
 /*                                                                        */
 /*    William E. Lamie, Microsoft Corporation                             */
@@ -55,6 +55,9 @@
 /*                                            add option to remove FileX  */
 /*                                            pointer, fix whitespace,    */
 /*                                            resulting in version 6.1.5  */
+/*  04-02-2021      Scott Larson            Modified comment(s), and      */
+/*                                            update patch number,        */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -94,7 +97,7 @@ extern   "C" {
 #define AZURE_RTOS_THREADX
 #define THREADX_MAJOR_VERSION           6
 #define THREADX_MINOR_VERSION           1
-#define THREADX_PATCH_VERSION           5
+#define THREADX_PATCH_VERSION           6
 
 /* Define the following symbol for backward compatibility */
 #define EL_PRODUCT_THREADX

ports/arc_em/metaware/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                       ARCv2_EM/MetaWare   */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -288,7 +291,7 @@ ULONG   _tx_misra_time_stamp_get(VOID);
    macros.  */
 
 
-#define TX_INTERRUPT_SAVE_AREA                  register unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _clri();
 #define TX_RESTORE                              _seti(interrupt_save);
@@ -308,7 +311,7 @@ ULONG   _tx_misra_time_stamp_get(VOID);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARCv2_EM/MetaWare Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARCv2_EM/MetaWare Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/arc_em/metaware/readme_threadx.txt

@@ -209,6 +209,18 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+            tx_initialize_low_level.s           Modified comments
+            tx_thread_context_restore.s         r25/r30 are caller saved
+            tx_thread_context_save.s            r25/r30 are caller saved
+            tx_thread_interrupt_control.s       Modified comments
+            tx_thread_schedule.s                fixed interrupt priority overwritting bug, 
+                                                and fixed hardware stack checker disable and reenable logic
+            tx_thread_stack_build.s             Modified comments
+            tx_thread_system_return.s           Modified comments
+            tx_timer_interrupt.s                remove unneeded load of _tx_thread_preempt_disable
+            
 09-30-2020  Initial ThreadX 6.1 for ARCv2 EM using MetaWare tools.
 
 

ports/arc_em/metaware/src/tx_initialize_low_level.s

@@ -8,33 +8,32 @@
 ;/*       and in the root directory of this software.                      */
 ;/*                                                                        */
 ;/**************************************************************************/
-;
+
-;
 ;/**************************************************************************/
 ;/**************************************************************************/
-;/**                                                                       */ 
+;/**                                                                       */
-;/** ThreadX Component                                                     */ 
+;/** ThreadX Component                                                     */
 ;/**                                                                       */
 ;/**   Initialize                                                          */
 ;/**                                                                       */
 ;/**************************************************************************/
 ;/**************************************************************************/
-;
+
     .equ    IRQ_SELECT,     0x40B
     .equ    KSTACK_TOP,     0x264
     .equ    KSTACK_BASE,    0x265
     .equ    STATUS32_SC,    0x4000
-;
+
 ;
 ;    /* Define section for placement after all linker allocated RAM memory. This
-;       is used to calculate the first free address that is passed to 
+;       is used to calculate the first free address that is passed to
 ;       tx_appication_define, soley for the ThreadX application's use.  */
 ;
     .section    ".free_memory","aw"
     .align  4
     .global     _tx_first_free_address
 _tx_first_free_address:
-    .space  4   
+    .space  4
 ;
 ;    /* Define section for placement before the main stack area for setting
 ;       up the STACK_TOP address for hardware stack checking.  */
@@ -53,54 +52,55 @@ _tx_system_stack_top_address:
     .global     _tx_system_stack_base_address
 _tx_system_stack_base_address:
     .space  4
-;
+
-;
     .text
-;/**************************************************************************/ 
+;/**************************************************************************/
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  FUNCTION                                               RELEASE        */ 
+;/*  FUNCTION                                               RELEASE        */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    _tx_initialize_low_level                        ARCv2_EM/MetaWare   */
-;/*                                                           6.1          */
+;/*                                                           6.1.6        */
 ;/*  AUTHOR                                                                */
 ;/*                                                                        */
 ;/*    William E. Lamie, Microsoft Corporation                             */
 ;/*                                                                        */
 ;/*  DESCRIPTION                                                           */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    This function is responsible for any low-level processor            */ 
+;/*    This function is responsible for any low-level processor            */
-;/*    initialization, including setting up interrupt vectors, setting     */ 
+;/*    initialization, including setting up interrupt vectors, setting     */
-;/*    up a periodic timer interrupt source, saving the system stack       */ 
+;/*    up a periodic timer interrupt source, saving the system stack       */
-;/*    pointer for use in ISR processing later, and finding the first      */ 
+;/*    pointer for use in ISR processing later, and finding the first      */
-;/*    available RAM memory address for tx_application_define.             */ 
+;/*    available RAM memory address for tx_application_define.             */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  INPUT                                                                 */ 
+;/*  INPUT                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  OUTPUT                                                                */ 
+;/*  OUTPUT                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLS                                                                 */ 
+;/*  CALLS                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLED BY                                                             */ 
+;/*  CALLED BY                                                             */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    _tx_initialize_kernel_enter           ThreadX entry function        */ 
+;/*    _tx_initialize_kernel_enter           ThreadX entry function        */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  RELEASE HISTORY                                                       */ 
+;/*  RELEASE HISTORY                                                       */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    DATE              NAME                      DESCRIPTION             */
 ;/*                                                                        */
 ;/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+;/*  04-02-2021     Andres Mlinar            Modified comments,            */
+;/*                                            resulting in version 6.1.6  */
 ;/*                                                                        */
 ;/**************************************************************************/
 ;VOID   _tx_initialize_low_level(VOID)
 ;{
     .global _tx_initialize_low_level
-    .type   _tx_initialize_low_level, @function 
+    .type   _tx_initialize_low_level, @function
 _tx_initialize_low_level:
 
     .ifdef  TX_ENABLE_HW_STACK_CHECKING
@@ -130,7 +130,7 @@ _tx_initialize_low_level:
 ;
 ;
 ;    /* Setup Timer 0 for periodic interrupts at interrupt vector 16.  */
-; 
+;
     mov     r0, 0                                       ; Disable additional ISR reg saving/restoring
     sr      r0, [AUX_IRQ_CTRL]                          ;
 
@@ -171,7 +171,7 @@ _tx_initialize_low_level:
 ;
 ;    /* Define default vector table entries.   */
 ;
-    .global _tx_memory_error        
+    .global _tx_memory_error
 _tx_memory_error:
     flag    1
     nop
@@ -179,7 +179,7 @@ _tx_memory_error:
     nop
     b       _tx_memory_error
 
-    .global _tx_instruction_error   
+    .global _tx_instruction_error
 _tx_instruction_error:
     flag    1
     nop
@@ -187,7 +187,7 @@ _tx_instruction_error:
     nop
     b       _tx_instruction_error
 
-    .global _tx_ev_machine_check    
+    .global _tx_ev_machine_check
 _tx_ev_machine_check:
     flag    1
     nop
@@ -195,7 +195,7 @@ _tx_ev_machine_check:
     nop
     b       _tx_ev_machine_check
 
-    .global _tx_ev_tblmiss_inst     
+    .global _tx_ev_tblmiss_inst
 _tx_ev_tblmiss_inst:
     flag    1
     nop
@@ -203,7 +203,7 @@ _tx_ev_tblmiss_inst:
     nop
     b       _tx_ev_tblmiss_inst
 
-    .global _tx_ev_tblmiss_data    
+    .global _tx_ev_tblmiss_data
 _tx_ev_tblmiss_data:
     flag    1
     nop
@@ -211,7 +211,7 @@ _tx_ev_tblmiss_data:
     nop
     b       _tx_ev_tblmiss_data
 
-    .global _tx_ev_protection_viol  
+    .global _tx_ev_protection_viol
 _tx_ev_protection_viol:
     flag    1
     nop
@@ -219,7 +219,7 @@ _tx_ev_protection_viol:
     nop
     b       _tx_ev_protection_viol
 
-    .global _tx_ev_privilege_viol   
+    .global _tx_ev_privilege_viol
 _tx_ev_privilege_viol:
     flag    1
     nop
@@ -227,7 +227,7 @@ _tx_ev_privilege_viol:
     nop
     b       _tx_ev_privilege_viol
 
-    .global _tx_ev_software_int     
+    .global _tx_ev_software_int
 _tx_ev_software_int:
     flag    1
     nop
@@ -235,7 +235,7 @@ _tx_ev_software_int:
     nop
     b       _tx_ev_software_int
 
-    .global _tx_ev_trap             
+    .global _tx_ev_trap
 _tx_ev_trap:
     flag    1
     nop
@@ -243,7 +243,7 @@ _tx_ev_trap:
     nop
     b       _tx_ev_trap
 
-    .global _tx_ev_extension        
+    .global _tx_ev_extension
 _tx_ev_extension:
     flag    1
     nop
@@ -251,7 +251,7 @@ _tx_ev_extension:
     nop
     b       _tx_ev_extension
 
-    .global _tx_ev_divide_by_zero   
+    .global _tx_ev_divide_by_zero
 _tx_ev_divide_by_zero:
     flag    1
     nop
@@ -259,7 +259,7 @@ _tx_ev_divide_by_zero:
     nop
     b       _tx_ev_divide_by_zero
 
-    .global _tx_ev_dc_error         
+    .global _tx_ev_dc_error
 _tx_ev_dc_error:
     flag    1
     nop
@@ -267,7 +267,7 @@ _tx_ev_dc_error:
     nop
     b       _tx_ev_dc_error
 
-    .global _tx_ev_maligned         
+    .global _tx_ev_maligned
 _tx_ev_maligned:
     flag    1
     nop
@@ -275,7 +275,7 @@ _tx_ev_maligned:
     nop
     b       _tx_ev_maligned
 
-    .global _tx_unsued_0            
+    .global _tx_unsued_0
 _tx_unsued_0:
     flag    1
     nop
@@ -283,7 +283,7 @@ _tx_unsued_0:
     nop
     b       _tx_unsued_0
 
-    .global _tx_unused_1            
+    .global _tx_unused_1
 _tx_unused_1:
     flag    1
     nop
@@ -291,7 +291,7 @@ _tx_unused_1:
     nop
     b       _tx_unused_1
 
-    .global _tx_timer_0             
+    .global _tx_timer_0
 _tx_timer_0:
 ;
 ;    /* By default, setup Timer 0 as the ThreadX timer interrupt.  */
@@ -311,7 +311,7 @@ _tx_timer_0:
 ;    nop
 ;    b       _tx_timer_0
 
-    .global _tx_timer_1             
+    .global _tx_timer_1
 _tx_timer_1:
     sub     sp, sp, 160                                 ; Allocate an interrupt stack frame
     st      blink, [sp, 16]                             ; Save blink
@@ -333,7 +333,7 @@ _tx_timer_1:
 ;    nop
 ;    b       _tx_timer_1
 
-    .global _tx_undefined_0         
+    .global _tx_undefined_0
 _tx_undefined_0:
     flag    1
     nop
@@ -341,7 +341,7 @@ _tx_undefined_0:
     nop
     b       _tx_undefined_0
 
-    .global _tx_undefined_1         
+    .global _tx_undefined_1
 _tx_undefined_1:
     flag    1
     nop
@@ -349,7 +349,7 @@ _tx_undefined_1:
     nop
     b       _tx_undefined_1
 
-    .global _tx_undefined_2         
+    .global _tx_undefined_2
 _tx_undefined_2:
     flag    1
     nop

ports/arc_em/metaware/src/tx_thread_context_restore.s

@@ -8,77 +8,70 @@
 ;/*       and in the root directory of this software.                      */
 ;/*                                                                        */
 ;/**************************************************************************/
-;
+
-;
+
 ;/**************************************************************************/
 ;/**************************************************************************/
-;/**                                                                       */ 
+;/**                                                                       */
-;/** ThreadX Component                                                     */ 
+;/** ThreadX Component                                                     */
 ;/**                                                                       */
 ;/**   Thread                                                              */
 ;/**                                                                       */
 ;/**************************************************************************/
 ;/**************************************************************************/
-;
+
-;
-;#define TX_SOURCE_CODE
-;
     .equ    BTA, 0x412
     .equ    KSTACK_TOP,     0x264
     .equ    KSTACK_BASE,    0x265
     .equ    STATUS32_SC,    0x4000
-;
+
-;/* Include necessary system files.  */
+;/**************************************************************************/
-;
+;/*                                                                        */
-;#include "tx_api.h"
+;/*  FUNCTION                                               RELEASE        */
-;#include "tx_thread.h"
+;/*                                                                        */
-;#include "tx_timer.h"
-;
-;
-;/**************************************************************************/ 
-;/*                                                                        */ 
-;/*  FUNCTION                                               RELEASE        */ 
-;/*                                                                        */ 
 ;/*    _tx_thread_context_restore                      ARCv2_EM/MetaWare   */
-;/*                                                           6.1          */
+;/*                                                           6.1.6        */
 ;/*  AUTHOR                                                                */
 ;/*                                                                        */
 ;/*    William E. Lamie, Microsoft Corporation                             */
 ;/*                                                                        */
 ;/*  DESCRIPTION                                                           */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    This function restores the interrupt context if it is processing a  */ 
+;/*    This function restores the interrupt context if it is processing a  */
-;/*    nested interrupt.  If not, it returns to the interrupt thread if no */ 
+;/*    nested interrupt.  If not, it returns to the interrupt thread if no */
-;/*    preemption is necessary.  Otherwise, if preemption is necessary or  */ 
+;/*    preemption is necessary.  Otherwise, if preemption is necessary or  */
-;/*    if no thread was running, the function returns to the scheduler.    */ 
+;/*    if no thread was running, the function returns to the scheduler.    */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  INPUT                                                                 */ 
+;/*  INPUT                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  OUTPUT                                                                */ 
+;/*  OUTPUT                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLS                                                                 */ 
+;/*  CALLS                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    _tx_thread_schedule                   Thread scheduling routine     */ 
+;/*    _tx_thread_schedule                   Thread scheduling routine     */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLED BY                                                             */ 
+;/*  CALLED BY                                                             */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    ISRs                                  Interrupt Service Routines    */ 
+;/*    ISRs                                  Interrupt Service Routines    */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  RELEASE HISTORY                                                       */ 
+;/*  RELEASE HISTORY                                                       */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    DATE              NAME                      DESCRIPTION             */
 ;/*                                                                        */
 ;/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+;/*  04-02-2021     Andres Mlinar            Modified comment(s), and      */
+;/*                                            r25/r30 are caller saved,   */
+;/*                                            resulting in version 6.1.6  */
 ;/*                                                                        */
 ;/**************************************************************************/
 ;VOID   _tx_thread_context_restore(VOID)
 ;{
     .global _tx_thread_context_restore
-    .type   _tx_thread_context_restore, @function 
+    .type   _tx_thread_context_restore, @function
 _tx_thread_context_restore:
 ;
 ;    /* Note: it is assumed that the stack pointer is in the same position now as
@@ -109,7 +102,7 @@ _tx_thread_context_restore:
 ;
 ;    /* Interrupts are nested.  */
 ;
-;    /* Just recover the saved registers and return to the point of 
+;    /* Just recover the saved registers and return to the point of
 ;       interrupt.  */
 ;
 
@@ -119,7 +112,7 @@ __tx_thread_nested_restore:
     sr      r0, [LP_START]                              ; Restore LP_START
     ld      r1, [sp, 8]                                 ; Recover LP_END
     sr      r1, [LP_END]                                ; Restore LP_END
-    ld      r2, [sp, 12]                                ; Recover LP_COUNT 
+    ld      r2, [sp, 12]                                ; Recover LP_COUNT
     mov     LP_COUNT, r2
     ld      r2, [sp, 156]                               ; Pickup BTA
     sr      r2, [BTA]                                   ; Recover BTA
@@ -128,6 +121,7 @@ __tx_thread_nested_restore:
     ld      r59, [sp, 144]                              ; Recover r59
     .endif
     ld      blink, [sp, 16]                             ; Recover blink
+    ld      r25, [sp, 32]                               ; Recover r25
     ld      r12, [sp, 84]                               ; Recover r12
     ld      r11, [sp, 88]                               ; Recover r11
     ld      r10, [sp, 92]                               ; Recover r10
@@ -140,8 +134,9 @@ __tx_thread_nested_restore:
     ld      r3,  [sp, 120]                              ; Recover r3
     ld      r2,  [sp, 124]                              ; Recover r2
     ld      r1,  [sp, 128]                              ; Recover r1
-    ld      r0, [sp, 132]                               ; Recover r0
+    ld      r0,  [sp, 132]                              ; Recover r0
-    add     sp, sp, 160                                 ; Recover interrupt stack frame 
+    ld      r30, [sp, 136]                              ; Recover r30
+    add     sp, sp, 160                                 ; Recover interrupt stack frame
     rtie                                                ; Return from interrupt
 ;
 ;
@@ -149,7 +144,7 @@ __tx_thread_nested_restore:
 __tx_thread_not_nested_restore:
 ;
 ;    /* Determine if a thread was interrupted and no preemption is required.  */
-;    else if (((_tx_thread_current_ptr) && (_tx_thread_current_ptr == _tx_thread_execute_ptr) 
+;    else if (((_tx_thread_current_ptr) && (_tx_thread_current_ptr == _tx_thread_execute_ptr)
 ;               || (_tx_thread_preempt_disable))
 ;    {
 ;
@@ -207,6 +202,7 @@ __tx_thread_no_preempt_restore:
     ld      r59, [sp, 144]                              ; Recover r59
     .endif
     ld      blink, [sp, 16]                             ; Recover blink
+    ld      r25, [sp, 32]                               ; Recover r25
     ld      r12, [sp, 84]                               ; Recover r12
     ld      r11, [sp, 88]                               ; Recover r11
     ld      r10, [sp, 92]                               ; Recover r10
@@ -220,6 +216,7 @@ __tx_thread_no_preempt_restore:
     ld      r2,  [sp, 124]                              ; Recover r2
     ld      r1,  [sp, 128]                              ; Recover r1
     ld      r0,  [sp, 132]                              ; Recover r0
+    ld      r30, [sp, 136]                              ; Recover r30
     add     sp, sp, 160                                 ; Recover interrupt stack frame
     rtie                                                ; Return from interrupt
 ;

ports/arc_em/metaware/src/tx_thread_context_save.s

@@ -8,76 +8,68 @@
 ;/*       and in the root directory of this software.                      */
 ;/*                                                                        */
 ;/**************************************************************************/
-;
+
-;
 ;/**************************************************************************/
 ;/**************************************************************************/
-;/**                                                                       */ 
+;/**                                                                       */
-;/** ThreadX Component                                                     */ 
+;/** ThreadX Component                                                     */
 ;/**                                                                       */
 ;/**   Thread                                                              */
 ;/**                                                                       */
 ;/**************************************************************************/
 ;/**************************************************************************/
-;
+
-;
-;#define TX_SOURCE_CODE
-;
     .equ    BTA, 0x412
     .equ    KSTACK_TOP,     0x264
     .equ    KSTACK_BASE,    0x265
     .equ    STATUS32_SC,    0x4000
-;
+
-;/* Include necessary system files.  */
+;/**************************************************************************/
-;
+;/*                                                                        */
-;#include "tx_api.h"
+;/*  FUNCTION                                               RELEASE        */
-;#include "tx_thread.h"
+;/*                                                                        */
-;#include "tx_timer.h"
-;
-;
-;/**************************************************************************/ 
-;/*                                                                        */ 
-;/*  FUNCTION                                               RELEASE        */ 
-;/*                                                                        */ 
 ;/*    _tx_thread_context_save                         ARCv2_EM/MetaWare   */
-;/*                                                           6.1          */
+;/*                                                           6.1.6        */
 ;/*  AUTHOR                                                                */
 ;/*                                                                        */
 ;/*    William E. Lamie, Microsoft Corporation                             */
 ;/*                                                                        */
 ;/*  DESCRIPTION                                                           */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    This function saves the context of an executing thread in the       */ 
+;/*    This function saves the context of an executing thread in the       */
-;/*    beginning of interrupt processing.  The function also ensures that  */ 
+;/*    beginning of interrupt processing.  The function also ensures that  */
-;/*    the system stack is used upon return to the calling ISR.            */ 
+;/*    the system stack is used upon return to the calling ISR.            */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  INPUT                                                                 */ 
+;/*  INPUT                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  OUTPUT                                                                */ 
+;/*  OUTPUT                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLS                                                                 */ 
+;/*  CALLS                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLED BY                                                             */ 
+;/*  CALLED BY                                                             */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    ISRs                                                                */ 
+;/*    ISRs                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  RELEASE HISTORY                                                       */ 
+;/*  RELEASE HISTORY                                                       */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    DATE              NAME                      DESCRIPTION             */
 ;/*                                                                        */
 ;/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+;/*  04-02-2021     Andres Mlinar            Modified comment(s), and      */
+;/*                                            r25/r30 are caller saved,   */
+;/*                                            resulting in version 6.1.6  */
 ;/*                                                                        */
 ;/**************************************************************************/
 ;VOID   _tx_thread_context_save(VOID)
 ;{
     .global _tx_thread_context_save
-    .type   _tx_thread_context_save, @function 
+    .type   _tx_thread_context_save, @function
 _tx_thread_context_save:
 ;
 ;    /* Upon entry to this routine, it is assumed that an interrupt stack frame
@@ -106,6 +98,8 @@ _tx_thread_context_save:
 ;      calling ISR.  */
 ;
 __tx_thread_nested_save:                                ; Label is for special nested interrupt case from idle system save below
+    st      r30, [sp, 136]                              ; Save r30
+    st      r25, [sp, 32]                               ; Save r25
     st      r12, [sp, 84]                               ; Save r12
     st      r11, [sp, 88]                               ; Save r11
     st      r10, [sp, 92]                               ; Save r10
@@ -114,7 +108,7 @@ __tx_thread_nested_save:                                ; Label is for special n
     st      r7,  [sp, 104]                              ; Save r7
     st      r6,  [sp, 108]                              ; Save r6
     st      r5,  [sp, 112]                              ; Save r5
-    st      r4,  [sp, 116]                              ; Save r6
+    st      r4,  [sp, 116]                              ; Save r4
     lr      r10, [LP_START]                             ; Pickup LP_START
     lr      r9,  [LP_END]                               ; Pickup LP_END
     st      LP_COUNT, [sp, 12]                          ; Save LP_COUNT
@@ -156,6 +150,8 @@ __tx_thread_not_nested_save:
     add     r0, r0, 1                                   ; Increment the nested interrupt count
     st      r0, [gp, _tx_thread_system_state@sda]       ; Update system state
     ld      r1, [gp, _tx_thread_current_ptr@sda]        ; Pickup current thread pointer
+    st      r30, [sp, 136]                              ; Save r30
+    st      r25, [sp, 32]                               ; Save r25
     st      r12, [sp, 84]                               ; Save r12
     st      r11, [sp, 88]                               ; Save r11
     breq    r1, 0, __tx_thread_idle_system_save         ; If no thread is running, idle system was
@@ -247,13 +243,15 @@ __tx_thread_idle_system_save:
     lr      r0, [AUX_IRQ_ACT]                           ; Pickup the interrupt active register
     neg     r1, r0                                      ; Negate
     and     r1, r0, r1                                  ; See if there are any other interrupts present
-    brne    r0, r1, __tx_thread_nested_save             ; If more interrupts, go into the nested interrupt save logic
+    breq    r0, r1, __tx_thread_not_nested
+    j __tx_thread_nested_save                           ; If more interrupts, go into the nested interrupt save logic
+__tx_thread_not_nested:
 ;
-;    /* Not much to do here, just adjust the stack pointer, and return to  
+;    /* Not much to do here, just adjust the stack pointer, and return to
 ;       ISR processing.  */
 ;
     j_s.d   [blink]                                     ; Return to ISR
-    add     sp, sp, 160                                 ; Recover stack space 
+    add     sp, sp, 160                                 ; Recover stack space
 ;
 ;    }
 ;}

ports/arc_em/metaware/src/tx_thread_interrupt_control.s

@@ -8,69 +8,61 @@
 ;/*       and in the root directory of this software.                      */
 ;/*                                                                        */
 ;/**************************************************************************/
-;
+
-;
 ;/**************************************************************************/
 ;/**************************************************************************/
-;/**                                                                       */ 
+;/**                                                                       */
-;/** ThreadX Component                                                     */ 
+;/** ThreadX Component                                                     */
 ;/**                                                                       */
 ;/**   Thread                                                              */
 ;/**                                                                       */
 ;/**************************************************************************/
 ;/**************************************************************************/
-;
+
-;#define TX_SOURCE_CODE
+;/**************************************************************************/
-;
+;/*                                                                        */
-;
+;/*  FUNCTION                                               RELEASE        */
-;/* Include necessary system files.  */
+;/*                                                                        */
-;
-;#include "tx_api.h"
-;#include "tx_thread.h"
-;
-;
-;/**************************************************************************/ 
-;/*                                                                        */ 
-;/*  FUNCTION                                               RELEASE        */ 
-;/*                                                                        */ 
 ;/*    _tx_thread_interrupt_control                    ARCv2_EM/MetaWare   */
-;/*                                                           6.1          */
+;/*                                                           6.1.6        */
 ;/*  AUTHOR                                                                */
 ;/*                                                                        */
 ;/*    William E. Lamie, Microsoft Corporation                             */
 ;/*                                                                        */
 ;/*  DESCRIPTION                                                           */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    This function is responsible for changing the interrupt lockout     */ 
+;/*    This function is responsible for changing the interrupt lockout     */
-;/*    posture of the system.                                              */ 
+;/*    posture of the system.                                              */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  INPUT                                                                 */ 
+;/*  INPUT                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    new_posture                           New interrupt lockout posture */ 
+;/*    new_posture                           New interrupt lockout posture */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  OUTPUT                                                                */ 
+;/*  OUTPUT                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    old_posture                           Old interrupt lockout posture */ 
+;/*    old_posture                           Old interrupt lockout posture */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLS                                                                 */ 
+;/*  CALLS                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLED BY                                                             */ 
+;/*  CALLED BY                                                             */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    Application Code                                                    */ 
+;/*    Application Code                                                    */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  RELEASE HISTORY                                                       */ 
+;/*  RELEASE HISTORY                                                       */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    DATE              NAME                      DESCRIPTION             */
 ;/*                                                                        */
 ;/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+;/*  04-02-2021     Andres Mlinar            Modified comments,            */
+;/*                                            resulting in version 6.1.6  */
 ;/*                                                                        */
 ;/**************************************************************************/
 ;UINT   _tx_thread_interrupt_control(UINT new_posture)
 ;{
     .global _tx_thread_interrupt_control
-    .type   _tx_thread_interrupt_control, @function 
+    .type   _tx_thread_interrupt_control, @function
 _tx_thread_interrupt_control:
 ;
 ;    /* Pickup current interrupt lockout posture.  */

ports/arc_em/metaware/src/tx_thread_schedule.s

@@ -8,73 +8,67 @@
 ;/*       and in the root directory of this software.                      */
 ;/*                                                                        */
 ;/**************************************************************************/
-;
+
-;
 ;/**************************************************************************/
 ;/**************************************************************************/
-;/**                                                                       */ 
+;/**                                                                       */
-;/** ThreadX Component                                                     */ 
+;/** ThreadX Component                                                     */
 ;/**                                                                       */
 ;/**   Thread                                                              */
 ;/**                                                                       */
 ;/**************************************************************************/
 ;/**************************************************************************/
-;
+
-;
-;#define TX_SOURCE_CODE
-;
-;
     .equ    BTA, 0x412
     .equ    KSTACK_TOP,     0x264
     .equ    KSTACK_BASE,    0x265
     .equ    STATUS32_SC,    0x4000
-;
+
-;/* Include necessary system files.  */
+;/**************************************************************************/
-;
+;/*                                                                        */
-;#include "tx_api.h"
+;/*  FUNCTION                                               RELEASE        */
-;#include "tx_thread.h"
+;/*                                                                        */
-;#include "tx_timer.h"
-;
-;
-;/**************************************************************************/ 
-;/*                                                                        */ 
-;/*  FUNCTION                                               RELEASE        */ 
-;/*                                                                        */ 
 ;/*    _tx_thread_schedule                             ARCv2_EM/MetaWare   */
-;/*                                                           6.1          */
+;/*                                                           6.1.6        */
 ;/*  AUTHOR                                                                */
 ;/*                                                                        */
 ;/*    William E. Lamie, Microsoft Corporation                             */
 ;/*                                                                        */
 ;/*  DESCRIPTION                                                           */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    This function waits for a thread control block pointer to appear in */ 
+;/*    This function waits for a thread control block pointer to appear in */
-;/*    the _tx_thread_execute_ptr variable.  Once a thread pointer appears */ 
+;/*    the _tx_thread_execute_ptr variable.  Once a thread pointer appears */
-;/*    in the variable, the corresponding thread is resumed.               */ 
+;/*    in the variable, the corresponding thread is resumed.               */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  INPUT                                                                 */ 
+;/*  INPUT                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
-;/*                                                                        */ 
-;/*  OUTPUT                                                                */ 
-;/*                                                                        */ 
 ;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLS                                                                 */ 
+;/*  OUTPUT                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLED BY                                                             */ 
+;/*  CALLS                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    _tx_initialize_kernel_enter          ThreadX entry function         */ 
+;/*    None                                                                */
-;/*    _tx_thread_system_return             Return to system from thread   */ 
+;/*                                                                        */
-;/*    _tx_thread_context_restore           Restore thread's context       */ 
+;/*  CALLED BY                                                             */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  RELEASE HISTORY                                                       */ 
+;/*    _tx_initialize_kernel_enter          ThreadX entry function         */
-;/*                                                                        */ 
+;/*    _tx_thread_system_return             Return to system from thread   */
+;/*    _tx_thread_context_restore           Restore thread's context       */
+;/*                                                                        */
+;/*  RELEASE HISTORY                                                       */
+;/*                                                                        */
 ;/*    DATE              NAME                      DESCRIPTION             */
 ;/*                                                                        */
 ;/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+;/*  04-02-2021     Andres Mlinar              Modified comment(s), and    */
+;/*                                            fixed interrupt priority    */
+;/*                                            overwritting bug, and       */
+;/*                                            fixed hardware stack checker*/
+;/*                                            disable and reenable logic, */
+;/*                                            resulting in version 6.1.6  */
 ;/*                                                                        */
 ;/**************************************************************************/
 ;VOID   _tx_thread_schedule(VOID)
@@ -85,8 +79,13 @@ _tx_thread_schedule:
 ;
 ;    /* Enable interrupts.  */
 ;
-    mov     r0, 0x1F                                    ; Build enable interrupt value
+    seti    0                                           ; Enable interrupts without changing threshold level
-    seti    r0                                          ; Enable interrupts
+
+    .ifdef  TX_ENABLE_HW_STACK_CHECKING
+    lr      r2, [status32]                              ; Pickup current STATUS32
+    and     r2, r2, ~STATUS32_SC                        ; Clear the hardware stack checking enable bit (SC)
+    kflag   r2                                          ; Disable hardware stack checking
+    .endif
 ;
 ;    /* Wait for a thread to execute.  */
 ;    do
@@ -99,7 +98,7 @@ __tx_thread_schedule_loop:
 ;
 ;    }
 ;    while(_tx_thread_execute_ptr == TX_NULL);
-;    
+;
 ;    /* Yes! We have a thread to execute.  Lockout interrupts and
 ;       transfer control to it.  */
 ;
@@ -118,16 +117,6 @@ __tx_thread_schedule_loop:
     ld      r4, [r0, 24]                                ; Pickup time-slice for this thread
     add     r3, r3, 1                                   ; Increment run counter
     st      r3, [r0, 4]                                 ; Store the new run counter
-
-    .ifdef  TX_ENABLE_HW_STACK_CHECKING
-    lr      r2, [status32]                              ; Pickup current STATUS32
-    and     r2, r2, ~STATUS32_SC                        ; Clear the hardware stack checking enable bit (SC)
-    kflag   r2                                          ; Disable hardware stack checking
-    ld      r3, [r0, 12]                                ; Pickup the top of the thread's stack (lowest address)
-    sr		r3, [KSTACK_TOP]                            ; Setup KSTACK_TOP
-    ld      r3, [r0, 16]                                ; Pickup the base of the thread's stack (highest address)
-    sr      r3, [KSTACK_BASE]                           ; Setup KSTACK_BASE
-    .endif
 ;
 ;    /* Setup time-slice, if present.  */
 ;    _tx_timer_time_slice =  _tx_thread_current_ptr -> tx_thread_time_slice;
@@ -135,6 +124,10 @@ __tx_thread_schedule_loop:
     ld      sp, [r0, 8]                                 ; Switch to thread's stack
 
     .ifdef  TX_ENABLE_HW_STACK_CHECKING
+    ld      r3, [r0, 12]                                ; Pickup the top of the thread's stack (lowest address)
+    sr      r3, [KSTACK_TOP]                            ; Setup KSTACK_TOP
+    ld      r3, [r0, 16]                                ; Pickup the base of the thread's stack (highest address)
+    sr      r3, [KSTACK_BASE]                           ; Setup KSTACK_BASE
     or      r2, r2, STATUS32_SC                         ; Or in hardware stack checking enable bit (SC)
     kflag   r2                                          ; Enable hardware stack checking
     .endif
@@ -176,8 +169,8 @@ __tx_thread_schedule_loop:
     ld      r13, [sp, 64]                               ; Recover r13
     ld      r1,  [sp, 68]                               ; Pickup status32
     ld      r30, [sp, 72]                               ; Recover r30
-    add     sp, sp, 76                                  ; Recover solicited stack frame 
+    add     sp, sp, 76                                  ; Recover solicited stack frame
-    j_s.d   [blink]                                     ; Return to thread and restore flags 
+    j_s.d   [blink]                                     ; Return to thread and restore flags
     seti    r1                                          ; Recover STATUS32
 ;
 __tx_thread_schedule_int_ret:
@@ -189,7 +182,7 @@ __tx_thread_schedule_int_ret:
     sr      r0, [LP_START]                              ; Restore LP_START
     ld      r1, [sp, 8]                                 ; Recover LP_END
     sr      r1, [LP_END]                                ; Restore LP_END
-    ld      r2, [sp, 12]                                ; Recover LP_COUNT      
+    ld      r2, [sp, 12]                                ; Recover LP_COUNT
     mov     LP_COUNT, r2
     ld      r0, [sp, 156]                               ; Pickup saved BTA
     sr      r0, [BTA]                                   ; Recover BTA
@@ -230,7 +223,7 @@ __tx_thread_schedule_int_ret:
     .endif
     add     sp, sp, 160                                 ; Recover interrupt stack frame
     rtie                                                ; Return to point of interrupt
-   
+
 ;
 ;}
 ;

ports/arc_em/metaware/src/tx_thread_stack_build.s

@@ -8,70 +8,60 @@
 ;/*       and in the root directory of this software.                      */
 ;/*                                                                        */
 ;/**************************************************************************/
-;
+
-;
 ;/**************************************************************************/
 ;/**************************************************************************/
-;/**                                                                       */ 
+;/**                                                                       */
-;/** ThreadX Component                                                     */ 
+;/** ThreadX Component                                                     */
 ;/**                                                                       */
 ;/**   Thread                                                              */
 ;/**                                                                       */
 ;/**************************************************************************/
 ;/**************************************************************************/
-;
+
-;
+    .equ    LONG_ALIGN_MASK, 0xFFFFFFFC
-;#define TX_SOURCE_CODE
-;
-;
-;/* Include necessary system files.  */
-;
-;#include "tx_api.h"
-;#include "tx_thread.h"
-;
-;
-    .equ    LONG_ALIGN_MASK, 0xFFFFFFFC     
     .equ    INT_ENABLE_BITS, 0x8000001E
-;
+
-;
+;/**************************************************************************/
-;/**************************************************************************/ 
+;/*                                                                        */
-;/*                                                                        */ 
+;/*  FUNCTION                                               RELEASE        */
-;/*  FUNCTION                                               RELEASE        */ 
+;/*                                                                        */
-;/*                                                                        */ 
 ;/*    _tx_thread_stack_build                          ARCv2_EM/MetaWare   */
-;/*                                                           6.1          */
+;/*                                                           6.1.6        */
 ;/*  AUTHOR                                                                */
 ;/*                                                                        */
 ;/*    William E. Lamie, Microsoft Corporation                             */
 ;/*                                                                        */
 ;/*  DESCRIPTION                                                           */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    This function builds a stack frame on the supplied thread's stack.  */
 ;/*    The stack frame results in a fake interrupt return to the supplied  */
-;/*    function pointer.                                                   */ 
+;/*    function pointer.                                                   */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  INPUT                                                                 */ 
+;/*  INPUT                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    thread_ptr                            Pointer to thread control blk */
 ;/*    function_ptr                          Pointer to return function    */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  OUTPUT                                                                */ 
+;/*  OUTPUT                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLS                                                                 */ 
+;/*  CALLS                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLED BY                                                             */ 
+;/*  CALLED BY                                                             */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    _tx_thread_create                     Create thread service         */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  RELEASE HISTORY                                                       */ 
+;/*  RELEASE HISTORY                                                       */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    DATE              NAME                      DESCRIPTION             */
 ;/*                                                                        */
 ;/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+;/*  04-02-2021     Andres Mlinar            Modified comments,            */
+;/*                                            resulting in version 6.1.6  */
 ;/*                                                                        */
 ;/**************************************************************************/
 ;VOID   _tx_thread_stack_build(TX_THREAD *thread_ptr, VOID (*function_ptr)(VOID))
@@ -80,11 +70,11 @@
     .type   _tx_thread_stack_build, @function
 _tx_thread_stack_build:
 ;
-;       
+;
 ;    /* Build a fake interrupt frame.  The form of the fake interrupt stack
 ;       on the ARCv2 EM should look like the following after it is built.
 ;       Note that the extension registers are always assigned space here.
-;       
+;
 ;       Stack Top:      1           Interrupt stack frame type
 ;                       LP_START    Initial loop start
 ;                       LP_END      Initial loop end
@@ -119,7 +109,7 @@ _tx_thread_stack_build:
 ;                       r2          Initial r2
 ;                       r1          Initial r1
 ;                       r0          Initial r0
-;                       r30         Initial r30 
+;                       r30         Initial r30
 ;                       r58         Initial r58
 ;                       r59         Initial r59
 ;                       0           Reserved
@@ -127,10 +117,10 @@ _tx_thread_stack_build:
 ;                       0           Initial BTA
 ;                       0           Point of Interrupt (thread entry point)
 ;                       0           Initial STATUS32
-;                       0           Backtrace 
+;                       0           Backtrace
-;                       0           Backtrace 
+;                       0           Backtrace
-;                       0           Backtrace 
+;                       0           Backtrace
-;                       0           Backtrace 
+;                       0           Backtrace
 ;
 ; *: these registers will only be saved and restored if flag -Xxmac_d16 is passed to hcac
 ;
@@ -179,19 +169,19 @@ _tx_thread_stack_build:
     st      r5, [r3, 128]                               ; Store initial r1
     st      r5, [r3, 132]                               ; Store initial r0
     st      r5, [r3, 136]                               ; Store initial r30
-    st      r5, [r3, 140]                               ; Store initial r58 
+    st      r5, [r3, 140]                               ; Store initial r58
     st      r5, [r3, 144]                               ; Store initial r59
     st      r5, [r3, 148]                               ; Reserved
     st      r5, [r3, 152]                               ; Reserved
     st      r5, [r3, 156]                               ; Store initial BTA
-    st      r1, [r3, 160]                               ; Store initial point of entry 
+    st      r1, [r3, 160]                               ; Store initial point of entry
     lr      r6, [status32]                              ; Pickup STATUS32
     or      r6, r6, INT_ENABLE_BITS                     ; Make sure interrupts are enabled
     st      r6, [r3, 164]                               ; Store initial STATUS32
-    st      r5, [r3, 168]                               ; Backtrace 0 
+    st      r5, [r3, 168]                               ; Backtrace 0
-    st      r5, [r3, 172]                               ; Backtrace 0 
+    st      r5, [r3, 172]                               ; Backtrace 0
-    st      r5, [r3, 176]                               ; Backtrace 0 
+    st      r5, [r3, 176]                               ; Backtrace 0
-    st      r5, [r3, 180]                               ; Backtrace 0 
+    st      r5, [r3, 180]                               ; Backtrace 0
 ;
 ;    /* Setup stack pointer.  */
 ;    thread_ptr -> tx_thread_stack_ptr =  r3;

ports/arc_em/metaware/src/tx_thread_system_return.s

@@ -8,69 +8,61 @@
 ;/*       and in the root directory of this software.                      */
 ;/*                                                                        */
 ;/**************************************************************************/
-;
+
-;
 ;/**************************************************************************/
 ;/**************************************************************************/
-;/**                                                                       */ 
+;/**                                                                       */
-;/** ThreadX Component                                                     */ 
+;/** ThreadX Component                                                     */
 ;/**                                                                       */
 ;/**   Thread                                                              */
 ;/**                                                                       */
 ;/**************************************************************************/
 ;/**************************************************************************/
-;
+
-;#define TX_SOURCE_CODE
-;
     .equ    KSTACK_TOP,     0x264
     .equ    KSTACK_BASE,    0x265
     .equ    STATUS32_SC,    0x4000
-;
+
-;/* Include necessary system files.  */
+;/**************************************************************************/
-;
+;/*                                                                        */
-;#include "tx_api.h"
+;/*  FUNCTION                                               RELEASE        */
-;#include "tx_thread.h"
+;/*                                                                        */
-;#include "tx_timer.h"
-;
-;
-;/**************************************************************************/ 
-;/*                                                                        */ 
-;/*  FUNCTION                                               RELEASE        */ 
-;/*                                                                        */ 
 ;/*    _tx_thread_system_return                        ARCv2_EM/MetaWare   */
-;/*                                                           6.1          */
+;/*                                                           6.1.6        */
 ;/*  AUTHOR                                                                */
 ;/*                                                                        */
 ;/*    William E. Lamie, Microsoft Corporation                             */
 ;/*                                                                        */
 ;/*  DESCRIPTION                                                           */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    This function is target processor specific.  It is used to transfer */ 
+;/*    This function is target processor specific.  It is used to transfer */
-;/*    control from a thread back to the ThreadX system.  Only a           */ 
+;/*    control from a thread back to the ThreadX system.  Only a           */
-;/*    minimal context is saved since the compiler assumes temp registers  */ 
+;/*    minimal context is saved since the compiler assumes temp registers  */
-;/*    are going to get slicked by a function call anyway.                 */ 
+;/*    are going to get slicked by a function call anyway.                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  INPUT                                                                 */ 
+;/*  INPUT                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  OUTPUT                                                                */ 
+;/*  OUTPUT                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLS                                                                 */ 
+;/*  CALLS                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    _tx_thread_schedule                   Thread scheduling loop        */ 
+;/*    _tx_thread_schedule                   Thread scheduling loop        */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLED BY                                                             */ 
+;/*  CALLED BY                                                             */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    ThreadX components                                                  */ 
+;/*    ThreadX components                                                  */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  RELEASE HISTORY                                                       */ 
+;/*  RELEASE HISTORY                                                       */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    DATE              NAME                      DESCRIPTION             */
 ;/*                                                                        */
 ;/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+;/*  04-02-2021     Andres Mlinar            Modified comments,            */
+;/*                                            resulting in version 6.1.6  */
 ;/*                                                                        */
 ;/**************************************************************************/
 ;VOID   _tx_thread_system_return(VOID)
@@ -105,7 +97,7 @@ _tx_thread_system_return:
     st      r13, [sp, 64]                               ; Save r13
     st      r2,  [sp, 68]                               ; Save status32
     st      r30, [sp, 72]                               ; Save r30
-;   
+;
     .ifdef TX_ENABLE_EXECUTION_CHANGE_NOTIFY
 ;
 ;    /* Call the thread exit function to indicate the thread is no longer executing.  */

ports/arc_em/metaware/src/tx_timer_interrupt.s

@@ -8,32 +8,21 @@
 ;/*       and in the root directory of this software.                      */
 ;/*                                                                        */
 ;/**************************************************************************/
-;
+
-;
 ;/**************************************************************************/
 ;/**************************************************************************/
-;/**                                                                       */ 
+;/**                                                                       */
-;/** ThreadX Component                                                     */ 
+;/** ThreadX Component                                                     */
 ;/**                                                                       */
 ;/**   Timer                                                               */
 ;/**                                                                       */
 ;/**************************************************************************/
 ;/**************************************************************************/
-;
+
-;#define TX_SOURCE_CODE
+;/**************************************************************************/
-;
+;/*                                                                        */
-;
+;/*  FUNCTION                                               RELEASE        */
-;/* Include necessary system files.  */
+;/*                                                                        */
-;
-;#include "tx_api.h"
-;#include "tx_timer.h"
-;#include "tx_thread.h"
-;
-;
-;/**************************************************************************/ 
-;/*                                                                        */ 
-;/*  FUNCTION                                               RELEASE        */ 
-;/*                                                                        */ 
 ;/*    _tx_timer_interrupt                             ARCv2_EM/MetaWare   */
 ;/*                                                           6.1.3        */
 ;/*  AUTHOR                                                                */
@@ -41,34 +30,34 @@
 ;/*    William E. Lamie, Microsoft Corporation                             */
 ;/*                                                                        */
 ;/*  DESCRIPTION                                                           */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    This function processes the hardware timer interrupt.  This         */ 
+;/*    This function processes the hardware timer interrupt.  This         */
-;/*    processing includes incrementing the system clock and checking for  */ 
+;/*    processing includes incrementing the system clock and checking for  */
-;/*    time slice and/or timer expiration.  If either is found, the        */ 
+;/*    time slice and/or timer expiration.  If either is found, the        */
-;/*    interrupt context save/restore functions are called along with the  */ 
+;/*    interrupt context save/restore functions are called along with the  */
-;/*    expiration functions.                                               */ 
+;/*    expiration functions.                                               */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  INPUT                                                                 */ 
+;/*  INPUT                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  OUTPUT                                                                */ 
+;/*  OUTPUT                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    None                                                                */ 
+;/*    None                                                                */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLS                                                                 */ 
+;/*  CALLS                                                                 */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    _tx_timer_expiration_process          Process timer expiration      */ 
+;/*    _tx_timer_expiration_process          Process timer expiration      */
-;/*    _tx_thread_time_slice                 Time slice interrupted thread */ 
+;/*    _tx_thread_time_slice                 Time slice interrupted thread */
-;/*    _tx_thread_context_save               Save interrupt context        */ 
+;/*    _tx_thread_context_save               Save interrupt context        */
-;/*    _tx_thread_context_restore            Restore interrupt context     */ 
+;/*    _tx_thread_context_restore            Restore interrupt context     */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  CALLED BY                                                             */ 
+;/*  CALLED BY                                                             */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*    interrupt vector                                                    */ 
+;/*    interrupt vector                                                    */
-;/*                                                                        */ 
+;/*                                                                        */
-;/*  RELEASE HISTORY                                                       */ 
+;/*  RELEASE HISTORY                                                       */
-;/*                                                                        */ 
+;/*                                                                        */
 ;/*    DATE              NAME                      DESCRIPTION             */
 ;/*                                                                        */
 ;/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
@@ -81,7 +70,7 @@
 ;VOID   _tx_timer_interrupt(VOID)
 ;{
     .global _tx_timer_interrupt
-    .type   _tx_timer_interrupt, @function 
+    .type   _tx_timer_interrupt, @function
 _tx_timer_interrupt:
 ;
 ;    /* Upon entry to this routine, it is assumed the interrupt stack frame has
@@ -132,7 +121,7 @@ __tx_timer_no_time_slice:
 ;
     ld      r0, [gp, _tx_timer_current_ptr@sda]         ; Pickup current timer pointer
     ld      r2, [r0, 0]                                 ; Pickup examine actual list entry
-    breq    r2, 0, __tx_timer_no_timer                         ; 
+    breq    r2, 0, __tx_timer_no_timer                         ;
                                                         ; If NULL, no timer has expired, just move to the next entry
 ;
 ;        /* Set expiration flag.  */
@@ -220,7 +209,7 @@ __tx_timer_dont_activate:
 ;
 __tx_timer_not_ts_expiration:
 ;
-    st      0, [gp, _tx_timer_expired_time_slice@sda]  
+    st      0, [gp, _tx_timer_expired_time_slice@sda]
     b       _tx_thread_context_restore                  ; Go restore interrupt context..
                                                         ; ..clearing time-slice expired flag
                                                         ; Note that we don't return from
@@ -233,9 +222,9 @@ __tx_timer_nothing_expired:
     ld      r0, [sp, 0]                                 ; Recover r0
     ld      r1, [sp, 4]                                 ; Recover r1
     ld      r2, [sp, 8]                                 ; Recover r2
-    add     sp, sp, 160                                 ; Recover interrupt stack frame 
+    add     sp, sp, 160                                 ; Recover interrupt stack frame
     rtie                                                ; Return to point of interrupt
 ;
 ;}
     .end
-    
+

ports/arc_hs/metaware/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         ARC_HS/MetaWare   */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -288,7 +291,7 @@ ULONG   _tx_misra_time_stamp_get(VOID);
    macros.  */
 
 
-#define TX_INTERRUPT_SAVE_AREA                  register unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _clri();
 #define TX_RESTORE                              _seti(interrupt_save);
@@ -322,7 +325,7 @@ VOID  tx_thread_register_bank_assign(VOID *thread_ptr, UINT register_bank);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARC_HS/MetaWare Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARC_HS/MetaWare Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/arc_hs/metaware/readme_threadx.txt

@@ -241,6 +241,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 for ARC HS using MetaWare tools.
 
 

ports/arm11/ac5/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                           ARM11/AC5       */ 
-/*                                                            6.1         */
+/*                                                            6.1.6       */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -265,7 +268,7 @@ typedef unsigned short                          USHORT;
 
 #ifndef __thumb
 
-#define TX_INTERRUPT_SAVE_AREA                  register unsigned int interrupt_save_disabled;
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save_disabled;
 
 #ifdef  TX_ENABLE_FIQ_SUPPORT
 
@@ -296,7 +299,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -317,7 +320,7 @@ unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM11/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM11/AC5 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/arm11/ac5/readme_threadx.txt

@@ -524,6 +524,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A5 using AC5 tools.
 
 

ports/arm11/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                           ARM11/GNU       */ 
-/*                                                            6.1         */
+/*                                                            6.1.6       */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; ORR %1,%0,#0xC0; MSR CPSR_cxsf,%1 ": "=r" (interrupt_save), "=r" (tx_temp) );
@@ -306,7 +309,7 @@ unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM11/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM11/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/arm11/gnu/readme_threadx.txt

@@ -486,6 +486,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for ARM11 using GNU tools.
 
 

ports/arm11/iar/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                           ARM11/IAR       */ 
-/*                                                           6.1          */ 
+/*                                                           6.1.6        */ 
 /*                                                                        */
 /*  AUTHOR                                                                */ 
 /*                                                                        */ 
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */ 
 /*                                                                        */ 
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */ 
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */ 
+/*                                            macro definition,           */ 
+/*                                            resulting in version 6.1.6  */ 
 /*                                                                        */ 
 /**************************************************************************/ 
 
@@ -334,9 +337,9 @@ __intrinsic void          __set_CPSR( unsigned long );
 
 
 #if (__VER__ < 8002000)
-#define TX_INTERRUPT_SAVE_AREA      unsigned long interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      ULONG interrupt_save;
 #else
-#define TX_INTERRUPT_SAVE_AREA      unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      UINT interrupt_save;
 #endif
 
 #define TX_DISABLE                  interrupt_save =  __get_CPSR(); \
@@ -372,7 +375,7 @@ void  _tx_thread_interrupt_restore(UINT old_posture);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM11/IAR Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM11/IAR Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/arm11/iar/readme_threadx.txt

@@ -517,6 +517,9 @@ The project options "General Options -> Library Configuration" should also have
 
 11.  Revision History
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for ARM11 using IAR's ARM tools.
 
 

ports/arm9/ac5/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                            ARM9/AC5       */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -267,7 +270,7 @@ typedef unsigned short                          USHORT;
    macros.  */
 
 #ifndef __thumb
-#define TX_INTERRUPT_SAVE_AREA                  register unsigned int interrupt_save_disabled;
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save_disabled;
 
 #ifdef  TX_ENABLE_FIQ_SUPPORT
 
@@ -298,7 +301,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -319,7 +322,7 @@ unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX  ARM9/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX  ARM9/AC5 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/arm9/ac5/readme_threadx.txt

@@ -508,6 +508,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for ARM9 using AC5 tools.
 
 

ports/arm9/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                            ARM9/GNU       */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; ORR %1,%0,#0xC0; MSR CPSR_cxsf,%1 ": "=r" (interrupt_save), "=r" (tx_temp) );
@@ -306,7 +309,7 @@ unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM9/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM9/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/arm9/gnu/readme_threadx.txt

@@ -486,6 +486,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for ARM9 using GNU tools.
 
 

ports/arm9/iar/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                           ARM9/IAR        */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -334,9 +337,9 @@ __intrinsic void          __set_CPSR( unsigned long );
 
 
 #if (__VER__ < 8002000)
-#define TX_INTERRUPT_SAVE_AREA      unsigned long interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      ULONG interrupt_save;
 #else
-#define TX_INTERRUPT_SAVE_AREA      unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      UINT interrupt_save;
 #endif
 
 #define TX_DISABLE                  interrupt_save =  __get_CPSR(); \
@@ -372,7 +375,7 @@ void  _tx_thread_interrupt_restore(UINT old_posture);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM9/IAR Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX ARM9/IAR Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/arm9/iar/readme_threadx.txt

@@ -518,6 +518,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX version 6.1 for ARM9 using IAR's ARM tools.
 
 

ports/c667x/ccs/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                           C667x/TI        */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -237,7 +240,7 @@ typedef unsigned short                          USHORT;
    is used to define a local function save area for the disable and restore
    macros.  */
 
-#define TX_INTERRUPT_SAVE_AREA      unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA     UINT interrupt_save;
 
 #ifdef TX_SKIP_INTRINSICS
 unsigned int  _tx_thread_interrupt_control(unsigned int);
@@ -264,7 +267,7 @@ unsigned int  _tx_thread_interrupt_control(unsigned int);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX C667x/TI Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX C667x/TI Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/c667x/ccs/readme_threadx.txt

@@ -238,6 +238,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for TMS320C667x using TI Code Composer tools.
 
 

ports/cortex_a15/ac6/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A15/AC6    */ 
-/*                                                            6.1         */
+/*                                                            6.1.6       */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A15/AC6 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A15/AC6 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a15/ac6/readme_threadx.txt

@@ -332,6 +332,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A15 using AC6 tools.
 
 

ports/cortex_a15/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A15/GNU    */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A15/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A15/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a15/gnu/readme_threadx.txt

@@ -503,6 +503,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A15 using GNU tools.
 
 

ports/cortex_a15/iar/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A15/IAR    */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -336,9 +339,9 @@ __intrinsic void          __set_CPSR( unsigned long );
 
 
 #if (__VER__ < 8002000)
-#define TX_INTERRUPT_SAVE_AREA      unsigned long interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      ULONG interrupt_save;
 #else
-#define TX_INTERRUPT_SAVE_AREA      unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      UINT interrupt_save;
 #endif
 
 
@@ -382,7 +385,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A15/IAR Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A15/IAR Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/cortex_a15/iar/readme_threadx.txt

@@ -534,6 +534,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX version 6.1 for Cortex-A15 using IAR's ARM tools.
 
 

ports/cortex_a35/ac6/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A35/AC6    */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -311,7 +314,7 @@ unsigned long long temp;
 }
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 #define TX_DISABLE                              interrupt_save =  __disable_interrupts();
 #define TX_RESTORE                              __restore_interrupts(interrupt_save);
 
@@ -321,7 +324,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -354,7 +357,7 @@ VOID    tx_thread_fp_disable(VOID);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A35/AC6 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A35/AC6 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a35/ac6/readme_threadx.txt

@@ -243,6 +243,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A35 using AC6 tools.
 
 

ports/cortex_a35/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A35/GNU    */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -311,7 +314,7 @@ unsigned long long temp;
 }
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 #define TX_DISABLE                              interrupt_save =  __disable_interrupts();
 #define TX_RESTORE                              __restore_interrupts(interrupt_save);
 
@@ -321,7 +324,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -354,7 +357,7 @@ VOID    tx_thread_fp_disable(VOID);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A35/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A35/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a35/gnu/readme_threadx.txt

@@ -243,6 +243,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A35 using GCC tools.
 
 

ports/cortex_a5/ac5/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                          Cortex-A5/AC5    */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -265,7 +268,7 @@ typedef unsigned short                          USHORT;
 
 #ifndef __thumb
 
-#define TX_INTERRUPT_SAVE_AREA                  register unsigned int interrupt_save_disabled;
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save_disabled;
 
 #ifdef  TX_ENABLE_FIQ_SUPPORT
 
@@ -296,7 +299,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -324,7 +327,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX  Cortex-A5/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX  Cortex-A5/AC5 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a5/ac5/readme_threadx.txt

@@ -535,6 +535,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A5 using AC5 tools.
 
 

ports/cortex_a5/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A5/GNU     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A5/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A5/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a5/gnu/readme_threadx.txt

@@ -503,6 +503,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A5 using GNU tools.
 
 

ports/cortex_a5/green/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                     Cortex-A5/Green Hills */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -299,7 +302,7 @@ typedef unsigned short                          USHORT;
 unsigned int                    _tx_thread_interrupt_disable(void);
 void                            _tx_thread_interrupt_restore(unsigned int new_posture);
 
-#define TX_INTERRUPT_SAVE_AREA                  register int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register INT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save = _tx_thread_interrupt_disable();
 
@@ -307,7 +310,7 @@ void                            _tx_thread_interrupt_restore(unsigned int new_po
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA                  register int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register INT interrupt_save;
 
 #if defined(__GHS_VERSION_NUMBER) && (__GHS_VERSION_NUMBER >= 350)
 
@@ -391,8 +394,8 @@ void    tx_thread_vfp_disable(void);
 /* Define the version ID of ThreadX.  This may be utilized by the application.  */
 
 #ifdef TX_THREAD_INIT
-CHAR                            _tx_version_id[] = 
+CHAR                            _tx_version_id[] =
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A5/Green Hills Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A5/Green Hills Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a5/green/readme_threadx.txt

@@ -517,6 +517,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 05/19/2020  Initial ThreadX version of Cortex-A5/Green Hills port. 
 
 

ports/cortex_a5/iar/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A5/IAR     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -335,9 +338,9 @@ __intrinsic void          __set_CPSR( unsigned long );
 
 
 #if (__VER__ < 8002000)
-#define TX_INTERRUPT_SAVE_AREA      unsigned long interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      ULONG interrupt_save;
 #else
-#define TX_INTERRUPT_SAVE_AREA      unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      UINT interrupt_save;
 #endif
 
 #define TX_DISABLE                  interrupt_save =  __get_CPSR(); \
@@ -380,7 +383,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A5/IAR Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A5/IAR Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/cortex_a5/iar/readme_threadx.txt

@@ -534,6 +534,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX version 6.1 for Cortex-A5 using IAR's ARM tools.
 
 

ports/cortex_a5x/ac6/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A5x/ARM    */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -311,7 +314,7 @@ unsigned long long temp;
 }
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 #define TX_DISABLE                              interrupt_save =  __disable_interrupts();
 #define TX_RESTORE                              __restore_interrupts(interrupt_save);
 
@@ -321,7 +324,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -354,7 +357,7 @@ VOID    tx_thread_fp_disable(VOID);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A5x/ARM Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A5x/ARM Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a5x/ac6/readme_threadx.txt

@@ -245,6 +245,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A5x using ARM tools.
 
 

ports/cortex_a7/ac5/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A7/AC5     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -265,7 +268,7 @@ typedef unsigned short                          USHORT;
 
 #ifndef __thumb
 
-#define TX_INTERRUPT_SAVE_AREA                  register unsigned int interrupt_save_disabled;
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save_disabled;
 
 #ifdef  TX_ENABLE_FIQ_SUPPORT
 
@@ -296,7 +299,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -324,7 +327,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/AC5 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a7/ac5/readme_threadx.txt

@@ -534,6 +534,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A7 using AC5 tools.
 
 

ports/cortex_a7/ac6/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A7/AC6     */ 
-/*                                                            6.1         */
+/*                                                            6.1.6       */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/AC6 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/AC6 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a7/ac6/readme_threadx.txt

@@ -332,6 +332,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A7 using AC6 tools.
 
 

ports/cortex_a7/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A7/GNU     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a7/gnu/readme_threadx.txt

@@ -503,6 +503,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A7 using GNU tools.
 
 

ports/cortex_a7/green/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                     Cortex-A7/Green Hills */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -299,7 +302,7 @@ typedef unsigned short                          USHORT;
 unsigned int                    _tx_thread_interrupt_disable(void);
 void                            _tx_thread_interrupt_restore(unsigned int new_posture);
 
-#define TX_INTERRUPT_SAVE_AREA                  register int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register INT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save = _tx_thread_interrupt_disable();
 
@@ -307,7 +310,7 @@ void                            _tx_thread_interrupt_restore(unsigned int new_po
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA                  register int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register INT interrupt_save;
 
 #if defined(__GHS_VERSION_NUMBER) && (__GHS_VERSION_NUMBER >= 350)
 
@@ -391,8 +394,8 @@ void    tx_thread_vfp_disable(void);
 /* Define the version ID of ThreadX.  This may be utilized by the application.  */
 
 #ifdef TX_THREAD_INIT
-CHAR                            _tx_version_id[] = 
+CHAR                            _tx_version_id[] =
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/Green Hills Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/Green Hills Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a7/green/readme_threadx.txt

@@ -517,6 +517,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 05/19/2020  Initial ThreadX version of Cortex-A7/Green Hills port. 
 
 

ports/cortex_a7/iar/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A7/IAR     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -335,9 +338,9 @@ __intrinsic void          __set_CPSR( unsigned long );
 
 
 #if (__VER__ < 8002000)
-#define TX_INTERRUPT_SAVE_AREA      unsigned long interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      ULONG interrupt_save;
 #else
-#define TX_INTERRUPT_SAVE_AREA      unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      UINT interrupt_save;
 #endif
 
 #define TX_DISABLE                  interrupt_save =  __get_CPSR(); \
@@ -380,7 +383,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/IAR Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A7/IAR Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a7/iar/readme_threadx.txt

@@ -534,6 +534,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX version 6.1 for Cortex-A7 using IAR's ARM tools.
 
 

ports/cortex_a8/ac5/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                          Cortex-A8/AC5    */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -265,7 +268,7 @@ typedef unsigned short                          USHORT;
 
 #ifndef __thumb
 
-#define TX_INTERRUPT_SAVE_AREA                  register unsigned int interrupt_save_disabled;
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save_disabled;
 
 #ifdef  TX_ENABLE_FIQ_SUPPORT
 
@@ -296,7 +299,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -324,7 +327,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX  Cortex-A8/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX  Cortex-A8/AC5 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a8/ac5/readme_threadx.txt

@@ -537,6 +537,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A8 using AC5 tools.
 
 

ports/cortex_a8/ac6/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A8/AC6     */ 
-/*                                                            6.1         */
+/*                                                            6.1.6       */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A8/AC6 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A8/AC6 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a8/ac6/readme_threadx.txt

@@ -329,6 +329,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A8 using AC6 tools.
 
 

ports/cortex_a8/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A8/GNU     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A8/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A8/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a8/gnu/readme_threadx.txt

@@ -503,6 +503,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A8 using GNU tools.
 
 

ports/cortex_a8/green/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                     Cortex-A8/Green Hills */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -299,7 +302,7 @@ typedef unsigned short                          USHORT;
 unsigned int                    _tx_thread_interrupt_disable(void);
 void                            _tx_thread_interrupt_restore(unsigned int new_posture);
 
-#define TX_INTERRUPT_SAVE_AREA                  register int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register INT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save = _tx_thread_interrupt_disable();
 
@@ -307,7 +310,7 @@ void                            _tx_thread_interrupt_restore(unsigned int new_po
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA                  register int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register INT interrupt_save;
 
 #if defined(__GHS_VERSION_NUMBER) && (__GHS_VERSION_NUMBER >= 350)
 
@@ -391,8 +394,8 @@ void    tx_thread_vfp_disable(void);
 /* Define the version ID of ThreadX.  This may be utilized by the application.  */
 
 #ifdef TX_THREAD_INIT
-CHAR                            _tx_version_id[] = 
+CHAR                            _tx_version_id[] =
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A8/Green Hills Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A8/Green Hills Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a8/green/readme_threadx.txt

@@ -518,6 +518,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 05/19/2020  Initial ThreadX version of Cortex-A8/Green Hills port. 
 
 

ports/cortex_a8/iar/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A8/IAR     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -335,9 +338,9 @@ __intrinsic void          __set_CPSR( unsigned long );
 
 
 #if (__VER__ < 8002000)
-#define TX_INTERRUPT_SAVE_AREA      unsigned long interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      ULONG interrupt_save;
 #else
-#define TX_INTERRUPT_SAVE_AREA      unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      UINT interrupt_save;
 #endif
 
 
@@ -381,7 +384,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A8/IAR Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A8/IAR Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/cortex_a8/iar/readme_threadx.txt

@@ -534,6 +534,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX version 6.1 for Cortex-A8 using IAR's ARM tools.
 
 

ports/cortex_a9/ac5/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                          Cortex-A9/AC5    */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -265,7 +268,7 @@ typedef unsigned short                          USHORT;
 
 #ifndef __thumb
 
-#define TX_INTERRUPT_SAVE_AREA                  register unsigned int interrupt_save_disabled;
+#define TX_INTERRUPT_SAVE_AREA                  register UINT interrupt_save_disabled;
 
 #ifdef  TX_ENABLE_FIQ_SUPPORT
 
@@ -296,7 +299,7 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  _tx_thread_interrupt_disable();
 #define TX_RESTORE                              _tx_thread_interrupt_restore(interrupt_save);
@@ -324,7 +327,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX  Cortex-A9/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX  Cortex-A9/AC5 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a9/ac5/readme_threadx.txt

@@ -535,6 +535,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A9 using AC5 tools.
 
 

ports/cortex_a9/ac6/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A9/AC6     */ 
-/*                                                            6.1         */
+/*                                                            6.1.6       */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A9/AC6 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A9/AC6 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a9/ac6/readme_threadx.txt

@@ -332,6 +332,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A9 using AC6 tools.
 
 

ports/cortex_a9/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A9/GNU     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -272,14 +275,14 @@ unsigned int   _tx_thread_interrupt_disable(void);
 unsigned int   _tx_thread_interrupt_restore(UINT old_posture);
 
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  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                  unsigned int interrupt_save, tx_temp;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save, tx_temp;
 
 #ifdef TX_ENABLE_FIQ_SUPPORT
 #define TX_DISABLE                              asm volatile (" MRS %0,CPSR; CPSID if ": "=r" (interrupt_save) );
@@ -313,7 +316,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A9/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A9/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a9/gnu/readme_threadx.txt

@@ -503,6 +503,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX 6.1 version for Cortex-A9 using GNU tools.
 
 

ports/cortex_a9/green/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                     Cortex-A9/Green Hills */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -299,7 +302,7 @@ typedef unsigned short                          USHORT;
 unsigned int                    _tx_thread_interrupt_disable(void);
 void                            _tx_thread_interrupt_restore(unsigned int new_posture);
 
-#define TX_INTERRUPT_SAVE_AREA                  register int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register INT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save = _tx_thread_interrupt_disable();
 
@@ -307,7 +310,7 @@ void                            _tx_thread_interrupt_restore(unsigned int new_po
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA                  register int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  register INT interrupt_save;
 
 #if defined(__GHS_VERSION_NUMBER) && (__GHS_VERSION_NUMBER >= 350)
 
@@ -391,8 +394,8 @@ void    tx_thread_vfp_disable(void);
 /* Define the version ID of ThreadX.  This may be utilized by the application.  */
 
 #ifdef TX_THREAD_INIT
-CHAR                            _tx_version_id[] = 
+CHAR                            _tx_version_id[] =
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A9/Green Hills Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A9/Green Hills Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_a9/green/readme_threadx.txt

@@ -517,6 +517,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 05/19/2020  Initial ThreadX version of Cortex-A9/Green Hills port. 
 
 

ports/cortex_a9/iar/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */ 
 /*                                                                        */ 
 /*    tx_port.h                                         Cortex-A9/IAR     */ 
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -336,9 +339,9 @@ __intrinsic void          __set_CPSR( unsigned long );
 
 
 #if (__VER__ < 8002000)
-#define TX_INTERRUPT_SAVE_AREA      unsigned long interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      ULONG interrupt_save;
 #else
-#define TX_INTERRUPT_SAVE_AREA      unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA      UINT interrupt_save;
 #endif
 
 
@@ -382,7 +385,7 @@ void    tx_thread_vfp_disable(void);
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A9/IAR Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-A9/IAR Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/cortex_a9/iar/readme_threadx.txt

@@ -534,6 +534,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 09-30-2020  Initial ThreadX version 6.1 for Cortex-A9 using IAR's ARM tools.
 
 

ports/cortex_m0/ac5/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */
 /*                                                                        */
 /*    tx_port.h                                         Cortex-M0/AC5     */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -288,7 +291,7 @@ VOID                                            _tx_thread_interrupt_restore(UIN
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int  was_masked;
+#define TX_INTERRUPT_SAVE_AREA                  UINT was_masked;
 #define TX_DISABLE                              was_masked = __disable_irq();
 #define TX_RESTORE                              if (was_masked == 0) __enable_irq();
 
@@ -318,7 +321,7 @@ unsigned int          was_masked;
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/AC5 Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/cortex_m0/ac5/readme_threadx.txt

@@ -133,6 +133,10 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+            tx_thread_schedule.s                Fix compilation error
+
 03-02-2021  The following files were changed/added for version 6.1.5:
             tx_thread_schedule.s            Added low power feature
 

ports/cortex_m0/ac6/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */
 /*                                                                        */
 /*    tx_port.h                                         Cortex-M0/AC6     */
-/*                                                            6.1         */
+/*                                                            6.1.6       */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -335,7 +338,7 @@ unsigned int interrupt_save;
 }
 
 
-#define TX_INTERRUPT_SAVE_AREA  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  __disable_interrupts();
 #define TX_RESTORE                              __restore_interrupts(interrupt_save);
@@ -348,7 +351,7 @@ unsigned int interrupt_save;
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save = _tx_thread_interrupt_control(TX_INT_DISABLE);
 #define TX_RESTORE                              _tx_thread_interrupt_control(interrupt_save);
@@ -359,7 +362,7 @@ unsigned int interrupt_save;
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/AC6 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/AC6 Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_m0/ac6/readme_threadx.txt

@@ -148,6 +148,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 03-02-2021  The following files were changed/added for version 6.1.5:
             tx_thread_schedule.s            Added low power feature
 

ports/cortex_m0/gnu/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */
 /*                                                                        */
 /*    tx_port.h                                         Cortex-M0/GNU     */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -50,6 +50,9 @@
 /*  05-19-2020     William E. Lamie         Initial Version 6.0           */
 /*  09-30-2020     William E. Lamie         Modified comment(s),          */
 /*                                            resulting in version 6.1    */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -337,7 +340,7 @@ unsigned int interrupt_save;
 }
 
 
-#define TX_INTERRUPT_SAVE_AREA  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  __disable_interrupts();
 #define TX_RESTORE                              __restore_interrupts(interrupt_save);
@@ -350,7 +353,7 @@ unsigned int interrupt_save;
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save = _tx_thread_interrupt_control(TX_INT_DISABLE);
 #define TX_RESTORE                              _tx_thread_interrupt_control(interrupt_save);
@@ -361,7 +364,7 @@ unsigned int interrupt_save;
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/GNU Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/GNU Version 6.1.6 *";
 #else
 extern  CHAR                    _tx_version_id[];
 #endif

ports/cortex_m0/gnu/readme_threadx.txt

@@ -145,6 +145,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 03-02-2021  The following files were changed/added for version 6.1.5:
             tx_thread_schedule.s            Added low power feature
 

ports/cortex_m0/iar/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */
 /*                                                                        */
 /*    tx_port.h                                         Cortex-M0/IAR     */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -349,7 +352,7 @@ __istate_t interrupt_save;
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/IAR Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/IAR Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/cortex_m0/iar/readme_threadx.txt

@@ -148,6 +148,9 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+
 03-02-2021  The following files were changed/added for version 6.1.5:
             tx_thread_schedule.s            Added low power feature
 

ports/cortex_m0/keil/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */
 /*                                                                        */
 /*    tx_port.h                                         Cortex-M0/AC5     */
-/*                                                            6.1         */
+/*                                                            6.1.6       */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -288,7 +291,7 @@ VOID                                            _tx_thread_interrupt_restore(UIN
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int  was_masked;
+#define TX_INTERRUPT_SAVE_AREA                  UINT was_masked;
 #define TX_DISABLE                              was_masked = __disable_irq();
 #define TX_RESTORE                              if (was_masked == 0) __enable_irq();
 
@@ -318,7 +321,7 @@ unsigned int          was_masked;
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M0/AC5 Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/cortex_m0/keil/readme_threadx.txt

@@ -139,6 +139,10 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+            tx_thread_schedule.s                Fix compilation error
+
 03-02-2021  The following files were changed/added for version 6.1.5:
             tx_thread_schedule.s            Added low power feature
 

ports/cortex_m23/ac5/inc/tx_port.h

@@ -26,7 +26,7 @@
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */
 /*                                                                        */
 /*    tx_port.h                                         Cortex-M23/AC5    */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*                                                                        */
 /*  AUTHOR                                                                */
 /*                                                                        */
@@ -48,6 +48,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020     Scott Larson             Initial Version 6.1           */
+/*  04-02-2021     Bhupendra Naphade        Modified comment(s),updated   */
+/*                                            macro definition,           */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -377,7 +380,7 @@ VOID                                            _tx_thread_interrupt_restore(UIN
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int  was_masked;
+#define TX_INTERRUPT_SAVE_AREA                  UINT was_masked;
 #define TX_DISABLE                              was_masked = __disable_irq();
 #define TX_RESTORE                              if (was_masked == 0) __enable_irq();
 
@@ -406,7 +409,7 @@ unsigned int          was_masked;
 
 #ifdef TX_THREAD_INIT
 CHAR                            _tx_version_id[] = 
-                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M23/AC5 Version 6.1 *";
+                                    "Copyright (c) Microsoft Corporation. All rights reserved.  *  ThreadX Cortex-M23/AC5 Version 6.1.6 *";
 #else
 #ifdef TX_MISRA_ENABLE
 extern  CHAR                    _tx_version_id[100];

ports/cortex_m23/ac5/readme_threadx.txt

@@ -143,6 +143,8 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
 
 09-30-2020  Initial ThreadX 6.1 version for Cortex-M23 using AC5 tools.
 

ports/cortex_m23/ac6/inc/tx_port.h

@@ -381,7 +381,7 @@ VOID                                            _tx_thread_interrupt_restore(UIN
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA                  unsigned int  was_masked;
+#define TX_INTERRUPT_SAVE_AREA                  UINT was_masked;
 #define TX_DISABLE                              was_masked = __disable_irq();
 #define TX_RESTORE                              if (was_masked == 0) __enable_irq();
 

ports/cortex_m23/ac6/readme_threadx.txt

@@ -145,6 +145,12 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+            tx_thread_schedule.s                Added low power support
+
+03-02-2021  The following files were changed/added for version 6.1.5:
+            tx_port.h                       Added ULONG64_DEFINED
 
 09-30-2020  Initial ThreadX 6.1 version for Cortex-M23 using AC6 tools.
 

ports/cortex_m23/ac6/src/tx_thread_schedule.s

@@ -26,7 +26,7 @@
 /*  FUNCTION                                               RELEASE        */
 /*                                                                        */
 /*    _tx_thread_schedule                               Cortex-M23/AC6    */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*  AUTHOR                                                                */
 /*                                                                        */
 /*    Scott Larson, Microsoft Corporation                                 */
@@ -59,6 +59,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020      Scott Larson            Initial Version 6.1           */
+/*  04-02-2021      Scott Larson            Modified comment(s), added    */
+/*                                            low power code,             */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 // VOID   _tx_thread_schedule(VOID)
@@ -253,11 +256,25 @@ __tx_ts_wait:
     LDR     r1, [r2]                                // Pickup the next thread to execute pointer
     STR     r1, [r0]                                // Store it in the current pointer
     CBNZ    r1, __tx_ts_ready                       // If non-NULL, a new thread is ready!
+
+#ifdef TX_LOW_POWER
+    PUSH    {r0-r3}
+    BL      tx_low_power_enter                      // Possibly enter low power mode
+    POP     {r0-r3}
+#endif
+
 #ifdef TX_ENABLE_WFI
     DSB                                             // Ensure no outstanding memory transactions
     WFI                                             // Wait for interrupt
     ISB                                             // Ensure pipeline is flushed
 #endif
+
+#ifdef TX_LOW_POWER
+    PUSH    {r0-r3}
+    BL      tx_low_power_exit                       // Exit low power mode
+    POP     {r0-r3}
+#endif
+
     CPSIE   i                                       // Enable interrupts
     B       __tx_ts_wait                            // Loop to continue waiting
 

ports/cortex_m23/gnu/inc/tx_port.h

@@ -416,7 +416,7 @@ unsigned int interrupt_save;
 }
 
 
-#define TX_INTERRUPT_SAVE_AREA  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save =  __disable_interrupts();
 #define TX_RESTORE                              __restore_interrupts(interrupt_save);
@@ -429,7 +429,7 @@ unsigned int interrupt_save;
 
 #else
 
-#define TX_INTERRUPT_SAVE_AREA  unsigned int interrupt_save;
+#define TX_INTERRUPT_SAVE_AREA                  UINT interrupt_save;
 
 #define TX_DISABLE                              interrupt_save = _tx_thread_interrupt_control(TX_INT_DISABLE);
 #define TX_RESTORE                              _tx_thread_interrupt_control(interrupt_save);

ports/cortex_m23/gnu/readme_threadx.txt

@@ -128,10 +128,16 @@ For generic code revision information, please refer to the readme_threadx_generi
 file, which is included in your distribution. The following details the revision
 information associated with this specific port of ThreadX:
 
+04-02-2021  Release 6.1.6 changes:
+            tx_port.h                           Updated macro definition
+            tx_thread_schedule.s                Added low power support
+
+03-02-2021  The following files were changed/added for version 6.1.5:
+            tx_port.h                       Added ULONG64_DEFINED
+
 12-31-2020  The following files were 
             changed/added for port specific version 6.1.3:
             
-            
             tx_port.h                       Remove unneeded include files, 
                                             use builtin functions,
                                             modified comments.

ports/cortex_m23/gnu/src/tx_thread_schedule.s

@@ -26,7 +26,7 @@
 /*  FUNCTION                                               RELEASE        */
 /*                                                                        */
 /*    _tx_thread_schedule                               Cortex-M23/GNU    */
-/*                                                           6.1          */
+/*                                                           6.1.6        */
 /*  AUTHOR                                                                */
 /*                                                                        */
 /*    Scott Larson, Microsoft Corporation                                 */
@@ -59,6 +59,9 @@
 /*    DATE              NAME                      DESCRIPTION             */
 /*                                                                        */
 /*  09-30-2020      Scott Larson            Initial Version 6.1           */
+/*  04-02-2021      Scott Larson            Modified comment(s), added    */
+/*                                            low power code,             */
+/*                                            resulting in version 6.1.6  */
 /*                                                                        */
 /**************************************************************************/
 // VOID   _tx_thread_schedule(VOID)
@@ -253,11 +256,25 @@ __tx_ts_wait:
     LDR     r1, [r2]                                // Pickup the next thread to execute pointer
     STR     r1, [r0]                                // Store it in the current pointer
     CBNZ    r1, __tx_ts_ready                       // If non-NULL, a new thread is ready!
+
+#ifdef TX_LOW_POWER
+    PUSH    {r0-r3}
+    BL      tx_low_power_enter                      // Possibly enter low power mode
+    POP     {r0-r3}
+#endif
+
 #ifdef TX_ENABLE_WFI
     DSB                                             // Ensure no outstanding memory transactions
     WFI                                             // Wait for interrupt
     ISB                                             // Ensure pipeline is flushed
 #endif
+
+#ifdef TX_LOW_POWER
+    PUSH    {r0-r3}
+    BL      tx_low_power_exit                       // Exit low power mode
+    POP     {r0-r3}
+#endif
+
     CPSIE   i                                       // Enable interrupts
     B       __tx_ts_wait                            // Loop to continue waiting