/*

 *  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 of the License, or (at your option) any later version.

 *

 *  This library 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.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software  

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 *  Support for the verb/device/modifier core logic and API,

 *  command line tool and file parser was kindly sponsored by

 *  Texas Instruments Inc.

 *  Support for multiple active modifiers and devices,

 *  transition sequences, multiple client access and user defined use

 *  cases was kindly sponsored by Wolfson Microelectronics PLC.

 *

 *  Copyright (C) 2008-2010 SlimLogic Ltd

 *  Copyright (C) 2010 Wolfson Microelectronics PLC

 *  Copyright (C) 2010 Texas Instruments Inc.

 *  Copyright (C) 2010 Red Hat Inc.

 *  Authors: Liam Girdwood <lrg@slimlogic.co.uk>

 *	         Stefan Schmidt <stefan@slimlogic.co.uk>

 *	         Justin Xu <justinx@slimlogic.co.uk>

 *               Jaroslav Kysela <perex@perex.cz>

 */

#include "ucm_local.h"

#include <dirent.h>

#include <limits.h>

/* Directories to store UCM configuration files for components, like

 * off-soc codecs or embedded DSPs. Components can define their own

 * devices and sequences, to be reused by sound cards/machines. UCM

 * manager should not scan these component directories.

 * Machine use case files can include component configratuation files

 * via alsaconf syntax:

 * <searchdir:component-directory-name> and <component-conf-file-name>.

 * Alsaconf will import the included files automatically. After including

 * a component file, a machine device's sequence can enable or disable

 * a component device via syntax:

 * enadev "component_device_name"

 * disdev "component_device_name"

 */

static const char * const component_dir[] = {

	"codecs",	/* for off-soc codecs */

	"dsps",		/* for DSPs embedded in SoC */

	"platforms",	/* for common platform implementations */

	NULL,		/* terminator */

};

static int filename_filter(const struct dirent *dirent);

static int is_component_directory(const char *dir);

static int parse_sequence(snd_use_case_mgr_t *uc_mgr,

			  struct list_head *base,

			  snd_config_t *cfg);

/*

 * compose the absolute ucm filename

 */

static void ucm_filename(char *fn, size_t fn_len, long version,

			  const char *dir, const char *file)

{

	const char *env = getenv(version > 1 ? ALSA_CONFIG_UCM2_VAR : ALSA_CONFIG_UCM_VAR);

	if (env == NULL)

		snprintf(fn, fn_len, "%s/%s/%s%s%s",

			 snd_config_topdir(), version > 1 ? "ucm2" : "ucm",

			 dir ?: "", dir ? "/" : "", file);

	else

		snprintf(fn, fn_len, "%s/%s%s%s",

			 env, dir ?: "", dir ? "/" : "", file);

}

/*

 *

 */

int uc_mgr_config_load_file(snd_use_case_mgr_t *uc_mgr,

			     const char *file, snd_config_t **cfg)

{

	char filename[PATH_MAX];

	int err;

	ucm_filename(filename, sizeof(filename), uc_mgr->conf_format,

		     file[0] == '/' ? NULL : uc_mgr->conf_dir_name,

		     file);

	err = uc_mgr_config_load(uc_mgr->conf_format, filename, cfg);

	if (err < 0) {

		uc_error("error: failed to open file %s : %d", filename, -errno);

		return err;

	}

	return 0;

}

/*

 * Replace mallocated string

 */

static char *replace_string(char **dst, const char *value)

{

	free(*dst);

	*dst = value ? strdup(value) : NULL;

	return *dst;

}

/*

 * Parse string

 */

int parse_string(snd_config_t *n, char **res)

{

	int err;

	err = snd_config_get_string(n, (const char **)res);

	if (err < 0)

		return err;

	*res = strdup(*res);

	if (*res == NULL)

		return -ENOMEM;

	return 0;

}

/*

 * Parse string and substitute

 */

int parse_string_substitute(snd_use_case_mgr_t *uc_mgr,

			    snd_config_t *n, char **res)

