component.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_AUDIO_COMPONENT_H__
#define __SOF_AUDIO_COMPONENT_H__
 
#include <sof/audio/buffer.h>
#include <sof/audio/format.h>
#include <sof/audio/pipeline.h>
#include <sof/debug/telemetry/telemetry.h>
#include <rtos/mutex.h>
#include <rtos/userspace_data.h>
#include <sof/lib/uuid.h>
#include <ipc/control.h>
#include <sof/ipc/topology.h>
#include <kernel/abi.h>
 
#include <limits.h>
 
struct comp_dev;
struct sof_ipc_stream_posn;
struct dai_hw_params;
struct timestamp_data;
struct dai_ts_data;
struct dai_data;
struct task;
 
/* NOTE: Keep the component state diagram up to date:
 * sof-docs/developer_guides/firmware/components/images/comp-dev-states.pu
 */
 
#define COMP_STATE_NOT_EXIST    0   
#define COMP_STATE_INIT     1   
#define COMP_STATE_READY    2   
#define COMP_STATE_SUSPEND  3   
#define COMP_STATE_PREPARE  4   
#define COMP_STATE_PAUSED   5   
#define COMP_STATE_ACTIVE   6   
#define COMP_STATE_PRE_ACTIVE   7   
enum {
    COMP_TRIGGER_STOP,      
    COMP_TRIGGER_START,     
    COMP_TRIGGER_PAUSE,     
    COMP_TRIGGER_RELEASE,       
    COMP_TRIGGER_RESET,     
    COMP_TRIGGER_PREPARE,       
    COMP_TRIGGER_XRUN,      
    COMP_TRIGGER_PRE_START,     
    COMP_TRIGGER_PRE_RELEASE,   
    COMP_TRIGGER_POST_STOP,     
    COMP_TRIGGER_POST_PAUSE,    
    COMP_TRIGGER_NO_ACTION,     
};
#define COMP_CMD_SET_VALUE  100 
#define COMP_CMD_GET_VALUE  101     
#define COMP_CMD_SET_DATA   102     
#define COMP_CMD_GET_DATA   103     
#define COMP_CMD_IPC_MMAP_RPOS  200 
#define COMP_CMD_IPC_MMAP_PPOS  201 
#define COMP_CMD_IPC_MMAP_VOL(chan) (216 + chan)    
#define COMP_STATUS_STATE_ALREADY_SET   1   
#define COMP_ATTR_COPY_TYPE 0   
#define COMP_ATTR_HOST_BUFFER   1   
#define COMP_ATTR_COPY_DIR  2   
#define COMP_ATTR_VDMA_INDEX    3   
#define COMP_ATTR_BASE_CONFIG   4   
#define COMP_ATTR_IPC4_CONFIG   5   
#define trace_comp_drv_get_id(drv_p) (-1)
 
#define trace_comp_drv_get_subid(drv_p) (-1)
 
#define trace_comp_get_id(comp_p) ((comp_p)->ipc_config.pipeline_id)
 
#define trace_comp_get_subid(comp_p) ((comp_p)->ipc_config.id)
 
#if defined(__ZEPHYR__) && defined(CONFIG_ZEPHYR_LOG)
/* class (driver) level (no device object) tracing */
#define comp_cl_err(drv_p, __e, ...) LOG_ERR(__e, ##__VA_ARGS__)
 
#define comp_cl_warn(drv_p, __e, ...) LOG_WRN(__e, ##__VA_ARGS__)
 
#define comp_cl_info(drv_p, __e, ...) LOG_INF(__e, ##__VA_ARGS__)
 
#define comp_cl_dbg(drv_p, __e, ...) LOG_DBG(__e, ##__VA_ARGS__)
 
/* device level tracing */
 
#if CONFIG_IPC_MAJOR_4
#define __COMP_FMT "comp:%u %#x "
#else
#define __COMP_FMT "comp:%u.%u "
#endif
 
#define comp_err(comp_p, __e, ...) LOG_ERR(__COMP_FMT __e, trace_comp_get_id(comp_p), \
                       trace_comp_get_subid(comp_p), ##__VA_ARGS__)
 
#define comp_warn(comp_p, __e, ...) LOG_WRN(__COMP_FMT __e, trace_comp_get_id(comp_p), \
                        trace_comp_get_subid(comp_p), ##__VA_ARGS__)
 
