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  * @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     configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) /* FREERTOS_SYSTEM_CALL */\r
 353     {\r
 354         configRUN_TIME_COUNTER_TYPE xReturn;\r
 355         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 356 \r
 357         xReturn = ulTaskGetIdleRunTimePercent();\r
 358         vPortResetPrivilege( xRunningPrivileged );\r
 359         return xReturn;\r
 360     }\r
 361 #endif\r
 362 /*-----------------------------------------------------------*/\r
 363 \r
 364 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )\r
 365     configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */\r
 366     {\r
 367         configRUN_TIME_COUNTER_TYPE xReturn;\r
 368         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 369 \r
 370         xReturn = ulTaskGetIdleRunTimeCounter();\r
 371         vPortResetPrivilege( xRunningPrivileged );\r
 372         return xReturn;\r
 373     }\r
 374 #endif\r
 375 /*-----------------------------------------------------------*/\r
 376 \r
 377 #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 378     void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,\r
 379                                          TaskHookFunction_t pxTagValue ) /* FREERTOS_SYSTEM_CALL */\r
 380     {\r
 381         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 382 \r
 383         vTaskSetApplicationTaskTag( xTask, pxTagValue );\r
 384         vPortResetPrivilege( xRunningPrivileged );\r
 385     }\r
 386 #endif\r
 387 /*-----------------------------------------------------------*/\r
 388 \r
 389 #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 390     TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */\r
 391     {\r
 392         TaskHookFunction_t xReturn;\r
 393         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 394 \r
 395         xReturn = xTaskGetApplicationTaskTag( xTask );\r
 396         vPortResetPrivilege( xRunningPrivileged );\r
 397         return xReturn;\r
 398     }\r
 399 #endif\r
 400 /*-----------------------------------------------------------*/\r
 401 \r
 402 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
 403     void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,\r
 404                                                 BaseType_t xIndex,\r
 405                                                 void * pvValue ) /* FREERTOS_SYSTEM_CALL */\r
 406     {\r
 407         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 408 \r
 409         vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );\r
 410         vPortResetPrivilege( xRunningPrivileged );\r
 411     }\r
 412 #endif\r
 413 /*-----------------------------------------------------------*/\r
 414 \r
 415 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
 416     void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,\r
 417                                                    BaseType_t xIndex ) /* FREERTOS_SYSTEM_CALL */\r
 418     {\r
 419         void * pvReturn;\r
 420         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 421 \r
 422         pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );\r
 423         vPortResetPrivilege( xRunningPrivileged );\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;\r
 434         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 435 \r
 436         xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );\r
 437         vPortResetPrivilege( xRunningPrivileged );\r
 438         return xReturn;\r
 439     }\r
 440 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */\r
 441 /*-----------------------------------------------------------*/\r
 442 \r
 443 #if ( configUSE_TRACE_FACILITY == 1 )\r
 444     UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * pxTaskStatusArray,\r
 445                                           UBaseType_t uxArraySize,\r
 446                                           configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) /* FREERTOS_SYSTEM_CALL */\r
 447     {\r
 448         UBaseType_t uxReturn;\r
 449         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 450 \r
 451         uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );\r
 452         vPortResetPrivilege( xRunningPrivileged );\r
 453         return uxReturn;\r
 454     }\r
 455 #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */\r
 456 /*-----------------------------------------------------------*/\r
 457 \r
 458 BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTEM_CALL */\r
 459 {\r
 460     BaseType_t xReturn;\r
 461     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 462 \r
 463     xReturn = xTaskCatchUpTicks( xTicksToCatchUp );\r
 464     vPortResetPrivilege( xRunningPrivileged );\r
 465     return xReturn;\r
 466 }\r
 467 /*-----------------------------------------------------------*/\r
 468 \r
 469 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )\r
 470     UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */\r
 471     {\r
 472         UBaseType_t uxReturn;\r
 473         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 474 \r
 475         uxReturn = uxTaskGetStackHighWaterMark( xTask );\r
 476         vPortResetPrivilege( xRunningPrivileged );\r
 477         return uxReturn;\r
 478     }\r
 479 #endif\r
 480 /*-----------------------------------------------------------*/\r
 481 \r
 482 #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )\r
 483     configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */\r
 484     {\r
 485         configSTACK_DEPTH_TYPE uxReturn;\r
 486         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 487 \r
 488         uxReturn = uxTaskGetStackHighWaterMark2( xTask );\r
 489         vPortResetPrivilege( xRunningPrivileged );\r
 490         return uxReturn;\r
 491     }\r
 492 #endif\r
 493 /*-----------------------------------------------------------*/\r
 494 \r
 495 #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ))\r
 496     TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */\r
 497     {\r
 498         TaskHandle_t xReturn;\r
 499         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 500 \r
 501         xReturn = xTaskGetCurrentTaskHandle();\r
 502         vPortResetPrivilege( xRunningPrivileged );\r
 503         return xReturn;\r
 504     }\r
 505 #endif\r
 506 /*-----------------------------------------------------------*/\r
 507 \r
 508 #if ( INCLUDE_xTaskGetSchedulerState == 1 )\r
 509     BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */\r
 510     {\r
 511         BaseType_t xReturn;\r
 512         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 513 \r
 514         xReturn = xTaskGetSchedulerState();\r
 515         vPortResetPrivilege( xRunningPrivileged );\r
 516         return xReturn;\r
 517     }\r
 518 #endif\r
 519 /*-----------------------------------------------------------*/\r
 520 \r
 521 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */\r
 522 {\r
 523     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 524 \r
 525     vTaskSetTimeOutState( pxTimeOut );\r
 526     vPortResetPrivilege( xRunningPrivileged );\r
 527 }\r
 528 /*-----------------------------------------------------------*/\r
 529 \r
 530 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,\r
 531                                      TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 532 {\r
 533     BaseType_t xReturn;\r
 534     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 535 \r
 536     xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );\r
 537     vPortResetPrivilege( xRunningPrivileged );\r
 538     return xReturn;\r
 539 }\r
 540 /*-----------------------------------------------------------*/\r
 541 \r
 542 #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 543     BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,\r
 544                                        UBaseType_t uxIndexToNotify,\r
 545                                        uint32_t ulValue,\r
 546                                        eNotifyAction eAction,\r
 547                                        uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */\r
 548     {\r
 549         BaseType_t xReturn;\r
 550         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 551 \r
 552         xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );\r
 553         vPortResetPrivilege( xRunningPrivileged );\r
 554         return xReturn;\r
 555     }\r
 556 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 557 /*-----------------------------------------------------------*/\r
 558 \r
 559 #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 560     BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,\r
 561                                            uint32_t ulBitsToClearOnEntry,\r
 562                                            uint32_t ulBitsToClearOnExit,\r
 563                                            uint32_t * pulNotificationValue,\r
 564                                            TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 565     {\r
 566         BaseType_t xReturn;\r
 567         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 568 \r
 569         xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );\r
 570         vPortResetPrivilege( xRunningPrivileged );\r
 571         return xReturn;\r
 572     }\r
 573 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 574 /*-----------------------------------------------------------*/\r
 575 \r
 576 #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 577     uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,\r
 578                                           BaseType_t xClearCountOnExit,\r
 579                                           TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 580     {\r
 581         uint32_t ulReturn;\r
 582         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 583 \r
 584         ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );\r
 585         vPortResetPrivilege( xRunningPrivileged );\r
 586         return ulReturn;\r
 587     }\r
 588 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 589 /*-----------------------------------------------------------*/\r
 590 \r
 591 #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 592     BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,\r
 593                                                  UBaseType_t uxIndexToClear ) /* FREERTOS_SYSTEM_CALL */\r
 594     {\r
 595         BaseType_t xReturn;\r
 596         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 597 \r
 598         xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );\r
 599         vPortResetPrivilege( xRunningPrivileged );\r
 600         return xReturn;\r
 601     }\r
 602 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 603 /*-----------------------------------------------------------*/\r
 604 \r
 605 #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
 606     uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,\r
 607                                                 UBaseType_t uxIndexToClear,\r
 608                                                 uint32_t ulBitsToClear ) /* FREERTOS_SYSTEM_CALL */\r
 609     {\r
 610         uint32_t ulReturn;\r
 611         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 612 \r
 613         ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );\r
 614         vPortResetPrivilege( xRunningPrivileged );\r
 615         return ulReturn;\r
 616     }\r
 617 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */\r
 618 /*-----------------------------------------------------------*/\r
 619 \r
 620 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 621     QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength,\r
 622                                            UBaseType_t uxItemSize,\r
 623                                            uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */\r
 624     {\r
 625         QueueHandle_t xReturn;\r
 626         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 627 \r
 628         xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );\r
 629         vPortResetPrivilege( xRunningPrivileged );\r
 630         return xReturn;\r
 631     }\r
 632 #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */\r
 633 /*-----------------------------------------------------------*/\r
 634 \r
 635 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 636     QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,\r
 637                                                  const UBaseType_t uxItemSize,\r
 638                                                  uint8_t * pucQueueStorage,\r
 639                                                  StaticQueue_t * pxStaticQueue,\r
 640                                                  const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */\r
 641     {\r
 642         QueueHandle_t xReturn;\r
 643         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 644 \r
 645         xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );\r
 646         vPortResetPrivilege( xRunningPrivileged );\r
 647         return xReturn;\r
 648     }\r
 649 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */\r
 650 /*-----------------------------------------------------------*/\r
 651 \r
 652 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue,\r
 653                                    BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */\r
 654 {\r
 655     BaseType_t xReturn;\r
 656     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 657 \r
 658     xReturn = xQueueGenericReset( pxQueue, xNewQueue );\r
 659     vPortResetPrivilege( xRunningPrivileged );\r
 660     return xReturn;\r
 661 }\r
 662 /*-----------------------------------------------------------*/\r
 663 \r
 664 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,\r
 665                                   const void * const pvItemToQueue,\r
 666                                   TickType_t xTicksToWait,\r
 667                                   BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */\r
 668 {\r
 669     BaseType_t xReturn;\r
 670     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 671 \r
 672     xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );\r
 673     vPortResetPrivilege( xRunningPrivileged );\r
 674     return xReturn;\r
 675 }\r
 676 /*-----------------------------------------------------------*/\r
 677 \r
 678 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */\r
 679 {\r
 680     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 681     UBaseType_t uxReturn;\r
 682 \r
 683     uxReturn = uxQueueMessagesWaiting( pxQueue );\r
 684     vPortResetPrivilege( xRunningPrivileged );\r
 685     return uxReturn;\r
 686 }\r
 687 /*-----------------------------------------------------------*/\r
 688 \r
 689 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */\r
 690 {\r
 691     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 692     UBaseType_t uxReturn;\r
 693 \r
 694     uxReturn = uxQueueSpacesAvailable( xQueue );\r
 695     vPortResetPrivilege( xRunningPrivileged );\r
 696     return uxReturn;\r
 697 }\r
 698 /*-----------------------------------------------------------*/\r
 699 \r
 700 BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue,\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 = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );\r
 708     vPortResetPrivilege( xRunningPrivileged );\r
 709     return xReturn;\r
 710 }\r
 711 /*-----------------------------------------------------------*/\r
 712 \r
 713 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,\r
 714                            void * const pvBuffer,\r
 715                            TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 716 {\r
 717     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 718     BaseType_t xReturn;\r
 719 \r
 720     xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );\r
 721     vPortResetPrivilege( xRunningPrivileged );\r
 722     return xReturn;\r
 723 }\r
 724 /*-----------------------------------------------------------*/\r
 725 \r
 726 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,\r
 727                                     TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
 728 {\r
 729     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 730     BaseType_t xReturn;\r
 731 \r
 732     xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );\r
 733     vPortResetPrivilege( xRunningPrivileged );\r
 734     return xReturn;\r
 735 }\r
 736 /*-----------------------------------------------------------*/\r
 737 \r
 738 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )\r
 739     TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */\r
 740     {\r
 741         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 742         void * xReturn;\r
 743 \r
 744         xReturn = xQueueGetMutexHolder( xSemaphore );\r
 745         vPortResetPrivilege( xRunningPrivileged );\r
 746         return xReturn;\r
 747     }\r
 748 #endif\r
 749 /*-----------------------------------------------------------*/\r
 750 \r
 751 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 752     QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */\r
 753     {\r
 754         QueueHandle_t xReturn;\r
 755         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 756 \r
 757         xReturn = xQueueCreateMutex( ucQueueType );\r
 758         vPortResetPrivilege( xRunningPrivileged );\r
 759         return xReturn;\r
 760     }\r
 761 #endif\r
 762 /*-----------------------------------------------------------*/\r
 763 \r
 764 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 765     QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,\r
 766                                                StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */\r
 767     {\r
 768         QueueHandle_t xReturn;\r
 769         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 770 \r
 771         xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );\r
 772         vPortResetPrivilege( xRunningPrivileged );\r
 773         return xReturn;\r
 774     }\r
 775 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */\r
 776 /*-----------------------------------------------------------*/\r
 777 \r
 778 #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 779     QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue,\r
 780                                                      UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */\r
 781     {\r
 782         QueueHandle_t xReturn;\r
 783         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 784 \r
 785         xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );\r
 786         vPortResetPrivilege( xRunningPrivileged );\r
 787         return xReturn;\r
 788     }\r
 789 #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */\r
 790 /*-----------------------------------------------------------*/\r
 791 \r
 792 #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 793 \r
 794     QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,\r
 795                                                            const UBaseType_t uxInitialCount,\r
 796                                                            StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */\r
 797     {\r
 798         QueueHandle_t xReturn;\r
 799         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 800 \r
 801         xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );\r
 802         vPortResetPrivilege( xRunningPrivileged );\r
 803         return xReturn;\r
 804     }\r
 805 #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */\r
 806 /*-----------------------------------------------------------*/\r
 807 \r
 808 #if ( configUSE_RECURSIVE_MUTEXES == 1 )\r
 809     BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,\r
 810                                              TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */\r
 811     {\r
 812         BaseType_t xReturn;\r
 813         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 814 \r
 815         xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );\r
 816         vPortResetPrivilege( xRunningPrivileged );\r
 817         return xReturn;\r
 818     }\r
 819 #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */\r
 820 /*-----------------------------------------------------------*/\r
 821 \r
 822 #if ( configUSE_RECURSIVE_MUTEXES == 1 )\r
 823     BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */\r
 824     {\r
 825         BaseType_t xReturn;\r
 826         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 827 \r
 828         xReturn = xQueueGiveMutexRecursive( xMutex );\r
 829         vPortResetPrivilege( xRunningPrivileged );\r
 830         return xReturn;\r
 831     }\r
 832 #endif\r
 833 /*-----------------------------------------------------------*/\r
 834 \r
 835 #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 836     QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */\r
 837     {\r
 838         QueueSetHandle_t xReturn;\r
 839         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 840 \r
 841         xReturn = xQueueCreateSet( uxEventQueueLength );\r
 842         vPortResetPrivilege( xRunningPrivileged );\r
 843         return xReturn;\r
 844     }\r
 845 #endif\r
 846 /*-----------------------------------------------------------*/\r
 847 \r
 848 #if ( configUSE_QUEUE_SETS == 1 )\r
 849     QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,\r
 850                                                     TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */\r
 851     {\r
 852         QueueSetMemberHandle_t xReturn;\r
 853         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 854 \r
 855         xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );\r
 856         vPortResetPrivilege( xRunningPrivileged );\r
 857         return xReturn;\r
 858     }\r
 859 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */\r
 860 /*-----------------------------------------------------------*/\r
 861 \r
 862 #if ( configUSE_QUEUE_SETS == 1 )\r
 863     BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,\r
 864                                    QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */\r
 865     {\r
 866         BaseType_t xReturn;\r
 867         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 868 \r
 869         xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );\r
 870         vPortResetPrivilege( xRunningPrivileged );\r
 871         return xReturn;\r
 872     }\r
 873 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */\r
 874 /*-----------------------------------------------------------*/\r
 875 \r
 876 #if ( configUSE_QUEUE_SETS == 1 )\r
 877     BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,\r
 878                                         QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */\r
 879     {\r
 880         BaseType_t xReturn;\r
 881         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 882 \r
 883         xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );\r
 884         vPortResetPrivilege( xRunningPrivileged );\r
 885         return xReturn;\r
 886     }\r
 887 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */\r
 888 /*-----------------------------------------------------------*/\r
 889 \r
 890 #if configQUEUE_REGISTRY_SIZE > 0\r
 891     void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,\r
 892                                   const char * pcName ) /* FREERTOS_SYSTEM_CALL */\r
 893     {\r
 894         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 895 \r
 896         vQueueAddToRegistry( xQueue, pcName );\r
 897 \r
 898         vPortResetPrivilege( xRunningPrivileged );\r
 899     }\r
 900 #endif\r
 901 /*-----------------------------------------------------------*/\r
 902 \r
 903 #if configQUEUE_REGISTRY_SIZE > 0\r
 904     void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */\r
 905     {\r
 906         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 907 \r
 908         vQueueUnregisterQueue( xQueue );\r
 909 \r
 910         vPortResetPrivilege( xRunningPrivileged );\r
 911     }\r
 912 #endif\r
 913 /*-----------------------------------------------------------*/\r
 914 \r
 915 #if configQUEUE_REGISTRY_SIZE > 0\r
 916     const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */\r
 917     {\r
 918         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 919         const char * pcReturn;\r
 920 \r
 921         pcReturn = pcQueueGetName( xQueue );\r
 922 \r
 923         vPortResetPrivilege( xRunningPrivileged );\r
 924         return pcReturn;\r
 925     }\r
 926 #endif /* if configQUEUE_REGISTRY_SIZE > 0 */\r
 927 /*-----------------------------------------------------------*/\r
 928 \r
 929 void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */\r
 930 {\r
 931     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 932 \r
 933     vQueueDelete( xQueue );\r
 934 \r
 935     vPortResetPrivilege( xRunningPrivileged );\r
 936 }\r
 937 /*-----------------------------------------------------------*/\r
 938 \r
 939 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 940     void MPU_vPortInitialiseBlocks( void ) /* FREERTOS_SYSTEM_CALL */\r
 941     {\r
 942         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 943 \r
 944         vPortInitialiseBlocks();\r
 945 \r
 946         vPortResetPrivilege( xRunningPrivileged );\r
 947     }\r
 948 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 949 /*-----------------------------------------------------------*/\r
 950 \r
 951 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 952     size_t MPU_xPortGetFreeHeapSize( void ) /* FREERTOS_SYSTEM_CALL */\r
 953     {\r
 954         size_t xReturn;\r
 955         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 956 \r
 957         xReturn = xPortGetFreeHeapSize();\r
 958 \r
 959         vPortResetPrivilege( xRunningPrivileged );\r
 960 \r
 961         return xReturn;\r
 962     }\r
 963 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 964 /*-----------------------------------------------------------*/\r
 965 \r
 966 #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 967     TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName,\r
 968                                     const TickType_t xTimerPeriodInTicks,\r
 969                                     const UBaseType_t uxAutoReload,\r
 970                                     void * const pvTimerID,\r
 971                                     TimerCallbackFunction_t pxCallbackFunction ) /* FREERTOS_SYSTEM_CALL */\r
 972     {\r
 973         TimerHandle_t xReturn;\r
 974         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 975 \r
 976         xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );\r
 977         vPortResetPrivilege( xRunningPrivileged );\r
 978 \r
 979         return xReturn;\r
 980     }\r
 981 #endif /* if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) ) */\r
 982 /*-----------------------------------------------------------*/\r
 983 \r
 984 #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 985     TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName,\r
 986                                           const TickType_t xTimerPeriodInTicks,\r
 987                                           const UBaseType_t uxAutoReload,\r
 988                                           void * const pvTimerID,\r
 989                                           TimerCallbackFunction_t pxCallbackFunction,\r
 990                                           StaticTimer_t * pxTimerBuffer ) /* FREERTOS_SYSTEM_CALL */\r
 991     {\r
 992         TimerHandle_t xReturn;\r
 993         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 994 \r
 995         xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );\r
 996         vPortResetPrivilege( xRunningPrivileged );\r
 997 \r
 998         return xReturn;\r
 999     }\r
