static_pipeline.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2026 Sound Open Firmware (SOF) Project
 */
 
#ifndef __SOF_AUDIO_PIPELINE_STATIC_PIPELINE_H__
#define __SOF_AUDIO_PIPELINE_STATIC_PIPELINE_H__
 
#include <sof/audio/pipeline.h>
#include <sof/audio/component.h>
#include <sof/audio/buffer.h>
#include <sof/audio/format.h>
#include <ipc/topology.h>
#include <ipc/control.h>
#include <ipc/stream.h>
#include <ipc/dai.h>
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* =========================================================================
 * Audio Format & Pipeline Capabilities
 * ========================================================================= */
 
#define SOF_STATIC_RATE_8K      SOF_RATE_8000     
#define SOF_STATIC_RATE_11K     SOF_RATE_11025    
#define SOF_STATIC_RATE_12K     SOF_RATE_12000    
#define SOF_STATIC_RATE_16K     SOF_RATE_16000    
#define SOF_STATIC_RATE_22K     SOF_RATE_22050    
#define SOF_STATIC_RATE_24K     SOF_RATE_24000    
#define SOF_STATIC_RATE_32K     SOF_RATE_32000    
#define SOF_STATIC_RATE_44K1    SOF_RATE_44100    
#define SOF_STATIC_RATE_48K     SOF_RATE_48000    
#define SOF_STATIC_RATE_64K     SOF_RATE_64000    
#define SOF_STATIC_RATE_88K2    SOF_RATE_88200    
#define SOF_STATIC_RATE_96K     SOF_RATE_96000    
#define SOF_STATIC_RATE_176K4   SOF_RATE_176400   
#define SOF_STATIC_RATE_192K    SOF_RATE_192000   
#define SOF_STATIC_RATE_384K    (1 << 14)         
#define SOF_STATIC_FMT_S16_LE       BIT(SOF_IPC_FRAME_S16_LE)
#define SOF_STATIC_FMT_S24_4LE      BIT(SOF_IPC_FRAME_S24_4LE)
#define SOF_STATIC_FMT_S32_LE       BIT(SOF_IPC_FRAME_S32_LE)
#define SOF_STATIC_FMT_FLOAT        BIT(SOF_IPC_FRAME_FLOAT)
#define SOF_STATIC_FMT_S24_3LE      BIT(SOF_IPC_FRAME_S24_3LE)
#define SOF_STATIC_FMT_S24_4LE_MSB  BIT(SOF_IPC_FRAME_S24_4LE_MSB)
#define SOF_STATIC_FMT_U8           BIT(SOF_IPC_FRAME_U8)
#define SOF_STATIC_FMT_S16_4LE      BIT(SOF_IPC_FRAME_S16_4LE)
#define SOF_STATIC_FMT_A_LAW        BIT(SOF_IPC_FRAME_A_LAW)
#define SOF_STATIC_FMT_MU_LAW       BIT(SOF_IPC_FRAME_MU_LAW)
 
#define SOF_STATIC_RATE_MASK_ALL \
    (SOF_STATIC_RATE_8K | SOF_STATIC_RATE_11K | SOF_STATIC_RATE_12K | \
     SOF_STATIC_RATE_16K | SOF_STATIC_RATE_22K | SOF_STATIC_RATE_24K | \
     SOF_STATIC_RATE_32K | SOF_STATIC_RATE_44K1 | SOF_STATIC_RATE_48K | \
     SOF_STATIC_RATE_64K | SOF_STATIC_RATE_88K2 | SOF_STATIC_RATE_96K | \
     SOF_STATIC_RATE_176K4 | SOF_STATIC_RATE_192K | SOF_STATIC_RATE_384K)
 
