common/spl/spl_mmc.c

   1 /*
   2  * (C) Copyright 2010
   3  * Texas Instruments, <www.ti.com>
   4  *
   5  * Aneesh V <aneesh@ti.com>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <spl.h>
  12 #include <linux/compiler.h>
  13 #include <errno.h>
  14 #include <asm/u-boot.h>
  15 #include <errno.h>
  16 #include <mmc.h>
  17 #include <image.h>
  18
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 static int mmc_load_legacy(struct mmc *mmc, ulong sector,
  22                            struct image_header *header)
  23 {
  24         u32 image_size_sectors;
  25         unsigned long count;
  26
  27         spl_parse_image_header(header);
  28         /* convert size to sectors - round up */
  29         image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) /
  30                              mmc->read_bl_len;
  31
  32         /* Read the header too to avoid extra memcpy */
  33         count = mmc->block_dev.block_read(&mmc->block_dev, sector,
  34                                           image_size_sectors,
  35                                           (void *)(ulong)spl_image.load_addr);
  36         debug("read %x sectors to %x\n", image_size_sectors,
  37               spl_image.load_addr);
  38         if (count != image_size_sectors)
  39                 return -EIO;
  40
  41         return 0;
  42 }
  43
  44 static ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
  45                              ulong count, void *buf)
  46 {
  47         struct mmc *mmc = load->dev;
  48
  49         return mmc->block_dev.block_read(&mmc->block_dev, sector, count, buf);
  50 }
  51
  52 static int mmc_load_image_raw_sector(struct mmc *mmc, unsigned long sector)
  53 {
  54         unsigned long count;
  55         struct image_header *header;
  56         int ret = 0;
  57
  58         header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
  59                                          sizeof(struct image_header));
  60
  61         /* read image header to find the image size & load address */
  62         count = mmc->block_dev.block_read(&mmc->block_dev, sector, 1, header);
  63         debug("hdr read sector %lx, count=%lu\n", sector, count);
  64         if (count == 0) {
  65                 ret = -EIO;
  66                 goto end;
  67         }
  68
  69         if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
  70             image_get_magic(header) == FDT_MAGIC) {
  71                 struct spl_load_info load;
  72
  73                 debug("Found FIT\n");
  74                 load.dev = mmc;
  75                 load.priv = NULL;
  76                 load.bl_len = mmc->read_bl_len;
  77                 load.read = h_spl_load_read;
  78                 ret = spl_load_simple_fit(&load, sector, header);
  79         } else {
  80                 ret = mmc_load_legacy(mmc, sector, header);
  81         }
  82
  83 end:
  84         if (ret) {
  85 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
  86                 puts("spl: mmc block read error\n");
  87 #endif
  88                 return -1;
  89         }
  90
  91         return 0;
  92 }
  93
  94 int spl_mmc_get_device_index(u32 boot_device)
  95 {
  96         switch (boot_device) {
  97         case BOOT_DEVICE_MMC1:
  98                 return 0;
  99         case BOOT_DEVICE_MMC2:
 100         case BOOT_DEVICE_MMC2_2:
 101                 return 1;
 102         }
 103
 104 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 105         printf("spl: unsupported mmc boot device.\n");
 106 #endif
 107
 108         return -ENODEV;
 109 }
 110
 111 static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device)
 112 {
 113 #ifdef CONFIG_DM_MMC
 114         struct udevice *dev;
 115 #endif
 116         int err, mmc_dev;
 117
 118         mmc_dev = spl_mmc_get_device_index(boot_device);
 119         if (mmc_dev < 0)
 120                 return mmc_dev;
 121
 122         err = mmc_initialize(NULL);
 123         if (err) {
 124 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 125                 printf("spl: could not initialize mmc. error: %d\n", err);
 126 #endif
 127                 return err;
 128         }
 129
 130 #ifdef CONFIG_DM_MMC
 131         err = uclass_get_device(UCLASS_MMC, mmc_dev, &dev);
 132         if (!err)
 133                 *mmcp = mmc_get_mmc_dev(dev);
 134 #else
 135         *mmcp = find_mmc_device(mmc_dev);
 136         err = *mmcp ? 0 : -ENODEV;
 137 #endif
 138         if (err) {
 139 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 140                 printf("spl: could not find mmc device. error: %d\n", err);
 141 #endif
 142                 return err;
 143         }
 144
 145         return 0;
 146 }
 147
 148 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION
 149 static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
 150 {
 151         disk_partition_t info;
 152         int err;
 153
 154         err = part_get_info(&mmc->block_dev, partition, &info);
 155         if (err) {
 156 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 157                 puts("spl: partition error\n");
 158 #endif
 159                 return -1;
 160         }
 161
 162 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR
 163         return mmc_load_image_raw_sector(mmc, info.start +
 164                                          CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
 165 #else
 166         return mmc_load_image_raw_sector(mmc, info.start);
 167 #endif
 168 }
 169 #else
 170 #define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION -1
 171 static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
 172 {
 173         return -ENOSYS;
 174 }
 175 #endif
 176
 177 #ifdef CONFIG_SPL_OS_BOOT
 178 static int mmc_load_image_raw_os(struct mmc *mmc)
 179 {
 180         unsigned long count;
 181         int ret;
 182
 183         count = mmc->block_dev.block_read(&mmc->block_dev,
 184                 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
 185                 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
 186                 (void *) CONFIG_SYS_SPL_ARGS_ADDR);
 187         if (count == 0) {
 188 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 189                 puts("spl: mmc block read error\n");
 190 #endif
 191                 return -1;
 192         }
 193
 194         ret = mmc_load_image_raw_sector(mmc,
 195                 CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR);
 196         if (ret)
 197                 return ret;
 198
 199         if (spl_image.os != IH_OS_LINUX) {
 200                 puts("Expected Linux image is not found. Trying to start U-boot\n");
 201                 return -ENOENT;
 202         }
 203
 204         return 0;
 205 }
 206 #else
 207 int spl_start_uboot(void)
 208 {
 209         return 1;
 210 }
 211 static int mmc_load_image_raw_os(struct mmc *mmc)
 212 {
 213         return -ENOSYS;
 214 }
 215 #endif
 216
 217 #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
 218 int spl_mmc_do_fs_boot(struct mmc *mmc)
 219 {
 220         int err = -ENOSYS;
 221
 222 #ifdef CONFIG_SPL_FAT_SUPPORT
 223         if (!spl_start_uboot()) {
 224                 err = spl_load_image_fat_os(&mmc->block_dev,
 225                         CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
 226                 if (!err)
 227                         return err;
 228         }
 229 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
 230         err = spl_load_image_fat(&mmc->block_dev,
 231                                  CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
 232                                  CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
 233         if (!err)
 234                 return err;
 235 #endif
 236 #endif
 237 #ifdef CONFIG_SPL_EXT_SUPPORT
 238         if (!spl_start_uboot()) {
 239                 err = spl_load_image_ext_os(&mmc->block_dev,
 240                         CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
 241                 if (!err)
 242                         return err;
 243         }
 244 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
 245         err = spl_load_image_ext(&mmc->block_dev,
 246                                  CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
 247                                  CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
 248         if (!err)
 249                 return err;
 250 #endif
 251 #endif
 252
 253 #if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT)
 254         err = -ENOENT;
 255 #endif
 256
 257         return err;
 258 }
 259 #else
 260 int spl_mmc_do_fs_boot(struct mmc *mmc)
 261 {
 262         return -ENOSYS;
 263 }
 264 #endif
 265
 266 int spl_mmc_load_image(u32 boot_device)
 267 {
 268         struct mmc *mmc = NULL;
 269         u32 boot_mode;
 270         int err = 0;
 271         __maybe_unused int part;
 272
 273         err = spl_mmc_find_device(&mmc, boot_device);
 274         if (err)
 275                 return err;
 276
 277         err = mmc_init(mmc);
 278         if (err) {
 279 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 280                 printf("spl: mmc init failed with error: %d\n", err);
 281 #endif
 282                 return err;
 283         }
 284
 285         boot_mode = spl_boot_mode();
 286         err = -EINVAL;
 287         switch (boot_mode) {
 288         case MMCSD_MODE_EMMCBOOT:
 289                         /*
 290                          * We need to check what the partition is configured to.
 291                          * 1 and 2 match up to boot0 / boot1 and 7 is user data
 292                          * which is the first physical partition (0).
 293                          */
 294                         part = (mmc->part_config >> 3) & PART_ACCESS_MASK;
 295
 296                         if (part == 7)
 297                                 part = 0;
 298
 299                         err = mmc_switch_part(0, part);
 300                         if (err) {
 301 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 302                                 puts("spl: mmc partition switch failed\n");
 303 #endif
 304                                 return err;
 305                         }
 306                         /* Fall through */
 307         case MMCSD_MODE_RAW:
 308                 debug("spl: mmc boot mode: raw\n");
 309
 310                 if (!spl_start_uboot()) {
 311                         err = mmc_load_image_raw_os(mmc);
 312                         if (!err)
 313                                 return err;
 314                 }
 315
 316                 err = mmc_load_image_raw_partition(mmc,
 317                         CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
 318                 if (!err)
 319                         return err;
 320 #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR)
 321                 err = mmc_load_image_raw_sector(mmc,
 322                         CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
 323                 if (!err)
 324                         return err;
 325 #endif
 326                 /* If RAW mode fails, try FS mode. */
 327         case MMCSD_MODE_FS:
 328                 debug("spl: mmc boot mode: fs\n");
 329
 330                 err = spl_mmc_do_fs_boot(mmc);
 331                 if (!err)
 332                         return err;
 333
 334                 break;
 335         case MMCSD_MODE_UNDEFINED:
 336 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 337         default:
 338                 puts("spl: mmc: wrong boot mode\n");
 339 #endif
 340         }
 341
 342         return err;
 343 }