/* main loop for the UART send thread */
void UartSendThreadMainFunc(ULONG v)
{
ULONG actualFlag;
while(true)
{
//wait for a flag wake the thread up
tx_event_flags_get(&gUartSendEventFlags, 1, TX_AND, &actualFlag, TX_WAIT_FOREVER);
//send next letter
send_next_uart();
}
}
wiced_result_t wiced_rtos_wait_for_event_flags( wiced_event_flags_t* event_flags, uint32_t flags_to_wait_for, uint32_t* flags_set, wiced_bool_t clear_set_flags, wiced_event_flags_wait_option_t wait_option, uint32_t timeout_ms )
{
UINT option = 0;
option |= ( clear_set_flags == WICED_TRUE ) ? ( 1 << 0 ) : 0;
option |= ( wait_option == WAIT_FOR_ALL_EVENTS ) ? ( 1 << 1 ) : 0;
if ( tx_event_flags_get( event_flags, flags_to_wait_for, option, (ULONG*)flags_set, TX_TIMEOUT( timeout_ms ) ) != TX_SUCCESS )
{
return WICED_ERROR;
}
return WICED_SUCCESS;
}
void thread_5_entry(ULONG thread_input)
{
UINT status;
ULONG actual_flags;
/* This thread simply waits for an event in a forever loop. */
while(1)
{
/* Increment the thread counter. */
thread_5_counter++;
/* Wait for event flag 0. */
status = tx_event_flags_get(&event_flags_0, 0x1, TX_OR_CLEAR,
&actual_flags, TX_WAIT_FOREVER);
/* Check status. */
if ((status != TX_SUCCESS) || (actual_flags != 0x1))
break;
}
}
/*
* compact given EraseUnit. if previous compaction failed, supply the LogEntry as
* argument and the function will continue the process from the failure point
*/
static FS_STATUS CompactBlock(uint8_t euIndex,LogEntry entry)
{
EraseUnitHeader header;
uint32_t acutalFlags;
uint16_t actualNextFileDescIdx = 0,secDescAddr,dataOffset;
uint8_t i;
FS_STATUS status;
SectorDescriptor sec;
//if the LogEntry we got is uninitilize one, init it with data
if (entry.bits.valid == 1)
{
entry.bits.euIndex = euIndex;
entry.bits.eraseNumber = gEUList[euIndex].eraseNumber+1;
if (WRITE_LOG_ENTRY(gLogIndex,entry) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
//flash_write((gLogIndex+1)*FLASH_BLOCK_SIZE - sizeof(LogEntry),sizeof(LogEntry),(uint8_t*)&entry);
}
//mark the entry as valid if needed
if (entry.bits.valid == 1)
{
entry.bits.valid = 0;
//make the entry valid
if (WRITE_LOG_ENTRY(gLogIndex,entry) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
}
//if we didn't copy files yet
if (entry.bits.copyComplete == 1)
{
memset(&header,0xFF,sizeof(EraseUnitHeader));
//if we going to copy some valid files, mark the header as non empty
if (gEUList[euIndex].validDescriptors > 0)
{
header.metadata.bits.emptyEU = 0;
gEUList[gLogIndex].metadata.bits.emptyEU = 0;
}
if (flash_write(gLogIndex*FLASH_BLOCK_SIZE,sizeof(EraseUnitHeader),(uint8_t*)&header) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
//set initial addres and offset
secDescAddr = gLogIndex*FLASH_BLOCK_SIZE + sizeof(EraseUnitHeader);
dataOffset = FLASH_BLOCK_SIZE - sizeof(LogEntry);
//start to copy files
for(i = 0 ; i < gEUList[euIndex].validDescriptors ; ++i)
{
getNextValidSectorDescriptor(euIndex,&actualNextFileDescIdx,&sec);
dataOffset -= sec.size;
//copy the file's conent to the new block
if ((status = CopyDataInsideFlash(FLASH_BLOCK_SIZE*euIndex + sec.offset,sec.size,FLASH_BLOCK_SIZE*gLogIndex + dataOffset)) != FS_SUCCESS)
{
return status;;
}
sec.offset = dataOffset;
//set the file's descriptor (SecotrDescriptor)
if (flash_write(secDescAddr,sizeof(SectorDescriptor),(uint8_t*)&sec) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
secDescAddr+=sizeof(SectorDescriptor);
}
//set copy complete
entry.bits.copyComplete = 0;
if (flash_write(gLogIndex*FLASH_BLOCK_SIZE,sizeof(EraseUnitHeader),(uint8_t*)&header) != FS_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
}
//erase the block if need to
if (entry.bits.eraseComplete == 1)
{
if (flash_block_erase_start(FLASH_BLOCK_SIZE*euIndex) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
tx_event_flags_get(&gFsGlobalEventFlags,1,TX_AND_CLEAR,&acutalFlags,TX_WAIT_FOREVER);
//set erase complete
entry.bits.eraseComplete = 0;
if (flash_write(gLogIndex*FLASH_BLOCK_SIZE,sizeof(EraseUnitHeader),(uint8_t*)&header) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
}
//set log header to this erased block
memset(&header,0xFF,sizeof(EraseUnitHeader));
header.canary = CANARY_VALUE;
header.eraseNumber = entry.bits.eraseNumber;
header.metadata.bits.type = LOG;
header.metadata.bits.valid = 0;
if (flash_write(euIndex*FLASH_BLOCK_SIZE,sizeof(EraseUnitHeader),(uint8_t*)&header) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
//change old log's type to data type
memset(&header,0xFF,sizeof(EraseUnitHeader));
header.metadata.bits.type = DATA;
if (flash_write(gLogIndex*FLASH_BLOCK_SIZE,sizeof(EraseUnitHeader),(uint8_t*)&header) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
//set some general data
gEUList[euIndex].eraseNumber++;
gEUList[gLogIndex].bytesFree = gEUList[euIndex].bytesFree + gEUList[euIndex].deleteFilesTotalSize;
gEUList[gLogIndex].deleteFilesTotalSize = 0;
gEUList[gLogIndex].nextFreeOffset = dataOffset;
gEUList[gLogIndex].totalDescriptors = gEUList[gLogIndex].validDescriptors = gEUList[euIndex].validDescriptors;
gEUList[euIndex].metadata.bits.type = LOG;
//set new log index
gLogIndex = euIndex;
return FS_SUCCESS;
}
/*
* install FileSystem on the flash. all previouse content will be deleted
*/
static FS_STATUS intstallFileSystem()
{
int i;
uint16_t euAddress = 0;
uint32_t acutalFlags;
EraseUnitHeader header;
memset(&header,0xFF,sizeof(EraseUnitHeader));
header.canary = CANARY_VALUE;
header.eraseNumber = 0;
header.metadata.bits.emptyEU = 1;
//1. erase the whole flash
if (flash_bulk_erase_start() != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
tx_event_flags_get(&gFsGlobalEventFlags,1,TX_AND_CLEAR,&acutalFlags,TX_WAIT_FOREVER);
//2. write each EraseUnitHeader + update the data structure of the EU's logical metadata.
//the LOG will be placed at the first block.
for(i = 0 ; i < ERASE_UNITS_NUMBER ; ++i)
{
header.metadata.bits.valid = 1;
if (i > 0)
{
header.metadata.bits.type = DATA;
gEUList[i].nextFreeOffset = FLASH_BLOCK_SIZE;
gEUList[i].bytesFree = FLASH_BLOCK_SIZE-sizeof(EraseUnitHeader);
}
else
{
header.metadata.bits.type = LOG;
gEUList[i].nextFreeOffset = FLASH_BLOCK_SIZE - sizeof(LogEntry); //make room for one log entry at the end of the block
gEUList[i].bytesFree = FLASH_BLOCK_SIZE-sizeof(EraseUnitHeader) - sizeof(LogEntry);
}
if (flash_write(euAddress,sizeof(EraseUnitHeader),(uint8_t*)&header) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
header.metadata.bits.valid = 0;
if (flash_write(euAddress + MY_OFFSET(EraseUnitHeader,metadata.data),1,(uint8_t*)&header.metadata.data) != OPERATION_SUCCESS)
{
return FAILURE_ACCESSING_FLASH;
}
//init the DAST which saves data about every EraseUnit (block)
gEUList[i].eraseNumber = 0;
gEUList[i].validDescriptors = 0;
gEUList[i].totalDescriptors = 0;
gEUList[i].deleteFilesTotalSize = 0;
gEUList[i].metadata = header.metadata;
euAddress+=FLASH_BLOCK_SIZE;
}
gLogIndex = 0;
gFilesCount = 0;
return FS_SUCCESS;
}
