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

/*
 * (C) Copyright 2014 Leo C. <erbl259-lmu@yahoo.de>
 *
 * SPDX-License-Identifier:	GPL-2.0
 */

#include "env.h"
#include <avr/eeprom.h>

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


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

#define ENVLIST_DELETE	(1<<0)


/*
 * Default Environment
 */

#define DELIM 		"\0"

const FLASH char default_env[] = {
	ENV_BAUDRATE	  "=" "115200" DELIM
	ENV_BOOTDELAY	  "=" "3" DELIM
	ENV_BOOTCMD		  "=" "pin ${pins}; loadcpm3; go ${startaddress}" DELIM
	ENV_CPM3_SYSFILE  "=" CONFIG_CPM3_SYSFILE DELIM
	ENV_PINALIAS	  "=" "0:PG5,1:PG4,2:PB4,3:PB5,4:PB6,5:PB7,"
						  "6:PG3,7:PG2,8:PG1,9:PG0,10:PE7" DELIM
	ENV_STARTADDRESS  "=" "0" DELIM
	"pins"			  "=" "2,8 low 9 high 3 2" 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 {
	char * envvar;
} 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;
	char ret;

	switch (env_valid) {
	case 2:
		off += CONFIG_ENV_SIZE;
	case 1:
		ret = (char) eeprom_read_byte((const uint8_t *)off + index +
				offsetof(env_t, data));
		break;

	default:
		ret = default_env[index];
	}

	return ret;
}


static const FLASH char *comp_key;

static
int comp_env_items(const void *m1, const void *m2)
{
	env_item_t *ep1 = (env_item_t *) m1;
	env_item_t *ep2 = (env_item_t *) m2;

	if (ep1 == NULL)
		return - strcmp_P(ep2->envvar, comp_key);
	else
		return strcmp(ep1->envvar, ep2->envvar);
}


env_item_t *envlist_search(const MEMX char *name)
{
#ifdef __MEMX
	if (__builtin_avr_flash_segment(name) != -1) {
		comp_key = name;
		return bsearch(0, env_list, entrycount,
				sizeof(env_item_t), comp_env_items);
	} else {

		env_item_t e;
		e.envvar = (char *) name;

		return bsearch(&e, env_list, entrycount,
				sizeof(env_item_t), comp_env_items);
	}
#else
	env_item_t e;
	e.envvar = (char *) name;

	return bsearch(&e, env_list, entrycount,
				sizeof(env_item_t), comp_env_items);
#endif /* __MEMX */
}


static
env_item_t *envlist_enter(env_item_t *e)
{
	const size_t size = sizeof(env_item_t);
	env_item_t *ep;

	ep = bsearch(e, env_list, entrycount,
			size, comp_env_items);

	if (ep == NULL) {
		if (entrycount < CONFIG_ENVVAR_MAX) {

			env_list[entrycount++] = *e;
			qsort(env_list, entrycount, size, comp_env_items);
			ep = bsearch(e, env_list, entrycount,
						size, comp_env_items);
		}
	} else {
		free(ep->envvar);
		ep->envvar = e->envvar;
	}

	return ep;
}


static
int env_item_delete(env_item_t *ep)
{
	if (entrycount == 0)
		return -1;

	free(ep->envvar);

	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 MEMX char *name)
{
	env_item_t *ep = envlist_search(name);

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

	return 1;
}


static
int envlist_import(uint8_t flags)
{
	uint16_t index;

	int len;
	env_item_t e;
	char *np, c;
	uint_fast8_t ef;

	if ((flags & ENVLIST_DELETE) != 0)
		while (entrycount != 0)
			env_item_delete(&env_list[entrycount-1]);

	for (index = 0; env_get_char(index) != '\0'; ) {
		for (len = 0; env_get_char(index + len) != '\0'; ++len) {
			if ((index + len) >= ENV_SIZE)
				return -1;
		}

		np = (char *) xmalloc(len+1);
		if (np == NULL) {
			printf_P(PSTR("## Can't malloc %d bytes\n"), len+1);
			return 1;
		}
		e.envvar = np;
		ef = 0;
		while ((c = env_get_char(index++)) != '\0') {
			if (!ef && (c == '=')) {
				*np = '\0';
				ef = 1;
			} else
				*np = c;
			np++;
		}
		*np = '\0';
		envlist_enter(&e);
	}


	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"));
	}

	envlist_import(ENVLIST_DELETE);
	return 0;
}


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

	ep = envlist_search(name);
	if (ep != NULL)
		ret = ep->envvar + strlen(ep->envvar) +1;
	return ret;
}

