topology: add nhlt generation into topology2.0 pre-processing

Add optional generation of nhlt acpi table into topology2.0 processing.
Nhlt internal structure is defined in:
https://01.org/sites/default/files/595976_intel_sst_nhlt.pdf
Nhlt acpi table contain vendor specific binary data blobs that are used
in some Intel dsp platforms for configuring the dmic and ssp hardware.

The beef in this code is to generate the vendor specific binary blobs,
but as there is existing nhlt parser in kernel there's no point of
re-inventing the container: just use the existing nhlt acpi table
format. Basically this code is creating similar nhlt acpi table that you
would get from: cat /sys/firmware/acpi/tables/NHLT

Nhlt generation can be enabled with a alsatplg switch -l.

Nhlt generation is done by adding auto attribute function for
topology2.0 dai processing, saving parameters and generating the nhlt
struct after parsing. Nhlt struct is added into the manifest as bytes
field.

Nhlt processing uses a private data in tplg_pre_processor struct and
needs to be initialized before parsing starts. After all dais have been
parsed the nhlt can be created. Nhtl structs are almost direct copy from
related kernel header. Vendor specific blob generation will be added in
later commits.

Signed-off-by: Jaska Uimonen <[email protected]>

Author: Jaska Uimonen

topology/Makefile.am

@@ -9,9 +9,10 @@ endif
 	rst2man $< > $@
 
 alsatplg_SOURCES = topology.c pre-processor.c pre-process-class.c pre-process-object.c \
-		    pre-process-dapm.c pre-process-dai.c
+		pre-process-dapm.c pre-process-dai.c nhlt/nhlt-processor.c
 
-noinst_HEADERS = topology.h pre-processor.h
+noinst_HEADERS = topology.h pre-processor.h \
+		nhlt/nhlt-processor.h nhlt/nhlt.h
 
 AM_CPPFLAGS = \
          -Wall -I$(top_srcdir)/include

topology/nhlt/nhlt-processor.c

