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

   1 /*\r
   2  * FreeRTOS Kernel <DEVELOPMENT BRANCH>\r
   3  * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
   4  *\r
   5  * SPDX-License-Identifier: MIT\r
   6  *\r
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
   8  * this software and associated documentation files (the "Software"), to deal in\r
   9  * the Software without restriction, including without limitation the rights to\r
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
  11  * the Software, and to permit persons to whom the Software is furnished to do so,\r
  12  * subject to the following conditions:\r
  13  *\r
  14  * The above copyright notice and this permission notice shall be included in all\r
  15  * copies or substantial portions of the Software.\r
  16  *\r
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  19  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  20  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  23  *\r
  24  * https://www.FreeRTOS.org\r
  25  * https://github.com/FreeRTOS\r
  26  *\r
  27  */\r
  28 \r
  29 /*\r
  30  * Implementation of the wrapper functions used to raise the processor privilege\r
  31  * before calling a standard FreeRTOS API function.\r
  32  */\r
  33 \r
  34 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining\r
  35  * all the API functions to use the MPU wrappers.  That should only be done when\r
  36  * task.h is included from an application file. */\r
  37 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE\r
  38 \r
  39 /* Scheduler includes. */\r
  40 #include "FreeRTOS.h"\r
  41 #include "task.h"\r
  42 #include "queue.h"\r
  43 #include "timers.h"\r
  44 #include "event_groups.h"\r
  45 #include "stream_buffer.h"\r
  46 #include "mpu_prototypes.h"\r
  47 \r
  48 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE\r
  49 /*-----------------------------------------------------------*/\r
  50 \r
  51 #if ( portUSING_MPU_WRAPPERS == 1 )\r
  52 \r
  53     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
  54         BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode,\r
  55                                     const char * const pcName,\r
  56                                     uint16_t usStackDepth,\r
  57                                     void * pvParameters,\r
  58                                     UBaseType_t uxPriority,\r
  59                                     TaskHandle_t * pxCreatedTask ) /* FREERTOS_SYSTEM_CALL */\r
  60         {\r
  61             BaseType_t xReturn, xRunningPrivileged;\r
  62 \r
  63             xPortRaisePrivilege( xRunningPrivileged );\r
  64             xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );\r
  65             vPortResetPrivilege( xRunningPrivileged );\r
  66 \r
  67             return xReturn;\r
  68         }\r
  69     #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
  70 /*-----------------------------------------------------------*/\r
  71 \r
  72     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
  73         TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,\r
  74                                             const char * const pcName,\r
  75                                             const uint32_t ulStackDepth,\r
  76                                             void * const pvParameters,\r
  77                                             UBaseType_t uxPriority,\r
  78                                             StackType_t * const puxStackBuffer,\r
  79                                             StaticTask_t * const pxTaskBuffer ) /* FREERTOS_SYSTEM_CALL */\r
  80         {\r
  81             TaskHandle_t xReturn;\r
  82             BaseType_t xRunningPrivileged;\r
  83 \r
  84             xPortRaisePrivilege( xRunningPrivileged );\r
  85             xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );\r
  86             vPortResetPrivilege( xRunningPrivileged );\r
  87 \r
  88             return xReturn;\r
  89         }\r
  90     #endif /* configSUPPORT_STATIC_ALLOCATION */\r
  91 /*-----------------------------------------------------------*/\r
  92 \r
  93     #if ( INCLUDE_vTaskDelete == 1 )\r
  94         void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete ) /* FREERTOS_SYSTEM_CALL */\r
  95         {\r
  96             BaseType_t xRunningPrivileged;\r
  97 \r
  98             xPortRaisePrivilege( xRunningPrivileged );\r
  99             vTaskDelete( pxTaskToDelete );\r
 100             vPortResetPrivilege( xRunningPrivileged );\r
 101         }\r
 102     #endif\r
 103 /*-----------------------------------------------------------*/\r
 104 \r
 105     #if ( INCLUDE_xTaskDelayUntil == 1 )\r
 106         BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,\r
 107                                         TickType_t xTimeIncrement ) /* FREERTOS_SYSTEM_CALL */\r
 108         {\r
 109             BaseType_t xRunningPrivileged, xReturn;\r
 110 \r
 111             xPortRaisePrivilege( xRunningPrivileged );\r
 112             xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );\r
 113             vPortResetPrivilege( xRunningPrivileged );\r
 114 \r
 115             return xReturn;\r
 116         }\r
 117     #endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */\r
 118 /*-----------------------------------------------------------*/\r
 119 \r
 120     #if ( INCLUDE_xTaskAbortDelay == 1 )\r
 121         BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */\r
 122         {\r
 123             BaseType_t xReturn, xRunningPrivileged;\r
 124 \r
 125             xPortRaisePrivilege( xRunningPrivileged );\r
 126             xReturn = xTaskAbortDelay( xTask );\r
 127             vPortResetPrivilege( xRunningPrivileged );\r
 128 \r
 129             return xReturn;\r
 130         }\r
 131     #endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */\r
 132 /*-----------------------------------------------------------*/\r
 133 \r
 134     #if ( INCLUDE_vTaskDelay == 1 )\r
 135         void MPU_vTaskDelay( TickType_t xTicksToDelay ) /* FREERTOS_SYSTEM_CALL */\r
 136         {\r
 137             BaseType_t xRunningPrivileged;\r
 138 \r
 139             xPortRaisePrivilege( xRunningPrivileged );\r
 140             vTaskDelay( xTicksToDelay );\r
 141             vPortResetPrivilege( xRunningPrivileged );\r
 142         }\r
 143     #endif\r
 144 /*-----------------------------------------------------------*/\r
 145 \r
 146     #if ( INCLUDE_uxTaskPriorityGet == 1 )\r
 147         UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */\r
 148         {\r
 149             UBaseType_t uxReturn;\r
 150             BaseType_t xRunningPrivileged;\r
 151 \r
 152             xPortRaisePrivilege( xRunningPrivileged );\r
 153             uxReturn = uxTaskPriorityGet( pxTask );\r
 154             vPortResetPrivilege( xRunningPrivileged );\r
 155 \r
 156             return uxReturn;\r
 157         }\r
 158     #endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */\r
 159 /*-----------------------------------------------------------*/\r
 160 \r
 161     #if ( INCLUDE_vTaskPrioritySet == 1 )\r
 162         void MPU_vTaskPrioritySet( TaskHandle_t pxTask,\r
 163                                    UBaseType_t uxNewPriority ) /* FREERTOS_SYSTEM_CALL */\r
 164         {\r
 165             BaseType_t xRunningPrivileged;\r
 166 \r
 167             xPortRaisePrivilege( xRunningPrivileged );\r
 168             vTaskPrioritySet( pxTask, uxNewPriority );\r
 169             vPortResetPrivilege( xRunningPrivileged );\r
 170         }\r
 171     #endif /* if ( INCLUDE_vTaskPrioritySet == 1 ) */\r
 172 /*-----------------------------------------------------------*/\r
 173 \r
 174     #if ( INCLUDE_eTaskGetState == 1 )\r
 175         eTaskState MPU_eTaskGetState( TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */\r
 176         {\r
 177             eTaskState eReturn;\r
 178             BaseType_t xRunningPrivileged;\r
 179 \r
 180             xPortRaisePrivilege( xRunningPrivileged );\r
 181             eReturn = eTaskGetState( pxTask );\r
 182             vPortResetPrivilege( xRunningPrivileged );\r
 183 \r
 184             return eReturn;\r
 185         }\r
 186     #endif /* if ( INCLUDE_eTaskGetState == 1 ) */\r
 187 /*-----------------------------------------------------------*/\r
 188 \r
 189     #if ( configUSE_TRACE_FACILITY == 1 )\r
 190         void MPU_vTaskGetInfo( TaskHandle_t xTask,\r
 191                                TaskStatus_t * pxTaskStatus,\r
 192                                BaseType_t xGetFreeStackSpace,\r
 193                                eTaskState eState ) /* FREERTOS_SYSTEM_CALL */\r
 194         {\r
 195             BaseType_t xRunningPrivileged;\r
 196 \r
 197             xPortRaisePrivilege( xRunningPrivileged );\r
 198             vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );\r
 199             vPortResetPrivilege( xRunningPrivileged );\r
 200         }\r
 201     #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */\r
 202 /*-----------------------------------------------------------*/\r
 203 \r
 204     #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )\r
 205         TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */\r
 206         {\r
 207             TaskHandle_t xReturn;\r
 208             BaseType_t xRunningPrivileged;\r
 209 \r
 210             xPortRaisePrivilege( xRunningPrivileged );\r
 211             xReturn = xTaskGetIdleTaskHandle();\r
 212             vPortResetPrivilege( xRunningPrivileged );\r
 213 \r
 214             return xReturn;\r
 215         }\r
 216     #endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */\r
 217 /*-----------------------------------------------------------*/\r
 218 \r
 219     #if ( INCLUDE_vTaskSuspend == 1 )\r
 220         void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend ) /* FREERTOS_SYSTEM_CALL */\r
 221         {\r
 222             BaseType_t xRunningPrivileged;\r
 223 \r
 224             xPortRaisePrivilege( xRunningPrivileged );\r
 225             vTaskSuspend( pxTaskToSuspend );\r
 226             vPortResetPrivilege( xRunningPrivileged );\r
 227         }\r
 228     #endif\r
 229 /*-----------------------------------------------------------*/\r
 230 \r
 231     #if ( INCLUDE_vTaskSuspend == 1 )\r
 232         void MPU_vTaskResume( TaskHandle_t pxTaskToResume ) /* FREERTOS_SYSTEM_CALL */\r
 233         {\r
 234             BaseType_t xRunningPrivileged;\r
 235 \r
 236             xPortRaisePrivilege( xRunningPrivileged );\r
 237             vTaskResume( pxTaskToResume );\r
 238             vPortResetPrivilege( xRunningPrivileged );\r
 239         }\r
 240     #endif\r
 241 /*-----------------------------------------------------------*/\r
 242 \r
 243     void MPU_vTaskSuspendAll( void ) /* FREERTOS_SYSTEM_CALL */\r
 244     {\r
 245         BaseType_t xRunningPrivileged;\r
 246 \r
 247         xPortRaisePrivilege( xRunningPrivileged );\r
 248         vTaskSuspendAll();\r
 249         vPortResetPrivilege( xRunningPrivileged );\r
 250     }\r
 251 /*-----------------------------------------------------------*/\r
 252 \r
 253     BaseType_t MPU_xTaskResumeAll( void ) /* FREERTOS_SYSTEM_CALL */\r
 254     {\r
 255         BaseType_t xReturn, xRunningPrivileged;\r
 256 \r
 257         xPortRaisePrivilege( xRunningPrivileged );\r
 258         xReturn = xTaskResumeAll();\r
 259         vPortResetPrivilege( xRunningPrivileged );\r
 260 \r
 261         return xReturn;\r
 262     }\r
 263 /*-----------------------------------------------------------*/\r
 264 \r
 265     TickType_t MPU_xTaskGetTickCount( void ) /* FREERTOS_SYSTEM_CALL */\r
 266     {\r
 267         TickType_t xReturn;\r
 268         BaseType_t xRunningPrivileged;\r
 269 \r
 270         xPortRaisePrivilege( xRunningPrivileged );\r
 271         xReturn = xTaskGetTickCount();\r
 272         vPortResetPrivilege( xRunningPrivileged );\r
 273 \r
 274         return xReturn;\r
 275     }\r
 276 /*-----------------------------------------------------------*/\r
 277 \r
 278     UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* FREERTOS_SYSTEM_CALL */\r
 279     {\r
 280         UBaseType_t uxReturn;\r
 281         BaseType_t xRunningPrivileged;\r
 282 \r
 283         xPortRaisePrivilege( xRunningPrivileged );\r
 284         uxReturn = uxTaskGetNumberOfTasks();\r
 285         vPortResetPrivilege( xRunningPrivileged );\r
 286 \r
 287         return uxReturn;\r
 288     }\r
 289 /*-----------------------------------------------------------*/\r
 290 \r
 291     char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */\r
 292     {\r
 293         char * pcReturn;\r
 294         BaseType_t xRunningPrivileged;\r
 295 \r
 296         xPortRaisePrivilege( xRunningPrivileged );\r
 297         pcReturn = pcTaskGetName( xTaskToQuery );\r
 298         vPortResetPrivilege( xRunningPrivileged );\r
 299 \r
 300         return pcReturn;\r
 301     }\r
 302 /*-----------------------------------------------------------*/\r
 303 \r
 304     #if ( INCLUDE_xTaskGetHandle == 1 )\r
 305         TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) /* FREERTOS_SYSTEM_CALL */\r
 306         {\r
 307             TaskHandle_t xReturn;\r
 308             BaseType_t xRunningPrivileged;\r
 309 \r
 310             xPortRaisePrivilege( xRunningPrivileged );\r
 311             xReturn = xTaskGetHandle( pcNameToQuery );\r
 312             vPortResetPrivilege( xRunningPrivileged );\r
 313 \r
 314             return xReturn;\r
 315         }\r
 316     #endif /* if ( INCLUDE_xTaskGetHandle == 1 ) */\r
 317 /*-----------------------------------------------------------*/\r
 318 \r
 319     #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 320         void MPU_vTaskList( char * pcWriteBuffer ) /* FREERTOS_SYSTEM_CALL */\r
 321         {\r
 322             BaseType_t xRunningPrivileged;\r
 323 \r
 324             xPortRaisePrivilege( xRunningPrivileged );\r
 325             vTaskList( pcWriteBuffer );\r
 326             vPortResetPrivilege( xRunningPrivileged );\r
 327         }\r
 328     #endif\r
 329 /*-----------------------------------------------------------*/\r
 330 \r
 331     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 332         void MPU_vTaskGetRunTimeStats( char * pcWriteBuffer ) /* FREERTOS_SYSTEM_CALL */\r
 333         {\r
 334             BaseType_t xRunningPrivileged;\r
 335 \r
 336             xPortRaisePrivilege( xRunningPrivileged );\r
 337             vTaskGetRunTimeStats( pcWriteBuffer );\r
 338             vPortResetPrivilege( xRunningPrivileged );\r
 339         }\r
 340     #endif\r
 341 /*-----------------------------------------------------------*/\r
 342 \r
 343     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )\r
 344         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) /* FREERTOS_SYSTEM_CALL */\r
 345         {\r
 346             configRUN_TIME_COUNTER_TYPE xReturn;\r
 347             BaseType_t xRunningPrivileged;\r
 348 \r
 349             xPortRaisePrivilege( xRunningPrivileged );\r
 350             xReturn = ulTaskGetIdleRunTimePercent();\r
 351             vPortResetPrivilege( xRunningPrivileged );\r
 352 \r
 353             return xReturn;\r
 354         }\r
 355     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */\r
 356 /*-----------------------------------------------------------*/\r
 357 \r
 358     #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )\r
 359         configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */\r
 360         {\r
 361             configRUN_TIME_COUNTER_TYPE xReturn;\r
 362             BaseType_t xRunningPrivileged;\r
 363 \r
 364             xPortRaisePrivilege( xRunningPrivileged );\r
 365             xReturn = ulTaskGetIdleRunTimeCounter();\r
 366             vPortResetPrivilege( xRunningPrivileged );\r
 367 \r
 368             return xReturn;\r
 369         }\r
 370     #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */\r
 371 /*-----------------------------------------------------------*/\r
 372 \r
 373     #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 374         void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,\r
 375                                              TaskHookFunction_t pxTagValue ) /* FREERTOS_SYSTEM_CALL */\r
 376         {\r
 377             BaseType_t xRunningPrivileged;\r
 378 \r
 379             xPortRaisePrivilege( xRunningPrivileged );\r
 380             vTaskSetApplicationTaskTag( xTask, pxTagValue );\r
 381             vPortResetPrivilege( xRunningPrivileged );\r
 382         }\r
 383     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */\r
 384 /*-----------------------------------------------------------*/\r
 385 \r
 386     #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 387         TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */\r
 388         {\r
 389             TaskHookFunction_t xReturn;\r
 390             BaseType_t xRunningPrivileged;\r
 391 \r
 392             xPortRaisePrivilege( xRunningPrivileged );\r
 393             xReturn = xTaskGetApplicationTaskTag( xTask );\r
 394             vPortResetPrivilege( xRunningPrivileged );\r
 395 \r
 396             return xReturn;\r
 397         }\r
 398     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */\r
 399 /*-----------------------------------------------------------*/\r
 400 \r
 401     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
 402         void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,\r
 403                                                     BaseType_t xIndex,\r
 404                                                     void * pvValue ) /* FREERTOS_SYSTEM_CALL */\r
 405         {\r
 406             BaseType_t xRunningPrivileged;\r
 407 \r
 408             xPortRaisePrivilege( xRunningPrivileged );\r
 409             vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );\r
 410             vPortResetPrivilege( xRunningPrivileged );\r
 411         }\r
 412     #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */\r
 413 /*-----------------------------------------------------------*/\r
 414 \r
 415     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
 416         void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,\r
 417                                                        BaseType_t xIndex ) /* FREERTOS_SYSTEM_CALL */\r
 418         {\r
 419             void * pvReturn;\r
 420             BaseType_t xRunningPrivileged;\r
 421 \r
 422             xPortRaisePrivilege( xRunningPrivileged );\r
 423             pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );\r
 424             vPortResetPrivilege( xRunningPrivileged );\r
 425 \r
 426             return pvReturn;\r
 427         }\r
 428     #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */\r
 429 /*-----------------------------------------------------------*/\r
 430 \r
 431     #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 432         BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,\r
 433                                                      void * pvParameter ) /* FREERTOS_SYSTEM_CALL */\r
 434         {\r
 435             BaseType_t xReturn, xRunningPrivileged;\r
 436 \r
 437             xPortRaisePrivilege( xRunningPrivileged );\r
 438             xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );\r
 439             vPortResetPrivilege( xRunningPrivileged );\r
 440 \r
 441             return xReturn;\r
 442         }\r
 443     #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */\r
 444 /*-----------------------------------------------------------*/\r
 445 \r
 446     #if ( configUSE_TRACE_FACILITY == 1 )\r
 447         UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * pxTaskStatusArray,\r
 448                                               UBaseType_t uxArraySize,\r
 449                                               configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) /* FREERTOS_SYSTEM_CALL */\r
 450         {\r
 451             UBaseType_t uxReturn;\r
 452             BaseType_t xRunningPrivileged;\r
 453 \r
 454             xPortRaisePrivilege( xRunningPrivileged );\r
 455             uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );\r
 456             vPortResetPrivilege( xRunningPrivileged );\r
 457 \r
 458             return uxReturn;\r
 459         }\r
 460     #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */\r
 461 /*-----------------------------------------------------------*/\r
 462 \r
 463     BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTEM_CALL */\r
 464     {\r
 465         BaseType_t xReturn, xRunningPrivileged;\r
 466 \r
 467         xPortRaisePrivilege( xRunningPrivileged );\r
 468         xReturn = xTaskCatchUpTicks( xTicksToCatchUp );\r
 469         vPortResetPrivilege( xRunningPrivileged );\r
 470 \r
 471         return xReturn;\r
 472     }\r
 473 /*-----------------------------------------------------------*/\r
 474 \r
 475     #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )\r
 476         UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */\r
 477         {\r
 478             UBaseType_t uxReturn;\r
 479             BaseType_t xRunningPrivileged;\r
 480 \r
 481             xPortRaisePrivilege( xRunningPrivileged );\r
 482             uxReturn = uxTaskGetStackHighWaterMark( xTask );\r
 483             vPortResetPrivilege( xRunningPrivileged );\r
 484 \r
 485             return uxReturn;\r
 486         }\r
 487     #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */\r
 488 /*-----------------------------------------------------------*/\r
 489 \r
 490     #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )\r
 491         configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */\r
 492         {\r
 493             configSTACK_DEPTH_TYPE uxReturn;\r
 494             BaseType_t xRunningPrivileged;\r
 495 \r
 496             xPortRaisePrivilege( xRunningPrivileged );\r
 497             uxReturn = uxTaskGetStackHighWaterMark2( xTask );\r
 498             vPortResetPrivilege( xRunningPrivileged );\r
 499 \r
 500             return uxReturn;\r
 501         }\r
 502     #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */\r
 503 /*-----------------------------------------------------------*/\r
 504 \r
 505     #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )\r
 506         TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */\r
 507         {\r
 508             TaskHandle_t xReturn;\r
 509             BaseType_t xRunningPrivileged;\r
 510 \r
 511             xPortRaisePrivilege( xRunningPrivileged );\r
 512             xReturn = xTaskGetCurrentTaskHandle();\r
 513             vPortResetPrivilege( xRunningPrivileged );\r
 514 \r
 515             return xReturn;\r
 516         }\r
 517     #endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */\r
 518 /*-----------------------------------------------------------*/\r
 519 \r
 520     #if ( INCLUDE_xTaskGetSchedulerState == 1 )\r
 521         BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */\r
 522         {\r
 523             BaseType_t xReturn, xRunningPrivileged;\r
 524 \r
 525             xPortRaisePrivilege( xRunningPrivileged );\r
 526             xReturn = xTaskGetSchedulerState();\r
 527             vPortResetPrivilege( xRunningPrivileged );\r
 528 \r
 529             return xReturn;\r
 530         }\r
 531     #endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */\r
 532 /*-----------------------------------------------------------*/\r
 533 \r
 534     void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */\r
 535     {\r
 536         BaseType_t xRunningPrivileged;\r
 537 \r
 538         xPortRaisePrivilege( xRunningPrivileged );\r
 539         vTaskSetTimeOutState( pxTimeOut );\r
 540         vPortResetPrivilege( xRunningPrivileged );\r
 541     }\r
 542 /*-----------------------------------------------------------*/\r
 543 \r
 544     BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,\r
 545                                          TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 546     {\r
 547         BaseType_t xReturn, xRunningPrivileged;\r
 548 \r
 549         xPortRaisePrivilege( xRunningPrivileged );\r
 550         xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );\r
 551         vPortResetPrivilege( xRunningPrivileged );\r
 552 \r
 553         return xReturn;\r
 554     }\r
 555 /*-----------------------------------------------------------*/\r
 556 \r
 557     #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 558         BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,\r
 559                                            UBaseType_t uxIndexToNotify,\r
 560                                            uint32_t ulValue,\r
 561                                            eNotifyAction eAction,\r
 562                                            uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */\r
 563         {\r
 564             BaseType_t xReturn, xRunningPrivileged;\r
 565 \r
 566             xPortRaisePrivilege( xRunningPrivileged );\r
 567             xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );\r
 568             vPortResetPrivilege( xRunningPrivileged );\r
 569 \r
 570             return xReturn;\r
 571         }\r
 572     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 573 /*-----------------------------------------------------------*/\r
 574 \r
 575     #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 576         BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,\r
 577                                                uint32_t ulBitsToClearOnEntry,\r
 578                                                uint32_t ulBitsToClearOnExit,\r
 579                                                uint32_t * pulNotificationValue,\r
 580                                                TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 581         {\r
 582             BaseType_t xReturn, xRunningPrivileged;\r
 583 \r
 584             xPortRaisePrivilege( xRunningPrivileged );\r
 585             xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );\r
 586             vPortResetPrivilege( xRunningPrivileged );\r
 587 \r
 588             return xReturn;\r
 589         }\r
 590     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 591 /*-----------------------------------------------------------*/\r
 592 \r
 593     #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 594         uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,\r
 595                                               BaseType_t xClearCountOnExit,\r
 596                                               TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 597         {\r
 598             uint32_t ulReturn;\r
 599             BaseType_t xRunningPrivileged;\r
 600 \r
 601             xPortRaisePrivilege( xRunningPrivileged );\r
 602             ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );\r
 603             vPortResetPrivilege( xRunningPrivileged );\r
 604 \r
 605             return ulReturn;\r
 606         }\r
 607     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 608 /*-----------------------------------------------------------*/\r
 609 \r
 610     #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 611         BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,\r
 612                                                      UBaseType_t uxIndexToClear ) /* FREERTOS_SYSTEM_CALL */\r
 613         {\r
 614             BaseType_t xReturn, xRunningPrivileged;\r
 615 \r
 616             xPortRaisePrivilege( xRunningPrivileged );\r
 617             xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );\r
 618             vPortResetPrivilege( xRunningPrivileged );\r
 619 \r
 620             return xReturn;\r
 621         }\r
 622     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 623 /*-----------------------------------------------------------*/\r
 624 \r
 625     #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 626         uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,\r
 627                                                     UBaseType_t uxIndexToClear,\r
 628                                                     uint32_t ulBitsToClear ) /* FREERTOS_SYSTEM_CALL */\r
 629         {\r
 630             uint32_t ulReturn;\r
 631             BaseType_t xRunningPrivileged;\r
 632 \r
 633             xPortRaisePrivilege( xRunningPrivileged );\r
 634             ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );\r
 635             vPortResetPrivilege( xRunningPrivileged );\r
 636 \r
 637             return ulReturn;\r
 638         }\r
 639     #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 640 /*-----------------------------------------------------------*/\r
 641 \r
 642     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 643         QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength,\r
 644                                                UBaseType_t uxItemSize,\r
 645                                                uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */\r
 646         {\r
 647             QueueHandle_t xReturn;\r
 648             BaseType_t xRunningPrivileged;\r
 649 \r
 650             xPortRaisePrivilege( xRunningPrivileged );\r
 651             xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );\r
 652             vPortResetPrivilege( xRunningPrivileged );\r
 653 \r
 654             return xReturn;\r
 655         }\r
 656     #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */\r
 657 /*-----------------------------------------------------------*/\r
 658 \r
 659     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 660         QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,\r
 661                                                      const UBaseType_t uxItemSize,\r
 662                                                      uint8_t * pucQueueStorage,\r
 663                                                      StaticQueue_t * pxStaticQueue,\r
 664                                                      const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */\r
 665         {\r
 666             QueueHandle_t xReturn;\r
 667             BaseType_t xRunningPrivileged;\r
 668 \r
 669             xPortRaisePrivilege( xRunningPrivileged );\r
 670             xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );\r
 671             vPortResetPrivilege( xRunningPrivileged );\r
 672 \r
 673             return xReturn;\r
 674         }\r
 675     #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */\r
 676 /*-----------------------------------------------------------*/\r
 677 \r
 678     BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue,\r
 679                                        BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */\r
 680     {\r
 681         BaseType_t xReturn, xRunningPrivileged;\r
 682 \r
 683         xPortRaisePrivilege( xRunningPrivileged );\r
 684         xReturn = xQueueGenericReset( pxQueue, xNewQueue );\r
 685         vPortResetPrivilege( xRunningPrivileged );\r
 686 \r
 687         return xReturn;\r
 688     }\r
 689 /*-----------------------------------------------------------*/\r
 690 \r
 691     BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,\r
 692                                       const void * const pvItemToQueue,\r
 693                                       TickType_t xTicksToWait,\r
 694                                       BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */\r
 695     {\r
 696         BaseType_t xReturn, xRunningPrivileged;\r
 697 \r
 698         xPortRaisePrivilege( xRunningPrivileged );\r
 699         xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );\r
 700         vPortResetPrivilege( xRunningPrivileged );\r
 701 \r
 702         return xReturn;\r
 703     }\r
 704 /*-----------------------------------------------------------*/\r
 705 \r
 706     UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */\r
 707     {\r
 708         UBaseType_t uxReturn;\r
 709         BaseType_t xRunningPrivileged;\r
 710 \r
 711         xPortRaisePrivilege( xRunningPrivileged );\r
 712         uxReturn = uxQueueMessagesWaiting( pxQueue );\r
 713         vPortResetPrivilege( xRunningPrivileged );\r
 714 \r
 715         return uxReturn;\r
 716     }\r
 717 /*-----------------------------------------------------------*/\r
 718 \r
 719     UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */\r
 720     {\r
 721         UBaseType_t uxReturn;\r
 722         BaseType_t xRunningPrivileged;\r
 723 \r
 724         xPortRaisePrivilege( xRunningPrivileged );\r
 725         uxReturn = uxQueueSpacesAvailable( xQueue );\r
 726         vPortResetPrivilege( xRunningPrivileged );\r
 727 \r
 728         return uxReturn;\r
 729     }\r
 730 /*-----------------------------------------------------------*/\r
 731 \r
 732     BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue,\r
 733                                   void * const pvBuffer,\r
 734                                   TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 735     {\r
 736         BaseType_t xReturn, xRunningPrivileged;\r
 737 \r
 738         xPortRaisePrivilege( xRunningPrivileged );\r
 739         xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );\r
 740         vPortResetPrivilege( xRunningPrivileged );\r
 741 \r
 742         return xReturn;\r
 743     }\r
 744 /*-----------------------------------------------------------*/\r
 745 \r
 746     BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,\r
 747                                void * const pvBuffer,\r
 748                                TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 749     {\r
 750         BaseType_t xReturn, xRunningPrivileged;\r
 751 \r
 752         xPortRaisePrivilege( xRunningPrivileged );\r
 753         xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );\r
 754         vPortResetPrivilege( xRunningPrivileged );\r
 755 \r
 756         return xReturn;\r
 757     }\r
 758 /*-----------------------------------------------------------*/\r
 759 \r
 760     BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,\r
 761                                         TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 762     {\r
 763         BaseType_t xReturn, xRunningPrivileged;\r
 764 \r
 765         xPortRaisePrivilege( xRunningPrivileged );\r
 766         xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );\r
 767         vPortResetPrivilege( xRunningPrivileged );\r
 768 \r
 769         return xReturn;\r
 770     }\r
 771 /*-----------------------------------------------------------*/\r
 772 \r
 773     #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )\r
 774         TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */\r
 775         {\r
 776             void * xReturn;\r
 777             BaseType_t xRunningPrivileged;\r
 778 \r
 779             xPortRaisePrivilege( xRunningPrivileged );\r
 780             xReturn = xQueueGetMutexHolder( xSemaphore );\r
 781             vPortResetPrivilege( xRunningPrivileged );\r
 782 \r
 783             return xReturn;\r
 784         }\r
 785     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */\r
 786 /*-----------------------------------------------------------*/\r
 787 \r
 788     #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 789         QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */\r
 790         {\r
 791             QueueHandle_t xReturn;\r
 792             BaseType_t xRunningPrivileged;\r
 793 \r
 794             xPortRaisePrivilege( xRunningPrivileged );\r
 795             xReturn = xQueueCreateMutex( ucQueueType );\r
 796             vPortResetPrivilege( xRunningPrivileged );\r
 797 \r
 798             return xReturn;\r
 799         }\r
 800     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */\r
 801 /*-----------------------------------------------------------*/\r
 802 \r
 803     #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 804         QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,\r
 805                                                    StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */\r
 806         {\r
 807             QueueHandle_t xReturn;\r
 808             BaseType_t xRunningPrivileged;\r
 809 \r
 810             xPortRaisePrivilege( xRunningPrivileged );\r
 811             xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );\r
 812             vPortResetPrivilege( xRunningPrivileged );\r
 813 \r
 814             return xReturn;\r
 815         }\r
 816     #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */\r
 817 /*-----------------------------------------------------------*/\r
 818 \r
 819     #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 820         QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue,\r
 821                                                          UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */\r
 822         {\r
 823             QueueHandle_t xReturn;\r
 824             BaseType_t xRunningPrivileged;\r
 825 \r
 826             xPortRaisePrivilege( xRunningPrivileged );\r
 827             xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );\r
 828             vPortResetPrivilege( xRunningPrivileged );\r
 829 \r
 830             return xReturn;\r
 831         }\r
 832     #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */\r
 833 /*-----------------------------------------------------------*/\r
 834 \r
 835     #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 836 \r
 837         QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,\r
 838                                                                const UBaseType_t uxInitialCount,\r
 839                                                                StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */\r
 840         {\r
 841             QueueHandle_t xReturn;\r
 842             BaseType_t xRunningPrivileged;\r
 843 \r
 844             xPortRaisePrivilege( xRunningPrivileged );\r
 845             xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );\r
 846             vPortResetPrivilege( xRunningPrivileged );\r
 847 \r
 848             return xReturn;\r
 849         }\r
 850     #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */\r
 851 /*-----------------------------------------------------------*/\r
 852 \r
 853     #if ( configUSE_RECURSIVE_MUTEXES == 1 )\r
 854         BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,\r
 855                                                  TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */\r
 856         {\r
 857             BaseType_t xReturn, xRunningPrivileged;\r
 858 \r
 859             xPortRaisePrivilege( xRunningPrivileged );\r
 860             xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );\r
 861             vPortResetPrivilege( xRunningPrivileged );\r
 862 \r
 863             return xReturn;\r
 864         }\r
 865     #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */\r
 866 /*-----------------------------------------------------------*/\r
 867 \r
 868     #if ( configUSE_RECURSIVE_MUTEXES == 1 )\r
 869         BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */\r
 870         {\r
 871             BaseType_t xReturn, xRunningPrivileged;\r
 872 \r
 873             xPortRaisePrivilege( xRunningPrivileged );\r
 874             xReturn = xQueueGiveMutexRecursive( xMutex );\r
 875             vPortResetPrivilege( xRunningPrivileged );\r
 876 \r
 877             return xReturn;\r
 878         }\r
 879     #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */\r
 880 /*-----------------------------------------------------------*/\r
 881 \r
 882     #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 883         QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */\r
 884         {\r
 885             QueueSetHandle_t xReturn;\r
 886             BaseType_t xRunningPrivileged;\r
 887 \r
 888             xPortRaisePrivilege( xRunningPrivileged );\r
 889             xReturn = xQueueCreateSet( uxEventQueueLength );\r
 890             vPortResetPrivilege( xRunningPrivileged );\r
 891 \r
 892             return xReturn;\r
 893         }\r
 894     #endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */\r
 895 /*-----------------------------------------------------------*/\r
 896 \r
 897     #if ( configUSE_QUEUE_SETS == 1 )\r
 898         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,\r
 899                                                         TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */\r
 900         {\r
 901             QueueSetMemberHandle_t xReturn;\r
 902             BaseType_t xRunningPrivileged;\r
 903 \r
 904             xPortRaisePrivilege( xRunningPrivileged );\r
 905             xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );\r
 906             vPortResetPrivilege( xRunningPrivileged );\r
 907 \r
 908             return xReturn;\r
 909         }\r
 910     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */\r
 911 /*-----------------------------------------------------------*/\r
 912 \r
 913     #if ( configUSE_QUEUE_SETS == 1 )\r
 914         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,\r
 915                                        QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */\r
 916         {\r
 917             BaseType_t xReturn, xRunningPrivileged;\r
 918 \r
 919             xPortRaisePrivilege( xRunningPrivileged );\r
 920             xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );\r
 921             vPortResetPrivilege( xRunningPrivileged );\r
 922 \r
 923             return xReturn;\r
 924         }\r
 925     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */\r
 926 /*-----------------------------------------------------------*/\r
 927 \r
 928     #if ( configUSE_QUEUE_SETS == 1 )\r
 929         BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,\r
 930                                             QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */\r
 931         {\r
 932             BaseType_t xReturn, xRunningPrivileged;\r
 933 \r
 934             xPortRaisePrivilege( xRunningPrivileged );\r
 935             xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );\r
 936             vPortResetPrivilege( xRunningPrivileged );\r
 937 \r
 938             return xReturn;\r
 939         }\r
 940     #endif /* if ( configUSE_QUEUE_SETS == 1 ) */\r
 941 /*-----------------------------------------------------------*/\r
 942 \r
 943     #if configQUEUE_REGISTRY_SIZE > 0\r
 944         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,\r
 945                                       const char * pcName ) /* FREERTOS_SYSTEM_CALL */\r
 946         {\r
 947             BaseType_t xRunningPrivileged;\r
 948 \r
 949             xPortRaisePrivilege( xRunningPrivileged );\r
 950             vQueueAddToRegistry( xQueue, pcName );\r
 951             vPortResetPrivilege( xRunningPrivileged );\r
 952         }\r
 953     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */\r
 954 /*-----------------------------------------------------------*/\r
 955 \r
 956     #if configQUEUE_REGISTRY_SIZE > 0\r
 957         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */\r
 958         {\r
 959             BaseType_t xRunningPrivileged;\r
 960 \r
 961             xPortRaisePrivilege( xRunningPrivileged );\r
 962             vQueueUnregisterQueue( xQueue );\r
 963             vPortResetPrivilege( xRunningPrivileged );\r
 964         }\r
 965     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */\r
 966 /*-----------------------------------------------------------*/\r
 967 \r
 968     #if configQUEUE_REGISTRY_SIZE > 0\r
 969         const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */\r
 970         {\r
 971             const char * pcReturn;\r
 972             BaseType_t xRunningPrivileged;\r
 973 \r
 974             xPortRaisePrivilege( xRunningPrivileged );\r
 975             pcReturn = pcQueueGetName( xQueue );\r
 976             vPortResetPrivilege( xRunningPrivileged );\r
 977 \r
 978             return pcReturn;\r
 979         }\r
 980     #endif /* if configQUEUE_REGISTRY_SIZE > 0 */\r
 981 /*-----------------------------------------------------------*/\r
 982 \r
 983     void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */\r
 984     {\r
 985         BaseType_t xRunningPrivileged;\r
 986 \r
 987         xPortRaisePrivilege( xRunningPrivileged );\r
 988         vQueueDelete( xQueue );\r
 989         vPortResetPrivilege( xRunningPrivileged );\r
 990     }\r
 991 /*-----------------------------------------------------------*/\r
 992 \r
 993     #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 994         TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName,\r
 995                                         const TickType_t xTimerPeriodInTicks,\r
 996                                         const UBaseType_t uxAutoReload,\r
 997                                         void * const pvTimerID,\r
 998                                         TimerCallbackFunction_t pxCallbackFunction ) /* FREERTOS_SYSTEM_CALL */\r
 999         {\r
1000             TimerHandle_t xReturn;\r
1001             BaseType_t xRunningPrivileged;\r
1002 \r
1003             xPortRaisePrivilege( xRunningPrivileged );\r
1004             xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );\r
1005             vPortResetPrivilege( xRunningPrivileged );\r
1006 \r
1007             return xReturn;\r
1008         }\r
1009     #endif /* if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) ) */\r
1010 /*-----------------------------------------------------------*/\r
1011 \r
1012     #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
1013         TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName,\r
1014                                               const TickType_t xTimerPeriodInTicks,\r
1015                                               const UBaseType_t uxAutoReload,\r
1016                                               void * const pvTimerID,\r
1017                                               TimerCallbackFunction_t pxCallbackFunction,\r
1018                                               StaticTimer_t * pxTimerBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1019         {\r
1020             TimerHandle_t xReturn;\r
1021             BaseType_t xRunningPrivileged;\r
1022 \r
1023             xPortRaisePrivilege( xRunningPrivileged );\r
1024             xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );\r
1025             vPortResetPrivilege( xRunningPrivileged );\r
1026 \r
1027             return xReturn;\r
1028         }\r
1029     #endif /* if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) ) */\r
1030 /*-----------------------------------------------------------*/\r
1031 \r
1032     #if ( configUSE_TIMERS == 1 )\r
1033         void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1034         {\r
1035             void * pvReturn;\r
1036             BaseType_t xRunningPrivileged;\r
1037 \r
1038             xPortRaisePrivilege( xRunningPrivileged );\r
1039             pvReturn = pvTimerGetTimerID( xTimer );\r
1040             vPortResetPrivilege( xRunningPrivileged );\r
1041 \r
1042             return pvReturn;\r
1043         }\r
1044     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1045 /*-----------------------------------------------------------*/\r
1046 \r
1047     #if ( configUSE_TIMERS == 1 )\r
1048         void MPU_vTimerSetTimerID( TimerHandle_t xTimer,\r
1049                                    void * pvNewID ) /* FREERTOS_SYSTEM_CALL */\r
1050         {\r
1051             BaseType_t xRunningPrivileged;\r
1052 \r
1053             xPortRaisePrivilege( xRunningPrivileged );\r
1054             vTimerSetTimerID( xTimer, pvNewID );\r
1055             vPortResetPrivilege( xRunningPrivileged );\r
1056         }\r
1057     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1058 /*-----------------------------------------------------------*/\r
1059 \r
1060     #if ( configUSE_TIMERS == 1 )\r
1061         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1062         {\r
1063             BaseType_t xReturn, xRunningPrivileged;\r
1064 \r
1065             xPortRaisePrivilege( xRunningPrivileged );\r
1066             xReturn = xTimerIsTimerActive( xTimer );\r
1067             vPortResetPrivilege( xRunningPrivileged );\r
1068 \r
1069             return xReturn;\r
1070         }\r
1071     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1072 /*-----------------------------------------------------------*/\r
1073 \r
1074     #if ( configUSE_TIMERS == 1 )\r
1075         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */\r
1076         {\r
1077             TaskHandle_t xReturn;\r
1078             BaseType_t xRunningPrivileged;\r
1079 \r
1080             xPortRaisePrivilege( xRunningPrivileged );\r
1081             xReturn = xTimerGetTimerDaemonTaskHandle();\r
1082             vPortResetPrivilege( xRunningPrivileged );\r
1083 \r
1084             return xReturn;\r
1085         }\r
1086     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1087 /*-----------------------------------------------------------*/\r
1088 \r
1089     #if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )\r
1090         BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,\r
1091                                                void * pvParameter1,\r
1092                                                uint32_t ulParameter2,\r
1093                                                TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1094         {\r
1095             BaseType_t xReturn, xRunningPrivileged;\r
1096 \r
1097             xPortRaisePrivilege( xRunningPrivileged );\r
1098             xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );\r
1099             vPortResetPrivilege( xRunningPrivileged );\r
1100 \r
1101             return xReturn;\r
1102         }\r
1103     #endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */\r
1104 /*-----------------------------------------------------------*/\r
1105 \r
1106     #if ( configUSE_TIMERS == 1 )\r
1107         void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,\r
1108                                       const UBaseType_t uxAutoReload ) /* FREERTOS_SYSTEM_CALL */\r
1109         {\r
1110             BaseType_t xRunningPrivileged;\r
1111 \r
1112             xPortRaisePrivilege( xRunningPrivileged );\r
1113             vTimerSetReloadMode( xTimer, uxAutoReload );\r
1114             vPortResetPrivilege( xRunningPrivileged );\r
1115         }\r
1116     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1117 /*-----------------------------------------------------------*/\r
1118 \r
1119     #if ( configUSE_TIMERS == 1 )\r
1120         UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer )\r
1121         {\r
1122             UBaseType_t uxReturn;\r
1123             BaseType_t xRunningPrivileged;\r
1124 \r
1125             xPortRaisePrivilege( xRunningPrivileged );\r
1126             uxReturn = uxTimerGetReloadMode( xTimer );\r
1127             vPortResetPrivilege( xRunningPrivileged );\r
1128 \r
1129             return uxReturn;\r
1130         }\r
1131     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1132 /*-----------------------------------------------------------*/\r
1133 \r
1134     #if ( configUSE_TIMERS == 1 )\r
1135         const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1136         {\r
1137             const char * pcReturn;\r
1138             BaseType_t xRunningPrivileged;\r
1139 \r
1140             xPortRaisePrivilege( xRunningPrivileged );\r
1141             pcReturn = pcTimerGetName( xTimer );\r
1142             vPortResetPrivilege( xRunningPrivileged );\r
1143 \r
1144             return pcReturn;\r
1145         }\r
1146     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1147 /*-----------------------------------------------------------*/\r
1148 \r
1149     #if ( configUSE_TIMERS == 1 )\r
1150         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1151         {\r
1152             TickType_t xReturn;\r
1153             BaseType_t xRunningPrivileged;\r
1154 \r
1155             xPortRaisePrivilege( xRunningPrivileged );\r
1156             xReturn = xTimerGetPeriod( xTimer );\r
1157             vPortResetPrivilege( xRunningPrivileged );\r
1158 \r
1159             return xReturn;\r
1160         }\r
1161     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1162 /*-----------------------------------------------------------*/\r
1163 \r
1164     #if ( configUSE_TIMERS == 1 )\r
1165         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1166         {\r
1167             TickType_t xReturn;\r
1168             BaseType_t xRunningPrivileged;\r
1169 \r
1170             xPortRaisePrivilege( xRunningPrivileged );\r
1171             xReturn = xTimerGetExpiryTime( xTimer );\r
1172             vPortResetPrivilege( xRunningPrivileged );\r
1173 \r
1174             return xReturn;\r
1175         }\r
1176     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1177 /*-----------------------------------------------------------*/\r
1178 \r
1179     #if ( configUSE_TIMERS == 1 )\r
1180         BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer,\r
1181                                              const BaseType_t xCommandID,\r
1182                                              const TickType_t xOptionalValue,\r
1183                                              BaseType_t * const pxHigherPriorityTaskWoken,\r
1184                                              const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1185         {\r
1186             BaseType_t xReturn;\r
1187             BaseType_t xRunningPrivileged;\r
1188 \r
1189             xPortRaisePrivilege( xRunningPrivileged );\r
1190             xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );\r
1191             vPortResetPrivilege( xRunningPrivileged );\r
1192 \r
1193             return xReturn;\r
1194         }\r
1195     #endif /* if ( configUSE_TIMERS == 1 ) */\r
1196 /*-----------------------------------------------------------*/\r
1197 \r
1198     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
1199         EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */\r
1200         {\r
1201             EventGroupHandle_t xReturn;\r
1202             BaseType_t xRunningPrivileged;\r
1203 \r
1204             xPortRaisePrivilege( xRunningPrivileged );\r
1205             xReturn = xEventGroupCreate();\r
1206             vPortResetPrivilege( xRunningPrivileged );\r
1207 \r
1208             return xReturn;\r
1209         }\r
1210     #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */\r
1211 /*-----------------------------------------------------------*/\r
1212 \r
1213     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
1214         EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1215         {\r
1216             EventGroupHandle_t xReturn;\r
1217             BaseType_t xRunningPrivileged;\r
1218 \r
1219             xPortRaisePrivilege( xRunningPrivileged );\r
1220             xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );\r
1221             vPortResetPrivilege( xRunningPrivileged );\r
1222 \r
1223             return xReturn;\r
1224         }\r
1225     #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */\r
1226 /*-----------------------------------------------------------*/\r
1227 \r
1228     EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,\r
1229                                          const EventBits_t uxBitsToWaitFor,\r
1230                                          const BaseType_t xClearOnExit,\r
1231                                          const BaseType_t xWaitForAllBits,\r
1232                                          TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1233     {\r
1234         EventBits_t xReturn;\r
1235         BaseType_t xRunningPrivileged;\r
1236 \r
1237         xPortRaisePrivilege( xRunningPrivileged );\r
1238         xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );\r
1239         vPortResetPrivilege( xRunningPrivileged );\r
1240 \r
1241         return xReturn;\r
1242     }\r
1243 /*-----------------------------------------------------------*/\r
1244 \r
1245     EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,\r
1246                                           const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */\r
1247     {\r
1248         EventBits_t xReturn;\r
1249         BaseType_t xRunningPrivileged;\r
1250 \r
1251         xPortRaisePrivilege( xRunningPrivileged );\r
1252         xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );\r
1253         vPortResetPrivilege( xRunningPrivileged );\r
1254 \r
1255         return xReturn;\r
1256     }\r
1257 /*-----------------------------------------------------------*/\r
1258 \r
1259     EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,\r
1260                                         const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */\r
1261     {\r
1262         EventBits_t xReturn;\r
1263         BaseType_t xRunningPrivileged;\r
1264 \r
1265         xPortRaisePrivilege( xRunningPrivileged );\r
1266         xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );\r
1267         vPortResetPrivilege( xRunningPrivileged );\r
1268 \r
1269         return xReturn;\r
1270     }\r
1271 /*-----------------------------------------------------------*/\r
1272 \r
1273     EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,\r
1274                                      const EventBits_t uxBitsToSet,\r
1275                                      const EventBits_t uxBitsToWaitFor,\r
1276                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1277     {\r
1278         EventBits_t xReturn;\r
1279         BaseType_t xRunningPrivileged;\r
1280 \r
1281         xPortRaisePrivilege( xRunningPrivileged );\r
1282         xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );\r
1283         vPortResetPrivilege( xRunningPrivileged );\r
1284 \r
1285         return xReturn;\r
1286     }\r
1287 /*-----------------------------------------------------------*/\r
1288 \r
1289     void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */\r
1290     {\r
1291         BaseType_t xRunningPrivileged;\r
1292 \r
1293         xPortRaisePrivilege( xRunningPrivileged );\r
1294         vEventGroupDelete( xEventGroup );\r
1295         vPortResetPrivilege( xRunningPrivileged );\r
1296     }\r
1297 /*-----------------------------------------------------------*/\r
1298 \r
1299     size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,\r
1300                                   const void * pvTxData,\r
1301                                   size_t xDataLengthBytes,\r
1302                                   TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1303     {\r
1304         size_t xReturn;\r
1305         BaseType_t xRunningPrivileged;\r
1306 \r
1307         xPortRaisePrivilege( xRunningPrivileged );\r
1308         xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );\r
1309         vPortResetPrivilege( xRunningPrivileged );\r
1310 \r
1311         return xReturn;\r
1312     }\r
1313 /*-----------------------------------------------------------*/\r
1314 \r
1315     size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1316     {\r
1317         size_t xReturn;\r
1318         BaseType_t xRunningPrivileged;\r
1319 \r
1320         xPortRaisePrivilege( xRunningPrivileged );\r
1321         xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );\r
1322         vPortResetPrivilege( xRunningPrivileged );\r
1323 \r
1324         return xReturn;\r
1325     }\r
1326 /*-----------------------------------------------------------*/\r
1327 \r
1328     size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,\r
1329                                      void * pvRxData,\r
1330                                      size_t xBufferLengthBytes,\r
1331                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1332     {\r
1333         size_t xReturn;\r
1334         BaseType_t xRunningPrivileged;\r
1335 \r
1336         xPortRaisePrivilege( xRunningPrivileged );\r
1337         xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );\r
1338         vPortResetPrivilege( xRunningPrivileged );\r
1339 \r
1340         return xReturn;\r
1341     }\r
1342 /*-----------------------------------------------------------*/\r
1343 \r
1344     void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1345     {\r
1346         BaseType_t xRunningPrivileged;\r
1347 \r
1348         xPortRaisePrivilege( xRunningPrivileged );\r
1349         vStreamBufferDelete( xStreamBuffer );\r
1350         vPortResetPrivilege( xRunningPrivileged );\r
1351     }\r
1352 /*-----------------------------------------------------------*/\r
1353 \r
1354     BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1355     {\r
1356         BaseType_t xReturn, xRunningPrivileged;\r
1357 \r
1358         xPortRaisePrivilege( xRunningPrivileged );\r
1359         xReturn = xStreamBufferIsFull( xStreamBuffer );\r
1360         vPortResetPrivilege( xRunningPrivileged );\r
1361 \r
1362         return xReturn;\r
1363     }\r
1364 /*-----------------------------------------------------------*/\r
1365 \r
1366     BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1367     {\r
1368         BaseType_t xReturn, xRunningPrivileged;\r
1369 \r
1370         xPortRaisePrivilege( xRunningPrivileged );\r
1371         xReturn = xStreamBufferIsEmpty( xStreamBuffer );\r
1372         vPortResetPrivilege( xRunningPrivileged );\r
1373 \r
1374         return xReturn;\r
1375     }\r
1376 /*-----------------------------------------------------------*/\r
1377 \r
1378     BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1379     {\r
1380         BaseType_t xReturn, xRunningPrivileged;\r
1381 \r
1382         xPortRaisePrivilege( xRunningPrivileged );\r
1383         xReturn = xStreamBufferReset( xStreamBuffer );\r
1384         vPortResetPrivilege( xRunningPrivileged );\r
1385 \r
1386         return xReturn;\r
1387     }\r
1388 /*-----------------------------------------------------------*/\r
1389 \r
1390     size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1391     {\r
1392         size_t xReturn;\r
1393         BaseType_t xRunningPrivileged;\r
1394 \r
1395         xPortRaisePrivilege( xRunningPrivileged );\r
1396         xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );\r
1397         vPortResetPrivilege( xRunningPrivileged );\r
1398 \r
1399         return xReturn;\r
1400     }\r
1401 /*-----------------------------------------------------------*/\r
1402 \r
1403     size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1404     {\r
1405         size_t xReturn;\r
1406         BaseType_t xRunningPrivileged;\r
1407 \r
1408         xPortRaisePrivilege( xRunningPrivileged );\r
1409         xReturn = xStreamBufferBytesAvailable( xStreamBuffer );\r
1410         vPortResetPrivilege( xRunningPrivileged );\r
1411 \r
1412         return xReturn;\r
1413     }\r
1414 /*-----------------------------------------------------------*/\r
1415 \r
1416     BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,\r
1417                                                  size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */\r
1418     {\r
1419         BaseType_t xReturn, xRunningPrivileged;\r
1420 \r
1421         xPortRaisePrivilege( xRunningPrivileged );\r
1422         xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );\r
1423         vPortResetPrivilege( xRunningPrivileged );\r
1424 \r
1425         return xReturn;\r
1426     }\r
1427 /*-----------------------------------------------------------*/\r
1428 \r
1429     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
1430         StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,\r
1431                                                              size_t xTriggerLevelBytes,\r
1432                                                              BaseType_t xIsMessageBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1433         {\r
1434             StreamBufferHandle_t xReturn;\r
1435             BaseType_t xRunningPrivileged;\r
1436 \r
1437             xPortRaisePrivilege( xRunningPrivileged );\r
1438             xReturn = xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer );\r
1439             vPortResetPrivilege( xRunningPrivileged );\r
1440 \r
1441             return xReturn;\r
1442         }\r
1443     #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
1444 /*-----------------------------------------------------------*/\r
1445 \r
1446     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
1447         StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,\r
1448                                                                    size_t xTriggerLevelBytes,\r
1449                                                                    BaseType_t xIsMessageBuffer,\r
1450                                                                    uint8_t * const pucStreamBufferStorageArea,\r
1451                                                                    StaticStreamBuffer_t * const pxStaticStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1452         {\r
1453             StreamBufferHandle_t xReturn;\r
1454             BaseType_t xRunningPrivileged;\r
1455 \r
1456             xPortRaisePrivilege( xRunningPrivileged );\r
1457             xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer, pucStreamBufferStorageArea, pxStaticStreamBuffer );\r
1458             vPortResetPrivilege( xRunningPrivileged );\r
1459 \r
1460             return xReturn;\r
1461         }\r
1462     #endif /* configSUPPORT_STATIC_ALLOCATION */\r
1463 /*-----------------------------------------------------------*/\r
1464 \r
1465 \r
1466 /* Functions that the application writer wants to execute in privileged mode\r
1467  * can be defined in application_defined_privileged_functions.h.  The functions\r
1468  * must take the same format as those above whereby the privilege state on exit\r
1469  * equals the privilege state on entry.  For example:\r
1470  *\r
1471  * void MPU_FunctionName( [parameters ] ) FREERTOS_SYSTEM_CALL;\r
1472  * void MPU_FunctionName( [parameters ] )\r
1473  * {\r
1474  * BaseType_t xRunningPrivileged;\r
1475  *\r
1476  * xPortRaisePrivilege( xRunningPrivileged );\r
1477  * FunctionName( [parameters ] );\r
1478  * vPortResetPrivilege( xRunningPrivileged );\r
1479  * }\r
1480  */\r
1481 \r
1482     #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1\r
1483         #include "application_defined_privileged_functions.h"\r
1484     #endif\r
1485 /*-----------------------------------------------------------*/\r
1486 \r
1487 #endif /* portUSING_MPU_WRAPPERS == 1 */\r
1488 /*-----------------------------------------------------------*/\r