ra8_pdm_regs.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stddef.h>
#include <stdint.h>

typedef enum : uintptr_t {
  k_ra8_pdm_base_addr = 0x40256000UL, 
} ra8_pdm_addr_t;

typedef enum : uint8_t {
  k_ra8_pdm_fifo_depth = 32U, 
} ra8_pdm_fifo_t;

typedef enum : uint8_t {
  k_ra8_pdm_cfch_count         = 11U, 
  k_ra8_pdm_lfch1_count        = 20U, 
  k_ra8_pdm_common_rsvd1_words = 21U, 
  k_ra8_pdm_common_rsvd2_words = 31U, 
} ra8_pdm_array_count_t;

typedef enum : uint32_t {
  k_ra8_pdm_off_pdmdsr     = 0x20U,  
  k_ra8_pdm_off_pdsfcr     = 0x24U,  
  k_ra8_pdm_off_pdcfchr    = 0x38U,  
  k_ra8_pdm_off_pdlfch010r = 0x64U,  
  k_ra8_pdm_off_pddrcr     = 0xE0U,  
  k_ra8_pdm_off_pddrr      = 0xE8U,  
  k_ra8_pdm_off_pddsr      = 0xECU,  
  k_ra8_pdm_ch_bank_bytes  = 0x100U, 
} ra8_pdm_ch_off_t;

typedef enum : uint32_t {
  k_ra8_pdm_off_pdcsr   = 0x10U,  
  k_ra8_pdm_off_pdvr    = 0x80U,  
  k_ra8_pdm_off_ch      = 0x100U, 
  k_ra8_pdm_block_bytes = 0x400U, 
} ra8_pdm_common_off_t;

typedef struct {
  volatile uint32_t PDSTRTR;                         
  volatile uint32_t PDSTPTR;                         
  volatile uint32_t PDCHGTR;                         
  volatile uint32_t PDICR;                           
  volatile uint32_t PDSDCR;                          
  volatile uint32_t PDSR;                            
  volatile uint32_t PDSCR;                           
  volatile uint32_t RESERVED0;                       
  volatile uint32_t PDMDSR;                          
  volatile uint32_t PDSFCR;                          
  volatile uint32_t PDHFCS0R;                        
  volatile uint32_t PDHFCK1R;                        
  volatile uint32_t PDHFCHR[2];                      
  volatile uint32_t PDCFCHR[k_ra8_pdm_cfch_count];   
  volatile uint32_t PDLFCH010R;                      
  volatile uint32_t PDLFCH1R[k_ra8_pdm_lfch1_count]; 
  volatile uint32_t PDSDLTR;                         
  volatile uint32_t PDSDUTR;                         
  volatile uint32_t PDDBCR;                          
  volatile uint32_t PDSCTSR;                         
  volatile uint32_t PDOVLTR;                         
  volatile uint32_t PDOVUTR;                         
  volatile uint32_t RESERVED1[4];                    
  volatile uint32_t PDDRCR;                          
  volatile uint32_t PDDCR;                           
  volatile uint32_t PDDRR;                           
  volatile uint32_t PDDSR;                           
  volatile uint32_t RESERVED2[4];                    
} r_pdm_ch_regs_t;
 
static_assert(sizeof(r_pdm_ch_regs_t) == (size_t)k_ra8_pdm_ch_bank_bytes,
              "PDM channel bank must be 256 bytes");
static_assert(offsetof(r_pdm_ch_regs_t, PDMDSR) == (size_t)k_ra8_pdm_off_pdmdsr, "PDMDSR offset");
static_assert(offsetof(r_pdm_ch_regs_t, PDSFCR) == (size_t)k_ra8_pdm_off_pdsfcr, "PDSFCR offset");
static_assert(offsetof(r_pdm_ch_regs_t, PDCFCHR) == (size_t)k_ra8_pdm_off_pdcfchr,
              "PDCFCHR offset");
static_assert(offsetof(r_pdm_ch_regs_t, PDLFCH010R) == (size_t)k_ra8_pdm_off_pdlfch010r,
              "PDLFCH010R offset");
