dm: core: Introduce dev_read_alias_highest_id()
[oweals/u-boot.git] / drivers / tee / tee-uclass.c
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 }