[people/ms/u-boot.git] / common / env_common.c

/*
 * (C) Copyright 2000-2010
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
 * Andreas Heppel <aheppel@sysgo.de>
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <common.h>
#include <command.h>
#include <environment.h>
#include <linux/stddef.h>
#include <search.h>
#include <errno.h>
#include <malloc.h>

DECLARE_GLOBAL_DATA_PTR;

extern env_t *env_ptr;

extern void env_relocate_spec (void);
extern uchar env_get_char_spec(int);

static uchar env_get_char_init (int index);

/************************************************************************
 * Default settings to be used when no valid environment is found
 */
#define XMK_STR(x)	#x
#define MK_STR(x)	XMK_STR(x)

uchar default_environment[] = {
#ifdef	CONFIG_BOOTARGS
	"bootargs="	CONFIG_BOOTARGS			"\0"
#endif
#ifdef	CONFIG_BOOTCOMMAND
	"bootcmd="	CONFIG_BOOTCOMMAND		"\0"
#endif
#ifdef	CONFIG_RAMBOOTCOMMAND
	"ramboot="	CONFIG_RAMBOOTCOMMAND		"\0"
#endif
#ifdef	CONFIG_NFSBOOTCOMMAND
	"nfsboot="	CONFIG_NFSBOOTCOMMAND		"\0"
#endif
#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
	"bootdelay="	MK_STR(CONFIG_BOOTDELAY)	"\0"
#endif
#if defined(CONFIG_BAUDRATE) && (CONFIG_BAUDRATE >= 0)
	"baudrate="	MK_STR(CONFIG_BAUDRATE)		"\0"
#endif
#ifdef	CONFIG_LOADS_ECHO
	"loads_echo="	MK_STR(CONFIG_LOADS_ECHO)	"\0"
#endif
#ifdef	CONFIG_ETHADDR
	"ethaddr="	MK_STR(CONFIG_ETHADDR)		"\0"
#endif
#ifdef	CONFIG_ETH1ADDR
	"eth1addr="	MK_STR(CONFIG_ETH1ADDR)		"\0"
#endif
#ifdef	CONFIG_ETH2ADDR
	"eth2addr="	MK_STR(CONFIG_ETH2ADDR)		"\0"
#endif
#ifdef	CONFIG_ETH3ADDR
	"eth3addr="	MK_STR(CONFIG_ETH3ADDR)		"\0"
#endif
#ifdef	CONFIG_ETH4ADDR
	"eth4addr="	MK_STR(CONFIG_ETH4ADDR)		"\0"
#endif
#ifdef	CONFIG_ETH5ADDR
	"eth5addr="	MK_STR(CONFIG_ETH5ADDR)		"\0"
#endif
#ifdef	CONFIG_IPADDR
	"ipaddr="	MK_STR(CONFIG_IPADDR)		"\0"
#endif
#ifdef	CONFIG_SERVERIP
	"serverip="	MK_STR(CONFIG_SERVERIP)		"\0"
#endif
#ifdef	CONFIG_SYS_AUTOLOAD
	"autoload="	CONFIG_SYS_AUTOLOAD			"\0"
#endif
#ifdef	CONFIG_PREBOOT
	"preboot="	CONFIG_PREBOOT			"\0"
#endif
#ifdef	CONFIG_ROOTPATH
	"rootpath="	MK_STR(CONFIG_ROOTPATH)		"\0"
#endif
#ifdef	CONFIG_GATEWAYIP
	"gatewayip="	MK_STR(CONFIG_GATEWAYIP)	"\0"
#endif
#ifdef	CONFIG_NETMASK
	"netmask="	MK_STR(CONFIG_NETMASK)		"\0"
#endif
#ifdef	CONFIG_HOSTNAME
	"hostname="	MK_STR(CONFIG_HOSTNAME)		"\0"
#endif
#ifdef	CONFIG_BOOTFILE
	"bootfile="	MK_STR(CONFIG_BOOTFILE)		"\0"
#endif
#ifdef	CONFIG_LOADADDR
	"loadaddr="	MK_STR(CONFIG_LOADADDR)		"\0"
#endif
#ifdef  CONFIG_CLOCKS_IN_MHZ
	"clocks_in_mhz=1\0"
#endif
#if defined(CONFIG_PCI_BOOTDELAY) && (CONFIG_PCI_BOOTDELAY > 0)
	"pcidelay="	MK_STR(CONFIG_PCI_BOOTDELAY)	"\0"
#endif
#ifdef  CONFIG_EXTRA_ENV_SETTINGS
	CONFIG_EXTRA_ENV_SETTINGS
#endif
	"\0"
};

static uchar env_get_char_init (int index)
{
	uchar c;

	/* if crc was bad, use the default environment */
	if (gd->env_valid)
		c = env_get_char_spec(index);
	else
		c = default_environment[index];

	return (c);
}

