1 /*
2 * Copyright (c) 2014-2017, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <bl_common.h>
9 #include <debug.h>
10 #include <errno.h>
11 #include <firmware_image_package.h>
12 #include <io_driver.h>
13 #include <io_fip.h>
14 #include <io_storage.h>
15 #include <platform.h>
16 #include <platform_def.h>
17 #include <stdint.h>
18 #include <string.h>
19 #include <utils.h>
20 #include <uuid.h>
21
22 /* Useful for printing UUIDs when debugging.*/
23 #define PRINT_UUID2(x) \
24 "%08x-%04hx-%04hx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx", \
25 x.time_low, x.time_mid, x.time_hi_and_version, \
26 x.clock_seq_hi_and_reserved, x.clock_seq_low, \
27 x.node[0], x.node[1], x.node[2], x.node[3], \
28 x.node[4], x.node[5]
29
30 typedef struct {
31 /* Put file_pos above the struct to allow {0} on static init.
32 * It is a workaround for a known bug in GCC
33 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
34 */
35 unsigned int file_pos;
36 fip_toc_entry_t entry;
37 } file_state_t;
38
39 static const uuid_t uuid_null = {0};
40 static file_state_t current_file = {0};
41 static uintptr_t backend_dev_handle;
42 static uintptr_t backend_image_spec;
43
44
45 /* Firmware Image Package driver functions */
46 static int fip_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info);
47 static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
48 io_entity_t *entity);
49 static int fip_file_len(io_entity_t *entity, size_t *length);
50 static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
51 size_t *length_read);
52 static int fip_file_close(io_entity_t *entity);
53 static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params);
54 static int fip_dev_close(io_dev_info_t *dev_info);
55
56
57 /* Return 0 for equal uuids. */
compare_uuids(const uuid_t * uuid1,const uuid_t * uuid2)58 static inline int compare_uuids(const uuid_t *uuid1, const uuid_t *uuid2)
59 {
60 return memcmp(uuid1, uuid2, sizeof(uuid_t));
61 }
62
63
64 /* TODO: We could check version numbers or do a package checksum? */
is_valid_header(fip_toc_header_t * header)65 static inline int is_valid_header(fip_toc_header_t *header)
66 {
67 if ((header->name == TOC_HEADER_NAME) && (header->serial_number != 0)) {
68 return 1;
69 } else {
70 return 0;
71 }
72 }
73
74
75 /* Identify the device type as a virtual driver */
device_type_fip(void)76 io_type_t device_type_fip(void)
77 {
78 return IO_TYPE_FIRMWARE_IMAGE_PACKAGE;
79 }
80
81
82 static const io_dev_connector_t fip_dev_connector = {
83 .dev_open = fip_dev_open
84 };
85
86
87 static const io_dev_funcs_t fip_dev_funcs = {
88 .type = device_type_fip,
89 .open = fip_file_open,
90 .seek = NULL,
91 .size = fip_file_len,
92 .read = fip_file_read,
93 .write = NULL,
94 .close = fip_file_close,
95 .dev_init = fip_dev_init,
96 .dev_close = fip_dev_close,
97 };
98
99
100 /* No state associated with this device so structure can be const */
101 static const io_dev_info_t fip_dev_info = {
102 .funcs = &fip_dev_funcs,
103 .info = (uintptr_t)NULL
104 };
105
106
107 /* Open a connection to the FIP device */
fip_dev_open(const uintptr_t dev_spec __unused,io_dev_info_t ** dev_info)108 static int fip_dev_open(const uintptr_t dev_spec __unused,
109 io_dev_info_t **dev_info)
110 {
111 assert(dev_info != NULL);
112 *dev_info = (io_dev_info_t *)&fip_dev_info; /* cast away const */
113
114 return 0;
115 }
116
117
118 /* Do some basic package checks. */
fip_dev_init(io_dev_info_t * dev_info,const uintptr_t init_params)119 static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params)
120 {
121 int result;
122 unsigned int image_id = (unsigned int)init_params;
123 uintptr_t backend_handle;
124 fip_toc_header_t header;
125 size_t bytes_read;
126
127 /* Obtain a reference to the image by querying the platform layer */
128 result = plat_get_image_source(image_id, &backend_dev_handle,
129 &backend_image_spec);
130 if (result != 0) {
131 WARN("Failed to obtain reference to image id=%u (%i)\n",
132 image_id, result);
133 result = -ENOENT;
134 goto fip_dev_init_exit;
135 }
136
137 /* Attempt to access the FIP image */
138 result = io_open(backend_dev_handle, backend_image_spec,
139 &backend_handle);
140 if (result != 0) {
141 WARN("Failed to access image id=%u (%i)\n", image_id, result);
142 result = -ENOENT;
143 goto fip_dev_init_exit;
144 }
145
146 result = io_read(backend_handle, (uintptr_t)&header, sizeof(header),
147 &bytes_read);
148 if (result == 0) {
149 if (!is_valid_header(&header)) {
150 WARN("Firmware Image Package header check failed.\n");
151 result = -ENOENT;
152 } else {
153 VERBOSE("FIP header looks OK.\n");
154 }
155 }
156
157 io_close(backend_handle);
158
159 fip_dev_init_exit:
160 return result;
161 }
162
163 /* Close a connection to the FIP device */
fip_dev_close(io_dev_info_t * dev_info)164 static int fip_dev_close(io_dev_info_t *dev_info)
165 {
166 /* TODO: Consider tracking open files and cleaning them up here */
167
168 /* Clear the backend. */
169 backend_dev_handle = (uintptr_t)NULL;
170 backend_image_spec = (uintptr_t)NULL;
171
172 return 0;
173 }
174
175
176 /* Open a file for access from package. */
fip_file_open(io_dev_info_t * dev_info,const uintptr_t spec,io_entity_t * entity)177 static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
178 io_entity_t *entity)
179 {
180 int result;
181 uintptr_t backend_handle;
182 const io_uuid_spec_t *uuid_spec = (io_uuid_spec_t *)spec;
183 size_t bytes_read;
184 int found_file = 0;
185
186 assert(uuid_spec != NULL);
187 assert(entity != NULL);
188
189 /* Can only have one file open at a time for the moment. We need to
190 * track state like file cursor position. We know the header lives at
191 * offset zero, so this entry should never be zero for an active file.
192 * When the system supports dynamic memory allocation we can allow more
193 * than one open file at a time if needed.
194 */
195 if (current_file.entry.offset_address != 0) {
196 WARN("fip_file_open : Only one open file at a time.\n");
197 return -ENOMEM;
198 }
199
200 /* Attempt to access the FIP image */
201 result = io_open(backend_dev_handle, backend_image_spec,
202 &backend_handle);
203 if (result != 0) {
204 WARN("Failed to open Firmware Image Package (%i)\n", result);
205 result = -ENOENT;
206 goto fip_file_open_exit;
207 }
208
209 /* Seek past the FIP header into the Table of Contents */
210 result = io_seek(backend_handle, IO_SEEK_SET, sizeof(fip_toc_header_t));
211 if (result != 0) {
212 WARN("fip_file_open: failed to seek\n");
213 result = -ENOENT;
214 goto fip_file_open_close;
215 }
216
217 found_file = 0;
218 do {
219 result = io_read(backend_handle,
220 (uintptr_t)¤t_file.entry,
221 sizeof(current_file.entry),
222 &bytes_read);
223 if (result == 0) {
224 if (compare_uuids(¤t_file.entry.uuid,
225 &uuid_spec->uuid) == 0) {
226 found_file = 1;
227 break;
228 }
229 } else {
230 WARN("Failed to read FIP (%i)\n", result);
231 goto fip_file_open_close;
232 }
233 } while (compare_uuids(¤t_file.entry.uuid, &uuid_null) != 0);
234
235 if (found_file == 1) {
236 /* All fine. Update entity info with file state and return. Set
237 * the file position to 0. The 'current_file.entry' holds the
238 * base and size of the file.
239 */
240 current_file.file_pos = 0;
241 entity->info = (uintptr_t)¤t_file;
242 } else {
243 /* Did not find the file in the FIP. */
244 current_file.entry.offset_address = 0;
245 result = -ENOENT;
246 }
247
248 fip_file_open_close:
249 io_close(backend_handle);
250
251 fip_file_open_exit:
252 return result;
253 }
254
255
256 /* Return the size of a file in package */
fip_file_len(io_entity_t * entity,size_t * length)257 static int fip_file_len(io_entity_t *entity, size_t *length)
258 {
259 assert(entity != NULL);
260 assert(length != NULL);
261
262 *length = ((file_state_t *)entity->info)->entry.size;
263
264 return 0;
265 }
266
267
268 /* Read data from a file in package */
fip_file_read(io_entity_t * entity,uintptr_t buffer,size_t length,size_t * length_read)269 static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
270 size_t *length_read)
271 {
272 int result;
273 file_state_t *fp;
274 size_t file_offset;
275 size_t bytes_read;
276 uintptr_t backend_handle;
277
278 assert(entity != NULL);
279 assert(buffer != (uintptr_t)NULL);
280 assert(length_read != NULL);
281 assert(entity->info != (uintptr_t)NULL);
282
283 /* Open the backend, attempt to access the blob image */
284 result = io_open(backend_dev_handle, backend_image_spec,
285 &backend_handle);
286 if (result != 0) {
287 WARN("Failed to open FIP (%i)\n", result);
288 result = -ENOENT;
289 goto fip_file_read_exit;
290 }
291
292 fp = (file_state_t *)entity->info;
293
294 /* Seek to the position in the FIP where the payload lives */
295 file_offset = fp->entry.offset_address + fp->file_pos;
296 result = io_seek(backend_handle, IO_SEEK_SET, file_offset);
297 if (result != 0) {
298 WARN("fip_file_read: failed to seek\n");
299 result = -ENOENT;
300 goto fip_file_read_close;
301 }
302
303 result = io_read(backend_handle, buffer, length, &bytes_read);
304 if (result != 0) {
305 /* We cannot read our data. Fail. */
306 WARN("Failed to read payload (%i)\n", result);
307 result = -ENOENT;
308 goto fip_file_read_close;
309 } else {
310 /* Set caller length and new file position. */
311 *length_read = bytes_read;
312 fp->file_pos += bytes_read;
313 }
314
315 /* Close the backend. */
316 fip_file_read_close:
317 io_close(backend_handle);
318
319 fip_file_read_exit:
320 return result;
321 }
322
323
324 /* Close a file in package */
fip_file_close(io_entity_t * entity)325 static int fip_file_close(io_entity_t *entity)
326 {
327 /* Clear our current file pointer.
328 * If we had malloc() we would free() here.
329 */
330 if (current_file.entry.offset_address != 0) {
331 zeromem(¤t_file, sizeof(current_file));
332 }
333
334 /* Clear the Entity info. */
335 entity->info = 0;
336
337 return 0;
338 }
339
340 /* Exported functions */
341
342 /* Register the Firmware Image Package driver with the IO abstraction */
register_io_dev_fip(const io_dev_connector_t ** dev_con)343 int register_io_dev_fip(const io_dev_connector_t **dev_con)
344 {
345 int result;
346 assert(dev_con != NULL);
347
348 result = io_register_device(&fip_dev_info);
349 if (result == 0)
350 *dev_con = &fip_dev_connector;
351
352 return result;
353 }
354