/***********************************************************************
*
* Function: cmd_nandrs
*
* Purpose: Displays a list of reserved NAND blocks
*
* Processing:
* See function.
*
* Parameters: None
*
* Outputs: None
*
* Returns: Always returns TRUE.
*
* Notes: None
*
**********************************************************************/
BOOL_32 cmd_nandrs(void)
{
UNS_8 blk [16];
UNS_32 idx = 0;
UNS_32 fblock = 0, nblks = 0;
BOOL_32 ct, newct;
if (sysinfo.nandgood == FALSE)
{
term_dat_out(noflash_msg);
}
else
{
term_dat_out_crlf(rsvlist_msg);
ct = flash_is_rsv_block((UNS_32) idx);
while (idx < sysinfo.nandgeom.blocks)
{
/* Read "extra" data area */
newct = flash_is_rsv_block((UNS_32) idx);
if ((newct != ct) || (idx == (sysinfo.nandgeom.blocks - 1)))
{
if (ct == FALSE)
{
term_dat_out("Nonreserved blocks :");
}
else
{
term_dat_out("Reserved blocks :");
}
if (idx == (sysinfo.nandgeom.blocks - 1))
{
nblks++;
}
str_makedec(blk, fblock);
term_dat_out(blk);
term_dat_out("(");
str_makedec(blk, nblks);
term_dat_out(blk);
term_dat_out_crlf(" block(s))");
ct = newct;
nblks = 0;
fblock = (UNS_32) idx;
}
nblks++;
idx++;
}
}
return TRUE;
}
/***********************************************************************
*
* Function: cmd_clock
*
* Purpose: Clock command
*
* Processing:
* Parse the string elements for the clock command and sets the
* new clock value.
*
* Parameters: None
*
* Outputs: None
*
* Returns: TRUE if the command was processed, otherwise FALSE
*
* Notes: May not work in DDR systems.
*
**********************************************************************/
BOOL_32 cmd_clock(void)
{
UNS_32 freqr, armclk, hclkdiv, pclkdiv;
UNS_8 dclk [32];
BOOL_32 processed = TRUE;
/* Get arguments */
armclk = cmd_get_field_val(1);
hclkdiv = cmd_get_field_val(2);
pclkdiv = cmd_get_field_val(3);
if (!((hclkdiv == 1) || (hclkdiv == 2) || (hclkdiv == 4)))
{
processed = FALSE;
}
if ((pclkdiv < 1) || (pclkdiv > 32))
{
processed = FALSE;
}
if ((armclk < 33) || (armclk > 550))
{
term_dat_out_crlf(clockerr_msg);
processed = FALSE;
}
else
{
armclk = armclk * 1000 * 1000;
}
if (processed == TRUE)
{
sys_saved_data.clksetup.armclk = armclk;
sys_saved_data.clksetup.hclkdiv = hclkdiv;
sys_saved_data.clksetup.pclkdiv = pclkdiv;
freqr = clock_adjust();
if (freqr == 0)
{
term_dat_out_crlf(clockbad_msg);
}
else
{
term_dat_out(clock_msg);
str_makedec(dclk, freqr);
term_dat_out_crlf(dclk);
sys_save(&sys_saved_data);
}
}
return TRUE;
}
/***********************************************************************
*
* Function: mem_to_nand
*
* Purpose: Moves data from memory to FLASH
*
* Processing:
* See function.
*
* Parameters:
* starting_sector : Starting sector for write
* buff : Pointer to buffer to write
* bytes : Number of bytes to write
*
* Outputs: None
*
* Returns: Nothing
*
* Notes: None
*
**********************************************************************/
BOOL_32 mem_to_nand(UNS_32 starting_sector,
void *buff,
UNS_32 bytes)
{
BOOL_32 blkchk;
UNS_32 block, page, sector, wbytes;
UNS_8 str[16], *p8 = (UNS_8 *) buff;
if (sysinfo.nandgeom == NULL)
{
term_dat_out_crlf(noflash_msg);
return FALSE;
}
/* Get block and page for passed sector */
block = starting_sector / sysinfo.nandgeom->pages_per_block;
page = starting_sector -
(block * sysinfo.nandgeom->pages_per_block);
/* Align bytes to a sector boundary */
wbytes = bytes & ~(sysinfo.nandgeom->data_bytes_per_page - 1);
if (wbytes < bytes)
{
bytes = wbytes + sysinfo.nandgeom->data_bytes_per_page;
}
/* Write data */
blkchk = TRUE;
while (bytes > 0)
{
/* Is a block check needed? */
if ((page == 0) && (blkchk == TRUE))
{
if (flash_is_bad_block(block) != FALSE)
{
/* Goto next block */
term_dat_out(bskip_msg);
str_makedec(str, block);
term_dat_out_crlf(str);
block++;
page = 0;
}
else
{
/* Block is good */
blkchk = FALSE;
}
}
else
{
/* Convert to sector */
sector = conv_to_sector(block, page);
/* Write sector data */
if (flash_write_sector(sector, p8, NULL) == FALSE)
{
term_dat_out(writeerr_msg);
str_makedec(str, sector);
term_dat_out_crlf(str);
bytes = 0;
return FALSE;
}
else
{
p8 += sysinfo.nandgeom->data_bytes_per_page;
bytes -= sysinfo.nandgeom->data_bytes_per_page;
}
/* Next page and block */
page++;
if (page >= sysinfo.nandgeom->pages_per_block)
{
page = 0;
block++;
blkchk = TRUE;
}
}
}
return TRUE;
}
/***********************************************************************
*
* Function: nand_to_mem
*
* Purpose: Moves data from FLASH to memory
*
* Processing:
* See function.
*
* Parameters:
* starting_sector : Starting sector for read operation
* buff : Buffer to place read data
* bytes : Number of bytyes to read
*
* Outputs: None
*
* Returns: Nothing
*
* Notes: None
*
**********************************************************************/
BOOL_32 nand_to_mem(UNS_32 starting_sector,
void *buff,
UNS_32 bytes)
{
BOOL_32 blkchk;
UNS_32 block, page, sector, toread;
UNS_8 str[16], *p8 = (UNS_8 *) buff;
if (sysinfo.nandgeom == NULL)
{
term_dat_out_crlf(noflash_msg);
return FALSE;
}
/* Get block and page for passed sector */
block = starting_sector / sysinfo.nandgeom->pages_per_block;
page = starting_sector -
(block * sysinfo.nandgeom->pages_per_block);
/* Read data */
blkchk = TRUE;
while (bytes > 0)
{
/* Is a block check needed? */
if ((page == 0) && (blkchk == TRUE))
{
if (flash_is_bad_block(block) != FALSE)
{
/* Goto next block */
term_dat_out(bskip_msg);
str_makedec(str, block);
term_dat_out_crlf(str);
block++;
page = 0;
blkchk = TRUE;
}
else
{
blkchk = FALSE;
}
}
else
{
/* Convert to sector */
sector = conv_to_sector(block, page);
toread = bytes;
if (toread > sysinfo.nandgeom->data_bytes_per_page)
{
toread = sysinfo.nandgeom->data_bytes_per_page;
}
/* Read sector data */
if (flash_read_sector(sector, secdat, NULL) <= 0)
{
term_dat_out(readerr_msg);
str_makedec(str, sector);
term_dat_out_crlf(str);
}
memcpy(p8, secdat, toread);
p8 += toread;
bytes -= toread;
/* Next page and block */
page++;
if (page >= sysinfo.nandgeom->pages_per_block)
{
page = 0;
block++;
blkchk = TRUE;
}
}
}
return TRUE;
}
/***********************************************************************
*
* Function: cmd_info
*
* Purpose: Info command
*
* Processing:
* For the load command, start parsing subcommand elements and
* route to the specific handler.
*
* Parameters: None
*
* Outputs: None
*
* Returns: TRUE if the command was processed, otherwise FALSE
*
* Notes: None
*
**********************************************************************/
BOOL_32 cmd_info(void) {
int i, idx;
UNS_8 str [128];
UNS_32 tmp;
/* S1L configuration */
term_dat_out(prto_msg);
str_makedec(str, syscfg.prmpt_to);
term_dat_out_crlf(str);
/* Dump FLASH geometry */
term_dat_out(flashsts_msg);
if (sysinfo.nandgeom != NULL)
{
term_dat_out_crlf(present_msg);
term_dat_out(numblks_msg);
str_makedec(str, sysinfo.nandgeom->num_blocks);
term_dat_out_crlf(str);
term_dat_out(pgsblk_msg);
str_makedec(str, sysinfo.nandgeom->pages_per_block);
term_dat_out_crlf(str);
term_dat_out(pgsbyt_msg);
str_makedec(str, sysinfo.nandgeom->data_bytes_per_page);
term_dat_out_crlf(str);
tmp = sysinfo.nandgeom->num_blocks *
sysinfo.nandgeom->pages_per_block *
sysinfo.nandgeom->data_bytes_per_page;
tmp = tmp / (1024 * 1024);
term_dat_out(ttlsz_msg);
str_makedec(str, tmp);
term_dat_out_crlf(str);
/* Dump FLASH usage for stage 1 loader */
tmp = sysinfo.sysrtcfg.bl_num_blks;
term_dat_out(blspace_msg);
str_makedec(str, tmp);
term_dat_out_crlf(str);
}
else
{
term_dat_out_crlf(notpresent_msg);
}
/* Loaded program status */
term_dat_out(ftloaded_msg);
if (sysinfo.lfile.flt == FLT_NONE)
{
term_dat_out_crlf(ftnone_msg);
}
else
{
term_dat_out_crlf(ftimage_msg);
term_dat_out(ftaddr_msg);
str_makehex(str, sysinfo.lfile.loadaddr, 8);
term_dat_out_crlf(str);
term_dat_out(ftmbytes_msg);
str_makedec(str, sysinfo.lfile.num_bytes);
term_dat_out_crlf(str);
term_dat_out(fteaddr_msg);
if ((UNS_32) sysinfo.lfile.startaddr != 0xFFFFFFFF)
{
str_makehex(str, (UNS_32) sysinfo.lfile.startaddr, 8);
term_dat_out_crlf(str);
}
else
{
term_dat_out_crlf(fteaddrunk_msg);
}
}
/* FLASHed program status */
if (syscfg.fsave.valid == FALSE)
{
term_dat_out_crlf(flsnone_msg);
}
else
{
term_dat_out(fifb_msg);
str_makedec(str, syscfg.fsave.block_first);
term_dat_out_crlf(str);
term_dat_out(finbu_msg);
str_makedec(str, syscfg.fsave.blocks_used);
term_dat_out_crlf(str);
term_dat_out(finsu_msg);
str_makedec(str, syscfg.fsave.secs_used);
term_dat_out_crlf(str);
term_dat_out(finnbu_msg);
str_makedec(str, syscfg.fsave.num_bytes);
term_dat_out_crlf(str);
term_dat_out(fladd_msg);
str_makehex(str, syscfg.fsave.loadaddr, 8);
term_dat_out_crlf(str);
term_dat_out(fsadd_msg);
str_makehex(str, syscfg.fsave.startaddr, 8);
term_dat_out_crlf(str);
}
/* Autoboot source */
term_dat_out(absrc_msg);
switch (syscfg.aboot.abootsrc)
{
case SRC_TERM:
term_dat_out_crlf(absrcterm_msg);
break;
case SRC_NAND:
term_dat_out_crlf(absrcnand_msg);
break;
case SRC_BLKDEV:
term_dat_out(absrcsd_msg);
term_dat_out_crlf(syscfg.aboot.fname);
break;
case SRC_NONE:
default:
term_dat_out_crlf(absnone_msg);
break;
}
if (syscfg.aboot.abootsrc != SRC_NONE)
{
term_dat_out(absrcft_msg);
switch (syscfg.aboot.flt)
{
case FLT_RAW:
term_dat_out_crlf(absrcraw_msg);
break;
case FLT_BIN:
term_dat_out_crlf(absrcnbin_msg);
break;
case FLT_SREC:
term_dat_out_crlf(absrcsrec_msg);
break;
case FLT_ELF:
term_dat_out_crlf(absrcelf_msg);
break;
default:
/* These should never happen */
break;
}
if (syscfg.aboot.abootsrc != SRC_NAND)
{
term_dat_out(abadd_msg);
str_makehex(str, syscfg.aboot.loadaddr, 8);
term_dat_out_crlf(str);
term_dat_out(abeadd_msg);
str_makehex(str, syscfg.aboot.startaddr, 8);
term_dat_out_crlf(str);
}
}
/* Show any scripts */
term_dat_out((UNS_8 *) "Scripting: ");
if ((syscfg.scr.number_entries == 0) ||
(syscfg.scr.enabled == FALSE)) {
term_dat_out_crlf((UNS_8 *) "Disabled");
}
else {
term_dat_out_crlf((UNS_8 *) "Enabled");
idx = 0;
for (i = 0; i < syscfg.scr.number_entries; i++) {
term_dat_out((UNS_8 *) "-S>");
term_dat_out_crlf(&syscfg.scr.script_data[idx]);
idx = idx + syscfg.scr.entry_size[i] + 1;
}
}
/* Call user defined extended info */
cmd_info_extend();
return TRUE;
}
