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 #ifdef CONFIG_SPL_LOAD_FIT 45 static ulong h_spl_load_read(struct spl_load_info *load, ulong sector, 46 ulong count, void *buf) 47 { 48 struct mmc *mmc = load->dev; 49 50 return mmc->block_dev.block_read(&mmc->block_dev, sector, count, buf); 51 } 52 #endif 53 54 static int mmc_load_image_raw_sector(struct mmc *mmc, unsigned long sector) 55 { 56 unsigned long count; 57 struct image_header *header; 58 int ret = 0; 59 60 header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - 61 sizeof(struct image_header)); 62 63 /* read image header to find the image size & load address */ 64 count = mmc->block_dev.block_read(&mmc->block_dev, sector, 1, header); 65 debug("hdr read sector %lx, count=%lu\n", sector, count); 66 if (count == 0) { 67 ret = -EIO; 68 goto end; 69 } 70 71 switch (image_get_magic(header)) { 72 case IH_MAGIC: 73 ret = mmc_load_legacy(mmc, sector, header); 74 break; 75 #ifdef CONFIG_SPL_LOAD_FIT 76 case FDT_MAGIC: { 77 struct spl_load_info load; 78 79 debug("Found FIT\n"); 80 load.dev = mmc; 81 load.priv = NULL; 82 load.bl_len = mmc->read_bl_len; 83 load.read = h_spl_load_read; 84 ret = spl_load_simple_fit(&load, sector, header); 85 break; 86 } 87 #endif 88 default: 89 puts("bad magic\n"); 90 return -1; 91 } 92 93 end: 94 if (ret) { 95 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 96 puts("spl: mmc block read error\n"); 97 #endif 98 return -1; 99 } 100 101 return 0; 102 } 103 104 int spl_mmc_get_device_index(u32 boot_device) 105 { 106 switch (boot_device) { 107 case BOOT_DEVICE_MMC1: 108 return 0; 109 case BOOT_DEVICE_MMC2: 110 case BOOT_DEVICE_MMC2_2: 111 return 1; 112 } 113 114 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 115 printf("spl: unsupported mmc boot device.\n"); 116 #endif 117 118 return -ENODEV; 119 } 120 121 static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device) 122 { 123 #ifdef CONFIG_DM_MMC 124 struct udevice *dev; 125 #endif 126 int err, mmc_dev; 127 128 mmc_dev = spl_mmc_get_device_index(boot_device); 129 if (mmc_dev < 0) 130 return mmc_dev; 131 132 err = mmc_initialize(NULL); 133 if (err) { 134 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 135 printf("spl: could not initialize mmc. error: %d\n", err); 136 #endif 137 return err; 138 } 139 140 #ifdef CONFIG_DM_MMC 141 err = uclass_get_device(UCLASS_MMC, mmc_dev, &dev); 142 if (!err) 143 *mmcp = mmc_get_mmc_dev(dev); 144 #else 145 *mmcp = find_mmc_device(mmc_dev); 146 err = *mmcp ? 0 : -ENODEV; 147 #endif 148 if (err) { 149 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 150 printf("spl: could not find mmc device. error: %d\n", err); 151 #endif 152 return err; 153 } 154 155 return 0; 156 } 157 158 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION 159 static int mmc_load_image_raw_partition(struct mmc *mmc, int partition) 160 { 161 disk_partition_t info; 162 int err; 163 164 err = part_get_info(&mmc->block_dev, partition, &info); 165 if (err) { 166 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 167 puts("spl: partition error\n"); 168 #endif 169 return -1; 170 } 171 172 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR 173 return mmc_load_image_raw_sector(mmc, info.start + 174 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); 175 #else 176 return mmc_load_image_raw_sector(mmc, info.start); 177 #endif 178 } 179 #else 180 #define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION -1 181 static int mmc_load_image_raw_partition(struct mmc *mmc, int partition) 182 { 183 return -ENOSYS; 184 } 185 #endif 186 187 #ifdef CONFIG_SPL_OS_BOOT 188 static int mmc_load_image_raw_os(struct mmc *mmc) 189 { 190 unsigned long count; 191 192 count = mmc->block_dev.block_read(&mmc->block_dev, 193 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR, 194 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS, 195 (void *) CONFIG_SYS_SPL_ARGS_ADDR); 196 if (count == 0) { 197 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 198 puts("spl: mmc block read error\n"); 199 #endif 200 return -1; 201 } 202 203 return mmc_load_image_raw_sector(mmc, 204 CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR); 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 } 344