From 0e8d158664a913392cb01fb11a948d83f72e105e Mon Sep 17 00:00:00 2001 From: Jean-Christophe PLAGNIOL-VILLARD Date: Wed, 10 Sep 2008 22:48:06 +0200 Subject: rename CFG_ENV macros to CONFIG_ENV Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD --- common/cmd_bdinfo.c | 2 +- common/cmd_nvedit.c | 4 +-- common/env_common.c | 2 +- common/env_dataflash.c | 14 ++++----- common/env_eeprom.c | 14 ++++----- common/env_embedded.c | 6 ++-- common/env_flash.c | 84 +++++++++++++++++++++++++------------------------- common/env_nand.c | 80 +++++++++++++++++++++++------------------------ common/env_nvram.c | 20 ++++++------ common/env_onenand.c | 6 ++-- common/env_sf.c | 34 ++++++++++---------- 11 files changed, 133 insertions(+), 133 deletions(-) (limited to 'common') diff --git a/common/cmd_bdinfo.c b/common/cmd_bdinfo.c index 24ff9b9..f4d9d40 100644 --- a/common/cmd_bdinfo.c +++ b/common/cmd_bdinfo.c @@ -224,7 +224,7 @@ int do_bdinfo(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]) print_lnum("memsize ", bd->bi_memsize); print_num("flashstart ", bd->bi_flashstart); print_num("CFG_MONITOR_BASE ", CFG_MONITOR_BASE); - print_num("CFG_ENV_ADDR ", CFG_ENV_ADDR); + print_num("CONFIG_ENV_ADDR ", CONFIG_ENV_ADDR); printf("CFG_RELOC_MONITOR_BASE = 0x%lx (%d)\n", CFG_RELOC_MONITOR_BASE, CFG_MONITOR_LEN); printf("CFG_MALLOC_BASE = 0x%lx (%d)\n", CFG_MALLOC_BASE, diff --git a/common/cmd_nvedit.c b/common/cmd_nvedit.c index f449715..637d6c9 100644 --- a/common/cmd_nvedit.c +++ b/common/cmd_nvedit.c @@ -503,7 +503,7 @@ char *getenv (char *name) int val; for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) { - if (nxt >= CFG_ENV_SIZE) { + if (nxt >= CONFIG_ENV_SIZE) { return (NULL); } } @@ -523,7 +523,7 @@ int getenv_r (char *name, char *buf, unsigned len) int val, n; for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) { - if (nxt >= CFG_ENV_SIZE) { + if (nxt >= CONFIG_ENV_SIZE) { return (-1); } } diff --git a/common/env_common.c b/common/env_common.c index c3946f0..77f9944 100644 --- a/common/env_common.c +++ b/common/env_common.c @@ -241,7 +241,7 @@ void env_relocate (void) /* * We must allocate a buffer for the environment */ - env_ptr = (env_t *)malloc (CFG_ENV_SIZE); + env_ptr = (env_t *)malloc (CONFIG_ENV_SIZE); DEBUGF ("%s[%d] malloced ENV at %p\n", __FUNCTION__,__LINE__,env_ptr); #endif diff --git a/common/env_dataflash.c b/common/env_dataflash.c index 2254b9b..fed919e 100644 --- a/common/env_dataflash.c +++ b/common/env_dataflash.c @@ -41,22 +41,22 @@ extern uchar default_environment[]; uchar env_get_char_spec (int index) { uchar c; - read_dataflash(CFG_ENV_ADDR + index + offsetof(env_t,data), + read_dataflash(CONFIG_ENV_ADDR + index + offsetof(env_t,data), 1, (char *)&c); return (c); } void env_relocate_spec (void) { - read_dataflash(CFG_ENV_ADDR, CFG_ENV_SIZE, (char *)env_ptr); + read_dataflash(CONFIG_ENV_ADDR, CONFIG_ENV_SIZE, (char *)env_ptr); } int saveenv(void) { /* env must be copied to do not alter env structure in memory*/ - unsigned char temp[CFG_ENV_SIZE]; - memcpy(temp, env_ptr, CFG_ENV_SIZE); - return write_dataflash(CFG_ENV_ADDR, (unsigned long)temp, CFG_ENV_SIZE); + unsigned char temp[CONFIG_ENV_SIZE]; + memcpy(temp, env_ptr, CONFIG_ENV_SIZE); + return write_dataflash(CONFIG_ENV_ADDR, (unsigned long)temp, CONFIG_ENV_SIZE); } /************************************************************************ @@ -74,14 +74,14 @@ int env_init(void) AT91F_DataflashInit(); /* prepare for DATAFLASH read/write */ /* read old CRC */ - read_dataflash(CFG_ENV_ADDR + offsetof(env_t, crc), + read_dataflash(CONFIG_ENV_ADDR + offsetof(env_t, crc), sizeof(ulong), (char *)&crc); new = 0; len = ENV_SIZE; off = offsetof(env_t,data); while (len > 0) { int n = (len > sizeof(buf)) ? sizeof(buf) : len; - read_dataflash(CFG_ENV_ADDR + off, n, (char *)buf); + read_dataflash(CONFIG_ENV_ADDR + off, n, (char *)buf); new = crc32 (new, buf, n); len -= n; off += n; diff --git a/common/env_eeprom.c b/common/env_eeprom.c index df3e31e..1f0f413 100644 --- a/common/env_eeprom.c +++ b/common/env_eeprom.c @@ -40,7 +40,7 @@ uchar env_get_char_spec (int index) uchar c; eeprom_read (CFG_DEF_EEPROM_ADDR, - CFG_ENV_OFFSET+index+offsetof(env_t,data), + CONFIG_ENV_OFFSET+index+offsetof(env_t,data), &c, 1); return (c); @@ -49,17 +49,17 @@ uchar env_get_char_spec (int index) void env_relocate_spec (void) { eeprom_read (CFG_DEF_EEPROM_ADDR, - CFG_ENV_OFFSET, + CONFIG_ENV_OFFSET, (uchar*)env_ptr, - CFG_ENV_SIZE); + CONFIG_ENV_SIZE); } int saveenv(void) { return eeprom_write (CFG_DEF_EEPROM_ADDR, - CFG_ENV_OFFSET, + CONFIG_ENV_OFFSET, (uchar *)env_ptr, - CFG_ENV_SIZE); + CONFIG_ENV_SIZE); } /************************************************************************ @@ -78,7 +78,7 @@ int env_init(void) /* read old CRC */ eeprom_read (CFG_DEF_EEPROM_ADDR, - CFG_ENV_OFFSET+offsetof(env_t,crc), + CONFIG_ENV_OFFSET+offsetof(env_t,crc), (uchar *)&crc, sizeof(ulong)); new = 0; @@ -87,7 +87,7 @@ int env_init(void) while (len > 0) { int n = (len > sizeof(buf)) ? sizeof(buf) : len; - eeprom_read (CFG_DEF_EEPROM_ADDR, CFG_ENV_OFFSET+off, buf, n); + eeprom_read (CFG_DEF_EEPROM_ADDR, CONFIG_ENV_OFFSET+off, buf, n); new = crc32 (new, buf, n); len -= n; off += n; diff --git a/common/env_embedded.c b/common/env_embedded.c index 3b9914f..77e5619 100644 --- a/common/env_embedded.c +++ b/common/env_embedded.c @@ -180,7 +180,7 @@ env_t environment __PPCENV__ = { "\0" /* Term. env_t.data with 2 NULs */ } }; -#ifdef CFG_ENV_ADDR_REDUND +#ifdef CONFIG_ENV_ADDR_REDUND env_t redundand_environment __PPCENV__ = { 0, /* CRC Sum: invalid */ 0, /* Flags: invalid */ @@ -188,7 +188,7 @@ env_t redundand_environment __PPCENV__ = { "\0" } }; -#endif /* CFG_ENV_ADDR_REDUND */ +#endif /* CONFIG_ENV_ADDR_REDUND */ /* * These will end up in the .text section @@ -203,6 +203,6 @@ unsigned long env_size __PPCTEXT__ = sizeof(env_t); /* * Add in absolutes. */ -GEN_ABS(env_offset, CFG_ENV_OFFSET); +GEN_ABS(env_offset, CONFIG_ENV_OFFSET); #endif /* ENV_IS_EMBEDDED */ diff --git a/common/env_flash.c b/common/env_flash.c index 84166af..75ee8dd 100644 --- a/common/env_flash.c +++ b/common/env_flash.c @@ -36,17 +36,17 @@ DECLARE_GLOBAL_DATA_PTR; #if defined(CONFIG_CMD_ENV) && defined(CONFIG_CMD_FLASH) #define CMD_SAVEENV -#elif defined(CFG_ENV_ADDR_REDUND) -#error Cannot use CFG_ENV_ADDR_REDUND without CONFIG_CMD_ENV & CONFIG_CMD_FLASH +#elif defined(CONFIG_ENV_ADDR_REDUND) +#error Cannot use CONFIG_ENV_ADDR_REDUND without CONFIG_CMD_ENV & CONFIG_CMD_FLASH #endif -#if defined(CFG_ENV_SIZE_REDUND) && (CFG_ENV_SIZE_REDUND < CFG_ENV_SIZE) -#error CFG_ENV_SIZE_REDUND should not be less then CFG_ENV_SIZE +#if defined(CONFIG_ENV_SIZE_REDUND) && (CONFIG_ENV_SIZE_REDUND < CONFIG_ENV_SIZE) +#error CONFIG_ENV_SIZE_REDUND should not be less then CONFIG_ENV_SIZE #endif #ifdef CONFIG_INFERNO -# ifdef CFG_ENV_ADDR_REDUND -#error CFG_ENV_ADDR_REDUND is not implemented for CONFIG_INFERNO +# ifdef CONFIG_ENV_ADDR_REDUND +#error CONFIG_ENV_ADDR_REDUND is not implemented for CONFIG_INFERNO # endif #endif @@ -59,28 +59,28 @@ env_t *env_ptr = (env_t *)(&environment[0]); #ifdef CMD_SAVEENV /* static env_t *flash_addr = (env_t *)(&environment[0]);-broken on ARM-wd-*/ -static env_t *flash_addr = (env_t *)CFG_ENV_ADDR; +static env_t *flash_addr = (env_t *)CONFIG_ENV_ADDR; #endif #else /* ! ENV_IS_EMBEDDED */ -env_t *env_ptr = (env_t *)CFG_ENV_ADDR; +env_t *env_ptr = (env_t *)CONFIG_ENV_ADDR; #ifdef CMD_SAVEENV -static env_t *flash_addr = (env_t *)CFG_ENV_ADDR; +static env_t *flash_addr = (env_t *)CONFIG_ENV_ADDR; #endif #endif /* ENV_IS_EMBEDDED */ -#ifdef CFG_ENV_ADDR_REDUND -static env_t *flash_addr_new = (env_t *)CFG_ENV_ADDR_REDUND; +#ifdef CONFIG_ENV_ADDR_REDUND +static env_t *flash_addr_new = (env_t *)CONFIG_ENV_ADDR_REDUND; -/* CFG_ENV_ADDR is supposed to be on sector boundary */ -static ulong end_addr = CFG_ENV_ADDR + CFG_ENV_SECT_SIZE - 1; -static ulong end_addr_new = CFG_ENV_ADDR_REDUND + CFG_ENV_SECT_SIZE - 1; +/* CONFIG_ENV_ADDR is supposed to be on sector boundary */ +static ulong end_addr = CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1; +static ulong end_addr_new = CONFIG_ENV_ADDR_REDUND + CONFIG_ENV_SECT_SIZE - 1; #define ACTIVE_FLAG 1 #define OBSOLETE_FLAG 0 -#endif /* CFG_ENV_ADDR_REDUND */ +#endif /* CONFIG_ENV_ADDR_REDUND */ extern uchar default_environment[]; extern int default_environment_size; @@ -91,7 +91,7 @@ uchar env_get_char_spec (int index) return ( *((uchar *)(gd->env_addr + index)) ); } -#ifdef CFG_ENV_ADDR_REDUND +#ifdef CONFIG_ENV_ADDR_REDUND int env_init(void) { @@ -142,7 +142,7 @@ int saveenv(void) char *saved_data = NULL; int rc = 1; char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG; -#if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE +#if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE ulong up_data = 0; #endif @@ -160,8 +160,8 @@ int saveenv(void) goto Done; } -#if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE - up_data = (end_addr_new + 1 - ((long)flash_addr_new + CFG_ENV_SIZE)); +#if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE + up_data = (end_addr_new + 1 - ((long)flash_addr_new + CONFIG_ENV_SIZE)); debug ("Data to save 0x%x\n", up_data); if (up_data) { if ((saved_data = malloc(up_data)) == NULL) { @@ -170,9 +170,9 @@ int saveenv(void) goto Done; } memcpy(saved_data, - (void *)((long)flash_addr_new + CFG_ENV_SIZE), up_data); + (void *)((long)flash_addr_new + CONFIG_ENV_SIZE), up_data); debug ("Data (start 0x%x, len 0x%x) saved at 0x%x\n", - (long)flash_addr_new + CFG_ENV_SIZE, + (long)flash_addr_new + CONFIG_ENV_SIZE, up_data, saved_data); } #endif @@ -206,12 +206,12 @@ int saveenv(void) } puts ("done\n"); -#if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE +#if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE if (up_data) { /* restore the rest of sector */ debug ("Restoring the rest of data to 0x%x len 0x%x\n", - (long)flash_addr_new + CFG_ENV_SIZE, up_data); + (long)flash_addr_new + CONFIG_ENV_SIZE, up_data); if (flash_write(saved_data, - (long)flash_addr_new + CFG_ENV_SIZE, + (long)flash_addr_new + CONFIG_ENV_SIZE, up_data)) { flash_perror(rc); goto Done; @@ -242,7 +242,7 @@ Done: } #endif /* CMD_SAVEENV */ -#else /* ! CFG_ENV_ADDR_REDUND */ +#else /* ! CONFIG_ENV_ADDR_REDUND */ int env_init(void) { @@ -264,36 +264,36 @@ int saveenv(void) int len, rc; ulong end_addr; ulong flash_sect_addr; -#if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) +#if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) ulong flash_offset; - uchar env_buffer[CFG_ENV_SECT_SIZE]; + uchar env_buffer[CONFIG_ENV_SECT_SIZE]; #else uchar *env_buffer = (uchar *)env_ptr; -#endif /* CFG_ENV_SECT_SIZE */ +#endif /* CONFIG_ENV_SECT_SIZE */ int rcode = 0; -#if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) +#if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) - flash_offset = ((ulong)flash_addr) & (CFG_ENV_SECT_SIZE-1); - flash_sect_addr = ((ulong)flash_addr) & ~(CFG_ENV_SECT_SIZE-1); + flash_offset = ((ulong)flash_addr) & (CONFIG_ENV_SECT_SIZE-1); + flash_sect_addr = ((ulong)flash_addr) & ~(CONFIG_ENV_SECT_SIZE-1); debug ( "copy old content: " "sect_addr: %08lX env_addr: %08lX offset: %08lX\n", flash_sect_addr, (ulong)flash_addr, flash_offset); /* copy old contents to temporary buffer */ - memcpy (env_buffer, (void *)flash_sect_addr, CFG_ENV_SECT_SIZE); + memcpy (env_buffer, (void *)flash_sect_addr, CONFIG_ENV_SECT_SIZE); /* copy current environment to temporary buffer */ memcpy ((uchar *)((unsigned long)env_buffer + flash_offset), env_ptr, - CFG_ENV_SIZE); + CONFIG_ENV_SIZE); - len = CFG_ENV_SECT_SIZE; + len = CONFIG_ENV_SECT_SIZE; #else flash_sect_addr = (ulong)flash_addr; - len = CFG_ENV_SIZE; -#endif /* CFG_ENV_SECT_SIZE */ + len = CONFIG_ENV_SIZE; +#endif /* CONFIG_ENV_SECT_SIZE */ #ifndef CONFIG_INFERNO end_addr = flash_sect_addr + len - 1; @@ -329,12 +329,12 @@ int saveenv(void) #endif /* CMD_SAVEENV */ -#endif /* CFG_ENV_ADDR_REDUND */ +#endif /* CONFIG_ENV_ADDR_REDUND */ void env_relocate_spec (void) { -#if !defined(ENV_IS_EMBEDDED) || defined(CFG_ENV_ADDR_REDUND) -#ifdef CFG_ENV_ADDR_REDUND +#if !defined(ENV_IS_EMBEDDED) || defined(CONFIG_ENV_ADDR_REDUND) +#ifdef CONFIG_ENV_ADDR_REDUND if (gd->env_addr != (ulong)&(flash_addr->data)) { env_t * etmp = flash_addr; ulong ltmp = end_addr; @@ -374,9 +374,9 @@ void env_relocate_spec (void) if (gd->env_valid == 2) puts ("*** Warning - some problems detected " "reading environment; recovered successfully\n\n"); -#endif /* CFG_ENV_ADDR_REDUND */ +#endif /* CONFIG_ENV_ADDR_REDUND */ #ifdef CMD_SAVEENV - memcpy (env_ptr, (void*)flash_addr, CFG_ENV_SIZE); + memcpy (env_ptr, (void*)flash_addr, CONFIG_ENV_SIZE); #endif -#endif /* ! ENV_IS_EMBEDDED || CFG_ENV_ADDR_REDUND */ +#endif /* ! ENV_IS_EMBEDDED || CONFIG_ENV_ADDR_REDUND */ } diff --git a/common/env_nand.c b/common/env_nand.c index 9d01d7c..8af9e74 100644 --- a/common/env_nand.c +++ b/common/env_nand.c @@ -41,20 +41,20 @@ #if defined(CONFIG_CMD_ENV) && defined(CONFIG_CMD_NAND) #define CMD_SAVEENV -#elif defined(CFG_ENV_OFFSET_REDUND) -#error Cannot use CFG_ENV_OFFSET_REDUND without CONFIG_CMD_ENV & CONFIG_CMD_NAND +#elif defined(CONFIG_ENV_OFFSET_REDUND) +#error Cannot use CONFIG_ENV_OFFSET_REDUND without CONFIG_CMD_ENV & CONFIG_CMD_NAND #endif -#if defined(CFG_ENV_SIZE_REDUND) && (CFG_ENV_SIZE_REDUND != CFG_ENV_SIZE) -#error CFG_ENV_SIZE_REDUND should be the same as CFG_ENV_SIZE +#if defined(CONFIG_ENV_SIZE_REDUND) && (CONFIG_ENV_SIZE_REDUND != CONFIG_ENV_SIZE) +#error CONFIG_ENV_SIZE_REDUND should be the same as CONFIG_ENV_SIZE #endif #ifdef CONFIG_INFERNO #error CONFIG_INFERNO not supported yet #endif -#ifndef CFG_ENV_RANGE -#define CFG_ENV_RANGE CFG_ENV_SIZE +#ifndef CONFIG_ENV_RANGE +#define CONFIG_ENV_RANGE CONFIG_ENV_SIZE #endif int nand_legacy_rw (struct nand_chip* nand, int cmd, @@ -107,10 +107,10 @@ int env_init(void) int crc1_ok = 0, crc2_ok = 0; env_t *tmp_env1, *tmp_env2; - total = CFG_ENV_SIZE; + total = CONFIG_ENV_SIZE; tmp_env1 = env_ptr; - tmp_env2 = (env_t *)((ulong)env_ptr + CFG_ENV_SIZE); + tmp_env2 = (env_t *)((ulong)env_ptr + CONFIG_ENV_SIZE); crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc); crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc); @@ -154,16 +154,16 @@ int env_init(void) */ int writeenv(size_t offset, u_char *buf) { - size_t end = offset + CFG_ENV_RANGE; + size_t end = offset + CONFIG_ENV_RANGE; size_t amount_saved = 0; size_t blocksize, len; u_char *char_ptr; blocksize = nand_info[0].erasesize; - len = min(blocksize, CFG_ENV_SIZE); + len = min(blocksize, CONFIG_ENV_SIZE); - while (amount_saved < CFG_ENV_SIZE && offset < end) { + while (amount_saved < CONFIG_ENV_SIZE && offset < end) { if (nand_block_isbad(&nand_info[0], offset)) { offset += blocksize; } else { @@ -175,12 +175,12 @@ int writeenv(size_t offset, u_char *buf) amount_saved += len; } } - if (amount_saved != CFG_ENV_SIZE) + if (amount_saved != CONFIG_ENV_SIZE) return 1; return 0; } -#ifdef CFG_ENV_OFFSET_REDUND +#ifdef CONFIG_ENV_OFFSET_REDUND int saveenv(void) { size_t total; @@ -188,31 +188,31 @@ int saveenv(void) nand_erase_options_t nand_erase_options; env_ptr->flags++; - total = CFG_ENV_SIZE; + total = CONFIG_ENV_SIZE; - nand_erase_options.length = CFG_ENV_RANGE; + nand_erase_options.length = CONFIG_ENV_RANGE; nand_erase_options.quiet = 0; nand_erase_options.jffs2 = 0; nand_erase_options.scrub = 0; - if (CFG_ENV_RANGE < CFG_ENV_SIZE) + if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE) return 1; if(gd->env_valid == 1) { puts ("Erasing redundant Nand...\n"); - nand_erase_options.offset = CFG_ENV_OFFSET_REDUND; + nand_erase_options.offset = CONFIG_ENV_OFFSET_REDUND; if (nand_erase_opts(&nand_info[0], &nand_erase_options)) return 1; puts ("Writing to redundant Nand... "); - ret = writeenv(CFG_ENV_OFFSET_REDUND, (u_char *) env_ptr); + ret = writeenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) env_ptr); } else { puts ("Erasing Nand...\n"); - nand_erase_options.offset = CFG_ENV_OFFSET; + nand_erase_options.offset = CONFIG_ENV_OFFSET; if (nand_erase_opts(&nand_info[0], &nand_erase_options)) return 1; puts ("Writing to Nand... "); - ret = writeenv(CFG_ENV_OFFSET, (u_char *) env_ptr); + ret = writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr); } if (ret) { puts("FAILED!\n"); @@ -223,28 +223,28 @@ int saveenv(void) gd->env_valid = (gd->env_valid == 2 ? 1 : 2); return ret; } -#else /* ! CFG_ENV_OFFSET_REDUND */ +#else /* ! CONFIG_ENV_OFFSET_REDUND */ int saveenv(void) { size_t total; int ret = 0; nand_erase_options_t nand_erase_options; - nand_erase_options.length = CFG_ENV_RANGE; + nand_erase_options.length = CONFIG_ENV_RANGE; nand_erase_options.quiet = 0; nand_erase_options.jffs2 = 0; nand_erase_options.scrub = 0; - nand_erase_options.offset = CFG_ENV_OFFSET; + nand_erase_options.offset = CONFIG_ENV_OFFSET; - if (CFG_ENV_RANGE < CFG_ENV_SIZE) + if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE) return 1; puts ("Erasing Nand...\n"); if (nand_erase_opts(&nand_info[0], &nand_erase_options)) return 1; puts ("Writing to Nand... "); - total = CFG_ENV_SIZE; - if (writeenv(CFG_ENV_OFFSET, (u_char *) env_ptr)) { + total = CONFIG_ENV_SIZE; + if (writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr)) { puts("FAILED!\n"); return 1; } @@ -252,21 +252,21 @@ int saveenv(void) puts ("done\n"); return ret; } -#endif /* CFG_ENV_OFFSET_REDUND */ +#endif /* CONFIG_ENV_OFFSET_REDUND */ #endif /* CMD_SAVEENV */ int readenv (size_t offset, u_char * buf) { - size_t end = offset + CFG_ENV_RANGE; + size_t end = offset + CONFIG_ENV_RANGE; size_t amount_loaded = 0; size_t blocksize, len; u_char *char_ptr; blocksize = nand_info[0].erasesize; - len = min(blocksize, CFG_ENV_SIZE); + len = min(blocksize, CONFIG_ENV_SIZE); - while (amount_loaded < CFG_ENV_SIZE && offset < end) { + while (amount_loaded < CONFIG_ENV_SIZE && offset < end) { if (nand_block_isbad(&nand_info[0], offset)) { offset += blocksize; } else { @@ -277,13 +277,13 @@ int readenv (size_t offset, u_char * buf) amount_loaded += len; } } - if (amount_loaded != CFG_ENV_SIZE) + if (amount_loaded != CONFIG_ENV_SIZE) return 1; return 0; } -#ifdef CFG_ENV_OFFSET_REDUND +#ifdef CONFIG_ENV_OFFSET_REDUND void env_relocate_spec (void) { #if !defined(ENV_IS_EMBEDDED) @@ -291,14 +291,14 @@ void env_relocate_spec (void) int crc1_ok = 0, crc2_ok = 0; env_t *tmp_env1, *tmp_env2; - total = CFG_ENV_SIZE; + total = CONFIG_ENV_SIZE; - tmp_env1 = (env_t *) malloc(CFG_ENV_SIZE); - tmp_env2 = (env_t *) malloc(CFG_ENV_SIZE); + tmp_env1 = (env_t *) malloc(CONFIG_ENV_SIZE); + tmp_env2 = (env_t *) malloc(CONFIG_ENV_SIZE); - if (readenv(CFG_ENV_OFFSET, (u_char *) tmp_env1)) + if (readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1)) puts("No Valid Environment Area Found\n"); - if (readenv(CFG_ENV_OFFSET_REDUND, (u_char *) tmp_env2)) + if (readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2)) puts("No Valid Reundant Environment Area Found\n"); crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc); @@ -336,7 +336,7 @@ void env_relocate_spec (void) #endif /* ! ENV_IS_EMBEDDED */ } -#else /* ! CFG_ENV_OFFSET_REDUND */ +#else /* ! CONFIG_ENV_OFFSET_REDUND */ /* * The legacy NAND code saved the environment in the first NAND device i.e., * nand_dev_desc + 0. This is also the behaviour using the new NAND code. @@ -346,7 +346,7 @@ void env_relocate_spec (void) #if !defined(ENV_IS_EMBEDDED) int ret; - ret = readenv(CFG_ENV_OFFSET, (u_char *) env_ptr); + ret = readenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr); if (ret) return use_default(); @@ -354,7 +354,7 @@ void env_relocate_spec (void) return use_default(); #endif /* ! ENV_IS_EMBEDDED */ } -#endif /* CFG_ENV_OFFSET_REDUND */ +#endif /* CONFIG_ENV_OFFSET_REDUND */ #if !defined(ENV_IS_EMBEDDED) static void use_default() diff --git a/common/env_nvram.c b/common/env_nvram.c index c59bf9f..a8b7959 100644 --- a/common/env_nvram.c +++ b/common/env_nvram.c @@ -52,7 +52,7 @@ extern void *nvram_read(void *dest, const long src, size_t count); extern void nvram_write(long dest, const void *src, size_t count); env_t *env_ptr = NULL; #else -env_t *env_ptr = (env_t *)CFG_ENV_ADDR; +env_t *env_ptr = (env_t *)CONFIG_ENV_ADDR; #endif char * env_name_spec = "NVRAM"; @@ -66,7 +66,7 @@ uchar env_get_char_spec (int index) #ifdef CFG_NVRAM_ACCESS_ROUTINE uchar c; - nvram_read(&c, CFG_ENV_ADDR+index, 1); + nvram_read(&c, CONFIG_ENV_ADDR+index, 1); return c; #else @@ -83,7 +83,7 @@ uchar env_get_char_spec (int index) #ifdef CFG_NVRAM_ACCESS_ROUTINE uchar c; - nvram_read(&c, CFG_ENV_ADDR+index, 1); + nvram_read(&c, CONFIG_ENV_ADDR+index, 1); return c; #else @@ -95,9 +95,9 @@ uchar env_get_char_spec (int index) void env_relocate_spec (void) { #if defined(CFG_NVRAM_ACCESS_ROUTINE) - nvram_read(env_ptr, CFG_ENV_ADDR, CFG_ENV_SIZE); + nvram_read(env_ptr, CONFIG_ENV_ADDR, CONFIG_ENV_SIZE); #else - memcpy (env_ptr, (void*)CFG_ENV_ADDR, CFG_ENV_SIZE); + memcpy (env_ptr, (void*)CONFIG_ENV_ADDR, CONFIG_ENV_SIZE); #endif } @@ -108,9 +108,9 @@ int saveenv (void) enable_nvram(); #endif #ifdef CFG_NVRAM_ACCESS_ROUTINE - nvram_write(CFG_ENV_ADDR, env_ptr, CFG_ENV_SIZE); + nvram_write(CONFIG_ENV_ADDR, env_ptr, CONFIG_ENV_SIZE); #else - if (memcpy ((char *)CFG_ENV_ADDR, env_ptr, CFG_ENV_SIZE) == NULL) + if (memcpy ((char *)CONFIG_ENV_ADDR, env_ptr, CONFIG_ENV_SIZE) == NULL) rcode = 1 ; #endif #ifdef CONFIG_AMIGAONEG3SE @@ -134,11 +134,11 @@ int env_init (void) #if defined(CFG_NVRAM_ACCESS_ROUTINE) ulong crc; uchar data[ENV_SIZE]; - nvram_read (&crc, CFG_ENV_ADDR, sizeof(ulong)); - nvram_read (data, CFG_ENV_ADDR+sizeof(ulong), ENV_SIZE); + nvram_read (&crc, CONFIG_ENV_ADDR, sizeof(ulong)); + nvram_read (data, CONFIG_ENV_ADDR+sizeof(ulong), ENV_SIZE); if (crc32(0, data, ENV_SIZE) == crc) { - gd->env_addr = (ulong)CFG_ENV_ADDR + sizeof(long); + gd->env_addr = (ulong)CONFIG_ENV_ADDR + sizeof(long); #else if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) { gd->env_addr = (ulong)&(env_ptr->data); diff --git a/common/env_onenand.c b/common/env_onenand.c index 09a79d0..3c65b3e 100644 --- a/common/env_onenand.c +++ b/common/env_onenand.c @@ -62,7 +62,7 @@ void env_relocate_spec(void) int use_default = 0; size_t retlen; - env_addr = CFG_ENV_ADDR; + env_addr = CONFIG_ENV_ADDR; /* Check OneNAND exist */ if (onenand_mtd.writesize) @@ -89,13 +89,13 @@ void env_relocate_spec(void) int saveenv(void) { - unsigned long env_addr = CFG_ENV_ADDR; + unsigned long env_addr = CONFIG_ENV_ADDR; struct erase_info instr = { .callback = NULL, }; size_t retlen; - instr.len = CFG_ENV_SIZE; + instr.len = CONFIG_ENV_SIZE; instr.addr = env_addr; if (onenand_erase(&onenand_mtd, &instr)) { printf("OneNAND: erase failed at 0x%08lx\n", env_addr); diff --git a/common/env_sf.c b/common/env_sf.c index faf6260..1bbf93f 100644 --- a/common/env_sf.c +++ b/common/env_sf.c @@ -29,17 +29,17 @@ #include #include -#ifndef CFG_ENV_SPI_BUS -# define CFG_ENV_SPI_BUS 0 +#ifndef CONFIG_ENV_SPI_BUS +# define CONFIG_ENV_SPI_BUS 0 #endif -#ifndef CFG_ENV_SPI_CS -# define CFG_ENV_SPI_CS 0 +#ifndef CONFIG_ENV_SPI_CS +# define CONFIG_ENV_SPI_CS 0 #endif -#ifndef CFG_ENV_SPI_MAX_HZ -# define CFG_ENV_SPI_MAX_HZ 1000000 +#ifndef CONFIG_ENV_SPI_MAX_HZ +# define CONFIG_ENV_SPI_MAX_HZ 1000000 #endif -#ifndef CFG_ENV_SPI_MODE -# define CFG_ENV_SPI_MODE SPI_MODE_3 +#ifndef CONFIG_ENV_SPI_MODE +# define CONFIG_ENV_SPI_MODE SPI_MODE_3 #endif DECLARE_GLOBAL_DATA_PTR; @@ -67,18 +67,18 @@ int saveenv(void) return 1; } - if (CFG_ENV_SIZE > CFG_ENV_SECT_SIZE) { - sector = CFG_ENV_SIZE / CFG_ENV_SECT_SIZE; - if (CFG_ENV_SIZE % CFG_ENV_SECT_SIZE) + if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) { + sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE; + if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE) sector++; } puts("Erasing SPI flash..."); - if (spi_flash_erase(env_flash, CFG_ENV_OFFSET, sector * CFG_ENV_SECT_SIZE)) + if (spi_flash_erase(env_flash, CONFIG_ENV_OFFSET, sector * CONFIG_ENV_SECT_SIZE)) return 1; puts("Writing to SPI flash..."); - if (spi_flash_write(env_flash, CFG_ENV_OFFSET, CFG_ENV_SIZE, env_ptr)) + if (spi_flash_write(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, env_ptr)) return 1; puts("done\n"); @@ -89,12 +89,12 @@ void env_relocate_spec(void) { int ret; - env_flash = spi_flash_probe(CFG_ENV_SPI_BUS, CFG_ENV_SPI_CS, - CFG_ENV_SPI_MAX_HZ, CFG_ENV_SPI_MODE); + env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS, + CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE); if (!env_flash) goto err_probe; - ret = spi_flash_read(env_flash, CFG_ENV_OFFSET, CFG_ENV_SIZE, env_ptr); + ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, env_ptr); if (ret) goto err_read; @@ -112,7 +112,7 @@ err_probe: err_crc: puts("*** Warning - bad CRC, using default environment\n\n"); - if (default_environment_size > CFG_ENV_SIZE) { + if (default_environment_size > CONFIG_ENV_SIZE) { gd->env_valid = 0; puts("*** Error - default environment is too large\n\n"); return; -- cgit v1.1