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 #endif 137 138 #ifdef CONFIG_SPL_OS_BOOT 139 static int mmc_load_image_raw_os(struct mmc *mmc) 140 { 141 unsigned long count; 142 143 count = mmc->block_dev.block_read(0, 144 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR, 145 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS, 146 (void *) CONFIG_SYS_SPL_ARGS_ADDR); 147 if (count == 0) { 148 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 149 puts("spl: mmc block read error\n"); 150 #endif 151 return -1; 152 } 153 154 return mmc_load_image_raw_sector(mmc, 155 CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR); 156 } 157 #endif 158 159 void spl_mmc_load_image(void) 160 { 161 struct mmc *mmc; 162 u32 boot_mode; 163 int err = 0; 164 __maybe_unused int part; 165 166 if (spl_mmc_find_device(&mmc)) 167 hang(); 168 169 err = mmc_init(mmc); 170 if (err) { 171 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 172 printf("spl: mmc init failed with error: %d\n", err); 173 #endif 174 hang(); 175 } 176 177 boot_mode = spl_boot_mode(); 178 switch (boot_mode) { 179 case MMCSD_MODE_RAW: 180 debug("spl: mmc boot mode: raw\n"); 181 182 #ifdef CONFIG_SPL_OS_BOOT 183 if (!spl_start_uboot()) { 184 err = mmc_load_image_raw_os(mmc); 185 if (!err) 186 return; 187 } 188 #endif 189 #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION) 190 err = mmc_load_image_raw_partition(mmc, 191 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION); 192 if (!err) 193 return; 194 #elif defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR) 195 err = mmc_load_image_raw_sector(mmc, 196 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); 197 if (!err) 198 return; 199 #endif 200 break; 201 case MMCSD_MODE_FS: 202 debug("spl: mmc boot mode: fs\n"); 203 204 #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION 205 #ifdef CONFIG_SPL_FAT_SUPPORT 206 #ifdef CONFIG_SPL_OS_BOOT 207 if (!spl_start_uboot()) { 208 err = spl_load_image_fat_os(&mmc->block_dev, 209 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); 210 if (!err) 211 return; 212 } 213 #endif 214 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME 215 err = spl_load_image_fat(&mmc->block_dev, 216 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, 217 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME); 218 if (!err) 219 return; 220 #endif 221 #endif 222 #ifdef CONFIG_SPL_EXT_SUPPORT 223 #ifdef CONFIG_SPL_OS_BOOT 224 if (!spl_start_uboot()) { 225 err = spl_load_image_ext_os(&mmc->block_dev, 226 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); 227 if (!err) 228 return; 229 } 230 #endif 231 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME 232 err = spl_load_image_ext(&mmc->block_dev, 233 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, 234 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME); 235 if (!err) 236 return; 237 #endif 238 #endif 239 #endif 240 break; 241 #ifdef CONFIG_SUPPORT_EMMC_BOOT 242 case MMCSD_MODE_EMMCBOOT: 243 /* 244 * We need to check what the partition is configured to. 245 * 1 and 2 match up to boot0 / boot1 and 7 is user data 246 * which is the first physical partition (0). 247 */ 248 part = (mmc->part_config >> 3) & PART_ACCESS_MASK; 249 250 if (part == 7) 251 part = 0; 252 253 if (mmc_switch_part(0, part)) { 254 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 255 puts("spl: mmc partition switch failed\n"); 256 #endif 257 hang(); 258 } 259 260 #ifdef CONFIG_SPL_OS_BOOT 261 if (!spl_start_uboot()) { 262 err = mmc_load_image_raw_os(mmc); 263 if (!err) 264 return; 265 } 266 #endif 267 #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION) 268 err = mmc_load_image_raw_partition(mmc, 269 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION); 270 if (!err) 271 return; 272 #elif defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR) 273 err = mmc_load_image_raw_sector(mmc, 274 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); 275 if (!err) 276 return; 277 #endif 278 break; 279 #endif 280 case MMCSD_MODE_UNDEFINED: 281 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 282 default: 283 puts("spl: mmc: wrong boot mode\n"); 284 #endif 285 } 286 287 hang(); 288 } 289