Use UBaseType_t as interrupt mask (#689)

chinglee-iot · web-flow · commit 80f67449ba68 · 2023-06-12T17:33:52.000+08:00
* Use UBaseType_t as interrupt mask
* Update GCC posix port to use UBaseType_t as interrupt mask
diff --git a/event_groups.c b/event_groups.c
@@ -521,15 +521,15 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
 
 EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )
 {
-    portBASE_TYPE xSavedInterruptStatus;
+    UBaseType_t uxSavedInterruptStatus;
     EventGroup_t const * const pxEventBits = xEventGroup;
     EventBits_t uxReturn;
 
-    xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
     {
         uxReturn = pxEventBits->uxEventBits;
     }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
     return uxReturn;
 } /*lint !e818 EventGroupHandle_t is a typedef used in other functions to so can't be pointer to const. */
diff --git a/portable/ThirdParty/GCC/Posix/port.c b/portable/ThirdParty/GCC/Posix/port.c
@@ -332,17 +332,17 @@ void vPortEnableInterrupts( void )
 }
 /*-----------------------------------------------------------*/
 
-portBASE_TYPE xPortSetInterruptMask( void )
+UBaseType_t xPortSetInterruptMask( void )
 {
     /* Interrupts are always disabled inside ISRs (signals
      * handlers). */
-    return pdTRUE;
+    return ( UBaseType_t )0;
 }
 /*-----------------------------------------------------------*/
 
-void vPortClearInterruptMask( portBASE_TYPE xMask )
+void vPortClearInterruptMask( UBaseType_t uxMask )
 {
-    ( void ) xMask;
+    ( void ) uxMask;
 }
 /*-----------------------------------------------------------*/
 
diff --git a/portable/ThirdParty/GCC/Posix/portmacro.h b/portable/ThirdParty/GCC/Posix/portmacro.h
@@ -94,8 +94,8 @@ extern void vPortEnableInterrupts( void );
 #define portSET_INTERRUPT_MASK()        ( vPortDisableInterrupts() )
 #define portCLEAR_INTERRUPT_MASK()      ( vPortEnableInterrupts() )
 
-extern portBASE_TYPE xPortSetInterruptMask( void );
-extern void vPortClearInterruptMask( portBASE_TYPE xMask );
+extern UBaseType_t xPortSetInterruptMask( void );
+extern void vPortClearInterruptMask( UBaseType_t xMask );
 
 extern void vPortEnterCritical( void );
 extern void vPortExitCritical( void );
diff --git a/queue.c b/queue.c
@@ -1099,7 +1099,7 @@ BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,
                                      const BaseType_t xCopyPosition )
 {
     BaseType_t xReturn;
-    portBASE_TYPE xSavedInterruptStatus;
+    UBaseType_t uxSavedInterruptStatus;
     Queue_t * const pxQueue = xQueue;
 
     configASSERT( pxQueue );
@@ -1127,7 +1127,7 @@ BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,
      * read, instead return a flag to say whether a context switch is required or
      * not (i.e. has a task with a higher priority than us been woken by this
      * post). */
-    xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
     {
         if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
         {
@@ -1252,7 +1252,7 @@ BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,
             xReturn = errQUEUE_FULL;
         }
     }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
     return xReturn;
 }
