ra8_io_blockdev_mram.c

Go to the documentation of this file.

 
#include "ra8_io_blockdev_mram.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_flash.h"
#include "ra8_flash_regs.h"
#include "ra8_io_blockdev.h"
#include "ra8_io_blockdev_backend.h"

static const char* const s_tag = "ra8_io_blockdev_mram";

typedef enum : uint32_t {
  k_ra8_io_mram_erase_block_bytes = (uint32_t)k_ra8_mram_block_size_bytes,
  k_ra8_io_mram_program_bytes = (uint32_t)k_ra8_mram_write_size_bytes,
  k_ra8_io_mram_erase_unit_blocks = 1U,
  k_ra8_io_mram_min_blocks = 1U, 
  k_ra8_io_mram_zero_len   = 0U, 
} ra8_io_mram_const_t;

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_mram_bounds(const ra8_io_blockdev_mram_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_mram_window_ok(uintptr_t base, uint32_t block_count)
{
  const uintptr_t extra_start = (uintptr_t)k_ra8_flash_extra_start;
  const uintptr_t extra_end   = extra_start + (uintptr_t)k_ra8_flash_extra_size;
  const uintptr_t span        = (uintptr_t)block_count * (uintptr_t)k_ra8_io_block_size_bytes;
  if ((base % (uintptr_t)k_ra8_io_mram_erase_block_bytes) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  if ((span % (uintptr_t)k_ra8_io_mram_erase_block_bytes) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (base < extra_start) {
    return k_ra8_err_invalid_arg;
  }
  if (base >= extra_end) {
    return k_ra8_err_invalid_arg;
  }
  if (span > extra_end - base) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_mram_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_mram_state_t* st = (const ra8_io_blockdev_mram_state_t*)ctx;
  const ra8_err_t                     b  = internal_mram_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, (const uint8_t*)(st->base + (uintptr_t)off), n);
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_mram_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_mram_state_t* st = (const ra8_io_blockdev_mram_state_t*)ctx;
  if (st->read_only) {
    return k_ra8_err_not_supported;
  }
  const ra8_err_t b = internal_mram_bounds(st, lba, count);
  if (b != k_ra8_ok) {
    return b;
  }
  const uintptr_t off  = (uintptr_t)lba * (uintptr_t)k_ra8_io_block_size_bytes;
  const uintptr_t span = (uintptr_t)count * (uintptr_t)k_ra8_io_block_size_bytes;
  const uint32_t  step = (uint32_t)k_ra8_io_mram_program_bytes;
  for (uintptr_t done = (uintptr_t)k_ra8_io_mram_zero_len; done < span; done += step) {
    const ra8_err_t w =
      ra8_flash_extra_mram_write((uint32_t)(st->base + off + done), &buf[done], step);
    if (w != k_ra8_ok) {
      return w;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_mram_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_mram_state_t* st = (const ra8_io_blockdev_mram_state_t*)ctx;
  if (st->read_only) {
    return k_ra8_err_not_supported;
  }
  const ra8_err_t b = internal_mram_bounds(st, lba, count);
  if (b != k_ra8_ok) {
    return b;
  }
  const uintptr_t off  = (uintptr_t)lba * (uintptr_t)k_ra8_io_block_size_bytes;
  const uintptr_t span = (uintptr_t)count * (uintptr_t)k_ra8_io_block_size_bytes;
  const uint32_t  step = (uint32_t)k_ra8_io_mram_erase_block_bytes;
  for (uintptr_t done = (uintptr_t)k_ra8_io_mram_zero_len; done < span; done += step) {
    const ra8_err_t e = ra8_flash_extra_mram_erase((uint32_t)(st->base + off + done));
    if (e != k_ra8_ok) {
      return e;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_mram_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_mram_state_t* st = (const ra8_io_blockdev_mram_state_t*)ctx;
  out->block_count                       = st->block_count;
  out->erase_unit_blocks                 = (uint32_t)k_ra8_io_mram_erase_unit_blocks;
  out->program_size_bytes                = (uint32_t)k_ra8_io_mram_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_mram_iface = {
  .read     = internal_mram_read,
  .write    = internal_mram_write,
  .erase    = internal_mram_erase,
  .get_caps = internal_mram_get_caps,
  .sync     = nullptr,
};
 
ra8_err_t ra8_io_blockdev_mram_init(ra8_io_blockdev_t*            bd,
                                    ra8_io_blockdev_mram_state_t* state,
                                    uintptr_t                     base_addr,
                                    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");
  if (block_count < (uint32_t)k_ra8_io_mram_min_blocks) {
    return k_ra8_err_invalid_arg;
  }
  const ra8_err_t w = internal_mram_window_ok(base_addr, block_count);
  if (w != k_ra8_ok) {
    return w;
  }
  state->base        = base_addr;
  state->block_count = block_count;
  state->read_only   = read_only;
  bd->iface          = &s_mram_iface;
  bd->ctx            = state;
  return k_ra8_ok;
}