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