/*********************************************************************** * * 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_peek * * Purpose: Peek command * * Processing: * Parse the string elements for the peek command and display the * peeked value. * * Parameters: None * * Outputs: None * * Returns: TRUE if the command was processed, otherwise FALSE * * Notes: None * **********************************************************************/ static BOOL_32 cmd_peek(void) { UNS_32 newaddr, newwidth; /* If only 1 parsed command, then print at current address and width */ if (parse_get_entry_count() > 1) { /* Get address */ newaddr = cmd_get_field_val(1); /* Width */ newwidth = last_width; if (parse_get_entry_count() >= 3) { newwidth = cmd_get_field_val(2); if (!((newwidth == 1) || (newwidth == 2) || (newwidth == 4))) { newwidth = 1; } } last_addr = newaddr; last_width = newwidth; } /* Based on width, limit address start */ last_addr = last_addr & ~(last_width - 1); /* Dump data */ hex_dump(last_addr, last_width, 1); return TRUE; }
/*********************************************************************** * * Function: cmd_dump * * Purpose: Dump command * * Processing: * Parse the string elements for the dump command and display the * dumped values. * * Parameters: None * * Outputs: None * * Returns: TRUE if the command was processed, otherwise FALSE * * Notes: None * **********************************************************************/ static BOOL_32 cmd_dump(void) { UNS_32 newaddr, newwidth, newtrans; /* If only 1 parsed command, then print at current address and width */ if (parse_get_entry_count() > 1) { newaddr = dump_addr; newwidth = dump_width; newtrans = dump_trans; /* Get address */ newaddr = cmd_get_field_val(1); /* Convert decimal value to width */ if (parse_get_entry_count() >= 3) { newtrans = cmd_get_field_val(2); } if (parse_get_entry_count() >= 4) { newwidth = cmd_get_field_val(3); if (!((newwidth == 1) || (newwidth == 2) || (newwidth == 4))) { newwidth = 1; } } dump_addr = newaddr; dump_width = newwidth; dump_trans = newtrans; /* Limit dump size to 1024 bytes */ if ((dump_trans * dump_width) > 1024) { dump_trans = dump_trans / dump_width; } } /* Based on width, limit address start */ dump_addr = dump_addr & ~(dump_width - 1); /* Dump data and increment address */ hex_dump(dump_addr, dump_width, dump_trans); dump_addr = dump_addr + (dump_width * dump_trans); return TRUE; }
/*********************************************************************** * * Function: cmd_help * * Purpose: Processes the help command * * Processing: * See function. * * Parameters: None * * Outputs: None * * Returns: Nothing * * Notes: None * **********************************************************************/ BOOL_32 cmd_help(void) { GROUP_LIST_T *pGroup = &group_list_head; UNS_8 *str = get_parsed_entry(1); CMD_ROUTE_T *pCmd; // If this is just the help command with no arguments, then display // the standard help message if (parse_get_entry_count() == 1) { cmd_show_group_help(pGroup, FALSE); } else { // Verify second argument if (str_cmp(str, "menu") == 0) { // Show everything while (pGroup != NULL) { cmd_show_group_help(pGroup, FALSE); pGroup = pGroup->next_group; } } else if (str_cmp(str, "all") == 0) { // Show everything while (pGroup != NULL) { cmd_show_group_help(pGroup, TRUE); pGroup = pGroup->next_group; } } else { // Second argument is either a command or group name, so // attempt to find the matching name if (cmd_find_index(str, &pGroup, &pCmd) == FALSE) { // No matching group or command term_dat_out_crlf(helperr_msg); } else { if (pCmd != NULL) { cmd_show_cmd_help(pCmd); } else { cmd_show_group_help(pGroup, TRUE); } } } } 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: cmd_script * * Purpose: Sets up, enables, or disables startup scripting * * Processing: * See function. * * Parameters: None * * Outputs: None * * Returns: TRUE if the command was accepted, otherwise FALSE * * Notes: None * **********************************************************************/ static BOOL_32 cmd_script(void) { BOOL_32 update = FALSE, parsed = FALSE; UNS_8 *str = get_parsed_entry(1); if (parse_get_entry_count() == 2) { /* on, off, or setup commands? */ if (str_cmp(str, "on") == 0) { if ((syscfg.scr.number_entries > 0) && (syscfg.scr.enabled == FALSE)) { syscfg.scr.enabled = TRUE; update = TRUE; } parsed = TRUE; } else if (str_cmp(str, "off") == 0) { if (syscfg.scr.enabled == TRUE) { syscfg.scr.enabled = FALSE; update = TRUE; } parsed = TRUE; } else if (str_cmp(str, "setup") == 0) { syscfg.scr.enabled = TRUE; update = parsed = script_capture(); } else term_dat_out_crlf((UNS_8 *) "Invalid script command, type help script for more " "info"); if (update) cfg_save(&syscfg); } return parsed; }
/*********************************************************************** * * 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_update * * Purpose: Updates the stage 1 bootloader * * Processing: * See function. * * Parameters: None * * Outputs: None * * Returns: Always returns TRUE. * * Notes: None * **********************************************************************/ BOOL_32 cmd_update(void) { BOOL_32 updated = FALSE; /* Is an image in memory? */ if (sysinfo.lfile.flt == FLT_NONE) { term_dat_out_crlf(updnoim_msg); return TRUE; } /* Is an image in memory a raw image? */ if (sysinfo.lfile.flt != FLT_RAW) { term_dat_out_crlf(updnotraw_msg); return TRUE; } /* Is the image in memory contiguous? */ if (sysinfo.lfile.contiguous == FALSE) { term_dat_out_crlf(updnotc_msg); return TRUE; } /* Is the image for stage 1 or the kickstart loader */ if (parse_get_entry_count() == 2) { /* Get passed command */ if (str_cmp(get_parsed_entry(1), "kick") == 0) { /* Updating block 0, does the image exceed 15.5K(small block)? * large block 54K */ if (sysinfo.lfile.num_bytes > (31 * 512)) { term_dat_out_crlf(updgt31_msg); return TRUE; } else { updated = nand_kickstart_update(); } } } else { /* Updating block 0, does the image exceed 256K? */ if (sysinfo.lfile.num_bytes > (256 * 512)) { term_dat_out_crlf(updgt256_msg); return TRUE; } else { updated = nand_bootloader_update(); } } /* Image in memory passes all checks, FLASH it at start of block 0 */ if (updated == FALSE) { term_dat_out_crlf(updfail_msg); } else { term_dat_out_crlf(updgood_msg); } return TRUE; }
/*********************************************************************** * * 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; }