/*

  Copyright(c) 2014-2015 Intel Corporation

  All rights reserved.

  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.

  Authors: Mengdong Lin <mengdong.lin@intel.com>

           Yao Jin <yao.jin@intel.com>

           Liam Girdwood <liam.r.girdwood@linux.intel.com>

*/

#include "list.h"

#include "tplg_local.h"

struct tplg_table tplg_table[] = {

	{

		.name  = "manifest",

		.id    = "SectionManifest",

		.loff  = offsetof(snd_tplg_t, manifest_list),

		.type  = SND_TPLG_TYPE_MANIFEST,

		.tsoc  = SND_SOC_TPLG_TYPE_MANIFEST,

		.size  = sizeof(struct snd_soc_tplg_manifest),

		.enew  = 1,

		.parse = tplg_parse_manifest_data,

		.save  = tplg_save_manifest_data,

		.decod = tplg_decode_manifest_data,

	},

	{

		.name  = "control mixer",

		.id    = "SectionControlMixer",

		.loff  = offsetof(snd_tplg_t, mixer_list),

		.type  = SND_TPLG_TYPE_MIXER,

		.tsoc  = SND_SOC_TPLG_TYPE_MIXER,

		.size  = sizeof(struct snd_soc_tplg_mixer_control),

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_control_mixer,

		.save  = tplg_save_control_mixer,

		.decod = tplg_decode_control_mixer,

	},

	{

		.name  = "control enum",

		.id    = "SectionControlEnum",

		.loff  = offsetof(snd_tplg_t, enum_list),

		.type  = SND_TPLG_TYPE_ENUM,

		.tsoc  = SND_SOC_TPLG_TYPE_ENUM,

		.size  = sizeof(struct snd_soc_tplg_enum_control),

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_control_enum,

		.save  = tplg_save_control_enum,

		.decod = tplg_decode_control_enum,

	},

	{

		.name  = "control extended (bytes)",

		.id    = "SectionControlBytes",

		.loff  = offsetof(snd_tplg_t, bytes_ext_list),

		.type  = SND_TPLG_TYPE_BYTES,

		.tsoc  = SND_SOC_TPLG_TYPE_BYTES,

		.size  = sizeof(struct snd_soc_tplg_bytes_control),

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_control_bytes,

		.save  = tplg_save_control_bytes,

		.decod = tplg_decode_control_bytes,

	},

	{

		.name  = "dapm widget",

		.id    = "SectionWidget",

		.loff  = offsetof(snd_tplg_t, widget_list),

		.type  = SND_TPLG_TYPE_DAPM_WIDGET,

		.tsoc  = SND_SOC_TPLG_TYPE_DAPM_WIDGET,

		.size  = sizeof(struct snd_soc_tplg_dapm_widget),

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_dapm_widget,

		.save  = tplg_save_dapm_widget,

		.decod = tplg_decode_dapm_widget,

	},

	{

		.name  = "pcm",

		.id    = "SectionPCM",

		.loff  = offsetof(snd_tplg_t, pcm_list),

		.type  = SND_TPLG_TYPE_PCM,

		.tsoc  = SND_SOC_TPLG_TYPE_PCM,

		.size  = sizeof(struct snd_soc_tplg_pcm),

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_pcm,

		.save  = tplg_save_pcm,

		.decod = tplg_decode_pcm,

	},

	{

		.name  = "physical dai",

		.id    = "SectionDAI",

		.loff  = offsetof(snd_tplg_t, dai_list),

		.type  = SND_TPLG_TYPE_DAI,

		.tsoc  = SND_SOC_TPLG_TYPE_DAI,

		.size  = sizeof(struct snd_soc_tplg_dai),

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_dai,

		.save  = tplg_save_dai,

		.decod = tplg_decode_dai,

	},

	{

		.name  = "be",

		.id    = "SectionBE",

		.id2   = "SectionLink",

		.loff  = offsetof(snd_tplg_t, be_list),

		.type  = SND_TPLG_TYPE_BE,

		.tsoc  = SND_SOC_TPLG_TYPE_BACKEND_LINK,

		.size  = sizeof(struct snd_soc_tplg_link_config),

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_link,

		.save  = tplg_save_link,

		.decod = tplg_decode_link,

	},

	{

		.name  = "cc",

		.id    = "SectionCC",

		.loff  = offsetof(snd_tplg_t, cc_list),

		.type  = SND_TPLG_TYPE_CC,

		.tsoc  = SND_SOC_TPLG_TYPE_CODEC_LINK,

		.size  = sizeof(struct snd_soc_tplg_link_config),

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_cc,

		.save  = tplg_save_cc,

		.decod = tplg_decode_cc,

	},

	{

		.name  = "route (dapm graph)",

		.id = "SectionGraph",

		.loff  = offsetof(snd_tplg_t, route_list),

		.type  = SND_TPLG_TYPE_DAPM_GRAPH,

		.tsoc  = SND_SOC_TPLG_TYPE_DAPM_GRAPH,

		.build = 1,

		.parse = tplg_parse_dapm_graph,

		.gsave = tplg_save_dapm_graph,

		.decod = tplg_decode_dapm_graph,

	},

