ra8_io_blockdev_xspi.c

Go to the documentation of this file.

 
#include "ra8_io_blockdev_xspi.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_io_blockdev.h"
#include "ra8_io_blockdev_backend.h"
#include "ra8_ospi_regs.h"
#include "ra8_xspi.h"

static const char* const s_tag = "ra8_io_blockdev_xspi";

typedef enum : uint32_t {
  k_xspi_sector_bytes      = 4096, 
  k_xspi_blocks_per_sector = 8,    
  k_xspi_program_bytes     = 256,  
  k_xspi_zero_blocks       = 0,    
  k_xspi_min_instance      = 0,    
} ra8_io_xspi_const_t;

static uint8_t s_sector[k_xspi_sector_bytes];

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_xspi_bounds(const ra8_io_blockdev_xspi_state_t* st, uint32_t lba, uint32_t count)
{
  if (count > st->block_count) {
    return k_ra8_err_out_of_range;
  }
  if (lba > st->block_count - count) {
    return k_ra8_err_out_of_range;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_xspi_read_chunked(uint8_t instance, uint32_t flash_addr, uint8_t* buf, uint32_t len)
{
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  uint32_t done = k_xspi_zero_blocks;
  while (done < len) {
    const uint32_t remaining = len - done;
    const uint32_t chunk =
      (remaining > (uint32_t)k_ra8_xspi_max_xfer) ? (uint32_t)k_ra8_xspi_max_xfer : remaining;
    const ra8_err_t e = ra8_xspi_flash_read(instance, flash_addr + done, &buf[done], chunk);
    if (e != k_ra8_ok) {
      return e;
    }
    done += chunk;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_xspi_program_chunked(uint8_t        instance,
                                               uint32_t       flash_addr,
                                               const uint8_t* data,
                                               uint32_t       len)
{
  RA8_CHECK_NULL_PTR(data, s_tag, "data must not be nullptr");
  uint32_t done = k_xspi_zero_blocks;
  while (done < len) {
    const uint32_t remaining = len - done;
    const uint32_t chunk =
      (remaining > (uint32_t)k_ra8_xspi_max_xfer) ? (uint32_t)k_ra8_xspi_max_xfer : remaining;
    const ra8_err_t e = ra8_xspi_flash_program(instance, flash_addr + done, &data[done], chunk);
    if (e != k_ra8_ok) {
      return e;
    }
    done += chunk;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_write_one_sector(const ra8_io_blockdev_xspi_state_t* st,
                                                        uint32_t       sector_lba,
                                                        uint32_t       first_blk,
                                                        uint32_t       n_blocks,
                                                        const uint8_t* src)
{
  RA8_CHECK_NULL_PTR(st, s_tag, "st must not be nullptr");
  RA8_CHECK_NULL_PTR(src, s_tag, "src must not be nullptr");
  const uint32_t  sec_addr = st->base_off + (sector_lba * (uint32_t)k_ra8_io_block_size_bytes);
  const ra8_err_t r =
    internal_xspi_read_chunked(st->instance, sec_addr, s_sector, (uint32_t)k_xspi_sector_bytes);
  if (r != k_ra8_ok) {
    return r;
  }
  const size_t dst_off = (size_t)first_blk * (size_t)k_ra8_io_block_size_bytes;
  const size_t n_bytes = (size_t)n_blocks * (size_t)k_ra8_io_block_size_bytes;
  (void)memcpy(&s_sector[dst_off], src, n_bytes);
  const ra8_err_t e = ra8_xspi_flash_erase_sector(st->instance, sec_addr);
  if (e != k_ra8_ok) {
    return e;
  }
  return internal_xspi_program_chunked(st->instance,
                                       sec_addr,
                                       s_sector,
                                       (uint32_t)k_xspi_sector_bytes);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_xspi_read(void* ctx, uint32_t lba, uint32_t count, uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  const ra8_io_blockdev_xspi_state_t* st = (const ra8_io_blockdev_xspi_state_t*)ctx;
  const ra8_err_t                     b  = internal_xspi_bounds(st, lba, count);
  if (b != k_ra8_ok) {
    return b;
  }
  const uint32_t addr = st->base_off + (lba * (uint32_t)k_ra8_io_block_size_bytes);
  const uint32_t len  = count * (uint32_t)k_ra8_io_block_size_bytes;
  return internal_xspi_read_chunked(st->instance, addr, buf, len);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_xspi_write(void* ctx, uint32_t lba, uint32_t count, const uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  const ra8_io_blockdev_xspi_state_t* st = (const ra8_io_blockdev_xspi_state_t*)ctx;
  if (st->read_only) {
    return k_ra8_err_not_supported;
  }
  const ra8_err_t b = internal_xspi_bounds(st, lba, count);
  if (b != k_ra8_ok) {
    return b;
  }
  uint32_t done = k_xspi_zero_blocks;
  while (done < count) {
    const uint32_t  blk        = lba + done;
    const uint32_t  first_blk  = blk % (uint32_t)k_xspi_blocks_per_sector;
    const uint32_t  sector_lba = blk - first_blk;
    const uint32_t  room       = (uint32_t)k_xspi_blocks_per_sector - first_blk;
    const uint32_t  left       = count - done;
    const uint32_t  n_blocks   = (left < room) ? left : room;
    const uint8_t*  src        = &buf[(size_t)done * (size_t)k_ra8_io_block_size_bytes];
    const ra8_err_t e = internal_write_one_sector(st, sector_lba, first_blk, n_blocks, src);
    if (e != k_ra8_ok) {
      return e;
    }
    done += n_blocks;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
/* cppcheck-suppress constParameterCallback -- ra8_io_blockdev_ops_t fixes this callback's context type as void*. */
static ra8_err_t internal_xspi_erase(void* ctx, uint32_t lba, uint32_t count)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  const ra8_io_blockdev_xspi_state_t* st = (const ra8_io_blockdev_xspi_state_t*)ctx;
  if (st->read_only) {
    return k_ra8_err_not_supported;
  }
  if ((lba % (uint32_t)k_xspi_blocks_per_sector) != k_xspi_zero_blocks) {
    return k_ra8_err_invalid_arg;
  }
  if ((count % (uint32_t)k_xspi_blocks_per_sector) != k_xspi_zero_blocks) {
    return k_ra8_err_invalid_arg;
  }
  const ra8_err_t b = internal_xspi_bounds(st, lba, count);
  if (b != k_ra8_ok) {
    return b;
  }
  uint32_t blk = lba;
  while (blk < lba + count) {
    const uint32_t  addr = st->base_off + (blk * (uint32_t)k_ra8_io_block_size_bytes);
    const ra8_err_t e    = ra8_xspi_flash_erase_sector(st->instance, addr);
    if (e != k_ra8_ok) {
      return e;
    }
    blk += (uint32_t)k_xspi_blocks_per_sector;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_xspi_get_caps(const void* ctx, ra8_io_blockdev_caps_t* out)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  const ra8_io_blockdev_xspi_state_t* st = (const ra8_io_blockdev_xspi_state_t*)ctx;
  out->block_count                       = st->block_count;
  out->erase_unit_blocks                 = (uint32_t)k_xspi_blocks_per_sector;
  out->program_size_bytes                = (uint32_t)k_xspi_program_bytes;
  out->logical_block_bytes               = (uint16_t)k_ra8_io_block_size_bytes;
  out->erase_value                       = (uint8_t)k_ra8_io_erase_value_ones;
  out->must_erase_before_write           = true;
  out->read_only                         = st->read_only;
  return k_ra8_ok;
}

static const ra8_io_blockdev_iface_t s_xspi_iface = {
  .read     = internal_xspi_read,
  .write    = internal_xspi_write,
  .erase    = internal_xspi_erase,
  .get_caps = internal_xspi_get_caps,
  .sync     = nullptr,
};

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_xspi_check_geom(uint8_t instance, uint32_t base_off, uint32_t block_count)
{
  if (instance >= (uint8_t)k_ra8_xspi_instance_count) {
    return k_ra8_err_invalid_arg;
  }
  if ((base_off % (uint32_t)k_xspi_sector_bytes) != k_xspi_zero_blocks) {
    return k_ra8_err_invalid_arg;
  }
  if (block_count == k_xspi_zero_blocks) {
    return k_ra8_err_invalid_arg;
  }
  if ((block_count % (uint32_t)k_xspi_blocks_per_sector) != k_xspi_zero_blocks) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_blockdev_xspi_init(ra8_io_blockdev_t*            bd,
                                    ra8_io_blockdev_xspi_state_t* state,
                                    uint8_t                       instance,
                                    uint32_t                      base_off,
                                    uint32_t                      block_count,
                                    bool                          read_only)
{
  RA8_CHECK_NULL_PTR(bd, s_tag, "bd must not be nullptr");
  RA8_CHECK_NULL_PTR(state, s_tag, "state must not be nullptr");
  const ra8_err_t g = internal_xspi_check_geom(instance, base_off, block_count);
  if (g != k_ra8_ok) {
    return g;
  }
  state->instance    = instance;
  state->base_off    = base_off;
  state->block_count = block_count;
  state->read_only   = read_only;
  bd->iface          = &s_xspi_iface;
  bd->ctx            = state;
  return k_ra8_ok;
}
 
static_assert((uint32_t)k_xspi_sector_bytes ==
                ((uint32_t)k_xspi_blocks_per_sector * (uint32_t)k_ra8_io_block_size_bytes),
              "sector must equal blocks_per_sector * logical block size");