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

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