menu.c

Windows CE 6.0 BSP for the Beagle Board.

//
// Copyright (c) Special Computing.  All rights reserved. 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//------------------------------------------------------------------------------
//
//  File:  menu.c
//
#include <eboot.h>
#include <oal_memory.h>

//------------------------------------------------------------------------------
//
//  Define:  dimof
//
#ifdef dimof
#undef dimof
#endif
#define dimof(x)                (sizeof(x)/sizeof(x[0]))

//------------------------------------------------------------------------------

static VOID ShowSettings(OAL_BLMENU_ITEM *pMenu);
static VOID ShowNetworkSettings(OAL_BLMENU_ITEM *pMenu);
static VOID SetKitlMode(OAL_BLMENU_ITEM *pMenu);
static VOID SaveSettings(OAL_BLMENU_ITEM *pMenu);
static VOID EditMemory(OAL_BLMENU_ITEM *pMenu);

//------------------------------------------------------------------------------

extern OAL_BLMENU_ITEM g_menuFlash[];
extern OAL_ADDRESS_TABLE g_oalAddressTable[];

//------------------------------------------------------------------------------

static OAL_BLMENU_ITEM g_menuNetwork[] = {
    {
        L'1', L"Show Current Settings", ShowNetworkSettings,
        NULL, NULL, NULL
    }, {
        L'2', L"Enable/disable KITL", OALBLMenuEnable,
        L"KITL", &g_bootCfg.kitlFlags, (VOID*)OAL_KITL_FLAGS_ENABLED
    }, {
        L'3', L"KITL interrupt/poll mode", SetKitlMode,
        NULL, NULL, NULL
    }, {
        L'4', L"Enable/disable DHCP", OALBLMenuEnable,
        L"DHCP", &g_bootCfg.kitlFlags, (VOID*)OAL_KITL_FLAGS_DHCP
    }, {
        L'5', L"Set IP address", OALBLMenuSetIpAddress,
        L"Device", &g_bootCfg.ipAddress, NULL
    }, {
        L'6', L"Set IP mask", OALBLMenuSetIpMask,
        L"Device", &g_bootCfg.ipMask, NULL
    }, {
        L'7', L"Set default router", OALBLMenuSetIpAddress,
        L"Default router", &g_bootCfg.ipRoute, NULL
    }, {
        L'8', L"Enable/disable VMINI", OALBLMenuEnable,
        L"VMINI", &g_bootCfg.kitlFlags, (VOID*)OAL_KITL_FLAGS_VMINI
    }, {
        L'9', L"Set MAC address", OALBLMenuSetMacAddress,
        L"", &g_mac[0], NULL
    }, {
        L'0', L"Exit and Continue", NULL,
        NULL, NULL, NULL
    }, {
        0, NULL, NULL,
        NULL, NULL, NULL
    }
};

static OAL_BLMENU_ITEM g_menuMain[] = {
    {
        L'1', L"Show Current Settings", ShowSettings,
        NULL, NULL, NULL
    }, {
        L'2', L"Select Boot Device", OALBLMenuSelectDevice,
        L"Boot", &g_bootCfg.bootDevLoc, g_bootDevices
    }, {
        L'3', L"Select Debug Device", OALBLMenuSelectDevice,
        L"Debug", &g_bootCfg.kitlDevLoc, g_kitlDevices
    }, {
        L'4', L"Network Settings", OALBLMenuShow,
        L"Network Settings", &g_menuNetwork, NULL
    }, {
        L'5', L"NAND/NOR Flash ", OALBLMenuShow,
        L"NAND/NOR Flash", &g_menuFlash, NULL
    }, {
        L'6', L"Save Settings", SaveSettings,
        NULL, NULL, NULL
    }, {
        L'7', L"Edit memory", EditMemory,
        NULL, NULL, NULL
    }, {
        L'0', L"Exit and Continue", NULL,
        NULL, NULL, NULL
    }, {
        0, NULL, NULL,
        NULL, NULL, NULL
    }
};

static OAL_BLMENU_ITEM g_menuRoot = {
    0, NULL, OALBLMenuShow,
    L"Main Menu", g_menuMain, NULL
};

//------------------------------------------------------------------------------

