commit 779565f8745f2912f9103650faa305090321c7fd Author: cfif Date: Mon Jun 2 14:32:56 2025 +0300 Init diff --git a/LittleFsInterface.c b/LittleFsInterface.c new file mode 100644 index 0000000..bb9d766 --- /dev/null +++ b/LittleFsInterface.c @@ -0,0 +1,157 @@ +// +// Created by cfif on 29.05.2024. +// +#include "LittleFsInterface.h" +#include "at32f435_437_flash.h" +#include "ext_telematica.h" +#include "ld_adr.h" + +#define FLASH_START_SECTOR ((BOOT_AREA_LENGTH + FIRMWARE_MAIN_AREA_LENGTH + FIRMWARE_MAIN_UPDATE_AREA_LENGTH + FIRMWARE_TELE_AREA_LENGTH + FIRMWARE_SETTINGS_AREA_LENGTH + FIRMWARE_SETTINGS_RECOVERY_AREA_LENGTH) / FLASH_PAGE_SIZE) // 496 +#define FLASH_STOP_SECTOR ((BOOT_AREA_LENGTH + FIRMWARE_MAIN_AREA_LENGTH + FIRMWARE_MAIN_UPDATE_AREA_LENGTH + FIRMWARE_TELE_AREA_LENGTH + FIRMWARE_SETTINGS_AREA_LENGTH + FIRMWARE_SETTINGS_RECOVERY_AREA_LENGTH + FIRMWARE_FILESYSTEM_LENGTH) / FLASH_PAGE_SIZE) // 511 + +// Read a region in a block. Negative error codes are propagated +// to the user. +int readFlashArtery(const struct lfs_config *c, lfs_block_t block, + lfs_off_t off, void *buffer, lfs_size_t size) { + +// uint32_t sectorAdr = (FLASH_START_BLOCK + block) * 0x10000 + off + FLASH_BASE; + uint32_t sectorAdr = (FLASH_START_SECTOR + block) * FLASH_PAGE_SIZE + off + FLASH_BASE; + + for (uint32_t i = 0; i < size; ++i) { + ((uint8_t *) buffer)[i] = *(uint8_t *) sectorAdr; + ++sectorAdr; + } + + return LFS_ERR_OK; +} + + +// Program a region in a block. The block must have previously +// been erased. Negative error codes are propagated to the user. +// May return LFS_ERR_CORRUPT if the block should be considered bad. +int progFlashArtery(const struct lfs_config *c, lfs_block_t block, + lfs_off_t off, const void *buffer, lfs_size_t size) { + +// uint32_t sectorAdr = (FLASH_START_BLOCK + block) * 0x10000 + off + FLASH_BASE; + uint32_t sectorAdr = (FLASH_START_SECTOR + block) * FLASH_PAGE_SIZE + off + FLASH_BASE; + + flash_unlock(); + + for (uint32_t i = 0; i < size; ++i) { + if (FLASH_OPERATE_DONE != flash_byte_program(sectorAdr + i, ((uint8_t *) buffer)[i])) { + flash_lock(); + return LFS_ERR_IO; + } + } + + flash_lock(); + + return LFS_ERR_OK; +} + + +// Erase a block. A block must be erased before being programmed. +// The state of an erased block is undefined. Negative error codes +// are propagated to the user. +// May return LFS_ERR_CORRUPT if the block should be considered bad. +int eraseFlashArtery(const struct lfs_config *c, lfs_block_t block) { + +// uint32_t sectorAdr = (FLASH_START_BLOCK + block) * 0x10000 + FLASH_BASE; + uint32_t sectorAdr = (FLASH_START_SECTOR + block) * FLASH_PAGE_SIZE + FLASH_BASE; + + flash_unlock(); + + if (FLASH_OPERATE_DONE != flash_sector_erase(sectorAdr)) { + flash_lock(); + return LFS_ERR_IO; + } + + flash_lock(); + +// W25qxx_EraseSector(block * c->block_size); + + return LFS_ERR_OK; +} + +// Sync the state of the underlying block device. Negative error codes +// are propagated to the user. +int syncFlashArtery(const struct lfs_config *c) { + + return LFS_ERR_OK; +} + + +// Lock the underlying block device. Negative error codes +// are propagated to the user. +int lockFlashArtery(const struct lfs_config *c) { + + if (osMutexAcquire(EXT_ENV_TELE.store.accessDumper, 5000) == osOK) + return LFS_ERR_OK; + + return LFS_ERR_IO; +} + +// Unlock the underlying block device. Negative error codes +// are propagated to the user. +int unlockFlashArtery(const struct lfs_config *c) { + + if (osMutexRelease(EXT_ENV_TELE.store.accessDumper) == osOK) + return LFS_ERR_OK; + + return LFS_ERR_IO; +} + +#define LFS_CACHE_SIZE (2048) +#define LFS_LOOK_HEAD_SIZE (256) + +#ifdef LFS_NO_MALLOC +uint8_t readBuffer[LFS_CACHE_SIZE]; +uint8_t writeBuffer[LFS_CACHE_SIZE]; +uint8_t lookBuffer[LFS_LOOK_HEAD_SIZE]; +uint8_t g_file_buffer[LFS_CACHE_SIZE]; +#endif + +int lfs_init_Over(lfs_t *lfs, const struct lfs_config *cfg); + +int LittleFileFsInit(tLittleFileFs *env) { + env->cfg.read = readFlashArtery; + env->cfg.prog = progFlashArtery; + env->cfg.erase = eraseFlashArtery; + env->cfg.sync = syncFlashArtery; + env->cfg.lock = lockFlashArtery; + env->cfg.unlock = unlockFlashArtery; + + // block device configuration + env->cfg.read_size = LFS_CACHE_SIZE; + env->cfg.prog_size = LFS_CACHE_SIZE; + env->cfg.block_size = FLASH_PAGE_SIZE; + env->cfg.block_count = FLASH_STOP_SECTOR - FLASH_START_SECTOR; + env->cfg.cache_size = LFS_CACHE_SIZE; + env->cfg.lookahead_size = LFS_LOOK_HEAD_SIZE; + env->cfg.block_cycles = 100; + +#ifdef LFS_NO_MALLOC + env->cfg.read_buffer = readBuffer; + env->cfg.prog_buffer = writeBuffer; + env->cfg.lookahead_buffer = lookBuffer; + + env->g_file_cfg.buffer = g_file_buffer; +#endif + int err; + + err = lfs_init_Over(&env->lfs, &env->cfg); + +// err = lfs_format(&env->lfs, &env->cfg); + + // mount the filesystem + err = lfs_mount(&env->lfs, &env->cfg); + + // reformat if we can't mount the filesystem + // this should only happen on the first boot + if (err) { + err = lfs_format(&env->lfs, &env->cfg); + err = lfs_mount(&env->lfs, &env->cfg); + } + + return err; +} \ No newline at end of file diff --git a/LittleFsInterface.h b/LittleFsInterface.h new file mode 100644 index 0000000..8164776 --- /dev/null +++ b/LittleFsInterface.h @@ -0,0 +1,21 @@ +// +// Created by cfif on 29.05.2024. +// + +#ifndef SMART_COMPONENTS_LITTLEFSINTERFACE_H +#define SMART_COMPONENTS_LITTLEFSINTERFACE_H + +#include "cmsis_os2.h" +#include "lfs.h" + +typedef struct { + lfs_t lfs; + struct lfs_config cfg; +#ifdef LFS_NO_MALLOC + struct lfs_file_config g_file_cfg; +#endif +} tLittleFileFs; + +int LittleFileFsInit(tLittleFileFs *env); + +#endif //SMART_COMPONENTS_LITTLEFSINTERFACE_H diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..0dd1901 --- /dev/null +++ b/modular.json @@ -0,0 +1,10 @@ +{ + "cmake": { + "inc_dirs": [ + "./" + ], + "srcs": [ + "./**.c" + ] + } +} \ No newline at end of file