2 * FreeRTOS Kernel V10.2.1
\r
3 * Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
\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
12 * The above copyright notice and this permission notice shall be included in all
\r
13 * copies or substantial portions of the Software.
\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
22 * http://www.FreeRTOS.org
\r
23 * http://aws.amazon.com/freertos
\r
25 * 1 tab == 4 spaces!
\r
29 * Implementation of the wrapper functions used to raise the processor privilege
\r
30 * before calling a standard FreeRTOS API function.
\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
38 /* Scheduler includes. */
\r
39 #include "FreeRTOS.h"
\r
43 #include "event_groups.h"
\r
44 #include "stream_buffer.h"
\r
45 #include "mpu_prototypes.h"
\r
47 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
\r
50 * @brief Calls the port specific code to raise the privilege.
\r
52 * @return pdFALSE if privilege was raised, pdTRUE otherwise.
\r
54 BaseType_t xPortRaisePrivilege( void ) FREERTOS_SYSTEM_CALL;
\r
57 * @brief If xRunningPrivileged is not pdTRUE, calls the port specific
\r
58 * code to reset the privilege, otherwise does nothing.
\r
60 void vPortResetPrivilege( BaseType_t xRunningPrivileged );
\r
61 /*-----------------------------------------------------------*/
\r
63 BaseType_t xPortRaisePrivilege( void ) /* FREERTOS_SYSTEM_CALL */
\r
65 BaseType_t xRunningPrivileged;
\r
67 /* Check whether the processor is already privileged. */
\r
68 xRunningPrivileged = portIS_PRIVILEGED();
\r
70 /* If the processor is not already privileged, raise privilege. */
\r
71 if( xRunningPrivileged != pdTRUE )
\r
73 portRAISE_PRIVILEGE();
\r
76 return xRunningPrivileged;
\r
78 /*-----------------------------------------------------------*/
\r
80 void vPortResetPrivilege( BaseType_t xRunningPrivileged )
\r
82 if( xRunningPrivileged != pdTRUE )
\r
84 portRESET_PRIVILEGE();
\r
87 /*-----------------------------------------------------------*/
\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
93 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
95 xReturn = xTaskCreateRestricted( pxTaskDefinition, pxCreatedTask );
\r
96 vPortResetPrivilege( xRunningPrivileged );
\r
99 #endif /* conifgSUPPORT_DYNAMIC_ALLOCATION */
\r
100 /*-----------------------------------------------------------*/
\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
105 BaseType_t xReturn;
\r
106 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
108 xReturn = xTaskCreateRestrictedStatic( pxTaskDefinition, pxCreatedTask );
\r
109 vPortResetPrivilege( xRunningPrivileged );
\r
112 #endif /* conifgSUPPORT_DYNAMIC_ALLOCATION */
\r
113 /*-----------------------------------------------------------*/
\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
118 BaseType_t xReturn;
\r
119 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
121 xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );
\r
122 vPortResetPrivilege( xRunningPrivileged );
\r
125 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
126 /*-----------------------------------------------------------*/
\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
131 TaskHandle_t xReturn;
\r
132 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
134 xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
\r
135 vPortResetPrivilege( xRunningPrivileged );
\r
138 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
139 /*-----------------------------------------------------------*/
\r
141 void MPU_vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const xRegions ) /* FREERTOS_SYSTEM_CALL */
\r
143 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
145 vTaskAllocateMPURegions( xTask, xRegions );
\r
146 vPortResetPrivilege( xRunningPrivileged );
\r
148 /*-----------------------------------------------------------*/
\r
150 #if ( INCLUDE_vTaskDelete == 1 )
\r
151 void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete ) /* FREERTOS_SYSTEM_CALL */
\r
153 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
155 vTaskDelete( pxTaskToDelete );
\r
156 vPortResetPrivilege( xRunningPrivileged );
\r
159 /*-----------------------------------------------------------*/
\r
161 #if ( INCLUDE_vTaskDelayUntil == 1 )
\r
162 void MPU_vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, TickType_t xTimeIncrement ) /* FREERTOS_SYSTEM_CALL */
\r
164 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
166 vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
\r
167 vPortResetPrivilege( xRunningPrivileged );
\r
170 /*-----------------------------------------------------------*/
\r
172 #if ( INCLUDE_xTaskAbortDelay == 1 )
\r
173 BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
\r
175 BaseType_t xReturn;
\r
176 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
178 xReturn = xTaskAbortDelay( xTask );
\r
179 vPortResetPrivilege( xRunningPrivileged );
\r
183 /*-----------------------------------------------------------*/
\r
185 #if ( INCLUDE_vTaskDelay == 1 )
\r
186 void MPU_vTaskDelay( TickType_t xTicksToDelay ) /* FREERTOS_SYSTEM_CALL */
\r
188 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
190 vTaskDelay( xTicksToDelay );
\r
191 vPortResetPrivilege( xRunningPrivileged );
\r
194 /*-----------------------------------------------------------*/
\r
196 #if ( INCLUDE_uxTaskPriorityGet == 1 )
\r
197 UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */
\r
199 UBaseType_t uxReturn;
\r
200 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
202 uxReturn = uxTaskPriorityGet( pxTask );
\r
203 vPortResetPrivilege( xRunningPrivileged );
\r
207 /*-----------------------------------------------------------*/
\r
209 #if ( INCLUDE_vTaskPrioritySet == 1 )
\r
210 void MPU_vTaskPrioritySet( TaskHandle_t pxTask, UBaseType_t uxNewPriority ) /* FREERTOS_SYSTEM_CALL */
\r
212 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
214 vTaskPrioritySet( pxTask, uxNewPriority );
\r
215 vPortResetPrivilege( xRunningPrivileged );
\r
218 /*-----------------------------------------------------------*/
\r
220 #if ( INCLUDE_eTaskGetState == 1 )
\r
221 eTaskState MPU_eTaskGetState( TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */
\r
223 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
224 eTaskState eReturn;
\r
226 eReturn = eTaskGetState( pxTask );
\r
227 vPortResetPrivilege( xRunningPrivileged );
\r
231 /*-----------------------------------------------------------*/
\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
236 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
238 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
\r
239 vPortResetPrivilege( xRunningPrivileged );
\r
242 /*-----------------------------------------------------------*/
\r
244 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
\r
245 TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
\r
247 TaskHandle_t xReturn;
\r
248 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
250 xReturn = xTaskGetIdleTaskHandle();
\r
251 vPortResetPrivilege( xRunningPrivileged );
\r
255 /*-----------------------------------------------------------*/
\r
257 #if ( INCLUDE_vTaskSuspend == 1 )
\r
258 void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend ) /* FREERTOS_SYSTEM_CALL */
\r
260 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
262 vTaskSuspend( pxTaskToSuspend );
\r
263 vPortResetPrivilege( xRunningPrivileged );
\r
266 /*-----------------------------------------------------------*/
\r
268 #if ( INCLUDE_vTaskSuspend == 1 )
\r
269 void MPU_vTaskResume( TaskHandle_t pxTaskToResume ) /* FREERTOS_SYSTEM_CALL */
\r
271 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
273 vTaskResume( pxTaskToResume );
\r
274 vPortResetPrivilege( xRunningPrivileged );
\r
277 /*-----------------------------------------------------------*/
\r
279 void MPU_vTaskSuspendAll( void ) /* FREERTOS_SYSTEM_CALL */
\r
281 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
284 vPortResetPrivilege( xRunningPrivileged );
\r
286 /*-----------------------------------------------------------*/
\r
288 BaseType_t MPU_xTaskResumeAll( void ) /* FREERTOS_SYSTEM_CALL */
\r
290 BaseType_t xReturn;
\r
291 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
293 xReturn = xTaskResumeAll();
\r
294 vPortResetPrivilege( xRunningPrivileged );
\r
297 /*-----------------------------------------------------------*/
\r
299 TickType_t MPU_xTaskGetTickCount( void ) /* FREERTOS_SYSTEM_CALL */
\r
301 TickType_t xReturn;
\r
302 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
304 xReturn = xTaskGetTickCount();
\r
305 vPortResetPrivilege( xRunningPrivileged );
\r
308 /*-----------------------------------------------------------*/
\r
310 UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* FREERTOS_SYSTEM_CALL */
\r
312 UBaseType_t uxReturn;
\r
313 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
315 uxReturn = uxTaskGetNumberOfTasks();
\r
316 vPortResetPrivilege( xRunningPrivileged );
\r
319 /*-----------------------------------------------------------*/
\r
321 char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
\r
324 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
326 pcReturn = pcTaskGetName( xTaskToQuery );
\r
327 vPortResetPrivilege( xRunningPrivileged );
\r
330 /*-----------------------------------------------------------*/
\r
332 #if ( INCLUDE_xTaskGetHandle == 1 )
\r
333 TaskHandle_t MPU_xTaskGetHandle( const char *pcNameToQuery ) /* FREERTOS_SYSTEM_CALL */
\r
335 TaskHandle_t xReturn;
\r
336 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
338 xReturn = xTaskGetHandle( pcNameToQuery );
\r
339 vPortResetPrivilege( xRunningPrivileged );
\r
343 /*-----------------------------------------------------------*/
\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
348 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
350 vTaskList( pcWriteBuffer );
\r
351 vPortResetPrivilege( xRunningPrivileged );
\r
354 /*-----------------------------------------------------------*/
\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
359 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
361 vTaskGetRunTimeStats( pcWriteBuffer );
\r
362 vPortResetPrivilege( xRunningPrivileged );
\r
365 /*-----------------------------------------------------------*/
\r
367 #if( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
\r
368 uint32_t MPU_ulTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */
\r
371 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
373 xReturn = ulTaskGetIdleRunTimeCounter();
\r
374 vPortResetPrivilege( xRunningPrivileged );
\r
378 /*-----------------------------------------------------------*/
\r
380 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
381 void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxTagValue ) /* FREERTOS_SYSTEM_CALL */
\r
383 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
385 vTaskSetApplicationTaskTag( xTask, pxTagValue );
\r
386 vPortResetPrivilege( xRunningPrivileged );
\r
389 /*-----------------------------------------------------------*/
\r
391 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
392 TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
\r
394 TaskHookFunction_t xReturn;
\r
395 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
397 xReturn = xTaskGetApplicationTaskTag( xTask );
\r
398 vPortResetPrivilege( xRunningPrivileged );
\r
402 /*-----------------------------------------------------------*/
\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
407 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
409 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
\r
410 vPortResetPrivilege( xRunningPrivileged );
\r
413 /*-----------------------------------------------------------*/
\r
415 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
\r
416 void *MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex ) /* FREERTOS_SYSTEM_CALL */
\r
419 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
421 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
\r
422 vPortResetPrivilege( xRunningPrivileged );
\r
426 /*-----------------------------------------------------------*/
\r
428 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
429 BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter ) /* FREERTOS_SYSTEM_CALL */
\r
431 BaseType_t xReturn;
\r
432 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
434 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
\r
435 vPortResetPrivilege( xRunningPrivileged );
\r
439 /*-----------------------------------------------------------*/
\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
444 UBaseType_t uxReturn;
\r
445 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
447 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
\r
448 vPortResetPrivilege( xRunningPrivileged );
\r
452 /*-----------------------------------------------------------*/
\r
454 BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTEM_CALL */
\r
456 BaseType_t xReturn;
\r
457 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
459 xReturn = xTaskCatchUpTicks( xTicksToCatchUp );
\r
460 vPortResetPrivilege( xRunningPrivileged );
\r
463 /*-----------------------------------------------------------*/
\r
465 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
\r
466 UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
\r
468 UBaseType_t uxReturn;
\r
469 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
471 uxReturn = uxTaskGetStackHighWaterMark( xTask );
\r
472 vPortResetPrivilege( xRunningPrivileged );
\r
476 /*-----------------------------------------------------------*/
\r
478 #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
\r
479 configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
\r
481 configSTACK_DEPTH_TYPE uxReturn;
\r
482 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
484 uxReturn = uxTaskGetStackHighWaterMark2( xTask );
\r
485 vPortResetPrivilege( xRunningPrivileged );
\r
489 /*-----------------------------------------------------------*/
\r
491 #if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )
\r
492 TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
\r
494 TaskHandle_t xReturn;
\r
495 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
497 xReturn = xTaskGetCurrentTaskHandle();
\r
498 vPortResetPrivilege( xRunningPrivileged );
\r
502 /*-----------------------------------------------------------*/
\r
504 #if ( INCLUDE_xTaskGetSchedulerState == 1 )
\r
505 BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */
\r
507 BaseType_t xReturn;
\r
508 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
510 xReturn = xTaskGetSchedulerState();
\r
511 vPortResetPrivilege( xRunningPrivileged );
\r
515 /*-----------------------------------------------------------*/
\r
517 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */
\r
519 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
521 vTaskSetTimeOutState( pxTimeOut );
\r
522 vPortResetPrivilege( xRunningPrivileged );
\r
524 /*-----------------------------------------------------------*/
\r
526 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
528 BaseType_t xReturn;
\r
529 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
531 xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
\r
532 vPortResetPrivilege( xRunningPrivileged );
\r
535 /*-----------------------------------------------------------*/
\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
540 BaseType_t xReturn;
\r
541 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
543 xReturn = xTaskGenericNotify( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue );
\r
544 vPortResetPrivilege( xRunningPrivileged );
\r
548 /*-----------------------------------------------------------*/
\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
553 BaseType_t xReturn;
\r
554 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
556 xReturn = xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
\r
557 vPortResetPrivilege( xRunningPrivileged );
\r
561 /*-----------------------------------------------------------*/
\r
563 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
564 uint32_t MPU_ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
567 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
569 ulReturn = ulTaskNotifyTake( xClearCountOnExit, xTicksToWait );
\r
570 vPortResetPrivilege( xRunningPrivileged );
\r
574 /*-----------------------------------------------------------*/
\r
576 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
577 BaseType_t MPU_xTaskNotifyStateClear( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
\r
579 BaseType_t xReturn;
\r
580 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
582 xReturn = xTaskNotifyStateClear( xTask );
\r
583 vPortResetPrivilege( xRunningPrivileged );
\r
587 /*-----------------------------------------------------------*/
\r
589 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
590 uint32_t MPU_ulTaskNotifyValueClear( TaskHandle_t xTask, uint32_t ulBitsToClear ) /* FREERTOS_SYSTEM_CALL */
\r
593 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
595 ulReturn = ulTaskNotifyValueClear( xTask, ulBitsToClear );
\r
596 vPortResetPrivilege( xRunningPrivileged );
\r
600 /*-----------------------------------------------------------*/
\r
602 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
603 QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize, uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
\r
605 QueueHandle_t xReturn;
\r
606 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
608 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
\r
609 vPortResetPrivilege( xRunningPrivileged );
\r
613 /*-----------------------------------------------------------*/
\r
615 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
616 QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
\r
618 QueueHandle_t xReturn;
\r
619 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
621 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
\r
622 vPortResetPrivilege( xRunningPrivileged );
\r
626 /*-----------------------------------------------------------*/
\r
628 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue, BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */
\r
630 BaseType_t xReturn;
\r
631 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
633 xReturn = xQueueGenericReset( pxQueue, xNewQueue );
\r
634 vPortResetPrivilege( xRunningPrivileged );
\r
637 /*-----------------------------------------------------------*/
\r
639 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */
\r
641 BaseType_t xReturn;
\r
642 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
644 xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
\r
645 vPortResetPrivilege( xRunningPrivileged );
\r
648 /*-----------------------------------------------------------*/
\r
650 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */
\r
652 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
653 UBaseType_t uxReturn;
\r
655 uxReturn = uxQueueMessagesWaiting( pxQueue );
\r
656 vPortResetPrivilege( xRunningPrivileged );
\r
659 /*-----------------------------------------------------------*/
\r
661 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
\r
663 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
664 UBaseType_t uxReturn;
\r
666 uxReturn = uxQueueSpacesAvailable( xQueue );
\r
667 vPortResetPrivilege( xRunningPrivileged );
\r
670 /*-----------------------------------------------------------*/
\r
672 BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue, void * const pvBuffer, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
674 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
675 BaseType_t xReturn;
\r
677 xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
\r
678 vPortResetPrivilege( xRunningPrivileged );
\r
681 /*-----------------------------------------------------------*/
\r
683 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
685 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
686 BaseType_t xReturn;
\r
688 xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
\r
689 vPortResetPrivilege( xRunningPrivileged );
\r
692 /*-----------------------------------------------------------*/
\r
694 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
696 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
697 BaseType_t xReturn;
\r
699 xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
\r
700 vPortResetPrivilege( xRunningPrivileged );
\r
703 /*-----------------------------------------------------------*/
\r
705 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
\r
706 TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */
\r
708 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
711 xReturn = xQueueGetMutexHolder( xSemaphore );
\r
712 vPortResetPrivilege( xRunningPrivileged );
\r
716 /*-----------------------------------------------------------*/
\r
718 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
719 QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
\r
721 QueueHandle_t xReturn;
\r
722 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
724 xReturn = xQueueCreateMutex( ucQueueType );
\r
725 vPortResetPrivilege( xRunningPrivileged );
\r
729 /*-----------------------------------------------------------*/
\r
731 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
732 QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
\r
734 QueueHandle_t xReturn;
\r
735 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
737 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
\r
738 vPortResetPrivilege( xRunningPrivileged );
\r
742 /*-----------------------------------------------------------*/
\r
744 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
745 QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue, UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */
\r
747 QueueHandle_t xReturn;
\r
748 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
750 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
\r
751 vPortResetPrivilege( xRunningPrivileged );
\r
755 /*-----------------------------------------------------------*/
\r
757 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
759 QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
\r
761 QueueHandle_t xReturn;
\r
762 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
764 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
\r
765 vPortResetPrivilege( xRunningPrivileged );
\r
769 /*-----------------------------------------------------------*/
\r
771 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
772 BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */
\r
774 BaseType_t xReturn;
\r
775 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
777 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
\r
778 vPortResetPrivilege( xRunningPrivileged );
\r
782 /*-----------------------------------------------------------*/
\r
784 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
785 BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */
\r
787 BaseType_t xReturn;
\r
788 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
790 xReturn = xQueueGiveMutexRecursive( xMutex );
\r
791 vPortResetPrivilege( xRunningPrivileged );
\r
795 /*-----------------------------------------------------------*/
\r
797 #if( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
798 QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */
\r
800 QueueSetHandle_t xReturn;
\r
801 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
803 xReturn = xQueueCreateSet( uxEventQueueLength );
\r
804 vPortResetPrivilege( xRunningPrivileged );
\r
808 /*-----------------------------------------------------------*/
\r
810 #if ( configUSE_QUEUE_SETS == 1 )
\r
811 QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */
\r
813 QueueSetMemberHandle_t xReturn;
\r
814 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
816 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
\r
817 vPortResetPrivilege( xRunningPrivileged );
\r
821 /*-----------------------------------------------------------*/
\r
823 #if ( configUSE_QUEUE_SETS == 1 )
\r
824 BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
\r
826 BaseType_t xReturn;
\r
827 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
829 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
\r
830 vPortResetPrivilege( xRunningPrivileged );
\r
834 /*-----------------------------------------------------------*/
\r
836 #if ( configUSE_QUEUE_SETS == 1 )
\r
837 BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
\r
839 BaseType_t xReturn;
\r
840 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
842 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
\r
843 vPortResetPrivilege( xRunningPrivileged );
\r
847 /*-----------------------------------------------------------*/
\r
849 #if configQUEUE_REGISTRY_SIZE > 0
\r
850 void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName ) /* FREERTOS_SYSTEM_CALL */
\r
852 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
854 vQueueAddToRegistry( xQueue, pcName );
\r
856 vPortResetPrivilege( xRunningPrivileged );
\r
859 /*-----------------------------------------------------------*/
\r
861 #if configQUEUE_REGISTRY_SIZE > 0
\r
862 void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
\r
864 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
866 vQueueUnregisterQueue( xQueue );
\r
868 vPortResetPrivilege( xRunningPrivileged );
\r
871 /*-----------------------------------------------------------*/
\r
873 #if configQUEUE_REGISTRY_SIZE > 0
\r
874 const char *MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
\r
876 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
877 const char *pcReturn;
\r
879 pcReturn = pcQueueGetName( xQueue );
\r
881 vPortResetPrivilege( xRunningPrivileged );
\r
885 /*-----------------------------------------------------------*/
\r
887 void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
\r
889 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
891 vQueueDelete( xQueue );
\r
893 vPortResetPrivilege( xRunningPrivileged );
\r
895 /*-----------------------------------------------------------*/
\r
897 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
898 void *MPU_pvPortMalloc( size_t xSize ) /* FREERTOS_SYSTEM_CALL */
\r
901 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
903 pvReturn = pvPortMalloc( xSize );
\r
905 vPortResetPrivilege( xRunningPrivileged );
\r
909 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
910 /*-----------------------------------------------------------*/
\r
912 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
913 void MPU_vPortFree( void *pv ) /* FREERTOS_SYSTEM_CALL */
\r
915 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
919 vPortResetPrivilege( xRunningPrivileged );
\r
921 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
922 /*-----------------------------------------------------------*/
\r
924 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
925 void MPU_vPortInitialiseBlocks( void ) /* FREERTOS_SYSTEM_CALL */
\r
927 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
929 vPortInitialiseBlocks();
\r
931 vPortResetPrivilege( xRunningPrivileged );
\r
933 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
934 /*-----------------------------------------------------------*/
\r
936 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
937 size_t MPU_xPortGetFreeHeapSize( void ) /* FREERTOS_SYSTEM_CALL */
\r
940 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
942 xReturn = xPortGetFreeHeapSize();
\r
944 vPortResetPrivilege( xRunningPrivileged );
\r
948 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
949 /*-----------------------------------------------------------*/
\r
951 #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
952 TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction ) /* FREERTOS_SYSTEM_CALL */
\r
954 TimerHandle_t xReturn;
\r
955 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
957 xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );
\r
958 vPortResetPrivilege( xRunningPrivileged );
\r
963 /*-----------------------------------------------------------*/
\r
965 #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
966 TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxTimerBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
968 TimerHandle_t xReturn;
\r
969 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
971 xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );
\r
972 vPortResetPrivilege( xRunningPrivileged );
\r
977 /*-----------------------------------------------------------*/
\r
979 #if( configUSE_TIMERS == 1 )
\r
980 void *MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
983 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
985 pvReturn = pvTimerGetTimerID( xTimer );
\r
986 vPortResetPrivilege( xRunningPrivileged );
\r
991 /*-----------------------------------------------------------*/
\r
993 #if( configUSE_TIMERS == 1 )
\r
994 void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID ) /* FREERTOS_SYSTEM_CALL */
\r
996 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
998 vTimerSetTimerID( xTimer, pvNewID );
\r
999 vPortResetPrivilege( xRunningPrivileged );
\r
1002 /*-----------------------------------------------------------*/
\r
1004 #if( configUSE_TIMERS == 1 )
\r
1005 BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
1007 BaseType_t xReturn;
\r
1008 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1010 xReturn = xTimerIsTimerActive( xTimer );
\r
1011 vPortResetPrivilege( xRunningPrivileged );
\r
1016 /*-----------------------------------------------------------*/
\r
1018 #if( configUSE_TIMERS == 1 )
\r
1019 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
\r
1021 TaskHandle_t xReturn;
\r
1022 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1024 xReturn = xTimerGetTimerDaemonTaskHandle();
\r
1025 vPortResetPrivilege( xRunningPrivileged );
\r
1030 /*-----------------------------------------------------------*/
\r
1032 #if( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
1033 BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1035 BaseType_t xReturn;
\r
1036 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1038 xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );
\r
1039 vPortResetPrivilege( xRunningPrivileged );
\r
1044 /*-----------------------------------------------------------*/
\r
1046 #if( configUSE_TIMERS == 1 )
\r
1047 void MPU_vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload ) /* FREERTOS_SYSTEM_CALL */
\r
1049 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1051 vTimerSetReloadMode( xTimer, uxAutoReload );
\r
1052 vPortResetPrivilege( xRunningPrivileged );
\r
1055 /*-----------------------------------------------------------*/
\r
1057 #if( configUSE_TIMERS == 1 )
\r
1058 const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
1060 const char * pcReturn;
\r
1061 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1063 pcReturn = pcTimerGetName( xTimer );
\r
1064 vPortResetPrivilege( xRunningPrivileged );
\r
1069 /*-----------------------------------------------------------*/
\r
1071 #if( configUSE_TIMERS == 1 )
\r
1072 TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
1074 TickType_t xReturn;
\r
1075 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1077 xReturn = xTimerGetPeriod( xTimer );
\r
1078 vPortResetPrivilege( xRunningPrivileged );
\r
1083 /*-----------------------------------------------------------*/
\r
1085 #if( configUSE_TIMERS == 1 )
\r
1086 TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
1088 TickType_t xReturn;
\r
1089 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1091 xReturn = xTimerGetExpiryTime( xTimer );
\r
1092 vPortResetPrivilege( xRunningPrivileged );
\r
1097 /*-----------------------------------------------------------*/
\r
1099 #if( configUSE_TIMERS == 1 )
\r
1100 BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1102 BaseType_t xReturn;
\r
1103 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1105 xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
\r
1106 vPortResetPrivilege( xRunningPrivileged );
\r
1111 /*-----------------------------------------------------------*/
\r
1113 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
1114 EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */
\r
1116 EventGroupHandle_t xReturn;
\r
1117 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1119 xReturn = xEventGroupCreate();
\r
1120 vPortResetPrivilege( xRunningPrivileged );
\r
1125 /*-----------------------------------------------------------*/
\r
1127 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
1128 EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1130 EventGroupHandle_t xReturn;
\r
1131 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1133 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
\r
1134 vPortResetPrivilege( xRunningPrivileged );
\r
1139 /*-----------------------------------------------------------*/
\r
1141 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1143 EventBits_t xReturn;
\r
1144 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1146 xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
\r
1147 vPortResetPrivilege( xRunningPrivileged );
\r
1151 /*-----------------------------------------------------------*/
\r
1153 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */
\r
1155 EventBits_t xReturn;
\r
1156 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1158 xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
\r
1159 vPortResetPrivilege( xRunningPrivileged );
\r
1163 /*-----------------------------------------------------------*/
\r
1165 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */
\r
1167 EventBits_t xReturn;
\r
1168 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1170 xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
\r
1171 vPortResetPrivilege( xRunningPrivileged );
\r
1175 /*-----------------------------------------------------------*/
\r
1177 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1179 EventBits_t xReturn;
\r
1180 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1182 xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
\r
1183 vPortResetPrivilege( xRunningPrivileged );
\r
1187 /*-----------------------------------------------------------*/
\r
1189 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */
\r
1191 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1193 vEventGroupDelete( xEventGroup );
\r
1194 vPortResetPrivilege( xRunningPrivileged );
\r
1196 /*-----------------------------------------------------------*/
\r
1198 size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1201 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1203 xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
\r
1204 vPortResetPrivilege( xRunningPrivileged );
\r
1208 /*-----------------------------------------------------------*/
\r
1210 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1213 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1215 xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
\r
1216 vPortResetPrivilege( xRunningPrivileged );
\r
1220 /*-----------------------------------------------------------*/
\r
1222 size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1225 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1227 xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
\r
1228 vPortResetPrivilege( xRunningPrivileged );
\r
1232 /*-----------------------------------------------------------*/
\r
1234 void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1236 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1238 vStreamBufferDelete( xStreamBuffer );
\r
1239 vPortResetPrivilege( xRunningPrivileged );
\r
1241 /*-----------------------------------------------------------*/
\r
1243 BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1245 BaseType_t xReturn;
\r
1246 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1248 xReturn = xStreamBufferIsFull( xStreamBuffer );
\r
1249 vPortResetPrivilege( xRunningPrivileged );
\r
1253 /*-----------------------------------------------------------*/
\r
1255 BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1257 BaseType_t xReturn;
\r
1258 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1260 xReturn = xStreamBufferIsEmpty( xStreamBuffer );
\r
1261 vPortResetPrivilege( xRunningPrivileged );
\r
1265 /*-----------------------------------------------------------*/
\r
1267 BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1269 BaseType_t xReturn;
\r
1270 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1272 xReturn = xStreamBufferReset( xStreamBuffer );
\r
1273 vPortResetPrivilege( xRunningPrivileged );
\r
1277 /*-----------------------------------------------------------*/
\r
1279 size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1282 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1284 xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
\r
1285 vPortResetPrivilege( xRunningPrivileged );
\r
1289 /*-----------------------------------------------------------*/
\r
1291 size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1294 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1296 xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
\r
1297 vPortResetPrivilege( xRunningPrivileged );
\r
1301 /*-----------------------------------------------------------*/
\r
1303 BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */
\r
1305 BaseType_t xReturn;
\r
1306 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1308 xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
\r
1309 vPortResetPrivilege( xRunningPrivileged );
\r
1313 /*-----------------------------------------------------------*/
\r
1315 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
1316 StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1318 StreamBufferHandle_t xReturn;
\r
1319 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1321 xReturn = xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer );
\r
1322 vPortResetPrivilege( xRunningPrivileged );
\r
1326 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
1327 /*-----------------------------------------------------------*/
\r
1329 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
1330 StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer, uint8_t * const pucStreamBufferStorageArea, StaticStreamBuffer_t * const pxStaticStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1332 StreamBufferHandle_t xReturn;
\r
1333 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1335 xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer, pucStreamBufferStorageArea, pxStaticStreamBuffer );
\r
1336 vPortResetPrivilege( xRunningPrivileged );
\r
1340 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
1341 /*-----------------------------------------------------------*/
\r
1344 /* Functions that the application writer wants to execute in privileged mode
\r
1345 can be defined in application_defined_privileged_functions.h. The functions
\r
1346 must take the same format as those above whereby the privilege state on exit
\r
1347 equals the privilege state on entry. For example:
\r
1349 void MPU_FunctionName( [parameters ] )
\r
1351 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1353 FunctionName( [parameters ] );
\r
1355 vPortResetPrivilege( xRunningPrivileged );
\r
1359 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
\r
1360 #include "application_defined_privileged_functions.h"
\r