#define SOF_STATIC_FMT_MASK_ALL \
    (SOF_STATIC_FMT_S16_LE | SOF_STATIC_FMT_S24_4LE | SOF_STATIC_FMT_S32_LE | \
     SOF_STATIC_FMT_FLOAT | SOF_STATIC_FMT_S24_3LE | SOF_STATIC_FMT_S24_4LE_MSB | \
     SOF_STATIC_FMT_U8 | SOF_STATIC_FMT_S16_4LE | SOF_STATIC_FMT_A_LAW | \
     SOF_STATIC_FMT_MU_LAW)
 
struct sof_static_caps {
    uint32_t formats;       
    uint32_t rates;         
    uint16_t min_channels;  
    uint16_t max_channels;  
    uint32_t default_rate;  
    uint32_t sink_rate;     
    enum sof_ipc_frame default_fmt; 
};
 
#define SOF_STATIC_CAPS(_fmt, _rate, _ch) \
    { \
        .formats = BIT(_fmt), \
        .rates = (_rate == 8000) ? SOF_STATIC_RATE_8K : \
             (_rate == 11025) ? SOF_STATIC_RATE_11K : \
             (_rate == 12000) ? SOF_STATIC_RATE_12K : \
             (_rate == 16000) ? SOF_STATIC_RATE_16K : \
             (_rate == 22050) ? SOF_STATIC_RATE_22K : \
             (_rate == 24000) ? SOF_STATIC_RATE_24K : \
             (_rate == 32000) ? SOF_STATIC_RATE_32K : \
             (_rate == 44100) ? SOF_STATIC_RATE_44K1 : \
             (_rate == 48000) ? SOF_STATIC_RATE_48K : \
             (_rate == 64000) ? SOF_STATIC_RATE_64K : \
             (_rate == 88200) ? SOF_STATIC_RATE_88K2 : \
             (_rate == 96000) ? SOF_STATIC_RATE_96K : \
             (_rate == 176400) ? SOF_STATIC_RATE_176K4 : \
             (_rate == 192000) ? SOF_STATIC_RATE_192K : \
             (_rate == 384000) ? SOF_STATIC_RATE_384K : SOF_STATIC_RATE_48K, \
        .min_channels = (_ch), \
        .max_channels = (_ch), \
        .default_rate = (_rate), \
        .default_fmt = (_fmt), \
    }
 
/* =========================================================================
 * Components / Processing Modules
 * ========================================================================= */
 
enum sof_static_comp_type {
    SOF_STATIC_COMP_MODULE = 0, 
    SOF_STATIC_COMP_HOST,       
    SOF_STATIC_COMP_DAI,        
};
 
enum sof_static_ep_type {
    SOF_STATIC_EP_NONE = 0,     
    SOF_STATIC_EP_USB_TERMINAL, 
    SOF_STATIC_EP_DAI,          
};
 
struct sof_static_comp {
    uint32_t id;                     
    uint32_t pipeline_id;            
    const char *name;                
    enum sof_static_comp_type type;  
    const struct sof_uuid *uuid;     
    uint32_t direction;              
    struct sof_static_caps caps;     
    enum sof_static_ep_type ep_type; 
    union {
        struct {
            uint32_t terminal_id;    
        } usb;
        struct {
            uint32_t dai_type;       
            uint32_t dai_index;      
            uint32_t format;         
            int (*configure)(struct comp_dev *dev,
                     struct ipc_config_dai *dai_cfg,
                     void *spec_cfg); 
        } dai;
    } ep;
 
    const void *init_blob;           
    size_t init_blob_size;           
};
 
#define SOF_STATIC_COMP_MODULE(...) \
    { .type = SOF_STATIC_COMP_MODULE, __VA_ARGS__ }
 
#define SOF_STATIC_COMP_HOST(...) \
    { .type = SOF_STATIC_COMP_HOST, .ep_type = SOF_STATIC_EP_USB_TERMINAL, __VA_ARGS__ }
 
#define SOF_STATIC_COMP_DAI(...) \
    { .type = SOF_STATIC_COMP_DAI, .ep_type = SOF_STATIC_EP_DAI, __VA_ARGS__ }
 
