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