| /*
|
| * Copyright (c) 2016-2018 ARM Limited
|
| *
|
| * Licensed under the Apache License, Version 2.0 (the "License");
|
| * you may not use this file except in compliance with the License.
|
| * You may obtain a copy of the License at
|
| *
|
| * http://www.apache.org/licenses/LICENSE-2.0
|
| *
|
| * Unless required by applicable law or agreed to in writing, software
|
| * distributed under the License is distributed on an "AS IS" BASIS,
|
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
| * See the License for the specific language governing permissions and
|
| * limitations under the License.
|
| */
|
| #ifndef __DRIVER_MPC_H
|
| #define __DRIVER_MPC_H
|
|
|
| #include "Driver_Common.h"
|
|
|
| /* API version */
|
| #define ARM_MPC_API_VERSION ARM_DRIVER_VERSION_MAJOR_MINOR(1,0)
|
|
|
| /* Error code returned by the driver functions */
|
| #define ARM_MPC_ERR_NOT_INIT (ARM_DRIVER_ERROR_SPECIFIC - 1) ///< MPC not initialized */
|
| #define ARM_MPC_ERR_NOT_IN_RANGE (ARM_DRIVER_ERROR_SPECIFIC - 2) ///< Address does not belong to a range controlled by the MPC */
|
| #define ARM_MPC_ERR_NOT_ALIGNED (ARM_DRIVER_ERROR_SPECIFIC - 3) ///< Address is not aligned on the block size of this MPC */
|
| #define ARM_MPC_ERR_INVALID_RANGE (ARM_DRIVER_ERROR_SPECIFIC - 4) ///< The given address range to configure is invalid
|
| #define ARM_MPC_ERR_RANGE_SEC_ATTR_NON_COMPATIBLE (ARM_DRIVER_ERROR_SPECIFIC - 4) ///< The given range cannot be accessed with the wanted security attributes */
|
| #define ARM_MPC_ERR_UNSPECIFIED (ARM_DRIVER_ERROR_SPECIFIC - 5) ///< Unspecified error */
|
|
|
| /* Security attribute used in various place of the API */
|
| typedef enum _ARM_MPC_SEC_ATTR {
|
| ARM_MPC_ATTR_SECURE, ///< Secure attribute
|
| ARM_MPC_ATTR_NONSECURE, ///< Non-secure attribute
|
| /* Used when getting the configuration of a memory range and some blocks are
|
| * secure whereas some other are non secure */
|
| ARM_MPC_ATTR_MIXED, ///< Mixed attribute
|
| } ARM_MPC_SEC_ATTR;
|
|
|
| /* Function documentation */
|
| /**
|
| \fn ARM_DRIVER_VERSION ARM_MPC_GetVersion (void)
|
| \brief Get driver version.
|
| \return \ref ARM_DRIVER_VERSION
|
|
|
| \fn int32_t ARM_MPC_Initialize (void)
|
| \brief Initialize MPC Interface.
|
| \return Returns error code.
|
|
|
| \fn int32_t ARM_MPC_Uninitialize (void)
|
| \brief De-initialize MPC Interface. The controlled memory region
|
| should not be accessed after a call to this function, as
|
| it is allowed to configure everything to be secure (to
|
| prevent information leak for example).
|
| \return Returns error code.
|
|
|
| \fn int32_t ARM_MPC_GetBlockSize (uint32_t* blk_size)
|
| \brief Get the block size of the MPC. All regions must be aligned
|
| on this block size (base address and limit+1 address).
|
| \param[out] blk_size: The block size in bytes.
|
| \return Returns error code.
|
|
|
| \fn int32_t ARM_MPC_GetCtrlConfig (uint32_t* ctrl_val)
|
| \brief Get some information on how the MPC IP is configured.
|
| \param[out] ctrl_val: MPC control configuration
|
| \return Returns error code.
|
|
|
| \fn int32_t ARM_MPC_SetCtrlConfig (uint32_t ctrl)
|
| \brief Set new control configuration for the MPC IP.
|
| \param[in] ctrl: New control configuration.
|
| \return Returns error code.
|
|
|
| \fn int32_t ARM_MPC_ConfigRegion (uintptr_t base,
|
| uintptr_t limit,
|
| ARM_MPC_SEC_ATTR attr)
|
| \brief Configure a memory region (base and limit included).
|
| Both base and limit addresses must belong to the same
|
| memory range, and this range must be managed by this MPC.
|
| Also, some ranges are only allowed to be configured as
|
| secure/non-secure, because of hardware requirements
|
| (security aliases), and only a relevant security attribute
|
| is therefore allowed for such ranges.
|
| \param[in] base: Base address of the region to configure. This
|
| bound is included in the configured region.
|
| This must be aligned on the block size of this MPC.
|
| \param[in] limit: Limit address of the region to configure. This
|
| bound is included in the configured region.
|
| Limit+1 must be aligned on the block size of this MPC.
|
| \param[in] attr: Wanted security attribute of the region.
|
| \return Returns error code.
|
|
|
| \fn int32_t ARM_MPC_GetRegionConfig (uintptr_t base,
|
| uintptr_t limit,
|
| ARM_MPC_SEC_ATTR *attr)
|
| \brief Gets a memory region (base and limit included).
|
| \param[in] base: Base address of the region to poll. This
|
| bound is included. It does not need to be aligned
|
| in any way.
|
| \param[in] limit: Limit address of the region to poll. This
|
| bound is included. (limit+1) does not need to be aligned
|
| in any way.
|
| \param[out] attr: Security attribute of the region.
|
| If the region has mixed secure/non-secure,
|
| a special value is returned (\ref ARM_MPC_SEC_ATTR).
|
|
|
| In case base and limit+1 addresses are not aligned on
|
| the block size, the enclosing region with base and
|
| limit+1 aligned on block size will be queried.
|
| In case of early termination of the function (error), the
|
| security attribute will be set to ARM_MPC_ATTR_MIXED.
|
| \return Returns error code.
|
| |
| \fn int32_t ARM_MPC_EnableInterrupt (void) |
| \brief Enable MPC interrupt. |
| \return Returns error code. |
| |
| \fn void ARM_MPC_DisableInterrupt (void) |
| \brief Disable MPC interrupt. |
| |
| \fn void ARM_MPC_ClearInterrupt (void) |
| \brief Clear MPC interrupt. |
| |
| \fn uint32_t ARM_MPC_InterruptState (void) |
| \brief MPC interrupt state. |
| \return Returns 1 if the interrupt is active, 0 otherwise. |
| |
| \fn int32_t ARM_MPC_LockDown (void) |
| \brief Lock down the MPC configuration. |
| \return Returns error code. |
| */
|
|
|
| /**
|
| * \brief Access structure of the MPC Driver.
|
| */
|
| typedef struct _ARM_DRIVER_MPC {
|
| ARM_DRIVER_VERSION (*GetVersion) (void); ///< Pointer to \ref ARM_MPC_GetVersion : Get driver version. |
| int32_t (*Initialize) (void); ///< Pointer to \ref ARM_MPC_Initialize : Initialize the MPC Interface. |
| int32_t (*Uninitialize) (void); ///< Pointer to \ref ARM_MPC_Uninitialize : De-initialize the MPC Interface. |
| int32_t (*GetBlockSize) (uint32_t* blk_size); ///< Pointer to \ref ARM_MPC_GetBlockSize : Get MPC block size |
| int32_t (*GetCtrlConfig) (uint32_t* ctrl_val); ///< Pointer to \ref ARM_MPC_GetCtrlConfig : Get the MPC control configuration flags. |
| int32_t (*SetCtrlConfig) (uint32_t ctrl); ///< Pointer to \ref ARM_MPC_SetCtrlConfig : Set the MPC control configuration flags. |
| int32_t (*ConfigRegion) (uintptr_t base, uintptr_t limit, ARM_MPC_SEC_ATTR attr); ///< Pointer to \ref ARM_MPC_ConfigRegion : Configure a region using the driver for the specific MPC. |
| int32_t (*GetRegionConfig) (uintptr_t base, uintptr_t limit, ARM_MPC_SEC_ATTR *attr); ///< Pointer to \ref ARM_MPC_GetRegionConfig : Get the configuration of a specific region on this MPC. |
| int32_t (*EnableInterrupt) (void); ///< Pointer to \ref ARM_MPC_EnableInterrupt : Enable MPC interrupt. |
| void (*DisableInterrupt) (void); ///< Pointer to \ref ARM_MPC_DisableInterrupt : Disable MPC interrupt. |
| void (*ClearInterrupt) (void); ///< Pointer to \ref ARM_MPC_ClearInterrupt : Clear MPC interrupt. |
| uint32_t (*InterruptState) (void); ///< Pointer to \ref ARM_MPC_InterruptState : MPC interrupt State. |
| int32_t (*LockDown) (void); ///< Pointer to \ref ARM_MPC_LockDown : Lock down the MPC configuration. |
| } const ARM_DRIVER_MPC;
|
|
|
| #endif /* __DRIVER_MPC_H */
|
|
|