dai-legacy.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2016 Intel Corporation. All rights reserved.
 *
 * Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
 *         Keyon Jie <yang.jie@linux.intel.com>
 *
 * Renamed from dai.h to dai-legacy.h because of Zephyr refactoring and
 * the file content has not changed.
 */

 
#ifndef __SOF_LIB_DAI_LEGACY_H__
#define __SOF_LIB_DAI_LEGACY_H__
 
#include <platform/lib/dai.h>
#include <rtos/bit.h>
#include <sof/list.h>
#include <sof/lib/io.h>
#include <sof/lib/memory.h>
#include <sof/lib/dma.h>
#include <sof/list.h>
#include <rtos/sof.h>
#include <rtos/spinlock.h>
#include <sof/trace/trace.h>
#include <sof/ipc/topology.h>
#include <sof/audio/pcm_converter.h>
#include <sof/audio/ipc-config.h>
#include <errno.h>
#include <stddef.h>
#include <stdint.h>
 
struct dai;
struct sof_ipc_stream_params;

 
#define DAI_CLOCK_IN        0
#define DAI_CLOCK_OUT       1
 
#define DAI_DIR_PLAYBACK    0
#define DAI_DIR_CAPTURE     1
 
#define DAI_NUM_SLOT_MAPS   8
 
#define DAI_INFO_TYPE       0
#define DAI_INFO_DMA_CAPS   1
#define DAI_INFO_DMA_DEV    2
 
/* DAI flags */

#define DAI_FLAGS_IRQ_CB    BIT(0)
 
/* DAI get() flags */

#define DAI_CREAT       BIT(0)

struct dai_ops {
    int (*set_config)(struct dai *dai, struct ipc_config_dai *config,
              const void *spec_config);
    int (*trigger)(struct dai *dai, int cmd, int direction);
    int (*get_hw_params)(struct dai *dai,
                 struct sof_ipc_stream_params *params, int dir);
    int (*hw_params)(struct dai *dai, struct sof_ipc_stream_params *params);
    int (*get_handshake)(struct dai *dai, int direction, int stream_id);
    int (*get_fifo)(struct dai *dai, int direction, int stream_id);
    int (*probe)(struct dai *dai);
    int (*remove)(struct dai *dai);
    uint32_t (*get_init_delay_ms)(struct dai *dai);
    int (*get_fifo_depth)(struct dai *dai, int direction);
    void (*copy)(struct dai *dai);  /* Can be used by DAIs to prepare for data copying */
};
 
struct timestamp_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; /* GPDMA id*/
    int dma_chan_index; /* Used GPDMA channel */
    int dma_chan_count; /* Channels in single GPDMA */
};
 
struct timestamp_data {
    uint64_t walclk; /* Wall clock */
    uint64_t sample; /* Sample count */
    uint32_t walclk_rate; /* Rate in Hz, e.g. 19200000 */
};
 
struct timestamp_ops {
    int (*ts_config)(struct dai *dai, struct timestamp_cfg *cfg);
    int (*ts_start)(struct dai *dai, struct timestamp_cfg *cfg);
    int (*ts_stop)(struct dai *dai, struct timestamp_cfg *cfg);
    int (*ts_get)(struct dai *dai, struct timestamp_cfg *cfg,
              struct timestamp_data *tsd);
};
 
struct dai_driver {
    uint32_t type;  
    const struct sof_uuid_entry *uid;
    struct tr_ctx *tctx;
    uint32_t dma_caps;
    uint32_t dma_dev;
    struct dai_ops ops;
    struct timestamp_ops ts_ops;
};

struct dai_slot_map {
    uint32_t channel;   
    uint32_t slot;      
};
 
struct dai_plat_fifo_data {
    uint32_t offset;
    uint32_t width;
    uint32_t depth;
    uint32_t watermark;
    uint32_t handshake;
};

struct dai_plat_data {
    uint32_t base;
    int irq;
    const char *irq_name;
    uint32_t flags;
    struct dai_plat_fifo_data fifo[2];
};

struct llp_slot_info {
    uint32_t node_id;
    uint32_t reg_offset;
};
 
typedef int (*channel_copy_func)(const struct audio_stream *src, unsigned int src_channel,
                 struct audio_stream *dst, unsigned int dst_channel,
                 unsigned int frames);

struct dai_data {
    /* local DMA config */
    struct dma_chan_data *chan;
    uint32_t stream_id;
    struct dma_sg_config config;
    struct comp_dev *dai_dev;
    struct comp_buffer *dma_buffer;
    struct comp_buffer *local_buffer;
    struct timestamp_cfg ts_config;
    struct dai *dai;
    struct dma *dma;
    struct dai_group *group;        /* NULL if no group assigned */
    int xrun;               /* true if we are doing xrun recovery */
 
    pcm_converter_func process;     /* processing function */
    uint32_t chmap;
    channel_copy_func channel_copy;     /* channel copy func used by multi-endpoint
                         * gateway to mux/demux stream from/to multiple
                         * DMA buffers
                         */
 
