[z180-stamp.git] / avr / env.c

#include "common.h"
#include <string.h>
#include <stdlib.h>

#include <avr/eeprom.h>

#include "config.h"
#include "debug.h"
#include "xmalloc.h"
#include "crc.h"
#include "command.h"

#include "env.h"


#define ENV_SIZE	(CONFIG_ENV_SIZE - sizeof(uint16_t) -1)
#define ACTIVE_FLAG	1
#define OBSOLETE_FLAG	0
#define ENV_GET_VAL	(1<<0)


/*
 * Default Environment
 */

#define DELIM 		"\0"

const FLASH char default_env[] = {
	"bootdelay="	"3"		DELIM
	"bootcmd="	"reset; loadf; go $(startaddr)"	DELIM
	"baudrate="	"115200"	DELIM
	"startaddr="	"0"		DELIM
	DELIM
};

/* EEPROM storage */
typedef struct environment_s {
	uint16_t	crc;		/* CRC16 over data bytes	*/
	uint8_t		flags;		/* active/obsolete flags	*/
	char		data[ENV_SIZE]; /* Environment data		*/
} env_t;


/* */
typedef struct env_item_s {
#define EF_N_EEP	(1<<7)		/* Variable name is in EEPROM */
#define EF_V_EEP	(1<<6)		/* Variable value is in EEPROM */
#define EF_DIRTY	(1<<0)		/* Variable is new or value changed */
	uint8_t flags;
	union {
		uint16_t eep;
		char	 *ram;
	} name;
	union {
		uint16_t eep;
		char	 *ram;
	} val;
} env_item_t;


static uint8_t env_valid;
static env_item_t env_list[CONFIG_ENVVAR_MAX];
static int entrycount;


static
char env_get_char(uint16_t index)
{
	unsigned int off = CONFIG_ENV_OFFSET;

	if (env_valid == 2)
		off = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;

	return (char) eeprom_read_byte((const uint8_t *)off + index + 
				offsetof(env_t, data));
}


static
uint16_t varname_get(char *buf, env_item_t *ep)
{
	int i = 0;
	char c;
	
	if (ep->flags & EF_N_EEP) {

		while ((c = env_get_char(ep->name.eep + i)) != '=' &&
				c != '\0' && i < CONFIG_SYS_ENV_NAMELEN) {

			buf[i] = c;
			i++;
		}
		if (i > 0 && c != '=') {
			debug("** ee_name: '%s' not '=' terminated!\n", buf);
		}
	} else {
		strncpy(buf, ep->name.ram, CONFIG_SYS_ENV_NAMELEN);
		i = strnlen(buf, CONFIG_SYS_ENV_NAMELEN);
	}
	buf[i] = '\0';
	return i;
}


static
uint16_t varval_getlen(uint16_t index)
{
	int i = 0;
	char c;

	while ((c = env_get_char (index + i)) != '\0') {
		i++;
	};

	return i;
}

static
uint16_t varval_get(char *buf, uint16_t index, int len)
{
	int i = 0;
	char c;
	
	while ((c = env_get_char (index + i)) != '\0' && i < len) {
		buf[i] = c;
		i++;
	};
		
	buf[i] = '\0';
	
	/* TODO: len check */
	
	return i;
}

static
int comp_env_key_item(const void *key, const void *item)
{
	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	env_item_t *ep = (env_item_t *) item;
	
	varname_get(buf, ep);
	
	return strcmp((char *) key, buf);
}

static
int comp_env_items(const void *m1, const void *m2)
{
	char b1[CONFIG_SYS_ENV_NAMELEN+1];
	char b2[CONFIG_SYS_ENV_NAMELEN+1];
	
	env_item_t *ep1 = (env_item_t *) m1;
	env_item_t *ep2 = (env_item_t *) m2;
	
	varname_get(b1, ep1);
	varname_get(b2, ep2);
	
	return strcmp(b1, b2);
}


static
int envlist_import(void)
{
	char name[CONFIG_SYS_ENV_NAMELEN+1];
	uint16_t idx = 0;
	int nlen;
	env_item_t e;
	
	e.flags = EF_N_EEP | EF_V_EEP;
	e.name.eep = idx;
	while ((nlen = varname_get(name, &e)) != 0 && idx < ENV_SIZE) {
	
		if (entrycount <= CONFIG_ENVVAR_MAX) {
			e.val.eep = idx + nlen + 1;
	
			env_list[entrycount++] = e;

			idx += nlen + 1;
			while (env_get_char(idx++) != 0 && idx < ENV_SIZE)
				;
			e.name.eep = idx;
		} else {
			debug("** Too many environment variables!\n");
			break;
		}
	}
	qsort(env_list, entrycount, sizeof(env_item_t), comp_env_items);

	return 0;
}


static
int set_default_env(void)
{
	char buf[56];
	uint16_t eep = CONFIG_ENV_OFFSET + offsetof(env_t, data);
	unsigned int len = ENV_SIZE;
	unsigned int i, src = 0;
	char c = 0xff, c0 = c;

	if (env_valid == 1) {
		eep = CONFIG_ENV_OFFSET + offsetof(env_t, data) + CONFIG_ENV_SIZE;
	}

	while (len)  {
		memcpy_P(buf, default_env+src, sizeof(buf));
		for (i=0; i < (len < sizeof(buf) ? len : sizeof(buf)) &&
				!(c == 0 && c0 == 0);
				i++) {
			c0 = c; c = buf[i];
		}
		eeprom_update_block(buf, (char *) eep, i);
		if (c == 0 && c0 == 0)
			len = 0;
		if (len > sizeof(buf))
			len -= sizeof(buf);
		src += sizeof(buf);
		eep += sizeof(buf);
	}

	return 0;
}


static
uint16_t env_crc(uint16_t data_offset)
{
	uint16_t crc; 
	uint16_t i;
	char c, c0;

	crc = 0xffff;
	c = 0xff;
	for (i = 0; !(c == 0 && c0 == 0) && i < ENV_SIZE; i++)
	{
		c0 = c; 
		c = eeprom_read_byte((const uint8_t *) data_offset + i);
		crc = crc16(crc, c);
	}
	return crc ;
}


/**
 * return valid env
 */
