lib/tpm_api.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2019 Google LLC
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <log.h>
   9 #include <tpm_api.h>
  10 #include <tpm-v1.h>
  11 #include <tpm-v2.h>
  12 #include <tpm_api.h>
  13
  14 static bool is_tpm1(struct udevice *dev)
  15 {
  16         return IS_ENABLED(CONFIG_TPM_V1) && tpm_get_version(dev) == TPM_V1;
  17 }
  18
  19 u32 tpm_startup(struct udevice *dev, enum tpm_startup_type mode)
  20 {
  21         if (is_tpm1(dev))
  22                 return tpm1_startup(dev, mode);
  23         else
  24                 return -ENOSYS;
  25 }
  26
  27 u32 tpm_resume(struct udevice *dev)
  28 {
  29         if (is_tpm1(dev))
  30                 return tpm1_startup(dev, TPM_ST_STATE);
  31         else
  32                 return -ENOSYS;
  33 }
  34
  35 u32 tpm_self_test_full(struct udevice *dev)
  36 {
  37         if (is_tpm1(dev))
  38                 return tpm1_self_test_full(dev);
  39         else
  40                 return -ENOSYS;
  41 }
  42
  43 u32 tpm_continue_self_test(struct udevice *dev)
  44 {
  45         if (is_tpm1(dev))
  46                 return tpm1_continue_self_test(dev);
  47         else
  48                 return -ENOSYS;
  49 }
  50
  51 u32 tpm_clear_and_reenable(struct udevice *dev)
  52 {
  53         u32 ret;
  54
  55         log_info("TPM: Clear and re-enable\n");
  56         ret = tpm_force_clear(dev);
  57         if (ret != TPM_SUCCESS) {
  58                 log_err("Can't initiate a force clear\n");
  59                 return ret;
  60         }
  61
  62         if (is_tpm1(dev)) {
  63                 ret = tpm1_physical_enable(dev);
  64                 if (ret != TPM_SUCCESS) {
  65                         log_err("TPM: Can't set enabled state\n");
  66                         return ret;
  67                 }
  68
  69                 ret = tpm1_physical_set_deactivated(dev, 0);
  70                 if (ret != TPM_SUCCESS) {
  71                         log_err("TPM: Can't set deactivated state\n");
  72                         return ret;
  73                 }
  74         } else {
  75                 return -ENOSYS;
  76         }
  77
  78         return TPM_SUCCESS;
  79 }
  80
  81 u32 tpm_nv_enable_locking(struct udevice *dev)
  82 {
  83         if (is_tpm1(dev))
  84                 return tpm1_nv_define_space(dev, TPM_NV_INDEX_LOCK, 0, 0);
  85         else
  86                 return -ENOSYS;
  87 }
  88
  89 u32 tpm_nv_read_value(struct udevice *dev, u32 index, void *data, u32 count)
  90 {
  91         if (is_tpm1(dev))
  92                 return tpm1_nv_read_value(dev, index, data, count);
  93         else
  94                 return -ENOSYS;
  95 }
  96
  97 u32 tpm_nv_write_value(struct udevice *dev, u32 index, const void *data,
  98                        u32 count)
  99 {
 100         if (is_tpm1(dev))
 101                 return tpm1_nv_write_value(dev, index, data, count);
 102         else
 103                 return -ENOSYS;
 104 }
 105
 106 u32 tpm_set_global_lock(struct udevice *dev)
 107 {
 108         return tpm_nv_write_value(dev, TPM_NV_INDEX_0, NULL, 0);
 109 }
 110
 111 u32 tpm_write_lock(struct udevice *dev, u32 index)
 112 {
 113         if (is_tpm1(dev))
 114                 return -ENOSYS;
 115         else
 116                 return -ENOSYS;
 117 }
 118
 119 u32 tpm_pcr_extend(struct udevice *dev, u32 index, const void *in_digest,
 120                    void *out_digest)
 121 {
 122         if (is_tpm1(dev))
 123                 return tpm1_extend(dev, index, in_digest, out_digest);
 124         else
 125                 return -ENOSYS;
 126 }
 127
 128 u32 tpm_pcr_read(struct udevice *dev, u32 index, void *data, size_t count)
 129 {
 130         if (is_tpm1(dev))
 131                 return tpm1_pcr_read(dev, index, data, count);
 132         else
 133                 return -ENOSYS;
 134 }
 135
 136 u32 tpm_tsc_physical_presence(struct udevice *dev, u16 presence)
 137 {
 138         if (is_tpm1(dev))
 139                 return tpm1_tsc_physical_presence(dev, presence);
 140         else
 141                 return -ENOSYS;
 142 }
 143
 144 u32 tpm_finalise_physical_presence(struct udevice *dev)
 145 {
 146         if (is_tpm1(dev))
 147                 return tpm1_finalise_physical_presence(dev);
 148         else
 149                 return -ENOSYS;
 150 }
 151
 152 u32 tpm_read_pubek(struct udevice *dev, void *data, size_t count)
 153 {
 154         if (is_tpm1(dev))
 155                 return tpm1_read_pubek(dev, data, count);
 156         else
 157                 return -ENOSYS; /* not implemented yet */
 158 }
 159
 160 u32 tpm_force_clear(struct udevice *dev)
 161 {
 162         if (is_tpm1(dev))
 163                 return tpm1_force_clear(dev);
 164         else
 165                 return -ENOSYS;
 166 }
 167
 168 u32 tpm_physical_enable(struct udevice *dev)
 169 {
 170         if (is_tpm1(dev))
 171                 return tpm1_physical_enable(dev);
 172         else
 173                 return -ENOSYS;
 174 }
 175
 176 u32 tpm_physical_disable(struct udevice *dev)
 177 {
 178         if (is_tpm1(dev))
 179                 return tpm1_physical_disable(dev);
 180         else
 181                 return -ENOSYS;
 182 }
 183
 184 u32 tpm_physical_set_deactivated(struct udevice *dev, u8 state)
 185 {
 186         if (is_tpm1(dev))
 187                 return tpm1_physical_set_deactivated(dev, state);
 188         else
 189                 return -ENOSYS;
 190 }
 191
 192 u32 tpm_get_capability(struct udevice *dev, u32 cap_area, u32 sub_cap,
 193                        void *cap, size_t count)
 194 {
 195         if (is_tpm1(dev))
 196                 return tpm1_get_capability(dev, cap_area, sub_cap, cap, count);
 197         else
 198                 return -ENOSYS;
 199 }
 200
 201 u32 tpm_get_permissions(struct udevice *dev, u32 index, u32 *perm)
 202 {
 203         if (is_tpm1(dev))
 204                 return tpm1_get_permissions(dev, index, perm);
 205         else
 206                 return -ENOSYS; /* not implemented yet */
 207 }
 208
 209 u32 tpm_get_random(struct udevice *dev, void *data, u32 count)
 210 {
 211         if (is_tpm1(dev))
 212                 return tpm1_get_random(dev, data, count);
 213         else
 214                 return -ENOSYS; /* not implemented yet */
 215 }