flash_main.cpp File Reference

Detailed Description

Higher-level logic of saving data into internal flash memory.

Date

Sep 19, 2013

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file flash_main.cpp.

Enumerations
enum class	FlashState { Ok , CrcFailed , IncompatibleVersion , BlankChip }

Functions
void	boardInitMfs (void)
const MFSConfig *	boardGetMfsConfig (void)
static uint32_t	flashStateCrc (const persistent_config_container_s &state)
chibios_rt::BinarySemaphore	flashWriteSemaphore (true)
static	THD_WORKING_AREA (flashWriteStack, 3 *UTILITY_THREAD_STACK_SIZE)
static	THD_WORKING_AREA (flashWriteStack, UTILITY_THREAD_STACK_SIZE)
static void	flashWriteThread (void *)
bool	allowFlashWhileRunning ()
void	setNeedToWriteConfiguration ()
bool	getNeedToWriteConfiguration ()
void	writeToFlashIfPending ()
template<typename TStorage >
int	eraseAndFlashCopy (flashaddr_t storageAddress, const TStorage &data)
void	writeToFlashNow ()
static void	doResetConfiguration ()
static FlashState	validatePersistentState ()
static FlashState	readOneConfigurationCopy (flashaddr_t address)
static FlashState	readConfiguration ()
void	readFromFlash ()
static void	rewriteConfig ()
static void	eraseConfig ()
void	initFlash ()

Variables
static bool	needToWriteConfiguration = false
MFSDriver	mfsd
bool	burnWithoutFlash = false

Enumeration Type Documentation

FlashState

enum FlashState

strong

Enumerator
Ok
CrcFailed
IncompatibleVersion
BlankChip

Definition at line 234 of file flash_main.cpp.

                      {
    Ok,
    CrcFailed,
    IncompatibleVersion,
    // all is well, but we're on a fresh chip with blank memory
    BlankChip,
};

Function Documentation

allowFlashWhileRunning()

bool allowFlashWhileRunning

(

)

Definition at line 94 of file flash_main.cpp.

                              {
    // either MCU supports flashing while executing
    // either we store settings in external storage
    return (mcuCanFlashWhileRunning() || (EFI_STORAGE_MFS_EXTERNAL == TRUE));
}

Referenced by initFlash(), setNeedToWriteConfiguration(), and writeToFlashIfPending().

Here is the call graph for this function:

Here is the caller graph for this function:

boardGetMfsConfig()

const MFSConfig* boardGetMfsConfig

(

void

)

Definition at line 34 of file board_storage.cpp.

{
    return &mfscfg1;
}

Referenced by initFlash().

Here is the caller graph for this function:

boardInitMfs()

void boardInitMfs

(

void

)

Definition at line 28 of file board_storage.cpp.

{
  /* Starting EFL driver.*/
  eflStart(&EFLD2, NULL);
}

Referenced by initFlash().

Here is the call graph for this function:

Here is the caller graph for this function:

doResetConfiguration()

static void doResetConfiguration ( )

static

Definition at line 230 of file flash_main.cpp.

                                   {
    resetConfigurationExt(engineConfiguration->engineType);
}

Referenced by initFlash(), and rewriteConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseAndFlashCopy()

template<typename TStorage >

int eraseAndFlashCopy	(	flashaddr_t	storageAddress,
		const TStorage &	data
	)

Definition at line 139 of file flash_main.cpp.

                                                                        {
    // error already reported, return
    if (!storageAddress) {
        return FLASH_RETURN_SUCCESS;
    }
 
    auto err = intFlashErase(storageAddress, sizeof(TStorage));
    if (FLASH_RETURN_SUCCESS != err) {
        criticalError("Failed to erase flash at 0x%08x: %d", storageAddress, err);
        return err;
    }
 
    err = intFlashWrite(storageAddress, reinterpret_cast<const char*>(&data), sizeof(TStorage));
    if (FLASH_RETURN_SUCCESS != err) {
        criticalError("Failed to write flash at 0x%08x: %d", storageAddress, err);
        return err;
    }
 
    return err;
}

Referenced by writeToFlashNow().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseConfig()

static void eraseConfig ( )

static

Definition at line 372 of file flash_main.cpp.

                          {
    efitick_t startNt = getTimeNowNt();
 
    mfs_error_t err;
    err = mfsErase(&mfsd);
 
    efitick_t endNt = getTimeNowNt();
    int elapsed_Ms = US2MS(NT2US(endNt - startNt));
    efiPrintf("erase done %d mS err %d", elapsed_Ms, err);
}

Referenced by initFlash().

Here is the call graph for this function:

