acpidb.c revision 330449 
1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2000-2002 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 *	$FreeBSD: stable/11/usr.sbin/acpi/acpidb/acpidb.c 330449 2018-03-05 07:26:05Z eadler $
29 */
30
31#include <sys/param.h>
32#include <sys/queue.h>
33#include <sys/mman.h>
34#include <sys/stat.h>
35#include <sys/stdint.h>
36#include <sys/types.h>
37
38#include <assert.h>
39#include <ctype.h>
40#include <err.h>
41#include <fcntl.h>
42#include <limits.h>
43#include <stdio.h>
44#include <stdlib.h>
45#include <unistd.h>
46
47#include <contrib/dev/acpica/include/acpi.h>
48#include <contrib/dev/acpica/include/accommon.h>
49#include <contrib/dev/acpica/include/acapps.h>
50#include <contrib/dev/acpica/include/acdebug.h>
51#include <contrib/dev/acpica/include/amlresrc.h>
52
53/*
54 * Dummy DSDT Table Header
55 */
56
57static ACPI_TABLE_HEADER dummy_dsdt_table = {
58	"DSDT", 123, 1, 123, "OEMID", "OEMTBLID", 1, "CRID", 1
59};
60
61/*
62 * Region space I/O routines on virtual machine
63 */
64
65static int	aml_debug_prompt = 1;
66
67struct ACPIRegionContent {
68	TAILQ_ENTRY(ACPIRegionContent) links;
69	int			regtype;
70	ACPI_PHYSICAL_ADDRESS	addr;
71	UINT8			value;
72};
73
74TAILQ_HEAD(ACPIRegionContentList, ACPIRegionContent);
75static struct	ACPIRegionContentList RegionContentList;
76
77static int		 aml_simulation_initialized = 0;
78
79ACPI_PHYSICAL_ADDRESS	 AeLocalGetRootPointer(void);
80void			 AeDoObjectOverrides(void);
81void			 AeTableOverride(ACPI_TABLE_HEADER *, ACPI_TABLE_HEADER **);
82
83static void		 aml_simulation_init(void);
84static int		 aml_simulate_regcontent_add(int regtype,
85			     ACPI_PHYSICAL_ADDRESS addr,
86			     UINT8 value);
87static int		 aml_simulate_regcontent_read(int regtype,
88			     ACPI_PHYSICAL_ADDRESS addr,
89			     UINT8 *valuep);
90static int		 aml_simulate_regcontent_write(int regtype,
91			     ACPI_PHYSICAL_ADDRESS addr,
92			     UINT8 *valuep);
93static UINT64		 aml_simulate_prompt(char *msg, UINT64 def_val);
94static void		 aml_simulation_regload(const char *dumpfile);
95static void		 aml_simulation_regdump(const char *dumpfile);
96
97/* Stubs to simplify linkage to the ACPICA core subsystem. */
98ACPI_PHYSICAL_ADDRESS
99AcpiOsGetRootPointer(void)
100{
101
102	return (0);
103}
104
105void
106AeDoObjectOverrides(void)
107{
108}
109
110void
111AeTableOverride(ACPI_TABLE_HEADER *ExistingTable, ACPI_TABLE_HEADER **NewTable)
112{
113}
114
115void
116MpSaveGpioInfo(ACPI_PARSE_OBJECT *Op, AML_RESOURCE *Resource,
117    UINT32 PinCount, UINT16 *PinList, char *DeviceName)
118{
119}
120
121void
122MpSaveSerialInfo(ACPI_PARSE_OBJECT *Op, AML_RESOURCE *Resource,
123    char *DeviceName)
124{
125}
126
127static void
128aml_simulation_init(void)
129{
130
131	aml_simulation_initialized = 1;
132	TAILQ_INIT(&RegionContentList);
133	aml_simulation_regload("region.ini");
134}
135
136static int
137aml_simulate_regcontent_add(int regtype, ACPI_PHYSICAL_ADDRESS addr, UINT8 value)
138{
139	struct	ACPIRegionContent *rc;
140
141	rc = malloc(sizeof(struct ACPIRegionContent));
142	if (rc == NULL) {
143		return (-1);	/* malloc fail */
144	}
145	rc->regtype = regtype;
146	rc->addr = addr;
147	rc->value = value;
148
149	TAILQ_INSERT_TAIL(&RegionContentList, rc, links);
150	return (0);
151}
152
153static int
154aml_simulate_regcontent_read(int regtype, ACPI_PHYSICAL_ADDRESS addr, UINT8 *valuep)
155{
156	struct	ACPIRegionContent *rc;
157
158	if (!aml_simulation_initialized) {
159		aml_simulation_init();
160	}
161	TAILQ_FOREACH(rc, &RegionContentList, links) {
162		if (rc->regtype == regtype && rc->addr == addr) {
163			*valuep = rc->value;
164			return (1);	/* found */
165		}
166	}
167
168	*valuep = 0;
169	return (aml_simulate_regcontent_add(regtype, addr, *valuep));
170}
171
172static int
173aml_simulate_regcontent_write(int regtype, ACPI_PHYSICAL_ADDRESS addr, UINT8 *valuep)
174{
175	struct	ACPIRegionContent *rc;
176
177	if (!aml_simulation_initialized) {
178		aml_simulation_init();
179	}
180	TAILQ_FOREACH(rc, &RegionContentList, links) {
181		if (rc->regtype == regtype && rc->addr == addr) {
182			rc->value = *valuep;
183			return (1);	/* exists */
184		}
185	}
186
187	return (aml_simulate_regcontent_add(regtype, addr, *valuep));
188}
189
190static UINT64
191aml_simulate_prompt(char *msg, UINT64 def_val)
192{
193	char		buf[16], *ep;
194	UINT64		val;
195
196	val = def_val;
197	printf("DEBUG");
198	if (msg != NULL) {
199		printf("%s", msg);
200	}
201	printf("(default: 0x%jx ", (uintmax_t)val);
202	printf(" / %ju) >>", (uintmax_t)val);
203	fflush(stdout);
204
205	bzero(buf, sizeof buf);
206	while (1) {
207		if (read(0, buf, sizeof buf) == 0) {
208			continue;
209		}
210		if (buf[0] == '\n') {
211			break;	/* use default value */
212		}
213		if (buf[0] == '0' && buf[1] == 'x') {
214			val = strtoq(buf, &ep, 16);
215		} else {
216			val = strtoq(buf, &ep, 10);
217		}
218		break;
219	}
220	return (val);
221}
222
223static void
224aml_simulation_regload(const char *dumpfile)
225{
226	char	buf[256], *np, *ep;
227	struct	ACPIRegionContent rc;
228	FILE	*fp;
229
230	if (!aml_simulation_initialized) {
231		return;
232	}
233
234	if ((fp = fopen(dumpfile, "r")) == NULL) {
235		return;
236	}
237
238	while (fgets(buf, sizeof buf, fp) != NULL) {
239		np = buf;
240		/* reading region type */
241		rc.regtype = strtoq(np, &ep, 10);
242		if (np == ep) {
243			continue;
244		}
245		np = ep;
246
247		/* reading address */
248		rc.addr = strtoq(np, &ep, 16);
249		if (np == ep) {
250			continue;
251		}
252		np = ep;
253
254		/* reading value */
255		rc.value = strtoq(np, &ep, 16);
256		if (np == ep) {
257			continue;
258		}
259		aml_simulate_regcontent_write(rc.regtype, rc.addr, &rc.value);
260	}
261
262	fclose(fp);
263}
264
265static void
266aml_simulation_regdump(const char *dumpfile)
267{
268	struct	ACPIRegionContent *rc;
269	FILE	*fp;
270
271	if (!aml_simulation_initialized) {
272		return;
273	}
274	if ((fp = fopen(dumpfile, "w")) == NULL) {
275		warn("%s", dumpfile);
276		return;
277	}
278	while (!TAILQ_EMPTY(&RegionContentList)) {
279		rc = TAILQ_FIRST(&RegionContentList);
280		fprintf(fp, "%d	0x%jx	0x%x\n",
281		    rc->regtype, (uintmax_t)rc->addr, rc->value);
282		TAILQ_REMOVE(&RegionContentList, rc, links);
283		free(rc);
284	}
285
286	fclose(fp);
287	TAILQ_INIT(&RegionContentList);
288}
289
290/*
291 * Space handlers on virtual machine
292 */
293
294static ACPI_STATUS
295aml_vm_space_handler(
296	UINT32			SpaceID,
297	UINT32			Function,
298	ACPI_PHYSICAL_ADDRESS	Address,
299	UINT32			BitWidth,
300	UINT64			*Value,
301	int			Prompt)
302{
303	int			state;
304	UINT8			val;
305	UINT64			value, i;
306	char			msg[256];
307	static const char	*space_names[] = {
308		"SYSTEM_MEMORY", "SYSTEM_IO", "PCI_CONFIG",
309		"EC", "SMBUS", "CMOS", "PCI_BAR_TARGET"};
310
311	switch (Function) {
312	case ACPI_READ:
313		value = 0;
314		for (i = 0; (i * 8) < BitWidth; i++) {
315			state = aml_simulate_regcontent_read(SpaceID,
316							     Address + i, &val);
317			if (state == -1) {
318				return (AE_NO_MEMORY);
319			}
320			value |= val << (i * 8);
321		}
322		*Value = value;
323		if (Prompt) {
324			sprintf(msg, "[read (%s, %2d, 0x%jx)]",
325				space_names[SpaceID], BitWidth,
326				(uintmax_t)Address);
327			*Value = aml_simulate_prompt(msg, value);
328			if (*Value != value) {
329				return(aml_vm_space_handler(SpaceID,
330						ACPI_WRITE,
331						Address, BitWidth, Value, 0));
332			}
333		}
334		break;
335
336	case ACPI_WRITE:
337		value = *Value;
338		if (Prompt) {
339			sprintf(msg, "[write(%s, %2d, 0x%jx)]",
340				space_names[SpaceID], BitWidth,
341				(uintmax_t)Address);
342			value = aml_simulate_prompt(msg, *Value);
343		}
344		*Value = value;
345		for (i = 0; (i * 8) < BitWidth; i++) {
346			val = value & 0xff;
347			state = aml_simulate_regcontent_write(SpaceID,
348							      Address + i, &val);
349			if (state == -1) {
350				return (AE_NO_MEMORY);
351			}
352			value = value >> 8;
353		}
354	}
355
356	return (AE_OK);
357}
358
359#define DECLARE_VM_SPACE_HANDLER(name, id);			\
360static ACPI_STATUS						\
361aml_vm_space_handler_##name (					\
362	UINT32			Function,			\
363	ACPI_PHYSICAL_ADDRESS	Address,			\
364	UINT32			BitWidth,			\
365	UINT64			*Value)				\
366{								\
367	return (aml_vm_space_handler(id, Function, Address,	\
368		BitWidth, Value, aml_debug_prompt));		\
369}
370
371DECLARE_VM_SPACE_HANDLER(system_memory,	ACPI_ADR_SPACE_SYSTEM_MEMORY);
372DECLARE_VM_SPACE_HANDLER(system_io,	ACPI_ADR_SPACE_SYSTEM_IO);
373DECLARE_VM_SPACE_HANDLER(pci_config,	ACPI_ADR_SPACE_PCI_CONFIG);
374DECLARE_VM_SPACE_HANDLER(ec,		ACPI_ADR_SPACE_EC);
375DECLARE_VM_SPACE_HANDLER(smbus,		ACPI_ADR_SPACE_SMBUS);
376DECLARE_VM_SPACE_HANDLER(cmos,		ACPI_ADR_SPACE_CMOS);
377DECLARE_VM_SPACE_HANDLER(pci_bar_target,ACPI_ADR_SPACE_PCI_BAR_TARGET);
378
379/*
380 * Load DSDT data file and invoke debugger
381 */
382
383static int
384load_dsdt(const char *dsdtfile)
385{
386	char			filetmp[PATH_MAX];
387	ACPI_NEW_TABLE_DESC	*list;
388	u_int8_t		*code;
389	struct stat		sb;
390	int			dounlink, error, fd;
391
392	fd = open(dsdtfile, O_RDONLY, 0);
393	if (fd == -1) {
394		perror("open");
395		return (-1);
396	}
397	if (fstat(fd, &sb) == -1) {
398		perror("fstat");
399		close(fd);
400		return (-1);
401	}
402	code = mmap(NULL, (size_t)sb.st_size, PROT_READ, MAP_PRIVATE, fd, (off_t)0);
403	close(fd);
404	if (code == NULL) {
405		perror("mmap");
406		return (-1);
407	}
408	if ((error = AcpiInitializeSubsystem()) != AE_OK) {
409		munmap(code, (size_t)sb.st_size);
410		return (-1);
411	}
412
413	/*
414	 * make sure DSDT data contains table header or not.
415	 */
416	if (strncmp((char *)code, "DSDT", 4) == 0) {
417		dounlink = 0;
418		strlcpy(filetmp, dsdtfile, sizeof(filetmp));
419	} else {
420		dounlink = 1;
421		mode_t	mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
422		dummy_dsdt_table.Length = sizeof(ACPI_TABLE_HEADER) + sb.st_size;
423		if ((size_t)snprintf(filetmp, sizeof(filetmp), "%s.tmp",
424		    dsdtfile) > sizeof(filetmp) - 1) {
425			fprintf(stderr, "file name too long\n");
426			munmap(code, (size_t)sb.st_size);
427			return (-1);
428		}
429		fd = open(filetmp, O_WRONLY | O_CREAT | O_TRUNC, mode);
430		if (fd == -1) {
431			perror("open");
432			munmap(code, (size_t)sb.st_size);
433			return (-1);
434		}
435		write(fd, &dummy_dsdt_table, sizeof(ACPI_TABLE_HEADER));
436
437		write(fd, code, sb.st_size);
438		close(fd);
439	}
440	munmap(code, (size_t)sb.st_size);
441
442	/*
443	 * Install the virtual machine version of address space handlers.
444	 */
445	if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
446			ACPI_ADR_SPACE_SYSTEM_MEMORY,
447			(ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_system_memory,
448			NULL, NULL)) != AE_OK) {
449		fprintf(stderr, "could not initialise SystemMemory handler: %d\n", error);
450		return (-1);
451	}
452	if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
453			ACPI_ADR_SPACE_SYSTEM_IO,
454			(ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_system_io,
455			NULL, NULL)) != AE_OK) {
456		fprintf(stderr, "could not initialise SystemIO handler: %d\n", error);
457		return (-1);
458	}
459	if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
460			ACPI_ADR_SPACE_PCI_CONFIG,
461			(ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_pci_config,
462			NULL, NULL)) != AE_OK) {
463		fprintf(stderr, "could not initialise PciConfig handler: %d\n", error);
464		return (-1);
465	}
466	if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
467			ACPI_ADR_SPACE_EC,
468			(ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_ec,
469			NULL, NULL)) != AE_OK) {
470		fprintf(stderr, "could not initialise EC handler: %d\n", error);
471		return (-1);
472	}
473	if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
474			ACPI_ADR_SPACE_SMBUS,
475			(ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_smbus,
476			NULL, NULL)) != AE_OK) {
477		fprintf(stderr, "could not initialise SMBUS handler: %d\n", error);
478		return (-1);
479	}
480	if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
481			ACPI_ADR_SPACE_CMOS,
482			(ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_cmos,
483			NULL, NULL)) != AE_OK) {
484		fprintf(stderr, "could not initialise CMOS handler: %d\n", error);
485		return (-1);
486	}
487	if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
488			ACPI_ADR_SPACE_PCI_BAR_TARGET,
489			(ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_pci_bar_target,
490			NULL, NULL)) != AE_OK) {
491		fprintf(stderr, "could not initialise PCI BAR TARGET handler: %d\n", error);
492		return (-1);
493	}
494
495	list = NULL;
496	AcGetAllTablesFromFile(filetmp, TRUE, &list);
497
498	AcpiInitializeDebugger();
499	AcpiGbl_DebuggerConfiguration = 0;
500	AcpiDbUserCommands();
501
502	if (dounlink) {
503		unlink(filetmp);
504	}
505
506	return (0);
507}
508
509static void
510usage(const char *progname)
511{
512
513	printf("usage: %s dsdt_file\n", progname);
514	exit(1);
515}
516
517int
518main(int argc, char *argv[])
519{
520	char	*progname;
521
522	progname = argv[0];
523
524	if (argc == 1) {
525		usage(progname);
526	}
527
528	AcpiDbgLevel = ACPI_DEBUG_DEFAULT;
529
530	/*
531	 * Match kernel options for the interpreter.  Global variable names
532	 * can be found in acglobal.h.
533	 */
534	AcpiGbl_EnableInterpreterSlack = TRUE;
535
536	aml_simulation_regload("region.ini");
537	if (load_dsdt(argv[1]) == 0) {
538		aml_simulation_regdump("region.dmp");
539	}
540
541	return (0);
542}
543