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

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