Here is the caller graph for this function:

flashStateCrc()

static uint32_t flashStateCrc ( const persistent_config_container_s &  state )

static

https://sourceforge.net/p/rusefi/tickets/335/

In order to preserve at least one copy of the tune in case of electrical issues address of second configuration copy should be in a different sector of flash since complete flash sectors are erased on write.

Definition at line 66 of file flash_main.cpp.

                                                                          {
    return crc32(&state.persistentConfiguration, sizeof(persistent_config_s));
}

Referenced by validatePersistentState(), and writeToFlashNow().

Here is the caller graph for this function:

flashWriteSemaphore()

chibios_rt::BinarySemaphore flashWriteSemaphore

(

true

)

Referenced by flashWriteThread(), and setNeedToWriteConfiguration().

Here is the caller graph for this function:

flashWriteThread()

static void flashWriteThread ( void *  )

static

Definition at line 80 of file flash_main.cpp.

                                    {
    chRegSetThreadName("flash writer");
 
    while (true) {
        // Wait for a request to come in
        flashWriteSemaphore.wait();
 
        // Do the actual flash write operation
        writeToFlashNow();
    }
}

Referenced by initFlash().

Here is the call graph for this function:

Here is the caller graph for this function:

getNeedToWriteConfiguration()

bool getNeedToWriteConfiguration

(

)

Returns

true if an flash write is pending

Definition at line 112 of file flash_main.cpp.

                                   {
    return needToWriteConfiguration;
}

Referenced by updateFlags(), and writeToFlashIfPending().

Here is the caller graph for this function:

initFlash()

void initFlash

(

)

This would write NOW (you should not be doing this while connected to real engine)

This would schedule write to flash once the engine is stopped

Definition at line 384 of file flash_main.cpp.

                 {
#if EFI_STORAGE_MFS == TRUE
    boardInitMfs();
    const MFSConfig *mfsConfig = boardGetMfsConfig();
 
    /* MFS */
    mfsObjectInit(&mfsd);
    mfs_error_t err = mfsStart(&mfsd, mfsConfig);
    if (err < MFS_NO_ERROR) {
        /* hm...? */
    }
 
    addConsoleAction("eraseconfig", eraseConfig);
#endif
 
    addConsoleAction("readconfig", readFromFlash);
    /**
     * This would write NOW (you should not be doing this while connected to real engine)
     */
    addConsoleAction(CMD_WRITECONFIG, writeToFlashNow);
#if EFI_TUNER_STUDIO
    /**
     * This would schedule write to flash once the engine is stopped
     */
    addConsoleAction(CMD_BURNCONFIG, requestBurn);
#endif
    addConsoleAction("resetconfig", doResetConfiguration);
    addConsoleAction("rewriteconfig", rewriteConfig);
 
#if (EFI_FLASH_WRITE_THREAD == TRUE)
    if (allowFlashWhileRunning()) {
        chThdCreateStatic(flashWriteStack, sizeof(flashWriteStack), PRIO_FLASH_WRITE, flashWriteThread, nullptr);
    } else {
        efiPrintf("EFI_FLASH_WRITE_THREAD is enabled, but not used");
    }
#endif
}

Referenced by initHardwareNoConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

readConfiguration()

static FlashState readConfiguration ( )

static

this method could and should be executed before we have any connectivity so no console output here

in this method we read first copy of configuration in flash. if that first copy has CRC or other issues we read second copy.

Definition at line 283 of file flash_main.cpp.

                                      {
#if EFI_STORAGE_MFS == TRUE
    size_t settings_size = sizeof(persistentState);
    mfs_error_t err = mfsReadRecord(&mfsd, EFI_MFS_SETTINGS_RECORD_ID,
                        &settings_size, (uint8_t *)&persistentState);
 
    if (err >= MFS_NO_ERROR) {
        // readed size is not exactly the same
        if (settings_size != sizeof(persistentState))
            return FlashState::IncompatibleVersion;
        return validatePersistentState();
    } else {
        return FlashState::BlankChip;
    }
#endif
 
#if EFI_STORAGE_INT_FLASH == TRUE
    auto firstCopyAddr = getFlashAddrFirstCopy();
    auto secondyCopyAddr = getFlashAddrSecondCopy();
 
    FlashState firstCopy = readOneConfigurationCopy(firstCopyAddr);
 
    if (firstCopy == FlashState::Ok) {
        // First copy looks OK, don't even need to check second copy.
        return firstCopy;
    }
 
    /* no second copy? */
    if (getFlashAddrSecondCopy() == 0x0) {
        return firstCopy;
    }
 
    efiPrintf("Reading second configuration copy");
    return readOneConfigurationCopy(secondyCopyAddr);
#endif
 
    // In case of neither of those cases, return that things went OK?
    return FlashState::Ok;
}