@@ -1262,7 +1262,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,
                               BaseType_t * const pxHigherPriorityTaskWoken )
 {
     BaseType_t xReturn;
-    portBASE_TYPE xSavedInterruptStatus;
+    UBaseType_t uxSavedInterruptStatus;
     Queue_t * const pxQueue = xQueue;
 
     /* Similar to xQueueGenericSendFromISR() but used with semaphores where the
@@ -1298,7 +1298,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,
      * link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
     portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
 
-    xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
     {
         const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
 
@@ -1418,7 +1418,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,
             xReturn = errQUEUE_FULL;
         }
     }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
     return xReturn;
 }
@@ -1933,7 +1933,7 @@ BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,
                                  BaseType_t * const pxHigherPriorityTaskWoken )
 {
     BaseType_t xReturn;
-    portBASE_TYPE xSavedInterruptStatus;
+    UBaseType_t uxSavedInterruptStatus;
     Queue_t * const pxQueue = xQueue;
 
     configASSERT( pxQueue );
@@ -1955,7 +1955,7 @@ BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,
      * link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
     portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
 
-    xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
     {
         const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
 
@@ -2015,7 +2015,7 @@ BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,
             traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue );
         }
     }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
     return xReturn;
 }
@@ -2025,7 +2025,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,
                               void * const pvBuffer )
 {
     BaseType_t xReturn;
-    portBASE_TYPE xSavedInterruptStatus;
+    UBaseType_t uxSavedInterruptStatus;
     int8_t * pcOriginalReadPosition;
     Queue_t * const pxQueue = xQueue;
 
@@ -2049,7 +2049,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,
      * link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
     portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
 
-    xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
     {
         /* Cannot block in an ISR, so check there is data available. */
         if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
@@ -2070,7 +2070,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,
             traceQUEUE_PEEK_FROM_ISR_FAILED( pxQueue );
         }
     }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
     return xReturn;
 }
diff --git a/stream_buffer.c b/stream_buffer.c
@@ -96,9 +96,9 @@
     #define sbRECEIVE_COMPLETED_FROM_ISR( pxStreamBuffer,                            \
                                           pxHigherPriorityTaskWoken )                \
     do {                                                                             \
-        portBASE_TYPE xSavedInterruptStatus;                                         \
+        UBaseType_t uxSavedInterruptStatus;                                          \
                                                                                      \
-        xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();                   \
+        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();                  \
         {                                                                            \
             if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL )                     \
             {                                                                        \
@@ -109,7 +109,7 @@
                 ( pxStreamBuffer )->xTaskWaitingToSend = NULL;                       \
             }                                                                        \
         }                                                                            \
-        portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );                  \
+        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );                 \
     } while( 0 )
 #endif /* sbRECEIVE_COMPLETED_FROM_ISR */
 
@@ -173,9 +173,9 @@
 #ifndef sbSEND_COMPLETE_FROM_ISR
     #define sbSEND_COMPLETE_FROM_ISR( pxStreamBuffer, pxHigherPriorityTaskWoken )       \
     do {                                                                                \
-        portBASE_TYPE xSavedInterruptStatus;                                            \
+        UBaseType_t uxSavedInterruptStatus;                                             \
                                                                                         \
-        xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();                      \
+        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();                     \
         {                                                                               \
             if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL )                     \
             {                                                                           \
@@ -186,7 +186,7 @@
                 ( pxStreamBuffer )->xTaskWaitingToReceive = NULL;                       \
             }                                                                           \
         }                                                                               \
-        portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );                     \
+        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );                    \
     } while( 0 )
 #endif /* sbSEND_COMPLETE_FROM_ISR */
 
@@ -1214,11 +1214,11 @@ BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer
 {
     StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;
     BaseType_t xReturn;
-    portBASE_TYPE xSavedInterruptStatus;
+    UBaseType_t uxSavedInterruptStatus;
 
     configASSERT( pxStreamBuffer );
 
-    xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
     {
         if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL )
         {
@@ -1234,7 +1234,7 @@ BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer
             xReturn = pdFALSE;
         }
     }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
     return xReturn;
 }
@@ -1245,11 +1245,11 @@ BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuf
 {
     StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;
     BaseType_t xReturn;
-    portBASE_TYPE xSavedInterruptStatus;
+    UBaseType_t uxSavedInterruptStatus;
 
     configASSERT( pxStreamBuffer );
 
-    xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
     {
         if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL )
         {
@@ -1265,7 +1265,7 @@ BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuf
             xReturn = pdFALSE;
         }
     }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
     return xReturn;
 }
