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 <errno.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_ */