/*

 *  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 <ctype.h>

#include <stdarg.h>

#include <pthread.h>

#include <sys/stat.h>

#include <limits.h>

/*

 * misc

 */

static int get_value(snd_use_case_mgr_t *uc_mgr,

			const char *identifier,

			char **value,

			const char *mod_dev_name,

			const char *verb_name,

			int exact);

static int get_value1(snd_use_case_mgr_t *uc_mgr, char **value,

                      struct list_head *value_list, const char *identifier);

static int get_value3(snd_use_case_mgr_t *uc_mgr,

                      char **value,

		      const char *identifier,

		      struct list_head *value_list1,

		      struct list_head *value_list2,

		      struct list_head *value_list3);

static int execute_component_seq(snd_use_case_mgr_t *uc_mgr,

				 struct component_sequence *cmpt_seq,

				 struct list_head *value_list1,

				 struct list_head *value_list2,

				 struct list_head *value_list3,

				 char *cdev);

static int check_identifier(const char *identifier, const char *prefix)

{

	int len;

	len = strlen(prefix);

	if (strncmp(identifier, prefix, len) != 0)

		return 0;

	if (identifier[len] == 0 || identifier[len] == '/')

		return 1;

	return 0;

}

static int list_count(struct list_head *list)

{

        struct list_head *pos;

        int count = 0;

        list_for_each(pos, list) {

                count += 1;

        }

        return count;

}

static int alloc_str_list(struct list_head *list, int mult, char **result[])

{

        char **res;

        int cnt;

        cnt = list_count(list) * mult;

        if (cnt == 0) {

		*result = NULL;

                return cnt;

	}

        res = calloc(mult, cnt * sizeof(char *));

        if (res == NULL)

                return -ENOMEM;

        *result = res;

        return cnt;

}

/**

 * \brief Create an identifier

 * \param fmt Format (sprintf like)

 * \param ... Optional arguments for sprintf like format

 * \return Allocated string identifier or NULL on error

 */

char *snd_use_case_identifier(const char *fmt, ...)

{

	char *str, *res;

	int size = strlen(fmt) + 512;

	va_list args;

	str = malloc(size);

	if (str == NULL)

		return NULL;

	va_start(args, fmt);

	vsnprintf(str, size, fmt, args);

	va_end(args);

	str[size-1] = '\0';

	res = realloc(str, strlen(str) + 1);

	if (res)

		return res;

	return str;

}

/**

 * \brief Free a string list

 * \param list The string list to free

 * \param items Count of strings

 * \return Zero if success, otherwise a negative error code

 */

int snd_use_case_free_list(const char *list[], int items)

{

        int i;

	if (list == NULL)

		return 0;

        for (i = 0; i < items; i++)

		free((void *)list[i]);

        free(list);

	return 0;

}

static int read_tlv_file(unsigned int **res,

			 const char *filepath)

{

	int err = 0;

	int fd;

	struct stat st;

	size_t sz;

	ssize_t sz_read;

	struct snd_ctl_tlv *tlv;

	fd = open(filepath, O_RDONLY);

	if (fd < 0) {

		err = -errno;

		return err;

	}

	if (fstat(fd, &st) == -1) {

		err = -errno;

		goto __fail;

	}

	sz = st.st_size;

	if (sz > 16 * 1024 * 1024 || sz < 8 || sz % 4) {

		uc_error("File size should be less than 16 MB "

			 "and multiple of 4");

		err = -EINVAL;

		goto __fail;

	}

	*res = malloc(sz);

	if (res == NULL) {

		err = -ENOMEM;

		goto __fail;

	}

	sz_read = read(fd, *res, sz);

	if (sz_read < 0 || (size_t)sz_read != sz) {

		err = -EIO;

		free(*res);

		*res = NULL;

	}

	/* Check if the tlv file specifies valid size. */

	tlv = (struct snd_ctl_tlv *)(*res);

	if (tlv->length + 2 * sizeof(unsigned int) != sz) {

		uc_error("Invalid tlv size: %d", tlv->length);

		err = -EINVAL;

		free(*res);

		*res = NULL;

	}

__fail:

	close(fd);

	return err;

}

