/*
 *  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 of the License, or (at your option) any later version.
 *
 *  This library 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.
 */

#include <limits.h>
#include <stdint.h>
#include <stdbool.h>

#include "local.h"
#include "list.h"
#include "bswap.h"
#include "topology.h"

#include <sound/type_compat.h>
#include <sound/asound.h>
#include <sound/asoc.h>
#include <sound/tlv.h>

#ifdef TPLG_DEBUG
#define tplg_dbg SNDERR
#else
#define tplg_dbg(fmt, arg...) do { } while (0)
#endif

#define TPLG_MAX_PRIV_SIZE	(1024 * 128)

/** The name of the environment variable containing the tplg directory */
#define ALSA_CONFIG_TPLG_VAR "ALSA_CONFIG_TPLG"

struct tplg_ref;
struct tplg_elem;
struct tplg_table;

typedef enum _snd_pcm_rates {
	SND_PCM_RATE_UNKNOWN = -1,
	SND_PCM_RATE_5512 = 0,
	SND_PCM_RATE_8000,
	SND_PCM_RATE_11025,
	SND_PCM_RATE_16000,
	SND_PCM_RATE_22050,
	SND_PCM_RATE_32000,
	SND_PCM_RATE_44100,
	SND_PCM_RATE_48000,
	SND_PCM_RATE_64000,
	SND_PCM_RATE_88200,
	SND_PCM_RATE_96000,
	SND_PCM_RATE_176400,
	SND_PCM_RATE_192000,
	SND_PCM_RATE_CONTINUOUS = 30,
	SND_PCM_RATE_KNOT = 31,
	SND_PCM_RATE_LAST = SND_PCM_RATE_KNOT,
} snd_pcm_rates_t;

struct snd_tplg {
	/* out file */
	unsigned char *bin;
	size_t bin_pos;
	size_t bin_size;

	int verbose;
	unsigned int dapm_sort: 1;
	unsigned int version;

	/* runtime state */
	size_t next_hdr_pos;
	int index;
	int channel_idx;

	/* manifest */
	struct snd_soc_tplg_manifest manifest;
	void *manifest_pdata;	/* copied by builder at file write */

	/* list of each element type */
	struct list_head tlv_list;
	struct list_head widget_list;
	struct list_head pcm_list;
	struct list_head dai_list;
	struct list_head be_list;
	struct list_head cc_list;
	struct list_head route_list;
	struct list_head text_list;
	struct list_head pdata_list;
	struct list_head token_list;
	struct list_head tuple_list;
	struct list_head manifest_list;
	struct list_head pcm_config_list;
	struct list_head pcm_caps_list;
	struct list_head hw_cfg_list;

	/* type-specific control lists */
	struct list_head mixer_list;
	struct list_head enum_list;
	struct list_head bytes_ext_list;
};

