topology.h

/*
 *
 *  This library is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as
 *  published by the Free Software Foundation; either version 2.1 of
 *  the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  Copyright (C) 2015 Intel Corporation
 *
 */
 
#ifndef __ALSA_TOPOLOGY_H
#define __ALSA_TOPOLOGY_H
 
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define SND_TPLG_MAX_CHAN       8
 
typedef struct snd_tplg snd_tplg_t;
 
enum snd_tplg_type {
    SND_TPLG_TYPE_TLV = 0,      
    SND_TPLG_TYPE_MIXER,        
    SND_TPLG_TYPE_ENUM,     
    SND_TPLG_TYPE_TEXT,     
    SND_TPLG_TYPE_DATA,     
    SND_TPLG_TYPE_BYTES,        
    SND_TPLG_TYPE_STREAM_CONFIG,    
    SND_TPLG_TYPE_STREAM_CAPS,  
    SND_TPLG_TYPE_PCM,      
    SND_TPLG_TYPE_DAPM_WIDGET,  
    SND_TPLG_TYPE_DAPM_GRAPH,   
    SND_TPLG_TYPE_BE,       
    SND_TPLG_TYPE_CC,       
    SND_TPLG_TYPE_MANIFEST,     
    SND_TPLG_TYPE_TOKEN,        
    SND_TPLG_TYPE_TUPLE,        
    SND_TPLG_TYPE_LINK,     
    SND_TPLG_TYPE_HW_CONFIG,    
    SND_TPLG_TYPE_DAI,      
};
 
#define SND_TPLG_INDEX_ALL  0
 
#define SND_TPLG_CREATE_VERBOSE     (1<<0)  
#define SND_TPLG_CREATE_DAPM_NOSORT (1<<1)  
const char *snd_tplg_version(void);
 
snd_tplg_t *snd_tplg_new(void);
 
snd_tplg_t *snd_tplg_create(int flags);
 
void snd_tplg_free(snd_tplg_t *tplg);
 
int snd_tplg_load(snd_tplg_t *tplg, const char *buf, size_t size);
 
int snd_tplg_build_file(snd_tplg_t *tplg, const char *infile,
            const char *outfile);
 
void snd_tplg_verbose(snd_tplg_t *tplg, int verbose);
 
struct snd_tplg_tlv_template {
    int type;    
};
 
struct snd_tplg_tlv_dbscale_template {
    struct snd_tplg_tlv_template hdr;   
    int min;            
    int step;           
    int mute;           
};
 
struct snd_tplg_channel_elem {
    int size;   
    int reg;    
    int shift;  
    int id;     
};
 
struct snd_tplg_channel_map_template {
    int num_channels;   
    struct snd_tplg_channel_elem channel[SND_TPLG_MAX_CHAN];    
};
 
struct snd_tplg_pdata_template {
    unsigned int length;    
    const void *data;   
};
 
struct snd_tplg_io_ops_template {
    int get;    
    int put;    
    int info;   
};
 
struct snd_tplg_ctl_template {
    int type;       
    const char *name;   
    int access;     
    struct snd_tplg_io_ops_template ops;    
    union {
        struct snd_tplg_tlv_template *tlv; 
        struct snd_tplg_tlv_dbscale_template *tlv_scale; 
    };
};
 
struct snd_tplg_mixer_template {
    struct snd_tplg_ctl_template hdr;   
    struct snd_tplg_channel_map_template *map;  
    int min;    
    int max;    
    int platform_max;   
    int invert; 
    struct snd_soc_tplg_private *priv;  
};
 
struct snd_tplg_enum_template {
    struct snd_tplg_ctl_template hdr;   
    struct snd_tplg_channel_map_template *map;  
    int items;  
    int mask;   
    const char **texts; 
    const int **values; 
    struct snd_soc_tplg_private *priv;  
};
 
struct snd_tplg_bytes_template {
    struct snd_tplg_ctl_template hdr;   
    int max;        
    int mask;       
    int base;       
    int num_regs;       
    struct snd_tplg_io_ops_template ext_ops;    
    struct snd_soc_tplg_private *priv;  
};
 
struct snd_tplg_graph_elem {
    const char *src;    
    const char *ctl;    
    const char *sink;   
};
 
struct snd_tplg_graph_template {
    int count;      
    struct snd_tplg_graph_elem elem[0]; 
};
 
struct snd_tplg_widget_template {
    int id;         
    const char *name;   
    const char *sname;  
    int reg;        
    int shift;      
    int mask;       
    int subseq;     
    unsigned int invert;        
    unsigned int ignore_suspend;    
    unsigned short event_flags; 
    unsigned short event_type;  
    struct snd_soc_tplg_private *priv;  
    int num_ctls;           
    struct snd_tplg_ctl_template *ctl[0];   
};
 
struct snd_tplg_stream_template {
    const char *name;   
    int format;     
    int rate;       
    int period_bytes;   
    int buffer_bytes;   
    int channels;       
};
 
