{
					case sizeof(BYTE):
						break;
					case sizeof(WORD):
						if( length >= sizeof(WORD))
							length = length/2;
						else
							length = 1;
						break;
					case sizeof(DWORD):
						if (length >= sizeof(DWORD))
							length = length/4;
						else
							length = 1;
						break;
				}				
				
				EdbgOutputDebugString("StartAddr = 0x%x, Value = 0x%x, length = 0x%x size = %d!\r\n", modifyAddr, dataValue, length, gSize);
				BootCompareMemory(modifyAddr, dataValue, length, gSize);
				}
				break;
				
			case 't':
			case 'T':
// For futher
/*			
				BootRunSelfTest();
*/
				break;
			case OEM_DEBUG_COM_ERROR:
				EdbgOutputDebugString("COM error occurred!\r\n");
				break;
			case ' ':
				break;
			case 'v':
			case 'V':
				{
					DWORD	index;
					DWORD	verifyStart;
					DWORD	verifyLength;
					DWORD	verifyChecksum;
					
					stringPtr = ParseString(stringPtr, addrString);
					if ((addrString[0] == (TCHAR) NULL) || !Asc2Int(addrString, &verifyStart))
					{
						EdbgOutputDebugString("Invalid first area specified!\r\n");
						break;
					}
					stringPtr = ParseString(stringPtr, addrString);
					if ((addrString[0] == (TCHAR) NULL) || !Asc2Int(addrString, &verifyLength))
					{
						EdbgOutputDebugString("Invalid length specified!\r\n");
						break;
					}
					verifyChecksum = 0;
					for(index = 0; index < verifyLength; index++)
					{
						verifyChecksum += *((unsigned char *)verifyStart + index);
					}
					EdbgOutputDebugString("Checksum %x\r\n", verifyChecksum);
					
				}
				break;
			case 'x':
			case 'X':
				return 3;
				break;
			case 'z':
			case 'Z':
				return 4;
				break;
			case 0x00:
				break;
			default:
				EdbgOutputDebugString("\r\nError Command , Press '?'- Help Menu \r\n");
				break;
		}
	}
}


//
//
//
void
EraseSystemFlash(void)
{
	DWORD pdwFlash;
	UINT16 result;
	ULONG SystemFlashSize;
	
	pdwFlash = SystemFLASH_START + FlashStartOffset;
	
	SystemFlashSize = FlashEndOffset - FlashStartOffset;
	
	EdbgOutputDebugString("BootEraseFlash: 0x%X , Length = 0x%X\r\n", pdwFlash , SystemFlashSize);
	
	
	result = FlashErase((DWORD)pdwFlash, SystemFlashSize);
	
	if (result)
		EdbgOutputDebugString("\n\rError erasing Flash!\r\n");
}

void
ShowHelpMessage(void)
{
	EdbgOutputDebugString("    MINI Monitor Command:\r\n");
	EdbgOutputDebugString("    ? - Help Menu\r\n");
	EdbgOutputDebugString("    L[S,E] - (Serial,Ethernet) Run the Boot Loader Updater\r\n");
	EdbgOutputDebugString("    E - Completely erases all of system Flash returns to prompt when complete\r\n");
	EdbgOutputDebugString("    C <source> <destination> <Blength> - Copy memory (RAM or Flash)\r\n");
	EdbgOutputDebugString("    D[B,W,D] <address> [length] - Display data from starting address\r\n");
	EdbgOutputDebugString("    F[B,W,D] <Saddress> <Eaddress> <data> - Fill data from Saddress to Eaddress\r\n");
	EdbgOutputDebugString("    P[B,W,D] <Saddress> <Eaddress> <data> - Compare data from Saddress,length(Eaddr-Saddr) \r\n");	
	EdbgOutputDebugString("    G <address> - Starts execution from the address\r\n");
	EdbgOutputDebugString("    M[B,W,D] <address> - Modify RAM data at starting address\r\n");
//	EdbgOutputDebugString("    T - Run the self-test\r\n");
	EdbgOutputDebugString("    I - Identify. Prints the device identification information\r\n");
	EdbgOutputDebugString("    V <start> <length> - Verify checksum of specified memory region.\r\n");
	EdbgOutputDebugString("    X - Launch System Image.\r\n");
}

