spl_mmc.c 10 KB

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