VOID BLMenu()
{
    UINT32 time, delay = 5;
    WCHAR key = 0;
    BSP_ARGS *pArgs = OALPAtoCA(IMAGE_SHARE_ARGS_PA);
    
    // First let user break to menu
    while (delay > 0 && key != L' ') {
       OALLog(L"Hit space to enter configuration menu %d...\r\n", delay);
       time = OALGetTickCount();
       while ((OALGetTickCount() - time) < 1000) {
          if ((key = OALBLMenuReadKey(FALSE)) == L' ') break;
       }
       delay--;
    }
    
    if (key == L' ') {
        OALBLMenuShow(&g_menuRoot);
        // We have to invalidate arguments
        pArgs->header.signature = 0;
    }        
}

//------------------------------------------------------------------------------

VOID ShowSettings(OAL_BLMENU_ITEM *pMenu)
{
    OALLog(L"\r\n Main:\r\n");
    OALLog(
        L"  Boot device:   %s\r\n",
        OALKitlDeviceName(&g_bootCfg.bootDevLoc, g_bootDevices)
    );
    OALLog(
        L"  Debug device:  %s\r\n",
        OALKitlDeviceName(&g_bootCfg.kitlDevLoc, g_kitlDevices)
    );
    ShowNetworkSettings(pMenu);
}

//------------------------------------------------------------------------------

VOID ShowNetworkSettings(OAL_BLMENU_ITEM *pMenu)
{
    OALLog(L"\r\n Network:\r\n");
    OALLog(
        L"  KITL state:    %s\r\n",
        (g_bootCfg.kitlFlags & OAL_KITL_FLAGS_ENABLED) ? L"enabled" : L"disabled"
    );
    OALLog(
        L"  KITL mode:     %s\r\n",
        (g_bootCfg.kitlFlags & OAL_KITL_FLAGS_POLL) ? L"poll" : L"interrupt"
    );
    OALLog(
        L"  DHCP:          %s\r\n",
        (g_bootCfg.kitlFlags & OAL_KITL_FLAGS_DHCP) ? L"enabled" : L"disabled"
    );
    OALLog(L"  IP address:    %s\r\n", OALKitlIPtoString(g_bootCfg.ipAddress));
    OALLog(L"  IP mask:       %s\r\n", OALKitlIPtoString(g_bootCfg.ipMask));
    OALLog(L"  IP router:     %s\r\n", OALKitlIPtoString(g_bootCfg.ipRoute));
    OALLog(
        L"  VMINI:         %s\r\n",
        (g_bootCfg.kitlFlags & OAL_KITL_FLAGS_VMINI) ? L"enabled" : L"disabled"
    );
}

//------------------------------------------------------------------------------

VOID SetKitlMode(OAL_BLMENU_ITEM *pMenu)
{
    WCHAR key;

    if ((g_bootCfg.kitlFlags & OAL_KITL_FLAGS_POLL) != 0) {
        OALLog(L" Set KITL to interrupt mode [y/-]: ");
    } else {
        OALLog(L" Set KITL to poll mode [y/-]: ");
    }    

    // Get key
    key = OALBLMenuReadKey(TRUE);
    OALLog(L"%c\r\n", key);

    if (key == L'y' || key == L'Y') {
        if ((g_bootCfg.kitlFlags & OAL_KITL_FLAGS_POLL) != 0) {
            g_bootCfg.kitlFlags &= ~OAL_KITL_FLAGS_POLL;
            OALLog(L" KITL set to interrupt mode\r\n");
        } else {
            g_bootCfg.kitlFlags |= OAL_KITL_FLAGS_POLL;
            OALLog(L" KITL set to pool mode\r\n");
        }            
    }
}

//------------------------------------------------------------------------------

VOID SaveSettings(OAL_BLMENU_ITEM *pMenu)
{
    WCHAR key;

    OALLog(L" Do you want save current settings [y/-]? ");

    // Get key
    key = OALBLMenuReadKey(TRUE);
    OALLog(L"%c\r\n", key);

    // Depending on result
    if (key != L'y' && key != L'Y') goto cleanUp;

    if (BLWriteBootCfg(&g_bootCfg)) {
        OALLog(L" Current settings has been saved\r\n");
    } else {        
        OALLog(L"ERROR: Settings save failed!\r\n");
    }
    if (BLWriteMAC(&g_bootCfg, g_mac)) {
        OALLog(L" Current MAC has been saved\r\n");
    } else {        
        OALLog(L"ERROR: MAC save failed!\r\n");
    }
    

cleanUp:
    return;
}

