1 /*
2 * Copyright (c) 2018-2021, Arm Limited. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #if SPMC_AT_EL3
8
9 #include "ffa_helpers.h"
10 #include "tsp_private.h"
11
12 #include <common/debug.h>
13 #include <services/ffa_svc.h>
14
15 /**
16 * Initialises the header of the given `ffa_memory_region`, not including the
17 * composite memory region offset.
18 */
ffa_memory_region_init_header(struct ffa_memory_region * memory_region,ffa_id_t sender,ffa_memory_attributes_t attributes,ffa_memory_region_flags_t flags,ffa_memory_handle_t handle,uint32_t tag,ffa_id_t receiver,ffa_memory_access_permissions_t permissions)19 static void ffa_memory_region_init_header(
20 struct ffa_memory_region *memory_region, ffa_id_t sender,
21 ffa_memory_attributes_t attributes, ffa_memory_region_flags_t flags,
22 ffa_memory_handle_t handle, uint32_t tag, ffa_id_t receiver,
23 ffa_memory_access_permissions_t permissions)
24 {
25 memory_region->sender = sender;
26 memory_region->attributes = attributes;
27 memory_region->reserved_0 = 0;
28 memory_region->flags = flags;
29 memory_region->handle = handle;
30 memory_region->tag = tag;
31 memory_region->reserved_1 = 0;
32 memory_region->receiver_count = 1;
33 memory_region->receivers[0].receiver_permissions.receiver = receiver;
34 memory_region->receivers[0].receiver_permissions.permissions =
35 permissions;
36 memory_region->receivers[0].receiver_permissions.flags = 0;
37 memory_region->receivers[0].reserved_0 = 0;
38 }
39
40 /**
41 * Initialises the given `ffa_memory_region` to be used for an
42 * `FFA_MEM_RETRIEVE_REQ` by the receiver of a memory transaction.
43 *
44 * Returns the size of the message written.
45 */
ffa_memory_retrieve_request_init(struct ffa_memory_region * memory_region,ffa_memory_handle_t handle,ffa_id_t sender,ffa_id_t receiver,uint32_t tag,ffa_memory_region_flags_t flags,enum ffa_data_access data_access,enum ffa_instruction_access instruction_access,enum ffa_memory_type type,enum ffa_memory_cacheability cacheability,enum ffa_memory_shareability shareability)46 uint32_t ffa_memory_retrieve_request_init(
47 struct ffa_memory_region *memory_region, ffa_memory_handle_t handle,
48 ffa_id_t sender, ffa_id_t receiver, uint32_t tag,
49 ffa_memory_region_flags_t flags, enum ffa_data_access data_access,
50 enum ffa_instruction_access instruction_access,
51 enum ffa_memory_type type, enum ffa_memory_cacheability cacheability,
52 enum ffa_memory_shareability shareability)
53 {
54 ffa_memory_access_permissions_t permissions = 0;
55 ffa_memory_attributes_t attributes = 0;
56
57 /* Set memory region's permissions. */
58 ffa_set_data_access_attr(&permissions, data_access);
59 ffa_set_instruction_access_attr(&permissions, instruction_access);
60
61 /* Set memory region's page attributes. */
62 ffa_set_memory_type_attr(&attributes, type);
63 ffa_set_memory_cacheability_attr(&attributes, cacheability);
64 ffa_set_memory_shareability_attr(&attributes, shareability);
65
66 ffa_memory_region_init_header(memory_region, sender, attributes, flags,
67 handle, tag, receiver, permissions);
68 /*
69 * Offset 0 in this case means that the hypervisor should allocate the
70 * address ranges. This is the only configuration supported by Hafnium,
71 * as it enforces 1:1 mappings in the stage 2 page tables.
72 */
73 memory_region->receivers[0].composite_memory_region_offset = 0;
74 memory_region->receivers[0].reserved_0 = 0;
75
76 return sizeof(struct ffa_memory_region) +
77 memory_region->receiver_count * sizeof(struct ffa_memory_access);
78 }
79
80 /* Relinquish access to memory region */
ffa_mem_relinquish(void)81 bool ffa_mem_relinquish(void)
82 {
83 tsp_args_t ret;
84 ret = tsp_smc(FFA_MEM_RELINQUISH, 0, 0, 0, 0, 0, 0, 0);
85 if (ffa_func_id(ret) != FFA_SUCCESS_SMC32) {
86 ERROR("%s failed to relinquish memory! error: (%x) %x\n",
87 __func__, ffa_func_id(ret), ffa_error_code(ret));
88 return -1;
89 }
90 return 0;
91 }
92
93 /* Retrieve memory shared by another partition */
ffa_mem_retrieve_req(uint32_t descriptor_length,uint32_t fragment_length)94 tsp_args_t ffa_mem_retrieve_req(uint32_t descriptor_length,
95 uint32_t fragment_length)
96 {
97 return tsp_smc(FFA_MEM_RETRIEVE_REQ_SMC32,
98 descriptor_length,
99 fragment_length,
100 0, 0, 0, 0, 0);
101 }
102
103 /* Retrieve the next memory descriptor fragment */
ffa_mem_frag_rx(uint64_t handle,uint32_t recv_length)104 tsp_args_t ffa_mem_frag_rx(uint64_t handle, uint32_t recv_length)
105 {
106 return tsp_smc(FFA_MEM_FRAG_RX,
107 FFA_MEM_HANDLE_LOW(handle),
108 FFA_MEM_HANDLE_HIGH(handle),
109 recv_length,
110 0, 0, 0, 0);
111 }
112
113 /* Relinquish the memory region */
memory_relinquish(struct ffa_mem_relinquish * m,uint64_t handle,ffa_id_t id)114 bool memory_relinquish(struct ffa_mem_relinquish *m, uint64_t handle,
115 ffa_id_t id)
116 {
117
118 ffa_mem_relinquish_init(m, handle, 0, id);
119 if (ffa_mem_relinquish()) {
120 return false;
121 }
122
123 return true;
124 }
125
126 /* Query SPMC that the rx buffer of the partition can be released */
ffa_rx_release(void)127 bool ffa_rx_release(void)
128 {
129 tsp_args_t ret;
130 ret = tsp_smc(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
131 return ret._regs[TSP_ARG0] != FFA_SUCCESS_SMC32;
132 }
133
134 /* Map the provided buffers with the SPMC */
135
ffa_rxtx_map(uintptr_t send,uintptr_t recv,uint32_t pages)136 bool ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages)
137 {
138 tsp_args_t ret = {0};
139 ret = tsp_smc(FFA_RXTX_MAP_SMC64, send, recv, pages, 0, 0, 0, 0);
140 return ret._regs[0] != FFA_SUCCESS_SMC32;
141 }
142
143 #endif /*SPMC_AT_EL3 */
144