spl_mmc.c 10 KB

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