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