ra8_dotf_power.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_check.h"
#include "ra8_dotf.h"
#include "ra8_dotf_regs.h"
#include "ra8_err.h"
#include "ra8_hal_internal.h"
#include "ra8_log.h"
#include "ra8_mstp.h"

static const char* s_tag = "DOTF";

static const ra8_mstp_t s_dotf_mstp_table[k_ra8_dotf_channel_count] = {
  k_ra8_mstp_ospi0,
  k_ra8_mstp_ospi1,
};
 
/* =============================================================================
 * Power
 * =============================================================================
 */

RA8_INTERNAL
[[nodiscard]] static ra8_err_t internal_open_validate_init(const ra8_dotf_open_cfg_t* cfg)
{
  if (!internal_ra8_dotf_internal_channel_in_range(cfg->channel)) {
    return k_ra8_err_invalid_arg;
  }
  /* Step 1: Power on the DOTF block (idempotent). HUM Ch 45.6.1 p 3050. */
  const ra8_err_t init_err = ra8_dotf_init();
  RA8_RETURN_ON_ERROR(init_err, s_tag, "open: init");
  return k_ra8_ok;
}

RA8_INTERNAL
[[nodiscard]] static ra8_err_t internal_open_stage_key_iv_region(const ra8_dotf_open_cfg_t* cfg)
{
  /* Step 2: Install the wrapped key. HUM Ch 45.3 p 3049 (REG03 staging). */
  const ra8_err_t key_err = ra8_dotf_install_key(cfg->channel, &cfg->key);
  RA8_RETURN_ON_ERROR(key_err, s_tag, "open: install_key");
 
  /* Step 3: Stage the IV. HUM Ch 45.1 p 3048 (counter mode). */
  const ra8_err_t iv_err = ra8_dotf_set_iv(cfg->channel, cfg->iv_words);
  /* GCOVR_EXCL_BR_START -- embedded IV is non-null and channel was range-checked */
  RA8_RETURN_ON_ERROR(iv_err, s_tag, "open: set_iv");
  /* GCOVR_EXCL_BR_STOP */
 
  /* Step 4: Stage the conversion region. HUM Ch 45.3.1 / 45.3.2 p 3049. */
  const ra8_err_t reg_err = ra8_dotf_set_region(cfg->channel, &cfg->region);
  RA8_RETURN_ON_ERROR(reg_err, s_tag, "open: set_region");
 
  /* Step 5: Promote to live region. */
  const ra8_err_t sel_err = ra8_dotf_select_region(cfg->channel, cfg->region.region_id);
  /* GCOVR_EXCL_BR_START -- successful set_region made this same id live-selectable */
  RA8_RETURN_ON_ERROR(sel_err, s_tag, "open: select_region");
  /* GCOVR_EXCL_BR_STOP */
  return k_ra8_ok;
}

RA8_INTERNAL
[[nodiscard]] static ra8_err_t internal_open_finalise(const ra8_dotf_open_cfg_t* cfg)
{
  /* Step 6: Side-channel level. */
  const ra8_err_t sca_err = ra8_dotf_set_sca_level(cfg->channel, cfg->sca_level);
  RA8_RETURN_ON_ERROR(sca_err, s_tag, "open: set_sca_level");
 
  /* Step 7: Optionally arm the AES core. */
  if (cfg->enable_after) {
    /* GCOVR_EXCL_BR_START -- validated channel maps to a non-null static DOTF block */
    const ra8_err_t en_err = ra8_dotf_enable(cfg->channel);
    RA8_RETURN_ON_ERROR(en_err, s_tag, "open: enable");
    /* GCOVR_EXCL_BR_STOP */
  }
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_dotf_open(const ra8_dotf_open_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg must not be nullptr");
 
  const ra8_err_t vi_err = internal_open_validate_init(cfg);
  RA8_RETURN_ON_ERROR(vi_err, s_tag, "open: validate_init");
 
  const ra8_err_t st_err = internal_open_stage_key_iv_region(cfg);
  RA8_RETURN_ON_ERROR(st_err, s_tag, "open: stage");
 
  const ra8_err_t fi_err = internal_open_finalise(cfg);
  RA8_RETURN_ON_ERROR(fi_err, s_tag, "open: finalise");
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_dotf_close(void)
{
  /* Symmetric companion to ra8_dotf_open. HUM Ch 45.6.1 p 3050. */
  return ra8_dotf_deinit();
}
 
[[nodiscard]] ra8_err_t ra8_dotf_set_region_window(uint8_t channel, uint32_t start, uint32_t len)
{
  if (!internal_ra8_dotf_internal_channel_in_range(channel)) {
    return k_ra8_err_invalid_arg;
  }
  if (len == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if ((start & k_ra8_dotf_addr_low_mask) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  if ((len & k_ra8_dotf_addr_low_mask) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  /* HUM Ch 45.3.1 "CONVAREAST" p 3049 */
  /* HUM Ch 45.3.2 "CONVAREAD" p 3049 */
  /* end address is inclusive. */
  const ra8_dotf_region_t r = {
    .start_addr = start,
    .end_addr   = start + len - 1U,
    .key_index  = 0U,
    .region_id  = 0U,
  };
  return ra8_dotf_set_region(channel, &r);
}
 
[[nodiscard]] ra8_err_t ra8_dotf_enter_stop(void)
{
  for (uint8_t ch = 0U; ch < k_ra8_dotf_channel_count; ++ch) {
    /* HUM Ch 45.6.1 "Module-stop Function" p 3050 */
    (void)ra8_mstp_disable(s_dotf_mstp_table[ch]);
  }
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_dotf_exit_stop(void)
{
  for (uint8_t ch = 0U; ch < k_ra8_dotf_channel_count; ++ch) {
    /* HUM Ch 45.6.1 "Module-stop Function" p 3050 */
    const ra8_err_t mst_err = ra8_mstp_enable(s_dotf_mstp_table[ch]);
    /* GCOVR_EXCL_BR_START -- ra8_mstp_enable() error edge in the per-channel stop-exit loop */
    RA8_RETURN_ON_ERROR(mst_err, s_tag, "exit_stop: mstp enable failed");
    /* GCOVR_EXCL_BR_STOP */
  }
  return k_ra8_ok;
}