info.c

MIPS YAMON, a famous monitor inc. source, make file and PDF manuals.

    if( descr )
    {
       strcat( syntax_descr, "\n" );
       strcat( syntax_descr, name );
       strcat( syntax_descr, " : " );
       for( i = strlen(name); i < MAX_NAME_LEN; i++ )
           strcat( syntax_descr, " " );
       strcat( syntax_descr, descr );
    }

    item[item_count].name = name;
    item[item_count].func = func;
    item_count++;
}

/************************************************************************
 *                          determine_total_flash
 ************************************************************************/
static UINT32
determine_total_flash( void )
{
    UINT32 flash_size = 0;
    UINT32 wdata;

    if(SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_SIZE_ID,  
		    &wdata, sizeof(wdata) ) == OK)
    {
        flash_size += wdata;
    }

    if(SYSCON_read( SYSCON_BOARD_MONITORFLASH_SIZE_ID, &wdata,
	            sizeof(wdata) ) == OK)
    {
        flash_size += wdata;
    }

    if(SYSCON_read( SYSCON_BOARD_FILEFLASH_SIZE_ID, &wdata,
		        sizeof(wdata) ) == OK)
    {
        flash_size += wdata;
    }

    return flash_size;
}


/************************************************************************
 *                          disp_prid
 ************************************************************************/
static bool
disp_prid(
    UINT32 prid )
{
    UINT8 bdata;
    char  msg[80];
    char  *name;

    /* Processor Company ID/Options */
    if(SHELL_PUTS( "Processor Company ID/options =" )) return TRUE;

    bdata = (prid & M_PRIdCoID) >> S_PRIdCoID;
    sprintf( msg, "0x%02x", bdata );
    if(SHELL_PUTS_INDENT( msg, INDENT )) return TRUE;

    name = sys_decode_compid( bdata );
    if( name )
        sprintf( msg, " (%s) / ", name );
    else
        sprintf( msg, " / " );
    if(SHELL_PUTS( msg )) return TRUE;

    bdata = (prid & M_PRIdCoOpt) >> S_PRIdCoOpt;
    sprintf( msg, "0x%02x\n", bdata );
    if(SHELL_PUTS( msg )) return TRUE;

    /* Processor ID/Revision */
    if(SHELL_PUTS( "Processor ID/revision =" )) return TRUE;

    bdata = (prid & M_PRIdImp) >> S_PRIdImp;
    sprintf( msg, "0x%02x", bdata );
    if(SHELL_PUTS_INDENT( msg, INDENT )) return TRUE;

    name = sys_decode_procid();

    if( name )
    {
        sprintf( msg, " (%s)", name );
        if(SHELL_PUTS( msg )) return TRUE;
    }

    sprintf( msg, " / 0x%02x\n", ((prid & M_PRIdRev) >> S_PRIdRev) );

    return (SHELL_PUTS_INDENT( msg, INDENT ));
}


/************************************************************************
 *                          info_microsoft
 ************************************************************************/
