lx_fs_backend.c

Go to the documentation of this file.

 
#include "lx_fs_backend.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"

static const char* const s_tag = "lx_fs_be";

typedef enum : uint32_t {
  k_lx_fsbe_sector_bytes = 512U,  
  k_lx_fsbe_erased_byte  = 0xFFU, 
} lx_fs_backend_geometry_t;
 
static_assert((uint32_t)LX_NOR_SECTOR_SIZE * (uint32_t)sizeof(ULONG) ==
                (uint32_t)k_lx_fsbe_sector_bytes,
              "LevelX logical sector must be 512 bytes");

static ULONG s_lx_fsbe_bounce[LX_NOR_SECTOR_SIZE];

RA8_INTERNAL static uint64_t internal_usable_sectors(const LX_NOR_FLASH* nor_flash)
{
  uint64_t phys_per_block = (uint64_t)nor_flash->lx_nor_flash_physical_sectors_per_block;
  if (phys_per_block <= 1U) {
    return 0U;
  }
  uint64_t total_blocks = (uint64_t)nor_flash->lx_nor_flash_total_blocks;
  return total_blocks * (phys_per_block - 1U);
}

RA8_INTERNAL static ra8_err_t
internal_read_block(void* ctx, uint64_t lba, uint32_t count, uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf");
  LX_NOR_FLASH* nor_flash = ctx;
  if ((lba + (uint64_t)count) > internal_usable_sectors(nor_flash)) {
    return k_ra8_err_out_of_range;
  }
  for (uint32_t i = 0U; i < count; i++) {
    uint8_t* dst = &buf[(size_t)i * (size_t)k_lx_fsbe_sector_bytes];
    UINT     rc = lx_nor_flash_sector_read(nor_flash, (ULONG)(lba + (uint64_t)i), s_lx_fsbe_bounce);
    if (rc == (UINT)LX_SECTOR_NOT_FOUND) {
      (void)memset(dst, (int)k_lx_fsbe_erased_byte, (size_t)k_lx_fsbe_sector_bytes);
    } else if (rc != (UINT)LX_SUCCESS) {
      return k_ra8_err_hw_init_failed;
    } else {
      (void)memcpy(dst, s_lx_fsbe_bounce, (size_t)k_lx_fsbe_sector_bytes);
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_write_block(void* ctx, uint64_t lba, uint32_t count, const uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf");
  LX_NOR_FLASH* nor_flash = ctx;
  if ((lba + (uint64_t)count) > internal_usable_sectors(nor_flash)) {
    return k_ra8_err_out_of_range;
  }
  for (uint32_t i = 0U; i < count; i++) {
    const uint8_t* src = &buf[(size_t)i * (size_t)k_lx_fsbe_sector_bytes];
    (void)memcpy(s_lx_fsbe_bounce, src, (size_t)k_lx_fsbe_sector_bytes);
    UINT rc = lx_nor_flash_sector_write(nor_flash, (ULONG)(lba + (uint64_t)i), s_lx_fsbe_bounce);
    if (rc != (UINT)LX_SUCCESS) {
      return k_ra8_err_hw_init_failed;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_get_capacity(void* ctx, uint64_t* block_count, uint32_t* block_size)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  RA8_CHECK_NULL_PTR(block_count, s_tag, "block_count");
  RA8_CHECK_NULL_PTR(block_size, s_tag, "block_size");
  uint64_t usable = internal_usable_sectors(ctx);
  if (usable == 0U) {
    return k_ra8_err_not_initialized;
  }
  *block_count = usable;
  *block_size  = (uint32_t)k_lx_fsbe_sector_bytes;
  return k_ra8_ok;
}

ra8_err_t lx_fs_backend_bind(LX_NOR_FLASH* nor_flash, ra8_fs_backend_t* out)
{
  RA8_CHECK_NULL_PTR(nor_flash, s_tag, "nor_flash");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
  if (internal_usable_sectors(nor_flash) == 0U) {
    return k_ra8_err_not_initialized;
  }
  out->read_block   = internal_read_block;
  out->write_block  = internal_write_block;
  out->get_capacity = internal_get_capacity;
  out->erase_blocks = nullptr; /* NOR erases to ones; ra8_fs wants zero-erase. */
  out->ctx          = nor_flash;
  return k_ra8_ok;
}