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