diff --git a/tasks.c b/tasks.c
@@ -1481,7 +1481,7 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )
     {
         TCB_t const * pxTCB;
         UBaseType_t uxReturn;
-        portBASE_TYPE xSavedInterruptState;
+        UBaseType_t uxSavedInterruptState;
 
         /* RTOS ports that support interrupt nesting have the concept of a
          * maximum  system call (or maximum API call) interrupt priority.
@@ -1501,14 +1501,14 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )
          * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
         portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
 
-        xSavedInterruptState = portSET_INTERRUPT_MASK_FROM_ISR();
+        uxSavedInterruptState = portSET_INTERRUPT_MASK_FROM_ISR();
         {
             /* If null is passed in here then it is the priority of the calling
              * task that is being queried. */
             pxTCB = prvGetTCBFromHandle( xTask );
             uxReturn = pxTCB->uxPriority;
         }
-        portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptState );
+        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptState );
 
         return uxReturn;
     }
@@ -1894,7 +1894,7 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )
     {
         BaseType_t xYieldRequired = pdFALSE;
         TCB_t * const pxTCB = xTaskToResume;
-        portBASE_TYPE xSavedInterruptStatus;
+        UBaseType_t uxSavedInterruptStatus;
 
         configASSERT( xTaskToResume );
 
@@ -1916,7 +1916,7 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )
          * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
         portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
 
-        xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
         {
             if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )
             {
@@ -1957,7 +1957,7 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )
                 mtCOVERAGE_TEST_MARKER();
             }
         }
-        portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
         return xYieldRequired;
     }
@@ -2315,7 +2315,7 @@ TickType_t xTaskGetTickCount( void )
 TickType_t xTaskGetTickCountFromISR( void )
 {
     TickType_t xReturn;
-    portBASE_TYPE xSavedInterruptStatus;
+    UBaseType_t uxSavedInterruptStatus;
 
     /* RTOS ports that support interrupt nesting have the concept of a maximum
      * system call (or maximum API call) interrupt priority.  Interrupts that are
@@ -2333,11 +2333,11 @@ TickType_t xTaskGetTickCountFromISR( void )
      * link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
     portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
 
-    xSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();
+    uxSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();
     {
         xReturn = xTickCount;
     }
-    portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+    portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
     return xReturn;
 }
@@ -3015,18 +3015,18 @@ BaseType_t xTaskIncrementTick( void )
     {
         TCB_t * pxTCB;
         TaskHookFunction_t xReturn;
-        portBASE_TYPE xSavedInterruptStatus;
+        UBaseType_t uxSavedInterruptStatus;
 
         /* If xTask is NULL then set the calling task's hook. */
         pxTCB = prvGetTCBFromHandle( xTask );
 
         /* Save the hook function in the TCB.  A critical section is required as
          * the value can be accessed from an interrupt. */
-        xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
         {
             xReturn = pxTCB->pxTaskTag;
         }
-        portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
         return xReturn;
     }
@@ -5035,7 +5035,7 @@ TickType_t uxTaskResetEventItemValue( void )
         TCB_t * pxTCB;
         uint8_t ucOriginalNotifyState;
         BaseType_t xReturn = pdPASS;
-        portBASE_TYPE xSavedInterruptStatus;
+        UBaseType_t uxSavedInterruptStatus;
 
         configASSERT( xTaskToNotify );
         configASSERT( uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES );
@@ -5060,7 +5060,7 @@ TickType_t uxTaskResetEventItemValue( void )
 
         pxTCB = xTaskToNotify;
 
-        xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
         {
             if( pulPreviousNotificationValue != NULL )
             {
@@ -5154,7 +5154,7 @@ TickType_t uxTaskResetEventItemValue( void )
                 }
             }
         }
-        portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
         return xReturn;
     }
