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 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 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 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 /* invoke subdevice interrupt handlers */ 46 if (status) { 47 if (psp->sev_irq_handler) 48 psp->sev_irq_handler(irq, psp->sev_irq_data, status); 49 50 if (psp->tee_irq_handler) 51 psp->tee_irq_handler(irq, psp->tee_irq_data, status); 52 } 53 54 /* Clear the interrupt status by writing the same value we read. */ 55 iowrite32(status, psp->io_regs + psp->vdata->intsts_reg); 56 57 return IRQ_HANDLED; 58 } 59 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 return 0; 78 } 79 80 static int psp_check_sev_support(struct psp_device *psp) 81 { 82 /* Check if device supports SEV feature */ 83 if (!(psp->capability & PSP_CAPABILITY_SEV)) { 84 dev_dbg(psp->dev, "psp does not support SEV\n"); 85 return -ENODEV; 86 } 87 88 return 0; 89 } 90 91 static int psp_check_tee_support(struct psp_device *psp) 92 { 93 /* Check if device supports TEE feature */ 94 if (!(psp->capability & PSP_CAPABILITY_TEE)) { 95 dev_dbg(psp->dev, "psp does not support TEE\n"); 96 return -ENODEV; 97 } 98 99 return 0; 100 } 101 102 static int psp_init(struct psp_device *psp) 103 { 104 int ret; 105 106 if (!psp_check_sev_support(psp)) { 107 ret = sev_dev_init(psp); 108 if (ret) 109 return ret; 110 } 111 112 if (!psp_check_tee_support(psp)) { 113 ret = tee_dev_init(psp); 114 if (ret) 115 return ret; 116 } 117 118 return 0; 119 } 120 121 int psp_dev_init(struct sp_device *sp) 122 { 123 struct device *dev = sp->dev; 124 struct psp_device *psp; 125 int ret; 126 127 ret = -ENOMEM; 128 psp = psp_alloc_struct(sp); 129 if (!psp) 130 goto e_err; 131 132 sp->psp_data = psp; 133 134 psp->vdata = (struct psp_vdata *)sp->dev_vdata->psp_vdata; 135 if (!psp->vdata) { 136 ret = -ENODEV; 137 dev_err(dev, "missing driver data\n"); 138 goto e_err; 139 } 140 141 psp->io_regs = sp->io_map; 142 143 ret = psp_get_capability(psp); 144 if (ret) 145 goto e_disable; 146 147 /* Disable and clear interrupts until ready */ 148 iowrite32(0, psp->io_regs + psp->vdata->inten_reg); 149 iowrite32(-1, psp->io_regs + psp->vdata->intsts_reg); 150 151 /* Request an irq */ 152 ret = sp_request_psp_irq(psp->sp, psp_irq_handler, psp->name, psp); 153 if (ret) { 154 dev_err(dev, "psp: unable to allocate an IRQ\n"); 155 goto e_err; 156 } 157 158 ret = psp_init(psp); 159 if (ret) 160 goto e_irq; 161 162 if (sp->set_psp_master_device) 163 sp->set_psp_master_device(sp); 164 165 /* Enable interrupt */ 166 iowrite32(-1, psp->io_regs + psp->vdata->inten_reg); 167 168 dev_notice(dev, "psp enabled\n"); 169 170 return 0; 171 172 e_irq: 173 sp_free_psp_irq(psp->sp, psp); 174 e_err: 175 sp->psp_data = NULL; 176 177 dev_notice(dev, "psp initialization failed\n"); 178 179 return ret; 180 181 e_disable: 182 sp->psp_data = NULL; 183 184 return ret; 185 } 186 187 void psp_dev_destroy(struct sp_device *sp) 188 { 189 struct psp_device *psp = sp->psp_data; 190 191 if (!psp) 192 return; 193 194 sev_dev_destroy(psp); 195 196 tee_dev_destroy(psp); 197 198 sp_free_psp_irq(sp, psp); 199 200 if (sp->clear_psp_master_device) 201 sp->clear_psp_master_device(sp); 202 } 203 204 void psp_set_sev_irq_handler(struct psp_device *psp, psp_irq_handler_t handler, 205 void *data) 206 { 207 psp->sev_irq_data = data; 208 psp->sev_irq_handler = handler; 209 } 210 211 void psp_clear_sev_irq_handler(struct psp_device *psp) 212 { 213 psp_set_sev_irq_handler(psp, NULL, NULL); 214 } 215 216 void psp_set_tee_irq_handler(struct psp_device *psp, psp_irq_handler_t handler, 217 void *data) 218 { 219 psp->tee_irq_data = data; 220 psp->tee_irq_handler = handler; 221 } 222 223 void psp_clear_tee_irq_handler(struct psp_device *psp) 224 { 225 psp_set_tee_irq_handler(psp, NULL, NULL); 226 } 227 228 struct psp_device *psp_get_master_device(void) 229 { 230 struct sp_device *sp = sp_get_psp_master_device(); 231 232 return sp ? sp->psp_data : NULL; 233 } 234 235 void psp_pci_init(void) 236 { 237 psp_master = psp_get_master_device(); 238 239 if (!psp_master) 240 return; 241 242 sev_pci_init(); 243 } 244 245 void psp_pci_exit(void) 246 { 247 if (!psp_master) 248 return; 249 250 sev_pci_exit(); 251 } 252