env_flash.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381
  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. #ifdef CONFIG_INFERNO
  41. # ifdef CONFIG_ENV_ADDR_REDUND
  42. #error CONFIG_ENV_ADDR_REDUND is not implemented for CONFIG_INFERNO
  43. # endif
  44. #endif
  45. char * env_name_spec = "Flash";
  46. #ifdef ENV_IS_EMBEDDED
  47. extern uchar environment[];
  48. env_t *env_ptr = (env_t *)(&environment[0]);
  49. #ifdef CMD_SAVEENV
  50. /* static env_t *flash_addr = (env_t *)(&environment[0]);-broken on ARM-wd-*/
  51. static env_t *flash_addr = (env_t *)CONFIG_ENV_ADDR;
  52. #endif
  53. #else /* ! ENV_IS_EMBEDDED */
  54. env_t *env_ptr = (env_t *)CONFIG_ENV_ADDR;
  55. #ifdef CMD_SAVEENV
  56. static env_t *flash_addr = (env_t *)CONFIG_ENV_ADDR;
  57. #endif
  58. #endif /* ENV_IS_EMBEDDED */
  59. #ifdef CONFIG_ENV_ADDR_REDUND
  60. static env_t *flash_addr_new = (env_t *)CONFIG_ENV_ADDR_REDUND;
  61. /* CONFIG_ENV_ADDR is supposed to be on sector boundary */
  62. static ulong end_addr = CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1;
  63. static ulong end_addr_new = CONFIG_ENV_ADDR_REDUND + CONFIG_ENV_SECT_SIZE - 1;
  64. #define ACTIVE_FLAG 1
  65. #define OBSOLETE_FLAG 0
  66. #endif /* CONFIG_ENV_ADDR_REDUND */
  67. extern uchar default_environment[];
  68. uchar env_get_char_spec (int index)
  69. {
  70. return ( *((uchar *)(gd->env_addr + index)) );
  71. }
  72. #ifdef CONFIG_ENV_ADDR_REDUND
  73. int env_init(void)
  74. {
  75. int crc1_ok = 0, crc2_ok = 0;
  76. uchar flag1 = flash_addr->flags;
  77. uchar flag2 = flash_addr_new->flags;
  78. ulong addr_default = (ulong)&default_environment[0];
  79. ulong addr1 = (ulong)&(flash_addr->data);
  80. ulong addr2 = (ulong)&(flash_addr_new->data);
  81. crc1_ok = (crc32(0, flash_addr->data, ENV_SIZE) == flash_addr->crc);
  82. crc2_ok = (crc32(0, flash_addr_new->data, ENV_SIZE) == flash_addr_new->crc);
  83. if (crc1_ok && ! crc2_ok) {
  84. gd->env_addr = addr1;
  85. gd->env_valid = 1;
  86. } else if (! crc1_ok && crc2_ok) {
  87. gd->env_addr = addr2;
  88. gd->env_valid = 1;
  89. } else if (! crc1_ok && ! crc2_ok) {
  90. gd->env_addr = addr_default;
  91. gd->env_valid = 0;
  92. } else if (flag1 == ACTIVE_FLAG && flag2 == OBSOLETE_FLAG) {
  93. gd->env_addr = addr1;
  94. gd->env_valid = 1;
  95. } else if (flag1 == OBSOLETE_FLAG && flag2 == ACTIVE_FLAG) {
  96. gd->env_addr = addr2;
  97. gd->env_valid = 1;
  98. } else if (flag1 == flag2) {
  99. gd->env_addr = addr1;
  100. gd->env_valid = 2;
  101. } else if (flag1 == 0xFF) {
  102. gd->env_addr = addr1;
  103. gd->env_valid = 2;
  104. } else if (flag2 == 0xFF) {
  105. gd->env_addr = addr2;
  106. gd->env_valid = 2;
  107. }
  108. return (0);
  109. }
  110. #ifdef CMD_SAVEENV
  111. int saveenv(void)
  112. {
  113. char *saved_data = NULL;
  114. int rc = 1;
  115. char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG;
  116. #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
  117. ulong up_data = 0;
  118. #endif
  119. debug ("Protect off %08lX ... %08lX\n",
  120. (ulong)flash_addr, end_addr);
  121. if (flash_sect_protect (0, (ulong)flash_addr, end_addr)) {
  122. goto Done;
  123. }
  124. debug ("Protect off %08lX ... %08lX\n",
  125. (ulong)flash_addr_new, end_addr_new);
  126. if (flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new)) {
  127. goto Done;
  128. }
  129. #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
  130. up_data = (end_addr_new + 1 - ((long)flash_addr_new + CONFIG_ENV_SIZE));
  131. debug ("Data to save 0x%x\n", up_data);
  132. if (up_data) {
  133. if ((saved_data = malloc(up_data)) == NULL) {
  134. printf("Unable to save the rest of sector (%ld)\n",
  135. up_data);
  136. goto Done;
  137. }
  138. memcpy(saved_data,
  139. (void *)((long)flash_addr_new + CONFIG_ENV_SIZE), up_data);
  140. debug ("Data (start 0x%x, len 0x%x) saved at 0x%x\n",
  141. (long)flash_addr_new + CONFIG_ENV_SIZE,
  142. up_data, saved_data);
  143. }
  144. #endif
  145. puts ("Erasing Flash...");
  146. debug (" %08lX ... %08lX ...",
  147. (ulong)flash_addr_new, end_addr_new);
  148. if (flash_sect_erase ((ulong)flash_addr_new, end_addr_new)) {
  149. goto Done;
  150. }
  151. puts ("Writing to Flash... ");
  152. debug (" %08lX ... %08lX ...",
  153. (ulong)&(flash_addr_new->data),
  154. sizeof(env_ptr->data)+(ulong)&(flash_addr_new->data));
  155. if ((rc = flash_write((char *)env_ptr->data,
  156. (ulong)&(flash_addr_new->data),
  157. sizeof(env_ptr->data))) ||
  158. (rc = flash_write((char *)&(env_ptr->crc),
  159. (ulong)&(flash_addr_new->crc),
  160. sizeof(env_ptr->crc))) ||
  161. (rc = flash_write(&flag,
  162. (ulong)&(flash_addr->flags),
  163. sizeof(flash_addr->flags))) ||
  164. (rc = flash_write(&new_flag,
  165. (ulong)&(flash_addr_new->flags),
  166. sizeof(flash_addr_new->flags))))
  167. {
  168. flash_perror (rc);
  169. goto Done;
  170. }
  171. puts ("done\n");
  172. #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
  173. if (up_data) { /* restore the rest of sector */
  174. debug ("Restoring the rest of data to 0x%x len 0x%x\n",
  175. (long)flash_addr_new + CONFIG_ENV_SIZE, up_data);
  176. if (flash_write(saved_data,
  177. (long)flash_addr_new + CONFIG_ENV_SIZE,
  178. up_data)) {
  179. flash_perror(rc);
  180. goto Done;
  181. }
  182. }
  183. #endif
  184. {
  185. env_t * etmp = flash_addr;
  186. ulong ltmp = end_addr;
  187. flash_addr = flash_addr_new;
  188. flash_addr_new = etmp;
  189. end_addr = end_addr_new;
  190. end_addr_new = ltmp;
  191. }
  192. rc = 0;
  193. Done:
  194. if (saved_data)
  195. free (saved_data);
  196. /* try to re-protect */
  197. (void) flash_sect_protect (1, (ulong)flash_addr, end_addr);
  198. (void) flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
  199. return rc;
  200. }
  201. #endif /* CMD_SAVEENV */
  202. #else /* ! CONFIG_ENV_ADDR_REDUND */
  203. int env_init(void)
  204. {
  205. if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
  206. gd->env_addr = (ulong)&(env_ptr->data);
  207. gd->env_valid = 1;
  208. return(0);
  209. }
  210. gd->env_addr = (ulong)&default_environment[0];
  211. gd->env_valid = 0;
  212. return (0);
  213. }
  214. #ifdef CMD_SAVEENV
  215. int saveenv(void)
  216. {
  217. int len, rc;
  218. ulong end_addr;
  219. ulong flash_sect_addr;
  220. #if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE)
  221. ulong flash_offset;
  222. uchar env_buffer[CONFIG_ENV_SECT_SIZE];
  223. #else
  224. uchar *env_buffer = (uchar *)env_ptr;
  225. #endif /* CONFIG_ENV_SECT_SIZE */
  226. int rcode = 0;
  227. #if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE)
  228. flash_offset = ((ulong)flash_addr) & (CONFIG_ENV_SECT_SIZE-1);
  229. flash_sect_addr = ((ulong)flash_addr) & ~(CONFIG_ENV_SECT_SIZE-1);
  230. debug ( "copy old content: "
  231. "sect_addr: %08lX env_addr: %08lX offset: %08lX\n",
  232. flash_sect_addr, (ulong)flash_addr, flash_offset);
  233. /* copy old contents to temporary buffer */
  234. memcpy (env_buffer, (void *)flash_sect_addr, CONFIG_ENV_SECT_SIZE);
  235. /* copy current environment to temporary buffer */
  236. memcpy ((uchar *)((unsigned long)env_buffer + flash_offset),
  237. env_ptr,
  238. CONFIG_ENV_SIZE);
  239. len = CONFIG_ENV_SECT_SIZE;
  240. #else
  241. flash_sect_addr = (ulong)flash_addr;
  242. len = CONFIG_ENV_SIZE;
  243. #endif /* CONFIG_ENV_SECT_SIZE */
  244. #ifndef CONFIG_INFERNO
  245. end_addr = flash_sect_addr + len - 1;
  246. #else
  247. /* this is the last sector, and the size is hardcoded here */
  248. /* otherwise we will get stack problems on loading 128 KB environment */
  249. end_addr = flash_sect_addr + 0x20000 - 1;
  250. #endif
  251. debug ("Protect off %08lX ... %08lX\n",
  252. (ulong)flash_sect_addr, end_addr);
  253. if (flash_sect_protect (0, flash_sect_addr, end_addr))
  254. return 1;
  255. puts ("Erasing Flash...");
  256. if (flash_sect_erase (flash_sect_addr, end_addr))
  257. return 1;
  258. puts ("Writing to Flash... ");
  259. rc = flash_write((char *)env_buffer, flash_sect_addr, len);
  260. if (rc != 0) {
  261. flash_perror (rc);
  262. rcode = 1;
  263. } else {
  264. puts ("done\n");
  265. }
  266. /* try to re-protect */
  267. (void) flash_sect_protect (1, flash_sect_addr, end_addr);
  268. return rcode;
  269. }
  270. #endif /* CMD_SAVEENV */
  271. #endif /* CONFIG_ENV_ADDR_REDUND */
  272. void env_relocate_spec (void)
  273. {
  274. #if !defined(ENV_IS_EMBEDDED) || defined(CONFIG_ENV_ADDR_REDUND)
  275. #ifdef CONFIG_ENV_ADDR_REDUND
  276. if (gd->env_addr != (ulong)&(flash_addr->data)) {
  277. env_t * etmp = flash_addr;
  278. ulong ltmp = end_addr;
  279. flash_addr = flash_addr_new;
  280. flash_addr_new = etmp;
  281. end_addr = end_addr_new;
  282. end_addr_new = ltmp;
  283. }
  284. if (flash_addr_new->flags != OBSOLETE_FLAG &&
  285. crc32(0, flash_addr_new->data, ENV_SIZE) ==
  286. flash_addr_new->crc) {
  287. char flag = OBSOLETE_FLAG;
  288. gd->env_valid = 2;
  289. flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new);
  290. flash_write(&flag,
  291. (ulong)&(flash_addr_new->flags),
  292. sizeof(flash_addr_new->flags));
  293. flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
  294. }
  295. if (flash_addr->flags != ACTIVE_FLAG &&
  296. (flash_addr->flags & ACTIVE_FLAG) == ACTIVE_FLAG) {
  297. char flag = ACTIVE_FLAG;
  298. gd->env_valid = 2;
  299. flash_sect_protect (0, (ulong)flash_addr, end_addr);
  300. flash_write(&flag,
  301. (ulong)&(flash_addr->flags),
  302. sizeof(flash_addr->flags));
  303. flash_sect_protect (1, (ulong)flash_addr, end_addr);
  304. }
  305. if (gd->env_valid == 2)
  306. puts ("*** Warning - some problems detected "
  307. "reading environment; recovered successfully\n\n");
  308. #endif /* CONFIG_ENV_ADDR_REDUND */
  309. #ifdef CMD_SAVEENV
  310. memcpy (env_ptr, (void*)flash_addr, CONFIG_ENV_SIZE);
  311. #endif
  312. #endif /* ! ENV_IS_EMBEDDED || CONFIG_ENV_ADDR_REDUND */
  313. }