uint8_t EFile::write(uint8_t*buf,uint8_t i_len){
uint8_t len=i_len;
if(!m_currBlk && m_pos==0)
{
eeFs->files[m_fileId].startBlk = m_currBlk = EeFsAlloc();
}
while(len)
{
if(!m_currBlk) {
m_err = ERR_FULL;
break;
}
if(m_ofs>=(BS-1)){
m_ofs=0;
if( ! EeFsGetLink(m_currBlk) ){
EeFsSetLink(m_currBlk, EeFsAlloc());
}
m_currBlk = EeFsGetLink(m_currBlk);
}
if(!m_currBlk) {
m_err = ERR_FULL;
break;
}
uint8_t l = BS-1-m_ofs; if(l>len) l=len;
EeFsSetDat(m_currBlk, m_ofs, buf, l);
buf +=l;
m_ofs +=l;
len -=l;
}
m_pos += i_len - len;
return i_len - len;
}
void EFile::EeFsFree(uint8_t blk){///free one or more blocks
uint8_t i = blk;
while( EeFsGetLink(i)) i = EeFsGetLink(i);
EeFsSetLink(i,eeFs->freeList);
eeFs->freeList = blk; //chain in front
EeFsFlushFreelist();
}
/*
* alloc one block from freelist
*/
unsigned int EFile::EeFsAlloc()
{
unsigned int ret = (IS_ARM(board) ? eeFsArm->freeList : eeFs->freeList);
if (ret) {
if (IS_ARM(board))
eeFsArm->freeList = EeFsGetLink(ret);
else
eeFs->freeList = EeFsGetLink(ret);
EeFsSetLink(ret, 0);
}
return ret;
}
/*
* free one or more blocks
*/
void EFile::EeFsFree(unsigned int blk)
{
unsigned int i = blk;
while (EeFsGetLink(i)) i = EeFsGetLink(i);
if (IS_ARM(board)) {
EeFsSetLink(i, eeFsArm->freeList);
eeFsArm->freeList = blk; //chain in front
}
else {
EeFsSetLink(i, eeFs->freeList);
eeFs->freeList = blk; //chain in front
}
}
void EFile::closeTrunc()
{
uint8_t fri=0;
eeFs->files[m_fileId].size = m_pos;
if(m_currBlk && ( fri = EeFsGetLink(m_currBlk))) EeFsSetLink(m_currBlk, 0);
EeFsFlush(); //chained out
if(fri) EeFsFree( fri ); //chain in
}
uint8_t EFile::EeFsAlloc(){ ///alloc one block from freelist
uint8_t ret=eeFs->freeList;
if(ret){
eeFs->freeList = EeFsGetLink(ret);
EeFsFlushFreelist();
EeFsSetLink(ret,0);
}
return ret;
}
uint16_t EFile::EeFsGetFree()
{
uint16_t ret = 0;
uint8_t i = eeFs->freeList;
while( i ){
ret += BS-1;
i = EeFsGetLink(i);
}
return ret;
}
int8_t EFile::EeFsck()
{
uint8_t *bufp;
static uint8_t buffer[BLOCKS];
bufp = buffer;
memset(bufp,0,BLOCKS);
uint8_t blk ;
int8_t ret=0;
for(uint8_t i = 0; i <= MAXFILES; i++){
uint8_t *startP = i==MAXFILES ? &(eeFs->freeList) : &(eeFs->files[i].startBlk);
uint8_t lastBlk = 0;
blk = *startP;
//if(i == MAXFILES) blk = eeFs->freeList;
// else blk = eeFs->files[i].startBlk;
while(blk){
// if(blk < FIRSTBLK ) goto err_1; //bad blk index
// if(blk >= BLOCKS ) goto err_2; //bad blk index
// if(bufp[blk]) goto err_3; //blk double usage
if( ( blk < FIRSTBLK ) //goto err_1; //bad blk index
|| (blk >= BLOCKS ) //goto err_2; //bad blk index
|| (bufp[blk] ))//goto err_3; //blk double usage
{
if(lastBlk){
EeFsSetLink(lastBlk,0);
}else{
*startP = 0; //interrupt chain at startpos
EeFsFlush();
}
blk=0; //abort
}else{
bufp[blk] = i+1;
lastBlk = blk;
blk = EeFsGetLink(blk);
}
}
}
for(blk = FIRSTBLK; blk < BLOCKS; blk++){
if(bufp[blk]==0) { //goto err_4; //unused block
EeFsSetLink(blk,eeFs->freeList);
eeFs->freeList = blk; //chain in front
EeFsFlushFreelist();
}
}
// if(0){
//err_4: ret--;
//err_3: ret--;
// err_2: ret--;
// err_1: ret--;
// }
return ret;
}
unsigned int EFile::EeFsGetFree()
{
unsigned int ret = 0;
unsigned int i;
if (IS_ARM(board))
i = eeFsArm->freeList;
else
i = eeFs->freeList;
while (i) {
ret += eeFsBlockSize-eeFsLinkSize;
i = EeFsGetLink(i);
}
return ret;
}
uint16_t EeFsGetFree()
{
#if defined(CPUARM)
int32_t ret = freeBlocks * (BS-sizeof(blkid_t));
#else
int16_t ret = 0;
blkid_t i = eeFs.freeList;
while (i) {
ret += BS-sizeof(blkid_t);
i = EeFsGetLink(i);
}
#endif
ret += eeFs.files[FILE_TMP].size;
ret -= eeFs.files[FILE_MODEL(g_eeGeneral.currModel)].size;
return (ret > 0 ? ret : 0);
}
/// free one or more blocks
static void EeFsFree(blkid_t blk)
{
blkid_t i = blk;
blkid_t tmp;
freeBlocks++;
while ((tmp=EeFsGetLink(i))) {
i = tmp;
freeBlocks++;
}
EeFsSetLink(i, eeFs.freeList);
eeFs.freeList = blk; //chain in front
EeFsFlushFreelist();
}
uint8_t EFile::read(uint8_t*buf,uint16_t i_len){
uint16_t len = eeFs->files[m_fileId].size - m_pos;
if(len < i_len) i_len = len;
len = i_len;
while(len)
{
if(!m_currBlk) break;
*buf++ = EeFsGetDat(m_currBlk, m_ofs++);
if(m_ofs>=(BS-1)){
m_ofs=0;
m_currBlk=EeFsGetLink(m_currBlk);
}
len--;
}
m_pos += i_len - len;
return i_len - len;
}
unsigned int EFile::read(uint8_t *buf, unsigned int i_len)
{
unsigned int len = IS_ARM(board) ? eeFsArm->files[m_fileId].size : eeFs->files[m_fileId].size;
len -= m_pos;
if (i_len > len) i_len = len;
len = i_len;
while(len) {
if (!m_currBlk) break;
*buf++ = EeFsGetDat(m_currBlk, m_ofs++);
if (m_ofs >= (eeFsBlockSize-(IS_ARM(board)? 2 : 1))) {
m_ofs = 0;
m_currBlk = EeFsGetLink(m_currBlk);
}
len--;
}
m_pos += i_len - len;
return i_len - len;
}
/// free one or more blocks
static void EeFsFree(blkid_t blk)
{
blkid_t i = blk;
blkid_t tmp;
#if defined(PCBTARANIS)
freeBlocks++;
#endif
while ((tmp=EeFsGetLink(i))) {
i = tmp;
#if defined(PCBTARANIS)
freeBlocks++;
#endif
}
EeFsSetLink(i, eeFs.freeList);
eeFs.freeList = blk; //chain in front
EeFsFlushFreelist();
}
uint8_t EFile::read(uint8_t *buf, uint8_t i_len)
{
uint16_t len = eeFs.files[m_fileId].size - m_pos;
if (i_len > len) i_len = len;
uint8_t remaining = i_len;
while (remaining) {
if (!m_currBlk) break;
*buf++ = EeFsGetDat(m_currBlk, m_ofs++);
if (m_ofs >= BS-sizeof(blkid_t)) {
m_ofs = 0;
m_currBlk = EeFsGetLink(m_currBlk);
}
remaining--;
}
i_len -= remaining;
m_pos += i_len;
return i_len;
}
int8_t EeFsck()
{
ENABLE_SYNC_WRITE(true);
uint8_t *bufp = (uint8_t *)&g_model;
memclear(bufp, BLOCKS);
blkid_t blk ;
#if defined(PCBTARANIS)
blkid_t blocksCount;
#endif
for (uint8_t i=0; i<=MAXFILES; i++) {
#if defined(PCBTARANIS)
blocksCount = 0;
#endif
blkid_t *startP = (i==MAXFILES ? &eeFs.freeList : &eeFs.files[i].startBlk);
blkid_t lastBlk = 0;
blk = *startP;
while (blk) {
if (blk < FIRSTBLK || // bad blk index
blk >= BLOCKS || // bad blk indexchan
bufp[blk]) // blk double usage
{
if (lastBlk) {
EeFsSetLink(lastBlk, 0);
}
else {
*startP = 0; // interrupt chain at startpos
EeFsFlush();
}
blk = 0; // abort
}
else {
#if defined(PCBTARANIS)
blocksCount++;
#endif
bufp[blk] = i+1;
lastBlk = blk;
blk = EeFsGetLink(blk);
}
}
}
#if defined(PCBTARANIS)
freeBlocks = blocksCount;
#endif
for (blk=FIRSTBLK; blk<BLOCKS; blk++) {
if (!bufp[blk]) { // unused block
#if defined(PCBTARANIS)
freeBlocks++;
#endif
EeFsSetLink(blk, eeFs.freeList);
eeFs.freeList = blk; // chain in front
EeFsFlushFreelist();
}
}
ENABLE_SYNC_WRITE(false);
return 0;
}
