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