10 files changed, 49 insertions(+), 39 deletions(-)

M module-bsp/board/linux/eeprom/eeprom.cpp
M module-bsp/board/rt1051/bsp/eeprom/eeprom.cpp
M module-bsp/bsp/eeprom/eeprom.hpp
M module-vfs/board/rt1051/purefs/include/purefs/blkdev/disk_emmc.hpp
M module-vfs/board/rt1051/purefs/src/blkdev/disk_eeprom.cpp
M module-vfs/board/rt1051/purefs/src/blkdev/disk_emmc.cpp
M module-vfs/board/rt1051/purefs/src/vfs_subsystem_internal.cpp
M module-vfs/drivers/src/thirdparty/littlefs/lfs_glue.cpp
M module-vfs/include/user/purefs/blkdev/disk.hpp
M module-vfs/src/purefs/blkdev/disk.cpp

@@ 6,9 6,8 @@
 
 namespace bsp::eeprom
 {
-    int init()
+    void init()
     {
-        return true;
     }
 
     bool isPresent(int busid)


@@ 36,4 35,4 @@ namespace bsp::eeprom
         return 0;
     }
 
-} // namespace bsp::eeprom>
\ No newline at end of file
+} // namespace bsp::eeprom

@@ 22,12 22,11 @@ namespace bsp::eeprom
 
     } // namespace
 
-    int init()
+    void init()
     {
         drivers::DriverI2CParams i2cParams;
         i2cParams.baudrate = static_cast<std::uint32_t>(BoardDefinitions::EEPROM_I2C_BAUDRATE);
         i2c = drivers::DriverI2C::Create(static_cast<drivers::I2CInstances>(BoardDefinitions::EEPROM_I2C), i2cParams);
-        return 0;
     }
 
     bool isPresent(int busid)


@@ 58,7 57,8 @@ namespace bsp::eeprom
                 written += i2c->Write(addr, reinterpret_cast<std::uint8_t *>(ptr), static_cast<size_t>(bl_len));
                 vTaskDelay(pdMS_TO_TICKS(10));
                 ptr += bl_len;
-                addr.subAddress += bl_len;
+                mem_addr += bl_len;
+                addr.subAddress = __builtin_bswap16(mem_addr);
             }
         }
         // reminder


@@ 90,7 90,8 @@ namespace bsp::eeprom
                 LOG_DEBUG("[EEPROM - R] reading chunk %d of %d", i, chunks);
                 read += i2c->Read(addr, reinterpret_cast<std::uint8_t *>(ptr), static_cast<size_t>(bl_len));
                 ptr += bl_len;
-                addr.subAddress += bl_len;
+                mem_addr += bl_len;
+                addr.subAddress = __builtin_bswap16(mem_addr);
             }
         }
         // reminder

