rename CFG_ENV macros to CONFIG_ENV

Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>

11 files changed, 133 insertions, 133 deletions

diff --git a/common/cmd_bdinfo.c b/common/cmd_bdinfo.c
index 24ff9b9956e..f4d9d404e62 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 f449715ca29..637d6c948d5 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 c3946f0a74c..77f99441a1c 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 2254b9b491a..fed919e675e 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 df3e31e93ab..1f0f413cf87 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 3b9914f4984..77e561912cb 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 84166afea85..75ee8ddc89e 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 9d01d7c7265..8af9e74aac5 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 c59bf9faa1b..a8b79591dcd 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 09a79d01918..3c65b3e4873 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 faf62608b4d..1bbf93fdfa4 100644
--- a/common/env_sf.c
+++ b/common/env_sf.c
@@ -29,17 +29,17 @@
 #include <environment.h>
 #include <spi_flash.h>
 
-#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;