1 /* ----------------------------------------------------------------------- *
2 *
3 * Copyright 2011 Erwan Velu - All Rights Reserved
4 *
5 * Permission is hereby granted, free of charge, to any person
6 * obtaining a copy of this software and associated documentation
7 * files (the "Software"), to deal in the Software without
8 * restriction, including without limitation the rights to use,
9 * copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Software, and to permit persons to whom
11 * the Software is furnished to do so, subject to the following
12 * conditions:
13 *
14 * The above copyright notice and this permission notice shall
15 * be included in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
19 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
21 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 * OTHER DEALINGS IN THE SOFTWARE.
25 *
26 * -----------------------------------------------------------------------
27 */
28
29 #include "hdt-common.h"
30 #include "hdt-dump.h"
31
show_header(char * name,void * address,s_acpi_description_header * h,ZZJSON_CONFIG * config,ZZJSON ** item)32 void show_header(char *name, void *address, s_acpi_description_header *h, ZZJSON_CONFIG *config, ZZJSON **item)
33 {
34 char signature[10]={0};
35 char revision[10]={0};
36 char s_address[16]={0};
37 char oem_id[16]={0};
38 char oem_table_id[16]={0};
39 char oem_revision[16]={0};
40 char creator_revision[16]={0};
41 char creator_id[16]={0};
42 snprintf(signature,sizeof(signature),"%s",h->signature);
43 snprintf(revision,sizeof(revision),"0x%03x",h->revision);
44 snprintf(oem_id,sizeof(oem_id),"%s",h->oem_id);
45 snprintf(oem_table_id,sizeof(oem_table_id),"%s",h->oem_table_id);
46 snprintf(creator_id,sizeof(creator_id),"%s",h->creator_id);
47 snprintf(oem_revision,sizeof(oem_revision),"0x%08x",h->oem_revision);
48 snprintf(creator_revision,sizeof(creator_revision),"0x%08x",h->creator_revision);
49 snprintf(s_address,sizeof(s_address),"%p",address);
50
51 char address_name[32]={0};
52 char signature_name[32]={0};
53 char revision_name[32]={0};
54 char oem_id_name[32]={0};
55 char oem_table_id_name[32]={0};
56 char oem_revision_name[32]={0};
57 char creator_revision_name[32]={0};
58 char creator_id_name[32]={0};
59 snprintf(signature_name,sizeof(signature_name),"acpi.%s.signature",name);
60 snprintf(revision_name,sizeof(revision_name),"acpi.%s.revision",name);
61 snprintf(address_name,sizeof(address_name),"acpi.%s.address",name);
62 snprintf(oem_id_name,sizeof(oem_id_name),"acpi.%s.oem_id",name);
63 snprintf(oem_table_id_name,sizeof(oem_table_id_name),"acpi.%s.oem_table_id",name);
64 snprintf(oem_revision_name,sizeof(oem_revision_name),"acpi.%s.oem_revision",name);
65 snprintf(creator_revision_name,sizeof(creator_revision_name),"acpi.%s.creator_revision",name);
66 snprintf(creator_id_name,sizeof(creator_id_name),"acpi.%s.creator_id",name);
67
68 APPEND_ARRAY
69 add_as(signature_name,signature)
70 add_as(revision_name,revision)
71 add_as(oem_id_name,oem_id)
72 add_as(oem_table_id_name,oem_table_id)
73 add_as(oem_revision_name,oem_revision)
74 add_as(creator_id_name,creator_id)
75 add_as(creator_revision_name,creator_revision)
76 add_as(address_name,s_address)
77 END_OF_APPEND;
78
79 FLUSH_OBJECT;
80
81 }
82
dump_rsdt(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)83 void dump_rsdt(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
84 {
85 char valid[8]={0};
86 snprintf(valid,sizeof(valid),"%s","false");
87 if (acpi->rsdt.valid) {
88 snprintf(valid,sizeof(valid),"%s","true");
89 }
90 CREATE_ARRAY
91 add_as("acpi.item","rsdt")
92 add_as("acpi.rsdt.is_valid",valid)
93 END_OF_ARRAY;
94
95 if (acpi->rsdt.valid==false) {
96 FLUSH_OBJECT;
97 return;
98 }
99
100 show_header("rsdt",acpi->rsdt.address, &acpi->rsdt.header, config, item);
101 }
102
dump_xsdt(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)103 void dump_xsdt(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
104 {
105 char valid[8]={0};
106 snprintf(valid,sizeof(valid),"%s","false");
107 if (acpi->xsdt.valid) {
108 snprintf(valid,sizeof(valid),"%s","true");
109 }
110 CREATE_ARRAY
111 add_as("acpi.item","xsdt")
112 add_as("acpi.xsdt.is_valid",valid)
113 END_OF_ARRAY;
114
115 if (acpi->xsdt.valid==false) {
116 FLUSH_OBJECT;
117 return;
118 }
119
120 show_header("xsdt",acpi->xsdt.address, &acpi->xsdt.header, config, item);
121 }
122
dump_fadt(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)123 void dump_fadt(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
124 {
125 char valid[8]={0};
126 snprintf(valid,sizeof(valid),"%s","false");
127 if (acpi->rsdt.valid) {
128 snprintf(valid,sizeof(valid),"%s","true");
129 }
130 CREATE_ARRAY
131 add_as("acpi.item","fadt")
132 add_as("acpi.fadt.is_valid",valid)
133 END_OF_ARRAY;
134
135 if (acpi->fadt.valid==false) {
136 FLUSH_OBJECT;
137 return;
138 }
139
140 show_header("fadt",acpi->fadt.address, &acpi->fadt.header, config, item);
141 }
142
dump_dsdt(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)143 void dump_dsdt(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
144 {
145 char valid[8]={0};
146 snprintf(valid,sizeof(valid),"%s","false");
147 if (acpi->dsdt.valid) {
148 snprintf(valid,sizeof(valid),"%s","true");
149 }
150 CREATE_ARRAY
151 add_as("acpi.item","dsdt")
152 add_as("acpi.dsdt.is_valid",valid)
153 END_OF_ARRAY;
154
155 if (acpi->dsdt.valid==false) {
156 FLUSH_OBJECT;
157 return;
158 }
159
160 show_header("dsdt",acpi->dsdt.address, &acpi->dsdt.header, config, item);
161 }
162
dump_sbst(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)163 void dump_sbst(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
164 {
165 char valid[8]={0};
166 snprintf(valid,sizeof(valid),"%s","false");
167 if (acpi->sbst.valid) {
168 snprintf(valid,sizeof(valid),"%s","true");
169 }
170 CREATE_ARRAY
171 add_as("acpi.item","sbst")
172 add_as("acpi.sbst.is_valid",valid)
173 END_OF_ARRAY;
174
175 if (acpi->sbst.valid==false) {
176 FLUSH_OBJECT;
177 return;
178 }
179
180 show_header("sbst",acpi->sbst.address, &acpi->sbst.header, config, item);
181 }
182
dump_ecdt(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)183 void dump_ecdt(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
184 {
185 char valid[8]={0};
186 snprintf(valid,sizeof(valid),"%s","false");
187 if (acpi->ecdt.valid) {
188 snprintf(valid,sizeof(valid),"%s","true");
189 }
190 CREATE_ARRAY
191 add_as("acpi.item","ecdt")
192 add_as("acpi.ecdt.is_valid",valid)
193 END_OF_ARRAY;
194
195 if (acpi->ecdt.valid==false) {
196 FLUSH_OBJECT;
197 return;
198 }
199
200 show_header("ecdt",acpi->ecdt.address, &acpi->ecdt.header, config, item);
201 }
202
dump_hpet(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)203 void dump_hpet(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
204 {
205 char valid[8]={0};
206 snprintf(valid,sizeof(valid),"%s","false");
207 if (acpi->hpet.valid) {
208 snprintf(valid,sizeof(valid),"%s","true");
209 }
210 CREATE_ARRAY
211 add_as("acpi.item","hpet")
212 add_as("acpi.hpet.is_valid",valid)
213 END_OF_ARRAY;
214
215 if (acpi->hpet.valid==false) {
216 FLUSH_OBJECT;
217 return;
218 }
219
220 show_header("hpet",acpi->hpet.address, &acpi->hpet.header, config, item);
221 }
222
dump_tcpa(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)223 void dump_tcpa(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
224 {
225 char valid[8]={0};
226 snprintf(valid,sizeof(valid),"%s","false");
227 if (acpi->tcpa.valid) {
228 snprintf(valid,sizeof(valid),"%s","true");
229 }
230 CREATE_ARRAY
231 add_as("acpi.item","tcpa")
232 add_as("acpi.tcpa.is_valid",valid)
233 END_OF_ARRAY;
234
235 if (acpi->tcpa.valid==false) {
236 FLUSH_OBJECT;
237 return;
238 }
239
240 show_header("tcpa",acpi->tcpa.address, &acpi->tcpa.header, config, item);
241 }
242
dump_mcfg(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)243 void dump_mcfg(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
244 {
245 char valid[8]={0};
246 snprintf(valid,sizeof(valid),"%s","false");
247 if (acpi->mcfg.valid) {
248 snprintf(valid,sizeof(valid),"%s","true");
249 }
250 CREATE_ARRAY
251 add_as("acpi.item","mcfg")
252 add_as("acpi.mcfg.is_valid",valid)
253 END_OF_ARRAY;
254
255 if (acpi->mcfg.valid==false) {
256 FLUSH_OBJECT;
257 return;
258 }
259
260 show_header("mcfg",acpi->mcfg.address, &acpi->mcfg.header, config, item);
261 }
262
dump_slic(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)263 void dump_slic(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
264 {
265 char valid[8]={0};
266 snprintf(valid,sizeof(valid),"%s","false");
267 if (acpi->slic.valid) {
268 snprintf(valid,sizeof(valid),"%s","true");
269 }
270 CREATE_ARRAY
271 add_as("acpi.item","slic")
272 add_as("acpi.slic.is_valid",valid)
273 END_OF_ARRAY;
274
275 if (acpi->slic.valid==false) {
276 FLUSH_OBJECT;
277 return;
278 }
279
280 show_header("slic",acpi->slic.address, &acpi->slic.header, config, item);
281 }
282
283
dump_boot(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)284 void dump_boot(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
285 {
286 char valid[8]={0};
287 snprintf(valid,sizeof(valid),"%s","false");
288 if (acpi->boot.valid) {
289 snprintf(valid,sizeof(valid),"%s","true");
290 }
291 CREATE_ARRAY
292 add_as("acpi.item","boot")
293 add_as("acpi.boot.is_valid",valid)
294 END_OF_ARRAY;
295
296 if (acpi->boot.valid==false) {
297 FLUSH_OBJECT;
298 return;
299 }
300
301 show_header("boot",acpi->boot.address, &acpi->boot.header, config, item);
302 }
303
dump_madt(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)304 void dump_madt(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
305 {
306 char valid[8]={0};
307 snprintf(valid,sizeof(valid),"%s","false");
308 if (acpi->madt.valid) {
309 snprintf(valid,sizeof(valid),"%s","true");
310 }
311 CREATE_ARRAY
312 add_as("acpi.item","madt")
313 add_as("acpi.madt.is_valid",valid)
314 END_OF_ARRAY;
315
316 if (acpi->madt.valid==false) {
317 FLUSH_OBJECT;
318 return;
319 }
320
321 show_header("madt",acpi->madt.address, &acpi->madt.header, config, item);
322 }
323
dump_ssdt(s_ssdt * ssdt,ZZJSON_CONFIG * config,ZZJSON ** item)324 void dump_ssdt(s_ssdt *ssdt, ZZJSON_CONFIG * config, ZZJSON ** item)
325 {
326 char valid[8]={0};
327 snprintf(valid,sizeof(valid),"%s","false");
328 if (ssdt->valid) {
329 snprintf(valid,sizeof(valid),"%s","true");
330 }
331 CREATE_ARRAY
332 add_as("acpi.item","ssdt")
333 add_as("acpi.ssdt.is_valid",valid)
334 END_OF_ARRAY;
335
336 if (ssdt->valid==false) {
337 FLUSH_OBJECT;
338 return;
339 }
340
341 show_header("ssdt",ssdt->address, &ssdt->header, config, item);
342 }
343
dump_rsdp(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)344 void dump_rsdp(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
345 {
346 char valid[8]={0};
347 snprintf(valid,sizeof(valid),"%s","false");
348 if (acpi->rsdp.valid) {
349 snprintf(valid,sizeof(valid),"%s","true");
350 }
351 CREATE_ARRAY
352 add_as("acpi.item","rsdp")
353 add_as("acpi.rsdp.is_valid",valid)
354 END_OF_ARRAY;
355
356 if (acpi->rsdp.valid==false) {
357 FLUSH_OBJECT;
358 return;
359 }
360
361 s_rsdp *r = &acpi->rsdp;
362 char revision[10]={0};
363 char address[16]={0};
364 char oem_id[16]={0};
365 snprintf(revision,sizeof(revision),"0x%03x",r->revision);
366 snprintf(address,sizeof(address),"%p",r->address);
367 snprintf(oem_id,sizeof(oem_id),"%s",r->oem_id);
368 APPEND_ARRAY
369 add_as("acpi.rsdp.revision",revision)
370 add_as("acpi.rsdp.oem_id",oem_id)
371 add_as("acpi.rsdp.address",address)
372 END_OF_APPEND;
373
374 FLUSH_OBJECT;
375
376 }
377
dump_facs(s_acpi * acpi,ZZJSON_CONFIG * config,ZZJSON ** item)378 void dump_facs(s_acpi * acpi, ZZJSON_CONFIG * config, ZZJSON ** item)
379 {
380 char valid[8]={0};
381 snprintf(valid,sizeof(valid),"%s","false");
382 if (acpi->facs.valid) {
383 snprintf(valid,sizeof(valid),"%s","true");
384 }
385 CREATE_ARRAY
386 add_as("acpi.item","facs")
387 add_as("acpi.facs.is_valid",valid)
388 END_OF_ARRAY;
389
390 if (acpi->facs.valid==false) {
391 FLUSH_OBJECT;
392 return;
393 }
394
395 s_facs *fa = &acpi->facs;
396 char address[16]={0};
397 snprintf(address,sizeof(address),"%p",fa->address);
398 APPEND_ARRAY
399 add_as("acpi.facs.address",address)
400 END_OF_APPEND;
401
402 FLUSH_OBJECT;
403
404 }
405
dump_interrupt_source_override(s_madt * madt,ZZJSON_CONFIG * config,ZZJSON ** item)406 void dump_interrupt_source_override(s_madt * madt, ZZJSON_CONFIG * config, ZZJSON ** item)
407 {
408 CREATE_ARRAY
409 add_as("acpi.item","interrupt_source_override")
410 add_ai("acpi.interrupt_source_override.count", madt->interrupt_source_override_count)
411 END_OF_ARRAY;
412
413 if (madt->interrupt_source_override_count == 0) {
414 FLUSH_OBJECT;
415 return;
416 }
417
418 /* Let's process each interrupt source override */
419 for (int i = 0; i < madt->interrupt_source_override_count; i++) {
420 s_interrupt_source_override *siso = &madt->interrupt_source_override[i];
421 char buffer[20] = {0};
422 char bus_type[10]= {0};
423
424 /* Spec report bus type 0 as ISA */
425 if (siso->bus == 0)
426 strcpy(bus_type, "ISA");
427 else
428 strcpy(bus_type, "unknown");
429
430 APPEND_ARRAY
431 add_as("acpi.interrupt_source_override.bus_type",bus_type)
432 add_ai("acpi.interrupt_source_override.bus",siso->bus)
433 add_ai("acpi.interrupt_source_override.bus_irq",siso->source)
434 add_ai("acpi.interrupt_source_override.global_irq",siso->global_system_interrupt)
435 add_as("acpi.interrupt_source_override.flags",flags_to_string(buffer,siso->flags))
436 END_OF_APPEND;
437 }
438 FLUSH_OBJECT;
439 }
440
dump_io_apic(s_madt * madt,ZZJSON_CONFIG * config,ZZJSON ** item)441 void dump_io_apic(s_madt * madt, ZZJSON_CONFIG * config, ZZJSON ** item)
442 {
443 CREATE_ARRAY
444 add_as("acpi.item","io_apic")
445 add_ai("acpi.io_apic.count", madt->io_apic_count)
446 END_OF_ARRAY;
447
448 if (madt->io_apic_count == 0) {
449 FLUSH_OBJECT;
450 return;
451 }
452
453 /* For all IO APICS */
454 for (int i = 0; i < madt->io_apic_count; i++) {
455 s_io_apic *sio = &madt->io_apic[i];
456 char buffer[15]={0};
457 memset(buffer, 0, sizeof(buffer));
458 /* GSI base reports the GSI configuration
459 * Let's interpret it as string */
460 switch (sio->global_system_interrupt_base) {
461 case 0:
462 strcpy(buffer, "0-23");
463 break;
464 case 24:
465 strcpy(buffer,"24-39");
466 break;
467 case 40:
468 strcpy(buffer, "40-55");
469 break;
470 default:
471 strcpy(buffer,"Unknown");
472 break;
473 }
474
475 char apic_id[16] = { 0 };
476 char address[16] = { 0 };
477 snprintf(apic_id,sizeof(apic_id),"0x%02x",sio->io_apic_id);
478 snprintf(address,sizeof(address),"0x%08x",sio->io_apic_address);
479 APPEND_ARRAY
480 add_ai("acpi.io_apic.number",i)
481 add_as("acpi.io_apic.apic_id",apic_id)
482 add_as("acpi.io_apic.adress",address)
483 add_as("acpi.io_apic.gsi",buffer)
484 END_OF_APPEND;
485 }
486 FLUSH_OBJECT;
487 }
488
dump_local_apic_nmi(s_madt * madt,ZZJSON_CONFIG * config,ZZJSON ** item)489 void dump_local_apic_nmi(s_madt * madt, ZZJSON_CONFIG * config, ZZJSON ** item)
490 {
491 CREATE_ARRAY
492 add_as("acpi.item","local_apic_nmi")
493 add_ai("acpi.local_apic_nmi.count", madt->local_apic_nmi_count)
494 END_OF_ARRAY;
495
496 if (madt->local_apic_nmi_count == 0) {
497 FLUSH_OBJECT;
498 return;
499 }
500
501 for (int i = 0; i < madt->local_apic_nmi_count; i++) {
502 s_local_apic_nmi *slan = &madt->local_apic_nmi[i];
503 char buffer[20]={0};
504 char acpi_id[16] = { 0 };
505 char local_apic_lint[16] = { 0 };
506 snprintf(acpi_id, sizeof(acpi_id), "0x%02x", slan->acpi_processor_id);
507 snprintf(local_apic_lint, sizeof(local_apic_lint), "0x%02x", slan->local_apic_lint);
508 APPEND_ARRAY
509 add_as("acpi.processor_id", acpi_id)
510 add_as("acpi.local_apic_nmi.flags", flags_to_string(buffer,slan->flags))
511 add_as("acpi.local_apic_nmi.lint",local_apic_lint)
512 END_OF_APPEND;
513 }
514
515 FLUSH_OBJECT;
516 }
517
dump_local_apic(s_madt * madt,ZZJSON_CONFIG * config,ZZJSON ** item)518 void dump_local_apic(s_madt * madt, ZZJSON_CONFIG * config, ZZJSON ** item)
519 {
520 char buffer[16] = { 0 };
521 snprintf(buffer, sizeof(buffer), "0x%08x", madt->local_apic_address);
522
523 CREATE_ARRAY
524 add_as("acpi.item","local_apic")
525 add_as("acpi.local_apic.address", buffer)
526 add_ai("acpi.processor_local_apic.count", madt->processor_local_apic_count)
527 END_OF_ARRAY;
528
529 if (madt->processor_local_apic_count ==0) {
530 FLUSH_OBJECT;
531 return;
532 }
533
534 /* For all detected logical CPU */
535 for (int i = 0; i < madt->processor_local_apic_count; i++) {
536 s_processor_local_apic *sla = &madt->processor_local_apic[i];
537 char lapic_status[16] = { 0 };
538 char acpi_id[16] = { 0 };
539 char apic_id[16] = { 0 };
540
541 snprintf(lapic_status,sizeof(lapic_status),"%s","disabled");
542 /* Let's check if the flags reports the cpu as enabled */
543 if ((sla->flags & PROCESSOR_LOCAL_APIC_ENABLE) ==
544 PROCESSOR_LOCAL_APIC_ENABLE)
545 snprintf(lapic_status,sizeof(lapic_status),"%s","enabled");
546 snprintf(acpi_id, sizeof(acpi_id), "0x%02x", sla->acpi_id);
547 snprintf(apic_id, sizeof(apic_id), "0x%02x", sla->apic_id);
548 APPEND_ARRAY
549 add_ai("acpi.cpu.apic_id", sla->apic_id)
550 add_as("acpi.cpu.apic_id (hex)", apic_id)
551 add_as("acpi.cpu.acpi_id (hex)", acpi_id)
552 add_as("acpi.lapic.enabled", lapic_status)
553 END_OF_APPEND;
554 }
555 FLUSH_OBJECT;
556 }
557
dump_acpi(struct s_hardware * hardware,ZZJSON_CONFIG * config,ZZJSON ** item)558 void dump_acpi(struct s_hardware *hardware, ZZJSON_CONFIG * config,
559 ZZJSON ** item)
560 {
561 CREATE_NEW_OBJECT;
562 add_hb(is_acpi_valid);
563 if (hardware->is_acpi_valid == false)
564 goto exit;
565
566 s_madt *madt = &hardware->acpi.madt;
567 add_b("acpi.apic.detected", madt->valid);
568 if (madt->valid == false) {
569 goto exit;
570 }
571
572 FLUSH_OBJECT;
573
574 dump_local_apic(madt, config, item);
575 dump_local_apic_nmi(madt, config, item);
576 dump_io_apic(madt, config, item);
577 dump_interrupt_source_override(madt, config, item);
578
579 dump_rsdp(&hardware->acpi,config,item);
580 dump_rsdt(&hardware->acpi,config,item);
581 dump_xsdt(&hardware->acpi,config,item);
582 dump_fadt(&hardware->acpi,config,item);
583 dump_dsdt(&hardware->acpi,config,item);
584 dump_sbst(&hardware->acpi,config,item);
585 dump_ecdt(&hardware->acpi,config,item);
586 dump_hpet(&hardware->acpi,config,item);
587 dump_tcpa(&hardware->acpi,config,item);
588 dump_mcfg(&hardware->acpi,config,item);
589 dump_slic(&hardware->acpi,config,item);
590 dump_boot(&hardware->acpi,config,item);
591 dump_madt(&hardware->acpi,config,item);
592 for (int i = 0; i < hardware->acpi.ssdt_count; i++) {
593 if ((hardware->acpi.ssdt[i] != NULL) && (hardware->acpi.ssdt[i]->valid))
594 dump_ssdt(hardware->acpi.ssdt[i], config, item);
595 }
596 dump_facs(&hardware->acpi,config,item);
597
598 exit:
599 to_cpio("acpi");
600 }
601