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_PCM,             
        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_COMMON_COUNT,

        AUDIO_CHANNEL_PRIV_START = AUDIO_CHANNEL_COMMON_COUNT,

        AUDIO_CHANNEL_MAX = INT16_MAX
} audio_channel_t;

typedef uint8_t audio_dai_dir_t;
#define AUDIO_DAI_DIR_TX   BIT(0)
#define AUDIO_DAI_DIR_RX   BIT(1)
#define AUDIO_DAI_DIR_TXRX (AUDIO_DAI_DIR_TX | AUDIO_DAI_DIR_RX)

struct pcm_config {
        audio_dai_dir_t dir;
        audio_pcm_width_t pcm_width;
        uint8_t channels;
        size_t block_size;
        audio_pcm_rate_t samplerate;
};

typedef union {
        struct i2s_config i2s; 
        struct pcm_config pcm; 
                               /* 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);

typedef void (*audio_codec_tx_done_callback_t)(const struct device *dev, void *user_data);

typedef void (*audio_codec_rx_done_callback_t)(const struct device *dev, uint8_t *buf, uint32_t len,
                                               void *user_data);


typedef int (*audio_codec_configure_t)(const struct device *dev, struct audio_codec_cfg *cfg);

typedef void (*audio_codec_start_output_t)(const struct device *dev);

typedef void (*audio_codec_stop_output_t)(const struct device *dev);

typedef int (*audio_codec_set_property_t)(const struct device *dev, audio_property_t property,
                                          audio_channel_t channel, audio_property_value_t val);

typedef int (*audio_codec_apply_properties_t)(const struct device *dev);

typedef int (*audio_codec_clear_errors_t)(const struct device *dev);

typedef int (*audio_codec_register_error_callback_t)(const struct device *dev,
                                                     audio_codec_error_callback_t cb);

typedef int (*audio_codec_route_input_t)(const struct device *dev, audio_channel_t channel,
                                         uint32_t input);

typedef int (*audio_codec_route_output_t)(const struct device *dev, audio_channel_t channel,
                                          uint32_t output);

typedef int (*audio_codec_start_t)(const struct device *dev, audio_dai_dir_t dir);

typedef int (*audio_codec_stop_t)(const struct device *dev, audio_dai_dir_t dir);

typedef int (*audio_codec_write_t)(const struct device *dev, uint8_t *data, size_t data_size);

typedef int (*audio_codec_register_done_callback_t)(
        const struct device *dev, audio_codec_tx_done_callback_t tx_cb, void *tx_cb_user_data,
        audio_codec_rx_done_callback_t rx_cb, void *rx_cb_user_data);

#define audio_codec_api audio_codec_driver_api __DEPRECATED_MACRO

__subsystem struct audio_codec_driver_api {
        audio_codec_configure_t configure;
        audio_codec_start_output_t start_output;
        audio_codec_stop_output_t stop_output;
        audio_codec_set_property_t set_property;
        audio_codec_apply_properties_t apply_properties;
        audio_codec_clear_errors_t clear_errors;
        audio_codec_register_error_callback_t register_error_callback;
        audio_codec_route_input_t route_input;
        audio_codec_route_output_t route_output;
        audio_codec_start_t start;
        audio_codec_stop_t stop;
        audio_codec_write_t write;
        audio_codec_register_done_callback_t register_done_callback;
};


static inline int audio_codec_configure(const struct device *dev, struct audio_codec_cfg *cfg)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        return api->configure(dev, cfg);
}

static inline void audio_codec_start_output(const struct device *dev)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        api->start_output(dev);
}

static inline void audio_codec_stop_output(const struct device *dev)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        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_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        return api->set_property(dev, property, channel, val);
}

static inline int audio_codec_apply_properties(const struct device *dev)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        return api->apply_properties(dev);
}

static inline int audio_codec_clear_errors(const struct device *dev)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        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_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        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_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        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_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        if (api->route_output == NULL) {
                return -ENOSYS;
        }
 
        return api->route_output(dev, channel, output);
}

static inline int audio_codec_start(const struct device *dev, audio_dai_dir_t dir)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        if (api->start == NULL) {
                return -ENOSYS;
        }
 
        return api->start(dev, dir);
}

static inline int audio_codec_stop(const struct device *dev, audio_dai_dir_t dir)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        if (api->stop == NULL) {
                return -ENOSYS;
        }
 
        return api->stop(dev, dir);
}

static inline int audio_codec_write(const struct device *dev, uint8_t *data, size_t data_size)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        if (api->write == NULL) {
                return -ENOSYS;
        }
 
        return api->write(dev, data, data_size);
}

static inline int audio_codec_register_done_callback(const struct device *dev,
                                                     audio_codec_tx_done_callback_t tx_cb,
                                                     void *tx_cb_user_data,
                                                     audio_codec_rx_done_callback_t rx_cb,
                                                     void *rx_cb_user_data)
{
        const struct audio_codec_driver_api *api = DEVICE_API_GET(audio_codec, dev);
 
        if (api->register_done_callback == NULL) {
                return -ENOSYS;
        }
 
        return api->register_done_callback(dev, tx_cb, tx_cb_user_data, rx_cb, rx_cb_user_data);
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_AUDIO_CODEC_H_ */