/*

  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 RATE(v) [SND_PCM_RATE_##v] = #v

static const char *const snd_pcm_rate_names[] = {

	RATE(5512),

	RATE(8000),

	RATE(11025),

	RATE(16000),

	RATE(22050),

	RATE(32000),

	RATE(44100),

	RATE(48000),

	RATE(64000),

	RATE(88200),

	RATE(96000),

	RATE(176400),

	RATE(192000),

	RATE(CONTINUOUS),

	RATE(KNOT),

};

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

{

	struct list_head *pos;

	struct tplg_elem *elem;

	struct snd_soc_tplg_pcm *pcm;

	list_for_each(pos, base) {

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

		if (elem->type != SND_TPLG_TYPE_PCM)

			return NULL;

		pcm = elem->pcm;

		if (pcm && !strcmp(pcm->dai_name, id))

			return elem;

	}

	return NULL;

}

/* copy referenced caps to the parent (pcm or be dai) */

static void copy_stream_caps(const char *id ATTRIBUTE_UNUSED,

			     struct snd_soc_tplg_stream_caps *caps,

			     struct tplg_elem *ref_elem)

{

	struct snd_soc_tplg_stream_caps *ref_caps = ref_elem->stream_caps;

	tplg_dbg("Copy pcm caps (%ld bytes) from '%s' to '%s'",

		sizeof(*caps), ref_elem->id, id);

	*caps =  *ref_caps;

}

/* find and copy the referenced stream caps */

static int tplg_build_stream_caps(snd_tplg_t *tplg,

				  const char *id, int index,

				  struct snd_soc_tplg_stream_caps *caps)

{

	struct tplg_elem *ref_elem = NULL;

	unsigned int i;

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

		ref_elem = tplg_elem_lookup(&tplg->pcm_caps_list,

			caps[i].name, SND_TPLG_TYPE_STREAM_CAPS, index);

		if (ref_elem != NULL)

			copy_stream_caps(id, &caps[i], ref_elem);

	}

	return 0;

}

/* build a PCM (FE DAI & DAI link) element */

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

{

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	int err;

	err = tplg_build_stream_caps(tplg, elem->id, elem->index,

						elem->pcm->caps);

	if (err < 0)

		return err;

	/* merge private data from the referenced data elements */

	base = &elem->ref_list;

	list_for_each(pos, base) {

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

		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"

				" PCM '%s'", ref->id, elem->id);

			return -EINVAL;

		}

	}

	return 0;

}

/* build all PCM (FE DAI & DAI link) elements */

int tplg_build_pcms(snd_tplg_t *tplg, unsigned int type)

{

	struct list_head *base, *pos;

	struct tplg_elem *elem;

	int err = 0;

	base = &tplg->pcm_list;

	list_for_each(pos, base) {

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

		if (elem->type != type) {

			SNDERR("invalid elem '%s'", elem->id);

			return -EINVAL;

		}

		err = build_pcm(tplg, elem);

		if (err < 0)

			return err;

		/* add PCM to manifest */

		tplg->manifest.pcm_elems++;

	}

	return 0;

}

/* build a physical DAI */

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

{

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	int err = 0;

	/* get playback & capture stream caps */

	err = tplg_build_stream_caps(tplg, elem->id, elem->index,

						elem->dai->caps);

	if (err < 0)

		return err;

	/* get private data */

	base = &elem->ref_list;

	list_for_each(pos, base) {

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

		if (ref->type == SND_TPLG_TYPE_DATA) {

			err = tplg_copy_data(tplg, elem, ref);

			if (err < 0)

				return err;

		}

	}

	/* add DAI to manifest */

	tplg->manifest.dai_elems++;

	return 0;

}

/* build physical DAIs*/

int tplg_build_dais(snd_tplg_t *tplg, unsigned int type)

