//
// FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
int wmId, wmEvent;
PAINTSTRUCT ps;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_HELP_ABOUT:
DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
break;
case IDM_FILE_EXIT:
SendMessage (hWnd, WM_CLOSE, 0, 0);
break;
case IDM_FLASH_ERASE:
if (gSystemErrorHasOccured != TRUE){
LoadString(hInst, IDS_FLASH_ERASE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
EraseFlash(hWnd);
LoadString(hInst, IDS_IDLE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
}
else
SystemErrorAlert(hWnd);
break;
case IDM_FLASH_TEST_TIMED:
LoadString(hInst, IDS_FLASH_TEST_TIMED, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
gTimerID = SetTimer(hWnd,BB_TEST_FLASH,50,NULL);
break;
case IDM_FLASH_TEST_STRAIGHT:
TestFlash(hWnd);
break;
case IDM_FLASH_SAVE:
LoadString(hInst, IDS_FLASH_SAVE_BL, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
SaveFlash(hWnd);
LoadString(hInst, IDS_IDLE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
break;
case IDM_FLASH_SAVE_WINCE:
LoadString(hInst, IDS_FLASH_SAVE_WINCE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
SaveFlashWince(hWnd);
LoadString(hInst, IDS_IDLE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
break;
case IDM_FLASH_PROTECT_WINCE:
LoadString(hInst, IDS_FLASH_PROTECT_WINCE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
ProtectWince(hWnd);
LoadString(hInst, IDS_IDLE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
break;
case IDM_FLASH_SAVE_GZ:
LoadString(hInst, IDS_FLASH_SAVE_BL_GZ, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
SaveFlashGZ(hWnd);
LoadString(hInst, IDS_IDLE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
break;
case IDM_FLASH_PROGRAM:
if (gSystemErrorHasOccured != TRUE){
if (LoadImage(hWnd) != TRUE) //loaded, so program it
return 0;
LoadString(hInst, IDS_FLASH_PROTECT_WINCE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
ProtectWince(hWnd);
if (gSystemErrorHasOccured == TRUE)
return 0;
LoadString(hInst, IDS_FLASH_ERASE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
EraseFlash(hWnd);
LoadString(hInst, IDS_FLASH_PROGRAM, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,FALSE);
UpdateWindow(hWnd);
Sleep(100);
if (ProgramFlash(hWnd) == TRUE)
VerifyFlash(hWnd);
LoadString(hInst, IDS_IDLE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
}
else
SystemErrorAlert(hWnd);
break;
case IDM_FLASH_PROGRAM_XPLE:
if (gSystemErrorHasOccured != TRUE){
if (LoadImage(hWnd) != TRUE) //loaded, so program it
return 0;
for (int i=0; i < 50; i++){
LoadString(hInst, IDS_FLASH_PROTECT_WINCE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
ProtectWince(hWnd);
if (gSystemErrorHasOccured == TRUE)
return 0;
LoadString(hInst, IDS_FLASH_ERASE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
EraseFlash(hWnd);
LoadString(hInst, IDS_FLASH_PROGRAM, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,FALSE);
UpdateWindow(hWnd);
Sleep(100);
ProgramFlash(hWnd);
LoadString(hInst, IDS_IDLE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
UpdateWindow(hWnd);
Sleep(100);
}
VerifyFlash(hWnd);
}
else
SystemErrorAlert(hWnd);
break;
case IDM_FLASH_SHOW:
ShowFlash(hWnd);
break;
case IDM_FLASH_VERIFY:
VerifyFlash(hWnd);
break;
case IDOK:
//SendMessage(hWnd, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), (LPARAM)hWnd);
//SendMessage (hWnd, WM_CLOSE, 0, 0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_TIMER:
// this method isn;t used anymore, really
KillTimer(hWnd,wParam);
if (wParam == BB_TEST_FLASH){
TestFlash(hWnd);
LoadString(hInst, IDS_IDLE, szStatus, MAX_LOADSTRING);
InvalidateRect(hWnd,NULL,TRUE);
}
else{}
case WM_CREATE:
hwndCB = CreateRpCommandBar(hWnd);
break;
case WM_PAINT:
RECT rt;
hdc = BeginPaint(hWnd, &ps);
GetClientRect(hWnd, &rt);
DrawText(hdc, szStatus, _tcslen(szStatus), &rt,
DT_CENTER);
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
CommandBar_Destroy(hwndCB);
PostQuitMessage(0);
break;
case WM_SETTINGCHANGE:
SHHandleWMSettingChange(hWnd, wParam, lParam, &s_sai);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
int BootFromFlash( void )
{
long int HexFile_p = 0; /* datafile descriptor */
long int HexFileSize = 0; /* size in bytes of the file */
int ErrorCount = 0;
ST_ErrorCode_t ReturnError = ST_NO_ERROR;
char Filename[] = "flash.hex";
U8 Block;
U32 BlockStart;
STFLASH_Print(( "\n" ));
STFLASH_Print(( "============================================================\n" ));
STFLASH_Print(( "Commencing Boot From Flash Test ..\n" ));
STFLASH_Print(( "============================================================\n" ));
/* Init Bank 0, Vpp 0 */
InitParams_s.DeviceType = DEVICE_TYPE;
InitParams_s.BaseAddress = (U32*)STFLASH_BANK_0_BASE;
InitParams_s.VppAddress = (U32*)STFLASH_VPP_0_ENABLE;
InitParams_s.MinAccessWidth = MIN_ACCESS_WIDTH;
InitParams_s.MaxAccessWidth = MAX_ACCESS_WIDTH;
InitParams_s.NumberOfBlocks = NUM_BLOCKS;
InitParams_s.Blocks = BlockData_s;
#ifdef ST_OS21
InitParams_s.DriverPartition = system_partition;
#else
InitParams_s.DriverPartition = TEST_PARTITION_1;
#endif
STFLASH_Print(( "FLASH_BANK_0_BASE = %x\n", STFLASH_BANK_0_BASE ));
STFLASH_Print(( "Calling STFLASH_Init() Bank0 ..........\n" ));
ReturnError = STFLASH_Init( "Bank0", &InitParams_s );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
/* Open Bank 0 */
STFLASH_Print(( "Calling STFLASH_Open() Bank0 ..........\n" ));
ReturnError = STFLASH_Open( "Bank0",
&OpenParams_s,
&FLASHHndl[0] );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
/* GetParams for Bank 0 */
GetParams_s.InitParams.Blocks = GetBlkDat_s;
STFLASH_Print(( "Calling STFLASH_GetParams() Bank 0 ....\n" ));
ReturnError = STFLASH_GetParams( FLASHHndl[0], &GetParams_s );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
ParamsReport( &GetParams_s );
BlockStart = BaseAddress[BANK0] = (U32) InitParams_s.BaseAddress;
for ( Block = 0; Block < InitParams_s.NumberOfBlocks; Block ++)
{
BlockInfo[Block].Bank = 0;
BlockInfo[Block].Address = BlockStart;
BlockInfo[Block].Length = InitParams_s.Blocks[Block].Length;
BlockStart += InitParams_s.Blocks[Block].Length;
}
/* Open and Read file into memory */
HexFile_p = debugopen(Filename, "rb");
STFLASH_Print(("HexFile_p = 0x%8x\n",HexFile_p));
if (HexFile_p < 0)
{
STFLASH_Print(("Error opening file \'%s\'\n", Filename ));
return (0);
}
else
{
HexFileSize = debugfilesize(HexFile_p);
STFLASH_Print(("HexFileSize = 0x%8x\n",HexFileSize));
/* allocate File data buffer */
FlashData_p = (char*) memory_allocate( system_partition, (U32) HexFileSize );
if ( FlashData_p != NULL )
{
STFLASH_Print(("Loading \'%s\' into memory, wait .. ", Filename ));
debugread(HexFile_p, FlashData_p, (size_t) HexFileSize);
STFLASH_Print(("%d bytes\n", HexFileSize ));
}
else
{
STFLASH_Print(("Not enough memory for HEX file (%d bytes)\n", HexFileSize));
HexFileSize = 0;
}
debugclose(HexFile_p);
}
if ( HexFileSize > 0 )
{
/* convert buffer to binary and resize memory */
STFLASH_Print(("Converting file in memory, wait .. "));
FlashSize = ConvertMemory( HexFileSize );
if ( FlashSize > 0 )
{
STFLASH_Print(("%d bytes\n", FlashSize ));
FlashData_p = (char*) memory_reallocate( system_partition, FlashData_p, FlashSize );
}
else
{
STFLASH_Print(("Invalid file\n"));
}
}
if ( EraseFlash(FALSE) == FALSE )
{
if ( ProgramFlash() == FALSE )
{
VerifyFlash();
}
}
/* Close Bank 0 */
STFLASH_Print(( "Calling STFLASH_Close() Bank 0 ........\n" ));
ReturnError = STFLASH_Close( FLASHHndl[0] );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
/* Term Bank 0 */
TermParams_s.ForceTerminate = FALSE;
STFLASH_Print(( "Calling STFLASH_Term() Bank 0 .........\n" ));
ReturnError = STFLASH_Term( "Bank0", &TermParams_s );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
return( ErrorCount );
}
void try_receive_data(void)
{
byte i;
byte *ptr;
if (uart0_flags.data_received)
{
ptr = uart0_get_data_begin();
for (i=0; i<9; i++)
{
TB_bufIn[i] = *ptr;
ptr++;
}
uart0_get_data_end();
uart0_flags.data_received = FALSE;
if (TB_Read() == 0)
{
switch (TB_Decode())
{
case ENTER_BOOTLOADER:
BootStatus = 1;
TB_SendAck(TB_ERR_OK, ENTER_BOOTLOADER);
break;
case READ_LOCK_BITS:
TB_SendAck(TB_ERR_OK, boot_lock_fuse_bits_get(GET_LOCK_BITS));
break;
case CHIP_ERASE_FLASH:
ChipErase();
TB_SendAck(TB_ERR_OK, CHIP_ERASE_FLASH);
break;
case CHIP_ERASE_EEPROM:
EepromErase();
TB_SendAck(TB_ERR_OK, CHIP_ERASE_EEPROM);
break;
case CHIP_ERASE_ALL:
ChipErase();
EepromErase();
TB_SendAck(TB_ERR_OK, CHIP_ERASE_ALL);
break;
case WRITE_LOCK_BITS:
TB_SendAck(TB_ERR_NOTEVALUABLE, WRITE_LOCK_BITS);
break;
case READ_LOW_FUSE:
TB_SendAck(TB_ERR_OK, boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
break;
case READ_HIGH_FUSE:
TB_SendAck(TB_ERR_OK, boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
break;
case READ_EXTENDED_FUSE:
TB_SendAck(TB_ERR_NOTEVALUABLE, boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
break;
case READ_SIGNATURE:
Signature = 0x1E9502;
TB_SendAck(TB_ERR_OK, Signature);
break;
case READ_SOFTWARE_VERSION:
TB_SendAck(TB_ERR_OK, SOFTWARE_IDENTIFIER);
break;
case READ_BOOTLOADER_VERSION:
TB_SendAck(TB_ERR_OK, BOOTLOADER_VERSION);
break;
case VERIFY_FLASH:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
if (Address < (START_BOOT_ADDRESS_BYTES - 4))
{
VerifyFlash(Address);
}
else
{
TB_SendAck(TB_ERR_VALUE, Address);
}
break;
case WRITE_FLASH:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
Aktualni = (Address & ADDRESS_MASK_MSB);
if (Address < (START_BOOT_ADDRESS_BYTES - 4))
{
if (Aktualni == Predchozi)
{
FillBufferData(Address);
EndComFlash = 1;
TB_SendAck(TB_ERR_OK, WRITE_FLASH);
}
else
{
if (EndComFlash)
{
WriteFlashPages(Predchozi, BufferFlash);
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
FillBufferData(Address);
TB_SendAck(TB_ERR_OK, Address);
Predchozi = Address;
}
else
{
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
FillBufferData(Address);
TB_SendAck(TB_ERR_OK, WRITE_FLASH);
Predchozi = Address;
}
}
NowFlash = 1;
}
else
{
TB_SendAck(TB_ERR_VALUE, Address);
}
break;
case WRITE_EEPROM:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
Aktualni = (Address & ADDRESS_MASK_MSB);
if (Address < (START_EEPROM_ADDRESS - 4))
{
if (Aktualni == Predchozi)
{
FillBufferData(Address);
EndComEeprom = 1;
TB_SendAck(TB_ERR_OK, WRITE_EEPROM);
}
else
{
if (EndComEeprom)
{
WriteEepromPages(Predchozi, BufferFlash);
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
FillBufferData(Address);
TB_SendAck(TB_ERR_OK, Address);
Predchozi = Address;
}
else
{
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
FillBufferData(Address);
TB_SendAck(TB_ERR_OK, WRITE_EEPROM);
}
}
NowEeprom = 1;
}
else
{
TB_SendAck(TB_ERR_VALUE, Address);
}
break;
case END_WRITE_ALL:
if (NowFlash)
{
WriteFlashPages(Predchozi, BufferFlash);
EndComFlash=0;
TB_SendAck(TB_ERR_OK, END_WRITE_ALL);
}
else if(NowEeprom)
{
WriteEepromPages(Predchozi, BufferFlash);
EndComEeprom = 0;
TB_SendAck(TB_ERR_OK, END_WRITE_ALL);
}
else
{
TB_SendAck(TB_ERR_VALUE, 0);
}
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
Predchozi = 0;
Aktualni = 0;
break;
case READ_FLASH:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
if (Address < (START_BOOT_ADDRESS_BYTES - 4))
{
ReadFlashPages(Address);
}
else
{
TB_SendAck(TB_ERR_VALUE, 0);
}
break;
case READ_EEPROM:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
if (Address < (START_EEPROM_ADDRESS - 4))
{
ReadEepromPages(Address);
}
else
{
TB_SendAck(TB_ERR_VALUE, READ_EEPROM);
}
break;
case CMD_SPM_PAGE_SIZE:
TB_SendAck(TB_ERR_OK, SPM_PAGESIZE);
break;
case CMD_ALL_PAGE_SIZE:
TB_SendAck(TB_ERR_OK, PAGE_SIZE);
break;
case EXIT_BOOTLOADER:
TB_SendAck(TB_ERR_OK, EXIT_BOOTLOADER);
jumpaddress();
break;
}
}
}
}
