ra8_io_stream_blockdev.c

Go to the documentation of this file.

 
#include "ra8_io_stream_blockdev.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_stream_backend.h"

static const char* const s_tag = "ra8_io_stream_blockdev";

typedef enum : uint32_t {
  k_bd_one_block = 1, 
  k_bd_pad_byte  = 0, 
} ra8_io_stream_bd_const_t;

RA8_INTERNAL static ra8_err_t internal_bdsink_commit_sector(ra8_io_stream_blockdev_state_t* st)
{
  RA8_CHECK_NULL_PTR(st, s_tag, "st must not be nullptr");
  RA8_CHECK_NULL_PTR(st->bd, s_tag, "st->bd must not be nullptr");
  const ra8_err_t e = ra8_io_blockdev_write(st->bd, st->lba, (uint32_t)k_bd_one_block, st->sector);
  if (e != k_ra8_ok) {
    return e;
  }
  st->lba += (uint32_t)k_bd_one_block;
  st->fill = 0;
  return k_ra8_ok;
}

RA8_INTERNAL static uint32_t internal_bdsink_fill_chunk(ra8_io_stream_blockdev_state_t* st,
                                                        const uint8_t*                  buf,
                                                        uint32_t                        len,
                                                        uint32_t*                       done)
{
  const uint32_t room  = (uint32_t)k_ra8_io_block_size_bytes - st->fill;
  const uint32_t rem   = len - *done;
  const uint32_t chunk = (rem < room) ? rem : room;
  (void)memcpy(&st->sector[st->fill], &buf[*done], (size_t)chunk);
  st->fill += chunk;
  *done += chunk;
  return chunk;
}

RA8_INTERNAL static ra8_err_t internal_bdsink_commit_if_full(ra8_io_stream_blockdev_state_t* st)
{
  if (st->fill == (uint32_t)k_ra8_io_block_size_bytes) {
    return internal_bdsink_commit_sector(st);
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_bdsink_write(void* ctx, const uint8_t* buf, uint32_t len, uint32_t* out_written)
{
  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_stream_blockdev_state_t* st   = (ra8_io_stream_blockdev_state_t*)ctx;
  uint32_t                        done = 0;
  while (done < len) {
    (void)internal_bdsink_fill_chunk(st, buf, len, &done);
    const ra8_err_t e = internal_bdsink_commit_if_full(st);
    if (e != k_ra8_ok) {
      if (out_written != nullptr) {
        *out_written = done;
      }
      return e;
    }
  }
  if (out_written != nullptr) {
    *out_written = len;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_bdsink_flush(void* ctx)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  ra8_io_stream_blockdev_state_t* st = (ra8_io_stream_blockdev_state_t*)ctx;
  if (st->fill == 0U) {
    return k_ra8_ok;
  }
  const size_t pad = (size_t)((uint32_t)k_ra8_io_block_size_bytes - st->fill);
  (void)memset(&st->sector[st->fill], (int)k_bd_pad_byte, pad);
  return internal_bdsink_commit_sector(st);
}

static const ra8_io_stream_iface_t s_bd_iface = {
  .write = internal_bdsink_write,
  .flush = internal_bdsink_flush,
};
 
ra8_err_t ra8_io_stream_blockdev_init(ra8_io_stream_t*                s,
                                      ra8_io_stream_blockdev_state_t* state,
                                      const ra8_io_blockdev_t*        bd,
                                      uint32_t                        start_lba)
{
  RA8_CHECK_NULL_PTR(s, s_tag, "s must not be nullptr");
  RA8_CHECK_NULL_PTR(state, s_tag, "state must not be nullptr");
  RA8_CHECK_NULL_PTR(bd, s_tag, "bd must not be nullptr");
  state->bd   = bd;
  state->lba  = start_lba;
  state->fill = 0;
  return ra8_io_stream_bind(s, &s_bd_iface, state);
}