/* =========================================================================
 * Module Constructor Macros
 * ========================================================================= */
 
#define SOF_STATIC_MODULE(_id, _ppl, _name, _dir, _uuid, _fmt, _rate, _ch, _blob, _blob_sz) \
    { \
        .id = (_id), \
        .pipeline_id = (_ppl), \
        .name = (_name), \
        .type = SOF_STATIC_COMP_MODULE, \
        .uuid = (_uuid), \
        .direction = (_dir), \
        .caps = SOF_STATIC_CAPS((_fmt), (_rate), (_ch)), \
        .init_blob = (_blob), \
        .init_blob_size = (_blob_sz), \
    }
 
#define SOF_STATIC_MODULE_RATE_CONV(_id, _ppl, _name, _dir, _uuid, _fmt, _in_rate, _out_rate, _ch) \
    { \
        .id = (_id), \
        .pipeline_id = (_ppl), \
        .name = (_name), \
        .type = SOF_STATIC_COMP_MODULE, \
        .uuid = (_uuid), \
        .direction = (_dir), \
        .caps = { \
            .formats = BIT(_fmt), \
            .rates = SOF_STATIC_RATE_MASK_ALL, \
            .min_channels = (_ch), \
            .max_channels = (_ch), \
            .default_rate = (_in_rate), \
            .sink_rate = (_out_rate), \
            .default_fmt = (_fmt), \
        }, \
    }
 
/* =========================================================================
 * Endpoint Constructor Macros
 * ========================================================================= */
 
#define SOF_STATIC_ENDPOINT_USB(_id, _ppl, _name, _dir, _fmt, _rate, _ch, _term_id) \
    { \
        .id = (_id), \
        .pipeline_id = (_ppl), \
        .name = (_name), \
        .type = SOF_STATIC_COMP_HOST, \
        .direction = (_dir), \
        .caps = SOF_STATIC_CAPS((_fmt), (_rate), (_ch)), \
        .ep_type = SOF_STATIC_EP_USB_TERMINAL, \
        .ep.usb.terminal_id = (_term_id), \
    }
 
#define SOF_STATIC_ENDPOINT_DAI(_id, _ppl, _name, _dir, _fmt, _rate, _ch, _type, _idx, _clk_fmt) \
    { \
        .id = (_id), \
        .pipeline_id = (_ppl), \
        .name = (_name), \
        .type = SOF_STATIC_COMP_DAI, \
        .direction = (_dir), \
        .caps = SOF_STATIC_CAPS((_fmt), (_rate), (_ch)), \
        .ep_type = SOF_STATIC_EP_DAI, \
        .ep.dai.dai_type = (_type), \
        .ep.dai.dai_index = (_idx), \
        .ep.dai.format = (_clk_fmt), \
    }
 
#define SOF_STATIC_ENDPOINT_DAI_CFG(_id, _ppl, _name, _dir, _fmt, _rate, _ch, _type, _idx, _clk_fmt, _cfg_fn) \
    { \
        .id = (_id), \
        .pipeline_id = (_ppl), \
        .name = (_name), \
        .type = SOF_STATIC_COMP_DAI, \
        .direction = (_dir), \
        .caps = SOF_STATIC_CAPS((_fmt), (_rate), (_ch)), \
        .ep_type = SOF_STATIC_EP_DAI, \
        .ep.dai.dai_type = (_type), \
        .ep.dai.dai_index = (_idx), \
        .ep.dai.format = (_clk_fmt), \
        .ep.dai.configure = (_cfg_fn), \
    }
 
/* =========================================================================
 * Static Module Operations
 * ========================================================================= */
 
struct sof_static_module_ops {
    const struct sof_uuid *uuid;
 
    struct comp_dev *(*create)(const struct comp_driver *drv,
                   struct comp_ipc_config *cfg,
                   const struct sof_static_comp *cdesc,
                   uint32_t period_us);
 
