aboutsummaryrefslogtreecommitdiffstats
path: root/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71-e3000/0023-crypto-ccp-Add-Secure-Encrypted-Virtualization-SEV-c.patch
diff options
context:
space:
mode:
Diffstat (limited to 'meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71-e3000/0023-crypto-ccp-Add-Secure-Encrypted-Virtualization-SEV-c.patch')
-rw-r--r--meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71-e3000/0023-crypto-ccp-Add-Secure-Encrypted-Virtualization-SEV-c.patch678
1 files changed, 678 insertions, 0 deletions
diff --git a/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71-e3000/0023-crypto-ccp-Add-Secure-Encrypted-Virtualization-SEV-c.patch b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71-e3000/0023-crypto-ccp-Add-Secure-Encrypted-Virtualization-SEV-c.patch
new file mode 100644
index 00000000..03c0d5a3
--- /dev/null
+++ b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71-e3000/0023-crypto-ccp-Add-Secure-Encrypted-Virtualization-SEV-c.patch
@@ -0,0 +1,678 @@
+From af510af728dde095118afc345e5cc4e1e6551c54 Mon Sep 17 00:00:00 2001
+From: Brijesh Singh <brijesh.singh@amd.com>
+Date: Mon, 4 Dec 2017 10:57:28 -0600
+Subject: [PATCH 23/95] crypto: ccp: Add Secure Encrypted Virtualization (SEV)
+ command support
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+AMD's new Secure Encrypted Virtualization (SEV) feature allows the
+memory contents of virtual machines to be transparently encrypted with a
+key unique to the VM. The programming and management of the encryption
+keys are handled by the AMD Secure Processor (AMD-SP) which exposes the
+commands for these tasks. The complete spec is available at:
+
+http://support.amd.com/TechDocs/55766_SEV-KM%20API_Specification.pdf
+
+Extend the AMD-SP driver to provide the following support:
+
+ - an in-kernel API to communicate with the SEV firmware. The API can be
+ used by the hypervisor to create encryption context for a SEV guest.
+
+ - a userspace IOCTL to manage the platform certificates.
+
+Cc: Paolo Bonzini <pbonzini@redhat.com>
+Cc: "Radim Krčmář" <rkrcmar@redhat.com>
+Cc: Borislav Petkov <bp@suse.de>
+Cc: Herbert Xu <herbert@gondor.apana.org.au>
+Cc: Gary Hook <gary.hook@amd.com>
+Cc: Tom Lendacky <thomas.lendacky@amd.com>
+Cc: linux-crypto@vger.kernel.org
+Cc: kvm@vger.kernel.org
+Cc: linux-kernel@vger.kernel.org
+Improvements-by: Borislav Petkov <bp@suse.de>
+Signed-off-by: Brijesh Singh <brijesh.singh@amd.com>
+Signed-off-by: Sudheesh Mavila <sudheesh.mavila@amd.com>
+---
+ drivers/crypto/ccp/psp-dev.c | 344 +++++++++++++++++++++++++++++++++++++++++++
+ drivers/crypto/ccp/psp-dev.h | 24 +++
+ drivers/crypto/ccp/sp-dev.c | 9 ++
+ drivers/crypto/ccp/sp-dev.h | 4 +
+ include/linux/psp-sev.h | 137 +++++++++++++++++
+ 5 files changed, 518 insertions(+)
+
+diff --git a/drivers/crypto/ccp/psp-dev.c b/drivers/crypto/ccp/psp-dev.c
+index b5789f87..9915a6c 100644
+--- a/drivers/crypto/ccp/psp-dev.c
++++ b/drivers/crypto/ccp/psp-dev.c
+@@ -26,6 +26,12 @@
+ #include "sp-dev.h"
+ #include "psp-dev.h"
+
++#define DEVICE_NAME "sev"
++
++static DEFINE_MUTEX(sev_cmd_mutex);
++static struct sev_misc_dev *misc_dev;
++static struct psp_device *psp_master;
++
+ static struct psp_device *psp_alloc_struct(struct sp_device *sp)
+ {
+ struct device *dev = sp->dev;
+@@ -45,9 +51,285 @@ static struct psp_device *psp_alloc_struct(struct sp_device *sp)
+
+ static irqreturn_t psp_irq_handler(int irq, void *data)
+ {
++ struct psp_device *psp = data;
++ unsigned int status;
++ int reg;
++
++ /* Read the interrupt status: */
++ status = ioread32(psp->io_regs + PSP_P2CMSG_INTSTS);
++
++ /* Check if it is command completion: */
++ if (!(status & BIT(PSP_CMD_COMPLETE_REG)))
++ goto done;
++
++ /* Check if it is SEV command completion: */
++ reg = ioread32(psp->io_regs + PSP_CMDRESP);
++ if (reg & PSP_CMDRESP_RESP) {
++ psp->sev_int_rcvd = 1;
++ wake_up(&psp->sev_int_queue);
++ }
++
++done:
++ /* Clear the interrupt status by writing the same value we read. */
++ iowrite32(status, psp->io_regs + PSP_P2CMSG_INTSTS);
++
+ return IRQ_HANDLED;
+ }
+
++static void sev_wait_cmd_ioc(struct psp_device *psp, unsigned int *reg)
++{
++ psp->sev_int_rcvd = 0;
++
++ wait_event(psp->sev_int_queue, psp->sev_int_rcvd);
++ *reg = ioread32(psp->io_regs + PSP_CMDRESP);
++}
++
++static int sev_cmd_buffer_len(int cmd)
++{
++ switch (cmd) {
++ case SEV_CMD_INIT: return sizeof(struct sev_data_init);
++ case SEV_CMD_PLATFORM_STATUS: return sizeof(struct sev_user_data_status);
++ case SEV_CMD_PEK_CSR: return sizeof(struct sev_data_pek_csr);
++ case SEV_CMD_PEK_CERT_IMPORT: return sizeof(struct sev_data_pek_cert_import);
++ case SEV_CMD_PDH_CERT_EXPORT: return sizeof(struct sev_data_pdh_cert_export);
++ case SEV_CMD_LAUNCH_START: return sizeof(struct sev_data_launch_start);
++ case SEV_CMD_LAUNCH_UPDATE_DATA: return sizeof(struct sev_data_launch_update_data);
++ case SEV_CMD_LAUNCH_UPDATE_VMSA: return sizeof(struct sev_data_launch_update_vmsa);
++ case SEV_CMD_LAUNCH_FINISH: return sizeof(struct sev_data_launch_finish);
++ case SEV_CMD_LAUNCH_MEASURE: return sizeof(struct sev_data_launch_measure);
++ case SEV_CMD_ACTIVATE: return sizeof(struct sev_data_activate);
++ case SEV_CMD_DEACTIVATE: return sizeof(struct sev_data_deactivate);
++ case SEV_CMD_DECOMMISSION: return sizeof(struct sev_data_decommission);
++ case SEV_CMD_GUEST_STATUS: return sizeof(struct sev_data_guest_status);
++ case SEV_CMD_DBG_DECRYPT: return sizeof(struct sev_data_dbg);
++ case SEV_CMD_DBG_ENCRYPT: return sizeof(struct sev_data_dbg);
++ case SEV_CMD_SEND_START: return sizeof(struct sev_data_send_start);
++ case SEV_CMD_SEND_UPDATE_DATA: return sizeof(struct sev_data_send_update_data);
++ case SEV_CMD_SEND_UPDATE_VMSA: return sizeof(struct sev_data_send_update_vmsa);
++ case SEV_CMD_SEND_FINISH: return sizeof(struct sev_data_send_finish);
++ case SEV_CMD_RECEIVE_START: return sizeof(struct sev_data_receive_start);
++ case SEV_CMD_RECEIVE_FINISH: return sizeof(struct sev_data_receive_finish);
++ case SEV_CMD_RECEIVE_UPDATE_DATA: return sizeof(struct sev_data_receive_update_data);
++ case SEV_CMD_RECEIVE_UPDATE_VMSA: return sizeof(struct sev_data_receive_update_vmsa);
++ case SEV_CMD_LAUNCH_UPDATE_SECRET: return sizeof(struct sev_data_launch_secret);
++ default: return 0;
++ }
++
++ return 0;
++}
++
++static int __sev_do_cmd_locked(int cmd, void *data, int *psp_ret)
++{
++ struct psp_device *psp = psp_master;
++ unsigned int phys_lsb, phys_msb;
++ unsigned int reg, ret = 0;
++
++ if (!psp)
++ return -ENODEV;
++
++ /* Get the physical address of the command buffer */
++ phys_lsb = data ? lower_32_bits(__psp_pa(data)) : 0;
++ phys_msb = data ? upper_32_bits(__psp_pa(data)) : 0;
++
++ dev_dbg(psp->dev, "sev command id %#x buffer 0x%08x%08x\n",
++ cmd, phys_msb, phys_lsb);
++
++ print_hex_dump_debug("(in): ", DUMP_PREFIX_OFFSET, 16, 2, data,
++ sev_cmd_buffer_len(cmd), false);
++
++ iowrite32(phys_lsb, psp->io_regs + PSP_CMDBUFF_ADDR_LO);
++ iowrite32(phys_msb, psp->io_regs + PSP_CMDBUFF_ADDR_HI);
++
++ reg = cmd;
++ reg <<= PSP_CMDRESP_CMD_SHIFT;
++ reg |= PSP_CMDRESP_IOC;
++ iowrite32(reg, psp->io_regs + PSP_CMDRESP);
++
++ /* wait for command completion */
++ sev_wait_cmd_ioc(psp, &reg);
++
++ if (psp_ret)
++ *psp_ret = reg & PSP_CMDRESP_ERR_MASK;
++
++ if (reg & PSP_CMDRESP_ERR_MASK) {
++ dev_dbg(psp->dev, "sev command %#x failed (%#010x)\n",
++ cmd, reg & PSP_CMDRESP_ERR_MASK);
++ ret = -EIO;
++ }
++
++ print_hex_dump_debug("(out): ", DUMP_PREFIX_OFFSET, 16, 2, data,
++ sev_cmd_buffer_len(cmd), false);
++
++ return ret;
++}
++
++static int sev_do_cmd(int cmd, void *data, int *psp_ret)
++{
++ int rc;
++
++ mutex_lock(&sev_cmd_mutex);
++ rc = __sev_do_cmd_locked(cmd, data, psp_ret);
++ mutex_unlock(&sev_cmd_mutex);
++
++ return rc;
++}
++
++static int __sev_platform_init_locked(int *error)
++{
++ struct psp_device *psp = psp_master;
++ int rc = 0;
++
++ if (!psp)
++ return -ENODEV;
++
++ if (psp->sev_state == SEV_STATE_INIT)
++ return 0;
++
++ rc = __sev_do_cmd_locked(SEV_CMD_INIT, &psp->init_cmd_buf, error);
++ if (rc)
++ return rc;
++
++ psp->sev_state = SEV_STATE_INIT;
++ dev_dbg(psp->dev, "SEV firmware initialized\n");
++
++ return rc;
++}
++
++int sev_platform_init(int *error)
++{
++ int rc;
++
++ mutex_lock(&sev_cmd_mutex);
++ rc = __sev_platform_init_locked(error);
++ mutex_unlock(&sev_cmd_mutex);
++
++ return rc;
++}
++EXPORT_SYMBOL_GPL(sev_platform_init);
++
++static int __sev_platform_shutdown_locked(int *error)
++{
++ int ret;
++
++ ret = __sev_do_cmd_locked(SEV_CMD_SHUTDOWN, 0, error);
++ if (ret)
++ return ret;
++
++ psp_master->sev_state = SEV_STATE_UNINIT;
++ dev_dbg(psp_master->dev, "SEV firmware shutdown\n");
++
++ return ret;
++}
++
++static int sev_platform_shutdown(int *error)
++{
++ int rc;
++
++ mutex_lock(&sev_cmd_mutex);
++ rc = __sev_platform_shutdown_locked(NULL);
++ mutex_unlock(&sev_cmd_mutex);
++
++ return rc;
++}
++
++static long sev_ioctl(struct file *file, unsigned int ioctl, unsigned long arg)
++{
++ return -ENOTTY;
++}
++
++static const struct file_operations sev_fops = {
++ .owner = THIS_MODULE,
++ .unlocked_ioctl = sev_ioctl,
++};
++
++int sev_platform_status(struct sev_user_data_status *data, int *error)
++{
++ return sev_do_cmd(SEV_CMD_PLATFORM_STATUS, data, error);
++}
++EXPORT_SYMBOL_GPL(sev_platform_status);
++
++int sev_guest_deactivate(struct sev_data_deactivate *data, int *error)
++{
++ return sev_do_cmd(SEV_CMD_DEACTIVATE, data, error);
++}
++EXPORT_SYMBOL_GPL(sev_guest_deactivate);
++
++int sev_guest_activate(struct sev_data_activate *data, int *error)
++{
++ return sev_do_cmd(SEV_CMD_ACTIVATE, data, error);
++}
++EXPORT_SYMBOL_GPL(sev_guest_activate);
++
++int sev_guest_decommission(struct sev_data_decommission *data, int *error)
++{
++ return sev_do_cmd(SEV_CMD_DECOMMISSION, data, error);
++}
++EXPORT_SYMBOL_GPL(sev_guest_decommission);
++
++int sev_guest_df_flush(int *error)
++{
++ return sev_do_cmd(SEV_CMD_DF_FLUSH, 0, error);
++}
++EXPORT_SYMBOL_GPL(sev_guest_df_flush);
++
++static void sev_exit(struct kref *ref)
++{
++ struct sev_misc_dev *misc_dev = container_of(ref, struct sev_misc_dev, refcount);
++
++ misc_deregister(&misc_dev->misc);
++}
++
++static int sev_misc_init(struct psp_device *psp)
++{
++ struct device *dev = psp->dev;
++ int ret;
++
++ /*
++ * SEV feature support can be detected on multiple devices but the SEV
++ * FW commands must be issued on the master. During probe, we do not
++ * know the master hence we create /dev/sev on the first device probe.
++ * sev_do_cmd() finds the right master device to which to issue the
++ * command to the firmware.
++ */
++ if (!misc_dev) {
++ struct miscdevice *misc;
++
++ misc_dev = devm_kzalloc(dev, sizeof(*misc_dev), GFP_KERNEL);
++ if (!misc_dev)
++ return -ENOMEM;
++
++ misc = &misc_dev->misc;
++ misc->minor = MISC_DYNAMIC_MINOR;
++ misc->name = DEVICE_NAME;
++ misc->fops = &sev_fops;
++
++ ret = misc_register(misc);
++ if (ret)
++ return ret;
++
++ kref_init(&misc_dev->refcount);
++ } else {
++ kref_get(&misc_dev->refcount);
++ }
++
++ init_waitqueue_head(&psp->sev_int_queue);
++ psp->sev_misc = misc_dev;
++ dev_dbg(dev, "registered SEV device\n");
++
++ return 0;
++}
++
++static int sev_init(struct psp_device *psp)
++{
++ /* Check if device supports SEV feature */
++ if (!(ioread32(psp->io_regs + PSP_FEATURE_REG) & 1)) {
++ dev_dbg(psp->dev, "device does not support SEV\n");
++ return 1;
++ }
++
++ return sev_misc_init(psp);
++}
++
+ int psp_dev_init(struct sp_device *sp)
+ {
+ struct device *dev = sp->dev;
+@@ -81,6 +363,10 @@ int psp_dev_init(struct sp_device *sp)
+ goto e_err;
+ }
+
++ ret = sev_init(psp);
++ if (ret)
++ goto e_irq;
++
+ if (sp->set_psp_master_device)
+ sp->set_psp_master_device(sp);
+
+@@ -89,6 +375,8 @@ int psp_dev_init(struct sp_device *sp)
+
+ return 0;
+
++e_irq:
++ sp_free_psp_irq(psp->sp, psp);
+ e_err:
+ sp->psp_data = NULL;
+
+@@ -101,5 +389,61 @@ void psp_dev_destroy(struct sp_device *sp)
+ {
+ struct psp_device *psp = sp->psp_data;
+
++ if (psp->sev_misc)
++ kref_put(&misc_dev->refcount, sev_exit);
++
+ sp_free_psp_irq(sp, psp);
+ }
++
++int sev_issue_cmd_external_user(struct file *filep, unsigned int cmd,
++ void *data, int *error)
++{
++ if (!filep || filep->f_op != &sev_fops)
++ return -EBADF;
++
++ return sev_do_cmd(cmd, data, error);
++}
++EXPORT_SYMBOL_GPL(sev_issue_cmd_external_user);
++
++void psp_pci_init(void)
++{
++ struct sev_user_data_status *status;
++ struct sp_device *sp;
++ int error, rc;
++
++ sp = sp_get_psp_master_device();
++ if (!sp)
++ return;
++
++ psp_master = sp->psp_data;
++
++ /* Initialize the platform */
++ rc = sev_platform_init(&error);
++ if (rc) {
++ dev_err(sp->dev, "SEV: failed to INIT error %#x\n", error);
++ goto err;
++ }
++
++ /* Display SEV firmware version */
++ status = &psp_master->status_cmd_buf;
++ rc = sev_platform_status(status, &error);
++ if (rc) {
++ dev_err(sp->dev, "SEV: failed to get status error %#x\n", error);
++ goto err;
++ }
++
++ dev_info(sp->dev, "SEV API:%d.%d build:%d\n", status->api_major,
++ status->api_minor, status->build);
++ return;
++
++err:
++ psp_master = NULL;
++}
++
++void psp_pci_exit(void)
++{
++ if (!psp_master)
++ return;
++
++ sev_platform_shutdown(NULL);
++}
+diff --git a/drivers/crypto/ccp/psp-dev.h b/drivers/crypto/ccp/psp-dev.h
+index 55b7808..c81f0b1 100644
+--- a/drivers/crypto/ccp/psp-dev.h
++++ b/drivers/crypto/ccp/psp-dev.h
+@@ -25,9 +25,21 @@
+ #include <linux/interrupt.h>
+ #include <linux/irqreturn.h>
+ #include <linux/dmaengine.h>
++#include <linux/psp-sev.h>
++#include <linux/miscdevice.h>
+
+ #include "sp-dev.h"
+
++#define PSP_C2PMSG(_num) ((_num) << 2)
++#define PSP_CMDRESP PSP_C2PMSG(32)
++#define PSP_CMDBUFF_ADDR_LO PSP_C2PMSG(56)
++#define PSP_CMDBUFF_ADDR_HI PSP_C2PMSG(57)
++#define PSP_FEATURE_REG PSP_C2PMSG(63)
++
++#define PSP_P2CMSG(_num) ((_num) << 2)
++#define PSP_CMD_COMPLETE_REG 1
++#define PSP_CMD_COMPLETE PSP_P2CMSG(PSP_CMD_COMPLETE_REG)
++
+ #define PSP_P2CMSG_INTEN 0x0110
+ #define PSP_P2CMSG_INTSTS 0x0114
+
+@@ -44,6 +56,11 @@
+
+ #define MAX_PSP_NAME_LEN 16
+
++struct sev_misc_dev {
++ struct kref refcount;
++ struct miscdevice misc;
++};
++
+ struct psp_device {
+ struct list_head entry;
+
+@@ -54,6 +71,13 @@ struct psp_device {
+ struct sp_device *sp;
+
+ void __iomem *io_regs;
++
++ int sev_state;
++ unsigned int sev_int_rcvd;
++ wait_queue_head_t sev_int_queue;
++ struct sev_misc_dev *sev_misc;
++ struct sev_user_data_status status_cmd_buf;
++ struct sev_data_init init_cmd_buf;
+ };
+
+ #endif /* __PSP_DEV_H */
+diff --git a/drivers/crypto/ccp/sp-dev.c b/drivers/crypto/ccp/sp-dev.c
+index cf101c0..eb0da65 100644
+--- a/drivers/crypto/ccp/sp-dev.c
++++ b/drivers/crypto/ccp/sp-dev.c
+@@ -272,6 +272,10 @@ static int __init sp_mod_init(void)
+ if (ret)
+ return ret;
+
++#ifdef CONFIG_CRYPTO_DEV_SP_PSP
++ psp_pci_init();
++#endif
++
+ return 0;
+ #endif
+
+@@ -291,6 +295,11 @@ static int __init sp_mod_init(void)
+ static void __exit sp_mod_exit(void)
+ {
+ #ifdef CONFIG_X86
++
++#ifdef CONFIG_CRYPTO_DEV_SP_PSP
++ psp_pci_exit();
++#endif
++
+ sp_pci_exit();
+ #endif
+
+diff --git a/drivers/crypto/ccp/sp-dev.h b/drivers/crypto/ccp/sp-dev.h
+index 909cf3e4..acb197b 100644
+--- a/drivers/crypto/ccp/sp-dev.h
++++ b/drivers/crypto/ccp/sp-dev.h
+@@ -143,12 +143,16 @@ static inline int ccp_dev_resume(struct sp_device *sp)
+ #ifdef CONFIG_CRYPTO_DEV_SP_PSP
+
+ int psp_dev_init(struct sp_device *sp);
++void psp_pci_init(void);
+ void psp_dev_destroy(struct sp_device *sp);
++void psp_pci_exit(void);
+
+ #else /* !CONFIG_CRYPTO_DEV_SP_PSP */
+
+ static inline int psp_dev_init(struct sp_device *sp) { return 0; }
++static inline void psp_pci_init(void) { }
+ static inline void psp_dev_destroy(struct sp_device *sp) { }
++static inline void psp_pci_exit(void) { }
+
+ #endif /* CONFIG_CRYPTO_DEV_SP_PSP */
+
+diff --git a/include/linux/psp-sev.h b/include/linux/psp-sev.h
+index 4a150d1..0b6dd30 100644
+--- a/include/linux/psp-sev.h
++++ b/include/linux/psp-sev.h
+@@ -462,4 +462,141 @@ struct sev_data_dbg {
+ u32 len; /* In */
+ } __packed;
+
++#ifdef CONFIG_CRYPTO_DEV_SP_PSP
++
++/**
++ * sev_platform_init - perform SEV INIT command
++ *
++ * @error: SEV command return code
++ *
++ * Returns:
++ * 0 if the SEV successfully processed the command
++ * -%ENODEV if the SEV device is not available
++ * -%ENOTSUPP if the SEV does not support SEV
++ * -%ETIMEDOUT if the SEV command timed out
++ * -%EIO if the SEV returned a non-zero return code
++ */
++int sev_platform_init(int *error);
++
++/**
++ * sev_platform_status - perform SEV PLATFORM_STATUS command
++ *
++ * @status: sev_user_data_status structure to be processed
++ * @error: SEV command return code
++ *
++ * Returns:
++ * 0 if the SEV successfully processed the command
++ * -%ENODEV if the SEV device is not available
++ * -%ENOTSUPP if the SEV does not support SEV
++ * -%ETIMEDOUT if the SEV command timed out
++ * -%EIO if the SEV returned a non-zero return code
++ */
++int sev_platform_status(struct sev_user_data_status *status, int *error);
++
++/**
++ * sev_issue_cmd_external_user - issue SEV command by other driver with a file
++ * handle.
++ *
++ * This function can be used by other drivers to issue a SEV command on
++ * behalf of userspace. The caller must pass a valid SEV file descriptor
++ * so that we know that it has access to SEV device.
++ *
++ * @filep - SEV device file pointer
++ * @cmd - command to issue
++ * @data - command buffer
++ * @error: SEV command return code
++ *
++ * Returns:
++ * 0 if the SEV successfully processed the command
++ * -%ENODEV if the SEV device is not available
++ * -%ENOTSUPP if the SEV does not support SEV
++ * -%ETIMEDOUT if the SEV command timed out
++ * -%EIO if the SEV returned a non-zero return code
++ * -%EINVAL if the SEV file descriptor is not valid
++ */
++int sev_issue_cmd_external_user(struct file *filep, unsigned int id,
++ void *data, int *error);
++
++/**
++ * sev_guest_deactivate - perform SEV DEACTIVATE command
++ *
++ * @deactivate: sev_data_deactivate structure to be processed
++ * @sev_ret: sev command return code
++ *
++ * Returns:
++ * 0 if the sev successfully processed the command
++ * -%ENODEV if the sev device is not available
++ * -%ENOTSUPP if the sev does not support SEV
++ * -%ETIMEDOUT if the sev command timed out
++ * -%EIO if the sev returned a non-zero return code
++ */
++int sev_guest_deactivate(struct sev_data_deactivate *data, int *error);
++
++/**
++ * sev_guest_activate - perform SEV ACTIVATE command
++ *
++ * @activate: sev_data_activate structure to be processed
++ * @sev_ret: sev command return code
++ *
++ * Returns:
++ * 0 if the sev successfully processed the command
++ * -%ENODEV if the sev device is not available
++ * -%ENOTSUPP if the sev does not support SEV
++ * -%ETIMEDOUT if the sev command timed out
++ * -%EIO if the sev returned a non-zero return code
++ */
++int sev_guest_activate(struct sev_data_activate *data, int *error);
++
++/**
++ * sev_guest_df_flush - perform SEV DF_FLUSH command
++ *
++ * @sev_ret: sev command return code
++ *
++ * Returns:
++ * 0 if the sev successfully processed the command
++ * -%ENODEV if the sev device is not available
++ * -%ENOTSUPP if the sev does not support SEV
++ * -%ETIMEDOUT if the sev command timed out
++ * -%EIO if the sev returned a non-zero return code
++ */
++int sev_guest_df_flush(int *error);
++
++/**
++ * sev_guest_decommission - perform SEV DECOMMISSION command
++ *
++ * @decommission: sev_data_decommission structure to be processed
++ * @sev_ret: sev command return code
++ *
++ * Returns:
++ * 0 if the sev successfully processed the command
++ * -%ENODEV if the sev device is not available
++ * -%ENOTSUPP if the sev does not support SEV
++ * -%ETIMEDOUT if the sev command timed out
++ * -%EIO if the sev returned a non-zero return code
++ */
++int sev_guest_decommission(struct sev_data_decommission *data, int *error);
++
++#else /* !CONFIG_CRYPTO_DEV_SP_PSP */
++
++static inline int
++sev_platform_status(struct sev_user_data_status *status, int *error) { return -ENODEV; }
++
++static inline int sev_platform_init(int *error) { return -ENODEV; }
++
++static inline int
++sev_guest_deactivate(struct sev_data_deactivate *data, int *error) { return -ENODEV; }
++
++static inline int
++sev_guest_decommission(struct sev_data_decommission *data, int *error) { return -ENODEV; }
++
++static inline int
++sev_guest_activate(struct sev_data_activate *data, int *error) { return -ENODEV; }
++
++static inline int sev_guest_df_flush(int *error) { return -ENODEV; }
++
++static inline int
++sev_issue_cmd_external_user(struct file *filep, unsigned int id, void *data, int *error) { return -ENODEV; }
++
++#endif /* CONFIG_CRYPTO_DEV_SP_PSP */
++
+ #endif /* __PSP_SEV_H__ */
+--
+2.7.4
+
generated by cgit 1.2.3-korg (git 2.39.0) at 2024-04-24 07:12:23 +0000