aboutsummaryrefslogtreecommitdiff
path: root/drivers/core/acpi.c
blob: 0ebd288ab4209788dd0f93271e3dbcc18915dfef (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
// SPDX-License-Identifier: GPL-2.0+
/*
 * Core driver model support for ACPI table generation
 *
 * Copyright 2019 Google LLC
 * Written by Simon Glass <sjg@chromium.org>
 */

#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;
}