env_flash.c 9.8 KB

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