begriffs open source - freertos/blob - portable/GCC/ARM_CM4_MPU/mpu_wrappers_v2_asm.c

   1 /*
   2  * FreeRTOS Kernel V11.0.1
   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 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
  30  * all the API functions to use the MPU wrappers.  That should only be done when
  31  * task.h is included from an application file. */
  32 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  33
  34 /* Scheduler includes. */
  35 #include "FreeRTOS.h"
  36 #include "task.h"
  37 #include "queue.h"
  38 #include "timers.h"
  39 #include "event_groups.h"
  40 #include "stream_buffer.h"
  41 #include "mpu_prototypes.h"
  42 #include "mpu_syscall_numbers.h"
  43
  44 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  45 /*-----------------------------------------------------------*/
  46
  47 #if ( configUSE_MPU_WRAPPERS_V1 == 0 )
  48
  49     #if ( INCLUDE_xTaskDelayUntil == 1 )
  50
  51         BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
  52                                         const TickType_t xTimeIncrement ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
  53
  54         BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
  55                                         const TickType_t xTimeIncrement ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
  56         {
  57             __asm volatile
  58             (
  59                 " .syntax unified                                       \n"
  60                 " .extern MPU_xTaskDelayUntilImpl                       \n"
  61                 "                                                       \n"
  62                 " push {r0}                                             \n"
  63                 " mrs r0, control                                       \n"
  64                 " tst r0, #1                                            \n"
  65                 " bne MPU_xTaskDelayUntil_Unpriv                        \n"
  66                 " MPU_xTaskDelayUntil_Priv:                             \n"
  67                 "     pop {r0}                                          \n"
  68                 "     b MPU_xTaskDelayUntilImpl                         \n"
  69                 " MPU_xTaskDelayUntil_Unpriv:                           \n"
  70                 "     pop {r0}                                          \n"
  71                 "     svc %0                                            \n"
  72                 "                                                       \n"
  73                 : : "i" ( SYSTEM_CALL_xTaskDelayUntil ) : "memory"
  74             );
  75         }
  76
  77     #endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */
  78 /*-----------------------------------------------------------*/
  79
  80     #if ( INCLUDE_xTaskAbortDelay == 1 )
  81
  82         BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
  83
  84         BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
  85         {
  86             __asm volatile
  87             (
  88                 " .syntax unified                                       \n"
  89                 " .extern MPU_xTaskAbortDelayImpl                       \n"
  90                 "                                                       \n"
  91                 " push {r0}                                             \n"
  92                 " mrs r0, control                                       \n"
  93                 " tst r0, #1                                            \n"
  94                 " bne MPU_xTaskAbortDelay_Unpriv                        \n"
  95                 " MPU_xTaskAbortDelay_Priv:                             \n"
  96                 "     pop {r0}                                          \n"
  97                 "     b MPU_xTaskAbortDelayImpl                         \n"
  98                 " MPU_xTaskAbortDelay_Unpriv:                           \n"
  99                 "     pop {r0}                                          \n"
 100                 "     svc %0                                            \n"
 101                 "                                                       \n"
 102                 : : "i" ( SYSTEM_CALL_xTaskAbortDelay ) : "memory"
 103             );
 104         }
 105
 106     #endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */
 107 /*-----------------------------------------------------------*/
 108
 109     #if ( INCLUDE_vTaskDelay == 1 )
 110
 111         void MPU_vTaskDelay( const TickType_t xTicksToDelay ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 112
 113         void MPU_vTaskDelay( const TickType_t xTicksToDelay ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 114         {
 115             __asm volatile
 116             (
 117                 " .syntax unified                                       \n"
 118                 " .extern MPU_vTaskDelayImpl                            \n"
 119                 "                                                       \n"
 120                 " push {r0}                                             \n"
 121                 " mrs r0, control                                       \n"
 122                 " tst r0, #1                                            \n"
 123                 " bne MPU_vTaskDelay_Unpriv                             \n"
 124                 " MPU_vTaskDelay_Priv:                                  \n"
 125                 "     pop {r0}                                          \n"
 126                 "     b MPU_vTaskDelayImpl                              \n"
 127                 " MPU_vTaskDelay_Unpriv:                                \n"
 128                 "     pop {r0}                                          \n"
 129                 "     svc %0                                            \n"
 130                 "                                                       \n"
 131                 : : "i" ( SYSTEM_CALL_vTaskDelay ) : "memory"
 132             );
 133         }
 134
 135     #endif /* if ( INCLUDE_vTaskDelay == 1 ) */
 136 /*-----------------------------------------------------------*/
 137
 138     #if ( INCLUDE_uxTaskPriorityGet == 1 )
 139
 140         UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 141
 142         UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 143         {
 144             __asm volatile
 145             (
 146                 " .syntax unified                                       \n"
 147                 " .extern MPU_uxTaskPriorityGetImpl                     \n"
 148                 "                                                       \n"
 149                 " push {r0}                                             \n"
 150                 " mrs r0, control                                       \n"
 151                 " tst r0, #1                                            \n"
 152                 " bne MPU_uxTaskPriorityGet_Unpriv                      \n"
 153                 " MPU_uxTaskPriorityGet_Priv:                           \n"
 154                 "     pop {r0}                                          \n"
 155                 "     b MPU_uxTaskPriorityGetImpl                       \n"
 156                 " MPU_uxTaskPriorityGet_Unpriv:                         \n"
 157                 "     pop {r0}                                          \n"
 158                 "     svc %0                                            \n"
 159                 "                                                       \n"
 160                 : : "i" ( SYSTEM_CALL_uxTaskPriorityGet ) : "memory"
 161             );
 162         }
 163
 164     #endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */
 165 /*-----------------------------------------------------------*/
 166
 167     #if ( INCLUDE_eTaskGetState == 1 )
 168
 169         eTaskState MPU_eTaskGetState( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 170
 171         eTaskState MPU_eTaskGetState( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 172         {
 173             __asm volatile
 174             (
 175                 " .syntax unified                                       \n"
 176                 " .extern MPU_eTaskGetStateImpl                         \n"
 177                 "                                                       \n"
 178                 " push {r0}                                             \n"
 179                 " mrs r0, control                                       \n"
 180                 " tst r0, #1                                            \n"
 181                 " bne MPU_eTaskGetState_Unpriv                          \n"
 182                 " MPU_eTaskGetState_Priv:                               \n"
 183                 "     pop {r0}                                          \n"
 184                 "     b MPU_eTaskGetStateImpl                           \n"
 185                 " MPU_eTaskGetState_Unpriv:                             \n"
 186                 "     pop {r0}                                          \n"
 187                 "     svc %0                                            \n"
 188                 "                                                       \n"
 189                 : : "i" ( SYSTEM_CALL_eTaskGetState ) : "memory"
 190             );
 191         }
 192
 193     #endif /* if ( INCLUDE_eTaskGetState == 1 ) */
 194 /*-----------------------------------------------------------*/
 195
 196     #if ( configUSE_TRACE_FACILITY == 1 )
 197
 198         void MPU_vTaskGetInfo( TaskHandle_t xTask,
 199                                TaskStatus_t * pxTaskStatus,
 200                                BaseType_t xGetFreeStackSpace,
 201                                eTaskState eState ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 202
 203         void MPU_vTaskGetInfo( TaskHandle_t xTask,
 204                                TaskStatus_t * pxTaskStatus,
 205                                BaseType_t xGetFreeStackSpace,
 206                                eTaskState eState ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 207         {
 208             __asm volatile
 209             (
 210                 " .syntax unified                                       \n"
 211                 " .extern MPU_vTaskGetInfoImpl                          \n"
 212                 "                                                       \n"
 213                 " push {r0}                                             \n"
 214                 " mrs r0, control                                       \n"
 215                 " tst r0, #1                                            \n"
 216                 " bne MPU_vTaskGetInfo_Unpriv                           \n"
 217                 " MPU_vTaskGetInfo_Priv:                                \n"
 218                 "     pop {r0}                                          \n"
 219                 "     b MPU_vTaskGetInfoImpl                            \n"
 220                 " MPU_vTaskGetInfo_Unpriv:                              \n"
 221                 "     pop {r0}                                          \n"
 222                 "     svc %0                                            \n"
 223                 "                                                       \n"
 224                 : : "i" ( SYSTEM_CALL_vTaskGetInfo ) : "memory"
 225             );
 226         }
 227
 228     #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
 229 /*-----------------------------------------------------------*/
 230
 231     #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
 232
 233         TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 234
 235         TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 236         {
 237             __asm volatile
 238             (
 239                 " .syntax unified                                       \n"
 240                 " .extern MPU_xTaskGetIdleTaskHandleImpl                \n"
 241                 "                                                       \n"
 242                 " push {r0}                                             \n"
 243                 " mrs r0, control                                       \n"
 244                 " tst r0, #1                                            \n"
 245                 " bne MPU_xTaskGetIdleTaskHandle_Unpriv                 \n"
 246                 " MPU_xTaskGetIdleTaskHandle_Priv:                      \n"
 247                 "     pop {r0}                                          \n"
 248                 "     b MPU_xTaskGetIdleTaskHandleImpl                  \n"
 249                 " MPU_xTaskGetIdleTaskHandle_Unpriv:                    \n"
 250                 "     pop {r0}                                          \n"
 251                 "     svc %0                                            \n"
 252                 "                                                       \n"
 253                 : : "i" ( SYSTEM_CALL_xTaskGetIdleTaskHandle ) : "memory"
 254             );
 255         }
 256
 257     #endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */
 258 /*-----------------------------------------------------------*/
 259
 260     #if ( INCLUDE_vTaskSuspend == 1 )
 261
 262         void MPU_vTaskSuspend( TaskHandle_t xTaskToSuspend ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 263
 264         void MPU_vTaskSuspend( TaskHandle_t xTaskToSuspend ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 265         {
 266             __asm volatile
 267             (
 268                 " .syntax unified                                       \n"
 269                 " .extern MPU_vTaskSuspendImpl                          \n"
 270                 "                                                       \n"
 271                 " push {r0}                                             \n"
 272                 " mrs r0, control                                       \n"
 273                 " tst r0, #1                                            \n"
 274                 " bne MPU_vTaskSuspend_Unpriv                           \n"
 275                 " MPU_vTaskSuspend_Priv:                                \n"
 276                 "     pop {r0}                                          \n"
 277                 "     b MPU_vTaskSuspendImpl                            \n"
 278                 " MPU_vTaskSuspend_Unpriv:                              \n"
 279                 "     pop {r0}                                          \n"
 280                 "     svc %0                                            \n"
 281                 "                                                       \n"
 282                 : : "i" ( SYSTEM_CALL_vTaskSuspend ) : "memory"
 283             );
 284         }
 285
 286     #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
 287 /*-----------------------------------------------------------*/
 288
 289     #if ( INCLUDE_vTaskSuspend == 1 )
 290
 291         void MPU_vTaskResume( TaskHandle_t xTaskToResume ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 292
 293         void MPU_vTaskResume( TaskHandle_t xTaskToResume ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 294         {
 295             __asm volatile
 296             (
 297                 " .syntax unified                                       \n"
 298                 " .extern MPU_vTaskResumeImpl                           \n"
 299                 "                                                       \n"
 300                 " push {r0}                                             \n"
 301                 " mrs r0, control                                       \n"
 302                 " tst r0, #1                                            \n"
 303                 " bne MPU_vTaskResume_Unpriv                            \n"
 304                 " MPU_vTaskResume_Priv:                                 \n"
 305                 "     pop {r0}                                          \n"
 306                 "     b MPU_vTaskResumeImpl                             \n"
 307                 " MPU_vTaskResume_Unpriv:                               \n"
 308                 "     pop {r0}                                          \n"
 309                 "     svc %0                                            \n"
 310                 "                                                       \n"
 311                 : : "i" ( SYSTEM_CALL_vTaskResume ) : "memory"
 312             );
 313         }
 314
 315     #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
 316 /*-----------------------------------------------------------*/
 317
 318     TickType_t MPU_xTaskGetTickCount( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 319
 320     TickType_t MPU_xTaskGetTickCount( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 321     {
 322         __asm volatile
 323         (
 324             " .syntax unified                                       \n"
 325             " .extern MPU_xTaskGetTickCountImpl                     \n"
 326             "                                                       \n"
 327             " push {r0}                                             \n"
 328             " mrs r0, control                                       \n"
 329             " tst r0, #1                                            \n"
 330             " bne MPU_xTaskGetTickCount_Unpriv                      \n"
 331             " MPU_xTaskGetTickCount_Priv:                           \n"
 332             "     pop {r0}                                          \n"
 333             "     b MPU_xTaskGetTickCountImpl                       \n"
 334             " MPU_xTaskGetTickCount_Unpriv:                         \n"
 335             "     pop {r0}                                          \n"
 336             "     svc %0                                            \n"
 337             "                                                       \n"
 338             : : "i" ( SYSTEM_CALL_xTaskGetTickCount ) : "memory"
 339         );
 340     }
 341 /*-----------------------------------------------------------*/
 342
 343     UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 344
 345     UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 346     {
 347         __asm volatile
 348         (
 349             " .syntax unified                                       \n"
 350             " .extern MPU_uxTaskGetNumberOfTasksImpl                \n"
 351             "                                                       \n"
 352             " push {r0}                                             \n"
 353             " mrs r0, control                                       \n"
 354             " tst r0, #1                                            \n"
 355             " bne MPU_uxTaskGetNumberOfTasks_Unpriv                 \n"
 356             " MPU_uxTaskGetNumberOfTasks_Priv:                      \n"
 357             "     pop {r0}                                          \n"
 358             "     b MPU_uxTaskGetNumberOfTasksImpl                  \n"
 359             " MPU_uxTaskGetNumberOfTasks_Unpriv:                    \n"
 360             "     pop {r0}                                          \n"
 361             "     svc %0                                            \n"
 362             "                                                       \n"
 363             : : "i" ( SYSTEM_CALL_uxTaskGetNumberOfTasks ) : "memory"
 364         );
 365     }
 366 /*-----------------------------------------------------------*/
 367
 368     #if ( configGENERATE_RUN_TIME_STATS == 1 )
 369
 370         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounter( const TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 371
 372         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounter( const TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 373         {
 374             __asm volatile
 375             (
 376                 " .syntax unified                                       \n"
 377                 " .extern MPU_ulTaskGetRunTimeCounterImpl               \n"
 378                 "                                                       \n"
 379                 " push {r0}                                             \n"
 380                 " mrs r0, control                                       \n"
 381                 " tst r0, #1                                            \n"
 382                 " bne MPU_ulTaskGetRunTimeCounter_Unpriv                \n"
 383                 " MPU_ulTaskGetRunTimeCounter_Priv:                     \n"
 384                 "     pop {r0}                                          \n"
 385                 "     b MPU_ulTaskGetRunTimeCounterImpl                 \n"
 386                 " MPU_ulTaskGetRunTimeCounter_Unpriv:                   \n"
 387                 "     pop {r0}                                          \n"
 388                 "     svc %0                                            \n"
 389                 "                                                       \n"
 390                 : : "i" ( SYSTEM_CALL_ulTaskGetRunTimeCounter ) : "memory"
 391             );
 392         }
 393
 394     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) */
 395 /*-----------------------------------------------------------*/
 396
 397     #if ( configGENERATE_RUN_TIME_STATS == 1 )
 398
 399         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercent( const TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 400
 401         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercent( const TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 402         {
 403             __asm volatile
 404             (
 405                 " .syntax unified                                       \n"
 406                 " .extern MPU_ulTaskGetRunTimePercentImpl               \n"
 407                 "                                                       \n"
 408                 " push {r0}                                             \n"
 409                 " mrs r0, control                                       \n"
 410                 " tst r0, #1                                            \n"
 411                 " bne MPU_ulTaskGetRunTimePercent_Unpriv                \n"
 412                 " MPU_ulTaskGetRunTimePercent_Priv:                     \n"
 413                 "     pop {r0}                                          \n"
 414                 "     b MPU_ulTaskGetRunTimePercentImpl                 \n"
 415                 " MPU_ulTaskGetRunTimePercent_Unpriv:                   \n"
 416                 "     pop {r0}                                          \n"
 417                 "     svc %0                                            \n"
 418                 "                                                       \n"
 419                 : : "i" ( SYSTEM_CALL_ulTaskGetRunTimePercent ) : "memory"
 420             );
 421         }
 422
 423     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) */
 424 /*-----------------------------------------------------------*/
 425
 426     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
 427
 428         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 429
 430         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 431         {
 432             __asm volatile
 433             (
 434                 " .syntax unified                                       \n"
 435                 " .extern MPU_ulTaskGetIdleRunTimePercentImpl           \n"
 436                 "                                                       \n"
 437                 " push {r0}                                             \n"
 438                 " mrs r0, control                                       \n"
 439                 " tst r0, #1                                            \n"
 440                 " bne MPU_ulTaskGetIdleRunTimePercent_Unpriv            \n"
 441                 " MPU_ulTaskGetIdleRunTimePercent_Priv:                 \n"
 442                 "     pop {r0}                                          \n"
 443                 "     b MPU_ulTaskGetIdleRunTimePercentImpl             \n"
 444                 " MPU_ulTaskGetIdleRunTimePercent_Unpriv:               \n"
 445                 "     pop {r0}                                          \n"
 446                 "     svc %0                                            \n"
 447                 "                                                       \n"
 448                 : : "i" ( SYSTEM_CALL_ulTaskGetIdleRunTimePercent ) : "memory"
 449             );
 450         }
 451
 452     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
 453 /*-----------------------------------------------------------*/
 454
 455     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
 456
 457         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 458
 459         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 460         {
 461             __asm volatile
 462             (
 463                 " .syntax unified                                       \n"
 464                 " .extern MPU_ulTaskGetIdleRunTimeCounterImpl           \n"
 465                 "                                                       \n"
 466                 " push {r0}                                             \n"
 467                 " mrs r0, control                                       \n"
 468                 " tst r0, #1                                            \n"
 469                 " bne MPU_ulTaskGetIdleRunTimeCounter_Unpriv            \n"
 470                 " MPU_ulTaskGetIdleRunTimeCounter_Priv:                 \n"
 471                 "     pop {r0}                                          \n"
 472                 "     b MPU_ulTaskGetIdleRunTimeCounterImpl             \n"
 473                 " MPU_ulTaskGetIdleRunTimeCounter_Unpriv:               \n"
 474                 "     pop {r0}                                          \n"
 475                 "     svc %0                                            \n"
 476                 "                                                       \n"
 477                 : : "i" ( SYSTEM_CALL_ulTaskGetIdleRunTimeCounter ) : "memory"
 478             );
 479         }
 480
 481     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
 482 /*-----------------------------------------------------------*/
 483
 484     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 485
 486         void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,
 487                                              TaskHookFunction_t pxHookFunction ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 488
 489         void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,
 490                                              TaskHookFunction_t pxHookFunction ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 491         {
 492             __asm volatile
 493             (
 494                 " .syntax unified                                       \n"
 495                 " .extern MPU_vTaskSetApplicationTaskTagImpl            \n"
 496                 "                                                       \n"
 497                 " push {r0}                                             \n"
 498                 " mrs r0, control                                       \n"
 499                 " tst r0, #1                                            \n"
 500                 " bne MPU_vTaskSetApplicationTaskTag_Unpriv             \n"
 501                 " MPU_vTaskSetApplicationTaskTag_Priv:                  \n"
 502                 "     pop {r0}                                          \n"
 503                 "     b MPU_vTaskSetApplicationTaskTagImpl              \n"
 504                 " MPU_vTaskSetApplicationTaskTag_Unpriv:                \n"
 505                 "     pop {r0}                                          \n"
 506                 "     svc %0                                            \n"
 507                 "                                                       \n"
 508                 : : "i" ( SYSTEM_CALL_vTaskSetApplicationTaskTag ) : "memory"
 509             );
 510         }
 511
 512     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 513 /*-----------------------------------------------------------*/
 514
 515     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 516
 517         TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 518
 519         TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 520         {
 521             __asm volatile
 522             (
 523                 " .syntax unified                                       \n"
 524                 " .extern MPU_xTaskGetApplicationTaskTagImpl            \n"
 525                 "                                                       \n"
 526                 " push {r0}                                             \n"
 527                 " mrs r0, control                                       \n"
 528                 " tst r0, #1                                            \n"
 529                 " bne MPU_xTaskGetApplicationTaskTag_Unpriv             \n"
 530                 " MPU_xTaskGetApplicationTaskTag_Priv:                  \n"
 531                 "     pop {r0}                                          \n"
 532                 "     b MPU_xTaskGetApplicationTaskTagImpl              \n"
 533                 " MPU_xTaskGetApplicationTaskTag_Unpriv:                \n"
 534                 "     pop {r0}                                          \n"
 535                 "     svc %0                                            \n"
 536                 "                                                       \n"
 537                 : : "i" ( SYSTEM_CALL_xTaskGetApplicationTaskTag ) : "memory"
 538             );
 539         }
 540
 541     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 542 /*-----------------------------------------------------------*/
 543
 544     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
 545
 546         void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
 547                                                     BaseType_t xIndex,
 548                                                     void * pvValue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 549
 550         void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
 551                                                     BaseType_t xIndex,
 552                                                     void * pvValue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 553         {
 554             __asm volatile
 555             (
 556                 " .syntax unified                                       \n"
 557                 " .extern MPU_vTaskSetThreadLocalStoragePointerImpl     \n"
 558                 "                                                       \n"
 559                 " push {r0}                                             \n"
 560                 " mrs r0, control                                       \n"
 561                 " tst r0, #1                                            \n"
 562                 " bne MPU_vTaskSetThreadLocalStoragePointer_Unpriv      \n"
 563                 " MPU_vTaskSetThreadLocalStoragePointer_Priv:           \n"
 564                 "     pop {r0}                                          \n"
 565                 "     b MPU_vTaskSetThreadLocalStoragePointerImpl       \n"
 566                 " MPU_vTaskSetThreadLocalStoragePointer_Unpriv:         \n"
 567                 "     pop {r0}                                          \n"
 568                 "     svc %0                                            \n"
 569                 "                                                       \n"
 570                 : : "i" ( SYSTEM_CALL_vTaskSetThreadLocalStoragePointer ) : "memory"
 571             );
 572         }
 573
 574     #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
 575 /*-----------------------------------------------------------*/
 576
 577     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
 578
 579         void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
 580                                                        BaseType_t xIndex ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 581
 582         void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
 583                                                        BaseType_t xIndex ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 584         {
 585             __asm volatile
 586             (
 587                 " .syntax unified                                       \n"
 588                 " .extern MPU_pvTaskGetThreadLocalStoragePointerImpl    \n"
 589                 "                                                       \n"
 590                 " push {r0}                                             \n"
 591                 " mrs r0, control                                       \n"
 592                 " tst r0, #1                                            \n"
 593                 " bne MPU_pvTaskGetThreadLocalStoragePointer_Unpriv     \n"
 594                 " MPU_pvTaskGetThreadLocalStoragePointer_Priv:          \n"
 595                 "     pop {r0}                                          \n"
 596                 "     b MPU_pvTaskGetThreadLocalStoragePointerImpl      \n"
 597                 " MPU_pvTaskGetThreadLocalStoragePointer_Unpriv:        \n"
 598                 "     pop {r0}                                          \n"
 599                 "     svc %0                                            \n"
 600                 "                                                       \n"
 601                 : : "i" ( SYSTEM_CALL_pvTaskGetThreadLocalStoragePointer ) : "memory"
 602             );
 603         }
 604
 605     #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
 606 /*-----------------------------------------------------------*/
 607
 608     #if ( configUSE_TRACE_FACILITY == 1 )
 609
 610         UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
 611                                               const UBaseType_t uxArraySize,
 612                                               configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 613
 614         UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
 615                                               const UBaseType_t uxArraySize,
 616                                               configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 617         {
 618             __asm volatile
 619             (
 620                 " .syntax unified                                       \n"
 621                 " .extern MPU_uxTaskGetSystemStateImpl                  \n"
 622                 "                                                       \n"
 623                 " push {r0}                                             \n"
 624                 " mrs r0, control                                       \n"
 625                 " tst r0, #1                                            \n"
 626                 " bne MPU_uxTaskGetSystemState_Unpriv                   \n"
 627                 " MPU_uxTaskGetSystemState_Priv:                        \n"
 628                 "     pop {r0}                                          \n"
 629                 "     b MPU_uxTaskGetSystemStateImpl                    \n"
 630                 " MPU_uxTaskGetSystemState_Unpriv:                      \n"
 631                 "     pop {r0}                                          \n"
 632                 "     svc %0                                            \n"
 633                 "                                                       \n"
 634                 : : "i" ( SYSTEM_CALL_uxTaskGetSystemState ) : "memory"
 635             );
 636         }
 637
 638     #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
 639 /*-----------------------------------------------------------*/
 640
 641     #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
 642
 643         UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 644
 645         UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 646         {
 647             __asm volatile
 648             (
 649                 " .syntax unified                                       \n"
 650                 " .extern MPU_uxTaskGetStackHighWaterMarkImpl           \n"
 651                 "                                                       \n"
 652                 " push {r0}                                             \n"
 653                 " mrs r0, control                                       \n"
 654                 " tst r0, #1                                            \n"
 655                 " bne MPU_uxTaskGetStackHighWaterMark_Unpriv            \n"
 656                 " MPU_uxTaskGetStackHighWaterMark_Priv:                 \n"
 657                 "     pop {r0}                                          \n"
 658                 "     b MPU_uxTaskGetStackHighWaterMarkImpl             \n"
 659                 " MPU_uxTaskGetStackHighWaterMark_Unpriv:               \n"
 660                 "     pop {r0}                                          \n"
 661                 "     svc %0                                            \n"
 662                 "                                                       \n"
 663                 : : "i" ( SYSTEM_CALL_uxTaskGetStackHighWaterMark ) : "memory"
 664             );
 665         }
 666
 667     #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */
 668 /*-----------------------------------------------------------*/
 669
 670     #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
 671
 672         configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 673
 674         configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 675         {
 676             __asm volatile
 677             (
 678                 " .syntax unified                                       \n"
 679                 " .extern MPU_uxTaskGetStackHighWaterMark2Impl          \n"
 680                 "                                                       \n"
 681                 " push {r0}                                             \n"
 682                 " mrs r0, control                                       \n"
 683                 " tst r0, #1                                            \n"
 684                 " bne MPU_uxTaskGetStackHighWaterMark2_Unpriv           \n"
 685                 " MPU_uxTaskGetStackHighWaterMark2_Priv:                \n"
 686                 "     pop {r0}                                          \n"
 687                 "     b MPU_uxTaskGetStackHighWaterMark2Impl            \n"
 688                 " MPU_uxTaskGetStackHighWaterMark2_Unpriv:              \n"
 689                 "     pop {r0}                                          \n"
 690                 "     svc %0                                            \n"
 691                 "                                                       \n"
 692                 : : "i" ( SYSTEM_CALL_uxTaskGetStackHighWaterMark2 ) : "memory"
 693             );
 694         }
 695
 696     #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */
 697 /*-----------------------------------------------------------*/
 698
 699     #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
 700
 701         TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 702
 703         TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 704         {
 705             __asm volatile
 706             (
 707                 " .syntax unified                                       \n"
 708                 " .extern MPU_xTaskGetCurrentTaskHandleImpl             \n"
 709                 "                                                       \n"
 710                 " push {r0}                                             \n"
 711                 " mrs r0, control                                       \n"
 712                 " tst r0, #1                                            \n"
 713                 " bne MPU_xTaskGetCurrentTaskHandle_Unpriv              \n"
 714                 " MPU_xTaskGetCurrentTaskHandle_Priv:                   \n"
 715                 "     pop {r0}                                          \n"
 716                 "     b MPU_xTaskGetCurrentTaskHandleImpl               \n"
 717                 " MPU_xTaskGetCurrentTaskHandle_Unpriv:                 \n"
 718                 "     pop {r0}                                          \n"
 719                 "     svc %0                                            \n"
 720                 "                                                       \n"
 721                 : : "i" ( SYSTEM_CALL_xTaskGetCurrentTaskHandle ) : "memory"
 722             );
 723         }
 724
 725     #endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */
 726 /*-----------------------------------------------------------*/
 727
 728     #if ( INCLUDE_xTaskGetSchedulerState == 1 )
 729
 730         BaseType_t MPU_xTaskGetSchedulerState( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 731
 732         BaseType_t MPU_xTaskGetSchedulerState( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 733         {
 734             __asm volatile
 735             (
 736                 " .syntax unified                                       \n"
 737                 " .extern MPU_xTaskGetSchedulerStateImpl                \n"
 738                 "                                                       \n"
 739                 " push {r0}                                             \n"
 740                 " mrs r0, control                                       \n"
 741                 " tst r0, #1                                            \n"
 742                 " bne MPU_xTaskGetSchedulerState_Unpriv                 \n"
 743                 " MPU_xTaskGetSchedulerState_Priv:                      \n"
 744                 "     pop {r0}                                          \n"
 745                 "     b MPU_xTaskGetSchedulerStateImpl                  \n"
 746                 " MPU_xTaskGetSchedulerState_Unpriv:                    \n"
 747                 "     pop {r0}                                          \n"
 748                 "     svc %0                                            \n"
 749                 "                                                       \n"
 750                 : : "i" ( SYSTEM_CALL_xTaskGetSchedulerState ) : "memory"
 751             );
 752         }
 753
 754     #endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */
 755 /*-----------------------------------------------------------*/
 756
 757     void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 758
 759     void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 760     {
 761         __asm volatile
 762         (
 763             " .syntax unified                                       \n"
 764             " .extern MPU_vTaskSetTimeOutStateImpl                  \n"
 765             "                                                       \n"
 766             " push {r0}                                             \n"
 767             " mrs r0, control                                       \n"
 768             " tst r0, #1                                            \n"
 769             " bne MPU_vTaskSetTimeOutState_Unpriv                   \n"
 770             " MPU_vTaskSetTimeOutState_Priv:                        \n"
 771             "     pop {r0}                                          \n"
 772             "     b MPU_vTaskSetTimeOutStateImpl                    \n"
 773             " MPU_vTaskSetTimeOutState_Unpriv:                      \n"
 774             "     pop {r0}                                          \n"
 775             "     svc %0                                            \n"
 776             "                                                       \n"
 777             : : "i" ( SYSTEM_CALL_vTaskSetTimeOutState ) : "memory"
 778         );
 779     }
 780 /*-----------------------------------------------------------*/
 781
 782     BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
 783                                          TickType_t * const pxTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 784
 785     BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
 786                                          TickType_t * const pxTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 787     {
 788         __asm volatile
 789         (
 790             " .syntax unified                                       \n"
 791             " .extern MPU_xTaskCheckForTimeOutImpl                  \n"
 792             "                                                       \n"
 793             " push {r0}                                             \n"
 794             " mrs r0, control                                       \n"
 795             " tst r0, #1                                            \n"
 796             " bne MPU_xTaskCheckForTimeOut_Unpriv                   \n"
 797             " MPU_xTaskCheckForTimeOut_Priv:                        \n"
 798             "     pop {r0}                                          \n"
 799             "     b MPU_xTaskCheckForTimeOutImpl                    \n"
 800             " MPU_xTaskCheckForTimeOut_Unpriv:                      \n"
 801             "     pop {r0}                                          \n"
 802             "     svc %0                                            \n"
 803             "                                                       \n"
 804             : : "i" ( SYSTEM_CALL_xTaskCheckForTimeOut ) : "memory"
 805         );
 806     }
 807 /*-----------------------------------------------------------*/
 808
 809     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 810
 811         BaseType_t MPU_xTaskGenericNotifyEntry( const xTaskGenericNotifyParams_t * pxParams ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 812
 813         BaseType_t MPU_xTaskGenericNotifyEntry( const xTaskGenericNotifyParams_t * pxParams ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 814         {
 815             __asm volatile
 816             (
 817                 " .syntax unified                                       \n"
 818                 " .extern MPU_xTaskGenericNotifyImpl                    \n"
 819                 "                                                       \n"
 820                 " push {r0}                                             \n"
 821                 " mrs r0, control                                       \n"
 822                 " tst r0, #1                                            \n"
 823                 " bne MPU_xTaskGenericNotify_Unpriv                     \n"
 824                 " MPU_xTaskGenericNotify_Priv:                          \n"
 825                 "     pop {r0}                                          \n"
 826                 "     b MPU_xTaskGenericNotifyImpl                      \n"
 827                 " MPU_xTaskGenericNotify_Unpriv:                        \n"
 828                 "     pop {r0}                                          \n"
 829                 "     svc %0                                            \n"
 830                 "                                                       \n"
 831                 : : "i" ( SYSTEM_CALL_xTaskGenericNotify ) : "memory"
 832             );
 833         }
 834
 835     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 836 /*-----------------------------------------------------------*/
 837
 838     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 839
 840         BaseType_t MPU_xTaskGenericNotifyWaitEntry( const xTaskGenericNotifyWaitParams_t * pxParams ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 841
 842         BaseType_t MPU_xTaskGenericNotifyWaitEntry( const xTaskGenericNotifyWaitParams_t * pxParams ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 843         {
 844             __asm volatile
 845             (
 846                 " .syntax unified                                       \n"
 847                 " .extern MPU_xTaskGenericNotifyWaitImpl                \n"
 848                 "                                                       \n"
 849                 " push {r0}                                             \n"
 850                 " mrs r0, control                                       \n"
 851                 " tst r0, #1                                            \n"
 852                 " bne MPU_xTaskGenericNotifyWait_Unpriv                 \n"
 853                 " MPU_xTaskGenericNotifyWait_Priv:                      \n"
 854                 "     pop {r0}                                          \n"
 855                 "     b MPU_xTaskGenericNotifyWaitImpl                  \n"
 856                 " MPU_xTaskGenericNotifyWait_Unpriv:                    \n"
 857                 "     pop {r0}                                          \n"
 858                 "     svc %0                                            \n"
 859                 "                                                       \n"
 860                 : : "i" ( SYSTEM_CALL_xTaskGenericNotifyWait ) : "memory"
 861             );
 862         }
 863
 864     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 865 /*-----------------------------------------------------------*/
 866
 867     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 868
 869         uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
 870                                               BaseType_t xClearCountOnExit,
 871                                               TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 872
 873         uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
 874                                               BaseType_t xClearCountOnExit,
 875                                               TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 876         {
 877             __asm volatile
 878             (
 879                 " .syntax unified                                       \n"
 880                 " .extern MPU_ulTaskGenericNotifyTakeImpl               \n"
 881                 "                                                       \n"
 882                 " push {r0}                                             \n"
 883                 " mrs r0, control                                       \n"
 884                 " tst r0, #1                                            \n"
 885                 " bne MPU_ulTaskGenericNotifyTake_Unpriv                \n"
 886                 " MPU_ulTaskGenericNotifyTake_Priv:                     \n"
 887                 "     pop {r0}                                          \n"
 888                 "     b MPU_ulTaskGenericNotifyTakeImpl                 \n"
 889                 " MPU_ulTaskGenericNotifyTake_Unpriv:                   \n"
 890                 "     pop {r0}                                          \n"
 891                 "     svc %0                                            \n"
 892                 "                                                       \n"
 893                 : : "i" ( SYSTEM_CALL_ulTaskGenericNotifyTake ) : "memory"
 894             );
 895         }
 896
 897     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 898 /*-----------------------------------------------------------*/
 899
 900     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 901
 902         BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,
 903                                                      UBaseType_t uxIndexToClear ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 904
 905         BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,
 906                                                      UBaseType_t uxIndexToClear ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 907         {
 908             __asm volatile
 909             (
 910                 " .syntax unified                                       \n"
 911                 " .extern MPU_xTaskGenericNotifyStateClearImpl          \n"
 912                 "                                                       \n"
 913                 " push {r0}                                             \n"
 914                 " mrs r0, control                                       \n"
 915                 " tst r0, #1                                            \n"
 916                 " bne MPU_xTaskGenericNotifyStateClear_Unpriv           \n"
 917                 " MPU_xTaskGenericNotifyStateClear_Priv:                \n"
 918                 "     pop {r0}                                          \n"
 919                 "     b MPU_xTaskGenericNotifyStateClearImpl            \n"
 920                 " MPU_xTaskGenericNotifyStateClear_Unpriv:              \n"
 921                 "     pop {r0}                                          \n"
 922                 "     svc %0                                            \n"
 923                 "                                                       \n"
 924                 : : "i" ( SYSTEM_CALL_xTaskGenericNotifyStateClear ) : "memory"
 925             );
 926         }
 927
 928     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 929 /*-----------------------------------------------------------*/
 930
 931     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 932
 933         uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
 934                                                     UBaseType_t uxIndexToClear,
 935                                                     uint32_t ulBitsToClear ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 936
 937         uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
 938                                                     UBaseType_t uxIndexToClear,
 939                                                     uint32_t ulBitsToClear ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 940         {
 941             __asm volatile
 942             (
 943                 " .syntax unified                                       \n"
 944                 " .extern MPU_ulTaskGenericNotifyValueClearImpl         \n"
 945                 "                                                       \n"
 946                 " push {r0}                                             \n"
 947                 " mrs r0, control                                       \n"
 948                 " tst r0, #1                                            \n"
 949                 " bne MPU_ulTaskGenericNotifyValueClear_Unpriv          \n"
 950                 " MPU_ulTaskGenericNotifyValueClear_Priv:               \n"
 951                 "     pop {r0}                                          \n"
 952                 "     b MPU_ulTaskGenericNotifyValueClearImpl           \n"
 953                 " MPU_ulTaskGenericNotifyValueClear_Unpriv:             \n"
 954                 "     pop {r0}                                          \n"
 955                 "     svc %0                                            \n"
 956                 "                                                       \n"
 957                 : : "i" ( SYSTEM_CALL_ulTaskGenericNotifyValueClear ) : "memory"
 958             );
 959         }
 960
 961     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 962 /*-----------------------------------------------------------*/
 963
 964     BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,
 965                                       const void * const pvItemToQueue,
 966                                       TickType_t xTicksToWait,
 967                                       const BaseType_t xCopyPosition ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 968
 969     BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,
 970                                       const void * const pvItemToQueue,
 971                                       TickType_t xTicksToWait,
 972                                       const BaseType_t xCopyPosition ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 973     {
 974         __asm volatile
 975         (
 976             " .syntax unified                                       \n"
 977             " .extern MPU_xQueueGenericSendImpl                     \n"
 978             "                                                       \n"
 979             " push {r0}                                             \n"
 980             " mrs r0, control                                       \n"
 981             " tst r0, #1                                            \n"
 982             " bne MPU_xQueueGenericSend_Unpriv                      \n"
 983             " MPU_xQueueGenericSend_Priv:                           \n"
 984             "     pop {r0}                                          \n"
 985             "     b MPU_xQueueGenericSendImpl                       \n"
 986             " MPU_xQueueGenericSend_Unpriv:                         \n"
 987             "     pop {r0}                                          \n"
 988             "     svc %0                                            \n"
 989             "                                                       \n"
 990             : : "i" ( SYSTEM_CALL_xQueueGenericSend ) : "memory"
 991         );
 992     }
 993 /*-----------------------------------------------------------*/
 994
 995     UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t xQueue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
 996
 997     UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t xQueue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
 998     {
 999         __asm volatile
1000         (
1001             " .syntax unified                                       \n"
1002             " .extern MPU_uxQueueMessagesWaitingImpl                \n"
1003             "                                                       \n"
1004             " push {r0}                                             \n"
1005             " mrs r0, control                                       \n"
1006             " tst r0, #1                                            \n"
1007             " bne MPU_uxQueueMessagesWaiting_Unpriv                 \n"
1008             " MPU_uxQueueMessagesWaiting_Priv:                      \n"
1009             "     pop {r0}                                          \n"
1010             "     b MPU_uxQueueMessagesWaitingImpl                  \n"
1011             " MPU_uxQueueMessagesWaiting_Unpriv:                    \n"
1012             "     pop {r0}                                          \n"
1013             "     svc %0                                            \n"
1014             "                                                       \n"
1015             : : "i" ( SYSTEM_CALL_uxQueueMessagesWaiting ) : "memory"
1016         );
1017     }
1018 /*-----------------------------------------------------------*/
1019
1020     UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1021
1022     UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1023     {
1024         __asm volatile
1025         (
1026             " .syntax unified                                       \n"
1027             " .extern MPU_uxQueueSpacesAvailableImpl                \n"
1028             "                                                       \n"
1029             " push {r0}                                             \n"
1030             " mrs r0, control                                       \n"
1031             " tst r0, #1                                            \n"
1032             " bne MPU_uxQueueSpacesAvailable_Unpriv                 \n"
1033             " MPU_uxQueueSpacesAvailable_Priv:                      \n"
1034             "     pop {r0}                                          \n"
1035             "     b MPU_uxQueueSpacesAvailableImpl                  \n"
1036             " MPU_uxQueueSpacesAvailable_Unpriv:                    \n"
1037             "     pop {r0}                                          \n"
1038             "     svc %0                                            \n"
1039             "                                                       \n"
1040             : : "i" ( SYSTEM_CALL_uxQueueSpacesAvailable ) : "memory"
1041         );
1042     }
1043 /*-----------------------------------------------------------*/
1044
1045     BaseType_t MPU_xQueueReceive( QueueHandle_t xQueue,
1046                                   void * const pvBuffer,
1047                                   TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1048
1049     BaseType_t MPU_xQueueReceive( QueueHandle_t xQueue,
1050                                   void * const pvBuffer,
1051                                   TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1052     {
1053         __asm volatile
1054         (
1055             " .syntax unified                                       \n"
1056             " .extern MPU_xQueueReceiveImpl                         \n"
1057             "                                                       \n"
1058             " push {r0}                                             \n"
1059             " mrs r0, control                                       \n"
1060             " tst r0, #1                                            \n"
1061             " bne MPU_xQueueReceive_Unpriv                          \n"
1062             " MPU_xQueueReceive_Priv:                               \n"
1063             "     pop {r0}                                          \n"
1064             "     b MPU_xQueueReceiveImpl                           \n"
1065             " MPU_xQueueReceive_Unpriv:                             \n"
1066             "     pop {r0}                                          \n"
1067             "     svc %0                                            \n"
1068             "                                                       \n"
1069             : : "i" ( SYSTEM_CALL_xQueueReceive ) : "memory"
1070         );
1071     }
1072 /*-----------------------------------------------------------*/
1073
1074     BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
1075                                void * const pvBuffer,
1076                                TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1077
1078     BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
1079                                void * const pvBuffer,
1080                                TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1081     {
1082         __asm volatile
1083         (
1084             " .syntax unified                                       \n"
1085             " .extern MPU_xQueuePeekImpl                            \n"
1086             "                                                       \n"
1087             " push {r0}                                             \n"
1088             " mrs r0, control                                       \n"
1089             " tst r0, #1                                            \n"
1090             " bne MPU_xQueuePeek_Unpriv                             \n"
1091             " MPU_xQueuePeek_Priv:                                  \n"
1092             "     pop {r0}                                          \n"
1093             "     b MPU_xQueuePeekImpl                              \n"
1094             " MPU_xQueuePeek_Unpriv:                                \n"
1095             "     pop {r0}                                          \n"
1096             "     svc %0                                            \n"
1097             "                                                       \n"
1098             : : "i" ( SYSTEM_CALL_xQueuePeek ) : "memory"
1099         );
1100     }
1101 /*-----------------------------------------------------------*/
1102
1103     BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
1104                                         TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1105
1106     BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
1107                                         TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1108     {
1109         __asm volatile
1110         (
1111             " .syntax unified                                       \n"
1112             " .extern MPU_xQueueSemaphoreTakeImpl                   \n"
1113             "                                                       \n"
1114             " push {r0}                                             \n"
1115             " mrs r0, control                                       \n"
1116             " tst r0, #1                                            \n"
1117             " bne MPU_xQueueSemaphoreTake_Unpriv                    \n"
1118             " MPU_xQueueSemaphoreTake_Priv:                         \n"
1119             "     pop {r0}                                          \n"
1120             "     b MPU_xQueueSemaphoreTakeImpl                     \n"
1121             " MPU_xQueueSemaphoreTake_Unpriv:                       \n"
1122             "     pop {r0}                                          \n"
1123             "     svc %0                                            \n"
1124             "                                                       \n"
1125             : : "i" ( SYSTEM_CALL_xQueueSemaphoreTake ) : "memory"
1126         );
1127     }
1128 /*-----------------------------------------------------------*/
1129
1130     #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
1131
1132         TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1133
1134         TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1135         {
1136             __asm volatile
1137             (
1138                 " .syntax unified                                       \n"
1139                 " .extern MPU_xQueueGetMutexHolderImpl                  \n"
1140                 "                                                       \n"
1141                 " push {r0}                                             \n"
1142                 " mrs r0, control                                       \n"
1143                 " tst r0, #1                                            \n"
1144                 " bne MPU_xQueueGetMutexHolder_Unpriv                   \n"
1145                 " MPU_xQueueGetMutexHolder_Priv:                        \n"
1146                 "     pop {r0}                                          \n"
1147                 "     b MPU_xQueueGetMutexHolderImpl                    \n"
1148                 " MPU_xQueueGetMutexHolder_Unpriv:                      \n"
1149                 "     pop {r0}                                          \n"
1150                 "     svc %0                                            \n"
1151                 "                                                       \n"
1152                 : : "i" ( SYSTEM_CALL_xQueueGetMutexHolder ) : "memory"
1153             );
1154         }
1155
1156     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
1157 /*-----------------------------------------------------------*/
1158
1159     #if ( configUSE_RECURSIVE_MUTEXES == 1 )
1160
1161         BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,
1162                                                  TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1163
1164         BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,
1165                                                  TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1166         {
1167             __asm volatile
1168             (
1169                 " .syntax unified                                       \n"
1170                 " .extern MPU_xQueueTakeMutexRecursiveImpl              \n"
1171                 "                                                       \n"
1172                 " push {r0}                                             \n"
1173                 " mrs r0, control                                       \n"
1174                 " tst r0, #1                                            \n"
1175                 " bne MPU_xQueueTakeMutexRecursive_Unpriv               \n"
1176                 " MPU_xQueueTakeMutexRecursive_Priv:                    \n"
1177                 "     pop {r0}                                          \n"
1178                 "     b MPU_xQueueTakeMutexRecursiveImpl                \n"
1179                 " MPU_xQueueTakeMutexRecursive_Unpriv:                  \n"
1180                 "     pop {r0}                                          \n"
1181                 "     svc %0                                            \n"
1182                 "                                                       \n"
1183                 : : "i" ( SYSTEM_CALL_xQueueTakeMutexRecursive ) : "memory"
1184             );
1185         }
1186
1187     #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
1188 /*-----------------------------------------------------------*/
1189
1190     #if ( configUSE_RECURSIVE_MUTEXES == 1 )
1191
1192         BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1193
1194         BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1195         {
1196             __asm volatile
1197             (
1198                 " .syntax unified                                       \n"
1199                 " .extern MPU_xQueueGiveMutexRecursiveImpl              \n"
1200                 "                                                       \n"
1201                 " push {r0}                                             \n"
1202                 " mrs r0, control                                       \n"
1203                 " tst r0, #1                                            \n"
1204                 " bne MPU_xQueueGiveMutexRecursive_Unpriv               \n"
1205                 " MPU_xQueueGiveMutexRecursive_Priv:                    \n"
1206                 "     pop {r0}                                          \n"
1207                 "     b MPU_xQueueGiveMutexRecursiveImpl                \n"
1208                 " MPU_xQueueGiveMutexRecursive_Unpriv:                  \n"
1209                 "     pop {r0}                                          \n"
1210                 "     svc %0                                            \n"
1211                 "                                                       \n"
1212                 : : "i" ( SYSTEM_CALL_xQueueGiveMutexRecursive ) : "memory"
1213             );
1214         }
1215
1216     #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
1217 /*-----------------------------------------------------------*/
1218
1219     #if ( configUSE_QUEUE_SETS == 1 )
1220
1221         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
1222                                                         const TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1223
1224         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
1225                                                         const TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1226         {
1227             __asm volatile
1228             (
1229                 " .syntax unified                                       \n"
1230                 " .extern MPU_xQueueSelectFromSetImpl                   \n"
1231                 "                                                       \n"
1232                 " push {r0}                                             \n"
1233                 " mrs r0, control                                       \n"
1234                 " tst r0, #1                                            \n"
1235                 " bne MPU_xQueueSelectFromSet_Unpriv                    \n"
1236                 " MPU_xQueueSelectFromSet_Priv:                         \n"
1237                 "     pop {r0}                                          \n"
1238                 "     b MPU_xQueueSelectFromSetImpl                     \n"
1239                 " MPU_xQueueSelectFromSet_Unpriv:                       \n"
1240                 "     pop {r0}                                          \n"
1241                 "     svc %0                                            \n"
1242                 "                                                       \n"
1243                 : : "i" ( SYSTEM_CALL_xQueueSelectFromSet ) : "memory"
1244             );
1245         }
1246
1247     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1248 /*-----------------------------------------------------------*/
1249
1250     #if ( configUSE_QUEUE_SETS == 1 )
1251
1252         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
1253                                        QueueSetHandle_t xQueueSet ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1254
1255         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
1256                                        QueueSetHandle_t xQueueSet ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1257         {
1258             __asm volatile
1259             (
1260                 " .syntax unified                                       \n"
1261                 " .extern MPU_xQueueAddToSetImpl                        \n"
1262                 "                                                       \n"
1263                 " push {r0}                                             \n"
1264                 " mrs r0, control                                       \n"
1265                 " tst r0, #1                                            \n"
1266                 " bne MPU_xQueueAddToSet_Unpriv                         \n"
1267                 " MPU_xQueueAddToSet_Priv:                              \n"
1268                 "     pop {r0}                                          \n"
1269                 "     b MPU_xQueueAddToSetImpl                          \n"
1270                 " MPU_xQueueAddToSet_Unpriv:                            \n"
1271                 "     pop {r0}                                          \n"
1272                 "     svc %0                                            \n"
1273                 "                                                       \n"
1274                 : : "i" ( SYSTEM_CALL_xQueueAddToSet ) : "memory"
1275             );
1276         }
1277
1278     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1279 /*-----------------------------------------------------------*/
1280
1281     #if ( configQUEUE_REGISTRY_SIZE > 0 )
1282
1283         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
1284                                       const char * pcName ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1285
1286         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
1287                                       const char * pcName ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1288         {
1289             __asm volatile
1290             (
1291                 " .syntax unified                                       \n"
1292                 " .extern MPU_vQueueAddToRegistryImpl                   \n"
1293                 "                                                       \n"
1294                 " push {r0}                                             \n"
1295                 " mrs r0, control                                       \n"
1296                 " tst r0, #1                                            \n"
1297                 " bne MPU_vQueueAddToRegistry_Unpriv                    \n"
1298                 " MPU_vQueueAddToRegistry_Priv:                         \n"
1299                 "     pop {r0}                                          \n"
1300                 "     b MPU_vQueueAddToRegistryImpl                     \n"
1301                 " MPU_vQueueAddToRegistry_Unpriv:                       \n"
1302                 "     pop {r0}                                          \n"
1303                 "     svc %0                                            \n"
1304                 "                                                       \n"
1305                 : : "i" ( SYSTEM_CALL_vQueueAddToRegistry ) : "memory"
1306             );
1307         }
1308
1309     #endif /* if ( configQUEUE_REGISTRY_SIZE > 0 ) */
1310 /*-----------------------------------------------------------*/
1311
1312     #if ( configQUEUE_REGISTRY_SIZE > 0 )
1313
1314         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1315
1316         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1317         {
1318             __asm volatile
1319             (
1320                 " .syntax unified                                       \n"
1321                 " .extern MPU_vQueueUnregisterQueueImpl                 \n"
1322                 "                                                       \n"
1323                 " push {r0}                                             \n"
1324                 " mrs r0, control                                       \n"
1325                 " tst r0, #1                                            \n"
1326                 " bne MPU_vQueueUnregisterQueue_Unpriv                  \n"
1327                 " MPU_vQueueUnregisterQueue_Priv:                       \n"
1328                 "     pop {r0}                                          \n"
1329                 "     b MPU_vQueueUnregisterQueueImpl                   \n"
1330                 " MPU_vQueueUnregisterQueue_Unpriv:                     \n"
1331                 "     pop {r0}                                          \n"
1332                 "     svc %0                                            \n"
1333                 "                                                       \n"
1334                 : : "i" ( SYSTEM_CALL_vQueueUnregisterQueue ) : "memory"
1335             );
1336         }
1337
1338     #endif /* if ( configQUEUE_REGISTRY_SIZE > 0 ) */
1339 /*-----------------------------------------------------------*/
1340
1341     #if ( configQUEUE_REGISTRY_SIZE > 0 )
1342
1343         const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1344
1345         const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1346         {
1347             __asm volatile
1348             (
1349                 " .syntax unified                                       \n"
1350                 " .extern MPU_pcQueueGetNameImpl                        \n"
1351                 "                                                       \n"
1352                 " push {r0}                                             \n"
1353                 " mrs r0, control                                       \n"
1354                 " tst r0, #1                                            \n"
1355                 " bne MPU_pcQueueGetName_Unpriv                         \n"
1356                 " MPU_pcQueueGetName_Priv:                              \n"
1357                 "     pop {r0}                                          \n"
1358                 "     b MPU_pcQueueGetNameImpl                          \n"
1359                 " MPU_pcQueueGetName_Unpriv:                            \n"
1360                 "     pop {r0}                                          \n"
1361                 "     svc %0                                            \n"
1362                 "                                                       \n"
1363                 : : "i" ( SYSTEM_CALL_pcQueueGetName ) : "memory"
1364             );
1365         }
1366
1367     #endif /* if ( configQUEUE_REGISTRY_SIZE > 0 ) */
1368 /*-----------------------------------------------------------*/
1369
1370     #if ( configUSE_TIMERS == 1 )
1371
1372         void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1373
1374         void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1375         {
1376             __asm volatile
1377             (
1378                 " .syntax unified                                       \n"
1379                 " .extern MPU_pvTimerGetTimerIDImpl                     \n"
1380                 "                                                       \n"
1381                 " push {r0}                                             \n"
1382                 " mrs r0, control                                       \n"
1383                 " tst r0, #1                                            \n"
1384                 " bne MPU_pvTimerGetTimerID_Unpriv                      \n"
1385                 " MPU_pvTimerGetTimerID_Priv:                           \n"
1386                 "     pop {r0}                                          \n"
1387                 "     b MPU_pvTimerGetTimerIDImpl                       \n"
1388                 " MPU_pvTimerGetTimerID_Unpriv:                         \n"
1389                 "     pop {r0}                                          \n"
1390                 "     svc %0                                            \n"
1391                 "                                                       \n"
1392                 : : "i" ( SYSTEM_CALL_pvTimerGetTimerID ) : "memory"
1393             );
1394         }
1395
1396     #endif /* if ( configUSE_TIMERS == 1 ) */
1397 /*-----------------------------------------------------------*/
1398
1399     #if ( configUSE_TIMERS == 1 )
1400
1401         void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
1402                                    void * pvNewID ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1403
1404         void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
1405                                    void * pvNewID ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1406         {
1407             __asm volatile
1408             (
1409                 " .syntax unified                                       \n"
1410                 " .extern MPU_vTimerSetTimerIDImpl                      \n"
1411                 "                                                       \n"
1412                 " push {r0}                                             \n"
1413                 " mrs r0, control                                       \n"
1414                 " tst r0, #1                                            \n"
1415                 " bne MPU_vTimerSetTimerID_Unpriv                       \n"
1416                 " MPU_vTimerSetTimerID_Priv:                            \n"
1417                 "     pop {r0}                                          \n"
1418                 "     b MPU_vTimerSetTimerIDImpl                        \n"
1419                 " MPU_vTimerSetTimerID_Unpriv:                          \n"
1420                 "     pop {r0}                                          \n"
1421                 "     svc %0                                            \n"
1422                 "                                                       \n"
1423                 : : "i" ( SYSTEM_CALL_vTimerSetTimerID ) : "memory"
1424             );
1425         }
1426
1427     #endif /* if ( configUSE_TIMERS == 1 ) */
1428 /*-----------------------------------------------------------*/
1429
1430     #if ( configUSE_TIMERS == 1 )
1431
1432         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1433
1434         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1435         {
1436             __asm volatile
1437             (
1438                 " .syntax unified                                       \n"
1439                 " .extern MPU_xTimerIsTimerActiveImpl                   \n"
1440                 "                                                       \n"
1441                 " push {r0}                                             \n"
1442                 " mrs r0, control                                       \n"
1443                 " tst r0, #1                                            \n"
1444                 " bne MPU_xTimerIsTimerActive_Unpriv                    \n"
1445                 " MPU_xTimerIsTimerActive_Priv:                         \n"
1446                 "     pop {r0}                                          \n"
1447                 "     b MPU_xTimerIsTimerActiveImpl                     \n"
1448                 " MPU_xTimerIsTimerActive_Unpriv:                       \n"
1449                 "     pop {r0}                                          \n"
1450                 "     svc %0                                            \n"
1451                 "                                                       \n"
1452                 : : "i" ( SYSTEM_CALL_xTimerIsTimerActive ) : "memory"
1453             );
1454         }
1455
1456     #endif /* if ( configUSE_TIMERS == 1 ) */
1457 /*-----------------------------------------------------------*/
1458
1459     #if ( configUSE_TIMERS == 1 )
1460
1461         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1462
1463         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1464         {
1465             __asm volatile
1466             (
1467                 " .syntax unified                                       \n"
1468                 " .extern MPU_xTimerGetTimerDaemonTaskHandleImpl        \n"
1469                 "                                                       \n"
1470                 " push {r0}                                             \n"
1471                 " mrs r0, control                                       \n"
1472                 " tst r0, #1                                            \n"
1473                 " bne MPU_xTimerGetTimerDaemonTaskHandle_Unpriv         \n"
1474                 " MPU_xTimerGetTimerDaemonTaskHandle_Priv:              \n"
1475                 "     pop {r0}                                          \n"
1476                 "     b MPU_xTimerGetTimerDaemonTaskHandleImpl          \n"
1477                 " MPU_xTimerGetTimerDaemonTaskHandle_Unpriv:            \n"
1478                 "     pop {r0}                                          \n"
1479                 "     svc %0                                            \n"
1480                 "                                                       \n"
1481                 : : "i" ( SYSTEM_CALL_xTimerGetTimerDaemonTaskHandle ) : "memory"
1482             );
1483         }
1484
1485     #endif /* if ( configUSE_TIMERS == 1 ) */
1486 /*-----------------------------------------------------------*/
1487
1488     #if ( configUSE_TIMERS == 1 )
1489
1490         BaseType_t MPU_xTimerGenericCommandFromTaskEntry( const xTimerGenericCommandFromTaskParams_t * pxParams ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1491
1492         BaseType_t MPU_xTimerGenericCommandFromTaskEntry( const xTimerGenericCommandFromTaskParams_t * pxParams ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1493         {
1494             __asm volatile
1495             (
1496                 " .syntax unified                                               \n"
1497                 " .extern MPU_xTimerGenericCommandFromTaskImpl                  \n"
1498                 "                                                               \n"
1499                 " push {r0}                                                     \n"
1500                 " mrs r0, control                                               \n"
1501                 " tst r0, #1                                                    \n"
1502                 " bne MPU_xTimerGenericCommandFromTask_Unpriv                   \n"
1503                 " MPU_xTimerGenericCommandFromTask_Priv:                        \n"
1504                 "     pop {r0}                                                  \n"
1505                 "     b MPU_xTimerGenericCommandFromTaskImpl                    \n"
1506                 " MPU_xTimerGenericCommandFromTask_Unpriv:                      \n"
1507                 "     pop {r0}                                                  \n"
1508                 "     svc %0                                                    \n"
1509                 "                                                               \n"
1510                 : : "i" ( SYSTEM_CALL_xTimerGenericCommandFromTask ) : "memory"
1511             );
1512         }
1513
1514     #endif /* if ( configUSE_TIMERS == 1 ) */
1515 /*-----------------------------------------------------------*/
1516
1517     #if ( configUSE_TIMERS == 1 )
1518
1519         const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1520
1521         const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1522         {
1523             __asm volatile
1524             (
1525                 " .syntax unified                                       \n"
1526                 " .extern MPU_pcTimerGetNameImpl                        \n"
1527                 "                                                       \n"
1528                 " push {r0}                                             \n"
1529                 " mrs r0, control                                       \n"
1530                 " tst r0, #1                                            \n"
1531                 " bne MPU_pcTimerGetName_Unpriv                         \n"
1532                 " MPU_pcTimerGetName_Priv:                              \n"
1533                 "     pop {r0}                                          \n"
1534                 "     b MPU_pcTimerGetNameImpl                          \n"
1535                 " MPU_pcTimerGetName_Unpriv:                            \n"
1536                 "     pop {r0}                                          \n"
1537                 "     svc %0                                            \n"
1538                 "                                                       \n"
1539                 : : "i" ( SYSTEM_CALL_pcTimerGetName ) : "memory"
1540             );
1541         }
1542
1543     #endif /* if ( configUSE_TIMERS == 1 ) */
1544 /*-----------------------------------------------------------*/
1545
1546     #if ( configUSE_TIMERS == 1 )
1547
1548         void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
1549                                       const BaseType_t uxAutoReload ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1550
1551         void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
1552                                       const BaseType_t uxAutoReload ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1553         {
1554             __asm volatile
1555             (
1556                 " .syntax unified                                       \n"
1557                 " .extern MPU_vTimerSetReloadModeImpl                   \n"
1558                 "                                                       \n"
1559                 " push {r0}                                             \n"
1560                 " mrs r0, control                                       \n"
1561                 " tst r0, #1                                            \n"
1562                 " bne MPU_vTimerSetReloadMode_Unpriv                    \n"
1563                 " MPU_vTimerSetReloadMode_Priv:                         \n"
1564                 "     pop {r0}                                          \n"
1565                 "     b MPU_vTimerSetReloadModeImpl                     \n"
1566                 " MPU_vTimerSetReloadMode_Unpriv:                       \n"
1567                 "     pop {r0}                                          \n"
1568                 "     svc %0                                            \n"
1569                 "                                                       \n"
1570                 : : "i" ( SYSTEM_CALL_vTimerSetReloadMode ) : "memory"
1571             );
1572         }
1573
1574     #endif /* if ( configUSE_TIMERS == 1 ) */
1575 /*-----------------------------------------------------------*/
1576
1577     #if ( configUSE_TIMERS == 1 )
1578
1579         BaseType_t MPU_xTimerGetReloadMode( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1580
1581         BaseType_t MPU_xTimerGetReloadMode( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1582         {
1583             __asm volatile
1584             (
1585                 " .syntax unified                                       \n"
1586                 " .extern MPU_xTimerGetReloadModeImpl                   \n"
1587                 "                                                       \n"
1588                 " push {r0}                                             \n"
1589                 " mrs r0, control                                       \n"
1590                 " tst r0, #1                                            \n"
1591                 " bne MPU_xTimerGetReloadMode_Unpriv                    \n"
1592                 " MPU_xTimerGetReloadMode_Priv:                         \n"
1593                 "     pop {r0}                                          \n"
1594                 "     b MPU_xTimerGetReloadModeImpl                     \n"
1595                 " MPU_xTimerGetReloadMode_Unpriv:                       \n"
1596                 "     pop {r0}                                          \n"
1597                 "     svc %0                                            \n"
1598                 "                                                       \n"
1599                 : : "i" ( SYSTEM_CALL_xTimerGetReloadMode ) : "memory"
1600             );
1601         }
1602
1603     #endif /* if ( configUSE_TIMERS == 1 ) */
1604 /*-----------------------------------------------------------*/
1605
1606     #if ( configUSE_TIMERS == 1 )
1607
1608         UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1609
1610         UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1611         {
1612             __asm volatile
1613             (
1614                 " .syntax unified                                       \n"
1615                 " .extern MPU_uxTimerGetReloadModeImpl                  \n"
1616                 "                                                       \n"
1617                 " push {r0}                                             \n"
1618                 " mrs r0, control                                       \n"
1619                 " tst r0, #1                                            \n"
1620                 " bne MPU_uxTimerGetReloadMode_Unpriv                   \n"
1621                 " MPU_uxTimerGetReloadMode_Priv:                        \n"
1622                 "     pop {r0}                                          \n"
1623                 "     b MPU_uxTimerGetReloadModeImpl                    \n"
1624                 " MPU_uxTimerGetReloadMode_Unpriv:                      \n"
1625                 "     pop {r0}                                          \n"
1626                 "     svc %0                                            \n"
1627                 "                                                       \n"
1628                 : : "i" ( SYSTEM_CALL_uxTimerGetReloadMode ) : "memory"
1629             );
1630         }
1631
1632     #endif /* if ( configUSE_TIMERS == 1 ) */
1633 /*-----------------------------------------------------------*/
1634
1635     #if ( configUSE_TIMERS == 1 )
1636
1637         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1638
1639         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1640         {
1641             __asm volatile
1642             (
1643                 " .syntax unified                                       \n"
1644                 " .extern MPU_xTimerGetPeriodImpl                       \n"
1645                 "                                                       \n"
1646                 " push {r0}                                             \n"
1647                 " mrs r0, control                                       \n"
1648                 " tst r0, #1                                            \n"
1649                 " bne MPU_xTimerGetPeriod_Unpriv                        \n"
1650                 " MPU_xTimerGetPeriod_Priv:                             \n"
1651                 "     pop {r0}                                          \n"
1652                 "     b MPU_xTimerGetPeriodImpl                         \n"
1653                 " MPU_xTimerGetPeriod_Unpriv:                           \n"
1654                 "     pop {r0}                                          \n"
1655                 "     svc %0                                            \n"
1656                 "                                                       \n"
1657                 : : "i" ( SYSTEM_CALL_xTimerGetPeriod ) : "memory"
1658             );
1659         }
1660
1661     #endif /* if ( configUSE_TIMERS == 1 ) */
1662 /*-----------------------------------------------------------*/
1663
1664     #if ( configUSE_TIMERS == 1 )
1665
1666         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1667
1668         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1669         {
1670             __asm volatile
1671             (
1672                 " .syntax unified                                       \n"
1673                 " .extern MPU_xTimerGetExpiryTimeImpl                   \n"
1674                 "                                                       \n"
1675                 " push {r0}                                             \n"
1676                 " mrs r0, control                                       \n"
1677                 " tst r0, #1                                            \n"
1678                 " bne MPU_xTimerGetExpiryTime_Unpriv                    \n"
1679                 " MPU_xTimerGetExpiryTime_Priv:                         \n"
1680                 "     pop {r0}                                          \n"
1681                 "     b MPU_xTimerGetExpiryTimeImpl                     \n"
1682                 " MPU_xTimerGetExpiryTime_Unpriv:                       \n"
1683                 "     pop {r0}                                          \n"
1684                 "     svc %0                                            \n"
1685                 "                                                       \n"
1686                 : : "i" ( SYSTEM_CALL_xTimerGetExpiryTime ) : "memory"
1687             );
1688         }
1689
1690     #endif /* if ( configUSE_TIMERS == 1 ) */
1691 /*-----------------------------------------------------------*/
1692
1693     EventBits_t MPU_xEventGroupWaitBitsEntry( const xEventGroupWaitBitsParams_t * pxParams ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1694
1695     EventBits_t MPU_xEventGroupWaitBitsEntry( const xEventGroupWaitBitsParams_t * pxParams ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1696     {
1697         __asm volatile
1698         (
1699             " .syntax unified                                       \n"
1700             " .extern MPU_xEventGroupWaitBitsImpl                   \n"
1701             "                                                       \n"
1702             " push {r0}                                             \n"
1703             " mrs r0, control                                       \n"
1704             " tst r0, #1                                            \n"
1705             " bne MPU_xEventGroupWaitBits_Unpriv                    \n"
1706             " MPU_xEventGroupWaitBits_Priv:                         \n"
1707             "     pop {r0}                                          \n"
1708             "     b MPU_xEventGroupWaitBitsImpl                     \n"
1709             " MPU_xEventGroupWaitBits_Unpriv:                       \n"
1710             "     pop {r0}                                          \n"
1711             "     svc %0                                            \n"
1712             "                                                       \n"
1713             : : "i" ( SYSTEM_CALL_xEventGroupWaitBits ) : "memory"
1714         );
1715     }
1716 /*-----------------------------------------------------------*/
1717
1718     EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
1719                                           const EventBits_t uxBitsToClear ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1720
1721     EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
1722                                           const EventBits_t uxBitsToClear ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1723     {
1724         __asm volatile
1725         (
1726             " .syntax unified                                       \n"
1727             " .extern MPU_xEventGroupClearBitsImpl                  \n"
1728             "                                                       \n"
1729             " push {r0}                                             \n"
1730             " mrs r0, control                                       \n"
1731             " tst r0, #1                                            \n"
1732             " bne MPU_xEventGroupClearBits_Unpriv                   \n"
1733             " MPU_xEventGroupClearBits_Priv:                        \n"
1734             "     pop {r0}                                          \n"
1735             "     b MPU_xEventGroupClearBitsImpl                    \n"
1736             " MPU_xEventGroupClearBits_Unpriv:                      \n"
1737             "     pop {r0}                                          \n"
1738             "     svc %0                                            \n"
1739             "                                                       \n"
1740             : : "i" ( SYSTEM_CALL_xEventGroupClearBits ) : "memory"
1741         );
1742     }
1743 /*-----------------------------------------------------------*/
1744
1745     EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
1746                                         const EventBits_t uxBitsToSet ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1747
1748     EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
1749                                         const EventBits_t uxBitsToSet ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1750     {
1751         __asm volatile
1752         (
1753             " .syntax unified                                       \n"
1754             " .extern MPU_xEventGroupSetBitsImpl                    \n"
1755             "                                                       \n"
1756             " push {r0}                                             \n"
1757             " mrs r0, control                                       \n"
1758             " tst r0, #1                                            \n"
1759             " bne MPU_xEventGroupSetBits_Unpriv                     \n"
1760             " MPU_xEventGroupSetBits_Priv:                          \n"
1761             "     pop {r0}                                          \n"
1762             "     b MPU_xEventGroupSetBitsImpl                      \n"
1763             " MPU_xEventGroupSetBits_Unpriv:                        \n"
1764             "     pop {r0}                                          \n"
1765             "     svc %0                                            \n"
1766             "                                                       \n"
1767             : : "i" ( SYSTEM_CALL_xEventGroupSetBits ) : "memory"
1768         );
1769     }
1770 /*-----------------------------------------------------------*/
1771
1772     EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
1773                                      const EventBits_t uxBitsToSet,
1774                                      const EventBits_t uxBitsToWaitFor,
1775                                      TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1776
1777     EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
1778                                      const EventBits_t uxBitsToSet,
1779                                      const EventBits_t uxBitsToWaitFor,
1780                                      TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1781     {
1782         __asm volatile
1783         (
1784             " .syntax unified                                       \n"
1785             " .extern MPU_xEventGroupSyncImpl                       \n"
1786             "                                                       \n"
1787             " push {r0}                                             \n"
1788             " mrs r0, control                                       \n"
1789             " tst r0, #1                                            \n"
1790             " bne MPU_xEventGroupSync_Unpriv                        \n"
1791             " MPU_xEventGroupSync_Priv:                             \n"
1792             "     pop {r0}                                          \n"
1793             "     b MPU_xEventGroupSyncImpl                         \n"
1794             " MPU_xEventGroupSync_Unpriv:                           \n"
1795             "     pop {r0}                                          \n"
1796             "     svc %0                                            \n"
1797             "                                                       \n"
1798             : : "i" ( SYSTEM_CALL_xEventGroupSync ) : "memory"
1799         );
1800     }
1801 /*-----------------------------------------------------------*/
1802
1803     #if ( configUSE_TRACE_FACILITY == 1 )
1804
1805         UBaseType_t MPU_uxEventGroupGetNumber( void * xEventGroup ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1806
1807         UBaseType_t MPU_uxEventGroupGetNumber( void * xEventGroup ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1808         {
1809             __asm volatile
1810             (
1811                 " .syntax unified                                       \n"
1812                 " .extern MPU_uxEventGroupGetNumberImpl                 \n"
1813                 "                                                       \n"
1814                 " push {r0}                                             \n"
1815                 " mrs r0, control                                       \n"
1816                 " tst r0, #1                                            \n"
1817                 " bne MPU_uxEventGroupGetNumber_Unpriv                  \n"
1818                 " MPU_uxEventGroupGetNumber_Priv:                       \n"
1819                 "     pop {r0}                                          \n"
1820                 "     b MPU_uxEventGroupGetNumberImpl                   \n"
1821                 " MPU_uxEventGroupGetNumber_Unpriv:                     \n"
1822                 "     pop {r0}                                          \n"
1823                 "     svc %0                                            \n"
1824                 "                                                       \n"
1825                 : : "i" ( SYSTEM_CALL_uxEventGroupGetNumber ) : "memory"
1826             );
1827         }
1828
1829     #endif /*( configUSE_TRACE_FACILITY == 1 )*/
1830 /*-----------------------------------------------------------*/
1831
1832     #if ( configUSE_TRACE_FACILITY == 1 )
1833
1834         void MPU_vEventGroupSetNumber( void * xEventGroup,
1835                                        UBaseType_t uxEventGroupNumber ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1836
1837         void MPU_vEventGroupSetNumber( void * xEventGroup,
1838                                        UBaseType_t uxEventGroupNumber ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1839         {
1840             __asm volatile
1841             (
1842                 " .syntax unified                                       \n"
1843                 " .extern MPU_vEventGroupSetNumberImpl                  \n"
1844                 "                                                       \n"
1845                 " push {r0}                                             \n"
1846                 " mrs r0, control                                       \n"
1847                 " tst r0, #1                                            \n"
1848                 " bne MPU_vEventGroupSetNumber_Unpriv                   \n"
1849                 " MPU_vEventGroupSetNumber_Priv:                        \n"
1850                 "     pop {r0}                                          \n"
1851                 "     b MPU_vEventGroupSetNumberImpl                    \n"
1852                 " MPU_vEventGroupSetNumber_Unpriv:                      \n"
1853                 "     pop {r0}                                          \n"
1854                 "     svc %0                                            \n"
1855                 "                                                       \n"
1856                 : : "i" ( SYSTEM_CALL_vEventGroupSetNumber ) : "memory"
1857             );
1858         }
1859
1860     #endif /*( configUSE_TRACE_FACILITY == 1 )*/
1861 /*-----------------------------------------------------------*/
1862
1863     size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
1864                                   const void * pvTxData,
1865                                   size_t xDataLengthBytes,
1866                                   TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1867
1868     size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
1869                                   const void * pvTxData,
1870                                   size_t xDataLengthBytes,
1871                                   TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1872     {
1873         __asm volatile
1874         (
1875             " .syntax unified                                       \n"
1876             " .extern MPU_xStreamBufferSendImpl                     \n"
1877             "                                                       \n"
1878             " push {r0}                                             \n"
1879             " mrs r0, control                                       \n"
1880             " tst r0, #1                                            \n"
1881             " bne MPU_xStreamBufferSend_Unpriv                      \n"
1882             " MPU_xStreamBufferSend_Priv:                           \n"
1883             "     pop {r0}                                          \n"
1884             "     b MPU_xStreamBufferSendImpl                       \n"
1885             " MPU_xStreamBufferSend_Unpriv:                         \n"
1886             "     pop {r0}                                          \n"
1887             "     svc %0                                            \n"
1888             "                                                       \n"
1889             : : "i" ( SYSTEM_CALL_xStreamBufferSend ) : "memory"
1890         );
1891     }
1892 /*-----------------------------------------------------------*/
1893
1894     size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
1895                                      void * pvRxData,
1896                                      size_t xBufferLengthBytes,
1897                                      TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1898
1899     size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
1900                                      void * pvRxData,
1901                                      size_t xBufferLengthBytes,
1902                                      TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1903     {
1904         __asm volatile
1905         (
1906             " .syntax unified                                       \n"
1907             " .extern MPU_xStreamBufferReceiveImpl                  \n"
1908             "                                                       \n"
1909             " push {r0}                                             \n"
1910             " mrs r0, control                                       \n"
1911             " tst r0, #1                                            \n"
1912             " bne MPU_xStreamBufferReceive_Unpriv                   \n"
1913             " MPU_xStreamBufferReceive_Priv:                        \n"
1914             "     pop {r0}                                          \n"
1915             "     b MPU_xStreamBufferReceiveImpl                    \n"
1916             " MPU_xStreamBufferReceive_Unpriv:                      \n"
1917             "     pop {r0}                                          \n"
1918             "     svc %0                                            \n"
1919             "                                                       \n"
1920             : : "i" ( SYSTEM_CALL_xStreamBufferReceive ) : "memory"
1921         );
1922     }
1923 /*-----------------------------------------------------------*/
1924
1925     BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1926
1927     BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1928     {
1929         __asm volatile
1930         (
1931             " .syntax unified                                       \n"
1932             " .extern MPU_xStreamBufferIsFullImpl                   \n"
1933             "                                                       \n"
1934             " push {r0}                                             \n"
1935             " mrs r0, control                                       \n"
1936             " tst r0, #1                                            \n"
1937             " bne MPU_xStreamBufferIsFull_Unpriv                    \n"
1938             " MPU_xStreamBufferIsFull_Priv:                         \n"
1939             "     pop {r0}                                          \n"
1940             "     b MPU_xStreamBufferIsFullImpl                     \n"
1941             " MPU_xStreamBufferIsFull_Unpriv:                       \n"
1942             "     pop {r0}                                          \n"
1943             "     svc %0                                            \n"
1944             "                                                       \n"
1945             : : "i" ( SYSTEM_CALL_xStreamBufferIsFull ) : "memory"
1946         );
1947     }
1948 /*-----------------------------------------------------------*/
1949
1950     BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1951
1952     BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1953     {
1954         __asm volatile
1955         (
1956             " .syntax unified                                       \n"
1957             " .extern MPU_xStreamBufferIsEmptyImpl                  \n"
1958             "                                                       \n"
1959             " push {r0}                                             \n"
1960             " mrs r0, control                                       \n"
1961             " tst r0, #1                                            \n"
1962             " bne MPU_xStreamBufferIsEmpty_Unpriv                   \n"
1963             " MPU_xStreamBufferIsEmpty_Priv:                        \n"
1964             "     pop {r0}                                          \n"
1965             "     b MPU_xStreamBufferIsEmptyImpl                    \n"
1966             " MPU_xStreamBufferIsEmpty_Unpriv:                      \n"
1967             "     pop {r0}                                          \n"
1968             "     svc %0                                            \n"
1969             "                                                       \n"
1970             : : "i" ( SYSTEM_CALL_xStreamBufferIsEmpty ) : "memory"
1971         );
1972     }
1973 /*-----------------------------------------------------------*/
1974
1975     size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
1976
1977     size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
1978     {
1979         __asm volatile
1980         (
1981             " .syntax unified                                       \n"
1982             " .extern MPU_xStreamBufferSpacesAvailableImpl          \n"
1983             "                                                       \n"
1984             " push {r0}                                             \n"
1985             " mrs r0, control                                       \n"
1986             " tst r0, #1                                            \n"
1987             " bne MPU_xStreamBufferSpacesAvailable_Unpriv           \n"
1988             " MPU_xStreamBufferSpacesAvailable_Priv:                \n"
1989             "     pop {r0}                                          \n"
1990             "     b MPU_xStreamBufferSpacesAvailableImpl            \n"
1991             " MPU_xStreamBufferSpacesAvailable_Unpriv:              \n"
1992             "     pop {r0}                                          \n"
1993             "     svc %0                                            \n"
1994             "                                                       \n"
1995             : : "i" ( SYSTEM_CALL_xStreamBufferSpacesAvailable ) : "memory"
1996         );
1997     }
1998 /*-----------------------------------------------------------*/
1999
2000     size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
2001
2002     size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
2003     {
2004         __asm volatile
2005         (
2006             " .syntax unified                                       \n"
2007             " .extern MPU_xStreamBufferBytesAvailableImpl           \n"
2008             "                                                       \n"
2009             " push {r0}                                             \n"
2010             " mrs r0, control                                       \n"
2011             " tst r0, #1                                            \n"
2012             " bne MPU_xStreamBufferBytesAvailable_Unpriv            \n"
2013             " MPU_xStreamBufferBytesAvailable_Priv:                 \n"
2014             "     pop {r0}                                          \n"
2015             "     b MPU_xStreamBufferBytesAvailableImpl             \n"
2016             " MPU_xStreamBufferBytesAvailable_Unpriv:               \n"
2017             "     pop {r0}                                          \n"
2018             "     svc %0                                            \n"
2019             "                                                       \n"
2020             : : "i" ( SYSTEM_CALL_xStreamBufferBytesAvailable ) : "memory"
2021         );
2022     }
2023 /*-----------------------------------------------------------*/
2024
2025     BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
2026                                                  size_t xTriggerLevel ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
2027
2028     BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
2029                                                  size_t xTriggerLevel ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
2030     {
2031         __asm volatile
2032         (
2033             " .syntax unified                                       \n"
2034             " .extern MPU_xStreamBufferSetTriggerLevelImpl          \n"
2035             "                                                       \n"
2036             " push {r0}                                             \n"
2037             " mrs r0, control                                       \n"
2038             " tst r0, #1                                            \n"
2039             " bne MPU_xStreamBufferSetTriggerLevel_Unpriv           \n"
2040             " MPU_xStreamBufferSetTriggerLevel_Priv:                \n"
2041             "     pop {r0}                                          \n"
2042             "     b MPU_xStreamBufferSetTriggerLevelImpl            \n"
2043             " MPU_xStreamBufferSetTriggerLevel_Unpriv:              \n"
2044             "     pop {r0}                                          \n"
2045             "     svc %0                                            \n"
2046             "                                                       \n"
2047             : : "i" ( SYSTEM_CALL_xStreamBufferSetTriggerLevel ) : "memory"
2048         );
2049     }
2050 /*-----------------------------------------------------------*/
2051
2052     size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL;
2053
2054     size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */
2055     {
2056         __asm volatile
2057         (
2058             " .syntax unified                                       \n"
2059             " .extern MPU_xStreamBufferNextMessageLengthBytesImpl   \n"
2060             "                                                       \n"
2061             " push {r0}                                             \n"
2062             " mrs r0, control                                       \n"
2063             " tst r0, #1                                            \n"
2064             " bne MPU_xStreamBufferNextMessageLengthBytes_Unpriv    \n"
2065             " MPU_xStreamBufferNextMessageLengthBytes_Priv:         \n"
2066             "     pop {r0}                                          \n"
2067             "     b MPU_xStreamBufferNextMessageLengthBytesImpl     \n"
2068             " MPU_xStreamBufferNextMessageLengthBytes_Unpriv:       \n"
2069             "     pop {r0}                                          \n"
2070             "     svc %0                                            \n"
2071             "                                                       \n"
2072             : : "i" ( SYSTEM_CALL_xStreamBufferNextMessageLengthBytes ) : "memory"
2073         );
2074     }
2075 /*-----------------------------------------------------------*/
2076
2077 #endif /* configUSE_MPU_WRAPPERS_V1 == 0 */