env_flash.c 9.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366
  1. /*
  2. * (C) Copyright 2000-2002
  3. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  4. *
  5. * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
  6. * Andreas Heppel <aheppel@sysgo.de>
  7. * See file CREDITS for list of people who contributed to this
  8. * project.
  9. *
  10. * This program is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU General Public License as
  12. * published by the Free Software Foundation; either version 2 of
  13. * the License, or (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  23. * MA 02111-1307 USA
  24. */
  25. /* #define DEBUG */
  26. #include <common.h>
  27. #include <command.h>
  28. #include <environment.h>
  29. #include <linux/stddef.h>
  30. #include <malloc.h>
  31. DECLARE_GLOBAL_DATA_PTR;
  32. #if defined(CONFIG_CMD_SAVEENV) && defined(CONFIG_CMD_FLASH)
  33. #define CMD_SAVEENV
  34. #elif defined(CONFIG_ENV_ADDR_REDUND)
  35. #error Cannot use CONFIG_ENV_ADDR_REDUND without CONFIG_CMD_SAVEENV & CONFIG_CMD_FLASH
  36. #endif
  37. #if defined(CONFIG_ENV_SIZE_REDUND) && (CONFIG_ENV_SIZE_REDUND < CONFIG_ENV_SIZE)
  38. #error CONFIG_ENV_SIZE_REDUND should not be less then CONFIG_ENV_SIZE
  39. #endif
  40. char * env_name_spec = "Flash";
  41. #ifdef ENV_IS_EMBEDDED
  42. extern uchar environment[];
  43. env_t *env_ptr = (env_t *)(&environment[0]);
  44. #ifdef CMD_SAVEENV
  45. /* static env_t *flash_addr = (env_t *)(&environment[0]);-broken on ARM-wd-*/
  46. static env_t *flash_addr = (env_t *)CONFIG_ENV_ADDR;
  47. #endif
  48. #else /* ! ENV_IS_EMBEDDED */
  49. env_t *env_ptr = (env_t *)CONFIG_ENV_ADDR;
  50. #ifdef CMD_SAVEENV
  51. static env_t *flash_addr = (env_t *)CONFIG_ENV_ADDR;
  52. #endif
  53. #endif /* ENV_IS_EMBEDDED */
  54. #ifdef CONFIG_ENV_ADDR_REDUND
  55. static env_t *flash_addr_new = (env_t *)CONFIG_ENV_ADDR_REDUND;
  56. /* CONFIG_ENV_ADDR is supposed to be on sector boundary */
  57. static ulong end_addr = CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1;
  58. static ulong end_addr_new = CONFIG_ENV_ADDR_REDUND + CONFIG_ENV_SECT_SIZE - 1;
  59. #endif /* CONFIG_ENV_ADDR_REDUND */
  60. extern uchar default_environment[];
  61. uchar env_get_char_spec (int index)
  62. {
  63. return ( *((uchar *)(gd->env_addr + index)) );
  64. }
  65. #ifdef CONFIG_ENV_ADDR_REDUND
  66. int env_init(void)
  67. {
  68. int crc1_ok = 0, crc2_ok = 0;
  69. uchar flag1 = flash_addr->flags;
  70. uchar flag2 = flash_addr_new->flags;
  71. ulong addr_default = (ulong)&default_environment[0];
  72. ulong addr1 = (ulong)&(flash_addr->data);
  73. ulong addr2 = (ulong)&(flash_addr_new->data);
  74. crc1_ok = (crc32(0, flash_addr->data, ENV_SIZE) == flash_addr->crc);
  75. crc2_ok = (crc32(0, flash_addr_new->data, ENV_SIZE) == flash_addr_new->crc);
  76. if (crc1_ok && ! crc2_ok) {
  77. gd->env_addr = addr1;
  78. gd->env_valid = 1;
  79. } else if (! crc1_ok && crc2_ok) {
  80. gd->env_addr = addr2;
  81. gd->env_valid = 1;
  82. } else if (! crc1_ok && ! crc2_ok) {
  83. gd->env_addr = addr_default;
  84. gd->env_valid = 0;
  85. } else if (flag1 == ACTIVE_FLAG && flag2 == OBSOLETE_FLAG) {
  86. gd->env_addr = addr1;
  87. gd->env_valid = 1;
  88. } else if (flag1 == OBSOLETE_FLAG && flag2 == ACTIVE_FLAG) {
  89. gd->env_addr = addr2;
  90. gd->env_valid = 1;
  91. } else if (flag1 == flag2) {
  92. gd->env_addr = addr1;
  93. gd->env_valid = 2;
  94. } else if (flag1 == 0xFF) {
  95. gd->env_addr = addr1;
  96. gd->env_valid = 2;
  97. } else if (flag2 == 0xFF) {
  98. gd->env_addr = addr2;
  99. gd->env_valid = 2;
  100. }
  101. return (0);
  102. }
  103. #ifdef CMD_SAVEENV
  104. int saveenv(void)
  105. {
  106. char *saved_data = NULL;
  107. int rc = 1;
  108. char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG;
  109. #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
  110. ulong up_data = 0;
  111. #endif
  112. debug ("Protect off %08lX ... %08lX\n",
  113. (ulong)flash_addr, end_addr);
  114. if (flash_sect_protect (0, (ulong)flash_addr, end_addr)) {
  115. goto Done;
  116. }
  117. debug ("Protect off %08lX ... %08lX\n",
  118. (ulong)flash_addr_new, end_addr_new);
  119. if (flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new)) {
  120. goto Done;
  121. }
  122. #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
  123. up_data = (end_addr_new + 1 - ((long)flash_addr_new + CONFIG_ENV_SIZE));
  124. debug ("Data to save 0x%x\n", up_data);
  125. if (up_data) {
  126. if ((saved_data = malloc(up_data)) == NULL) {
  127. printf("Unable to save the rest of sector (%ld)\n",
  128. up_data);
  129. goto Done;
  130. }
  131. memcpy(saved_data,
  132. (void *)((long)flash_addr_new + CONFIG_ENV_SIZE), up_data);
  133. debug ("Data (start 0x%x, len 0x%x) saved at 0x%x\n",
  134. (long)flash_addr_new + CONFIG_ENV_SIZE,
  135. up_data, saved_data);
  136. }
  137. #endif
  138. puts ("Erasing Flash...");
  139. debug (" %08lX ... %08lX ...",
  140. (ulong)flash_addr_new, end_addr_new);
  141. if (flash_sect_erase ((ulong)flash_addr_new, end_addr_new)) {
  142. goto Done;
  143. }
  144. puts ("Writing to Flash... ");
  145. debug (" %08lX ... %08lX ...",
  146. (ulong)&(flash_addr_new->data),
  147. sizeof(env_ptr->data)+(ulong)&(flash_addr_new->data));
  148. if ((rc = flash_write((char *)env_ptr->data,
  149. (ulong)&(flash_addr_new->data),
  150. sizeof(env_ptr->data))) ||
  151. (rc = flash_write((char *)&(env_ptr->crc),
  152. (ulong)&(flash_addr_new->crc),
  153. sizeof(env_ptr->crc))) ||
  154. (rc = flash_write(&flag,
  155. (ulong)&(flash_addr->flags),
  156. sizeof(flash_addr->flags))) ||
  157. (rc = flash_write(&new_flag,
  158. (ulong)&(flash_addr_new->flags),
  159. sizeof(flash_addr_new->flags))))
  160. {
  161. flash_perror (rc);
  162. goto Done;
  163. }
  164. puts ("done\n");
  165. #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
  166. if (up_data) { /* restore the rest of sector */
  167. debug ("Restoring the rest of data to 0x%x len 0x%x\n",
  168. (long)flash_addr_new + CONFIG_ENV_SIZE, up_data);
  169. if (flash_write(saved_data,
  170. (long)flash_addr_new + CONFIG_ENV_SIZE,
  171. up_data)) {
  172. flash_perror(rc);
  173. goto Done;
  174. }
  175. }
  176. #endif
  177. {
  178. env_t * etmp = flash_addr;
  179. ulong ltmp = end_addr;
  180. flash_addr = flash_addr_new;
  181. flash_addr_new = etmp;
  182. end_addr = end_addr_new;
  183. end_addr_new = ltmp;
  184. }
  185. rc = 0;
  186. Done:
  187. if (saved_data)
  188. free (saved_data);
  189. /* try to re-protect */
  190. (void) flash_sect_protect (1, (ulong)flash_addr, end_addr);
  191. (void) flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
  192. return rc;
  193. }
  194. #endif /* CMD_SAVEENV */
  195. #else /* ! CONFIG_ENV_ADDR_REDUND */
  196. int env_init(void)
  197. {
  198. if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
  199. gd->env_addr = (ulong)&(env_ptr->data);
  200. gd->env_valid = 1;
  201. return(0);
  202. }
  203. gd->env_addr = (ulong)&default_environment[0];
  204. gd->env_valid = 0;
  205. return (0);
  206. }
  207. #ifdef CMD_SAVEENV
  208. int saveenv(void)
  209. {
  210. int len, rc;
  211. ulong end_addr;
  212. ulong flash_sect_addr;
  213. #if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE)
  214. ulong flash_offset;
  215. uchar env_buffer[CONFIG_ENV_SECT_SIZE];
  216. #else
  217. uchar *env_buffer = (uchar *)env_ptr;
  218. #endif /* CONFIG_ENV_SECT_SIZE */
  219. int rcode = 0;
  220. #if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE)
  221. flash_offset = ((ulong)flash_addr) & (CONFIG_ENV_SECT_SIZE-1);
  222. flash_sect_addr = ((ulong)flash_addr) & ~(CONFIG_ENV_SECT_SIZE-1);
  223. debug ( "copy old content: "
  224. "sect_addr: %08lX env_addr: %08lX offset: %08lX\n",
  225. flash_sect_addr, (ulong)flash_addr, flash_offset);
  226. /* copy old contents to temporary buffer */
  227. memcpy (env_buffer, (void *)flash_sect_addr, CONFIG_ENV_SECT_SIZE);
  228. /* copy current environment to temporary buffer */
  229. memcpy ((uchar *)((unsigned long)env_buffer + flash_offset),
  230. env_ptr,
  231. CONFIG_ENV_SIZE);
  232. len = CONFIG_ENV_SECT_SIZE;
  233. #else
  234. flash_sect_addr = (ulong)flash_addr;
  235. len = CONFIG_ENV_SIZE;
  236. #endif /* CONFIG_ENV_SECT_SIZE */
  237. end_addr = flash_sect_addr + len - 1;
  238. debug ("Protect off %08lX ... %08lX\n",
  239. (ulong)flash_sect_addr, end_addr);
  240. if (flash_sect_protect (0, flash_sect_addr, end_addr))
  241. return 1;
  242. puts ("Erasing Flash...");
  243. if (flash_sect_erase (flash_sect_addr, end_addr))
  244. return 1;
  245. puts ("Writing to Flash... ");
  246. rc = flash_write((char *)env_buffer, flash_sect_addr, len);
  247. if (rc != 0) {
  248. flash_perror (rc);
  249. rcode = 1;
  250. } else {
  251. puts ("done\n");
  252. }
  253. /* try to re-protect */
  254. (void) flash_sect_protect (1, flash_sect_addr, end_addr);
  255. return rcode;
  256. }
  257. #endif /* CMD_SAVEENV */
  258. #endif /* CONFIG_ENV_ADDR_REDUND */
  259. void env_relocate_spec (void)
  260. {
  261. #if !defined(ENV_IS_EMBEDDED) || defined(CONFIG_ENV_ADDR_REDUND)
  262. #ifdef CONFIG_ENV_ADDR_REDUND
  263. if (gd->env_addr != (ulong)&(flash_addr->data)) {
  264. env_t * etmp = flash_addr;
  265. ulong ltmp = end_addr;
  266. flash_addr = flash_addr_new;
  267. flash_addr_new = etmp;
  268. end_addr = end_addr_new;
  269. end_addr_new = ltmp;
  270. }
  271. if (flash_addr_new->flags != OBSOLETE_FLAG &&
  272. crc32(0, flash_addr_new->data, ENV_SIZE) ==
  273. flash_addr_new->crc) {
  274. char flag = OBSOLETE_FLAG;
  275. gd->env_valid = 2;
  276. flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new);
  277. flash_write(&flag,
  278. (ulong)&(flash_addr_new->flags),
  279. sizeof(flash_addr_new->flags));
  280. flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
  281. }
  282. if (flash_addr->flags != ACTIVE_FLAG &&
  283. (flash_addr->flags & ACTIVE_FLAG) == ACTIVE_FLAG) {
  284. char flag = ACTIVE_FLAG;
  285. gd->env_valid = 2;
  286. flash_sect_protect (0, (ulong)flash_addr, end_addr);
  287. flash_write(&flag,
  288. (ulong)&(flash_addr->flags),
  289. sizeof(flash_addr->flags));
  290. flash_sect_protect (1, (ulong)flash_addr, end_addr);
  291. }
  292. if (gd->env_valid == 2)
  293. puts ("*** Warning - some problems detected "
  294. "reading environment; recovered successfully\n\n");
  295. #endif /* CONFIG_ENV_ADDR_REDUND */
  296. #ifdef CMD_SAVEENV
  297. memcpy (env_ptr, (void*)flash_addr, CONFIG_ENV_SIZE);
  298. #endif
  299. #endif /* ! ENV_IS_EMBEDDED || CONFIG_ENV_ADDR_REDUND */
  300. }