xref: /rk3399_ARM-atf/lib/debugfs/devfip.c (revision 52e486f6a6192bd18d36cdcbc35c59092eefc810) 
1 /*
2  * Copyright (c) 2019-2021, Arm Limited. All rights reserved.
3  *
4  * SPDX-License-Identifier: BSD-3-Clause
5  */
6 
7 #include <assert.h>
8 #include <lib/debugfs.h>
9 #include <limits.h>
10 #include <plat/arm/common/plat_arm.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <tools_share/firmware_image_package.h>
14 
15 #include "dev.h"
16 
17 #define NR_FIPS		1
18 #define STOC_HEADER	(sizeof(fip_toc_header_t))
19 #define STOC_ENTRY	(sizeof(fip_toc_entry_t))
20 
21 struct fipfile {
22 	chan_t	*c;
23 	long	offset[NR_FILES];
24 	long	size[NR_FILES];
25 };
26 
27 struct fip_entry {
28 	uuid_t		uuid;
29 	long long	offset_address;
30 	long long	size;
31 	long long	flags;
32 };
33 
34 struct uuidnames {
35 	const char   name[NAMELEN];
36 	const uuid_t uuid;
37 };
38 
39 /*******************************************************************************
40  * This array links the FIP file names to their UUID.
41  * The elements are ordered according to the image number stored in
42  * tbbr_img_def.h, starting at index 1.
43  *
44  * TODO: this name to uuid binding will preferably be done using
45  * the coming Property Access Layer / Firmware CONFiguration feature.
46  ******************************************************************************/
47 static const struct uuidnames uuidnames[] = {
48 	{"",			{ {0}, {0}, {0}, 0, 0, {0} } },
49 	{"bl2.bin",		UUID_TRUSTED_BOOT_FIRMWARE_BL2},
50 	{"scp-bl2.bin",		UUID_SCP_FIRMWARE_SCP_BL2},
51 	{"bl31.bin",		UUID_EL3_RUNTIME_FIRMWARE_BL31},
52 	{"bl32.bin",		UUID_SECURE_PAYLOAD_BL32},
53 	{"bl33.bin",		UUID_NON_TRUSTED_FIRMWARE_BL33},
54 	{"tb-fw.crt",		UUID_TRUSTED_BOOT_FW_CERT},
55 	{"trstd-k.crt",		UUID_TRUSTED_KEY_CERT},
56 	{"scp-fw-k.crt",	UUID_SCP_FW_KEY_CERT},
57 	{"soc-fw-k.crt",	UUID_SOC_FW_KEY_CERT},
58 	{"tos-fw-k.crt",	UUID_TRUSTED_OS_FW_KEY_CERT},
59 	{"nt-fw-k.crt",		UUID_NON_TRUSTED_FW_KEY_CERT},
60 	{"scp-fw-c.crt",	UUID_SCP_FW_CONTENT_CERT},
61 	{"soc-fw-c.crt",	UUID_SOC_FW_CONTENT_CERT},
62 	{"tos-fw-c.crt",	UUID_TRUSTED_OS_FW_CONTENT_CERT},
63 	{"nt-fw-c.crt",		UUID_NON_TRUSTED_FW_CONTENT_CERT},
64 	{ },
65 	{"fwu.crt",		UUID_TRUSTED_FWU_CERT},
66 	{"scp-bl2u.bin",	UUID_TRUSTED_UPDATE_FIRMWARE_SCP_BL2U},
67 	{"bl2u.bin",		UUID_TRUSTED_UPDATE_FIRMWARE_BL2U},
68 	{"ns-bl2u.bin",		UUID_TRUSTED_UPDATE_FIRMWARE_NS_BL2U},
69 	{"bl32-xtr1.bin",	UUID_SECURE_PAYLOAD_BL32_EXTRA1},
70 	{"bl32-xtr2.bin",	UUID_SECURE_PAYLOAD_BL32_EXTRA2},
71 	{"hw.cfg",		UUID_HW_CONFIG},
72 	{"tb-fw.cfg",		UUID_TB_FW_CONFIG},
73 	{"soc-fw.cfg",		UUID_SOC_FW_CONFIG},
74 	{"tos-fw.cfg",		UUID_TOS_FW_CONFIG},
75 	{"nt-fw.cfg",		UUID_NT_FW_CONFIG},
76 	{"fw.cfg",		UUID_FW_CONFIG},
77 	{"rot-k.crt",		UUID_ROT_KEY_CERT},
78 	{"nt-k.crt",		UUID_NON_TRUSTED_WORLD_KEY_CERT},
79 	{"sip-sp.crt",		UUID_SIP_SECURE_PARTITION_CONTENT_CERT},
80 	{"plat-sp.crt",		UUID_PLAT_SECURE_PARTITION_CONTENT_CERT}
81 };
82 
83 /*******************************************************************************
84  * This array contains all the available FIP files.
85  ******************************************************************************/
86 static struct fipfile archives[NR_FIPS];
87 
88 /*******************************************************************************
89  * This variable stores the current number of registered FIP files.
90  ******************************************************************************/
91 static int nfips;
92 
93 /*******************************************************************************
94  * This function parses the ToC of the FIP.
95  ******************************************************************************/
96 static int get_entry(chan_t *c, struct fip_entry *entry)
97 {
98 	int n;
99 
100 	n = devtab[c->index]->read(c, entry, sizeof(struct fip_entry));
101 	if (n <= 0) {
102 		return n;
103 	}
104 
105 	if (n != sizeof(struct fip_entry)) {
106 		return -1;
107 	}
108 
109 	if (entry->size == 0) {
110 		return 0;
111 	}
112 
113 	return 1;
114 }
115 
116 /*******************************************************************************
117  * This function exposes the FIP images as files.
118  ******************************************************************************/
119 static int fipgen(chan_t *c, const dirtab_t *tab, int ntab, int n, dir_t *dir)
120 {
121 	int i, r;
122 	long off;
123 	chan_t nc;
124 	struct fip_entry entry;
125 	struct fipfile *fip;
126 	static const char unk[] = "unknown";
127 
128 	if (c->dev >= nfips) {
129 		panic();
130 	}
131 
132 	if (clone(archives[c->dev].c, &nc) == NULL) {
133 		panic();
134 	}
135 
136 	fip = &archives[nc.dev];
137 
138 	off = STOC_HEADER;
139 	for (i = 0; i <= n; i++) {
140 		if (fip->offset[i] == -1) {
141 			return 0;
142 		}
143 
144 		if (devtab[nc.index]->seek(&nc, off, KSEEK_SET) < 0) {
145 			return -1;
146 		}
147 
148 		r = get_entry(&nc, &entry);
149 		if (r <= 0) {
150 			return r;
151 		}
152 
153 		off += sizeof(entry);
154 	}
155 
156 	for (i = 1; i < NELEM(uuidnames); i++) {
157 		if (memcmp(&uuidnames[i].uuid,
158 			   &entry.uuid, sizeof(uuid_t)) == 0) {
159 			break;
160 		}
161 	}
162 
163 	if (i < NELEM(uuidnames)) {
164 		make_dir_entry(c, dir, uuidnames[i].name,
165 			       entry.size, n, O_READ);
166 	} else {
167 		// TODO: set name depending on uuid node value
168 		make_dir_entry(c, dir, unk, entry.size, n, O_READ);
169 	}
170 
171 	return 1;
172 }
173 
174 static int fipwalk(chan_t *c, const char *name)
175 {
176 	return devwalk(c, name, NULL, 0, fipgen);
177 }
178 
179 static int fipstat(chan_t *c, const char *file, dir_t *dir)
180 {
181 	return devstat(c, file, dir, NULL, 0, fipgen);
182 }
183 
184 /*******************************************************************************
185  * This function copies at most n bytes of the FIP image referred by c into
186  * buf.
187  ******************************************************************************/
188 static int fipread(chan_t *c, void *buf, int n)
189 {
190 	long off;
191 	chan_t cs;
192 	struct fipfile *fip;
193 	long size;
194 
195 	/* Only makes sense when using debug language */
196 	assert(c->qid != CHDIR);
197 
198 	if ((c->dev >= nfips) || ((c->qid & CHDIR) != 0)) {
199 		panic();
200 	}
201 
202 	fip = &archives[c->dev];
203 
204 	if ((c->qid >= NR_FILES) || (fip->offset[c->qid] < 0)) {
205 		panic();
206 	}
207 
208 	if (clone(fip->c, &cs) == NULL) {
209 		panic();
210 	}
211 
212 	size = fip->size[c->qid];
213 	if (c->offset >= size) {
214 		return 0;
215 	}
216 
217 	if (n < 0) {
218 		return -1;
219 	}
220 
221 	if (n > (size - c->offset)) {
222 		n = size - c->offset;
223 	}
224 
225 	off = fip->offset[c->qid] + c->offset;
226 	if (devtab[cs.index]->seek(&cs, off, KSEEK_SET) < 0) {
227 		return -1;
228 	}
229 
230 	n = devtab[cs.index]->read(&cs, buf, n);
231 	if (n > 0) {
232 		c->offset += n;
233 	}
234 
235 	return n;
236 }
237 
238 /*******************************************************************************
239  * This function parses the FIP spec and registers its images in order to
240  * expose them as files in the driver namespace.
241  * It acts as an initialization function for the FIP driver.
242  * It returns a pointer to the newly created channel.
243  ******************************************************************************/
244 static chan_t *fipmount(chan_t *c, const char *spec)
245 {
246 	int r, n, t;
247 	chan_t *cspec;
248 	uint32_t hname;
249 	struct fip_entry entry;
250 	struct fipfile *fip;
251 	dir_t dir;
252 
253 	if (nfips == NR_FIPS) {
254 		return NULL;
255 	}
256 
257 	fip = &archives[nfips];
258 
259 	for (n = 0; n < NR_FILES; n++) {
260 		fip->offset[n] = -1;
261 	}
262 
263 	cspec = path_to_channel(spec, O_READ);
264 	if (cspec == NULL) {
265 		return NULL;
266 	}
267 
268 	fip->c = cspec;
269 
270 	r = devtab[cspec->index]->read(cspec, &hname, sizeof(hname));
271 	if (r < 0) {
272 		goto err;
273 	}
274 
275 	if ((r != sizeof(hname)) || (hname != TOC_HEADER_NAME)) {
276 		goto err;
277 	}
278 
279 	if (stat(spec, &dir) < 0) {
280 		goto err;
281 	}
282 
283 	t = cspec->index;
284 	if (devtab[t]->seek(cspec, STOC_HEADER, KSEEK_SET) < 0) {
285 		goto err;
286 	}
287 
288 	for (n = 0; n < NR_FILES; n++) {
289 		switch (get_entry(cspec, &entry)) {
290 		case 0:
291 			return attach('F', nfips++);
292 		case -1:
293 			goto err;
294 		default:
295 			if ((entry.offset_address + entry.size) > dir.length) {
296 				goto err;
297 			}
298 
299 			fip->offset[n] = entry.offset_address;
300 			fip->size[n] = entry.size;
301 			break;
302 		}
303 	}
304 
305 err:
306 	channel_close(cspec);
307 	return NULL;
308 }
309 
310 const dev_t fipdevtab = {
311 	.id = 'F',
312 	.stat = fipstat,
313 	.clone = devclone,
314 	.attach = devattach,
315 	.walk = fipwalk,
316 	.read = fipread,
317 	.write = deverrwrite,
318 	.mount = fipmount,
319 	.seek = devseek
320 };
321 
322