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

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