static
int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
{
	int nlen, vlen;
	char *var = ep->envvar;

	nlen = strlen(var);
	if (nlen == 0)
		return 0;
	vlen = strlen(var + nlen + 1);
	if (vlen == 0)
		return 0;
	if (nlen + vlen + 2 > space_left)
		return 0;

	eeprom_update_block(var, (uint8_t *) offset, nlen);
	offset += nlen;
	eeprom_update_byte((uint8_t *) offset++, '=');
	eeprom_update_block(var + nlen +1, (uint8_t *) offset, vlen+1);

	return nlen + vlen + 2;
}


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) {
		eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags),
					OBSOLETE_FLAG);
		env_valid = (env_valid == 2) ? 1 : 2;
	}

	return rc;
}


static
int env_item_print(env_item_t *ep)
{
	int len;
	char *ev = ep->envvar;

	len = printf_P(PSTR("%s="), ev);
	len += printf_P(PSTR("%s\n"), ev + 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;
}


/**
 * 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(uint_fast8_t flag, int argc, char * const argv[])
{
	int i, len;
	char *name, *value, *valp, *p;
	env_item_t e, *ep;

	(void) flag;

	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;
	}
	len = strlen(name);
	if (len > 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 += 1; 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;
	}
	strcpy(value, name);
	valp = value + strlen(name) + 1;
	for (i = 2, p = valp; i < argc; ++i) {
		char *v = argv[i];

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

	e.envvar = 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 MEMX char *varname, const char *varvalue)
{
	int rc;

#ifdef __MEMX
	char *tmpname = NULL;
	if (__builtin_avr_flash_segment(varname) != -1) {
		tmpname = malloc(strlen_P(varname)+1);
		if (tmpname == NULL) {
			printf_P(PSTR("setenv: Out of Memory!\n"));
			return 1;
		}
		strcpy_P(tmpname, varname);
	} else
		tmpname = (char *) varname;
#endif

	const char * const argv[3] = { NULL, tmpname, varvalue };
	int argc = 3;

	if (varvalue == NULL || varvalue[0] == '\0')
		--argc;

	rc = (int) _do_env_set(0, argc, (char * const *)argv);

#ifdef __MEMX
	free(tmpname);
#endif
	return rc;
}

/**
 * Set an environment variable to an integer value
 *
 * @param name	Environment variable to set
 * @param value	Value to set it to
 * @param radix	Base
 * @return 0 if ok, 1 on error
 */
static
int setenv_intval(const MEMX char *name, unsigned long value, int radix)
{
	char buf[11];

	ultoa(value, buf, radix);

	return setenv(name, buf);
}

/**
 * Set an environment variable to a decimal integer value
 *
 * @param name	Environment variable to set
 * @param value	Value to set it to
 * @return 0 if ok, 1 on error
 */
int setenv_ulong(const MEMX char *name, unsigned long value)
{
	return setenv_intval(name, value, 10);
}


/**
 * Set an environment variable to a value in hex
 *
 * @param name	Environment variable to set
 * @param value	Value to set it to
 * @return 0 if ok, 1 on error
 */
int setenv_hex(const MEMX char *name, unsigned long value)
{
	return setenv_intval(name, value, 16);
}


/**
 * 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)
{
	unsigned long value;
	char *vp, *endp;

	env_item_t *ep = envlist_search(name);

	if (ep != NULL ) {
		vp = ep->envvar + strlen(ep->envvar) +1;
		value = strtoul(vp, &endp, base);
		if (endp != vp)
			return value;
	}

	return default_val;
}


/*
 * Read an environment variable as a boolean
 */
bool getenv_yesno(const MEMX char *name)
{
	char *s = getenv_str(name);

	if (s == NULL)
		return false;

	return strchr_P(PSTR("1yYtT"), *s) != NULL;

/*
	return *s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T' ?
		1 : 0;
*/
}

command_ret_t do_env_print(cmd_tbl_t *cmdtp, uint_fast8_t 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);
		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;
}


