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 220 void psp_set_sev_irq_handler(struct psp_device *psp, psp_irq_handler_t handler, 221 void *data) 222 { 223 psp->sev_irq_data = data; 224 psp->sev_irq_handler = handler; 225 } 226 227 void psp_clear_sev_irq_handler(struct psp_device *psp) 228 { 229 psp_set_sev_irq_handler(psp, NULL, NULL); 230 } 231 232 void psp_set_tee_irq_handler(struct psp_device *psp, psp_irq_handler_t handler, 233 void *data) 234 { 235 psp->tee_irq_data = data; 236 psp->tee_irq_handler = handler; 237 } 238 239 void psp_clear_tee_irq_handler(struct psp_device *psp) 240 { 241 psp_set_tee_irq_handler(psp, NULL, NULL); 242 } 243 244 struct psp_device *psp_get_master_device(void) 245 { 246 struct sp_device *sp = sp_get_psp_master_device(); 247 248 return sp ? sp->psp_data : NULL; 249 } 250 251 void psp_pci_init(void) 252 { 253 psp_master = psp_get_master_device(); 254 255 if (!psp_master) 256 return; 257 258 sev_pci_init(); 259 } 260 261 void psp_pci_exit(void) 262 { 263 if (!psp_master) 264 return; 265 266 sev_pci_exit(); 267 } 268