begriffs open source - freertos/blob - portable/GCC/ARM_CM33/non_secure/port.c

   1 /*
   2  * FreeRTOS Kernel V10.4.6
   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
  38 /* MPU wrappers includes. */
  39 #include "mpu_wrappers.h"
  40
  41 /* Portasm includes. */
  42 #include "portasm.h"
  43
  44 #if ( configENABLE_TRUSTZONE == 1 )
  45     /* Secure components includes. */
  46     #include "secure_context.h"
  47     #include "secure_init.h"
  48 #endif /* configENABLE_TRUSTZONE */
  49
  50 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  51
  52 /**
  53  * The FreeRTOS Cortex M33 port can be configured to run on the Secure Side only
  54  * i.e. the processor boots as secure and never jumps to the non-secure side.
  55  * The Trust Zone support in the port must be disabled in order to run FreeRTOS
  56  * on the secure side. The following are the valid configuration seetings:
  57  *
  58  * 1. Run FreeRTOS on the Secure Side:
  59  *    configRUN_FREERTOS_SECURE_ONLY = 1 and configENABLE_TRUSTZONE = 0
  60  *
  61  * 2. Run FreeRTOS on the Non-Secure Side with Secure Side function call support:
  62  *    configRUN_FREERTOS_SECURE_ONLY = 0 and configENABLE_TRUSTZONE = 1
  63  *
  64  * 3. Run FreeRTOS on the Non-Secure Side only i.e. no Secure Side function call support:
  65  *    configRUN_FREERTOS_SECURE_ONLY = 0 and configENABLE_TRUSTZONE = 0
  66  */
  67 #if ( ( configRUN_FREERTOS_SECURE_ONLY == 1 ) && ( configENABLE_TRUSTZONE == 1 ) )
  68     #error TrustZone needs to be disabled in order to run FreeRTOS on the Secure Side.
  69 #endif
  70 /*-----------------------------------------------------------*/
  71
  72 /**
  73  * @brief Constants required to manipulate the NVIC.
  74  */
  75 #define portNVIC_SYSTICK_CTRL_REG             ( *( ( volatile uint32_t * ) 0xe000e010 ) )
  76 #define portNVIC_SYSTICK_LOAD_REG             ( *( ( volatile uint32_t * ) 0xe000e014 ) )
  77 #define portNVIC_SYSTICK_CURRENT_VALUE_REG    ( *( ( volatile uint32_t * ) 0xe000e018 ) )
  78 #define portNVIC_SHPR3_REG                    ( *( ( volatile uint32_t * ) 0xe000ed20 ) )
  79 #define portNVIC_SYSTICK_ENABLE_BIT           ( 1UL << 0UL )
  80 #define portNVIC_SYSTICK_INT_BIT              ( 1UL << 1UL )
  81 #define portNVIC_SYSTICK_COUNT_FLAG_BIT       ( 1UL << 16UL )
  82 #define portMIN_INTERRUPT_PRIORITY            ( 255UL )
  83 #define portNVIC_PENDSV_PRI                   ( portMIN_INTERRUPT_PRIORITY << 16UL )
  84 #define portNVIC_SYSTICK_PRI                  ( portMIN_INTERRUPT_PRIORITY << 24UL )
  85 #ifndef configSYSTICK_CLOCK_HZ
  86     #define configSYSTICK_CLOCK_HZ            configCPU_CLOCK_HZ
  87     /* Ensure the SysTick is clocked at the same frequency as the core. */
  88     #define portNVIC_SYSTICK_CLK_BIT          ( 1UL << 2UL )
  89 #else
  90
  91 /* The way the SysTick is clocked is not modified in case it is not the
  92  * same a the core. */
  93     #define portNVIC_SYSTICK_CLK_BIT    ( 0 )
  94 #endif
  95 /*-----------------------------------------------------------*/
  96
  97 /**
  98  * @brief Constants required to manipulate the SCB.
  99  */
 100 #define portSCB_SYS_HANDLER_CTRL_STATE_REG    ( *( volatile uint32_t * ) 0xe000ed24 )
 101 #define portSCB_MEM_FAULT_ENABLE_BIT          ( 1UL << 16UL )
 102 /*-----------------------------------------------------------*/
 103
 104 /**
 105  * @brief Constants required to manipulate the FPU.
 106  */
 107 #define portCPACR               ( ( volatile uint32_t * ) 0xe000ed88 )              /* Coprocessor Access Control Register. */
 108 #define portCPACR_CP10_VALUE    ( 3UL )
 109 #define portCPACR_CP11_VALUE    portCPACR_CP10_VALUE
 110 #define portCPACR_CP10_POS      ( 20UL )
 111 #define portCPACR_CP11_POS      ( 22UL )
 112
 113 #define portFPCCR               ( ( volatile uint32_t * ) 0xe000ef34 )              /* Floating Point Context Control Register. */
 114 #define portFPCCR_ASPEN_POS     ( 31UL )
 115 #define portFPCCR_ASPEN_MASK    ( 1UL << portFPCCR_ASPEN_POS )
 116 #define portFPCCR_LSPEN_POS     ( 30UL )
 117 #define portFPCCR_LSPEN_MASK    ( 1UL << portFPCCR_LSPEN_POS )
 118 /*-----------------------------------------------------------*/
 119
 120 /**
 121  * @brief Constants required to manipulate the MPU.
 122  */
 123 #define portMPU_TYPE_REG                      ( *( ( volatile uint32_t * ) 0xe000ed90 ) )
 124 #define portMPU_CTRL_REG                      ( *( ( volatile uint32_t * ) 0xe000ed94 ) )
 125 #define portMPU_RNR_REG                       ( *( ( volatile uint32_t * ) 0xe000ed98 ) )
 126
 127 #define portMPU_RBAR_REG                      ( *( ( volatile uint32_t * ) 0xe000ed9c ) )
 128 #define portMPU_RLAR_REG                      ( *( ( volatile uint32_t * ) 0xe000eda0 ) )
 129
 130 #define portMPU_RBAR_A1_REG                   ( *( ( volatile uint32_t * ) 0xe000eda4 ) )
 131 #define portMPU_RLAR_A1_REG                   ( *( ( volatile uint32_t * ) 0xe000eda8 ) )
 132
 133 #define portMPU_RBAR_A2_REG                   ( *( ( volatile uint32_t * ) 0xe000edac ) )
 134 #define portMPU_RLAR_A2_REG                   ( *( ( volatile uint32_t * ) 0xe000edb0 ) )
 135
 136 #define portMPU_RBAR_A3_REG                   ( *( ( volatile uint32_t * ) 0xe000edb4 ) )
 137 #define portMPU_RLAR_A3_REG                   ( *( ( volatile uint32_t * ) 0xe000edb8 ) )
 138
 139 #define portMPU_MAIR0_REG                     ( *( ( volatile uint32_t * ) 0xe000edc0 ) )
 140 #define portMPU_MAIR1_REG                     ( *( ( volatile uint32_t * ) 0xe000edc4 ) )
 141
 142 #define portMPU_RBAR_ADDRESS_MASK             ( 0xffffffe0 ) /* Must be 32-byte aligned. */
 143 #define portMPU_RLAR_ADDRESS_MASK             ( 0xffffffe0 ) /* Must be 32-byte aligned. */
 144
 145 #define portMPU_MAIR_ATTR0_POS                ( 0UL )
 146 #define portMPU_MAIR_ATTR0_MASK               ( 0x000000ff )
 147
 148 #define portMPU_MAIR_ATTR1_POS                ( 8UL )
 149 #define portMPU_MAIR_ATTR1_MASK               ( 0x0000ff00 )
 150
 151 #define portMPU_MAIR_ATTR2_POS                ( 16UL )
 152 #define portMPU_MAIR_ATTR2_MASK               ( 0x00ff0000 )
 153
 154 #define portMPU_MAIR_ATTR3_POS                ( 24UL )
 155 #define portMPU_MAIR_ATTR3_MASK               ( 0xff000000 )
 156
 157 #define portMPU_MAIR_ATTR4_POS                ( 0UL )
 158 #define portMPU_MAIR_ATTR4_MASK               ( 0x000000ff )
 159
 160 #define portMPU_MAIR_ATTR5_POS                ( 8UL )
 161 #define portMPU_MAIR_ATTR5_MASK               ( 0x0000ff00 )
 162
 163 #define portMPU_MAIR_ATTR6_POS                ( 16UL )
 164 #define portMPU_MAIR_ATTR6_MASK               ( 0x00ff0000 )
 165
 166 #define portMPU_MAIR_ATTR7_POS                ( 24UL )
 167 #define portMPU_MAIR_ATTR7_MASK               ( 0xff000000 )
 168
 169 #define portMPU_RLAR_ATTR_INDEX0              ( 0UL << 1UL )
 170 #define portMPU_RLAR_ATTR_INDEX1              ( 1UL << 1UL )
 171 #define portMPU_RLAR_ATTR_INDEX2              ( 2UL << 1UL )
 172 #define portMPU_RLAR_ATTR_INDEX3              ( 3UL << 1UL )
 173 #define portMPU_RLAR_ATTR_INDEX4              ( 4UL << 1UL )
 174 #define portMPU_RLAR_ATTR_INDEX5              ( 5UL << 1UL )
 175 #define portMPU_RLAR_ATTR_INDEX6              ( 6UL << 1UL )
 176 #define portMPU_RLAR_ATTR_INDEX7              ( 7UL << 1UL )
 177
 178 #define portMPU_RLAR_REGION_ENABLE            ( 1UL )
 179
 180 /* Enable privileged access to unmapped region. */
 181 #define portMPU_PRIV_BACKGROUND_ENABLE_BIT    ( 1UL << 2UL )
 182
 183 /* Enable MPU. */
 184 #define portMPU_ENABLE_BIT                    ( 1UL << 0UL )
 185
 186 /* Expected value of the portMPU_TYPE register. */
 187 #define portEXPECTED_MPU_TYPE_VALUE           ( 8UL << 8UL ) /* 8 regions, unified. */
 188 /*-----------------------------------------------------------*/
 189
 190 /**
 191  * @brief The maximum 24-bit number.
 192  *
 193  * It is needed because the systick is a 24-bit counter.
 194  */
 195 #define portMAX_24_BIT_NUMBER       ( 0xffffffUL )
 196
 197 /**
 198  * @brief A fiddle factor to estimate the number of SysTick counts that would
 199  * have occurred while the SysTick counter is stopped during tickless idle
 200  * calculations.
 201  */
 202 #define portMISSED_COUNTS_FACTOR    ( 45UL )
 203 /*-----------------------------------------------------------*/
 204
 205 /**
 206  * @brief Constants required to set up the initial stack.
 207  */
 208 #define portINITIAL_XPSR    ( 0x01000000 )
 209
 210 #if ( configRUN_FREERTOS_SECURE_ONLY == 1 )
 211
 212 /**
 213  * @brief Initial EXC_RETURN value.
 214  *
 215  *     FF         FF         FF         FD
 216  * 1111 1111  1111 1111  1111 1111  1111 1101
 217  *
 218  * Bit[6] - 1 --> The exception was taken from the Secure state.
 219  * Bit[5] - 1 --> Do not skip stacking of additional state context.
 220  * Bit[4] - 1 --> The PE did not allocate space on the stack for FP context.
 221  * Bit[3] - 1 --> Return to the Thread mode.
 222  * Bit[2] - 1 --> Restore registers from the process stack.
 223  * Bit[1] - 0 --> Reserved, 0.
 224  * Bit[0] - 1 --> The exception was taken to the Secure state.
 225  */
 226     #define portINITIAL_EXC_RETURN    ( 0xfffffffd )
 227 #else
 228
 229 /**
 230  * @brief Initial EXC_RETURN value.
 231  *
 232  *     FF         FF         FF         BC
 233  * 1111 1111  1111 1111  1111 1111  1011 1100
 234  *
 235  * Bit[6] - 0 --> The exception was taken from the Non-Secure state.
 236  * Bit[5] - 1 --> Do not skip stacking of additional state context.
 237  * Bit[4] - 1 --> The PE did not allocate space on the stack for FP context.
 238  * Bit[3] - 1 --> Return to the Thread mode.
 239  * Bit[2] - 1 --> Restore registers from the process stack.
 240  * Bit[1] - 0 --> Reserved, 0.
 241  * Bit[0] - 0 --> The exception was taken to the Non-Secure state.
 242  */
 243     #define portINITIAL_EXC_RETURN    ( 0xffffffbc )
 244 #endif /* configRUN_FREERTOS_SECURE_ONLY */
 245
 246 /**
 247  * @brief CONTROL register privileged bit mask.
 248  *
 249  * Bit[0] in CONTROL register tells the privilege:
 250  *  Bit[0] = 0 ==> The task is privileged.
 251  *  Bit[0] = 1 ==> The task is not privileged.
 252  */
 253 #define portCONTROL_PRIVILEGED_MASK         ( 1UL << 0UL )
 254
 255 /**
 256  * @brief Initial CONTROL register values.
 257  */
 258 #define portINITIAL_CONTROL_UNPRIVILEGED    ( 0x3 )
 259 #define portINITIAL_CONTROL_PRIVILEGED      ( 0x2 )
 260
 261 /**
 262  * @brief Let the user override the pre-loading of the initial LR with the
 263  * address of prvTaskExitError() in case it messes up unwinding of the stack
 264  * in the debugger.
 265  */
 266 #ifdef configTASK_RETURN_ADDRESS
 267     #define portTASK_RETURN_ADDRESS    configTASK_RETURN_ADDRESS
 268 #else
 269     #define portTASK_RETURN_ADDRESS    prvTaskExitError
 270 #endif
 271
 272 /**
 273  * @brief If portPRELOAD_REGISTERS then registers will be given an initial value
 274  * when a task is created. This helps in debugging at the cost of code size.
 275  */
 276 #define portPRELOAD_REGISTERS    1
 277
 278 /**
 279  * @brief A task is created without a secure context, and must call
 280  * portALLOCATE_SECURE_CONTEXT() to give itself a secure context before it makes
 281  * any secure calls.
 282  */
 283 #define portNO_SECURE_CONTEXT    0
 284 /*-----------------------------------------------------------*/
 285
 286 /**
 287  * @brief Used to catch tasks that attempt to return from their implementing
 288  * function.
 289  */
 290 static void prvTaskExitError( void );
 291
 292 #if ( configENABLE_MPU == 1 )
 293
 294 /**
 295  * @brief Setup the Memory Protection Unit (MPU).
 296  */
 297     static void prvSetupMPU( void ) PRIVILEGED_FUNCTION;
 298 #endif /* configENABLE_MPU */
 299
 300 #if ( configENABLE_FPU == 1 )
 301
 302 /**
 303  * @brief Setup the Floating Point Unit (FPU).
 304  */
 305     static void prvSetupFPU( void ) PRIVILEGED_FUNCTION;
 306 #endif /* configENABLE_FPU */
 307
 308 /**
 309  * @brief Setup the timer to generate the tick interrupts.
 310  *
 311  * The implementation in this file is weak to allow application writers to
 312  * change the timer used to generate the tick interrupt.
 313  */
 314 void vPortSetupTimerInterrupt( void ) PRIVILEGED_FUNCTION;
 315
 316 /**
 317  * @brief Checks whether the current execution context is interrupt.
 318  *
 319  * @return pdTRUE if the current execution context is interrupt, pdFALSE
 320  * otherwise.
 321  */
 322 BaseType_t xPortIsInsideInterrupt( void );
 323
 324 /**
 325  * @brief Yield the processor.
 326  */
 327 void vPortYield( void ) PRIVILEGED_FUNCTION;
 328
 329 /**
 330  * @brief Enter critical section.
 331  */
 332 void vPortEnterCritical( void ) PRIVILEGED_FUNCTION;
 333
 334 /**
 335  * @brief Exit from critical section.
 336  */
 337 void vPortExitCritical( void ) PRIVILEGED_FUNCTION;
 338
 339 /**
 340  * @brief SysTick handler.
 341  */
 342 void SysTick_Handler( void ) PRIVILEGED_FUNCTION;
 343
 344 /**
 345  * @brief C part of SVC handler.
 346  */
 347 portDONT_DISCARD void vPortSVCHandler_C( uint32_t * pulCallerStackAddress ) PRIVILEGED_FUNCTION;
 348 /*-----------------------------------------------------------*/
 349
 350 /**
 351  * @brief Each task maintains its own interrupt status in the critical nesting
 352  * variable.
 353  */
 354 PRIVILEGED_DATA static volatile uint32_t ulCriticalNesting = 0xaaaaaaaaUL;
 355
 356 #if ( configENABLE_TRUSTZONE == 1 )
 357
 358 /**
 359  * @brief Saved as part of the task context to indicate which context the
 360  * task is using on the secure side.
 361  */
 362     PRIVILEGED_DATA portDONT_DISCARD volatile SecureContextHandle_t xSecureContext = portNO_SECURE_CONTEXT;
 363 #endif /* configENABLE_TRUSTZONE */
 364
 365 #if ( configUSE_TICKLESS_IDLE == 1 )
 366
 367 /**
 368  * @brief The number of SysTick increments that make up one tick period.
 369  */
 370     PRIVILEGED_DATA static uint32_t ulTimerCountsForOneTick = 0;
 371
 372 /**
 373  * @brief The maximum number of tick periods that can be suppressed is
 374  * limited by the 24 bit resolution of the SysTick timer.
 375  */
 376     PRIVILEGED_DATA static uint32_t xMaximumPossibleSuppressedTicks = 0;
 377
 378 /**
 379  * @brief Compensate for the CPU cycles that pass while the SysTick is
 380  * stopped (low power functionality only).
 381  */
 382     PRIVILEGED_DATA static uint32_t ulStoppedTimerCompensation = 0;
 383 #endif /* configUSE_TICKLESS_IDLE */
 384 /*-----------------------------------------------------------*/
 385
 386 #if ( configUSE_TICKLESS_IDLE == 1 )
 387     __attribute__( ( weak ) ) void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )
 388     {
 389         uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements;
 390         TickType_t xModifiableIdleTime;
 391
 392         /* Make sure the SysTick reload value does not overflow the counter. */
 393         if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks )
 394         {
 395             xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
 396         }
 397
 398         /* Stop the SysTick momentarily. The time the SysTick is stopped for is
 399          * accounted for as best it can be, but using the tickless mode will
 400          * inevitably result in some tiny drift of the time maintained by the
 401          * kernel with respect to calendar time. */
 402         portNVIC_SYSTICK_CTRL_REG &= ~portNVIC_SYSTICK_ENABLE_BIT;
 403
 404         /* Calculate the reload value required to wait xExpectedIdleTime
 405          * tick periods. -1 is used because this code will execute part way
 406          * through one of the tick periods. */
 407         ulReloadValue = portNVIC_SYSTICK_CURRENT_VALUE_REG + ( ulTimerCountsForOneTick * ( xExpectedIdleTime - 1UL ) );
 408
 409         if( ulReloadValue > ulStoppedTimerCompensation )
 410         {
 411             ulReloadValue -= ulStoppedTimerCompensation;
 412         }
 413
 414         /* Enter a critical section but don't use the taskENTER_CRITICAL()
 415          * method as that will mask interrupts that should exit sleep mode. */
 416         __asm volatile ( "cpsid i" ::: "memory" );
 417         __asm volatile ( "dsb" );
 418         __asm volatile ( "isb" );
 419
 420         /* If a context switch is pending or a task is waiting for the scheduler
 421          * to be un-suspended then abandon the low power entry. */
 422         if( eTaskConfirmSleepModeStatus() == eAbortSleep )
 423         {
 424             /* Restart from whatever is left in the count register to complete
 425              * this tick period. */
 426             portNVIC_SYSTICK_LOAD_REG = portNVIC_SYSTICK_CURRENT_VALUE_REG;
 427
 428             /* Restart SysTick. */
 429             portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
 430
 431             /* Reset the reload register to the value required for normal tick
 432              * periods. */
 433             portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
 434
 435             /* Re-enable interrupts - see comments above the cpsid instruction()
 436              * above. */
 437             __asm volatile ( "cpsie i" ::: "memory" );
 438         }
 439         else
 440         {
 441             /* Set the new reload value. */
 442             portNVIC_SYSTICK_LOAD_REG = ulReloadValue;
 443
 444             /* Clear the SysTick count flag and set the count value back to
 445              * zero. */
 446             portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
 447
 448             /* Restart SysTick. */
 449             portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
 450
 451             /* Sleep until something happens. configPRE_SLEEP_PROCESSING() can
 452              * set its parameter to 0 to indicate that its implementation
 453              * contains its own wait for interrupt or wait for event
 454              * instruction, and so wfi should not be executed again. However,
 455              * the original expected idle time variable must remain unmodified,
 456              * so a copy is taken. */
 457             xModifiableIdleTime = xExpectedIdleTime;
 458             configPRE_SLEEP_PROCESSING( xModifiableIdleTime );
 459
 460             if( xModifiableIdleTime > 0 )
 461             {
 462                 __asm volatile ( "dsb" ::: "memory" );
 463                 __asm volatile ( "wfi" );
 464                 __asm volatile ( "isb" );
 465             }
 466
 467             configPOST_SLEEP_PROCESSING( xExpectedIdleTime );
 468
 469             /* Re-enable interrupts to allow the interrupt that brought the MCU
 470              * out of sleep mode to execute immediately. See comments above
 471              * the cpsid instruction above. */
 472             __asm volatile ( "cpsie i" ::: "memory" );
 473             __asm volatile ( "dsb" );
 474             __asm volatile ( "isb" );
 475
 476             /* Disable interrupts again because the clock is about to be stopped
 477              * and interrupts that execute while the clock is stopped will
 478              * increase any slippage between the time maintained by the RTOS and
 479              * calendar time. */
 480             __asm volatile ( "cpsid i" ::: "memory" );
 481             __asm volatile ( "dsb" );
 482             __asm volatile ( "isb" );
 483
 484             /* Disable the SysTick clock without reading the
 485              * portNVIC_SYSTICK_CTRL_REG register to ensure the
 486              * portNVIC_SYSTICK_COUNT_FLAG_BIT is not cleared if it is set.
 487              * Again, the time the SysTick is stopped for is accounted for as
 488              * best it can be, but using the tickless mode will inevitably
 489              * result in some tiny drift of the time maintained by the kernel
 490              * with respect to calendar time*/
 491             portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT );
 492
 493             /* Determine if the SysTick clock has already counted to zero and
 494              * been set back to the current reload value (the reload back being
 495              * correct for the entire expected idle time) or if the SysTick is
 496              * yet to count to zero (in which case an interrupt other than the
 497              * SysTick must have brought the system out of sleep mode). */
 498             if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
 499             {
 500                 uint32_t ulCalculatedLoadValue;
 501
 502                 /* The tick interrupt is already pending, and the SysTick count
 503                  * reloaded with ulReloadValue.  Reset the
 504                  * portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick
 505                  * period. */
 506                 ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );
 507
 508                 /* Don't allow a tiny value, or values that have somehow
 509                  * underflowed because the post sleep hook did something
 510                  * that took too long. */
 511                 if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )
 512                 {
 513                     ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );
 514                 }
 515
 516                 portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;
 517
 518                 /* As the pending tick will be processed as soon as this
 519                  * function exits, the tick value maintained by the tick is
 520                  * stepped forward by one less than the time spent waiting. */
 521                 ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
 522             }
 523             else
 524             {
 525                 /* Something other than the tick interrupt ended the sleep.
 526                  * Work out how long the sleep lasted rounded to complete tick
 527                  * periods (not the ulReload value which accounted for part
 528                  * ticks). */
 529                 ulCompletedSysTickDecrements = ( xExpectedIdleTime * ulTimerCountsForOneTick ) - portNVIC_SYSTICK_CURRENT_VALUE_REG;
 530
 531                 /* How many complete tick periods passed while the processor
 532                  * was waiting? */
 533                 ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
 534
 535                 /* The reload value is set to whatever fraction of a single tick
 536                  * period remains. */
 537                 portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1UL ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;
 538             }
 539
 540             /* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG
 541              * again, then set portNVIC_SYSTICK_LOAD_REG back to its standard
 542              * value. */
 543             portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
 544             portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
 545             vTaskStepTick( ulCompleteTickPeriods );
 546             portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
 547
 548             /* Exit with interrupts enabled. */
 549             __asm volatile ( "cpsie i" ::: "memory" );
 550         }
 551     }
 552 #endif /* configUSE_TICKLESS_IDLE */
 553 /*-----------------------------------------------------------*/
 554
 555 __attribute__( ( weak ) ) void vPortSetupTimerInterrupt( void ) /* PRIVILEGED_FUNCTION */
 556 {
 557     /* Calculate the constants required to configure the tick interrupt. */
 558     #if ( configUSE_TICKLESS_IDLE == 1 )
 559         {
 560             ulTimerCountsForOneTick = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ );
 561             xMaximumPossibleSuppressedTicks = portMAX_24_BIT_NUMBER / ulTimerCountsForOneTick;
 562             ulStoppedTimerCompensation = portMISSED_COUNTS_FACTOR / ( configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ );
 563         }
 564     #endif /* configUSE_TICKLESS_IDLE */
 565
 566     /* Stop and reset the SysTick. */
 567     portNVIC_SYSTICK_CTRL_REG = 0UL;
 568     portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
 569
 570     /* Configure SysTick to interrupt at the requested rate. */
 571     portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
 572     portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
 573 }
 574 /*-----------------------------------------------------------*/
 575
 576 static void prvTaskExitError( void )
 577 {
 578     volatile uint32_t ulDummy = 0UL;
 579
 580     /* A function that implements a task must not exit or attempt to return to
 581      * its caller as there is nothing to return to. If a task wants to exit it
 582      * should instead call vTaskDelete( NULL ). Artificially force an assert()
 583      * to be triggered if configASSERT() is defined, then stop here so
 584      * application writers can catch the error. */
 585     configASSERT( ulCriticalNesting == ~0UL );
 586     portDISABLE_INTERRUPTS();
 587
 588     while( ulDummy == 0 )
 589     {
 590         /* This file calls prvTaskExitError() after the scheduler has been
 591          * started to remove a compiler warning about the function being
 592          * defined but never called.  ulDummy is used purely to quieten other
 593          * warnings about code appearing after this function is called - making
 594          * ulDummy volatile makes the compiler think the function could return
 595          * and therefore not output an 'unreachable code' warning for code that
 596          * appears after it. */
 597     }
 598 }
 599 /*-----------------------------------------------------------*/
 600
 601 #if ( configENABLE_MPU == 1 )
 602     static void prvSetupMPU( void ) /* PRIVILEGED_FUNCTION */
 603     {
 604         #if defined( __ARMCC_VERSION )
 605
 606             /* Declaration when these variable are defined in code instead of being
 607              * exported from linker scripts. */
 608             extern uint32_t * __privileged_functions_start__;
 609             extern uint32_t * __privileged_functions_end__;
 610             extern uint32_t * __syscalls_flash_start__;
 611             extern uint32_t * __syscalls_flash_end__;
 612             extern uint32_t * __unprivileged_flash_start__;
 613             extern uint32_t * __unprivileged_flash_end__;
 614             extern uint32_t * __privileged_sram_start__;
 615             extern uint32_t * __privileged_sram_end__;
 616         #else /* if defined( __ARMCC_VERSION ) */
 617             /* Declaration when these variable are exported from linker scripts. */
 618             extern uint32_t __privileged_functions_start__[];
 619             extern uint32_t __privileged_functions_end__[];
 620             extern uint32_t __syscalls_flash_start__[];
 621             extern uint32_t __syscalls_flash_end__[];
 622             extern uint32_t __unprivileged_flash_start__[];
 623             extern uint32_t __unprivileged_flash_end__[];
 624             extern uint32_t __privileged_sram_start__[];
 625             extern uint32_t __privileged_sram_end__[];
 626         #endif /* defined( __ARMCC_VERSION ) */
 627
 628         /* Check that the MPU is present. */
 629         if( portMPU_TYPE_REG == portEXPECTED_MPU_TYPE_VALUE )
 630         {
 631             /* MAIR0 - Index 0. */
 632             portMPU_MAIR0_REG |= ( ( portMPU_NORMAL_MEMORY_BUFFERABLE_CACHEABLE << portMPU_MAIR_ATTR0_POS ) & portMPU_MAIR_ATTR0_MASK );
 633             /* MAIR0 - Index 1. */
 634             portMPU_MAIR0_REG |= ( ( portMPU_DEVICE_MEMORY_nGnRE << portMPU_MAIR_ATTR1_POS ) & portMPU_MAIR_ATTR1_MASK );
 635
 636             /* Setup privileged flash as Read Only so that privileged tasks can
 637              * read it but not modify. */
 638             portMPU_RNR_REG = portPRIVILEGED_FLASH_REGION;
 639             portMPU_RBAR_REG = ( ( ( uint32_t ) __privileged_functions_start__ ) & portMPU_RBAR_ADDRESS_MASK ) |
 640                                ( portMPU_REGION_NON_SHAREABLE ) |
 641                                ( portMPU_REGION_PRIVILEGED_READ_ONLY );
 642             portMPU_RLAR_REG = ( ( ( uint32_t ) __privileged_functions_end__ ) & portMPU_RLAR_ADDRESS_MASK ) |
 643                                ( portMPU_RLAR_ATTR_INDEX0 ) |
 644                                ( portMPU_RLAR_REGION_ENABLE );
 645
 646             /* Setup unprivileged flash as Read Only by both privileged and
 647              * unprivileged tasks. All tasks can read it but no-one can modify. */
 648             portMPU_RNR_REG = portUNPRIVILEGED_FLASH_REGION;
 649             portMPU_RBAR_REG = ( ( ( uint32_t ) __unprivileged_flash_start__ ) & portMPU_RBAR_ADDRESS_MASK ) |
 650                                ( portMPU_REGION_NON_SHAREABLE ) |
 651                                ( portMPU_REGION_READ_ONLY );
 652             portMPU_RLAR_REG = ( ( ( uint32_t ) __unprivileged_flash_end__ ) & portMPU_RLAR_ADDRESS_MASK ) |
 653                                ( portMPU_RLAR_ATTR_INDEX0 ) |
 654                                ( portMPU_RLAR_REGION_ENABLE );
 655
 656             /* Setup unprivileged syscalls flash as Read Only by both privileged
 657              * and unprivileged tasks. All tasks can read it but no-one can modify. */
 658             portMPU_RNR_REG = portUNPRIVILEGED_SYSCALLS_REGION;
 659             portMPU_RBAR_REG = ( ( ( uint32_t ) __syscalls_flash_start__ ) & portMPU_RBAR_ADDRESS_MASK ) |
 660                                ( portMPU_REGION_NON_SHAREABLE ) |
 661                                ( portMPU_REGION_READ_ONLY );
 662             portMPU_RLAR_REG = ( ( ( uint32_t ) __syscalls_flash_end__ ) & portMPU_RLAR_ADDRESS_MASK ) |
 663                                ( portMPU_RLAR_ATTR_INDEX0 ) |
 664                                ( portMPU_RLAR_REGION_ENABLE );
 665
 666             /* Setup RAM containing kernel data for privileged access only. */
 667             portMPU_RNR_REG = portPRIVILEGED_RAM_REGION;
 668             portMPU_RBAR_REG = ( ( ( uint32_t ) __privileged_sram_start__ ) & portMPU_RBAR_ADDRESS_MASK ) |
 669                                ( portMPU_REGION_NON_SHAREABLE ) |
 670                                ( portMPU_REGION_PRIVILEGED_READ_WRITE ) |
 671                                ( portMPU_REGION_EXECUTE_NEVER );
 672             portMPU_RLAR_REG = ( ( ( uint32_t ) __privileged_sram_end__ ) & portMPU_RLAR_ADDRESS_MASK ) |
 673                                ( portMPU_RLAR_ATTR_INDEX0 ) |
 674                                ( portMPU_RLAR_REGION_ENABLE );
 675
 676             /* Enable mem fault. */
 677             portSCB_SYS_HANDLER_CTRL_STATE_REG |= portSCB_MEM_FAULT_ENABLE_BIT;
 678
 679             /* Enable MPU with privileged background access i.e. unmapped
 680              * regions have privileged access. */
 681             portMPU_CTRL_REG |= ( portMPU_PRIV_BACKGROUND_ENABLE_BIT | portMPU_ENABLE_BIT );
 682         }
 683     }
 684 #endif /* configENABLE_MPU */
 685 /*-----------------------------------------------------------*/
 686
 687 #if ( configENABLE_FPU == 1 )
 688     static void prvSetupFPU( void ) /* PRIVILEGED_FUNCTION */
 689     {
 690         #if ( configENABLE_TRUSTZONE == 1 )
 691             {
 692                 /* Enable non-secure access to the FPU. */
 693                 SecureInit_EnableNSFPUAccess();
 694             }
 695         #endif /* configENABLE_TRUSTZONE */
 696
 697         /* CP10 = 11 ==> Full access to FPU i.e. both privileged and
 698          * unprivileged code should be able to access FPU. CP11 should be
 699          * programmed to the same value as CP10. */
 700         *( portCPACR ) |= ( ( portCPACR_CP10_VALUE << portCPACR_CP10_POS ) |
 701                             ( portCPACR_CP11_VALUE << portCPACR_CP11_POS )
 702                             );
 703
 704         /* ASPEN = 1 ==> Hardware should automatically preserve floating point
 705          * context on exception entry and restore on exception return.
 706          * LSPEN = 1 ==> Enable lazy context save of FP state. */
 707         *( portFPCCR ) |= ( portFPCCR_ASPEN_MASK | portFPCCR_LSPEN_MASK );
 708     }
 709 #endif /* configENABLE_FPU */
 710 /*-----------------------------------------------------------*/
 711
 712 void vPortYield( void ) /* PRIVILEGED_FUNCTION */
 713 {
 714     /* Set a PendSV to request a context switch. */
 715     portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
 716
 717     /* Barriers are normally not required but do ensure the code is
 718      * completely within the specified behaviour for the architecture. */
 719     __asm volatile ( "dsb" ::: "memory" );
 720     __asm volatile ( "isb" );
 721 }
 722 /*-----------------------------------------------------------*/
 723
 724 void vPortEnterCritical( void ) /* PRIVILEGED_FUNCTION */
 725 {
 726     portDISABLE_INTERRUPTS();
 727     ulCriticalNesting++;
 728
 729     /* Barriers are normally not required but do ensure the code is
 730      * completely within the specified behaviour for the architecture. */
 731     __asm volatile ( "dsb" ::: "memory" );
 732     __asm volatile ( "isb" );
 733 }
 734 /*-----------------------------------------------------------*/
 735
 736 void vPortExitCritical( void ) /* PRIVILEGED_FUNCTION */
 737 {
 738     configASSERT( ulCriticalNesting );
 739     ulCriticalNesting--;
 740
 741     if( ulCriticalNesting == 0 )
 742     {
 743         portENABLE_INTERRUPTS();
 744     }
 745 }
 746 /*-----------------------------------------------------------*/
 747
 748 void SysTick_Handler( void ) /* PRIVILEGED_FUNCTION */
 749 {
 750     uint32_t ulPreviousMask;
 751
 752     ulPreviousMask = portSET_INTERRUPT_MASK_FROM_ISR();
 753     {
 754         /* Increment the RTOS tick. */
 755         if( xTaskIncrementTick() != pdFALSE )
 756         {
 757             /* Pend a context switch. */
 758             portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
 759         }
 760     }
 761     portCLEAR_INTERRUPT_MASK_FROM_ISR( ulPreviousMask );
 762 }
 763 /*-----------------------------------------------------------*/
 764
 765 void vPortSVCHandler_C( uint32_t * pulCallerStackAddress ) /* PRIVILEGED_FUNCTION portDONT_DISCARD */
 766 {
 767     #if ( configENABLE_MPU == 1 )
 768         #if defined( __ARMCC_VERSION )
 769
 770             /* Declaration when these variable are defined in code instead of being
 771              * exported from linker scripts. */
 772             extern uint32_t * __syscalls_flash_start__;
 773             extern uint32_t * __syscalls_flash_end__;
 774         #else
 775             /* Declaration when these variable are exported from linker scripts. */
 776             extern uint32_t __syscalls_flash_start__[];
 777             extern uint32_t __syscalls_flash_end__[];
 778         #endif /* defined( __ARMCC_VERSION ) */
 779     #endif /* configENABLE_MPU */
 780
 781     uint32_t ulPC;
 782
 783     #if ( configENABLE_TRUSTZONE == 1 )
 784         uint32_t ulR0, ulR1;
 785         extern TaskHandle_t pxCurrentTCB;
 786         #if ( configENABLE_MPU == 1 )
 787             uint32_t ulControl, ulIsTaskPrivileged;
 788         #endif /* configENABLE_MPU */
 789     #endif /* configENABLE_TRUSTZONE */
 790     uint8_t ucSVCNumber;
 791
 792     /* Register are stored on the stack in the following order - R0, R1, R2, R3,
 793      * R12, LR, PC, xPSR. */
 794     ulPC = pulCallerStackAddress[ 6 ];
 795     ucSVCNumber = ( ( uint8_t * ) ulPC )[ -2 ];
 796
 797     switch( ucSVCNumber )
 798     {
 799         #if ( configENABLE_TRUSTZONE == 1 )
 800             case portSVC_ALLOCATE_SECURE_CONTEXT:
 801
 802                 /* R0 contains the stack size passed as parameter to the
 803                  * vPortAllocateSecureContext function. */
 804                 ulR0 = pulCallerStackAddress[ 0 ];
 805
 806                 #if ( configENABLE_MPU == 1 )
 807                     {
 808                         /* Read the CONTROL register value. */
 809                         __asm volatile ( "mrs %0, control"  : "=r" ( ulControl ) );
 810
 811                         /* The task that raised the SVC is privileged if Bit[0]
 812                          * in the CONTROL register is 0. */
 813                         ulIsTaskPrivileged = ( ( ulControl & portCONTROL_PRIVILEGED_MASK ) == 0 );
 814
 815                         /* Allocate and load a context for the secure task. */
 816                         xSecureContext = SecureContext_AllocateContext( ulR0, ulIsTaskPrivileged, pxCurrentTCB );
 817                     }
 818                 #else /* if ( configENABLE_MPU == 1 ) */
 819                     {
 820                         /* Allocate and load a context for the secure task. */
 821                         xSecureContext = SecureContext_AllocateContext( ulR0, pxCurrentTCB );
 822                     }
 823                 #endif /* configENABLE_MPU */
 824
 825                 configASSERT( xSecureContext != securecontextINVALID_CONTEXT_ID );
 826                 SecureContext_LoadContext( xSecureContext, pxCurrentTCB );
 827                 break;
 828
 829             case portSVC_FREE_SECURE_CONTEXT:
 830                 /* R0 contains TCB being freed and R1 contains the secure
 831                  * context handle to be freed. */
 832                 ulR0 = pulCallerStackAddress[ 0 ];
 833                 ulR1 = pulCallerStackAddress[ 1 ];
 834
 835                 /* Free the secure context. */
 836                 SecureContext_FreeContext( ( SecureContextHandle_t ) ulR1, ( void * ) ulR0 );
 837                 break;
 838         #endif /* configENABLE_TRUSTZONE */
 839
 840         case portSVC_START_SCHEDULER:
 841             #if ( configENABLE_TRUSTZONE == 1 )
 842                 {
 843                     /* De-prioritize the non-secure exceptions so that the
 844                      * non-secure pendSV runs at the lowest priority. */
 845                     SecureInit_DePrioritizeNSExceptions();
 846
 847                     /* Initialize the secure context management system. */
 848                     SecureContext_Init();
 849                 }
 850             #endif /* configENABLE_TRUSTZONE */
 851
 852             #if ( configENABLE_FPU == 1 )
 853                 {
 854                     /* Setup the Floating Point Unit (FPU). */
 855                     prvSetupFPU();
 856                 }
 857             #endif /* configENABLE_FPU */
 858
 859             /* Setup the context of the first task so that the first task starts
 860              * executing. */
 861             vRestoreContextOfFirstTask();
 862             break;
 863
 864             #if ( configENABLE_MPU == 1 )
 865                 case portSVC_RAISE_PRIVILEGE:
 866
 867                     /* Only raise the privilege, if the svc was raised from any of
 868                      * the system calls. */
 869                     if( ( ulPC >= ( uint32_t ) __syscalls_flash_start__ ) &&
 870                         ( ulPC <= ( uint32_t ) __syscalls_flash_end__ ) )
 871                     {
 872                         vRaisePrivilege();
 873                     }
 874                     break;
 875             #endif /* configENABLE_MPU */
 876
 877         default:
 878             /* Incorrect SVC call. */
 879             configASSERT( pdFALSE );
 880     }
 881 }
 882 /*-----------------------------------------------------------*/
 883 /* *INDENT-OFF* */
 884 #if ( configENABLE_MPU == 1 )
 885     StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
 886                                          StackType_t * pxEndOfStack,
 887                                          TaskFunction_t pxCode,
 888                                          void * pvParameters,
 889                                          BaseType_t xRunPrivileged ) /* PRIVILEGED_FUNCTION */
 890 #else
 891     StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
 892                                          StackType_t * pxEndOfStack,
 893                                          TaskFunction_t pxCode,
 894                                          void * pvParameters ) /* PRIVILEGED_FUNCTION */
 895 #endif /* configENABLE_MPU */
 896 /* *INDENT-ON* */
 897 {
 898     /* Simulate the stack frame as it would be created by a context switch
 899      * interrupt. */
 900     #if ( portPRELOAD_REGISTERS == 0 )
 901         {
 902             pxTopOfStack--;                                          /* Offset added to account for the way the MCU uses the stack on entry/exit of interrupts. */
 903             *pxTopOfStack = portINITIAL_XPSR;                        /* xPSR */
 904             pxTopOfStack--;
 905             *pxTopOfStack = ( StackType_t ) pxCode;                  /* PC */
 906             pxTopOfStack--;
 907             *pxTopOfStack = ( StackType_t ) portTASK_RETURN_ADDRESS; /* LR */
 908             pxTopOfStack -= 5;                                       /* R12, R3, R2 and R1. */
 909             *pxTopOfStack = ( StackType_t ) pvParameters;            /* R0 */
 910             pxTopOfStack -= 9;                                       /* R11..R4, EXC_RETURN. */
 911             *pxTopOfStack = portINITIAL_EXC_RETURN;
 912
 913             #if ( configENABLE_MPU == 1 )
 914                 {
 915                     pxTopOfStack--;
 916
 917                     if( xRunPrivileged == pdTRUE )
 918                     {
 919                         *pxTopOfStack = portINITIAL_CONTROL_PRIVILEGED; /* Slot used to hold this task's CONTROL value. */
 920                     }
 921                     else
 922                     {
 923                         *pxTopOfStack = portINITIAL_CONTROL_UNPRIVILEGED; /* Slot used to hold this task's CONTROL value. */
 924                     }
 925                 }
 926             #endif /* configENABLE_MPU */
 927
 928             pxTopOfStack--;
 929             *pxTopOfStack = ( StackType_t ) pxEndOfStack; /* Slot used to hold this task's PSPLIM value. */
 930
 931             #if ( configENABLE_TRUSTZONE == 1 )
 932                 {
 933                     pxTopOfStack--;
 934                     *pxTopOfStack = portNO_SECURE_CONTEXT; /* Slot used to hold this task's xSecureContext value. */
 935                 }
 936             #endif /* configENABLE_TRUSTZONE */
 937         }
 938     #else /* portPRELOAD_REGISTERS */
 939         {
 940             pxTopOfStack--;                                          /* Offset added to account for the way the MCU uses the stack on entry/exit of interrupts. */
 941             *pxTopOfStack = portINITIAL_XPSR;                        /* xPSR */
 942             pxTopOfStack--;
 943             *pxTopOfStack = ( StackType_t ) pxCode;                  /* PC */
 944             pxTopOfStack--;
 945             *pxTopOfStack = ( StackType_t ) portTASK_RETURN_ADDRESS; /* LR */
 946             pxTopOfStack--;
 947             *pxTopOfStack = ( StackType_t ) 0x12121212UL;            /* R12 */
 948             pxTopOfStack--;
 949             *pxTopOfStack = ( StackType_t ) 0x03030303UL;            /* R3 */
 950             pxTopOfStack--;
 951             *pxTopOfStack = ( StackType_t ) 0x02020202UL;            /* R2 */
 952             pxTopOfStack--;
 953             *pxTopOfStack = ( StackType_t ) 0x01010101UL;            /* R1 */
 954             pxTopOfStack--;
 955             *pxTopOfStack = ( StackType_t ) pvParameters;            /* R0 */
 956             pxTopOfStack--;
 957             *pxTopOfStack = ( StackType_t ) 0x11111111UL;            /* R11 */
 958             pxTopOfStack--;
 959             *pxTopOfStack = ( StackType_t ) 0x10101010UL;            /* R10 */
 960             pxTopOfStack--;
 961             *pxTopOfStack = ( StackType_t ) 0x09090909UL;            /* R09 */
 962             pxTopOfStack--;
 963             *pxTopOfStack = ( StackType_t ) 0x08080808UL;            /* R08 */
 964             pxTopOfStack--;
 965             *pxTopOfStack = ( StackType_t ) 0x07070707UL;            /* R07 */
 966             pxTopOfStack--;
 967             *pxTopOfStack = ( StackType_t ) 0x06060606UL;            /* R06 */
 968             pxTopOfStack--;
 969             *pxTopOfStack = ( StackType_t ) 0x05050505UL;            /* R05 */
 970             pxTopOfStack--;
 971             *pxTopOfStack = ( StackType_t ) 0x04040404UL;            /* R04 */
 972             pxTopOfStack--;
 973             *pxTopOfStack = portINITIAL_EXC_RETURN;                  /* EXC_RETURN */
 974
 975             #if ( configENABLE_MPU == 1 )
 976                 {
 977                     pxTopOfStack--;
 978
 979                     if( xRunPrivileged == pdTRUE )
 980                     {
 981                         *pxTopOfStack = portINITIAL_CONTROL_PRIVILEGED; /* Slot used to hold this task's CONTROL value. */
 982                     }
 983                     else
 984                     {
 985                         *pxTopOfStack = portINITIAL_CONTROL_UNPRIVILEGED; /* Slot used to hold this task's CONTROL value. */
 986                     }
 987                 }
 988             #endif /* configENABLE_MPU */
 989
 990             pxTopOfStack--;
 991             *pxTopOfStack = ( StackType_t ) pxEndOfStack; /* Slot used to hold this task's PSPLIM value. */
 992
 993             #if ( configENABLE_TRUSTZONE == 1 )
 994                 {
 995                     pxTopOfStack--;
 996                     *pxTopOfStack = portNO_SECURE_CONTEXT; /* Slot used to hold this task's xSecureContext value. */
 997                 }
 998             #endif /* configENABLE_TRUSTZONE */
 999         }
1000     #endif /* portPRELOAD_REGISTERS */
1001
1002     return pxTopOfStack;
1003 }
1004 /*-----------------------------------------------------------*/
1005
1006 BaseType_t xPortStartScheduler( void ) /* PRIVILEGED_FUNCTION */
1007 {
1008     /* Make PendSV, CallSV and SysTick the same priority as the kernel. */
1009     portNVIC_SHPR3_REG |= portNVIC_PENDSV_PRI;
1010     portNVIC_SHPR3_REG |= portNVIC_SYSTICK_PRI;
1011
1012     #if ( configENABLE_MPU == 1 )
1013         {
1014             /* Setup the Memory Protection Unit (MPU). */
1015             prvSetupMPU();
1016         }
1017     #endif /* configENABLE_MPU */
1018
1019     /* Start the timer that generates the tick ISR. Interrupts are disabled
1020      * here already. */
1021     vPortSetupTimerInterrupt();
1022
1023     /* Initialize the critical nesting count ready for the first task. */
1024     ulCriticalNesting = 0;
1025
1026     /* Start the first task. */
1027     vStartFirstTask();
1028
1029     /* Should never get here as the tasks will now be executing. Call the task
1030      * exit error function to prevent compiler warnings about a static function
1031      * not being called in the case that the application writer overrides this
1032      * functionality by defining configTASK_RETURN_ADDRESS. Call
1033      * vTaskSwitchContext() so link time optimization does not remove the
1034      * symbol. */
1035     vTaskSwitchContext();
1036     prvTaskExitError();
1037
1038     /* Should not get here. */
1039     return 0;
1040 }
1041 /*-----------------------------------------------------------*/
1042
1043 void vPortEndScheduler( void ) /* PRIVILEGED_FUNCTION */
1044 {
1045     /* Not implemented in ports where there is nothing to return to.
1046      * Artificially force an assert. */
1047     configASSERT( ulCriticalNesting == 1000UL );
1048 }
1049 /*-----------------------------------------------------------*/
1050
1051 #if ( configENABLE_MPU == 1 )
1052     void vPortStoreTaskMPUSettings( xMPU_SETTINGS * xMPUSettings,
1053                                     const struct xMEMORY_REGION * const xRegions,
1054                                     StackType_t * pxBottomOfStack,
1055                                     uint32_t ulStackDepth )
1056     {
1057         uint32_t ulRegionStartAddress, ulRegionEndAddress, ulRegionNumber;
1058         int32_t lIndex = 0;
1059
1060         #if defined( __ARMCC_VERSION )
1061
1062             /* Declaration when these variable are defined in code instead of being
1063              * exported from linker scripts. */
1064             extern uint32_t * __privileged_sram_start__;
1065             extern uint32_t * __privileged_sram_end__;
1066         #else
1067             /* Declaration when these variable are exported from linker scripts. */
1068             extern uint32_t __privileged_sram_start__[];
1069             extern uint32_t __privileged_sram_end__[];
1070         #endif /* defined( __ARMCC_VERSION ) */
1071
1072         /* Setup MAIR0. */
1073         xMPUSettings->ulMAIR0 = ( ( portMPU_NORMAL_MEMORY_BUFFERABLE_CACHEABLE << portMPU_MAIR_ATTR0_POS ) & portMPU_MAIR_ATTR0_MASK );
1074         xMPUSettings->ulMAIR0 |= ( ( portMPU_DEVICE_MEMORY_nGnRE << portMPU_MAIR_ATTR1_POS ) & portMPU_MAIR_ATTR1_MASK );
1075
1076         /* This function is called automatically when the task is created - in
1077          * which case the stack region parameters will be valid.  At all other
1078          * times the stack parameters will not be valid and it is assumed that
1079          * the stack region has already been configured. */
1080         if( ulStackDepth > 0 )
1081         {
1082             ulRegionStartAddress = ( uint32_t ) pxBottomOfStack;
1083             ulRegionEndAddress = ( uint32_t ) pxBottomOfStack + ( ulStackDepth * ( uint32_t ) sizeof( StackType_t ) ) - 1;
1084
1085             /* If the stack is within the privileged SRAM, do not protect it
1086              * using a separate MPU region. This is needed because privileged
1087              * SRAM is already protected using an MPU region and ARMv8-M does
1088              * not allow overlapping MPU regions. */
1089             if( ( ulRegionStartAddress >= ( uint32_t ) __privileged_sram_start__ ) &&
1090                 ( ulRegionEndAddress <= ( uint32_t ) __privileged_sram_end__ ) )
1091             {
1092                 xMPUSettings->xRegionsSettings[ 0 ].ulRBAR = 0;
1093                 xMPUSettings->xRegionsSettings[ 0 ].ulRLAR = 0;
1094             }
1095             else
1096             {
1097                 /* Define the region that allows access to the stack. */
1098                 ulRegionStartAddress &= portMPU_RBAR_ADDRESS_MASK;
1099                 ulRegionEndAddress &= portMPU_RLAR_ADDRESS_MASK;
1100
1101                 xMPUSettings->xRegionsSettings[ 0 ].ulRBAR = ( ulRegionStartAddress ) |
1102                                                              ( portMPU_REGION_NON_SHAREABLE ) |
1103                                                              ( portMPU_REGION_READ_WRITE ) |
1104                                                              ( portMPU_REGION_EXECUTE_NEVER );
1105
1106                 xMPUSettings->xRegionsSettings[ 0 ].ulRLAR = ( ulRegionEndAddress ) |
1107                                                              ( portMPU_RLAR_ATTR_INDEX0 ) |
1108                                                              ( portMPU_RLAR_REGION_ENABLE );
1109             }
1110         }
1111
1112         /* User supplied configurable regions. */
1113         for( ulRegionNumber = 1; ulRegionNumber <= portNUM_CONFIGURABLE_REGIONS; ulRegionNumber++ )
1114         {
1115             /* If xRegions is NULL i.e. the task has not specified any MPU
1116              * region, the else part ensures that all the configurable MPU
1117              * regions are invalidated. */
1118             if( ( xRegions != NULL ) && ( xRegions[ lIndex ].ulLengthInBytes > 0UL ) )
1119             {
1120                 /* Translate the generic region definition contained in xRegions
1121                  * into the ARMv8 specific MPU settings that are then stored in
1122                  * xMPUSettings. */
1123                 ulRegionStartAddress = ( ( uint32_t ) xRegions[ lIndex ].pvBaseAddress ) & portMPU_RBAR_ADDRESS_MASK;
1124                 ulRegionEndAddress = ( uint32_t ) xRegions[ lIndex ].pvBaseAddress + xRegions[ lIndex ].ulLengthInBytes - 1;
1125                 ulRegionEndAddress &= portMPU_RLAR_ADDRESS_MASK;
1126
1127                 /* Start address. */
1128                 xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR = ( ulRegionStartAddress ) |
1129                                                                           ( portMPU_REGION_NON_SHAREABLE );
1130
1131                 /* RO/RW. */
1132                 if( ( xRegions[ lIndex ].ulParameters & tskMPU_REGION_READ_ONLY ) != 0 )
1133                 {
1134                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR |= ( portMPU_REGION_READ_ONLY );
1135                 }
1136                 else
1137                 {
1138                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR |= ( portMPU_REGION_READ_WRITE );
1139                 }
1140
1141                 /* XN. */
1142                 if( ( xRegions[ lIndex ].ulParameters & tskMPU_REGION_EXECUTE_NEVER ) != 0 )
1143                 {
1144                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR |= ( portMPU_REGION_EXECUTE_NEVER );
1145                 }
1146
1147                 /* End Address. */
1148                 xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRLAR = ( ulRegionEndAddress ) |
1149                                                                           ( portMPU_RLAR_REGION_ENABLE );
1150
1151                 /* Normal memory/ Device memory. */
1152                 if( ( xRegions[ lIndex ].ulParameters & tskMPU_REGION_DEVICE_MEMORY ) != 0 )
1153                 {
1154                     /* Attr1 in MAIR0 is configured as device memory. */
1155                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRLAR |= portMPU_RLAR_ATTR_INDEX1;
1156                 }
1157                 else
1158                 {
1159                     /* Attr1 in MAIR0 is configured as normal memory. */
1160                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRLAR |= portMPU_RLAR_ATTR_INDEX0;
1161                 }
1162             }
1163             else
1164             {
1165                 /* Invalidate the region. */
1166                 xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR = 0UL;
1167                 xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRLAR = 0UL;
1168             }
1169
1170             lIndex++;
1171         }
1172     }
1173 #endif /* configENABLE_MPU */
1174 /*-----------------------------------------------------------*/
1175
1176 BaseType_t xPortIsInsideInterrupt( void )
1177 {
1178     uint32_t ulCurrentInterrupt;
1179     BaseType_t xReturn;
1180
1181     /* Obtain the number of the currently executing interrupt. Interrupt Program
1182      * Status Register (IPSR) holds the exception number of the currently-executing
1183      * exception or zero for Thread mode.*/
1184     __asm volatile ( "mrs %0, ipsr" : "=r" ( ulCurrentInterrupt )::"memory" );
1185
1186     if( ulCurrentInterrupt == 0 )
1187     {
1188         xReturn = pdFALSE;
1189     }
1190     else
1191     {
1192         xReturn = pdTRUE;
1193     }
1194
1195     return xReturn;
1196 }
1197 /*-----------------------------------------------------------*/