// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (C) 2023 ARM Ltd.
*/
#include <linux/arm-rsi-cmds.h>
#include <linux/arm-smccc-bus.h>
#include <linux/arm-smccc-rsi.h>
#include <linux/cc_platform.h>
#include <linux/kernel.h>
#include <linux/device-id/platform.h>
#include <linux/module.h>
#include <linux/smp.h>
#include <linux/tsm.h>
#include <linux/types.h>
/**
* struct arm_cca_token_info - a descriptor for the token buffer.
* @granule: PA of the granule to which the token will be written
* @offset: Offset within granule to start of buffer in bytes
*/
struct arm_cca_token_info {
phys_addr_t granule;
unsigned long offset;
};
/**
* arm_cca_attestation_continue - Retrieve the attestation token data.
*
* @info: pointer to the arm_cca_token_info
*
* Attestation token generation is a long running operation and therefore
* the token data may not be retrieved in a single call. Moreover, the
* token retrieval operation must be requested on the same CPU on which the
* attestation token generation was initialised.
* This helper function must therefore be executed on the same CPU multiple
* times until the entire token data is retrieved.
*/
static unsigned long
arm_cca_attestation_continue(struct arm_cca_token_info *info)
{
unsigned long ret;
unsigned long len;
unsigned long size;
size = RSI_GRANULE_SIZE - info->offset;
ret = rsi_attestation_token_continue(info->granule, info->offset, size,
&len);
info->offset += len;
return ret;
}
/**
* arm_cca_report_new - Generate a new attestation token.
*
* @report: pointer to the TSM report context information.
* @data: pointer to the context specific data for this module.
*
* Initialise the attestation token generation using the challenge data
* passed in the TSM descriptor. Allocate memory for the attestation token
* and retrieve the attestation token on the same CPU on which the
* attestation token generation was initialised.
*
* The challenge data must be at least 32 bytes and no more than 64 bytes. If
* less than 64 bytes are provided it will be zero padded to 64 bytes.
*
* Return:
* * %0 - Attestation token generated successfully.
* * %-EINVAL - A parameter was not valid.
* * %-ENOMEM - Out of memory.
* * %-EFAULT - Failed to get IPA for memory page(s).
*/
static int arm_cca_report_new(struct tsm_report *report, void *data)
{
int ret = 0;
unsigned long rsi_result;
long max_size;
unsigned long token_size = 0;
struct arm_cca_token_info info;
void *buf;
u8 *token __free(kvfree) = NULL;
struct tsm_report_desc *desc = &report->desc;
if (desc->inblob_len < 32 || desc->inblob_len > 64)
return -EINVAL;
/*
* The attestation token 'init' and 'continue' calls must be
* performed on the same CPU, so disable CPU migration around
* those operations.
*/
migrate_disable();
max_size = rsi_attestation_token_init(desc->inblob, desc->inblob_len);
if (max_size <= 0) {
ret = -EINVAL;
goto exit_migrate_enable;
}
/* Allocate outblob */
token = kvzalloc(max_size, GFP_KERNEL);
if (!token) {
ret = -ENOMEM;
goto exit_migrate_enable;
}
/*
* Since the outblob may not be physically contiguous, use a page
* to bounce the buffer from RMM.
*/
buf = alloc_pages_exact(RSI_GRANULE_SIZE, GFP_KERNEL);
if (!buf) {
ret = -ENOMEM;
goto exit_migrate_enable;
}
/* Get the PA of the memory page(s) that were allocated */
info.granule = (unsigned long)virt_to_phys(buf);
/* Loop until the token is ready or there is an error */
do {
/* Retrieve one RSI_GRANULE_SIZE data per loop iteration */
info.offset = 0;
do {
/*
* Retrieve a sub-granule chunk of data per loop
* iteration.
*/
rsi_result = arm_cca_attestation_continue(&info);
} while (rsi_result == RSI_INCOMPLETE &&
info.offset < RSI_GRANULE_SIZE);
/* Break out in case of failure */
if (rsi_result != RSI_SUCCESS && rsi_result != RSI_INCOMPLETE) {
ret = -ENXIO;
token_size = 0;
goto exit_free_granule_page;
}
/*
* Copy the retrieved token data from the granule
* to the token buffer, ensuring that the RMM doesn't
* overflow the buffer.
*/
if (WARN_ON(token_size + info.offset > max_size))
break;
memcpy(&token[token_size], buf, info.offset);
token_size += info.offset;
} while (rsi_result == RSI_INCOMPLETE);
report->outblob = no_free_ptr(token);
exit_free_granule_page:
report->outblob_len = token_size;
free_pages_exact(buf, RSI_GRANULE_SIZE);
exit_migrate_enable:
migrate_enable();
return ret;
}
static const struct tsm_report_ops arm_cca_tsm_report_ops = {
.name = KBUILD_MODNAME,
.report_new = arm_cca_report_new,
};
static int cca_tsm_probe(struct arm_smccc_device *sdev)
{
int ret;
if (!is_realm_world())
return -ENODEV;
ret = tsm_report_register(&arm_cca_tsm_report_ops, NULL);
if (ret < 0)
return dev_err_probe(&sdev->dev,
ret, "Error registering with TSM\n");
return 0;
}
static void cca_tsm_remove(struct arm_smccc_device *sdev)
{
tsm_report_unregister(&arm_cca_tsm_report_ops);
}
static const struct arm_smccc_device_id cca_tsm_id_table[] = {
{ .func_id = SMC_RSI_ABI_VERSION },
{}
};
MODULE_DEVICE_TABLE(arm_smccc, cca_tsm_id_table);
static struct arm_smccc_driver cca_tsm_driver = {
.name = KBUILD_MODNAME,
.probe = cca_tsm_probe,
.remove = cca_tsm_remove,
.id_table = cca_tsm_id_table,
};
module_arm_smccc_driver(cca_tsm_driver);
MODULE_AUTHOR("Sami Mujawar <sami.mujawar@arm.com>");
MODULE_DESCRIPTION("Arm CCA Guest TSM Driver");
MODULE_LICENSE("GPL");