EEPROM.cpp

Go to the documentation of this file.

/*
(c) 2017 night_ghost@ykoctpa.ru
 

*/
#pragma GCC optimize ("O2")

#include <AP_HAL/AP_HAL.h>

#if CONFIG_HAL_BOARD == HAL_BOARD_F4LIGHT


#include <string.h>
#include "stm32f4xx.h"
#include "EEPROM.h"
#include <hal.h>

#include <GCS_MAVLink/GCS.h>

/*
    address not uses 2 high bits so we will use them as flags of right written slot - if address has high bit then it written wrong
*/

EEPROMClass::EEPROMClass(void) 
: PageSize(0)
, _status(EEPROM_NOT_INIT)
{
}

static void reset_flash_errors(){
    if(FLASH->SR & 0xE0) FLASH->SR = 0xE0; // reset Programming Sequence, Parallelism and Alignment errors
    if(FLASH->SR & FLASH_FLAG_WRPERR) {  // write protection detected
        FLASH_OB_Unlock();
        
        FLASH_OB_WRPConfig(OB_WRP_Sector_All, DISABLE); // remove protection            
        FLASH->SR |= FLASH_FLAG_WRPERR; // reset flag
    }
}

// библиотечная версия содержит ошибку и не разблокирует память
void EEPROMClass::FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState)
{ 
  
  /* Check the parameters */
  assert_param(IS_OB_WRP(OB_WRP));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
    
    FLASH_WaitForLastOperation();

//  if(status == FLASH_COMPLETE) {  тут может быть любая ошибка - оттого мы и вызываем разблокировку!
    if(NewState != DISABLE)
    {
      *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS &= (~OB_WRP);
    }
    else
    {
      *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS |= (uint16_t)OB_WRP;
    }
//  }
}



FLASH_Status EEPROMClass::write_16(uint32_t addr, uint16_t data){
    uint16_t n_try=16;
again:
    FLASH_Status  sts = FLASH_ProgramHalfWord(addr, data);
    
    if(sts != FLASH_COMPLETE ) {
        reset_flash_errors();
        if(n_try-- > 0) goto again;
    }
    
    return sts;
}

FLASH_Status EEPROMClass::write_8(uint32_t addr, uint8_t data){ 
    uint16_t n_try=16;
again:

    FLASH_Status  sts = FLASH_ProgramByte(addr, data);
    
    if(sts != FLASH_COMPLETE ) {
        reset_flash_errors();

        if(n_try-- > 0) goto again;
    }
    
    return sts;
}

void EEPROMClass::FLASH_Lock_check(){
    FLASH_Lock();
    FLASH->CR |= FLASH_CR_ERRIE;
    FLASH->ACR |= FLASH_ACR_DCEN; // enable data cache again
}

void EEPROMClass::FLASH_Unlock_dis(){
    FLASH->ACR &= ~FLASH_ACR_DCEN; // disable data cache
    FLASH_Unlock();
}

uint16_t EEPROMClass::_CheckPage(uint32_t pageBase, uint16_t status)
{
    uint32_t pageEnd = pageBase + PageSize;

    // Page Status not EEPROM_ERASED and not a "state"
    if (read_16(pageBase) != EEPROM_ERASED && read_16(pageBase) != status)
        return EEPROM_BAD_FLASH;

    for(pageBase += 4; pageBase < pageEnd; pageBase += 4)
        if (read_32(pageBase) != 0xFFFFFFFF)    // Verify if slot is empty
            return EEPROM_BAD_FLASH;
    return EEPROM_OK;
}

FLASH_Status EEPROMClass::_ErasePageByAddress(uint32_t Page_Address)
{

    int Page_Offset = Page_Address - 0x08000000; // calculates sector by address
    uint32_t FLASH_Sector;

    if(Page_Offset < 0x10000) {
    FLASH_Sector = Page_Offset / 0x4000; // 4 * 16K pages
    } else if(Page_Offset < 0x20000) {
    FLASH_Sector = 4;                    // 1 * 64K page
    } else {
    FLASH_Sector = 4 + Page_Offset / 0x20000; // all another pages of 128K
    }

    uint8_t n_try = 16;
again:
    FLASH_Status ret = FLASH_EraseSector(8 * FLASH_Sector, VoltageRange_3);

    if(ret != FLASH_COMPLETE ) {
        reset_flash_errors();
        if(n_try-- > 0) goto again;
    }
    
    return ret;
}

