storage.cpp File Reference

Detailed Description

adapter for unify access to MFS and legacy 'internal flash' storage drivers

Date

Jan 4, 2025

Author

Andrey Gusakov

Definition in file storage.cpp.

Functions
bool	storageAllowWriteID (StorageItemId id)
static bool	storageWriteID (uint32_t id)
static bool	storageReadID (uint32_t id)
static const char *	storageTypeToName (StorageType type)
static bool	storageIsIdAvailableForId (StorageItemId id)
StorageStatus	storageWrite (StorageItemId id, const uint8_t *ptr, size_t size)
StorageStatus	storageRead (StorageItemId id, uint8_t *ptr, size_t size)
static bool	storageManagerSendCmd (uint32_t cmd, uint32_t arg)
bool	storageRequestWriteID (StorageItemId id, bool forced)
bool	storageReqestReadID (StorageItemId id)
bool	storageRegisterStorage (StorageType type, SettingStorageBase *storage)
bool	storageUnregisterStorage (StorageType type)
bool	storageIsStorageRegistered (StorageType type)
bool	storagRequestRegisterStorage (StorageType id)
bool	storagRequestUnregisterStorage (StorageType id)
static	THD_WORKING_AREA (storageManagerThreadStack, 3 *UTILITY_THREAD_STACK_SIZE)
static	THD_WORKING_AREA (storageManagerThreadStack, UTILITY_THREAD_STACK_SIZE)
static void	storageManagerThread (void *)
bool	getNeedToWriteConfiguration ()
void	initStorage ()

Variables
static constexpr size_t	storagesCount = STORAGE_TOTAL
static SettingStorageBase *	storages [storagesCount]
chibios_rt::Mailbox< msg_t, 16 >	storageManagerMb
static uint32_t	pendingWrites = 0
static uint32_t	pendingReads = 0

Function Documentation

getNeedToWriteConfiguration()

bool getNeedToWriteConfiguration

(

)

Returns

true if an persistentState write is pending

Definition at line 353 of file storage.cpp.

                                   {
    return (pendingWrites & BIT(EFI_SETTINGS_RECORD_ID)) != 0;
}

Referenced by updateFlags().

Here is the caller graph for this function:

initStorage()

void initStorage

(

)

Definition at line 357 of file storage.cpp.

                   {
    bool settingsStorageReady = false;
    // may be unused
    (void)settingsStorageReady;
 
#if EFI_STORAGE_INT_FLASH == TRUE
    settingsStorageReady = initStorageFlash();
#endif // EFI_STORAGE_INT_FLASH
 
#if EFI_STORAGE_MFS == TRUE
    if (settingsStorageReady) {
        // Skip MFS if internal storage is used for persistentState
        // Init of MFS may take significant time, lets postpone it until storage manager thread
        storagRequestRegisterStorage(STORAGE_MFS_EXT_FLASH);
    } else {
        // Set long timeout to watchdog as this code is called before any thread is started
        // and no one is feeding watchdog
        startWatchdog(WATCHDOG_MFS_START_TIMEOUT_MS);
 
        initStorageMfs();
 
        // restart the watchdog with the default timeout
        startWatchdog();
    }
#endif // EFI_STORAGE_MFS
 
    chThdCreateStatic(storageManagerThreadStack, sizeof(storageManagerThreadStack), PRIO_STORAGE_MANAGER, storageManagerThread, nullptr);
}

Referenced by initFlash().

Here is the call graph for this function:

Here is the caller graph for this function:

storageAllowWriteID()

bool storageAllowWriteID

(

StorageItemId

id

)

Definition at line 19 of file storage.cpp.

