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