void
DisplaySystemINFO(void)
{
	EdbgOutputDebugString("Company: R-TECH Corporation\r\n");
	EdbgOutputDebugString("Hardware Support:\r\n");
	EdbgOutputDebugString("Board: Embedded Portable Data Terminal\r\n");
	EdbgOutputDebugString("\tRevision: 1.0\r\n");
	EdbgOutputDebugString("Software: \r\n");
	EdbgOutputDebugString("\tRevision Date: %s\r\n", __DATE__);
	EdbgOutputDebugString("\tBootloader Version: Embedded PDA BootLoader V0.1.10\r\n");
	EdbgOutputDebugString("\tBuild: WINCE 3.0\r\n");
	EdbgOutputDebugString("Processor Information:\r\n");
	EdbgOutputDebugString("\tCompany: Intel Corporation\r\n");
	EdbgOutputDebugString("\tPart Number: Cotulla\r\n");
	EdbgOutputDebugString("\tRevision: Version 1, Stepping Revision A1\r\n");
	EdbgOutputDebugString("Installed Memory:\r\n");
	//EdbgOutputDebugString("\tRAM: %d Mbytes\r\n", (theRamSize / ONE_MEG));
	//EdbgOutputDebugString("\tFlash: %d Mbytes\r\n"), (theFlashSize / ONE_MEG));
}
// 
// Tools
//

BOOL
FlashCheckAddr(ULONG destination, ULONG length)
{
	ULONG SystemFlashSize, SystemFlashEnd, SystemFlashStart;

	SystemFlashStart = SystemFLASH_START + FlashStartOffset;
	
	SystemFlashEnd = SystemFLASH_START + FlashEndOffset;
	
	SystemFlashSize = FlashEndOffset - FlashStartOffset;
	
	//EdbgOutputDebugString("FlashStart = 0x%x, FlashEnd = 0x%x, FLashSize = 0x%x\r\n", SystemFlashStart, SystemFlashEnd, SystemFlashSize);

	
	if ((destination & 0x90000000) == 0x90000000)
	{
	 	if ((destination >= SystemFlashStart) && (destination <= SystemFlashEnd))
	 	{
	 	   	if(length < SystemFlashSize)
	 	   		return TRUE;
	 	}
	}
	return FALSE;
}

LPTSTR
ParseString(LPTSTR stringPtr, LPTSTR destPtr)
{

	*destPtr = (TCHAR) NULL;
	
	while (*stringPtr == ' ')
	{
		stringPtr++;
		//EdbgOutputDebugString ("Space ");
	}


	while (*stringPtr != (TCHAR) NULL && *stringPtr != ' ')
	{
		//EdbgOutputDebugString ("Char = %c ", *stringPtr);
		*destPtr++ = *stringPtr++;
		*destPtr = (TCHAR) NULL;
	}
	//EdbgOutputDebugString ("SPACE or NULL\r\n");

	return stringPtr;
}

BOOL
Asc2Int(PTCHAR ascData, PULONG value)
{
	ULONG hexData;
	BYTE multiplier;
	BOOL invertFlag = FALSE;
	BOOL result = TRUE;

	hexData = 0;
	multiplier = 10;

	if (*ascData == '-')
	{
		invertFlag = TRUE;
		ascData += 1;
	}
	
	if (*ascData == '0' && *(ascData+1) == 'x')
	{
		multiplier = 16;
		ascData += 2;
	}

	while (*ascData != (TCHAR) NULL)
	{
		if ((*ascData >= '0' && *ascData <= '9') ||
			(((*ascData >= 'a' && *ascData <= 'f') ||
			(*ascData >= 'A' && *ascData <= 'F')) && multiplier == 16))
		{
			hexData *= multiplier;

			if (*ascData > '9')
			{
				hexData += 9;
			}
			hexData += *ascData++ & 0x0F;
		}
		else
		{
			return FALSE;
		}
	}

	if (invertFlag)
	{
		hexData = (ULONG) ((int) hexData * (-1));
	}

	*value = hexData;

	return TRUE;
}

