1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * AMD Platform Security Processor (PSP) 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/kernel.h>
11 #include <linux/irqreturn.h>
12
13 #include "sp-dev.h"
14 #include "psp-dev.h"
15 #include "sev-dev.h"
16 #include "tee-dev.h"
17
18 struct psp_device *psp_master;
19
psp_alloc_struct(struct sp_device * sp)20 static struct psp_device *psp_alloc_struct(struct sp_device *sp)
21 {
22 struct device *dev = sp->dev;
23 struct psp_device *psp;
24
25 psp = devm_kzalloc(dev, sizeof(*psp), GFP_KERNEL);
26 if (!psp)
27 return NULL;
28
29 psp->dev = dev;
30 psp->sp = sp;
31
32 snprintf(psp->name, sizeof(psp->name), "psp-%u", sp->ord);
33
34 return psp;
35 }
36
psp_irq_handler(int irq,void * data)37 static irqreturn_t psp_irq_handler(int irq, void *data)
38 {
39 struct psp_device *psp = data;
40 unsigned int status;
41
42 /* Read the interrupt status: */
43 status = ioread32(psp->io_regs + psp->vdata->intsts_reg);
44
45 /* Clear the interrupt status by writing the same value we read. */
46 iowrite32(status, psp->io_regs + psp->vdata->intsts_reg);
47
48 /* invoke subdevice interrupt handlers */
49 if (status) {
50 if (psp->sev_irq_handler)
51 psp->sev_irq_handler(irq, psp->sev_irq_data, status);
52
53 if (psp->tee_irq_handler)
54 psp->tee_irq_handler(irq, psp->tee_irq_data, status);
55 }
56
57 return IRQ_HANDLED;
58 }
59
psp_get_capability(struct psp_device * psp)60 static unsigned int psp_get_capability(struct psp_device *psp)
61 {
62 unsigned int val = ioread32(psp->io_regs + psp->vdata->feature_reg);
63
64 /*
65 * Check for a access to the registers. If this read returns
66 * 0xffffffff, it's likely that the system is running a broken
67 * BIOS which disallows access to the device. Stop here and
68 * fail the PSP initialization (but not the load, as the CCP
69 * could get properly initialized).
70 */
71 if (val == 0xffffffff) {
72 dev_notice(psp->dev, "psp: unable to access the device: you might be running a broken BIOS.\n");
73 return -ENODEV;
74 }
75 psp->capability = val;
76
77 /* Detect if TSME and SME are both enabled */
78 if (psp->capability & PSP_CAPABILITY_PSP_SECURITY_REPORTING &&
79 psp->capability & (PSP_SECURITY_TSME_STATUS << PSP_CAPABILITY_PSP_SECURITY_OFFSET) &&
80 cc_platform_has(CC_ATTR_HOST_MEM_ENCRYPT))
81 dev_notice(psp->dev, "psp: Both TSME and SME are active, SME is unnecessary when TSME is active.\n");
82
83 return 0;
84 }
85
psp_check_sev_support(struct psp_device * psp)86 static int psp_check_sev_support(struct psp_device *psp)
87 {
88 /* Check if device supports SEV feature */
89 if (!(psp->capability & PSP_CAPABILITY_SEV)) {
90 dev_dbg(psp->dev, "psp does not support SEV\n");
91 return -ENODEV;
92 }
93
94 return 0;
95 }
96
psp_check_tee_support(struct psp_device * psp)97 static int psp_check_tee_support(struct psp_device *psp)
98 {
99 /* Check if device supports TEE feature */
100 if (!(psp->capability & PSP_CAPABILITY_TEE)) {
101 dev_dbg(psp->dev, "psp does not support TEE\n");
102 return -ENODEV;
103 }
104
105 return 0;
106 }
107
psp_init(struct psp_device * psp)108 static int psp_init(struct psp_device *psp)
109 {
110 int ret;
111
112 if (!psp_check_sev_support(psp)) {
113 ret = sev_dev_init(psp);
114 if (ret)
115 return ret;
116 }
117
118 if (!psp_check_tee_support(psp)) {
119 ret = tee_dev_init(psp);
120 if (ret)
121 return ret;
122 }
123
124 return 0;
125 }
126
psp_dev_init(struct sp_device * sp)127 int psp_dev_init(struct sp_device *sp)
128 {
129 struct device *dev = sp->dev;
130 struct psp_device *psp;
131 int ret;
132
133 ret = -ENOMEM;
134 psp = psp_alloc_struct(sp);
135 if (!psp)
136 goto e_err;
137
138 sp->psp_data = psp;
139
140 psp->vdata = (struct psp_vdata *)sp->dev_vdata->psp_vdata;
141 if (!psp->vdata) {
142 ret = -ENODEV;
143 dev_err(dev, "missing driver data\n");
144 goto e_err;
145 }
146
147 psp->io_regs = sp->io_map;
148
149 ret = psp_get_capability(psp);
150 if (ret)
151 goto e_disable;
152
153 /* Disable and clear interrupts until ready */
154 iowrite32(0, psp->io_regs + psp->vdata->inten_reg);
155 iowrite32(-1, psp->io_regs + psp->vdata->intsts_reg);
156
157 /* Request an irq */
158 ret = sp_request_psp_irq(psp->sp, psp_irq_handler, psp->name, psp);
159 if (ret) {
160 dev_err(dev, "psp: unable to allocate an IRQ\n");
161 goto e_err;
162 }
163
164 ret = psp_init(psp);
165 if (ret)
166 goto e_irq;
167
168 if (sp->set_psp_master_device)
169 sp->set_psp_master_device(sp);
170
171 /* Enable interrupt */
172 iowrite32(-1, psp->io_regs + psp->vdata->inten_reg);
173
174 dev_notice(dev, "psp enabled\n");
175
176 return 0;
177
178 e_irq:
179 sp_free_psp_irq(psp->sp, psp);
180 e_err:
181 sp->psp_data = NULL;
182
183 dev_notice(dev, "psp initialization failed\n");
184
185 return ret;
186
187 e_disable:
188 sp->psp_data = NULL;
189
190 return ret;
191 }
192
psp_dev_destroy(struct sp_device * sp)193 void psp_dev_destroy(struct sp_device *sp)
194 {
195 struct psp_device *psp = sp->psp_data;
196
197 if (!psp)
198 return;
199
200 sev_dev_destroy(psp);
201
202 tee_dev_destroy(psp);
203
204 sp_free_psp_irq(sp, psp);
205
206 if (sp->clear_psp_master_device)
207 sp->clear_psp_master_device(sp);
208 }
209
psp_set_sev_irq_handler(struct psp_device * psp,psp_irq_handler_t handler,void * data)210 void psp_set_sev_irq_handler(struct psp_device *psp, psp_irq_handler_t handler,
211 void *data)
212 {
213 psp->sev_irq_data = data;
214 psp->sev_irq_handler = handler;
215 }
216
psp_clear_sev_irq_handler(struct psp_device * psp)217 void psp_clear_sev_irq_handler(struct psp_device *psp)
218 {
219 psp_set_sev_irq_handler(psp, NULL, NULL);
220 }
221
psp_set_tee_irq_handler(struct psp_device * psp,psp_irq_handler_t handler,void * data)222 void psp_set_tee_irq_handler(struct psp_device *psp, psp_irq_handler_t handler,
223 void *data)
224 {
225 psp->tee_irq_data = data;
226 psp->tee_irq_handler = handler;
227 }
228
psp_clear_tee_irq_handler(struct psp_device * psp)229 void psp_clear_tee_irq_handler(struct psp_device *psp)
230 {
231 psp_set_tee_irq_handler(psp, NULL, NULL);
232 }
233
psp_get_master_device(void)234 struct psp_device *psp_get_master_device(void)
235 {
236 struct sp_device *sp = sp_get_psp_master_device();
237
238 return sp ? sp->psp_data : NULL;
239 }
240
psp_pci_init(void)241 void psp_pci_init(void)
242 {
243 psp_master = psp_get_master_device();
244
245 if (!psp_master)
246 return;
247
248 sev_pci_init();
249 }
250
psp_pci_exit(void)251 void psp_pci_exit(void)
252 {
253 if (!psp_master)
254 return;
255
256 sev_pci_exit();
257 }
258