command_ret_t do_env_set(cmd_tbl_t *cmdtp, uint_fast8_t 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_default(cmd_tbl_t *cmdtp, uint_fast8_t flag,
			  int argc, char * const argv[])
{
	(void) cmdtp; (void) flag; (void) argc;	(void) argv;

	uint8_t tmp = env_valid;
	env_valid = 0;

	/* Reset the whole environment */
	printf_P(PSTR("## Resetting to default environment\n"));
	envlist_import(ENVLIST_DELETE);

	env_valid = tmp;

	return CMD_RET_SUCCESS;
}


command_ret_t do_env_save(cmd_tbl_t *cmdtp, uint_fast8_t 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
35edb766 L	1	/*
	2	* (C) Copyright 2014 Leo C. <erbl259-lmu@yahoo.de>
	3	*
b51d2360	4	* SPDX-License-Identifier: GPL-2.0
35edb766 L	5	*/
35edb766 L	6
228b1c5f	7	#include "env.h"
d684c216 L	8	#include <avr/eeprom.h>
	9
	10	#include "config.h"
	11	#include "debug.h"
	12	#include "xmalloc.h"
	13	#include "crc.h"
d684c216 L	14
d684c216 L	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	19
7e24905c L	20	#define ENVLIST_DELETE (1<<0)
7e24905c L	21
d684c216	22
534e1dfc L	23	/*
	24	* Default Environment
	25	*/
1da3acc4 L	26
	27	#define DELIM "\0"
	28
534e1dfc	29	const FLASH char default_env[] = {
c0abd68b L	30	ENV_BAUDRATE "=" "115200" DELIM
c0abd68b L	31	ENV_BOOTDELAY "=" "3" DELIM
b51d2360	32	ENV_BOOTCMD "=" "pin ${pins}; loadcpm3; go ${startaddress}" DELIM
057817cb	33	ENV_CPM3_SYSFILE "=" CONFIG_CPM3_SYSFILE DELIM
c0abd68b L	34	ENV_PINALIAS "=" "0:PG5,1:PG4,2:PB4,3:PB5,4:PB6,5:PB7,"
	35	"6:PG3,7:PG2,8:PG1,9:PG0,10:PE7" DELIM
	36	ENV_STARTADDRESS "=" "0" DELIM
b51d2360	37	"pins" "=" "2,8 low 9 high 3 2" DELIM
534e1dfc L	38	DELIM
	39	};
	40
c0abd68b	41
1da3acc4	42	/* EEPROM storage */
d684c216 L	43	typedef struct environment_s {
d684c216 L	44	uint16_t crc; /* CRC16 over data bytes */
323398b1	45	uint8_t flags; /* active/obsolete flags */
d684c216 L	46	char data[ENV_SIZE]; /* Environment data */
	47	} env_t;
	48
	49
1da3acc4	50	/* */
d684c216	51	typedef struct env_item_s {
55027f3b	52	char * envvar;
d684c216 L	53	} env_item_t;
d684c216 L	54
1da3acc4	55
323398b1	56	static uint8_t env_valid;
d684c216 L	57	static env_item_t env_list[CONFIG_ENVVAR_MAX];
	58	static int entrycount;
	59
	60
1da3acc4 L	61	static
1da3acc4 L	62	char env_get_char(uint16_t index)
d684c216 L	63	{
d684c216 L	64	unsigned int off = CONFIG_ENV_OFFSET;
55027f3b	65	char ret;
d684c216	66
55027f3b L	67	switch (env_valid) {
	68	case 2:
	69	off += CONFIG_ENV_SIZE;
	70	case 1:
	71	ret = (char) eeprom_read_byte((const uint8_t *)off + index +
d684c216	72	offsetof(env_t, data));
55027f3b	73	break;
d684c216	74
55027f3b L	75	default:
55027f3b L	76	ret = default_env[index];
d684c216	77	}
d684c216	78
55027f3b	79	return ret;
d684c216 L	80	}
d684c216 L	81
d684c216	82
04cffff0 L	83	static const FLASH char *comp_key;
04cffff0 L	84
d684c216 L	85	static
	86	int comp_env_items(const void m1, const void m2)
	87	{
d684c216 L	88	env_item_t ep1 = (env_item_t ) m1;
d684c216 L	89	env_item_t ep2 = (env_item_t ) m2;
7e24905c	90
04cffff0 L	91	if (ep1 == NULL)
	92	return - strcmp_P(ep2->envvar, comp_key);
	93	else
	94	return strcmp(ep1->envvar, ep2->envvar);
d684c216 L	95	}
d684c216 L	96
1da3acc4	97
7e24905c L	98	env_item_t envlist_search(const MEMX char name)
7e24905c L	99	{
7e24905c	100	#ifdef __MEMX
7e24905c	101	if (__builtin_avr_flash_segment(name) != -1) {
04cffff0 L	102	comp_key = name;
	103	return bsearch(0, env_list, entrycount,
	104	sizeof(env_item_t), comp_env_items);
	105	} else {
	106
	107	env_item_t e;
	108	e.envvar = (char *) name;
	109
	110	return bsearch(&e, env_list, entrycount,
	111	sizeof(env_item_t), comp_env_items);
7e24905c	112	}
04cffff0 L	113	#else
	114	env_item_t e;
	115	e.envvar = (char *) name;
7e24905c	116
55027f3b L	117	return bsearch(&e, env_list, entrycount,
55027f3b L	118	sizeof(env_item_t), comp_env_items);
04cffff0	119	#endif /* __MEMX */
7e24905c L	120	}
	121
	122
	123	static
	124	env_item_t envlist_enter(env_item_t e)
	125	{
7e24905c L	126	const size_t size = sizeof(env_item_t);
	127	env_item_t *ep;
	128
55027f3b L	129	ep = bsearch(e, env_list, entrycount,
55027f3b L	130	size, comp_env_items);
7e24905c L	131
	132	if (ep == NULL) {
	133	if (entrycount < CONFIG_ENVVAR_MAX) {
	134
	135	env_list[entrycount++] = *e;
	136	qsort(env_list, entrycount, size, comp_env_items);
55027f3b L	137	ep = bsearch(e, env_list, entrycount,
55027f3b L	138	size, comp_env_items);
7e24905c L	139	}
7e24905c L	140	} else {
55027f3b L	141	free(ep->envvar);
55027f3b L	142	ep->envvar = e->envvar;
7e24905c L	143	}
	144
	145	return ep;
	146	}
	147
	148
	149	static
	150	int env_item_delete(env_item_t *ep)
	151	{
	152	if (entrycount == 0)
	153	return -1;
55027f3b L	154
55027f3b L	155	free(ep->envvar);
7e24905c L	156
	157	entrycount--;
	158	size_t size = sizeof(env_item_t);
	159	memmove(ep, ep + 1, (env_list - ep)size + entrycountsize);
	160
	161	return 0;
	162	}
	163
	164	static
04cffff0	165	int envlist_delete(const MEMX char *name)
7e24905c	166	{
04cffff0	167	env_item_t *ep = envlist_search(name);
7e24905c L	168
	169	if (ep != NULL)
	170	return env_item_delete(ep);
	171
	172	return 1;
	173	}
	174
	175
7e24905c L	176
	177	static
	178	int envlist_import(uint8_t flags)
d684c216	179	{
55027f3b L	180	uint16_t index;
	181
	182	int len;
1da3acc4	183	env_item_t e;
55027f3b L	184	char *np, c;
55027f3b L	185	uint_fast8_t ef;
7e24905c L	186
	187	if ((flags & ENVLIST_DELETE) != 0)
	188	while (entrycount != 0)
	189	env_item_delete(&env_list[entrycount-1]);
	190
55027f3b L	191	for (index = 0; env_get_char(index) != '\0'; ) {
	192	for (len = 0; env_get_char(index + len) != '\0'; ++len) {
	193	if ((index + len) >= ENV_SIZE)
	194	return -1;
1da3acc4	195	}
d684c216	196
55027f3b L	197	np = (char *) xmalloc(len+1);
	198	if (np == NULL) {
	199	printf_P(PSTR("## Can't malloc %d bytes\n"), len+1);
	200	return 1;
d684c216	201	}
55027f3b L	202	e.envvar = np;
	203	ef = 0;
	204	while ((c = env_get_char(index++)) != '\0') {
	205	if (!ef && (c == '=')) {
	206	*np = '\0';
	207	ef = 1;
	208	} else
	209	*np = c;
	210	np++;
	211	}
	212	*np = '\0';
	213	envlist_enter(&e);
d684c216	214	}
d684c216	215
55027f3b	216
1da3acc4 L	217	return 0;
1da3acc4 L	218	}
d684c216 L	219
d684c216 L	220
1da3acc4 L	221	static
1da3acc4 L	222	uint16_t env_crc(uint16_t data_offset)
323398b1	223	{
7e24905c	224	uint16_t crc;
1da3acc4 L	225	uint16_t i;
1da3acc4 L	226	char c, c0;
323398b1	227
1da3acc4 L	228	crc = 0xffff;
	229	c = 0xff;
	230	for (i = 0; !(c == 0 && c0 == 0) && i < ENV_SIZE; i++)
	231	{
7e24905c	232	c0 = c;
1da3acc4 L	233	c = eeprom_read_byte((const uint8_t *) data_offset + i);
1da3acc4 L	234	crc = crc16(crc, c);
323398b1	235	}
1da3acc4 L	236	return crc ;
1da3acc4 L	237	}
323398b1 L	238
323398b1 L	239
1da3acc4 L	240	/**
1da3acc4 L	241	* return valid env
323398b1	242	*/
1da3acc4 L	243	static
	244	int env_check_valid(void)
	245	{
	246	const uint16_t offset[2] = {CONFIG_ENV_OFFSET,
	247	CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE};
	248	uint_fast8_t flags[2], crc_ok[2];
	249	int rc;
	250
	251	/* read FLAGS */
	252	flags[0] = eeprom_read_byte ((uint8_t *) offset[0] +
	253	offsetof(env_t, flags));
	254	flags[1] = eeprom_read_byte ((uint8_t *) offset[1] +
	255	offsetof(env_t, flags));
	256
	257	/* check CRC */
	258	crc_ok[0] = (
	259	eeprom_read_word((uint16_t *) offset[0] +
	260	offsetof(env_t, crc))
	261	== env_crc(offset[0] + offsetof(env_t, data))
	262	);
	263	crc_ok[1] = (
	264	eeprom_read_word((uint16_t *) offset[1] +
	265	offsetof(env_t, crc))
	266	== env_crc(offset[1] + offsetof(env_t, data))
	267	);
323398b1	268
1da3acc4 L	269	if (!crc_ok[0] && !crc_ok[1]) {
1da3acc4 L	270	rc = 0;
323398b1	271
1da3acc4 L	272	} else if (crc_ok[0] && !crc_ok[1]) {
	273	rc = 1;
	274	} else if (!crc_ok[0] && crc_ok[1]) {
	275	rc = 2;
	276	} else {
	277	/* both ok - check serial */
	278	#if 1
	279	if (flags[1] == ACTIVE_FLAG && flags[0] != ACTIVE_FLAG)
	280	rc = 2;
	281	else if (flags[1] == OBSOLETE_FLAG && flags[0] == 0xFF)
	282	rc = 2;
	283	else
	284	rc = 1;
	285	#else
	286	if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
	287	rc = 1;
	288	else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
	289	rc = 2;
	290	else if (flags[0] == 0xFF && flags[1] == 0)
	291	rc = 2;
	292	else if (flags[1] == 0xFF && flags[0] == 0)
	293	rc = 1;
	294	else /* flags are equal - almost impossible */
	295	rc = 1;
	296	#endif
323398b1	297	}
7e24905c	298
1da3acc4 L	299	return rc;
1da3acc4 L	300	}
323398b1 L	301
323398b1 L	302
1da3acc4	303	int env_init(void)
323398b1	304	{
1da3acc4 L	305	env_valid = env_check_valid();
1da3acc4 L	306	if (env_valid == 0) {
55027f3b	307	printf_P(PSTR("*** Warning - bad CRC, "
1da3acc4	308	"using default environment\n\n"));
d684c216	309	}
55027f3b	310
7e24905c L	311	envlist_import(ENVLIST_DELETE);
7e24905c L	312	return 0;
323398b1	313	}
d684c216	314
1da3acc4	315
bddc7e77	316	char getenv_str(const MEMX char name)
d684c216 L	317	{
	318	env_item_t *ep;
	319	char *ret = NULL;
	320
55027f3b	321	ep = envlist_search(name);
d684c216	322	if (ep != NULL)
55027f3b	323	ret = ep->envvar + strlen(ep->envvar) +1;
d684c216 L	324	return ret;
	325	}
	326
1da3acc4 L	327	static
1da3acc4 L	328	int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
323398b1	329	{
55027f3b L	330	int nlen, vlen;
55027f3b L	331	char *var = ep->envvar;
323398b1	332
55027f3b L	333	nlen = strlen(var);
55027f3b L	334	if (nlen == 0)
1da3acc4	335	return 0;
55027f3b L	336	vlen = strlen(var + nlen + 1);
	337	if (vlen == 0)
	338	return 0;
	339	if (nlen + vlen + 2 > space_left)
1da3acc4	340	return 0;
7e24905c	341
55027f3b L	342	eeprom_update_block(var, (uint8_t *) offset, nlen);
	343	offset += nlen;
	344	eeprom_update_byte((uint8_t *) offset++, '=');
	345	eeprom_update_block(var + nlen +1, (uint8_t *) offset, vlen+1);
	346
	347	return nlen + vlen + 2;
7e24905c	348	}
1da3acc4	349
323398b1	350
1da3acc4	351	static
d684c216 L	352	int saveenv(void)
d684c216 L	353	{
323398b1 L	354	unsigned int off = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	355	unsigned int off_red = CONFIG_ENV_OFFSET;
	356	unsigned int pos;
	357	int len, left;
	358	uint16_t crc;
	359	int rc = 0;
d684c216	360
323398b1 L	361	if (env_valid == 2) {
	362	off = CONFIG_ENV_OFFSET;
	363	off_red = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	364	}
	365
7e24905c	366	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 0xff);
d684c216	367
323398b1 L	368	pos = off + offsetof(env_t, data);
	369	left = ENV_SIZE - 1;
	370	for (int i = 0 ; i < entrycount; i++) {
	371	len = env_item_save(&env_list[i], pos, left);
	372	if (len == 0) {
	373	return 1;
	374	}
	375	pos += len;
	376	left -= len;
	377	}
	378	/* terminate list */
	379	eeprom_update_byte((uint8_t *) pos, 0);
	380	crc = env_crc(off + offsetof(env_t, data));
	381	eeprom_update_word((uint16_t *) off + offsetof(env_t, crc), crc);
7e24905c	382	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags),
323398b1 L	383	ACTIVE_FLAG);
	384
	385	if (rc == 0) {
7e24905c	386	eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags),
323398b1 L	387	OBSOLETE_FLAG);
323398b1 L	388	env_valid = (env_valid == 2) ? 1 : 2;
323398b1	389	}
7e24905c	390
d684c216 L	391	return rc;
	392	}
	393
