/*

  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"

#include <ctype.h>

/* Get private data buffer of an element */

struct snd_soc_tplg_private *get_priv_data(struct tplg_elem *elem)

{

	struct snd_soc_tplg_private *priv = NULL;

	switch (elem->type) {

	case SND_TPLG_TYPE_MANIFEST:

		priv = &elem->manifest->priv;

		break;

	case SND_TPLG_TYPE_MIXER:

		priv = &elem->mixer_ctrl->priv;

		break;

	case SND_TPLG_TYPE_ENUM:

		priv = &elem->enum_ctrl->priv;

		break;

	case SND_TPLG_TYPE_BYTES:

		priv = &elem->bytes_ext->priv;

		break;

	case SND_TPLG_TYPE_DAPM_WIDGET:

		priv = &elem->widget->priv;

		break;

	case SND_TPLG_TYPE_DAI:

		priv = &elem->dai->priv;

		break;

	case SND_TPLG_TYPE_BE:

		priv = &elem->link->priv;

		break;

	case SND_TPLG_TYPE_PCM:

		priv = &elem->pcm->priv;

		break;

	default:

		SNDERR("error: '%s': no support for private data for type %d\n",

			elem->id, elem->type);

	}

	return priv;

}

/* Get Private data from a file. */

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

{

	struct snd_soc_tplg_private *priv = NULL;

	const char *value = NULL;

	char filename[MAX_FILE];

	char *env = getenv(ALSA_CONFIG_TPLG_VAR);

	FILE *fp;

	size_t size, bytes_read;

	int ret = 0;

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

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

		return -EINVAL;

	/* prepend alsa config directory to path */

	if (env)

		snprintf(filename, sizeof(filename), "%s/%s", env, value);

	else

		snprintf(filename, sizeof(filename), "%s/topology/%s",

			 snd_config_topdir(), value);

	fp = fopen(filename, "r");

	if (fp == NULL) {

		SNDERR("error: invalid data file path '%s'\n",

			filename);

		return -errno;

	}

	fseek(fp, 0L, SEEK_END);

	size = ftell(fp);

	fseek(fp, 0L, SEEK_SET);

	if (size <= 0) {

		SNDERR("error: invalid data file size %zu\n", size);

		ret = -EINVAL;

		goto err;

	}

	if (size > TPLG_MAX_PRIV_SIZE) {

		SNDERR("error: data file too big %zu\n", size);

		ret = -EINVAL;

		goto err;

	}

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

	if (!priv) {

		ret = -ENOMEM;

		goto err;

	}

	bytes_read = fread(&priv->data, 1, size, fp);

	if (bytes_read != size) {

		ret = -errno;

		goto err;

	}

	elem->data = priv;

	priv->size = size;

	elem->size = sizeof(*priv) + size;

	if (fclose(fp) == EOF) {

		SNDERR("Cannot close data file.");

		return -errno;

	}

	return 0;

err:

	fclose(fp);

	if (priv)

		free(priv);

	return ret;

}

static void dump_priv_data(struct tplg_elem *elem)

{

	struct snd_soc_tplg_private *priv = elem->data;

	unsigned int i, j = 0;

	tplg_dbg(" elem size = %d, priv data size = %d\n",

		elem->size, priv->size);

	for (i = 0; i < priv->size; i++) {

		if (j++ % 8 == 0)

			tplg_dbg("\n");

		tplg_dbg(" 0x%x", *p++);

	}

	tplg_dbg("\n\n");

}

/* get number of hex value elements in CSV list */

static int get_hex_num(const char *str)

{

	int commas = 0, values = 0, len = strlen(str);

	const char *end = str + len;

	/* we expect "0x0, 0x0, 0x0" */

	while (str < end) {

		/* skip white space */

		if (isspace(*str)) {

			str++;

			continue;

		}

		/* find delimeters */

		if (*str == ',') {

			commas++;

			str++;

			continue;

		}

		/* find 0x[0-9] values */

		if (*str == '0' && str + 2 <= end) {

			if (str[1] == 'x' && str[2] >= '0' && str[2] <= 'f') {

				values++;

				str += 3;

			} else {

				str++;

			}

		}

		str++;

	}

	/* there should always be one less comma than value */

	if (values -1 != commas)

		return -EINVAL;

	return values;

}

