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

   1 /*\r
   2     FreeRTOS V9.0.0rc2 - Copyright (C) 2016 Real Time Engineers Ltd.\r
   3     All rights reserved\r
   4 \r
   5     VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
   6 \r
   7     This file is part of the FreeRTOS distribution.\r
   8 \r
   9     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  10     the terms of the GNU General Public License (version 2) as published by the\r
  11     Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.\r
  12 \r
  13     ***************************************************************************\r
  14     >>!   NOTE: The modification to the GPL is included to allow you to     !<<\r
  15     >>!   distribute a combined work that includes FreeRTOS without being   !<<\r
  16     >>!   obliged to provide the source code for proprietary components     !<<\r
  17     >>!   outside of the FreeRTOS kernel.                                   !<<\r
  18     ***************************************************************************\r
  19 \r
  20     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
  21     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
  22     FOR A PARTICULAR PURPOSE.  Full license text is available on the following\r
  23     link: http://www.freertos.org/a00114.html\r
  24 \r
  25     ***************************************************************************\r
  26      *                                                                       *\r
  27      *    FreeRTOS provides completely free yet professionally developed,    *\r
  28      *    robust, strictly quality controlled, supported, and cross          *\r
  29      *    platform software that is more than just the market leader, it     *\r
  30      *    is the industry's de facto standard.                               *\r
  31      *                                                                       *\r
  32      *    Help yourself get started quickly while simultaneously helping     *\r
  33      *    to support the FreeRTOS project by purchasing a FreeRTOS           *\r
  34      *    tutorial book, reference manual, or both:                          *\r
  35      *    http://www.FreeRTOS.org/Documentation                              *\r
  36      *                                                                       *\r
  37     ***************************************************************************\r
  38 \r
  39     http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading\r
  40     the FAQ page "My application does not run, what could be wrong?".  Have you\r
  41     defined configASSERT()?\r
  42 \r
  43     http://www.FreeRTOS.org/support - In return for receiving this top quality\r
  44     embedded software for free we request you assist our global community by\r
  45     participating in the support forum.\r
  46 \r
  47     http://www.FreeRTOS.org/training - Investing in training allows your team to\r
  48     be as productive as possible as early as possible.  Now you can receive\r
  49     FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers\r
  50     Ltd, and the world's leading authority on the world's leading RTOS.\r
  51 \r
  52     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
  53     including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
  54     compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
  55 \r
  56     http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
  57     Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
  58 \r
  59     http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High\r
  60     Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS\r
  61     licenses offer ticketed support, indemnification and commercial middleware.\r
  62 \r
  63     http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
  64     engineered and independently SIL3 certified version for use in safety and\r
  65     mission critical applications that require provable dependability.\r
  66 \r
  67     1 tab == 4 spaces!\r
  68 */\r
  69 \r
  70 /*\r
  71  * Implementation of the wrapper functions used to raise the processor privilege\r
  72  * before calling a standard FreeRTOS API function.\r
  73  */\r
  74 \r
  75 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining\r
  76 all the API functions to use the MPU wrappers.  That should only be done when\r
  77 task.h is included from an application file. */\r
  78 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE\r
  79 \r
  80 /* Scheduler includes. */\r
  81 #include "FreeRTOS.h"\r
  82 #include "task.h"\r
  83 #include "queue.h"\r
  84 #include "timers.h"\r
  85 #include "event_groups.h"\r
  86 #include "mpu_prototypes.h"\r
  87 \r
  88 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE\r
  89 \r
  90 /*\r
  91  * Checks to see if being called from the context of an unprivileged task, and\r
  92  * if so raises the privilege level and returns false - otherwise does nothing\r
  93  * other than return true.\r
  94  */\r
  95 extern BaseType_t xPortRaisePrivilege( void );\r
  96 \r
  97 /*-----------------------------------------------------------*/\r
  98 \r
  99 BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )\r
 100 {\r
 101 BaseType_t xReturn;\r
 102 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 103 \r
 104         xReturn = xTaskCreateRestricted( pxTaskDefinition, pxCreatedTask );\r
 105         vPortResetPrivilege( xRunningPrivileged );\r
 106         return xReturn;\r
 107 }\r
 108 /*-----------------------------------------------------------*/\r
 109 \r
 110 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 111         BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode, const char * const pcName, uint16_t usStackDepth, void *pvParameters, UBaseType_t uxPriority, TaskHandle_t *pxCreatedTask )\r
 112         {\r
 113         BaseType_t xReturn;\r
 114         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 115 \r
 116                 xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );\r
 117                 vPortResetPrivilege( xRunningPrivileged );\r
 118                 return xReturn;\r
 119         }\r
 120 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 121 /*-----------------------------------------------------------*/\r
 122 \r
 123 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 124         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
 125         {\r
 126         TaskHandle_t xReturn;\r
 127         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 128 \r
 129                 xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );\r
 130                 vPortResetPrivilege( xRunningPrivileged );\r
 131                 return xReturn;\r
 132         }\r
 133 #endif /* configSUPPORT_STATIC_ALLOCATION */\r
 134 /*-----------------------------------------------------------*/\r
 135 \r
 136 void MPU_vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const xRegions )\r
 137 {\r
 138 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 139 \r
 140         vTaskAllocateMPURegions( xTask, xRegions );\r
 141         vPortResetPrivilege( xRunningPrivileged );\r
 142 }\r
 143 /*-----------------------------------------------------------*/\r
 144 \r
 145 #if ( INCLUDE_vTaskDelete == 1 )\r
 146         void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete )\r
 147         {\r
 148         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 149 \r
 150                 vTaskDelete( pxTaskToDelete );\r
 151                 vPortResetPrivilege( xRunningPrivileged );\r
 152         }\r
 153 #endif\r
 154 /*-----------------------------------------------------------*/\r
 155 \r
 156 #if ( INCLUDE_vTaskDelayUntil == 1 )\r
 157         void MPU_vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, TickType_t xTimeIncrement )\r
 158         {\r
 159         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 160 \r
 161                 vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );\r
 162                 vPortResetPrivilege( xRunningPrivileged );\r
 163         }\r
 164 #endif\r
 165 /*-----------------------------------------------------------*/\r
 166 \r
 167 #if ( INCLUDE_xTaskAbortDelay == 1 )\r
 168         BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask )\r
 169         {\r
 170         BaseType_t xReturn;\r
 171         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 172 \r
 173                 xReturn = xTaskAbortDelay( xTask );\r
 174                 vPortResetPrivilege( xRunningPrivileged );\r
 175                 return xReturn;\r
 176         }\r
 177 #endif\r
 178 /*-----------------------------------------------------------*/\r
 179 \r
 180 #if ( INCLUDE_vTaskDelay == 1 )\r
 181         void MPU_vTaskDelay( TickType_t xTicksToDelay )\r
 182         {\r
 183         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 184 \r
 185                 vTaskDelay( xTicksToDelay );\r
 186                 vPortResetPrivilege( xRunningPrivileged );\r
 187         }\r
 188 #endif\r
 189 /*-----------------------------------------------------------*/\r
 190 \r
 191 #if ( INCLUDE_uxTaskPriorityGet == 1 )\r
 192         UBaseType_t MPU_uxTaskPriorityGet( TaskHandle_t pxTask )\r
 193         {\r
 194         UBaseType_t uxReturn;\r
 195         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 196 \r
 197                 uxReturn = uxTaskPriorityGet( pxTask );\r
 198                 vPortResetPrivilege( xRunningPrivileged );\r
 199                 return uxReturn;\r
 200         }\r
 201 #endif\r
 202 /*-----------------------------------------------------------*/\r
 203 \r
 204 #if ( INCLUDE_vTaskPrioritySet == 1 )\r
 205         void MPU_vTaskPrioritySet( TaskHandle_t pxTask, UBaseType_t uxNewPriority )\r
 206         {\r
 207         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 208 \r
 209                 vTaskPrioritySet( pxTask, uxNewPriority );\r
 210                 vPortResetPrivilege( xRunningPrivileged );\r
 211         }\r
 212 #endif\r
 213 /*-----------------------------------------------------------*/\r
 214 \r
 215 #if ( INCLUDE_eTaskGetState == 1 )\r
 216         eTaskState MPU_eTaskGetState( TaskHandle_t pxTask )\r
 217         {\r
 218         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 219         eTaskState eReturn;\r
 220 \r
 221                 eReturn = eTaskGetState( pxTask );\r
 222                 vPortResetPrivilege( xRunningPrivileged );\r
 223                 return eReturn;\r
 224         }\r
 225 #endif\r
 226 /*-----------------------------------------------------------*/\r
 227 \r
 228 #if( configUSE_TRACE_FACILITY == 1 )\r
 229         void MPU_vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState )\r
 230         {\r
 231         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 232 \r
 233                 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );\r
 234                 vPortResetPrivilege( xRunningPrivileged );\r
 235         }\r
 236 #endif\r
 237 /*-----------------------------------------------------------*/\r
 238 \r
 239 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )\r
 240         TaskHandle_t MPU_xTaskGetIdleTaskHandle( void )\r
 241         {\r
 242         TaskHandle_t xReturn;\r
 243         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 244 \r
 245                 xReturn = xTaskGetIdleTaskHandle();\r
 246                 vPortResetPrivilege( xRunningPrivileged );\r
 247                 return xReturn;\r
 248         }\r
 249 #endif\r
 250 /*-----------------------------------------------------------*/\r
 251 \r
 252 #if ( INCLUDE_vTaskSuspend == 1 )\r
 253         void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend )\r
 254         {\r
 255         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 256 \r
 257                 vTaskSuspend( pxTaskToSuspend );\r
 258                 vPortResetPrivilege( xRunningPrivileged );\r
 259         }\r
 260 #endif\r
 261 /*-----------------------------------------------------------*/\r
 262 \r
 263 #if ( INCLUDE_vTaskSuspend == 1 )\r
 264         void MPU_vTaskResume( TaskHandle_t pxTaskToResume )\r
 265         {\r
 266         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 267 \r
 268                 vTaskResume( pxTaskToResume );\r
 269                 vPortResetPrivilege( xRunningPrivileged );\r
 270         }\r
 271 #endif\r
 272 /*-----------------------------------------------------------*/\r
 273 \r
 274 void MPU_vTaskSuspendAll( void )\r
 275 {\r
 276 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 277 \r
 278         vTaskSuspendAll();\r
 279         vPortResetPrivilege( xRunningPrivileged );\r
 280 }\r
 281 /*-----------------------------------------------------------*/\r
 282 \r
 283 BaseType_t MPU_xTaskResumeAll( void )\r
 284 {\r
 285 BaseType_t xReturn;\r
 286 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 287 \r
 288         xReturn = xTaskResumeAll();\r
 289         vPortResetPrivilege( xRunningPrivileged );\r
 290         return xReturn;\r
 291 }\r
 292 /*-----------------------------------------------------------*/\r
 293 \r
 294 TickType_t MPU_xTaskGetTickCount( void )\r
 295 {\r
 296 TickType_t xReturn;\r
 297 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 298 \r
 299         xReturn = xTaskGetTickCount();\r
 300         vPortResetPrivilege( xRunningPrivileged );\r
 301         return xReturn;\r
 302 }\r
 303 /*-----------------------------------------------------------*/\r
 304 \r
 305 UBaseType_t MPU_uxTaskGetNumberOfTasks( void )\r
 306 {\r
 307 UBaseType_t uxReturn;\r
 308 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 309 \r
 310         uxReturn = uxTaskGetNumberOfTasks();\r
 311         vPortResetPrivilege( xRunningPrivileged );\r
 312         return uxReturn;\r
 313 }\r
 314 /*-----------------------------------------------------------*/\r
 315 \r
 316 char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery )\r
 317 {\r
 318 char *pcReturn;\r
 319 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 320 \r
 321         pcReturn = pcTaskGetName( xTaskToQuery );\r
 322         vPortResetPrivilege( xRunningPrivileged );\r
 323         return pcReturn;\r
 324 }\r
 325 /*-----------------------------------------------------------*/\r
 326 \r
 327 #if ( INCLUDE_xTaskGetHandle == 1 )\r
 328         TaskHandle_t MPU_xTaskGetHandle( const char *pcNameToQuery )\r
 329         {\r
 330         TaskHandle_t xReturn;\r
 331         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 332 \r
 333                 xReturn = xTaskGetHandle( pcNameToQuery );\r
 334                 vPortResetPrivilege( xRunningPrivileged );\r
 335                 return xReturn;\r
 336         }\r
 337 #endif\r
 338 /*-----------------------------------------------------------*/\r
 339 \r
 340 #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )\r
 341         void MPU_vTaskList( char *pcWriteBuffer )\r
 342         {\r
 343         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 344 \r
 345                 vTaskList( pcWriteBuffer );\r
 346                 vPortResetPrivilege( xRunningPrivileged );\r
 347         }\r
 348 #endif\r
 349 /*-----------------------------------------------------------*/\r
 350 \r
 351 #if ( configGENERATE_RUN_TIME_STATS == 1 )\r
 352         void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer )\r
 353         {\r
 354         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 355 \r
 356                 vTaskGetRunTimeStats( pcWriteBuffer );\r
 357                 vPortResetPrivilege( xRunningPrivileged );\r
 358         }\r
 359 #endif\r
 360 /*-----------------------------------------------------------*/\r
 361 \r
 362 #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 363         void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxTagValue )\r
 364         {\r
 365         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 366 \r
 367                 vTaskSetApplicationTaskTag( xTask, pxTagValue );\r
 368                 vPortResetPrivilege( xRunningPrivileged );\r
 369         }\r
 370 #endif\r
 371 /*-----------------------------------------------------------*/\r
 372 \r
 373 #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 374         TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask )\r
 375         {\r
 376         TaskHookFunction_t xReturn;\r
 377         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 378 \r
 379                 xReturn = xTaskGetApplicationTaskTag( xTask );\r
 380                 vPortResetPrivilege( xRunningPrivileged );\r
 381                 return xReturn;\r
 382         }\r
 383 #endif\r
 384 /*-----------------------------------------------------------*/\r
 385 \r
 386 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
 387         void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue )\r
 388         {\r
 389         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 390 \r
 391                 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );\r
 392                 vPortResetPrivilege( xRunningPrivileged );\r
 393         }\r
 394 #endif\r
 395 /*-----------------------------------------------------------*/\r
 396 \r
 397 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
 398         void *MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex )\r
 399         {\r
 400         void *pvReturn;\r
 401         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 402 \r
 403                 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );\r
 404                 vPortResetPrivilege( xRunningPrivileged );\r
 405                 return pvReturn;\r
 406         }\r
 407 #endif\r
 408 /*-----------------------------------------------------------*/\r
 409 \r
 410 #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 411         BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter )\r
 412         {\r
 413         BaseType_t xReturn;\r
 414         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 415 \r
 416                 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );\r
 417                 vPortResetPrivilege( xRunningPrivileged );\r
 418                 return xReturn;\r
 419         }\r
 420 #endif\r
 421 /*-----------------------------------------------------------*/\r
 422 \r
 423 #if ( configUSE_TRACE_FACILITY == 1 )\r
 424         UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t *pxTaskStatusArray, UBaseType_t uxArraySize, uint32_t *pulTotalRunTime )\r
 425         {\r
 426         UBaseType_t uxReturn;\r
 427         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 428 \r
 429                 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );\r
 430                 vPortResetPrivilege( xRunningPrivileged );\r
 431                 return uxReturn;\r
 432         }\r
 433 #endif\r
 434 /*-----------------------------------------------------------*/\r
 435 \r
 436 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )\r
 437         UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask )\r
 438         {\r
 439         UBaseType_t uxReturn;\r
 440         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 441 \r
 442                 uxReturn = uxTaskGetStackHighWaterMark( 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_xQueueGenericReceive( QueueHandle_t pxQueue, void * const pvBuffer, TickType_t xTicksToWait, BaseType_t xJustPeeking )\r
 618 {\r
 619 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 620 BaseType_t xReturn;\r
 621 \r
 622         xReturn = xQueueGenericReceive( pxQueue, pvBuffer, xTicksToWait, xJustPeeking );\r
 623         vPortResetPrivilege( xRunningPrivileged );\r
 624         return xReturn;\r
 625 }\r
 626 /*-----------------------------------------------------------*/\r
 627 \r
 628 BaseType_t MPU_xQueuePeekFromISR( QueueHandle_t pxQueue, void * const pvBuffer )\r
 629 {\r
 630 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 631 BaseType_t xReturn;\r
 632 \r
 633         xReturn = xQueuePeekFromISR( pxQueue, pvBuffer );\r
 634         vPortResetPrivilege( xRunningPrivileged );\r
 635         return xReturn;\r
 636 }\r
 637 /*-----------------------------------------------------------*/\r
 638 \r
 639 void* MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore )\r
 640 {\r
 641 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 642 void * xReturn;\r
 643 \r
 644         xReturn = ( void * ) xQueueGetMutexHolder( xSemaphore );\r
 645         vPortResetPrivilege( xRunningPrivileged );\r
 646         return xReturn;\r
 647 }\r
 648 /*-----------------------------------------------------------*/\r
 649 \r
 650 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 651         QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType )\r
 652         {\r
 653         QueueHandle_t xReturn;\r
 654         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 655 \r
 656                 xReturn = xQueueCreateMutex( ucQueueType );\r
 657                 vPortResetPrivilege( xRunningPrivileged );\r
 658                 return xReturn;\r
 659         }\r
 660 #endif\r
 661 /*-----------------------------------------------------------*/\r
 662 \r
 663 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 664         QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue )\r
 665         {\r
 666         QueueHandle_t xReturn;\r
 667         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 668 \r
 669                 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );\r
 670                 vPortResetPrivilege( xRunningPrivileged );\r
 671                 return xReturn;\r
 672         }\r
 673 #endif\r
 674 /*-----------------------------------------------------------*/\r
 675 \r
 676 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 677         QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue, UBaseType_t uxInitialCount )\r
 678         {\r
 679         QueueHandle_t xReturn;\r
 680         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 681 \r
 682                 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );\r
 683                 vPortResetPrivilege( xRunningPrivileged );\r
 684                 return xReturn;\r
 685         }\r
 686 #endif\r
 687 /*-----------------------------------------------------------*/\r
 688 \r
 689 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 690 \r
 691         QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue )\r
 692         {\r
 693         QueueHandle_t xReturn;\r
 694         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 695 \r
 696                 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );\r
 697                 vPortResetPrivilege( xRunningPrivileged );\r
 698                 return xReturn;\r
 699         }\r
 700 #endif\r
 701 /*-----------------------------------------------------------*/\r
 702 \r
 703 #if ( configUSE_MUTEXES == 1 )\r
 704         BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xBlockTime )\r
 705         {\r
 706         BaseType_t xReturn;\r
 707         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 708 \r
 709                 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );\r
 710                 vPortResetPrivilege( xRunningPrivileged );\r
 711                 return xReturn;\r
 712         }\r
 713 #endif\r
 714 /*-----------------------------------------------------------*/\r
 715 \r
 716 #if ( configUSE_MUTEXES == 1 )\r
 717         BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex )\r
 718         {\r
 719         BaseType_t xReturn;\r
 720         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 721 \r
 722                 xReturn = xQueueGiveMutexRecursive( xMutex );\r
 723                 vPortResetPrivilege( xRunningPrivileged );\r
 724                 return xReturn;\r
 725         }\r
 726 #endif\r
 727 /*-----------------------------------------------------------*/\r
 728 \r
 729 #if ( configUSE_QUEUE_SETS == 1 )\r
 730         QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength )\r
 731         {\r
 732         QueueSetHandle_t xReturn;\r
 733         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 734 \r
 735                 xReturn = xQueueCreateSet( uxEventQueueLength );\r
 736                 vPortResetPrivilege( xRunningPrivileged );\r
 737                 return xReturn;\r
 738         }\r
 739 #endif\r
 740 /*-----------------------------------------------------------*/\r
 741 \r
 742 #if ( configUSE_QUEUE_SETS == 1 )\r
 743         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, TickType_t xBlockTimeTicks )\r
 744         {\r
 745         QueueSetMemberHandle_t xReturn;\r
 746         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 747 \r
 748                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );\r
 749                 vPortResetPrivilege( xRunningPrivileged );\r
 750                 return xReturn;\r
 751         }\r
 752 #endif\r
 753 /*-----------------------------------------------------------*/\r
 754 \r
 755 #if ( configUSE_QUEUE_SETS == 1 )\r
 756         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )\r
 757         {\r
 758         BaseType_t xReturn;\r
 759         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 760 \r
 761                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );\r
 762                 vPortResetPrivilege( xRunningPrivileged );\r
 763                 return xReturn;\r
 764         }\r
 765 #endif\r
 766 /*-----------------------------------------------------------*/\r
 767 \r
 768 #if ( configUSE_QUEUE_SETS == 1 )\r
 769         BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )\r
 770         {\r
 771         BaseType_t xReturn;\r
 772         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 773 \r
 774                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );\r
 775                 vPortResetPrivilege( xRunningPrivileged );\r
 776                 return xReturn;\r
 777         }\r
 778 #endif\r
 779 /*-----------------------------------------------------------*/\r
 780 \r
 781 #if configQUEUE_REGISTRY_SIZE > 0\r
 782         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName )\r
 783         {\r
 784         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 785 \r
 786                 vQueueAddToRegistry( xQueue, pcName );\r
 787 \r
 788                 vPortResetPrivilege( xRunningPrivileged );\r
 789         }\r
 790 #endif\r
 791 /*-----------------------------------------------------------*/\r
 792 \r
 793 #if configQUEUE_REGISTRY_SIZE > 0\r
 794         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue )\r
 795         {\r
 796         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 797 \r
 798                 vQueueUnregisterQueue( xQueue );\r
 799 \r
 800                 vPortResetPrivilege( xRunningPrivileged );\r
 801         }\r
 802 #endif\r
 803 /*-----------------------------------------------------------*/\r
 804 \r
 805 #if configQUEUE_REGISTRY_SIZE > 0\r
 806         const char *MPU_pcQueueGetName( QueueHandle_t xQueue )\r
 807         {\r
 808         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 809         const char *pcReturn;\r
 810 \r
 811                 pcReturn = pcQueueGetName( xQueue );\r
 812 \r
 813                 vPortResetPrivilege( xRunningPrivileged );\r
 814                 return pcReturn;\r
 815         }\r
 816 #endif\r
 817 /*-----------------------------------------------------------*/\r
 818 \r
 819 void MPU_vQueueDelete( QueueHandle_t xQueue )\r
 820 {\r
 821 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 822 \r
 823         vQueueDelete( xQueue );\r
 824 \r
 825         vPortResetPrivilege( xRunningPrivileged );\r
 826 }\r
 827 /*-----------------------------------------------------------*/\r
 828 \r
 829 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 830 \r
 831         void *MPU_pvPortMalloc( size_t xSize )\r
 832         {\r
 833         void *pvReturn;\r
 834         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 835 \r
 836                 pvReturn = pvPortMalloc( xSize );\r
 837 \r
 838                 vPortResetPrivilege( xRunningPrivileged );\r
 839 \r
 840                 return pvReturn;\r
 841         }\r
 842 \r
 843 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 844 /*-----------------------------------------------------------*/\r
 845 \r
 846 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 847 \r
 848         void MPU_vPortFree( void *pv )\r
 849         {\r
 850         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 851 \r
 852                 vPortFree( pv );\r
 853 \r
 854                 vPortResetPrivilege( xRunningPrivileged );\r
 855         }\r
 856 \r
 857 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 858 /*-----------------------------------------------------------*/\r
 859 \r
 860 void MPU_vPortInitialiseBlocks( void )\r
 861 {\r
 862 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 863 \r
 864         vPortInitialiseBlocks();\r
 865 \r
 866         vPortResetPrivilege( xRunningPrivileged );\r
 867 }\r
 868 /*-----------------------------------------------------------*/\r
 869 \r
 870 size_t MPU_xPortGetFreeHeapSize( void )\r
 871 {\r
 872 size_t xReturn;\r
 873 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 874 \r
 875         xReturn = xPortGetFreeHeapSize();\r
 876 \r
 877         vPortResetPrivilege( xRunningPrivileged );\r
 878 \r
 879         return xReturn;\r
 880 }\r
 881 /*-----------------------------------------------------------*/\r
 882 \r
 883 #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 884         TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction )\r
 885         {\r
 886         TimerHandle_t xReturn;\r
 887         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 888 \r
 889                 xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );\r
 890                 vPortResetPrivilege( xRunningPrivileged );\r
 891 \r
 892                 return xReturn;\r
 893         }\r
 894 #endif\r
 895 /*-----------------------------------------------------------*/\r
 896 \r
 897 #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 898         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
 899         {\r
 900         TimerHandle_t xReturn;\r
 901         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 902 \r
 903                 xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );\r
 904                 vPortResetPrivilege( xRunningPrivileged );\r
 905 \r
 906                 return xReturn;\r
 907         }\r
 908 #endif\r
 909 /*-----------------------------------------------------------*/\r
 910 \r
 911 #if( configUSE_TIMERS == 1 )\r
 912         void *MPU_pvTimerGetTimerID( const TimerHandle_t xTimer )\r
 913         {\r
 914         void * pvReturn;\r
 915         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 916 \r
 917                 pvReturn = pvTimerGetTimerID( xTimer );\r
 918                 vPortResetPrivilege( xRunningPrivileged );\r
 919 \r
 920                 return pvReturn;\r
 921         }\r
 922 #endif\r
 923 /*-----------------------------------------------------------*/\r
 924 \r
 925 #if( configUSE_TIMERS == 1 )\r
 926         void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID )\r
 927         {\r
 928         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 929 \r
 930                 vTimerSetTimerID( xTimer, pvNewID );\r
 931                 vPortResetPrivilege( xRunningPrivileged );\r
 932         }\r
 933 #endif\r
 934 /*-----------------------------------------------------------*/\r
 935 \r
 936 #if( configUSE_TIMERS == 1 )\r
 937         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer )\r
 938         {\r
 939         BaseType_t xReturn;\r
 940         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 941 \r
 942                 xReturn = xTimerIsTimerActive( xTimer );\r
 943                 vPortResetPrivilege( xRunningPrivileged );\r
 944 \r
 945                 return xReturn;\r
 946         }\r
 947 #endif\r
 948 /*-----------------------------------------------------------*/\r
 949 \r
 950 #if( configUSE_TIMERS == 1 )\r
 951         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void )\r
 952         {\r
 953         TaskHandle_t xReturn;\r
 954         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 955 \r
 956                 xReturn = xTimerGetTimerDaemonTaskHandle();\r
 957                 vPortResetPrivilege( xRunningPrivileged );\r
 958 \r
 959                 return xReturn;\r
 960         }\r
 961 #endif\r
 962 /*-----------------------------------------------------------*/\r
 963 \r
 964 #if( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 965         BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait )\r
 966         {\r
 967         BaseType_t xReturn;\r
 968         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 969 \r
 970                 xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );\r
 971                 vPortResetPrivilege( xRunningPrivileged );\r
 972 \r
 973                 return xReturn;\r
 974         }\r
 975 #endif\r
 976 /*-----------------------------------------------------------*/\r
 977 \r
 978 #if( configUSE_TIMERS == 1 )\r
 979         const char * MPU_pcTimerGetName( TimerHandle_t xTimer )\r
 980         {\r
 981         const char * pcReturn;\r
 982         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 983 \r
 984                 pcReturn = pcTimerGetName( xTimer );\r
 985                 vPortResetPrivilege( xRunningPrivileged );\r
 986 \r
 987                 return pcReturn;\r
 988         }\r
 989 #endif\r
 990 /*-----------------------------------------------------------*/\r
 991 \r
 992 #if( configUSE_TIMERS == 1 )\r
 993         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer )\r
 994         {\r
 995         TickType_t xReturn;\r
 996         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 997 \r
 998                 xReturn = xTimerGetPeriod( xTimer );\r
 999                 vPortResetPrivilege( xRunningPrivileged );\r
1000 \r
1001                 return xReturn;\r
1002         }\r
1003 #endif\r
1004 /*-----------------------------------------------------------*/\r
1005 \r
1006 #if( configUSE_TIMERS == 1 )\r
1007         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer )\r
1008         {\r
1009         TickType_t xReturn;\r
1010         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1011 \r
1012                 xReturn = xTimerGetExpiryTime( xTimer );\r
1013                 vPortResetPrivilege( xRunningPrivileged );\r
1014 \r
1015                 return xReturn;\r
1016         }\r
1017 #endif\r
1018 /*-----------------------------------------------------------*/\r
1019 \r
1020 #if( configUSE_TIMERS == 1 )\r
1021         BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait )\r
1022         {\r
1023         BaseType_t xReturn;\r
1024         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1025 \r
1026                 xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );\r
1027                 vPortResetPrivilege( xRunningPrivileged );\r
1028 \r
1029                 return xReturn;\r
1030         }\r
1031 #endif\r
1032 /*-----------------------------------------------------------*/\r
1033 \r
1034 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
1035         EventGroupHandle_t MPU_xEventGroupCreate( void )\r
1036         {\r
1037         EventGroupHandle_t xReturn;\r
1038         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1039 \r
1040                 xReturn = xEventGroupCreate();\r
1041                 vPortResetPrivilege( xRunningPrivileged );\r
1042 \r
1043                 return xReturn;\r
1044         }\r
1045 #endif\r
1046 /*-----------------------------------------------------------*/\r
1047 \r
1048 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
1049         EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )\r
1050         {\r
1051         EventGroupHandle_t xReturn;\r
1052         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1053 \r
1054                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );\r
1055                 vPortResetPrivilege( xRunningPrivileged );\r
1056 \r
1057                 return xReturn;\r
1058         }\r
1059 #endif\r
1060 /*-----------------------------------------------------------*/\r
1061 \r
1062 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )\r
1063 {\r
1064 EventBits_t xReturn;\r
1065 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1066 \r
1067         xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );\r
1068         vPortResetPrivilege( xRunningPrivileged );\r
1069 \r
1070         return xReturn;\r
1071 }\r
1072 /*-----------------------------------------------------------*/\r
1073 \r
1074 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )\r
1075 {\r
1076 EventBits_t xReturn;\r
1077 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1078 \r
1079         xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );\r
1080         vPortResetPrivilege( xRunningPrivileged );\r
1081 \r
1082         return xReturn;\r
1083 }\r
1084 /*-----------------------------------------------------------*/\r
1085 \r
1086 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )\r
1087 {\r
1088 EventBits_t xReturn;\r
1089 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1090 \r
1091         xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );\r
1092         vPortResetPrivilege( xRunningPrivileged );\r
1093 \r
1094         return xReturn;\r
1095 }\r
1096 /*-----------------------------------------------------------*/\r
1097 \r
1098 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )\r
1099 {\r
1100 EventBits_t xReturn;\r
1101 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1102 \r
1103         xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );\r
1104         vPortResetPrivilege( xRunningPrivileged );\r
1105 \r
1106         return xReturn;\r
1107 }\r
1108 /*-----------------------------------------------------------*/\r
1109 \r
1110 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup )\r
1111 {\r
1112 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1113 \r
1114         vEventGroupDelete( xEventGroup );\r
1115         vPortResetPrivilege( xRunningPrivileged );\r
1116 }\r
1117 /*-----------------------------------------------------------*/\r
1118 \r
1119 \r
1120 \r
1121 \r
1122 \r
1123 /* Functions that the application writer wants to execute in privileged mode\r
1124 can be defined in application_defined_privileged_functions.h.  The functions\r
1125 must take the same format as those above whereby the privilege state on exit\r
1126 equals the privilege state on entry.  For example:\r
1127 \r
1128 void MPU_FunctionName( [parameters ] )\r
1129 {\r
1130 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1131 \r
1132         FunctionName( [parameters ] );\r
1133 \r
1134         vPortResetPrivilege( xRunningPrivileged );\r
1135 }\r
1136 */\r
1137 \r
1138 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1\r
1139         #include "application_defined_privileged_functions.h"\r
1140 #endif\r