[3/8] arm_ffa: Add FFA_MEM_RECLAIM support

From: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>

Add to the FF-A bus FFA_MEM_RECLAIM ABI

The FFA_MEM_RECLAIM is a memory management ABI described in the FF-A
v1.0 specification [1].

This ABI restores exclusive access to a memory region back to its Owner.

This work is based on the implementation in Linux [2].

[1]: https://developer.arm.com/documentation/den0077/a/?lang=en
[2]: commit cc2195fe536c28e192df5d07e6dd277af36814b4
     File: drivers/firmware/arm_ffa/driver.c

Signed-off-by: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
---
 doc/arch/arm64.ffa.rst                    |  2 +
 drivers/firmware/arm-ffa/arm-ffa-uclass.c | 70 +++++++++++++++++++++++
 drivers/firmware/arm-ffa/arm-ffa.c        |  1 +
 include/arm_ffa.h                         | 25 +++++++-
 include/arm_ffa_priv.h                    |  3 +-
 5 files changed, 99 insertions(+), 2 deletions(-)

[...]
>  }
>
> +/**
> + * ffa_memory_reclaim_hdlr() - FFA_MEM_RECLAIM handler function
> + * @dev: The FF-A bus device
> + * @g_handle: The memory region globally unique Handle
> + * @flags: Zero memory and time slicing flags
> + *
> + * Implement FFA_MEM_RECLAIM FF-A function
> + * to restore exclusive access to a memory region back to its Owner.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_memory_reclaim_hdlr(struct udevice *dev, u64 g_handle, u32 flags)
> +{
> +	ffa_value_t res;
> +	int ffa_errno;
> +
> +	invoke_ffa_fn((ffa_value_t){
> +			.a0 = FFA_SMC_32(FFA_MEM_RECLAIM),
> +			.a1 = HANDLE_LOW(g_handle), .a2 = HANDLE_HIGH(g_handle),
> +			.a3 = flags,
> +			},
> +			&res
> +	);
> +
> +	if (res.a0 != FFA_SMC_32(FFA_SUCCESS)) {
> +		ffa_errno = res.a2;
> +		ffa_print_error_log(FFA_MEM_RECLAIM, ffa_errno);
> +		return ffa_to_std_errno(ffa_errno);
> +	}
> +
> +	return 0;
> +}

Is there a reason you have to define both ffa_memory_reclaim_hdlr() and ffa_memory_reclaim()?
Can't you just move the checks of ffa_memory_reclaim() to
ffa_memory_reclaim_hdlr()?

> +
>  /* FF-A driver operations (used by clients for communicating with FF-A)*/
>
>  /**
> @@ -1214,6 +1261,29 @@ int ffa_memory_share(struct udevice *dev, struct ffa_mem_ops_args *args)
>  	return ops->memory_share(dev, args);
>  }
>
> +/**
> + * ffa_memory_reclaim() - FFA_MEM_RECLAIM driver operation
> + * @dev: The FF-A bus device
> + * @g_handle: The memory region globally unique Handle
> + * @flags: Zero memory and time slicing flags
> + *
> + * Driver operation for FFA_MEM_RECLAIM.
> + * Please see ffa_memory_reclaim_hdlr() description for more details.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_memory_reclaim(struct udevice *dev, u64 g_handle, u32 flags)
> +{
> +	struct ffa_bus_ops *ops = ffa_get_ops(dev);
> +
> +	if (!ops || !ops->memory_reclaim)
> +		return -ENOSYS;
> +
> +	return ops->memory_reclaim(dev, g_handle, flags);
> +}
> +
>  /**
>   * ffa_do_probe() - probing FF-A framework
>   * @dev:	the FF-A bus device (arm_ffa)
> diff --git a/drivers/firmware/arm-ffa/arm-ffa.c b/drivers/firmware/arm-ffa/arm-ffa.c
> index c4211c953ef..b7e751e3821 100644
> --- a/drivers/firmware/arm-ffa/arm-ffa.c
> +++ b/drivers/firmware/arm-ffa/arm-ffa.c
> @@ -85,6 +85,7 @@ static const struct ffa_bus_ops ffa_ops = {
>  	.sync_send_receive = ffa_msg_send_direct_req_hdlr,
>  	.rxtx_unmap = ffa_unmap_rxtx_buffers_hdlr,
>  	.memory_share = ffa_memory_share_hdlr,
> +	.memory_reclaim = ffa_memory_reclaim_hdlr,
>  };
>

[...]

Thanks
/Ilias

Hi Ilias,

> > +/**
> > + * ffa_memory_reclaim_hdlr() - FFA_MEM_RECLAIM handler function
> > + * @dev: The FF-A bus device
> > + * @g_handle: The memory region globally unique Handle
> > + * @flags: Zero memory and time slicing flags
> > + *
> > + * Implement FFA_MEM_RECLAIM FF-A function
> > + * to restore exclusive access to a memory region back to its Owner.
> > + *
> > + * Return:
> > + *
> > + * 0 on success. Otherwise, failure
> > + */
> > +int ffa_memory_reclaim_hdlr(struct udevice *dev, u64 g_handle, u32 flags)
> > +{
> > +	ffa_value_t res;
> > +	int ffa_errno;
> > +
> > +	invoke_ffa_fn((ffa_value_t){
> > +			.a0 = FFA_SMC_32(FFA_MEM_RECLAIM),
> > +			.a1 = HANDLE_LOW(g_handle), .a2 = HANDLE_HIGH(g_handle),
> > +			.a3 = flags,
> > +			},
> > +			&res
> > +	);
> > +
> > +	if (res.a0 != FFA_SMC_32(FFA_SUCCESS)) {
> > +		ffa_errno = res.a2;
> > +		ffa_print_error_log(FFA_MEM_RECLAIM, ffa_errno);
> > +		return ffa_to_std_errno(ffa_errno);
> > +	}
> > +
> > +	return 0;
> > +}
> 
> Is there a reason you have to define both ffa_memory_reclaim_hdlr() and ffa_memory_reclaim()?
> Can't you just move the checks of ffa_memory_reclaim() to
> ffa_memory_reclaim_hdlr()?

