/usr/src/packages/BUILD/alsa-lib-1.1.4.1/include/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 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

snd_tplg_t *snd_tplg_new(void);

void snd_tplg_free(snd_tplg_t *tplg);

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;    
        struct snd_tplg_tlv_template *tlv; 
};

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;      /* 1 if clock can be gated to save power */
        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_master;     /* 1 for master of BCLK, 0 for slave */
        unsigned char  fsync_master;    /* 1 for master of FSYNC, 0 for slave */
        unsigned char  mclk_direction;  /* 0 for input, 1 for output */
        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_set_manifest_data(snd_tplg_t *tplg, const void *data, int len);

int snd_tplg_set_version(snd_tplg_t *tplg, unsigned int version);

/* \} */

#ifdef __cplusplus
}
#endif

#endif /* __ALSA_TOPOLOGY_H */