begriffs open source - freertos/blob - portable/Common/mpu_wrappers.c

   1 /*
   2  * FreeRTOS Kernel <DEVELOPMENT BRANCH>
   3  * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
   4  *
   5  * SPDX-License-Identifier: MIT
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   8  * this software and associated documentation files (the "Software"), to deal in
   9  * the Software without restriction, including without limitation the rights to
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  11  * the Software, and to permit persons to whom the Software is furnished to do so,
  12  * subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in all
  15  * copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  19  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  20  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * https://www.FreeRTOS.org
  25  * https://github.com/FreeRTOS
  26  *
  27  */
  28
  29 /*
  30  * Implementation of the wrapper functions used to raise the processor privilege
  31  * before calling a standard FreeRTOS API function.
  32  */
  33
  34 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
  35  * all the API functions to use the MPU wrappers.  That should only be done when
  36  * task.h is included from an application file. */
  37 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  38
  39 /* Scheduler includes. */
  40 #include "FreeRTOS.h"
  41 #include "task.h"
  42 #include "queue.h"
  43 #include "timers.h"
  44 #include "event_groups.h"
  45 #include "stream_buffer.h"
  46 #include "mpu_prototypes.h"
  47
  48 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  49 /*-----------------------------------------------------------*/
  50
  51 #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) )
  52
  53     #if ( 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     #if ( INCLUDE_xTaskGetHandle == 1 )
 481         TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) /* FREERTOS_SYSTEM_CALL */
 482         {
 483             TaskHandle_t xReturn;
 484
 485             if( portIS_PRIVILEGED() == pdFALSE )
 486             {
 487                 portRAISE_PRIVILEGE();
 488                 portMEMORY_BARRIER();
 489
 490                 xReturn = xTaskGetHandle( pcNameToQuery );
 491                 portMEMORY_BARRIER();
 492
 493                 portRESET_PRIVILEGE();
 494                 portMEMORY_BARRIER();
 495             }
 496             else
 497             {
 498                 xReturn = xTaskGetHandle( pcNameToQuery );
 499             }
 500
 501             return xReturn;
 502         }
 503     #endif /* if ( INCLUDE_xTaskGetHandle == 1 ) */
 504 /*-----------------------------------------------------------*/
 505
 506     #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
 507         void MPU_vTaskList( char * pcWriteBuffer ) /* FREERTOS_SYSTEM_CALL */
 508         {
 509             if( portIS_PRIVILEGED() == pdFALSE )
 510             {
 511                 portRAISE_PRIVILEGE();
 512                 portMEMORY_BARRIER();
 513
 514                 vTaskList( pcWriteBuffer );
 515                 portMEMORY_BARRIER();
 516
 517                 portRESET_PRIVILEGE();
 518                 portMEMORY_BARRIER();
 519             }
 520             else
 521             {
 522                 vTaskList( pcWriteBuffer );
 523             }
 524         }
 525     #endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
 526 /*-----------------------------------------------------------*/
 527
 528     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
 529         void MPU_vTaskGetRunTimeStats( char * pcWriteBuffer ) /* FREERTOS_SYSTEM_CALL */
 530         {
 531             if( portIS_PRIVILEGED() == pdFALSE )
 532             {
 533                 portRAISE_PRIVILEGE();
 534                 portMEMORY_BARRIER();
 535
 536                 vTaskGetRunTimeStats( pcWriteBuffer );
 537                 portMEMORY_BARRIER();
 538
 539                 portRESET_PRIVILEGE();
 540                 portMEMORY_BARRIER();
 541             }
 542             else
 543             {
 544                 vTaskGetRunTimeStats( pcWriteBuffer );
 545             }
 546         }
 547     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
 548 /*-----------------------------------------------------------*/
 549
 550     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
 551         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) /* FREERTOS_SYSTEM_CALL */
 552         {
 553             configRUN_TIME_COUNTER_TYPE xReturn;
 554
 555             if( portIS_PRIVILEGED() == pdFALSE )
 556             {
 557                 portRAISE_PRIVILEGE();
 558                 portMEMORY_BARRIER();
 559
 560                 xReturn = ulTaskGetIdleRunTimePercent();
 561                 portMEMORY_BARRIER();
 562
 563                 portRESET_PRIVILEGE();
 564                 portMEMORY_BARRIER();
 565             }
 566             else
 567             {
 568                 xReturn = ulTaskGetIdleRunTimePercent();
 569             }
 570
 571             return xReturn;
 572         }
 573     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
 574 /*-----------------------------------------------------------*/
 575
 576     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
 577         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */
 578         {
 579             configRUN_TIME_COUNTER_TYPE xReturn;
 580
 581             if( portIS_PRIVILEGED() == pdFALSE )
 582             {
 583                 portRAISE_PRIVILEGE();
 584                 portMEMORY_BARRIER();
 585
 586                 xReturn = ulTaskGetIdleRunTimeCounter();
 587                 portMEMORY_BARRIER();
 588
 589                 portRESET_PRIVILEGE();
 590                 portMEMORY_BARRIER();
 591             }
 592             else
 593             {
 594                 xReturn = ulTaskGetIdleRunTimeCounter();
 595             }
 596
 597             return xReturn;
 598         }
 599     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
 600 /*-----------------------------------------------------------*/
 601
 602     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 603         void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,
 604                                              TaskHookFunction_t pxTagValue ) /* FREERTOS_SYSTEM_CALL */
 605         {
 606             if( portIS_PRIVILEGED() == pdFALSE )
 607             {
 608                 portRAISE_PRIVILEGE();
 609                 portMEMORY_BARRIER();
 610
 611                 vTaskSetApplicationTaskTag( xTask, pxTagValue );
 612                 portMEMORY_BARRIER();
 613
 614                 portRESET_PRIVILEGE();
 615                 portMEMORY_BARRIER();
 616             }
 617             else
 618             {
 619                 vTaskSetApplicationTaskTag( xTask, pxTagValue );
 620             }
 621         }
 622     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 623 /*-----------------------------------------------------------*/
 624
 625     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 626         TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
 627         {
 628             TaskHookFunction_t xReturn;
 629
 630             if( portIS_PRIVILEGED() == pdFALSE )
 631             {
 632                 portRAISE_PRIVILEGE();
 633                 portMEMORY_BARRIER();
 634
 635                 xReturn = xTaskGetApplicationTaskTag( xTask );
 636                 portMEMORY_BARRIER();
 637
 638                 portRESET_PRIVILEGE();
 639                 portMEMORY_BARRIER();
 640             }
 641             else
 642             {
 643                 xReturn = xTaskGetApplicationTaskTag( xTask );
 644             }
 645
 646             return xReturn;
 647         }
 648     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 649 /*-----------------------------------------------------------*/
 650
 651     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
 652         void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
 653                                                     BaseType_t xIndex,
 654                                                     void * pvValue ) /* FREERTOS_SYSTEM_CALL */
 655         {
 656             if( portIS_PRIVILEGED() == pdFALSE )
 657             {
 658                 portRAISE_PRIVILEGE();
 659                 portMEMORY_BARRIER();
 660
 661                 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
 662                 portMEMORY_BARRIER();
 663
 664                 portRESET_PRIVILEGE();
 665                 portMEMORY_BARRIER();
 666             }
 667             else
 668             {
 669                 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
 670             }
 671         }
 672     #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
 673 /*-----------------------------------------------------------*/
 674
 675     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
 676         void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
 677                                                        BaseType_t xIndex ) /* FREERTOS_SYSTEM_CALL */
 678         {
 679             void * pvReturn;
 680
 681             if( portIS_PRIVILEGED() == pdFALSE )
 682             {
 683                 portRAISE_PRIVILEGE();
 684                 portMEMORY_BARRIER();
 685
 686                 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
 687                 portMEMORY_BARRIER();
 688
 689                 portRESET_PRIVILEGE();
 690                 portMEMORY_BARRIER();
 691             }
 692             else
 693             {
 694                 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
 695             }
 696
 697             return pvReturn;
 698         }
 699     #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
 700 /*-----------------------------------------------------------*/
 701
 702     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 703         BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
 704                                                      void * pvParameter ) /* FREERTOS_SYSTEM_CALL */
 705         {
 706             BaseType_t xReturn;
 707
 708             if( portIS_PRIVILEGED() == pdFALSE )
 709             {
 710                 portRAISE_PRIVILEGE();
 711                 portMEMORY_BARRIER();
 712
 713                 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
 714                 portMEMORY_BARRIER();
 715
 716                 portRESET_PRIVILEGE();
 717                 portMEMORY_BARRIER();
 718             }
 719             else
 720             {
 721                 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
 722             }
 723
 724             return xReturn;
 725         }
 726     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 727 /*-----------------------------------------------------------*/
 728
 729     #if ( configUSE_TRACE_FACILITY == 1 )
 730         UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * pxTaskStatusArray,
 731                                               UBaseType_t uxArraySize,
 732                                               configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) /* FREERTOS_SYSTEM_CALL */
 733         {
 734             UBaseType_t uxReturn;
 735
 736             if( portIS_PRIVILEGED() == pdFALSE )
 737             {
 738                 portRAISE_PRIVILEGE();
 739                 portMEMORY_BARRIER();
 740
 741                 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
 742                 portMEMORY_BARRIER();
 743
 744                 portRESET_PRIVILEGE();
 745                 portMEMORY_BARRIER();
 746             }
 747             else
 748             {
 749                 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
 750             }
 751
 752             return uxReturn;
 753         }
 754     #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
 755 /*-----------------------------------------------------------*/
 756
 757     BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTEM_CALL */
 758     {
 759         BaseType_t xReturn;
 760
 761         if( portIS_PRIVILEGED() == pdFALSE )
 762         {
 763             portRAISE_PRIVILEGE();
 764             portMEMORY_BARRIER();
 765
 766             xReturn = xTaskCatchUpTicks( xTicksToCatchUp );
 767             portMEMORY_BARRIER();
 768
 769             portRESET_PRIVILEGE();
 770             portMEMORY_BARRIER();
 771         }
 772         else
 773         {
 774             xReturn = xTaskCatchUpTicks( xTicksToCatchUp );
 775         }
 776
 777         return xReturn;
 778     }
 779 /*-----------------------------------------------------------*/
 780
 781     #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
 782         UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
 783         {
 784             UBaseType_t uxReturn;
 785
 786             if( portIS_PRIVILEGED() == pdFALSE )
 787             {
 788                 portRAISE_PRIVILEGE();
 789                 portMEMORY_BARRIER();
 790
 791                 uxReturn = uxTaskGetStackHighWaterMark( xTask );
 792                 portMEMORY_BARRIER();
 793
 794                 portRESET_PRIVILEGE();
 795                 portMEMORY_BARRIER();
 796             }
 797             else
 798             {
 799                 uxReturn = uxTaskGetStackHighWaterMark( xTask );
 800             }
 801
 802             return uxReturn;
 803         }
 804     #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */
 805 /*-----------------------------------------------------------*/
 806
 807     #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
 808         configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
 809         {
 810             configSTACK_DEPTH_TYPE uxReturn;
 811
 812             if( portIS_PRIVILEGED() == pdFALSE )
 813             {
 814                 portRAISE_PRIVILEGE();
 815                 portMEMORY_BARRIER();
 816
 817                 uxReturn = uxTaskGetStackHighWaterMark2( xTask );
 818                 portMEMORY_BARRIER();
 819
 820                 portRESET_PRIVILEGE();
 821                 portMEMORY_BARRIER();
 822             }
 823             else
 824             {
 825                 uxReturn = uxTaskGetStackHighWaterMark2( xTask );
 826             }
 827
 828             return uxReturn;
 829         }
 830     #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */
 831 /*-----------------------------------------------------------*/
 832
 833     #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
 834         TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
 835         {
 836             TaskHandle_t xReturn;
 837
 838             if( portIS_PRIVILEGED() == pdFALSE )
 839             {
 840                 portRAISE_PRIVILEGE();
 841                 portMEMORY_BARRIER();
 842                 xReturn = xTaskGetCurrentTaskHandle();
 843                 portMEMORY_BARRIER();
 844
 845                 portRESET_PRIVILEGE();
 846                 portMEMORY_BARRIER();
 847             }
 848             else
 849             {
 850                 xReturn = xTaskGetCurrentTaskHandle();
 851             }
 852
 853             return xReturn;
 854         }
 855     #endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */
 856 /*-----------------------------------------------------------*/
 857
 858     #if ( INCLUDE_xTaskGetSchedulerState == 1 )
 859         BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */
 860         {
 861             BaseType_t xReturn;
 862
 863             if( portIS_PRIVILEGED() == pdFALSE )
 864             {
 865                 portRAISE_PRIVILEGE();
 866                 portMEMORY_BARRIER();
 867
 868                 xReturn = xTaskGetSchedulerState();
 869                 portMEMORY_BARRIER();
 870
 871                 portRESET_PRIVILEGE();
 872                 portMEMORY_BARRIER();
 873             }
 874             else
 875             {
 876                 xReturn = xTaskGetSchedulerState();
 877             }
 878
 879             return xReturn;
 880         }
 881     #endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */
 882 /*-----------------------------------------------------------*/
 883
 884     void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */
 885     {
 886         if( portIS_PRIVILEGED() == pdFALSE )
 887         {
 888             portRAISE_PRIVILEGE();
 889             portMEMORY_BARRIER();
 890
 891             vTaskSetTimeOutState( pxTimeOut );
 892             portMEMORY_BARRIER();
 893
 894             portRESET_PRIVILEGE();
 895             portMEMORY_BARRIER();
 896         }
 897         else
 898         {
 899             vTaskSetTimeOutState( pxTimeOut );
 900         }
 901     }
 902 /*-----------------------------------------------------------*/
 903
 904     BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
 905                                          TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 906     {
 907         BaseType_t xReturn;
 908
 909         if( portIS_PRIVILEGED() == pdFALSE )
 910         {
 911             portRAISE_PRIVILEGE();
 912             portMEMORY_BARRIER();
 913
 914             xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
 915             portMEMORY_BARRIER();
 916
 917             portRESET_PRIVILEGE();
 918             portMEMORY_BARRIER();
 919         }
 920         else
 921         {
 922             xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
 923         }
 924
 925         return xReturn;
 926     }
 927 /*-----------------------------------------------------------*/
 928
 929     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 930         BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,
 931                                            UBaseType_t uxIndexToNotify,
 932                                            uint32_t ulValue,
 933                                            eNotifyAction eAction,
 934                                            uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */
 935         {
 936             BaseType_t xReturn;
 937
 938             if( portIS_PRIVILEGED() == pdFALSE )
 939             {
 940                 portRAISE_PRIVILEGE();
 941                 portMEMORY_BARRIER();
 942
 943                 xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );
 944                 portMEMORY_BARRIER();
 945
 946                 portRESET_PRIVILEGE();
 947                 portMEMORY_BARRIER();
 948             }
 949             else
 950             {
 951                 xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );
 952             }
 953
 954             return xReturn;
 955         }
 956     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 957 /*-----------------------------------------------------------*/
 958
 959     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 960         BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
 961                                                uint32_t ulBitsToClearOnEntry,
 962                                                uint32_t ulBitsToClearOnExit,
 963                                                uint32_t * pulNotificationValue,
 964                                                TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 965         {
 966             BaseType_t xReturn;
 967
 968             if( portIS_PRIVILEGED() == pdFALSE )
 969             {
 970                 portRAISE_PRIVILEGE();
 971                 portMEMORY_BARRIER();
 972
 973                 xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
 974                 portMEMORY_BARRIER();
 975
 976                 portRESET_PRIVILEGE();
 977                 portMEMORY_BARRIER();
 978             }
 979             else
 980             {
 981                 xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
 982             }
 983
 984             return xReturn;
 985         }
 986     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 987 /*-----------------------------------------------------------*/
 988
 989     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 990         uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
 991                                               BaseType_t xClearCountOnExit,
 992                                               TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 993         {
 994             uint32_t ulReturn;
 995
 996             if( portIS_PRIVILEGED() == pdFALSE )
 997             {
 998                 portRAISE_PRIVILEGE();
 999                 portMEMORY_BARRIER();
1000
1001                 ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
1002                 portMEMORY_BARRIER();
1003
1004                 portRESET_PRIVILEGE();
1005                 portMEMORY_BARRIER();
1006             }
1007             else
1008             {
1009                 ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
1010             }
1011
1012             return ulReturn;
1013         }
1014     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1015 /*-----------------------------------------------------------*/
1016
1017     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1018         BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,
1019                                                      UBaseType_t uxIndexToClear ) /* FREERTOS_SYSTEM_CALL */
1020         {
1021             BaseType_t xReturn;
1022
1023             if( portIS_PRIVILEGED() == pdFALSE )
1024             {
1025                 portRAISE_PRIVILEGE();
1026                 portMEMORY_BARRIER();
1027
1028                 xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
1029                 portMEMORY_BARRIER();
1030
1031                 portRESET_PRIVILEGE();
1032                 portMEMORY_BARRIER();
1033             }
1034             else
1035             {
1036                 xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
1037             }
1038
1039             return xReturn;
1040         }
1041     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1042 /*-----------------------------------------------------------*/
1043
1044     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1045         uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
1046                                                     UBaseType_t uxIndexToClear,
1047                                                     uint32_t ulBitsToClear ) /* FREERTOS_SYSTEM_CALL */
1048         {
1049             uint32_t ulReturn;
1050
1051             if( portIS_PRIVILEGED() == pdFALSE )
1052             {
1053                 portRAISE_PRIVILEGE();
1054                 portMEMORY_BARRIER();
1055
1056                 ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
1057                 portMEMORY_BARRIER();
1058
1059                 portRESET_PRIVILEGE();
1060                 portMEMORY_BARRIER();
1061             }
1062             else
1063             {
1064                 ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
1065             }
1066
1067             return ulReturn;
1068         }
1069     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1070 /*-----------------------------------------------------------*/
1071
1072     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
1073         QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength,
1074                                                UBaseType_t uxItemSize,
1075                                                uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
1076         {
1077             QueueHandle_t xReturn;
1078
1079             if( portIS_PRIVILEGED() == pdFALSE )
1080             {
1081                 portRAISE_PRIVILEGE();
1082                 portMEMORY_BARRIER();
1083
1084                 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
1085                 portMEMORY_BARRIER();
1086
1087                 portRESET_PRIVILEGE();
1088                 portMEMORY_BARRIER();
1089             }
1090             else
1091             {
1092                 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
1093             }
1094
1095             return xReturn;
1096         }
1097     #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
1098 /*-----------------------------------------------------------*/
1099
1100     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
1101         QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
1102                                                      const UBaseType_t uxItemSize,
1103                                                      uint8_t * pucQueueStorage,
1104                                                      StaticQueue_t * pxStaticQueue,
1105                                                      const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
1106         {
1107             QueueHandle_t xReturn;
1108
1109             if( portIS_PRIVILEGED() == pdFALSE )
1110             {
1111                 portRAISE_PRIVILEGE();
1112                 portMEMORY_BARRIER();
1113
1114                 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
1115                 portMEMORY_BARRIER();
1116
1117                 portRESET_PRIVILEGE();
1118                 portMEMORY_BARRIER();
1119             }
1120             else
1121             {
1122                 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
1123             }
1124
1125             return xReturn;
1126         }
1127     #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
1128 /*-----------------------------------------------------------*/
1129
1130     BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue,
1131                                        BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */
1132     {
1133         BaseType_t xReturn;
1134
1135         if( portIS_PRIVILEGED() == pdFALSE )
1136         {
1137             portRAISE_PRIVILEGE();
1138             portMEMORY_BARRIER();
1139
1140             xReturn = xQueueGenericReset( pxQueue, xNewQueue );
1141             portMEMORY_BARRIER();
1142
1143             portRESET_PRIVILEGE();
1144             portMEMORY_BARRIER();
1145         }
1146         else
1147         {
1148             xReturn = xQueueGenericReset( pxQueue, xNewQueue );
1149         }
1150
1151         return xReturn;
1152     }
1153 /*-----------------------------------------------------------*/
1154
1155     BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,
1156                                       const void * const pvItemToQueue,
1157                                       TickType_t xTicksToWait,
1158                                       BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */
1159     {
1160         BaseType_t xReturn;
1161
1162         if( portIS_PRIVILEGED() == pdFALSE )
1163         {
1164             portRAISE_PRIVILEGE();
1165             portMEMORY_BARRIER();
1166
1167             xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
1168             portMEMORY_BARRIER();
1169
1170             portRESET_PRIVILEGE();
1171             portMEMORY_BARRIER();
1172         }
1173         else
1174         {
1175             xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
1176         }
1177
1178         return xReturn;
1179     }
1180 /*-----------------------------------------------------------*/
1181
1182     UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */
1183     {
1184         UBaseType_t uxReturn;
1185
1186         if( portIS_PRIVILEGED() == pdFALSE )
1187         {
1188             portRAISE_PRIVILEGE();
1189             portMEMORY_BARRIER();
1190
1191             uxReturn = uxQueueMessagesWaiting( pxQueue );
1192             portMEMORY_BARRIER();
1193
1194             portRESET_PRIVILEGE();
1195             portMEMORY_BARRIER();
1196         }
1197         else
1198         {
1199             uxReturn = uxQueueMessagesWaiting( pxQueue );
1200         }
1201
1202         return uxReturn;
1203     }
1204 /*-----------------------------------------------------------*/
1205
1206     UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1207     {
1208         UBaseType_t uxReturn;
1209
1210         if( portIS_PRIVILEGED() == pdFALSE )
1211         {
1212             portRAISE_PRIVILEGE();
1213             portMEMORY_BARRIER();
1214
1215             uxReturn = uxQueueSpacesAvailable( xQueue );
1216             portMEMORY_BARRIER();
1217
1218             portRESET_PRIVILEGE();
1219             portMEMORY_BARRIER();
1220         }
1221         else
1222         {
1223             uxReturn = uxQueueSpacesAvailable( xQueue );
1224         }
1225
1226         return uxReturn;
1227     }
1228 /*-----------------------------------------------------------*/
1229
1230     BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue,
1231                                   void * const pvBuffer,
1232                                   TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1233     {
1234         BaseType_t xReturn;
1235
1236         if( portIS_PRIVILEGED() == pdFALSE )
1237         {
1238             portRAISE_PRIVILEGE();
1239             portMEMORY_BARRIER();
1240
1241             xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
1242             portMEMORY_BARRIER();
1243
1244             portRESET_PRIVILEGE();
1245             portMEMORY_BARRIER();
1246         }
1247         else
1248         {
1249             xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
1250         }
1251
1252         return xReturn;
1253     }
1254 /*-----------------------------------------------------------*/
1255
1256     BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
1257                                void * const pvBuffer,
1258                                TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1259     {
1260         BaseType_t xReturn;
1261
1262         if( portIS_PRIVILEGED() == pdFALSE )
1263         {
1264             portRAISE_PRIVILEGE();
1265             portMEMORY_BARRIER();
1266
1267             xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
1268             portMEMORY_BARRIER();
1269
1270             portRESET_PRIVILEGE();
1271             portMEMORY_BARRIER();
1272         }
1273         else
1274         {
1275             xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
1276         }
1277
1278         return xReturn;
1279     }
1280 /*-----------------------------------------------------------*/
1281
1282     BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
1283                                         TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1284     {
1285         BaseType_t xReturn;
1286
1287         if( portIS_PRIVILEGED() == pdFALSE )
1288         {
1289             portRAISE_PRIVILEGE();
1290             portMEMORY_BARRIER();
1291
1292             xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
1293             portMEMORY_BARRIER();
1294
1295             portRESET_PRIVILEGE();
1296             portMEMORY_BARRIER();
1297         }
1298         else
1299         {
1300             xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
1301         }
1302
1303         return xReturn;
1304     }
1305 /*-----------------------------------------------------------*/
1306
1307     #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
1308         TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */
1309         {
1310             void * xReturn;
1311
1312             if( portIS_PRIVILEGED() == pdFALSE )
1313             {
1314                 portRAISE_PRIVILEGE();
1315                 portMEMORY_BARRIER();
1316
1317                 xReturn = xQueueGetMutexHolder( xSemaphore );
1318                 portMEMORY_BARRIER();
1319
1320                 portRESET_PRIVILEGE();
1321                 portMEMORY_BARRIER();
1322             }
1323             else
1324             {
1325                 xReturn = xQueueGetMutexHolder( xSemaphore );
1326             }
1327
1328             return xReturn;
1329         }
1330     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
1331 /*-----------------------------------------------------------*/
1332
1333     #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
1334         QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
1335         {
1336             QueueHandle_t xReturn;
1337
1338             if( portIS_PRIVILEGED() == pdFALSE )
1339             {
1340                 portRAISE_PRIVILEGE();
1341                 portMEMORY_BARRIER();
1342
1343                 xReturn = xQueueCreateMutex( ucQueueType );
1344                 portMEMORY_BARRIER();
1345
1346                 portRESET_PRIVILEGE();
1347                 portMEMORY_BARRIER();
1348             }
1349             else
1350             {
1351                 xReturn = xQueueCreateMutex( ucQueueType );
1352             }
1353
1354             return xReturn;
1355         }
1356     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
1357 /*-----------------------------------------------------------*/
1358
1359     #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
1360         QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
1361                                                    StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
1362         {
1363             QueueHandle_t xReturn;
1364
1365             if( portIS_PRIVILEGED() == pdFALSE )
1366             {
1367                 portRAISE_PRIVILEGE();
1368                 portMEMORY_BARRIER();
1369
1370                 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
1371                 portMEMORY_BARRIER();
1372
1373                 portRESET_PRIVILEGE();
1374                 portMEMORY_BARRIER();
1375             }
1376             else
1377             {
1378                 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
1379             }
1380
1381             return xReturn;
1382         }
1383     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
1384 /*-----------------------------------------------------------*/
1385
1386     #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
1387         QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue,
1388                                                          UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */
1389         {
1390             QueueHandle_t xReturn;
1391
1392             if( portIS_PRIVILEGED() == pdFALSE )
1393             {
1394                 portRAISE_PRIVILEGE();
1395                 portMEMORY_BARRIER();
1396
1397                 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
1398                 portMEMORY_BARRIER();
1399
1400                 portRESET_PRIVILEGE();
1401                 portMEMORY_BARRIER();
1402             }
1403             else
1404             {
1405                 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
1406             }
1407
1408             return xReturn;
1409         }
1410     #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
1411 /*-----------------------------------------------------------*/
1412
1413     #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
1414
1415         QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
1416                                                                const UBaseType_t uxInitialCount,
1417                                                                StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
1418         {
1419             QueueHandle_t xReturn;
1420
1421             if( portIS_PRIVILEGED() == pdFALSE )
1422             {
1423                 portRAISE_PRIVILEGE();
1424                 portMEMORY_BARRIER();
1425
1426                 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
1427                 portMEMORY_BARRIER();
1428
1429                 portRESET_PRIVILEGE();
1430                 portMEMORY_BARRIER();
1431             }
1432             else
1433             {
1434                 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
1435             }
1436
1437             return xReturn;
1438         }
1439     #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
1440 /*-----------------------------------------------------------*/
1441
1442     #if ( configUSE_RECURSIVE_MUTEXES == 1 )
1443         BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,
1444                                                  TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */
1445         {
1446             BaseType_t xReturn;
1447
1448             if( portIS_PRIVILEGED() == pdFALSE )
1449             {
1450                 portRAISE_PRIVILEGE();
1451                 portMEMORY_BARRIER();
1452
1453                 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
1454                 portMEMORY_BARRIER();
1455
1456                 portRESET_PRIVILEGE();
1457                 portMEMORY_BARRIER();
1458             }
1459             else
1460             {
1461                 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
1462             }
1463
1464             return xReturn;
1465         }
1466     #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
1467 /*-----------------------------------------------------------*/
1468
1469     #if ( configUSE_RECURSIVE_MUTEXES == 1 )
1470         BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */
1471         {
1472             BaseType_t xReturn;
1473
1474             if( portIS_PRIVILEGED() == pdFALSE )
1475             {
1476                 portRAISE_PRIVILEGE();
1477                 portMEMORY_BARRIER();
1478
1479                 xReturn = xQueueGiveMutexRecursive( xMutex );
1480                 portMEMORY_BARRIER();
1481
1482                 portRESET_PRIVILEGE();
1483                 portMEMORY_BARRIER();
1484             }
1485             else
1486             {
1487                 xReturn = xQueueGiveMutexRecursive( xMutex );
1488             }
1489
1490             return xReturn;
1491         }
1492     #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
1493 /*-----------------------------------------------------------*/
1494
1495     #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
1496         QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */
1497         {
1498             QueueSetHandle_t xReturn;
1499
1500             if( portIS_PRIVILEGED() == pdFALSE )
1501             {
1502                 portRAISE_PRIVILEGE();
1503                 portMEMORY_BARRIER();
1504
1505                 xReturn = xQueueCreateSet( uxEventQueueLength );
1506                 portMEMORY_BARRIER();
1507
1508                 portRESET_PRIVILEGE();
1509                 portMEMORY_BARRIER();
1510             }
1511             else
1512             {
1513                 xReturn = xQueueCreateSet( uxEventQueueLength );
1514             }
1515
1516             return xReturn;
1517         }
1518     #endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
1519 /*-----------------------------------------------------------*/
1520
1521     #if ( configUSE_QUEUE_SETS == 1 )
1522         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
1523                                                         TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */
1524         {
1525             QueueSetMemberHandle_t xReturn;
1526
1527             if( portIS_PRIVILEGED() == pdFALSE )
1528             {
1529                 portRAISE_PRIVILEGE();
1530                 portMEMORY_BARRIER();
1531
1532                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
1533                 portMEMORY_BARRIER();
1534
1535                 portRESET_PRIVILEGE();
1536                 portMEMORY_BARRIER();
1537             }
1538             else
1539             {
1540                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
1541             }
1542
1543             return xReturn;
1544         }
1545     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1546 /*-----------------------------------------------------------*/
1547
1548     #if ( configUSE_QUEUE_SETS == 1 )
1549         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
1550                                        QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
1551         {
1552             BaseType_t xReturn;
1553
1554             if( portIS_PRIVILEGED() == pdFALSE )
1555             {
1556                 portRAISE_PRIVILEGE();
1557                 portMEMORY_BARRIER();
1558
1559                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
1560                 portMEMORY_BARRIER();
1561
1562                 portRESET_PRIVILEGE();
1563                 portMEMORY_BARRIER();
1564             }
1565             else
1566             {
1567                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
1568             }
1569
1570             return xReturn;
1571         }
1572     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1573 /*-----------------------------------------------------------*/
1574
1575     #if ( configUSE_QUEUE_SETS == 1 )
1576         BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
1577                                             QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
1578         {
1579             BaseType_t xReturn;
1580
1581             if( portIS_PRIVILEGED() == pdFALSE )
1582             {
1583                 portRAISE_PRIVILEGE();
1584                 portMEMORY_BARRIER();
1585
1586                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
1587                 portMEMORY_BARRIER();
1588
1589                 portRESET_PRIVILEGE();
1590                 portMEMORY_BARRIER();
1591             }
1592             else
1593             {
1594                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
1595             }
1596
1597             return xReturn;
1598         }
1599     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1600 /*-----------------------------------------------------------*/
1601
1602     #if configQUEUE_REGISTRY_SIZE > 0
1603         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
1604                                       const char * pcName ) /* FREERTOS_SYSTEM_CALL */
1605         {
1606             if( portIS_PRIVILEGED() == pdFALSE )
1607             {
1608                 portRAISE_PRIVILEGE();
1609                 portMEMORY_BARRIER();
1610
1611                 vQueueAddToRegistry( xQueue, pcName );
1612                 portMEMORY_BARRIER();
1613
1614                 portRESET_PRIVILEGE();
1615                 portMEMORY_BARRIER();
1616             }
1617             else
1618             {
1619                 vQueueAddToRegistry( xQueue, pcName );
1620             }
1621         }
1622     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1623 /*-----------------------------------------------------------*/
1624
1625     #if configQUEUE_REGISTRY_SIZE > 0
1626         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1627         {
1628             if( portIS_PRIVILEGED() == pdFALSE )
1629             {
1630                 portRAISE_PRIVILEGE();
1631                 portMEMORY_BARRIER();
1632
1633                 vQueueUnregisterQueue( xQueue );
1634                 portMEMORY_BARRIER();
1635
1636                 portRESET_PRIVILEGE();
1637                 portMEMORY_BARRIER();
1638             }
1639             else
1640             {
1641                 vQueueUnregisterQueue( xQueue );
1642             }
1643         }
1644     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1645 /*-----------------------------------------------------------*/
1646
1647     #if configQUEUE_REGISTRY_SIZE > 0
1648         const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1649         {
1650             const char * pcReturn;
1651
1652             if( portIS_PRIVILEGED() == pdFALSE )
1653             {
1654                 portRAISE_PRIVILEGE();
1655                 portMEMORY_BARRIER();
1656
1657                 pcReturn = pcQueueGetName( xQueue );
1658                 portMEMORY_BARRIER();
1659
1660                 portRESET_PRIVILEGE();
1661                 portMEMORY_BARRIER();
1662             }
1663             else
1664             {
1665                 pcReturn = pcQueueGetName( xQueue );
1666             }
1667
1668             return pcReturn;
1669         }
1670     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1671 /*-----------------------------------------------------------*/
1672
1673     void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1674     {
1675         if( portIS_PRIVILEGED() == pdFALSE )
1676         {
1677             portRAISE_PRIVILEGE();
1678             portMEMORY_BARRIER();
1679
1680             vQueueDelete( xQueue );
1681             portMEMORY_BARRIER();
1682
1683             portRESET_PRIVILEGE();
1684             portMEMORY_BARRIER();
1685         }
1686         else
1687         {
1688             vQueueDelete( xQueue );
1689         }
1690     }
1691 /*-----------------------------------------------------------*/
1692
1693     #if ( configUSE_TIMERS == 1 )
1694         void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1695         {
1696             void * pvReturn;
1697
1698             if( portIS_PRIVILEGED() == pdFALSE )
1699             {
1700                 portRAISE_PRIVILEGE();
1701                 portMEMORY_BARRIER();
1702
1703                 pvReturn = pvTimerGetTimerID( xTimer );
1704                 portMEMORY_BARRIER();
1705
1706                 portRESET_PRIVILEGE();
1707                 portMEMORY_BARRIER();
1708             }
1709             else
1710             {
1711                 pvReturn = pvTimerGetTimerID( xTimer );
1712             }
1713
1714             return pvReturn;
1715         }
1716     #endif /* if ( configUSE_TIMERS == 1 ) */
1717 /*-----------------------------------------------------------*/
1718
1719     #if ( configUSE_TIMERS == 1 )
1720         void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
1721                                    void * pvNewID ) /* FREERTOS_SYSTEM_CALL */
1722         {
1723             if( portIS_PRIVILEGED() == pdFALSE )
1724             {
1725                 portRAISE_PRIVILEGE();
1726                 portMEMORY_BARRIER();
1727
1728                 vTimerSetTimerID( xTimer, pvNewID );
1729                 portMEMORY_BARRIER();
1730
1731                 portRESET_PRIVILEGE();
1732                 portMEMORY_BARRIER();
1733             }
1734             else
1735             {
1736                 vTimerSetTimerID( xTimer, pvNewID );
1737             }
1738         }
1739     #endif /* if ( configUSE_TIMERS == 1 ) */
1740 /*-----------------------------------------------------------*/
1741
1742     #if ( configUSE_TIMERS == 1 )
1743         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1744         {
1745             BaseType_t xReturn;
1746
1747             if( portIS_PRIVILEGED() == pdFALSE )
1748             {
1749                 portRAISE_PRIVILEGE();
1750                 portMEMORY_BARRIER();
1751
1752                 xReturn = xTimerIsTimerActive( xTimer );
1753                 portMEMORY_BARRIER();
1754
1755                 portRESET_PRIVILEGE();
1756                 portMEMORY_BARRIER();
1757             }
1758             else
1759             {
1760                 xReturn = xTimerIsTimerActive( xTimer );
1761             }
1762
1763             return xReturn;
1764         }
1765     #endif /* if ( configUSE_TIMERS == 1 ) */
1766 /*-----------------------------------------------------------*/
1767
1768     #if ( configUSE_TIMERS == 1 )
1769         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
1770         {
1771             TaskHandle_t xReturn;
1772
1773             if( portIS_PRIVILEGED() == pdFALSE )
1774             {
1775                 portRAISE_PRIVILEGE();
1776                 portMEMORY_BARRIER();
1777
1778                 xReturn = xTimerGetTimerDaemonTaskHandle();
1779                 portMEMORY_BARRIER();
1780
1781                 portRESET_PRIVILEGE();
1782                 portMEMORY_BARRIER();
1783             }
1784             else
1785             {
1786                 xReturn = xTimerGetTimerDaemonTaskHandle();
1787             }
1788
1789             return xReturn;
1790         }
1791     #endif /* if ( configUSE_TIMERS == 1 ) */
1792 /*-----------------------------------------------------------*/
1793
1794     #if ( configUSE_TIMERS == 1 )
1795         void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
1796                                       const UBaseType_t uxAutoReload ) /* FREERTOS_SYSTEM_CALL */
1797         {
1798             if( portIS_PRIVILEGED() == pdFALSE )
1799             {
1800                 portRAISE_PRIVILEGE();
1801                 portMEMORY_BARRIER();
1802
1803                 vTimerSetReloadMode( xTimer, uxAutoReload );
1804                 portMEMORY_BARRIER();
1805
1806                 portRESET_PRIVILEGE();
1807                 portMEMORY_BARRIER();
1808             }
1809             else
1810             {
1811                 vTimerSetReloadMode( xTimer, uxAutoReload );
1812             }
1813         }
1814     #endif /* if ( configUSE_TIMERS == 1 ) */
1815 /*-----------------------------------------------------------*/
1816
1817     #if ( configUSE_TIMERS == 1 )
1818         UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer )
1819         {
1820             UBaseType_t uxReturn;
1821
1822             if( portIS_PRIVILEGED() == pdFALSE )
1823             {
1824                 portRAISE_PRIVILEGE();
1825                 portMEMORY_BARRIER();
1826
1827                 uxReturn = uxTimerGetReloadMode( xTimer );
1828                 portMEMORY_BARRIER();
1829
1830                 portRESET_PRIVILEGE();
1831                 portMEMORY_BARRIER();
1832             }
1833             else
1834             {
1835                 uxReturn = uxTimerGetReloadMode( xTimer );
1836             }
1837
1838             return uxReturn;
1839         }
1840     #endif /* if ( configUSE_TIMERS == 1 ) */
1841 /*-----------------------------------------------------------*/
1842
1843     #if ( configUSE_TIMERS == 1 )
1844         const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1845         {
1846             const char * pcReturn;
1847
1848             if( portIS_PRIVILEGED() == pdFALSE )
1849             {
1850                 portRAISE_PRIVILEGE();
1851                 portMEMORY_BARRIER();
1852
1853                 pcReturn = pcTimerGetName( xTimer );
1854                 portMEMORY_BARRIER();
1855
1856                 portRESET_PRIVILEGE();
1857                 portMEMORY_BARRIER();
1858             }
1859             else
1860             {
1861                 pcReturn = pcTimerGetName( xTimer );
1862             }
1863
1864             return pcReturn;
1865         }
1866     #endif /* if ( configUSE_TIMERS == 1 ) */
1867 /*-----------------------------------------------------------*/
1868
1869     #if ( configUSE_TIMERS == 1 )
1870         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1871         {
1872             TickType_t xReturn;
1873
1874             if( portIS_PRIVILEGED() == pdFALSE )
1875             {
1876                 portRAISE_PRIVILEGE();
1877                 portMEMORY_BARRIER();
1878
1879                 xReturn = xTimerGetPeriod( xTimer );
1880                 portMEMORY_BARRIER();
1881
1882                 portRESET_PRIVILEGE();
1883                 portMEMORY_BARRIER();
1884             }
1885             else
1886             {
1887                 xReturn = xTimerGetPeriod( xTimer );
1888             }
1889
1890             return xReturn;
1891         }
1892     #endif /* if ( configUSE_TIMERS == 1 ) */
1893 /*-----------------------------------------------------------*/
1894
1895     #if ( configUSE_TIMERS == 1 )
1896         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1897         {
1898             TickType_t xReturn;
1899
1900             if( portIS_PRIVILEGED() == pdFALSE )
1901             {
1902                 portRAISE_PRIVILEGE();
1903                 portMEMORY_BARRIER();
1904
1905                 xReturn = xTimerGetExpiryTime( xTimer );
1906                 portMEMORY_BARRIER();
1907
1908                 portRESET_PRIVILEGE();
1909                 portMEMORY_BARRIER();
1910             }
1911             else
1912             {
1913                 xReturn = xTimerGetExpiryTime( xTimer );
1914             }
1915
1916             return xReturn;
1917         }
1918     #endif /* if ( configUSE_TIMERS == 1 ) */
1919 /*-----------------------------------------------------------*/
1920
1921     #if ( configUSE_TIMERS == 1 )
1922         BaseType_t MPU_xTimerGenericCommandFromTask( TimerHandle_t xTimer,
1923                                                      const BaseType_t xCommandID,
1924                                                      const TickType_t xOptionalValue,
1925                                                      BaseType_t * const pxHigherPriorityTaskWoken,
1926                                                      const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1927         {
1928             BaseType_t xReturn;
1929
1930             if( portIS_PRIVILEGED() == pdFALSE )
1931             {
1932                 portRAISE_PRIVILEGE();
1933                 portMEMORY_BARRIER();
1934
1935                 xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
1936                 portMEMORY_BARRIER();
1937
1938                 portRESET_PRIVILEGE();
1939                 portMEMORY_BARRIER();
1940             }
1941             else
1942             {
1943                 xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
1944             }
1945
1946             return xReturn;
1947         }
1948     #endif /* if ( configUSE_TIMERS == 1 ) */
1949 /*-----------------------------------------------------------*/
1950
1951     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
1952         EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */
1953         {
1954             EventGroupHandle_t xReturn;
1955
1956             if( portIS_PRIVILEGED() == pdFALSE )
1957             {
1958                 portRAISE_PRIVILEGE();
1959                 portMEMORY_BARRIER();
1960
1961                 xReturn = xEventGroupCreate();
1962                 portMEMORY_BARRIER();
1963
1964                 portRESET_PRIVILEGE();
1965                 portMEMORY_BARRIER();
1966             }
1967             else
1968             {
1969                 xReturn = xEventGroupCreate();
1970             }
1971
1972             return xReturn;
1973         }
1974     #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
1975 /*-----------------------------------------------------------*/
1976
1977     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
1978         EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */
1979         {
1980             EventGroupHandle_t xReturn;
1981
1982             if( portIS_PRIVILEGED() == pdFALSE )
1983             {
1984                 portRAISE_PRIVILEGE();
1985                 portMEMORY_BARRIER();
1986
1987                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
1988                 portMEMORY_BARRIER();
1989
1990                 portRESET_PRIVILEGE();
1991                 portMEMORY_BARRIER();
1992             }
1993             else
1994             {
1995                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
1996             }
1997
1998             return xReturn;
1999         }
2000     #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
2001 /*-----------------------------------------------------------*/
2002
2003     EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
2004                                          const EventBits_t uxBitsToWaitFor,
2005                                          const BaseType_t xClearOnExit,
2006                                          const BaseType_t xWaitForAllBits,
2007                                          TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2008     {
2009         EventBits_t xReturn;
2010
2011         if( portIS_PRIVILEGED() == pdFALSE )
2012         {
2013             portRAISE_PRIVILEGE();
2014             portMEMORY_BARRIER();
2015
2016             xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
2017             portMEMORY_BARRIER();
2018
2019             portRESET_PRIVILEGE();
2020             portMEMORY_BARRIER();
2021         }
2022         else
2023         {
2024             xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
2025         }
2026
2027         return xReturn;
2028     }
2029 /*-----------------------------------------------------------*/
2030
2031     EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
2032                                           const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */
2033     {
2034         EventBits_t xReturn;
2035
2036         if( portIS_PRIVILEGED() == pdFALSE )
2037         {
2038             portRAISE_PRIVILEGE();
2039             portMEMORY_BARRIER();
2040
2041             xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
2042             portMEMORY_BARRIER();
2043
2044             portRESET_PRIVILEGE();
2045             portMEMORY_BARRIER();
2046         }
2047         else
2048         {
2049             xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
2050         }
2051
2052         return xReturn;
2053     }
2054 /*-----------------------------------------------------------*/
2055
2056     EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
2057                                         const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */
2058     {
2059         EventBits_t xReturn;
2060
2061         if( portIS_PRIVILEGED() == pdFALSE )
2062         {
2063             portRAISE_PRIVILEGE();
2064             portMEMORY_BARRIER();
2065
2066             xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
2067             portMEMORY_BARRIER();
2068
2069             portRESET_PRIVILEGE();
2070             portMEMORY_BARRIER();
2071         }
2072         else
2073         {
2074             xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
2075         }
2076
2077         return xReturn;
2078     }
2079 /*-----------------------------------------------------------*/
2080
2081     EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
2082                                      const EventBits_t uxBitsToSet,
2083                                      const EventBits_t uxBitsToWaitFor,
2084                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2085     {
2086         EventBits_t xReturn;
2087
2088         if( portIS_PRIVILEGED() == pdFALSE )
2089         {
2090             portRAISE_PRIVILEGE();
2091             portMEMORY_BARRIER();
2092
2093             xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
2094             portMEMORY_BARRIER();
2095
2096             portRESET_PRIVILEGE();
2097             portMEMORY_BARRIER();
2098         }
2099         else
2100         {
2101             xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
2102         }
2103
2104         return xReturn;
2105     }
2106 /*-----------------------------------------------------------*/
2107
2108     void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */
2109     {
2110         if( portIS_PRIVILEGED() == pdFALSE )
2111         {
2112             portRAISE_PRIVILEGE();
2113             portMEMORY_BARRIER();
2114
2115             vEventGroupDelete( xEventGroup );
2116             portMEMORY_BARRIER();
2117
2118             portRESET_PRIVILEGE();
2119             portMEMORY_BARRIER();
2120         }
2121         else
2122         {
2123             vEventGroupDelete( xEventGroup );
2124         }
2125     }
2126 /*-----------------------------------------------------------*/
2127
2128     size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
2129                                   const void * pvTxData,
2130                                   size_t xDataLengthBytes,
2131                                   TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2132     {
2133         size_t xReturn;
2134
2135         if( portIS_PRIVILEGED() == pdFALSE )
2136         {
2137             portRAISE_PRIVILEGE();
2138             portMEMORY_BARRIER();
2139
2140             xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
2141             portMEMORY_BARRIER();
2142
2143             portRESET_PRIVILEGE();
2144             portMEMORY_BARRIER();
2145         }
2146         else
2147         {
2148             xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
2149         }
2150
2151         return xReturn;
2152     }
2153 /*-----------------------------------------------------------*/
2154
2155     size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2156     {
2157         size_t xReturn;
2158
2159         if( portIS_PRIVILEGED() == pdFALSE )
2160         {
2161             portRAISE_PRIVILEGE();
2162             portMEMORY_BARRIER();
2163
2164             xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
2165             portMEMORY_BARRIER();
2166
2167             portRESET_PRIVILEGE();
2168             portMEMORY_BARRIER();
2169         }
2170         else
2171         {
2172             xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
2173         }
2174
2175         return xReturn;
2176     }
2177 /*-----------------------------------------------------------*/
2178
2179     size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
2180                                      void * pvRxData,
2181                                      size_t xBufferLengthBytes,
2182                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2183     {
2184         size_t xReturn;
2185
2186         if( portIS_PRIVILEGED() == pdFALSE )
2187         {
2188             portRAISE_PRIVILEGE();
2189             portMEMORY_BARRIER();
2190
2191             xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
2192             portMEMORY_BARRIER();
2193
2194             portRESET_PRIVILEGE();
2195             portMEMORY_BARRIER();
2196         }
2197         else
2198         {
2199             xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
2200         }
2201
2202         return xReturn;
2203     }
2204 /*-----------------------------------------------------------*/
2205
2206     void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2207     {
2208         if( portIS_PRIVILEGED() == pdFALSE )
2209         {
2210             portRAISE_PRIVILEGE();
2211             portMEMORY_BARRIER();
2212
2213             vStreamBufferDelete( xStreamBuffer );
2214             portMEMORY_BARRIER();
2215
2216             portRESET_PRIVILEGE();
2217             portMEMORY_BARRIER();
2218         }
2219         else
2220         {
2221             vStreamBufferDelete( xStreamBuffer );
2222         }
2223     }
2224 /*-----------------------------------------------------------*/
2225
2226     BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2227     {
2228         BaseType_t xReturn;
2229
2230         if( portIS_PRIVILEGED() == pdFALSE )
2231         {
2232             portRAISE_PRIVILEGE();
2233             portMEMORY_BARRIER();
2234
2235             xReturn = xStreamBufferIsFull( xStreamBuffer );
2236             portMEMORY_BARRIER();
2237
2238             portRESET_PRIVILEGE();
2239             portMEMORY_BARRIER();
2240         }
2241         else
2242         {
2243             xReturn = xStreamBufferIsFull( xStreamBuffer );
2244         }
2245
2246         return xReturn;
2247     }
2248 /*-----------------------------------------------------------*/
2249
2250     BaseType_t MPU_xStreamBufferIsEmpty( 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 = xStreamBufferIsEmpty( xStreamBuffer );
2260             portMEMORY_BARRIER();
2261
2262             portRESET_PRIVILEGE();
2263             portMEMORY_BARRIER();
2264         }
2265         else
2266         {
2267             xReturn = xStreamBufferIsEmpty( xStreamBuffer );
2268         }
2269
2270         return xReturn;
2271     }
2272 /*-----------------------------------------------------------*/
2273
2274     BaseType_t MPU_xStreamBufferReset( 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 = xStreamBufferReset( xStreamBuffer );
2284             portMEMORY_BARRIER();
2285
2286             portRESET_PRIVILEGE();
2287             portMEMORY_BARRIER();
2288         }
2289         else
2290         {
2291             xReturn = xStreamBufferReset( xStreamBuffer );
2292         }
2293
2294         return xReturn;
2295     }
2296 /*-----------------------------------------------------------*/
2297
2298     size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2299     {
2300         size_t xReturn;
2301
2302         if( portIS_PRIVILEGED() == pdFALSE )
2303         {
2304             portRAISE_PRIVILEGE();
2305             portMEMORY_BARRIER();
2306             xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
2307             portMEMORY_BARRIER();
2308
2309             portRESET_PRIVILEGE();
2310             portMEMORY_BARRIER();
2311         }
2312         else
2313         {
2314             xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
2315         }
2316
2317         return xReturn;
2318     }
2319 /*-----------------------------------------------------------*/
2320
2321     size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2322     {
2323         size_t xReturn;
2324
2325         if( portIS_PRIVILEGED() == pdFALSE )
2326         {
2327             portRAISE_PRIVILEGE();
2328             portMEMORY_BARRIER();
2329
2330             xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
2331             portMEMORY_BARRIER();
2332
2333             portRESET_PRIVILEGE();
2334             portMEMORY_BARRIER();
2335         }
2336         else
2337         {
2338             xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
2339         }
2340
2341         return xReturn;
2342     }
2343 /*-----------------------------------------------------------*/
2344
2345     BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
2346                                                  size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */
2347     {
2348         BaseType_t xReturn;
2349
2350         if( portIS_PRIVILEGED() == pdFALSE )
2351         {
2352             portRAISE_PRIVILEGE();
2353             portMEMORY_BARRIER();
2354
2355             xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
2356             portMEMORY_BARRIER();
2357
2358             portRESET_PRIVILEGE();
2359             portMEMORY_BARRIER();
2360         }
2361         else
2362         {
2363             xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
2364         }
2365
2366         return xReturn;
2367     }
2368 /*-----------------------------------------------------------*/
2369
2370     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
2371         StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
2372                                                              size_t xTriggerLevelBytes,
2373                                                              BaseType_t xIsMessageBuffer,
2374                                                              StreamBufferCallbackFunction_t pxSendCompletedCallback,
2375                                                              StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */
2376         {
2377             StreamBufferHandle_t xReturn;
2378
2379             /**
2380              * Streambuffer application level callback functionality is disabled for MPU
2381              * enabled ports.
2382              */
2383             configASSERT( ( pxSendCompletedCallback == NULL ) &&
2384                           ( pxReceiveCompletedCallback == NULL ) );
2385
2386             if( ( pxSendCompletedCallback == NULL ) &&
2387                 ( pxReceiveCompletedCallback == NULL ) )
2388             {
2389                 if( portIS_PRIVILEGED() == pdFALSE )
2390                 {
2391                     portRAISE_PRIVILEGE();
2392                     portMEMORY_BARRIER();
2393
2394                     xReturn = xStreamBufferGenericCreate( xBufferSizeBytes,
2395                                                           xTriggerLevelBytes,
2396                                                           xIsMessageBuffer,
2397                                                           NULL,
2398                                                           NULL );
2399                     portMEMORY_BARRIER();
2400
2401                     portRESET_PRIVILEGE();
2402                     portMEMORY_BARRIER();
2403                 }
2404                 else
2405                 {
2406                     xReturn = xStreamBufferGenericCreate( xBufferSizeBytes,
2407                                                           xTriggerLevelBytes,
2408                                                           xIsMessageBuffer,
2409                                                           NULL,
2410                                                           NULL );
2411                 }
2412             }
2413             else
2414             {
2415                 traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer );
2416                 xReturn = NULL;
2417             }
2418
2419             return xReturn;
2420         }
2421     #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
2422 /*-----------------------------------------------------------*/
2423
2424     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
2425         StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
2426                                                                    size_t xTriggerLevelBytes,
2427                                                                    BaseType_t xIsMessageBuffer,
2428                                                                    uint8_t * const pucStreamBufferStorageArea,
2429                                                                    StaticStreamBuffer_t * const pxStaticStreamBuffer,
2430                                                                    StreamBufferCallbackFunction_t pxSendCompletedCallback,
2431                                                                    StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */
2432         {
2433             StreamBufferHandle_t xReturn;
2434
2435             /**
2436              * Streambuffer application level callback functionality is disabled for MPU
2437              * enabled ports.
2438              */
2439             configASSERT( ( pxSendCompletedCallback == NULL ) &&
2440                           ( pxReceiveCompletedCallback == NULL ) );
2441
2442             if( ( pxSendCompletedCallback == NULL ) &&
2443                 ( pxReceiveCompletedCallback == NULL ) )
2444             {
2445                 if( portIS_PRIVILEGED() == pdFALSE )
2446                 {
2447                     portRAISE_PRIVILEGE();
2448                     portMEMORY_BARRIER();
2449
2450                     xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
2451                                                                 xTriggerLevelBytes,
2452                                                                 xIsMessageBuffer,
2453                                                                 pucStreamBufferStorageArea,
2454                                                                 pxStaticStreamBuffer,
2455                                                                 NULL,
2456                                                                 NULL );
2457                     portMEMORY_BARRIER();
2458
2459                     portRESET_PRIVILEGE();
2460                     portMEMORY_BARRIER();
2461                 }
2462                 else
2463                 {
2464                     xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
2465                                                                 xTriggerLevelBytes,
2466                                                                 xIsMessageBuffer,
2467                                                                 pucStreamBufferStorageArea,
2468                                                                 pxStaticStreamBuffer,
2469                                                                 NULL,
2470                                                                 NULL );
2471                 }
2472             }
2473             else
2474             {
2475                 traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xIsMessageBuffer );
2476                 xReturn = NULL;
2477             }
2478
2479             return xReturn;
2480         }
2481     #endif /* configSUPPORT_STATIC_ALLOCATION */
2482 /*-----------------------------------------------------------*/
2483
2484
2485 /* Functions that the application writer wants to execute in privileged mode
2486  * can be defined in application_defined_privileged_functions.h.  The functions
2487  * must take the same format as those above whereby the privilege state on exit
2488  * equals the privilege state on entry.  For example:
2489  *
2490  * void MPU_FunctionName( [parameters ] ) FREERTOS_SYSTEM_CALL;
2491  * void MPU_FunctionName( [parameters ] )
2492  * {
2493  *      if( portIS_PRIVILEGED() == pdFALSE )
2494  *      {
2495  *          portRAISE_PRIVILEGE();
2496  *          portMEMORY_BARRIER();
2497  *
2498  *          FunctionName( [parameters ] );
2499  *          portMEMORY_BARRIER();
2500  *
2501  *          portRESET_PRIVILEGE();
2502  *          portMEMORY_BARRIER();
2503  *      }
2504  *      else
2505  *      {
2506  *          FunctionName( [parameters ] );
2507  *      }
2508  * }
2509  */
2510
2511     #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
2512         #include "application_defined_privileged_functions.h"
2513     #endif
2514 /*-----------------------------------------------------------*/
2515
2516 #endif /* #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) ) */
2517 /*-----------------------------------------------------------*/