FLASH_Status EEPROMClass::_ErasePage(uint32_t pageBase)
{

    FLASH_Status status;
    uint16_t data = read_16(pageBase);
    if ((data == EEPROM_ERASED) || (data == EEPROM_VALID_PAGE) || (data == EEPROM_RECEIVE_DATA))
        data = read_16(pageBase + 2) + 1; // erase count +1
    else
        data = 0;
#ifdef DEBUG_BUILD
        printf("\nEEprom erase page %d\n ", (uint16_t)((pageBase & 0x00ffffff) / 0x4000) ); // clear high byte of address and count 16K blocks
#endif
        gcs().send_text(MAV_SEVERITY_INFO, "EEprom erase page %d", (uint16_t)((pageBase & 0x00ffffff) / 0x4000) );

    status = _ErasePageByAddress(pageBase);
    
    if (status == FLASH_COMPLETE)
        status = write_16(pageBase + 2, data); // write count back

    return status;
}

uint16_t EEPROMClass::_CheckErasePage(uint32_t pageBase, uint16_t req)
{
    uint16_t status;
    if (_CheckPage(pageBase, req) != EEPROM_OK) {
        status = _ErasePage(pageBase);
        if (status != FLASH_COMPLETE)
            return status;
        return _CheckPage(pageBase, req);
    }
    return EEPROM_OK;
}

uint32_t EEPROMClass::_FindValidPage(void)
{

        if (_status == EEPROM_NOT_INIT) {
            if (_init() != EEPROM_OK) return 0;
        }
again:
    uint16_t status0 = read_16(PageBase0);      // Get Page0 actual status
    uint16_t status1 = read_16(PageBase1);      // Get Page1 actual status

    if (status0 == EEPROM_VALID_PAGE && status1 == EEPROM_ERASED)
        return PageBase0;
    if (status1 == EEPROM_VALID_PAGE && status0 == EEPROM_ERASED)
        return PageBase1;
// something went wrong, try to recover
        if(_init() == EEPROM_OK) goto again;

// all bad - -_init() fails. TODO: Panic()?
        return 0;
}

uint16_t EEPROMClass::_GetVariablesCount(uint32_t pageBase, uint16_t skipAddress)
{
    uint16_t varAddress, nextAddress;
    uint32_t idx;
    uint32_t pageEnd = pageBase + PageSize;
    uint16_t mycount = 0;

    for (pageBase += 6; pageBase < pageEnd; pageBase += 4) {
        varAddress = read_16(pageBase);
        if (varAddress == 0xFFFF || (varAddress & ADDRESS_MASK)== skipAddress || /* partially written */ (varAddress & FLAGS_MASK)!=0 )
            continue;

        mycount++;

        for(idx = pageBase + 4; idx < pageEnd; idx += 4) {
            nextAddress = read_16(idx);
            if ((nextAddress & ADDRESS_MASK) == (varAddress & ADDRESS_MASK)) {
                mycount--;
                break;
            }
        }
    }
    return mycount;
}

uint16_t EEPROMClass::_PageTransfer(uint32_t newPage, uint32_t oldPage, uint16_t SkipAddress)
{
    uint32_t oldEnd, newEnd;
    uint32_t oldIdx, newIdx, idx;
    uint16_t address, data, found;
    FLASH_Status status;

    // Transfer process: transfer variables from old to the new active page
    newEnd = newPage + PageSize;

    // Find first free element in new page
    for (newIdx = newPage + 4; newIdx < newEnd; newIdx += 4)
        if (read_32(newIdx) == 0xFFFFFFFF)  // Verify if element contents are 0xFFFFFFFF
            break;
    if (newIdx >= newEnd)
        return EEPROM_OUT_SIZE;

    oldEnd = oldPage + 4;
    oldIdx = oldPage + (PageSize - 2);

    for (; oldIdx > oldEnd; oldIdx -= 4) {
        address = read_16(oldIdx);
        if ( address == SkipAddress || (address & FLAGS_MASK)!=0)
            continue;                       // it's means that power off after write data

        found = 0;

        for (idx = newPage + 6; idx < newIdx; idx += 4){
            if (read_16(idx) == address) {
                found = 1;
                break;
            }
                }
        if (found)
            continue;       // There is more recent data with this address

        if (newIdx < newEnd) {
            data = read_16(oldIdx - 2);

            status = write_16(newIdx, data);
            if (status != FLASH_COMPLETE)
                return status;

            status = write_16(newIdx + 2, address & ADDRESS_MASK);
            if (status != FLASH_COMPLETE)
                return status;

            newIdx += 4;
        }
        else
            return EEPROM_OUT_SIZE;
    }

    // Erase the old Page: Set old Page status to EEPROM_EEPROM_ERASED status
    data = _CheckErasePage(oldPage, EEPROM_ERASED);
    if (data != EEPROM_OK)
        return data;

    // Set new Page status
    status = write_16(newPage, EEPROM_VALID_PAGE);
    if (status != FLASH_COMPLETE)
        return status;

    return EEPROM_OK;
}

