Skip to content

Commit 0c0bab0

Browse files
odeprezTrustedFirmware Code Review
odeprez
authored and
TrustedFirmware Code Review
committed
Merge changes from topic "ffa_el3_spmc" into integration
* changes: feat(tsp): enable test cases for EL3 SPMC feat(tsp): increase stack size for tsp feat(tsp): add ffa_helpers to enable more FF-A functionality
2 parents 748749a + 15ca1ee commit 0c0bab0

10 files changed

+694
-80
lines changed

‎bl32/tsp/ffa_helpers.c

+250
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,250 @@
1+
/*
2+
* Copyright (c) 2022, Arm Limited. All rights reserved.
3+
*
4+
* SPDX-License-Identifier: BSD-3-Clause
5+
*/
6+
7+
#include <common/debug.h>
8+
#include "ffa_helpers.h"
9+
#include <services/ffa_svc.h>
10+
#include "tsp_private.h"
11+
12+
/*******************************************************************************
13+
* Wrapper function to send a direct request.
14+
******************************************************************************/
15+
smc_args_t ffa_msg_send_direct_req(ffa_endpoint_id16_t sender,
16+
ffa_endpoint_id16_t receiver,
17+
uint32_t arg3,
18+
uint32_t arg4,
19+
uint32_t arg5,
20+
uint32_t arg6,
21+
uint32_t arg7)
22+
{
23+
uint32_t src_dst_ids = (sender << FFA_DIRECT_MSG_SOURCE_SHIFT) |
24+
(receiver << FFA_DIRECT_MSG_DESTINATION_SHIFT);
25+
26+
27+
/* Send Direct Request. */
28+
return smc_helper(FFA_MSG_SEND_DIRECT_REQ_SMC64, src_dst_ids,
29+
0, arg3, arg4, arg5, arg6, arg7);
30+
}
31+
32+
/*******************************************************************************
33+
* Wrapper function to send a direct response.
34+
******************************************************************************/
35+
smc_args_t *ffa_msg_send_direct_resp(ffa_endpoint_id16_t sender,
36+
ffa_endpoint_id16_t receiver,
37+
uint32_t arg3,
38+
uint32_t arg4,
39+
uint32_t arg5,
40+
uint32_t arg6,
41+
uint32_t arg7)
42+
{
43+
uint32_t src_dst_ids = (sender << FFA_DIRECT_MSG_SOURCE_SHIFT) |
44+
(receiver << FFA_DIRECT_MSG_DESTINATION_SHIFT);
45+
46+
return set_smc_args(FFA_MSG_SEND_DIRECT_RESP_SMC64, src_dst_ids,
47+
0, arg3, arg4, arg5, arg6, arg7);
48+
}
49+
50+
/*******************************************************************************
51+
* Memory Management Helpers.
52+
******************************************************************************/
53+
54+
/**
55+
* Initialises the header of the given `ffa_mtd`, not including the
56+
* composite memory region offset.
57+
*/
58+
static void ffa_memory_region_init_header(
59+
struct ffa_mtd *memory_region, ffa_endpoint_id16_t sender,
60+
ffa_mem_attr16_t attributes, ffa_mtd_flag32_t flags,
61+
uint64_t handle, uint64_t tag, ffa_endpoint_id16_t *receivers,
62+
uint32_t receiver_count, ffa_mem_perm8_t permissions)
63+
{
64+
struct ffa_emad_v1_0 *emad;
65+
66+
memory_region->emad_offset = sizeof(struct ffa_mtd);
67+
memory_region->emad_size = sizeof(struct ffa_emad_v1_0);
68+
emad = (struct ffa_emad_v1_0 *)
69+
((uint8_t *) memory_region +
70+
memory_region->emad_offset);
71+
memory_region->sender_id = sender;
72+
memory_region->memory_region_attributes = attributes;
73+
memory_region->reserved_36_39 = 0;
74+
memory_region->flags = flags;
75+
memory_region->handle = handle;
76+
memory_region->tag = tag;
77+
memory_region->reserved_40_47 = 0;
78+
memory_region->emad_count = receiver_count;
79+
for (uint32_t i = 0U; i < receiver_count; i++) {
80+
emad[i].mapd.endpoint_id = receivers[i];
81+
emad[i].mapd.memory_access_permissions = permissions;
82+
emad[i].mapd.flags = 0;
83+
emad[i].comp_mrd_offset = 0;
84+
emad[i].reserved_8_15 = 0;
85+
}
86+
}
87+
/**
88+
* Initialises the given `ffa_mtd` to be used for an
89+
* `FFA_MEM_RETRIEVE_REQ` by the receiver of a memory transaction.
90+
* TODO: Support differing attributes per receiver.
91+
*
92+
* Returns the size of the descriptor written.
93+
*/
94+
static uint32_t ffa_memory_retrieve_request_init(
95+
struct ffa_mtd *memory_region, uint64_t handle,
96+
ffa_endpoint_id16_t sender, ffa_endpoint_id16_t *receivers, uint32_t receiver_count,
97+
uint64_t tag, ffa_mtd_flag32_t flags,
98+
ffa_mem_perm8_t permissions,
99+
ffa_mem_attr16_t attributes)
100+
{
101+
ffa_memory_region_init_header(memory_region, sender, attributes, flags,
102+
handle, tag, receivers,
103+
receiver_count, permissions);
104+
105+
return sizeof(struct ffa_mtd) +
106+
memory_region->emad_count * sizeof(struct ffa_emad_v1_0);
107+
}
108+
109+
/* Relinquish access to memory region. */
110+
bool ffa_mem_relinquish(void)
111+
{
112+
smc_args_t ret;
113+
114+
ret = smc_helper(FFA_MEM_RELINQUISH, 0, 0, 0, 0, 0, 0, 0);
115+
if (ffa_func_id(ret) != FFA_SUCCESS_SMC32) {
116+
ERROR("%s failed to relinquish memory! error: (%x) %x\n",
117+
__func__, ffa_func_id(ret), ffa_error_code(ret));
118+
return false;
119+
}
120+
return true;
121+
}
122+
123+
/* Retrieve memory shared by another partition. */
124+
smc_args_t ffa_mem_retrieve_req(uint32_t descriptor_length,
125+
uint32_t fragment_length)
126+
{
127+
return smc_helper(FFA_MEM_RETRIEVE_REQ_SMC32,
128+
descriptor_length,
129+
fragment_length,
130+
0, 0, 0, 0, 0);
131+
}
132+
133+
/* Retrieve the next memory descriptor fragment. */
134+
smc_args_t ffa_mem_frag_rx(uint64_t handle, uint32_t recv_length)
135+
{
136+
return smc_helper(FFA_MEM_FRAG_RX,
137+
FFA_MEM_HANDLE_LOW(handle),
138+
FFA_MEM_HANDLE_HIGH(handle),
139+
recv_length,
140+
0, 0, 0, 0);
141+
}
142+
143+
bool memory_retrieve(struct mailbox *mb,
144+
struct ffa_mtd **retrieved,
145+
uint64_t handle, ffa_endpoint_id16_t sender,
146+
ffa_endpoint_id16_t *receivers, uint32_t receiver_count,
147+
ffa_mtd_flag32_t flags, uint32_t *frag_length,
148+
uint32_t *total_length)
149+
{
150+
smc_args_t ret;
151+
uint32_t descriptor_size;
152+
struct ffa_mtd *memory_region = (struct ffa_mtd *)mb->tx_buffer;
153+
154+
if (retrieved == NULL || mb == NULL) {
155+
ERROR("Invalid parameters!\n");
156+
return false;
157+
}
158+
159+
/* Clear TX buffer. */
160+
memset(memory_region, 0, PAGE_SIZE);
161+
162+
/* Clear local buffer. */
163+
memset(mem_region_buffer, 0, REGION_BUF_SIZE);
164+
165+
descriptor_size = ffa_memory_retrieve_request_init(
166+
memory_region, handle, sender, receivers, receiver_count, 0, flags,
167+
FFA_MEM_PERM_RW | FFA_MEM_PERM_NX,
168+
FFA_MEM_ATTR_NORMAL_MEMORY_CACHED_WB |
169+
FFA_MEM_ATTR_INNER_SHAREABLE);
170+
171+
ret = ffa_mem_retrieve_req(descriptor_size, descriptor_size);
172+
173+
if (ffa_func_id(ret) == FFA_ERROR) {
174+
ERROR("Couldn't retrieve the memory page. Error: %x\n",
175+
ffa_error_code(ret));
176+
return false;
177+
}
178+
179+
/*
180+
* Following total_size and fragment_size are useful to keep track
181+
* of the state of transaction. When the sum of all fragment_size of all
182+
* fragments is equal to total_size, the memory transaction has been
183+
* completed.
184+
*/
185+
*total_length = ret._regs[1];
186+
*frag_length = ret._regs[2];
187+
188+
/* Validate frag_length is less than total_length and mailbox size. */
189+
if (*frag_length == 0U || *total_length == 0U ||
190+
*frag_length > *total_length || *frag_length > (mb->rxtx_page_count * PAGE_SIZE)) {
191+
ERROR("Invalid parameters!\n");
192+
return false;
193+
}
194+
195+
/* Copy response to local buffer. */
196+
memcpy(mem_region_buffer, mb->rx_buffer, *frag_length);
197+
198+
if (ffa_rx_release()) {
199+
ERROR("Failed to release buffer!\n");
200+
return false;
201+
}
202+
203+
*retrieved = (struct ffa_mtd *) mem_region_buffer;
204+
205+
if ((*retrieved)->emad_count > MAX_MEM_SHARE_RECIPIENTS) {
206+
VERBOSE("SPMC memory sharing supports max of %u receivers!\n",
207+
MAX_MEM_SHARE_RECIPIENTS);
208+
return false;
209+
}
210+
211+
/*
212+
* We are sharing memory from the normal world therefore validate the NS
213+
* bit was set by the SPMC.
214+
*/
215+
if (((*retrieved)->memory_region_attributes & FFA_MEM_ATTR_NS_BIT) == 0U) {
216+
ERROR("SPMC has not set the NS bit! 0x%x\n",
217+
(*retrieved)->memory_region_attributes);
218+
return false;
219+
}
220+
221+
VERBOSE("Memory Descriptor Retrieved!\n");
222+
223+
return true;
224+
}
225+
226+
/* Relinquish the memory region. */
227+
bool memory_relinquish(struct ffa_mem_relinquish_descriptor *m, uint64_t handle,
228+
ffa_endpoint_id16_t id)
229+
{
230+
ffa_mem_relinquish_init(m, handle, 0, id);
231+
return ffa_mem_relinquish();
232+
}
233+
234+
/* Query SPMC that the rx buffer of the partition can be released. */
235+
bool ffa_rx_release(void)
236+
{
237+
smc_args_t ret;
238+
239+
ret = smc_helper(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
240+
return ret._regs[SMC_ARG0] != FFA_SUCCESS_SMC32;
241+
}
242+
243+
/* Map the provided buffers with the SPMC. */
244+
bool ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages)
245+
{
246+
smc_args_t ret;
247+
248+
ret = smc_helper(FFA_RXTX_MAP_SMC64, send, recv, pages, 0, 0, 0, 0);
249+
return ret._regs[0] != FFA_SUCCESS_SMC32;
250+
}

