ra8_devcfg.c

Go to the documentation of this file.

 
#include "ra8_devcfg.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_log.h"

static const char* const s_tag = "DEVCFG";

typedef enum : uint32_t {
  k_ra8_devcfg_crc_init = 0xFFFFFFFFU, 
  k_ra8_devcfg_crc_poly = 0xEDB88320U, 
} ra8_devcfg_crc_t;

typedef enum : uint8_t {
  k_ra8_devcfg_bits_per_byte = 8U,    
  k_ra8_devcfg_byte_shift    = 8U,    
  k_ra8_devcfg_byte_mask     = 0xFFU, 
  k_ra8_devcfg_off_b0        = 0U,    
  k_ra8_devcfg_off_b1        = 1U,    
  k_ra8_devcfg_off_b2        = 2U,    
  k_ra8_devcfg_off_b3        = 3U,    
} ra8_devcfg_bits_t;

typedef enum : uint8_t {
  k_ra8_devcfg_state_unloaded      = 0U, 
  k_ra8_devcfg_state_loaded        = 1U, 
  k_ra8_devcfg_state_unprovisioned = 2U, 
} ra8_devcfg_state_t;

static ra8_devcfg_state_t s_state = k_ra8_devcfg_state_unloaded;

static ra8_devcfg_record_t s_record = {};
 
/* ===========================================================================
 * Local helpers -- byte codec
 * ===========================================================================
 */

RA8_INTERNAL
[[nodiscard]] static uint32_t internal_devcfg_crc32(const uint8_t* data, uint32_t len)
{
  uint32_t crc = (uint32_t)k_ra8_devcfg_crc_init;
  for (uint32_t i = 0U; i < len; i++) {
    crc ^= (uint32_t)data[i];
    for (uint8_t bit = 0U; bit < (uint8_t)k_ra8_devcfg_bits_per_byte; bit++) {
      const uint32_t mask = (uint32_t)0U - (crc & 1U);
      crc                 = (crc >> 1U) ^ ((uint32_t)k_ra8_devcfg_crc_poly & mask);
    }
  }
  return crc ^ (uint32_t)k_ra8_devcfg_crc_init;
}

RA8_INTERNAL
static void internal_devcfg_pack_le16(uint8_t* dst, uint16_t val)
{
  dst[k_ra8_devcfg_off_b0] = (uint8_t)(val & (uint16_t)k_ra8_devcfg_byte_mask);
  dst[k_ra8_devcfg_off_b1] =
    (uint8_t)((val >> (uint16_t)k_ra8_devcfg_byte_shift) & (uint16_t)k_ra8_devcfg_byte_mask);
}

RA8_INTERNAL
static void internal_devcfg_pack_le32(uint8_t* dst, uint32_t val)
{
  const uint32_t sh        = (uint32_t)k_ra8_devcfg_byte_shift;
  dst[k_ra8_devcfg_off_b0] = (uint8_t)(val & (uint32_t)k_ra8_devcfg_byte_mask);
  dst[k_ra8_devcfg_off_b1] = (uint8_t)((val >> sh) & (uint32_t)k_ra8_devcfg_byte_mask);
  dst[k_ra8_devcfg_off_b2] = (uint8_t)((val >> (sh * 2U)) & (uint32_t)k_ra8_devcfg_byte_mask);
  dst[k_ra8_devcfg_off_b3] = (uint8_t)((val >> (sh * 3U)) & (uint32_t)k_ra8_devcfg_byte_mask);
}

RA8_INTERNAL
[[nodiscard]] static uint16_t internal_devcfg_unpack_le16(const uint8_t* src)
{
  return (uint16_t)((uint16_t)src[k_ra8_devcfg_off_b0] |
                    ((uint16_t)src[k_ra8_devcfg_off_b1] << (uint16_t)k_ra8_devcfg_byte_shift));
}

