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         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 }