1/* SPDX-License-Identifier: GPL-2.0+ */ 2/* 3 * Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com> 4 * 5 * Authors: 6 * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com> 7 */ 8 9#ifndef __ARM_FFA_H 10#define __ARM_FFA_H 11 12#include <linux/printk.h> 13 14/* 15 * This header is public. It can be used by clients to access 16 * data structures and definitions they need 17 */ 18 19/* 20 * struct ffa_partition_info - Partition information descriptor 21 * @id: Partition ID 22 * @exec_ctxt: Execution context count 23 * @properties: Partition properties 24 * 25 * Data structure containing information about partitions instantiated in the system 26 * This structure is filled with the data queried by FFA_PARTITION_INFO_GET 27 */ 28struct ffa_partition_info { 29 u16 id; 30 u16 exec_ctxt; 31/* partition supports receipt of direct requests */ 32#define FFA_PARTITION_DIRECT_RECV BIT(0) 33/* partition can send direct requests. */ 34#define FFA_PARTITION_DIRECT_SEND BIT(1) 35/* partition can send and receive indirect messages. */ 36#define FFA_PARTITION_INDIRECT_MSG BIT(2) 37 u32 properties; 38}; 39 40/* 41 * struct ffa_partition_uuid - 16 bytes UUID transmitted by FFA_PARTITION_INFO_GET 42 * @a1-4: 32-bit words access to the UUID data 43 * 44 */ 45struct ffa_partition_uuid { 46 u32 a1; /* w1 */ 47 u32 a2; /* w2 */ 48 u32 a3; /* w3 */ 49 u32 a4; /* w4 */ 50}; 51 52/** 53 * struct ffa_partition_desc - the secure partition descriptor 54 * @info: partition information 55 * @sp_uuid: the secure partition UUID 56 * 57 * Each partition has its descriptor containing the partitions information and the UUID 58 */ 59struct ffa_partition_desc { 60 struct ffa_partition_info info; 61 struct ffa_partition_uuid sp_uuid; 62}; 63 64/* 65 * struct ffa_send_direct_data - Data structure hosting the data 66 * used by FFA_MSG_SEND_DIRECT_{REQ,RESP} 67 * @data0-4: Data read/written from/to x3-x7 registers 68 * 69 * Data structure containing the data to be sent by FFA_MSG_SEND_DIRECT_REQ 70 * or read from FFA_MSG_SEND_DIRECT_RESP 71 */ 72 73/* For use with FFA_MSG_SEND_DIRECT_{REQ,RESP} which pass data via registers */ 74struct ffa_send_direct_data { 75 ulong data0; /* w3/x3 */ 76 ulong data1; /* w4/x4 */ 77 ulong data2; /* w5/x5 */ 78 ulong data3; /* w6/x6 */ 79 ulong data4; /* w7/x7 */ 80}; 81 82struct udevice; 83 84/** 85 * struct ffa_bus_ops - Operations for FF-A 86 * @partition_info_get: callback for the FFA_PARTITION_INFO_GET 87 * @sync_send_receive: callback for the FFA_MSG_SEND_DIRECT_REQ 88 * @rxtx_unmap: callback for the FFA_RXTX_UNMAP 89 * 90 * The data structure providing all the operations supported by the driver. 91 * This structure is EFI runtime resident. 92 */ 93struct ffa_bus_ops { 94 int (*partition_info_get)(struct udevice *dev, const char *uuid_str, 95 u32 *sp_count, struct ffa_partition_desc **sp_descs); 96 int (*sync_send_receive)(struct udevice *dev, u16 dst_part_id, 97 struct ffa_send_direct_data *msg, 98 bool is_smc64); 99 int (*rxtx_unmap)(struct udevice *dev); 100}; 101 102#define ffa_get_ops(dev) ((struct ffa_bus_ops *)(dev)->driver->ops) 103 104/** 105 * ffa_rxtx_unmap() - FFA_RXTX_UNMAP driver operation 106 * Please see ffa_unmap_rxtx_buffers_hdlr() description for more details. 107 */ 108int ffa_rxtx_unmap(struct udevice *dev); 109 110/** 111 * ffa_unmap_rxtx_buffers_hdlr() - FFA_RXTX_UNMAP handler function 112 * @dev: The arm_ffa bus device 113 * 114 * This function implements FFA_RXTX_UNMAP FF-A function 115 * to unmap the RX/TX buffers 116 * 117 * Return: 118 * 119 * 0 on success. Otherwise, failure 120 */ 121int ffa_unmap_rxtx_buffers_hdlr(struct udevice *dev); 122 123/** 124 * ffa_sync_send_receive() - FFA_MSG_SEND_DIRECT_{REQ,RESP} driver operation 125 * Please see ffa_msg_send_direct_req_hdlr() description for more details. 126 */ 127int ffa_sync_send_receive(struct udevice *dev, u16 dst_part_id, 128 struct ffa_send_direct_data *msg, bool is_smc64); 129 130/** 131 * ffa_msg_send_direct_req_hdlr() - FFA_MSG_SEND_DIRECT_{REQ,RESP} handler function 132 * @dev: The arm_ffa bus device 133 * @dst_part_id: destination partition ID 134 * @msg: pointer to the message data preallocated by the client (in/out) 135 * @is_smc64: select 64-bit or 32-bit FF-A ABI 136 * 137 * This function implements FFA_MSG_SEND_DIRECT_{REQ,RESP} 138 * FF-A functions. 139 * 140 * FFA_MSG_SEND_DIRECT_REQ is used to send the data to the secure partition. 141 * The response from the secure partition is handled by reading the 142 * FFA_MSG_SEND_DIRECT_RESP arguments. 143 * 144 * The maximum size of the data that can be exchanged is 40 bytes which is 145 * sizeof(struct ffa_send_direct_data) as defined by the FF-A specification 1.0 146 * in the section relevant to FFA_MSG_SEND_DIRECT_{REQ,RESP} 147 * 148 * Return: 149 * 150 * 0 on success. Otherwise, failure 151 */ 152int ffa_msg_send_direct_req_hdlr(struct udevice *dev, u16 dst_part_id, 153 struct ffa_send_direct_data *msg, bool is_smc64); 154 155/** 156 * ffa_partition_info_get() - FFA_PARTITION_INFO_GET driver operation 157 * Please see ffa_get_partitions_info_hdlr() description for more details. 158 */ 159int ffa_partition_info_get(struct udevice *dev, const char *uuid_str, 160 u32 *sp_count, struct ffa_partition_desc **sp_descs); 161 162/** 163 * ffa_get_partitions_info_hdlr() - FFA_PARTITION_INFO_GET handler function 164 * @uuid_str: pointer to the UUID string 165 * @sp_count: address of the variable containing the number of partitions matching the UUID 166 * The variable is set by the driver 167 * @sp_descs: address of the descriptors of the partitions matching the UUID 168 * The address is set by the driver 169 * 170 * Return the number of partitions and their descriptors matching the UUID 171 * 172 * Query the secure partition data from uc_priv. 173 * If not found, invoke FFA_PARTITION_INFO_GET 174 * FF-A function to query the partition information from secure world. 175 * 176 * A client of the FF-A driver should know the UUID of the service it wants to 177 * access. It should use the UUID to request the FF-A driver to provide the 178 * partition(s) information of the service. The FF-A driver uses 179 * PARTITION_INFO_GET to obtain this information. This is implemented through 180 * ffa_get_partitions_info_hdlr() function. 181 * A new FFA_PARTITION_INFO_GET call is issued (first one performed through 182 * ffa_cache_partitions_info) allowing to retrieve the partition(s) information. 183 * They are not saved (already done). We only update the UUID in the cached area. 184 * This assumes that partitions data does not change in the secure world. 185 * Otherwise u-boot will have an outdated partition data. The benefit of caching 186 * the information in the FF-A driver is to accommodate discovery after 187 * ExitBootServices(). 188 * 189 * Return: 190 * 191 * @sp_count: the number of partitions 192 * @sp_descs: address of the partitions descriptors 193 * 194 * On success 0 is returned. Otherwise, failure 195 */ 196int ffa_get_partitions_info_hdlr(struct udevice *dev, const char *uuid_str, 197 u32 *sp_count, struct ffa_partition_desc **sp_descs); 198 199struct ffa_priv; 200 201/** 202 * ffa_set_smc_conduit() - Set the SMC conduit 203 * @dev: The FF-A bus device 204 * 205 * Selects the SMC conduit by setting the FF-A ABI invoke function. 206 * 207 * Return: 208 * 209 * 0 on success. Otherwise, failure 210 */ 211int ffa_set_smc_conduit(struct udevice *dev); 212 213#endif 214