[u-boot.git] / drivers / core / acpi.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Core driver model support for ACPI table generation
 *
 * Copyright 2019 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEOGRY	LOGC_ACPI

#include <common.h>
#include <display_options.h>
#include <dm.h>
#include <log.h>
#include <malloc.h>
#include <mapmem.h>
#include <acpi/acpi_device.h>
#include <dm/acpi.h>
#include <dm/device-internal.h>
#include <dm/root.h>

#define MAX_ACPI_ITEMS	100

/**
 * Type of table that we collected
 *
 * @TYPE_NONE: Not yet known
 * @TYPE_SSDT: Items in the Secondary System Description Table
 * @TYPE_DSDT: Items in the Differentiated System Description Table
 * @TYPE_OTHER: Other (whole)
 */
enum gen_type_t {
	TYPE_NONE,
	TYPE_SSDT,
	TYPE_DSDT,
	TYPE_OTHER,
};

const char *gen_type_str[] = {
	"-",
	"ssdt",
	"dsdt",
	"other",
};

/* Type of method to call */
enum method_t {
	METHOD_WRITE_TABLES,
	METHOD_FILL_SSDT,
	METHOD_INJECT_DSDT,
	METHOD_SETUP_NHLT,
};

/* Prototype for all methods */
typedef int (*acpi_method)(const struct udevice *dev, struct acpi_ctx *ctx);

/**
 * struct acpi_item - Holds info about ACPI data generated by a driver method
 *
 * @dev: Device that generated this data
 * @type: Table type it refers to
 * @writer: Writer that wrote this table
 * @base: Pointer to base of table in its original location
 * @buf: Buffer allocated to contain the data (NULL if not allocated)
 * @size: Size of the data in bytes
 */
struct acpi_item {
	struct udevice *dev;
	const struct acpi_writer *writer;
	enum gen_type_t type;
	const char *base;
	char *buf;
	int size;
};

/* List of ACPI items collected */
static struct acpi_item acpi_item[MAX_ACPI_ITEMS];
static int item_count;

int acpi_copy_name(char *out_name, const char *name)
{
	strncpy(out_name, name, ACPI_NAME_LEN);
	out_name[ACPI_NAME_LEN] = '\0';

	return 0;
}

int acpi_get_name(const struct udevice *dev, char *out_name)
{
	struct acpi_ops *aops;
	const char *name;
	int ret;

	aops = device_get_acpi_ops(dev);
	if (aops && aops->get_name)
		return aops->get_name(dev, out_name);
	name = dev_read_string(dev, "acpi,name");
	if (name)
		return acpi_copy_name(out_name, name);
	ret = acpi_device_infer_name(dev, out_name);
	if (ret)
		return log_msg_ret("dev", ret);

	return 0;
}

int acpi_get_path(const struct udevice *dev, char *out_path, int maxlen)
{
	const char *path;
	int ret;

	path = dev_read_string(dev, "acpi,path");
	if (path) {
		if (strlen(path) >= maxlen)
			return -ENOSPC;
		strcpy(out_path, path);
		return 0;
	}
	ret = acpi_device_path(dev, out_path, maxlen);
	if (ret)
		return log_msg_ret("dev", ret);

	return 0;
}

/**
 * add_item() - Add a new item to the list of data collected
 *
 * @ctx: ACPI context
 * @dev: Device that generated the data, if type != TYPE_OTHER
 * @writer: Writer entry that generated the data, if type == TYPE_OTHER
 * @type: Table type it refers to
 * @start: The start of the data (the end is obtained from ctx->current)
 * Return: 0 if OK, -ENOSPC if too many items, -ENOMEM if out of memory
 */
static int add_item(struct acpi_ctx *ctx, struct udevice *dev,
		    const struct acpi_writer *writer, enum gen_type_t type,
		    void *start)
{
	struct acpi_item *item;
	void *end = ctx->current;

	if (item_count == MAX_ACPI_ITEMS) {
		log_err("Too many items\n");
		return log_msg_ret("mem", -ENOSPC);
	}

	item = &acpi_item[item_count];
	item->dev = dev;
	item->writer = writer;
	item->type = type;
	item->size = end - start;
	item->base = start;
	if (!item->size)
		return 0;
	if (type != TYPE_OTHER) {
		item->buf = malloc(item->size);
		if (!item->buf)
			return log_msg_ret("mem", -ENOMEM);
		memcpy(item->buf, start, item->size);
	}
	item_count++;
	log_debug("* %s: Added type %d, %p, size %x\n",
		  dev ? dev->name : "other", type, start, item->size);

	return 0;
}

