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