/*

  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"

#define ENUM_VAL_SIZE 	(SNDRV_CTL_ELEM_ID_NAME_MAXLEN >> 2)

struct ctl_access_elem {

	const char *name;

	unsigned int value;

};

/* CTL access strings and codes */

static const struct ctl_access_elem ctl_access[] = {

	{"read", SNDRV_CTL_ELEM_ACCESS_READ},

	{"write", SNDRV_CTL_ELEM_ACCESS_WRITE},

	{"read_write", SNDRV_CTL_ELEM_ACCESS_READWRITE},

	{"volatile", SNDRV_CTL_ELEM_ACCESS_VOLATILE},

	{"timestamp", SNDRV_CTL_ELEM_ACCESS_TIMESTAMP},

	{"tlv_read", SNDRV_CTL_ELEM_ACCESS_TLV_READ},

	{"tlv_write", SNDRV_CTL_ELEM_ACCESS_TLV_WRITE},

	{"tlv_read_write", SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE},

	{"tlv_command", SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND},

	{"inactive", SNDRV_CTL_ELEM_ACCESS_INACTIVE},

	{"lock", SNDRV_CTL_ELEM_ACCESS_LOCK},

	{"owner", SNDRV_CTL_ELEM_ACCESS_OWNER},

	{"tlv_callback", SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK},

};

/* find CTL access strings and conver to values */

static int parse_access_values(snd_config_t *cfg,

	struct snd_soc_tplg_ctl_hdr *hdr)

{

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *value = NULL;

	unsigned int j;

	tplg_dbg(" Access:\n");

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		/* get value */

		if (snd_config_get_string(n, &value) < 0)

			continue;

		/* match access value and set flags */

		for (j = 0; j < ARRAY_SIZE(ctl_access); j++) {

			if (strcmp(value, ctl_access[j].name) == 0) {

				hdr->access |= ctl_access[j].value;

				tplg_dbg("\t%s\n", value);

				break;

			}

		}

	}

	return 0;

}

/* Parse Access */

int parse_access(snd_config_t *cfg,

	struct snd_soc_tplg_ctl_hdr *hdr)

{

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id;

	int err = 0;

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		if (snd_config_get_id(n, &id) < 0)

			continue;

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

			err = parse_access_values(n, hdr);

			if (err < 0) {

				SNDERR("error: failed to parse access");

				return err;

			}

			continue;

		}

	}

	return err;

}

/* copy referenced TLV to the mixer control */

static int copy_tlv(struct tplg_elem *elem, struct tplg_elem *ref)

{

	struct snd_soc_tplg_mixer_control *mixer_ctrl =  elem->mixer_ctrl;

	struct snd_soc_tplg_ctl_tlv *tlv = ref->tlv;

	tplg_dbg("TLV '%s' used by '%s\n", ref->id, elem->id);

	/* TLV has a fixed size */

	mixer_ctrl->hdr.tlv = *tlv;

	return 0;

}

/* check referenced TLV for a mixer control */

static int tplg_build_mixer_control(snd_tplg_t *tplg,

				struct tplg_elem *elem)

{

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	int err = 0;

	base = &elem->ref_list;

	/* for each ref in this control elem */

	list_for_each(pos, base) {

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

		if (ref->elem)

			continue;

		if (ref->type == SND_TPLG_TYPE_TLV) {

			ref->elem = tplg_elem_lookup(&tplg->tlv_list,

				ref->id, SND_TPLG_TYPE_TLV, elem->index);

			if (ref->elem)

				 err = copy_tlv(elem, ref->elem);

		} else if (ref->type == SND_TPLG_TYPE_DATA) {

			err = tplg_copy_data(tplg, elem, ref);

			if (err < 0)

				return err;

		}

		if (!ref->elem) {

			SNDERR("error: cannot find '%s' referenced by"

				" control '%s'\n", ref->id, elem->id);

			return -EINVAL;

		} else if (err < 0)

			return err;

	}

	return 0;

}

static void copy_enum_texts(struct tplg_elem *enum_elem,

	struct tplg_elem *ref_elem)

{

	struct snd_soc_tplg_enum_control *ec = enum_elem->enum_ctrl;

	struct tplg_texts *texts = ref_elem->texts;

	memcpy(ec->texts, texts->items,

		SND_SOC_TPLG_NUM_TEXTS * SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	ec->items += texts->num_items;

}

/* check referenced text for a enum control */

static int tplg_build_enum_control(snd_tplg_t *tplg,

				struct tplg_elem *elem)

{

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	int err;

