drivers/mmc/fsl_esdhc_spl.c

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