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