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

   1 /*
   2  * FreeRTOS Kernel <DEVELOPMENT BRANCH>
   3  * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   4  *
   5  * SPDX-License-Identifier: MIT
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   8  * this software and associated documentation files (the "Software"), to deal in
   9  * the Software without restriction, including without limitation the rights to
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  11  * the Software, and to permit persons to whom the Software is furnished to do so,
  12  * subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in all
  15  * copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  19  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  20  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * https://www.FreeRTOS.org
  25  * https://github.com/FreeRTOS
  26  *
  27  */
  28
  29 /*
  30  * Implementation of the wrapper functions used to raise the processor privilege
  31  * before calling a standard FreeRTOS API function.
  32  */
  33
  34 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
  35  * all the API functions to use the MPU wrappers.  That should only be done when
  36  * task.h is included from an application file. */
  37 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  38
  39 /* Scheduler includes. */
  40 #include "FreeRTOS.h"
  41 #include "task.h"
  42 #include "queue.h"
  43 #include "timers.h"
  44 #include "event_groups.h"
  45 #include "stream_buffer.h"
  46 #include "mpu_prototypes.h"
  47
  48 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  49 /*-----------------------------------------------------------*/
  50
  51 #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) )
  52
  53     #if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
  54         #error Access control list is not available with this MPU wrapper. Please set configENABLE_ACCESS_CONTROL_LIST to 0.
  55     #endif
  56
  57     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
  58         BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode,
  59                                     const char * const pcName,
  60                                     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 )
