/*

  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"

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)

{

	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);

		list_del(&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;

}

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

static 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;

	}

	p->prev = pos->prev;

	pos->prev->next = p;

	pos->prev = p;

	p->next = 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_elem *elem;

	const char *id, *val = NULL;

	int obj_size = 0;

	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 (snd_config_get_string(n, &val) < 0) {

					free(elem);

					return NULL;

				}

				elem->index = atoi(val);

			}

		}

	} else if (name != NULL)

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

	switch (type) {

	case SND_TPLG_TYPE_DATA:

		tplg_elem_insert(elem, &tplg->pdata_list);

		break;

	case SND_TPLG_TYPE_MANIFEST:

		tplg_elem_insert(elem, &tplg->manifest_list);

		obj_size = sizeof(struct snd_soc_tplg_manifest);

		break;

	case SND_TPLG_TYPE_TEXT:

		tplg_elem_insert(elem, &tplg->text_list);

		obj_size = sizeof(struct tplg_texts);

		break;

	case SND_TPLG_TYPE_TLV:

		tplg_elem_insert(elem, &tplg->tlv_list);

		elem->size = sizeof(struct snd_soc_tplg_ctl_tlv);

		break;

	case SND_TPLG_TYPE_BYTES:

		tplg_elem_insert(elem, &tplg->bytes_ext_list);

		obj_size = sizeof(struct snd_soc_tplg_bytes_control);

		break;

	case SND_TPLG_TYPE_ENUM:

		tplg_elem_insert(elem, &tplg->enum_list);

		obj_size = sizeof(struct snd_soc_tplg_enum_control);

		break;

	case SND_TPLG_TYPE_MIXER:

		tplg_elem_insert(elem, &tplg->mixer_list);

		obj_size = sizeof(struct snd_soc_tplg_mixer_control);

		break;

	case SND_TPLG_TYPE_DAPM_WIDGET:

		tplg_elem_insert(elem, &tplg->widget_list);

		obj_size = sizeof(struct snd_soc_tplg_dapm_widget);

		break;

	case SND_TPLG_TYPE_STREAM_CONFIG:

		tplg_elem_insert(elem, &tplg->pcm_config_list);

		obj_size = sizeof(struct snd_soc_tplg_stream);

		break;

	case SND_TPLG_TYPE_STREAM_CAPS:

		tplg_elem_insert(elem, &tplg->pcm_caps_list);

		obj_size = sizeof(struct snd_soc_tplg_stream_caps);

		break;

	case SND_TPLG_TYPE_PCM:

		tplg_elem_insert(elem, &tplg->pcm_list);

		obj_size = sizeof(struct snd_soc_tplg_pcm);

		break;

	case SND_TPLG_TYPE_DAI:

		tplg_elem_insert(elem, &tplg->dai_list);

		obj_size = sizeof(struct snd_soc_tplg_dai);

		break;

	case SND_TPLG_TYPE_BE:

	case SND_TPLG_TYPE_LINK:

		tplg_elem_insert(elem, &tplg->be_list);

		obj_size = sizeof(struct snd_soc_tplg_link_config);

		break;

	case SND_TPLG_TYPE_CC:

		tplg_elem_insert(elem, &tplg->cc_list);

		obj_size = sizeof(struct snd_soc_tplg_link_config);

		break;

	case SND_TPLG_TYPE_TOKEN:

		tplg_elem_insert(elem, &tplg->token_list);

		break;

	case SND_TPLG_TYPE_TUPLE:

		tplg_elem_insert(elem, &tplg->tuple_list);

		elem->free = tplg_free_tuples;

		break;

	case SND_TPLG_TYPE_HW_CONFIG:

		tplg_elem_insert(elem, &tplg->hw_cfg_list);

		obj_size = sizeof(struct snd_soc_tplg_hw_config);

		break;

	default:

		free(elem);

		return NULL;

	}

	/* 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;

}