static void
info_microsoft( void )
{
    UINT32 wdata;
    UINT32 flash_size;
    char   msg[80];

    if(SHELL_PUTS( "\nSDB Information List :" )) return;
    
    /* Company */
    if(SHELL_PUTS( "\n\n**** Company ****\n" )) return;
    if(SHELL_PUTS( MIPS_NAME )) return;

    /* Support */
    if(SHELL_PUTS( "\n\n**** Support ****\n" )) return;
    if(SHELL_PUTS( SUPPORT )) return;

    /* SDB Board version */
    determine_sdbrevision( msg );
    if(SHELL_PUTS( "\n\n**** SDB Board Version ****\n" )) return;
    if(SHELL_PUTS( msg )) return;

    /* Boot Monitor Revision Date */
    if(SHELL_PUTS( "\n\n**** Boot Monitor Revision Date ****\n" )) return;
    if(SHELL_PUTS( _shell_date )) return;         /* TBD MM/DD/YYYY */

    if(SYSCON_read( SYSCON_CPU_CP0_PRID_ID, &wdata, sizeof(wdata)) == OK)
    {
        if(SHELL_PUTS( "\n\n**** Processor ID/Version ****\n" )) return;

        /* ProcessorID */
	if( disp_prid( wdata ) )
	    return;
    }

    /* Upgrade Info */
    if(SHELL_PUTS( "\n\n**** Upgrade Info ****\n" )) return;
    if(SHELL_PUTS( UPGRADE )) return;

    /* Configuration Info */
    if(SHELL_PUTS( "\n\n**** Configuration Info ****\n" )) return;
    if(SHELL_PUTS( CONFIGURATION )) return;

    /**** Memory ****/

    if(SHELL_PUTS( "\n\n**** Memory Footprint ****\n" )) return;
 
    if(SYSCON_read( SYSCON_BOARD_SYSTEMRAM_ACTUAL_SIZE_ID, 
		    &wdata, sizeof(wdata)) == OK)
    {
        if(SHELL_PUTS( "SDRAM size =" )) return;
        sprintf( msg, "%d MB\n", wdata/(1024*1024) );
        if(SHELL_PUTS_INDENT( msg, INDENT )) return;
    }

    flash_size = determine_total_flash();
    if(SHELL_PUTS( "Flash memory size =" )) return;
    sprintf( msg, "%d MB\n", flash_size/(1024*1024) );
    if(SHELL_PUTS_INDENT( msg, INDENT )) return;
}

static void
determine_sdbrevision( 
    char *msg )
{
    UINT32 brev, ctype, crev, frev;
  
    strcpy( msg, SDBREV );

    /*  We can assume this is an Atlas board since info_sdb is only
     *  registered in that case.
     */

    SYSCON_read(SYSCON_BOARD_PRODUCTREV_ID,  &brev,  sizeof(UINT32));
    SYSCON_read(SYSCON_BOARD_CORECARDID_ID,  &ctype, sizeof(UINT32));
    SYSCON_read(SYSCON_BOARD_CORECARDREV_ID, &crev,  sizeof(UINT32));
    SYSCON_read(SYSCON_BOARD_FPGAREV_ID,     &frev,  sizeof(UINT32));

    if(      (brev   == 0)	 &&
	     (ctype  == 0)	 &&
	     (crev   == 0)	 &&
	     (frev   <= 6) )
    {
 	strcat( msg, "1.0" );
    }
    else if( (brev   == 0)	 &&
	     (ctype  == 0)	 &&
	     (crev   == 0)	 &&
	     (frev   == 7) )
    {
 	strcat( msg, "1.1" );
    }
    else
    {
	strcpy( msg, SDBREV_UNKNOWN );
    }
}

/************************************************************************
 *                          info_uart
 ************************************************************************/

