board_periph_adc.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <stdio.h>
 
#include "board_console.h"
#include "board_periph_block.h"
#include "emu_host_io_internal.h"

typedef enum : uint32_t {
  k_adc_console_line_cap = 48U, 
} adc_console_t;

typedef enum : uint64_t {
  k_adc_base          = 0x40338000UL, 
  k_adc_span          = 0x2224UL,     
  k_adc_off_adsger    = 0x0048UL,     
  k_adc_off_adintcr   = 0x005CUL,     
  k_adc_off_adsgdcr0  = 0x0200UL,     
  k_adc_off_adchcr0   = 0x0600UL,     
  k_adc_off_addopcrc0 = 0x060CUL,     
  k_adc_off_adtrgenr  = 0x0C08UL,     
  k_adc_off_adstr0    = 0x0C20UL,     
  k_adc_off_adstopr   = 0x0C60UL,     
  k_adc_off_adsr      = 0x0C80UL,     
  k_adc_off_addr0     = 0x2000UL,     
  k_adc_off_adexdr0   = 0x2180UL,     
  k_adc_chcr_stride   = 0x10UL,       
  k_adc_addr_stride   = 0x04UL,       
  k_adc_str_stride    = 0x04UL,       
  k_adc_sgdcr_stride  = 0x04UL,       
  k_adc_exdr_stride   = 0x04UL,       
} adc_map_t;

typedef enum : uint32_t {
  k_adc_max_channels = 24U,          
  k_adc_result_regs  = 23U,          
  k_adc_ext_regs     = 23U,          
  k_adc_scan_groups  = 9U,           
  k_adc_reg_words    = 0x2224U / 4U, 
} adc_dim_t;

typedef enum : uint32_t {
  k_adc_adst_mask     = 0x00000001UL, 
  k_adc_adact0_mask   = 0x00000001UL, 
  k_adc_addr_data     = 0x0000FFFFUL, 
  k_adc_chcr_sgsel    = 0x0000001FUL, 
  k_adc_chcr_cnvcs_m  = 0x00007F00UL, 
  k_adc_chcr_cnvcs_s  = 8U,           
  k_adc_sgdcr_diagval = 0x00000007UL, 
  k_adc_opcrc_adprc_m = 0x00030000UL, 
  k_adc_opcrc_adprc_s = 16U,          
} adc_field_t;

typedef enum : uint32_t {
  k_adc_adprc_16bit = 0x0U, 
  k_adc_adprc_14bit = 0x1U, 
  k_adc_adprc_12bit = 0x2U, 
  k_adc_adprc_10bit = 0x3U, 
} adc_adprc_t;

typedef enum : uint16_t {
  k_adc_mid_16bit = 0x8000U, 
  k_adc_mid_14bit = 0x2000U, 
  k_adc_mid_12bit = 0x0800U, 
  k_adc_mid_10bit = 0x0200U, 
} adc_midscale_t;

typedef enum : uint32_t {
  k_adc_ext_chan_base = 0x60U, 
  k_adc_chan_selfdiag = 0x60U, 
  k_adc_chan_temp     = 0x64U, 
  k_adc_chan_int_vref = 0x65U, 
} adc_ext_chan_t;

typedef enum : uint32_t {
  k_adc_diagval_mode1  = 0x4U,    
  k_adc_diagval_mode2  = 0x5U,    
  k_adc_diagval_mode3  = 0x6U,    
  k_adc_selfdiag_zero  = 0x0000U, 
  k_adc_selfdiag_negfs = 0x8000U, 
  k_adc_selfdiag_posfs = 0x7FFFU, 
} adc_selfdiag_t;

typedef enum : uint16_t {
  k_adc_sample_code = 2048U, 
  /* Temperature-sensor code: with the factory calibration ra8_emulator seeds at
   * 0x02C1EDA0 (TSCDR=3000 @125C, TSCDR2=1000 @-40C), the two-point math in
   * ra8_tsn_convert_to_milli_c maps this 12-bit code to ~26 degC -- a plausible,
   * deterministic die temperature. See main.c k_tsn_cal_* for the paired seed. */
  k_adc_temp_code = 1800U, 
} adc_sample_t;

typedef enum : uint16_t {
  k_event_adc0_scan_end = 0x09CU, 
} adc_elc_event_t;

static uint32_t s_adc_reg[k_adc_reg_words];
static uint32_t s_adc_scans;     
static uint16_t s_adc_last_code; 