static_assert(offsetof(r_pdm_ch_regs_t, PDDRCR) == (size_t)k_ra8_pdm_off_pddrcr, "PDDRCR offset");
static_assert(offsetof(r_pdm_ch_regs_t, PDDRR) == (size_t)k_ra8_pdm_off_pddrr, "PDDRR offset");
static_assert(offsetof(r_pdm_ch_regs_t, PDDSR) == (size_t)k_ra8_pdm_off_pddsr, "PDDSR offset");

typedef struct {
  volatile uint32_t PDCSTRTR;     
  volatile uint32_t PDCSTPTR;     
  volatile uint32_t PDCCHGTR;     
  volatile uint32_t PDCICR;       
  volatile uint32_t PDCSR;        
  volatile uint32_t PDCSCR;       
  volatile uint32_t RESERVED0[2]; 
  volatile uint32_t PDCSDCR;      
  volatile uint32_t PDCDRCR;      
  volatile uint32_t PDCDCR;       
  volatile uint32_t RESERVED1[k_ra8_pdm_common_rsvd1_words];
  volatile uint32_t PDVR;
  volatile uint32_t RESERVED2[k_ra8_pdm_common_rsvd2_words];
  r_pdm_ch_regs_t   CH[3]; 
} r_pdm_regs_t;
 
static_assert(offsetof(r_pdm_regs_t, PDCSR) == (size_t)k_ra8_pdm_off_pdcsr, "PDCSR offset");
static_assert(offsetof(r_pdm_regs_t, PDVR) == (size_t)k_ra8_pdm_off_pdvr, "PDVR offset");
static_assert(offsetof(r_pdm_regs_t, CH) == (size_t)k_ra8_pdm_off_ch, "CH bank offset");
static_assert(sizeof(r_pdm_regs_t) == (size_t)k_ra8_pdm_block_bytes,
              "PDM block must be 1024 bytes");

typedef enum : uint32_t {
  k_ra8_pdm_pdmdsr_inpsel   = 0x1U, 
  k_ra8_pdm_pdmdsr_sfmd_pos = 4U,   
  k_ra8_pdm_pdmdsr_hfis_pos = 8U,   
  k_ra8_pdm_pdmdsr_cfis_pos = 12U,  
  k_ra8_pdm_pdmdsr_lfis_pos = 16U,  
  k_ra8_pdm_pdmdsr_sdma_pos = 24U,  
  k_ra8_pdm_pdmdsr_dbis_pos = 28U,  
} ra8_pdm_pdmdsr_bits_t;

typedef enum : uint32_t {
  k_ra8_pdm_pdsfcr_ckdiv_pos   = 0U,  
  k_ra8_pdm_pdsfcr_sincdec_pos = 16U, 
  k_ra8_pdm_pdsfcr_sincrng_pos = 24U, 
} ra8_pdm_pdsfcr_bits_t;

typedef enum : uint32_t {
  k_ra8_pdm_pdsr_state    = 0x1U,        
  k_ra8_pdm_pdsr_drf      = 0x4U,        
  k_ra8_pdm_pdscr_clr_all = 0x08070002U, 
  k_ra8_pdm_pdstrtr_strt  = 0x1U,        
  k_ra8_pdm_pdstptr_stp   = 0x1U,        
  k_ra8_pdm_pdicr_idre    = 0x4U,        
  k_ra8_pdm_pddrcr_datre  = 0x1U,        
} ra8_pdm_status_bits_t;

typedef enum : uint32_t {
  k_ra8_pdm_pddrr_dat_mask = 0x000FFFFFU, 
  k_ra8_pdm_pddrr_sign_bit = 0x00080000U, 
  k_ra8_pdm_pddrr_sign_ext = 0xFFF00000U, 
  k_ra8_pdm_pddsr_num_mask = 0x000000FFU, 
} ra8_pdm_data_bits_t;

static inline volatile r_pdm_regs_t* ra8_pdm(void)
{
  return (volatile r_pdm_regs_t*)k_ra8_pdm_base_addr;
}

static inline volatile r_pdm_ch_regs_t* ra8_pdm_ch(uint8_t ch)
{
  return &ra8_pdm()->CH[ch];
}
 
#ifdef __cplusplus
}
#endif