@@ -0,0 +1,290 @@
+/*
+  Copyright(c) 2021 Intel Corporation
+  All rights reserved.
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of version 2 of the GNU General Public License as
+  published by the Free Software Foundation.
+
+  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
+  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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+  The full GNU General Public License is included in this distribution
+  in the file called LICENSE.GPL.
+*/
+
+#include <errno.h>
+#include <stdio.h>
+#include <alsa/input.h>
+#include <alsa/output.h>
+#include <alsa/conf.h>
+#include <alsa/error.h>
+#include "pre-processor.h"
+#include "nhlt-processor.h"
+#include "nhlt.h"
+
+#define MAX_ENDPOINT_COUNT 20
+
+static int add_bytes_to_data_section(struct tplg_pre_processor *tplg_pp, char *src)
+{
+	const char *data_name = "nhlt";
+	snd_config_t *top_data_section;
+	snd_config_t *bytes;
+	snd_config_t *nhlt;
+	int ret;
+
+	/* add the nhlt bytes as new config into existing SectionData*/
+	ret = snd_config_search(tplg_pp->output_cfg, "SectionData", &top_data_section);
+	if (ret < 0)
+		return ret;
+
+	ret = tplg_config_make_add(&nhlt, data_name, SND_CONFIG_TYPE_COMPOUND, top_data_section);
+	if (ret < 0)
+		return ret;
+
+	ret = tplg_config_make_add(&bytes, "bytes", SND_CONFIG_TYPE_STRING, nhlt);
+	if (ret < 0) {
+		snd_config_delete(nhlt);
+		return ret;
+	}
+
+	ret = snd_config_set_string(bytes, src);
+	if (ret < 0) {
+		snd_config_delete(nhlt);
+		snd_config_delete(bytes);
+		return ret;
+	}
+
+	return 0;
+}
+
+static int add_to_manifest(struct tplg_pre_processor *tplg_pp, char *src)
+{
+	const char *data_name = "nhlt";
+	snd_config_t *manifest;
+	snd_config_t *man_inst;
+	snd_config_t *n;
+	snd_config_t *cfg_new;
+	snd_config_t *data;
+	snd_config_iterator_t i, next;
+	const char *id;
+	char *id_name;
+	int ret, id_num = 0;
+
+	/* find manifest section and its named instance */
+	ret = snd_config_search(tplg_pp->output_cfg, "SectionManifest", &manifest);
+	if (ret < 0)
+		return 0;
+
+	snd_config_for_each(i, next, manifest) {
+
+		n = snd_config_iterator_entry(i);
+
+		if (snd_config_get_id(n, &id) < 0)
+			continue;
+
+		if (!strcmp(id, "sof_manifest"))
+			man_inst = n;
+	}
+
+	/* if manifest not found, just exit */
+	if (!man_inst)
+		return 0;
+
+	ret = add_bytes_to_data_section(tplg_pp, src);
+	if (ret < 0)
+		return ret;
+
+	/* add the reference to the bytes into manifest data */
+	ret = snd_config_search(man_inst, "data", &data);
+	if (ret < 0)
+		return ret;
+
+	snd_config_for_each(i, next, data) {
+		const char *name;
+
+		n = snd_config_iterator_entry(i);
+		if (snd_config_get_string(n, &name) < 0)
+			continue;
+
+		/* item already exists */
+		if (!strcmp(name, data_name))
+			return 0;
+		id_num++;
+	}
+
+	/* add new item */
+	id_name = tplg_snprintf("%d", id_num);
+	if (!id_name)
+		return -ENOMEM;
+
+	ret = snd_config_make(&cfg_new, id_name, SND_CONFIG_TYPE_STRING);
+	free(id_name);
+	if (ret < 0)
+		return ret;
+
+	ret = snd_config_set_string(cfg_new, data_name);
+	if (ret < 0)
+		return ret;
+
+	ret = snd_config_add(data, cfg_new);
+	if (ret < 0)
+		snd_config_delete(cfg_new);
+
+	return 0;
+}
+
+static int print_nhlt_as_hex_bytes(struct nhlt *blob, struct endpoint_descriptor **eps, char *dst)
+{
+	uint8_t *top_p = (uint8_t *)blob;
+	struct endpoint_descriptor *ep;
+	uint8_t *ep_p;
+	int i, j;
+
+	for (i = 0; i < sizeof(struct nhlt); i++) {
+		snprintf(dst, 6, "0x%02x,", *top_p);
+		dst += 5;
+		top_p++;
+	}
+
+	for (i = 0; i < blob->endpoint_count; i++) {
+		ep = eps[i];
+		ep_p = (uint8_t *)ep;
+		printf("ep %i length is %u\n", i, ep->length);
+		for (j = 0; j < ep->length; j++) {
+			snprintf(dst, 6, "0x%02x,", *ep_p);
+			dst += 5;
+			ep_p++;
+		}
+	}
+
+	/* remove the last comma... */
+	dst--;
+	*dst = '\0';
+
+	return 0;
+}
+
+/* called at the beginning of topology pre-processing */
+int nhlt_init(struct tplg_pre_processor *tplg_pp)
+{
+	if (!tplg_pp)
+		return -EINVAL;
+
+	return 0;
+}
+
+/* called when exiting topology pre-processing */
+int nhlt_delete(struct tplg_pre_processor *tplg_pp)
+{
+	if (!tplg_pp)
+		return -EINVAL;
+
+	if(tplg_pp->private_data)
+		free(tplg_pp->private_data);
+
+	return 0;
+}
+
+/* called at the end of topology pre-processing */
+int nhlt_create(struct tplg_pre_processor *tplg_pp)
+{
+	struct endpoint_descriptor *eps[MAX_ENDPOINT_COUNT];
+	struct intel_nhlt_params *nhlt;
+	char *bytes_string_buffer;
+	int eps_count = 0;
+	struct nhlt blob;
+	size_t nhlt_size;
+	int ret;
+	int i;
+
+	nhlt = (struct intel_nhlt_params *)tplg_pp->private_data;
+	if (!nhlt)
+		return -EINVAL;
+
+	for (i = 0; i < MAX_ENDPOINT_COUNT; i++)
+		eps[i] = NULL;
+
+	/* we always have only 0 or 1 dmic ep */
+	if (nhlt_dmic_get_ep_count(tplg_pp)) {
+		/* the index is always 0 in dmic case */
+		ret = nhlt_dmic_get_ep(tplg_pp, &eps[eps_count], 0);
+		if (ret < 0)
+			return ret;
+		eps_count++;
+	}
+
+	/* we can have 0 to several ssp eps */
+	for (i = 0; i < nhlt_ssp_get_ep_count(tplg_pp); i++) {
+		ret = nhlt_ssp_get_ep(tplg_pp, &eps[eps_count], i);
+		if (ret < 0)
+			goto err;
+		eps_count++;
+	}
+
+	/* we don't have endpoints */
+	if (!eps_count)
+		return 0;
+
+	blob.efi_acpi.signature = 0;
+	blob.efi_acpi.length = 0;
+	blob.efi_acpi.revision = 0;
+	blob.efi_acpi.checksum = 0;
+	blob.efi_acpi.oem_id[6] = 0;
+	blob.efi_acpi.oem_table_id = 0;
+	blob.efi_acpi.oem_revision = 0;
+	blob.efi_acpi.creator_id = 0;
+	blob.efi_acpi.creator_revision = 0;
+
+	blob.endpoint_count = eps_count;
+
+	/* get blob total size */
+	nhlt_size = sizeof(struct nhlt);
+	for (i = 0; i < eps_count; i++) {
+		if (eps[i])
+			nhlt_size += eps[i]->length;
+	}
+
+	/* add the total length to top level struct */
+	blob.efi_acpi.length = nhlt_size;
+
+	/* allocate the bytes string, every byte is alsa conf byte string format "0xA1," */
+	bytes_string_buffer = calloc(nhlt_size * 5, sizeof(uint8_t));
+	if (!bytes_string_buffer) {
+		ret = -ENOMEM;
+		goto err;
+	}
+
+	/* print the whole thing in hex characters */
+	print_nhlt_as_hex_bytes(&blob, eps, bytes_string_buffer);
+
+	ret = add_to_manifest(tplg_pp, bytes_string_buffer);
+
+err:
+	/* remove all enpoints */
+	for (i = 0; i < eps_count; i++)
+		free(eps[i]);
+
+	free(bytes_string_buffer);
+
+	return ret;
+}
+
+/* called from pre-processor deferred dai processing */
+int nhlt_set_dai(struct tplg_pre_processor *tplg_pp,
+		 snd_config_t *cfg, snd_config_t *parent)
+{
+	const char *id;
+
+	if (snd_config_get_id(cfg, &id) < 0)
+		return -EINVAL;
+
+	/* set dai parameters here */
+
+	return 0;
+}

topology/nhlt/nhlt-processor.h

@@ -0,0 +1,31 @@
+/*
+  Copyright(c) 2021 Intel Corporation
+  All rights reserved.
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of version 2 of the GNU General Public License as
+  published by the Free Software Foundation.
+
+  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
+  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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+  The full GNU General Public License is included in this distribution
+  in the file called LICENSE.GPL.
+*/
+
+#ifndef __NHLT_PROCESSOR_H
+#define __NHLT_PROCESSOR_H
+
+#include "pre-processor.h"
+
+int nhlt_init(struct tplg_pre_processor *tplg_pp);
+int nhlt_set_dai(struct tplg_pre_processor *tplg_pp, snd_config_t *cfg, snd_config_t *parent);
+int nhlt_create(struct tplg_pre_processor *tplg_pp);
+int nhlt_delete(struct tplg_pre_processor *tplg_pp);
+
+#endif