git.sur5r.net Git - freertos/blob - FreeRTOS/Source/portable/Common/mpu_wrappers.c

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