Add RSS Communication Protocol components
The Corstone-1000 platform uses RSS Communication Protocol
to communicate between the Secure Enclave and the Host processor.
This uses the previously copied RSS Comm Protocol-related files
and has minor modifications to make them work correctly in
Trusted Services. Currently, only the Embed Protocol is supported
from the RSS Comms.
A new messaging and RPC component was made, and both of them follows the
previous OpenAMP and psa_ipc components' structures.
Modified the SE-Proxy deployment to use this new protocol instead of
the OpenAMP.
Signed-off-by: Bence Balogh <bence.balogh@arm.com>
Change-Id: Ia0d2c71396006404f28b8f1338dbbb939237cf62
diff --git a/components/rpc/rss_comms/caller/sp/rss_comms_caller.c b/components/rpc/rss_comms/caller/sp/rss_comms_caller.c
new file mode 100644
index 0000000..d857a2e
--- /dev/null
+++ b/components/rpc/rss_comms/caller/sp/rss_comms_caller.c
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "rss_comms_caller.h"
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "protocols/rpc/common/packed-c/status.h"
+#include "rpc_caller.h"
+#include "rpc_status.h"
+
+struct rss_comms_caller_context {
+ struct rss_comms_messenger rss_comms;
+};
+
+rpc_status_t open_session(void *context, const struct rpc_uuid *service_uuid, uint16_t endpoint_id)
+{
+ return RPC_SUCCESS;
+}
+
+rpc_status_t find_and_open_session(void *context, const struct rpc_uuid *service_uuid)
+{
+ return RPC_SUCCESS;
+}
+
+rpc_status_t close_session(void *context)
+{
+ return RPC_SUCCESS;
+}
+
+rpc_status_t create_shared_memory(void *context, size_t size,
+ struct rpc_caller_shared_memory *shared_memory)
+{
+ return RPC_ERROR_INVALID_VALUE;
+}
+
+rpc_status_t release_shared_memory(void *context, struct rpc_caller_shared_memory *shared_memory)
+{
+ return RPC_ERROR_INVALID_VALUE;
+}
+
+rpc_status_t call(void *context, uint16_t opcode, struct rpc_caller_shared_memory *shared_memory,
+ size_t request_length, size_t *response_length, service_status_t *service_status)
+{
+ return RPC_ERROR_INTERNAL;
+}
+
+rpc_status_t rss_comms_caller_invoke(rss_comms_call_handle handle, uint32_t opcode,
+ uint8_t **response_buffer, size_t *response_length)
+{
+ struct rpc_caller_interface *caller = (struct rpc_caller_interface *)handle;
+ struct rss_comms_caller_context *context = NULL;
+ int ret = 0;
+
+ if (!handle || !caller->context)
+ return RPC_ERROR_INVALID_VALUE;
+
+ context = (struct rss_comms_caller_context *)caller->context;
+
+ ret = rss_comms_messenger_call_invoke(&context->rss_comms, response_buffer,
+ response_length);
+ if (ret < 0)
+ return RPC_ERROR_TRANSPORT_LAYER;
+
+ return RPC_SUCCESS;
+}
+
+rpc_status_t rss_comms_caller_init(struct rpc_caller_interface *rpc_caller)
+{
+ struct rss_comms_caller_context *context = NULL;
+ int ret = 0;
+
+ if (!rpc_caller || rpc_caller->context)
+ return RPC_ERROR_INVALID_VALUE;
+
+ context = (struct rss_comms_caller_context *)calloc(1,
+ sizeof(struct rss_comms_caller_context));
+ if (!context)
+ return RPC_ERROR_INTERNAL;
+
+ ret = rss_comms_messenger_init(&context->rss_comms);
+
+ if (ret < 0) {
+ free(context);
+ return RPC_ERROR_TRANSPORT_LAYER;
+ }
+
+ rpc_caller->context = context;
+ rpc_caller->open_session = open_session;
+ rpc_caller->find_and_open_session = find_and_open_session;
+ rpc_caller->close_session = close_session;
+ rpc_caller->create_shared_memory = create_shared_memory;
+ rpc_caller->release_shared_memory = release_shared_memory;
+ rpc_caller->call = call;
+
+ return RPC_SUCCESS;
+}
+
+rss_comms_call_handle rss_comms_caller_begin(struct rpc_caller_interface *caller,
+ uint8_t **request_buffer, size_t request_length)
+{
+ struct rss_comms_caller_context *context = NULL;
+ int ret = 0;
+
+ if (!caller || !caller->context)
+ return NULL;
+
+ context = (struct rss_comms_caller_context *)caller->context;
+
+ ret = rss_comms_messenger_call_begin(&context->rss_comms, request_buffer, request_length);
+
+ if (ret < 0)
+ return NULL;
+
+ return caller;
+}
+
+rpc_status_t rss_comms_caller_end(rss_comms_call_handle handle)
+{
+ struct rpc_caller_interface *caller = (struct rpc_caller_interface *)handle;
+ struct rss_comms_caller_context *context = NULL;
+
+ if (!handle || !caller->context)
+ return RPC_ERROR_INVALID_VALUE;
+
+ context = (struct rss_comms_caller_context *)caller->context;
+
+ rss_comms_messenger_call_end(&context->rss_comms);
+
+ return RPC_SUCCESS;
+}
+
+rpc_status_t rss_comms_caller_deinit(struct rpc_caller_interface *rpc_caller)
+{
+ struct rss_comms_caller_context *context = NULL;
+
+ if (!rpc_caller)
+ return RPC_ERROR_INVALID_VALUE;
+
+ context = (struct rss_comms_caller_context *)rpc_caller->context;
+
+ rss_comms_messenger_deinit(&context->rss_comms);
+
+ free(context);
+ rpc_caller->context = NULL;
+
+ return RPC_SUCCESS;
+}
diff --git a/components/rpc/rss_comms/caller/sp/rss_comms_caller.h b/components/rpc/rss_comms/caller/sp/rss_comms_caller.h
new file mode 100644
index 0000000..a62edb5
--- /dev/null
+++ b/components/rpc/rss_comms/caller/sp/rss_comms_caller.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef __RSS_COMMS_CALLER_H__
+#define __RSS_COMMS_CALLER_H__
+
+#include "rpc_caller.h"
+#include "rss_comms_messenger_api.h"
+
+typedef void *rss_comms_call_handle;
+
+rpc_status_t rss_comms_caller_init(struct rpc_caller_interface *rpc_caller);
+rpc_status_t rss_comms_caller_deinit(struct rpc_caller_interface *rpc_caller);
+
+rss_comms_call_handle rss_comms_caller_begin(struct rpc_caller_interface *caller,
+ uint8_t **request_buffer, size_t request_length);
+
+rpc_status_t rss_comms_caller_invoke(rss_comms_call_handle handle, uint32_t opcode,
+ uint8_t **response_buffer, size_t *response_length);
+
+rpc_status_t rss_comms_caller_end(rss_comms_call_handle handle);
+
+#endif /* __RSS_COMMS_CALLER_H__ */
diff --git a/components/rpc/rss_comms/caller/sp/rss_comms_protocol.c b/components/rpc/rss_comms/caller/sp/rss_comms_protocol.c
index a1b1b58..7969536 100644
--- a/components/rpc/rss_comms/caller/sp/rss_comms_protocol.c
+++ b/components/rpc/rss_comms/caller/sp/rss_comms_protocol.c
@@ -1,24 +1,23 @@
/*
- * Copyright (c) 2022, Arm Limited. All rights reserved.
+ * Copyright (c) 2022-2024, Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*
*/
#include <assert.h>
-#include <common/debug.h>
#include "rss_comms_protocol.h"
psa_status_t rss_protocol_serialize_msg(psa_handle_t handle,
int16_t type,
- const psa_invec *in_vec,
+ const struct psa_invec *in_vec,
uint8_t in_len,
- const psa_outvec *out_vec,
+ const struct psa_outvec *out_vec,
uint8_t out_len,
struct serialized_rss_comms_msg_t *msg,
size_t *msg_len)
{
- psa_status_t status;
+ psa_status_t status = PSA_SUCCESS;
assert(msg != NULL);
assert(msg_len != NULL);
@@ -50,7 +49,7 @@
return PSA_SUCCESS;
}
-psa_status_t rss_protocol_deserialize_reply(psa_outvec *out_vec,
+psa_status_t rss_protocol_deserialize_reply(struct psa_outvec *out_vec,
uint8_t out_len,
psa_status_t *return_val,
const struct serialized_rss_comms_reply_t *reply,
@@ -73,3 +72,31 @@
return PSA_SUCCESS;
}
+
+psa_status_t rss_protocol_calculate_msg_len(psa_handle_t handle,
+ uint8_t protocol_ver,
+ const struct psa_invec *in_vec,
+ uint8_t in_len,
+ size_t *msg_len)
+{
+ psa_status_t status = PSA_SUCCESS;
+
+ assert(msg_len != NULL);
+ assert(in_vec != NULL);
+
+ switch (protocol_ver) {
+ case RSS_COMMS_PROTOCOL_EMBED:
+ status = rss_protocol_embed_calculate_msg_len(handle, in_vec, in_len, msg_len);
+ if (status != PSA_SUCCESS)
+ return status;
+
+ break;
+ case RSS_COMMS_PROTOCOL_POINTER_ACCESS:
+ default:
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
+
+ *msg_len += sizeof(struct serialized_rss_comms_header_t);
+
+ return PSA_SUCCESS;
+}
diff --git a/components/rpc/rss_comms/caller/sp/rss_comms_protocol.h b/components/rpc/rss_comms/caller/sp/rss_comms_protocol.h
index 9a38057..2d597b4 100644
--- a/components/rpc/rss_comms/caller/sp/rss_comms_protocol.h
+++ b/components/rpc/rss_comms/caller/sp/rss_comms_protocol.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2022, Arm Limited. All rights reserved.
+ * Copyright (c) 2022-2024, Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*
@@ -8,12 +8,12 @@
#ifndef __RSS_COMMS_PROTOCOL_H__
#define __RSS_COMMS_PROTOCOL_H__
-#include <cdefs.h>
#include <stdint.h>
#include <psa/client.h>
#include "rss_comms_protocol_embed.h"
#include "rss_comms_protocol_pointer_access.h"
+#include "service/common/include/psa/client.h"
enum rss_comms_protocol_version_t {
RSS_COMMS_PROTOCOL_EMBED = 0,
@@ -44,24 +44,25 @@
} reply;
};
-/* in_len and out_len are uint8_ts, therefore if there are more than 255 iovecs
- * an error may occur.
- */
-CASSERT(PSA_MAX_IOVEC <= UINT8_MAX, assert_rss_comms_max_iovec_too_large);
-
psa_status_t rss_protocol_serialize_msg(psa_handle_t handle,
int16_t type,
- const psa_invec *in_vec,
+ const struct psa_invec *in_vec,
uint8_t in_len,
- const psa_outvec *out_vec,
+ const struct psa_outvec *out_vec,
uint8_t out_len,
struct serialized_rss_comms_msg_t *msg,
size_t *msg_len);
-psa_status_t rss_protocol_deserialize_reply(psa_outvec *out_vec,
+psa_status_t rss_protocol_deserialize_reply(struct psa_outvec *out_vec,
uint8_t out_len,
psa_status_t *return_val,
const struct serialized_rss_comms_reply_t *reply,
size_t reply_size);
+psa_status_t rss_protocol_calculate_msg_len(psa_handle_t handle,
+ uint8_t protocol_ver,
+ const struct psa_invec *in_vec,
+ uint8_t in_len,
+ size_t *msg_len);
+
#endif /* __RSS_COMMS_PROTOCOL_H__ */
diff --git a/components/rpc/rss_comms/caller/sp/rss_comms_protocol_embed.c b/components/rpc/rss_comms/caller/sp/rss_comms_protocol_embed.c
index 05628cc..6d96ff2 100644
--- a/components/rpc/rss_comms/caller/sp/rss_comms_protocol_embed.c
+++ b/components/rpc/rss_comms/caller/sp/rss_comms_protocol_embed.c
@@ -8,15 +8,14 @@
#include <assert.h>
#include <string.h>
-#include <common/debug.h>
#include "rss_comms_protocol_common.h"
#include "rss_comms_protocol_embed.h"
psa_status_t rss_protocol_embed_serialize_msg(psa_handle_t handle,
int16_t type,
- const psa_invec *in_vec,
+ const struct psa_invec *in_vec,
uint8_t in_len,
- const psa_outvec *out_vec,
+ const struct psa_outvec *out_vec,
uint8_t out_len,
struct rss_embed_msg_t *msg,
size_t *msg_len)
@@ -44,7 +43,7 @@
return PSA_ERROR_INVALID_ARGUMENT;
}
memcpy(msg->trailer + payload_size,
- in_vec[i].base,
+ psa_u32_to_ptr(in_vec[i].base),
in_vec[i].len);
payload_size += in_vec[i].len;
}
@@ -55,7 +54,7 @@
return PSA_SUCCESS;
}
-psa_status_t rss_protocol_embed_deserialize_reply(psa_outvec *out_vec,
+psa_status_t rss_protocol_embed_deserialize_reply(struct psa_outvec *out_vec,
uint8_t out_len,
psa_status_t *return_val,
const struct rss_embed_reply_t *reply,
@@ -73,7 +72,7 @@
return PSA_ERROR_INVALID_ARGUMENT;
}
- memcpy(out_vec[i].base,
+ memcpy(psa_u32_to_ptr(out_vec[i].base),
reply->trailer + payload_offset,
reply->out_size[i]);
out_vec[i].len = reply->out_size[i];
@@ -84,3 +83,23 @@
return PSA_SUCCESS;
}
+
+psa_status_t rss_protocol_embed_calculate_msg_len(psa_handle_t handle,
+ const struct psa_invec *in_vec,
+ uint8_t in_len,
+ size_t *msg_len)
+{
+ uint32_t payload_size = 0;
+ uint32_t i = 0;
+
+ assert(in_vec != NULL);
+ assert(msg_len != NULL);
+
+ for (i = 0U; i < in_len; ++i)
+ payload_size += in_vec[i].len;
+
+ /* Output the actual size of the message, to optimize sending */
+ *msg_len = offsetof(struct rss_embed_msg_t, trailer) + payload_size;
+
+ return PSA_SUCCESS;
+}
diff --git a/components/rpc/rss_comms/caller/sp/rss_comms_protocol_embed.h b/components/rpc/rss_comms/caller/sp/rss_comms_protocol_embed.h
index c81c795..29e2250 100644
--- a/components/rpc/rss_comms/caller/sp/rss_comms_protocol_embed.h
+++ b/components/rpc/rss_comms/caller/sp/rss_comms_protocol_embed.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2022, Arm Limited. All rights reserved.
+ * Copyright (c) 2022-2024, Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*
@@ -8,13 +8,8 @@
#ifndef __RSS_COMMS_PROTOCOL_EMBED_H__
#define __RSS_COMMS_PROTOCOL_EMBED_H__
-#include <cdefs.h>
-
#include <psa/client.h>
-
-#include <platform_def.h>
-
-
+#include <sys/cdefs.h>
struct __packed rss_embed_msg_t {
psa_handle_t handle;
@@ -31,17 +26,22 @@
psa_status_t rss_protocol_embed_serialize_msg(psa_handle_t handle,
int16_t type,
- const psa_invec *in_vec,
+ const struct psa_invec *in_vec,
uint8_t in_len,
- const psa_outvec *out_vec,
+ const struct psa_outvec *out_vec,
uint8_t out_len,
struct rss_embed_msg_t *msg,
size_t *msg_len);
-psa_status_t rss_protocol_embed_deserialize_reply(psa_outvec *out_vec,
+psa_status_t rss_protocol_embed_deserialize_reply(struct psa_outvec *out_vec,
uint8_t out_len,
psa_status_t *return_val,
const struct rss_embed_reply_t *reply,
size_t reply_size);
+psa_status_t rss_protocol_embed_calculate_msg_len(psa_handle_t handle,
+ const struct psa_invec *in_vec,
+ uint8_t in_len,
+ size_t *msg_len);
+
#endif /* __RSS_COMMS_PROTOCOL_EMBED_H__ */
diff --git a/components/rpc/rss_comms/caller/sp/rss_comms_protocol_pointer_access.c b/components/rpc/rss_comms/caller/sp/rss_comms_protocol_pointer_access.c
index 3a10a98..6d7d771 100644
--- a/components/rpc/rss_comms/caller/sp/rss_comms_protocol_pointer_access.c
+++ b/components/rpc/rss_comms/caller/sp/rss_comms_protocol_pointer_access.c
@@ -11,9 +11,9 @@
psa_status_t rss_protocol_pointer_access_serialize_msg(psa_handle_t handle,
int16_t type,
- const psa_invec *in_vec,
+ const struct psa_invec *in_vec,
uint8_t in_len,
- const psa_outvec *out_vec,
+ const struct psa_outvec *out_vec,
uint8_t out_len,
struct rss_pointer_access_msg_t *msg,
size_t *msg_len)
@@ -42,7 +42,7 @@
return PSA_SUCCESS;
}
-psa_status_t rss_protocol_pointer_access_deserialize_reply(psa_outvec *out_vec,
+psa_status_t rss_protocol_pointer_access_deserialize_reply(struct psa_outvec *out_vec,
uint8_t out_len,
psa_status_t *return_val,
const struct rss_pointer_access_reply_t *reply,
diff --git a/components/rpc/rss_comms/caller/sp/rss_comms_protocol_pointer_access.h b/components/rpc/rss_comms/caller/sp/rss_comms_protocol_pointer_access.h
index a4d054b..a1b278c 100644
--- a/components/rpc/rss_comms/caller/sp/rss_comms_protocol_pointer_access.h
+++ b/components/rpc/rss_comms/caller/sp/rss_comms_protocol_pointer_access.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2022, Arm Limited. All rights reserved.
+ * Copyright (c) 2022-2024, Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*
@@ -8,9 +8,9 @@
#ifndef __RSS_COMMS_PROTOCOL_POINTER_ACCESS_H__
#define __RSS_COMMS_PROTOCOL_POINTER_ACCESS_H__
-#include <cdefs.h>
#include <psa/client.h>
+#include <sys/cdefs.h>
struct __packed rss_pointer_access_msg_t {
psa_handle_t handle;
@@ -26,14 +26,14 @@
psa_status_t rss_protocol_pointer_access_serialize_msg(psa_handle_t handle,
int16_t type,
- const psa_invec *in_vec,
+ const struct psa_invec *in_vec,
uint8_t in_len,
- const psa_outvec *out_vec,
+ const struct psa_outvec *out_vec,
uint8_t out_len,
struct rss_pointer_access_msg_t *msg,
size_t *msg_len);
-psa_status_t rss_protocol_pointer_access_deserialize_reply(psa_outvec *out_vec,
+psa_status_t rss_protocol_pointer_access_deserialize_reply(struct psa_outvec *out_vec,
uint8_t out_len,
psa_status_t *return_val,
const struct rss_pointer_access_reply_t *reply,
diff --git a/components/rpc/rss_comms/component.cmake b/components/rpc/rss_comms/component.cmake
new file mode 100644
index 0000000..1cafb5c
--- /dev/null
+++ b/components/rpc/rss_comms/component.cmake
@@ -0,0 +1,27 @@
+#-------------------------------------------------------------------------------
+# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+#-------------------------------------------------------------------------------
+if (NOT DEFINED TGT)
+ message(FATAL_ERROR "mandatory parameter TGT is not defined.")
+endif()
+
+set_property(TARGET ${TGT} APPEND PROPERTY PUBLIC_HEADER
+ ${CMAKE_CURRENT_LIST_DIR}/caller/sp/rss_comms_caller.h
+ )
+
+target_sources(${TGT} PRIVATE
+ "${CMAKE_CURRENT_LIST_DIR}/rss_comms.c"
+ "${CMAKE_CURRENT_LIST_DIR}/caller/sp/rss_comms_caller.c"
+ "${CMAKE_CURRENT_LIST_DIR}/caller/sp/rss_comms_protocol.c"
+ "${CMAKE_CURRENT_LIST_DIR}/caller/sp/rss_comms_protocol_embed.c"
+ "${CMAKE_CURRENT_LIST_DIR}/caller/sp/rss_comms_protocol_pointer_access.c"
+ )
+
+target_include_directories(${TGT}
+ PUBLIC
+ "${CMAKE_CURRENT_LIST_DIR}/caller/sp/"
+ )
+
diff --git a/components/rpc/rss_comms/rss_comms.c b/components/rpc/rss_comms/rss_comms.c
index 332105f..267d134 100644
--- a/components/rpc/rss_comms/rss_comms.c
+++ b/components/rpc/rss_comms/rss_comms.c
@@ -7,24 +7,23 @@
#include <stdint.h>
#include <string.h>
-#include <common/debug.h>
-#include <drivers/arm/mhu.h>
-#include <drivers/arm/rss_comms.h>
-#include <psa/client.h>
-#include <rss_comms_protocol.h>
+#include "protocols/rpc/common/packed-c/status.h"
+#include "psa/client.h"
+#include "rss_comms_caller.h"
+#include "rss_comms_protocol.h"
+#include "trace.h"
-/* Union as message space and reply space are never used at the same time, and this saves space as
- * we can overlap them.
+/* This value should be set according to the implemented channels
+ * in the MHU. As only the Embed protocol is supported at the moment,
+ * it is set big enough to fit even the largest messages.
*/
-union __packed __attribute__((aligned(4))) rss_comms_io_buffer_t {
- struct serialized_rss_comms_msg_t msg;
- struct serialized_rss_comms_reply_t reply;
-};
+#ifndef COMMS_MHU_MSG_SIZE
+#define COMMS_MHU_MSG_SIZE 0x2200
+#endif
-static uint8_t select_protocol_version(const psa_invec *in_vec, size_t in_len,
- const psa_outvec *out_vec, size_t out_len)
+static uint8_t select_protocol_version(const struct psa_invec *in_vec, size_t in_len,
+ const struct psa_outvec *out_vec, size_t out_len)
{
- size_t comms_mhu_msg_size;
size_t comms_embed_msg_min_size;
size_t comms_embed_reply_min_size;
size_t in_size_total = 0;
@@ -38,11 +37,8 @@
out_size_total += out_vec[i].len;
}
- comms_mhu_msg_size = mhu_get_max_message_size();
-
comms_embed_msg_min_size = sizeof(struct serialized_rss_comms_header_t) +
- sizeof(struct rss_embed_msg_t) -
- PLAT_RSS_COMMS_PAYLOAD_MAX_SIZE;
+ sizeof(struct rss_embed_msg_t) - PLAT_RSS_COMMS_PAYLOAD_MAX_SIZE;
comms_embed_reply_min_size = sizeof(struct serialized_rss_comms_header_t) +
sizeof(struct rss_embed_reply_t) -
@@ -60,121 +56,100 @@
* pointers.
*/
if ((comms_embed_msg_min_size + in_size_total >
- comms_mhu_msg_size - sizeof(uint32_t)) ||
+ COMMS_MHU_MSG_SIZE - sizeof(uint32_t)) ||
(comms_embed_reply_min_size + out_size_total >
- comms_mhu_msg_size - sizeof(uint32_t))) {
+ COMMS_MHU_MSG_SIZE - sizeof(uint32_t))) {
return RSS_COMMS_PROTOCOL_POINTER_ACCESS;
} else {
return RSS_COMMS_PROTOCOL_EMBED;
}
}
-psa_status_t psa_call(psa_handle_t handle, int32_t type, const psa_invec *in_vec, size_t in_len,
- psa_outvec *out_vec, size_t out_len)
+psa_status_t __psa_call(struct rpc_caller_interface *caller, psa_handle_t handle, int32_t client_id,
+ int32_t type, const struct psa_invec *in_vec, size_t in_len,
+ struct psa_outvec *out_vec, size_t out_len)
{
- /* Declared statically to avoid using huge amounts of stack space. Maybe revisit if
- * functions not being reentrant becomes a problem.
- */
- static union rss_comms_io_buffer_t io_buf;
- enum mhu_error_t err;
- psa_status_t status;
static uint8_t seq_num = 1U;
- size_t msg_size;
- size_t reply_size = sizeof(io_buf.reply);
- psa_status_t return_val;
- size_t idx;
+ rpc_status_t rpc_status = RPC_ERROR_INTERNAL;
+ psa_status_t psa_status = PSA_ERROR_INVALID_ARGUMENT;
+ psa_status_t return_val = PSA_ERROR_INVALID_ARGUMENT;
+ rss_comms_call_handle rpc_handle = (rss_comms_call_handle)caller;
+ size_t req_len = 0;
+ size_t resp_len = 0;
+ struct serialized_rss_comms_msg_t *req = NULL;
+ struct serialized_rss_comms_reply_t *reply = NULL;
+ uint8_t protocol_ver = 0;
- if (type > PSA_CALL_TYPE_MAX || type < PSA_CALL_TYPE_MIN ||
- in_len > PSA_MAX_IOVEC || out_len > PSA_MAX_IOVEC) {
- return PSA_ERROR_INVALID_ARGUMENT;
+ protocol_ver = select_protocol_version(in_vec, in_len, out_vec, out_len);
+
+ psa_status = rss_protocol_calculate_msg_len(handle, protocol_ver, in_vec, in_len, &req_len);
+ if (psa_status != PSA_SUCCESS) {
+ EMSG("Message size calculation failed: %d", psa_status);
+ return psa_status;
}
- io_buf.msg.header.seq_num = seq_num,
+ rpc_handle = rss_comms_caller_begin(caller, (uint8_t **)&req, req_len);
+ if (!rpc_handle) {
+ EMSG("Could not get handle");
+ return PSA_ERROR_GENERIC_ERROR;
+ }
+
+ req->header.seq_num = seq_num;
/* No need to distinguish callers (currently concurrent calls are not supported). */
- io_buf.msg.header.client_id = 1U,
- io_buf.msg.header.protocol_ver = select_protocol_version(in_vec, in_len, out_vec, out_len);
+ req->header.client_id = client_id;
+ req->header.protocol_ver = protocol_ver;
- status = rss_protocol_serialize_msg(handle, type, in_vec, in_len, out_vec,
- out_len, &io_buf.msg, &msg_size);
- if (status != PSA_SUCCESS) {
- return status;
+ psa_status = rss_protocol_serialize_msg(handle, type, in_vec, in_len, out_vec, out_len, req,
+ &req_len);
+ if (psa_status != PSA_SUCCESS) {
+ EMSG("Serialize msg failed: %d", psa_status);
+ return psa_status;
}
- VERBOSE("[RSS-COMMS] Sending message\n");
- VERBOSE("protocol_ver=%u\n", io_buf.msg.header.protocol_ver);
- VERBOSE("seq_num=%u\n", io_buf.msg.header.seq_num);
- VERBOSE("client_id=%u\n", io_buf.msg.header.client_id);
- for (idx = 0; idx < in_len; idx++) {
- VERBOSE("in_vec[%lu].len=%lu\n", idx, in_vec[idx].len);
- VERBOSE("in_vec[%lu].buf=%p\n", idx, (void *)in_vec[idx].base);
+ DMSG("Sending rss_comms message");
+ DMSG("protocol_ver=%u", req->header.protocol_ver);
+ DMSG("seq_num=%u", req->header.seq_num);
+ DMSG("client_id=%u", req->header.client_id);
+
+ resp_len = sizeof(*reply);
+
+ rpc_status = rss_comms_caller_invoke(rpc_handle, 0, (uint8_t **)&reply, &resp_len);
+ if (rpc_status != RPC_SUCCESS) {
+ EMSG("Invoke failed: %d", rpc_status);
+ return PSA_ERROR_GENERIC_ERROR;
}
- err = mhu_send_data((uint8_t *)&io_buf.msg, msg_size);
- if (err != MHU_ERR_NONE) {
- return PSA_ERROR_COMMUNICATION_FAILURE;
+ DMSG("Received rss_comms reply");
+ DMSG("protocol_ver=%u", reply->header.protocol_ver);
+ DMSG("seq_num=%u", reply->header.seq_num);
+ DMSG("client_id=%u", reply->header.client_id);
+ DMSG("resp_len=%lu", resp_len);
+
+ psa_status = rss_protocol_deserialize_reply(out_vec, out_len, &return_val, reply, resp_len);
+ if (psa_status != PSA_SUCCESS) {
+ EMSG("Protocol deserialize reply failed: %d", psa_status);
+ return psa_status;
}
-#if DEBUG
- /*
- * Poisoning the message buffer (with a known pattern).
- * Helps in detecting hypothetical RSS communication bugs.
- */
- memset(&io_buf.msg, 0xA5, msg_size);
-#endif
+ DMSG("Return_val=%d", return_val);
- err = mhu_receive_data((uint8_t *)&io_buf.reply, &reply_size);
- if (err != MHU_ERR_NONE) {
- return PSA_ERROR_COMMUNICATION_FAILURE;
- }
-
- VERBOSE("[RSS-COMMS] Received reply\n");
- VERBOSE("protocol_ver=%u\n", io_buf.reply.header.protocol_ver);
- VERBOSE("seq_num=%u\n", io_buf.reply.header.seq_num);
- VERBOSE("client_id=%u\n", io_buf.reply.header.client_id);
-
- status = rss_protocol_deserialize_reply(out_vec, out_len, &return_val,
- &io_buf.reply, reply_size);
- if (status != PSA_SUCCESS) {
- return status;
- }
-
- VERBOSE("return_val=%d\n", return_val);
- for (idx = 0U; idx < out_len; idx++) {
- VERBOSE("out_vec[%lu].len=%lu\n", idx, out_vec[idx].len);
- VERBOSE("out_vec[%lu].buf=%p\n", idx, (void *)out_vec[idx].base);
- }
-
- /* Clear the MHU message buffer to remove assets from memory */
- memset(&io_buf, 0x0, sizeof(io_buf));
+ rss_comms_caller_end(rpc_handle);
seq_num++;
return return_val;
}
-int rss_comms_init(uintptr_t mhu_sender_base, uintptr_t mhu_receiver_base)
+psa_status_t psa_call_client_id(struct rpc_caller_interface *caller, psa_handle_t psa_handle,
+ int32_t client_id, int32_t type, const struct psa_invec *in_vec,
+ size_t in_len, struct psa_outvec *out_vec, size_t out_len)
{
- enum mhu_error_t err;
+ return __psa_call(caller, psa_handle, client_id, type, in_vec, in_len, out_vec, out_len);
+}
- err = mhu_init_sender(mhu_sender_base);
- if (err != MHU_ERR_NONE) {
- if (err == MHU_ERR_ALREADY_INIT) {
- INFO("[RSS-COMMS] Host to RSS MHU driver already initialized\n");
- } else {
- ERROR("[RSS-COMMS] Host to RSS MHU driver initialization failed: %d\n", err);
- return -1;
- }
- }
-
- err = mhu_init_receiver(mhu_receiver_base);
- if (err != MHU_ERR_NONE) {
- if (err == MHU_ERR_ALREADY_INIT) {
- INFO("[RSS-COMMS] RSS to Host MHU driver already initialized\n");
- } else {
- ERROR("[RSS-COMMS] RSS to Host MHU driver initialization failed: %d\n", err);
- return -1;
- }
- }
-
- return 0;
+psa_status_t psa_call(struct rpc_caller_interface *caller, psa_handle_t psa_handle, int32_t type,
+ const struct psa_invec *in_vec, size_t in_len, struct psa_outvec *out_vec,
+ size_t out_len)
+{
+ return __psa_call(caller, psa_handle, 0, type, in_vec, in_len, out_vec, out_len);
}