begriffs open source - freertos/blob - timers.c

   1 /*
   2  * FreeRTOS Kernel <DEVELOPMENT BRANCH>
   3  * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   4  *
   5  * SPDX-License-Identifier: MIT
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   8  * this software and associated documentation files (the "Software"), to deal in
   9  * the Software without restriction, including without limitation the rights to
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  11  * the Software, and to permit persons to whom the Software is furnished to do so,
  12  * subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in all
  15  * copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  19  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  20  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * https://www.FreeRTOS.org
  25  * https://github.com/FreeRTOS
  26  *
  27  */
  28
  29 /* Standard includes. */
  30 #include <stdlib.h>
  31
  32 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
  33  * all the API functions to use the MPU wrappers.  That should only be done when
  34  * task.h is included from an application file. */
  35 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  36
  37 #include "FreeRTOS.h"
  38 #include "task.h"
  39 #include "queue.h"
  40 #include "timers.h"
  41
  42 #if ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 0 )
  43     #error configUSE_TIMERS must be set to 1 to make the xTimerPendFunctionCall() function available.
  44 #endif
  45
  46 /* The MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined
  47  * for the header files above, but not in this file, in order to generate the
  48  * correct privileged Vs unprivileged linkage and placement. */
  49 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  50
  51
  52 /* This entire source file will be skipped if the application is not configured
  53  * to include software timer functionality.  This #if is closed at the very bottom
  54  * of this file.  If you want to include software timer functionality then ensure
  55  * configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
  56 #if ( configUSE_TIMERS == 1 )
  57
  58 /* Misc definitions. */
  59     #define tmrNO_DELAY                    ( ( TickType_t ) 0U )
  60     #define tmrMAX_TIME_BEFORE_OVERFLOW    ( ( TickType_t ) -1 )
  61
  62 /* The name assigned to the timer service task. This can be overridden by
  63  * defining configTIMER_SERVICE_TASK_NAME in FreeRTOSConfig.h. */
  64     #ifndef configTIMER_SERVICE_TASK_NAME
  65         #define configTIMER_SERVICE_TASK_NAME    "Tmr Svc"
  66     #endif
  67
  68     #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) )
  69
  70 /* The core affinity assigned to the timer service task on SMP systems.
  71  * This can be overridden by defining configTIMER_SERVICE_TASK_CORE_AFFINITY in FreeRTOSConfig.h. */
  72         #ifndef configTIMER_SERVICE_TASK_CORE_AFFINITY
  73             #define configTIMER_SERVICE_TASK_CORE_AFFINITY    tskNO_AFFINITY
  74         #endif
  75     #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */
  76
  77 /* Bit definitions used in the ucStatus member of a timer structure. */
  78     #define tmrSTATUS_IS_ACTIVE                  ( 0x01U )
  79     #define tmrSTATUS_IS_STATICALLY_ALLOCATED    ( 0x02U )
  80     #define tmrSTATUS_IS_AUTORELOAD              ( 0x04U )
  81
  82 /* The definition of the timers themselves. */
  83     typedef struct tmrTimerControl                                               /* The old naming convention is used to prevent breaking kernel aware debuggers. */
  84     {
  85         const char * pcTimerName;                                                /**< Text name.  This is not used by the kernel, it is included simply to make debugging easier. */
  86         ListItem_t xTimerListItem;                                               /**< Standard linked list item as used by all kernel features for event management. */
  87         TickType_t xTimerPeriodInTicks;                                          /**< How quickly and often the timer expires. */
  88         void * pvTimerID;                                                        /**< An ID to identify the timer.  This allows the timer to be identified when the same callback is used for multiple timers. */
  89         portTIMER_CALLBACK_ATTRIBUTE TimerCallbackFunction_t pxCallbackFunction; /**< The function that will be called when the timer expires. */
  90         #if ( configUSE_TRACE_FACILITY == 1 )
  91             UBaseType_t uxTimerNumber;                                           /**< An ID assigned by trace tools such as FreeRTOS+Trace */
  92         #endif
  93         uint8_t ucStatus;                                                        /**< Holds bits to say if the timer was statically allocated or not, and if it is active or not. */
  94     } xTIMER;
  95
  96 /* The old xTIMER name is maintained above then typedefed to the new Timer_t
  97  * name below to enable the use of older kernel aware debuggers. */
  98     typedef xTIMER Timer_t;
  99
 100 /* The definition of messages that can be sent and received on the timer queue.
 101  * Two types of message can be queued - messages that manipulate a software timer,
 102  * and messages that request the execution of a non-timer related callback.  The
 103  * two message types are defined in two separate structures, xTimerParametersType
 104  * and xCallbackParametersType respectively. */
 105     typedef struct tmrTimerParameters
 106     {
 107         TickType_t xMessageValue; /**< An optional value used by a subset of commands, for example, when changing the period of a timer. */
 108         Timer_t * pxTimer;        /**< The timer to which the command will be applied. */
 109     } TimerParameter_t;
 110
 111
 112     typedef struct tmrCallbackParameters
 113     {
 114         portTIMER_CALLBACK_ATTRIBUTE
 115         PendedFunction_t pxCallbackFunction; /* << The callback function to execute. */
 116         void * pvParameter1;                 /* << The value that will be used as the callback functions first parameter. */
 117         uint32_t ulParameter2;               /* << The value that will be used as the callback functions second parameter. */
 118     } CallbackParameters_t;
 119
 120 /* The structure that contains the two message types, along with an identifier
 121  * that is used to determine which message type is valid. */
 122     typedef struct tmrTimerQueueMessage
 123     {
 124         BaseType_t xMessageID; /**< The command being sent to the timer service task. */
 125         union
 126         {
 127             TimerParameter_t xTimerParameters;
 128
 129             /* Don't include xCallbackParameters if it is not going to be used as
 130              * it makes the structure (and therefore the timer queue) larger. */
 131             #if ( INCLUDE_xTimerPendFunctionCall == 1 )
 132                 CallbackParameters_t xCallbackParameters;
 133             #endif /* INCLUDE_xTimerPendFunctionCall */
 134         } u;
 135     } DaemonTaskMessage_t;
 136
 137 /* The list in which active timers are stored.  Timers are referenced in expire
 138  * time order, with the nearest expiry time at the front of the list.  Only the
 139  * timer service task is allowed to access these lists.
 140  * xActiveTimerList1 and xActiveTimerList2 could be at function scope but that
 141  * breaks some kernel aware debuggers, and debuggers that reply on removing the
 142  * static qualifier. */
 143     PRIVILEGED_DATA static List_t xActiveTimerList1;
 144     PRIVILEGED_DATA static List_t xActiveTimerList2;
 145     PRIVILEGED_DATA static List_t * pxCurrentTimerList;
 146     PRIVILEGED_DATA static List_t * pxOverflowTimerList;
 147
 148 /* A queue that is used to send commands to the timer service task. */
 149     PRIVILEGED_DATA static QueueHandle_t xTimerQueue = NULL;
 150     PRIVILEGED_DATA static TaskHandle_t xTimerTaskHandle = NULL;
 151
 152 /*-----------------------------------------------------------*/
 153
 154 /*
 155  * Initialise the infrastructure used by the timer service task if it has not
 156  * been initialised already.
 157  */
 158     static void prvCheckForValidListAndQueue( void ) PRIVILEGED_FUNCTION;
 159
 160 /*
 161  * The timer service task (daemon).  Timer functionality is controlled by this
 162  * task.  Other tasks communicate with the timer service task using the
 163  * xTimerQueue queue.
 164  */
 165     static portTASK_FUNCTION_PROTO( prvTimerTask, pvParameters ) PRIVILEGED_FUNCTION;
 166
 167 /*
 168  * Called by the timer service task to interpret and process a command it
 169  * received on the timer queue.
 170  */
 171     static void prvProcessReceivedCommands( void ) PRIVILEGED_FUNCTION;
 172
 173 /*
 174  * Insert the timer into either xActiveTimerList1, or xActiveTimerList2,
 175  * depending on if the expire time causes a timer counter overflow.
 176  */
 177     static BaseType_t prvInsertTimerInActiveList( Timer_t * const pxTimer,
 178                                                   const TickType_t xNextExpiryTime,
 179                                                   const TickType_t xTimeNow,
 180                                                   const TickType_t xCommandTime ) PRIVILEGED_FUNCTION;
 181
 182 /*
 183  * Reload the specified auto-reload timer.  If the reloading is backlogged,
 184  * clear the backlog, calling the callback for each additional reload.  When
 185  * this function returns, the next expiry time is after xTimeNow.
 186  */
 187     static void prvReloadTimer( Timer_t * const pxTimer,
 188                                 TickType_t xExpiredTime,
 189                                 const TickType_t xTimeNow ) PRIVILEGED_FUNCTION;
 190
 191 /*
 192  * An active timer has reached its expire time.  Reload the timer if it is an
 193  * auto-reload timer, then call its callback.
 194  */
 195     static void prvProcessExpiredTimer( const TickType_t xNextExpireTime,
 196                                         const TickType_t xTimeNow ) PRIVILEGED_FUNCTION;
 197
 198 /*
 199  * The tick count has overflowed.  Switch the timer lists after ensuring the
 200  * current timer list does not still reference some timers.
 201  */
 202     static void prvSwitchTimerLists( void ) PRIVILEGED_FUNCTION;
 203
 204 /*
 205  * Obtain the current tick count, setting *pxTimerListsWereSwitched to pdTRUE
 206  * if a tick count overflow occurred since prvSampleTimeNow() was last called.
 207  */
 208     static TickType_t prvSampleTimeNow( BaseType_t * const pxTimerListsWereSwitched ) PRIVILEGED_FUNCTION;
 209
 210 /*
 211  * If the timer list contains any active timers then return the expire time of
 212  * the timer that will expire first and set *pxListWasEmpty to false.  If the
 213  * timer list does not contain any timers then return 0 and set *pxListWasEmpty
 214  * to pdTRUE.
 215  */
 216     static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty ) PRIVILEGED_FUNCTION;
 217
 218 /*
 219  * If a timer has expired, process it.  Otherwise, block the timer service task
 220  * until either a timer does expire or a command is received.
 221  */
 222     static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime,
 223                                             BaseType_t xListWasEmpty ) PRIVILEGED_FUNCTION;
 224
 225 /*
 226  * Called after a Timer_t structure has been allocated either statically or
 227  * dynamically to fill in the structure's members.
 228  */
 229     static void prvInitialiseNewTimer( const char * const pcTimerName,
 230                                        const TickType_t xTimerPeriodInTicks,
 231                                        const BaseType_t xAutoReload,
 232                                        void * const pvTimerID,
 233                                        TimerCallbackFunction_t pxCallbackFunction,
 234                                        Timer_t * pxNewTimer ) PRIVILEGED_FUNCTION;
 235 /*-----------------------------------------------------------*/
 236
 237     BaseType_t xTimerCreateTimerTask( void )
 238     {
 239         BaseType_t xReturn = pdFAIL;
 240
 241         traceENTER_xTimerCreateTimerTask();
 242
 243         /* This function is called when the scheduler is started if
 244          * configUSE_TIMERS is set to 1.  Check that the infrastructure used by the
 245          * timer service task has been created/initialised.  If timers have already
 246          * been created then the initialisation will already have been performed. */
 247         prvCheckForValidListAndQueue();
 248
 249         if( xTimerQueue != NULL )
 250         {
 251             #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) )
 252             {
 253                 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
 254                 {
 255                     StaticTask_t * pxTimerTaskTCBBuffer = NULL;
 256                     StackType_t * pxTimerTaskStackBuffer = NULL;
 257                     configSTACK_DEPTH_TYPE uxTimerTaskStackSize;
 258
 259                     vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer, &pxTimerTaskStackBuffer, &uxTimerTaskStackSize );
 260                     xTimerTaskHandle = xTaskCreateStaticAffinitySet( prvTimerTask,
 261                                                                      configTIMER_SERVICE_TASK_NAME,
 262                                                                      uxTimerTaskStackSize,
 263                                                                      NULL,
 264                                                                      ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
 265                                                                      pxTimerTaskStackBuffer,
 266                                                                      pxTimerTaskTCBBuffer,
 267                                                                      configTIMER_SERVICE_TASK_CORE_AFFINITY );
 268
 269                     if( xTimerTaskHandle != NULL )
 270                     {
 271                         xReturn = pdPASS;
 272                     }
 273                 }
 274                 #else /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
 275                 {
 276                     xReturn = xTaskCreateAffinitySet( prvTimerTask,
 277                                                       configTIMER_SERVICE_TASK_NAME,
 278                                                       configTIMER_TASK_STACK_DEPTH,
 279                                                       NULL,
 280                                                       ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
 281                                                       configTIMER_SERVICE_TASK_CORE_AFFINITY,
 282                                                       &xTimerTaskHandle );
 283                 }
 284                 #endif /* configSUPPORT_STATIC_ALLOCATION */
 285             }
 286             #else /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */
 287             {
 288                 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
 289                 {
 290                     StaticTask_t * pxTimerTaskTCBBuffer = NULL;
 291                     StackType_t * pxTimerTaskStackBuffer = NULL;
 292                     configSTACK_DEPTH_TYPE uxTimerTaskStackSize;
 293
 294                     vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer, &pxTimerTaskStackBuffer, &uxTimerTaskStackSize );
 295                     xTimerTaskHandle = xTaskCreateStatic( prvTimerTask,
 296                                                           configTIMER_SERVICE_TASK_NAME,
 297                                                           uxTimerTaskStackSize,
 298                                                           NULL,
 299                                                           ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
 300                                                           pxTimerTaskStackBuffer,
 301                                                           pxTimerTaskTCBBuffer );
 302
 303                     if( xTimerTaskHandle != NULL )
 304                     {
 305                         xReturn = pdPASS;
 306                     }
 307                 }
 308                 #else /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
 309                 {
 310                     xReturn = xTaskCreate( prvTimerTask,
 311                                            configTIMER_SERVICE_TASK_NAME,
 312                                            configTIMER_TASK_STACK_DEPTH,
 313                                            NULL,
 314                                            ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
 315                                            &xTimerTaskHandle );
 316                 }
 317                 #endif /* configSUPPORT_STATIC_ALLOCATION */
 318             }
 319             #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */
 320         }
 321         else
 322         {
 323             mtCOVERAGE_TEST_MARKER();
 324         }
 325
 326         configASSERT( xReturn );
 327
 328         traceRETURN_xTimerCreateTimerTask( xReturn );
 329
 330         return xReturn;
 331     }
 332 /*-----------------------------------------------------------*/
 333
 334     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
 335
 336         TimerHandle_t xTimerCreate( const char * const pcTimerName,
 337                                     const TickType_t xTimerPeriodInTicks,
 338                                     const BaseType_t xAutoReload,
 339                                     void * const pvTimerID,
 340                                     TimerCallbackFunction_t pxCallbackFunction )
 341         {
 342             Timer_t * pxNewTimer;
 343
 344             traceENTER_xTimerCreate( pcTimerName, xTimerPeriodInTicks, xAutoReload, pvTimerID, pxCallbackFunction );
 345
 346             /* MISRA Ref 11.5.1 [Malloc memory assignment] */
 347             /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
 348             /* coverity[misra_c_2012_rule_11_5_violation] */
 349             pxNewTimer = ( Timer_t * ) pvPortMalloc( sizeof( Timer_t ) );
 350
 351             if( pxNewTimer != NULL )
 352             {
 353                 /* Status is thus far zero as the timer is not created statically
 354                  * and has not been started.  The auto-reload bit may get set in
 355                  * prvInitialiseNewTimer. */
 356                 pxNewTimer->ucStatus = 0x00;
 357                 prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, xAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );
 358             }
 359
 360             traceRETURN_xTimerCreate( pxNewTimer );
 361
 362             return pxNewTimer;
 363         }
 364
 365     #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 366 /*-----------------------------------------------------------*/
 367
 368     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
 369
 370         TimerHandle_t xTimerCreateStatic( const char * const pcTimerName,
 371                                           const TickType_t xTimerPeriodInTicks,
 372                                           const BaseType_t xAutoReload,
 373                                           void * const pvTimerID,
 374                                           TimerCallbackFunction_t pxCallbackFunction,
 375                                           StaticTimer_t * pxTimerBuffer )
 376         {
 377             Timer_t * pxNewTimer;
 378
 379             traceENTER_xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, xAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );
 380
 381             #if ( configASSERT_DEFINED == 1 )
 382             {
 383                 /* Sanity check that the size of the structure used to declare a
 384                  * variable of type StaticTimer_t equals the size of the real timer
 385                  * structure. */
 386                 volatile size_t xSize = sizeof( StaticTimer_t );
 387                 configASSERT( xSize == sizeof( Timer_t ) );
 388                 ( void ) xSize; /* Prevent unused variable warning when configASSERT() is not defined. */
 389             }
 390             #endif /* configASSERT_DEFINED */
 391
 392             /* A pointer to a StaticTimer_t structure MUST be provided, use it. */
 393             configASSERT( pxTimerBuffer );
 394             /* MISRA Ref 11.3.1 [Misaligned access] */
 395             /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
 396             /* coverity[misra_c_2012_rule_11_3_violation] */
 397             pxNewTimer = ( Timer_t * ) pxTimerBuffer;
 398
 399             if( pxNewTimer != NULL )
 400             {
 401                 /* Timers can be created statically or dynamically so note this
 402                  * timer was created statically in case it is later deleted.  The
 403                  * auto-reload bit may get set in prvInitialiseNewTimer(). */
 404                 pxNewTimer->ucStatus = ( uint8_t ) tmrSTATUS_IS_STATICALLY_ALLOCATED;
 405
 406                 prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, xAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );
 407             }
 408
 409             traceRETURN_xTimerCreateStatic( pxNewTimer );
 410
 411             return pxNewTimer;
 412         }
 413
 414     #endif /* configSUPPORT_STATIC_ALLOCATION */
 415 /*-----------------------------------------------------------*/
 416
 417     static void prvInitialiseNewTimer( const char * const pcTimerName,
 418                                        const TickType_t xTimerPeriodInTicks,
 419                                        const BaseType_t xAutoReload,
 420                                        void * const pvTimerID,
 421                                        TimerCallbackFunction_t pxCallbackFunction,
 422                                        Timer_t * pxNewTimer )
 423     {
 424         /* 0 is not a valid value for xTimerPeriodInTicks. */
 425         configASSERT( ( xTimerPeriodInTicks > 0 ) );
 426
 427         /* Ensure the infrastructure used by the timer service task has been
 428          * created/initialised. */
 429         prvCheckForValidListAndQueue();
 430
 431         /* Initialise the timer structure members using the function
 432          * parameters. */
 433         pxNewTimer->pcTimerName = pcTimerName;
 434         pxNewTimer->xTimerPeriodInTicks = xTimerPeriodInTicks;
 435         pxNewTimer->pvTimerID = pvTimerID;
 436         pxNewTimer->pxCallbackFunction = pxCallbackFunction;
 437         vListInitialiseItem( &( pxNewTimer->xTimerListItem ) );
 438
 439         if( xAutoReload != pdFALSE )
 440         {
 441             pxNewTimer->ucStatus |= ( uint8_t ) tmrSTATUS_IS_AUTORELOAD;
 442         }
 443
 444         traceTIMER_CREATE( pxNewTimer );
 445     }
 446 /*-----------------------------------------------------------*/
 447
 448     BaseType_t xTimerGenericCommandFromTask( TimerHandle_t xTimer,
 449                                              const BaseType_t xCommandID,
 450                                              const TickType_t xOptionalValue,
 451                                              BaseType_t * const pxHigherPriorityTaskWoken,
 452                                              const TickType_t xTicksToWait )
 453     {
 454         BaseType_t xReturn = pdFAIL;
 455         DaemonTaskMessage_t xMessage;
 456
 457         ( void ) pxHigherPriorityTaskWoken;
 458
 459         traceENTER_xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
 460
 461         configASSERT( xTimer );
 462
 463         /* Send a message to the timer service task to perform a particular action
 464          * on a particular timer definition. */
 465         if( xTimerQueue != NULL )
 466         {
 467             /* Send a command to the timer service task to start the xTimer timer. */
 468             xMessage.xMessageID = xCommandID;
 469             xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;
 470             xMessage.u.xTimerParameters.pxTimer = xTimer;
 471
 472             configASSERT( xCommandID < tmrFIRST_FROM_ISR_COMMAND );
 473
 474             if( xCommandID < tmrFIRST_FROM_ISR_COMMAND )
 475             {
 476                 if( xTaskGetSchedulerState() == taskSCHEDULER_RUNNING )
 477                 {
 478                     xReturn = xQueueSendToBack( xTimerQueue, &xMessage, xTicksToWait );
 479                 }
 480                 else
 481                 {
 482                     xReturn = xQueueSendToBack( xTimerQueue, &xMessage, tmrNO_DELAY );
 483                 }
 484             }
 485
 486             traceTIMER_COMMAND_SEND( xTimer, xCommandID, xOptionalValue, xReturn );
 487         }
 488         else
 489         {
 490             mtCOVERAGE_TEST_MARKER();
 491         }
 492
 493         traceRETURN_xTimerGenericCommandFromTask( xReturn );
 494
 495         return xReturn;
 496     }
 497 /*-----------------------------------------------------------*/
 498
 499     BaseType_t xTimerGenericCommandFromISR( TimerHandle_t xTimer,
 500                                             const BaseType_t xCommandID,
 501                                             const TickType_t xOptionalValue,
 502                                             BaseType_t * const pxHigherPriorityTaskWoken,
 503                                             const TickType_t xTicksToWait )
 504     {
 505         BaseType_t xReturn = pdFAIL;
 506         DaemonTaskMessage_t xMessage;
 507
 508         ( void ) xTicksToWait;
 509
 510         traceENTER_xTimerGenericCommandFromISR( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
 511
 512         configASSERT( xTimer );
 513
 514         /* Send a message to the timer service task to perform a particular action
 515          * on a particular timer definition. */
 516         if( xTimerQueue != NULL )
 517         {
 518             /* Send a command to the timer service task to start the xTimer timer. */
 519             xMessage.xMessageID = xCommandID;
 520             xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;
 521             xMessage.u.xTimerParameters.pxTimer = xTimer;
 522
 523             configASSERT( xCommandID >= tmrFIRST_FROM_ISR_COMMAND );
 524
 525             if( xCommandID >= tmrFIRST_FROM_ISR_COMMAND )
 526             {
 527                 xReturn = xQueueSendToBackFromISR( xTimerQueue, &xMessage, pxHigherPriorityTaskWoken );
 528             }
 529
 530             traceTIMER_COMMAND_SEND( xTimer, xCommandID, xOptionalValue, xReturn );
 531         }
 532         else
 533         {
 534             mtCOVERAGE_TEST_MARKER();
 535         }
 536
 537         traceRETURN_xTimerGenericCommandFromISR( xReturn );
 538
 539         return xReturn;
 540     }
 541 /*-----------------------------------------------------------*/
 542
 543     TaskHandle_t xTimerGetTimerDaemonTaskHandle( void )
 544     {
 545         traceENTER_xTimerGetTimerDaemonTaskHandle();
 546
 547         /* If xTimerGetTimerDaemonTaskHandle() is called before the scheduler has been
 548          * started, then xTimerTaskHandle will be NULL. */
 549         configASSERT( ( xTimerTaskHandle != NULL ) );
 550
 551         traceRETURN_xTimerGetTimerDaemonTaskHandle( xTimerTaskHandle );
 552
 553         return xTimerTaskHandle;
 554     }
 555 /*-----------------------------------------------------------*/
 556
 557     TickType_t xTimerGetPeriod( TimerHandle_t xTimer )
 558     {
 559         Timer_t * pxTimer = xTimer;
 560
 561         traceENTER_xTimerGetPeriod( xTimer );
 562
 563         configASSERT( xTimer );
 564
 565         traceRETURN_xTimerGetPeriod( pxTimer->xTimerPeriodInTicks );
 566
 567         return pxTimer->xTimerPeriodInTicks;
 568     }
 569 /*-----------------------------------------------------------*/
 570
 571     void vTimerSetReloadMode( TimerHandle_t xTimer,
 572                               const BaseType_t xAutoReload )
 573     {
 574         Timer_t * pxTimer = xTimer;
 575
 576         traceENTER_vTimerSetReloadMode( xTimer, xAutoReload );
 577
 578         configASSERT( xTimer );
 579         taskENTER_CRITICAL();
 580         {
 581             if( xAutoReload != pdFALSE )
 582             {
 583                 pxTimer->ucStatus |= ( uint8_t ) tmrSTATUS_IS_AUTORELOAD;
 584             }
 585             else
 586             {
 587                 pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_AUTORELOAD );
 588             }
 589         }
 590         taskEXIT_CRITICAL();
 591
 592         traceRETURN_vTimerSetReloadMode();
 593     }
 594 /*-----------------------------------------------------------*/
 595
 596     BaseType_t xTimerGetReloadMode( TimerHandle_t xTimer )
 597     {
 598         Timer_t * pxTimer = xTimer;
 599         BaseType_t xReturn;
 600
 601         traceENTER_xTimerGetReloadMode( xTimer );
 602
 603         configASSERT( xTimer );
 604         taskENTER_CRITICAL();
 605         {
 606             if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) == 0U )
 607             {
 608                 /* Not an auto-reload timer. */
 609                 xReturn = pdFALSE;
 610             }
 611             else
 612             {
 613                 /* Is an auto-reload timer. */
 614                 xReturn = pdTRUE;
 615             }
 616         }
 617         taskEXIT_CRITICAL();
 618
 619         traceRETURN_xTimerGetReloadMode( xReturn );
 620
 621         return xReturn;
 622     }
 623
 624     UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer )
 625     {
 626         UBaseType_t uxReturn;
 627
 628         traceENTER_uxTimerGetReloadMode( xTimer );
 629
 630         uxReturn = ( UBaseType_t ) xTimerGetReloadMode( xTimer );
 631
 632         traceRETURN_uxTimerGetReloadMode( uxReturn );
 633
 634         return uxReturn;
 635     }
 636 /*-----------------------------------------------------------*/
 637
 638     TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer )
 639     {
 640         Timer_t * pxTimer = xTimer;
 641         TickType_t xReturn;
 642
 643         traceENTER_xTimerGetExpiryTime( xTimer );
 644
 645         configASSERT( xTimer );
 646         xReturn = listGET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ) );
 647
 648         traceRETURN_xTimerGetExpiryTime( xReturn );
 649
 650         return xReturn;
 651     }
 652 /*-----------------------------------------------------------*/
 653
 654     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
 655         BaseType_t xTimerGetStaticBuffer( TimerHandle_t xTimer,
 656                                           StaticTimer_t ** ppxTimerBuffer )
 657         {
 658             BaseType_t xReturn;
 659             Timer_t * pxTimer = xTimer;
 660
 661             traceENTER_xTimerGetStaticBuffer( xTimer, ppxTimerBuffer );
 662
 663             configASSERT( ppxTimerBuffer != NULL );
 664
 665             if( ( pxTimer->ucStatus & tmrSTATUS_IS_STATICALLY_ALLOCATED ) != 0U )
 666             {
 667                 /* MISRA Ref 11.3.1 [Misaligned access] */
 668                 /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
 669                 /* coverity[misra_c_2012_rule_11_3_violation] */
 670                 *ppxTimerBuffer = ( StaticTimer_t * ) pxTimer;
 671                 xReturn = pdTRUE;
 672             }
 673             else
 674             {
 675                 xReturn = pdFALSE;
 676             }
 677
 678             traceRETURN_xTimerGetStaticBuffer( xReturn );
 679
 680             return xReturn;
 681         }
 682     #endif /* configSUPPORT_STATIC_ALLOCATION */
 683 /*-----------------------------------------------------------*/
 684
 685     const char * pcTimerGetName( TimerHandle_t xTimer )
 686     {
 687         Timer_t * pxTimer = xTimer;
 688
 689         traceENTER_pcTimerGetName( xTimer );
 690
 691         configASSERT( xTimer );
 692
 693         traceRETURN_pcTimerGetName( pxTimer->pcTimerName );
 694
 695         return pxTimer->pcTimerName;
 696     }
 697 /*-----------------------------------------------------------*/
 698
 699     static void prvReloadTimer( Timer_t * const pxTimer,
 700                                 TickType_t xExpiredTime,
 701                                 const TickType_t xTimeNow )
 702     {
 703         /* Insert the timer into the appropriate list for the next expiry time.
 704          * If the next expiry time has already passed, advance the expiry time,
 705          * call the callback function, and try again. */
 706         while( prvInsertTimerInActiveList( pxTimer, ( xExpiredTime + pxTimer->xTimerPeriodInTicks ), xTimeNow, xExpiredTime ) != pdFALSE )
 707         {
 708             /* Advance the expiry time. */
 709             xExpiredTime += pxTimer->xTimerPeriodInTicks;
 710
 711             /* Call the timer callback. */
 712             traceTIMER_EXPIRED( pxTimer );
 713             pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
 714         }
 715     }
 716 /*-----------------------------------------------------------*/
 717
 718     static void prvProcessExpiredTimer( const TickType_t xNextExpireTime,
 719                                         const TickType_t xTimeNow )
 720     {
 721         /* MISRA Ref 11.5.3 [Void pointer assignment] */
 722         /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
 723         /* coverity[misra_c_2012_rule_11_5_violation] */
 724         Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );
 725
 726         /* Remove the timer from the list of active timers.  A check has already
 727          * been performed to ensure the list is not empty. */
 728
 729         ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );
 730
 731         /* If the timer is an auto-reload timer then calculate the next
 732          * expiry time and re-insert the timer in the list of active timers. */
 733         if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0U )
 734         {
 735             prvReloadTimer( pxTimer, xNextExpireTime, xTimeNow );
 736         }
 737         else
 738         {
 739             pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
 740         }
 741
 742         /* Call the timer callback. */
 743         traceTIMER_EXPIRED( pxTimer );
 744         pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
 745     }
 746 /*-----------------------------------------------------------*/
 747
 748     static portTASK_FUNCTION( prvTimerTask, pvParameters )
 749     {
 750         TickType_t xNextExpireTime;
 751         BaseType_t xListWasEmpty;
 752
 753         /* Just to avoid compiler warnings. */
 754         ( void ) pvParameters;
 755
 756         #if ( configUSE_DAEMON_TASK_STARTUP_HOOK == 1 )
 757         {
 758             /* Allow the application writer to execute some code in the context of
 759              * this task at the point the task starts executing.  This is useful if the
 760              * application includes initialisation code that would benefit from
 761              * executing after the scheduler has been started. */
 762             vApplicationDaemonTaskStartupHook();
 763         }
 764         #endif /* configUSE_DAEMON_TASK_STARTUP_HOOK */
 765
 766         for( ; configCONTROL_INFINITE_LOOP(); )
 767         {
 768             /* Query the timers list to see if it contains any timers, and if so,
 769              * obtain the time at which the next timer will expire. */
 770             xNextExpireTime = prvGetNextExpireTime( &xListWasEmpty );
 771
 772             /* If a timer has expired, process it.  Otherwise, block this task
 773              * until either a timer does expire, or a command is received. */
 774             prvProcessTimerOrBlockTask( xNextExpireTime, xListWasEmpty );
 775
 776             /* Empty the command queue. */
 777             prvProcessReceivedCommands();
 778         }
 779     }
 780 /*-----------------------------------------------------------*/
 781
 782     static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime,
 783                                             BaseType_t xListWasEmpty )
 784     {
 785         TickType_t xTimeNow;
 786         BaseType_t xTimerListsWereSwitched;
 787
 788         vTaskSuspendAll();
 789         {
 790             /* Obtain the time now to make an assessment as to whether the timer
 791              * has expired or not.  If obtaining the time causes the lists to switch
 792              * then don't process this timer as any timers that remained in the list
 793              * when the lists were switched will have been processed within the
 794              * prvSampleTimeNow() function. */
 795             xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );
 796
 797             if( xTimerListsWereSwitched == pdFALSE )
 798             {
 799                 /* The tick count has not overflowed, has the timer expired? */
 800                 if( ( xListWasEmpty == pdFALSE ) && ( xNextExpireTime <= xTimeNow ) )
 801                 {
 802                     ( void ) xTaskResumeAll();
 803                     prvProcessExpiredTimer( xNextExpireTime, xTimeNow );
 804                 }
 805                 else
 806                 {
 807                     /* The tick count has not overflowed, and the next expire
 808                      * time has not been reached yet.  This task should therefore
 809                      * block to wait for the next expire time or a command to be
 810                      * received - whichever comes first.  The following line cannot
 811                      * be reached unless xNextExpireTime > xTimeNow, except in the
 812                      * case when the current timer list is empty. */
 813                     if( xListWasEmpty != pdFALSE )
 814                     {
 815                         /* The current timer list is empty - is the overflow list
 816                          * also empty? */
 817                         xListWasEmpty = listLIST_IS_EMPTY( pxOverflowTimerList );
 818                     }
 819
 820                     vQueueWaitForMessageRestricted( xTimerQueue, ( xNextExpireTime - xTimeNow ), xListWasEmpty );
 821
 822                     if( xTaskResumeAll() == pdFALSE )
 823                     {
 824                         /* Yield to wait for either a command to arrive, or the
 825                          * block time to expire.  If a command arrived between the
 826                          * critical section being exited and this yield then the yield
 827                          * will not cause the task to block. */
 828                         taskYIELD_WITHIN_API();
 829                     }
 830                     else
 831                     {
 832                         mtCOVERAGE_TEST_MARKER();
 833                     }
 834                 }
 835             }
 836             else
 837             {
 838                 ( void ) xTaskResumeAll();
 839             }
 840         }
 841     }
 842 /*-----------------------------------------------------------*/
 843
 844     static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty )
 845     {
 846         TickType_t xNextExpireTime;
 847
 848         /* Timers are listed in expiry time order, with the head of the list
 849          * referencing the task that will expire first.  Obtain the time at which
 850          * the timer with the nearest expiry time will expire.  If there are no
 851          * active timers then just set the next expire time to 0.  That will cause
 852          * this task to unblock when the tick count overflows, at which point the
 853          * timer lists will be switched and the next expiry time can be
 854          * re-assessed.  */
 855         *pxListWasEmpty = listLIST_IS_EMPTY( pxCurrentTimerList );
 856
 857         if( *pxListWasEmpty == pdFALSE )
 858         {
 859             xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );
 860         }
 861         else
 862         {
 863             /* Ensure the task unblocks when the tick count rolls over. */
 864             xNextExpireTime = ( TickType_t ) 0U;
 865         }
 866
 867         return xNextExpireTime;
 868     }
 869 /*-----------------------------------------------------------*/
 870
 871     static TickType_t prvSampleTimeNow( BaseType_t * const pxTimerListsWereSwitched )
 872     {
 873         TickType_t xTimeNow;
 874         PRIVILEGED_DATA static TickType_t xLastTime = ( TickType_t ) 0U;
 875
 876         xTimeNow = xTaskGetTickCount();
 877
 878         if( xTimeNow < xLastTime )
 879         {
 880             prvSwitchTimerLists();
 881             *pxTimerListsWereSwitched = pdTRUE;
 882         }
 883         else
 884         {
 885             *pxTimerListsWereSwitched = pdFALSE;
 886         }
 887
 888         xLastTime = xTimeNow;
 889
 890         return xTimeNow;
 891     }
 892 /*-----------------------------------------------------------*/
 893
 894     static BaseType_t prvInsertTimerInActiveList( Timer_t * const pxTimer,
 895                                                   const TickType_t xNextExpiryTime,
 896                                                   const TickType_t xTimeNow,
 897                                                   const TickType_t xCommandTime )
 898     {
 899         BaseType_t xProcessTimerNow = pdFALSE;
 900
 901         listSET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ), xNextExpiryTime );
 902         listSET_LIST_ITEM_OWNER( &( pxTimer->xTimerListItem ), pxTimer );
 903
 904         if( xNextExpiryTime <= xTimeNow )
 905         {
 906             /* Has the expiry time elapsed between the command to start/reset a
 907              * timer was issued, and the time the command was processed? */
 908             if( ( ( TickType_t ) ( xTimeNow - xCommandTime ) ) >= pxTimer->xTimerPeriodInTicks )
 909             {
 910                 /* The time between a command being issued and the command being
 911                  * processed actually exceeds the timers period.  */
 912                 xProcessTimerNow = pdTRUE;
 913             }
 914             else
 915             {
 916                 vListInsert( pxOverflowTimerList, &( pxTimer->xTimerListItem ) );
 917             }
 918         }
 919         else
 920         {
 921             if( ( xTimeNow < xCommandTime ) && ( xNextExpiryTime >= xCommandTime ) )
 922             {
 923                 /* If, since the command was issued, the tick count has overflowed
 924                  * but the expiry time has not, then the timer must have already passed
 925                  * its expiry time and should be processed immediately. */
 926                 xProcessTimerNow = pdTRUE;
 927             }
 928             else
 929             {
 930                 vListInsert( pxCurrentTimerList, &( pxTimer->xTimerListItem ) );
 931             }
 932         }
 933
 934         return xProcessTimerNow;
 935     }
 936 /*-----------------------------------------------------------*/
 937
 938     static void prvProcessReceivedCommands( void )
 939     {
 940         DaemonTaskMessage_t xMessage = { 0 };
 941         Timer_t * pxTimer;
 942         BaseType_t xTimerListsWereSwitched;
 943         TickType_t xTimeNow;
 944
 945         while( xQueueReceive( xTimerQueue, &xMessage, tmrNO_DELAY ) != pdFAIL )
 946         {
 947             #if ( INCLUDE_xTimerPendFunctionCall == 1 )
 948             {
 949                 /* Negative commands are pended function calls rather than timer
 950                  * commands. */
 951                 if( xMessage.xMessageID < ( BaseType_t ) 0 )
 952                 {
 953                     const CallbackParameters_t * const pxCallback = &( xMessage.u.xCallbackParameters );
 954
 955                     /* The timer uses the xCallbackParameters member to request a
 956                      * callback be executed.  Check the callback is not NULL. */
 957                     configASSERT( pxCallback );
 958
 959                     /* Call the function. */
 960                     pxCallback->pxCallbackFunction( pxCallback->pvParameter1, pxCallback->ulParameter2 );
 961                 }
 962                 else
 963                 {
 964                     mtCOVERAGE_TEST_MARKER();
 965                 }
 966             }
 967             #endif /* INCLUDE_xTimerPendFunctionCall */
 968
 969             /* Commands that are positive are timer commands rather than pended
 970              * function calls. */
 971             if( xMessage.xMessageID >= ( BaseType_t ) 0 )
 972             {
 973                 /* The messages uses the xTimerParameters member to work on a
 974                  * software timer. */
 975                 pxTimer = xMessage.u.xTimerParameters.pxTimer;
 976
 977                 if( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) == pdFALSE )
 978                 {
 979                     /* The timer is in a list, remove it. */
 980                     ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );
 981                 }
 982                 else
 983                 {
 984                     mtCOVERAGE_TEST_MARKER();
 985                 }
 986
 987                 traceTIMER_COMMAND_RECEIVED( pxTimer, xMessage.xMessageID, xMessage.u.xTimerParameters.xMessageValue );
 988
 989                 /* In this case the xTimerListsWereSwitched parameter is not used, but
 990                  *  it must be present in the function call.  prvSampleTimeNow() must be
 991                  *  called after the message is received from xTimerQueue so there is no
 992                  *  possibility of a higher priority task adding a message to the message
 993                  *  queue with a time that is ahead of the timer daemon task (because it
 994                  *  pre-empted the timer daemon task after the xTimeNow value was set). */
 995                 xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );
 996
 997                 switch( xMessage.xMessageID )
 998                 {
 999                     case tmrCOMMAND_START:
1000                     case tmrCOMMAND_START_FROM_ISR:
1001                     case tmrCOMMAND_RESET:
1002                     case tmrCOMMAND_RESET_FROM_ISR:
1003                         /* Start or restart a timer. */
1004                         pxTimer->ucStatus |= ( uint8_t ) tmrSTATUS_IS_ACTIVE;
1005
1006                         if( prvInsertTimerInActiveList( pxTimer, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow, xMessage.u.xTimerParameters.xMessageValue ) != pdFALSE )
1007                         {
1008                             /* The timer expired before it was added to the active
1009                              * timer list.  Process it now. */
1010                             if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0U )
1011                             {
1012                                 prvReloadTimer( pxTimer, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow );
1013                             }
1014                             else
1015                             {
1016                                 pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
1017                             }
1018
1019                             /* Call the timer callback. */
1020                             traceTIMER_EXPIRED( pxTimer );
1021                             pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
1022                         }
1023                         else
1024                         {
1025                             mtCOVERAGE_TEST_MARKER();
1026                         }
1027
1028                         break;
1029
1030                     case tmrCOMMAND_STOP:
1031                     case tmrCOMMAND_STOP_FROM_ISR:
1032                         /* The timer has already been removed from the active list. */
1033                         pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
1034                         break;
1035
1036                     case tmrCOMMAND_CHANGE_PERIOD:
1037                     case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR:
1038                         pxTimer->ucStatus |= ( uint8_t ) tmrSTATUS_IS_ACTIVE;
1039                         pxTimer->xTimerPeriodInTicks = xMessage.u.xTimerParameters.xMessageValue;
1040                         configASSERT( ( pxTimer->xTimerPeriodInTicks > 0 ) );
1041
1042                         /* The new period does not really have a reference, and can
1043                          * be longer or shorter than the old one.  The command time is
1044                          * therefore set to the current time, and as the period cannot
1045                          * be zero the next expiry time can only be in the future,
1046                          * meaning (unlike for the xTimerStart() case above) there is
1047                          * no fail case that needs to be handled here. */
1048                         ( void ) prvInsertTimerInActiveList( pxTimer, ( xTimeNow + pxTimer->xTimerPeriodInTicks ), xTimeNow, xTimeNow );
1049                         break;
1050
1051                     case tmrCOMMAND_DELETE:
1052                         #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
1053                         {
1054                             /* The timer has already been removed from the active list,
1055                              * just free up the memory if the memory was dynamically
1056                              * allocated. */
1057                             if( ( pxTimer->ucStatus & tmrSTATUS_IS_STATICALLY_ALLOCATED ) == ( uint8_t ) 0 )
1058                             {
1059                                 vPortFree( pxTimer );
1060                             }
1061                             else
1062                             {
1063                                 pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
1064                             }
1065                         }
1066                         #else /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
1067                         {
1068                             /* If dynamic allocation is not enabled, the memory
1069                              * could not have been dynamically allocated. So there is
1070                              * no need to free the memory - just mark the timer as
1071                              * "not active". */
1072                             pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
1073                         }
1074                         #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
1075                         break;
1076
1077                     default:
1078                         /* Don't expect to get here. */
1079                         break;
1080                 }
1081             }
1082         }
1083     }
1084 /*-----------------------------------------------------------*/
1085
1086     static void prvSwitchTimerLists( void )
1087     {
1088         TickType_t xNextExpireTime;
1089         List_t * pxTemp;
1090
1091         /* The tick count has overflowed.  The timer lists must be switched.
1092          * If there are any timers still referenced from the current timer list
1093          * then they must have expired and should be processed before the lists
1094          * are switched. */
1095         while( listLIST_IS_EMPTY( pxCurrentTimerList ) == pdFALSE )
1096         {
1097             xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );
1098
1099             /* Process the expired timer.  For auto-reload timers, be careful to
1100              * process only expirations that occur on the current list.  Further
1101              * expirations must wait until after the lists are switched. */
1102             prvProcessExpiredTimer( xNextExpireTime, tmrMAX_TIME_BEFORE_OVERFLOW );
1103         }
1104
1105         pxTemp = pxCurrentTimerList;
1106         pxCurrentTimerList = pxOverflowTimerList;
1107         pxOverflowTimerList = pxTemp;
1108     }
1109 /*-----------------------------------------------------------*/
1110
1111     static void prvCheckForValidListAndQueue( void )
1112     {
1113         /* Check that the list from which active timers are referenced, and the
1114          * queue used to communicate with the timer service, have been
1115          * initialised. */
1116         taskENTER_CRITICAL();
1117         {
1118             if( xTimerQueue == NULL )
1119             {
1120                 vListInitialise( &xActiveTimerList1 );
1121                 vListInitialise( &xActiveTimerList2 );
1122                 pxCurrentTimerList = &xActiveTimerList1;
1123                 pxOverflowTimerList = &xActiveTimerList2;
1124
1125                 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
1126                 {
1127                     /* The timer queue is allocated statically in case
1128                      * configSUPPORT_DYNAMIC_ALLOCATION is 0. */
1129                     PRIVILEGED_DATA static StaticQueue_t xStaticTimerQueue;
1130                     PRIVILEGED_DATA static uint8_t ucStaticTimerQueueStorage[ ( size_t ) configTIMER_QUEUE_LENGTH * sizeof( DaemonTaskMessage_t ) ];
1131
1132                     xTimerQueue = xQueueCreateStatic( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, ( UBaseType_t ) sizeof( DaemonTaskMessage_t ), &( ucStaticTimerQueueStorage[ 0 ] ), &xStaticTimerQueue );
1133                 }
1134                 #else
1135                 {
1136                     xTimerQueue = xQueueCreate( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, ( UBaseType_t ) sizeof( DaemonTaskMessage_t ) );
1137                 }
1138                 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
1139
1140                 #if ( configQUEUE_REGISTRY_SIZE > 0 )
1141                 {
1142                     if( xTimerQueue != NULL )
1143                     {
1144                         vQueueAddToRegistry( xTimerQueue, "TmrQ" );
1145                     }
1146                     else
1147                     {
1148                         mtCOVERAGE_TEST_MARKER();
1149                     }
1150                 }
1151                 #endif /* configQUEUE_REGISTRY_SIZE */
1152             }
1153             else
1154             {
1155                 mtCOVERAGE_TEST_MARKER();
1156             }
1157         }
1158         taskEXIT_CRITICAL();
1159     }
1160 /*-----------------------------------------------------------*/
1161
1162     BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer )
1163     {
1164         BaseType_t xReturn;
1165         Timer_t * pxTimer = xTimer;
1166
1167         traceENTER_xTimerIsTimerActive( xTimer );
1168
1169         configASSERT( xTimer );
1170
1171         /* Is the timer in the list of active timers? */
1172         taskENTER_CRITICAL();
1173         {
1174             if( ( pxTimer->ucStatus & tmrSTATUS_IS_ACTIVE ) == 0U )
1175             {
1176                 xReturn = pdFALSE;
1177             }
1178             else
1179             {
1180                 xReturn = pdTRUE;
1181             }
1182         }
1183         taskEXIT_CRITICAL();
1184
1185         traceRETURN_xTimerIsTimerActive( xReturn );
1186
1187         return xReturn;
1188     }
1189 /*-----------------------------------------------------------*/
1190
1191     void * pvTimerGetTimerID( const TimerHandle_t xTimer )
1192     {
1193         Timer_t * const pxTimer = xTimer;
1194         void * pvReturn;
1195
1196         traceENTER_pvTimerGetTimerID( xTimer );
1197
1198         configASSERT( xTimer );
1199
1200         taskENTER_CRITICAL();
1201         {
1202             pvReturn = pxTimer->pvTimerID;
1203         }
1204         taskEXIT_CRITICAL();
1205
1206         traceRETURN_pvTimerGetTimerID( pvReturn );
1207
1208         return pvReturn;
1209     }
1210 /*-----------------------------------------------------------*/
1211
1212     void vTimerSetTimerID( TimerHandle_t xTimer,
1213                            void * pvNewID )
1214     {
1215         Timer_t * const pxTimer = xTimer;
1216
1217         traceENTER_vTimerSetTimerID( xTimer, pvNewID );
1218
1219         configASSERT( xTimer );
1220
1221         taskENTER_CRITICAL();
1222         {
1223             pxTimer->pvTimerID = pvNewID;
1224         }
1225         taskEXIT_CRITICAL();
1226
1227         traceRETURN_vTimerSetTimerID();
1228     }
1229 /*-----------------------------------------------------------*/
1230
1231     #if ( INCLUDE_xTimerPendFunctionCall == 1 )
1232
1233         BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend,
1234                                                   void * pvParameter1,
1235                                                   uint32_t ulParameter2,
1236                                                   BaseType_t * pxHigherPriorityTaskWoken )
1237         {
1238             DaemonTaskMessage_t xMessage;
1239             BaseType_t xReturn;
1240
1241             traceENTER_xTimerPendFunctionCallFromISR( xFunctionToPend, pvParameter1, ulParameter2, pxHigherPriorityTaskWoken );
1242
1243             /* Complete the message with the function parameters and post it to the
1244              * daemon task. */
1245             xMessage.xMessageID = tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR;
1246             xMessage.u.xCallbackParameters.pxCallbackFunction = xFunctionToPend;
1247             xMessage.u.xCallbackParameters.pvParameter1 = pvParameter1;
1248             xMessage.u.xCallbackParameters.ulParameter2 = ulParameter2;
1249
1250             xReturn = xQueueSendFromISR( xTimerQueue, &xMessage, pxHigherPriorityTaskWoken );
1251
1252             tracePEND_FUNC_CALL_FROM_ISR( xFunctionToPend, pvParameter1, ulParameter2, xReturn );
1253             traceRETURN_xTimerPendFunctionCallFromISR( xReturn );
1254
1255             return xReturn;
1256         }
1257
1258     #endif /* INCLUDE_xTimerPendFunctionCall */
1259 /*-----------------------------------------------------------*/
1260
1261     #if ( INCLUDE_xTimerPendFunctionCall == 1 )
1262
1263         BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,
1264                                            void * pvParameter1,
1265                                            uint32_t ulParameter2,
1266                                            TickType_t xTicksToWait )
1267         {
1268             DaemonTaskMessage_t xMessage;
1269             BaseType_t xReturn;
1270
1271             traceENTER_xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );
1272
1273             /* This function can only be called after a timer has been created or
1274              * after the scheduler has been started because, until then, the timer
1275              * queue does not exist. */
1276             configASSERT( xTimerQueue );
1277
1278             /* Complete the message with the function parameters and post it to the
1279              * daemon task. */
1280             xMessage.xMessageID = tmrCOMMAND_EXECUTE_CALLBACK;
1281             xMessage.u.xCallbackParameters.pxCallbackFunction = xFunctionToPend;
1282             xMessage.u.xCallbackParameters.pvParameter1 = pvParameter1;
1283             xMessage.u.xCallbackParameters.ulParameter2 = ulParameter2;
1284
1285             xReturn = xQueueSendToBack( xTimerQueue, &xMessage, xTicksToWait );
1286
1287             tracePEND_FUNC_CALL( xFunctionToPend, pvParameter1, ulParameter2, xReturn );
1288             traceRETURN_xTimerPendFunctionCall( xReturn );
1289
1290             return xReturn;
1291         }
1292
1293     #endif /* INCLUDE_xTimerPendFunctionCall */
1294 /*-----------------------------------------------------------*/
1295
1296     #if ( configUSE_TRACE_FACILITY == 1 )
1297
1298         UBaseType_t uxTimerGetTimerNumber( TimerHandle_t xTimer )
1299         {
1300             traceENTER_uxTimerGetTimerNumber( xTimer );
1301
1302             traceRETURN_uxTimerGetTimerNumber( ( ( Timer_t * ) xTimer )->uxTimerNumber );
1303
1304             return ( ( Timer_t * ) xTimer )->uxTimerNumber;
1305         }
1306
1307     #endif /* configUSE_TRACE_FACILITY */
1308 /*-----------------------------------------------------------*/
1309
1310     #if ( configUSE_TRACE_FACILITY == 1 )
1311
1312         void vTimerSetTimerNumber( TimerHandle_t xTimer,
1313                                    UBaseType_t uxTimerNumber )
1314         {
1315             traceENTER_vTimerSetTimerNumber( xTimer, uxTimerNumber );
1316
1317             ( ( Timer_t * ) xTimer )->uxTimerNumber = uxTimerNumber;
1318
1319             traceRETURN_vTimerSetTimerNumber();
1320         }
1321
1322     #endif /* configUSE_TRACE_FACILITY */
1323 /*-----------------------------------------------------------*/
1324
1325 /*
1326  * Reset the state in this file. This state is normally initialized at start up.
1327  * This function must be called by the application before restarting the
1328  * scheduler.
1329  */
1330     void vTimerResetState( void )
1331     {
1332         xTimerQueue = NULL;
1333         xTimerTaskHandle = NULL;
1334     }
1335 /*-----------------------------------------------------------*/
1336
1337 /* This entire source file will be skipped if the application is not configured
1338  * to include software timer functionality.  If you want to include software timer
1339  * functionality then ensure configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
1340 #endif /* configUSE_TIMERS == 1 */