uchar env_get_char_memory (int index)
{
	return *env_get_addr(index);
}

uchar env_get_char (int index)
{
	uchar c;

	/* if relocated to RAM */
	if (gd->flags & GD_FLG_RELOC)
		c = env_get_char_memory(index);
	else
		c = env_get_char_init(index);

	return (c);
}

uchar *env_get_addr (int index)
{
	if (gd->env_valid)
		return (uchar *)(gd->env_addr + index);
	else
		return &default_environment[index];
}

void set_default_env(const char *s)
{
	if (sizeof(default_environment) > ENV_SIZE) {
		puts("*** Error - default environment is too large\n\n");
		return;
	}

	if (s) {
		if (*s == '!') {
			printf("*** Warning - %s, "
				"using default environment\n\n",
				s+1);
		} else {
			puts(s);
		}
	} else {
		puts("Using default environment\n\n");
	}

	if (himport((char *)default_environment,
		    sizeof(default_environment), '\0', 0) == 0) {
		error("Environment import failed: errno = %d\n", errno);
	}
	gd->flags |= GD_FLG_ENV_READY;
}

/*
 * Check if CRC is valid and (if yes) import the environment.
 * Note that "buf" may or may not be aligned.
 */
int env_import(const char *buf, int check)
{
	env_t *ep = (env_t *)buf;

	if (check) {
		uint32_t crc;

		memcpy(&crc, &ep->crc, sizeof(crc));

		if (crc32(0, ep->data, ENV_SIZE) != crc) {
			set_default_env("!bad CRC");
			return 0;
		}
	}

	if (himport((char *)ep->data, ENV_SIZE, '\0', 0)) {
		gd->flags |= GD_FLG_ENV_READY;
		return 1;
	}

	error("Cannot import environment: errno = %d\n", errno);

	set_default_env("!import failed");

	return 0;
}

void env_relocate (void)
{
#if defined(CONFIG_NEEDS_MANUAL_RELOC)
	extern void env_reloc(void);

	env_reloc();
#endif
	if (gd->env_valid == 0) {
#if defined(CONFIG_ENV_IS_NOWHERE)	/* Environment not changable */
		set_default_env(NULL);
#else
		show_boot_progress (-60);
		set_default_env("!bad CRC");
#endif
	} else {
		env_relocate_spec ();
	}
}

