Add the helper strtoul_from_ubuf()
[akaros.git] / kern / drivers / dev / acpi.c
index 65de225..66ab1a0 100644 (file)
@@ -1,4 +1,4 @@
-/* 
+/*
  * This file is part of the UCB release of Plan 9. It is subject to the license
  * terms in the LICENSE file found in the top-level directory of this
  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
@@ -20,7 +20,9 @@
 #include <pmap.h>
 #include <smp.h>
 #include <ip.h>
+#include <ns.h>
 #include <acpi.h>
+#include <slice.h>
 
 #include "../timers/hpet.h"
 
 #include <arch/pci.h>
 #endif
 
+/* -----------------------------------------------------------------------------
+ * Basic ACPI device.
+ *
+ * The qid.Path will be made unique by incrementing lastpath. lastpath starts
+ * at Qroot.
+ *
+ * Qtbl will return a pointer to the Atable, which includes the signature, OEM
+ * data, and so on.
+ *
+ * Raw, at any level, dumps the raw table at that level, which by the ACPI
+ * flattened tree layout will include all descendents.
+ *
+ * Qpretty, at any level, will print the pretty form for that level and all
+ * descendants.
+ */
+enum {
+       Qroot = 0,
+
+       // The type is the qid.path mod NQtypes.
+       Qdir = 0,
+       Qpretty,
+       Qraw,
+       Qtbl,
+       NQtypes,
+
+       QIndexShift = 8,
+       QIndexMask = (1 << QIndexShift) - 1,
+};
+
+#define ATABLEBUFSZ    ROUNDUP(sizeof(struct Atable), KMALLOC_ALIGNMENT)
+
+static uint64_t lastpath;
+static struct slice emptyslice;
+static struct Atable **atableindex;
 struct dev acpidevtab;
 
 static char *devname(void)
@@ -39,96 +75,143 @@ static char *devname(void)
  * ACPI 4.0 Support.
  * Still WIP.
  *
- * This driver locates tables and parses only the FADT
- * and the XSDT. All other tables are mapped and kept there
- * for the user-level interpreter.
+ * This driver locates tables and parses only a small subset
+ * of tables. All other tables are mapped and kept for the user-level
+ * interpreter.
  */
-
-static struct Atable *acpifadt(uint8_t *, int);
-static struct Atable *acpitable(uint8_t *, int);
-static struct Atable *acpimadt(uint8_t *, int);
-static struct Atable *acpimsct(uint8_t *, int);
-static struct Atable *acpisrat(uint8_t *, int);
-static struct Atable *acpislit(uint8_t *, int);
-
 static struct cmdtab ctls[] = {
        {CMregion, "region", 6},
        {CMgpe, "gpe", 3},
 };
 
-static struct dirtab acpidir[] = {
-       {".", {Qdir, 0, QTDIR}, 0, DMDIR | 0555},
-       {"acpictl", {Qctl}, 0, 0666},
-       {"acpitbl", {Qtbl}, 0, 0444},
-       {"acpiregio", {Qio}, 0, 0666},
-       {"acpipretty", {Qpretty}, 0, 0444},
-       {"ioapic", {Qioapic}, 0, 0444},
-       {"apic", {Qapic}, 0, 0444},
-};
-
-/*
- * The DSDT is always given to the user interpreter.
- * Tables listed here are also loaded from the XSDT:
- * MSCT, MADT, and FADT are processed by us, because they are
- * required to do early initialization before we have user processes.
- * Other tables are given to the user level interpreter for
- * execution.
- *
- * These historically returned a value to tell acpi whether or not it was okay
- * to unmap the table.  (return 0 means there was no table, meaning it was okay
- * to unmap).  We just use the kernbase mapping, so it's irrelevant. */
-static struct Parse ptables[] = {
-       {"FACP", acpifadt},
-       {"APIC", acpimadt,},
-       {"SRAT", acpisrat,},
-       {"SLIT", acpislit,},
-       {"MSCT", acpimsct,},
-       {"SSDT", acpitable,},
-       {"HPET", acpihpet,},
-};
-
 static struct Facs *facs;              /* Firmware ACPI control structure */
-static struct Fadt fadt;               /* Fixed ACPI description. To reach ACPI registers */
+static struct Fadt *fadt;              /* Fixed ACPI description to reach ACPI regs */
+static struct Atable *root;
 static struct Xsdt *xsdt;              /* XSDT table */
 static struct Atable *tfirst;  /* loaded DSDT/SSDT/... tables */
 static struct Atable *tlast;   /* pointer to last table */
-struct Madt *apics;                            /* APIC info */
-struct Srat *srat;                             /* System resource affinity, used by physalloc */
-static struct Slit *slit;              /* System locality information table used by the scheduler */
-static struct Msct *msct;              /* Maximum system characteristics table */
+struct Atable *apics;                  /* APIC info */
+struct Atable *srat;                   /* System resource affinity used by physalloc */
+struct Atable *dmar;
+static struct Slit *slit;              /* Sys locality info table used by scheduler */
+static struct Atable *mscttbl;         /* Maximum system characteristics table */
 static struct Reg *reg;                        /* region used for I/O */
 static struct Gpe *gpes;               /* General purpose events */
 static int ngpes;
 
 static char *regnames[] = {
        "mem", "io", "pcicfg", "embed",
-       "smb", "cmos", "pcibar",
+       "smb", "cmos", "pcibar", "ipmi",
 };
 
+/*
+ * Lists to store RAM that we copy ACPI tables into. When we map a new
+ * ACPI list into the kernel, we copy it into a specifically RAM buffer
+ * (to make sure it's not coming from e.g. slow device memory). We store
+ * pointers to those buffers on these lists.
+ */
+struct Acpilist {
+       struct Acpilist *next;
+       size_t size;
+       int8_t raw[];
+};
+
+static struct Acpilist *acpilists;
+
+/*
+ * Produces an Atable at some level in the tree. Note that Atables are
+ * isomorphic to directories in the file system namespace; this code
+ * ensures that invariant.
+ */
+struct Atable *mkatable(struct Atable *parent,
+                        int type, char *name, uint8_t *raw,
+                        size_t rawsize, size_t addsize)
+{
+       void *m;
+       struct Atable *t;
+
+       m = kzmalloc(ATABLEBUFSZ + addsize, MEM_WAIT);
+       if (m == NULL)
+               panic("no memory for more aml tables");
+       t = m;
+       t->parent = parent;
+       t->tbl = NULL;
+       if (addsize != 0)
+               t->tbl = m + ATABLEBUFSZ;
+       t->rawsize = rawsize;
+       t->raw = raw;
+       strlcpy(t->name, name, sizeof(t->name));
+       mkqid(&t->qid,  (lastpath << QIndexShift) + Qdir, 0, QTDIR);
+       mkqid(&t->rqid, (lastpath << QIndexShift) + Qraw, 0, 0);
+       mkqid(&t->pqid, (lastpath << QIndexShift) + Qpretty, 0, 0);
+       mkqid(&t->tqid, (lastpath << QIndexShift) + Qtbl, 0, 0);
+       lastpath++;
+
+       return t;
+}
+
+struct Atable *finatable(struct Atable *t, struct slice *slice)
+{
+       size_t n;
+       struct Atable *tail;
+       struct dirtab *dirs;
+
+       n = slice_len(slice);
+       t->nchildren = n;
+       t->children = (struct Atable **)slice_finalize(slice);
+       dirs = kreallocarray(NULL, n + NQtypes, sizeof(struct dirtab),
+                            MEM_WAIT);
+       assert(dirs != NULL);
+       dirs[0] = (struct dirtab){ ".",      t->qid,   0, 0555 };
+       dirs[1] = (struct dirtab){ "pretty", t->pqid,  0, 0444 };
+       dirs[2] = (struct dirtab){ "raw",    t->rqid,  0, 0444 };
+       dirs[3] = (struct dirtab){ "table",  t->tqid,  0, 0444 };
+       for (size_t i = 0; i < n; i++) {
+               strlcpy(dirs[i + NQtypes].name, t->children[i]->name, KNAMELEN);
+               dirs[i + NQtypes].qid = t->children[i]->qid;
+               dirs[i + NQtypes].length = 0;
+               dirs[i + NQtypes].perm = DMDIR | 0555;
+       }
+       t->cdirs = dirs;
+       tail = NULL;
+       while (n-- > 0) {
+               t->children[n]->next = tail;
+               tail = t->children[n];
+       }
+
+       return t;
+}
+
+struct Atable *finatable_nochildren(struct Atable *t)
+{
+       return finatable(t, &emptyslice);
+}
+
 static char *dumpGas(char *start, char *end, char *prefix, struct Gas *g);
+static void dumpxsdt(void);
 
 static char *acpiregstr(int id)
 {
        static char buf[20];            /* BUG */
 
-       if (id >= 0 && id < ARRAY_SIZE(regnames)) {
+       if (id >= 0 && id < ARRAY_SIZE(regnames))
                return regnames[id];
-       }
        seprintf(buf, buf + sizeof(buf), "spc:%#x", id);
        return buf;
 }
 
 static int acpiregid(char *s)
 {
-       int i;
-
-       for (i = 0; i < ARRAY_SIZE(regnames); i++)
-               if (strcmp(regnames[i], s) == 0) {
+       for (int i = 0; i < ARRAY_SIZE(regnames); i++)
+               if (strcmp(regnames[i], s) == 0)
                        return i;
-               }
        return -1;
 }
 