/* get uuid from a string made by 16 characters separated by commas */

static int get_uuid(const char *str, unsigned char *uuid_le)

{

	unsigned long int  val;

	char *tmp, *s = NULL;

	int values = 0, ret = 0;

	tmp = strdup(str);

	if (tmp == NULL)

		return -ENOMEM;

	s = strtok(tmp, ",");

	while (s != NULL) {

		errno = 0;

		val = strtoul(s, NULL, 0);

		if ((errno == ERANGE && val == ULONG_MAX)

			|| (errno != 0 && val == 0)

			|| (val > UCHAR_MAX)) {

			SNDERR("error: invalid value for uuid\n");

			ret = -EINVAL;

			goto out;

		}

		 *(uuid_le + values) = (unsigned char)val;

		values++;

		if (values >= 16)

			break;

		s = strtok(NULL, ",");

	}

	if (values < 16) {

		SNDERR("error: less than 16 integers for uuid\n");

		ret = -EINVAL;

	}

out:

	free(tmp);

	return ret;

}

static int write_hex(char *buf, char *str, int width)

{

	long val;

	void *p = &val;

        errno = 0;

	val = strtol(str, NULL, 16);

	if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN))

		|| (errno != 0 && val == 0)) {

		return -EINVAL;

        }

	switch (width) {

	case 1:

		*(unsigned char *)buf = *(unsigned char *)p;

		break;

	case 2:

		*(unsigned short *)buf = *(unsigned short *)p;

		break;

	case 4:

		*(unsigned int *)buf = *(unsigned int *)p;

		break;

	default:

		return -EINVAL;

	}

	return 0;

}

static int copy_data_hex(char *data, int off, const char *str, int width)

{

	char *tmp, *s = NULL, *p = data;

	int ret;

	tmp = strdup(str);

	if (tmp == NULL)

		return -ENOMEM;

	p += off;

	s = strtok(tmp, ",");

	while (s != NULL) {

		ret = write_hex(p, s, width);

		if (ret < 0) {

			free(tmp);

			return ret;

		}

		s = strtok(NULL, ",");

		p += width;

	}

	free(tmp);

	return 0;

}

static int tplg_parse_data_hex(snd_config_t *cfg, struct tplg_elem *elem,

	int width)

{

	struct snd_soc_tplg_private *priv;

	const char *value = NULL;

	int size, esize, off, num;

	int ret;

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

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

		return -EINVAL;

	num = get_hex_num(value);

	if (num <= 0) {

		SNDERR("error: malformed hex variable list %s\n", value);

		return -EINVAL;

	}

	size = num * width;

	priv = elem->data;

	if (size > TPLG_MAX_PRIV_SIZE) {

		SNDERR("error: data too big %d\n", size);

		return -EINVAL;

	}

	if (priv != NULL) {

		off = priv->size;

		esize = elem->size + size;

		priv = realloc(priv, esize);

	} else {

		off = 0;

		esize = sizeof(*priv) + size;

		priv = calloc(1, esize);

	}

	if (!priv)

		return -ENOMEM;

	elem->data = priv;

	priv->size += size;

	elem->size = esize;

	ret = copy_data_hex(priv->data, off, value, width);

	dump_priv_data(elem);

	return ret;

}

/* get the token integer value from its id */

static int get_token_value(const char *token_id,

	struct tplg_vendor_tokens *tokens)

{

	unsigned int i;

	for (i = 0; i < tokens->num_tokens; i++) {

		if (strcmp(token_id, tokens->token[i].id) == 0)

			return tokens->token[i].value;

	}

	SNDERR("error: cannot find token id '%s'\n", token_id);

	return -1;

}

/* get the vendor tokens referred by the vendor tuples */

static struct tplg_elem *get_tokens(snd_tplg_t *tplg, struct tplg_elem *elem)

{

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	base = &elem->ref_list;

	list_for_each(pos, base) {

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

		if (ref->type != SND_TPLG_TYPE_TOKEN)

			continue;

		if (!ref->elem) {

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

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

		}

		return ref->elem;

	}

	return NULL;

}

/* check if a data element has tuples */

static bool has_tuples(struct tplg_elem *elem)