#if 0 /* need to reimplement - def CONFIG_AUTO_COMPLETE */
int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
{
	int i, nxt, len, vallen, found;
	const char *lval, *rval;

	found = 0;
	cmdv[0] = NULL;

	len = strlen(var);
	/* now iterate over the variables and select those that match */
	for (i=0; env_get_char(i) != '\0'; i=nxt+1) {

		for (nxt=i; env_get_char(nxt) != '\0'; ++nxt)
			;

		lval = (char *)env_get_addr(i);
		rval = strchr(lval, '=');
		if (rval != NULL) {
			vallen = rval - lval;
			rval++;
		} else
			vallen = strlen(lval);

		if (len > 0 && (vallen < len || memcmp(lval, var, len) != 0))
			continue;

		if (found >= maxv - 2 || bufsz < vallen + 1) {
			cmdv[found++] = "...";
			break;
		}
		cmdv[found++] = buf;
		memcpy(buf, lval, vallen); buf += vallen; bufsz -= vallen;
		*buf++ = '\0'; bufsz--;
	}

	cmdv[found] = NULL;
	return found;
}
#endif
Commit	Line	Data
05706fdd	1	/*
ea882baf	2	* (C) Copyright 2000-2010
05706fdd WD	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>
ea882baf	7	*
05706fdd WD	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	#include <common.h>
	28	#include <command.h>
	29	#include <environment.h>
05706fdd	30	#include <linux/stddef.h>
ea882baf WD	31	#include <search.h>
ea882baf WD	32	#include <errno.h>
05706fdd WD	33	#include <malloc.h>
05706fdd WD	34
d87080b7 WD	35	DECLARE_GLOBAL_DATA_PTR;
d87080b7 WD	36
05706fdd WD	37	extern env_t *env_ptr;
	38
	39	extern void env_relocate_spec (void);
	40	extern uchar env_get_char_spec(int);
	41
	42	static uchar env_get_char_init (int index);
05706fdd WD	43
	44	/************************************************************************
	45	* Default settings to be used when no valid environment is found
	46	*/
	47	#define XMK_STR(x) #x
	48	#define MK_STR(x) XMK_STR(x)
	49
	50	uchar default_environment[] = {
	51	#ifdef CONFIG_BOOTARGS
	52	"bootargs=" CONFIG_BOOTARGS "\0"
	53	#endif
	54	#ifdef CONFIG_BOOTCOMMAND
	55	"bootcmd=" CONFIG_BOOTCOMMAND "\0"
	56	#endif
	57	#ifdef CONFIG_RAMBOOTCOMMAND
	58	"ramboot=" CONFIG_RAMBOOTCOMMAND "\0"
	59	#endif
	60	#ifdef CONFIG_NFSBOOTCOMMAND
	61	"nfsboot=" CONFIG_NFSBOOTCOMMAND "\0"
	62	#endif
	63	#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
	64	"bootdelay=" MK_STR(CONFIG_BOOTDELAY) "\0"
	65	#endif
	66	#if defined(CONFIG_BAUDRATE) && (CONFIG_BAUDRATE >= 0)
	67	"baudrate=" MK_STR(CONFIG_BAUDRATE) "\0"
	68	#endif
	69	#ifdef CONFIG_LOADS_ECHO
	70	"loads_echo=" MK_STR(CONFIG_LOADS_ECHO) "\0"
	71	#endif
	72	#ifdef CONFIG_ETHADDR
	73	"ethaddr=" MK_STR(CONFIG_ETHADDR) "\0"
	74	#endif
	75	#ifdef CONFIG_ETH1ADDR
	76	"eth1addr=" MK_STR(CONFIG_ETH1ADDR) "\0"
	77	#endif
	78	#ifdef CONFIG_ETH2ADDR
	79	"eth2addr=" MK_STR(CONFIG_ETH2ADDR) "\0"
	80	#endif
69459791 WD	81	#ifdef CONFIG_ETH3ADDR
	82	"eth3addr=" MK_STR(CONFIG_ETH3ADDR) "\0"
	83	#endif
c68a05fe	84	#ifdef CONFIG_ETH4ADDR
	85	"eth4addr=" MK_STR(CONFIG_ETH4ADDR) "\0"
	86	#endif
	87	#ifdef CONFIG_ETH5ADDR
	88	"eth5addr=" MK_STR(CONFIG_ETH5ADDR) "\0"
	89	#endif
05706fdd WD	90	#ifdef CONFIG_IPADDR
	91	"ipaddr=" MK_STR(CONFIG_IPADDR) "\0"
	92	#endif
	93	#ifdef CONFIG_SERVERIP
	94	"serverip=" MK_STR(CONFIG_SERVERIP) "\0"
	95	#endif
6d0f6bcf JCPV	96	#ifdef CONFIG_SYS_AUTOLOAD
6d0f6bcf JCPV	97	"autoload=" CONFIG_SYS_AUTOLOAD "\0"
05706fdd WD	98	#endif
	99	#ifdef CONFIG_PREBOOT
	100	"preboot=" CONFIG_PREBOOT "\0"
	101	#endif
	102	#ifdef CONFIG_ROOTPATH
	103	"rootpath=" MK_STR(CONFIG_ROOTPATH) "\0"
	104	#endif
	105	#ifdef CONFIG_GATEWAYIP
	106	"gatewayip=" MK_STR(CONFIG_GATEWAYIP) "\0"
	107	#endif
	108	#ifdef CONFIG_NETMASK
	109	"netmask=" MK_STR(CONFIG_NETMASK) "\0"
	110	#endif
	111	#ifdef CONFIG_HOSTNAME
	112	"hostname=" MK_STR(CONFIG_HOSTNAME) "\0"
	113	#endif
	114	#ifdef CONFIG_BOOTFILE
	115	"bootfile=" MK_STR(CONFIG_BOOTFILE) "\0"
	116	#endif
	117	#ifdef CONFIG_LOADADDR
	118	"loadaddr=" MK_STR(CONFIG_LOADADDR) "\0"
	119	#endif
	120	#ifdef CONFIG_CLOCKS_IN_MHZ
	121	"clocks_in_mhz=1\0"
	122	#endif
ad10dd9a SR	123	#if defined(CONFIG_PCI_BOOTDELAY) && (CONFIG_PCI_BOOTDELAY > 0)
	124	"pcidelay=" MK_STR(CONFIG_PCI_BOOTDELAY) "\0"
	125	#endif
05706fdd WD	126	#ifdef CONFIG_EXTRA_ENV_SETTINGS
	127	CONFIG_EXTRA_ENV_SETTINGS
	128	#endif
	129	"\0"
	130	};
	131
05706fdd WD	132	static uchar env_get_char_init (int index)
05706fdd WD	133	{
05706fdd WD	134	uchar c;
	135
	136	/* if crc was bad, use the default environment */
	137	if (gd->env_valid)
05706fdd	138	c = env_get_char_spec(index);
ea882baf	139	else
05706fdd	140	c = default_environment[index];
05706fdd WD	141
	142	return (c);
	143	}
	144
	145	uchar env_get_char_memory (int index)
	146	{
ea882baf	147	return *env_get_addr(index);
05706fdd WD	148	}
05706fdd WD	149
b502611b JT	150	uchar env_get_char (int index)
	151	{
	152	uchar c;
	153
	154	/* if relocated to RAM */
	155	if (gd->flags & GD_FLG_RELOC)
	156	c = env_get_char_memory(index);
	157	else
	158	c = env_get_char_init(index);
	159
	160	return (c);
	161	}
	162