{

	struct list_head *base, *pos;

	struct tplg_elem *elem;

	int err = 0;

	base = &tplg->dai_list;

	list_for_each(pos, base) {

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

		if (elem->type != type) {

			SNDERR("invalid elem '%s'", elem->id);

			return -EINVAL;

		}

		err = tplg_build_dai(tplg, elem);

		if (err < 0)

			return err;

	}

	return 0;

}

static int tplg_build_stream_cfg(snd_tplg_t *tplg,

				 struct snd_soc_tplg_stream *stream,

				 int num_streams, int index)

{

	struct snd_soc_tplg_stream *strm;

	struct tplg_elem *ref_elem;

	int i;

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

		strm = stream + i;

		ref_elem = tplg_elem_lookup(&tplg->pcm_config_list,

			strm->name, SND_TPLG_TYPE_STREAM_CONFIG, index);

		if (ref_elem && ref_elem->stream_cfg)

			*strm = *ref_elem->stream_cfg;

	}

	return 0;

}

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

{

	struct snd_soc_tplg_link_config *link = elem->link;

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	int num_hw_configs = 0, err = 0;

	err = tplg_build_stream_cfg(tplg, link->stream,

				    link->num_streams, elem->index);

	if (err < 0)

		return err;

	/* hw configs & private data */

	base = &elem->ref_list;

	list_for_each(pos, base) {

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

		switch (ref->type) {

		case SND_TPLG_TYPE_HW_CONFIG:

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

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

			if (!ref->elem) {

				SNDERR("cannot find HW config '%s'"

				       " referenced by link '%s'",

				       ref->id, elem->id);

				return -EINVAL;

			}

			memcpy(&link->hw_config[num_hw_configs],

				ref->elem->hw_cfg,

				sizeof(struct snd_soc_tplg_hw_config));

			num_hw_configs++;

			break;

		case SND_TPLG_TYPE_DATA: /* merge private data */

			err = tplg_copy_data(tplg, elem, ref);

			if (err < 0)

				return err;

			link = elem->link; /* realloc */

			break;

		default:

			break;

		}

	}

	/* add link to manifest */

	tplg->manifest.dai_link_elems++;

	return 0;

}

/* build physical DAI link configurations */

int tplg_build_links(snd_tplg_t *tplg, unsigned int type)

{

	struct list_head *base, *pos;

	struct tplg_elem *elem;

	int err = 0;

	switch (type) {

	case SND_TPLG_TYPE_LINK:

	case SND_TPLG_TYPE_BE:

		base = &tplg->be_list;

		break;

	case SND_TPLG_TYPE_CC:

		base = &tplg->cc_list;

		break;

	default:

		return -EINVAL;

	}

	list_for_each(pos, base) {

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

		err =  build_link(tplg, elem);

		if (err < 0)

			return err;

	}

	return 0;

}

static int split_format(struct snd_soc_tplg_stream_caps *caps, char *str)

{

	char *s = NULL;

	snd_pcm_format_t format;

	int i = 0;

	s = strtok(str, ",");

	while ((s != NULL) && (i < SND_SOC_TPLG_MAX_FORMATS)) {

		format = snd_pcm_format_value(s);

		if (format == SND_PCM_FORMAT_UNKNOWN) {

			SNDERR("unsupported stream format %s", s);

			return -EINVAL;

		}

		caps->formats |= 1ull << format;

		s = strtok(NULL, ", ");

		i++;

	}

	return 0;

}

static int get_rate_value(const char* name)

{

	int rate;

	for (rate = 0; rate <= SND_PCM_RATE_LAST; rate++) {

		if (snd_pcm_rate_names[rate] &&

		    strcasecmp(name, snd_pcm_rate_names[rate]) == 0) {

			return rate;

		}

	}

	return SND_PCM_RATE_UNKNOWN;

}

static const char *get_rate_name(int rate)

{

	if (rate >= 0 && rate <= SND_PCM_RATE_LAST)

		return snd_pcm_rate_names[rate];

	return NULL;

}