static
int env_check_valid(void)
{
	const uint16_t offset[2] = {CONFIG_ENV_OFFSET,
				    CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE};
	uint_fast8_t flags[2], crc_ok[2];
	int rc;

	/* read FLAGS */
	flags[0] = eeprom_read_byte ((uint8_t *) offset[0] +
				offsetof(env_t, flags));
	flags[1] = eeprom_read_byte ((uint8_t *) offset[1] +
				offsetof(env_t, flags));

	/* check CRC */
	crc_ok[0] = (
		eeprom_read_word((uint16_t *) offset[0] +
				offsetof(env_t, crc))
		== env_crc(offset[0] + offsetof(env_t, data))
	);
	crc_ok[1] = (
		eeprom_read_word((uint16_t *) offset[1] +
				offsetof(env_t, crc))
		== env_crc(offset[1] + offsetof(env_t, data))
	);

	if (!crc_ok[0] && !crc_ok[1]) {
		rc = 0;

	} else if (crc_ok[0] && !crc_ok[1]) {
		rc = 1;
	} else if (!crc_ok[0] && crc_ok[1]) {
		rc = 2;
	} else {
		/* both ok - check serial */
#if 1
		if      (flags[1] == ACTIVE_FLAG && flags[0] != ACTIVE_FLAG)
			rc = 2;
		else if (flags[1] == OBSOLETE_FLAG && flags[0] == 0xFF)
			rc = 2;
		else
			rc = 1;
#else
		if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
			rc = 1;
		else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
			rc = 2;
		else if (flags[0] == 0xFF && flags[1] == 0)
			rc = 2;
		else if (flags[1] == 0xFF && flags[0] == 0)
			rc = 1;
		else /* flags are equal - almost impossible */
			rc = 1;
#endif
	}
	
	return rc;
}


int env_init(void)
{
	env_valid = env_check_valid();
	if (env_valid == 0) {
		printf_P(PSTR("*** Warning - bad CRC, "
				"using default environment\n\n"));
		set_default_env();
	}
	entrycount = 0;
	envlist_import();
	return 0; 
}	


env_item_t *envlist_search(const MEMX char *name)
{
	char *p = (char *) name;

#ifdef __MEMX
	char buf[CONFIG_SYS_ENV_NAMELEN+1];

	if (__builtin_avr_flash_segment(name) != -1) {
		p = buf;
		while ((*p++ = *name++) != '\0')
			;
		p = buf;
	}
#endif /* __MEMX */

	return bsearch(p, env_list, entrycount,
				sizeof(env_item_t), comp_env_key_item);
}
			

static
env_item_t *envlist_enter(env_item_t *e)
{
	char *key = e->name.ram;
	const size_t size = sizeof(env_item_t);
	env_item_t *ep;
	
	ep = bsearch(key, env_list, entrycount, 
			size, comp_env_key_item);
					
	if (ep == NULL) {
		if (entrycount < CONFIG_ENVVAR_MAX) {
			
			env_list[entrycount++] = *e;
			qsort(env_list, entrycount, size, comp_env_items);
			ep = bsearch(key, env_list, entrycount, 
						size, comp_env_key_item);
		}
	} else { 
		if ((ep->flags & EF_V_EEP) == 0) {
			free(ep->val.ram);
		}
		ep->val.ram = e->val.ram;
	}		

	if (ep != NULL) {
		ep->flags |= EF_DIRTY;
		ep->flags &= ~EF_V_EEP;
		
		if ((ep->flags & EF_N_EEP) == 0) {
			int nlen = strnlen(key, CONFIG_SYS_ENV_NAMELEN);
			char *name = xmalloc(nlen + 1);
			if (name == NULL) {
				printf_P(PSTR("## Can't malloc %d bytes\n"), 
					nlen + 1);
				return NULL;
			}
			strcpy(name, key);
			name[nlen] = '\0';
			ep->name.ram = name;
		}
	}

	return ep;		
}	


static
int env_item_delete(env_item_t *ep)
{
	if (entrycount == 0)
		return -1;
	if ((ep->flags & EF_V_EEP) == 0) 
		free(ep->val.ram);
	if ((ep->flags & EF_N_EEP) == 0) 
		free(ep->name.ram); 

	entrycount--;
	size_t size = sizeof(env_item_t);
	memmove(ep, ep + 1, (env_list - ep)*size + entrycount*size);

	return 0;		
}

static
int envlist_delete(const char *name)
{
	env_item_t *ep = bsearch(name, env_list, entrycount, 
				sizeof(env_item_t), comp_env_key_item);

	if (ep != NULL)
		return env_item_delete(ep);

	return 1;
}

	
static
env_item_t *envlist_get(const MEMX char *name, uint_fast8_t flag)
{
	env_item_t *ep;
	
	ep = envlist_search(name);

	if (ep != NULL && (flag & ENV_GET_VAL)) {
		if (ep->flags & EF_V_EEP) {
			char *vp;
			int len;
			len = varval_getlen(ep->val.eep);
			if (len > CONFIG_SYS_CBSIZE)
				len = CONFIG_SYS_CBSIZE;
			vp = xmalloc(len + 1);
			if (vp) {
				varval_get(vp, ep->val.eep, len + 1);
				ep->val.ram = vp;
				ep->flags &= ~EF_V_EEP;
			} else
				printf_P(PSTR("Out of memory!\n"));
		}
	}			
	
	return ep;
}


char *getenv(const MEMX char *name)
{
	env_item_t *ep;
	char *ret = NULL;

	ep = envlist_get(name, ENV_GET_VAL);
	if (ep != NULL)
		ret = ep->val.ram;
	return ret;
}

static
int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
{
	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	int len;
	env_item_t e = *ep;

	len = varname_get(buf, ep);
	if (len == 0)
		return 0;
	buf[len++] = '=';
	space_left -= len;

	if (space_left <= 0)
		return 0;
	
	eeprom_update_block(buf, (uint8_t *) offset, len);
	offset += len;
	
	if (e.val.ram != NULL) {
		char c;
		do {
			if (e.flags & EF_V_EEP) 
				c = env_get_char(e.val.eep++);
			else
				c = *e.val.ram++;
			
			eeprom_update_byte((uint8_t *) offset, c);
			offset++;
			space_left--;
			len++;
		} while ((c != '\0') && space_left );
	}
	return len;
}	


