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