projects/linux·blob master · refs

381 lines · 7.7 KiB

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 <[email protected]>
8 */
9
10#include <linux/kernel.h>
11#include <linux/irqreturn.h>
12#include <linux/mutex.h>
13#include <linux/bitfield.h>
14#include <linux/delay.h>
15
16#include "sp-dev.h"
17#include "psp-dev.h"
18#include "sev-dev.h"
19#include "tee-dev.h"
20#include "sfs.h"
21#include "platform-access.h"
22#include "dbc.h"
23#include "hsti.h"
24
25struct psp_device *psp_master;
26
27#define PSP_C2PMSG_17_CMDRESP_CMD GENMASK(19, 16)
28
29static int psp_mailbox_poll(const void __iomem *cmdresp_reg, unsigned int *cmdresp,
30 unsigned int timeout_msecs)
31{
32 while (true) {
33 *cmdresp = ioread32(cmdresp_reg);
34 if (FIELD_GET(PSP_CMDRESP_RESP, *cmdresp))
35 return 0;
36
37 if (!timeout_msecs--)
38 break;
39
40 usleep_range(1000, 1100);
41 }
42
43 return -ETIMEDOUT;
44}
45
46int psp_mailbox_command(struct psp_device *psp, enum psp_cmd cmd, void *cmdbuff,
47 unsigned int timeout_msecs, unsigned int *cmdresp)
48{
49 void __iomem *cmdresp_reg, *cmdbuff_lo_reg, *cmdbuff_hi_reg;
50 int ret;
51
52 if (!psp || !psp->vdata || !psp->vdata->cmdresp_reg ||
53 !psp->vdata->cmdbuff_addr_lo_reg || !psp->vdata->cmdbuff_addr_hi_reg)
54 return -ENODEV;
55
56 cmdresp_reg = psp->io_regs + psp->vdata->cmdresp_reg;
57 cmdbuff_lo_reg = psp->io_regs + psp->vdata->cmdbuff_addr_lo_reg;
58 cmdbuff_hi_reg = psp->io_regs + psp->vdata->cmdbuff_addr_hi_reg;
59
60 mutex_lock(&psp->mailbox_mutex);
61
62 /* Ensure mailbox is ready for a command */
63 ret = -EBUSY;
64 if (psp_mailbox_poll(cmdresp_reg, cmdresp, 0))
65 goto unlock;
66
67 if (cmdbuff) {
68 iowrite32(lower_32_bits(__psp_pa(cmdbuff)), cmdbuff_lo_reg);
69 iowrite32(upper_32_bits(__psp_pa(cmdbuff)), cmdbuff_hi_reg);
70 }
71
72 *cmdresp = FIELD_PREP(PSP_C2PMSG_17_CMDRESP_CMD, cmd);
73 iowrite32(*cmdresp, cmdresp_reg);
74
75 ret = psp_mailbox_poll(cmdresp_reg, cmdresp, timeout_msecs);
76
77unlock:
78 mutex_unlock(&psp->mailbox_mutex);
79
80 return ret;
81}
82
83int psp_extended_mailbox_cmd(struct psp_device *psp, unsigned int timeout_msecs,
84 struct psp_ext_request *req)
85{
86 unsigned int reg;
87 int ret;
88
89 print_hex_dump_debug("->psp ", DUMP_PREFIX_OFFSET, 16, 2, req,
90 req->header.payload_size, false);
91
92 ret = psp_mailbox_command(psp, PSP_CMD_TEE_EXTENDED_CMD, (void *)req,
93 timeout_msecs, &reg);
94 if (ret) {
95 return ret;
96 } else if (FIELD_GET(PSP_CMDRESP_STS, reg)) {
97 req->header.status = FIELD_GET(PSP_CMDRESP_STS, reg);
98 return -EIO;
99 }
100
101 print_hex_dump_debug("<-psp ", DUMP_PREFIX_OFFSET, 16, 2, req,
102 req->header.payload_size, false);
103
104 return 0;
105}
106
107static struct psp_device *psp_alloc_struct(struct sp_device *sp)
108{
109 struct device *dev = sp->dev;
110 struct psp_device *psp;
111
112 psp = devm_kzalloc(dev, sizeof(*psp), GFP_KERNEL);
113 if (!psp)
114 return NULL;
115
116 psp->dev = dev;
117 psp->sp = sp;
118
119 snprintf(psp->name, sizeof(psp->name), "psp-%u", sp->ord);
120
121 return psp;
122}
123
124static irqreturn_t psp_irq_handler(int irq, void *data)
125{
126 struct psp_device *psp = data;
127 unsigned int status;
128
129 /* Read the interrupt status: */
130 status = ioread32(psp->io_regs + psp->vdata->intsts_reg);
131
132 /* Clear the interrupt status by writing the same value we read. */
133 iowrite32(status, psp->io_regs + psp->vdata->intsts_reg);
134
135 /* invoke subdevice interrupt handlers */
136 if (status) {
137 if (psp->sev_irq_handler)
138 psp->sev_irq_handler(irq, psp->sev_irq_data, status);
139 }
140
141 return IRQ_HANDLED;
142}
143
144static unsigned int psp_get_capability(struct psp_device *psp)
145{
146 unsigned int val = ioread32(psp->io_regs + psp->vdata->feature_reg);
147
148 /*
149 * Check for a access to the registers. If this read returns
150 * 0xffffffff, it's likely that the system is running a broken
151 * BIOS which disallows access to the device. Stop here and
152 * fail the PSP initialization (but not the load, as the CCP
153 * could get properly initialized).
154 */
155 if (val == 0xffffffff) {
156 dev_notice(psp->dev, "psp: unable to access the device: you might be running a broken BIOS.\n");
157 return -ENODEV;
158 }
159 psp->capability.raw = val;
160
161 return 0;
162}
163
164static int psp_check_sev_support(struct psp_device *psp)
165{
166 /* Check if device supports SEV feature */
167 if (!psp->capability.sev) {
168 dev_dbg(psp->dev, "psp does not support SEV\n");
169 return -ENODEV;
170 }
171
172 return 0;
173}
174
175static int psp_check_tee_support(struct psp_device *psp)
176{
177 /* Check if device supports TEE feature */
178 if (!psp->capability.tee) {
179 dev_dbg(psp->dev, "psp does not support TEE\n");
180 return -ENODEV;
181 }
182
183 return 0;
184}
185
186static int psp_check_sfs_support(struct psp_device *psp)
187{
188 /* Check if device supports SFS feature */
189 if (!psp->capability.sfs) {
190 dev_dbg(psp->dev, "psp does not support SFS\n");
191 return -ENODEV;
192 }
193
194 return 0;
195}
196
197static int psp_init(struct psp_device *psp)
198{
199 int ret;
200
201 if (!psp_check_sev_support(psp)) {
202 ret = sev_dev_init(psp);
203 if (ret)
204 return ret;
205 }
206
207 if (!psp_check_tee_support(psp)) {
208 ret = tee_dev_init(psp);
209 if (ret)
210 return ret;
211 }
212
213 if (!psp_check_sfs_support(psp)) {
214 ret = sfs_dev_init(psp);
215 if (ret)
216 return ret;
217 }
218
219 if (psp->vdata->platform_access) {
220 ret = platform_access_dev_init(psp);
221 if (ret)
222 return ret;
223 }
224
225 /* dbc must come after platform access as it tests the feature */
226 if (PSP_FEATURE(psp, DBC) ||
227 psp->capability.dbc_thru_ext) {
228 ret = dbc_dev_init(psp);
229 if (ret)
230 return ret;
231 }
232
233 /* HSTI uses platform access on some systems. */
234 ret = psp_init_hsti(psp);
235 if (ret)
236 return ret;
237
238 return 0;
239}
240
241int psp_dev_init(struct sp_device *sp)
242{
243 struct device *dev = sp->dev;
244 struct psp_device *psp;
245 int ret;
246
247 ret = -ENOMEM;
248 psp = psp_alloc_struct(sp);
249 if (!psp)
250 goto e_err;
251
252 sp->psp_data = psp;
253
254 psp->vdata = (struct psp_vdata *)sp->dev_vdata->psp_vdata;
255 if (!psp->vdata) {
256 ret = -ENODEV;
257 dev_err(dev, "missing driver data\n");
258 goto e_err;
259 }
260
261 psp->io_regs = sp->io_map;
262 mutex_init(&psp->mailbox_mutex);
263
264 ret = psp_get_capability(psp);
265 if (ret)
266 goto e_disable;
267
268 /* Disable and clear interrupts until ready */
269 iowrite32(0, psp->io_regs + psp->vdata->inten_reg);
270 iowrite32(-1, psp->io_regs + psp->vdata->intsts_reg);
271
272 /* Request an irq */
273 ret = sp_request_psp_irq(psp->sp, psp_irq_handler, psp->name, psp);
274 if (ret) {
275 dev_err(dev, "psp: unable to allocate an IRQ\n");
276 goto e_err;
277 }
278
279 /* master device must be set for platform access */
280 if (psp->sp->set_psp_master_device)
281 psp->sp->set_psp_master_device(psp->sp);
282
283 ret = psp_init(psp);
284 if (ret)
285 goto e_irq;
286
287 /* Enable interrupt */
288 iowrite32(-1, psp->io_regs + psp->vdata->inten_reg);
289
290 dev_notice(dev, "psp enabled\n");
291
292 return 0;
293
294e_irq:
295 if (sp->clear_psp_master_device)
296 sp->clear_psp_master_device(sp);
297
298 sp_free_psp_irq(psp->sp, psp);
299e_err:
300 sp->psp_data = NULL;
301
302 dev_notice(dev, "psp initialization failed\n");
303
304 return ret;
305
306e_disable:
307 sp->psp_data = NULL;
308
309 return ret;
310}
311
312void psp_dev_destroy(struct sp_device *sp)
313{
314 struct psp_device *psp = sp->psp_data;
315
316 if (!psp)
317 return;
318
319 dbc_dev_destroy(psp);
320
321 platform_access_dev_destroy(psp);
322
323 sfs_dev_destroy(psp);
324
325 tee_dev_destroy(psp);
326
327 sev_dev_destroy(psp);
328
329 sp_free_psp_irq(sp, psp);
330
331 if (sp->clear_psp_master_device)
332 sp->clear_psp_master_device(sp);
333}
334
335void psp_set_sev_irq_handler(struct psp_device *psp, psp_irq_handler_t handler,
336 void *data)
337{
338 psp->sev_irq_data = data;
339 psp->sev_irq_handler = handler;
340}
341
342void psp_clear_sev_irq_handler(struct psp_device *psp)
343{
344 psp_set_sev_irq_handler(psp, NULL, NULL);
345}
346
347struct psp_device *psp_get_master_device(void)
348{
349 struct sp_device *sp = sp_get_psp_master_device();
350
351 return sp ? sp->psp_data : NULL;
352}
353
354int psp_restore(struct sp_device *sp)
355{
356 struct psp_device *psp = sp->psp_data;
357 int ret = 0;
358
359 if (psp->tee_data)
360 ret = tee_restore(psp);
361
362 return ret;
363}
364
365void psp_pci_init(void)
366{
367 psp_master = psp_get_master_device();
368
369 if (!psp_master)
370 return;
371
372 sev_pci_init();
373}
374
375void psp_pci_exit(void)
376{
377 if (!psp_master)
378 return;
379
380 sev_pci_exit();
381}