/*

 *  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 configuration file

 */

static void configuration_filename2(char *fn, size_t fn_len, int format,

				    const char *dir, const char *file,

				    const char *suffix)

{

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

		 snd_config_topdir(), format >= 2 ? "2" : "",

		 dir, file, suffix);

}

static void configuration_filename(snd_use_case_mgr_t *uc_mgr,

				   char *fn, size_t fn_len,

				   const char *dir, const char *file,

				   const char *suffix)

{

	const char *env;

	if (uc_mgr->conf_format > 0) {

		/* known format */

		env = getenv(uc_mgr->conf_format >= 2 ? ALSA_CONFIG_UCM2_VAR :

							ALSA_CONFIG_UCM_VAR);

	} else {

		/* auto-detect */

		env = getenv(ALSA_CONFIG_UCM2_VAR);

		if (env == NULL) {

			env = getenv(ALSA_CONFIG_UCM_VAR);

		} else {

			uc_mgr->conf_format = 2;

		}

	}

	if (env) {

		snprintf(fn, fn_len, "%s/%s/%s%s", env, dir, file, suffix);

		return;

	}

	if (uc_mgr->conf_format > 0) {

		configuration_filename2(fn, fn_len, uc_mgr->conf_format,

					dir, file, suffix);

		return;

	}

	configuration_filename2(fn, fn_len, 2, dir, file, suffix);

	if (access(fn, R_OK) == 0) {

		/* Found an ucm2 file, only look in the ucm2 dir from now on */

		uc_mgr->conf_format = 2;

		return;

	}

	configuration_filename2(fn, fn_len, 0, dir, file, suffix);

	if (access(fn, R_OK) == 0) {

		/* Found an ucm1 file, only look in the ucm dir from now on */

		uc_mgr->conf_format = 1;

		return;

	}

	/* make sure that the error message refers to the new path */

	configuration_filename2(fn, fn_len, 2, dir, file, suffix);

}

/*

 * 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 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 parse_get_safe_id(snd_config_t *n, const char **id)

{

	int err;

	err = snd_config_get_id(n, id);

	if (err < 0)

		return err;

	if (!parse_is_name_safe((char *)(*id)))

		return -EINVAL;

	return 0;

}

/*

 * 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 0;

	if (err < 0)

		return err;

	err = uc_mgr_evaluate_condition(uc_mgr, cfg, n);

	snd_config_delete(n);

	return err;

}

/*

 * 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);

		tseq->name = strdup(id);

		if (tseq->name == NULL) {

			free(tseq);

			return -ENOMEM;

		}

		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(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)

{

	const char *val;

	int err;

	err = snd_config_get_string(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);

		return -EINVAL;

	}

	/* 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(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(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(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(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 = snd_config_get_integer(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 = snd_config_get_integer(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(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 condition evaluation */

	err = evaluate_condition(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;

			}

			break;

		case SND_CONFIG_TYPE_STRING:

			err = parse_string(n, &s);

			if (err < 0) {

				uc_error("error: unable to parse a string for id '%s'!", id);

				return err;

			}

			break;

		default:

			uc_error("error: invalid type %i in Value compound '%s'", type, id);

			return -EINVAL;

		}

		err = uc_mgr_add_value(base, id, s);

		if (err < 0) {

			free(s);

			return err;

		}

	}

	return 0;

}

/*

 * Parse Modifier Use cases

 *

 *	# Each modifier is described in new section. N modifiers are allowed

 *	SectionModifier."Capture Voice" {

 *

 *		Comment "Record voice call"

 *

 *		SupportedDevice [

 *			"x"

 *			"y"

 *		]

 *

 *		ConflictingDevice [

 *			"x"

 *			"y"

 *		]

 *

 *		EnableSequence [

 *			....

 *		]

 *

 *		DisableSequence [

 *			...

 *		]

 *

 *              TransitionSequence."ToModifierName" [

 *			...

 *		]

 *

 *		# Optional TQ and ALSA PCMs

 *		Value {

 *			TQ Voice

 *			CapturePCM "hw:1"

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

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

 *		}

 *

 *	 }

 *

 * SupportedDevice and ConflictingDevice cannot be specified together.

 * Both are optional.

 */

