arm_ffa.h

  1/* SPDX-License-Identifier: GPL-2.0-only */
  2/*
  3 * Copyright (C) 2021 ARM Ltd.
  4 */
  5
  6#ifndef _LINUX_ARM_FFA_H
  7#define _LINUX_ARM_FFA_H
  8
  9#include <linux/bitfield.h>
 10#include <linux/device.h>
 11#include <linux/module.h>
 12#include <linux/types.h>
 13#include <linux/uuid.h>
 14
 15#define FFA_SMC(calling_convention, func_num)				\
 16	ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, (calling_convention),	\
 17			   ARM_SMCCC_OWNER_STANDARD, (func_num))
 18
 19#define FFA_SMC_32(func_num)	FFA_SMC(ARM_SMCCC_SMC_32, (func_num))
 20#define FFA_SMC_64(func_num)	FFA_SMC(ARM_SMCCC_SMC_64, (func_num))
 21
 22#define FFA_ERROR			FFA_SMC_32(0x60)
 23#define FFA_SUCCESS			FFA_SMC_32(0x61)
 24#define FFA_FN64_SUCCESS		FFA_SMC_64(0x61)
 25#define FFA_INTERRUPT			FFA_SMC_32(0x62)
 26#define FFA_VERSION			FFA_SMC_32(0x63)
 27#define FFA_FEATURES			FFA_SMC_32(0x64)
 28#define FFA_RX_RELEASE			FFA_SMC_32(0x65)
 29#define FFA_RXTX_MAP			FFA_SMC_32(0x66)
 30#define FFA_FN64_RXTX_MAP		FFA_SMC_64(0x66)
 31#define FFA_RXTX_UNMAP			FFA_SMC_32(0x67)
 32#define FFA_PARTITION_INFO_GET		FFA_SMC_32(0x68)
 33#define FFA_ID_GET			FFA_SMC_32(0x69)
 34#define FFA_MSG_POLL			FFA_SMC_32(0x6A)
 35#define FFA_MSG_WAIT			FFA_SMC_32(0x6B)
 36#define FFA_YIELD			FFA_SMC_32(0x6C)
 37#define FFA_RUN				FFA_SMC_32(0x6D)
 38#define FFA_MSG_SEND			FFA_SMC_32(0x6E)
 39#define FFA_MSG_SEND_DIRECT_REQ		FFA_SMC_32(0x6F)
 40#define FFA_FN64_MSG_SEND_DIRECT_REQ	FFA_SMC_64(0x6F)
 41#define FFA_MSG_SEND_DIRECT_RESP	FFA_SMC_32(0x70)
 42#define FFA_FN64_MSG_SEND_DIRECT_RESP	FFA_SMC_64(0x70)
 43#define FFA_MEM_DONATE			FFA_SMC_32(0x71)
 44#define FFA_FN64_MEM_DONATE		FFA_SMC_64(0x71)
 45#define FFA_MEM_LEND			FFA_SMC_32(0x72)
 46#define FFA_FN64_MEM_LEND		FFA_SMC_64(0x72)
 47#define FFA_MEM_SHARE			FFA_SMC_32(0x73)
 48#define FFA_FN64_MEM_SHARE		FFA_SMC_64(0x73)
 49#define FFA_MEM_RETRIEVE_REQ		FFA_SMC_32(0x74)
 50#define FFA_FN64_MEM_RETRIEVE_REQ	FFA_SMC_64(0x74)
 51#define FFA_MEM_RETRIEVE_RESP		FFA_SMC_32(0x75)
 52#define FFA_MEM_RELINQUISH		FFA_SMC_32(0x76)
 53#define FFA_MEM_RECLAIM			FFA_SMC_32(0x77)
 54#define FFA_MEM_OP_PAUSE		FFA_SMC_32(0x78)
 55#define FFA_MEM_OP_RESUME		FFA_SMC_32(0x79)
 56#define FFA_MEM_FRAG_RX			FFA_SMC_32(0x7A)
 57#define FFA_MEM_FRAG_TX			FFA_SMC_32(0x7B)
 58#define FFA_NORMAL_WORLD_RESUME		FFA_SMC_32(0x7C)
 59#define FFA_NOTIFICATION_BITMAP_CREATE	FFA_SMC_32(0x7D)
 60#define FFA_NOTIFICATION_BITMAP_DESTROY FFA_SMC_32(0x7E)
 61#define FFA_NOTIFICATION_BIND		FFA_SMC_32(0x7F)
 62#define FFA_NOTIFICATION_UNBIND		FFA_SMC_32(0x80)
 63#define FFA_NOTIFICATION_SET		FFA_SMC_32(0x81)
 64#define FFA_NOTIFICATION_GET		FFA_SMC_32(0x82)
 65#define FFA_NOTIFICATION_INFO_GET	FFA_SMC_32(0x83)
 66#define FFA_FN64_NOTIFICATION_INFO_GET	FFA_SMC_64(0x83)
 67#define FFA_RX_ACQUIRE			FFA_SMC_32(0x84)
 68#define FFA_SPM_ID_GET			FFA_SMC_32(0x85)
 69#define FFA_MSG_SEND2			FFA_SMC_32(0x86)
 70#define FFA_SECONDARY_EP_REGISTER	FFA_SMC_32(0x87)
 71#define FFA_FN64_SECONDARY_EP_REGISTER	FFA_SMC_64(0x87)
 72#define FFA_MEM_PERM_GET		FFA_SMC_32(0x88)
 73#define FFA_FN64_MEM_PERM_GET		FFA_SMC_64(0x88)
 74#define FFA_MEM_PERM_SET		FFA_SMC_32(0x89)
 75#define FFA_FN64_MEM_PERM_SET		FFA_SMC_64(0x89)
 76#define FFA_CONSOLE_LOG			FFA_SMC_32(0x8A)
 77#define FFA_PARTITION_INFO_GET_REGS	FFA_SMC_64(0x8B)
 78#define FFA_EL3_INTR_HANDLE		FFA_SMC_32(0x8C)
 79#define FFA_MSG_SEND_DIRECT_REQ2	FFA_SMC_64(0x8D)
 80#define FFA_MSG_SEND_DIRECT_RESP2	FFA_SMC_64(0x8E)
 81
 82/*
 83 * For some calls it is necessary to use SMC64 to pass or return 64-bit values.
 84 * For such calls FFA_FN_NATIVE(name) will choose the appropriate
 85 * (native-width) function ID.
 86 */
 87#ifdef CONFIG_64BIT
 88#define FFA_FN_NATIVE(name)	FFA_FN64_##name
 89#else
 90#define FFA_FN_NATIVE(name)	FFA_##name
 91#endif
 92
 93/* FFA error codes. */
 94#define FFA_RET_SUCCESS            (0)
 95#define FFA_RET_NOT_SUPPORTED      (-1)
 96#define FFA_RET_INVALID_PARAMETERS (-2)
 97#define FFA_RET_NO_MEMORY          (-3)
 98#define FFA_RET_BUSY               (-4)
 99#define FFA_RET_INTERRUPTED        (-5)