{

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	base = &elem->ref_list;

	list_for_each(pos, base) {

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

		if (ref->type == SND_TPLG_TYPE_TUPLE)

			return true;

	}

	return false;

}

/* get size of a tuple element from its type */

static unsigned int get_tuple_size(int type)

{

	switch (type) {

	case SND_SOC_TPLG_TUPLE_TYPE_UUID:

		return sizeof(struct snd_soc_tplg_vendor_uuid_elem);

	case SND_SOC_TPLG_TUPLE_TYPE_STRING:

		return sizeof(struct snd_soc_tplg_vendor_string_elem);

	default:

		return sizeof(struct snd_soc_tplg_vendor_value_elem);

	}

}

/* Add a tuples object to the private buffer of its parent data element */

static int copy_tuples(struct tplg_elem *elem,

	struct tplg_vendor_tuples *tuples, struct tplg_vendor_tokens *tokens)

{

	struct snd_soc_tplg_private *priv = elem->data, *priv2;

	struct tplg_tuple_set *tuple_set;

	struct tplg_tuple *tuple;

	struct snd_soc_tplg_vendor_array *array;

	struct snd_soc_tplg_vendor_uuid_elem *uuid;

	struct snd_soc_tplg_vendor_string_elem *string;

	struct snd_soc_tplg_vendor_value_elem *value;

	int set_size, size, off;

	unsigned int i, j;

	int token_val;

	size = priv ? priv->size : 0; /* original private data size */

	/* scan each tuples set (one set per type) */

	for (i = 0; i < tuples->num_sets ; i++) {

		tuple_set = tuples->set[i];

		set_size = sizeof(struct snd_soc_tplg_vendor_array)

			+ get_tuple_size(tuple_set->type)

			* tuple_set->num_tuples;

		size += set_size;

		if (size > TPLG_MAX_PRIV_SIZE) {

			SNDERR("error: data too big %d\n", size);

			return -EINVAL;

		}

		if (priv != NULL) {

			priv2 = realloc(priv, sizeof(*priv) + size);

			if (priv2 == NULL) {

				free(priv);

				priv = NULL;

			} else {

				priv = priv2;

			}

		} else {

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

		}

		if (!priv)

			return -ENOMEM;

		off = priv->size;

		priv->size = size; /* update private data size */

		elem->data = priv;

		array = (struct snd_soc_tplg_vendor_array *)(priv->data + off);

		array->size = set_size;

		array->type = tuple_set->type;

		array->num_elems = tuple_set->num_tuples;

		/* fill the private data buffer */

		for (j = 0; j < tuple_set->num_tuples; j++) {

			tuple = &tuple_set->tuple[j];

			token_val = get_token_value(tuple->token, tokens);

			if (token_val  < 0)

				return -EINVAL;

			switch (tuple_set->type) {

			case SND_SOC_TPLG_TUPLE_TYPE_UUID:

				uuid = &array->uuid[j];

				uuid->token = token_val;

				memcpy(uuid->uuid, tuple->uuid, 16);

				break;

			case SND_SOC_TPLG_TUPLE_TYPE_STRING:

				string = &array->string[j];

				string->token = token_val;

				snd_strlcpy(string->string, tuple->string,

					SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

				break;

			default:

				value = &array->value[j];

				value->token = token_val;

				value->value = tuple->value;

				break;

			}

		}

	}

	return 0;

}

/* build a data element from its tuples */

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

{

	struct tplg_ref *ref;

	struct list_head *base, *pos;

	struct tplg_elem *tuples, *tokens;

	int err;

	base = &elem->ref_list;

	list_for_each(pos, base) {

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

		if (ref->type != SND_TPLG_TYPE_TUPLE)

			continue;

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

		if (!ref->elem)

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

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

		tuples = ref->elem;

		if (!tuples) {

			SNDERR("error: cannot find tuples %s\n", ref->id);

			return -EINVAL;

		}

		tokens = get_tokens(tplg, tuples);

		if (!tokens) {

			SNDERR("error: cannot find token for %s\n", ref->id);

			return -EINVAL;

		}

		/* a data object can have multiple tuples objects */

		err = copy_tuples(elem, tuples->tuples, tokens->tokens);

		if (err < 0)

			return err;

	}

	return 0;

}

static int parse_tuple_set(snd_config_t *cfg,

	struct tplg_tuple_set **s)

{

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id, *value;

