1 /*
2   Copyright(c) 2014-2015 Intel Corporation
3   All rights reserved.
4 
5   This library is free software; you can redistribute it and/or modify
6   it under the terms of the GNU Lesser General Public License as
7   published by the Free Software Foundation; either version 2.1 of
8   the License, or (at your option) any later version.
9 
10   This program is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13   GNU Lesser General Public License for more details.
14 
15   Authors: Mengdong Lin <mengdong.lin@intel.com>
16            Yao Jin <yao.jin@intel.com>
17            Liam Girdwood <liam.r.girdwood@linux.intel.com>
18 */
19 
20 #include "tplg_local.h"
21 #include <sys/stat.h>
22 
23 /*
24  * Get integer value
25  */
tplg_get_integer(snd_config_t *n, int *val, int base)26 int tplg_get_integer(snd_config_t *n, int *val, int base)
27 {
28 	const char *str;
29 	long lval;
30 	int err;
31 
32 	switch (snd_config_get_type(n)) {
33 	case SND_CONFIG_TYPE_INTEGER:
34 		err = snd_config_get_integer(n, &lval);
35 		if (err < 0)
36 			return err;
37 		goto __retval;
38 	case SND_CONFIG_TYPE_STRING:
39 		err = snd_config_get_string(n, &str);
40 		if (err < 0)
41 			return err;
42 		err = safe_strtol_base(str, &lval, base);
43 		if (err < 0)
44 			return err;
45 		goto __retval;
46 	default:
47 		return -EINVAL;
48 	}
49   __retval:
50 	if (lval < INT_MIN || lval > INT_MAX)
51 		return -ERANGE;
52 	*val = lval;
53 	return 0;
54 }
55 
56 /*
57  * Get unsigned integer value
58  */
tplg_get_unsigned(snd_config_t *n, unsigned *val, int base)59 int tplg_get_unsigned(snd_config_t *n, unsigned *val, int base)
60 {
61 	const char *str;
62 	long lval;
63 	long long llval;
64 	unsigned long uval;
65 	int err;
66 
67 	switch (snd_config_get_type(n)) {
68 	case SND_CONFIG_TYPE_INTEGER:
69 		err = snd_config_get_integer(n, &lval);
70 		if (err < 0)
71 			return err;
72 		if (lval < 0 && lval >= INT_MIN)
73 			lval = UINT_MAX + lval + 1;
74 		if (lval < 0 || lval > UINT_MAX)
75 			return -ERANGE;
76 		*val = lval;
77 		return err;
78 	case SND_CONFIG_TYPE_INTEGER64:
79 		err = snd_config_get_integer64(n, &llval);
80 		if (err < 0)
81 			return err;
82 		if (llval < 0 && llval >= INT_MIN)
83 			llval = UINT_MAX + llval + 1;
84 		if (llval < 0 || llval > UINT_MAX)
85 			return -ERANGE;
86 		*val = llval;
87 		return err;
88 	case SND_CONFIG_TYPE_STRING:
89 		err = snd_config_get_string(n, &str);
90 		if (err < 0)
91 			return err;
92 		errno = 0;
93 		uval = strtoul(str, NULL, base);
94 		if (errno == ERANGE && uval == ULONG_MAX)
95 			return -ERANGE;
96 		if (errno && uval == 0)
97 			return -EINVAL;
98 		if (uval > UINT_MAX)
99 			return -ERANGE;
100 		*val = uval;
101 		return 0;
102 	default:
103 		return -EINVAL;
104 	}
105 }
106 
107 /*
108  * Parse compound
109  */
tplg_parse_compound(snd_tplg_t *tplg, snd_config_t *cfg, int (*fcn)(snd_tplg_t *, snd_config_t *, void *), void *private)110 int tplg_parse_compound(snd_tplg_t *tplg, snd_config_t *cfg,
111 			int (*fcn)(snd_tplg_t *, snd_config_t *, void *),
112 			void *private)
113 {
114 	const char *id;
115 	snd_config_iterator_t i, next;
116 	snd_config_t *n;
117 	int err = -EINVAL;
118 
119 	if (snd_config_get_id(cfg, &id) < 0)
120 		return -EINVAL;
121 
122 	if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
123 		SNDERR("compound type expected for %s", id);
124 		return -EINVAL;
125 	}
126 
127 	/* parse compound */
128 	snd_config_for_each(i, next, cfg) {
129 		n = snd_config_iterator_entry(i);
130 
131 		if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
132 			SNDERR("compound type expected for %s, is %d",
133 				id, snd_config_get_type(cfg));
134 			return -EINVAL;
135 		}
136 
137 		err = fcn(tplg, n, private);
138 		if (err < 0)
139 			return err;
140 	}
141 
142 	return err;
143 }
144 
tplg_parse_config(snd_tplg_t *tplg, snd_config_t *cfg)145 static int tplg_parse_config(snd_tplg_t *tplg, snd_config_t *cfg)
146 {
147 	int (*parser)(snd_tplg_t *tplg, snd_config_t *cfg, void *priv);
148 	snd_config_iterator_t i, next;
149 	snd_config_t *n;
150 	const char *id;
151 	struct tplg_table *p;
152 	unsigned int idx;
153 	int err;
154 
155 	if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
156 		SNDERR("compound type expected at top level");
157 		return -EINVAL;
158 	}
159 
160 	/* parse topology config sections */
161 	snd_config_for_each(i, next, cfg) {
162 
163 		n = snd_config_iterator_entry(i);
164 		if (snd_config_get_id(n, &id) < 0)
165 			continue;
166 
167 		parser = NULL;
168 		for (idx = 0; idx < tplg_table_items; idx++) {
169 			p = &tplg_table[idx];
170 			if (p->id && strcmp(id, p->id) == 0) {
171 				parser = p->parse;
172 				break;
173 			}
174 			if (p->id2 && strcmp(id, p->id2) == 0) {
175 				parser = p->parse;
176 				break;
177 			}
178 		}
179 
180 		if (parser == NULL) {
181 			SNDERR("unknown section %s", id);
182 			continue;
183 		}
184 
185 		err = tplg_parse_compound(tplg, n, parser, NULL);
186 		if (err < 0)
187 			return err;
188 	}
189 	return 0;
190 }
191 
tplg_load_config(snd_tplg_t *tplg, snd_input_t *in)192 static int tplg_load_config(snd_tplg_t *tplg, snd_input_t *in)
193 {
194 	snd_config_t *top;
195 	int ret;
196 
197 	ret = snd_config_top(&top);
198 	if (ret < 0)
199 		return ret;
200 
201 	ret = snd_config_load(top, in);
202 	if (ret < 0) {
203 		SNDERR("could not load configuration");
204 		snd_config_delete(top);
205 		return ret;
206 	}
207 
208 	ret = tplg_parse_config(tplg, top);
209 	snd_config_delete(top);
210 	if (ret < 0) {
211 		SNDERR("failed to parse topology");
212 		return ret;
213 	}
214 
215 	return 0;
216 }
217 
tplg_build_integ(snd_tplg_t *tplg)218 static int tplg_build_integ(snd_tplg_t *tplg)
219 {
220 	int err;
221 
222 	err = tplg_build_data(tplg);
223 	if (err <  0)
224 		return err;
225 
226 	err = tplg_build_manifest_data(tplg);
227 	if (err <  0)
228 		return err;
229 
230 	err = tplg_build_controls(tplg);
231 	if (err <  0)
232 		return err;
233 
234 	err = tplg_build_widgets(tplg);
235 	if (err <  0)
236 		return err;
237 
238 	err = tplg_build_pcms(tplg, SND_TPLG_TYPE_PCM);
239 	if (err <  0)
240 		return err;
241 
242 	err = tplg_build_dais(tplg, SND_TPLG_TYPE_DAI);
243 	if (err <  0)
244 		return err;
245 
246 	err = tplg_build_links(tplg, SND_TPLG_TYPE_BE);
247 	if (err <  0)
248 		return err;
249 
250 	err = tplg_build_links(tplg, SND_TPLG_TYPE_CC);
251 	if (err <  0)
252 		return err;
253 
254 	err = tplg_build_routes(tplg);
255 	if (err <  0)
256 		return err;
257 
258 	return err;
259 }
260 
snd_tplg_load(snd_tplg_t *tplg, const char *buf, size_t size)261 int snd_tplg_load(snd_tplg_t *tplg, const char *buf, size_t size)
262 {
263 	snd_input_t *in;
264 	int err;
265 
266 	err = snd_input_buffer_open(&in, buf, size);
267 	if (err < 0) {
268 		SNDERR("could not create input buffer");
269 		return err;
270 	}
271 
272 	err = tplg_load_config(tplg, in);
273 	snd_input_close(in);
274 	return err;
275 }
276 
tplg_build(snd_tplg_t *tplg)277 static int tplg_build(snd_tplg_t *tplg)
278 {
279 	int err;
280 
281 	err = tplg_build_integ(tplg);
282 	if (err < 0) {
283 		SNDERR("failed to check topology integrity");
284 		return err;
285 	}
286 
287 	err = tplg_write_data(tplg);
288 	if (err < 0) {
289 		SNDERR("failed to write data %d", err);
290 		return err;
291 	}
292 	return 0;
293 }
294 
snd_tplg_build_file(snd_tplg_t *tplg, const char *infile, const char *outfile)295 int snd_tplg_build_file(snd_tplg_t *tplg,
296 			const char *infile,
297 			const char *outfile)
298 {
299 	FILE *fp;
300 	snd_input_t *in;
301 	int err;
302 
303 	fp = fopen(infile, "r");
304 	if (fp == NULL) {
305 		SNDERR("could not open configuration file %s", infile);
306 		return -errno;
307 	}
308 
309 	err = snd_input_stdio_attach(&in, fp, 1);
310 	if (err < 0) {
311 		fclose(fp);
312 		SNDERR("could not attach stdio %s", infile);
313 		return err;
314 	}
315 
316 	err = tplg_load_config(tplg, in);
317 	snd_input_close(in);
318 	if (err < 0)
319 		return err;
320 
321 	return snd_tplg_build(tplg, outfile);
322 }
323 
snd_tplg_add_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t)324 int snd_tplg_add_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t)
325 {
326 	switch (t->type) {
327 	case SND_TPLG_TYPE_MIXER:
328 		return tplg_add_mixer_object(tplg, t);
329 	case SND_TPLG_TYPE_ENUM:
330 		return tplg_add_enum_object(tplg, t);
331 	case SND_TPLG_TYPE_BYTES:
332 		return tplg_add_bytes_object(tplg, t);
333 	case SND_TPLG_TYPE_DAPM_WIDGET:
334 		return tplg_add_widget_object(tplg, t);
335 	case SND_TPLG_TYPE_DAPM_GRAPH:
336 		return tplg_add_graph_object(tplg, t);
337 	case SND_TPLG_TYPE_PCM:
338 		return tplg_add_pcm_object(tplg, t);
339 	case SND_TPLG_TYPE_DAI:
340 		return tplg_add_dai_object(tplg, t);
341 	case SND_TPLG_TYPE_LINK:
342 	case SND_TPLG_TYPE_BE:
343 	case SND_TPLG_TYPE_CC:
344 		return tplg_add_link_object(tplg, t);
345 	default:
346 		SNDERR("invalid object type %d", t->type);
347 		return -EINVAL;
348 	};
349 }
350 
snd_tplg_build(snd_tplg_t *tplg, const char *outfile)351 int snd_tplg_build(snd_tplg_t *tplg, const char *outfile)
352 {
353 	int fd, err;
354 	ssize_t r;
355 
356 	err = tplg_build(tplg);
357 	if (err < 0)
358 		return err;
359 
360 	fd = open(outfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
361 	if (fd < 0) {
362 		SNDERR("failed to open %s err %d", outfile, -errno);
363 		return -errno;
364 	}
365 	r = write(fd, tplg->bin, tplg->bin_size);
366 	close(fd);
367 	if (r < 0) {
368 		err = -errno;
369 		SNDERR("write error: %s", strerror(errno));
370 		return err;
371 	}
372 	if ((size_t)r != tplg->bin_size) {
373 		SNDERR("partial write (%zd != %zd)", r, tplg->bin_size);
374 		return -EIO;
375 	}
376 	return 0;
377 }
378 
snd_tplg_build_bin(snd_tplg_t *tplg, void **bin, size_t *size)379 int snd_tplg_build_bin(snd_tplg_t *tplg,
380 		       void **bin, size_t *size)
381 {
382 	int err;
383 
384 	err = tplg_build(tplg);
385 	if (err < 0)
386 		return err;
387 
388 	*bin = tplg->bin;
389 	*size = tplg->bin_size;
390 	tplg->bin = NULL;
391 	tplg->bin_size = tplg->bin_pos = 0;
392 	return 0;
393 }
394 
snd_tplg_set_manifest_data(snd_tplg_t *tplg, const void *data, int len)395 int snd_tplg_set_manifest_data(snd_tplg_t *tplg, const void *data, int len)
396 {
397 	struct tplg_elem *elem;
398 
399 	elem = tplg_elem_type_lookup(tplg, SND_TPLG_TYPE_MANIFEST);
400 	if (elem == NULL) {
401 		elem = tplg_elem_new_common(tplg, NULL, "manifest",
402 					    SND_TPLG_TYPE_MANIFEST);
403 		if (!elem)
404 			return -ENOMEM;
405 		tplg->manifest.size = elem->size;
406 	}
407 
408 	if (len <= 0)
409 		return 0;
410 
411 	return tplg_add_data_bytes(tplg, elem, NULL, data, len);
412 }
413 
snd_tplg_set_version(snd_tplg_t *tplg, unsigned int version)414 int snd_tplg_set_version(snd_tplg_t *tplg, unsigned int version)
415 {
416 	tplg->version = version;
417 
418 	return 0;
419 }
420 
snd_tplg_verbose(snd_tplg_t *tplg, int verbose)421 void snd_tplg_verbose(snd_tplg_t *tplg, int verbose)
422 {
423 	tplg->verbose = verbose;
424 }
425 
is_little_endian(void)426 static bool is_little_endian(void)
427 {
428 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_INT__ == 4
429 	return true;
430 #endif
431 	return false;
432 }
433 
snd_tplg_create(int flags)434 snd_tplg_t *snd_tplg_create(int flags)
435 {
436 	snd_tplg_t *tplg;
437 
438 	if (!is_little_endian()) {
439 		SNDERR("cannot support big-endian machines");
440 		return NULL;
441 	}
442 
443 	tplg = calloc(1, sizeof(snd_tplg_t));
444 	if (!tplg)
445 		return NULL;
446 
447 	tplg->verbose = !!(flags & SND_TPLG_CREATE_VERBOSE);
448 	tplg->dapm_sort = (flags & SND_TPLG_CREATE_DAPM_NOSORT) == 0;
449 
450 	tplg->manifest.size = sizeof(struct snd_soc_tplg_manifest);
451 
452 	INIT_LIST_HEAD(&tplg->tlv_list);
453 	INIT_LIST_HEAD(&tplg->widget_list);
454 	INIT_LIST_HEAD(&tplg->pcm_list);
455 	INIT_LIST_HEAD(&tplg->dai_list);
456 	INIT_LIST_HEAD(&tplg->be_list);
457 	INIT_LIST_HEAD(&tplg->cc_list);
458 	INIT_LIST_HEAD(&tplg->route_list);
459 	INIT_LIST_HEAD(&tplg->pdata_list);
460 	INIT_LIST_HEAD(&tplg->manifest_list);
461 	INIT_LIST_HEAD(&tplg->text_list);
462 	INIT_LIST_HEAD(&tplg->pcm_config_list);
463 	INIT_LIST_HEAD(&tplg->pcm_caps_list);
464 	INIT_LIST_HEAD(&tplg->mixer_list);
465 	INIT_LIST_HEAD(&tplg->enum_list);
466 	INIT_LIST_HEAD(&tplg->bytes_ext_list);
467 	INIT_LIST_HEAD(&tplg->token_list);
468 	INIT_LIST_HEAD(&tplg->tuple_list);
469 	INIT_LIST_HEAD(&tplg->hw_cfg_list);
470 
471 	return tplg;
472 }
473 
snd_tplg_new(void)474 snd_tplg_t *snd_tplg_new(void)
475 {
476 	return snd_tplg_create(0);
477 }
478 
snd_tplg_free(snd_tplg_t *tplg)479 void snd_tplg_free(snd_tplg_t *tplg)
480 {
481 	free(tplg->bin);
482 	free(tplg->manifest_pdata);
483 
484 	tplg_elem_free_list(&tplg->tlv_list);
485 	tplg_elem_free_list(&tplg->widget_list);
486 	tplg_elem_free_list(&tplg->pcm_list);
487 	tplg_elem_free_list(&tplg->dai_list);
488 	tplg_elem_free_list(&tplg->be_list);
489 	tplg_elem_free_list(&tplg->cc_list);
490 	tplg_elem_free_list(&tplg->route_list);
491 	tplg_elem_free_list(&tplg->pdata_list);
492 	tplg_elem_free_list(&tplg->manifest_list);
493 	tplg_elem_free_list(&tplg->text_list);
494 	tplg_elem_free_list(&tplg->pcm_config_list);
495 	tplg_elem_free_list(&tplg->pcm_caps_list);
496 	tplg_elem_free_list(&tplg->mixer_list);
497 	tplg_elem_free_list(&tplg->enum_list);
498 	tplg_elem_free_list(&tplg->bytes_ext_list);
499 	tplg_elem_free_list(&tplg->token_list);
500 	tplg_elem_free_list(&tplg->tuple_list);
501 	tplg_elem_free_list(&tplg->hw_cfg_list);
502 
503 	free(tplg);
504 }
505 
snd_tplg_version(void)506 const char *snd_tplg_version(void)
507 {
508 	return SND_LIB_VERSION_STR;
509 }
510