d684c216	394
1da3acc4 L	395	static
1da3acc4 L	396	int env_item_print(env_item_t *ep)
d684c216	397	{
1da3acc4	398	int len;
55027f3b L	399	char *ev = ep->envvar;
	400
	401	len = printf_P(PSTR("%s="), ev);
	402	len += printf_P(PSTR("%s\n"), ev + len);
1da3acc4 L	403
1da3acc4 L	404	return len;
7e24905c	405	}
323398b1 L	406
323398b1 L	407
d684c216 L	408	/*
	409	* Command interface: print one or all environment variables
	410	*
	411	* Returns -1 in case of error, or length of printed string
	412	*/
7e24905c	413	static
fc30b18e	414	int env_print(const MEMX char *name)
d684c216 L	415	{
	416	int len = -1;
	417
	418	if (name) { /* print a single name */
7e24905c	419
d684c216 L	420	env_item_t *ep = envlist_search(name);
	421	if (ep != NULL)
	422	len = env_item_print(ep);
	423
	424	} else { /* print whole list */
	425	len = 0;
	426	for (int i = 0 ; i < entrycount; i++) {
	427	len += env_item_print(&env_list[i]);
	428	}
	429	}
	430	return len;
	431	}
	432
1da3acc4	433
72f58822 L	434	/**
	435	* Set or delete environment variable
	436	*
d684c216 L	437	* Set a new environment variable,
d684c216 L	438	* or replace or delete an existing one.
72f58822 L	439	*
	440	* @param flag (not used)
	441	* @param argc
	442	* @param argv[1] Environment variable to set or delete
	443	* if no more args
	444	* @param argv[2] ... Value to set it to
	445	*
	446	* @return 0 if ok, 1 on error
d684c216	447	*/
1da3acc4	448	static
93ea25f2	449	command_ret_t _do_env_set(uint_fast8_t flag, int argc, char * const argv[])
d684c216	450	{
72f58822	451	int i, len;
55027f3b	452	char name, value, valp, p;
d684c216 L	453	env_item_t e, *ep;
	454
	455	(void) flag;
d684c216 L	456
	457	name = argv[1];
	458	value = argv[2];
	459
	460	if (strchr(name, '=')) {
	461	printf_P(PSTR("## Error: illegal character '='"
	462	"in variable name \"%s\"\n"), name);
d0581f88	463	return CMD_RET_FAILURE;
d684c216	464	}
55027f3b L	465	len = strlen(name);
55027f3b L	466	if (len > CONFIG_SYS_ENV_NAMELEN) {
d684c216 L	467	printf_P(PSTR("## Error: Variable name \"%s\" too long. "
d684c216 L	468	"(max %d characters)\n"), name, CONFIG_SYS_ENV_NAMELEN);
d0581f88	469	return CMD_RET_FAILURE;
d684c216 L	470	}
	471	/*
	472	env_id++;
	473	*/
	474	/* Delete only ? */
	475	if (argc < 3 \|\| argv[2] == NULL) {
	476	int rc = envlist_delete(name);
d0581f88	477	return rc ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
d684c216 L	478	}
	479
	480	/*
	481	* Insert / replace new value
	482	*/
55027f3b	483	for (i = 2, len += 1; i < argc; ++i)
d684c216 L	484	len += strlen(argv[i]) + 1;
	485
	486	value = xmalloc(len);
	487	if (value == NULL) {
	488	printf_P(PSTR("## Can't malloc %d bytes\n"), len);
d0581f88	489	return CMD_RET_FAILURE;
d684c216	490	}
55027f3b L	491	strcpy(value, name);
	492	valp = value + strlen(name) + 1;
	493	for (i = 2, p = valp; i < argc; ++i) {
d684c216 L	494	char *v = argv[i];
d684c216 L	495
55027f3b	496	while ((p++ = v++) != '\0')
d684c216	497	;
55027f3b	498	*(p - 1) = ' ';
d684c216	499	}
55027f3b L	500	if (p != valp)
55027f3b L	501	*--p = '\0';
d684c216	502
55027f3b	503	e.envvar = value;
d684c216 L	504	ep = envlist_enter(&e);
	505	if (!ep) {
	506	printf_P(PSTR("## Error inserting \"%s\" variable.\n"),
	507	name);
d0581f88	508	return CMD_RET_FAILURE;
d684c216 L	509	}
d684c216 L	510
d0581f88	511	return CMD_RET_SUCCESS;
d684c216 L	512	}
d684c216 L	513
72f58822 L	514	/**
	515	* Set an environment variable
	516	*
	517	* @param varname Environment variable to set
	518	* @param varvalue Value to set it to
	519	* @return 0 if ok, 1 on error
	520	*/
