spl_mmc.c 10 KB

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