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