From eace8f82713d5d4292a5723a959a3ef3dd3a33c1 Mon Sep 17 00:00:00 2001
From: Teo Hall <teo.hall@nxp.com>
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 <teo.hall@nxp.com>
---
 plat/freescale/common/sci/svc/rm/rm_rpc_clnt.c | 521 +++++++++++++++++++++++++
 plat/freescale/common/sci/svc/rm/rpc.h         |  77 ++++
 2 files changed, 598 insertions(+)
 create mode 100644 plat/freescale/common/sci/svc/rm/rm_rpc_clnt.c
 create mode 100644 plat/freescale/common/sci/svc/rm/rpc.h

(limited to 'plat/freescale/common/sci/svc')

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 */
+
+/**@}*/
-- 
cgit v1.2.3