@@ -5170,7 +5170,7 @@ TickType_t uxTaskResetEventItemValue( void )
     {
         TCB_t * pxTCB;
         uint8_t ucOriginalNotifyState;
-        portBASE_TYPE xSavedInterruptStatus;
+        UBaseType_t uxSavedInterruptStatus;
 
         configASSERT( xTaskToNotify );
         configASSERT( uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES );
@@ -5195,7 +5195,7 @@ TickType_t uxTaskResetEventItemValue( void )
 
         pxTCB = xTaskToNotify;
 
-        xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
+        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
         {
             ucOriginalNotifyState = pxTCB->ucNotifyState[ uxIndexToNotify ];
             pxTCB->ucNotifyState[ uxIndexToNotify ] = taskNOTIFICATION_RECEIVED;
@@ -5245,7 +5245,7 @@ TickType_t uxTaskResetEventItemValue( void )
                 }
             }
         }
-        portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );
+        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
     }
 
 #endif /* configUSE_TASK_NOTIFICATIONS */

Original file line number	Diff line number	Diff line change
`@@ -521,15 +521,15 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,`
`521`	`521`
`522`	`522`	`EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )`
`523`	`523`	`{`
`524`		`- portBASE_TYPE xSavedInterruptStatus;`
	`524`	`+ UBaseType_t uxSavedInterruptStatus;`
`525`	`525`	`EventGroup_t const * const pxEventBits = xEventGroup;`
`526`	`526`	`EventBits_t uxReturn;`
`527`	`527`
`528`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`528`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`529`	`529`	`{`
`530`	`530`	`uxReturn = pxEventBits->uxEventBits;`
`531`	`531`	`}`
`532`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`532`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`533`	`533`
`534`	`534`	`return uxReturn;`
`535`	`535`	`} /lint !e818 EventGroupHandle_t is a typedef used in other functions to so can't be pointer to const. /`
Original file line number	Diff line number	Diff line change
`@@ -332,17 +332,17 @@ void vPortEnableInterrupts( void )`
`332`	`332`	`}`
`333`	`333`	`/-----------------------------------------------------------/`
`334`	`334`
`335`		`-portBASE_TYPE xPortSetInterruptMask( void )`
	`335`	`+UBaseType_t xPortSetInterruptMask( void )`
`336`	`336`	`{`
`337`	`337`	`/* Interrupts are always disabled inside ISRs (signals`
`338`	`338`	`* handlers). */`
`339`		`- return pdTRUE;`
	`339`	`+ return ( UBaseType_t )0;`
`340`	`340`	`}`
`341`	`341`	`/-----------------------------------------------------------/`
`342`	`342`
`343`		`-void vPortClearInterruptMask( portBASE_TYPE xMask )`
	`343`	`+void vPortClearInterruptMask( UBaseType_t uxMask )`
`344`	`344`	`{`
`345`		`- ( void ) xMask;`
	`345`	`+ ( void ) uxMask;`
`346`	`346`	`}`
`347`	`347`	`/-----------------------------------------------------------/`
`348`	`348`
Original file line number	Diff line number	Diff line change
`@@ -1099,7 +1099,7 @@ BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,`
`1099`	`1099`	`const BaseType_t xCopyPosition )`
`1100`	`1100`	`{`
`1101`	`1101`	`BaseType_t xReturn;`
`1102`		`- portBASE_TYPE xSavedInterruptStatus;`
	`1102`	`+ UBaseType_t uxSavedInterruptStatus;`
`1103`	`1103`	`Queue_t * const pxQueue = xQueue;`
`1104`	`1104`
`1105`	`1105`	`configASSERT( pxQueue );`
`@@ -1127,7 +1127,7 @@ BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,`
`1127`	`1127`	`* read, instead return a flag to say whether a context switch is required or`
`1128`	`1128`	`* not (i.e. has a task with a higher priority than us been woken by this`
`1129`	`1129`	`* post). */`
`1130`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`1130`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`1131`	`1131`	`{`
`1132`	`1132`	`if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) \|\| ( xCopyPosition == queueOVERWRITE ) )`
`1133`	`1133`	`{`
`@@ -1252,7 +1252,7 @@ BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,`
`1252`	`1252`	`xReturn = errQUEUE_FULL;`
`1253`	`1253`	`}`
`1254`	`1254`	`}`
`1255`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`1255`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`1256`	`1256`
`1257`	`1257`	`return xReturn;`
`1258`	`1258`	`}`
`@@ -1262,7 +1262,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,`
`1262`	`1262`	`BaseType_t * const pxHigherPriorityTaskWoken )`
`1263`	`1263`	`{`
`1264`	`1264`	`BaseType_t xReturn;`
`1265`		`- portBASE_TYPE xSavedInterruptStatus;`
	`1265`	`+ UBaseType_t uxSavedInterruptStatus;`