RA8_INTERNAL
[[nodiscard]] static uint32_t internal_devcfg_unpack_le32(const uint8_t* src)
{
  const uint32_t sh = (uint32_t)k_ra8_devcfg_byte_shift;
  return (uint32_t)src[k_ra8_devcfg_off_b0] | ((uint32_t)src[k_ra8_devcfg_off_b1] << sh) |
         ((uint32_t)src[k_ra8_devcfg_off_b2] << (sh * 2U)) |
         ((uint32_t)src[k_ra8_devcfg_off_b3] << (sh * 3U));
}
 
/* ===========================================================================
 * Local helpers -- record codec
 * ===========================================================================
 */

RA8_INTERNAL
static void internal_devcfg_serialize(const ra8_devcfg_record_t* rec, uint32_t seq, uint8_t* buf)
{
  (void)memset(buf, 0, (size_t)k_ra8_devcfg_record_len);
  const ra8_devcfg_body_t* b = &rec->body;
  (void)memcpy(&buf[k_ra8_devcfg_off_serial], b->serial, (size_t)k_ra8_devcfg_serial_len);
  (void)memcpy(&buf[k_ra8_devcfg_off_panel_serial],
               b->panel_serial,
               (size_t)k_ra8_devcfg_panel_serial_len);
  (void)memcpy(&buf[k_ra8_devcfg_off_panel_lut],
               b->panel_lut_id,
               (size_t)k_ra8_devcfg_panel_lut_len);
  (void)memcpy(&buf[k_ra8_devcfg_off_touch_cal], b->touch_cal, (size_t)k_ra8_devcfg_touch_cal_len);
  internal_devcfg_pack_le32(&buf[k_ra8_devcfg_off_mfg_date], b->mfg_date);
  internal_devcfg_pack_le32(&buf[k_ra8_devcfg_off_key_id], b->device_key_id);
  internal_devcfg_pack_le16(&buf[k_ra8_devcfg_off_hw_rev], b->hw_rev);
  internal_devcfg_pack_le16(&buf[k_ra8_devcfg_off_fixture], b->fixture_id);
  internal_devcfg_pack_le16(&buf[k_ra8_devcfg_off_vcom], b->panel_vcom_mv);
 
  const uint32_t crc =
    internal_devcfg_crc32(&buf[k_ra8_devcfg_hdr_bytes], (uint32_t)k_ra8_devcfg_body_bytes);
  internal_devcfg_pack_le32(&buf[k_ra8_devcfg_off_magic], (uint32_t)k_ra8_devcfg_magic);
  internal_devcfg_pack_le16(&buf[k_ra8_devcfg_off_schema], (uint16_t)k_ra8_devcfg_schema_ver);
  internal_devcfg_pack_le16(&buf[k_ra8_devcfg_off_reclen], (uint16_t)k_ra8_devcfg_record_len);
  internal_devcfg_pack_le32(&buf[k_ra8_devcfg_off_seq], seq);
  internal_devcfg_pack_le32(&buf[k_ra8_devcfg_off_crc], crc);
  internal_devcfg_pack_le32(&buf[k_ra8_devcfg_off_flags], rec->flags);
}

RA8_INTERNAL
static void internal_devcfg_deserialize(const uint8_t* buf, ra8_devcfg_record_t* out)
{
  ra8_devcfg_body_t* b = &out->body;
  (void)memcpy(b->serial, &buf[k_ra8_devcfg_off_serial], (size_t)k_ra8_devcfg_serial_len);
  (void)memcpy(b->panel_serial,
               &buf[k_ra8_devcfg_off_panel_serial],
               (size_t)k_ra8_devcfg_panel_serial_len);
  (void)memcpy(b->panel_lut_id,
               &buf[k_ra8_devcfg_off_panel_lut],
               (size_t)k_ra8_devcfg_panel_lut_len);
  (void)memcpy(b->touch_cal, &buf[k_ra8_devcfg_off_touch_cal], (size_t)k_ra8_devcfg_touch_cal_len);
  b->mfg_date         = internal_devcfg_unpack_le32(&buf[k_ra8_devcfg_off_mfg_date]);
  b->device_key_id    = internal_devcfg_unpack_le32(&buf[k_ra8_devcfg_off_key_id]);
  b->hw_rev           = internal_devcfg_unpack_le16(&buf[k_ra8_devcfg_off_hw_rev]);
  b->fixture_id       = internal_devcfg_unpack_le16(&buf[k_ra8_devcfg_off_fixture]);
  b->panel_vcom_mv    = internal_devcfg_unpack_le16(&buf[k_ra8_devcfg_off_vcom]);
  out->flags          = internal_devcfg_unpack_le32(&buf[k_ra8_devcfg_off_flags]);
  out->seq            = internal_devcfg_unpack_le32(&buf[k_ra8_devcfg_off_seq]);
  out->schema_version = internal_devcfg_unpack_le16(&buf[k_ra8_devcfg_off_schema]);
}