	base = &elem->ref_list;

	list_for_each(pos, base) {

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

		if (ref->elem)

			continue;

		if (ref->type == SND_TPLG_TYPE_TEXT) {

			ref->elem = tplg_elem_lookup(&tplg->text_list,

				ref->id, SND_TPLG_TYPE_TEXT, elem->index);

			if (ref->elem)

				copy_enum_texts(elem, ref->elem);

		} else if (ref->type == SND_TPLG_TYPE_DATA) {

			err = tplg_copy_data(tplg, elem, ref);

			if (err < 0)

				return err;

		}

		if (!ref->elem) {

			SNDERR("error: cannot find '%s' referenced by"

				" control '%s'\n", ref->id, elem->id);

			return -EINVAL;

		}

	}

	return 0;

}

/* check referenced private data for a byte control */

static int tplg_build_bytes_control(snd_tplg_t *tplg, struct tplg_elem *elem)

{

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	int err;

	base = &elem->ref_list;

	list_for_each(pos, base) {

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

		if (ref->elem)

			continue;

		 if (ref->type == SND_TPLG_TYPE_DATA) {

			err = tplg_copy_data(tplg, elem, ref);

			if (err < 0)

				return err;

		}

	}

	return 0;

}

int tplg_build_controls(snd_tplg_t *tplg)

{

	struct list_head *base, *pos;

	struct tplg_elem *elem;

	int err = 0;

	base = &tplg->mixer_list;

	list_for_each(pos, base) {

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

		err = tplg_build_mixer_control(tplg, elem);

		if (err < 0)

			return err;

		/* add control to manifest */

		tplg->manifest.control_elems++;

	}

	base = &tplg->enum_list;

	list_for_each(pos, base) {

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

		err = tplg_build_enum_control(tplg, elem);

		if (err < 0)

			return err;

		/* add control to manifest */

		tplg->manifest.control_elems++;

	}

	base = &tplg->bytes_ext_list;

	list_for_each(pos, base) {

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

		err = tplg_build_bytes_control(tplg, elem);

		if (err < 0)

			return err;

		/* add control to manifest */

		tplg->manifest.control_elems++;

	}

	return 0;

}

/*

 * Parse TLV of DBScale type.

 *

 * Parse DBScale describing min, step, mute in DB.

 */

static int tplg_parse_tlv_dbscale(snd_config_t *cfg, struct tplg_elem *elem)

{

	snd_config_iterator_t i, next;

	snd_config_t *n;

	struct snd_soc_tplg_ctl_tlv *tplg_tlv;

	struct snd_soc_tplg_tlv_dbscale *scale;

	const char *id = NULL, *value = NULL;

	tplg_dbg(" scale: %s\n", elem->id);

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

	if (!tplg_tlv)

		return -ENOMEM;

	elem->tlv = tplg_tlv;

	tplg_tlv->size = sizeof(struct snd_soc_tplg_ctl_tlv);

	tplg_tlv->type = SNDRV_CTL_TLVT_DB_SCALE;

	scale = &tplg_tlv->scale;

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		/* get ID */

		if (snd_config_get_id(n, &id) < 0) {

			SNDERR("error: cant get ID\n");

			return -EINVAL;

		}

		/* get value */

		if (snd_config_get_string(n, &value) < 0)

			continue;

		tplg_dbg("\t%s = %s\n", id, value);

		/* get TLV data */

		if (strcmp(id, "min") == 0)

			scale->min = atoi(value);

		else if (strcmp(id, "step") == 0)

			scale->step = atoi(value);

		else if (strcmp(id, "mute") == 0)

			scale->mute = atoi(value);

		else

			SNDERR("error: unknown key %s\n", id);

	}

	return 0;

}

/* Parse TLV */

int tplg_parse_tlv(snd_tplg_t *tplg, snd_config_t *cfg,

	void *private ATTRIBUTE_UNUSED)

{

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id;

	int err = 0;

	struct tplg_elem *elem;

	elem = tplg_elem_new_common(tplg, cfg, NULL, SND_TPLG_TYPE_TLV);

	if (!elem)

		return -ENOMEM;

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		if (snd_config_get_id(n, &id) < 0)

			continue;

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

			err = tplg_parse_tlv_dbscale(n, elem);

			if (err < 0) {

				SNDERR("error: failed to DBScale");

				return err;

			}

			continue;

		}

	}

	return err;

}