	struct tplg_tuple_set *set;

	unsigned int type, num_tuples = 0;

	struct tplg_tuple *tuple;

	unsigned long int tuple_val;

	snd_config_get_id(cfg, &id;;

	if (strncmp(id, "uuid", 4) == 0)

		type = SND_SOC_TPLG_TUPLE_TYPE_UUID;

	else if (strncmp(id, "string", 5) == 0)

		type = SND_SOC_TPLG_TUPLE_TYPE_STRING;

	else if (strncmp(id, "bool", 4) == 0)

		type = SND_SOC_TPLG_TUPLE_TYPE_BOOL;

	else if (strncmp(id, "byte", 4) == 0)

		type = SND_SOC_TPLG_TUPLE_TYPE_BYTE;

	else if (strncmp(id, "short", 5) == 0)

		type = SND_SOC_TPLG_TUPLE_TYPE_SHORT;

	else if (strncmp(id, "word", 4) == 0)

		type = SND_SOC_TPLG_TUPLE_TYPE_WORD;

	else {

		SNDERR("error: invalid tuple type '%s'\n", id);

		return -EINVAL;

	}

	snd_config_for_each(i, next, cfg)

		num_tuples++;

	if (!num_tuples)

		return 0;

	tplg_dbg("\t %d %s tuples:\n", num_tuples, id);

	set = calloc(1, sizeof(*set) + num_tuples * sizeof(struct tplg_tuple));

	if (!set)

		return -ENOMEM;

	set->type = type;

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		/* get id */

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

			continue;

		/* get value */

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

			continue;

		tuple = &set->tuple[set->num_tuples];

		snd_strlcpy(tuple->token, id,

				SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

		switch (type) {

		case SND_SOC_TPLG_TUPLE_TYPE_UUID:

			if (get_uuid(value, tuple->uuid) < 0)

				goto err;

			break;

		case SND_SOC_TPLG_TUPLE_TYPE_STRING:

			snd_strlcpy(tuple->string, value,

				SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

			tplg_dbg("\t\t%s = %s\n", tuple->token, tuple->string);

			break;

		case SND_SOC_TPLG_TUPLE_TYPE_BOOL:

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

				tuple->value = 1;

			tplg_dbg("\t\t%s = %d\n", tuple->token, tuple->value);

			break;

		case SND_SOC_TPLG_TUPLE_TYPE_BYTE:

		case SND_SOC_TPLG_TUPLE_TYPE_SHORT:

		case SND_SOC_TPLG_TUPLE_TYPE_WORD:

			errno = 0;

			/* no support for negative value */

			tuple_val = strtoul(value, NULL, 0);

			if ((errno == ERANGE && tuple_val == ULONG_MAX)

				|| (errno != 0 && tuple_val == 0)) {

				SNDERR("error: tuple %s:strtoul fail\n", id);

				goto err;

			}

			if ((type == SND_SOC_TPLG_TUPLE_TYPE_WORD

					&& tuple_val > UINT_MAX)

				|| (type == SND_SOC_TPLG_TUPLE_TYPE_SHORT

					&& tuple_val > USHRT_MAX)

				|| (type == SND_SOC_TPLG_TUPLE_TYPE_BYTE

					&& tuple_val > UCHAR_MAX)) {

				SNDERR("error: tuple %s: invalid value\n", id);

				goto err;

			}

			tuple->value = (unsigned int) tuple_val;

			tplg_dbg("\t\t%s = 0x%x\n", tuple->token, tuple->value);

			break;

		default:

			break;

		}

		set->num_tuples++;

	}

	*s = set;

	return 0;

err:

	free(set);

	return -EINVAL;

}

static int parse_tuple_sets(snd_config_t *cfg,

	struct tplg_vendor_tuples *tuples)

{

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *id;

	unsigned int num_tuple_sets = 0;

	int err;

	if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {

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

			SNDERR("error: compound type expected for %s", id);

		return -EINVAL;

	}

	snd_config_for_each(i, next, cfg) {

		num_tuple_sets++;

	}

	if (!num_tuple_sets)

		return 0;

	tuples->set = calloc(1, num_tuple_sets * sizeof(void *));

	if (!tuples->set)

		return -ENOMEM;

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		if (snd_config_get_type(n) != SND_CONFIG_TYPE_COMPOUND) {

			SNDERR("error: compound type expected for %s, is %d",

			id, snd_config_get_type(n));

			return -EINVAL;

		}

		err = parse_tuple_set(n, &tuples->set[tuples->num_sets]);

		if (err < 0)

			return err;

		/* overlook empty tuple sets */

		if (tuples->set[tuples->num_sets])

			tuples->num_sets++;

	}

	return 0;

}

/* Parse tuples references for a data element, either a single tuples section

 * or a list of tuples sections.

 */

static int parse_tuples_refs(snd_config_t *cfg,

	struct tplg_elem *elem)

{