static int split_rate(struct snd_soc_tplg_stream_caps *caps, char *str)

{

	char *s = NULL;

	snd_pcm_rates_t rate;

	int i = 0;

	s = strtok(str, ",");

	while (s) {

		rate = get_rate_value(s);

		if (rate == SND_PCM_RATE_UNKNOWN) {

			SNDERR("unsupported stream rate %s", s);

			return -EINVAL;

		}

		caps->rates |= 1 << rate;

		s = strtok(NULL, ", ");

		i++;

	}

	return 0;

}

static int parse_unsigned(snd_config_t *n, unsigned int *dst)

{

	int ival;

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

		return -EINVAL;

	*dst = ival;

#if TPLG_DEBUG

	{

		const char *id;

		if (snd_config_get_id(n, &id) >= 0)

			tplg_dbg("\t\t%s: %d", id, *dst);

	}

#endif

	return 0;

}

/* Parse pcm stream capabilities */

int tplg_parse_stream_caps(snd_tplg_t *tplg,

			   snd_config_t *cfg,

			   void *private ATTRIBUTE_UNUSED)

{

	struct snd_soc_tplg_stream_caps *sc;

	struct tplg_elem *elem;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id, *val;

	char *s;

	int err;

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

	if (!elem)

		return -ENOMEM;

	sc = elem->stream_caps;

	sc->size = elem->size;

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

	tplg_dbg(" PCM Capabilities: %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, "formats") == 0) {

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

				return -EINVAL;

			s = strdup(val);

			if (s == NULL)

				return -ENOMEM;

			err = split_format(sc, s);

			free(s);

			if (err < 0)

				return err;

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

			continue;

		}

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

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

				return -EINVAL;

			s = strdup(val);

			if (!s)

				return -ENOMEM;

			err = split_rate(sc, s);

			free(s);

			if (err < 0)

				return err;

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

			continue;

		}

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

			if (parse_unsigned(n, &sc->rate_min))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->rate_max))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->channels_min))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->channels_max))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->periods_min))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->periods_max))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->period_size_min))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->period_size_max))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->buffer_size_min))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->buffer_size_max))

				return -EINVAL;

			continue;

		}

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

			if (parse_unsigned(n, &sc->sig_bits))

				return -EINVAL;

			continue;

		}

	}

	return 0;

}

/* save stream caps */

int tplg_save_stream_caps(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

			  struct tplg_elem *elem,

			  char **dst, const char *pfx)