//------------------------------------------------------------------------------

DWORD HexStrToul(char *str, UINT32 len)
{
	DWORD val;
	UINT32 i;
	char c1;

	val=0;

	for(i=0;i<len;i++) {
		if(*str=='\0') break;
		
		c1=*str++;
		
		if(c1>='A' && c1<='F') c1=(c1-'A')+0xA;
		else if(c1>='a' && c1<='f') c1=(c1-'a')+0xA;
		else if(c1>='0' && c1<='9') c1=(c1-'0');

		val<<=4;
		val|=c1;
	}

	return val;
}


DWORD ParseHex(UINT32 *pRet, char **ppPars)
{
    DWORD ret=1;
    if (!**ppPars)
        return 0;
    *pRet = 0;
    while (**ppPars)
    {
        if (((**ppPars>='0') && (**ppPars<='9')) ||
            ((**ppPars>='a') && (**ppPars<='f')) ||
            ((**ppPars>='A') && (**ppPars<='F')))
        {
            *pRet*=16;
            if ((**ppPars>='0') && (**ppPars<='9'))
                *pRet += (**ppPars-'0');
            else
            {
                if ((**ppPars>='a') && (**ppPars<='f'))
                    **ppPars-=('a'-'A');
                *pRet += (**ppPars-'A')+10;
            }
            (*ppPars)++;
        }
        else
        {
            if ((**ppPars!=' ') &&
                (**ppPars!='\t') &&
                (**ppPars!=10) &&
                (**ppPars!=13))
            {
                /* invalid character entered */
                ret = 0;
                (*ppPars)++;
                /* bypass non-whitespace */
                while ((**ppPars) &&
                       (**ppPars!=' ') &&
                       (**ppPars!='\t') &&
                       (**ppPars!=13) &&
                       (**ppPars!=10))
                    (*ppPars)++;
            }
            break;
        }
    }
    return ret;
}


DWORD ParseDec(UINT32 *pRet, char **ppPars)
{
    DWORD ret=1;
    if (!**ppPars)
        return 0;
    *pRet = 0;
    while (**ppPars)
    {
        if ((**ppPars>='0') && (**ppPars<='9'))
        {
            *pRet*=10;
            *pRet += (**ppPars-'0');
            (*ppPars)++;
        }
        else
        {
            if ((**ppPars!=' ') &&
                (**ppPars!='\t') &&
                (**ppPars!=10) &&
                (**ppPars!=13))
            {
                /* invalid character entered */
                ret = 0;
                (*ppPars)++;
                /* bypass non-whitespace */
                while ((**ppPars) &&
                       (**ppPars!=' ') &&
                       (**ppPars!='\t') &&
                       (**ppPars!=13) &&
                       (**ppPars!=10))
                    (*ppPars)++;
            }
            break;
        }
    }
    return ret;
}


VOID DumpGPIORegisters(void)
{
	OALLog(L"GPIO Registers:\r\n\r\n");
	OALLog(L"        GPIO1     GPIO2     GPIO3     GPIO4     GPIO5     GPIO6\r\n");
	OALLog(L"DATAIN: %08X  %08X  %08X  %08X  %08X  %08X\r\n",
		INREG32(OMAP3_GPIO1_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_DATAIN)),
		INREG32(OMAP3_GPIO2_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_DATAIN)),
		INREG32(OMAP3_GPIO3_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_DATAIN)),
		INREG32(OMAP3_GPIO4_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_DATAIN)),
		INREG32(OMAP3_GPIO5_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_DATAIN)),
		INREG32(OMAP3_GPIO6_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_DATAIN)));
	OALLog(L"OE:     %08X  %08X  %08X  %08X  %08X  %08X\r\n",
		INREG32(OMAP3_GPIO1_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_OE)),
		INREG32(OMAP3_GPIO2_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_OE)),
		INREG32(OMAP3_GPIO3_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_OE)),
		INREG32(OMAP3_GPIO4_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_OE)),
		INREG32(OMAP3_GPIO5_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_OE)),
		INREG32(OMAP3_GPIO6_REGS_PA + offsetof(OMAP3_GPIO_REGS,ulGPIO_OE)));
}