@@ 12,9 12,9 @@ extern "C"
 
 namespace bsp::eeprom
 {
-    typedef std::uint32_t addr_t;
+    typedef std::uint16_t addr_t;
 
-    int init();
+    void init();
 
     bool isPresent(int busid);
 

@@ 33,7 33,6 @@ namespace purefs::blkdev
         auto sync() -> int override;
         auto status() const -> media_status override;
         auto get_info(info_type what, hwpart_t hwpart) const -> scount_t override;
-        auto erase(sector_t lba, std::size_t count, hwpart_t hwpart) -> int override;
         auto pm_control(pm_state target_state) -> int override;
         auto pm_read(pm_state &current_state) -> int override;
 

@@ 10,10 10,7 @@ namespace purefs::blkdev
     auto disk_eeprom::probe(unsigned flags) -> int
     {
         cpp_freertos::LockGuard lock(mutex);
-        const auto error = bsp::eeprom::init();
-        if (error) {
-            return -EIO;
-        }
+        bsp::eeprom::init();
         if (!bsp::eeprom::isPresent(bus_id)) {
             return -ENXIO;
         }


@@ 27,10 24,10 @@ namespace purefs::blkdev
 
     auto disk_eeprom::get_info(info_type what, hwpart_t hwpart) const -> scount_t
     {
-        cpp_freertos::LockGuard lock(mutex);
         if (hwpart > 0) {
             return -ERANGE;
         }
+        cpp_freertos::LockGuard lock(mutex);
         switch (what) {
         case info_type::sector_size:
             return bsp::eeprom::eeprom_block_size(bus_id);


@@ 45,10 42,10 @@ namespace purefs::blkdev
 
     auto disk_eeprom::write(const void *buf, sector_t lba, std::size_t count, hwpart_t hwpart) -> int
     {
-        cpp_freertos::LockGuard lock(mutex);
         if (hwpart > 0) {
             return -ERANGE;
         }
+        cpp_freertos::LockGuard lock(mutex);
         const size_t block_siz = bsp::eeprom::eeprom_block_size(bus_id);
         const size_t total_siz = bsp::eeprom::eeprom_total_size(bus_id);
         const auto addr        = lba * block_siz;


@@ 56,16 53,16 @@ namespace purefs::blkdev
         if (addr + len > total_siz) {
             return -ERANGE;
         }
-        const auto nwr = bsp::eeprom::eeprom_write(bus_id, addr, reinterpret_cast<const char *>(buf), len);
-        return (nwr != int(len)) ? (-ENXIO) : (0);
+        const auto bytes_written = bsp::eeprom::eeprom_write(bus_id, addr, reinterpret_cast<const char *>(buf), len);
+        return (bytes_written != int(len)) ? (-ENXIO) : (0);
     }
 
     auto disk_eeprom::read(void *buf, sector_t lba, std::size_t count, hwpart_t hwpart) -> int
     {
-        cpp_freertos::LockGuard lock(mutex);
         if (hwpart > 0) {
             return -ERANGE;
         }
+        cpp_freertos::LockGuard lock(mutex);
         const size_t block_siz = bsp::eeprom::eeprom_block_size(bus_id);
         const size_t total_siz = bsp::eeprom::eeprom_total_size(bus_id);
         const auto addr        = lba * block_siz;


@@ 73,7 70,7 @@ namespace purefs::blkdev
         if (addr + len > total_siz) {
             return -ERANGE;
         }
-        const auto nwr = bsp::eeprom::eeprom_read(bus_id, addr, reinterpret_cast<char *>(buf), len);
-        return (nwr != int(len)) ? (-ENXIO) : (0);
+        const auto bytes_read = bsp::eeprom::eeprom_read(bus_id, addr, reinterpret_cast<char *>(buf), len);
+        return (bytes_read != int(len)) ? (-ENXIO) : (0);
     }
 } // namespace purefs::blkdev

@@ 75,12 75,6 @@ namespace purefs::blkdev
         return statusBlkDevSuccess;
     }
 
-    auto disk_emmc::erase(sector_t lba, std::size_t count, hwpart_t hwpart) -> int
-    {
-        // erase group size is 512kB so it has been deliberately disallowed
-        // group of this size would make the solution inefficient in this case
-        return statusBlkDevSuccess;
-    }
     auto disk_emmc::read(void *buf, sector_t lba, std::size_t count, hwpart_t hwpart) -> int
     {
         cpp_freertos::LockGuard lock(mutex);

@@ 5,13 5,10 @@
 #include <purefs/blkdev/disk_manager.hpp>
 #include <purefs/blkdev/disk_emmc.hpp>
 #include <purefs/blkdev/disk_eeprom.hpp>
+#include "board/rt1051/bsp/eeprom/M24256.hpp"
 
 namespace purefs::subsystem::internal
 {
-    namespace
-    {
-        constexpr auto eeprom_bus_address = 0xA0 >> 1;
-    }
     auto create_default_block_device() -> std::shared_ptr<blkdev::disk>
     {
         return std::make_shared<purefs::blkdev::disk_emmc>();


@@ 19,6 16,6 @@ namespace purefs::subsystem::internal
 
     auto create_default_nvm_device() -> std::shared_ptr<blkdev::disk>
     {
-        return std::make_shared<purefs::blkdev::disk_eeprom>(eeprom_bus_address);
+        return std::make_shared<purefs::blkdev::disk_eeprom>(bsp::eeprom::M24256_MEM_DEVICE_ADDR);
     }
 } // namespace purefs::subsystem::internal

@@ 20,12 20,16 @@ namespace purefs::fs::drivers::littlefs::internal
             class io_context
             {
               public:
-                io_context(std::shared_ptr<blkdev::disk_manager> diskmm, blkdev::disk_fd diskh, size_t _sector_size)
-                    : disk(diskmm), disk_h(diskh), sector_size(_sector_size)
+                io_context(std::shared_ptr<blkdev::disk_manager> diskmm,
+                           blkdev::disk_fd diskh,
+                           size_t _sector_size,
+                           size_t _erase_block)
+                    : disk(diskmm), disk_h(diskh), sector_size(_sector_size), erase_block(_erase_block)
                 {}
                 const std::weak_ptr<blkdev::disk_manager> disk;
                 const blkdev::disk_fd disk_h;
                 const size_t sector_size;
+                const size_t erase_block;
                 mutable cpp_freertos::MutexRecursive mutex;
             };
 


@@ 121,6 125,10 @@ namespace purefs::fs::drivers::littlefs::internal
                 if (!ctx) {
                     return LFS_ERR_IO;
                 }
+                if (ctx->erase_block == 0) {
+                    // Erase not supported
+                    return LFS_ERR_OK;
+                }
                 auto diskmm = ctx->disk.lock();
                 if (!diskmm) {
                     return LFS_ERR_IO;


@@ 173,7 181,12 @@ namespace purefs::fs::drivers::littlefs::internal
             LOG_ERROR("Unable to get sector size %li", long(sect_size));
             return sect_size;
         }
-        auto ctx      = new lfs_io::io_context(diskmm, diskh, sect_size);
+        const auto erase_size = diskmm->get_info(diskh, blkdev::info_type::erase_block);
+        if (erase_size < 0) {
+            LOG_ERROR("Unable to get erase block size %li", long(erase_size));
+            return erase_size;
+        }
+        auto ctx      = new lfs_io::io_context(diskmm, diskh, sect_size, erase_size);
         lfsc->context = ctx;
         lfsc->read    = lfs_io::read;
         lfsc->prog    = lfs_io::prog;

@@ 25,7 25,7 @@ namespace purefs::blkdev
         /** Disk cleanup just before unregistering
          * @return  zero on success otherwise error
          */
-        virtual auto cleanup() -> int = 0;
+        virtual auto cleanup() -> int;
 
         /** Write a data onto block device or partition
          * @param[in] buf Data buffer to write


@@ 56,7 56,7 @@ namespace purefs::blkdev
         /** Flush buffers and write all data into the physical device
          * @return zero or success otherwise error
          */
-        virtual auto sync() -> int = 0;
+        virtual auto sync() -> int;
 
         /** Set block device power state
          * @param[in] target_state Set the target power state

@@ 12,10 12,20 @@ namespace purefs::blkdev
     }
     auto disk::pm_control(pm_state target_state) -> int
     {
-        return -ENOTSUP;
+        return 0;
     }
     auto disk::pm_read(pm_state &current_state) -> int
     {
-        return -ENOTSUP;
+        current_state = pm_state::active;
+        return 0;
+    }
+    auto disk::sync() -> int
+    {
+        return 0;
     }
+    auto disk::cleanup() -> int
+    {
+        return 0;
+    }
+
 } // namespace purefs::blkdev