+/*
+ * TODO(rminnich): Fix these if we're ever on a different-endian machine.
+ * They are specific to little-endian processors and are not portable.
+ */
 static uint8_t mget8(uintptr_t p, void *unused)
 {
        uint8_t *cp = (uint8_t *) p;
@@ -207,8 +290,10 @@ static void ioset32(uintptr_t p, uint32_t v, void *unused)
        outl(p, v);
 }
 
-/* TODO: these cfgs are hacky. maybe all the struct Reg should have struct
- * pci_device or something? */
+/*
+ * TODO(rminnich): these cfgs are hacky. Maybe all the struct Reg should have
+ * struct pci_device or something?
+ */
 static uint8_t cfgget8(uintptr_t p, void *r)
 {
        struct Reg *ro = r;
@@ -347,7 +432,7 @@ static long regio(struct Reg *r, void *p, uint32_t len, uintptr_t off, int iswr)
                        if (r->p == NULL)
                                r->p = KADDR_NOCHECK(r->base);
                        if (r->p == NULL)
-                               error("regio: vmap/KADDR failed");
+                               error(EFAIL, "regio: vmap/KADDR failed");
                        rp = (uintptr_t) r->p + off;
                        rio = memio;
                        break;
@@ -367,7 +452,7 @@ static long regio(struct Reg *r, void *p, uint32_t len, uintptr_t off, int iswr)
                case Ripmi:
                case Rfixedhw:
                        printd("regio: reg %s not supported\n", acpiregstr(r->spc));
-                       error("region not supported");
+                       error(EFAIL, "region not supported");
        }
        if (iswr)
                regcpy(&rio, rp, &memio, (uintptr_t) p, len, r->accsz);
@@ -376,51 +461,24 @@ static long regio(struct Reg *r, void *p, uint32_t len, uintptr_t off, int iswr)
        return len;
 }
 
-struct Atable *new_acpi_table(uint8_t * p)
-{
-       struct Atable *t;
-       struct Sdthdr *h;
-
-       t = kzmalloc(sizeof(struct Atable), 0);
-       if (t == NULL)
-               panic("no memory for more aml tables");
-       t->tbl = p;
-       h = (struct Sdthdr *)t->tbl;
-       t->is64 = h->rev >= 2;
-       t->dlen = l32get(h->length) - Sdthdrsz;
-       memmove(t->sig, h->sig, sizeof(h->sig));
-       t->sig[sizeof(t->sig) - 1] = 0;
-       memmove(t->oemid, h->oemid, sizeof(h->oemid));
-       t->oemtblid[sizeof(t->oemtblid) - 1] = 0;
-       memmove(t->oemtblid, h->oemtblid, sizeof(h->oemtblid));
-       t->oemtblid[sizeof(t->oemtblid) - 1] = 0;
-       t->next = NULL;
-       if (tfirst == NULL)
-               tfirst = tlast = t;
-       else {
-               tlast->next = t;
-               tlast = t;
-       }
-       return t;
-}
-
-static void *sdtchecksum(void *addr, int len)
+/*
+ * Compute and return SDT checksum: '0' is a correct sum.
+ */
+static uint8_t sdtchecksum(void *addr, int len)
 {
        uint8_t *p, sum;
 
        sum = 0;
        for (p = addr; len-- > 0; p++)
                sum += *p;
-       if (sum == 0) {
-               return addr;
-       }
 
-       return NULL;
+       return sum;
 }
 