int acpi_add_other_item(struct acpi_ctx *ctx, const struct acpi_writer *writer,
			void *start)
{
	return add_item(ctx, NULL, writer, TYPE_OTHER, start);
}

void acpi_dump_items(enum acpi_dump_option option)
{
	int i;

	printf("Seq  Type       Base   Size  Device/Writer\n");
	printf("---  -----  --------   ----  -------------\n");
	for (i = 0; i < item_count; i++) {
		struct acpi_item *item = &acpi_item[i];

		printf("%3x  %-5s  %8lx  %5x  %s\n", i,
		       gen_type_str[item->type],
		       (ulong)map_to_sysmem(item->base), item->size,
		       item->dev ? item->dev->name : item->writer->name);
		if (option == ACPI_DUMP_CONTENTS) {
			print_buffer(0, item->buf ? item->buf : item->base, 1,
				     item->size, 0);
			printf("\n");
		}
	}
}

static struct acpi_item *find_acpi_item(const char *devname)
{
	int i;

	for (i = 0; i < item_count; i++) {
		struct acpi_item *item = &acpi_item[i];

		if (item->dev && !strcmp(devname, item->dev->name))
			return item;
	}

	return NULL;
}

/**
 * sort_acpi_item_type - Sort the ACPI items into the desired order
 *
 * This looks up the ordering in the device tree and then adds each item one by
 * one into the supplied buffer
 *
 * @ctx: ACPI context
 * @start: Start position to put the sorted items. The items will follow each
 *	other in sorted order
 * @type: Type of items to sort
 * Return: 0 if OK, -ve on error
 */
static int sort_acpi_item_type(struct acpi_ctx *ctx, void *start,
			       enum gen_type_t type)
{
	const u32 *order;
	int size;
	int count;
	void *ptr;
	void *end = ctx->current;

	ptr = start;
	order = ofnode_read_chosen_prop(type == TYPE_DSDT ?
					"u-boot,acpi-dsdt-order" :
					"u-boot,acpi-ssdt-order", &size);
	if (!order) {
		log_debug("Failed to find ordering, leaving as is\n");
		return 0;
	}

	/*
	 * This algorithm rewrites the context buffer without changing its
	 * length. So there is no need to update ctx-current
	 */
	count = size / sizeof(u32);
	while (count--) {
		struct acpi_item *item;
		const char *name;
		ofnode node;

		node = ofnode_get_by_phandle(fdt32_to_cpu(*order++));
		name = ofnode_get_name(node);
		item = find_acpi_item(name);
		if (!item) {
			log_err("Failed to find item '%s'\n", name);
			return log_msg_ret("find", -ENOENT);
		}
		if (item->type == type) {
			log_debug("   - add %s\n", item->dev->name);
			memcpy(ptr, item->buf, item->size);
			ptr += item->size;
		}
	}

	/*
	 * If the sort order is missing an item then the output will be too
	 * small. Report this error since the item needs to be added to the
	 * ordering for the ACPI tables to be complete.
	 */
	if (ptr != end) {
		log_warning("*** Missing bytes: ptr=%p, end=%p\n", ptr, end);
		return -ENXIO;
	}

	return 0;
}

acpi_method acpi_get_method(struct udevice *dev, enum method_t method)
{
	struct acpi_ops *aops;

	aops = device_get_acpi_ops(dev);
	if (aops) {
		switch (method) {
		case METHOD_WRITE_TABLES:
			return aops->write_tables;
		case METHOD_FILL_SSDT:
			return aops->fill_ssdt;
		case METHOD_INJECT_DSDT:
			return aops->inject_dsdt;
		case METHOD_SETUP_NHLT:
			return aops->setup_nhlt;
		}
	}

	return NULL;
}

int acpi_recurse_method(struct acpi_ctx *ctx, struct udevice *parent,
			enum method_t method, enum gen_type_t type)
{
	struct udevice *dev;
	acpi_method func;
	int ret;

	func = acpi_get_method(parent, method);
	if (func) {
		log_debug("- method %d, %s %p\n", method, parent->name, func);
		ret = device_of_to_plat(parent);
		if (ret)
			return log_msg_ret("ofdata", ret);
		ctx->tab_start = ctx->current;
		ret = func(parent, ctx);
		if (ret)
			return log_msg_ret("func", ret);

		/* Add the item to the internal list */
		if (type != TYPE_NONE) {
			ret = add_item(ctx, parent, NULL, type, ctx->tab_start);
			if (ret)
				return log_msg_ret("add", ret);
		}
	}
	device_foreach_child(dev, parent) {
		ret = acpi_recurse_method(ctx, dev, method, type);
		if (ret)
			return log_msg_ret("recurse", ret);
	}

