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