1da3acc4	521	static
c0abd68b	522	int setenv(const MEMX char varname, const char varvalue)
d684c216	523	{
c0abd68b L	524	int rc;
	525
	526	#ifdef __MEMX
	527	char *tmpname = NULL;
	528	if (__builtin_avr_flash_segment(varname) != -1) {
	529	tmpname = malloc(strlen_P(varname)+1);
	530	if (tmpname == NULL) {
	531	printf_P(PSTR("setenv: Out of Memory!\n"));
	532	return 1;
	533	}
	534	strcpy_P(tmpname, varname);
	535	} else
	536	tmpname = (char *) varname;
	537	#endif
	538
	539	const char * const argv[3] = { NULL, tmpname, varvalue };
d684c216 L	540	int argc = 3;
	541
	542	if (varvalue == NULL \|\| varvalue[0] == '\0')
	543	--argc;
7e24905c	544
c0abd68b L	545	rc = (int) _do_env_set(0, argc, (char * const *)argv);
	546
	547	#ifdef __MEMX
	548	free(tmpname);
	549	#endif
	550	return rc;
d684c216 L	551	}
d684c216 L	552
d684c216 L	553	/**
	554	* Set an environment variable to an integer value
	555	*
f76ca346 L	556	* @param name Environment variable to set
	557	* @param value Value to set it to
	558	* @param radix Base
d684c216 L	559	* @return 0 if ok, 1 on error
d684c216 L	560	*/
f76ca346 L	561	static
f76ca346 L	562	int setenv_intval(const MEMX char *name, unsigned long value, int radix)
d684c216	563	{
f76ca346	564	char buf[11];
d684c216	565
f76ca346	566	ultoa(value, buf, radix);
d684c216	567
f76ca346 L	568	return setenv(name, buf);
f76ca346 L	569	}
d684c216 L	570
d684c216 L	571	/**
f76ca346	572	* Set an environment variable to a decimal integer value
d684c216	573	*
f76ca346 L	574	* @param name Environment variable to set
f76ca346 L	575	* @param value Value to set it to
d684c216 L	576	* @return 0 if ok, 1 on error
d684c216 L	577	*/
f76ca346	578	int setenv_ulong(const MEMX char *name, unsigned long value)
d684c216	579	{
f76ca346 L	580	return setenv_intval(name, value, 10);
	581	}
	582