	return 0;
}

int acpi_fill_ssdt(struct acpi_ctx *ctx)
{
	void *start = ctx->current;
	int ret;

	log_debug("Writing SSDT tables\n");
	ret = acpi_recurse_method(ctx, dm_root(), METHOD_FILL_SSDT, TYPE_SSDT);
	log_debug("Writing SSDT finished, err=%d\n", ret);
	ret = sort_acpi_item_type(ctx, start, TYPE_SSDT);
	if (ret)
		return log_msg_ret("build", ret);

	return ret;
}

int acpi_inject_dsdt(struct acpi_ctx *ctx)
{
	void *start = ctx->current;
	int ret;

	log_debug("Writing DSDT tables\n");
	ret = acpi_recurse_method(ctx, dm_root(), METHOD_INJECT_DSDT,
				  TYPE_DSDT);
	log_debug("Writing DSDT finished, err=%d\n", ret);
	ret = sort_acpi_item_type(ctx, start, TYPE_DSDT);
	if (ret)
		return log_msg_ret("build", ret);

	return ret;
}

void acpi_reset_items(void)
{
	item_count = 0;
}

int acpi_write_dev_tables(struct acpi_ctx *ctx)
{
	int ret;

	log_debug("Writing device tables\n");
	ret = acpi_recurse_method(ctx, dm_root(), METHOD_WRITE_TABLES,
				  TYPE_NONE);
	log_debug("Writing finished, err=%d\n", ret);

	return ret;
}

int acpi_setup_nhlt(struct acpi_ctx *ctx, struct nhlt *nhlt)
{
	int ret;

	log_debug("Setup NHLT\n");
	ctx->nhlt = nhlt;
	ret = acpi_recurse_method(ctx, dm_root(), METHOD_SETUP_NHLT, TYPE_NONE);
	log_debug("Setup finished, err=%d\n", ret);

	return ret;
}
Commit	Line	Data
7ca2850c SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Core driver model support for ACPI table generation
	4	*
	5	* Copyright 2019 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
	9	#define LOG_CATEOGRY LOGC_ACPI
	10
	11	#include <common.h>
4e4bf944	12	#include <display_options.h>
7ca2850c	13	#include <dm.h>
f7ae49fc	14	#include <log.h>
fefac0b0	15	#include <malloc.h>
a9246416	16	#include <mapmem.h>
fefac0b0	17	#include <acpi/acpi_device.h>
7ca2850c	18	#include <dm/acpi.h>
93f7f827	19	#include <dm/device-internal.h>
7ca2850c SG	20	#include <dm/root.h>
7ca2850c SG	21
64ba6f43 SG	22	#define MAX_ACPI_ITEMS 100
64ba6f43 SG	23
2d7c7382 SG	24	/**
	25	* Type of table that we collected
	26	*
	27	* @TYPE_NONE: Not yet known
	28	* @TYPE_SSDT: Items in the Secondary System Description Table
	29	* @TYPE_DSDT: Items in the Differentiated System Description Table
	30	* @TYPE_OTHER: Other (whole)
	31	*/
64ba6f43 SG	32	enum gen_type_t {
	33	TYPE_NONE,
	34	TYPE_SSDT,
01694589	35	TYPE_DSDT,
2d7c7382	36	TYPE_OTHER,
64ba6f43 SG	37	};
64ba6f43 SG	38
a9246416 SG	39	const char *gen_type_str[] = {
	40	"-",
	41	"ssdt",
	42	"dsdt",
	43	"other",
	44	};
	45
93f7f827 SG	46	/* Type of method to call */
	47	enum method_t {
	48	METHOD_WRITE_TABLES,
b5183172	49	METHOD_FILL_SSDT,
01694589	50	METHOD_INJECT_DSDT,
b4e84334	51	METHOD_SETUP_NHLT,
93f7f827 SG	52	};
	53
	54	/* Prototype for all methods */
	55	typedef int (acpi_method)(const struct udevice dev, struct acpi_ctx *ctx);
	56
