spl_mmc.c 10.0 KB

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