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