{

	struct snd_soc_tplg_stream_caps *sc = elem->stream_caps;

	const char *s;

	unsigned int i;

	int err, first;

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

	if (err >= 0 && sc->formats) {

		err = tplg_save_printf(dst, pfx, "\tformats '");

		first = 1;

		for (i = 0; err >= 0 && i < SND_PCM_FORMAT_LAST; i++) {

			if (sc->formats & (1ULL << i)) {

				s = snd_pcm_format_name(i);

				err = tplg_save_printf(dst, NULL, "%s%s",

						       !first ? ", " : "", s);

				first = 0;

			}

		}

		if (err >= 0)

			err = tplg_save_printf(dst, NULL, "'\n");

	}

	if (err >= 0 && sc->rates) {

		err = tplg_save_printf(dst, pfx, "\trates '");

		first = 1;

		for (i = 0; err >= 0 && i < SND_PCM_RATE_LAST; i++) {

			if (sc->rates & (1ULL << i)) {

				s = get_rate_name(i);

				err = tplg_save_printf(dst, NULL, "%s%s",

						       !first ? ", " : "", s);

				first = 0;

			}

		}

		if (err >= 0)

			err = tplg_save_printf(dst, NULL, "'\n");

	}

	if (err >= 0 && sc->rate_min)

		err = tplg_save_printf(dst, pfx, "\trate_min %u\n",

				       sc->rate_min);

	if (err >= 0 && sc->rate_max)

		err = tplg_save_printf(dst, pfx, "\trate_max %u\n",

				       sc->rate_max);

	if (err >= 0 && sc->channels_min)

		err = tplg_save_printf(dst, pfx, "\tchannels_min %u\n",

				       sc->channels_min);

	if (err >= 0 && sc->channels_max)

		err = tplg_save_printf(dst, pfx, "\tchannels_max %u\n",

				       sc->channels_max);

	if (err >= 0 && sc->periods_min)

		err = tplg_save_printf(dst, pfx, "\tperiods_min %u\n",

				       sc->periods_min);

	if (err >= 0 && sc->periods_max)

		err = tplg_save_printf(dst, pfx, "\tperiods_max %u\n",

				       sc->periods_max);

	if (err >= 0 && sc->period_size_min)

		err = tplg_save_printf(dst, pfx, "\tperiod_size_min %u\n",

				       sc->period_size_min);

	if (err >= 0 && sc->period_size_max)

		err = tplg_save_printf(dst, pfx, "\tperiod_size_max %u\n",

				       sc->period_size_max);

	if (err >= 0 && sc->buffer_size_min)

		err = tplg_save_printf(dst, pfx, "\tbuffer_size_min %u\n",

				       sc->buffer_size_min);

	if (err >= 0 && sc->buffer_size_max)

		err = tplg_save_printf(dst, pfx, "\tbuffer_size_max %u\n",

				       sc->buffer_size_max);

	if (err >= 0)

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

	return err;

}

/* Parse the caps and config of a pcm stream */

static int tplg_parse_streams(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

			      snd_config_t *cfg, void *private)

{

	snd_config_iterator_t i, next;

	snd_config_t *n;

	struct tplg_elem *elem = private;

	struct snd_soc_tplg_pcm *pcm;

	struct snd_soc_tplg_dai *dai;

	unsigned int *playback, *capture;

	struct snd_soc_tplg_stream_caps *caps;

	const char *id, *value;

	int stream;

	snd_config_get_id(cfg, &id;;

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

	switch (elem->type) {

	case SND_TPLG_TYPE_PCM:

		pcm = elem->pcm;

		playback = &pcm->playback;

		capture = &pcm->capture;

		caps = pcm->caps;

		break;

	case SND_TPLG_TYPE_DAI:

		dai = elem->dai;

		playback = &dai->playback;

		capture = &dai->capture;

		caps = dai->caps;

		break;

	default:

		return -EINVAL;

	}

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

		stream = SND_SOC_TPLG_STREAM_PLAYBACK;

		*playback = 1;

	} else if (strcmp(id, "capture") == 0) {

		stream = SND_SOC_TPLG_STREAM_CAPTURE;

		*capture = 1;

	} else

		return -EINVAL;

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		/* get id */

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

			continue;

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

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

				continue;

			/* store stream caps name, to find and merge

			 * the caps in building phase.

			 */

			snd_strlcpy(caps[stream].name, value,

				SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

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

			continue;

		}

	}

	return 0;

}

/* Save the caps and config of a pcm stream */

int tplg_save_streams(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

		      struct tplg_elem *elem,

		      char **dst, const char *pfx)

{

	static const char *stream_ids[2] = {

		"playback",

		"capture"

	};

	static unsigned int stream_types[2] = {

		SND_SOC_TPLG_STREAM_PLAYBACK,

		SND_SOC_TPLG_STREAM_CAPTURE

	};

	struct snd_soc_tplg_stream_caps *caps;

	unsigned int streams[2], stream;

	const char *s;

	int err;

	switch (elem->type) {

	case SND_TPLG_TYPE_PCM:

		streams[0] = elem->pcm->playback;

		streams[1] = elem->pcm->capture;

		caps = elem->pcm->caps;

		break;

	case SND_TPLG_TYPE_DAI:

		streams[0] = elem->dai->playback;

		streams[1] = elem->dai->capture;

		caps = elem->dai->caps;

		break;

	default:

		return -EINVAL;

	}

	for (stream = 0; stream < 2; stream++) {

		if (streams[stream] == 0)

			continue;

		if (!caps)

			continue;

		s = caps[stream_types[stream]].name;

		if (s[0] == '\0')

			continue;

		err = tplg_save_printf(dst, pfx, "pcm.%s {\n", stream_ids[stream]);

		if (err < 0)

			return err;

		err = tplg_save_printf(dst, pfx, "\tcapabilities '%s'\n", s);

		if (err < 0)

			return err;

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

		if (err < 0)

			return err;

	}

	return 0;

}