uint16_t EEPROMClass::_VerifyPageFullWriteVariable(uint16_t Address, uint16_t Data)
{
    FLASH_Status status;
    uint32_t idx, pageBase, pageEnd, newPage;
    uint16_t mycount;
    uint16_t old_data;

    // Get valid Page for write operation
    pageBase = _FindValidPage();
    if (pageBase == 0)
        return  EEPROM_NO_VALID_PAGE;

    // Get the valid Page end Address
    pageEnd = pageBase + PageSize;          // Set end of page
    
// read from end to begin
    for (idx = pageEnd - 2; idx > pageBase; idx -= 4) { 
        if (read_16(idx) == Address){       // Find last value for address, will stop loop if found
            old_data = read_16(idx - 2);    // Read last data
            if (old_data == Data){
                return EEPROM_OK;   //      data already OK
            }
            if (old_data == 0xFFFF || /* we can write - there is no '0' where we need '1' */ (~old_data & Data)==0 ) { 
                status = write_16(idx - 2, Data);   // Set variable data
                if (status == FLASH_COMPLETE && read_16(idx - 2) == Data) // check if writen
                    return EEPROM_OK;
            }
            break;
        }
    }

    // Check each active page address starting from begining
    for (idx = pageBase + 4; idx < pageEnd; idx += 4){
        if (read_32(idx) == 0xFFFFFFFF){        // Verify if element contents are 0xFFFFFFFF
            status = write_16(idx, Data);   // Set variable data
            if (status != FLASH_COMPLETE)
                return status;
            status = write_16(idx + 2, Address & ADDRESS_MASK); // Set variable virtual address
            if (status != FLASH_COMPLETE)
                return 0x90 + status;
            return EEPROM_OK;
        }
        }

    // Empty slot not found, need page transfer
    // Calculate unique variables in page
    mycount = _GetVariablesCount(pageBase, Address) + 1;
    if (mycount >= maxcount())
        return EEPROM_OUT_SIZE;

    if (pageBase == PageBase1)
        newPage = PageBase0;        // New page address where variable will be moved to
    else
        newPage = PageBase1;

    // Set the new Page status to RECEIVE_DATA status
    status = write_16(newPage, EEPROM_RECEIVE_DATA);
    if (status != FLASH_COMPLETE)
        return status;

    // Write the variable passed as parameter in the new active page
    status = write_16(newPage + 4, Data);
    if (status != FLASH_COMPLETE)
        return status;

    status = write_16(newPage + 6, Address);
    if (status != FLASH_COMPLETE)
        return status;

    return _PageTransfer(newPage, pageBase, Address);
}


uint16_t EEPROMClass::init(uint32_t pageBase0, uint32_t pageBase1, uint32_t pageSize)
{
    PageBase0 = pageBase0;
    PageBase1 = pageBase1;
    PageSize = pageSize;

    return _init();
}

