dai.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_DAI_H_
#define ZEPHYR_INCLUDE_DRIVERS_DAI_H_
 
#include <errno.h>
 
#include <zephyr/types.h>
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum dai_type {
        DAI_LEGACY_I2S = 0,     
        DAI_INTEL_SSP,          
        DAI_INTEL_DMIC,         
        DAI_INTEL_HDA,          
        DAI_INTEL_ALH,          
        DAI_IMX_SAI,            
        DAI_IMX_ESAI,           
        DAI_AMD_BT,             
        DAI_AMD_SP,             
        DAI_AMD_DMIC,           
        DAI_MEDIATEK_AFE,       
        DAI_INTEL_SSP_NHLT,     
        DAI_INTEL_DMIC_NHLT,    
        DAI_INTEL_HDA_NHLT,     
        DAI_INTEL_ALH_NHLT,     
};
 
enum dai_dir {
        DAI_DIR_RX = 1,
        DAI_DIR_TX,
        DAI_DIR_BOTH,
};
 
enum dai_state {
        DAI_STATE_NOT_READY = 0,
        DAI_STATE_READY,
        DAI_STATE_RUNNING,
        DAI_STATE_PRE_RUNNING,
        DAI_STATE_PAUSED,
        DAI_STATE_STOPPING,
        DAI_STATE_ERROR,
};
 
enum dai_trigger_cmd {
        DAI_TRIGGER_START = 0,
        DAI_TRIGGER_PRE_START,
        DAI_TRIGGER_STOP,
        DAI_TRIGGER_PAUSE,
        DAI_TRIGGER_POST_STOP,
        DAI_TRIGGER_DRAIN,
        DAI_TRIGGER_DROP,
        DAI_TRIGGER_PREPARE,
        DAI_TRIGGER_RESET,
        DAI_TRIGGER_COPY,
};
 
struct dai_properties {
        uint32_t fifo_address; /* fifo address */
        uint32_t fifo_depth; /* fifo depth */
        uint32_t dma_hs_id; /* dma handshake id */
        uint32_t reg_init_delay; /* delay for register init */
        int stream_id; /* stream id */
};
 
struct dai_config {
        enum dai_type type;
        uint32_t dai_index;
        uint8_t channels;
        uint32_t rate;
        uint16_t format;
        uint8_t options;
        uint8_t word_size;
        size_t block_size;
        uint16_t link_config;
};
 
struct dai_ts_cfg {
        uint32_t walclk_rate; /* Rate in Hz, e.g. 19200000 */
        int type; /* SSP, DMIC, HDA, etc. */
        int direction; /* Playback, capture */
        int index; /* For SSPx to select correct timestamp register */
        int dma_id; /* DMA instance id */
        int dma_chan_index; /* Used DMA channel */
        int dma_chan_count; /* Channels in single DMA */
};
 
struct dai_ts_data {
        uint64_t walclk; /* Wall clock */
        uint64_t sample; /* Sample count */
        uint32_t walclk_rate; /* Rate in Hz, e.g. 19200000 */
};
 
__subsystem struct dai_driver_api {
        int (*probe)(const struct device *dev);
        int (*remove)(const struct device *dev);
        int (*config_set)(const struct device *dev, const struct dai_config *cfg,
                          const void *bespoke_cfg);
        int (*config_get)(const struct device *dev, struct dai_config *cfg,
                          enum dai_dir dir);
 
        const struct dai_properties *(*get_properties)(const struct device *dev,
                                                       enum dai_dir dir,
                                                       int stream_id);
 
        int (*trigger)(const struct device *dev, enum dai_dir dir,
                       enum dai_trigger_cmd cmd);
 
        /* optional methods */
        int (*ts_config)(const struct device *dev, struct dai_ts_cfg *cfg);
        int (*ts_start)(const struct device *dev, struct dai_ts_cfg *cfg);
        int (*ts_stop)(const struct device *dev, struct dai_ts_cfg *cfg);
        int (*ts_get)(const struct device *dev, struct dai_ts_cfg *cfg,
                      struct dai_ts_data *tsd);
};
 
static inline int dai_probe(const struct device *dev)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        return api->probe(dev);
}
 
static inline int dai_remove(const struct device *dev)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        return api->remove(dev);
}
 
static inline int dai_config_set(const struct device *dev,
                                 const struct dai_config *cfg,
                                 const void *bespoke_cfg)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        return api->config_set(dev, cfg, bespoke_cfg);
}
 
static inline int dai_config_get(const struct device *dev,
                                 struct dai_config *cfg,
                                 enum dai_dir dir)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        return api->config_get(dev, cfg, dir);
}
 
static inline const struct dai_properties *dai_get_properties(const struct device *dev,
                                                              enum dai_dir dir,
                                                              int stream_id)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        return api->get_properties(dev, dir, stream_id);
}
 
static inline int dai_trigger(const struct device *dev,
                              enum dai_dir dir,
                              enum dai_trigger_cmd cmd)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        return api->trigger(dev, dir, cmd);
}
 
static inline int dai_ts_config(const struct device *dev, struct dai_ts_cfg *cfg)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        if (!api->ts_config)
                return -EINVAL;
 
        return api->ts_config(dev, cfg);
}
 
static inline int dai_ts_start(const struct device *dev, struct dai_ts_cfg *cfg)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        if (!api->ts_start)
                return -EINVAL;
 
        return api->ts_start(dev, cfg);
}
 
static inline int dai_ts_stop(const struct device *dev, struct dai_ts_cfg *cfg)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        if (!api->ts_stop)
                return -EINVAL;
 
        return api->ts_stop(dev, cfg);
}
 
static inline int dai_ts_get(const struct device *dev, struct dai_ts_cfg *cfg,
                             struct dai_ts_data *tsd)
{
        const struct dai_driver_api *api = (const struct dai_driver_api *)dev->api;
 
        if (!api->ts_get)
                return -EINVAL;
 
        return api->ts_get(dev, cfg, tsd);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_DAI_H_ */