board_periph_pdm.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 : uint64_t {
  k_pdm_base       = 0x40256000UL,  
  k_pdm_span       = 0x400UL,       
  k_pdm_words      = 0x400UL / 4UL, 
  k_pdm_ch_count   = 3UL,           
  k_pdm_ch0_off    = 0x100UL,       
  k_pdm_ch_stride  = 0x100UL,       
  k_pdm_off_cstrtr = 0x00UL,        
  k_pdm_off_cstptr = 0x04UL,        
  k_pdm_off_csr    = 0x10UL,        
  k_pdm_ch_pddrcr  = 0xE0UL,        
  k_pdm_ch_pddrr   = 0xE8UL,        
  k_pdm_ch_pddsr   = 0xECUL,        
} pdm_map_t;

typedef enum : uint32_t {
  k_pdm_pddrcr_datre = 0x1U,        
  k_pdm_pddsr_num    = 0x000000FFU, 
  k_pdm_pddrr_mask20 = 0x000FFFFFU, 
  k_pdm_fifo_depth   = 32U,         
} pdm_field_t;

typedef enum : uint32_t {
  k_pdm_tone_period = 64U, 
  k_pdm_tone_qmask  = 63U, 
  k_pdm_tone_half   = 32U, 
} pdm_tone_t;

typedef enum : int32_t {
  k_pdm_tone_amp  = 20000, 
  k_pdm_tone_step = 1250,  
} pdm_amp_t;

typedef enum : uint32_t {
  k_pdm_lcg_mul     = 1664525U,    
  k_pdm_lcg_add     = 1013904223U, 
  k_pdm_lcg_shift   = 16U,         
  k_pdm_dither_mask = 0x3FFU,      
  k_pdm_dither_half = 512U,        
} pdm_dither_t;

typedef enum : uint32_t {
  k_pdm_console_line_cap = 48U,  
  k_pdm_console_every    = 512U, 
} pdm_console_t;

typedef struct {
  bool     running;     
  bool     read_enable; 
  uint32_t phase;       
  uint32_t lcg;         
  uint32_t samples;     
} pdm_channel_t;
 
static pdm_channel_t s_pdm[k_pdm_ch_count];
static uint32_t      s_pdm_reg[k_pdm_words]; 

RA8_INTERNAL static bool internal_pdm_live(uint32_t ch)
{
  if (ch >= (uint32_t)k_pdm_ch_count) {
    return false;
  }
  return s_pdm[ch].running && s_pdm[ch].read_enable;
}

RA8_INTERNAL static uint32_t internal_pdm_next_sample(uint32_t ch)
{
  pdm_channel_t* c   = &s_pdm[ch];
  const uint32_t ph  = c->phase & (uint32_t)k_pdm_tone_qmask;
  int32_t        tri = 0;
  if (ph < (uint32_t)k_pdm_tone_half) {
    tri = -(int32_t)k_pdm_tone_amp + ((int32_t)k_pdm_tone_step * (int32_t)ph);
  } else {
    tri = (int32_t)k_pdm_tone_amp -
          ((int32_t)k_pdm_tone_step * (int32_t)(ph - (uint32_t)k_pdm_tone_half));
  }
  c->lcg = (c->lcg * (uint32_t)k_pdm_lcg_mul) + (uint32_t)k_pdm_lcg_add;
  const int32_t dither =
    (int32_t)((c->lcg >> (uint32_t)k_pdm_lcg_shift) & (uint32_t)k_pdm_dither_mask) -
    (int32_t)k_pdm_dither_half;
  c->phase++;
  c->samples++;
  const int32_t sample = tri + dither;
  return (uint32_t)sample & (uint32_t)k_pdm_pddrr_mask20;
}

RA8_INTERNAL static void internal_pdm_console_maybe(uint32_t ch)
{
  const uint32_t n = s_pdm[ch].samples;
  if ((n != 1U) && ((n % (uint32_t)k_pdm_console_every) != 0U)) {
    return;
  }
  char ln[k_pdm_console_line_cap];
  (void)snprintf(ln, sizeof(ln), "PDM%u samples=%u (synth tone)", (unsigned)ch, (unsigned)n);
  board_console_push(k_board_console_ch_i2s, ln);
}