	{

		.name  = "private data",

		.id    = "SectionData",

		.loff  = offsetof(snd_tplg_t, pdata_list),

		.type  = SND_TPLG_TYPE_DATA,

		.tsoc  = SND_SOC_TPLG_TYPE_PDATA,

		.build = 1,

		.enew  = 1,

		.parse = tplg_parse_data,

		.save  = tplg_save_data,

		.decod = tplg_decode_data,

	},

	{

		.name  = "text",

		.id    = "SectionText",

		.loff  = offsetof(snd_tplg_t, text_list),

		.type  = SND_TPLG_TYPE_TEXT,

		.size  = sizeof(struct tplg_texts),

		.enew  = 1,

		.parse = tplg_parse_text,

		.save  = tplg_save_text,

	},

	{

		.name  = "tlv",

		.id    = "SectionTLV",

		.loff  = offsetof(snd_tplg_t, tlv_list),

		.type  = SND_TPLG_TYPE_TLV,

		.size  = sizeof(struct snd_soc_tplg_ctl_tlv),

		.enew  = 1,

		.parse = tplg_parse_tlv,

		.save  = tplg_save_tlv,

	},

	{

		.name  = "stream config",

		.loff  = offsetof(snd_tplg_t, pcm_config_list),

		.type  = SND_TPLG_TYPE_STREAM_CONFIG,

		.size  = sizeof(struct snd_soc_tplg_stream),

		.enew  = 1,

	},

	{

		.name  = "stream capabilities",

		.id    = "SectionPCMCapabilities",

		.loff  = offsetof(snd_tplg_t, pcm_caps_list),

		.type  = SND_TPLG_TYPE_STREAM_CAPS,

		.size  = sizeof(struct snd_soc_tplg_stream_caps),

		.enew  = 1,

		.parse = tplg_parse_stream_caps,

		.save  = tplg_save_stream_caps,

	},

	{

		.name  = "token",

		.id    = "SectionVendorTokens",

		.loff  = offsetof(snd_tplg_t, token_list),

		.type  = SND_TPLG_TYPE_TOKEN,

		.enew  = 1,

		.parse = tplg_parse_tokens,

		.save  = tplg_save_tokens,

	},

	{

		.name  = "tuple",

		.id    = "SectionVendorTuples",

		.loff  = offsetof(snd_tplg_t, tuple_list),

		.type  = SND_TPLG_TYPE_TUPLE,

		.free  = tplg_free_tuples,

		.enew  = 1,

		.parse = tplg_parse_tuples,

		.save  = tplg_save_tuples,

	},

	{

		.name  = "hw config",

		.id    = "SectionHWConfig",

		.loff  = offsetof(snd_tplg_t, hw_cfg_list),

		.type  = SND_TPLG_TYPE_HW_CONFIG,

		.size  = sizeof(struct snd_soc_tplg_hw_config),

		.enew  = 1,

		.parse = tplg_parse_hw_config,

		.save  = tplg_save_hw_config,

	}

};

unsigned int tplg_table_items = ARRAY_SIZE(tplg_table);

int tplg_get_type(int asoc_type)

{

	unsigned int index;

	for (index = 0; index < tplg_table_items; index++)

		if (tplg_table[index].tsoc == asoc_type)

			return tplg_table[index].type;

	SNDERR("uknown asoc type %d", asoc_type);

	return -EINVAL;

}

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

