Quelle  tpm_svsm.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2025 Red Hat, Inc. All Rights Reserved.
 *
 * Driver for the vTPM defined by the AMD SVSM spec [1].
 *
 * The specification defines a protocol that a SEV-SNP guest OS can use to
 * discover and talk to a vTPM emulated by the Secure VM Service Module (SVSM)
 * in the guest context, but at a more privileged level (usually VMPL0).
 *
 * [1] "Secure VM Service Module for SEV-SNP Guests"
 *     Publication # 58019 Revision: 1.00
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/tpm_svsm.h>

#include <asm/sev.h>

#include "tpm.h"

struct tpm_svsm_priv {
 void *buffer;
};

static int tpm_svsm_send(struct tpm_chip *chip, u8 *buf, size_t bufsiz,
    size_t cmd_len)
{
 struct tpm_svsm_priv *priv = dev_get_drvdata(&chip->dev);
 int ret;

 ret = svsm_vtpm_cmd_request_fill(priv->buffer, 0, buf, cmd_len);
 if (ret)
  return ret;

 /*
 * The SVSM call uses the same buffer for the command and for the
 * response, so after this call, the buffer will contain the response.
 *
 * Note: we have to use an internal buffer because the device in SVSM
 * expects the svsm_vtpm header + data to be physically contiguous.
 */
 ret = snp_svsm_vtpm_send_command(priv->buffer);
 if (ret)
  return ret;

 return svsm_vtpm_cmd_response_parse(priv->buffer, buf, bufsiz);
}

static struct tpm_class_ops tpm_chip_ops = {
 .flags = TPM_OPS_AUTO_STARTUP,
 .send = tpm_svsm_send,
};

static int __init tpm_svsm_probe(struct platform_device *pdev)
{
 struct device *dev = &pdev->dev;
 struct tpm_svsm_priv *priv;
 struct tpm_chip *chip;
 int err;

 priv = devm_kmalloc(dev, sizeof(*priv), GFP_KERNEL);
 if (!priv)
  return -ENOMEM;

 /*
 * The maximum buffer supported is one page (see SVSM_VTPM_MAX_BUFFER
 * in tpm_svsm.h).
 */
 priv->buffer = (void *)devm_get_free_pages(dev, GFP_KERNEL, 0);
 if (!priv->buffer)
  return -ENOMEM;

 chip = tpmm_chip_alloc(dev, &tpm_chip_ops);
 if (IS_ERR(chip))
  return PTR_ERR(chip);

 dev_set_drvdata(&chip->dev, priv);

 chip->flags |= TPM_CHIP_FLAG_SYNC;
 err = tpm2_probe(chip);
 if (err)
  return err;

 err = tpm_chip_register(chip);
 if (err)
  return err;

 dev_info(dev, "SNP SVSM vTPM %s device\n",
   (chip->flags & TPM_CHIP_FLAG_TPM2) ? "2.0" : "1.2");

 return 0;
}

static void __exit tpm_svsm_remove(struct platform_device *pdev)
{
 struct tpm_chip *chip = platform_get_drvdata(pdev);

 tpm_chip_unregister(chip);
}

/*
 * tpm_svsm_remove() lives in .exit.text. For drivers registered via
 * module_platform_driver_probe() this is ok because they cannot get unbound
 * at runtime. So mark the driver struct with __refdata to prevent modpost
 * triggering a section mismatch warning.
 */
static struct platform_driver tpm_svsm_driver __refdata = {
 .remove = __exit_p(tpm_svsm_remove),
 .driver = {
  .name = "tpm-svsm",
 },
};

module_platform_driver_probe(tpm_svsm_driver, tpm_svsm_probe);

MODULE_DESCRIPTION("SNP SVSM vTPM Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:tpm-svsm");