RA8_INTERNAL static bool internal_pdm_channel_at(uint64_t off, uint32_t* ch, uint64_t* ch_off)
{
  if (off < (uint64_t)k_pdm_ch0_off) {
    return false;
  }
  const uint64_t rel = off - (uint64_t)k_pdm_ch0_off;
  *ch                = (uint32_t)(rel / (uint64_t)k_pdm_ch_stride);
  *ch_off            = rel % (uint64_t)k_pdm_ch_stride;
  return (*ch < (uint32_t)k_pdm_ch_count);
}

RA8_INTERNAL static uint32_t internal_pdm_read_csr(void)
{
  uint32_t csr = 0U;
  for (uint32_t i = 0U; i < (uint32_t)k_pdm_ch_count; i++) {
    if (s_pdm[i].running) {
      csr |= (1U << i);
    }
  }
  return csr;
}

RA8_INTERNAL static uint64_t internal_pdm_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_pdm_base;
  if (off >= (uint64_t)k_pdm_span) {
    return 0U;
  }
  if (off == (uint64_t)k_pdm_off_csr) {
    return internal_pdm_read_csr();
  }
  uint32_t ch     = 0U;
  uint64_t ch_off = 0U;
  if (internal_pdm_channel_at(off, &ch, &ch_off)) {
    if (ch_off == (uint64_t)k_pdm_ch_pddsr) {
      return internal_pdm_live(ch)
               ? (uint64_t)((uint32_t)k_pdm_fifo_depth & (uint32_t)k_pdm_pddsr_num)
               : 0U;
    }
    if (ch_off == (uint64_t)k_pdm_ch_pddrr) {
      if (!internal_pdm_live(ch)) {
        return 0U;
      }
      const uint32_t sample = internal_pdm_next_sample(ch);
      internal_pdm_console_maybe(ch);
      return (uint64_t)sample;
    }
  }
  return (uint64_t)s_pdm_reg[off >> 2U];
}

RA8_INTERNAL static void
internal_pdm_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_pdm_base;
  if (off >= (uint64_t)k_pdm_span) {
    return;
  }
  s_pdm_reg[off >> 2U] = (uint32_t)value;
 
  if (off == (uint64_t)k_pdm_off_cstrtr) {
    for (uint32_t i = 0U; i < (uint32_t)k_pdm_ch_count; i++) {
      if (((uint32_t)value & (1U << i)) != 0U) {
        s_pdm[i].running = true;
      }
    }
    return;
  }
  if (off == (uint64_t)k_pdm_off_cstptr) {
    for (uint32_t i = 0U; i < (uint32_t)k_pdm_ch_count; i++) {
      if (((uint32_t)value & (1U << i)) != 0U) {
        s_pdm[i].running = false;
      }
    }
    return;
  }
  uint32_t ch     = 0U;
  uint64_t ch_off = 0U;
  if (internal_pdm_channel_at(off, &ch, &ch_off) && (ch_off == (uint64_t)k_pdm_ch_pddrcr)) {
    s_pdm[ch].read_enable = (((uint32_t)value & (uint32_t)k_pdm_pddrcr_datre) != 0U);
  }
}

RA8_INTERNAL static void internal_pdm_reset(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_pdm_ch_count; i++) {
    s_pdm[i] = (pdm_channel_t){};
  }
  for (uint32_t i = 0U; i < (uint32_t)k_pdm_words; i++) {
    s_pdm_reg[i] = 0U;
  }
}

RA8_INTERNAL static void internal_pdm_report(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_pdm_ch_count; i++) {
    if (s_pdm[i].samples == 0U) {
      continue;
    }
    (void)priv_emu_io_errf("  PDM ch%u       : samples=%u run=%s read_en=%s (synth tone)\n",
                           i,
                           s_pdm[i].samples,
                           s_pdm[i].running ? "yes" : "no",
                           s_pdm[i].read_enable ? "yes" : "no");
  }
}

static const board_periph_block_t s_k_pdm_block = {
  .base   = (uint64_t)k_pdm_base,
  .span   = (uint64_t)k_pdm_span,
  .order  = (uint32_t)k_block_order_i2c, /* Pull model (read-driven); no tick. */
  .read   = internal_pdm_read,
  .write  = internal_pdm_write,
  .tick   = nullptr,
  .reset  = internal_pdm_reset,
  .report = internal_pdm_report,
  .name   = "PDM-IF",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_board_periph_pdm_register(void)
{
  board_periph_register_block(&s_k_pdm_block);
}