BOOL HAL_CONFIG_BLOCK::GetConfigSectorAddress(HAL_CONFIG_BLOCK_STORAGE_DATA& blData)
{
#if defined(HAL_REDUCESIZE)
// No config update.
return FALSE;
#else
BOOL fRet = FALSE;
BlockStorageStream stream;
if(stream.Initialize( BlockUsage::CONFIG ))
{
const BlockDeviceInfo* DeviceInfo = stream.Device->GetDeviceInfo();
blData.Device = stream.Device;
if(DeviceInfo)
{
UINT32 regionIndex, rangeIndex;
DeviceInfo->FindRegionFromAddress( stream.BaseAddress, regionIndex, rangeIndex );
const BlockRegionInfo* pRegion = &DeviceInfo->Regions[regionIndex];
blData.ConfigAddress = pRegion->BlockAddress( pRegion->BlockRanges[rangeIndex].StartBlock );
blData.BlockLength = pRegion->BytesPerBlock;
if (0 == DeviceInfo->Attribute.SupportsXIP)
{
// For windows builds this will cause a memory access violation because g_ConfigurationSector
// is a const. We also don't need to do this for the emulator because we only use the dynamic
// section of the config sector as non-XIP (in other words, g_ConfigurationSector is accessible).
#ifndef _WIN32
BYTE* pConfig = (BYTE*)&g_ConfigurationSector;
// get the latest right data from nonXIP block
stream.Read( &pConfig, sizeof(ConfigurationSector) );
#endif
blData.isXIP = FALSE ;
}
else
{
blData.isXIP = TRUE;
}
fRet = TRUE;
}
}
return fRet;
#endif
}
BOOL SimpleStorage::Compact()
{
GLOBAL_LOCK(irq);
BlockStorageStream* pFreeBlock = (s_pCurrentStream == &s_BsStreamA) ? &s_BsStreamB : &s_BsStreamA;
SIMPLESTORAGE_FILE_HEADER header;
UINT8 buffer[256];
const UINT32 eraseBlock = 0x0;
const UINT32 activeBlock = SIMPLESTORAGE_ACTIVE_BLOCK_MARKER;
pFreeBlock->Seek(0, BlockStorageStream::SeekBegin);
if(!pFreeBlock->Erase(pFreeBlock->Length)) return FALSE;
pFreeBlock->Seek(sizeof(SIMPLESTORAGE_BLOCK_HEADER), BlockStorageStream::SeekBegin);
s_pCurrentStream->Seek(sizeof(SIMPLESTORAGE_BLOCK_HEADER), BlockStorageStream::SeekBegin);
do
{
INT32 len;
if(!ReadToNextFile(header)) break;
if(header.Signature != SIMPLESTORAGE_FILE_SIGNATURE) break;
pFreeBlock->Write((UINT8*)&header, sizeof(header));
len = header.Length;
while(len > 0)
{
int bufLen = len < ARRAYSIZE(buffer) ? len : ARRAYSIZE(buffer);
if(!s_pCurrentStream->ReadIntoBuffer((UINT8*)buffer, bufLen)) break;
if(!pFreeBlock->Write((UINT8*)buffer, bufLen)) break;
len -= bufLen;
}
}
while(s_pCurrentStream->CurrentIndex + sizeof(header) < s_pCurrentStream->Length);
s_pCurrentStream->Seek(0, BlockStorageStream::SeekBegin);
s_pCurrentStream->Write((UINT8*)&eraseBlock, sizeof(eraseBlock));
pFreeBlock->Seek(0, BlockStorageStream::SeekBegin);
pFreeBlock->Write((UINT8*)&activeBlock, sizeof(activeBlock));
s_pCurrentStream = pFreeBlock;
return TRUE;
}
UINT32 MicroBooter_PrepareForExecution(UINT32 physicalEntryPointAddress)
{
if (physicalEntryPointAddress == CODE_BASEADDRESS)
{
BlockStorageDevice *device;
ByteAddress ByteAddress;
UINT32 physicalAddress = CODE_BASEADDRESS;
if (BlockStorageList::FindDeviceForPhysicalAddress( &device, physicalAddress, ByteAddress))
{
BlockStorageStream stream;
if(stream.Initialize(BlockUsage::CODE, device))
{
BYTE *dst;
if(stream.CurrentAddress() != CODE_BASEADDRESS)
{
hal_fprintf( STREAM_LCD, "Warn: at wrong offset: 0x%08x\r\n", (UINT32)stream.CurrentAddress());
debug_printf( "Warn: at wrong offset: 0x%08x\r\n", (UINT32)stream.CurrentAddress());
stream.Seek(CODE_BASEADDRESS - stream.CurrentAddress(), BlockStorageStream::SeekCurrent);
}
// load ER_FLASH only
dst =(BYTE *) EXCODE_BASEADDRESS ;
stream.Read( &dst, CODE_SIZE );
CPU_DrainWriteBuffers();
}
}
}
return EXCODE_BASEADDRESS;
}
void Initialize()
{
#if defined(PLATFORM_ARM_MOTE2)
if (COM_IsUsb(HalSystemConfig.DebugTextPort))
WaitInterval = 5000; // The USB port must be selected and the Start button pressed all during this time
else
WaitInterval = 2000; // The USART port may be selected before powering on the Imote2, so it takes less time
#else
WaitInterval = 2000;
#endif
SerialPortActive = FALSE;
UsartPort = USART_DEFAULT_PORT;
UsingUsb = FALSE;
UsbPort = USB1;
UsbEventCode = USB_DEBUG_EVENT_IN;
//--//
// wait an extra second for buttons and COM port to stabilize
Events_WaitForEvents( 0, 1000 );
// COM init is now delayed for TinyBootloader, so we need to initialize it here
CPU_InitializeCommunication();
//--//
// set default baud rate
if(UsartPort != DEBUG_TEXT_PORT)
{
DebuggerPort_Initialize( UsartPort );
}
// extra time to allow USB setup, so that we can see the printf
Events_WaitForEvents( 0, 1000 );
hal_printf( "PortBooter v%d.%d.%d.%d\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD, VERSION_REVISION);
hal_printf( "Build Date: %s %s\r\n", __DATE__, __TIME__);
#if defined(__GNUC__)
hal_printf( "GNU Compiler version %d\r\n", __GNUC__);
#elif defined(__ADSPBLACKFIN__)
hal_printf( "Blackfin Compiler version %d\r\n", __VERSIONNUM__ );
#else
hal_printf( "ARM Compiler version %d\r\n", __ARMCC_VERSION);
#endif
//--//
BlockStorageStream stream;
FLASH_WORD ProgramWordCheck;
if(!stream.Initialize(BlockUsage::CODE)) return;
do
{
do
{
UINT32 addr = stream.CurrentAddress();
FLASH_WORD *pWord = &ProgramWordCheck;
stream.Read( (BYTE**)&pWord, sizeof(FLASH_WORD) );
if(*pWord == PROGRAM_WORD_CHECK)
{
hal_printf("*** nXIP Program found at 0x%08x\r\n", addr );
Programs[ProgramCount++] = (UINT32)addr;
}
if(ProgramCount == MAX_PROGRAMS) break;
}
while( stream.Seek( BlockStorageStream::STREAM_SEEK_NEXT_BLOCK, BlockStorageStream::SeekCurrent ) );
} while(stream.NextStream());
}
BOOL MicroBooterUpdateProvider::InstallUpdate( MFUpdate* pUpdate, UINT8* pValidation, INT32 validationLen )
{
if(pUpdate->Providers->Storage == NULL) return FALSE;
if(!pUpdate->IsValidated()) return FALSE;
switch(pUpdate->Header.UpdateType)
{
case MFUPDATE_UPDATETYPE_FIRMWARE:
{
HAL_UPDATE_CONFIG cfg;
if(sizeof(cfg.UpdateSignature) < validationLen) return FALSE;
cfg.Header.Enable = TRUE;
cfg.UpdateID = pUpdate->Header.UpdateID;
if(validationLen == sizeof(UINT32))
{
cfg.UpdateSignType = HAL_UPDATE_CONFIG_SIGN_TYPE__CRC;
}
else
{
cfg.UpdateSignType = HAL_UPDATE_CONFIG_SIGN_TYPE__SIGNATURE;
}
memcpy( cfg.UpdateSignature, pValidation, validationLen );
if(HAL_CONFIG_BLOCK::UpdateBlockWithName(cfg.GetDriverName(), &cfg, sizeof(cfg), FALSE))
{
CPU_Reset();
}
}
break;
case MFUPDATE_UPDATETYPE_ASSEMBLY:
{
BlockStorageStream stream;
if(NULL == BlockStorageList::GetFirstDevice())
{
BlockStorageList::Initialize();
BlockStorage_AddDevices();
BlockStorageList::InitializeDevices();
}
if(stream.Initialize(BlockUsage::DEPLOYMENT))
{
if(pUpdate->Header.UpdateSubType == MFUPDATE_UPDATESUBTYPE_ASSEMBLY_REPLACE_DEPLOY)
{
do
{
stream.Erase(stream.Length);
}
while(stream.NextStream());
stream.Initialize(BlockUsage::DEPLOYMENT);
}
do
{
UINT8 buf[512];
INT32 offset = 0;
INT32 len = sizeof(buf);
const BlockDeviceInfo* deviceInfo = stream.Device->GetDeviceInfo();
BOOL isXIP = deviceInfo->Attribute.SupportsXIP;
const CLR_RECORD_ASSEMBLY* header;
INT32 headerInBytes = sizeof(CLR_RECORD_ASSEMBLY);
BYTE * headerBuffer = NULL;
if(!isXIP)
{
headerBuffer = (BYTE*)private_malloc( headerInBytes ); if(!headerBuffer) return FALSE;
memset( headerBuffer, 0, headerInBytes );
}
while(TRUE)
{
if(!stream.Read( &headerBuffer, headerInBytes )) break;
header = (const CLR_RECORD_ASSEMBLY*)headerBuffer;
// check header first before read
if(!header->GoodHeader())
{
stream.Seek(-headerInBytes);
if(stream.IsErased(pUpdate->Header.UpdateSize))
{
while(offset < pUpdate->Header.UpdateSize)
{
if((pUpdate->Header.UpdateSize - offset) < len)
{
len = pUpdate->Header.UpdateSize - offset;
}
offset += pUpdate->Providers->Storage->Read(pUpdate->StorageHandle, offset, buf, len);
stream.Write(buf, len);
}
ClrReboot();
return TRUE;
}
break;
}
UINT32 AssemblySizeInByte = ROUNDTOMULTIPLE(header->TotalSize(), CLR_UINT32);
stream.Seek( AssemblySizeInByte );
}
if(!isXIP) private_free( headerBuffer );
}
while(stream.NextStream());
}
}
break;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////////
// The TinyBooter_OnStateChange method is an event handler for state changes in
// the TinyBooter. It is designed to help porting kit users control the tinybooter
// execution and allow them to add diagnostics.
////////////////////////////////////////////////////////////////////////////////
void TinyBooter_OnStateChange(TinyBooterState state, void* data, void ** retData)
{
switch (state)
{
////////////////////////////////////////////////////////////////////////////////////
// State_EnterBooterMode - TinyBooter has entered upload mode
////////////////////////////////////////////////////////////////////////////////////
case State_EnterBooterMode:
hal_fprintf(STREAM_LCD, "Waiting\r");
break;
////////////////////////////////////////////////////////////////////////////////////
// State_ButtonPress - A button was pressed while Tinybooter
// The data parameter is a pointer to the timeout value for the booter mode.
////////////////////////////////////////////////////////////////////////////////////
case State_ButtonPress:
if (NULL != data)
{
UINT32 down, up;
INT32* timeout_ms = (INT32*)data;
// wait forever if a button was pressed
*timeout_ms = -1;
// process buttons
while (Buttons_GetNextStateChange(down, up))
{
// leave a way to exit boot mode incase it was accidentally entered
if (0 != (down & BUTTON_ENTR))
{
// force an enumerate and launch
*timeout_ms = 0;
}
}
}
break;
////////////////////////////////////////////////////////////////////////////////////
// State_ValidCommunication - TinyBooter has received valid communication from the host
// The data parameter is a pointer to the timeout value for the booter mode.
////////////////////////////////////////////////////////////////////////////////////
case State_ValidCommunication:
if (NULL != data)
{
INT32* timeout_ms = (INT32*)data;
// if we received any com/usb data then let's change the timeout to at least 20 seconds
if (*timeout_ms != -1 && *timeout_ms < 20000)
{
*timeout_ms = 20000;
}
}
break;
////////////////////////////////////////////////////////////////////////////////////
// State_Timeout - The default timeout for TinyBooter has expired and TinyBooter will
// perform an EnumerateAndLaunch
////////////////////////////////////////////////////////////////////////////////////
case State_Timeout:
break;
////////////////////////////////////////////////////////////////////////////////////
// State_MemoryXXX - Identifies memory accesses.
////////////////////////////////////////////////////////////////////////////////////
case State_MemoryWrite:
hal_fprintf(STREAM_LCD, "Wr: 0x%08x\r", (UINT32)data);
break;
case State_MemoryErase:
hal_fprintf(STREAM_LCD, "Er: 0x%08x\r", (UINT32)data);
break;
////////////////////////////////////////////////////////////////////////////////////
// State_CryptoXXX - Start and result of Crypto signature check
////////////////////////////////////////////////////////////////////////////////////
case State_CryptoStart:
hal_fprintf(STREAM_LCD, "Chk signature \r");
hal_printf("Chk signature \r");
break;
// The data parameter is a boolean that represents signature PASS/FAILURE
case State_CryptoResult:
if ((bool)data)
{
hal_fprintf(STREAM_LCD, "Signature PASS\r\n\r\n");
hal_printf("Signature PASS\r\n\r\n");
}
else
{
hal_fprintf(STREAM_LCD, "Signature FAIL\r\n\r\n");
hal_printf("Signature FAIL\r\n\r\n");
}
DebuggerPort_Flush(HalSystemConfig.DebugTextPort);
break;
////////////////////////////////////////////////////////////////////////////////////
// State_Launch - The host has requested to launch an application at a given address,
// or a timeout has occured and TinyBooter is about to launch the
// first application it finds in FLASH.
//
// The data parameter is a UINT32 value representing the launch address
////////////////////////////////////////////////////////////////////////////////////
case State_Launch:
UINT32 address = (UINT32)data;
if (NULL != data)
{
hal_fprintf(STREAM_LCD, "Starting application at 0x%08x\r\n", address);
debug_printf("Starting application at 0x%08x\r\n", address);
if (address == CODE_BASEADDRESS || address == EXCODE_BASEADDRESS)
{
BlockStorageDevice *device;
ByteAddress ByteAddress;
UINT32 physicalAddress = CODE_BASEADDRESS;
if (BlockStorageList::FindDeviceForPhysicalAddress(&device, physicalAddress, ByteAddress))
{
BlockStorageStream stream;
if (stream.Initialize(BlockUsage::CODE, device))
{
if (stream.CurrentAddress() != CODE_BASEADDRESS)
{
hal_fprintf(STREAM_LCD, "Warn: at wrong offset: 0x%08x\r\n", (UINT32)stream.CurrentAddress());
debug_printf("Warn: at wrong offset: 0x%08x\r\n", (UINT32)stream.CurrentAddress());
stream.Seek(CODE_BASEADDRESS - stream.CurrentAddress(), BlockStorageStream::SeekCurrent);
}
BYTE *dst;
dst = (BYTE *)EXCODE_BASEADDRESS;
stream.Read(&dst, CODE_SIZE);
if (retData != NULL)
{
*retData = (void*)EXCODE_BASEADDRESS;
}
CPU_DrainWriteBuffers();
}
}
}
else if (retData != NULL)
{
*retData = (void*)data;
}
}
break;
}
}
