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

   1 /*\r
   2  * FreeRTOS Kernel V10.1.1\r
   3  * Copyright (C) 2018 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_uxTaskGetStackHighWaterMark2 == 1 )\r
 424         configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask )\r
 425         {\r
 426         configSTACK_DEPTH_TYPE uxReturn;\r
 427         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 428 \r
 429                 uxReturn = uxTaskGetStackHighWaterMark2( xTask );\r
 430                 vPortResetPrivilege( xRunningPrivileged );\r
 431                 return uxReturn;\r
 432         }\r
 433 #endif\r
 434 /*-----------------------------------------------------------*/\r
 435 \r
 436 #if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )\r
 437         TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void )\r
 438         {\r
 439         TaskHandle_t xReturn;\r
 440         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 441 \r
 442                 xReturn = xTaskGetCurrentTaskHandle();\r
 443                 vPortResetPrivilege( xRunningPrivileged );\r
 444                 return xReturn;\r
 445         }\r
 446 #endif\r
 447 /*-----------------------------------------------------------*/\r
 448 \r
 449 #if ( INCLUDE_xTaskGetSchedulerState == 1 )\r
 450         BaseType_t MPU_xTaskGetSchedulerState( void )\r
 451         {\r
 452         BaseType_t xReturn;\r
 453         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 454 \r
 455                 xReturn = xTaskGetSchedulerState();\r
 456                 vPortResetPrivilege( xRunningPrivileged );\r
 457                 return xReturn;\r
 458         }\r
 459 #endif\r
 460 /*-----------------------------------------------------------*/\r
 461 \r
 462 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )\r
 463 {\r
 464 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 465 \r
 466         vTaskSetTimeOutState( pxTimeOut );\r
 467         vPortResetPrivilege( xRunningPrivileged );\r
 468 }\r
 469 /*-----------------------------------------------------------*/\r
 470 \r
 471 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait )\r
 472 {\r
 473 BaseType_t xReturn;\r
 474 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 475 \r
 476         xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );\r
 477         vPortResetPrivilege( xRunningPrivileged );\r
 478         return xReturn;\r
 479 }\r
 480 /*-----------------------------------------------------------*/\r
 481 \r
 482 #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
 483         BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )\r
 484         {\r
 485         BaseType_t xReturn;\r
 486         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 487 \r
 488                 xReturn = xTaskGenericNotify( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue );\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         BaseType_t MPU_xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )\r
 497         {\r
 498         BaseType_t xReturn;\r
 499         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 500 \r
 501                 xReturn = xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );\r
 502                 vPortResetPrivilege( xRunningPrivileged );\r
 503                 return xReturn;\r
 504         }\r
 505 #endif\r
 506 /*-----------------------------------------------------------*/\r
 507 \r
 508 #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
 509         uint32_t MPU_ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )\r
 510         {\r
 511         uint32_t ulReturn;\r
 512         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 513 \r
 514                 ulReturn = ulTaskNotifyTake( xClearCountOnExit, xTicksToWait );\r
 515                 vPortResetPrivilege( xRunningPrivileged );\r
 516                 return ulReturn;\r
 517         }\r
 518 #endif\r
 519 /*-----------------------------------------------------------*/\r
 520 \r
 521 #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
 522         BaseType_t MPU_xTaskNotifyStateClear( TaskHandle_t xTask )\r
 523         {\r
 524         BaseType_t xReturn;\r
 525         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 526 \r
 527                 xReturn = xTaskNotifyStateClear( xTask );\r
 528                 vPortResetPrivilege( xRunningPrivileged );\r
 529                 return xReturn;\r
 530         }\r
 531 #endif\r
 532 /*-----------------------------------------------------------*/\r
 533 \r
 534 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 535         QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize, uint8_t ucQueueType )\r
 536         {\r
 537         QueueHandle_t xReturn;\r
 538         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 539 \r
 540                 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );\r
 541                 vPortResetPrivilege( xRunningPrivileged );\r
 542                 return xReturn;\r
 543         }\r
 544 #endif\r
 545 /*-----------------------------------------------------------*/\r
 546 \r
 547 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 548         QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType )\r
 549         {\r
 550         QueueHandle_t xReturn;\r
 551         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 552 \r
 553                 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );\r
 554                 vPortResetPrivilege( xRunningPrivileged );\r
 555                 return xReturn;\r
 556         }\r
 557 #endif\r
 558 /*-----------------------------------------------------------*/\r
 559 \r
 560 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue, BaseType_t xNewQueue )\r
 561 {\r
 562 BaseType_t xReturn;\r
 563 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 564 \r
 565         xReturn = xQueueGenericReset( pxQueue, xNewQueue );\r
 566         vPortResetPrivilege( xRunningPrivileged );\r
 567         return xReturn;\r
 568 }\r
 569 /*-----------------------------------------------------------*/\r
 570 \r
 571 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition )\r
 572 {\r
 573 BaseType_t xReturn;\r
 574 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 575 \r
 576         xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );\r
 577         vPortResetPrivilege( xRunningPrivileged );\r
 578         return xReturn;\r
 579 }\r
 580 /*-----------------------------------------------------------*/\r
 581 \r
 582 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue )\r
 583 {\r
 584 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 585 UBaseType_t uxReturn;\r
 586 \r
 587         uxReturn = uxQueueMessagesWaiting( pxQueue );\r
 588         vPortResetPrivilege( xRunningPrivileged );\r
 589         return uxReturn;\r
 590 }\r
 591 /*-----------------------------------------------------------*/\r
 592 \r
 593 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue )\r
 594 {\r
 595 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 596 UBaseType_t uxReturn;\r
 597 \r
 598         uxReturn = uxQueueSpacesAvailable( xQueue );\r
 599         vPortResetPrivilege( xRunningPrivileged );\r
 600         return uxReturn;\r
 601 }\r
 602 /*-----------------------------------------------------------*/\r
 603 \r
 604 BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue, void * const pvBuffer, TickType_t xTicksToWait )\r
 605 {\r
 606 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 607 BaseType_t xReturn;\r
 608 \r
 609         xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );\r
 610         vPortResetPrivilege( xRunningPrivileged );\r
 611         return xReturn;\r
 612 }\r
 613 /*-----------------------------------------------------------*/\r
 614 \r
 615 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait )\r
 616 {\r
 617 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 618 BaseType_t xReturn;\r
 619 \r
 620         xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );\r
 621         vPortResetPrivilege( xRunningPrivileged );\r
 622         return xReturn;\r
 623 }\r
 624 /*-----------------------------------------------------------*/\r
 625 \r
 626 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait )\r
 627 {\r
 628 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 629 BaseType_t xReturn;\r
 630 \r
 631         xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );\r
 632         vPortResetPrivilege( xRunningPrivileged );\r
 633         return xReturn;\r
 634 }\r
 635 /*-----------------------------------------------------------*/\r
 636 \r
 637 TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore )\r
 638 {\r
 639 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 640 void * xReturn;\r
 641 \r
 642         xReturn = xQueueGetMutexHolder( xSemaphore );\r
 643         vPortResetPrivilege( xRunningPrivileged );\r
 644         return xReturn;\r
 645 }\r
 646 /*-----------------------------------------------------------*/\r
 647 \r
 648 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 649         QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType )\r
 650         {\r
 651         QueueHandle_t xReturn;\r
 652         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 653 \r
 654                 xReturn = xQueueCreateMutex( ucQueueType );\r
 655                 vPortResetPrivilege( xRunningPrivileged );\r
 656                 return xReturn;\r
 657         }\r
 658 #endif\r
 659 /*-----------------------------------------------------------*/\r
 660 \r
 661 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 662         QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue )\r
 663         {\r
 664         QueueHandle_t xReturn;\r
 665         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 666 \r
 667                 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );\r
 668                 vPortResetPrivilege( xRunningPrivileged );\r
 669                 return xReturn;\r
 670         }\r
 671 #endif\r
 672 /*-----------------------------------------------------------*/\r
 673 \r
 674 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 675         QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue, UBaseType_t uxInitialCount )\r
 676         {\r
 677         QueueHandle_t xReturn;\r
 678         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 679 \r
 680                 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );\r
 681                 vPortResetPrivilege( xRunningPrivileged );\r
 682                 return xReturn;\r
 683         }\r
 684 #endif\r
 685 /*-----------------------------------------------------------*/\r
 686 \r
 687 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 688 \r
 689         QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue )\r
 690         {\r
 691         QueueHandle_t xReturn;\r
 692         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 693 \r
 694                 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );\r
 695                 vPortResetPrivilege( xRunningPrivileged );\r
 696                 return xReturn;\r
 697         }\r
 698 #endif\r
 699 /*-----------------------------------------------------------*/\r
 700 \r
 701 #if ( configUSE_RECURSIVE_MUTEXES == 1 )\r
 702         BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xBlockTime )\r
 703         {\r
 704         BaseType_t xReturn;\r
 705         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 706 \r
 707                 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );\r
 708                 vPortResetPrivilege( xRunningPrivileged );\r
 709                 return xReturn;\r
 710         }\r
 711 #endif\r
 712 /*-----------------------------------------------------------*/\r
 713 \r
 714 #if ( configUSE_RECURSIVE_MUTEXES == 1 )\r
 715         BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex )\r
 716         {\r
 717         BaseType_t xReturn;\r
 718         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 719 \r
 720                 xReturn = xQueueGiveMutexRecursive( xMutex );\r
 721                 vPortResetPrivilege( xRunningPrivileged );\r
 722                 return xReturn;\r
 723         }\r
 724 #endif\r
 725 /*-----------------------------------------------------------*/\r
 726 \r
 727 #if( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 728         QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength )\r
 729         {\r
 730         QueueSetHandle_t xReturn;\r
 731         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 732 \r
 733                 xReturn = xQueueCreateSet( uxEventQueueLength );\r
 734                 vPortResetPrivilege( xRunningPrivileged );\r
 735                 return xReturn;\r
 736         }\r
 737 #endif\r
 738 /*-----------------------------------------------------------*/\r
 739 \r
 740 #if ( configUSE_QUEUE_SETS == 1 )\r
 741         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, TickType_t xBlockTimeTicks )\r
 742         {\r
 743         QueueSetMemberHandle_t xReturn;\r
 744         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 745 \r
 746                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );\r
 747                 vPortResetPrivilege( xRunningPrivileged );\r
 748                 return xReturn;\r
 749         }\r
 750 #endif\r
 751 /*-----------------------------------------------------------*/\r
 752 \r
 753 #if ( configUSE_QUEUE_SETS == 1 )\r
 754         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )\r
 755         {\r
 756         BaseType_t xReturn;\r
 757         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 758 \r
 759                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );\r
 760                 vPortResetPrivilege( xRunningPrivileged );\r
 761                 return xReturn;\r
 762         }\r
 763 #endif\r
 764 /*-----------------------------------------------------------*/\r
 765 \r
 766 #if ( configUSE_QUEUE_SETS == 1 )\r
 767         BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )\r
 768         {\r
 769         BaseType_t xReturn;\r
 770         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 771 \r
 772                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );\r
 773                 vPortResetPrivilege( xRunningPrivileged );\r
 774                 return xReturn;\r
 775         }\r
 776 #endif\r
 777 /*-----------------------------------------------------------*/\r
 778 \r
 779 #if configQUEUE_REGISTRY_SIZE > 0\r
 780         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName )\r
 781         {\r
 782         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 783 \r
 784                 vQueueAddToRegistry( xQueue, pcName );\r
 785 \r
 786                 vPortResetPrivilege( xRunningPrivileged );\r
 787         }\r
 788 #endif\r
 789 /*-----------------------------------------------------------*/\r
 790 \r
 791 #if configQUEUE_REGISTRY_SIZE > 0\r
 792         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue )\r
 793         {\r
 794         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 795 \r
 796                 vQueueUnregisterQueue( xQueue );\r
 797 \r
 798                 vPortResetPrivilege( xRunningPrivileged );\r
 799         }\r
 800 #endif\r
 801 /*-----------------------------------------------------------*/\r
 802 \r
 803 #if configQUEUE_REGISTRY_SIZE > 0\r
 804         const char *MPU_pcQueueGetName( QueueHandle_t xQueue )\r
 805         {\r
 806         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 807         const char *pcReturn;\r
 808 \r
 809                 pcReturn = pcQueueGetName( xQueue );\r
 810 \r
 811                 vPortResetPrivilege( xRunningPrivileged );\r
 812                 return pcReturn;\r
 813         }\r
 814 #endif\r
 815 /*-----------------------------------------------------------*/\r
 816 \r
 817 void MPU_vQueueDelete( QueueHandle_t xQueue )\r
 818 {\r
 819 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 820 \r
 821         vQueueDelete( xQueue );\r
 822 \r
 823         vPortResetPrivilege( xRunningPrivileged );\r
 824 }\r
 825 /*-----------------------------------------------------------*/\r
 826 \r
 827 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 828         void *MPU_pvPortMalloc( size_t xSize )\r
 829         {\r
 830         void *pvReturn;\r
 831         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 832 \r
 833                 pvReturn = pvPortMalloc( xSize );\r
 834 \r
 835                 vPortResetPrivilege( xRunningPrivileged );\r
 836 \r
 837                 return pvReturn;\r
 838         }\r
 839 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 840 /*-----------------------------------------------------------*/\r
 841 \r
 842 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 843         void MPU_vPortFree( void *pv )\r
 844         {\r
 845         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 846 \r
 847                 vPortFree( pv );\r
 848 \r
 849                 vPortResetPrivilege( xRunningPrivileged );\r
 850         }\r
 851 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 852 /*-----------------------------------------------------------*/\r
 853 \r
 854 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 855         void MPU_vPortInitialiseBlocks( void )\r
 856         {\r
 857         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 858 \r
 859                 vPortInitialiseBlocks();\r
 860 \r
 861                 vPortResetPrivilege( xRunningPrivileged );\r
 862         }\r
 863 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 864 /*-----------------------------------------------------------*/\r
 865 \r
 866 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 867         size_t MPU_xPortGetFreeHeapSize( void )\r
 868         {\r
 869         size_t xReturn;\r
 870         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 871 \r
 872                 xReturn = xPortGetFreeHeapSize();\r
 873 \r
 874                 vPortResetPrivilege( xRunningPrivileged );\r
 875 \r
 876                 return xReturn;\r
 877         }\r
 878 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 879 /*-----------------------------------------------------------*/\r
 880 \r
 881 #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 882         TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction )\r
 883         {\r
 884         TimerHandle_t xReturn;\r
 885         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 886 \r
 887                 xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );\r
 888                 vPortResetPrivilege( xRunningPrivileged );\r
 889 \r
 890                 return xReturn;\r
 891         }\r
 892 #endif\r
 893 /*-----------------------------------------------------------*/\r
 894 \r
 895 #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 896         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
 897         {\r
 898         TimerHandle_t xReturn;\r
 899         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 900 \r
 901                 xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );\r
 902                 vPortResetPrivilege( xRunningPrivileged );\r
 903 \r
 904                 return xReturn;\r
 905         }\r
 906 #endif\r
 907 /*-----------------------------------------------------------*/\r
 908 \r
 909 #if( configUSE_TIMERS == 1 )\r
 910         void *MPU_pvTimerGetTimerID( const TimerHandle_t xTimer )\r
 911         {\r
 912         void * pvReturn;\r
 913         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 914 \r
 915                 pvReturn = pvTimerGetTimerID( xTimer );\r
 916                 vPortResetPrivilege( xRunningPrivileged );\r
 917 \r
 918                 return pvReturn;\r
 919         }\r
 920 #endif\r
 921 /*-----------------------------------------------------------*/\r
 922 \r
 923 #if( configUSE_TIMERS == 1 )\r
 924         void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID )\r
 925         {\r
 926         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 927 \r
 928                 vTimerSetTimerID( xTimer, pvNewID );\r
 929                 vPortResetPrivilege( xRunningPrivileged );\r
 930         }\r
 931 #endif\r
 932 /*-----------------------------------------------------------*/\r
 933 \r
 934 #if( configUSE_TIMERS == 1 )\r
 935         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer )\r
 936         {\r
 937         BaseType_t xReturn;\r
 938         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 939 \r
 940                 xReturn = xTimerIsTimerActive( xTimer );\r
 941                 vPortResetPrivilege( xRunningPrivileged );\r
 942 \r
 943                 return xReturn;\r
 944         }\r
 945 #endif\r
 946 /*-----------------------------------------------------------*/\r
 947 \r
 948 #if( configUSE_TIMERS == 1 )\r
 949         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void )\r
 950         {\r
 951         TaskHandle_t xReturn;\r
 952         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 953 \r
 954                 xReturn = xTimerGetTimerDaemonTaskHandle();\r
 955                 vPortResetPrivilege( xRunningPrivileged );\r
 956 \r
 957                 return xReturn;\r
 958         }\r
 959 #endif\r
 960 /*-----------------------------------------------------------*/\r
 961 \r
 962 #if( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 963         BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait )\r
 964         {\r
 965         BaseType_t xReturn;\r
 966         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 967 \r
 968                 xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );\r
 969                 vPortResetPrivilege( xRunningPrivileged );\r
 970 \r
 971                 return xReturn;\r
 972         }\r
 973 #endif\r
 974 /*-----------------------------------------------------------*/\r
 975 \r
 976 #if( configUSE_TIMERS == 1 )\r
 977         void MPU_vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload )\r
 978         {\r
 979         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 980 \r
 981                 vTimerSetReloadMode( xTimer, uxAutoReload );\r
 982                 vPortResetPrivilege( xRunningPrivileged );\r
 983         }\r
 984 #endif\r
 985 /*-----------------------------------------------------------*/\r
 986 \r
 987 #if( configUSE_TIMERS == 1 )\r
 988         const char * MPU_pcTimerGetName( TimerHandle_t xTimer )\r
 989         {\r
 990         const char * pcReturn;\r
 991         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 992 \r
 993                 pcReturn = pcTimerGetName( xTimer );\r
 994                 vPortResetPrivilege( xRunningPrivileged );\r
 995 \r
 996                 return pcReturn;\r
 997         }\r
 998 #endif\r
 999 /*-----------------------------------------------------------*/\r
