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