#define comp_info(comp_p, __e, ...) LOG_INF(__COMP_FMT __e, trace_comp_get_id(comp_p), \
                        trace_comp_get_subid(comp_p), ##__VA_ARGS__)
 
#define comp_dbg(comp_p, __e, ...) LOG_DBG(__COMP_FMT __e, trace_comp_get_id(comp_p), \
                       trace_comp_get_subid(comp_p), ##__VA_ARGS__)
 
#else
#define trace_comp_drv_get_tr_ctx(drv_p) ((drv_p)->tctx)
 
#define trace_comp_get_tr_ctx(comp_p) (&(comp_p)->tctx)
 
/* class (driver) level (no device object) tracing */
 
#define comp_cl_err(drv_p, __e, ...)            \
    trace_dev_err(trace_comp_drv_get_tr_ctx,    \
              trace_comp_drv_get_id,        \
              trace_comp_drv_get_subid,     \
              drv_p,                \
              __e, ##__VA_ARGS__)
 
#define comp_cl_warn(drv_p, __e, ...)           \
    trace_dev_warn(trace_comp_drv_get_tr_ctx,   \
               trace_comp_drv_get_id,       \
               trace_comp_drv_get_subid,    \
               drv_p,               \
               __e, ##__VA_ARGS__)
 
#define comp_cl_info(drv_p, __e, ...)           \
    trace_dev_info(trace_comp_drv_get_tr_ctx,   \
               trace_comp_drv_get_id,       \
               trace_comp_drv_get_subid,    \
               drv_p,               \
               __e, ##__VA_ARGS__)
 
#define comp_cl_dbg(drv_p, __e, ...)            \
    trace_dev_dbg(trace_comp_drv_get_tr_ctx,    \
              trace_comp_drv_get_id,        \
              trace_comp_drv_get_subid,     \
              drv_p,                \
              __e, ##__VA_ARGS__)
 
/* device tracing */
 
#define comp_err(comp_p, __e, ...)                  \
    trace_dev_err(trace_comp_get_tr_ctx, trace_comp_get_id,     \
              trace_comp_get_subid, comp_p, __e, ##__VA_ARGS__)
 
#define comp_warn(comp_p, __e, ...)                 \
    trace_dev_warn(trace_comp_get_tr_ctx, trace_comp_get_id,    \
               trace_comp_get_subid, comp_p, __e, ##__VA_ARGS__)
 
#define comp_info(comp_p, __e, ...)                 \
    trace_dev_info(trace_comp_get_tr_ctx, trace_comp_get_id,    \
               trace_comp_get_subid, comp_p, __e, ##__VA_ARGS__)
 
#define comp_dbg(comp_p, __e, ...)                  \
    trace_dev_dbg(trace_comp_get_tr_ctx, trace_comp_get_id,     \
              trace_comp_get_subid, comp_p, __e, ##__VA_ARGS__)
 
#endif /* #if defined(__ZEPHYR__) && defined(CONFIG_ZEPHYR_LOG) */
 
#define comp_perf_info(pcd, comp_p)                 \
    comp_info(comp_p, "perf comp_copy peak plat %u cpu %u",     \
          (uint32_t)((pcd)->plat_delta_peak),           \
          (uint32_t)((pcd)->cpu_delta_peak))
 
#define comp_perf_avg_info(pcd, comp_p)                 \
    comp_info(comp_p, "perf comp_copy samples %u period %u cpu avg %u peak %u %u",\
          (uint32_t)((comp_p)->frames),            \
          (uint32_t)((comp_p)->period),             \
          (uint32_t)((pcd)->cpu_delta_sum),         \
          (uint32_t)((pcd)->cpu_delta_peak),            \
          (uint32_t)((pcd)->peak_mcps_period_cnt))
 
enum comp_endpoint_type {
    COMP_ENDPOINT_HOST, 
    COMP_ENDPOINT_DAI,  
    COMP_ENDPOINT_NODE  
};
 
enum comp_copy_type {
    COMP_COPY_INVALID = -1, 
    COMP_COPY_NORMAL = 0,   
    COMP_COPY_BLOCKING, 
    COMP_COPY_ONE_SHOT, 
};
 
struct comp_driver;
struct comp_ipc_config;
union ipc_config_specific;
struct ipc4_module_bind_unbind;
 
enum bind_type {
    COMP_BIND_TYPE_SOURCE,  
    COMP_BIND_TYPE_SINK 
};
 
struct bind_info {
    const struct ipc4_module_bind_unbind *ipc4_data;    
    enum bind_type bind_type;               
    /* pointers to sink or source API of the data provider/consumer
     * that is being bound to the module
     */
    union {
        struct sof_source *source;          
        struct sof_sink *sink;              
    };
};
 
struct comp_ops {
    struct comp_dev *(*create)(const struct comp_driver *drv,
                   const struct comp_ipc_config *ipc_config,
                   const void *spec);
 
    void (*free)(struct comp_dev *dev);
 
    int (*params)(struct comp_dev *dev,
              struct sof_ipc_stream_params *params);
 
    int (*dai_get_hw_params)(struct comp_dev *dev,
                 struct sof_ipc_stream_params *params, int dir);
 
    int (*dai_config)(struct dai_data *dd, struct comp_dev *dev,
              struct ipc_config_dai *dai_config, const void *dai_spec_config);
 
#if CONFIG_IPC_MAJOR_3 || CONFIG_LIBRARY
    int (*cmd)(struct comp_dev *dev, int cmd, void *data,
           int max_data_size);
#endif
 
    int (*trigger)(struct comp_dev *dev, int cmd);
 
    int (*prepare)(struct comp_dev *dev);
 
    int (*reset)(struct comp_dev *dev);
 
    int (*copy)(struct comp_dev *dev);
 
    int (*position)(struct comp_dev *dev,
        struct sof_ipc_stream_posn *posn);
 
    int (*get_attribute)(struct comp_dev *dev, uint32_t type,
                 void *value);
 
    int (*set_attribute)(struct comp_dev *dev, uint32_t type,
                 void *value);
 
    int (*dai_ts_config)(struct comp_dev *dev);
 
    int (*dai_ts_start)(struct comp_dev *dev);
 
    int (*dai_ts_stop)(struct comp_dev *dev);
 
#if CONFIG_ZEPHYR_NATIVE_DRIVERS
    int (*dai_ts_get)(struct comp_dev *dev, struct dai_ts_data *tsd);
#else
    int (*dai_ts_get)(struct comp_dev *dev,
              struct timestamp_data *tsd);
#endif
 
    int (*bind)(struct comp_dev *dev, const struct bind_info *bind_data);
 
    int (*unbind)(struct comp_dev *dev, const struct bind_info *unbind_data);
 
    int (*get_large_config)(struct comp_dev *dev, uint32_t param_id,
                bool first_block,
                bool last_block,
                uint32_t *data_offset,
                char *data);
 
    int (*set_large_config)(struct comp_dev *dev, uint32_t param_id,
                bool first_block,
                bool last_block,
                uint32_t data_offset,
                const char *data);
 
    uint64_t (*get_total_data_processed)(struct comp_dev *dev, uint32_t stream_no, bool input);
};
 
#if CONFIG_ZEPHYR_LOG
#define SOF_DRV_UID_NAME(drv) (drv)->uid
#else
#define SOF_DRV_UID_NAME(drv) (drv)->tctx->uuid_p
#endif
 
struct comp_driver {
    uint32_t type;                  
    const struct sof_uuid *uid;         
#if !CONFIG_ZEPHYR_LOG
    struct tr_ctx *tctx;                
#endif
    struct comp_ops ops;                
    const struct module_interface *adapter_ops; 
    struct k_heap *user_heap;           
    struct sof_uuid uid_cp;             
};
 
struct comp_driver_info {
    const struct comp_driver *drv;          
    const struct module_interface **adapter_ops;    
    struct list_item list;              
};
 
#define COMP_PROCESSING_DOMAIN_LL 0 
#define COMP_PROCESSING_DOMAIN_DP 1 
struct comp_ipc_config {
    uint32_t core;          
    uint32_t id;            
    uint32_t pipeline_id;       
    uint32_t proc_domain;       
    enum sof_comp_type type;    
    uint32_t periods_sink;      
    uint32_t periods_source;    
    uint32_t frame_fmt;     
    uint32_t xrun_action;       
#if CONFIG_IPC_MAJOR_4
    bool ipc_extended_init;     
    uint32_t ipc_config_size;   
#endif
};
 
struct comp_perf_data {
    size_t peak_of_measured_cpc;        
    struct perf_data_item_comp *perf_data_item; 
};
 
struct comp_dev {
    /* runtime */
    uint16_t state;        
    uint32_t frames;       
    bool expect_eos;       
    struct pipeline *pipeline; 
    struct task *task;  
    uint32_t size;      
    uint32_t period;    
    uint32_t priority;  
    bool is_shared;     
    struct comp_ipc_config ipc_config;  
#if !CONFIG_ZEPHYR_LOG
    struct tr_ctx tctx; 
#endif
 
    /* common runtime configuration for downstream/upstream */
    uint32_t direction; 
    bool direction_set; 
    const struct comp_driver *drv;  
    struct processing_module *mod;  
    /* lists */
    struct list_item bsource_list;  
    struct list_item bsink_list;    
    /* performance data*/
    struct comp_perf_data perf_data;    
    size_t ibs;     
    size_t obs;     
    size_t cpc;     
    size_t ll_chunk_size : 16;  
    /* private data - core does not touch this */
    void *priv_data;    
#if CONFIG_PERFORMANCE_COUNTERS_COMPONENT
    struct perf_cnt_data pcd;   
#endif
 
#if CONFIG_KCPS_DYNAMIC_CLOCK_CONTROL
    int32_t kcps_inc[CONFIG_CORE_COUNT];    
#endif
};
 
static inline struct comp_buffer *comp_dev_get_first_data_producer(struct comp_dev *component)
{
    return list_is_empty(&component->bsource_list) ? NULL :
           list_first_item(&component->bsource_list, struct comp_buffer, sink_list);
}
 
static inline struct comp_buffer *comp_dev_get_next_data_producer(struct comp_dev *component,
                                  struct comp_buffer *producer)
{
    return producer->sink_list.next == &component->bsource_list ? NULL :
           list_item(producer->sink_list.next, struct comp_buffer, sink_list);
}
 
static inline struct comp_buffer *comp_dev_get_next_data_producer_safe(struct comp_dev *component,
                                       struct comp_buffer *producer)
{
    return producer ? comp_dev_get_next_data_producer(component, producer) : NULL;
}
 
static inline struct comp_buffer *comp_dev_get_first_data_consumer(struct comp_dev *component)
{
    return list_is_empty(&component->bsink_list) ? NULL :
           list_first_item(&component->bsink_list, struct comp_buffer, source_list);
}
 
static inline struct comp_buffer *comp_dev_get_next_data_consumer(struct comp_dev *component,
                                  struct comp_buffer *consumer)
{
    return consumer->source_list.next == &component->bsink_list ? NULL :
            list_item(consumer->source_list.next, struct comp_buffer, source_list);
}
 
static inline struct comp_buffer *comp_dev_get_next_data_consumer_safe(struct comp_dev *component,
                                       struct comp_buffer *consumer)
{
    return consumer ? comp_dev_get_next_data_consumer(component, consumer) : NULL;
}
 
#define comp_dev_for_each_producer(_dev, _producer)         \
    for (_producer = comp_dev_get_first_data_producer(_dev);    \
         _producer != NULL;                     \
         _producer = comp_dev_get_next_data_producer(_dev, _producer))
 
#define comp_dev_for_each_producer_safe(_dev, _producer, _next_producer)        \
    for (_producer = comp_dev_get_first_data_producer(_dev),            \
         _next_producer = comp_dev_get_next_data_producer_safe(_dev, _producer);    \
         _producer != NULL;                             \
         _producer = _next_producer,                        \
         _next_producer = comp_dev_get_next_data_producer_safe(_dev, _producer))
 
#define comp_dev_for_each_consumer(_dev, _consumer)             \
    for (_consumer = comp_dev_get_first_data_consumer(_dev);        \
         _consumer != NULL;                         \
         _consumer = comp_dev_get_next_data_consumer(_dev, _consumer))  \
 
#define comp_dev_for_each_consumer_safe(_dev, _consumer, _next_consumer)        \
    for (_consumer = comp_dev_get_first_data_consumer(_dev),            \
         _next_consumer = comp_dev_get_next_data_consumer_safe(_dev, _consumer);    \
         _consumer != NULL;                             \
         _consumer = _next_consumer,                        \
         _next_consumer = comp_dev_get_next_data_consumer_safe(_dev, _consumer))
 
/* Common helper function used internally by the component implementations
 * begin here.
 */
 
struct comp_copy_limits {
    int frames;         
    int source_bytes;       
    int sink_bytes;         
    int source_frame_bytes;     
    int sink_frame_bytes;       
};
 
static inline uint32_t dev_comp_id(const struct comp_dev *dev)
{
    return dev->ipc_config.id;
}
 
static inline uint32_t dev_comp_pipe_id(const struct comp_dev *dev)
{
    return dev->ipc_config.pipeline_id;
}
 
static inline enum sof_comp_type dev_comp_type(const struct comp_dev *dev)
{
    return dev->ipc_config.type;
}
 
static inline void comp_init(const struct comp_driver *drv,
                 struct comp_dev *dev, size_t bytes)
{
    dev->size = bytes;
    dev->drv = drv;
    dev->state = COMP_STATE_INIT;
    list_init(&dev->bsink_list);
    list_init(&dev->bsource_list);
#if !CONFIG_ZEPHYR_LOG
    memcpy_s(&dev->tctx, sizeof(dev->tctx),
         trace_comp_drv_get_tr_ctx(dev->drv), sizeof(struct tr_ctx));
#endif
}
 
static inline struct comp_dev *comp_alloc(const struct comp_driver *drv, size_t bytes)
{
    /*
     * Use uncached address everywhere to access components to rule out
     * multi-core failures. TODO: verify if cached alias may be used in some cases
     */
    struct comp_dev *dev = sof_heap_alloc(drv->user_heap,
                          SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT,
                          bytes, 0);
 
    if (!dev)
        return NULL;
 
    memset(dev, 0, sizeof(*dev));
    comp_init(drv, dev, bytes);
 
    return dev;
}
 
static inline void comp_free_device(struct comp_dev *dev)
{
    sof_heap_free(dev->drv->user_heap, dev);
}
 
static inline struct processing_module *comp_mod(const struct comp_dev *dev)
{
    return dev->mod;
}
 
#define comp_set_drvdata(c, data) \
    (c->priv_data = data)
 
#define comp_get_drvdata(c) \
    (c->priv_data)
 
#if defined UNIT_TEST || defined __ZEPHYR__  || CONFIG_LIBRARY
#define DECLARE_MODULE(init)
 
/* declared modules */
void sys_comp_dai_init(void);
void sys_comp_host_init(void);
void sys_comp_kpb_init(void);
void sys_comp_selector_init(void);
 
/* Start of modules in alphabetical order */
void sys_comp_module_aria_interface_init(void);
void sys_comp_module_asrc_interface_init(void);
void sys_comp_module_copier_interface_init(void);
void sys_comp_module_crossover_interface_init(void);
void sys_comp_module_dcblock_interface_init(void);
void sys_comp_module_demux_interface_init(void);
void sys_comp_module_dolby_dax_audio_processing_interface_init(void);
void sys_comp_module_drc_interface_init(void);
void sys_comp_module_dts_interface_init(void);
void sys_comp_module_eq_fir_interface_init(void);
void sys_comp_module_eq_iir_interface_init(void);
void sys_comp_module_gain_interface_init(void);
void sys_comp_module_google_rtc_audio_processing_interface_init(void);
void sys_comp_module_google_ctc_audio_processing_interface_init(void);
void sys_comp_module_igo_nr_interface_init(void);
void sys_comp_module_level_multiplier_interface_init(void);
void sys_comp_module_mfcc_interface_init(void);
void sys_comp_module_mixer_interface_init(void);
void sys_comp_module_mixin_interface_init(void);
void sys_comp_module_mixout_interface_init(void);
void sys_comp_module_multiband_drc_interface_init(void);
void sys_comp_module_mux_interface_init(void);
void sys_comp_module_nxp_eap_interface_init(void);
void sys_comp_module_phase_vocoder_interface_init(void);
void sys_comp_module_rtnr_interface_init(void);
void sys_comp_module_selector_interface_init(void);
void sys_comp_module_sound_dose_interface_init(void);
void sys_comp_module_src_interface_init(void);
void sys_comp_module_src_lite_interface_init(void);
void sys_comp_module_stft_process_interface_init(void);
void sys_comp_module_tdfb_interface_init(void);
void sys_comp_module_tone_interface_init(void);
void sys_comp_module_template_interface_init(void);
void sys_comp_module_tester_interface_init(void);
void sys_comp_module_volume_interface_init(void);
/* End of modules in alphabetical order */
 
#elif CONFIG_LIBRARY
/* In case of shared libs components are initialised in dlopen */
#define DECLARE_MODULE(init) __attribute__((constructor)) \
    static void _module_##init(void) { init(); }
#else
#define DECLARE_MODULE(init) __attribute__((__used__)) \
    __section(".initcall") static void(*f##init)(void) = init
#endif
 
int comp_register(struct comp_driver_info *drv);
 
void comp_unregister(struct comp_driver_info *drv);
 
int comp_set_adapter_ops(const struct comp_driver *drv, const struct module_interface *ops);
 
const struct comp_driver *comp_driver_find(const struct sof_uuid *uuid, uint32_t type);
 
int comp_set_state(struct comp_dev *dev, int cmd);
 
static inline void component_set_nearest_period_frames(struct comp_dev *current,
                               uint32_t rate)
{
    uint64_t frames;
 
    /* Sample rate is in Hz and period in microseconds.
     * As we don't have floats use scale divider 1000000.
     * Also integer round up the result.
     * dma buffer size should align with 32bytes which can't be
     * compatible with current 45K adjustment. 48K is a suitable
     * adjustment.
     */
 
    switch (rate) {
    case 44100:
        rate = 48000;
        break;
    case 88200:
        rate = 96000;
        break;
    case 176400:
        rate = 192000;
        break;
    default:
        break;
    }
 
    frames = SOF_DIV_ROUND_UP((uint64_t)rate * current->period, 1000000);
 
    assert(frames <= UINT_MAX);
    current->frames = (uint32_t)frames;
}
 
static inline void comp_underrun(struct comp_dev *dev,
                 struct comp_buffer *source,
                 uint32_t copy_bytes)
{
    LOG_MODULE_DECLARE(component, CONFIG_SOF_LOG_LEVEL);
 
    int32_t bytes = (int32_t)audio_stream_get_avail_bytes(&source->stream) -
            copy_bytes;
 
    comp_err(dev, "comp_underrun(): dev->comp.id = %u, source->avail = %u, copy_bytes = %u",
         dev_comp_id(dev),
         audio_stream_get_avail_bytes(&source->stream),
         copy_bytes);
 
    pipeline_xrun(dev->pipeline, dev, bytes);
}
 
static inline void comp_overrun(struct comp_dev *dev, struct comp_buffer *sink,
                uint32_t copy_bytes)
{
    LOG_MODULE_DECLARE(component, CONFIG_SOF_LOG_LEVEL);
 
    int32_t bytes = (int32_t)copy_bytes -
            audio_stream_get_free_bytes(&sink->stream);
 
    comp_err(dev, "comp_overrun(): sink->free = %u, copy_bytes = %u",
         audio_stream_get_free_bytes(&sink->stream), copy_bytes);
 
    pipeline_xrun(dev->pipeline, dev, bytes);
}
 
void comp_get_copy_limits(struct comp_buffer *source,
              struct comp_buffer *sink,
              struct comp_copy_limits *cl);
 
void comp_get_copy_limits_frame_aligned(const struct comp_buffer *source,
                    const struct comp_buffer *sink,
                    struct comp_copy_limits *cl);
 
static inline int comp_get_state(const struct comp_dev *dev)
{
    if (!dev)
        return COMP_STATE_NOT_EXIST;
    return dev->state;
}
 
static inline int comp_buffer_get_source_state(const struct comp_buffer *buffer)
{
    return comp_get_state(comp_buffer_get_source_component(buffer));
}
 
static inline int comp_buffer_get_sink_state(const struct comp_buffer *buffer)
{
    return comp_get_state(comp_buffer_get_sink_component(buffer));
}
 
int comp_verify_params(struct comp_dev *dev, uint32_t flag,
               struct sof_ipc_stream_params *params);
 
void comp_update_ibs_obs_cpc(struct comp_dev *dev);
 
void comp_init_performance_data(struct comp_dev *dev);
 
bool comp_update_performance_data(struct comp_dev *dev, uint32_t cycles_used);
 
static inline int user_get_buffer_memory_region(const struct comp_driver *drv)
{
#if CONFIG_SOF_USERSPACE_USE_DRIVER_HEAP
    return drv->user_heap ? SOF_MEM_FLAG_USER_SHARED_BUFFER : SOF_MEM_FLAG_USER;
#else
    return SOF_MEM_FLAG_USER;
#endif
}
 
#endif /* __SOF_AUDIO_COMPONENT_H__ */