static
int saveenv(void)
{
	unsigned int off     = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	unsigned int off_red = CONFIG_ENV_OFFSET;
	unsigned int pos;
	int len, left;
	uint16_t crc;
	int rc = 0;

	if (env_valid == 2) {
		off	= CONFIG_ENV_OFFSET;
		off_red	= CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	}

	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 0xff); 

	pos = off + offsetof(env_t, data);
	left = ENV_SIZE - 1;
	for (int i = 0 ; i < entrycount; i++) {
		len = env_item_save(&env_list[i], pos, left);
		if (len == 0) {
			return 1;
		}
		pos += len;
		left -= len;
	}
	/* terminate list */
	eeprom_update_byte((uint8_t *) pos, 0);
	crc = env_crc(off + offsetof(env_t, data));
	eeprom_update_word((uint16_t *) off + offsetof(env_t, crc), crc);
	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 
					ACTIVE_FLAG);

	if (rc == 0) {
		while (entrycount != 0) {
			env_item_delete(&env_list[entrycount-1]);
		}
		eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags), 
					OBSOLETE_FLAG);
		env_valid = (env_valid == 2) ? 1 : 2;

		envlist_import();
	}
	
	return rc;
}


static
int env_item_print(env_item_t *ep)
{
	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	int len;
	env_item_t e = *ep;
	
	varname_get(buf, ep);
	len = printf_P(PSTR("%s="), buf);
	
	if (e.val.ram != NULL) {
		while (1) {
			char c;
			if (e.flags & EF_V_EEP) 
				c = env_get_char(e.val.eep++);
			else
				c = *e.val.ram++;
			
			if (c != '\0') {
				putchar(c);
				len++;
			} else
				break;
		}
	}
	putchar('\n');
	len ++;

	return len;
}	


/*
 * Command interface: print one or all environment variables
 *
 * Returns -1 in case of error, or length of printed string
 */
static 
int env_print(const MEMX char *name)
{
	int len = -1;

	if (name) {		/* print a single name */
	
		env_item_t *ep = envlist_search(name);
		if (ep != NULL)
			len = env_item_print(ep);

	} else {		/* print whole list */
		len = 0;
		for (int i = 0 ; i < entrycount; i++) {
			len += env_item_print(&env_list[i]);
		}
	}
	return len;
}

static
int env_print_ramsize(void)
{
	int size = 0;
	uint8_t name_cnt = 0;
	uint8_t val_cnt = 0;
	
	for (int i = 0 ; i < entrycount; i++) {
		if ((env_list[i].flags & EF_N_EEP) == 0 &&
				(env_list[i].name.ram != NULL)) {
			name_cnt++;
			size += strlen(env_list[i].name.ram) + 3;
		}
		if ((env_list[i].flags & EF_V_EEP) == 0 &&
				(env_list[i].val.ram != NULL)) {
			val_cnt++;
			size += strlen(env_list[i].val.ram) + 3;
		}
	}
	printf_P(PSTR("%d bytes RAM used for %u names and %u values\n"),
			size, name_cnt, val_cnt);
	return size;
}


command_ret_t do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	command_ret_t rc = CMD_RET_SUCCESS;

	(void) cmdtp; (void) flag;

	if (argc == 1) {
		/* print all env vars */
		int size = env_print(NULL);
		if (size < 0)
			return CMD_RET_FAILURE;
		printf_P(PSTR("\nEnvironment size: %d/%d bytes\n"),
			size, ENV_SIZE);
		env_print_ramsize();
		return CMD_RET_SUCCESS;
	}

	/* print selected env vars */
	for (int i = 1; i < argc; ++i) {
		int rc = env_print(argv[i]);
		if (rc < 0) {
			printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
			rc = CMD_RET_FAILURE;
		}
	}

	return rc;
}


/**
 * Set or delete environment variable
 *
 * Set a new environment variable,
 * or replace or delete an existing one.
 *
 * @param flag		(not used)
 * @param argc
 * @param argv[1]	Environment variable to set or delete
 *			if no more args
 * @param argv[2] ...	Value to set it to
 *
 * @return 0 if ok, 1 on error
 */
static
command_ret_t _do_env_set(int flag, int argc, char * const argv[])
{
	int i, len;
	char *name, *value, *s;
	env_item_t e, *ep;

	(void) flag;
	debug("Initial value for argc=%d\n", argc);

	name = argv[1];
	value = argv[2];

	if (strchr(name, '=')) {
		printf_P(PSTR("## Error: illegal character '='"
		       "in variable name \"%s\"\n"), name);
		return CMD_RET_FAILURE;
	}
	if (strlen(name) > CONFIG_SYS_ENV_NAMELEN) {
		printf_P(PSTR("## Error: Variable name \"%s\" too long. "
		       "(max %d characters)\n"), name, CONFIG_SYS_ENV_NAMELEN);
		return CMD_RET_FAILURE;
	}
/*
	env_id++;
*/
	/* Delete only ? */
	if (argc < 3 || argv[2] == NULL) {
		int rc = envlist_delete(name);
		return rc ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
	}

	/*
	 * Insert / replace new value
	 */
	for (i = 2, len = 0; i < argc; ++i)
		len += strlen(argv[i]) + 1;

	value = xmalloc(len);
	if (value == NULL) {
		printf_P(PSTR("## Can't malloc %d bytes\n"), len);
		return CMD_RET_FAILURE;
	}
	for (i = 2, s = value; i < argc; ++i) {
		char *v = argv[i];

		while ((*s++ = *v++) != '\0')
			;
		*(s - 1) = ' ';
	}
	if (s != value)
		*--s = '\0';

	e.flags = EF_DIRTY;
	e.name.ram = name;
	e.val.ram = value;
	ep = envlist_enter(&e);
	if (!ep) {
		printf_P(PSTR("## Error inserting \"%s\" variable.\n"),
			name);
		return CMD_RET_FAILURE;
	}

	return CMD_RET_SUCCESS;
}

/**
 * Set an environment variable
 *
 * @param varname	Environment variable to set
 * @param varvalue	Value to set it to
 * @return 0 if ok, 1 on error
 */
static
int setenv(const char *varname, const char *varvalue)
{
	const char * const argv[3] = { NULL, varname, varvalue };
	int argc = 3;

	if (varvalue == NULL || varvalue[0] == '\0')
		--argc;
		
	return (int) _do_env_set(0, argc, (char * const *)argv);
}

#if 0
/**
 * Set an environment variable to an integer value
 *
 * @param varname	Environment variable to set
 * @param value		Value to set it to
 * @return 0 if ok, 1 on error
 */
int setenv_ulong(const char *varname, unsigned long value)
{
	/* TODO: this should be unsigned */
	char *str = simple_itoa(value);

	return setenv(varname, str);
}
#endif


