diff options
| -rw-r--r-- | src/use-case.c | 3515 |
1 files changed, 3515 insertions, 0 deletions
diff --git a/src/use-case.c b/src/use-case.c new file mode 100644 index 00000000..b45fe1f1 --- /dev/null +++ b/src/use-case.c @@ -0,0 +1,3515 @@ +/* + * 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 General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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. + * Authors: Liam Girdwood <lrg@slimlogic.co.uk> + * Stefan Schmidt <stefan@slimlogic.co.uk> + * Justin Xu <justinx@slimlogic.co.uk> + */ + +#include <stdio.h> +#include <unistd.h> +#include <errno.h> +#include <string.h> +#include <fcntl.h> +#include <ctype.h> +#include <alsa/asoundlib.h> +#include <pthread.h> + +#include "../include/use-case.h" +#include "../include/iatomic.h" + +#define PRE_SEQ 0 +#define POST_SEQ 1 +#define MAX_VERB 32 +#define MAX_DEVICE 64 +#define MAX_MODIFIER 64 +#define MAX_NAME 64 +#define MAX_FILE 256 +#define MAX_BUF 256 +#define ALSA_USE_CASE_DIR "/usr/share/alsa/ucm" +#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) +#define VERB_NOT_INITIALISED -1 + +/* + * Stores all use case settings for 1 kcontrol. Hence we have a + * control_settings for each kcontrol in card. + */ +struct control_settings { + char name[MAX_NAME]; + unsigned int id; + snd_ctl_elem_type_t type; + short count; /* 1 = mono, 2 = stereo, etc */ + unsigned short *value; +}; + +/* + * If sleep is 0 the element contains the settings in control. Else sleep + * contains the sleep time in micro seconds. + */ +struct sequence_element { + unsigned int sleep; /* Sleep time in msecs if sleep element, else 0 */ + struct control_settings *control; + struct sequence_element *next; /* Pointer to next list element */ +}; + +/* + * Transition sequences. i.e. transition between one verb, device, mod to another + */ +struct transition_sequence { + char *name; + struct sequence_element *transition; + struct transition_sequence *next; +}; + +/* + * Modifier Supported Devicees. + */ +struct dev_list { + char *name; + struct dev_list *next; +}; + + +/* + * Describes a Use Case Modifier and it's enable and disable sequences. + * A use case verb can have N modifiers. + */ +struct use_case_modifier { + char *name; + char *comment; + + /* modifier enable and disable sequences */ + struct sequence_element *enable; + struct sequence_element *disable; + + /* modifier transition list */ + struct transition_sequence *transition_list; + + /* list of supported devices per modifier */ + struct dev_list *dev_list; + + /* ALSA PCM devices associated with any modifier PCM streams */ + int capture_pcm; + int playback_pcm; + + /* Any modifier stream QoS */ + enum snd_use_case_qos qos; + + /* aliased controls */ + char *playback_volume_id; + char *playback_switch_id; + char *capture_volume_id; + char *capture_switch_id; +}; + +/* + * Describes a Use Case Device and it's enable and disable sequences. + * A use case verb can have N devices. + */ +struct use_case_device { + char *name; + char *comment; + int idx; /* index for similar devices i.e. 2 headphone jacks */ + + /* device enable and disable sequences */ + struct sequence_element *enable; + struct sequence_element *disable; + + /* device transition list */ + struct transition_sequence *transition_list; + + /* aliased controls */ + char *playback_volume_id; + char *playback_switch_id; + char *capture_volume_id; + char *capture_switch_id; +}; + +/* + * Describes a Use Case Verb and it's enable and disable sequences. + * A use case verb can have N devices and N modifiers. + */ +struct use_case_verb { + char *name; + char *comment; + + /* verb enable and disable sequences */ + struct sequence_element *enable; + struct sequence_element *disable; + + /* verb transition list */ + struct transition_sequence *transition_list; + + /* verb PCMs and QoS */ + enum snd_use_case_qos qos; + int capture_pcm; + int playback_pcm; + + /* hardware devices that can be used with this use case */ + int num_devices; + struct use_case_device *device; + /* + * device_list[i] shares string with device[i].name, + * so device_list don't need not be freed + */ + const char *device_list[MAX_DEVICE]; + + /* modifiers that can be used with this use case */ + int num_modifiers; + struct use_case_modifier *modifier; + /* + * modifier_list[i] shares string with modifier[i].name, + * so modifier_list don't need not be freed + */ + const char *modifier_list[MAX_MODIFIER]; +}; + +struct ucm_card { + int current_verb; + int current_device[MAX_DEVICE]; + int current_modifier[MAX_MODIFIER]; +}; + +/* + * Manages a sound card and all its use cases. + */ +struct snd_use_case_mgr { + pthread_mutex_t mutex; + char *card_name; + char *ctl_name; + struct ucm_card card; + + /* use case verb, devices and modifier configs parsed from files */ + int num_verbs; /* number of supported use case verbs */ + struct use_case_verb *verb; /* var len array of use case info */ + /* + * verb_list[i] shares string with verb[i].name, + * so verb_list don't need not be freed + */ + const char *verb_list[MAX_VERB]; + + /* sound card ALSA kcontrol read from sound card device */ + struct control_settings *control; /* var len array of controls */ + + /* snd ctl */ + int count; + snd_ctl_t *handle; + snd_ctl_card_info_t *info; + snd_ctl_elem_list_t *list; + snd_ctl_elem_id_t *id; +}; + +static void uc_mgr_error(const char *fmt,...) +{ + va_list va; + va_start(va, fmt); + fprintf(stderr, "ucm: "); + vfprintf(stderr, fmt, va); + va_end(va); +} + +#define uc_error(fmt, arg...) do { \ + uc_mgr_error("%s() - " fmt "\n", __FUNCTION__ , ## arg); \ +} while (0) + +static void uc_mgr_stdout(const char *fmt,...) +{ + va_list va; + va_start(va, fmt); + vfprintf(stdout, fmt, va); + va_end(va); +} + +#undef UC_MGR_DEBUG + +#ifdef UC_MGR_DEBUG +#define uc_dbg(fmt, arg...) do { \ + uc_mgr_stdout("%s() - " fmt "\n", __FUNCTION__ , ## arg); \ +} while (0) +#else +#define uc_dbg(fmt, arg...) +#endif + +static int set_control(snd_ctl_t *handle, snd_ctl_elem_id_t *id, + snd_use_case_mgr_t *uc_mgr, unsigned short value[]); + +static inline void set_value(struct control_settings *control, + int count, unsigned short val) +{ + uc_dbg("value %d, count %d", val, count); + control->value[count] = val; +} + +static inline unsigned short get_value(struct control_settings *control, + int count) +{ + return control->value[count]; +} + +static inline void set_device_status(struct snd_use_case_mgr *uc_mgr, + int device_id, int status) +{ + struct use_case_verb *verb; + + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + uc_mgr->card.current_device[device_id] = status; +} + +static inline void set_modifier_status(struct snd_use_case_mgr *uc_mgr, + int modifier_id, int status) +{ + struct use_case_verb *verb; + + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + uc_mgr->card.current_modifier[modifier_id] = status; +} + +static inline int get_device_status(struct snd_use_case_mgr *uc_mgr, + int device_id) +{ + struct use_case_verb *verb; + + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + return uc_mgr->card.current_device[device_id]; +} + +static inline int get_modifier_status(struct snd_use_case_mgr *uc_mgr, + int modifier_id) +{ + struct use_case_verb *verb; + + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + return uc_mgr->card.current_modifier[modifier_id]; +} + +static int dump_control(snd_ctl_t *handle, snd_ctl_elem_id_t *id) +{ + int err, count, i; + snd_ctl_elem_info_t *info; + snd_ctl_elem_type_t type; + snd_ctl_elem_value_t *control; + + snd_ctl_elem_info_alloca(&info); + snd_ctl_elem_value_alloca(&control); + + snd_ctl_elem_info_set_id(info, id); + err = snd_ctl_elem_info(handle, info); + if (err < 0) { + uc_error("error: failed to get ctl info: %s\n", + snd_strerror(err)); + return err; + } + + snd_ctl_elem_value_set_id(control, id); + snd_ctl_elem_read(handle, control); + + type = snd_ctl_elem_info_get_type(info); + count = snd_ctl_elem_info_get_count(info); + if (count == 0) + return 0; + + uc_mgr_stdout("'%s':%d:", + snd_ctl_elem_id_get_name(id), count); + + switch (type) { + case SND_CTL_ELEM_TYPE_BOOLEAN: + for (i = 0; i < count - 1; i++) + uc_mgr_stdout("%d,", + snd_ctl_elem_value_get_boolean(control, i)); + uc_mgr_stdout("%d", + snd_ctl_elem_value_get_boolean(control, i)); + break; + case SND_CTL_ELEM_TYPE_INTEGER: + for (i = 0; i < count - 1; i++) + uc_mgr_stdout("%d,", + snd_ctl_elem_value_get_integer(control, i)); + uc_mgr_stdout("%d", + snd_ctl_elem_value_get_integer(control, i)); + break; + case SND_CTL_ELEM_TYPE_INTEGER64: + for (i = 0; i < count - 1; i++) + uc_mgr_stdout("%ld,", + snd_ctl_elem_value_get_integer64(control, i)); + uc_mgr_stdout("%ld", + snd_ctl_elem_value_get_integer64(control, i)); + break; + case SND_CTL_ELEM_TYPE_ENUMERATED: + for (i = 0; i < count - 1; i++) + uc_mgr_stdout("%d,", + snd_ctl_elem_value_get_enumerated(control, i)); + uc_mgr_stdout("%d", + snd_ctl_elem_value_get_enumerated(control, i)); + break; + case SND_CTL_ELEM_TYPE_BYTES: + for (i = 0; i < count - 1; i++) + uc_mgr_stdout("%2.2x,", + snd_ctl_elem_value_get_byte(control, i)); + uc_mgr_stdout("%2.2x", + snd_ctl_elem_value_get_byte(control, i)); + break; + default: + break; + } + uc_mgr_stdout("\n"); + return 0; +} + +/* + * Add new kcontrol from sound card into memory database. + */ +static int add_control(snd_ctl_t *handle, snd_ctl_elem_id_t *id, + struct control_settings *control_settings) +{ + int err; + snd_ctl_elem_info_t *info; + snd_ctl_elem_value_t *control; + + snd_ctl_elem_info_alloca(&info); + snd_ctl_elem_value_alloca(&control); + + snd_ctl_elem_info_set_id(info, id); + err = snd_ctl_elem_info(handle, info); + if (err < 0) { + uc_error("error: failed to get ctl info: %s\n", + snd_strerror(err)); + return err; + } + + snd_ctl_elem_value_set_id(control, id); + snd_ctl_elem_read(handle, control); + + strncpy(control_settings->name, snd_ctl_elem_id_get_name(id), + MAX_NAME); + + control_settings->name[MAX_NAME - 1] = 0; + control_settings->count = snd_ctl_elem_info_get_count(info); + control_settings->type = snd_ctl_elem_info_get_type(info); + control_settings->id = snd_ctl_elem_id_get_numid(id); + uc_dbg("control name %s", control_settings->name); + uc_dbg("control count %d", control_settings->count); + uc_dbg("control type %d", control_settings->type); + uc_dbg("control id %d", control_settings->id); + return 0; +} + +static int set_control_default(snd_use_case_mgr_t *uc_mgr, + struct control_settings *control) +{ + snd_ctl_elem_id_t *id; + int i, ret = -ENODEV; + unsigned int numid; + + snd_ctl_elem_id_alloca(&id); + + /* Where is id lookup from numid if you need it? */ + for (i = 0; i < uc_mgr->count; ++i) { + snd_ctl_elem_list_get_id(uc_mgr->list, i, id); + numid = snd_ctl_elem_id_get_numid(id); + if (numid == control->id) { + ret = set_control(uc_mgr->handle, id, uc_mgr, + control->value); + goto out; + } + } + uc_error("error: could not find control ID %s : %d", + control->name, control->id); +out: + return ret; +} + +static int get_control_id(snd_use_case_mgr_t *uc_mgr, + struct control_settings *control) +{ + int i = 0; + struct control_settings *card_control; + + uc_dbg("name %s count %d", + control->name, control->count); + + for (i = 0; i < uc_mgr->count; i++) { + card_control = &uc_mgr->control[i]; + if (!strcmp(card_control->name, control->name)) { + control->id = uc_mgr->control[i].id; + uc_dbg("Get id %d", control->id); + return 0; + } + } + + uc_error("error: control name %s is not available", control->name); + + return -EINVAL; +} + +static char *get_control_name(char *buf, int line, char *file) +{ + char name[MAX_NAME]; + char *name_start, *name_end, *tbuf = buf; + + /* get name start */ + while (*tbuf != 0 && *tbuf != '\'') + tbuf++; + if (*tbuf == 0) + return NULL; + name_start = ++tbuf; + + /* get name end */ + while (*tbuf != 0 && *tbuf != '\'') + tbuf++; + if (*tbuf == 0) + return NULL; + name_end = tbuf++; + + /* copy name */ + if ((name_end - name_start) > MAX_NAME) { + uc_error("error: %s:%d name too big at %d chars", + file, line, name_end - name_start); + return NULL; + } + strncpy(name, name_start, name_end - name_start); + name[name_end - name_start] = 0; + return strdup(name); +} + +/* + * Parse a single control from file. + * + * Controls are in the following form:- + * + * 'name':channels:value0,value1,...,valueN + * + * e.g. + * 'Master Playback Switch':2:0,0 + */ +static int parse_control(snd_use_case_mgr_t *uc_mgr, + struct control_settings *control, char *buf, + int line, char *file) +{ + char name[MAX_NAME]; + int count, i; + char *name_start, *name_end, *tbuf; + + uc_dbg("%s", buf); + + tbuf = buf; + + /* get name start */ + while (*tbuf != 0 && *tbuf != '\'') + tbuf++; + if (*tbuf == 0) + return -EINVAL; + name_start = ++tbuf; + + /* get name end */ + while (*tbuf != 0 && *tbuf != '\'') + tbuf++; + if (*tbuf == 0) + return -EINVAL; + name_end = tbuf++; + + /* copy name */ + if ((name_end - name_start) > MAX_NAME) { + uc_error("error: %s:%d name too big at %d chars", + file, line, name_end - name_start); + return -EINVAL; + } + strncpy(name, name_start, name_end - name_start); + name[name_end - name_start] = 0; + strncpy(control->name, name, name_end - name_start +1); + + /* get count */ + uc_dbg("%s", tbuf); + tbuf++; + count = atoi(tbuf); + if (count == 0) { + uc_error("error: %s:%d count == 0 on line %d", file, line); + return -EINVAL; + } + control->count = count; + + /* get vals */ + control->value = calloc(count, sizeof(unsigned short)); + if (control->value == NULL) + return -ENOMEM; + + while (*tbuf != 0 && *tbuf != ':') + tbuf++; + if (*tbuf == 0) + return -EINVAL; + tbuf++; + + for (i = 0; i < count; i++) { + set_value(control, i, atoi(tbuf)); + while (*tbuf != 0 && *tbuf != ',') + tbuf++; + + if (*tbuf++ == 0 && i < (count - 1)) + return -EINVAL; + } + + return get_control_id(uc_mgr, control); +} + +static int parse_controls(snd_use_case_mgr_t *uc_mgr, FILE *f, int *line_, + char *file) +{ + struct control_settings *control = NULL; + char buf[MAX_BUF], name[MAX_NAME]; + int count, i, ret = 0, line = *line_; + char *name_start, *name_end, *tbuf; + + while (fgets(buf, MAX_BUF, f) != NULL) { + + uc_dbg("%s: get line %d\n%s", file, line, buf); + + tbuf = buf; + while (isblank(*tbuf)) + tbuf++; + line ++; + + /* end of section ?*/ + if (strncmp(tbuf, "EndSectionDefaults", 18) == 0) + return 0; + + /* get name start */ + while (*tbuf != 0 && *tbuf != '\'') + tbuf++; + if (*tbuf == 0) + return -EINVAL; + name_start = ++tbuf; + + /* get name end */ + while (*tbuf != 0 && *tbuf != '\'') + tbuf++; + if (*tbuf == 0) + return -EINVAL; + name_end = tbuf++; + + /* copy name */ + if ((name_end - name_start) > MAX_NAME) { + uc_error("error: %s:%d name too big at %d chars", + file, line, name_end - name_start); + return -EINVAL; + } + strncpy(name, name_start, name_end - name_start); + name[name_end - name_start] = 0; + + for (i = 0; i < uc_mgr->count; i++) { + struct control_settings *card_control = + &uc_mgr->control[i]; + if (!strcmp(card_control->name, name)) + control = &uc_mgr->control[i]; + } + + uc_dbg("control id %d", control->id); + + /* get count */ + tbuf++; + count = atoi(tbuf); + if (count == 0) { + uc_error("error: %s:%d count == 0", file, line); + return -EINVAL; + } + if (count != control->count) { + uc_error("error: %s:%d count %d does not match card count" + " %d", file, line, count, control->count); + return -EINVAL; + } + + /* get vals */ + control->value = malloc(control->count *uc_mgr->num_verbs * + sizeof(unsigned short)); + if (control->value == NULL) + return -ENOMEM; + + while (*tbuf != 0 && *tbuf != ':') + tbuf++; + if (*tbuf == 0) + return -EINVAL; + tbuf++; + + for (i = 0; i < count; i++) { + set_value(control, i, atoi(tbuf)); + while (*tbuf != 0 && *tbuf != ',') + tbuf++; + + if (*tbuf++ == 0 && i < (count - 1)) + return -EINVAL; + } + } + + *line_ = line; + return ret; +} + +static char *get_string (char *buf) +{ + char *str, *end; + + uc_dbg("%s", buf); + + while (isblank(*buf)) + buf++; + + /* find leading '"' */ + if (*buf == 0 || *buf != '"') { + uc_error("error: missing start '\"'"); + return NULL; + } + str = ++buf; + + /* get value */ + while (*buf != 0 && *buf != '"') + buf++; + end = buf; + + /* find '"' terminator */ + if (*buf == 0 || *buf != '"') { + uc_error("error: missing terminator '\"' %s", buf); + return NULL; + } + + *end = 0; + return strdup(str); +} + +static enum snd_use_case_qos get_enum (char *buf) +{ + while (isblank(*buf)) + buf++; + + if (!strncmp(buf, "Music", 5)) + return SND_USE_CASE_QOS_MUSIC; + if (!strncmp(buf, "Voice", 5)) + return SND_USE_CASE_QOS_VOICE; + if (!strncmp(buf, "Tones", 5)) + return SND_USE_CASE_QOS_TONES; + + return SND_USE_CASE_QOS_MUSIC; +} + +static void seq_list_append(struct sequence_element **base, + struct sequence_element *curr) +{ + struct sequence_element *last, *tmp; + + if (!*base) + *base = curr; + else { + tmp = *base; + while (tmp) { + last = tmp; + tmp = tmp->next; + } + last->next = curr; + curr->next = NULL; + } +} +/* + * Parse sequences. + * + * Sequence controls elements are in the following form:- + * + * 'name':value0,value1,...,valueN + * + * e.g. + * 'Master Playback Switch':0,0 + */ +static int parse_sequence(snd_use_case_mgr_t *uc_mgr, + struct sequence_element **base, FILE *f, + int *line_, char *file) +{ + char buf[MAX_BUF], *tbuf; + int ret, line = *line_; + struct sequence_element *curr; + + /* read line by line */ + while (fgets(buf, MAX_BUF, f) != NULL) { + + uc_dbg("%s", buf); + line++; + + /* Check for lines with comments and ignore */ + if (buf[0] == '#') + continue; + + /* Parse current line and skip blanks */ + tbuf = buf; + while (isblank(*tbuf)) + tbuf++; + + /* end of sequence ? */ + if (strncmp(tbuf, "EndSequence", 11) == 0) + goto out; + + if (strncmp(tbuf, "EndTransition", 13) == 0) + goto out; + + /* alloc new sequence element */ + curr = calloc(1, sizeof(struct sequence_element)); + if (curr == NULL) + return -ENOMEM; + + /* is element a sleep ? */ + if (strncmp(tbuf, "msleep", 6) == 0) { + curr->sleep = atoi(tbuf + 6); + uc_dbg("msleep %d", curr->sleep); + seq_list_append(base, curr); + continue; + } + + /* alloc new sequence control */ + curr->control = calloc(1, sizeof(struct control_settings)); + if (curr->control == NULL) + return -ENOMEM; + + ret = parse_control(uc_mgr, curr->control, tbuf, line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to get parse sequence" + " controls", file, line); + goto err; + } + + uc_dbg("name %s, id %d, count %d", curr->control->name, + curr->control->id, curr->control->count); + seq_list_append(base, curr); + } + +out: + *line_ = line; + return 0; + +err: + free(curr); + return ret; +} + +static void prepend_transition( + struct transition_sequence **transition_list, + struct transition_sequence *trans_seq) +{ + if (*transition_list == NULL) + *transition_list = trans_seq; + else { + trans_seq->next = *transition_list; + *transition_list = trans_seq; + } + +} + +static void prepend_dev(struct dev_list **dev_list, + struct dev_list *sdev) +{ + if (*dev_list == NULL) + *dev_list = sdev; + else { + sdev->next = *dev_list; + *dev_list = sdev; + } + +} + +/* + * Parse Modifier Use cases + * + * # Each modifier is described in new section. N modifier are allowed + * SectionModifier + * + * Name "Capture Voice" + * Comment "Record voice call" + * SupportedDevice "x" + * SupportedDevice "y" + * + * EnableSequence + * .... + * EndSequence + * + * DisableSequence + * ... + * EndSequence + * + * # Optional QoS and ALSA PCMs + * QoS Voice + * CapturePCM 1 + * MasterPlaybackVolume 'Device Master Playback Volume' + * MasterPlaybackSwitch 'Device Master Playback Switch' + * + * EndSection + */ +static int parse_modifier(snd_use_case_mgr_t *uc_mgr, + struct use_case_verb *verb, FILE *f, int *line_, char *file) +{ + struct use_case_modifier *modifier; + int line = *line_, end = 0, en_seq = 0, dis_seq = 0; + int id = 0, dev = 0, ret; + char buf[MAX_BUF], *tbuf; + char *name = NULL, *comment = NULL; + + /* allocate modifier */ + verb->modifier = realloc(verb->modifier, + (verb->num_modifiers + 1) * sizeof(struct use_case_modifier)); + if (verb->modifier == NULL) + return -ENOMEM; + modifier = verb->modifier + verb->num_modifiers; + bzero(modifier, sizeof(struct use_case_modifier)); + + /* read line by line */ + while(fgets(buf, MAX_BUF, f) != NULL) { + + line++; + + /* skip comments */ + if (buf[0] == '#') + continue; + + tbuf = buf; + /* skip spaces */ + while (isblank(*tbuf)) + tbuf++; + + /* get use case modifier name */ + if (strncmp(tbuf, "Name", 4) == 0) { + name = get_string(tbuf + 4); + if (name == NULL) { + uc_error("error: %s:%d failed to get modifier name", + file, line); + goto err; + } + modifier->name = name; + id = 1; + continue; + } + + if (strncmp(tbuf, "Comment", 8) == 0) { + name = get_string(tbuf + 8); + if (name == NULL) { + uc_error("error: %s:%d failed to get modifier comment", + file, line); + goto err; + } + modifier->comment = comment; + continue; + } + + if (strncmp(tbuf, "SupportedDevice", 15) == 0) { + struct dev_list *sdev; + name = get_string(tbuf + 15); + if (name == NULL) { + uc_error("error: %s:%d failed to get modifier" + " supported device", file, line); + goto err; + } + + sdev = calloc(1, sizeof(struct dev_list)); + if (sdev == NULL) + goto err; + + dev = 1; + sdev->name = name; + prepend_dev(&modifier->dev_list, sdev); + continue; + } + + if (strncmp(tbuf, "EnableSequence", 14) == 0) { + ret = parse_sequence(uc_mgr, &modifier->enable, f, + &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse modifier" + " enable sequence", file, line); + goto err; + } + en_seq = 1; + continue; + } + + if (strncmp(tbuf, "DisableSequence", 15) == 0) { + ret = parse_sequence(uc_mgr, &modifier->disable, f, + &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse modifier" + " disable sequence", file, line); + goto err; + } + dis_seq = 1; + continue; + } + + if (strncmp(tbuf, "TransitionModifier", 16) == 0) { + struct transition_sequence *trans_seq; + + name = get_string(tbuf + 16); + if (name == NULL) + continue; + + trans_seq = calloc(1, sizeof(struct transition_sequence)); + if (trans_seq == NULL) + return -ENOMEM; + + trans_seq->name = name; + + ret = parse_sequence(uc_mgr, &trans_seq->transition, f, + &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse transition" + " modifier", file, line); + goto err; + } + + prepend_transition(&modifier->transition_list, trans_seq); + continue; + } + + if (strncmp(tbuf, "QoS", 3) == 0) { + modifier->qos = get_enum(tbuf + 3); + continue; + } + + if (strncmp(tbuf, "CapturePCM", 3) == 0) { + modifier->capture_pcm = atoi(tbuf + 3); + if (modifier->capture_pcm < 0) { + uc_error("error: %s:%d failed to get Capture PCM ID", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "PlaybackPCM", 3) == 0) { + modifier->playback_pcm = atoi(tbuf + 3); + if (modifier->playback_pcm < 0) { + uc_error("error: %s:%d failed to get Playback PCM ID", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "MasterPlaybackVolume", 20) == 0) { + modifier->playback_volume_id = + get_control_name(tbuf + 20, line, file); + if (modifier->playback_volume_id == NULL) { + uc_error("error: %s:%d failed to get MasterPlaybackVolume", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "MasterPlaybackSwitch", 20) == 0) { + modifier->playback_switch_id = + get_control_name(tbuf + 20, line, file); + if (modifier->playback_switch_id == NULL) { + uc_error("error: %s:%d failed to get MasterPlaybackSwitch", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "MasterCaptureVolume", 19) == 0) { + modifier->capture_volume_id = + get_control_name(tbuf + 19, line, file); + if (modifier->capture_volume_id == NULL) { + uc_error("error: %s:%d failed to get MasterCaptureVolume", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "MasterCaptureSwitch", 19) == 0) { + modifier->capture_switch_id = + get_control_name(tbuf + 19, line, file); + if (modifier->capture_switch_id == NULL) { + uc_error("error: %s:%d failed to get MasterCaptureSwitch", + file, line); + goto err; + } + continue; + } + + /* end of section ?*/ + if (strncmp(tbuf, "EndSection", 10) == 0) { + end = 1; + break; + } + } + + /* do we have the modifier basics ? */ + if (!en_seq || !dis_seq || !end || !dev) { + uc_error("error: invalid modifier"); + if (!en_seq) + uc_error("error: %s: modifier missing enable sequence", + file); + if (!dis_seq) + uc_error("error: %s: modifier missing disable sequence", + file); + if (!dev) + uc_error("error: %s: modifier missing supported device" + " sequence", file); + if (!end) + uc_error("error: %s: modifier missing end", file); + return -EINVAL; + } + + verb->modifier_list[verb->num_modifiers++] = modifier->name; + *line_ = line; + return 0; + +err: + if (ferror(f)) { + uc_error("error: %s: failed to read modifier master section", + file); + return ferror(f); + } + return -ENOMEM; +} + +/* + * Parse Device Use Cases + * + *# Each device is described in new section. N devices are allowed + *SectionDevice + * + * Name "Headphones" + * Comment "Headphones connected to 3.5mm jack" + * Index 0 + * + * EnableSequence + * .... + * EndSequence + * + * DisableSequence + * ... + * EndSequence + * + * #Optional control aliases + * MasterPlaybackVolume 'Device Master Playback Volume' + * MasterPlaybackSwitch 'Device Master Playback Switch' + * + * EndSection + */ +static int parse_device(snd_use_case_mgr_t *uc_mgr, + struct use_case_verb *verb, FILE *f, int *line_, char *file) +{ + struct use_case_device *device; + int line = *line_, end = 0, en_seq = 0, dis_seq = 0, id = 0, ret; + char buf[MAX_BUF], *tbuf; + char *name = NULL, *comment; + + /* allocate device */ + verb->device = realloc(verb->device, + (verb->num_devices + 1) * sizeof(struct use_case_device)); + if (verb->device == NULL) + return -ENOMEM; + device = verb->device + verb->num_devices; + bzero(device, sizeof(struct use_case_device)); + + /* read line by line */ + while(fgets(buf, MAX_BUF, f) != NULL) { + + line++; + + /* skip comments */ + if (buf[0] == '#') + continue; + + tbuf = buf; + /* skip spaces */ + while (isblank(*tbuf)) + tbuf++; + + /* get use case device name */ + if (strncmp(tbuf, "Name", 4) == 0) { + name = get_string(tbuf + 4); + if (name == NULL) { + uc_error("error: %s:%d failed to get device name", + file, line); + goto err; + } + device->name = name; + id = 1; + continue; + } + + if (strncmp(tbuf, "Comment", 8) == 0) { + comment = get_string(tbuf + 8); + if (name == NULL) { + uc_error("error: %s: %d failed to get device comment", + file, line); + goto err; + } + + device->comment = comment; + continue; + } + + if (strncmp(tbuf, "Index", 5) == 0) { + device->idx = atoi(tbuf + 5); + if (device->idx < 0) { + uc_error("error: %s:%d failed to get device index", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "EnableSequence", 14) == 0) { + ret = parse_sequence(uc_mgr, &device->enable, f, + &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse device enable" + " sequence", file, line); + goto err; + } + en_seq = 1; + continue; + } + + if (strncmp(tbuf, "DisableSequence", 15) == 0) { + uc_dbg("DisableSequence"); + ret = parse_sequence(uc_mgr, &device->disable, f, + &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse device disable sequence", + file, line); + goto err; + } + dis_seq = 1; + continue; + } + + if (strncmp(tbuf, "TransitionDevice", 14) == 0) { + struct transition_sequence *trans_seq; + + name = get_string(tbuf + 14); + if (name == NULL) + continue; + + uc_dbg("TransitionDevice %s", name); + + trans_seq = calloc(1, sizeof(struct transition_sequence)); + if (trans_seq == NULL) + return -ENOMEM; + + trans_seq->name = name; + + ret = parse_sequence(uc_mgr, &trans_seq->transition, f, + &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse transition" + " device", file, line); + goto err; + } + + prepend_transition(&device->transition_list, trans_seq); + continue; + } + + if (strncmp(tbuf, "MasterPlaybackVolume", 20) == 0) { + device->playback_volume_id = + get_control_name(tbuf + 20, line, file); + if (device->playback_volume_id == NULL) { + uc_error("error: %s:%d failed to get MasterPlaybackVolume", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "MasterPlaybackSwitch", 20) == 0) { + device->playback_switch_id = + get_control_name(tbuf + 20, line, file); + if (device->playback_switch_id == NULL) { + uc_error("error: %s:%d failed to get MasterPlaybackSwitch", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "MasterCaptureVolume", 19) == 0) { + device->capture_volume_id = + get_control_name(tbuf + 19, line, file); + if (device->capture_volume_id == NULL) { + uc_error("error: %s:%d failed to get MasterCaptureVolume%d", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "MasterCaptureSwitch", 19) == 0) { + device->capture_switch_id = + get_control_name(tbuf + 19, line, file); + if (device->capture_switch_id == NULL) { + uc_error("error: %s:%d failed to get MasterCaptureSwitch", + file, line); + goto err; + } + continue; + } + + /* end of section ?*/ + if (strncmp(tbuf, "EndSection", 10) == 0) { + end = 1; + break; + } + } + + /* do we have the basics for this device ? */ + if (!en_seq || !dis_seq || !end || !id) { + uc_error("error: invalid device"); + if (!en_seq) + uc_error("error: %s: device missing enable sequence", file); + if (!dis_seq) + uc_error("error: %s: device missing disable sequence", file); + if (!end) + uc_error("error: %s: device missing end", file); + return -EINVAL; + } + + verb->device_list[verb->num_devices++] = device->name; + *line_ = line; + return 0; + +err: + if (ferror(f)) { + uc_error("%s: failed to read device section", file); + return ferror(f); + } + return -ENOMEM; +} + +/* + * Parse Verb Section + * + * # Example Use case verb section for Voice call blah + * # By Joe Blogs <joe@blogs.com> + * + * SectionVerb + * # enable and disable sequences are compulsory + * EnableSequence + * 'Master Playback Switch':2:0,0 + * 'Master Playback Volume':2:25,25 + * msleep 50 + * 'Master Playback Switch':2:1,1 + * 'Master Playback Volume':2:50,50 + * EndSequence + * + * DisableSequence + * 'Master Playback Switch':2:0,0 + * 'Master Playback Volume':2:25,25 + * msleep 50 + * 'Master Playback Switch':2:1,1 + * 'Master Playback Volume':2:50,50 + * EndSequence + * + * # Optional QoS and ALSA PCMs + * QoS HiFi + * CapturePCM 0 + * PlaybackPCM 0 + * + * EndSection + */ +static int parse_verb(snd_use_case_mgr_t *uc_mgr, + struct use_case_verb *verb, FILE *f, int *line_, char *file) +{ + int line = *line_, end = 0, en_seq = 0, dis_seq = 0, ret; + char buf[MAX_BUF], *tbuf; + + /* read line by line */ + while(fgets(buf, MAX_BUF, f) != NULL) { + + line++; + + /* skip comments */ + if (buf[0] == '#') + continue; + + tbuf = buf; + /* skip spaces */ + while (isblank(*tbuf)) + tbuf++; + + if (strncmp(tbuf, "EnableSequence", 14) == 0) { + uc_dbg("Parse EnableSequence"); + ret = parse_sequence(uc_mgr, &verb->enable, f, &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse verb enable sequence", + file, line); + goto err; + } + en_seq = 1; + continue; + } + + if (strncmp(tbuf, "DisableSequence", 15) == 0) { + uc_dbg("Parse DisableSequence"); + ret = parse_sequence(uc_mgr, &verb->disable, f, &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse verb disable sequence", + file, line); + goto err; + } + dis_seq = 1; + continue; + } + + if (strncmp(tbuf, "TransitionVerb", 12) == 0) { + struct transition_sequence *trans_seq; + char *name; + + name = get_string(tbuf + 12); + if (name == NULL) + continue; + + uc_dbg("TransitionVerb %s", name); + + trans_seq = calloc(1, sizeof(struct transition_sequence)); + if (trans_seq == NULL) + return -ENOMEM; + + trans_seq->name = name; + + ret = parse_sequence(uc_mgr, &trans_seq->transition, f, + &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse transition verb", + file, line); + goto err; + } + + prepend_transition(&verb->transition_list, trans_seq); + continue; + } + + if (strncmp(tbuf, "QoS", 3) == 0) { + uc_dbg("Parse Qos"); + verb->qos = get_enum(tbuf + 3); + continue; + } + + if (strncmp(tbuf, "CapturePCM", 3) == 0) { + uc_dbg("Parse CapTurePCM"); + verb->capture_pcm = atoi(tbuf + 3); + if (verb->capture_pcm < 0) { + uc_error("error: %s:%d failed to get Capture PCM ID", + file, line); + goto err; + } + continue; + } + + if (strncmp(tbuf, "PlaybackPCM", 3) == 0) { + uc_dbg("Parse PlaybackPCM"); + verb->playback_pcm = atoi(tbuf + 3); + if (verb->playback_pcm < 0) { + uc_error("error: %s: %d failed to get Playback PCM ID", + file, line); + goto err; + } + continue; + } + + /* end of section ?*/ + if (strncmp(tbuf, "EndSection", 10) == 0) { + end = 1; + break; + } + } + + /* do we have both use case name and file ? */ + if (!en_seq || !dis_seq || !end) { + uc_error("error: invalid verb"); + if (!en_seq) + uc_error("error: %s: verb missing enable sequence", file); + if (!dis_seq) + uc_error("error: %s: verb missing disable sequence", file); + if (!end) + uc_error("error: %s: verb missing end", file); + return -EINVAL; + } + + *line_ = line; + return 0; + +err: + if (ferror(f)) { + uc_error("error: failed to read verb master section"); + return ferror(f); + } + return -ENOMEM; +} + +/* + * Parse a Use case verb file. + * + * This file contains the following :- + * o Verb enable and disable sequences. + * o Supported Device enable and disable sequences for verb. + * o Supported Modifier enable and disable sequences for verb + * o Optional QoS for the verb and modifiers. + * o Optional PCM device ID for verb and modifiers + * o Alias kcontrols IDs for master and volumes and mutes. + */ +static int parse_verb_file(snd_use_case_mgr_t *uc_mgr, + char *use_case_name, char *file) +{ + struct use_case_verb *verb; + FILE *f; + int line = 0, ret = 0, dev_idx = 0, verb_idx = 0, mod_idx = 0; + char buf[MAX_BUF], *tbuf; + char filename[MAX_FILE]; + + /* allocate verb */ + uc_mgr->verb = realloc(uc_mgr->verb, + (uc_mgr->num_verbs + 1) * sizeof(struct use_case_verb)); + if (uc_mgr->verb == NULL) + return -ENOMEM; + verb = uc_mgr->verb +uc_mgr->num_verbs; + bzero(verb, sizeof(struct use_case_verb)); + + /* open Verb file for reading */ + sprintf(filename, "%s/%s/%s", ALSA_USE_CASE_DIR, + uc_mgr->card_name, file); + + f = fopen(filename, "r"); + if (f == NULL) { + uc_error("error: failed to open verb file %s : %d", + filename, -errno); + return -errno; + } + + /* read line by line */ + while(fgets(buf, MAX_BUF, f) != NULL) { + + line++; + + /* skip comments */ + if (buf[0] == '#') + continue; + + /* skip leading spaces */ + tbuf = buf; + while (isblank(*tbuf)) + tbuf++; + + /* find verb section and parse it */ + if (strncmp(tbuf, "SectionVerb", 11) == 0) { + ret = parse_verb(uc_mgr, verb, f, &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse verb %s", + file, line, use_case_name); + goto err; + } + verb_idx++; + continue; + } + + /* find device sections and parse them */ + if (strncmp(tbuf, "SectionDevice", 13) == 0) { + + if (verb->num_devices >= MAX_DEVICE) { + uc_error("error: %s:%d verb number of devices %d" + "exceeds max %d", file, line, + verb->num_devices, MAX_DEVICE); + goto err; + } + ret = parse_device(uc_mgr, verb, f, &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse device", + file, line); + goto err; + } + dev_idx++; + continue; + } + + /* find modifier sections and parse them */ + if (strncmp(tbuf, "SectionModifier", 15) == 0) { + if (verb->num_modifiers >= MAX_MODIFIER) { + uc_error("error: %s:%d verb number of modifiers %d" + " exceeds max %d", file, line, + verb->num_modifiers, MAX_MODIFIER); + goto err; + } + + ret = parse_modifier(uc_mgr, verb, f, &line, file); + if (ret < 0) { + uc_error("error: %s:%d failed to parse modifier", + file, line); + goto err; + } + mod_idx++; + continue; + } + } + + /* use case verb must have at least verb and 1 device */ + if (verb_idx && dev_idx) { + uc_mgr->verb_list[uc_mgr->num_verbs++] = use_case_name; + verb->name = use_case_name; + } + else { + uc_error("error: failed to parse use case %s", file); + if (verb_idx == 0) + uc_error("error: no use case verb defined", file); + if (dev_idx == 0) + uc_error("error: no use case device defined", file); + ret = -EINVAL; + } + +err: + fclose(f); + return ret; +} + +/* + * Parse master section for "Use Case" and "File" tags. + */ +static int parse_master_section(snd_use_case_mgr_t *uc_mgr, FILE *f, + int *line_) +{ + int line = *line_ - 1, end = 0; + char buf[MAX_BUF], *tbuf; + char *file = NULL, *use_case_name = NULL, *comment; + + /* read line by line */ + while(fgets(buf, MAX_BUF, f) != NULL) { + + line++; + + /* skip comments */ + if (buf[0] == '#') + continue; + + uc_dbg("%s", buf); + + /* skip leading spaces */ + tbuf = buf; + while (isblank(*tbuf)) + tbuf++; + + /* get use case name */ + if (strncmp(tbuf, "Use Case", 8) == 0) { + use_case_name = get_string(tbuf + 8); + if (use_case_name == NULL) { + uc_error("error: failed to get Use Case at line %d", + line); + goto err; + } + + if (uc_mgr->num_verbs >= MAX_VERB) { + uc_error("error: verb number exceed max %d", + uc_mgr->num_verbs, MAX_VERB); + goto err; + } + continue; + } + + /* get use case verb file name */ + if (strncmp(tbuf, "File", 4) == 0) { + file = get_string(tbuf + 4); + if (file == NULL) { + uc_error("error: failed to get File at line %d", line); + goto err; + } + continue; + } + + /* get optional use case comment */ + if (strncmp(tbuf, "Comment", 7) == 0) { + comment = get_string(tbuf + 7); + if (comment == NULL) { + uc_error("error: failed to get Comment at line %d", + line); + goto err; + } + continue; + } + + /* end of section ?*/ + if (strncmp(tbuf, "EndSectionUseCase", 10) == 0) { + end = 1; + break; + } + } + + uc_dbg("use_case_name %s file %s end %d", use_case_name, file, end); + + /* do we have both use case name and file ? */ + if (!use_case_name || !file || !end) { + uc_error("error: failed to find use case\n"); + if (!use_case_name) + uc_error("error: use case missing name"); + if (!file) + uc_error("error: use case missing file"); + if (!end) + uc_error("error: use case missing end"); + return -EINVAL; + } + + *line_ = line; + + /* parse verb file */ + return parse_verb_file(uc_mgr, use_case_name, file); + +err: + if (ferror(f)) { + uc_error("error: failed to read use case master section"); + return ferror(f); + } + return -ENOMEM; +} + +/* + * Each sound card has a master sound card file that lists all the supported + * use case verbs for that sound card. i.e. + * + * #Example master file for blah sound card + * #By Joe Blogs <joe@bloggs.org> + * + * # The file is divided into Use case sections. One section per use case verb. + * + * SectionUseCase + * Use Case "Voice Call" + * File "voice_call_blah" + * Comment "Make a voice phone call." + * EndSectionUseCase + * + * SectionUseCase + * Use Case "HiFi" + * File "hifi_blah" + * Comment "Play and record HiFi quality Music." + * EndSectionUseCase + * + * # This file also stores the default sound card state. + * + * SectionDefaults + * 'Master Playback Switch':2:1,1 + * 'Master Playback Volume':2:25,25 + * 'Master Mono Playback Switch':1:0 + * 'Master Mono Playback Volume':1:0 + * 'PCM Switch':2:1,1 + * ........ + * EndSectionDefaults + * + * # End of example file. + */ +static int parse_master_file(snd_use_case_mgr_t *uc_mgr, FILE *f, + char *file) +{ + int line = 0, ret = 0; + char buf[MAX_BUF], *tbuf; + + /* parse master config sections */ + while(fgets(buf, MAX_BUF, f) != NULL) { + + line++; + + /* ignore comments */ + if (buf[0] == '#') { + line++; + continue; + } + + /* find use case section and parse it */ + if (strncmp(buf, "SectionUseCase", 14) == 0) { + tbuf = buf + 14; + while (isblank(*tbuf)) + tbuf++; + ret = parse_master_section(uc_mgr, f, &line); + if (ret < 0) + goto err; + } + + /* find default control values section and parse it */ + if (strncmp(buf, "SectionDefaults", 15) == 0) { + tbuf = buf + 15; + while (isblank(*tbuf)) + tbuf++; + ret = parse_controls(uc_mgr, f, &line, file); + if (ret < 0) + goto err; + } + } + +err: + if (ferror(f)) { + uc_error("error: %s: failed to read master file", file); + return ferror(f); + } + return ret; +} + +/* load master use case file for sound card */ +static int import_master_config(snd_use_case_mgr_t *uc_mgr) +{ + int ret; + FILE *f; + char filename[MAX_FILE]; + + sprintf(filename, "%s/%s/%s.conf", ALSA_USE_CASE_DIR, + uc_mgr->card_name, uc_mgr->card_name); + + uc_dbg("master config file %s", filename); + + f = fopen(filename, "r"); + if (f == NULL) { + uc_error("error: couldn't open %s configuration file %s", + uc_mgr->card_name, filename); + return -errno; + } + + ret = parse_master_file(uc_mgr, f, uc_mgr->card_name); + fclose(f); + return ret; +} + +static int parse_card_controls(snd_use_case_mgr_t *uc_mgr) +{ + struct control_settings *control; + int i, ret = 0; + snd_ctl_elem_id_t *id; + + /* allocate memory for controls */ + uc_mgr->control = calloc(uc_mgr->count, + sizeof(struct control_settings)); + if (uc_mgr->control == NULL) { + uc_error("error: not enough memory to store controls.\n"); + return -ENOMEM; + } + control = uc_mgr->control; + snd_ctl_elem_id_alloca(&id); + + /* iterate through each kcontrol and add to manager */ + for (i = 0; i < uc_mgr->count; ++i) { + + snd_ctl_elem_list_get_id(uc_mgr->list, i, id); + ret = add_control(uc_mgr->handle, id, control++); + if (ret < 0) { + uc_error("error: failed to add control error %s\n", + __func__, snd_strerror(ret)); + break; + } + } + + return ret; +} + +static int import_use_case_files(snd_use_case_mgr_t *uc_mgr) +{ + int ret; + + /* import the master file and default kcontrol settings */ + ret = import_master_config(uc_mgr); + if (ret < 0) { + uc_error("error: failed to parse master use case config %s\n", + uc_mgr->card_name); + return ret; + } + + return 0; +} + + +static void free_sequence(struct sequence_element *sequence) +{ + struct sequence_element *element = sequence; + + while (element) { + struct sequence_element *pre_element; + + if (element->control) { + free(element->control->value); + free(element->control); + } + pre_element = element; + element = element->next; + free(pre_element); + } +} + +static void free_transition_sequence_element(struct transition_sequence *trans) +{ + free(trans->name); + free_sequence(trans->transition); + free(trans); +} + +static void free_transition_sequence(struct transition_sequence *transition_list) +{ + struct transition_sequence *last, *trans_sequence = transition_list; + + while (trans_sequence) { + last = trans_sequence; + trans_sequence = trans_sequence->next; + free_transition_sequence_element(last); + } +} + +static void free_modifier(struct use_case_modifier *modifier) +{ + if (!modifier) + return; + + free(modifier->name); + free(modifier->comment); + free(modifier->playback_volume_id); + free(modifier->playback_switch_id); + free(modifier->capture_volume_id); + free(modifier->capture_switch_id); + + free_sequence(modifier->enable); + free_sequence(modifier->disable); + free_transition_sequence(modifier->transition_list); +} + +static void free_device(struct use_case_device *device) +{ + if (!device) + return; + + free(device->name); + free(device->comment); + free(device->playback_volume_id); + free(device->playback_switch_id); + free(device->capture_volume_id); + free(device->capture_switch_id); + + free_sequence(device->enable); + free_sequence(device->disable); + free_transition_sequence(device->transition_list); +} + +static void free_devices(struct use_case_device *devices, int num_devices) +{ + int i; + + if (!devices) + return; + + for (i = 0; i< num_devices; i++) + free_device(devices + i); + + free(devices); +} + +static void free_modifiers(struct use_case_modifier *modifiers, + int num_modifiers) +{ + int i; + + if (!modifiers) + return; + + for (i = 0; i < num_modifiers; i++) + free_modifier(modifiers + i); + + free(modifiers); +} + +static void free_verb(struct use_case_verb *verb) +{ + if (!verb) + return; + + free(verb->name); + free(verb->comment); + + free_sequence(verb->enable); + free_sequence(verb->disable); + free_transition_sequence(verb->transition_list); + + free_devices(verb->device, verb->num_devices); + free_modifiers(verb->modifier, verb->num_modifiers); +} + +static void free_verbs(struct use_case_verb *verbs, int num_verbs) +{ + int i; + + if (!verbs) + return; + + for (i = 0; i < num_verbs; i++) + free_verb(verbs + i); + + free(verbs); +} + +static void free_controls(struct control_settings *controls, int num_controls) +{ + int i = 0; + + if (!controls) + return; + + for(i = 0; i < num_controls; i++){ + struct control_settings *control = controls + i; + free(control->value); + } + free(controls); +} + +/* + * Free all use case manager resources. + * Callers holds locks. + */ +static void free_uc_mgr(snd_use_case_mgr_t *uc_mgr) +{ + if (uc_mgr == NULL) + return; + + if (uc_mgr->info) + snd_ctl_card_info_free(uc_mgr->info); + if (uc_mgr->list) + snd_ctl_elem_list_free(uc_mgr->list); + if (uc_mgr->id) + snd_ctl_elem_id_free(uc_mgr->id); + + if (uc_mgr->handle) + snd_ctl_close(uc_mgr->handle); + + free(uc_mgr->card_name); + free(uc_mgr->ctl_name); + + free_verbs(uc_mgr->verb, uc_mgr->num_verbs); + + free_controls(uc_mgr->control, uc_mgr->count); + + pthread_mutex_destroy(&uc_mgr->mutex); + + free(uc_mgr); +} + + /** + * \brief Init sound card use case manager. + * \param uc_mgr Use case manager + * \return zero on success, otherwise a negative error code + */ +snd_use_case_mgr_t *snd_use_case_mgr_open(const char *card_name) +{ + snd_use_case_mgr_t *uc_mgr; + char ctl_name[8]; + int err, idx; + + idx = snd_card_get_index(card_name); + if (idx < 0) { + uc_error("error: can't get sound card %s: %s", + card_name, snd_strerror(idx)); + return NULL; + } + + /* create a new UCM */ + uc_mgr = calloc(1, sizeof(snd_use_case_mgr_t)); + if (uc_mgr == NULL) + return NULL; + + uc_mgr->card_name = strdup(card_name); + if (uc_mgr->card_name == NULL) { + free(uc_mgr); + return NULL; + } + sprintf(ctl_name, "hw:%d", idx); + uc_mgr->ctl_name = strdup(ctl_name); + if (uc_mgr->ctl_name == NULL) { + free_uc_mgr(uc_mgr); + return NULL; + } + if (snd_ctl_card_info_malloc(&uc_mgr->info) < 0) { + free_uc_mgr(uc_mgr); + return NULL; + } + if (snd_ctl_elem_list_malloc(&uc_mgr->list) < 0) { + free_uc_mgr(uc_mgr); + return NULL; + } + if (snd_ctl_elem_id_malloc(&uc_mgr->id) < 0) { + free_uc_mgr(uc_mgr); + return NULL; + } + + /* open and init CTLs */ + err = snd_ctl_open(&uc_mgr->handle, uc_mgr->ctl_name, 0); + if (err) { + uc_error("error: can't open sound card %s: %s", + uc_mgr->card_name, snd_strerror(err)); + goto err; + } + + err = snd_ctl_card_info(uc_mgr->handle, uc_mgr->info); + if (err < 0) { + uc_error("error: can't get sound card %s control info: %s", + uc_mgr->card_name, snd_strerror(err)); + goto err; + } + + err = snd_ctl_elem_list(uc_mgr->handle, uc_mgr->list); + if (err < 0) { + uc_error("error: can't get sound card %s elements: %s", + uc_mgr->card_name, snd_strerror(err)); + goto err; + } + + uc_mgr->count = snd_ctl_elem_list_get_count(uc_mgr->list); + if (uc_mgr->count < 0) { + uc_error("error: can't get sound card %s controls %s:", + uc_mgr->card_name, snd_strerror(err)); + goto err; + } + + snd_ctl_elem_list_set_offset(uc_mgr->list, 0); + if (snd_ctl_elem_list_alloc_space(uc_mgr->list, uc_mgr->count) < 0) { + uc_error("error: could not allocate elements for %s", + uc_mgr->card_name); + goto err; + } + + err = snd_ctl_elem_list(uc_mgr->handle, uc_mgr->list); + if (err < 0) { + uc_error("error: could not get elements for %s : %s", + uc_mgr->card_name, snd_strerror(err)); + goto err; + } + + /* get info about sound card */ + err = parse_card_controls(uc_mgr); + if (err < 0) { + uc_error("error: failed to parse sound device %s controls %d", + card_name, err); + goto err; + } + + /* get info on use_cases and verify against card */ + err = import_use_case_files(uc_mgr); + if (err < 0) { + uc_error("error: failed to import %s use case configuration %d", + card_name, err); + goto err; + } + + pthread_mutex_init(&uc_mgr->mutex, NULL); + uc_mgr->card.current_verb = VERB_NOT_INITIALISED; + + return uc_mgr; + +err: + free_uc_mgr(uc_mgr); + return NULL; +} + + /** + * \brief Reload and reparse all use case files. + * \param uc_mgr Use case manager + * \return zero on success, otherwise a negative error code + */ +int snd_use_case_mgr_reload(snd_use_case_mgr_t *uc_mgr) +{ + int ret; + + pthread_mutex_lock(&uc_mgr->mutex); + + free_verbs(uc_mgr->verb, uc_mgr->num_verbs); + free_controls(uc_mgr->control, uc_mgr->count); + + /* reload all sound card controls */ + ret = parse_card_controls(uc_mgr); + if (ret <= 0) { + uc_error("error: failed to reload sound card controls %d\n", + ret); + free_uc_mgr(uc_mgr); + return -EINVAL; + } + + /* reload all use cases */ + uc_mgr->num_verbs = import_use_case_files(uc_mgr); + if (uc_mgr->num_verbs <= 0) { + uc_error("error: failed to reload use cases\n"); + return -EINVAL; + } + + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + + /** + * \brief Close use case manager. + * \param uc_mgr Use case manager + * \return zero on success, otherwise a negative error code + */ +int snd_use_case_mgr_close(snd_use_case_mgr_t *uc_mgr) +{ + free_uc_mgr(uc_mgr); + + return 0; +} + + /** + * \brief Reset sound card controls to default values. + * \param uc_mgr Use case manager + * \return zero on success, otherwise a negative error code + */ +int snd_use_case_mgr_reset(snd_use_case_mgr_t *uc_mgr) +{ + int ret = 0, i; + struct control_settings *control; + + pthread_mutex_lock(&uc_mgr->mutex); + + for (i = 0; i < uc_mgr->count; i++) { + control = &uc_mgr->control[i]; + + /* Only set default value specified in master config file */ + if (control->value == NULL) + continue; + + ret = set_control_default(uc_mgr, control); + if (ret < 0) + goto out; + } + uc_mgr->card.current_verb = VERB_NOT_INITIALISED; +out: + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + + +/* + * Change a sound card control to a new value. + */ +static int set_control(snd_ctl_t *handle, snd_ctl_elem_id_t *id, + snd_use_case_mgr_t *uc_mgr, unsigned short value[]) +{ + struct control_settings *setting; + int ret, count, i; + unsigned int idnum; + snd_ctl_elem_info_t *info; + snd_ctl_elem_type_t type; + snd_ctl_elem_value_t *control; + + snd_ctl_elem_info_alloca(&info); + snd_ctl_elem_value_alloca(&control); + + snd_ctl_elem_info_set_id(info, id); + ret = snd_ctl_elem_info(handle, info); + if (ret < 0) { + uc_error("error: failed to get ctl elem info %d: ", + snd_strerror(ret)); + return ret; + } + + snd_ctl_elem_value_set_id(control, id); + snd_ctl_elem_read(handle, control); + + idnum = snd_ctl_elem_id_get_numid(id); + for (i = 0; i < uc_mgr->count; i++) { + setting = &uc_mgr->control[i]; + if (setting->id == idnum) + goto set_val; + } + uc_error("error: failed to find control at id %d", idnum); + return 0; + +set_val: + uc_dbg("set control %s id %d count %d", setting->name, setting->id, + setting->count); + + type = snd_ctl_elem_info_get_type(info); + count = snd_ctl_elem_info_get_count(info); + if (count == 0) + return 0; + + uc_dbg("type %d count %d", type, count); + + switch (type) { + case SND_CTL_ELEM_TYPE_BOOLEAN: + for (i = 0; i < count; i++) { + uc_dbg("count %d value %u", i, *(value + i)); + snd_ctl_elem_value_set_boolean(control, i, value[i]); + } + break; + case SND_CTL_ELEM_TYPE_INTEGER: + uc_dbg("int"); + for (i = 0; i < count; i++) { + uc_dbg("count %d value %u", i, value[i]); + snd_ctl_elem_value_set_integer(control, i, value[i]); + } + break; + case SND_CTL_ELEM_TYPE_INTEGER64: + uc_dbg("int64"); + for (i = 0; i < count; i++) { + uc_dbg("count %d value %u", i, value[i]); + snd_ctl_elem_value_set_integer64(control, i, value[i]); + } + + break; + case SND_CTL_ELEM_TYPE_ENUMERATED: + uc_dbg("enumerated"); + for (i = 0; i < count; i++) { + uc_dbg("count %d value %u", i, value[i]); + snd_ctl_elem_value_set_enumerated(control, i, value[i]); + } + break; + case SND_CTL_ELEM_TYPE_BYTES: + uc_dbg("bytes"); + for (i = 0; i < count; i++) { + uc_dbg("count %d value %u", i, value[i]); + snd_ctl_elem_value_set_byte(control, i, value[i]); + } + break; + default: + break; + } + + ret = snd_ctl_elem_write(handle, control); + if (ret < 0) { + uc_error("error: failed to set control %s: %s", + setting->name, snd_strerror(ret)); + uc_error("error: count %d type: %d", + count, type); + for (i = 0; i < count; i++) + fprintf(stderr, "%d ", get_value(setting, i)); + return ret; + } + return 0; +} + +/* + * Execute a sequence of control writes. + */ +static int exec_sequence(struct sequence_element *seq, snd_use_case_mgr_t + *uc_mgr, snd_ctl_elem_list_t *list, snd_ctl_t *handle) +{ + int count = snd_ctl_elem_list_get_count(list); + int ret, i; + + uc_dbg(""); + + /* keep going until end of sequence */ + while (seq) { + /* do we need to sleep */ + if (seq->sleep) { + uc_dbg("msleep %d", seq->sleep); + usleep(seq->sleep); + } else { + uc_dbg("control name %s, id %d, count %d, vale[1] %u", + seq->control->name, seq->control->id, + seq->control->count, seq->control->value[0]); + + /* control write */ + snd_ctl_elem_id_t *id; + snd_ctl_elem_id_alloca(&id); + unsigned int numid; + + /* Where is id lookup from numid if you need it? */ + for (i = 0; i < count; ++i) { + + snd_ctl_elem_list_get_id(list, i, id); + numid = snd_ctl_elem_id_get_numid(id); + + if (numid == seq->control->id) { + ret = set_control(handle, id, uc_mgr, seq->control->value); + if (ret < 0) { + uc_error("error: failed to set control %s", + __func__, uc_mgr->card_name); + return ret; + } + break; + } + } + } + seq = seq->next; + } + return 0; +} + +static int enable_use_case_verb(snd_use_case_mgr_t *uc_mgr, int verb_id, + snd_ctl_elem_list_t *list, snd_ctl_t *handle) +{ + struct use_case_verb *verb; + int ret; + + if (verb_id >= uc_mgr->num_verbs) { + uc_error("error: invalid verb id %d", verb_id); + return -EINVAL; + } + verb = &uc_mgr->verb[verb_id]; + + uc_dbg("verb %s", verb->name); + ret = exec_sequence(verb->enable, uc_mgr, list, handle); + if (ret < 0) { + uc_error("error: could not enable verb %s", verb->name); + return ret; + } + uc_mgr->card.current_verb = verb_id; + + return 0; +} + +static int disable_use_case_verb(snd_use_case_mgr_t *uc_mgr, int verb_id, + snd_ctl_elem_list_t *list, snd_ctl_t *handle) +{ + struct use_case_verb *verb; + int ret; + + if (verb_id >= uc_mgr->num_verbs) { + uc_error("error: invalid verb id %d", verb_id); + return -EINVAL; + } + verb = &uc_mgr->verb[verb_id]; + + /* we set the invalid verb at open() but we should still + * check that this succeeded */ + if (verb == NULL) + return 0; + + uc_dbg("verb %s", verb->name); + ret = exec_sequence(verb->disable, uc_mgr, list, handle); + if (ret < 0) { + uc_error("error: could not disable verb %s", verb->name); + return ret; + } + + return 0; +} + +static int enable_use_case_device(snd_use_case_mgr_t *uc_mgr, + int device_id, snd_ctl_elem_list_t *list, snd_ctl_t *handle) +{ + struct use_case_verb *verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + struct use_case_device *device = &verb->device[device_id]; + int ret; + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) + return -EINVAL; + + uc_dbg("device %s", device->name); + ret = exec_sequence(device->enable, uc_mgr, list, handle); + if (ret < 0) { + uc_error("error: could not enable device %s", device->name); + return ret; + } + + set_device_status(uc_mgr, device_id, 1); + return 0; +} + +static int disable_use_case_device(snd_use_case_mgr_t *uc_mgr, + int device_id, snd_ctl_elem_list_t *list, snd_ctl_t *handle) +{ + struct use_case_verb *verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + struct use_case_device *device = &verb->device[device_id]; + int ret; + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) + return -EINVAL; + + uc_dbg("device %s", device->name); + ret = exec_sequence(device->disable, uc_mgr, list, handle); + if (ret < 0) { + uc_error("error: could not disable device %s", device->name); + return ret; + } + + set_device_status(uc_mgr, device_id, 0); + return 0; +} + +static int enable_use_case_modifier(snd_use_case_mgr_t *uc_mgr, + int modifier_id, snd_ctl_elem_list_t *list, snd_ctl_t *handle) +{ + struct use_case_verb *verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + struct use_case_modifier *modifier = &verb->modifier[modifier_id]; + int ret; + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) + return -EINVAL; + + uc_dbg("modifier %s", modifier->name); + ret = exec_sequence(modifier->enable, uc_mgr, list, handle); + if (ret < 0) { + uc_error("error: could not enable modifier %s", modifier->name); + return ret; + } + + set_modifier_status(uc_mgr, modifier_id, 1); + return 0; +} + +static int disable_use_case_modifier(snd_use_case_mgr_t *uc_mgr, + int modifier_id, snd_ctl_elem_list_t *list, snd_ctl_t *handle) +{ + struct use_case_verb *verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + struct use_case_modifier *modifier = &verb->modifier[modifier_id]; + int ret; + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) + return -EINVAL; + + uc_dbg("modifier %s", modifier->name); + ret = exec_sequence(modifier->disable, uc_mgr, list, handle); + if (ret < 0) { + uc_error("error: could not disable modifier %s", modifier->name); + return ret; + } + + set_modifier_status(uc_mgr, modifier_id, 0); + return 0; +} + +/* + * Tear down current use case verb, device and modifier. + */ +static int dismantle_use_case(snd_use_case_mgr_t *uc_mgr, + snd_ctl_elem_list_t *list, snd_ctl_t *handle) +{ + struct use_case_verb *verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + int ret, i; + + /* No active verb */ + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) + return 0; + + /* disable all modifiers that are active */ + for (i = 0; i < verb->num_modifiers; i++) { + if (get_modifier_status(uc_mgr,i)) { + ret = disable_use_case_modifier(uc_mgr, i, list, handle); + if (ret < 0) + return ret; + } + } + + /* disable all devices that are active */ + for (i = 0; i < verb->num_devices; i++) { + if (get_device_status(uc_mgr,i)) { + ret = disable_use_case_device(uc_mgr, i, list, handle); + if (ret < 0) + return ret; + } + } + + /* disable verb */ + ret = disable_use_case_verb(uc_mgr, uc_mgr->card.current_verb, list, handle); + if (ret < 0) + return ret; + + return 0; +} + + /** + * \brief Dump sound card controls in format required for sequencer. + * \param card_name The name of the sound card to be dumped + * \return zero on success, otherwise a negative error code + */ +int snd_use_case_dump(const char *card_name) +{ + snd_ctl_t *handle; + snd_ctl_card_info_t *info; + snd_ctl_elem_list_t *list; + int ret, i, count, idx; + char ctl_name[8]; + + snd_ctl_card_info_alloca(&info); + snd_ctl_elem_list_alloca(&list); + + idx = snd_card_get_index(card_name); + if (idx < 0) + return idx; + sprintf(ctl_name, "hw:%d", idx); + + /* open and load snd card */ + ret = snd_ctl_open(&handle, ctl_name, SND_CTL_READONLY); + if (ret < 0) { + uc_error("error: could not open controls for %s: %s", + card_name, snd_strerror(ret)); + return ret; + } + + ret = snd_ctl_card_info(handle, info); + if (ret < 0) { + uc_error("error: could not get control info for %s:%s", + card_name, snd_strerror(ret)); + goto close; + } + + ret = snd_ctl_elem_list(handle, list); + if (ret < 0) { + uc_error("error: cannot determine controls for %s: %s", + card_name, snd_strerror(ret)); + goto close; + } + + count = snd_ctl_elem_list_get_count(list); + if (count < 0) { + ret = 0; + goto close; + } + + snd_ctl_elem_list_set_offset(list, 0); + if (snd_ctl_elem_list_alloc_space(list, count) < 0) { + uc_error("error: not enough memory for control elements"); + ret = -ENOMEM; + goto close; + } + if ((ret = snd_ctl_elem_list(handle, list)) < 0) { + uc_error("error: cannot determine controls: %s", + snd_strerror(ret)); + goto free; + } + + /* iterate through each kcontrol and add to use + * case manager control list */ + for (i = 0; i < count; ++i) { + snd_ctl_elem_id_t *id; + snd_ctl_elem_id_alloca(&id); + snd_ctl_elem_list_get_id(list, i, id); + + /* dump to stdout in friendly format */ + ret = dump_control(handle, id); + if (ret < 0) { + uc_error("error: control dump failed: %s", + snd_strerror(ret)); + goto free; + } + } +free: + snd_ctl_elem_list_free_space(list); +close: + snd_ctl_close(handle); + return ret; +} + +/** + * \brief List supported use case verbs for given soundcard + * \param uc_mgr use case manager + * \param verb returned list of supported use case verb id and names + * \return number of use case verbs if success, otherwise a negative error code + */ +int snd_use_case_get_verb_list(snd_use_case_mgr_t *uc_mgr, + const char **verb[]) +{ + int ret; + + pthread_mutex_lock(&uc_mgr->mutex); + + *verb = uc_mgr->verb_list; + ret = uc_mgr->num_verbs; + + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + +/** + * \brief List supported use case devices for given verb + * \param uc_mgr use case manager + * \param verb verb id. + * \param device returned list of supported use case device id and names + * \return number of use case devices if success, otherwise a negative error code + */ +int snd_use_case_get_device_list(snd_use_case_mgr_t *uc_mgr, + const char *verb_name, const char **device[]) +{ + struct use_case_verb *verb = NULL; + int i, ret = -EINVAL; + + pthread_mutex_lock(&uc_mgr->mutex); + + /* find verb name */ + for (i = 0; i < uc_mgr->num_verbs; i++) { + verb = &uc_mgr->verb[i]; + if (!strcmp(uc_mgr->verb[i].name, verb_name)) + goto found; + } + + uc_error("error: use case verb %s not found", verb_name); + goto out; + +found: + *device = verb->device_list; + ret = verb->num_devices; +out: + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + +/** + * \brief List supported use case verb modifiers for given verb + * \param uc_mgr use case manager + * \param verb verb id. + * \param mod returned list of supported use case modifier id and names + * \return number of use case modifiers if success, otherwise a negative error code + */ +int snd_use_case_get_mod_list(snd_use_case_mgr_t *uc_mgr, + const char *verb_name, const char **mod[]) +{ + struct use_case_verb *verb = NULL; + int i, ret = -EINVAL; + + pthread_mutex_lock(&uc_mgr->mutex); + + /* find verb name */ + for (i = 0; i <uc_mgr->num_verbs; i++) { + verb = &uc_mgr->verb[i]; + if (!strcmp(uc_mgr->verb[i].name, verb_name)) + goto found; + } + + uc_error("error: use case verb %s not found", verb_name); + goto out; + +found: + *mod = verb->modifier_list; + ret = verb->num_modifiers; +out: + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + +static struct sequence_element *get_transition_sequence( + struct transition_sequence *trans_list, const char *name) +{ + struct transition_sequence *trans = trans_list; + + while (trans) { + if (trans->name && !strcmp(trans->name, name)) + return trans->transition; + + trans = trans->next; + } + + return NULL; +} + +static int exec_transition_sequence(snd_use_case_mgr_t *uc_mgr, + struct sequence_element *trans_sequence) +{ + int ret; + + ret = exec_sequence(trans_sequence, uc_mgr, uc_mgr->list, + uc_mgr->handle); + if (ret < 0) + uc_error("error: could not exec transition sequence"); + + return ret; +} + +static int handle_transition_verb(snd_use_case_mgr_t *uc_mgr, + int new_verb_id) +{ + struct use_case_verb *old_verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + struct use_case_verb *new_verb; + static struct sequence_element *trans_sequence; + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) + return -EINVAL; + + if (new_verb_id >= uc_mgr->num_verbs) { + uc_error("error: invalid new_verb id %d", new_verb_id); + return -EINVAL; + } + + new_verb = &uc_mgr->verb[new_verb_id]; + + uc_dbg("new verb %s", new_verb->name); + + trans_sequence = get_transition_sequence(old_verb->transition_list, + new_verb->name); + if (trans_sequence != NULL) { + int ret, i; + + uc_dbg("find transition sequence %s->%s", + old_verb->name, new_verb->name); + + /* disable all modifiers that are active */ + for (i = 0; i < old_verb->num_modifiers; i++) { + if (get_modifier_status(uc_mgr,i)) { + ret = disable_use_case_modifier(uc_mgr, i, + uc_mgr->list, uc_mgr->handle); + if (ret < 0) + return ret; + } + } + + /* disable all devices that are active */ + for (i = 0; i < old_verb->num_devices; i++) { + if (get_device_status(uc_mgr,i)) { + ret = disable_use_case_device(uc_mgr, i, + uc_mgr->list, uc_mgr->handle); + if (ret < 0) + return ret; + } + } + + ret = exec_transition_sequence(uc_mgr, trans_sequence); + if (ret) + return ret; + + uc_mgr->card.current_verb = new_verb_id; + + return 0; + } + + return-EINVAL; +} + +/** + * \brief Set new use case verb for sound card + * \param uc_mgr use case manager + * \param verb verb id + * \return zero if success, otherwise a negative error code + */ +int snd_use_case_set_verb(snd_use_case_mgr_t *uc_mgr, + const char *verb_name) +{ + int i = 0, ret = -EINVAL, inactive = 0; + + pthread_mutex_lock(&uc_mgr->mutex); + + uc_dbg("uc_mgr %p, verb_name %s", uc_mgr, verb_name); + + /* check for "Inactive" */ + if (!strcmp(verb_name, SND_USE_CASE_VERB_INACTIVE)) { + inactive = 1; + goto found; + } + + /* find verb name */ + for (i = 0; i <uc_mgr->num_verbs; i++) { + if (!strcmp(uc_mgr->verb[i].name, verb_name)) + goto found; + } + + uc_error("error: use case verb %s not found", verb_name); + goto out; +found: + /* use case verb found - check that we actually changing the verb */ + if (i == uc_mgr->card.current_verb) { + uc_dbg("current verb ID %d", i); + ret = 0; + goto out; + } + + if (handle_transition_verb(uc_mgr, i) == 0) + goto out; + + /* + * Dismantle the old use cases by running it's verb, device and modifier + * disable sequences + */ + ret = dismantle_use_case(uc_mgr, uc_mgr->list, uc_mgr->handle); + if (ret < 0) { + uc_error("error: failed to dismantle current use case: %s", + uc_mgr->verb[i].name); + goto out; + } + + /* we don't need to initialise new verb if inactive */ + if (inactive) + goto out; + + /* Initialise the new use case verb */ + ret = enable_use_case_verb(uc_mgr, i, uc_mgr->list, uc_mgr->handle); + if (ret < 0) + uc_error("error: failed to initialise new use case: %s", + verb_name); +out: + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +static int config_use_case_device(snd_use_case_mgr_t *uc_mgr, + const char *device_name, int enable) +{ + struct use_case_verb *verb; + int ret, i; + + pthread_mutex_lock(&uc_mgr->mutex); + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) { + uc_error("error: no valid use case verb set\n"); + ret = -EINVAL; + goto out; + } + + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + + uc_dbg("current verb %s", verb->name); + uc_dbg("uc_mgr %p device_name %s", uc_mgr, device_name); + + /* find device name and index */ + for (i = 0; i <verb->num_devices; i++) { + uc_dbg("verb->num_devices %s", verb->device[i].name); + if (!strcmp(verb->device[i].name, device_name)) + goto found; + } + + uc_error("error: use case device %s not found", device_name); + ret = -EINVAL; + goto out; + +found: + if (enable) { + /* Initialise the new use case device */ + ret = enable_use_case_device(uc_mgr, i, uc_mgr->list, + uc_mgr->handle); + if (ret < 0) + goto out; + } else { + /* disable the old device */ + ret = disable_use_case_device(uc_mgr, i, uc_mgr->list, + uc_mgr->handle); + if (ret < 0) + goto out; + } + +out: + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + +/** + * \brief Enable use case device + * \param uc_mgr Use case manager + * \param device the device to be enabled + * \return 0 = successful negative = error + */ +int snd_use_case_enable_device(snd_use_case_mgr_t *uc_mgr, + const char *device) +{ + return config_use_case_device(uc_mgr, device, 1); +} + +/** + * \brief Disable use case device + * \param uc_mgr Use case manager + * \param device the device to be disabled + * \return 0 = successful negative = error + */ +int snd_use_case_disable_device(snd_use_case_mgr_t *uc_mgr, + const char *device) +{ + return config_use_case_device(uc_mgr, device, 0); +} + +static struct use_case_device *get_device(snd_use_case_mgr_t *uc_mgr, + const char *name, int *id) +{ + struct use_case_verb *verb; + int i; + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) + return NULL; + + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + + uc_dbg("current verb %s", verb->name); + + for (i = 0; i < verb->num_devices; i++) { + uc_dbg("device %s", verb->device[i].name); + + if (!strcmp(verb->device[i].name, name)) { + if (id) + *id = i; + return &verb->device[i]; + } + } + + return NULL; +} + +/** + * \brief Disable old_device and then enable new_device. + * If from_device is not enabled just return. + * Check transition sequence firstly. + * \param uc_mgr Use case manager + * \param old the device to be closed + * \param new the device to be opened + * \return 0 = successful negative = error + */ +int snd_use_case_switch_device(snd_use_case_mgr_t *uc_mgr, + const char *old, const char *new) +{ + static struct sequence_element *trans_sequence; + struct use_case_device *old_device; + struct use_case_device *new_device; + int ret = 0, old_id, new_id; + + uc_dbg("old %s, new %s", old, new); + + pthread_mutex_lock(&uc_mgr->mutex); + + old_device = get_device(uc_mgr, old, &old_id); + if (!old_device) { + uc_error("error: device %s not found", old); + ret = -EINVAL; + goto out; + } + + if (!get_device_status(uc_mgr, old_id)) { + uc_error("error: device %s not enabled", old); + goto out; + } + + new_device = get_device(uc_mgr, new, &new_id); + if (!new_device) { + uc_error("error: device %s not found", new); + ret = -EINVAL; + goto out; + } + + trans_sequence = get_transition_sequence(old_device->transition_list, new); + if (trans_sequence != NULL) { + + uc_dbg("find transition sequece %s->%s", old, new); + + ret = exec_transition_sequence(uc_mgr, trans_sequence); + if (ret) + goto out; + + set_device_status(uc_mgr, old_id, 0); + set_device_status(uc_mgr, new_id, 1); + } else { + /* use lock in config_use_case_device */ + pthread_mutex_unlock(&uc_mgr->mutex); + + config_use_case_device(uc_mgr, old, 0); + config_use_case_device(uc_mgr, new, 1); + + return 0; + } +out: + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + +/* + * Check to make sure that the modifier actually supports any of the + * active devices. + */ +static int is_modifier_valid(snd_use_case_mgr_t *uc_mgr, + struct use_case_verb *verb, struct use_case_modifier *modifier) +{ + struct dev_list *dev_list; + int dev; + + /* check modifier list against each enabled device */ + for (dev = 0; dev < verb->num_devices; dev++) { + if (!get_device_status(uc_mgr, dev)) + continue; + + dev_list = modifier->dev_list; + uc_dbg("checking device %s for %s", verb->device[dev].name, + dev_list->name ? dev_list->name : ""); + + while (dev_list) { + uc_dbg("device supports %s", dev_list->name); + if (!strcmp(dev_list->name, verb->device[dev].name)) + return 1; + dev_list = dev_list->next; + } + } + return 0; +} + +static int config_use_case_mod(snd_use_case_mgr_t *uc_mgr, + const char *modifier_name, int enable) +{ + struct use_case_verb *verb; + int ret, i; + + pthread_mutex_lock(&uc_mgr->mutex); + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) { + ret = -EINVAL; + goto out; + } + + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + + uc_dbg("current verb %s", verb->name); + uc_dbg("uc_mgr %p modifier_name %s", uc_mgr, modifier_name); + + /* find modifier name */ + for (i = 0; i <verb->num_modifiers; i++) { + uc_dbg("verb->num_modifiers %d %s", i, verb->modifier[i].name); + if (!strcmp(verb->modifier[i].name, modifier_name) && + is_modifier_valid(uc_mgr, verb, &verb->modifier[i])) + goto found; + } + + uc_error("error: use case modifier %s not found or invalid", + modifier_name); + ret = -EINVAL; + goto out; + +found: + if (enable) { + /* Initialise the new use case device */ + ret = enable_use_case_modifier(uc_mgr, i, uc_mgr->list, + uc_mgr->handle); + if (ret < 0) + goto out; + } else { + /* disable the old device */ + ret = disable_use_case_modifier(uc_mgr, i, uc_mgr->list, + uc_mgr->handle); + if (ret < 0) + goto out; + } + +out: + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + +/** + * \brief Enable use case modifier + * \param uc_mgr Use case manager + * \param modifier the modifier to be enabled + * \return 0 = successful negative = error + */ +int snd_use_case_enable_modifier(snd_use_case_mgr_t *uc_mgr, + const char *modifier) +{ + return config_use_case_mod(uc_mgr, modifier, 1); +} + +/** + * \brief Disable use case modifier + * \param uc_mgr Use case manager + * \param modifier the modifier to be disabled + * \return 0 = successful negative = error + */ +int snd_use_case_disable_modifier(snd_use_case_mgr_t *uc_mgr, + const char *modifier) +{ + return config_use_case_mod(uc_mgr, modifier, 0); +} + +static struct use_case_modifier *get_modifier(snd_use_case_mgr_t *uc_mgr, + const char *name, int *mod_id) +{ + struct use_case_verb *verb; + int i; + + if (uc_mgr->card.current_verb == VERB_NOT_INITIALISED) + return NULL; + + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + + uc_dbg("current verb %s", verb->name); + + uc_dbg("uc_mgr %p modifier_name %s", uc_mgr, name); + + for (i = 0; i < verb->num_modifiers; i++) { + uc_dbg("verb->num_devices %s", verb->modifier[i].name); + + if (!strcmp(verb->modifier[i].name, name)) { + if (mod_id) + *mod_id = i; + return &verb->modifier[i]; + } + } + + return NULL; +} + +/** + * \brief Disable old_modifier and then enable new_modifier. + * If old_modifier is not enabled just return. + * Check transition sequence firstly. + * \param uc_mgr Use case manager + * \param old the modifier to be closed + * \param new the modifier to be opened + * \return 0 = successful negative = error + */ +int snd_use_case_switch_modifier(snd_use_case_mgr_t *uc_mgr, + const char *old, const char *new) +{ + struct use_case_modifier *old_modifier; + struct use_case_modifier *new_modifier; + static struct sequence_element *trans_sequence; + int ret = 0, old_id, new_id + + uc_dbg("old %s, new %s", old, new); + + pthread_mutex_lock(&uc_mgr->mutex); + + old_modifier = get_modifier(uc_mgr, old, &old_id); + if (!old_modifier) { + uc_error("error: modifier %s not found", old); + ret = -EINVAL; + goto out; + } + + if (!get_modifier_status(uc_mgr, old_id)) { + uc_error("error: modifier %s not enabled", old); + ret = -EINVAL; + goto out; + } + + new_modifier = get_modifier(uc_mgr, new, &new_id); + if (!new_modifier) { + uc_error("error: modifier %s not found", new); + ret = -EINVAL; + goto out; + } + + trans_sequence = get_transition_sequence( + old_modifier->transition_list, new); + if (trans_sequence != NULL) { + uc_dbg("find transition sequence %s->%s", old, new); + + ret = exec_transition_sequence(uc_mgr, trans_sequence); + if (ret) + goto out; + + set_device_status(uc_mgr, old_id, 0); + set_device_status(uc_mgr, new_id, 1); + } else { + /* use lock in config_use_case_mod*/ + pthread_mutex_unlock(&uc_mgr->mutex); + + config_use_case_mod(uc_mgr, old, 0); + config_use_case_mod(uc_mgr, new, 1); + + return 0; + } +out: + pthread_mutex_unlock(&uc_mgr->mutex); + return ret; +} + +/** + * \brief Get current use case verb from sound card + * \param uc_mgr use case manager + * \return Verb Name if success, otherwise NULL + */ +const char *snd_use_case_get_verb(snd_use_case_mgr_t *uc_mgr) +{ + const char *ret = NULL; + + pthread_mutex_lock(&uc_mgr->mutex); + + if (uc_mgr->card.current_verb != VERB_NOT_INITIALISED) + ret = uc_mgr->verb_list[uc_mgr->card.current_verb]; + + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get device status for current use case verb + * \param uc_mgr Use case manager + * \param device_name The device we are interested in. + * \return - 1 = enabled, 0 = disabled, negative = error + */ +int snd_use_case_get_device_status(snd_use_case_mgr_t *uc_mgr, + const char *device_name) +{ + struct use_case_device *device; + int ret = -EINVAL, dev_id; + + pthread_mutex_lock(&uc_mgr->mutex); + + device = get_device(uc_mgr, device_name, &dev_id); + if (device == NULL) { + uc_error("error: use case device %s not found", device_name); + goto out; + } + + ret = get_device_status(uc_mgr, dev_id); +out: + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get modifier status for current use case verb + * \param uc_mgr Use case manager + * \param device_name The device we are interested in. + * \return - 1 = enabled, 0 = disabled, negative = error + */ +int snd_use_case_get_modifier_status(snd_use_case_mgr_t *uc_mgr, + const char *modifier_name) +{ + struct use_case_modifier *modifier; + int ret = -EINVAL, mod_id; + + pthread_mutex_lock(&uc_mgr->mutex); + + modifier = get_modifier(uc_mgr, modifier_name, &mod_id); + if (modifier == NULL) { + uc_error("error: use case modifier %s not found", modifier_name); + goto out; + } + + ret = get_modifier_status(uc_mgr, mod_id); +out: + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get current use case verb QoS + * \param uc_mgr use case manager + * \return QoS level + */ +enum snd_use_case_qos + snd_use_case_get_verb_qos(snd_use_case_mgr_t *uc_mgr) +{ + struct use_case_verb *verb; + enum snd_use_case_qos ret = SND_USE_CASE_QOS_UNKNOWN; + + pthread_mutex_lock(&uc_mgr->mutex); + + if (uc_mgr->card.current_verb != VERB_NOT_INITIALISED) { + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + ret = verb->qos; + } + + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get current use case modifier QoS + * \param uc_mgr use case manager + * \return QoS level + */ +enum snd_use_case_qos + snd_use_case_get_mod_qos(snd_use_case_mgr_t *uc_mgr, + const char *modifier_name) +{ + struct use_case_modifier *modifier; + enum snd_use_case_qos ret = SND_USE_CASE_QOS_UNKNOWN; + + pthread_mutex_lock(&uc_mgr->mutex); + + modifier = get_modifier(uc_mgr, modifier_name, NULL); + if (modifier != NULL) + ret = modifier->qos; + else + uc_error("error: use case modifier %s not found", modifier_name); + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get current use case verb playback PCM + * \param uc_mgr use case manager + * \return PCM number if success, otherwise negative + */ +int snd_use_case_get_verb_playback_pcm(snd_use_case_mgr_t *uc_mgr) +{ + struct use_case_verb *verb; + int ret = -EINVAL; + + pthread_mutex_lock(&uc_mgr->mutex); + + if (uc_mgr->card.current_verb != VERB_NOT_INITIALISED) { + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + ret = verb->playback_pcm; + } + + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get current use case verb playback PCM + * \param uc_mgr use case manager + * \return PCM number if success, otherwise negative + */ +int snd_use_case_get_verb_capture_pcm(snd_use_case_mgr_t *uc_mgr) +{ + struct use_case_verb *verb; + int ret = -EINVAL; + + pthread_mutex_lock(&uc_mgr->mutex); + + if (uc_mgr->card.current_verb != VERB_NOT_INITIALISED) { + verb = &uc_mgr->verb[uc_mgr->card.current_verb]; + ret = verb->capture_pcm; + } + + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get current use case modifier playback PCM + * \param uc_mgr use case manager + * \return PCM number if success, otherwise negative + */ +int snd_use_case_get_mod_playback_pcm(snd_use_case_mgr_t *uc_mgr, + const char *modifier_name) +{ + struct use_case_modifier *modifier; + int ret = -EINVAL; + + pthread_mutex_lock(&uc_mgr->mutex); + + modifier = get_modifier(uc_mgr, modifier_name, NULL); + if (modifier == NULL) + uc_error("error: use case modifier %s not found", + modifier_name); + else + ret = modifier->playback_pcm; + + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get current use case modifier playback PCM + * \param uc_mgr use case manager + * \return PCM number if success, otherwise negative + */ +int snd_use_case_get_mod_capture_pcm(snd_use_case_mgr_t *uc_mgr, + const char *modifier_name) +{ + struct use_case_modifier *modifier; + int ret = -EINVAL; + + pthread_mutex_lock(&uc_mgr->mutex); + + modifier = get_modifier(uc_mgr, modifier_name, NULL); + if (modifier == NULL) + uc_error("error: use case modifier %s not found", + modifier_name); + else + ret = modifier->capture_pcm; + + pthread_mutex_unlock(&uc_mgr->mutex); + + return ret; +} + +/** + * \brief Get volume/mute control name depending on use case device. + * \param uc_mgr use case manager + * \param type the control type we are looking for + * \param device_name The use case device we are interested in. + * \return control name if success, otherwise NULL + * + * Get the control id for common volume and mute controls that are aliased + * in the named use case device. + */ +const char *snd_use_case_get_device_ctl_elem_name(snd_use_case_mgr_t *uc_mgr, + enum snd_use_case_control_alias type, const char *device_name) +{ + struct use_case_device *device; + const char *kcontrol_name = NULL; + + pthread_mutex_lock(&uc_mgr->mutex); + + device = get_device(uc_mgr, device_name, NULL); + if (!device) { + uc_error("error: device %s not found", device_name); + goto out; + } + + switch (type) { + case SND_USE_CASE_ALIAS_PLAYBACK_VOLUME: + kcontrol_name = device->playback_volume_id; + break; + case SND_USE_CASE_ALIAS_CAPTURE_VOLUME: + kcontrol_name = device->capture_volume_id; + break; + case SND_USE_CASE_ALIAS_PLAYBACK_SWITCH: + kcontrol_name = device->playback_switch_id; + break; + case SND_USE_CASE_ALIAS_CAPTURE_SWITCH: + kcontrol_name = device->capture_switch_id; + break; + default: + uc_error("error: invalid control alias %d", type); + break; + } + +out: + pthread_mutex_unlock(&uc_mgr->mutex); + + return kcontrol_name; +} + +/** + * \brief Get volume/mute control IDs depending on use case modifier. + * \param uc_mgr use case manager + * \param type the control type we are looking for + * \param modifier_name The use case modifier we are interested in. + * \return ID if success, otherwise a negative error code + * + * Get the control id for common volume and mute controls that are aliased + * in the named use case device. + */ +const char *snd_use_case_get_modifier_ctl_elem_name(snd_use_case_mgr_t *uc_mgr, + enum snd_use_case_control_alias type, const char *modifier_name) +{ + struct use_case_modifier *modifier; + const char *kcontrol_name = NULL; + + pthread_mutex_lock(&uc_mgr->mutex); + + modifier = get_modifier(uc_mgr, modifier_name, NULL); + if (!modifier) { + uc_error("error: modifier %s not found", modifier_name); + goto out; + } + + switch (type) { + case SND_USE_CASE_ALIAS_PLAYBACK_VOLUME: + kcontrol_name = modifier->playback_volume_id; + break; + case SND_USE_CASE_ALIAS_CAPTURE_VOLUME: + kcontrol_name = modifier->capture_volume_id; + break; + case SND_USE_CASE_ALIAS_PLAYBACK_SWITCH: + kcontrol_name = modifier->playback_switch_id; + break; + case SND_USE_CASE_ALIAS_CAPTURE_SWITCH: + kcontrol_name = modifier->capture_switch_id; + break; + default: + uc_error("error: invalid control alias %d", type); + break; + } + +out: + pthread_mutex_unlock(&uc_mgr->mutex); + + return kcontrol_name; +} |