d684c216	583
f76ca346 L	584	/**
	585	* Set an environment variable to a value in hex
	586	*
	587	* @param name Environment variable to set
	588	* @param value Value to set it to
	589	* @return 0 if ok, 1 on error
	590	*/
	591	int setenv_hex(const MEMX char *name, unsigned long value)
	592	{
	593	return setenv_intval(name, value, 16);
d684c216 L	594	}
d684c216 L	595
35e9ec0c	596
72f58822	597	/**
35e9ec0c	598	* Decode the integer value of an environment variable and return it.
72f58822	599	*
35e9ec0c L	600	* @param name Name of environemnt variable
	601	* @param base Number base to use (normally 10, or 16 for hex)
	602	* @param default_val Default value to return if the variable is not
	603	* found
	604	* @return the decoded value, or default_val if not found
72f58822	605	*/
fc30b18e	606	unsigned long getenv_ulong(const MEMX char *name, int base, unsigned long default_val)
d684c216	607	{
d684c216	608	unsigned long value;
35e9ec0c L	609	char vp, endp;
	610
	611	env_item_t *ep = envlist_search(name);
d684c216	612
35e9ec0c	613	if (ep != NULL ) {
55027f3b L	614	vp = ep->envvar + strlen(ep->envvar) +1;
	615	value = strtoul(vp, &endp, base);
	616	if (endp != vp)
	617	return value;
35e9ec0c	618	}
d684c216	619
35e9ec0c	620	return default_val;
d684c216 L	621	}
d684c216 L	622
35e9ec0c	623
be84a704 L	624	/*
	625	* Read an environment variable as a boolean
	626	*/
	627	bool getenv_yesno(const MEMX char *name)
	628	{
bddc7e77	629	char *s = getenv_str(name);
be84a704 L	630
	631	if (s == NULL)
	632	return false;
	633
	634	return strchr_P(PSTR("1yYtT"), *s) != NULL;
	635
	636	/*
	637	return s == '1' \|\| s == 'y' \|\| s == 'Y' \|\| s == 't' \|\| *s == 'T' ?
	638	1 : 0;
	639	*/
	640	}
	641
