2 * FreeRTOS Kernel V10.0.1
\r
3 * Copyright (C) 2017 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 * Checks to see if being called from the context of an unprivileged task, and
\r
51 * if so raises the privilege level and returns false - otherwise does nothing
\r
52 * other than return true.
\r
54 extern BaseType_t xPortRaisePrivilege( void );
\r
56 /*-----------------------------------------------------------*/
\r
58 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
59 BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )
\r
62 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
64 xReturn = xTaskCreateRestricted( pxTaskDefinition, pxCreatedTask );
\r
65 vPortResetPrivilege( xRunningPrivileged );
\r
68 #endif /* conifgSUPPORT_DYNAMIC_ALLOCATION */
\r
69 /*-----------------------------------------------------------*/
\r
71 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
72 BaseType_t MPU_xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )
\r
75 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
77 xReturn = xTaskCreateRestrictedStatic( pxTaskDefinition, pxCreatedTask );
\r
78 vPortResetPrivilege( xRunningPrivileged );
\r
81 #endif /* conifgSUPPORT_DYNAMIC_ALLOCATION */
\r
82 /*-----------------------------------------------------------*/
\r
84 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
85 BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode, const char * const pcName, uint16_t usStackDepth, void *pvParameters, UBaseType_t uxPriority, TaskHandle_t *pxCreatedTask )
\r
88 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
90 xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );
\r
91 vPortResetPrivilege( xRunningPrivileged );
\r
94 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
95 /*-----------------------------------------------------------*/
\r
97 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
98 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
100 TaskHandle_t xReturn;
\r
101 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
103 xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
\r
104 vPortResetPrivilege( xRunningPrivileged );
\r
107 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
108 /*-----------------------------------------------------------*/
\r
110 void MPU_vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const xRegions )
\r
112 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
114 vTaskAllocateMPURegions( xTask, xRegions );
\r
115 vPortResetPrivilege( xRunningPrivileged );
\r
117 /*-----------------------------------------------------------*/
\r
119 #if ( INCLUDE_vTaskDelete == 1 )
\r
120 void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete )
\r
122 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
124 vTaskDelete( pxTaskToDelete );
\r
125 vPortResetPrivilege( xRunningPrivileged );
\r
128 /*-----------------------------------------------------------*/
\r
130 #if ( INCLUDE_vTaskDelayUntil == 1 )
\r
131 void MPU_vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, TickType_t xTimeIncrement )
\r
133 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
135 vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
\r
136 vPortResetPrivilege( xRunningPrivileged );
\r
139 /*-----------------------------------------------------------*/
\r
141 #if ( INCLUDE_xTaskAbortDelay == 1 )
\r
142 BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask )
\r
144 BaseType_t xReturn;
\r
145 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
147 xReturn = xTaskAbortDelay( xTask );
\r
148 vPortResetPrivilege( xRunningPrivileged );
\r
152 /*-----------------------------------------------------------*/
\r
154 #if ( INCLUDE_vTaskDelay == 1 )
\r
155 void MPU_vTaskDelay( TickType_t xTicksToDelay )
\r
157 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
159 vTaskDelay( xTicksToDelay );
\r
160 vPortResetPrivilege( xRunningPrivileged );
\r
163 /*-----------------------------------------------------------*/
\r
165 #if ( INCLUDE_uxTaskPriorityGet == 1 )
\r
166 UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t pxTask )
\r
168 UBaseType_t uxReturn;
\r
169 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
171 uxReturn = uxTaskPriorityGet( pxTask );
\r
172 vPortResetPrivilege( xRunningPrivileged );
\r
176 /*-----------------------------------------------------------*/
\r
178 #if ( INCLUDE_vTaskPrioritySet == 1 )
\r
179 void MPU_vTaskPrioritySet( TaskHandle_t pxTask, UBaseType_t uxNewPriority )
\r
181 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
183 vTaskPrioritySet( pxTask, uxNewPriority );
\r
184 vPortResetPrivilege( xRunningPrivileged );
\r
187 /*-----------------------------------------------------------*/
\r
189 #if ( INCLUDE_eTaskGetState == 1 )
\r
190 eTaskState MPU_eTaskGetState( TaskHandle_t pxTask )
\r
192 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
193 eTaskState eReturn;
\r
195 eReturn = eTaskGetState( pxTask );
\r
196 vPortResetPrivilege( xRunningPrivileged );
\r
200 /*-----------------------------------------------------------*/
\r
202 #if( configUSE_TRACE_FACILITY == 1 )
\r
203 void MPU_vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState )
\r
205 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
207 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
\r
208 vPortResetPrivilege( xRunningPrivileged );
\r
211 /*-----------------------------------------------------------*/
\r
213 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
\r
214 TaskHandle_t MPU_xTaskGetIdleTaskHandle( void )
\r
216 TaskHandle_t xReturn;
\r
217 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
219 xReturn = xTaskGetIdleTaskHandle();
\r
220 vPortResetPrivilege( xRunningPrivileged );
\r
224 /*-----------------------------------------------------------*/
\r
226 #if ( INCLUDE_vTaskSuspend == 1 )
\r
227 void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend )
\r
229 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
231 vTaskSuspend( pxTaskToSuspend );
\r
232 vPortResetPrivilege( xRunningPrivileged );
\r
235 /*-----------------------------------------------------------*/
\r
237 #if ( INCLUDE_vTaskSuspend == 1 )
\r
238 void MPU_vTaskResume( TaskHandle_t pxTaskToResume )
\r
240 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
242 vTaskResume( pxTaskToResume );
\r
243 vPortResetPrivilege( xRunningPrivileged );
\r
246 /*-----------------------------------------------------------*/
\r
248 void MPU_vTaskSuspendAll( void )
\r
250 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
253 vPortResetPrivilege( xRunningPrivileged );
\r
255 /*-----------------------------------------------------------*/
\r
257 BaseType_t MPU_xTaskResumeAll( void )
\r
259 BaseType_t xReturn;
\r
260 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
262 xReturn = xTaskResumeAll();
\r
263 vPortResetPrivilege( xRunningPrivileged );
\r
266 /*-----------------------------------------------------------*/
\r
268 TickType_t MPU_xTaskGetTickCount( void )
\r
270 TickType_t xReturn;
\r
271 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
273 xReturn = xTaskGetTickCount();
\r
274 vPortResetPrivilege( xRunningPrivileged );
\r
277 /*-----------------------------------------------------------*/
\r
279 UBaseType_t MPU_uxTaskGetNumberOfTasks( void )
\r
281 UBaseType_t uxReturn;
\r
282 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
284 uxReturn = uxTaskGetNumberOfTasks();
\r
285 vPortResetPrivilege( xRunningPrivileged );
\r
288 /*-----------------------------------------------------------*/
\r
290 char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery )
\r
293 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
295 pcReturn = pcTaskGetName( xTaskToQuery );
\r
296 vPortResetPrivilege( xRunningPrivileged );
\r
299 /*-----------------------------------------------------------*/
\r
301 #if ( INCLUDE_xTaskGetHandle == 1 )
\r
302 TaskHandle_t MPU_xTaskGetHandle( const char *pcNameToQuery )
\r
304 TaskHandle_t xReturn;
\r
305 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
307 xReturn = xTaskGetHandle( pcNameToQuery );
\r
308 vPortResetPrivilege( xRunningPrivileged );
\r
312 /*-----------------------------------------------------------*/
\r
314 #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
315 void MPU_vTaskList( char *pcWriteBuffer )
\r
317 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
319 vTaskList( pcWriteBuffer );
\r
320 vPortResetPrivilege( xRunningPrivileged );
\r
323 /*-----------------------------------------------------------*/
\r
325 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
326 void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer )
\r
328 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
330 vTaskGetRunTimeStats( pcWriteBuffer );
\r
331 vPortResetPrivilege( xRunningPrivileged );
\r
334 /*-----------------------------------------------------------*/
\r
336 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
337 void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxTagValue )
\r
339 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
341 vTaskSetApplicationTaskTag( xTask, pxTagValue );
\r
342 vPortResetPrivilege( xRunningPrivileged );
\r
345 /*-----------------------------------------------------------*/
\r
347 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
348 TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask )
\r
350 TaskHookFunction_t xReturn;
\r
351 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
353 xReturn = xTaskGetApplicationTaskTag( xTask );
\r
354 vPortResetPrivilege( xRunningPrivileged );
\r
358 /*-----------------------------------------------------------*/
\r
360 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
\r
361 void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue )
\r
363 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
365 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
\r
366 vPortResetPrivilege( xRunningPrivileged );
\r
369 /*-----------------------------------------------------------*/
\r
371 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
\r
372 void *MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex )
\r
375 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
377 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
\r
378 vPortResetPrivilege( xRunningPrivileged );
\r
382 /*-----------------------------------------------------------*/
\r
384 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
\r
385 BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter )
\r
387 BaseType_t xReturn;
\r
388 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
390 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
\r
391 vPortResetPrivilege( xRunningPrivileged );
\r
395 /*-----------------------------------------------------------*/
\r
397 #if ( configUSE_TRACE_FACILITY == 1 )
\r
398 UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t *pxTaskStatusArray, UBaseType_t uxArraySize, uint32_t *pulTotalRunTime )
\r
400 UBaseType_t uxReturn;
\r
401 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
403 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
\r
404 vPortResetPrivilege( xRunningPrivileged );
\r
408 /*-----------------------------------------------------------*/
\r
410 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
\r
411 UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask )
\r
413 UBaseType_t uxReturn;
\r
414 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
416 uxReturn = uxTaskGetStackHighWaterMark( xTask );
\r
417 vPortResetPrivilege( xRunningPrivileged );
\r
421 /*-----------------------------------------------------------*/
\r
423 #if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )
\r
424 TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void )
\r
426 TaskHandle_t xReturn;
\r
427 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
429 xReturn = xTaskGetCurrentTaskHandle();
\r
430 vPortResetPrivilege( xRunningPrivileged );
\r
434 /*-----------------------------------------------------------*/
\r
436 #if ( INCLUDE_xTaskGetSchedulerState == 1 )
\r
437 BaseType_t MPU_xTaskGetSchedulerState( void )
\r
439 BaseType_t xReturn;
\r
440 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
442 xReturn = xTaskGetSchedulerState();
\r
443 vPortResetPrivilege( xRunningPrivileged );
\r
447 /*-----------------------------------------------------------*/
\r
449 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )
\r
451 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
453 vTaskSetTimeOutState( pxTimeOut );
\r
454 vPortResetPrivilege( xRunningPrivileged );
\r
456 /*-----------------------------------------------------------*/
\r
458 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait )
\r
460 BaseType_t xReturn;
\r
461 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
463 xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
\r
464 vPortResetPrivilege( xRunningPrivileged );
\r
467 /*-----------------------------------------------------------*/
\r
469 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
470 BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )
\r
472 BaseType_t xReturn;
\r
473 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
475 xReturn = xTaskGenericNotify( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue );
\r
476 vPortResetPrivilege( xRunningPrivileged );
\r
480 /*-----------------------------------------------------------*/
\r
482 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
483 BaseType_t MPU_xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )
\r
485 BaseType_t xReturn;
\r
486 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
488 xReturn = xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
\r
489 vPortResetPrivilege( xRunningPrivileged );
\r
493 /*-----------------------------------------------------------*/
\r
495 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
496 uint32_t MPU_ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )
\r
499 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
501 ulReturn = ulTaskNotifyTake( xClearCountOnExit, xTicksToWait );
\r
502 vPortResetPrivilege( xRunningPrivileged );
\r
506 /*-----------------------------------------------------------*/
\r
508 #if( configUSE_TASK_NOTIFICATIONS == 1 )
\r
509 BaseType_t MPU_xTaskNotifyStateClear( TaskHandle_t xTask )
\r
511 BaseType_t xReturn;
\r
512 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
514 xReturn = xTaskNotifyStateClear( xTask );
\r
515 vPortResetPrivilege( xRunningPrivileged );
\r
519 /*-----------------------------------------------------------*/
\r
521 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
522 QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize, uint8_t ucQueueType )
\r
524 QueueHandle_t xReturn;
\r
525 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
527 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
\r
528 vPortResetPrivilege( xRunningPrivileged );
\r
532 /*-----------------------------------------------------------*/
\r
534 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
535 QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType )
\r
537 QueueHandle_t xReturn;
\r
538 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
540 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
\r
541 vPortResetPrivilege( xRunningPrivileged );
\r
545 /*-----------------------------------------------------------*/
\r
547 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue, BaseType_t xNewQueue )
\r
549 BaseType_t xReturn;
\r
550 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
552 xReturn = xQueueGenericReset( pxQueue, xNewQueue );
\r
553 vPortResetPrivilege( xRunningPrivileged );
\r
556 /*-----------------------------------------------------------*/
\r
558 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition )
\r
560 BaseType_t xReturn;
\r
561 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
563 xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
\r
564 vPortResetPrivilege( xRunningPrivileged );
\r
567 /*-----------------------------------------------------------*/
\r
569 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue )
\r
571 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
572 UBaseType_t uxReturn;
\r
574 uxReturn = uxQueueMessagesWaiting( pxQueue );
\r
575 vPortResetPrivilege( xRunningPrivileged );
\r
578 /*-----------------------------------------------------------*/
\r
580 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue )
\r
582 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
583 UBaseType_t uxReturn;
\r
585 uxReturn = uxQueueSpacesAvailable( xQueue );
\r
586 vPortResetPrivilege( xRunningPrivileged );
\r
589 /*-----------------------------------------------------------*/
\r
591 BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue, void * const pvBuffer, TickType_t xTicksToWait )
\r
593 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
594 BaseType_t xReturn;
\r
596 xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
\r
597 vPortResetPrivilege( xRunningPrivileged );
\r
600 /*-----------------------------------------------------------*/
\r
602 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait )
\r
604 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
605 BaseType_t xReturn;
\r
607 xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
\r
608 vPortResetPrivilege( xRunningPrivileged );
\r
611 /*-----------------------------------------------------------*/
\r
613 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait )
\r
615 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
616 BaseType_t xReturn;
\r
618 xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
\r
619 vPortResetPrivilege( xRunningPrivileged );
\r
622 /*-----------------------------------------------------------*/
\r
624 BaseType_t MPU_xQueuePeekFromISR( QueueHandle_t pxQueue, void * const pvBuffer )
\r
626 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
627 BaseType_t xReturn;
\r
629 xReturn = xQueuePeekFromISR( pxQueue, pvBuffer );
\r
630 vPortResetPrivilege( xRunningPrivileged );
\r
633 /*-----------------------------------------------------------*/
\r
635 TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore )
\r
637 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
640 xReturn = xQueueGetMutexHolder( xSemaphore );
\r
641 vPortResetPrivilege( xRunningPrivileged );
\r
644 /*-----------------------------------------------------------*/
\r
646 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
647 QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType )
\r
649 QueueHandle_t xReturn;
\r
650 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
652 xReturn = xQueueCreateMutex( ucQueueType );
\r
653 vPortResetPrivilege( xRunningPrivileged );
\r
657 /*-----------------------------------------------------------*/
\r
659 #if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
660 QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue )
\r
662 QueueHandle_t xReturn;
\r
663 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
665 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
\r
666 vPortResetPrivilege( xRunningPrivileged );
\r
670 /*-----------------------------------------------------------*/
\r
672 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
673 QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue, UBaseType_t uxInitialCount )
\r
675 QueueHandle_t xReturn;
\r
676 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
678 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
\r
679 vPortResetPrivilege( xRunningPrivileged );
\r
683 /*-----------------------------------------------------------*/
\r
685 #if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
687 QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue )
\r
689 QueueHandle_t xReturn;
\r
690 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
692 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
\r
693 vPortResetPrivilege( xRunningPrivileged );
\r
697 /*-----------------------------------------------------------*/
\r
699 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
700 BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xBlockTime )
\r
702 BaseType_t xReturn;
\r
703 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
705 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
\r
706 vPortResetPrivilege( xRunningPrivileged );
\r
710 /*-----------------------------------------------------------*/
\r
712 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
713 BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex )
\r
715 BaseType_t xReturn;
\r
716 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
718 xReturn = xQueueGiveMutexRecursive( xMutex );
\r
719 vPortResetPrivilege( xRunningPrivileged );
\r
723 /*-----------------------------------------------------------*/
\r
725 #if( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
726 QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength )
\r
728 QueueSetHandle_t xReturn;
\r
729 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
731 xReturn = xQueueCreateSet( uxEventQueueLength );
\r
732 vPortResetPrivilege( xRunningPrivileged );
\r
736 /*-----------------------------------------------------------*/
\r
738 #if ( configUSE_QUEUE_SETS == 1 )
\r
739 QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, TickType_t xBlockTimeTicks )
\r
741 QueueSetMemberHandle_t xReturn;
\r
742 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
744 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
\r
745 vPortResetPrivilege( xRunningPrivileged );
\r
749 /*-----------------------------------------------------------*/
\r
751 #if ( configUSE_QUEUE_SETS == 1 )
\r
752 BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )
\r
754 BaseType_t xReturn;
\r
755 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
757 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
\r
758 vPortResetPrivilege( xRunningPrivileged );
\r
762 /*-----------------------------------------------------------*/
\r
764 #if ( configUSE_QUEUE_SETS == 1 )
\r
765 BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )
\r
767 BaseType_t xReturn;
\r
768 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
770 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
\r
771 vPortResetPrivilege( xRunningPrivileged );
\r
775 /*-----------------------------------------------------------*/
\r
777 #if configQUEUE_REGISTRY_SIZE > 0
\r
778 void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName )
\r
780 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
782 vQueueAddToRegistry( xQueue, pcName );
\r
784 vPortResetPrivilege( xRunningPrivileged );
\r
787 /*-----------------------------------------------------------*/
\r
789 #if configQUEUE_REGISTRY_SIZE > 0
\r
790 void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue )
\r
792 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
794 vQueueUnregisterQueue( xQueue );
\r
796 vPortResetPrivilege( xRunningPrivileged );
\r
799 /*-----------------------------------------------------------*/
\r
801 #if configQUEUE_REGISTRY_SIZE > 0
\r
802 const char *MPU_pcQueueGetName( QueueHandle_t xQueue )
\r
804 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
805 const char *pcReturn;
\r
807 pcReturn = pcQueueGetName( xQueue );
\r
809 vPortResetPrivilege( xRunningPrivileged );
\r
813 /*-----------------------------------------------------------*/
\r
815 void MPU_vQueueDelete( QueueHandle_t xQueue )
\r
817 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
819 vQueueDelete( xQueue );
\r
821 vPortResetPrivilege( xRunningPrivileged );
\r
823 /*-----------------------------------------------------------*/
\r
825 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
826 void *MPU_pvPortMalloc( size_t xSize )
\r
829 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
831 pvReturn = pvPortMalloc( xSize );
\r
833 vPortResetPrivilege( xRunningPrivileged );
\r
837 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
838 /*-----------------------------------------------------------*/
\r
840 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
841 void MPU_vPortFree( void *pv )
\r
843 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
847 vPortResetPrivilege( xRunningPrivileged );
\r
849 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
850 /*-----------------------------------------------------------*/
\r
852 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
853 void MPU_vPortInitialiseBlocks( void )
\r
855 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
857 vPortInitialiseBlocks();
\r
859 vPortResetPrivilege( xRunningPrivileged );
\r
861 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
862 /*-----------------------------------------------------------*/
\r
864 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
865 size_t MPU_xPortGetFreeHeapSize( void )
\r
868 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
870 xReturn = xPortGetFreeHeapSize();
\r
872 vPortResetPrivilege( xRunningPrivileged );
\r
876 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
877 /*-----------------------------------------------------------*/
\r
879 #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
880 TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction )
\r
882 TimerHandle_t xReturn;
\r
883 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
885 xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );
\r
886 vPortResetPrivilege( xRunningPrivileged );
\r
891 /*-----------------------------------------------------------*/
\r
893 #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
894 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
896 TimerHandle_t xReturn;
\r
897 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
899 xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );
\r
900 vPortResetPrivilege( xRunningPrivileged );
\r
905 /*-----------------------------------------------------------*/
\r
907 #if( configUSE_TIMERS == 1 )
\r
908 void *MPU_pvTimerGetTimerID( const TimerHandle_t xTimer )
\r
911 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
913 pvReturn = pvTimerGetTimerID( xTimer );
\r
914 vPortResetPrivilege( xRunningPrivileged );
\r
919 /*-----------------------------------------------------------*/
\r
921 #if( configUSE_TIMERS == 1 )
\r
922 void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID )
\r
924 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
926 vTimerSetTimerID( xTimer, pvNewID );
\r
927 vPortResetPrivilege( xRunningPrivileged );
\r
930 /*-----------------------------------------------------------*/
\r
932 #if( configUSE_TIMERS == 1 )
\r
933 BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer )
\r
935 BaseType_t xReturn;
\r
936 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
938 xReturn = xTimerIsTimerActive( xTimer );
\r
939 vPortResetPrivilege( xRunningPrivileged );
\r
944 /*-----------------------------------------------------------*/
\r
946 #if( configUSE_TIMERS == 1 )
\r
947 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void )
\r
949 TaskHandle_t xReturn;
\r
950 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
952 xReturn = xTimerGetTimerDaemonTaskHandle();
\r
953 vPortResetPrivilege( xRunningPrivileged );
\r
958 /*-----------------------------------------------------------*/
\r
960 #if( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
\r
961 BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait )
\r
963 BaseType_t xReturn;
\r
964 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
966 xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );
\r
967 vPortResetPrivilege( xRunningPrivileged );
\r
972 /*-----------------------------------------------------------*/
\r
974 #if( configUSE_TIMERS == 1 )
\r
975 const char * MPU_pcTimerGetName( TimerHandle_t xTimer )
\r
977 const char * pcReturn;
\r
978 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
980 pcReturn = pcTimerGetName( xTimer );
\r
981 vPortResetPrivilege( xRunningPrivileged );
\r
986 /*-----------------------------------------------------------*/
\r
988 #if( configUSE_TIMERS == 1 )
\r
989 TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer )
\r
991 TickType_t xReturn;
\r
992 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
994 xReturn = xTimerGetPeriod( xTimer );
\r
995 vPortResetPrivilege( xRunningPrivileged );
\r
1000 /*-----------------------------------------------------------*/
\r
1002 #if( configUSE_TIMERS == 1 )
\r
1003 TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer )
\r
1005 TickType_t xReturn;
\r
1006 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1008 xReturn = xTimerGetExpiryTime( xTimer );
\r
1009 vPortResetPrivilege( xRunningPrivileged );
\r
1014 /*-----------------------------------------------------------*/
\r
1016 #if( configUSE_TIMERS == 1 )
\r
1017 BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait )
\r
1019 BaseType_t xReturn;
\r
1020 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1022 xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
\r
1023 vPortResetPrivilege( xRunningPrivileged );
\r
1028 /*-----------------------------------------------------------*/
\r
1030 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
1031 EventGroupHandle_t MPU_xEventGroupCreate( void )
\r
1033 EventGroupHandle_t xReturn;
\r
1034 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1036 xReturn = xEventGroupCreate();
\r
1037 vPortResetPrivilege( xRunningPrivileged );
\r
1042 /*-----------------------------------------------------------*/
\r
1044 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
1045 EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )
\r
1047 EventGroupHandle_t xReturn;
\r
1048 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1050 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
\r
1051 vPortResetPrivilege( xRunningPrivileged );
\r
1056 /*-----------------------------------------------------------*/
\r
1058 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )
\r
1060 EventBits_t xReturn;
\r
1061 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1063 xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
\r
1064 vPortResetPrivilege( xRunningPrivileged );
\r
1068 /*-----------------------------------------------------------*/
\r
1070 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
\r
1072 EventBits_t xReturn;
\r
1073 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1075 xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
\r
1076 vPortResetPrivilege( xRunningPrivileged );
\r
1080 /*-----------------------------------------------------------*/
\r
1082 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )
\r
1084 EventBits_t xReturn;
\r
1085 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1087 xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
\r
1088 vPortResetPrivilege( xRunningPrivileged );
\r
1092 /*-----------------------------------------------------------*/
\r
1094 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )
\r
1096 EventBits_t xReturn;
\r
1097 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1099 xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
\r
1100 vPortResetPrivilege( xRunningPrivileged );
\r
1104 /*-----------------------------------------------------------*/
\r
1106 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup )
\r
1108 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1110 vEventGroupDelete( xEventGroup );
\r
1111 vPortResetPrivilege( xRunningPrivileged );
\r
1113 /*-----------------------------------------------------------*/
\r
1115 size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, TickType_t xTicksToWait )
\r
1118 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1120 xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
\r
1121 vPortResetPrivilege( xRunningPrivileged );
\r
1125 /*-----------------------------------------------------------*/
\r
1127 size_t MPU_xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, BaseType_t * const pxHigherPriorityTaskWoken )
\r
1130 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1132 xReturn = xStreamBufferSendFromISR( xStreamBuffer, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken );
\r
1133 vPortResetPrivilege( xRunningPrivileged );
\r
1137 /*-----------------------------------------------------------*/
\r
1139 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer )
\r
1142 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1144 xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
\r
1145 vPortResetPrivilege( xRunningPrivileged );
\r
1149 /*-----------------------------------------------------------*/
\r
1151 size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, TickType_t xTicksToWait )
\r
1154 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1156 xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
\r
1157 vPortResetPrivilege( xRunningPrivileged );
\r
1161 /*-----------------------------------------------------------*/
\r
1163 size_t MPU_xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, BaseType_t * const pxHigherPriorityTaskWoken )
\r
1166 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1168 xReturn = xStreamBufferReceiveFromISR( xStreamBuffer, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken );
\r
1169 vPortResetPrivilege( xRunningPrivileged );
\r
1173 /*-----------------------------------------------------------*/
\r
1175 void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer )
\r
1177 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1179 vStreamBufferDelete( xStreamBuffer );
\r
1180 vPortResetPrivilege( xRunningPrivileged );
\r
1182 /*-----------------------------------------------------------*/
\r
1184 BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer )
\r
1186 BaseType_t xReturn;
\r
1187 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1189 xReturn = xStreamBufferIsFull( xStreamBuffer );
\r
1190 vPortResetPrivilege( xRunningPrivileged );
\r
1194 /*-----------------------------------------------------------*/
\r
1196 BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer )
\r
1198 BaseType_t xReturn;
\r
1199 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1201 xReturn = xStreamBufferIsEmpty( xStreamBuffer );
\r
1202 vPortResetPrivilege( xRunningPrivileged );
\r
1206 /*-----------------------------------------------------------*/
\r
1208 BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer )
\r
1210 BaseType_t xReturn;
\r
1211 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1213 xReturn = xStreamBufferReset( xStreamBuffer );
\r
1214 vPortResetPrivilege( xRunningPrivileged );
\r
1218 /*-----------------------------------------------------------*/
\r
1220 size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer )
\r
1223 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1225 xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
\r
1226 vPortResetPrivilege( xRunningPrivileged );
\r
1230 /*-----------------------------------------------------------*/
\r
1232 size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer )
\r
1235 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1237 xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
\r
1238 vPortResetPrivilege( xRunningPrivileged );
\r
1242 /*-----------------------------------------------------------*/
\r
1244 BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel )
\r
1246 BaseType_t xReturn;
\r
1247 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1249 xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
\r
1250 vPortResetPrivilege( xRunningPrivileged );
\r
1254 /*-----------------------------------------------------------*/
\r
1256 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
1257 StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer )
\r
1259 StreamBufferHandle_t xReturn;
\r
1260 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1262 xReturn = xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer );
\r
1263 vPortResetPrivilege( xRunningPrivileged );
\r
1267 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
1268 /*-----------------------------------------------------------*/
\r
1270 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
1271 StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer, uint8_t * const pucStreamBufferStorageArea, StaticStreamBuffer_t * const pxStaticStreamBuffer )
\r
1273 StreamBufferHandle_t xReturn;
\r
1274 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1276 xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer, pucStreamBufferStorageArea, pxStaticStreamBuffer );
\r
1277 vPortResetPrivilege( xRunningPrivileged );
\r
1281 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
1282 /*-----------------------------------------------------------*/
\r
1285 /* Functions that the application writer wants to execute in privileged mode
\r
1286 can be defined in application_defined_privileged_functions.h. The functions
\r
1287 must take the same format as those above whereby the privilege state on exit
\r
1288 equals the privilege state on entry. For example:
\r
1290 void MPU_FunctionName( [parameters ] )
\r
1292 BaseType_t xRunningPrivileged = xPortRaisePrivilege();
\r
1294 FunctionName( [parameters ] );
\r
1296 vPortResetPrivilege( xRunningPrivileged );
\r
1300 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
\r
1301 #include "application_defined_privileged_functions.h"
\r