1 /*
2 * Copyright (c) 2014-2019, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <errno.h>
9 #include <stdint.h>
10 #include <string.h>
11
12 #include <platform_def.h>
13
14 #include <common/bl_common.h>
15 #include <common/debug.h>
16 #include <drivers/io/io_driver.h>
17 #include <drivers/io/io_fip.h>
18 #include <drivers/io/io_storage.h>
19 #include <lib/utils.h>
20 #include <plat/common/platform.h>
21 #include <tools_share/firmware_image_package.h>
22 #include <tools_share/uuid.h>
23
24 #ifndef MAX_FIP_DEVICES
25 #define MAX_FIP_DEVICES 1
26 #endif
27
28 /* Useful for printing UUIDs when debugging.*/
29 #define PRINT_UUID2(x) \
30 "%08x-%04hx-%04hx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx", \
31 x.time_low, x.time_mid, x.time_hi_and_version, \
32 x.clock_seq_hi_and_reserved, x.clock_seq_low, \
33 x.node[0], x.node[1], x.node[2], x.node[3], \
34 x.node[4], x.node[5]
35
36 typedef struct {
37 unsigned int file_pos;
38 fip_toc_entry_t entry;
39 } file_state_t;
40
41 /*
42 * Maintain dev_spec per FIP Device
43 * TODO - Add backend handles and file state
44 * per FIP device here once backends like io_memmap
45 * can support multiple open files
46 */
47 typedef struct {
48 uintptr_t dev_spec;
49 } fip_dev_state_t;
50
51 static const uuid_t uuid_null;
52 /*
53 * Only one file can be open across all FIP device
54 * as backends like io_memmap don't support
55 * multiple open files. The file state and
56 * backend handle should be maintained per FIP device
57 * if the same support is available in the backend
58 */
59 static file_state_t current_file = {0};
60 static uintptr_t backend_dev_handle;
61 static uintptr_t backend_image_spec;
62
63 static fip_dev_state_t state_pool[MAX_FIP_DEVICES];
64 static io_dev_info_t dev_info_pool[MAX_FIP_DEVICES];
65
66 /* Track number of allocated fip devices */
67 static unsigned int fip_dev_count;
68
69 /* Firmware Image Package driver functions */
70 static int fip_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info);
71 static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
72 io_entity_t *entity);
73 static int fip_file_len(io_entity_t *entity, size_t *length);
74 static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
75 size_t *length_read);
76 static int fip_file_close(io_entity_t *entity);
77 static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params);
78 static int fip_dev_close(io_dev_info_t *dev_info);
79
80
81 /* Return 0 for equal uuids. */
compare_uuids(const uuid_t * uuid1,const uuid_t * uuid2)82 static inline int compare_uuids(const uuid_t *uuid1, const uuid_t *uuid2)
83 {
84 return memcmp(uuid1, uuid2, sizeof(uuid_t));
85 }
86
87
is_valid_header(fip_toc_header_t * header)88 static inline int is_valid_header(fip_toc_header_t *header)
89 {
90 if ((header->name == TOC_HEADER_NAME) && (header->serial_number != 0)) {
91 return 1;
92 } else {
93 return 0;
94 }
95 }
96
97
98 /* Identify the device type as a virtual driver */
device_type_fip(void)99 static io_type_t device_type_fip(void)
100 {
101 return IO_TYPE_FIRMWARE_IMAGE_PACKAGE;
102 }
103
104
105 static const io_dev_connector_t fip_dev_connector = {
106 .dev_open = fip_dev_open
107 };
108
109
110 static const io_dev_funcs_t fip_dev_funcs = {
111 .type = device_type_fip,
112 .open = fip_file_open,
113 .seek = NULL,
114 .size = fip_file_len,
115 .read = fip_file_read,
116 .write = NULL,
117 .close = fip_file_close,
118 .dev_init = fip_dev_init,
119 .dev_close = fip_dev_close,
120 };
121
122 /* Locate a file state in the pool, specified by address */
find_first_fip_state(const uintptr_t dev_spec,unsigned int * index_out)123 static int find_first_fip_state(const uintptr_t dev_spec,
124 unsigned int *index_out)
125 {
126 int result = -ENOENT;
127 unsigned int index;
128
129 for (index = 0; index < (unsigned int)MAX_FIP_DEVICES; ++index) {
130 /* dev_spec is used as identifier since it's unique */
131 if (state_pool[index].dev_spec == dev_spec) {
132 result = 0;
133 *index_out = index;
134 break;
135 }
136 }
137 return result;
138 }
139
140
141 /* Allocate a device info from the pool and return a pointer to it */
allocate_dev_info(io_dev_info_t ** dev_info)142 static int allocate_dev_info(io_dev_info_t **dev_info)
143 {
144 int result = -ENOMEM;
145
146 assert(dev_info != NULL);
147
148 if (fip_dev_count < (unsigned int)MAX_FIP_DEVICES) {
149 unsigned int index = 0;
150
151 result = find_first_fip_state(0, &index);
152 assert(result == 0);
153 /* initialize dev_info */
154 dev_info_pool[index].funcs = &fip_dev_funcs;
155 dev_info_pool[index].info =
156 (uintptr_t)&state_pool[index];
157 *dev_info = &dev_info_pool[index];
158 ++fip_dev_count;
159 }
160
161 return result;
162 }
163
164 /* Release a device info to the pool */
free_dev_info(io_dev_info_t * dev_info)165 static int free_dev_info(io_dev_info_t *dev_info)
166 {
167 int result;
168 unsigned int index = 0;
169 fip_dev_state_t *state;
170
171 assert(dev_info != NULL);
172
173 state = (fip_dev_state_t *)dev_info->info;
174 result = find_first_fip_state(state->dev_spec, &index);
175 if (result == 0) {
176 /* free if device info is valid */
177 zeromem(state, sizeof(fip_dev_state_t));
178 --fip_dev_count;
179 }
180
181 return result;
182 }
183
184 /*
185 * Multiple FIP devices can be opened depending on the value of
186 * MAX_FIP_DEVICES. Given that there is only one backend, only a
187 * single file can be open at a time by any FIP device.
188 */
fip_dev_open(const uintptr_t dev_spec,io_dev_info_t ** dev_info)189 static int fip_dev_open(const uintptr_t dev_spec,
190 io_dev_info_t **dev_info)
191 {
192 int result;
193 io_dev_info_t *info;
194 fip_dev_state_t *state;
195
196 assert(dev_info != NULL);
197 #if MAX_FIP_DEVICES > 1
198 assert(dev_spec != (uintptr_t)NULL);
199 #endif
200
201 result = allocate_dev_info(&info);
202 if (result != 0)
203 return -ENOMEM;
204
205 state = (fip_dev_state_t *)info->info;
206
207 state->dev_spec = dev_spec;
208
209 *dev_info = info;
210
211 return 0;
212 }
213
214
215 /* Do some basic package checks. */
fip_dev_init(io_dev_info_t * dev_info,const uintptr_t init_params)216 static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params)
217 {
218 int result;
219 unsigned int image_id = (unsigned int)init_params;
220 uintptr_t backend_handle;
221 fip_toc_header_t header;
222 size_t bytes_read;
223
224 /* Obtain a reference to the image by querying the platform layer */
225 result = plat_get_image_source(image_id, &backend_dev_handle,
226 &backend_image_spec);
227 if (result != 0) {
228 WARN("Failed to obtain reference to image id=%u (%i)\n",
229 image_id, result);
230 result = -ENOENT;
231 goto fip_dev_init_exit;
232 }
233
234 /* Attempt to access the FIP image */
235 result = io_open(backend_dev_handle, backend_image_spec,
236 &backend_handle);
237 if (result != 0) {
238 WARN("Failed to access image id=%u (%i)\n", image_id, result);
239 result = -ENOENT;
240 goto fip_dev_init_exit;
241 }
242
243 result = io_read(backend_handle, (uintptr_t)&header, sizeof(header),
244 &bytes_read);
245 if (result == 0) {
246 if (!is_valid_header(&header)) {
247 WARN("Firmware Image Package header check failed.\n");
248 result = -ENOENT;
249 } else {
250 VERBOSE("FIP header looks OK.\n");
251 }
252 }
253
254 io_close(backend_handle);
255
256 fip_dev_init_exit:
257 return result;
258 }
259
260 /* Close a connection to the FIP device */
fip_dev_close(io_dev_info_t * dev_info)261 static int fip_dev_close(io_dev_info_t *dev_info)
262 {
263 /* TODO: Consider tracking open files and cleaning them up here */
264
265 /* Clear the backend. */
266 backend_dev_handle = (uintptr_t)NULL;
267 backend_image_spec = (uintptr_t)NULL;
268
269 return free_dev_info(dev_info);
270 }
271
272
273 /* Open a file for access from package. */
fip_file_open(io_dev_info_t * dev_info,const uintptr_t spec,io_entity_t * entity)274 static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
275 io_entity_t *entity)
276 {
277 int result;
278 uintptr_t backend_handle;
279 const io_uuid_spec_t *uuid_spec = (io_uuid_spec_t *)spec;
280 size_t bytes_read;
281 int found_file = 0;
282
283 assert(uuid_spec != NULL);
284 assert(entity != NULL);
285
286 /* Can only have one file open at a time for the moment. We need to
287 * track state like file cursor position. We know the header lives at
288 * offset zero, so this entry should never be zero for an active file.
289 * When the system supports dynamic memory allocation we can allow more
290 * than one open file at a time if needed.
291 */
292 if (current_file.entry.offset_address != 0) {
293 WARN("fip_file_open : Only one open file at a time.\n");
294 return -ENOMEM;
295 }
296
297 /* Attempt to access the FIP image */
298 result = io_open(backend_dev_handle, backend_image_spec,
299 &backend_handle);
300 if (result != 0) {
301 WARN("Failed to open Firmware Image Package (%i)\n", result);
302 result = -ENOENT;
303 goto fip_file_open_exit;
304 }
305
306 /* Seek past the FIP header into the Table of Contents */
307 result = io_seek(backend_handle, IO_SEEK_SET,
308 (signed long long)sizeof(fip_toc_header_t));
309 if (result != 0) {
310 WARN("fip_file_open: failed to seek\n");
311 result = -ENOENT;
312 goto fip_file_open_close;
313 }
314
315 found_file = 0;
316 do {
317 result = io_read(backend_handle,
318 (uintptr_t)¤t_file.entry,
319 sizeof(current_file.entry),
320 &bytes_read);
321 if (result == 0) {
322 if (compare_uuids(¤t_file.entry.uuid,
323 &uuid_spec->uuid) == 0) {
324 found_file = 1;
325 break;
326 }
327 } else {
328 WARN("Failed to read FIP (%i)\n", result);
329 goto fip_file_open_close;
330 }
331 } while (compare_uuids(¤t_file.entry.uuid, &uuid_null) != 0);
332
333 if (found_file == 1) {
334 /* All fine. Update entity info with file state and return. Set
335 * the file position to 0. The 'current_file.entry' holds the
336 * base and size of the file.
337 */
338 current_file.file_pos = 0;
339 entity->info = (uintptr_t)¤t_file;
340 } else {
341 /* Did not find the file in the FIP. */
342 current_file.entry.offset_address = 0;
343 result = -ENOENT;
344 }
345
346 fip_file_open_close:
347 io_close(backend_handle);
348
349 fip_file_open_exit:
350 return result;
351 }
352
353
354 /* Return the size of a file in package */
fip_file_len(io_entity_t * entity,size_t * length)355 static int fip_file_len(io_entity_t *entity, size_t *length)
356 {
357 assert(entity != NULL);
358 assert(length != NULL);
359
360 *length = ((file_state_t *)entity->info)->entry.size;
361
362 return 0;
363 }
364
365
366 /* Read data from a file in package */
fip_file_read(io_entity_t * entity,uintptr_t buffer,size_t length,size_t * length_read)367 static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
368 size_t *length_read)
369 {
370 int result;
371 file_state_t *fp;
372 size_t file_offset;
373 size_t bytes_read;
374 uintptr_t backend_handle;
375
376 assert(entity != NULL);
377 assert(length_read != NULL);
378 assert(entity->info != (uintptr_t)NULL);
379
380 /* Open the backend, attempt to access the blob image */
381 result = io_open(backend_dev_handle, backend_image_spec,
382 &backend_handle);
383 if (result != 0) {
384 WARN("Failed to open FIP (%i)\n", result);
385 result = -ENOENT;
386 goto fip_file_read_exit;
387 }
388
389 fp = (file_state_t *)entity->info;
390
391 /* Seek to the position in the FIP where the payload lives */
392 file_offset = fp->entry.offset_address + fp->file_pos;
393 result = io_seek(backend_handle, IO_SEEK_SET,
394 (signed long long)file_offset);
395 if (result != 0) {
396 WARN("fip_file_read: failed to seek\n");
397 result = -ENOENT;
398 goto fip_file_read_close;
399 }
400
401 result = io_read(backend_handle, buffer, length, &bytes_read);
402 if (result != 0) {
403 /* We cannot read our data. Fail. */
404 WARN("Failed to read payload (%i)\n", result);
405 result = -ENOENT;
406 goto fip_file_read_close;
407 } else {
408 /* Set caller length and new file position. */
409 *length_read = bytes_read;
410 fp->file_pos += bytes_read;
411 }
412
413 /* Close the backend. */
414 fip_file_read_close:
415 io_close(backend_handle);
416
417 fip_file_read_exit:
418 return result;
419 }
420
421
422 /* Close a file in package */
fip_file_close(io_entity_t * entity)423 static int fip_file_close(io_entity_t *entity)
424 {
425 /* Clear our current file pointer.
426 * If we had malloc() we would free() here.
427 */
428 if (current_file.entry.offset_address != 0) {
429 zeromem(¤t_file, sizeof(current_file));
430 }
431
432 /* Clear the Entity info. */
433 entity->info = 0;
434
435 return 0;
436 }
437
438 /* Exported functions */
439
440 /* Register the Firmware Image Package driver with the IO abstraction */
register_io_dev_fip(const io_dev_connector_t ** dev_con)441 int register_io_dev_fip(const io_dev_connector_t **dev_con)
442 {
443 int result;
444 assert(dev_con != NULL);
445
446 /*
447 * Since dev_info isn't really used in io_register_device, always
448 * use the same device info at here instead.
449 */
450 result = io_register_device(&dev_info_pool[0]);
451 if (result == 0)
452 *dev_con = &fip_dev_connector;
453
454 return result;
455 }
456