drivers/crypto/ccp/psp-dev.c

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