`1266`	`1266`	`Queue_t * const pxQueue = xQueue;`
`1267`	`1267`
`1268`	`1268`	`/* Similar to xQueueGenericSendFromISR() but used with semaphores where the`
`@@ -1298,7 +1298,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,`
`1298`	`1298`	`* link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */`
`1299`	`1299`	`portASSERT_IF_INTERRUPT_PRIORITY_INVALID();`
`1300`	`1300`
`1301`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`1301`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`1302`	`1302`	`{`
`1303`	`1303`	`const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;`
`1304`	`1304`
`@@ -1418,7 +1418,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,`
`1418`	`1418`	`xReturn = errQUEUE_FULL;`
`1419`	`1419`	`}`
`1420`	`1420`	`}`
`1421`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`1421`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`1422`	`1422`
`1423`	`1423`	`return xReturn;`
`1424`	`1424`	`}`
`@@ -1933,7 +1933,7 @@ BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,`
`1933`	`1933`	`BaseType_t * const pxHigherPriorityTaskWoken )`
`1934`	`1934`	`{`
`1935`	`1935`	`BaseType_t xReturn;`
`1936`		`- portBASE_TYPE xSavedInterruptStatus;`
	`1936`	`+ UBaseType_t uxSavedInterruptStatus;`
`1937`	`1937`	`Queue_t * const pxQueue = xQueue;`
`1938`	`1938`
`1939`	`1939`	`configASSERT( pxQueue );`
`@@ -1955,7 +1955,7 @@ BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,`
`1955`	`1955`	`* link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */`
`1956`	`1956`	`portASSERT_IF_INTERRUPT_PRIORITY_INVALID();`
`1957`	`1957`
`1958`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`1958`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`1959`	`1959`	`{`
`1960`	`1960`	`const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;`
`1961`	`1961`
`@@ -2015,7 +2015,7 @@ BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,`
`2015`	`2015`	`traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue );`
`2016`	`2016`	`}`
`2017`	`2017`	`}`
`2018`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`2018`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`2019`	`2019`
`2020`	`2020`	`return xReturn;`
`2021`	`2021`	`}`
`@@ -2025,7 +2025,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,`
`2025`	`2025`	`void * const pvBuffer )`
`2026`	`2026`	`{`
`2027`	`2027`	`BaseType_t xReturn;`
`2028`		`- portBASE_TYPE xSavedInterruptStatus;`
	`2028`	`+ UBaseType_t uxSavedInterruptStatus;`