-static void *sdtmap(uintptr_t pa, int *n, int cksum)
+static void *sdtmap(uintptr_t pa, size_t *n, int cksum)
 {
        struct Sdthdr *sdt;
+       struct Acpilist *p;
 
        if (!pa) {
                printk("sdtmap: NULL pa\n");
@@ -428,39 +486,42 @@ static void *sdtmap(uintptr_t pa, int *n, int cksum)
        }
        sdt = KADDR_NOCHECK(pa);
        if (sdt == NULL) {
-               printk("acpi: vmap1: NULL\n");
+               printk("acpi: vmap: NULL\n");
                return NULL;
        }
        *n = l32get(sdt->length);
        if (!*n) {
-               printk("sdt has zero length!\n");
-               return NULL;
-       }
-       if ((sdt = KADDR_NOCHECK(pa)) == NULL) {
-               printk("acpi: NULL vmap\n");
+               printk("sdt has zero length: pa = %p, sig = %.4s\n", pa, sdt->sig);
                return NULL;
        }
-       if (cksum != 0 && sdtchecksum(sdt, *n) == NULL) {
-               printk("acpi: SDT: bad checksum\n");
+       if (cksum != 0 && sdtchecksum(sdt, *n) != 0) {
+               printk("acpi: SDT: bad checksum. pa = %p, len = %lu\n", pa, *n);
                return NULL;
        }
-       return sdt;
+       p = kzmalloc(sizeof(struct Acpilist) + *n, MEM_WAIT);
+       if (p == NULL)
+               panic("sdtmap: memory allocation failed for %lu bytes", *n);
+       memmove(p->raw, (void *)sdt, *n);
+       p->size = *n;
+       p->next = acpilists;
+       acpilists = p;
+
+       return p->raw;
 }
 
 static int loadfacs(uintptr_t pa)
 {
-       int n;
+       size_t n;
 
        facs = sdtmap(pa, &n, 0);
-       if (facs == NULL) {
+       if (facs == NULL)
                return -1;
-       }
-       if (memcmp(facs, "FACS", 4) != 0) {
+       if (memcmp(facs->sig, "FACS", 4) != 0) {
                facs = NULL;
                return -1;
        }
-       /* no unmap */
 
+       /* no unmap */
        printd("acpi: facs: hwsig: %#p\n", facs->hwsig);
        printd("acpi: facs: wakingv: %#p\n", facs->wakingv);
        printd("acpi: facs: flags: %#p\n", facs->flags);
@@ -468,21 +529,23 @@ static int loadfacs(uintptr_t pa)
        printd("acpi: facs: xwakingv: %#p\n", facs->xwakingv);
        printd("acpi: facs: vers: %#p\n", facs->vers);
        printd("acpi: facs: ospmflags: %#p\n", facs->ospmflags);
+
        return 0;
 }
 
 static void loaddsdt(uintptr_t pa)
 {
-       int n;
+       size_t n;
        uint8_t *dsdtp;
 
        dsdtp = sdtmap(pa, &n, 1);
        if (dsdtp == NULL) {
+               printk("acpi: Failed to map dsdtp.\n");
                return;
        }
 }
 
-static void gasget(struct Gas *gas, uint8_t * p)
+static void gasget(struct Gas *gas, uint8_t *p)
 {
        gas->spc = p[0];
        gas->len = p[1];
@@ -493,10 +556,10 @@ static void gasget(struct Gas *gas, uint8_t * p)
 
 static char *dumpfadt(char *start, char *end, struct Fadt *fp)
 {
-       if (2 == 0) {
-               return NULL;
-       }
+       if (fp == NULL)
+               return start;
 
+       start = seprintf(start, end, "acpi: FADT@%p\n", fp);
        start = seprintf(start, end, "acpi: fadt: facs: $%p\n", fp->facs);
        start = seprintf(start, end, "acpi: fadt: dsdt: $%p\n", fp->dsdt);
        start = seprintf(start, end, "acpi: fadt: pmprofile: $%p\n", fp->pmprofile);
@@ -559,15 +622,21 @@ static char *dumpfadt(char *start, char *end, struct Fadt *fp)
        return start;
 }
 
-static struct Atable *acpifadt(uint8_t * p, int len)
+static struct Atable *parsefadt(struct Atable *parent,
+                                                               char *name, uint8_t *p, size_t rawsize)
 {
+       struct Atable *t;
        struct Fadt *fp;
 
-       if (len < 116) {
+       t = mkatable(parent, FADT, name, p, rawsize, sizeof(struct Fadt));
+
+       if (rawsize < 116) {
                printk("ACPI: unusually short FADT, aborting!\n");
-               return 0;
+               return t;
        }
-       fp = &fadt;
+       /* for now, keep the globals. We'll get rid of them later. */
+       fp = t->tbl;
+       fadt = fp;
        fp->facs = l32get(p + 36);
        fp->dsdt = l32get(p + 40);
        fp->pmprofile = p[45];
@@ -605,9 +674,12 @@ static struct Atable *acpifadt(uint8_t * p, int len)
        fp->iapcbootarch = l16get(p + 109);
        fp->flags = l32get(p + 112);
 
-       /* qemu gives us a 116 byte fadt, though i haven't seen any HW do that. */
-       if (len < 244)
-               return 0;
+       /*
+        * qemu gives us a 116 byte fadt, though i haven't seen any HW do that.
+        * The right way to do this is to realloc the table and fake it out.
+        */
+       if (rawsize < 244)
+               return finatable_nochildren(t);
 
        gasget(&fp->resetreg, p + 116);
        fp->resetval = p[128];
@@ -627,26 +699,36 @@ static struct Atable *acpifadt(uint8_t * p, int len)
        else
                loadfacs(fp->facs);
 
-       if (fp->xdsdt == ((uint64_t) fp->dsdt)) /* acpica */
+       if (fp->xdsdt == (uint64_t)fp->dsdt)    /* acpica */
                loaddsdt(fp->xdsdt);
        else
                loaddsdt(fp->dsdt);
 
-       return NULL;    /* can be unmapped once parsed */
+       return finatable_nochildren(t);
 }
 
-static char *dumpmsct(char *start, char *end, struct Msct *msct)
+static char *dumpmsct(char *start, char *end, struct Atable *table)
 {
-       struct Mdom *st;
+       struct Msct *msct;
+
+       if (!table)
+               return start;
 
+       msct = table->tbl;
        if (!msct)
                return start;
+
        start = seprintf(start, end, "acpi: msct: %d doms %d clkdoms %#p maxpa\n",
                                         msct->ndoms, msct->nclkdoms, msct->maxpa);
-       for (st = msct->dom; st != NULL; st = st->next)
+       for (int i = 0; i < table->nchildren; i++) {
+               struct Atable *domtbl = table->children[i]->tbl;
+               struct Mdom *st = domtbl->tbl;
+
                start = seprintf(start, end, "\t[%d:%d] %d maxproc %#p maxmmem\n",
                                                 st->start, st->end, st->maxproc, st->maxmem);
+       }
        start = seprintf(start, end, "\n");
+
        return start;
 }
 
@@ -654,37 +736,77 @@ static char *dumpmsct(char *start, char *end, struct Msct *msct)
  * XXX: should perhaps update our idea of available memory.
  * Else we should remove this code.
  */
-static struct Atable *acpimsct(uint8_t * p, int len)
+static struct Atable *parsemsct(struct Atable *parent,
+                                char *name, uint8_t *raw, size_t rawsize)
 {
-       uint8_t *pe;
+       struct Atable *t;
+       uint8_t *r, *re;
+       struct Msct *msct;
        struct Mdom **stl, *st;
-       int off;
+       size_t off, nmdom;
+       int i;
 
-       msct = kzmalloc(sizeof(struct Msct), 0);
-       msct->ndoms = l32get(p + 40) + 1;
-       msct->nclkdoms = l32get(p + 44) + 1;
-       msct->maxpa = l64get(p + 48);
+       re = raw + rawsize;
+       off = l32get(raw + 36);
+       nmdom = 0;
+       for (r = raw + off, re = raw + rawsize; r < re; r += 22)
+               nmdom++;
+       t = mkatable(parent, MSCT, name, raw, rawsize,
+                    sizeof(struct Msct) + nmdom * sizeof(struct Mdom));
+       msct = t->tbl;
+       msct->ndoms = l32get(raw + 40) + 1;
+       msct->nclkdoms = l32get(raw + 44) + 1;
+       msct->maxpa = l64get(raw + 48);
+       msct->nmdom = nmdom;
        msct->dom = NULL;
-       stl = &msct->dom;
-       pe = p + len;
-       off = l32get(p + 36);
-       for (p += off; p < pe; p += 22) {
-               st = kzmalloc(sizeof(struct Mdom), 0);
-               st->next = NULL;
-               st->start = l32get(p + 2);
-               st->end = l32get(p + 6);
-               st->maxproc = l32get(p + 10);
-               st->maxmem = l64get(p + 14);
-               *stl = st;
-               stl = &st->next;
+       if (nmdom != 0)
+               msct->dom = (void *)msct + sizeof(struct Msct);
+       for (i = 0, r = raw; i < nmdom; i++, r += 22) {
+               msct->dom[i].start = l32get(r + 2);
+               msct->dom[i].end = l32get(r + 6);
+               msct->dom[i].maxproc = l32get(r + 10);
+               msct->dom[i].maxmem = l64get(r + 14);
+       }
+       mscttbl = finatable_nochildren(t);
+
+       return mscttbl;
+}
+
+/* TODO(rminnich): only handles on IOMMU for now. */
+static char *dumpdmar(char *start, char *end, struct Atable *dmar)
+{
+       struct Dmar *dt;
+
+       if (dmar == NULL)
+               return start;
+
+       dt = dmar->tbl;
+       start = seprintf(start, end, "acpi: DMAR addr %p:\n", dt);
+       start = seprintf(start, end, "\tdmar: intr_remap %d haw %d\n",
+                        dt->intr_remap, dt->haw);
+       for (int i = 0; i < dmar->nchildren; i++) {
+               struct Atable *at = dmar->children[i];
+               struct Drhd *drhd = at->tbl;
+
+               start = seprintf(start, end, "\tDRHD: ");
+               start = seprintf(start, end, "%s 0x%02x 0x%016x\n",
+                                drhd->all & 1 ? "INCLUDE_PCI_ALL" : "Scoped",
+                                drhd->segment, drhd->rba);
        }
-       return NULL;    /* can be unmapped once parsed */
+
+       return start;
 }
 
-static char *dumpsrat(char *start, char *end, struct Srat *st)
+static char *dumpsrat(char *start, char *end, struct Atable *table)
 {
-       start = seprintf(start, end, "acpi: srat:\n");
-       for (; st != NULL; st = st->next)
+       if (table == NULL)
+               return seprintf(start, end, "NO SRAT\n");
+       start = seprintf(start, end, "acpi: SRAT@%p:\n", table->tbl);
+       for (; table != NULL; table = table->next) {
+               struct Srat *st = table->tbl;
+
+               if (st == NULL)
+                       continue;
                switch (st->type) {
                        case SRlapic:
                                start =
@@ -708,29 +830,35 @@ static char *dumpsrat(char *start, char *end, struct Srat *st)
                        default:
                                start = seprintf(start, end, "\t<unknown srat entry>\n");
                }
+       }
        start = seprintf(start, end, "\n");
        return start;
 }
 
-static struct Atable *acpisrat(uint8_t * p, int len)
+static struct Atable *parsesrat(struct Atable *parent,
+                                char *name, uint8_t *p, size_t rawsize)
 {
 
-       struct Srat **stl, *st;
+       struct Atable *t, *tt, *tail;
        uint8_t *pe;
        int stlen, flags;
+       struct slice slice;
+       char buf[16];
+       int i;
+       struct Srat *st;
 
-       if (srat != NULL) {
-               printd("acpi: two SRATs?\n");
-               return NULL;
-       }
+       if (srat != NULL)
+               panic("acpi: two SRATs?\n");
 
-       stl = &srat;
-       pe = p + len;
-       for (p += 48; p < pe; p += stlen) {
-               st = kzmalloc(sizeof(struct Srat), 1);
-               st->type = p[0];
-               st->next = NULL;
+       t = mkatable(parent, SRAT, name, p, rawsize, 0);
+       slice_init(&slice);
+       pe = p + rawsize;
+       for (p += 48, i = 0; p < pe; p += stlen, i++) {
+               snprintf(buf, sizeof(buf), "%d", i);
                stlen = p[1];
+               tt = mkatable(t, SRAT, buf, p, stlen, sizeof(struct Srat));
+               st = tt->tbl;
+               st->type = p[0];
                switch (st->type) {
                        case SRlapic:
                                st->lapic.dom = p[2] | p[9] << 24 | p[10] << 16 | p[11] << 8;
@@ -738,8 +866,8 @@ static struct Atable *acpisrat(uint8_t * p, int len)
                                st->lapic.sapic = p[8];
                                st->lapic.clkdom = l32get(p + 12);
                                if (l32get(p + 4) == 0) {
-                                       kfree(st);
-                                       st = NULL;
+                                       kfree(tt);
+                                       tt = NULL;
                                }
                                break;
                        case SRmem:
@@ -748,8 +876,8 @@ static struct Atable *acpisrat(uint8_t * p, int len)
                                st->mem.len = l64get(p + 16);
                                flags = l32get(p + 28);
                                if ((flags & 1) == 0) { /* not enabled */
-                                       kfree(st);
-                                       st = NULL;
+                                       kfree(tt);
+                                       tt = NULL;
                                } else {
                                        st->mem.hplug = flags & 2;
                                        st->mem.nvram = flags & 4;
@@ -760,28 +888,31 @@ static struct Atable *acpisrat(uint8_t * p, int len)
                                st->lx2apic.apic = l32get(p + 8);
                                st->lx2apic.clkdom = l32get(p + 16);
                                if (l32get(p + 12) == 0) {
-                                       kfree(st);
-                                       st = NULL;
+                                       kfree(tt);
+                                       tt = NULL;
                                }
                                break;
                        default:
                                printd("unknown SRAT structure\n");
-                               kfree(st);
-                               st = NULL;
+                               kfree(tt);
+                               tt = NULL;
+                               break;
                }
-               if (st != NULL) {
-                       *stl = st;
-                       stl = &st->next;
+               if (tt != NULL) {
+                       finatable_nochildren(tt);
+                       slice_append(&slice, tt);
                }
        }
-       return NULL;    /* can be unmapped once parsed */
+       srat = finatable(t, &slice);
+
+       return srat;
 }
 
 static char *dumpslit(char *start, char *end, struct Slit *sl)
 {
        int i;
 
-       if (!sl)
+       if (sl == NULL)
                return start;
        start = seprintf(start, end, "acpi slit:\n");
        for (i = 0; i < sl->rowlen * sl->rowlen; i++) {
@@ -802,47 +933,47 @@ static int cmpslitent(void *v1, void *v2)
        return se1->dist - se2->dist;
 }
 
-static struct Atable *acpislit(uint8_t * p, int len)
+static struct Atable *parseslit(struct Atable *parent,
+                                char *name, uint8_t *raw, size_t rawsize)
 {
-
-       uint8_t *pe;
+       struct Atable *t;
+       uint8_t *r, *re;
        int i, j, k;
        struct SlEntry *se;
+       size_t addsize, rowlen;
+       void *p;
+
+       addsize = sizeof(*slit);
+       rowlen = l64get(raw + 36);
+       addsize += rowlen * sizeof(struct SlEntry *);
+       addsize += sizeof(struct SlEntry) * rowlen * rowlen;
+
+       t = mkatable(parent, SLIT, name, raw, rawsize, addsize);
+       slit = t->tbl;
+       slit->rowlen = rowlen;
+       p = (void *)slit + sizeof(*slit);
+       slit->e = p;
+       p += rowlen * sizeof(struct SlEntry *);
+       for (i = 0; i < rowlen; i++) {
+               slit->e[i] = p;
+               p += sizeof(struct SlEntry) * rowlen;
+       }
+       for (i = 0, r = raw + 44, re = raw + rawsize; r < re; r++, i++) {
+               int j = i / rowlen;
+               int k = i % rowlen;
 
-       pe = p + len;
-       slit = kzmalloc(sizeof(*slit), 0);
-       slit->rowlen = l64get(p + 36);
-       slit->e = kzmalloc(slit->rowlen * sizeof(struct SlEntry *), 0);
-       for (i = 0; i < slit->rowlen; i++)
-               slit->e[i] = kzmalloc(sizeof(struct SlEntry) * slit->rowlen, 0);
-
-       i = 0;
-       for (p += 44; p < pe; p++, i++) {
-               j = i / slit->rowlen;
-               k = i % slit->rowlen;
                se = &slit->e[j][k];
                se->dom = k;
-               se->dist = *p;
+               se->dist = *r;
        }
+
 #if 0
        /* TODO: might need to sort this shit */
        for (i = 0; i < slit->rowlen; i++)
                qsort(slit->e[i], slit->rowlen, sizeof(slit->e[0][0]), cmpslitent);
 #endif
-       return NULL;    /* can be unmapped once parsed */
-}
-
-uintptr_t acpimblocksize(uintptr_t addr, int *dom)
-{
-       struct Srat *sl;
 
-       for (sl = srat; sl != NULL; sl = sl->next)
-               if (sl->type == SRmem)
-                       if (sl->mem.addr <= addr && sl->mem.addr + sl->mem.len > addr) {
-                               *dom = sl->mem.dom;
-                               return sl->mem.len - (addr - sl->mem.addr);
-                       }
-       return 0;
+       return finatable_nochildren(t);
 }
 
 int pickcore(int mycolor, int index)
@@ -850,9 +981,8 @@ int pickcore(int mycolor, int index)
        int color;
        int ncorepercol;
 
-       if (slit == NULL) {
+       if (slit == NULL)
                return 0;
-       }
        ncorepercol = num_cores / slit->rowlen;
        color = slit->e[mycolor][index / ncorepercol].dom;
        return color * ncorepercol + index % ncorepercol;
@@ -879,14 +1009,21 @@ static char *printiflags(char *start, char *end, int flags)
                                        polarity[flags & AFpmask], trigger[(flags & AFtmask) >> 2]);
 }
 
-static char *dumpmadt(char *start, char *end, struct Madt *apics)
+static char *dumpmadt(char *start, char *end, struct Atable *apics)
 {
-       struct Apicst *st;
+       struct Madt *mt;
 
-       start =
-               seprintf(start, end, "acpi: madt lapic paddr %llux pcat %d:\n",
-                                apics->lapicpa, apics->pcat);
-       for (st = apics->st; st != NULL; st = st->next)
+       if (apics == NULL)
+               return start;
+
+       mt = apics->tbl;
+       if (mt == NULL)
+               return seprintf(start, end, "acpi: no MADT");
+       start = seprintf(start, end, "acpi: MADT@%p: lapic paddr %p pcat %d:\n",
+                        mt, mt->lapicpa, mt->pcat);
+       for (int i = 0; i < apics->nchildren; i++) {
+               struct Atable *apic = apics->children[i];
+               struct Apicst *st = apic->tbl;
 
                switch (st->type) {
                        case ASlapic:
@@ -898,7 +1035,7 @@ static char *dumpmadt(char *start, char *end, struct Madt *apics)
                        case ASiosapic:
                                start =
                                        seprintf(start, end,
-                                                        "\tioapic id %d addr %#llux ibase %d\n",
+                                                        "\tioapic id %d addr %p ibase %d\n",
                                                         st->ioapic.id, st->ioapic.addr, st->ioapic.ibase);
                                break;
                        case ASintovr:
@@ -948,35 +1085,43 @@ static char *dumpmadt(char *start, char *end, struct Madt *apics)
                        default:
                                start = seprintf(start, end, "\t<unknown madt entry>\n");
                }
+       }
        start = seprintf(start, end, "\n");
        return start;
 }
 
-static struct Atable *acpimadt(uint8_t * p, int len)
+static struct Atable *parsemadt(struct Atable *parent,
+                                char *name, uint8_t *p, size_t size)
 {
-
+       struct Atable *t, *tt, *tail;
        uint8_t *pe;
-       struct Apicst *st, *l, **stl;
-       int stlen, id;
-
-       apics = kzmalloc(sizeof(struct Madt), 1);
-       apics->lapicpa = l32get(p + 36);
-       apics->pcat = l32get(p + 40);
-       apics->st = NULL;
-       stl = &apics->st;
-       pe = p + len;
-       for (p += 44; p < pe; p += stlen) {
-               st = kzmalloc(sizeof(struct Apicst), 1);
-               st->type = p[0];
-               st->next = NULL;
+       struct Madt *mt;
+       struct Apicst *st, *l;
+       int id;
+       size_t stlen;
+       char buf[16];
+       int i;
+       struct slice slice;
+
+       slice_init(&slice);
+       t = mkatable(parent, MADT, name, p, size, sizeof(struct Madt));
+       mt = t->tbl;
+       mt->lapicpa = l32get(p + 36);
+       mt->pcat = l32get(p + 40);
+       pe = p + size;
+       for (p += 44, i = 0; p < pe; p += stlen, i++) {
+               snprintf(buf, sizeof(buf), "%d", i);
                stlen = p[1];
+               tt = mkatable(t, APIC, buf, p, stlen, sizeof(struct Apicst));
+               st = tt->tbl;
+               st->type = p[0];
                switch (st->type) {
                        case ASlapic:
                                st->lapic.pid = p[2];
                                st->lapic.id = p[3];
                                if (l32get(p + 4) == 0) {
-                                       kfree(st);
-                                       st = NULL;
+                                       kfree(tt);
+                                       tt = NULL;
                                }
                                break;
                        case ASioapic:
@@ -984,12 +1129,14 @@ static struct Atable *acpimadt(uint8_t * p, int len)
                                st->ioapic.addr = l32get(p + 4);
                                st->ioapic.ibase = l32get(p + 8);
                                /* ioapic overrides any ioapic entry for the same id */
-                               for (l = apics->st; l != NULL; l = l->next)
+                               for (int i = 0; i < slice_len(&slice); i++) {
+                                       l = ((struct Atable *)slice_get(&slice, i))->tbl;
                                        if (l->type == ASiosapic && l->iosapic.id == id) {
                                                st->ioapic = l->iosapic;
                                                /* we leave it linked; could be removed */
                                                break;
                                        }
+                               }
                                break;
                        case ASintovr:
                                st->intovr.irq = p[3];
@@ -1009,20 +1156,22 @@ static struct Atable *acpimadt(uint8_t * p, int len)
                                /* This is for 64 bits, perhaps we should not
                                 * honor it on 32 bits.
                                 */
-                               apics->lapicpa = l64get(p + 8);
+                               mt->lapicpa = l64get(p + 8);
                                break;
                        case ASiosapic:
                                id = st->iosapic.id = p[2];
                                st->iosapic.ibase = l32get(p + 4);
                                st->iosapic.addr = l64get(p + 8);
                                /* iosapic overrides any ioapic entry for the same id */
-                               for (l = apics->st; l != NULL; l = l->next)
+                               for (int i = 0; i < slice_len(&slice); i++) {
+                                       l = ((struct Atable*)slice_get(&slice, i))->tbl;
                                        if (l->type == ASioapic && l->ioapic.id == id) {
                                                l->ioapic = st->iosapic;
-                                               kfree(st);
-                                               st = NULL;
+                                               kfree(tt);
+                                               tt = NULL;
                                                break;
                                        }
+                               }
                                break;
                        case ASlsapic:
                                st->lsapic.pid = p[2];
@@ -1030,8 +1179,8 @@ static struct Atable *acpimadt(uint8_t * p, int len)
                                st->lsapic.eid = p[4];
                                st->lsapic.puid = l32get(p + 12);
                                if (l32get(p + 8) == 0) {
-                                       kfree(st);
-                                       st = NULL;
+                                       kfree(tt);
+                                       tt = NULL;
                                } else
                                        kstrdup(&st->lsapic.puids, (char *)p + 16);
                                break;
@@ -1048,8 +1197,8 @@ static struct Atable *acpimadt(uint8_t * p, int len)
                                st->lx2apic.id = l32get(p + 4);
                                st->lx2apic.puid = l32get(p + 12);
                                if (l32get(p + 8) == 0) {
-                                       kfree(st);
-                                       st = NULL;
+                                       kfree(tt);
+                                       tt = NULL;
                                }
                                break;
                        case ASlx2nmi:
@@ -1059,29 +1208,130 @@ static struct Atable *acpimadt(uint8_t * p, int len)
                                break;
                        default:
                                printd("unknown APIC structure\n");
-                               kfree(st);
-                               st = NULL;
+                               kfree(tt);
+                               tt = NULL;
                }
-               if (st != NULL) {
-                       *stl = st;
-                       stl = &st->next;
+               if (tt != NULL) {
+                       finatable_nochildren(tt);
+                       slice_append(&slice, tt);
                }
        }
-       return NULL;    /* can be unmapped once parsed */
+       apics = finatable(t, &slice);
+
+       return apics;
+}
+
+static struct Atable *parsedmar(struct Atable *parent,
+                                char *name, uint8_t *raw, size_t rawsize)
+{
+       struct Atable *t, *tt;
+       int i;
+       int baselen = MIN(rawsize, 38);
+       int nentry, nscope, npath, off, dslen, dhlen, len, type, flags;
+       void *pathp;
+       char buf[16];
+       struct slice drhds;
+       struct Drhd *drhd;
+       struct Dmar *dt;
+
+       /* count the entries */
+       for (nentry = 0, off = 48; off < rawsize; nentry++) {
+               dslen = l16get(raw + off + 2);
+               printk("acpi DMAR: entry %d is addr %p (0x%x/0x%x)\n",
+                      nentry, raw + off, l16get(raw + off), dslen);
+               off = off + dslen;
+       }
+       printk("DMAR: %d entries\n", nentry);
+
+       t = mkatable(parent, DMAR, name, raw, rawsize, sizeof(*dmar));
+       dt = t->tbl;
+       /* The table can be only partly filled. */
+       if (baselen >= 38 && raw[37] & 1)
+               dt->intr_remap = 1;
+       if (baselen >= 37)
+               dt->haw = raw[36] + 1;
+
+       /* Now we walk all the DMAR entries. */
+       slice_init(&drhds);
+       for (off = 48, i = 0; i < nentry; i++, off += dslen) {
+               snprintf(buf, sizeof(buf), "%d", i);
+               dslen = l16get(raw + off + 2);
+               type = l16get(raw + off);
+               // TODO(dcross): Introduce sensible symbolic constants
+               // for DMAR entry types. For right now, type 0 => DRHD.
+               // We skip everything else.
+               if (type != 0)
+                       continue;
+               npath = 0;
+               nscope = 0;
+               for (int o = off + 16; o < (off + dslen); o += dhlen) {
+                       nscope++;
+                       dhlen = *(raw + o + 1); // Single byte length.
+                       npath += ((dhlen - 6) / 2);
+               }
+               tt = mkatable(t, DRHD, buf, raw + off, dslen,
+                             sizeof(struct Drhd) + 2 * npath +
+                             nscope * sizeof(struct DevScope));
+               flags = *(raw + off + 4);
+               drhd = tt->tbl;
+               drhd->all = flags & 1;
+               drhd->segment = l16get(raw + off + 6);
+               drhd->rba = l64get(raw + off + 8);
+               drhd->nscope = nscope;
+               drhd->scopes = (void *)drhd + sizeof(struct Drhd);
+               pathp = (void *)drhd +
+                   sizeof(struct Drhd) + nscope * sizeof(struct DevScope);
+               for (int i = 0, o = off + 16; i < nscope; i++) {
+                       struct DevScope *ds = &drhd->scopes[i];
+
+                       dhlen = *(raw + o + 1);
+                       ds->enumeration_id = *(raw + o + 4);
+                       ds->start_bus_number = *(raw + o + 5);
+                       ds->npath = (dhlen - 6) / 2;
+                       ds->paths = pathp;
+                       for (int j = 0; j < ds->npath; j++)
+                               ds->paths[j] = l16get(raw + o + 6 + 2*j);
+                       pathp += 2*ds->npath;
+                       o += dhlen;
+               }
+               /*
+                * NOTE: if all is set, there should be no scopes of type
+                * This being ACPI, where vendors randomly copy tables
+                * from one system to another, and creating breakage,
+                * anything is possible. But we'll warn them.
+                */
+               finatable_nochildren(tt);
+               slice_append(&drhds, tt);
+       }
+       dmar = finatable(t, &drhds);
+
+       return dmar;
 }
 
 /*
  * Map the table and keep it there.
  */
-static struct Atable *acpitable(uint8_t * p, int len)
+static struct Atable *parsessdt(struct Atable *parent,
+                                char *name, uint8_t *raw, size_t size)
 {
-       if (len < Sdthdrsz) {
+       struct Atable *t;
+       struct Sdthdr *h;
+
+       /*
+        * We found it and it is too small.
+        * Simply return with no side effect.
+        */
+       if (size < Sdthdrsz)
                return NULL;
-       }
-       return new_acpi_table(p);
+       t = mkatable(parent, SSDT, name, raw, size, 0);
+       h = (struct Sdthdr *)raw;
+       memmove(t->name, h->sig, sizeof(h->sig));
+       t->name[sizeof(h->sig)] = '\0';
+
+       return finatable_nochildren(t);
 }
 
-static char *dumptable(char *start, char *end, char *sig, uint8_t * p, int l)
+static char *dumptable(char *start, char *end, char *sig, uint8_t *p, int l)
 {
        int n, i;
 
@@ -1109,9 +1359,9 @@ static char *seprinttable(char *s, char *e, struct Atable *t)
        uint8_t *p;
        int i, n;
 
-       p = (uint8_t *) t->tbl; /* include header */
-       n = Sdthdrsz + t->dlen;
-       s = seprintf(s, e, "%s @ %#p\n", t->sig, p);
+       p = (uint8_t *)t->tbl;  /* include header */
+       n = t->rawsize;
+       s = seprintf(s, e, "%s @ %#p\n", t->name, p);
        for (i = 0; i < n; i++) {
                if ((i % 16) == 0)
                        s = seprintf(s, e, "%x: ", i);
@@ -1122,81 +1372,151 @@ static char *seprinttable(char *s, char *e, struct Atable *t)
        return seprintf(s, e, "\n\n");
 }
 
+static void *rsdsearch(char *signature)
+{
+       uintptr_t p;
+       uint8_t *bda;
+       void *rsd;
+
+       /*
+        * Search for the data structure signature:
+        * 1) in the BIOS ROM between 0xE0000 and 0xFFFFF.
+        */
+       return sigscan(KADDR(0xE0000), 0x20000, signature);
+}
+
+/*
+ * Note: some of this comment is from the unfinished user interpreter.
+ *
+ * The DSDT is always given to the user interpreter.
+ * Tables listed here are also loaded from the XSDT:
+ * MSCT, MADT, and FADT are processed by us, because they are
+ * required to do early initialization before we have user processes.
+ * Other tables are given to the user level interpreter for
+ * execution.
+ *
+ * These historically returned a value to tell acpi whether or not it was okay
+ * to unmap the table.  (return 0 means there was no table, meaning it was okay
+ * to unmap).  We just use the kernbase mapping, so it's irrelevant.
+ *
+ * N.B. The intel source code defines the constants for ACPI in a
+ * non-endian-independent manner. Rather than bring in the huge wad o' code
+ * that represents, we just the names.
+ */
+struct Parser {
+       char *sig;
+       struct Atable *(*parse)(struct Atable *parent,
+                               char *name, uint8_t *raw, size_t rawsize);
+};
+
+
+static struct Parser ptable[] = {
+       {"FACP", parsefadt},
+       {"APIC", parsemadt},
+       {"DMAR", parsedmar},
+       {"SRAT", parsesrat},
+       {"SLIT", parseslit},
+       {"MSCT", parsemsct},
+       {"SSDT", parsessdt},
+       {"HPET", parsehpet},
+};
+
 /*
  * process xsdt table and load tables with sig, or all if NULL.
  * (XXX: should be able to search for sig, oemid, oemtblid)
  */
-static int acpixsdtload(char *sig)
+static void parsexsdt(struct Atable *root)
 {
-       int i, l, t, found;
+       ERRSTACK(1);
+       struct Sdthdr *sdt;
+       struct Atable *table;
+       struct slice slice;
+       size_t l, end;
        uintptr_t dhpa;
-       uint8_t *sdt;
-       char tsig[5];
-       char table[128];
-
-       found = 0;
-       for (i = 0; i < xsdt->len; i += xsdt->asize) {
-               if (xsdt->asize == 8)
-                       dhpa = l64get(xsdt->p + i);
-               else
-                       dhpa = l32get(xsdt->p + i);
-               if ((sdt = sdtmap(dhpa, &l, 1)) == NULL)
+       struct Atable *n;
+       uint8_t *tbl;
+
+       slice_init(&slice);
+       if (waserror()) {
+               slice_destroy(&slice);
+               return;
+       }
+
+       tbl = xsdt->p + sizeof(struct Sdthdr);
+       end = xsdt->len - sizeof(struct Sdthdr);
+       for (int i = 0; i < end; i += xsdt->asize) {
+               dhpa = (xsdt->asize == 8) ? l64get(tbl + i) : l32get(tbl + i);
+               sdt = sdtmap(dhpa, &l, 1);
+               if (sdt == NULL)
                        continue;
-               memmove(tsig, sdt, 4);
-               tsig[4] = 0;
-               if (sig == NULL || strcmp(sig, tsig) == 0) {
-                       printd("acpi: %s addr %#p\n", tsig, sdt);
-                       for (t = 0; t < ARRAY_SIZE(ptables); t++)
-                               if (strcmp(tsig, ptables[t].sig) == 0) {
-                                       //dumptable(table, &table[127], tsig, sdt, l);
-                                       ptables[t].f(sdt, l);
-                                       found = 1;
-                                       break;
-                               }
+               printd("acpi: %s addr %#p\n", tsig, sdt);
+               for (int j = 0; j < ARRAY_SIZE(ptable); j++) {
+                       if (memcmp(sdt->sig, ptable[j].sig, sizeof(sdt->sig)) == 0) {
+                               table = ptable[j].parse(root, ptable[j].sig, (void *)sdt, l);
+                               if (table != NULL)
+                                       slice_append(&slice, table);
+                               break;
+                       }
                }
        }
-       return found;
+       finatable(root, &slice);
 }
 
-static void *rsdsearch(char *signature)
+void makeindex(struct Atable *root)
 {
-       uintptr_t p;
-       uint8_t *bda;
-       void *rsd;
+       uint64_t index;
 
-       /*
-        * Search for the data structure signature:
-        * 1) in the BIOS ROM between 0xE0000 and 0xFFFFF.
-        */
-       return sigscan(KADDR(0xE0000), 0x20000, signature);
+       if (root == NULL)
+               return;
+       index = root->qid.path >> QIndexShift;
+       atableindex[index] = root;
+       for (int k = 0; k < root->nchildren; k++)
+               makeindex(root->children[k]);
 }
 
-static void acpirsdptr(void)
+static void parsersdptr(void)
 {
        struct Rsdp *rsd;
-       int asize;
+       int asize, cksum;
        uintptr_t sdtpa;
 
-       if ((rsd = rsdsearch("RSD PTR ")) == NULL) {
+       static_assert(sizeof(struct Sdthdr) == 36);
+
+       /* Find the root pointer. */
+       rsd = rsdsearch("RSD PTR ");
+       if (rsd == NULL) {
+               printk("NO RSDP\n");
                return;
        }
 
-       assert(sizeof(struct Sdthdr) == 36);
+       /*
+        * Initialize the root of ACPI parse tree.
+        */
+       lastpath = Qroot;
+       root = mkatable(NULL, XSDT, devname(), NULL, 0, sizeof(struct Xsdt));
+       root->parent = root;
+
+       printd("/* RSDP */ struct Rsdp = {%08c, %x, %06c, %x, %p, %d, %p, %x}\n",
+                  rsd->signature, rsd->rchecksum, rsd->oemid, rsd->revision,
+                  *(uint32_t *)rsd->raddr, *(uint32_t *)rsd->length,
+                  *(uint32_t *)rsd->xaddr, rsd->xchecksum);
 
        printd("acpi: RSD PTR@ %#p, physaddr $%p length %ud %#llux rev %d\n",
                   rsd, l32get(rsd->raddr), l32get(rsd->length),
                   l64get(rsd->xaddr), rsd->revision);
 
        if (rsd->revision >= 2) {
-               if (sdtchecksum(rsd, 36) == NULL) {
-                       printk("acpi: RSD: bad checksum\n");
+               cksum = sdtchecksum(rsd, 36);
+               if (cksum != 0) {
+                       printk("acpi: bad RSD checksum %d, 64 bit parser aborted\n", cksum);
                        return;
                }
                sdtpa = l64get(rsd->xaddr);
                asize = 8;
        } else {
-               if (sdtchecksum(rsd, 20) == NULL) {
-                       printk("acpi: RSD: bad checksum\n");
+               cksum = sdtchecksum(rsd, 20);
+               if (cksum != 0) {
+                       printk("acpi: bad RSD checksum %d, 32 bit parser aborted\n", cksum);
                        return;
                }
                sdtpa = l32get(rsd->raddr);
@@ -1206,61 +1526,70 @@ static void acpirsdptr(void)
        /*
         * process the RSDT or XSDT table.
         */
-       xsdt = kzmalloc(sizeof(struct Xsdt), 0);
-       if (xsdt == NULL) {
-               printk("acpi: malloc failed\n");
-               return;
-       }
-       if ((xsdt->p = sdtmap(sdtpa, &xsdt->len, 1)) == NULL) {
+       xsdt = root->tbl;
+       xsdt->p = sdtmap(sdtpa, &xsdt->len, 1);
+       if (xsdt->p == NULL) {
                printk("acpi: sdtmap failed\n");
                return;
        }
        if ((xsdt->p[0] != 'R' && xsdt->p[0] != 'X')
                || memcmp(xsdt->p + 1, "SDT", 3) != 0) {
-               printd("acpi: xsdt sig: %c%c%c%c\n", xsdt->p[0], xsdt->p[1], xsdt->p[2],
-                          xsdt->p[3]);
-               kfree(xsdt);
+               printd("acpi: xsdt sig: %c%c%c%c\n",
+                      xsdt->p[0], xsdt->p[1], xsdt->p[2], xsdt->p[3]);
                xsdt = NULL;
                return;
        }
-       xsdt->p += sizeof(struct Sdthdr);
-       xsdt->len -= sizeof(struct Sdthdr);
        xsdt->asize = asize;
        printd("acpi: XSDT %#p\n", xsdt);
-       acpixsdtload(NULL);
-       /* xsdt is kept and not unmapped */
+       parsexsdt(root);
+       atableindex = kreallocarray(NULL, lastpath, sizeof(struct Atable *),
+                                   MEM_WAIT);
+       assert(atableindex != NULL);
+       makeindex(root);
+}
 
+/*
+ * The invariant that each level in the tree has an associated
+ * Atable implies that each chan can be mapped to an Atable.
+ * The assertions here enforce that invariant.
+ */
+static struct Atable *genatable(struct chan *c)
+{
+       struct Atable *a;
+       uint64_t ai;
+
+       ai = c->qid.path >> QIndexShift;
+       assert(ai < lastpath);
+       a = atableindex[ai];
+       assert(a != NULL);
+
+       return a;
 }
 
-static int
-acpigen(struct chan *c, char *unused_char_p_t, struct dirtab *tab, int ntab,
-               int i, struct dir *dp)
+static int acpigen(struct chan *c, char *name, struct dirtab *tab, int ntab,
+                                  int i, struct dir *dp)
 {
-       struct qid qid;
+       struct Atable *a = genatable(c);
 
        if (i == DEVDOTDOT) {
-               mkqid(&qid, Qdir, 0, QTDIR);
-               devdir(c, qid, devname(), 0, eve, 0555, dp);
+               assert((c->qid.path & QIndexMask) == Qdir);
+               devdir(c, a->parent->qid, a->parent->name, 0, eve, DMDIR|0555, dp);
                return 1;
        }
-       i++;    /* skip first element for . itself */
-       if (tab == 0 || i >= ntab) {
-               return -1;
-       }
-       tab += i;
-       qid = tab->qid;
-       qid.path &= ~Qdir;
-       qid.vers = 0;
-       devdir(c, qid, tab->name, tab->length, eve, tab->perm, dp);
-       return 1;
+       return devgen(c, name, a->cdirs, a->nchildren + NQtypes, i, dp);
+}
+
+/*
+ * Print the contents of the XSDT.
+ */
+static void dumpxsdt(void)
+{
+       printk("xsdt: len = %lu, asize = %lu, p = %p\n",
+              xsdt->len, xsdt->asize, xsdt->p);
 }
 
 static char *dumpGas(char *start, char *end, char *prefix, struct Gas *g)
 {
-       static char *rnames[] = {
-               "mem", "io", "pcicfg", "embed",
-               "smb", "cmos", "pcibar", "ipmi"
-       };
        start = seprintf(start, end, "%s", prefix);
 
        switch (g->spc) {
@@ -1271,18 +1600,18 @@ static char *dumpGas(char *start, char *end, char *prefix, struct Gas *g)
                case Rcmos:
                case Rpcibar:
                case Ripmi:
-                       start = seprintf(start, end, "[%s ", rnames[g->spc]);
+                       start = seprintf(start, end, "[%s ", regnames[g->spc]);
                        break;
                case Rpcicfg:
                        start = seprintf(start, end, "[pci ");
                        start =
                                seprintf(start, end, "dev %#p ",
-                                                (uint32_t) (g->addr >> 32) & 0xFFFF);
+                                                (uint32_t)(g->addr >> 32) & 0xFFFF);
                        start =
                                seprintf(start, end, "fn %#p ",
-                                                (uint32_t) (g->addr & 0xFFFF0000) >> 16);
+                                                (uint32_t)(g->addr & 0xFFFF0000) >> 16);
                        start =
-                               seprintf(start, end, "adr %#p ", (uint32_t) (g->addr & 0xFFFF));
+                               seprintf(start, end, "adr %#p ", (uint32_t)(g->addr & 0xFFFF));
                        break;
                case Rfixedhw:
                        start = seprintf(start, end, "[hw ");
@@ -1358,25 +1687,29 @@ static unsigned int setbanked(uintptr_t ra, uintptr_t rb, int sz, int v)
 
 static unsigned int getpm1ctl(void)
 {
-       return getbanked(fadt.pm1acntblk, fadt.pm1bcntblk, fadt.pm1cntlen);
+       assert(fadt != NULL);
+       return getbanked(fadt->pm1acntblk, fadt->pm1bcntblk, fadt->pm1cntlen);
 }
 
 static void setpm1sts(unsigned int v)
 {
-       setbanked(fadt.pm1aevtblk, fadt.pm1bevtblk, fadt.pm1evtlen / 2, v);
+       assert(fadt != NULL);
+       setbanked(fadt->pm1aevtblk, fadt->pm1bevtblk, fadt->pm1evtlen / 2, v);
 }
 
 static unsigned int getpm1sts(void)
 {
-       return getbanked(fadt.pm1aevtblk, fadt.pm1bevtblk, fadt.pm1evtlen / 2);
+       assert(fadt != NULL);
+       return getbanked(fadt->pm1aevtblk, fadt->pm1bevtblk, fadt->pm1evtlen / 2);
 }
 
 static unsigned int getpm1en(void)
 {
        int sz;
 
-       sz = fadt.pm1evtlen / 2;
-       return getbanked(fadt.pm1aevtblk + sz, fadt.pm1bevtblk + sz, sz);
+       assert(fadt != NULL);
+       sz = fadt->pm1evtlen / 2;
+       return getbanked(fadt->pm1aevtblk + sz, fadt->pm1bevtblk + sz, sz);
 }
 
 static int getgpeen(int n)
@@ -1436,27 +1769,29 @@ static void acpiintr(Ureg *, void *)
        setpm1sts(sts);
 }
 #endif
+
 static void initgpes(void)
 {
        int i, n0, n1;
 
-       n0 = fadt.gpe0blklen / 2;
-       n1 = fadt.gpe1blklen / 2;
+       assert(fadt != NULL);
+       n0 = fadt->gpe0blklen / 2;
+       n1 = fadt->gpe1blklen / 2;
        ngpes = n0 + n1;
        gpes = kzmalloc(sizeof(struct Gpe) * ngpes, 1);
        for (i = 0; i < n0; i++) {
                gpes[i].nb = i;
                gpes[i].stsbit = i & 7;
-               gpes[i].stsio = fadt.gpe0blk + (i >> 3);
+               gpes[i].stsio = fadt->gpe0blk + (i >> 3);
                gpes[i].enbit = (n0 + i) & 7;
-               gpes[i].enio = fadt.gpe0blk + ((n0 + i) >> 3);
+               gpes[i].enio = fadt->gpe0blk + ((n0 + i) >> 3);
        }
        for (i = 0; i + n0 < ngpes; i++) {
-               gpes[i + n0].nb = fadt.gp1base + i;
+               gpes[i + n0].nb = fadt->gp1base + i;
                gpes[i + n0].stsbit = i & 7;
-               gpes[i + n0].stsio = fadt.gpe1blk + (i >> 3);
+               gpes[i + n0].stsio = fadt->gpe1blk + (i >> 3);
                gpes[i + n0].enbit = (n1 + i) & 7;
-               gpes[i + n0].enio = fadt.gpe1blk + ((n1 + i) >> 3);
+               gpes[i + n0].enio = fadt->gpe1blk + ((n1 + i) >> 3);
        }
        for (i = 0; i < ngpes; i++) {
                setgpeen(i, 0);
@@ -1466,83 +1801,96 @@ static void initgpes(void)
 
 static void acpiioalloc(unsigned int addr, int len)
 {
-       if (addr != 0) {
-               printk("Just TAKING port %016lx to %016lx\n", addr, addr + len);
-               //ioalloc(addr, len, 0, "acpi");
-       }
+       if (addr != 0)
+               printd("Just TAKING port %016lx to %016lx\n", addr, addr + len);
+}
+
+static void acpiinitonce(void)
+{
+       parsersdptr();
+       if (root != NULL)
+               printk("ACPI initialized\n");
 }
 
 int acpiinit(void)
 {
-       /* this smicmd test implements 'run once' for now. */
-       if (fadt.smicmd == 0) {
-               //fmtinstall('G', Gfmt);
-               acpirsdptr();
-               if (fadt.smicmd == 0) {
-                       return -1;
-               }
-       }
-       printk("ACPI initialized\n");
-       return 0;
+       run_once(acpiinitonce());
+       return (root == NULL) ? -1 : 0;
 }
 
 static struct chan *acpiattach(char *spec)
 {
        int i;
-
+       struct chan *c;
        /*
         * This was written for the stock kernel.
         * This code must use 64 registers to be acpi ready in nix.
         */
-       if (acpiinit() < 0) {
-               error("no acpi");
-       }
+       if (acpiinit() < 0)
+               error(ENOSYS, "no acpi");
 
        /*
         * should use fadt->xpm* and fadt->xgpe* registers for 64 bits.
         * We are not ready in this kernel for that.
         */
-       acpiioalloc(fadt.smicmd, 1);
-       acpiioalloc(fadt.pm1aevtblk, fadt.pm1evtlen);
-       acpiioalloc(fadt.pm1bevtblk, fadt.pm1evtlen);
-       acpiioalloc(fadt.pm1acntblk, fadt.pm1cntlen);
-       acpiioalloc(fadt.pm1bcntblk, fadt.pm1cntlen);
-       acpiioalloc(fadt.pm2cntblk, fadt.pm2cntlen);
-       acpiioalloc(fadt.pmtmrblk, fadt.pmtmrlen);
-       acpiioalloc(fadt.gpe0blk, fadt.gpe0blklen);
-       acpiioalloc(fadt.gpe1blk, fadt.gpe1blklen);
+       assert(fadt != NULL);
+       acpiioalloc(fadt->smicmd, 1);
+       acpiioalloc(fadt->pm1aevtblk, fadt->pm1evtlen);
+       acpiioalloc(fadt->pm1bevtblk, fadt->pm1evtlen);
+       acpiioalloc(fadt->pm1acntblk, fadt->pm1cntlen);
+       acpiioalloc(fadt->pm1bcntblk, fadt->pm1cntlen);
+       acpiioalloc(fadt->pm2cntblk, fadt->pm2cntlen);
+       acpiioalloc(fadt->pmtmrblk, fadt->pmtmrlen);
+       acpiioalloc(fadt->gpe0blk, fadt->gpe0blklen);
+       acpiioalloc(fadt->gpe1blk, fadt->gpe1blklen);
 
        initgpes();
-
-       /*
+#ifdef RON_SAYS_CONFIG_WE_ARE_NOT_WORTHY
+       /* this is frightening. SMI: just say no. Although we will almost
+        * certainly find that we have no choice.
+        *
         * This starts ACPI, which may require we handle
         * power mgmt events ourselves. Use with care.
         */
-       outb(fadt.smicmd, fadt.acpienable);
+       outb(fadt->smicmd, fadt->acpienable);
        for (i = 0; i < 10; i++)
                if (getpm1ctl() & Pm1SciEn)
                        break;
        if (i == 10)
-               error("acpi: failed to enable\n");
-//  if(fadt.sciint != 0)
-//      intrenable(fadt.sciint, acpiintr, 0, BUSUNKNOWN, "acpi");
-       return devattach(devname(), spec);
+               error(EFAIL, "acpi: failed to enable\n");
+       if (fadt->sciint != 0)
+               intrenable(fadt->sciint, acpiintr, 0, BUSUNKNOWN, "acpi");
+#endif
+       c = devattach(devname(), spec);
+
+       return c;
 }
 
 static struct walkqid *acpiwalk(struct chan *c, struct chan *nc, char **name,
                                                                int nname)
 {
-       return devwalk(c, nc, name, nname, acpidir, ARRAY_SIZE(acpidir), acpigen);
+       /*
+        * Note that devwalk hard-codes a test against the location of 'devgen',
+        * so we pretty much have to not pass it here.
+        */
+       return devwalk(c, nc, name, nname, NULL, 0, acpigen);
 }
 
-static int acpistat(struct chan *c, uint8_t * dp, int n)
+static int acpistat(struct chan *c, uint8_t *dp, int n)
 {
-       return devstat(c, dp, n, acpidir, ARRAY_SIZE(acpidir), acpigen);
+       struct Atable *a = genatable(c);
+
+       if (c->qid.type == QTDIR)
+               a = a->parent;
+       assert(a != NULL);
+
+       /* TODO(dcross): make acpigen work here. */
+       return devstat(c, dp, n, a->cdirs, a->nchildren + NQtypes, devgen);
 }
 
 static struct chan *acpiopen(struct chan *c, int omode)
 {
-       return devopen(c, omode, acpidir, ARRAY_SIZE(acpidir), acpigen);
+       return devopen(c, omode, NULL, 0, acpigen);
 }
 
 static void acpiclose(struct chan *unused)
@@ -1552,6 +1900,8 @@ static void acpiclose(struct chan *unused)
 static char *ttext;
 static int tlen;
 
+// Get the table from the qid.
+// Read that one table using the pointers.
 static long acpiread(struct chan *c, void *a, long n, int64_t off)
 {
        long q;
@@ -1562,58 +1912,55 @@ static long acpiread(struct chan *c, void *a, long n, int64_t off)
                tlen = 32768;
                ttext = kzmalloc(tlen, 0);
        }
-       if (ttext == NULL) {
-               error("acpiread: no memory");
-       }
-       q = c->qid.path;
+       if (ttext == NULL)
+               error(ENOMEM, "acpiread: no memory");
+       q = c->qid.path & QIndexMask;
        switch (q) {
-               case Qdir:
-                       return devdirread(c, a, n, acpidir, ARRAY_SIZE(acpidir), acpigen);
-               case Qtbl:
-                       s = ttext;
-                       e = ttext + tlen;
-                       strncpy(s, "no tables\n", sizeof(s));
-                       for (t = tfirst; t != NULL; t = t->next) {
+       case Qdir:
+               return devdirread(c, a, n, NULL, 0, acpigen);
+       case Qraw:
+               return readmem(off, a, n, ttext, tlen);
+       case Qtbl:
+               s = ttext;
+               e = ttext + tlen;
+               strlcpy(s, "no tables\n", tlen);
+               for (t = tfirst; t != NULL; t = t->next) {
+                       ns = seprinttable(s, e, t);
+                       while (ns == e - 1) {
+                               ntext = krealloc(ttext, tlen * 2, 0);
+                               if (ntext == NULL)
+                                       panic("acpi: no memory\n");
+                               s = ntext + (ttext - s);
+                               ttext = ntext;
+                               tlen *= 2;
+                               e = ttext + tlen;
                                ns = seprinttable(s, e, t);
-                               while (ns == e - 1) {
-                                       ntext = krealloc(ttext, tlen * 2, 0);
-                                       if (ntext == NULL)
-                                               panic("acpi: no memory\n");
-                                       s = ntext + (ttext - s);
-                                       ttext = ntext;
-                                       tlen *= 2;
-                                       e = ttext + tlen;
-                                       ns = seprinttable(s, e, t);
-                               }
-                               s = ns;
                        }
-                       return readstr(off, a, n, ttext);
-               case Qpretty:
-                       s = ttext;
-                       e = ttext + tlen;
-                       s = dumpfadt(s, e, &fadt);
-                       s = dumpmadt(s, e, apics);
-                       s = dumpslit(s, e, slit);
-                       s = dumpsrat(s, e, srat);
-                       dumpmsct(s, e, msct);
-                       return readstr(off, a, n, ttext);
-               case Qioapic:
-                       s = ioapicdump(ttext, ttext + tlen);
-                       return readstr(off, a, n, ttext);
-               case Qapic:
-                       s = apicdump(ttext, ttext + tlen);
-                       return readstr(off, a, n, ttext);
-               case Qio:
-                       if (reg == NULL)
-                               error("region not configured");
-                       return regio(reg, a, n, off, 0);
+                       s = ns;
+               }
+               return readstr(off, a, n, ttext);
+       case Qpretty:
+               s = ttext;
+               e = ttext + tlen;
+               s = dumpfadt(s, e, fadt);
+               s = dumpmadt(s, e, apics);
+               s = dumpslit(s, e, slit);
+               s = dumpsrat(s, e, srat);
+               s = dumpdmar(s, e, dmar);
+               dumpmsct(s, e, mscttbl);
+               return readstr(off, a, n, ttext);
+       default:
+               error(EINVAL, "acpiread: bad path %d\n", q);
        }
-       error(Eperm);
+       error(EPERM, ERROR_FIXME);
+
        return -1;
 }
 
 static long acpiwrite(struct chan *c, void *a, long n, int64_t off)
 {
+       error(EFAIL, "acpiwrite: not until we can figure out what it's for");
+#if 0
        ERRSTACK(2);
        struct cmdtab *ct;
        struct cmdbuf *cb;
@@ -1622,11 +1969,11 @@ static long acpiwrite(struct chan *c, void *a, long n, int64_t off)
 
        if (c->qid.path == Qio) {
                if (reg == NULL)
-                       error("region not configured");
+                       error(EFAIL, "region not configured");
                return regio(reg, a, n, off, 1);
        }
        if (c->qid.path != Qctl)
-               error(Eperm);
+               error(EPERM, ERROR_FIXME);
 
        cb = parsecmd(a, n);
        if (waserror()) {
@@ -1647,18 +1994,18 @@ static long acpiwrite(struct chan *c, void *a, long n, int64_t off)
                        if (r->spc < 0) {
                                kfree(r);
                                reg = NULL;
-                               error("bad region type");
+                               error(EFAIL, "bad region type");
                        }
                        if (r->spc == Rpcicfg || r->spc == Rpcibar) {
                                rno = r->base >> Rpciregshift & Rpciregmask;
                                fun = r->base >> Rpcifunshift & Rpcifunmask;
                                dev = r->base >> Rpcidevshift & Rpcidevmask;
                                bus = r->base >> Rpcibusshift & Rpcibusmask;
-                               #ifdef CONFIG_X86
+#ifdef CONFIG_X86
                                r->tbdf = MKBUS(BusPCI, bus, dev, fun);
-                               #else
+#else
                                r->tbdf = 0
-                               #endif
+#endif
                                r->base = rno;  /* register ~ our base addr */
                        }
                        r->base = strtoul(cb->f[3], NULL, 0);
@@ -1667,7 +2014,7 @@ static long acpiwrite(struct chan *c, void *a, long n, int64_t off)
                        if (r->accsz < 1 || r->accsz > 4) {
                                kfree(r);
                                reg = NULL;
-                               error("bad region access size");
+                               error(EFAIL, "bad region access size");
                        }
                        reg = r;
                        printd("region %s %s %p %p sz%d",
@@ -1676,7 +2023,7 @@ static long acpiwrite(struct chan *c, void *a, long n, int64_t off)
                case CMgpe:
                        i = strtoul(cb->f[1], NULL, 0);
                        if (i >= ngpes)
-                               error("gpe out of range");
+                               error(ERANGE, "gpe out of range");
                        kstrdup(&gpes[i].obj, cb->f[2]);
                        setgpeen(i, 1);
                        break;
@@ -1686,24 +2033,51 @@ static long acpiwrite(struct chan *c, void *a, long n, int64_t off)
        poperror();
        kfree(cb);
        return n;
+#endif
+}
+
+struct {
+       char *(*pretty)(struct Atable *atbl, char *start, char *end, void *arg);
+} acpisw[NACPITBLS] = {
+};
+
+static char *pretty(struct Atable *atbl, char *start, char *end, void *arg)
+{
+       int type;
+
+       type = atbl->type;
+       if (type < 0 || NACPITBLS < type)
+               return start;
+       if (acpisw[type].pretty == NULL)
+               return seprintf(start, end, "\"\"\n");
+       return acpisw[type].pretty(atbl, start, end, arg);
+}
+
+static char *raw(struct Atable *atbl, char *start, char *end, void *unused_arg)
+{
+       size_t len = MIN(end - start, atbl->rawsize);
+
+       memmove(start, atbl->raw, len);
+
+       return start + len;
 }
 
 struct dev acpidevtab __devtab = {
-       "acpi",
-
-       devreset,
-       devinit,
-       devshutdown,
-       acpiattach,
-       acpiwalk,
-       acpistat,
-       acpiopen,
-       devcreate,
-       acpiclose,
-       acpiread,
-       devbread,
-       acpiwrite,
-       devbwrite,
-       devremove,
-       devwstat,
+       .name = "acpi",
+
+       .reset = devreset,
+       .init = devinit,
+       .shutdown = devshutdown,
+       .attach = acpiattach,
+       .walk = acpiwalk,
+       .stat = acpistat,
+       .open = acpiopen,
+       .create = devcreate,
+       .close = acpiclose,
+       .read = acpiread,
+       .bread = devbread,
+       .write = acpiwrite,
+       .bwrite = devbwrite,
+       .remove = devremove,
+       .wstat = devwstat,
 };