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 <teo.hall@nxp.com>

6 files changed, 662 insertions, 15 deletions

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 <types.h>
 #include <sci/ipc.h>
-//#include <sci/svc/irq/api.h>
-//#include <sci/svc/misc/api.h>
-//#include <sci/svc/otp/api.h>
 #include <sci/svc/pad/api.h>
 #include <sci/svc/pm/api.h>
-//#include <sci/svc/rm/api.h>
-//#include <sci/svc/timer/api.h>
-//#include <asm/arch/pins.h>
+#include <sci/svc/rm/api.h>
 
 #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 <sci/types.h>
+#include <sci/svc/rm/api.h>
+#include <sci/rpc.h>
+#include <stdlib.h>
+#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 <sci/sci.h>
 #include <xlat_tables.h>
 #include <lpuart.h>
+#include <sec_rsrc.h>
 
 /* 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
+};
+
+
+
+