Yes, ffa_memory_reclaim() is the FF-A bus operation which is called by upper layers (clients).

ffa_memory_reclaim_hdlr() is the low level handler called by the operation.

The handler is set by the driver (e.g: Arm driver, sandbox driver) in the driver's ops structure [5].

So, the driver can set the handler and define its own if needed.

The client doesn't know which handler to use. It just calls the driver operation.

This design was followed in the other ABIs already merged. For example [1][2][3][4].

[1]: ffa_rxtx_unmap() operation: drivers/firmware/arm-ffa/arm-ffa-uclass.c#L999
[2]: ffa_unmap_rxtx_buffers_hdlr() handler: drivers/firmware/arm-ffa/arm-ffa-uclass.c#L999
[3]: rxtx_unmap ops callback in sandbox driver: drivers/firmware/arm-ffa/sandbox_ffa.c#L93
[4]: rxtx_unmap ops callback in Arm driver: drivers/firmware/arm-ffa/arm-ffa.c#L86
[5]: Arm's driver ops structure: drivers/firmware/arm-ffa/arm-ffa.c#L83

> > +
> >  /* FF-A driver operations (used by clients for communicating with FF-A)*/
> > ...
> > +/**
> > + * ffa_memory_reclaim() - FFA_MEM_RECLAIM driver operation
> > + * @dev: The FF-A bus device
> > + * @g_handle: The memory region globally unique Handle
> > + * @flags: Zero memory and time slicing flags
> > + *
> > + * Driver operation for FFA_MEM_RECLAIM.
> > + * Please see ffa_memory_reclaim_hdlr() description for more details.
> > + *
> > + * Return:
> > + *
> > + * 0 on success. Otherwise, failure
> > + */
> > +int ffa_memory_reclaim(struct udevice *dev, u64 g_handle, u32 flags)
> > +{
> > +	struct ffa_bus_ops *ops = ffa_get_ops(dev);
> > +
> > +	if (!ops || !ops->memory_reclaim)
> > +		return -ENOSYS;
> > +
> > +	return ops->memory_reclaim(dev, g_handle, flags);
> > +}

Cheers,
Abdellatif