common/env_flash.c

   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
   8  * See file CREDITS for list of people who contributed to this
   9  * project.
  10  *
  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.
  15  *
  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.
  20  *
  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,
  24  * MA 02111-1307 USA
  25  */
  26
  27 /* #define DEBUG */
  28
  29 #include <common.h>
  30
  31 #if defined(CFG_ENV_IS_IN_FLASH) /* Environment is in Flash */
  32
  33 #include <command.h>
  34 #include <environment.h>
  35 #include <linux/stddef.h>
  36 #include <malloc.h>
  37
  38 #if ((CONFIG_COMMANDS&(CFG_CMD_ENV|CFG_CMD_FLASH)) == (CFG_CMD_ENV|CFG_CMD_FLASH))
  39 #define CMD_SAVEENV
  40 #elif defined(CFG_ENV_ADDR_REDUND)
  41 #error Cannot use CFG_ENV_ADDR_REDUND without CFG_CMD_ENV & CFG_CMD_FLASH
  42 #endif
  43
  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
  46 #endif
  47
  48 #ifdef CONFIG_INFERNO
  49 # ifdef CFG_ENV_ADDR_REDUND
  50 #error CFG_ENV_ADDR_REDUND is not implemented for CONFIG_INFERNO
  51 # endif
  52 #endif
  53
  54 char * env_name_spec = "Flash";
  55
  56 #ifdef ENV_IS_EMBEDDED
  57
  58 extern uchar environment[];
  59 env_t *env_ptr = (env_t *)(&environment[0]);
  60
  61 #ifdef CMD_SAVEENV
  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;
  64 #endif
  65
  66 #else /* ! ENV_IS_EMBEDDED */
  67
  68 env_t *env_ptr = (env_t *)CFG_ENV_ADDR;
  69 #ifdef CMD_SAVEENV
  70 static env_t *flash_addr = (env_t *)CFG_ENV_ADDR;
  71 #endif
  72
  73 #endif /* ENV_IS_EMBEDDED */
  74
  75 #ifdef CFG_ENV_ADDR_REDUND
  76 static env_t *flash_addr_new = (env_t *)CFG_ENV_ADDR_REDUND;
  77
  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;
  81
  82 #define ACTIVE_FLAG   1
  83 #define OBSOLETE_FLAG 0
  84 #endif /* CFG_ENV_ADDR_REDUND */
  85
  86 extern uchar default_environment[];
  87 extern int default_environment_size;
  88
  89
  90 uchar env_get_char_spec (int index)
  91 {
  92         DECLARE_GLOBAL_DATA_PTR;
  93
  94         return ( *((uchar *)(gd->env_addr + index)) );
  95 }
  96
  97 #ifdef CFG_ENV_ADDR_REDUND
  98
  99 int  env_init(void)
 100 {
 101         DECLARE_GLOBAL_DATA_PTR;
 102
 103         int crc1_ok =
 104                 (crc32(0, flash_addr->data, ENV_SIZE) == flash_addr->crc);
 105         int crc2_ok =
 106                 (crc32(0, flash_addr_new->data, ENV_SIZE) == flash_addr_new->crc);
 107
 108         uchar flag1 = flash_addr->flags;
 109         uchar flag2 = flash_addr_new->flags;
 110
 111         ulong addr_default = (ulong)&default_environment[0];
 112         ulong addr1 = (ulong)&(flash_addr->data);
 113         ulong addr2 = (ulong)&(flash_addr_new->data);
 114
 115         if (crc1_ok && ! crc2_ok) {
 116                 gd->env_addr  = addr1;
 117                 gd->env_valid = 1;
 118         } else if (! crc1_ok && crc2_ok) {
 119                 gd->env_addr  = addr2;
 120                 gd->env_valid = 1;
 121         } else if (! crc1_ok && ! crc2_ok) {
 122                 gd->env_addr  = addr_default;
 123                 gd->env_valid = 0;
 124         } else if (flag1 == ACTIVE_FLAG && flag2 == OBSOLETE_FLAG) {
 125                 gd->env_addr  = addr1;
 126                 gd->env_valid = 1;
 127         } else if (flag1 == OBSOLETE_FLAG && flag2 == ACTIVE_FLAG) {
 128                 gd->env_addr  = addr2;
 129                 gd->env_valid = 1;
 130         } else if (flag1 == flag2) {
 131                 gd->env_addr  = addr1;
 132                 gd->env_valid = 2;
 133         } else if (flag1 == 0xFF) {
 134                 gd->env_addr  = addr1;
 135                 gd->env_valid = 2;
 136         } else if (flag2 == 0xFF) {
 137                 gd->env_addr  = addr2;
 138                 gd->env_valid = 2;
 139         }
 140
 141         return (0);
 142 }
 143
 144 #ifdef CMD_SAVEENV
 145 int saveenv(void)
 146 {
 147         char *saved_data = NULL;
 148         int rc = 1;
 149         char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG;
 150 #if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE
 151         ulong up_data = 0;
 152 #endif
 153
 154         debug ("Protect off %08lX ... %08lX\n",
 155                 (ulong)flash_addr, end_addr);
 156
 157         if (flash_sect_protect (0, (ulong)flash_addr, end_addr)) {
 158                 goto Done;
 159         }
 160
 161         debug ("Protect off %08lX ... %08lX\n",
 162                 (ulong)flash_addr_new, end_addr_new);
 163
 164         if (flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new)) {
 165                 goto Done;
 166         }
 167
 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);
 171         if (up_data) {
 172                 if ((saved_data = malloc(up_data)) == NULL) {
 173                         printf("Unable to save the rest of sector (%ld)\n",
 174                                 up_data);
 175                         goto Done;
 176                 }
 177                 memcpy(saved_data,
 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);
 182         }
 183 #endif
 184         puts ("Erasing Flash...");
 185         debug (" %08lX ... %08lX ...",
 186                 (ulong)flash_addr_new, end_addr_new);
 187
 188         if (flash_sect_erase ((ulong)flash_addr_new, end_addr_new)) {
 189                 goto Done;
 190         }
 191
 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))))
 208         {
 209                 flash_perror (rc);
 210                 goto Done;
 211         }
 212         puts ("done\n");
 213
 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,
 220                                 up_data)) {
 221                         flash_perror(rc);
 222                         goto Done;
 223                 }
 224         }
 225 #endif
 226         {
 227                 env_t * etmp = flash_addr;
 228                 ulong ltmp = end_addr;
 229
 230                 flash_addr = flash_addr_new;
 231                 flash_addr_new = etmp;
 232
 233                 end_addr = end_addr_new;
 234                 end_addr_new = ltmp;
 235         }
 236
 237         rc = 0;
 238 Done:
 239
 240         if (saved_data)
 241                 free (saved_data);
 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);
 245
 246         return rc;
 247 }
 248 #endif /* CMD_SAVEENV */
 249
 250 #else /* ! CFG_ENV_ADDR_REDUND */
 251
 252 int  env_init(void)
 253 {
 254         DECLARE_GLOBAL_DATA_PTR;
 255
 256         if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
 257                 gd->env_addr  = (ulong)&(env_ptr->data);
 258                 gd->env_valid = 1;
 259         } else {
 260                 gd->env_addr  = (ulong)&default_environment[0];
 261                 gd->env_valid = 0;
 262         }
 263
 264         return (0);
 265 }
 266
 267 #ifdef CMD_SAVEENV
 268
 269 int saveenv(void)
 270 {
 271         int     len, rc;
 272         ulong   end_addr;
 273         ulong   flash_sect_addr;
 274 #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE)
 275         ulong   flash_offset;
 276         uchar   env_buffer[CFG_ENV_SECT_SIZE];
 277 #else
 278         uchar *env_buffer = (char *)env_ptr;
 279 #endif  /* CFG_ENV_SECT_SIZE */
 280         int rcode = 0;
 281
 282 #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE)
 283
 284         flash_offset    = ((ulong)flash_addr) & (CFG_ENV_SECT_SIZE-1);
 285         flash_sect_addr = ((ulong)flash_addr) & ~(CFG_ENV_SECT_SIZE-1);
 286
 287         debug ( "copy old content: "
 288                 "sect_addr: %08lX  env_addr: %08lX  offset: %08lX\n",
 289                 flash_sect_addr, (ulong)flash_addr, flash_offset);
 290
 291         /* copy old contents to temporary buffer */
 292         memcpy (env_buffer, (void *)flash_sect_addr, CFG_ENV_SECT_SIZE);
 293
 294         /* copy current environment to temporary buffer */
 295         memcpy ((uchar *)((unsigned long)env_buffer + flash_offset),
 296                 env_ptr,
 297                 CFG_ENV_SIZE);
 298
 299         len      = CFG_ENV_SECT_SIZE;
 300 #else
 301         flash_sect_addr = (ulong)flash_addr;
 302         len      = CFG_ENV_SIZE;
 303 #endif  /* CFG_ENV_SECT_SIZE */
 304
 305 #ifndef CONFIG_INFERNO
 306         end_addr = flash_sect_addr + len - 1;
 307 #else
 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;
 311 #endif
 312
 313         debug ("Protect off %08lX ... %08lX\n",
 314                 (ulong)flash_sect_addr, end_addr);
 315
 316         if (flash_sect_protect (0, flash_sect_addr, end_addr))
 317                 return 1;
 318
 319         puts ("Erasing Flash...");
 320         if (flash_sect_erase (flash_sect_addr, end_addr))
 321                 return 1;
 322
 323         puts ("Writing to Flash... ");
 324         rc = flash_write(env_buffer, flash_sect_addr, len);
 325         if (rc != 0) {
 326                 flash_perror (rc);
 327                 rcode = 1;
 328         } else {
 329                 puts ("done\n");
 330         }
 331
 332         /* try to re-protect */
 333         (void) flash_sect_protect (1, flash_sect_addr, end_addr);
 334         return rcode;
 335 }
 336
 337 #endif /* CMD_SAVEENV */
 338
 339 #endif /* CFG_ENV_ADDR_REDUND */
 340
 341 void env_relocate_spec (void)
 342 {
 343 #if !defined(ENV_IS_EMBEDDED) || defined(CFG_ENV_ADDR_REDUND)
 344 #ifdef CFG_ENV_ADDR_REDUND
 345         DECLARE_GLOBAL_DATA_PTR;
 346
 347         if (gd->env_addr != (ulong)&(flash_addr->data)) {
 348                 env_t * etmp = flash_addr;
 349                 ulong ltmp = end_addr;
 350
 351                 flash_addr = flash_addr_new;
 352                 flash_addr_new = etmp;
 353
 354                 end_addr = end_addr_new;
 355                 end_addr_new = ltmp;
 356         }
 357
 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;
 362
 363                 gd->env_valid = 2;
 364                 flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new);
 365                 flash_write(&flag,
 366                             (ulong)&(flash_addr_new->flags),
 367                             sizeof(flash_addr_new->flags));
 368                 flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
 369         }
 370
 371         if (flash_addr->flags != ACTIVE_FLAG &&
 372             (flash_addr->flags & ACTIVE_FLAG) == ACTIVE_FLAG) {
 373                 char flag = ACTIVE_FLAG;
 374
 375                 gd->env_valid = 2;
 376                 flash_sect_protect (0, (ulong)flash_addr, end_addr);
 377                 flash_write(&flag,
 378                             (ulong)&(flash_addr->flags),
 379                             sizeof(flash_addr->flags));
 380                 flash_sect_protect (1, (ulong)flash_addr, end_addr);
 381         }
 382
 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 */
 389 }
 390
 391 #endif /* CFG_ENV_IS_IN_FLASH */