Referenced by readFromFlash().

Here is the call graph for this function:

Here is the caller graph for this function:

readFromFlash()

void readFromFlash

(

)

Definition at line 323 of file flash_main.cpp.

                     {
#if HW_CHECK_MODE
    /*
     * getFlashAddr does device validation, we want validation to be invoked even while we are
     * HW_CHECK_MODE mode where we would not need actual address
     * todo: rename method to emphasis the fact of validation check?
     */
    getFlashAddrFirstCopy();
    getFlashAddrSecondCopy();
 
    resetConfigurationExt(DEFAULT_ENGINE_TYPE);
 
    FlashState result = FlashState::Ok;
#else
    FlashState result = readConfiguration();
#endif
 
    switch (result) {
        case FlashState::CrcFailed:
            warning(ObdCode::CUSTOM_ERR_FLASH_CRC_FAILED, "flash CRC failed");
            efiPrintf("Need to reset flash to default due to CRC mismatch");
            [[fallthrough]];
        case FlashState::BlankChip:
            resetConfigurationExt(DEFAULT_ENGINE_TYPE);
            break;
        case FlashState::IncompatibleVersion:
            // Preserve engine type from old config
            efiPrintf("Resetting due to version mismatch but preserving engine type [%d]", (int)engineConfiguration->engineType);
            resetConfigurationExt(engineConfiguration->engineType);
            break;
        case FlashState::Ok:
            // At this point we know that CRC and version number is what we expect. Safe to assume it's a valid configuration.
            applyNonPersistentConfiguration();
            efiPrintf("Read valid configuration from flash!");
            break;
    }
 
    // we can only change the state after the CRC check
    engineConfiguration->byFirmwareVersion = getRusEfiVersion();
    memset(persistentState.persistentConfiguration.warning_message , 0, sizeof(persistentState.persistentConfiguration.warning_message));
    engine->preCalculate();
}

Referenced by initFlash(), and loadConfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

readOneConfigurationCopy()

static FlashState readOneConfigurationCopy ( flashaddr_t  address )

static

Read single copy of rusEFI configuration from interan flash using custom driver

Definition at line 263 of file flash_main.cpp.

                                                                {
    efiPrintf("readFromFlash %x", address);
 
    // error already reported, return
    if (!address) {
        return FlashState::BlankChip;
    }
 
    intFlashRead(address, (char *) &persistentState, sizeof(persistentState));
 
    return validatePersistentState();
}

Referenced by readConfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

rewriteConfig()

static void rewriteConfig ( )

static

Definition at line 366 of file flash_main.cpp.

                            {
    doResetConfiguration();
    writeToFlashNow();
}

Referenced by initFlash().

Here is the call graph for this function:

Here is the caller graph for this function:

setNeedToWriteConfiguration()

void setNeedToWriteConfiguration

(

)

Definition at line 100 of file flash_main.cpp.

                                   {
    efiPrintf("Scheduling configuration write");
    needToWriteConfiguration = true;
 
#if (EFI_FLASH_WRITE_THREAD == TRUE)
    if (allowFlashWhileRunning()) {
        // Signal the flash writer thread to wake up and write at its leisure
        flashWriteSemaphore.signal();
    }
#endif // EFI_FLASH_WRITE_THREAD
}

Referenced by requestBurn().

Here is the call graph for this function:

Here is the caller graph for this function:

THD_WORKING_AREA() [1/2]

static THD_WORKING_AREA ( flashWriteStack  , 3 *  UTILITY_THREAD_STACK_SIZE  )

static

THD_WORKING_AREA() [2/2]

static THD_WORKING_AREA ( flashWriteStack  , UTILITY_THREAD_STACK_SIZE    )

static

validatePersistentState()

static FlashState validatePersistentState ( )

static

Definition at line 242 of file flash_main.cpp.

                                            {
    auto flashCrc = flashStateCrc(persistentState);
 
    if (flashCrc != persistentState.crc) {
        // If the stored crc is all 1s, that probably means the flash is actually blank, not that the crc failed.
        if (persistentState.crc == ((decltype(persistentState.crc))-1)) {
            return FlashState::BlankChip;
        } else {
            return FlashState::CrcFailed;
        }
    } else if (persistentState.version != FLASH_DATA_VERSION || persistentState.size != sizeof(persistentState)) {
        return FlashState::IncompatibleVersion;
    } else {
        return FlashState::Ok;
    }
}