RA8_INTERNAL static uint32_t internal_adc_word(uint64_t off)
{
  return (uint32_t)(off >> 2U);
}

RA8_INTERNAL static uint32_t internal_adc_chcr(uint32_t ch)
{
  return s_adc_reg[internal_adc_word((uint64_t)k_adc_off_adchcr0 +
                                     ((uint64_t)ch * (uint64_t)k_adc_chcr_stride))];
}

RA8_INTERNAL static void internal_adc_set_result(uint32_t ch, uint16_t code)
{
  if (ch >= (uint32_t)k_adc_result_regs) {
    return;
  }
  const uint64_t off = (uint64_t)k_adc_off_addr0 + ((uint64_t)ch * (uint64_t)k_adc_addr_stride);
  s_adc_reg[internal_adc_word(off)] = (uint32_t)code & (uint32_t)k_adc_addr_data;
  s_adc_last_code                   = code;
}

RA8_INTERNAL static void internal_adc_set_ext_result(uint32_t idx, uint16_t code)
{
  if (idx >= (uint32_t)k_adc_ext_regs) {
    return;
  }
  const uint64_t off = (uint64_t)k_adc_off_adexdr0 + ((uint64_t)idx * (uint64_t)k_adc_exdr_stride);
  s_adc_reg[internal_adc_word(off)] = (uint32_t)code & (uint32_t)k_adc_addr_data;
  s_adc_last_code                   = code;
}

RA8_INTERNAL static uint32_t internal_adc_diagval(uint32_t group)
{
  const uint64_t off =
    (uint64_t)k_adc_off_adsgdcr0 + ((uint64_t)group * (uint64_t)k_adc_sgdcr_stride);
  return s_adc_reg[internal_adc_word(off)] & (uint32_t)k_adc_sgdcr_diagval;
}

RA8_INTERNAL static uint16_t internal_adc_selfdiag_ideal(uint32_t diagval)
{
  switch (diagval) {
    case (uint32_t)k_adc_diagval_mode2:
      return (uint16_t)k_adc_selfdiag_negfs;
    case (uint32_t)k_adc_diagval_mode3:
      return (uint16_t)k_adc_selfdiag_posfs;
    default:
      return (uint16_t)k_adc_selfdiag_zero; /* mode 1 / DIAGVAL off. */
  }
}

RA8_INTERNAL static uint16_t internal_adc_ext_value(uint32_t phys, uint32_t group)
{
  if (phys == (uint32_t)k_adc_chan_selfdiag) {
    return internal_adc_selfdiag_ideal(internal_adc_diagval(group));
  }
  if (phys == (uint32_t)k_adc_chan_temp) {
    return (uint16_t)k_adc_temp_code;
  }
  return (uint16_t)k_adc_sample_code; /* internal Vref + any other ext source. */
}

RA8_INTERNAL static uint32_t internal_adc_adprc(uint32_t slot)
{
  const uint64_t off =
    (uint64_t)k_adc_off_addopcrc0 + ((uint64_t)slot * (uint64_t)k_adc_chcr_stride);
  return (s_adc_reg[internal_adc_word(off)] & (uint32_t)k_adc_opcrc_adprc_m) >>
         (uint32_t)k_adc_opcrc_adprc_s;
}

RA8_INTERNAL static uint16_t internal_adc_midscale_for_adprc(uint32_t adprc)
{
  switch (adprc) {
    case (uint32_t)k_adc_adprc_16bit:
      return (uint16_t)k_adc_mid_16bit;
    case (uint32_t)k_adc_adprc_14bit:
      return (uint16_t)k_adc_mid_14bit;
    case (uint32_t)k_adc_adprc_10bit:
      return (uint16_t)k_adc_mid_10bit;
    default: /* 12-bit (0b10) and any unmodelled code. */
      return (uint16_t)k_adc_mid_12bit;
  }
}

