/*

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

/* place the multi-bit values on top - like read_write - for save */

static const struct ctl_access_elem ctl_access[] = {

	{"read_write", SNDRV_CTL_ELEM_ACCESS_READWRITE},

	{"tlv_read_write", SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE},

	{"read", SNDRV_CTL_ELEM_ACCESS_READ},

	{"write", SNDRV_CTL_ELEM_ACCESS_WRITE},

	{"volatile", SNDRV_CTL_ELEM_ACCESS_VOLATILE},

	{"tlv_read", SNDRV_CTL_ELEM_ACCESS_TLV_READ},

	{"tlv_write", SNDRV_CTL_ELEM_ACCESS_TLV_WRITE},

	{"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:");

	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", 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("failed to parse access");

				return err;

			}

			continue;

		}

	}

	return err;

}

/* Save Access */

static int tplg_save_access(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

			    struct snd_soc_tplg_ctl_hdr *hdr, char **dst,

			    const char *pfx)

{

	const char *last;

	unsigned int j, count, access, cval;

	int err;

	if (hdr->access == 0)

		return 0;

	access = hdr->access;

	for (j = 0, count = 0, last = NULL; j < ARRAY_SIZE(ctl_access); j++) {

		cval = ctl_access[j].value;

		if ((access & cval) == cval) {

			access &= ~cval;

			last = ctl_access[j].name;

			count++;

		}

	}

	if (count == 1)

		return tplg_save_printf(dst, pfx, "access.0 %s\n", last);

	err = tplg_save_printf(dst, pfx, "access [\n");

	if (err < 0)

		return err;

	access = hdr->access;

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

		cval = ctl_access[j].value;

		if ((access & cval) == cval) {

			err = tplg_save_printf(dst, pfx, "\t%s\n",

					       ctl_access[j].name);

			if (err < 0)

				return err;

			access &= ~cval;

		}

	}

	return tplg_save_printf(dst, pfx, "]\n");

}

/* 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", 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("cannot find '%s' referenced by"

				" control '%s'", 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("cannot find '%s' referenced by"

				" control '%s'", 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 = elem->tlv;

	struct snd_soc_tplg_tlv_dbscale *scale;

	const char *id = NULL;

	int val;

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

	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)

			return -EINVAL;

		/* get value */

		if (tplg_get_integer(n, &val, 0))

			continue;

		tplg_dbg("\t%s = %i", id, val);

		/* get TLV data */

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

			scale->min = val;

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

			scale->step = val;

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

			scale->mute = val;

		else

			SNDERR("unknown id '%s'", 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("failed to DBScale");

				return err;

			}

			continue;

		}

	}

	return err;

}

/* save TLV data */

int tplg_save_tlv(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

		  struct tplg_elem *elem,

		  char **dst, const char *pfx)

{

	struct snd_soc_tplg_ctl_tlv *tlv = elem->tlv;

	struct snd_soc_tplg_tlv_dbscale *scale;

	int err;

	if (tlv->type != SNDRV_CTL_TLVT_DB_SCALE) {

		SNDERR("unknown TLV type");

		return -EINVAL;

	}

	scale = &tlv->scale;

	err = tplg_save_printf(dst, NULL, "'%s' {\n", elem->id);

	if (err >= 0)

		err = tplg_save_printf(dst, pfx, "\tscale {\n");

	if (err >= 0 && scale->min)

		err = tplg_save_printf(dst, pfx, "\t\tmin %i\n", scale->min);

	if (err >= 0 && scale->step > 0)

		err = tplg_save_printf(dst, pfx, "\t\tstep %i\n", scale->step);

	if (err >= 0 && scale->mute > 0)

		err = tplg_save_printf(dst, pfx, "\t\tmute %i\n", scale->mute);

	if (err >= 0)

		err = tplg_save_printf(dst, pfx, "\t}\n");

	if (err >= 0)

		err = tplg_save_printf(dst, pfx, "}\n");

	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, ival;

	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", 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 (tplg_get_integer(n, &ival, 0))

				return -EINVAL;

			be->base = ival;

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

			continue;

		}

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

			if (tplg_get_integer(n, &ival, 0))

				return -EINVAL;

			be->num_regs = ival;

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

			continue;

		}

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

			if (tplg_get_integer(n, &ival, 0))

				return -EINVAL;

			be->max = ival;

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

			continue;

		}

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

			if (tplg_get_integer(n, &ival, 16))

				return -EINVAL;

			be->mask = ival;

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

			continue;

		}

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

			err = tplg_parse_refs(n, elem, SND_TPLG_TYPE_DATA);

			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", 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;

}

/* save control bytes */

int tplg_save_control_bytes(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

			    struct tplg_elem *elem,

			    char **dst, const char *pfx)

