blob: 12506734f5b078dec69460ffe115912a9273fcc6 [file] [log] [blame]
J-Alves7581c382020-05-07 18:34:20 +01001/*
Daniel Boulby8aa994c2022-01-05 19:44:30 +00002 * Copyright (c) 2018-2022, Arm Limited. All rights reserved.
J-Alves7581c382020-05-07 18:34:20 +01003 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7#ifndef FFA_HELPERS_H
8#define FFA_HELPERS_H
9
J-Alves8f08a052020-05-26 17:14:40 +010010#include <ffa_svc.h>
J-Alves7581c382020-05-07 18:34:20 +010011#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 Boulbye79d2072021-03-03 11:34:53 +000017typedef unsigned short ffa_id_t;
J-Alves5aecd982020-06-11 10:25:33 +010018typedef unsigned short ffa_vm_count_t;
19typedef unsigned short ffa_vcpu_count_t;
J-Alvesf3a393c2020-10-23 16:00:39 +010020typedef uint64_t ffa_memory_handle_t;
21/** Flags to indicate properties of receivers during memory region retrieval. */
22typedef uint8_t ffa_memory_receiver_flags_t;
J-Alves5aecd982020-06-11 10:25:33 +010023
J-Alvesd708c032020-11-19 12:14:21 +000024struct ffa_uuid {
25 const uint32_t uuid[4];
26};
27
J-Alvesda3e6d42022-01-25 10:19:56 +000028/** 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 */
35struct 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
72static 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
79static 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
86static 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
91static 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 */
104struct 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-Alves7581c382020-05-07 18:34:20 +0100115#ifndef __ASSEMBLY__
116
J-Alves18c28052021-03-09 09:58:53 +0000117#include <cassert.h>
J-Alves7581c382020-05-07 18:34:20 +0100118#include <stdint.h>
119
J-Alves4439ece2021-11-05 11:52:54 +0000120/**
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 Shvetsov0b7d25f2021-03-05 13:46:42 +0000135/** Partition property: partition supports receipt of direct requests. */
136#define FFA_PARTITION_DIRECT_REQ_RECV 0x1
137
138/** Partition property: partition can send direct requests. */
139#define FFA_PARTITION_DIRECT_REQ_SEND 0x2
140
141/** Partition property: partition can send and receive indirect messages. */
142#define FFA_PARTITION_INDIRECT_MSG 0x4
143
J-Alves4d05dec2021-11-02 11:52:27 +0000144/** Partition property: partition can receive notifications. */
145#define FFA_PARTITION_NOTIFICATION 0x8
146
Daniel Boulby8aa994c2022-01-05 19:44:30 +0000147/**
148 * Partition info descriptor as defined in Table 13.34 of the v1.1 BETA0
149 * FF-A Specification
150 */
Max Shvetsovc32f4782020-06-23 09:41:15 +0100151struct ffa_partition_info {
152 /** The ID of the VM the information is about */
Daniel Boulbye79d2072021-03-03 11:34:53 +0000153 ffa_id_t id;
Max Shvetsovc32f4782020-06-23 09:41:15 +0100154 /** 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 Boulby8aa994c2022-01-05 19:44:30 +0000158 /** The uuid of the partition */
159 struct ffa_uuid uuid;
Max Shvetsovc32f4782020-06-23 09:41:15 +0100160};
161
Daniel Boulby2ac55f22022-01-21 12:08:08 +0000162/**
163 * Partition info descriptor as defined in Table 8.25 of the v1.0
164 * FF-A Specification
165 */
166struct ffa_partition_info_v1_0 {
167 /** The ID of the VM the information is about */
168 ffa_id_t id;
169 /** The number of execution contexts implemented by the partition */
170 uint16_t exec_context;
171 /** The Partition's properties, e.g. supported messaging methods */
172 uint32_t properties;
173};
174
Daniel Boulbyce386b12022-03-29 18:36:36 +0100175struct ffa_value {
176 u_register_t fid;
177 u_register_t arg1;
178 u_register_t arg2;
179 u_register_t arg3;
180 u_register_t arg4;
181 u_register_t arg5;
182 u_register_t arg6;
183 u_register_t arg7;
184};
185
186/* Function to make an SMC or SVC service call depending on the exception
187 * level of the SP.
188 */
189struct ffa_value ffa_service_call(struct ffa_value *args);
190
191/*
192 * Functions to trigger a service call.
193 *
194 * The arguments to pass through the service call must be stored in the
195 * ffa_value structure. The return values of the service call will be stored
196 * in the same structure (overriding the input arguments).
197 *
198 * Return the first return value. It is equivalent to args.fid but is also
199 * provided as the return value for convenience.
200 */
201u_register_t ffa_svc(struct ffa_value *args);
202u_register_t ffa_smc(struct ffa_value *args);
203
204static inline uint32_t ffa_func_id(struct ffa_value val)
J-Alvesf156ae92021-10-08 12:10:05 +0100205{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100206 return (uint32_t)val.fid;
J-Alves6cb21d92021-01-07 15:18:12 +0000207}
208
Daniel Boulbyce386b12022-03-29 18:36:36 +0100209static inline int32_t ffa_error_code(struct ffa_value val)
J-Alvesf156ae92021-10-08 12:10:05 +0100210{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100211 return (int32_t)val.arg2;
J-Alves6cb21d92021-01-07 15:18:12 +0000212}
213
Daniel Boulbyce386b12022-03-29 18:36:36 +0100214static inline ffa_id_t ffa_endpoint_id(struct ffa_value val) {
215 return (ffa_id_t)val.arg2 & 0xffff;
Daniel Boulby198deda2021-03-03 11:35:25 +0000216}
217
Daniel Boulbyce386b12022-03-29 18:36:36 +0100218static inline uint32_t ffa_partition_info_count(struct ffa_value val)
Daniel Boulby2ac55f22022-01-21 12:08:08 +0000219{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100220 return (uint32_t)val.arg2;
Daniel Boulby2ac55f22022-01-21 12:08:08 +0000221}
222
Daniel Boulbyce386b12022-03-29 18:36:36 +0100223static inline uint32_t ffa_feature_intid(struct ffa_value val)
J-Alves4439ece2021-11-05 11:52:54 +0000224{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100225 return (uint32_t)val.arg2;
J-Alves4439ece2021-11-05 11:52:54 +0000226}
227
J-Alves18c28052021-03-09 09:58:53 +0000228typedef uint64_t ffa_notification_bitmap_t;
229
230#define FFA_NOTIFICATION(ID) (UINT64_C(1) << ID)
231
232#define MAX_FFA_NOTIFICATIONS UINT32_C(64)
233
234#define FFA_NOTIFICATIONS_FLAG_PER_VCPU UINT32_C(0x1 << 0)
235
J-Alvesb0cb5d02021-07-08 11:19:33 +0100236/** Flag to delay Schedule Receiver Interrupt. */
237#define FFA_NOTIFICATIONS_FLAG_DELAY_SRI UINT32_C(0x1 << 1)
238
J-Alves18c28052021-03-09 09:58:53 +0000239#define FFA_NOTIFICATIONS_FLAGS_VCPU_ID(id) UINT32_C((id & 0xFFFF) << 16)
240
J-Alvesf156ae92021-10-08 12:10:05 +0100241#define FFA_NOTIFICATIONS_FLAG_BITMAP_SP UINT32_C(0x1 << 0)
242#define FFA_NOTIFICATIONS_FLAG_BITMAP_VM UINT32_C(0x1 << 1)
243#define FFA_NOTIFICATIONS_FLAG_BITMAP_SPM UINT32_C(0x1 << 2)
244#define FFA_NOTIFICATIONS_FLAG_BITMAP_HYP UINT32_C(0x1 << 3)
245
J-Alves269118a2021-09-22 09:46:11 +0100246/**
247 * The following is an SGI ID, that the SPMC configures as non-secure, as
248 * suggested by the FF-A v1.1 specification, in section 9.4.1.
249 */
250#define FFA_SCHEDULE_RECEIVER_INTERRUPT_ID 8
251
J-Alvesf156ae92021-10-08 12:10:05 +0100252#define FFA_NOTIFICATIONS_BITMAP(lo, hi) \
253 (ffa_notification_bitmap_t)(lo) | \
254 (((ffa_notification_bitmap_t)hi << 32) & 0xFFFFFFFF00000000ULL)
255
256#define FFA_NOTIFICATIONS_FLAGS_VCPU_ID(id) UINT32_C((id & 0xFFFF) << 16)
257
Daniel Boulbyce386b12022-03-29 18:36:36 +0100258static inline ffa_notification_bitmap_t ffa_notifications_get_from_sp(
259 struct ffa_value val)
J-Alvesf156ae92021-10-08 12:10:05 +0100260{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100261 return FFA_NOTIFICATIONS_BITMAP(val.arg2, val.arg3);
J-Alvesf156ae92021-10-08 12:10:05 +0100262}
263
Daniel Boulbyce386b12022-03-29 18:36:36 +0100264static inline ffa_notification_bitmap_t ffa_notifications_get_from_vm(
265 struct ffa_value val)
J-Alvesf156ae92021-10-08 12:10:05 +0100266{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100267 return FFA_NOTIFICATIONS_BITMAP(val.arg4, val.arg5);
J-Alvesf156ae92021-10-08 12:10:05 +0100268}
269
J-Alves5bce2502021-06-14 14:27:45 +0100270/*
271 * FFA_NOTIFICATION_INFO_GET is a SMC64 interface.
272 * The following macros are defined for SMC64 implementation.
273 */
274#define FFA_NOTIFICATIONS_INFO_GET_MAX_IDS 20U
275
276#define FFA_NOTIFICATIONS_INFO_GET_FLAG_MORE_PENDING UINT64_C(0x1)
277
278#define FFA_NOTIFICATIONS_LISTS_COUNT_SHIFT 0x7U
279#define FFA_NOTIFICATIONS_LISTS_COUNT_MASK 0x1FU
280#define FFA_NOTIFICATIONS_LIST_SHIFT(l) (2 * (l - 1) + 12)
281#define FFA_NOTIFICATIONS_LIST_SIZE_MASK 0x3U
282
283static inline uint32_t ffa_notifications_info_get_lists_count(
Daniel Boulbyce386b12022-03-29 18:36:36 +0100284 struct ffa_value ret)
J-Alves5bce2502021-06-14 14:27:45 +0100285{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100286 return (uint32_t)(ret.arg2 >> FFA_NOTIFICATIONS_LISTS_COUNT_SHIFT)
J-Alves5bce2502021-06-14 14:27:45 +0100287 & FFA_NOTIFICATIONS_LISTS_COUNT_MASK;
288}
289
290static inline uint32_t ffa_notifications_info_get_list_size(
Daniel Boulbyce386b12022-03-29 18:36:36 +0100291 struct ffa_value ret, uint32_t list)
J-Alves5bce2502021-06-14 14:27:45 +0100292{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100293 return (uint32_t)(ret.arg2 >> FFA_NOTIFICATIONS_LIST_SHIFT(list)) &
J-Alves5bce2502021-06-14 14:27:45 +0100294 FFA_NOTIFICATIONS_LIST_SIZE_MASK;
295}
296
Daniel Boulbyce386b12022-03-29 18:36:36 +0100297static inline bool ffa_notifications_info_get_more_pending(struct ffa_value ret)
J-Alves5bce2502021-06-14 14:27:45 +0100298{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100299 return (ret.arg2 & FFA_NOTIFICATIONS_INFO_GET_FLAG_MORE_PENDING) != 0U;
J-Alves5bce2502021-06-14 14:27:45 +0100300}
301
J-Alvesf3a393c2020-10-23 16:00:39 +0100302enum ffa_data_access {
303 FFA_DATA_ACCESS_NOT_SPECIFIED,
304 FFA_DATA_ACCESS_RO,
305 FFA_DATA_ACCESS_RW,
306 FFA_DATA_ACCESS_RESERVED,
307};
308
309enum ffa_instruction_access {
310 FFA_INSTRUCTION_ACCESS_NOT_SPECIFIED,
311 FFA_INSTRUCTION_ACCESS_NX,
312 FFA_INSTRUCTION_ACCESS_X,
313 FFA_INSTRUCTION_ACCESS_RESERVED,
314};
315
316enum ffa_memory_type {
317 FFA_MEMORY_NOT_SPECIFIED_MEM,
318 FFA_MEMORY_DEVICE_MEM,
319 FFA_MEMORY_NORMAL_MEM,
320};
321
322enum ffa_memory_cacheability {
323 FFA_MEMORY_CACHE_RESERVED = 0x0,
324 FFA_MEMORY_CACHE_NON_CACHEABLE = 0x1,
325 FFA_MEMORY_CACHE_RESERVED_1 = 0x2,
326 FFA_MEMORY_CACHE_WRITE_BACK = 0x3,
327 FFA_MEMORY_DEV_NGNRNE = 0x0,
328 FFA_MEMORY_DEV_NGNRE = 0x1,
329 FFA_MEMORY_DEV_NGRE = 0x2,
330 FFA_MEMORY_DEV_GRE = 0x3,
331};
332
333enum ffa_memory_shareability {
334 FFA_MEMORY_SHARE_NON_SHAREABLE,
335 FFA_MEMORY_SHARE_RESERVED,
336 FFA_MEMORY_OUTER_SHAREABLE,
337 FFA_MEMORY_INNER_SHAREABLE,
338};
339
340typedef uint8_t ffa_memory_access_permissions_t;
341
342/**
343 * This corresponds to table "Memory region attributes descriptor" of the FF-A
344 * 1.0 specification.
345 */
346typedef uint8_t ffa_memory_attributes_t;
347
348#define FFA_DATA_ACCESS_OFFSET (0x0U)
349#define FFA_DATA_ACCESS_MASK ((0x3U) << FFA_DATA_ACCESS_OFFSET)
350
351#define FFA_INSTRUCTION_ACCESS_OFFSET (0x2U)
352#define FFA_INSTRUCTION_ACCESS_MASK ((0x3U) << FFA_INSTRUCTION_ACCESS_OFFSET)
353
354#define FFA_MEMORY_TYPE_OFFSET (0x4U)
355#define FFA_MEMORY_TYPE_MASK ((0x3U) << FFA_MEMORY_TYPE_OFFSET)
356
357#define FFA_MEMORY_CACHEABILITY_OFFSET (0x2U)
358#define FFA_MEMORY_CACHEABILITY_MASK ((0x3U) << FFA_MEMORY_CACHEABILITY_OFFSET)
359
360#define FFA_MEMORY_SHAREABILITY_OFFSET (0x0U)
361#define FFA_MEMORY_SHAREABILITY_MASK ((0x3U) << FFA_MEMORY_SHAREABILITY_OFFSET)
362
363#define ATTR_FUNCTION_SET(name, container_type, offset, mask) \
364 static inline void ffa_set_##name##_attr(container_type *attr, \
365 const enum ffa_##name perm) \
366 { \
367 *attr = (*attr & ~(mask)) | ((perm << offset) & mask); \
368 }
369
370#define ATTR_FUNCTION_GET(name, container_type, offset, mask) \
371 static inline enum ffa_##name ffa_get_##name##_attr( \
372 container_type attr) \
373 { \
374 return (enum ffa_##name)((attr & mask) >> offset); \
375 }
376
377ATTR_FUNCTION_SET(data_access, ffa_memory_access_permissions_t,
378 FFA_DATA_ACCESS_OFFSET, FFA_DATA_ACCESS_MASK)
379ATTR_FUNCTION_GET(data_access, ffa_memory_access_permissions_t,
380 FFA_DATA_ACCESS_OFFSET, FFA_DATA_ACCESS_MASK)
381
382ATTR_FUNCTION_SET(instruction_access, ffa_memory_access_permissions_t,
383 FFA_INSTRUCTION_ACCESS_OFFSET, FFA_INSTRUCTION_ACCESS_MASK)
384ATTR_FUNCTION_GET(instruction_access, ffa_memory_access_permissions_t,
385 FFA_INSTRUCTION_ACCESS_OFFSET, FFA_INSTRUCTION_ACCESS_MASK)
386
387ATTR_FUNCTION_SET(memory_type, ffa_memory_attributes_t, FFA_MEMORY_TYPE_OFFSET,
388 FFA_MEMORY_TYPE_MASK)
389ATTR_FUNCTION_GET(memory_type, ffa_memory_attributes_t, FFA_MEMORY_TYPE_OFFSET,
390 FFA_MEMORY_TYPE_MASK)
391
392ATTR_FUNCTION_SET(memory_cacheability, ffa_memory_attributes_t,
393 FFA_MEMORY_CACHEABILITY_OFFSET, FFA_MEMORY_CACHEABILITY_MASK)
394ATTR_FUNCTION_GET(memory_cacheability, ffa_memory_attributes_t,
395 FFA_MEMORY_CACHEABILITY_OFFSET, FFA_MEMORY_CACHEABILITY_MASK)
396
397ATTR_FUNCTION_SET(memory_shareability, ffa_memory_attributes_t,
398 FFA_MEMORY_SHAREABILITY_OFFSET, FFA_MEMORY_SHAREABILITY_MASK)
399ATTR_FUNCTION_GET(memory_shareability, ffa_memory_attributes_t,
400 FFA_MEMORY_SHAREABILITY_OFFSET, FFA_MEMORY_SHAREABILITY_MASK)
401
402#define FFA_MEMORY_HANDLE_ALLOCATOR_MASK \
403 ((ffa_memory_handle_t)(UINT64_C(1) << 63))
404#define FFA_MEMORY_HANDLE_ALLOCATOR_HYPERVISOR \
405 ((ffa_memory_handle_t)(UINT64_C(1) << 63))
406#define FFA_MEMORY_HANDLE_INVALID (~UINT64_C(0))
407
408/**
409 * A set of contiguous pages which is part of a memory region. This corresponds
410 * to table "Constituent memory region descriptor" of the FFA 1.0 specification.
411 */
412struct ffa_memory_region_constituent {
413 /**
414 * The base IPA of the constituent memory region, aligned to 4 kiB page
415 * size granularity.
416 */
417 void *address;
418 /** The number of 4 kiB pages in the constituent memory region. */
419 uint32_t page_count;
420 /** Reserved field, must be 0. */
421 uint32_t reserved;
422};
423
424/**
425 * A set of pages comprising a memory region. This corresponds to table
426 * "Composite memory region descriptor" of the FFA 1.0 specification.
427 */
428struct ffa_composite_memory_region {
429 /**
430 * The total number of 4 kiB pages included in this memory region. This
431 * must be equal to the sum of page counts specified in each
432 * `ffa_memory_region_constituent`.
433 */
434 uint32_t page_count;
435 /**
436 * The number of constituents (`ffa_memory_region_constituent`)
437 * included in this memory region range.
438 */
439 uint32_t constituent_count;
440 /** Reserved field, must be 0. */
441 uint64_t reserved_0;
442 /** An array of `constituent_count` memory region constituents. */
443 struct ffa_memory_region_constituent constituents[];
444};
445
446/**
447 * This corresponds to table "Memory access permissions descriptor" of the FFA
448 * 1.0 specification.
449 */
450struct ffa_memory_region_attributes {
451 /** The ID of the VM to which the memory is being given or shared. */
Daniel Boulbye79d2072021-03-03 11:34:53 +0000452 ffa_id_t receiver;
J-Alvesf3a393c2020-10-23 16:00:39 +0100453 /**
454 * The permissions with which the memory region should be mapped in the
455 * receiver's page table.
456 */
457 ffa_memory_access_permissions_t permissions;
458 /**
459 * Flags used during FFA_MEM_RETRIEVE_REQ and FFA_MEM_RETRIEVE_RESP
460 * for memory regions with multiple borrowers.
461 */
462 ffa_memory_receiver_flags_t flags;
463};
464
465/** Flags to control the behaviour of a memory sharing transaction. */
466typedef uint32_t ffa_memory_region_flags_t;
467
468/**
469 * Clear memory region contents after unmapping it from the sender and before
470 * mapping it for any receiver.
471 */
472#define FFA_MEMORY_REGION_FLAG_CLEAR 0x1U
473
474/**
475 * Whether the hypervisor may time slice the memory sharing or retrieval
476 * operation.
477 */
478#define FFA_MEMORY_REGION_FLAG_TIME_SLICE 0x2U
479
480/**
481 * Whether the hypervisor should clear the memory region after the receiver
482 * relinquishes it or is aborted.
483 */
484#define FFA_MEMORY_REGION_FLAG_CLEAR_RELINQUISH 0x4U
485
486#define FFA_MEMORY_REGION_TRANSACTION_TYPE_MASK ((0x3U) << 3)
487#define FFA_MEMORY_REGION_TRANSACTION_TYPE_UNSPECIFIED ((0x0U) << 3)
488#define FFA_MEMORY_REGION_TRANSACTION_TYPE_SHARE ((0x1U) << 3)
489#define FFA_MEMORY_REGION_TRANSACTION_TYPE_LEND ((0x2U) << 3)
490#define FFA_MEMORY_REGION_TRANSACTION_TYPE_DONATE ((0x3U) << 3)
491
J-Alves0435cae2020-11-06 10:49:56 +0000492/** The maximum number of recipients a memory region may be sent to. */
493#define MAX_MEM_SHARE_RECIPIENTS 1U
494
J-Alvesf3a393c2020-10-23 16:00:39 +0100495/**
496 * This corresponds to table "Endpoint memory access descriptor" of the FFA 1.0
497 * specification.
498 */
499struct ffa_memory_access {
500 struct ffa_memory_region_attributes receiver_permissions;
501 /**
502 * Offset in bytes from the start of the outer `ffa_memory_region` to
503 * an `ffa_composite_memory_region` struct.
504 */
505 uint32_t composite_memory_region_offset;
506 uint64_t reserved_0;
507};
508
509/**
510 * Information about a set of pages which are being shared. This corresponds to
511 * table "Lend, donate or share memory transaction descriptor" of the FFA
512 * 1.0 specification. Note that it is also used for retrieve requests and
513 * responses.
514 */
515struct ffa_memory_region {
516 /**
517 * The ID of the VM which originally sent the memory region, i.e. the
518 * owner.
519 */
Daniel Boulbye79d2072021-03-03 11:34:53 +0000520 ffa_id_t sender;
J-Alvesf3a393c2020-10-23 16:00:39 +0100521 ffa_memory_attributes_t attributes;
522 /** Reserved field, must be 0. */
523 uint8_t reserved_0;
524 /** Flags to control behaviour of the transaction. */
525 ffa_memory_region_flags_t flags;
526 ffa_memory_handle_t handle;
527 /**
528 * An implementation defined value associated with the receiver and the
529 * memory region.
530 */
531 uint64_t tag;
532 /** Reserved field, must be 0. */
533 uint32_t reserved_1;
534 /**
535 * The number of `ffa_memory_access` entries included in this
536 * transaction.
537 */
538 uint32_t receiver_count;
539 /**
540 * An array of `attribute_count` endpoint memory access descriptors.
541 * Each one specifies a memory region offset, an endpoint and the
542 * attributes with which this memory region should be mapped in that
543 * endpoint's page table.
544 */
545 struct ffa_memory_access receivers[];
546};
547
548/**
549 * Descriptor used for FFA_MEM_RELINQUISH requests. This corresponds to table
550 * "Descriptor to relinquish a memory region" of the FFA 1.0 specification.
551 */
552struct ffa_mem_relinquish {
553 ffa_memory_handle_t handle;
554 ffa_memory_region_flags_t flags;
555 uint32_t endpoint_count;
Daniel Boulbye79d2072021-03-03 11:34:53 +0000556 ffa_id_t endpoints[];
J-Alvesf3a393c2020-10-23 16:00:39 +0100557};
558
559static inline ffa_memory_handle_t ffa_assemble_handle(uint32_t h1, uint32_t h2)
560{
J-Alves18c28052021-03-09 09:58:53 +0000561 return (ffa_notification_bitmap_t)h1 |
562 (ffa_notification_bitmap_t)h2 << 32;
J-Alvesf3a393c2020-10-23 16:00:39 +0100563}
564
Daniel Boulbyce386b12022-03-29 18:36:36 +0100565static inline ffa_memory_handle_t ffa_mem_success_handle(struct ffa_value r)
J-Alvesf3a393c2020-10-23 16:00:39 +0100566{
Daniel Boulbyce386b12022-03-29 18:36:36 +0100567 return ffa_assemble_handle(r.arg2, r.arg3);
J-Alvesf3a393c2020-10-23 16:00:39 +0100568}
569
570/**
571 * Gets the `ffa_composite_memory_region` for the given receiver from an
572 * `ffa_memory_region`, or NULL if it is not valid.
573 */
574static inline struct ffa_composite_memory_region *
575ffa_memory_region_get_composite(struct ffa_memory_region *memory_region,
576 uint32_t receiver_index)
577{
578 uint32_t offset = memory_region->receivers[receiver_index]
579 .composite_memory_region_offset;
580
581 if (offset == 0) {
582 return NULL;
583 }
584
585 return (struct ffa_composite_memory_region *)((uint8_t *)memory_region +
586 offset);
587}
588
589static inline uint32_t ffa_mem_relinquish_init(
590 struct ffa_mem_relinquish *relinquish_request,
591 ffa_memory_handle_t handle, ffa_memory_region_flags_t flags,
Daniel Boulbye79d2072021-03-03 11:34:53 +0000592 ffa_id_t sender)
J-Alvesf3a393c2020-10-23 16:00:39 +0100593{
594 relinquish_request->handle = handle;
595 relinquish_request->flags = flags;
596 relinquish_request->endpoint_count = 1;
597 relinquish_request->endpoints[0] = sender;
Daniel Boulbye79d2072021-03-03 11:34:53 +0000598 return sizeof(struct ffa_mem_relinquish) + sizeof(ffa_id_t);
J-Alvesf3a393c2020-10-23 16:00:39 +0100599}
600
601uint32_t ffa_memory_retrieve_request_init(
602 struct ffa_memory_region *memory_region, ffa_memory_handle_t handle,
Daniel Boulbye79d2072021-03-03 11:34:53 +0000603 ffa_id_t sender, ffa_id_t receiver, uint32_t tag,
J-Alvesf3a393c2020-10-23 16:00:39 +0100604 ffa_memory_region_flags_t flags, enum ffa_data_access data_access,
605 enum ffa_instruction_access instruction_access,
606 enum ffa_memory_type type, enum ffa_memory_cacheability cacheability,
607 enum ffa_memory_shareability shareability);
608
609uint32_t ffa_memory_region_init(
610 struct ffa_memory_region *memory_region, size_t memory_region_max_size,
Daniel Boulbye79d2072021-03-03 11:34:53 +0000611 ffa_id_t sender, ffa_id_t receiver,
J-Alvesf3a393c2020-10-23 16:00:39 +0100612 const struct ffa_memory_region_constituent constituents[],
613 uint32_t constituent_count, uint32_t tag,
614 ffa_memory_region_flags_t flags, enum ffa_data_access data_access,
615 enum ffa_instruction_access instruction_access,
616 enum ffa_memory_type type, enum ffa_memory_cacheability cacheability,
617 enum ffa_memory_shareability shareability, uint32_t *total_length,
618 uint32_t *fragment_length);
619
Daniel Boulbyce386b12022-03-29 18:36:36 +0100620static inline ffa_id_t ffa_dir_msg_dest(struct ffa_value val) {
621 return (ffa_id_t)val.arg1 & U(0xFFFF);
J-Alves6cb21d92021-01-07 15:18:12 +0000622}
623
Daniel Boulbyce386b12022-03-29 18:36:36 +0100624static inline ffa_id_t ffa_dir_msg_source(struct ffa_value val) {
625 return (ffa_id_t)(val.arg1 >> 16U);
J-Alves6cb21d92021-01-07 15:18:12 +0000626}
627
Daniel Boulbyce386b12022-03-29 18:36:36 +0100628struct ffa_value ffa_msg_send_direct_req64(ffa_id_t source_id,
629 ffa_id_t dest_id, uint64_t arg0,
630 uint64_t arg1, uint64_t arg2,
631 uint64_t arg3, uint64_t arg4);
J-Alvesd1aae292020-10-08 17:16:58 +0100632
Daniel Boulbyce386b12022-03-29 18:36:36 +0100633struct ffa_value ffa_msg_send_direct_req32(ffa_id_t source_id,
634 ffa_id_t dest_id, uint32_t arg0,
635 uint32_t arg1, uint32_t arg2,
636 uint32_t arg3, uint32_t arg4);
J-Alvesecd30742021-02-19 18:31:06 +0000637
Daniel Boulbyce386b12022-03-29 18:36:36 +0100638struct ffa_value ffa_msg_send_direct_resp64(ffa_id_t source_id,
639 ffa_id_t dest_id, uint64_t arg0,
640 uint64_t arg1, uint64_t arg2,
641 uint64_t arg3, uint64_t arg4);
J-Alvesecd30742021-02-19 18:31:06 +0000642
Daniel Boulbyce386b12022-03-29 18:36:36 +0100643struct ffa_value ffa_msg_send_direct_resp32(ffa_id_t source_id,
644 ffa_id_t dest_id, uint32_t arg0,
645 uint32_t arg1, uint32_t arg2,
646 uint32_t arg3, uint32_t arg4);
J-Alves035b7d02021-02-11 10:40:35 +0000647
Daniel Boulbyce386b12022-03-29 18:36:36 +0100648struct ffa_value ffa_run(uint32_t dest_id, uint32_t vcpu_id);
649struct ffa_value ffa_version(uint32_t input_version);
650struct ffa_value ffa_id_get(void);
651struct ffa_value ffa_spm_id_get(void);
652struct ffa_value ffa_msg_wait(void);
653struct ffa_value ffa_error(int32_t error_code);
654struct ffa_value ffa_features(uint32_t feature);
655struct ffa_value ffa_partition_info_get(const struct ffa_uuid uuid);
656struct ffa_value ffa_rx_release(void);
657struct ffa_value ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages);
658struct ffa_value ffa_rxtx_unmap(void);
659struct ffa_value ffa_mem_donate(uint32_t descriptor_length,
660 uint32_t fragment_length);
661struct ffa_value ffa_mem_lend(uint32_t descriptor_length,
J-Alves3ea46d12020-09-09 11:13:05 +0100662 uint32_t fragment_length);
Daniel Boulbyce386b12022-03-29 18:36:36 +0100663struct ffa_value ffa_mem_share(uint32_t descriptor_length,
664 uint32_t fragment_length);
665struct ffa_value ffa_mem_retrieve_req(uint32_t descriptor_length,
666 uint32_t fragment_length);
667struct ffa_value ffa_mem_relinquish(void);
668struct ffa_value ffa_mem_reclaim(uint64_t handle, uint32_t flags);
669struct ffa_value ffa_notification_bitmap_create(ffa_id_t vm_id,
670 ffa_vcpu_count_t vcpu_count);
671struct ffa_value ffa_notification_bitmap_destroy(ffa_id_t vm_id);
672struct ffa_value ffa_notification_bind(ffa_id_t sender, ffa_id_t receiver,
673 uint32_t flags,
J-Alves18c28052021-03-09 09:58:53 +0000674 ffa_notification_bitmap_t notifications);
Daniel Boulbyce386b12022-03-29 18:36:36 +0100675struct ffa_value ffa_notification_unbind(ffa_id_t sender, ffa_id_t receiver,
676 ffa_notification_bitmap_t notifications);
677struct ffa_value ffa_notification_set(ffa_id_t sender, ffa_id_t receiver,
678 uint32_t flags,
679 ffa_notification_bitmap_t bitmap);
680struct ffa_value ffa_notification_get(ffa_id_t receiver, uint32_t vcpu_id,
681 uint32_t flags);
682struct ffa_value ffa_notification_info_get(void);
J-Alves7581c382020-05-07 18:34:20 +0100683#endif /* __ASSEMBLY__ */
684
685#endif /* FFA_HELPERS_H */