ra8_io_blockdev.c

Go to the documentation of this file.

 
#include "ra8_io_blockdev.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_io_blockdev_backend.h"
#include "ra8_log.h"

static const char* const s_tag = "ra8_io_blockdev";
 
/* =============================================================================
 * Internal helpers
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t internal_validate(const ra8_io_blockdev_t* bd)
{
  if (bd == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (bd->iface == nullptr) {
    return k_ra8_err_not_initialized;
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * Public API -- dispatch through the bound backend
 * =============================================================================
 */
 
ra8_err_t
ra8_io_blockdev_read(const ra8_io_blockdev_t* bd, uint32_t lba, uint32_t count, uint8_t* buf)
{
  const ra8_err_t v = internal_validate(bd);
  if (v != k_ra8_ok) {
    return v;
  }
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  RA8_CHECK_NULL_PTR(bd->iface->read, s_tag, "backend read op missing");
  return bd->iface->read(bd->ctx, lba, count, buf);
}
 
ra8_err_t
ra8_io_blockdev_write(const ra8_io_blockdev_t* bd, uint32_t lba, uint32_t count, const uint8_t* buf)
{
  const ra8_err_t v = internal_validate(bd);
  if (v != k_ra8_ok) {
    return v;
  }
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  RA8_CHECK_NULL_PTR(bd->iface->write, s_tag, "backend write op missing");
  return bd->iface->write(bd->ctx, lba, count, buf);
}
 
ra8_err_t ra8_io_blockdev_erase(const ra8_io_blockdev_t* bd, uint32_t lba, uint32_t count)
{
  const ra8_err_t v = internal_validate(bd);
  if (v != k_ra8_ok) {
    return v;
  }
  if (bd->iface->erase == nullptr) {
    return k_ra8_err_not_supported;
  }
  return bd->iface->erase(bd->ctx, lba, count);
}
 
ra8_err_t ra8_io_blockdev_get_caps(const ra8_io_blockdev_t* bd, ra8_io_blockdev_caps_t* out)
{
  const ra8_err_t v = internal_validate(bd);
  if (v != k_ra8_ok) {
    return v;
  }
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  RA8_CHECK_NULL_PTR(bd->iface->get_caps, s_tag, "backend get_caps op missing");
  return bd->iface->get_caps(bd->ctx, out);
}
 
ra8_err_t ra8_io_blockdev_sync(const ra8_io_blockdev_t* bd)
{
  const ra8_err_t v = internal_validate(bd);
  if (v != k_ra8_ok) {
    return v;
  }
  if (bd->iface->sync == nullptr) {
    return k_ra8_ok;
  }
  return bd->iface->sync(bd->ctx);
}
 
/* =============================================================================
 * ra8_fs_backend_t bridge
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t internal_fs_read(void* ctx, uint64_t lba, uint32_t count, uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx (blockdev) must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  /* The io fabric addresses 32-bit LBAs -- every backend it fronts (SD, XSPI,
   * SDRAM, MRAM) fits comfortably -- so an address past that reach is refused
   * here rather than truncated. The 64-bit `ra8_fs` interface (#683) stays
   * fully honest: media needing it use a 64-bit-native backend. */
  if (lba > (uint64_t)UINT32_MAX) {
    return k_ra8_err_out_of_range;
  }
  return ra8_io_blockdev_read((const ra8_io_blockdev_t*)ctx, (uint32_t)lba, count, buf);
}

RA8_INTERNAL
static ra8_err_t internal_fs_write(void* ctx, uint64_t lba, uint32_t count, const uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx (blockdev) must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  if (lba > (uint64_t)UINT32_MAX) {
    return k_ra8_err_out_of_range; /* fabric LBAs are 32-bit; see internal_fs_read */
  }
  return ra8_io_blockdev_write((const ra8_io_blockdev_t*)ctx, (uint32_t)lba, count, buf);
}

RA8_INTERNAL
static ra8_err_t internal_fs_get_capacity(void* ctx, uint64_t* block_count, uint32_t* block_size)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx (blockdev) must not be nullptr");
  RA8_CHECK_NULL_PTR(block_count, s_tag, "block_count must not be nullptr");
  RA8_CHECK_NULL_PTR(block_size, s_tag, "block_size must not be nullptr");
  ra8_io_blockdev_caps_t caps = {};
  const ra8_err_t        e    = ra8_io_blockdev_get_caps((const ra8_io_blockdev_t*)ctx, &caps);
  if (e != k_ra8_ok) {
    return e;
  }
  *block_count = caps.block_count;
  *block_size  = (uint32_t)caps.logical_block_bytes;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fs_erase(void* ctx, uint64_t lba, uint64_t count)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx (blockdev) must not be nullptr");
  const ra8_io_blockdev_t* bd   = (const ra8_io_blockdev_t*)ctx;
  ra8_io_blockdev_caps_t   caps = {};
  const ra8_err_t          e    = ra8_io_blockdev_get_caps(bd, &caps);
  if (e != k_ra8_ok) {
    return e;
  }
  if (caps.erase_value != (uint8_t)k_ra8_io_erase_value_zero) {
    return k_ra8_err_not_supported;
  }
  if ((lba > (uint64_t)UINT32_MAX) || (count > (uint64_t)UINT32_MAX)) {
    return k_ra8_err_out_of_range; /* fabric LBAs are 32-bit; see internal_fs_read */
  }
  return ra8_io_blockdev_erase(bd, (uint32_t)lba, (uint32_t)count);
}
 
ra8_err_t ra8_io_blockdev_as_fs_backend(const ra8_io_blockdev_t* bd, ra8_fs_backend_t* out)
{
  const ra8_err_t v = internal_validate(bd);
  if (v != k_ra8_ok) {
    return v;
  }
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  out->read_block   = internal_fs_read;
  out->write_block  = internal_fs_write;
  out->get_capacity = internal_fs_get_capacity;
  out->erase_blocks = internal_fs_erase;
  out->ctx          = (void*)(uintptr_t)bd;
  return k_ra8_ok;
}