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 <part.h> 12 #include <spl.h> 13 #include <spl_rkfw.h> 14 #include <linux/compiler.h> 15 #include <errno.h> 16 #include <asm/u-boot.h> 17 #include <errno.h> 18 #include <mmc.h> 19 #include <image.h> 20 21 DECLARE_GLOBAL_DATA_PTR; 22 23 static int mmc_load_legacy(struct spl_image_info *spl_image, struct mmc *mmc, 24 ulong sector, struct image_header *header) 25 { 26 u32 image_size_sectors; 27 unsigned long count; 28 int ret; 29 30 ret = spl_parse_image_header(spl_image, header); 31 if (ret) 32 return ret; 33 34 /* convert size to sectors - round up */ 35 image_size_sectors = (spl_image->size + mmc->read_bl_len - 1) / 36 mmc->read_bl_len; 37 38 /* Read the header too to avoid extra memcpy */ 39 count = blk_dread(mmc_get_blk_desc(mmc), sector, image_size_sectors, 40 (void *)(ulong)spl_image->load_addr); 41 debug("read %x sectors to %lx\n", image_size_sectors, 42 spl_image->load_addr); 43 if (count != image_size_sectors) 44 return -EIO; 45 46 return 0; 47 } 48 49 static ulong h_spl_load_read(struct spl_load_info *load, ulong sector, 50 ulong count, void *buf) 51 { 52 return blk_dread(load->dev, sector, count, buf); 53 } 54 55 static __maybe_unused 56 int mmc_load_image_raw_sector(struct spl_image_info *spl_image, 57 struct mmc *mmc, unsigned long sector) 58 { 59 unsigned long count; 60 struct image_header *header; 61 int ret = 0; 62 63 header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - 64 sizeof(struct image_header)); 65 66 /* read image header to find the image size & load address */ 67 count = blk_dread(mmc_get_blk_desc(mmc), sector, 1, header); 68 debug("hdr read sector %lx, count=%lu\n", sector, count); 69 if (count == 0) { 70 ret = -EIO; 71 goto end; 72 } 73 74 #ifdef CONFIG_SPL_FIT_IMAGE_MULTIPLE 75 if ((IS_ENABLED(CONFIG_SPL_LOAD_FIT) && 76 image_get_magic(header) == FDT_MAGIC) || 77 CONFIG_SPL_FIT_IMAGE_MULTIPLE > 1) { 78 #else 79 if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && 80 image_get_magic(header) == FDT_MAGIC) { 81 #endif 82 struct spl_load_info load; 83 84 debug("Found FIT\n"); 85 load.dev = mmc_get_blk_desc(mmc); 86 load.priv = NULL; 87 load.filename = NULL; 88 load.bl_len = mmc->read_bl_len; 89 load.read = h_spl_load_read; 90 ret = spl_load_simple_fit(spl_image, &load, sector, header); 91 } else { 92 ret = mmc_load_legacy(spl_image, mmc, sector, header); 93 } 94 95 end: 96 if (ret) { 97 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 98 debug("mmc_load_image_raw_sector error: ret is %d\n", ret); 99 #endif 100 return -1; 101 } 102 103 return 0; 104 } 105 106 static int spl_mmc_get_device_index(u32 boot_device) 107 { 108 switch (boot_device) { 109 case BOOT_DEVICE_MMC1: 110 return 0; 111 case BOOT_DEVICE_MMC2: 112 case BOOT_DEVICE_MMC2_2: 113 return 1; 114 } 115 116 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 117 printf("spl: unsupported mmc boot device.\n"); 118 #endif 119 120 return -ENODEV; 121 } 122 123 static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device) 124 { 125 int err, mmc_dev; 126 127 mmc_dev = spl_mmc_get_device_index(boot_device); 128 if (mmc_dev < 0) 129 return mmc_dev; 130 131 err = mmc_initialize(NULL); 132 if (err) { 133 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 134 printf("spl: could not initialize mmc. error: %d\n", err); 135 #endif 136 return err; 137 } 138 139 *mmcp = find_mmc_device(mmc_dev); 140 err = *mmcp ? 0 : -ENODEV; 141 if (err) { 142 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 143 printf("spl: could not find mmc device. error: %d\n", err); 144 #endif 145 return err; 146 } 147 148 return 0; 149 } 150 151 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION 152 static int mmc_load_image_raw_partition(struct spl_image_info *spl_image, 153 struct mmc *mmc, int partition) 154 { 155 disk_partition_t info; 156 int err; 157 158 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION_TYPE 159 int type_part; 160 /* Only support MBR so DOS_ENTRY_NUMBERS */ 161 for (type_part = 1; type_part <= DOS_ENTRY_NUMBERS; type_part++) { 162 err = part_get_info(mmc_get_blk_desc(mmc), type_part, &info); 163 if (err) 164 continue; 165 if (info.sys_ind == 166 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION_TYPE) { 167 partition = type_part; 168 break; 169 } 170 } 171 #endif 172 173 err = part_get_info(mmc_get_blk_desc(mmc), partition, &info); 174 if (err) { 175 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 176 puts("spl: partition error\n"); 177 #endif 178 return -1; 179 } 180 181 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR 182 return mmc_load_image_raw_sector(spl_image, mmc, 183 info.start + CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); 184 #else 185 return mmc_load_image_raw_sector(spl_image, mmc, info.start); 186 #endif 187 } 188 #endif 189 190 #ifdef CONFIG_SPL_OS_BOOT 191 static int mmc_load_image_raw_os(struct spl_image_info *spl_image, 192 struct mmc *mmc) 193 { 194 unsigned long count; 195 int ret; 196 197 count = blk_dread(mmc_get_blk_desc(mmc), 198 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR, 199 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS, 200 (void *) CONFIG_SYS_SPL_ARGS_ADDR); 201 if (count != CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS) { 202 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 203 puts("mmc_load_image_raw_os: mmc block read error\n"); 204 #endif 205 return -1; 206 } 207 208 ret = mmc_load_image_raw_sector(spl_image, mmc, 209 CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR); 210 if (ret) 211 return ret; 212 213 if (spl_image->os != IH_OS_LINUX) { 214 puts("Expected Linux image is not found. Trying to start U-boot\n"); 215 return -ENOENT; 216 } 217 218 return 0; 219 } 220 #else 221 int spl_start_uboot(void) 222 { 223 return 1; 224 } 225 static int mmc_load_image_raw_os(struct spl_image_info *spl_image, 226 struct mmc *mmc) 227 { 228 return -ENOSYS; 229 } 230 #endif 231 232 #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION 233 static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc) 234 { 235 int err = -ENOSYS; 236 237 #ifdef CONFIG_SPL_FAT_SUPPORT 238 if (!spl_start_uboot()) { 239 err = spl_load_image_fat_os(spl_image, mmc_get_blk_desc(mmc), 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_fat(spl_image, mmc_get_blk_desc(mmc), 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 #ifdef CONFIG_SPL_EXT_SUPPORT 253 if (!spl_start_uboot()) { 254 err = spl_load_image_ext_os(spl_image, mmc_get_blk_desc(mmc), 255 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); 256 if (!err) 257 return err; 258 } 259 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME 260 err = spl_load_image_ext(spl_image, mmc_get_blk_desc(mmc), 261 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, 262 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME); 263 if (!err) 264 return err; 265 #endif 266 #endif 267 268 #if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT) 269 err = -ENOENT; 270 #endif 271 272 return err; 273 } 274 #else 275 static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc) 276 { 277 return -ENOSYS; 278 } 279 #endif 280 281 int spl_mmc_load_image(struct spl_image_info *spl_image, 282 struct spl_boot_device *bootdev) 283 { 284 struct mmc *mmc = NULL; 285 u32 boot_mode; 286 int err = 0; 287 __maybe_unused int part; 288 289 err = spl_mmc_find_device(&mmc, bootdev->boot_device); 290 if (err) 291 return err; 292 293 err = mmc_init(mmc); 294 if (err) { 295 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 296 printf("spl: mmc init failed with error: %d\n", err); 297 #endif 298 return err; 299 } 300 301 #ifdef CONFIG_SPL_LOAD_RKFW 302 struct spl_load_info load; 303 304 load.dev = mmc_get_blk_desc(mmc); 305 load.priv = NULL; 306 load.filename = NULL; 307 load.bl_len = mmc->read_bl_len; 308 load.read = h_spl_load_read; 309 310 err = spl_load_rkfw_image(spl_image, &load); 311 if (!err || err != -EAGAIN) 312 return err; 313 #endif 314 boot_mode = spl_boot_mode(bootdev->boot_device); 315 err = -EINVAL; 316 switch (boot_mode) { 317 case MMCSD_MODE_EMMCBOOT: 318 /* 319 * We need to check what the partition is configured to. 320 * 1 and 2 match up to boot0 / boot1 and 7 is user data 321 * which is the first physical partition (0). 322 */ 323 part = (mmc->part_config >> 3) & PART_ACCESS_MASK; 324 325 if (part == 7) 326 part = 0; 327 328 if (CONFIG_IS_ENABLED(MMC_TINY)) 329 err = mmc_switch_part(mmc, part); 330 else 331 err = blk_dselect_hwpart(mmc_get_blk_desc(mmc), part); 332 333 if (err) { 334 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 335 puts("spl: mmc partition switch failed\n"); 336 #endif 337 return err; 338 } 339 /* Fall through */ 340 case MMCSD_MODE_RAW: 341 debug("spl: mmc boot mode: raw\n"); 342 343 if (!spl_start_uboot()) { 344 err = mmc_load_image_raw_os(spl_image, mmc); 345 if (!err) 346 return err; 347 } 348 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION 349 err = mmc_load_image_raw_partition(spl_image, mmc, 350 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION); 351 if (!err) 352 return err; 353 #endif 354 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR 355 err = mmc_load_image_raw_sector(spl_image, mmc, 356 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); 357 if (!err) 358 return err; 359 #endif 360 /* If RAW mode fails, try FS mode. */ 361 case MMCSD_MODE_FS: 362 debug("spl: mmc boot mode: fs\n"); 363 364 err = spl_mmc_do_fs_boot(spl_image, mmc); 365 if (!err) 366 return err; 367 368 break; 369 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT 370 default: 371 puts("spl: mmc: wrong boot mode\n"); 372 #endif 373 } 374 375 return err; 376 } 377 378 SPL_LOAD_IMAGE_METHOD("MMC1", 0, BOOT_DEVICE_MMC1, spl_mmc_load_image); 379 SPL_LOAD_IMAGE_METHOD("MMC2", 0, BOOT_DEVICE_MMC2, spl_mmc_load_image); 380 SPL_LOAD_IMAGE_METHOD("MMC2_2", 0, BOOT_DEVICE_MMC2_2, spl_mmc_load_image); 381