drivers/mmc/fsl_esdhc_spl.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2013 Freescale Semiconductor, Inc.
   4  */
   5
   6 #include <common.h>
   7 #include <cpu_func.h>
   8 #include <hang.h>
   9 #include <mmc.h>
  10 #include <malloc.h>
  11
  12 /*
  13  * The environment variables are written to just after the u-boot image
  14  * on SDCard, so we must read the MBR to get the start address and code
  15  * length of the u-boot image, then calculate the address of the env.
  16  */
  17 #define ESDHC_BOOT_IMAGE_SIZE   0x48
  18 #define ESDHC_BOOT_IMAGE_ADDR   0x50
  19 #define MBRDBR_BOOT_SIG_55      0x1fe
  20 #define MBRDBR_BOOT_SIG_AA      0x1ff
  21 #define CONFIG_CFG_DATA_SECTOR  0
  22
  23
  24 void mmc_spl_load_image(uint32_t offs, unsigned int size, void *vdst)
  25 {
  26         uint blk_start, blk_cnt, err;
  27
  28         struct mmc *mmc = find_mmc_device(0);
  29         if (!mmc) {
  30                 puts("spl: mmc device not found!!\n");
  31                 hang();
  32         }
  33
  34         if (mmc_init(mmc)) {
  35                 puts("MMC init failed\n");
  36                 return;
  37         }
  38
  39         blk_start = ALIGN(offs, mmc->read_bl_len) / mmc->read_bl_len;
  40         blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
  41
  42         err = mmc->block_dev.block_read(&mmc->block_dev, blk_start, blk_cnt,
  43                                         vdst);
  44         if (err != blk_cnt) {
  45                 puts("spl: mmc read failed!!\n");
  46                 hang();
  47         }
  48 }
  49
  50 /*
  51  * The main entry for mmc booting. It's necessary that SDRAM is already
  52  * configured and available since this code loads the main U-Boot image
  53  * from mmc into SDRAM and starts it from there.
  54  */
  55
  56 void __noreturn mmc_boot(void)
  57 {
  58         __attribute__((noreturn)) void (*uboot)(void);
  59         uint blk_start, blk_cnt, err;
  60 #ifndef CONFIG_FSL_CORENET
  61         uchar *tmp_buf;
  62         u32 blklen;
  63         uchar val;
  64         uint i, byte_num;
  65 #endif
  66         u32 offset, code_len;
  67         struct mmc *mmc;
  68
  69         mmc = find_mmc_device(0);
  70         if (!mmc) {
  71                 puts("spl: mmc device not found!!\n");
  72                 hang();
  73         }
  74
  75 #ifdef CONFIG_FSL_CORENET
  76         offset = CONFIG_SYS_MMC_U_BOOT_OFFS;
  77         code_len = CONFIG_SYS_MMC_U_BOOT_SIZE;
  78 #else
  79         blklen = mmc->read_bl_len;
  80         tmp_buf = malloc(blklen);
  81         if (!tmp_buf) {
  82                 puts("spl: malloc memory failed!!\n");
  83                 hang();
  84         }
  85         memset(tmp_buf, 0, blklen);
  86
  87         /*
  88         * Read source addr from sd card
  89         */
  90         err = mmc->block_dev.block_read(&mmc->block_dev,
  91                                         CONFIG_CFG_DATA_SECTOR, 1, tmp_buf);
  92         if (err != 1) {
  93                 puts("spl: mmc read failed!!\n");
  94                 free(tmp_buf);
  95                 hang();
  96         }
  97
  98         val = *(tmp_buf + MBRDBR_BOOT_SIG_55);
  99         if (0x55 != val) {
 100                 puts("spl: mmc signature is not valid!!\n");
 101                 free(tmp_buf);
 102                 hang();
 103         }
 104         val = *(tmp_buf + MBRDBR_BOOT_SIG_AA);
 105         if (0xAA != val) {
 106                 puts("spl: mmc signature is not valid!!\n");
 107                 free(tmp_buf);
 108                 hang();
 109         }
 110
 111         byte_num = 4;
 112         offset = 0;
 113         for (i = 0; i < byte_num; i++) {
 114                 val = *(tmp_buf + ESDHC_BOOT_IMAGE_ADDR + i);
 115                 offset = (offset << 8) + val;
 116         }
 117         offset += CONFIG_SYS_MMC_U_BOOT_OFFS;
 118         /* Get the code size from offset 0x48 */
 119         byte_num = 4;
 120         code_len = 0;
 121         for (i = 0; i < byte_num; i++) {
 122                 val = *(tmp_buf + ESDHC_BOOT_IMAGE_SIZE + i);
 123                 code_len = (code_len << 8) + val;
 124         }
 125         code_len -= CONFIG_SYS_MMC_U_BOOT_OFFS;
 126         /*
 127         * Load U-Boot image from mmc into RAM
 128         */
 129 #endif
 130         blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
 131         blk_cnt = ALIGN(code_len, mmc->read_bl_len) / mmc->read_bl_len;
 132         err = mmc->block_dev.block_read(&mmc->block_dev, blk_start, blk_cnt,
 133                                         (uchar *)CONFIG_SYS_MMC_U_BOOT_DST);
 134         if (err != blk_cnt) {
 135                 puts("spl: mmc read failed!!\n");
 136 #ifndef CONFIG_FSL_CORENET
 137                 free(tmp_buf);
 138 #endif
 139                 hang();
 140         }
 141
 142         /*
 143         * Clean d-cache and invalidate i-cache, to
 144         * make sure that no stale data is executed.
 145         */
 146         flush_cache(CONFIG_SYS_MMC_U_BOOT_DST, CONFIG_SYS_MMC_U_BOOT_SIZE);
 147
 148         /*
 149         * Jump to U-Boot image
 150         */
 151         uboot = (void *)CONFIG_SYS_MMC_U_BOOT_START;
 152         (*uboot)();
 153 }