?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
acpidump: fix interaction with iasl
[dragonfly.git] / usr.sbin / acpi / acpidump / acpi.c
blob576f044ae1fa82187dab57b4cf90ff9dece8897b
1 /*-
2 * Copyright (c) 1998 Doug Rabson
3 * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: src/usr.sbin/acpi/acpidump/acpi.c,v 1.31 2005/02/14 11:21:48 scottl Exp $
28 * $DragonFly: src/usr.sbin/acpi/acpidump/acpi.c,v 1.7 2008/07/19 13:50:51 swildner Exp $
29 */
30
31 #include <sys/param.h>
32 #include <sys/endian.h>
33 #include <sys/stat.h>
34 #include <sys/wait.h>
35 #include <assert.h>
36 #include <err.h>
37 #include <fcntl.h>
38 #include <paths.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <unistd.h>
43
44 #include "acpidump.h"
45
46 #define BEGIN_COMMENT "/*\n"
47 #define END_COMMENT " */\n"
48
49 static void acpi_print_string(char *s, size_t length);
50 static void acpi_print_gas(struct ACPIgas *gas);
51 static int acpi_get_fadt_revision(struct FADTbody *fadt);
52 static void acpi_handle_fadt(struct ACPIsdt *fadt);
53 static void acpi_print_cpu(u_char cpu_id);
54 static void acpi_print_local_apic(u_char cpu_id, u_char apic_id,
55 u_int32_t flags);
56 static void acpi_print_io_apic(u_char apic_id, u_int32_t int_base,
57 u_int64_t apic_addr);
58 static void acpi_print_mps_flags(u_int16_t flags);
59 static void acpi_print_intr(u_int32_t intr, u_int16_t mps_flags);
60 static void acpi_print_apic(struct MADT_APIC *mp);
61 static void acpi_handle_apic(struct ACPIsdt *sdp);
62 static void acpi_handle_hpet(struct ACPIsdt *sdp);
63 static void acpi_print_sdt(struct ACPIsdt *sdp);
64 static void acpi_print_fadt(struct ACPIsdt *sdp);
65 static void acpi_print_facs(struct FACSbody *facs);
66 static void acpi_print_dsdt(struct ACPIsdt *dsdp);
67 static struct ACPIsdt *acpi_map_sdt(vm_offset_t pa);
68 static void acpi_print_rsd_ptr(struct ACPIrsdp *rp);
69 static void acpi_handle_rsdt(struct ACPIsdt *rsdp);
70
71 /* Size of an address. 32-bit for ACPI 1.0, 64-bit for ACPI 2.0 and up. */
72 static int addr_size;
73
74 static void
75 acpi_print_string(char *s, size_t length)
76 {
77 int c;
78
79 /* Trim trailing spaces and NULLs */
80 while (length > 0 && (s[length - 1] == ' ' || s[length - 1] == '\0'))
81 length--;
82
83 while (length--) {
84 c = *s++;
85 putchar(c);
86 }
87 }
88
89 static void
90 acpi_print_gas(struct ACPIgas *gas)
91 {
92 switch(gas->address_space_id) {
93 case ACPI_GAS_MEMORY:
94 printf("0x%08lx:%u[%u] (Memory)", (u_long)gas->address,
95 gas->bit_offset, gas->bit_width);
96 break;
97 case ACPI_GAS_IO:
98 printf("0x%02lx:%u[%u] (IO)", (u_long)gas->address,
99 gas->bit_offset, gas->bit_width);
100 break;
101 case ACPI_GAS_PCI:
102 printf("%x:%x+0x%x (PCI)", (uint16_t)(gas->address >> 32),
103 (uint16_t)((gas->address >> 16) & 0xffff),
104 (uint16_t)gas->address);
105 break;
106 /* XXX How to handle these below? */
107 case ACPI_GAS_EMBEDDED:
108 printf("0x%x:%u[%u] (EC)", (uint16_t)gas->address,
109 gas->bit_offset, gas->bit_width);
110 break;
111 case ACPI_GAS_SMBUS:
112 printf("0x%x:%u[%u] (SMBus)", (uint16_t)gas->address,
113 gas->bit_offset, gas->bit_width);
114 break;
115 case ACPI_GAS_FIXED:
116 default:
117 printf("0x%08lx (?)", (u_long)gas->address);
118 break;
119 }
120 }
121
122 /* The FADT revision indicates whether we use the DSDT or X_DSDT addresses. */
123 static int
124 acpi_get_fadt_revision(struct FADTbody *fadt)
125 {
126 int fadt_revision;
127
128 /* Set the FADT revision separately from the RSDP version. */
129 if (addr_size == 8) {
130 fadt_revision = 2;
131
132 /*
133 * A few systems (e.g., IBM T23) have an RSDP that claims
134 * revision 2 but the 64 bit addresses are invalid. If
135 * revision 2 and the 32 bit address is non-zero but the
136 * 32 and 64 bit versions don't match, prefer the 32 bit
137 * version for all subsequent tables.
138 */
139 if (fadt->facs_ptr != 0 &&
140 (fadt->x_facs_ptr & 0xffffffff) != fadt->facs_ptr)
141 fadt_revision = 1;
142 } else
143 fadt_revision = 1;
144 return (fadt_revision);
145 }
146
147 static void
148 acpi_handle_fadt(struct ACPIsdt *sdp)
149 {
150 struct ACPIsdt *dsdp;
151 struct FACSbody *facs;
152 struct FADTbody *fadt;
153 int fadt_revision;
154
155 fadt = (struct FADTbody *)sdp->body;
156 acpi_print_fadt(sdp);
157
158 fadt_revision = acpi_get_fadt_revision(fadt);
159 if (fadt_revision == 1)
160 facs = (struct FACSbody *)acpi_map_sdt(fadt->facs_ptr);
161 else
162 facs = (struct FACSbody *)acpi_map_sdt(fadt->x_facs_ptr);
163 if (memcmp(facs->signature, "FACS", 4) != 0 || facs->len < 64)
164 errx(1, "FACS is corrupt");
165 acpi_print_facs(facs);
166
167 if (fadt_revision == 1)
168 dsdp = (struct ACPIsdt *)acpi_map_sdt(fadt->dsdt_ptr);
169 else
170 dsdp = (struct ACPIsdt *)acpi_map_sdt(fadt->x_dsdt_ptr);
171 if (acpi_checksum(dsdp, dsdp->len))
172 errx(1, "DSDT is corrupt");
173 acpi_print_dsdt(dsdp);
174 }
175
176 static void
177 acpi_print_cpu(u_char cpu_id)
178 {
179
180 printf("\tACPI CPU=");
181 if (cpu_id == 0xff)
182 printf("ALL\n");
183 else
184 printf("%d\n", (u_int)cpu_id);
185 }
186
187 static void
188 acpi_print_local_apic(u_char cpu_id, u_char apic_id, u_int32_t flags)
189 {
190 acpi_print_cpu(cpu_id);
191 printf("\tFlags={");
192 if (flags & ACPI_MADT_APIC_LOCAL_FLAG_ENABLED)
193 printf("ENABLED");
194 else
195 printf("DISABLED");
196 printf("}\n");
197 printf("\tAPIC ID=%d\n", (u_int)apic_id);
198 }
199
200 static void
201 acpi_print_io_apic(u_char apic_id, u_int32_t int_base, u_int64_t apic_addr)
202 {
203 printf("\tAPIC ID=%d\n", (u_int)apic_id);
204 printf("\tINT BASE=%d\n", int_base);
205 printf("\tADDR=0x%016jx\n", apic_addr);
206 }
207
208 static void
209 acpi_print_mps_flags(u_int16_t flags)
210 {
211
212 printf("\tFlags={Polarity=");
213 switch (flags & MPS_INT_FLAG_POLARITY_MASK) {
214 case MPS_INT_FLAG_POLARITY_CONFORM:
215 printf("conforming");
216 break;
217 case MPS_INT_FLAG_POLARITY_HIGH:
218 printf("active-hi");
219 break;
220 case MPS_INT_FLAG_POLARITY_LOW:
221 printf("active-lo");
222 break;
223 default:
224 printf("0x%x", flags & MPS_INT_FLAG_POLARITY_MASK);
225 break;
226 }
227 printf(", Trigger=");
228 switch (flags & MPS_INT_FLAG_TRIGGER_MASK) {
229 case MPS_INT_FLAG_TRIGGER_CONFORM:
230 printf("conforming");
231 break;
232 case MPS_INT_FLAG_TRIGGER_EDGE:
233 printf("edge");
234 break;
235 case MPS_INT_FLAG_TRIGGER_LEVEL:
236 printf("level");
237 break;
238 default:
239 printf("0x%x", (flags & MPS_INT_FLAG_TRIGGER_MASK) >> 2);
240 }
241 printf("}\n");
242 }
243
244 static void
245 acpi_print_intr(u_int32_t intr, u_int16_t mps_flags)
246 {
247
248 printf("\tINTR=%d\n", (u_int)intr);
249 acpi_print_mps_flags(mps_flags);
250 }
251
252 const char *apic_types[] = { "Local APIC", "IO APIC", "INT Override", "NMI",
253 "Local NMI", "Local APIC Override", "IO SAPIC",
254 "Local SAPIC", "Platform Interrupt" };
255 const char *platform_int_types[] = { "PMI", "INIT",
256 "Corrected Platform Error" };
257
258 static void
259 acpi_print_apic(struct MADT_APIC *mp)
260 {
261
262 printf("\tType=%s\n", apic_types[mp->type]);
263 switch (mp->type) {
264 case ACPI_MADT_APIC_TYPE_LOCAL_APIC:
265 acpi_print_local_apic(mp->body.local_apic.cpu_id,
266 mp->body.local_apic.apic_id, mp->body.local_apic.flags);
267 break;
268 case ACPI_MADT_APIC_TYPE_IO_APIC:
269 acpi_print_io_apic(mp->body.io_apic.apic_id,
270 mp->body.io_apic.int_base,
271 mp->body.io_apic.apic_addr);
272 break;
273 case ACPI_MADT_APIC_TYPE_INT_OVERRIDE:
274 printf("\tBUS=%d\n", (u_int)mp->body.int_override.bus);
275 printf("\tIRQ=%d\n", (u_int)mp->body.int_override.source);
276 acpi_print_intr(mp->body.int_override.intr,
277 mp->body.int_override.mps_flags);
278 break;
279 case ACPI_MADT_APIC_TYPE_NMI:
280 acpi_print_intr(mp->body.nmi.intr, mp->body.nmi.mps_flags);
281 break;
282 case ACPI_MADT_APIC_TYPE_LOCAL_NMI:
283 acpi_print_cpu(mp->body.local_nmi.cpu_id);
284 printf("\tLINT Pin=%d\n", mp->body.local_nmi.lintpin);
285 acpi_print_mps_flags(mp->body.local_nmi.mps_flags);
286 break;
287 case ACPI_MADT_APIC_TYPE_LOCAL_OVERRIDE:
288 printf("\tLocal APIC ADDR=0x%016jx\n",
289 mp->body.local_apic_override.apic_addr);
290 break;
291 case ACPI_MADT_APIC_TYPE_IO_SAPIC:
292 acpi_print_io_apic(mp->body.io_sapic.apic_id,
293 mp->body.io_sapic.int_base,
294 mp->body.io_sapic.apic_addr);
295 break;
296 case ACPI_MADT_APIC_TYPE_LOCAL_SAPIC:
297 acpi_print_local_apic(mp->body.local_sapic.cpu_id,
298 mp->body.local_sapic.apic_id, mp->body.local_sapic.flags);
299 printf("\tAPIC EID=%d\n", (u_int)mp->body.local_sapic.apic_eid);
300 break;
301 case ACPI_MADT_APIC_TYPE_INT_SRC:
302 printf("\tType=%s\n",
303 platform_int_types[mp->body.int_src.type]);
304 printf("\tCPU ID=%d\n", (u_int)mp->body.int_src.cpu_id);
305 printf("\tCPU EID=%d\n", (u_int)mp->body.int_src.cpu_id);
306 printf("\tSAPIC Vector=%d\n",
307 (u_int)mp->body.int_src.sapic_vector);
308 acpi_print_intr(mp->body.int_src.intr,
309 mp->body.int_src.mps_flags);
310 break;
311 default:
312 printf("\tUnknown type %d\n", (u_int)mp->type);
313 break;
314 }
315 }
316
317 static void
318 acpi_handle_apic(struct ACPIsdt *sdp)
319 {
320 struct MADTbody *madtp;
321 struct MADT_APIC *madt_apicp;
322
323 printf(BEGIN_COMMENT);
324 acpi_print_sdt(sdp);
325 madtp = (struct MADTbody *) sdp->body;
326 printf("\tLocal APIC ADDR=0x%08x\n", madtp->lapic_addr);
327 printf("\tFlags={");
328 if (madtp->flags & ACPI_APIC_FLAG_PCAT_COMPAT)
329 printf("PC-AT");
330 printf("}\n");
331 madt_apicp = (struct MADT_APIC *)madtp->body;
332 while (((uintptr_t)madt_apicp) - ((uintptr_t)sdp) < sdp->len) {
333 printf("\n");
334 acpi_print_apic(madt_apicp);
335 madt_apicp = (struct MADT_APIC *) ((char *)madt_apicp +
336 madt_apicp->len);
337 }
338 printf(END_COMMENT);
339 }
340
341 static void
342 acpi_handle_hpet(struct ACPIsdt *sdp)
343 {
344 struct HPETbody *hpetp;
345
346 printf(BEGIN_COMMENT);
347 acpi_print_sdt(sdp);
348 hpetp = (struct HPETbody *) sdp->body;
349 printf("\tHPET Number=%d\n", hpetp->hpet_number);
350 printf("\tADDR=0x%08x\n", hpetp->base_addr);
351 printf("\tHW Rev=0x%x\n", hpetp->block_hwrev);
352 printf("\tComparitors=%d\n", hpetp->block_comparitors);
353 printf("\tCounter Size=%d\n", hpetp->block_counter_size);
354 printf("\tLegacy IRQ routing capable={");
355 if (hpetp->block_legacy_capable)
356 printf("TRUE}\n");
357 else
358 printf("FALSE}\n");
359 printf("\tPCI Vendor ID=0x%04x\n", hpetp->block_pcivendor);
360 printf("\tMinimal Tick=%d\n", hpetp->clock_tick);
361 printf(END_COMMENT);
362 }
363
364 static void
365 acpi_handle_ecdt(struct ACPIsdt *sdp)
366 {
367 struct ECDTbody *ecdt;
368
369 printf(BEGIN_COMMENT);
370 acpi_print_sdt(sdp);
371 ecdt = (struct ECDTbody *) sdp->body;
372 printf("\tEC_CONTROL=");
373 acpi_print_gas(&ecdt->ec_control);
374 printf("\n\tEC_DATA=");
375 acpi_print_gas(&ecdt->ec_data);
376 printf("\n\tUID=%#x, ", ecdt->uid);
377 printf("GPE_BIT=%#x\n", ecdt->gpe_bit);
378 printf("\tEC_ID=%s\n", ecdt->ec_id);
379 printf(END_COMMENT);
380 }
381
382 static void
383 acpi_handle_mcfg(struct ACPIsdt *sdp)
384 {
385 struct MCFGbody *mcfg;
386 u_int i, e;
387
388 printf(BEGIN_COMMENT);
389 acpi_print_sdt(sdp);
390 mcfg = (struct MCFGbody *) sdp->body;
391
392 e = (sdp->len - ((caddr_t)&mcfg->s[0] - (caddr_t)sdp)) /
393 sizeof(*mcfg->s);
394 for (i = 0; i < e; i++, mcfg++) {
395 printf("\n");
396 printf("\tBase Address= 0x%016jx\n", mcfg->s[i].baseaddr);
397 printf("\tSegment Group= 0x%04x\n", mcfg->s[i].seg_grp);
398 printf("\tStart Bus= %d\n", mcfg->s[i].start);
399 printf("\tEnd Bus= %d\n", mcfg->s[i].end);
400 }
401 printf(END_COMMENT);
402 }
403
404 static void
405 acpi_print_sdt(struct ACPIsdt *sdp)
406 {
407 printf(" ");
408 acpi_print_string(sdp->signature, 4);
409 printf(": Length=%d, Revision=%d, Checksum=%d,\n",
410 sdp->len, sdp->rev, sdp->check);
411 printf("\tOEMID=");
412 acpi_print_string(sdp->oemid, 6);
413 printf(", OEM Table ID=");
414 acpi_print_string(sdp->oemtblid, 8);
415 printf(", OEM Revision=0x%x,\n", sdp->oemrev);
416 printf("\tCreator ID=");
417 acpi_print_string(sdp->creator, 4);
418 printf(", Creator Revision=0x%x\n", sdp->crerev);
419 }
420
421 static void
422 acpi_print_rsdt(struct ACPIsdt *rsdp)
423 {
424 int i, entries;
425 u_long addr;
426
427 printf(BEGIN_COMMENT);
428 acpi_print_sdt(rsdp);
429 entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size;
430 printf("\tEntries={ ");
431 for (i = 0; i < entries; i++) {
432 if (i > 0)
433 printf(", ");
434 switch (addr_size) {
435 case 4:
436 addr = le32dec((char*)rsdp->body + i * addr_size);
437 break;
438 case 8:
439 addr = le64dec((char*)rsdp->body + i * addr_size);
440 break;
441 default:
442 addr = 0;
443 }
444 assert(addr != 0);
445 printf("0x%08lx", addr);
446 }
447 printf(" }\n");
448 printf(END_COMMENT);
449 }
450
451 static const char *acpi_pm_profiles[] = {
452 "Unspecified", "Desktop", "Mobile", "Workstation",
453 "Enterprise Server", "SOHO Server", "Appliance PC"
454 };
455
456 static void
457 acpi_print_fadt(struct ACPIsdt *sdp)
458 {
459 struct FADTbody *fadt;
460 const char *pm;
461 char sep;
462
463 fadt = (struct FADTbody *)sdp->body;
464 printf(BEGIN_COMMENT);
465 acpi_print_sdt(sdp);
466 printf(" \tFACS=0x%x, DSDT=0x%x\n", fadt->facs_ptr,
467 fadt->dsdt_ptr);
468 printf("\tINT_MODEL=%s\n", fadt->int_model ? "APIC" : "PIC");
469 if (fadt->pm_profile >= sizeof(acpi_pm_profiles) / sizeof(char *))
470 pm = "Reserved";
471 else
472 pm = acpi_pm_profiles[fadt->pm_profile];
473 printf("\tPreferred_PM_Profile=%s (%d)\n", pm, fadt->pm_profile);
474 printf("\tSCI_INT=%d\n", fadt->sci_int);
475 printf("\tSMI_CMD=0x%x, ", fadt->smi_cmd);
476 printf("ACPI_ENABLE=0x%x, ", fadt->acpi_enable);
477 printf("ACPI_DISABLE=0x%x, ", fadt->acpi_disable);
478 printf("S4BIOS_REQ=0x%x\n", fadt->s4biosreq);
479 printf("\tPSTATE_CNT=0x%x\n", fadt->pstate_cnt);
480 printf("\tPM1a_EVT_BLK=0x%x-0x%x\n",
481 fadt->pm1a_evt_blk,
482 fadt->pm1a_evt_blk + fadt->pm1_evt_len - 1);
483 if (fadt->pm1b_evt_blk != 0)
484 printf("\tPM1b_EVT_BLK=0x%x-0x%x\n",
485 fadt->pm1b_evt_blk,
486 fadt->pm1b_evt_blk + fadt->pm1_evt_len - 1);
487 printf("\tPM1a_CNT_BLK=0x%x-0x%x\n",
488 fadt->pm1a_cnt_blk,
489 fadt->pm1a_cnt_blk + fadt->pm1_cnt_len - 1);
490 if (fadt->pm1b_cnt_blk != 0)
491 printf("\tPM1b_CNT_BLK=0x%x-0x%x\n",
492 fadt->pm1b_cnt_blk,
493 fadt->pm1b_cnt_blk + fadt->pm1_cnt_len - 1);
494 if (fadt->pm2_cnt_blk != 0)
495 printf("\tPM2_CNT_BLK=0x%x-0x%x\n",
496 fadt->pm2_cnt_blk,
497 fadt->pm2_cnt_blk + fadt->pm2_cnt_len - 1);
498 printf("\tPM_TMR_BLK=0x%x-0x%x\n",
499 fadt->pm_tmr_blk,
500 fadt->pm_tmr_blk + fadt->pm_tmr_len - 1);
501 if (fadt->gpe0_blk != 0)
502 printf("\tGPE0_BLK=0x%x-0x%x\n",
503 fadt->gpe0_blk,
504 fadt->gpe0_blk + fadt->gpe0_len - 1);
505 if (fadt->gpe1_blk != 0)
506 printf("\tGPE1_BLK=0x%x-0x%x, GPE1_BASE=%d\n",
507 fadt->gpe1_blk,
508 fadt->gpe1_blk + fadt->gpe1_len - 1,
509 fadt->gpe1_base);
510 if (fadt->cst_cnt != 0)
511 printf("\tCST_CNT=0x%x\n", fadt->cst_cnt);
512 printf("\tP_LVL2_LAT=%d us, P_LVL3_LAT=%d us\n",
513 fadt->p_lvl2_lat, fadt->p_lvl3_lat);
514 printf("\tFLUSH_SIZE=%d, FLUSH_STRIDE=%d\n",
515 fadt->flush_size, fadt->flush_stride);
516 printf("\tDUTY_OFFSET=%d, DUTY_WIDTH=%d\n",
517 fadt->duty_off, fadt->duty_width);
518 printf("\tDAY_ALRM=%d, MON_ALRM=%d, CENTURY=%d\n",
519 fadt->day_alrm, fadt->mon_alrm, fadt->century);
520
521 #define PRINTFLAG(var, flag) do { \
522 if ((var) & FADT_FLAG_## flag) { \
523 printf("%c%s", sep, #flag); sep = ','; \
524 } \
525 } while (0)
526
527 printf("\tIAPC_BOOT_ARCH=");
528 sep = '{';
529 PRINTFLAG(fadt->iapc_boot_arch, LEGACY_DEV);
530 PRINTFLAG(fadt->iapc_boot_arch, 8042);
531 if (fadt->iapc_boot_arch != 0)
532 printf("}");
533 printf("\n");
534
535 printf("\tFlags=");
536 sep = '{';
537 PRINTFLAG(fadt->flags, WBINVD);
538 PRINTFLAG(fadt->flags, WBINVD_FLUSH);
539 PRINTFLAG(fadt->flags, PROC_C1);
540 PRINTFLAG(fadt->flags, P_LVL2_UP);
541 PRINTFLAG(fadt->flags, PWR_BUTTON);
542 PRINTFLAG(fadt->flags, SLP_BUTTON);
543 PRINTFLAG(fadt->flags, FIX_RTC);
544 PRINTFLAG(fadt->flags, RTC_S4);
545 PRINTFLAG(fadt->flags, TMR_VAL_EXT);
546 PRINTFLAG(fadt->flags, DCK_CAP);
547 PRINTFLAG(fadt->flags, RESET_REG);
548 PRINTFLAG(fadt->flags, SEALED_CASE);
549 PRINTFLAG(fadt->flags, HEADLESS);
550 PRINTFLAG(fadt->flags, CPU_SW_SLP);
551 if (fadt->flags != 0)
552 printf("}\n");
553
554 #undef PRINTFLAG
555
556 if (fadt->flags & FADT_FLAG_RESET_REG) {
557 printf("\tRESET_REG=");
558 acpi_print_gas(&fadt->reset_reg);
559 printf(", RESET_VALUE=%#x\n", fadt->reset_value);
560 }
561 if (acpi_get_fadt_revision(fadt) > 1) {
562 printf("\tX_FACS=0x%08lx, ", (u_long)fadt->x_facs_ptr);
563 printf("X_DSDT=0x%08lx\n", (u_long)fadt->x_dsdt_ptr);
564 printf("\tX_PM1a_EVT_BLK=");
565 acpi_print_gas(&fadt->x_pm1a_evt_blk);
566 if (fadt->x_pm1b_evt_blk.address != 0) {
567 printf("\n\tX_PM1b_EVT_BLK=");
568 acpi_print_gas(&fadt->x_pm1b_evt_blk);
569 }
570 printf("\n\tX_PM1a_CNT_BLK=");
571 acpi_print_gas(&fadt->x_pm1a_cnt_blk);
572 if (fadt->x_pm1b_cnt_blk.address != 0) {
573 printf("\n\tX_PM1b_CNT_BLK=");
574 acpi_print_gas(&fadt->x_pm1b_cnt_blk);
575 }
576 if (fadt->x_pm1b_cnt_blk.address != 0) {
577 printf("\n\tX_PM2_CNT_BLK=");
578 acpi_print_gas(&fadt->x_pm2_cnt_blk);
579 }
580 printf("\n\tX_PM_TMR_BLK=");
581 acpi_print_gas(&fadt->x_pm_tmr_blk);
582 if (fadt->x_gpe0_blk.address != 0) {
583 printf("\n\tX_GPE0_BLK=");
584 acpi_print_gas(&fadt->x_gpe0_blk);
585 }
586 if (fadt->x_gpe1_blk.address != 0) {
587 printf("\n\tX_GPE1_BLK=");
588 acpi_print_gas(&fadt->x_gpe1_blk);
589 }
590 printf("\n");
591 }
592
593 printf(END_COMMENT);
594 }
595
596 static void
597 acpi_print_facs(struct FACSbody *facs)
598 {
599 printf(BEGIN_COMMENT);
600 printf(" FACS:\tLength=%u, ", facs->len);
601 printf("HwSig=0x%08x, ", facs->hw_sig);
602 printf("Firm_Wake_Vec=0x%08x\n", facs->firm_wake_vec);
603
604 printf("\tGlobal_Lock=");
605 if (facs->global_lock != 0) {
606 if (facs->global_lock & FACS_FLAG_LOCK_PENDING)
607 printf("PENDING,");
608 if (facs->global_lock & FACS_FLAG_LOCK_OWNED)
609 printf("OWNED");
610 }
611 printf("\n");
612
613 printf("\tFlags=");
614 if (facs->flags & FACS_FLAG_S4BIOS_F)
615 printf("S4BIOS");
616 printf("\n");
617
618 if (facs->x_firm_wake_vec != 0) {
619 printf("\tX_Firm_Wake_Vec=%08lx\n",
620 (u_long)facs->x_firm_wake_vec);
621 }
622 printf("\tVersion=%u\n", facs->version);
623
624 printf(END_COMMENT);
625 }
626
627 static void
628 acpi_print_dsdt(struct ACPIsdt *dsdp)
629 {
630 printf(BEGIN_COMMENT);
631 acpi_print_sdt(dsdp);
632 printf(END_COMMENT);
633 }
634
635 int
636 acpi_checksum(void *p, size_t length)
637 {
638 u_int8_t *bp;
639 u_int8_t sum;
640
641 bp = p;
642 sum = 0;
643 while (length--)
644 sum += *bp++;
645
646 return (sum);
647 }
648
649 static struct ACPIsdt *
650 acpi_map_sdt(vm_offset_t pa)
651 {
652 struct ACPIsdt *sp;
653
654 sp = acpi_map_physical(pa, sizeof(struct ACPIsdt));
655 sp = acpi_map_physical(pa, sp->len);
656 return (sp);
657 }
658
659 static void
660 acpi_print_rsd_ptr(struct ACPIrsdp *rp)
661 {
662 printf(BEGIN_COMMENT);
663 printf(" RSD PTR: OEM=");
664 acpi_print_string(rp->oem, 6);
665 printf(", ACPI_Rev=%s (%d)\n", rp->revision < 2 ? "1.0x" : "2.0x",
666 rp->revision);
667 if (rp->revision < 2) {
668 printf("\tRSDT=0x%08x, cksum=%u\n", rp->rsdt_addr, rp->sum);
669 } else {
670 printf("\tXSDT=0x%08lx, length=%u, cksum=%u\n",
671 (u_long)rp->xsdt_addr, rp->length, rp->xsum);
672 }
673 printf(END_COMMENT);
674 }
675
676 static void
677 acpi_handle_rsdt(struct ACPIsdt *rsdp)
678 {
679 struct ACPIsdt *sdp;
680 vm_offset_t addr;
681 int entries, i;
682
683 acpi_print_rsdt(rsdp);
684 entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size;
685 for (i = 0; i < entries; i++) {
686 switch (addr_size) {
687 case 4:
688 addr = le32dec((char*)rsdp->body + i * addr_size);
689 break;
690 case 8:
691 addr = le64dec((char*)rsdp->body + i * addr_size);
692 break;
693 default:
694 assert((addr = 0));
695 }
696
697 sdp = (struct ACPIsdt *)acpi_map_sdt(addr);
698 if (acpi_checksum(sdp, sdp->len)) {
699 warnx("RSDT entry %d (sig %.4s) is corrupt", i,
700 sdp->signature);
701 continue;
702 }
703 if (!memcmp(sdp->signature, "FACP", 4))
704 acpi_handle_fadt(sdp);
705 else if (!memcmp(sdp->signature, "APIC", 4))
706 acpi_handle_apic(sdp);
707 else if (!memcmp(sdp->signature, "HPET", 4))
708 acpi_handle_hpet(sdp);
709 else if (!memcmp(sdp->signature, "ECDT", 4))
710 acpi_handle_ecdt(sdp);
711 else if (!memcmp(sdp->signature, "MCFG", 4))
712 acpi_handle_mcfg(sdp);
713 else {
714 printf(BEGIN_COMMENT);
715 acpi_print_sdt(sdp);
716 printf(END_COMMENT);
717 }
718 }
719 }
720
721 struct ACPIsdt *
722 sdt_load_devmem(void)
723 {
724 struct ACPIrsdp *rp;
725 struct ACPIsdt *rsdp;
726
727 rp = acpi_find_rsd_ptr();
728 if (!rp)
729 errx(1, "Can't find ACPI information");
730
731 if (tflag)
732 acpi_print_rsd_ptr(rp);
733 if (rp->revision < 2) {
734 rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->rsdt_addr);
735 if (memcmp(rsdp->signature, "RSDT", 4) != 0 ||
736 acpi_checksum(rsdp, rsdp->len) != 0)
737 errx(1, "RSDT is corrupted");
738 addr_size = sizeof(uint32_t);
739 } else {
740 rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->xsdt_addr);
741 if (memcmp(rsdp->signature, "XSDT", 4) != 0 ||
742 acpi_checksum(rsdp, rsdp->len) != 0)
743 errx(1, "XSDT is corrupted");
744 addr_size = sizeof(uint64_t);
745 }
746 return (rsdp);
747 }
748
749 /* Write the DSDT to a file, concatenating any SSDTs (if present). */
750 static int
751 write_dsdt(int fd, struct ACPIsdt *rsdt, struct ACPIsdt *dsdt)
752 {
753 struct ACPIsdt sdt;
754 struct ACPIsdt *ssdt;
755 uint8_t sum;
756
757 /* Create a new checksum to account for the DSDT and any SSDTs. */
758 sdt = *dsdt;
759 if (rsdt != NULL) {
760 sdt.check = 0;
761 sum = acpi_checksum(dsdt->body, dsdt->len - SIZEOF_SDT_HDR);
762 ssdt = sdt_from_rsdt(rsdt, "SSDT", NULL);
763 while (ssdt != NULL) {
764 sdt.len += ssdt->len - SIZEOF_SDT_HDR;
765 sum += acpi_checksum(ssdt->body,
766 ssdt->len - SIZEOF_SDT_HDR);
767 ssdt = sdt_from_rsdt(rsdt, "SSDT", ssdt);
768 }
769 sum += acpi_checksum(&sdt, SIZEOF_SDT_HDR);
770 sdt.check -= sum;
771 }
772
773 /* Write out the DSDT header and body. */
774 write(fd, &sdt, SIZEOF_SDT_HDR);
775 write(fd, dsdt->body, dsdt->len - SIZEOF_SDT_HDR);
776
777 /* Write out any SSDTs (if present.) */
778 if (rsdt != NULL) {
779 ssdt = sdt_from_rsdt(rsdt, "SSDT", NULL);
780 while (ssdt != NULL) {
781 write(fd, ssdt->body, ssdt->len - SIZEOF_SDT_HDR);
782 ssdt = sdt_from_rsdt(rsdt, "SSDT", ssdt);
783 }
784 }
785 return (0);
786 }
787
788 void
789 dsdt_save_file(char *outfile, struct ACPIsdt *rsdt, struct ACPIsdt *dsdp)
790 {
791 int fd;
792 mode_t mode;
793
794 assert(outfile != NULL);
795 mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
796 fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, mode);
797 if (fd == -1) {
798 perror("dsdt_save_file");
799 return;
800 }
801 write_dsdt(fd, rsdt, dsdp);
802 close(fd);
803 }
804
805 void
806 aml_disassemble(struct ACPIsdt *rsdt, struct ACPIsdt *dsdp)
807 {
808 char buf[PATH_MAX], tmpstr[PATH_MAX];
809 const char *tmpdir;
810 char *tmpext;
811 FILE *fp;
812 size_t len;
813 int fd;
814
815 tmpdir = getenv("TMPDIR");
816 if (tmpdir == NULL)
817 tmpdir = _PATH_TMP;
818 strncpy(tmpstr, tmpdir, sizeof(tmpstr));
819 strncat(tmpstr, "/acpidump.", sizeof(tmpstr) - strlen(tmpdir));
820 if (realpath(tmpstr, buf) == NULL) {
821 perror("realpath tmp file");
822 return;
823 }
824 strncpy(tmpstr, buf, sizeof(tmpstr));
825 len = strlen(buf);
826 tmpext = tmpstr + len;
827 strncpy(tmpext, "XXXXXX", sizeof(tmpstr) - len);
828 fd = mkstemp(tmpstr);
829 if (fd < 0) {
830 perror("iasl tmp file");
831 return;
832 }
833 write_dsdt(fd, rsdt, dsdp);
834 close(fd);
835
836 /* Run iasl -d on the temp file */
837 if (fork() == 0) {
838 close(STDOUT_FILENO);
839 if (vflag == 0)
840 close(STDERR_FILENO);
841 execl("/usr/sbin/iasl", "iasl", "-d", tmpstr, NULL);
842 err(1, "exec");
843 }
844
845 wait(NULL);
846 unlink(tmpstr);
847
848 /* Dump iasl's output to stdout */
849 strncpy(tmpext, "dsl", sizeof(tmpstr) - len);
850 fp = fopen(tmpstr, "r");
851 unlink(tmpstr);
852 if (fp == NULL) {
853 perror("iasl tmp file (read)");
854 return;
855 }
856 while ((len = fread(buf, 1, sizeof(buf), fp)) > 0)
857 fwrite(buf, 1, len, stdout);
858 fclose(fp);
859 }
860
861 void
862 sdt_print_all(struct ACPIsdt *rsdp)
863 {
864 acpi_handle_rsdt(rsdp);
865 }
866
867 /* Fetch a table matching the given signature via the RSDT. */
868 struct ACPIsdt *
869 sdt_from_rsdt(struct ACPIsdt *rsdt, const char *sig, struct ACPIsdt *last)
870 {
871 struct ACPIsdt *sdt;
872 vm_offset_t addr;
873 int entries, i;
874
875 entries = (rsdt->len - SIZEOF_SDT_HDR) / addr_size;
876 for (i = 0; i < entries; i++) {
877 switch (addr_size) {
878 case 4:
879 addr = le32dec((char*)rsdt->body + i * addr_size);
880 break;
881 case 8:
882 addr = le64dec((char*)rsdt->body + i * addr_size);
883 break;
884 default:
885 assert((addr = 0));
886 }
887 sdt = (struct ACPIsdt *)acpi_map_sdt(addr);
888 if (last != NULL) {
889 if (sdt == last)
890 last = NULL;
891 continue;
892 }
893 if (memcmp(sdt->signature, sig, strlen(sig)))
894 continue;
895 if (acpi_checksum(sdt, sdt->len))
896 errx(1, "RSDT entry %d is corrupt", i);
897 return (sdt);
898 }
899
900 return (NULL);
901 }
902
903 struct ACPIsdt *
904 dsdt_from_fadt(struct FADTbody *fadt)
905 {
906 struct ACPIsdt *sdt;
907
908 /* Use the DSDT address if it is version 1, otherwise use X_DSDT. */
909 if (acpi_get_fadt_revision(fadt) == 1)
910 sdt = (struct ACPIsdt *)acpi_map_sdt(fadt->dsdt_ptr);
911 else
912 sdt = (struct ACPIsdt *)acpi_map_sdt(fadt->x_dsdt_ptr);
913 if (acpi_checksum(sdt, sdt->len))
914 errx(1, "DSDT is corrupt\n");
915 return (sdt);
916 }
DragonFly BSD