static bool
info_uart( void )
{
    char   msg[80];
    UINT32 myport;
    UINT32 mymajor;
    UINT32 myminor;
    t_SERIAL_ctrl_descriptor my_ioctl;

    my_ioctl.sc_command = SERIAL_CTRL_GET_STATISTICS;

    for ( myport = PORT_TTY0; myport <= PORT_TTY1; myport++ )
    {
	SYSCON_read( (myport == PORT_TTY0) ? SYSCON_COM_TTY0_MAJOR : SYSCON_COM_TTY1_MAJOR,
	             (void *)(&mymajor),
		     sizeof(UINT32) );

	SYSCON_read( (myport == PORT_TTY0) ? SYSCON_COM_TTY0_MINOR : SYSCON_COM_TTY1_MINOR,
	             (void *)(&myminor),
		     sizeof(UINT32) );

        sprintf( msg, "TTY%x:\n", myport );
        if(SHELL_PUTS( msg )) return FALSE;

        if (IO_ctrl(mymajor, myminor, &my_ioctl)) continue;

        if(SHELL_PUTS( " Bytes transmitted:" )) return FALSE;
        sprintf( msg, "%d\n", my_ioctl.sc_arg.sc_statistics.ua_tx_bytes);
        if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;

        if(SHELL_PUTS( " Bytes received:" )) return FALSE;
        sprintf( msg, "%d\n", my_ioctl.sc_arg.sc_statistics.ua_rx_bytes);
        if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;

        if(SHELL_PUTS( " Receive overruns:" )) return FALSE;
        sprintf( msg, "%d\n", my_ioctl.sc_arg.sc_statistics.ua_rx_overrun);
        if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;

        if(SHELL_PUTS( " Receive parity errors:" )) return FALSE;
        sprintf( msg, "%d\n", my_ioctl.sc_arg.sc_statistics.ua_rx_parity);
        if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;

        if(SHELL_PUTS( " Receive framing errors:" )) return FALSE;
        sprintf( msg, "%d\n", my_ioctl.sc_arg.sc_statistics.ua_rx_framing);
        if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;

        if(SHELL_PUTS( " Receive breaks:" )) return FALSE;
        sprintf( msg, "%d\n", my_ioctl.sc_arg.sc_statistics.ua_rx_break);
        if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;

        if(SHELL_PUTS( " Receive Interrupts:" )) return FALSE;
        sprintf( msg, "%d\n", my_ioctl.sc_arg.sc_statistics.ua_rx_irqs);
        if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;

        if(SHELL_PUTS( " No of resets:" )) return FALSE;
        sprintf( msg, "%d\n", my_ioctl.sc_arg.sc_statistics.ua_no_of_init);
        if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;
    }
    
    return TRUE;
}


/************************************************************************
 *                          info_lan
 ************************************************************************/

static bool
info_lan( void )
{
    /* TBD : should be able to break */

    INT32 rcode ;
    UINT32 en0_major_device ;
    t_LAN_CTRL_desc lan_ioctl;

    /* get a EN0 major device number */
    rcode = SYSCON_read( SYSCON_COM_EN0_MAJOR_DEVICE_ID,
                         &(en0_major_device),
                         sizeof(en0_major_device) );
    if (rcode)  return FALSE ;

    /* Display LAN device driver statistics */
    lan_ioctl.command = LAN_CTRL_DISPLAY_STATISTICS ;
    IO_ctrl(  en0_major_device, 0, &lan_ioctl ) ;

    return TRUE;
}


/************************************************************************
 *                          info_pci
 ************************************************************************/
static bool
info_pci( void )
{
    /* TBD : should be able to break */

    pci_display();

    return TRUE;
}


/************************************************************************
 *                          info_ide
 ************************************************************************/
static bool
info_ide( void )
{
    return (shell_ide_display() == OK ) ? TRUE : FALSE;
}


/************************************************************************
 *                          info_isa
 ************************************************************************/
static bool
info_isa( void )
{
    return isa_display();
}


/************************************************************************
 *                          info_cpu
 ************************************************************************/