`2029`	`2029`	`int8_t * pcOriginalReadPosition;`
`2030`	`2030`	`Queue_t * const pxQueue = xQueue;`
`2031`	`2031`
`@@ -2049,7 +2049,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,`
`2049`	`2049`	`* link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */`
`2050`	`2050`	`portASSERT_IF_INTERRUPT_PRIORITY_INVALID();`
`2051`	`2051`
`2052`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`2052`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`2053`	`2053`	`{`
`2054`	`2054`	`/* Cannot block in an ISR, so check there is data available. */`
`2055`	`2055`	`if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )`
`@@ -2070,7 +2070,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,`
`2070`	`2070`	`traceQUEUE_PEEK_FROM_ISR_FAILED( pxQueue );`
`2071`	`2071`	`}`
`2072`	`2072`	`}`
`2073`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`2073`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`2074`	`2074`
`2075`	`2075`	`return xReturn;`
`2076`	`2076`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,9 +96,9 @@`
`96`	`96`	`#define sbRECEIVE_COMPLETED_FROM_ISR( pxStreamBuffer, \`
`97`	`97`	`pxHigherPriorityTaskWoken ) \`
`98`	`98`	`do { \`
`99`		`- portBASE_TYPE xSavedInterruptStatus; \`
	`99`	`+ UBaseType_t uxSavedInterruptStatus; \`
`100`	`100`	`\`
`101`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR(); \`
	`101`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR(); \`
`102`	`102`	`{ \`
`103`	`103`	`if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL ) \`
`104`	`104`	`{ \`
`@@ -109,7 +109,7 @@`
`109`	`109`	`( pxStreamBuffer )->xTaskWaitingToSend = NULL; \`
`110`	`110`	`} \`
`111`	`111`	`} \`
`112`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus ); \`
	`112`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus ); \`
`113`	`113`	`} while( 0 )`
`114`	`114`	`#endif /* sbRECEIVE_COMPLETED_FROM_ISR */`
`115`	`115`
`@@ -173,9 +173,9 @@`
`173`	`173`	`#ifndef sbSEND_COMPLETE_FROM_ISR`
`174`	`174`	`#define sbSEND_COMPLETE_FROM_ISR( pxStreamBuffer, pxHigherPriorityTaskWoken ) \`
`175`	`175`	`do { \`
`176`		`- portBASE_TYPE xSavedInterruptStatus; \`
	`176`	`+ UBaseType_t uxSavedInterruptStatus; \`
`177`	`177`	`\`
`178`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR(); \`
	`178`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR(); \`
`179`	`179`	`{ \`
`180`	`180`	`if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL ) \`
`181`	`181`	`{ \`
`@@ -186,7 +186,7 @@`
`186`	`186`	`( pxStreamBuffer )->xTaskWaitingToReceive = NULL; \`
`187`	`187`	`} \`
`188`	`188`	`} \`
`189`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus ); \`
	`189`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus ); \`
`190`	`190`	`} while( 0 )`
`191`	`191`	`#endif /* sbSEND_COMPLETE_FROM_ISR */`
`192`	`192`
`@@ -1214,11 +1214,11 @@ BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer`
`1214`	`1214`	`{`
`1215`	`1215`	`StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;`
`1216`	`1216`	`BaseType_t xReturn;`
`1217`		`- portBASE_TYPE xSavedInterruptStatus;`
	`1217`	`+ UBaseType_t uxSavedInterruptStatus;`
`1218`	`1218`
`1219`	`1219`	`configASSERT( pxStreamBuffer );`
`1220`	`1220`
`1221`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`1221`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`1222`	`1222`	`{`
`1223`	`1223`	`if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL )`
`1224`	`1224`	`{`
`@@ -1234,7 +1234,7 @@ BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer`
`1234`	`1234`	`xReturn = pdFALSE;`
`1235`	`1235`	`}`
`1236`	`1236`	`}`
`1237`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`1237`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`1238`	`1238`
`1239`	`1239`	`return xReturn;`
`1240`	`1240`	`}`
`@@ -1245,11 +1245,11 @@ BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuf`
`1245`	`1245`	`{`
`1246`	`1246`	`StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;`
`1247`	`1247`	`BaseType_t xReturn;`
`1248`		`- portBASE_TYPE xSavedInterruptStatus;`
	`1248`	`+ UBaseType_t uxSavedInterruptStatus;`
