STAR
Cal STAR — firmware, DAQ server, and engine design
Loading...
Searching...
No Matches
mpu_wrappers_v2.c
Go to the documentation of this file.
1/*
2 * FreeRTOS Kernel V10.6.2
3 * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
4 *
5 * SPDX-License-Identifier: MIT
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy of
8 * this software and associated documentation files (the "Software"), to deal in
9 * the Software without restriction, including without limitation the rights to
10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11 * the Software, and to permit persons to whom the Software is furnished to do so,
12 * subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in all
15 * copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * https://www.FreeRTOS.org
25 * https://github.com/FreeRTOS
26 *
27 */
28
29/*
30 * Implementation of the wrapper functions used to raise the processor privilege
31 * before calling a standard FreeRTOS API function.
32 */
33
34/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
35 * all the API functions to use the MPU wrappers. That should only be done when
36 * task.h is included from an application file. */
37#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
38
39/* Scheduler includes. */
40#include "FreeRTOS.h"
41#include "task.h"
42#include "queue.h"
43#include "timers.h"
44#include "event_groups.h"
45#include "stream_buffer.h"
46#include "mpu_prototypes.h"
47#include "mpu_syscall_numbers.h"
48
49#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
50/*-----------------------------------------------------------*/
51
52#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) )
53
54 #ifndef configPROTECTED_KERNEL_OBJECT_POOL_SIZE
55 #error configPROTECTED_KERNEL_OBJECT_POOL_SIZE must be defined to maximum number of kernel objects in the application.
56 #endif
57
58/**
59 * @brief Offset added to the index before returning to the user.
60 *
61 * If the actual handle is stored at index i, ( i + INDEX_OFFSET )
62 * is returned to the user.
63 */
64 #define INDEX_OFFSET 1
65
66/**
67 * @brief Opaque type for a kernel object.
68 */
69 struct OpaqueObject;
70 typedef struct OpaqueObject * OpaqueObjectHandle_t;
71
72/**
73 * @brief Defines kernel object in the kernel object pool.
74 */
75 typedef struct KernelObject
76 {
77 OpaqueObjectHandle_t xInternalObjectHandle;
78 uint32_t ulKernelObjectType;
79 void * pvKernelObjectData;
80 } KernelObject_t;
81
82/**
83 * @brief Kernel object types.
84 */
85 #define KERNEL_OBJECT_TYPE_INVALID ( 0UL )
86 #define KERNEL_OBJECT_TYPE_QUEUE ( 1UL )
87 #define KERNEL_OBJECT_TYPE_TASK ( 2UL )
88 #define KERNEL_OBJECT_TYPE_STREAM_BUFFER ( 3UL )
89 #define KERNEL_OBJECT_TYPE_EVENT_GROUP ( 4UL )
90 #define KERNEL_OBJECT_TYPE_TIMER ( 5UL )
91
92/**
93 * @brief Checks whether an external index is valid or not.
94 */
95 #define IS_EXTERNAL_INDEX_VALID( lIndex ) \
96 ( ( ( lIndex ) >= INDEX_OFFSET ) && \
97 ( ( lIndex ) < ( configPROTECTED_KERNEL_OBJECT_POOL_SIZE + INDEX_OFFSET ) ) )
98
99/**
100 * @brief Checks whether an internal index is valid or not.
101 */
102 #define IS_INTERNAL_INDEX_VALID( lIndex ) \
103 ( ( ( lIndex ) >= 0 ) && \
104 ( ( lIndex ) < ( configPROTECTED_KERNEL_OBJECT_POOL_SIZE ) ) )
105
106/**
107 * @brief Converts an internal index into external.
108 */
109 #define CONVERT_TO_EXTERNAL_INDEX( lIndex ) ( ( lIndex ) + INDEX_OFFSET )
110
111/**
112 * @brief Converts an external index into internal.
113 */
114 #define CONVERT_TO_INTERNAL_INDEX( lIndex ) ( ( lIndex ) - INDEX_OFFSET )
115
116/**
117 * @brief Max value that fits in a uint32_t type.
118 */
119 #define mpuUINT32_MAX ( ~( ( uint32_t ) 0 ) )
120
121/**
122 * @brief Check if multiplying a and b will result in overflow.
123 */
124 #define mpuMULTIPLY_UINT32_WILL_OVERFLOW( a, b ) ( ( ( a ) > 0 ) && ( ( b ) > ( mpuUINT32_MAX / ( a ) ) ) )
125
126/**
127 * @brief Get the index of a free slot in the kernel object pool.
128 *
129 * If a free slot is found, this function marks the slot as
130 * "not free".
131 *
132 * @return Index of a free slot is returned, if a free slot is
133 * found. Otherwise -1 is returned.
134 */
135 static int32_t MPU_GetFreeIndexInKernelObjectPool( void ) PRIVILEGED_FUNCTION;
136
137/**
138 * @brief Set the given index as free in the kernel object pool.
139 *
140 * @param lIndex The index to set as free.
141 */
142 static void MPU_SetIndexFreeInKernelObjectPool( int32_t lIndex ) PRIVILEGED_FUNCTION;
143
144/**
145 * @brief Get the index at which a given kernel object is stored.
146 *
147 * @param xHandle The given kernel object handle.
148 * @param ulKernelObjectType The kernel object type.
149 *
150 * @return Index at which the kernel object is stored if it is a valid
151 * handle, -1 otherwise.
152 */
153 static int32_t MPU_GetIndexForHandle( OpaqueObjectHandle_t xHandle,
154 uint32_t ulKernelObjectType ) PRIVILEGED_FUNCTION;
155
156/**
157 * @brief Store the given kernel object handle at the given index in
158 * the kernel object pool.
159 *
160 * @param lIndex Index to store the given handle at.
161 * @param xHandle Kernel object handle to store.
162 * @param pvKernelObjectData The data associated with the kernel object.
163 * Currently, only used for timer objects to store timer callback.
164 * @param ulKernelObjectType The kernel object type.
165 */
166 static void MPU_StoreHandleAndDataAtIndex( int32_t lIndex,
167 OpaqueObjectHandle_t xHandle,
168 void * pvKernelObjectData,
169 uint32_t ulKernelObjectType ) PRIVILEGED_FUNCTION;
170
171/**
172 * @brief Get the kernel object handle at the given index from
173 * the kernel object pool.
174 *
175 * @param lIndex Index at which to get the kernel object handle.
176 * @param ulKernelObjectType The kernel object type.
177 *
178 * @return The kernel object handle at the index.
179 */
180 static OpaqueObjectHandle_t MPU_GetHandleAtIndex( int32_t lIndex,
181 uint32_t ulKernelObjectType ) PRIVILEGED_FUNCTION;
182
183 #if ( configUSE_TIMERS == 1 )
184
185/**
186 * @brief The function registered as callback for all the timers.
187 *
188 * We intercept all the timer callbacks so that we can call application
189 * callbacks with opaque handle.
190 *
191 * @param xInternalHandle The internal timer handle.
192 */
193 static void MPU_TimerCallback( TimerHandle_t xInternalHandle ) PRIVILEGED_FUNCTION;
194
195 #endif /* #if ( configUSE_TIMERS == 1 ) */
196
197/*
198 * Wrappers to keep all the casting in one place.
199 */
200 #define MPU_StoreQueueHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( lIndex, ( OpaqueObjectHandle_t ) xHandle, NULL, KERNEL_OBJECT_TYPE_QUEUE )
201 #define MPU_GetQueueHandleAtIndex( lIndex ) ( QueueHandle_t ) MPU_GetHandleAtIndex( lIndex, KERNEL_OBJECT_TYPE_QUEUE )
202
203 #if ( configUSE_QUEUE_SETS == 1 )
204 #define MPU_StoreQueueSetHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( lIndex, ( OpaqueObjectHandle_t ) xHandle, NULL, KERNEL_OBJECT_TYPE_QUEUE )
205 #define MPU_GetQueueSetHandleAtIndex( lIndex ) ( QueueSetHandle_t ) MPU_GetHandleAtIndex( lIndex, KERNEL_OBJECT_TYPE_QUEUE )
206 #define MPU_StoreQueueSetMemberHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( lIndex, ( OpaqueObjectHandle_t ) xHandle, NULL, KERNEL_OBJECT_TYPE_QUEUE )
207 #define MPU_GetQueueSetMemberHandleAtIndex( lIndex ) ( QueueSetMemberHandle_t ) MPU_GetHandleAtIndex( lIndex, KERNEL_OBJECT_TYPE_QUEUE )
208 #define MPU_GetIndexForQueueSetMemberHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) xHandle, KERNEL_OBJECT_TYPE_QUEUE )
209 #endif
210
211/*
212 * Wrappers to keep all the casting in one place for Task APIs.
213 */
214 #define MPU_StoreTaskHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( lIndex, ( OpaqueObjectHandle_t ) xHandle, NULL, KERNEL_OBJECT_TYPE_TASK )
215 #define MPU_GetTaskHandleAtIndex( lIndex ) ( TaskHandle_t ) MPU_GetHandleAtIndex( lIndex, KERNEL_OBJECT_TYPE_TASK )
216 #define MPU_GetIndexForTaskHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) xHandle, KERNEL_OBJECT_TYPE_TASK )
217
218/*
219 * Wrappers to keep all the casting in one place for Event Group APIs.
220 */
221 #define MPU_StoreEventGroupHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( lIndex, ( OpaqueObjectHandle_t ) xHandle, NULL, KERNEL_OBJECT_TYPE_EVENT_GROUP )
222 #define MPU_GetEventGroupHandleAtIndex( lIndex ) ( EventGroupHandle_t ) MPU_GetHandleAtIndex( lIndex, KERNEL_OBJECT_TYPE_EVENT_GROUP )
223 #define MPU_GetIndexForEventGroupHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) xHandle, KERNEL_OBJECT_TYPE_EVENT_GROUP )
224
225/*
226 * Wrappers to keep all the casting in one place for Stream Buffer APIs.
227 */
228 #define MPU_StoreStreamBufferHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( lIndex, ( OpaqueObjectHandle_t ) xHandle, NULL, KERNEL_OBJECT_TYPE_STREAM_BUFFER )
229 #define MPU_GetStreamBufferHandleAtIndex( lIndex ) ( StreamBufferHandle_t ) MPU_GetHandleAtIndex( lIndex, KERNEL_OBJECT_TYPE_STREAM_BUFFER )
230 #define MPU_GetIndexForStreamBufferHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) xHandle, KERNEL_OBJECT_TYPE_STREAM_BUFFER )
231
232 #if ( configUSE_TIMERS == 1 )
233
234/*
235 * Wrappers to keep all the casting in one place for Timer APIs.
236 */
237 #define MPU_StoreTimerHandleAtIndex( lIndex, xHandle, pxApplicationCallback ) MPU_StoreHandleAndDataAtIndex( lIndex, ( OpaqueObjectHandle_t ) xHandle, ( void * ) pxApplicationCallback, KERNEL_OBJECT_TYPE_TIMER )
238 #define MPU_GetTimerHandleAtIndex( lIndex ) ( TimerHandle_t ) MPU_GetHandleAtIndex( lIndex, KERNEL_OBJECT_TYPE_TIMER )
239 #define MPU_GetIndexForTimerHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) xHandle, KERNEL_OBJECT_TYPE_TIMER )
240
241 #endif /* #if ( configUSE_TIMERS == 1 ) */
242
243/*-----------------------------------------------------------*/
244
245/**
246 * @brief Kernel object pool.
247 */
248 PRIVILEGED_DATA static KernelObject_t xKernelObjectPool[ configPROTECTED_KERNEL_OBJECT_POOL_SIZE ] = { NULL };
249/*-----------------------------------------------------------*/
250
251 static int32_t MPU_GetFreeIndexInKernelObjectPool( void ) /* PRIVILEGED_FUNCTION */
252 {
253 int32_t i, lFreeIndex = -1;
254
255 /* This function is called only from resource create APIs
256 * which are not supposed to be called from ISRs. Therefore,
257 * we only need to suspend the scheduler and do not require
258 * critical section. */
259 vTaskSuspendAll();
260 {
261 for( i = 0; i < configPROTECTED_KERNEL_OBJECT_POOL_SIZE; i++ )
262 {
263 if( xKernelObjectPool[ i ].xInternalObjectHandle == NULL )
264 {
265 /* Mark this index as not free. */
266 xKernelObjectPool[ i ].xInternalObjectHandle = ( OpaqueObjectHandle_t ) ( ~0 );
267 lFreeIndex = i;
268 break;
269 }
270 }
271 }
272 xTaskResumeAll();
273
274 return lFreeIndex;
275 }
276/*-----------------------------------------------------------*/
277
278 static void MPU_SetIndexFreeInKernelObjectPool( int32_t lIndex ) /* PRIVILEGED_FUNCTION */
279 {
280 configASSERT( IS_INTERNAL_INDEX_VALID( lIndex ) != pdFALSE );
281
282 taskENTER_CRITICAL();
283 {
284 xKernelObjectPool[ lIndex ].xInternalObjectHandle = NULL;
285 xKernelObjectPool[ lIndex ].ulKernelObjectType = KERNEL_OBJECT_TYPE_INVALID;
286 xKernelObjectPool[ lIndex ].pvKernelObjectData = NULL;
287 }
288 taskEXIT_CRITICAL();
289 }
290/*-----------------------------------------------------------*/
291
292 static int32_t MPU_GetIndexForHandle( OpaqueObjectHandle_t xHandle,
293 uint32_t ulKernelObjectType ) /* PRIVILEGED_FUNCTION */
294 {
295 int32_t i, lIndex = -1;
296
297 configASSERT( xHandle != NULL );
298
299 for( i = 0; i < configPROTECTED_KERNEL_OBJECT_POOL_SIZE; i++ )
300 {
301 if( ( xKernelObjectPool[ i ].xInternalObjectHandle == xHandle ) &&
302 ( xKernelObjectPool[ i ].ulKernelObjectType == ulKernelObjectType ) )
303 {
304 lIndex = i;
305 break;
306 }
307 }
308
309 return lIndex;
310 }
311/*-----------------------------------------------------------*/
312
313 static void MPU_StoreHandleAndDataAtIndex( int32_t lIndex,
314 OpaqueObjectHandle_t xHandle,
315 void * pvKernelObjectData,
316 uint32_t ulKernelObjectType ) /* PRIVILEGED_FUNCTION */
317 {
318 configASSERT( IS_INTERNAL_INDEX_VALID( lIndex ) != pdFALSE );
319 xKernelObjectPool[ lIndex ].xInternalObjectHandle = xHandle;
320 xKernelObjectPool[ lIndex ].ulKernelObjectType = ulKernelObjectType;
321 xKernelObjectPool[ lIndex ].pvKernelObjectData = pvKernelObjectData;
322 }
323/*-----------------------------------------------------------*/
324
325 static OpaqueObjectHandle_t MPU_GetHandleAtIndex( int32_t lIndex,
326 uint32_t ulKernelObjectType ) /* PRIVILEGED_FUNCTION */
327 {
328 OpaqueObjectHandle_t xObjectHandle = NULL;
329
330 configASSERT( IS_INTERNAL_INDEX_VALID( lIndex ) != pdFALSE );
331
332 if( xKernelObjectPool[ lIndex ].ulKernelObjectType == ulKernelObjectType )
333 {
334 xObjectHandle = xKernelObjectPool[ lIndex ].xInternalObjectHandle;
335 }
336
337 return xObjectHandle;
338 }
339/*-----------------------------------------------------------*/
340
341 #if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
342
343 void vGrantAccessToKernelObject( TaskHandle_t xExternalTaskHandle,
344 int32_t lExternalKernelObjectHandle ) /* PRIVILEGED_FUNCTION */
345 {
346 int32_t lExternalTaskIndex;
347 TaskHandle_t xInternalTaskHandle = NULL;
348
349 if( IS_EXTERNAL_INDEX_VALID( lExternalKernelObjectHandle ) != pdFALSE )
350 {
351 if( xExternalTaskHandle == NULL )
352 {
353 vPortGrantAccessToKernelObject( xExternalTaskHandle, CONVERT_TO_INTERNAL_INDEX( lExternalKernelObjectHandle ) );
354 }
355 else
356 {
357 lExternalTaskIndex = ( int32_t ) xExternalTaskHandle;
358
359 if( IS_EXTERNAL_INDEX_VALID( lExternalTaskIndex ) != pdFALSE )
360 {
361 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lExternalTaskIndex ) );
362
363 if( xInternalTaskHandle != NULL )
364 {
365 vPortGrantAccessToKernelObject( xInternalTaskHandle,
366 CONVERT_TO_INTERNAL_INDEX( lExternalKernelObjectHandle ) );
367 }
368 }
369 }
370 }
371 }
372
373 #endif /* #if ( configENABLE_ACCESS_CONTROL_LIST == 1 ) */
374/*-----------------------------------------------------------*/
375
376 #if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
377
378 void vRevokeAccessToKernelObject( TaskHandle_t xExternalTaskHandle,
379 int32_t lExternalKernelObjectHandle ) /* PRIVILEGED_FUNCTION */
380 {
381 int32_t lExternalTaskIndex;
382 TaskHandle_t xInternalTaskHandle = NULL;
383
384 if( IS_EXTERNAL_INDEX_VALID( lExternalKernelObjectHandle ) != pdFALSE )
385 {
386 if( xExternalTaskHandle == NULL )
387 {
388 vPortRevokeAccessToKernelObject( xExternalTaskHandle, CONVERT_TO_INTERNAL_INDEX( lExternalKernelObjectHandle ) );
389 }
390 else
391 {
392 lExternalTaskIndex = ( int32_t ) xExternalTaskHandle;
393
394 if( IS_EXTERNAL_INDEX_VALID( lExternalTaskIndex ) != pdFALSE )
395 {
396 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lExternalTaskIndex ) );
397
398 if( xInternalTaskHandle != NULL )
399 {
400 vPortRevokeAccessToKernelObject( xInternalTaskHandle,
401 CONVERT_TO_INTERNAL_INDEX( lExternalKernelObjectHandle ) );
402 }
403 }
404 }
405 }
406 }
407
408 #endif /* #if ( configENABLE_ACCESS_CONTROL_LIST == 1 ) */
409/*-----------------------------------------------------------*/
410
411 #if ( configUSE_TIMERS == 1 )
412
413 static void MPU_TimerCallback( TimerHandle_t xInternalHandle ) /* PRIVILEGED_FUNCTION */
414 {
415 int32_t i, lIndex = -1;
416 TimerHandle_t xExternalHandle = NULL;
417 TimerCallbackFunction_t pxApplicationCallBack = NULL;
418
419 /* Coming from the timer task and therefore, should be valid. */
420 configASSERT( xInternalHandle != NULL );
421
422 for( i = 0; i < configPROTECTED_KERNEL_OBJECT_POOL_SIZE; i++ )
423 {
424 if( ( ( TimerHandle_t ) xKernelObjectPool[ i ].xInternalObjectHandle == xInternalHandle ) &&
425 ( xKernelObjectPool[ i ].ulKernelObjectType == KERNEL_OBJECT_TYPE_TIMER ) )
426 {
427 lIndex = i;
428 break;
429 }
430 }
431
432 configASSERT( lIndex != -1 );
433 xExternalHandle = ( TimerHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
434
435 pxApplicationCallBack = ( TimerCallbackFunction_t ) xKernelObjectPool[ lIndex ].pvKernelObjectData;
436 pxApplicationCallBack( xExternalHandle );
437 }
438
439 #endif /* #if ( configUSE_TIMERS == 1 ) */
440/*-----------------------------------------------------------*/
441
442/*-----------------------------------------------------------*/
443/* MPU wrappers for tasks APIs. */
444/*-----------------------------------------------------------*/
445
446 #if ( INCLUDE_xTaskDelayUntil == 1 )
447
448 BaseType_t MPU_xTaskDelayUntilImpl( TickType_t * const pxPreviousWakeTime,
449 TickType_t xTimeIncrement ) PRIVILEGED_FUNCTION;
450
451 BaseType_t MPU_xTaskDelayUntilImpl( TickType_t * const pxPreviousWakeTime,
452 TickType_t xTimeIncrement ) /* PRIVILEGED_FUNCTION */
453 {
454 BaseType_t xReturn = pdFAIL;
455 BaseType_t xIsPreviousWakeTimeAccessible = pdFALSE;
456
457 if( ( pxPreviousWakeTime != NULL ) && ( xTimeIncrement > 0U ) )
458 {
459 xIsPreviousWakeTimeAccessible = xPortIsAuthorizedToAccessBuffer( pxPreviousWakeTime,
460 sizeof( TickType_t ),
461 ( tskMPU_WRITE_PERMISSION | tskMPU_READ_PERMISSION ) );
462
463 if( xIsPreviousWakeTimeAccessible == pdTRUE )
464 {
465 xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
466 }
467 }
468
469 return xReturn;
470 }
471
472 #endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */
473/*-----------------------------------------------------------*/
474
475 #if ( INCLUDE_xTaskAbortDelay == 1 )
476
477 BaseType_t MPU_xTaskAbortDelayImpl( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
478
479 BaseType_t MPU_xTaskAbortDelayImpl( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
480 {
481 BaseType_t xReturn = pdFAIL;
482 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
483 TaskHandle_t xInternalTaskHandle = NULL;
484 int32_t lIndex;
485
486 lIndex = ( int32_t ) xTask;
487
488 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
489 {
490 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
491
492 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
493 {
494 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
495
496 if( xInternalTaskHandle != NULL )
497 {
498 xReturn = xTaskAbortDelay( xInternalTaskHandle );
499 }
500 }
501 }
502
503 return xReturn;
504 }
505
506 #endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */
507/*-----------------------------------------------------------*/
508
509 #if ( INCLUDE_vTaskDelay == 1 )
510
511 void MPU_vTaskDelayImpl( TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
512
513 void MPU_vTaskDelayImpl( TickType_t xTicksToDelay ) /* PRIVILEGED_FUNCTION */
514 {
515 vTaskDelay( xTicksToDelay );
516 }
517
518 #endif /* if ( INCLUDE_vTaskDelay == 1 ) */
519/*-----------------------------------------------------------*/
520
521 #if ( INCLUDE_uxTaskPriorityGet == 1 )
522
523 UBaseType_t MPU_uxTaskPriorityGetImpl( const TaskHandle_t pxTask ) PRIVILEGED_FUNCTION;
524
525 UBaseType_t MPU_uxTaskPriorityGetImpl( const TaskHandle_t pxTask ) /* PRIVILEGED_FUNCTION */
526 {
527 UBaseType_t uxReturn = configMAX_PRIORITIES;
528 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
529 int32_t lIndex;
530 TaskHandle_t xInternalTaskHandle = NULL;
531
532 if( pxTask == NULL )
533 {
534 uxReturn = uxTaskPriorityGet( pxTask );
535 }
536 else
537 {
538 lIndex = ( int32_t ) pxTask;
539
540 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
541 {
542 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
543
544 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
545 {
546 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
547
548 if( xInternalTaskHandle != NULL )
549 {
550 uxReturn = uxTaskPriorityGet( xInternalTaskHandle );
551 }
552 }
553 }
554 }
555
556 return uxReturn;
557 }
558
559 #endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */
560/*-----------------------------------------------------------*/
561
562 #if ( INCLUDE_eTaskGetState == 1 )
563
564 eTaskState MPU_eTaskGetStateImpl( TaskHandle_t pxTask ) PRIVILEGED_FUNCTION;
565
566 eTaskState MPU_eTaskGetStateImpl( TaskHandle_t pxTask ) /* PRIVILEGED_FUNCTION */
567 {
568 eTaskState eReturn = eInvalid;
569 TaskHandle_t xInternalTaskHandle = NULL;
570 int32_t lIndex;
571 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
572
573 lIndex = ( int32_t ) pxTask;
574
575 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
576 {
577 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
578
579 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
580 {
581 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
582
583 if( xInternalTaskHandle != NULL )
584 {
585 eReturn = eTaskGetState( xInternalTaskHandle );
586 }
587 }
588 }
589
590 return eReturn;
591 }
592
593 #endif /* if ( INCLUDE_eTaskGetState == 1 ) */
594/*-----------------------------------------------------------*/
595
596 #if ( configUSE_TRACE_FACILITY == 1 )
597
598 void MPU_vTaskGetInfoImpl( TaskHandle_t xTask,
599 TaskStatus_t * pxTaskStatus,
600 BaseType_t xGetFreeStackSpace,
601 eTaskState eState ) PRIVILEGED_FUNCTION;
602
603 void MPU_vTaskGetInfoImpl( TaskHandle_t xTask,
604 TaskStatus_t * pxTaskStatus,
605 BaseType_t xGetFreeStackSpace,
606 eTaskState eState ) /* PRIVILEGED_FUNCTION */
607 {
608 int32_t lIndex;
609 TaskHandle_t xInternalTaskHandle = NULL;
610 BaseType_t xIsTaskStatusWriteable = pdFALSE;
611 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
612
613 xIsTaskStatusWriteable = xPortIsAuthorizedToAccessBuffer( pxTaskStatus,
614 sizeof( TaskStatus_t ),
615 tskMPU_WRITE_PERMISSION );
616
617 if( xIsTaskStatusWriteable == pdTRUE )
618 {
619 if( xTask == NULL )
620 {
621 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
622 }
623 else
624 {
625 lIndex = ( int32_t ) xTask;
626
627 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
628 {
629 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
630
631 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
632 {
633 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
634
635 if( xInternalTaskHandle != NULL )
636 {
637 vTaskGetInfo( xInternalTaskHandle, pxTaskStatus, xGetFreeStackSpace, eState );
638 }
639 }
640 }
641 }
642 }
643 }
644
645 #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
646/*-----------------------------------------------------------*/
647
648 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
649
650 TaskHandle_t MPU_xTaskGetIdleTaskHandleImpl( void ) PRIVILEGED_FUNCTION;
651
652 TaskHandle_t MPU_xTaskGetIdleTaskHandleImpl( void ) /* PRIVILEGED_FUNCTION */
653 {
654 TaskHandle_t xIdleTaskHandle = NULL;
655
656 xIdleTaskHandle = xTaskGetIdleTaskHandle();
657
658 return xIdleTaskHandle;
659 }
660
661 #endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */
662/*-----------------------------------------------------------*/
663
664 #if ( INCLUDE_vTaskSuspend == 1 )
665
666 void MPU_vTaskSuspendImpl( TaskHandle_t pxTaskToSuspend ) PRIVILEGED_FUNCTION;
667
668 void MPU_vTaskSuspendImpl( TaskHandle_t pxTaskToSuspend ) /* PRIVILEGED_FUNCTION */
669 {
670 int32_t lIndex;
671 TaskHandle_t xInternalTaskHandle = NULL;
672 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
673
674 if( pxTaskToSuspend == NULL )
675 {
676 vTaskSuspend( pxTaskToSuspend );
677 }
678 else
679 {
680 /* After the scheduler starts, only privileged tasks are allowed
681 * to suspend other tasks. */
682 #if ( INCLUDE_xTaskGetSchedulerState == 1 )
683 if( ( xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED ) || ( portIS_TASK_PRIVILEGED() == pdTRUE ) )
684 #else
685 if( portIS_TASK_PRIVILEGED() == pdTRUE )
686 #endif
687 {
688 lIndex = ( int32_t ) pxTaskToSuspend;
689
690 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
691 {
692 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
693
694 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
695 {
696 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
697
698 if( xInternalTaskHandle != NULL )
699 {
700 vTaskSuspend( xInternalTaskHandle );
701 }
702 }
703 }
704 }
705 }
706 }
707
708 #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
709/*-----------------------------------------------------------*/
710
711 #if ( INCLUDE_vTaskSuspend == 1 )
712
713 void MPU_vTaskResumeImpl( TaskHandle_t pxTaskToResume ) PRIVILEGED_FUNCTION;
714
715 void MPU_vTaskResumeImpl( TaskHandle_t pxTaskToResume ) /* PRIVILEGED_FUNCTION */
716 {
717 int32_t lIndex;
718 TaskHandle_t xInternalTaskHandle = NULL;
719 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
720
721 lIndex = ( int32_t ) pxTaskToResume;
722
723 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
724 {
725 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
726
727 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
728 {
729 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
730
731 if( xInternalTaskHandle != NULL )
732 {
733 vTaskResume( xInternalTaskHandle );
734 }
735 }
736 }
737 }
738
739 #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
740/*-----------------------------------------------------------*/
741
742 TickType_t MPU_xTaskGetTickCountImpl( void ) PRIVILEGED_FUNCTION;
743
744 TickType_t MPU_xTaskGetTickCountImpl( void ) /* PRIVILEGED_FUNCTION */
745 {
746 TickType_t xReturn;
747
748 xReturn = xTaskGetTickCount();
749
750 return xReturn;
751 }
752/*-----------------------------------------------------------*/
753
754 UBaseType_t MPU_uxTaskGetNumberOfTasksImpl( void ) PRIVILEGED_FUNCTION;
755
756 UBaseType_t MPU_uxTaskGetNumberOfTasksImpl( void ) /* PRIVILEGED_FUNCTION */
757 {
758 UBaseType_t uxReturn;
759
760 uxReturn = uxTaskGetNumberOfTasks();
761
762 return uxReturn;
763 }
764/*-----------------------------------------------------------*/
765
766 char * MPU_pcTaskGetNameImpl( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION;
767
768 char * MPU_pcTaskGetNameImpl( TaskHandle_t xTaskToQuery ) /* PRIVILEGED_FUNCTION */
769 {
770 char * pcReturn = NULL;
771 int32_t lIndex;
772 TaskHandle_t xInternalTaskHandle = NULL;
773
774 if( xTaskToQuery == NULL )
775 {
776 pcReturn = pcTaskGetName( xTaskToQuery );
777 }
778 else
779 {
780 lIndex = ( int32_t ) xTaskToQuery;
781
782 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
783 {
784 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
785
786 if( xInternalTaskHandle != NULL )
787 {
788 pcReturn = pcTaskGetName( xInternalTaskHandle );
789 }
790 }
791 }
792
793 return pcReturn;
794 }
795/*-----------------------------------------------------------*/
796
797 #if ( configGENERATE_RUN_TIME_STATS == 1 )
798
799 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounterImpl( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
800
801 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounterImpl( const TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
802 {
803 configRUN_TIME_COUNTER_TYPE xReturn = 0;
804 int32_t lIndex;
805 TaskHandle_t xInternalTaskHandle = NULL;
806 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
807
808 if( xTask == NULL )
809 {
810 xReturn = ulTaskGetRunTimeCounter( xTask );
811 }
812 else
813 {
814 lIndex = ( int32_t ) xTask;
815
816 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
817 {
818 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
819
820 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
821 {
822 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
823
824 if( xInternalTaskHandle != NULL )
825 {
826 xReturn = ulTaskGetRunTimeCounter( xInternalTaskHandle );
827 }
828 }
829 }
830 }
831
832 return xReturn;
833 }
834
835 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) */
836/*-----------------------------------------------------------*/
837
838 #if ( configGENERATE_RUN_TIME_STATS == 1 )
839
840 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercentImpl( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
841
842 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercentImpl( const TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
843 {
844 configRUN_TIME_COUNTER_TYPE xReturn = 0;
845 int32_t lIndex;
846 TaskHandle_t xInternalTaskHandle = NULL;
847 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
848
849 if( xTask == NULL )
850 {
851 xReturn = ulTaskGetRunTimePercent( xTask );
852 }
853 else
854 {
855 lIndex = ( int32_t ) xTask;
856
857 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
858 {
859 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
860
861 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
862 {
863 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
864
865 if( xInternalTaskHandle != NULL )
866 {
867 xReturn = ulTaskGetRunTimePercent( xInternalTaskHandle );
868 }
869 }
870 }
871 }
872
873 return xReturn;
874 }
875
876 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) */
877/*-----------------------------------------------------------*/
878
879 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
880
881 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercentImpl( void ) PRIVILEGED_FUNCTION;
882
883 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercentImpl( void ) /* PRIVILEGED_FUNCTION */
884 {
885 configRUN_TIME_COUNTER_TYPE xReturn;
886
887 xReturn = ulTaskGetIdleRunTimePercent();
888
889 return xReturn;
890 }
891
892 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
893/*-----------------------------------------------------------*/
894
895 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
896
897 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounterImpl( void ) PRIVILEGED_FUNCTION;
898
899 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounterImpl( void ) /* PRIVILEGED_FUNCTION */
900 {
901 configRUN_TIME_COUNTER_TYPE xReturn;
902
903 xReturn = ulTaskGetIdleRunTimeCounter();
904
905 return xReturn;
906 }
907
908 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
909/*-----------------------------------------------------------*/
910
911 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
912
913 void MPU_vTaskSetApplicationTaskTagImpl( TaskHandle_t xTask,
914 TaskHookFunction_t pxTagValue ) PRIVILEGED_FUNCTION;
915
916 void MPU_vTaskSetApplicationTaskTagImpl( TaskHandle_t xTask,
917 TaskHookFunction_t pxTagValue ) /* PRIVILEGED_FUNCTION */
918 {
919 TaskHandle_t xInternalTaskHandle = NULL;
920 int32_t lIndex;
921 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
922
923 if( xTask == NULL )
924 {
925 vTaskSetApplicationTaskTag( xTask, pxTagValue );
926 }
927 else
928 {
929 lIndex = ( int32_t ) xTask;
930
931 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
932 {
933 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
934
935 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
936 {
937 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
938
939 if( xInternalTaskHandle != NULL )
940 {
941 vTaskSetApplicationTaskTag( xInternalTaskHandle, pxTagValue );
942 }
943 }
944 }
945 }
946 }
947
948 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
949/*-----------------------------------------------------------*/
950
951 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
952
953 TaskHookFunction_t MPU_xTaskGetApplicationTaskTagImpl( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
954
955 TaskHookFunction_t MPU_xTaskGetApplicationTaskTagImpl( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
956 {
957 TaskHookFunction_t xReturn = NULL;
958 int32_t lIndex;
959 TaskHandle_t xInternalTaskHandle = NULL;
960 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
961
962 if( xTask == NULL )
963 {
964 xReturn = xTaskGetApplicationTaskTag( xTask );
965 }
966 else
967 {
968 lIndex = ( int32_t ) xTask;
969
970 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
971 {
972 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
973
974 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
975 {
976 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
977
978 if( xInternalTaskHandle != NULL )
979 {
980 xReturn = xTaskGetApplicationTaskTag( xInternalTaskHandle );
981 }
982 }
983 }
984 }
985
986 return xReturn;
987 }
988
989 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
990/*-----------------------------------------------------------*/
991
992 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
993
994 void MPU_vTaskSetThreadLocalStoragePointerImpl( TaskHandle_t xTaskToSet,
995 BaseType_t xIndex,
996 void * pvValue ) PRIVILEGED_FUNCTION;
997
998 void MPU_vTaskSetThreadLocalStoragePointerImpl( TaskHandle_t xTaskToSet,
999 BaseType_t xIndex,
1000 void * pvValue ) /* PRIVILEGED_FUNCTION */
1001 {
1002 int32_t lIndex;
1003 TaskHandle_t xInternalTaskHandle = NULL;
1004 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
1005
1006 if( xTaskToSet == NULL )
1007 {
1008 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
1009 }
1010 else
1011 {
1012 lIndex = ( int32_t ) xTaskToSet;
1013
1014 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1015 {
1016 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1017
1018 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
1019 {
1020 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1021
1022 if( xInternalTaskHandle != NULL )
1023 {
1024 vTaskSetThreadLocalStoragePointer( xInternalTaskHandle, xIndex, pvValue );
1025 }
1026 }
1027 }
1028 }
1029 }
1030
1031 #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
1032/*-----------------------------------------------------------*/
1033
1034 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
1035
1036 void * MPU_pvTaskGetThreadLocalStoragePointerImpl( TaskHandle_t xTaskToQuery,
1037 BaseType_t xIndex ) PRIVILEGED_FUNCTION;
1038
1039 void * MPU_pvTaskGetThreadLocalStoragePointerImpl( TaskHandle_t xTaskToQuery,
1040 BaseType_t xIndex ) /* PRIVILEGED_FUNCTION */
1041 {
1042 void * pvReturn = NULL;
1043 int32_t lIndex;
1044 TaskHandle_t xInternalTaskHandle = NULL;
1045 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
1046
1047 if( xTaskToQuery == NULL )
1048 {
1049 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
1050 }
1051 else
1052 {
1053 lIndex = ( int32_t ) xTaskToQuery;
1054
1055 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1056 {
1057 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1058
1059 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
1060 {
1061 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1062
1063 if( xInternalTaskHandle != NULL )
1064 {
1065 pvReturn = pvTaskGetThreadLocalStoragePointer( xInternalTaskHandle, xIndex );
1066 }
1067 }
1068 }
1069 }
1070
1071 return pvReturn;
1072 }
1073
1074 #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
1075/*-----------------------------------------------------------*/
1076
1077 #if ( configUSE_TRACE_FACILITY == 1 )
1078
1079 UBaseType_t MPU_uxTaskGetSystemStateImpl( TaskStatus_t * pxTaskStatusArray,
1080 UBaseType_t uxArraySize,
1081 configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) PRIVILEGED_FUNCTION;
1082
1083 UBaseType_t MPU_uxTaskGetSystemStateImpl( TaskStatus_t * pxTaskStatusArray,
1084 UBaseType_t uxArraySize,
1085 configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) /* PRIVILEGED_FUNCTION */
1086 {
1087 UBaseType_t uxReturn = 0;
1088 UBaseType_t xIsTaskStatusArrayWriteable = pdFALSE;
1089 UBaseType_t xIsTotalRunTimeWriteable = pdFALSE;
1090 uint32_t ulArraySize = ( uint32_t ) uxArraySize;
1091 uint32_t ulTaskStatusSize = ( uint32_t ) sizeof( TaskStatus_t );
1092
1093 if( mpuMULTIPLY_UINT32_WILL_OVERFLOW( ulTaskStatusSize, ulArraySize ) == 0 )
1094 {
1095 xIsTaskStatusArrayWriteable = xPortIsAuthorizedToAccessBuffer( pxTaskStatusArray,
1096 ulTaskStatusSize * ulArraySize,
1097 tskMPU_WRITE_PERMISSION );
1098
1099 if( pulTotalRunTime != NULL )
1100 {
1101 xIsTotalRunTimeWriteable = xPortIsAuthorizedToAccessBuffer( pulTotalRunTime,
1102 sizeof( configRUN_TIME_COUNTER_TYPE ),
1103 tskMPU_WRITE_PERMISSION );
1104 }
1105
1106 if( ( xIsTaskStatusArrayWriteable == pdTRUE ) &&
1107 ( ( pulTotalRunTime == NULL ) || ( xIsTotalRunTimeWriteable == pdTRUE ) ) )
1108 {
1109 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, ( UBaseType_t ) ulArraySize, pulTotalRunTime );
1110 }
1111 }
1112
1113 return uxReturn;
1114 }
1115
1116 #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
1117/*-----------------------------------------------------------*/
1118
1119 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
1120
1121 UBaseType_t MPU_uxTaskGetStackHighWaterMarkImpl( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
1122
1123 UBaseType_t MPU_uxTaskGetStackHighWaterMarkImpl( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
1124 {
1125 UBaseType_t uxReturn = 0;
1126 int32_t lIndex;
1127 TaskHandle_t xInternalTaskHandle = NULL;
1128 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
1129
1130 if( xTask == NULL )
1131 {
1132 uxReturn = uxTaskGetStackHighWaterMark( xTask );
1133 }
1134 else
1135 {
1136 lIndex = ( int32_t ) xTask;
1137
1138 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1139 {
1140 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1141
1142 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
1143 {
1144 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1145
1146 if( xInternalTaskHandle != NULL )
1147 {
1148 uxReturn = uxTaskGetStackHighWaterMark( xInternalTaskHandle );
1149 }
1150 }
1151 }
1152 }
1153
1154 return uxReturn;
1155 }
1156
1157 #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */
1158/*-----------------------------------------------------------*/
1159
1160 #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
1161
1162 configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2Impl( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
1163
1164 configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2Impl( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
1165 {
1166 configSTACK_DEPTH_TYPE uxReturn = 0;
1167 int32_t lIndex;
1168 TaskHandle_t xInternalTaskHandle = NULL;
1169 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
1170
1171 if( xTask == NULL )
1172 {
1173 uxReturn = uxTaskGetStackHighWaterMark2( xTask );
1174 }
1175 else
1176 {
1177 lIndex = ( int32_t ) xTask;
1178
1179 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1180 {
1181 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1182
1183 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
1184 {
1185 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1186
1187 if( xInternalTaskHandle != NULL )
1188 {
1189 uxReturn = uxTaskGetStackHighWaterMark2( xInternalTaskHandle );
1190 }
1191 }
1192 }
1193 }
1194
1195 return uxReturn;
1196 }
1197
1198 #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */
1199/*-----------------------------------------------------------*/
1200
1201 #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
1202
1203 TaskHandle_t MPU_xTaskGetCurrentTaskHandleImpl( void ) PRIVILEGED_FUNCTION;
1204
1205 TaskHandle_t MPU_xTaskGetCurrentTaskHandleImpl( void ) /* PRIVILEGED_FUNCTION */
1206 {
1207 TaskHandle_t xInternalTaskHandle = NULL;
1208 TaskHandle_t xExternalTaskHandle = NULL;
1209 int32_t lIndex;
1210
1211 xInternalTaskHandle = xTaskGetCurrentTaskHandle();
1212
1213 if( xInternalTaskHandle != NULL )
1214 {
1215 lIndex = MPU_GetIndexForTaskHandle( xInternalTaskHandle );
1216
1217 if( lIndex != -1 )
1218 {
1219 xExternalTaskHandle = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
1220 }
1221 }
1222
1223 return xExternalTaskHandle;
1224 }
1225
1226 #endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */
1227/*-----------------------------------------------------------*/
1228
1229 #if ( INCLUDE_xTaskGetSchedulerState == 1 )
1230
1231 BaseType_t MPU_xTaskGetSchedulerStateImpl( void ) PRIVILEGED_FUNCTION;
1232
1233 BaseType_t MPU_xTaskGetSchedulerStateImpl( void ) /* PRIVILEGED_FUNCTION */
1234 {
1235 BaseType_t xReturn = taskSCHEDULER_NOT_STARTED;
1236
1237 xReturn = xTaskGetSchedulerState();
1238
1239 return xReturn;
1240 }
1241
1242 #endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */
1243/*-----------------------------------------------------------*/
1244
1245 void MPU_vTaskSetTimeOutStateImpl( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
1246
1247 void MPU_vTaskSetTimeOutStateImpl( TimeOut_t * const pxTimeOut ) /* PRIVILEGED_FUNCTION */
1248 {
1249 BaseType_t xIsTimeOutWriteable = pdFALSE;
1250
1251 if( pxTimeOut != NULL )
1252 {
1253 xIsTimeOutWriteable = xPortIsAuthorizedToAccessBuffer( pxTimeOut,
1254 sizeof( TimeOut_t ),
1255 tskMPU_WRITE_PERMISSION );
1256
1257 if( xIsTimeOutWriteable == pdTRUE )
1258 {
1259 vTaskSetTimeOutState( pxTimeOut );
1260 }
1261 }
1262 }
1263/*-----------------------------------------------------------*/
1264
1265 BaseType_t MPU_xTaskCheckForTimeOutImpl( TimeOut_t * const pxTimeOut,
1266 TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;
1267
1268 BaseType_t MPU_xTaskCheckForTimeOutImpl( TimeOut_t * const pxTimeOut,
1269 TickType_t * const pxTicksToWait ) /* PRIVILEGED_FUNCTION */
1270 {
1271 BaseType_t xReturn = pdFALSE;
1272 BaseType_t xIsTimeOutWriteable = pdFALSE;
1273 BaseType_t xIsTicksToWaitWriteable = pdFALSE;
1274
1275 if( ( pxTimeOut != NULL ) && ( pxTicksToWait != NULL ) )
1276 {
1277 xIsTimeOutWriteable = xPortIsAuthorizedToAccessBuffer( pxTimeOut,
1278 sizeof( TimeOut_t ),
1279 tskMPU_WRITE_PERMISSION );
1280 xIsTicksToWaitWriteable = xPortIsAuthorizedToAccessBuffer( pxTicksToWait,
1281 sizeof( TickType_t ),
1282 tskMPU_WRITE_PERMISSION );
1283
1284 if( ( xIsTimeOutWriteable == pdTRUE ) && ( xIsTicksToWaitWriteable == pdTRUE ) )
1285 {
1286 xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
1287 }
1288 }
1289
1290 return xReturn;
1291 }
1292/*-----------------------------------------------------------*/
1293
1294 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1295
1296 BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,
1297 UBaseType_t uxIndexToNotify,
1298 uint32_t ulValue,
1299 eNotifyAction eAction,
1300 uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */
1301 {
1302 BaseType_t xReturn = pdFAIL;
1303 xTaskGenericNotifyParams_t xParams;
1304
1305 xParams.xTaskToNotify = xTaskToNotify;
1306 xParams.uxIndexToNotify = uxIndexToNotify;
1307 xParams.ulValue = ulValue;
1308 xParams.eAction = eAction;
1309 xParams.pulPreviousNotificationValue = pulPreviousNotificationValue;
1310
1311 xReturn = MPU_xTaskGenericNotifyEntry( &( xParams ) );
1312
1313 return xReturn;
1314 }
1315
1316 BaseType_t MPU_xTaskGenericNotifyImpl( const xTaskGenericNotifyParams_t * pxParams ) PRIVILEGED_FUNCTION;
1317
1318 BaseType_t MPU_xTaskGenericNotifyImpl( const xTaskGenericNotifyParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
1319 {
1320 BaseType_t xReturn = pdFAIL;
1321 int32_t lIndex;
1322 TaskHandle_t xInternalTaskHandle = NULL;
1323 BaseType_t xIsPreviousNotificationValueWriteable = pdFALSE;
1324 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
1325 BaseType_t xAreParamsReadable = pdFALSE;
1326
1327 if( pxParams != NULL )
1328 {
1329 xAreParamsReadable = xPortIsAuthorizedToAccessBuffer( pxParams,
1330 sizeof( xTaskGenericNotifyParams_t ),
1331 tskMPU_READ_PERMISSION );
1332 }
1333
1334 if( xAreParamsReadable == pdTRUE )
1335 {
1336 if( ( pxParams->uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES ) &&
1337 ( ( pxParams->eAction == eNoAction ) ||
1338 ( pxParams->eAction == eSetBits ) ||
1339 ( pxParams->eAction == eIncrement ) ||
1340 ( pxParams->eAction == eSetValueWithOverwrite ) ||
1341 ( pxParams->eAction == eSetValueWithoutOverwrite ) ) )
1342 {
1343 if( pxParams->pulPreviousNotificationValue != NULL )
1344 {
1345 xIsPreviousNotificationValueWriteable = xPortIsAuthorizedToAccessBuffer( pxParams->pulPreviousNotificationValue,
1346 sizeof( uint32_t ),
1347 tskMPU_WRITE_PERMISSION );
1348 }
1349
1350 if( ( pxParams->pulPreviousNotificationValue == NULL ) ||
1351 ( xIsPreviousNotificationValueWriteable == pdTRUE ) )
1352 {
1353 lIndex = ( int32_t ) ( pxParams->xTaskToNotify );
1354
1355 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1356 {
1357 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1358
1359 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
1360 {
1361 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1362
1363 if( xInternalTaskHandle != NULL )
1364 {
1365 xReturn = xTaskGenericNotify( xInternalTaskHandle,
1366 pxParams->uxIndexToNotify,
1367 pxParams->ulValue,
1368 pxParams->eAction,
1369 pxParams->pulPreviousNotificationValue );
1370 }
1371 }
1372 }
1373 }
1374 }
1375 }
1376
1377 return xReturn;
1378 }
1379
1380 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1381/*-----------------------------------------------------------*/
1382
1383 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1384
1385 BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
1386 uint32_t ulBitsToClearOnEntry,
1387 uint32_t ulBitsToClearOnExit,
1388 uint32_t * pulNotificationValue,
1389 TickType_t xTicksToWait )
1390 {
1391 BaseType_t xReturn = pdFAIL;
1392 xTaskGenericNotifyWaitParams_t xParams;
1393
1394 xParams.uxIndexToWaitOn = uxIndexToWaitOn;
1395 xParams.ulBitsToClearOnEntry = ulBitsToClearOnEntry;
1396 xParams.ulBitsToClearOnExit = ulBitsToClearOnExit;
1397 xParams.pulNotificationValue = pulNotificationValue;
1398 xParams.xTicksToWait = xTicksToWait;
1399
1400 xReturn = MPU_xTaskGenericNotifyWaitEntry( &( xParams ) );
1401
1402 return xReturn;
1403 }
1404
1405 BaseType_t MPU_xTaskGenericNotifyWaitImpl( const xTaskGenericNotifyWaitParams_t * pxParams ) PRIVILEGED_FUNCTION;
1406
1407 BaseType_t MPU_xTaskGenericNotifyWaitImpl( const xTaskGenericNotifyWaitParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
1408 {
1409 BaseType_t xReturn = pdFAIL;
1410 BaseType_t xIsNotificationValueWritable = pdFALSE;
1411 BaseType_t xAreParamsReadable = pdFALSE;
1412
1413 if( pxParams != NULL )
1414 {
1415 xAreParamsReadable = xPortIsAuthorizedToAccessBuffer( pxParams,
1416 sizeof( xTaskGenericNotifyWaitParams_t ),
1417 tskMPU_READ_PERMISSION );
1418 }
1419
1420 if( xAreParamsReadable == pdTRUE )
1421 {
1422 if( pxParams->uxIndexToWaitOn < configTASK_NOTIFICATION_ARRAY_ENTRIES )
1423 {
1424 if( pxParams->pulNotificationValue != NULL )
1425 {
1426 xIsNotificationValueWritable = xPortIsAuthorizedToAccessBuffer( pxParams->pulNotificationValue,
1427 sizeof( uint32_t ),
1428 tskMPU_WRITE_PERMISSION );
1429 }
1430
1431 if( ( pxParams->pulNotificationValue == NULL ) ||
1432 ( xIsNotificationValueWritable == pdTRUE ) )
1433 {
1434 xReturn = xTaskGenericNotifyWait( pxParams->uxIndexToWaitOn,
1435 pxParams->ulBitsToClearOnEntry,
1436 pxParams->ulBitsToClearOnExit,
1437 pxParams->pulNotificationValue,
1438 pxParams->xTicksToWait );
1439 }
1440 }
1441 }
1442
1443 return xReturn;
1444 }
1445
1446 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1447/*-----------------------------------------------------------*/
1448
1449 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1450
1451 uint32_t MPU_ulTaskGenericNotifyTakeImpl( UBaseType_t uxIndexToWaitOn,
1452 BaseType_t xClearCountOnExit,
1453 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
1454
1455 uint32_t MPU_ulTaskGenericNotifyTakeImpl( UBaseType_t uxIndexToWaitOn,
1456 BaseType_t xClearCountOnExit,
1457 TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
1458 {
1459 uint32_t ulReturn = 0;
1460
1461 if( uxIndexToWaitOn < configTASK_NOTIFICATION_ARRAY_ENTRIES )
1462 {
1463 ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
1464 }
1465
1466 return ulReturn;
1467 }
1468
1469 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1470/*-----------------------------------------------------------*/
1471
1472 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1473
1474 BaseType_t MPU_xTaskGenericNotifyStateClearImpl( TaskHandle_t xTask,
1475 UBaseType_t uxIndexToClear ) PRIVILEGED_FUNCTION;
1476
1477 BaseType_t MPU_xTaskGenericNotifyStateClearImpl( TaskHandle_t xTask,
1478 UBaseType_t uxIndexToClear ) /* PRIVILEGED_FUNCTION */
1479 {
1480 BaseType_t xReturn = pdFAIL;
1481 int32_t lIndex;
1482 TaskHandle_t xInternalTaskHandle = NULL;
1483 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
1484
1485 if( uxIndexToClear < configTASK_NOTIFICATION_ARRAY_ENTRIES )
1486 {
1487 if( xTask == NULL )
1488 {
1489 xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
1490 }
1491 else
1492 {
1493 lIndex = ( int32_t ) xTask;
1494
1495 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1496 {
1497 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1498
1499 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
1500 {
1501 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1502
1503 if( xInternalTaskHandle != NULL )
1504 {
1505 xReturn = xTaskGenericNotifyStateClear( xInternalTaskHandle, uxIndexToClear );
1506 }
1507 }
1508 }
1509 }
1510 }
1511
1512 return xReturn;
1513 }
1514
1515 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1516/*-----------------------------------------------------------*/
1517
1518 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
1519
1520 uint32_t MPU_ulTaskGenericNotifyValueClearImpl( TaskHandle_t xTask,
1521 UBaseType_t uxIndexToClear,
1522 uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;
1523
1524 uint32_t MPU_ulTaskGenericNotifyValueClearImpl( TaskHandle_t xTask,
1525 UBaseType_t uxIndexToClear,
1526 uint32_t ulBitsToClear ) /* PRIVILEGED_FUNCTION */
1527 {
1528 uint32_t ulReturn = 0;
1529 int32_t lIndex;
1530 TaskHandle_t xInternalTaskHandle = NULL;
1531 BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
1532
1533 if( uxIndexToClear < configTASK_NOTIFICATION_ARRAY_ENTRIES )
1534 {
1535 if( xTask == NULL )
1536 {
1537 ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
1538 }
1539 else
1540 {
1541 lIndex = ( int32_t ) xTask;
1542
1543 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1544 {
1545 xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1546
1547 if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
1548 {
1549 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1550
1551 if( xInternalTaskHandle != NULL )
1552 {
1553 ulReturn = ulTaskGenericNotifyValueClear( xInternalTaskHandle, uxIndexToClear, ulBitsToClear );
1554 }
1555 }
1556 }
1557 }
1558 }
1559
1560 return ulReturn;
1561 }
1562
1563 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
1564/*-----------------------------------------------------------*/
1565
1566/* Privileged only wrappers for Task APIs. These are needed so that
1567 * the application can use opaque handles maintained in mpu_wrappers.c
1568 * with all the APIs. */
1569/*-----------------------------------------------------------*/
1570
1571 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
1572
1573 BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode,
1574 const char * const pcName,
1575 uint16_t usStackDepth,
1576 void * pvParameters,
1577 UBaseType_t uxPriority,
1578 TaskHandle_t * pxCreatedTask ) /* PRIVILEGED_FUNCTION */
1579 {
1580 BaseType_t xReturn = pdFAIL;
1581 int32_t lIndex;
1582 TaskHandle_t xInternalTaskHandle = NULL;
1583
1584 lIndex = MPU_GetFreeIndexInKernelObjectPool();
1585
1586 if( lIndex != -1 )
1587 {
1588 /* xTaskCreate() can only be used to create privileged tasks in MPU port. */
1589 if( ( uxPriority & portPRIVILEGE_BIT ) != 0 )
1590 {
1591 xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, &( xInternalTaskHandle ) );
1592
1593 if( ( xReturn == pdPASS ) && ( xInternalTaskHandle != NULL ) )
1594 {
1595 MPU_StoreTaskHandleAtIndex( lIndex, xInternalTaskHandle );
1596
1597 if( pxCreatedTask != NULL )
1598 {
1599 *pxCreatedTask = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
1600 }
1601 }
1602 else
1603 {
1604 MPU_SetIndexFreeInKernelObjectPool( lIndex );
1605 }
1606 }
1607 }
1608
1609 return xReturn;
1610 }
1611
1612 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
1613/*-----------------------------------------------------------*/
1614
1615 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
1616
1617 TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,
1618 const char * const pcName,
1619 const uint32_t ulStackDepth,
1620 void * const pvParameters,
1621 UBaseType_t uxPriority,
1622 StackType_t * const puxStackBuffer,
1623 StaticTask_t * const pxTaskBuffer ) /* PRIVILEGED_FUNCTION */
1624 {
1625 TaskHandle_t xExternalTaskHandle = NULL;
1626 TaskHandle_t xInternalTaskHandle = NULL;
1627 int32_t lIndex;
1628
1629 lIndex = MPU_GetFreeIndexInKernelObjectPool();
1630
1631 if( lIndex != -1 )
1632 {
1633 xInternalTaskHandle = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
1634
1635 if( xInternalTaskHandle != NULL )
1636 {
1637 MPU_StoreTaskHandleAtIndex( lIndex, xInternalTaskHandle );
1638
1639 #if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
1640 {
1641 /* By default, an unprivileged task has access to itself. */
1642 if( ( uxPriority & portPRIVILEGE_BIT ) == 0 )
1643 {
1644 vPortGrantAccessToKernelObject( xInternalTaskHandle, lIndex );
1645 }
1646 }
1647 #endif
1648
1649 xExternalTaskHandle = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
1650 }
1651 else
1652 {
1653 MPU_SetIndexFreeInKernelObjectPool( lIndex );
1654 }
1655 }
1656
1657 return xExternalTaskHandle;
1658 }
1659
1660 #endif /* configSUPPORT_STATIC_ALLOCATION */
1661/*-----------------------------------------------------------*/
1662
1663 #if ( INCLUDE_vTaskDelete == 1 )
1664
1665 void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete ) /* PRIVILEGED_FUNCTION */
1666 {
1667 TaskHandle_t xInternalTaskHandle = NULL;
1668 int32_t lIndex;
1669
1670 if( pxTaskToDelete == NULL )
1671 {
1672 xInternalTaskHandle = xTaskGetCurrentTaskHandle();
1673 lIndex = MPU_GetIndexForTaskHandle( xInternalTaskHandle );
1674
1675 vTaskDelete( xInternalTaskHandle );
1676
1677 if( lIndex != -1 )
1678 {
1679 MPU_SetIndexFreeInKernelObjectPool( lIndex );
1680 }
1681 }
1682 else
1683 {
1684 lIndex = ( int32_t ) pxTaskToDelete;
1685
1686 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1687 {
1688 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1689
1690 if( xInternalTaskHandle != NULL )
1691 {
1692 vTaskDelete( xInternalTaskHandle );
1693 MPU_SetIndexFreeInKernelObjectPool( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1694 }
1695 }
1696 }
1697 }
1698
1699 #endif /* #if ( INCLUDE_vTaskDelete == 1 ) */
1700/*-----------------------------------------------------------*/
1701
1702
1703 #if ( INCLUDE_vTaskPrioritySet == 1 )
1704
1705 void MPU_vTaskPrioritySet( TaskHandle_t pxTask,
1706 UBaseType_t uxNewPriority ) /* PRIVILEGED_FUNCTION */
1707 {
1708 TaskHandle_t xInternalTaskHandle = NULL;
1709 int32_t lIndex;
1710
1711 if( pxTask == NULL )
1712 {
1713 vTaskPrioritySet( pxTask, uxNewPriority );
1714 }
1715 else
1716 {
1717 lIndex = ( int32_t ) pxTask;
1718
1719 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1720 {
1721 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1722
1723 if( xInternalTaskHandle != NULL )
1724 {
1725 vTaskPrioritySet( xInternalTaskHandle, uxNewPriority );
1726 }
1727 }
1728 }
1729 }
1730
1731 #endif /* if ( INCLUDE_vTaskPrioritySet == 1 ) */
1732/*-----------------------------------------------------------*/
1733
1734 #if ( INCLUDE_xTaskGetHandle == 1 )
1735
1736 TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) /* PRIVILEGED_FUNCTION */
1737 {
1738 TaskHandle_t xInternalTaskHandle = NULL;
1739 TaskHandle_t xExternalTaskHandle = NULL;
1740 int32_t lIndex;
1741
1742 xInternalTaskHandle = xTaskGetHandle( pcNameToQuery );
1743
1744 if( xInternalTaskHandle != NULL )
1745 {
1746 lIndex = MPU_GetIndexForTaskHandle( xInternalTaskHandle );
1747
1748 if( lIndex != -1 )
1749 {
1750 xExternalTaskHandle = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
1751 }
1752 }
1753
1754 return xExternalTaskHandle;
1755 }
1756
1757 #endif /* if ( INCLUDE_xTaskGetHandle == 1 ) */
1758/*-----------------------------------------------------------*/
1759
1760
1761 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
1762
1763 BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
1764 void * pvParameter ) /* PRIVILEGED_FUNCTION */
1765 {
1766 BaseType_t xReturn = pdFAIL;
1767 int32_t lIndex;
1768 TaskHandle_t xInternalTaskHandle = NULL;
1769
1770 if( xTask == NULL )
1771 {
1772 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
1773 }
1774 else
1775 {
1776 lIndex = ( int32_t ) xTask;
1777
1778 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1779 {
1780 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1781
1782 if( xInternalTaskHandle != NULL )
1783 {
1784 xReturn = xTaskCallApplicationTaskHook( xInternalTaskHandle, pvParameter );
1785 }
1786 }
1787 }
1788
1789 return xReturn;
1790 }
1791
1792 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
1793/*-----------------------------------------------------------*/
1794
1795 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
1796
1797 BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition,
1798 TaskHandle_t * pxCreatedTask ) /* PRIVILEGED_FUNCTION */
1799 {
1800 BaseType_t xReturn = pdFAIL;
1801 int32_t lIndex;
1802 TaskHandle_t xInternalTaskHandle = NULL;
1803
1804 lIndex = MPU_GetFreeIndexInKernelObjectPool();
1805
1806 if( lIndex != -1 )
1807 {
1808 xReturn = xTaskCreateRestricted( pxTaskDefinition, &( xInternalTaskHandle ) );
1809
1810 if( ( xReturn == pdPASS ) && ( xInternalTaskHandle != NULL ) )
1811 {
1812 MPU_StoreTaskHandleAtIndex( lIndex, xInternalTaskHandle );
1813
1814 #if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
1815 {
1816 /* By default, an unprivileged task has access to itself. */
1817 if( ( pxTaskDefinition->uxPriority & portPRIVILEGE_BIT ) == 0 )
1818 {
1819 vPortGrantAccessToKernelObject( xInternalTaskHandle, lIndex );
1820 }
1821 }
1822 #endif
1823
1824 if( pxCreatedTask != NULL )
1825 {
1826 *pxCreatedTask = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
1827 }
1828 }
1829 else
1830 {
1831 MPU_SetIndexFreeInKernelObjectPool( lIndex );
1832 }
1833 }
1834
1835 return xReturn;
1836 }
1837
1838 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
1839/*-----------------------------------------------------------*/
1840
1841 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
1842
1843 BaseType_t MPU_xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition,
1844 TaskHandle_t * pxCreatedTask ) /* PRIVILEGED_FUNCTION */
1845 {
1846 BaseType_t xReturn = pdFAIL;
1847 int32_t lIndex;
1848 TaskHandle_t xInternalTaskHandle = NULL;
1849
1850 lIndex = MPU_GetFreeIndexInKernelObjectPool();
1851
1852 if( lIndex != -1 )
1853 {
1854 xReturn = xTaskCreateRestrictedStatic( pxTaskDefinition, &( xInternalTaskHandle ) );
1855
1856 if( ( xReturn == pdPASS ) && ( xInternalTaskHandle != NULL ) )
1857 {
1858 MPU_StoreTaskHandleAtIndex( lIndex, xInternalTaskHandle );
1859
1860 #if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
1861 {
1862 /* By default, an unprivileged task has access to itself. */
1863 if( ( pxTaskDefinition->uxPriority & portPRIVILEGE_BIT ) == 0 )
1864 {
1865 vPortGrantAccessToKernelObject( xInternalTaskHandle, lIndex );
1866 }
1867 }
1868 #endif
1869
1870 if( pxCreatedTask != NULL )
1871 {
1872 *pxCreatedTask = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
1873 }
1874 }
1875 else
1876 {
1877 MPU_SetIndexFreeInKernelObjectPool( lIndex );
1878 }
1879 }
1880
1881 return xReturn;
1882 }
1883
1884 #endif /* configSUPPORT_STATIC_ALLOCATION */
1885/*-----------------------------------------------------------*/
1886
1887 void MPU_vTaskAllocateMPURegions( TaskHandle_t xTaskToModify,
1888 const MemoryRegion_t * const xRegions ) /* PRIVILEGED_FUNCTION */
1889 {
1890 TaskHandle_t xInternalTaskHandle = NULL;
1891 int32_t lIndex;
1892
1893 if( xTaskToModify == NULL )
1894 {
1895 vTaskAllocateMPURegions( xTaskToModify, xRegions );
1896 }
1897 else
1898 {
1899 lIndex = ( int32_t ) xTaskToModify;
1900
1901 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1902 {
1903 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1904
1905 if( xInternalTaskHandle != NULL )
1906 {
1907 vTaskAllocateMPURegions( xInternalTaskHandle, xRegions );
1908 }
1909 }
1910 }
1911 }
1912/*-----------------------------------------------------------*/
1913
1914 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
1915
1916 BaseType_t MPU_xTaskGetStaticBuffers( TaskHandle_t xTask,
1917 StackType_t ** ppuxStackBuffer,
1918 StaticTask_t ** ppxTaskBuffer ) /* PRIVILEGED_FUNCTION */
1919 {
1920 TaskHandle_t xInternalTaskHandle = NULL;
1921 int32_t lIndex;
1922 BaseType_t xReturn = pdFALSE;
1923
1924 if( xTask == NULL )
1925 {
1926 xInternalTaskHandle = xTaskGetCurrentTaskHandle();
1927 xReturn = xTaskGetStaticBuffers( xInternalTaskHandle, ppuxStackBuffer, ppxTaskBuffer );
1928 }
1929 else
1930 {
1931 lIndex = ( int32_t ) xTask;
1932
1933 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1934 {
1935 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1936
1937 if( xInternalTaskHandle != NULL )
1938 {
1939 xReturn = xTaskGetStaticBuffers( xInternalTaskHandle, ppuxStackBuffer, ppxTaskBuffer );
1940 }
1941 }
1942 }
1943
1944 return xReturn;
1945 }
1946
1947 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
1948/*-----------------------------------------------------------*/
1949
1950 #if ( INCLUDE_uxTaskPriorityGet == 1 )
1951
1952 UBaseType_t MPU_uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
1953 {
1954 UBaseType_t uxReturn = configMAX_PRIORITIES;
1955 int32_t lIndex;
1956 TaskHandle_t xInternalTaskHandle = NULL;
1957
1958 if( xTask == NULL )
1959 {
1960 uxReturn = uxTaskPriorityGetFromISR( xTask );
1961 }
1962 else
1963 {
1964 lIndex = ( int32_t ) xTask;
1965
1966 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1967 {
1968 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1969
1970 if( xInternalTaskHandle != NULL )
1971 {
1972 uxReturn = uxTaskPriorityGetFromISR( xInternalTaskHandle );
1973 }
1974 }
1975 }
1976
1977 return uxReturn;
1978 }
1979
1980 #endif /* #if ( INCLUDE_uxTaskPriorityGet == 1 ) */
1981/*-----------------------------------------------------------*/
1982
1983 #if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )
1984
1985 BaseType_t MPU_xTaskResumeFromISR( TaskHandle_t xTaskToResume ) /* PRIVILEGED_FUNCTION */
1986 {
1987 BaseType_t xReturn = pdFAIL;
1988 int32_t lIndex;
1989 TaskHandle_t xInternalTaskHandle = NULL;
1990
1991 lIndex = ( int32_t ) xTaskToResume;
1992
1993 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
1994 {
1995 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
1996
1997 if( xInternalTaskHandle != NULL )
1998 {
1999 xReturn = xTaskResumeFromISR( xInternalTaskHandle );
2000 }
2001 }
2002
2003 return xReturn;
2004 }
2005
2006 #endif /* #if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )*/
2007/*---------------------------------------------------------------------------------------*/
2008
2009 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
2010
2011 TaskHookFunction_t MPU_xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
2012 {
2013 TaskHookFunction_t xReturn = NULL;
2014 int32_t lIndex;
2015 TaskHandle_t xInternalTaskHandle = NULL;
2016
2017 if( xTask == NULL )
2018 {
2019 xReturn = xTaskGetApplicationTaskTagFromISR( xTask );
2020 }
2021 else
2022 {
2023 lIndex = ( int32_t ) xTask;
2024
2025 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2026 {
2027 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2028
2029 if( xInternalTaskHandle != NULL )
2030 {
2031 xReturn = xTaskGetApplicationTaskTagFromISR( xInternalTaskHandle );
2032 }
2033 }
2034 }
2035
2036 return xReturn;
2037 }
2038
2039 #endif /* #if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
2040/*---------------------------------------------------------------------------------------*/
2041
2042 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
2043
2044 BaseType_t MPU_xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
2045 UBaseType_t uxIndexToNotify,
2046 uint32_t ulValue,
2047 eNotifyAction eAction,
2048 uint32_t * pulPreviousNotificationValue,
2049 BaseType_t * pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
2050 {
2051 BaseType_t xReturn = pdFAIL;
2052 int32_t lIndex;
2053 TaskHandle_t xInternalTaskHandle = NULL;
2054
2055 lIndex = ( int32_t ) xTaskToNotify;
2056
2057 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2058 {
2059 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2060
2061 if( xInternalTaskHandle != NULL )
2062 {
2063 xReturn = xTaskGenericNotifyFromISR( xInternalTaskHandle, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken );
2064 }
2065 }
2066
2067 return xReturn;
2068 }
2069
2070 #endif /* #if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
2071/*---------------------------------------------------------------------------------------*/
2072
2073 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
2074
2075 void MPU_vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
2076 UBaseType_t uxIndexToNotify,
2077 BaseType_t * pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
2078 {
2079 int32_t lIndex;
2080 TaskHandle_t xInternalTaskHandle = NULL;
2081
2082 lIndex = ( int32_t ) xTaskToNotify;
2083
2084 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2085 {
2086 xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2087
2088 if( xInternalTaskHandle != NULL )
2089 {
2090 vTaskGenericNotifyGiveFromISR( xInternalTaskHandle, uxIndexToNotify, pxHigherPriorityTaskWoken );
2091 }
2092 }
2093 }
2094 #endif /*#if ( configUSE_TASK_NOTIFICATIONS == 1 )*/
2095/*-----------------------------------------------------------*/
2096
2097/*-----------------------------------------------------------*/
2098/* MPU wrappers for queue APIs. */
2099/*-----------------------------------------------------------*/
2100
2101 BaseType_t MPU_xQueueGenericSendImpl( QueueHandle_t xQueue,
2102 const void * const pvItemToQueue,
2103 TickType_t xTicksToWait,
2104 BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
2105
2106 BaseType_t MPU_xQueueGenericSendImpl( QueueHandle_t xQueue,
2107 const void * const pvItemToQueue,
2108 TickType_t xTicksToWait,
2109 BaseType_t xCopyPosition ) /* PRIVILEGED_FUNCTION */
2110 {
2111 int32_t lIndex;
2112 QueueHandle_t xInternalQueueHandle = NULL;
2113 BaseType_t xReturn = pdFAIL;
2114 BaseType_t xIsItemToQueueReadable = pdFALSE;
2115 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2116 UBaseType_t uxQueueItemSize, uxQueueLength;
2117
2118 lIndex = ( int32_t ) xQueue;
2119
2120 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2121 {
2122 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2123
2124 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2125 {
2126 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2127
2128 if( xInternalQueueHandle != NULL )
2129 {
2130 uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
2131 uxQueueLength = uxQueueGetQueueLength( xInternalQueueHandle );
2132
2133 if( ( !( ( pvItemToQueue == NULL ) && ( uxQueueItemSize != ( UBaseType_t ) 0U ) ) ) &&
2134 ( !( ( xCopyPosition == queueOVERWRITE ) && ( uxQueueLength != ( UBaseType_t ) 1U ) ) )
2135 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
2136 && ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) )
2137 #endif
2138 )
2139 {
2140 if( pvItemToQueue != NULL )
2141 {
2142 xIsItemToQueueReadable = xPortIsAuthorizedToAccessBuffer( pvItemToQueue,
2143 uxQueueGetQueueItemSize( xInternalQueueHandle ),
2144 tskMPU_READ_PERMISSION );
2145 }
2146
2147 if( ( pvItemToQueue == NULL ) || ( xIsItemToQueueReadable == pdTRUE ) )
2148 {
2149 xReturn = xQueueGenericSend( xInternalQueueHandle, pvItemToQueue, xTicksToWait, xCopyPosition );
2150 }
2151 }
2152 }
2153 }
2154 }
2155
2156 return xReturn;
2157 }
2158/*-----------------------------------------------------------*/
2159
2160 UBaseType_t MPU_uxQueueMessagesWaitingImpl( const QueueHandle_t pxQueue ) PRIVILEGED_FUNCTION;
2161
2162 UBaseType_t MPU_uxQueueMessagesWaitingImpl( const QueueHandle_t pxQueue ) /* PRIVILEGED_FUNCTION */
2163 {
2164 int32_t lIndex;
2165 QueueHandle_t xInternalQueueHandle = NULL;
2166 UBaseType_t uxReturn = 0;
2167 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2168
2169 lIndex = ( int32_t ) pxQueue;
2170
2171 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2172 {
2173 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2174
2175 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2176 {
2177 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2178
2179 if( xInternalQueueHandle != NULL )
2180 {
2181 uxReturn = uxQueueMessagesWaiting( xInternalQueueHandle );
2182 }
2183 }
2184 }
2185
2186 return uxReturn;
2187 }
2188/*-----------------------------------------------------------*/
2189
2190 UBaseType_t MPU_uxQueueSpacesAvailableImpl( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
2191
2192 UBaseType_t MPU_uxQueueSpacesAvailableImpl( const QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
2193 {
2194 int32_t lIndex;
2195 QueueHandle_t xInternalQueueHandle = NULL;
2196 UBaseType_t uxReturn = 0;
2197 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2198
2199 lIndex = ( int32_t ) xQueue;
2200
2201 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2202 {
2203 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2204
2205 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2206 {
2207 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2208
2209 if( xInternalQueueHandle != NULL )
2210 {
2211 uxReturn = uxQueueSpacesAvailable( xInternalQueueHandle );
2212 }
2213 }
2214 }
2215
2216 return uxReturn;
2217 }
2218/*-----------------------------------------------------------*/
2219
2220 BaseType_t MPU_xQueueReceiveImpl( QueueHandle_t pxQueue,
2221 void * const pvBuffer,
2222 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
2223
2224 BaseType_t MPU_xQueueReceiveImpl( QueueHandle_t pxQueue,
2225 void * const pvBuffer,
2226 TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
2227 {
2228 int32_t lIndex;
2229 QueueHandle_t xInternalQueueHandle = NULL;
2230 BaseType_t xReturn = pdFAIL;
2231 BaseType_t xIsReceiveBufferWritable = pdFALSE;
2232 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2233 UBaseType_t uxQueueItemSize;
2234
2235 lIndex = ( int32_t ) pxQueue;
2236
2237 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2238 {
2239 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2240
2241 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2242 {
2243 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2244
2245 if( xInternalQueueHandle != NULL )
2246 {
2247 uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
2248
2249 if( ( !( ( ( pvBuffer ) == NULL ) && ( uxQueueItemSize != ( UBaseType_t ) 0U ) ) )
2250 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
2251 && ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) )
2252 #endif
2253 )
2254 {
2255 xIsReceiveBufferWritable = xPortIsAuthorizedToAccessBuffer( pvBuffer,
2256 uxQueueGetQueueItemSize( xInternalQueueHandle ),
2257 tskMPU_WRITE_PERMISSION );
2258
2259 if( xIsReceiveBufferWritable == pdTRUE )
2260 {
2261 xReturn = xQueueReceive( xInternalQueueHandle, pvBuffer, xTicksToWait );
2262 }
2263 }
2264 }
2265 }
2266 }
2267
2268 return xReturn;
2269 }
2270/*-----------------------------------------------------------*/
2271
2272 BaseType_t MPU_xQueuePeekImpl( QueueHandle_t xQueue,
2273 void * const pvBuffer,
2274 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
2275
2276 BaseType_t MPU_xQueuePeekImpl( QueueHandle_t xQueue,
2277 void * const pvBuffer,
2278 TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
2279 {
2280 int32_t lIndex;
2281 QueueHandle_t xInternalQueueHandle = NULL;
2282 BaseType_t xReturn = pdFAIL;
2283 BaseType_t xIsReceiveBufferWritable = pdFALSE;
2284 UBaseType_t uxQueueItemSize;
2285 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2286
2287 lIndex = ( int32_t ) xQueue;
2288
2289 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2290 {
2291 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2292
2293 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2294 {
2295 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2296
2297 if( xInternalQueueHandle != NULL )
2298 {
2299 uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
2300
2301 if( ( !( ( ( pvBuffer ) == NULL ) && ( uxQueueItemSize != ( UBaseType_t ) 0U ) ) )
2302 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
2303 && ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) )
2304 #endif
2305 )
2306 {
2307 xIsReceiveBufferWritable = xPortIsAuthorizedToAccessBuffer( pvBuffer,
2308 uxQueueGetQueueItemSize( xInternalQueueHandle ),
2309 tskMPU_WRITE_PERMISSION );
2310
2311 if( xIsReceiveBufferWritable == pdTRUE )
2312 {
2313 xReturn = xQueuePeek( xInternalQueueHandle, pvBuffer, xTicksToWait );
2314 }
2315 }
2316 }
2317 }
2318 }
2319
2320 return xReturn;
2321 }
2322/*-----------------------------------------------------------*/
2323
2324 BaseType_t MPU_xQueueSemaphoreTakeImpl( QueueHandle_t xQueue,
2325 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
2326
2327 BaseType_t MPU_xQueueSemaphoreTakeImpl( QueueHandle_t xQueue,
2328 TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
2329 {
2330 int32_t lIndex;
2331 QueueHandle_t xInternalQueueHandle = NULL;
2332 BaseType_t xReturn = pdFAIL;
2333 UBaseType_t uxQueueItemSize;
2334 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2335
2336 lIndex = ( int32_t ) xQueue;
2337
2338 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2339 {
2340 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2341
2342 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2343 {
2344 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2345
2346 if( xInternalQueueHandle != NULL )
2347 {
2348 uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
2349
2350 if( ( uxQueueItemSize == 0 )
2351 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
2352 && ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) )
2353 #endif
2354 )
2355 {
2356 xReturn = xQueueSemaphoreTake( xInternalQueueHandle, xTicksToWait );
2357 }
2358 }
2359 }
2360 }
2361
2362 return xReturn;
2363 }
2364/*-----------------------------------------------------------*/
2365
2366 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
2367
2368 TaskHandle_t MPU_xQueueGetMutexHolderImpl( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;
2369
2370 TaskHandle_t MPU_xQueueGetMutexHolderImpl( QueueHandle_t xSemaphore ) /* PRIVILEGED_FUNCTION */
2371 {
2372 TaskHandle_t xMutexHolderTaskInternalHandle = NULL;
2373 TaskHandle_t xMutexHolderTaskExternalHandle = NULL;
2374 int32_t lIndex, lMutexHolderTaskIndex;
2375 QueueHandle_t xInternalQueueHandle = NULL;
2376 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2377
2378
2379 lIndex = ( int32_t ) xSemaphore;
2380
2381 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2382 {
2383 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2384
2385 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2386 {
2387 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2388
2389 if( xInternalQueueHandle != NULL )
2390 {
2391 xMutexHolderTaskInternalHandle = xQueueGetMutexHolder( xInternalQueueHandle );
2392
2393 if( xMutexHolderTaskInternalHandle != NULL )
2394 {
2395 lMutexHolderTaskIndex = MPU_GetIndexForTaskHandle( xMutexHolderTaskInternalHandle );
2396
2397 if( lMutexHolderTaskIndex != -1 )
2398 {
2399 xMutexHolderTaskExternalHandle = ( TaskHandle_t ) ( CONVERT_TO_EXTERNAL_INDEX( lMutexHolderTaskIndex ) );
2400 }
2401 }
2402 }
2403 }
2404 }
2405
2406 return xMutexHolderTaskExternalHandle;
2407 }
2408
2409 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
2410/*-----------------------------------------------------------*/
2411
2412 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
2413
2414 BaseType_t MPU_xQueueTakeMutexRecursiveImpl( QueueHandle_t xMutex,
2415 TickType_t xBlockTime ) PRIVILEGED_FUNCTION;
2416
2417 BaseType_t MPU_xQueueTakeMutexRecursiveImpl( QueueHandle_t xMutex,
2418 TickType_t xBlockTime ) /* PRIVILEGED_FUNCTION */
2419 {
2420 BaseType_t xReturn = pdFAIL;
2421 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2422 int32_t lIndex;
2423 QueueHandle_t xInternalQueueHandle = NULL;
2424 UBaseType_t uxQueueItemSize;
2425
2426 lIndex = ( int32_t ) xMutex;
2427
2428 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2429 {
2430 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2431
2432 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2433 {
2434 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2435
2436 if( xInternalQueueHandle != NULL )
2437 {
2438 uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
2439
2440 if( uxQueueItemSize == 0 )
2441 {
2442 xReturn = xQueueTakeMutexRecursive( xInternalQueueHandle, xBlockTime );
2443 }
2444 }
2445 }
2446 }
2447
2448 return xReturn;
2449 }
2450
2451 #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
2452/*-----------------------------------------------------------*/
2453
2454 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
2455
2456 BaseType_t MPU_xQueueGiveMutexRecursiveImpl( QueueHandle_t xMutex ) PRIVILEGED_FUNCTION;
2457
2458 BaseType_t MPU_xQueueGiveMutexRecursiveImpl( QueueHandle_t xMutex ) /* PRIVILEGED_FUNCTION */
2459 {
2460 BaseType_t xReturn = pdFAIL;
2461 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2462 int32_t lIndex;
2463 QueueHandle_t xInternalQueueHandle = NULL;
2464
2465 lIndex = ( int32_t ) xMutex;
2466
2467 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2468 {
2469 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2470
2471 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2472 {
2473 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2474
2475 if( xInternalQueueHandle != NULL )
2476 {
2477 xReturn = xQueueGiveMutexRecursive( xInternalQueueHandle );
2478 }
2479 }
2480 }
2481
2482 return xReturn;
2483 }
2484
2485 #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
2486/*-----------------------------------------------------------*/
2487
2488 #if ( configUSE_QUEUE_SETS == 1 )
2489
2490 QueueSetMemberHandle_t MPU_xQueueSelectFromSetImpl( QueueSetHandle_t xQueueSet,
2491 TickType_t xBlockTimeTicks ) PRIVILEGED_FUNCTION;
2492
2493 QueueSetMemberHandle_t MPU_xQueueSelectFromSetImpl( QueueSetHandle_t xQueueSet,
2494 TickType_t xBlockTimeTicks ) /* PRIVILEGED_FUNCTION */
2495 {
2496 QueueSetHandle_t xInternalQueueSetHandle = NULL;
2497 QueueSetMemberHandle_t xSelectedMemberInternal = NULL;
2498 QueueSetMemberHandle_t xSelectedMemberExternal = NULL;
2499 int32_t lIndexQueueSet, lIndexSelectedMember;
2500 BaseType_t xCallingTaskIsAuthorizedToAccessQueueSet = pdFALSE;
2501
2502 lIndexQueueSet = ( int32_t ) xQueueSet;
2503
2504 if( IS_EXTERNAL_INDEX_VALID( lIndexQueueSet ) != pdFALSE )
2505 {
2506 xCallingTaskIsAuthorizedToAccessQueueSet = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
2507
2508 if( xCallingTaskIsAuthorizedToAccessQueueSet == pdTRUE )
2509 {
2510 xInternalQueueSetHandle = MPU_GetQueueSetHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
2511
2512 if( xInternalQueueSetHandle != NULL )
2513 {
2514 xSelectedMemberInternal = xQueueSelectFromSet( xInternalQueueSetHandle, xBlockTimeTicks );
2515
2516 if( xSelectedMemberInternal != NULL )
2517 {
2518 lIndexSelectedMember = MPU_GetIndexForQueueSetMemberHandle( xSelectedMemberInternal );
2519
2520 if( lIndexSelectedMember != -1 )
2521 {
2522 xSelectedMemberExternal = ( QueueSetMemberHandle_t ) ( CONVERT_TO_EXTERNAL_INDEX( lIndexSelectedMember ) );
2523 }
2524 }
2525 }
2526 }
2527 }
2528
2529 return xSelectedMemberExternal;
2530 }
2531
2532 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
2533/*-----------------------------------------------------------*/
2534
2535 #if ( configUSE_QUEUE_SETS == 1 )
2536
2537 BaseType_t MPU_xQueueAddToSetImpl( QueueSetMemberHandle_t xQueueOrSemaphore,
2538 QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
2539
2540 BaseType_t MPU_xQueueAddToSetImpl( QueueSetMemberHandle_t xQueueOrSemaphore,
2541 QueueSetHandle_t xQueueSet ) /* PRIVILEGED_FUNCTION */
2542 {
2543 BaseType_t xReturn = pdFAIL;
2544 QueueSetMemberHandle_t xInternalQueueSetMemberHandle = NULL;
2545 QueueSetHandle_t xInternalQueueSetHandle = NULL;
2546 int32_t lIndexQueueSet, lIndexQueueSetMember;
2547 BaseType_t xCallingTaskIsAuthorizedToAccessQueueSet = pdFALSE;
2548 BaseType_t xCallingTaskIsAuthorizedToAccessQueueSetMember = pdFALSE;
2549
2550 lIndexQueueSet = ( int32_t ) xQueueSet;
2551 lIndexQueueSetMember = ( int32_t ) xQueueOrSemaphore;
2552
2553 if( ( IS_EXTERNAL_INDEX_VALID( lIndexQueueSet ) != pdFALSE ) &&
2554 ( IS_EXTERNAL_INDEX_VALID( lIndexQueueSetMember ) != pdFALSE ) )
2555 {
2556 xCallingTaskIsAuthorizedToAccessQueueSet = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
2557 xCallingTaskIsAuthorizedToAccessQueueSetMember = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSetMember ) );
2558
2559 if( ( xCallingTaskIsAuthorizedToAccessQueueSet == pdTRUE ) && ( xCallingTaskIsAuthorizedToAccessQueueSetMember == pdTRUE ) )
2560 {
2561 xInternalQueueSetHandle = MPU_GetQueueSetHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
2562 xInternalQueueSetMemberHandle = MPU_GetQueueSetMemberHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSetMember ) );
2563
2564 if( ( xInternalQueueSetHandle != NULL ) && ( xInternalQueueSetMemberHandle != NULL ) )
2565 {
2566 xReturn = xQueueAddToSet( xInternalQueueSetMemberHandle, xInternalQueueSetHandle );
2567 }
2568 }
2569 }
2570
2571 return xReturn;
2572 }
2573
2574 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
2575/*-----------------------------------------------------------*/
2576
2577 #if configQUEUE_REGISTRY_SIZE > 0
2578
2579 void MPU_vQueueAddToRegistryImpl( QueueHandle_t xQueue,
2580 const char * pcName ) PRIVILEGED_FUNCTION;
2581
2582 void MPU_vQueueAddToRegistryImpl( QueueHandle_t xQueue,
2583 const char * pcName ) /* PRIVILEGED_FUNCTION */
2584 {
2585 int32_t lIndex;
2586 QueueHandle_t xInternalQueueHandle = NULL;
2587 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2588
2589 lIndex = ( int32_t ) xQueue;
2590
2591 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2592 {
2593 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2594
2595 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2596 {
2597 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2598
2599 if( xInternalQueueHandle != NULL )
2600 {
2601 vQueueAddToRegistry( xInternalQueueHandle, pcName );
2602 }
2603 }
2604 }
2605 }
2606
2607 #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
2608/*-----------------------------------------------------------*/
2609
2610 #if configQUEUE_REGISTRY_SIZE > 0
2611
2612 void MPU_vQueueUnregisterQueueImpl( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
2613
2614 void MPU_vQueueUnregisterQueueImpl( QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
2615 {
2616 int32_t lIndex;
2617 QueueHandle_t xInternalQueueHandle = NULL;
2618 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2619
2620 lIndex = ( int32_t ) xQueue;
2621
2622 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2623 {
2624 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2625
2626 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2627 {
2628 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2629
2630 if( xInternalQueueHandle != NULL )
2631 {
2632 vQueueUnregisterQueue( xInternalQueueHandle );
2633 }
2634 }
2635 }
2636 }
2637
2638 #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
2639/*-----------------------------------------------------------*/
2640
2641 #if configQUEUE_REGISTRY_SIZE > 0
2642
2643 const char * MPU_pcQueueGetNameImpl( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
2644
2645 const char * MPU_pcQueueGetNameImpl( QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
2646 {
2647 const char * pcReturn = NULL;
2648 QueueHandle_t xInternalQueueHandle = NULL;
2649 int32_t lIndex;
2650 BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
2651
2652 lIndex = ( int32_t ) xQueue;
2653
2654 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2655 {
2656 xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2657
2658 if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
2659 {
2660 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2661
2662 if( xInternalQueueHandle != NULL )
2663 {
2664 pcReturn = pcQueueGetName( xInternalQueueHandle );
2665 }
2666 }
2667 }
2668
2669 return pcReturn;
2670 }
2671
2672 #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
2673/*-----------------------------------------------------------*/
2674
2675/* Privileged only wrappers for Queue APIs. These are needed so that
2676 * the application can use opaque handles maintained in mpu_wrappers.c
2677 * with all the APIs. */
2678/*-----------------------------------------------------------*/
2679
2680 void MPU_vQueueDelete( QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
2681 {
2682 QueueHandle_t xInternalQueueHandle = NULL;
2683 int32_t lIndex;
2684
2685 lIndex = ( int32_t ) xQueue;
2686
2687 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2688 {
2689 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2690
2691 if( xInternalQueueHandle != NULL )
2692 {
2693 vQueueDelete( xInternalQueueHandle );
2694 MPU_SetIndexFreeInKernelObjectPool( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2695 }
2696 }
2697 }
2698/*-----------------------------------------------------------*/
2699
2700 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
2701
2702 QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* PRIVILEGED_FUNCTION */
2703 {
2704 QueueHandle_t xInternalQueueHandle = NULL;
2705 QueueHandle_t xExternalQueueHandle = NULL;
2706 int32_t lIndex;
2707
2708 lIndex = MPU_GetFreeIndexInKernelObjectPool();
2709
2710 if( lIndex != -1 )
2711 {
2712 xInternalQueueHandle = xQueueCreateMutex( ucQueueType );
2713
2714 if( xInternalQueueHandle != NULL )
2715 {
2716 MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
2717 xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
2718 }
2719 else
2720 {
2721 MPU_SetIndexFreeInKernelObjectPool( lIndex );
2722 }
2723 }
2724
2725 return xExternalQueueHandle;
2726 }
2727
2728 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
2729/*-----------------------------------------------------------*/
2730
2731 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
2732
2733 QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
2734 StaticQueue_t * pxStaticQueue ) /* PRIVILEGED_FUNCTION */
2735 {
2736 QueueHandle_t xInternalQueueHandle = NULL;
2737 QueueHandle_t xExternalQueueHandle = NULL;
2738 int32_t lIndex;
2739
2740 lIndex = MPU_GetFreeIndexInKernelObjectPool();
2741
2742 if( lIndex != -1 )
2743 {
2744 xInternalQueueHandle = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
2745
2746 if( xInternalQueueHandle != NULL )
2747 {
2748 MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
2749 xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
2750 }
2751 else
2752 {
2753 MPU_SetIndexFreeInKernelObjectPool( lIndex );
2754 }
2755 }
2756
2757 return xExternalQueueHandle;
2758 }
2759
2760 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
2761/*-----------------------------------------------------------*/
2762
2763 #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
2764
2765 QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue,
2766 UBaseType_t uxInitialCount ) /* PRIVILEGED_FUNCTION */
2767 {
2768 QueueHandle_t xInternalQueueHandle = NULL;
2769 QueueHandle_t xExternalQueueHandle = NULL;
2770 int32_t lIndex;
2771
2772 lIndex = MPU_GetFreeIndexInKernelObjectPool();
2773
2774 if( lIndex != -1 )
2775 {
2776 xInternalQueueHandle = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
2777
2778 if( xInternalQueueHandle != NULL )
2779 {
2780 MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
2781 xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
2782 }
2783 else
2784 {
2785 MPU_SetIndexFreeInKernelObjectPool( lIndex );
2786 }
2787 }
2788
2789 return xExternalQueueHandle;
2790 }
2791
2792 #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
2793/*-----------------------------------------------------------*/
2794
2795 #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
2796
2797 QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
2798 const UBaseType_t uxInitialCount,
2799 StaticQueue_t * pxStaticQueue ) /* PRIVILEGED_FUNCTION */
2800 {
2801 QueueHandle_t xInternalQueueHandle = NULL;
2802 QueueHandle_t xExternalQueueHandle = NULL;
2803 int32_t lIndex;
2804
2805 lIndex = MPU_GetFreeIndexInKernelObjectPool();
2806
2807 if( lIndex != -1 )
2808 {
2809 xInternalQueueHandle = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
2810
2811 if( xInternalQueueHandle != NULL )
2812 {
2813 MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
2814 xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
2815 }
2816 else
2817 {
2818 MPU_SetIndexFreeInKernelObjectPool( lIndex );
2819 }
2820 }
2821
2822 return xExternalQueueHandle;
2823 }
2824
2825 #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
2826/*-----------------------------------------------------------*/
2827
2828 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
2829
2830 QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength,
2831 UBaseType_t uxItemSize,
2832 uint8_t ucQueueType ) /* PRIVILEGED_FUNCTION */
2833 {
2834 QueueHandle_t xInternalQueueHandle = NULL;
2835 QueueHandle_t xExternalQueueHandle = NULL;
2836 int32_t lIndex;
2837
2838 lIndex = MPU_GetFreeIndexInKernelObjectPool();
2839
2840 if( lIndex != -1 )
2841 {
2842 xInternalQueueHandle = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
2843
2844 if( xInternalQueueHandle != NULL )
2845 {
2846 MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
2847 xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
2848 }
2849 else
2850 {
2851 MPU_SetIndexFreeInKernelObjectPool( lIndex );
2852 }
2853 }
2854
2855 return xExternalQueueHandle;
2856 }
2857
2858 #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
2859/*-----------------------------------------------------------*/
2860
2861 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
2862
2863 QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
2864 const UBaseType_t uxItemSize,
2865 uint8_t * pucQueueStorage,
2866 StaticQueue_t * pxStaticQueue,
2867 const uint8_t ucQueueType ) /* PRIVILEGED_FUNCTION */
2868 {
2869 QueueHandle_t xInternalQueueHandle = NULL;
2870 QueueHandle_t xExternalQueueHandle = NULL;
2871 int32_t lIndex;
2872
2873 lIndex = MPU_GetFreeIndexInKernelObjectPool();
2874
2875 if( lIndex != -1 )
2876 {
2877 xInternalQueueHandle = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
2878
2879 if( xInternalQueueHandle != NULL )
2880 {
2881 MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
2882 xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
2883 }
2884 else
2885 {
2886 MPU_SetIndexFreeInKernelObjectPool( lIndex );
2887 }
2888 }
2889
2890 return xExternalQueueHandle;
2891 }
2892
2893 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
2894/*-----------------------------------------------------------*/
2895
2896 BaseType_t MPU_xQueueGenericReset( QueueHandle_t xQueue,
2897 BaseType_t xNewQueue ) /* PRIVILEGED_FUNCTION */
2898 {
2899 int32_t lIndex;
2900 QueueHandle_t xInternalQueueHandle = NULL;
2901 BaseType_t xReturn = pdFAIL;
2902
2903 lIndex = ( uint32_t ) xQueue;
2904
2905 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2906 {
2907 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2908
2909 if( xInternalQueueHandle != NULL )
2910 {
2911 xReturn = xQueueGenericReset( xInternalQueueHandle, xNewQueue );
2912 }
2913 }
2914
2915 return xReturn;
2916 }
2917/*-----------------------------------------------------------*/
2918
2919 #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
2920
2921 QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* PRIVILEGED_FUNCTION */
2922 {
2923 QueueSetHandle_t xInternalQueueSetHandle = NULL;
2924 QueueSetHandle_t xExternalQueueSetHandle = NULL;
2925 int32_t lIndex;
2926
2927 lIndex = MPU_GetFreeIndexInKernelObjectPool();
2928
2929 if( lIndex != -1 )
2930 {
2931 xInternalQueueSetHandle = xQueueCreateSet( uxEventQueueLength );
2932
2933 if( xInternalQueueSetHandle != NULL )
2934 {
2935 MPU_StoreQueueSetHandleAtIndex( lIndex, xInternalQueueSetHandle );
2936 xExternalQueueSetHandle = ( QueueSetHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
2937 }
2938 else
2939 {
2940 MPU_SetIndexFreeInKernelObjectPool( lIndex );
2941 }
2942 }
2943
2944 return xExternalQueueSetHandle;
2945 }
2946
2947 #endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
2948/*-----------------------------------------------------------*/
2949
2950 #if ( configUSE_QUEUE_SETS == 1 )
2951
2952 BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
2953 QueueSetHandle_t xQueueSet ) /* PRIVILEGED_FUNCTION */
2954 {
2955 BaseType_t xReturn = pdFAIL;
2956 QueueSetMemberHandle_t xInternalQueueSetMemberHandle = NULL;
2957 QueueSetHandle_t xInternalQueueSetHandle = NULL;
2958 int32_t lIndexQueueSet, lIndexQueueSetMember;
2959
2960 lIndexQueueSet = ( int32_t ) xQueueSet;
2961 lIndexQueueSetMember = ( int32_t ) xQueueOrSemaphore;
2962
2963 if( ( IS_EXTERNAL_INDEX_VALID( lIndexQueueSet ) != pdFALSE ) &&
2964 ( IS_EXTERNAL_INDEX_VALID( lIndexQueueSetMember ) != pdFALSE ) )
2965 {
2966 xInternalQueueSetHandle = MPU_GetQueueSetHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
2967 xInternalQueueSetMemberHandle = MPU_GetQueueSetMemberHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSetMember ) );
2968
2969 if( ( xInternalQueueSetHandle != NULL ) && ( xInternalQueueSetMemberHandle != NULL ) )
2970 {
2971 xReturn = xQueueRemoveFromSet( xInternalQueueSetMemberHandle, xInternalQueueSetHandle );
2972 }
2973 }
2974
2975 return xReturn;
2976 }
2977
2978 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
2979/*-----------------------------------------------------------*/
2980
2981 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
2982
2983 BaseType_t MPU_xQueueGenericGetStaticBuffers( QueueHandle_t xQueue,
2984 uint8_t ** ppucQueueStorage,
2985 StaticQueue_t ** ppxStaticQueue ) /* PRIVILEGED_FUNCTION */
2986 {
2987 int32_t lIndex;
2988 QueueHandle_t xInternalQueueHandle = NULL;
2989 BaseType_t xReturn = pdFALSE;
2990
2991 lIndex = ( int32_t ) xQueue;
2992
2993 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
2994 {
2995 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
2996
2997 if( xInternalQueueHandle != NULL )
2998 {
2999 xReturn = xQueueGenericGetStaticBuffers( xInternalQueueHandle, ppucQueueStorage, ppxStaticQueue );
3000 }
3001 }
3002
3003 return xReturn;
3004 }
3005
3006 #endif /*if ( configSUPPORT_STATIC_ALLOCATION == 1 )*/
3007/*-----------------------------------------------------------*/
3008
3009 BaseType_t MPU_xQueueGenericSendFromISR( QueueHandle_t xQueue,
3010 const void * const pvItemToQueue,
3011 BaseType_t * const pxHigherPriorityTaskWoken,
3012 const BaseType_t xCopyPosition ) /* PRIVILEGED_FUNCTION */
3013 {
3014 BaseType_t xReturn = pdFAIL;
3015 int32_t lIndex;
3016 QueueHandle_t xInternalQueueHandle = NULL;
3017
3018 lIndex = ( int32_t ) xQueue;
3019
3020 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3021 {
3022 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3023
3024 if( xInternalQueueHandle != NULL )
3025 {
3026 xReturn = xQueueGenericSendFromISR( xInternalQueueHandle, pvItemToQueue, pxHigherPriorityTaskWoken, xCopyPosition );
3027 }
3028 }
3029
3030 return xReturn;
3031 }
3032
3033/*-----------------------------------------------------------*/
3034
3035 BaseType_t MPU_xQueueGiveFromISR( QueueHandle_t xQueue,
3036 BaseType_t * const pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
3037 {
3038 BaseType_t xReturn = pdFAIL;
3039 int32_t lIndex;
3040 QueueHandle_t xInternalQueueHandle = NULL;
3041
3042 lIndex = ( int32_t ) xQueue;
3043
3044 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3045 {
3046 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3047
3048 if( xInternalQueueHandle != NULL )
3049 {
3050 xReturn = xQueueGiveFromISR( xInternalQueueHandle, pxHigherPriorityTaskWoken );
3051 }
3052 }
3053
3054 return xReturn;
3055 }
3056
3057/*-----------------------------------------------------------*/
3058
3059 BaseType_t MPU_xQueuePeekFromISR( QueueHandle_t xQueue,
3060 void * const pvBuffer ) /* PRIVILEGED_FUNCTION */
3061 {
3062 BaseType_t xReturn = pdFAIL;
3063 int32_t lIndex;
3064 QueueHandle_t xInternalQueueHandle = NULL;
3065
3066 lIndex = ( int32_t ) xQueue;
3067
3068 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3069 {
3070 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3071
3072 if( xInternalQueueHandle != NULL )
3073 {
3074 xReturn = xQueuePeekFromISR( xInternalQueueHandle, pvBuffer );
3075 }
3076 }
3077
3078 return xReturn;
3079 }
3080
3081/*-----------------------------------------------------------*/
3082
3083 BaseType_t MPU_xQueueReceiveFromISR( QueueHandle_t xQueue,
3084 void * const pvBuffer,
3085 BaseType_t * const pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
3086 {
3087 BaseType_t xReturn = pdFAIL;
3088 int32_t lIndex;
3089 QueueHandle_t xInternalQueueHandle = NULL;
3090
3091 lIndex = ( int32_t ) xQueue;
3092
3093 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3094 {
3095 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3096
3097 if( xInternalQueueHandle != NULL )
3098 {
3099 xReturn = xQueueReceiveFromISR( xInternalQueueHandle, pvBuffer, pxHigherPriorityTaskWoken );
3100 }
3101 }
3102
3103 return xReturn;
3104 }
3105
3106/*-----------------------------------------------------------*/
3107
3108 BaseType_t MPU_xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
3109 {
3110 BaseType_t xReturn = pdFAIL;
3111 int32_t lIndex;
3112 QueueHandle_t xInternalQueueHandle = NULL;
3113
3114 lIndex = ( int32_t ) xQueue;
3115
3116 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3117 {
3118 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3119
3120 if( xInternalQueueHandle != NULL )
3121 {
3122 xReturn = xQueueIsQueueEmptyFromISR( xInternalQueueHandle );
3123 }
3124 }
3125
3126 return xReturn;
3127 }
3128/*-----------------------------------------------------------*/
3129
3130 BaseType_t MPU_xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
3131 {
3132 BaseType_t xReturn = pdFAIL;
3133 int32_t lIndex;
3134 QueueHandle_t xInternalQueueHandle = NULL;
3135
3136 lIndex = ( int32_t ) xQueue;
3137
3138 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3139 {
3140 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3141
3142 if( xInternalQueueHandle != NULL )
3143 {
3144 xReturn = xQueueIsQueueFullFromISR( xInternalQueueHandle );
3145 }
3146 }
3147
3148 return xReturn;
3149 }
3150
3151/*-----------------------------------------------------------*/
3152
3153 UBaseType_t MPU_uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
3154 {
3155 UBaseType_t uxReturn = 0;
3156 int32_t lIndex;
3157 QueueHandle_t xInternalQueueHandle = NULL;
3158
3159 lIndex = ( int32_t ) xQueue;
3160
3161 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3162 {
3163 xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3164
3165 if( xInternalQueueHandle != NULL )
3166 {
3167 uxReturn = uxQueueMessagesWaitingFromISR( xInternalQueueHandle );
3168 }
3169 }
3170
3171 return uxReturn;
3172 }
3173
3174/*-----------------------------------------------------------*/
3175
3176 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
3177
3178 TaskHandle_t MPU_xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore ) /* PRIVILEGED_FUNCTION */
3179 {
3180 TaskHandle_t xMutexHolderTaskInternalHandle = NULL;
3181 TaskHandle_t xMutexHolderTaskExternalHandle = NULL;
3182 int32_t lIndex, lMutexHolderTaskIndex;
3183 QueueHandle_t xInternalSemaphoreHandle = NULL;
3184
3185 lIndex = ( int32_t ) xSemaphore;
3186
3187 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3188 {
3189 xInternalSemaphoreHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3190
3191 if( xInternalSemaphoreHandle != NULL )
3192 {
3193 xMutexHolderTaskInternalHandle = xQueueGetMutexHolder( xInternalSemaphoreHandle );
3194
3195 if( xMutexHolderTaskInternalHandle != NULL )
3196 {
3197 lMutexHolderTaskIndex = MPU_GetIndexForTaskHandle( xMutexHolderTaskInternalHandle );
3198
3199 if( lMutexHolderTaskIndex != -1 )
3200 {
3201 xMutexHolderTaskExternalHandle = ( TaskHandle_t ) ( CONVERT_TO_EXTERNAL_INDEX( lMutexHolderTaskIndex ) );
3202 }
3203 }
3204 }
3205 }
3206
3207 return xMutexHolderTaskExternalHandle;
3208 }
3209
3210 #endif /* #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
3211/*-----------------------------------------------------------*/
3212
3213 #if ( configUSE_QUEUE_SETS == 1 )
3214
3215 QueueSetMemberHandle_t MPU_xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet ) /* PRIVILEGED_FUNCTION */
3216 {
3217 QueueSetHandle_t xInternalQueueSetHandle = NULL;
3218 QueueSetMemberHandle_t xSelectedMemberInternal = NULL;
3219 QueueSetMemberHandle_t xSelectedMemberExternal = NULL;
3220 int32_t lIndexQueueSet, lIndexSelectedMember;
3221
3222 lIndexQueueSet = ( int32_t ) xQueueSet;
3223
3224 if( IS_EXTERNAL_INDEX_VALID( lIndexQueueSet ) != pdFALSE )
3225 {
3226 xInternalQueueSetHandle = MPU_GetQueueSetHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
3227
3228 if( xInternalQueueSetHandle != NULL )
3229 {
3230 xSelectedMemberInternal = xQueueSelectFromSetFromISR( xInternalQueueSetHandle );
3231
3232 if( xSelectedMemberInternal != NULL )
3233 {
3234 lIndexSelectedMember = MPU_GetIndexForQueueSetMemberHandle( xSelectedMemberInternal );
3235
3236 if( lIndexSelectedMember != -1 )
3237 {
3238 xSelectedMemberExternal = ( QueueSetMemberHandle_t ) ( CONVERT_TO_EXTERNAL_INDEX( lIndexSelectedMember ) );
3239 }
3240 }
3241 }
3242 }
3243
3244 return xSelectedMemberExternal;
3245 }
3246
3247 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
3248/*-----------------------------------------------------------*/
3249
3250/*-----------------------------------------------------------*/
3251/* MPU wrappers for timers APIs. */
3252/*-----------------------------------------------------------*/
3253
3254 #if ( configUSE_TIMERS == 1 )
3255
3256 void * MPU_pvTimerGetTimerIDImpl( const TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
3257
3258 void * MPU_pvTimerGetTimerIDImpl( const TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
3259 {
3260 void * pvReturn = NULL;
3261 TimerHandle_t xInternalTimerHandle = NULL;
3262 int32_t lIndex;
3263 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3264
3265 lIndex = ( int32_t ) xTimer;
3266
3267 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3268 {
3269 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3270
3271 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3272 {
3273 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3274
3275 if( xInternalTimerHandle != NULL )
3276 {
3277 pvReturn = pvTimerGetTimerID( xInternalTimerHandle );
3278 }
3279 }
3280 }
3281
3282 return pvReturn;
3283 }
3284
3285 #endif /* if ( configUSE_TIMERS == 1 ) */
3286/*-----------------------------------------------------------*/
3287
3288 #if ( configUSE_TIMERS == 1 )
3289
3290 void MPU_vTimerSetTimerIDImpl( TimerHandle_t xTimer,
3291 void * pvNewID ) PRIVILEGED_FUNCTION;
3292
3293 void MPU_vTimerSetTimerIDImpl( TimerHandle_t xTimer,
3294 void * pvNewID ) /* PRIVILEGED_FUNCTION */
3295 {
3296 TimerHandle_t xInternalTimerHandle = NULL;
3297 int32_t lIndex;
3298 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3299
3300 lIndex = ( int32_t ) xTimer;
3301
3302 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3303 {
3304 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3305
3306 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3307 {
3308 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3309
3310 if( xInternalTimerHandle != NULL )
3311 {
3312 vTimerSetTimerID( xInternalTimerHandle, pvNewID );
3313 }
3314 }
3315 }
3316 }
3317
3318 #endif /* if ( configUSE_TIMERS == 1 ) */
3319/*-----------------------------------------------------------*/
3320
3321 #if ( configUSE_TIMERS == 1 )
3322
3323 BaseType_t MPU_xTimerIsTimerActiveImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
3324
3325 BaseType_t MPU_xTimerIsTimerActiveImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
3326 {
3327 BaseType_t xReturn = pdFALSE;
3328 TimerHandle_t xInternalTimerHandle = NULL;
3329 int32_t lIndex;
3330 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3331
3332 lIndex = ( int32_t ) xTimer;
3333
3334 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3335 {
3336 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3337
3338 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3339 {
3340 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3341
3342 if( xInternalTimerHandle != NULL )
3343 {
3344 xReturn = xTimerIsTimerActive( xInternalTimerHandle );
3345 }
3346 }
3347 }
3348
3349 return xReturn;
3350 }
3351
3352 #endif /* if ( configUSE_TIMERS == 1 ) */
3353/*-----------------------------------------------------------*/
3354
3355 #if ( configUSE_TIMERS == 1 )
3356
3357 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandleImpl( void ) PRIVILEGED_FUNCTION;
3358
3359 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandleImpl( void ) /* PRIVILEGED_FUNCTION */
3360 {
3361 TaskHandle_t xReturn;
3362
3363 xReturn = xTimerGetTimerDaemonTaskHandle();
3364
3365 return xReturn;
3366 }
3367
3368 #endif /* if ( configUSE_TIMERS == 1 ) */
3369/*-----------------------------------------------------------*/
3370
3371 #if ( configUSE_TIMERS == 1 )
3372
3373 BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer,
3374 const BaseType_t xCommandID,
3375 const TickType_t xOptionalValue,
3376 BaseType_t * const pxHigherPriorityTaskWoken,
3377 const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
3378 {
3379 BaseType_t xReturn = pdFALSE;
3380 xTimerGenericCommandParams_t xParams;
3381
3382 xParams.xTimer = xTimer;
3383 xParams.xCommandID = xCommandID;
3384 xParams.xOptionalValue = xOptionalValue;
3385 xParams.pxHigherPriorityTaskWoken = pxHigherPriorityTaskWoken;
3386 xParams.xTicksToWait = xTicksToWait;
3387
3388 xReturn = MPU_xTimerGenericCommandEntry( &( xParams ) );
3389
3390 return xReturn;
3391 }
3392
3393 BaseType_t MPU_xTimerGenericCommandImpl( const xTimerGenericCommandParams_t * pxParams ) PRIVILEGED_FUNCTION;
3394
3395 BaseType_t MPU_xTimerGenericCommandImpl( const xTimerGenericCommandParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
3396 {
3397 BaseType_t xReturn = pdFALSE;
3398 TimerHandle_t xInternalTimerHandle = NULL;
3399 int32_t lIndex;
3400 BaseType_t xIsHigherPriorityTaskWokenWriteable = pdFALSE;
3401 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3402 BaseType_t xAreParamsReadable = pdFALSE;
3403
3404 if( pxParams != NULL )
3405 {
3406 xAreParamsReadable = xPortIsAuthorizedToAccessBuffer( pxParams,
3407 sizeof( xTimerGenericCommandParams_t ),
3408 tskMPU_READ_PERMISSION );
3409 }
3410
3411 if( xAreParamsReadable == pdTRUE )
3412 {
3413 if( pxParams->pxHigherPriorityTaskWoken != NULL )
3414 {
3415 xIsHigherPriorityTaskWokenWriteable = xPortIsAuthorizedToAccessBuffer( pxParams->pxHigherPriorityTaskWoken,
3416 sizeof( BaseType_t ),
3417 tskMPU_WRITE_PERMISSION );
3418 }
3419
3420 if( ( pxParams->pxHigherPriorityTaskWoken == NULL ) ||
3421 ( xIsHigherPriorityTaskWokenWriteable == pdTRUE ) )
3422 {
3423 lIndex = ( int32_t ) ( pxParams->xTimer );
3424
3425 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3426 {
3427 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3428
3429 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3430 {
3431 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3432
3433 if( xInternalTimerHandle != NULL )
3434 {
3435 xReturn = xTimerGenericCommand( xInternalTimerHandle,
3436 pxParams->xCommandID,
3437 pxParams->xOptionalValue,
3438 pxParams->pxHigherPriorityTaskWoken,
3439 pxParams->xTicksToWait );
3440 }
3441 }
3442 }
3443 }
3444 }
3445
3446 return xReturn;
3447 }
3448
3449 BaseType_t MPU_xTimerGenericCommandPrivImpl( const xTimerGenericCommandParams_t * pxParams ) PRIVILEGED_FUNCTION;
3450
3451 BaseType_t MPU_xTimerGenericCommandPrivImpl( const xTimerGenericCommandParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
3452 {
3453 BaseType_t xReturn = pdFALSE;
3454 TimerHandle_t xInternalTimerHandle = NULL;
3455 int32_t lIndex;
3456
3457 if( pxParams != NULL )
3458 {
3459 lIndex = ( int32_t ) ( pxParams->xTimer );
3460
3461 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3462 {
3463 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3464
3465 if( xInternalTimerHandle != NULL )
3466 {
3467 xReturn = xTimerGenericCommand( xInternalTimerHandle,
3468 pxParams->xCommandID,
3469 pxParams->xOptionalValue,
3470 pxParams->pxHigherPriorityTaskWoken,
3471 pxParams->xTicksToWait );
3472 }
3473 }
3474 }
3475
3476 return xReturn;
3477 }
3478
3479 #endif /* if ( configUSE_TIMERS == 1 ) */
3480/*-----------------------------------------------------------*/
3481
3482 #if ( configUSE_TIMERS == 1 )
3483
3484 const char * MPU_pcTimerGetNameImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
3485
3486 const char * MPU_pcTimerGetNameImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
3487 {
3488 const char * pcReturn = NULL;
3489 TimerHandle_t xInternalTimerHandle = NULL;
3490 int32_t lIndex;
3491 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3492
3493 lIndex = ( int32_t ) xTimer;
3494
3495 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3496 {
3497 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3498
3499 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3500 {
3501 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3502
3503 if( xInternalTimerHandle != NULL )
3504 {
3505 pcReturn = pcTimerGetName( xInternalTimerHandle );
3506 }
3507 }
3508 }
3509
3510 return pcReturn;
3511 }
3512
3513 #endif /* if ( configUSE_TIMERS == 1 ) */
3514/*-----------------------------------------------------------*/
3515
3516 #if ( configUSE_TIMERS == 1 )
3517
3518 void MPU_vTimerSetReloadModeImpl( TimerHandle_t xTimer,
3519 const UBaseType_t uxAutoReload ) PRIVILEGED_FUNCTION;
3520
3521 void MPU_vTimerSetReloadModeImpl( TimerHandle_t xTimer,
3522 const UBaseType_t uxAutoReload ) /* PRIVILEGED_FUNCTION */
3523 {
3524 TimerHandle_t xInternalTimerHandle = NULL;
3525 int32_t lIndex;
3526 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3527
3528 lIndex = ( int32_t ) xTimer;
3529
3530 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3531 {
3532 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3533
3534 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3535 {
3536 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3537
3538 if( xInternalTimerHandle != NULL )
3539 {
3540 vTimerSetReloadMode( xInternalTimerHandle, uxAutoReload );
3541 }
3542 }
3543 }
3544 }
3545
3546 #endif /* if ( configUSE_TIMERS == 1 ) */
3547/*-----------------------------------------------------------*/
3548
3549 #if ( configUSE_TIMERS == 1 )
3550
3551 BaseType_t MPU_xTimerGetReloadModeImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
3552
3553 BaseType_t MPU_xTimerGetReloadModeImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
3554 {
3555 BaseType_t xReturn = pdFALSE;
3556 TimerHandle_t xInternalTimerHandle = NULL;
3557 int32_t lIndex;
3558 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3559
3560 lIndex = ( int32_t ) xTimer;
3561
3562 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3563 {
3564 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3565
3566 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3567 {
3568 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3569
3570 if( xInternalTimerHandle != NULL )
3571 {
3572 xReturn = xTimerGetReloadMode( xInternalTimerHandle );
3573 }
3574 }
3575 }
3576
3577 return xReturn;
3578 }
3579
3580 #endif /* if ( configUSE_TIMERS == 1 ) */
3581/*-----------------------------------------------------------*/
3582
3583 #if ( configUSE_TIMERS == 1 )
3584
3585 UBaseType_t MPU_uxTimerGetReloadModeImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
3586
3587 UBaseType_t MPU_uxTimerGetReloadModeImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
3588 {
3589 UBaseType_t uxReturn = 0;
3590 TimerHandle_t xInternalTimerHandle = NULL;
3591 int32_t lIndex;
3592 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3593
3594 lIndex = ( int32_t ) xTimer;
3595
3596 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3597 {
3598 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3599
3600 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3601 {
3602 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3603
3604 if( xInternalTimerHandle != NULL )
3605 {
3606 uxReturn = uxTimerGetReloadMode( xInternalTimerHandle );
3607 }
3608 }
3609 }
3610
3611 return uxReturn;
3612 }
3613
3614 #endif /* if ( configUSE_TIMERS == 1 ) */
3615/*-----------------------------------------------------------*/
3616
3617 #if ( configUSE_TIMERS == 1 )
3618
3619 TickType_t MPU_xTimerGetPeriodImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
3620
3621 TickType_t MPU_xTimerGetPeriodImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
3622 {
3623 TickType_t xReturn = 0;
3624 TimerHandle_t xInternalTimerHandle = NULL;
3625 int32_t lIndex;
3626 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3627
3628 lIndex = ( int32_t ) xTimer;
3629
3630 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3631 {
3632 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3633
3634 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3635 {
3636 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3637
3638 if( xInternalTimerHandle != NULL )
3639 {
3640 xReturn = xTimerGetPeriod( xInternalTimerHandle );
3641 }
3642 }
3643 }
3644
3645 return xReturn;
3646 }
3647
3648 #endif /* if ( configUSE_TIMERS == 1 ) */
3649/*-----------------------------------------------------------*/
3650
3651 #if ( configUSE_TIMERS == 1 )
3652
3653 TickType_t MPU_xTimerGetExpiryTimeImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
3654
3655 TickType_t MPU_xTimerGetExpiryTimeImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
3656 {
3657 TickType_t xReturn = 0;
3658 TimerHandle_t xInternalTimerHandle = NULL;
3659 int32_t lIndex;
3660 BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
3661
3662 lIndex = ( int32_t ) xTimer;
3663
3664 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3665 {
3666 xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3667
3668 if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
3669 {
3670 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3671
3672 if( xInternalTimerHandle != NULL )
3673 {
3674 xReturn = xTimerGetExpiryTime( xInternalTimerHandle );
3675 }
3676 }
3677 }
3678
3679 return xReturn;
3680 }
3681
3682 #endif /* if ( configUSE_TIMERS == 1 ) */
3683/*-----------------------------------------------------------*/
3684
3685/* Privileged only wrappers for Timer APIs. These are needed so that
3686 * the application can use opaque handles maintained in mpu_wrappers.c
3687 * with all the APIs. */
3688/*-----------------------------------------------------------*/
3689
3690 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 )
3691
3692 TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName,
3693 const TickType_t xTimerPeriodInTicks,
3694 const UBaseType_t uxAutoReload,
3695 void * const pvTimerID,
3696 TimerCallbackFunction_t pxCallbackFunction ) /* PRIVILEGED_FUNCTION */
3697 {
3698 TimerHandle_t xInternalTimerHandle = NULL;
3699 TimerHandle_t xExternalTimerHandle = NULL;
3700 int32_t lIndex;
3701
3702 lIndex = MPU_GetFreeIndexInKernelObjectPool();
3703
3704 if( lIndex != -1 )
3705 {
3706 xInternalTimerHandle = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, MPU_TimerCallback );
3707
3708 if( xInternalTimerHandle != NULL )
3709 {
3710 MPU_StoreTimerHandleAtIndex( lIndex, xInternalTimerHandle, pxCallbackFunction );
3711 xExternalTimerHandle = ( TimerHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
3712 }
3713 else
3714 {
3715 MPU_SetIndexFreeInKernelObjectPool( lIndex );
3716 }
3717 }
3718
3719 return xExternalTimerHandle;
3720 }
3721
3722 #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) */
3723/*-----------------------------------------------------------*/
3724
3725 #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 )
3726
3727 TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName,
3728 const TickType_t xTimerPeriodInTicks,
3729 const UBaseType_t uxAutoReload,
3730 void * const pvTimerID,
3731 TimerCallbackFunction_t pxCallbackFunction,
3732 StaticTimer_t * pxTimerBuffer ) /* PRIVILEGED_FUNCTION */
3733 {
3734 TimerHandle_t xInternalTimerHandle = NULL;
3735 TimerHandle_t xExternalTimerHandle = NULL;
3736 int32_t lIndex;
3737
3738 lIndex = MPU_GetFreeIndexInKernelObjectPool();
3739
3740 if( lIndex != -1 )
3741 {
3742 xInternalTimerHandle = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, MPU_TimerCallback, pxTimerBuffer );
3743
3744 if( xInternalTimerHandle != NULL )
3745 {
3746 MPU_StoreTimerHandleAtIndex( lIndex, xInternalTimerHandle, pxCallbackFunction );
3747 xExternalTimerHandle = ( TimerHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
3748 }
3749 else
3750 {
3751 MPU_SetIndexFreeInKernelObjectPool( lIndex );
3752 }
3753 }
3754
3755 return xExternalTimerHandle;
3756 }
3757
3758 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) */
3759/*-----------------------------------------------------------*/
3760
3761 #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 )
3762
3763 BaseType_t MPU_xTimerGetStaticBuffer( TimerHandle_t xTimer,
3764 StaticTimer_t ** ppxTimerBuffer ) /* PRIVILEGED_FUNCTION */
3765 {
3766 TimerHandle_t xInternalTimerHandle = NULL;
3767 int32_t lIndex;
3768 BaseType_t xReturn = pdFALSE;
3769
3770 lIndex = ( int32_t ) xTimer;
3771
3772 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3773 {
3774 xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3775
3776 if( xInternalTimerHandle != NULL )
3777 {
3778 xReturn = xTimerGetStaticBuffer( xInternalTimerHandle, ppxTimerBuffer );
3779 }
3780 }
3781
3782 return xReturn;
3783 }
3784
3785 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) */
3786/*-----------------------------------------------------------*/
3787
3788/*-----------------------------------------------------------*/
3789/* MPU wrappers for event group APIs. */
3790/*-----------------------------------------------------------*/
3791
3792 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
3793 const EventBits_t uxBitsToWaitFor,
3794 const BaseType_t xClearOnExit,
3795 const BaseType_t xWaitForAllBits,
3796 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
3797 {
3798 EventBits_t xReturn = 0;
3799 xEventGroupWaitBitsParams_t xParams;
3800
3801 xParams.xEventGroup = xEventGroup;
3802 xParams.uxBitsToWaitFor = uxBitsToWaitFor;
3803 xParams.xClearOnExit = xClearOnExit;
3804 xParams.xWaitForAllBits = xWaitForAllBits;
3805 xParams.xTicksToWait = xTicksToWait;
3806
3807 xReturn = MPU_xEventGroupWaitBitsEntry( &( xParams ) );
3808
3809 return xReturn;
3810 }
3811
3812 EventBits_t MPU_xEventGroupWaitBitsImpl( const xEventGroupWaitBitsParams_t * pxParams ) PRIVILEGED_FUNCTION;
3813
3814 EventBits_t MPU_xEventGroupWaitBitsImpl( const xEventGroupWaitBitsParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
3815 {
3816 EventBits_t xReturn = 0;
3817 EventGroupHandle_t xInternalEventGroupHandle = NULL;
3818 int32_t lIndex;
3819 BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
3820 BaseType_t xAreParamsReadable = pdFALSE;
3821
3822 if( pxParams != NULL )
3823 {
3824 xAreParamsReadable = xPortIsAuthorizedToAccessBuffer( pxParams,
3825 sizeof( xEventGroupWaitBitsParams_t ),
3826 tskMPU_READ_PERMISSION );
3827 }
3828
3829 if( xAreParamsReadable == pdTRUE )
3830 {
3831 if( ( ( pxParams->uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 ) &&
3832 ( pxParams->uxBitsToWaitFor != 0 )
3833 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
3834 && ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( pxParams->xTicksToWait != 0 ) ) )
3835 #endif
3836 )
3837 {
3838 lIndex = ( int32_t ) ( pxParams->xEventGroup );
3839
3840 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3841 {
3842 xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3843
3844 if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
3845 {
3846 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3847
3848 if( xInternalEventGroupHandle != NULL )
3849 {
3850 xReturn = xEventGroupWaitBits( xInternalEventGroupHandle,
3851 pxParams->uxBitsToWaitFor,
3852 pxParams->xClearOnExit,
3853 pxParams->xWaitForAllBits,
3854 pxParams->xTicksToWait );
3855 }
3856 }
3857 }
3858 }
3859 }
3860
3861 return xReturn;
3862 }
3863/*-----------------------------------------------------------*/
3864
3865 EventBits_t MPU_xEventGroupClearBitsImpl( EventGroupHandle_t xEventGroup,
3866 const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
3867
3868 EventBits_t MPU_xEventGroupClearBitsImpl( EventGroupHandle_t xEventGroup,
3869 const EventBits_t uxBitsToClear ) /* PRIVILEGED_FUNCTION */
3870 {
3871 EventBits_t xReturn = 0;
3872 EventGroupHandle_t xInternalEventGroupHandle = NULL;
3873 int32_t lIndex;
3874 BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
3875
3876 if( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0 )
3877 {
3878 lIndex = ( int32_t ) xEventGroup;
3879
3880 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3881 {
3882 xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3883
3884 if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
3885 {
3886 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3887
3888 if( xInternalEventGroupHandle != NULL )
3889 {
3890 xReturn = xEventGroupClearBits( xInternalEventGroupHandle, uxBitsToClear );
3891 }
3892 }
3893 }
3894 }
3895
3896 return xReturn;
3897 }
3898/*-----------------------------------------------------------*/
3899
3900 EventBits_t MPU_xEventGroupSetBitsImpl( EventGroupHandle_t xEventGroup,
3901 const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;
3902
3903 EventBits_t MPU_xEventGroupSetBitsImpl( EventGroupHandle_t xEventGroup,
3904 const EventBits_t uxBitsToSet ) /* PRIVILEGED_FUNCTION */
3905 {
3906 EventBits_t xReturn = 0;
3907 EventGroupHandle_t xInternalEventGroupHandle = NULL;
3908 int32_t lIndex;
3909 BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
3910
3911 if( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0 )
3912 {
3913 lIndex = ( int32_t ) xEventGroup;
3914
3915 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3916 {
3917 xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3918
3919 if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
3920 {
3921 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3922
3923 if( xInternalEventGroupHandle != NULL )
3924 {
3925 xReturn = xEventGroupSetBits( xInternalEventGroupHandle, uxBitsToSet );
3926 }
3927 }
3928 }
3929 }
3930
3931 return xReturn;
3932 }
3933/*-----------------------------------------------------------*/
3934
3935 EventBits_t MPU_xEventGroupSyncImpl( EventGroupHandle_t xEventGroup,
3936 const EventBits_t uxBitsToSet,
3937 const EventBits_t uxBitsToWaitFor,
3938 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
3939
3940 EventBits_t MPU_xEventGroupSyncImpl( EventGroupHandle_t xEventGroup,
3941 const EventBits_t uxBitsToSet,
3942 const EventBits_t uxBitsToWaitFor,
3943 TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
3944 {
3945 EventBits_t xReturn = 0;
3946 EventGroupHandle_t xInternalEventGroupHandle = NULL;
3947 int32_t lIndex;
3948 BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
3949
3950 if( ( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 ) &&
3951 ( uxBitsToWaitFor != 0 )
3952 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
3953 && ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) )
3954 #endif
3955 )
3956 {
3957 lIndex = ( int32_t ) xEventGroup;
3958
3959 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3960 {
3961 xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3962
3963 if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
3964 {
3965 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3966
3967 if( xInternalEventGroupHandle != NULL )
3968 {
3969 xReturn = xEventGroupSync( xInternalEventGroupHandle, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
3970 }
3971 }
3972 }
3973 }
3974
3975 return xReturn;
3976 }
3977/*-----------------------------------------------------------*/
3978
3979 #if ( configUSE_TRACE_FACILITY == 1 )
3980
3981 UBaseType_t MPU_uxEventGroupGetNumberImpl( void * xEventGroup ) PRIVILEGED_FUNCTION;
3982
3983 UBaseType_t MPU_uxEventGroupGetNumberImpl( void * xEventGroup ) /* PRIVILEGED_FUNCTION */
3984 {
3985 UBaseType_t xReturn = 0;
3986 EventGroupHandle_t xInternalEventGroupHandle = NULL;
3987 int32_t lIndex;
3988 BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
3989
3990 lIndex = ( int32_t ) xEventGroup;
3991
3992 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
3993 {
3994 xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3995
3996 if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
3997 {
3998 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
3999
4000 if( xInternalEventGroupHandle != NULL )
4001 {
4002 xReturn = uxEventGroupGetNumber( xInternalEventGroupHandle );
4003 }
4004 }
4005 }
4006
4007 return xReturn;
4008 }
4009
4010 #endif /*( configUSE_TRACE_FACILITY == 1 )*/
4011/*-----------------------------------------------------------*/
4012
4013 #if ( configUSE_TRACE_FACILITY == 1 )
4014
4015 void MPU_vEventGroupSetNumberImpl( void * xEventGroup,
4016 UBaseType_t uxEventGroupNumber ) PRIVILEGED_FUNCTION;
4017
4018 void MPU_vEventGroupSetNumberImpl( void * xEventGroup,
4019 UBaseType_t uxEventGroupNumber ) /* PRIVILEGED_FUNCTION */
4020 {
4021 EventGroupHandle_t xInternalEventGroupHandle = NULL;
4022 int32_t lIndex;
4023 BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
4024
4025 lIndex = ( int32_t ) xEventGroup;
4026
4027 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4028 {
4029 xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4030
4031 if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
4032 {
4033 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4034
4035 if( xInternalEventGroupHandle != NULL )
4036 {
4037 vEventGroupSetNumber( xInternalEventGroupHandle, uxEventGroupNumber );
4038 }
4039 }
4040 }
4041 }
4042
4043 #endif /*( configUSE_TRACE_FACILITY == 1 )*/
4044/*-----------------------------------------------------------*/
4045
4046/* Privileged only wrappers for Event Group APIs. These are needed so that
4047 * the application can use opaque handles maintained in mpu_wrappers.c
4048 * with all the APIs. */
4049/*-----------------------------------------------------------*/
4050
4051 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
4052
4053 EventGroupHandle_t MPU_xEventGroupCreate( void ) /* PRIVILEGED_FUNCTION */
4054 {
4055 EventGroupHandle_t xInternalEventGroupHandle = NULL;
4056 EventGroupHandle_t xExternalEventGroupHandle = NULL;
4057 int32_t lIndex;
4058
4059 lIndex = MPU_GetFreeIndexInKernelObjectPool();
4060
4061 if( lIndex != -1 )
4062 {
4063 xInternalEventGroupHandle = xEventGroupCreate();
4064
4065 if( xInternalEventGroupHandle != NULL )
4066 {
4067 MPU_StoreEventGroupHandleAtIndex( lIndex, xInternalEventGroupHandle );
4068 xExternalEventGroupHandle = ( EventGroupHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
4069 }
4070 else
4071 {
4072 MPU_SetIndexFreeInKernelObjectPool( lIndex );
4073 }
4074 }
4075
4076 return xExternalEventGroupHandle;
4077 }
4078
4079 #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
4080/*-----------------------------------------------------------*/
4081
4082 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
4083
4084 EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* PRIVILEGED_FUNCTION */
4085 {
4086 EventGroupHandle_t xInternalEventGroupHandle = NULL;
4087 EventGroupHandle_t xExternalEventGroupHandle = NULL;
4088 int32_t lIndex;
4089
4090 lIndex = MPU_GetFreeIndexInKernelObjectPool();
4091
4092 if( lIndex != -1 )
4093 {
4094 xInternalEventGroupHandle = xEventGroupCreateStatic( pxEventGroupBuffer );
4095
4096 if( xInternalEventGroupHandle != NULL )
4097 {
4098 MPU_StoreEventGroupHandleAtIndex( lIndex, xInternalEventGroupHandle );
4099 xExternalEventGroupHandle = ( EventGroupHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
4100 }
4101 else
4102 {
4103 MPU_SetIndexFreeInKernelObjectPool( lIndex );
4104 }
4105 }
4106
4107 return xExternalEventGroupHandle;
4108 }
4109
4110 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
4111/*-----------------------------------------------------------*/
4112
4113 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* PRIVILEGED_FUNCTION */
4114 {
4115 EventGroupHandle_t xInternalEventGroupHandle = NULL;
4116 int32_t lIndex;
4117
4118 lIndex = ( int32_t ) xEventGroup;
4119
4120 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4121 {
4122 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4123
4124 if( xInternalEventGroupHandle != NULL )
4125 {
4126 vEventGroupDelete( xInternalEventGroupHandle );
4127 MPU_SetIndexFreeInKernelObjectPool( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4128 }
4129 }
4130 }
4131/*-----------------------------------------------------------*/
4132
4133 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
4134
4135 BaseType_t MPU_xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
4136 StaticEventGroup_t ** ppxEventGroupBuffer ) /* PRIVILEGED_FUNCTION */
4137 {
4138 BaseType_t xReturn = pdFALSE;
4139 EventGroupHandle_t xInternalEventGroupHandle = NULL;
4140 int32_t lIndex;
4141
4142 lIndex = ( int32_t ) xEventGroup;
4143
4144 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4145 {
4146 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4147
4148 if( xInternalEventGroupHandle != NULL )
4149 {
4150 xReturn = xEventGroupGetStaticBuffer( xInternalEventGroupHandle, ppxEventGroupBuffer );
4151 }
4152 }
4153
4154 return xReturn;
4155 }
4156
4157 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
4158/*-----------------------------------------------------------*/
4159
4160 #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
4161
4162 BaseType_t MPU_xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
4163 const EventBits_t uxBitsToClear ) /* PRIVILEGED_FUNCTION */
4164 {
4165 BaseType_t xReturn = pdFALSE;
4166 EventGroupHandle_t xInternalEventGroupHandle = NULL;
4167 int32_t lIndex;
4168
4169 lIndex = ( int32_t ) xEventGroup;
4170
4171 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4172 {
4173 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4174
4175 if( xInternalEventGroupHandle != NULL )
4176 {
4177 xReturn = xEventGroupClearBitsFromISR( xInternalEventGroupHandle, uxBitsToClear );
4178 }
4179 }
4180
4181 return xReturn;
4182 }
4183
4184 #endif /* #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
4185/*-----------------------------------------------------------*/
4186
4187 #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
4188
4189 BaseType_t MPU_xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
4190 const EventBits_t uxBitsToSet,
4191 BaseType_t * pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
4192 {
4193 BaseType_t xReturn = pdFALSE;
4194 EventGroupHandle_t xInternalEventGroupHandle = NULL;
4195 int32_t lIndex;
4196
4197 lIndex = ( int32_t ) xEventGroup;
4198
4199 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4200 {
4201 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4202
4203 if( xInternalEventGroupHandle != NULL )
4204 {
4205 xReturn = xEventGroupSetBitsFromISR( xInternalEventGroupHandle, uxBitsToSet, pxHigherPriorityTaskWoken );
4206 }
4207 }
4208
4209 return xReturn;
4210 }
4211
4212 #endif /* #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
4213/*-----------------------------------------------------------*/
4214
4215 EventBits_t MPU_xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) /* PRIVILEGED_FUNCTION */
4216 {
4217 EventBits_t xReturn = 0;
4218 EventGroupHandle_t xInternalEventGroupHandle = NULL;
4219 int32_t lIndex;
4220
4221 lIndex = ( int32_t ) xEventGroup;
4222
4223 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4224 {
4225 xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4226
4227 if( xInternalEventGroupHandle != NULL )
4228 {
4229 xReturn = xEventGroupGetBitsFromISR( xInternalEventGroupHandle );
4230 }
4231 }
4232
4233 return xReturn;
4234 }
4235/*-----------------------------------------------------------*/
4236
4237/*-----------------------------------------------------------*/
4238/* MPU wrappers for stream buffer APIs. */
4239/*-----------------------------------------------------------*/
4240
4241 size_t MPU_xStreamBufferSendImpl( StreamBufferHandle_t xStreamBuffer,
4242 const void * pvTxData,
4243 size_t xDataLengthBytes,
4244 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
4245
4246 size_t MPU_xStreamBufferSendImpl( StreamBufferHandle_t xStreamBuffer,
4247 const void * pvTxData,
4248 size_t xDataLengthBytes,
4249 TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
4250 {
4251 size_t xReturn = 0;
4252 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4253 int32_t lIndex;
4254 BaseType_t xIsTxDataBufferReadable = pdFALSE;
4255 BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
4256
4257 if( pvTxData != NULL )
4258 {
4259 xIsTxDataBufferReadable = xPortIsAuthorizedToAccessBuffer( pvTxData,
4260 xDataLengthBytes,
4261 tskMPU_READ_PERMISSION );
4262
4263 if( xIsTxDataBufferReadable == pdTRUE )
4264 {
4265 lIndex = ( int32_t ) xStreamBuffer;
4266
4267 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4268 {
4269 xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4270
4271 if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
4272 {
4273 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4274
4275 if( xInternalStreamBufferHandle != NULL )
4276 {
4277 xReturn = xStreamBufferSend( xInternalStreamBufferHandle, pvTxData, xDataLengthBytes, xTicksToWait );
4278 }
4279 }
4280 }
4281 }
4282 }
4283
4284 return xReturn;
4285 }
4286/*-----------------------------------------------------------*/
4287
4288 size_t MPU_xStreamBufferReceiveImpl( StreamBufferHandle_t xStreamBuffer,
4289 void * pvRxData,
4290 size_t xBufferLengthBytes,
4291 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
4292
4293 size_t MPU_xStreamBufferReceiveImpl( StreamBufferHandle_t xStreamBuffer,
4294 void * pvRxData,
4295 size_t xBufferLengthBytes,
4296 TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
4297 {
4298 size_t xReturn = 0;
4299 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4300 int32_t lIndex;
4301 BaseType_t xIsRxDataBufferWriteable = pdFALSE;
4302 BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
4303
4304 if( pvRxData != NULL )
4305 {
4306 xIsRxDataBufferWriteable = xPortIsAuthorizedToAccessBuffer( pvRxData,
4307 xBufferLengthBytes,
4308 tskMPU_WRITE_PERMISSION );
4309
4310 if( xIsRxDataBufferWriteable == pdTRUE )
4311 {
4312 lIndex = ( int32_t ) xStreamBuffer;
4313
4314 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4315 {
4316 xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4317
4318 if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
4319 {
4320 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4321
4322 if( xInternalStreamBufferHandle != NULL )
4323 {
4324 xReturn = xStreamBufferReceive( xInternalStreamBufferHandle, pvRxData, xBufferLengthBytes, xTicksToWait );
4325 }
4326 }
4327 }
4328 }
4329 }
4330
4331 return xReturn;
4332 }
4333/*-----------------------------------------------------------*/
4334
4335 BaseType_t MPU_xStreamBufferIsFullImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
4336
4337 BaseType_t MPU_xStreamBufferIsFullImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
4338 {
4339 BaseType_t xReturn = pdFALSE;
4340 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4341 int32_t lIndex;
4342 BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
4343
4344 lIndex = ( int32_t ) xStreamBuffer;
4345
4346 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4347 {
4348 xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4349
4350 if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
4351 {
4352 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4353
4354 if( xInternalStreamBufferHandle != NULL )
4355 {
4356 xReturn = xStreamBufferIsFull( xInternalStreamBufferHandle );
4357 }
4358 }
4359 }
4360
4361 return xReturn;
4362 }
4363/*-----------------------------------------------------------*/
4364
4365 BaseType_t MPU_xStreamBufferIsEmptyImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
4366
4367 BaseType_t MPU_xStreamBufferIsEmptyImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
4368 {
4369 BaseType_t xReturn = pdFALSE;
4370 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4371 int32_t lIndex;
4372 BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
4373
4374 lIndex = ( int32_t ) xStreamBuffer;
4375
4376 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4377 {
4378 xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4379
4380 if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
4381 {
4382 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4383
4384 if( xInternalStreamBufferHandle != NULL )
4385 {
4386 xReturn = xStreamBufferIsEmpty( xInternalStreamBufferHandle );
4387 }
4388 }
4389 }
4390
4391 return xReturn;
4392 }
4393/*-----------------------------------------------------------*/
4394
4395 size_t MPU_xStreamBufferSpacesAvailableImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
4396
4397 size_t MPU_xStreamBufferSpacesAvailableImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
4398 {
4399 size_t xReturn = 0;
4400 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4401 int32_t lIndex;
4402 BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
4403
4404 lIndex = ( int32_t ) xStreamBuffer;
4405
4406 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4407 {
4408 xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4409
4410 if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
4411 {
4412 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4413
4414 if( xInternalStreamBufferHandle != NULL )
4415 {
4416 xReturn = xStreamBufferSpacesAvailable( xInternalStreamBufferHandle );
4417 }
4418 }
4419 }
4420
4421 return xReturn;
4422 }
4423/*-----------------------------------------------------------*/
4424
4425 size_t MPU_xStreamBufferBytesAvailableImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
4426
4427 size_t MPU_xStreamBufferBytesAvailableImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
4428 {
4429 size_t xReturn = 0;
4430 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4431 int32_t lIndex;
4432 BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
4433
4434 lIndex = ( int32_t ) xStreamBuffer;
4435
4436 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4437 {
4438 xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4439
4440 if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
4441 {
4442 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4443
4444 if( xInternalStreamBufferHandle != NULL )
4445 {
4446 xReturn = xStreamBufferBytesAvailable( xInternalStreamBufferHandle );
4447 }
4448 }
4449 }
4450
4451 return xReturn;
4452 }
4453/*-----------------------------------------------------------*/
4454
4455 BaseType_t MPU_xStreamBufferSetTriggerLevelImpl( StreamBufferHandle_t xStreamBuffer,
4456 size_t xTriggerLevel ) PRIVILEGED_FUNCTION;
4457
4458 BaseType_t MPU_xStreamBufferSetTriggerLevelImpl( StreamBufferHandle_t xStreamBuffer,
4459 size_t xTriggerLevel ) /* PRIVILEGED_FUNCTION */
4460 {
4461 BaseType_t xReturn = pdFALSE;
4462 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4463 int32_t lIndex;
4464 BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
4465
4466 lIndex = ( int32_t ) xStreamBuffer;
4467
4468 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4469 {
4470 xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4471
4472 if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
4473 {
4474 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4475
4476 if( xInternalStreamBufferHandle != NULL )
4477 {
4478 xReturn = xStreamBufferSetTriggerLevel( xInternalStreamBufferHandle, xTriggerLevel );
4479 }
4480 }
4481 }
4482
4483 return xReturn;
4484 }
4485/*-----------------------------------------------------------*/
4486
4487 size_t MPU_xStreamBufferNextMessageLengthBytesImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
4488
4489 size_t MPU_xStreamBufferNextMessageLengthBytesImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
4490 {
4491 size_t xReturn = 0;
4492 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4493 int32_t lIndex;
4494 BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
4495
4496 lIndex = ( int32_t ) xStreamBuffer;
4497
4498 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4499 {
4500 xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4501
4502 if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
4503 {
4504 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4505
4506 if( xInternalStreamBufferHandle != NULL )
4507 {
4508 xReturn = xStreamBufferNextMessageLengthBytes( xInternalStreamBufferHandle );
4509 }
4510 }
4511 }
4512
4513 return xReturn;
4514 }
4515/*-----------------------------------------------------------*/
4516
4517/* Privileged only wrappers for Stream Buffer APIs. These are needed so that
4518 * the application can use opaque handles maintained in mpu_wrappers.c
4519 * with all the APIs. */
4520/*-----------------------------------------------------------*/
4521
4522 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
4523
4524 StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
4525 size_t xTriggerLevelBytes,
4526 BaseType_t xIsMessageBuffer,
4527 StreamBufferCallbackFunction_t pxSendCompletedCallback,
4528 StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* PRIVILEGED_FUNCTION */
4529 {
4530 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4531 StreamBufferHandle_t xExternalStreamBufferHandle = NULL;
4532 int32_t lIndex;
4533
4534 /**
4535 * Stream buffer application level callback functionality is disabled for MPU
4536 * enabled ports.
4537 */
4538 configASSERT( ( pxSendCompletedCallback == NULL ) &&
4539 ( pxReceiveCompletedCallback == NULL ) );
4540
4541 if( ( pxSendCompletedCallback == NULL ) &&
4542 ( pxReceiveCompletedCallback == NULL ) )
4543 {
4544 lIndex = MPU_GetFreeIndexInKernelObjectPool();
4545
4546 if( lIndex != -1 )
4547 {
4548 xInternalStreamBufferHandle = xStreamBufferGenericCreate( xBufferSizeBytes,
4549 xTriggerLevelBytes,
4550 xIsMessageBuffer,
4551 NULL,
4552 NULL );
4553
4554 if( xInternalStreamBufferHandle != NULL )
4555 {
4556 MPU_StoreStreamBufferHandleAtIndex( lIndex, xInternalStreamBufferHandle );
4557 xExternalStreamBufferHandle = ( StreamBufferHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
4558 }
4559 else
4560 {
4561 MPU_SetIndexFreeInKernelObjectPool( lIndex );
4562 }
4563 }
4564 }
4565 else
4566 {
4567 traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer );
4568 xExternalStreamBufferHandle = NULL;
4569 }
4570
4571 return xExternalStreamBufferHandle;
4572 }
4573
4574 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
4575/*-----------------------------------------------------------*/
4576
4577 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
4578
4579 StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
4580 size_t xTriggerLevelBytes,
4581 BaseType_t xIsMessageBuffer,
4582 uint8_t * const pucStreamBufferStorageArea,
4583 StaticStreamBuffer_t * const pxStaticStreamBuffer,
4584 StreamBufferCallbackFunction_t pxSendCompletedCallback,
4585 StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* PRIVILEGED_FUNCTION */
4586 {
4587 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4588 StreamBufferHandle_t xExternalStreamBufferHandle = NULL;
4589 int32_t lIndex;
4590
4591 /**
4592 * Stream buffer application level callback functionality is disabled for MPU
4593 * enabled ports.
4594 */
4595 configASSERT( ( pxSendCompletedCallback == NULL ) &&
4596 ( pxReceiveCompletedCallback == NULL ) );
4597
4598 if( ( pxSendCompletedCallback == NULL ) &&
4599 ( pxReceiveCompletedCallback == NULL ) )
4600 {
4601 lIndex = MPU_GetFreeIndexInKernelObjectPool();
4602
4603 if( lIndex != -1 )
4604 {
4605 xInternalStreamBufferHandle = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
4606 xTriggerLevelBytes,
4607 xIsMessageBuffer,
4608 pucStreamBufferStorageArea,
4609 pxStaticStreamBuffer,
4610 NULL,
4611 NULL );
4612
4613 if( xInternalStreamBufferHandle != NULL )
4614 {
4615 MPU_StoreStreamBufferHandleAtIndex( lIndex, xInternalStreamBufferHandle );
4616 xExternalStreamBufferHandle = ( StreamBufferHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
4617 }
4618 else
4619 {
4620 MPU_SetIndexFreeInKernelObjectPool( lIndex );
4621 }
4622 }
4623 }
4624 else
4625 {
4626 traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xIsMessageBuffer );
4627 xExternalStreamBufferHandle = NULL;
4628 }
4629
4630 return xExternalStreamBufferHandle;
4631 }
4632
4633 #endif /* configSUPPORT_STATIC_ALLOCATION */
4634/*-----------------------------------------------------------*/
4635
4636 void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
4637 {
4638 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4639 int32_t lIndex;
4640
4641 lIndex = ( int32_t ) xStreamBuffer;
4642
4643 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4644 {
4645 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4646
4647 if( xInternalStreamBufferHandle != NULL )
4648 {
4649 vStreamBufferDelete( xInternalStreamBufferHandle );
4650 }
4651
4652 MPU_SetIndexFreeInKernelObjectPool( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4653 }
4654 }
4655/*-----------------------------------------------------------*/
4656
4657 BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
4658 {
4659 BaseType_t xReturn = pdFALSE;
4660 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4661 int32_t lIndex;
4662
4663 lIndex = ( int32_t ) xStreamBuffer;
4664
4665 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4666 {
4667 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4668
4669 if( xInternalStreamBufferHandle != NULL )
4670 {
4671 xReturn = xStreamBufferReset( xInternalStreamBufferHandle );
4672 }
4673 }
4674
4675 return xReturn;
4676 }
4677/*-----------------------------------------------------------*/
4678
4679 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
4680
4681 BaseType_t MPU_xStreamBufferGetStaticBuffers( StreamBufferHandle_t xStreamBuffers,
4682 uint8_t * ppucStreamBufferStorageArea,
4683 StaticStreamBuffer_t * ppxStaticStreamBuffer ) /* PRIVILEGED_FUNCTION */
4684 {
4685 BaseType_t xReturn = pdFALSE;
4686 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4687 int32_t lIndex;
4688
4689 lIndex = ( int32_t ) xStreamBuffers;
4690
4691 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4692 {
4693 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4694
4695 if( xInternalStreamBufferHandle != NULL )
4696 {
4697 xReturn = MPU_xStreamBufferGetStaticBuffers( xInternalStreamBufferHandle, ppucStreamBufferStorageArea, ppxStaticStreamBuffer );
4698 }
4699 }
4700
4701 return xReturn;
4702 }
4703
4704 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
4705/*-----------------------------------------------------------*/
4706
4707 size_t MPU_xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
4708 const void * pvTxData,
4709 size_t xDataLengthBytes,
4710 BaseType_t * const pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
4711 {
4712 size_t xReturn = 0;
4713 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4714 int32_t lIndex;
4715
4716 lIndex = ( int32_t ) xStreamBuffer;
4717
4718 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4719 {
4720 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4721
4722 if( xInternalStreamBufferHandle != NULL )
4723 {
4724 xReturn = xStreamBufferSendFromISR( xInternalStreamBufferHandle, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken );
4725 }
4726 }
4727
4728 return xReturn;
4729 }
4730/*-----------------------------------------------------------*/
4731
4732 size_t MPU_xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
4733 void * pvRxData,
4734 size_t xBufferLengthBytes,
4735 BaseType_t * const pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
4736 {
4737 size_t xReturn = 0;
4738 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4739 int32_t lIndex;
4740
4741 lIndex = ( int32_t ) xStreamBuffer;
4742
4743 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4744 {
4745 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4746
4747 if( xInternalStreamBufferHandle != NULL )
4748 {
4749 xReturn = xStreamBufferReceiveFromISR( xInternalStreamBufferHandle, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken );
4750 }
4751 }
4752
4753 return xReturn;
4754 }
4755/*-----------------------------------------------------------*/
4756
4757 BaseType_t MPU_xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
4758 BaseType_t * pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
4759 {
4760 BaseType_t xReturn = pdFALSE;
4761 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4762 int32_t lIndex;
4763
4764 lIndex = ( int32_t ) xStreamBuffer;
4765
4766 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4767 {
4768 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4769
4770 if( xInternalStreamBufferHandle != NULL )
4771 {
4772 xReturn = xStreamBufferSendCompletedFromISR( xInternalStreamBufferHandle, pxHigherPriorityTaskWoken );
4773 }
4774 }
4775
4776 return xReturn;
4777 }
4778/*-----------------------------------------------------------*/
4779
4780 BaseType_t MPU_xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
4781 BaseType_t * pxHigherPriorityTaskWoken ) /*PRIVILEGED_FUNCTION */
4782 {
4783 BaseType_t xReturn = pdFALSE;
4784 StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
4785 int32_t lIndex;
4786
4787 lIndex = ( int32_t ) xStreamBuffer;
4788
4789 if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
4790 {
4791 xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
4792
4793 if( xInternalStreamBufferHandle != NULL )
4794 {
4795 xReturn = xStreamBufferReceiveCompletedFromISR( xInternalStreamBufferHandle, pxHigherPriorityTaskWoken );
4796 }
4797 }
4798
4799 return xReturn;
4800 }
4801
4802/*-----------------------------------------------------------*/
4803
4804/* Functions that the application writer wants to execute in privileged mode
4805 * can be defined in application_defined_privileged_functions.h. */
4806
4807 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
4808 #include "application_defined_privileged_functions.h"
4809 #endif
4810/*-----------------------------------------------------------*/
4811
4812/**
4813 * @brief Array of system call implementation functions.
4814 *
4815 * The index in the array MUST match the corresponding system call number
4816 * defined in mpu_wrappers.h.
4817 */
4818 PRIVILEGED_DATA UBaseType_t uxSystemCallImplementations[ NUM_SYSTEM_CALLS ] =
4819 {
4820 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
4821 ( UBaseType_t ) MPU_xTaskGenericNotifyImpl, /* SYSTEM_CALL_xTaskGenericNotify. */
4822 ( UBaseType_t ) MPU_xTaskGenericNotifyWaitImpl, /* SYSTEM_CALL_xTaskGenericNotifyWait. */
4823 #else
4824 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGenericNotify. */
4825 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGenericNotifyWait. */
4826 #endif
4827
4828 #if ( configUSE_TIMERS == 1 )
4829 ( UBaseType_t ) MPU_xTimerGenericCommandImpl, /* SYSTEM_CALL_xTimerGenericCommand. */
4830 #else
4831 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGenericCommand. */
4832 #endif
4833
4834 ( UBaseType_t ) MPU_xEventGroupWaitBitsImpl, /* SYSTEM_CALL_xEventGroupWaitBits. */
4835
4836 /* The system calls above this line take 5 parameters. */
4837
4838 #if ( INCLUDE_xTaskDelayUntil == 1 )
4839 ( UBaseType_t ) MPU_xTaskDelayUntilImpl, /* SYSTEM_CALL_xTaskDelayUntil. */
4840 #else
4841 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskDelayUntil. */
4842 #endif
4843
4844 #if ( INCLUDE_xTaskAbortDelay == 1 )
4845 ( UBaseType_t ) MPU_xTaskAbortDelayImpl, /* SYSTEM_CALL_xTaskAbortDelay. */
4846 #else
4847 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskAbortDelay. */
4848 #endif
4849
4850 #if ( INCLUDE_vTaskDelay == 1 )
4851 ( UBaseType_t ) MPU_vTaskDelayImpl, /* SYSTEM_CALL_vTaskDelay. */
4852 #else
4853 ( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskDelay. */
4854 #endif
4855
4856 #if ( INCLUDE_uxTaskPriorityGet == 1 )
4857 ( UBaseType_t ) MPU_uxTaskPriorityGetImpl, /* SYSTEM_CALL_uxTaskPriorityGet. */
4858 #else
4859 ( UBaseType_t ) 0, /* SYSTEM_CALL_uxTaskPriorityGet. */
4860 #endif
4861
4862 #if ( INCLUDE_eTaskGetState == 1 )
4863 ( UBaseType_t ) MPU_eTaskGetStateImpl, /* SYSTEM_CALL_eTaskGetState. */
4864 #else
4865 ( UBaseType_t ) 0, /* SYSTEM_CALL_eTaskGetState. */
4866 #endif
4867
4868 #if ( configUSE_TRACE_FACILITY == 1 )
4869 ( UBaseType_t ) MPU_vTaskGetInfoImpl, /* SYSTEM_CALL_vTaskGetInfo. */
4870 #else
4871 ( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskGetInfo. */
4872 #endif
4873
4874 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
4875 ( UBaseType_t ) MPU_xTaskGetIdleTaskHandleImpl, /* SYSTEM_CALL_xTaskGetIdleTaskHandle. */
4876 #else
4877 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGetIdleTaskHandle. */
4878 #endif
4879
4880 #if ( INCLUDE_vTaskSuspend == 1 )
4881 ( UBaseType_t ) MPU_vTaskSuspendImpl, /* SYSTEM_CALL_vTaskSuspend. */
4882 ( UBaseType_t ) MPU_vTaskResumeImpl, /* SYSTEM_CALL_vTaskResume. */
4883 #else
4884 ( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskSuspend. */
4885 ( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskResume. */
4886 #endif
4887
4888 ( UBaseType_t ) MPU_xTaskGetTickCountImpl, /* SYSTEM_CALL_xTaskGetTickCount. */
4889 ( UBaseType_t ) MPU_uxTaskGetNumberOfTasksImpl, /* SYSTEM_CALL_uxTaskGetNumberOfTasks. */
4890 ( UBaseType_t ) MPU_pcTaskGetNameImpl, /* SYSTEM_CALL_pcTaskGetName. */
4891
4892 #if ( configGENERATE_RUN_TIME_STATS == 1 )
4893 ( UBaseType_t ) MPU_ulTaskGetRunTimeCounterImpl, /* SYSTEM_CALL_ulTaskGetRunTimeCounter. */
4894 ( UBaseType_t ) MPU_ulTaskGetRunTimePercentImpl, /* SYSTEM_CALL_ulTaskGetRunTimePercent. */
4895 #else
4896 ( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGetRunTimeCounter. */
4897 ( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGetRunTimePercent. */
4898 #endif
4899
4900 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
4901 ( UBaseType_t ) MPU_ulTaskGetIdleRunTimePercentImpl, /* SYSTEM_CALL_ulTaskGetIdleRunTimePercent. */
4902 ( UBaseType_t ) MPU_ulTaskGetIdleRunTimeCounterImpl, /* SYSTEM_CALL_ulTaskGetIdleRunTimeCounter. */
4903 #else
4904 ( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGetIdleRunTimePercent. */
4905 ( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGetIdleRunTimeCounter. */
4906 #endif
4907
4908 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
4909 ( UBaseType_t ) MPU_vTaskSetApplicationTaskTagImpl, /* SYSTEM_CALL_vTaskSetApplicationTaskTag. */
4910 ( UBaseType_t ) MPU_xTaskGetApplicationTaskTagImpl, /* SYSTEM_CALL_xTaskGetApplicationTaskTag. */
4911 #else
4912 ( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskSetApplicationTaskTag. */
4913 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGetApplicationTaskTag. */
4914 #endif
4915
4916 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
4917 ( UBaseType_t ) MPU_vTaskSetThreadLocalStoragePointerImpl, /* SYSTEM_CALL_vTaskSetThreadLocalStoragePointer. */
4918 ( UBaseType_t ) MPU_pvTaskGetThreadLocalStoragePointerImpl, /* SYSTEM_CALL_pvTaskGetThreadLocalStoragePointer. */
4919 #else
4920 ( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskSetThreadLocalStoragePointer. */
4921 ( UBaseType_t ) 0, /* SYSTEM_CALL_pvTaskGetThreadLocalStoragePointer. */
4922 #endif
4923
4924 #if ( configUSE_TRACE_FACILITY == 1 )
4925 ( UBaseType_t ) MPU_uxTaskGetSystemStateImpl, /* SYSTEM_CALL_uxTaskGetSystemState. */
4926 #else
4927 ( UBaseType_t ) 0, /* SYSTEM_CALL_uxTaskGetSystemState. */
4928 #endif
4929
4930 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
4931 ( UBaseType_t ) MPU_uxTaskGetStackHighWaterMarkImpl, /* SYSTEM_CALL_uxTaskGetStackHighWaterMark. */
4932 #else
4933 ( UBaseType_t ) 0, /* SYSTEM_CALL_uxTaskGetStackHighWaterMark. */
4934 #endif
4935
4936 #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
4937 ( UBaseType_t ) MPU_uxTaskGetStackHighWaterMark2Impl, /* SYSTEM_CALL_uxTaskGetStackHighWaterMark2. */
4938 #else
4939 ( UBaseType_t ) 0, /* SYSTEM_CALL_uxTaskGetStackHighWaterMark2. */
4940 #endif
4941
4942 #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
4943 ( UBaseType_t ) MPU_xTaskGetCurrentTaskHandleImpl, /* SYSTEM_CALL_xTaskGetCurrentTaskHandle. */
4944 #else
4945 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGetCurrentTaskHandle. */
4946 #endif
4947
4948 #if ( INCLUDE_xTaskGetSchedulerState == 1 )
4949 ( UBaseType_t ) MPU_xTaskGetSchedulerStateImpl, /* SYSTEM_CALL_xTaskGetSchedulerState. */
4950 #else
4951 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGetSchedulerState. */
4952 #endif
4953
4954 ( UBaseType_t ) MPU_vTaskSetTimeOutStateImpl, /* SYSTEM_CALL_vTaskSetTimeOutState. */
4955 ( UBaseType_t ) MPU_xTaskCheckForTimeOutImpl, /* SYSTEM_CALL_xTaskCheckForTimeOut. */
4956
4957 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
4958 ( UBaseType_t ) MPU_ulTaskGenericNotifyTakeImpl, /* SYSTEM_CALL_ulTaskGenericNotifyTake. */
4959 ( UBaseType_t ) MPU_xTaskGenericNotifyStateClearImpl, /* SYSTEM_CALL_xTaskGenericNotifyStateClear. */
4960 ( UBaseType_t ) MPU_ulTaskGenericNotifyValueClearImpl, /* SYSTEM_CALL_ulTaskGenericNotifyValueClear. */
4961 #else
4962 ( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGenericNotifyTake. */
4963 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGenericNotifyStateClear. */
4964 ( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGenericNotifyValueClear. */
4965 #endif
4966
4967 ( UBaseType_t ) MPU_xQueueGenericSendImpl, /* SYSTEM_CALL_xQueueGenericSend. */
4968 ( UBaseType_t ) MPU_uxQueueMessagesWaitingImpl, /* SYSTEM_CALL_uxQueueMessagesWaiting. */
4969 ( UBaseType_t ) MPU_uxQueueSpacesAvailableImpl, /* SYSTEM_CALL_uxQueueSpacesAvailable. */
4970 ( UBaseType_t ) MPU_xQueueReceiveImpl, /* SYSTEM_CALL_xQueueReceive. */
4971 ( UBaseType_t ) MPU_xQueuePeekImpl, /* SYSTEM_CALL_xQueuePeek. */
4972 ( UBaseType_t ) MPU_xQueueSemaphoreTakeImpl, /* SYSTEM_CALL_xQueueSemaphoreTake. */
4973
4974 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
4975 ( UBaseType_t ) MPU_xQueueGetMutexHolderImpl, /* SYSTEM_CALL_xQueueGetMutexHolder. */
4976 #else
4977 ( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueGetMutexHolder. */
4978 #endif
4979
4980 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
4981 ( UBaseType_t ) MPU_xQueueTakeMutexRecursiveImpl, /* SYSTEM_CALL_xQueueTakeMutexRecursive. */
4982 ( UBaseType_t ) MPU_xQueueGiveMutexRecursiveImpl, /* SYSTEM_CALL_xQueueGiveMutexRecursive. */
4983 #else
4984 ( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueTakeMutexRecursive. */
4985 ( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueGiveMutexRecursive. */
4986 #endif
4987
4988 #if ( configUSE_QUEUE_SETS == 1 )
4989 ( UBaseType_t ) MPU_xQueueSelectFromSetImpl, /* SYSTEM_CALL_xQueueSelectFromSet. */
4990 ( UBaseType_t ) MPU_xQueueAddToSetImpl, /* SYSTEM_CALL_xQueueAddToSet. */
4991 #else
4992 ( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueSelectFromSet. */
4993 ( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueAddToSet. */
4994 #endif
4995
4996 #if configQUEUE_REGISTRY_SIZE > 0
4997 ( UBaseType_t ) MPU_vQueueAddToRegistryImpl, /* SYSTEM_CALL_vQueueAddToRegistry. */
4998 ( UBaseType_t ) MPU_vQueueUnregisterQueueImpl, /* SYSTEM_CALL_vQueueUnregisterQueue. */
4999 ( UBaseType_t ) MPU_pcQueueGetNameImpl, /* SYSTEM_CALL_pcQueueGetName. */
5000 #else
5001 ( UBaseType_t ) 0, /* SYSTEM_CALL_vQueueAddToRegistry. */
5002 ( UBaseType_t ) 0, /* SYSTEM_CALL_vQueueUnregisterQueue. */
5003 ( UBaseType_t ) 0, /* SYSTEM_CALL_pcQueueGetName. */
5004 #endif
5005
5006 #if ( configUSE_TIMERS == 1 )
5007 ( UBaseType_t ) MPU_pvTimerGetTimerIDImpl, /* SYSTEM_CALL_pvTimerGetTimerID. */
5008 ( UBaseType_t ) MPU_vTimerSetTimerIDImpl, /* SYSTEM_CALL_vTimerSetTimerID. */
5009 ( UBaseType_t ) MPU_xTimerIsTimerActiveImpl, /* SYSTEM_CALL_xTimerIsTimerActive. */
5010 ( UBaseType_t ) MPU_xTimerGetTimerDaemonTaskHandleImpl, /* SYSTEM_CALL_xTimerGetTimerDaemonTaskHandle. */
5011 ( UBaseType_t ) MPU_pcTimerGetNameImpl, /* SYSTEM_CALL_pcTimerGetName. */
5012 ( UBaseType_t ) MPU_vTimerSetReloadModeImpl, /* SYSTEM_CALL_vTimerSetReloadMode. */
5013 ( UBaseType_t ) MPU_xTimerGetReloadModeImpl, /* SYSTEM_CALL_xTimerGetReloadMode. */
5014 ( UBaseType_t ) MPU_uxTimerGetReloadModeImpl, /* SYSTEM_CALL_uxTimerGetReloadMode. */
5015 ( UBaseType_t ) MPU_xTimerGetPeriodImpl, /* SYSTEM_CALL_xTimerGetPeriod. */
5016 ( UBaseType_t ) MPU_xTimerGetExpiryTimeImpl, /* SYSTEM_CALL_xTimerGetExpiryTime. */
5017 #else /* if ( configUSE_TIMERS == 1 ) */
5018 ( UBaseType_t ) 0, /* SYSTEM_CALL_pvTimerGetTimerID. */
5019 ( UBaseType_t ) 0, /* SYSTEM_CALL_vTimerSetTimerID. */
5020 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerIsTimerActive. */
5021 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGetTimerDaemonTaskHandle. */
5022 ( UBaseType_t ) 0, /* SYSTEM_CALL_pcTimerGetName. */
5023 ( UBaseType_t ) 0, /* SYSTEM_CALL_vTimerSetReloadMode. */
5024 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGetReloadMode. */
5025 ( UBaseType_t ) 0, /* SYSTEM_CALL_uxTimerGetReloadMode. */
5026 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGetPeriod. */
5027 ( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGetExpiryTime. */
5028 #endif /* if ( configUSE_TIMERS == 1 ) */
5029
5030 ( UBaseType_t ) MPU_xEventGroupClearBitsImpl, /* SYSTEM_CALL_xEventGroupClearBits. */
5031 ( UBaseType_t ) MPU_xEventGroupSetBitsImpl, /* SYSTEM_CALL_xEventGroupSetBits. */
5032 ( UBaseType_t ) MPU_xEventGroupSyncImpl, /* SYSTEM_CALL_xEventGroupSync. */
5033
5034 #if ( configUSE_TRACE_FACILITY == 1 )
5035 ( UBaseType_t ) MPU_uxEventGroupGetNumberImpl, /* SYSTEM_CALL_uxEventGroupGetNumber. */
5036 ( UBaseType_t ) MPU_vEventGroupSetNumberImpl, /* SYSTEM_CALL_vEventGroupSetNumber. */
5037 #else
5038 ( UBaseType_t ) 0, /* SYSTEM_CALL_uxEventGroupGetNumber. */
5039 ( UBaseType_t ) 0, /* SYSTEM_CALL_vEventGroupSetNumber. */
5040 #endif
5041
5042 ( UBaseType_t ) MPU_xStreamBufferSendImpl, /* SYSTEM_CALL_xStreamBufferSend. */
5043 ( UBaseType_t ) MPU_xStreamBufferReceiveImpl, /* SYSTEM_CALL_xStreamBufferReceive. */
5044 ( UBaseType_t ) MPU_xStreamBufferIsFullImpl, /* SYSTEM_CALL_xStreamBufferIsFull. */
5045 ( UBaseType_t ) MPU_xStreamBufferIsEmptyImpl, /* SYSTEM_CALL_xStreamBufferIsEmpty. */
5046 ( UBaseType_t ) MPU_xStreamBufferSpacesAvailableImpl, /* SYSTEM_CALL_xStreamBufferSpacesAvailable. */
5047 ( UBaseType_t ) MPU_xStreamBufferBytesAvailableImpl, /* SYSTEM_CALL_xStreamBufferBytesAvailable. */
5048 ( UBaseType_t ) MPU_xStreamBufferSetTriggerLevelImpl, /* SYSTEM_CALL_xStreamBufferSetTriggerLevel. */
5049 ( UBaseType_t ) MPU_xStreamBufferNextMessageLengthBytesImpl /* SYSTEM_CALL_xStreamBufferNextMessageLengthBytes. */
5050 };
5051/*-----------------------------------------------------------*/
5052
5053#endif /* #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) ) */
5054/*-----------------------------------------------------------*/
configASSERT
#define configASSERT(x)
Definition FreeRTOSConfig.h:161
configUSE_TRACE_FACILITY
#define configUSE_TRACE_FACILITY
Definition FreeRTOSConfig.h:75
INCLUDE_xTaskDelayUntil
#define INCLUDE_xTaskDelayUntil
Definition FreeRTOSConfig.h:117
configMAX_PRIORITIES
#define configMAX_PRIORITIES
Definition FreeRTOSConfig.h:68
INCLUDE_xTaskGetSchedulerState
#define INCLUDE_xTaskGetSchedulerState
Definition FreeRTOSConfig.h:119
configUSE_TIMERS
#define configUSE_TIMERS
Definition FreeRTOSConfig.h:95
StaticQueue_t
struct xSTATIC_QUEUE StaticQueue_t
portPRIVILEGE_BIT
#define portPRIVILEGE_BIT
Definition FreeRTOS.h:857
traceSTREAM_BUFFER_CREATE_FAILED
#define traceSTREAM_BUFFER_CREATE_FAILED(xIsMessageBuffer)
Definition FreeRTOS.h:779
StaticStreamBuffer_t
struct xSTATIC_STREAM_BUFFER StaticStreamBuffer_t
vQueueAddToRegistry
#define vQueueAddToRegistry(xQueue, pcName)
Definition FreeRTOS.h:403
configTASK_NOTIFICATION_ARRAY_ENTRIES
#define configTASK_NOTIFICATION_ARRAY_ENTRIES
Definition FreeRTOS.h:953
traceSTREAM_BUFFER_CREATE_STATIC_FAILED
#define traceSTREAM_BUFFER_CREATE_STATIC_FAILED(xReturn, xIsMessageBuffer)
Definition FreeRTOS.h:783
StaticTimer_t
struct xSTATIC_TIMER StaticTimer_t
configRUN_TIME_COUNTER_TYPE
#define configRUN_TIME_COUNTER_TYPE
Definition FreeRTOS.h:1006
configGENERATE_RUN_TIME_STATS
#define configGENERATE_RUN_TIME_STATS
Definition FreeRTOS.h:831
configSTACK_DEPTH_TYPE
#define configSTACK_DEPTH_TYPE
Definition FreeRTOS.h:998
pcQueueGetName
#define pcQueueGetName(xQueue)
Definition FreeRTOS.h:405
StaticTask_t
struct xSTATIC_TCB StaticTask_t
vQueueUnregisterQueue
#define vQueueUnregisterQueue(xQueue)
Definition FreeRTOS.h:404
StaticEventGroup_t
struct xSTATIC_EVENT_GROUP StaticEventGroup_t
xEventGroupWaitBits
EventBits_t xEventGroupWaitBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait)
Definition event_groups.c:302
vEventGroupDelete
void vEventGroupDelete(EventGroupHandle_t xEventGroup)
event_groups.h
Definition event_groups.c:614
xEventGroupClearBits
EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear)
Definition event_groups.c:458
xEventGroupSetBits
EventBits_t xEventGroupSetBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet)
Definition event_groups.c:518
xEventGroupSync
EventBits_t xEventGroupSync(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait)
Definition event_groups.c:179
xEventGroupGetBitsFromISR
EventBits_t xEventGroupGetBitsFromISR(EventGroupHandle_t xEventGroup)
Definition event_groups.c:502
event_groups.h
xEventGroupClearBitsFromISR
#define xEventGroupClearBitsFromISR(xEventGroup, uxBitsToClear)
Definition event_groups.h:447
eventEVENT_BITS_CONTROL_BYTES
#define eventEVENT_BITS_CONTROL_BYTES
Definition event_groups.h:46
xEventGroupSetBitsFromISR
#define xEventGroupSetBitsFromISR(xEventGroup, uxBitsToSet, pxHigherPriorityTaskWoken)
Definition event_groups.h:603
EventBits_t
TickType_t EventBits_t
Definition event_groups.h:113
EventGroupHandle_t
struct EventGroupDef_t * EventGroupHandle_t
Definition event_groups.h:103
NULL
#define NULL
Definition usbd_def.h:44
mpu_prototypes.h
MPU_uxTaskPriorityGetFromISR
UBaseType_t MPU_uxTaskPriorityGetFromISR(const TaskHandle_t xTask) PRIVILEGED_FUNCTION
MPU_xQueueCreateMutexStatic
QueueHandle_t MPU_xQueueCreateMutexStatic(const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue) PRIVILEGED_FUNCTION
MPU_xTaskGenericNotifyEntry
BaseType_t MPU_xTaskGenericNotifyEntry(const xTaskGenericNotifyParams_t *pxParams) FREERTOS_SYSTEM_CALL
MPU_xQueueGenericCreate
QueueHandle_t MPU_xQueueGenericCreate(const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType) PRIVILEGED_FUNCTION
xTaskGenericNotifyWaitParams_t
struct xTaskGenericNotifyWaitParams xTaskGenericNotifyWaitParams_t
MPU_vEventGroupDelete
void MPU_vEventGroupDelete(EventGroupHandle_t xEventGroup) PRIVILEGED_FUNCTION
MPU_vTaskGenericNotifyGiveFromISR
void MPU_vTaskGenericNotifyGiveFromISR(TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
MPU_xQueueGenericSendFromISR
BaseType_t MPU_xQueueGenericSendFromISR(QueueHandle_t xQueue, const void *const pvItemToQueue, BaseType_t *const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition) PRIVILEGED_FUNCTION
MPU_xTaskGenericNotifyFromISR
BaseType_t MPU_xTaskGenericNotifyFromISR(TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
MPU_xQueueRemoveFromSet
BaseType_t MPU_xQueueRemoveFromSet(QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION
MPU_xTaskGetApplicationTaskTagFromISR
TaskHookFunction_t MPU_xTaskGetApplicationTaskTagFromISR(TaskHandle_t xTask) PRIVILEGED_FUNCTION
MPU_xStreamBufferGenericCreateStatic
StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic(size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xStreamBufferType, uint8_t *const pucStreamBufferStorageArea, StaticStreamBuffer_t *const pxStaticStreamBuffer, StreamBufferCallbackFunction_t pxSendCompletedCallback, StreamBufferCallbackFunction_t pxReceiveCompletedCallback) PRIVILEGED_FUNCTION
MPU_vTaskDelete
void MPU_vTaskDelete(TaskHandle_t xTaskToDelete) PRIVILEGED_FUNCTION
xTimerGenericCommandParams_t
struct xTimerGenericCommandParams xTimerGenericCommandParams_t
MPU_xEventGroupGetBitsFromISR
EventBits_t MPU_xEventGroupGetBitsFromISR(EventGroupHandle_t xEventGroup) PRIVILEGED_FUNCTION
MPU_xTaskGenericNotifyWaitEntry
BaseType_t MPU_xTaskGenericNotifyWaitEntry(const xTaskGenericNotifyWaitParams_t *pxParams) FREERTOS_SYSTEM_CALL
MPU_xQueueGenericCreateStatic
QueueHandle_t MPU_xQueueGenericCreateStatic(const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType) PRIVILEGED_FUNCTION
MPU_xStreamBufferReceiveFromISR
size_t MPU_xStreamBufferReceiveFromISR(StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
MPU_xQueueGiveFromISR
BaseType_t MPU_xQueueGiveFromISR(QueueHandle_t xQueue, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
xEventGroupWaitBitsParams_t
struct xEventGroupWaitBitsParams xEventGroupWaitBitsParams_t
MPU_xQueueIsQueueFullFromISR
BaseType_t MPU_xQueueIsQueueFullFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
MPU_xEventGroupCreate
EventGroupHandle_t MPU_xEventGroupCreate(void) PRIVILEGED_FUNCTION
MPU_xQueueCreateCountingSemaphoreStatic
QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic(const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue) PRIVILEGED_FUNCTION
MPU_xTimerCreateStatic
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) PRIVILEGED_FUNCTION
MPU_vTaskPrioritySet
void MPU_vTaskPrioritySet(TaskHandle_t xTask, UBaseType_t uxNewPriority) PRIVILEGED_FUNCTION
MPU_xTaskGenericNotify
BaseType_t MPU_xTaskGenericNotify(TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue) FREERTOS_SYSTEM_CALL
MPU_vQueueDelete
void MPU_vQueueDelete(QueueHandle_t xQueue) PRIVILEGED_FUNCTION
MPU_xTaskGenericNotifyWait
BaseType_t MPU_xTaskGenericNotifyWait(UBaseType_t uxIndexToWaitOn, uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL
MPU_xTimerGenericCommandEntry
BaseType_t MPU_xTimerGenericCommandEntry(const xTimerGenericCommandParams_t *pxParams) FREERTOS_SYSTEM_CALL
MPU_xEventGroupSetBitsFromISR
BaseType_t MPU_xEventGroupSetBitsFromISR(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
MPU_xTaskResumeFromISR
BaseType_t MPU_xTaskResumeFromISR(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION
MPU_xStreamBufferReceiveCompletedFromISR
BaseType_t MPU_xStreamBufferReceiveCompletedFromISR(StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
MPU_xQueueCreateSet
QueueSetHandle_t MPU_xQueueCreateSet(const UBaseType_t uxEventQueueLength) PRIVILEGED_FUNCTION
MPU_xTaskGetStaticBuffers
BaseType_t MPU_xTaskGetStaticBuffers(TaskHandle_t xTask, StackType_t **ppuxStackBuffer, StaticTask_t **ppxTaskBuffer) PRIVILEGED_FUNCTION
MPU_xQueueGenericGetStaticBuffers
BaseType_t MPU_xQueueGenericGetStaticBuffers(QueueHandle_t xQueue, uint8_t **ppucQueueStorage, StaticQueue_t **ppxStaticQueue) PRIVILEGED_FUNCTION
MPU_xStreamBufferGetStaticBuffers
BaseType_t MPU_xStreamBufferGetStaticBuffers(StreamBufferHandle_t xStreamBuffers, uint8_t *ppucStreamBufferStorageArea, StaticStreamBuffer_t *ppxStaticStreamBuffer) PRIVILEGED_FUNCTION
MPU_xTaskCreate
BaseType_t MPU_xTaskCreate(TaskFunction_t pxTaskCode, const char *const pcName, const uint16_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority, TaskHandle_t *const pxCreatedTask) PRIVILEGED_FUNCTION
MPU_xStreamBufferGenericCreate
StreamBufferHandle_t MPU_xStreamBufferGenericCreate(size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xStreamBufferType, StreamBufferCallbackFunction_t pxSendCompletedCallback, StreamBufferCallbackFunction_t pxReceiveCompletedCallback) PRIVILEGED_FUNCTION
MPU_xStreamBufferSendCompletedFromISR
BaseType_t MPU_xStreamBufferSendCompletedFromISR(StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
MPU_xQueuePeekFromISR
BaseType_t MPU_xQueuePeekFromISR(QueueHandle_t xQueue, void *const pvBuffer) PRIVILEGED_FUNCTION
MPU_xEventGroupGetStaticBuffer
BaseType_t MPU_xEventGroupGetStaticBuffer(EventGroupHandle_t xEventGroup, StaticEventGroup_t **ppxEventGroupBuffer) PRIVILEGED_FUNCTION
MPU_xQueueGenericReset
BaseType_t MPU_xQueueGenericReset(QueueHandle_t xQueue, BaseType_t xNewQueue) PRIVILEGED_FUNCTION
MPU_xQueueCreateCountingSemaphore
QueueHandle_t MPU_xQueueCreateCountingSemaphore(const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount) PRIVILEGED_FUNCTION
MPU_xQueueSelectFromSetFromISR
QueueSetMemberHandle_t MPU_xQueueSelectFromSetFromISR(QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION
MPU_xEventGroupWaitBitsEntry
EventBits_t MPU_xEventGroupWaitBitsEntry(const xEventGroupWaitBitsParams_t *pxParams) FREERTOS_SYSTEM_CALL
MPU_xTaskCreateRestrictedStatic
BaseType_t MPU_xTaskCreateRestrictedStatic(const TaskParameters_t *const pxTaskDefinition, TaskHandle_t *pxCreatedTask) PRIVILEGED_FUNCTION
vTaskAllocateMPURegions
void vTaskAllocateMPURegions(TaskHandle_t xTaskToModify, const MemoryRegion_t *const xRegions) PRIVILEGED_FUNCTION
MPU_xQueueIsQueueEmptyFromISR
BaseType_t MPU_xQueueIsQueueEmptyFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
xTaskGenericNotifyParams_t
struct xTaskGenericNotifyParams xTaskGenericNotifyParams_t
MPU_xEventGroupCreateStatic
EventGroupHandle_t MPU_xEventGroupCreateStatic(StaticEventGroup_t *pxEventGroupBuffer) PRIVILEGED_FUNCTION
MPU_xTaskCallApplicationTaskHook
BaseType_t MPU_xTaskCallApplicationTaskHook(TaskHandle_t xTask, void *pvParameter) PRIVILEGED_FUNCTION
MPU_xQueueGetMutexHolderFromISR
TaskHandle_t MPU_xQueueGetMutexHolderFromISR(QueueHandle_t xSemaphore) PRIVILEGED_FUNCTION
MPU_xEventGroupClearBitsFromISR
BaseType_t MPU_xEventGroupClearBitsFromISR(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear) PRIVILEGED_FUNCTION
MPU_xStreamBufferReset
BaseType_t MPU_xStreamBufferReset(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
MPU_uxQueueMessagesWaitingFromISR
UBaseType_t MPU_uxQueueMessagesWaitingFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
MPU_vStreamBufferDelete
void MPU_vStreamBufferDelete(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
MPU_xTaskCreateRestricted
BaseType_t MPU_xTaskCreateRestricted(const TaskParameters_t *const pxTaskDefinition, TaskHandle_t *pxCreatedTask) PRIVILEGED_FUNCTION
MPU_xStreamBufferSendFromISR
size_t MPU_xStreamBufferSendFromISR(StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
MPU_xTaskCreateStatic
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) PRIVILEGED_FUNCTION
MPU_xQueueReceiveFromISR
BaseType_t MPU_xQueueReceiveFromISR(QueueHandle_t xQueue, void *const pvBuffer, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
MPU_xTimerGetStaticBuffer
BaseType_t MPU_xTimerGetStaticBuffer(TimerHandle_t xTimer, StaticTimer_t **ppxTimerBuffer) PRIVILEGED_FUNCTION
MPU_xQueueCreateMutex
QueueHandle_t MPU_xQueueCreateMutex(const uint8_t ucQueueType) PRIVILEGED_FUNCTION
MPU_xEventGroupWaitBits
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
MPU_xTimerCreate
TimerHandle_t MPU_xTimerCreate(const char *const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void *const pvTimerID, TimerCallbackFunction_t pxCallbackFunction) PRIVILEGED_FUNCTION
MPU_xTimerGenericCommand
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
MPU_xTaskGetHandle
TaskHandle_t MPU_xTaskGetHandle(const char *pcNameToQuery) PRIVILEGED_FUNCTION
mpu_syscall_numbers.h
NUM_SYSTEM_CALLS
#define NUM_SYSTEM_CALLS
Definition mpu_syscall_numbers.h:104
PRIVILEGED_FUNCTION
#define PRIVILEGED_FUNCTION
Definition mpu_wrappers.h:290
PRIVILEGED_DATA
#define PRIVILEGED_DATA
Definition mpu_wrappers.h:291
BaseType_t
long BaseType_t
Definition portmacro.h:59
UBaseType_t
unsigned long UBaseType_t
Definition portmacro.h:60
TickType_t
uint16_t TickType_t
Definition portmacro.h:63
StackType_t
portSTACK_TYPE StackType_t
Definition portmacro.h:58
pdPASS
#define pdPASS
Definition projdefs.h:52
pdFAIL
#define pdFAIL
Definition projdefs.h:53
TaskFunction_t
void(* TaskFunction_t)(void *)
Definition projdefs.h:36
pdFALSE
#define pdFALSE
Definition projdefs.h:45
pdTRUE
#define pdTRUE
Definition projdefs.h:46
xQueueSemaphoreTake
BaseType_t xQueueSemaphoreTake(QueueHandle_t xQueue, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
Definition queue.c:1570
QueueSetHandle_t
struct QueueDefinition * QueueSetHandle_t
Type by which queue sets are referenced.
Definition queue.h:58
xQueueGenericSendFromISR
BaseType_t xQueueGenericSendFromISR(QueueHandle_t xQueue, const void *const pvItemToQueue, BaseType_t *const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition) PRIVILEGED_FUNCTION
Definition queue.c:1096
xQueueGenericReset
BaseType_t xQueueGenericReset(QueueHandle_t xQueue, BaseType_t xNewQueue) PRIVILEGED_FUNCTION
Definition queue.c:296
uxQueueMessagesWaitingFromISR
UBaseType_t uxQueueMessagesWaitingFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition queue.c:2112
xQueuePeek
BaseType_t xQueuePeek(QueueHandle_t xQueue, void *const pvBuffer, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
Definition queue.c:1780
xQueueGiveMutexRecursive
BaseType_t xQueueGiveMutexRecursive(QueueHandle_t xMutex) PRIVILEGED_FUNCTION
QueueHandle_t
struct QueueDefinition * QueueHandle_t
Definition queue.h:51
queueOVERWRITE
#define queueOVERWRITE
Definition queue.h:70
xQueueCreateCountingSemaphoreStatic
QueueHandle_t xQueueCreateCountingSemaphoreStatic(const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue) PRIVILEGED_FUNCTION
vQueueDelete
void vQueueDelete(QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition queue.c:2124
xQueueSelectFromSet
QueueSetMemberHandle_t xQueueSelectFromSet(QueueSetHandle_t xQueueSet, const TickType_t xTicksToWait) PRIVILEGED_FUNCTION
xQueueTakeMutexRecursive
BaseType_t xQueueTakeMutexRecursive(QueueHandle_t xMutex, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
xQueueGenericSend
BaseType_t xQueueGenericSend(QueueHandle_t xQueue, const void *const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition) PRIVILEGED_FUNCTION
Definition queue.c:884
xQueueIsQueueFullFromISR
BaseType_t xQueueIsQueueFullFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition queue.c:2522
xQueueIsQueueEmptyFromISR
BaseType_t xQueueIsQueueEmptyFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition queue.c:2481
uxQueueSpacesAvailable
UBaseType_t uxQueueSpacesAvailable(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition queue.c:2095
xQueueRemoveFromSet
BaseType_t xQueueRemoveFromSet(QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION
uxQueueGetQueueLength
UBaseType_t uxQueueGetQueueLength(QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition queue.c:2203
xQueuePeekFromISR
BaseType_t xQueuePeekFromISR(QueueHandle_t xQueue, void *const pvBuffer) PRIVILEGED_FUNCTION
Definition queue.c:2024
xQueueGetMutexHolder
TaskHandle_t xQueueGetMutexHolder(QueueHandle_t xSemaphore) PRIVILEGED_FUNCTION
xQueueSelectFromSetFromISR
QueueSetMemberHandle_t xQueueSelectFromSetFromISR(QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION
xQueueCreateCountingSemaphore
QueueHandle_t xQueueCreateCountingSemaphore(const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount) PRIVILEGED_FUNCTION
xQueueCreateMutex
QueueHandle_t xQueueCreateMutex(const uint8_t ucQueueType) PRIVILEGED_FUNCTION
xQueueReceiveFromISR
BaseType_t xQueueReceiveFromISR(QueueHandle_t xQueue, void *const pvBuffer, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
Definition queue.c:1931
xQueueGiveFromISR
BaseType_t xQueueGiveFromISR(QueueHandle_t xQueue, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
Definition queue.c:1261
xQueueCreateSet
QueueSetHandle_t xQueueCreateSet(const UBaseType_t uxEventQueueLength) PRIVILEGED_FUNCTION
uxQueueMessagesWaiting
UBaseType_t uxQueueMessagesWaiting(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition queue.c:2079
xQueueAddToSet
BaseType_t xQueueAddToSet(QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION
xQueueReceive
BaseType_t xQueueReceive(QueueHandle_t xQueue, void *const pvBuffer, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
Definition queue.c:1427
uxQueueGetQueueItemSize
UBaseType_t uxQueueGetQueueItemSize(QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition queue.c:2197
xQueueCreateMutexStatic
QueueHandle_t xQueueCreateMutexStatic(const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue) PRIVILEGED_FUNCTION
QueueSetMemberHandle_t
struct QueueDefinition * QueueSetMemberHandle_t
Queue sets can contain both queues and semaphores, so the QueueSetMemberHandle_t is defined as a type...
Definition queue.h:65
stream_buffer.h
vStreamBufferDelete
void vStreamBufferDelete(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
Definition stream_buffer.c:505
xStreamBufferGenericCreateStatic
StreamBufferHandle_t xStreamBufferGenericCreateStatic(size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer, uint8_t *const pucStreamBufferStorageArea, StaticStreamBuffer_t *const pxStaticStreamBuffer, StreamBufferCallbackFunction_t pxSendCompletedCallback, StreamBufferCallbackFunction_t pxReceiveCompletedCallback) PRIVILEGED_FUNCTION
xStreamBufferSendFromISR
size_t xStreamBufferSendFromISR(StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
Definition stream_buffer.c:801
xStreamBufferSetTriggerLevel
BaseType_t xStreamBufferSetTriggerLevel(StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel) PRIVILEGED_FUNCTION
Definition stream_buffer.c:595
xStreamBufferSend
size_t xStreamBufferSend(StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
Definition stream_buffer.c:670
StreamBufferCallbackFunction_t
void(* StreamBufferCallbackFunction_t)(StreamBufferHandle_t xStreamBuffer, BaseType_t xIsInsideISR, BaseType_t *const pxHigherPriorityTaskWoken)
Type used as a stream buffer's optional callback.
Definition stream_buffer.h:77
xStreamBufferReset
BaseType_t xStreamBufferReset(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
Definition stream_buffer.c:538
xStreamBufferReceive
size_t xStreamBufferReceive(StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
Definition stream_buffer.c:902
xStreamBufferReceiveFromISR
size_t xStreamBufferReceiveFromISR(StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
Definition stream_buffer.c:1046
StreamBufferHandle_t
struct StreamBufferDef_t * StreamBufferHandle_t
Definition stream_buffer.h:72
xStreamBufferGenericCreate
StreamBufferHandle_t xStreamBufferGenericCreate(size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer, StreamBufferCallbackFunction_t pxSendCompletedCallback, StreamBufferCallbackFunction_t pxReceiveCompletedCallback) PRIVILEGED_FUNCTION
xStreamBufferSpacesAvailable
size_t xStreamBufferSpacesAvailable(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
Definition stream_buffer.c:625
xStreamBufferNextMessageLengthBytes
size_t xStreamBufferNextMessageLengthBytes(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
Definition stream_buffer.c:1006
xStreamBufferSendCompletedFromISR
BaseType_t xStreamBufferSendCompletedFromISR(StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
Definition stream_buffer.c:1214
xStreamBufferReceiveCompletedFromISR
BaseType_t xStreamBufferReceiveCompletedFromISR(StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
Definition stream_buffer.c:1245
xStreamBufferIsFull
BaseType_t xStreamBufferIsFull(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
Definition stream_buffer.c:1179
xStreamBufferBytesAvailable
size_t xStreamBufferBytesAvailable(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
Definition stream_buffer.c:658
xStreamBufferIsEmpty
BaseType_t xStreamBufferIsEmpty(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION
Definition stream_buffer.c:1155
xEventGroupWaitBitsParams::xEventGroup
EventGroupHandle_t xEventGroup
Definition mpu_prototypes.h:70
xTASK_PARAMETERS::uxPriority
UBaseType_t uxPriority
Definition task.h:149
xTaskGenericNotifyParams::pulPreviousNotificationValue
uint32_t * pulPreviousNotificationValue
Definition mpu_prototypes.h:47
xTimerGenericCommandParams::pxHigherPriorityTaskWoken
BaseType_t * pxHigherPriorityTaskWoken
Definition mpu_prototypes.h:64
xTaskResumeAll
BaseType_t xTaskResumeAll(void) PRIVILEGED_FUNCTION
Definition tasks.c:2187
xTaskGetSchedulerState
BaseType_t xTaskGetSchedulerState(void) PRIVILEGED_FUNCTION
ulTaskGetRunTimeCounter
configRUN_TIME_COUNTER_TYPE ulTaskGetRunTimeCounter(const TaskHandle_t xTask) PRIVILEGED_FUNCTION
taskSCHEDULER_NOT_STARTED
#define taskSCHEDULER_NOT_STARTED
Definition task.h:257
taskSCHEDULER_SUSPENDED
#define taskSCHEDULER_SUSPENDED
Definition task.h:256
ulTaskGenericNotifyValueClear
uint32_t ulTaskGenericNotifyValueClear(TaskHandle_t xTask, UBaseType_t uxIndexToClear, uint32_t ulBitsToClear) PRIVILEGED_FUNCTION
eTaskState
eTaskState
Definition task.h:102
eInvalid
@ eInvalid
Definition task.h:108
uxTaskPriorityGet
UBaseType_t uxTaskPriorityGet(const TaskHandle_t xTask) PRIVILEGED_FUNCTION
vTaskPrioritySet
void vTaskPrioritySet(TaskHandle_t xTask, UBaseType_t uxNewPriority) PRIVILEGED_FUNCTION
TaskHandle_t
struct tskTaskControlBlock * TaskHandle_t
Definition task.h:92
ulTaskGetRunTimePercent
configRUN_TIME_COUNTER_TYPE ulTaskGetRunTimePercent(const TaskHandle_t xTask) PRIVILEGED_FUNCTION
vTaskDelete
void vTaskDelete(TaskHandle_t xTaskToDelete) PRIVILEGED_FUNCTION
vTaskSuspendAll
void vTaskSuspendAll(void) PRIVILEGED_FUNCTION
Definition tasks.c:2103
TaskParameters_t
struct xTASK_PARAMETERS TaskParameters_t
xTaskCheckForTimeOut
BaseType_t xTaskCheckForTimeOut(TimeOut_t *const pxTimeOut, TickType_t *const pxTicksToWait) PRIVILEGED_FUNCTION
Definition tasks.c:3366
xTaskGetIdleTaskHandle
TaskHandle_t xTaskGetIdleTaskHandle(void) PRIVILEGED_FUNCTION
xTaskGetIdleTaskHandle() is only available if INCLUDE_xTaskGetIdleTaskHandle is set to 1 in FreeRTOSC...
xTaskGetHandle
TaskHandle_t xTaskGetHandle(const char *pcNameToQuery) PRIVILEGED_FUNCTION
vTaskGenericNotifyGiveFromISR
void vTaskGenericNotifyGiveFromISR(TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
TimeOut_t
struct xTIME_OUT TimeOut_t
xTaskGenericNotifyFromISR
BaseType_t xTaskGenericNotifyFromISR(TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
vTaskSetTimeOutState
void vTaskSetTimeOutState(TimeOut_t *const pxTimeOut) PRIVILEGED_FUNCTION
Definition tasks.c:3346
uxTaskGetNumberOfTasks
UBaseType_t uxTaskGetNumberOfTasks(void) PRIVILEGED_FUNCTION
Definition tasks.c:2345
tskMPU_READ_PERMISSION
#define tskMPU_READ_PERMISSION
Definition task.h:71
xTaskGetTickCount
TickType_t xTaskGetTickCount(void) PRIVILEGED_FUNCTION
Definition tasks.c:2299
uxTaskPriorityGetFromISR
UBaseType_t uxTaskPriorityGetFromISR(const TaskHandle_t xTask) PRIVILEGED_FUNCTION
task.
uxTaskGetStackHighWaterMark
UBaseType_t uxTaskGetStackHighWaterMark(TaskHandle_t xTask) PRIVILEGED_FUNCTION
task.h
uxTaskGetStackHighWaterMark2
configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2(TaskHandle_t xTask) PRIVILEGED_FUNCTION
task.h
vTaskResume
void vTaskResume(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION
vTaskSuspend
void vTaskSuspend(TaskHandle_t xTaskToSuspend) PRIVILEGED_FUNCTION
ulTaskGetIdleRunTimeCounter
configRUN_TIME_COUNTER_TYPE ulTaskGetIdleRunTimeCounter(void) PRIVILEGED_FUNCTION
xTaskGetCurrentTaskHandle
TaskHandle_t xTaskGetCurrentTaskHandle(void) PRIVILEGED_FUNCTION
uxTaskGetSystemState
UBaseType_t uxTaskGetSystemState(TaskStatus_t *const pxTaskStatusArray, const UBaseType_t uxArraySize, configRUN_TIME_COUNTER_TYPE *const pulTotalRunTime) PRIVILEGED_FUNCTION
configUSE_TRACE_FACILITY must be defined as 1 in FreeRTOSConfig.h for uxTaskGetSystemState() to be av...
xTaskGenericNotifyStateClear
BaseType_t xTaskGenericNotifyStateClear(TaskHandle_t xTask, UBaseType_t uxIndexToClear) PRIVILEGED_FUNCTION
eTaskGetState
eTaskState eTaskGetState(TaskHandle_t xTask) PRIVILEGED_FUNCTION
task.
tskMPU_WRITE_PERMISSION
#define tskMPU_WRITE_PERMISSION
Definition task.h:72
vTaskDelay
void vTaskDelay(const TickType_t xTicksToDelay) PRIVILEGED_FUNCTION
xTaskGenericNotifyWait
BaseType_t xTaskGenericNotifyWait(UBaseType_t uxIndexToWaitOn, uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
ulTaskGenericNotifyTake
uint32_t ulTaskGenericNotifyTake(UBaseType_t uxIndexToWaitOn, BaseType_t xClearCountOnExit, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
taskEXIT_CRITICAL
#define taskEXIT_CRITICAL()
Definition task.h:230
xTaskCallApplicationTaskHook
BaseType_t xTaskCallApplicationTaskHook(TaskHandle_t xTask, void *pvParameter) PRIVILEGED_FUNCTION
task.h
taskENTER_CRITICAL
#define taskENTER_CRITICAL()
Definition task.h:215
ulTaskGetIdleRunTimePercent
configRUN_TIME_COUNTER_TYPE ulTaskGetIdleRunTimePercent(void) PRIVILEGED_FUNCTION
MemoryRegion_t
struct xMEMORY_REGION MemoryRegion_t
vTaskGetInfo
void vTaskGetInfo(TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState) PRIVILEGED_FUNCTION
xTaskGenericNotify
BaseType_t xTaskGenericNotify(TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue) PRIVILEGED_FUNCTION
TaskStatus_t
struct xTASK_STATUS TaskStatus_t
eNotifyAction
eNotifyAction
Definition task.h:113
eIncrement
@ eIncrement
Definition task.h:116
eSetValueWithOverwrite
@ eSetValueWithOverwrite
Definition task.h:117
eSetBits
@ eSetBits
Definition task.h:115
eNoAction
@ eNoAction
Definition task.h:114
eSetValueWithoutOverwrite
@ eSetValueWithoutOverwrite
Definition task.h:118
pcTaskGetName
char * pcTaskGetName(TaskHandle_t xTaskToQuery) PRIVILEGED_FUNCTION
Definition tasks.c:2353
xTaskResumeFromISR
BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION
xTaskDelayUntil
BaseType_t xTaskDelayUntil(TickType_t *const pxPreviousWakeTime, const TickType_t xTimeIncrement) PRIVILEGED_FUNCTION
TaskHookFunction_t
BaseType_t(* TaskHookFunction_t)(void *)
Definition task.h:98
xTaskAbortDelay
BaseType_t xTaskAbortDelay(TaskHandle_t xTask) PRIVILEGED_FUNCTION
xIdleTaskHandle
static PRIVILEGED_DATA TaskHandle_t xIdleTaskHandle
Holds the handle of the idle task.
Definition tasks.c:374
xTimerGetExpiryTime
TickType_t xTimerGetExpiryTime(TimerHandle_t xTimer) PRIVILEGED_FUNCTION
TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer );.
uxTimerGetReloadMode
UBaseType_t uxTimerGetReloadMode(TimerHandle_t xTimer) PRIVILEGED_FUNCTION
UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer );.
pvTimerGetTimerID
void * pvTimerGetTimerID(const TimerHandle_t xTimer) PRIVILEGED_FUNCTION
TimerHandle_t xTimerCreate( const char * const pcTimerName, TickType_t...
xTimerGetReloadMode
BaseType_t xTimerGetReloadMode(TimerHandle_t xTimer) PRIVILEGED_FUNCTION
BaseType_t xTimerGetReloadMode( TimerHandle_t xTimer );.
xTimerGenericCommand
BaseType_t xTimerGenericCommand(TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t *const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait) PRIVILEGED_FUNCTION
vTimerSetTimerID
void vTimerSetTimerID(TimerHandle_t xTimer, void *pvNewID) PRIVILEGED_FUNCTION
void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID );
xTimerGetPeriod
TickType_t xTimerGetPeriod(TimerHandle_t xTimer) PRIVILEGED_FUNCTION
TickType_t xTimerGetPeriod( TimerHandle_t xTimer );.
xTimerIsTimerActive
BaseType_t xTimerIsTimerActive(TimerHandle_t xTimer) PRIVILEGED_FUNCTION
BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer );.
pcTimerGetName
const char * pcTimerGetName(TimerHandle_t xTimer) PRIVILEGED_FUNCTION
const char * const pcTimerGetName( TimerHandle_t xTimer );
vTimerSetReloadMode
void vTimerSetReloadMode(TimerHandle_t xTimer, const BaseType_t xAutoReload) PRIVILEGED_FUNCTION
void vTimerSetReloadMode( TimerHandle_t xTimer, const BaseType_t xAutoReload );
TimerCallbackFunction_t
void(* TimerCallbackFunction_t)(TimerHandle_t xTimer)
Definition timers.h:85
xTimerGetTimerDaemonTaskHandle
TaskHandle_t xTimerGetTimerDaemonTaskHandle(void) PRIVILEGED_FUNCTION
TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );.
TimerHandle_t
struct tmrTimerControl * TimerHandle_t
Definition timers.h:80