1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2016 NXP Semiconductor, Inc. 4 */ 5 #include <common.h> 6 #include <malloc.h> 7 #include <config.h> 8 #include <errno.h> 9 #include <asm/system.h> 10 #include <asm/types.h> 11 #include <asm/arch/soc.h> 12 #ifdef CONFIG_FSL_LSCH3 13 #include <asm/arch/immap_lsch3.h> 14 #elif defined(CONFIG_FSL_LSCH2) 15 #include <asm/arch/immap_lsch2.h> 16 #endif 17 #ifdef CONFIG_ARMV8_SEC_FIRMWARE_SUPPORT 18 #include <asm/armv8/sec_firmware.h> 19 #endif 20 #ifdef CONFIG_CHAIN_OF_TRUST 21 #include <fsl_validate.h> 22 #endif 23 24 #ifdef CONFIG_SYS_LS_PPA_FW_IN_NAND 25 #include <nand.h> 26 #elif defined(CONFIG_SYS_LS_PPA_FW_IN_MMC) 27 #include <mmc.h> 28 #endif 29 30 DECLARE_GLOBAL_DATA_PTR; 31 32 int ppa_init(void) 33 { 34 unsigned int el = current_el(); 35 void *ppa_fit_addr; 36 u32 *boot_loc_ptr_l, *boot_loc_ptr_h; 37 u32 *loadable_l, *loadable_h; 38 int ret; 39 40 #ifdef CONFIG_CHAIN_OF_TRUST 41 uintptr_t ppa_esbc_hdr = 0; 42 uintptr_t ppa_img_addr = 0; 43 #if defined(CONFIG_SYS_LS_PPA_FW_IN_MMC) || \ 44 defined(CONFIG_SYS_LS_PPA_FW_IN_NAND) 45 void *ppa_hdr_ddr; 46 #endif 47 #endif 48 49 /* Skip if running at lower exception level */ 50 if (el < 3) { 51 debug("Skipping PPA init, running at EL%d\n", el); 52 return 0; 53 } 54 55 #ifdef CONFIG_SYS_LS_PPA_FW_IN_XIP 56 ppa_fit_addr = (void *)CONFIG_SYS_LS_PPA_FW_ADDR; 57 debug("%s: PPA image load from XIP\n", __func__); 58 #ifdef CONFIG_CHAIN_OF_TRUST 59 ppa_esbc_hdr = CONFIG_SYS_LS_PPA_ESBC_ADDR; 60 #endif 61 #else /* !CONFIG_SYS_LS_PPA_FW_IN_XIP */ 62 size_t fw_length, fdt_header_len = sizeof(struct fdt_header); 63 64 /* Copy PPA image from MMC/SD/NAND to allocated memory */ 65 #ifdef CONFIG_SYS_LS_PPA_FW_IN_MMC 66 struct mmc *mmc; 67 int dev = CONFIG_SYS_MMC_ENV_DEV; 68 struct fdt_header *fitp; 69 u32 cnt; 70 u32 blk; 71 72 debug("%s: PPA image load from eMMC/SD\n", __func__); 73 74 ret = mmc_initialize(gd->bd); 75 if (ret) { 76 printf("%s: mmc_initialize() failed\n", __func__); 77 return ret; 78 } 79 mmc = find_mmc_device(dev); 80 if (!mmc) { 81 printf("PPA: MMC cannot find device for PPA firmware\n"); 82 return -ENODEV; 83 } 84 85 ret = mmc_init(mmc); 86 if (ret) { 87 printf("%s: mmc_init() failed\n", __func__); 88 return ret; 89 } 90 91 fitp = malloc(roundup(fdt_header_len, 512)); 92 if (!fitp) { 93 printf("PPA: malloc failed for FIT header(size 0x%zx)\n", 94 roundup(fdt_header_len, 512)); 95 return -ENOMEM; 96 } 97 98 blk = CONFIG_SYS_LS_PPA_FW_ADDR / 512; 99 cnt = DIV_ROUND_UP(fdt_header_len, 512); 100 debug("%s: MMC read PPA FIT header: dev # %u, block # %u, count %u\n", 101 __func__, dev, blk, cnt); 102 ret = mmc->block_dev.block_read(&mmc->block_dev, blk, cnt, fitp); 103 if (ret != cnt) { 104 free(fitp); 105 printf("MMC/SD read of PPA FIT header at offset 0x%x failed\n", 106 CONFIG_SYS_LS_PPA_FW_ADDR); 107 return -EIO; 108 } 109 110 ret = fdt_check_header(fitp); 111 if (ret) { 112 free(fitp); 113 printf("%s: fdt_check_header() failed\n", __func__); 114 return ret; 115 } 116 117 #ifdef CONFIG_CHAIN_OF_TRUST 118 ppa_hdr_ddr = malloc(CONFIG_LS_PPA_ESBC_HDR_SIZE); 119 if (!ppa_hdr_ddr) { 120 printf("PPA: malloc failed for PPA header\n"); 121 return -ENOMEM; 122 } 123 124 blk = CONFIG_SYS_LS_PPA_ESBC_ADDR >> 9; 125 cnt = DIV_ROUND_UP(CONFIG_LS_PPA_ESBC_HDR_SIZE, 512); 126 ret = mmc->block_dev.block_read(&mmc->block_dev, blk, cnt, ppa_hdr_ddr); 127 if (ret != cnt) { 128 free(ppa_hdr_ddr); 129 printf("MMC/SD read of PPA header failed\n"); 130 return -EIO; 131 } 132 debug("Read PPA header to 0x%p\n", ppa_hdr_ddr); 133 134 ppa_esbc_hdr = (uintptr_t)ppa_hdr_ddr; 135 #endif 136 137 fw_length = fdt_totalsize(fitp); 138 free(fitp); 139 140 fw_length = roundup(fw_length, 512); 141 ppa_fit_addr = malloc(fw_length); 142 if (!ppa_fit_addr) { 143 printf("PPA: malloc failed for PPA image(size 0x%zx)\n", 144 fw_length); 145 return -ENOMEM; 146 } 147 148 blk = CONFIG_SYS_LS_PPA_FW_ADDR / 512; 149 cnt = DIV_ROUND_UP(fw_length, 512); 150 debug("%s: MMC read PPA FIT image: dev # %u, block # %u, count %u\n", 151 __func__, dev, blk, cnt); 152 ret = mmc->block_dev.block_read(&mmc->block_dev, 153 blk, cnt, ppa_fit_addr); 154 if (ret != cnt) { 155 free(ppa_fit_addr); 156 printf("MMC/SD read of PPA FIT header at offset 0x%x failed\n", 157 CONFIG_SYS_LS_PPA_FW_ADDR); 158 return -EIO; 159 } 160 161 #elif defined(CONFIG_SYS_LS_PPA_FW_IN_NAND) 162 struct fdt_header fit; 163 164 debug("%s: PPA image load from NAND\n", __func__); 165 166 nand_init(); 167 ret = nand_read(get_nand_dev_by_index(0), 168 (loff_t)CONFIG_SYS_LS_PPA_FW_ADDR, 169 &fdt_header_len, (u_char *)&fit); 170 if (ret == -EUCLEAN) { 171 printf("NAND read of PPA FIT header at offset 0x%x failed\n", 172 CONFIG_SYS_LS_PPA_FW_ADDR); 173 return -EIO; 174 } 175 176 ret = fdt_check_header(&fit); 177 if (ret) { 178 printf("%s: fdt_check_header() failed\n", __func__); 179 return ret; 180 } 181 182 #ifdef CONFIG_CHAIN_OF_TRUST 183 ppa_hdr_ddr = malloc(CONFIG_LS_PPA_ESBC_HDR_SIZE); 184 if (!ppa_hdr_ddr) { 185 printf("PPA: malloc failed for PPA header\n"); 186 return -ENOMEM; 187 } 188 189 fw_length = CONFIG_LS_PPA_ESBC_HDR_SIZE; 190 191 ret = nand_read(get_nand_dev_by_index(0), 192 (loff_t)CONFIG_SYS_LS_PPA_ESBC_ADDR, 193 &fw_length, (u_char *)ppa_hdr_ddr); 194 if (ret == -EUCLEAN) { 195 free(ppa_hdr_ddr); 196 printf("NAND read of PPA firmware at offset 0x%x failed\n", 197 CONFIG_SYS_LS_PPA_FW_ADDR); 198 return -EIO; 199 } 200 debug("Read PPA header to 0x%p\n", ppa_hdr_ddr); 201 202 ppa_esbc_hdr = (uintptr_t)ppa_hdr_ddr; 203 #endif 204 205 fw_length = fdt_totalsize(&fit); 206 207 ppa_fit_addr = malloc(fw_length); 208 if (!ppa_fit_addr) { 209 printf("PPA: malloc failed for PPA image(size 0x%zx)\n", 210 fw_length); 211 return -ENOMEM; 212 } 213 214 ret = nand_read(get_nand_dev_by_index(0), 215 (loff_t)CONFIG_SYS_LS_PPA_FW_ADDR, 216 &fw_length, (u_char *)ppa_fit_addr); 217 if (ret == -EUCLEAN) { 218 free(ppa_fit_addr); 219 printf("NAND read of PPA firmware at offset 0x%x failed\n", 220 CONFIG_SYS_LS_PPA_FW_ADDR); 221 return -EIO; 222 } 223 #else 224 #error "No CONFIG_SYS_LS_PPA_FW_IN_xxx defined" 225 #endif 226 227 #endif 228 229 #ifdef CONFIG_CHAIN_OF_TRUST 230 ppa_img_addr = (uintptr_t)ppa_fit_addr; 231 if (fsl_check_boot_mode_secure() != 0) { 232 /* 233 * In case of failure in validation, fsl_secboot_validate 234 * would not return back in case of Production environment 235 * with ITS=1. In Development environment (ITS=0 and 236 * SB_EN=1), the function may return back in case of 237 * non-fatal failures. 238 */ 239 ret = fsl_secboot_validate(ppa_esbc_hdr, 240 PPA_KEY_HASH, 241 &ppa_img_addr); 242 if (ret != 0) 243 printf("SEC firmware(s) validation failed\n"); 244 else 245 printf("SEC firmware(s) validation Successful\n"); 246 } 247 #if defined(CONFIG_SYS_LS_PPA_FW_IN_MMC) || \ 248 defined(CONFIG_SYS_LS_PPA_FW_IN_NAND) 249 free(ppa_hdr_ddr); 250 #endif 251 #endif 252 253 #ifdef CONFIG_FSL_LSCH3 254 struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR); 255 boot_loc_ptr_l = &gur->bootlocptrl; 256 boot_loc_ptr_h = &gur->bootlocptrh; 257 258 /* Assign addresses to loadable ptrs */ 259 loadable_l = &gur->scratchrw[4]; 260 loadable_h = &gur->scratchrw[5]; 261 #elif defined(CONFIG_FSL_LSCH2) 262 struct ccsr_scfg __iomem *scfg = (void *)(CONFIG_SYS_FSL_SCFG_ADDR); 263 boot_loc_ptr_l = &scfg->scratchrw[1]; 264 boot_loc_ptr_h = &scfg->scratchrw[0]; 265 266 /* Assign addresses to loadable ptrs */ 267 loadable_l = &scfg->scratchrw[2]; 268 loadable_h = &scfg->scratchrw[3]; 269 #endif 270 271 debug("fsl-ppa: boot_loc_ptr_l = 0x%p, boot_loc_ptr_h =0x%p\n", 272 boot_loc_ptr_l, boot_loc_ptr_h); 273 ret = sec_firmware_init(ppa_fit_addr, boot_loc_ptr_l, boot_loc_ptr_h, 274 loadable_l, loadable_h); 275 276 #if defined(CONFIG_SYS_LS_PPA_FW_IN_MMC) || \ 277 defined(CONFIG_SYS_LS_PPA_FW_IN_NAND) 278 free(ppa_fit_addr); 279 #endif 280 281 return ret; 282 } 283