{

	const char *str;

	char *s;

	int err;

	err = snd_config_get_string(n, &str);

	if (err < 0)

		return err;

	err = uc_mgr_get_substituted_value(uc_mgr, &s, str);

	if (err >= 0)

		*res = s;

	return err;

}

/*

 * Parse string and substitute

 */

int parse_string_substitute3(snd_use_case_mgr_t *uc_mgr,

			     snd_config_t *n, char **res)

{

	if (uc_mgr->conf_format < 3)

		return parse_string(n, res);

	return parse_string_substitute(uc_mgr, n, res);

}

/*

 * Parse integer with substitution

 */

int parse_integer_substitute(snd_use_case_mgr_t *uc_mgr,

			     snd_config_t *n, long *res)

{

	char *s1, *s2;

	int err;

	err = snd_config_get_ascii(n, &s1;;

	if (err < 0)

		return err;

	err = uc_mgr_get_substituted_value(uc_mgr, &s2, s1);

	if (err >= 0)

		err = safe_strtol(s2, res);

	free(s2);

	free(s1);

	return err;

}

/*

 * Parse integer with substitution

 */

int parse_integer_substitute3(snd_use_case_mgr_t *uc_mgr,

			      snd_config_t *n, long *res)

{

	char *s1, *s2;

	int err;

	err = snd_config_get_ascii(n, &s1;;

	if (err < 0)

		return err;

	if (uc_mgr->conf_format < 3)

		s2 = s1;

	else

		err = uc_mgr_get_substituted_value(uc_mgr, &s2, s1);

	if (err >= 0)

		err = safe_strtol(s2, res);

	if (s1 != s2)

		free(s2);

	free(s1);

	return err;

}

/*

 * Parse safe ID

 */

int parse_is_name_safe(const char *name)

{

	if (strchr(name, '.')) {

		uc_error("char '.' not allowed in '%s'", name);

		return 0;

	}

	return 1;

}

int get_string3(snd_use_case_mgr_t *uc_mgr, const char *s1, char **s)

{

	if (uc_mgr->conf_format < 3) {

		*s = strdup(s1);

		if (*s == NULL)

			return -ENOMEM;

		return 0;

	}

	return uc_mgr_get_substituted_value(uc_mgr, s, s1);

}

int parse_get_safe_name(snd_use_case_mgr_t *uc_mgr, snd_config_t *n,

			const char *alt, char **name)

{

	const char *id;

	int err;

	if (alt) {

		id = alt;

	} else {

		err = snd_config_get_id(n, &id;;

		if (err < 0)

			return err;

	}

	err = get_string3(uc_mgr, id, name);

	if (err < 0)

		return err;

	if (!parse_is_name_safe(*name)) {

		free(*name);

		return -EINVAL;

	}

	return 0;

}

/*

 * Handle 'Error' configuration node.

 */

static int error_node(snd_use_case_mgr_t *uc_mgr, snd_config_t *cfg)

{

	int err;

	char *s;

	err = parse_string_substitute3(uc_mgr, cfg, &s);

	if (err < 0) {

		uc_error("error: failed to get Error string");

		return err;

	}

	uc_error("%s", s);

	free(s);

	return -ENXIO;

}

/*

 * Evaluate variable regex definitions (in-place delete)

 */

static int evaluate_regex(snd_use_case_mgr_t *uc_mgr,

			  snd_config_t *cfg)

{

	snd_config_iterator_t i, next;

	snd_config_t *d, *n;

	const char *id;

	int err;

	err = snd_config_search(cfg, "DefineRegex", &d);

	if (err == -ENOENT)

		return 1;

	if (err < 0)

		return err;

	if (snd_config_get_type(d) != SND_CONFIG_TYPE_COMPOUND) {

		uc_error("compound type expected for DefineRegex");

		return -EINVAL;

	}

	if (uc_mgr->conf_format < 3) {

		uc_error("DefineRegex is supported in v3+ syntax");

		return -EINVAL;

	}

	snd_config_for_each(i, next, d) {

		n = snd_config_iterator_entry(i);

		err = snd_config_get_id(n, &id;;

		if (err < 0)

			return err;

		err = uc_mgr_define_regex(uc_mgr, id, n);

		if (err < 0)

			return err;

	}

	snd_config_delete(d);

	return 0;

}

/*

 * Evaluate variable definitions (in-place delete)

 */

static int evaluate_define(snd_use_case_mgr_t *uc_mgr,

			   snd_config_t *cfg)

{

	snd_config_iterator_t i, next;

	snd_config_t *d, *n;

	const char *id;

	char *var, *s;

	int err;

	err = snd_config_search(cfg, "Define", &d);

	if (err == -ENOENT)

		return evaluate_regex(uc_mgr, cfg);

	if (err < 0)

		return err;

	if (snd_config_get_type(d) != SND_CONFIG_TYPE_COMPOUND) {

		uc_error("compound type expected for Define");

		return -EINVAL;

	}

	if (uc_mgr->conf_format < 3) {

		uc_error("Define is supported in v3+ syntax");

		return -EINVAL;

	}

	snd_config_for_each(i, next, d) {

		n = snd_config_iterator_entry(i);

		err = snd_config_get_id(n, &id;;

		if (err < 0)

			return err;

		err = snd_config_get_ascii(n, &var);

		if (err < 0)

			return err;

		err = uc_mgr_get_substituted_value(uc_mgr, &s, var);

		free(var);

		if (err < 0)

			return err;

		uc_mgr_set_variable(uc_mgr, id, s);

		free(s);

	}

	snd_config_delete(d);

	return evaluate_regex(uc_mgr, cfg);

}

/*

 * Evaluate include (in-place)

 */

static int evaluate_include(snd_use_case_mgr_t *uc_mgr,

			    snd_config_t *cfg)

{

	snd_config_t *n;

	int err;

	err = snd_config_search(cfg, "Include", &n);

	if (err == -ENOENT)

		return 1;

	if (err < 0)

		return err;

	err = uc_mgr_evaluate_include(uc_mgr, cfg, n);

	snd_config_delete(n);

	return err;

}

/*

 * Evaluate condition (in-place)

 */

static int evaluate_condition(snd_use_case_mgr_t *uc_mgr,

			      snd_config_t *cfg)

{

	snd_config_t *n;

	int err;

	err = snd_config_search(cfg, "If", &n);

	if (err == -ENOENT)

		return 1;

	if (err < 0)

		return err;

	err = uc_mgr_evaluate_condition(uc_mgr, cfg, n);

	snd_config_delete(n);

	return err;

}

/*

 * In-place evaluate

 */

int uc_mgr_evaluate_inplace(snd_use_case_mgr_t *uc_mgr,

			    snd_config_t *cfg)

{

	int err1 = 0, err2 = 0, err3 = 0;

	while (err1 == 0 || err2 == 0 || err3 == 0) {

		/* variables at first */

		err1 = evaluate_define(uc_mgr, cfg);

		if (err1 < 0)

			return err1;

		/* include at second */

		err2 = evaluate_include(uc_mgr, cfg);

		if (err2 < 0)

			return err2;

		/* include may define another variables */

		/* conditions may depend on them */

		if (err2 == 0)

			continue;

		err3 = evaluate_condition(uc_mgr, cfg);

		if (err3 < 0)

			return err3;

	}

	return 0;

}

/*

 * Parse transition

 */

static int parse_transition(snd_use_case_mgr_t *uc_mgr,

			    struct list_head *tlist,

			    snd_config_t *cfg)

{

	struct transition_sequence *tseq;

	const char *id;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	int err;

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

		return -EINVAL;

	if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {

		uc_error("compound type expected for %s", id);

		return -EINVAL;

	}

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

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

			return -EINVAL;

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

		if (tseq == NULL)

			return -ENOMEM;

		INIT_LIST_HEAD(&tseq->transition_list);

		err = get_string3(uc_mgr, id, &tseq->name);

		if (err < 0) {

			free(tseq);

			return err;

		}

		err = parse_sequence(uc_mgr, &tseq->transition_list, n);

		if (err < 0) {

			uc_mgr_free_transition_element(tseq);

			return err;

		}

		list_add(&tseq->list, tlist);

	}

	return 0;

}

/*

 * Parse compound

 */

static int parse_compound(snd_use_case_mgr_t *uc_mgr, snd_config_t *cfg,

	  int (*fcn)(snd_use_case_mgr_t *, snd_config_t *, void *, void *),

	  void *data1, void *data2)

{

	const char *id;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	int err;

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

		return -EINVAL;

	if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {

		uc_error("compound type expected for %s", id);

		return -EINVAL;

	}

	/* parse compound */

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

		if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {

			uc_error("compound type expected for %s, is %d", id, snd_config_get_type(cfg));

			return -EINVAL;

		}

		err = fcn(uc_mgr, n, data1, data2);

		if (err < 0)

			return err;

	}

	return 0;

}

static int strip_legacy_dev_index(char *name)

{

	char *dot = strchr(name, '.');

	if (!dot)

		return 0;

	if (dot[1] != '0' || dot[2] != '\0') {

		uc_error("device name %s contains a '.',"

			 " and is not legacy foo.0 format", name);

		return -EINVAL;

	}

	*dot = '\0';

	return 0;

}

/*

 * Parse device list

 */

static int parse_device_list(snd_use_case_mgr_t *uc_mgr ATTRIBUTE_UNUSED,

			     struct dev_list *dev_list,

			     enum dev_list_type type,

			     snd_config_t *cfg)

{

	struct dev_list_node *sdev;

	const char *id;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	int err;

	if (dev_list->type != DEVLIST_NONE) {

		uc_error("error: multiple supported or"

			" conflicting device lists");

		return -EEXIST;

	}

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

		return -EINVAL;

	if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {

		uc_error("compound type expected for %s", id);

		return -EINVAL;

	}

	snd_config_for_each(i, next, cfg) {

		n = snd_config_iterator_entry(i);

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

			return -EINVAL;

		sdev = calloc(1, sizeof(struct dev_list_node));

		if (sdev == NULL)

			return -ENOMEM;

		err = parse_string_substitute3(uc_mgr, n, &sdev->name);

		if (err < 0) {

			free(sdev);

			return err;

		}

		err = strip_legacy_dev_index(sdev->name);

		if (err < 0) {

			free(sdev->name);

			free(sdev);

			return err;

		}

		list_add(&sdev->list, &dev_list->list);

	}

	dev_list->type = type;

	return 0;

}

/* Find a component device by its name, and remove it from machine device

 * list.

 *

 * Component devices are defined by machine components (usually off-soc

 * codes or DSP embeded in SoC). Since alsaconf imports their configuration

 * files automatically, we don't know which devices are component devices

 * until they are referenced by a machine device sequence. So here when we

 * find a referenced device, we move it from the machine device list to the

 * component device list. Component devices will not be exposed to applications

 * by the original API to list devices for backward compatibility. So sound

 * servers can only see the machine devices.

 */

struct use_case_device *find_component_dev(snd_use_case_mgr_t *uc_mgr,

	const char *name)

{

	struct list_head *pos, *posdev, *_posdev;

	struct use_case_verb *verb;

	struct use_case_device *dev;

	list_for_each(pos, &uc_mgr->verb_list) {

		verb = list_entry(pos, struct use_case_verb, list);

		/* search in the component device list */

		list_for_each(posdev, &verb->cmpt_device_list) {

			dev = list_entry(posdev, struct use_case_device, list);

			if (!strcmp(dev->name, name))

				return dev;

		}

		/* search the machine device list */

		list_for_each_safe(posdev, _posdev, &verb->device_list) {

			dev = list_entry(posdev, struct use_case_device, list);

			if (!strcmp(dev->name, name)) {

				/* find the component device, move it from the

				 * machine device list to the component device

				 * list.

				 */

				list_del(&dev->list);

				list_add_tail(&dev->list,

					      &verb->cmpt_device_list);

				return dev;

			}

		}

	}

	return NULL;

}

/* parse sequence of a component device

 *

 * This function will find the component device and mark if its enable or

 * disable sequence is needed by its parenet device.

 */

static int parse_component_seq(snd_use_case_mgr_t *uc_mgr,

			       snd_config_t *n, int enable,

			       struct component_sequence *cmpt_seq)

{

	char *val;

	int err;

	err = parse_string_substitute3(uc_mgr, n, &val;;

	if (err < 0)

		return err;

	cmpt_seq->device = find_component_dev(uc_mgr, val);

	if (!cmpt_seq->device) {

		uc_error("error: Cannot find component device %s", val);

		free(val);

		return -EINVAL;

	}

	free(val);

	/* Parent needs its enable or disable sequence */

	cmpt_seq->enable = enable;

	return 0;

}

/*

 * Parse sequences.

 *

 * Sequence controls elements  are in the following form:-

 *

 * cdev "hw:0"

 * cset "element_id_syntax value_syntax"

 * usleep time

 * exec "any unix command with arguments"

 * enadev "component device name"

 * disdev "component device name"

 *

 * e.g.

 *	cset "name='Master Playback Switch' 0,0"

 *      cset "iface=PCM,name='Disable HDMI',index=1 0"

 *	enadev "rt286:Headphones"

 *	disdev "rt286:Speaker"

 */

static int parse_sequence(snd_use_case_mgr_t *uc_mgr,

			  struct list_head *base,

			  snd_config_t *cfg)

{

	struct sequence_element *curr;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	int err, idx = 0;

	const char *cmd = NULL;

	if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {

		uc_error("error: compound is expected for sequence definition");

		return -EINVAL;

	}

	snd_config_for_each(i, next, cfg) {

		const char *id;

		idx ^= 1;

		n = snd_config_iterator_entry(i);

		err = snd_config_get_id(n, &id;;

		if (err < 0)

			continue;

		if (idx == 1) {

			if (snd_config_get_type(n) != SND_CONFIG_TYPE_STRING) {

				uc_error("error: string type is expected for sequence command");

				return -EINVAL;

			}

			snd_config_get_string(n, &cmd);

			continue;

		}

		/* alloc new sequence element */

		curr = calloc(1, sizeof(struct sequence_element));

		if (curr == NULL)

			return -ENOMEM;

		list_add_tail(&curr->list, base);

		if (strcmp(cmd, "cdev") == 0) {

			curr->type = SEQUENCE_ELEMENT_TYPE_CDEV;

			err = parse_string_substitute3(uc_mgr, n, &curr->data.cdev);

			if (err < 0) {

				uc_error("error: cdev requires a string!");

				return err;

			}

			continue;

		}

		if (strcmp(cmd, "cset") == 0) {

			curr->type = SEQUENCE_ELEMENT_TYPE_CSET;

			err = parse_string_substitute3(uc_mgr, n, &curr->data.cset);

			if (err < 0) {

				uc_error("error: cset requires a string!");

				return err;

			}

			continue;

		}

		if (strcmp(cmd, "enadev") == 0) {

			/* need to enable a component device */

			curr->type = SEQUENCE_ELEMENT_TYPE_CMPT_SEQ;

			err = parse_component_seq(uc_mgr, n, 1,

						&curr->data.cmpt_seq);

			if (err < 0) {

				uc_error("error: enadev requires a valid device!");

				return err;

			}

			continue;

		}

		if (strcmp(cmd, "disdev") == 0) {

			/* need to disable a component device */

			curr->type = SEQUENCE_ELEMENT_TYPE_CMPT_SEQ;

			err = parse_component_seq(uc_mgr, n, 0,

						&curr->data.cmpt_seq);

			if (err < 0) {

				uc_error("error: disdev requires a valid device!");

				return err;

			}

			continue;

		}

		if (strcmp(cmd, "cset-bin-file") == 0) {

			curr->type = SEQUENCE_ELEMENT_TYPE_CSET_BIN_FILE;

			err = parse_string_substitute3(uc_mgr, n, &curr->data.cset);

			if (err < 0) {

				uc_error("error: cset-bin-file requires a string!");

				return err;

			}

			continue;

		}

		if (strcmp(cmd, "cset-tlv") == 0) {

			curr->type = SEQUENCE_ELEMENT_TYPE_CSET_TLV;

			err = parse_string_substitute3(uc_mgr, n, &curr->data.cset);

			if (err < 0) {

				uc_error("error: cset-tlv requires a string!");

				return err;

			}

			continue;

		}

		if (strcmp(cmd, "usleep") == 0) {

			curr->type = SEQUENCE_ELEMENT_TYPE_SLEEP;

			err = parse_integer_substitute3(uc_mgr, n, &curr->data.sleep);

			if (err < 0) {

				uc_error("error: usleep requires integer!");

				return err;

			}

			continue;

		}

		if (strcmp(cmd, "msleep") == 0) {

			curr->type = SEQUENCE_ELEMENT_TYPE_SLEEP;

			err = parse_integer_substitute3(uc_mgr, n, &curr->data.sleep);

			if (err < 0) {

				uc_error("error: msleep requires integer!");

				return err;

			}

			curr->data.sleep *= 1000L;

			continue;

		}

		if (strcmp(cmd, "exec") == 0) {

			curr->type = SEQUENCE_ELEMENT_TYPE_EXEC;

			err = parse_string_substitute3(uc_mgr, n, &curr->data.exec);

			if (err < 0) {

				uc_error("error: exec requires a string!");

				return err;

			}

			continue;

		}

		list_del(&curr->list);

		uc_mgr_free_sequence_element(curr);

	}

	return 0;

}

/*

 *

 */

int uc_mgr_add_value(struct list_head *base, const char *key, char *val)

{

	struct ucm_value *curr;

	curr = calloc(1, sizeof(struct ucm_value));

	if (curr == NULL)

		return -ENOMEM;

	curr->name = strdup(key);

	if (curr->name == NULL) {

		free(curr);

		return -ENOMEM;

	}

	list_add_tail(&curr->list, base);

	curr->data = val;

	return 0;

}

/*

 * Parse values.

 *

 * Parse values describing PCM, control/mixer settings and stream parameters.

 *

 * Value {

 *   TQ Voice

 *   CapturePCM "hw:1"

 *   PlaybackVolume "name='Master Playback Volume',index=2"

 *   PlaybackSwitch "name='Master Playback Switch',index=2"

 * }

 */

static int parse_value(snd_use_case_mgr_t *uc_mgr ATTRIBUTE_UNUSED,

			  struct list_head *base,

			  snd_config_t *cfg)

{

	snd_config_iterator_t i, next;

	snd_config_t *n;

	char *s;

	snd_config_type_t type;

	int err;

	if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {

		uc_error("error: compound is expected for value definition");

		return -EINVAL;

	}

	/* in-place evaluation */

	err = uc_mgr_evaluate_inplace(uc_mgr, cfg);

	if (err < 0)

		return err;

	snd_config_for_each(i, next, cfg) {

		const char *id;

		n = snd_config_iterator_entry(i);

		err = snd_config_get_id(n, &id;;

		if (err < 0)

			continue;

		type = snd_config_get_type(n);

		switch (type) {

		case SND_CONFIG_TYPE_INTEGER:

		case SND_CONFIG_TYPE_INTEGER64:

		case SND_CONFIG_TYPE_REAL:

			err = snd_config_get_ascii(n, &s);

			if (err < 0) {

				uc_error("error: unable to parse value for id '%s': %s!", id, snd_strerror(err));

				return err;