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 void spl_mmc_load_image(void) 175 { 176 struct mmc *mmc; 177 u32 boot_mode; 178 int err = 0; 179 __maybe_unused int part; 180 181 if (spl_mmc_find_device(&mmc)) 182 hang(); 183 184 err = mmc_init(mmc); 185 if (err) { 186 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 187 printf("spl: mmc init failed with error: %d\n", err); 188 #endif 189 hang(); 190 } 191 192 boot_mode = spl_boot_mode(); 193 switch (boot_mode) { 194 case MMCSD_MODE_RAW: 195 debug("spl: mmc boot mode: raw\n"); 196 197 if (!spl_start_uboot()) { 198 err = mmc_load_image_raw_os(mmc); 199 if (!err) 200 return; 201 } 202 203 err = mmc_load_image_raw_partition(mmc, 204 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION); 205 if (!err) 206 return; 207 #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR) 208 err = mmc_load_image_raw_sector(mmc, 209 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); 210 if (!err) 211 return; 212 #endif 213 break; 214 case MMCSD_MODE_FS: 215 debug("spl: mmc boot mode: fs\n"); 216 217 #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION 218 #ifdef CONFIG_SPL_FAT_SUPPORT 219 if (!spl_start_uboot()) { 220 err = spl_load_image_fat_os(&mmc->block_dev, 221 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); 222 if (!err) 223 return; 224 } 225 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME 226 err = spl_load_image_fat(&mmc->block_dev, 227 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, 228 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME); 229 if (!err) 230 return; 231 #endif 232 #endif 233 #ifdef CONFIG_SPL_EXT_SUPPORT 234 if (!spl_start_uboot()) { 235 err = spl_load_image_ext_os(&mmc->block_dev, 236 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); 237 if (!err) 238 return; 239 } 240 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME 241 err = spl_load_image_ext(&mmc->block_dev, 242 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, 243 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME); 244 if (!err) 245 return; 246 #endif 247 #endif 248 #endif 249 break; 250 #ifdef CONFIG_SUPPORT_EMMC_BOOT 251 case MMCSD_MODE_EMMCBOOT: 252 /* 253 * We need to check what the partition is configured to. 254 * 1 and 2 match up to boot0 / boot1 and 7 is user data 255 * which is the first physical partition (0). 256 */ 257 part = (mmc->part_config >> 3) & PART_ACCESS_MASK; 258 259 if (part == 7) 260 part = 0; 261 262 if (mmc_switch_part(0, part)) { 263 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 264 puts("spl: mmc partition switch failed\n"); 265 #endif 266 hang(); 267 } 268 269 if (!spl_start_uboot()) { 270 err = mmc_load_image_raw_os(mmc); 271 if (!err) 272 return; 273 } 274 err = mmc_load_image_raw_partition(mmc, 275 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION); 276 if (!err) 277 return; 278 #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR) 279 err = mmc_load_image_raw_sector(mmc, 280 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); 281 if (!err) 282 return; 283 #endif 284 break; 285 #endif 286 case MMCSD_MODE_UNDEFINED: 287 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 288 default: 289 puts("spl: mmc: wrong boot mode\n"); 290 #endif 291 } 292 293 hang(); 294 } 295