/***********************************************************************
*
* Function: cmd_exec
*
* Purpose: Executes a program or at an address
*
* Processing:
* See function.
*
* Parameters: None
*
* Outputs: None
*
* Returns: TRUE if the command was good, otherwise FALSE
*
* Notes: None
*
**********************************************************************/
BOOL_32 cmd_exec(void)
{
UNS_8 *curp;
UNS_32 ea;
BOOL_32 execgood;
/* An address was passed, use it */
if (parse_get_entry_count() == 1) {
if (sysinfo.lfile.startaddr != (PFV) 0xFFFFFFFF)
{
menuexit = TRUE;
}
}
else if (parse_get_entry_count() == 2) {
curp = get_parsed_entry(1);
execgood = str_hex_to_val(curp, &ea);
if (execgood == TRUE)
{
menuexit = TRUE;
sysinfo.lfile.startaddr = (PFV) ea;
}
}
return TRUE;
}
/***********************************************************************
*
* Function: cmd_maddr
*
* Purpose: Sets MAC address of ethernet device
*
* Processing:
* See function.
*
* Parameters: None
*
* Outputs: None
*
* Returns: TRUE if the command was good, otherwise FALSE
*
* Notes: None
*
**********************************************************************/
BOOL_32 cmd_maddr(void) {
int idx, offs;
UNS_8 *p8, *curp, mac[8], str[16];
UNS_32 ea;
BOOL_32 goodmac = FALSE;
str [0] = '0';
str [1] = 'x';
str [4] = '\0';
mac [6] = mac [7] = 0;
/* An address was passed, use it */
if (parse_get_entry_count() == 2) {
curp = get_parsed_entry(1);
goodmac = TRUE;
offs = 0;
for (idx = 0; idx < 6; idx++) {
str [2] = curp[offs];
str [3] = curp[offs + 1];
goodmac &= str_hex_to_val(str, &ea);
mac [idx] = (UNS_8) ea;
offs += 3;
}
if (goodmac == TRUE)
{
/* Yes NO VERIFY? */
term_dat_out(smac_msg);
if (prompt_yesno() != FALSE)
{
/* Save structure */
for (idx = 0; idx < 8; idx++) {
phyhwdesc.mac [idx] = mac [idx];
}
p8 = (UNS_8 *) &phyhwdesc;
for (idx = 0; idx < sizeof(phyhwdesc); idx++)
{
phy3250_sspwrite(*p8, (PHY3250_SEEPROM_CFGOFS + idx));
p8++;
}
}
}
else
{
term_dat_out_crlf(macafail_msg);
}
}
return goodmac;
}
/***********************************************************************
*
* Function: srec_get_hex
*
* Purpose: Gets a hex value from a s-record hex field
*
* Processing:
* See function.
*
* Parameters:
* data : Pointer to start of hex field
* numchars : Number of hex characters in field
*
* Outputs: None
*
* Returns: Converted hex value
*
* Notes: None
*
**********************************************************************/
static UNS_32 srec_get_hex(UNS_8 *data,
int numchars) {
UNS_32 hval;
UNS_8 hexval [32];
int offset;
offset = 0;
hexval [0] = '0';
hexval [1] = 'x';
while (numchars > offset) {
hexval [offset + 2] = data [offset];
offset++;
}
hexval [offset + 2] = '\0';
str_hex_to_val(hexval, &hval);
return hval;
}
/***********************************************************************
*
* Function: cmd_parse_fields
*
* Purpose: Parses and verifies parsed field entries
*
* Processing:
* See function.
*
* Parameters:
* pCmd : Pointer to command to verify parsing for
*
* Outputs: None
*
* Returns: Nothing
*
* Notes: None
*
**********************************************************************/
BOOL_32 cmd_parse_fields(CMD_ROUTE_T *pCmd)
{
UNS_32 tval, *parse_list = pCmd->parse_list;
int pfield, fields = parse_get_entry_count();
BOOL_32 good = TRUE;
// If the command has a free-form parse, then just exit
if ((*parse_list & PARSE_TYPE_FREE) != 0)
{
return TRUE;
}
// Process list
pfield = 0;
while ((pfield < fields) && (good == TRUE))
{
if (pfield == 0)
{
// This is just the command name
tval = (UNS_32) get_parsed_entry(0);
}
else
{
// Parse based on expected type
switch (*parse_list & 0xF)
{
case PARSE_TYPE_STR:
tval = (UNS_32) get_parsed_entry(pfield);
break;
case PARSE_TYPE_DEC:
good = str_dec_to_val(get_parsed_entry(pfield),
&tval);
break;
case PARSE_TYPE_HEX:
good = str_hex_to_val(get_parsed_entry(pfield),
&tval);
break;
default:
good = FALSE;
}
}
// Save pointer or value
pFData [pfield] = tval;
// Is this the last entry?
if (pfield >= (fields - 1))
{
// Is this entry marked with the end or optional flag?
if ((*parse_list & (PARSE_TYPE_OPT | PARSE_TYPE_END)) == 0)
{
// Not, parse line ended unexpectedly
good = FALSE;
}
}
else
{
/* Verify the parse line isn't too long */
if ((*parse_list & PARSE_TYPE_END) != 0)
{
/* Command line is too long */
good = FALSE;
}
}
/* Next entries */
parse_list++;
pfield++;
}
return good;
}
/***********************************************************************
*
* Function: cmd_aboot
*
* Purpose: Sets autoboot source
*
* Processing:
* See function.
*
* Parameters: None
*
* Outputs: None
*
* Returns: Always returns TRUE
*
* Notes: None
*
**********************************************************************/
BOOL_32 cmd_aboot(void)
{
UNS_8 *curp;
UNS_32 addr;
BOOL_32 processed = TRUE, ready = FALSE;
INT_32 nexidx;
ABOOT_SETUP_T abs;
abs.fname [0] = '\0';
if (parse_get_entry_count() >= 3)
{
/* Get source */
curp = get_parsed_entry(1);
nexidx = 2;
if (str_cmp(curp, "term") == 0)
{
/* Clear break */
term_break();
abs.abootsrc = SRC_TERM;
}
else if (str_cmp(curp, "blk") == 0)
{
abs.abootsrc = SRC_BLKDEV;
/* Get filename */
curp = get_parsed_entry(2);
memcpy(abs.fname, curp, str_size(curp));
abs.fname[str_size(curp)] = '\0';
nexidx = 3;
}
else if (str_cmp(curp, "flash") == 0)
{
abs.abootsrc = SRC_NAND;
}
else if (str_cmp(curp, "none") == 0)
{
abs.abootsrc = SRC_NONE;
}
else
{
term_dat_out_crlf(invalsrc_msg);
processed = FALSE;
}
/* Get file type */
curp = get_parsed_entry(nexidx);
abs.flt = FLT_NONE;
if (str_cmp(curp, "elf") == 0)
{
abs.flt = FLT_ELF;
}
else if (str_cmp(curp, "raw") == 0)
{
abs.flt = FLT_RAW;
}
else if (str_cmp(curp, "bin") == 0)
{
abs.flt = FLT_BIN;
}
else if (str_cmp(curp, "srec") == 0)
{
abs.flt = FLT_SREC;
}
else
{
abs.flt = FLT_NONE;
term_dat_out(unkft_msg);
term_dat_out_crlf(curp);
processed = FALSE;
}
/* Next index */
nexidx++;
/* Handle each file type */
if (processed == TRUE)
{
switch (abs.flt)
{
case FLT_RAW:
/* Get load address */
curp = get_parsed_entry(nexidx);
ready = str_hex_to_val(curp, &addr);
if (ready == TRUE)
{
abs.loadaddr = addr;
abs.startaddr = addr;
}
else
{
term_dat_out_crlf(rawna_msg);
}
/* Start address */
nexidx++;
curp = get_parsed_entry(nexidx);
if (curp != NULL)
{
ready &= str_hex_to_val(curp, &addr);
if (ready == TRUE)
{
abs.startaddr = addr;
}
}
break;
case FLT_BIN:
ready = FALSE; /* TBD not supported yet */
processed = TRUE;
break;
case FLT_SREC:
ready = TRUE;
processed = TRUE;
break;
case FLT_ELF:
ready = FALSE; /* TBD not supported yet */
processed = TRUE;
break;
default:
break;
}
}
}
if (ready == TRUE)
{
syscfg.aboot = abs;
cfg_save(&syscfg);
term_dat_out_crlf(bsgood_msg);
}
else
{
term_dat_out_crlf(bsbad_msg);
}
return TRUE;
}
/***********************************************************************
*
* Function: cmd_load
*
* Purpose: Load command
*
* Processing:
* For the load command, start parsing subcommand elements and
* route to the specific handler.
*
* Parameters: None
*
* Outputs: None
*
* Returns: Always returns TRUE
*
* Notes: None
*
**********************************************************************/
BOOL_32 cmd_load(void) {
UNS_8 *curp;
UNS_32 addr;
BOOL_32 processed = TRUE, loaded = FALSE;
FILE_DATA_T fdata;
SRC_LOAD_T src = SRC_TERM;
INT_32 nexidx;
UNS_8 *fname;
if (parse_get_entry_count() >= 3)
{
/* Get source */
curp = get_parsed_entry(1);
nexidx = 2;
if (str_cmp(curp, "term") == 0)
{
/* Clear break */
term_break();
src = SRC_TERM;
}
else if (str_cmp(curp, "blk") == 0)
{
src = SRC_BLKDEV;
nexidx = 3;
}
else if (str_cmp(curp, "flash") == 0)
{
src = SRC_NAND;
}
else
{
term_dat_out_crlf(invalsrc_msg);
processed = FALSE;
}
/* Get file type */
curp = get_parsed_entry(nexidx);
fdata.flt = FLT_NONE;
if (str_cmp(curp, "elf") == 0)
{
fdata.flt = FLT_ELF;
}
else if (str_cmp(curp, "raw") == 0)
{
fdata.flt = FLT_RAW;
}
else if (str_cmp(curp, "bin") == 0)
{
fdata.flt = FLT_BIN;
}
else if (str_cmp(curp, "srec") == 0)
{
fdata.flt = FLT_SREC;
}
else
{
fdata.flt = FLT_NONE;
term_dat_out(unkft_msg);
term_dat_out_crlf(curp);
processed = FALSE;
}
/* Next index */
nexidx++;
/* Handle each file type */
if (processed == TRUE)
{
/* Get filename */
fname = get_parsed_entry(2);
switch (fdata.flt)
{
case FLT_RAW:
/* Get load address */
curp = get_parsed_entry(nexidx);
loaded = str_hex_to_val(curp, &addr);
if (loaded == TRUE)
{
fdata.loadaddr = addr;
fdata.startaddr = (PFV) addr;
}
else
{
term_dat_out_crlf(rawna_msg);
}
/* Start address */
nexidx++;
curp = get_parsed_entry(nexidx);
if (curp != NULL)
{
loaded &= str_hex_to_val(curp, &addr);
if (loaded == TRUE)
{
fdata.startaddr = (PFV) addr;
}
}
if (loaded == TRUE)
{
loaded = raw_load(&fdata, fdata.loadaddr,
fname, src);
}
processed = TRUE;
break;
case FLT_BIN:
processed = TRUE; /* TBD not supported yet */
break;
case FLT_SREC:
loaded = srec_parse(&fdata, src, fname);
break;
case FLT_ELF:
processed = TRUE; /* TBD not supported yet */
break;
default:
break;
}
}
}
if (loaded == TRUE)
{
term_dat_out_crlf(floaded_msg);
sysinfo.lfile.loadaddr = fdata.loadaddr;
sysinfo.lfile.flt = fdata.flt;
sysinfo.lfile.num_bytes = fdata.num_bytes;
sysinfo.lfile.startaddr = fdata.startaddr;
sysinfo.lfile.contiguous = fdata.contiguous;
sysinfo.lfile.loaded = TRUE;
}
else
{
term_dat_out_crlf(notloaded_msg);
sysinfo.lfile.loadaddr = 0xFFFFFFFF;
sysinfo.lfile.flt = FLT_NONE;
sysinfo.lfile.num_bytes = 0;
sysinfo.lfile.startaddr = (PFV) 0xFFFFFFFF;
processed = FALSE;
}
return TRUE;
}
