1 /* 2 * FreeRTOS Kernel <DEVELOPMENT BRANCH> 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 48 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE 49 /*-----------------------------------------------------------*/ 50 51 #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) ) 52 53 #if ( configENABLE_ACCESS_CONTROL_LIST == 1 ) 54 #error Access control list is not available with this MPU wrapper. Please set configENABLE_ACCESS_CONTROL_LIST to 0. 55 #endif 56 57 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) MPU_xTaskCreate(TaskFunction_t pvTaskCode,const char * const pcName,const configSTACK_DEPTH_TYPE uxStackDepth,void * pvParameters,UBaseType_t uxPriority,TaskHandle_t * pxCreatedTask)58 BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode, 59 const char * const pcName, 60 const configSTACK_DEPTH_TYPE uxStackDepth, 61 void * pvParameters, 62 UBaseType_t uxPriority, 63 TaskHandle_t * pxCreatedTask ) /* FREERTOS_SYSTEM_CALL */ 64 { 65 BaseType_t xReturn; 66 67 if( portIS_PRIVILEGED() == pdFALSE ) 68 { 69 portRAISE_PRIVILEGE(); 70 portMEMORY_BARRIER(); 71 72 uxPriority = uxPriority & ~( portPRIVILEGE_BIT ); 73 portMEMORY_BARRIER(); 74 75 xReturn = xTaskCreate( pvTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, pxCreatedTask ); 76 portMEMORY_BARRIER(); 77 78 portRESET_PRIVILEGE(); 79 portMEMORY_BARRIER(); 80 } 81 else 82 { 83 xReturn = xTaskCreate( pvTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, pxCreatedTask ); 84 } 85 86 return xReturn; 87 } 88 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */ 89 /*-----------------------------------------------------------*/ 90 91 #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) MPU_xTaskCreateStatic(TaskFunction_t pxTaskCode,const char * const pcName,const configSTACK_DEPTH_TYPE uxStackDepth,void * const pvParameters,UBaseType_t uxPriority,StackType_t * const puxStackBuffer,StaticTask_t * const pxTaskBuffer)92 TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode, 93 const char * const pcName, 94 const configSTACK_DEPTH_TYPE uxStackDepth, 95 void * const pvParameters, 96 UBaseType_t uxPriority, 97 StackType_t * const puxStackBuffer, 98 StaticTask_t * const pxTaskBuffer ) /* FREERTOS_SYSTEM_CALL */ 99 { 100 TaskHandle_t xReturn; 101 102 if( portIS_PRIVILEGED() == pdFALSE ) 103 { 104 portRAISE_PRIVILEGE(); 105 portMEMORY_BARRIER(); 106 107 uxPriority = uxPriority & ~( portPRIVILEGE_BIT ); 108 portMEMORY_BARRIER(); 109 110 xReturn = xTaskCreateStatic( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer ); 111 portMEMORY_BARRIER(); 112 113 portRESET_PRIVILEGE(); 114 portMEMORY_BARRIER(); 115 } 116 else 117 { 118 xReturn = xTaskCreateStatic( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer ); 119 } 120 121 return xReturn; 122 } 123 #endif /* configSUPPORT_STATIC_ALLOCATION */ 124 /*-----------------------------------------------------------*/ 125 126 #if ( INCLUDE_vTaskDelete == 1 ) MPU_vTaskDelete(TaskHandle_t pxTaskToDelete)127 void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete ) /* FREERTOS_SYSTEM_CALL */ 128 { 129 if( portIS_PRIVILEGED() == pdFALSE ) 130 { 131 portRAISE_PRIVILEGE(); 132 portMEMORY_BARRIER(); 133 134 vTaskDelete( pxTaskToDelete ); 135 portMEMORY_BARRIER(); 136 137 portRESET_PRIVILEGE(); 138 portMEMORY_BARRIER(); 139 } 140 else 141 { 142 vTaskDelete( pxTaskToDelete ); 143 } 144 } 145 #endif /* if ( INCLUDE_vTaskDelete == 1 ) */ 146 /*-----------------------------------------------------------*/ 147 148 #if ( INCLUDE_xTaskDelayUntil == 1 ) MPU_xTaskDelayUntil(TickType_t * const pxPreviousWakeTime,TickType_t xTimeIncrement)149 BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime, 150 TickType_t xTimeIncrement ) /* FREERTOS_SYSTEM_CALL */ 151 { 152 BaseType_t xReturn; 153 154 if( portIS_PRIVILEGED() == pdFALSE ) 155 { 156 portRAISE_PRIVILEGE(); 157 portMEMORY_BARRIER(); 158 159 xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement ); 160 portMEMORY_BARRIER(); 161 162 portRESET_PRIVILEGE(); 163 portMEMORY_BARRIER(); 164 } 165 else 166 { 167 xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement ); 168 } 169 170 return xReturn; 171 } 172 #endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */ 173 /*-----------------------------------------------------------*/ 174 175 #if ( INCLUDE_xTaskAbortDelay == 1 ) MPU_xTaskAbortDelay(TaskHandle_t xTask)176 BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */ 177 { 178 BaseType_t xReturn; 179 180 if( portIS_PRIVILEGED() == pdFALSE ) 181 { 182 portRAISE_PRIVILEGE(); 183 portMEMORY_BARRIER(); 184 185 xReturn = xTaskAbortDelay( xTask ); 186 portMEMORY_BARRIER(); 187 188 portRESET_PRIVILEGE(); 189 portMEMORY_BARRIER(); 190 } 191 else 192 { 193 xReturn = xTaskAbortDelay( xTask ); 194 } 195 196 return xReturn; 197 } 198 #endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */ 199 /*-----------------------------------------------------------*/ 200 201 #if ( INCLUDE_vTaskDelay == 1 ) MPU_vTaskDelay(TickType_t xTicksToDelay)202 void MPU_vTaskDelay( TickType_t xTicksToDelay ) /* FREERTOS_SYSTEM_CALL */ 203 { 204 if( portIS_PRIVILEGED() == pdFALSE ) 205 { 206 portRAISE_PRIVILEGE(); 207 portMEMORY_BARRIER(); 208 209 vTaskDelay( xTicksToDelay ); 210 portMEMORY_BARRIER(); 211 212 portRESET_PRIVILEGE(); 213 portMEMORY_BARRIER(); 214 } 215 else 216 { 217 vTaskDelay( xTicksToDelay ); 218 } 219 } 220 #endif /* if ( INCLUDE_vTaskDelay == 1 ) */ 221 /*-----------------------------------------------------------*/ 222 223 #if ( INCLUDE_uxTaskPriorityGet == 1 ) MPU_uxTaskPriorityGet(const TaskHandle_t pxTask)224 UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */ 225 { 226 UBaseType_t uxReturn; 227 228 if( portIS_PRIVILEGED() == pdFALSE ) 229 { 230 portRAISE_PRIVILEGE(); 231 portMEMORY_BARRIER(); 232 233 uxReturn = uxTaskPriorityGet( pxTask ); 234 portMEMORY_BARRIER(); 235 236 portRESET_PRIVILEGE(); 237 portMEMORY_BARRIER(); 238 } 239 else 240 { 241 uxReturn = uxTaskPriorityGet( pxTask ); 242 } 243 244 return uxReturn; 245 } 246 #endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */ 247 /*-----------------------------------------------------------*/ 248 249 #if ( INCLUDE_vTaskPrioritySet == 1 ) MPU_vTaskPrioritySet(TaskHandle_t pxTask,UBaseType_t uxNewPriority)250 void MPU_vTaskPrioritySet( TaskHandle_t pxTask, 251 UBaseType_t uxNewPriority ) /* FREERTOS_SYSTEM_CALL */ 252 { 253 if( portIS_PRIVILEGED() == pdFALSE ) 254 { 255 portRAISE_PRIVILEGE(); 256 portMEMORY_BARRIER(); 257 258 vTaskPrioritySet( pxTask, uxNewPriority ); 259 portMEMORY_BARRIER(); 260 261 portRESET_PRIVILEGE(); 262 portMEMORY_BARRIER(); 263 } 264 else 265 { 266 vTaskPrioritySet( pxTask, uxNewPriority ); 267 } 268 } 269 #endif /* if ( INCLUDE_vTaskPrioritySet == 1 ) */ 270 /*-----------------------------------------------------------*/ 271 272 #if ( INCLUDE_eTaskGetState == 1 ) MPU_eTaskGetState(TaskHandle_t pxTask)273 eTaskState MPU_eTaskGetState( TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */ 274 { 275 eTaskState eReturn; 276 277 if( portIS_PRIVILEGED() == pdFALSE ) 278 { 279 portRAISE_PRIVILEGE(); 280 portMEMORY_BARRIER(); 281 282 eReturn = eTaskGetState( pxTask ); 283 portMEMORY_BARRIER(); 284 285 portRESET_PRIVILEGE(); 286 portMEMORY_BARRIER(); 287 } 288 else 289 { 290 eReturn = eTaskGetState( pxTask ); 291 } 292 293 return eReturn; 294 } 295 #endif /* if ( INCLUDE_eTaskGetState == 1 ) */ 296 /*-----------------------------------------------------------*/ 297 298 #if ( configUSE_TRACE_FACILITY == 1 ) MPU_vTaskGetInfo(TaskHandle_t xTask,TaskStatus_t * pxTaskStatus,BaseType_t xGetFreeStackSpace,eTaskState eState)299 void MPU_vTaskGetInfo( TaskHandle_t xTask, 300 TaskStatus_t * pxTaskStatus, 301 BaseType_t xGetFreeStackSpace, 302 eTaskState eState ) /* FREERTOS_SYSTEM_CALL */ 303 { 304 if( portIS_PRIVILEGED() == pdFALSE ) 305 { 306 portRAISE_PRIVILEGE(); 307 portMEMORY_BARRIER(); 308 309 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState ); 310 portMEMORY_BARRIER(); 311 312 portRESET_PRIVILEGE(); 313 portMEMORY_BARRIER(); 314 } 315 else 316 { 317 vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState ); 318 } 319 } 320 #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */ 321 /*-----------------------------------------------------------*/ 322 323 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) MPU_xTaskGetIdleTaskHandle(void)324 TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */ 325 { 326 TaskHandle_t xReturn; 327 328 if( portIS_PRIVILEGED() == pdFALSE ) 329 { 330 portRAISE_PRIVILEGE(); 331 portMEMORY_BARRIER(); 332 xReturn = xTaskGetIdleTaskHandle(); 333 portMEMORY_BARRIER(); 334 335 portRESET_PRIVILEGE(); 336 portMEMORY_BARRIER(); 337 } 338 else 339 { 340 xReturn = xTaskGetIdleTaskHandle(); 341 } 342 343 return xReturn; 344 } 345 #endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */ 346 /*-----------------------------------------------------------*/ 347 348 #if ( INCLUDE_vTaskSuspend == 1 ) MPU_vTaskSuspend(TaskHandle_t pxTaskToSuspend)349 void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend ) /* FREERTOS_SYSTEM_CALL */ 350 { 351 if( portIS_PRIVILEGED() == pdFALSE ) 352 { 353 portRAISE_PRIVILEGE(); 354 portMEMORY_BARRIER(); 355 356 vTaskSuspend( pxTaskToSuspend ); 357 portMEMORY_BARRIER(); 358 359 portRESET_PRIVILEGE(); 360 portMEMORY_BARRIER(); 361 } 362 else 363 { 364 vTaskSuspend( pxTaskToSuspend ); 365 } 366 } 367 #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */ 368 /*-----------------------------------------------------------*/ 369 370 #if ( INCLUDE_vTaskSuspend == 1 ) MPU_vTaskResume(TaskHandle_t pxTaskToResume)371 void MPU_vTaskResume( TaskHandle_t pxTaskToResume ) /* FREERTOS_SYSTEM_CALL */ 372 { 373 if( portIS_PRIVILEGED() == pdFALSE ) 374 { 375 portRAISE_PRIVILEGE(); 376 portMEMORY_BARRIER(); 377 378 vTaskResume( pxTaskToResume ); 379 portMEMORY_BARRIER(); 380 381 portRESET_PRIVILEGE(); 382 portMEMORY_BARRIER(); 383 } 384 else 385 { 386 vTaskResume( pxTaskToResume ); 387 } 388 } 389 #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */ 390 /*-----------------------------------------------------------*/ 391 MPU_vTaskSuspendAll(void)392 void MPU_vTaskSuspendAll( void ) /* FREERTOS_SYSTEM_CALL */ 393 { 394 if( portIS_PRIVILEGED() == pdFALSE ) 395 { 396 portRAISE_PRIVILEGE(); 397 portMEMORY_BARRIER(); 398 399 vTaskSuspendAll(); 400 portMEMORY_BARRIER(); 401 402 portRESET_PRIVILEGE(); 403 portMEMORY_BARRIER(); 404 } 405 else 406 { 407 vTaskSuspendAll(); 408 } 409 } 410 /*-----------------------------------------------------------*/ 411 MPU_xTaskResumeAll(void)412 BaseType_t MPU_xTaskResumeAll( void ) /* FREERTOS_SYSTEM_CALL */ 413 { 414 BaseType_t xReturn; 415 416 if( portIS_PRIVILEGED() == pdFALSE ) 417 { 418 portRAISE_PRIVILEGE(); 419 portMEMORY_BARRIER(); 420 421 xReturn = xTaskResumeAll(); 422 portMEMORY_BARRIER(); 423 424 portRESET_PRIVILEGE(); 425 portMEMORY_BARRIER(); 426 } 427 else 428 { 429 xReturn = xTaskResumeAll(); 430 } 431 432 return xReturn; 433 } 434 /*-----------------------------------------------------------*/ 435 MPU_xTaskGetTickCount(void)436 TickType_t MPU_xTaskGetTickCount( void ) /* FREERTOS_SYSTEM_CALL */ 437 { 438 TickType_t xReturn; 439 440 if( portIS_PRIVILEGED() == pdFALSE ) 441 { 442 portRAISE_PRIVILEGE(); 443 portMEMORY_BARRIER(); 444 445 xReturn = xTaskGetTickCount(); 446 portMEMORY_BARRIER(); 447 448 portRESET_PRIVILEGE(); 449 portMEMORY_BARRIER(); 450 } 451 else 452 { 453 xReturn = xTaskGetTickCount(); 454 } 455 456 return xReturn; 457 } 458 /*-----------------------------------------------------------*/ 459 MPU_uxTaskGetNumberOfTasks(void)460 UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* FREERTOS_SYSTEM_CALL */ 461 { 462 UBaseType_t uxReturn; 463 464 if( portIS_PRIVILEGED() == pdFALSE ) 465 { 466 portRAISE_PRIVILEGE(); 467 portMEMORY_BARRIER(); 468 469 uxReturn = uxTaskGetNumberOfTasks(); 470 portMEMORY_BARRIER(); 471 472 portRESET_PRIVILEGE(); 473 portMEMORY_BARRIER(); 474 } 475 else 476 { 477 uxReturn = uxTaskGetNumberOfTasks(); 478 } 479 480 return uxReturn; 481 } 482 /*-----------------------------------------------------------*/ 483 484 #if ( INCLUDE_xTaskGetHandle == 1 ) MPU_xTaskGetHandle(const char * pcNameToQuery)485 TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) /* FREERTOS_SYSTEM_CALL */ 486 { 487 TaskHandle_t xReturn; 488 489 if( portIS_PRIVILEGED() == pdFALSE ) 490 { 491 portRAISE_PRIVILEGE(); 492 portMEMORY_BARRIER(); 493 494 xReturn = xTaskGetHandle( pcNameToQuery ); 495 portMEMORY_BARRIER(); 496 497 portRESET_PRIVILEGE(); 498 portMEMORY_BARRIER(); 499 } 500 else 501 { 502 xReturn = xTaskGetHandle( pcNameToQuery ); 503 } 504 505 return xReturn; 506 } 507 #endif /* if ( INCLUDE_xTaskGetHandle == 1 ) */ 508 /*-----------------------------------------------------------*/ 509 510 #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) MPU_vTaskListTasks(char * pcWriteBuffer,size_t uxBufferLength)511 void MPU_vTaskListTasks( char * pcWriteBuffer, 512 size_t uxBufferLength ) /* FREERTOS_SYSTEM_CALL */ 513 { 514 if( portIS_PRIVILEGED() == pdFALSE ) 515 { 516 portRAISE_PRIVILEGE(); 517 portMEMORY_BARRIER(); 518 519 vTaskListTasks( pcWriteBuffer, uxBufferLength ); 520 portMEMORY_BARRIER(); 521 522 portRESET_PRIVILEGE(); 523 portMEMORY_BARRIER(); 524 } 525 else 526 { 527 vTaskListTasks( pcWriteBuffer, uxBufferLength ); 528 } 529 } 530 #endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */ 531 /*-----------------------------------------------------------*/ 532 533 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) MPU_vTaskGetRunTimeStatistics(char * pcWriteBuffer,size_t uxBufferLength)534 void MPU_vTaskGetRunTimeStatistics( char * pcWriteBuffer, 535 size_t uxBufferLength ) /* FREERTOS_SYSTEM_CALL */ 536 { 537 if( portIS_PRIVILEGED() == pdFALSE ) 538 { 539 portRAISE_PRIVILEGE(); 540 portMEMORY_BARRIER(); 541 542 vTaskGetRunTimeStatistics( pcWriteBuffer, uxBufferLength ); 543 portMEMORY_BARRIER(); 544 545 portRESET_PRIVILEGE(); 546 portMEMORY_BARRIER(); 547 } 548 else 549 { 550 vTaskGetRunTimeStatistics( pcWriteBuffer, uxBufferLength ); 551 } 552 } 553 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */ 554 /*-----------------------------------------------------------*/ 555 556 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) MPU_ulTaskGetIdleRunTimePercent(void)557 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) /* FREERTOS_SYSTEM_CALL */ 558 { 559 configRUN_TIME_COUNTER_TYPE xReturn; 560 561 if( portIS_PRIVILEGED() == pdFALSE ) 562 { 563 portRAISE_PRIVILEGE(); 564 portMEMORY_BARRIER(); 565 566 xReturn = ulTaskGetIdleRunTimePercent(); 567 portMEMORY_BARRIER(); 568 569 portRESET_PRIVILEGE(); 570 portMEMORY_BARRIER(); 571 } 572 else 573 { 574 xReturn = ulTaskGetIdleRunTimePercent(); 575 } 576 577 return xReturn; 578 } 579 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */ 580 /*-----------------------------------------------------------*/ 581 582 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) MPU_ulTaskGetIdleRunTimeCounter(void)583 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */ 584 { 585 configRUN_TIME_COUNTER_TYPE xReturn; 586 587 if( portIS_PRIVILEGED() == pdFALSE ) 588 { 589 portRAISE_PRIVILEGE(); 590 portMEMORY_BARRIER(); 591 592 xReturn = ulTaskGetIdleRunTimeCounter(); 593 portMEMORY_BARRIER(); 594 595 portRESET_PRIVILEGE(); 596 portMEMORY_BARRIER(); 597 } 598 else 599 { 600 xReturn = ulTaskGetIdleRunTimeCounter(); 601 } 602 603 return xReturn; 604 } 605 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */ 606 /*-----------------------------------------------------------*/ 607 608 #if ( configUSE_APPLICATION_TASK_TAG == 1 ) MPU_vTaskSetApplicationTaskTag(TaskHandle_t xTask,TaskHookFunction_t pxTagValue)609 void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, 610 TaskHookFunction_t pxTagValue ) /* FREERTOS_SYSTEM_CALL */ 611 { 612 if( portIS_PRIVILEGED() == pdFALSE ) 613 { 614 portRAISE_PRIVILEGE(); 615 portMEMORY_BARRIER(); 616 617 vTaskSetApplicationTaskTag( xTask, pxTagValue ); 618 portMEMORY_BARRIER(); 619 620 portRESET_PRIVILEGE(); 621 portMEMORY_BARRIER(); 622 } 623 else 624 { 625 vTaskSetApplicationTaskTag( xTask, pxTagValue ); 626 } 627 } 628 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */ 629 /*-----------------------------------------------------------*/ 630 631 #if ( configUSE_APPLICATION_TASK_TAG == 1 ) MPU_xTaskGetApplicationTaskTag(TaskHandle_t xTask)632 TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */ 633 { 634 TaskHookFunction_t xReturn; 635 636 if( portIS_PRIVILEGED() == pdFALSE ) 637 { 638 portRAISE_PRIVILEGE(); 639 portMEMORY_BARRIER(); 640 641 xReturn = xTaskGetApplicationTaskTag( xTask ); 642 portMEMORY_BARRIER(); 643 644 portRESET_PRIVILEGE(); 645 portMEMORY_BARRIER(); 646 } 647 else 648 { 649 xReturn = xTaskGetApplicationTaskTag( xTask ); 650 } 651 652 return xReturn; 653 } 654 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */ 655 /*-----------------------------------------------------------*/ 656 657 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) MPU_vTaskSetThreadLocalStoragePointer(TaskHandle_t xTaskToSet,BaseType_t xIndex,void * pvValue)658 void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, 659 BaseType_t xIndex, 660 void * pvValue ) /* FREERTOS_SYSTEM_CALL */ 661 { 662 if( portIS_PRIVILEGED() == pdFALSE ) 663 { 664 portRAISE_PRIVILEGE(); 665 portMEMORY_BARRIER(); 666 667 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue ); 668 portMEMORY_BARRIER(); 669 670 portRESET_PRIVILEGE(); 671 portMEMORY_BARRIER(); 672 } 673 else 674 { 675 vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue ); 676 } 677 } 678 #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */ 679 /*-----------------------------------------------------------*/ 680 681 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) MPU_pvTaskGetThreadLocalStoragePointer(TaskHandle_t xTaskToQuery,BaseType_t xIndex)682 void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, 683 BaseType_t xIndex ) /* FREERTOS_SYSTEM_CALL */ 684 { 685 void * pvReturn; 686 687 if( portIS_PRIVILEGED() == pdFALSE ) 688 { 689 portRAISE_PRIVILEGE(); 690 portMEMORY_BARRIER(); 691 692 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex ); 693 portMEMORY_BARRIER(); 694 695 portRESET_PRIVILEGE(); 696 portMEMORY_BARRIER(); 697 } 698 else 699 { 700 pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex ); 701 } 702 703 return pvReturn; 704 } 705 #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */ 706 /*-----------------------------------------------------------*/ 707 708 #if ( configUSE_APPLICATION_TASK_TAG == 1 ) MPU_xTaskCallApplicationTaskHook(TaskHandle_t xTask,void * pvParameter)709 BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask, 710 void * pvParameter ) /* FREERTOS_SYSTEM_CALL */ 711 { 712 BaseType_t xReturn; 713 714 if( portIS_PRIVILEGED() == pdFALSE ) 715 { 716 portRAISE_PRIVILEGE(); 717 portMEMORY_BARRIER(); 718 719 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter ); 720 portMEMORY_BARRIER(); 721 722 portRESET_PRIVILEGE(); 723 portMEMORY_BARRIER(); 724 } 725 else 726 { 727 xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter ); 728 } 729 730 return xReturn; 731 } 732 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */ 733 /*-----------------------------------------------------------*/ 734 735 #if ( configUSE_TRACE_FACILITY == 1 ) MPU_uxTaskGetSystemState(TaskStatus_t * pxTaskStatusArray,UBaseType_t uxArraySize,configRUN_TIME_COUNTER_TYPE * pulTotalRunTime)736 UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * pxTaskStatusArray, 737 UBaseType_t uxArraySize, 738 configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) /* FREERTOS_SYSTEM_CALL */ 739 { 740 UBaseType_t uxReturn; 741 742 if( portIS_PRIVILEGED() == pdFALSE ) 743 { 744 portRAISE_PRIVILEGE(); 745 portMEMORY_BARRIER(); 746 747 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime ); 748 portMEMORY_BARRIER(); 749 750 portRESET_PRIVILEGE(); 751 portMEMORY_BARRIER(); 752 } 753 else 754 { 755 uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime ); 756 } 757 758 return uxReturn; 759 } 760 #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */ 761 /*-----------------------------------------------------------*/ 762 MPU_xTaskCatchUpTicks(TickType_t xTicksToCatchUp)763 BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTEM_CALL */ 764 { 765 BaseType_t xReturn; 766 767 if( portIS_PRIVILEGED() == pdFALSE ) 768 { 769 portRAISE_PRIVILEGE(); 770 portMEMORY_BARRIER(); 771 772 xReturn = xTaskCatchUpTicks( xTicksToCatchUp ); 773 portMEMORY_BARRIER(); 774 775 portRESET_PRIVILEGE(); 776 portMEMORY_BARRIER(); 777 } 778 else 779 { 780 xReturn = xTaskCatchUpTicks( xTicksToCatchUp ); 781 } 782 783 return xReturn; 784 } 785 /*-----------------------------------------------------------*/ 786 787 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) MPU_uxTaskGetStackHighWaterMark(TaskHandle_t xTask)788 UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */ 789 { 790 UBaseType_t uxReturn; 791 792 if( portIS_PRIVILEGED() == pdFALSE ) 793 { 794 portRAISE_PRIVILEGE(); 795 portMEMORY_BARRIER(); 796 797 uxReturn = uxTaskGetStackHighWaterMark( xTask ); 798 portMEMORY_BARRIER(); 799 800 portRESET_PRIVILEGE(); 801 portMEMORY_BARRIER(); 802 } 803 else 804 { 805 uxReturn = uxTaskGetStackHighWaterMark( xTask ); 806 } 807 808 return uxReturn; 809 } 810 #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */ 811 /*-----------------------------------------------------------*/ 812 813 #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) MPU_uxTaskGetStackHighWaterMark2(TaskHandle_t xTask)814 configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */ 815 { 816 configSTACK_DEPTH_TYPE uxReturn; 817 818 if( portIS_PRIVILEGED() == pdFALSE ) 819 { 820 portRAISE_PRIVILEGE(); 821 portMEMORY_BARRIER(); 822 823 uxReturn = uxTaskGetStackHighWaterMark2( xTask ); 824 portMEMORY_BARRIER(); 825 826 portRESET_PRIVILEGE(); 827 portMEMORY_BARRIER(); 828 } 829 else 830 { 831 uxReturn = uxTaskGetStackHighWaterMark2( xTask ); 832 } 833 834 return uxReturn; 835 } 836 #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */ 837 /*-----------------------------------------------------------*/ 838 839 #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_RECURSIVE_MUTEXES == 1 ) ) MPU_xTaskGetCurrentTaskHandle(void)840 TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */ 841 { 842 TaskHandle_t xReturn; 843 844 if( portIS_PRIVILEGED() == pdFALSE ) 845 { 846 portRAISE_PRIVILEGE(); 847 portMEMORY_BARRIER(); 848 xReturn = xTaskGetCurrentTaskHandle(); 849 portMEMORY_BARRIER(); 850 851 portRESET_PRIVILEGE(); 852 portMEMORY_BARRIER(); 853 } 854 else 855 { 856 xReturn = xTaskGetCurrentTaskHandle(); 857 } 858 859 return xReturn; 860 } 861 #endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_RECURSIVE_MUTEXES == 1 ) ) */ 862 /*-----------------------------------------------------------*/ 863 864 #if ( INCLUDE_xTaskGetSchedulerState == 1 ) MPU_xTaskGetSchedulerState(void)865 BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */ 866 { 867 BaseType_t xReturn; 868 869 if( portIS_PRIVILEGED() == pdFALSE ) 870 { 871 portRAISE_PRIVILEGE(); 872 portMEMORY_BARRIER(); 873 874 xReturn = xTaskGetSchedulerState(); 875 portMEMORY_BARRIER(); 876 877 portRESET_PRIVILEGE(); 878 portMEMORY_BARRIER(); 879 } 880 else 881 { 882 xReturn = xTaskGetSchedulerState(); 883 } 884 885 return xReturn; 886 } 887 #endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */ 888 /*-----------------------------------------------------------*/ 889 MPU_vTaskSetTimeOutState(TimeOut_t * const pxTimeOut)890 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */ 891 { 892 if( portIS_PRIVILEGED() == pdFALSE ) 893 { 894 portRAISE_PRIVILEGE(); 895 portMEMORY_BARRIER(); 896 897 vTaskSetTimeOutState( pxTimeOut ); 898 portMEMORY_BARRIER(); 899 900 portRESET_PRIVILEGE(); 901 portMEMORY_BARRIER(); 902 } 903 else 904 { 905 vTaskSetTimeOutState( pxTimeOut ); 906 } 907 } 908 /*-----------------------------------------------------------*/ 909 MPU_xTaskCheckForTimeOut(TimeOut_t * const pxTimeOut,TickType_t * const pxTicksToWait)910 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, 911 TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 912 { 913 BaseType_t xReturn; 914 915 if( portIS_PRIVILEGED() == pdFALSE ) 916 { 917 portRAISE_PRIVILEGE(); 918 portMEMORY_BARRIER(); 919 920 xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait ); 921 portMEMORY_BARRIER(); 922 923 portRESET_PRIVILEGE(); 924 portMEMORY_BARRIER(); 925 } 926 else 927 { 928 xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait ); 929 } 930 931 return xReturn; 932 } 933 /*-----------------------------------------------------------*/ 934 935 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) MPU_xTaskGenericNotify(TaskHandle_t xTaskToNotify,UBaseType_t uxIndexToNotify,uint32_t ulValue,eNotifyAction eAction,uint32_t * pulPreviousNotificationValue)936 BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify, 937 UBaseType_t uxIndexToNotify, 938 uint32_t ulValue, 939 eNotifyAction eAction, 940 uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */ 941 { 942 BaseType_t xReturn; 943 944 if( portIS_PRIVILEGED() == pdFALSE ) 945 { 946 portRAISE_PRIVILEGE(); 947 portMEMORY_BARRIER(); 948 949 xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue ); 950 portMEMORY_BARRIER(); 951 952 portRESET_PRIVILEGE(); 953 portMEMORY_BARRIER(); 954 } 955 else 956 { 957 xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue ); 958 } 959 960 return xReturn; 961 } 962 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 963 /*-----------------------------------------------------------*/ 964 965 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) MPU_xTaskGenericNotifyWait(UBaseType_t uxIndexToWaitOn,uint32_t ulBitsToClearOnEntry,uint32_t ulBitsToClearOnExit,uint32_t * pulNotificationValue,TickType_t xTicksToWait)966 BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn, 967 uint32_t ulBitsToClearOnEntry, 968 uint32_t ulBitsToClearOnExit, 969 uint32_t * pulNotificationValue, 970 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 971 { 972 BaseType_t xReturn; 973 974 if( portIS_PRIVILEGED() == pdFALSE ) 975 { 976 portRAISE_PRIVILEGE(); 977 portMEMORY_BARRIER(); 978 979 xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ); 980 portMEMORY_BARRIER(); 981 982 portRESET_PRIVILEGE(); 983 portMEMORY_BARRIER(); 984 } 985 else 986 { 987 xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ); 988 } 989 990 return xReturn; 991 } 992 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 993 /*-----------------------------------------------------------*/ 994 995 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) MPU_ulTaskGenericNotifyTake(UBaseType_t uxIndexToWaitOn,BaseType_t xClearCountOnExit,TickType_t xTicksToWait)996 uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn, 997 BaseType_t xClearCountOnExit, 998 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 999 { 1000 uint32_t ulReturn; 1001 1002 if( portIS_PRIVILEGED() == pdFALSE ) 1003 { 1004 portRAISE_PRIVILEGE(); 1005 portMEMORY_BARRIER(); 1006 1007 ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait ); 1008 portMEMORY_BARRIER(); 1009 1010 portRESET_PRIVILEGE(); 1011 portMEMORY_BARRIER(); 1012 } 1013 else 1014 { 1015 ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait ); 1016 } 1017 1018 return ulReturn; 1019 } 1020 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 1021 /*-----------------------------------------------------------*/ 1022 1023 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) MPU_xTaskGenericNotifyStateClear(TaskHandle_t xTask,UBaseType_t uxIndexToClear)1024 BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask, 1025 UBaseType_t uxIndexToClear ) /* FREERTOS_SYSTEM_CALL */ 1026 { 1027 BaseType_t xReturn; 1028 1029 if( portIS_PRIVILEGED() == pdFALSE ) 1030 { 1031 portRAISE_PRIVILEGE(); 1032 portMEMORY_BARRIER(); 1033 1034 xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear ); 1035 portMEMORY_BARRIER(); 1036 1037 portRESET_PRIVILEGE(); 1038 portMEMORY_BARRIER(); 1039 } 1040 else 1041 { 1042 xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear ); 1043 } 1044 1045 return xReturn; 1046 } 1047 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 1048 /*-----------------------------------------------------------*/ 1049 1050 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) MPU_ulTaskGenericNotifyValueClear(TaskHandle_t xTask,UBaseType_t uxIndexToClear,uint32_t ulBitsToClear)1051 uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask, 1052 UBaseType_t uxIndexToClear, 1053 uint32_t ulBitsToClear ) /* FREERTOS_SYSTEM_CALL */ 1054 { 1055 uint32_t ulReturn; 1056 1057 if( portIS_PRIVILEGED() == pdFALSE ) 1058 { 1059 portRAISE_PRIVILEGE(); 1060 portMEMORY_BARRIER(); 1061 1062 ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear ); 1063 portMEMORY_BARRIER(); 1064 1065 portRESET_PRIVILEGE(); 1066 portMEMORY_BARRIER(); 1067 } 1068 else 1069 { 1070 ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear ); 1071 } 1072 1073 return ulReturn; 1074 } 1075 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 1076 /*-----------------------------------------------------------*/ 1077 1078 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) MPU_xQueueGenericCreate(UBaseType_t uxQueueLength,UBaseType_t uxItemSize,uint8_t ucQueueType)1079 QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength, 1080 UBaseType_t uxItemSize, 1081 uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */ 1082 { 1083 QueueHandle_t xReturn; 1084 1085 if( portIS_PRIVILEGED() == pdFALSE ) 1086 { 1087 portRAISE_PRIVILEGE(); 1088 portMEMORY_BARRIER(); 1089 1090 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType ); 1091 portMEMORY_BARRIER(); 1092 1093 portRESET_PRIVILEGE(); 1094 portMEMORY_BARRIER(); 1095 } 1096 else 1097 { 1098 xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType ); 1099 } 1100 1101 return xReturn; 1102 } 1103 #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */ 1104 /*-----------------------------------------------------------*/ 1105 1106 #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) MPU_xQueueGenericCreateStatic(const UBaseType_t uxQueueLength,const UBaseType_t uxItemSize,uint8_t * pucQueueStorage,StaticQueue_t * pxStaticQueue,const uint8_t ucQueueType)1107 QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, 1108 const UBaseType_t uxItemSize, 1109 uint8_t * pucQueueStorage, 1110 StaticQueue_t * pxStaticQueue, 1111 const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */ 1112 { 1113 QueueHandle_t xReturn; 1114 1115 if( portIS_PRIVILEGED() == pdFALSE ) 1116 { 1117 portRAISE_PRIVILEGE(); 1118 portMEMORY_BARRIER(); 1119 1120 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType ); 1121 portMEMORY_BARRIER(); 1122 1123 portRESET_PRIVILEGE(); 1124 portMEMORY_BARRIER(); 1125 } 1126 else 1127 { 1128 xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType ); 1129 } 1130 1131 return xReturn; 1132 } 1133 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */ 1134 /*-----------------------------------------------------------*/ 1135 MPU_xQueueGenericReset(QueueHandle_t pxQueue,BaseType_t xNewQueue)1136 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue, 1137 BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */ 1138 { 1139 BaseType_t xReturn; 1140 1141 if( portIS_PRIVILEGED() == pdFALSE ) 1142 { 1143 portRAISE_PRIVILEGE(); 1144 portMEMORY_BARRIER(); 1145 1146 xReturn = xQueueGenericReset( pxQueue, xNewQueue ); 1147 portMEMORY_BARRIER(); 1148 1149 portRESET_PRIVILEGE(); 1150 portMEMORY_BARRIER(); 1151 } 1152 else 1153 { 1154 xReturn = xQueueGenericReset( pxQueue, xNewQueue ); 1155 } 1156 1157 return xReturn; 1158 } 1159 /*-----------------------------------------------------------*/ 1160 MPU_xQueueGenericSend(QueueHandle_t xQueue,const void * const pvItemToQueue,TickType_t xTicksToWait,BaseType_t xCopyPosition)1161 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, 1162 const void * const pvItemToQueue, 1163 TickType_t xTicksToWait, 1164 BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */ 1165 { 1166 BaseType_t xReturn; 1167 1168 if( portIS_PRIVILEGED() == pdFALSE ) 1169 { 1170 portRAISE_PRIVILEGE(); 1171 portMEMORY_BARRIER(); 1172 1173 xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition ); 1174 portMEMORY_BARRIER(); 1175 1176 portRESET_PRIVILEGE(); 1177 portMEMORY_BARRIER(); 1178 } 1179 else 1180 { 1181 xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition ); 1182 } 1183 1184 return xReturn; 1185 } 1186 /*-----------------------------------------------------------*/ 1187 MPU_uxQueueMessagesWaiting(const QueueHandle_t pxQueue)1188 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */ 1189 { 1190 UBaseType_t uxReturn; 1191 1192 if( portIS_PRIVILEGED() == pdFALSE ) 1193 { 1194 portRAISE_PRIVILEGE(); 1195 portMEMORY_BARRIER(); 1196 1197 uxReturn = uxQueueMessagesWaiting( pxQueue ); 1198 portMEMORY_BARRIER(); 1199 1200 portRESET_PRIVILEGE(); 1201 portMEMORY_BARRIER(); 1202 } 1203 else 1204 { 1205 uxReturn = uxQueueMessagesWaiting( pxQueue ); 1206 } 1207 1208 return uxReturn; 1209 } 1210 /*-----------------------------------------------------------*/ 1211 MPU_uxQueueSpacesAvailable(const QueueHandle_t xQueue)1212 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */ 1213 { 1214 UBaseType_t uxReturn; 1215 1216 if( portIS_PRIVILEGED() == pdFALSE ) 1217 { 1218 portRAISE_PRIVILEGE(); 1219 portMEMORY_BARRIER(); 1220 1221 uxReturn = uxQueueSpacesAvailable( xQueue ); 1222 portMEMORY_BARRIER(); 1223 1224 portRESET_PRIVILEGE(); 1225 portMEMORY_BARRIER(); 1226 } 1227 else 1228 { 1229 uxReturn = uxQueueSpacesAvailable( xQueue ); 1230 } 1231 1232 return uxReturn; 1233 } 1234 /*-----------------------------------------------------------*/ 1235 MPU_xQueueReceive(QueueHandle_t pxQueue,void * const pvBuffer,TickType_t xTicksToWait)1236 BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue, 1237 void * const pvBuffer, 1238 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 1239 { 1240 BaseType_t xReturn; 1241 1242 if( portIS_PRIVILEGED() == pdFALSE ) 1243 { 1244 portRAISE_PRIVILEGE(); 1245 portMEMORY_BARRIER(); 1246 1247 xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait ); 1248 portMEMORY_BARRIER(); 1249 1250 portRESET_PRIVILEGE(); 1251 portMEMORY_BARRIER(); 1252 } 1253 else 1254 { 1255 xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait ); 1256 } 1257 1258 return xReturn; 1259 } 1260 /*-----------------------------------------------------------*/ 1261 MPU_xQueuePeek(QueueHandle_t xQueue,void * const pvBuffer,TickType_t xTicksToWait)1262 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, 1263 void * const pvBuffer, 1264 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 1265 { 1266 BaseType_t xReturn; 1267 1268 if( portIS_PRIVILEGED() == pdFALSE ) 1269 { 1270 portRAISE_PRIVILEGE(); 1271 portMEMORY_BARRIER(); 1272 1273 xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait ); 1274 portMEMORY_BARRIER(); 1275 1276 portRESET_PRIVILEGE(); 1277 portMEMORY_BARRIER(); 1278 } 1279 else 1280 { 1281 xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait ); 1282 } 1283 1284 return xReturn; 1285 } 1286 /*-----------------------------------------------------------*/ 1287 MPU_xQueueSemaphoreTake(QueueHandle_t xQueue,TickType_t xTicksToWait)1288 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, 1289 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 1290 { 1291 BaseType_t xReturn; 1292 1293 if( portIS_PRIVILEGED() == pdFALSE ) 1294 { 1295 portRAISE_PRIVILEGE(); 1296 portMEMORY_BARRIER(); 1297 1298 xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait ); 1299 portMEMORY_BARRIER(); 1300 1301 portRESET_PRIVILEGE(); 1302 portMEMORY_BARRIER(); 1303 } 1304 else 1305 { 1306 xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait ); 1307 } 1308 1309 return xReturn; 1310 } 1311 /*-----------------------------------------------------------*/ 1312 1313 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) MPU_xQueueGetMutexHolder(QueueHandle_t xSemaphore)1314 TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */ 1315 { 1316 void * xReturn; 1317 1318 if( portIS_PRIVILEGED() == pdFALSE ) 1319 { 1320 portRAISE_PRIVILEGE(); 1321 portMEMORY_BARRIER(); 1322 1323 xReturn = xQueueGetMutexHolder( xSemaphore ); 1324 portMEMORY_BARRIER(); 1325 1326 portRESET_PRIVILEGE(); 1327 portMEMORY_BARRIER(); 1328 } 1329 else 1330 { 1331 xReturn = xQueueGetMutexHolder( xSemaphore ); 1332 } 1333 1334 return xReturn; 1335 } 1336 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */ 1337 /*-----------------------------------------------------------*/ 1338 1339 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) MPU_xQueueCreateMutex(const uint8_t ucQueueType)1340 QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */ 1341 { 1342 QueueHandle_t xReturn; 1343 1344 if( portIS_PRIVILEGED() == pdFALSE ) 1345 { 1346 portRAISE_PRIVILEGE(); 1347 portMEMORY_BARRIER(); 1348 1349 xReturn = xQueueCreateMutex( ucQueueType ); 1350 portMEMORY_BARRIER(); 1351 1352 portRESET_PRIVILEGE(); 1353 portMEMORY_BARRIER(); 1354 } 1355 else 1356 { 1357 xReturn = xQueueCreateMutex( ucQueueType ); 1358 } 1359 1360 return xReturn; 1361 } 1362 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */ 1363 /*-----------------------------------------------------------*/ 1364 1365 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) MPU_xQueueCreateMutexStatic(const uint8_t ucQueueType,StaticQueue_t * pxStaticQueue)1366 QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, 1367 StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */ 1368 { 1369 QueueHandle_t xReturn; 1370 1371 if( portIS_PRIVILEGED() == pdFALSE ) 1372 { 1373 portRAISE_PRIVILEGE(); 1374 portMEMORY_BARRIER(); 1375 1376 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue ); 1377 portMEMORY_BARRIER(); 1378 1379 portRESET_PRIVILEGE(); 1380 portMEMORY_BARRIER(); 1381 } 1382 else 1383 { 1384 xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue ); 1385 } 1386 1387 return xReturn; 1388 } 1389 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */ 1390 /*-----------------------------------------------------------*/ 1391 1392 #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) MPU_xQueueCreateCountingSemaphore(UBaseType_t uxCountValue,UBaseType_t uxInitialCount)1393 QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue, 1394 UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */ 1395 { 1396 QueueHandle_t xReturn; 1397 1398 if( portIS_PRIVILEGED() == pdFALSE ) 1399 { 1400 portRAISE_PRIVILEGE(); 1401 portMEMORY_BARRIER(); 1402 1403 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount ); 1404 portMEMORY_BARRIER(); 1405 1406 portRESET_PRIVILEGE(); 1407 portMEMORY_BARRIER(); 1408 } 1409 else 1410 { 1411 xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount ); 1412 } 1413 1414 return xReturn; 1415 } 1416 #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */ 1417 /*-----------------------------------------------------------*/ 1418 1419 #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) 1420 MPU_xQueueCreateCountingSemaphoreStatic(const UBaseType_t uxMaxCount,const UBaseType_t uxInitialCount,StaticQueue_t * pxStaticQueue)1421 QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, 1422 const UBaseType_t uxInitialCount, 1423 StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */ 1424 { 1425 QueueHandle_t xReturn; 1426 1427 if( portIS_PRIVILEGED() == pdFALSE ) 1428 { 1429 portRAISE_PRIVILEGE(); 1430 portMEMORY_BARRIER(); 1431 1432 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue ); 1433 portMEMORY_BARRIER(); 1434 1435 portRESET_PRIVILEGE(); 1436 portMEMORY_BARRIER(); 1437 } 1438 else 1439 { 1440 xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue ); 1441 } 1442 1443 return xReturn; 1444 } 1445 #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */ 1446 /*-----------------------------------------------------------*/ 1447 1448 #if ( configUSE_RECURSIVE_MUTEXES == 1 ) MPU_xQueueTakeMutexRecursive(QueueHandle_t xMutex,TickType_t xBlockTime)1449 BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, 1450 TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */ 1451 { 1452 BaseType_t xReturn; 1453 1454 if( portIS_PRIVILEGED() == pdFALSE ) 1455 { 1456 portRAISE_PRIVILEGE(); 1457 portMEMORY_BARRIER(); 1458 1459 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime ); 1460 portMEMORY_BARRIER(); 1461 1462 portRESET_PRIVILEGE(); 1463 portMEMORY_BARRIER(); 1464 } 1465 else 1466 { 1467 xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime ); 1468 } 1469 1470 return xReturn; 1471 } 1472 #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */ 1473 /*-----------------------------------------------------------*/ 1474 1475 #if ( configUSE_RECURSIVE_MUTEXES == 1 ) MPU_xQueueGiveMutexRecursive(QueueHandle_t xMutex)1476 BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */ 1477 { 1478 BaseType_t xReturn; 1479 1480 if( portIS_PRIVILEGED() == pdFALSE ) 1481 { 1482 portRAISE_PRIVILEGE(); 1483 portMEMORY_BARRIER(); 1484 1485 xReturn = xQueueGiveMutexRecursive( xMutex ); 1486 portMEMORY_BARRIER(); 1487 1488 portRESET_PRIVILEGE(); 1489 portMEMORY_BARRIER(); 1490 } 1491 else 1492 { 1493 xReturn = xQueueGiveMutexRecursive( xMutex ); 1494 } 1495 1496 return xReturn; 1497 } 1498 #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */ 1499 /*-----------------------------------------------------------*/ 1500 1501 #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) MPU_xQueueCreateSet(UBaseType_t uxEventQueueLength)1502 QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */ 1503 { 1504 QueueSetHandle_t xReturn; 1505 1506 if( portIS_PRIVILEGED() == pdFALSE ) 1507 { 1508 portRAISE_PRIVILEGE(); 1509 portMEMORY_BARRIER(); 1510 1511 xReturn = xQueueCreateSet( uxEventQueueLength ); 1512 portMEMORY_BARRIER(); 1513 1514 portRESET_PRIVILEGE(); 1515 portMEMORY_BARRIER(); 1516 } 1517 else 1518 { 1519 xReturn = xQueueCreateSet( uxEventQueueLength ); 1520 } 1521 1522 return xReturn; 1523 } 1524 #endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */ 1525 /*-----------------------------------------------------------*/ 1526 1527 #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) MPU_xQueueCreateSetStatic(const UBaseType_t uxEventQueueLength,uint8_t * pucQueueStorage,StaticQueue_t * pxStaticQueue)1528 QueueSetHandle_t MPU_xQueueCreateSetStatic( const UBaseType_t uxEventQueueLength, 1529 uint8_t * pucQueueStorage, 1530 StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */ 1531 { 1532 QueueSetHandle_t xReturn; 1533 1534 if( portIS_PRIVILEGED() == pdFALSE ) 1535 { 1536 portRAISE_PRIVILEGE(); 1537 portMEMORY_BARRIER(); 1538 1539 xReturn = xQueueCreateSetStatic( uxEventQueueLength, pucQueueStorage, pxStaticQueue ); 1540 portMEMORY_BARRIER(); 1541 1542 portRESET_PRIVILEGE(); 1543 portMEMORY_BARRIER(); 1544 } 1545 else 1546 { 1547 xReturn = xQueueCreateSetStatic( uxEventQueueLength, pucQueueStorage, pxStaticQueue ); 1548 } 1549 1550 return xReturn; 1551 } 1552 #endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */ 1553 /*-----------------------------------------------------------*/ 1554 1555 #if ( configUSE_QUEUE_SETS == 1 ) MPU_xQueueSelectFromSet(QueueSetHandle_t xQueueSet,TickType_t xBlockTimeTicks)1556 QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, 1557 TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */ 1558 { 1559 QueueSetMemberHandle_t xReturn; 1560 1561 if( portIS_PRIVILEGED() == pdFALSE ) 1562 { 1563 portRAISE_PRIVILEGE(); 1564 portMEMORY_BARRIER(); 1565 1566 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks ); 1567 portMEMORY_BARRIER(); 1568 1569 portRESET_PRIVILEGE(); 1570 portMEMORY_BARRIER(); 1571 } 1572 else 1573 { 1574 xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks ); 1575 } 1576 1577 return xReturn; 1578 } 1579 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */ 1580 /*-----------------------------------------------------------*/ 1581 1582 #if ( configUSE_QUEUE_SETS == 1 ) MPU_xQueueAddToSet(QueueSetMemberHandle_t xQueueOrSemaphore,QueueSetHandle_t xQueueSet)1583 BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, 1584 QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */ 1585 { 1586 BaseType_t xReturn; 1587 1588 if( portIS_PRIVILEGED() == pdFALSE ) 1589 { 1590 portRAISE_PRIVILEGE(); 1591 portMEMORY_BARRIER(); 1592 1593 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet ); 1594 portMEMORY_BARRIER(); 1595 1596 portRESET_PRIVILEGE(); 1597 portMEMORY_BARRIER(); 1598 } 1599 else 1600 { 1601 xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet ); 1602 } 1603 1604 return xReturn; 1605 } 1606 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */ 1607 /*-----------------------------------------------------------*/ 1608 1609 #if ( configUSE_QUEUE_SETS == 1 ) MPU_xQueueRemoveFromSet(QueueSetMemberHandle_t xQueueOrSemaphore,QueueSetHandle_t xQueueSet)1610 BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, 1611 QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */ 1612 { 1613 BaseType_t xReturn; 1614 1615 if( portIS_PRIVILEGED() == pdFALSE ) 1616 { 1617 portRAISE_PRIVILEGE(); 1618 portMEMORY_BARRIER(); 1619 1620 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet ); 1621 portMEMORY_BARRIER(); 1622 1623 portRESET_PRIVILEGE(); 1624 portMEMORY_BARRIER(); 1625 } 1626 else 1627 { 1628 xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet ); 1629 } 1630 1631 return xReturn; 1632 } 1633 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */ 1634 /*-----------------------------------------------------------*/ 1635 1636 #if configQUEUE_REGISTRY_SIZE > 0 MPU_vQueueAddToRegistry(QueueHandle_t xQueue,const char * pcName)1637 void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, 1638 const char * pcName ) /* FREERTOS_SYSTEM_CALL */ 1639 { 1640 if( portIS_PRIVILEGED() == pdFALSE ) 1641 { 1642 portRAISE_PRIVILEGE(); 1643 portMEMORY_BARRIER(); 1644 1645 vQueueAddToRegistry( xQueue, pcName ); 1646 portMEMORY_BARRIER(); 1647 1648 portRESET_PRIVILEGE(); 1649 portMEMORY_BARRIER(); 1650 } 1651 else 1652 { 1653 vQueueAddToRegistry( xQueue, pcName ); 1654 } 1655 } 1656 #endif /* if configQUEUE_REGISTRY_SIZE > 0 */ 1657 /*-----------------------------------------------------------*/ 1658 1659 #if configQUEUE_REGISTRY_SIZE > 0 MPU_vQueueUnregisterQueue(QueueHandle_t xQueue)1660 void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */ 1661 { 1662 if( portIS_PRIVILEGED() == pdFALSE ) 1663 { 1664 portRAISE_PRIVILEGE(); 1665 portMEMORY_BARRIER(); 1666 1667 vQueueUnregisterQueue( xQueue ); 1668 portMEMORY_BARRIER(); 1669 1670 portRESET_PRIVILEGE(); 1671 portMEMORY_BARRIER(); 1672 } 1673 else 1674 { 1675 vQueueUnregisterQueue( xQueue ); 1676 } 1677 } 1678 #endif /* if configQUEUE_REGISTRY_SIZE > 0 */ 1679 /*-----------------------------------------------------------*/ 1680 1681 #if configQUEUE_REGISTRY_SIZE > 0 MPU_pcQueueGetName(QueueHandle_t xQueue)1682 const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */ 1683 { 1684 const char * pcReturn; 1685 1686 if( portIS_PRIVILEGED() == pdFALSE ) 1687 { 1688 portRAISE_PRIVILEGE(); 1689 portMEMORY_BARRIER(); 1690 1691 pcReturn = pcQueueGetName( xQueue ); 1692 portMEMORY_BARRIER(); 1693 1694 portRESET_PRIVILEGE(); 1695 portMEMORY_BARRIER(); 1696 } 1697 else 1698 { 1699 pcReturn = pcQueueGetName( xQueue ); 1700 } 1701 1702 return pcReturn; 1703 } 1704 #endif /* if configQUEUE_REGISTRY_SIZE > 0 */ 1705 /*-----------------------------------------------------------*/ 1706 MPU_vQueueDelete(QueueHandle_t xQueue)1707 void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */ 1708 { 1709 if( portIS_PRIVILEGED() == pdFALSE ) 1710 { 1711 portRAISE_PRIVILEGE(); 1712 portMEMORY_BARRIER(); 1713 1714 vQueueDelete( xQueue ); 1715 portMEMORY_BARRIER(); 1716 1717 portRESET_PRIVILEGE(); 1718 portMEMORY_BARRIER(); 1719 } 1720 else 1721 { 1722 vQueueDelete( xQueue ); 1723 } 1724 } 1725 /*-----------------------------------------------------------*/ 1726 1727 #if ( configUSE_TIMERS == 1 ) MPU_pvTimerGetTimerID(const TimerHandle_t xTimer)1728 void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */ 1729 { 1730 void * pvReturn; 1731 1732 if( portIS_PRIVILEGED() == pdFALSE ) 1733 { 1734 portRAISE_PRIVILEGE(); 1735 portMEMORY_BARRIER(); 1736 1737 pvReturn = pvTimerGetTimerID( xTimer ); 1738 portMEMORY_BARRIER(); 1739 1740 portRESET_PRIVILEGE(); 1741 portMEMORY_BARRIER(); 1742 } 1743 else 1744 { 1745 pvReturn = pvTimerGetTimerID( xTimer ); 1746 } 1747 1748 return pvReturn; 1749 } 1750 #endif /* if ( configUSE_TIMERS == 1 ) */ 1751 /*-----------------------------------------------------------*/ 1752 1753 #if ( configUSE_TIMERS == 1 ) MPU_vTimerSetTimerID(TimerHandle_t xTimer,void * pvNewID)1754 void MPU_vTimerSetTimerID( TimerHandle_t xTimer, 1755 void * pvNewID ) /* FREERTOS_SYSTEM_CALL */ 1756 { 1757 if( portIS_PRIVILEGED() == pdFALSE ) 1758 { 1759 portRAISE_PRIVILEGE(); 1760 portMEMORY_BARRIER(); 1761 1762 vTimerSetTimerID( xTimer, pvNewID ); 1763 portMEMORY_BARRIER(); 1764 1765 portRESET_PRIVILEGE(); 1766 portMEMORY_BARRIER(); 1767 } 1768 else 1769 { 1770 vTimerSetTimerID( xTimer, pvNewID ); 1771 } 1772 } 1773 #endif /* if ( configUSE_TIMERS == 1 ) */ 1774 /*-----------------------------------------------------------*/ 1775 1776 #if ( configUSE_TIMERS == 1 ) MPU_xTimerIsTimerActive(TimerHandle_t xTimer)1777 BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */ 1778 { 1779 BaseType_t xReturn; 1780 1781 if( portIS_PRIVILEGED() == pdFALSE ) 1782 { 1783 portRAISE_PRIVILEGE(); 1784 portMEMORY_BARRIER(); 1785 1786 xReturn = xTimerIsTimerActive( xTimer ); 1787 portMEMORY_BARRIER(); 1788 1789 portRESET_PRIVILEGE(); 1790 portMEMORY_BARRIER(); 1791 } 1792 else 1793 { 1794 xReturn = xTimerIsTimerActive( xTimer ); 1795 } 1796 1797 return xReturn; 1798 } 1799 #endif /* if ( configUSE_TIMERS == 1 ) */ 1800 /*-----------------------------------------------------------*/ 1801 1802 #if ( configUSE_TIMERS == 1 ) MPU_xTimerGetTimerDaemonTaskHandle(void)1803 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */ 1804 { 1805 TaskHandle_t xReturn; 1806 1807 if( portIS_PRIVILEGED() == pdFALSE ) 1808 { 1809 portRAISE_PRIVILEGE(); 1810 portMEMORY_BARRIER(); 1811 1812 xReturn = xTimerGetTimerDaemonTaskHandle(); 1813 portMEMORY_BARRIER(); 1814 1815 portRESET_PRIVILEGE(); 1816 portMEMORY_BARRIER(); 1817 } 1818 else 1819 { 1820 xReturn = xTimerGetTimerDaemonTaskHandle(); 1821 } 1822 1823 return xReturn; 1824 } 1825 #endif /* if ( configUSE_TIMERS == 1 ) */ 1826 /*-----------------------------------------------------------*/ 1827 1828 #if ( configUSE_TIMERS == 1 ) MPU_vTimerSetReloadMode(TimerHandle_t xTimer,const BaseType_t xAutoReload)1829 void MPU_vTimerSetReloadMode( TimerHandle_t xTimer, 1830 const BaseType_t xAutoReload ) /* FREERTOS_SYSTEM_CALL */ 1831 { 1832 if( portIS_PRIVILEGED() == pdFALSE ) 1833 { 1834 portRAISE_PRIVILEGE(); 1835 portMEMORY_BARRIER(); 1836 1837 vTimerSetReloadMode( xTimer, xAutoReload ); 1838 portMEMORY_BARRIER(); 1839 1840 portRESET_PRIVILEGE(); 1841 portMEMORY_BARRIER(); 1842 } 1843 else 1844 { 1845 vTimerSetReloadMode( xTimer, xAutoReload ); 1846 } 1847 } 1848 #endif /* if ( configUSE_TIMERS == 1 ) */ 1849 /*-----------------------------------------------------------*/ 1850 1851 #if ( configUSE_TIMERS == 1 ) MPU_uxTimerGetReloadMode(TimerHandle_t xTimer)1852 UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer ) 1853 { 1854 UBaseType_t uxReturn; 1855 1856 if( portIS_PRIVILEGED() == pdFALSE ) 1857 { 1858 portRAISE_PRIVILEGE(); 1859 portMEMORY_BARRIER(); 1860 1861 uxReturn = uxTimerGetReloadMode( xTimer ); 1862 portMEMORY_BARRIER(); 1863 1864 portRESET_PRIVILEGE(); 1865 portMEMORY_BARRIER(); 1866 } 1867 else 1868 { 1869 uxReturn = uxTimerGetReloadMode( xTimer ); 1870 } 1871 1872 return uxReturn; 1873 } 1874 #endif /* if ( configUSE_TIMERS == 1 ) */ 1875 /*-----------------------------------------------------------*/ 1876 1877 #if ( configUSE_TIMERS == 1 ) MPU_pcTimerGetName(TimerHandle_t xTimer)1878 const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */ 1879 { 1880 const char * pcReturn; 1881 1882 if( portIS_PRIVILEGED() == pdFALSE ) 1883 { 1884 portRAISE_PRIVILEGE(); 1885 portMEMORY_BARRIER(); 1886 1887 pcReturn = pcTimerGetName( xTimer ); 1888 portMEMORY_BARRIER(); 1889 1890 portRESET_PRIVILEGE(); 1891 portMEMORY_BARRIER(); 1892 } 1893 else 1894 { 1895 pcReturn = pcTimerGetName( xTimer ); 1896 } 1897 1898 return pcReturn; 1899 } 1900 #endif /* if ( configUSE_TIMERS == 1 ) */ 1901 /*-----------------------------------------------------------*/ 1902 1903 #if ( configUSE_TIMERS == 1 ) MPU_xTimerGetPeriod(TimerHandle_t xTimer)1904 TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */ 1905 { 1906 TickType_t xReturn; 1907 1908 if( portIS_PRIVILEGED() == pdFALSE ) 1909 { 1910 portRAISE_PRIVILEGE(); 1911 portMEMORY_BARRIER(); 1912 1913 xReturn = xTimerGetPeriod( xTimer ); 1914 portMEMORY_BARRIER(); 1915 1916 portRESET_PRIVILEGE(); 1917 portMEMORY_BARRIER(); 1918 } 1919 else 1920 { 1921 xReturn = xTimerGetPeriod( xTimer ); 1922 } 1923 1924 return xReturn; 1925 } 1926 #endif /* if ( configUSE_TIMERS == 1 ) */ 1927 /*-----------------------------------------------------------*/ 1928 1929 #if ( configUSE_TIMERS == 1 ) MPU_xTimerGetExpiryTime(TimerHandle_t xTimer)1930 TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */ 1931 { 1932 TickType_t xReturn; 1933 1934 if( portIS_PRIVILEGED() == pdFALSE ) 1935 { 1936 portRAISE_PRIVILEGE(); 1937 portMEMORY_BARRIER(); 1938 1939 xReturn = xTimerGetExpiryTime( xTimer ); 1940 portMEMORY_BARRIER(); 1941 1942 portRESET_PRIVILEGE(); 1943 portMEMORY_BARRIER(); 1944 } 1945 else 1946 { 1947 xReturn = xTimerGetExpiryTime( xTimer ); 1948 } 1949 1950 return xReturn; 1951 } 1952 #endif /* if ( configUSE_TIMERS == 1 ) */ 1953 /*-----------------------------------------------------------*/ 1954 1955 #if ( configUSE_TIMERS == 1 ) MPU_xTimerGenericCommandFromTask(TimerHandle_t xTimer,const BaseType_t xCommandID,const TickType_t xOptionalValue,BaseType_t * const pxHigherPriorityTaskWoken,const TickType_t xTicksToWait)1956 BaseType_t MPU_xTimerGenericCommandFromTask( TimerHandle_t xTimer, 1957 const BaseType_t xCommandID, 1958 const TickType_t xOptionalValue, 1959 BaseType_t * const pxHigherPriorityTaskWoken, 1960 const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 1961 { 1962 BaseType_t xReturn; 1963 1964 if( portIS_PRIVILEGED() == pdFALSE ) 1965 { 1966 portRAISE_PRIVILEGE(); 1967 portMEMORY_BARRIER(); 1968 1969 xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait ); 1970 portMEMORY_BARRIER(); 1971 1972 portRESET_PRIVILEGE(); 1973 portMEMORY_BARRIER(); 1974 } 1975 else 1976 { 1977 xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait ); 1978 } 1979 1980 return xReturn; 1981 } 1982 #endif /* if ( configUSE_TIMERS == 1 ) */ 1983 /*-----------------------------------------------------------*/ 1984 1985 #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) MPU_xEventGroupCreate(void)1986 EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */ 1987 { 1988 EventGroupHandle_t xReturn; 1989 1990 if( portIS_PRIVILEGED() == pdFALSE ) 1991 { 1992 portRAISE_PRIVILEGE(); 1993 portMEMORY_BARRIER(); 1994 1995 xReturn = xEventGroupCreate(); 1996 portMEMORY_BARRIER(); 1997 1998 portRESET_PRIVILEGE(); 1999 portMEMORY_BARRIER(); 2000 } 2001 else 2002 { 2003 xReturn = xEventGroupCreate(); 2004 } 2005 2006 return xReturn; 2007 } 2008 #endif /* #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */ 2009 /*-----------------------------------------------------------*/ 2010 2011 #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) MPU_xEventGroupCreateStatic(StaticEventGroup_t * pxEventGroupBuffer)2012 EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */ 2013 { 2014 EventGroupHandle_t xReturn; 2015 2016 if( portIS_PRIVILEGED() == pdFALSE ) 2017 { 2018 portRAISE_PRIVILEGE(); 2019 portMEMORY_BARRIER(); 2020 2021 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer ); 2022 portMEMORY_BARRIER(); 2023 2024 portRESET_PRIVILEGE(); 2025 portMEMORY_BARRIER(); 2026 } 2027 else 2028 { 2029 xReturn = xEventGroupCreateStatic( pxEventGroupBuffer ); 2030 } 2031 2032 return xReturn; 2033 } 2034 #endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */ 2035 /*-----------------------------------------------------------*/ 2036 2037 #if ( configUSE_EVENT_GROUPS == 1 ) MPU_xEventGroupWaitBits(EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToWaitFor,const BaseType_t xClearOnExit,const BaseType_t xWaitForAllBits,TickType_t xTicksToWait)2038 EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, 2039 const EventBits_t uxBitsToWaitFor, 2040 const BaseType_t xClearOnExit, 2041 const BaseType_t xWaitForAllBits, 2042 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 2043 { 2044 EventBits_t xReturn; 2045 2046 if( portIS_PRIVILEGED() == pdFALSE ) 2047 { 2048 portRAISE_PRIVILEGE(); 2049 portMEMORY_BARRIER(); 2050 2051 xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait ); 2052 portMEMORY_BARRIER(); 2053 2054 portRESET_PRIVILEGE(); 2055 portMEMORY_BARRIER(); 2056 } 2057 else 2058 { 2059 xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait ); 2060 } 2061 2062 return xReturn; 2063 } 2064 #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */ 2065 /*-----------------------------------------------------------*/ 2066 2067 #if ( configUSE_EVENT_GROUPS == 1 ) MPU_xEventGroupClearBits(EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToClear)2068 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, 2069 const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */ 2070 { 2071 EventBits_t xReturn; 2072 2073 if( portIS_PRIVILEGED() == pdFALSE ) 2074 { 2075 portRAISE_PRIVILEGE(); 2076 portMEMORY_BARRIER(); 2077 2078 xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear ); 2079 portMEMORY_BARRIER(); 2080 2081 portRESET_PRIVILEGE(); 2082 portMEMORY_BARRIER(); 2083 } 2084 else 2085 { 2086 xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear ); 2087 } 2088 2089 return xReturn; 2090 } 2091 #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */ 2092 /*-----------------------------------------------------------*/ 2093 2094 #if ( configUSE_EVENT_GROUPS == 1 ) MPU_xEventGroupSetBits(EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToSet)2095 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, 2096 const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */ 2097 { 2098 EventBits_t xReturn; 2099 2100 if( portIS_PRIVILEGED() == pdFALSE ) 2101 { 2102 portRAISE_PRIVILEGE(); 2103 portMEMORY_BARRIER(); 2104 2105 xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet ); 2106 portMEMORY_BARRIER(); 2107 2108 portRESET_PRIVILEGE(); 2109 portMEMORY_BARRIER(); 2110 } 2111 else 2112 { 2113 xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet ); 2114 } 2115 2116 return xReturn; 2117 } 2118 #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */ 2119 /*-----------------------------------------------------------*/ 2120 2121 #if ( configUSE_EVENT_GROUPS == 1 ) MPU_xEventGroupSync(EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToSet,const EventBits_t uxBitsToWaitFor,TickType_t xTicksToWait)2122 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, 2123 const EventBits_t uxBitsToSet, 2124 const EventBits_t uxBitsToWaitFor, 2125 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 2126 { 2127 EventBits_t xReturn; 2128 2129 if( portIS_PRIVILEGED() == pdFALSE ) 2130 { 2131 portRAISE_PRIVILEGE(); 2132 portMEMORY_BARRIER(); 2133 2134 xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait ); 2135 portMEMORY_BARRIER(); 2136 2137 portRESET_PRIVILEGE(); 2138 portMEMORY_BARRIER(); 2139 } 2140 else 2141 { 2142 xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait ); 2143 } 2144 2145 return xReturn; 2146 } 2147 #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */ 2148 /*-----------------------------------------------------------*/ 2149 2150 #if ( configUSE_EVENT_GROUPS == 1 ) MPU_vEventGroupDelete(EventGroupHandle_t xEventGroup)2151 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */ 2152 { 2153 if( portIS_PRIVILEGED() == pdFALSE ) 2154 { 2155 portRAISE_PRIVILEGE(); 2156 portMEMORY_BARRIER(); 2157 2158 vEventGroupDelete( xEventGroup ); 2159 portMEMORY_BARRIER(); 2160 2161 portRESET_PRIVILEGE(); 2162 portMEMORY_BARRIER(); 2163 } 2164 else 2165 { 2166 vEventGroupDelete( xEventGroup ); 2167 } 2168 } 2169 #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */ 2170 /*-----------------------------------------------------------*/ 2171 2172 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferSend(StreamBufferHandle_t xStreamBuffer,const void * pvTxData,size_t xDataLengthBytes,TickType_t xTicksToWait)2173 size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, 2174 const void * pvTxData, 2175 size_t xDataLengthBytes, 2176 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 2177 { 2178 size_t xReturn; 2179 2180 if( portIS_PRIVILEGED() == pdFALSE ) 2181 { 2182 portRAISE_PRIVILEGE(); 2183 portMEMORY_BARRIER(); 2184 2185 xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait ); 2186 portMEMORY_BARRIER(); 2187 2188 portRESET_PRIVILEGE(); 2189 portMEMORY_BARRIER(); 2190 } 2191 else 2192 { 2193 xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait ); 2194 } 2195 2196 return xReturn; 2197 } 2198 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2199 /*-----------------------------------------------------------*/ 2200 2201 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferNextMessageLengthBytes(StreamBufferHandle_t xStreamBuffer)2202 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */ 2203 { 2204 size_t xReturn; 2205 2206 if( portIS_PRIVILEGED() == pdFALSE ) 2207 { 2208 portRAISE_PRIVILEGE(); 2209 portMEMORY_BARRIER(); 2210 2211 xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer ); 2212 portMEMORY_BARRIER(); 2213 2214 portRESET_PRIVILEGE(); 2215 portMEMORY_BARRIER(); 2216 } 2217 else 2218 { 2219 xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer ); 2220 } 2221 2222 return xReturn; 2223 } 2224 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2225 /*-----------------------------------------------------------*/ 2226 2227 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferReceive(StreamBufferHandle_t xStreamBuffer,void * pvRxData,size_t xBufferLengthBytes,TickType_t xTicksToWait)2228 size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, 2229 void * pvRxData, 2230 size_t xBufferLengthBytes, 2231 TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */ 2232 { 2233 size_t xReturn; 2234 2235 if( portIS_PRIVILEGED() == pdFALSE ) 2236 { 2237 portRAISE_PRIVILEGE(); 2238 portMEMORY_BARRIER(); 2239 2240 xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait ); 2241 portMEMORY_BARRIER(); 2242 2243 portRESET_PRIVILEGE(); 2244 portMEMORY_BARRIER(); 2245 } 2246 else 2247 { 2248 xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait ); 2249 } 2250 2251 return xReturn; 2252 } 2253 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2254 /*-----------------------------------------------------------*/ 2255 2256 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_vStreamBufferDelete(StreamBufferHandle_t xStreamBuffer)2257 void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */ 2258 { 2259 if( portIS_PRIVILEGED() == pdFALSE ) 2260 { 2261 portRAISE_PRIVILEGE(); 2262 portMEMORY_BARRIER(); 2263 2264 vStreamBufferDelete( xStreamBuffer ); 2265 portMEMORY_BARRIER(); 2266 2267 portRESET_PRIVILEGE(); 2268 portMEMORY_BARRIER(); 2269 } 2270 else 2271 { 2272 vStreamBufferDelete( xStreamBuffer ); 2273 } 2274 } 2275 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2276 /*-----------------------------------------------------------*/ 2277 2278 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferIsFull(StreamBufferHandle_t xStreamBuffer)2279 BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */ 2280 { 2281 BaseType_t xReturn; 2282 2283 if( portIS_PRIVILEGED() == pdFALSE ) 2284 { 2285 portRAISE_PRIVILEGE(); 2286 portMEMORY_BARRIER(); 2287 2288 xReturn = xStreamBufferIsFull( xStreamBuffer ); 2289 portMEMORY_BARRIER(); 2290 2291 portRESET_PRIVILEGE(); 2292 portMEMORY_BARRIER(); 2293 } 2294 else 2295 { 2296 xReturn = xStreamBufferIsFull( xStreamBuffer ); 2297 } 2298 2299 return xReturn; 2300 } 2301 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2302 /*-----------------------------------------------------------*/ 2303 2304 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferIsEmpty(StreamBufferHandle_t xStreamBuffer)2305 BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */ 2306 { 2307 BaseType_t xReturn; 2308 2309 if( portIS_PRIVILEGED() == pdFALSE ) 2310 { 2311 portRAISE_PRIVILEGE(); 2312 portMEMORY_BARRIER(); 2313 2314 xReturn = xStreamBufferIsEmpty( xStreamBuffer ); 2315 portMEMORY_BARRIER(); 2316 2317 portRESET_PRIVILEGE(); 2318 portMEMORY_BARRIER(); 2319 } 2320 else 2321 { 2322 xReturn = xStreamBufferIsEmpty( xStreamBuffer ); 2323 } 2324 2325 return xReturn; 2326 } 2327 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2328 /*-----------------------------------------------------------*/ 2329 2330 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferReset(StreamBufferHandle_t xStreamBuffer)2331 BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */ 2332 { 2333 BaseType_t xReturn; 2334 2335 if( portIS_PRIVILEGED() == pdFALSE ) 2336 { 2337 portRAISE_PRIVILEGE(); 2338 portMEMORY_BARRIER(); 2339 2340 xReturn = xStreamBufferReset( xStreamBuffer ); 2341 portMEMORY_BARRIER(); 2342 2343 portRESET_PRIVILEGE(); 2344 portMEMORY_BARRIER(); 2345 } 2346 else 2347 { 2348 xReturn = xStreamBufferReset( xStreamBuffer ); 2349 } 2350 2351 return xReturn; 2352 } 2353 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2354 /*-----------------------------------------------------------*/ 2355 2356 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferSpacesAvailable(StreamBufferHandle_t xStreamBuffer)2357 size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */ 2358 { 2359 size_t xReturn; 2360 2361 if( portIS_PRIVILEGED() == pdFALSE ) 2362 { 2363 portRAISE_PRIVILEGE(); 2364 portMEMORY_BARRIER(); 2365 xReturn = xStreamBufferSpacesAvailable( xStreamBuffer ); 2366 portMEMORY_BARRIER(); 2367 2368 portRESET_PRIVILEGE(); 2369 portMEMORY_BARRIER(); 2370 } 2371 else 2372 { 2373 xReturn = xStreamBufferSpacesAvailable( xStreamBuffer ); 2374 } 2375 2376 return xReturn; 2377 } 2378 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2379 /*-----------------------------------------------------------*/ 2380 2381 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferBytesAvailable(StreamBufferHandle_t xStreamBuffer)2382 size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */ 2383 { 2384 size_t xReturn; 2385 2386 if( portIS_PRIVILEGED() == pdFALSE ) 2387 { 2388 portRAISE_PRIVILEGE(); 2389 portMEMORY_BARRIER(); 2390 2391 xReturn = xStreamBufferBytesAvailable( xStreamBuffer ); 2392 portMEMORY_BARRIER(); 2393 2394 portRESET_PRIVILEGE(); 2395 portMEMORY_BARRIER(); 2396 } 2397 else 2398 { 2399 xReturn = xStreamBufferBytesAvailable( xStreamBuffer ); 2400 } 2401 2402 return xReturn; 2403 } 2404 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2405 /*-----------------------------------------------------------*/ 2406 2407 #if ( configUSE_STREAM_BUFFERS == 1 ) MPU_xStreamBufferSetTriggerLevel(StreamBufferHandle_t xStreamBuffer,size_t xTriggerLevel)2408 BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, 2409 size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */ 2410 { 2411 BaseType_t xReturn; 2412 2413 if( portIS_PRIVILEGED() == pdFALSE ) 2414 { 2415 portRAISE_PRIVILEGE(); 2416 portMEMORY_BARRIER(); 2417 2418 xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel ); 2419 portMEMORY_BARRIER(); 2420 2421 portRESET_PRIVILEGE(); 2422 portMEMORY_BARRIER(); 2423 } 2424 else 2425 { 2426 xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel ); 2427 } 2428 2429 return xReturn; 2430 } 2431 #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */ 2432 /*-----------------------------------------------------------*/ 2433 2434 #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) MPU_xStreamBufferGenericCreate(size_t xBufferSizeBytes,size_t xTriggerLevelBytes,BaseType_t xStreamBufferType,StreamBufferCallbackFunction_t pxSendCompletedCallback,StreamBufferCallbackFunction_t pxReceiveCompletedCallback)2435 StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes, 2436 size_t xTriggerLevelBytes, 2437 BaseType_t xStreamBufferType, 2438 StreamBufferCallbackFunction_t pxSendCompletedCallback, 2439 StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */ 2440 { 2441 StreamBufferHandle_t xReturn; 2442 2443 /** 2444 * Stream buffer application level callback functionality is disabled for MPU 2445 * enabled ports. 2446 */ 2447 configASSERT( ( pxSendCompletedCallback == NULL ) && 2448 ( pxReceiveCompletedCallback == NULL ) ); 2449 2450 if( ( pxSendCompletedCallback == NULL ) && 2451 ( pxReceiveCompletedCallback == NULL ) ) 2452 { 2453 if( portIS_PRIVILEGED() == pdFALSE ) 2454 { 2455 portRAISE_PRIVILEGE(); 2456 portMEMORY_BARRIER(); 2457 2458 xReturn = xStreamBufferGenericCreate( xBufferSizeBytes, 2459 xTriggerLevelBytes, 2460 xStreamBufferType, 2461 NULL, 2462 NULL ); 2463 portMEMORY_BARRIER(); 2464 2465 portRESET_PRIVILEGE(); 2466 portMEMORY_BARRIER(); 2467 } 2468 else 2469 { 2470 xReturn = xStreamBufferGenericCreate( xBufferSizeBytes, 2471 xTriggerLevelBytes, 2472 xStreamBufferType, 2473 NULL, 2474 NULL ); 2475 } 2476 } 2477 else 2478 { 2479 traceSTREAM_BUFFER_CREATE_FAILED( xStreamBufferType ); 2480 xReturn = NULL; 2481 } 2482 2483 return xReturn; 2484 } 2485 #endif /* #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */ 2486 /*-----------------------------------------------------------*/ 2487 2488 #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) 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)2489 StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes, 2490 size_t xTriggerLevelBytes, 2491 BaseType_t xStreamBufferType, 2492 uint8_t * const pucStreamBufferStorageArea, 2493 StaticStreamBuffer_t * const pxStaticStreamBuffer, 2494 StreamBufferCallbackFunction_t pxSendCompletedCallback, 2495 StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */ 2496 { 2497 StreamBufferHandle_t xReturn; 2498 2499 /** 2500 * Stream buffer application level callback functionality is disabled for MPU 2501 * enabled ports. 2502 */ 2503 configASSERT( ( pxSendCompletedCallback == NULL ) && 2504 ( pxReceiveCompletedCallback == NULL ) ); 2505 2506 if( ( pxSendCompletedCallback == NULL ) && 2507 ( pxReceiveCompletedCallback == NULL ) ) 2508 { 2509 if( portIS_PRIVILEGED() == pdFALSE ) 2510 { 2511 portRAISE_PRIVILEGE(); 2512 portMEMORY_BARRIER(); 2513 2514 xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes, 2515 xTriggerLevelBytes, 2516 xStreamBufferType, 2517 pucStreamBufferStorageArea, 2518 pxStaticStreamBuffer, 2519 NULL, 2520 NULL ); 2521 portMEMORY_BARRIER(); 2522 2523 portRESET_PRIVILEGE(); 2524 portMEMORY_BARRIER(); 2525 } 2526 else 2527 { 2528 xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes, 2529 xTriggerLevelBytes, 2530 xStreamBufferType, 2531 pucStreamBufferStorageArea, 2532 pxStaticStreamBuffer, 2533 NULL, 2534 NULL ); 2535 } 2536 } 2537 else 2538 { 2539 traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xStreamBufferType ); 2540 xReturn = NULL; 2541 } 2542 2543 return xReturn; 2544 } 2545 #endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */ 2546 /*-----------------------------------------------------------*/ 2547 2548 2549 /* Functions that the application writer wants to execute in privileged mode 2550 * can be defined in application_defined_privileged_functions.h. The functions 2551 * must take the same format as those above whereby the privilege state on exit 2552 * equals the privilege state on entry. For example: 2553 * 2554 * void MPU_FunctionName( [parameters ] ) FREERTOS_SYSTEM_CALL; 2555 * void MPU_FunctionName( [parameters ] ) 2556 * { 2557 * if( portIS_PRIVILEGED() == pdFALSE ) 2558 * { 2559 * portRAISE_PRIVILEGE(); 2560 * portMEMORY_BARRIER(); 2561 * 2562 * FunctionName( [parameters ] ); 2563 * portMEMORY_BARRIER(); 2564 * 2565 * portRESET_PRIVILEGE(); 2566 * portMEMORY_BARRIER(); 2567 * } 2568 * else 2569 * { 2570 * FunctionName( [parameters ] ); 2571 * } 2572 * } 2573 */ 2574 2575 #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1 2576 #include "application_defined_privileged_functions.h" 2577 #endif 2578 /*-----------------------------------------------------------*/ 2579 2580 #endif /* #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) ) */ 2581 /*-----------------------------------------------------------*/ 2582