    uint32_t period_bytes;          /* number of bytes per one period */
    uint64_t total_data_processed;
 
    struct ipc_config_dai ipc_config;   /* generic common config */
    void *dai_spec_config;          /* dai specific config from the host */
 
    uint64_t wallclock;         /* wall clock at stream start */
 
    /*
     * flag indicating two-step stop/pause for DAI comp and DAI DMA.
     * DAI stop occurs during STREAM_TRIG_STOP IPC and DMA stop during DAI_CONFIG IPC with
     * the SOF_DAI_CONFIG_FLAGS_HW_FREE flag.
     * DAI pause occurs during STREAM_TRIG_PAUSE IPC and DMA pause during DAI_CONFIG IPC with
     * the SOF_DAI_CONFIG_FLAGS_PAUSE flag.
     */
    bool delayed_dma_stop;
 
    /* llp slot info in memory windows */
    struct llp_slot_info slot_info;
 
    /* Copier gain params */
    struct copier_gain_params *gain_data;
};
 
struct dai {
    uint32_t index;     
    uint32_t type;      
    struct k_spinlock lock; 
    int sref;       
    struct dai_plat_data plat_data;
    const struct dai_driver *drv;
    const struct dai_data *dd;
    void *priv_data;
};

struct dai_type_info {
    uint32_t type;      
    struct dai *dai_array;  
    size_t num_dais;    
};
 
/* dai tracing */
#define trace_dai_drv_get_tr_ctx(drv_p) ((drv_p)->tctx)
#define trace_dai_drv_get_id(drv_p) (-1)
#define trace_dai_drv_get_subid(drv_p) (-1)
 
#define trace_dai_get_tr_ctx(dai_p) ((dai_p)->drv->tctx)
#define trace_dai_get_id(dai_p) ((dai_p)->drv->type)
#define trace_dai_get_subid(dai_p) ((dai_p)->index)
 
#if defined(__ZEPHYR__) && defined(CONFIG_ZEPHYR_LOG)
/* driver level tracing */
#define dai_cl_err(drv_p, __e, ...) LOG_ERR(__e, ##__VA_ARGS__)
 
#define dai_cl_warn(drv_p, __e, ...) LOG_WRN(__e, ##__VA_ARGS__)
 
#define dai_cl_info(drv_p, __e, ...) LOG_INF(__e, ##__VA_ARGS__)
 
#define dai_cl_dbg(drv_p, __e, ...) LOG_DBG(__e, ##__VA_ARGS__)
 
/* device level tracing */
#define dai_err(dai_p, __e, ...) LOG_ERR(__e, ##__VA_ARGS__)
 
#define dai_warn(dai_p, __e, ...) LOG_WRN(__e, ##__VA_ARGS__)
 
#define dai_info(dai_p, __e, ...) LOG_INF(__e, ##__VA_ARGS__)
 
#define dai_dbg(dai_p, __e, ...) LOG_DBG(__e, ##__VA_ARGS__)
 
#else
/* class (driver) level (no device object) tracing */
 