1000 \r
1001 #if( configUSE_TIMERS == 1 )\r
1002         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer )\r
1003         {\r
1004         TickType_t xReturn;\r
1005         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1006 \r
1007                 xReturn = xTimerGetPeriod( xTimer );\r
1008                 vPortResetPrivilege( xRunningPrivileged );\r
1009 \r
1010                 return xReturn;\r
1011         }\r
1012 #endif\r
1013 /*-----------------------------------------------------------*/\r
1014 \r
1015 #if( configUSE_TIMERS == 1 )\r
1016         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer )\r
1017         {\r
1018         TickType_t xReturn;\r
1019         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1020 \r
1021                 xReturn = xTimerGetExpiryTime( xTimer );\r
1022                 vPortResetPrivilege( xRunningPrivileged );\r
1023 \r
1024                 return xReturn;\r
1025         }\r
1026 #endif\r
1027 /*-----------------------------------------------------------*/\r
1028 \r
1029 #if( configUSE_TIMERS == 1 )\r
1030         BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait )\r
1031         {\r
1032         BaseType_t xReturn;\r
1033         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1034 \r
1035                 xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );\r
1036                 vPortResetPrivilege( xRunningPrivileged );\r
1037 \r
1038                 return xReturn;\r
1039         }\r
1040 #endif\r
1041 /*-----------------------------------------------------------*/\r
1042 \r
1043 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
1044         EventGroupHandle_t MPU_xEventGroupCreate( void )\r
1045         {\r
1046         EventGroupHandle_t xReturn;\r
1047         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1048 \r
1049                 xReturn = xEventGroupCreate();\r
1050                 vPortResetPrivilege( xRunningPrivileged );\r
1051 \r
1052                 return xReturn;\r
1053         }\r
1054 #endif\r
1055 /*-----------------------------------------------------------*/\r
1056 \r
1057 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
1058         EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )\r
1059         {\r
1060         EventGroupHandle_t xReturn;\r
1061         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1062 \r
1063                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );\r
1064                 vPortResetPrivilege( xRunningPrivileged );\r
1065 \r
1066                 return xReturn;\r
1067         }\r
1068 #endif\r
1069 /*-----------------------------------------------------------*/\r
1070 \r
1071 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )\r
1072 {\r
1073 EventBits_t xReturn;\r
1074 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1075 \r
1076         xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );\r
1077         vPortResetPrivilege( xRunningPrivileged );\r
1078 \r
1079         return xReturn;\r
1080 }\r
1081 /*-----------------------------------------------------------*/\r
1082 \r
1083 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )\r
1084 {\r
1085 EventBits_t xReturn;\r
1086 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1087 \r
1088         xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );\r
1089         vPortResetPrivilege( xRunningPrivileged );\r
1090 \r
1091         return xReturn;\r
1092 }\r
1093 /*-----------------------------------------------------------*/\r
1094 \r
1095 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )\r
1096 {\r
1097 EventBits_t xReturn;\r
1098 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1099 \r
1100         xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );\r
1101         vPortResetPrivilege( xRunningPrivileged );\r
1102 \r
1103         return xReturn;\r
1104 }\r
1105 /*-----------------------------------------------------------*/\r
1106 \r
1107 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )\r
1108 {\r
1109 EventBits_t xReturn;\r
1110 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1111 \r
1112         xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );\r
1113         vPortResetPrivilege( xRunningPrivileged );\r
1114 \r
1115         return xReturn;\r
1116 }\r
1117 /*-----------------------------------------------------------*/\r
1118 \r
1119 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup )\r
1120 {\r
1121 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1122 \r
1123         vEventGroupDelete( xEventGroup );\r
1124         vPortResetPrivilege( xRunningPrivileged );\r
1125 }\r
1126 /*-----------------------------------------------------------*/\r
1127 \r
1128 size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, TickType_t xTicksToWait )\r
1129 {\r
1130 size_t xReturn;\r
1131 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1132 \r
1133         xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );\r
1134         vPortResetPrivilege( xRunningPrivileged );\r
1135 \r
1136         return xReturn;\r
1137 }\r
1138 /*-----------------------------------------------------------*/\r
1139 \r
1140 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer )\r
1141 {\r
1142 size_t xReturn;\r
1143 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1144 \r
1145         xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );\r
1146         vPortResetPrivilege( xRunningPrivileged );\r
1147 \r
1148         return xReturn;\r
1149 }\r
1150 /*-----------------------------------------------------------*/\r
1151 \r
1152 size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, TickType_t xTicksToWait )\r
1153 {\r
1154 size_t xReturn;\r
1155 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1156 \r
1157         xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );\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