100#define FFA_RET_DENIED             (-6)
101#define FFA_RET_RETRY              (-7)
102#define FFA_RET_ABORTED            (-8)
103#define FFA_RET_NO_DATA            (-9)
104
105/* FFA version encoding */
106#define FFA_MAJOR_VERSION_MASK	GENMASK(30, 16)
107#define FFA_MINOR_VERSION_MASK	GENMASK(15, 0)
108#define FFA_MAJOR_VERSION(x)	((u16)(FIELD_GET(FFA_MAJOR_VERSION_MASK, (x))))
109#define FFA_MINOR_VERSION(x)	((u16)(FIELD_GET(FFA_MINOR_VERSION_MASK, (x))))
110#define FFA_PACK_VERSION_INFO(major, minor)			\
111	(FIELD_PREP(FFA_MAJOR_VERSION_MASK, (major)) |		\
112	 FIELD_PREP(FFA_MINOR_VERSION_MASK, (minor)))
113#define FFA_VERSION_1_0		FFA_PACK_VERSION_INFO(1, 0)
114#define FFA_VERSION_1_1		FFA_PACK_VERSION_INFO(1, 1)
115#define FFA_VERSION_1_2		FFA_PACK_VERSION_INFO(1, 2)
116
117/**
118 * FF-A specification mentions explicitly about '4K pages'. This should
119 * not be confused with the kernel PAGE_SIZE, which is the translation
120 * granule kernel is configured and may be one among 4K, 16K and 64K.
121 */
122#define FFA_PAGE_SIZE		SZ_4K
123
124/*
125 * Minimum buffer size/alignment encodings returned by an FFA_FEATURES
126 * query for FFA_RXTX_MAP.
127 */
128#define FFA_FEAT_RXTX_MIN_SZ_4K		0
129#define FFA_FEAT_RXTX_MIN_SZ_64K	1
130#define FFA_FEAT_RXTX_MIN_SZ_16K	2
131#define FFA_FEAT_RXTX_MIN_SZ_MASK	GENMASK(1, 0)
132
133/* FFA Bus/Device/Driver related */
134struct ffa_device {
135	u32 id;
136	u32 properties;
137	int vm_id;
138	bool mode_32bit;
139	uuid_t uuid;
140	struct device dev;
141	const struct ffa_ops *ops;
142};
143
144#define to_ffa_dev(d) container_of(d, struct ffa_device, dev)
145
146struct ffa_device_id {
147	uuid_t uuid;
148};
149
150struct ffa_driver {
151	const char *name;
152	int (*probe)(struct ffa_device *sdev);
153	void (*remove)(struct ffa_device *sdev);
154	const struct ffa_device_id *id_table;
155
156	struct device_driver driver;
157};
158
159#define to_ffa_driver(d) container_of_const(d, struct ffa_driver, driver)
160
161static inline void ffa_dev_set_drvdata(struct ffa_device *fdev, void *data)
162{
163	dev_set_drvdata(&fdev->dev, data);
164}
165
166static inline void *ffa_dev_get_drvdata(struct ffa_device *fdev)
167{
168	return dev_get_drvdata(&fdev->dev);
169}
170
171struct ffa_partition_info;
172
173#if IS_REACHABLE(CONFIG_ARM_FFA_TRANSPORT)
174struct ffa_device *
175ffa_device_register(const struct ffa_partition_info *part_info,
176		    const struct ffa_ops *ops);
177void ffa_device_unregister(struct ffa_device *ffa_dev);
178int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
179			const char *mod_name);
180void ffa_driver_unregister(struct ffa_driver *driver);
181void ffa_devices_unregister(void);
182bool ffa_device_is_valid(struct ffa_device *ffa_dev);
183
184#else
185static inline struct ffa_device *
186ffa_device_register(const struct ffa_partition_info *part_info,
187		    const struct ffa_ops *ops)
188{
189	return NULL;
190}
191
192static inline void ffa_device_unregister(struct ffa_device *dev) {}
193
194static inline void ffa_devices_unregister(void) {}
195
196static inline int
197ffa_driver_register(struct ffa_driver *driver, struct module *owner,
198		    const char *mod_name)
199{
200	return -EINVAL;
201}
202
203static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
204
205static inline
206bool ffa_device_is_valid(struct ffa_device *ffa_dev) { return false; }
207
208#endif /* CONFIG_ARM_FFA_TRANSPORT */
209
210#define ffa_register(driver) \
211	ffa_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
212#define ffa_unregister(driver) \
213	ffa_driver_unregister(driver)
214
215/**
216 * module_ffa_driver() - Helper macro for registering a psa_ffa driver
217 * @__ffa_driver: ffa_driver structure
218 *
219 * Helper macro for psa_ffa drivers to set up proper module init / exit
220 * functions.  Replaces module_init() and module_exit() and keeps people from
221 * printing pointless things to the kernel log when their driver is loaded.
222 */
223#define module_ffa_driver(__ffa_driver)	\
224	module_driver(__ffa_driver, ffa_register, ffa_unregister)
225
226extern const struct bus_type ffa_bus_type;
227
228/* The FF-A 1.0 partition structure lacks the uuid[4] */
229#define FFA_1_0_PARTITON_INFO_SZ	(8)
230
231/* FFA transport related */
232struct ffa_partition_info {
233	u16 id;
234	u16 exec_ctxt;
235/* partition supports receipt of direct requests */
236#define FFA_PARTITION_DIRECT_RECV	BIT(0)
237/* partition can send direct requests. */
238#define FFA_PARTITION_DIRECT_SEND	BIT(1)
239/* partition can send and receive indirect messages. */
240#define FFA_PARTITION_INDIRECT_MSG	BIT(2)
241/* partition can receive notifications */
242#define FFA_PARTITION_NOTIFICATION_RECV	BIT(3)
243/* partition runs in the AArch64 execution state. */
244#define FFA_PARTITION_AARCH64_EXEC	BIT(8)
245/* partition supports receipt of direct request2 */
246#define FFA_PARTITION_DIRECT_REQ2_RECV	BIT(9)
247/* partition can send direct request2. */
248#define FFA_PARTITION_DIRECT_REQ2_SEND	BIT(10)
249	u32 properties;
250	uuid_t uuid;
251};
252
253static inline
254bool ffa_partition_check_property(struct ffa_device *dev, u32 property)
255{
256	return dev->properties & property;
257}
258
259#define ffa_partition_supports_notify_recv(dev)	\
260	ffa_partition_check_property(dev, FFA_PARTITION_NOTIFICATION_RECV)
261
262#define ffa_partition_supports_indirect_msg(dev)	\
263	ffa_partition_check_property(dev, FFA_PARTITION_INDIRECT_MSG)
264
265#define ffa_partition_supports_direct_recv(dev)	\
266	ffa_partition_check_property(dev, FFA_PARTITION_DIRECT_RECV)
267
268#define ffa_partition_supports_direct_req2_recv(dev)	\
269	(ffa_partition_check_property(dev, FFA_PARTITION_DIRECT_REQ2_RECV) && \
270	 !dev->mode_32bit)
271
272/* For use with FFA_MSG_SEND_DIRECT_{REQ,RESP} which pass data via registers */
273struct ffa_send_direct_data {
274	unsigned long data0; /* w3/x3 */
275	unsigned long data1; /* w4/x4 */
276	unsigned long data2; /* w5/x5 */
277	unsigned long data3; /* w6/x6 */
278	unsigned long data4; /* w7/x7 */
279};
280
281struct ffa_indirect_msg_hdr {
282	u32 flags;
283	u32 res0;
284	u32 offset;
285	u32 send_recv_id;
286	u32 size;
287	u32 res1;
288	uuid_t uuid;
289};
290
291/* For use with FFA_MSG_SEND_DIRECT_{REQ,RESP}2 which pass data via registers */
292struct ffa_send_direct_data2 {
293	unsigned long data[14]; /* x4-x17 */
294};
295
296struct ffa_mem_region_addr_range {
297	/* The base IPA of the constituent memory region, aligned to 4 kiB */
298	u64 address;
299	/* The number of 4 kiB pages in the constituent memory region. */
300	u32 pg_cnt;
301	u32 reserved;
302};
303
304struct ffa_composite_mem_region {
305	/*
306	 * The total number of 4 kiB pages included in this memory region. This
307	 * must be equal to the sum of page counts specified in each
308	 * `struct ffa_mem_region_addr_range`.
309	 */
310	u32 total_pg_cnt;
311	/* The number of constituents included in this memory region range */
312	u32 addr_range_cnt;
313	u64 reserved;
314	/** An array of `addr_range_cnt` memory region constituents. */
315	struct ffa_mem_region_addr_range constituents[];
316};
317
318struct ffa_mem_region_attributes {
319	/* The ID of the VM to which the memory is being given or shared. */
320	u16 receiver;
321	/*
322	 * The permissions with which the memory region should be mapped in the
323	 * receiver's page table.
324	 */
325#define FFA_MEM_EXEC		BIT(3)
326#define FFA_MEM_NO_EXEC		BIT(2)
327#define FFA_MEM_RW		BIT(1)
328#define FFA_MEM_RO		BIT(0)
329	u8 attrs;
330	/*
331	 * Flags used during FFA_MEM_RETRIEVE_REQ and FFA_MEM_RETRIEVE_RESP
332	 * for memory regions with multiple borrowers.
333	 */
334#define FFA_MEM_RETRIEVE_SELF_BORROWER	BIT(0)
335	u8 flag;
336	/*
337	 * Offset in bytes from the start of the outer `ffa_memory_region` to
338	 * an `struct ffa_mem_region_addr_range`.
339	 */
340	u32 composite_off;
341	u8 impdef_val[16];
342	u64 reserved;
343};
344
345struct ffa_mem_region {
346	/* The ID of the VM/owner which originally sent the memory region */
347	u16 sender_id;
348#define FFA_MEM_NORMAL		BIT(5)
349#define FFA_MEM_DEVICE		BIT(4)
350
351#define FFA_MEM_WRITE_BACK	(3 << 2)
352#define FFA_MEM_NON_CACHEABLE	(1 << 2)
353
354#define FFA_DEV_nGnRnE		(0 << 2)
355#define FFA_DEV_nGnRE		(1 << 2)
356#define FFA_DEV_nGRE		(2 << 2)
357#define FFA_DEV_GRE		(3 << 2)
358
359#define FFA_MEM_NON_SHAREABLE	(0)
360#define FFA_MEM_OUTER_SHAREABLE	(2)
361#define FFA_MEM_INNER_SHAREABLE	(3)
362	/* Memory region attributes, upper byte MBZ pre v1.1 */
363	u16 attributes;
364/*
365 * Clear memory region contents after unmapping it from the sender and
366 * before mapping it for any receiver.
367 */
368#define FFA_MEM_CLEAR			BIT(0)
369/*
370 * Whether the hypervisor may time slice the memory sharing or retrieval
371 * operation.
372 */
373#define FFA_TIME_SLICE_ENABLE		BIT(1)
374
375#define FFA_MEM_RETRIEVE_TYPE_IN_RESP	(0 << 3)
376#define FFA_MEM_RETRIEVE_TYPE_SHARE	(1 << 3)
377#define FFA_MEM_RETRIEVE_TYPE_LEND	(2 << 3)
378#define FFA_MEM_RETRIEVE_TYPE_DONATE	(3 << 3)
379
380#define FFA_MEM_RETRIEVE_ADDR_ALIGN_HINT	BIT(9)
381#define FFA_MEM_RETRIEVE_ADDR_ALIGN(x)		((x) << 5)
382	/* Flags to control behaviour of the transaction. */
383	u32 flags;
384#define HANDLE_LOW_MASK		GENMASK_ULL(31, 0)
385#define HANDLE_HIGH_MASK	GENMASK_ULL(63, 32)
386#define HANDLE_LOW(x)		((u32)(FIELD_GET(HANDLE_LOW_MASK, (x))))
387#define	HANDLE_HIGH(x)		((u32)(FIELD_GET(HANDLE_HIGH_MASK, (x))))
388
389#define PACK_HANDLE(l, h)		\
390	(FIELD_PREP(HANDLE_LOW_MASK, (l)) | FIELD_PREP(HANDLE_HIGH_MASK, (h)))
391	/*
392	 * A globally-unique ID assigned by the hypervisor for a region
393	 * of memory being sent between VMs.
394	 */
395	u64 handle;
396	/*
397	 * An implementation defined value associated with the receiver and the
398	 * memory region.
399	 */
400	u64 tag;
401	/* Size of each endpoint memory access descriptor, MBZ pre v1.1 */
402	u32 ep_mem_size;
403	/*
404	 * The number of `ffa_mem_region_attributes` entries included in this
405	 * transaction.
406	 */
407	u32 ep_count;
408	/*
409	 * 16-byte aligned offset from the base address of this descriptor
410	 * to the first element of the endpoint memory access descriptor array
411	 * Valid only from v1.1
412	 */
413	u32 ep_mem_offset;
414	/* MBZ, valid only from v1.1 */
415	u32 reserved[3];
416};
417
418#define CONSTITUENTS_OFFSET(x)	\
419	(offsetof(struct ffa_composite_mem_region, constituents[x]))
420
421#define FFA_EMAD_HAS_IMPDEF_FIELD(version)	((version) >= FFA_VERSION_1_2)
422#define FFA_MEM_REGION_HAS_EP_MEM_OFFSET(version) ((version) > FFA_VERSION_1_0)
423
424static inline u32 ffa_emad_size_get(u32 ffa_version)
425{
426	u32 sz;
427	struct ffa_mem_region_attributes *ep_mem_access;
428
429	if (FFA_EMAD_HAS_IMPDEF_FIELD(ffa_version))
430		sz = sizeof(*ep_mem_access);
431	else
432		sz = sizeof(*ep_mem_access) - sizeof(ep_mem_access->impdef_val);
433
434	return sz;
435}
436
437static inline u32
438ffa_mem_desc_offset(struct ffa_mem_region *buf, int count, u32 ffa_version)
439{
440	u32 offset = count * ffa_emad_size_get(ffa_version);
441	/*
442	 * Earlier to v1.1, the endpoint memory descriptor array started at
443	 * offset 32(i.e. offset of ep_mem_offset in the current structure)
444	 */
445	if (!FFA_MEM_REGION_HAS_EP_MEM_OFFSET(ffa_version))
446		offset += offsetof(struct ffa_mem_region, ep_mem_offset);
447	else
448		offset += sizeof(struct ffa_mem_region);
449
450	return offset;
451}
452
453struct ffa_mem_ops_args {
454	bool use_txbuf;
455	u32 nattrs;
456	u32 flags;
457	u64 tag;
458	u64 g_handle;
459	struct scatterlist *sg;
460	struct ffa_mem_region_attributes *attrs;
461};
462
463struct ffa_info_ops {
464	u32 (*api_version_get)(void);
465	int (*partition_info_get)(const char *uuid_str,
466				  struct ffa_partition_info *buffer);
467};
468
469struct ffa_msg_ops {
470	void (*mode_32bit_set)(struct ffa_device *dev);
471	int (*sync_send_receive)(struct ffa_device *dev,
472				 struct ffa_send_direct_data *data);
473	int (*indirect_send)(struct ffa_device *dev, void *buf, size_t sz);
474	int (*sync_send_receive2)(struct ffa_device *dev,
475				  struct ffa_send_direct_data2 *data);
476};
477
478struct ffa_mem_ops {
479	int (*memory_reclaim)(u64 g_handle, u32 flags);
480	int (*memory_share)(struct ffa_mem_ops_args *args);
481	int (*memory_lend)(struct ffa_mem_ops_args *args);
482};
483
484struct ffa_cpu_ops {
485	int (*run)(struct ffa_device *dev, u16 vcpu);
486};
487
488typedef void (*ffa_sched_recv_cb)(u16 vcpu, bool is_per_vcpu, void *cb_data);
489typedef void (*ffa_notifier_cb)(int notify_id, void *cb_data);
490typedef void (*ffa_fwk_notifier_cb)(int notify_id, void *cb_data, void *buf);
491
492struct ffa_notifier_ops {
493	int (*sched_recv_cb_register)(struct ffa_device *dev,
494				      ffa_sched_recv_cb cb, void *cb_data);
495	int (*sched_recv_cb_unregister)(struct ffa_device *dev);
496	int (*notify_request)(struct ffa_device *dev, bool per_vcpu,
497			      ffa_notifier_cb cb, void *cb_data, int notify_id);
498	int (*notify_relinquish)(struct ffa_device *dev, int notify_id);
499	int (*fwk_notify_request)(struct ffa_device *dev,
500				  ffa_fwk_notifier_cb cb, void *cb_data,
501				  int notify_id);
502	int (*fwk_notify_relinquish)(struct ffa_device *dev, int notify_id);
503	int (*notify_send)(struct ffa_device *dev, int notify_id, bool per_vcpu,
504			   u16 vcpu);
505};
506
507struct ffa_ops {
508	const struct ffa_info_ops *info_ops;
509	const struct ffa_msg_ops *msg_ops;
510	const struct ffa_mem_ops *mem_ops;
511	const struct ffa_cpu_ops *cpu_ops;
512	const struct ffa_notifier_ops *notifier_ops;
513};
514
515#endif /* _LINUX_ARM_FFA_H */