RA8_INTERNAL static void internal_adc_convert_group(uint32_t group)
{
  uint32_t converted = 0U;
  uint16_t last_code = 0U;
  for (uint32_t slot = 0U; slot < (uint32_t)k_adc_max_channels; slot++) {
    const uint32_t chcr = internal_adc_chcr(slot);
    if ((chcr & (uint32_t)k_adc_chcr_sgsel) != group) {
      continue;
    }
    const uint32_t phys = (chcr & (uint32_t)k_adc_chcr_cnvcs_m) >> (uint32_t)k_adc_chcr_cnvcs_s;
    if (phys >= (uint32_t)k_adc_ext_chan_base) {
      /* An internal / extended-analog channel (self-diagnosis, temperature
       * sensor, internal Vref) reports through ADEXDR[CNVCS - base], not ADDR[]. */
      last_code = internal_adc_ext_value(phys, group);
      internal_adc_set_ext_result(phys - (uint32_t)k_adc_ext_chan_base, last_code);
      converted++;
    } else if (slot < (uint32_t)k_adc_result_regs) {
      /* Normal channel -> its virtual-channel result register ADDR[slot].
       * Resolution is the slot's ADDOPCRCn.ADPRC data-format, so a mid-scale
       * input converts to that format's half-full-scale code. */
      last_code = internal_adc_midscale_for_adprc(internal_adc_adprc(slot));
      internal_adc_set_result(slot, last_code);
      converted++;
    }
    /* else: a normal channel on a virtual slot with no ADDR result register
     * (the diagnostic slot) produces no ordinary result. */
  }
  /* Console ADC tab: one line per scan-group conversion (coalesced -- a whole
   * group is one push, never one per channel), skipped when the group is empty. */
  if (converted != 0U) {
    char ln[k_adc_console_line_cap];
    (void)snprintf(ln,
                   sizeof(ln),
                   "ADC grp=%u %uch code=%u",
                   (unsigned)group,
                   (unsigned)converted,
                   (unsigned)last_code);
    board_console_push(k_board_console_ch_adc, ln);
  }
}

RA8_INTERNAL static uint64_t internal_adc_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_adc_base;
  if (off == (uint64_t)k_adc_off_adsr) {
    /* Conversion is modelled as instantaneous: ADACT0 reads idle so the
     * driver's busy-poll completes on its first read and fetches ADDR. */
    return s_adc_reg[internal_adc_word(off)] & ~(uint32_t)k_adc_adact0_mask;
  }
  if (off >= (uint64_t)k_adc_span) {
    return 0U;
  }
  return s_adc_reg[internal_adc_word(off)];
}

RA8_INTERNAL static void
internal_adc_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)size;
  const uint64_t off = addr - (uint64_t)k_adc_base;
  if (off >= (uint64_t)k_adc_span) {
    return;
  }
  const uint64_t str_lo = (uint64_t)k_adc_off_adstr0;
  const uint64_t str_hi = str_lo + ((uint64_t)k_adc_scan_groups * (uint64_t)k_adc_str_stride);
  if ((off >= str_lo) && (off < str_hi) && ((value & (uint64_t)k_adc_adst_mask) != 0U)) {
    const uint32_t group              = (uint32_t)((off - str_lo) / (uint64_t)k_adc_str_stride);
    s_adc_reg[internal_adc_word(off)] = (uint32_t)value;
    internal_adc_convert_group(group);
    s_adc_scans++;
    board_periph_icu_raise_event(uc, (uint16_t)k_event_adc0_scan_end);
    if (board_periph_trace()) {
      (void)priv_emu_io_errf("  [trace] ADC_B scan grp%u -> code=%u\n",
                             group,
                             (unsigned)s_adc_last_code);
    }
    return;
  }
  s_adc_reg[internal_adc_word(off)] = (uint32_t)value;
}

RA8_INTERNAL static void internal_adc_reset(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_adc_reg_words; i++) {
    s_adc_reg[i] = 0U;
  }
  s_adc_scans     = 0U;
  s_adc_last_code = 0U;
}

RA8_INTERNAL static void internal_adc_report(void)
{
  if (s_adc_scans == 0U) {
    return;
  }
  (void)priv_emu_io_errf("  ADC_B         : scans=%u last_code=%u (0x%03X)\n",
                         s_adc_scans,
                         s_adc_last_code,
                         s_adc_last_code);
}

static const board_periph_block_t s_k_adc_block = {
  .base   = (uint64_t)k_adc_base,
  .span   = (uint64_t)k_adc_span,
  .order  = (uint32_t)k_block_order_i2c, /* After the timers/UART; no tick. */
  .read   = internal_adc_read,
  .write  = internal_adc_write,
  .tick   = nullptr,
  .reset  = internal_adc_reset,
  .report = internal_adc_report,
  .name   = "ADC_B",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_board_periph_adc_register(void)
{
  board_periph_register_block(&s_k_adc_block);
}