05706fdd WD	163	uchar *env_get_addr (int index)
05706fdd WD	164	{
ea882baf WD	165	if (gd->env_valid)
	166	return (uchar *)(gd->env_addr + index);
	167	else
	168	return &default_environment[index];
05706fdd WD	169	}
05706fdd WD	170
ea882baf	171	void set_default_env(const char *s)
5bb12dbd HW	172	{
5bb12dbd HW	173	if (sizeof(default_environment) > ENV_SIZE) {
ea882baf	174	puts("*** Error - default environment is too large\n\n");
5bb12dbd HW	175	return;
	176	}
	177
ea882baf WD	178	if (s) {
	179	if (*s == '!') {
	180	printf("*** Warning - %s, "
	181	"using default environment\n\n",
	182	s+1);
	183	} else {
	184	puts(s);
	185	}
	186	} else {
	187	puts("Using default environment\n\n");
	188	}
	189
	190	if (himport((char *)default_environment,
	191	sizeof(default_environment), '\0', 0) == 0) {
	192	error("Environment import failed: errno = %d\n", errno);
	193	}
	194	gd->flags \|= GD_FLG_ENV_READY;
5bb12dbd HW	195	}
5bb12dbd HW	196
ea882baf WD	197	/*
	198	* Check if CRC is valid and (if yes) import the environment.
	199	* Note that "buf" may or may not be aligned.
	200	*/
	201	int env_import(const char *buf, int check)
05706fdd	202	{
ea882baf	203	env_t ep = (env_t )buf;
05706fdd	204
ea882baf WD	205	if (check) {
	206	uint32_t crc;
	207
	208	memcpy(&crc, &ep->crc, sizeof(crc));
	209
	210	if (crc32(0, ep->data, ENV_SIZE) != crc) {
	211	set_default_env("!bad CRC");
	212	return 0;
	213	}
	214	}
	215
	216	if (himport((char *)ep->data, ENV_SIZE, '\0', 0)) {
	217	gd->flags \|= GD_FLG_ENV_READY;
	218	return 1;
	219	}
05706fdd	220
ea882baf WD	221	error("Cannot import environment: errno = %d\n", errno);
	222
	223	set_default_env("!import failed");
	224
	225	return 0;
	226	}
	227
	228	void env_relocate (void)
	229	{
2e5167cc	230	#if defined(CONFIG_NEEDS_MANUAL_RELOC)
60f7da1f HS	231	extern void env_reloc(void);
	232
	233	env_reloc();
	234	#endif
05706fdd	235	if (gd->env_valid == 0) {
0fe247b9	236	#if defined(CONFIG_ENV_IS_NOWHERE) /* Environment not changable */
ea882baf	237	set_default_env(NULL);
05706fdd	238	#else
fad63407	239	show_boot_progress (-60);
ea882baf	240	set_default_env("!bad CRC");
d259079d	241	#endif
ea882baf	242	} else {
05706fdd WD	243	env_relocate_spec ();
05706fdd WD	244	}
05706fdd	245	}
04a85b3b	246
ea882baf	247	#if 0 /* need to reimplement - def CONFIG_AUTO_COMPLETE */
04a85b3b WD	248	int env_complete(char var, int maxv, char cmdv[], int bufsz, char *buf)
	249	{
	250	int i, nxt, len, vallen, found;
	251	const char lval, rval;
	252
	253	found = 0;
	254	cmdv[0] = NULL;
	255
	256	len = strlen(var);
	257	/* now iterate over the variables and select those that match */
	258	for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
	259
	260	for (nxt=i; env_get_char(nxt) != '\0'; ++nxt)
	261	;
	262
77ddac94	263	lval = (char *)env_get_addr(i);
04a85b3b WD	264	rval = strchr(lval, '=');
	265	if (rval != NULL) {
	266	vallen = rval - lval;
	267	rval++;
	268	} else
	269	vallen = strlen(lval);
	270
	271	if (len > 0 && (vallen < len \|\| memcmp(lval, var, len) != 0))
	272	continue;
	273
	274	if (found >= maxv - 2 \|\| bufsz < vallen + 1) {
	275	cmdv[found++] = "...";
	276	break;
	277	}
	278	cmdv[found++] = buf;
	279	memcpy(buf, lval, vallen); buf += vallen; bufsz -= vallen;
	280	*buf++ = '\0'; bufsz--;
	281	}
	282
	283	cmdv[found] = NULL;
	284	return found;
	285	}
	286	#endif