/* object text references */
struct tplg_ref {
	unsigned int type;
	struct tplg_elem *elem;
	char id[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
	struct list_head list;
};

struct tplg_texts {
	unsigned int num_items;
	char items[SND_SOC_TPLG_NUM_TEXTS][SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
};

/* element for vendor tokens */
struct tplg_token {
	char id[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
	unsigned int value;
};

struct tplg_vendor_tokens {
	unsigned int num_tokens;
	struct tplg_token token[0];
};

/* element for vendor tuples */
struct tplg_tuple {
	char token[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
	union {
		char string[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
		unsigned char uuid[16];
		unsigned int value;
	};
};

struct tplg_tuple_set {
	unsigned int  type; /* uuid, bool, byte, short, word, string*/
	unsigned int  num_tuples;
	struct tplg_tuple tuple[0];
};

struct tplg_vendor_tuples {
	unsigned int num_sets;
	unsigned int alloc_sets;
	struct tplg_tuple_set **set;
};

/* topology element */
struct tplg_elem {

	struct tplg_table *table;

	char id[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];

	int index;
	enum snd_tplg_type type;

	int size; /* total size of this object inc pdata and ref objects */
	int compound_elem; /* dont write this element as individual elem */
	int vendor_type; /* vendor type for private data */

	/* UAPI object for this elem */
	union {
		void *obj;
		struct snd_soc_tplg_mixer_control *mixer_ctrl;
		struct snd_soc_tplg_enum_control *enum_ctrl;
		struct snd_soc_tplg_bytes_control *bytes_ext;
		struct snd_soc_tplg_dapm_widget *widget;
		struct snd_soc_tplg_pcm *pcm;
		struct snd_soc_tplg_dai *dai;
		struct snd_soc_tplg_link_config *link;/* physical link */
		struct snd_soc_tplg_dapm_graph_elem *route;
		struct snd_soc_tplg_stream *stream_cfg;
		struct snd_soc_tplg_stream_caps *stream_caps;
		struct snd_soc_tplg_hw_config *hw_cfg;

		/* these do not map to UAPI structs but are internal only */
		struct snd_soc_tplg_ctl_tlv *tlv;
		struct tplg_texts *texts;
		struct snd_soc_tplg_private *data;
		struct tplg_vendor_tokens *tokens;
		struct tplg_vendor_tuples *tuples;
		struct snd_soc_tplg_manifest *manifest;
	};

	/* an element may refer to other elements:
	 * a mixer control may refer to a tlv,
	 * a widget may refer to a mixer control array,
	 * a graph may refer to some widgets.
	 */
	struct list_head ref_list;
	struct list_head list; /* list of all elements with same type */

	void (*free)(void *obj);
};

struct map_elem {
	const char *name;
	int id;
};

/* output buffer */
struct tplg_buf {
	char *dst;
	size_t dst_len;
	char *printf_buf;
	size_t printf_buf_size;
};

/* mapping table */
struct tplg_table {
	const char *name;
	const char *id;
	const char *id2;
	off_t loff;
	size_t size;
	int type;
	int tsoc;
	unsigned build: 1;
	unsigned enew: 1;
	void (*free)(void *);
	int (*parse)(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
	int (*save)(snd_tplg_t *tplg, struct tplg_elem *elem,
		    struct tplg_buf *dst, const char *prefix);
	int (*gsave)(snd_tplg_t *tplg, int index,
		     struct tplg_buf *dst, const char *prefix);
	int (*decod)(snd_tplg_t *tplg, size_t pos,
		     struct snd_soc_tplg_hdr *hdr,
		     void *bin, size_t size);
};

extern struct tplg_table tplg_table[];
extern unsigned int tplg_table_items;

#if __SIZEOF_INT__ == 4
static inline unsigned int unaligned_get32(void *src)
{
	unsigned int ret;
	memcpy(&ret, src, sizeof(ret));
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	ret = bswap_32(ret);
#endif
	return ret;
}
static inline void unaligned_put32(void *dst, unsigned int val)
{
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	val = bswap_32(val);
#endif
	memcpy(dst, &val, sizeof(val));
}
#endif

#define tplg_log(tplg, type, pos, fmt, args...) do { \
	if ((tplg)->verbose) \
		tplg_log_((tplg), (type), (pos), (fmt), ##args); \
} while (0)

void tplg_log_(snd_tplg_t *tplg, char type, size_t pos, const char *fmt, ...);

void *tplg_calloc(struct list_head *heap, size_t size);
void tplg_free(struct list_head *heap);

int tplg_get_type(int asoc_type);

int tplg_parse_compound(snd_tplg_t *tplg, snd_config_t *cfg,
	int (*fcn)(snd_tplg_t *, snd_config_t *, void *),
	void *private);

int tplg_write_data(snd_tplg_t *tplg);

int tplg_parse_tlv(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_text(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_data(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_tokens(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_tuples(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_manifest_data(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_control_bytes(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_control_enum(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_control_mixer(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_dapm_graph(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_dapm_widget(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_stream_caps(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_pcm(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_dai(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_link(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_cc(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
int tplg_parse_hw_config(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);

unsigned int tplg_get_tuple_size(int type);
void tplg_free_tuples(void *obj);

int tplg_build_data(snd_tplg_t *tplg);
int tplg_build_manifest_data(snd_tplg_t *tplg);
int tplg_build_controls(snd_tplg_t *tplg);
int tplg_build_widgets(snd_tplg_t *tplg);
int tplg_build_routes(snd_tplg_t *tplg);
int tplg_build_pcm_dai(snd_tplg_t *tplg, unsigned int type);

int tplg_copy_data(snd_tplg_t *tplg, struct tplg_elem *elem,
		   struct tplg_ref *ref);

int tplg_parse_refs(snd_config_t *cfg, struct tplg_elem *elem,
		    unsigned int type);

int tplg_ref_add(struct tplg_elem *elem, int type, const char* id);
int tplg_ref_add_elem(struct tplg_elem *elem, struct tplg_elem *elem_ref);

struct tplg_elem *tplg_elem_new(void);
void tplg_elem_free(struct tplg_elem *elem);
void tplg_elem_free_list(struct list_head *base);
void tplg_elem_insert(struct tplg_elem *elem_p, struct list_head *list);
struct tplg_elem *tplg_elem_lookup(struct list_head *base,
				const char* id,
				unsigned int type,
				int index);
struct tplg_elem *tplg_elem_type_lookup(snd_tplg_t *tplg,
					enum snd_tplg_type type);
struct tplg_elem* tplg_elem_new_common(snd_tplg_t *tplg,
	snd_config_t *cfg, const char *name, enum snd_tplg_type type);

int tplg_get_integer(snd_config_t *n, int *val, int base);
int tplg_get_unsigned(snd_config_t *n, unsigned *val, int base);

const char *tplg_channel_name(int type);
int tplg_parse_channel(snd_tplg_t *tplg ATTRIBUTE_UNUSED,
	snd_config_t *cfg, void *private);

const char *tplg_ops_name(int type);
int tplg_parse_ops(snd_tplg_t *tplg ATTRIBUTE_UNUSED,
	snd_config_t *cfg, void *private);
int tplg_parse_ext_ops(snd_tplg_t *tplg ATTRIBUTE_UNUSED,
	snd_config_t *cfg, void *private);

struct tplg_elem *lookup_pcm_dai_stream(struct list_head *base,
	const char* id);

int tplg_add_data(snd_tplg_t *tplg, struct tplg_elem *parent,
		  const void *bin, size_t size);
int tplg_add_data_bytes(snd_tplg_t *tplg, struct tplg_elem *parent,
			const char *suffix, const void *bin, size_t size);
int tplg_add_mixer_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);
int tplg_add_enum_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);
int tplg_add_bytes_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);
int tplg_add_widget_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);
int tplg_add_graph_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);

int tplg_add_mixer(snd_tplg_t *tplg, struct snd_tplg_mixer_template *mixer,
		   struct tplg_elem **e);
int tplg_add_enum(snd_tplg_t *tplg, struct snd_tplg_enum_template *enum_ctl,
		  struct tplg_elem **e);
int tplg_add_bytes(snd_tplg_t *tplg, struct snd_tplg_bytes_template *bytes_ctl,
		   struct tplg_elem **e);

int tplg_build_pcms(snd_tplg_t *tplg, unsigned int type);
int tplg_build_dais(snd_tplg_t *tplg, unsigned int type);
int tplg_build_links(snd_tplg_t *tplg, unsigned int type);
int tplg_add_link_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);
int tplg_add_pcm_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);
int tplg_add_dai_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t);

int tplg_nice_value_format(char *dst, size_t dst_size, unsigned int value);

int tplg_save_printf(struct tplg_buf *dst, const char *prefix, const char *fmt, ...);
int tplg_save_refs(snd_tplg_t *tplg, struct tplg_elem *elem, unsigned int type,
		   const char *id, struct tplg_buf *dst, const char *pfx);
int tplg_save_channels(snd_tplg_t *tplg, struct snd_soc_tplg_channel *channel,
		       unsigned int channel_count, struct tplg_buf *dst, const char *pfx);
int tplg_save_ops(snd_tplg_t *tplg, struct snd_soc_tplg_ctl_hdr *hdr,
		  struct tplg_buf *dst, const char *pfx);
int tplg_save_ext_ops(snd_tplg_t *tplg, struct snd_soc_tplg_bytes_control *be,
		      struct tplg_buf *dst, const char *pfx);
int tplg_save_manifest_data(snd_tplg_t *tplg, struct tplg_elem *elem,
			    struct tplg_buf *dst, const char *pfx);
int tplg_save_control_mixer(snd_tplg_t *tplg, struct tplg_elem *elem,
			    struct tplg_buf *dst, const char *pfx);
int tplg_save_control_enum(snd_tplg_t *tplg, struct tplg_elem *elem,
			   struct tplg_buf *dst, const char *pfx);
int tplg_save_control_bytes(snd_tplg_t *tplg, struct tplg_elem *elem,
			    struct tplg_buf *dst, const char *pfx);
int tplg_save_tlv(snd_tplg_t *tplg, struct tplg_elem *elem,
		  struct tplg_buf *dst, const char *pfx);
int tplg_save_data(snd_tplg_t *tplg, struct tplg_elem *elem,
		   struct tplg_buf *dst, const char *pfx);
int tplg_save_text(snd_tplg_t *tplg, struct tplg_elem *elem,
		   struct tplg_buf *dst, const char *pfx);
int tplg_save_tokens(snd_tplg_t *tplg, struct tplg_elem *elem,
		     struct tplg_buf *dst, const char *pfx);
int tplg_save_tuples(snd_tplg_t *tplg, struct tplg_elem *elem,
		     struct tplg_buf *dst, const char *pfx);
int tplg_save_dapm_graph(snd_tplg_t *tplg, int index,
			 struct tplg_buf *dst, const char *pfx);
int tplg_save_dapm_widget(snd_tplg_t *tplg, struct tplg_elem *elem,
			  struct tplg_buf *dst, const char *pfx);
int tplg_save_link(snd_tplg_t *tplg, struct tplg_elem *elem,
		   struct tplg_buf *dst, const char *pfx);
int tplg_save_cc(snd_tplg_t *tplg, struct tplg_elem *elem,
		 struct tplg_buf *dst, const char *pfx);
int tplg_save_pcm(snd_tplg_t *tplg, struct tplg_elem *elem,
		  struct tplg_buf *dst, const char *pfx);
int tplg_save_hw_config(snd_tplg_t *tplg, struct tplg_elem *elem,
			struct tplg_buf *dst, const char *pfx);
int tplg_save_stream_caps(snd_tplg_t *tplg, struct tplg_elem *elem,
			  struct tplg_buf *dst, const char *pfx);
int tplg_save_dai(snd_tplg_t *tplg, struct tplg_elem *elem,
		  struct tplg_buf *dst, const char *pfx);

int tplg_decode_template(snd_tplg_t *tplg,
			 size_t pos,
			 struct snd_soc_tplg_hdr *hdr,
			 snd_tplg_obj_template_t *t);
int tplg_decode_manifest_data(snd_tplg_t *tplg, size_t pos,
			      struct snd_soc_tplg_hdr *hdr,
			      void *bin, size_t size);
int tplg_decode_control_mixer1(snd_tplg_t *tplg,
			       struct list_head *heap,
			       struct snd_tplg_mixer_template *mt,
			       size_t pos,
			       void *bin, size_t size);
int tplg_decode_control_mixer(snd_tplg_t *tplg, size_t pos,
			      struct snd_soc_tplg_hdr *hdr,
			      void *bin, size_t size);
int tplg_decode_control_enum1(snd_tplg_t *tplg,
			      struct list_head *heap,
			      struct snd_tplg_enum_template *et,
			      size_t pos,
			      struct snd_soc_tplg_enum_control *ec);
int tplg_decode_control_enum(snd_tplg_t *tplg, size_t pos,
			     struct snd_soc_tplg_hdr *hdr,
			     void *bin, size_t size);
int tplg_decode_control_bytes1(snd_tplg_t *tplg,
			       struct snd_tplg_bytes_template *bt,
			       size_t pos,
			       void *bin, size_t size);
int tplg_decode_control_bytes(snd_tplg_t *tplg, size_t pos,
			      struct snd_soc_tplg_hdr *hdr,
			      void *bin, size_t size);
int tplg_decode_data(snd_tplg_t *tplg, size_t pos,
		     struct snd_soc_tplg_hdr *hdr,
		     void *bin, size_t size);
int tplg_decode_dapm_graph(snd_tplg_t *tplg, size_t pos,
			   struct snd_soc_tplg_hdr *hdr,
			   void *bin, size_t size);
int tplg_decode_dapm_widget(snd_tplg_t *tplg, size_t pos,
			    struct snd_soc_tplg_hdr *hdr,
			    void *bin, size_t size);
int tplg_decode_link(snd_tplg_t *tplg, size_t pos,
		     struct snd_soc_tplg_hdr *hdr,
		     void *bin, size_t size);
int tplg_decode_cc(snd_tplg_t *tplg, size_t pos,
		   struct snd_soc_tplg_hdr *hdr,
		   void *bin, size_t size);
int tplg_decode_pcm(snd_tplg_t *tplg, size_t pos,
		    struct snd_soc_tplg_hdr *hdr,
		    void *bin, size_t size);
int tplg_decode_dai(snd_tplg_t *tplg, size_t pos,
		    struct snd_soc_tplg_hdr *hdr,
		    void *bin, size_t size);