blob: d2914238052cb4268e71e20f2aa922ae4c2da095 [file] [log] [blame]
Harry Liebel561cd332014-02-14 14:42:48 +00001/*
2 * Copyright (c) 2014, ARM Limited and Contributors. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * Redistributions of source code must retain the above copyright notice, this
8 * list of conditions and the following disclaimer.
9 *
10 * Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 *
14 * Neither the name of ARM nor the names of its contributors may be used
15 * to endorse or promote products derived from this software without specific
16 * prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 */
30
Harry Liebel561cd332014-02-14 14:42:48 +000031#include <assert.h>
Dan Handleyed6ff952014-05-14 17:44:19 +010032#include <bl_common.h>
Dan Handley2bd4ef22014-04-09 13:14:54 +010033#include <debug.h>
34#include <errno.h>
Dan Handley714a0d22014-04-09 13:13:04 +010035#include <firmware_image_package.h>
Dan Handley714a0d22014-04-09 13:13:04 +010036#include <io_driver.h>
37#include <io_fip.h>
Dan Handley2bd4ef22014-04-09 13:14:54 +010038#include <io_storage.h>
39#include <platform.h>
Dan Handleyed6ff952014-05-14 17:44:19 +010040#include <platform_def.h>
Dan Handley2bd4ef22014-04-09 13:14:54 +010041#include <stdint.h>
42#include <string.h>
43#include <uuid.h>
Harry Liebel561cd332014-02-14 14:42:48 +000044
45/* Useful for printing UUIDs when debugging.*/
46#define PRINT_UUID2(x) \
47 "%08x-%04hx-%04hx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx", \
48 x.time_low, x.time_mid, x.time_hi_and_version, \
49 x.clock_seq_hi_and_reserved, x.clock_seq_low, \
50 x.node[0], x.node[1], x.node[2], x.node[3], \
51 x.node[4], x.node[5]
52
53typedef struct {
Harry Liebel561cd332014-02-14 14:42:48 +000054 /* Put file_pos above the struct to allow {0} on static init.
55 * It is a workaround for a known bug in GCC
56 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
57 */
58 unsigned int file_pos;
Dan Handleye2712bc2014-04-10 15:37:22 +010059 fip_toc_entry_t entry;
60} file_state_t;
Harry Liebel561cd332014-02-14 14:42:48 +000061
Harry Liebel561cd332014-02-14 14:42:48 +000062static const uuid_t uuid_null = {0};
Dan Handleye2712bc2014-04-10 15:37:22 +010063static file_state_t current_file = {0};
Dan Handleya4cb68e2014-04-23 13:47:06 +010064static uintptr_t backend_dev_handle;
65static uintptr_t backend_image_spec;
Harry Liebel561cd332014-02-14 14:42:48 +000066
67
68/* Firmware Image Package driver functions */
Dan Handleya4cb68e2014-04-23 13:47:06 +010069static int fip_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info);
70static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
Dan Handleye2712bc2014-04-10 15:37:22 +010071 io_entity_t *entity);
72static int fip_file_len(io_entity_t *entity, size_t *length);
Dan Handleya4cb68e2014-04-23 13:47:06 +010073static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
Harry Liebel561cd332014-02-14 14:42:48 +000074 size_t *length_read);
Dan Handleye2712bc2014-04-10 15:37:22 +010075static int fip_file_close(io_entity_t *entity);
Dan Handleya4cb68e2014-04-23 13:47:06 +010076static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params);
Dan Handleye2712bc2014-04-10 15:37:22 +010077static int fip_dev_close(io_dev_info_t *dev_info);
Harry Liebel561cd332014-02-14 14:42:48 +000078
Harry Liebel561cd332014-02-14 14:42:48 +000079
80/* Return 0 for equal uuids. */
81static inline int compare_uuids(const uuid_t *uuid1, const uuid_t *uuid2)
82{
83 return memcmp(uuid1, uuid2, sizeof(uuid_t));
84}
85
86
87/* TODO: We could check version numbers or do a package checksum? */
Dan Handleye2712bc2014-04-10 15:37:22 +010088static inline int is_valid_header(fip_toc_header_t *header)
Harry Liebel561cd332014-02-14 14:42:48 +000089{
90 if ((header->name == TOC_HEADER_NAME) && (header->serial_number != 0)) {
91 return 1;
92 } else {
93 return 0;
94 }
95}
96
97
Harry Liebel561cd332014-02-14 14:42:48 +000098/* Identify the device type as a virtual driver */
Dan Handleye2712bc2014-04-10 15:37:22 +010099io_type_t device_type_fip(void)
Harry Liebel561cd332014-02-14 14:42:48 +0000100{
101 return IO_TYPE_FIRMWARE_IMAGE_PACKAGE;
102}
103
104
Dan Handleya4cb68e2014-04-23 13:47:06 +0100105static const io_dev_connector_t fip_dev_connector = {
Harry Liebel561cd332014-02-14 14:42:48 +0000106 .dev_open = fip_dev_open
107};
108
109
Dan Handleya4cb68e2014-04-23 13:47:06 +0100110static const io_dev_funcs_t fip_dev_funcs = {
Harry Liebel561cd332014-02-14 14:42:48 +0000111 .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
Dan Handleya4cb68e2014-04-23 13:47:06 +0100123/* No state associated with this device so structure can be const */
124static const io_dev_info_t fip_dev_info = {
Harry Liebel561cd332014-02-14 14:42:48 +0000125 .funcs = &fip_dev_funcs,
126 .info = (uintptr_t)NULL
127};
128
129
130/* Open a connection to the FIP device */
Dan Handleya4cb68e2014-04-23 13:47:06 +0100131static int fip_dev_open(const uintptr_t dev_spec __attribute__((unused)),
Dan Handleye2712bc2014-04-10 15:37:22 +0100132 io_dev_info_t **dev_info)
Harry Liebel561cd332014-02-14 14:42:48 +0000133{
134 assert(dev_info != NULL);
Dan Handleya4cb68e2014-04-23 13:47:06 +0100135 *dev_info = (io_dev_info_t *)&fip_dev_info; /* cast away const */
Harry Liebel561cd332014-02-14 14:42:48 +0000136
Juan Castillo6e762062015-11-02 10:47:01 +0000137 return 0;
Harry Liebel561cd332014-02-14 14:42:48 +0000138}
139
140
141/* Do some basic package checks. */
Dan Handleya4cb68e2014-04-23 13:47:06 +0100142static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params)
Harry Liebel561cd332014-02-14 14:42:48 +0000143{
Juan Castillo6e762062015-11-02 10:47:01 +0000144 int result;
Juan Castillo3a66aca2015-04-13 17:36:19 +0100145 unsigned int image_id = (unsigned int)init_params;
Dan Handleya4cb68e2014-04-23 13:47:06 +0100146 uintptr_t backend_handle;
Dan Handleye2712bc2014-04-10 15:37:22 +0100147 fip_toc_header_t header;
Harry Liebel561cd332014-02-14 14:42:48 +0000148 size_t bytes_read;
149
150 /* Obtain a reference to the image by querying the platform layer */
Juan Castillo3a66aca2015-04-13 17:36:19 +0100151 result = plat_get_image_source(image_id, &backend_dev_handle,
Harry Liebel561cd332014-02-14 14:42:48 +0000152 &backend_image_spec);
Juan Castillo6e762062015-11-02 10:47:01 +0000153 if (result != 0) {
Juan Castillo3a66aca2015-04-13 17:36:19 +0100154 WARN("Failed to obtain reference to image id=%u (%i)\n",
155 image_id, result);
Juan Castillo6e762062015-11-02 10:47:01 +0000156 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000157 goto fip_dev_init_exit;
158 }
159
160 /* Attempt to access the FIP image */
161 result = io_open(backend_dev_handle, backend_image_spec,
162 &backend_handle);
Juan Castillo6e762062015-11-02 10:47:01 +0000163 if (result != 0) {
Juan Castillo3a66aca2015-04-13 17:36:19 +0100164 WARN("Failed to access image id=%u (%i)\n", image_id, result);
Juan Castillo6e762062015-11-02 10:47:01 +0000165 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000166 goto fip_dev_init_exit;
167 }
168
Dan Handleya4cb68e2014-04-23 13:47:06 +0100169 result = io_read(backend_handle, (uintptr_t)&header, sizeof(header),
170 &bytes_read);
Juan Castillo6e762062015-11-02 10:47:01 +0000171 if (result == 0) {
Harry Liebel561cd332014-02-14 14:42:48 +0000172 if (!is_valid_header(&header)) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000173 WARN("Firmware Image Package header check failed.\n");
Juan Castillo6e762062015-11-02 10:47:01 +0000174 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000175 } else {
Dan Handley91b624e2014-07-29 17:14:00 +0100176 VERBOSE("FIP header looks OK.\n");
Harry Liebel561cd332014-02-14 14:42:48 +0000177 }
178 }
179
180 io_close(backend_handle);
181
182 fip_dev_init_exit:
183 return result;
184}
185
186/* Close a connection to the FIP device */
Dan Handleye2712bc2014-04-10 15:37:22 +0100187static int fip_dev_close(io_dev_info_t *dev_info)
Harry Liebel561cd332014-02-14 14:42:48 +0000188{
189 /* TODO: Consider tracking open files and cleaning them up here */
190
191 /* Clear the backend. */
Dan Handleya4cb68e2014-04-23 13:47:06 +0100192 backend_dev_handle = (uintptr_t)NULL;
193 backend_image_spec = (uintptr_t)NULL;
Harry Liebel561cd332014-02-14 14:42:48 +0000194
Juan Castillo6e762062015-11-02 10:47:01 +0000195 return 0;
Harry Liebel561cd332014-02-14 14:42:48 +0000196}
197
198
199/* Open a file for access from package. */
Dan Handleya4cb68e2014-04-23 13:47:06 +0100200static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
Dan Handleye2712bc2014-04-10 15:37:22 +0100201 io_entity_t *entity)
Harry Liebel561cd332014-02-14 14:42:48 +0000202{
Juan Castillo6e762062015-11-02 10:47:01 +0000203 int result;
Dan Handleya4cb68e2014-04-23 13:47:06 +0100204 uintptr_t backend_handle;
Juan Castillo3a66aca2015-04-13 17:36:19 +0100205 const io_uuid_spec_t *uuid_spec = (io_uuid_spec_t *)spec;
Harry Liebel561cd332014-02-14 14:42:48 +0000206 size_t bytes_read;
207 int found_file = 0;
208
Juan Castillo3a66aca2015-04-13 17:36:19 +0100209 assert(uuid_spec != NULL);
Harry Liebel561cd332014-02-14 14:42:48 +0000210 assert(entity != NULL);
211
212 /* Can only have one file open at a time for the moment. We need to
213 * track state like file cursor position. We know the header lives at
214 * offset zero, so this entry should never be zero for an active file.
215 * When the system supports dynamic memory allocation we can allow more
216 * than one open file at a time if needed.
217 */
218 if (current_file.entry.offset_address != 0) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000219 WARN("fip_file_open : Only one open file at a time.\n");
Juan Castillo6e762062015-11-02 10:47:01 +0000220 return -ENOMEM;
Harry Liebel561cd332014-02-14 14:42:48 +0000221 }
222
223 /* Attempt to access the FIP image */
224 result = io_open(backend_dev_handle, backend_image_spec,
225 &backend_handle);
Juan Castillo6e762062015-11-02 10:47:01 +0000226 if (result != 0) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000227 WARN("Failed to open Firmware Image Package (%i)\n", result);
Juan Castillo6e762062015-11-02 10:47:01 +0000228 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000229 goto fip_file_open_exit;
230 }
231
232 /* Seek past the FIP header into the Table of Contents */
Dan Handleye2712bc2014-04-10 15:37:22 +0100233 result = io_seek(backend_handle, IO_SEEK_SET, sizeof(fip_toc_header_t));
Juan Castillo6e762062015-11-02 10:47:01 +0000234 if (result != 0) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000235 WARN("fip_file_open: failed to seek\n");
Juan Castillo6e762062015-11-02 10:47:01 +0000236 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000237 goto fip_file_open_close;
238 }
239
Harry Liebel561cd332014-02-14 14:42:48 +0000240 found_file = 0;
241 do {
Dan Handleya4cb68e2014-04-23 13:47:06 +0100242 result = io_read(backend_handle,
243 (uintptr_t)&current_file.entry,
Harry Liebel561cd332014-02-14 14:42:48 +0000244 sizeof(current_file.entry),
245 &bytes_read);
Juan Castillo6e762062015-11-02 10:47:01 +0000246 if (result == 0) {
Harry Liebel561cd332014-02-14 14:42:48 +0000247 if (compare_uuids(&current_file.entry.uuid,
Juan Castillo3a66aca2015-04-13 17:36:19 +0100248 &uuid_spec->uuid) == 0) {
Harry Liebel561cd332014-02-14 14:42:48 +0000249 found_file = 1;
250 break;
251 }
252 } else {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000253 WARN("Failed to read FIP (%i)\n", result);
Harry Liebel561cd332014-02-14 14:42:48 +0000254 goto fip_file_open_close;
255 }
256 } while (compare_uuids(&current_file.entry.uuid, &uuid_null) != 0);
257
258 if (found_file == 1) {
259 /* All fine. Update entity info with file state and return. Set
260 * the file position to 0. The 'current_file.entry' holds the
261 * base and size of the file.
262 */
263 current_file.file_pos = 0;
264 entity->info = (uintptr_t)&current_file;
265 } else {
266 /* Did not find the file in the FIP. */
Jeenu Viswambharandd3dc322014-02-20 11:51:00 +0000267 current_file.entry.offset_address = 0;
Juan Castillo6e762062015-11-02 10:47:01 +0000268 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000269 }
270
271 fip_file_open_close:
272 io_close(backend_handle);
273
274 fip_file_open_exit:
275 return result;
276}
277
278
279/* Return the size of a file in package */
Dan Handleye2712bc2014-04-10 15:37:22 +0100280static int fip_file_len(io_entity_t *entity, size_t *length)
Harry Liebel561cd332014-02-14 14:42:48 +0000281{
282 assert(entity != NULL);
283 assert(length != NULL);
284
Dan Handleye2712bc2014-04-10 15:37:22 +0100285 *length = ((file_state_t *)entity->info)->entry.size;
Harry Liebel561cd332014-02-14 14:42:48 +0000286
Juan Castillo6e762062015-11-02 10:47:01 +0000287 return 0;
Harry Liebel561cd332014-02-14 14:42:48 +0000288}
289
290
291/* Read data from a file in package */
Dan Handleya4cb68e2014-04-23 13:47:06 +0100292static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
Harry Liebel561cd332014-02-14 14:42:48 +0000293 size_t *length_read)
294{
Juan Castillo6e762062015-11-02 10:47:01 +0000295 int result;
Dan Handleye2712bc2014-04-10 15:37:22 +0100296 file_state_t *fp;
Harry Liebel561cd332014-02-14 14:42:48 +0000297 size_t file_offset;
298 size_t bytes_read;
Dan Handleya4cb68e2014-04-23 13:47:06 +0100299 uintptr_t backend_handle;
Harry Liebel561cd332014-02-14 14:42:48 +0000300
301 assert(entity != NULL);
Dan Handleya4cb68e2014-04-23 13:47:06 +0100302 assert(buffer != (uintptr_t)NULL);
Harry Liebel561cd332014-02-14 14:42:48 +0000303 assert(length_read != NULL);
Dan Handleya4cb68e2014-04-23 13:47:06 +0100304 assert(entity->info != (uintptr_t)NULL);
Harry Liebel561cd332014-02-14 14:42:48 +0000305
306 /* Open the backend, attempt to access the blob image */
307 result = io_open(backend_dev_handle, backend_image_spec,
308 &backend_handle);
Juan Castillo6e762062015-11-02 10:47:01 +0000309 if (result != 0) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000310 WARN("Failed to open FIP (%i)\n", result);
Juan Castillo6e762062015-11-02 10:47:01 +0000311 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000312 goto fip_file_read_exit;
313 }
314
Dan Handleye2712bc2014-04-10 15:37:22 +0100315 fp = (file_state_t *)entity->info;
Harry Liebel561cd332014-02-14 14:42:48 +0000316
317 /* Seek to the position in the FIP where the payload lives */
318 file_offset = fp->entry.offset_address + fp->file_pos;
319 result = io_seek(backend_handle, IO_SEEK_SET, file_offset);
Juan Castillo6e762062015-11-02 10:47:01 +0000320 if (result != 0) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000321 WARN("fip_file_read: failed to seek\n");
Juan Castillo6e762062015-11-02 10:47:01 +0000322 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000323 goto fip_file_read_close;
324 }
325
326 result = io_read(backend_handle, buffer, length, &bytes_read);
Juan Castillo6e762062015-11-02 10:47:01 +0000327 if (result != 0) {
Harry Liebel561cd332014-02-14 14:42:48 +0000328 /* We cannot read our data. Fail. */
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000329 WARN("Failed to read payload (%i)\n", result);
Juan Castillo6e762062015-11-02 10:47:01 +0000330 result = -ENOENT;
Harry Liebel561cd332014-02-14 14:42:48 +0000331 goto fip_file_read_close;
332 } else {
333 /* Set caller length and new file position. */
334 *length_read = bytes_read;
335 fp->file_pos += bytes_read;
336 }
337
338/* Close the backend. */
339 fip_file_read_close:
340 io_close(backend_handle);
341
342 fip_file_read_exit:
343 return result;
344}
345
346
347/* Close a file in package */
Dan Handleye2712bc2014-04-10 15:37:22 +0100348static int fip_file_close(io_entity_t *entity)
Harry Liebel561cd332014-02-14 14:42:48 +0000349{
350 /* Clear our current file pointer.
351 * If we had malloc() we would free() here.
352 */
353 if (current_file.entry.offset_address != 0) {
354 memset(&current_file, 0, sizeof(current_file));
355 }
356
357 /* Clear the Entity info. */
358 entity->info = 0;
359
Juan Castillo6e762062015-11-02 10:47:01 +0000360 return 0;
Harry Liebel561cd332014-02-14 14:42:48 +0000361}
362
363/* Exported functions */
364
365/* Register the Firmware Image Package driver with the IO abstraction */
Dan Handleya4cb68e2014-04-23 13:47:06 +0100366int register_io_dev_fip(const io_dev_connector_t **dev_con)
Harry Liebel561cd332014-02-14 14:42:48 +0000367{
Juan Castillo6e762062015-11-02 10:47:01 +0000368 int result;
Harry Liebel561cd332014-02-14 14:42:48 +0000369 assert(dev_con != NULL);
370
371 result = io_register_device(&fip_dev_info);
Juan Castillo6e762062015-11-02 10:47:01 +0000372 if (result == 0)
Harry Liebel561cd332014-02-14 14:42:48 +0000373 *dev_con = &fip_dev_connector;
374
375 return result;
376}