uint16_t EEPROMClass::_init(void) // 
{

    uint16_t status0, status1, erased0;
    FLASH_Status status;

    _status = EEPROM_NO_VALID_PAGE;

        if(PageSize == 0) return _status; // no real Init call

    FLASH_Unlock();

    erased0 = read_16(PageBase0 + 2);
    if (erased0 == 0xffff) erased0 = 0;
    // Print number of EEprom write cycles - but it cleared each reflash
#ifdef DEBUG_BUILD
    printf("\nEEprom write cycles %d\n ", erased0);
#endif

    status0 = read_16(PageBase0);
    status1 = read_16(PageBase1);

    // Check if EEprom is formatted
        if (       status0 != EEPROM_VALID_PAGE && status0 != EEPROM_RECEIVE_DATA && status0 != EEPROM_ERASED){
            // _status = _format();  как-то жестко форматировать ВСЕ по одиночной ошибке. Если ВТОРАЯ страница валидная то достаточно стереть пострадавшую
            if(status1 == EEPROM_VALID_PAGE) _status = _CheckErasePage(PageBase0, EEPROM_ERASED);
            else                             _status = _format();
            status0 = read_16(PageBase0);
            status1 = read_16(PageBase1);
        }else  if (status1 != EEPROM_VALID_PAGE && status1 != EEPROM_RECEIVE_DATA && status1 != EEPROM_ERASED){
        //    _status = _format();  тут мы первую страницу уже проверили - валидная, отставить вредительство!
            _status = _CheckErasePage(PageBase1, EEPROM_ERASED);
        status0 = read_16(PageBase0);
        status1 = read_16(PageBase1);            
        }


    switch (status0) {
/*
        Page0               Page1
        -----               -----
        EEPROM_ERASED           EEPROM_VALID_PAGE           Page1 valid, Page0 erased
                        EEPROM_RECEIVE_DATA         Page1 need set to valid, Page0 erased
                        EEPROM_ERASED               make _Format
                        any                 Error: EEPROM_NO_VALID_PAGE
*/
    case EEPROM_ERASED:
        if (status1 == EEPROM_VALID_PAGE)       // Page0 erased, Page1 valid
            _status = _CheckErasePage(PageBase0, EEPROM_ERASED);
        else if (status1 == EEPROM_RECEIVE_DATA) {  // Page0 erased, Page1 receive      
        // Page Transfer failed! we can't be sure if it finished OK so should restart transfer - but page is erased. This can be if write "valid" mark fails
            status = write_16(PageBase1, EEPROM_VALID_PAGE); // so just mark it as valid
            if (status != FLASH_COMPLETE)
                _status = status;
            else
                _status = _CheckErasePage(PageBase0, EEPROM_ERASED);

        }
        else /* if (status1 == EEPROM_ERASED)*/     // Both in erased OR 2nd in unknown state so format EEPROM
            _status = _format();
        break;
/*
        Page0               Page1
        -----               -----
        EEPROM_RECEIVE_DATA     EEPROM_VALID_PAGE           Transfer Page1 to Page0
                        EEPROM_ERASED               Page0 need set to valid, Page1 erased
                        any                 EEPROM_NO_VALID_PAGE
*/
    case EEPROM_RECEIVE_DATA:
        if (status1 == EEPROM_VALID_PAGE)           // Page0 receive, Page1 valid
        // transfer failed and we have good data - restart transfer
            _status = _PageTransfer(PageBase0, PageBase1, 0xFFFF);
        else if (status1 == EEPROM_ERASED){         // Page0 receive, Page1 erased      
                        // setting "valid" mark failed
            _status = _CheckErasePage(PageBase1, EEPROM_ERASED);
            if (_status == EEPROM_OK){          
                status = write_16(PageBase0, EEPROM_VALID_PAGE); // mark as valid again
                if (status != FLASH_COMPLETE)
                    _status = status;
                else
                    _status = EEPROM_OK;
            }
        }
        else _status = _format(); // all bad
        break;
/*
        Page0               Page1
        -----               -----
        EEPROM_VALID_PAGE       EEPROM_VALID_PAGE           Error: EEPROM_NO_VALID_PAGE
                        EEPROM_RECEIVE_DATA         Transfer Page0 to Page1
                        any                 Page0 valid, Page1 erased
*/
    case EEPROM_VALID_PAGE:
        if (status1 == EEPROM_VALID_PAGE){          // Both pages valid
// just check amount and correctness of data
                    uint16_t cnt0 = _GetVariablesCount(PageBase0, 0xFFFF);
                    uint16_t cnt1 = _GetVariablesCount(PageBase1, 0xFFFF);
                    if(cnt0>cnt1){
                        _status = _CheckErasePage(PageBase1, EEPROM_ERASED);
                    }else if(cnt0<cnt1){
                        _status = _CheckErasePage(PageBase0, EEPROM_ERASED);
                    } else { // ну такого совсем не может быть ибо марку "валид" мы делаем только после стирания.
                // _status = EEPROM_NO_VALID_PAGE;
                _status = _CheckErasePage(PageBase1, EEPROM_ERASED); // сотрем вторую - я монетку бросил
            }
        }else if (status1 == EEPROM_RECEIVE_DATA) {     
            _status = _PageTransfer(PageBase1, PageBase0, 0xFFFF); // restart transfer
        } else {
            _status = _CheckErasePage(PageBase1, EEPROM_ERASED);
        }
        break;
/*
        Page0               Page1
        -----               -----
        any             EEPROM_VALID_PAGE           Page1 valid, Page0 erased
                        EEPROM_RECEIVE_DATA         Page1 valid, Page0 erased
                        any                 EEPROM_NO_VALID_PAGE
*/
    default:
        if (status1 == EEPROM_VALID_PAGE)
            _status = _CheckErasePage(PageBase0, EEPROM_ERASED);    // Check/Erase Page0
        else if (status1 == EEPROM_RECEIVE_DATA) {
            status = write_16(PageBase1, EEPROM_VALID_PAGE);
            if (status != FLASH_COMPLETE)
                _status = status;
            else
                _status = _CheckErasePage(PageBase0, EEPROM_ERASED);
        }
        else _status = _format(); // all bad
        break;
    }
    
    FLASH_Lock_check(); // lock after all writes
    return _status;
}