struct snd_tplg_stream_caps_template {
    const char *name;   
    uint64_t formats;   
    unsigned int rates; 
    unsigned int rate_min;  
    unsigned int rate_max;  
    unsigned int channels_min;  
    unsigned int channels_max;  
    unsigned int periods_min;   
    unsigned int periods_max;   
    unsigned int period_size_min;   
    unsigned int period_size_max;   
    unsigned int buffer_size_min;   
    unsigned int buffer_size_max;   
    unsigned int sig_bits;      
};
 
struct snd_tplg_pcm_template {
    const char *pcm_name;   
    const char *dai_name;   
    unsigned int pcm_id;    
    unsigned int dai_id;    
    unsigned int playback;  
    unsigned int capture;   
    unsigned int compress;  
    struct snd_tplg_stream_caps_template *caps[2]; 
    unsigned int flag_mask; 
    unsigned int flags;     
    struct snd_soc_tplg_private *priv;  
    int num_streams;    
    struct snd_tplg_stream_template stream[0]; 
};
 
struct snd_tplg_hw_config_template {
    int id;                         /* unique ID - - used to match */
    unsigned int fmt;               /* SND_SOC_DAI_FORMAT_ format value */
    unsigned char clock_gated;      /* SND_SOC_TPLG_DAI_CLK_GATE_ value */
    unsigned char  invert_bclk;     /* 1 for inverted BCLK, 0 for normal */
    unsigned char  invert_fsync;    /* 1 for inverted frame clock, 0 for normal */
    unsigned char  bclk_provider;   /* SND_SOC_TPLG_BCLK_ value */
    unsigned char  fsync_provider;  /* SND_SOC_TPLG_FSYNC_ value */
    unsigned char  mclk_direction;  /* SND_SOC_TPLG_MCLK_ value */
    unsigned short reserved;        /* for 32bit alignment */
    unsigned int mclk_rate;         /* MCLK or SYSCLK freqency in Hz */
    unsigned int bclk_rate;         /* BCLK freqency in Hz */
    unsigned int fsync_rate;        /* frame clock in Hz */
    unsigned int tdm_slots;         /* number of TDM slots in use */
    unsigned int tdm_slot_width;    /* width in bits for each slot */
    unsigned int tx_slots;          /* bit mask for active Tx slots */
    unsigned int rx_slots;          /* bit mask for active Rx slots */
    unsigned int tx_channels;       /* number of Tx channels */
    unsigned int *tx_chanmap;       /* array of slot number */
    unsigned int rx_channels;       /* number of Rx channels */
    unsigned int *rx_chanmap;       /* array of slot number */
};
 
struct snd_tplg_dai_template {
    const char *dai_name;   
    unsigned int dai_id;    
    unsigned int playback;  
    unsigned int capture;   
    struct snd_tplg_stream_caps_template *caps[2]; 
    unsigned int flag_mask; 
    unsigned int flags; 
    struct snd_soc_tplg_private *priv;  
};
 
struct snd_tplg_link_template {
    const char *name;   
    int id; 
    const char *stream_name;        
    int num_streams;    
    struct snd_tplg_stream_template *stream;       
    struct snd_tplg_hw_config_template *hw_config; 
    int num_hw_configs;     /* number of hw configs */
    int default_hw_config_id;       /* default hw config ID for init */
 
    unsigned int flag_mask;         /* bitmask of flags to configure */
    unsigned int flags;             /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */
    struct snd_soc_tplg_private *priv; 
};
 
typedef struct snd_tplg_obj_template {
    enum snd_tplg_type type;    
    int index;      
    int version;        
    int vendor_type;    
    union {
        struct snd_tplg_widget_template *widget;    
        struct snd_tplg_mixer_template *mixer;      
        struct snd_tplg_bytes_template *bytes_ctl;  
        struct snd_tplg_enum_template *enum_ctl;    
        struct snd_tplg_graph_template *graph;      
        struct snd_tplg_pcm_template *pcm;      
        struct snd_tplg_link_template *link;        
        struct snd_tplg_dai_template *dai;      
    };
} snd_tplg_obj_template_t;
 
int snd_tplg_add_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);
 
int snd_tplg_build(snd_tplg_t *tplg, const char *outfile);
 
int snd_tplg_build_bin(snd_tplg_t *tplg, void **bin, size_t *size);
 
int snd_tplg_set_manifest_data(snd_tplg_t *tplg, const void *data, int len);
 
int snd_tplg_set_version(snd_tplg_t *tplg, unsigned int version);
 
/*
 * Flags for the snd_tplg_save()
 */
#define SND_TPLG_SAVE_SORT  (1<<0)  
#define SND_TPLG_SAVE_GROUPS    (1<<1)  
#define SND_TPLG_SAVE_NOCHECK   (1<<16) 
int snd_tplg_save(snd_tplg_t *tplg, char **dst, int flags);
 
int snd_tplg_decode(snd_tplg_t *tplg, void *bin, size_t size, int dflags);
 
/* \} */
 
#ifdef __cplusplus
}
#endif
 
#endif /* __ALSA_TOPOLOGY_H */