#define dai_cl_err(drv_p, __e, ...)     \
    trace_dev_err(trace_dai_drv_get_tr_ctx, \
              trace_dai_drv_get_id, \
              trace_dai_drv_get_subid,  \
              drv_p, __e, ##__VA_ARGS__)
 
#define dai_cl_warn(drv_p, __e, ...)        \
    trace_dev_warn(trace_dai_drv_get_tr_ctx,\
               trace_dai_drv_get_id,    \
               trace_dai_drv_get_subid, \
               drv_p, __e, ##__VA_ARGS__)
 
#define dai_cl_info(drv_p, __e, ...)        \
    trace_dev_info(trace_dai_drv_get_tr_ctx,\
               trace_dai_drv_get_id,    \
               trace_dai_drv_get_subid, \
               drv_p, __e, ##__VA_ARGS__)
 
#define dai_cl_dbg(drv_p, __e, ...)     \
    trace_dev_dbg(trace_dai_drv_get_tr_ctx, \
              trace_dai_drv_get_id, \
              trace_dai_drv_get_subid,  \
              drv_p, __e, ##__VA_ARGS__)
 
/* device tracing */
 
#define dai_err(dai_p, __e, ...)                    \
    trace_dev_err(trace_dai_get_tr_ctx,             \
              trace_dai_get_id,                 \
              trace_dai_get_subid, dai_p, __e, ##__VA_ARGS__)
 
#define dai_warn(dai_p, __e, ...)                   \
    trace_dev_warn(trace_dai_get_tr_ctx,                \
               trace_dai_get_id,                \
               trace_dai_get_subid, dai_p, __e, ##__VA_ARGS__)
 
#define dai_info(dai_p, __e, ...)                   \
    trace_dev_info(trace_dai_get_tr_ctx,                \
               trace_dai_get_id,                \
               trace_dai_get_subid, dai_p, __e, ##__VA_ARGS__)
 
#define dai_dbg(dai_p, __e, ...)                    \
    trace_dev_dbg(trace_dai_get_tr_ctx,             \
              trace_dai_get_id,                 \
              trace_dai_get_subid, dai_p, __e, ##__VA_ARGS__)
 
#endif /* #if defined(__ZEPHYR__) && defined(CONFIG_ZEPHYR_LOG) */

struct dai_group *dai_group_get(uint32_t group_id, uint32_t flags);

void dai_group_put(struct dai_group *group);

struct dai_group {
    uint32_t group_id;

    uint32_t num_dais;

    uint32_t trigger_counter;

    int trigger_cmd;

    int trigger_ret;

    struct list_item list;
};

struct dai_info {
    const struct dai_type_info *dai_type_array;
    size_t num_dai_types;
};

int dai_init(struct sof *sof);

struct dai *dai_get(uint32_t type, uint32_t index, uint32_t flags);

void dai_put(struct dai *dai);
 
#define dai_set_drvdata(dai, data) \
    (dai->priv_data = data)
#define dai_get_drvdata(dai) \
    dai->priv_data
#define dai_base(dai) \
    dai->plat_data.base
#define dai_irq(dai) \
    dai->plat_data.irq
#define dai_fifo(dai, direction) \
    dai->plat_data.fifo[direction].offset

static inline int dai_set_config(struct dai *dai, struct ipc_config_dai *config,
                 const void *spec_config, size_t size)
{
    return dai->drv->ops.set_config(dai, config, spec_config);
}

static inline int dai_trigger(struct dai *dai, int cmd, int direction)
{
    return dai->drv->ops.trigger(dai, cmd, direction);
}

static inline int dai_get_hw_params(struct dai *dai,
                    struct sof_ipc_stream_params *params,
                    int dir)
{
    return dai->drv->ops.get_hw_params(dai, params, dir);
}

static inline int dai_hw_params(struct dai *dai,
                struct sof_ipc_stream_params *params)
{
    if (dai->drv->ops.hw_params)
        return dai->drv->ops.hw_params(dai, params);
 
    return 0;
}

static inline int dai_get_handshake(struct dai *dai, int direction,
                    int stream_id)
{
    return dai->drv->ops.get_handshake(dai, direction, stream_id);
}

static inline int dai_get_fifo(struct dai *dai, int direction,
                   int stream_id)
{
    return dai->drv->ops.get_fifo(dai, direction, stream_id);
}

static inline int dai_probe(struct dai *dai)
{
    return dai->drv->ops.probe(dai);
}

static inline int dai_remove(struct dai *dai)
{
    return dai->drv->ops.remove(dai);
}

static inline uint32_t dai_get_init_delay_ms(struct dai *dai)
{
    if (dai && dai->drv->ops.get_init_delay_ms)
        return dai->drv->ops.get_init_delay_ms(dai);
 
    return 0;
}
 
static inline int dai_get_fifo_depth(struct dai *dai, int direction)
{
    if (dai && dai->drv->ops.get_fifo_depth)
        return dai->drv->ops.get_fifo_depth(dai, direction);
 
    return 0;
}

static inline int dai_get_info(struct dai *dai, int info)
{
    int ret;
 
    switch (info) {
    case DAI_INFO_TYPE:
        ret = dai->drv->type;
        break;
    case DAI_INFO_DMA_CAPS:
        ret = dai->drv->dma_caps;
        break;
    case DAI_INFO_DMA_DEV:
        ret = dai->drv->dma_dev;
        break;
    default:
        ret = -EINVAL;
        break;
    }
 
    return ret;
}
 
static inline void dai_write(struct dai *dai, uint32_t reg, uint32_t value)
{
    io_reg_write(dai_base(dai) + reg, value);
}
 
static inline uint32_t dai_read(struct dai *dai, uint32_t reg)
{
    return io_reg_read(dai_base(dai) + reg);
}
 
static inline void dai_update_bits(struct dai *dai, uint32_t reg,
                   uint32_t mask, uint32_t value)
{
    io_reg_update_bits(dai_base(dai) + reg, mask, value);
}
 
static inline const struct dai_info *dai_info_get(void)
{
    return sof_get()->dai_info;
}

int dai_config_dma_channel(struct dai_data *dd, struct comp_dev *dev, const void *config);

void dai_set_link_hda_config(uint16_t *link_config,
                 struct ipc_config_dai *common_config,
                 const void *spec_config);

void dai_dma_release(struct dai_data *dd, struct comp_dev *dev);

int dai_config(struct dai_data *dd, struct comp_dev *dev,  struct ipc_config_dai *common_config,
           const void *spec_config);

int dai_assign_group(struct dai_data *dd, struct comp_dev *dev, uint32_t group_id);

int dai_position(struct comp_dev *dev, struct sof_ipc_stream_posn *posn);

void dai_dma_position_update(struct dai_data *dd, struct comp_dev *dev);

void dai_release_llp_slot(struct dai_data *dd);
 
#endif /* __SOF_LIB_DAI_LEGACY_H__ */