RA8_INTERNAL
[[nodiscard]] static bool internal_devcfg_copy_valid(const uint8_t* buf)
{
  if (internal_devcfg_unpack_le32(&buf[k_ra8_devcfg_off_magic]) != (uint32_t)k_ra8_devcfg_magic) {
    return false; /* not our record / blank window */
  }
  if (internal_devcfg_unpack_le16(&buf[k_ra8_devcfg_off_schema]) >
      (uint16_t)k_ra8_devcfg_schema_ver) {
    return false; /* written by a newer, unknown schema -- reject, never guess */
  }
  if (internal_devcfg_unpack_le16(&buf[k_ra8_devcfg_off_reclen]) !=
      (uint16_t)k_ra8_devcfg_record_len) {
    return false; /* length not what this schema expects */
  }
  const uint32_t stored = internal_devcfg_unpack_le32(&buf[k_ra8_devcfg_off_crc]);
  const uint32_t calc =
    internal_devcfg_crc32(&buf[k_ra8_devcfg_hdr_bytes], (uint32_t)k_ra8_devcfg_body_bytes);
  return stored == calc;
}

RA8_INTERNAL
[[nodiscard]] static bool
internal_devcfg_probe(const ra8_devcfg_store_t* store, uint32_t offset, ra8_devcfg_record_t* out)
{
  uint8_t buf[k_ra8_devcfg_record_len] = {};
  if (store->read(offset, buf, (uint32_t)k_ra8_devcfg_record_len) != k_ra8_ok) {
    return false; /* read fault / blank -> copy absent, resolver falls through */
  }
  if (!internal_devcfg_copy_valid(buf)) {
    return false;
  }
  internal_devcfg_deserialize(buf, out);
  return true;
}

RA8_INTERNAL
[[nodiscard]] static uint32_t
internal_devcfg_target(bool valid0, uint32_t seq0, bool valid1, uint32_t seq1)
{
  if (!valid0) {
    return (uint32_t)k_ra8_devcfg_copy0_off;
  }
  if (!valid1) {
    return (uint32_t)k_ra8_devcfg_copy1_off;
  }
  return (seq0 <= seq1) ? (uint32_t)k_ra8_devcfg_copy0_off : (uint32_t)k_ra8_devcfg_copy1_off;
}

RA8_INTERNAL
static void
internal_devcfg_plan(const ra8_devcfg_store_t* store, uint32_t* out_target, uint32_t* out_seq)
{
  ra8_devcfg_record_t cur0 = {};
  ra8_devcfg_record_t cur1 = {};
  const bool     valid0    = internal_devcfg_probe(store, (uint32_t)k_ra8_devcfg_copy0_off, &cur0);
  const bool     valid1    = internal_devcfg_probe(store, (uint32_t)k_ra8_devcfg_copy1_off, &cur1);
  const uint32_t seq0      = valid0 ? cur0.seq : 0U;
  const uint32_t seq1      = valid1 ? cur1.seq : 0U;
  const uint32_t newest    = (seq0 >= seq1) ? seq0 : seq1;
  *out_seq                 = newest + 1U;
  *out_target              = internal_devcfg_target(valid0, seq0, valid1, seq1);
}