{

	struct snd_soc_tplg_bytes_control *be = elem->bytes_ext;

	char pfx2[16];

	int err;

	if (!be)

		return 0;

	snprintf(pfx2, sizeof(pfx2), "%s\t", pfx ?: "");

	err = tplg_save_printf(dst, NULL, "'%s' {\n", elem->id);

	if (err < 0)

		return err;

	if (err >= 0 && elem->index > 0)

		err = tplg_save_printf(dst, pfx, "\tindex %u\n", elem->index);

	if (err >= 0 && be->base > 0)

		err = tplg_save_printf(dst, pfx, "\tbase %u\n", be->base);

	if (err >= 0 && be->num_regs > 0)

		err = tplg_save_printf(dst, pfx, "\tnum_regs %u\n", be->num_regs);

	if (err >= 0 && be->max > 0)

		err = tplg_save_printf(dst, pfx, "\tmax %u\n", be->max);

	if (err >= 0 && be->mask > 0)

		err = tplg_save_printf(dst, pfx, "\tmask %u\n", be->mask);

	if (err >= 0)

		err = tplg_save_ops(tplg, &be->hdr, dst, pfx2);

	if (err >= 0)

		err = tplg_save_ext_ops(tplg, be, dst, pfx2);

	if (err >= 0)

		err = tplg_save_access(tplg, &be->hdr, dst, pfx2);

	if (err >= 0)

		err = tplg_save_refs(tplg, elem, SND_TPLG_TYPE_TLV,

				     "tlv", dst, pfx2);

	if (err >= 0)

		err = tplg_save_refs(tplg, elem, SND_TPLG_TYPE_DATA,

				     "data", dst, pfx2);

	if (err >= 0)

		err = tplg_save_printf(dst, pfx, "}\n");

	return err;

}

/* 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", 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", id, val);

			continue;

		}

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

			if (ec->num_channels >= SND_SOC_TPLG_MAX_CHAN) {

				SNDERR("too many channels %s", 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_refs(n, elem, SND_TPLG_TYPE_DATA);

			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;

}

/* save control eunm */

int tplg_save_control_enum(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

			   struct tplg_elem *elem,

			   char **dst, const char *pfx)

{

	struct snd_soc_tplg_enum_control *ec = elem->enum_ctrl;

	char pfx2[16];

	int err;

	if (!ec)

		return 0;

	snprintf(pfx2, sizeof(pfx2), "%s\t", pfx ?: "");

	err = tplg_save_printf(dst, NULL, "'%s' {\n", elem->id);

	if (err < 0)

		return err;

	if (err >= 0 && elem->index > 0)

		err = tplg_save_printf(dst, pfx, "\tindex %u\n", elem->index);

	if (err >= 0)

		err = tplg_save_refs(tplg, elem, SND_TPLG_TYPE_TEXT,

				     "texts", dst, pfx2);

	if (err >= 0)

		err = tplg_save_channels(tplg, ec->channel, ec->num_channels,

					 dst, pfx2);

	if (err >= 0)

		err = tplg_save_ops(tplg, &ec->hdr, dst, pfx2);

	if (err >= 0)

		err = tplg_save_access(tplg, &ec->hdr, dst, pfx2);

	if (err >= 0)

		err = tplg_save_refs(tplg, elem, SND_TPLG_TYPE_DATA,

				     "data", dst, pfx2);

	if (err >= 0)

		err = tplg_save_printf(dst, pfx, "}\n");

	return err;

}

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

	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", 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("too many channels %s", 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 (tplg_get_integer(n, &ival, 0))

				return -EINVAL;

			mc->max = ival;

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

			continue;

		}

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

			ival = snd_config_get_bool(n);

			if (ival < 0)

				return -EINVAL;

			mc->invert = ival;

			tplg_dbg("\t%s: %d", 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", id, val);

			continue;

		}

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

			err = tplg_parse_refs(n, elem, SND_TPLG_TYPE_DATA);

			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;

}

int tplg_save_control_mixer(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

			    struct tplg_elem *elem, char **dst,

			    const char *pfx)

{

	struct snd_soc_tplg_mixer_control *mc = elem->mixer_ctrl;

	char pfx2[16];

	int err;

	if (!mc)

		return 0;

	err = tplg_save_printf(dst, NULL, "'%s' {\n", elem->id);

	if (err < 0)

		return err;

	snprintf(pfx2, sizeof(pfx2), "%s\t", pfx ?: "");

	if (err >= 0 && elem->index > 0)

		err = tplg_save_printf(dst, pfx, "\tindex %u\n", elem->index);

	if (err >= 0)

		err = tplg_save_channels(tplg, mc->channel, mc->num_channels,

					 dst, pfx2);

	if (err >= 0 && mc->max > 0)

		err = tplg_save_printf(dst, pfx, "\tmax %u\n", mc->max);