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 TickType_t MPU_xTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */
\r
370 TickType_t xReturn;
\r
371 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
373 xReturn = xTaskGetIdleRunTimeCounter();
\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 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
\r
455 UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
\r
457 UBaseType_t uxReturn;
\r
458 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
460 uxReturn = uxTaskGetStackHighWaterMark( xTask );
\r
461 vPortResetPrivilege( xRunningPrivileged );
\r
465 /*-----------------------------------------------------------*/
\r
467 #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
\r
468 configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
\r
470 configSTACK_DEPTH_TYPE uxReturn;
\r
471 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
473 uxReturn = uxTaskGetStackHighWaterMark2( xTask );
\r
474 vPortResetPrivilege( xRunningPrivileged );
\r
478 /*-----------------------------------------------------------*/
\r
480 #if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )
\r
481 TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
\r
483 TaskHandle_t xReturn;
\r
484 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
486 xReturn = xTaskGetCurrentTaskHandle();
\r
487 vPortResetPrivilege( xRunningPrivileged );
\r
491 /*-----------------------------------------------------------*/
\r
493 #if ( INCLUDE_xTaskGetSchedulerState == 1 )
\r
494 BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */
\r
496 BaseType_t xReturn;
\r
497 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
499 xReturn = xTaskGetSchedulerState();
\r
500 vPortResetPrivilege( xRunningPrivileged );
\r
504 /*-----------------------------------------------------------*/
\r
506 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */
\r
508 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
510 vTaskSetTimeOutState( pxTimeOut );
\r
511 vPortResetPrivilege( xRunningPrivileged );
\r
513 /*-----------------------------------------------------------*/
\r
515 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
517 BaseType_t xReturn;
\r
518 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
520 xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
\r
521 vPortResetPrivilege( xRunningPrivileged );
\r
524 /*-----------------------------------------------------------*/
\r
526 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
527 BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */
\r
529 BaseType_t xReturn;
\r
530 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
532 xReturn = xTaskGenericNotify( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue );
\r
533 vPortResetPrivilege( xRunningPrivileged );
\r
537 /*-----------------------------------------------------------*/
\r
539 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
540 BaseType_t MPU_xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
542 BaseType_t xReturn;
\r
543 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
545 xReturn = xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
\r
546 vPortResetPrivilege( xRunningPrivileged );
\r
550 /*-----------------------------------------------------------*/
\r
552 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
553 uint32_t MPU_ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
556 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
558 ulReturn = ulTaskNotifyTake( xClearCountOnExit, xTicksToWait );
\r
559 vPortResetPrivilege( xRunningPrivileged );
\r
563 /*-----------------------------------------------------------*/
\r
565 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
566 BaseType_t MPU_xTaskNotifyStateClear( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
\r
568 BaseType_t xReturn;
\r
569 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
571 xReturn = xTaskNotifyStateClear( xTask );
\r
572 vPortResetPrivilege( xRunningPrivileged );
\r
576 /*-----------------------------------------------------------*/
\r
578 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
579 QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize, uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
\r
581 QueueHandle_t xReturn;
\r
582 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
584 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
\r
585 vPortResetPrivilege( xRunningPrivileged );
\r
589 /*-----------------------------------------------------------*/
\r
591 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
592 QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
\r
594 QueueHandle_t xReturn;
\r
595 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
597 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
\r
598 vPortResetPrivilege( xRunningPrivileged );
\r
602 /*-----------------------------------------------------------*/
\r
604 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue, BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */
\r
606 BaseType_t xReturn;
\r
607 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
609 xReturn = xQueueGenericReset( pxQueue, xNewQueue );
\r
610 vPortResetPrivilege( xRunningPrivileged );
\r
613 /*-----------------------------------------------------------*/
\r
615 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */
\r
617 BaseType_t xReturn;
\r
618 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
620 xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
\r
621 vPortResetPrivilege( xRunningPrivileged );
\r
624 /*-----------------------------------------------------------*/
\r
626 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */
\r
628 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
629 UBaseType_t uxReturn;
\r
631 uxReturn = uxQueueMessagesWaiting( pxQueue );
\r
632 vPortResetPrivilege( xRunningPrivileged );
\r
635 /*-----------------------------------------------------------*/
\r
637 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
\r
639 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
640 UBaseType_t uxReturn;
\r
642 uxReturn = uxQueueSpacesAvailable( xQueue );
\r
643 vPortResetPrivilege( xRunningPrivileged );
\r
646 /*-----------------------------------------------------------*/
\r
648 BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue, void * const pvBuffer, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
650 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
651 BaseType_t xReturn;
\r
653 xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
\r
654 vPortResetPrivilege( xRunningPrivileged );
\r
657 /*-----------------------------------------------------------*/
\r
659 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
661 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
662 BaseType_t xReturn;
\r
664 xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
\r
665 vPortResetPrivilege( xRunningPrivileged );
\r
668 /*-----------------------------------------------------------*/
\r
670 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
672 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
673 BaseType_t xReturn;
\r
675 xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
\r
676 vPortResetPrivilege( xRunningPrivileged );
\r
679 /*-----------------------------------------------------------*/
\r
681 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
\r
682 TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */
\r
684 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
687 xReturn = xQueueGetMutexHolder( xSemaphore );
\r
688 vPortResetPrivilege( xRunningPrivileged );
\r
692 /*-----------------------------------------------------------*/
\r
694 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
695 QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
\r
697 QueueHandle_t xReturn;
\r
698 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
700 xReturn = xQueueCreateMutex( ucQueueType );
\r
701 vPortResetPrivilege( xRunningPrivileged );
\r
705 /*-----------------------------------------------------------*/
\r
707 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
708 QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
\r
710 QueueHandle_t xReturn;
\r
711 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
713 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
\r
714 vPortResetPrivilege( xRunningPrivileged );
\r
718 /*-----------------------------------------------------------*/
\r
720 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
721 QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue, UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */
\r
723 QueueHandle_t xReturn;
\r
724 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
726 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
\r
727 vPortResetPrivilege( xRunningPrivileged );
\r
731 /*-----------------------------------------------------------*/
\r
733 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
735 QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
\r
737 QueueHandle_t xReturn;
\r
738 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
740 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
\r
741 vPortResetPrivilege( xRunningPrivileged );
\r
745 /*-----------------------------------------------------------*/
\r
747 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
748 BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */
\r
750 BaseType_t xReturn;
\r
751 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
753 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
\r
754 vPortResetPrivilege( xRunningPrivileged );
\r
758 /*-----------------------------------------------------------*/
\r
760 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
761 BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */
\r
763 BaseType_t xReturn;
\r
764 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
766 xReturn = xQueueGiveMutexRecursive( xMutex );
\r
767 vPortResetPrivilege( xRunningPrivileged );
\r
771 /*-----------------------------------------------------------*/
\r
773 #if( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
774 QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */
\r
776 QueueSetHandle_t xReturn;
\r
777 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
779 xReturn = xQueueCreateSet( uxEventQueueLength );
\r
780 vPortResetPrivilege( xRunningPrivileged );
\r
784 /*-----------------------------------------------------------*/
\r
786 #if ( configUSE_QUEUE_SETS == 1 )
\r
787 QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */
\r
789 QueueSetMemberHandle_t xReturn;
\r
790 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
792 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
\r
793 vPortResetPrivilege( xRunningPrivileged );
\r
797 /*-----------------------------------------------------------*/
\r
799 #if ( configUSE_QUEUE_SETS == 1 )
\r
800 BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
\r
802 BaseType_t xReturn;
\r
803 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
805 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
\r
806 vPortResetPrivilege( xRunningPrivileged );
\r
810 /*-----------------------------------------------------------*/
\r
812 #if ( configUSE_QUEUE_SETS == 1 )
\r
813 BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
\r
815 BaseType_t xReturn;
\r
816 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
818 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
\r
819 vPortResetPrivilege( xRunningPrivileged );
\r
823 /*-----------------------------------------------------------*/
\r
825 #if configQUEUE_REGISTRY_SIZE > 0
\r
826 void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName ) /* FREERTOS_SYSTEM_CALL */
\r
828 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
830 vQueueAddToRegistry( xQueue, pcName );
\r
832 vPortResetPrivilege( xRunningPrivileged );
\r
835 /*-----------------------------------------------------------*/
\r
837 #if configQUEUE_REGISTRY_SIZE > 0
\r
838 void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
\r
840 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
842 vQueueUnregisterQueue( xQueue );
\r
844 vPortResetPrivilege( xRunningPrivileged );
\r
847 /*-----------------------------------------------------------*/
\r
849 #if configQUEUE_REGISTRY_SIZE > 0
\r
850 const char *MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
\r
852 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
853 const char *pcReturn;
\r
855 pcReturn = pcQueueGetName( xQueue );
\r
857 vPortResetPrivilege( xRunningPrivileged );
\r
861 /*-----------------------------------------------------------*/
\r
863 void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
\r
865 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
867 vQueueDelete( xQueue );
\r
869 vPortResetPrivilege( xRunningPrivileged );
\r
871 /*-----------------------------------------------------------*/
\r
873 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
874 void *MPU_pvPortMalloc( size_t xSize ) /* FREERTOS_SYSTEM_CALL */
\r
877 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
879 pvReturn = pvPortMalloc( xSize );
\r
881 vPortResetPrivilege( xRunningPrivileged );
\r
885 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
886 /*-----------------------------------------------------------*/
\r
888 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
889 void MPU_vPortFree( void *pv ) /* FREERTOS_SYSTEM_CALL */
\r
891 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
895 vPortResetPrivilege( xRunningPrivileged );
\r
897 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
898 /*-----------------------------------------------------------*/
\r
900 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
901 void MPU_vPortInitialiseBlocks( void ) /* FREERTOS_SYSTEM_CALL */
\r
903 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
905 vPortInitialiseBlocks();
\r
907 vPortResetPrivilege( xRunningPrivileged );
\r
909 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
910 /*-----------------------------------------------------------*/
\r
912 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
913 size_t MPU_xPortGetFreeHeapSize( void ) /* FREERTOS_SYSTEM_CALL */
\r
916 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
918 xReturn = xPortGetFreeHeapSize();
\r
920 vPortResetPrivilege( xRunningPrivileged );
\r
924 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
925 /*-----------------------------------------------------------*/
\r
927 #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
928 TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction ) /* FREERTOS_SYSTEM_CALL */
\r
930 TimerHandle_t xReturn;
\r
931 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
933 xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );
\r
934 vPortResetPrivilege( xRunningPrivileged );
\r
939 /*-----------------------------------------------------------*/
\r
941 #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
942 TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxTimerBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
944 TimerHandle_t xReturn;
\r
945 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
947 xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );
\r
948 vPortResetPrivilege( xRunningPrivileged );
\r
953 /*-----------------------------------------------------------*/
\r
955 #if( configUSE_TIMERS == 1 )
\r
956 void *MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
959 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
961 pvReturn = pvTimerGetTimerID( xTimer );
\r
962 vPortResetPrivilege( xRunningPrivileged );
\r
967 /*-----------------------------------------------------------*/
\r
969 #if( configUSE_TIMERS == 1 )
\r
970 void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID ) /* FREERTOS_SYSTEM_CALL */
\r
972 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
974 vTimerSetTimerID( xTimer, pvNewID );
\r
975 vPortResetPrivilege( xRunningPrivileged );
\r
978 /*-----------------------------------------------------------*/
\r
980 #if( configUSE_TIMERS == 1 )
\r
981 BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
983 BaseType_t xReturn;
\r
984 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
986 xReturn = xTimerIsTimerActive( xTimer );
\r
987 vPortResetPrivilege( xRunningPrivileged );
\r
992 /*-----------------------------------------------------------*/
\r
994 #if( configUSE_TIMERS == 1 )
\r
995 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
\r
997 TaskHandle_t xReturn;
\r
998 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1000 xReturn = xTimerGetTimerDaemonTaskHandle();
\r
1001 vPortResetPrivilege( xRunningPrivileged );
\r
1006 /*-----------------------------------------------------------*/
\r
1008 #if( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
1009 BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1011 BaseType_t xReturn;
\r
1012 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1014 xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );
\r
1015 vPortResetPrivilege( xRunningPrivileged );
\r
1020 /*-----------------------------------------------------------*/
\r
1022 #if( configUSE_TIMERS == 1 )
\r
1023 void MPU_vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload ) /* FREERTOS_SYSTEM_CALL */
\r
1025 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1027 vTimerSetReloadMode( xTimer, uxAutoReload );
\r
1028 vPortResetPrivilege( xRunningPrivileged );
\r
1031 /*-----------------------------------------------------------*/
\r
1033 #if( configUSE_TIMERS == 1 )
\r
1034 const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
1036 const char * pcReturn;
\r
1037 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1039 pcReturn = pcTimerGetName( xTimer );
\r
1040 vPortResetPrivilege( xRunningPrivileged );
\r
1045 /*-----------------------------------------------------------*/
\r
1047 #if( configUSE_TIMERS == 1 )
\r
1048 TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
1050 TickType_t xReturn;
\r
1051 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1053 xReturn = xTimerGetPeriod( xTimer );
\r
1054 vPortResetPrivilege( xRunningPrivileged );
\r
1059 /*-----------------------------------------------------------*/
\r
1061 #if( configUSE_TIMERS == 1 )
\r
1062 TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
\r
1064 TickType_t xReturn;
\r
1065 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1067 xReturn = xTimerGetExpiryTime( xTimer );
\r
1068 vPortResetPrivilege( xRunningPrivileged );
\r
1073 /*-----------------------------------------------------------*/
\r
1075 #if( configUSE_TIMERS == 1 )
\r
1076 BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1078 BaseType_t xReturn;
\r
1079 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1081 xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
\r
1082 vPortResetPrivilege( xRunningPrivileged );
\r
1087 /*-----------------------------------------------------------*/
\r
1089 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
1090 EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */
\r
1092 EventGroupHandle_t xReturn;
\r
1093 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1095 xReturn = xEventGroupCreate();
\r
1096 vPortResetPrivilege( xRunningPrivileged );
\r
1101 /*-----------------------------------------------------------*/
\r
1103 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
1104 EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1106 EventGroupHandle_t xReturn;
\r
1107 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1109 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
\r
1110 vPortResetPrivilege( xRunningPrivileged );
\r
1115 /*-----------------------------------------------------------*/
\r
1117 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1119 EventBits_t xReturn;
\r
1120 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1122 xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
\r
1123 vPortResetPrivilege( xRunningPrivileged );
\r
1127 /*-----------------------------------------------------------*/
\r
1129 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */
\r
1131 EventBits_t xReturn;
\r
1132 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1134 xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
\r
1135 vPortResetPrivilege( xRunningPrivileged );
\r
1139 /*-----------------------------------------------------------*/
\r
1141 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */
\r
1143 EventBits_t xReturn;
\r
1144 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1146 xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
\r
1147 vPortResetPrivilege( xRunningPrivileged );
\r
1151 /*-----------------------------------------------------------*/
\r
1153 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1155 EventBits_t xReturn;
\r
1156 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1158 xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
\r
1159 vPortResetPrivilege( xRunningPrivileged );
\r
1163 /*-----------------------------------------------------------*/
\r
1165 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */
\r
1167 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1169 vEventGroupDelete( xEventGroup );
\r
1170 vPortResetPrivilege( xRunningPrivileged );
\r
1172 /*-----------------------------------------------------------*/
\r
1174 size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1177 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1179 xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
\r
1180 vPortResetPrivilege( xRunningPrivileged );
\r
1184 /*-----------------------------------------------------------*/
\r
1186 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1189 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1191 xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
\r
1192 vPortResetPrivilege( xRunningPrivileged );
\r
1196 /*-----------------------------------------------------------*/
\r
1198 size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
\r
1201 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1203 xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
\r
1204 vPortResetPrivilege( xRunningPrivileged );
\r
1208 /*-----------------------------------------------------------*/
\r
1210 void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1212 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1214 vStreamBufferDelete( xStreamBuffer );
\r
1215 vPortResetPrivilege( xRunningPrivileged );
\r
1217 /*-----------------------------------------------------------*/
\r
1219 BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1221 BaseType_t xReturn;
\r
1222 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1224 xReturn = xStreamBufferIsFull( xStreamBuffer );
\r
1225 vPortResetPrivilege( xRunningPrivileged );
\r
1229 /*-----------------------------------------------------------*/
\r
1231 BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1233 BaseType_t xReturn;
\r
1234 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1236 xReturn = xStreamBufferIsEmpty( xStreamBuffer );
\r
1237 vPortResetPrivilege( xRunningPrivileged );
\r
1241 /*-----------------------------------------------------------*/
\r
1243 BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1245 BaseType_t xReturn;
\r
1246 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1248 xReturn = xStreamBufferReset( xStreamBuffer );
\r
1249 vPortResetPrivilege( xRunningPrivileged );
\r
1253 /*-----------------------------------------------------------*/
\r
1255 size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1258 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1260 xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
\r
1261 vPortResetPrivilege( xRunningPrivileged );
\r
1265 /*-----------------------------------------------------------*/
\r
1267 size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1270 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1272 xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
\r
1273 vPortResetPrivilege( xRunningPrivileged );
\r
1277 /*-----------------------------------------------------------*/
\r
1279 BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */
\r
1281 BaseType_t xReturn;
\r
1282 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1284 xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
\r
1285 vPortResetPrivilege( xRunningPrivileged );
\r
1289 /*-----------------------------------------------------------*/
\r
1291 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
1292 StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1294 StreamBufferHandle_t xReturn;
\r
1295 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1297 xReturn = xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer );
\r
1298 vPortResetPrivilege( xRunningPrivileged );
\r
1302 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
1303 /*-----------------------------------------------------------*/
\r
1305 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
1306 StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer, uint8_t * const pucStreamBufferStorageArea, StaticStreamBuffer_t * const pxStaticStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
\r
1308 StreamBufferHandle_t xReturn;
\r
1309 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1311 xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer, pucStreamBufferStorageArea, pxStaticStreamBuffer );
\r
1312 vPortResetPrivilege( xRunningPrivileged );
\r
1316 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
1317 /*-----------------------------------------------------------*/
\r
1320 /* Functions that the application writer wants to execute in privileged mode
\r
1321 can be defined in application_defined_privileged_functions.h. The functions
\r
1322 must take the same format as those above whereby the privilege state on exit
\r
1323 equals the privilege state on entry. For example:
\r
1325 void MPU_FunctionName( [parameters ] )
\r
1327 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1329 FunctionName( [parameters ] );
\r
1331 vPortResetPrivilege( xRunningPrivileged );
\r
1335 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
\r
1336 #include "application_defined_privileged_functions.h"
\r