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 182 count = mmc->block_dev.block_read(&mmc->block_dev, 183 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR, 184 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS, 185 (void *) CONFIG_SYS_SPL_ARGS_ADDR); 186 if (count == 0) { 187 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 188 puts("spl: mmc block read error\n"); 189 #endif 190 return -1; 191 } 192 193 return mmc_load_image_raw_sector(mmc, 194 CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR); 195 } 196 #else 197 int spl_start_uboot(void) 198 { 199 return 1; 200 } 201 static int mmc_load_image_raw_os(struct mmc *mmc) 202 { 203 return -ENOSYS; 204 } 205 #endif 206 207 #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION 208 int spl_mmc_do_fs_boot(struct mmc *mmc) 209 { 210 int err = -ENOSYS; 211 212 #ifdef CONFIG_SPL_FAT_SUPPORT 213 if (!spl_start_uboot()) { 214 err = spl_load_image_fat_os(&mmc->block_dev, 215 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); 216 if (!err) 217 return err; 218 } 219 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME 220 err = spl_load_image_fat(&mmc->block_dev, 221 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, 222 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME); 223 if (!err) 224 return err; 225 #endif 226 #endif 227 #ifdef CONFIG_SPL_EXT_SUPPORT 228 if (!spl_start_uboot()) { 229 err = spl_load_image_ext_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_ext(&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 243 #if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT) 244 err = -ENOENT; 245 #endif 246 247 return err; 248 } 249 #else 250 int spl_mmc_do_fs_boot(struct mmc *mmc) 251 { 252 return -ENOSYS; 253 } 254 #endif 255 256 int spl_mmc_load_image(u32 boot_device) 257 { 258 struct mmc *mmc = NULL; 259 u32 boot_mode; 260 int err = 0; 261 __maybe_unused int part; 262 263 err = spl_mmc_find_device(&mmc, boot_device); 264 if (err) 265 return err; 266 267 err = mmc_init(mmc); 268 if (err) { 269 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 270 printf("spl: mmc init failed with error: %d\n", err); 271 #endif 272 return err; 273 } 274 275 boot_mode = spl_boot_mode(); 276 err = -EINVAL; 277 switch (boot_mode) { 278 case MMCSD_MODE_EMMCBOOT: 279 /* 280 * We need to check what the partition is configured to. 281 * 1 and 2 match up to boot0 / boot1 and 7 is user data 282 * which is the first physical partition (0). 283 */ 284 part = (mmc->part_config >> 3) & PART_ACCESS_MASK; 285 286 if (part == 7) 287 part = 0; 288 289 err = mmc_switch_part(0, part); 290 if (err) { 291 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 292 puts("spl: mmc partition switch failed\n"); 293 #endif 294 return err; 295 } 296 /* Fall through */ 297 case MMCSD_MODE_RAW: 298 debug("spl: mmc boot mode: raw\n"); 299 300 if (!spl_start_uboot()) { 301 err = mmc_load_image_raw_os(mmc); 302 if (!err) 303 return err; 304 } 305 306 err = mmc_load_image_raw_partition(mmc, 307 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION); 308 if (!err) 309 return err; 310 #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR) 311 err = mmc_load_image_raw_sector(mmc, 312 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); 313 if (!err) 314 return err; 315 #endif 316 /* If RAW mode fails, try FS mode. */ 317 case MMCSD_MODE_FS: 318 debug("spl: mmc boot mode: fs\n"); 319 320 err = spl_mmc_do_fs_boot(mmc); 321 if (!err) 322 return err; 323 324 break; 325 case MMCSD_MODE_UNDEFINED: 326 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 327 default: 328 puts("spl: mmc: wrong boot mode\n"); 329 #endif 330 } 331 332 return err; 333 } 334