drivers/crypto/ccp/psp-dev.c

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