64ba6f43 SG	57	/**
	58	* struct acpi_item - Holds info about ACPI data generated by a driver method
	59	*
	60	* @dev: Device that generated this data
	61	* @type: Table type it refers to
2d7c7382	62	* @writer: Writer that wrote this table
a9246416 SG	63	* @base: Pointer to base of table in its original location
a9246416 SG	64	* @buf: Buffer allocated to contain the data (NULL if not allocated)
64ba6f43 SG	65	* @size: Size of the data in bytes
	66	*/
	67	struct acpi_item {
	68	struct udevice *dev;
2d7c7382	69	const struct acpi_writer *writer;
64ba6f43	70	enum gen_type_t type;
a9246416	71	const char *base;
64ba6f43 SG	72	char *buf;
	73	int size;
	74	};
	75
	76	/* List of ACPI items collected */
	77	static struct acpi_item acpi_item[MAX_ACPI_ITEMS];
	78	static int item_count;
	79
7ca2850c SG	80	int acpi_copy_name(char out_name, const char name)
	81	{
	82	strncpy(out_name, name, ACPI_NAME_LEN);
	83	out_name[ACPI_NAME_LEN] = '\0';
	84
	85	return 0;
	86	}
	87
	88	int acpi_get_name(const struct udevice dev, char out_name)
	89	{
	90	struct acpi_ops *aops;
fefac0b0 SG	91	const char *name;
fefac0b0 SG	92	int ret;
7ca2850c SG	93
	94	aops = device_get_acpi_ops(dev);
	95	if (aops && aops->get_name)
	96	return aops->get_name(dev, out_name);
fefac0b0 SG	97	name = dev_read_string(dev, "acpi,name");
	98	if (name)
	99	return acpi_copy_name(out_name, name);
	100	ret = acpi_device_infer_name(dev, out_name);
	101	if (ret)
	102	return log_msg_ret("dev", ret);
7ca2850c	103
fefac0b0	104	return 0;
7ca2850c	105	}
93f7f827	106
f1858957 SG	107	int acpi_get_path(const struct udevice dev, char out_path, int maxlen)
	108	{
	109	const char *path;
	110	int ret;
	111
	112	path = dev_read_string(dev, "acpi,path");
	113	if (path) {
	114	if (strlen(path) >= maxlen)
aa4ad8bb	115	return -ENOSPC;
f1858957 SG	116	strcpy(out_path, path);
	117	return 0;
	118	}
	119	ret = acpi_device_path(dev, out_path, maxlen);
	120	if (ret)
	121	return log_msg_ret("dev", ret);
	122
	123	return 0;
	124	}
	125
64ba6f43	126	/**
2d7c7382	127	* add_item() - Add a new item to the list of data collected
64ba6f43 SG	128	*
64ba6f43 SG	129	* @ctx: ACPI context
2d7c7382 SG	130	* @dev: Device that generated the data, if type != TYPE_OTHER
2d7c7382 SG	131	* @writer: Writer entry that generated the data, if type == TYPE_OTHER
64ba6f43 SG	132	* @type: Table type it refers to
64ba6f43 SG	133	* @start: The start of the data (the end is obtained from ctx->current)
185f812c	134	* Return: 0 if OK, -ENOSPC if too many items, -ENOMEM if out of memory
64ba6f43	135	*/
2d7c7382 SG	136	static int add_item(struct acpi_ctx ctx, struct udevice dev,
	137	const struct acpi_writer *writer, enum gen_type_t type,
	138	void *start)
64ba6f43 SG	139	{
	140	struct acpi_item *item;
	141	void *end = ctx->current;
	142
	143	if (item_count == MAX_ACPI_ITEMS) {
	144	log_err("Too many items\n");
	145	return log_msg_ret("mem", -ENOSPC);
	146	}
	147
	148	item = &acpi_item[item_count];
	149	item->dev = dev;
2d7c7382	150	item->writer = writer;
64ba6f43 SG	151	item->type = type;
64ba6f43 SG	152	item->size = end - start;
a9246416	153	item->base = start;
64ba6f43 SG	154	if (!item->size)
64ba6f43 SG	155	return 0;
2d7c7382 SG	156	if (type != TYPE_OTHER) {
	157	item->buf = malloc(item->size);
	158	if (!item->buf)
	159	return log_msg_ret("mem", -ENOMEM);
	160	memcpy(item->buf, start, item->size);
	161	}
64ba6f43	162	item_count++;
53fbaa4a HS	163	log_debug("* %s: Added type %d, %p, size %x\n",
53fbaa4a HS	164	dev ? dev->name : "other", type, start, item->size);
64ba6f43 SG	165
	166	return 0;
	167	}
	168
