ra8_sdfont.c

Go to the documentation of this file.

 
#include "ra8_sdfont.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_gpio_constants.h"
#include "ra8_port_utils.h"
#include "ra8_sci_spi.h"
#include "ra8_sdmmc_spi.h"
#include "ra8_spi.h"

static const char* s_tag = "SDFONT";

static const char* s_default_name = "FONT.OTF";

typedef enum : uint32_t {
  k_sdfont_min_bytes = 16U, 
} sdfont_limits_t;

typedef struct {
  uint8_t        channel;  
  uint32_t       pclka_hz; 
  ra8_port_pin_t cs;       
} sdfont_ctx_t;

static sdfont_ctx_t s_ctx;
 
/* ---------------------------------------------------------------------------
 * ra8_sdmmc_spi transport shim (Dependency Inversion seam) over ra8_sci_spi.
 * ---------------------------------------------------------------------------
 */

RA8_INTERNAL static ra8_err_t internal_set_clock(void* ctx, uint32_t hz)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  const sdfont_ctx_t* c = (const sdfont_ctx_t*)ctx;
  return ra8_sci_spi_set_clock(c->channel, hz, c->pclka_hz);
}

RA8_INTERNAL static ra8_err_t internal_cs(void* ctx, bool asserted)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  const sdfont_ctx_t* c = (const sdfont_ctx_t*)ctx;
  return ra8_gpio_write(c->cs, asserted ? k_ra8_level_low : k_ra8_level_high);
}

RA8_INTERNAL static ra8_err_t internal_xfer(void* ctx, const uint8_t* tx, uint8_t* rx, uint32_t len)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  const sdfont_ctx_t* c = (const sdfont_ctx_t*)ctx;
  return ra8_sci_spi_xfer(c->channel, tx, rx, len);
}
 
/* ---------------------------------------------------------------------------
 * Bring-up helpers
 * ---------------------------------------------------------------------------
 */

RA8_INTERNAL static ra8_err_t internal_bringup_spi(const ra8_sdfont_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg");
 
  s_ctx.channel  = cfg->spi_channel;
  s_ctx.pclka_hz = cfg->pclka_hz;
  s_ctx.cs       = cfg->cs;
 
  ra8_err_t err = ra8_pfs_route_peripheral(cfg->sck, k_ra8_psel_sci_async, "sdfont.sck");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(cfg->cipo, k_ra8_psel_sci_async, "sdfont.cipo");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(cfg->copi, k_ra8_psel_sci_async, "sdfont.copi");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_gpio_output_init(cfg->cs, k_ra8_level_high);
  if (err != k_ra8_ok) {
    return err;
  }
  const ra8_sci_spi_cfg_t spi_cfg = {
    .baud_hz   = (uint32_t)k_ra8_sdmmc_spi_clock_init_hz,
    .pclk_hz   = cfg->pclka_hz,
    .mode      = k_ra8_spi_mode_0,
    .lsb_first = false,
  };
  return ra8_sci_spi_init(cfg->spi_channel, &spi_cfg);
}

RA8_INTERNAL static ra8_err_t internal_mount(ra8_fs_mount_t** out_mount)
{
  RA8_CHECK_NULL_PTR(out_mount, s_tag, "out_mount");
 
  const ra8_sdmmc_spi_transport_t transport = {
    .set_clock = internal_set_clock,
    .cs        = internal_cs,
    .xfer      = internal_xfer,
    .ctx       = &s_ctx,
  };
  ra8_err_t err = ra8_sdmmc_spi_init(&transport);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_fs_backend_t backend = {};
  err                      = ra8_sdmmc_spi_bind_fs_backend(&backend);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_fs_mount(&backend, out_mount);
}

RA8_INTERNAL static ra8_err_t internal_open_or_provision(const ra8_sdfont_cfg_t* cfg,
                                                         ra8_fs_mount_t*         mount,
                                                         const char*             name,
                                                         ra8_fs_file_t**         out_file,
                                                         ra8_sdfont_source_t*    out_source)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg");
  RA8_CHECK_NULL_PTR(mount, s_tag, "mount");
  RA8_CHECK_NULL_PTR(out_file, s_tag, "out_file");
 
  *out_source   = k_ra8_sdfont_source_card;
  ra8_err_t err = ra8_fs_open(mount, name, k_ra8_fs_mode_read, out_file);
 
  /* Self-provision only when the file is genuinely absent and a blob is
   * configured. Kept as separate single-condition guards (not one compound
   * decision) so each branch is independently covered without MC/DC vectors. */
  if (err != k_ra8_err_not_found) {
    return err;
  }
  if (cfg->provision_blob == nullptr) {
    return err; /* provisioning disabled -- propagate k_ra8_err_not_found */
  }
  if (cfg->provision_len == 0U) {
    return err; /* nothing to write -- propagate k_ra8_err_not_found */
  }
  err = ra8_fs_write_file(mount, name, cfg->provision_blob, cfg->provision_len);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_source = k_ra8_sdfont_source_provisioned;
  return ra8_fs_open(mount, name, k_ra8_fs_mode_read, out_file);
}

RA8_INTERNAL static ra8_err_t
internal_read_font(ra8_fs_file_t* file, uint8_t* buf, uint32_t cap, uint32_t* out_len)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "out_len");
 
  uint32_t        got = 0U;
  const ra8_err_t err = ra8_fs_read(file, buf, cap, &got);
  (void)ra8_fs_close(file);
  if (err != k_ra8_ok) {
    return err;
  }
  if (got < (uint32_t)k_sdfont_min_bytes) {
    return k_ra8_err_no_data;
  }
  *out_len = got;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_validate(const ra8_sdfont_cfg_t* cfg,
                                                const uint8_t*          buf,
                                                const uint32_t*         out_len,
                                                uint32_t                cap)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "out_len");
  if (cap == 0U) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_sdfont_load(const ra8_sdfont_cfg_t* cfg,
                          uint8_t*                buf,
                          uint32_t                cap,
                          uint32_t*               out_len,
                          ra8_sdfont_source_t*    out_source)
{
  ra8_err_t err = internal_validate(cfg, buf, out_len, cap);
  if (err != k_ra8_ok) {
    return err;
  }
 
  err = internal_bringup_spi(cfg);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_fs_mount_t* mount = nullptr;
  err                   = internal_mount(&mount);
  if (err != k_ra8_ok) {
    return err;
  }
 
  const char*         name = (cfg->filename != nullptr) ? cfg->filename : s_default_name;
  ra8_fs_file_t*      file = nullptr;
  ra8_sdfont_source_t src  = k_ra8_sdfont_source_card;
  err                      = internal_open_or_provision(cfg, mount, name, &file, &src);
  if (err == k_ra8_ok) {
    err = internal_read_font(file, buf, cap, out_len);
  }
  (void)ra8_fs_unmount(mount);
  if (err != k_ra8_ok) {
    return err;
  }
 
  if (out_source != nullptr) {
    *out_source = src;
  }
  return k_ra8_ok;
}