git.sur5r.net Git - u-boot/blob - arch/arm/cpu/armv8/fsl-layerscape/ppa.c

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