ffa.h File Reference

#include <asm/kvm_host.h>

Include dependency graph for ffa.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FFA_MIN_FUNC_NUM   0x60
#define	FFA_MAX_FUNC_NUM   0x7F

Functions
int	hyp_ffa_init (void *pages)
bool	kvm_host_ffa_handler (struct kvm_cpu_context *host_ctxt, u32 func_id)

Macro Definition Documentation

FFA_MAX_FUNC_NUM

#define FFA_MAX_FUNC_NUM   0x7F

Definition at line 12 of file ffa.h.

FFA_MIN_FUNC_NUM

#define FFA_MIN_FUNC_NUM   0x60

Definition at line 11 of file ffa.h.

Function Documentation

hyp_ffa_init()

int hyp_ffa_init

(

void *

pages

)

Definition at line 700 of file ffa.c.

{
    struct arm_smccc_res res;
    size_t min_rxtx_sz;
    void *tx, *rx;
 
    if (kvm_host_psci_config.smccc_version < ARM_SMCCC_VERSION_1_2)
        return 0;
 
    arm_smccc_1_1_smc(FFA_VERSION, FFA_VERSION_1_0, 0, 0, 0, 0, 0, 0, &res);
    if (res.a0 == FFA_RET_NOT_SUPPORTED)
        return 0;
 
    /*
     * Firmware returns the maximum supported version of the FF-A
     * implementation. Check that the returned version is
     * backwards-compatible with the hyp according to the rules in DEN0077A
     * v1.1 REL0 13.2.1.
     *
     * Of course, things are never simple when dealing with firmware. v1.1
     * broke ABI with v1.0 on several structures, which is itself
     * incompatible with the aforementioned versioning scheme. The
     * expectation is that v1.x implementations that do not support the v1.0
     * ABI return NOT_SUPPORTED rather than a version number, according to
     * DEN0077A v1.1 REL0 18.6.4.
     */
    if (FFA_MAJOR_VERSION(res.a0) != 1)
        return -EOPNOTSUPP;
 
    arm_smccc_1_1_smc(FFA_ID_GET, 0, 0, 0, 0, 0, 0, 0, &res);
    if (res.a0 != FFA_SUCCESS)
        return -EOPNOTSUPP;
 
    if (res.a2 != HOST_FFA_ID)
        return -EINVAL;
 
    arm_smccc_1_1_smc(FFA_FEATURES, FFA_FN64_RXTX_MAP,
              0, 0, 0, 0, 0, 0, &res);
    if (res.a0 != FFA_SUCCESS)
        return -EOPNOTSUPP;
 
    switch (res.a2) {
    case FFA_FEAT_RXTX_MIN_SZ_4K:
        min_rxtx_sz = SZ_4K;
        break;
    case FFA_FEAT_RXTX_MIN_SZ_16K:
        min_rxtx_sz = SZ_16K;
        break;
    case FFA_FEAT_RXTX_MIN_SZ_64K:
        min_rxtx_sz = SZ_64K;
        break;
    default:
        return -EINVAL;
    }
 
    if (min_rxtx_sz > PAGE_SIZE)
        return -EOPNOTSUPP;
 
    tx = pages;
    pages += KVM_FFA_MBOX_NR_PAGES * PAGE_SIZE;
    rx = pages;
    pages += KVM_FFA_MBOX_NR_PAGES * PAGE_SIZE;
 
    ffa_desc_buf = (struct kvm_ffa_descriptor_buffer) {
        .buf    = pages,
        .len    = PAGE_SIZE *
              (hyp_ffa_proxy_pages() - (2 * KVM_FFA_MBOX_NR_PAGES)),
    };
 
    hyp_buffers = (struct kvm_ffa_buffers) {
        .lock   = __HYP_SPIN_LOCK_UNLOCKED,
        .tx = tx,
        .rx = rx,
    };
 
    host_buffers = (struct kvm_ffa_buffers) {
        .lock   = __HYP_SPIN_LOCK_UNLOCKED,
    };
 
    return 0;
}

Here is the caller graph for this function:

kvm_host_ffa_handler()

bool kvm_host_ffa_handler	(	struct kvm_cpu_context *	host_ctxt,
		u32	func_id
	)

Definition at line 643 of file ffa.c.

{
    struct arm_smccc_res res;
 
    /*
     * There's no way we can tell what a non-standard SMC call might
     * be up to. Ideally, we would terminate these here and return
     * an error to the host, but sadly devices make use of custom
     * firmware calls for things like power management, debugging,
     * RNG access and crash reporting.
     *
     * Given that the architecture requires us to trust EL3 anyway,
     * we forward unrecognised calls on under the assumption that
     * the firmware doesn't expose a mechanism to access arbitrary
     * non-secure memory. Short of a per-device table of SMCs, this
     * is the best we can do.
     */
    if (!is_ffa_call(func_id))
        return false;
 
    switch (func_id) {
    case FFA_FEATURES:
        if (!do_ffa_features(&res, host_ctxt))
            return false;
        goto out_handled;
    /* Memory management */
    case FFA_FN64_RXTX_MAP:
        do_ffa_rxtx_map(&res, host_ctxt);
        goto out_handled;
    case FFA_RXTX_UNMAP:
        do_ffa_rxtx_unmap(&res, host_ctxt);
        goto out_handled;
    case FFA_MEM_SHARE:
    case FFA_FN64_MEM_SHARE:
        do_ffa_mem_xfer(FFA_FN64_MEM_SHARE, &res, host_ctxt);
        goto out_handled;
    case FFA_MEM_RECLAIM:
        do_ffa_mem_reclaim(&res, host_ctxt);
        goto out_handled;
    case FFA_MEM_LEND:
    case FFA_FN64_MEM_LEND:
        do_ffa_mem_xfer(FFA_FN64_MEM_LEND, &res, host_ctxt);
        goto out_handled;
    case FFA_MEM_FRAG_TX:
        do_ffa_mem_frag_tx(&res, host_ctxt);
        goto out_handled;
    }
 
    if (ffa_call_supported(func_id))
        return false; /* Pass through */
 
    ffa_to_smccc_error(&res, FFA_RET_NOT_SUPPORTED);
out_handled:
    ffa_set_retval(host_ctxt, &res);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: