2 FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
\r
5 VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
\r
7 This file is part of the FreeRTOS distribution.
\r
9 FreeRTOS is free software; you can redistribute it and/or modify it under
\r
10 the terms of the GNU General Public License (version 2) as published by the
\r
11 Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
\r
13 ***************************************************************************
\r
14 >>! NOTE: The modification to the GPL is included to allow you to !<<
\r
15 >>! distribute a combined work that includes FreeRTOS without being !<<
\r
16 >>! obliged to provide the source code for proprietary components !<<
\r
17 >>! outside of the FreeRTOS kernel. !<<
\r
18 ***************************************************************************
\r
20 FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
\r
21 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
\r
22 FOR A PARTICULAR PURPOSE. Full license text is available on the following
\r
23 link: http://www.freertos.org/a00114.html
\r
25 ***************************************************************************
\r
27 * FreeRTOS provides completely free yet professionally developed, *
\r
28 * robust, strictly quality controlled, supported, and cross *
\r
29 * platform software that is more than just the market leader, it *
\r
30 * is the industry's de facto standard. *
\r
32 * Help yourself get started quickly while simultaneously helping *
\r
33 * to support the FreeRTOS project by purchasing a FreeRTOS *
\r
34 * tutorial book, reference manual, or both: *
\r
35 * http://www.FreeRTOS.org/Documentation *
\r
37 ***************************************************************************
\r
39 http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
\r
40 the FAQ page "My application does not run, what could be wrong?". Have you
\r
41 defined configASSERT()?
\r
43 http://www.FreeRTOS.org/support - In return for receiving this top quality
\r
44 embedded software for free we request you assist our global community by
\r
45 participating in the support forum.
\r
47 http://www.FreeRTOS.org/training - Investing in training allows your team to
\r
48 be as productive as possible as early as possible. Now you can receive
\r
49 FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
\r
50 Ltd, and the world's leading authority on the world's leading RTOS.
\r
52 http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
\r
53 including FreeRTOS+Trace - an indispensable productivity tool, a DOS
\r
54 compatible FAT file system, and our tiny thread aware UDP/IP stack.
\r
56 http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
\r
57 Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
\r
59 http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
\r
60 Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
\r
61 licenses offer ticketed support, indemnification and commercial middleware.
\r
63 http://www.SafeRTOS.com - High Integrity Systems also provide a safety
\r
64 engineered and independently SIL3 certified version for use in safety and
\r
65 mission critical applications that require provable dependability.
\r
71 * Implementation of the wrapper functions used to raise the processor privilege
\r
72 * before calling a standard FreeRTOS API function.
\r
75 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
\r
76 all the API functions to use the MPU wrappers. That should only be done when
\r
77 task.h is included from an application file. */
\r
78 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
\r
80 /* Scheduler includes. */
\r
81 #include "FreeRTOS.h"
\r
85 #include "event_groups.h"
\r
86 #include "mpu_prototypes.h"
\r
88 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
\r
91 * Checks to see if being called from the context of an unprivileged task, and
\r
92 * if so raises the privilege level and returns false - otherwise does nothing
\r
93 * other than return true.
\r
95 extern BaseType_t xPortRaisePrivilege( void );
\r
97 /*-----------------------------------------------------------*/
\r
99 BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )
\r
101 BaseType_t xReturn;
\r
102 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
104 xReturn = xTaskCreateRestricted( pxTaskDefinition, pxCreatedTask );
\r
105 vPortResetPrivilege( xRunningPrivileged );
\r
108 /*-----------------------------------------------------------*/
\r
110 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
111 BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode, const char * const pcName, uint16_t usStackDepth, void *pvParameters, UBaseType_t uxPriority, TaskHandle_t *pxCreatedTask )
\r
113 BaseType_t xReturn;
\r
114 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
116 xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );
\r
117 vPortResetPrivilege( xRunningPrivileged );
\r
120 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
121 /*-----------------------------------------------------------*/
\r
123 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
124 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 )
\r
126 TaskHandle_t xReturn;
\r
127 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
129 xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
\r
130 vPortResetPrivilege( xRunningPrivileged );
\r
133 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
134 /*-----------------------------------------------------------*/
\r
136 void MPU_vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const xRegions )
\r
138 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
140 vTaskAllocateMPURegions( xTask, xRegions );
\r
141 vPortResetPrivilege( xRunningPrivileged );
\r
143 /*-----------------------------------------------------------*/
\r
145 #if ( INCLUDE_vTaskDelete == 1 )
\r
146 void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete )
\r
148 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
150 vTaskDelete( pxTaskToDelete );
\r
151 vPortResetPrivilege( xRunningPrivileged );
\r
154 /*-----------------------------------------------------------*/
\r
156 #if ( INCLUDE_vTaskDelayUntil == 1 )
\r
157 void MPU_vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, TickType_t xTimeIncrement )
\r
159 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
161 vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
\r
162 vPortResetPrivilege( xRunningPrivileged );
\r
165 /*-----------------------------------------------------------*/
\r
167 #if ( INCLUDE_xTaskAbortDelay == 1 )
\r
168 BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask )
\r
170 BaseType_t xReturn;
\r
171 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
173 xReturn = xTaskAbortDelay( xTask );
\r
174 vPortResetPrivilege( xRunningPrivileged );
\r
178 /*-----------------------------------------------------------*/
\r
180 #if ( INCLUDE_vTaskDelay == 1 )
\r
181 void MPU_vTaskDelay( TickType_t xTicksToDelay )
\r
183 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
185 vTaskDelay( xTicksToDelay );
\r
186 vPortResetPrivilege( xRunningPrivileged );
\r
189 /*-----------------------------------------------------------*/
\r
191 #if ( INCLUDE_uxTaskPriorityGet == 1 )
\r
192 UBaseType_t MPU_uxTaskPriorityGet( TaskHandle_t pxTask )
\r
194 UBaseType_t uxReturn;
\r
195 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
197 uxReturn = uxTaskPriorityGet( pxTask );
\r
198 vPortResetPrivilege( xRunningPrivileged );
\r
202 /*-----------------------------------------------------------*/
\r
204 #if ( INCLUDE_vTaskPrioritySet == 1 )
\r
205 void MPU_vTaskPrioritySet( TaskHandle_t pxTask, UBaseType_t uxNewPriority )
\r
207 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
209 vTaskPrioritySet( pxTask, uxNewPriority );
\r
210 vPortResetPrivilege( xRunningPrivileged );
\r
213 /*-----------------------------------------------------------*/
\r
215 #if ( INCLUDE_eTaskGetState == 1 )
\r
216 eTaskState MPU_eTaskGetState( TaskHandle_t pxTask )
\r
218 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
219 eTaskState eReturn;
\r
221 eReturn = eTaskGetState( pxTask );
\r
222 vPortResetPrivilege( xRunningPrivileged );
\r
226 /*-----------------------------------------------------------*/
\r
228 #if( configUSE_TRACE_FACILITY == 1 )
\r
229 void MPU_vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState )
\r
231 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
233 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
\r
234 vPortResetPrivilege( xRunningPrivileged );
\r
237 /*-----------------------------------------------------------*/
\r
239 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
\r
240 TaskHandle_t MPU_xTaskGetIdleTaskHandle( void )
\r
242 TaskHandle_t xReturn;
\r
243 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
245 xReturn = xTaskGetIdleTaskHandle();
\r
246 vPortResetPrivilege( xRunningPrivileged );
\r
250 /*-----------------------------------------------------------*/
\r
252 #if ( INCLUDE_vTaskSuspend == 1 )
\r
253 void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend )
\r
255 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
257 vTaskSuspend( pxTaskToSuspend );
\r
258 vPortResetPrivilege( xRunningPrivileged );
\r
261 /*-----------------------------------------------------------*/
\r
263 #if ( INCLUDE_vTaskSuspend == 1 )
\r
264 void MPU_vTaskResume( TaskHandle_t pxTaskToResume )
\r
266 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
268 vTaskResume( pxTaskToResume );
\r
269 vPortResetPrivilege( xRunningPrivileged );
\r
272 /*-----------------------------------------------------------*/
\r
274 void MPU_vTaskSuspendAll( void )
\r
276 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
279 vPortResetPrivilege( xRunningPrivileged );
\r
281 /*-----------------------------------------------------------*/
\r
283 BaseType_t MPU_xTaskResumeAll( void )
\r
285 BaseType_t xReturn;
\r
286 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
288 xReturn = xTaskResumeAll();
\r
289 vPortResetPrivilege( xRunningPrivileged );
\r
292 /*-----------------------------------------------------------*/
\r
294 TickType_t MPU_xTaskGetTickCount( void )
\r
296 TickType_t xReturn;
\r
297 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
299 xReturn = xTaskGetTickCount();
\r
300 vPortResetPrivilege( xRunningPrivileged );
\r
303 /*-----------------------------------------------------------*/
\r
305 UBaseType_t MPU_uxTaskGetNumberOfTasks( void )
\r
307 UBaseType_t uxReturn;
\r
308 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
310 uxReturn = uxTaskGetNumberOfTasks();
\r
311 vPortResetPrivilege( xRunningPrivileged );
\r
314 /*-----------------------------------------------------------*/
\r
316 char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery )
\r
319 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
321 pcReturn = pcTaskGetName( xTaskToQuery );
\r
322 vPortResetPrivilege( xRunningPrivileged );
\r
325 /*-----------------------------------------------------------*/
\r
327 #if ( INCLUDE_xTaskGetHandle == 1 )
\r
328 TaskHandle_t MPU_xTaskGetHandle( const char *pcNameToQuery )
\r
330 TaskHandle_t xReturn;
\r
331 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
333 xReturn = xTaskGetHandle( pcNameToQuery );
\r
334 vPortResetPrivilege( xRunningPrivileged );
\r
338 /*-----------------------------------------------------------*/
\r
340 #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )
\r
341 void MPU_vTaskList( char *pcWriteBuffer )
\r
343 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
345 vTaskList( pcWriteBuffer );
\r
346 vPortResetPrivilege( xRunningPrivileged );
\r
349 /*-----------------------------------------------------------*/
\r
351 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )
\r
352 void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer )
\r
354 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
356 vTaskGetRunTimeStats( pcWriteBuffer );
\r
357 vPortResetPrivilege( xRunningPrivileged );
\r
360 /*-----------------------------------------------------------*/
\r
362 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
363 void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxTagValue )
\r
365 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
367 vTaskSetApplicationTaskTag( xTask, pxTagValue );
\r
368 vPortResetPrivilege( xRunningPrivileged );
\r
371 /*-----------------------------------------------------------*/
\r
373 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
374 TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask )
\r
376 TaskHookFunction_t xReturn;
\r
377 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
379 xReturn = xTaskGetApplicationTaskTag( xTask );
\r
380 vPortResetPrivilege( xRunningPrivileged );
\r
384 /*-----------------------------------------------------------*/
\r
386 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
\r
387 void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue )
\r
389 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
391 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
\r
392 vPortResetPrivilege( xRunningPrivileged );
\r
395 /*-----------------------------------------------------------*/
\r
397 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
\r
398 void *MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex )
\r
401 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
403 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
\r
404 vPortResetPrivilege( xRunningPrivileged );
\r
408 /*-----------------------------------------------------------*/
\r
410 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
411 BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter )
\r
413 BaseType_t xReturn;
\r
414 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
416 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
\r
417 vPortResetPrivilege( xRunningPrivileged );
\r
421 /*-----------------------------------------------------------*/
\r
423 #if ( configUSE_TRACE_FACILITY == 1 )
\r
424 UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t *pxTaskStatusArray, UBaseType_t uxArraySize, uint32_t *pulTotalRunTime )
\r
426 UBaseType_t uxReturn;
\r
427 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
429 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
\r
430 vPortResetPrivilege( xRunningPrivileged );
\r
434 /*-----------------------------------------------------------*/
\r
436 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
\r
437 UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask )
\r
439 UBaseType_t uxReturn;
\r
440 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
442 uxReturn = uxTaskGetStackHighWaterMark( xTask );
\r
443 vPortResetPrivilege( xRunningPrivileged );
\r
447 /*-----------------------------------------------------------*/
\r
449 #if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )
\r
450 TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void )
\r
452 TaskHandle_t xReturn;
\r
453 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
455 xReturn = xTaskGetCurrentTaskHandle();
\r
456 vPortResetPrivilege( xRunningPrivileged );
\r
460 /*-----------------------------------------------------------*/
\r
462 #if ( INCLUDE_xTaskGetSchedulerState == 1 )
\r
463 BaseType_t MPU_xTaskGetSchedulerState( void )
\r
465 BaseType_t xReturn;
\r
466 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
468 xReturn = xTaskGetSchedulerState();
\r
469 vPortResetPrivilege( xRunningPrivileged );
\r
473 /*-----------------------------------------------------------*/
\r
475 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )
\r
477 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
479 vTaskSetTimeOutState( pxTimeOut );
\r
480 vPortResetPrivilege( xRunningPrivileged );
\r
482 /*-----------------------------------------------------------*/
\r
484 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait )
\r
486 BaseType_t xReturn;
\r
487 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
489 xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
\r
490 vPortResetPrivilege( xRunningPrivileged );
\r
493 /*-----------------------------------------------------------*/
\r
495 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
496 BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )
\r
498 BaseType_t xReturn;
\r
499 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
501 xReturn = xTaskGenericNotify( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue );
\r
502 vPortResetPrivilege( xRunningPrivileged );
\r
506 /*-----------------------------------------------------------*/
\r
508 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
509 BaseType_t MPU_xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )
\r
511 BaseType_t xReturn;
\r
512 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
514 xReturn = xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
\r
515 vPortResetPrivilege( xRunningPrivileged );
\r
519 /*-----------------------------------------------------------*/
\r
521 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
522 uint32_t MPU_ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )
\r
525 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
527 ulReturn = ulTaskNotifyTake( xClearCountOnExit, xTicksToWait );
\r
528 vPortResetPrivilege( xRunningPrivileged );
\r
532 /*-----------------------------------------------------------*/
\r
534 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
535 BaseType_t MPU_xTaskNotifyStateClear( TaskHandle_t xTask )
\r
537 BaseType_t xReturn;
\r
538 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
540 xReturn = xTaskNotifyStateClear( xTask );
\r
541 vPortResetPrivilege( xRunningPrivileged );
\r
545 /*-----------------------------------------------------------*/
\r
547 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
548 QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize, uint8_t ucQueueType )
\r
550 QueueHandle_t xReturn;
\r
551 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
553 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
\r
554 vPortResetPrivilege( xRunningPrivileged );
\r
558 /*-----------------------------------------------------------*/
\r
560 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
561 QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType )
\r
563 QueueHandle_t xReturn;
\r
564 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
566 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
\r
567 vPortResetPrivilege( xRunningPrivileged );
\r
571 /*-----------------------------------------------------------*/
\r
573 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue, BaseType_t xNewQueue )
\r
575 BaseType_t xReturn;
\r
576 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
578 xReturn = xQueueGenericReset( pxQueue, xNewQueue );
\r
579 vPortResetPrivilege( xRunningPrivileged );
\r
582 /*-----------------------------------------------------------*/
\r
584 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition )
\r
586 BaseType_t xReturn;
\r
587 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
589 xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
\r
590 vPortResetPrivilege( xRunningPrivileged );
\r
593 /*-----------------------------------------------------------*/
\r
595 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue )
\r
597 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
598 UBaseType_t uxReturn;
\r
600 uxReturn = uxQueueMessagesWaiting( pxQueue );
\r
601 vPortResetPrivilege( xRunningPrivileged );
\r
604 /*-----------------------------------------------------------*/
\r
606 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue )
\r
608 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
609 UBaseType_t uxReturn;
\r
611 uxReturn = uxQueueSpacesAvailable( xQueue );
\r
612 vPortResetPrivilege( xRunningPrivileged );
\r
615 /*-----------------------------------------------------------*/
\r
617 BaseType_t MPU_xQueueGenericReceive( QueueHandle_t pxQueue, void * const pvBuffer, TickType_t xTicksToWait, BaseType_t xJustPeeking )
\r
619 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
620 BaseType_t xReturn;
\r
622 xReturn = xQueueGenericReceive( pxQueue, pvBuffer, xTicksToWait, xJustPeeking );
\r
623 vPortResetPrivilege( xRunningPrivileged );
\r
626 /*-----------------------------------------------------------*/
\r
628 BaseType_t MPU_xQueuePeekFromISR( QueueHandle_t pxQueue, void * const pvBuffer )
\r
630 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
631 BaseType_t xReturn;
\r
633 xReturn = xQueuePeekFromISR( pxQueue, pvBuffer );
\r
634 vPortResetPrivilege( xRunningPrivileged );
\r
637 /*-----------------------------------------------------------*/
\r
639 void* MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore )
\r
641 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
644 xReturn = ( void * ) xQueueGetMutexHolder( xSemaphore );
\r
645 vPortResetPrivilege( xRunningPrivileged );
\r
648 /*-----------------------------------------------------------*/
\r
650 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
651 QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType )
\r
653 QueueHandle_t xReturn;
\r
654 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
656 xReturn = xQueueCreateMutex( ucQueueType );
\r
657 vPortResetPrivilege( xRunningPrivileged );
\r
661 /*-----------------------------------------------------------*/
\r
663 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
664 QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue )
\r
666 QueueHandle_t xReturn;
\r
667 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
669 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
\r
670 vPortResetPrivilege( xRunningPrivileged );
\r
674 /*-----------------------------------------------------------*/
\r
676 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
677 QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue, UBaseType_t uxInitialCount )
\r
679 QueueHandle_t xReturn;
\r
680 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
682 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
\r
683 vPortResetPrivilege( xRunningPrivileged );
\r
687 /*-----------------------------------------------------------*/
\r
689 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
691 QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue )
\r
693 QueueHandle_t xReturn;
\r
694 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
696 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
\r
697 vPortResetPrivilege( xRunningPrivileged );
\r
701 /*-----------------------------------------------------------*/
\r
703 #if ( configUSE_MUTEXES == 1 )
\r
704 BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xBlockTime )
\r
706 BaseType_t xReturn;
\r
707 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
709 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
\r
710 vPortResetPrivilege( xRunningPrivileged );
\r
714 /*-----------------------------------------------------------*/
\r
716 #if ( configUSE_MUTEXES == 1 )
\r
717 BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex )
\r
719 BaseType_t xReturn;
\r
720 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
722 xReturn = xQueueGiveMutexRecursive( xMutex );
\r
723 vPortResetPrivilege( xRunningPrivileged );
\r
727 /*-----------------------------------------------------------*/
\r
729 #if ( configUSE_QUEUE_SETS == 1 )
\r
730 QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength )
\r
732 QueueSetHandle_t xReturn;
\r
733 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
735 xReturn = xQueueCreateSet( uxEventQueueLength );
\r
736 vPortResetPrivilege( xRunningPrivileged );
\r
740 /*-----------------------------------------------------------*/
\r
742 #if ( configUSE_QUEUE_SETS == 1 )
\r
743 QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, TickType_t xBlockTimeTicks )
\r
745 QueueSetMemberHandle_t xReturn;
\r
746 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
748 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
\r
749 vPortResetPrivilege( xRunningPrivileged );
\r
753 /*-----------------------------------------------------------*/
\r
755 #if ( configUSE_QUEUE_SETS == 1 )
\r
756 BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )
\r
758 BaseType_t xReturn;
\r
759 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
761 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
\r
762 vPortResetPrivilege( xRunningPrivileged );
\r
766 /*-----------------------------------------------------------*/
\r
768 #if ( configUSE_QUEUE_SETS == 1 )
\r
769 BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )
\r
771 BaseType_t xReturn;
\r
772 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
774 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
\r
775 vPortResetPrivilege( xRunningPrivileged );
\r
779 /*-----------------------------------------------------------*/
\r
781 #if configQUEUE_REGISTRY_SIZE > 0
\r
782 void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName )
\r
784 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
786 vQueueAddToRegistry( xQueue, pcName );
\r
788 vPortResetPrivilege( xRunningPrivileged );
\r
791 /*-----------------------------------------------------------*/
\r
793 #if configQUEUE_REGISTRY_SIZE > 0
\r
794 void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue )
\r
796 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
798 vQueueUnregisterQueue( xQueue );
\r
800 vPortResetPrivilege( xRunningPrivileged );
\r
803 /*-----------------------------------------------------------*/
\r
805 #if configQUEUE_REGISTRY_SIZE > 0
\r
806 const char *MPU_pcQueueGetName( QueueHandle_t xQueue )
\r
808 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
809 const char *pcReturn;
\r
811 pcReturn = pcQueueGetName( xQueue );
\r
813 vPortResetPrivilege( xRunningPrivileged );
\r
817 /*-----------------------------------------------------------*/
\r
819 void MPU_vQueueDelete( QueueHandle_t xQueue )
\r
821 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
823 vQueueDelete( xQueue );
\r
825 vPortResetPrivilege( xRunningPrivileged );
\r
827 /*-----------------------------------------------------------*/
\r
829 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
831 void *MPU_pvPortMalloc( size_t xSize )
\r
834 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
836 pvReturn = pvPortMalloc( xSize );
\r
838 vPortResetPrivilege( xRunningPrivileged );
\r
843 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
844 /*-----------------------------------------------------------*/
\r
846 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
848 void MPU_vPortFree( void *pv )
\r
850 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
854 vPortResetPrivilege( xRunningPrivileged );
\r
857 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
858 /*-----------------------------------------------------------*/
\r
860 void MPU_vPortInitialiseBlocks( void )
\r
862 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
864 vPortInitialiseBlocks();
\r
866 vPortResetPrivilege( xRunningPrivileged );
\r
868 /*-----------------------------------------------------------*/
\r
870 size_t MPU_xPortGetFreeHeapSize( void )
\r
873 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
875 xReturn = xPortGetFreeHeapSize();
\r
877 vPortResetPrivilege( xRunningPrivileged );
\r
881 /*-----------------------------------------------------------*/
\r
883 #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
884 TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction )
\r
886 TimerHandle_t xReturn;
\r
887 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
889 xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );
\r
890 vPortResetPrivilege( xRunningPrivileged );
\r
895 /*-----------------------------------------------------------*/
\r
897 #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
898 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 )
\r
900 TimerHandle_t xReturn;
\r
901 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
903 xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );
\r
904 vPortResetPrivilege( xRunningPrivileged );
\r
909 /*-----------------------------------------------------------*/
\r
911 #if( configUSE_TIMERS == 1 )
\r
912 void *MPU_pvTimerGetTimerID( const TimerHandle_t xTimer )
\r
915 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
917 pvReturn = pvTimerGetTimerID( xTimer );
\r
918 vPortResetPrivilege( xRunningPrivileged );
\r
923 /*-----------------------------------------------------------*/
\r
925 #if( configUSE_TIMERS == 1 )
\r
926 void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID )
\r
928 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
930 vTimerSetTimerID( xTimer, pvNewID );
\r
931 vPortResetPrivilege( xRunningPrivileged );
\r
934 /*-----------------------------------------------------------*/
\r
936 #if( configUSE_TIMERS == 1 )
\r
937 BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer )
\r
939 BaseType_t xReturn;
\r
940 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
942 xReturn = xTimerIsTimerActive( xTimer );
\r
943 vPortResetPrivilege( xRunningPrivileged );
\r
948 /*-----------------------------------------------------------*/
\r
950 #if( configUSE_TIMERS == 1 )
\r
951 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void )
\r
953 TaskHandle_t xReturn;
\r
954 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
956 xReturn = xTimerGetTimerDaemonTaskHandle();
\r
957 vPortResetPrivilege( xRunningPrivileged );
\r
962 /*-----------------------------------------------------------*/
\r
964 #if( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
965 BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait )
\r
967 BaseType_t xReturn;
\r
968 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
970 xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );
\r
971 vPortResetPrivilege( xRunningPrivileged );
\r
976 /*-----------------------------------------------------------*/
\r
978 #if( configUSE_TIMERS == 1 )
\r
979 const char * MPU_pcTimerGetName( TimerHandle_t xTimer )
\r
981 const char * pcReturn;
\r
982 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
984 pcReturn = pcTimerGetName( xTimer );
\r
985 vPortResetPrivilege( xRunningPrivileged );
\r
990 /*-----------------------------------------------------------*/
\r
992 #if( configUSE_TIMERS == 1 )
\r
993 TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer )
\r
995 TickType_t xReturn;
\r
996 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
998 xReturn = xTimerGetPeriod( xTimer );
\r
999 vPortResetPrivilege( xRunningPrivileged );
\r
1004 /*-----------------------------------------------------------*/
\r
1006 #if( configUSE_TIMERS == 1 )
\r
1007 TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer )
\r
1009 TickType_t xReturn;
\r
1010 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1012 xReturn = xTimerGetExpiryTime( xTimer );
\r
1013 vPortResetPrivilege( xRunningPrivileged );
\r
1018 /*-----------------------------------------------------------*/
\r
1020 #if( configUSE_TIMERS == 1 )
\r
1021 BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait )
\r
1023 BaseType_t xReturn;
\r
1024 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1026 xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
\r
1027 vPortResetPrivilege( xRunningPrivileged );
\r
1032 /*-----------------------------------------------------------*/
\r
1034 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
1035 EventGroupHandle_t MPU_xEventGroupCreate( void )
\r
1037 EventGroupHandle_t xReturn;
\r
1038 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1040 xReturn = xEventGroupCreate();
\r
1041 vPortResetPrivilege( xRunningPrivileged );
\r
1046 /*-----------------------------------------------------------*/
\r
1048 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
1049 EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )
\r
1051 EventGroupHandle_t xReturn;
\r
1052 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1054 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
\r
1055 vPortResetPrivilege( xRunningPrivileged );
\r
1060 /*-----------------------------------------------------------*/
\r
1062 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )
\r
1064 EventBits_t xReturn;
\r
1065 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1067 xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
\r
1068 vPortResetPrivilege( xRunningPrivileged );
\r
1072 /*-----------------------------------------------------------*/
\r
1074 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
\r
1076 EventBits_t xReturn;
\r
1077 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1079 xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
\r
1080 vPortResetPrivilege( xRunningPrivileged );
\r
1084 /*-----------------------------------------------------------*/
\r
1086 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )
\r
1088 EventBits_t xReturn;
\r
1089 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1091 xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
\r
1092 vPortResetPrivilege( xRunningPrivileged );
\r
1096 /*-----------------------------------------------------------*/
\r
1098 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )
\r
1100 EventBits_t xReturn;
\r
1101 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1103 xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
\r
1104 vPortResetPrivilege( xRunningPrivileged );
\r
1108 /*-----------------------------------------------------------*/
\r
1110 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup )
\r
1112 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1114 vEventGroupDelete( xEventGroup );
\r
1115 vPortResetPrivilege( xRunningPrivileged );
\r
1117 /*-----------------------------------------------------------*/
\r
1123 /* Functions that the application writer wants to execute in privileged mode
\r
1124 can be defined in application_defined_privileged_functions.h. The functions
\r
1125 must take the same format as those above whereby the privilege state on exit
\r
1126 equals the privilege state on entry. For example:
\r
1128 void MPU_FunctionName( [parameters ] )
\r
1130 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1132 FunctionName( [parameters ] );
\r
1134 vPortResetPrivilege( xRunningPrivileged );
\r
1138 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
\r
1139 #include "application_defined_privileged_functions.h"
\r