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