1 /* 2 * Copyright (c) 2014-2018, 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 = { {0} }; 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. */ 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 static 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 /* Locate a file state in the pool, specified by address */ 124 static int find_first_fip_state(const uintptr_t dev_spec, 125 unsigned int *index_out) 126 { 127 int result = -ENOENT; 128 unsigned int index; 129 130 for (index = 0; index < (unsigned int)MAX_FIP_DEVICES; ++index) { 131 /* dev_spec is used as identifier since it's unique */ 132 if (state_pool[index].dev_spec == dev_spec) { 133 result = 0; 134 *index_out = index; 135 break; 136 } 137 } 138 return result; 139 } 140 141 142 /* Allocate a device info from the pool and return a pointer to it */ 143 static int allocate_dev_info(io_dev_info_t **dev_info) 144 { 145 int result = -ENOMEM; 146 147 assert(dev_info != NULL); 148 149 if (fip_dev_count < (unsigned int)MAX_FIP_DEVICES) { 150 unsigned int index = 0; 151 152 result = find_first_fip_state(0, &index); 153 assert(result == 0); 154 /* initialize dev_info */ 155 dev_info_pool[index].funcs = &fip_dev_funcs; 156 dev_info_pool[index].info = 157 (uintptr_t)&state_pool[index]; 158 *dev_info = &dev_info_pool[index]; 159 ++fip_dev_count; 160 } 161 162 return result; 163 } 164 165 /* Release a device info to the pool */ 166 static int free_dev_info(io_dev_info_t *dev_info) 167 { 168 int result; 169 unsigned int index = 0; 170 fip_dev_state_t *state; 171 172 assert(dev_info != NULL); 173 174 state = (fip_dev_state_t *)dev_info->info; 175 result = find_first_fip_state(state->dev_spec, &index); 176 if (result == 0) { 177 /* free if device info is valid */ 178 zeromem(state, sizeof(fip_dev_state_t)); 179 --fip_dev_count; 180 } 181 182 return result; 183 } 184 185 /* 186 * Multiple FIP devices can be opened depending on the value of 187 * MAX_FIP_DEVICES. Given that there is only one backend, only a 188 * single file can be open at a time by any FIP device. 189 */ 190 static int fip_dev_open(const uintptr_t dev_spec, 191 io_dev_info_t **dev_info) 192 { 193 int result; 194 io_dev_info_t *info; 195 fip_dev_state_t *state; 196 197 assert(dev_info != NULL); 198 #if MAX_FIP_DEVICES > 1 199 assert(dev_spec != (uintptr_t)NULL); 200 #endif 201 202 result = allocate_dev_info(&info); 203 if (result != 0) 204 return -ENOMEM; 205 206 state = (fip_dev_state_t *)info->info; 207 208 state->dev_spec = dev_spec; 209 210 *dev_info = info; 211 212 return 0; 213 } 214 215 216 /* Do some basic package checks. */ 217 static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params) 218 { 219 int result; 220 unsigned int image_id = (unsigned int)init_params; 221 uintptr_t backend_handle; 222 fip_toc_header_t header; 223 size_t bytes_read; 224 225 /* Obtain a reference to the image by querying the platform layer */ 226 result = plat_get_image_source(image_id, &backend_dev_handle, 227 &backend_image_spec); 228 if (result != 0) { 229 WARN("Failed to obtain reference to image id=%u (%i)\n", 230 image_id, result); 231 result = -ENOENT; 232 goto fip_dev_init_exit; 233 } 234 235 /* Attempt to access the FIP image */ 236 result = io_open(backend_dev_handle, backend_image_spec, 237 &backend_handle); 238 if (result != 0) { 239 WARN("Failed to access image id=%u (%i)\n", image_id, result); 240 result = -ENOENT; 241 goto fip_dev_init_exit; 242 } 243 244 result = io_read(backend_handle, (uintptr_t)&header, sizeof(header), 245 &bytes_read); 246 if (result == 0) { 247 if (!is_valid_header(&header)) { 248 WARN("Firmware Image Package header check failed.\n"); 249 result = -ENOENT; 250 } else { 251 VERBOSE("FIP header looks OK.\n"); 252 } 253 } 254 255 io_close(backend_handle); 256 257 fip_dev_init_exit: 258 return result; 259 } 260 261 /* Close a connection to the FIP device */ 262 static int fip_dev_close(io_dev_info_t *dev_info) 263 { 264 /* TODO: Consider tracking open files and cleaning them up here */ 265 266 /* Clear the backend. */ 267 backend_dev_handle = (uintptr_t)NULL; 268 backend_image_spec = (uintptr_t)NULL; 269 270 return free_dev_info(dev_info); 271 } 272 273 274 /* Open a file for access from package. */ 275 static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec, 276 io_entity_t *entity) 277 { 278 int result; 279 uintptr_t backend_handle; 280 const io_uuid_spec_t *uuid_spec = (io_uuid_spec_t *)spec; 281 size_t bytes_read; 282 int found_file = 0; 283 284 assert(uuid_spec != NULL); 285 assert(entity != NULL); 286 287 /* Can only have one file open at a time for the moment. We need to 288 * track state like file cursor position. We know the header lives at 289 * offset zero, so this entry should never be zero for an active file. 290 * When the system supports dynamic memory allocation we can allow more 291 * than one open file at a time if needed. 292 */ 293 if (current_file.entry.offset_address != 0) { 294 WARN("fip_file_open : Only one open file at a time.\n"); 295 return -ENOMEM; 296 } 297 298 /* Attempt to access the FIP image */ 299 result = io_open(backend_dev_handle, backend_image_spec, 300 &backend_handle); 301 if (result != 0) { 302 WARN("Failed to open Firmware Image Package (%i)\n", result); 303 result = -ENOENT; 304 goto fip_file_open_exit; 305 } 306 307 /* Seek past the FIP header into the Table of Contents */ 308 result = io_seek(backend_handle, IO_SEEK_SET, 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 */ 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 */ 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, file_offset); 394 if (result != 0) { 395 WARN("fip_file_read: failed to seek\n"); 396 result = -ENOENT; 397 goto fip_file_read_close; 398 } 399 400 result = io_read(backend_handle, buffer, length, &bytes_read); 401 if (result != 0) { 402 /* We cannot read our data. Fail. */ 403 WARN("Failed to read payload (%i)\n", result); 404 result = -ENOENT; 405 goto fip_file_read_close; 406 } else { 407 /* Set caller length and new file position. */ 408 *length_read = bytes_read; 409 fp->file_pos += bytes_read; 410 } 411 412 /* Close the backend. */ 413 fip_file_read_close: 414 io_close(backend_handle); 415 416 fip_file_read_exit: 417 return result; 418 } 419 420 421 /* Close a file in package */ 422 static int fip_file_close(io_entity_t *entity) 423 { 424 /* Clear our current file pointer. 425 * If we had malloc() we would free() here. 426 */ 427 if (current_file.entry.offset_address != 0) { 428 zeromem(¤t_file, sizeof(current_file)); 429 } 430 431 /* Clear the Entity info. */ 432 entity->info = 0; 433 434 return 0; 435 } 436 437 /* Exported functions */ 438 439 /* Register the Firmware Image Package driver with the IO abstraction */ 440 int register_io_dev_fip(const io_dev_connector_t **dev_con) 441 { 442 int result; 443 assert(dev_con != NULL); 444 445 /* 446 * Since dev_info isn't really used in io_register_device, always 447 * use the same device info at here instead. 448 */ 449 result = io_register_device(&dev_info_pool[0]); 450 if (result == 0) 451 *dev_con = &fip_dev_connector; 452 453 return result; 454 } 455