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

   1 /*\r
   2     FreeRTOS V9.0.1 - Copyright (C) 2017 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 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 100         BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )\r
 101         {\r
 102         BaseType_t xReturn;\r
 103         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 104 \r
 105                 xReturn = xTaskCreateRestricted( pxTaskDefinition, pxCreatedTask );\r
 106                 vPortResetPrivilege( xRunningPrivileged );\r
 107                 return xReturn;\r
 108         }\r
 109 #endif /* conifgSUPPORT_DYNAMIC_ALLOCATION */\r
 110 /*-----------------------------------------------------------*/\r
 111 \r
 112 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 113         BaseType_t MPU_xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )\r
 114         {\r
 115         BaseType_t xReturn;\r
 116         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 117 \r
 118                 xReturn = xTaskCreateRestrictedStatic( pxTaskDefinition, pxCreatedTask );\r
 119                 vPortResetPrivilege( xRunningPrivileged );\r
 120                 return xReturn;\r
 121         }\r
 122 #endif /* conifgSUPPORT_DYNAMIC_ALLOCATION */\r
 123 /*-----------------------------------------------------------*/\r
 124 \r
 125 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 126         BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode, const char * const pcName, uint16_t usStackDepth, void *pvParameters, UBaseType_t uxPriority, TaskHandle_t *pxCreatedTask )\r
 127         {\r
 128         BaseType_t xReturn;\r
 129         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 130 \r
 131                 xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );\r
 132                 vPortResetPrivilege( xRunningPrivileged );\r
 133                 return xReturn;\r
 134         }\r
 135 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 136 /*-----------------------------------------------------------*/\r
 137 \r
 138 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 139         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
 140         {\r
 141         TaskHandle_t xReturn;\r
 142         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 143 \r
 144                 xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );\r
 145                 vPortResetPrivilege( xRunningPrivileged );\r
 146                 return xReturn;\r
 147         }\r
 148 #endif /* configSUPPORT_STATIC_ALLOCATION */\r
 149 /*-----------------------------------------------------------*/\r
 150 \r
 151 void MPU_vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const xRegions )\r
 152 {\r
 153 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 154 \r
 155         vTaskAllocateMPURegions( xTask, xRegions );\r
 156         vPortResetPrivilege( xRunningPrivileged );\r
 157 }\r
 158 /*-----------------------------------------------------------*/\r
 159 \r
 160 #if ( INCLUDE_vTaskDelete == 1 )\r
 161         void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete )\r
 162         {\r
 163         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 164 \r
 165                 vTaskDelete( pxTaskToDelete );\r
 166                 vPortResetPrivilege( xRunningPrivileged );\r
 167         }\r
 168 #endif\r
 169 /*-----------------------------------------------------------*/\r
 170 \r
 171 #if ( INCLUDE_vTaskDelayUntil == 1 )\r
 172         void MPU_vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, TickType_t xTimeIncrement )\r
 173         {\r
 174         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 175 \r
 176                 vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );\r
 177                 vPortResetPrivilege( xRunningPrivileged );\r
 178         }\r
 179 #endif\r
 180 /*-----------------------------------------------------------*/\r
 181 \r
 182 #if ( INCLUDE_xTaskAbortDelay == 1 )\r
 183         BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask )\r
 184         {\r
 185         BaseType_t xReturn;\r
 186         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 187 \r
 188                 xReturn = xTaskAbortDelay( xTask );\r
 189                 vPortResetPrivilege( xRunningPrivileged );\r
 190                 return xReturn;\r
 191         }\r
 192 #endif\r
 193 /*-----------------------------------------------------------*/\r
 194 \r
 195 #if ( INCLUDE_vTaskDelay == 1 )\r
 196         void MPU_vTaskDelay( TickType_t xTicksToDelay )\r
 197         {\r
 198         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 199 \r
 200                 vTaskDelay( xTicksToDelay );\r
 201                 vPortResetPrivilege( xRunningPrivileged );\r
 202         }\r
 203 #endif\r
 204 /*-----------------------------------------------------------*/\r
 205 \r
 206 #if ( INCLUDE_uxTaskPriorityGet == 1 )\r
 207         UBaseType_t MPU_uxTaskPriorityGet( TaskHandle_t pxTask )\r
 208         {\r
 209         UBaseType_t uxReturn;\r
 210         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 211 \r
 212                 uxReturn = uxTaskPriorityGet( pxTask );\r
 213                 vPortResetPrivilege( xRunningPrivileged );\r
 214                 return uxReturn;\r
 215         }\r
 216 #endif\r
 217 /*-----------------------------------------------------------*/\r
 218 \r
 219 #if ( INCLUDE_vTaskPrioritySet == 1 )\r
 220         void MPU_vTaskPrioritySet( TaskHandle_t pxTask, UBaseType_t uxNewPriority )\r
 221         {\r
 222         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 223 \r
 224                 vTaskPrioritySet( pxTask, uxNewPriority );\r
 225                 vPortResetPrivilege( xRunningPrivileged );\r
 226         }\r
 227 #endif\r
 228 /*-----------------------------------------------------------*/\r
 229 \r
 230 #if ( INCLUDE_eTaskGetState == 1 )\r
 231         eTaskState MPU_eTaskGetState( TaskHandle_t pxTask )\r
 232         {\r
 233         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 234         eTaskState eReturn;\r
 235 \r
 236                 eReturn = eTaskGetState( pxTask );\r
 237                 vPortResetPrivilege( xRunningPrivileged );\r
 238                 return eReturn;\r
 239         }\r
 240 #endif\r
 241 /*-----------------------------------------------------------*/\r
 242 \r
 243 #if( configUSE_TRACE_FACILITY == 1 )\r
 244         void MPU_vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState )\r
 245         {\r
 246         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 247 \r
 248                 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );\r
 249                 vPortResetPrivilege( xRunningPrivileged );\r
 250         }\r
 251 #endif\r
 252 /*-----------------------------------------------------------*/\r
 253 \r
 254 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )\r
 255         TaskHandle_t MPU_xTaskGetIdleTaskHandle( void )\r
 256         {\r
 257         TaskHandle_t xReturn;\r
 258         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 259 \r
 260                 xReturn = xTaskGetIdleTaskHandle();\r
 261                 vPortResetPrivilege( xRunningPrivileged );\r
 262                 return xReturn;\r
 263         }\r
 264 #endif\r
 265 /*-----------------------------------------------------------*/\r
 266 \r
 267 #if ( INCLUDE_vTaskSuspend == 1 )\r
 268         void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend )\r
 269         {\r
 270         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 271 \r
 272                 vTaskSuspend( pxTaskToSuspend );\r
 273                 vPortResetPrivilege( xRunningPrivileged );\r
 274         }\r
 275 #endif\r
 276 /*-----------------------------------------------------------*/\r
 277 \r
 278 #if ( INCLUDE_vTaskSuspend == 1 )\r
 279         void MPU_vTaskResume( TaskHandle_t pxTaskToResume )\r
 280         {\r
 281         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 282 \r
 283                 vTaskResume( pxTaskToResume );\r
 284                 vPortResetPrivilege( xRunningPrivileged );\r
 285         }\r
 286 #endif\r
 287 /*-----------------------------------------------------------*/\r
 288 \r
 289 void MPU_vTaskSuspendAll( void )\r
 290 {\r
 291 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 292 \r
 293         vTaskSuspendAll();\r
 294         vPortResetPrivilege( xRunningPrivileged );\r
 295 }\r
 296 /*-----------------------------------------------------------*/\r
 297 \r
 298 BaseType_t MPU_xTaskResumeAll( void )\r
 299 {\r
 300 BaseType_t xReturn;\r
 301 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 302 \r
 303         xReturn = xTaskResumeAll();\r
 304         vPortResetPrivilege( xRunningPrivileged );\r
 305         return xReturn;\r
 306 }\r
 307 /*-----------------------------------------------------------*/\r
 308 \r
 309 TickType_t MPU_xTaskGetTickCount( void )\r
 310 {\r
 311 TickType_t xReturn;\r
 312 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 313 \r
 314         xReturn = xTaskGetTickCount();\r
 315         vPortResetPrivilege( xRunningPrivileged );\r
 316         return xReturn;\r
 317 }\r
 318 /*-----------------------------------------------------------*/\r
 319 \r
 320 UBaseType_t MPU_uxTaskGetNumberOfTasks( void )\r
 321 {\r
 322 UBaseType_t uxReturn;\r
 323 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 324 \r
 325         uxReturn = uxTaskGetNumberOfTasks();\r
 326         vPortResetPrivilege( xRunningPrivileged );\r
 327         return uxReturn;\r
 328 }\r
 329 /*-----------------------------------------------------------*/\r
 330 \r
 331 char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery )\r
 332 {\r
 333 char *pcReturn;\r
 334 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 335 \r
 336         pcReturn = pcTaskGetName( xTaskToQuery );\r
 337         vPortResetPrivilege( xRunningPrivileged );\r
 338         return pcReturn;\r
 339 }\r
 340 /*-----------------------------------------------------------*/\r
 341 \r
 342 #if ( INCLUDE_xTaskGetHandle == 1 )\r
 343         TaskHandle_t MPU_xTaskGetHandle( const char *pcNameToQuery )\r
 344         {\r
 345         TaskHandle_t xReturn;\r
 346         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 347 \r
 348                 xReturn = xTaskGetHandle( pcNameToQuery );\r
 349                 vPortResetPrivilege( xRunningPrivileged );\r
 350                 return xReturn;\r
 351         }\r
 352 #endif\r
 353 /*-----------------------------------------------------------*/\r
 354 \r
 355 #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 356         void MPU_vTaskList( char *pcWriteBuffer )\r
 357         {\r
 358         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 359 \r
 360                 vTaskList( pcWriteBuffer );\r
 361                 vPortResetPrivilege( xRunningPrivileged );\r
 362         }\r
 363 #endif\r
 364 /*-----------------------------------------------------------*/\r
 365 \r
 366 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 367         void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer )\r
 368         {\r
 369         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 370 \r
 371                 vTaskGetRunTimeStats( pcWriteBuffer );\r
 372                 vPortResetPrivilege( xRunningPrivileged );\r
 373         }\r
 374 #endif\r
 375 /*-----------------------------------------------------------*/\r
 376 \r
 377 #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 378         void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxTagValue )\r
 379         {\r
 380         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 381 \r
 382                 vTaskSetApplicationTaskTag( xTask, pxTagValue );\r
 383                 vPortResetPrivilege( xRunningPrivileged );\r
 384         }\r
 385 #endif\r
 386 /*-----------------------------------------------------------*/\r
 387 \r
 388 #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 389         TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask )\r
 390         {\r
 391         TaskHookFunction_t xReturn;\r
 392         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 393 \r
 394                 xReturn = xTaskGetApplicationTaskTag( xTask );\r
 395                 vPortResetPrivilege( xRunningPrivileged );\r
 396                 return xReturn;\r
 397         }\r
 398 #endif\r
 399 /*-----------------------------------------------------------*/\r
 400 \r
 401 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
 402         void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue )\r
 403         {\r
 404         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 405 \r
 406                 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );\r
 407                 vPortResetPrivilege( xRunningPrivileged );\r
 408         }\r
 409 #endif\r
 410 /*-----------------------------------------------------------*/\r
 411 \r
 412 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
 413         void *MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex )\r
 414         {\r
 415         void *pvReturn;\r
 416         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 417 \r
 418                 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );\r
 419                 vPortResetPrivilege( xRunningPrivileged );\r
 420                 return pvReturn;\r
 421         }\r
 422 #endif\r
 423 /*-----------------------------------------------------------*/\r
 424 \r
 425 #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
 426         BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter )\r
 427         {\r
 428         BaseType_t xReturn;\r
 429         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 430 \r
 431                 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );\r
 432                 vPortResetPrivilege( xRunningPrivileged );\r
 433                 return xReturn;\r
 434         }\r
 435 #endif\r
 436 /*-----------------------------------------------------------*/\r
 437 \r
 438 #if ( configUSE_TRACE_FACILITY == 1 )\r
 439         UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t *pxTaskStatusArray, UBaseType_t uxArraySize, uint32_t *pulTotalRunTime )\r
 440         {\r
 441         UBaseType_t uxReturn;\r
 442         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 443 \r
 444                 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );\r
 445                 vPortResetPrivilege( xRunningPrivileged );\r
 446                 return uxReturn;\r
 447         }\r
 448 #endif\r
 449 /*-----------------------------------------------------------*/\r
 450 \r
 451 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )\r
 452         UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask )\r
 453         {\r
 454         UBaseType_t uxReturn;\r
 455         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 456 \r
 457                 uxReturn = uxTaskGetStackHighWaterMark( xTask );\r
 458                 vPortResetPrivilege( xRunningPrivileged );\r
 459                 return uxReturn;\r
 460         }\r
 461 #endif\r
 462 /*-----------------------------------------------------------*/\r
 463 \r
 464 #if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )\r
 465         TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void )\r
 466         {\r
 467         TaskHandle_t xReturn;\r
 468         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 469 \r
 470                 xReturn = xTaskGetCurrentTaskHandle();\r
 471                 vPortResetPrivilege( xRunningPrivileged );\r
 472                 return xReturn;\r
 473         }\r
 474 #endif\r
 475 /*-----------------------------------------------------------*/\r
 476 \r
 477 #if ( INCLUDE_xTaskGetSchedulerState == 1 )\r
 478         BaseType_t MPU_xTaskGetSchedulerState( void )\r
 479         {\r
 480         BaseType_t xReturn;\r
 481         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 482 \r
 483                 xReturn = xTaskGetSchedulerState();\r
 484                 vPortResetPrivilege( xRunningPrivileged );\r
 485                 return xReturn;\r
 486         }\r
 487 #endif\r
 488 /*-----------------------------------------------------------*/\r
 489 \r
 490 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )\r
 491 {\r
 492 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 493 \r
 494         vTaskSetTimeOutState( pxTimeOut );\r
 495         vPortResetPrivilege( xRunningPrivileged );\r
 496 }\r
 497 /*-----------------------------------------------------------*/\r
 498 \r
 499 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait )\r
 500 {\r
 501 BaseType_t xReturn;\r
 502 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 503 \r
 504         xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );\r
 505         vPortResetPrivilege( xRunningPrivileged );\r
 506         return xReturn;\r
 507 }\r
 508 /*-----------------------------------------------------------*/\r
 509 \r
 510 #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
 511         BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )\r
 512         {\r
 513         BaseType_t xReturn;\r
 514         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 515 \r
 516                 xReturn = xTaskGenericNotify( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue );\r
 517                 vPortResetPrivilege( xRunningPrivileged );\r
 518                 return xReturn;\r
 519         }\r
 520 #endif\r
 521 /*-----------------------------------------------------------*/\r
 522 \r
 523 #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
 524         BaseType_t MPU_xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )\r
 525         {\r
 526         BaseType_t xReturn;\r
 527         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 528 \r
 529                 xReturn = xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );\r
 530                 vPortResetPrivilege( xRunningPrivileged );\r
 531                 return xReturn;\r
 532         }\r
 533 #endif\r
 534 /*-----------------------------------------------------------*/\r
 535 \r
 536 #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
 537         uint32_t MPU_ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )\r
 538         {\r
 539         uint32_t ulReturn;\r
 540         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 541 \r
 542                 ulReturn = ulTaskNotifyTake( xClearCountOnExit, xTicksToWait );\r
 543                 vPortResetPrivilege( xRunningPrivileged );\r
 544                 return ulReturn;\r
 545         }\r
 546 #endif\r
 547 /*-----------------------------------------------------------*/\r
 548 \r
 549 #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
 550         BaseType_t MPU_xTaskNotifyStateClear( TaskHandle_t xTask )\r
 551         {\r
 552         BaseType_t xReturn;\r
 553         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 554 \r
 555                 xReturn = xTaskNotifyStateClear( xTask );\r
 556                 vPortResetPrivilege( xRunningPrivileged );\r
 557                 return xReturn;\r
 558         }\r
 559 #endif\r
 560 /*-----------------------------------------------------------*/\r
 561 \r
 562 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 563         QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize, uint8_t ucQueueType )\r
 564         {\r
 565         QueueHandle_t xReturn;\r
 566         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 567 \r
 568                 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );\r
 569                 vPortResetPrivilege( xRunningPrivileged );\r
 570                 return xReturn;\r
 571         }\r
 572 #endif\r
 573 /*-----------------------------------------------------------*/\r
 574 \r
 575 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 576         QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType )\r
 577         {\r
 578         QueueHandle_t xReturn;\r
 579         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 580 \r
 581                 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );\r
 582                 vPortResetPrivilege( xRunningPrivileged );\r
 583                 return xReturn;\r
 584         }\r
 585 #endif\r
 586 /*-----------------------------------------------------------*/\r
 587 \r
 588 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue, BaseType_t xNewQueue )\r
 589 {\r
 590 BaseType_t xReturn;\r
 591 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 592 \r
 593         xReturn = xQueueGenericReset( pxQueue, xNewQueue );\r
 594         vPortResetPrivilege( xRunningPrivileged );\r
 595         return xReturn;\r
 596 }\r
 597 /*-----------------------------------------------------------*/\r
 598 \r
 599 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition )\r
 600 {\r
 601 BaseType_t xReturn;\r
 602 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 603 \r
 604         xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );\r
 605         vPortResetPrivilege( xRunningPrivileged );\r
 606         return xReturn;\r
 607 }\r
 608 /*-----------------------------------------------------------*/\r
 609 \r
 610 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue )\r
 611 {\r
 612 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 613 UBaseType_t uxReturn;\r
 614 \r
 615         uxReturn = uxQueueMessagesWaiting( pxQueue );\r
 616         vPortResetPrivilege( xRunningPrivileged );\r
 617         return uxReturn;\r
 618 }\r
 619 /*-----------------------------------------------------------*/\r
 620 \r
 621 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue )\r
 622 {\r
 623 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 624 UBaseType_t uxReturn;\r
 625 \r
 626         uxReturn = uxQueueSpacesAvailable( xQueue );\r
 627         vPortResetPrivilege( xRunningPrivileged );\r
 628         return uxReturn;\r
 629 }\r
 630 /*-----------------------------------------------------------*/\r
 631 \r
 632 BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue, void * const pvBuffer, TickType_t xTicksToWait )\r
 633 {\r
 634 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 635 BaseType_t xReturn;\r
 636 \r
 637         xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );\r
 638         vPortResetPrivilege( xRunningPrivileged );\r
 639         return xReturn;\r
 640 }\r
 641 /*-----------------------------------------------------------*/\r
 642 \r
 643 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait )\r
 644 {\r
 645 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 646 BaseType_t xReturn;\r
 647 \r
 648         xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );\r
 649         vPortResetPrivilege( xRunningPrivileged );\r
 650         return xReturn;\r
 651 }\r
 652 /*-----------------------------------------------------------*/\r
 653 \r
 654 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait )\r
 655 {\r
 656 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 657 BaseType_t xReturn;\r
 658 \r
 659         xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );\r
 660         vPortResetPrivilege( xRunningPrivileged );\r
 661         return xReturn;\r
 662 }\r
 663 /*-----------------------------------------------------------*/\r
 664 \r
 665 BaseType_t MPU_xQueuePeekFromISR( QueueHandle_t pxQueue, void * const pvBuffer )\r
 666 {\r
 667 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 668 BaseType_t xReturn;\r
 669 \r
 670         xReturn = xQueuePeekFromISR( pxQueue, pvBuffer );\r
 671         vPortResetPrivilege( xRunningPrivileged );\r
 672         return xReturn;\r
 673 }\r
 674 /*-----------------------------------------------------------*/\r
 675 \r
 676 void* MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore )\r
 677 {\r
 678 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 679 void * xReturn;\r
 680 \r
 681         xReturn = ( void * ) xQueueGetMutexHolder( xSemaphore );\r
 682         vPortResetPrivilege( xRunningPrivileged );\r
 683         return xReturn;\r
 684 }\r
 685 /*-----------------------------------------------------------*/\r
 686 \r
 687 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 688         QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType )\r
 689         {\r
 690         QueueHandle_t xReturn;\r
 691         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 692 \r
 693                 xReturn = xQueueCreateMutex( ucQueueType );\r
 694                 vPortResetPrivilege( xRunningPrivileged );\r
 695                 return xReturn;\r
 696         }\r
 697 #endif\r
 698 /*-----------------------------------------------------------*/\r
 699 \r
 700 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 701         QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue )\r
 702         {\r
 703         QueueHandle_t xReturn;\r
 704         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 705 \r
 706                 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );\r
 707                 vPortResetPrivilege( xRunningPrivileged );\r
 708                 return xReturn;\r
 709         }\r
 710 #endif\r
 711 /*-----------------------------------------------------------*/\r
 712 \r
 713 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 714         QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue, UBaseType_t uxInitialCount )\r
 715         {\r
 716         QueueHandle_t xReturn;\r
 717         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 718 \r
 719                 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );\r
 720                 vPortResetPrivilege( xRunningPrivileged );\r
 721                 return xReturn;\r
 722         }\r
 723 #endif\r
 724 /*-----------------------------------------------------------*/\r
 725 \r
 726 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
 727 \r
 728         QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue )\r
 729         {\r
 730         QueueHandle_t xReturn;\r
 731         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 732 \r
 733                 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );\r
 734                 vPortResetPrivilege( xRunningPrivileged );\r
 735                 return xReturn;\r
 736         }\r
 737 #endif\r
 738 /*-----------------------------------------------------------*/\r
 739 \r
 740 #if ( configUSE_MUTEXES == 1 )\r
 741         BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xBlockTime )\r
 742         {\r
 743         BaseType_t xReturn;\r
 744         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 745 \r
 746                 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );\r
 747                 vPortResetPrivilege( xRunningPrivileged );\r
 748                 return xReturn;\r
 749         }\r
 750 #endif\r
 751 /*-----------------------------------------------------------*/\r
 752 \r
 753 #if ( configUSE_MUTEXES == 1 )\r
 754         BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex )\r
 755         {\r
 756         BaseType_t xReturn;\r
 757         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 758 \r
 759                 xReturn = xQueueGiveMutexRecursive( xMutex );\r
 760                 vPortResetPrivilege( xRunningPrivileged );\r
 761                 return xReturn;\r
 762         }\r
 763 #endif\r
 764 /*-----------------------------------------------------------*/\r
 765 \r
 766 #if( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
 767         QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength )\r
 768         {\r
 769         QueueSetHandle_t xReturn;\r
 770         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 771 \r
 772                 xReturn = xQueueCreateSet( uxEventQueueLength );\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         QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, TickType_t xBlockTimeTicks )\r
 781         {\r
 782         QueueSetMemberHandle_t xReturn;\r
 783         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 784 \r
 785                 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );\r
 786                 vPortResetPrivilege( xRunningPrivileged );\r
 787                 return xReturn;\r
 788         }\r
 789 #endif\r
 790 /*-----------------------------------------------------------*/\r
 791 \r
 792 #if ( configUSE_QUEUE_SETS == 1 )\r
 793         BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )\r
 794         {\r
 795         BaseType_t xReturn;\r
 796         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 797 \r
 798                 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );\r
 799                 vPortResetPrivilege( xRunningPrivileged );\r
 800                 return xReturn;\r
 801         }\r
 802 #endif\r
 803 /*-----------------------------------------------------------*/\r
 804 \r
 805 #if ( configUSE_QUEUE_SETS == 1 )\r
 806         BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )\r
 807         {\r
 808         BaseType_t xReturn;\r
 809         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 810 \r
 811                 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );\r
 812                 vPortResetPrivilege( xRunningPrivileged );\r
 813                 return xReturn;\r
 814         }\r
 815 #endif\r
 816 /*-----------------------------------------------------------*/\r
 817 \r
 818 #if configQUEUE_REGISTRY_SIZE > 0\r
 819         void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName )\r
 820         {\r
 821         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 822 \r
 823                 vQueueAddToRegistry( xQueue, pcName );\r
 824 \r
 825                 vPortResetPrivilege( xRunningPrivileged );\r
 826         }\r
 827 #endif\r
 828 /*-----------------------------------------------------------*/\r
 829 \r
 830 #if configQUEUE_REGISTRY_SIZE > 0\r
 831         void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue )\r
 832         {\r
 833         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 834 \r
 835                 vQueueUnregisterQueue( xQueue );\r
 836 \r
 837                 vPortResetPrivilege( xRunningPrivileged );\r
 838         }\r
 839 #endif\r
 840 /*-----------------------------------------------------------*/\r
 841 \r
 842 #if configQUEUE_REGISTRY_SIZE > 0\r
 843         const char *MPU_pcQueueGetName( QueueHandle_t xQueue )\r
 844         {\r
 845         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 846         const char *pcReturn;\r
 847 \r
 848                 pcReturn = pcQueueGetName( xQueue );\r
 849 \r
 850                 vPortResetPrivilege( xRunningPrivileged );\r
 851                 return pcReturn;\r
 852         }\r
 853 #endif\r
 854 /*-----------------------------------------------------------*/\r
 855 \r
 856 void MPU_vQueueDelete( QueueHandle_t xQueue )\r
 857 {\r
 858 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 859 \r
 860         vQueueDelete( xQueue );\r
 861 \r
 862         vPortResetPrivilege( xRunningPrivileged );\r
 863 }\r
 864 /*-----------------------------------------------------------*/\r
 865 \r
 866 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 867         void *MPU_pvPortMalloc( size_t xSize )\r
 868         {\r
 869         void *pvReturn;\r
 870         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 871 \r
 872                 pvReturn = pvPortMalloc( xSize );\r
 873 \r
 874                 vPortResetPrivilege( xRunningPrivileged );\r
 875 \r
 876                 return pvReturn;\r
 877         }\r
 878 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 879 /*-----------------------------------------------------------*/\r
 880 \r
 881 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 882         void MPU_vPortFree( void *pv )\r
 883         {\r
 884         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 885 \r
 886                 vPortFree( pv );\r
 887 \r
 888                 vPortResetPrivilege( xRunningPrivileged );\r
 889         }\r
 890 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 891 /*-----------------------------------------------------------*/\r
 892 \r
 893 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 894         void MPU_vPortInitialiseBlocks( void )\r
 895         {\r
 896         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 897 \r
 898                 vPortInitialiseBlocks();\r
 899 \r
 900                 vPortResetPrivilege( xRunningPrivileged );\r
 901         }\r
 902 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 903 /*-----------------------------------------------------------*/\r
 904 \r
 905 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 906         size_t MPU_xPortGetFreeHeapSize( void )\r
 907         {\r
 908         size_t xReturn;\r
 909         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 910 \r
 911                 xReturn = xPortGetFreeHeapSize();\r
 912 \r
 913                 vPortResetPrivilege( xRunningPrivileged );\r
 914 \r
 915                 return xReturn;\r
 916         }\r
 917 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 918 /*-----------------------------------------------------------*/\r
 919 \r
 920 #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 921         TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction )\r
 922         {\r
 923         TimerHandle_t xReturn;\r
 924         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 925 \r
 926                 xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );\r
 927                 vPortResetPrivilege( xRunningPrivileged );\r
 928 \r
 929                 return xReturn;\r
 930         }\r
 931 #endif\r
 932 /*-----------------------------------------------------------*/\r
 933 \r
 934 #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )\r
 935         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
 936         {\r
 937         TimerHandle_t xReturn;\r
 938         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 939 \r
 940                 xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );\r
 941                 vPortResetPrivilege( xRunningPrivileged );\r
 942 \r
 943                 return xReturn;\r
 944         }\r
 945 #endif\r
 946 /*-----------------------------------------------------------*/\r
 947 \r
 948 #if( configUSE_TIMERS == 1 )\r
 949         void *MPU_pvTimerGetTimerID( const TimerHandle_t xTimer )\r
 950         {\r
 951         void * pvReturn;\r
 952         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 953 \r
 954                 pvReturn = pvTimerGetTimerID( xTimer );\r
 955                 vPortResetPrivilege( xRunningPrivileged );\r
 956 \r
 957                 return pvReturn;\r
 958         }\r
 959 #endif\r
 960 /*-----------------------------------------------------------*/\r
 961 \r
 962 #if( configUSE_TIMERS == 1 )\r
 963         void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID )\r
 964         {\r
 965         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 966 \r
 967                 vTimerSetTimerID( xTimer, pvNewID );\r
 968                 vPortResetPrivilege( xRunningPrivileged );\r
 969         }\r
 970 #endif\r
 971 /*-----------------------------------------------------------*/\r
 972 \r
 973 #if( configUSE_TIMERS == 1 )\r
 974         BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer )\r
 975         {\r
 976         BaseType_t xReturn;\r
 977         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 978 \r
 979                 xReturn = xTimerIsTimerActive( xTimer );\r
 980                 vPortResetPrivilege( xRunningPrivileged );\r
 981 \r
 982                 return xReturn;\r
 983         }\r
 984 #endif\r
 985 /*-----------------------------------------------------------*/\r
 986 \r
 987 #if( configUSE_TIMERS == 1 )\r
 988         TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void )\r
 989         {\r
 990         TaskHandle_t xReturn;\r
 991         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
 992 \r
 993                 xReturn = xTimerGetTimerDaemonTaskHandle();\r
 994                 vPortResetPrivilege( xRunningPrivileged );\r
 995 \r
 996                 return xReturn;\r
 997         }\r
 998 #endif\r
 999 /*-----------------------------------------------------------*/\r
