spl_mmc.c 11 KB

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