{
#if (EFI_STORAGE_INT_FLASH == TRUE) || defined(EFI_UNIT_TEST)
    if ((id == EFI_SETTINGS_RECORD_ID) ||
        (id == EFI_SETTINGS_BACKUP_RECORD_ID)) {
        // special case, settings can be stored in internal flash
 
        // writing internal flash can cause cpu freeze
        // check if HW support flash writing while executing
        if (mcuCanFlashWhileRunning()) {
            return true;
        }
 
#if EFI_SHAFT_POSITION_INPUT
        // MCU does not support write while executing, check if engine is stopped
        if (engine->triggerCentral.directSelfStimulation || engine->rpmCalculator.isStopped()) {
            return true;
        } else {
            // rusEfi usually runs on hardware which halts execution while writing to internal flash, so we
            // postpone writes to until engine is stopped. Writes in case of self-stimulation are fine.
            return false;
        }
#endif // EFI_SHAFT_POSITION_INPUT
    }
#endif // EFI_STORAGE_INT_FLASH
 
    // TODO: we expect every other ID to be stored in external flash...
    return true;
}

Referenced by storageManagerThread().

Here is the call graph for this function:

Here is the caller graph for this function:

storageIsIdAvailableForId()

static bool storageIsIdAvailableForId ( StorageItemId  id )

static

Definition at line 132 of file storage.cpp.

                                                        {
    for_all_storages {
        if ((storage->isReady()) && (storage->isIdSupported(id))) {
            return true;
        }
    }
 
    return false;
}

Referenced by storageManagerThread().

Here is the caller graph for this function:

storageIsStorageRegistered()

bool storageIsStorageRegistered

(

StorageType

type

)

Definition at line 230 of file storage.cpp.

                                                  {
    if (type >= STORAGE_TOTAL) {
        return false;
    }
 
    return (storages[type] != nullptr);
}

Referenced by hellenDisableEn(), storageRegisterStorage(), and storageUnregisterStorage().

Here is the caller graph for this function:

storageManagerSendCmd()

static bool storageManagerSendCmd ( uint32_t  cmd, uint32_t  arg  )

static

Definition at line 178 of file storage.cpp.

{
    msg_t msg = ((cmd & 0xff) << 24) | (arg & 0x00ffffff);
    // Note: we are not sure about caller context and using universal (but not optimal) chSysGetStatusAndLockX()
    chibios_rt::CriticalSectionLocker csl;
    return (storageManagerMb.postI(msg) == MSG_OK);
}

Referenced by storageRegisterStorage(), storageReqestReadID(), storageRequestWriteID(), storagRequestRegisterStorage(), and storagRequestUnregisterStorage().

Here is the caller graph for this function:

storageManagerThread()

static void storageManagerThread ( void *  )

static

Definition at line 258 of file storage.cpp.

                                        {
    chRegSetThreadName("storage manger");
 
    while (true) {
        msg_t ret;
        msg_t msg;
 
        // Wait for a request to come in or timeout
        ret = storageManagerMb.fetch(&msg, TIME_MS2I(STORAGE_MANAGER_POLL_INTERVAL_MS));
        if (ret == MSG_OK) {
            uint8_t cmd = (msg >> 24) & 0xff;
            uint32_t id = msg & MSG_ID_MASK;
 
            switch (cmd) {
            case MSG_CMD_READ:
                pendingReads |= BIT(id);
                break;
            case MSG_CMD_WRITE:
                pendingWrites |= BIT(id);
                break;
            case MSG_CMD_WRITE_NOW:
                pendingWrites |= BIT(id);
                // skip storageAllowWriteID() check
                if (storageWriteID(id)) {
                    pendingWrites &= ~BIT(id);
                }
                break;
            case MSG_CMD_PING:
                /* nop */
                break;
            case MSG_CMD_REG:
#if EFI_STORAGE_INT_FLASH == TRUE
                if ((StorageType)id == STORAGE_INT_FLASH) {
                    initStorageFlash();
                }
#endif // EFI_STORAGE_INT_FLASH
#if EFI_STORAGE_MFS == TRUE
                if ((StorageType)id == STORAGE_MFS_EXT_FLASH) {
                    initStorageMfs();
                }
#endif // EFI_STORAGE_MFS
#if EFI_STORAGE_SD == TRUE
                if ((StorageType)id == STORAGE_SD_CARD) {
                    initStorageSD();
                }
#endif // EFI_STORAGE_SD
                break;
            case MSG_CMD_UNREG:
                storageUnregisterStorage((StorageType)id);
                break;
            default:
                /* ignore */
                break;
            }
        }
 
        // check if we can read some of pending IDs...
        for (size_t i = 0; (i < EFI_STORAGE_TOTAL_ITEMS) && pendingReads; i++) {
            if ((pendingReads & BIT(i)) == 0) {
                continue;
            }
 
            StorageItemId id = (StorageItemId)i;
            if (!storageIsIdAvailableForId(id)) {
                continue;
            }
 
            if (storageReadID(id)) {
                pendingReads &= ~BIT(id);
            }
        }
 
        // check if we can write some of pendind IDs...
        for (size_t i = 0; (i < EFI_STORAGE_TOTAL_ITEMS) && pendingWrites; i++) {
            if ((pendingWrites & BIT(i)) == 0) {
                continue;
            }
 
            StorageItemId id = (StorageItemId)i;
            if (!storageIsIdAvailableForId(id)) {
                continue;
            }
 
            if (!storageAllowWriteID(id)) {
                continue;
            }
 
            if (storageWriteID(id)) {
                pendingWrites &= ~BIT(id);
            }
        }
    }
}

