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