2d7c7382 SG	169	int acpi_add_other_item(struct acpi_ctx ctx, const struct acpi_writer writer,
	170	void *start)
	171	{
	172	return add_item(ctx, NULL, writer, TYPE_OTHER, start);
	173	}
	174
a4f82089 SG	175	void acpi_dump_items(enum acpi_dump_option option)
	176	{
	177	int i;
	178
a9246416 SG	179	printf("Seq Type Base Size Device/Writer\n");
a9246416 SG	180	printf("--- ----- -------- ---- -------------\n");
a4f82089 SG	181	for (i = 0; i < item_count; i++) {
	182	struct acpi_item *item = &acpi_item[i];
	183
a9246416 SG	184	printf("%3x %-5s %8lx %5x %s\n", i,
	185	gen_type_str[item->type],
	186	(ulong)map_to_sysmem(item->base), item->size,
	187	item->dev ? item->dev->name : item->writer->name);
a4f82089	188	if (option == ACPI_DUMP_CONTENTS) {
a9246416 SG	189	print_buffer(0, item->buf ? item->buf : item->base, 1,
a9246416 SG	190	item->size, 0);
a4f82089 SG	191	printf("\n");
	192	}
	193	}
	194	}
	195
0f7b111f SG	196	static struct acpi_item find_acpi_item(const char devname)
	197	{
	198	int i;
	199
	200	for (i = 0; i < item_count; i++) {
	201	struct acpi_item *item = &acpi_item[i];
	202
2d7c7382	203	if (item->dev && !strcmp(devname, item->dev->name))
0f7b111f SG	204	return item;
	205	}
	206
	207	return NULL;
	208	}
	209
	210	/**
	211	* sort_acpi_item_type - Sort the ACPI items into the desired order
	212	*
	213	* This looks up the ordering in the device tree and then adds each item one by
	214	* one into the supplied buffer
	215	*
	216	* @ctx: ACPI context
	217	* @start: Start position to put the sorted items. The items will follow each
	218	* other in sorted order
	219	* @type: Type of items to sort
185f812c	220	* Return: 0 if OK, -ve on error
0f7b111f SG	221	*/
	222	static int sort_acpi_item_type(struct acpi_ctx ctx, void start,
	223	enum gen_type_t type)
	224	{
	225	const u32 *order;
	226	int size;
	227	int count;
	228	void *ptr;
	229	void *end = ctx->current;
	230
	231	ptr = start;
01694589 SG	232	order = ofnode_read_chosen_prop(type == TYPE_DSDT ?
	233	"u-boot,acpi-dsdt-order" :
	234	"u-boot,acpi-ssdt-order", &size);
0f7b111f	235	if (!order) {
d2ee543a	236	log_debug("Failed to find ordering, leaving as is\n");
0f7b111f SG	237	return 0;
	238	}
	239
	240	/*
	241	* This algorithm rewrites the context buffer without changing its
	242	* length. So there is no need to update ctx-current
	243	*/
	244	count = size / sizeof(u32);
	245	while (count--) {
	246	struct acpi_item *item;
	247	const char *name;
	248	ofnode node;
	249
	250	node = ofnode_get_by_phandle(fdt32_to_cpu(*order++));
	251	name = ofnode_get_name(node);
	252	item = find_acpi_item(name);
	253	if (!item) {
	254	log_err("Failed to find item '%s'\n", name);
	255	return log_msg_ret("find", -ENOENT);
	256	}
	257	if (item->type == type) {
	258	log_debug(" - add %s\n", item->dev->name);
	259	memcpy(ptr, item->buf, item->size);
	260	ptr += item->size;
	261	}
	262	}
	263
	264	/*
	265	* If the sort order is missing an item then the output will be too
	266	* small. Report this error since the item needs to be added to the
	267	* ordering for the ACPI tables to be complete.
	268	*/
	269	if (ptr != end) {
	270	log_warning("*** Missing bytes: ptr=%p, end=%p\n", ptr, end);
	271	return -ENXIO;
	272	}
	273
	274	return 0;
	275	}
	276
