You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
846 lines
33 KiB
C
846 lines
33 KiB
C
/*
|
|
* FreeRTOS Kernel <DEVELOPMENT BRANCH>
|
|
* Copyright (C) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
* this software and associated documentation files (the "Software"), to deal in
|
|
* the Software without restriction, including without limitation the rights to
|
|
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
* the Software, and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* https://www.FreeRTOS.org
|
|
* https://github.com/FreeRTOS
|
|
*
|
|
*/
|
|
|
|
/* Standard includes. */
|
|
#include <stdint.h>
|
|
|
|
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
|
|
* all the API functions to use the MPU wrappers. That should only be done when
|
|
* task.h is included from an application file. */
|
|
#ifndef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
|
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
|
#endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
|
|
|
|
/* Scheduler includes. */
|
|
#include "FreeRTOS.h"
|
|
#include "portmacro.h"
|
|
#include "task.h"
|
|
#include "mpu_syscall_numbers.h"
|
|
|
|
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
|
|
|
/* Max value that fits in a uint32_t type. */
|
|
#define portUINT32_MAX ( ~( ( uint32_t ) 0 ) )
|
|
|
|
/* Check if adding a and b will result in overflow. */
|
|
#define portADD_UINT32_WILL_OVERFLOW( a, b ) ( ( a ) > ( portUINT32_MAX - ( b ) ) )
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Variable used to keep track of critical section nesting.
|
|
*
|
|
* @ingroup Critical Sections
|
|
*
|
|
* This variable is stored as part of the task context and must be initialised
|
|
* to a non zero value to ensure interrupts don't inadvertently become unmasked
|
|
* before the scheduler starts. As it is stored as part of the task context, it
|
|
* will be set to 0 when the first task is started.
|
|
*/
|
|
PRIVILEGED_DATA volatile UBaseType_t ulCriticalNesting = 0xFFFF;
|
|
|
|
/**
|
|
* @brief Set to 1 to pend a context switch from an ISR.
|
|
*
|
|
* @ingroup Interrupt Management
|
|
*/
|
|
PRIVILEGED_DATA volatile UBaseType_t ulPortYieldRequired = pdFALSE;
|
|
|
|
/**
|
|
* @brief Interrupt nesting depth, used to count the number of interrupts to unwind.
|
|
*
|
|
* @ingroup Interrupt Management
|
|
*/
|
|
PRIVILEGED_DATA volatile UBaseType_t ulPortInterruptNesting = 0UL;
|
|
|
|
/**
|
|
* @brief Variable to track whether or not the scheduler has been started.
|
|
*
|
|
* @ingroup Scheduler
|
|
*
|
|
* This is the port specific version of the xSchedulerRunning in tasks.c.
|
|
*/
|
|
PRIVILEGED_DATA static BaseType_t prvPortSchedulerRunning = pdFALSE;
|
|
|
|
/* -------------------------- Private Function Declarations -------------------------- */
|
|
|
|
/**
|
|
* @brief Determine if the given MPU region settings authorizes the requested
|
|
* access to the given buffer.
|
|
*
|
|
* @ingroup Task Context
|
|
* @ingroup MPU Control
|
|
*
|
|
* @param xTaskMPURegion MPU region settings.
|
|
* @param ulBufferStart Start address of the given buffer.
|
|
* @param ulBufferLength Length of the given buffer.
|
|
* @param ulAccessRequested Access requested.
|
|
*
|
|
* @return pdTRUE if MPU region settings authorizes the requested access to the
|
|
* given buffer, pdFALSE otherwise.
|
|
*/
|
|
PRIVILEGED_FUNCTION static BaseType_t prvMPURegionAuthorizesBuffer( const xMPU_REGION_REGISTERS * xTaskMPURegion,
|
|
const uint32_t ulBufferStart,
|
|
const uint32_t ulBufferLength,
|
|
const uint32_t ulAccessRequested );
|
|
|
|
/**
|
|
* @brief Determine the smallest MPU Region Size Encoding for the given MPU
|
|
* region size.
|
|
*
|
|
* @ingroup MPU Control
|
|
*
|
|
* @param ulActualMPURegionSize MPU region size in bytes.
|
|
*
|
|
* @return The smallest MPU Region Size Encoding for the given MPU region size.
|
|
*/
|
|
PRIVILEGED_FUNCTION static uint32_t prvGetMPURegionSizeEncoding( uint32_t ulActualMPURegionSize );
|
|
|
|
/**
|
|
* @brief Set up MPU.
|
|
*
|
|
* @ingroup MPU Control
|
|
*/
|
|
PRIVILEGED_FUNCTION static void prvSetupMPU( void );
|
|
|
|
/* -------------------------- Exported Function Declarations -------------------------- */
|
|
|
|
/**
|
|
* @brief Enter critical section.
|
|
*
|
|
* @ingroup Critical Section
|
|
*/
|
|
PRIVILEGED_FUNCTION void vPortEnterCritical( void );
|
|
|
|
/**
|
|
* @brief Exit critical section.
|
|
*
|
|
* @ingroup Critical Section
|
|
*/
|
|
PRIVILEGED_FUNCTION void vPortExitCritical( void );
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Setup a FreeRTOS task's initial context.
|
|
*
|
|
* @ingroup Task Context
|
|
*
|
|
* @param pxTopOfStack Top of stack.
|
|
* @param pxCode The task function.
|
|
* @param pvParameters Argument passed to the task function.
|
|
* @param xRunPrivileged Marks if the task is privileged.
|
|
* @param xMPUSettings MPU settings of the task.
|
|
*
|
|
* @return Location where to restore the task's context from.
|
|
*/
|
|
/* PRIVILEGED_FUNCTION */
|
|
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
|
TaskFunction_t pxCode,
|
|
void * pvParameters,
|
|
BaseType_t xRunPrivileged,
|
|
xMPU_SETTINGS * xMPUSettings )
|
|
{
|
|
/* Setup the initial context of the task. The context is set exactly as
|
|
* expected by the portRESTORE_CONTEXT() macro. */
|
|
UBaseType_t ulIndex = CONTEXT_SIZE - 1U;
|
|
|
|
xSYSTEM_CALL_STACK_INFO * xSysCallInfo = NULL;
|
|
|
|
if( xRunPrivileged == pdTRUE )
|
|
{
|
|
xMPUSettings->ulTaskFlags |= portTASK_IS_PRIVILEGED_FLAG;
|
|
/* Current Program Status Register (CPSR). */
|
|
xMPUSettings->ulContext[ ulIndex ] = SYS_MODE;
|
|
}
|
|
else
|
|
{
|
|
xMPUSettings->ulTaskFlags &= ( ~portTASK_IS_PRIVILEGED_FLAG );
|
|
/* Current Program Status Register (CPSR). */
|
|
xMPUSettings->ulContext[ ulIndex ] = USER_MODE;
|
|
}
|
|
|
|
if( ( ( uint32_t ) pxCode & portTHUMB_MODE_ADDRESS ) != 0x0UL )
|
|
{
|
|
/* The task will cause the processor to start in THUMB state, set the
|
|
* Thumb state bit in the CPSR. */
|
|
xMPUSettings->ulContext[ ulIndex ] |= portTHUMB_MODE_BIT;
|
|
}
|
|
|
|
ulIndex--;
|
|
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) pxCode; /* PC. */
|
|
ulIndex--;
|
|
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) portTASK_RETURN_ADDRESS; /* LR. */
|
|
ulIndex--;
|
|
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) pxTopOfStack; /* SP. */
|
|
ulIndex--;
|
|
|
|
/* General Purpose Registers. */
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x12121212; /* R12. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x11111111; /* R11. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x10101010; /* R10. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x09090909; /* R9. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x08080808; /* R8. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x07070707; /* R7. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x06060606; /* R6. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x05050505; /* R5. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x04040404; /* R4. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x03030303; /* R3. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x02020202; /* R2. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x01010101; /* R1. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) pvParameters; /* R0. */
|
|
ulIndex--;
|
|
|
|
#if( portENABLE_FPU == 1 )
|
|
{
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000015; /* S31. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD1500000; /* S30. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000014; /* S29. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD1400000; /* S28. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000013; /* S27. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD1300000; /* S26. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000012; /* S25. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD1200000; /* S24. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000011; /* S23. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD1100000; /* S22. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000010; /* S21. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD1000000; /* S20. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000009; /* S19. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD9000000; /* S18. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000008; /* S17. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD8000000; /* S16. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000007; /* S15. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD7000000; /* S14. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000006; /* S13. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD6000000; /* S12. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000005; /* S11. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD5000000; /* S10. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000004; /* S9. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD4000000; /* S8. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000003; /* S7. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD3000000; /* S6. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000002; /* S5. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD2000000; /* S4. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000001; /* S3. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD1000000; /* S2. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000000; /* S1. */
|
|
ulIndex--;
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0xD0000000; /* S0. */
|
|
ulIndex--;
|
|
|
|
xMPUSettings->ulContext[ ulIndex ] = ( StackType_t ) 0x00000000; /* FPSR. */
|
|
ulIndex--;
|
|
}
|
|
#endif /* portENABLE_FPU */
|
|
|
|
/* The task will start with a critical nesting count of 0. */
|
|
xMPUSettings->ulContext[ ulIndex ] = portNO_CRITICAL_NESTING;
|
|
|
|
/* Ensure that the system call stack is double word aligned. */
|
|
xSysCallInfo = &( xMPUSettings->xSystemCallStackInfo );
|
|
xSysCallInfo->pulSystemCallStackPointer = &( xSysCallInfo->ulSystemCallStackBuffer[ configSYSTEM_CALL_STACK_SIZE - 1U ] );
|
|
xSysCallInfo->pulSystemCallStackPointer = ( uint32_t * ) ( ( ( uint32_t ) ( xSysCallInfo->pulSystemCallStackPointer ) ) &
|
|
( ( uint32_t ) ( ~( portBYTE_ALIGNMENT_MASK ) ) ) );
|
|
|
|
/* This is not NULL only for the duration of a system call. */
|
|
xSysCallInfo->pulTaskStackPointer = NULL;
|
|
|
|
/* Set the System Call to return to vPortSystemCallExit. */
|
|
xSysCallInfo->pulSystemCallExitAddress = ( uint32_t * ) ( &vPortSystemCallExit );
|
|
|
|
/* Return the address where this task's context should be restored from. */
|
|
return &( xMPUSettings->ulContext[ ulIndex ] );
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Store a FreeRTOS task's MPU settings in its TCB.
|
|
*
|
|
* @ingroup Task Context
|
|
* @ingroup MPU Control
|
|
*
|
|
* @param xMPUSettings The MPU settings in TCB.
|
|
* @param xRegions The updated MPU settings requested by the task.
|
|
* @param pxBottomOfStack The base address of the task's Stack.
|
|
* @param ulStackDepth The length of the task's stack.
|
|
*/
|
|
/* PRIVILEGED_FUNCTION */
|
|
void vPortStoreTaskMPUSettings( xMPU_SETTINGS * xMPUSettings,
|
|
const struct xMEMORY_REGION * const xRegions,
|
|
StackType_t * pxBottomOfStack,
|
|
uint32_t ulStackDepth )
|
|
{
|
|
#if defined( __ARMCC_VERSION )
|
|
/* Declaration when these variable are defined in code instead of being
|
|
* exported from linker scripts. */
|
|
extern uint32_t * __SRAM_segment_start__;
|
|
extern uint32_t * __SRAM_segment_end__;
|
|
#else
|
|
/* Declaration when these variable are exported from linker scripts. */
|
|
extern uint32_t __SRAM_segment_start__[];
|
|
extern uint32_t __SRAM_segment_end__[];
|
|
#endif /* if defined( __ARMCC_VERSION ) */
|
|
|
|
uint32_t ulIndex = 0x0;
|
|
uint32_t ulRegionLength;
|
|
uint32_t ulRegionLengthEncoded;
|
|
uint32_t ulRegionLengthDecoded;
|
|
|
|
if( xRegions == NULL )
|
|
{
|
|
/* No MPU regions are specified so allow access to all of the RAM. */
|
|
ulRegionLength = ( uint32_t ) __SRAM_segment_end__ - ( uint32_t ) __SRAM_segment_start__;
|
|
ulRegionLengthEncoded = prvGetMPURegionSizeEncoding( ulRegionLength );
|
|
ulRegionLength |= portMPU_REGION_ENABLE;
|
|
|
|
/* MPU Settings is zero'd out in the TCB before this function is called.
|
|
* We, therefore, do not need to explicitly zero out unused MPU regions
|
|
* in xMPUSettings. */
|
|
ulIndex = portSTACK_REGION;
|
|
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionBaseAddress = ( uint32_t ) __SRAM_segment_start__;
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionSize = ( ulRegionLengthEncoded |
|
|
portMPU_REGION_ENABLE );
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionAttribute = ( portMPU_REGION_PRIV_RW_USER_RW_NOEXEC |
|
|
portMPU_REGION_NORMAL_OIWTNOWA_SHARED );
|
|
}
|
|
else
|
|
{
|
|
for( ulIndex = 0UL; ulIndex < portNUM_CONFIGURABLE_REGIONS; ulIndex++ )
|
|
{
|
|
/* If a length has been provided, the region is in use. */
|
|
if( ( xRegions[ ulIndex ] ).ulLengthInBytes > 0UL )
|
|
{
|
|
ulRegionLength = xRegions[ ulIndex ].ulLengthInBytes;
|
|
ulRegionLengthEncoded = prvGetMPURegionSizeEncoding( ulRegionLength );
|
|
|
|
/* MPU region base address must be aligned to the region size
|
|
* boundary. */
|
|
ulRegionLengthDecoded = 2UL << ( ulRegionLengthEncoded >> 1UL );
|
|
configASSERT( ( ( ( uint32_t ) xRegions[ ulIndex ].pvBaseAddress ) % ( ulRegionLengthDecoded ) ) == 0UL );
|
|
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionBaseAddress = ( uint32_t ) xRegions[ ulIndex ].pvBaseAddress;
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionSize = ( ulRegionLengthEncoded |
|
|
portMPU_REGION_ENABLE );
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionAttribute = xRegions[ ulIndex ].ulParameters;
|
|
}
|
|
else
|
|
{
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionBaseAddress = 0x0UL;
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionSize = 0x0UL;
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionAttribute = 0x0UL;
|
|
}
|
|
}
|
|
|
|
/* This function is called automatically when the task is created - in
|
|
* which case the stack region parameters will be valid. At all other
|
|
* times the stack parameters will not be valid and it is assumed that the
|
|
* stack region has already been configured. */
|
|
if( ulStackDepth != 0x0UL )
|
|
{
|
|
ulRegionLengthEncoded = prvGetMPURegionSizeEncoding( ulStackDepth * ( uint32_t ) sizeof( StackType_t ) );
|
|
|
|
/* MPU region base address must be aligned to the region size
|
|
* boundary. */
|
|
ulRegionLengthDecoded = 2UL << ( ulRegionLengthEncoded >> 1UL );
|
|
configASSERT( ( ( uint32_t ) pxBottomOfStack % ( ulRegionLengthDecoded ) ) == 0U );
|
|
|
|
ulIndex = portSTACK_REGION;
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionBaseAddress = ( uint32_t ) pxBottomOfStack;
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionSize = ( ulRegionLengthEncoded |
|
|
portMPU_REGION_ENABLE );;
|
|
xMPUSettings->xRegion[ ulIndex ].ulRegionAttribute = ( portMPU_REGION_PRIV_RW_USER_RW_NOEXEC |
|
|
portMPU_REGION_NORMAL_OIWTNOWA_SHARED );
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
BaseType_t xPortIsTaskPrivileged( void )
|
|
{
|
|
BaseType_t xTaskIsPrivileged = pdFALSE;
|
|
|
|
/* Calling task's MPU settings. */
|
|
const xMPU_SETTINGS * xTaskMpuSettings = xTaskGetMPUSettings( NULL );
|
|
|
|
if( ( xTaskMpuSettings->ulTaskFlags & portTASK_IS_PRIVILEGED_FLAG ) == portTASK_IS_PRIVILEGED_FLAG )
|
|
{
|
|
xTaskIsPrivileged = pdTRUE;
|
|
}
|
|
|
|
return xTaskIsPrivileged;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
BaseType_t xPortStartScheduler( void )
|
|
{
|
|
/* Start the timer that generates the tick ISR. */
|
|
configSETUP_TICK_INTERRUPT();
|
|
|
|
/* Configure MPU regions that are common to all tasks. */
|
|
prvSetupMPU();
|
|
|
|
prvPortSchedulerRunning = pdTRUE;
|
|
|
|
/* Load the context of the first task. */
|
|
vPortStartFirstTask();
|
|
|
|
/* Will only get here if vTaskStartScheduler() was called with the CPU in
|
|
* a non-privileged mode or the binary point register was not set to its lowest
|
|
* possible value. prvTaskExitError() is referenced to prevent a compiler
|
|
* warning about it being defined but not referenced in the case that the user
|
|
* defines their own exit address. */
|
|
( void ) prvTaskExitError();
|
|
return pdFALSE;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
static uint32_t prvGetMPURegionSizeEncoding( uint32_t ulActualMPURegionSize )
|
|
{
|
|
uint32_t ulRegionSize, ulReturnValue = 4U;
|
|
|
|
/* 32 bytes is the smallest valid region for Cortex R4 and R5 CPUs. */
|
|
for( ulRegionSize = 0x20UL; ulReturnValue < 0x1FUL; ( ulRegionSize <<= 1UL ) )
|
|
{
|
|
if( ulActualMPURegionSize <= ulRegionSize )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ulReturnValue++;
|
|
}
|
|
}
|
|
|
|
/* Shift the code by one before returning so it can be written directly
|
|
* into the the correct bit position of the attribute register. */
|
|
return ulReturnValue << 1UL;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
static void prvSetupMPU( void )
|
|
{
|
|
#if defined( __ARMCC_VERSION )
|
|
/* Declaration when these variable are defined in code. */
|
|
/* Sections used for FLASH. */
|
|
extern uint32_t * __FLASH_segment_start__;
|
|
extern uint32_t * __FLASH_segment_end__;
|
|
extern uint32_t * __privileged_functions_start__;
|
|
extern uint32_t * __privileged_functions_end__;
|
|
|
|
/* Sections used for RAM. */
|
|
extern uint32_t * __SRAM_segment_start__;
|
|
extern uint32_t * __SRAM_segment_end__;
|
|
extern uint32_t * __privileged_data_start__;
|
|
extern uint32_t * __privileged_data_end__;
|
|
#else
|
|
/* Declaration when these variable are exported from linker scripts. */
|
|
/* Sections used for FLASH. */
|
|
extern uint32_t __FLASH_segment_start__[];
|
|
extern uint32_t __FLASH_segment_end__[];
|
|
extern uint32_t __privileged_functions_start__[];
|
|
extern uint32_t __privileged_functions_end__[];
|
|
|
|
/* Sections used for RAM. */
|
|
extern uint32_t __SRAM_segment_start__[];
|
|
extern uint32_t __SRAM_segment_end__[];
|
|
extern uint32_t __privileged_data_start__[];
|
|
extern uint32_t __privileged_data_end__[];
|
|
#endif /* if defined( __ARMCC_VERSION ) */
|
|
|
|
uint32_t ulRegionLength;
|
|
uint32_t ulRegionLengthEncoded;
|
|
|
|
/* Disable the MPU before programming it. */
|
|
vMPUDisable();
|
|
|
|
/* Priv: RX, Unpriv: RX for entire Flash. */
|
|
ulRegionLength = ( uint32_t ) __FLASH_segment_end__ - ( uint32_t ) __FLASH_segment_start__;
|
|
ulRegionLengthEncoded = prvGetMPURegionSizeEncoding( ulRegionLength );
|
|
vMPUSetRegion( portUNPRIVILEGED_FLASH_REGION,
|
|
( uint32_t ) __FLASH_segment_start__,
|
|
( ulRegionLengthEncoded | portMPU_REGION_ENABLE ),
|
|
( portMPU_REGION_PRIV_RO_USER_RO_EXEC |
|
|
portMPU_REGION_NORMAL_OIWTNOWA_SHARED ) );
|
|
|
|
/* Priv: RX, Unpriv: No access for privileged functions. */
|
|
ulRegionLength = ( uint32_t ) __privileged_functions_end__ - ( uint32_t ) __privileged_functions_start__;
|
|
ulRegionLengthEncoded = prvGetMPURegionSizeEncoding( ulRegionLength );
|
|
vMPUSetRegion( portPRIVILEGED_FLASH_REGION,
|
|
( uint32_t ) __privileged_functions_start__,
|
|
( ulRegionLengthEncoded | portMPU_REGION_ENABLE ),
|
|
( portMPU_REGION_PRIV_RO_USER_NA_EXEC |
|
|
portMPU_REGION_NORMAL_OIWTNOWA_SHARED ) );
|
|
|
|
/* Priv: RW, Unpriv: No Access for privileged data. */
|
|
ulRegionLength = ( uint32_t ) __privileged_data_end__ - ( uint32_t ) __privileged_data_start__;
|
|
ulRegionLengthEncoded = prvGetMPURegionSizeEncoding( ulRegionLength );
|
|
vMPUSetRegion( portPRIVILEGED_RAM_REGION,
|
|
( uint32_t ) __privileged_data_start__,
|
|
( ulRegionLengthEncoded | portMPU_REGION_ENABLE ),
|
|
( portMPU_REGION_PRIV_RW_USER_NA_NOEXEC |
|
|
portMPU_REGION_PRIV_RW_USER_NA_NOEXEC ) );
|
|
|
|
/* Enable the MPU background region - it allows privileged operating modes
|
|
* access to unmapped regions of memory without generating a fault. */
|
|
vMPUEnableBackgroundRegion();
|
|
|
|
/* After setting default regions, enable the MPU. */
|
|
vMPUEnable();
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
static BaseType_t prvMPURegionAuthorizesBuffer( const xMPU_REGION_REGISTERS * xTaskMPURegion,
|
|
const uint32_t ulBufferStart,
|
|
const uint32_t ulBufferLength,
|
|
const uint32_t ulAccessRequested )
|
|
{
|
|
BaseType_t xAccessGranted = pdFALSE;
|
|
uint32_t ulBufferEnd;
|
|
uint32_t ulMPURegionLength;
|
|
uint32_t ulMPURegionStart;
|
|
uint32_t ulMPURegionEnd;
|
|
uint32_t ulMPURegionAccessPermissions;
|
|
|
|
if( portADD_UINT32_WILL_OVERFLOW( ulBufferStart, ( ulBufferLength - 1UL ) ) == pdFALSE )
|
|
{
|
|
ulBufferEnd = ulBufferStart + ulBufferLength - 1UL;
|
|
ulMPURegionLength = 2UL << ( xTaskMPURegion->ulRegionSize >> 1UL );
|
|
ulMPURegionStart = xTaskMPURegion->ulRegionBaseAddress;
|
|
ulMPURegionEnd = xTaskMPURegion->ulRegionBaseAddress + ulMPURegionLength - 1UL;
|
|
|
|
if( ( ulBufferStart >= ulMPURegionStart ) &&
|
|
( ulBufferEnd <= ulMPURegionEnd ) &&
|
|
( ulBufferStart <= ulBufferEnd ) )
|
|
{
|
|
ulMPURegionAccessPermissions = xTaskMPURegion->ulRegionAttribute & portMPU_REGION_AP_BITMASK;
|
|
|
|
if( ulAccessRequested == tskMPU_READ_PERMISSION ) /* RO. */
|
|
{
|
|
if( ( ulMPURegionAccessPermissions == portMPU_REGION_PRIV_RW_USER_RO ) ||
|
|
( ulMPURegionAccessPermissions == portMPU_REGION_PRIV_RO_USER_RO ) ||
|
|
( ulMPURegionAccessPermissions == portMPU_REGION_PRIV_RW_USER_RW ) )
|
|
|
|
{
|
|
xAccessGranted = pdTRUE;
|
|
}
|
|
}
|
|
else if( ( ulAccessRequested & tskMPU_WRITE_PERMISSION ) != 0UL ) /* W or RW. */
|
|
{
|
|
if( ulMPURegionAccessPermissions == portMPU_REGION_PRIV_RW_USER_RW )
|
|
{
|
|
xAccessGranted = pdTRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return xAccessGranted;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
BaseType_t xPortIsAuthorizedToAccessBuffer( const void * pvBuffer,
|
|
uint32_t ulBufferLength,
|
|
uint32_t ulAccessRequested )
|
|
{
|
|
BaseType_t xAccessGranted = pdFALSE;
|
|
uint32_t ulRegionIndex;
|
|
xMPU_SETTINGS * xTaskMPUSettings = NULL;
|
|
|
|
if( prvPortSchedulerRunning == pdFALSE )
|
|
{
|
|
/* Grant access to all the memory before the scheduler is started. It is
|
|
* necessary because there is no task running yet and therefore, we
|
|
* cannot use the permissions of any task. */
|
|
xAccessGranted = pdTRUE;
|
|
}
|
|
else
|
|
{
|
|
/* Calling task's MPU settings. */
|
|
xTaskMPUSettings = xTaskGetMPUSettings( NULL );
|
|
|
|
if( ( xTaskMPUSettings->ulTaskFlags & portTASK_IS_PRIVILEGED_FLAG ) == portTASK_IS_PRIVILEGED_FLAG )
|
|
{
|
|
/* Privileged tasks have access to all the memory. */
|
|
xAccessGranted = pdTRUE;
|
|
}
|
|
else
|
|
{
|
|
for( ulRegionIndex = 0x0UL; ulRegionIndex < portTOTAL_NUM_REGIONS_IN_TCB; ulRegionIndex++ )
|
|
{
|
|
xAccessGranted = prvMPURegionAuthorizesBuffer( &( xTaskMPUSettings->xRegion[ ulRegionIndex ] ),
|
|
( uint32_t ) pvBuffer,
|
|
ulBufferLength,
|
|
ulAccessRequested );
|
|
|
|
if( xAccessGranted == pdTRUE )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return xAccessGranted;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
#if( configENABLE_ACCESS_CONTROL_LIST == 1 )
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
BaseType_t xPortIsAuthorizedToAccessKernelObject( int32_t lInternalIndexOfKernelObject )
|
|
{
|
|
uint32_t ulAccessControlListEntryIndex, ulAccessControlListEntryBit;
|
|
BaseType_t xAccessGranted = pdFALSE;
|
|
const xMPU_SETTINGS * xTaskMpuSettings;
|
|
|
|
if( prvPortSchedulerRunning == pdFALSE )
|
|
{
|
|
/* Grant access to all the kernel objects before the scheduler
|
|
* is started. It is necessary because there is no task running
|
|
* yet and therefore, we cannot use the permissions of any
|
|
* task. */
|
|
xAccessGranted = pdTRUE;
|
|
}
|
|
else
|
|
{
|
|
/* Calling task's MPU settings. */
|
|
xTaskMpuSettings = xTaskGetMPUSettings( NULL );
|
|
|
|
ulAccessControlListEntryIndex = ( ( uint32_t ) lInternalIndexOfKernelObject
|
|
/ portACL_ENTRY_SIZE_BITS );
|
|
ulAccessControlListEntryBit = ( ( uint32_t ) lInternalIndexOfKernelObject
|
|
% portACL_ENTRY_SIZE_BITS );
|
|
|
|
if( ( xTaskMpuSettings->ulTaskFlags & portTASK_IS_PRIVILEGED_FLAG ) == portTASK_IS_PRIVILEGED_FLAG )
|
|
{
|
|
xAccessGranted = pdTRUE;
|
|
}
|
|
else
|
|
{
|
|
if( ( ( xTaskMpuSettings->ulAccessControlList[ ulAccessControlListEntryIndex ] ) &
|
|
( 1U << ulAccessControlListEntryBit ) ) != 0UL )
|
|
{
|
|
xAccessGranted = pdTRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return xAccessGranted;
|
|
}
|
|
|
|
#else
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
BaseType_t xPortIsAuthorizedToAccessKernelObject( int32_t lInternalIndexOfKernelObject )
|
|
{
|
|
( void ) lInternalIndexOfKernelObject;
|
|
|
|
/* If Access Control List feature is not used, all the tasks have
|
|
* access to all the kernel objects. */
|
|
return pdTRUE;
|
|
}
|
|
|
|
#endif /* #if ( configENABLE_ACCESS_CONTROL_LIST == 1 ) */
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
#if( configENABLE_ACCESS_CONTROL_LIST == 1 )
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
void vPortGrantAccessToKernelObject( TaskHandle_t xInternalTaskHandle,
|
|
int32_t lInternalIndexOfKernelObject )
|
|
{
|
|
uint32_t ulAccessControlListEntryIndex, ulAccessControlListEntryBit;
|
|
xMPU_SETTINGS * xTaskMpuSettings;
|
|
|
|
ulAccessControlListEntryIndex = ( ( uint32_t ) lInternalIndexOfKernelObject
|
|
/ portACL_ENTRY_SIZE_BITS );
|
|
ulAccessControlListEntryBit = ( ( uint32_t ) lInternalIndexOfKernelObject
|
|
% portACL_ENTRY_SIZE_BITS );
|
|
|
|
xTaskMpuSettings = xTaskGetMPUSettings( xInternalTaskHandle );
|
|
|
|
xTaskMpuSettings->ulAccessControlList[ ulAccessControlListEntryIndex ] |= ( 1U << ulAccessControlListEntryBit );
|
|
}
|
|
|
|
#endif /* #if ( configENABLE_ACCESS_CONTROL_LIST == 1 ) */
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
#if( configENABLE_ACCESS_CONTROL_LIST == 1 )
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
void vPortRevokeAccessToKernelObject( TaskHandle_t xInternalTaskHandle,
|
|
int32_t lInternalIndexOfKernelObject )
|
|
{
|
|
uint32_t ulAccessControlListEntryIndex, ulAccessControlListEntryBit;
|
|
xMPU_SETTINGS * xTaskMpuSettings;
|
|
|
|
ulAccessControlListEntryIndex = ( ( uint32_t ) lInternalIndexOfKernelObject
|
|
/ portACL_ENTRY_SIZE_BITS );
|
|
ulAccessControlListEntryBit = ( ( uint32_t ) lInternalIndexOfKernelObject
|
|
% portACL_ENTRY_SIZE_BITS );
|
|
|
|
xTaskMpuSettings = xTaskGetMPUSettings( xInternalTaskHandle );
|
|
|
|
xTaskMpuSettings->ulAccessControlList[ ulAccessControlListEntryIndex ] &= ~( 1U << ulAccessControlListEntryBit );
|
|
}
|
|
|
|
#endif /* #if ( configENABLE_ACCESS_CONTROL_LIST == 1 ) */
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
void prvTaskExitError( void )
|
|
{
|
|
/* A function that implements a task must not exit or attempt to return to
|
|
* its caller as there is nothing to return to. If a task wants to exit it
|
|
* should instead call vTaskDelete( NULL ).
|
|
*
|
|
* Artificially force an assert() to be triggered if configASSERT() is
|
|
* defined, then stop here so application writers can catch the error. */
|
|
configASSERT( ulPortInterruptNesting == ~0UL );
|
|
|
|
for( ;; )
|
|
{
|
|
}
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
void vPortEndScheduler( void )
|
|
{
|
|
prvPortSchedulerRunning = pdFALSE;
|
|
|
|
/* Not implemented in this port. Artificially force an assert. */
|
|
configASSERT( prvPortSchedulerRunning == pdTRUE );
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
void vPortEnterCritical( void )
|
|
{
|
|
portDISABLE_INTERRUPTS();
|
|
|
|
/* Now that interrupts are disabled, ulCriticalNesting can be accessed
|
|
* directly. Increment ulCriticalNesting to keep a count of how many times
|
|
* portENTER_CRITICAL() has been called. */
|
|
ulCriticalNesting++;
|
|
|
|
/* This is not the interrupt safe version of the enter critical function so
|
|
* assert() if it is being called from an interrupt context. Only API
|
|
* functions that end in "FromISR" can be used in an interrupt. Only assert
|
|
* if the critical nesting count is 1 to protect against recursive calls if
|
|
* the assert function also uses a critical section. */
|
|
if( ulCriticalNesting == 1 )
|
|
{
|
|
configASSERT( ulPortInterruptNesting == 0 );
|
|
}
|
|
}
|
|
/* ----------------------------------------------------------------------------------- */
|
|
|
|
/* PRIVILEGED_FUNCTION */
|
|
void vPortExitCritical( void )
|
|
{
|
|
if( ulCriticalNesting > portNO_CRITICAL_NESTING )
|
|
{
|
|
/* Decrement the nesting count as the critical section is being
|
|
* exited. */
|
|
ulCriticalNesting--;
|
|
|
|
/* If the nesting level has reached zero then all interrupt
|
|
* priorities must be re-enabled. */
|
|
if( ulCriticalNesting == portNO_CRITICAL_NESTING )
|
|
{
|
|
/* Critical nesting has reached zero so all interrupt priorities
|
|
* should be unmasked. */
|
|
portENABLE_INTERRUPTS();
|
|
}
|
|
}
|
|
}
|
|
/* ----------------------------------------------------------------------------------- */
|