param.c

motorola自己开发的针对coldfire 5272的Dbug bootloader程序

/*
 * File:		param.c
 * Purpose:		Common routines to set/get parameters
 *
 * Notes:		
 *
 */

#include "src/include/dbug.h"
#include "param.h"

/********************************************************************/

extern void
update_board_params (uint8*, int, uint32);

/********************************************************************/
void
board_set_baud (int baud)
{
	uint8 bps[4];
	PARAM *tparam = (PARAM *)NULL;

	*((uint32 *)bps) = baud;

	update_board_params(bps, 4, (uint32)&tparam->baud);
}

/********************************************************************/
int
board_get_baud (void)
{
	int baud;

	switch (((PARAM *)PARAMS_ADDRESS)->baud)
	{
		case 9600:	
			baud = 9600;	
			break;
		case 38400:	
			baud = 38400;	
			break;
		case 57600:	
			baud = 57600;	
			break;
		case 115200:	
			baud = 115200;	
			break;
		case 19200:	
		default:	
			baud = 19200;
			break;
	}
	return baud;
}

/********************************************************************/

#ifdef DBUG_NETWORK

/********************************************************************/
void
board_set_ethaddr (uint8 ethaddr[])
{
	PARAM *tparam = (PARAM *)NULL;

	update_board_params(ethaddr, 6, (uint32)&tparam->ethaddr);
}

/********************************************************************/
uint8 *
board_get_ethaddr (uint8 ethaddr[])
{
	int i;

	for (i = 0; i < 6; i++)
	{
		ethaddr[i] = ((PARAM *)PARAMS_ADDRESS)->ethaddr[i];
	}
	return ethaddr;
}

/********************************************************************/
static int
parse_ethaddr (char *ethstr, uint8 *ethaddr)
{
	int i, j, l, ti;
	char *m;
	char tstr[3];
	unsigned long ul;

	l = strlen(ethstr) + 1;
	j = 0;
	ti = 0;

	for (i = 0; i < l; i++)
	{
		if ((ethstr[i] != ':') && (ethstr[i] != '\0'))
		{
			if (ti >= 2)
			{
				return 0;
			}
			else
			{
				tstr[ti++] = ethstr[i];
			}
		}
		else
		{
			/*
			 * convert string portion started at 'p'
			 */
			tstr[ti] = '\0';
			ti = 0;
			ul = strtoul(tstr,&m,16);
			if ((ul == 0) && (m == tstr))
			{
				return 0;
			}
			ethaddr[j++] = (uint8)ul;
		}
	}
	if (j == 6)
		return 1;
	else
		return 0;
}

/********************************************************************/
void
board_ethaddr (int argc, char **argv)
{
	/*
	 * This function sets or shows the Ethernet Address
	 * assigned to this board.  The address is contained in
	 * the FLASH.
	 */
	uint8 ethaddr[6];
	int i;

	(void)argc;

	if (argv[2] == NULL)
	{
		board_get_ethaddr(ethaddr);
		for (i = 0; i < 6; i++)
		{
			if (i != 5)
			{
				printf("%02X:",ethaddr[i]);
			}
			else
			{
				printf("%02X\n",ethaddr[i]);
			}
		}
		return;
	}

	if (parse_ethaddr(argv[2],ethaddr))
	{
		board_set_ethaddr(ethaddr);
	}
	else
	{
		printf("Error:  Invalid Ethernet Address:  %s\n", argv[2]);
	}
}

/********************************************************************/
void
board_set_client (uint8 client[])
{
	PARAM *tparam = (PARAM *)NULL;

	update_board_params(client, 4, (uint32)&tparam->client);
}

/********************************************************************/
uint8 *
board_get_client (uint8 client[])
{
	int i;

	for (i = 0; i < 4; i++)
	{
		client[i] = ((PARAM *)PARAMS_ADDRESS)->client[i];
	}
	return client;
}

/********************************************************************/
void
board_set_server (uint8 server[])
{
	PARAM *tparam = (PARAM *)NULL;

	update_board_params(server, 4, (uint32)&tparam->server);
}

/********************************************************************/
uint8 *
board_get_server (uint8 server[])
{
	int i;

	for (i = 0; i < 4; i++)
	{
		server[i] = ((PARAM *)PARAMS_ADDRESS)->server[i];
	}
	return server;
}

/********************************************************************/
void
board_set_gateway (uint8 gateway[])
{
	PARAM *tparam = (PARAM *)NULL;

	update_board_params(gateway, 4, (uint32)&tparam->gateway);
}

/********************************************************************/
uint8 *
board_get_gateway (uint8 gateway[])
{
	int i;

	for (i = 0; i < 4; i++)
	{
		gateway[i] = ((PARAM *)PARAMS_ADDRESS)->gateway[i];
	}
	return gateway;
}

/********************************************************************/
void
board_set_netmask (uint8 netmask[])
{
	PARAM *tparam = (PARAM *)NULL;

	update_board_params(netmask, 4, (uint32)&tparam->netmask);
}

/********************************************************************/
uint8 *
board_get_netmask (uint8 netmask[])
{
	int i;

	for (i = 0; i < 4; i++)
	{
		netmask[i] = ((PARAM *)PARAMS_ADDRESS)->netmask[i];
	}
	return netmask;
}

/********************************************************************/
void
board_set_filename (char filename[])
{
	PARAM *tparam = (PARAM *)NULL;

	update_board_params((uint8 *)filename, FILENAME_SIZE, 
						(uint32)&tparam->filename);
}

/********************************************************************/
char *
board_get_filename (char filename[])
{
	int c, i = 0;

	while (i < FILENAME_SIZE)
	{
		c = ((PARAM *)PARAMS_ADDRESS)->filename[i];
		filename[i] = (char)c;
		++i;
		if (c == '\0')
		{
			i = FILENAME_SIZE;
		}
	}
	filename[i] = '\0';
	return filename;
}

/********************************************************************/
int
board_get_filetype (void)
{
	return ((PARAM *)PARAMS_ADDRESS)->netcfg[2];
}

/********************************************************************/
void
board_set_filetype (int ft)
{
	PARAM *tparam = (PARAM *)NULL;
	uint8 netcfg;

	netcfg = (uint8)ft;

	update_board_params(&netcfg, 1, (uint32)&tparam->netcfg[2]);
}

/********************************************************************/
int
board_get_autoboot (void)
{
	return ((PARAM *)PARAMS_ADDRESS)->netcfg[0];
}

/********************************************************************/
void
board_set_autoboot (int onoff)
{
    PARAM *tparam = (PARAM *)NULL;
	uint8 netcfg;

	if (onoff)
	{
		netcfg = TRUE;
	}
	else
	{
		netcfg = FALSE;
	}
	
	update_board_params(&netcfg, 1, (uint32)&tparam->netcfg[0]);
}

/********************************************************************/

#endif /* DBUG_NETWORK */

/********************************************************************/