2 * (C) Copyright 2000-2002
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
6 * Andreas Heppel <aheppel@sysgo.de>
8 * See file CREDITS for list of people who contributed to this
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of
14 * the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
31 #if defined(CFG_ENV_IS_IN_FLASH) /* Environment is in Flash */
34 #include <environment.h>
35 #include <linux/stddef.h>
38 #if ((CONFIG_COMMANDS&(CFG_CMD_ENV|CFG_CMD_FLASH)) == (CFG_CMD_ENV|CFG_CMD_FLASH))
40 #elif defined(CFG_ENV_ADDR_REDUND)
41 #error Cannot use CFG_ENV_ADDR_REDUND without CFG_CMD_ENV & CFG_CMD_FLASH
44 #if defined(CFG_ENV_SIZE_REDUND) && (CFG_ENV_SIZE_REDUND < CFG_ENV_SIZE)
45 #error CFG_ENV_SIZE_REDUND should not be less then CFG_ENV_SIZE
49 # ifdef CFG_ENV_ADDR_REDUND
50 #error CFG_ENV_ADDR_REDUND is not implemented for CONFIG_INFERNO
54 char * env_name_spec = "Flash";
56 #ifdef ENV_IS_EMBEDDED
58 extern uchar environment[];
59 env_t *env_ptr = (env_t *)(&environment[0]);
62 /* static env_t *flash_addr = (env_t *)(&environment[0]);-broken on ARM-wd-*/
63 static env_t *flash_addr = (env_t *)CFG_ENV_ADDR;
66 #else /* ! ENV_IS_EMBEDDED */
68 env_t *env_ptr = (env_t *)CFG_ENV_ADDR;
70 static env_t *flash_addr = (env_t *)CFG_ENV_ADDR;
73 #endif /* ENV_IS_EMBEDDED */
75 #ifdef CFG_ENV_ADDR_REDUND
76 static env_t *flash_addr_new = (env_t *)CFG_ENV_ADDR_REDUND;
78 /* CFG_ENV_ADDR is supposed to be on sector boundary */
79 static ulong end_addr = CFG_ENV_ADDR + CFG_ENV_SECT_SIZE - 1;
80 static ulong end_addr_new = CFG_ENV_ADDR_REDUND + CFG_ENV_SECT_SIZE - 1;
83 #define OBSOLETE_FLAG 0
84 #endif /* CFG_ENV_ADDR_REDUND */
86 extern uchar default_environment[];
87 extern int default_environment_size;
90 uchar env_get_char_spec (int index)
92 DECLARE_GLOBAL_DATA_PTR;
94 return ( *((uchar *)(gd->env_addr + index)) );
97 #ifdef CFG_ENV_ADDR_REDUND
101 DECLARE_GLOBAL_DATA_PTR;
104 (crc32(0, flash_addr->data, ENV_SIZE) == flash_addr->crc);
106 (crc32(0, flash_addr_new->data, ENV_SIZE) == flash_addr_new->crc);
108 uchar flag1 = flash_addr->flags;
109 uchar flag2 = flash_addr_new->flags;
111 ulong addr_default = (ulong)&default_environment[0];
112 ulong addr1 = (ulong)&(flash_addr->data);
113 ulong addr2 = (ulong)&(flash_addr_new->data);
115 if (crc1_ok && ! crc2_ok) {
116 gd->env_addr = addr1;
118 } else if (! crc1_ok && crc2_ok) {
119 gd->env_addr = addr2;
121 } else if (! crc1_ok && ! crc2_ok) {
122 gd->env_addr = addr_default;
124 } else if (flag1 == ACTIVE_FLAG && flag2 == OBSOLETE_FLAG) {
125 gd->env_addr = addr1;
127 } else if (flag1 == OBSOLETE_FLAG && flag2 == ACTIVE_FLAG) {
128 gd->env_addr = addr2;
130 } else if (flag1 == flag2) {
131 gd->env_addr = addr1;
133 } else if (flag1 == 0xFF) {
134 gd->env_addr = addr1;
136 } else if (flag2 == 0xFF) {
137 gd->env_addr = addr2;
147 char *saved_data = NULL;
149 char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG;
150 #if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE
154 debug ("Protect off %08lX ... %08lX\n",
155 (ulong)flash_addr, end_addr);
157 if (flash_sect_protect (0, (ulong)flash_addr, end_addr)) {
161 debug ("Protect off %08lX ... %08lX\n",
162 (ulong)flash_addr_new, end_addr_new);
164 if (flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new)) {
168 #if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE
169 up_data = (end_addr_new + 1 - ((long)flash_addr_new + CFG_ENV_SIZE));
170 debug ("Data to save 0x%x\n", up_data);
172 if ((saved_data = malloc(up_data)) == NULL) {
173 printf("Unable to save the rest of sector (%ld)\n",
178 (void *)((long)flash_addr_new + CFG_ENV_SIZE), up_data);
179 debug ("Data (start 0x%x, len 0x%x) saved at 0x%x\n",
180 (long)flash_addr_new + CFG_ENV_SIZE,
181 up_data, saved_data);
184 puts ("Erasing Flash...");
185 debug (" %08lX ... %08lX ...",
186 (ulong)flash_addr_new, end_addr_new);
188 if (flash_sect_erase ((ulong)flash_addr_new, end_addr_new)) {
192 puts ("Writing to Flash... ");
193 debug (" %08lX ... %08lX ...",
194 (ulong)&(flash_addr_new->data),
195 sizeof(env_ptr->data)+(ulong)&(flash_addr_new->data));
196 if ((rc = flash_write(env_ptr->data,
197 (ulong)&(flash_addr_new->data),
198 sizeof(env_ptr->data))) ||
199 (rc = flash_write((char *)&(env_ptr->crc),
200 (ulong)&(flash_addr_new->crc),
201 sizeof(env_ptr->crc))) ||
202 (rc = flash_write(&flag,
203 (ulong)&(flash_addr->flags),
204 sizeof(flash_addr->flags))) ||
205 (rc = flash_write(&new_flag,
206 (ulong)&(flash_addr_new->flags),
207 sizeof(flash_addr_new->flags))))
214 #if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE
215 if (up_data) { /* restore the rest of sector */
216 debug ("Restoring the rest of data to 0x%x len 0x%x\n",
217 (long)flash_addr_new + CFG_ENV_SIZE, up_data);
218 if (flash_write(saved_data,
219 (long)flash_addr_new + CFG_ENV_SIZE,
227 env_t * etmp = flash_addr;
228 ulong ltmp = end_addr;
230 flash_addr = flash_addr_new;
231 flash_addr_new = etmp;
233 end_addr = end_addr_new;
242 /* try to re-protect */
243 (void) flash_sect_protect (1, (ulong)flash_addr, end_addr);
244 (void) flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
248 #endif /* CMD_SAVEENV */
250 #else /* ! CFG_ENV_ADDR_REDUND */
254 DECLARE_GLOBAL_DATA_PTR;
256 if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
257 gd->env_addr = (ulong)&(env_ptr->data);
260 gd->env_addr = (ulong)&default_environment[0];
273 ulong flash_sect_addr;
274 #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE)
276 uchar env_buffer[CFG_ENV_SECT_SIZE];
278 uchar *env_buffer = (char *)env_ptr;
279 #endif /* CFG_ENV_SECT_SIZE */
282 #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE)
284 flash_offset = ((ulong)flash_addr) & (CFG_ENV_SECT_SIZE-1);
285 flash_sect_addr = ((ulong)flash_addr) & ~(CFG_ENV_SECT_SIZE-1);
287 debug ( "copy old content: "
288 "sect_addr: %08lX env_addr: %08lX offset: %08lX\n",
289 flash_sect_addr, (ulong)flash_addr, flash_offset);
291 /* copy old contents to temporary buffer */
292 memcpy (env_buffer, (void *)flash_sect_addr, CFG_ENV_SECT_SIZE);
294 /* copy current environment to temporary buffer */
295 memcpy ((uchar *)((unsigned long)env_buffer + flash_offset),
299 len = CFG_ENV_SECT_SIZE;
301 flash_sect_addr = (ulong)flash_addr;
303 #endif /* CFG_ENV_SECT_SIZE */
305 #ifndef CONFIG_INFERNO
306 end_addr = flash_sect_addr + len - 1;
308 /* this is the last sector, and the size is hardcoded here */
309 /* otherwise we will get stack problems on loading 128 KB environment */
310 end_addr = flash_sect_addr + 0x20000 - 1;
313 debug ("Protect off %08lX ... %08lX\n",
314 (ulong)flash_sect_addr, end_addr);
316 if (flash_sect_protect (0, flash_sect_addr, end_addr))
319 puts ("Erasing Flash...");
320 if (flash_sect_erase (flash_sect_addr, end_addr))
323 puts ("Writing to Flash... ");
324 rc = flash_write(env_buffer, flash_sect_addr, len);
332 /* try to re-protect */
333 (void) flash_sect_protect (1, flash_sect_addr, end_addr);
337 #endif /* CMD_SAVEENV */
339 #endif /* CFG_ENV_ADDR_REDUND */
341 void env_relocate_spec (void)
343 #if !defined(ENV_IS_EMBEDDED) || defined(CFG_ENV_ADDR_REDUND)
344 #ifdef CFG_ENV_ADDR_REDUND
345 DECLARE_GLOBAL_DATA_PTR;
347 if (gd->env_addr != (ulong)&(flash_addr->data)) {
348 env_t * etmp = flash_addr;
349 ulong ltmp = end_addr;
351 flash_addr = flash_addr_new;
352 flash_addr_new = etmp;
354 end_addr = end_addr_new;
358 if (flash_addr_new->flags != OBSOLETE_FLAG &&
359 crc32(0, flash_addr_new->data, ENV_SIZE) ==
360 flash_addr_new->crc) {
361 char flag = OBSOLETE_FLAG;
364 flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new);
366 (ulong)&(flash_addr_new->flags),
367 sizeof(flash_addr_new->flags));
368 flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
371 if (flash_addr->flags != ACTIVE_FLAG &&
372 (flash_addr->flags & ACTIVE_FLAG) == ACTIVE_FLAG) {
373 char flag = ACTIVE_FLAG;
376 flash_sect_protect (0, (ulong)flash_addr, end_addr);
378 (ulong)&(flash_addr->flags),
379 sizeof(flash_addr->flags));
380 flash_sect_protect (1, (ulong)flash_addr, end_addr);
383 if (gd->env_valid == 2)
384 puts ("*** Warning - some problems detected "
385 "reading environment; recovered successfully\n\n");
386 #endif /* CFG_ENV_ADDR_REDUND */
387 memcpy (env_ptr, (void*)flash_addr, CFG_ENV_SIZE);
388 #endif /* ! ENV_IS_EMBEDDED || CFG_ENV_ADDR_REDUND */
391 #endif /* CFG_ENV_IS_IN_FLASH */