static bool
info_cpu( void )
{
    char   msg[80];
    UINT32 wdata, wdata_cur;
    UINT8  bdata, bdata_cur;
    bool   tlb_avail;
    
    if( !info_cpu_boot() )
        return FALSE;

    /* ICACHE SIZE */
    if( (SYSCON_read( SYSCON_CPU_ICACHE_SIZE_ID, 
		      &wdata, 
		      sizeof(wdata)) == OK)	&&
        (SYSCON_read( SYSCON_CPU_ICACHE_SIZE_CURRENT_ID, 
		      &wdata_cur, 
		      sizeof(wdata_cur)) == OK) )
    {
        if(SHELL_PUTS( "ICACHE size =" )) return FALSE;

	if( wdata == wdata_cur )
	    sprintf( msg, "%d kByte\n", wdata_cur/1024 );
	else
	    sprintf( msg, "%d (%d) kByte\n", wdata_cur/1024, wdata/1024 );

	if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;
    }
    else
        wdata = 0; /* Should never happen */

    if( wdata != 0 ) /* Only if CPU has cache */
    {
        /* ICACHE LINESIZE */
        if( (SYSCON_read( SYSCON_CPU_ICACHE_LINESIZE_ID, 
		          &wdata, 
		          sizeof(wdata)) == OK)	   &&
	    (SYSCON_read( SYSCON_CPU_ICACHE_LINESIZE_CURRENT_ID, 
		          &wdata_cur, 
		          sizeof(wdata_cur)) == OK) )
        {
            if(SHELL_PUTS( "ICACHE line size =" )) return FALSE;

	    if( wdata == wdata_cur )
                sprintf( msg, "%d bytes\n", wdata_cur );
	    else
	        sprintf( msg, "%d (%d) bytes\n", wdata_cur, wdata );	

            if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;
        }

        /* ICACHE ASSOC */
        if( (SYSCON_read( SYSCON_CPU_ICACHE_ASSOC_ID, 
			  &wdata, 
			  sizeof(wdata)) == OK)	   &&
	    (SYSCON_read( SYSCON_CPU_ICACHE_ASSOC_CURRENT_ID, 
		          &wdata_cur, 
		          sizeof(wdata_cur)) == OK) )
        {
            if(SHELL_PUTS( "ICACHE associativity =" )) return FALSE;

            if (wdata_cur == 1)
	        sprintf( msg, "direct mapped" );
	    else
   	        sprintf( msg, "%d-way", wdata_cur );

	    if( wdata != wdata_cur )
	    {
	        if( wdata == 1 )
	            sprintf( &msg[strlen(msg)], " (direct mapped)\n" );
	        else
	            sprintf( &msg[strlen(msg)], " (%d-way)\n", wdata );
	    }
	    else
	        sprintf( &msg[strlen(msg)], "\n" );

            if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;
        }
    }

    /* DCACHE SIZE */
    if( (SYSCON_read( SYSCON_CPU_DCACHE_SIZE_ID, 
		      &wdata, 
		      sizeof(wdata)) == OK)	&&
        (SYSCON_read( SYSCON_CPU_DCACHE_SIZE_CURRENT_ID, 
		      &wdata_cur, 
		      sizeof(wdata_cur)) == OK) )
    {
        if(SHELL_PUTS( "DCACHE size =" )) return FALSE;

	if( wdata == wdata_cur )
	    sprintf( msg, "%d kByte\n", wdata_cur/1024 );
	else
	    sprintf( msg, "%d (%d) kByte\n", wdata_cur/1024, wdata/1024 );

	if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;
    }
    else
        wdata = 0; /* Should never happen */

    if( wdata ) /* Only if CPU has cache */
    {    
        /* DCACHE LINESIZE */
        if( (SYSCON_read( SYSCON_CPU_DCACHE_LINESIZE_ID, 
		          &wdata, 
		          sizeof(wdata)) == OK)	   &&
	    (SYSCON_read( SYSCON_CPU_DCACHE_LINESIZE_CURRENT_ID, 
		          &wdata_cur, 
		          sizeof(wdata_cur)) == OK) )
        {
            if(SHELL_PUTS( "DCACHE line size =" )) return FALSE;

	    if( wdata == wdata_cur )
                sprintf( msg, "%d bytes\n", wdata_cur );
	    else
	        sprintf( msg, "%d (%d) bytes\n", wdata_cur, wdata );	

            if(SHELL_PUTS_INDENT( msg, INDENT )) return FALSE;
        }

        /* DCACHE ASSOC */
        if( (SYSCON_read( SYSCON_CPU_DCACHE_ASSOC_ID, 
	   	          &wdata, 
		          sizeof(wdata)) == OK)	   &&
	    (SYSCON_read( SYSCON_CPU_DCACHE_ASSOC_CURRENT_ID, 
		          &wdata_cur,