uint16_t EEPROMClass::_format(void)
{
    uint16_t status;
    uint16_t n_try=16;

again:

    // Erase Page0
    status = _CheckErasePage(PageBase0, EEPROM_VALID_PAGE);
    if (status != EEPROM_OK) goto error;
    
    if (read_16(PageBase0) == EEPROM_ERASED) {
        // Set Page0 as valid page: Write VALID_PAGE at Page0 base address
        FLASH_Status fs = write_16(PageBase0, EEPROM_VALID_PAGE);
        if (fs != FLASH_COMPLETE) goto error;
    }
    // Erase Page1
    status = _CheckErasePage(PageBase1, EEPROM_ERASED);
    if (status == EEPROM_OK) return status;
error:
        // something went wrong
        reset_flash_errors();

        if(n_try-- > 0) goto again;
        
    return status;
}

uint16_t EEPROMClass::format(void){
    uint16_t status;
    FLASH_Unlock();
    status = _format();
    FLASH_Lock_check();
    return status;
}


uint16_t EEPROMClass::erases(uint16_t *Erases)
{
    uint32_t pageBase;

    // Get active Page for read operation
    pageBase = _FindValidPage();
    if (pageBase == 0)
        return  EEPROM_NO_VALID_PAGE;

    *Erases = read_16(pageBase+2);
    return EEPROM_OK;
}


uint16_t EEPROMClass::read(uint16_t Address, uint16_t *Data)
{
    uint32_t pageBase, pageEnd;

    *Data = EEPROM_DEFAULT_DATA; // Set default data (empty EEPROM)

    // Get active Page for read operation
    pageBase = _FindValidPage();
    if (pageBase == 0)      return  EEPROM_NO_VALID_PAGE;

    // Get the valid Page end Address
    pageEnd = pageBase + (PageSize - 2);
    
    Address &= ADDRESS_MASK;
    
    uint32_t ptr = pageEnd;
    
    // Check each active page address  starting from end - the last value written
    for (pageBase += 6; ptr >= pageBase; ptr -= 4){
        if (read_16(ptr) == Address){// Compare the read address with the virtual address       
        *Data = read_16(ptr - 2);       // Get content of Address-2 which is variable value
        return EEPROM_OK;
        }
    }

    return EEPROM_BAD_ADDRESS;
}

uint16_t EEPROMClass::write(uint16_t Address, uint16_t Data)
{
    if (_status == EEPROM_NOT_INIT)
        if (_init() != EEPROM_OK)
            return _status;

    if (Address == 0xFFFF)
        return EEPROM_BAD_ADDRESS;

        FLASH_Unlock();

    // Write the variable virtual address and value in the EEPROM
    uint16_t status = _VerifyPageFullWriteVariable(Address & ADDRESS_MASK, Data);
    if(status == EEPROM_NO_VALID_PAGE) _status = EEPROM_NOT_INIT;

    FLASH_Lock_check();
    return status;
}

uint16_t EEPROMClass::count(uint16_t *cnt)
{
    // Get valid Page for write operation
    uint32_t pageBase = _FindValidPage();
    if (pageBase == 0)
        return EEPROM_NO_VALID_PAGE;    // No valid page, return max. numbers

    *cnt = _GetVariablesCount(pageBase, 0xFFFF);
    return EEPROM_OK;
}


EEPROMClass EEPROM;
#endif