void
GetInputBuffer(LPTSTR InputBuffer)
{
	int inputByte = OEM_DEBUG_READ_NODATA;
	ULONG stringIndex = 0;
	
	*InputBuffer = (TCHAR) NULL;
	
	while (inputByte != '\r')
	{
		inputByte = OEM_DEBUG_READ_NODATA;
		while (inputByte == OEM_DEBUG_READ_NODATA)
		{
			inputByte = OEMReadDebugByte();
		}
		switch(inputByte)
		{
			case OEM_DEBUG_COM_ERROR:
				EdbgOutputDebugString("COM error occurred!\r\n");
				break;
			case '\b':
				if (stringIndex)
				{
					*(InputBuffer + stringIndex) = (TCHAR) NULL;
					stringIndex--;
					EdbgOutputDebugString("\b \b", (TCHAR) inputByte);
				}
				break;
			default:
				if ((inputByte >= 0x20) && (inputByte <= 0x7E))
				{
					*(InputBuffer + stringIndex) = (TCHAR) inputByte;
					stringIndex++;
					*(InputBuffer + stringIndex) = (TCHAR) NULL;
					
				}
					EdbgOutputDebugString("%c", (TCHAR) inputByte);
				break;
		}
	}
	EdbgOutputDebugString("\r\n");
	
}

void
BootDisplayMemory(ULONG startAddr, BYTE dataSize)
{

	ULONG dataAddr = startAddr;
	ULONG dataValue;

	switch (dataSize)
	{
		case sizeof(BYTE):
			(BYTE) dataValue = *((PBYTE) dataAddr);
			EdbgOutputDebugString("0x%x	0x%B", startAddr, *((PBYTE) dataAddr));
			break;
			
		case sizeof(WORD):
			(WORD) dataValue = *((PWORD) dataAddr);
			EdbgOutputDebugString("0x%x	0x%H", startAddr, *((PWORD) dataAddr));
			break;
			
		case sizeof(DWORD):
			(DWORD) dataValue = *((PDWORD) dataAddr);
			EdbgOutputDebugString("0x%x	0x%X", startAddr, *((PDWORD) dataAddr));
			break;

		default:
			break;
		}
}

BOOL
BootCompareMemory(ULONG startAddr, ULONG dataValue, ULONG length, BYTE dataSize)
{
	ULONG dataAddr = startAddr;
	ULONG index;

	//EdbgOutputDebugString("BootSetMemory!\r\n");
	//EdbgOutputDebugString("Start Address = 0x%X, Value = 0x%x, length = 0x%x, size = %d:\r\n\r\n", startAddr, dataValue, length, dataSize );
	for (index = 0; index < length; index++)
	{
		switch (dataSize)
		{
			case sizeof(BYTE):
				if (*((PBYTE) dataAddr) != (BYTE) dataValue)
					EdbgOutputDebugString("Error Address = 0x%X, Expected Value = 0x%B, Actual Value = 0x%B\r\n", startAddr, dataValue, *((PBYTE) dataAddr) );
				else
					goto Continuous;
				break;

			case sizeof(WORD):
				if(*((PWORD) dataAddr) != (WORD) dataValue)
					EdbgOutputDebugString("Error Address = 0x%X, Expected Value= 0x%H, Actual Value = 0x%H\r\n", startAddr, dataValue, *((PBYTE) dataAddr) );
				else
					goto Continuous;					
				break;

			case sizeof(DWORD):
				if(*((PDWORD) dataAddr) != (DWORD) dataValue)
					EdbgOutputDebugString("Error Address = 0x%X, Expected Value = 0x%X, Actual Value = 0x%X\r\n", startAddr, dataValue, *((PBYTE) dataAddr) );
				else
					goto Continuous;					
				break;

			default:
				break;
		}


		{	// Wait key pressed
			int inputByte = OEM_DEBUG_READ_NODATA;
	
			while (1)
			{
				inputByte = OEM_DEBUG_READ_NODATA;
				while (inputByte == OEM_DEBUG_READ_NODATA)
				{
					inputByte = OEMReadDebugByte();
				}
				switch(inputByte)
				{
					case 0x20:
						goto Continuous;
					case '\r':
						return FALSE;	
					default:
						break;
				}
			}
		}		// Wait key pressed
Continuous:
				dataAddr += dataSize;
				
	}

	return TRUE;
}