/**
 * Set an environment variable to an value in hex
 *
 * @param varname	Environment variable to set
 * @param value		Value to set it to
 * @return 0 if ok, 1 on error
 */
int setenv_hex(const MEMX char *varname, unsigned long value)
{
	char str[sizeof(unsigned long) *2 + 1];

	sprintf_P(str, PSTR("%lx"), value);
	return setenv(varname, str);
}


/**
 * Decode the integer value of an environment variable and return it.
 *
 * @param name		Name of environemnt variable
 * @param base		Number base to use (normally 10, or 16 for hex)
 * @param default_val	Default value to return if the variable is not
 *			found
 * @return the decoded value, or default_val if not found
 */
unsigned long getenv_ulong(const MEMX char *name, int base, unsigned long default_val)
{
	char buf[16];
	unsigned long value;
	char *vp, *endp;

	env_item_t *ep = envlist_search(name);

	if (ep != NULL ) {
		if (ep->flags & EF_V_EEP) {
			varval_get(buf, ep->val.eep, sizeof(buf));
			vp = buf;
		} else
			vp = ep->val.ram;
		if (vp != NULL) {
			value = strtoul(vp, &endp, base);
			if (endp != vp)
				return value;
		}
	}

	return default_val;
}


command_ret_t do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	(void) cmdtp;

	if (argc < 2)
		return CMD_RET_USAGE;

	return _do_env_set(flag, argc, argv);
}


command_ret_t do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	(void) cmdtp; (void) flag; (void) argc;	(void) argv;

	printf_P(PSTR("Saving Environment ...\n"));
	return saveenv() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}

#if defined(CONFIG_AUTO_COMPLETE) 
int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
{
	ENTRY *match;
	int found, idx;

	idx = 0;
	found = 0;
	cmdv[0] = NULL;

	while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
		int vallen = strlen(match->key) + 1;

		if (found >= maxv - 2 || bufsz < vallen)
			break;

		cmdv[found++] = buf;
		memcpy(buf, match->key, vallen);
		buf += vallen;
		bufsz -= vallen;
	}

	qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);

	if (idx)
		cmdv[found++] = "...";

	cmdv[found] = NULL;
	return found;
}
#endif
Commit	Line	Data
d684c216 L	1	#include "common.h"
	2	#include <string.h>
	3	#include <stdlib.h>
	4
	5	#include <avr/eeprom.h>
	6
	7	#include "config.h"
	8	#include "debug.h"
	9	#include "xmalloc.h"
	10	#include "crc.h"
	11	#include "command.h"
	12
	13	#include "env.h"
	14
	15
323398b1 L	16	#define ENV_SIZE (CONFIG_ENV_SIZE - sizeof(uint16_t) -1)
	17	#define ACTIVE_FLAG 1
	18	#define OBSOLETE_FLAG 0
d684c216 L	19	#define ENV_GET_VAL (1<<0)
	20
	21
534e1dfc L	22	/*
	23	* Default Environment
	24	*/
1da3acc4 L	25
	26	#define DELIM "\0"
	27
534e1dfc L	28	const FLASH char default_env[] = {
	29	"bootdelay=" "3" DELIM
	30	"bootcmd=" "reset; loadf; go $(startaddr)" DELIM
	31	"baudrate=" "115200" DELIM
	32	"startaddr=" "0" DELIM
	33	DELIM
	34	};
	35
1da3acc4	36	/* EEPROM storage */
d684c216 L	37	typedef struct environment_s {
d684c216 L	38	uint16_t crc; /* CRC16 over data bytes */
323398b1	39	uint8_t flags; /* active/obsolete flags */
d684c216 L	40	char data[ENV_SIZE]; /* Environment data */
	41	} env_t;
	42
	43
1da3acc4	44	/* */
d684c216	45	typedef struct env_item_s {
72f58822 L	46	#define EF_N_EEP (1<<7) /* Variable name is in EEPROM */
	47	#define EF_V_EEP (1<<6) /* Variable value is in EEPROM */
	48	#define EF_DIRTY (1<<0) /* Variable is new or value changed */
d684c216 L	49	uint8_t flags;
	50	union {
	51	uint16_t eep;
	52	char *ram;
	53	} name;
	54	union {
	55	uint16_t eep;
	56	char *ram;
	57	} val;
	58	} env_item_t;
	59
1da3acc4	60
323398b1	61	static uint8_t env_valid;
d684c216 L	62	static env_item_t env_list[CONFIG_ENVVAR_MAX];
	63	static int entrycount;
	64
	65
1da3acc4 L	66	static
1da3acc4 L	67	char env_get_char(uint16_t index)
d684c216 L	68	{
	69	unsigned int off = CONFIG_ENV_OFFSET;
	70
323398b1 L	71	if (env_valid == 2)
	72	off = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	73
d684c216 L	74	return (char) eeprom_read_byte((const uint8_t *)off + index +
	75	offsetof(env_t, data));
	76	}
	77
	78
1da3acc4 L	79	static
1da3acc4 L	80	uint16_t varname_get(char buf, env_item_t ep)
d684c216 L	81	{
	82	int i = 0;
	83	char c;
	84
	85	if (ep->flags & EF_N_EEP) {
	86
	87	while ((c = env_get_char(ep->name.eep + i)) != '=' &&
	88	c != '\0' && i < CONFIG_SYS_ENV_NAMELEN) {
	89
	90	buf[i] = c;
	91	i++;
	92	}
	93	if (i > 0 && c != '=') {
	94	debug("** ee_name: '%s' not '=' terminated!\n", buf);
	95	}
	96	} else {
	97	strncpy(buf, ep->name.ram, CONFIG_SYS_ENV_NAMELEN);
	98	i = strnlen(buf, CONFIG_SYS_ENV_NAMELEN);
	99	}
	100	buf[i] = '\0';
	101	return i;
	102	}
	103
	104
69988dc1 L	105	static
	106	uint16_t varval_getlen(uint16_t index)
	107	{
	108	int i = 0;
	109	char c;
	110
	111	while ((c = env_get_char (index + i)) != '\0') {
	112	i++;
	113	};
	114
	115	return i;
	116	}
	117