1528         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
1529                                                         TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */
1530         {
1531             QueueSetMemberHandle_t xReturn;
1532
1533             if( portIS_PRIVILEGED() == pdFALSE )
1534             {
1535                 portRAISE_PRIVILEGE();
1536                 portMEMORY_BARRIER();
1537
1538                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
1539                 portMEMORY_BARRIER();
1540
1541                 portRESET_PRIVILEGE();
1542                 portMEMORY_BARRIER();
1543             }
1544             else
1545             {
1546                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
1547             }
1548
1549             return xReturn;
1550         }
1551     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1552 /*-----------------------------------------------------------*/
1553
1554     #if ( configUSE_QUEUE_SETS == 1 )
1555         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
1556                                        QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
1557         {
1558             BaseType_t xReturn;
1559
1560             if( portIS_PRIVILEGED() == pdFALSE )
1561             {
1562                 portRAISE_PRIVILEGE();
1563                 portMEMORY_BARRIER();
1564
1565                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
1566                 portMEMORY_BARRIER();
1567
1568                 portRESET_PRIVILEGE();
1569                 portMEMORY_BARRIER();
1570             }
1571             else
1572             {
1573                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
1574             }
1575
1576             return xReturn;
1577         }
1578     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1579 /*-----------------------------------------------------------*/
1580
1581     #if ( configUSE_QUEUE_SETS == 1 )
1582         BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
1583                                             QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
1584         {
1585             BaseType_t xReturn;
1586
1587             if( portIS_PRIVILEGED() == pdFALSE )
1588             {
1589                 portRAISE_PRIVILEGE();
1590                 portMEMORY_BARRIER();
1591
1592                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
1593                 portMEMORY_BARRIER();
1594
1595                 portRESET_PRIVILEGE();
1596                 portMEMORY_BARRIER();
1597             }
1598             else
1599             {
1600                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
1601             }
1602
1603             return xReturn;
1604         }
1605     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
1606 /*-----------------------------------------------------------*/
1607
1608     #if configQUEUE_REGISTRY_SIZE > 0
1609         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
1610                                       const char * pcName ) /* FREERTOS_SYSTEM_CALL */
1611         {
1612             if( portIS_PRIVILEGED() == pdFALSE )
1613             {
1614                 portRAISE_PRIVILEGE();
1615                 portMEMORY_BARRIER();
1616
1617                 vQueueAddToRegistry( xQueue, pcName );
1618                 portMEMORY_BARRIER();
1619
1620                 portRESET_PRIVILEGE();
1621                 portMEMORY_BARRIER();
1622             }
1623             else
1624             {
1625                 vQueueAddToRegistry( xQueue, pcName );
1626             }
1627         }
1628     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1629 /*-----------------------------------------------------------*/
1630
1631     #if configQUEUE_REGISTRY_SIZE > 0
1632         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1633         {
1634             if( portIS_PRIVILEGED() == pdFALSE )
1635             {
1636                 portRAISE_PRIVILEGE();
1637                 portMEMORY_BARRIER();
1638
1639                 vQueueUnregisterQueue( xQueue );
1640                 portMEMORY_BARRIER();
1641
1642                 portRESET_PRIVILEGE();
1643                 portMEMORY_BARRIER();
1644             }
1645             else
1646             {
1647                 vQueueUnregisterQueue( xQueue );
1648             }
1649         }
1650     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1651 /*-----------------------------------------------------------*/
1652
1653     #if configQUEUE_REGISTRY_SIZE > 0
1654         const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1655         {
1656             const char * pcReturn;
1657
1658             if( portIS_PRIVILEGED() == pdFALSE )
1659             {
1660                 portRAISE_PRIVILEGE();
1661                 portMEMORY_BARRIER();
1662
1663                 pcReturn = pcQueueGetName( xQueue );
1664                 portMEMORY_BARRIER();
1665
1666                 portRESET_PRIVILEGE();
1667                 portMEMORY_BARRIER();
1668             }
1669             else
1670             {
1671                 pcReturn = pcQueueGetName( xQueue );
1672             }
1673
1674             return pcReturn;
1675         }
1676     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
1677 /*-----------------------------------------------------------*/
1678
1679     void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
1680     {
1681         if( portIS_PRIVILEGED() == pdFALSE )
1682         {
1683             portRAISE_PRIVILEGE();
1684             portMEMORY_BARRIER();
1685
1686             vQueueDelete( xQueue );
1687             portMEMORY_BARRIER();
1688
1689             portRESET_PRIVILEGE();
1690             portMEMORY_BARRIER();
1691         }
1692         else
1693         {
1694             vQueueDelete( xQueue );
1695         }
1696     }
1697 /*-----------------------------------------------------------*/
1698
1699     #if ( configUSE_TIMERS == 1 )
1700         void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1701         {
1702             void * pvReturn;
1703
1704             if( portIS_PRIVILEGED() == pdFALSE )
1705             {
1706                 portRAISE_PRIVILEGE();
1707                 portMEMORY_BARRIER();
1708
1709                 pvReturn = pvTimerGetTimerID( xTimer );
1710                 portMEMORY_BARRIER();
1711
1712                 portRESET_PRIVILEGE();
1713                 portMEMORY_BARRIER();
1714             }
1715             else
1716             {
1717                 pvReturn = pvTimerGetTimerID( xTimer );
1718             }
1719
1720             return pvReturn;
1721         }
1722     #endif /* if ( configUSE_TIMERS == 1 ) */
1723 /*-----------------------------------------------------------*/
1724
1725     #if ( configUSE_TIMERS == 1 )
1726         void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
1727                                    void * pvNewID ) /* FREERTOS_SYSTEM_CALL */
1728         {
1729             if( portIS_PRIVILEGED() == pdFALSE )
1730             {
1731                 portRAISE_PRIVILEGE();
1732                 portMEMORY_BARRIER();
1733
1734                 vTimerSetTimerID( xTimer, pvNewID );
1735                 portMEMORY_BARRIER();
1736
1737                 portRESET_PRIVILEGE();
1738                 portMEMORY_BARRIER();
1739             }
1740             else
1741             {
1742                 vTimerSetTimerID( xTimer, pvNewID );
1743             }
1744         }
1745     #endif /* if ( configUSE_TIMERS == 1 ) */
1746 /*-----------------------------------------------------------*/
1747
1748     #if ( configUSE_TIMERS == 1 )
1749         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1750         {
1751             BaseType_t xReturn;
1752
1753             if( portIS_PRIVILEGED() == pdFALSE )
1754             {
1755                 portRAISE_PRIVILEGE();
1756                 portMEMORY_BARRIER();
1757
1758                 xReturn = xTimerIsTimerActive( xTimer );
1759                 portMEMORY_BARRIER();
1760
1761                 portRESET_PRIVILEGE();
1762                 portMEMORY_BARRIER();
1763             }
1764             else
1765             {
1766                 xReturn = xTimerIsTimerActive( xTimer );
1767             }
1768
1769             return xReturn;
1770         }
1771     #endif /* if ( configUSE_TIMERS == 1 ) */
1772 /*-----------------------------------------------------------*/
1773
1774     #if ( configUSE_TIMERS == 1 )
1775         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
1776         {
1777             TaskHandle_t xReturn;
1778
1779             if( portIS_PRIVILEGED() == pdFALSE )
1780             {
1781                 portRAISE_PRIVILEGE();
1782                 portMEMORY_BARRIER();
1783
1784                 xReturn = xTimerGetTimerDaemonTaskHandle();
1785                 portMEMORY_BARRIER();
1786
1787                 portRESET_PRIVILEGE();
1788                 portMEMORY_BARRIER();
1789             }
1790             else
1791             {
1792                 xReturn = xTimerGetTimerDaemonTaskHandle();
1793             }
1794
1795             return xReturn;
1796         }
1797     #endif /* if ( configUSE_TIMERS == 1 ) */
1798 /*-----------------------------------------------------------*/
1799
1800     #if ( configUSE_TIMERS == 1 )
1801         void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
1802                                       const BaseType_t xAutoReload ) /* FREERTOS_SYSTEM_CALL */
1803         {
1804             if( portIS_PRIVILEGED() == pdFALSE )
1805             {
1806                 portRAISE_PRIVILEGE();
1807                 portMEMORY_BARRIER();
1808
1809                 vTimerSetReloadMode( xTimer, uxAutoReload );
1810                 portMEMORY_BARRIER();
1811
1812                 portRESET_PRIVILEGE();
1813                 portMEMORY_BARRIER();
1814             }
1815             else
1816             {
1817                 vTimerSetReloadMode( xTimer, uxAutoReload );
1818             }
1819         }
1820     #endif /* if ( configUSE_TIMERS == 1 ) */
1821 /*-----------------------------------------------------------*/
1822
1823     #if ( configUSE_TIMERS == 1 )
1824         UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer )
1825         {
1826             UBaseType_t uxReturn;
1827
1828             if( portIS_PRIVILEGED() == pdFALSE )
1829             {
1830                 portRAISE_PRIVILEGE();
1831                 portMEMORY_BARRIER();
1832
1833                 uxReturn = uxTimerGetReloadMode( xTimer );
1834                 portMEMORY_BARRIER();
1835
1836                 portRESET_PRIVILEGE();
1837                 portMEMORY_BARRIER();
1838             }
1839             else
1840             {
1841                 uxReturn = uxTimerGetReloadMode( xTimer );
1842             }
1843
1844             return uxReturn;
1845         }
1846     #endif /* if ( configUSE_TIMERS == 1 ) */
1847 /*-----------------------------------------------------------*/
1848
1849     #if ( configUSE_TIMERS == 1 )
1850         const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1851         {
1852             const char * pcReturn;
1853
1854             if( portIS_PRIVILEGED() == pdFALSE )
1855             {
1856                 portRAISE_PRIVILEGE();
1857                 portMEMORY_BARRIER();
1858
1859                 pcReturn = pcTimerGetName( xTimer );
1860                 portMEMORY_BARRIER();
1861
1862                 portRESET_PRIVILEGE();
1863                 portMEMORY_BARRIER();
1864             }
1865             else
1866             {
1867                 pcReturn = pcTimerGetName( xTimer );
1868             }
1869
1870             return pcReturn;
1871         }
1872     #endif /* if ( configUSE_TIMERS == 1 ) */
1873 /*-----------------------------------------------------------*/
1874
1875     #if ( configUSE_TIMERS == 1 )
1876         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1877         {
1878             TickType_t xReturn;
1879
1880             if( portIS_PRIVILEGED() == pdFALSE )
1881             {
1882                 portRAISE_PRIVILEGE();
1883                 portMEMORY_BARRIER();
1884
1885                 xReturn = xTimerGetPeriod( xTimer );
1886                 portMEMORY_BARRIER();
1887
1888                 portRESET_PRIVILEGE();
1889                 portMEMORY_BARRIER();
1890             }
1891             else
1892             {
1893                 xReturn = xTimerGetPeriod( xTimer );
1894             }
1895
1896             return xReturn;
1897         }
1898     #endif /* if ( configUSE_TIMERS == 1 ) */
1899 /*-----------------------------------------------------------*/
1900
1901     #if ( configUSE_TIMERS == 1 )
1902         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
1903         {
1904             TickType_t xReturn;
1905
1906             if( portIS_PRIVILEGED() == pdFALSE )
1907             {
1908                 portRAISE_PRIVILEGE();
1909                 portMEMORY_BARRIER();
1910
1911                 xReturn = xTimerGetExpiryTime( xTimer );
1912                 portMEMORY_BARRIER();
1913
1914                 portRESET_PRIVILEGE();
1915                 portMEMORY_BARRIER();
1916             }
1917             else
1918             {
1919                 xReturn = xTimerGetExpiryTime( xTimer );
1920             }
1921
1922             return xReturn;
1923         }
1924     #endif /* if ( configUSE_TIMERS == 1 ) */
1925 /*-----------------------------------------------------------*/
1926
1927     #if ( configUSE_TIMERS == 1 )
1928         BaseType_t MPU_xTimerGenericCommandFromTask( TimerHandle_t xTimer,
1929                                                      const BaseType_t xCommandID,
1930                                                      const TickType_t xOptionalValue,
1931                                                      BaseType_t * const pxHigherPriorityTaskWoken,
1932                                                      const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
1933         {
1934             BaseType_t xReturn;
1935
1936             if( portIS_PRIVILEGED() == pdFALSE )
1937             {
1938                 portRAISE_PRIVILEGE();
1939                 portMEMORY_BARRIER();
1940
1941                 xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
1942                 portMEMORY_BARRIER();
1943
1944                 portRESET_PRIVILEGE();
1945                 portMEMORY_BARRIER();
1946             }
1947             else
1948             {
1949                 xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
1950             }
1951
1952             return xReturn;
1953         }
1954     #endif /* if ( configUSE_TIMERS == 1 ) */
1955 /*-----------------------------------------------------------*/
1956
1957     #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) )
1958         EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */
1959         {
1960             EventGroupHandle_t xReturn;
1961
1962             if( portIS_PRIVILEGED() == pdFALSE )
1963             {
1964                 portRAISE_PRIVILEGE();
1965                 portMEMORY_BARRIER();
1966
1967                 xReturn = xEventGroupCreate();
1968                 portMEMORY_BARRIER();
1969
1970                 portRESET_PRIVILEGE();
1971                 portMEMORY_BARRIER();
1972             }
1973             else
1974             {
1975                 xReturn = xEventGroupCreate();
1976             }
1977
1978             return xReturn;
1979         }
1980     #endif /* #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */
1981 /*-----------------------------------------------------------*/
1982
1983     #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) )
1984         EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */
1985         {
1986             EventGroupHandle_t xReturn;
1987
1988             if( portIS_PRIVILEGED() == pdFALSE )
1989             {
1990                 portRAISE_PRIVILEGE();
1991                 portMEMORY_BARRIER();
1992
1993                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
1994                 portMEMORY_BARRIER();
1995
1996                 portRESET_PRIVILEGE();
1997                 portMEMORY_BARRIER();
1998             }
1999             else
2000             {
2001                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
2002             }
2003
2004             return xReturn;
2005         }
2006     #endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */
2007 /*-----------------------------------------------------------*/
2008
2009     #if ( configUSE_EVENT_GROUPS == 1 )
2010         EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
2011                                              const EventBits_t uxBitsToWaitFor,
2012                                              const BaseType_t xClearOnExit,
2013                                              const BaseType_t xWaitForAllBits,
2014                                              TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2015         {
2016             EventBits_t xReturn;
2017
2018             if( portIS_PRIVILEGED() == pdFALSE )
2019             {
2020                 portRAISE_PRIVILEGE();
2021                 portMEMORY_BARRIER();
2022
2023                 xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
2024                 portMEMORY_BARRIER();
2025
2026                 portRESET_PRIVILEGE();
2027                 portMEMORY_BARRIER();
2028             }
2029             else
2030             {
2031                 xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
2032             }
2033
2034             return xReturn;
2035         }
2036     #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
2037 /*-----------------------------------------------------------*/
2038
2039     #if ( configUSE_EVENT_GROUPS == 1 )
2040         EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
2041                                               const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */
2042         {
2043             EventBits_t xReturn;
2044
2045             if( portIS_PRIVILEGED() == pdFALSE )
2046             {
2047                 portRAISE_PRIVILEGE();
2048                 portMEMORY_BARRIER();
2049
2050                 xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
2051                 portMEMORY_BARRIER();
2052
2053                 portRESET_PRIVILEGE();
2054                 portMEMORY_BARRIER();
2055             }
2056             else
2057             {
2058                 xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
2059             }
2060
2061             return xReturn;
2062         }
2063     #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
2064 /*-----------------------------------------------------------*/
2065
2066     #if ( configUSE_EVENT_GROUPS == 1 )
2067         EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
2068                                             const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */
2069         {
2070             EventBits_t xReturn;
2071
2072             if( portIS_PRIVILEGED() == pdFALSE )
2073             {
2074                 portRAISE_PRIVILEGE();
2075                 portMEMORY_BARRIER();
2076
2077                 xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
2078                 portMEMORY_BARRIER();
2079
2080                 portRESET_PRIVILEGE();
2081                 portMEMORY_BARRIER();
2082             }
2083             else
2084             {
2085                 xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
2086             }
2087
2088             return xReturn;
2089         }
2090     #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
2091 /*-----------------------------------------------------------*/
2092
2093     #if ( configUSE_EVENT_GROUPS == 1 )
2094         EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
2095                                          const EventBits_t uxBitsToSet,
2096                                          const EventBits_t uxBitsToWaitFor,
2097                                          TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2098         {
2099             EventBits_t xReturn;
2100
2101             if( portIS_PRIVILEGED() == pdFALSE )
2102             {
2103                 portRAISE_PRIVILEGE();
2104                 portMEMORY_BARRIER();
2105
2106                 xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
2107                 portMEMORY_BARRIER();
2108
2109                 portRESET_PRIVILEGE();
2110                 portMEMORY_BARRIER();
2111             }
2112             else
2113             {
2114                 xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
2115             }
2116
2117             return xReturn;
2118         }
2119     #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
2120 /*-----------------------------------------------------------*/
2121
2122     #if ( configUSE_EVENT_GROUPS == 1 )
2123         void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */
2124         {
2125             if( portIS_PRIVILEGED() == pdFALSE )
2126             {
2127                 portRAISE_PRIVILEGE();
2128                 portMEMORY_BARRIER();
2129
2130                 vEventGroupDelete( xEventGroup );
2131                 portMEMORY_BARRIER();
2132
2133                 portRESET_PRIVILEGE();
2134                 portMEMORY_BARRIER();
2135             }
2136             else
2137             {
2138                 vEventGroupDelete( xEventGroup );
2139             }
2140         }
2141     #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
2142 /*-----------------------------------------------------------*/
2143
2144     #if ( configUSE_STREAM_BUFFERS == 1 )
2145         size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
2146                                       const void * pvTxData,
2147                                       size_t xDataLengthBytes,
2148                                       TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2149         {
2150             size_t xReturn;
2151
2152             if( portIS_PRIVILEGED() == pdFALSE )
2153             {
2154                 portRAISE_PRIVILEGE();
2155                 portMEMORY_BARRIER();
2156
2157                 xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
2158                 portMEMORY_BARRIER();
2159
2160                 portRESET_PRIVILEGE();
2161                 portMEMORY_BARRIER();
2162             }
2163             else
2164             {
2165                 xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
2166             }
2167
2168             return xReturn;
2169         }
2170     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2171 /*-----------------------------------------------------------*/
2172
2173     #if ( configUSE_STREAM_BUFFERS == 1 )
2174         size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2175         {
2176             size_t xReturn;
2177
2178             if( portIS_PRIVILEGED() == pdFALSE )
2179             {
2180                 portRAISE_PRIVILEGE();
2181                 portMEMORY_BARRIER();
2182
2183                 xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
2184                 portMEMORY_BARRIER();
2185
2186                 portRESET_PRIVILEGE();
2187                 portMEMORY_BARRIER();
2188             }
2189             else
2190             {
2191                 xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
2192             }
2193
2194             return xReturn;
2195         }
2196     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2197 /*-----------------------------------------------------------*/
2198
2199     #if ( configUSE_STREAM_BUFFERS == 1 )
2200         size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
2201                                          void * pvRxData,
2202                                          size_t xBufferLengthBytes,
2203                                          TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
2204         {
2205             size_t xReturn;
2206
2207             if( portIS_PRIVILEGED() == pdFALSE )
2208             {
2209                 portRAISE_PRIVILEGE();
2210                 portMEMORY_BARRIER();
2211
2212                 xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
2213                 portMEMORY_BARRIER();
2214
2215                 portRESET_PRIVILEGE();
2216                 portMEMORY_BARRIER();
2217             }
2218             else
2219             {
2220                 xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
2221             }
2222
2223             return xReturn;
2224         }
2225     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2226 /*-----------------------------------------------------------*/
2227
2228     #if ( configUSE_STREAM_BUFFERS == 1 )
2229         void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2230         {
2231             if( portIS_PRIVILEGED() == pdFALSE )
2232             {
2233                 portRAISE_PRIVILEGE();
2234                 portMEMORY_BARRIER();
2235
2236                 vStreamBufferDelete( xStreamBuffer );
2237                 portMEMORY_BARRIER();
2238
2239                 portRESET_PRIVILEGE();
2240                 portMEMORY_BARRIER();
2241             }
2242             else
2243             {
2244                 vStreamBufferDelete( xStreamBuffer );
2245             }
2246         }
2247     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2248 /*-----------------------------------------------------------*/
2249
2250     #if ( configUSE_STREAM_BUFFERS == 1 )
2251         BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2252         {
2253             BaseType_t xReturn;
2254
2255             if( portIS_PRIVILEGED() == pdFALSE )
2256             {
2257                 portRAISE_PRIVILEGE();
2258                 portMEMORY_BARRIER();
2259
2260                 xReturn = xStreamBufferIsFull( xStreamBuffer );
2261                 portMEMORY_BARRIER();
2262
2263                 portRESET_PRIVILEGE();
2264                 portMEMORY_BARRIER();
2265             }
2266             else
2267             {
2268                 xReturn = xStreamBufferIsFull( xStreamBuffer );
2269             }
2270
2271             return xReturn;
2272         }
2273     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2274 /*-----------------------------------------------------------*/
2275
2276     #if ( configUSE_STREAM_BUFFERS == 1 )
2277         BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2278         {
2279             BaseType_t xReturn;
2280
2281             if( portIS_PRIVILEGED() == pdFALSE )
2282             {
2283                 portRAISE_PRIVILEGE();
2284                 portMEMORY_BARRIER();
2285
2286                 xReturn = xStreamBufferIsEmpty( xStreamBuffer );
2287                 portMEMORY_BARRIER();
2288
2289                 portRESET_PRIVILEGE();
2290                 portMEMORY_BARRIER();
2291             }
2292             else
2293             {
2294                 xReturn = xStreamBufferIsEmpty( xStreamBuffer );
2295             }
2296
2297             return xReturn;
2298         }
2299     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2300 /*-----------------------------------------------------------*/
2301
2302     #if ( configUSE_STREAM_BUFFERS == 1 )
2303         BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2304         {
2305             BaseType_t xReturn;
2306
2307             if( portIS_PRIVILEGED() == pdFALSE )
2308             {
2309                 portRAISE_PRIVILEGE();
2310                 portMEMORY_BARRIER();
2311
2312                 xReturn = xStreamBufferReset( xStreamBuffer );
2313                 portMEMORY_BARRIER();
2314
2315                 portRESET_PRIVILEGE();
2316                 portMEMORY_BARRIER();
2317             }
2318             else
2319             {
2320                 xReturn = xStreamBufferReset( xStreamBuffer );
2321             }
2322
2323             return xReturn;
2324         }
2325     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2326 /*-----------------------------------------------------------*/
2327
2328     #if ( configUSE_STREAM_BUFFERS == 1 )
2329         size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2330         {
2331             size_t xReturn;
2332
2333             if( portIS_PRIVILEGED() == pdFALSE )
2334             {
2335                 portRAISE_PRIVILEGE();
2336                 portMEMORY_BARRIER();
2337                 xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
2338                 portMEMORY_BARRIER();
2339
2340                 portRESET_PRIVILEGE();
2341                 portMEMORY_BARRIER();
2342             }
2343             else
2344             {
2345                 xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
2346             }
2347
2348             return xReturn;
2349         }
2350     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2351 /*-----------------------------------------------------------*/
2352
2353     #if ( configUSE_STREAM_BUFFERS == 1 )
2354         size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
2355         {
2356             size_t xReturn;
2357
2358             if( portIS_PRIVILEGED() == pdFALSE )
2359             {
2360                 portRAISE_PRIVILEGE();
2361                 portMEMORY_BARRIER();
2362
2363                 xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
2364                 portMEMORY_BARRIER();
2365
2366                 portRESET_PRIVILEGE();
2367                 portMEMORY_BARRIER();
2368             }
2369             else
2370             {
2371                 xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
2372             }
2373
2374             return xReturn;
2375         }
2376     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2377 /*-----------------------------------------------------------*/
2378
2379     #if ( configUSE_STREAM_BUFFERS == 1 )
2380         BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
2381                                                      size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */
2382         {
2383             BaseType_t xReturn;
2384
2385             if( portIS_PRIVILEGED() == pdFALSE )
2386             {
2387                 portRAISE_PRIVILEGE();
2388                 portMEMORY_BARRIER();
2389
2390                 xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
2391                 portMEMORY_BARRIER();
2392
2393                 portRESET_PRIVILEGE();
2394                 portMEMORY_BARRIER();
2395             }
2396             else
2397             {
2398                 xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
2399             }
2400
2401             return xReturn;
2402         }
2403     #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
2404 /*-----------------------------------------------------------*/
2405
2406     #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) )
2407         StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
2408                                                              size_t xTriggerLevelBytes,
2409                                                              BaseType_t xStreamBufferType,
2410                                                              StreamBufferCallbackFunction_t pxSendCompletedCallback,
2411                                                              StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */
2412         {
2413             StreamBufferHandle_t xReturn;
2414
2415             /**
2416              * Stream buffer application level callback functionality is disabled for MPU
2417              * enabled ports.
2418              */
2419             configASSERT( ( pxSendCompletedCallback == NULL ) &&
2420                           ( pxReceiveCompletedCallback == NULL ) );
2421
2422             if( ( pxSendCompletedCallback == NULL ) &&
2423                 ( pxReceiveCompletedCallback == NULL ) )
2424             {
2425                 if( portIS_PRIVILEGED() == pdFALSE )
2426                 {
2427                     portRAISE_PRIVILEGE();
2428                     portMEMORY_BARRIER();
2429
2430                     xReturn = xStreamBufferGenericCreate( xBufferSizeBytes,
2431                                                           xTriggerLevelBytes,
2432                                                           xStreamBufferType,
2433                                                           NULL,
2434                                                           NULL );
2435                     portMEMORY_BARRIER();
2436
2437                     portRESET_PRIVILEGE();
2438                     portMEMORY_BARRIER();
2439                 }
2440                 else
2441                 {
2442                     xReturn = xStreamBufferGenericCreate( xBufferSizeBytes,
2443                                                           xTriggerLevelBytes,
2444                                                           xStreamBufferType,
2445                                                           NULL,
2446                                                           NULL );
2447                 }
2448             }
2449             else
2450             {
2451                 traceSTREAM_BUFFER_CREATE_FAILED( xStreamBufferType );
2452                 xReturn = NULL;
2453             }
2454
2455             return xReturn;
2456         }
2457     #endif /* #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */
2458 /*-----------------------------------------------------------*/
2459
2460     #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) )
2461         StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
2462                                                                    size_t xTriggerLevelBytes,
2463                                                                    BaseType_t xStreamBufferType,
2464                                                                    uint8_t * const pucStreamBufferStorageArea,
2465                                                                    StaticStreamBuffer_t * const pxStaticStreamBuffer,
2466                                                                    StreamBufferCallbackFunction_t pxSendCompletedCallback,
2467                                                                    StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */
2468         {
2469             StreamBufferHandle_t xReturn;
2470
2471             /**
2472              * Stream buffer application level callback functionality is disabled for MPU
2473              * enabled ports.
2474              */
2475             configASSERT( ( pxSendCompletedCallback == NULL ) &&
2476                           ( pxReceiveCompletedCallback == NULL ) );
2477
2478             if( ( pxSendCompletedCallback == NULL ) &&
2479                 ( pxReceiveCompletedCallback == NULL ) )
2480             {
2481                 if( portIS_PRIVILEGED() == pdFALSE )
2482                 {
2483                     portRAISE_PRIVILEGE();
2484                     portMEMORY_BARRIER();
2485
2486                     xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
2487                                                                 xTriggerLevelBytes,
2488                                                                 xStreamBufferType,
2489                                                                 pucStreamBufferStorageArea,
2490                                                                 pxStaticStreamBuffer,
2491                                                                 NULL,
2492                                                                 NULL );
2493                     portMEMORY_BARRIER();
2494
2495                     portRESET_PRIVILEGE();
2496                     portMEMORY_BARRIER();
2497                 }
2498                 else
2499                 {
2500                     xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
2501                                                                 xTriggerLevelBytes,
2502                                                                 xStreamBufferType,
2503                                                                 pucStreamBufferStorageArea,
2504                                                                 pxStaticStreamBuffer,
2505                                                                 NULL,
2506                                                                 NULL );
2507                 }
2508             }
2509             else
2510             {
2511                 traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xStreamBufferType );
2512                 xReturn = NULL;
2513             }
2514
2515             return xReturn;
2516         }
2517     #endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */
2518 /*-----------------------------------------------------------*/
2519
2520
2521 /* Functions that the application writer wants to execute in privileged mode
2522  * can be defined in application_defined_privileged_functions.h.  The functions
2523  * must take the same format as those above whereby the privilege state on exit
2524  * equals the privilege state on entry.  For example:
2525  *
2526  * void MPU_FunctionName( [parameters ] ) FREERTOS_SYSTEM_CALL;
2527  * void MPU_FunctionName( [parameters ] )
2528  * {
2529  *      if( portIS_PRIVILEGED() == pdFALSE )
2530  *      {
2531  *          portRAISE_PRIVILEGE();
2532  *          portMEMORY_BARRIER();
2533  *
2534  *          FunctionName( [parameters ] );
2535  *          portMEMORY_BARRIER();
2536  *
2537  *          portRESET_PRIVILEGE();
2538  *          portMEMORY_BARRIER();
2539  *      }
2540  *      else
2541  *      {
2542  *          FunctionName( [parameters ] );
2543  *      }
2544  * }
2545  */
2546
2547     #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
2548         #include "application_defined_privileged_functions.h"
2549     #endif
2550 /*-----------------------------------------------------------*/
2551
2552 #endif /* #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) ) */
2553 /*-----------------------------------------------------------*/