J-Alves | 7581c38 | 2020-05-07 18:34:20 +0100 | [diff] [blame] | 1 | /* |
Daniel Boulby | 8aa994c | 2022-01-05 19:44:30 +0000 | [diff] [blame] | 2 | * Copyright (c) 2018-2022, Arm Limited. All rights reserved. |
J-Alves | 7581c38 | 2020-05-07 18:34:20 +0100 | [diff] [blame] | 3 | * |
| 4 | * SPDX-License-Identifier: BSD-3-Clause |
| 5 | */ |
| 6 | |
| 7 | #ifndef FFA_HELPERS_H |
| 8 | #define FFA_HELPERS_H |
| 9 | |
J-Alves | 8f08a05 | 2020-05-26 17:14:40 +0100 | [diff] [blame] | 10 | #include <ffa_svc.h> |
J-Alves | 7581c38 | 2020-05-07 18:34:20 +0100 | [diff] [blame] | 11 | #include <tftf_lib.h> |
| 12 | #include <utils_def.h> |
| 13 | |
| 14 | /* This error code must be different to the ones used by FFA */ |
| 15 | #define FFA_TFTF_ERROR -42 |
| 16 | |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 17 | typedef unsigned short ffa_id_t; |
J-Alves | 5aecd98 | 2020-06-11 10:25:33 +0100 | [diff] [blame] | 18 | typedef unsigned short ffa_vm_count_t; |
| 19 | typedef unsigned short ffa_vcpu_count_t; |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 20 | typedef uint64_t ffa_memory_handle_t; |
| 21 | /** Flags to indicate properties of receivers during memory region retrieval. */ |
| 22 | typedef uint8_t ffa_memory_receiver_flags_t; |
J-Alves | 5aecd98 | 2020-06-11 10:25:33 +0100 | [diff] [blame] | 23 | |
J-Alves | d708c03 | 2020-11-19 12:14:21 +0000 | [diff] [blame] | 24 | struct ffa_uuid { |
Raghu Krishnamurthy | ab5321a | 2023-04-23 16:14:28 -0700 | [diff] [blame^] | 25 | uint32_t uuid[4]; |
J-Alves | d708c03 | 2020-11-19 12:14:21 +0000 | [diff] [blame] | 26 | }; |
| 27 | |
J-Alves | da3e6d4 | 2022-01-25 10:19:56 +0000 | [diff] [blame] | 28 | /** Length in bytes of the name in boot information descriptor. */ |
| 29 | #define FFA_BOOT_INFO_NAME_LEN 16 |
| 30 | |
| 31 | /** |
| 32 | * The FF-A boot info descriptor, as defined in table 5.8 of section 5.4.1, of |
| 33 | * the FF-A v1.1 EAC0 specification. |
| 34 | */ |
| 35 | struct ffa_boot_info_desc { |
| 36 | char name[FFA_BOOT_INFO_NAME_LEN]; |
| 37 | uint8_t type; |
| 38 | uint8_t reserved; |
| 39 | uint16_t flags; |
| 40 | uint32_t size; |
| 41 | uint64_t content; |
| 42 | }; |
| 43 | |
| 44 | /** FF-A boot information type mask. */ |
| 45 | #define FFA_BOOT_INFO_TYPE_SHIFT 7 |
| 46 | #define FFA_BOOT_INFO_TYPE_MASK (0x1U << FFA_BOOT_INFO_TYPE_SHIFT) |
| 47 | #define FFA_BOOT_INFO_TYPE_STD 0U |
| 48 | #define FFA_BOOT_INFO_TYPE_IMPDEF 1U |
| 49 | |
| 50 | /** Standard boot info type IDs. */ |
| 51 | #define FFA_BOOT_INFO_TYPE_ID_MASK 0x7FU |
| 52 | #define FFA_BOOT_INFO_TYPE_ID_FDT 0U |
| 53 | #define FFA_BOOT_INFO_TYPE_ID_HOB 1U |
| 54 | |
| 55 | /** FF-A Boot Info descriptors flags. */ |
| 56 | #define FFA_BOOT_INFO_FLAG_MBZ_MASK 0xFFF0U |
| 57 | |
| 58 | /** Bits [1:0] encode the format of the name field in ffa_boot_info_desc. */ |
| 59 | #define FFA_BOOT_INFO_FLAG_NAME_FORMAT_SHIFT 0U |
| 60 | #define FFA_BOOT_INFO_FLAG_NAME_FORMAT_MASK \ |
| 61 | (0x3U << FFA_BOOT_INFO_FLAG_NAME_FORMAT_SHIFT) |
| 62 | #define FFA_BOOT_INFO_FLAG_NAME_FORMAT_STRING 0x0U |
| 63 | #define FFA_BOOT_INFO_FLAG_NAME_FORMAT_UUID 0x1U |
| 64 | |
| 65 | /** Bits [3:2] encode the format of the content field in ffa_boot_info_desc. */ |
| 66 | #define FFA_BOOT_INFO_FLAG_CONTENT_FORMAT_SHIFT 2 |
| 67 | #define FFA_BOOT_INFO_FLAG_CONTENT_FORMAT_MASK \ |
| 68 | (0x3U << FFA_BOOT_INFO_FLAG_CONTENT_FORMAT_SHIFT) |
| 69 | #define FFA_BOOT_INFO_FLAG_CONTENT_FORMAT_VALUE 0x1U |
| 70 | #define FFA_BOOT_INFO_FLAG_CONTENT_FORMAT_ADDR 0x0U |
| 71 | |
| 72 | static inline uint16_t ffa_boot_info_content_format( |
| 73 | struct ffa_boot_info_desc *desc) |
| 74 | { |
| 75 | return (desc->flags & FFA_BOOT_INFO_FLAG_CONTENT_FORMAT_MASK) >> |
| 76 | FFA_BOOT_INFO_FLAG_CONTENT_FORMAT_SHIFT; |
| 77 | } |
| 78 | |
| 79 | static inline uint16_t ffa_boot_info_name_format( |
| 80 | struct ffa_boot_info_desc *desc) |
| 81 | { |
| 82 | return (desc->flags & FFA_BOOT_INFO_FLAG_NAME_FORMAT_MASK) >> |
| 83 | FFA_BOOT_INFO_FLAG_NAME_FORMAT_SHIFT; |
| 84 | } |
| 85 | |
| 86 | static inline uint8_t ffa_boot_info_type_id(struct ffa_boot_info_desc *desc) |
| 87 | { |
| 88 | return desc->type & FFA_BOOT_INFO_TYPE_ID_MASK; |
| 89 | } |
| 90 | |
| 91 | static inline uint8_t ffa_boot_info_type(struct ffa_boot_info_desc *desc) |
| 92 | { |
| 93 | return (desc->type & FFA_BOOT_INFO_TYPE_MASK) >> |
| 94 | FFA_BOOT_INFO_TYPE_SHIFT; |
| 95 | } |
| 96 | |
| 97 | /** Length in bytes of the signature in the boot descriptor. */ |
| 98 | #define FFA_BOOT_INFO_HEADER_SIGNATURE_LEN 4 |
| 99 | |
| 100 | /** |
| 101 | * The FF-A boot information header, as defined in table 5.9 of section 5.4.2, |
| 102 | * of the FF-A v1.1 EAC0 specification. |
| 103 | */ |
| 104 | struct ffa_boot_info_header { |
| 105 | uint32_t signature; |
| 106 | uint32_t version; |
| 107 | uint32_t info_blob_size; |
| 108 | uint32_t desc_size; |
| 109 | uint32_t desc_count; |
| 110 | uint32_t desc_offset; |
| 111 | uint64_t reserved; |
| 112 | struct ffa_boot_info_desc boot_info[]; |
| 113 | }; |
| 114 | |
J-Alves | 7581c38 | 2020-05-07 18:34:20 +0100 | [diff] [blame] | 115 | #ifndef __ASSEMBLY__ |
| 116 | |
J-Alves | 18c2805 | 2021-03-09 09:58:53 +0000 | [diff] [blame] | 117 | #include <cassert.h> |
J-Alves | 7581c38 | 2020-05-07 18:34:20 +0100 | [diff] [blame] | 118 | #include <stdint.h> |
| 119 | |
J-Alves | 4439ece | 2021-11-05 11:52:54 +0000 | [diff] [blame] | 120 | /** |
| 121 | * FF-A Feature ID, to be used with interface FFA_FEATURES. |
| 122 | * As defined in the FF-A v1.1 Beta specification, table 13.10, in section |
| 123 | * 13.2. |
| 124 | */ |
| 125 | |
| 126 | /** Query interrupt ID of Notification Pending Interrupt. */ |
| 127 | #define FFA_FEATURE_NPI 0x1U |
| 128 | |
| 129 | /** Query interrupt ID of Schedule Receiver Interrupt. */ |
| 130 | #define FFA_FEATURE_SRI 0x2U |
| 131 | |
| 132 | /** Query interrupt ID of the Managed Exit Interrupt. */ |
| 133 | #define FFA_FEATURE_MEI 0x3U |
| 134 | |
Max Shvetsov | 0b7d25f | 2021-03-05 13:46:42 +0000 | [diff] [blame] | 135 | /** Partition property: partition supports receipt of direct requests. */ |
Kathleen Capella | 7774d6e | 2022-11-23 19:06:21 -0500 | [diff] [blame] | 136 | #define FFA_PARTITION_DIRECT_REQ_RECV (UINT32_C(1) << 0) |
Max Shvetsov | 0b7d25f | 2021-03-05 13:46:42 +0000 | [diff] [blame] | 137 | |
| 138 | /** Partition property: partition can send direct requests. */ |
Kathleen Capella | 7774d6e | 2022-11-23 19:06:21 -0500 | [diff] [blame] | 139 | #define FFA_PARTITION_DIRECT_REQ_SEND (UINT32_C(1) << 1) |
Max Shvetsov | 0b7d25f | 2021-03-05 13:46:42 +0000 | [diff] [blame] | 140 | |
| 141 | /** Partition property: partition can send and receive indirect messages. */ |
Kathleen Capella | 7774d6e | 2022-11-23 19:06:21 -0500 | [diff] [blame] | 142 | #define FFA_PARTITION_INDIRECT_MSG (UINT32_C(1) << 2) |
Max Shvetsov | 0b7d25f | 2021-03-05 13:46:42 +0000 | [diff] [blame] | 143 | |
J-Alves | 4d05dec | 2021-11-02 11:52:27 +0000 | [diff] [blame] | 144 | /** Partition property: partition can receive notifications. */ |
Kathleen Capella | 7774d6e | 2022-11-23 19:06:21 -0500 | [diff] [blame] | 145 | #define FFA_PARTITION_NOTIFICATION (UINT32_C(1) << 3) |
J-Alves | 4d05dec | 2021-11-02 11:52:27 +0000 | [diff] [blame] | 146 | |
Kathleen Capella | 7774d6e | 2022-11-23 19:06:21 -0500 | [diff] [blame] | 147 | /** Partition property: partition runs in the AArch64 execution state. */ |
| 148 | #define FFA_PARTITION_AARCH64_EXEC (UINT32_C(1) << 8) |
| 149 | |
| 150 | /** Partition info descriptor as defined in FF-A v1.1 EAC0 Table 13.37 */ |
Max Shvetsov | c32f478 | 2020-06-23 09:41:15 +0100 | [diff] [blame] | 151 | struct ffa_partition_info { |
| 152 | /** The ID of the VM the information is about */ |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 153 | ffa_id_t id; |
Max Shvetsov | c32f478 | 2020-06-23 09:41:15 +0100 | [diff] [blame] | 154 | /** The number of execution contexts implemented by the partition */ |
| 155 | uint16_t exec_context; |
| 156 | /** The Partition's properties, e.g. supported messaging methods */ |
| 157 | uint32_t properties; |
Daniel Boulby | 8aa994c | 2022-01-05 19:44:30 +0000 | [diff] [blame] | 158 | /** The uuid of the partition */ |
| 159 | struct ffa_uuid uuid; |
Max Shvetsov | c32f478 | 2020-06-23 09:41:15 +0100 | [diff] [blame] | 160 | }; |
| 161 | |
Daniel Boulby | 2ac55f2 | 2022-01-21 12:08:08 +0000 | [diff] [blame] | 162 | /** |
Kathleen Capella | 7774d6e | 2022-11-23 19:06:21 -0500 | [diff] [blame] | 163 | * Bits[31:3] of partition properties must be zero for FF-A v1.0. |
| 164 | * This corresponds to table 8.25 "Partition information descriptor" |
| 165 | * in DEN0077A FF-A 1.0 REL specification. |
| 166 | */ |
| 167 | #define FFA_PARTITION_v1_0_RES_MASK (~(UINT32_C(0x7))) |
| 168 | |
| 169 | /** |
Daniel Boulby | 2ac55f2 | 2022-01-21 12:08:08 +0000 | [diff] [blame] | 170 | * Partition info descriptor as defined in Table 8.25 of the v1.0 |
Kathleen Capella | 7774d6e | 2022-11-23 19:06:21 -0500 | [diff] [blame] | 171 | * FF-A Specification (DEN0077A). |
Daniel Boulby | 2ac55f2 | 2022-01-21 12:08:08 +0000 | [diff] [blame] | 172 | */ |
| 173 | struct ffa_partition_info_v1_0 { |
| 174 | /** The ID of the VM the information is about */ |
| 175 | ffa_id_t id; |
| 176 | /** The number of execution contexts implemented by the partition */ |
| 177 | uint16_t exec_context; |
| 178 | /** The Partition's properties, e.g. supported messaging methods */ |
| 179 | uint32_t properties; |
| 180 | }; |
| 181 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 182 | struct ffa_value { |
| 183 | u_register_t fid; |
| 184 | u_register_t arg1; |
| 185 | u_register_t arg2; |
| 186 | u_register_t arg3; |
| 187 | u_register_t arg4; |
| 188 | u_register_t arg5; |
| 189 | u_register_t arg6; |
| 190 | u_register_t arg7; |
Raghu Krishnamurthy | ab5321a | 2023-04-23 16:14:28 -0700 | [diff] [blame^] | 191 | u_register_t arg8; |
| 192 | u_register_t arg9; |
| 193 | u_register_t arg10; |
| 194 | u_register_t arg11; |
| 195 | u_register_t arg12; |
| 196 | u_register_t arg13; |
| 197 | u_register_t arg14; |
| 198 | u_register_t arg15; |
| 199 | u_register_t arg16; |
| 200 | u_register_t arg17; |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 201 | }; |
| 202 | |
| 203 | /* Function to make an SMC or SVC service call depending on the exception |
| 204 | * level of the SP. |
| 205 | */ |
| 206 | struct ffa_value ffa_service_call(struct ffa_value *args); |
| 207 | |
| 208 | /* |
| 209 | * Functions to trigger a service call. |
| 210 | * |
| 211 | * The arguments to pass through the service call must be stored in the |
| 212 | * ffa_value structure. The return values of the service call will be stored |
| 213 | * in the same structure (overriding the input arguments). |
| 214 | * |
| 215 | * Return the first return value. It is equivalent to args.fid but is also |
| 216 | * provided as the return value for convenience. |
| 217 | */ |
| 218 | u_register_t ffa_svc(struct ffa_value *args); |
| 219 | u_register_t ffa_smc(struct ffa_value *args); |
| 220 | |
| 221 | static inline uint32_t ffa_func_id(struct ffa_value val) |
J-Alves | f156ae9 | 2021-10-08 12:10:05 +0100 | [diff] [blame] | 222 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 223 | return (uint32_t)val.fid; |
J-Alves | 6cb21d9 | 2021-01-07 15:18:12 +0000 | [diff] [blame] | 224 | } |
| 225 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 226 | static inline int32_t ffa_error_code(struct ffa_value val) |
J-Alves | f156ae9 | 2021-10-08 12:10:05 +0100 | [diff] [blame] | 227 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 228 | return (int32_t)val.arg2; |
J-Alves | 6cb21d9 | 2021-01-07 15:18:12 +0000 | [diff] [blame] | 229 | } |
| 230 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 231 | static inline ffa_id_t ffa_endpoint_id(struct ffa_value val) { |
| 232 | return (ffa_id_t)val.arg2 & 0xffff; |
Daniel Boulby | 198deda | 2021-03-03 11:35:25 +0000 | [diff] [blame] | 233 | } |
| 234 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 235 | static inline uint32_t ffa_partition_info_count(struct ffa_value val) |
Daniel Boulby | 2ac55f2 | 2022-01-21 12:08:08 +0000 | [diff] [blame] | 236 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 237 | return (uint32_t)val.arg2; |
Daniel Boulby | 2ac55f2 | 2022-01-21 12:08:08 +0000 | [diff] [blame] | 238 | } |
| 239 | |
Daniel Boulby | 07d751e | 2022-05-30 17:32:00 +0100 | [diff] [blame] | 240 | static inline uint32_t ffa_partition_info_desc_size(struct ffa_value val) |
| 241 | { |
| 242 | return (uint32_t)val.arg3; |
| 243 | } |
| 244 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 245 | static inline uint32_t ffa_feature_intid(struct ffa_value val) |
J-Alves | 4439ece | 2021-11-05 11:52:54 +0000 | [diff] [blame] | 246 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 247 | return (uint32_t)val.arg2; |
J-Alves | 4439ece | 2021-11-05 11:52:54 +0000 | [diff] [blame] | 248 | } |
| 249 | |
Raghu Krishnamurthy | ab5321a | 2023-04-23 16:14:28 -0700 | [diff] [blame^] | 250 | static inline uint16_t ffa_partition_info_regs_get_last_idx( |
| 251 | struct ffa_value args) |
| 252 | { |
| 253 | return args.arg2 & 0xFFFF; |
| 254 | } |
| 255 | |
| 256 | static inline uint16_t ffa_partition_info_regs_get_curr_idx( |
| 257 | struct ffa_value args) |
| 258 | { |
| 259 | return (args.arg2 >> 16) & 0xFFFF; |
| 260 | } |
| 261 | |
| 262 | static inline uint16_t ffa_partition_info_regs_get_tag(struct ffa_value args) |
| 263 | { |
| 264 | return (args.arg2 >> 32) & 0xFFFF; |
| 265 | } |
| 266 | |
| 267 | static inline uint16_t ffa_partition_info_regs_get_desc_size( |
| 268 | struct ffa_value args) |
| 269 | { |
| 270 | return (args.arg2 >> 48); |
| 271 | } |
| 272 | |
| 273 | static inline uint32_t ffa_partition_info_regs_partition_count( |
| 274 | struct ffa_value args) |
| 275 | { |
| 276 | return ffa_partition_info_regs_get_last_idx(args) + 1; |
| 277 | } |
| 278 | |
| 279 | static inline uint32_t ffa_partition_info_regs_entry_count( |
| 280 | struct ffa_value args, uint16_t start_idx) |
| 281 | { |
| 282 | return (ffa_partition_info_regs_get_curr_idx(args) - start_idx + 1); |
| 283 | } |
| 284 | |
| 285 | static inline uint16_t ffa_partition_info_regs_entry_size( |
| 286 | struct ffa_value args) |
| 287 | { |
| 288 | return (args.arg2 >> 48) & 0xFFFFU; |
| 289 | } |
| 290 | |
J-Alves | 18c2805 | 2021-03-09 09:58:53 +0000 | [diff] [blame] | 291 | typedef uint64_t ffa_notification_bitmap_t; |
| 292 | |
| 293 | #define FFA_NOTIFICATION(ID) (UINT64_C(1) << ID) |
| 294 | |
| 295 | #define MAX_FFA_NOTIFICATIONS UINT32_C(64) |
| 296 | |
| 297 | #define FFA_NOTIFICATIONS_FLAG_PER_VCPU UINT32_C(0x1 << 0) |
| 298 | |
J-Alves | b0cb5d0 | 2021-07-08 11:19:33 +0100 | [diff] [blame] | 299 | /** Flag to delay Schedule Receiver Interrupt. */ |
| 300 | #define FFA_NOTIFICATIONS_FLAG_DELAY_SRI UINT32_C(0x1 << 1) |
| 301 | |
J-Alves | 18c2805 | 2021-03-09 09:58:53 +0000 | [diff] [blame] | 302 | #define FFA_NOTIFICATIONS_FLAGS_VCPU_ID(id) UINT32_C((id & 0xFFFF) << 16) |
| 303 | |
J-Alves | f156ae9 | 2021-10-08 12:10:05 +0100 | [diff] [blame] | 304 | #define FFA_NOTIFICATIONS_FLAG_BITMAP_SP UINT32_C(0x1 << 0) |
| 305 | #define FFA_NOTIFICATIONS_FLAG_BITMAP_VM UINT32_C(0x1 << 1) |
| 306 | #define FFA_NOTIFICATIONS_FLAG_BITMAP_SPM UINT32_C(0x1 << 2) |
| 307 | #define FFA_NOTIFICATIONS_FLAG_BITMAP_HYP UINT32_C(0x1 << 3) |
| 308 | |
J-Alves | 269118a | 2021-09-22 09:46:11 +0100 | [diff] [blame] | 309 | /** |
| 310 | * The following is an SGI ID, that the SPMC configures as non-secure, as |
| 311 | * suggested by the FF-A v1.1 specification, in section 9.4.1. |
| 312 | */ |
| 313 | #define FFA_SCHEDULE_RECEIVER_INTERRUPT_ID 8 |
| 314 | |
J-Alves | f156ae9 | 2021-10-08 12:10:05 +0100 | [diff] [blame] | 315 | #define FFA_NOTIFICATIONS_BITMAP(lo, hi) \ |
| 316 | (ffa_notification_bitmap_t)(lo) | \ |
| 317 | (((ffa_notification_bitmap_t)hi << 32) & 0xFFFFFFFF00000000ULL) |
| 318 | |
| 319 | #define FFA_NOTIFICATIONS_FLAGS_VCPU_ID(id) UINT32_C((id & 0xFFFF) << 16) |
| 320 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 321 | static inline ffa_notification_bitmap_t ffa_notifications_get_from_sp( |
| 322 | struct ffa_value val) |
J-Alves | f156ae9 | 2021-10-08 12:10:05 +0100 | [diff] [blame] | 323 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 324 | return FFA_NOTIFICATIONS_BITMAP(val.arg2, val.arg3); |
J-Alves | f156ae9 | 2021-10-08 12:10:05 +0100 | [diff] [blame] | 325 | } |
| 326 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 327 | static inline ffa_notification_bitmap_t ffa_notifications_get_from_vm( |
| 328 | struct ffa_value val) |
J-Alves | f156ae9 | 2021-10-08 12:10:05 +0100 | [diff] [blame] | 329 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 330 | return FFA_NOTIFICATIONS_BITMAP(val.arg4, val.arg5); |
J-Alves | f156ae9 | 2021-10-08 12:10:05 +0100 | [diff] [blame] | 331 | } |
| 332 | |
J-Alves | 5bce250 | 2021-06-14 14:27:45 +0100 | [diff] [blame] | 333 | /* |
| 334 | * FFA_NOTIFICATION_INFO_GET is a SMC64 interface. |
| 335 | * The following macros are defined for SMC64 implementation. |
| 336 | */ |
| 337 | #define FFA_NOTIFICATIONS_INFO_GET_MAX_IDS 20U |
| 338 | |
| 339 | #define FFA_NOTIFICATIONS_INFO_GET_FLAG_MORE_PENDING UINT64_C(0x1) |
| 340 | |
| 341 | #define FFA_NOTIFICATIONS_LISTS_COUNT_SHIFT 0x7U |
| 342 | #define FFA_NOTIFICATIONS_LISTS_COUNT_MASK 0x1FU |
| 343 | #define FFA_NOTIFICATIONS_LIST_SHIFT(l) (2 * (l - 1) + 12) |
| 344 | #define FFA_NOTIFICATIONS_LIST_SIZE_MASK 0x3U |
| 345 | |
| 346 | static inline uint32_t ffa_notifications_info_get_lists_count( |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 347 | struct ffa_value ret) |
J-Alves | 5bce250 | 2021-06-14 14:27:45 +0100 | [diff] [blame] | 348 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 349 | return (uint32_t)(ret.arg2 >> FFA_NOTIFICATIONS_LISTS_COUNT_SHIFT) |
J-Alves | 5bce250 | 2021-06-14 14:27:45 +0100 | [diff] [blame] | 350 | & FFA_NOTIFICATIONS_LISTS_COUNT_MASK; |
| 351 | } |
| 352 | |
| 353 | static inline uint32_t ffa_notifications_info_get_list_size( |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 354 | struct ffa_value ret, uint32_t list) |
J-Alves | 5bce250 | 2021-06-14 14:27:45 +0100 | [diff] [blame] | 355 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 356 | return (uint32_t)(ret.arg2 >> FFA_NOTIFICATIONS_LIST_SHIFT(list)) & |
J-Alves | 5bce250 | 2021-06-14 14:27:45 +0100 | [diff] [blame] | 357 | FFA_NOTIFICATIONS_LIST_SIZE_MASK; |
| 358 | } |
| 359 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 360 | static inline bool ffa_notifications_info_get_more_pending(struct ffa_value ret) |
J-Alves | 5bce250 | 2021-06-14 14:27:45 +0100 | [diff] [blame] | 361 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 362 | return (ret.arg2 & FFA_NOTIFICATIONS_INFO_GET_FLAG_MORE_PENDING) != 0U; |
J-Alves | 5bce250 | 2021-06-14 14:27:45 +0100 | [diff] [blame] | 363 | } |
| 364 | |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 365 | enum ffa_data_access { |
| 366 | FFA_DATA_ACCESS_NOT_SPECIFIED, |
| 367 | FFA_DATA_ACCESS_RO, |
| 368 | FFA_DATA_ACCESS_RW, |
| 369 | FFA_DATA_ACCESS_RESERVED, |
| 370 | }; |
| 371 | |
| 372 | enum ffa_instruction_access { |
| 373 | FFA_INSTRUCTION_ACCESS_NOT_SPECIFIED, |
| 374 | FFA_INSTRUCTION_ACCESS_NX, |
| 375 | FFA_INSTRUCTION_ACCESS_X, |
| 376 | FFA_INSTRUCTION_ACCESS_RESERVED, |
| 377 | }; |
| 378 | |
| 379 | enum ffa_memory_type { |
| 380 | FFA_MEMORY_NOT_SPECIFIED_MEM, |
| 381 | FFA_MEMORY_DEVICE_MEM, |
| 382 | FFA_MEMORY_NORMAL_MEM, |
| 383 | }; |
| 384 | |
| 385 | enum ffa_memory_cacheability { |
| 386 | FFA_MEMORY_CACHE_RESERVED = 0x0, |
| 387 | FFA_MEMORY_CACHE_NON_CACHEABLE = 0x1, |
| 388 | FFA_MEMORY_CACHE_RESERVED_1 = 0x2, |
| 389 | FFA_MEMORY_CACHE_WRITE_BACK = 0x3, |
| 390 | FFA_MEMORY_DEV_NGNRNE = 0x0, |
| 391 | FFA_MEMORY_DEV_NGNRE = 0x1, |
| 392 | FFA_MEMORY_DEV_NGRE = 0x2, |
| 393 | FFA_MEMORY_DEV_GRE = 0x3, |
| 394 | }; |
| 395 | |
| 396 | enum ffa_memory_shareability { |
| 397 | FFA_MEMORY_SHARE_NON_SHAREABLE, |
| 398 | FFA_MEMORY_SHARE_RESERVED, |
| 399 | FFA_MEMORY_OUTER_SHAREABLE, |
| 400 | FFA_MEMORY_INNER_SHAREABLE, |
| 401 | }; |
| 402 | |
| 403 | typedef uint8_t ffa_memory_access_permissions_t; |
| 404 | |
| 405 | /** |
J-Alves | b42d17f | 2022-07-04 12:42:13 +0100 | [diff] [blame] | 406 | * This corresponds to table 10.18 of the FF-A v1.1 EAC0 specification, "Memory |
| 407 | * region attributes descriptor". |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 408 | */ |
J-Alves | b42d17f | 2022-07-04 12:42:13 +0100 | [diff] [blame] | 409 | typedef uint16_t ffa_memory_attributes_t; |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 410 | |
| 411 | #define FFA_DATA_ACCESS_OFFSET (0x0U) |
| 412 | #define FFA_DATA_ACCESS_MASK ((0x3U) << FFA_DATA_ACCESS_OFFSET) |
| 413 | |
| 414 | #define FFA_INSTRUCTION_ACCESS_OFFSET (0x2U) |
| 415 | #define FFA_INSTRUCTION_ACCESS_MASK ((0x3U) << FFA_INSTRUCTION_ACCESS_OFFSET) |
| 416 | |
| 417 | #define FFA_MEMORY_TYPE_OFFSET (0x4U) |
| 418 | #define FFA_MEMORY_TYPE_MASK ((0x3U) << FFA_MEMORY_TYPE_OFFSET) |
| 419 | |
| 420 | #define FFA_MEMORY_CACHEABILITY_OFFSET (0x2U) |
| 421 | #define FFA_MEMORY_CACHEABILITY_MASK ((0x3U) << FFA_MEMORY_CACHEABILITY_OFFSET) |
| 422 | |
| 423 | #define FFA_MEMORY_SHAREABILITY_OFFSET (0x0U) |
| 424 | #define FFA_MEMORY_SHAREABILITY_MASK ((0x3U) << FFA_MEMORY_SHAREABILITY_OFFSET) |
| 425 | |
| 426 | #define ATTR_FUNCTION_SET(name, container_type, offset, mask) \ |
| 427 | static inline void ffa_set_##name##_attr(container_type *attr, \ |
| 428 | const enum ffa_##name perm) \ |
| 429 | { \ |
| 430 | *attr = (*attr & ~(mask)) | ((perm << offset) & mask); \ |
| 431 | } |
| 432 | |
| 433 | #define ATTR_FUNCTION_GET(name, container_type, offset, mask) \ |
| 434 | static inline enum ffa_##name ffa_get_##name##_attr( \ |
| 435 | container_type attr) \ |
| 436 | { \ |
| 437 | return (enum ffa_##name)((attr & mask) >> offset); \ |
| 438 | } |
| 439 | |
| 440 | ATTR_FUNCTION_SET(data_access, ffa_memory_access_permissions_t, |
| 441 | FFA_DATA_ACCESS_OFFSET, FFA_DATA_ACCESS_MASK) |
| 442 | ATTR_FUNCTION_GET(data_access, ffa_memory_access_permissions_t, |
| 443 | FFA_DATA_ACCESS_OFFSET, FFA_DATA_ACCESS_MASK) |
| 444 | |
| 445 | ATTR_FUNCTION_SET(instruction_access, ffa_memory_access_permissions_t, |
| 446 | FFA_INSTRUCTION_ACCESS_OFFSET, FFA_INSTRUCTION_ACCESS_MASK) |
| 447 | ATTR_FUNCTION_GET(instruction_access, ffa_memory_access_permissions_t, |
| 448 | FFA_INSTRUCTION_ACCESS_OFFSET, FFA_INSTRUCTION_ACCESS_MASK) |
| 449 | |
| 450 | ATTR_FUNCTION_SET(memory_type, ffa_memory_attributes_t, FFA_MEMORY_TYPE_OFFSET, |
| 451 | FFA_MEMORY_TYPE_MASK) |
| 452 | ATTR_FUNCTION_GET(memory_type, ffa_memory_attributes_t, FFA_MEMORY_TYPE_OFFSET, |
| 453 | FFA_MEMORY_TYPE_MASK) |
| 454 | |
| 455 | ATTR_FUNCTION_SET(memory_cacheability, ffa_memory_attributes_t, |
| 456 | FFA_MEMORY_CACHEABILITY_OFFSET, FFA_MEMORY_CACHEABILITY_MASK) |
| 457 | ATTR_FUNCTION_GET(memory_cacheability, ffa_memory_attributes_t, |
| 458 | FFA_MEMORY_CACHEABILITY_OFFSET, FFA_MEMORY_CACHEABILITY_MASK) |
| 459 | |
| 460 | ATTR_FUNCTION_SET(memory_shareability, ffa_memory_attributes_t, |
| 461 | FFA_MEMORY_SHAREABILITY_OFFSET, FFA_MEMORY_SHAREABILITY_MASK) |
| 462 | ATTR_FUNCTION_GET(memory_shareability, ffa_memory_attributes_t, |
| 463 | FFA_MEMORY_SHAREABILITY_OFFSET, FFA_MEMORY_SHAREABILITY_MASK) |
| 464 | |
| 465 | #define FFA_MEMORY_HANDLE_ALLOCATOR_MASK \ |
| 466 | ((ffa_memory_handle_t)(UINT64_C(1) << 63)) |
| 467 | #define FFA_MEMORY_HANDLE_ALLOCATOR_HYPERVISOR \ |
| 468 | ((ffa_memory_handle_t)(UINT64_C(1) << 63)) |
| 469 | #define FFA_MEMORY_HANDLE_INVALID (~UINT64_C(0)) |
| 470 | |
| 471 | /** |
| 472 | * A set of contiguous pages which is part of a memory region. This corresponds |
J-Alves | b42d17f | 2022-07-04 12:42:13 +0100 | [diff] [blame] | 473 | * to table 10.14 of the FF-A v1.1 EAC0 specification, "Constituent memory |
| 474 | * region descriptor". |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 475 | */ |
| 476 | struct ffa_memory_region_constituent { |
| 477 | /** |
| 478 | * The base IPA of the constituent memory region, aligned to 4 kiB page |
| 479 | * size granularity. |
| 480 | */ |
| 481 | void *address; |
| 482 | /** The number of 4 kiB pages in the constituent memory region. */ |
| 483 | uint32_t page_count; |
| 484 | /** Reserved field, must be 0. */ |
| 485 | uint32_t reserved; |
| 486 | }; |
| 487 | |
| 488 | /** |
J-Alves | b42d17f | 2022-07-04 12:42:13 +0100 | [diff] [blame] | 489 | * A set of pages comprising a memory region. This corresponds to table 10.13 of |
| 490 | * the FF-A v1.1 EAC0 specification, "Composite memory region descriptor". |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 491 | */ |
| 492 | struct ffa_composite_memory_region { |
| 493 | /** |
| 494 | * The total number of 4 kiB pages included in this memory region. This |
| 495 | * must be equal to the sum of page counts specified in each |
| 496 | * `ffa_memory_region_constituent`. |
| 497 | */ |
| 498 | uint32_t page_count; |
| 499 | /** |
| 500 | * The number of constituents (`ffa_memory_region_constituent`) |
| 501 | * included in this memory region range. |
| 502 | */ |
| 503 | uint32_t constituent_count; |
| 504 | /** Reserved field, must be 0. */ |
| 505 | uint64_t reserved_0; |
| 506 | /** An array of `constituent_count` memory region constituents. */ |
| 507 | struct ffa_memory_region_constituent constituents[]; |
| 508 | }; |
| 509 | |
| 510 | /** |
| 511 | * This corresponds to table "Memory access permissions descriptor" of the FFA |
| 512 | * 1.0 specification. |
| 513 | */ |
| 514 | struct ffa_memory_region_attributes { |
| 515 | /** The ID of the VM to which the memory is being given or shared. */ |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 516 | ffa_id_t receiver; |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 517 | /** |
| 518 | * The permissions with which the memory region should be mapped in the |
| 519 | * receiver's page table. |
| 520 | */ |
| 521 | ffa_memory_access_permissions_t permissions; |
| 522 | /** |
| 523 | * Flags used during FFA_MEM_RETRIEVE_REQ and FFA_MEM_RETRIEVE_RESP |
| 524 | * for memory regions with multiple borrowers. |
| 525 | */ |
| 526 | ffa_memory_receiver_flags_t flags; |
| 527 | }; |
| 528 | |
| 529 | /** Flags to control the behaviour of a memory sharing transaction. */ |
| 530 | typedef uint32_t ffa_memory_region_flags_t; |
| 531 | |
| 532 | /** |
| 533 | * Clear memory region contents after unmapping it from the sender and before |
| 534 | * mapping it for any receiver. |
| 535 | */ |
| 536 | #define FFA_MEMORY_REGION_FLAG_CLEAR 0x1U |
| 537 | |
| 538 | /** |
| 539 | * Whether the hypervisor may time slice the memory sharing or retrieval |
| 540 | * operation. |
| 541 | */ |
| 542 | #define FFA_MEMORY_REGION_FLAG_TIME_SLICE 0x2U |
| 543 | |
| 544 | /** |
| 545 | * Whether the hypervisor should clear the memory region after the receiver |
| 546 | * relinquishes it or is aborted. |
| 547 | */ |
| 548 | #define FFA_MEMORY_REGION_FLAG_CLEAR_RELINQUISH 0x4U |
| 549 | |
| 550 | #define FFA_MEMORY_REGION_TRANSACTION_TYPE_MASK ((0x3U) << 3) |
| 551 | #define FFA_MEMORY_REGION_TRANSACTION_TYPE_UNSPECIFIED ((0x0U) << 3) |
| 552 | #define FFA_MEMORY_REGION_TRANSACTION_TYPE_SHARE ((0x1U) << 3) |
| 553 | #define FFA_MEMORY_REGION_TRANSACTION_TYPE_LEND ((0x2U) << 3) |
| 554 | #define FFA_MEMORY_REGION_TRANSACTION_TYPE_DONATE ((0x3U) << 3) |
| 555 | |
J-Alves | 0435cae | 2020-11-06 10:49:56 +0000 | [diff] [blame] | 556 | /** The maximum number of recipients a memory region may be sent to. */ |
| 557 | #define MAX_MEM_SHARE_RECIPIENTS 1U |
| 558 | |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 559 | /** |
| 560 | * This corresponds to table "Endpoint memory access descriptor" of the FFA 1.0 |
| 561 | * specification. |
| 562 | */ |
| 563 | struct ffa_memory_access { |
| 564 | struct ffa_memory_region_attributes receiver_permissions; |
| 565 | /** |
| 566 | * Offset in bytes from the start of the outer `ffa_memory_region` to |
| 567 | * an `ffa_composite_memory_region` struct. |
| 568 | */ |
| 569 | uint32_t composite_memory_region_offset; |
| 570 | uint64_t reserved_0; |
| 571 | }; |
| 572 | |
| 573 | /** |
| 574 | * Information about a set of pages which are being shared. This corresponds to |
J-Alves | b42d17f | 2022-07-04 12:42:13 +0100 | [diff] [blame] | 575 | * table 10.20 of the FF-A v1.1 EAC0 specification, "Lend, donate or share |
| 576 | * memory transaction descriptor". Note that it is also used for retrieve |
| 577 | * requests and responses. |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 578 | */ |
| 579 | struct ffa_memory_region { |
| 580 | /** |
| 581 | * The ID of the VM which originally sent the memory region, i.e. the |
| 582 | * owner. |
| 583 | */ |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 584 | ffa_id_t sender; |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 585 | ffa_memory_attributes_t attributes; |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 586 | /** Flags to control behaviour of the transaction. */ |
| 587 | ffa_memory_region_flags_t flags; |
| 588 | ffa_memory_handle_t handle; |
| 589 | /** |
| 590 | * An implementation defined value associated with the receiver and the |
| 591 | * memory region. |
| 592 | */ |
| 593 | uint64_t tag; |
J-Alves | b42d17f | 2022-07-04 12:42:13 +0100 | [diff] [blame] | 594 | /** Size of the memory access descriptor. */ |
| 595 | uint32_t memory_access_desc_size; |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 596 | /** |
| 597 | * The number of `ffa_memory_access` entries included in this |
| 598 | * transaction. |
| 599 | */ |
| 600 | uint32_t receiver_count; |
| 601 | /** |
J-Alves | b42d17f | 2022-07-04 12:42:13 +0100 | [diff] [blame] | 602 | * Offset of the 'receivers' field, which relates to the memory access |
| 603 | * descriptors. |
| 604 | */ |
| 605 | uint32_t receivers_offset; |
| 606 | /** Reserved field (12 bytes) must be 0. */ |
| 607 | uint32_t reserved[3]; |
| 608 | /** |
| 609 | * An array of `receiver_count` endpoint memory access descriptors. |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 610 | * Each one specifies a memory region offset, an endpoint and the |
| 611 | * attributes with which this memory region should be mapped in that |
| 612 | * endpoint's page table. |
| 613 | */ |
| 614 | struct ffa_memory_access receivers[]; |
| 615 | }; |
| 616 | |
| 617 | /** |
| 618 | * Descriptor used for FFA_MEM_RELINQUISH requests. This corresponds to table |
J-Alves | b42d17f | 2022-07-04 12:42:13 +0100 | [diff] [blame] | 619 | * 16.25 of the FF-A v1.1 EAC0 specification, "Descriptor to relinquish a memory |
| 620 | * region". |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 621 | */ |
| 622 | struct ffa_mem_relinquish { |
| 623 | ffa_memory_handle_t handle; |
| 624 | ffa_memory_region_flags_t flags; |
| 625 | uint32_t endpoint_count; |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 626 | ffa_id_t endpoints[]; |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 627 | }; |
| 628 | |
| 629 | static inline ffa_memory_handle_t ffa_assemble_handle(uint32_t h1, uint32_t h2) |
| 630 | { |
J-Alves | 18c2805 | 2021-03-09 09:58:53 +0000 | [diff] [blame] | 631 | return (ffa_notification_bitmap_t)h1 | |
| 632 | (ffa_notification_bitmap_t)h2 << 32; |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 633 | } |
| 634 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 635 | static inline ffa_memory_handle_t ffa_mem_success_handle(struct ffa_value r) |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 636 | { |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 637 | return ffa_assemble_handle(r.arg2, r.arg3); |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 638 | } |
| 639 | |
| 640 | /** |
| 641 | * Gets the `ffa_composite_memory_region` for the given receiver from an |
| 642 | * `ffa_memory_region`, or NULL if it is not valid. |
| 643 | */ |
| 644 | static inline struct ffa_composite_memory_region * |
| 645 | ffa_memory_region_get_composite(struct ffa_memory_region *memory_region, |
| 646 | uint32_t receiver_index) |
| 647 | { |
| 648 | uint32_t offset = memory_region->receivers[receiver_index] |
| 649 | .composite_memory_region_offset; |
| 650 | |
| 651 | if (offset == 0) { |
| 652 | return NULL; |
| 653 | } |
| 654 | |
| 655 | return (struct ffa_composite_memory_region *)((uint8_t *)memory_region + |
| 656 | offset); |
| 657 | } |
| 658 | |
| 659 | static inline uint32_t ffa_mem_relinquish_init( |
| 660 | struct ffa_mem_relinquish *relinquish_request, |
| 661 | ffa_memory_handle_t handle, ffa_memory_region_flags_t flags, |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 662 | ffa_id_t sender) |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 663 | { |
| 664 | relinquish_request->handle = handle; |
| 665 | relinquish_request->flags = flags; |
| 666 | relinquish_request->endpoint_count = 1; |
| 667 | relinquish_request->endpoints[0] = sender; |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 668 | return sizeof(struct ffa_mem_relinquish) + sizeof(ffa_id_t); |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 669 | } |
| 670 | |
| 671 | uint32_t ffa_memory_retrieve_request_init( |
| 672 | struct ffa_memory_region *memory_region, ffa_memory_handle_t handle, |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 673 | ffa_id_t sender, ffa_id_t receiver, uint32_t tag, |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 674 | ffa_memory_region_flags_t flags, enum ffa_data_access data_access, |
| 675 | enum ffa_instruction_access instruction_access, |
| 676 | enum ffa_memory_type type, enum ffa_memory_cacheability cacheability, |
| 677 | enum ffa_memory_shareability shareability); |
| 678 | |
| 679 | uint32_t ffa_memory_region_init( |
| 680 | struct ffa_memory_region *memory_region, size_t memory_region_max_size, |
Daniel Boulby | e79d207 | 2021-03-03 11:34:53 +0000 | [diff] [blame] | 681 | ffa_id_t sender, ffa_id_t receiver, |
J-Alves | f3a393c | 2020-10-23 16:00:39 +0100 | [diff] [blame] | 682 | const struct ffa_memory_region_constituent constituents[], |
| 683 | uint32_t constituent_count, uint32_t tag, |
| 684 | ffa_memory_region_flags_t flags, enum ffa_data_access data_access, |
| 685 | enum ffa_instruction_access instruction_access, |
| 686 | enum ffa_memory_type type, enum ffa_memory_cacheability cacheability, |
| 687 | enum ffa_memory_shareability shareability, uint32_t *total_length, |
| 688 | uint32_t *fragment_length); |
| 689 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 690 | static inline ffa_id_t ffa_dir_msg_dest(struct ffa_value val) { |
| 691 | return (ffa_id_t)val.arg1 & U(0xFFFF); |
J-Alves | 6cb21d9 | 2021-01-07 15:18:12 +0000 | [diff] [blame] | 692 | } |
| 693 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 694 | static inline ffa_id_t ffa_dir_msg_source(struct ffa_value val) { |
| 695 | return (ffa_id_t)(val.arg1 >> 16U); |
J-Alves | 6cb21d9 | 2021-01-07 15:18:12 +0000 | [diff] [blame] | 696 | } |
| 697 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 698 | struct ffa_value ffa_msg_send_direct_req64(ffa_id_t source_id, |
| 699 | ffa_id_t dest_id, uint64_t arg0, |
| 700 | uint64_t arg1, uint64_t arg2, |
| 701 | uint64_t arg3, uint64_t arg4); |
J-Alves | d1aae29 | 2020-10-08 17:16:58 +0100 | [diff] [blame] | 702 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 703 | struct ffa_value ffa_msg_send_direct_req32(ffa_id_t source_id, |
| 704 | ffa_id_t dest_id, uint32_t arg0, |
| 705 | uint32_t arg1, uint32_t arg2, |
| 706 | uint32_t arg3, uint32_t arg4); |
J-Alves | ecd3074 | 2021-02-19 18:31:06 +0000 | [diff] [blame] | 707 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 708 | struct ffa_value ffa_msg_send_direct_resp64(ffa_id_t source_id, |
| 709 | ffa_id_t dest_id, uint64_t arg0, |
| 710 | uint64_t arg1, uint64_t arg2, |
| 711 | uint64_t arg3, uint64_t arg4); |
J-Alves | ecd3074 | 2021-02-19 18:31:06 +0000 | [diff] [blame] | 712 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 713 | struct ffa_value ffa_msg_send_direct_resp32(ffa_id_t source_id, |
| 714 | ffa_id_t dest_id, uint32_t arg0, |
| 715 | uint32_t arg1, uint32_t arg2, |
| 716 | uint32_t arg3, uint32_t arg4); |
J-Alves | 035b7d0 | 2021-02-11 10:40:35 +0000 | [diff] [blame] | 717 | |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 718 | struct ffa_value ffa_run(uint32_t dest_id, uint32_t vcpu_id); |
| 719 | struct ffa_value ffa_version(uint32_t input_version); |
| 720 | struct ffa_value ffa_id_get(void); |
| 721 | struct ffa_value ffa_spm_id_get(void); |
| 722 | struct ffa_value ffa_msg_wait(void); |
| 723 | struct ffa_value ffa_error(int32_t error_code); |
| 724 | struct ffa_value ffa_features(uint32_t feature); |
Karl Meakin | 31b8177 | 2023-03-14 15:38:17 +0000 | [diff] [blame] | 725 | struct ffa_value ffa_features_with_input_property(uint32_t feature, |
| 726 | uint32_t param); |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 727 | struct ffa_value ffa_partition_info_get(const struct ffa_uuid uuid); |
| 728 | struct ffa_value ffa_rx_release(void); |
| 729 | struct ffa_value ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages); |
| 730 | struct ffa_value ffa_rxtx_unmap(void); |
| 731 | struct ffa_value ffa_mem_donate(uint32_t descriptor_length, |
| 732 | uint32_t fragment_length); |
| 733 | struct ffa_value ffa_mem_lend(uint32_t descriptor_length, |
J-Alves | 3ea46d1 | 2020-09-09 11:13:05 +0100 | [diff] [blame] | 734 | uint32_t fragment_length); |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 735 | struct ffa_value ffa_mem_share(uint32_t descriptor_length, |
| 736 | uint32_t fragment_length); |
| 737 | struct ffa_value ffa_mem_retrieve_req(uint32_t descriptor_length, |
| 738 | uint32_t fragment_length); |
| 739 | struct ffa_value ffa_mem_relinquish(void); |
| 740 | struct ffa_value ffa_mem_reclaim(uint64_t handle, uint32_t flags); |
| 741 | struct ffa_value ffa_notification_bitmap_create(ffa_id_t vm_id, |
| 742 | ffa_vcpu_count_t vcpu_count); |
| 743 | struct ffa_value ffa_notification_bitmap_destroy(ffa_id_t vm_id); |
| 744 | struct ffa_value ffa_notification_bind(ffa_id_t sender, ffa_id_t receiver, |
| 745 | uint32_t flags, |
J-Alves | 18c2805 | 2021-03-09 09:58:53 +0000 | [diff] [blame] | 746 | ffa_notification_bitmap_t notifications); |
Daniel Boulby | ce386b1 | 2022-03-29 18:36:36 +0100 | [diff] [blame] | 747 | struct ffa_value ffa_notification_unbind(ffa_id_t sender, ffa_id_t receiver, |
| 748 | ffa_notification_bitmap_t notifications); |
| 749 | struct ffa_value ffa_notification_set(ffa_id_t sender, ffa_id_t receiver, |
| 750 | uint32_t flags, |
| 751 | ffa_notification_bitmap_t bitmap); |
| 752 | struct ffa_value ffa_notification_get(ffa_id_t receiver, uint32_t vcpu_id, |
| 753 | uint32_t flags); |
| 754 | struct ffa_value ffa_notification_info_get(void); |
Maksims Svecovs | 0b45223 | 2022-05-24 11:30:34 +0100 | [diff] [blame] | 755 | |
| 756 | struct ffa_value ffa_console_log(const char* message, size_t char_count); |
Raghu Krishnamurthy | ab5321a | 2023-04-23 16:14:28 -0700 | [diff] [blame^] | 757 | struct ffa_value ffa_partition_info_get_regs(const struct ffa_uuid uuid, |
| 758 | const uint16_t start_index, |
| 759 | const uint16_t tag); |
J-Alves | 7581c38 | 2020-05-07 18:34:20 +0100 | [diff] [blame] | 760 | #endif /* __ASSEMBLY__ */ |
| 761 | |
| 762 | #endif /* FFA_HELPERS_H */ |