93f7f827 SG	277	acpi_method acpi_get_method(struct udevice *dev, enum method_t method)
	278	{
	279	struct acpi_ops *aops;
	280
	281	aops = device_get_acpi_ops(dev);
	282	if (aops) {
	283	switch (method) {
	284	case METHOD_WRITE_TABLES:
	285	return aops->write_tables;
b5183172 SG	286	case METHOD_FILL_SSDT:
b5183172 SG	287	return aops->fill_ssdt;
01694589 SG	288	case METHOD_INJECT_DSDT:
01694589 SG	289	return aops->inject_dsdt;
b4e84334 SG	290	case METHOD_SETUP_NHLT:
b4e84334 SG	291	return aops->setup_nhlt;
93f7f827 SG	292	}
	293	}
	294
	295	return NULL;
	296	}
	297
	298	int acpi_recurse_method(struct acpi_ctx ctx, struct udevice parent,
64ba6f43	299	enum method_t method, enum gen_type_t type)
93f7f827 SG	300	{
	301	struct udevice *dev;
	302	acpi_method func;
	303	int ret;
	304
	305	func = acpi_get_method(parent, method);
	306	if (func) {
18434aec	307	log_debug("- method %d, %s %p\n", method, parent->name, func);
d1998a9f	308	ret = device_of_to_plat(parent);
93f7f827 SG	309	if (ret)
93f7f827 SG	310	return log_msg_ret("ofdata", ret);
fb746fde	311	ctx->tab_start = ctx->current;
93f7f827 SG	312	ret = func(parent, ctx);
	313	if (ret)
	314	return log_msg_ret("func", ret);
64ba6f43 SG	315
	316	/* Add the item to the internal list */
	317	if (type != TYPE_NONE) {
2d7c7382	318	ret = add_item(ctx, parent, NULL, type, ctx->tab_start);
64ba6f43 SG	319	if (ret)
	320	return log_msg_ret("add", ret);
	321	}
93f7f827 SG	322	}
93f7f827 SG	323	device_foreach_child(dev, parent) {
64ba6f43	324	ret = acpi_recurse_method(ctx, dev, method, type);
93f7f827 SG	325	if (ret)
	326	return log_msg_ret("recurse", ret);
	327	}
	328
	329	return 0;
	330	}
	331
b5183172 SG	332	int acpi_fill_ssdt(struct acpi_ctx *ctx)
b5183172 SG	333	{
0f7b111f	334	void *start = ctx->current;
b5183172 SG	335	int ret;
	336
	337	log_debug("Writing SSDT tables\n");
64ba6f43	338	ret = acpi_recurse_method(ctx, dm_root(), METHOD_FILL_SSDT, TYPE_SSDT);
b5183172	339	log_debug("Writing SSDT finished, err=%d\n", ret);
0f7b111f SG	340	ret = sort_acpi_item_type(ctx, start, TYPE_SSDT);
	341	if (ret)
	342	return log_msg_ret("build", ret);
b5183172 SG	343
	344	return ret;
	345	}
	346
01694589 SG	347	int acpi_inject_dsdt(struct acpi_ctx *ctx)
	348	{
	349	void *start = ctx->current;
	350	int ret;
	351
	352	log_debug("Writing DSDT tables\n");
01694589 SG	353	ret = acpi_recurse_method(ctx, dm_root(), METHOD_INJECT_DSDT,
	354	TYPE_DSDT);
	355	log_debug("Writing DSDT finished, err=%d\n", ret);
	356	ret = sort_acpi_item_type(ctx, start, TYPE_DSDT);
	357	if (ret)
	358	return log_msg_ret("build", ret);
	359
	360	return ret;
	361	}
	362
18434aec SG	363	void acpi_reset_items(void)
	364	{
	365	item_count = 0;
	366	}
	367
93f7f827 SG	368	int acpi_write_dev_tables(struct acpi_ctx *ctx)
	369	{
	370	int ret;
	371
	372	log_debug("Writing device tables\n");
64ba6f43 SG	373	ret = acpi_recurse_method(ctx, dm_root(), METHOD_WRITE_TABLES,
64ba6f43 SG	374	TYPE_NONE);
93f7f827 SG	375	log_debug("Writing finished, err=%d\n", ret);
	376
	377	return ret;
	378	}
b4e84334 SG	379
	380	int acpi_setup_nhlt(struct acpi_ctx ctx, struct nhlt nhlt)
	381	{
	382	int ret;
	383
	384	log_debug("Setup NHLT\n");
	385	ctx->nhlt = nhlt;
	386	ret = acpi_recurse_method(ctx, dm_root(), METHOD_SETUP_NHLT, TYPE_NONE);
	387	log_debug("Setup finished, err=%d\n", ret);
	388
	389	return ret;
	390	}