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 spl_image_info *spl_image, struct mmc *mmc,
  22                            ulong sector, struct image_header *header)
  23 {
  24         u32 image_size_sectors;
  25         unsigned long count;
  26         int ret;
  27
  28         ret = spl_parse_image_header(spl_image, 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 = blk_dread(mmc_get_blk_desc(mmc), sector, image_size_sectors,
  38                           (void *)(ulong)spl_image->load_addr);
  39         debug("read %x sectors to %x\n", image_size_sectors,
  40               spl_image->load_addr);
  41         if (count != image_size_sectors)
  42                 return -EIO;
  43
  44         return 0;
  45 }
  46
  47 static ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
  48                              ulong count, void *buf)
  49 {
  50         struct mmc *mmc = load->dev;
  51
  52         return blk_dread(mmc_get_blk_desc(mmc), sector, count, buf);
  53 }
  54
  55 static int mmc_load_image_raw_sector(struct spl_image_info *spl_image,
  56                                      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 = blk_dread(mmc_get_blk_desc(mmc), 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(spl_image, &load, sector, header);
  84         } else {
  85                 ret = mmc_load_legacy(spl_image, 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 spl_image_info *spl_image,
 155                                         struct mmc *mmc, int partition)
 156 {
 157         disk_partition_t info;
 158         int err;
 159
 160         err = part_get_info(mmc_get_blk_desc(mmc), partition, &info);
 161         if (err) {
 162 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 163                 puts("spl: partition error\n");
 164 #endif
 165                 return -1;
 166         }
 167
 168 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR
 169         return mmc_load_image_raw_sector(spl_image, mmc,
 170                         info.start + CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
 171 #else
 172         return mmc_load_image_raw_sector(spl_image, mmc, info.start);
 173 #endif
 174 }
 175 #else
 176 #define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION -1
 177 static int mmc_load_image_raw_partition(struct spl_image_info *spl_image,
 178                                         struct mmc *mmc, int partition)
 179 {
 180         return -ENOSYS;
 181 }
 182 #endif
 183
 184 #ifdef CONFIG_SPL_OS_BOOT
 185 static int mmc_load_image_raw_os(struct spl_image_info *spl_image,
 186                                  struct mmc *mmc)
 187 {
 188         unsigned long count;
 189         int ret;
 190
 191         count = blk_dread(mmc_get_blk_desc(mmc),
 192                 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
 193                 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
 194                 (void *) CONFIG_SYS_SPL_ARGS_ADDR);
 195         if (count == 0) {
 196 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 197                 puts("mmc_load_image_raw_os: mmc block read error\n");
 198 #endif
 199                 return -1;
 200         }
 201
 202         ret = mmc_load_image_raw_sector(spl_image, mmc,
 203                 CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR);
 204         if (ret)
 205                 return ret;
 206
 207         if (spl_image->os != IH_OS_LINUX) {
 208                 puts("Expected Linux image is not found. Trying to start U-boot\n");
 209                 return -ENOENT;
 210         }
 211
 212         return 0;
 213 }
 214 #else
 215 int spl_start_uboot(void)
 216 {
 217         return 1;
 218 }
 219 static int mmc_load_image_raw_os(struct spl_image_info *spl_image,
 220                                  struct mmc *mmc)
 221 {
 222         return -ENOSYS;
 223 }
 224 #endif
 225
 226 #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
 227 static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc)
 228 {
 229         int err = -ENOSYS;
 230
 231 #ifdef CONFIG_SPL_FAT_SUPPORT
 232         if (!spl_start_uboot()) {
 233                 err = spl_load_image_fat_os(spl_image, mmc_get_blk_desc(mmc),
 234                         CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
 235                 if (!err)
 236                         return err;
 237         }
 238 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
 239         err = spl_load_image_fat(spl_image, mmc_get_blk_desc(mmc),
 240                                  CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
 241                                  CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
 242         if (!err)
 243                 return err;
 244 #endif
 245 #endif
 246 #ifdef CONFIG_SPL_EXT_SUPPORT
 247         if (!spl_start_uboot()) {
 248                 err = spl_load_image_ext_os(spl_image, &mmc->block_dev,
 249                         CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
 250                 if (!err)
 251                         return err;
 252         }
 253 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
 254         err = spl_load_image_ext(spl_image, &mmc->block_dev,
 255                                  CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
 256                                  CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
 257         if (!err)
 258                 return err;
 259 #endif
 260 #endif
 261
 262 #if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT)
 263         err = -ENOENT;
 264 #endif
 265
 266         return err;
 267 }
 268 #else
 269 static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc)
 270 {
 271         return -ENOSYS;
 272 }
 273 #endif
 274
 275 static int spl_mmc_load_image(struct spl_image_info *spl_image,
 276                               struct spl_boot_device *bootdev)
 277 {
 278         struct mmc *mmc = NULL;
 279         u32 boot_mode;
 280         int err = 0;
 281         __maybe_unused int part;
 282
 283         err = spl_mmc_find_device(&mmc, bootdev->boot_device);
 284         if (err)
 285                 return err;
 286
 287         err = mmc_init(mmc);
 288         if (err) {
 289 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 290                 printf("spl: mmc init failed with error: %d\n", err);
 291 #endif
 292                 return err;
 293         }
 294
 295         boot_mode = spl_boot_mode(bootdev->boot_device);
 296         err = -EINVAL;
 297         switch (boot_mode) {
 298         case MMCSD_MODE_EMMCBOOT:
 299                         /*
 300                          * We need to check what the partition is configured to.
 301                          * 1 and 2 match up to boot0 / boot1 and 7 is user data
 302                          * which is the first physical partition (0).
 303                          */
 304                         part = (mmc->part_config >> 3) & PART_ACCESS_MASK;
 305
 306                         if (part == 7)
 307                                 part = 0;
 308
 309                         err = blk_dselect_hwpart(mmc_get_blk_desc(mmc), part);
 310                         if (err) {
 311 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 312                                 puts("spl: mmc partition switch failed\n");
 313 #endif
 314                                 return err;
 315                         }
 316                         /* Fall through */
 317         case MMCSD_MODE_RAW:
 318                 debug("spl: mmc boot mode: raw\n");
 319
 320                 if (!spl_start_uboot()) {
 321                         err = mmc_load_image_raw_os(spl_image, mmc);
 322                         if (!err)
 323                                 return err;
 324                 }
 325
 326                 err = mmc_load_image_raw_partition(spl_image, mmc,
 327                         CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
 328                 if (!err)
 329                         return err;
 330 #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR)
 331                 err = mmc_load_image_raw_sector(spl_image, mmc,
 332                         CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
 333                 if (!err)
 334                         return err;
 335 #endif
 336                 /* If RAW mode fails, try FS mode. */
 337         case MMCSD_MODE_FS:
 338                 debug("spl: mmc boot mode: fs\n");
 339
 340                 err = spl_mmc_do_fs_boot(spl_image, mmc);
 341                 if (!err)
 342                         return err;
 343
 344                 break;
 345         case MMCSD_MODE_UNDEFINED:
 346 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 347         default:
 348                 puts("spl: mmc: wrong boot mode\n");
 349 #endif
 350         }
 351
 352         return err;
 353 }
 354
 355 SPL_LOAD_IMAGE_METHOD(0, BOOT_DEVICE_MMC1, spl_mmc_load_image);
 356 SPL_LOAD_IMAGE_METHOD(0, BOOT_DEVICE_MMC2, spl_mmc_load_image);
 357 SPL_LOAD_IMAGE_METHOD(0, BOOT_DEVICE_MMC2_2, spl_mmc_load_image);