Referenced by readConfiguration(), and readOneConfigurationCopy().

Here is the call graph for this function:

Here is the caller graph for this function:

writeToFlashIfPending()

void writeToFlashIfPending

(

)

Definition at line 116 of file flash_main.cpp.

                             {
#if (EFI_FLASH_WRITE_THREAD == TRUE)
    // with a flash write thread, the schedule happens directly from
    // setNeedToWriteConfiguration and writing happens from flash thread,
    // so there's nothing to do here
    if (allowFlashWhileRunning()) {
        return;
    }
#endif
    if (!getNeedToWriteConfiguration()) {
        // Allow sensor timeouts again now that we're done (and a little time has passed)
        Sensor::inhibitTimeouts(false);
        return;
    }
 
    // Prevent sensor timeouts while flashing
    Sensor::inhibitTimeouts(true);
    writeToFlashNow();
    // we do not want to allow sensor timeouts right away, we re-enable next time method is invoked
}

Referenced by doPeriodicSlowCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

writeToFlashNow()

void writeToFlashNow

(

)

Because of hardware-related issues, stm32f4 chip is totally frozen while we are writing to internal flash. Writing the configuration takes about 1-2 seconds, we cannot afford to do that while the engine is running so we postpone the write until the engine is stopped.

Definition at line 162 of file flash_main.cpp.

                       {
    engine->configBurnTimer.reset();
    bool isSuccess = false;
 
    if (burnWithoutFlash) {
        needToWriteConfiguration = false;
        return;
    }
    efiPrintf("Writing pending configuration... %d bytes", sizeof(persistentState));
    efitick_t startNt = getTimeNowNt();
 
    // Set up the container
    persistentState.size = sizeof(persistentState);
    persistentState.version = FLASH_DATA_VERSION;
    persistentState.crc = flashStateCrc(persistentState);
 
    // there's no wdgStop() for STM32, so we cannot disable it.
    // we just set a long timeout of 5 secs to wait until flash is done.
    startWatchdog(WATCHDOG_FLASH_TIMEOUT_MS);
 
#if EFI_STORAGE_MFS == TRUE
    mfs_error_t err;
    /* In case of MFS:
     * do we need to have two copies?
     * do we need to protect it with CRC? */
 
    err = mfsWriteRecord(&mfsd, EFI_MFS_SETTINGS_RECORD_ID,
                         sizeof(persistentState), (uint8_t *)&persistentState);
 
    if (err >= MFS_NO_ERROR)
        isSuccess = true;
#endif
 
#if EFI_STORAGE_INT_FLASH == TRUE
    // Flash two copies
    int result1 = eraseAndFlashCopy(getFlashAddrFirstCopy(), persistentState);
    int result2 = FLASH_RETURN_SUCCESS;
    /* Only if second copy is supported */
    if (getFlashAddrSecondCopy()) {
        result2 = eraseAndFlashCopy(getFlashAddrSecondCopy(), persistentState);
    }
 
    // handle success/failure
    isSuccess = (result1 == FLASH_RETURN_SUCCESS) && (result2 == FLASH_RETURN_SUCCESS);
#endif
 
    // restart the watchdog with the default timeout
    startWatchdog();
 
    if (isSuccess) {
        efitick_t endNt = getTimeNowNt();
        int elapsed_Ms = US2MS(NT2US(endNt - startNt));
 
#if EFI_STORAGE_MFS == TRUE
        efiPrintf("FLASH_SUCCESS after %d mS MFS status %d", elapsed_Ms, err);
#else
        efiPrintf("FLASH_SUCCESS after %d mS", elapsed_Ms);
#endif
    } else {
        efiPrintf("Flashing failed");
    }
 
    resetMaxValues();
 
    // Write complete, clear the flag
    needToWriteConfiguration = false;
}

Referenced by flashWriteThread(), handleCommandX14(), initFlash(), loadConfiguration(), rewriteConfig(), setEngineType(), and writeToFlashIfPending().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

burnWithoutFlash

bool burnWithoutFlash = false

Definition at line 160 of file flash_main.cpp.

Referenced by handleCommandX14(), and writeToFlashNow().

mfsd

MFSDriver mfsd

Definition at line 50 of file flash_main.cpp.

Referenced by eraseConfig(), initFlash(), readConfiguration(), and writeToFlashNow().

needToWriteConfiguration

bool needToWriteConfiguration = false

static

Definition at line 44 of file flash_main.cpp.

Referenced by getNeedToWriteConfiguration(), setNeedToWriteConfiguration(), and writeToFlashNow().

Go to the source code of this file.