1 /* 2 * FreeRTOS Kernel V11.0.1 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 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining 30 * all the API functions to use the MPU wrappers. That should only be done when 31 * task.h is included from an application file. */ 32 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE 33 34 /* Scheduler includes. */ 35 #include "FreeRTOS.h" 36 #include "task.h" 37 #include "queue.h" 38 #include "timers.h" 39 #include "event_groups.h" 40 #include "stream_buffer.h" 41 #include "mpu_prototypes.h" 42 #include "mpu_syscall_numbers.h" 43 44 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE 45 /*-----------------------------------------------------------*/ 46 47 #if ( ( configENABLE_MPU == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) ) 48 49 #if ( INCLUDE_xTaskDelayUntil == 1 ) 50 51 BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime, 52 const TickType_t xTimeIncrement ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 53 MPU_xTaskDelayUntil(TickType_t * const pxPreviousWakeTime,const TickType_t xTimeIncrement)54 BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime, 55 const TickType_t xTimeIncrement ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 56 { 57 __asm volatile 58 ( 59 " .syntax unified \n" 60 " .extern MPU_xTaskDelayUntilImpl \n" 61 " \n" 62 " push {r0, r1} \n" 63 " mrs r0, control \n" 64 " movs r1, #1 \n" 65 " tst r0, r1 \n" 66 " bne MPU_xTaskDelayUntil_Unpriv \n" 67 " MPU_xTaskDelayUntil_Priv: \n" 68 " pop {r0, r1} \n" 69 " b MPU_xTaskDelayUntilImpl \n" 70 " MPU_xTaskDelayUntil_Unpriv: \n" 71 " pop {r0, r1} \n" 72 " svc %0 \n" 73 " \n" 74 : : "i" ( SYSTEM_CALL_xTaskDelayUntil ) : "memory" 75 ); 76 } 77 78 #endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */ 79 /*-----------------------------------------------------------*/ 80 81 #if ( INCLUDE_xTaskAbortDelay == 1 ) 82 83 BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 84 MPU_xTaskAbortDelay(TaskHandle_t xTask)85 BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 86 { 87 __asm volatile 88 ( 89 " .syntax unified \n" 90 " .extern MPU_xTaskAbortDelayImpl \n" 91 " \n" 92 " push {r0, r1} \n" 93 " mrs r0, control \n" 94 " movs r1, #1 \n" 95 " tst r0, r1 \n" 96 " bne MPU_xTaskAbortDelay_Unpriv \n" 97 " MPU_xTaskAbortDelay_Priv: \n" 98 " pop {r0, r1} \n" 99 " b MPU_xTaskAbortDelayImpl \n" 100 " MPU_xTaskAbortDelay_Unpriv: \n" 101 " pop {r0, r1} \n" 102 " svc %0 \n" 103 " \n" 104 : : "i" ( SYSTEM_CALL_xTaskAbortDelay ) : "memory" 105 ); 106 } 107 108 #endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */ 109 /*-----------------------------------------------------------*/ 110 111 #if ( INCLUDE_vTaskDelay == 1 ) 112 113 void MPU_vTaskDelay( const TickType_t xTicksToDelay ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 114 MPU_vTaskDelay(const TickType_t xTicksToDelay)115 void MPU_vTaskDelay( const TickType_t xTicksToDelay ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 116 { 117 __asm volatile 118 ( 119 " .syntax unified \n" 120 " .extern MPU_vTaskDelayImpl \n" 121 " \n" 122 " push {r0, r1} \n" 123 " mrs r0, control \n" 124 " movs r1, #1 \n" 125 " tst r0, r1 \n" 126 " bne MPU_vTaskDelay_Unpriv \n" 127 " MPU_vTaskDelay_Priv: \n" 128 " pop {r0, r1} \n" 129 " b MPU_vTaskDelayImpl \n" 130 " MPU_vTaskDelay_Unpriv: \n" 131 " pop {r0, r1} \n" 132 " svc %0 \n" 133 " \n" 134 : : "i" ( SYSTEM_CALL_vTaskDelay ) : "memory" 135 ); 136 } 137 138 #endif /* if ( INCLUDE_vTaskDelay == 1 ) */ 139 /*-----------------------------------------------------------*/ 140 141 #if ( INCLUDE_uxTaskPriorityGet == 1 ) 142 143 UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 144 MPU_uxTaskPriorityGet(const TaskHandle_t xTask)145 UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 146 { 147 __asm volatile 148 ( 149 " .syntax unified \n" 150 " .extern MPU_uxTaskPriorityGetImpl \n" 151 " \n" 152 " push {r0, r1} \n" 153 " mrs r0, control \n" 154 " movs r1, #1 \n" 155 " tst r0, r1 \n" 156 " bne MPU_uxTaskPriorityGet_Unpriv \n" 157 " MPU_uxTaskPriorityGet_Priv: \n" 158 " pop {r0, r1} \n" 159 " b MPU_uxTaskPriorityGetImpl \n" 160 " MPU_uxTaskPriorityGet_Unpriv: \n" 161 " pop {r0, r1} \n" 162 " svc %0 \n" 163 " \n" 164 : : "i" ( SYSTEM_CALL_uxTaskPriorityGet ) : "memory" 165 ); 166 } 167 168 #endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */ 169 /*-----------------------------------------------------------*/ 170 171 #if ( INCLUDE_eTaskGetState == 1 ) 172 173 eTaskState MPU_eTaskGetState( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 174 MPU_eTaskGetState(TaskHandle_t xTask)175 eTaskState MPU_eTaskGetState( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 176 { 177 __asm volatile 178 ( 179 " .syntax unified \n" 180 " .extern MPU_eTaskGetStateImpl \n" 181 " \n" 182 " push {r0, r1} \n" 183 " mrs r0, control \n" 184 " movs r1, #1 \n" 185 " tst r0, r1 \n" 186 " bne MPU_eTaskGetState_Unpriv \n" 187 " MPU_eTaskGetState_Priv: \n" 188 " pop {r0, r1} \n" 189 " b MPU_eTaskGetStateImpl \n" 190 " MPU_eTaskGetState_Unpriv: \n" 191 " pop {r0, r1} \n" 192 " svc %0 \n" 193 " \n" 194 : : "i" ( SYSTEM_CALL_eTaskGetState ) : "memory" 195 ); 196 } 197 198 #endif /* if ( INCLUDE_eTaskGetState == 1 ) */ 199 /*-----------------------------------------------------------*/ 200 201 #if ( configUSE_TRACE_FACILITY == 1 ) 202 203 void MPU_vTaskGetInfo( TaskHandle_t xTask, 204 TaskStatus_t * pxTaskStatus, 205 BaseType_t xGetFreeStackSpace, 206 eTaskState eState ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 207 MPU_vTaskGetInfo(TaskHandle_t xTask,TaskStatus_t * pxTaskStatus,BaseType_t xGetFreeStackSpace,eTaskState eState)208 void MPU_vTaskGetInfo( TaskHandle_t xTask, 209 TaskStatus_t * pxTaskStatus, 210 BaseType_t xGetFreeStackSpace, 211 eTaskState eState ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 212 { 213 __asm volatile 214 ( 215 " .syntax unified \n" 216 " .extern MPU_vTaskGetInfoImpl \n" 217 " \n" 218 " push {r0, r1} \n" 219 " mrs r0, control \n" 220 " movs r1, #1 \n" 221 " tst r0, r1 \n" 222 " bne MPU_vTaskGetInfo_Unpriv \n" 223 " MPU_vTaskGetInfo_Priv: \n" 224 " pop {r0, r1} \n" 225 " b MPU_vTaskGetInfoImpl \n" 226 " MPU_vTaskGetInfo_Unpriv: \n" 227 " pop {r0, r1} \n" 228 " svc %0 \n" 229 " \n" 230 : : "i" ( SYSTEM_CALL_vTaskGetInfo ) : "memory" 231 ); 232 } 233 234 #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */ 235 /*-----------------------------------------------------------*/ 236 237 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) 238 239 TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 240 MPU_xTaskGetIdleTaskHandle(void)241 TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 242 { 243 __asm volatile 244 ( 245 " .syntax unified \n" 246 " .extern MPU_xTaskGetIdleTaskHandleImpl \n" 247 " \n" 248 " push {r0, r1} \n" 249 " mrs r0, control \n" 250 " movs r1, #1 \n" 251 " tst r0, r1 \n" 252 " bne MPU_xTaskGetIdleTaskHandle_Unpriv \n" 253 " MPU_xTaskGetIdleTaskHandle_Priv: \n" 254 " pop {r0, r1} \n" 255 " b MPU_xTaskGetIdleTaskHandleImpl \n" 256 " MPU_xTaskGetIdleTaskHandle_Unpriv: \n" 257 " pop {r0, r1} \n" 258 " svc %0 \n" 259 " \n" 260 : : "i" ( SYSTEM_CALL_xTaskGetIdleTaskHandle ) : "memory" 261 ); 262 } 263 264 #endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */ 265 /*-----------------------------------------------------------*/ 266 267 #if ( INCLUDE_vTaskSuspend == 1 ) 268 269 void MPU_vTaskSuspend( TaskHandle_t xTaskToSuspend ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 270 MPU_vTaskSuspend(TaskHandle_t xTaskToSuspend)271 void MPU_vTaskSuspend( TaskHandle_t xTaskToSuspend ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 272 { 273 __asm volatile 274 ( 275 " .syntax unified \n" 276 " .extern MPU_vTaskSuspendImpl \n" 277 " \n" 278 " push {r0, r1} \n" 279 " mrs r0, control \n" 280 " movs r1, #1 \n" 281 " tst r0, r1 \n" 282 " bne MPU_vTaskSuspend_Unpriv \n" 283 " MPU_vTaskSuspend_Priv: \n" 284 " pop {r0, r1} \n" 285 " b MPU_vTaskSuspendImpl \n" 286 " MPU_vTaskSuspend_Unpriv: \n" 287 " pop {r0, r1} \n" 288 " svc %0 \n" 289 " \n" 290 : : "i" ( SYSTEM_CALL_vTaskSuspend ) : "memory" 291 ); 292 } 293 294 #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */ 295 /*-----------------------------------------------------------*/ 296 297 #if ( INCLUDE_vTaskSuspend == 1 ) 298 299 void MPU_vTaskResume( TaskHandle_t xTaskToResume ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 300 MPU_vTaskResume(TaskHandle_t xTaskToResume)301 void MPU_vTaskResume( TaskHandle_t xTaskToResume ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 302 { 303 __asm volatile 304 ( 305 " .syntax unified \n" 306 " .extern MPU_vTaskResumeImpl \n" 307 " \n" 308 " push {r0, r1} \n" 309 " mrs r0, control \n" 310 " movs r1, #1 \n" 311 " tst r0, r1 \n" 312 " bne MPU_vTaskResume_Unpriv \n" 313 " MPU_vTaskResume_Priv: \n" 314 " pop {r0, r1} \n" 315 " b MPU_vTaskResumeImpl \n" 316 " MPU_vTaskResume_Unpriv: \n" 317 " pop {r0, r1} \n" 318 " svc %0 \n" 319 " \n" 320 : : "i" ( SYSTEM_CALL_vTaskResume ) : "memory" 321 ); 322 } 323 324 #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */ 325 /*-----------------------------------------------------------*/ 326 327 TickType_t MPU_xTaskGetTickCount( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 328 MPU_xTaskGetTickCount(void)329 TickType_t MPU_xTaskGetTickCount( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 330 { 331 __asm volatile 332 ( 333 " .syntax unified \n" 334 " .extern MPU_xTaskGetTickCountImpl \n" 335 " \n" 336 " push {r0, r1} \n" 337 " mrs r0, control \n" 338 " movs r1, #1 \n" 339 " tst r0, r1 \n" 340 " bne MPU_xTaskGetTickCount_Unpriv \n" 341 " MPU_xTaskGetTickCount_Priv: \n" 342 " pop {r0, r1} \n" 343 " b MPU_xTaskGetTickCountImpl \n" 344 " MPU_xTaskGetTickCount_Unpriv: \n" 345 " pop {r0, r1} \n" 346 " svc %0 \n" 347 " \n" 348 : : "i" ( SYSTEM_CALL_xTaskGetTickCount ) : "memory" 349 ); 350 } 351 /*-----------------------------------------------------------*/ 352 353 UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 354 MPU_uxTaskGetNumberOfTasks(void)355 UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 356 { 357 __asm volatile 358 ( 359 " .syntax unified \n" 360 " .extern MPU_uxTaskGetNumberOfTasksImpl \n" 361 " \n" 362 " push {r0, r1} \n" 363 " mrs r0, control \n" 364 " movs r1, #1 \n" 365 " tst r0, r1 \n" 366 " bne MPU_uxTaskGetNumberOfTasks_Unpriv \n" 367 " MPU_uxTaskGetNumberOfTasks_Priv: \n" 368 " pop {r0, r1} \n" 369 " b MPU_uxTaskGetNumberOfTasksImpl \n" 370 " MPU_uxTaskGetNumberOfTasks_Unpriv: \n" 371 " pop {r0, r1} \n" 372 " svc %0 \n" 373 " \n" 374 : : "i" ( SYSTEM_CALL_uxTaskGetNumberOfTasks ) : "memory" 375 ); 376 } 377 /*-----------------------------------------------------------*/ 378 379 #if ( configGENERATE_RUN_TIME_STATS == 1 ) 380 381 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounter( const TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 382 MPU_ulTaskGetRunTimeCounter(const TaskHandle_t xTask)383 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounter( const TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 384 { 385 __asm volatile 386 ( 387 " .syntax unified \n" 388 " .extern MPU_ulTaskGetRunTimeCounterImpl \n" 389 " \n" 390 " push {r0, r1} \n" 391 " mrs r0, control \n" 392 " movs r1, #1 \n" 393 " tst r0, r1 \n" 394 " bne MPU_ulTaskGetRunTimeCounter_Unpriv \n" 395 " MPU_ulTaskGetRunTimeCounter_Priv: \n" 396 " pop {r0, r1} \n" 397 " b MPU_ulTaskGetRunTimeCounterImpl \n" 398 " MPU_ulTaskGetRunTimeCounter_Unpriv: \n" 399 " pop {r0, r1} \n" 400 " svc %0 \n" 401 " \n" 402 : : "i" ( SYSTEM_CALL_ulTaskGetRunTimeCounter ) : "memory" 403 ); 404 } 405 406 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) */ 407 /*-----------------------------------------------------------*/ 408 409 #if ( configGENERATE_RUN_TIME_STATS == 1 ) 410 411 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercent( const TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 412 MPU_ulTaskGetRunTimePercent(const TaskHandle_t xTask)413 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercent( const TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 414 { 415 __asm volatile 416 ( 417 " .syntax unified \n" 418 " .extern MPU_ulTaskGetRunTimePercentImpl \n" 419 " \n" 420 " push {r0, r1} \n" 421 " mrs r0, control \n" 422 " movs r1, #1 \n" 423 " tst r0, r1 \n" 424 " bne MPU_ulTaskGetRunTimePercent_Unpriv \n" 425 " MPU_ulTaskGetRunTimePercent_Priv: \n" 426 " pop {r0, r1} \n" 427 " b MPU_ulTaskGetRunTimePercentImpl \n" 428 " MPU_ulTaskGetRunTimePercent_Unpriv: \n" 429 " pop {r0, r1} \n" 430 " svc %0 \n" 431 " \n" 432 : : "i" ( SYSTEM_CALL_ulTaskGetRunTimePercent ) : "memory" 433 ); 434 } 435 436 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) */ 437 /*-----------------------------------------------------------*/ 438 439 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) 440 441 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 442 MPU_ulTaskGetIdleRunTimePercent(void)443 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 444 { 445 __asm volatile 446 ( 447 " .syntax unified \n" 448 " .extern MPU_ulTaskGetIdleRunTimePercentImpl \n" 449 " \n" 450 " push {r0, r1} \n" 451 " mrs r0, control \n" 452 " movs r1, #1 \n" 453 " tst r0, r1 \n" 454 " bne MPU_ulTaskGetIdleRunTimePercent_Unpriv \n" 455 " MPU_ulTaskGetIdleRunTimePercent_Priv: \n" 456 " pop {r0, r1} \n" 457 " b MPU_ulTaskGetIdleRunTimePercentImpl \n" 458 " MPU_ulTaskGetIdleRunTimePercent_Unpriv: \n" 459 " pop {r0, r1} \n" 460 " svc %0 \n" 461 " \n" 462 : : "i" ( SYSTEM_CALL_ulTaskGetIdleRunTimePercent ) : "memory" 463 ); 464 } 465 466 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */ 467 /*-----------------------------------------------------------*/ 468 469 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) 470 471 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 472 MPU_ulTaskGetIdleRunTimeCounter(void)473 configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 474 { 475 __asm volatile 476 ( 477 " .syntax unified \n" 478 " .extern MPU_ulTaskGetIdleRunTimeCounterImpl \n" 479 " \n" 480 " push {r0, r1} \n" 481 " mrs r0, control \n" 482 " movs r1, #1 \n" 483 " tst r0, r1 \n" 484 " bne MPU_ulTaskGetIdleRunTimeCounter_Unpriv \n" 485 " MPU_ulTaskGetIdleRunTimeCounter_Priv: \n" 486 " pop {r0, r1} \n" 487 " b MPU_ulTaskGetIdleRunTimeCounterImpl \n" 488 " MPU_ulTaskGetIdleRunTimeCounter_Unpriv: \n" 489 " pop {r0, r1} \n" 490 " svc %0 \n" 491 " \n" 492 : : "i" ( SYSTEM_CALL_ulTaskGetIdleRunTimeCounter ) : "memory" 493 ); 494 } 495 496 #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */ 497 /*-----------------------------------------------------------*/ 498 499 #if ( configUSE_APPLICATION_TASK_TAG == 1 ) 500 501 void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, 502 TaskHookFunction_t pxHookFunction ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 503 MPU_vTaskSetApplicationTaskTag(TaskHandle_t xTask,TaskHookFunction_t pxHookFunction)504 void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, 505 TaskHookFunction_t pxHookFunction ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 506 { 507 __asm volatile 508 ( 509 " .syntax unified \n" 510 " .extern MPU_vTaskSetApplicationTaskTagImpl \n" 511 " \n" 512 " push {r0, r1} \n" 513 " mrs r0, control \n" 514 " movs r1, #1 \n" 515 " tst r0, r1 \n" 516 " bne MPU_vTaskSetApplicationTaskTag_Unpriv \n" 517 " MPU_vTaskSetApplicationTaskTag_Priv: \n" 518 " pop {r0, r1} \n" 519 " b MPU_vTaskSetApplicationTaskTagImpl \n" 520 " MPU_vTaskSetApplicationTaskTag_Unpriv: \n" 521 " pop {r0, r1} \n" 522 " svc %0 \n" 523 " \n" 524 : : "i" ( SYSTEM_CALL_vTaskSetApplicationTaskTag ) : "memory" 525 ); 526 } 527 528 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */ 529 /*-----------------------------------------------------------*/ 530 531 #if ( configUSE_APPLICATION_TASK_TAG == 1 ) 532 533 TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 534 MPU_xTaskGetApplicationTaskTag(TaskHandle_t xTask)535 TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 536 { 537 __asm volatile 538 ( 539 " .syntax unified \n" 540 " .extern MPU_xTaskGetApplicationTaskTagImpl \n" 541 " \n" 542 " push {r0, r1} \n" 543 " mrs r0, control \n" 544 " movs r1, #1 \n" 545 " tst r0, r1 \n" 546 " bne MPU_xTaskGetApplicationTaskTag_Unpriv \n" 547 " MPU_xTaskGetApplicationTaskTag_Priv: \n" 548 " pop {r0, r1} \n" 549 " b MPU_xTaskGetApplicationTaskTagImpl \n" 550 " MPU_xTaskGetApplicationTaskTag_Unpriv: \n" 551 " pop {r0, r1} \n" 552 " svc %0 \n" 553 " \n" 554 : : "i" ( SYSTEM_CALL_xTaskGetApplicationTaskTag ) : "memory" 555 ); 556 } 557 558 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */ 559 /*-----------------------------------------------------------*/ 560 561 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) 562 563 void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, 564 BaseType_t xIndex, 565 void * pvValue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 566 MPU_vTaskSetThreadLocalStoragePointer(TaskHandle_t xTaskToSet,BaseType_t xIndex,void * pvValue)567 void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, 568 BaseType_t xIndex, 569 void * pvValue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 570 { 571 __asm volatile 572 ( 573 " .syntax unified \n" 574 " .extern MPU_vTaskSetThreadLocalStoragePointerImpl \n" 575 " \n" 576 " push {r0, r1} \n" 577 " mrs r0, control \n" 578 " movs r1, #1 \n" 579 " tst r0, r1 \n" 580 " bne MPU_vTaskSetThreadLocalStoragePointer_Unpriv \n" 581 " MPU_vTaskSetThreadLocalStoragePointer_Priv: \n" 582 " pop {r0, r1} \n" 583 " b MPU_vTaskSetThreadLocalStoragePointerImpl \n" 584 " MPU_vTaskSetThreadLocalStoragePointer_Unpriv: \n" 585 " pop {r0, r1} \n" 586 " svc %0 \n" 587 " \n" 588 : : "i" ( SYSTEM_CALL_vTaskSetThreadLocalStoragePointer ) : "memory" 589 ); 590 } 591 592 #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */ 593 /*-----------------------------------------------------------*/ 594 595 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) 596 597 void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, 598 BaseType_t xIndex ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 599 MPU_pvTaskGetThreadLocalStoragePointer(TaskHandle_t xTaskToQuery,BaseType_t xIndex)600 void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, 601 BaseType_t xIndex ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 602 { 603 __asm volatile 604 ( 605 " .syntax unified \n" 606 " .extern MPU_pvTaskGetThreadLocalStoragePointerImpl \n" 607 " \n" 608 " push {r0, r1} \n" 609 " mrs r0, control \n" 610 " movs r1, #1 \n" 611 " tst r0, r1 \n" 612 " bne MPU_pvTaskGetThreadLocalStoragePointer_Unpriv \n" 613 " MPU_pvTaskGetThreadLocalStoragePointer_Priv: \n" 614 " pop {r0, r1} \n" 615 " b MPU_pvTaskGetThreadLocalStoragePointerImpl \n" 616 " MPU_pvTaskGetThreadLocalStoragePointer_Unpriv: \n" 617 " pop {r0, r1} \n" 618 " svc %0 \n" 619 " \n" 620 : : "i" ( SYSTEM_CALL_pvTaskGetThreadLocalStoragePointer ) : "memory" 621 ); 622 } 623 624 #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */ 625 /*-----------------------------------------------------------*/ 626 627 #if ( configUSE_TRACE_FACILITY == 1 ) 628 629 UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, 630 const UBaseType_t uxArraySize, 631 configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 632 MPU_uxTaskGetSystemState(TaskStatus_t * const pxTaskStatusArray,const UBaseType_t uxArraySize,configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime)633 UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, 634 const UBaseType_t uxArraySize, 635 configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 636 { 637 __asm volatile 638 ( 639 " .syntax unified \n" 640 " .extern MPU_uxTaskGetSystemStateImpl \n" 641 " \n" 642 " push {r0, r1} \n" 643 " mrs r0, control \n" 644 " movs r1, #1 \n" 645 " tst r0, r1 \n" 646 " bne MPU_uxTaskGetSystemState_Unpriv \n" 647 " MPU_uxTaskGetSystemState_Priv: \n" 648 " pop {r0, r1} \n" 649 " b MPU_uxTaskGetSystemStateImpl \n" 650 " MPU_uxTaskGetSystemState_Unpriv: \n" 651 " pop {r0, r1} \n" 652 " svc %0 \n" 653 " \n" 654 : : "i" ( SYSTEM_CALL_uxTaskGetSystemState ) : "memory" 655 ); 656 } 657 658 #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */ 659 /*-----------------------------------------------------------*/ 660 661 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) 662 663 UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 664 MPU_uxTaskGetStackHighWaterMark(TaskHandle_t xTask)665 UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 666 { 667 __asm volatile 668 ( 669 " .syntax unified \n" 670 " .extern MPU_uxTaskGetStackHighWaterMarkImpl \n" 671 " \n" 672 " push {r0, r1} \n" 673 " mrs r0, control \n" 674 " movs r1, #1 \n" 675 " tst r0, r1 \n" 676 " bne MPU_uxTaskGetStackHighWaterMark_Unpriv \n" 677 " MPU_uxTaskGetStackHighWaterMark_Priv: \n" 678 " pop {r0, r1} \n" 679 " b MPU_uxTaskGetStackHighWaterMarkImpl \n" 680 " MPU_uxTaskGetStackHighWaterMark_Unpriv: \n" 681 " pop {r0, r1} \n" 682 " svc %0 \n" 683 " \n" 684 : : "i" ( SYSTEM_CALL_uxTaskGetStackHighWaterMark ) : "memory" 685 ); 686 } 687 688 #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */ 689 /*-----------------------------------------------------------*/ 690 691 #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) 692 693 configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 694 MPU_uxTaskGetStackHighWaterMark2(TaskHandle_t xTask)695 configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 696 { 697 __asm volatile 698 ( 699 " .syntax unified \n" 700 " .extern MPU_uxTaskGetStackHighWaterMark2Impl \n" 701 " \n" 702 " push {r0, r1} \n" 703 " mrs r0, control \n" 704 " movs r1, #1 \n" 705 " tst r0, r1 \n" 706 " bne MPU_uxTaskGetStackHighWaterMark2_Unpriv \n" 707 " MPU_uxTaskGetStackHighWaterMark2_Priv: \n" 708 " pop {r0, r1} \n" 709 " b MPU_uxTaskGetStackHighWaterMark2Impl \n" 710 " MPU_uxTaskGetStackHighWaterMark2_Unpriv: \n" 711 " pop {r0, r1} \n" 712 " svc %0 \n" 713 " \n" 714 : : "i" ( SYSTEM_CALL_uxTaskGetStackHighWaterMark2 ) : "memory" 715 ); 716 } 717 718 #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */ 719 /*-----------------------------------------------------------*/ 720 721 #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) 722 723 TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 724 MPU_xTaskGetCurrentTaskHandle(void)725 TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 726 { 727 __asm volatile 728 ( 729 " .syntax unified \n" 730 " .extern MPU_xTaskGetCurrentTaskHandleImpl \n" 731 " \n" 732 " push {r0, r1} \n" 733 " mrs r0, control \n" 734 " movs r1, #1 \n" 735 " tst r0, r1 \n" 736 " bne MPU_xTaskGetCurrentTaskHandle_Unpriv \n" 737 " MPU_xTaskGetCurrentTaskHandle_Priv: \n" 738 " pop {r0, r1} \n" 739 " b MPU_xTaskGetCurrentTaskHandleImpl \n" 740 " MPU_xTaskGetCurrentTaskHandle_Unpriv: \n" 741 " pop {r0, r1} \n" 742 " svc %0 \n" 743 " \n" 744 : : "i" ( SYSTEM_CALL_xTaskGetCurrentTaskHandle ) : "memory" 745 ); 746 } 747 748 #endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */ 749 /*-----------------------------------------------------------*/ 750 751 #if ( INCLUDE_xTaskGetSchedulerState == 1 ) 752 753 BaseType_t MPU_xTaskGetSchedulerState( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 754 MPU_xTaskGetSchedulerState(void)755 BaseType_t MPU_xTaskGetSchedulerState( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 756 { 757 __asm volatile 758 ( 759 " .syntax unified \n" 760 " .extern MPU_xTaskGetSchedulerStateImpl \n" 761 " \n" 762 " push {r0, r1} \n" 763 " mrs r0, control \n" 764 " movs r1, #1 \n" 765 " tst r0, r1 \n" 766 " bne MPU_xTaskGetSchedulerState_Unpriv \n" 767 " MPU_xTaskGetSchedulerState_Priv: \n" 768 " pop {r0, r1} \n" 769 " b MPU_xTaskGetSchedulerStateImpl \n" 770 " MPU_xTaskGetSchedulerState_Unpriv: \n" 771 " pop {r0, r1} \n" 772 " svc %0 \n" 773 " \n" 774 : : "i" ( SYSTEM_CALL_xTaskGetSchedulerState ) : "memory" 775 ); 776 } 777 778 #endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */ 779 /*-----------------------------------------------------------*/ 780 781 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 782 MPU_vTaskSetTimeOutState(TimeOut_t * const pxTimeOut)783 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 784 { 785 __asm volatile 786 ( 787 " .syntax unified \n" 788 " .extern MPU_vTaskSetTimeOutStateImpl \n" 789 " \n" 790 " push {r0, r1} \n" 791 " mrs r0, control \n" 792 " movs r1, #1 \n" 793 " tst r0, r1 \n" 794 " bne MPU_vTaskSetTimeOutState_Unpriv \n" 795 " MPU_vTaskSetTimeOutState_Priv: \n" 796 " pop {r0, r1} \n" 797 " b MPU_vTaskSetTimeOutStateImpl \n" 798 " MPU_vTaskSetTimeOutState_Unpriv: \n" 799 " pop {r0, r1} \n" 800 " svc %0 \n" 801 " \n" 802 : : "i" ( SYSTEM_CALL_vTaskSetTimeOutState ) : "memory" 803 ); 804 } 805 /*-----------------------------------------------------------*/ 806 807 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, 808 TickType_t * const pxTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 809 MPU_xTaskCheckForTimeOut(TimeOut_t * const pxTimeOut,TickType_t * const pxTicksToWait)810 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, 811 TickType_t * const pxTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 812 { 813 __asm volatile 814 ( 815 " .syntax unified \n" 816 " .extern MPU_xTaskCheckForTimeOutImpl \n" 817 " \n" 818 " push {r0, r1} \n" 819 " mrs r0, control \n" 820 " movs r1, #1 \n" 821 " tst r0, r1 \n" 822 " bne MPU_xTaskCheckForTimeOut_Unpriv \n" 823 " MPU_xTaskCheckForTimeOut_Priv: \n" 824 " pop {r0, r1} \n" 825 " b MPU_xTaskCheckForTimeOutImpl \n" 826 " MPU_xTaskCheckForTimeOut_Unpriv: \n" 827 " pop {r0, r1} \n" 828 " svc %0 \n" 829 " \n" 830 : : "i" ( SYSTEM_CALL_xTaskCheckForTimeOut ) : "memory" 831 ); 832 } 833 /*-----------------------------------------------------------*/ 834 835 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) 836 837 BaseType_t MPU_xTaskGenericNotifyEntry( const xTaskGenericNotifyParams_t * pxParams ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 838 MPU_xTaskGenericNotifyEntry(const xTaskGenericNotifyParams_t * pxParams)839 BaseType_t MPU_xTaskGenericNotifyEntry( const xTaskGenericNotifyParams_t * pxParams ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 840 { 841 __asm volatile 842 ( 843 " .syntax unified \n" 844 " .extern MPU_xTaskGenericNotifyImpl \n" 845 " \n" 846 " push {r0, r1} \n" 847 " mrs r0, control \n" 848 " movs r1, #1 \n" 849 " tst r0, r1 \n" 850 " bne MPU_xTaskGenericNotify_Unpriv \n" 851 " MPU_xTaskGenericNotify_Priv: \n" 852 " pop {r0, r1} \n" 853 " b MPU_xTaskGenericNotifyImpl \n" 854 " MPU_xTaskGenericNotify_Unpriv: \n" 855 " pop {r0, r1} \n" 856 " svc %0 \n" 857 " \n" 858 : : "i" ( SYSTEM_CALL_xTaskGenericNotify ) : "memory" 859 ); 860 } 861 862 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 863 /*-----------------------------------------------------------*/ 864 865 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) 866 867 BaseType_t MPU_xTaskGenericNotifyWaitEntry( const xTaskGenericNotifyWaitParams_t * pxParams ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 868 MPU_xTaskGenericNotifyWaitEntry(const xTaskGenericNotifyWaitParams_t * pxParams)869 BaseType_t MPU_xTaskGenericNotifyWaitEntry( const xTaskGenericNotifyWaitParams_t * pxParams ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 870 { 871 __asm volatile 872 ( 873 " .syntax unified \n" 874 " .extern MPU_xTaskGenericNotifyWaitImpl \n" 875 " \n" 876 " push {r0, r1} \n" 877 " mrs r0, control \n" 878 " movs r1, #1 \n" 879 " tst r0, r1 \n" 880 " bne MPU_xTaskGenericNotifyWait_Unpriv \n" 881 " MPU_xTaskGenericNotifyWait_Priv: \n" 882 " pop {r0, r1} \n" 883 " b MPU_xTaskGenericNotifyWaitImpl \n" 884 " MPU_xTaskGenericNotifyWait_Unpriv: \n" 885 " pop {r0, r1} \n" 886 " svc %0 \n" 887 " \n" 888 : : "i" ( SYSTEM_CALL_xTaskGenericNotifyWait ) : "memory" 889 ); 890 } 891 892 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 893 /*-----------------------------------------------------------*/ 894 895 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) 896 897 uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn, 898 BaseType_t xClearCountOnExit, 899 TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 900 MPU_ulTaskGenericNotifyTake(UBaseType_t uxIndexToWaitOn,BaseType_t xClearCountOnExit,TickType_t xTicksToWait)901 uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn, 902 BaseType_t xClearCountOnExit, 903 TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 904 { 905 __asm volatile 906 ( 907 " .syntax unified \n" 908 " .extern MPU_ulTaskGenericNotifyTakeImpl \n" 909 " \n" 910 " push {r0, r1} \n" 911 " mrs r0, control \n" 912 " movs r1, #1 \n" 913 " tst r0, r1 \n" 914 " bne MPU_ulTaskGenericNotifyTake_Unpriv \n" 915 " MPU_ulTaskGenericNotifyTake_Priv: \n" 916 " pop {r0, r1} \n" 917 " b MPU_ulTaskGenericNotifyTakeImpl \n" 918 " MPU_ulTaskGenericNotifyTake_Unpriv: \n" 919 " pop {r0, r1} \n" 920 " svc %0 \n" 921 " \n" 922 : : "i" ( SYSTEM_CALL_ulTaskGenericNotifyTake ) : "memory" 923 ); 924 } 925 926 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 927 /*-----------------------------------------------------------*/ 928 929 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) 930 931 BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask, 932 UBaseType_t uxIndexToClear ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 933 MPU_xTaskGenericNotifyStateClear(TaskHandle_t xTask,UBaseType_t uxIndexToClear)934 BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask, 935 UBaseType_t uxIndexToClear ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 936 { 937 __asm volatile 938 ( 939 " .syntax unified \n" 940 " .extern MPU_xTaskGenericNotifyStateClearImpl \n" 941 " \n" 942 " push {r0, r1} \n" 943 " mrs r0, control \n" 944 " movs r1, #1 \n" 945 " tst r0, r1 \n" 946 " bne MPU_xTaskGenericNotifyStateClear_Unpriv \n" 947 " MPU_xTaskGenericNotifyStateClear_Priv: \n" 948 " pop {r0, r1} \n" 949 " b MPU_xTaskGenericNotifyStateClearImpl \n" 950 " MPU_xTaskGenericNotifyStateClear_Unpriv: \n" 951 " pop {r0, r1} \n" 952 " svc %0 \n" 953 " \n" 954 : : "i" ( SYSTEM_CALL_xTaskGenericNotifyStateClear ) : "memory" 955 ); 956 } 957 958 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 959 /*-----------------------------------------------------------*/ 960 961 #if ( configUSE_TASK_NOTIFICATIONS == 1 ) 962 963 uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask, 964 UBaseType_t uxIndexToClear, 965 uint32_t ulBitsToClear ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 966 MPU_ulTaskGenericNotifyValueClear(TaskHandle_t xTask,UBaseType_t uxIndexToClear,uint32_t ulBitsToClear)967 uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask, 968 UBaseType_t uxIndexToClear, 969 uint32_t ulBitsToClear ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 970 { 971 __asm volatile 972 ( 973 " .syntax unified \n" 974 " .extern MPU_ulTaskGenericNotifyValueClearImpl \n" 975 " \n" 976 " push {r0, r1} \n" 977 " mrs r0, control \n" 978 " movs r1, #1 \n" 979 " tst r0, r1 \n" 980 " bne MPU_ulTaskGenericNotifyValueClear_Unpriv \n" 981 " MPU_ulTaskGenericNotifyValueClear_Priv: \n" 982 " pop {r0, r1} \n" 983 " b MPU_ulTaskGenericNotifyValueClearImpl \n" 984 " MPU_ulTaskGenericNotifyValueClear_Unpriv: \n" 985 " pop {r0, r1} \n" 986 " svc %0 \n" 987 " \n" 988 : : "i" ( SYSTEM_CALL_ulTaskGenericNotifyValueClear ) : "memory" 989 ); 990 } 991 992 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ 993 /*-----------------------------------------------------------*/ 994 995 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, 996 const void * const pvItemToQueue, 997 TickType_t xTicksToWait, 998 const BaseType_t xCopyPosition ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 999 MPU_xQueueGenericSend(QueueHandle_t xQueue,const void * const pvItemToQueue,TickType_t xTicksToWait,const BaseType_t xCopyPosition)1000 BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, 1001 const void * const pvItemToQueue, 1002 TickType_t xTicksToWait, 1003 const BaseType_t xCopyPosition ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1004 { 1005 __asm volatile 1006 ( 1007 " .syntax unified \n" 1008 " .extern MPU_xQueueGenericSendImpl \n" 1009 " \n" 1010 " push {r0, r1} \n" 1011 " mrs r0, control \n" 1012 " movs r1, #1 \n" 1013 " tst r0, r1 \n" 1014 " bne MPU_xQueueGenericSend_Unpriv \n" 1015 " MPU_xQueueGenericSend_Priv: \n" 1016 " pop {r0, r1} \n" 1017 " b MPU_xQueueGenericSendImpl \n" 1018 " MPU_xQueueGenericSend_Unpriv: \n" 1019 " pop {r0, r1} \n" 1020 " svc %0 \n" 1021 " \n" 1022 : : "i" ( SYSTEM_CALL_xQueueGenericSend ) : "memory" 1023 ); 1024 } 1025 /*-----------------------------------------------------------*/ 1026 1027 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t xQueue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1028 MPU_uxQueueMessagesWaiting(const QueueHandle_t xQueue)1029 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t xQueue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1030 { 1031 __asm volatile 1032 ( 1033 " .syntax unified \n" 1034 " .extern MPU_uxQueueMessagesWaitingImpl \n" 1035 " \n" 1036 " push {r0, r1} \n" 1037 " mrs r0, control \n" 1038 " movs r1, #1 \n" 1039 " tst r0, r1 \n" 1040 " bne MPU_uxQueueMessagesWaiting_Unpriv \n" 1041 " MPU_uxQueueMessagesWaiting_Priv: \n" 1042 " pop {r0, r1} \n" 1043 " b MPU_uxQueueMessagesWaitingImpl \n" 1044 " MPU_uxQueueMessagesWaiting_Unpriv: \n" 1045 " pop {r0, r1} \n" 1046 " svc %0 \n" 1047 " \n" 1048 : : "i" ( SYSTEM_CALL_uxQueueMessagesWaiting ) : "memory" 1049 ); 1050 } 1051 /*-----------------------------------------------------------*/ 1052 1053 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1054 MPU_uxQueueSpacesAvailable(const QueueHandle_t xQueue)1055 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1056 { 1057 __asm volatile 1058 ( 1059 " .syntax unified \n" 1060 " .extern MPU_uxQueueSpacesAvailableImpl \n" 1061 " \n" 1062 " push {r0, r1} \n" 1063 " mrs r0, control \n" 1064 " movs r1, #1 \n" 1065 " tst r0, r1 \n" 1066 " bne MPU_uxQueueSpacesAvailable_Unpriv \n" 1067 " MPU_uxQueueSpacesAvailable_Priv: \n" 1068 " pop {r0, r1} \n" 1069 " b MPU_uxQueueSpacesAvailableImpl \n" 1070 " MPU_uxQueueSpacesAvailable_Unpriv: \n" 1071 " pop {r0, r1} \n" 1072 " svc %0 \n" 1073 " \n" 1074 : : "i" ( SYSTEM_CALL_uxQueueSpacesAvailable ) : "memory" 1075 ); 1076 } 1077 /*-----------------------------------------------------------*/ 1078 1079 BaseType_t MPU_xQueueReceive( QueueHandle_t xQueue, 1080 void * const pvBuffer, 1081 TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1082 MPU_xQueueReceive(QueueHandle_t xQueue,void * const pvBuffer,TickType_t xTicksToWait)1083 BaseType_t MPU_xQueueReceive( QueueHandle_t xQueue, 1084 void * const pvBuffer, 1085 TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1086 { 1087 __asm volatile 1088 ( 1089 " .syntax unified \n" 1090 " .extern MPU_xQueueReceiveImpl \n" 1091 " \n" 1092 " push {r0, r1} \n" 1093 " mrs r0, control \n" 1094 " movs r1, #1 \n" 1095 " tst r0, r1 \n" 1096 " bne MPU_xQueueReceive_Unpriv \n" 1097 " MPU_xQueueReceive_Priv: \n" 1098 " pop {r0, r1} \n" 1099 " b MPU_xQueueReceiveImpl \n" 1100 " MPU_xQueueReceive_Unpriv: \n" 1101 " pop {r0, r1} \n" 1102 " svc %0 \n" 1103 " \n" 1104 : : "i" ( SYSTEM_CALL_xQueueReceive ) : "memory" 1105 ); 1106 } 1107 /*-----------------------------------------------------------*/ 1108 1109 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, 1110 void * const pvBuffer, 1111 TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1112 MPU_xQueuePeek(QueueHandle_t xQueue,void * const pvBuffer,TickType_t xTicksToWait)1113 BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, 1114 void * const pvBuffer, 1115 TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1116 { 1117 __asm volatile 1118 ( 1119 " .syntax unified \n" 1120 " .extern MPU_xQueuePeekImpl \n" 1121 " \n" 1122 " push {r0, r1} \n" 1123 " mrs r0, control \n" 1124 " movs r1, #1 \n" 1125 " tst r0, r1 \n" 1126 " bne MPU_xQueuePeek_Unpriv \n" 1127 " MPU_xQueuePeek_Priv: \n" 1128 " pop {r0, r1} \n" 1129 " b MPU_xQueuePeekImpl \n" 1130 " MPU_xQueuePeek_Unpriv: \n" 1131 " pop {r0, r1} \n" 1132 " svc %0 \n" 1133 " \n" 1134 : : "i" ( SYSTEM_CALL_xQueuePeek ) : "memory" 1135 ); 1136 } 1137 /*-----------------------------------------------------------*/ 1138 1139 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, 1140 TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1141 MPU_xQueueSemaphoreTake(QueueHandle_t xQueue,TickType_t xTicksToWait)1142 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, 1143 TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1144 { 1145 __asm volatile 1146 ( 1147 " .syntax unified \n" 1148 " .extern MPU_xQueueSemaphoreTakeImpl \n" 1149 " \n" 1150 " push {r0, r1} \n" 1151 " mrs r0, control \n" 1152 " movs r1, #1 \n" 1153 " tst r0, r1 \n" 1154 " bne MPU_xQueueSemaphoreTake_Unpriv \n" 1155 " MPU_xQueueSemaphoreTake_Priv: \n" 1156 " pop {r0, r1} \n" 1157 " b MPU_xQueueSemaphoreTakeImpl \n" 1158 " MPU_xQueueSemaphoreTake_Unpriv: \n" 1159 " pop {r0, r1} \n" 1160 " svc %0 \n" 1161 " \n" 1162 : : "i" ( SYSTEM_CALL_xQueueSemaphoreTake ) : "memory" 1163 ); 1164 } 1165 /*-----------------------------------------------------------*/ 1166 1167 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) 1168 1169 TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1170 MPU_xQueueGetMutexHolder(QueueHandle_t xSemaphore)1171 TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1172 { 1173 __asm volatile 1174 ( 1175 " .syntax unified \n" 1176 " .extern MPU_xQueueGetMutexHolderImpl \n" 1177 " \n" 1178 " push {r0, r1} \n" 1179 " mrs r0, control \n" 1180 " movs r1, #1 \n" 1181 " tst r0, r1 \n" 1182 " bne MPU_xQueueGetMutexHolder_Unpriv \n" 1183 " MPU_xQueueGetMutexHolder_Priv: \n" 1184 " pop {r0, r1} \n" 1185 " b MPU_xQueueGetMutexHolderImpl \n" 1186 " MPU_xQueueGetMutexHolder_Unpriv: \n" 1187 " pop {r0, r1} \n" 1188 " svc %0 \n" 1189 " \n" 1190 : : "i" ( SYSTEM_CALL_xQueueGetMutexHolder ) : "memory" 1191 ); 1192 } 1193 1194 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */ 1195 /*-----------------------------------------------------------*/ 1196 1197 #if ( configUSE_RECURSIVE_MUTEXES == 1 ) 1198 1199 BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, 1200 TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1201 MPU_xQueueTakeMutexRecursive(QueueHandle_t xMutex,TickType_t xTicksToWait)1202 BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, 1203 TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1204 { 1205 __asm volatile 1206 ( 1207 " .syntax unified \n" 1208 " .extern MPU_xQueueTakeMutexRecursiveImpl \n" 1209 " \n" 1210 " push {r0, r1} \n" 1211 " mrs r0, control \n" 1212 " movs r1, #1 \n" 1213 " tst r0, r1 \n" 1214 " bne MPU_xQueueTakeMutexRecursive_Unpriv \n" 1215 " MPU_xQueueTakeMutexRecursive_Priv: \n" 1216 " pop {r0, r1} \n" 1217 " b MPU_xQueueTakeMutexRecursiveImpl \n" 1218 " MPU_xQueueTakeMutexRecursive_Unpriv: \n" 1219 " pop {r0, r1} \n" 1220 " svc %0 \n" 1221 " \n" 1222 : : "i" ( SYSTEM_CALL_xQueueTakeMutexRecursive ) : "memory" 1223 ); 1224 } 1225 1226 #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */ 1227 /*-----------------------------------------------------------*/ 1228 1229 #if ( configUSE_RECURSIVE_MUTEXES == 1 ) 1230 1231 BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1232 MPU_xQueueGiveMutexRecursive(QueueHandle_t pxMutex)1233 BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1234 { 1235 __asm volatile 1236 ( 1237 " .syntax unified \n" 1238 " .extern MPU_xQueueGiveMutexRecursiveImpl \n" 1239 " \n" 1240 " push {r0, r1} \n" 1241 " mrs r0, control \n" 1242 " movs r1, #1 \n" 1243 " tst r0, r1 \n" 1244 " bne MPU_xQueueGiveMutexRecursive_Unpriv \n" 1245 " MPU_xQueueGiveMutexRecursive_Priv: \n" 1246 " pop {r0, r1} \n" 1247 " b MPU_xQueueGiveMutexRecursiveImpl \n" 1248 " MPU_xQueueGiveMutexRecursive_Unpriv: \n" 1249 " pop {r0, r1} \n" 1250 " svc %0 \n" 1251 " \n" 1252 : : "i" ( SYSTEM_CALL_xQueueGiveMutexRecursive ) : "memory" 1253 ); 1254 } 1255 1256 #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */ 1257 /*-----------------------------------------------------------*/ 1258 1259 #if ( configUSE_QUEUE_SETS == 1 ) 1260 1261 QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, 1262 const TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1263 MPU_xQueueSelectFromSet(QueueSetHandle_t xQueueSet,const TickType_t xTicksToWait)1264 QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, 1265 const TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1266 { 1267 __asm volatile 1268 ( 1269 " .syntax unified \n" 1270 " .extern MPU_xQueueSelectFromSetImpl \n" 1271 " \n" 1272 " push {r0, r1} \n" 1273 " mrs r0, control \n" 1274 " movs r1, #1 \n" 1275 " tst r0, r1 \n" 1276 " bne MPU_xQueueSelectFromSet_Unpriv \n" 1277 " MPU_xQueueSelectFromSet_Priv: \n" 1278 " pop {r0, r1} \n" 1279 " b MPU_xQueueSelectFromSetImpl \n" 1280 " MPU_xQueueSelectFromSet_Unpriv: \n" 1281 " pop {r0, r1} \n" 1282 " svc %0 \n" 1283 " \n" 1284 : : "i" ( SYSTEM_CALL_xQueueSelectFromSet ) : "memory" 1285 ); 1286 } 1287 1288 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */ 1289 /*-----------------------------------------------------------*/ 1290 1291 #if ( configUSE_QUEUE_SETS == 1 ) 1292 1293 BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, 1294 QueueSetHandle_t xQueueSet ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1295 MPU_xQueueAddToSet(QueueSetMemberHandle_t xQueueOrSemaphore,QueueSetHandle_t xQueueSet)1296 BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, 1297 QueueSetHandle_t xQueueSet ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1298 { 1299 __asm volatile 1300 ( 1301 " .syntax unified \n" 1302 " .extern MPU_xQueueAddToSetImpl \n" 1303 " \n" 1304 " push {r0, r1} \n" 1305 " mrs r0, control \n" 1306 " movs r1, #1 \n" 1307 " tst r0, r1 \n" 1308 " bne MPU_xQueueAddToSet_Unpriv \n" 1309 " MPU_xQueueAddToSet_Priv: \n" 1310 " pop {r0, r1} \n" 1311 " b MPU_xQueueAddToSetImpl \n" 1312 " MPU_xQueueAddToSet_Unpriv: \n" 1313 " pop {r0, r1} \n" 1314 " svc %0 \n" 1315 " \n" 1316 : : "i" ( SYSTEM_CALL_xQueueAddToSet ) : "memory" 1317 ); 1318 } 1319 1320 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */ 1321 /*-----------------------------------------------------------*/ 1322 1323 #if ( configQUEUE_REGISTRY_SIZE > 0 ) 1324 1325 void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, 1326 const char * pcName ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1327 MPU_vQueueAddToRegistry(QueueHandle_t xQueue,const char * pcName)1328 void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, 1329 const char * pcName ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1330 { 1331 __asm volatile 1332 ( 1333 " .syntax unified \n" 1334 " .extern MPU_vQueueAddToRegistryImpl \n" 1335 " \n" 1336 " push {r0, r1} \n" 1337 " mrs r0, control \n" 1338 " movs r1, #1 \n" 1339 " tst r0, r1 \n" 1340 " bne MPU_vQueueAddToRegistry_Unpriv \n" 1341 " MPU_vQueueAddToRegistry_Priv: \n" 1342 " pop {r0, r1} \n" 1343 " b MPU_vQueueAddToRegistryImpl \n" 1344 " MPU_vQueueAddToRegistry_Unpriv: \n" 1345 " pop {r0, r1} \n" 1346 " svc %0 \n" 1347 " \n" 1348 : : "i" ( SYSTEM_CALL_vQueueAddToRegistry ) : "memory" 1349 ); 1350 } 1351 1352 #endif /* if ( configQUEUE_REGISTRY_SIZE > 0 ) */ 1353 /*-----------------------------------------------------------*/ 1354 1355 #if ( configQUEUE_REGISTRY_SIZE > 0 ) 1356 1357 void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1358 MPU_vQueueUnregisterQueue(QueueHandle_t xQueue)1359 void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1360 { 1361 __asm volatile 1362 ( 1363 " .syntax unified \n" 1364 " .extern MPU_vQueueUnregisterQueueImpl \n" 1365 " \n" 1366 " push {r0, r1} \n" 1367 " mrs r0, control \n" 1368 " movs r1, #1 \n" 1369 " tst r0, r1 \n" 1370 " bne MPU_vQueueUnregisterQueue_Unpriv \n" 1371 " MPU_vQueueUnregisterQueue_Priv: \n" 1372 " pop {r0, r1} \n" 1373 " b MPU_vQueueUnregisterQueueImpl \n" 1374 " MPU_vQueueUnregisterQueue_Unpriv: \n" 1375 " pop {r0, r1} \n" 1376 " svc %0 \n" 1377 " \n" 1378 : : "i" ( SYSTEM_CALL_vQueueUnregisterQueue ) : "memory" 1379 ); 1380 } 1381 1382 #endif /* if ( configQUEUE_REGISTRY_SIZE > 0 ) */ 1383 /*-----------------------------------------------------------*/ 1384 1385 #if ( configQUEUE_REGISTRY_SIZE > 0 ) 1386 1387 const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1388 MPU_pcQueueGetName(QueueHandle_t xQueue)1389 const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1390 { 1391 __asm volatile 1392 ( 1393 " .syntax unified \n" 1394 " .extern MPU_pcQueueGetNameImpl \n" 1395 " \n" 1396 " push {r0, r1} \n" 1397 " mrs r0, control \n" 1398 " movs r1, #1 \n" 1399 " tst r0, r1 \n" 1400 " bne MPU_pcQueueGetName_Unpriv \n" 1401 " MPU_pcQueueGetName_Priv: \n" 1402 " pop {r0, r1} \n" 1403 " b MPU_pcQueueGetNameImpl \n" 1404 " MPU_pcQueueGetName_Unpriv: \n" 1405 " pop {r0, r1} \n" 1406 " svc %0 \n" 1407 " \n" 1408 : : "i" ( SYSTEM_CALL_pcQueueGetName ) : "memory" 1409 ); 1410 } 1411 1412 #endif /* if ( configQUEUE_REGISTRY_SIZE > 0 ) */ 1413 /*-----------------------------------------------------------*/ 1414 1415 #if ( configUSE_TIMERS == 1 ) 1416 1417 void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1418 MPU_pvTimerGetTimerID(const TimerHandle_t xTimer)1419 void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1420 { 1421 __asm volatile 1422 ( 1423 " .syntax unified \n" 1424 " .extern MPU_pvTimerGetTimerIDImpl \n" 1425 " \n" 1426 " push {r0, r1} \n" 1427 " mrs r0, control \n" 1428 " movs r1, #1 \n" 1429 " tst r0, r1 \n" 1430 " bne MPU_pvTimerGetTimerID_Unpriv \n" 1431 " MPU_pvTimerGetTimerID_Priv: \n" 1432 " pop {r0, r1} \n" 1433 " b MPU_pvTimerGetTimerIDImpl \n" 1434 " MPU_pvTimerGetTimerID_Unpriv: \n" 1435 " pop {r0, r1} \n" 1436 " svc %0 \n" 1437 " \n" 1438 : : "i" ( SYSTEM_CALL_pvTimerGetTimerID ) : "memory" 1439 ); 1440 } 1441 1442 #endif /* if ( configUSE_TIMERS == 1 ) */ 1443 /*-----------------------------------------------------------*/ 1444 1445 #if ( configUSE_TIMERS == 1 ) 1446 1447 void MPU_vTimerSetTimerID( TimerHandle_t xTimer, 1448 void * pvNewID ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1449 MPU_vTimerSetTimerID(TimerHandle_t xTimer,void * pvNewID)1450 void MPU_vTimerSetTimerID( TimerHandle_t xTimer, 1451 void * pvNewID ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1452 { 1453 __asm volatile 1454 ( 1455 " .syntax unified \n" 1456 " .extern MPU_vTimerSetTimerIDImpl \n" 1457 " \n" 1458 " push {r0, r1} \n" 1459 " mrs r0, control \n" 1460 " movs r1, #1 \n" 1461 " tst r0, r1 \n" 1462 " bne MPU_vTimerSetTimerID_Unpriv \n" 1463 " MPU_vTimerSetTimerID_Priv: \n" 1464 " pop {r0, r1} \n" 1465 " b MPU_vTimerSetTimerIDImpl \n" 1466 " MPU_vTimerSetTimerID_Unpriv: \n" 1467 " pop {r0, r1} \n" 1468 " svc %0 \n" 1469 " \n" 1470 : : "i" ( SYSTEM_CALL_vTimerSetTimerID ) : "memory" 1471 ); 1472 } 1473 1474 #endif /* if ( configUSE_TIMERS == 1 ) */ 1475 /*-----------------------------------------------------------*/ 1476 1477 #if ( configUSE_TIMERS == 1 ) 1478 1479 BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1480 MPU_xTimerIsTimerActive(TimerHandle_t xTimer)1481 BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1482 { 1483 __asm volatile 1484 ( 1485 " .syntax unified \n" 1486 " .extern MPU_xTimerIsTimerActiveImpl \n" 1487 " \n" 1488 " push {r0, r1} \n" 1489 " mrs r0, control \n" 1490 " movs r1, #1 \n" 1491 " tst r0, r1 \n" 1492 " bne MPU_xTimerIsTimerActive_Unpriv \n" 1493 " MPU_xTimerIsTimerActive_Priv: \n" 1494 " pop {r0, r1} \n" 1495 " b MPU_xTimerIsTimerActiveImpl \n" 1496 " MPU_xTimerIsTimerActive_Unpriv: \n" 1497 " pop {r0, r1} \n" 1498 " svc %0 \n" 1499 " \n" 1500 : : "i" ( SYSTEM_CALL_xTimerIsTimerActive ) : "memory" 1501 ); 1502 } 1503 1504 #endif /* if ( configUSE_TIMERS == 1 ) */ 1505 /*-----------------------------------------------------------*/ 1506 1507 #if ( configUSE_TIMERS == 1 ) 1508 1509 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1510 MPU_xTimerGetTimerDaemonTaskHandle(void)1511 TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1512 { 1513 __asm volatile 1514 ( 1515 " .syntax unified \n" 1516 " .extern MPU_xTimerGetTimerDaemonTaskHandleImpl \n" 1517 " \n" 1518 " push {r0, r1} \n" 1519 " mrs r0, control \n" 1520 " movs r1, #1 \n" 1521 " tst r0, r1 \n" 1522 " bne MPU_xTimerGetTimerDaemonTaskHandle_Unpriv \n" 1523 " MPU_xTimerGetTimerDaemonTaskHandle_Priv: \n" 1524 " pop {r0, r1} \n" 1525 " b MPU_xTimerGetTimerDaemonTaskHandleImpl \n" 1526 " MPU_xTimerGetTimerDaemonTaskHandle_Unpriv: \n" 1527 " pop {r0, r1} \n" 1528 " svc %0 \n" 1529 " \n" 1530 : : "i" ( SYSTEM_CALL_xTimerGetTimerDaemonTaskHandle ) : "memory" 1531 ); 1532 } 1533 1534 #endif /* if ( configUSE_TIMERS == 1 ) */ 1535 /*-----------------------------------------------------------*/ 1536 1537 #if ( configUSE_TIMERS == 1 ) 1538 1539 BaseType_t MPU_xTimerGenericCommandFromTaskEntry( const xTimerGenericCommandFromTaskParams_t * pxParams ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1540 MPU_xTimerGenericCommandFromTaskEntry(const xTimerGenericCommandFromTaskParams_t * pxParams)1541 BaseType_t MPU_xTimerGenericCommandFromTaskEntry( const xTimerGenericCommandFromTaskParams_t * pxParams ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1542 { 1543 __asm volatile 1544 ( 1545 " .syntax unified \n" 1546 " .extern MPU_xTimerGenericCommandFromTaskImpl \n" 1547 " \n" 1548 " push {r0, r1} \n" 1549 " mrs r0, control \n" 1550 " movs r1, #1 \n" 1551 " tst r0, r1 \n" 1552 " bne MPU_xTimerGenericCommandFromTask_Unpriv \n" 1553 " MPU_xTimerGenericCommandFromTask_Priv: \n" 1554 " pop {r0, r1} \n" 1555 " b MPU_xTimerGenericCommandFromTaskImpl \n" 1556 " MPU_xTimerGenericCommandFromTask_Unpriv: \n" 1557 " pop {r0, r1} \n" 1558 " svc %0 \n" 1559 " \n" 1560 : : "i" ( SYSTEM_CALL_xTimerGenericCommandFromTask ) : "memory" 1561 ); 1562 } 1563 1564 #endif /* if ( configUSE_TIMERS == 1 ) */ 1565 /*-----------------------------------------------------------*/ 1566 1567 #if ( configUSE_TIMERS == 1 ) 1568 1569 const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1570 MPU_pcTimerGetName(TimerHandle_t xTimer)1571 const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1572 { 1573 __asm volatile 1574 ( 1575 " .syntax unified \n" 1576 " .extern MPU_pcTimerGetNameImpl \n" 1577 " \n" 1578 " push {r0, r1} \n" 1579 " mrs r0, control \n" 1580 " movs r1, #1 \n" 1581 " tst r0, r1 \n" 1582 " bne MPU_pcTimerGetName_Unpriv \n" 1583 " MPU_pcTimerGetName_Priv: \n" 1584 " pop {r0, r1} \n" 1585 " b MPU_pcTimerGetNameImpl \n" 1586 " MPU_pcTimerGetName_Unpriv: \n" 1587 " pop {r0, r1} \n" 1588 " svc %0 \n" 1589 " \n" 1590 : : "i" ( SYSTEM_CALL_pcTimerGetName ) : "memory" 1591 ); 1592 } 1593 1594 #endif /* if ( configUSE_TIMERS == 1 ) */ 1595 /*-----------------------------------------------------------*/ 1596 1597 #if ( configUSE_TIMERS == 1 ) 1598 1599 void MPU_vTimerSetReloadMode( TimerHandle_t xTimer, 1600 const BaseType_t uxAutoReload ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1601 MPU_vTimerSetReloadMode(TimerHandle_t xTimer,const BaseType_t uxAutoReload)1602 void MPU_vTimerSetReloadMode( TimerHandle_t xTimer, 1603 const BaseType_t uxAutoReload ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1604 { 1605 __asm volatile 1606 ( 1607 " .syntax unified \n" 1608 " .extern MPU_vTimerSetReloadModeImpl \n" 1609 " \n" 1610 " push {r0, r1} \n" 1611 " mrs r0, control \n" 1612 " movs r1, #1 \n" 1613 " tst r0, r1 \n" 1614 " bne MPU_vTimerSetReloadMode_Unpriv \n" 1615 " MPU_vTimerSetReloadMode_Priv: \n" 1616 " pop {r0, r1} \n" 1617 " b MPU_vTimerSetReloadModeImpl \n" 1618 " MPU_vTimerSetReloadMode_Unpriv: \n" 1619 " pop {r0, r1} \n" 1620 " svc %0 \n" 1621 " \n" 1622 : : "i" ( SYSTEM_CALL_vTimerSetReloadMode ) : "memory" 1623 ); 1624 } 1625 1626 #endif /* if ( configUSE_TIMERS == 1 ) */ 1627 /*-----------------------------------------------------------*/ 1628 1629 #if ( configUSE_TIMERS == 1 ) 1630 1631 BaseType_t MPU_xTimerGetReloadMode( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1632 MPU_xTimerGetReloadMode(TimerHandle_t xTimer)1633 BaseType_t MPU_xTimerGetReloadMode( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1634 { 1635 __asm volatile 1636 ( 1637 " .syntax unified \n" 1638 " .extern MPU_xTimerGetReloadModeImpl \n" 1639 " \n" 1640 " push {r0, r1} \n" 1641 " mrs r0, control \n" 1642 " movs r1, #1 \n" 1643 " tst r0, r1 \n" 1644 " bne MPU_xTimerGetReloadMode_Unpriv \n" 1645 " MPU_xTimerGetReloadMode_Priv: \n" 1646 " pop {r0, r1} \n" 1647 " b MPU_xTimerGetReloadModeImpl \n" 1648 " MPU_xTimerGetReloadMode_Unpriv: \n" 1649 " pop {r0, r1} \n" 1650 " svc %0 \n" 1651 " \n" 1652 : : "i" ( SYSTEM_CALL_xTimerGetReloadMode ) : "memory" 1653 ); 1654 } 1655 1656 #endif /* if ( configUSE_TIMERS == 1 ) */ 1657 /*-----------------------------------------------------------*/ 1658 1659 #if ( configUSE_TIMERS == 1 ) 1660 1661 UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1662 MPU_uxTimerGetReloadMode(TimerHandle_t xTimer)1663 UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1664 { 1665 __asm volatile 1666 ( 1667 " .syntax unified \n" 1668 " .extern MPU_uxTimerGetReloadModeImpl \n" 1669 " \n" 1670 " push {r0, r1} \n" 1671 " mrs r0, control \n" 1672 " movs r1, #1 \n" 1673 " tst r0, r1 \n" 1674 " bne MPU_uxTimerGetReloadMode_Unpriv \n" 1675 " MPU_uxTimerGetReloadMode_Priv: \n" 1676 " pop {r0, r1} \n" 1677 " b MPU_uxTimerGetReloadModeImpl \n" 1678 " MPU_uxTimerGetReloadMode_Unpriv: \n" 1679 " pop {r0, r1} \n" 1680 " svc %0 \n" 1681 " \n" 1682 : : "i" ( SYSTEM_CALL_uxTimerGetReloadMode ) : "memory" 1683 ); 1684 } 1685 1686 #endif /* if ( configUSE_TIMERS == 1 ) */ 1687 /*-----------------------------------------------------------*/ 1688 1689 #if ( configUSE_TIMERS == 1 ) 1690 1691 TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1692 MPU_xTimerGetPeriod(TimerHandle_t xTimer)1693 TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1694 { 1695 __asm volatile 1696 ( 1697 " .syntax unified \n" 1698 " .extern MPU_xTimerGetPeriodImpl \n" 1699 " \n" 1700 " push {r0, r1} \n" 1701 " mrs r0, control \n" 1702 " movs r1, #1 \n" 1703 " tst r0, r1 \n" 1704 " bne MPU_xTimerGetPeriod_Unpriv \n" 1705 " MPU_xTimerGetPeriod_Priv: \n" 1706 " pop {r0, r1} \n" 1707 " b MPU_xTimerGetPeriodImpl \n" 1708 " MPU_xTimerGetPeriod_Unpriv: \n" 1709 " pop {r0, r1} \n" 1710 " svc %0 \n" 1711 " \n" 1712 : : "i" ( SYSTEM_CALL_xTimerGetPeriod ) : "memory" 1713 ); 1714 } 1715 1716 #endif /* if ( configUSE_TIMERS == 1 ) */ 1717 /*-----------------------------------------------------------*/ 1718 1719 #if ( configUSE_TIMERS == 1 ) 1720 1721 TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1722 MPU_xTimerGetExpiryTime(TimerHandle_t xTimer)1723 TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1724 { 1725 __asm volatile 1726 ( 1727 " .syntax unified \n" 1728 " .extern MPU_xTimerGetExpiryTimeImpl \n" 1729 " \n" 1730 " push {r0, r1} \n" 1731 " mrs r0, control \n" 1732 " movs r1, #1 \n" 1733 " tst r0, r1 \n" 1734 " bne MPU_xTimerGetExpiryTime_Unpriv \n" 1735 " MPU_xTimerGetExpiryTime_Priv: \n" 1736 " pop {r0, r1} \n" 1737 " b MPU_xTimerGetExpiryTimeImpl \n" 1738 " MPU_xTimerGetExpiryTime_Unpriv: \n" 1739 " pop {r0, r1} \n" 1740 " svc %0 \n" 1741 " \n" 1742 : : "i" ( SYSTEM_CALL_xTimerGetExpiryTime ) : "memory" 1743 ); 1744 } 1745 1746 #endif /* if ( configUSE_TIMERS == 1 ) */ 1747 /*-----------------------------------------------------------*/ 1748 1749 EventBits_t MPU_xEventGroupWaitBitsEntry( const xEventGroupWaitBitsParams_t * pxParams ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1750 MPU_xEventGroupWaitBitsEntry(const xEventGroupWaitBitsParams_t * pxParams)1751 EventBits_t MPU_xEventGroupWaitBitsEntry( const xEventGroupWaitBitsParams_t * pxParams ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1752 { 1753 __asm volatile 1754 ( 1755 " .syntax unified \n" 1756 " .extern MPU_xEventGroupWaitBitsImpl \n" 1757 " \n" 1758 " push {r0, r1} \n" 1759 " mrs r0, control \n" 1760 " movs r1, #1 \n" 1761 " tst r0, r1 \n" 1762 " bne MPU_xEventGroupWaitBits_Unpriv \n" 1763 " MPU_xEventGroupWaitBits_Priv: \n" 1764 " pop {r0, r1} \n" 1765 " b MPU_xEventGroupWaitBitsImpl \n" 1766 " MPU_xEventGroupWaitBits_Unpriv: \n" 1767 " pop {r0, r1} \n" 1768 " svc %0 \n" 1769 " \n" 1770 : : "i" ( SYSTEM_CALL_xEventGroupWaitBits ) : "memory" 1771 ); 1772 } 1773 /*-----------------------------------------------------------*/ 1774 1775 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, 1776 const EventBits_t uxBitsToClear ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1777 MPU_xEventGroupClearBits(EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToClear)1778 EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, 1779 const EventBits_t uxBitsToClear ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1780 { 1781 __asm volatile 1782 ( 1783 " .syntax unified \n" 1784 " .extern MPU_xEventGroupClearBitsImpl \n" 1785 " \n" 1786 " push {r0, r1} \n" 1787 " mrs r0, control \n" 1788 " movs r1, #1 \n" 1789 " tst r0, r1 \n" 1790 " bne MPU_xEventGroupClearBits_Unpriv \n" 1791 " MPU_xEventGroupClearBits_Priv: \n" 1792 " pop {r0, r1} \n" 1793 " b MPU_xEventGroupClearBitsImpl \n" 1794 " MPU_xEventGroupClearBits_Unpriv: \n" 1795 " pop {r0, r1} \n" 1796 " svc %0 \n" 1797 " \n" 1798 : : "i" ( SYSTEM_CALL_xEventGroupClearBits ) : "memory" 1799 ); 1800 } 1801 /*-----------------------------------------------------------*/ 1802 1803 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, 1804 const EventBits_t uxBitsToSet ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1805 MPU_xEventGroupSetBits(EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToSet)1806 EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, 1807 const EventBits_t uxBitsToSet ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1808 { 1809 __asm volatile 1810 ( 1811 " .syntax unified \n" 1812 " .extern MPU_xEventGroupSetBitsImpl \n" 1813 " \n" 1814 " push {r0, r1} \n" 1815 " mrs r0, control \n" 1816 " movs r1, #1 \n" 1817 " tst r0, r1 \n" 1818 " bne MPU_xEventGroupSetBits_Unpriv \n" 1819 " MPU_xEventGroupSetBits_Priv: \n" 1820 " pop {r0, r1} \n" 1821 " b MPU_xEventGroupSetBitsImpl \n" 1822 " MPU_xEventGroupSetBits_Unpriv: \n" 1823 " pop {r0, r1} \n" 1824 " svc %0 \n" 1825 " \n" 1826 : : "i" ( SYSTEM_CALL_xEventGroupSetBits ) : "memory" 1827 ); 1828 } 1829 /*-----------------------------------------------------------*/ 1830 1831 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, 1832 const EventBits_t uxBitsToSet, 1833 const EventBits_t uxBitsToWaitFor, 1834 TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1835 MPU_xEventGroupSync(EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToSet,const EventBits_t uxBitsToWaitFor,TickType_t xTicksToWait)1836 EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, 1837 const EventBits_t uxBitsToSet, 1838 const EventBits_t uxBitsToWaitFor, 1839 TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1840 { 1841 __asm volatile 1842 ( 1843 " .syntax unified \n" 1844 " .extern MPU_xEventGroupSyncImpl \n" 1845 " \n" 1846 " push {r0, r1} \n" 1847 " mrs r0, control \n" 1848 " movs r1, #1 \n" 1849 " tst r0, r1 \n" 1850 " bne MPU_xEventGroupSync_Unpriv \n" 1851 " MPU_xEventGroupSync_Priv: \n" 1852 " pop {r0, r1} \n" 1853 " b MPU_xEventGroupSyncImpl \n" 1854 " MPU_xEventGroupSync_Unpriv: \n" 1855 " pop {r0, r1} \n" 1856 " svc %0 \n" 1857 " \n" 1858 : : "i" ( SYSTEM_CALL_xEventGroupSync ) : "memory" 1859 ); 1860 } 1861 /*-----------------------------------------------------------*/ 1862 1863 #if ( configUSE_TRACE_FACILITY == 1 ) 1864 1865 UBaseType_t MPU_uxEventGroupGetNumber( void * xEventGroup ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1866 MPU_uxEventGroupGetNumber(void * xEventGroup)1867 UBaseType_t MPU_uxEventGroupGetNumber( void * xEventGroup ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1868 { 1869 __asm volatile 1870 ( 1871 " .syntax unified \n" 1872 " .extern MPU_uxEventGroupGetNumberImpl \n" 1873 " \n" 1874 " push {r0, r1} \n" 1875 " mrs r0, control \n" 1876 " movs r1, #1 \n" 1877 " tst r0, r1 \n" 1878 " bne MPU_uxEventGroupGetNumber_Unpriv \n" 1879 " MPU_uxEventGroupGetNumber_Priv: \n" 1880 " pop {r0, r1} \n" 1881 " b MPU_uxEventGroupGetNumberImpl \n" 1882 " MPU_uxEventGroupGetNumber_Unpriv: \n" 1883 " pop {r0, r1} \n" 1884 " svc %0 \n" 1885 " \n" 1886 : : "i" ( SYSTEM_CALL_uxEventGroupGetNumber ) : "memory" 1887 ); 1888 } 1889 1890 #endif /*( configUSE_TRACE_FACILITY == 1 )*/ 1891 /*-----------------------------------------------------------*/ 1892 1893 #if ( configUSE_TRACE_FACILITY == 1 ) 1894 1895 void MPU_vEventGroupSetNumber( void * xEventGroup, 1896 UBaseType_t uxEventGroupNumber ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1897 MPU_vEventGroupSetNumber(void * xEventGroup,UBaseType_t uxEventGroupNumber)1898 void MPU_vEventGroupSetNumber( void * xEventGroup, 1899 UBaseType_t uxEventGroupNumber ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1900 { 1901 __asm volatile 1902 ( 1903 " .syntax unified \n" 1904 " .extern MPU_vEventGroupSetNumberImpl \n" 1905 " \n" 1906 " push {r0, r1} \n" 1907 " mrs r0, control \n" 1908 " movs r1, #1 \n" 1909 " tst r0, r1 \n" 1910 " bne MPU_vEventGroupSetNumber_Unpriv \n" 1911 " MPU_vEventGroupSetNumber_Priv: \n" 1912 " pop {r0, r1} \n" 1913 " b MPU_vEventGroupSetNumberImpl \n" 1914 " MPU_vEventGroupSetNumber_Unpriv: \n" 1915 " pop {r0, r1} \n" 1916 " svc %0 \n" 1917 " \n" 1918 : : "i" ( SYSTEM_CALL_vEventGroupSetNumber ) : "memory" 1919 ); 1920 } 1921 1922 #endif /*( configUSE_TRACE_FACILITY == 1 )*/ 1923 /*-----------------------------------------------------------*/ 1924 1925 size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, 1926 const void * pvTxData, 1927 size_t xDataLengthBytes, 1928 TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1929 MPU_xStreamBufferSend(StreamBufferHandle_t xStreamBuffer,const void * pvTxData,size_t xDataLengthBytes,TickType_t xTicksToWait)1930 size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, 1931 const void * pvTxData, 1932 size_t xDataLengthBytes, 1933 TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1934 { 1935 __asm volatile 1936 ( 1937 " .syntax unified \n" 1938 " .extern MPU_xStreamBufferSendImpl \n" 1939 " \n" 1940 " push {r0, r1} \n" 1941 " mrs r0, control \n" 1942 " movs r1, #1 \n" 1943 " tst r0, r1 \n" 1944 " bne MPU_xStreamBufferSend_Unpriv \n" 1945 " MPU_xStreamBufferSend_Priv: \n" 1946 " pop {r0, r1} \n" 1947 " b MPU_xStreamBufferSendImpl \n" 1948 " MPU_xStreamBufferSend_Unpriv: \n" 1949 " pop {r0, r1} \n" 1950 " svc %0 \n" 1951 " \n" 1952 : : "i" ( SYSTEM_CALL_xStreamBufferSend ) : "memory" 1953 ); 1954 } 1955 /*-----------------------------------------------------------*/ 1956 1957 size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, 1958 void * pvRxData, 1959 size_t xBufferLengthBytes, 1960 TickType_t xTicksToWait ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1961 MPU_xStreamBufferReceive(StreamBufferHandle_t xStreamBuffer,void * pvRxData,size_t xBufferLengthBytes,TickType_t xTicksToWait)1962 size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, 1963 void * pvRxData, 1964 size_t xBufferLengthBytes, 1965 TickType_t xTicksToWait ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1966 { 1967 __asm volatile 1968 ( 1969 " .syntax unified \n" 1970 " .extern MPU_xStreamBufferReceiveImpl \n" 1971 " \n" 1972 " push {r0, r1} \n" 1973 " mrs r0, control \n" 1974 " movs r1, #1 \n" 1975 " tst r0, r1 \n" 1976 " bne MPU_xStreamBufferReceive_Unpriv \n" 1977 " MPU_xStreamBufferReceive_Priv: \n" 1978 " pop {r0, r1} \n" 1979 " b MPU_xStreamBufferReceiveImpl \n" 1980 " MPU_xStreamBufferReceive_Unpriv: \n" 1981 " pop {r0, r1} \n" 1982 " svc %0 \n" 1983 " \n" 1984 : : "i" ( SYSTEM_CALL_xStreamBufferReceive ) : "memory" 1985 ); 1986 } 1987 /*-----------------------------------------------------------*/ 1988 1989 BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 1990 MPU_xStreamBufferIsFull(StreamBufferHandle_t xStreamBuffer)1991 BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 1992 { 1993 __asm volatile 1994 ( 1995 " .syntax unified \n" 1996 " .extern MPU_xStreamBufferIsFullImpl \n" 1997 " \n" 1998 " push {r0, r1} \n" 1999 " mrs r0, control \n" 2000 " movs r1, #1 \n" 2001 " tst r0, r1 \n" 2002 " bne MPU_xStreamBufferIsFull_Unpriv \n" 2003 " MPU_xStreamBufferIsFull_Priv: \n" 2004 " pop {r0, r1} \n" 2005 " b MPU_xStreamBufferIsFullImpl \n" 2006 " MPU_xStreamBufferIsFull_Unpriv: \n" 2007 " pop {r0, r1} \n" 2008 " svc %0 \n" 2009 " \n" 2010 : : "i" ( SYSTEM_CALL_xStreamBufferIsFull ) : "memory" 2011 ); 2012 } 2013 /*-----------------------------------------------------------*/ 2014 2015 BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 2016 MPU_xStreamBufferIsEmpty(StreamBufferHandle_t xStreamBuffer)2017 BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 2018 { 2019 __asm volatile 2020 ( 2021 " .syntax unified \n" 2022 " .extern MPU_xStreamBufferIsEmptyImpl \n" 2023 " \n" 2024 " push {r0, r1} \n" 2025 " mrs r0, control \n" 2026 " movs r1, #1 \n" 2027 " tst r0, r1 \n" 2028 " bne MPU_xStreamBufferIsEmpty_Unpriv \n" 2029 " MPU_xStreamBufferIsEmpty_Priv: \n" 2030 " pop {r0, r1} \n" 2031 " b MPU_xStreamBufferIsEmptyImpl \n" 2032 " MPU_xStreamBufferIsEmpty_Unpriv: \n" 2033 " pop {r0, r1} \n" 2034 " svc %0 \n" 2035 " \n" 2036 : : "i" ( SYSTEM_CALL_xStreamBufferIsEmpty ) : "memory" 2037 ); 2038 } 2039 /*-----------------------------------------------------------*/ 2040 2041 size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 2042 MPU_xStreamBufferSpacesAvailable(StreamBufferHandle_t xStreamBuffer)2043 size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 2044 { 2045 __asm volatile 2046 ( 2047 " .syntax unified \n" 2048 " .extern MPU_xStreamBufferSpacesAvailableImpl \n" 2049 " \n" 2050 " push {r0, r1} \n" 2051 " mrs r0, control \n" 2052 " movs r1, #1 \n" 2053 " tst r0, r1 \n" 2054 " bne MPU_xStreamBufferSpacesAvailable_Unpriv \n" 2055 " MPU_xStreamBufferSpacesAvailable_Priv: \n" 2056 " pop {r0, r1} \n" 2057 " b MPU_xStreamBufferSpacesAvailableImpl \n" 2058 " MPU_xStreamBufferSpacesAvailable_Unpriv: \n" 2059 " pop {r0, r1} \n" 2060 " svc %0 \n" 2061 " \n" 2062 : : "i" ( SYSTEM_CALL_xStreamBufferSpacesAvailable ) : "memory" 2063 ); 2064 } 2065 /*-----------------------------------------------------------*/ 2066 2067 size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 2068 MPU_xStreamBufferBytesAvailable(StreamBufferHandle_t xStreamBuffer)2069 size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 2070 { 2071 __asm volatile 2072 ( 2073 " .syntax unified \n" 2074 " .extern MPU_xStreamBufferBytesAvailableImpl \n" 2075 " \n" 2076 " push {r0, r1} \n" 2077 " mrs r0, control \n" 2078 " movs r1, #1 \n" 2079 " tst r0, r1 \n" 2080 " bne MPU_xStreamBufferBytesAvailable_Unpriv \n" 2081 " MPU_xStreamBufferBytesAvailable_Priv: \n" 2082 " pop {r0, r1} \n" 2083 " b MPU_xStreamBufferBytesAvailableImpl \n" 2084 " MPU_xStreamBufferBytesAvailable_Unpriv: \n" 2085 " pop {r0, r1} \n" 2086 " svc %0 \n" 2087 " \n" 2088 : : "i" ( SYSTEM_CALL_xStreamBufferBytesAvailable ) : "memory" 2089 ); 2090 } 2091 /*-----------------------------------------------------------*/ 2092 2093 BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, 2094 size_t xTriggerLevel ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 2095 MPU_xStreamBufferSetTriggerLevel(StreamBufferHandle_t xStreamBuffer,size_t xTriggerLevel)2096 BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, 2097 size_t xTriggerLevel ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 2098 { 2099 __asm volatile 2100 ( 2101 " .syntax unified \n" 2102 " .extern MPU_xStreamBufferSetTriggerLevelImpl \n" 2103 " \n" 2104 " push {r0, r1} \n" 2105 " mrs r0, control \n" 2106 " movs r1, #1 \n" 2107 " tst r0, r1 \n" 2108 " bne MPU_xStreamBufferSetTriggerLevel_Unpriv \n" 2109 " MPU_xStreamBufferSetTriggerLevel_Priv: \n" 2110 " pop {r0, r1} \n" 2111 " b MPU_xStreamBufferSetTriggerLevelImpl \n" 2112 " MPU_xStreamBufferSetTriggerLevel_Unpriv: \n" 2113 " pop {r0, r1} \n" 2114 " svc %0 \n" 2115 " \n" 2116 : : "i" ( SYSTEM_CALL_xStreamBufferSetTriggerLevel ) : "memory" 2117 ); 2118 } 2119 /*-----------------------------------------------------------*/ 2120 2121 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) __attribute__( ( naked ) ) FREERTOS_SYSTEM_CALL; 2122 MPU_xStreamBufferNextMessageLengthBytes(StreamBufferHandle_t xStreamBuffer)2123 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* __attribute__ (( naked )) FREERTOS_SYSTEM_CALL */ 2124 { 2125 __asm volatile 2126 ( 2127 " .syntax unified \n" 2128 " .extern MPU_xStreamBufferNextMessageLengthBytesImpl \n" 2129 " \n" 2130 " push {r0, r1} \n" 2131 " mrs r0, control \n" 2132 " movs r1, #1 \n" 2133 " tst r0, r1 \n" 2134 " bne MPU_xStreamBufferNextMessageLengthBytes_Unpriv \n" 2135 " MPU_xStreamBufferNextMessageLengthBytes_Priv: \n" 2136 " pop {r0, r1} \n" 2137 " b MPU_xStreamBufferNextMessageLengthBytesImpl \n" 2138 " MPU_xStreamBufferNextMessageLengthBytes_Unpriv: \n" 2139 " pop {r0, r1} \n" 2140 " svc %0 \n" 2141 " \n" 2142 : : "i" ( SYSTEM_CALL_xStreamBufferNextMessageLengthBytes ) : "memory" 2143 ); 2144 } 2145 /*-----------------------------------------------------------*/ 2146 2147 #endif /* ( configENABLE_MPU == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) */ 2148
