Mirror/edgetx
1
0
Fork 0
mirror of https://github.com/EdgeTX/edgetx.git synced 2025-07-25 17:25:10 +03:00
Code Activity

EEPROM simplification. Needs tests. (#3713)

Browse source
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
Download patch file Download diff file Expand all files Collapse all files

2
radio/src/CMakeLists.txt
View file

@ -140,7 +140,7 @@ elseif(${EEPROM} STREQUAL EEPROM_RLC)
add_definitions(-DEEPROM -DEEPROM_RLC) add_definitions(-DEEPROM -DEEPROM_RLC)
else() else()
set(SRC ${SRC} storage/storage_common.cpp storage/eeprom_common.cpp storage/eeprom_raw.cpp) set(SRC ${SRC} storage/storage_common.cpp storage/eeprom_common.cpp storage/eeprom_raw.cpp)
add_definitions(-DEEPROM) add_definitions(-DEEPROM -DEEPROM_RAW)
endif() endif()
if(ARCH STREQUAL ARM AND NOT PCB STREQUAL HORUS AND NOT PCB STREQUAL FLAMENCO) if(ARCH STREQUAL ARM AND NOT PCB STREQUAL HORUS AND NOT PCB STREQUAL FLAMENCO)

2
radio/src/main_avr.cpp
View file

@ -88,7 +88,7 @@ void perMain()
} }
#endif #endif
if (!eeprom_buffer_size) { if (eepromIsTransferComplete()) {
if (theFile.isWriting()) if (theFile.isWriting())
theFile.nextWriteStep(); theFile.nextWriteStep();
else if (TIME_TO_WRITE()) else if (TIME_TO_WRITE())

2
radio/src/storage/eeprom_common.cpp
View file

@ -111,7 +111,7 @@ void storageReadAll()
void storageEraseAll(bool warn) void storageEraseAll(bool warn)
{ {
TRACE("storageEraseAll()"); TRACE("storageEraseAll");
generalDefault(); generalDefault();
modelDefault(0); modelDefault(0);

65
radio/src/storage/eeprom_raw.cpp
View file

@ -63,7 +63,14 @@ uint8_t eepromWriteBuffer[EEPROM_BUFFER_SIZE] __DMA;
void eepromWaitReadStatus() void eepromWaitReadStatus()
{ {
while ((eepromReadStatus() & 1) != 0) { while (eepromReadStatus() == 0) {
SIMU_SLEEP(5/*ms*/);
}
}
void eepromWaitTransferComplete()
{
while (!eepromIsTransferComplete()) {
SIMU_SLEEP(5/*ms*/); SIMU_SLEEP(5/*ms*/);
} }
} }
@ -71,46 +78,44 @@ void eepromWaitReadStatus()
void eepromEraseBlock(uint32_t address, bool blocking=true) void eepromEraseBlock(uint32_t address, bool blocking=true)
{ {
// TRACE("eepromEraseBlock(%d)", address); // TRACE("eepromEraseBlock(%d)", address);
eepromWriteEnable();
eepromBlockErase(address); eepromBlockErase(address);
if (blocking) { if (blocking) {
eepromWaitSpiComplete(); eepromWaitTransferComplete();
eepromWaitReadStatus(); 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); eepromStartRead(buffer, address, size);
if (blocking) { eepromWaitTransferComplete();
eepromWaitSpiComplete();
}
} }
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(); eepromStartWrite(buffer, address, size);
eepromByteProgram(address, buffer, size);
if (blocking) { if (blocking) {
eepromWaitSpiComplete(); eepromWaitTransferComplete();
eepromWaitReadStatus(); eepromWaitReadStatus();
} }
} }
bool eepromOpen() bool eepromOpen()
{ {
TRACE("eepromOpen");
int32_t bestFatAddr = -1; int32_t bestFatAddr = -1;
uint32_t bestFatIndex = 0; uint32_t bestFatIndex = 0;
eepromFatAddr = 0; eepromFatAddr = 0;
while (eepromFatAddr < EEPROM_ZONE_SIZE) { 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) { if (eepromHeader.mark == EEPROM_MARK && eepromHeader.index >= bestFatIndex) {
bestFatAddr = eepromFatAddr; bestFatAddr = eepromFatAddr;
bestFatIndex = eepromHeader.index; bestFatIndex = eepromHeader.index;
@ -119,7 +124,7 @@ bool eepromOpen()
} }
if (bestFatAddr >= 0) { if (bestFatAddr >= 0) {
eepromFatAddr = bestFatAddr; eepromFatAddr = bestFatAddr;
eepromRead(eepromFatAddr, (uint8_t *)&eepromHeader, sizeof(eepromHeader)); eepromRead((uint8_t *)&eepromHeader, eepromFatAddr, sizeof(eepromHeader));
return true; return true;
} }
else { else {
@ -132,12 +137,12 @@ uint32_t readFile(int index, uint8_t * data, uint32_t size)
if (eepromHeader.files[index].exists) { if (eepromHeader.files[index].exists) {
EepromFileHeader header; EepromFileHeader header;
uint32_t address = eepromHeader.files[index].zoneIndex * EEPROM_ZONE_SIZE; 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) { if (size < header.size) {
header.size = size; header.size = size;
} }
if (header.size > 0) { if (header.size > 0) {
eepromRead(address + sizeof(header), data, header.size); eepromRead(data, address + sizeof(header), header.size);
size -= header.size; size -= header.size;
} }
if (size > 0) { if (size > 0) {
@ -199,8 +204,8 @@ bool eeCopyModel(uint8_t dst, uint8_t src)
// write model // write model
for (int pos=0; pos<EEPROM_ZONE_SIZE; pos+=EEPROM_BUFFER_SIZE) { for (int pos=0; pos<EEPROM_ZONE_SIZE; pos+=EEPROM_BUFFER_SIZE) {
eepromRead(eepromWriteSourceAddr+pos, eepromWriteBuffer, EEPROM_BUFFER_SIZE); eepromRead(eepromWriteBuffer, eepromWriteSourceAddr+pos, EEPROM_BUFFER_SIZE);
eepromWrite(eepromWriteDestinationAddr+pos, eepromWriteBuffer, EEPROM_BUFFER_SIZE); eepromWrite(eepromWriteBuffer, eepromWriteDestinationAddr+pos, EEPROM_BUFFER_SIZE);
} }
// write FAT // write FAT
@ -292,7 +297,7 @@ void storageFormat()
} }
eepromEraseBlock(0); eepromEraseBlock(0);
eepromEraseBlock(EEPROM_BLOCK_SIZE); eepromEraseBlock(EEPROM_BLOCK_SIZE);
eepromWrite(0, (uint8_t *)&eepromHeader, sizeof(eepromHeader)); eepromWrite((uint8_t *)&eepromHeader, 0, sizeof(eepromHeader));
} }
void eepromWriteWait(EepromWriteState state/* = EEPROM_IDLE*/) void eepromWriteWait(EepromWriteState state/* = EEPROM_IDLE*/)
@ -346,7 +351,7 @@ void eepromWriteProcess()
case EEPROM_WRITING_BUFFER: case EEPROM_WRITING_BUFFER:
case EEPROM_ERASING_FAT_BLOCK: case EEPROM_ERASING_FAT_BLOCK:
case EEPROM_WRITING_NEW_FAT: case EEPROM_WRITING_NEW_FAT:
if (eepromIsSpiComplete()) { if (eepromIsTransferComplete()) {
eepromWriteState = EepromWriteState(eepromWriteState + 1); eepromWriteState = EepromWriteState(eepromWriteState + 1);
} }
break; break;
@ -356,7 +361,7 @@ void eepromWriteProcess()
case EEPROM_WRITING_BUFFER_WAIT: case EEPROM_WRITING_BUFFER_WAIT:
case EEPROM_ERASING_FAT_BLOCK_WAIT: case EEPROM_ERASING_FAT_BLOCK_WAIT:
case EEPROM_WRITING_NEW_FAT_WAIT: case EEPROM_WRITING_NEW_FAT_WAIT:
if ((eepromReadStatus() & 1) == 0) { if (eepromReadStatus()) {
eepromWriteState = EepromWriteState(eepromWriteState + 1); eepromWriteState = EepromWriteState(eepromWriteState + 1);
} }
break; break;
@ -379,7 +384,7 @@ void eepromWriteProcess()
uint32_t size = min<uint32_t>(EEPROM_BUFFER_SIZE-sizeof(EepromFileHeader), eepromWriteSize); uint32_t size = min<uint32_t>(EEPROM_BUFFER_SIZE-sizeof(EepromFileHeader), eepromWriteSize);
memcpy(eepromWriteBuffer+sizeof(EepromFileHeader), eepromWriteSourceAddr, size); memcpy(eepromWriteBuffer+sizeof(EepromFileHeader), eepromWriteSourceAddr, size);
eepromWriteState = EEPROM_WRITING_BUFFER; eepromWriteState = EEPROM_WRITING_BUFFER;
eepromWrite(eepromWriteDestinationAddr, eepromWriteBuffer, sizeof(EepromFileHeader)+size, false); eepromWrite(eepromWriteBuffer, eepromWriteDestinationAddr, sizeof(EepromFileHeader)+size, false);
eepromWriteSourceAddr += size; eepromWriteSourceAddr += size;
eepromWriteDestinationAddr += sizeof(EepromFileHeader)+size; eepromWriteDestinationAddr += sizeof(EepromFileHeader)+size;
eepromWriteSize -= size; eepromWriteSize -= size;
@ -392,7 +397,7 @@ void eepromWriteProcess()
if (size > 0) { if (size > 0) {
memcpy(eepromWriteBuffer, eepromWriteSourceAddr, size); memcpy(eepromWriteBuffer, eepromWriteSourceAddr, size);
eepromWriteState = EEPROM_WRITING_BUFFER; eepromWriteState = EEPROM_WRITING_BUFFER;
eepromWrite(eepromWriteDestinationAddr, eepromWriteBuffer, size, false); eepromWrite(eepromWriteBuffer, eepromWriteDestinationAddr, size, false);
eepromWriteSourceAddr += size; eepromWriteSourceAddr += size;
eepromWriteDestinationAddr += size; eepromWriteDestinationAddr += size;
eepromWriteSize -= size; eepromWriteSize -= size;
@ -408,7 +413,7 @@ void eepromWriteProcess()
case EEPROM_WRITE_NEW_FAT: case EEPROM_WRITE_NEW_FAT:
eepromWriteState = EEPROM_WRITING_NEW_FAT; eepromWriteState = EEPROM_WRITING_NEW_FAT;
eepromWrite(eepromFatAddr, (uint8_t *)&eepromHeader, sizeof(eepromHeader), false); eepromWrite((uint8_t *)&eepromHeader, eepromFatAddr, sizeof(eepromHeader), false);
break; break;
case EEPROM_END_WRITE: case EEPROM_END_WRITE:
@ -427,7 +432,7 @@ uint16_t eeModelSize(uint8_t index)
if (eepromHeader.files[index+1].exists) { if (eepromHeader.files[index+1].exists) {
uint32_t address = eepromHeader.files[index+1].zoneIndex * EEPROM_ZONE_SIZE; uint32_t address = eepromHeader.files[index+1].zoneIndex * EEPROM_ZONE_SIZE;
EepromFileHeader header; EepromFileHeader header;
eepromRead(address, (uint8_t *)&header, sizeof(header)); eepromRead((uint8_t *)&header, address, sizeof(header));
result = header.size; 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); uint32_t address = eepromHeader.files[i_fileSrc+1].zoneIndex * EEPROM_ZONE_SIZE + sizeof(EepromFileHeader);
while (size > 0) { while (size > 0) {
uint16_t blockSize = min<uint16_t>(size, EEPROM_BUFFER_SIZE); 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); result = f_write(&archiveFile, eepromWriteBuffer, blockSize, &written);
if (result != FR_OK || written != blockSize) { if (result != FR_OK || written != blockSize) {
f_close(&archiveFile); f_close(&archiveFile);
@ -567,7 +572,7 @@ const pm_char * eeRestoreModel(uint8_t i_fileDst, char *model_name)
f_close(&g_oLogFile); f_close(&g_oLogFile);
return SDCARD_ERROR(result); return SDCARD_ERROR(result);
} }
eepromWrite(address, eepromWriteBuffer, blockSize+offset); eepromWrite(eepromWriteBuffer, address, blockSize+offset);
size -= blockSize; size -= blockSize;
address += EEPROM_BUFFER_SIZE; address += EEPROM_BUFFER_SIZE;
offset = 0; offset = 0;

82
radio/src/storage/eeprom_rlc.cpp
View file

@ -29,74 +29,15 @@ EeFs eeFs;
#if defined(CPUARM) #if defined(CPUARM)
blkid_t freeBlocks = 0; 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 #else
EECR |= 1<<EEMWE; uint8_t s_sync_write = false;
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();
}
}
#endif #endif
static uint8_t EeFsRead(blkid_t blk, uint8_t ofs) static uint8_t EeFsRead(blkid_t blk, uint8_t ofs)
{ {
uint8_t ret; uint8_t byte;
eepromReadBlock(&ret, (uint16_t)(blk*BS+ofs+BLOCKS_OFFSET), 1); eepromReadBlock(&byte, (size_t)(blk*BS+ofs+BLOCKS_OFFSET), 1);
return ret; return byte;
} }
static blkid_t EeFsGetLink(blkid_t blk) static blkid_t EeFsGetLink(blkid_t blk)
@ -246,10 +187,10 @@ void storageFormat()
{ {
ENABLE_SYNC_WRITE(true); 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 // write zero to the end of the new EEPROM file to set it's proper size
uint8_t dummy = 0; static uint8_t dummy = 0;
eepromWriteBlock(&dummy, EESIZE-1, 1); eepromWriteBlock(&dummy, EEPROM_SIZE-1, 1);
#endif #endif
memclear(&eeFs, sizeof(eeFs)); memclear(&eeFs, sizeof(eeFs));
@ -831,9 +772,8 @@ void RlcFile::nextRlcWriteStep()
void RlcFile::flush() void RlcFile::flush()
{ {
#if !defined(CPUARM) while (!eepromIsTransferComplete())
while (eeprom_buffer_size > 0) wdt_reset(); wdt_reset();
#endif
ENABLE_SYNC_WRITE(true); ENABLE_SYNC_WRITE(true);
@ -1008,11 +948,11 @@ void eepromBackup()
// open the file for writing... // open the file for writing...
f_open(&file, filename, FA_WRITE | FA_CREATE_ALWAYS); 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; UINT count;
eepromReadBlock(buffer, i, 1024); eepromReadBlock(buffer, i, 1024);
f_write(&file, buffer, 1024, &count); f_write(&file, buffer, 1024, &count);
updateProgressBar(i, EESIZE); updateProgressBar(i, EEPROM_SIZE);
SIMU_SLEEP(100/*ms*/); SIMU_SLEEP(100/*ms*/);
} }

32
radio/src/storage/eeprom_rlc.h
View file

@ -25,27 +25,16 @@
#if defined(PCBTARANIS) #if defined(PCBTARANIS)
#define blkid_t uint16_t #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 EEFS_VERS 5
#define MAXFILES 62 #define MAXFILES 62
#define BS 64 #define BS 64
#elif defined(CPUM2560) || defined(CPUM2561) || defined(CPUM128) #elif defined(CPUM2560) || defined(CPUM2561) || defined(CPUM128)
#define blkid_t uint8_t #define blkid_t uint8_t
#define EESIZE 4096
#define EEFS_VERS 5 #define EEFS_VERS 5
#define MAXFILES 36 #define MAXFILES 36
#define BS 16 #define BS 16
#else #else
#define blkid_t uint8_t #define blkid_t uint8_t
#define EESIZE 2048
#define EEFS_VERS 4 #define EEFS_VERS 4
#define MAXFILES 20 #define MAXFILES 20
#define BS 16 #define BS 16
@ -87,20 +76,16 @@ extern EeFs eeFs;
#if defined(CPUM64) #if defined(CPUM64)
#define FIRSTBLK (RESV/BS) #define FIRSTBLK (RESV/BS)
#define BLOCKS (EESIZE/BS) #define BLOCKS (EEPROM_SIZE/BS)
#define BLOCKS_OFFSET 0 #define BLOCKS_OFFSET 0
#else #else
#define FIRSTBLK 1 #define FIRSTBLK 1
#define BLOCKS (1+(EESIZE-RESV)/BS) #define BLOCKS (1+(EEPROM_SIZE-RESV)/BS)
#define BLOCKS_OFFSET (RESV-BS) #define BLOCKS_OFFSET (RESV-BS)
#endif #endif
uint16_t EeFsGetFree(); uint16_t EeFsGetFree();
#if !defined(CPUARM)
extern volatile int8_t eeprom_buffer_size;
#endif
class EFile class EFile
{ {
public: public:
@ -134,9 +119,14 @@ class EFile
#define ERR_FULL 1 #define ERR_FULL 1
extern uint8_t s_write_err; // error reasons extern uint8_t s_write_err; // error reasons
extern uint8_t s_sync_write; #if defined(CPUARM)
#define ENABLE_SYNC_WRITE(val) s_sync_write = val; #define ENABLE_SYNC_WRITE(val)
#define IS_SYNC_WRITE_ENABLE() s_sync_write #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 ///deliver current errno, this is reset in open
inline uint8_t write_errno() { return s_write_err; } inline uint8_t write_errno() { return s_write_err; }
@ -200,6 +190,8 @@ inline void eeFlush()
theFile.flush(); theFile.flush();
} }
void eepromWriteBlock(uint8_t * buffer, size_t address, size_t size);
inline bool eepromIsWriting() inline bool eepromIsWriting()
{ {
return theFile.isWriting(); return theFile.isWriting();

5
radio/src/targets/9x/CMakeLists.txt
View file

@ -22,5 +22,8 @@ endif()
if(PWM_BACKLIGHT) if(PWM_BACKLIGHT)
add_definitions(-DPWM_BACKLIGHT) add_definitions(-DPWM_BACKLIGHT)
endif() endif()
set(FIRMWARE_TARGET_SRC ${FIRMWARE_TARGET_SRC} lcd_driver.cpp) set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
lcd_driver.cpp
)

5
radio/src/targets/9x/board.h
View file

@ -240,9 +240,4 @@ void rotencPoll();
#define buzzerOn() PORTE |= (1 << OUT_E_BUZZER) #define buzzerOn() PORTE |= (1 << OUT_E_BUZZER)
#define buzzerOff() PORTE &= ~(1 << OUT_E_BUZZER) #define buzzerOff() PORTE &= ~(1 << OUT_E_BUZZER)
// EEPROM driver
#if !defined(SIMU)
#define eepromReadBlock(a, b, c) eeprom_read_block(a, (const void *)b, c)
#endif
#endif // _BOARD_STOCK_H_ #endif // _BOARD_STOCK_H_

24
radio/src/targets/common/arm/stm32/usbd_storage_msd.cpp
View file

@ -145,7 +145,7 @@ int8_t STORAGE_GetCapacity (uint8_t lun, uint32_t *block_num, uint32_t *block_si
#if defined(EEPROM) #if defined(EEPROM)
if (lun == STORAGE_EEPROM_LUN) { if (lun == STORAGE_EEPROM_LUN) {
*block_size = BLOCK_SIZE; *block_size = BLOCK_SIZE;
*block_num = 3 + EESIZE/BLOCK_SIZE + FLASHSIZE/BLOCK_SIZE; *block_num = 3 + EEPROM_SIZE/BLOCK_SIZE + FLASHSIZE/BLOCK_SIZE;
return 0; return 0;
} }
#endif #endif
@ -282,7 +282,7 @@ const char g_FATboot[BLOCK_SIZE] =
0x01, // Number of FATs 0x01, // Number of FATs
0x10, 0x00, // Number of root directory entries 0x10, 0x00, // Number of root directory entries
3+(EESIZE/BLOCK_SIZE), (FLASHSIZE/BLOCK_SIZE)>>8, // Total sectors 3+(EEPROM_SIZE/BLOCK_SIZE), (FLASHSIZE/BLOCK_SIZE)>>8, // Total sectors
0xf8, // Media descriptor 0xf8, // Media descriptor
0x01, 0x00, // Sectors per FAT table 0x01, 0x00, // Sectors per FAT table
0x20, 0x00, // Sectors per track 0x20, 0x00, // Sectors per track
@ -462,7 +462,7 @@ const FATDirEntry_t g_DIRroot[16] =
0xA302, 0xA302,
0x3D55, 0x3D55,
0x0002, 0x0002,
EESIZE EEPROM_SIZE
}, },
{ {
{ 'F', 'I', 'R', 'M', 'W', 'A', 'R', 'E'}, { 'F', 'I', 'R', 'M', 'W', 'A', 'R', 'E'},
@ -476,7 +476,7 @@ const FATDirEntry_t g_DIRroot[16] =
0x0000, 0x0000,
0xA302, 0xA302,
0x3D55, 0x3D55,
0x0002 + (EESIZE/BLOCK_SIZE)/8, 0x0002 + (EEPROM_SIZE/BLOCK_SIZE)/8,
FLASHSIZE FLASHSIZE
}, },
{ {
@ -690,12 +690,12 @@ int32_t fat12Read(uint8_t * buffer, uint16_t sector, uint16_t count)
else if (sector == 2) { else if (sector == 2) {
memcpy(buffer, g_DIRroot, BLOCK_SIZE ) ; memcpy(buffer, g_DIRroot, BLOCK_SIZE ) ;
} }
else if (sector < 3 + (EESIZE/BLOCK_SIZE)) { else if (sector < 3 + (EEPROM_SIZE/BLOCK_SIZE)) {
eepromReadBlock(buffer, (sector-3)*BLOCK_SIZE, BLOCK_SIZE); eepromReadBlock(buffer, (sector-3)*BLOCK_SIZE, BLOCK_SIZE);
} }
else if (sector < 3 + (EESIZE/BLOCK_SIZE) + (FLASHSIZE/BLOCK_SIZE)) { else if (sector < 3 + (EEPROM_SIZE/BLOCK_SIZE) + (FLASHSIZE/BLOCK_SIZE)) {
uint32_t address; uint32_t address;
address = sector - 3 - (EESIZE/BLOCK_SIZE); address = sector - 3 - (EEPROM_SIZE/BLOCK_SIZE);
address *= BLOCK_SIZE; address *= BLOCK_SIZE;
address += FIRMWARE_ADDRESS; address += FIRMWARE_ADDRESS;
memcpy(buffer, (uint8_t *)address, BLOCK_SIZE); memcpy(buffer, (uint8_t *)address, BLOCK_SIZE);
@ -722,7 +722,7 @@ int32_t fat12Write(const uint8_t * buffer, uint16_t sector, uint16_t count)
if (sector < 3) { if (sector < 3) {
// reserved, read-only // reserved, read-only
} }
else if (sector < 3 + (EESIZE/BLOCK_SIZE)) { else if (sector < 3 + (EEPROM_SIZE/BLOCK_SIZE)) {
// eeprom // eeprom
while (count) { while (count) {
if (operation == FATWRITE_NONE && isEepromStart(buffer)) { if (operation == FATWRITE_NONE && isEepromStart(buffer)) {
@ -735,16 +735,16 @@ int32_t fat12Write(const uint8_t * buffer, uint16_t sector, uint16_t count)
buffer += BLOCK_SIZE; buffer += BLOCK_SIZE;
sector++; sector++;
count--; count--;
if (sector-3 >= (EESIZE/BLOCK_SIZE)) { if (sector-3 >= (EEPROM_SIZE/BLOCK_SIZE)) {
TRACE("EEPROM end written at sector %d", sector-1); TRACE("EEPROM end written at sector %d", sector-1);
operation = FATWRITE_NONE; operation = FATWRITE_NONE;
} }
} }
} }
else if (sector < 3 + (EESIZE/BLOCK_SIZE) + (FLASHSIZE/BLOCK_SIZE)) { else if (sector < 3 + (EEPROM_SIZE/BLOCK_SIZE) + (FLASHSIZE/BLOCK_SIZE)) {
// firmware // firmware
uint32_t address; uint32_t address;
address = sector - 3 - (EESIZE/BLOCK_SIZE); address = sector - 3 - (EEPROM_SIZE/BLOCK_SIZE);
address *= BLOCK_SIZE; address *= BLOCK_SIZE;
address += FIRMWARE_ADDRESS; address += FIRMWARE_ADDRESS;
while (count) { while (count) {
@ -763,7 +763,7 @@ int32_t fat12Write(const uint8_t * buffer, uint16_t sector, uint16_t count)
} }
sector++; sector++;
count--; count--;
if (sector-3-(EESIZE/BLOCK_SIZE) >= (FLASHSIZE/BLOCK_SIZE)) { if (sector-3-(EEPROM_SIZE/BLOCK_SIZE) >= (FLASHSIZE/BLOCK_SIZE)) {
TRACE("FIRMWARE end written at sector %d", sector-1); TRACE("FIRMWARE end written at sector %d", sector-1);
operation = FATWRITE_NONE; operation = FATWRITE_NONE;
} }

11
radio/src/targets/common/avr/CMakeLists.txt
View file

@ -11,7 +11,11 @@ set(DSM2 "NO" CACHE STRING "LCD type (NO/PPM/SERIAL)")
set(LUA NO) set(LUA NO)
set(PULSES_SRC pulses_avr.cpp) set(PULSES_SRC pulses_avr.cpp)
set(SRC ${SRC} main_avr.cpp) set(SRC ${SRC} main_avr.cpp)
set(FIRMWARE_SRC ${FIRMWARE_SRC} targets/common/avr/adc_driver.cpp) set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/avr/adc_driver.cpp
targets/common/avr/eeprom_driver.cpp
)
add_definitions(-DLCD_${LCD}) add_definitions(-DLCD_${LCD})
if(DSM2) if(DSM2)
add_definitions(-DDSM2 -DDSM2_${DSM2}) add_definitions(-DDSM2 -DDSM2_${DSM2})
@ -86,7 +90,10 @@ if(TELEMETRY STREQUAL FRSKY OR TELEMETRY STREQUAL FRSKY_SPORT OR TELEMETRY STREQ
option(VARIO "Vario support" ON) option(VARIO "Vario support" ON)
add_definitions(-DTELEMETRY_FRSKY) add_definitions(-DTELEMETRY_FRSKY)
set(SRC ${SRC} telemetry/telemetry.cpp telemetry/telemetry_holders.cpp telemetry/frsky.cpp telemetry/frsky_d.cpp) set(SRC ${SRC} telemetry/telemetry.cpp telemetry/telemetry_holders.cpp telemetry/frsky.cpp telemetry/frsky_d.cpp)
set(FIRMWARE_SRC ${FIRMWARE_SRC} targets/common/avr/telemetry_driver.cpp) set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/avr/telemetry_driver.cpp
)
set(GUI_SRC ${GUI_SRC} view_telemetry.cpp) set(GUI_SRC ${GUI_SRC} view_telemetry.cpp)
if(FRSKY_HUB) if(FRSKY_HUB)
add_definitions(-DFRSKY_HUB) add_definitions(-DFRSKY_HUB)

13
radio/src/targets/common/avr/board_avr.h
View file

@ -117,6 +117,19 @@ void lcdRefreshSide();
uint8_t lcdRefresh_ST7920(uint8_t full); uint8_t lcdRefresh_ST7920(uint8_t full);
#endif #endif
// EEPROM driver
#if defined(CPUM2560) || defined(CPUM2561) || defined(CPUM128)
#define EEPROM_SIZE 4096
#else
#define EEPROM_SIZE 2048
#endif
#if defined(SIMU)
void eepromReadBlock(uint8_t * buffer, size_t address, size_t size);
#else
#define eepromReadBlock(buffer, address, size) eeprom_read_block(buffer, (const void *)address, size)
#endif
uint8_t eepromIsTransferComplete();
// USART driver (static register dispatcher) // USART driver (static register dispatcher)
#define RXD_DDR1 DDRD #define RXD_DDR1 DDRD
#define RXD_DDR_PIN1 DDD2 #define RXD_DDR_PIN1 DDD2

87
radio/src/targets/common/avr/eeprom_driver.cpp Normal file
View file

@ -0,0 +1,87 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
uint16_t eeprom_pointer;
uint8_t * eeprom_buffer_data;
volatile int8_t eeprom_buffer_size = 0;
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
}
}
void eepromStartWrite(uint8_t * buffer, size_t address, size_t size)
{
assert(eeprom_buffer_size == 0);
eeprom_pointer = address;
eeprom_buffer_data = buffer;
eeprom_buffer_size = size+1;
#if defined (CPUM2560) || defined(CPUM2561)
EECR |= (1<<EERIE);
#else
EECR |= (1<<EERIE);
#endif
}
uint8_t eepromIsTransferComplete()
{
return eeprom_buffer_size == 0;
}
extern uint8_t s_sync_write;
void eepromWriteBlock(uint8_t * buffer, size_t address, size_t size)
{
eepromStartWrite(buffer, address, size);
if (s_sync_write) {
while (!eepromIsTransferComplete()) {
wdt_reset();
}
}
}

2
radio/src/targets/gruvin9x/board.cpp
View file

@ -175,7 +175,7 @@ uint8_t keyState(uint8_t index)
uint8_t switchState(uint8_t index) uint8_t switchState(uint8_t index)
{ {
uint8_t result; uint8_t result = 0;
switch (index) { switch (index) {
case SW_ELE: case SW_ELE:

5
radio/src/targets/gruvin9x/board.h
View file

@ -168,9 +168,4 @@ void pwrOff();
#define buzzerOn() PORTE |= (1 << OUT_E_BUZZER) #define buzzerOn() PORTE |= (1 << OUT_E_BUZZER)
#define buzzerOff() PORTE &= ~(1 << OUT_E_BUZZER) #define buzzerOff() PORTE &= ~(1 << OUT_E_BUZZER)
// EEPROM driver
#if !defined(SIMU)
#define eepromReadBlock(a, b, c) eeprom_read_block(a, (const void *)b, c)
#endif
#endif // _BOARD_GRUVIN9X_H_ #endif // _BOARD_GRUVIN9X_H_

5
radio/src/targets/mega2560/board.h
View file

@ -188,9 +188,4 @@ void pwrOff();
#define WTV20SD_CLK (PING & 0x20) #define WTV20SD_CLK (PING & 0x20)
#endif #endif
// EEPROM driver
#if !defined(SIMU)
#define eepromReadBlock(a, b, c) eeprom_read_block(a, (const void *)b, c)
#endif
#endif // _BOARD_MEGA2560_H_ #endif // _BOARD_MEGA2560_H_

6
radio/src/targets/simu/CMakeLists.txt
View file

@ -2,7 +2,11 @@ foreach(FILE ${SRC})
set(SIMU_SRC ${SIMU_SRC} ../../${FILE}) set(SIMU_SRC ${SIMU_SRC} ../../${FILE})
endforeach() endforeach()
set(SIMU_SRC ${SIMU_SRC} simpgmspace.cpp) set(SIMU_SRC
${SIMU_SRC}
simpgmspace.cpp
simueeprom.cpp
)
add_definitions(-DSIMU) add_definitions(-DSIMU)
remove_definitions(-DCLI) remove_definitions(-DCLI)

4
radio/src/targets/simu/opentxsimulator.cpp
View file

@ -90,7 +90,9 @@ bool OpenTxSimulator::lcdChanged(bool & lightEnable)
void OpenTxSimulator::start(QByteArray & ee, bool tests) void OpenTxSimulator::start(QByteArray & ee, bool tests)
{ {
memcpy(eeprom, ee.data(), std::min<int>(EESIZE_SIMU, ee.size())); #if defined(EEPROM_SIZE)
memcpy(eeprom, ee.data(), std::min<int>(EEPROM_SIZE, ee.size()));
#endif
start((const char *)0, tests); start((const char *)0, tests);
} }

205
radio/src/targets/simu/simpgmspace.cpp
View file

@ -43,8 +43,6 @@ uint8_t MCUCSR, MCUSR, MCUCR;
volatile uint8_t pina=0xff, pinb=0xff, pinc=0xff, pind, pine=0xff, pinf=0xff, ping=0xff, pinh=0xff, pinj=0, pinl=0; volatile uint8_t pina=0xff, pinb=0xff, pinc=0xff, pind, pine=0xff, pinf=0xff, ping=0xff, pinh=0xff, pinj=0, pinl=0;
uint8_t portb, portc, porth=0, dummyport; uint8_t portb, portc, porth=0, dummyport;
uint16_t dummyport16; uint16_t dummyport16;
const char *eepromFile = NULL;
FILE *fp = NULL;
int g_snapshot_idx = 0; int g_snapshot_idx = 0;
#if !defined(CPUARM) #if !defined(CPUARM)
@ -73,23 +71,10 @@ Dacc dacc;
Adc Adc0; Adc Adc0;
#endif #endif
#if defined(EEPROM_RLC)
extern uint16_t eeprom_pointer;
extern uint8_t * eeprom_buffer_data;
#else
uint32_t eeprom_pointer;
uint8_t * eeprom_buffer_data;
volatile int32_t eeprom_buffer_size;
bool eeprom_read_operation;
#endif
#if defined(SDCARD) && !defined(SKIP_FATFS_DECLARATION) #if defined(SDCARD) && !defined(SKIP_FATFS_DECLARATION)
char simuSdDirectory[1024] = ""; char simuSdDirectory[1024] = "";
#endif #endif
uint8_t eeprom[EESIZE_SIMU];
sem_t *eeprom_write_sem;
void lcdInit() void lcdInit()
{ {
} }
@ -311,76 +296,6 @@ void simuSetSwitch(uint8_t swtch, int8_t state)
} }
} }
#if defined(EEPROM_RAW)
uint8_t Spi_complete = 1;
void * eeprom_write_function(void *)
{
while (!sem_wait(eeprom_write_sem)) {
if (!eeprom_thread_running)
return NULL;
if (eeprom_read_operation) {
assert(eeprom_buffer_size);
eepromReadBlock(eeprom_buffer_data, eeprom_pointer, eeprom_buffer_size);
}
else {
if (fp) {
if (fseek(fp, eeprom_pointer, SEEK_SET) == -1)
perror("error in fseek");
}
while (--eeprom_buffer_size) {
assert(eeprom_buffer_size > 0);
if (fp) {
if (fwrite(eeprom_buffer_data, 1, 1, fp) != 1)
perror("error in fwrite");
}
else {
memcpy(&eeprom[eeprom_pointer], eeprom_buffer_data, 1);
}
eeprom_pointer++;
eeprom_buffer_data++;
if (fp && eeprom_buffer_size == 1) {
fflush(fp);
}
}
}
Spi_complete = 1;
}
return 0;
}
#elif !defined(PCBTARANIS) && !defined(PCBHORUS)
bool eeprom_thread_running = true;
void * eeprom_write_function(void *)
{
while (!sem_wait(eeprom_write_sem)) {
if (!eeprom_thread_running)
return NULL;
if (fp) {
if (fseek(fp, eeprom_pointer, SEEK_SET) == -1)
perror("error in fseek");
}
while (--eeprom_buffer_size) {
assert(eeprom_buffer_size > 0);
if (fp) {
if (fwrite(eeprom_buffer_data, 1, 1, fp) != 1)
perror("error in fwrite");
sleep(5/*ms*/);
}
else {
memcpy(&eeprom[eeprom_pointer], eeprom_buffer_data, 1);
}
eeprom_pointer++;
eeprom_buffer_data++;
if (fp && eeprom_buffer_size == 1) {
fflush(fp);
}
}
}
return 0;
}
#endif
void StartSimu(bool tests) void StartSimu(bool tests)
{ {
s_current_protocol[0] = 255; s_current_protocol[0] = 255;
@ -484,7 +399,6 @@ int32_t getVolume()
#endif #endif
#if defined(SIMU_AUDIO) && defined(CPUARM) #if defined(SIMU_AUDIO) && defined(CPUARM)
void copyBuffer(uint8_t * dest, uint16_t * buff, unsigned int samples) void copyBuffer(uint8_t * dest, uint16_t * buff, unsigned int samples)
{ {
for(unsigned int i=0; i<samples; i++) { for(unsigned int i=0; i<samples; i++) {
@ -602,94 +516,11 @@ void StopAudioThread()
} }
#endif // #if defined(SIMU_AUDIO) && defined(CPUARM) #endif // #if defined(SIMU_AUDIO) && defined(CPUARM)
pthread_t eeprom_thread_pid;
void StartEepromThread(const char *filename)
{
eepromFile = filename;
if (eepromFile) {
fp = fopen(eepromFile, "rb+");
if (!fp)
fp = fopen(eepromFile, "wb+");
if (!fp) perror("error in fopen");
}
#ifdef __APPLE__
eeprom_write_sem = sem_open("eepromsem", O_CREAT, S_IRUSR | S_IWUSR, 0);
#else
eeprom_write_sem = (sem_t *)malloc(sizeof(sem_t));
sem_init(eeprom_write_sem, 0, 0);
#endif
#if !defined(PCBTARANIS) && !defined(PCBHORUS)
eeprom_thread_running = true;
assert(!pthread_create(&eeprom_thread_pid, NULL, &eeprom_write_function, NULL));
#endif
}
void StopEepromThread()
{
#if !defined(PCBTARANIS) && !defined(PCBFLAMENCO) && !defined(PCBHORUS)
eeprom_thread_running = false;
sem_post(eeprom_write_sem);
pthread_join(eeprom_thread_pid, NULL);
#endif
#ifdef __APPLE__
//TODO free semaphore eeprom_write_sem
#else
sem_destroy(eeprom_write_sem);
free(eeprom_write_sem);
#endif
if (fp) fclose(fp);
}
void eepromReadBlock (uint8_t * pointer_ram, uint32_t pointer_eeprom, uint32_t size)
{
assert(size);
if (fp) {
// TRACE("EEPROM read (pos=%d, size=%d)", pointer_eeprom, size);
if (fseek(fp, (long)pointer_eeprom, SEEK_SET)==-1) perror("error in fseek");
if (fread(pointer_ram, size, 1, fp) <= 0) perror("error in fread");
}
else {
memcpy(pointer_ram, &eeprom[(uint64_t)pointer_eeprom], size);
}
}
#if defined(PCBTARANIS) || defined(PCBFLAMENCO)
void eepromWriteBlock(uint8_t * pointer_ram, uint32_t pointer_eeprom, uint32_t size)
{
assert(size);
if (fp) {
// TRACE("EEPROM write (pos=%d, size=%d)", pointer_eeprom, size);
if (fseek(fp, (long)pointer_eeprom, SEEK_SET)==-1) perror("error in fseek");
if (fwrite(pointer_ram, size, 1, fp) <= 0) perror("error in fwrite");
}
else {
memcpy(&eeprom[(uint64_t)pointer_eeprom], pointer_ram, size);
}
}
#endif
uint16_t stackAvailable() uint16_t stackAvailable()
{ {
return 500; return 500;
} }
#if 0
static void EeFsDump(){
for(int i=0; i<EESIZE; i++)
{
printf("%02x ",eeprom[i]);
if(i%16 == 15) puts("");
}
puts("");
}
#endif
#if defined(SDCARD) && !defined(SKIP_FATFS_DECLARATION) && !defined(SIMU_DISKIO) #if defined(SDCARD) && !defined(SKIP_FATFS_DECLARATION) && !defined(SIMU_DISKIO)
namespace simu { namespace simu {
#include <dirent.h> #include <dirent.h>
@ -1438,39 +1269,3 @@ OS_TID CoCreateTask(FUNCPtr task, void *argv, uint32_t parameter, void * stk, ui
pthread_create(&tid, NULL, start_routine, (void *)task); pthread_create(&tid, NULL, start_routine, (void *)task);
return tid; return tid;
} }
#if defined(EEPROM_RAW)
void eepromBlockErase(uint32_t address)
{
static uint8_t erasedBlock[EEPROM_BLOCK_SIZE]; // can't be on the stack!
memset(erasedBlock, 0xff, sizeof(erasedBlock));
eeprom_pointer = address;
eeprom_buffer_data = erasedBlock;
eeprom_buffer_size = EEPROM_BLOCK_SIZE;
eeprom_read_operation = false;
Spi_complete = false;
sem_post(eeprom_write_sem);
}
void eepromReadArray(uint32_t address, uint8_t * buffer, uint32_t size)
{
assert(size);
eeprom_pointer = address;
eeprom_buffer_data = buffer;
eeprom_buffer_size = size;
eeprom_read_operation = true;
Spi_complete = false;
sem_post(eeprom_write_sem);
}
void eepromByteProgram(uint32_t address, uint8_t * buffer, uint32_t size)
{
assert(size);
eeprom_pointer = address;
eeprom_buffer_data = buffer;
eeprom_buffer_size = size + 1;
eeprom_read_operation = false;
Spi_complete = false;
sem_post(eeprom_write_sem);
}
#endif

25
radio/src/targets/simu/simpgmspace.h
View file

@ -199,13 +199,10 @@ extern Pwm pwm;
#define PWM (&pwm) #define PWM (&pwm)
#endif #endif
extern sem_t *eeprom_write_sem; #if defined(EEPROM_SIZE)
extern uint8_t eeprom[EEPROM_SIZE];
#if !defined(EEPROM_RLC) #else
extern uint32_t eeprom_pointer; extern uint8_t * eeprom;
extern uint8_t * eeprom_buffer_data;
extern volatile int32_t eeprom_buffer_size;
extern bool eeprom_read_operation;
#endif #endif
#if defined(CPUARM) #if defined(CPUARM)
@ -387,16 +384,6 @@ void StopEepromThread();
#define StopAudioThread() #define StopAudioThread()
#endif #endif
#if !defined(EEPROM_RLC)
#define EESIZE_SIMU (128*4096)
#else
#define EESIZE_SIMU EESIZE
#endif
extern uint8_t eeprom[];
extern const char * eepromFile;
void eepromReadBlock (uint8_t * pointer_ram, uint32_t address, uint32_t size);
#if !defined(CPUARM) #if !defined(CPUARM)
#define wdt_disable(...) sleep(1/*ms*/) #define wdt_disable(...) sleep(1/*ms*/)
#define wdt_enable(...) sleep(1/*ms*/) #define wdt_enable(...) sleep(1/*ms*/)
@ -490,8 +477,4 @@ extern char simuSdDirectory[1024];
#define sdMounted() (true) #define sdMounted() (true)
#endif #endif
void eepromBlockErase(uint32_t address);
void eepromReadArray(uint32_t address, uint8_t * buffer, uint32_t size);
void eepromByteProgram(uint32_t address, uint8_t * buffer, uint32_t size);
#endif // _SIMPGMSPACE_H_ #endif // _SIMPGMSPACE_H_

178
radio/src/targets/simu/simueeprom.cpp Normal file
View file

@ -0,0 +1,178 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
const char * eepromFile = NULL;
FILE * fp = NULL;
uint32_t eeprom_pointer;
uint8_t * eeprom_buffer_data;
volatile int32_t eeprom_buffer_size;
bool eeprom_read_operation;
bool eeprom_thread_running = true;
#if defined(EEPROM_SIZE)
uint8_t eeprom[EEPROM_SIZE];
#else
uint8_t * eeprom = NULL;
#endif
sem_t * eeprom_write_sem;
void eepromReadBlock (uint8_t * buffer, size_t address, size_t size)
{
assert(size);
if (fp) {
// TRACE("EEPROM read (pos=%d, size=%d)", pointer_eeprom, size);
if (fseek(fp, address, SEEK_SET) < 0)
perror("error in fseek");
if (fread(buffer, size, 1, fp) <= 0)
perror("error in fread");
}
else {
memcpy(buffer, &eeprom[address], size);
}
}
void eepromSimuWriteBlock(uint8_t * buffer, size_t address, size_t size)
{
assert(size);
if (fp) {
// TRACE("EEPROM write (pos=%d, size=%d)", pointer_eeprom, size);
if (fseek(fp, address, SEEK_SET) < 0)
perror("error in fseek");
if (fwrite(buffer, size, 1, fp) <= 0)
perror("error in fwrite");
}
else {
memcpy(&eeprom[address], buffer, size);
}
}
volatile uint8_t eepromTransferComplete = 1;
void * eeprom_thread_function(void *)
{
while (!sem_wait(eeprom_write_sem)) {
if (!eeprom_thread_running)
return NULL;
assert(eeprom_buffer_size);
if (eeprom_read_operation) {
eepromReadBlock(eeprom_buffer_data, eeprom_pointer, eeprom_buffer_size);
}
else {
eepromSimuWriteBlock(eeprom_buffer_data, eeprom_pointer, eeprom_buffer_size);
}
eepromTransferComplete = 1;
}
return 0;
}
uint8_t eepromReadStatus()
{
return 1;
}
uint8_t eepromIsTransferComplete()
{
return eepromTransferComplete;
}
void eepromTransmitData(uint32_t address, uint8_t * buffer, uint32_t size, bool read)
{
eeprom_pointer = address;
eeprom_buffer_data = buffer;
eeprom_buffer_size = size;
eeprom_read_operation = read;
eepromTransferComplete = 0;
sem_post(eeprom_write_sem);
}
#if defined(EEPROM_BLOCK_SIZE)
void eepromBlockErase(uint32_t address)
{
static uint8_t erasedBlock[EEPROM_BLOCK_SIZE]; // can't be on the stack!
memset(erasedBlock, 0xff, sizeof(erasedBlock));
eepromTransmitData(address, erasedBlock, EEPROM_BLOCK_SIZE, false);
}
#endif
void eepromStartRead(uint8_t * buffer, size_t address, size_t size)
{
assert(size);
eepromTransmitData(address, buffer, size, true);
}
void eepromStartWrite(uint8_t * buffer, size_t address, size_t size)
{
assert(size);
eepromTransmitData(address, buffer, size, false);
}
void eepromWriteBlock(uint8_t * buffer, size_t address, size_t size)
{
eepromStartWrite(buffer, address, size);
while (!eepromIsTransferComplete()) {
sleep(1/*ms*/);
}
}
pthread_t eeprom_thread_pid;
void StartEepromThread(const char * filename)
{
eepromFile = filename;
if (eepromFile) {
fp = fopen(eepromFile, "rb+");
if (!fp)
fp = fopen(eepromFile, "wb+");
if (!fp)
perror("error in fopen");
}
#ifdef __APPLE__
eeprom_write_sem = sem_open("eepromsem", O_CREAT, S_IRUSR | S_IWUSR, 0);
#else
eeprom_write_sem = (sem_t *)malloc(sizeof(sem_t));
sem_init(eeprom_write_sem, 0, 0);
#endif
eeprom_thread_running = true;
assert(!pthread_create(&eeprom_thread_pid, NULL, &eeprom_thread_function, NULL));
}
void StopEepromThread()
{
eeprom_thread_running = false;
sem_post(eeprom_write_sem);
pthread_join(eeprom_thread_pid, NULL);
#ifdef __APPLE__
sem_close(eeprom_write_sem);
#else
sem_destroy(eeprom_write_sem);
free(eeprom_write_sem);
#endif
if (fp) fclose(fp);
}

66
radio/src/targets/sky9x/CMakeLists.txt
View file

@ -1,5 +1,13 @@
set(ARCH ARM) set(ARCH ARM)
set(LUA NO) set(LUA NO)
set(MCU cortex-m3)
set(SDCARD YES)
set(HAPTIC YES)
set(EEPROM EEPROM_RAW)
set(GUI_DIR 128x64)
set(TARGET_DIR sky9x)
set(FIRMWARE_DEPENDENCIES ${FIRMWARE_DEPENDENCIES} 9x_bitmaps)
if(PCB STREQUAL 9XRPRO) if(PCB STREQUAL 9XRPRO)
add_definitions(-Dat91sam3s8 -DREVX) add_definitions(-Dat91sam3s8 -DREVX)
set(FLAVOUR 9xrpro) set(FLAVOUR 9xrpro)
@ -32,14 +40,6 @@ else()
endif() endif()
endif() endif()
set(MCU cortex-m3)
set(SDCARD YES)
set(HAPTIC YES)
set(EEPROM EEPROM_RAW)
set(GUI_DIR 128x64)
set(TARGET_DIR sky9x)
set(FIRMWARE_DEPENDENCIES ${FIRMWARE_DEPENDENCIES} 9x_bitmaps)
add_definitions(-DPCBSKY9X -DPPM_PIN_SERIAL) add_definitions(-DPCBSKY9X -DPPM_PIN_SERIAL)
add_definitions(-DAUDIO -DVOICE -DRTCLOCK -DVARIO) add_definitions(-DAUDIO -DVOICE -DRTCLOCK -DVARIO)
add_definitions(-DEEPROM_VARIANT=0) add_definitions(-DEEPROM_VARIANT=0)
@ -57,15 +57,32 @@ set(GUI_SRC
view_about.cpp view_about.cpp
) )
set(FIRMWARE_TARGET_SRC ${FIRMWARE_TARGET_SRC} core_cm3.c board_lowlevel.c crt.c vectors_sam3s.c) set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
set(FIRMWARE_TARGET_SRC ${FIRMWARE_TARGET_SRC} lcd_driver.cpp pwr_driver.cpp core_cm3.c
usb/device/core/USBD_UDP.c usb/device/core/USBDDriver.c board_lowlevel.c
usb/device/massstorage/MSDDriver.c usb/device/massstorage/MSDDStateMachine.c usb/device/massstorage/MSDLun.c crt.c
usb/device/massstorage/MSDDriverDescriptors.c usb/device/massstorage/SBCMethods.c usb/common/core/USBEndpointDescriptor.c vectors_sam3s.c
usb/common/core/USBGenericRequest.c usb/common/core/USBFeatureRequest.c usb/common/core/USBInterfaceRequest.c eeprom_driver.cpp
usb/common/core/USBGetDescriptorRequest.c usb/common/core/USBSetAddressRequest.c usb/common/core/USBSetConfigurationRequest.c lcd_driver.cpp
usb/common/core/USBConfigurationDescriptor.c usb/common/core/USBGenericDescriptor.c MEDSdcard.c pwr_driver.cpp
usb/device/core/USBD_UDP.c
usb/device/core/USBDDriver.c
usb/device/massstorage/MSDDriver.c
usb/device/massstorage/MSDDStateMachine.c
usb/device/massstorage/MSDLun.c
usb/device/massstorage/MSDDriverDescriptors.c
usb/device/massstorage/SBCMethods.c
usb/common/core/USBEndpointDescriptor.c
usb/common/core/USBGenericRequest.c
usb/common/core/USBFeatureRequest.c
usb/common/core/USBInterfaceRequest.c
usb/common/core/USBGetDescriptorRequest.c
usb/common/core/USBSetAddressRequest.c
usb/common/core/USBSetConfigurationRequest.c
usb/common/core/USBConfigurationDescriptor.c
usb/common/core/USBGenericDescriptor.c
MEDSdcard.c
) )
set(TARGET_SRC set(TARGET_SRC
@ -73,7 +90,6 @@ set(TARGET_SRC
board.cpp board.cpp
telemetry_driver.cpp telemetry_driver.cpp
adc_driver.cpp adc_driver.cpp
eeprom_driver.cpp
pulses_driver.cpp pulses_driver.cpp
keys_driver.cpp keys_driver.cpp
audio_driver.cpp audio_driver.cpp
@ -81,8 +97,16 @@ set(TARGET_SRC
haptic_driver.cpp haptic_driver.cpp
sdcard_driver.cpp sdcard_driver.cpp
massstorage.cpp massstorage.cpp
) )
set(FIRMWARE_SRC
${FIRMWARE_SRC}
loadboot.cpp
)
set(SRC
${SRC}
debug.cpp
)
set(SERIAL2_DRIVER serial2_driver.cpp) set(SERIAL2_DRIVER serial2_driver.cpp)
set(SRC ${SRC} debug.cpp)
set(FIRMWARE_SRC ${FIRMWARE_SRC} loadboot.cpp)

10
radio/src/targets/sky9x/board.h
View file

@ -353,13 +353,11 @@ uint32_t pwroffPressed();
#define EEPROM_SIZE (4*1024*1024/8) #define EEPROM_SIZE (4*1024*1024/8)
#define EEPROM_BLOCK_SIZE (4*1024) #define EEPROM_BLOCK_SIZE (4*1024)
void eepromInit(); void eepromInit();
uint32_t eepromReadStatus(); uint8_t eepromReadStatus();
uint8_t eepromIsSpiComplete(void); uint8_t eepromIsTransferComplete(void);
void eepromWaitSpiComplete(void);
void eepromWriteEnable();
void eepromBlockErase(uint32_t address); void eepromBlockErase(uint32_t address);
void eepromReadArray(uint32_t address, uint8_t * buffer, uint32_t size); void eepromStartRead(uint8_t * buffer, size_t address, size_t size);
void eepromByteProgram(uint32_t address, uint8_t * buffer, uint32_t size); void eepromStartWrite(uint8_t * buffer, size_t address, size_t size);
// Rotary Encoder driver // Rotary Encoder driver
void rotencInit(); void rotencInit();

75
radio/src/targets/sky9x/eeprom_driver.cpp
View file

@ -20,39 +20,26 @@
#include "opentx.h" #include "opentx.h"
volatile uint8_t Spi_complete; volatile uint8_t Spi_complete = 1;
uint8_t Spi_tx_buf[24]; uint8_t Spi_tx_buf[24];
uint8_t eepromIsSpiComplete() uint8_t eepromIsTransferComplete()
{ {
return Spi_complete; return Spi_complete;
} }
void eepromWaitSpiComplete()
{
while (!Spi_complete) {
SIMU_SLEEP(5/*ms*/);
}
Spi_complete = false;
}
uint32_t eepromTransmitData(register uint8_t *command, register uint8_t *tx, register uint8_t *rx, register uint32_t comlen, register uint32_t count) uint32_t eepromTransmitData(register uint8_t *command, register uint8_t *tx, register uint8_t *rx, register uint32_t comlen, register uint32_t count)
{ {
#ifndef SIMU register Spi * spiptr = SPI;
register Spi *spiptr;
register uint32_t condition; register uint32_t condition;
static uint8_t discard_rx_command[4]; static uint8_t discard_rx_command[4];
// PMC->PMC_PCER0 |= 0x00200000L; // Enable peripheral clock to SPI
Spi_complete = 0;
if (comlen > 4) { if (comlen > 4) {
Spi_complete = 1;
return 0x4FFFF; return 0x4FFFF;
} }
Spi_complete = 0;
condition = SPI_SR_TXEMPTY; condition = SPI_SR_TXEMPTY;
spiptr = SPI;
spiptr->SPI_CR = 1; // Enable spiptr->SPI_CR = 1; // Enable
(void) spiptr->SPI_RDR; // Dump any rx data (void) spiptr->SPI_RDR; // Dump any rx data
(void) spiptr->SPI_SR; // Clear error flags (void) spiptr->SPI_SR; // Clear error flags
@ -84,21 +71,14 @@ uint32_t eepromTransmitData(register uint8_t *command, register uint8_t *tx, reg
} }
spiptr->SPI_IER = condition; spiptr->SPI_IER = condition;
#endif
return 0; return 0;
} }
uint8_t eepromTransmitByte(uint8_t out, bool skipFirst) uint8_t eepromTransmitByte(uint8_t out, bool skipFirst)
{ {
register Spi *spiptr; register Spi * spiptr = SPI;
register uint32_t delay; register uint32_t delay;
#if defined(SIMU)
return 0;
#endif
spiptr = SPI;
spiptr->SPI_CR = 1; // Enable spiptr->SPI_CR = 1; // Enable
(void) spiptr->SPI_RDR; // Dump any rx data (void) spiptr->SPI_RDR; // Dump any rx data
@ -146,9 +126,10 @@ void eepromPrepareCommand(EepromCommand command, uint32_t address)
*(p+3) = address; *(p+3) = address;
} }
uint32_t eepromReadStatus() uint8_t eepromReadStatus()
{ {
return eepromTransmitByte(COMMAND_READ_STATUS, true); uint8_t read_status = eepromTransmitByte(COMMAND_READ_STATUS, true);
return !(read_status & 1);
} }
void eepromWriteStatusRegister() void eepromWriteStatusRegister()
@ -156,25 +137,27 @@ void eepromWriteStatusRegister()
eepromTransmitByte(COMMAND_WRITE_STATUS_REGISTER, true); eepromTransmitByte(COMMAND_WRITE_STATUS_REGISTER, true);
} }
void eepromByteProgram(uint32_t address, uint8_t * buffer, uint32_t size)
{
eepromPrepareCommand(COMMAND_BYTE_PROGRAM, address);
eepromTransmitData(Spi_tx_buf, buffer, 0, 4, size);
}
void eepromReadArray(uint32_t address, uint8_t * buffer, uint32_t size)
{
eepromPrepareCommand(COMMAND_READ_ARRAY, address);
eepromTransmitData(Spi_tx_buf, 0, buffer, 4, size);
}
void eepromWriteEnable() void eepromWriteEnable()
{ {
eepromTransmitByte(COMMAND_WRITE_ENABLE, false); eepromTransmitByte(COMMAND_WRITE_ENABLE, false);
} }
void eepromStartWrite(uint8_t * buffer, size_t address, size_t size)
{
eepromWriteEnable();
eepromPrepareCommand(COMMAND_BYTE_PROGRAM, address);
eepromTransmitData(Spi_tx_buf, buffer, 0, 4, size);
}
void eepromStartRead(uint8_t * buffer, size_t address, size_t size)
{
eepromPrepareCommand(COMMAND_READ_ARRAY, address);
eepromTransmitData(Spi_tx_buf, 0, buffer, 4, size);
}
void eepromBlockErase(uint32_t address) void eepromBlockErase(uint32_t address)
{ {
eepromWriteEnable();
eepromPrepareCommand(COMMAND_BLOCK_ERASE, address); eepromPrepareCommand(COMMAND_BLOCK_ERASE, address);
eepromTransmitData(Spi_tx_buf, 0, 0, 4, 0); eepromTransmitData(Spi_tx_buf, 0, 0, 4, 0);
} }
@ -189,14 +172,13 @@ void eepromBlockErase(uint32_t address)
// Set clock to 3 MHz, AT25 device is rated to 70MHz, 18MHz would be better // Set clock to 3 MHz, AT25 device is rated to 70MHz, 18MHz would be better
void eepromInit() void eepromInit()
{ {
register Spi *spiptr; register Spi * spiptr = SPI;
register uint32_t timer; register uint32_t timer;
PMC->PMC_PCER0 |= 0x00200000L; // Enable peripheral clock to SPI PMC->PMC_PCER0 |= 0x00200000L; // Enable peripheral clock to SPI
/* Configure PIO */ /* Configure PIO */
configure_pins(0x00007800, PIN_PERIPHERAL | PIN_INPUT | PIN_PER_A | PIN_PORTA | PIN_NO_PULLUP); configure_pins(0x00007800, PIN_PERIPHERAL | PIN_INPUT | PIN_PER_A | PIN_PORTA | PIN_NO_PULLUP);
spiptr = SPI;
timer = (Master_frequency / 3000000) << 8; // Baud rate 3Mb/s timer = (Master_frequency / 3000000) << 8; // Baud rate 3Mb/s
spiptr->SPI_MR = 0x14000011; // 0001 0100 0000 0000 0000 0000 0001 0001 Master spiptr->SPI_MR = 0x14000011; // 0001 0100 0000 0000 0000 0000 0001 0001 Master
spiptr->SPI_CSR[0] = 0x01180009 | timer; // 0000 0001 0001 1000 xxxx xxxx 0000 1001 spiptr->SPI_CSR[0] = 0x01180009 | timer; // 0000 0001 0001 1000 xxxx xxxx 0000 1001
@ -206,20 +188,13 @@ void eepromInit()
eepromWriteStatusRegister(); eepromWriteStatusRegister();
} }
#ifndef SIMU
extern "C" void SPI_IRQHandler() extern "C" void SPI_IRQHandler()
{ {
register Spi *spiptr; register Spi * spiptr = SPI;
spiptr = SPI;
SPI->SPI_IDR = 0x07FF; // All interrupts off SPI->SPI_IDR = 0x07FF; // All interrupts off
spiptr->SPI_CR = 2; // Disable spiptr->SPI_CR = 2; // Disable
(void) spiptr->SPI_RDR; // Dump any rx data (void) spiptr->SPI_RDR; // Dump any rx data
(void) spiptr->SPI_SR; // Clear error flags (void) spiptr->SPI_SR; // Clear error flags
spiptr->SPI_PTCR = SPI_PTCR_RXTDIS | SPI_PTCR_TXTDIS; // Stop tramsfers spiptr->SPI_PTCR = SPI_PTCR_RXTDIS | SPI_PTCR_TXTDIS; // Stop tramsfers
Spi_complete = 1; // Indicate completion Spi_complete = 1; // Indicate completion
// Power save
// PMC->PMC_PCER0 &= ~0x00200000L; // Disable peripheral clock to SPI
} }
#endif

11
radio/src/targets/taranis/board.h
View file

@ -427,9 +427,16 @@ void usbSerialPutc(uint8_t c);
#endif #endif
// I2C driver: EEPROM + Audio Volume // I2C driver: EEPROM + Audio Volume
#if defined(REV4a)
#define EEPROM_SIZE (64*1024)
#else
#define EEPROM_SIZE (32*1024)
#endif
void i2cInit(void); void i2cInit(void);
void eepromReadBlock(uint8_t * buffer, uint32_t address, uint32_t size); void eepromReadBlock(uint8_t * buffer, size_t address, size_t size);
void eepromWriteBlock(uint8_t * buffer, uint32_t address, uint32_t size); void eepromStartWrite(uint8_t * buffer, size_t address, size_t size);
uint8_t eepromIsTransferComplete();
// Debug driver // Debug driver
void debugPutc(const char c); void debugPutc(const char c);

4
radio/src/targets/taranis/bootloader/boot.cpp
View file

@ -594,7 +594,7 @@ int main()
else { else {
writeEepromBlock(); writeEepromBlock();
eepromWritten += sizeof(Block_buffer); eepromWritten += sizeof(Block_buffer);
progress = (200*eepromWritten) / EESIZE; progress = (200*eepromWritten) / EEPROM_SIZE;
} }
lcdDrawRect( 3, 6*FH+4, 204, 7); lcdDrawRect( 3, 6*FH+4, 204, 7);
@ -609,7 +609,7 @@ int main()
if (firmwareWritten >= FLASHSIZE - BOOTLOADER_SIZE) { if (firmwareWritten >= FLASHSIZE - BOOTLOADER_SIZE) {
state = ST_FLASH_DONE; // Backstop state = ST_FLASH_DONE; // Backstop
} }
if (eepromWritten >= EESIZE) { if (eepromWritten >= EEPROM_SIZE) {
state = ST_FLASH_DONE; // Backstop state = ST_FLASH_DONE; // Backstop
} }
} }

35
radio/src/targets/taranis/i2c_driver.cpp
View file

@ -130,41 +130,46 @@ bool I2C_EE_ReadBlock(uint8_t* pBuffer, uint16_t ReadAddr, uint16_t NumByteToRea
return true; return true;
} }
void eepromReadBlock(uint8_t* pBuffer, uint32_t ReadAddr, uint32_t NumByteToRead) void eepromReadBlock(uint8_t * buffer, size_t address, size_t size)
{ {
while (!I2C_EE_ReadBlock(pBuffer, ReadAddr, NumByteToRead)) { while (!I2C_EE_ReadBlock(buffer, address, size)) {
i2cInit(); i2cInit();
} }
} }
/** /**
* @brief Writes buffer of data to the I2C EEPROM. * @brief Writes buffer of data to the I2C EEPROM.
* @param pBuffer : pointer to the buffer containing the data to be * @param buffer : pointer to the buffer containing the data to be
* written to the EEPROM. * written to the EEPROM.
* @param WriteAddr : EEPROM's internal address to write to. * @param address : EEPROM's internal address to write to.
* @param NumByteToWrite : number of bytes to write to the EEPROM. * @param size : number of bytes to write to the EEPROM.
* @retval None * @retval None
*/ */
void eepromWriteBlock(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite) void eepromWriteBlock(uint8_t * buffer, size_t address, size_t size)
{ {
uint8_t offset = WriteAddr % I2C_FLASH_PAGESIZE; uint8_t offset = address % I2C_FLASH_PAGESIZE;
uint8_t count = I2C_FLASH_PAGESIZE - offset; uint8_t count = I2C_FLASH_PAGESIZE - offset;
if (NumByteToWrite < count) { if (size < count) {
count = NumByteToWrite; count = size;
} }
while (count > 0) { while (count > 0) {
eepromPageWrite(pBuffer, WriteAddr, count); eepromPageWrite(buffer, address, count);
eepromWaitEepromStandbyState(); eepromWaitEepromStandbyState();
WriteAddr += count; address += count;
pBuffer += count; buffer += count;
NumByteToWrite -= count; size -= count;
count = I2C_FLASH_PAGESIZE; count = I2C_FLASH_PAGESIZE;
if (NumByteToWrite < I2C_FLASH_PAGESIZE) { if (size < I2C_FLASH_PAGESIZE) {
count = NumByteToWrite; count = size;
} }
} }
} }
uint8_t eepromIsTransferComplete()
{
return 1;
}
/** /**
* @brief Writes more than one byte to the EEPROM with a single WRITE cycle. * @brief Writes more than one byte to the EEPROM with a single WRITE cycle.
* @note The number of byte can't exceed the EEPROM page size. * @note The number of byte can't exceed the EEPROM page size.

2
radio/src/tests/CMakeLists.txt
View file

@ -25,7 +25,7 @@ if(EXISTS "${GTEST_SRCDIR}/src/gtest-all.cc")
set(CMAKE_C_FLAGS_DEBUG "${COMMON_FLAGS} -g -O0") set(CMAKE_C_FLAGS_DEBUG "${COMMON_FLAGS} -g -O0")
set(CMAKE_CXX_FLAGS_DEBUG "${COMMON_CPP_FLAGS} -g -O0") set(CMAKE_CXX_FLAGS_DEBUG "${COMMON_CPP_FLAGS} -g -O0")
add_executable(gtests EXCLUDE_FROM_ALL ${TEST_SRC_FILES} ${CMAKE_CURRENT_SOURCE_DIR}/location.h ${RADIO_SRC} ../targets/simu/simpgmspace.cpp) add_executable(gtests EXCLUDE_FROM_ALL ${TEST_SRC_FILES} ${CMAKE_CURRENT_SOURCE_DIR}/location.h ${RADIO_SRC} ../targets/simu/simpgmspace.cpp ../targets/simu/simueeprom.cpp)
qt5_use_modules(gtests Core Widgets) qt5_use_modules(gtests Core Widgets)
add_dependencies(gtests ${FIRMWARE_DEPENDENCIES} gtests-lib) add_dependencies(gtests ${FIRMWARE_DEPENDENCIES} gtests-lib)
target_link_libraries(gtests gtests-lib pthread) target_link_libraries(gtests gtests-lib pthread)

2
radio/src/tests/eeprom.cpp
View file

@ -20,6 +20,8 @@
#include "gtests.h" #include "gtests.h"
extern const char * eepromFile;
#if !defined(EEPROM) && defined(SDCARD) #if !defined(EEPROM) && defined(SDCARD)
namespace Backup { namespace Backup {
#define BACKUP #define BACKUP