1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 2018 Linaro Limited 4 */ 5 6 #include <common.h> 7 #include <dm.h> 8 #include <dm/device-internal.h> 9 #include <dm/uclass-internal.h> 10 #include <tee.h> 11 12 /** 13 * struct tee_uclass_priv - information of a TEE, stored by the uclass 14 * 15 * @list_shm: list of structe tee_shm representing memory blocks shared 16 * with the TEE. 17 */ 18 struct tee_uclass_priv { 19 struct list_head list_shm; 20 }; 21 22 static const struct tee_driver_ops *tee_get_ops(struct udevice *dev) 23 { 24 return device_get_ops(dev); 25 } 26 27 void tee_get_version(struct udevice *dev, struct tee_version_data *vers) 28 { 29 tee_get_ops(dev)->get_version(dev, vers); 30 } 31 32 int tee_open_session(struct udevice *dev, struct tee_open_session_arg *arg, 33 uint num_param, struct tee_param *param) 34 { 35 return tee_get_ops(dev)->open_session(dev, arg, num_param, param); 36 } 37 38 int tee_close_session(struct udevice *dev, u32 session) 39 { 40 return tee_get_ops(dev)->close_session(dev, session); 41 } 42 43 int tee_invoke_func(struct udevice *dev, struct tee_invoke_arg *arg, 44 uint num_param, struct tee_param *param) 45 { 46 return tee_get_ops(dev)->invoke_func(dev, arg, num_param, param); 47 } 48 49 int __tee_shm_add(struct udevice *dev, ulong align, void *addr, ulong size, 50 u32 flags, struct tee_shm **shmp) 51 { 52 struct tee_shm *shm; 53 void *p = addr; 54 int rc; 55 56 if (flags & TEE_SHM_ALLOC) { 57 if (align) 58 p = memalign(align, size); 59 else 60 p = malloc(size); 61 } 62 if (!p) 63 return -ENOMEM; 64 65 shm = calloc(1, sizeof(*shm)); 66 if (!shm) { 67 rc = -ENOMEM; 68 goto err; 69 } 70 71 shm->dev = dev; 72 shm->addr = p; 73 shm->size = size; 74 shm->flags = flags; 75 76 if (flags & TEE_SHM_SEC_REGISTER) { 77 rc = tee_get_ops(dev)->shm_register(dev, shm); 78 if (rc) 79 goto err; 80 } 81 82 if (flags & TEE_SHM_REGISTER) { 83 struct tee_uclass_priv *priv = dev_get_uclass_priv(dev); 84 85 list_add(&shm->link, &priv->list_shm); 86 } 87 88 *shmp = shm; 89 90 return 0; 91 err: 92 free(shm); 93 if (flags & TEE_SHM_ALLOC) 94 free(p); 95 96 return rc; 97 } 98 99 int tee_shm_alloc(struct udevice *dev, ulong size, u32 flags, 100 struct tee_shm **shmp) 101 { 102 u32 f = flags; 103 104 f |= TEE_SHM_SEC_REGISTER | TEE_SHM_REGISTER | TEE_SHM_ALLOC; 105 106 return __tee_shm_add(dev, 0, NULL, size, f, shmp); 107 } 108 109 int tee_shm_register(struct udevice *dev, void *addr, ulong size, u32 flags, 110 struct tee_shm **shmp) 111 { 112 u32 f = flags & ~TEE_SHM_ALLOC; 113 114 f |= TEE_SHM_SEC_REGISTER | TEE_SHM_REGISTER; 115 116 return __tee_shm_add(dev, 0, addr, size, f, shmp); 117 } 118 119 void tee_shm_free(struct tee_shm *shm) 120 { 121 if (!shm) 122 return; 123 124 if (shm->flags & TEE_SHM_SEC_REGISTER) 125 tee_get_ops(shm->dev)->shm_unregister(shm->dev, shm); 126 127 if (shm->flags & TEE_SHM_REGISTER) 128 list_del(&shm->link); 129 130 if (shm->flags & TEE_SHM_ALLOC) 131 free(shm->addr); 132 133 free(shm); 134 } 135 136 bool tee_shm_is_registered(struct tee_shm *shm, struct udevice *dev) 137 { 138 struct tee_uclass_priv *priv = dev_get_uclass_priv(dev); 139 struct tee_shm *s; 140 141 list_for_each_entry(s, &priv->list_shm, link) 142 if (s == shm) 143 return true; 144 145 return false; 146 } 147 148 struct udevice *tee_find_device(struct udevice *start, 149 int (*match)(struct tee_version_data *vers, 150 const void *data), 151 const void *data, 152 struct tee_version_data *vers) 153 { 154 struct udevice *dev = start; 155 struct tee_version_data lv; 156 struct tee_version_data *v = vers ? vers : &lv; 157 158 if (!dev) 159 uclass_find_first_device(UCLASS_TEE, &dev); 160 else 161 uclass_find_next_device(&dev); 162 163 for (; dev; uclass_find_next_device(&dev)) { 164 if (device_probe(dev)) 165 continue; 166 tee_get_ops(dev)->get_version(dev, v); 167 if (!match || match(v, data)) 168 return dev; 169 } 170 171 return NULL; 172 } 173 174 static int tee_pre_probe(struct udevice *dev) 175 { 176 struct tee_uclass_priv *priv = dev_get_uclass_priv(dev); 177 178 INIT_LIST_HEAD(&priv->list_shm); 179 180 return 0; 181 } 182 183 static int tee_pre_remove(struct udevice *dev) 184 { 185 struct tee_uclass_priv *priv = dev_get_uclass_priv(dev); 186 struct tee_shm *shm; 187 188 /* 189 * Any remaining shared memory must be unregistered now as U-Boot 190 * is about to hand over to the next stage and that memory will be 191 * reused. 192 */ 193 while (!list_empty(&priv->list_shm)) { 194 shm = list_first_entry(&priv->list_shm, struct tee_shm, link); 195 debug("%s: freeing leftover shm %p (size %lu, flags %#x)\n", 196 __func__, (void *)shm, shm->size, shm->flags); 197 tee_shm_free(shm); 198 } 199 200 return 0; 201 } 202 203 UCLASS_DRIVER(tee) = { 204 .id = UCLASS_TEE, 205 .name = "tee", 206 .per_device_auto_alloc_size = sizeof(struct tee_uclass_priv), 207 .pre_probe = tee_pre_probe, 208 .pre_remove = tee_pre_remove, 209 }; 210 211 void tee_optee_ta_uuid_from_octets(struct tee_optee_ta_uuid *d, 212 const u8 s[TEE_UUID_LEN]) 213 { 214 d->time_low = ((u32)s[0] << 24) | ((u32)s[1] << 16) | 215 ((u32)s[2] << 8) | s[3], 216 d->time_mid = ((u32)s[4] << 8) | s[5]; 217 d->time_hi_and_version = ((u32)s[6] << 8) | s[7]; 218 memcpy(d->clock_seq_and_node, s + 8, sizeof(d->clock_seq_and_node)); 219 } 220 221 void tee_optee_ta_uuid_to_octets(u8 d[TEE_UUID_LEN], 222 const struct tee_optee_ta_uuid *s) 223 { 224 d[0] = s->time_low >> 24; 225 d[1] = s->time_low >> 16; 226 d[2] = s->time_low >> 8; 227 d[3] = s->time_low; 228 d[4] = s->time_mid >> 8; 229 d[5] = s->time_mid; 230 d[6] = s->time_hi_and_version >> 8; 231 d[7] = s->time_hi_and_version; 232 memcpy(d + 8, s->clock_seq_and_node, sizeof(s->clock_seq_and_node)); 233 } 234