codec.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_AUDIO_CODEC_H_
#define ZEPHYR_INCLUDE_AUDIO_CODEC_H_
 
#include <zephyr/drivers/i2s.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
        AUDIO_PCM_RATE_8K       = 8000,         
        AUDIO_PCM_RATE_11P025K  = 11025,        
        AUDIO_PCM_RATE_16K      = 16000,        
        AUDIO_PCM_RATE_22P05K   = 22050,        
        AUDIO_PCM_RATE_24K      = 24000,        
        AUDIO_PCM_RATE_32K      = 32000,        
        AUDIO_PCM_RATE_44P1K    = 44100,        
        AUDIO_PCM_RATE_48K      = 48000,        
        AUDIO_PCM_RATE_96K      = 96000,        
        AUDIO_PCM_RATE_192K     = 192000,       
} audio_pcm_rate_t;
 
typedef enum {
        AUDIO_PCM_WIDTH_16_BITS = 16,   
        AUDIO_PCM_WIDTH_20_BITS = 20,   
        AUDIO_PCM_WIDTH_24_BITS = 24,   
        AUDIO_PCM_WIDTH_32_BITS = 32,   
} audio_pcm_width_t;
 
typedef enum {
        AUDIO_DAI_TYPE_I2S,     
        AUDIO_DAI_TYPE_LEFT_JUSTIFIED,  
        AUDIO_DAI_TYPE_RIGHT_JUSTIFIED, 
        AUDIO_DAI_TYPE_PCMA,            
        AUDIO_DAI_TYPE_PCMB,            
        AUDIO_DAI_TYPE_INVALID, 
} audio_dai_type_t;
 
typedef enum {
        AUDIO_PROPERTY_OUTPUT_VOLUME,   
        AUDIO_PROPERTY_OUTPUT_MUTE,     
        AUDIO_PROPERTY_INPUT_VOLUME,    
        AUDIO_PROPERTY_INPUT_MUTE       
} audio_property_t;
 
typedef enum {
        AUDIO_CHANNEL_FRONT_LEFT,       
        AUDIO_CHANNEL_FRONT_RIGHT,      
        AUDIO_CHANNEL_LFE,              
        AUDIO_CHANNEL_FRONT_CENTER,     
        AUDIO_CHANNEL_REAR_LEFT,        
        AUDIO_CHANNEL_REAR_RIGHT,       
        AUDIO_CHANNEL_REAR_CENTER,      
        AUDIO_CHANNEL_SIDE_LEFT,        
        AUDIO_CHANNEL_SIDE_RIGHT,       
        AUDIO_CHANNEL_HEADPHONE_LEFT,   
        AUDIO_CHANNEL_HEADPHONE_RIGHT,  
        AUDIO_CHANNEL_ALL,              
} audio_channel_t;
 
typedef union {
        struct i2s_config i2s;  
                                /* Other DAI types go here */
} audio_dai_cfg_t;
 
/*
 * DAI Route types
 */
typedef enum {
        AUDIO_ROUTE_BYPASS,
        AUDIO_ROUTE_PLAYBACK,
        AUDIO_ROUTE_PLAYBACK_CAPTURE,
        AUDIO_ROUTE_CAPTURE,
} audio_route_t;
 
struct audio_codec_cfg {
        uint32_t                mclk_freq;      
        audio_dai_type_t        dai_type;       
        audio_dai_cfg_t         dai_cfg;        
        audio_route_t           dai_route;      
};
 
typedef union {
        int     vol;    
        bool    mute;   
} audio_property_value_t;
 
enum audio_codec_error_type {
        AUDIO_CODEC_ERROR_OVERCURRENT = BIT(0),
 
        AUDIO_CODEC_ERROR_OVERTEMPERATURE = BIT(1),
 
        AUDIO_CODEC_ERROR_UNDERVOLTAGE = BIT(2),
 
        AUDIO_CODEC_ERROR_OVERVOLTAGE = BIT(3),
 
        AUDIO_CODEC_ERROR_DC = BIT(4),
};
 
typedef void (*audio_codec_error_callback_t)(const struct device *dev, uint32_t errors);
 
struct audio_codec_api {
        int (*configure)(const struct device *dev,
                         struct audio_codec_cfg *cfg);
        void (*start_output)(const struct device *dev);
        void (*stop_output)(const struct device *dev);
        int (*set_property)(const struct device *dev,
                            audio_property_t property,
                            audio_channel_t channel,
                            audio_property_value_t val);
        int (*apply_properties)(const struct device *dev);
        int (*clear_errors)(const struct device *dev);
        int (*register_error_callback)(const struct device *dev,
                         audio_codec_error_callback_t cb);
        int (*route_input)(const struct device *dev, audio_channel_t channel, uint32_t input);
        int (*route_output)(const struct device *dev, audio_channel_t channel, uint32_t output);
};
static inline int audio_codec_configure(const struct device *dev,
                                        struct audio_codec_cfg *cfg)
{
        const struct audio_codec_api *api =
                (const struct audio_codec_api *)dev->api;
 
        return api->configure(dev, cfg);
}
 
static inline void audio_codec_start_output(const struct device *dev)
{
        const struct audio_codec_api *api =
                (const struct audio_codec_api *)dev->api;
 
        api->start_output(dev);
}
 
static inline void audio_codec_stop_output(const struct device *dev)
{
        const struct audio_codec_api *api =
                (const struct audio_codec_api *)dev->api;
 
        api->stop_output(dev);
}
 
static inline int audio_codec_set_property(const struct device *dev,
                                           audio_property_t property,
                                           audio_channel_t channel,
                                           audio_property_value_t val)
{
        const struct audio_codec_api *api =
                (const struct audio_codec_api *)dev->api;
 
        return api->set_property(dev, property, channel, val);
}
 
static inline int audio_codec_apply_properties(const struct device *dev)
{
        const struct audio_codec_api *api =
                (const struct audio_codec_api *)dev->api;
 
        return api->apply_properties(dev);
}
 
static inline int audio_codec_clear_errors(const struct device *dev)
{
        const struct audio_codec_api *api =
                (const struct audio_codec_api *)dev->api;
 
        if (api->clear_errors == NULL) {
                return -ENOSYS;
        }
 
        return api->clear_errors(dev);
}
 
static inline int audio_codec_register_error_callback(const struct device *dev,
                                     audio_codec_error_callback_t cb)
{
        const struct audio_codec_api *api =
                (const struct audio_codec_api *)dev->api;
 
        if (api->register_error_callback == NULL) {
                return -ENOSYS;
        }
 
        return api->register_error_callback(dev, cb);
}
 
static inline int audio_codec_route_input(const struct device *dev, audio_channel_t channel,
                                          uint32_t input)
{
        const struct audio_codec_api *api = (const struct audio_codec_api *)dev->api;
 
        if (api->route_input == NULL) {
                return -ENOSYS;
        }
 
        return api->route_input(dev, channel, input);
}
 
static inline int audio_codec_route_output(const struct device *dev, audio_channel_t channel,
                                           uint32_t output)
{
        const struct audio_codec_api *api = (const struct audio_codec_api *)dev->api;
 
        if (api->route_output == NULL) {
                return -ENOSYS;
        }
 
        return api->route_output(dev, channel, output);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_AUDIO_CODEC_H_ */