board_periph_dac.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_dac_console_line_cap = 48U,  
  k_dac_console_every    = 256U, 
} dac_console_t;

typedef enum : uint64_t {
  k_dac_base       = 0x40233000UL,  
  k_dac_stride     = 0x100UL,       
  k_dac_count      = 2UL,           
  k_dac_span       = 0x200UL,       
  k_dac_inst_words = 0x100UL / 4UL, 
  k_dac_off_dadr   = 0x00UL,        
  k_dac_off_dacr0  = 0x04UL,        
  k_dac_off_dacr1  = 0x08UL,        
  k_dac_off_dacr2  = 0x0CUL,        
} dac_map_t;

typedef enum : uint32_t {
  k_dac_dadr_mask  = 0x00000FFFUL, 
  k_dac_dacen_mask = 0x00000001UL, 
} dac_field_t;

typedef struct {
  uint32_t reg[k_dac_inst_words]; 
  uint16_t last;                  
  uint16_t peak;                  
  uint32_t writes;                
} dac_inst_t;
 
static dac_inst_t s_dac[k_dac_count];

RA8_INTERNAL static uint32_t internal_dac_word(uint64_t inst_off)
{
  return (uint32_t)(inst_off >> 2U);
}

RA8_INTERNAL static uint64_t internal_dac_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off  = addr - (uint64_t)k_dac_base;
  const uint32_t inst = (uint32_t)(off / (uint64_t)k_dac_stride);
  if (inst >= (uint32_t)k_dac_count) {
    return 0U;
  }
  const uint64_t inst_off = off % (uint64_t)k_dac_stride;
  if (inst_off >= (uint64_t)k_dac_stride) {
    return 0U;
  }
  return s_dac[inst].reg[internal_dac_word(inst_off)];
}

RA8_INTERNAL static void
internal_dac_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)size;
  const uint64_t off  = addr - (uint64_t)k_dac_base;
  const uint32_t inst = (uint32_t)(off / (uint64_t)k_dac_stride);
  if (inst >= (uint32_t)k_dac_count) {
    return;
  }
  const uint64_t inst_off = off % (uint64_t)k_dac_stride;
  if (inst_off >= (uint64_t)k_dac_stride) {
    return;
  }
  s_dac[inst].reg[internal_dac_word(inst_off)] = (uint32_t)value;
  if (inst_off == (uint64_t)k_dac_off_dadr) {
    const uint16_t code = (uint16_t)((uint32_t)value & (uint32_t)k_dac_dadr_mask);
    s_dac[inst].last    = code;
    if (code > s_dac[inst].peak) {
      s_dac[inst].peak = code;
    }
    s_dac[inst].writes++;
    /* Console DAC tab: anti-flood -- the first update and then every Nth update
     * (a continuous waveform writes per-sample, so one line per N keeps the ring
     * readable while still showing the channel is active). */
    bool should_report = (s_dac[inst].writes == 1U);
    if ((s_dac[inst].writes % (uint32_t)k_dac_console_every) == 0U) {
      should_report = true;
    }
    if (should_report) {
      char ln[k_dac_console_line_cap];
      (void)snprintf(ln,
                     sizeof(ln),
                     "DAC%u code=%u (n=%u)",
                     (unsigned)inst,
                     (unsigned)code,
                     (unsigned)s_dac[inst].writes);
      board_console_push(k_board_console_ch_dac, ln);
    }
    if (board_periph_trace()) {
      (void)priv_emu_io_errf("  [trace] DAC_B%u <- code=%u\n", inst, code);
    }
  }
}

RA8_INTERNAL static void internal_dac_reset(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_dac_count; i++) {
    s_dac[i] = (dac_inst_t){};
  }
}

RA8_INTERNAL static void internal_dac_report(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_dac_count; i++) {
    if (s_dac[i].writes == 0U) {
      continue;
    }
    (void)priv_emu_io_errf(
      "  DAC_B%u        : writes=%u last=%u peak=%u enabled=%s\n",
      i,
      s_dac[i].writes,
      s_dac[i].last,
      s_dac[i].peak,
      (s_dac[i].reg[internal_dac_word((uint64_t)k_dac_off_dacr0)] & (uint32_t)k_dac_dacen_mask)
        ? "yes"
        : "no");
  }
}

static const board_periph_block_t s_k_dac_block = {
  .base   = (uint64_t)k_dac_base,
  .span   = (uint64_t)k_dac_span,
  .order  = (uint32_t)k_block_order_i2c, /* After the timers/UART; no tick. */
  .read   = internal_dac_read,
  .write  = internal_dac_write,
  .tick   = nullptr,
  .reset  = internal_dac_reset,
  .report = internal_dac_report,
  .name   = "DAC_B",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_board_periph_dac_register(void)
{
  board_periph_register_block(&s_k_dac_block);
}