1 /* 2 * Copyright (c) 2015-2021, ARM Limited. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <common/debug.h> 8 #include <drivers/fwu/fwu_metadata.h> 9 #include <drivers/io/io_driver.h> 10 #include <drivers/io/io_fip.h> 11 #include <drivers/io/io_memmap.h> 12 #include <drivers/io/io_storage.h> 13 #include <drivers/partition/partition.h> 14 #include <lib/utils.h> 15 16 #include <plat/arm/common/arm_fconf_getter.h> 17 #include <plat/arm/common/arm_fconf_io_storage.h> 18 #include <plat/arm/common/plat_arm.h> 19 #include <plat/common/platform.h> 20 #include <platform_def.h> 21 22 /* IO devices */ 23 static const io_dev_connector_t *fip_dev_con; 24 uintptr_t fip_dev_handle; 25 static const io_dev_connector_t *memmap_dev_con; 26 uintptr_t memmap_dev_handle; 27 28 #if ARM_GPT_SUPPORT 29 /* fip partition names */ 30 static const char * const fip_part_names[] = {"FIP_A", "FIP_B"}; 31 CASSERT(sizeof(fip_part_names)/sizeof(char *) == NR_OF_FW_BANKS, 32 assert_fip_partition_names_missing); 33 #endif /* ARM_GPT_SUPPORT */ 34 35 /* Weak definitions may be overridden in specific ARM standard platform */ 36 #pragma weak plat_arm_io_setup 37 #pragma weak plat_arm_get_alt_image_source 38 39 int open_fip(const uintptr_t spec) 40 { 41 int result; 42 uintptr_t local_image_handle; 43 44 /* See if a Firmware Image Package is available */ 45 result = io_dev_init(fip_dev_handle, (uintptr_t)FIP_IMAGE_ID); 46 if (result == 0) { 47 result = io_open(fip_dev_handle, spec, &local_image_handle); 48 if (result == 0) { 49 VERBOSE("Using FIP\n"); 50 io_close(local_image_handle); 51 } 52 } 53 return result; 54 } 55 56 int open_memmap(const uintptr_t spec) 57 { 58 int result; 59 uintptr_t local_image_handle; 60 61 result = io_dev_init(memmap_dev_handle, (uintptr_t)NULL); 62 if (result == 0) { 63 result = io_open(memmap_dev_handle, spec, &local_image_handle); 64 if (result == 0) { 65 VERBOSE("Using Memmap\n"); 66 io_close(local_image_handle); 67 } 68 } 69 return result; 70 } 71 72 int arm_io_setup(void) 73 { 74 int io_result; 75 76 io_result = register_io_dev_fip(&fip_dev_con); 77 if (io_result < 0) { 78 return io_result; 79 } 80 81 io_result = register_io_dev_memmap(&memmap_dev_con); 82 if (io_result < 0) { 83 return io_result; 84 } 85 86 /* Open connections to devices and cache the handles */ 87 io_result = io_dev_open(fip_dev_con, (uintptr_t)NULL, 88 &fip_dev_handle); 89 if (io_result < 0) { 90 return io_result; 91 } 92 93 io_result = io_dev_open(memmap_dev_con, (uintptr_t)NULL, 94 &memmap_dev_handle); 95 96 return io_result; 97 } 98 99 void plat_arm_io_setup(void) 100 { 101 int err; 102 103 err = arm_io_setup(); 104 if (err < 0) { 105 panic(); 106 } 107 } 108 109 int plat_arm_get_alt_image_source( 110 unsigned int image_id __unused, 111 uintptr_t *dev_handle __unused, 112 uintptr_t *image_spec __unused) 113 { 114 /* By default do not try an alternative */ 115 return -ENOENT; 116 } 117 118 /* Return an IO device handle and specification which can be used to access 119 * an image. Use this to enforce platform load policy */ 120 int plat_get_image_source(unsigned int image_id, uintptr_t *dev_handle, 121 uintptr_t *image_spec) 122 { 123 int result; 124 const struct plat_io_policy *policy; 125 126 policy = FCONF_GET_PROPERTY(arm, io_policies, image_id); 127 assert(policy->check != NULL); 128 result = policy->check(policy->image_spec); 129 if (result == 0) { 130 *image_spec = policy->image_spec; 131 *dev_handle = *(policy->dev_handle); 132 } else { 133 VERBOSE("Trying alternative IO\n"); 134 result = plat_arm_get_alt_image_source(image_id, dev_handle, 135 image_spec); 136 } 137 138 return result; 139 } 140 141 /* 142 * See if a Firmware Image Package is available, 143 * by checking if TOC is valid or not. 144 */ 145 bool arm_io_is_toc_valid(void) 146 { 147 return (io_dev_init(fip_dev_handle, (uintptr_t)FIP_IMAGE_ID) == 0); 148 } 149 150 #if ARM_GPT_SUPPORT 151 /****************************************************************************** 152 * Retrieve partition entry details such as offset and length, and set these 153 * details in the I/O policy of the requested image. 154 * 155 * @image_id: image id whose I/O policy to be updated 156 * 157 * @part_name: partition name whose details to be retrieved 158 * 159 * Returns 0 on success, error otherwise 160 * Alongside, returns device handle and image specification of requested 161 * image. 162 ******************************************************************************/ 163 int arm_set_image_source(unsigned int image_id, const char *part_name, 164 uintptr_t *dev_handle, uintptr_t *image_spec) 165 { 166 const partition_entry_t *entry = get_partition_entry(part_name); 167 168 if (entry == NULL) { 169 ERROR("Unable to find the %s partition\n", part_name); 170 return -ENOENT; 171 } 172 173 struct plat_io_policy *policy = FCONF_GET_PROPERTY(arm, 174 io_policies, 175 image_id); 176 177 assert(policy != NULL); 178 assert(policy->image_spec != 0UL); 179 180 io_block_spec_t *spec = (io_block_spec_t *)policy->image_spec; 181 /* set offset and length of the image */ 182 spec->offset = PLAT_ARM_FLASH_IMAGE_BASE + entry->start; 183 spec->length = entry->length; 184 185 *dev_handle = *(policy->dev_handle); 186 *image_spec = policy->image_spec; 187 188 return 0; 189 } 190 191 /******************************************************************************* 192 * Set the source offset and length of the FIP image in its I/O policy. 193 * 194 * @active_fw_bank_idx: active firmware bank index gathered from FWU metadata. 195 ******************************************************************************/ 196 void arm_set_fip_addr(uint32_t active_fw_bank_idx) 197 { 198 uintptr_t dev_handle __unused; 199 uintptr_t image_spec __unused; 200 201 assert(active_fw_bank_idx < NR_OF_FW_BANKS); 202 203 INFO("Booting with partition %s\n", fip_part_names[active_fw_bank_idx]); 204 205 int result = arm_set_image_source(FIP_IMAGE_ID, 206 fip_part_names[active_fw_bank_idx], 207 &dev_handle, 208 &image_spec); 209 if (result != 0) { 210 panic(); 211 } 212 } 213 #endif /* ARM_GPT_SUPPORT */ 214 215 #if PSA_FWU_SUPPORT 216 /******************************************************************************* 217 * Read the FIP partition of the GPT image corresponding to the active firmware 218 * bank to get its offset and length, and update these details in the I/O policy 219 * of the FIP image. 220 ******************************************************************************/ 221 void plat_fwu_set_images_source(const struct fwu_metadata *metadata) 222 { 223 arm_set_fip_addr(metadata->active_index); 224 } 225 226 /******************************************************************************* 227 * Read the requested FWU metadata partition of the GPT image to get its offset 228 * and length, and update these details in the I/O policy of the requested FWU 229 * metadata image. 230 ******************************************************************************/ 231 int plat_fwu_set_metadata_image_source(unsigned int image_id, 232 uintptr_t *dev_handle, 233 uintptr_t *image_spec) 234 { 235 int result = -1; 236 237 if (image_id == FWU_METADATA_IMAGE_ID) { 238 result = arm_set_image_source(FWU_METADATA_IMAGE_ID, 239 "FWU-Metadata", 240 dev_handle, 241 image_spec); 242 } else if (image_id == BKUP_FWU_METADATA_IMAGE_ID) { 243 result = arm_set_image_source(BKUP_FWU_METADATA_IMAGE_ID, 244 "Bkup-FWU-Metadata", 245 dev_handle, 246 image_spec); 247 } 248 249 return result; 250 } 251 #endif /* PSA_FWU_SUPPORT */ 252