1da3acc4 L	118	static
1da3acc4 L	119	uint16_t varval_get(char *buf, uint16_t index, int len)
d684c216 L	120	{
	121	int i = 0;
	122	char c;
	123
	124	while ((c = env_get_char (index + i)) != '\0' && i < len) {
	125	buf[i] = c;
	126	i++;
	127	};
	128
	129	buf[i] = '\0';
	130
	131	/* TODO: len check */
	132
	133	return i;
	134	}
	135
	136	static
	137	int comp_env_key_item(const void key, const void item)
	138	{
	139	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	140	env_item_t ep = (env_item_t ) item;
	141
1da3acc4	142	varname_get(buf, ep);
d684c216 L	143
	144	return strcmp((char *) key, buf);
	145	}
	146
	147	static
	148	int comp_env_items(const void m1, const void m2)
	149	{
	150	char b1[CONFIG_SYS_ENV_NAMELEN+1];
	151	char b2[CONFIG_SYS_ENV_NAMELEN+1];
	152
	153	env_item_t ep1 = (env_item_t ) m1;
	154	env_item_t ep2 = (env_item_t ) m2;
	155
1da3acc4 L	156	varname_get(b1, ep1);
1da3acc4 L	157	varname_get(b2, ep2);
d684c216 L	158
	159	return strcmp(b1, b2);
	160	}
	161
1da3acc4 L	162
	163	static
	164	int envlist_import(void)
d684c216 L	165	{
	166	char name[CONFIG_SYS_ENV_NAMELEN+1];
	167	uint16_t idx = 0;
	168	int nlen;
1da3acc4	169	env_item_t e;
d684c216	170
1da3acc4 L	171	e.flags = EF_N_EEP \| EF_V_EEP;
	172	e.name.eep = idx;
	173	while ((nlen = varname_get(name, &e)) != 0 && idx < ENV_SIZE) {
d684c216	174
1da3acc4 L	175	if (entrycount <= CONFIG_ENVVAR_MAX) {
1da3acc4 L	176	e.val.eep = idx + nlen + 1;
d684c216	177
1da3acc4	178	env_list[entrycount++] = e;
d684c216	179
1da3acc4 L	180	idx += nlen + 1;
	181	while (env_get_char(idx++) != 0 && idx < ENV_SIZE)
	182	;
	183	e.name.eep = idx;
	184	} else {
	185	debug("** Too many environment variables!\n");
	186	break;
	187	}
d684c216	188	}
1da3acc4	189	qsort(env_list, entrycount, sizeof(env_item_t), comp_env_items);
d684c216	190
1da3acc4 L	191	return 0;
1da3acc4 L	192	}
d684c216	193
d684c216	194
1da3acc4 L	195	static
1da3acc4 L	196	int set_default_env(void)
d684c216	197	{
1da3acc4 L	198	char buf[56];
	199	uint16_t eep = CONFIG_ENV_OFFSET + offsetof(env_t, data);
	200	unsigned int len = ENV_SIZE;
	201	unsigned int i, src = 0;
	202	char c = 0xff, c0 = c;
	203
	204	if (env_valid == 1) {
	205	eep = CONFIG_ENV_OFFSET + offsetof(env_t, data) + CONFIG_ENV_SIZE;
d684c216	206	}
d684c216	207
1da3acc4 L	208	while (len) {
	209	memcpy_P(buf, default_env+src, sizeof(buf));
	210	for (i=0; i < (len < sizeof(buf) ? len : sizeof(buf)) &&
	211	!(c == 0 && c0 == 0);
	212	i++) {
	213	c0 = c; c = buf[i];
d684c216	214	}
1da3acc4 L	215	eeprom_update_block(buf, (char *) eep, i);
	216	if (c == 0 && c0 == 0)
	217	len = 0;
	218	if (len > sizeof(buf))
	219	len -= sizeof(buf);
	220	src += sizeof(buf);
	221	eep += sizeof(buf);
d684c216	222	}
d684c216	223
1da3acc4 L	224	return 0;
1da3acc4 L	225	}
d684c216 L	226
d684c216 L	227
1da3acc4 L	228	static
1da3acc4 L	229	uint16_t env_crc(uint16_t data_offset)
323398b1	230	{
1da3acc4 L	231	uint16_t crc;
	232	uint16_t i;
	233	char c, c0;
323398b1	234
1da3acc4 L	235	crc = 0xffff;
	236	c = 0xff;
	237	for (i = 0; !(c == 0 && c0 == 0) && i < ENV_SIZE; i++)
	238	{
	239	c0 = c;
	240	c = eeprom_read_byte((const uint8_t *) data_offset + i);
	241	crc = crc16(crc, c);
323398b1	242	}
1da3acc4 L	243	return crc ;
1da3acc4 L	244	}
323398b1 L	245
323398b1 L	246
1da3acc4 L	247	/**
1da3acc4 L	248	* return valid env
323398b1	249	*/
1da3acc4 L	250	static
	251	int env_check_valid(void)
	252	{
	253	const uint16_t offset[2] = {CONFIG_ENV_OFFSET,
	254	CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE};
	255	uint_fast8_t flags[2], crc_ok[2];
	256	int rc;
	257
	258	/* read FLAGS */
	259	flags[0] = eeprom_read_byte ((uint8_t *) offset[0] +
	260	offsetof(env_t, flags));
	261	flags[1] = eeprom_read_byte ((uint8_t *) offset[1] +
	262	offsetof(env_t, flags));
	263
	264	/* check CRC */
	265	crc_ok[0] = (
	266	eeprom_read_word((uint16_t *) offset[0] +
	267	offsetof(env_t, crc))
	268	== env_crc(offset[0] + offsetof(env_t, data))
	269	);
	270	crc_ok[1] = (
	271	eeprom_read_word((uint16_t *) offset[1] +
	272	offsetof(env_t, crc))
	273	== env_crc(offset[1] + offsetof(env_t, data))
	274	);
323398b1	275
1da3acc4 L	276	if (!crc_ok[0] && !crc_ok[1]) {
1da3acc4 L	277	rc = 0;
323398b1	278
1da3acc4 L	279	} else if (crc_ok[0] && !crc_ok[1]) {
	280	rc = 1;
	281	} else if (!crc_ok[0] && crc_ok[1]) {
	282	rc = 2;
	283	} else {
	284	/* both ok - check serial */
	285	#if 1
	286	if (flags[1] == ACTIVE_FLAG && flags[0] != ACTIVE_FLAG)
	287	rc = 2;
	288	else if (flags[1] == OBSOLETE_FLAG && flags[0] == 0xFF)
	289	rc = 2;
	290	else
	291	rc = 1;
	292	#else
	293	if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
	294	rc = 1;
	295	else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
	296	rc = 2;
	297	else if (flags[0] == 0xFF && flags[1] == 0)
	298	rc = 2;
	299	else if (flags[1] == 0xFF && flags[0] == 0)
	300	rc = 1;
	301	else /* flags are equal - almost impossible */
	302	rc = 1;
	303	#endif
323398b1	304	}
323398b1	305
1da3acc4 L	306	return rc;
1da3acc4 L	307	}
323398b1 L	308
323398b1 L	309
1da3acc4	310	int env_init(void)
323398b1	311	{
1da3acc4 L	312	env_valid = env_check_valid();
	313	if (env_valid == 0) {
	314	printf_P(PSTR("*** Warning - bad CRC, "
	315	"using default environment\n\n"));
	316	set_default_env();
323398b1	317	}
1da3acc4 L	318	entrycount = 0;
	319	envlist_import();
	320	return 0;
	321	}
