/*
Copyright(c) 2014-2015 Intel Corporation
All rights reserved.
This library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include <sys/stat.h>
#include "list.h"
#include "tplg_local.h"
/*
* Parse compound
*/
int tplg_parse_compound(snd_tplg_t *tplg, snd_config_t *cfg,
int (*fcn)(snd_tplg_t *, snd_config_t *, void *),
void *private)
{
const char *id;
snd_config_iterator_t i, next;
snd_config_t *n;
int err = -EINVAL;
if (snd_config_get_id(cfg, &id) < 0)
return -EINVAL;
if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
SNDERR("error: compound type expected for %s", id);
return -EINVAL;
}
/* parse compound */
snd_config_for_each(i, next, cfg) {
n = snd_config_iterator_entry(i);
if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
SNDERR("error: compound type expected for %s, is %d",
id, snd_config_get_type(cfg));
return -EINVAL;
}
err = fcn(tplg, n, private);
if (err < 0)
return err;
}
return err;
}
static int tplg_parse_config(snd_tplg_t *tplg, snd_config_t *cfg)
{
snd_config_iterator_t i, next;
snd_config_t *n;
const char *id;
int err;
if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
SNDERR("error: compound type expected at top level");
return -EINVAL;
}
/* parse topology config sections */
snd_config_for_each(i, next, cfg) {
n = snd_config_iterator_entry(i);
if (snd_config_get_id(n, &id) < 0)
continue;
if (strcmp(id, "SectionTLV") == 0) {
err = tplg_parse_compound(tplg, n, tplg_parse_tlv,
NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionControlMixer") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_control_mixer, NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionControlEnum") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_control_enum, NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionControlBytes") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_control_bytes, NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionWidget") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_dapm_widget, NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionPCMCapabilities") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_stream_caps, NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionPCM") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_pcm, NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionDAI") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_dai, NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionHWConfig") == 0) {
err = tplg_parse_compound(tplg, n, tplg_parse_hw_config,
NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionLink") == 0
|| strcmp(id, "SectionBE") == 0) {
err = tplg_parse_compound(tplg, n, tplg_parse_link,
NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionCC") == 0) {
err = tplg_parse_compound(tplg, n, tplg_parse_cc,
NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionGraph") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_dapm_graph, NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionText") == 0) {
err = tplg_parse_compound(tplg, n, tplg_parse_text,
NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionData") == 0) {
err = tplg_parse_compound(tplg, n, tplg_parse_data,
NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionVendorTokens") == 0) {
err = tplg_parse_compound(tplg, n, tplg_parse_tokens,
NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionVendorTuples") == 0) {
err = tplg_parse_compound(tplg, n, tplg_parse_tuples,
NULL);
if (err < 0)
return err;
continue;
}
if (strcmp(id, "SectionManifest") == 0) {
err = tplg_parse_compound(tplg, n,
tplg_parse_manifest_data,
NULL);
if (err < 0)
return err;
continue;
}
SNDERR("error: unknown section %s\n", id);
}
return 0;
}
static int tplg_load_config(const char *file, snd_config_t **cfg)
{
FILE *fp;
snd_input_t *in;
snd_config_t *top;
int ret;
fp = fopen(file, "r");
if (fp == NULL) {
SNDERR("error: could not open configuration file %s",
file);
return -errno;
}
ret = snd_input_stdio_attach(&in, fp, 1);
if (ret < 0) {
fclose(fp);
SNDERR("error: could not attach stdio %s", file);
return ret;
}
ret = snd_config_top(&top);
if (ret < 0)
goto err;
ret = snd_config_load(top, in);
if (ret < 0) {
SNDERR("error: could not load configuration file %s",
file);
goto err_load;
}
ret = snd_input_close(in);
if (ret < 0) {
in = NULL;
goto err_load;
}
*cfg = top;
return 0;
err_load:
snd_config_delete(top);
err:
if (in)
snd_input_close(in);
return ret;
}
static int tplg_build_integ(snd_tplg_t *tplg)
{
int err;
err = tplg_build_data(tplg);
if (err < 0)
return err;
err = tplg_build_manifest_data(tplg);
if (err < 0)
return err;
err = tplg_build_controls(tplg);
if (err < 0)
return err;
err = tplg_build_widgets(tplg);
if (err < 0)
return err;
err = tplg_build_pcms(tplg, SND_TPLG_TYPE_PCM);
if (err < 0)
return err;
err = tplg_build_dais(tplg, SND_TPLG_TYPE_DAI);
if (err < 0)
return err;
err = tplg_build_links(tplg, SND_TPLG_TYPE_BE);
if (err < 0)
return err;
err = tplg_build_links(tplg, SND_TPLG_TYPE_CC);
if (err < 0)
return err;
err = tplg_build_routes(tplg);
if (err < 0)
return err;
return err;
}
int snd_tplg_build_file(snd_tplg_t *tplg, const char *infile,
const char *outfile)
{
snd_config_t *cfg = NULL;
int err = 0;
tplg->out_fd =
open(outfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
if (tplg->out_fd < 0) {
SNDERR("error: failed to open %s err %d\n",
outfile, -errno);
return -errno;
}
err = tplg_load_config(infile, &cfg);
if (err < 0) {
SNDERR("error: failed to load topology file %s\n",
infile);
goto out_close;
}
err = tplg_parse_config(tplg, cfg);
if (err < 0) {
SNDERR("error: failed to parse topology\n");
goto out;
}
err = tplg_build_integ(tplg);
if (err < 0) {
SNDERR("error: failed to check topology integrity\n");
goto out;
}
err = tplg_write_data(tplg);
if (err < 0) {
SNDERR("error: failed to write data %d\n", err);
goto out;
}
out:
snd_config_delete(cfg);
out_close:
close(tplg->out_fd);
return err;
}
int snd_tplg_add_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t)
{
switch (t->type) {
case SND_TPLG_TYPE_MIXER:
return tplg_add_mixer_object(tplg, t);
case SND_TPLG_TYPE_ENUM:
return tplg_add_enum_object(tplg, t);
case SND_TPLG_TYPE_BYTES:
return tplg_add_bytes_object(tplg, t);
case SND_TPLG_TYPE_DAPM_WIDGET:
return tplg_add_widget_object(tplg, t);
case SND_TPLG_TYPE_DAPM_GRAPH:
return tplg_add_graph_object(tplg, t);
case SND_TPLG_TYPE_PCM:
return tplg_add_pcm_object(tplg, t);
case SND_TPLG_TYPE_DAI:
return tplg_add_dai_object(tplg, t);
case SND_TPLG_TYPE_LINK:
case SND_TPLG_TYPE_BE:
case SND_TPLG_TYPE_CC:
return tplg_add_link_object(tplg, t);
default:
SNDERR("error: invalid object type %d\n", t->type);
return -EINVAL;
};
}
int snd_tplg_build(snd_tplg_t *tplg, const char *outfile)
{
int err;
tplg->out_fd =
open(outfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
if (tplg->out_fd < 0) {
SNDERR("error: failed to open %s err %d\n",
outfile, -errno);
return -errno;
}
err = tplg_build_integ(tplg);
if (err < 0) {
SNDERR("error: failed to check topology integrity\n");
goto out;
}
err = tplg_write_data(tplg);
if (err < 0) {
SNDERR("error: failed to write data %d\n", err);
goto out;
}
out:
close(tplg->out_fd);
return err;
}
int snd_tplg_set_manifest_data(snd_tplg_t *tplg, const void *data, int len)
{
if (len <= 0)
return 0;
tplg->manifest.priv.size = len;
tplg->manifest_pdata = malloc(len);
if (!tplg->manifest_pdata)
return -ENOMEM;
memcpy(tplg->manifest_pdata, data, len);
return 0;
}
int snd_tplg_set_version(snd_tplg_t *tplg, unsigned int version)
{
tplg->version = version;
return 0;
}
void snd_tplg_verbose(snd_tplg_t *tplg, int verbose)
{
tplg->verbose = verbose;
}
static bool is_little_endian(void)
{
#ifdef __BYTE_ORDER
#if __BYTE_ORDER == __LITTLE_ENDIAN
return true;
#endif
#endif
return false;
}
snd_tplg_t *snd_tplg_new(void)
{
snd_tplg_t *tplg;
if (!is_little_endian()) {
SNDERR("error: cannot support big-endian machines\n");
return NULL;
}
tplg = calloc(1, sizeof(snd_tplg_t));
if (!tplg)
return NULL;
tplg->manifest.size = sizeof(struct snd_soc_tplg_manifest);
INIT_LIST_HEAD(&tplg->tlv_list);
INIT_LIST_HEAD(&tplg->widget_list);
INIT_LIST_HEAD(&tplg->pcm_list);
INIT_LIST_HEAD(&tplg->dai_list);
INIT_LIST_HEAD(&tplg->be_list);
INIT_LIST_HEAD(&tplg->cc_list);
INIT_LIST_HEAD(&tplg->route_list);
INIT_LIST_HEAD(&tplg->pdata_list);
INIT_LIST_HEAD(&tplg->manifest_list);
INIT_LIST_HEAD(&tplg->text_list);
INIT_LIST_HEAD(&tplg->pcm_config_list);
INIT_LIST_HEAD(&tplg->pcm_caps_list);
INIT_LIST_HEAD(&tplg->mixer_list);
INIT_LIST_HEAD(&tplg->enum_list);
INIT_LIST_HEAD(&tplg->bytes_ext_list);
INIT_LIST_HEAD(&tplg->token_list);
INIT_LIST_HEAD(&tplg->tuple_list);
INIT_LIST_HEAD(&tplg->hw_cfg_list);
return tplg;
}
void snd_tplg_free(snd_tplg_t *tplg)
{
if (tplg->manifest_pdata)
free(tplg->manifest_pdata);
tplg_elem_free_list(&tplg->tlv_list);
tplg_elem_free_list(&tplg->widget_list);
tplg_elem_free_list(&tplg->pcm_list);
tplg_elem_free_list(&tplg->dai_list);
tplg_elem_free_list(&tplg->be_list);
tplg_elem_free_list(&tplg->cc_list);
tplg_elem_free_list(&tplg->route_list);
tplg_elem_free_list(&tplg->pdata_list);
tplg_elem_free_list(&tplg->manifest_list);
tplg_elem_free_list(&tplg->text_list);
tplg_elem_free_list(&tplg->pcm_config_list);
tplg_elem_free_list(&tplg->pcm_caps_list);
tplg_elem_free_list(&tplg->mixer_list);
tplg_elem_free_list(&tplg->enum_list);
tplg_elem_free_list(&tplg->bytes_ext_list);
tplg_elem_free_list(&tplg->token_list);
tplg_elem_free_list(&tplg->tuple_list);
tplg_elem_free_list(&tplg->hw_cfg_list);
free(tplg);
}