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

   1 /*
   2  * FreeRTOS Kernel <DEVELOPMENT BRANCH>
   3  * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
   4  *
   5  * SPDX-License-Identifier: MIT
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   8  * this software and associated documentation files (the "Software"), to deal in
   9  * the Software without restriction, including without limitation the rights to
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  11  * the Software, and to permit persons to whom the Software is furnished to do so,
  12  * subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in all
  15  * copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  19  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  20  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * https://www.FreeRTOS.org
  25  * https://github.com/FreeRTOS
  26  *
  27  */
  28
  29 /* 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;
 785         #if ( configENABLE_MPU == 1 )
 786             uint32_t ulControl, ulIsTaskPrivileged;
 787         #endif /* configENABLE_MPU */
 788     #endif /* configENABLE_TRUSTZONE */
 789     uint8_t ucSVCNumber;
 790
 791     /* Register are stored on the stack in the following order - R0, R1, R2, R3,
 792      * R12, LR, PC, xPSR. */
 793     ulPC = pulCallerStackAddress[ 6 ];
 794     ucSVCNumber = ( ( uint8_t * ) ulPC )[ -2 ];
 795
 796     switch( ucSVCNumber )
 797     {
 798         #if ( configENABLE_TRUSTZONE == 1 )
 799             case portSVC_ALLOCATE_SECURE_CONTEXT:
 800
 801                 /* R0 contains the stack size passed as parameter to the
 802                  * vPortAllocateSecureContext function. */
 803                 ulR0 = pulCallerStackAddress[ 0 ];
 804
 805                 #if ( configENABLE_MPU == 1 )
 806                     {
 807                         /* Read the CONTROL register value. */
 808                         __asm volatile ( "mrs %0, control"  : "=r" ( ulControl ) );
 809
 810                         /* The task that raised the SVC is privileged if Bit[0]
 811                          * in the CONTROL register is 0. */
 812                         ulIsTaskPrivileged = ( ( ulControl & portCONTROL_PRIVILEGED_MASK ) == 0 );
 813
 814                         /* Allocate and load a context for the secure task. */
 815                         xSecureContext = SecureContext_AllocateContext( ulR0, ulIsTaskPrivileged );
 816                     }
 817                 #else /* if ( configENABLE_MPU == 1 ) */
 818                     {
 819                         /* Allocate and load a context for the secure task. */
 820                         xSecureContext = SecureContext_AllocateContext( ulR0 );
 821                     }
 822                 #endif /* configENABLE_MPU */
 823
 824                 configASSERT( xSecureContext != NULL );
 825                 SecureContext_LoadContext( xSecureContext );
 826                 break;
 827
 828             case portSVC_FREE_SECURE_CONTEXT:
 829                 /* R0 contains the secure context handle to be freed. */
 830                 ulR0 = pulCallerStackAddress[ 0 ];
 831
 832                 /* Free the secure context. */
 833                 SecureContext_FreeContext( ( SecureContextHandle_t ) ulR0 );
 834                 break;
 835         #endif /* configENABLE_TRUSTZONE */
 836
 837         case portSVC_START_SCHEDULER:
 838             #if ( configENABLE_TRUSTZONE == 1 )
 839                 {
 840                     /* De-prioritize the non-secure exceptions so that the
 841                      * non-secure pendSV runs at the lowest priority. */
 842                     SecureInit_DePrioritizeNSExceptions();
 843
 844                     /* Initialize the secure context management system. */
 845                     SecureContext_Init();
 846                 }
 847             #endif /* configENABLE_TRUSTZONE */
 848
 849             #if ( configENABLE_FPU == 1 )
 850                 {
 851                     /* Setup the Floating Point Unit (FPU). */
 852                     prvSetupFPU();
 853                 }
 854             #endif /* configENABLE_FPU */
 855
 856             /* Setup the context of the first task so that the first task starts
 857              * executing. */
 858             vRestoreContextOfFirstTask();
 859             break;
 860
 861             #if ( configENABLE_MPU == 1 )
 862                 case portSVC_RAISE_PRIVILEGE:
 863
 864                     /* Only raise the privilege, if the svc was raised from any of
 865                      * the system calls. */
 866                     if( ( ulPC >= ( uint32_t ) __syscalls_flash_start__ ) &&
 867                         ( ulPC <= ( uint32_t ) __syscalls_flash_end__ ) )
 868                     {
 869                         vRaisePrivilege();
 870                     }
 871                     break;
 872             #endif /* configENABLE_MPU */
 873
 874         default:
 875             /* Incorrect SVC call. */
 876             configASSERT( pdFALSE );
 877     }
 878 }
 879 /*-----------------------------------------------------------*/
 880 /* *INDENT-OFF* */
 881 #if ( configENABLE_MPU == 1 )
 882     StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
 883                                          StackType_t * pxEndOfStack,
 884                                          TaskFunction_t pxCode,
 885                                          void * pvParameters,
 886                                          BaseType_t xRunPrivileged ) /* PRIVILEGED_FUNCTION */
 887 #else
 888     StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
 889                                          StackType_t * pxEndOfStack,
 890                                          TaskFunction_t pxCode,
 891                                          void * pvParameters ) /* PRIVILEGED_FUNCTION */
 892 #endif /* configENABLE_MPU */
 893 /* *INDENT-ON* */
 894 {
 895     /* Simulate the stack frame as it would be created by a context switch
 896      * interrupt. */
 897     #if ( portPRELOAD_REGISTERS == 0 )
 898         {
 899             pxTopOfStack--;                                          /* Offset added to account for the way the MCU uses the stack on entry/exit of interrupts. */
 900             *pxTopOfStack = portINITIAL_XPSR;                        /* xPSR */
 901             pxTopOfStack--;
 902             *pxTopOfStack = ( StackType_t ) pxCode;                  /* PC */
 903             pxTopOfStack--;
 904             *pxTopOfStack = ( StackType_t ) portTASK_RETURN_ADDRESS; /* LR */
 905             pxTopOfStack -= 5;                                       /* R12, R3, R2 and R1. */
 906             *pxTopOfStack = ( StackType_t ) pvParameters;            /* R0 */
 907             pxTopOfStack -= 9;                                       /* R11..R4, EXC_RETURN. */
 908             *pxTopOfStack = portINITIAL_EXC_RETURN;
 909
 910             #if ( configENABLE_MPU == 1 )
 911                 {
 912                     pxTopOfStack--;
 913
 914                     if( xRunPrivileged == pdTRUE )
 915                     {
 916                         *pxTopOfStack = portINITIAL_CONTROL_PRIVILEGED; /* Slot used to hold this task's CONTROL value. */
 917                     }
 918                     else
 919                     {
 920                         *pxTopOfStack = portINITIAL_CONTROL_UNPRIVILEGED; /* Slot used to hold this task's CONTROL value. */
 921                     }
 922                 }
 923             #endif /* configENABLE_MPU */
 924
 925             pxTopOfStack--;
 926             *pxTopOfStack = ( StackType_t ) pxEndOfStack; /* Slot used to hold this task's PSPLIM value. */
 927
 928             #if ( configENABLE_TRUSTZONE == 1 )
 929                 {
 930                     pxTopOfStack--;
 931                     *pxTopOfStack = portNO_SECURE_CONTEXT; /* Slot used to hold this task's xSecureContext value. */
 932                 }
 933             #endif /* configENABLE_TRUSTZONE */
 934         }
 935     #else /* portPRELOAD_REGISTERS */
 936         {
 937             pxTopOfStack--;                                          /* Offset added to account for the way the MCU uses the stack on entry/exit of interrupts. */
 938             *pxTopOfStack = portINITIAL_XPSR;                        /* xPSR */
 939             pxTopOfStack--;
 940             *pxTopOfStack = ( StackType_t ) pxCode;                  /* PC */
 941             pxTopOfStack--;
 942             *pxTopOfStack = ( StackType_t ) portTASK_RETURN_ADDRESS; /* LR */
 943             pxTopOfStack--;
 944             *pxTopOfStack = ( StackType_t ) 0x12121212UL;            /* R12 */
 945             pxTopOfStack--;
 946             *pxTopOfStack = ( StackType_t ) 0x03030303UL;            /* R3 */
 947             pxTopOfStack--;
 948             *pxTopOfStack = ( StackType_t ) 0x02020202UL;            /* R2 */
 949             pxTopOfStack--;
 950             *pxTopOfStack = ( StackType_t ) 0x01010101UL;            /* R1 */
 951             pxTopOfStack--;
 952             *pxTopOfStack = ( StackType_t ) pvParameters;            /* R0 */
 953             pxTopOfStack--;
 954             *pxTopOfStack = ( StackType_t ) 0x11111111UL;            /* R11 */
 955             pxTopOfStack--;
 956             *pxTopOfStack = ( StackType_t ) 0x10101010UL;            /* R10 */
 957             pxTopOfStack--;
 958             *pxTopOfStack = ( StackType_t ) 0x09090909UL;            /* R09 */
 959             pxTopOfStack--;
 960             *pxTopOfStack = ( StackType_t ) 0x08080808UL;            /* R08 */
 961             pxTopOfStack--;
 962             *pxTopOfStack = ( StackType_t ) 0x07070707UL;            /* R07 */
 963             pxTopOfStack--;
 964             *pxTopOfStack = ( StackType_t ) 0x06060606UL;            /* R06 */
 965             pxTopOfStack--;
 966             *pxTopOfStack = ( StackType_t ) 0x05050505UL;            /* R05 */
 967             pxTopOfStack--;
 968             *pxTopOfStack = ( StackType_t ) 0x04040404UL;            /* R04 */
 969             pxTopOfStack--;
 970             *pxTopOfStack = portINITIAL_EXC_RETURN;                  /* EXC_RETURN */
 971
 972             #if ( configENABLE_MPU == 1 )
 973                 {
 974                     pxTopOfStack--;
 975
 976                     if( xRunPrivileged == pdTRUE )
 977                     {
 978                         *pxTopOfStack = portINITIAL_CONTROL_PRIVILEGED; /* Slot used to hold this task's CONTROL value. */
 979                     }
 980                     else
 981                     {
 982                         *pxTopOfStack = portINITIAL_CONTROL_UNPRIVILEGED; /* Slot used to hold this task's CONTROL value. */
 983                     }
 984                 }
 985             #endif /* configENABLE_MPU */
 986
 987             pxTopOfStack--;
 988             *pxTopOfStack = ( StackType_t ) pxEndOfStack; /* Slot used to hold this task's PSPLIM value. */
 989
 990             #if ( configENABLE_TRUSTZONE == 1 )
 991                 {
 992                     pxTopOfStack--;
 993                     *pxTopOfStack = portNO_SECURE_CONTEXT; /* Slot used to hold this task's xSecureContext value. */
 994                 }
 995             #endif /* configENABLE_TRUSTZONE */
 996         }
 997     #endif /* portPRELOAD_REGISTERS */
 998
 999     return pxTopOfStack;
1000 }
1001 /*-----------------------------------------------------------*/
1002
1003 BaseType_t xPortStartScheduler( void ) /* PRIVILEGED_FUNCTION */
1004 {
1005     /* Make PendSV, CallSV and SysTick the same priority as the kernel. */
1006     portNVIC_SHPR3_REG |= portNVIC_PENDSV_PRI;
1007     portNVIC_SHPR3_REG |= portNVIC_SYSTICK_PRI;
1008
1009     #if ( configENABLE_MPU == 1 )
1010         {
1011             /* Setup the Memory Protection Unit (MPU). */
1012             prvSetupMPU();
1013         }
1014     #endif /* configENABLE_MPU */
1015
1016     /* Start the timer that generates the tick ISR. Interrupts are disabled
1017      * here already. */
1018     vPortSetupTimerInterrupt();
1019
1020     /* Initialize the critical nesting count ready for the first task. */
1021     ulCriticalNesting = 0;
1022
1023     /* Start the first task. */
1024     vStartFirstTask();
1025
1026     /* Should never get here as the tasks will now be executing. Call the task
1027      * exit error function to prevent compiler warnings about a static function
1028      * not being called in the case that the application writer overrides this
1029      * functionality by defining configTASK_RETURN_ADDRESS. Call
1030      * vTaskSwitchContext() so link time optimization does not remove the
1031      * symbol. */
1032     vTaskSwitchContext();
1033     prvTaskExitError();
1034
1035     /* Should not get here. */
1036     return 0;
1037 }
1038 /*-----------------------------------------------------------*/
1039
1040 void vPortEndScheduler( void ) /* PRIVILEGED_FUNCTION */
1041 {
1042     /* Not implemented in ports where there is nothing to return to.
1043      * Artificially force an assert. */
1044     configASSERT( ulCriticalNesting == 1000UL );
1045 }
1046 /*-----------------------------------------------------------*/
1047
1048 #if ( configENABLE_MPU == 1 )
1049     void vPortStoreTaskMPUSettings( xMPU_SETTINGS * xMPUSettings,
1050                                     const struct xMEMORY_REGION * const xRegions,
1051                                     StackType_t * pxBottomOfStack,
1052                                     uint32_t ulStackDepth )
1053     {
1054         uint32_t ulRegionStartAddress, ulRegionEndAddress, ulRegionNumber;
1055         int32_t lIndex = 0;
1056
1057         #if defined( __ARMCC_VERSION )
1058
1059             /* Declaration when these variable are defined in code instead of being
1060              * exported from linker scripts. */
1061             extern uint32_t * __privileged_sram_start__;
1062             extern uint32_t * __privileged_sram_end__;
1063         #else
1064             /* Declaration when these variable are exported from linker scripts. */
1065             extern uint32_t __privileged_sram_start__[];
1066             extern uint32_t __privileged_sram_end__[];
1067         #endif /* defined( __ARMCC_VERSION ) */
1068
1069         /* Setup MAIR0. */
1070         xMPUSettings->ulMAIR0 = ( ( portMPU_NORMAL_MEMORY_BUFFERABLE_CACHEABLE << portMPU_MAIR_ATTR0_POS ) & portMPU_MAIR_ATTR0_MASK );
1071         xMPUSettings->ulMAIR0 |= ( ( portMPU_DEVICE_MEMORY_nGnRE << portMPU_MAIR_ATTR1_POS ) & portMPU_MAIR_ATTR1_MASK );
1072
1073         /* This function is called automatically when the task is created - in
1074          * which case the stack region parameters will be valid.  At all other
1075          * times the stack parameters will not be valid and it is assumed that
1076          * the stack region has already been configured. */
1077         if( ulStackDepth > 0 )
1078         {
1079             ulRegionStartAddress = ( uint32_t ) pxBottomOfStack;
1080             ulRegionEndAddress = ( uint32_t ) pxBottomOfStack + ( ulStackDepth * ( uint32_t ) sizeof( StackType_t ) ) - 1;
1081
1082             /* If the stack is within the privileged SRAM, do not protect it
1083              * using a separate MPU region. This is needed because privileged
1084              * SRAM is already protected using an MPU region and ARMv8-M does
1085              * not allow overlapping MPU regions. */
1086             if( ( ulRegionStartAddress >= ( uint32_t ) __privileged_sram_start__ ) &&
1087                 ( ulRegionEndAddress <= ( uint32_t ) __privileged_sram_end__ ) )
1088             {
1089                 xMPUSettings->xRegionsSettings[ 0 ].ulRBAR = 0;
1090                 xMPUSettings->xRegionsSettings[ 0 ].ulRLAR = 0;
1091             }
1092             else
1093             {
1094                 /* Define the region that allows access to the stack. */
1095                 ulRegionStartAddress &= portMPU_RBAR_ADDRESS_MASK;
1096                 ulRegionEndAddress &= portMPU_RLAR_ADDRESS_MASK;
1097
1098                 xMPUSettings->xRegionsSettings[ 0 ].ulRBAR = ( ulRegionStartAddress ) |
1099                                                              ( portMPU_REGION_NON_SHAREABLE ) |
1100                                                              ( portMPU_REGION_READ_WRITE ) |
1101                                                              ( portMPU_REGION_EXECUTE_NEVER );
1102
1103                 xMPUSettings->xRegionsSettings[ 0 ].ulRLAR = ( ulRegionEndAddress ) |
1104                                                              ( portMPU_RLAR_ATTR_INDEX0 ) |
1105                                                              ( portMPU_RLAR_REGION_ENABLE );
1106             }
1107         }
1108
1109         /* User supplied configurable regions. */
1110         for( ulRegionNumber = 1; ulRegionNumber <= portNUM_CONFIGURABLE_REGIONS; ulRegionNumber++ )
1111         {
1112             /* If xRegions is NULL i.e. the task has not specified any MPU
1113              * region, the else part ensures that all the configurable MPU
1114              * regions are invalidated. */
1115             if( ( xRegions != NULL ) && ( xRegions[ lIndex ].ulLengthInBytes > 0UL ) )
1116             {
1117                 /* Translate the generic region definition contained in xRegions
1118                  * into the ARMv8 specific MPU settings that are then stored in
1119                  * xMPUSettings. */
1120                 ulRegionStartAddress = ( ( uint32_t ) xRegions[ lIndex ].pvBaseAddress ) & portMPU_RBAR_ADDRESS_MASK;
1121                 ulRegionEndAddress = ( uint32_t ) xRegions[ lIndex ].pvBaseAddress + xRegions[ lIndex ].ulLengthInBytes - 1;
1122                 ulRegionEndAddress &= portMPU_RLAR_ADDRESS_MASK;
1123
1124                 /* Start address. */
1125                 xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR = ( ulRegionStartAddress ) |
1126                                                                           ( portMPU_REGION_NON_SHAREABLE );
1127
1128                 /* RO/RW. */
1129                 if( ( xRegions[ lIndex ].ulParameters & tskMPU_REGION_READ_ONLY ) != 0 )
1130                 {
1131                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR |= ( portMPU_REGION_READ_ONLY );
1132                 }
1133                 else
1134                 {
1135                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR |= ( portMPU_REGION_READ_WRITE );
1136                 }
1137
1138                 /* XN. */
1139                 if( ( xRegions[ lIndex ].ulParameters & tskMPU_REGION_EXECUTE_NEVER ) != 0 )
1140                 {
1141                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR |= ( portMPU_REGION_EXECUTE_NEVER );
1142                 }
1143
1144                 /* End Address. */
1145                 xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRLAR = ( ulRegionEndAddress ) |
1146                                                                           ( portMPU_RLAR_REGION_ENABLE );
1147
1148                 /* Normal memory/ Device memory. */
1149                 if( ( xRegions[ lIndex ].ulParameters & tskMPU_REGION_DEVICE_MEMORY ) != 0 )
1150                 {
1151                     /* Attr1 in MAIR0 is configured as device memory. */
1152                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRLAR |= portMPU_RLAR_ATTR_INDEX1;
1153                 }
1154                 else
1155                 {
1156                     /* Attr1 in MAIR0 is configured as normal memory. */
1157                     xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRLAR |= portMPU_RLAR_ATTR_INDEX0;
1158                 }
1159             }
1160             else
1161             {
1162                 /* Invalidate the region. */
1163                 xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRBAR = 0UL;
1164                 xMPUSettings->xRegionsSettings[ ulRegionNumber ].ulRLAR = 0UL;
1165             }
1166
1167             lIndex++;
1168         }
1169     }
1170 #endif /* configENABLE_MPU */
1171 /*-----------------------------------------------------------*/
1172
1173 BaseType_t xPortIsInsideInterrupt( void )
1174 {
1175     uint32_t ulCurrentInterrupt;
1176     BaseType_t xReturn;
1177
1178     /* Obtain the number of the currently executing interrupt. Interrupt Program
1179      * Status Register (IPSR) holds the exception number of the currently-executing
1180      * exception or zero for Thread mode.*/
1181     __asm volatile ( "mrs %0, ipsr" : "=r" ( ulCurrentInterrupt )::"memory" );
1182
1183     if( ulCurrentInterrupt == 0 )
1184     {
1185         xReturn = pdFALSE;
1186     }
1187     else
1188     {
1189         xReturn = pdTRUE;
1190     }
1191
1192     return xReturn;
1193 }
1194 /*-----------------------------------------------------------*/