93ea25f2	642	command_ret_t do_env_print(cmd_tbl_t cmdtp, uint_fast8_t flag, int argc, char const argv[])
f76ca346 L	643	{
	644	command_ret_t rc = CMD_RET_SUCCESS;
	645
	646	(void) cmdtp; (void) flag;
	647
	648	if (argc == 1) {
	649	/* print all env vars */
	650	int size = env_print(NULL);
	651	if (size < 0)
	652	return CMD_RET_FAILURE;
	653	printf_P(PSTR("\nEnvironment size: %d/%d bytes\n"),
	654	size, ENV_SIZE);
	655	return CMD_RET_SUCCESS;
	656	}
	657
	658	/* print selected env vars */
	659	for (int i = 1; i < argc; ++i) {
	660	int rc = env_print(argv[i]);
	661	if (rc < 0) {
	662	printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
	663	rc = CMD_RET_FAILURE;
	664	}
	665	}
	666
	667	return rc;
	668	}
	669
	670
93ea25f2	671	command_ret_t do_env_set(cmd_tbl_t cmdtp, uint_fast8_t flag, int argc, char const argv[])
d684c216 L	672	{
	673	(void) cmdtp;
	674
	675	if (argc < 2)
	676	return CMD_RET_USAGE;
	677
	678	return _do_env_set(flag, argc, argv);
	679	}
	680
	681
