/*********************************************************************** * * 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; }