main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_psa_crypto.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_rng_demo_baud      = 115200U, 
  k_rng_demo_period_ms = 1000U,   
} rng_demo_config_t;

typedef enum : uint8_t {
  k_rng_demo_bytes_per_line  = 32U,   
  k_rng_demo_hex_per_byte    = 2U,    
  k_rng_demo_nibble_mask     = 0x0FU, 
  k_rng_demo_nibble_shift    = 4U,    
  k_rng_demo_alpha_threshold = 10U,   
} rng_demo_byte_t;

static const uint8_t s_rng_demo_prefix[] = "rng: ";
static const uint8_t s_rng_demo_eol[]    = "\r\n";

static const uint8_t s_rng_demo_pass_msg[] = "rng: PRNG stub OK (deterministic, NOT entropy)\r\n";

RA8_INTERNAL static void internal_rng_demo_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

RA8_INTERNAL static uint8_t internal_rng_demo_nibble_to_hex(uint8_t nibble)
{
  uint8_t n = (uint8_t)(nibble & (uint8_t)k_rng_demo_nibble_mask);
  if (n < (uint8_t)k_rng_demo_alpha_threshold) {
    return (uint8_t)('0' + n);
  }
  return (uint8_t)('a' + (n - (uint8_t)k_rng_demo_alpha_threshold));
}

RA8_INTERNAL static void internal_rng_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_rng_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_rng_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_rng_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_rng_demo_baud) != k_ra8_ok) {
    internal_rng_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_rng_demo_panic_halt();
  }
  if (ra8_psa_crypto_init() != k_ra8_ok) {
    internal_rng_demo_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_rng_demo_emit_one_line(void)
{
  uint8_t        rng[k_rng_demo_bytes_per_line]                                     = {};
  uint8_t        hex[(uint16_t)k_rng_demo_bytes_per_line * k_rng_demo_hex_per_byte] = {};
  const uint32_t hex_len =
    (uint32_t)((uint16_t)k_rng_demo_bytes_per_line * (uint16_t)k_rng_demo_hex_per_byte);
 
  if (ra8_psa_crypto_random(rng, sizeof(rng)) != k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  /* Stuck-bit detector: if every byte in the 32-byte sample is the
   * same value, the TRNG entropy path is almost certainly broken
   * (probability of 32 random bytes all matching is 1 in 2^248).
   * Without this check the demo would happily print "trng: 00...00"
   * or "trng: ff...ff" forever and the probe would pass. */
  bool all_same = true;
  for (uint8_t i = 1U; i < (uint8_t)k_rng_demo_bytes_per_line; ++i) {
    if (rng[i] != rng[0]) {
      all_same = false;
      break;
    }
  }
  if (all_same) {
    const uint8_t fail_banner[] = "rng_demo: FAIL stuck\r\n";
    (void)ra8_board_uart_console_write(fail_banner, (size_t)(sizeof(fail_banner) - 1U));
    return k_ra8_err_hw_error;
  }
  for (uint8_t i = 0U; i < (uint8_t)k_rng_demo_bytes_per_line; ++i) {
    const size_t hi = (size_t)i * (size_t)k_rng_demo_hex_per_byte;
    hex[hi] =
      internal_rng_demo_nibble_to_hex((uint8_t)(rng[i] >> (uint8_t)k_rng_demo_nibble_shift));
    hex[hi + 1U] = internal_rng_demo_nibble_to_hex(rng[i]);
  }
 
  if (ra8_board_uart_console_write(s_rng_demo_prefix, (size_t)(sizeof(s_rng_demo_prefix) - 1U)) !=
      k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  if (ra8_board_uart_console_write(hex, (size_t)hex_len) != k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  if (ra8_board_uart_console_write(s_rng_demo_eol, (size_t)(sizeof(s_rng_demo_eol) - 1U)) !=
      k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  /* Success-only verdict for the HIL scrape; fire-and-forget so it adds
   * no decision to the documented MC/DC vector set above. */
  (void)ra8_board_uart_console_write(s_rng_demo_pass_msg,
                                     (size_t)(sizeof(s_rng_demo_pass_msg) - 1U));
  return k_ra8_ok;
}
 
void main(void)
{
  internal_rng_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  while (1) {
    if (internal_rng_demo_emit_one_line() != k_ra8_ok) {
      break;
    }
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    ra8_delay_ms(k_rng_demo_period_ms);
  }
  internal_rng_demo_panic_halt();
}