1000 #endif /* if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) ) */\r
1001 /*-----------------------------------------------------------*/\r
1002 \r
1003 #if ( configUSE_TIMERS == 1 )\r
1004     void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1005     {\r
1006         void * pvReturn;\r
1007         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1008 \r
1009         pvReturn = pvTimerGetTimerID( xTimer );\r
1010         vPortResetPrivilege( xRunningPrivileged );\r
1011 \r
1012         return pvReturn;\r
1013     }\r
1014 #endif /* if ( configUSE_TIMERS == 1 ) */\r
1015 /*-----------------------------------------------------------*/\r
1016 \r
1017 #if ( configUSE_TIMERS == 1 )\r
1018     void MPU_vTimerSetTimerID( TimerHandle_t xTimer,\r
1019                                void * pvNewID ) /* FREERTOS_SYSTEM_CALL */\r
1020     {\r
1021         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1022 \r
1023         vTimerSetTimerID( xTimer, pvNewID );\r
1024         vPortResetPrivilege( xRunningPrivileged );\r
1025     }\r
1026 #endif\r
1027 /*-----------------------------------------------------------*/\r
1028 \r
1029 #if ( configUSE_TIMERS == 1 )\r
1030     BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1031     {\r
1032         BaseType_t xReturn;\r
1033         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1034 \r
1035         xReturn = xTimerIsTimerActive( xTimer );\r
1036         vPortResetPrivilege( xRunningPrivileged );\r
1037 \r
1038         return xReturn;\r
1039     }\r
1040 #endif /* if ( configUSE_TIMERS == 1 ) */\r
1041 /*-----------------------------------------------------------*/\r
1042 \r
1043 #if ( configUSE_TIMERS == 1 )\r
1044     TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */\r
1045     {\r
1046         TaskHandle_t xReturn;\r
1047         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1048 \r
1049         xReturn = xTimerGetTimerDaemonTaskHandle();\r
1050         vPortResetPrivilege( xRunningPrivileged );\r
1051 \r
1052         return xReturn;\r
1053     }\r
1054 #endif /* if ( configUSE_TIMERS == 1 ) */\r
1055 /*-----------------------------------------------------------*/\r
1056 \r
1057 #if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )\r
1058     BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,\r
1059                                            void * pvParameter1,\r
1060                                            uint32_t ulParameter2,\r
1061                                            TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1062     {\r
1063         BaseType_t xReturn;\r
1064         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1065 \r
1066         xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );\r
1067         vPortResetPrivilege( xRunningPrivileged );\r
1068 \r
1069         return xReturn;\r
1070     }\r
1071 #endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */\r
1072 /*-----------------------------------------------------------*/\r
1073 \r
1074 #if ( configUSE_TIMERS == 1 )\r
1075     void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,\r
1076                                   const UBaseType_t uxAutoReload ) /* FREERTOS_SYSTEM_CALL */\r
1077     {\r
1078         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1079 \r
1080         vTimerSetReloadMode( xTimer, uxAutoReload );\r
1081         vPortResetPrivilege( xRunningPrivileged );\r
1082     }\r
1083 #endif\r
1084 /*-----------------------------------------------------------*/\r
1085 \r
1086 #if ( configUSE_TIMERS == 1 )\r
1087     UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer )\r
1088     {\r
1089         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1090         UBaseType_t uxReturn;\r
1091 \r
1092         uxReturn = uxTimerGetReloadMode( xTimer );\r
1093         vPortResetPrivilege( xRunningPrivileged );\r
1094         return uxReturn;\r
1095     }\r
1096 #endif\r
1097 /*-----------------------------------------------------------*/\r
1098 \r
1099 #if ( configUSE_TIMERS == 1 )\r
1100     const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1101     {\r
1102         const char * pcReturn;\r
1103         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1104 \r
1105         pcReturn = pcTimerGetName( xTimer );\r
1106         vPortResetPrivilege( xRunningPrivileged );\r
1107 \r
1108         return pcReturn;\r
1109     }\r
1110 #endif /* if ( configUSE_TIMERS == 1 ) */\r
1111 /*-----------------------------------------------------------*/\r
1112 \r
1113 #if ( configUSE_TIMERS == 1 )\r
1114     TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1115     {\r
1116         TickType_t xReturn;\r
1117         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1118 \r
1119         xReturn = xTimerGetPeriod( xTimer );\r
1120         vPortResetPrivilege( xRunningPrivileged );\r
1121 \r
1122         return xReturn;\r
1123     }\r
1124 #endif /* if ( configUSE_TIMERS == 1 ) */\r
1125 /*-----------------------------------------------------------*/\r
1126 \r
1127 #if ( configUSE_TIMERS == 1 )\r
1128     TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */\r
1129     {\r
1130         TickType_t xReturn;\r
1131         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1132 \r
1133         xReturn = xTimerGetExpiryTime( xTimer );\r
1134         vPortResetPrivilege( xRunningPrivileged );\r
1135 \r
1136         return xReturn;\r
1137     }\r
1138 #endif /* if ( configUSE_TIMERS == 1 ) */\r
1139 /*-----------------------------------------------------------*/\r
1140 \r
1141 #if ( configUSE_TIMERS == 1 )\r
1142     BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer,\r
1143                                          const BaseType_t xCommandID,\r
1144                                          const TickType_t xOptionalValue,\r
1145                                          BaseType_t * const pxHigherPriorityTaskWoken,\r
1146                                          const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1147     {\r
1148         BaseType_t xReturn;\r
1149         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1150 \r
1151         xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );\r
1152         vPortResetPrivilege( xRunningPrivileged );\r
1153 \r
1154         return xReturn;\r
1155     }\r
1156 #endif /* if ( configUSE_TIMERS == 1 ) */\r
1157 /*-----------------------------------------------------------*/\r
1158 \r
1159 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
1160     EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */\r
1161     {\r
1162         EventGroupHandle_t xReturn;\r
1163         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1164 \r
1165         xReturn = xEventGroupCreate();\r
1166         vPortResetPrivilege( xRunningPrivileged );\r
1167 \r
1168         return xReturn;\r
1169     }\r
1170 #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */\r
1171 /*-----------------------------------------------------------*/\r
1172 \r
1173 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
1174     EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1175     {\r
1176         EventGroupHandle_t xReturn;\r
1177         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1178 \r
1179         xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );\r
1180         vPortResetPrivilege( xRunningPrivileged );\r
1181 \r
1182         return xReturn;\r
1183     }\r
1184 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */\r
1185 /*-----------------------------------------------------------*/\r
1186 \r
1187 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,\r
1188                                      const EventBits_t uxBitsToWaitFor,\r
1189                                      const BaseType_t xClearOnExit,\r
1190                                      const BaseType_t xWaitForAllBits,\r
1191                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1192 {\r
1193     EventBits_t xReturn;\r
1194     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1195 \r
1196     xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );\r
1197     vPortResetPrivilege( xRunningPrivileged );\r
1198 \r
1199     return xReturn;\r
1200 }\r
1201 /*-----------------------------------------------------------*/\r
1202 \r
1203 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,\r
1204                                       const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */\r
1205 {\r
1206     EventBits_t xReturn;\r
1207     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1208 \r
1209     xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );\r
1210     vPortResetPrivilege( xRunningPrivileged );\r
1211 \r
1212     return xReturn;\r
1213 }\r
1214 /*-----------------------------------------------------------*/\r
1215 \r
1216 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,\r
1217                                     const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */\r
1218 {\r
1219     EventBits_t xReturn;\r
1220     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1221 \r
1222     xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );\r
1223     vPortResetPrivilege( xRunningPrivileged );\r
1224 \r
1225     return xReturn;\r
1226 }\r
1227 /*-----------------------------------------------------------*/\r
1228 \r
1229 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,\r
1230                                  const EventBits_t uxBitsToSet,\r
1231                                  const EventBits_t uxBitsToWaitFor,\r
1232                                  TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1233 {\r
1234     EventBits_t xReturn;\r
1235     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1236 \r
1237     xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );\r
1238     vPortResetPrivilege( xRunningPrivileged );\r
1239 \r
1240     return xReturn;\r
1241 }\r
1242 /*-----------------------------------------------------------*/\r
1243 \r
1244 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */\r
1245 {\r
1246     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1247 \r
1248     vEventGroupDelete( xEventGroup );\r
1249     vPortResetPrivilege( xRunningPrivileged );\r
1250 }\r
1251 /*-----------------------------------------------------------*/\r
1252 \r
1253 size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,\r
1254                               const void * pvTxData,\r
1255                               size_t xDataLengthBytes,\r
1256                               TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1257 {\r
1258     size_t xReturn;\r
1259     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1260 \r
1261     xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );\r
1262     vPortResetPrivilege( xRunningPrivileged );\r
1263 \r
1264     return xReturn;\r
1265 }\r
1266 /*-----------------------------------------------------------*/\r
1267 \r
1268 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1269 {\r
1270     size_t xReturn;\r
1271     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1272 \r
1273     xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );\r
1274     vPortResetPrivilege( xRunningPrivileged );\r
1275 \r
1276     return xReturn;\r
1277 }\r
1278 /*-----------------------------------------------------------*/\r
1279 \r
1280 size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,\r
1281                                  void * pvRxData,\r
1282                                  size_t xBufferLengthBytes,\r
1283                                  TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */\r
1284 {\r
1285     size_t xReturn;\r
1286     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1287 \r
1288     xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );\r
1289     vPortResetPrivilege( xRunningPrivileged );\r
1290 \r
1291     return xReturn;\r
1292 }\r
1293 /*-----------------------------------------------------------*/\r
1294 \r
1295 void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1296 {\r
1297     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1298 \r
1299     vStreamBufferDelete( xStreamBuffer );\r
1300     vPortResetPrivilege( xRunningPrivileged );\r
1301 }\r
1302 /*-----------------------------------------------------------*/\r
1303 \r
1304 BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1305 {\r
1306     BaseType_t xReturn;\r
1307     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1308 \r
1309     xReturn = xStreamBufferIsFull( xStreamBuffer );\r
1310     vPortResetPrivilege( xRunningPrivileged );\r
1311 \r
1312     return xReturn;\r
1313 }\r
1314 /*-----------------------------------------------------------*/\r
1315 \r
1316 BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1317 {\r
1318     BaseType_t xReturn;\r
1319     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1320 \r
1321     xReturn = xStreamBufferIsEmpty( xStreamBuffer );\r
1322     vPortResetPrivilege( xRunningPrivileged );\r
1323 \r
1324     return xReturn;\r
1325 }\r
1326 /*-----------------------------------------------------------*/\r
1327 \r
1328 BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1329 {\r
1330     BaseType_t xReturn;\r
1331     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1332 \r
1333     xReturn = xStreamBufferReset( xStreamBuffer );\r
1334     vPortResetPrivilege( xRunningPrivileged );\r
1335 \r
1336     return xReturn;\r
1337 }\r
1338 /*-----------------------------------------------------------*/\r
1339 \r
1340 size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1341 {\r
1342     size_t xReturn;\r
1343     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1344 \r
1345     xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );\r
1346     vPortResetPrivilege( xRunningPrivileged );\r
1347 \r
1348     return xReturn;\r
1349 }\r
1350 /*-----------------------------------------------------------*/\r
1351 \r
1352 size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1353 {\r
1354     size_t xReturn;\r
1355     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1356 \r
1357     xReturn = xStreamBufferBytesAvailable( xStreamBuffer );\r
1358     vPortResetPrivilege( xRunningPrivileged );\r
1359 \r
1360     return xReturn;\r
1361 }\r
1362 /*-----------------------------------------------------------*/\r
1363 \r
1364 BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,\r
1365                                              size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */\r
1366 {\r
1367     BaseType_t xReturn;\r
1368     BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1369 \r
1370     xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );\r
1371     vPortResetPrivilege( xRunningPrivileged );\r
1372 \r
1373     return xReturn;\r
1374 }\r
1375 /*-----------------------------------------------------------*/\r
1376 \r
1377 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
1378     StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,\r
1379                                                          size_t xTriggerLevelBytes,\r
1380                                                          BaseType_t xIsMessageBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1381     {\r
1382         StreamBufferHandle_t xReturn;\r
1383         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1384 \r
1385         xReturn = xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer );\r
1386         vPortResetPrivilege( xRunningPrivileged );\r
1387 \r
1388         return xReturn;\r
1389     }\r
1390 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
1391 /*-----------------------------------------------------------*/\r
1392 \r
1393 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
1394     StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,\r
1395                                                                size_t xTriggerLevelBytes,\r
1396                                                                BaseType_t xIsMessageBuffer,\r
1397                                                                uint8_t * const pucStreamBufferStorageArea,\r
1398                                                                StaticStreamBuffer_t * const pxStaticStreamBuffer ) /* FREERTOS_SYSTEM_CALL */\r
1399     {\r
1400         StreamBufferHandle_t xReturn;\r
1401         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1402 \r
1403         xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer, pucStreamBufferStorageArea, pxStaticStreamBuffer );\r
1404         vPortResetPrivilege( xRunningPrivileged );\r
1405 \r
1406         return xReturn;\r
1407     }\r
1408 #endif /* configSUPPORT_STATIC_ALLOCATION */\r
1409 /*-----------------------------------------------------------*/\r
1410 \r
1411 \r
1412 /* Functions that the application writer wants to execute in privileged mode\r
1413  * can be defined in application_defined_privileged_functions.h.  The functions\r
1414  * must take the same format as those above whereby the privilege state on exit\r
1415  * equals the privilege state on entry.  For example:\r
1416  *\r
1417  * void MPU_FunctionName( [parameters ] )\r
1418  * {\r
1419  * BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1420  *\r
1421  *  FunctionName( [parameters ] );\r
1422  *\r
1423  *  vPortResetPrivilege( xRunningPrivileged );\r
1424  * }\r
1425  */\r
1426 \r
1427 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1\r
1428     #include "application_defined_privileged_functions.h"\r
1429 #endif\r