sys_audio_mgr.h

Go to the documentation of this file.

 
#ifndef SYS_AUDIO_MGR_H_
#define SYS_AUDIO_MGR_H_
 
 
#if dg_configUSE_SYS_AUDIO_MGR
 
#include <stdbool.h>
#include <string.h>
#include "hw_dma.h"
#include "hw_pdm.h"
#include "hw_pcm.h"
 
# if dg_configUSE_HW_SDADC
#include "hw_sdadc.h"
# endif /* dg_configUSE_HW_SDADC */
 
#define MAX_NUM_OF_PATHS         4      // the max number of concurrently supported audio data paths according to device family
 
typedef enum {
        AUDIO_INVALID = 0,      
        AUDIO_PCM,              
        AUDIO_PDM,              
        AUDIO_MEMORY,           
# if dg_configUSE_HW_SDADC
        AUDIO_SDADC,            
# endif /* dg_configUSE_HW_SDADC */
        AUDIO_SIZE              
} SYS_AUDIO_MGR_DEVICE;
 
typedef enum {
        MODE_SLAVE = 0,        
        MODE_MASTER = 1,       
} SYS_AUDIO_MGR_MODE;
 
typedef enum {
        PCM_MODE = 0,           
        I2S_MODE,               
        IOM2_MODE,              
        TDM_MODE                
} SYS_AUDIO_MGR_PCM_FORMATS;
 
typedef enum {
        NO_SRC,                  
        SRC_1,                   
        SRC_2,                   
        SRC_AUTO                 
}SYS_AUDIO_MGR_SRC_USE;
 
typedef struct {
        SYS_AUDIO_MGR_MODE mode;         
        uint32_t clk_frequency;          
        HW_PDM_CHANNEL_CONFIG channel;   
        HW_PDM_DI_DELAY in_delay;        
        HW_PDM_DO_DELAY out_delay;       
        bool swap_channel;               
} sys_audio_pdm_specific_t;
 
 
typedef struct {
        SYS_AUDIO_MGR_MODE mode;                          
        SYS_AUDIO_MGR_PCM_FORMATS format;                 
        HW_PCM_CLOCK clock;                               
        uint32_t sample_rate;                             
        uint8_t channel_delay;                            
        uint8_t total_channel_num;                        
        HW_PCM_DO_OUTPUT_MODE output_mode;                
        uint8_t bit_depth;                                
        HW_PCM_CLK_GENERATION clk_generation;             
        HW_PCM_FSC_DELAY fsc_delay;                       
        HW_PCM_FSC_POLARITY inverted_fsc_polarity;        
        HW_PCM_CLK_POLARITY inverted_clk_polarity;        
        HW_PCM_CYCLE_PER_BIT cycle_per_bit;               
        uint8_t fsc_length;                               
} sys_audio_pcm_specific_t;
 
typedef struct {
        uint32_t address;         
        uint32_t buff_len_total;  
        uint32_t buff_len_cb;     
        uint32_t buff_len_pos;    
        uint8_t  channel_num;     
        bool     stereo;          
} sys_audio_mgr_buffer_data_block_t;
 
typedef void (*sys_audio_mgr_buffer_ready_cb)(sys_audio_mgr_buffer_data_block_t *buff_data_block, void *app_ud);
 
typedef struct {
        bool            use_prio;       
        HW_DMA_PRIO     prio[2];        
} sys_audio_dma_prio_t;
 
typedef struct {
        HW_DMA_CHANNEL                dma_channel[2];                 
        uint32_t                      buff_addr[2];                   
        uint32_t                      total_buffer_len;               
        uint32_t                      cb_buffer_len;                  
        sys_audio_mgr_buffer_ready_cb cb;                             
        void*                         app_ud;                         
        uint32_t                      sample_rate;                    
        bool                          stereo;                         
        uint8_t                       bit_depth;                      
        bool                          circular;                       
        sys_audio_dma_prio_t          dma_prio;                       
} sys_audio_memory_specific_t;
 
# if dg_configUSE_HW_SDADC
 
typedef struct {
        HW_SDADC_PGA_GAIN pga_gain;       
        HW_SDADC_PGA_MODE pga_mode;       
        HW_SDADC_PGA_BIAS pga_bias;       
        hw_sdadc_interrupt_cb cb;         
} sys_audio_sdadc_specific_t;
# endif /* dg_configUSE_HW_SDADC */
 
typedef struct {
        SYS_AUDIO_MGR_DEVICE device_type; 
        union {
                sys_audio_pdm_specific_t pdm_param;       
                sys_audio_pcm_specific_t pcm_param;       
                sys_audio_memory_specific_t memory_param; 
# if dg_configUSE_HW_SDADC
                sys_audio_sdadc_specific_t sdadc_param;   
# endif /* dg_configUSE_HW_SDADC */
        };
} sys_audio_device_t;
 
typedef struct {
        sys_audio_device_t *dev_in;     
        sys_audio_device_t *dev_out;    
} audio_path_t;
 
typedef struct {
        audio_path_t audio_path[MAX_NUM_OF_PATHS]; 
} sys_audio_path_t;
 
bool sys_audio_mgr_start(uint8_t idx);
 
bool sys_audio_mgr_stop(uint8_t idx);
 
uint8_t sys_audio_mgr_open_path(sys_audio_device_t *dev_in,  sys_audio_device_t *dev_out, SYS_AUDIO_MGR_SRC_USE src);
 
void sys_audio_mgr_close_path(uint8_t idx);
 
DEPRECATED_MSG("API no longer supported, use sys_audio_mgr_open_path() instead.")
__STATIC_INLINE void sys_audio_mgr_open(sys_audio_path_t *devs)
{
        for (uint8_t idx = 0; idx < MAX_NUM_OF_PATHS; idx++) {
                if (devs->audio_path[idx].dev_in != NULL &&
                    devs->audio_path[idx].dev_out != NULL &&
                    devs->audio_path[idx].dev_in->device_type != AUDIO_INVALID &&
                    devs->audio_path[idx].dev_out->device_type != AUDIO_INVALID) {
                        sys_audio_mgr_open_path(devs->audio_path[idx].dev_in,
                                                  devs->audio_path[idx].dev_out, SRC_AUTO);
                }
        }
}
 
DEPRECATED_MSG("API no longer supported, use sys_audio_mgr_close_path() instead.")
__STATIC_INLINE void sys_audio_mgr_close(void)
{
        for (uint8_t idx = 0; idx < MAX_NUM_OF_PATHS; idx++) {
                sys_audio_mgr_close_path(idx);
        }
}
 
#  endif /* dg_configUSE_SYS_AUDIO_MGR */
#endif /* SYS_AUDIO_MGR_H_ */