/* Parse Control Bytes */

int tplg_parse_control_bytes(snd_tplg_t *tplg,

	snd_config_t *cfg, void *private ATTRIBUTE_UNUSED)

{

	struct snd_soc_tplg_bytes_control *be;

	struct tplg_elem *elem;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id, *val = NULL;

	int err;

	bool access_set = false, tlv_set = false;

	elem = tplg_elem_new_common(tplg, cfg, NULL, SND_TPLG_TYPE_BYTES);

	if (!elem)

		return -ENOMEM;

	be = elem->bytes_ext;

	be->size = elem->size;

	snd_strlcpy(be->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	be->hdr.type = SND_SOC_TPLG_TYPE_BYTES;

	tplg_dbg(" Control Bytes: %s\n", elem->id);

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		if (snd_config_get_id(n, &id) < 0)

			continue;

		/* skip comments */

		if (strcmp(id, "comment") == 0)

			continue;

		if (id[0] == '#')

			continue;

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			be->base = atoi(val);

			tplg_dbg("\t%s: %d\n", id, be->base);

			continue;

		}

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			be->num_regs = atoi(val);

			tplg_dbg("\t%s: %d\n", id, be->num_regs);

			continue;

		}

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			be->max = atoi(val);

			tplg_dbg("\t%s: %d\n", id, be->max);

			continue;

		}

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			be->mask = strtol(val, NULL, 16);

			tplg_dbg("\t%s: %d\n", id, be->mask);

			continue;

		}

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

			err = tplg_parse_data_refs(n, elem);

			if (err < 0)

				return err;

			continue;

		}

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			err = tplg_ref_add(elem, SND_TPLG_TYPE_TLV, val);

			if (err < 0)

				return err;

			tlv_set = true;

			tplg_dbg("\t%s: %s\n", id, val);

			continue;

		}

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

			err = tplg_parse_compound(tplg, n, tplg_parse_ops,

				&be->hdr);

			if (err < 0)

				return err;

			continue;

		}

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

			err = tplg_parse_compound(tplg, n, tplg_parse_ext_ops,

				be);

			if (err < 0)

				return err;

			continue;

		}

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

			err = parse_access(cfg, &be->hdr);

			if (err < 0)

				return err;

			access_set = true;

			continue;

		}

	}

	/* set CTL access to default values if none are provided */

	if (!access_set) {

		be->hdr.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;

		if (tlv_set)

			be->hdr.access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;

	}

	return 0;

}

/* Parse Control Enums. */

int tplg_parse_control_enum(snd_tplg_t *tplg, snd_config_t *cfg,

	void *private ATTRIBUTE_UNUSED)

{

	struct snd_soc_tplg_enum_control *ec;

	struct tplg_elem *elem;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id, *val = NULL;

	int err, j;

	bool access_set = false;

	elem = tplg_elem_new_common(tplg, cfg, NULL, SND_TPLG_TYPE_ENUM);

	if (!elem)

		return -ENOMEM;

	ec = elem->enum_ctrl;

	snd_strlcpy(ec->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	ec->hdr.type = SND_SOC_TPLG_TYPE_ENUM;

	ec->size = elem->size;

	tplg->channel_idx = 0;

	/* set channel reg to default state */

	for (j = 0; j < SND_SOC_TPLG_MAX_CHAN; j++)

		ec->channel[j].reg = -1;

	tplg_dbg(" Control Enum: %s\n", elem->id);

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		if (snd_config_get_id(n, &id) < 0)

			continue;

		/* skip comments */

		if (strcmp(id, "comment") == 0)

			continue;

		if (id[0] == '#')

			continue;

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			tplg_ref_add(elem, SND_TPLG_TYPE_TEXT, val);

			tplg_dbg("\t%s: %s\n", id, val);

			continue;

		}

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

			if (ec->num_channels >= SND_SOC_TPLG_MAX_CHAN) {

				SNDERR("error: too many channels %s\n",

					elem->id);

				return -EINVAL;

			}

			err = tplg_parse_compound(tplg, n, tplg_parse_channel,

				ec->channel);

			if (err < 0)

				return err;

			ec->num_channels = tplg->channel_idx;

			continue;

		}

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

			err = tplg_parse_compound(tplg, n, tplg_parse_ops,

				&ec->hdr);

			if (err < 0)

				return err;

			continue;

		}

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

			err = tplg_parse_data_refs(n, elem);

			if (err < 0)

				return err;

			continue;

		}

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

			err = parse_access(cfg, &ec->hdr);

			if (err < 0)

				return err;

			access_set = true;

			continue;

		}

	}

	/* set CTL access to default values if none are provided */

	if (!access_set) {

		ec->hdr.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;

	}

	return 0;

}

