env_mmc.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337
  1. /*
  2. * (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
  3. *
  4. * SPDX-License-Identifier: GPL-2.0+
  5. */
  6. /* #define DEBUG */
  7. #include <common.h>
  8. #include <command.h>
  9. #include <environment.h>
  10. #include <linux/stddef.h>
  11. #include <malloc.h>
  12. #include <memalign.h>
  13. #include <mmc.h>
  14. #include <search.h>
  15. #include <errno.h>
  16. #if defined(CONFIG_ENV_SIZE_REDUND) && \
  17. (CONFIG_ENV_SIZE_REDUND != CONFIG_ENV_SIZE)
  18. #error CONFIG_ENV_SIZE_REDUND should be the same as CONFIG_ENV_SIZE
  19. #endif
  20. char *env_name_spec = "MMC";
  21. #ifdef ENV_IS_EMBEDDED
  22. env_t *env_ptr = &environment;
  23. #else /* ! ENV_IS_EMBEDDED */
  24. env_t *env_ptr;
  25. #endif /* ENV_IS_EMBEDDED */
  26. DECLARE_GLOBAL_DATA_PTR;
  27. #if !defined(CONFIG_ENV_OFFSET)
  28. #define CONFIG_ENV_OFFSET 0
  29. #endif
  30. __weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
  31. {
  32. s64 offset;
  33. offset = CONFIG_ENV_OFFSET;
  34. #ifdef CONFIG_ENV_OFFSET_REDUND
  35. if (copy)
  36. offset = CONFIG_ENV_OFFSET_REDUND;
  37. #endif
  38. if (offset < 0)
  39. offset += mmc->capacity;
  40. *env_addr = offset;
  41. return 0;
  42. }
  43. int env_init(void)
  44. {
  45. /* use default */
  46. gd->env_addr = (ulong)&default_environment[0];
  47. gd->env_valid = 1;
  48. return 0;
  49. }
  50. #ifdef CONFIG_SYS_MMC_ENV_PART
  51. __weak uint mmc_get_env_part(struct mmc *mmc)
  52. {
  53. return CONFIG_SYS_MMC_ENV_PART;
  54. }
  55. static int mmc_set_env_part(struct mmc *mmc)
  56. {
  57. uint part = mmc_get_env_part(mmc);
  58. int dev = CONFIG_SYS_MMC_ENV_DEV;
  59. int ret = 0;
  60. #ifdef CONFIG_SPL_BUILD
  61. dev = 0;
  62. #endif
  63. if (part != mmc->part_num) {
  64. ret = mmc_switch_part(dev, part);
  65. if (ret)
  66. puts("MMC partition switch failed\n");
  67. }
  68. return ret;
  69. }
  70. #else
  71. static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
  72. #endif
  73. static const char *init_mmc_for_env(struct mmc *mmc)
  74. {
  75. if (!mmc)
  76. return "!No MMC card found";
  77. if (mmc_init(mmc))
  78. return "!MMC init failed";
  79. if (mmc_set_env_part(mmc))
  80. return "!MMC partition switch failed";
  81. return NULL;
  82. }
  83. static void fini_mmc_for_env(struct mmc *mmc)
  84. {
  85. #ifdef CONFIG_SYS_MMC_ENV_PART
  86. int dev = CONFIG_SYS_MMC_ENV_DEV;
  87. #ifdef CONFIG_SPL_BUILD
  88. dev = 0;
  89. #endif
  90. if (mmc_get_env_part(mmc) != mmc->part_num)
  91. mmc_switch_part(dev, mmc->part_num);
  92. #endif
  93. }
  94. #ifdef CONFIG_CMD_SAVEENV
  95. static inline int write_env(struct mmc *mmc, unsigned long size,
  96. unsigned long offset, const void *buffer)
  97. {
  98. uint blk_start, blk_cnt, n;
  99. blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
  100. blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
  101. n = mmc->block_dev.block_write(&mmc->block_dev, blk_start,
  102. blk_cnt, (u_char *)buffer);
  103. return (n == blk_cnt) ? 0 : -1;
  104. }
  105. #ifdef CONFIG_ENV_OFFSET_REDUND
  106. static unsigned char env_flags;
  107. #endif
  108. int saveenv(void)
  109. {
  110. ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
  111. struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
  112. u32 offset;
  113. int ret, copy = 0;
  114. const char *errmsg;
  115. errmsg = init_mmc_for_env(mmc);
  116. if (errmsg) {
  117. printf("%s\n", errmsg);
  118. return 1;
  119. }
  120. ret = env_export(env_new);
  121. if (ret)
  122. goto fini;
  123. #ifdef CONFIG_ENV_OFFSET_REDUND
  124. env_new->flags = ++env_flags; /* increase the serial */
  125. if (gd->env_valid == 1)
  126. copy = 1;
  127. #endif
  128. if (mmc_get_env_addr(mmc, copy, &offset)) {
  129. ret = 1;
  130. goto fini;
  131. }
  132. printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "",
  133. CONFIG_SYS_MMC_ENV_DEV);
  134. if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
  135. puts("failed\n");
  136. ret = 1;
  137. goto fini;
  138. }
  139. puts("done\n");
  140. ret = 0;
  141. #ifdef CONFIG_ENV_OFFSET_REDUND
  142. gd->env_valid = gd->env_valid == 2 ? 1 : 2;
  143. #endif
  144. fini:
  145. fini_mmc_for_env(mmc);
  146. return ret;
  147. }
  148. #endif /* CONFIG_CMD_SAVEENV */
  149. static inline int read_env(struct mmc *mmc, unsigned long size,
  150. unsigned long offset, const void *buffer)
  151. {
  152. uint blk_start, blk_cnt, n;
  153. blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
  154. blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
  155. n = mmc->block_dev.block_read(&mmc->block_dev, blk_start, blk_cnt,
  156. (uchar *)buffer);
  157. return (n == blk_cnt) ? 0 : -1;
  158. }
  159. #ifdef CONFIG_ENV_OFFSET_REDUND
  160. void env_relocate_spec(void)
  161. {
  162. #if !defined(ENV_IS_EMBEDDED)
  163. struct mmc *mmc;
  164. u32 offset1, offset2;
  165. int read1_fail = 0, read2_fail = 0;
  166. int crc1_ok = 0, crc2_ok = 0;
  167. env_t *ep;
  168. int ret;
  169. int dev = CONFIG_SYS_MMC_ENV_DEV;
  170. const char *errmsg = NULL;
  171. ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
  172. ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
  173. #ifdef CONFIG_SPL_BUILD
  174. dev = 0;
  175. #endif
  176. mmc = find_mmc_device(dev);
  177. errmsg = init_mmc_for_env(mmc);
  178. if (errmsg) {
  179. ret = 1;
  180. goto err;
  181. }
  182. if (mmc_get_env_addr(mmc, 0, &offset1) ||
  183. mmc_get_env_addr(mmc, 1, &offset2)) {
  184. ret = 1;
  185. goto fini;
  186. }
  187. read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
  188. read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
  189. if (read1_fail && read2_fail)
  190. puts("*** Error - No Valid Environment Area found\n");
  191. else if (read1_fail || read2_fail)
  192. puts("*** Warning - some problems detected "
  193. "reading environment; recovered successfully\n");
  194. crc1_ok = !read1_fail &&
  195. (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
  196. crc2_ok = !read2_fail &&
  197. (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
  198. if (!crc1_ok && !crc2_ok) {
  199. errmsg = "!bad CRC";
  200. ret = 1;
  201. goto fini;
  202. } else if (crc1_ok && !crc2_ok) {
  203. gd->env_valid = 1;
  204. } else if (!crc1_ok && crc2_ok) {
  205. gd->env_valid = 2;
  206. } else {
  207. /* both ok - check serial */
  208. if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
  209. gd->env_valid = 2;
  210. else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
  211. gd->env_valid = 1;
  212. else if (tmp_env1->flags > tmp_env2->flags)
  213. gd->env_valid = 1;
  214. else if (tmp_env2->flags > tmp_env1->flags)
  215. gd->env_valid = 2;
  216. else /* flags are equal - almost impossible */
  217. gd->env_valid = 1;
  218. }
  219. free(env_ptr);
  220. if (gd->env_valid == 1)
  221. ep = tmp_env1;
  222. else
  223. ep = tmp_env2;
  224. env_flags = ep->flags;
  225. env_import((char *)ep, 0);
  226. ret = 0;
  227. fini:
  228. fini_mmc_for_env(mmc);
  229. err:
  230. if (ret)
  231. set_default_env(errmsg);
  232. #endif
  233. }
  234. #else /* ! CONFIG_ENV_OFFSET_REDUND */
  235. void env_relocate_spec(void)
  236. {
  237. #if !defined(ENV_IS_EMBEDDED)
  238. ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
  239. struct mmc *mmc;
  240. u32 offset;
  241. int ret;
  242. int dev = CONFIG_SYS_MMC_ENV_DEV;
  243. const char *errmsg;
  244. #ifdef CONFIG_SPL_BUILD
  245. dev = 0;
  246. #endif
  247. mmc = find_mmc_device(dev);
  248. errmsg = init_mmc_for_env(mmc);
  249. if (errmsg) {
  250. ret = 1;
  251. goto err;
  252. }
  253. if (mmc_get_env_addr(mmc, 0, &offset)) {
  254. ret = 1;
  255. goto fini;
  256. }
  257. if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
  258. errmsg = "!read failed";
  259. ret = 1;
  260. goto fini;
  261. }
  262. env_import(buf, 1);
  263. ret = 0;
  264. fini:
  265. fini_mmc_for_env(mmc);
  266. err:
  267. if (ret)
  268. set_default_env(errmsg);
  269. #endif
  270. }
  271. #endif /* CONFIG_ENV_OFFSET_REDUND */