usr.sbin/bhyve/tpm_device.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2023 Beckhoff Automation GmbH & Co. KG
   5  * Author: Corvin Köhne <corvink@FreeBSD.org>
   6  */
   7
   8 #include <sys/types.h>
   9
  10 #include <assert.h>
  11 #include <err.h>
  12 #include <errno.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <vmmapi.h>
  16
  17 #include "acpi.h"
  18 #include "acpi_device.h"
  19 #include "config.h"
  20 #include "tpm_device.h"
  21 #include "tpm_emul.h"
  22 #include "tpm_intf.h"
  23 #include "tpm_ppi.h"
  24
  25 #define TPM_ACPI_DEVICE_NAME "TPM"
  26 #define TPM_ACPI_HARDWARE_ID "MSFT0101"
  27
  28 SET_DECLARE(tpm_emul_set, struct tpm_emul);
  29 SET_DECLARE(tpm_intf_set, struct tpm_intf);
  30 SET_DECLARE(tpm_ppi_set, struct tpm_ppi);
  31
  32 struct tpm_device {
  33         struct vmctx *vm_ctx;
  34         struct acpi_device *acpi_dev;
  35         struct tpm_emul *emul;
  36         void *emul_sc;
  37         struct tpm_intf *intf;
  38         void *intf_sc;
  39         struct tpm_ppi *ppi;
  40         void *ppi_sc;
  41 };
  42
  43 static int
  44 tpm_build_acpi_table(const struct acpi_device *const dev)
  45 {
  46         const struct tpm_device *const tpm = acpi_device_get_softc(dev);
  47
  48         if (tpm->intf->build_acpi_table == NULL) {
  49                 return (0);
  50         }
  51
  52         return (tpm->intf->build_acpi_table(tpm->intf_sc, tpm->vm_ctx));
  53 }
  54
  55 static int
  56 tpm_write_dsdt(const struct acpi_device *const dev)
  57 {
  58         int error;
  59
  60         const struct tpm_device *const tpm = acpi_device_get_softc(dev);
  61         const struct tpm_ppi *const ppi = tpm->ppi;
  62
  63         /*
  64          * packages for returns
  65          */
  66         dsdt_line("Name(TPM2, Package(2) {0, 0})");
  67         dsdt_line("Name(TPM3, Package(3) {0, 0, 0})");
  68
  69         if (ppi->write_dsdt_regions) {
  70                 error = ppi->write_dsdt_regions(tpm->ppi_sc);
  71                 if (error) {
  72                         warnx("%s: failed to write ppi dsdt regions\n",
  73                             __func__);
  74                         return (error);
  75                 }
  76         }
  77
  78         /*
  79          * Device Specific Method
  80          * Arg0: UUID
  81          * Arg1: Revision ID
  82          * Arg2: Function Index
  83          * Arg3: Arguments
  84          */
  85         dsdt_line("Method(_DSM, 4, Serialized)");
  86         dsdt_line("{");
  87         dsdt_indent(1);
  88         if (ppi->write_dsdt_dsm) {
  89                 error = ppi->write_dsdt_dsm(tpm->ppi_sc);
  90                 if (error) {
  91                         warnx("%s: failed to write ppi dsdt dsm\n", __func__);
  92                         return (error);
  93                 }
  94         }
  95         dsdt_unindent(1);
  96         dsdt_line("}");
  97
  98         return (0);
  99 }
 100
 101 static const struct acpi_device_emul tpm_acpi_device_emul = {
 102         .name = TPM_ACPI_DEVICE_NAME,
 103         .hid = TPM_ACPI_HARDWARE_ID,
 104         .build_table = tpm_build_acpi_table,
 105         .write_dsdt = tpm_write_dsdt,
 106 };
 107
 108 void
 109 tpm_device_destroy(struct tpm_device *const dev)
 110 {
 111         if (dev == NULL)
 112                 return;
 113
 114         if (dev->ppi != NULL && dev->ppi->deinit != NULL)
 115                 dev->ppi->deinit(dev->ppi_sc);
 116         if (dev->intf != NULL && dev->intf->deinit != NULL)
 117                 dev->intf->deinit(dev->intf_sc);
 118         if (dev->emul != NULL && dev->emul->deinit != NULL)
 119                 dev->emul->deinit(dev->emul_sc);
 120
 121         acpi_device_destroy(dev->acpi_dev);
 122         free(dev);
 123 }
 124
 125 int
 126 tpm_device_create(struct tpm_device **const new_dev, struct vmctx *const vm_ctx,
 127     nvlist_t *const nvl)
 128 {
 129         struct tpm_device *dev = NULL;
 130         struct tpm_emul **ppemul;
 131         struct tpm_intf **ppintf;
 132         struct tpm_ppi **pp_ppi;
 133         const char *value;
 134         int error;
 135
 136         if (new_dev == NULL || vm_ctx == NULL) {
 137                 error = EINVAL;
 138                 goto err_out;
 139         }
 140
 141         set_config_value_node_if_unset(nvl, "intf", "crb");
 142         set_config_value_node_if_unset(nvl, "ppi", "qemu");
 143
 144         value = get_config_value_node(nvl, "version");
 145         assert(value != NULL);
 146         if (strcmp(value, "2.0")) {
 147                 warnx("%s: unsupported tpm version %s", __func__, value);
 148                 error = EINVAL;
 149                 goto err_out;
 150         }
 151
 152         dev = calloc(1, sizeof(*dev));
 153         if (dev == NULL) {
 154                 error = ENOMEM;
 155                 goto err_out;
 156         }
 157
 158         dev->vm_ctx = vm_ctx;
 159
 160         error = acpi_device_create(&dev->acpi_dev, dev, dev->vm_ctx,
 161             &tpm_acpi_device_emul);
 162         if (error)
 163                 goto err_out;
 164
 165         value = get_config_value_node(nvl, "type");
 166         assert(value != NULL);
 167         SET_FOREACH(ppemul, tpm_emul_set) {
 168                 if (strcmp(value, (*ppemul)->name))
 169                         continue;
 170                 dev->emul = *ppemul;
 171                 break;
 172         }
 173         if (dev->emul == NULL) {
 174                 warnx("TPM emulation \"%s\" not found", value);
 175                 error = EINVAL;
 176                 goto err_out;
 177         }
 178
 179         if (dev->emul->init) {
 180                 error = dev->emul->init(&dev->emul_sc, nvl);
 181                 if (error)
 182                         goto err_out;
 183         }
 184
 185         value = get_config_value_node(nvl, "intf");
 186         SET_FOREACH(ppintf, tpm_intf_set) {
 187                 if (strcmp(value, (*ppintf)->name)) {
 188                         continue;
 189                 }
 190                 dev->intf = *ppintf;
 191                 break;
 192         }
 193         if (dev->intf == NULL) {
 194                 warnx("TPM interface \"%s\" not found", value);
 195                 error = EINVAL;
 196                 goto err_out;
 197         }
 198
 199         if (dev->intf->init) {
 200                 error = dev->intf->init(&dev->intf_sc, dev->emul, dev->emul_sc,
 201                     dev->acpi_dev);
 202                 if (error)
 203                         goto err_out;
 204         }
 205
 206         value = get_config_value_node(nvl, "ppi");
 207         SET_FOREACH(pp_ppi, tpm_ppi_set) {
 208                 if (strcmp(value, (*pp_ppi)->name)) {
 209                         continue;
 210                 }
 211                 dev->ppi = *pp_ppi;
 212                 break;
 213         }
 214         if (dev->ppi == NULL) {
 215                 warnx("TPM PPI \"%s\" not found\n", value);
 216                 error = EINVAL;
 217                 goto err_out;
 218         }
 219
 220         if (dev->ppi->init) {
 221                 error = dev->ppi->init(&dev->ppi_sc);
 222                 if (error)
 223                         goto err_out;
 224         }
 225
 226         *new_dev = dev;
 227
 228         return (0);
 229
 230 err_out:
 231         tpm_device_destroy(dev);
 232
 233         return (error);
 234 }
 235
 236 static struct tpm_device *lpc_tpm;
 237
 238 int
 239 init_tpm(struct vmctx *ctx)
 240 {
 241         nvlist_t *nvl;
 242         int error;
 243
 244         nvl = find_config_node("tpm");
 245         if (nvl == NULL)
 246                 return (0);
 247
 248         error = tpm_device_create(&lpc_tpm, ctx, nvl);
 249         if (error) {
 250                 warnx("%s: unable to create a TPM device (%d)",
 251                     __func__, error);
 252                 return (error);
 253         }
 254
 255         return (0);
 256 }