VOID DumpAddrTable(void)
{
	POAL_ADDRESS_TABLE pEnt = g_oalAddressTable;
	OALLog(L"\r\nTable at address %08X\r\n",g_oalAddressTable);
    OALLog(L"Virtual Address Mapping:\r\n\r\n");
    OALLog(L"Cached   UnCached Physical Megs\r\n");
	OALLog(L"-------------------------------\r\n");
    do {
        OALLog(L"%08X %08X %08X %0d\r\n",pEnt->CA,pEnt->CA+0x20000000,pEnt->PA,pEnt->size);
        pEnt++;
    } while ((pEnt->CA!=0) || (pEnt->PA!=0) || (pEnt->size!=0));
    OALLog(L"\r\n");
}



VOID EditMemory(OAL_BLMENU_ITEM *pMenu)
{
    UINT16  inChar = 0;
    DWORD   addr;
    DWORD   saddr,daddr;
    DWORD   val;
	DWORD   len;
	DWORD   inp;
    DWORD  *pAddr;
	BYTE   *pBAddr;
    void   *pSAddr,*pDAddr;
    char    chBuf[64];
    char    *pStart,*pChk;
    DWORD   i;

	OALLog(L"\r\n\r\nEdit Flash/Virtual Memory\r\n");
	OALLog(L"Commands: (all addresses in hex,num in decimal) \r\n");
	OALLog(L"  r <a> [<num=1>]          Read decimal # <num> DWORDS at address <a>\r\n");
	OALLog(L"  R <a>                    Read BYTE at address <a>\r\n");
	OALLog(L"  w <a> <hexval>           Write hex DWORD <hexval> at address <a>\r\n");
	OALLog(L"  W <a> <hexval>           Write hex BYTE <hexval> at address <a>\r\n");
	OALLog(L"  f <a> <hexval> [<num=1>] Fill hex DWORD(s) <hexval> at address <a>\r\n");
	OALLog(L"  m <sa> <da> [<num=1>]    Move source address <sa> to dest <da> # <num> bytes\r\n");
	OALLog(L"  e <b> [<num=1>]          Erase Flash # <num> blocks at decimal <b>\r\n");
	OALLog(L"  p <secta> <ma> [<num=1>] Pgm Flash # <num> sectors at <secta> buffer <ma>\r\n");
	OALLog(L"  o                        Dump OEMAddressTable\r\n");
	OALLog(L"  g                        Dump GPIO registers\r\n");
	OALLog(L"  l <a>                    Launch at physical address <a>\r\n");
	OALLog(L"  x                        Quit Memory Editor\r\n\r\n");
	
    do {
        /* do the next command */
        chBuf[0] = 0;
        i = 0;
        OALLog(L">");
        do {
            inChar = OEMReadDebugByte();
    		if ((inChar<127) && (inChar != OEM_DEBUG_COM_ERROR && inChar != OEM_DEBUG_READ_NODATA))
            {
                if (inChar==8)
                {
                    if (i>0)
                    {
                        i--;
                        chBuf[i] = 0;
                        OALLog(L"%c %c",8,8);
                    }
                }
                else if ((inChar!=13) && (inChar!=10) && (i<63))
                {
                    OALLog(L"%c",inChar);
                    chBuf[i] = (char)inChar;
                    i++;
                    chBuf[i] = 0;
                }
            }
        } while ((inChar!=10) && (inChar!=13));

        /* chBuf now holds the command string */
        OALLog(L"\r\n");
        pStart = chBuf;
        while ((*pStart) && ((*pStart==' ') || (*pStart=='\t')))
            pStart++;
        if (*pStart)
        {
            pChk = pStart;
			switch (*pStart) {
				case 'o':
				case 'O':
					pChk++;
					while (*pChk)
					{
						if ((*pChk!=' ') && (*pChk!='\t'))
							break;
						pChk++;
					}
					if (*pChk)
						*pStart = 0;    /* nothing allowed after m */
					else
					{
						DumpAddrTable();
					}
					break;
				case 'g':
				case 'G':
					pChk++;