dai-zephyr.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>
 */
 
#ifndef __SOF_LIB_DAI_ZEPHYR_H__
#define __SOF_LIB_DAI_ZEPHYR_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 <sof/audio/component.h>
#include <ipc/dai.h>
#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <zephyr/device.h>
#include <zephyr/drivers/dai.h>
 
#include <sof/debug/telemetry/performance_monitor.h>
 
#define DAI_CREAT       BIT(0)
 
struct dai {
    uint32_t index;
    uint32_t type;
    uint32_t dma_caps;
    uint32_t dma_dev;
    const struct device *dev;
    const struct dai_data *dd;
    struct k_spinlock lock;     /* protect properties */
};
 
union hdalink_cfg {
    uint16_t full;
    struct {
        uint16_t lchan  :4;
        uint16_t hchan  :4;
        uint16_t stream :6;
        uint16_t rsvd   :1;
        uint16_t dir    :1;
    } part;
};
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 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 */
    int chan_index;
    uint32_t stream_id;
    struct dma_sg_config config;
    struct dma_config *z_config;
    struct comp_dev *dai_dev;
    struct comp_buffer *dma_buffer;
    struct comp_buffer *local_buffer;
    struct dai_ts_cfg ts_config;
    struct dai *dai;
    struct sof_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 DMA 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;
    /* fast mode, use one byte memory to save repreated cycles */
    bool fast_mode;
#if CONFIG_XRUN_NOTIFICATIONS_ENABLE
    bool xrun_notification_sent;
#endif
#ifdef CONFIG_SOF_TELEMETRY_IO_PERFORMANCE_MEASUREMENTS
    /* io performance measurement */
    struct io_perf_data_item *io_perf_dai_byte_count;
#endif
    /* Copier gain params */
    struct copier_gain_params *gain_data;
 
    struct mod_alloc_ctx alloc_ctx;
};
 
static inline void dai_write(struct dai *dai, uint32_t reg, uint32_t value)
{
}
 
static inline uint32_t dai_read(struct dai *dai, uint32_t reg)
{
    return 0;
}
 
static inline void dai_update_bits(struct dai *dai, uint32_t reg,
                   uint32_t mask, uint32_t value)
{
}
 
struct dai_group *dai_group_get(uint32_t group_id, uint32_t flags);
 
void dai_group_put(struct dai_group *group);
 
static inline int dai_init(struct sof *sof)
{
    return 0;
}
 
struct dai *dai_get(uint32_t type, uint32_t index, uint32_t flags);
 
void dai_put(struct dai *dai);
 
int dai_set_config(struct dai *dai, struct ipc_config_dai *config,
           const void *spec_config, size_t size);
 
int dai_get_handshake(struct dai *dai, int direction, int stream_id);
 
int dai_get_fifo_depth(struct dai *dai, int direction);
 
uint32_t dai_get_init_delay_ms(struct dai *dai);
 
int dai_get_stream_id(struct dai *dai, int direction);
 
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_cfg, const void *spec_cfg);
 
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);
 
__syscall const struct device *dai_get_device(enum sof_ipc_dai_type type, uint32_t index);
 
const struct device **dai_get_device_list(size_t *count);
#include <zephyr/syscalls/dai-zephyr.h>
 
#endif /* __SOF_LIB_DAI_ZEPHYR_H__ */