static int parse_modifier(snd_use_case_mgr_t *uc_mgr,

		snd_config_t *cfg,

		void *data1,

		void *data2)

{

	struct use_case_verb *verb = data1;

	struct use_case_modifier *modifier;

	const char *name;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	int err;

	if (data2) {

		name = data2;

		if (!parse_is_name_safe(name))

			return -EINVAL;

	}

	else {

		if (parse_get_safe_id(cfg, &name) < 0)

			return -EINVAL;

	}

	/* allocate modifier */

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

	if (modifier == NULL)

		return -ENOMEM;

	INIT_LIST_HEAD(&modifier->enable_list);

	INIT_LIST_HEAD(&modifier->disable_list);

	INIT_LIST_HEAD(&modifier->transition_list);

	INIT_LIST_HEAD(&modifier->dev_list.list);

	INIT_LIST_HEAD(&modifier->value_list);

	list_add_tail(&modifier->list, &verb->modifier_list);

	modifier->name = strdup(name);

	/* in-place condition evaluation */

	err = evaluate_condition(uc_mgr, cfg);

	if (err < 0)

		return err;

	snd_config_for_each(i, next, cfg) {

		const char *id;

		n = snd_config_iterator_entry(i);

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

			continue;

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

			err = parse_string(n, &modifier->comment);

			if (err < 0) {

				uc_error("error: failed to get modifier comment");

				return err;

			}

			continue;

		}

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

			err = parse_device_list(uc_mgr, &modifier->dev_list,

						DEVLIST_SUPPORTED, n);

			if (err < 0) {

				uc_error("error: failed to parse supported"

					" device list");

				return err;

			}

		}

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

			err = parse_device_list(uc_mgr, &modifier->dev_list,

						DEVLIST_CONFLICTING, n);

			if (err < 0) {

				uc_error("error: failed to parse conflicting"

					" device list");

				return err;

			}

		}

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

			err = parse_sequence(uc_mgr, &modifier->enable_list, n);

			if (err < 0) {

				uc_error("error: failed to parse modifier"

					" enable sequence");

				return err;

			}

			continue;

		}

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

			err = parse_sequence(uc_mgr, &modifier->disable_list, n);

			if (err < 0) {

				uc_error("error: failed to parse modifier"

					" disable sequence");

				return err;

			}

			continue;

		}

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

			err = parse_transition(uc_mgr, &modifier->transition_list, n);

			if (err < 0) {

				uc_error("error: failed to parse transition"

					" modifier");

				return err;

			}

			continue;

		}

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

			err = parse_value(uc_mgr, &modifier->value_list, n);

			if (err < 0) {

				uc_error("error: failed to parse Value");

				return err;

			}

			continue;

		}

	}

	return 0;

}

/*

 * Parse Device Use Cases

 *

 *# Each device is described in new section. N devices are allowed

 *SectionDevice."Headphones" {

 *	Comment "Headphones connected to 3.5mm jack"

 *

 *	upportedDevice [

 *		"x"

 *		"y"

 *	]

 *

 *	ConflictingDevice [

 *		"x"

 *		"y"

 *	]

 *

 *	EnableSequence [

 *		....

 *	]

 *

 *	DisableSequence [

 *		...

 *	]

 *

 *      TransitionSequence."ToDevice" [

 *		...

 *	]

 *

 *	Value {

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

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

 *	}

 * }

 */

static int parse_device(snd_use_case_mgr_t *uc_mgr,

			snd_config_t *cfg,

			void *data1,

			void *data2)

{

	struct use_case_verb *verb = data1;

	const char *name;

	struct use_case_device *device;

	snd_config_iterator_t i, next;

	snd_config_t *n;

	int err;

	if (data2) {

		name = data2;

		if (!parse_is_name_safe(name))

			return -EINVAL;

	}

	else {

		if (parse_get_safe_id(cfg, &name) < 0)

			return -EINVAL;

	}