static int binary_file_parse(snd_ctl_elem_value_t *dst,

			      snd_ctl_elem_info_t *info,

			      const char *filepath)

{

	int err = 0;

	int fd;

	struct stat st;

	size_t sz;

	ssize_t sz_read;

	char *res;

	snd_ctl_elem_type_t type;

	unsigned int idx, count;

	type = snd_ctl_elem_info_get_type(info);

	if (type != SND_CTL_ELEM_TYPE_BYTES) {

		uc_error("only support byte type!");

		err = -EINVAL;

		return err;

	}

	fd = open(filepath, O_RDONLY);

	if (fd < 0) {

		err = -errno;

		return err;

	}

	if (stat(filepath, &st) == -1) {

		err = -errno;

		goto __fail;

	}

	sz = st.st_size;

	count = snd_ctl_elem_info_get_count(info);

	if (sz != count || sz > sizeof(dst->value.bytes)) {

		uc_error("invalid parameter size %d!", sz);

		err = -EINVAL;

		goto __fail;

	}

	res = malloc(sz);

	if (res == NULL) {

		err = -ENOMEM;

		goto __fail;

	}

	sz_read = read(fd, res, sz);

	if (sz_read < 0 || (size_t)sz_read != sz) {

		err = -errno;

		goto __fail_read;

	}

	for (idx = 0; idx < sz; idx++)

		snd_ctl_elem_value_set_byte(dst, idx, *(res + idx));

      __fail_read:

	free(res);

      __fail:

	close(fd);

	return err;

}

extern int __snd_ctl_ascii_elem_id_parse(snd_ctl_elem_id_t *dst,

					 const char *str,

					 const char **ret_ptr);

static int execute_cset(snd_ctl_t *ctl, const char *cset, unsigned int type)

