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