323398b1	322
323398b1	323
d04c2fed	324
fc30b18e	325	env_item_t envlist_search(const MEMX char name)
d684c216	326	{
d04c2fed L	327	char p = (char ) name;
	328
	329	#ifdef __MEMX
	330	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	331
	332	if (__builtin_avr_flash_segment(name) != -1) {
	333	p = buf;
	334	while ((p++ = name++) != '\0')
	335	;
	336	p = buf;
	337	}
	338	#endif /* __MEMX */
	339
	340	return bsearch(p, env_list, entrycount,
d684c216 L	341	sizeof(env_item_t), comp_env_key_item);
	342	}
	343
d684c216	344
1da3acc4	345	static
d684c216 L	346	env_item_t envlist_enter(env_item_t e)
	347	{
	348	char *key = e->name.ram;
	349	const size_t size = sizeof(env_item_t);
	350	env_item_t *ep;
	351
	352	ep = bsearch(key, env_list, entrycount,
	353	size, comp_env_key_item);
	354
	355	if (ep == NULL) {
	356	if (entrycount < CONFIG_ENVVAR_MAX) {
	357
	358	env_list[entrycount++] = *e;
	359	qsort(env_list, entrycount, size, comp_env_items);
	360	ep = bsearch(key, env_list, entrycount,
	361	size, comp_env_key_item);
	362	}
	363	} else {
	364	if ((ep->flags & EF_V_EEP) == 0) {
	365	free(ep->val.ram);
	366	}
	367	ep->val.ram = e->val.ram;
	368	}
	369
	370	if (ep != NULL) {
	371	ep->flags \|= EF_DIRTY;
	372	ep->flags &= ~EF_V_EEP;
	373
	374	if ((ep->flags & EF_N_EEP) == 0) {
	375	int nlen = strnlen(key, CONFIG_SYS_ENV_NAMELEN);
	376	char *name = xmalloc(nlen + 1);
	377	if (name == NULL) {
	378	printf_P(PSTR("## Can't malloc %d bytes\n"),
	379	nlen + 1);
	380	return NULL;
	381	}
	382	strcpy(name, key);
	383	name[nlen] = '\0';
	384	ep->name.ram = name;
	385	}
	386	}
	387
	388	return ep;
	389	}
	390
	391
1da3acc4	392	static
323398b1 L	393	int env_item_delete(env_item_t *ep)
	394	{
	395	if (entrycount == 0)
	396	return -1;
	397	if ((ep->flags & EF_V_EEP) == 0)
	398	free(ep->val.ram);
	399	if ((ep->flags & EF_N_EEP) == 0)
	400	free(ep->name.ram);
	401
	402	entrycount--;
	403	size_t size = sizeof(env_item_t);
	404	memmove(ep, ep + 1, (env_list - ep)size + entrycountsize);
	405
	406	return 0;
	407	}
d684c216	408
1da3acc4 L	409	static
1da3acc4 L	410	int envlist_delete(const char *name)
d684c216	411	{
d684c216 L	412	env_item_t *ep = bsearch(name, env_list, entrycount,
d684c216 L	413	sizeof(env_item_t), comp_env_key_item);
d684c216	414
323398b1 L	415	if (ep != NULL)
323398b1 L	416	return env_item_delete(ep);
d684c216	417
323398b1	418	return 1;
d684c216	419	}
1da3acc4 L	420
	421
	422	static
fc30b18e	423	env_item_t envlist_get(const MEMX char name, uint_fast8_t flag)
1da3acc4 L	424	{
	425	env_item_t *ep;
	426
	427	ep = envlist_search(name);
	428
	429	if (ep != NULL && (flag & ENV_GET_VAL)) {
	430	if (ep->flags & EF_V_EEP) {
	431	char *vp;
69988dc1 L	432	int len;
	433	len = varval_getlen(ep->val.eep);
	434	if (len > CONFIG_SYS_CBSIZE)
	435	len = CONFIG_SYS_CBSIZE;
	436	vp = xmalloc(len + 1);
	437	if (vp) {
	438	varval_get(vp, ep->val.eep, len + 1);
	439	ep->val.ram = vp;
	440	ep->flags &= ~EF_V_EEP;
	441	} else
	442	printf_P(PSTR("Out of memory!\n"));
1da3acc4 L	443	}
	444	}
	445
	446	return ep;
	447	}
	448
	449
fc30b18e	450	char getenv(const MEMX char name)
d684c216 L	451	{
	452	env_item_t *ep;
	453	char *ret = NULL;
	454
d684c216 L	455	ep = envlist_get(name, ENV_GET_VAL);
	456	if (ep != NULL)
	457	ret = ep->val.ram;
d684c216 L	458	return ret;
	459	}
	460
1da3acc4 L	461	static
1da3acc4 L	462	int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
323398b1	463	{
1da3acc4 L	464	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	465	int len;
	466	env_item_t e = *ep;
323398b1	467
1da3acc4 L	468	len = varname_get(buf, ep);
	469	if (len == 0)
	470	return 0;
	471	buf[len++] = '=';
	472	space_left -= len;
	473
	474	if (space_left <= 0)
	475	return 0;
	476
	477	eeprom_update_block(buf, (uint8_t *) offset, len);
	478	offset += len;
	479
	480	if (e.val.ram != NULL) {
	481	char c;
	482	do {
	483	if (e.flags & EF_V_EEP)
	484	c = env_get_char(e.val.eep++);
	485	else
	486	c = *e.val.ram++;
	487
	488	eeprom_update_byte((uint8_t *) offset, c);
	489	offset++;
	490	space_left--;
	491	len++;
	492	} while ((c != '\0') && space_left );
323398b1	493	}
1da3acc4 L	494	return len;
	495	}
	496
