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