`1249`	`1249`
`1250`	`1250`	`configASSERT( pxStreamBuffer );`
`1251`	`1251`
`1252`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`1252`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`1253`	`1253`	`{`
`1254`	`1254`	`if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL )`
`1255`	`1255`	`{`
`@@ -1265,7 +1265,7 @@ BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuf`
`1265`	`1265`	`xReturn = pdFALSE;`
`1266`	`1266`	`}`
`1267`	`1267`	`}`
`1268`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`1268`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`1269`	`1269`
`1270`	`1270`	`return xReturn;`
`1271`	`1271`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1481,7 +1481,7 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )`
`1481`	`1481`	`{`
`1482`	`1482`	`TCB_t const * pxTCB;`
`1483`	`1483`	`UBaseType_t uxReturn;`
`1484`		`- portBASE_TYPE xSavedInterruptState;`
	`1484`	`+ UBaseType_t uxSavedInterruptState;`
`1485`	`1485`
`1486`	`1486`	`/* RTOS ports that support interrupt nesting have the concept of a`
`1487`	`1487`	`* maximum system call (or maximum API call) interrupt priority.`
`@@ -1501,14 +1501,14 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )`
`1501`	`1501`	`* https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */`
`1502`	`1502`	`portASSERT_IF_INTERRUPT_PRIORITY_INVALID();`
`1503`	`1503`
`1504`		`- xSavedInterruptState = portSET_INTERRUPT_MASK_FROM_ISR();`
	`1504`	`+ uxSavedInterruptState = portSET_INTERRUPT_MASK_FROM_ISR();`
`1505`	`1505`	`{`
`1506`	`1506`	`/* If null is passed in here then it is the priority of the calling`
`1507`	`1507`	`* task that is being queried. */`
`1508`	`1508`	`pxTCB = prvGetTCBFromHandle( xTask );`
`1509`	`1509`	`uxReturn = pxTCB->uxPriority;`
`1510`	`1510`	`}`
`1511`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptState );`
	`1511`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptState );`
`1512`	`1512`
`1513`	`1513`	`return uxReturn;`
`1514`	`1514`	`}`
`@@ -1894,7 +1894,7 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )`
`1894`	`1894`	`{`
`1895`	`1895`	`BaseType_t xYieldRequired = pdFALSE;`
`1896`	`1896`	`TCB_t * const pxTCB = xTaskToResume;`
`1897`		`- portBASE_TYPE xSavedInterruptStatus;`
	`1897`	`+ UBaseType_t uxSavedInterruptStatus;`
`1898`	`1898`
`1899`	`1899`	`configASSERT( xTaskToResume );`
`1900`	`1900`
`@@ -1916,7 +1916,7 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )`
`1916`	`1916`	`* https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */`
`1917`	`1917`	`portASSERT_IF_INTERRUPT_PRIORITY_INVALID();`
`1918`	`1918`
`1919`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`1919`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`1920`	`1920`	`{`
`1921`	`1921`	`if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )`
`1922`	`1922`	`{`
`@@ -1957,7 +1957,7 @@ static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )`
`1957`	`1957`	`mtCOVERAGE_TEST_MARKER();`
`1958`	`1958`	`}`
`1959`	`1959`	`}`
`1960`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`1960`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`1961`	`1961`
`1962`	`1962`	`return xYieldRequired;`
`1963`	`1963`	`}`
`@@ -2315,7 +2315,7 @@ TickType_t xTaskGetTickCount( void )`
`2315`	`2315`	`TickType_t xTaskGetTickCountFromISR( void )`
`2316`	`2316`	`{`
`2317`	`2317`	`TickType_t xReturn;`
`2318`		`- portBASE_TYPE xSavedInterruptStatus;`
	`2318`	`+ UBaseType_t uxSavedInterruptStatus;`
`2319`	`2319`
`2320`	`2320`	`/* RTOS ports that support interrupt nesting have the concept of a maximum`
`2321`	`2321`	`* system call (or maximum API call) interrupt priority. Interrupts that are`
`@@ -2333,11 +2333,11 @@ TickType_t xTaskGetTickCountFromISR( void )`
`2333`	`2333`	`* link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */`
`2334`	`2334`	`portASSERT_IF_INTERRUPT_PRIORITY_INVALID();`
`2335`	`2335`
`2336`		`- xSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();`
	`2336`	`+ uxSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();`
`2337`	`2337`	`{`
`2338`	`2338`	`xReturn = xTickCount;`
`2339`	`2339`	`}`
`2340`		`- portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`2340`	`+ portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`2341`	`2341`
`2342`	`2342`	`return xReturn;`
`2343`	`2343`	`}`
`@@ -3015,18 +3015,18 @@ BaseType_t xTaskIncrementTick( void )`
`3015`	`3015`	`{`
`3016`	`3016`	`TCB_t * pxTCB;`
`3017`	`3017`	`TaskHookFunction_t xReturn;`
`3018`		`- portBASE_TYPE xSavedInterruptStatus;`
	`3018`	`+ UBaseType_t uxSavedInterruptStatus;`
`3019`	`3019`
`3020`	`3020`	`/* If xTask is NULL then set the calling task's hook. */`
`3021`	`3021`	`pxTCB = prvGetTCBFromHandle( xTask );`
`3022`	`3022`
`3023`	`3023`	`/* Save the hook function in the TCB. A critical section is required as`
`3024`	`3024`	`* the value can be accessed from an interrupt. */`
`3025`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`3025`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`3026`	`3026`	`{`
`3027`	`3027`	`xReturn = pxTCB->pxTaskTag;`
`3028`	`3028`	`}`
`3029`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`3029`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`3030`	`3030`
`3031`	`3031`	`return xReturn;`
`3032`	`3032`	`}`
`@@ -5035,7 +5035,7 @@ TickType_t uxTaskResetEventItemValue( void )`
`5035`	`5035`	`TCB_t * pxTCB;`
`5036`	`5036`	`uint8_t ucOriginalNotifyState;`
`5037`	`5037`	`BaseType_t xReturn = pdPASS;`
`5038`		`- portBASE_TYPE xSavedInterruptStatus;`
	`5038`	`+ UBaseType_t uxSavedInterruptStatus;`
`5039`	`5039`
`5040`	`5040`	`configASSERT( xTaskToNotify );`
`5041`	`5041`	`configASSERT( uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES );`
`@@ -5060,7 +5060,7 @@ TickType_t uxTaskResetEventItemValue( void )`
`5060`	`5060`
`5061`	`5061`	`pxTCB = xTaskToNotify;`
`5062`	`5062`
`5063`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`5063`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`5064`	`5064`	`{`
`5065`	`5065`	`if( pulPreviousNotificationValue != NULL )`
`5066`	`5066`	`{`
`@@ -5154,7 +5154,7 @@ TickType_t uxTaskResetEventItemValue( void )`
`5154`	`5154`	`}`
`5155`	`5155`	`}`
`5156`	`5156`	`}`
`5157`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`5157`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`5158`	`5158`
`5159`	`5159`	`return xReturn;`
`5160`	`5160`	`}`
`@@ -5170,7 +5170,7 @@ TickType_t uxTaskResetEventItemValue( void )`
`5170`	`5170`	`{`
`5171`	`5171`	`TCB_t * pxTCB;`
`5172`	`5172`	`uint8_t ucOriginalNotifyState;`
`5173`		`- portBASE_TYPE xSavedInterruptStatus;`
	`5173`	`+ UBaseType_t uxSavedInterruptStatus;`
`5174`	`5174`
`5175`	`5175`	`configASSERT( xTaskToNotify );`
`5176`	`5176`	`configASSERT( uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES );`
`@@ -5195,7 +5195,7 @@ TickType_t uxTaskResetEventItemValue( void )`
`5195`	`5195`
`5196`	`5196`	`pxTCB = xTaskToNotify;`
`5197`	`5197`
`5198`		`- xSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
	`5198`	`+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();`
`5199`	`5199`	`{`
`5200`	`5200`	`ucOriginalNotifyState = pxTCB->ucNotifyState[ uxIndexToNotify ];`
`5201`	`5201`	`pxTCB->ucNotifyState[ uxIndexToNotify ] = taskNOTIFICATION_RECEIVED;`
`@@ -5245,7 +5245,7 @@ TickType_t uxTaskResetEventItemValue( void )`
`5245`	`5245`	`}`
`5246`	`5246`	`}`
`5247`	`5247`	`}`
`5248`		`- portCLEAR_INTERRUPT_MASK_FROM_ISR( xSavedInterruptStatus );`
	`5248`	`+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );`
`5249`	`5249`	`}`
`5250`	`5250`
`5251`	`5251`	`#endif /* configUSE_TASK_NOTIFICATIONS */`