EEPROM simplification. Needs tests. (#3713)

This commit is contained in:
Bertrand Songis
2016-08-23 07:14:44 +02:00
committed by GitHub
parent c16ad94e3a
commit 0ff601a3fa
28 changed files with 485 additions and 480 deletions
+1 -1
View File
@@ -111,7 +111,7 @@ void storageReadAll()
void storageEraseAll(bool warn)
{
TRACE("storageEraseAll()");
TRACE("storageEraseAll");
generalDefault();
modelDefault(0);
+35 -30
View File
@@ -63,7 +63,14 @@ uint8_t eepromWriteBuffer[EEPROM_BUFFER_SIZE] __DMA;
void eepromWaitReadStatus()
{
while ((eepromReadStatus() & 1) != 0) {
while (eepromReadStatus() == 0) {
SIMU_SLEEP(5/*ms*/);
}
}
void eepromWaitTransferComplete()
{
while (!eepromIsTransferComplete()) {
SIMU_SLEEP(5/*ms*/);
}
}
@@ -71,46 +78,44 @@ void eepromWaitReadStatus()
void eepromEraseBlock(uint32_t address, bool blocking=true)
{
// TRACE("eepromEraseBlock(%d)", address);
eepromWriteEnable();
eepromBlockErase(address);
if (blocking) {
eepromWaitSpiComplete();
eepromWaitTransferComplete();
eepromWaitReadStatus();
}
}
void eepromRead(uint32_t address, uint8_t * buffer, uint32_t size, bool blocking=true)
void eepromRead(uint8_t * buffer, size_t address, size_t size)
{
// TRACE("eepromRead(%d, %p, %d)", address, buffer, size);
// TRACE("eepromRead(%p, %d, %d)", buffer, address, size);
eepromReadArray(address, buffer, size);
if (blocking) {
eepromWaitSpiComplete();
}
eepromStartRead(buffer, address, size);
eepromWaitTransferComplete();
}
void eepromWrite(uint32_t address, uint8_t * buffer, uint32_t size, bool blocking=true)
void eepromWrite(uint8_t * buffer, size_t address, size_t size, bool blocking=true)
{
// TRACE("eepromWrite(%d, %p, %d)", address, buffer, size);
// TRACE("eepromWrite(%p, %d, %d)", buffer, address, size);
eepromWriteEnable();
eepromByteProgram(address, buffer, size);
eepromStartWrite(buffer, address, size);
if (blocking) {
eepromWaitSpiComplete();
eepromWaitTransferComplete();
eepromWaitReadStatus();
}
}
bool eepromOpen()
{
TRACE("eepromOpen");
int32_t bestFatAddr = -1;
uint32_t bestFatIndex = 0;
eepromFatAddr = 0;
while (eepromFatAddr < EEPROM_ZONE_SIZE) {
eepromRead(eepromFatAddr, (uint8_t *)&eepromHeader, sizeof(eepromHeader.mark) + sizeof(eepromHeader.index));
eepromRead((uint8_t *)&eepromHeader, eepromFatAddr, sizeof(eepromHeader.mark) + sizeof(eepromHeader.index));
if (eepromHeader.mark == EEPROM_MARK && eepromHeader.index >= bestFatIndex) {
bestFatAddr = eepromFatAddr;
bestFatIndex = eepromHeader.index;
@@ -119,7 +124,7 @@ bool eepromOpen()
}
if (bestFatAddr >= 0) {
eepromFatAddr = bestFatAddr;
eepromRead(eepromFatAddr, (uint8_t *)&eepromHeader, sizeof(eepromHeader));
eepromRead((uint8_t *)&eepromHeader, eepromFatAddr, sizeof(eepromHeader));
return true;
}
else {
@@ -132,12 +137,12 @@ uint32_t readFile(int index, uint8_t * data, uint32_t size)
if (eepromHeader.files[index].exists) {
EepromFileHeader header;
uint32_t address = eepromHeader.files[index].zoneIndex * EEPROM_ZONE_SIZE;
eepromRead(address, (uint8_t *)&header, sizeof(header));
eepromRead((uint8_t *)&header, address, sizeof(header));
if (size < header.size) {
header.size = size;
}
if (header.size > 0) {
eepromRead(address + sizeof(header), data, header.size);
eepromRead(data, address + sizeof(header), header.size);
size -= header.size;
}
if (size > 0) {
@@ -199,8 +204,8 @@ bool eeCopyModel(uint8_t dst, uint8_t src)
// write model
for (int pos=0; pos<EEPROM_ZONE_SIZE; pos+=EEPROM_BUFFER_SIZE) {
eepromRead(eepromWriteSourceAddr+pos, eepromWriteBuffer, EEPROM_BUFFER_SIZE);
eepromWrite(eepromWriteDestinationAddr+pos, eepromWriteBuffer, EEPROM_BUFFER_SIZE);
eepromRead(eepromWriteBuffer, eepromWriteSourceAddr+pos, EEPROM_BUFFER_SIZE);
eepromWrite(eepromWriteBuffer, eepromWriteDestinationAddr+pos, EEPROM_BUFFER_SIZE);
}
// write FAT
@@ -292,7 +297,7 @@ void storageFormat()
}
eepromEraseBlock(0);
eepromEraseBlock(EEPROM_BLOCK_SIZE);
eepromWrite(0, (uint8_t *)&eepromHeader, sizeof(eepromHeader));
eepromWrite((uint8_t *)&eepromHeader, 0, sizeof(eepromHeader));
}
void eepromWriteWait(EepromWriteState state/* = EEPROM_IDLE*/)
@@ -346,7 +351,7 @@ void eepromWriteProcess()
case EEPROM_WRITING_BUFFER:
case EEPROM_ERASING_FAT_BLOCK:
case EEPROM_WRITING_NEW_FAT:
if (eepromIsSpiComplete()) {
if (eepromIsTransferComplete()) {
eepromWriteState = EepromWriteState(eepromWriteState + 1);
}
break;
@@ -356,7 +361,7 @@ void eepromWriteProcess()
case EEPROM_WRITING_BUFFER_WAIT:
case EEPROM_ERASING_FAT_BLOCK_WAIT:
case EEPROM_WRITING_NEW_FAT_WAIT:
if ((eepromReadStatus() & 1) == 0) {
if (eepromReadStatus()) {
eepromWriteState = EepromWriteState(eepromWriteState + 1);
}
break;
@@ -379,7 +384,7 @@ void eepromWriteProcess()
uint32_t size = min<uint32_t>(EEPROM_BUFFER_SIZE-sizeof(EepromFileHeader), eepromWriteSize);
memcpy(eepromWriteBuffer+sizeof(EepromFileHeader), eepromWriteSourceAddr, size);
eepromWriteState = EEPROM_WRITING_BUFFER;
eepromWrite(eepromWriteDestinationAddr, eepromWriteBuffer, sizeof(EepromFileHeader)+size, false);
eepromWrite(eepromWriteBuffer, eepromWriteDestinationAddr, sizeof(EepromFileHeader)+size, false);
eepromWriteSourceAddr += size;
eepromWriteDestinationAddr += sizeof(EepromFileHeader)+size;
eepromWriteSize -= size;
@@ -392,7 +397,7 @@ void eepromWriteProcess()
if (size > 0) {
memcpy(eepromWriteBuffer, eepromWriteSourceAddr, size);
eepromWriteState = EEPROM_WRITING_BUFFER;
eepromWrite(eepromWriteDestinationAddr, eepromWriteBuffer, size, false);
eepromWrite(eepromWriteBuffer, eepromWriteDestinationAddr, size, false);
eepromWriteSourceAddr += size;
eepromWriteDestinationAddr += size;
eepromWriteSize -= size;
@@ -408,7 +413,7 @@ void eepromWriteProcess()
case EEPROM_WRITE_NEW_FAT:
eepromWriteState = EEPROM_WRITING_NEW_FAT;
eepromWrite(eepromFatAddr, (uint8_t *)&eepromHeader, sizeof(eepromHeader), false);
eepromWrite((uint8_t *)&eepromHeader, eepromFatAddr, sizeof(eepromHeader), false);
break;
case EEPROM_END_WRITE:
@@ -427,7 +432,7 @@ uint16_t eeModelSize(uint8_t index)
if (eepromHeader.files[index+1].exists) {
uint32_t address = eepromHeader.files[index+1].zoneIndex * EEPROM_ZONE_SIZE;
EepromFileHeader header;
eepromRead(address, (uint8_t *)&header, sizeof(header));
eepromRead((uint8_t *)&header, address, sizeof(header));
result = header.size;
}
@@ -483,7 +488,7 @@ const pm_char * eeBackupModel(uint8_t i_fileSrc)
uint32_t address = eepromHeader.files[i_fileSrc+1].zoneIndex * EEPROM_ZONE_SIZE + sizeof(EepromFileHeader);
while (size > 0) {
uint16_t blockSize = min<uint16_t>(size, EEPROM_BUFFER_SIZE);
eepromRead(address, eepromWriteBuffer, blockSize);
eepromRead(eepromWriteBuffer, address, blockSize);
result = f_write(&archiveFile, eepromWriteBuffer, blockSize, &written);
if (result != FR_OK || written != blockSize) {
f_close(&archiveFile);
@@ -567,7 +572,7 @@ const pm_char * eeRestoreModel(uint8_t i_fileDst, char *model_name)
f_close(&g_oLogFile);
return SDCARD_ERROR(result);
}
eepromWrite(address, eepromWriteBuffer, blockSize+offset);
eepromWrite(eepromWriteBuffer, address, blockSize+offset);
size -= blockSize;
address += EEPROM_BUFFER_SIZE;
offset = 0;
+11 -71
View File
@@ -29,74 +29,15 @@ EeFs eeFs;
#if defined(CPUARM)
blkid_t freeBlocks = 0;
#endif
uint8_t s_sync_write = false;
#if !defined(CPUARM)
uint16_t eeprom_pointer;
uint8_t * eeprom_buffer_data;
volatile int8_t eeprom_buffer_size = 0;
#if !defined(SIMU)
inline void eeprom_write_byte()
{
EEAR = eeprom_pointer;
EEDR = *eeprom_buffer_data;
// TODO add some define here
#if defined (CPUM2560) || defined(CPUM2561)
EECR |= 1<<EEMPE;
EECR |= 1<<EEPE;
#else
EECR |= 1<<EEMWE;
EECR |= 1<<EEWE;
#endif
eeprom_pointer++;
eeprom_buffer_data++;
}
ISR(EE_READY_vect)
{
if (--eeprom_buffer_size > 0) {
eeprom_write_byte();
}
else {
#if defined(CPUM2560) || defined(CPUM2561)
EECR &= ~(1<<EERIE);
#else
EECR &= ~(1<<EERIE);
#endif
}
}
#endif
void eepromWriteBlock(uint8_t * i_pointer_ram, uint16_t i_pointer_eeprom, size_t size)
{
assert(!eeprom_buffer_size);
eeprom_pointer = i_pointer_eeprom;
eeprom_buffer_data = i_pointer_ram;
eeprom_buffer_size = size+1;
#if defined(SIMU)
sem_post(eeprom_write_sem);
#elif defined (CPUM2560) || defined(CPUM2561)
EECR |= (1<<EERIE);
#else
EECR |= (1<<EERIE);
#endif
if (s_sync_write) {
while (eeprom_buffer_size > 0) wdt_reset();
}
}
uint8_t s_sync_write = false;
#endif
static uint8_t EeFsRead(blkid_t blk, uint8_t ofs)
{
uint8_t ret;
eepromReadBlock(&ret, (uint16_t)(blk*BS+ofs+BLOCKS_OFFSET), 1);
return ret;
uint8_t byte;
eepromReadBlock(&byte, (size_t)(blk*BS+ofs+BLOCKS_OFFSET), 1);
return byte;
}
static blkid_t EeFsGetLink(blkid_t blk)
@@ -246,10 +187,10 @@ void storageFormat()
{
ENABLE_SYNC_WRITE(true);
#ifdef SIMU
#if defined(SIMU)
// write zero to the end of the new EEPROM file to set it's proper size
uint8_t dummy = 0;
eepromWriteBlock(&dummy, EESIZE-1, 1);
static uint8_t dummy = 0;
eepromWriteBlock(&dummy, EEPROM_SIZE-1, 1);
#endif
memclear(&eeFs, sizeof(eeFs));
@@ -831,9 +772,8 @@ void RlcFile::nextRlcWriteStep()
void RlcFile::flush()
{
#if !defined(CPUARM)
while (eeprom_buffer_size > 0) wdt_reset();
#endif
while (!eepromIsTransferComplete())
wdt_reset();
ENABLE_SYNC_WRITE(true);
@@ -1008,11 +948,11 @@ void eepromBackup()
// open the file for writing...
f_open(&file, filename, FA_WRITE | FA_CREATE_ALWAYS);
for (int i=0; i<EESIZE; i+=1024) {
for (int i=0; i<EEPROM_SIZE; i+=1024) {
UINT count;
eepromReadBlock(buffer, i, 1024);
f_write(&file, buffer, 1024, &count);
updateProgressBar(i, EESIZE);
updateProgressBar(i, EEPROM_SIZE);
SIMU_SLEEP(100/*ms*/);
}
+12 -20
View File
@@ -25,27 +25,16 @@
#if defined(PCBTARANIS)
#define blkid_t uint16_t
#if !defined(EESIZE)
#if defined(REV4a)
#define EESIZE (64*1024)
#else
#define EESIZE (32*1024)
#endif
#else
#define EESIZE_SIMU (64*1024)
#endif
#define EEFS_VERS 5
#define MAXFILES 62
#define BS 64
#elif defined(CPUM2560) || defined(CPUM2561) || defined(CPUM128)
#define blkid_t uint8_t
#define EESIZE 4096
#define EEFS_VERS 5
#define MAXFILES 36
#define BS 16
#else
#define blkid_t uint8_t
#define EESIZE 2048
#define EEFS_VERS 4
#define MAXFILES 20
#define BS 16
@@ -87,20 +76,16 @@ extern EeFs eeFs;
#if defined(CPUM64)
#define FIRSTBLK (RESV/BS)
#define BLOCKS (EESIZE/BS)
#define BLOCKS (EEPROM_SIZE/BS)
#define BLOCKS_OFFSET 0
#else
#define FIRSTBLK 1
#define BLOCKS (1+(EESIZE-RESV)/BS)
#define BLOCKS (1+(EEPROM_SIZE-RESV)/BS)
#define BLOCKS_OFFSET (RESV-BS)
#endif
uint16_t EeFsGetFree();
#if !defined(CPUARM)
extern volatile int8_t eeprom_buffer_size;
#endif
class EFile
{
public:
@@ -134,9 +119,14 @@ class EFile
#define ERR_FULL 1
extern uint8_t s_write_err; // error reasons
extern uint8_t s_sync_write;
#define ENABLE_SYNC_WRITE(val) s_sync_write = val;
#define IS_SYNC_WRITE_ENABLE() s_sync_write
#if defined(CPUARM)
#define ENABLE_SYNC_WRITE(val)
#define IS_SYNC_WRITE_ENABLE() true
#else
#define ENABLE_SYNC_WRITE(val) s_sync_write = val;
#define IS_SYNC_WRITE_ENABLE() s_sync_write
#endif
///deliver current errno, this is reset in open
inline uint8_t write_errno() { return s_write_err; }
@@ -200,6 +190,8 @@ inline void eeFlush()
theFile.flush();
}
void eepromWriteBlock(uint8_t * buffer, size_t address, size_t size);
inline bool eepromIsWriting()
{
return theFile.isWriting();