Commit 93b7c6b3 authored by Stefano Garzarella's avatar Stefano Garzarella Committed by Borislav Petkov (AMD)
Browse files

tpm: Add SNP SVSM vTPM driver 



Add 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 (VMPL0).

The new tpm-svsm platform driver uses API exposed by the x86/sev core
implementation interface to a SVSM to send commands and receive responses.

The device cannot be hot-plugged/unplugged as it is emulated by the platform,
so module_platform_driver_probe() can be used. The device will be registered
by the platform only when it's available, so the probe function just needs to
setup the tpm_chip.

This device does not support interrupts and sends responses to commands
synchronously.

In order to have .recv() called just after .send() in tpm_try_transmit(), the
.status() callback is not implemented as recently supported by commit

  980a5736 ("tpm: Make chip->{status,cancel,req_canceled} opt").

  [1] "Secure VM Service Module for SEV-SNP Guests"
      Publication # 58019 Revision: 1.00

  [ bp: Massage commit message. ]

Signed-off-by: default avatarStefano Garzarella <sgarzare@redhat.com>
Signed-off-by: default avatarBorislav Petkov (AMD) <bp@alien8.de>
Reviewed-by: default avatarJarkko Sakkinen <jarkko@kernel.org>
Link: https://lore.kernel.org/r/20250410135118.133240-4-sgarzare@redhat.com
parent b2849b07

drivers/char/tpm/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -234,5 +234,15 @@ config TCG_FTPM_TEE 
	help

	  This driver proxies for firmware TPM running in TEE.



config TCG_SVSM

	tristate "SNP SVSM vTPM interface"

	depends on AMD_MEM_ENCRYPT

	help

	  This is a driver for the AMD SVSM vTPM 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).  To compile this driver as a module, choose M

	  here; the module will be called tpm_svsm.



source "drivers/char/tpm/st33zp24/Kconfig"

endif # TCG_TPM

drivers/char/tpm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -45,3 +45,4 @@ obj-$(CONFIG_TCG_CRB) += tpm_crb.o 
obj-$(CONFIG_TCG_ARM_CRB_FFA) += tpm_crb_ffa.o

obj-$(CONFIG_TCG_VTPM_PROXY) += tpm_vtpm_proxy.o

obj-$(CONFIG_TCG_FTPM_TEE) += tpm_ftpm_tee.o

obj-$(CONFIG_TCG_SVSM) += tpm_svsm.o

drivers/char/tpm/tpm_svsm.c

0 → 100644
+125 −0
Original line number Diff line number Diff line 
// 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 len)

{

	struct tpm_svsm_priv *priv = dev_get_drvdata(&chip->dev);

	int ret;



	ret = svsm_vtpm_cmd_request_fill(priv->buffer, 0, buf, 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

	 * that can be used by .recv() op.

	 */

	return snp_svsm_vtpm_send_command(priv->buffer);

}



static int tpm_svsm_recv(struct tpm_chip *chip, u8 *buf, size_t len)

{

	struct tpm_svsm_priv *priv = dev_get_drvdata(&chip->dev);



	/*

	 * The internal buffer contains the response after we send the command

	 * to SVSM.

	 */

	return svsm_vtpm_cmd_response_parse(priv->buffer, buf, len);

}



static struct tpm_class_ops tpm_chip_ops = {

	.flags = TPM_OPS_AUTO_STARTUP,

	.recv = tpm_svsm_recv,

	.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);



	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");