/* Parse name and id of a front-end DAI (ie. cpu dai of a FE DAI link) */

static int tplg_parse_fe_dai(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

			     snd_config_t *cfg, void *private)

{

	struct tplg_elem *elem = private;

	struct snd_soc_tplg_pcm *pcm = elem->pcm;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id;

	snd_config_get_id(cfg, &id;;

	tplg_dbg("\t\tFE DAI %s:", id);

	snd_strlcpy(pcm->dai_name, id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		/* get id */

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

			continue;

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

			if (tplg_get_unsigned(n, &pcm->dai_id, 0)) {

				SNDERR("invalid fe dai ID");

				return -EINVAL;

			}

			tplg_dbg("\t\t\tindex: %d", pcm->dai_id);

		}

	}

	return 0;

}

/* Save the caps and config of a pcm stream */

int tplg_save_fe_dai(snd_tplg_t *tplg ATTRIBUTE_UNUSED,

		     struct tplg_elem *elem,

		     char **dst, const char *pfx)

{

	struct snd_soc_tplg_pcm *pcm = elem->pcm;

	int err = 0;

	if (pcm->dai_id > 0)

		err = tplg_save_printf(dst, pfx, "dai.0.id %u\n", pcm->dai_id);

	return err;

}

/* parse a flag bit of the given mask */

static int parse_flag(snd_config_t *n, unsigned int mask_in,

		      unsigned int *mask, unsigned int *flags)

{

	int ret;

	ret = snd_config_get_bool(n);

	if (ret < 0)

		return ret;

	*mask |= mask_in;

	if (ret)

		*flags |= mask_in;

	else

		*flags &= ~mask_in;

	return 0;

}

static int save_flags(unsigned int flags, unsigned int mask,

		      char **dst, const char *pfx)

{

	static unsigned int flag_masks[3] = {

		SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES,

		SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS,

		SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS,

	};

	static const char *flag_ids[3] = {

		"symmetric_rates",

		"symmetric_channels",

		"symmetric_sample_bits",

	};

	unsigned int i;

	int err = 0;

	for (i = 0; err >= 0 && i < ARRAY_SIZE(flag_masks); i++) {

		if (mask & flag_masks[i]) {

			unsigned int v = (flags & flag_masks[i]) ? 1 : 0;

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

					       flag_ids[i], v);

		}

	}

	return err;

}

/* Parse PCM (for front end DAI & DAI link) in text conf file */

int tplg_parse_pcm(snd_tplg_t *tplg, snd_config_t *cfg,

		   void *private ATTRIBUTE_UNUSED)

{

	struct snd_soc_tplg_pcm *pcm;

	struct tplg_elem *elem;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id;

	int err, ival;

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

	if (!elem)

		return -ENOMEM;

	pcm = elem->pcm;

	pcm->size = elem->size;

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

	tplg_dbg(" PCM: %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, "id") == 0) {

			if (parse_unsigned(n, &pcm->pcm_id))

				return -EINVAL;

			continue;

		}

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

			err = tplg_parse_compound(tplg, n,

				tplg_parse_streams, elem);

			if (err < 0)

				return err;

			continue;

		}

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

			ival = snd_config_get_bool(n);

			if (ival < 0)