1 /* 2 * AMD Platform Security Processor (PSP) interface 3 * 4 * Copyright (C) 2016-2017 Advanced Micro Devices, Inc. 5 * 6 * Author: Brijesh Singh <brijesh.singh@amd.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/kernel.h> 15 #include <linux/kthread.h> 16 #include <linux/sched.h> 17 #include <linux/interrupt.h> 18 #include <linux/spinlock.h> 19 #include <linux/spinlock_types.h> 20 #include <linux/types.h> 21 #include <linux/mutex.h> 22 #include <linux/delay.h> 23 #include <linux/hw_random.h> 24 #include <linux/ccp.h> 25 26 #include "sp-dev.h" 27 #include "psp-dev.h" 28 29 #define DEVICE_NAME "sev" 30 31 static DEFINE_MUTEX(sev_cmd_mutex); 32 static struct sev_misc_dev *misc_dev; 33 static struct psp_device *psp_master; 34 35 static struct psp_device *psp_alloc_struct(struct sp_device *sp) 36 { 37 struct device *dev = sp->dev; 38 struct psp_device *psp; 39 40 psp = devm_kzalloc(dev, sizeof(*psp), GFP_KERNEL); 41 if (!psp) 42 return NULL; 43 44 psp->dev = dev; 45 psp->sp = sp; 46 47 snprintf(psp->name, sizeof(psp->name), "psp-%u", sp->ord); 48 49 return psp; 50 } 51 52 static irqreturn_t psp_irq_handler(int irq, void *data) 53 { 54 struct psp_device *psp = data; 55 unsigned int status; 56 int reg; 57 58 /* Read the interrupt status: */ 59 status = ioread32(psp->io_regs + PSP_P2CMSG_INTSTS); 60 61 /* Check if it is command completion: */ 62 if (!(status & BIT(PSP_CMD_COMPLETE_REG))) 63 goto done; 64 65 /* Check if it is SEV command completion: */ 66 reg = ioread32(psp->io_regs + PSP_CMDRESP); 67 if (reg & PSP_CMDRESP_RESP) { 68 psp->sev_int_rcvd = 1; 69 wake_up(&psp->sev_int_queue); 70 } 71 72 done: 73 /* Clear the interrupt status by writing the same value we read. */ 74 iowrite32(status, psp->io_regs + PSP_P2CMSG_INTSTS); 75 76 return IRQ_HANDLED; 77 } 78 79 static void sev_wait_cmd_ioc(struct psp_device *psp, unsigned int *reg) 80 { 81 psp->sev_int_rcvd = 0; 82 83 wait_event(psp->sev_int_queue, psp->sev_int_rcvd); 84 *reg = ioread32(psp->io_regs + PSP_CMDRESP); 85 } 86 87 static int sev_cmd_buffer_len(int cmd) 88 { 89 switch (cmd) { 90 case SEV_CMD_INIT: return sizeof(struct sev_data_init); 91 case SEV_CMD_PLATFORM_STATUS: return sizeof(struct sev_user_data_status); 92 case SEV_CMD_PEK_CSR: return sizeof(struct sev_data_pek_csr); 93 case SEV_CMD_PEK_CERT_IMPORT: return sizeof(struct sev_data_pek_cert_import); 94 case SEV_CMD_PDH_CERT_EXPORT: return sizeof(struct sev_data_pdh_cert_export); 95 case SEV_CMD_LAUNCH_START: return sizeof(struct sev_data_launch_start); 96 case SEV_CMD_LAUNCH_UPDATE_DATA: return sizeof(struct sev_data_launch_update_data); 97 case SEV_CMD_LAUNCH_UPDATE_VMSA: return sizeof(struct sev_data_launch_update_vmsa); 98 case SEV_CMD_LAUNCH_FINISH: return sizeof(struct sev_data_launch_finish); 99 case SEV_CMD_LAUNCH_MEASURE: return sizeof(struct sev_data_launch_measure); 100 case SEV_CMD_ACTIVATE: return sizeof(struct sev_data_activate); 101 case SEV_CMD_DEACTIVATE: return sizeof(struct sev_data_deactivate); 102 case SEV_CMD_DECOMMISSION: return sizeof(struct sev_data_decommission); 103 case SEV_CMD_GUEST_STATUS: return sizeof(struct sev_data_guest_status); 104 case SEV_CMD_DBG_DECRYPT: return sizeof(struct sev_data_dbg); 105 case SEV_CMD_DBG_ENCRYPT: return sizeof(struct sev_data_dbg); 106 case SEV_CMD_SEND_START: return sizeof(struct sev_data_send_start); 107 case SEV_CMD_SEND_UPDATE_DATA: return sizeof(struct sev_data_send_update_data); 108 case SEV_CMD_SEND_UPDATE_VMSA: return sizeof(struct sev_data_send_update_vmsa); 109 case SEV_CMD_SEND_FINISH: return sizeof(struct sev_data_send_finish); 110 case SEV_CMD_RECEIVE_START: return sizeof(struct sev_data_receive_start); 111 case SEV_CMD_RECEIVE_FINISH: return sizeof(struct sev_data_receive_finish); 112 case SEV_CMD_RECEIVE_UPDATE_DATA: return sizeof(struct sev_data_receive_update_data); 113 case SEV_CMD_RECEIVE_UPDATE_VMSA: return sizeof(struct sev_data_receive_update_vmsa); 114 case SEV_CMD_LAUNCH_UPDATE_SECRET: return sizeof(struct sev_data_launch_secret); 115 default: return 0; 116 } 117 118 return 0; 119 } 120 121 static int __sev_do_cmd_locked(int cmd, void *data, int *psp_ret) 122 { 123 struct psp_device *psp = psp_master; 124 unsigned int phys_lsb, phys_msb; 125 unsigned int reg, ret = 0; 126 127 if (!psp) 128 return -ENODEV; 129 130 /* Get the physical address of the command buffer */ 131 phys_lsb = data ? lower_32_bits(__psp_pa(data)) : 0; 132 phys_msb = data ? upper_32_bits(__psp_pa(data)) : 0; 133 134 dev_dbg(psp->dev, "sev command id %#x buffer 0x%08x%08x\n", 135 cmd, phys_msb, phys_lsb); 136 137 print_hex_dump_debug("(in): ", DUMP_PREFIX_OFFSET, 16, 2, data, 138 sev_cmd_buffer_len(cmd), false); 139 140 iowrite32(phys_lsb, psp->io_regs + PSP_CMDBUFF_ADDR_LO); 141 iowrite32(phys_msb, psp->io_regs + PSP_CMDBUFF_ADDR_HI); 142 143 reg = cmd; 144 reg <<= PSP_CMDRESP_CMD_SHIFT; 145 reg |= PSP_CMDRESP_IOC; 146 iowrite32(reg, psp->io_regs + PSP_CMDRESP); 147 148 /* wait for command completion */ 149 sev_wait_cmd_ioc(psp, ®); 150 151 if (psp_ret) 152 *psp_ret = reg & PSP_CMDRESP_ERR_MASK; 153 154 if (reg & PSP_CMDRESP_ERR_MASK) { 155 dev_dbg(psp->dev, "sev command %#x failed (%#010x)\n", 156 cmd, reg & PSP_CMDRESP_ERR_MASK); 157 ret = -EIO; 158 } 159 160 print_hex_dump_debug("(out): ", DUMP_PREFIX_OFFSET, 16, 2, data, 161 sev_cmd_buffer_len(cmd), false); 162 163 return ret; 164 } 165 166 static int sev_do_cmd(int cmd, void *data, int *psp_ret) 167 { 168 int rc; 169 170 mutex_lock(&sev_cmd_mutex); 171 rc = __sev_do_cmd_locked(cmd, data, psp_ret); 172 mutex_unlock(&sev_cmd_mutex); 173 174 return rc; 175 } 176 177 static int __sev_platform_init_locked(int *error) 178 { 179 struct psp_device *psp = psp_master; 180 int rc = 0; 181 182 if (!psp) 183 return -ENODEV; 184 185 if (psp->sev_state == SEV_STATE_INIT) 186 return 0; 187 188 rc = __sev_do_cmd_locked(SEV_CMD_INIT, &psp->init_cmd_buf, error); 189 if (rc) 190 return rc; 191 192 psp->sev_state = SEV_STATE_INIT; 193 dev_dbg(psp->dev, "SEV firmware initialized\n"); 194 195 return rc; 196 } 197 198 int sev_platform_init(int *error) 199 { 200 int rc; 201 202 mutex_lock(&sev_cmd_mutex); 203 rc = __sev_platform_init_locked(error); 204 mutex_unlock(&sev_cmd_mutex); 205 206 return rc; 207 } 208 EXPORT_SYMBOL_GPL(sev_platform_init); 209 210 static int __sev_platform_shutdown_locked(int *error) 211 { 212 int ret; 213 214 ret = __sev_do_cmd_locked(SEV_CMD_SHUTDOWN, 0, error); 215 if (ret) 216 return ret; 217 218 psp_master->sev_state = SEV_STATE_UNINIT; 219 dev_dbg(psp_master->dev, "SEV firmware shutdown\n"); 220 221 return ret; 222 } 223 224 static int sev_platform_shutdown(int *error) 225 { 226 int rc; 227 228 mutex_lock(&sev_cmd_mutex); 229 rc = __sev_platform_shutdown_locked(NULL); 230 mutex_unlock(&sev_cmd_mutex); 231 232 return rc; 233 } 234 235 static int sev_get_platform_state(int *state, int *error) 236 { 237 int rc; 238 239 rc = __sev_do_cmd_locked(SEV_CMD_PLATFORM_STATUS, 240 &psp_master->status_cmd_buf, error); 241 if (rc) 242 return rc; 243 244 *state = psp_master->status_cmd_buf.state; 245 return rc; 246 } 247 248 static int sev_ioctl_do_reset(struct sev_issue_cmd *argp) 249 { 250 int state, rc; 251 252 /* 253 * The SEV spec requires that FACTORY_RESET must be issued in 254 * UNINIT state. Before we go further lets check if any guest is 255 * active. 256 * 257 * If FW is in WORKING state then deny the request otherwise issue 258 * SHUTDOWN command do INIT -> UNINIT before issuing the FACTORY_RESET. 259 * 260 */ 261 rc = sev_get_platform_state(&state, &argp->error); 262 if (rc) 263 return rc; 264 265 if (state == SEV_STATE_WORKING) 266 return -EBUSY; 267 268 if (state == SEV_STATE_INIT) { 269 rc = __sev_platform_shutdown_locked(&argp->error); 270 if (rc) 271 return rc; 272 } 273 274 return __sev_do_cmd_locked(SEV_CMD_FACTORY_RESET, 0, &argp->error); 275 } 276 277 static int sev_ioctl_do_platform_status(struct sev_issue_cmd *argp) 278 { 279 struct sev_user_data_status *data = &psp_master->status_cmd_buf; 280 int ret; 281 282 ret = __sev_do_cmd_locked(SEV_CMD_PLATFORM_STATUS, data, &argp->error); 283 if (ret) 284 return ret; 285 286 if (copy_to_user((void __user *)argp->data, data, sizeof(*data))) 287 ret = -EFAULT; 288 289 return ret; 290 } 291 292 static int sev_ioctl_do_pek_pdh_gen(int cmd, struct sev_issue_cmd *argp) 293 { 294 int rc; 295 296 if (psp_master->sev_state == SEV_STATE_UNINIT) { 297 rc = __sev_platform_init_locked(&argp->error); 298 if (rc) 299 return rc; 300 } 301 302 return __sev_do_cmd_locked(cmd, 0, &argp->error); 303 } 304 305 static int sev_ioctl_do_pek_csr(struct sev_issue_cmd *argp) 306 { 307 struct sev_user_data_pek_csr input; 308 struct sev_data_pek_csr *data; 309 void *blob = NULL; 310 int ret; 311 312 if (copy_from_user(&input, (void __user *)argp->data, sizeof(input))) 313 return -EFAULT; 314 315 data = kzalloc(sizeof(*data), GFP_KERNEL); 316 if (!data) 317 return -ENOMEM; 318 319 /* userspace wants to query CSR length */ 320 if (!input.address || !input.length) 321 goto cmd; 322 323 /* allocate a physically contiguous buffer to store the CSR blob */ 324 if (!access_ok(VERIFY_WRITE, input.address, input.length) || 325 input.length > SEV_FW_BLOB_MAX_SIZE) { 326 ret = -EFAULT; 327 goto e_free; 328 } 329 330 blob = kmalloc(input.length, GFP_KERNEL); 331 if (!blob) { 332 ret = -ENOMEM; 333 goto e_free; 334 } 335 336 data->address = __psp_pa(blob); 337 data->len = input.length; 338 339 cmd: 340 if (psp_master->sev_state == SEV_STATE_UNINIT) { 341 ret = __sev_platform_init_locked(&argp->error); 342 if (ret) 343 goto e_free_blob; 344 } 345 346 ret = __sev_do_cmd_locked(SEV_CMD_PEK_CSR, data, &argp->error); 347 348 /* If we query the CSR length, FW responded with expected data. */ 349 input.length = data->len; 350 351 if (copy_to_user((void __user *)argp->data, &input, sizeof(input))) { 352 ret = -EFAULT; 353 goto e_free_blob; 354 } 355 356 if (blob) { 357 if (copy_to_user((void __user *)input.address, blob, input.length)) 358 ret = -EFAULT; 359 } 360 361 e_free_blob: 362 kfree(blob); 363 e_free: 364 kfree(data); 365 return ret; 366 } 367 368 void *psp_copy_user_blob(u64 __user uaddr, u32 len) 369 { 370 void *data; 371 372 if (!uaddr || !len) 373 return ERR_PTR(-EINVAL); 374 375 /* verify that blob length does not exceed our limit */ 376 if (len > SEV_FW_BLOB_MAX_SIZE) 377 return ERR_PTR(-EINVAL); 378 379 data = kmalloc(len, GFP_KERNEL); 380 if (!data) 381 return ERR_PTR(-ENOMEM); 382 383 if (copy_from_user(data, (void __user *)(uintptr_t)uaddr, len)) 384 goto e_free; 385 386 return data; 387 388 e_free: 389 kfree(data); 390 return ERR_PTR(-EFAULT); 391 } 392 EXPORT_SYMBOL_GPL(psp_copy_user_blob); 393 394 static int sev_ioctl_do_pek_import(struct sev_issue_cmd *argp) 395 { 396 struct sev_user_data_pek_cert_import input; 397 struct sev_data_pek_cert_import *data; 398 void *pek_blob, *oca_blob; 399 int ret; 400 401 if (copy_from_user(&input, (void __user *)argp->data, sizeof(input))) 402 return -EFAULT; 403 404 data = kzalloc(sizeof(*data), GFP_KERNEL); 405 if (!data) 406 return -ENOMEM; 407 408 /* copy PEK certificate blobs from userspace */ 409 pek_blob = psp_copy_user_blob(input.pek_cert_address, input.pek_cert_len); 410 if (IS_ERR(pek_blob)) { 411 ret = PTR_ERR(pek_blob); 412 goto e_free; 413 } 414 415 data->pek_cert_address = __psp_pa(pek_blob); 416 data->pek_cert_len = input.pek_cert_len; 417 418 /* copy PEK certificate blobs from userspace */ 419 oca_blob = psp_copy_user_blob(input.oca_cert_address, input.oca_cert_len); 420 if (IS_ERR(oca_blob)) { 421 ret = PTR_ERR(oca_blob); 422 goto e_free_pek; 423 } 424 425 data->oca_cert_address = __psp_pa(oca_blob); 426 data->oca_cert_len = input.oca_cert_len; 427 428 /* If platform is not in INIT state then transition it to INIT */ 429 if (psp_master->sev_state != SEV_STATE_INIT) { 430 ret = __sev_platform_init_locked(&argp->error); 431 if (ret) 432 goto e_free_oca; 433 } 434 435 ret = __sev_do_cmd_locked(SEV_CMD_PEK_CERT_IMPORT, data, &argp->error); 436 437 e_free_oca: 438 kfree(oca_blob); 439 e_free_pek: 440 kfree(pek_blob); 441 e_free: 442 kfree(data); 443 return ret; 444 } 445 446 static int sev_ioctl_do_pdh_export(struct sev_issue_cmd *argp) 447 { 448 struct sev_user_data_pdh_cert_export input; 449 void *pdh_blob = NULL, *cert_blob = NULL; 450 struct sev_data_pdh_cert_export *data; 451 int ret; 452 453 if (copy_from_user(&input, (void __user *)argp->data, sizeof(input))) 454 return -EFAULT; 455 456 data = kzalloc(sizeof(*data), GFP_KERNEL); 457 if (!data) 458 return -ENOMEM; 459 460 /* Userspace wants to query the certificate length. */ 461 if (!input.pdh_cert_address || 462 !input.pdh_cert_len || 463 !input.cert_chain_address) 464 goto cmd; 465 466 /* Allocate a physically contiguous buffer to store the PDH blob. */ 467 if ((input.pdh_cert_len > SEV_FW_BLOB_MAX_SIZE) || 468 !access_ok(VERIFY_WRITE, input.pdh_cert_address, input.pdh_cert_len)) { 469 ret = -EFAULT; 470 goto e_free; 471 } 472 473 /* Allocate a physically contiguous buffer to store the cert chain blob. */ 474 if ((input.cert_chain_len > SEV_FW_BLOB_MAX_SIZE) || 475 !access_ok(VERIFY_WRITE, input.cert_chain_address, input.cert_chain_len)) { 476 ret = -EFAULT; 477 goto e_free; 478 } 479 480 pdh_blob = kmalloc(input.pdh_cert_len, GFP_KERNEL); 481 if (!pdh_blob) { 482 ret = -ENOMEM; 483 goto e_free; 484 } 485 486 data->pdh_cert_address = __psp_pa(pdh_blob); 487 data->pdh_cert_len = input.pdh_cert_len; 488 489 cert_blob = kmalloc(input.cert_chain_len, GFP_KERNEL); 490 if (!cert_blob) { 491 ret = -ENOMEM; 492 goto e_free_pdh; 493 } 494 495 data->cert_chain_address = __psp_pa(cert_blob); 496 data->cert_chain_len = input.cert_chain_len; 497 498 cmd: 499 /* If platform is not in INIT state then transition it to INIT. */ 500 if (psp_master->sev_state != SEV_STATE_INIT) { 501 ret = __sev_platform_init_locked(&argp->error); 502 if (ret) 503 goto e_free_cert; 504 } 505 506 ret = __sev_do_cmd_locked(SEV_CMD_PDH_CERT_EXPORT, data, &argp->error); 507 508 /* If we query the length, FW responded with expected data. */ 509 input.cert_chain_len = data->cert_chain_len; 510 input.pdh_cert_len = data->pdh_cert_len; 511 512 if (copy_to_user((void __user *)argp->data, &input, sizeof(input))) { 513 ret = -EFAULT; 514 goto e_free_cert; 515 } 516 517 if (pdh_blob) { 518 if (copy_to_user((void __user *)input.pdh_cert_address, 519 pdh_blob, input.pdh_cert_len)) { 520 ret = -EFAULT; 521 goto e_free_cert; 522 } 523 } 524 525 if (cert_blob) { 526 if (copy_to_user((void __user *)input.cert_chain_address, 527 cert_blob, input.cert_chain_len)) 528 ret = -EFAULT; 529 } 530 531 e_free_cert: 532 kfree(cert_blob); 533 e_free_pdh: 534 kfree(pdh_blob); 535 e_free: 536 kfree(data); 537 return ret; 538 } 539 540 static long sev_ioctl(struct file *file, unsigned int ioctl, unsigned long arg) 541 { 542 void __user *argp = (void __user *)arg; 543 struct sev_issue_cmd input; 544 int ret = -EFAULT; 545 546 if (!psp_master) 547 return -ENODEV; 548 549 if (ioctl != SEV_ISSUE_CMD) 550 return -EINVAL; 551 552 if (copy_from_user(&input, argp, sizeof(struct sev_issue_cmd))) 553 return -EFAULT; 554 555 if (input.cmd > SEV_MAX) 556 return -EINVAL; 557 558 mutex_lock(&sev_cmd_mutex); 559 560 switch (input.cmd) { 561 562 case SEV_FACTORY_RESET: 563 ret = sev_ioctl_do_reset(&input); 564 break; 565 case SEV_PLATFORM_STATUS: 566 ret = sev_ioctl_do_platform_status(&input); 567 break; 568 case SEV_PEK_GEN: 569 ret = sev_ioctl_do_pek_pdh_gen(SEV_CMD_PEK_GEN, &input); 570 break; 571 case SEV_PDH_GEN: 572 ret = sev_ioctl_do_pek_pdh_gen(SEV_CMD_PDH_GEN, &input); 573 break; 574 case SEV_PEK_CSR: 575 ret = sev_ioctl_do_pek_csr(&input); 576 break; 577 case SEV_PEK_CERT_IMPORT: 578 ret = sev_ioctl_do_pek_import(&input); 579 break; 580 case SEV_PDH_CERT_EXPORT: 581 ret = sev_ioctl_do_pdh_export(&input); 582 break; 583 default: 584 ret = -EINVAL; 585 goto out; 586 } 587 588 if (copy_to_user(argp, &input, sizeof(struct sev_issue_cmd))) 589 ret = -EFAULT; 590 out: 591 mutex_unlock(&sev_cmd_mutex); 592 593 return ret; 594 } 595 596 static const struct file_operations sev_fops = { 597 .owner = THIS_MODULE, 598 .unlocked_ioctl = sev_ioctl, 599 }; 600 601 int sev_platform_status(struct sev_user_data_status *data, int *error) 602 { 603 return sev_do_cmd(SEV_CMD_PLATFORM_STATUS, data, error); 604 } 605 EXPORT_SYMBOL_GPL(sev_platform_status); 606 607 int sev_guest_deactivate(struct sev_data_deactivate *data, int *error) 608 { 609 return sev_do_cmd(SEV_CMD_DEACTIVATE, data, error); 610 } 611 EXPORT_SYMBOL_GPL(sev_guest_deactivate); 612 613 int sev_guest_activate(struct sev_data_activate *data, int *error) 614 { 615 return sev_do_cmd(SEV_CMD_ACTIVATE, data, error); 616 } 617 EXPORT_SYMBOL_GPL(sev_guest_activate); 618 619 int sev_guest_decommission(struct sev_data_decommission *data, int *error) 620 { 621 return sev_do_cmd(SEV_CMD_DECOMMISSION, data, error); 622 } 623 EXPORT_SYMBOL_GPL(sev_guest_decommission); 624 625 int sev_guest_df_flush(int *error) 626 { 627 return sev_do_cmd(SEV_CMD_DF_FLUSH, 0, error); 628 } 629 EXPORT_SYMBOL_GPL(sev_guest_df_flush); 630 631 static void sev_exit(struct kref *ref) 632 { 633 struct sev_misc_dev *misc_dev = container_of(ref, struct sev_misc_dev, refcount); 634 635 misc_deregister(&misc_dev->misc); 636 } 637 638 static int sev_misc_init(struct psp_device *psp) 639 { 640 struct device *dev = psp->dev; 641 int ret; 642 643 /* 644 * SEV feature support can be detected on multiple devices but the SEV 645 * FW commands must be issued on the master. During probe, we do not 646 * know the master hence we create /dev/sev on the first device probe. 647 * sev_do_cmd() finds the right master device to which to issue the 648 * command to the firmware. 649 */ 650 if (!misc_dev) { 651 struct miscdevice *misc; 652 653 misc_dev = devm_kzalloc(dev, sizeof(*misc_dev), GFP_KERNEL); 654 if (!misc_dev) 655 return -ENOMEM; 656 657 misc = &misc_dev->misc; 658 misc->minor = MISC_DYNAMIC_MINOR; 659 misc->name = DEVICE_NAME; 660 misc->fops = &sev_fops; 661 662 ret = misc_register(misc); 663 if (ret) 664 return ret; 665 666 kref_init(&misc_dev->refcount); 667 } else { 668 kref_get(&misc_dev->refcount); 669 } 670 671 init_waitqueue_head(&psp->sev_int_queue); 672 psp->sev_misc = misc_dev; 673 dev_dbg(dev, "registered SEV device\n"); 674 675 return 0; 676 } 677 678 static int sev_init(struct psp_device *psp) 679 { 680 /* Check if device supports SEV feature */ 681 if (!(ioread32(psp->io_regs + PSP_FEATURE_REG) & 1)) { 682 dev_dbg(psp->dev, "device does not support SEV\n"); 683 return 1; 684 } 685 686 return sev_misc_init(psp); 687 } 688 689 int psp_dev_init(struct sp_device *sp) 690 { 691 struct device *dev = sp->dev; 692 struct psp_device *psp; 693 int ret; 694 695 ret = -ENOMEM; 696 psp = psp_alloc_struct(sp); 697 if (!psp) 698 goto e_err; 699 700 sp->psp_data = psp; 701 702 psp->vdata = (struct psp_vdata *)sp->dev_vdata->psp_vdata; 703 if (!psp->vdata) { 704 ret = -ENODEV; 705 dev_err(dev, "missing driver data\n"); 706 goto e_err; 707 } 708 709 psp->io_regs = sp->io_map + psp->vdata->offset; 710 711 /* Disable and clear interrupts until ready */ 712 iowrite32(0, psp->io_regs + PSP_P2CMSG_INTEN); 713 iowrite32(-1, psp->io_regs + PSP_P2CMSG_INTSTS); 714 715 /* Request an irq */ 716 ret = sp_request_psp_irq(psp->sp, psp_irq_handler, psp->name, psp); 717 if (ret) { 718 dev_err(dev, "psp: unable to allocate an IRQ\n"); 719 goto e_err; 720 } 721 722 ret = sev_init(psp); 723 if (ret) 724 goto e_irq; 725 726 if (sp->set_psp_master_device) 727 sp->set_psp_master_device(sp); 728 729 /* Enable interrupt */ 730 iowrite32(-1, psp->io_regs + PSP_P2CMSG_INTEN); 731 732 return 0; 733 734 e_irq: 735 sp_free_psp_irq(psp->sp, psp); 736 e_err: 737 sp->psp_data = NULL; 738 739 dev_notice(dev, "psp initialization failed\n"); 740 741 return ret; 742 } 743 744 void psp_dev_destroy(struct sp_device *sp) 745 { 746 struct psp_device *psp = sp->psp_data; 747 748 if (psp->sev_misc) 749 kref_put(&misc_dev->refcount, sev_exit); 750 751 sp_free_psp_irq(sp, psp); 752 } 753 754 int sev_issue_cmd_external_user(struct file *filep, unsigned int cmd, 755 void *data, int *error) 756 { 757 if (!filep || filep->f_op != &sev_fops) 758 return -EBADF; 759 760 return sev_do_cmd(cmd, data, error); 761 } 762 EXPORT_SYMBOL_GPL(sev_issue_cmd_external_user); 763 764 void psp_pci_init(void) 765 { 766 struct sev_user_data_status *status; 767 struct sp_device *sp; 768 int error, rc; 769 770 sp = sp_get_psp_master_device(); 771 if (!sp) 772 return; 773 774 psp_master = sp->psp_data; 775 776 /* Initialize the platform */ 777 rc = sev_platform_init(&error); 778 if (rc) { 779 dev_err(sp->dev, "SEV: failed to INIT error %#x\n", error); 780 goto err; 781 } 782 783 /* Display SEV firmware version */ 784 status = &psp_master->status_cmd_buf; 785 rc = sev_platform_status(status, &error); 786 if (rc) { 787 dev_err(sp->dev, "SEV: failed to get status error %#x\n", error); 788 goto err; 789 } 790 791 dev_info(sp->dev, "SEV API:%d.%d build:%d\n", status->api_major, 792 status->api_minor, status->build); 793 return; 794 795 err: 796 psp_master = NULL; 797 } 798 799 void psp_pci_exit(void) 800 { 801 if (!psp_master) 802 return; 803 804 sev_platform_shutdown(NULL); 805 } 806