/* Parse Controls.

 *

 * Mixer control. Supports multiple channels.

 */

int tplg_parse_control_mixer(snd_tplg_t *tplg,

	snd_config_t *cfg, void *private ATTRIBUTE_UNUSED)

{

	struct snd_soc_tplg_mixer_control *mc;

	struct tplg_elem *elem;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id, *val = NULL;

	int err, j;

	bool access_set = false, tlv_set = false;

	elem = tplg_elem_new_common(tplg, cfg, NULL, SND_TPLG_TYPE_MIXER);

	if (!elem)

		return -ENOMEM;

	/* init new mixer */

	mc = elem->mixer_ctrl;

	snd_strlcpy(mc->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	mc->hdr.type = SND_SOC_TPLG_TYPE_MIXER;

	mc->size = elem->size;

	tplg->channel_idx = 0;

	/* set channel reg to default state */

	for (j = 0; j < SND_SOC_TPLG_MAX_CHAN; j++)

		mc->channel[j].reg = -1;

	tplg_dbg(" Control Mixer: %s\n", elem->id);

	/* giterate trough each mixer elment */

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		if (snd_config_get_id(n, &id) < 0)

			continue;

		/* skip comments */

		if (strcmp(id, "comment") == 0)

			continue;

		if (id[0] == '#')

			continue;

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

			if (mc->num_channels >= SND_SOC_TPLG_MAX_CHAN) {

				SNDERR("error: too many channels %s\n",

					elem->id);

				return -EINVAL;

			}

			err = tplg_parse_compound(tplg, n, tplg_parse_channel,

				mc->channel);

			if (err < 0)

				return err;

			mc->num_channels = tplg->channel_idx;

			continue;

		}

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			mc->max = atoi(val);

			tplg_dbg("\t%s: %d\n", id, mc->max);

			continue;

		}

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			if (strcmp(val, "true") == 0)

				mc->invert = 1;

			else if (strcmp(val, "false") == 0)

				mc->invert = 0;

			tplg_dbg("\t%s: %d\n", id, mc->invert);

			continue;

		}

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

			err = tplg_parse_compound(tplg, n, tplg_parse_ops,

				&mc->hdr);

			if (err < 0)

				return err;

			continue;

		}

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

			if (snd_config_get_string(n, &val) < 0)

				return -EINVAL;

			err = tplg_ref_add(elem, SND_TPLG_TYPE_TLV, val);

			if (err < 0)

				return err;

			tlv_set = true;

			tplg_dbg("\t%s: %s\n", id, val);

			continue;

		}

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

			err = tplg_parse_data_refs(n, elem);

			if (err < 0)

				return err;

			continue;

		}

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

			err = parse_access(cfg, &mc->hdr);

			if (err < 0)

				return err;

			access_set = true;

			continue;

		}

	}

	/* set CTL access to default values if none are provided */

	if (!access_set) {

		mc->hdr.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;

		if (tlv_set)

			mc->hdr.access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;

	}

	return 0;

}

static int init_ctl_hdr(struct snd_soc_tplg_ctl_hdr *hdr,

		struct snd_tplg_ctl_template *t)

{

	hdr->size = sizeof(struct snd_soc_tplg_ctl_hdr);

	hdr->type = t->type;

