From eace8f82713d5d4292a5723a959a3ef3dd3a33c1 Mon Sep 17 00:00:00 2001 From: Teo Hall Date: Wed, 3 May 2017 17:07:39 -0500 Subject: add RM scu svc and partition secure MU add rm svc api and set aside separate MU for secure api calls into SCU Signed-off-by: Teo Hall --- plat/freescale/common/include/sci/sci.h | 16 +- plat/freescale/common/sci/sci_api.mk | 3 +- plat/freescale/common/sci/svc/rm/rm_rpc_clnt.c | 521 +++++++++++++++++++++++++ plat/freescale/common/sci/svc/rm/rpc.h | 77 ++++ plat/freescale/imx8qm/imx8qm_bl31_setup.c | 46 +++ plat/freescale/imx8qm/include/sec_rsrc.h | 14 + 6 files changed, 662 insertions(+), 15 deletions(-) create mode 100644 plat/freescale/common/sci/svc/rm/rm_rpc_clnt.c create mode 100644 plat/freescale/common/sci/svc/rm/rpc.h create mode 100644 plat/freescale/imx8qm/include/sec_rsrc.h diff --git a/plat/freescale/common/include/sci/sci.h b/plat/freescale/common/include/sci/sci.h index 29f05697..ca6f0265 100644 --- a/plat/freescale/common/include/sci/sci.h +++ b/plat/freescale/common/include/sci/sci.h @@ -37,14 +37,9 @@ #include #include -//#include -//#include -//#include #include #include -//#include -//#include -//#include +#include #ifdef PLAT_IMX8QM #define MU_BASE_ADDR(id) ((0x5D1B0000UL + (id*0x10000))) @@ -58,13 +53,6 @@ #define SC_IPC_AP_CH3 (MU_BASE_ADDR(3)) #define SC_IPC_AP_CH4 (MU_BASE_ADDR(4)) -#define SC_IPC_CH SC_IPC_AP_CH0 - -/* Types */ - -/* Functions */ +#define SC_IPC_CH SC_IPC_AP_CH1 #endif /* _SC_SCI_H */ - -/**@}*/ - diff --git a/plat/freescale/common/sci/sci_api.mk b/plat/freescale/common/sci/sci_api.mk index 4a103da8..5a05adb1 100755 --- a/plat/freescale/common/sci/sci_api.mk +++ b/plat/freescale/common/sci/sci_api.mk @@ -30,4 +30,5 @@ BL31_SOURCES += plat/freescale/common/sci/ipc.c \ plat/freescale/common/sci/mx8_mu.c \ plat/freescale/common/sci/svc/pad/pad_rpc_clnt.c \ - plat/freescale/common/sci/svc/pm/pm_rpc_clnt.c + plat/freescale/common/sci/svc/pm/pm_rpc_clnt.c \ + plat/freescale/common/sci/svc/rm/rm_rpc_clnt.c diff --git a/plat/freescale/common/sci/svc/rm/rm_rpc_clnt.c b/plat/freescale/common/sci/svc/rm/rm_rpc_clnt.c new file mode 100644 index 00000000..a7e7e188 --- /dev/null +++ b/plat/freescale/common/sci/svc/rm/rm_rpc_clnt.c @@ -0,0 +1,521 @@ +/* + * Copyright 2017 NXP + * + */ + +/*! + * File containing client-side RPC functions for the RM service. These + * function are ported to clients that communicate to the SC. + * + * @addtogroup RM_SVC + * @{ + */ + +/* Includes */ + +#include +#include +#include +#include +#include "rpc.h" + +/* Local Defines */ + +/* Local Types */ + +/* Local Functions */ + +sc_err_t sc_rm_partition_alloc(sc_ipc_t ipc, sc_rm_pt_t *pt, bool secure, + bool isolated, bool restricted, + bool confidential, bool coherent) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_PARTITION_ALLOC; + RPC_D8(&msg, 0) = secure; + RPC_D8(&msg, 1) = isolated; + RPC_D8(&msg, 2) = restricted; + RPC_D8(&msg, 3) = confidential; + RPC_D8(&msg, 4) = coherent; + RPC_SIZE(&msg) = 3; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + if (pt != NULL) + *pt = RPC_D8(&msg, 0); + return (sc_err_t)result; +} + +sc_err_t sc_rm_partition_free(sc_ipc_t ipc, sc_rm_pt_t pt) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_PARTITION_FREE; + RPC_D8(&msg, 0) = pt; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_rm_did_t sc_rm_get_did(sc_ipc_t ipc) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_GET_DID; + RPC_SIZE(&msg) = 1; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_rm_did_t) result; +} + +sc_err_t sc_rm_partition_static(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_did_t did) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_PARTITION_STATIC; + RPC_D8(&msg, 0) = pt; + RPC_D8(&msg, 1) = did; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_partition_lock(sc_ipc_t ipc, sc_rm_pt_t pt) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_PARTITION_LOCK; + RPC_D8(&msg, 0) = pt; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_get_partition(sc_ipc_t ipc, sc_rm_pt_t *pt) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_GET_PARTITION; + RPC_SIZE(&msg) = 1; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + if (pt != NULL) + *pt = RPC_D8(&msg, 0); + return (sc_err_t)result; +} + +sc_err_t sc_rm_set_parent(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_pt_t pt_parent) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_SET_PARENT; + RPC_D8(&msg, 0) = pt; + RPC_D8(&msg, 1) = pt_parent; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_move_all(sc_ipc_t ipc, sc_rm_pt_t pt_src, sc_rm_pt_t pt_dst, + bool move_rsrc, bool move_pins) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_MOVE_ALL; + RPC_D8(&msg, 0) = pt_src; + RPC_D8(&msg, 1) = pt_dst; + RPC_D8(&msg, 2) = move_rsrc; + RPC_D8(&msg, 3) = move_pins; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_assign_resource(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rsrc_t resource) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_ASSIGN_RESOURCE; + RPC_D16(&msg, 0) = resource; + RPC_D8(&msg, 2) = pt; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_set_resource_movable(sc_ipc_t ipc, sc_rsrc_t resource_fst, + sc_rsrc_t resource_lst, bool movable) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_SET_RESOURCE_MOVABLE; + RPC_D16(&msg, 0) = resource_fst; + RPC_D16(&msg, 2) = resource_lst; + RPC_D8(&msg, 4) = movable; + RPC_SIZE(&msg) = 3; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_set_master_attributes(sc_ipc_t ipc, sc_rsrc_t resource, + sc_rm_spa_t sa, sc_rm_spa_t pa, + bool smmu_bypass) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_SET_MASTER_ATTRIBUTES; + RPC_D16(&msg, 0) = resource; + RPC_D8(&msg, 2) = sa; + RPC_D8(&msg, 3) = pa; + RPC_D8(&msg, 4) = smmu_bypass; + RPC_SIZE(&msg) = 3; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_set_master_sid(sc_ipc_t ipc, sc_rsrc_t resource, sc_rm_sid_t sid) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_SET_MASTER_SID; + RPC_D16(&msg, 0) = resource; + RPC_D16(&msg, 2) = sid; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_set_peripheral_permissions(sc_ipc_t ipc, sc_rsrc_t resource, + sc_rm_pt_t pt, sc_rm_perm_t perm) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_SET_PERIPHERAL_PERMISSIONS; + RPC_D16(&msg, 0) = resource; + RPC_D8(&msg, 2) = pt; + RPC_D8(&msg, 3) = perm; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +bool sc_rm_is_resource_owned(sc_ipc_t ipc, sc_rsrc_t resource) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_OWNED; + RPC_D16(&msg, 0) = resource; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (bool)result; +} + +bool sc_rm_is_resource_master(sc_ipc_t ipc, sc_rsrc_t resource) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_MASTER; + RPC_D16(&msg, 0) = resource; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (bool)result; +} + +bool sc_rm_is_resource_peripheral(sc_ipc_t ipc, sc_rsrc_t resource) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_PERIPHERAL; + RPC_D16(&msg, 0) = resource; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (bool)result; +} + +sc_err_t sc_rm_get_resource_info(sc_ipc_t ipc, sc_rsrc_t resource, + sc_rm_sid_t *sid) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_GET_RESOURCE_INFO; + RPC_D16(&msg, 0) = resource; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + if (sid != NULL) + *sid = RPC_D16(&msg, 0); + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_memreg_alloc(sc_ipc_t ipc, sc_rm_mr_t *mr, + sc_faddr_t addr_start, sc_faddr_t addr_end) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_MEMREG_ALLOC; + RPC_D32(&msg, 0) = addr_start >> 32; + RPC_D32(&msg, 4) = addr_start; + RPC_D32(&msg, 8) = addr_end >> 32; + RPC_D32(&msg, 12) = addr_end; + RPC_SIZE(&msg) = 5; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + if (mr != NULL) + *mr = RPC_D8(&msg, 0); + return (sc_err_t)result; +} + +sc_err_t sc_rm_memreg_free(sc_ipc_t ipc, sc_rm_mr_t mr) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_MEMREG_FREE; + RPC_D8(&msg, 0) = mr; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_assign_memreg(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_mr_t mr) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_ASSIGN_MEMREG; + RPC_D8(&msg, 0) = pt; + RPC_D8(&msg, 1) = mr; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_set_memreg_permissions(sc_ipc_t ipc, sc_rm_mr_t mr, + sc_rm_pt_t pt, sc_rm_perm_t perm) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_SET_MEMREG_PERMISSIONS; + RPC_D8(&msg, 0) = mr; + RPC_D8(&msg, 1) = pt; + RPC_D8(&msg, 2) = perm; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +bool sc_rm_is_memreg_owned(sc_ipc_t ipc, sc_rm_mr_t mr) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_IS_MEMREG_OWNED; + RPC_D8(&msg, 0) = mr; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (bool)result; +} + +sc_err_t sc_rm_get_memreg_info(sc_ipc_t ipc, sc_rm_mr_t mr, + sc_faddr_t *addr_start, sc_faddr_t *addr_end) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_GET_MEMREG_INFO; + RPC_D8(&msg, 0) = mr; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + if (addr_start != NULL) + *addr_start = + ((uint64_t) RPC_D32(&msg, 0) << 32) | RPC_D32(&msg, 4); + if (addr_end != NULL) + *addr_end = + ((uint64_t) RPC_D32(&msg, 8) << 32) | RPC_D32(&msg, 12); + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_assign_pin(sc_ipc_t ipc, sc_rm_pt_t pt, sc_pin_t pin) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_ASSIGN_PIN; + RPC_D16(&msg, 0) = pin; + RPC_D8(&msg, 2) = pt; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +sc_err_t sc_rm_set_pin_movable(sc_ipc_t ipc, sc_pin_t pin_fst, + sc_pin_t pin_lst, bool movable) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_SET_PIN_MOVABLE; + RPC_D16(&msg, 0) = pin_fst; + RPC_D16(&msg, 2) = pin_lst; + RPC_D8(&msg, 4) = movable; + RPC_SIZE(&msg) = 3; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (sc_err_t)result; +} + +bool sc_rm_is_pin_owned(sc_ipc_t ipc, sc_pin_t pin) +{ + sc_rpc_msg_t msg; + uint8_t result; + + RPC_VER(&msg) = SC_RPC_VERSION; + RPC_SVC(&msg) = SC_RPC_SVC_RM; + RPC_FUNC(&msg) = RM_FUNC_IS_PIN_OWNED; + RPC_D8(&msg, 0) = pin; + RPC_SIZE(&msg) = 2; + + sc_call_rpc(ipc, &msg, false); + + result = RPC_R8(&msg); + return (bool)result; +} + +/**@}*/ diff --git a/plat/freescale/common/sci/svc/rm/rpc.h b/plat/freescale/common/sci/svc/rm/rpc.h new file mode 100644 index 00000000..25e60243 --- /dev/null +++ b/plat/freescale/common/sci/svc/rm/rpc.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2016 Freescale Semiconductor, Inc. + * Copyright 2017 NXP + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +/*! + * Header file for the RM RPC implementation. + * + * @addtogroup RM_SVC + * @{ + */ + +#ifndef _SC_RM_RPC_H +#define _SC_RM_RPC_H + +/* Includes */ + +/* Defines */ + +/* Types */ + +/*! + * This type is used to indicate RPC RM function calls. + */ +typedef enum rm_func_e { + RM_FUNC_UNKNOWN = 0, /* Unknown function */ + RM_FUNC_PARTITION_ALLOC = 1, /* Index for rm_partition_alloc() RPC call */ + RM_FUNC_PARTITION_FREE = 2, /* Index for rm_partition_free() RPC call */ + RM_FUNC_GET_DID = 26, /* Index for rm_get_did() RPC call */ + RM_FUNC_PARTITION_STATIC = 3, /* Index for rm_partition_static() RPC call */ + RM_FUNC_PARTITION_LOCK = 4, /* Index for rm_partition_lock() RPC call */ + RM_FUNC_GET_PARTITION = 5, /* Index for rm_get_partition() RPC call */ + RM_FUNC_SET_PARENT = 6, /* Index for rm_set_parent() RPC call */ + RM_FUNC_MOVE_ALL = 7, /* Index for rm_move_all() RPC call */ + RM_FUNC_ASSIGN_RESOURCE = 8, /* Index for rm_assign_resource() RPC call */ + RM_FUNC_SET_RESOURCE_MOVABLE = 9, /* Index for rm_set_resource_movable() RPC call */ + RM_FUNC_SET_MASTER_ATTRIBUTES = 10, /* Index for rm_set_master_attributes() RPC call */ + RM_FUNC_SET_MASTER_SID = 11, /* Index for rm_set_master_sid() RPC call */ + RM_FUNC_SET_PERIPHERAL_PERMISSIONS = 12, /* Index for rm_set_peripheral_permissions() RPC call */ + RM_FUNC_IS_RESOURCE_OWNED = 13, /* Index for rm_is_resource_owned() RPC call */ + RM_FUNC_IS_RESOURCE_MASTER = 14, /* Index for rm_is_resource_master() RPC call */ + RM_FUNC_IS_RESOURCE_PERIPHERAL = 15, /* Index for rm_is_resource_peripheral() RPC call */ + RM_FUNC_GET_RESOURCE_INFO = 16, /* Index for rm_get_resource_info() RPC call */ + RM_FUNC_MEMREG_ALLOC = 17, /* Index for rm_memreg_alloc() RPC call */ + RM_FUNC_MEMREG_FREE = 18, /* Index for rm_memreg_free() RPC call */ + RM_FUNC_ASSIGN_MEMREG = 19, /* Index for rm_assign_memreg() RPC call */ + RM_FUNC_SET_MEMREG_PERMISSIONS = 20, /* Index for rm_set_memreg_permissions() RPC call */ + RM_FUNC_IS_MEMREG_OWNED = 21, /* Index for rm_is_memreg_owned() RPC call */ + RM_FUNC_GET_MEMREG_INFO = 22, /* Index for rm_get_memreg_info() RPC call */ + RM_FUNC_ASSIGN_PIN = 23, /* Index for rm_assign_pin() RPC call */ + RM_FUNC_SET_PIN_MOVABLE = 24, /* Index for rm_set_pin_movable() RPC call */ + RM_FUNC_IS_PIN_OWNED = 25, /* Index for rm_is_pin_owned() RPC call */ +} rm_func_t; + +/* Functions */ + +/*! + * This function dispatches an incoming RM RPC request. + * + * @param[in] caller_pt caller partition + * @param[in] msg pointer to RPC message + */ +void rm_dispatch(sc_rm_pt_t caller_pt, sc_rpc_msg_t *msg); + +/*! + * This function translates and dispatches an RM RPC request. + * + * @param[in] ipc IPC handle + * @param[in] msg pointer to RPC message + */ +void rm_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg); + +#endif /* _SC_RM_RPC_H */ + +/**@}*/ diff --git a/plat/freescale/imx8qm/imx8qm_bl31_setup.c b/plat/freescale/imx8qm/imx8qm_bl31_setup.c index fd6a403b..257ce7fc 100644 --- a/plat/freescale/imx8qm/imx8qm_bl31_setup.c +++ b/plat/freescale/imx8qm/imx8qm_bl31_setup.c @@ -44,6 +44,7 @@ #include #include #include +#include /* linker defined symbols */ extern unsigned long __RO_START__; @@ -182,6 +183,45 @@ static int lpuart32_serial_init(unsigned int base) return 0; } +void mx8_partition_resources(void) +{ + sc_err_t err; + sc_rm_pt_t secure_part, os_part; + int i; + + err = sc_rm_get_partition(ipc_handle, &secure_part); + + err = sc_rm_partition_alloc(ipc_handle, &os_part, false, false, + false, false, false); + + err = sc_rm_set_parent(ipc_handle, os_part, secure_part); + + /* set secure resources to NOT-movable */ + for(i = 0; i<(sizeof(secure_rsrcs)/sizeof(sc_rsrc_t)); i++){ + err = sc_rm_set_resource_movable(ipc_handle, secure_rsrcs[i], + secure_rsrcs[i], false); + + } + + /* move all movable resources and pins to non-secure partition */ + err = sc_rm_move_all(ipc_handle, secure_part, os_part, true, true); + + /* + * sc_rm_set_peripheral_permissions + * + * sc_rm_set_memreg_permissions + * + * sc_rm_set_pin_movable + * + */ + + if(err) + NOTICE("Partitioning Failed\n"); + else + NOTICE("Non-secure Partitioning Succeeded\n"); + +} + void bl31_early_platform_setup(bl31_params_t *from_bl2, void *plat_params_from_bl2) { @@ -221,6 +261,12 @@ void bl31_early_platform_setup(bl31_params_t *from_bl2, console_init(IMX_BOOT_UART_BASE, IMX_BOOT_UART_CLK_IN_HZ, IMX_CONSOLE_BAUDRATE); #endif + /* create new partition for non-secure OS/Hypervisor + * + * uses global structs defined in sec_rsrc.h */ + + mx8_partition_resources(); + /* * tell BL3-1 where the non-secure software image is located * and the entry state information. diff --git a/plat/freescale/imx8qm/include/sec_rsrc.h b/plat/freescale/imx8qm/include/sec_rsrc.h new file mode 100644 index 00000000..df3ccfdd --- /dev/null +++ b/plat/freescale/imx8qm/include/sec_rsrc.h @@ -0,0 +1,14 @@ +/* Copyright 2017 NXP */ +/* Include file detailing the resource partitioning for ATF */ + + + + + +sc_rsrc_t secure_rsrcs[] = { + SC_R_MU_1A +}; + + + + -- cgit v1.2.3