drivers/crypto/ccp/sev-dev.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * AMD Secure Encrypted Virtualization (SEV) interface
   4  *
   5  * Copyright (C) 2016,2019 Advanced Micro Devices, Inc.
   6  *
   7  * Author: Brijesh Singh <brijesh.singh@amd.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/kthread.h>
  13 #include <linux/sched.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/spinlock_types.h>
  17 #include <linux/types.h>
  18 #include <linux/mutex.h>
  19 #include <linux/delay.h>
  20 #include <linux/hw_random.h>
  21 #include <linux/ccp.h>
  22 #include <linux/firmware.h>
  23 #include <linux/gfp.h>
  24 #include <linux/cpufeature.h>
  25 #include <linux/fs.h>
  26 #include <linux/fs_struct.h>
  27
  28 #include <asm/smp.h>
  29
  30 #include "psp-dev.h"
  31 #include "sev-dev.h"
  32
  33 #define DEVICE_NAME             "sev"
  34 #define SEV_FW_FILE             "amd/sev.fw"
  35 #define SEV_FW_NAME_SIZE        64
  36
  37 static DEFINE_MUTEX(sev_cmd_mutex);
  38 static struct sev_misc_dev *misc_dev;
  39
  40 static int psp_cmd_timeout = 100;
  41 module_param(psp_cmd_timeout, int, 0644);
  42 MODULE_PARM_DESC(psp_cmd_timeout, " default timeout value, in seconds, for PSP commands");
  43
  44 static int psp_probe_timeout = 5;
  45 module_param(psp_probe_timeout, int, 0644);
  46 MODULE_PARM_DESC(psp_probe_timeout, " default timeout value, in seconds, during PSP device probe");
  47
  48 static char *init_ex_path;
  49 module_param(init_ex_path, charp, 0444);
  50 MODULE_PARM_DESC(init_ex_path, " Path for INIT_EX data; if set try INIT_EX");
  51
  52 static bool psp_init_on_probe = true;
  53 module_param(psp_init_on_probe, bool, 0444);
  54 MODULE_PARM_DESC(psp_init_on_probe, "  if true, the PSP will be initialized on module init. Else the PSP will be initialized on the first command requiring it");
  55
  56 MODULE_FIRMWARE("amd/amd_sev_fam17h_model0xh.sbin"); /* 1st gen EPYC */
  57 MODULE_FIRMWARE("amd/amd_sev_fam17h_model3xh.sbin"); /* 2nd gen EPYC */
  58 MODULE_FIRMWARE("amd/amd_sev_fam19h_model0xh.sbin"); /* 3rd gen EPYC */
  59
  60 static bool psp_dead;
  61 static int psp_timeout;
  62
  63 /* Trusted Memory Region (TMR):
  64  *   The TMR is a 1MB area that must be 1MB aligned.  Use the page allocator
  65  *   to allocate the memory, which will return aligned memory for the specified
  66  *   allocation order.
  67  */
  68 #define SEV_ES_TMR_SIZE         (1024 * 1024)
  69 static void *sev_es_tmr;
  70
  71 /* INIT_EX NV Storage:
  72  *   The NV Storage is a 32Kb area and must be 4Kb page aligned.  Use the page
  73  *   allocator to allocate the memory, which will return aligned memory for the
  74  *   specified allocation order.
  75  */
  76 #define NV_LENGTH (32 * 1024)
  77 static void *sev_init_ex_buffer;
  78
  79 static inline bool sev_version_greater_or_equal(u8 maj, u8 min)
  80 {
  81         struct sev_device *sev = psp_master->sev_data;
  82
  83         if (sev->api_major > maj)
  84                 return true;
  85
  86         if (sev->api_major == maj && sev->api_minor >= min)
  87                 return true;
  88
  89         return false;
  90 }
  91
  92 static void sev_irq_handler(int irq, void *data, unsigned int status)
  93 {
  94         struct sev_device *sev = data;
  95         int reg;
  96
  97         /* Check if it is command completion: */
  98         if (!(status & SEV_CMD_COMPLETE))
  99                 return;
 100
 101         /* Check if it is SEV command completion: */
 102         reg = ioread32(sev->io_regs + sev->vdata->cmdresp_reg);
 103         if (reg & PSP_CMDRESP_RESP) {
 104                 sev->int_rcvd = 1;
 105                 wake_up(&sev->int_queue);
 106         }
 107 }
 108
 109 static int sev_wait_cmd_ioc(struct sev_device *sev,
 110                             unsigned int *reg, unsigned int timeout)
 111 {
 112         int ret;
 113
 114         ret = wait_event_timeout(sev->int_queue,
 115                         sev->int_rcvd, timeout * HZ);
 116         if (!ret)
 117                 return -ETIMEDOUT;
 118
 119         *reg = ioread32(sev->io_regs + sev->vdata->cmdresp_reg);
 120
 121         return 0;
 122 }
 123
 124 static int sev_cmd_buffer_len(int cmd)
 125 {
 126         switch (cmd) {
 127         case SEV_CMD_INIT:                      return sizeof(struct sev_data_init);
 128         case SEV_CMD_INIT_EX:                   return sizeof(struct sev_data_init_ex);
 129         case SEV_CMD_PLATFORM_STATUS:           return sizeof(struct sev_user_data_status);
 130         case SEV_CMD_PEK_CSR:                   return sizeof(struct sev_data_pek_csr);
 131         case SEV_CMD_PEK_CERT_IMPORT:           return sizeof(struct sev_data_pek_cert_import);
 132         case SEV_CMD_PDH_CERT_EXPORT:           return sizeof(struct sev_data_pdh_cert_export);
 133         case SEV_CMD_LAUNCH_START:              return sizeof(struct sev_data_launch_start);
 134         case SEV_CMD_LAUNCH_UPDATE_DATA:        return sizeof(struct sev_data_launch_update_data);
 135         case SEV_CMD_LAUNCH_UPDATE_VMSA:        return sizeof(struct sev_data_launch_update_vmsa);
 136         case SEV_CMD_LAUNCH_FINISH:             return sizeof(struct sev_data_launch_finish);
 137         case SEV_CMD_LAUNCH_MEASURE:            return sizeof(struct sev_data_launch_measure);
 138         case SEV_CMD_ACTIVATE:                  return sizeof(struct sev_data_activate);
 139         case SEV_CMD_DEACTIVATE:                return sizeof(struct sev_data_deactivate);
 140         case SEV_CMD_DECOMMISSION:              return sizeof(struct sev_data_decommission);
 141         case SEV_CMD_GUEST_STATUS:              return sizeof(struct sev_data_guest_status);
 142         case SEV_CMD_DBG_DECRYPT:               return sizeof(struct sev_data_dbg);
 143         case SEV_CMD_DBG_ENCRYPT:               return sizeof(struct sev_data_dbg);
 144         case SEV_CMD_SEND_START:                return sizeof(struct sev_data_send_start);
 145         case SEV_CMD_SEND_UPDATE_DATA:          return sizeof(struct sev_data_send_update_data);
 146         case SEV_CMD_SEND_UPDATE_VMSA:          return sizeof(struct sev_data_send_update_vmsa);
 147         case SEV_CMD_SEND_FINISH:               return sizeof(struct sev_data_send_finish);
 148         case SEV_CMD_RECEIVE_START:             return sizeof(struct sev_data_receive_start);
 149         case SEV_CMD_RECEIVE_FINISH:            return sizeof(struct sev_data_receive_finish);
 150         case SEV_CMD_RECEIVE_UPDATE_DATA:       return sizeof(struct sev_data_receive_update_data);
 151         case SEV_CMD_RECEIVE_UPDATE_VMSA:       return sizeof(struct sev_data_receive_update_vmsa);
 152         case SEV_CMD_LAUNCH_UPDATE_SECRET:      return sizeof(struct sev_data_launch_secret);
 153         case SEV_CMD_DOWNLOAD_FIRMWARE:         return sizeof(struct sev_data_download_firmware);
 154         case SEV_CMD_GET_ID:                    return sizeof(struct sev_data_get_id);
 155         case SEV_CMD_ATTESTATION_REPORT:        return sizeof(struct sev_data_attestation_report);
 156         case SEV_CMD_SEND_CANCEL:               return sizeof(struct sev_data_send_cancel);
 157         default:                                return 0;
 158         }
 159
 160         return 0;
 161 }
 162
 163 static void *sev_fw_alloc(unsigned long len)
 164 {
 165         struct page *page;
 166
 167         page = alloc_pages(GFP_KERNEL, get_order(len));
 168         if (!page)
 169                 return NULL;
 170
 171         return page_address(page);
 172 }
 173
 174 static struct file *open_file_as_root(const char *filename, int flags, umode_t mode)
 175 {
 176         struct file *fp;
 177         struct path root;
 178         struct cred *cred;
 179         const struct cred *old_cred;
 180
 181         task_lock(&init_task);
 182         get_fs_root(init_task.fs, &root);
 183         task_unlock(&init_task);
 184
 185         cred = prepare_creds();
 186         if (!cred)
 187                 return ERR_PTR(-ENOMEM);
 188         cred->fsuid = GLOBAL_ROOT_UID;
 189         old_cred = override_creds(cred);
 190
 191         fp = file_open_root(&root, filename, flags, mode);
 192         path_put(&root);
 193
 194         revert_creds(old_cred);
 195
 196         return fp;
 197 }
 198
 199 static int sev_read_init_ex_file(void)
 200 {
 201         struct sev_device *sev = psp_master->sev_data;
 202         struct file *fp;
 203         ssize_t nread;
 204
 205         lockdep_assert_held(&sev_cmd_mutex);
 206
 207         if (!sev_init_ex_buffer)
 208                 return -EOPNOTSUPP;
 209
 210         fp = open_file_as_root(init_ex_path, O_RDONLY, 0);
 211         if (IS_ERR(fp)) {
 212                 int ret = PTR_ERR(fp);
 213
 214                 dev_err(sev->dev,
 215                         "SEV: could not open %s for read, error %d\n",
 216                         init_ex_path, ret);
 217                 return ret;
 218         }
 219
 220         nread = kernel_read(fp, sev_init_ex_buffer, NV_LENGTH, NULL);
 221         if (nread != NV_LENGTH) {
 222                 dev_err(sev->dev,
 223                         "SEV: failed to read %u bytes to non volatile memory area, ret %ld\n",
 224                         NV_LENGTH, nread);
 225                 return -EIO;
 226         }
 227
 228         dev_dbg(sev->dev, "SEV: read %ld bytes from NV file\n", nread);
 229         filp_close(fp, NULL);
 230
 231         return 0;
 232 }
 233
 234 static void sev_write_init_ex_file(void)
 235 {
 236         struct sev_device *sev = psp_master->sev_data;
 237         struct file *fp;
 238         loff_t offset = 0;
 239         ssize_t nwrite;
 240
 241         lockdep_assert_held(&sev_cmd_mutex);
 242
 243         if (!sev_init_ex_buffer)
 244                 return;
 245
 246         fp = open_file_as_root(init_ex_path, O_CREAT | O_WRONLY, 0600);
 247         if (IS_ERR(fp)) {
 248                 dev_err(sev->dev,
 249                         "SEV: could not open file for write, error %ld\n",
 250                         PTR_ERR(fp));
 251                 return;
 252         }
 253
 254         nwrite = kernel_write(fp, sev_init_ex_buffer, NV_LENGTH, &offset);
 255         vfs_fsync(fp, 0);
 256         filp_close(fp, NULL);
 257
 258         if (nwrite != NV_LENGTH) {
 259                 dev_err(sev->dev,
 260                         "SEV: failed to write %u bytes to non volatile memory area, ret %ld\n",
 261                         NV_LENGTH, nwrite);
 262                 return;
 263         }
 264
 265         dev_dbg(sev->dev, "SEV: write successful to NV file\n");
 266 }
 267
 268 static void sev_write_init_ex_file_if_required(int cmd_id)
 269 {
 270         lockdep_assert_held(&sev_cmd_mutex);
 271
 272         if (!sev_init_ex_buffer)
 273                 return;
 274
 275         /*
 276          * Only a few platform commands modify the SPI/NV area, but none of the
 277          * non-platform commands do. Only INIT(_EX), PLATFORM_RESET, PEK_GEN,
 278          * PEK_CERT_IMPORT, and PDH_GEN do.
 279          */
 280         switch (cmd_id) {
 281         case SEV_CMD_FACTORY_RESET:
 282         case SEV_CMD_INIT_EX:
 283         case SEV_CMD_PDH_GEN:
 284         case SEV_CMD_PEK_CERT_IMPORT:
 285         case SEV_CMD_PEK_GEN:
 286                 break;
 287         default:
 288                 return;
 289         }
 290
 291         sev_write_init_ex_file();
 292 }
 293
 294 static int __sev_do_cmd_locked(int cmd, void *data, int *psp_ret)
 295 {
 296         struct psp_device *psp = psp_master;
 297         struct sev_device *sev;
 298         unsigned int phys_lsb, phys_msb;
 299         unsigned int reg, ret = 0;
 300         int buf_len;
 301
 302         if (!psp || !psp->sev_data)
 303                 return -ENODEV;
 304
 305         if (psp_dead)
 306                 return -EBUSY;
 307
 308         sev = psp->sev_data;
 309
 310         buf_len = sev_cmd_buffer_len(cmd);
 311         if (WARN_ON_ONCE(!data != !buf_len))
 312                 return -EINVAL;
 313
 314         /*
 315          * Copy the incoming data to driver's scratch buffer as __pa() will not
 316          * work for some memory, e.g. vmalloc'd addresses, and @data may not be
 317          * physically contiguous.
 318          */
 319         if (data)
 320                 memcpy(sev->cmd_buf, data, buf_len);
 321
 322         /* Get the physical address of the command buffer */
 323         phys_lsb = data ? lower_32_bits(__psp_pa(sev->cmd_buf)) : 0;
 324         phys_msb = data ? upper_32_bits(__psp_pa(sev->cmd_buf)) : 0;
 325
 326         dev_dbg(sev->dev, "sev command id %#x buffer 0x%08x%08x timeout %us\n",
 327                 cmd, phys_msb, phys_lsb, psp_timeout);
 328
 329         print_hex_dump_debug("(in):  ", DUMP_PREFIX_OFFSET, 16, 2, data,
 330                              buf_len, false);
 331
 332         iowrite32(phys_lsb, sev->io_regs + sev->vdata->cmdbuff_addr_lo_reg);
 333         iowrite32(phys_msb, sev->io_regs + sev->vdata->cmdbuff_addr_hi_reg);
 334
 335         sev->int_rcvd = 0;
 336
 337         reg = cmd;
 338         reg <<= SEV_CMDRESP_CMD_SHIFT;
 339         reg |= SEV_CMDRESP_IOC;
 340         iowrite32(reg, sev->io_regs + sev->vdata->cmdresp_reg);
 341
 342         /* wait for command completion */
 343         ret = sev_wait_cmd_ioc(sev, &reg, psp_timeout);
 344         if (ret) {
 345                 if (psp_ret)
 346                         *psp_ret = 0;
 347
 348                 dev_err(sev->dev, "sev command %#x timed out, disabling PSP\n", cmd);
 349                 psp_dead = true;
 350
 351                 return ret;
 352         }
 353
 354         psp_timeout = psp_cmd_timeout;
 355
 356         if (psp_ret)
 357                 *psp_ret = reg & PSP_CMDRESP_ERR_MASK;
 358
 359         if (reg & PSP_CMDRESP_ERR_MASK) {
 360                 dev_dbg(sev->dev, "sev command %#x failed (%#010x)\n",
 361                         cmd, reg & PSP_CMDRESP_ERR_MASK);
 362                 ret = -EIO;
 363         } else {
 364                 sev_write_init_ex_file_if_required(cmd);
 365         }
 366
 367         print_hex_dump_debug("(out): ", DUMP_PREFIX_OFFSET, 16, 2, data,
 368                              buf_len, false);
 369
 370         /*
 371          * Copy potential output from the PSP back to data.  Do this even on
 372          * failure in case the caller wants to glean something from the error.
 373          */
 374         if (data)
 375                 memcpy(data, sev->cmd_buf, buf_len);
 376
 377         return ret;
 378 }
 379
 380 static int sev_do_cmd(int cmd, void *data, int *psp_ret)
 381 {
 382         int rc;
 383
 384         mutex_lock(&sev_cmd_mutex);
 385         rc = __sev_do_cmd_locked(cmd, data, psp_ret);
 386         mutex_unlock(&sev_cmd_mutex);
 387
 388         return rc;
 389 }
 390
 391 static int __sev_init_locked(int *error)
 392 {
 393         struct sev_data_init data;
 394
 395         memset(&data, 0, sizeof(data));
 396         if (sev_es_tmr) {
 397                 /*
 398                  * Do not include the encryption mask on the physical
 399                  * address of the TMR (firmware should clear it anyway).
 400                  */
 401                 data.tmr_address = __pa(sev_es_tmr);
 402
 403                 data.flags |= SEV_INIT_FLAGS_SEV_ES;
 404                 data.tmr_len = SEV_ES_TMR_SIZE;
 405         }
 406
 407         return __sev_do_cmd_locked(SEV_CMD_INIT, &data, error);
 408 }
 409
 410 static int __sev_init_ex_locked(int *error)
 411 {
 412         struct sev_data_init_ex data;
 413         int ret;
 414
 415         memset(&data, 0, sizeof(data));
 416         data.length = sizeof(data);
 417         data.nv_address = __psp_pa(sev_init_ex_buffer);
 418         data.nv_len = NV_LENGTH;
 419
 420         ret = sev_read_init_ex_file();
 421         if (ret)
 422                 return ret;
 423
 424         if (sev_es_tmr) {
 425                 /*
 426                  * Do not include the encryption mask on the physical
 427                  * address of the TMR (firmware should clear it anyway).
 428                  */
 429                 data.tmr_address = __pa(sev_es_tmr);
 430
 431                 data.flags |= SEV_INIT_FLAGS_SEV_ES;
 432                 data.tmr_len = SEV_ES_TMR_SIZE;
 433         }
 434
 435         return __sev_do_cmd_locked(SEV_CMD_INIT_EX, &data, error);
 436 }
 437
 438 static int __sev_platform_init_locked(int *error)
 439 {
 440         struct psp_device *psp = psp_master;
 441         struct sev_device *sev;
 442         int rc, psp_ret = -1;
 443         int (*init_function)(int *error);
 444
 445         if (!psp || !psp->sev_data)
 446                 return -ENODEV;
 447
 448         sev = psp->sev_data;
 449
 450         if (sev->state == SEV_STATE_INIT)
 451                 return 0;
 452
 453         init_function = sev_init_ex_buffer ? __sev_init_ex_locked :
 454                         __sev_init_locked;
 455         rc = init_function(&psp_ret);
 456         if (rc && psp_ret == SEV_RET_SECURE_DATA_INVALID) {
 457                 /*
 458                  * Initialization command returned an integrity check failure
 459                  * status code, meaning that firmware load and validation of SEV
 460                  * related persistent data has failed. Retrying the
 461                  * initialization function should succeed by replacing the state
 462                  * with a reset state.
 463                  */
 464                 dev_err(sev->dev, "SEV: retrying INIT command because of SECURE_DATA_INVALID error. Retrying once to reset PSP SEV state.");
 465                 rc = init_function(&psp_ret);
 466         }
 467         if (error)
 468                 *error = psp_ret;
 469
 470         if (rc)
 471                 return rc;
 472
 473         sev->state = SEV_STATE_INIT;
 474
 475         /* Prepare for first SEV guest launch after INIT */
 476         wbinvd_on_all_cpus();
 477         rc = __sev_do_cmd_locked(SEV_CMD_DF_FLUSH, NULL, error);
 478         if (rc)
 479                 return rc;
 480
 481         dev_dbg(sev->dev, "SEV firmware initialized\n");
 482
 483         dev_info(sev->dev, "SEV API:%d.%d build:%d\n", sev->api_major,
 484                  sev->api_minor, sev->build);
 485
 486         return 0;
 487 }
 488
 489 int sev_platform_init(int *error)
 490 {
 491         int rc;
 492
 493         mutex_lock(&sev_cmd_mutex);
 494         rc = __sev_platform_init_locked(error);
 495         mutex_unlock(&sev_cmd_mutex);
 496
 497         return rc;
 498 }
 499 EXPORT_SYMBOL_GPL(sev_platform_init);
 500
 501 static int __sev_platform_shutdown_locked(int *error)
 502 {
 503         struct sev_device *sev = psp_master->sev_data;
 504         int ret;
 505
 506         if (sev->state == SEV_STATE_UNINIT)
 507                 return 0;
 508
 509         ret = __sev_do_cmd_locked(SEV_CMD_SHUTDOWN, NULL, error);
 510         if (ret)
 511                 return ret;
 512
 513         sev->state = SEV_STATE_UNINIT;
 514         dev_dbg(sev->dev, "SEV firmware shutdown\n");
 515
 516         return ret;
 517 }
 518
 519 static int sev_platform_shutdown(int *error)
 520 {
 521         int rc;
 522
 523         mutex_lock(&sev_cmd_mutex);
 524         rc = __sev_platform_shutdown_locked(NULL);
 525         mutex_unlock(&sev_cmd_mutex);
 526
 527         return rc;
 528 }
 529
 530 static int sev_get_platform_state(int *state, int *error)
 531 {
 532         struct sev_user_data_status data;
 533         int rc;
 534
 535         rc = __sev_do_cmd_locked(SEV_CMD_PLATFORM_STATUS, &data, error);
 536         if (rc)
 537                 return rc;
 538
 539         *state = data.state;
 540         return rc;
 541 }
 542
 543 static int sev_ioctl_do_reset(struct sev_issue_cmd *argp, bool writable)
 544 {
 545         int state, rc;
 546
 547         if (!writable)
 548                 return -EPERM;
 549
 550         /*
 551          * The SEV spec requires that FACTORY_RESET must be issued in
 552          * UNINIT state. Before we go further lets check if any guest is
 553          * active.
 554          *
 555          * If FW is in WORKING state then deny the request otherwise issue
 556          * SHUTDOWN command do INIT -> UNINIT before issuing the FACTORY_RESET.
 557          *
 558          */
 559         rc = sev_get_platform_state(&state, &argp->error);
 560         if (rc)
 561                 return rc;
 562
 563         if (state == SEV_STATE_WORKING)
 564                 return -EBUSY;
 565
 566         if (state == SEV_STATE_INIT) {
 567                 rc = __sev_platform_shutdown_locked(&argp->error);
 568                 if (rc)
 569                         return rc;
 570         }
 571
 572         return __sev_do_cmd_locked(SEV_CMD_FACTORY_RESET, NULL, &argp->error);
 573 }
 574
 575 static int sev_ioctl_do_platform_status(struct sev_issue_cmd *argp)
 576 {
 577         struct sev_user_data_status data;
 578         int ret;
 579
 580         ret = __sev_do_cmd_locked(SEV_CMD_PLATFORM_STATUS, &data, &argp->error);
 581         if (ret)
 582                 return ret;
 583
 584         if (copy_to_user((void __user *)argp->data, &data, sizeof(data)))
 585                 ret = -EFAULT;
 586
 587         return ret;
 588 }
 589
 590 static int sev_ioctl_do_pek_pdh_gen(int cmd, struct sev_issue_cmd *argp, bool writable)
 591 {
 592         struct sev_device *sev = psp_master->sev_data;
 593         int rc;
 594
 595         if (!writable)
 596                 return -EPERM;
 597
 598         if (sev->state == SEV_STATE_UNINIT) {
 599                 rc = __sev_platform_init_locked(&argp->error);
 600                 if (rc)
 601                         return rc;
 602         }
 603
 604         return __sev_do_cmd_locked(cmd, NULL, &argp->error);
 605 }
 606
 607 static int sev_ioctl_do_pek_csr(struct sev_issue_cmd *argp, bool writable)
 608 {
 609         struct sev_device *sev = psp_master->sev_data;
 610         struct sev_user_data_pek_csr input;
 611         struct sev_data_pek_csr data;
 612         void __user *input_address;
 613         void *blob = NULL;
 614         int ret;
 615
 616         if (!writable)
 617                 return -EPERM;
 618
 619         if (copy_from_user(&input, (void __user *)argp->data, sizeof(input)))
 620                 return -EFAULT;
 621
 622         memset(&data, 0, sizeof(data));
 623
 624         /* userspace wants to query CSR length */
 625         if (!input.address || !input.length)
 626                 goto cmd;
 627
 628         /* allocate a physically contiguous buffer to store the CSR blob */
 629         input_address = (void __user *)input.address;
 630         if (input.length > SEV_FW_BLOB_MAX_SIZE)
 631                 return -EFAULT;
 632
 633         blob = kmalloc(input.length, GFP_KERNEL);
 634         if (!blob)
 635                 return -ENOMEM;
 636
 637         data.address = __psp_pa(blob);
 638         data.len = input.length;
 639
 640 cmd:
 641         if (sev->state == SEV_STATE_UNINIT) {
 642                 ret = __sev_platform_init_locked(&argp->error);
 643                 if (ret)
 644                         goto e_free_blob;
 645         }
 646
 647         ret = __sev_do_cmd_locked(SEV_CMD_PEK_CSR, &data, &argp->error);
 648
 649          /* If we query the CSR length, FW responded with expected data. */
 650         input.length = data.len;
 651
 652         if (copy_to_user((void __user *)argp->data, &input, sizeof(input))) {
 653                 ret = -EFAULT;
 654                 goto e_free_blob;
 655         }
 656
 657         if (blob) {
 658                 if (copy_to_user(input_address, blob, input.length))
 659                         ret = -EFAULT;
 660         }
 661
 662 e_free_blob:
 663         kfree(blob);
 664         return ret;
 665 }
 666
 667 void *psp_copy_user_blob(u64 uaddr, u32 len)
 668 {
 669         if (!uaddr || !len)
 670                 return ERR_PTR(-EINVAL);
 671
 672         /* verify that blob length does not exceed our limit */
 673         if (len > SEV_FW_BLOB_MAX_SIZE)
 674                 return ERR_PTR(-EINVAL);
 675
 676         return memdup_user((void __user *)uaddr, len);
 677 }
 678 EXPORT_SYMBOL_GPL(psp_copy_user_blob);
 679
 680 static int sev_get_api_version(void)
 681 {
 682         struct sev_device *sev = psp_master->sev_data;
 683         struct sev_user_data_status status;
 684         int error = 0, ret;
 685
 686         ret = sev_platform_status(&status, &error);
 687         if (ret) {
 688                 dev_err(sev->dev,
 689                         "SEV: failed to get status. Error: %#x\n", error);
 690                 return 1;
 691         }
 692
 693         sev->api_major = status.api_major;
 694         sev->api_minor = status.api_minor;
 695         sev->build = status.build;
 696         sev->state = status.state;
 697
 698         return 0;
 699 }
 700
 701 static int sev_get_firmware(struct device *dev,
 702                             const struct firmware **firmware)
 703 {
 704         char fw_name_specific[SEV_FW_NAME_SIZE];
 705         char fw_name_subset[SEV_FW_NAME_SIZE];
 706
 707         snprintf(fw_name_specific, sizeof(fw_name_specific),
 708                  "amd/amd_sev_fam%.2xh_model%.2xh.sbin",
 709                  boot_cpu_data.x86, boot_cpu_data.x86_model);
 710
 711         snprintf(fw_name_subset, sizeof(fw_name_subset),
 712                  "amd/amd_sev_fam%.2xh_model%.1xxh.sbin",
 713                  boot_cpu_data.x86, (boot_cpu_data.x86_model & 0xf0) >> 4);
 714
 715         /* Check for SEV FW for a particular model.
 716          * Ex. amd_sev_fam17h_model00h.sbin for Family 17h Model 00h
 717          *
 718          * or
 719          *
 720          * Check for SEV FW common to a subset of models.
 721          * Ex. amd_sev_fam17h_model0xh.sbin for
 722          *     Family 17h Model 00h -- Family 17h Model 0Fh
 723          *
 724          * or
 725          *
 726          * Fall-back to using generic name: sev.fw
 727          */
 728         if ((firmware_request_nowarn(firmware, fw_name_specific, dev) >= 0) ||
 729             (firmware_request_nowarn(firmware, fw_name_subset, dev) >= 0) ||
 730             (firmware_request_nowarn(firmware, SEV_FW_FILE, dev) >= 0))
 731                 return 0;
 732
 733         return -ENOENT;
 734 }
 735
 736 /* Don't fail if SEV FW couldn't be updated. Continue with existing SEV FW */
 737 static int sev_update_firmware(struct device *dev)
 738 {
 739         struct sev_data_download_firmware *data;
 740         const struct firmware *firmware;
 741         int ret, error, order;
 742         struct page *p;
 743         u64 data_size;
 744
 745         if (sev_get_firmware(dev, &firmware) == -ENOENT) {
 746                 dev_dbg(dev, "No SEV firmware file present\n");
 747                 return -1;
 748         }
 749
 750         /*
 751          * SEV FW expects the physical address given to it to be 32
 752          * byte aligned. Memory allocated has structure placed at the
 753          * beginning followed by the firmware being passed to the SEV
 754          * FW. Allocate enough memory for data structure + alignment
 755          * padding + SEV FW.
 756          */
 757         data_size = ALIGN(sizeof(struct sev_data_download_firmware), 32);
 758
 759         order = get_order(firmware->size + data_size);
 760         p = alloc_pages(GFP_KERNEL, order);
 761         if (!p) {
 762                 ret = -1;
 763                 goto fw_err;
 764         }
 765
 766         /*
 767          * Copy firmware data to a kernel allocated contiguous
 768          * memory region.
 769          */
 770         data = page_address(p);
 771         memcpy(page_address(p) + data_size, firmware->data, firmware->size);
 772
 773         data->address = __psp_pa(page_address(p) + data_size);
 774         data->len = firmware->size;
 775
 776         ret = sev_do_cmd(SEV_CMD_DOWNLOAD_FIRMWARE, data, &error);
 777         if (ret)
 778                 dev_dbg(dev, "Failed to update SEV firmware: %#x\n", error);
 779         else
 780                 dev_info(dev, "SEV firmware update successful\n");
 781
 782         __free_pages(p, order);
 783
 784 fw_err:
 785         release_firmware(firmware);
 786
 787         return ret;
 788 }
 789
 790 static int sev_ioctl_do_pek_import(struct sev_issue_cmd *argp, bool writable)
 791 {
 792         struct sev_device *sev = psp_master->sev_data;
 793         struct sev_user_data_pek_cert_import input;
 794         struct sev_data_pek_cert_import data;
 795         void *pek_blob, *oca_blob;
 796         int ret;
 797
 798         if (!writable)
 799                 return -EPERM;
 800
 801         if (copy_from_user(&input, (void __user *)argp->data, sizeof(input)))
 802                 return -EFAULT;
 803
 804         /* copy PEK certificate blobs from userspace */
 805         pek_blob = psp_copy_user_blob(input.pek_cert_address, input.pek_cert_len);
 806         if (IS_ERR(pek_blob))
 807                 return PTR_ERR(pek_blob);
 808
 809         data.reserved = 0;
 810         data.pek_cert_address = __psp_pa(pek_blob);
 811         data.pek_cert_len = input.pek_cert_len;
 812
 813         /* copy PEK certificate blobs from userspace */
 814         oca_blob = psp_copy_user_blob(input.oca_cert_address, input.oca_cert_len);
 815         if (IS_ERR(oca_blob)) {
 816                 ret = PTR_ERR(oca_blob);
 817                 goto e_free_pek;
 818         }
 819
 820         data.oca_cert_address = __psp_pa(oca_blob);
 821         data.oca_cert_len = input.oca_cert_len;
 822
 823         /* If platform is not in INIT state then transition it to INIT */
 824         if (sev->state != SEV_STATE_INIT) {
 825                 ret = __sev_platform_init_locked(&argp->error);
 826                 if (ret)
 827                         goto e_free_oca;
 828         }
 829
 830         ret = __sev_do_cmd_locked(SEV_CMD_PEK_CERT_IMPORT, &data, &argp->error);
 831
 832 e_free_oca:
 833         kfree(oca_blob);
 834 e_free_pek:
 835         kfree(pek_blob);
 836         return ret;
 837 }
 838
 839 static int sev_ioctl_do_get_id2(struct sev_issue_cmd *argp)
 840 {
 841         struct sev_user_data_get_id2 input;
 842         struct sev_data_get_id data;
 843         void __user *input_address;
 844         void *id_blob = NULL;
 845         int ret;
 846
 847         /* SEV GET_ID is available from SEV API v0.16 and up */
 848         if (!sev_version_greater_or_equal(0, 16))
 849                 return -ENOTSUPP;
 850
 851         if (copy_from_user(&input, (void __user *)argp->data, sizeof(input)))
 852                 return -EFAULT;
 853
 854         input_address = (void __user *)input.address;
 855
 856         if (input.address && input.length) {
 857                 id_blob = kmalloc(input.length, GFP_KERNEL);
 858                 if (!id_blob)
 859                         return -ENOMEM;
 860
 861                 data.address = __psp_pa(id_blob);
 862                 data.len = input.length;
 863         } else {
 864                 data.address = 0;
 865                 data.len = 0;
 866         }
 867
 868         ret = __sev_do_cmd_locked(SEV_CMD_GET_ID, &data, &argp->error);
 869
 870         /*
 871          * Firmware will return the length of the ID value (either the minimum
 872          * required length or the actual length written), return it to the user.
 873          */
 874         input.length = data.len;
 875
 876         if (copy_to_user((void __user *)argp->data, &input, sizeof(input))) {
 877                 ret = -EFAULT;
 878                 goto e_free;
 879         }
 880
 881         if (id_blob) {
 882                 if (copy_to_user(input_address, id_blob, data.len)) {
 883                         ret = -EFAULT;
 884                         goto e_free;
 885                 }
 886         }
 887
 888 e_free:
 889         kfree(id_blob);
 890
 891         return ret;
 892 }
 893
 894 static int sev_ioctl_do_get_id(struct sev_issue_cmd *argp)
 895 {
 896         struct sev_data_get_id *data;
 897         u64 data_size, user_size;
 898         void *id_blob, *mem;
 899         int ret;
 900
 901         /* SEV GET_ID available from SEV API v0.16 and up */
 902         if (!sev_version_greater_or_equal(0, 16))
 903                 return -ENOTSUPP;
 904
 905         /* SEV FW expects the buffer it fills with the ID to be
 906          * 8-byte aligned. Memory allocated should be enough to
 907          * hold data structure + alignment padding + memory
 908          * where SEV FW writes the ID.
 909          */
 910         data_size = ALIGN(sizeof(struct sev_data_get_id), 8);
 911         user_size = sizeof(struct sev_user_data_get_id);
 912
 913         mem = kzalloc(data_size + user_size, GFP_KERNEL);
 914         if (!mem)
 915                 return -ENOMEM;
 916
 917         data = mem;
 918         id_blob = mem + data_size;
 919
 920         data->address = __psp_pa(id_blob);
 921         data->len = user_size;
 922
 923         ret = __sev_do_cmd_locked(SEV_CMD_GET_ID, data, &argp->error);
 924         if (!ret) {
 925                 if (copy_to_user((void __user *)argp->data, id_blob, data->len))
 926                         ret = -EFAULT;
 927         }
 928
 929         kfree(mem);
 930
 931         return ret;
 932 }
 933
 934 static int sev_ioctl_do_pdh_export(struct sev_issue_cmd *argp, bool writable)
 935 {
 936         struct sev_device *sev = psp_master->sev_data;
 937         struct sev_user_data_pdh_cert_export input;
 938         void *pdh_blob = NULL, *cert_blob = NULL;
 939         struct sev_data_pdh_cert_export data;
 940         void __user *input_cert_chain_address;
 941         void __user *input_pdh_cert_address;
 942         int ret;
 943
 944         /* If platform is not in INIT state then transition it to INIT. */
 945         if (sev->state != SEV_STATE_INIT) {
 946                 if (!writable)
 947                         return -EPERM;
 948
 949                 ret = __sev_platform_init_locked(&argp->error);
 950                 if (ret)
 951                         return ret;
 952         }
 953
 954         if (copy_from_user(&input, (void __user *)argp->data, sizeof(input)))
 955                 return -EFAULT;
 956
 957         memset(&data, 0, sizeof(data));
 958
 959         /* Userspace wants to query the certificate length. */
 960         if (!input.pdh_cert_address ||
 961             !input.pdh_cert_len ||
 962             !input.cert_chain_address)
 963                 goto cmd;
 964
 965         input_pdh_cert_address = (void __user *)input.pdh_cert_address;
 966         input_cert_chain_address = (void __user *)input.cert_chain_address;
 967
 968         /* Allocate a physically contiguous buffer to store the PDH blob. */
 969         if (input.pdh_cert_len > SEV_FW_BLOB_MAX_SIZE)
 970                 return -EFAULT;
 971
 972         /* Allocate a physically contiguous buffer to store the cert chain blob. */
 973         if (input.cert_chain_len > SEV_FW_BLOB_MAX_SIZE)
 974                 return -EFAULT;
 975
 976         pdh_blob = kmalloc(input.pdh_cert_len, GFP_KERNEL);
 977         if (!pdh_blob)
 978                 return -ENOMEM;
 979
 980         data.pdh_cert_address = __psp_pa(pdh_blob);
 981         data.pdh_cert_len = input.pdh_cert_len;
 982
 983         cert_blob = kmalloc(input.cert_chain_len, GFP_KERNEL);
 984         if (!cert_blob) {
 985                 ret = -ENOMEM;
 986                 goto e_free_pdh;
 987         }
 988
 989         data.cert_chain_address = __psp_pa(cert_blob);
 990         data.cert_chain_len = input.cert_chain_len;
 991
 992 cmd:
 993         ret = __sev_do_cmd_locked(SEV_CMD_PDH_CERT_EXPORT, &data, &argp->error);
 994
 995         /* If we query the length, FW responded with expected data. */
 996         input.cert_chain_len = data.cert_chain_len;
 997         input.pdh_cert_len = data.pdh_cert_len;
 998
 999         if (copy_to_user((void __user *)argp->data, &input, sizeof(input))) {
1000                 ret = -EFAULT;
1001                 goto e_free_cert;
1002         }
1003
1004         if (pdh_blob) {
1005                 if (copy_to_user(input_pdh_cert_address,
1006                                  pdh_blob, input.pdh_cert_len)) {
1007                         ret = -EFAULT;
1008                         goto e_free_cert;
1009                 }
1010         }
1011
1012         if (cert_blob) {
1013                 if (copy_to_user(input_cert_chain_address,
1014                                  cert_blob, input.cert_chain_len))
1015                         ret = -EFAULT;
1016         }
1017
1018 e_free_cert:
1019         kfree(cert_blob);
1020 e_free_pdh:
1021         kfree(pdh_blob);
1022         return ret;
1023 }
1024
1025 static long sev_ioctl(struct file *file, unsigned int ioctl, unsigned long arg)
1026 {
1027         void __user *argp = (void __user *)arg;
1028         struct sev_issue_cmd input;
1029         int ret = -EFAULT;
1030         bool writable = file->f_mode & FMODE_WRITE;
1031
1032         if (!psp_master || !psp_master->sev_data)
1033                 return -ENODEV;
1034
1035         if (ioctl != SEV_ISSUE_CMD)
1036                 return -EINVAL;
1037
1038         if (copy_from_user(&input, argp, sizeof(struct sev_issue_cmd)))
1039                 return -EFAULT;
1040
1041         if (input.cmd > SEV_MAX)
1042                 return -EINVAL;
1043
1044         mutex_lock(&sev_cmd_mutex);
1045
1046         switch (input.cmd) {
1047
1048         case SEV_FACTORY_RESET:
1049                 ret = sev_ioctl_do_reset(&input, writable);
1050                 break;
1051         case SEV_PLATFORM_STATUS:
1052                 ret = sev_ioctl_do_platform_status(&input);
1053                 break;
1054         case SEV_PEK_GEN:
1055                 ret = sev_ioctl_do_pek_pdh_gen(SEV_CMD_PEK_GEN, &input, writable);
1056                 break;
1057         case SEV_PDH_GEN:
1058                 ret = sev_ioctl_do_pek_pdh_gen(SEV_CMD_PDH_GEN, &input, writable);
1059                 break;
1060         case SEV_PEK_CSR:
1061                 ret = sev_ioctl_do_pek_csr(&input, writable);
1062                 break;
1063         case SEV_PEK_CERT_IMPORT:
1064                 ret = sev_ioctl_do_pek_import(&input, writable);
1065                 break;
1066         case SEV_PDH_CERT_EXPORT:
1067                 ret = sev_ioctl_do_pdh_export(&input, writable);
1068                 break;
1069         case SEV_GET_ID:
1070                 pr_warn_once("SEV_GET_ID command is deprecated, use SEV_GET_ID2\n");
1071                 ret = sev_ioctl_do_get_id(&input);
1072                 break;
1073         case SEV_GET_ID2:
1074                 ret = sev_ioctl_do_get_id2(&input);
1075                 break;
1076         default:
1077                 ret = -EINVAL;
1078                 goto out;
1079         }
1080
1081         if (copy_to_user(argp, &input, sizeof(struct sev_issue_cmd)))
1082                 ret = -EFAULT;
1083 out:
1084         mutex_unlock(&sev_cmd_mutex);
1085
1086         return ret;
1087 }
1088
1089 static const struct file_operations sev_fops = {
1090         .owner  = THIS_MODULE,
1091         .unlocked_ioctl = sev_ioctl,
1092 };
1093
1094 int sev_platform_status(struct sev_user_data_status *data, int *error)
1095 {
1096         return sev_do_cmd(SEV_CMD_PLATFORM_STATUS, data, error);
1097 }
1098 EXPORT_SYMBOL_GPL(sev_platform_status);
1099
1100 int sev_guest_deactivate(struct sev_data_deactivate *data, int *error)
1101 {
1102         return sev_do_cmd(SEV_CMD_DEACTIVATE, data, error);
1103 }
1104 EXPORT_SYMBOL_GPL(sev_guest_deactivate);
1105
1106 int sev_guest_activate(struct sev_data_activate *data, int *error)
1107 {
1108         return sev_do_cmd(SEV_CMD_ACTIVATE, data, error);
1109 }
1110 EXPORT_SYMBOL_GPL(sev_guest_activate);
1111
1112 int sev_guest_decommission(struct sev_data_decommission *data, int *error)
1113 {
1114         return sev_do_cmd(SEV_CMD_DECOMMISSION, data, error);
1115 }
1116 EXPORT_SYMBOL_GPL(sev_guest_decommission);
1117
1118 int sev_guest_df_flush(int *error)
1119 {
1120         return sev_do_cmd(SEV_CMD_DF_FLUSH, NULL, error);
1121 }
1122 EXPORT_SYMBOL_GPL(sev_guest_df_flush);
1123
1124 static void sev_exit(struct kref *ref)
1125 {
1126         misc_deregister(&misc_dev->misc);
1127         kfree(misc_dev);
1128         misc_dev = NULL;
1129 }
1130
1131 static int sev_misc_init(struct sev_device *sev)
1132 {
1133         struct device *dev = sev->dev;
1134         int ret;
1135
1136         /*
1137          * SEV feature support can be detected on multiple devices but the SEV
1138          * FW commands must be issued on the master. During probe, we do not
1139          * know the master hence we create /dev/sev on the first device probe.
1140          * sev_do_cmd() finds the right master device to which to issue the
1141          * command to the firmware.
1142          */
1143         if (!misc_dev) {
1144                 struct miscdevice *misc;
1145
1146                 misc_dev = kzalloc(sizeof(*misc_dev), GFP_KERNEL);
1147                 if (!misc_dev)
1148                         return -ENOMEM;
1149
1150                 misc = &misc_dev->misc;
1151                 misc->minor = MISC_DYNAMIC_MINOR;
1152                 misc->name = DEVICE_NAME;
1153                 misc->fops = &sev_fops;
1154
1155                 ret = misc_register(misc);
1156                 if (ret)
1157                         return ret;
1158
1159                 kref_init(&misc_dev->refcount);
1160         } else {
1161                 kref_get(&misc_dev->refcount);
1162         }
1163
1164         init_waitqueue_head(&sev->int_queue);
1165         sev->misc = misc_dev;
1166         dev_dbg(dev, "registered SEV device\n");
1167
1168         return 0;
1169 }
1170
1171 int sev_dev_init(struct psp_device *psp)
1172 {
1173         struct device *dev = psp->dev;
1174         struct sev_device *sev;
1175         int ret = -ENOMEM;
1176
1177         if (!boot_cpu_has(X86_FEATURE_SEV)) {
1178                 dev_info_once(dev, "SEV: memory encryption not enabled by BIOS\n");
1179                 return 0;
1180         }
1181
1182         sev = devm_kzalloc(dev, sizeof(*sev), GFP_KERNEL);
1183         if (!sev)
1184                 goto e_err;
1185
1186         sev->cmd_buf = (void *)devm_get_free_pages(dev, GFP_KERNEL, 0);
1187         if (!sev->cmd_buf)
1188                 goto e_sev;
1189
1190         psp->sev_data = sev;
1191
1192         sev->dev = dev;
1193         sev->psp = psp;
1194
1195         sev->io_regs = psp->io_regs;
1196
1197         sev->vdata = (struct sev_vdata *)psp->vdata->sev;
1198         if (!sev->vdata) {
1199                 ret = -ENODEV;
1200                 dev_err(dev, "sev: missing driver data\n");
1201                 goto e_buf;
1202         }
1203
1204         psp_set_sev_irq_handler(psp, sev_irq_handler, sev);
1205
1206         ret = sev_misc_init(sev);
1207         if (ret)
1208                 goto e_irq;
1209
1210         dev_notice(dev, "sev enabled\n");
1211
1212         return 0;
1213
1214 e_irq:
1215         psp_clear_sev_irq_handler(psp);
1216 e_buf:
1217         devm_free_pages(dev, (unsigned long)sev->cmd_buf);
1218 e_sev:
1219         devm_kfree(dev, sev);
1220 e_err:
1221         psp->sev_data = NULL;
1222
1223         dev_notice(dev, "sev initialization failed\n");
1224
1225         return ret;
1226 }
1227
1228 static void sev_firmware_shutdown(struct sev_device *sev)
1229 {
1230         sev_platform_shutdown(NULL);
1231
1232         if (sev_es_tmr) {
1233                 /* The TMR area was encrypted, flush it from the cache */
1234                 wbinvd_on_all_cpus();
1235
1236                 free_pages((unsigned long)sev_es_tmr,
1237                            get_order(SEV_ES_TMR_SIZE));
1238                 sev_es_tmr = NULL;
1239         }
1240
1241         if (sev_init_ex_buffer) {
1242                 free_pages((unsigned long)sev_init_ex_buffer,
1243                            get_order(NV_LENGTH));
1244                 sev_init_ex_buffer = NULL;
1245         }
1246 }
1247
1248 void sev_dev_destroy(struct psp_device *psp)
1249 {
1250         struct sev_device *sev = psp->sev_data;
1251
1252         if (!sev)
1253                 return;
1254
1255         sev_firmware_shutdown(sev);
1256
1257         if (sev->misc)
1258                 kref_put(&misc_dev->refcount, sev_exit);
1259
1260         psp_clear_sev_irq_handler(psp);
1261 }
1262
1263 int sev_issue_cmd_external_user(struct file *filep, unsigned int cmd,
1264                                 void *data, int *error)
1265 {
1266         if (!filep || filep->f_op != &sev_fops)
1267                 return -EBADF;
1268
1269         return sev_do_cmd(cmd, data, error);
1270 }
1271 EXPORT_SYMBOL_GPL(sev_issue_cmd_external_user);
1272
1273 void sev_pci_init(void)
1274 {
1275         struct sev_device *sev = psp_master->sev_data;
1276         int error, rc;
1277
1278         if (!sev)
1279                 return;
1280
1281         psp_timeout = psp_probe_timeout;
1282
1283         if (sev_get_api_version())
1284                 goto err;
1285
1286         if (sev_version_greater_or_equal(0, 15) &&
1287             sev_update_firmware(sev->dev) == 0)
1288                 sev_get_api_version();
1289
1290         /* If an init_ex_path is provided rely on INIT_EX for PSP initialization
1291          * instead of INIT.
1292          */
1293         if (init_ex_path) {
1294                 sev_init_ex_buffer = sev_fw_alloc(NV_LENGTH);
1295                 if (!sev_init_ex_buffer) {
1296                         dev_err(sev->dev,
1297                                 "SEV: INIT_EX NV memory allocation failed\n");
1298                         goto err;
1299                 }
1300         }
1301
1302         /* Obtain the TMR memory area for SEV-ES use */
1303         sev_es_tmr = sev_fw_alloc(SEV_ES_TMR_SIZE);
1304         if (!sev_es_tmr)
1305                 dev_warn(sev->dev,
1306                          "SEV: TMR allocation failed, SEV-ES support unavailable\n");
1307
1308         if (!psp_init_on_probe)
1309                 return;
1310
1311         /* Initialize the platform */
1312         rc = sev_platform_init(&error);
1313         if (rc)
1314                 dev_err(sev->dev, "SEV: failed to INIT error %#x, rc %d\n",
1315                         error, rc);
1316
1317         return;
1318
1319 err:
1320         psp_master->sev_data = NULL;
1321 }
1322
1323 void sev_pci_exit(void)
1324 {
1325         struct sev_device *sev = psp_master->sev_data;
1326
1327         if (!sev)
1328                 return;
1329
1330         sev_firmware_shutdown(sev);
1331 }