1000 \r
1001 #if( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )\r
1002         BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait )\r
1003         {\r
1004         BaseType_t xReturn;\r
1005         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1006 \r
1007                 xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );\r
1008                 vPortResetPrivilege( xRunningPrivileged );\r
1009 \r
1010                 return xReturn;\r
1011         }\r
1012 #endif\r
1013 /*-----------------------------------------------------------*/\r
1014 \r
1015 #if( configUSE_TIMERS == 1 )\r
1016         const char * MPU_pcTimerGetName( TimerHandle_t xTimer )\r
1017         {\r
1018         const char * pcReturn;\r
1019         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1020 \r
1021                 pcReturn = pcTimerGetName( xTimer );\r
1022                 vPortResetPrivilege( xRunningPrivileged );\r
1023 \r
1024                 return pcReturn;\r
1025         }\r
1026 #endif\r
1027 /*-----------------------------------------------------------*/\r
1028 \r
1029 #if( configUSE_TIMERS == 1 )\r
1030         TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer )\r
1031         {\r
1032         TickType_t xReturn;\r
1033         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1034 \r
1035                 xReturn = xTimerGetPeriod( xTimer );\r
1036                 vPortResetPrivilege( xRunningPrivileged );\r
1037 \r
1038                 return xReturn;\r
1039         }\r
1040 #endif\r
1041 /*-----------------------------------------------------------*/\r
1042 \r
1043 #if( configUSE_TIMERS == 1 )\r
1044         TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer )\r
1045         {\r
1046         TickType_t xReturn;\r
1047         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1048 \r
1049                 xReturn = xTimerGetExpiryTime( xTimer );\r
1050                 vPortResetPrivilege( xRunningPrivileged );\r
1051 \r
1052                 return xReturn;\r
1053         }\r
1054 #endif\r
1055 /*-----------------------------------------------------------*/\r
1056 \r
1057 #if( configUSE_TIMERS == 1 )\r
1058         BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait )\r
1059         {\r
1060         BaseType_t xReturn;\r
1061         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1062 \r
1063                 xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );\r
1064                 vPortResetPrivilege( xRunningPrivileged );\r
1065 \r
1066                 return xReturn;\r
1067         }\r
1068 #endif\r
1069 /*-----------------------------------------------------------*/\r
1070 \r
1071 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
1072         EventGroupHandle_t MPU_xEventGroupCreate( void )\r
1073         {\r
1074         EventGroupHandle_t xReturn;\r
1075         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1076 \r
1077                 xReturn = xEventGroupCreate();\r
1078                 vPortResetPrivilege( xRunningPrivileged );\r
1079 \r
1080                 return xReturn;\r
1081         }\r
1082 #endif\r
1083 /*-----------------------------------------------------------*/\r
1084 \r
1085 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
1086         EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )\r
1087         {\r
1088         EventGroupHandle_t xReturn;\r
1089         BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1090 \r
1091                 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );\r
1092                 vPortResetPrivilege( xRunningPrivileged );\r
1093 \r
1094                 return xReturn;\r
1095         }\r
1096 #endif\r
1097 /*-----------------------------------------------------------*/\r
1098 \r
1099 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )\r
1100 {\r
1101 EventBits_t xReturn;\r
1102 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1103 \r
1104         xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );\r
1105         vPortResetPrivilege( xRunningPrivileged );\r
1106 \r
1107         return xReturn;\r
1108 }\r
1109 /*-----------------------------------------------------------*/\r
1110 \r
1111 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )\r
1112 {\r
1113 EventBits_t xReturn;\r
1114 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1115 \r
1116         xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );\r
1117         vPortResetPrivilege( xRunningPrivileged );\r
1118 \r
1119         return xReturn;\r
1120 }\r
1121 /*-----------------------------------------------------------*/\r
1122 \r
1123 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )\r
1124 {\r
1125 EventBits_t xReturn;\r
1126 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1127 \r
1128         xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );\r
1129         vPortResetPrivilege( xRunningPrivileged );\r
1130 \r
1131         return xReturn;\r
1132 }\r
1133 /*-----------------------------------------------------------*/\r
1134 \r
1135 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )\r
1136 {\r
1137 EventBits_t xReturn;\r
1138 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1139 \r
1140         xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );\r
1141         vPortResetPrivilege( xRunningPrivileged );\r
1142 \r
1143         return xReturn;\r
1144 }\r
1145 /*-----------------------------------------------------------*/\r
1146 \r
1147 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup )\r
1148 {\r
1149 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1150 \r
1151         vEventGroupDelete( xEventGroup );\r
1152         vPortResetPrivilege( xRunningPrivileged );\r
1153 }\r
1154 /*-----------------------------------------------------------*/\r
1155 \r
1156 \r
1157 \r
1158 \r
1159 \r
1160 /* Functions that the application writer wants to execute in privileged mode\r
1161 can be defined in application_defined_privileged_functions.h.  The functions\r
1162 must take the same format as those above whereby the privilege state on exit\r
1163 equals the privilege state on entry.  For example:\r
1164 \r
1165 void MPU_FunctionName( [parameters ] )\r
1166 {\r
1167 BaseType_t xRunningPrivileged = xPortRaisePrivilege();\r
1168 \r
1169         FunctionName( [parameters ] );\r
1170 \r
1171         vPortResetPrivilege( xRunningPrivileged );\r
1172 }\r
1173 */\r
1174 \r
1175 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1\r
1176         #include "application_defined_privileged_functions.h"\r
1177 #endif\r