	snd_config_type_t  type;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *val = NULL;

	type = snd_config_get_type(cfg);

	/* refer to a single tuples section */

	if (type == SND_CONFIG_TYPE_STRING) {

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

			return -EINVAL;

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

		return tplg_ref_add(elem, SND_TPLG_TYPE_TUPLE, val);

	}

	if (type != SND_CONFIG_TYPE_COMPOUND) {

		SNDERR("error: compound type expected for %s", elem->id);

		return -EINVAL;

	}

	/* refer to a list of data sections */

	snd_config_for_each(i, next, cfg) {

		const char *val;

		n = snd_config_iterator_entry(i);

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

			continue;

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

		tplg_ref_add(elem, SND_TPLG_TYPE_TUPLE, val);

	}

	return 0;

}

/* Parse private data references for the element, either a single data section

 * or a list of data sections.

 */

int tplg_parse_data_refs(snd_config_t *cfg,

	struct tplg_elem *elem)

{

	snd_config_type_t  type;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	const char *val = NULL;

	type = snd_config_get_type(cfg);

	/* refer to a single data section */

	if (type == SND_CONFIG_TYPE_STRING) {

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

			return -EINVAL;

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

		return tplg_ref_add(elem, SND_TPLG_TYPE_DATA, val);

	}

	if (type != SND_CONFIG_TYPE_COMPOUND) {

		SNDERR("error: compound type expected for %s", elem->id);

		return -EINVAL;

	}

	/* refer to a list of data sections */

	snd_config_for_each(i, next, cfg) {

		const char *val;

		n = snd_config_iterator_entry(i);

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

			continue;

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

		tplg_ref_add(elem, SND_TPLG_TYPE_DATA, val);

	}

	return 0;

}

/* Parse vendor tokens

 */

int tplg_parse_tokens(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, *value;

	struct tplg_elem *elem;

	struct tplg_vendor_tokens *tokens;

	int num_tokens = 0;

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

	if (!elem)

		return -ENOMEM;

	snd_config_for_each(i, next, cfg) {

		num_tokens++;

	}

	if (!num_tokens)

		return 0;

	tplg_dbg(" Vendor tokens: %s, %d tokens\n", elem->id, num_tokens);

	tokens = calloc(1, sizeof(*tokens)

			+ num_tokens * sizeof(struct tplg_token));

	if (!tokens)

		return -ENOMEM;

	elem->tokens = tokens;

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

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

			continue;

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

			continue;

		snd_strlcpy(tokens->token[tokens->num_tokens].id, id,

				SNDRV_CTL_ELEM_ID_NAME_MAXLEN);

		tokens->token[tokens->num_tokens].value = atoi(value);

		tplg_dbg("\t\t %s : %d\n", tokens->token[tokens->num_tokens].id,

			tokens->token[tokens->num_tokens].value);

		tokens->num_tokens++;

	}

	return 0;

}

/* Parse vendor tuples.

 */

int tplg_parse_tuples(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, *value;

	struct tplg_elem *elem;

	struct tplg_vendor_tuples *tuples;

	int err;

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

	if (!elem)

		return -ENOMEM;

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

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

	if (!tuples)

		return -ENOMEM;

	elem->tuples = tuples;

	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, "tokens") == 0) {

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

				return -EINVAL;

			tplg_ref_add(elem, SND_TPLG_TYPE_TOKEN, value);

			tplg_dbg("\t refer to vendor tokens: %s\n", value);