Referenced by initStorage().

Here is the call graph for this function:

Here is the caller graph for this function:

storageRead()

StorageStatus storageRead	(	StorageItemId	id,
		uint8_t *	ptr,
		size_t	size
	)

Definition at line 160 of file storage.cpp.

                                                                       {
    bool success = false;
    StorageStatus status = StorageStatus::NotSupported;
 
    for_all_storages {
        if ((!storage->isReady()) || (!storage->isIdSupported(id))) {
            continue;
        }
 
        status = storage->read(id, ptr, size);
        if (status == StorageStatus::Ok) {
            success = true;
        }
    }
 
    return (success ? StorageStatus::Ok : status);
}

Referenced by LtftState::load(), and readConfiguration().

Here is the caller graph for this function:

storageReadID()

static bool storageReadID ( uint32_t  id )

static

Definition at line 98 of file storage.cpp.

                                       {
    // Do actual read and call consumers callback
 
    if (id == EFI_LTFT_RECORD_ID) {
        engine->module<LongTermFuelTrim>()->load();
        return true;
    } else {
        efiPrintf("Requested to read unknown record id %ld", id);
        // to clear pending bit
        return true;
    }
}

Referenced by storageManagerThread().

Here is the call graph for this function:

Here is the caller graph for this function:

storageRegisterStorage()

bool storageRegisterStorage	(	StorageType	type,
		SettingStorageBase *	storage
	)

Definition at line 194 of file storage.cpp.

                                                                           {
    if (type >= STORAGE_TOTAL) {
        return false;
    }
 
    if (storageIsStorageRegistered(type)) {
        /* already registered */
        efiPrintf("Trying to register already exist storage %s", storageTypeToName(type));
        return false;
    }
 
    storages[type] = storage;
    efiPrintf("Storage %s registered", storageTypeToName(type));
 
    storageManagerSendCmd(MSG_CMD_PING, 0);
 
    return true;
}

Referenced by initStorageFlash(), initStorageMfs(), and initStorageSD().

Here is the call graph for this function:

Here is the caller graph for this function:

storageReqestReadID()

bool storageReqestReadID

(

StorageItemId

id

)

Definition at line 190 of file storage.cpp.

                                           {
    return storageManagerSendCmd(MSG_CMD_READ, (uint32_t)id);
}

Referenced by LtftState::load().

Here is the call graph for this function:

Here is the caller graph for this function:

storageRequestWriteID()

bool storageRequestWriteID	(	StorageItemId	id,
		bool	forced
	)

