begriffs open source - freertos/blob - portable/Common/mpu_wrappers.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 /*
  30  * Implementation of the wrapper functions used to raise the processor privilege
  31  * before calling a standard FreeRTOS API function.
  32  */
  33
  34 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
  35  * all the API functions to use the MPU wrappers.  That should only be done when
  36  * task.h is included from an application file. */
  37 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  38
  39 /* Scheduler includes. */
  40 #include "FreeRTOS.h"
  41 #include "task.h"
  42 #include "queue.h"
  43 #include "timers.h"
  44 #include "event_groups.h"
  45 #include "stream_buffer.h"
  46 #include "mpu_prototypes.h"
  47
  48 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  49 /*-----------------------------------------------------------*/
  50
  51 #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) )
  52
  53     #if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
  54         #error Access control list is not available with this MPU wrapper. Please set configENABLE_ACCESS_CONTROL_LIST to 0.
  55     #endif
  56
  57     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
  58         BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode,
  59                                     const char * const pcName,
  60                                     uint16_t usStackDepth,
  61                                     void * pvParameters,
  62                                     UBaseType_t uxPriority,
  63                                     TaskHandle_t * pxCreatedTask ) /* FREERTOS_SYSTEM_CALL */
  64         {
  65             BaseType_t xReturn;
  66
  67             if( portIS_PRIVILEGED() == pdFALSE )
  68             {
  69                 portRAISE_PRIVILEGE();
  70                 portMEMORY_BARRIER();
  71
  72                 uxPriority = uxPriority & ~( portPRIVILEGE_BIT );
  73                 portMEMORY_BARRIER();
  74
  75                 xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );
  76                 portMEMORY_BARRIER();
  77
  78                 portRESET_PRIVILEGE();
  79                 portMEMORY_BARRIER();
  80             }
  81             else
  82             {
  83                 xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );
  84             }
  85
  86             return xReturn;
  87         }
  88     #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
  89 /*-----------------------------------------------------------*/
  90
  91     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
  92         TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,
  93                                             const char * const pcName,
  94                                             const uint32_t ulStackDepth,
  95                                             void * const pvParameters,
  96                                             UBaseType_t uxPriority,
  97                                             StackType_t * const puxStackBuffer,
  98                                             StaticTask_t * const pxTaskBuffer ) /* FREERTOS_SYSTEM_CALL */
  99         {
 100             TaskHandle_t xReturn;
 101
 102             if( portIS_PRIVILEGED() == pdFALSE )
 103             {
 104                 portRAISE_PRIVILEGE();
 105                 portMEMORY_BARRIER();
 106
 107                 uxPriority = uxPriority & ~( portPRIVILEGE_BIT );
 108                 portMEMORY_BARRIER();
 109
 110                 xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
 111                 portMEMORY_BARRIER();
 112
 113                 portRESET_PRIVILEGE();
 114                 portMEMORY_BARRIER();
 115             }
 116             else
 117             {
 118                 xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
 119             }
 120
 121             return xReturn;
 122         }
 123     #endif /* configSUPPORT_STATIC_ALLOCATION */
 124 /*-----------------------------------------------------------*/
 125
 126     #if ( INCLUDE_vTaskDelete == 1 )
 127         void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete ) /* FREERTOS_SYSTEM_CALL */
 128         {
 129             if( portIS_PRIVILEGED() == pdFALSE )
 130             {
 131                 portRAISE_PRIVILEGE();
 132                 portMEMORY_BARRIER();
 133
 134                 vTaskDelete( pxTaskToDelete );
 135                 portMEMORY_BARRIER();
 136
 137                 portRESET_PRIVILEGE();
 138                 portMEMORY_BARRIER();
 139             }
 140             else
 141             {
 142                 vTaskDelete( pxTaskToDelete );
 143             }
 144         }
 145     #endif /* if ( INCLUDE_vTaskDelete == 1 ) */
 146 /*-----------------------------------------------------------*/
 147
 148     #if ( INCLUDE_xTaskDelayUntil == 1 )
 149         BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
 150                                         TickType_t xTimeIncrement ) /* FREERTOS_SYSTEM_CALL */
 151         {
 152             BaseType_t xReturn;
 153
 154             if( portIS_PRIVILEGED() == pdFALSE )
 155             {
 156                 portRAISE_PRIVILEGE();
 157                 portMEMORY_BARRIER();
 158
 159                 xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
 160                 portMEMORY_BARRIER();
 161
 162                 portRESET_PRIVILEGE();
 163                 portMEMORY_BARRIER();
 164             }
 165             else
 166             {
 167                 xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
 168             }
 169
 170             return xReturn;
 171         }
 172     #endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */
 173 /*-----------------------------------------------------------*/
 174
 175     #if ( INCLUDE_xTaskAbortDelay == 1 )
 176         BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
 177         {
 178             BaseType_t xReturn;
 179
 180             if( portIS_PRIVILEGED() == pdFALSE )
 181             {
 182                 portRAISE_PRIVILEGE();
 183                 portMEMORY_BARRIER();
 184
 185                 xReturn = xTaskAbortDelay( xTask );
 186                 portMEMORY_BARRIER();
 187
 188                 portRESET_PRIVILEGE();
 189                 portMEMORY_BARRIER();
 190             }
 191             else
 192             {
 193                 xReturn = xTaskAbortDelay( xTask );
 194             }
 195
 196             return xReturn;
 197         }
 198     #endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */
 199 /*-----------------------------------------------------------*/
 200
 201     #if ( INCLUDE_vTaskDelay == 1 )
 202         void MPU_vTaskDelay( TickType_t xTicksToDelay ) /* FREERTOS_SYSTEM_CALL */
 203         {
 204             if( portIS_PRIVILEGED() == pdFALSE )
 205             {
 206                 portRAISE_PRIVILEGE();
 207                 portMEMORY_BARRIER();
 208
 209                 vTaskDelay( xTicksToDelay );
 210                 portMEMORY_BARRIER();
 211
 212                 portRESET_PRIVILEGE();
 213                 portMEMORY_BARRIER();
 214             }
 215             else
 216             {
 217                 vTaskDelay( xTicksToDelay );
 218             }
 219         }
 220     #endif /* if ( INCLUDE_vTaskDelay == 1 ) */
 221 /*-----------------------------------------------------------*/
 222
 223     #if ( INCLUDE_uxTaskPriorityGet == 1 )
 224         UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */
 225         {
 226             UBaseType_t uxReturn;
 227
 228             if( portIS_PRIVILEGED() == pdFALSE )
 229             {
 230                 portRAISE_PRIVILEGE();
 231                 portMEMORY_BARRIER();
 232
 233                 uxReturn = uxTaskPriorityGet( pxTask );
 234                 portMEMORY_BARRIER();
 235
 236                 portRESET_PRIVILEGE();
 237                 portMEMORY_BARRIER();
 238             }
 239             else
 240             {
 241                 uxReturn = uxTaskPriorityGet( pxTask );
 242             }
 243
 244             return uxReturn;
 245         }
 246     #endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */
 247 /*-----------------------------------------------------------*/
 248
 249     #if ( INCLUDE_vTaskPrioritySet == 1 )
 250         void MPU_vTaskPrioritySet( TaskHandle_t pxTask,
 251                                    UBaseType_t uxNewPriority ) /* FREERTOS_SYSTEM_CALL */
 252         {
 253             if( portIS_PRIVILEGED() == pdFALSE )
 254             {
 255                 portRAISE_PRIVILEGE();
 256                 portMEMORY_BARRIER();
 257
 258                 vTaskPrioritySet( pxTask, uxNewPriority );
 259                 portMEMORY_BARRIER();
 260
 261                 portRESET_PRIVILEGE();
 262                 portMEMORY_BARRIER();
 263             }
 264             else
 265             {
 266                 vTaskPrioritySet( pxTask, uxNewPriority );
 267             }
 268         }
 269     #endif /* if ( INCLUDE_vTaskPrioritySet == 1 ) */
 270 /*-----------------------------------------------------------*/
 271
 272     #if ( INCLUDE_eTaskGetState == 1 )
 273         eTaskState MPU_eTaskGetState( TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */
 274         {
 275             eTaskState eReturn;
 276
 277             if( portIS_PRIVILEGED() == pdFALSE )
 278             {
 279                 portRAISE_PRIVILEGE();
 280                 portMEMORY_BARRIER();
 281
 282                 eReturn = eTaskGetState( pxTask );
 283                 portMEMORY_BARRIER();
 284
 285                 portRESET_PRIVILEGE();
 286                 portMEMORY_BARRIER();
 287             }
 288             else
 289             {
 290                 eReturn = eTaskGetState( pxTask );
 291             }
 292
 293             return eReturn;
 294         }
 295     #endif /* if ( INCLUDE_eTaskGetState == 1 ) */
 296 /*-----------------------------------------------------------*/
 297
 298     #if ( configUSE_TRACE_FACILITY == 1 )
 299         void MPU_vTaskGetInfo( TaskHandle_t xTask,
 300                                TaskStatus_t * pxTaskStatus,
 301                                BaseType_t xGetFreeStackSpace,
 302                                eTaskState eState ) /* FREERTOS_SYSTEM_CALL */
 303         {
 304             if( portIS_PRIVILEGED() == pdFALSE )
 305             {
 306                 portRAISE_PRIVILEGE();
 307                 portMEMORY_BARRIER();
 308
 309                 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
 310                 portMEMORY_BARRIER();
 311
 312                 portRESET_PRIVILEGE();
 313                 portMEMORY_BARRIER();
 314             }
 315             else
 316             {
 317                 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
 318             }
 319         }
 320     #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
 321 /*-----------------------------------------------------------*/
 322
 323     #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
 324         TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
 325         {
 326             TaskHandle_t xReturn;
 327
 328             if( portIS_PRIVILEGED() == pdFALSE )
 329             {
 330                 portRAISE_PRIVILEGE();
 331                 portMEMORY_BARRIER();
 332                 xReturn = xTaskGetIdleTaskHandle();
 333                 portMEMORY_BARRIER();
 334
 335                 portRESET_PRIVILEGE();
 336                 portMEMORY_BARRIER();
 337             }
 338             else
 339             {
 340                 xReturn = xTaskGetIdleTaskHandle();
 341             }
 342
 343             return xReturn;
 344         }
 345     #endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */
 346 /*-----------------------------------------------------------*/
 347
 348     #if ( INCLUDE_vTaskSuspend == 1 )
 349         void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend ) /* FREERTOS_SYSTEM_CALL */
 350         {
 351             if( portIS_PRIVILEGED() == pdFALSE )
 352             {
 353                 portRAISE_PRIVILEGE();
 354                 portMEMORY_BARRIER();
 355
 356                 vTaskSuspend( pxTaskToSuspend );
 357                 portMEMORY_BARRIER();
 358
 359                 portRESET_PRIVILEGE();
 360                 portMEMORY_BARRIER();
 361             }
 362             else
 363             {
 364                 vTaskSuspend( pxTaskToSuspend );
 365             }
 366         }
 367     #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
 368 /*-----------------------------------------------------------*/
 369
 370     #if ( INCLUDE_vTaskSuspend == 1 )
 371         void MPU_vTaskResume( TaskHandle_t pxTaskToResume ) /* FREERTOS_SYSTEM_CALL */
 372         {
 373             if( portIS_PRIVILEGED() == pdFALSE )
 374             {
 375                 portRAISE_PRIVILEGE();
 376                 portMEMORY_BARRIER();
 377
 378                 vTaskResume( pxTaskToResume );
 379                 portMEMORY_BARRIER();
 380
 381                 portRESET_PRIVILEGE();
 382                 portMEMORY_BARRIER();
 383             }
 384             else
 385             {
 386                 vTaskResume( pxTaskToResume );
 387             }
 388         }
 389     #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
 390 /*-----------------------------------------------------------*/
 391
 392     void MPU_vTaskSuspendAll( void ) /* FREERTOS_SYSTEM_CALL */
 393     {
 394         if( portIS_PRIVILEGED() == pdFALSE )
 395         {
 396             portRAISE_PRIVILEGE();
 397             portMEMORY_BARRIER();
 398
 399             vTaskSuspendAll();
 400             portMEMORY_BARRIER();
 401
 402             portRESET_PRIVILEGE();
 403             portMEMORY_BARRIER();
 404         }
 405         else
 406         {
 407             vTaskSuspendAll();
 408         }
 409     }
 410 /*-----------------------------------------------------------*/
 411
 412     BaseType_t MPU_xTaskResumeAll( void ) /* FREERTOS_SYSTEM_CALL */
 413     {
 414         BaseType_t xReturn;
 415
 416         if( portIS_PRIVILEGED() == pdFALSE )
 417         {
 418             portRAISE_PRIVILEGE();
 419             portMEMORY_BARRIER();
 420
 421             xReturn = xTaskResumeAll();
 422             portMEMORY_BARRIER();
 423
 424             portRESET_PRIVILEGE();
 425             portMEMORY_BARRIER();
 426         }
 427         else
 428         {
 429             xReturn = xTaskResumeAll();
 430         }
 431
 432         return xReturn;
 433     }
 434 /*-----------------------------------------------------------*/
 435
 436     TickType_t MPU_xTaskGetTickCount( void ) /* FREERTOS_SYSTEM_CALL */
 437     {
 438         TickType_t xReturn;
 439
 440         if( portIS_PRIVILEGED() == pdFALSE )
 441         {
 442             portRAISE_PRIVILEGE();
 443             portMEMORY_BARRIER();
 444
 445             xReturn = xTaskGetTickCount();
 446             portMEMORY_BARRIER();
 447
 448             portRESET_PRIVILEGE();
 449             portMEMORY_BARRIER();
 450         }
 451         else
 452         {
 453             xReturn = xTaskGetTickCount();
 454         }
 455
 456         return xReturn;
 457     }
 458 /*-----------------------------------------------------------*/
 459
 460     UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* FREERTOS_SYSTEM_CALL */
 461     {
 462         UBaseType_t uxReturn;
 463
 464         if( portIS_PRIVILEGED() == pdFALSE )
 465         {
 466             portRAISE_PRIVILEGE();
 467             portMEMORY_BARRIER();
 468
 469             uxReturn = uxTaskGetNumberOfTasks();
 470             portMEMORY_BARRIER();
 471
 472             portRESET_PRIVILEGE();
 473             portMEMORY_BARRIER();
 474         }
 475         else
 476         {
 477             uxReturn = uxTaskGetNumberOfTasks();
 478         }
 479
 480         return uxReturn;
 481     }
 482 /*-----------------------------------------------------------*/
 483
 484     #if ( INCLUDE_xTaskGetHandle == 1 )
 485         TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) /* FREERTOS_SYSTEM_CALL */
 486         {
 487             TaskHandle_t xReturn;
 488
 489             if( portIS_PRIVILEGED() == pdFALSE )
 490             {
 491                 portRAISE_PRIVILEGE();
 492                 portMEMORY_BARRIER();
 493
 494                 xReturn = xTaskGetHandle( pcNameToQuery );
 495                 portMEMORY_BARRIER();
 496
 497                 portRESET_PRIVILEGE();
 498                 portMEMORY_BARRIER();
 499             }
 500             else
 501             {
 502                 xReturn = xTaskGetHandle( pcNameToQuery );
 503             }
 504
 505             return xReturn;
 506         }
 507     #endif /* if ( INCLUDE_xTaskGetHandle == 1 ) */
 508 /*-----------------------------------------------------------*/
 509
 510     #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
 511         void MPU_vTaskList( char * pcWriteBuffer ) /* FREERTOS_SYSTEM_CALL */
 512         {
 513             if( portIS_PRIVILEGED() == pdFALSE )
 514             {
 515                 portRAISE_PRIVILEGE();
 516                 portMEMORY_BARRIER();
 517
 518                 vTaskList( pcWriteBuffer );
 519                 portMEMORY_BARRIER();
 520
 521                 portRESET_PRIVILEGE();
 522                 portMEMORY_BARRIER();
 523             }
 524             else
 525             {
 526                 vTaskList( pcWriteBuffer );
 527             }
 528         }
 529     #endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
 530 /*-----------------------------------------------------------*/
 531
 532     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
 533         void MPU_vTaskGetRunTimeStats( char * pcWriteBuffer ) /* FREERTOS_SYSTEM_CALL */
 534         {
 535             if( portIS_PRIVILEGED() == pdFALSE )
 536             {
 537                 portRAISE_PRIVILEGE();
 538                 portMEMORY_BARRIER();
 539
 540                 vTaskGetRunTimeStats( pcWriteBuffer );
 541                 portMEMORY_BARRIER();
 542
 543                 portRESET_PRIVILEGE();
 544                 portMEMORY_BARRIER();
 545             }
 546             else
 547             {
 548                 vTaskGetRunTimeStats( pcWriteBuffer );
 549             }
 550         }
 551     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
 552 /*-----------------------------------------------------------*/
 553
 554     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
 555         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) /* FREERTOS_SYSTEM_CALL */
 556         {
 557             configRUN_TIME_COUNTER_TYPE xReturn;
 558
 559             if( portIS_PRIVILEGED() == pdFALSE )
 560             {
 561                 portRAISE_PRIVILEGE();
 562                 portMEMORY_BARRIER();
 563
 564                 xReturn = ulTaskGetIdleRunTimePercent();
 565                 portMEMORY_BARRIER();
 566
 567                 portRESET_PRIVILEGE();
 568                 portMEMORY_BARRIER();
 569             }
 570             else
 571             {
 572                 xReturn = ulTaskGetIdleRunTimePercent();
 573             }
 574
 575             return xReturn;
 576         }
 577     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
 578 /*-----------------------------------------------------------*/
 579
 580     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
 581         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */
 582         {
 583             configRUN_TIME_COUNTER_TYPE xReturn;
 584
 585             if( portIS_PRIVILEGED() == pdFALSE )
 586             {
 587                 portRAISE_PRIVILEGE();
 588                 portMEMORY_BARRIER();
 589
 590                 xReturn = ulTaskGetIdleRunTimeCounter();
 591                 portMEMORY_BARRIER();
 592
 593                 portRESET_PRIVILEGE();
 594                 portMEMORY_BARRIER();
 595             }
 596             else
 597             {
 598                 xReturn = ulTaskGetIdleRunTimeCounter();
 599             }
 600
 601             return xReturn;
 602         }
 603     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
 604 /*-----------------------------------------------------------*/
 605
 606     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 607         void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,
 608                                              TaskHookFunction_t pxTagValue ) /* FREERTOS_SYSTEM_CALL */
 609         {
 610             if( portIS_PRIVILEGED() == pdFALSE )
 611             {
 612                 portRAISE_PRIVILEGE();
 613                 portMEMORY_BARRIER();
 614
 615                 vTaskSetApplicationTaskTag( xTask, pxTagValue );
 616                 portMEMORY_BARRIER();
 617
 618                 portRESET_PRIVILEGE();
 619                 portMEMORY_BARRIER();
 620             }
 621             else
 622             {
 623                 vTaskSetApplicationTaskTag( xTask, pxTagValue );
 624             }
 625         }
 626     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 627 /*-----------------------------------------------------------*/
 628
 629     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 630         TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
 631         {
 632             TaskHookFunction_t xReturn;
 633
 634             if( portIS_PRIVILEGED() == pdFALSE )
 635             {
 636                 portRAISE_PRIVILEGE();
 637                 portMEMORY_BARRIER();
 638
 639                 xReturn = xTaskGetApplicationTaskTag( xTask );
 640                 portMEMORY_BARRIER();
 641
 642                 portRESET_PRIVILEGE();
 643                 portMEMORY_BARRIER();
 644             }
 645             else
 646             {
 647                 xReturn = xTaskGetApplicationTaskTag( xTask );
 648             }
 649
 650             return xReturn;
 651         }
 652     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 653 /*-----------------------------------------------------------*/
 654
 655     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
 656         void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
 657                                                     BaseType_t xIndex,
 658                                                     void * pvValue ) /* FREERTOS_SYSTEM_CALL */
 659         {
 660             if( portIS_PRIVILEGED() == pdFALSE )
 661             {
 662                 portRAISE_PRIVILEGE();
 663                 portMEMORY_BARRIER();
 664
 665                 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
 666                 portMEMORY_BARRIER();
 667
 668                 portRESET_PRIVILEGE();
 669                 portMEMORY_BARRIER();
 670             }
 671             else
 672             {
 673                 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
 674             }
 675         }
 676     #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
 677 /*-----------------------------------------------------------*/
 678
 679     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
 680         void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
 681                                                        BaseType_t xIndex ) /* FREERTOS_SYSTEM_CALL */
 682         {
 683             void * pvReturn;
 684
 685             if( portIS_PRIVILEGED() == pdFALSE )
 686             {
 687                 portRAISE_PRIVILEGE();
 688                 portMEMORY_BARRIER();
 689
 690                 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
 691                 portMEMORY_BARRIER();
 692
 693                 portRESET_PRIVILEGE();
 694                 portMEMORY_BARRIER();
 695             }
 696             else
 697             {
 698                 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
 699             }
 700
 701             return pvReturn;
 702         }
 703     #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
 704 /*-----------------------------------------------------------*/
 705
 706     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 707         BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
 708                                                      void * pvParameter ) /* FREERTOS_SYSTEM_CALL */
 709         {
 710             BaseType_t xReturn;
 711
 712             if( portIS_PRIVILEGED() == pdFALSE )
 713             {
 714                 portRAISE_PRIVILEGE();
 715                 portMEMORY_BARRIER();
 716
 717                 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
 718                 portMEMORY_BARRIER();
 719
 720                 portRESET_PRIVILEGE();
 721                 portMEMORY_BARRIER();
 722             }
 723             else
 724             {
 725                 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
 726             }
 727
 728             return xReturn;
 729         }
 730     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 731 /*-----------------------------------------------------------*/
 732
 733     #if ( configUSE_TRACE_FACILITY == 1 )
 734         UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * pxTaskStatusArray,
 735                                               UBaseType_t uxArraySize,
 736                                               configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) /* FREERTOS_SYSTEM_CALL */
 737         {
 738             UBaseType_t uxReturn;
 739
 740             if( portIS_PRIVILEGED() == pdFALSE )
 741             {
 742                 portRAISE_PRIVILEGE();
 743                 portMEMORY_BARRIER();
 744
 745                 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
 746                 portMEMORY_BARRIER();
 747
 748                 portRESET_PRIVILEGE();
 749                 portMEMORY_BARRIER();
 750             }
 751             else
 752             {
 753                 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
 754             }
 755
 756             return uxReturn;
 757         }
 758     #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
 759 /*-----------------------------------------------------------*/
 760
 761     BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTEM_CALL */
 762     {
 763         BaseType_t xReturn;
 764
 765         if( portIS_PRIVILEGED() == pdFALSE )
 766         {
 767             portRAISE_PRIVILEGE();
 768             portMEMORY_BARRIER();
 769
 770             xReturn = xTaskCatchUpTicks( xTicksToCatchUp );
 771             portMEMORY_BARRIER();
 772
 773             portRESET_PRIVILEGE();
 774             portMEMORY_BARRIER();
 775         }
 776         else
 777         {
 778             xReturn = xTaskCatchUpTicks( xTicksToCatchUp );
 779         }
 780
 781         return xReturn;
 782     }
 783 /*-----------------------------------------------------------*/
 784
 785     #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
 786         UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
 787         {
 788             UBaseType_t uxReturn;
 789
 790             if( portIS_PRIVILEGED() == pdFALSE )
 791             {
 792                 portRAISE_PRIVILEGE();
 793                 portMEMORY_BARRIER();
 794
 795                 uxReturn = uxTaskGetStackHighWaterMark( xTask );
 796                 portMEMORY_BARRIER();
 797
 798                 portRESET_PRIVILEGE();
 799                 portMEMORY_BARRIER();
 800             }
 801             else
 802             {
 803                 uxReturn = uxTaskGetStackHighWaterMark( xTask );
 804             }
 805
 806             return uxReturn;
 807         }
 808     #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */
 809 /*-----------------------------------------------------------*/
 810
 811     #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
 812         configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
 813         {
 814             configSTACK_DEPTH_TYPE uxReturn;
 815
 816             if( portIS_PRIVILEGED() == pdFALSE )
 817             {
 818                 portRAISE_PRIVILEGE();
 819                 portMEMORY_BARRIER();
 820
 821                 uxReturn = uxTaskGetStackHighWaterMark2( xTask );
 822                 portMEMORY_BARRIER();
 823
 824                 portRESET_PRIVILEGE();
 825                 portMEMORY_BARRIER();
 826             }
 827             else
 828             {
 829                 uxReturn = uxTaskGetStackHighWaterMark2( xTask );
 830             }
 831
 832             return uxReturn;
 833         }
 834     #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */
 835 /*-----------------------------------------------------------*/
 836
 837     #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
 838         TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
 839         {
 840             TaskHandle_t xReturn;
 841
 842             if( portIS_PRIVILEGED() == pdFALSE )
 843             {
 844                 portRAISE_PRIVILEGE();
 845                 portMEMORY_BARRIER();
 846                 xReturn = xTaskGetCurrentTaskHandle();
 847                 portMEMORY_BARRIER();
 848
 849                 portRESET_PRIVILEGE();
 850                 portMEMORY_BARRIER();
 851             }
 852             else
 853             {
 854                 xReturn = xTaskGetCurrentTaskHandle();
 855             }
 856
 857             return xReturn;
 858         }
 859     #endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */
 860 /*-----------------------------------------------------------*/
 861
 862     #if ( INCLUDE_xTaskGetSchedulerState == 1 )
 863         BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */
 864         {
 865             BaseType_t xReturn;
 866
 867             if( portIS_PRIVILEGED() == pdFALSE )
 868             {
 869                 portRAISE_PRIVILEGE();
 870                 portMEMORY_BARRIER();
 871
 872                 xReturn = xTaskGetSchedulerState();
 873                 portMEMORY_BARRIER();
 874
 875                 portRESET_PRIVILEGE();
 876                 portMEMORY_BARRIER();
 877             }
 878             else
 879             {
 880                 xReturn = xTaskGetSchedulerState();
 881             }
 882
 883             return xReturn;
 884         }
 885     #endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */
 886 /*-----------------------------------------------------------*/
 887
 888     void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */
 889     {
 890         if( portIS_PRIVILEGED() == pdFALSE )
 891         {
 892             portRAISE_PRIVILEGE();
 893             portMEMORY_BARRIER();
 894
 895             vTaskSetTimeOutState( pxTimeOut );
 896             portMEMORY_BARRIER();
 897
 898             portRESET_PRIVILEGE();
 899             portMEMORY_BARRIER();
 900         }
 901         else
 902         {
 903             vTaskSetTimeOutState( pxTimeOut );
 904         }
 905     }
 906 /*-----------------------------------------------------------*/
 907
 908     BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
 909                                          TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 910     {
 911         BaseType_t xReturn;
 912
 913         if( portIS_PRIVILEGED() == pdFALSE )
 914         {
 915             portRAISE_PRIVILEGE();
 916             portMEMORY_BARRIER();
 917
 918             xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
 919             portMEMORY_BARRIER();
 920
 921             portRESET_PRIVILEGE();
 922             portMEMORY_BARRIER();
 923         }
 924         else
 925         {
 926             xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
 927         }
 928
 929         return xReturn;
 930     }
 931 /*-----------------------------------------------------------*/
 932
 933     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 934         BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,
 935                                            UBaseType_t uxIndexToNotify,
 936                                            uint32_t ulValue,
 937                                            eNotifyAction eAction,
 938                                            uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */
 939         {
 940             BaseType_t xReturn;
 941
 942             if( portIS_PRIVILEGED() == pdFALSE )
 943             {
 944                 portRAISE_PRIVILEGE();
 945                 portMEMORY_BARRIER();
 946
 947                 xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );
 948                 portMEMORY_BARRIER();
 949
 950                 portRESET_PRIVILEGE();
 951                 portMEMORY_BARRIER();
 952             }
 953             else
 954             {
 955                 xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );
 956             }
 957
 958             return xReturn;
 959         }
 960     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 961 /*-----------------------------------------------------------*/
 962
 963     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 964         BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
 965                                                uint32_t ulBitsToClearOnEntry,
 966                                                uint32_t ulBitsToClearOnExit,
 967                                                uint32_t * pulNotificationValue,
 968                                                TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 969         {
 970             BaseType_t xReturn;
 971
 972             if( portIS_PRIVILEGED() == pdFALSE )
 973             {
 974                 portRAISE_PRIVILEGE();
 975                 portMEMORY_BARRIER();
 976
 977                 xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
 978                 portMEMORY_BARRIER();
 979
 980                 portRESET_PRIVILEGE();
 981                 portMEMORY_BARRIER();
 982             }
 983             else
 984             {
 985                 xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
 986             }
 987
 988             return xReturn;
 989         }
 990     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 991 /*-----------------------------------------------------------*/
 992
 993     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 994         uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
 995                                               BaseType_t xClearCountOnExit,
 996                                               TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 997         {
 998             uint32_t ulReturn;
 999
1000             if( portIS_PRIVILEGED() == pdFALSE )
1001             {
1002                 portRAISE_PRIVILEGE();
1003                 portMEMORY_BARRIER();
1004
1005                 ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
1006                 portMEMORY_BARRIER();
1007
1008                 portRESET_PRIVILEGE();
1009                 portMEMORY_BARRIER();
1010             }
1011             else
1012             {
1013                 ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
1014             }
1015
1016             return ulReturn;
1017         }
1018     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1019 /*-----------------------------------------------------------*/
1020
1021     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1022         BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,
1023                                                      UBaseType_t uxIndexToClear ) /* FREERTOS_SYSTEM_CALL */
1024         {
1025             BaseType_t xReturn;
1026
1027             if( portIS_PRIVILEGED() == pdFALSE )
1028             {
1029                 portRAISE_PRIVILEGE();
1030                 portMEMORY_BARRIER();
1031
1032                 xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
1033                 portMEMORY_BARRIER();
1034
1035                 portRESET_PRIVILEGE();
1036                 portMEMORY_BARRIER();
1037             }
1038             else
1039             {
1040                 xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
1041             }
1042
1043             return xReturn;
1044         }
1045     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1046 /*-----------------------------------------------------------*/
1047
1048     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1049         uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
1050                                                     UBaseType_t uxIndexToClear,
1051                                                     uint32_t ulBitsToClear ) /* FREERTOS_SYSTEM_CALL */
1052         {
1053             uint32_t ulReturn;
1054
1055             if( portIS_PRIVILEGED() == pdFALSE )
1056             {
1057                 portRAISE_PRIVILEGE();
1058                 portMEMORY_BARRIER();
1059
1060                 ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
1061                 portMEMORY_BARRIER();
1062
1063                 portRESET_PRIVILEGE();
1064                 portMEMORY_BARRIER();
1065             }
1066             else
1067             {
1068                 ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
1069             }
1070
1071             return ulReturn;
1072         }
1073     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1074 /*-----------------------------------------------------------*/
1075
1076     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
1077         QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength,
1078                                                UBaseType_t uxItemSize,
1079                                                uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
1080         {
1081             QueueHandle_t xReturn;
1082
1083             if( portIS_PRIVILEGED() == pdFALSE )
1084             {
1085                 portRAISE_PRIVILEGE();
1086                 portMEMORY_BARRIER();
1087
1088                 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
1089                 portMEMORY_BARRIER();
1090
1091                 portRESET_PRIVILEGE();
1092                 portMEMORY_BARRIER();
1093             }
1094             else
1095             {
1096                 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
1097             }
1098
1099             return xReturn;
1100         }
1101     #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
1102 /*-----------------------------------------------------------*/
1103
1104     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
1105         QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
1106                                                      const UBaseType_t uxItemSize,
1107                                                      uint8_t * pucQueueStorage,
1108                                                      StaticQueue_t * pxStaticQueue,
1109                                                      const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
1110         {
1111             QueueHandle_t xReturn;
1112
1113             if( portIS_PRIVILEGED() == pdFALSE )
1114             {
1115                 portRAISE_PRIVILEGE();
1116                 portMEMORY_BARRIER();
1117
1118                 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
1119                 portMEMORY_BARRIER();
1120
1121                 portRESET_PRIVILEGE();
1122                 portMEMORY_BARRIER();
1123             }
1124             else
1125             {
1126                 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
1127             }
1128
1129             return xReturn;
1130         }
1131     #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
1132 /*-----------------------------------------------------------*/
1133
1134     BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue,
1135                                        BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */
1136     {
1137         BaseType_t xReturn;
1138
1139         if( portIS_PRIVILEGED() == pdFALSE )
1140         {
1141             portRAISE_PRIVILEGE();
1142             portMEMORY_BARRIER();
1143
1144             xReturn = xQueueGenericReset( pxQueue, xNewQueue );
1145             portMEMORY_BARRIER();
1146
1147             portRESET_PRIVILEGE();
1148             portMEMORY_BARRIER();
1149         }
1150         else
1151         {
1152             xReturn = xQueueGenericReset( pxQueue, xNewQueue );
1153         }
1154
1155         return xReturn;
1156     }
1157 /*-----------------------------------------------------------*/
1158
1159     BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,
1160                                       const void * const pvItemToQueue,
1161                                       TickType_t xTicksToWait,
1162                                       BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */
1163     {
1164         BaseType_t xReturn;
1165
1166         if( portIS_PRIVILEGED() == pdFALSE )
1167         {
1168             portRAISE_PRIVILEGE();
1169             portMEMORY_BARRIER();
1170
1171             xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
1172             portMEMORY_BARRIER();
1173
1174             portRESET_PRIVILEGE();
1175             portMEMORY_BARRIER();
1176         }
1177         else
1178         {
1179             xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
1180         }
1181
1182         return xReturn;
1183     }
1184 /*-----------------------------------------------------------*/
1185
1186     UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */
1187     {
1188         UBaseType_t uxReturn;
1189
1190         if( portIS_PRIVILEGED() == pdFALSE )
1191         {
1192             portRAISE_PRIVILEGE();
1193             portMEMORY_BARRIER();
1194
1195             uxReturn = uxQueueMessagesWaiting( pxQueue );
1196             portMEMORY_BARRIER();
1197
1198             portRESET_PRIVILEGE();
1199             portMEMORY_BARRIER();
1200         }
1201         else
1202         {
1203             uxReturn = uxQueueMessagesWaiting( pxQueue );
1204         }
1205
1206         return uxReturn;
1207     }
1208 /*-----------------------------------------------------------*/
1209
1210     UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1211     {
1212         UBaseType_t uxReturn;
1213
1214         if( portIS_PRIVILEGED() == pdFALSE )
1215         {
1216             portRAISE_PRIVILEGE();
1217             portMEMORY_BARRIER();
1218
1219             uxReturn = uxQueueSpacesAvailable( xQueue );
1220             portMEMORY_BARRIER();
1221
1222             portRESET_PRIVILEGE();
1223             portMEMORY_BARRIER();
1224         }
1225         else
1226         {
1227             uxReturn = uxQueueSpacesAvailable( xQueue );
1228         }
1229
1230         return uxReturn;
1231     }
1232 /*-----------------------------------------------------------*/
1233
1234     BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue,
1235                                   void * const pvBuffer,
1236                                   TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1237     {
1238         BaseType_t xReturn;
1239
1240         if( portIS_PRIVILEGED() == pdFALSE )
1241         {
1242             portRAISE_PRIVILEGE();
1243             portMEMORY_BARRIER();
1244
1245             xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
1246             portMEMORY_BARRIER();
1247
1248             portRESET_PRIVILEGE();
1249             portMEMORY_BARRIER();
1250         }
1251         else
1252         {
1253             xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
1254         }
1255
1256         return xReturn;
1257     }
1258 /*-----------------------------------------------------------*/
1259
1260     BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
1261                                void * const pvBuffer,
1262                                TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1263     {
1264         BaseType_t xReturn;
1265
1266         if( portIS_PRIVILEGED() == pdFALSE )
1267         {
1268             portRAISE_PRIVILEGE();
1269             portMEMORY_BARRIER();
1270
1271             xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
1272             portMEMORY_BARRIER();
1273
1274             portRESET_PRIVILEGE();
1275             portMEMORY_BARRIER();
1276         }
1277         else
1278         {
1279             xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
1280         }
1281
1282         return xReturn;
1283     }
1284 /*-----------------------------------------------------------*/
1285
1286     BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
1287                                         TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1288     {
1289         BaseType_t xReturn;
1290
1291         if( portIS_PRIVILEGED() == pdFALSE )
1292         {
1293             portRAISE_PRIVILEGE();
1294             portMEMORY_BARRIER();
1295
1296             xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
1297             portMEMORY_BARRIER();
1298
1299             portRESET_PRIVILEGE();
1300             portMEMORY_BARRIER();
1301         }
1302         else
1303         {
1304             xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
1305         }
1306
1307         return xReturn;
1308     }
1309 /*-----------------------------------------------------------*/
1310
1311     #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
1312         TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */
1313         {
1314             void * xReturn;
1315
1316             if( portIS_PRIVILEGED() == pdFALSE )
1317             {
1318                 portRAISE_PRIVILEGE();
1319                 portMEMORY_BARRIER();
1320
1321                 xReturn = xQueueGetMutexHolder( xSemaphore );
1322                 portMEMORY_BARRIER();
1323
1324                 portRESET_PRIVILEGE();
1325                 portMEMORY_BARRIER();
1326             }
1327             else
1328             {
1329                 xReturn = xQueueGetMutexHolder( xSemaphore );
1330             }
1331
1332             return xReturn;
1333         }
1334     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
1335 /*-----------------------------------------------------------*/
1336
1337     #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
1338         QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
1339         {
1340             QueueHandle_t xReturn;
1341
1342             if( portIS_PRIVILEGED() == pdFALSE )
1343             {
1344                 portRAISE_PRIVILEGE();
1345                 portMEMORY_BARRIER();
1346
1347                 xReturn = xQueueCreateMutex( ucQueueType );
1348                 portMEMORY_BARRIER();
1349
1350                 portRESET_PRIVILEGE();
1351                 portMEMORY_BARRIER();
1352             }
1353             else
1354             {
1355                 xReturn = xQueueCreateMutex( ucQueueType );
1356             }
1357
1358             return xReturn;
1359         }
1360     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
1361 /*-----------------------------------------------------------*/
1362
1363     #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
1364         QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
1365                                                    StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
1366         {
1367             QueueHandle_t xReturn;
1368
1369             if( portIS_PRIVILEGED() == pdFALSE )
1370             {
1371                 portRAISE_PRIVILEGE();
1372                 portMEMORY_BARRIER();
1373
1374                 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
1375                 portMEMORY_BARRIER();
1376
1377                 portRESET_PRIVILEGE();
1378                 portMEMORY_BARRIER();
1379             }
1380             else
1381             {
1382                 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
1383             }
1384
1385             return xReturn;
1386         }
1387     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
1388 /*-----------------------------------------------------------*/
1389
1390     #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
1391         QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue,
1392                                                          UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */
1393         {
1394             QueueHandle_t xReturn;
1395
1396             if( portIS_PRIVILEGED() == pdFALSE )
1397             {
1398                 portRAISE_PRIVILEGE();
1399                 portMEMORY_BARRIER();
1400
1401                 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
1402                 portMEMORY_BARRIER();
1403
1404                 portRESET_PRIVILEGE();
1405                 portMEMORY_BARRIER();
1406             }
1407             else
1408             {
1409                 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
1410             }
1411
1412             return xReturn;
1413         }
1414     #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
1415 /*-----------------------------------------------------------*/
1416
1417     #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
1418
1419         QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
1420                                                                const UBaseType_t uxInitialCount,
1421                                                                StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
1422         {
1423             QueueHandle_t xReturn;
1424
1425             if( portIS_PRIVILEGED() == pdFALSE )
1426             {
1427                 portRAISE_PRIVILEGE();
1428                 portMEMORY_BARRIER();
1429
1430                 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
1431                 portMEMORY_BARRIER();
1432
1433                 portRESET_PRIVILEGE();
1434                 portMEMORY_BARRIER();
1435             }
1436             else
1437             {
1438                 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
1439             }
1440
1441             return xReturn;
1442         }
1443     #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
1444 /*-----------------------------------------------------------*/
1445
1446     #if ( configUSE_RECURSIVE_MUTEXES == 1 )
1447         BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,
1448                                                  TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */
1449         {
1450             BaseType_t xReturn;
1451
1452             if( portIS_PRIVILEGED() == pdFALSE )
1453             {
1454                 portRAISE_PRIVILEGE();
1455                 portMEMORY_BARRIER();
1456
1457                 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
1458                 portMEMORY_BARRIER();
1459
1460                 portRESET_PRIVILEGE();
1461                 portMEMORY_BARRIER();
1462             }
1463             else
1464             {
1465                 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
1466             }
1467
1468             return xReturn;
1469         }
1470     #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
1471 /*-----------------------------------------------------------*/
1472
1473     #if ( configUSE_RECURSIVE_MUTEXES == 1 )
1474         BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */
1475         {
1476             BaseType_t xReturn;
1477
1478             if( portIS_PRIVILEGED() == pdFALSE )
1479             {
1480                 portRAISE_PRIVILEGE();
1481                 portMEMORY_BARRIER();
1482
1483                 xReturn = xQueueGiveMutexRecursive( xMutex );
1484                 portMEMORY_BARRIER();
1485
1486                 portRESET_PRIVILEGE();
1487                 portMEMORY_BARRIER();
1488             }
1489             else
1490             {
1491                 xReturn = xQueueGiveMutexRecursive( xMutex );
1492             }
1493
1494             return xReturn;
1495         }
1496     #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
1497 /*-----------------------------------------------------------*/
1498
1499     #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
1500         QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */
1501         {
1502             QueueSetHandle_t xReturn;
1503
1504             if( portIS_PRIVILEGED() == pdFALSE )
1505             {
1506                 portRAISE_PRIVILEGE();
1507                 portMEMORY_BARRIER();
1508
1509                 xReturn = xQueueCreateSet( uxEventQueueLength );
1510                 portMEMORY_BARRIER();
1511
1512                 portRESET_PRIVILEGE();
1513                 portMEMORY_BARRIER();
1514             }
1515             else
1516             {
1517                 xReturn = xQueueCreateSet( uxEventQueueLength );
1518             }
1519
1520             return xReturn;
1521         }
1522     #endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
1523 /*-----------------------------------------------------------*/
1524
1525     #if ( configUSE_QUEUE_SETS == 1 )
1526         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
1527                                                         TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */
1528         {
1529             QueueSetMemberHandle_t xReturn;
1530
1531             if( portIS_PRIVILEGED() == pdFALSE )
1532             {
1533                 portRAISE_PRIVILEGE();
1534                 portMEMORY_BARRIER();
1535
1536                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
1537                 portMEMORY_BARRIER();
1538
1539                 portRESET_PRIVILEGE();
1540                 portMEMORY_BARRIER();
1541             }
1542             else
1543             {
1544                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
1545             }
1546
1547             return xReturn;
1548         }
1549     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1550 /*-----------------------------------------------------------*/
1551
1552     #if ( configUSE_QUEUE_SETS == 1 )
1553         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
1554                                        QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
1555         {
1556             BaseType_t xReturn;
1557
1558             if( portIS_PRIVILEGED() == pdFALSE )
1559             {
1560                 portRAISE_PRIVILEGE();
1561                 portMEMORY_BARRIER();
1562
1563                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
1564                 portMEMORY_BARRIER();
1565
1566                 portRESET_PRIVILEGE();
1567                 portMEMORY_BARRIER();
1568             }
1569             else
1570             {
1571                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
1572             }
1573
1574             return xReturn;
1575         }
1576     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1577 /*-----------------------------------------------------------*/
1578
1579     #if ( configUSE_QUEUE_SETS == 1 )
1580         BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
1581                                             QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
1582         {
1583             BaseType_t xReturn;
1584
1585             if( portIS_PRIVILEGED() == pdFALSE )
1586             {
1587                 portRAISE_PRIVILEGE();
1588                 portMEMORY_BARRIER();
1589
1590                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
1591                 portMEMORY_BARRIER();
1592
1593                 portRESET_PRIVILEGE();
1594                 portMEMORY_BARRIER();
1595             }
1596             else
1597             {
1598                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
1599             }
1600
1601             return xReturn;
1602         }
1603     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1604 /*-----------------------------------------------------------*/
1605
1606     #if configQUEUE_REGISTRY_SIZE > 0
1607         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
1608                                       const char * pcName ) /* FREERTOS_SYSTEM_CALL */
1609         {
1610             if( portIS_PRIVILEGED() == pdFALSE )
1611             {
1612                 portRAISE_PRIVILEGE();
1613                 portMEMORY_BARRIER();
1614
1615                 vQueueAddToRegistry( xQueue, pcName );
1616                 portMEMORY_BARRIER();
1617
1618                 portRESET_PRIVILEGE();
1619                 portMEMORY_BARRIER();
1620             }
1621             else
1622             {
1623                 vQueueAddToRegistry( xQueue, pcName );
1624             }
1625         }
1626     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1627 /*-----------------------------------------------------------*/
1628
1629     #if configQUEUE_REGISTRY_SIZE > 0
1630         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1631         {
1632             if( portIS_PRIVILEGED() == pdFALSE )
1633             {
1634                 portRAISE_PRIVILEGE();
1635                 portMEMORY_BARRIER();
1636
1637                 vQueueUnregisterQueue( xQueue );
1638                 portMEMORY_BARRIER();
1639
1640                 portRESET_PRIVILEGE();
1641                 portMEMORY_BARRIER();
1642             }
1643             else
1644             {
1645                 vQueueUnregisterQueue( xQueue );
1646             }
1647         }
1648     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1649 /*-----------------------------------------------------------*/
1650
1651     #if configQUEUE_REGISTRY_SIZE > 0
1652         const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1653         {
1654             const char * pcReturn;
1655
1656             if( portIS_PRIVILEGED() == pdFALSE )
1657             {
1658                 portRAISE_PRIVILEGE();
1659                 portMEMORY_BARRIER();
1660
1661                 pcReturn = pcQueueGetName( xQueue );
1662                 portMEMORY_BARRIER();
1663
1664                 portRESET_PRIVILEGE();
1665                 portMEMORY_BARRIER();
1666             }
1667             else
1668             {
1669                 pcReturn = pcQueueGetName( xQueue );
1670             }
1671
1672             return pcReturn;
1673         }
1674     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1675 /*-----------------------------------------------------------*/
1676
1677     void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1678     {
1679         if( portIS_PRIVILEGED() == pdFALSE )
1680         {
1681             portRAISE_PRIVILEGE();
1682             portMEMORY_BARRIER();
1683
1684             vQueueDelete( xQueue );
1685             portMEMORY_BARRIER();
1686
1687             portRESET_PRIVILEGE();
1688             portMEMORY_BARRIER();
1689         }
1690         else
1691         {
1692             vQueueDelete( xQueue );
1693         }
1694     }
1695 /*-----------------------------------------------------------*/
1696
1697     #if ( configUSE_TIMERS == 1 )
1698         void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1699         {
1700             void * pvReturn;
1701
1702             if( portIS_PRIVILEGED() == pdFALSE )
1703             {
1704                 portRAISE_PRIVILEGE();
1705                 portMEMORY_BARRIER();
1706
1707                 pvReturn = pvTimerGetTimerID( xTimer );
1708                 portMEMORY_BARRIER();
1709
1710                 portRESET_PRIVILEGE();
1711                 portMEMORY_BARRIER();
1712             }
1713             else
1714             {
1715                 pvReturn = pvTimerGetTimerID( xTimer );
1716             }
1717
1718             return pvReturn;
1719         }
1720     #endif /* if ( configUSE_TIMERS == 1 ) */
1721 /*-----------------------------------------------------------*/
1722
1723     #if ( configUSE_TIMERS == 1 )
1724         void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
1725                                    void * pvNewID ) /* FREERTOS_SYSTEM_CALL */
1726         {
1727             if( portIS_PRIVILEGED() == pdFALSE )
1728             {
1729                 portRAISE_PRIVILEGE();
1730                 portMEMORY_BARRIER();
1731
1732                 vTimerSetTimerID( xTimer, pvNewID );
1733                 portMEMORY_BARRIER();
1734
1735                 portRESET_PRIVILEGE();
1736                 portMEMORY_BARRIER();
1737             }
1738             else
1739             {
1740                 vTimerSetTimerID( xTimer, pvNewID );
1741             }
1742         }
1743     #endif /* if ( configUSE_TIMERS == 1 ) */
1744 /*-----------------------------------------------------------*/
1745
1746     #if ( configUSE_TIMERS == 1 )
1747         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1748         {
1749             BaseType_t xReturn;
1750
1751             if( portIS_PRIVILEGED() == pdFALSE )
1752             {
1753                 portRAISE_PRIVILEGE();
1754                 portMEMORY_BARRIER();
1755
1756                 xReturn = xTimerIsTimerActive( xTimer );
1757                 portMEMORY_BARRIER();
1758
1759                 portRESET_PRIVILEGE();
1760                 portMEMORY_BARRIER();
1761             }
1762             else
1763             {
1764                 xReturn = xTimerIsTimerActive( xTimer );
1765             }
1766
1767             return xReturn;
1768         }
1769     #endif /* if ( configUSE_TIMERS == 1 ) */
1770 /*-----------------------------------------------------------*/
1771
1772     #if ( configUSE_TIMERS == 1 )
1773         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
1774         {
1775             TaskHandle_t xReturn;
1776
1777             if( portIS_PRIVILEGED() == pdFALSE )
1778             {
1779                 portRAISE_PRIVILEGE();
1780                 portMEMORY_BARRIER();
1781
1782                 xReturn = xTimerGetTimerDaemonTaskHandle();
1783                 portMEMORY_BARRIER();
1784
1785                 portRESET_PRIVILEGE();
1786                 portMEMORY_BARRIER();
1787             }
1788             else
1789             {
1790                 xReturn = xTimerGetTimerDaemonTaskHandle();
1791             }
1792
1793             return xReturn;
1794         }
1795     #endif /* if ( configUSE_TIMERS == 1 ) */
1796 /*-----------------------------------------------------------*/
1797
1798     #if ( configUSE_TIMERS == 1 )
1799         void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
1800                                       const UBaseType_t uxAutoReload ) /* FREERTOS_SYSTEM_CALL */
1801         {
1802             if( portIS_PRIVILEGED() == pdFALSE )
1803             {
1804                 portRAISE_PRIVILEGE();
1805                 portMEMORY_BARRIER();
1806
1807                 vTimerSetReloadMode( xTimer, uxAutoReload );
1808                 portMEMORY_BARRIER();
1809
1810                 portRESET_PRIVILEGE();
1811                 portMEMORY_BARRIER();
1812             }
1813             else
1814             {
1815                 vTimerSetReloadMode( xTimer, uxAutoReload );
1816             }
1817         }
1818     #endif /* if ( configUSE_TIMERS == 1 ) */
1819 /*-----------------------------------------------------------*/
1820
1821     #if ( configUSE_TIMERS == 1 )
1822         UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer )
1823         {
1824             UBaseType_t uxReturn;
1825
1826             if( portIS_PRIVILEGED() == pdFALSE )
1827             {
1828                 portRAISE_PRIVILEGE();
1829                 portMEMORY_BARRIER();
1830
1831                 uxReturn = uxTimerGetReloadMode( xTimer );
1832                 portMEMORY_BARRIER();
1833
1834                 portRESET_PRIVILEGE();
1835                 portMEMORY_BARRIER();
1836             }
1837             else
1838             {
1839                 uxReturn = uxTimerGetReloadMode( xTimer );
1840             }
1841
1842             return uxReturn;
1843         }
1844     #endif /* if ( configUSE_TIMERS == 1 ) */
1845 /*-----------------------------------------------------------*/
1846
1847     #if ( configUSE_TIMERS == 1 )
1848         const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1849         {
1850             const char * pcReturn;
1851
1852             if( portIS_PRIVILEGED() == pdFALSE )
1853             {
1854                 portRAISE_PRIVILEGE();
1855                 portMEMORY_BARRIER();
1856
1857                 pcReturn = pcTimerGetName( xTimer );
1858                 portMEMORY_BARRIER();
1859
1860                 portRESET_PRIVILEGE();
1861                 portMEMORY_BARRIER();
1862             }
1863             else
1864             {
1865                 pcReturn = pcTimerGetName( xTimer );
1866             }
1867
1868             return pcReturn;
1869         }
1870     #endif /* if ( configUSE_TIMERS == 1 ) */
1871 /*-----------------------------------------------------------*/
1872
1873     #if ( configUSE_TIMERS == 1 )
1874         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1875         {
1876             TickType_t xReturn;
1877
1878             if( portIS_PRIVILEGED() == pdFALSE )
1879             {
1880                 portRAISE_PRIVILEGE();
1881                 portMEMORY_BARRIER();
1882
1883                 xReturn = xTimerGetPeriod( xTimer );
1884                 portMEMORY_BARRIER();
1885
1886                 portRESET_PRIVILEGE();
1887                 portMEMORY_BARRIER();
1888             }
1889             else
1890             {
1891                 xReturn = xTimerGetPeriod( xTimer );
1892             }
1893
1894             return xReturn;
1895         }
1896     #endif /* if ( configUSE_TIMERS == 1 ) */
1897 /*-----------------------------------------------------------*/
1898
1899     #if ( configUSE_TIMERS == 1 )
1900         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1901         {
1902             TickType_t xReturn;
1903
1904             if( portIS_PRIVILEGED() == pdFALSE )
1905             {
1906                 portRAISE_PRIVILEGE();
1907                 portMEMORY_BARRIER();
1908
1909                 xReturn = xTimerGetExpiryTime( xTimer );
1910                 portMEMORY_BARRIER();
1911
1912                 portRESET_PRIVILEGE();
1913                 portMEMORY_BARRIER();
1914             }
1915             else
1916             {
1917                 xReturn = xTimerGetExpiryTime( xTimer );
1918             }
1919
1920             return xReturn;
1921         }
1922     #endif /* if ( configUSE_TIMERS == 1 ) */
1923 /*-----------------------------------------------------------*/
1924
1925     #if ( configUSE_TIMERS == 1 )
1926         BaseType_t MPU_xTimerGenericCommandFromTask( TimerHandle_t xTimer,
1927                                                      const BaseType_t xCommandID,
1928                                                      const TickType_t xOptionalValue,
1929                                                      BaseType_t * const pxHigherPriorityTaskWoken,
1930                                                      const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1931         {
1932             BaseType_t xReturn;
1933
1934             if( portIS_PRIVILEGED() == pdFALSE )
1935             {
1936                 portRAISE_PRIVILEGE();
1937                 portMEMORY_BARRIER();
1938
1939                 xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
1940                 portMEMORY_BARRIER();
1941
1942                 portRESET_PRIVILEGE();
1943                 portMEMORY_BARRIER();
1944             }
1945             else
1946             {
1947                 xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
1948             }
1949
1950             return xReturn;
1951         }
1952     #endif /* if ( configUSE_TIMERS == 1 ) */
1953 /*-----------------------------------------------------------*/
1954
1955     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
1956         EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */
1957         {
1958             EventGroupHandle_t xReturn;
1959
1960             if( portIS_PRIVILEGED() == pdFALSE )
1961             {
1962                 portRAISE_PRIVILEGE();
1963                 portMEMORY_BARRIER();
1964
1965                 xReturn = xEventGroupCreate();
1966                 portMEMORY_BARRIER();
1967
1968                 portRESET_PRIVILEGE();
1969                 portMEMORY_BARRIER();
1970             }
1971             else
1972             {
1973                 xReturn = xEventGroupCreate();
1974             }
1975
1976             return xReturn;
1977         }
1978     #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
1979 /*-----------------------------------------------------------*/
1980
1981     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
1982         EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */
1983         {
1984             EventGroupHandle_t xReturn;
1985
1986             if( portIS_PRIVILEGED() == pdFALSE )
1987             {
1988                 portRAISE_PRIVILEGE();
1989                 portMEMORY_BARRIER();
1990
1991                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
1992                 portMEMORY_BARRIER();
1993
1994                 portRESET_PRIVILEGE();
1995                 portMEMORY_BARRIER();
1996             }
1997             else
1998             {
1999                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
2000             }
2001
2002             return xReturn;
2003         }
2004     #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
2005 /*-----------------------------------------------------------*/
2006
2007     EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
2008                                          const EventBits_t uxBitsToWaitFor,
2009                                          const BaseType_t xClearOnExit,
2010                                          const BaseType_t xWaitForAllBits,
2011                                          TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2012     {
2013         EventBits_t xReturn;
2014
2015         if( portIS_PRIVILEGED() == pdFALSE )
2016         {
2017             portRAISE_PRIVILEGE();
2018             portMEMORY_BARRIER();
2019
2020             xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
2021             portMEMORY_BARRIER();
2022
2023             portRESET_PRIVILEGE();
2024             portMEMORY_BARRIER();
2025         }
2026         else
2027         {
2028             xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
2029         }
2030
2031         return xReturn;
2032     }
2033 /*-----------------------------------------------------------*/
2034
2035     EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
2036                                           const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */
2037     {
2038         EventBits_t xReturn;
2039
2040         if( portIS_PRIVILEGED() == pdFALSE )
2041         {
2042             portRAISE_PRIVILEGE();
2043             portMEMORY_BARRIER();
2044
2045             xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
2046             portMEMORY_BARRIER();
2047
2048             portRESET_PRIVILEGE();
2049             portMEMORY_BARRIER();
2050         }
2051         else
2052         {
2053             xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
2054         }
2055
2056         return xReturn;
2057     }
2058 /*-----------------------------------------------------------*/
2059
2060     EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
2061                                         const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */
2062     {
2063         EventBits_t xReturn;
2064
2065         if( portIS_PRIVILEGED() == pdFALSE )
2066         {
2067             portRAISE_PRIVILEGE();
2068             portMEMORY_BARRIER();
2069
2070             xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
2071             portMEMORY_BARRIER();
2072
2073             portRESET_PRIVILEGE();
2074             portMEMORY_BARRIER();
2075         }
2076         else
2077         {
2078             xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
2079         }
2080
2081         return xReturn;
2082     }
2083 /*-----------------------------------------------------------*/
2084
2085     EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
2086                                      const EventBits_t uxBitsToSet,
2087                                      const EventBits_t uxBitsToWaitFor,
2088                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2089     {
2090         EventBits_t xReturn;
2091
2092         if( portIS_PRIVILEGED() == pdFALSE )
2093         {
2094             portRAISE_PRIVILEGE();
2095             portMEMORY_BARRIER();
2096
2097             xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
2098             portMEMORY_BARRIER();
2099
2100             portRESET_PRIVILEGE();
2101             portMEMORY_BARRIER();
2102         }
2103         else
2104         {
2105             xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
2106         }
2107
2108         return xReturn;
2109     }
2110 /*-----------------------------------------------------------*/
2111
2112     void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */
2113     {
2114         if( portIS_PRIVILEGED() == pdFALSE )
2115         {
2116             portRAISE_PRIVILEGE();
2117             portMEMORY_BARRIER();
2118
2119             vEventGroupDelete( xEventGroup );
2120             portMEMORY_BARRIER();
2121
2122             portRESET_PRIVILEGE();
2123             portMEMORY_BARRIER();
2124         }
2125         else
2126         {
2127             vEventGroupDelete( xEventGroup );
2128         }
2129     }
2130 /*-----------------------------------------------------------*/
2131
2132     size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
2133                                   const void * pvTxData,
2134                                   size_t xDataLengthBytes,
2135                                   TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2136     {
2137         size_t xReturn;
2138
2139         if( portIS_PRIVILEGED() == pdFALSE )
2140         {
2141             portRAISE_PRIVILEGE();
2142             portMEMORY_BARRIER();
2143
2144             xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
2145             portMEMORY_BARRIER();
2146
2147             portRESET_PRIVILEGE();
2148             portMEMORY_BARRIER();
2149         }
2150         else
2151         {
2152             xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
2153         }
2154
2155         return xReturn;
2156     }
2157 /*-----------------------------------------------------------*/
2158
2159     size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2160     {
2161         size_t xReturn;
2162
2163         if( portIS_PRIVILEGED() == pdFALSE )
2164         {
2165             portRAISE_PRIVILEGE();
2166             portMEMORY_BARRIER();
2167
2168             xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
2169             portMEMORY_BARRIER();
2170
2171             portRESET_PRIVILEGE();
2172             portMEMORY_BARRIER();
2173         }
2174         else
2175         {
2176             xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
2177         }
2178
2179         return xReturn;
2180     }
2181 /*-----------------------------------------------------------*/
2182
2183     size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
2184                                      void * pvRxData,
2185                                      size_t xBufferLengthBytes,
2186                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2187     {
2188         size_t xReturn;
2189
2190         if( portIS_PRIVILEGED() == pdFALSE )
2191         {
2192             portRAISE_PRIVILEGE();
2193             portMEMORY_BARRIER();
2194
2195             xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
2196             portMEMORY_BARRIER();
2197
2198             portRESET_PRIVILEGE();
2199             portMEMORY_BARRIER();
2200         }
2201         else
2202         {
2203             xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
2204         }
2205
2206         return xReturn;
2207     }
2208 /*-----------------------------------------------------------*/
2209
2210     void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2211     {
2212         if( portIS_PRIVILEGED() == pdFALSE )
2213         {
2214             portRAISE_PRIVILEGE();
2215             portMEMORY_BARRIER();
2216
2217             vStreamBufferDelete( xStreamBuffer );
2218             portMEMORY_BARRIER();
2219
2220             portRESET_PRIVILEGE();
2221             portMEMORY_BARRIER();
2222         }
2223         else
2224         {
2225             vStreamBufferDelete( xStreamBuffer );
2226         }
2227     }
2228 /*-----------------------------------------------------------*/
2229
2230     BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2231     {
2232         BaseType_t xReturn;
2233
2234         if( portIS_PRIVILEGED() == pdFALSE )
2235         {
2236             portRAISE_PRIVILEGE();
2237             portMEMORY_BARRIER();
2238
2239             xReturn = xStreamBufferIsFull( xStreamBuffer );
2240             portMEMORY_BARRIER();
2241
2242             portRESET_PRIVILEGE();
2243             portMEMORY_BARRIER();
2244         }
2245         else
2246         {
2247             xReturn = xStreamBufferIsFull( xStreamBuffer );
2248         }
2249
2250         return xReturn;
2251     }
2252 /*-----------------------------------------------------------*/
2253
2254     BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2255     {
2256         BaseType_t xReturn;
2257
2258         if( portIS_PRIVILEGED() == pdFALSE )
2259         {
2260             portRAISE_PRIVILEGE();
2261             portMEMORY_BARRIER();
2262
2263             xReturn = xStreamBufferIsEmpty( xStreamBuffer );
2264             portMEMORY_BARRIER();
2265
2266             portRESET_PRIVILEGE();
2267             portMEMORY_BARRIER();
2268         }
2269         else
2270         {
2271             xReturn = xStreamBufferIsEmpty( xStreamBuffer );
2272         }
2273
2274         return xReturn;
2275     }
2276 /*-----------------------------------------------------------*/
2277
2278     BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2279     {
2280         BaseType_t xReturn;
2281
2282         if( portIS_PRIVILEGED() == pdFALSE )
2283         {
2284             portRAISE_PRIVILEGE();
2285             portMEMORY_BARRIER();
2286
2287             xReturn = xStreamBufferReset( xStreamBuffer );
2288             portMEMORY_BARRIER();
2289
2290             portRESET_PRIVILEGE();
2291             portMEMORY_BARRIER();
2292         }
2293         else
2294         {
2295             xReturn = xStreamBufferReset( xStreamBuffer );
2296         }
2297
2298         return xReturn;
2299     }
2300 /*-----------------------------------------------------------*/
2301
2302     size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2303     {
2304         size_t xReturn;
2305
2306         if( portIS_PRIVILEGED() == pdFALSE )
2307         {
2308             portRAISE_PRIVILEGE();
2309             portMEMORY_BARRIER();
2310             xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
2311             portMEMORY_BARRIER();
2312
2313             portRESET_PRIVILEGE();
2314             portMEMORY_BARRIER();
2315         }
2316         else
2317         {
2318             xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
2319         }
2320
2321         return xReturn;
2322     }
2323 /*-----------------------------------------------------------*/
2324
2325     size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2326     {
2327         size_t xReturn;
2328
2329         if( portIS_PRIVILEGED() == pdFALSE )
2330         {
2331             portRAISE_PRIVILEGE();
2332             portMEMORY_BARRIER();
2333
2334             xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
2335             portMEMORY_BARRIER();
2336
2337             portRESET_PRIVILEGE();
2338             portMEMORY_BARRIER();
2339         }
2340         else
2341         {
2342             xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
2343         }
2344
2345         return xReturn;
2346     }
2347 /*-----------------------------------------------------------*/
2348
2349     BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
2350                                                  size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */
2351     {
2352         BaseType_t xReturn;
2353
2354         if( portIS_PRIVILEGED() == pdFALSE )
2355         {
2356             portRAISE_PRIVILEGE();
2357             portMEMORY_BARRIER();
2358
2359             xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
2360             portMEMORY_BARRIER();
2361
2362             portRESET_PRIVILEGE();
2363             portMEMORY_BARRIER();
2364         }
2365         else
2366         {
2367             xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
2368         }
2369
2370         return xReturn;
2371     }
2372 /*-----------------------------------------------------------*/
2373
2374     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
2375         StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
2376                                                              size_t xTriggerLevelBytes,
2377                                                              BaseType_t xIsMessageBuffer,
2378                                                              StreamBufferCallbackFunction_t pxSendCompletedCallback,
2379                                                              StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */
2380         {
2381             StreamBufferHandle_t xReturn;
2382
2383             /**
2384              * Streambuffer application level callback functionality is disabled for MPU
2385              * enabled ports.
2386              */
2387             configASSERT( ( pxSendCompletedCallback == NULL ) &&
2388                           ( pxReceiveCompletedCallback == NULL ) );
2389
2390             if( ( pxSendCompletedCallback == NULL ) &&
2391                 ( pxReceiveCompletedCallback == NULL ) )
2392             {
2393                 if( portIS_PRIVILEGED() == pdFALSE )
2394                 {
2395                     portRAISE_PRIVILEGE();
2396                     portMEMORY_BARRIER();
2397
2398                     xReturn = xStreamBufferGenericCreate( xBufferSizeBytes,
2399                                                           xTriggerLevelBytes,
2400                                                           xIsMessageBuffer,
2401                                                           NULL,
2402                                                           NULL );
2403                     portMEMORY_BARRIER();
2404
2405                     portRESET_PRIVILEGE();
2406                     portMEMORY_BARRIER();
2407                 }
2408                 else
2409                 {
2410                     xReturn = xStreamBufferGenericCreate( xBufferSizeBytes,
2411                                                           xTriggerLevelBytes,
2412                                                           xIsMessageBuffer,
2413                                                           NULL,
2414                                                           NULL );
2415                 }
2416             }
2417             else
2418             {
2419                 traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer );
2420                 xReturn = NULL;
2421             }
2422
2423             return xReturn;
2424         }
2425     #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
2426 /*-----------------------------------------------------------*/
2427
2428     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
2429         StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
2430                                                                    size_t xTriggerLevelBytes,
2431                                                                    BaseType_t xIsMessageBuffer,
2432                                                                    uint8_t * const pucStreamBufferStorageArea,
2433                                                                    StaticStreamBuffer_t * const pxStaticStreamBuffer,
2434                                                                    StreamBufferCallbackFunction_t pxSendCompletedCallback,
2435                                                                    StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */
2436         {
2437             StreamBufferHandle_t xReturn;
2438
2439             /**
2440              * Streambuffer application level callback functionality is disabled for MPU
2441              * enabled ports.
2442              */
2443             configASSERT( ( pxSendCompletedCallback == NULL ) &&
2444                           ( pxReceiveCompletedCallback == NULL ) );
2445
2446             if( ( pxSendCompletedCallback == NULL ) &&
2447                 ( pxReceiveCompletedCallback == NULL ) )
2448             {
2449                 if( portIS_PRIVILEGED() == pdFALSE )
2450                 {
2451                     portRAISE_PRIVILEGE();
2452                     portMEMORY_BARRIER();
2453
2454                     xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
2455                                                                 xTriggerLevelBytes,
2456                                                                 xIsMessageBuffer,
2457                                                                 pucStreamBufferStorageArea,
2458                                                                 pxStaticStreamBuffer,
2459                                                                 NULL,
2460                                                                 NULL );
2461                     portMEMORY_BARRIER();
2462
2463                     portRESET_PRIVILEGE();
2464                     portMEMORY_BARRIER();
2465                 }
2466                 else
2467                 {
2468                     xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
2469                                                                 xTriggerLevelBytes,
2470                                                                 xIsMessageBuffer,
2471                                                                 pucStreamBufferStorageArea,
2472                                                                 pxStaticStreamBuffer,
2473                                                                 NULL,
2474                                                                 NULL );
2475                 }
2476             }
2477             else
2478             {
2479                 traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xIsMessageBuffer );
2480                 xReturn = NULL;
2481             }
2482
2483             return xReturn;
2484         }
2485     #endif /* configSUPPORT_STATIC_ALLOCATION */
2486 /*-----------------------------------------------------------*/
2487
2488
2489 /* Functions that the application writer wants to execute in privileged mode
2490  * can be defined in application_defined_privileged_functions.h.  The functions
2491  * must take the same format as those above whereby the privilege state on exit
2492  * equals the privilege state on entry.  For example:
2493  *
2494  * void MPU_FunctionName( [parameters ] ) FREERTOS_SYSTEM_CALL;
2495  * void MPU_FunctionName( [parameters ] )
2496  * {
2497  *      if( portIS_PRIVILEGED() == pdFALSE )
2498  *      {
2499  *          portRAISE_PRIVILEGE();
2500  *          portMEMORY_BARRIER();
2501  *
2502  *          FunctionName( [parameters ] );
2503  *          portMEMORY_BARRIER();
2504  *
2505  *          portRESET_PRIVILEGE();
2506  *          portMEMORY_BARRIER();
2507  *      }
2508  *      else
2509  *      {
2510  *          FunctionName( [parameters ] );
2511  *      }
2512  * }
2513  */
2514
2515     #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
2516         #include "application_defined_privileged_functions.h"
2517     #endif
2518 /*-----------------------------------------------------------*/
2519
2520 #endif /* #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) ) */
2521 /*-----------------------------------------------------------*/