?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / crypto / ccp / psp-dev.c
blobb3afb6cc9d72278b35eadb239e280b5aa311c3f9
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, &reg);
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, NULL, 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, NULL, &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, NULL, &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, NULL, 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 }
CRIS linux kernel tree