RA8_INTERNAL
[[nodiscard]] static ra8_err_t
internal_devcfg_write_record(const ra8_devcfg_store_t* store, uint32_t target, const uint8_t* buf)
{
  const ra8_err_t body_err = store->write(target + (uint32_t)k_ra8_devcfg_hdr_bytes,
                                          &buf[k_ra8_devcfg_hdr_bytes],
                                          (uint32_t)k_ra8_devcfg_body_bytes);
  RA8_RETURN_ON_ERROR(body_err, s_tag, "commit: body write failed");
  const ra8_err_t hdr_err = store->write(target, buf, (uint32_t)k_ra8_devcfg_hdr_bytes);
  RA8_RETURN_ON_ERROR(hdr_err, s_tag, "commit: header write failed");
  return k_ra8_ok;
}
 
/* ===========================================================================
 * Public API
 * ===========================================================================
 */
 
[[nodiscard]] ra8_err_t ra8_devcfg_load(const ra8_devcfg_store_t* store)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "load: store null");
  RA8_CHECK_NULL_PTR(store->read, s_tag, "load: store->read null");
 
  ra8_devcfg_record_t rec0 = {};
  ra8_devcfg_record_t rec1 = {};
  const bool valid0        = internal_devcfg_probe(store, (uint32_t)k_ra8_devcfg_copy0_off, &rec0);
  const bool valid1        = internal_devcfg_probe(store, (uint32_t)k_ra8_devcfg_copy1_off, &rec1);
 
  if (valid0 && valid1) {
    /* Both survive -- the higher sequence is the newer record; a tie takes 0. */
    s_record = (rec0.seq >= rec1.seq) ? rec0 : rec1;
  } else if (valid0) {
    s_record = rec0;
  } else if (valid1) {
    s_record = rec1;
  } else {
    s_state = k_ra8_devcfg_state_unprovisioned;
    ra8_log_warn(s_tag, "no valid device config -- UNPROVISIONED");
    return k_ra8_err_validation_failed;
  }
  s_state = k_ra8_devcfg_state_loaded;
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_devcfg_get_vcom_mv(uint16_t* out_mv)
{
  RA8_CHECK_NULL_PTR(out_mv, s_tag, "get_vcom: out_mv null");
  if (s_state != k_ra8_devcfg_state_loaded) {
    return k_ra8_err_not_initialized;
  }
  if ((s_record.flags & (uint32_t)k_ra8_devcfg_flag_vcom_valid) == 0U) {
    ra8_log_error(s_tag, "VCOM not marked valid -- refuse the panel");
    return k_ra8_err_validation_failed;
  }
  const uint16_t mv = s_record.body.panel_vcom_mv;
  if ((mv < (uint16_t)k_ra8_devcfg_vcom_min_mv) || (mv > (uint16_t)k_ra8_devcfg_vcom_max_mv)) {
    ra8_log_error(s_tag, "VCOM out of plausible range -- refuse the panel");
    return k_ra8_err_validation_failed;
  }
  *out_mv = mv;
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_devcfg_get_body(const ra8_devcfg_body_t** out_body)
{
  RA8_CHECK_NULL_PTR(out_body, s_tag, "get_body: out_body null");
  if (s_state != k_ra8_devcfg_state_loaded) {
    return k_ra8_err_not_initialized;
  }
  *out_body = &s_record.body;
  return k_ra8_ok;
}
 
[[nodiscard]] bool ra8_devcfg_is_blank(void)
{
  return s_state != k_ra8_devcfg_state_loaded;
}
 
[[nodiscard]] ra8_err_t ra8_devcfg_commit(const ra8_devcfg_store_t*  store,
                                          const ra8_devcfg_record_t* rec)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "commit: store null");
  RA8_CHECK_NULL_PTR(store->read, s_tag, "commit: store->read null");
  RA8_CHECK_NULL_PTR(store->write, s_tag, "commit: store->write null");
  RA8_CHECK_NULL_PTR(rec, s_tag, "commit: rec null");
 
  uint32_t target  = 0U;
  uint32_t new_seq = 0U;
  internal_devcfg_plan(store, &target, &new_seq);
 
  uint8_t buf[k_ra8_devcfg_record_len] = {};
  internal_devcfg_serialize(rec, new_seq, buf);
  return internal_devcfg_write_record(store, target, buf);
}
 
void ra8_devcfg_reset(void)
{
  s_state  = k_ra8_devcfg_state_unloaded;
  s_record = (ra8_devcfg_record_t){};
}