    int (*apply_volume)(struct comp_dev *dev, uint32_t channels, int32_t val);
 
    int (*apply_volume_chan)(struct comp_dev *dev, uint32_t channel, int32_t val);
 
    int (*apply_switch)(struct comp_dev *dev, uint32_t channels, int32_t val);
 
    int (*apply_switch_chan)(struct comp_dev *dev, uint32_t channel, int32_t val);
 
    int (*apply_enum)(struct comp_dev *dev, uint32_t channel, int32_t val);
 
    int (*apply_binary)(struct comp_dev *dev, const void *data, size_t size);
 
    struct list_item list;
};
 
#if defined(__ZEPHYR__)
#include <zephyr/init.h>
#define DECLARE_STATIC_MODULE_OPS(name, ops) \
    static int _static_ops_init_##name(void) \
    { \
        return sof_static_register_module_ops(ops); \
    } \
    SYS_INIT(_static_ops_init_##name, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY)
#else
#define DECLARE_STATIC_MODULE_OPS(name, ops) \
    static __attribute__((constructor)) void _static_ops_init_##name(void) \
    { \
        sof_static_register_module_ops(ops); \
    }
#endif
 
/* =========================================================================
 * Intermediate Audio Buffers & Pipeline Routing
 * ========================================================================= */
 
struct sof_static_buffer {
    uint32_t id;                     
    size_t size;                     
    enum sof_ipc_frame fmt;          
    uint32_t rate;                   
    uint16_t channels;               
    uint32_t flags;                  
};
 
#define SOF_STATIC_BUFFER(...) \
    { .flags = SOF_MEM_FLAG_DMA | SOF_MEM_FLAG_USER, .fmt = SOF_IPC_FRAME_INVALID, __VA_ARGS__ }
 
struct sof_static_route {
    uint32_t src_comp_id;            
    uint32_t buffer_id;              
    uint32_t sink_comp_id;           
};
 
#define SOF_STATIC_ROUTE(...) \
    { __VA_ARGS__ }
 
/* =========================================================================
 * PCMs (Pulse Code Modulated Endpoints)
 * ========================================================================= */
 
struct sof_static_pcm {
    uint32_t pcm_id;                 
    const char *name;                
    uint32_t direction;              
    uint32_t pipeline_id;            
    uint32_t host_comp_id;           
    struct sof_static_caps caps;     
};
 
#define SOF_STATIC_PCM(...) \
    { __VA_ARGS__ }
 
/* =========================================================================
 * Kcontrols (Volume, Mute, Bypass, Presets, Coefficients)
 * ========================================================================= */
 
enum sof_static_ctrl_type {
    SOF_STATIC_CTRL_VOLUME = 0,      
    SOF_STATIC_CTRL_SWITCH,          
    SOF_STATIC_CTRL_ENUM,            
    SOF_STATIC_CTRL_BINARY,          
};
 
struct sof_static_kcontrol {
    uint32_t id;                     
    const char *name;                
    enum sof_static_ctrl_type type;  
    uint32_t target_comp_id;         
    uint32_t param_id;               
    int32_t min;                     
    int32_t max;                     
    int32_t def;                     
    uint32_t channels;               
    uint8_t uac2_entity_id;          
};
 
#define SOF_STATIC_KCONTROL_VOLUME(...) \
    { .type = SOF_STATIC_CTRL_VOLUME, __VA_ARGS__ }
 
#define SOF_STATIC_KCONTROL_SWITCH(...) \
    { .type = SOF_STATIC_CTRL_SWITCH, __VA_ARGS__ }
 
#define SOF_STATIC_KCONTROL_ENUM(...) \
    { .type = SOF_STATIC_CTRL_ENUM, __VA_ARGS__ }
 
#define SOF_STATIC_KCONTROL_BINARY(...) \
    { .type = SOF_STATIC_CTRL_BINARY, __VA_ARGS__ }
 
/* =========================================================================
 * Pipeline Descriptors & Top-Level Topology
 * ========================================================================= */
 
struct sof_static_pipeline_desc {
    uint32_t pipeline_id;            
    const char *name;                
    uint32_t direction;              
    uint32_t priority;               
    uint32_t core;                   
    uint32_t period;                 
    uint32_t frames_per_sched;       
    uint32_t time_domain;            
    uint32_t default_rate;           
    uint16_t default_channels;       
    uint32_t sched_comp_id;          
    uint32_t source_comp_id;         
    uint32_t sink_comp_id;           
};
 
typedef int (*sof_static_kcontrol_handler_fn)(const struct sof_static_kcontrol *ctl,
                          int32_t val, void *priv);
 
struct sof_static_topology {
    const char *name;                                   
    size_t num_pipelines;                               
    const struct sof_static_pipeline_desc *pipelines;   
    size_t num_comps;                                   
    const struct sof_static_comp *comps;                
    size_t num_buffers;                                 
    const struct sof_static_buffer *buffers;            
    size_t num_routes;                                  
    const struct sof_static_route *routes;              
    size_t num_pcms;                                    
    const struct sof_static_pcm *pcms;                  
    size_t num_controls;                                
    const struct sof_static_kcontrol *controls;         
    sof_static_kcontrol_handler_fn custom_control_handler; 
    void *custom_control_data;                             
};
 
/* =========================================================================
 * Generic Engine Public APIs
 * ========================================================================= */
 
int sof_static_topology_init(const struct sof_static_topology *topo);
 
const struct sof_static_topology *sof_static_topology_get(void);
 
struct pipeline *sof_static_pipeline_get(uint32_t pipeline_id);
 
struct comp_dev *sof_static_comp_get(uint32_t comp_id);
 
struct comp_buffer *sof_static_buffer_get(uint32_t buffer_id);
 
int sof_static_register_module_ops(struct sof_static_module_ops *ops);
 
const struct sof_static_module_ops *sof_static_find_module_ops(const struct sof_uuid *uuid);
 
struct ipc4_base_module_cfg;
 
void sof_static_init_base_cfg(struct ipc4_base_module_cfg *base_cfg,
                  const struct sof_static_comp *cdesc,
                  uint32_t period_us);
 
struct comp_dev *sof_static_module_create_default(const struct comp_driver *drv,
                          struct comp_ipc_config *cfg,
                          const struct sof_static_comp *cdesc,
                          uint32_t period_us);
 
int sof_static_kcontrol_set(uint32_t ctrl_id, int32_t val);
 
int sof_static_kcontrol_set_chan(uint32_t ctrl_id, uint32_t channel, int32_t val);
 
int sof_static_kcontrol_set_binary(uint32_t ctrl_id, const void *data, size_t size);
 
int sof_static_kcontrol_get(uint32_t ctrl_id, int32_t *val);
 
int sof_static_kcontrol_find_by_name(const char *name);
 
int sof_static_kcontrol_set_by_uac2(uint8_t entity_id, uint8_t channel, int32_t val, bool is_volume);
 
int sof_static_kcontrol_get_by_uac2(uint8_t entity_id, uint8_t channel, int32_t *val, bool is_volume);
 
int sof_static_pipeline_trigger_by_uac2_term(uint8_t terminal_id, bool start);
 
int sof_static_pipeline_start(uint32_t pipeline_id);
 
int sof_static_pipeline_stop(uint32_t pipeline_id);
 
int sof_static_pipeline_trigger(uint32_t pipeline_id, bool start);
 
int sof_static_pipeline_set_sample_rate(uint32_t pipeline_id, uint32_t rate);
 
uint32_t sof_static_pipeline_get_sample_rate(uint32_t pipeline_id);
 
int sof_static_set_sample_rate(uint32_t rate);
 
uint32_t sof_static_get_sample_rate(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __SOF_AUDIO_PIPELINE_STATIC_PIPELINE_H__ */