Definition at line 186 of file storage.cpp.

                                                          {
    return storageManagerSendCmd(forced ? MSG_CMD_WRITE_NOW : MSG_CMD_WRITE, (uint32_t)id);
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

storageTypeToName()

static const char * storageTypeToName ( StorageType  type )

static

Definition at line 111 of file storage.cpp.

                                                       {
    switch (type) {
    case STORAGE_INT_FLASH:
        return "INT_FLASH";
    case STORAGE_MFS_INT_FLASH:
        return "MFS_INT_FLASH";
    case STORAGE_MFS_EXT_FLASH:
        return "MFS_EXT_FLASH";
    case STORAGE_SD_CARD:
        return "SD_CARD";
    default:
        break;
    }
 
    return "UNK";
}

Referenced by storageRegisterStorage(), and storageUnregisterStorage().

Here is the caller graph for this function:

storageUnregisterStorage()

bool storageUnregisterStorage

(

StorageType

type

)

Definition at line 213 of file storage.cpp.

                                                {
    if (type >= STORAGE_TOTAL) {
        return false;
    }
 
    if (!storageIsStorageRegistered(type)) {
        /* already unregistered */
        efiPrintf("Trying to unregister non-exist storage %s", storageTypeToName(type));
        return false;
    }
 
    storages[type] = nullptr;
    efiPrintf("Storage %s unregistered", storageTypeToName(type));
 
    return true;
}

Referenced by deinitStorageSD(), and storageManagerThread().

Here is the call graph for this function:

Here is the caller graph for this function:

storageWrite()

StorageStatus storageWrite	(	StorageItemId	id,
		const uint8_t *	ptr,
		size_t	size
	)

Definition at line 142 of file storage.cpp.

                                                                              {
    bool success = false;
    StorageStatus status = StorageStatus::NotSupported;
 
    for_all_storages {
        if ((!storage->isReady()) || (!storage->isIdSupported(id))) {
            continue;
        }
 
        status = storage->store(id, ptr, size);
        if (status == StorageStatus::Ok) {
            success = true;
        }
    }
 
    return (success ? StorageStatus::Ok : status);
}

Referenced by LtftState::save(), and writeToFlashNowImpl().

Here is the caller graph for this function:

storageWriteID()

static bool storageWriteID ( uint32_t  id )

static

Definition at line 83 of file storage.cpp.

                                        {
    // Do the actual flash write operation for given ID
    if (id == EFI_SETTINGS_RECORD_ID) {
        return writeToFlashNowImpl();
    } else if (id == EFI_LTFT_RECORD_ID) {
        engine->module<LongTermFuelTrim>()->store();
        return true;
    } else {
        efiPrintf("Requested to write unknown record id %ld", id);
        // to clear pending bit
        return true;
    }
    return true;
}

Referenced by storageManagerThread().

Here is the call graph for this function:

Here is the caller graph for this function:

storagRequestRegisterStorage()

bool storagRequestRegisterStorage

(

StorageType

id

)

Definition at line 238 of file storage.cpp.

{
    return storageManagerSendCmd(MSG_CMD_REG, (uint32_t)id);
}

Referenced by hellenEnableEn(), and initStorage().

Here is the call graph for this function:

Here is the caller graph for this function:

storagRequestUnregisterStorage()

bool storagRequestUnregisterStorage

(

StorageType

id

)

Definition at line 243 of file storage.cpp.

{
    return storageManagerSendCmd(MSG_CMD_UNREG, (uint32_t)id);
}

Referenced by hellenDisableEn().

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 ( storageManagerThreadStack  , 3 *  UTILITY_THREAD_STACK_SIZE  )

static

THD_WORKING_AREA() [2/2]

static THD_WORKING_AREA ( storageManagerThreadStack  , UTILITY_THREAD_STACK_SIZE    )

static

Variable Documentation

pendingReads

uint32_t pendingReads = 0

static

Definition at line 249 of file storage.cpp.

Referenced by storageManagerThread().

pendingWrites

uint32_t pendingWrites = 0

static

Definition at line 248 of file storage.cpp.

Referenced by getNeedToWriteConfiguration(), and storageManagerThread().

storageManagerMb

chibios_rt::Mailbox<msg_t, 16> storageManagerMb

Definition at line 71 of file storage.cpp.

Referenced by storageManagerSendCmd(), and storageManagerThread().

storages

SettingStorageBase* storages[storagesCount]

static

Definition at line 69 of file storage.cpp.

Referenced by storageIsStorageRegistered(), storageRegisterStorage(), and storageUnregisterStorage().

storagesCount

constexpr size_t storagesCount = STORAGE_TOTAL

staticconstexpr

Definition at line 67 of file storage.cpp.

Go to the source code of this file.