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