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

#define DAI_FORMAT_CLOCK_PROVIDER_MASK 0xf000
#define DAI_FORMAT_PROTOCOL_MASK 0x000f
#define DAI_FORMAT_CLOCK_INVERSION_MASK 0x0f00

enum dai_clock_provider {
        DAI_CBP_CFP = (0 << 12),
        DAI_CBC_CFP = (2 << 12),
        DAI_CBP_CFC = (3 << 12),
        DAI_CBC_CFC = (4 << 12),
};

enum dai_protocol {
        DAI_PROTO_I2S = 1, 
        DAI_PROTO_RIGHT_J, 
        DAI_PROTO_LEFT_J, 
        DAI_PROTO_DSP_A, 
        DAI_PROTO_DSP_B, 
        DAI_PROTO_PDM, 
};

enum dai_clock_inversion {
        DAI_INVERSION_NB_NF = 0,
        DAI_INVERSION_NB_IF = (2 << 8),
        DAI_INVERSION_IB_NF = (3 << 8),
        DAI_INVERSION_IB_IF = (4 << 8),
};

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,     
        DAI_IMX_MICFIL,         
        DAI_INTEL_UAOL,         
};

enum dai_dir {
        DAI_DIR_TX = 0,
        DAI_DIR_RX,
        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;
        uint32_t fifo_depth;
        uint32_t dma_hs_id;
        uint32_t reg_init_delay;
        int 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;
        uint32_t  tdm_slot_group;
};

struct dai_ts_cfg {
        uint32_t walclk_rate;
        int type;
        int direction;
        int index;
        int dma_id;
        int dma_chan_index;
        int dma_chan_count;
};

struct dai_ts_data {
        uint64_t walclk;
        uint64_t sample;
        uint32_t walclk_rate;
};

__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, size_t size);
        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 (*get_properties_copy)(const struct device *dev,
                                   enum dai_dir dir,
                                   int stream_id,
                                   struct dai_properties *dst);
 
        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);
        int (*config_update)(const struct device *dev, const void *bespoke_cfg,
                             size_t size);
};


__syscall int dai_probe(const struct device *dev);
 
static inline int z_impl_dai_probe(const struct device *dev)
{
        return DEVICE_API_GET(dai, dev)->probe(dev);
}

__syscall int dai_remove(const struct device *dev);
 
static inline int z_impl_dai_remove(const struct device *dev)
{
        return DEVICE_API_GET(dai, dev)->remove(dev);
}

 
__syscall int dai_config_set(const struct device *dev,
                             const struct dai_config *cfg,
                             const void *bespoke_cfg,
                             size_t size);
 
static inline int z_impl_dai_config_set(const struct device *dev,
                                        const struct dai_config *cfg,
                                        const void *bespoke_cfg,
                                        size_t size)
{
        return DEVICE_API_GET(dai, dev)->config_set(dev, cfg, bespoke_cfg, size);
}

__syscall int dai_config_get(const struct device *dev,
                             struct dai_config *cfg,
                             enum dai_dir dir);
 
static inline int z_impl_dai_config_get(const struct device *dev,
                                        struct dai_config *cfg,
                                        enum dai_dir dir)
{
        return DEVICE_API_GET(dai, dev)->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)
{
        return DEVICE_API_GET(dai, dev)->get_properties(dev, dir, stream_id);
}

__syscall int dai_get_properties_copy(const struct device *dev,
                                      enum dai_dir dir,
                                      int stream_id,
                                      struct dai_properties *dst);
 
static inline int z_impl_dai_get_properties_copy(const struct device *dev,
                                                 enum dai_dir dir,
                                                 int stream_id,
                                                 struct dai_properties *dst)
{
        const struct dai_driver_api *api = DEVICE_API_GET(dai, dev);
 
        if (!api->get_properties_copy) {
                return -ENOSYS;
        }
 
        return api->get_properties_copy(dev, dir, stream_id, dst);
}

__syscall int dai_trigger(const struct device *dev,
                          enum dai_dir dir,
                          enum dai_trigger_cmd cmd);
 
static inline int z_impl_dai_trigger(const struct device *dev,
                                     enum dai_dir dir,
                                     enum dai_trigger_cmd cmd)
{
        return DEVICE_API_GET(dai, dev)->trigger(dev, dir, cmd);
}

__syscall int dai_ts_config(const struct device *dev, struct dai_ts_cfg *cfg);
 
static inline int z_impl_dai_ts_config(const struct device *dev, struct dai_ts_cfg *cfg)
{
        const struct dai_driver_api *api = DEVICE_API_GET(dai, dev);
 
        if (!api->ts_config) {
                return -EINVAL;
        }
 
        return api->ts_config(dev, cfg);
}

__syscall int dai_ts_start(const struct device *dev, struct dai_ts_cfg *cfg);
 
static inline int z_impl_dai_ts_start(const struct device *dev, struct dai_ts_cfg *cfg)
{
        const struct dai_driver_api *api = DEVICE_API_GET(dai, dev);
 
        if (!api->ts_start) {
                return -EINVAL;
        }
 
        return api->ts_start(dev, cfg);
}

__syscall int dai_ts_stop(const struct device *dev, struct dai_ts_cfg *cfg);
 
static inline int z_impl_dai_ts_stop(const struct device *dev, struct dai_ts_cfg *cfg)
{
        const struct dai_driver_api *api = DEVICE_API_GET(dai, dev);
 
        if (!api->ts_stop) {
                return -EINVAL;
        }
 
        return api->ts_stop(dev, cfg);
}

__syscall int dai_ts_get(const struct device *dev, struct dai_ts_cfg *cfg,
                         struct dai_ts_data *tsd);
 
static inline int z_impl_dai_ts_get(const struct device *dev, struct dai_ts_cfg *cfg,
                                    struct dai_ts_data *tsd)
{
        const struct dai_driver_api *api = DEVICE_API_GET(dai, dev);
 
        if (!api->ts_get) {
                return -EINVAL;
        }
 
        return api->ts_get(dev, cfg, tsd);
}

__syscall int dai_config_update(const struct device *dev,
                                const void *bespoke_cfg,
                                size_t size);
 
static inline int z_impl_dai_config_update(const struct device *dev,
                                           const void *bespoke_cfg,
                                           size_t size)
{
        const struct dai_driver_api *api = DEVICE_API_GET(dai, dev);
 
        if (!api->config_update) {
                return -ENOSYS;
        }
 
        return api->config_update(dev, bespoke_cfg, size);
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/dai.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_DAI_H_ */