323398b1	497
1da3acc4	498	static
d684c216 L	499	int saveenv(void)
d684c216 L	500	{
323398b1 L	501	unsigned int off = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	502	unsigned int off_red = CONFIG_ENV_OFFSET;
	503	unsigned int pos;
	504	int len, left;
	505	uint16_t crc;
	506	int rc = 0;
d684c216	507
323398b1 L	508	if (env_valid == 2) {
	509	off = CONFIG_ENV_OFFSET;
	510	off_red = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	511	}
	512
	513	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 0xff);
d684c216	514
323398b1 L	515	pos = off + offsetof(env_t, data);
	516	left = ENV_SIZE - 1;
	517	for (int i = 0 ; i < entrycount; i++) {
	518	len = env_item_save(&env_list[i], pos, left);
	519	if (len == 0) {
	520	return 1;
	521	}
	522	pos += len;
	523	left -= len;
	524	}
	525	/* terminate list */
	526	eeprom_update_byte((uint8_t *) pos, 0);
	527	crc = env_crc(off + offsetof(env_t, data));
	528	eeprom_update_word((uint16_t *) off + offsetof(env_t, crc), crc);
	529	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags),
	530	ACTIVE_FLAG);
	531
	532	if (rc == 0) {
	533	while (entrycount != 0) {
	534	env_item_delete(&env_list[entrycount-1]);
	535	}
	536	eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags),
	537	OBSOLETE_FLAG);
	538	env_valid = (env_valid == 2) ? 1 : 2;
	539
	540	envlist_import();
	541	}
	542
d684c216 L	543	return rc;
	544	}
	545
d684c216	546
1da3acc4 L	547	static
1da3acc4 L	548	int env_item_print(env_item_t *ep)
d684c216	549	{
1da3acc4 L	550	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	551	int len;
	552	env_item_t e = *ep;
d684c216	553
1da3acc4 L	554	varname_get(buf, ep);
1da3acc4 L	555	len = printf_P(PSTR("%s="), buf);
323398b1	556
1da3acc4 L	557	if (e.val.ram != NULL) {
	558	while (1) {
	559	char c;
	560	if (e.flags & EF_V_EEP)
	561	c = env_get_char(e.val.eep++);
	562	else
	563	c = *e.val.ram++;
	564
	565	if (c != '\0') {
	566	putchar(c);
	567	len++;
	568	} else
	569	break;
	570	}
323398b1	571	}
1da3acc4 L	572	putchar('\n');
	573	len ++;
	574
	575	return len;
323398b1 L	576	}
	577
	578
d684c216 L	579	/*
	580	* Command interface: print one or all environment variables
	581	*
	582	* Returns -1 in case of error, or length of printed string
	583	*/
1da3acc4	584	static
fc30b18e	585	int env_print(const MEMX char *name)
d684c216 L	586	{
	587	int len = -1;
	588
	589	if (name) { /* print a single name */
	590
	591	env_item_t *ep = envlist_search(name);
	592	if (ep != NULL)
	593	len = env_item_print(ep);
	594
	595	} else { /* print whole list */
	596	len = 0;
	597	for (int i = 0 ; i < entrycount; i++) {
	598	len += env_item_print(&env_list[i]);
	599	}
	600	}
	601	return len;
	602	}
	603
1da3acc4	604	static
534e1dfc L	605	int env_print_ramsize(void)
	606	{
	607	int size = 0;
	608	uint8_t name_cnt = 0;
	609	uint8_t val_cnt = 0;
	610
	611	for (int i = 0 ; i < entrycount; i++) {
	612	if ((env_list[i].flags & EF_N_EEP) == 0 &&
	613	(env_list[i].name.ram != NULL)) {
	614	name_cnt++;
	615	size += strlen(env_list[i].name.ram) + 3;
	616	}
	617	if ((env_list[i].flags & EF_V_EEP) == 0 &&
	618	(env_list[i].val.ram != NULL)) {
	619	val_cnt++;
	620	size += strlen(env_list[i].val.ram) + 3;
	621	}
	622	}
	623	printf_P(PSTR("%d bytes RAM used for %u names and %u values\n"),
	624	size, name_cnt, val_cnt);
	625	return size;
	626	}