	snd_strlcpy(hdr->name, t->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	/* clean up access flag */

	if (t->access == 0)

		t->access = SNDRV_CTL_ELEM_ACCESS_READWRITE;

	t->access &= (SNDRV_CTL_ELEM_ACCESS_READWRITE |

		SNDRV_CTL_ELEM_ACCESS_VOLATILE |

		SNDRV_CTL_ELEM_ACCESS_INACTIVE |

		SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE |

		SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND |

		SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK);

	hdr->access = t->access;

	hdr->ops.get = t->ops.get;

	hdr->ops.put = t->ops.put;

	hdr->ops.info = t->ops.info;

	/* TLV */

	if (hdr->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE

		&& !(hdr->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK)) {

		struct snd_tplg_tlv_template *tlvt = t->tlv;

		struct snd_soc_tplg_ctl_tlv *tlv = &hdr->tlv;

		struct snd_tplg_tlv_dbscale_template *scalet;

		struct snd_soc_tplg_tlv_dbscale *scale;

		if (!tlvt) {

			SNDERR("error: missing TLV data\n");

			return -EINVAL;

		}

		tlv->size = sizeof(struct snd_soc_tplg_ctl_tlv);

		tlv->type = tlvt->type;

		switch (tlvt->type) {

		case SNDRV_CTL_TLVT_DB_SCALE:

			scalet = container_of(tlvt,

				struct snd_tplg_tlv_dbscale_template, hdr);

			scale = &tlv->scale;

			scale->min = scalet->min;

			scale->step = scalet->step;

			scale->mute = scalet->mute;

			break;

		/* TODO: add support for other TLV types */

		default:

			SNDERR("error: unsupported TLV type %d\n", tlv->type);

			break;

		}

	}

	return 0;

}

int tplg_add_mixer(snd_tplg_t *tplg, struct snd_tplg_mixer_template *mixer,

	struct tplg_elem **e)

{

	struct snd_soc_tplg_private *priv = mixer->priv;

	struct snd_soc_tplg_mixer_control *mc;

	struct tplg_elem *elem;

	int ret, i, num_channels;

	tplg_dbg(" Control Mixer: %s\n", mixer->hdr.name);

	if (mixer->hdr.type != SND_SOC_TPLG_TYPE_MIXER) {

		SNDERR("error: invalid mixer type %d\n", mixer->hdr.type);

		return -EINVAL;

	}

	elem = tplg_elem_new_common(tplg, NULL, mixer->hdr.name,

		SND_TPLG_TYPE_MIXER);

	if (!elem)

		return -ENOMEM;

	/* init new mixer */

	mc = elem->mixer_ctrl;

	mc->size = elem->size;

	ret =  init_ctl_hdr(&mc->hdr, &mixer->hdr);

	if (ret < 0) {

		tplg_elem_free(elem);

		return ret;

	}

	mc->min = mixer->min;

	mc->max = mixer->max;

	mc->platform_max = mixer->platform_max;

	mc->invert = mixer->invert;

	/* set channel reg to default state */

	for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++)

		mc->channel[i].reg = -1;

	num_channels = mixer->map ? mixer->map->num_channels : 0;

	mc->num_channels = num_channels;

	for (i = 0; i < num_channels; i++) {

		struct snd_tplg_channel_elem *channel = &mixer->map->channel[i];

		mc->channel[i].size = channel->size;

		mc->channel[i].reg = channel->reg;

		mc->channel[i].shift = channel->shift;

		mc->channel[i].id = channel->id;

	}

	/* priv data */

	if (priv) {

		mc = realloc(mc, elem->size + priv->size);

		if (!mc) {

			tplg_elem_free(elem);

			return -ENOMEM;

		}

		elem->mixer_ctrl = mc;

		elem->size += priv->size;

		mc->priv.size = priv->size;

		memcpy(mc->priv.data, priv->data,  priv->size);

        }

	if (e)

		*e = elem;

	return 0;

}

int tplg_add_enum(snd_tplg_t *tplg, struct snd_tplg_enum_template *enum_ctl,

	struct tplg_elem **e)

{

	struct snd_soc_tplg_enum_control *ec;

	struct tplg_elem *elem;

	int ret, i, num_items;

	tplg_dbg(" Control Enum: %s\n", enum_ctl->hdr.name);

	if (enum_ctl->hdr.type != SND_SOC_TPLG_TYPE_ENUM) {

		SNDERR("error: invalid enum type %d\n", enum_ctl->hdr.type);

		return -EINVAL;

	}

	elem = tplg_elem_new_common(tplg, NULL, enum_ctl->hdr.name,

		SND_TPLG_TYPE_ENUM);

	if (!elem)

		return -ENOMEM;

	ec = elem->enum_ctrl;

	ec->size = elem->size;

	ret = init_ctl_hdr(&ec->hdr, &enum_ctl->hdr);

	if (ret < 0) {

		tplg_elem_free(elem);

		return ret;

	}

	num_items =  enum_ctl->items < SND_SOC_TPLG_NUM_TEXTS ?

		enum_ctl->items : SND_SOC_TPLG_NUM_TEXTS;

	ec->items = num_items;

	ec->mask = enum_ctl->mask;

	ec->count = enum_ctl->items;

	if (enum_ctl->texts != NULL) {