{

	const char *pos;

	int err;

	snd_ctl_elem_id_t *id;

	snd_ctl_elem_value_t *value;

	snd_ctl_elem_info_t *info;

	unsigned int *res = NULL;

	snd_ctl_elem_id_malloc(&id;;

	snd_ctl_elem_value_malloc(&value);

	snd_ctl_elem_info_malloc(&info;;

	err = __snd_ctl_ascii_elem_id_parse(id, cset, &pos;;

	if (err < 0)

		goto __fail;

	while (*pos && isspace(*pos))

		pos++;

	if (!*pos) {

		uc_error("undefined value for cset >%s<", cset);

		err = -EINVAL;

		goto __fail;

	}

	snd_ctl_elem_info_set_id(info, id);

	err = snd_ctl_elem_info(ctl, info);

	if (err < 0)

		goto __fail;

	if (type == SEQUENCE_ELEMENT_TYPE_CSET_TLV) {

		if (!snd_ctl_elem_info_is_tlv_writable(info)) {

			err = -EINVAL;

			goto __fail;

		}

		err = read_tlv_file(&res, pos);

		if (err < 0)

			goto __fail;

		err = snd_ctl_elem_tlv_write(ctl, id, res);

		if (err < 0)

			goto __fail;

	} else {

		snd_ctl_elem_value_set_id(value, id);

		err = snd_ctl_elem_read(ctl, value);

		if (err < 0)

			goto __fail;

		if (type == SEQUENCE_ELEMENT_TYPE_CSET_BIN_FILE)

			err = binary_file_parse(value, info, pos);

		else

			err = snd_ctl_ascii_value_parse(ctl, value, info, pos);

		if (err < 0)

			goto __fail;

		err = snd_ctl_elem_write(ctl, value);

		if (err < 0)

			goto __fail;

	}

	err = 0;

      __fail:

	if (id != NULL)

		free(id);

	if (value != NULL)

		free(value);

	if (info != NULL)

		free(info);

	if (res != NULL)

		free(res);

	return err;

}

/**

 * \brief Execute the sequence

 * \param uc_mgr Use case manager

 * \param seq Sequence

 * \return zero on success, otherwise a negative error code

 */

static int execute_sequence(snd_use_case_mgr_t *uc_mgr,

			    struct list_head *seq,

			    struct list_head *value_list1,

			    struct list_head *value_list2,

			    struct list_head *value_list3)

{

	struct list_head *pos;

	struct sequence_element *s;

	char *cdev = NULL;

	snd_ctl_t *ctl = NULL;

	struct ctl_list *ctl_list;

	int err = 0;

	list_for_each(pos, seq) {

		s = list_entry(pos, struct sequence_element, list);

		switch (s->type) {

		case SEQUENCE_ELEMENT_TYPE_CDEV:

			cdev = strdup(s->data.cdev);

			if (cdev == NULL)

				goto __fail_nomem;

			break;

		case SEQUENCE_ELEMENT_TYPE_CSET:

		case SEQUENCE_ELEMENT_TYPE_CSET_BIN_FILE:

		case SEQUENCE_ELEMENT_TYPE_CSET_TLV:

			if (cdev == NULL && uc_mgr->in_component_domain) {

				/* For sequence of a component device, use

				 * its parent's cdev stored by ucm manager.

				 */

				if (uc_mgr->cdev == NULL) {

					uc_error("cdev is not defined!");

					return err;

				}

				cdev = strndup(uc_mgr->cdev, PATH_MAX);

				if (!cdev)

					return -ENOMEM;

			} else if (cdev == NULL) {

				char *playback_ctl = NULL;

				char *capture_ctl = NULL;

				err = get_value3(uc_mgr, &playback_ctl, "PlaybackCTL",

						 value_list1,

						 value_list2,

						 value_list3);

				if (err < 0 && err != -ENOENT) {

					uc_error("cdev is not defined!");

					return err;

				}

				err = get_value3(uc_mgr, &capture_ctl, "CaptureCTL",

						 value_list1,

						 value_list2,

						 value_list3);

				if (err < 0 && err != -ENOENT) {

					free(playback_ctl);

					uc_error("cdev is not defined!");

					return err;

				}

				if (playback_ctl == NULL &&

				    capture_ctl == NULL) {

					uc_error("cdev is not defined!");

					return -EINVAL;

				}

				if (playback_ctl != NULL &&

				    capture_ctl != NULL &&

				    strcmp(playback_ctl, capture_ctl) != 0) {

					free(playback_ctl);

					free(capture_ctl);

					uc_error("cdev is not equal for playback and capture!");

					return -EINVAL;

				}

				if (playback_ctl != NULL) {

					cdev = playback_ctl;

					free(capture_ctl);

				} else {

					cdev = capture_ctl;

				}

			}

			if (ctl == NULL) {

				err = uc_mgr_open_ctl(uc_mgr, &ctl_list, cdev, 1);

				if (err < 0) {

					uc_error("unable to open ctl device '%s'", cdev);

					goto __fail;

				}

				ctl = ctl_list->ctl;

			}

			err = execute_cset(ctl, s->data.cset, s->type);

			if (err < 0) {

				uc_error("unable to execute cset '%s'", s->data.cset);

				goto __fail;

			}

			break;

		case SEQUENCE_ELEMENT_TYPE_SLEEP:

			usleep(s->data.sleep);

			break;

		case SEQUENCE_ELEMENT_TYPE_EXEC:

			err = system(s->data.exec);

			if (err < 0)

				goto __fail;

			break;

		case SEQUENCE_ELEMENT_TYPE_CMPT_SEQ:

			/* Execute enable or disable sequence of a component

			 * device. Pass the cdev defined by the machine device.

			 */

			err = execute_component_seq(uc_mgr,

						    &s->data.cmpt_seq,

						    value_list1,

						    value_list2,

						    value_list3,

						    cdev);

			if (err < 0)

				goto __fail;

			break;

		default:

			uc_error("unknown sequence command %i", s->type);

			break;

		}

	}

	free(cdev);

	return 0;

      __fail_nomem:

	err = -ENOMEM;

      __fail:

	free(cdev);

	return err;

}

/* Execute enable or disable sequence of a component device.

 *

 * For a component device (a codec or embedded DSP), its sequence doesn't

 * specify the sound card device 'cdev', because a component can be reused

 * by different sound cards (machines). So when executing its sequence, a

 * parameter 'cdev' is used to pass cdev defined by the sequence of its

 * parent, the machine device. UCM manger will store the cdev when entering

 * the component domain.

 */

static int execute_component_seq(snd_use_case_mgr_t *uc_mgr,

				 struct component_sequence *cmpt_seq,

				 struct list_head *value_list1 ATTRIBUTE_UNUSED,

				 struct list_head *value_list2 ATTRIBUTE_UNUSED,

				 struct list_head *value_list3 ATTRIBUTE_UNUSED,

				 char *cdev)

{

	struct use_case_device *device = cmpt_seq->device;

	struct list_head *seq;

	int err;

	/* enter component domain and store cdev for the component */

	uc_mgr->in_component_domain = 1;

	uc_mgr->cdev = cdev;

	/* choose enable or disable sequence of the component device */

	if (cmpt_seq->enable)

		seq = &device->enable_list;

	else

		seq = &device->disable_list;

	/* excecute the sequence of the component dev */

	err = execute_sequence(uc_mgr, seq,

			       &device->value_list,

			       &uc_mgr->active_verb->value_list,

			       &uc_mgr->value_list);

	/* exit component domain and clear cdev */

	uc_mgr->in_component_domain = 0;

	uc_mgr->cdev = NULL;

	return err;

}

static int add_auto_value(snd_use_case_mgr_t *uc_mgr, const char *key, char *value)

{

	char *s;

	int err;

	err = get_value1(uc_mgr, &value, &uc_mgr->value_list, key);

	if (err == -ENOENT) {

		s = strdup(value);

		if (s == NULL)

			return -ENOMEM;

		return uc_mgr_add_value(&uc_mgr->value_list, key, s);

	} else if (err < 0) {

		return err;

	}

	free(value);

	return 0;

}

static int add_auto_values(snd_use_case_mgr_t *uc_mgr)

{

	struct ctl_list *ctl_list;

	const char *id;

	char buf[40];

	int err;

	ctl_list = uc_mgr_get_master_ctl(uc_mgr);

	if (ctl_list) {

		id = snd_ctl_card_info_get_id(ctl_list->ctl_info);

		snprintf(buf, sizeof(buf), "hw:%s", id);

		err = add_auto_value(uc_mgr, "PlaybackCTL", buf);

		if (err < 0)

			return err;

		err = add_auto_value(uc_mgr, "CaptureCTL", buf);

		if (err < 0)

			return err;

	}

	return 0;

}

/**

 * \brief execute default commands

 * \param uc_mgr Use case manager

 * \return zero on success, otherwise a negative error code

 */

static int set_defaults(snd_use_case_mgr_t *uc_mgr)

{

	int err;

	if (uc_mgr->default_list_executed)

		return 0;

	err = execute_sequence(uc_mgr, &uc_mgr->default_list,

			       &uc_mgr->value_list, NULL, NULL);

	if (err < 0) {

		uc_error("Unable to execute default sequence");

		return err;

	}

	uc_mgr->default_list_executed = 1;

	return 0;

}

/**

 * \brief Import master config and execute the default sequence

 * \param uc_mgr Use case manager

 * \return zero on success, otherwise a negative error code

 */

static int import_master_config(snd_use_case_mgr_t *uc_mgr)

{

	int err;

	err = uc_mgr_import_master_config(uc_mgr);

	if (err < 0)

		return err;

	return add_auto_values(uc_mgr);

}

/**

 * \brief Check, if the UCM configuration is empty

 * \param uc_mgr Use case Manager

 * \return zero on success, otherwise a negative error code

 */

static int check_empty_configuration(snd_use_case_mgr_t *uc_mgr)

{

	int err;

	char *value;

	err = get_value(uc_mgr, "Linked", &value, NULL, NULL, 1);

	if (err >= 0) {

		err = strcasecmp(value, "true") == 0 ||

		      strcmp(value, "1") == 0;

		free(value);

		if (err)

			return 0;

	}

	if (!list_empty(&uc_mgr->verb_list))

		return 0;

	if (!list_empty(&uc_mgr->boot_list))

		return 0;

	return -ENXIO;

}

/**

 * \brief Universal find - string in a list

 * \param list List of structures

 * \param offset Offset of list structure

 * \param soffset Offset of string structure

 * \param match String to match

 * \return structure on success, otherwise a NULL (not found)

 */

static void *find0(struct list_head *list,

		   unsigned long offset,

		   unsigned long soffset,

		   const char *match)

{

	struct list_head *pos;

	char *ptr, *str;

	list_for_each(pos, list) {

		ptr = list_entry_offset(pos, char, offset);

		str = *((char **)(ptr + soffset));

		if (strcmp(str, match) == 0)

			return ptr;

	}

	return NULL;

}

#define find(list, type, member, value, match) \

	find0(list, (unsigned long)(&((type *)0)->member), \

		    (unsigned long)(&((type *)0)->value), match)

/**

 * \brief Universal string list

 * \param list List of structures

 * \param result Result list

 * \param offset Offset of list structure

 * \param s1offset Offset of string structure

 * \return count of items on success, otherwise a negative error code

 */

static int get_list0(struct list_head *list,

                     const char **result[],

                     unsigned long offset,

                     unsigned long s1offset)

{

        char **res;

        int cnt;

	struct list_head *pos;

	char *ptr, *str1;

	cnt = alloc_str_list(list, 1, &res;;

	if (cnt <= 0) {

		*result = NULL;

	        return cnt;

	}

	*result = (const char **)res;

	list_for_each(pos, list) {

		ptr = list_entry_offset(pos, char, offset);

		str1 = *((char **)(ptr + s1offset));

		if (str1 != NULL) {

		        *res = strdup(str1);

		        if (*res == NULL)

		                goto __fail;

                } else {

                        *res = NULL;

                }

                res++;

	}

	return cnt;

      __fail:

        snd_use_case_free_list((const char **)res, cnt);

        return -ENOMEM;

}

#define get_list(list, result, type, member, s1) \

	get_list0(list, result, \

	            (unsigned long)(&((type *)0)->member), \

		    (unsigned long)(&((type *)0)->s1))

/**

 * \brief Universal string list - pair of strings

 * \param list List of structures

 * \param result Result list

 * \param offset Offset of list structure

 * \param s1offset Offset of string structure

 * \param s1offset Offset of string structure

 * \return count of items on success, otherwise a negative error code

 */

static int get_list20(struct list_head *list,

                      const char **result[],

                      unsigned long offset,

                      unsigned long s1offset,

                      unsigned long s2offset)

{

        char **res;

        int cnt;

	struct list_head *pos;

	char *ptr, *str1, *str2;

	cnt = alloc_str_list(list, 2, &res;;

	if (cnt <= 0) {

		*result = NULL;

	        return cnt;

	}

        *result = (const char **)res;

	list_for_each(pos, list) {

		ptr = list_entry_offset(pos, char, offset);

		str1 = *((char **)(ptr + s1offset));

		if (str1 != NULL) {

		        *res = strdup(str1);

		        if (*res == NULL)

		                goto __fail;

                } else {

                        *res = NULL;

                }

                res++;

		str2 = *((char **)(ptr + s2offset));

		if (str2 != NULL) {

		        *res = strdup(str2);

		        if (*res == NULL)

		                goto __fail;

                } else {

                        *res = NULL;

                }

                res++;

	}

	return cnt;

      __fail:

        snd_use_case_free_list((const char **)res, cnt);

        return -ENOMEM;

}

#define get_list2(list, result, type, member, s1, s2) \

	get_list20(list, result, \

	            (unsigned long)(&((type *)0)->member), \

		    (unsigned long)(&((type *)0)->s1), \

		    (unsigned long)(&((type *)0)->s2))

/**

 * \brief Find verb

 * \param uc_mgr Use case manager

 * \param verb_name verb to find

 * \return structure on success, otherwise a NULL (not found)

 */

static inline struct use_case_verb *find_verb(snd_use_case_mgr_t *uc_mgr,

					      const char *verb_name)

{

	return find(&uc_mgr->verb_list,

		    struct use_case_verb, list, name,

		    verb_name);

}

static int is_devlist_supported(snd_use_case_mgr_t *uc_mgr, 

	struct dev_list *dev_list)

{

	struct dev_list_node *device;

	struct use_case_device *adev;

	struct list_head *pos, *pos1;

	int found_ret;

	switch (dev_list->type) {

	case DEVLIST_NONE:

	default:

		return 1;

	case DEVLIST_SUPPORTED:

		found_ret = 1;

		break;

	case DEVLIST_CONFLICTING:

		found_ret = 0;

		break;

	}

	list_for_each(pos, &dev_list->list) {

		device = list_entry(pos, struct dev_list_node, list);

		list_for_each(pos1, &uc_mgr->active_devices) {

			adev = list_entry(pos1, struct use_case_device,

					    active_list);

			if (!strcmp(device->name, adev->name))

				return found_ret;

		}

	}

	return 1 - found_ret;

}

static inline int is_modifier_supported(snd_use_case_mgr_t *uc_mgr, 

	struct use_case_modifier *modifier)

{

	return is_devlist_supported(uc_mgr, &modifier->dev_list);

}

static inline int is_device_supported(snd_use_case_mgr_t *uc_mgr, 

	struct use_case_device *device)

{

	return is_devlist_supported(uc_mgr, &device->dev_list);

}

/**

 * \brief Find device

 * \param verb Use case verb

 * \param device_name device to find

 * \return structure on success, otherwise a NULL (not found)

 */

static inline struct use_case_device *

        find_device(snd_use_case_mgr_t *uc_mgr, struct use_case_verb *verb,

		    const char *device_name, int check_supported)

{

	struct use_case_device *device;

	struct list_head *pos;

	list_for_each(pos, &verb->device_list) {

		device = list_entry(pos, struct use_case_device, list);

		if (strcmp(device_name, device->name))

			continue;

		if (check_supported &&

		    !is_device_supported(uc_mgr, device))

			continue;

		return device;

	}

	return NULL;

}

/**

 * \brief Find modifier

 * \param verb Use case verb

 * \param modifier_name modifier to find

 * \return structure on success, otherwise a NULL (not found)

 */

static struct use_case_modifier *

        find_modifier(snd_use_case_mgr_t *uc_mgr, struct use_case_verb *verb,

		      const char *modifier_name, int check_supported)

{

	struct use_case_modifier *modifier;

	struct list_head *pos;

	list_for_each(pos, &verb->modifier_list) {

		modifier = list_entry(pos, struct use_case_modifier, list);

		if (strcmp(modifier->name, modifier_name))

			continue;

		if (check_supported &&

		    !is_modifier_supported(uc_mgr, modifier))

			continue;

		return modifier;

	}

	return NULL;

}

long device_status(snd_use_case_mgr_t *uc_mgr,

                   const char *device_name)

{

        struct use_case_device *dev;

        struct list_head *pos;

        list_for_each(pos, &uc_mgr->active_devices) {

                dev = list_entry(pos, struct use_case_device, active_list);

                if (strcmp(dev->name, device_name) == 0)

                        return 1;

        }

        return 0;

}

long modifier_status(snd_use_case_mgr_t *uc_mgr,

                     const char *modifier_name)

{

        struct use_case_modifier *mod;

        struct list_head *pos;

        list_for_each(pos, &uc_mgr->active_modifiers) {

                mod = list_entry(pos, struct use_case_modifier, active_list);

                if (strcmp(mod->name, modifier_name) == 0)

                        return 1;

        }

        return 0;

}

/**