d684c216	627
1da3acc4	628
d0581f88	629	command_ret_t do_env_print(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
d684c216	630	{
d0581f88	631	command_ret_t rc = CMD_RET_SUCCESS;
d684c216 L	632
	633	(void) cmdtp; (void) flag;
	634
	635	if (argc == 1) {
	636	/* print all env vars */
d0581f88 L	637	int size = env_print(NULL);
	638	if (size < 0)
	639	return CMD_RET_FAILURE;
d684c216	640	printf_P(PSTR("\nEnvironment size: %d/%d bytes\n"),
d0581f88	641	size, ENV_SIZE);
534e1dfc	642	env_print_ramsize();
d0581f88	643	return CMD_RET_SUCCESS;
d684c216 L	644	}
	645
	646	/* print selected env vars */
d0581f88	647	for (int i = 1; i < argc; ++i) {
d684c216 L	648	int rc = env_print(argv[i]);
	649	if (rc < 0) {
	650	printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
d0581f88	651	rc = CMD_RET_FAILURE;
d684c216 L	652	}
	653	}
	654
d0581f88	655	return rc;
d684c216 L	656	}
	657
	658
72f58822 L	659	/**
	660	* Set or delete environment variable
	661	*
d684c216 L	662	* Set a new environment variable,
d684c216 L	663	* or replace or delete an existing one.
72f58822 L	664	*
	665	* @param flag (not used)
	666	* @param argc
	667	* @param argv[1] Environment variable to set or delete
	668	* if no more args
	669	* @param argv[2] ... Value to set it to
	670	*
	671	* @return 0 if ok, 1 on error
d684c216	672	*/
1da3acc4	673	static
d0581f88	674	command_ret_t _do_env_set(int flag, int argc, char * const argv[])
d684c216	675	{
72f58822 L	676	int i, len;
72f58822 L	677	char name, value, *s;
d684c216 L	678	env_item_t e, *ep;
	679
	680	(void) flag;
	681	debug("Initial value for argc=%d\n", argc);
	682
	683	name = argv[1];
	684	value = argv[2];
	685
	686	if (strchr(name, '=')) {
	687	printf_P(PSTR("## Error: illegal character '='"
	688	"in variable name \"%s\"\n"), name);
d0581f88	689	return CMD_RET_FAILURE;
d684c216 L	690	}
	691	if (strlen(name) > CONFIG_SYS_ENV_NAMELEN) {
	692	printf_P(PSTR("## Error: Variable name \"%s\" too long. "
	693	"(max %d characters)\n"), name, CONFIG_SYS_ENV_NAMELEN);
d0581f88	694	return CMD_RET_FAILURE;
d684c216 L	695	}
	696	/*
	697	env_id++;
	698	*/
	699	/* Delete only ? */
	700	if (argc < 3 \|\| argv[2] == NULL) {
	701	int rc = envlist_delete(name);
d0581f88	702	return rc ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
d684c216 L	703	}
	704
	705	/*
	706	* Insert / replace new value
	707	*/
	708	for (i = 2, len = 0; i < argc; ++i)
	709	len += strlen(argv[i]) + 1;
	710
	711	value = xmalloc(len);
	712	if (value == NULL) {
	713	printf_P(PSTR("## Can't malloc %d bytes\n"), len);
d0581f88	714	return CMD_RET_FAILURE;
d684c216 L	715	}
	716	for (i = 2, s = value; i < argc; ++i) {
	717	char *v = argv[i];
	718
	719	while ((s++ = v++) != '\0')
	720	;
	721	*(s - 1) = ' ';
	722	}
	723	if (s != value)
	724	*--s = '\0';
	725
	726	e.flags = EF_DIRTY;
	727	e.name.ram = name;
	728	e.val.ram = value;
	729	ep = envlist_enter(&e);
	730	if (!ep) {
	731	printf_P(PSTR("## Error inserting \"%s\" variable.\n"),
	732	name);
d0581f88	733	return CMD_RET_FAILURE;
d684c216 L	734	}
d684c216 L	735
d0581f88	736	return CMD_RET_SUCCESS;
d684c216 L	737	}
d684c216 L	738
72f58822 L	739	/**
	740	* Set an environment variable
	741	*
	742	* @param varname Environment variable to set
	743	* @param varvalue Value to set it to
	744	* @return 0 if ok, 1 on error
	745	*/
1da3acc4	746	static
d684c216 L	747	int setenv(const char varname, const char varvalue)
	748	{
	749	const char * const argv[3] = { NULL, varname, varvalue };
	750	int argc = 3;
	751
	752	if (varvalue == NULL \|\| varvalue[0] == '\0')
	753	--argc;
	754
d0581f88	755	return (int) _do_env_set(0, argc, (char * const *)argv);
d684c216 L	756	}
	757
	758	#if 0
	759	/**
	760	* Set an environment variable to an integer value
	761	*
	762	* @param varname Environment variable to set
	763	* @param value Value to set it to
	764	* @return 0 if ok, 1 on error
	765	*/
	766	int setenv_ulong(const char *varname, unsigned long value)
	767	{
	768	/* TODO: this should be unsigned */
	769	char *str = simple_itoa(value);
	770
	771	return setenv(varname, str);
	772	}
	773	#endif
	774
	775
	776	/**
	777	* Set an environment variable to an value in hex
	778	*
	779	* @param varname Environment variable to set
	780	* @param value Value to set it to
	781	* @return 0 if ok, 1 on error
	782	*/
fc30b18e	783	int setenv_hex(const MEMX char *varname, unsigned long value)
d684c216 L	784	{
	785	char str[sizeof(unsigned long) *2 + 1];
	786
	787	sprintf_P(str, PSTR("%lx"), value);
	788	return setenv(varname, str);
	789	}
	790
35e9ec0c	791
72f58822	792	/**
35e9ec0c	793	* Decode the integer value of an environment variable and return it.
72f58822	794	*
35e9ec0c L	795	* @param name Name of environemnt variable
	796	* @param base Number base to use (normally 10, or 16 for hex)
	797	* @param default_val Default value to return if the variable is not
	798	* found
	799	* @return the decoded value, or default_val if not found
72f58822	800	*/
fc30b18e	801	unsigned long getenv_ulong(const MEMX char *name, int base, unsigned long default_val)
d684c216	802	{
35e9ec0c	803	char buf[16];
d684c216	804	unsigned long value;
35e9ec0c L	805	char vp, endp;
	806
	807	env_item_t *ep = envlist_search(name);
d684c216	808
35e9ec0c L	809	if (ep != NULL ) {
	810	if (ep->flags & EF_V_EEP) {
	811	varval_get(buf, ep->val.eep, sizeof(buf));
	812	vp = buf;
	813	} else
	814	vp = ep->val.ram;
	815	if (vp != NULL) {
	816	value = strtoul(vp, &endp, base);
	817	if (endp != vp)
	818	return value;
	819	}
	820	}
d684c216	821
35e9ec0c	822	return default_val;
d684c216 L	823	}
d684c216 L	824
35e9ec0c	825
d0581f88	826	command_ret_t do_env_set(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
d684c216 L	827	{
	828	(void) cmdtp;
	829
	830	if (argc < 2)
	831	return CMD_RET_USAGE;
	832
	833	return _do_env_set(flag, argc, argv);
	834	}
	835
	836
d0581f88	837	command_ret_t do_env_save(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
323398b1 L	838	{
	839	(void) cmdtp; (void) flag; (void) argc; (void) argv;
	840
	841	printf_P(PSTR("Saving Environment ...\n"));
d0581f88	842	return saveenv() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
323398b1 L	843	}
323398b1 L	844
d684c216 L	845	#if defined(CONFIG_AUTO_COMPLETE)
	846	int env_complete(char var, int maxv, char cmdv[], int bufsz, char *buf)
	847	{
	848	ENTRY *match;
	849	int found, idx;
	850
	851	idx = 0;
	852	found = 0;
	853	cmdv[0] = NULL;
	854
	855	while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
	856	int vallen = strlen(match->key) + 1;
	857
	858	if (found >= maxv - 2 \|\| bufsz < vallen)
	859	break;
	860
	861	cmdv[found++] = buf;
	862	memcpy(buf, match->key, vallen);
	863	buf += vallen;
	864	bufsz -= vallen;
	865	}
	866
	867	qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
	868
	869	if (idx)
	870	cmdv[found++] = "...";
	871
	872	cmdv[found] = NULL;
	873	return found;
	874	}
	875	#endif