{

	struct tplg_ref *ref;

	ref = calloc(1, sizeof(*ref));

	if (!ref)

		return -ENOMEM;

	strncpy(ref->id, id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	ref->id[SNDRV_CTL_ELEM_ID_NAME_MAXLEN - 1] = 0;

	ref->type = type;

	list_add_tail(&ref->list, &elem->ref_list);

	return 0;

}

/* directly add a reference elem */

int tplg_ref_add_elem(struct tplg_elem *elem, struct tplg_elem *elem_ref)

{

	struct tplg_ref *ref;

	ref = calloc(1, sizeof(*ref));

	if (!ref)

		return -ENOMEM;

	ref->type = elem_ref->type;

	ref->elem = elem_ref;

	snd_strlcpy(ref->id, elem_ref->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	list_add_tail(&ref->list, &elem->ref_list);

	return 0;

}

void tplg_ref_free_list(struct list_head *base)

{

	struct list_head *pos, *npos;

	struct tplg_ref *ref;

	list_for_each_safe(pos, npos, base) {

		ref = list_entry(pos, struct tplg_ref, list);

		list_del(&ref->list);

		free(ref);

	}

}

struct tplg_elem *tplg_elem_new(void)

{

	struct tplg_elem *elem;

	elem = calloc(1, sizeof(*elem));

	if (!elem)

		return NULL;

	INIT_LIST_HEAD(&elem->ref_list);

	return elem;

}

void tplg_elem_free(struct tplg_elem *elem)

{

	list_del(&elem->list);

	tplg_ref_free_list(&elem->ref_list);

	/* free struct snd_tplg_ object,

	 * the union pointers share the same address

	 */

	if (elem->obj) {

		if (elem->free)

			elem->free(elem->obj);

		free(elem->obj);

	}

	free(elem);

}

void tplg_elem_free_list(struct list_head *base)

{

	struct list_head *pos, *npos;

	struct tplg_elem *elem;

	list_for_each_safe(pos, npos, base) {

		elem = list_entry(pos, struct tplg_elem, list);

		tplg_elem_free(elem);

	}

}

struct tplg_elem *tplg_elem_lookup(struct list_head *base, const char* id,

				   unsigned int type, int index)

{

	struct list_head *pos;

	struct tplg_elem *elem;

	if (!base || !id)

		return NULL;

	list_for_each(pos, base) {

		elem = list_entry(pos, struct tplg_elem, list);

		if (!strcmp(elem->id, id) && elem->type == type)

			return elem;

		/* SND_TPLG_INDEX_ALL is the default value "0" and applicable

		   for all use cases */

		if ((index != SND_TPLG_INDEX_ALL)

			&& (elem->index > index))

			break;

	}

	return NULL;

}

/* find an element by type */

struct tplg_elem *tplg_elem_type_lookup(snd_tplg_t *tplg,

					enum snd_tplg_type type)

{

	struct tplg_table *tptr;

	struct list_head *pos, *list;

	struct tplg_elem *elem;

	unsigned int index;

	for (index = 0; index < tplg_table_items; index++) {

		tptr = &tplg_table[index];

		if (!tptr->enew)

			continue;

		if ((int)type != tptr->type)

			continue;

		break;

	}

	if (index >= tplg_table_items)

		return NULL;

	list = (struct list_head *)((void *)tplg + tptr->loff);

	/* return only first element */

	list_for_each(pos, list) {

		elem = list_entry(pos, struct tplg_elem, list);

		return elem;

	}

	return NULL;

}

/* insert a new element into list in the ascending order of index value */

void tplg_elem_insert(struct tplg_elem *elem_p, struct list_head *list)

{

	struct list_head *pos, *p = &(elem_p->list);

	struct tplg_elem *elem;

	list_for_each(pos, list) {

		elem = list_entry(pos, struct tplg_elem, list);

		if (elem_p->index < elem->index)

			break;

	}

	/* insert item before pos */

	list_insert(p, pos->prev, pos);

}

/* create a new common element and object */

struct tplg_elem* tplg_elem_new_common(snd_tplg_t *tplg,

				       snd_config_t *cfg,

				       const char *name,

				       enum snd_tplg_type type)

{

	struct tplg_table *tptr;

	struct tplg_elem *elem;

	struct list_head *list;

	const char *id;

	int obj_size = 0;

	unsigned index;

	void *obj;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	if (!cfg && !name)

		return NULL;

	elem = tplg_elem_new();

	if (!elem)

		return NULL;

	/* do we get name from cfg */

	if (cfg) {

		snd_config_get_id(cfg, &id;;

		snd_strlcpy(elem->id, id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

		elem->id[SNDRV_CTL_ELEM_ID_NAME_MAXLEN - 1] = 0;

		/* as we insert new elem based on the index value, move index

		   parsing here */

		snd_config_for_each(i, next, cfg) {

			n = snd_config_iterator_entry(i);

			if (snd_config_get_id(n, &id))

				continue;

			if (strcmp(id, "index") == 0) {

				if (tplg_get_integer(n, &elem->index, 0)) {

					free(elem);

					return NULL;

				}

				if (elem->index < 0) {

					free(elem);

					return NULL;

				}

			}

		}

	} else if (name != NULL)

		snd_strlcpy(elem->id, name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	for (index = 0; index < tplg_table_items; index++) {

		tptr = &tplg_table[index];

		if (!tptr->enew)

			continue;

		if ((int)type != tptr->type)

			continue;

		break;

	}

	if (index >= tplg_table_items) {

		free(elem);

		return NULL;

	}

	list = (struct list_head *)((void *)tplg + tptr->loff);

	tplg_elem_insert(elem, list);

	obj_size = tptr->size;

	elem->free = tptr->free;

	elem->table = tptr;

	/* create new object too if required */

	if (obj_size > 0) {

		obj = calloc(1, obj_size);

		if (obj == NULL) {

			free(elem);

			return NULL;

		}

		elem->obj = obj;

		elem->size = obj_size;

	}

	elem->type = type;

	return elem;

}

struct tplg_alloc {

	struct list_head list;

	void *data[0];

};

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

{

	struct tplg_alloc *a;

	a = calloc(1, sizeof(*a) + size);

	if (a == NULL)

		return NULL;

	list_add_tail(&a->list, heap);

	return a->data;

}

void tplg_free(struct list_head *heap)

{

	struct list_head *pos, *npos;

	struct tplg_alloc *a;

	list_for_each_safe(pos, npos, heap) {

		a = list_entry(pos, struct tplg_alloc, list);

		list_del(&a->list);

		free(a);

	}

}