/* ----------------------------------------------------------------------- *
*
* Copyright 2010 Intel Corporation; author: H. Peter Anvin
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston MA 02110-1301, USA; either version 2 of the License, or
* (at your option) any later version; incorporated herein by reference.
*
* ----------------------------------------------------------------------- */
/*
* Dump ACPI information
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "sysdump.h"
#include "backend.h"
#include "rbtree.h"
struct acpi_rsdp {
uint8_t magic[8]; /* "RSD PTR " */
uint8_t csum;
char oemid[6];
uint8_t rev;
uint32_t rsdt_addr;
uint32_t len;
uint64_t xsdt_addr;
uint8_t xcsum;
uint8_t rsvd[3];
};
struct acpi_hdr {
char sig[4]; /* Signature */
uint32_t len;
uint8_t rev;
uint8_t csum;
char oemid[6];
char oemtblid[16];
uint32_t oemrev;
uint32_t creatorid;
uint32_t creatorrev;
};
struct acpi_rsdt {
struct acpi_hdr hdr;
uint32_t entry[0];
};
struct acpi_xsdt {
struct acpi_hdr hdr;
uint64_t entry[0];
};
static struct rbtree *rb_types, *rb_addrs;
static bool rb_has(struct rbtree **tree, uint64_t key)
{
struct rbtree *node;
node = rb_search(*tree, key);
if (node && node->key == key)
return true;
node = malloc(sizeof *node);
if (node) {
node->key = key;
*tree = rb_insert(*tree, node);
}
return false;
}
static inline bool addr_ok(uint64_t addr)
{
/* We can only handle 32-bit addresses for now... */
return addr <= 0xffffffff;
}
enum tbl_errs {
ERR_NONE, /* No errors */
ERR_CSUM, /* Invalid checksum */
ERR_SIZE, /* Impossibly large table */
ERR_NOSIG /* No signature */
};
static uint8_t checksum_range(const void *start, uint32_t size)
{
const uint8_t *p = start;
uint8_t csum = 0;
while (size--)
csum += *p++;
return csum;
}
static enum tbl_errs is_valid_table(const void *ptr)
{
const struct acpi_hdr *hdr = ptr;
if (hdr->sig[0] == 0)
return ERR_NOSIG;
if (hdr->len < 10 || hdr->len > (1 << 20)) {
/* Either insane or too large to dump */
return ERR_SIZE;
}
return checksum_range(hdr, hdr->len) == 0 ? ERR_NONE : ERR_CSUM;
}
static const struct acpi_rsdp *scan_for_rsdp(uint32_t base, uint32_t end)
{
for (base &= ~15; base < end-20; base += 16) {
const struct acpi_rsdp *rsdp = (const struct acpi_rsdp *)base;
if (memcmp(rsdp->magic, "RSD PTR ", 8))
continue;
if (checksum_range(rsdp, 20))
continue;
if (rsdp->rev > 0) {
if (base + rsdp->len >= end ||
checksum_range(rsdp, rsdp->len))
continue;
}
return rsdp;
}
return NULL;
}
static const struct acpi_rsdp *find_rsdp(void)
{
uint32_t ebda;
const struct acpi_rsdp *rsdp;
ebda = (*(uint16_t *)0x40e) << 4;
if (ebda >= 0x70000 && ebda < 0xa0000) {
rsdp = scan_for_rsdp(ebda, ebda+1024);
if (rsdp)
return rsdp;
}
return scan_for_rsdp(0xe0000, 0x100000);
}
static void dump_table(struct backend *be,
const char name[], const void *ptr, uint32_t len)
{
char namebuf[64];
uint32_t name_key = *(uint32_t *)name;
if (rb_has(&rb_addrs, (size_t)ptr))
return; /* Already dumped this table */
if (!rb_has(&rb_types, name_key)) {
snprintf(namebuf, sizeof namebuf, "acpi/%4.4s", name);
cpio_mkdir(be, namebuf);
}
snprintf(namebuf, sizeof namebuf, "acpi/%4.4s/%08x", name, (uint32_t)ptr);
cpio_hdr(be, MODE_FILE, len, namebuf);
write_data(be, ptr, len);
}
static void dump_rsdt(struct backend *be, const struct acpi_rsdp *rsdp)
{
const struct acpi_rsdt *rsdt;
uint32_t i, n;
rsdt = (const struct acpi_rsdt *)rsdp->rsdt_addr;
if (memcmp(rsdt->hdr.sig, "RSDT", 4) || is_valid_table(rsdt) > ERR_CSUM)
return;
dump_table(be, rsdt->hdr.sig, rsdt, rsdt->hdr.len);
if (rsdt->hdr.len < 36)
return;
n = (rsdt->hdr.len - 36) >> 2;
for (i = 0; i < n; i++) {
const struct acpi_hdr *hdr = (const struct acpi_hdr *)(rsdt->entry[i]);
if (is_valid_table(hdr) <= ERR_CSUM)
dump_table(be, hdr->sig, hdr, hdr->len);
}
}
static void dump_xsdt(struct backend *be, const struct acpi_rsdp *rsdp)
{
const struct acpi_xsdt *xsdt;
uint32_t rsdp_len = rsdp->rev > 0 ? rsdp->len : 20;
uint32_t i, n;
if (rsdp_len < 34)
return;
if (!addr_ok(rsdp->xsdt_addr))
return;
xsdt = (const struct acpi_xsdt *)(size_t)rsdp->xsdt_addr;
if (memcmp(xsdt->hdr.sig, "XSDT", 4) || is_valid_table(xsdt) > ERR_CSUM)
return;
dump_table(be, xsdt->hdr.sig, xsdt, xsdt->hdr.len);
if (xsdt->hdr.len < 36)
return;
n = (xsdt->hdr.len - 36) >> 3;
for (i = 0; i < n; i++) {
const struct acpi_hdr *hdr;
if (addr_ok(xsdt->entry[i])) {
hdr = (const struct acpi_hdr *)(size_t)(xsdt->entry[i]);
if (is_valid_table(hdr) <= ERR_CSUM)
dump_table(be, hdr->sig, hdr, hdr->len);
}
}
}
void dump_acpi(struct backend *be)
{
const struct acpi_rsdp *rsdp;
uint32_t rsdp_len;
rsdp = find_rsdp();
printf("Dumping ACPI... ");
if (!rsdp)
return; /* No ACPI information found */
cpio_mkdir(be, "acpi");
rsdp_len = rsdp->rev > 0 ? rsdp->len : 20;
dump_table(be, "RSDP", rsdp, rsdp_len);
dump_rsdt(be, rsdp);
dump_xsdt(be, rsdp);
rb_destroy(rb_types);
rb_destroy(rb_addrs);
printf("done.\n");
}
