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

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