‎bl32/tsp/ffa_helpers.h

+116
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
/*
2+
* Copyright (c) 2022, Arm Limited. All rights reserved.
3+
*
4+
* SPDX-License-Identifier: BSD-3-Clause
5+
*/
6+
7+
#ifndef FFA_HELPERS_H
8+
#define FFA_HELPERS_H
9+
10+
#include <stdint.h>
11+
12+
#include "../../services/std_svc/spm/el3_spmc/spmc.h"
13+
#include "../../services/std_svc/spm/el3_spmc/spmc_shared_mem.h"
14+
#include <services/el3_spmc_ffa_memory.h>
15+
#include <services/ffa_svc.h>
16+
#include "tsp_private.h"
17+
18+
static inline uint32_t ffa_func_id(smc_args_t val)
19+
{
20+
return (uint32_t) val._regs[0];
21+
}
22+
23+
static inline int32_t ffa_error_code(smc_args_t val)
24+
{
25+
return (uint32_t) val._regs[2];
26+
}
27+
28+
extern uint8_t mem_region_buffer[4096 * 2] __aligned(PAGE_SIZE);
29+
#define REGION_BUF_SIZE sizeof(mem_region_buffer)
30+
31+
/** The maximum number of recipients a memory region may be sent to. */
32+
#define MAX_MEM_SHARE_RECIPIENTS 2U
33+
34+
/* FFA Memory Management mode flags. */
35+
#define FFA_FLAG_SHARE_MEMORY (1U << 3)
36+
#define FFA_FLAG_LEND_MEMORY (1U << 4)
37+
38+
#define FFA_FLAG_MEMORY_MASK (3U << 3)
39+
40+
#define FFA_MEM_HANDLE_LOW(x) (x & 0xFFFFFFFF)
41+
#define FFA_MEM_HANDLE_HIGH(x) (x >> 32)
42+
43+
#define FFA_MEM_PERM_DATA_OFFSET 0
44+
#define FFA_MEM_PERM_DATA_MASK 0x3
45+
46+
static inline uint32_t ffa_mem_relinquish_init(
47+
struct ffa_mem_relinquish_descriptor *relinquish_request,
48+
uint64_t handle, ffa_mtd_flag32_t flags,
49+
ffa_endpoint_id16_t sender)
50+
{
51+
relinquish_request->handle = handle;
52+
relinquish_request->flags = flags;
53+
relinquish_request->endpoint_count = 1;
54+
relinquish_request->endpoint_array[0] = sender;
55+
56+
return sizeof(struct ffa_mem_relinquish_descriptor) + sizeof(ffa_endpoint_id16_t);
57+
}
58+
59+
/**
60+
* Gets the `ffa_comp_mrd` for the given receiver from an
61+
* `ffa_mtd`, or NULL if it is not valid.
62+
*/
63+
static inline struct ffa_comp_mrd *
64+
ffa_memory_region_get_composite(struct ffa_mtd *memory_region,
65+
uint32_t receiver_index)
66+
{
67+
struct ffa_emad_v1_0 *receivers;
68+
uint32_t offset;
69+
70+
receivers = (struct ffa_emad_v1_0 *)
71+
((uint8_t *) memory_region +
72+
memory_region->emad_offset +
73+
(memory_region->emad_size * receiver_index));
74+
offset = receivers->comp_mrd_offset;
75+
76+
if (offset == 0U) {
77+
return NULL;
78+
}
79+
80+
return (struct ffa_comp_mrd *)
81+
((uint8_t *) memory_region + offset);
82+
}
83+
84+
static inline uint32_t ffa_get_data_access_attr(ffa_mem_perm8_t perm)
85+
{
86+
return ((perm >> FFA_MEM_PERM_DATA_OFFSET) & FFA_MEM_PERM_DATA_MASK);
87+
}
88+
89+
smc_args_t ffa_mem_frag_rx(uint64_t handle, uint32_t recv_length);
90+
bool ffa_mem_relinquish(void);
91+
bool ffa_rx_release(void);
92+
bool memory_relinquish(struct ffa_mem_relinquish_descriptor *m, uint64_t handle,
93+
ffa_endpoint_id16_t id);
94+
bool ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages);
95+
bool memory_retrieve(struct mailbox *mb,
96+
struct ffa_mtd **retrieved,
97+
uint64_t handle, ffa_endpoint_id16_t sender,
98+
ffa_endpoint_id16_t *receivers, uint32_t receiver_count,
99+
ffa_mtd_flag32_t flags, uint32_t *frag_length,
100+
uint32_t *total_length);
101+
102+
smc_args_t ffa_msg_send_direct_req(ffa_endpoint_id16_t sender,
103+
ffa_endpoint_id16_t receiver,
104+
uint32_t arg3,
105+
uint32_t arg4,
106+
uint32_t arg5,
107+
uint32_t arg6,
108+
uint32_t arg7);
109+
smc_args_t *ffa_msg_send_direct_resp(ffa_endpoint_id16_t sender,
110+
ffa_endpoint_id16_t receiver,
111+
uint32_t arg3,
112+
uint32_t arg4,
113+
uint32_t arg5,
114+
uint32_t arg6,
115+
uint32_t arg7);
116+
#endif /* FFA_HELPERS_H */

‎bl32/tsp/tsp.mk

+2-1
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,8 @@
77
INCLUDES += -Iinclude/bl32/tsp
88

99
ifeq (${SPMC_AT_EL3},1)
10-
BL32_SOURCES += bl32/tsp/tsp_ffa_main.c
10+
BL32_SOURCES += bl32/tsp/tsp_ffa_main.c \
11+
bl32/tsp/ffa_helpers.c
1112
else
1213
BL32_SOURCES += bl32/tsp/tsp_main.c
1314
endif

0 commit comments

Comments
 (0)