93ea25f2	682	command_ret_t do_env_default(cmd_tbl_t *cmdtp, uint_fast8_t flag,
7e24905c L	683	int argc, char * const argv[])
	684	{
	685	(void) cmdtp; (void) flag; (void) argc; (void) argv;
	686
55027f3b L	687	uint8_t tmp = env_valid;
	688	env_valid = 0;
	689
7e24905c	690	/* Reset the whole environment */
55027f3b	691	printf_P(PSTR("## Resetting to default environment\n"));
7e24905c L	692	envlist_import(ENVLIST_DELETE);
7e24905c L	693
55027f3b L	694	env_valid = tmp;
55027f3b L	695
7e24905c L	696	return CMD_RET_SUCCESS;
	697	}
	698
55027f3b	699
93ea25f2	700	command_ret_t do_env_save(cmd_tbl_t cmdtp, uint_fast8_t flag, int argc, char const argv[])
323398b1 L	701	{
	702	(void) cmdtp; (void) flag; (void) argc; (void) argv;
	703
	704	printf_P(PSTR("Saving Environment ...\n"));
d0581f88	705	return saveenv() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
323398b1 L	706	}
323398b1 L	707
55027f3b	708
7e24905c	709	#if defined(CONFIG_AUTO_COMPLETE)
d684c216 L	710	int env_complete(char var, int maxv, char cmdv[], int bufsz, char *buf)
	711	{
	712	ENTRY *match;
	713	int found, idx;
	714
	715	idx = 0;
	716	found = 0;
	717	cmdv[0] = NULL;
	718
	719	while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
	720	int vallen = strlen(match->key) + 1;
	721
	722	if (found >= maxv - 2 \|\| bufsz < vallen)
	723	break;
	724
	725	cmdv[found++] = buf;
	726	memcpy(buf, match->key, vallen);
	727	buf += vallen;
	728	bufsz -= vallen;
	729	}
	730
	731	qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
	732
	733	if (idx)
	734	cmdv[found++] = "...";
	735
	736	cmdv[found] = NULL;
	737	return found;
	738	}
	739	#endif