ra8_io_blockdev_ram.c

Go to the documentation of this file.

 
#include "ra8_io_blockdev_ram.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"

static const char* const s_tag = "ra8_io_blockdev_ram";

typedef enum : uint32_t {
  k_ra8_io_ram_erase_unit_blocks = 1, 
  k_ra8_io_ram_min_blocks        = 1, 
} ra8_io_ram_const_t;

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_ram_bounds(const ra8_io_blockdev_ram_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_ram_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_ram_state_t* st = (const ra8_io_blockdev_ram_state_t*)ctx;
  const ra8_err_t                    b  = internal_ram_bounds(st, lba, count);
  if (b != k_ra8_ok) {
    return b;
  }
  const size_t off = (size_t)lba * (size_t)k_ra8_io_block_size_bytes;
  const size_t n   = (size_t)count * (size_t)k_ra8_io_block_size_bytes;
  (void)memcpy(buf, &st->storage[off], n);
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_ram_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");
  ra8_io_blockdev_ram_state_t* st = (ra8_io_blockdev_ram_state_t*)ctx;
  if (st->read_only) {
    return k_ra8_err_not_supported;
  }
  const ra8_err_t b = internal_ram_bounds(st, lba, count);
  if (b != k_ra8_ok) {
    return b;
  }
  const size_t off = (size_t)lba * (size_t)k_ra8_io_block_size_bytes;
  const size_t n   = (size_t)count * (size_t)k_ra8_io_block_size_bytes;
  (void)memcpy(&st->storage[off], buf, n);
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_ram_erase(void* ctx, uint32_t lba, uint32_t count)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  ra8_io_blockdev_ram_state_t* st = (ra8_io_blockdev_ram_state_t*)ctx;
  if (st->read_only) {
    return k_ra8_err_not_supported;
  }
  const ra8_err_t b = internal_ram_bounds(st, lba, count);
  if (b != k_ra8_ok) {
    return b;
  }
  const size_t off = (size_t)lba * (size_t)k_ra8_io_block_size_bytes;
  const size_t n   = (size_t)count * (size_t)k_ra8_io_block_size_bytes;
  (void)memset(&st->storage[off], (int)k_ra8_io_erase_value_zero, n);
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_ram_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_ram_state_t* st = (const ra8_io_blockdev_ram_state_t*)ctx;
  out->block_count                      = st->block_count;
  out->erase_unit_blocks                = (uint32_t)k_ra8_io_ram_erase_unit_blocks;
  out->program_size_bytes               = (uint32_t)k_ra8_io_block_size_bytes;
  out->logical_block_bytes              = (uint16_t)k_ra8_io_block_size_bytes;
  out->erase_value                      = (uint8_t)k_ra8_io_erase_value_zero;
  out->must_erase_before_write          = false;
  out->read_only                        = st->read_only;
  return k_ra8_ok;
}

static const ra8_io_blockdev_iface_t s_ram_iface = {
  .read     = internal_ram_read,
  .write    = internal_ram_write,
  .erase    = internal_ram_erase,
  .get_caps = internal_ram_get_caps,
  .sync     = nullptr,
};
 
ra8_err_t ra8_io_blockdev_ram_init(ra8_io_blockdev_t*           bd,
                                   ra8_io_blockdev_ram_state_t* state,
                                   uint8_t*                     storage,
                                   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");
  RA8_CHECK_NULL_PTR(storage, s_tag, "storage must not be nullptr");
  if (block_count < (uint32_t)k_ra8_io_ram_min_blocks) {
    return k_ra8_err_invalid_size;
  }
  state->storage     = storage;
  state->block_count = block_count;
  state->read_only   = read_only;
  bd->iface          = &s_ram_iface;
  bd->ctx            = state;
  return k_ra8_ok;
}