Use readstr() for #device text buffers
[akaros.git] / kern / drivers / dev / acpi.c
1 /*
2  * This file is part of the UCB release of Plan 9. It is subject to the license
3  * terms in the LICENSE file found in the top-level directory of this
4  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
5  * part of the UCB release of Plan 9, including this file, may be copied,
6  * modified, propagated, or distributed except according to the terms contained
7  * in the LICENSE file.
8  */
9
10 #include <slab.h>
11 #include <kmalloc.h>
12 #include <kref.h>
13 #include <string.h>
14 #include <stdio.h>
15 #include <assert.h>
16 #include <error.h>
17 #include <cpio.h>
18 #include <pmap.h>
19 #include <smp.h>
20 #include <net/ip.h>
21 #include <ns.h>
22 #include <acpi.h>
23 #include <slice.h>
24
25 #include "../timers/hpet.h"
26
27 #ifdef CONFIG_X86
28 #include <arch/pci.h>
29 #endif
30
31 /* -----------------------------------------------------------------------------
32  * Basic ACPI device.
33  *
34  * The qid.Path will be made unique by incrementing lastpath. lastpath starts
35  * at Qroot.
36  *
37  * Qtbl will return a pointer to the Atable, which includes the signature, OEM
38  * data, and so on.
39  *
40  * Raw, at any level, dumps the raw table at that level, which by the ACPI
41  * flattened tree layout will include all descendents.
42  *
43  * Qpretty, at any level, will print the pretty form for that level and all
44  * descendants.
45  */
46 enum {
47         Qroot = 0,
48
49         // The type is the qid.path mod NQtypes.
50         Qdir = 0,
51         Qpretty,
52         Qraw,
53         Qtbl,
54         NQtypes,
55
56         QIndexShift = 8,
57         QIndexMask = (1 << QIndexShift) - 1,
58 };
59
60 #define ATABLEBUFSZ     ROUNDUP(sizeof(struct Atable), KMALLOC_ALIGNMENT)
61
62 static uint64_t lastpath;
63 static struct slice emptyslice;
64 static struct Atable **atableindex;
65 struct dev acpidevtab;
66
67 static char *devname(void)
68 {
69         return acpidevtab.name;
70 }
71
72 /*
73  * ACPI 4.0 Support.
74  * Still WIP.
75  *
76  * This driver locates tables and parses only a small subset
77  * of tables. All other tables are mapped and kept for the user-level
78  * interpreter.
79  */
80 static struct cmdtab ctls[] = {
81         {CMregion, "region", 6},
82         {CMgpe, "gpe", 3},
83 };
84
85 static struct Facs *facs;               /* Firmware ACPI control structure */
86 static struct Fadt *fadt;               /* Fixed ACPI description to reach ACPI regs */
87 static struct Atable *root;
88 static struct Xsdt *xsdt;               /* XSDT table */
89 static struct Atable *tfirst;   /* loaded DSDT/SSDT/... tables */
90 static struct Atable *tlast;    /* pointer to last table */
91 struct Atable *apics;                   /* APIC info */
92 struct Atable *srat;                    /* System resource affinity used by physalloc */
93 struct Atable *dmar;
94 static struct Slit *slit;               /* Sys locality info table used by scheduler */
95 static struct Atable *mscttbl;          /* Maximum system characteristics table */
96 static struct Reg *reg;                 /* region used for I/O */
97 static struct Gpe *gpes;                /* General purpose events */
98 static int ngpes;
99
100 static char *regnames[] = {
101         "mem", "io", "pcicfg", "embed",
102         "smb", "cmos", "pcibar", "ipmi",
103 };
104
105 /*
106  * Lists to store RAM that we copy ACPI tables into. When we map a new
107  * ACPI list into the kernel, we copy it into a specifically RAM buffer
108  * (to make sure it's not coming from e.g. slow device memory). We store
109  * pointers to those buffers on these lists.
110  */
111 struct Acpilist {
112         struct Acpilist *next;
113         size_t size;
114         int8_t raw[];
115 };
116
117 static struct Acpilist *acpilists;
118
119 /*
120  * Produces an Atable at some level in the tree. Note that Atables are
121  * isomorphic to directories in the file system namespace; this code
122  * ensures that invariant.
123  */
124 struct Atable *mkatable(struct Atable *parent,
125                         int type, char *name, uint8_t *raw,
126                         size_t rawsize, size_t addsize)
127 {
128         void *m;
129         struct Atable *t;
130
131         m = kzmalloc(ATABLEBUFSZ + addsize, MEM_WAIT);
132         if (m == NULL)
133                 panic("no memory for more aml tables");
134         t = m;
135         t->parent = parent;
136         t->tbl = NULL;
137         if (addsize != 0)
138                 t->tbl = m + ATABLEBUFSZ;
139         t->rawsize = rawsize;
140         t->raw = raw;
141         strlcpy(t->name, name, sizeof(t->name));
142         mkqid(&t->qid,  (lastpath << QIndexShift) + Qdir, 0, QTDIR);
143         mkqid(&t->rqid, (lastpath << QIndexShift) + Qraw, 0, 0);
144         mkqid(&t->pqid, (lastpath << QIndexShift) + Qpretty, 0, 0);
145         mkqid(&t->tqid, (lastpath << QIndexShift) + Qtbl, 0, 0);
146         lastpath++;
147
148         return t;
149 }
150
151 struct Atable *finatable(struct Atable *t, struct slice *slice)
152 {
153         size_t n;
154         struct Atable *tail;
155         struct dirtab *dirs;
156
157         n = slice_len(slice);
158         t->nchildren = n;
159         t->children = (struct Atable **)slice_finalize(slice);
160         dirs = kreallocarray(NULL, n + NQtypes, sizeof(struct dirtab),
161                              MEM_WAIT);
162         assert(dirs != NULL);
163         dirs[0] = (struct dirtab){ ".",      t->qid,   0, 0555 };
164         dirs[1] = (struct dirtab){ "pretty", t->pqid,  0, 0444 };
165         dirs[2] = (struct dirtab){ "raw",    t->rqid,  0, 0444 };
166         dirs[3] = (struct dirtab){ "table",  t->tqid,  0, 0444 };
167         for (size_t i = 0; i < n; i++) {
168                 strlcpy(dirs[i + NQtypes].name, t->children[i]->name, KNAMELEN);
169                 dirs[i + NQtypes].qid = t->children[i]->qid;
170                 dirs[i + NQtypes].length = 0;
171                 dirs[i + NQtypes].perm = DMDIR | 0555;
172         }
173         t->cdirs = dirs;
174         tail = NULL;
175         while (n-- > 0) {
176                 t->children[n]->next = tail;
177                 tail = t->children[n];
178         }
179
180         return t;
181 }
182
183 struct Atable *finatable_nochildren(struct Atable *t)
184 {
185         return finatable(t, &emptyslice);
186 }
187
188 static char *dumpGas(char *start, char *end, char *prefix, struct Gas *g);
189 static void dumpxsdt(void);
190
191 static char *acpiregstr(int id)
192 {
193         static char buf[20];            /* BUG */
194
195         if (id >= 0 && id < ARRAY_SIZE(regnames))
196                 return regnames[id];
197         seprintf(buf, buf + sizeof(buf), "spc:%#x", id);
198         return buf;
199 }
200
201 static int acpiregid(char *s)
202 {
203         for (int i = 0; i < ARRAY_SIZE(regnames); i++)
204                 if (strcmp(regnames[i], s) == 0)
205                         return i;
206         return -1;
207 }
208
209 /*
210  * TODO(rminnich): Fix these if we're ever on a different-endian machine.
211  * They are specific to little-endian processors and are not portable.
212  */
213 static uint8_t mget8(uintptr_t p, void *unused)
214 {
215         uint8_t *cp = (uint8_t *) p;
216         return *cp;
217 }
218
219 static void mset8(uintptr_t p, uint8_t v, void *unused)
220 {
221         uint8_t *cp = (uint8_t *) p;
222         *cp = v;
223 }
224
225 static uint16_t mget16(uintptr_t p, void *unused)
226 {
227         uint16_t *cp = (uint16_t *) p;
228         return *cp;
229 }
230
231 static void mset16(uintptr_t p, uint16_t v, void *unused)
232 {
233         uint16_t *cp = (uint16_t *) p;
234         *cp = v;
235 }
236
237 static uint32_t mget32(uintptr_t p, void *unused)
238 {
239         uint32_t *cp = (uint32_t *) p;
240         return *cp;
241 }
242
243 static void mset32(uintptr_t p, uint32_t v, void *unused)
244 {
245         uint32_t *cp = (uint32_t *) p;
246         *cp = v;
247 }
248
249 static uint64_t mget64(uintptr_t p, void *unused)
250 {
251         uint64_t *cp = (uint64_t *) p;
252         return *cp;
253 }
254
255 static void mset64(uintptr_t p, uint64_t v, void *unused)
256 {
257         uint64_t *cp = (uint64_t *) p;
258         *cp = v;
259 }
260
261 static uint8_t ioget8(uintptr_t p, void *unused)
262 {
263         return inb(p);
264 }
265
266 static void ioset8(uintptr_t p, uint8_t v, void *unused)
267 {
268         outb(p, v);
269 }
270
271 static uint16_t ioget16(uintptr_t p, void *unused)
272 {
273         return inw(p);
274 }
275
276 static void ioset16(uintptr_t p, uint16_t v, void *unused)
277 {
278         outw(p, v);
279 }
280
281 static uint32_t ioget32(uintptr_t p, void *unused)
282 {
283         return inl(p);
284 }
285
286 static void ioset32(uintptr_t p, uint32_t v, void *unused)
287 {
288         outl(p, v);
289 }
290
291 /*
292  * TODO(rminnich): these cfgs are hacky. Maybe all the struct Reg should have
293  * struct pci_device or something?
294  */
295 static uint8_t cfgget8(uintptr_t p, void *r)
296 {
297         struct Reg *ro = r;
298         struct pci_device pcidev;
299
300         explode_tbdf(ro->tbdf);
301         return pcidev_read8(&pcidev, p);
302 }
303
304 static void cfgset8(uintptr_t p, uint8_t v, void *r)
305 {
306         struct Reg *ro = r;
307         struct pci_device pcidev;
308
309         explode_tbdf(ro->tbdf);
310         pcidev_write8(&pcidev, p, v);
311 }
312
313 static uint16_t cfgget16(uintptr_t p, void *r)
314 {
315         struct Reg *ro = r;
316         struct pci_device pcidev;
317
318         explode_tbdf(ro->tbdf);
319         return pcidev_read16(&pcidev, p);
320 }
321
322 static void cfgset16(uintptr_t p, uint16_t v, void *r)
323 {
324         struct Reg *ro = r;
325         struct pci_device pcidev;
326
327         explode_tbdf(ro->tbdf);
328         pcidev_write16(&pcidev, p, v);
329 }
330
331 static uint32_t cfgget32(uintptr_t p, void *r)
332 {
333         struct Reg *ro = r;
334         struct pci_device pcidev;
335
336         explode_tbdf(ro->tbdf);
337         return pcidev_read32(&pcidev, p);
338 }
339
340 static void cfgset32(uintptr_t p, uint32_t v, void *r)
341 {
342         struct Reg *ro = r;
343         struct pci_device pcidev;
344
345         explode_tbdf(ro->tbdf);
346         pcidev_write32(&pcidev, p, v);
347 }
348
349 static struct Regio memio = {
350         NULL,
351         mget8, mset8, mget16, mset16,
352         mget32, mset32, mget64, mset64
353 };
354
355 static struct Regio ioio = {
356         NULL,
357         ioget8, ioset8, ioget16, ioset16,
358         ioget32, ioset32, NULL, NULL
359 };
360
361 static struct Regio cfgio = {
362         NULL,
363         cfgget8, cfgset8, cfgget16, cfgset16,
364         cfgget32, cfgset32, NULL, NULL
365 };
366
367 /*
368  * Copy memory, 1/2/4/8-bytes at a time, to/from a region.
369  */
370 static long
371 regcpy(struct Regio *dio, uintptr_t da, struct Regio *sio,
372            uintptr_t sa, long len, int align)
373 {
374         int n, i;
375
376         printd("regcpy %#p %#p %#p %#p\n", da, sa, len, align);
377         if ((len % align) != 0)
378                 printd("regcpy: bug: copy not aligned. truncated\n");
379         n = len / align;
380         for (i = 0; i < n; i++) {
381                 switch (align) {
382                         case 1:
383                                 printd("cpy8 %#p %#p\n", da, sa);
384                                 dio->set8(da, sio->get8(sa, sio->arg), dio->arg);
385                                 break;
386                         case 2:
387                                 printd("cpy16 %#p %#p\n", da, sa);
388                                 dio->set16(da, sio->get16(sa, sio->arg), dio->arg);
389                                 break;
390                         case 4:
391                                 printd("cpy32 %#p %#p\n", da, sa);
392                                 dio->set32(da, sio->get32(sa, sio->arg), dio->arg);
393                                 break;
394                         case 8:
395                                 printd("cpy64 %#p %#p\n", da, sa);
396                                 warn("Not doing set64 for some reason, fix me!");
397                                 //  dio->set64(da, sio->get64(sa, sio->arg), dio->arg);
398                                 break;
399                         default:
400                                 panic("regcpy: align bug");
401                 }
402                 da += align;
403                 sa += align;
404         }
405         return n * align;
406 }
407
408 /*
409  * Perform I/O within region in access units of accsz bytes.
410  * All units in bytes.
411  */
412 static long regio(struct Reg *r, void *p, uint32_t len, uintptr_t off, int iswr)
413 {
414         struct Regio rio;
415         uintptr_t rp;
416
417         printd("reg%s %s %#p %#p %#lx sz=%d\n",
418                    iswr ? "out" : "in", r->name, p, off, len, r->accsz);
419         rp = 0;
420         if (off + len > r->len) {
421                 printd("regio: access outside limits");
422                 len = r->len - off;
423         }
424         if (len <= 0) {
425                 printd("regio: zero len\n");
426                 return 0;
427         }
428         switch (r->spc) {
429                 case Rsysmem:
430                         if (r->p == NULL)
431                                 r->p = KADDR_NOCHECK(r->base);
432                         if (r->p == NULL)
433                                 error(EFAIL, "regio: vmap/KADDR failed");
434                         rp = (uintptr_t) r->p + off;
435                         rio = memio;
436                         break;
437                 case Rsysio:
438                         rp = r->base + off;
439                         rio = ioio;
440                         break;
441                 case Rpcicfg:
442                         rp = r->base + off;
443                         rio = cfgio;
444                         rio.arg = r;
445                         break;
446                 case Rpcibar:
447                 case Rembed:
448                 case Rsmbus:
449                 case Rcmos:
450                 case Ripmi:
451                 case Rfixedhw:
452                         printd("regio: reg %s not supported\n", acpiregstr(r->spc));
453                         error(EFAIL, "region not supported");
454         }
455         if (iswr)
456                 regcpy(&rio, rp, &memio, (uintptr_t) p, len, r->accsz);
457         else
458                 regcpy(&memio, (uintptr_t) p, &rio, rp, len, r->accsz);
459         return len;
460 }
461
462 /*
463  * Compute and return SDT checksum: '0' is a correct sum.
464  */
465 static uint8_t sdtchecksum(void *addr, int len)
466 {
467         uint8_t *p, sum;
468
469         sum = 0;
470         for (p = addr; len-- > 0; p++)
471                 sum += *p;
472
473         return sum;
474 }
475
476 static void *sdtmap(uintptr_t pa, size_t *n, int cksum)
477 {
478         struct Sdthdr *sdt;
479         struct Acpilist *p;
480
481         if (!pa) {
482                 printk("sdtmap: NULL pa\n");
483                 return NULL;
484         }
485         sdt = KADDR_NOCHECK(pa);
486         if (sdt == NULL) {
487                 printk("acpi: vmap: NULL\n");
488                 return NULL;
489         }
490         *n = l32get(sdt->length);
491         if (!*n) {
492                 printk("sdt has zero length: pa = %p, sig = %.4s\n", pa, sdt->sig);
493                 return NULL;
494         }
495         if (cksum != 0 && sdtchecksum(sdt, *n) != 0) {
496                 printk("acpi: SDT: bad checksum. pa = %p, len = %lu\n", pa, *n);
497                 return NULL;
498         }
499         p = kzmalloc(sizeof(struct Acpilist) + *n, MEM_WAIT);
500         if (p == NULL)
501                 panic("sdtmap: memory allocation failed for %lu bytes", *n);
502         memmove(p->raw, (void *)sdt, *n);
503         p->size = *n;
504         p->next = acpilists;
505         acpilists = p;
506
507         return p->raw;
508 }
509
510 static int loadfacs(uintptr_t pa)
511 {
512         size_t n;
513
514         facs = sdtmap(pa, &n, 0);
515         if (facs == NULL)
516                 return -1;
517         if (memcmp(facs->sig, "FACS", 4) != 0) {
518                 facs = NULL;
519                 return -1;
520         }
521
522         /* no unmap */
523         printd("acpi: facs: hwsig: %#p\n", facs->hwsig);
524         printd("acpi: facs: wakingv: %#p\n", facs->wakingv);
525         printd("acpi: facs: flags: %#p\n", facs->flags);
526         printd("acpi: facs: glock: %#p\n", facs->glock);
527         printd("acpi: facs: xwakingv: %#p\n", facs->xwakingv);
528         printd("acpi: facs: vers: %#p\n", facs->vers);
529         printd("acpi: facs: ospmflags: %#p\n", facs->ospmflags);
530
531         return 0;
532 }
533
534 static void loaddsdt(uintptr_t pa)
535 {
536         size_t n;
537         uint8_t *dsdtp;
538
539         dsdtp = sdtmap(pa, &n, 1);
540         if (dsdtp == NULL) {
541                 printk("acpi: Failed to map dsdtp.\n");
542                 return;
543         }
544 }
545
546 static void gasget(struct Gas *gas, uint8_t *p)
547 {
548         gas->spc = p[0];
549         gas->len = p[1];
550         gas->off = p[2];
551         gas->accsz = p[3];
552         gas->addr = l64get(p + 4);
553 }
554
555 static char *dumpfadt(char *start, char *end, struct Fadt *fp)
556 {
557         if (fp == NULL)
558                 return start;
559
560         start = seprintf(start, end, "acpi: FADT@%p\n", fp);
561         start = seprintf(start, end, "acpi: fadt: facs: $%p\n", fp->facs);
562         start = seprintf(start, end, "acpi: fadt: dsdt: $%p\n", fp->dsdt);
563         start = seprintf(start, end, "acpi: fadt: pmprofile: $%p\n", fp->pmprofile);
564         start = seprintf(start, end, "acpi: fadt: sciint: $%p\n", fp->sciint);
565         start = seprintf(start, end, "acpi: fadt: smicmd: $%p\n", fp->smicmd);
566         start =
567                 seprintf(start, end, "acpi: fadt: acpienable: $%p\n", fp->acpienable);
568         start =
569                 seprintf(start, end, "acpi: fadt: acpidisable: $%p\n", fp->acpidisable);
570         start = seprintf(start, end, "acpi: fadt: s4biosreq: $%p\n", fp->s4biosreq);
571         start = seprintf(start, end, "acpi: fadt: pstatecnt: $%p\n", fp->pstatecnt);
572         start =
573                 seprintf(start, end, "acpi: fadt: pm1aevtblk: $%p\n", fp->pm1aevtblk);
574         start =
575                 seprintf(start, end, "acpi: fadt: pm1bevtblk: $%p\n", fp->pm1bevtblk);
576         start =
577                 seprintf(start, end, "acpi: fadt: pm1acntblk: $%p\n", fp->pm1acntblk);
578         start =
579                 seprintf(start, end, "acpi: fadt: pm1bcntblk: $%p\n", fp->pm1bcntblk);
580         start = seprintf(start, end, "acpi: fadt: pm2cntblk: $%p\n", fp->pm2cntblk);
581         start = seprintf(start, end, "acpi: fadt: pmtmrblk: $%p\n", fp->pmtmrblk);
582         start = seprintf(start, end, "acpi: fadt: gpe0blk: $%p\n", fp->gpe0blk);
583         start = seprintf(start, end, "acpi: fadt: gpe1blk: $%p\n", fp->gpe1blk);
584         start = seprintf(start, end, "acpi: fadt: pm1evtlen: $%p\n", fp->pm1evtlen);
585         start = seprintf(start, end, "acpi: fadt: pm1cntlen: $%p\n", fp->pm1cntlen);
586         start = seprintf(start, end, "acpi: fadt: pm2cntlen: $%p\n", fp->pm2cntlen);
587         start = seprintf(start, end, "acpi: fadt: pmtmrlen: $%p\n", fp->pmtmrlen);
588         start =
589                 seprintf(start, end, "acpi: fadt: gpe0blklen: $%p\n", fp->gpe0blklen);
590         start =
591                 seprintf(start, end, "acpi: fadt: gpe1blklen: $%p\n", fp->gpe1blklen);
592         start = seprintf(start, end, "acpi: fadt: gp1base: $%p\n", fp->gp1base);
593         start = seprintf(start, end, "acpi: fadt: cstcnt: $%p\n", fp->cstcnt);
594         start = seprintf(start, end, "acpi: fadt: plvl2lat: $%p\n", fp->plvl2lat);
595         start = seprintf(start, end, "acpi: fadt: plvl3lat: $%p\n", fp->plvl3lat);
596         start = seprintf(start, end, "acpi: fadt: flushsz: $%p\n", fp->flushsz);
597         start =
598                 seprintf(start, end, "acpi: fadt: flushstride: $%p\n", fp->flushstride);
599         start = seprintf(start, end, "acpi: fadt: dutyoff: $%p\n", fp->dutyoff);
600         start = seprintf(start, end, "acpi: fadt: dutywidth: $%p\n", fp->dutywidth);
601         start = seprintf(start, end, "acpi: fadt: dayalrm: $%p\n", fp->dayalrm);
602         start = seprintf(start, end, "acpi: fadt: monalrm: $%p\n", fp->monalrm);
603         start = seprintf(start, end, "acpi: fadt: century: $%p\n", fp->century);
604         start =
605                 seprintf(start, end, "acpi: fadt: iapcbootarch: $%p\n",
606                                  fp->iapcbootarch);
607         start = seprintf(start, end, "acpi: fadt: flags: $%p\n", fp->flags);
608         start = dumpGas(start, end, "acpi: fadt: resetreg: ", &fp->resetreg);
609         start = seprintf(start, end, "acpi: fadt: resetval: $%p\n", fp->resetval);
610         start = seprintf(start, end, "acpi: fadt: xfacs: %p\n", fp->xfacs);
611         start = seprintf(start, end, "acpi: fadt: xdsdt: %p\n", fp->xdsdt);
612         start = dumpGas(start, end, "acpi: fadt: xpm1aevtblk:", &fp->xpm1aevtblk);
613         start = dumpGas(start, end, "acpi: fadt: xpm1bevtblk:", &fp->xpm1bevtblk);
614         start = dumpGas(start, end, "acpi: fadt: xpm1acntblk:", &fp->xpm1acntblk);
615         start = dumpGas(start, end, "acpi: fadt: xpm1bcntblk:", &fp->xpm1bcntblk);
616         start = dumpGas(start, end, "acpi: fadt: xpm2cntblk:", &fp->xpm2cntblk);
617         start = dumpGas(start, end, "acpi: fadt: xpmtmrblk:", &fp->xpmtmrblk);
618         start = dumpGas(start, end, "acpi: fadt: xgpe0blk:", &fp->xgpe0blk);
619         start = dumpGas(start, end, "acpi: fadt: xgpe1blk:", &fp->xgpe1blk);
620         return start;
621 }
622
623 static struct Atable *parsefadt(struct Atable *parent,
624                                                                 char *name, uint8_t *p, size_t rawsize)
625 {
626         struct Atable *t;
627         struct Fadt *fp;
628
629         t = mkatable(parent, FADT, name, p, rawsize, sizeof(struct Fadt));
630
631         if (rawsize < 116) {
632                 printk("ACPI: unusually short FADT, aborting!\n");
633                 return t;
634         }
635         /* for now, keep the globals. We'll get rid of them later. */
636         fp = t->tbl;
637         fadt = fp;
638         fp->facs = l32get(p + 36);
639         fp->dsdt = l32get(p + 40);
640         fp->pmprofile = p[45];
641         fp->sciint = l16get(p + 46);
642         fp->smicmd = l32get(p + 48);
643         fp->acpienable = p[52];
644         fp->acpidisable = p[53];
645         fp->s4biosreq = p[54];
646         fp->pstatecnt = p[55];
647         fp->pm1aevtblk = l32get(p + 56);
648         fp->pm1bevtblk = l32get(p + 60);
649         fp->pm1acntblk = l32get(p + 64);
650         fp->pm1bcntblk = l32get(p + 68);
651         fp->pm2cntblk = l32get(p + 72);
652         fp->pmtmrblk = l32get(p + 76);
653         fp->gpe0blk = l32get(p + 80);
654         fp->gpe1blk = l32get(p + 84);
655         fp->pm1evtlen = p[88];
656         fp->pm1cntlen = p[89];
657         fp->pm2cntlen = p[90];
658         fp->pmtmrlen = p[91];
659         fp->gpe0blklen = p[92];
660         fp->gpe1blklen = p[93];
661         fp->gp1base = p[94];
662         fp->cstcnt = p[95];
663         fp->plvl2lat = l16get(p + 96);
664         fp->plvl3lat = l16get(p + 98);
665         fp->flushsz = l16get(p + 100);
666         fp->flushstride = l16get(p + 102);
667         fp->dutyoff = p[104];
668         fp->dutywidth = p[105];
669         fp->dayalrm = p[106];
670         fp->monalrm = p[107];
671         fp->century = p[108];
672         fp->iapcbootarch = l16get(p + 109);
673         fp->flags = l32get(p + 112);
674
675         /*
676          * qemu gives us a 116 byte fadt, though i haven't seen any HW do that.
677          * The right way to do this is to realloc the table and fake it out.
678          */
679         if (rawsize < 244)
680                 return finatable_nochildren(t);
681
682         gasget(&fp->resetreg, p + 116);
683         fp->resetval = p[128];
684         fp->xfacs = l64get(p + 132);
685         fp->xdsdt = l64get(p + 140);
686         gasget(&fp->xpm1aevtblk, p + 148);
687         gasget(&fp->xpm1bevtblk, p + 160);
688         gasget(&fp->xpm1acntblk, p + 172);
689         gasget(&fp->xpm1bcntblk, p + 184);
690         gasget(&fp->xpm2cntblk, p + 196);
691         gasget(&fp->xpmtmrblk, p + 208);
692         gasget(&fp->xgpe0blk, p + 220);
693         gasget(&fp->xgpe1blk, p + 232);
694
695         if (fp->xfacs != 0)
696                 loadfacs(fp->xfacs);
697         else
698                 loadfacs(fp->facs);
699
700         if (fp->xdsdt == (uint64_t)fp->dsdt)    /* acpica */
701                 loaddsdt(fp->xdsdt);
702         else
703                 loaddsdt(fp->dsdt);
704
705         return finatable_nochildren(t);
706 }
707
708 static char *dumpmsct(char *start, char *end, struct Atable *table)
709 {
710         struct Msct *msct;
711
712         if (!table)
713                 return start;
714
715         msct = table->tbl;
716         if (!msct)
717                 return start;
718
719         start = seprintf(start, end, "acpi: msct: %d doms %d clkdoms %#p maxpa\n",
720                                          msct->ndoms, msct->nclkdoms, msct->maxpa);
721         for (int i = 0; i < table->nchildren; i++) {
722                 struct Atable *domtbl = table->children[i]->tbl;
723                 struct Mdom *st = domtbl->tbl;
724
725                 start = seprintf(start, end, "\t[%d:%d] %d maxproc %#p maxmmem\n",
726                                                  st->start, st->end, st->maxproc, st->maxmem);
727         }
728         start = seprintf(start, end, "\n");
729
730         return start;
731 }
732
733 /*
734  * XXX: should perhaps update our idea of available memory.
735  * Else we should remove this code.
736  */
737 static struct Atable *parsemsct(struct Atable *parent,
738                                 char *name, uint8_t *raw, size_t rawsize)
739 {
740         struct Atable *t;
741         uint8_t *r, *re;
742         struct Msct *msct;
743         struct Mdom **stl, *st;
744         size_t off, nmdom;
745         int i;
746
747         re = raw + rawsize;
748         off = l32get(raw + 36);
749         nmdom = 0;
750         for (r = raw + off, re = raw + rawsize; r < re; r += 22)
751                 nmdom++;
752         t = mkatable(parent, MSCT, name, raw, rawsize,
753                      sizeof(struct Msct) + nmdom * sizeof(struct Mdom));
754         msct = t->tbl;
755         msct->ndoms = l32get(raw + 40) + 1;
756         msct->nclkdoms = l32get(raw + 44) + 1;
757         msct->maxpa = l64get(raw + 48);
758         msct->nmdom = nmdom;
759         msct->dom = NULL;
760         if (nmdom != 0)
761                 msct->dom = (void *)msct + sizeof(struct Msct);
762         for (i = 0, r = raw; i < nmdom; i++, r += 22) {
763                 msct->dom[i].start = l32get(r + 2);
764                 msct->dom[i].end = l32get(r + 6);
765                 msct->dom[i].maxproc = l32get(r + 10);
766                 msct->dom[i].maxmem = l64get(r + 14);
767         }
768         mscttbl = finatable_nochildren(t);
769
770         return mscttbl;
771 }
772
773 /* TODO(rminnich): only handles on IOMMU for now. */
774 static char *dumpdmar(char *start, char *end, struct Atable *dmar)
775 {
776         struct Dmar *dt;
777
778         if (dmar == NULL)
779                 return start;
780
781         dt = dmar->tbl;
782         start = seprintf(start, end, "acpi: DMAR addr %p:\n", dt);
783         start = seprintf(start, end, "\tdmar: intr_remap %d haw %d\n",
784                          dt->intr_remap, dt->haw);
785         for (int i = 0; i < dmar->nchildren; i++) {
786                 struct Atable *at = dmar->children[i];
787                 struct Drhd *drhd = at->tbl;
788
789                 start = seprintf(start, end, "\tDRHD: ");
790                 start = seprintf(start, end, "%s 0x%02x 0x%016x\n",
791                                  drhd->all & 1 ? "INCLUDE_PCI_ALL" : "Scoped",
792                                  drhd->segment, drhd->rba);
793         }
794
795         return start;
796 }
797
798 static char *dumpsrat(char *start, char *end, struct Atable *table)
799 {
800         if (table == NULL)
801                 return seprintf(start, end, "NO SRAT\n");
802         start = seprintf(start, end, "acpi: SRAT@%p:\n", table->tbl);
803         for (; table != NULL; table = table->next) {
804                 struct Srat *st = table->tbl;
805
806                 if (st == NULL)
807                         continue;
808                 switch (st->type) {
809                         case SRlapic:
810                                 start =
811                                         seprintf(start, end,
812                                                          "\tlapic: dom %d apic %d sapic %d clk %d\n",
813                                                          st->lapic.dom, st->lapic.apic, st->lapic.sapic,
814                                                          st->lapic.clkdom);
815                                 break;
816                         case SRmem:
817                                 start = seprintf(start, end, "\tmem: dom %d %#p %#p %c%c\n",
818                                                                  st->mem.dom, st->mem.addr, st->mem.len,
819                                                                  st->mem.hplug ? 'h' : '-',
820                                                                  st->mem.nvram ? 'n' : '-');
821                                 break;
822                         case SRlx2apic:
823                                 start =
824                                         seprintf(start, end, "\tlx2apic: dom %d apic %d clk %d\n",
825                                                          st->lx2apic.dom, st->lx2apic.apic,
826                                                          st->lx2apic.clkdom);
827                                 break;
828                         default:
829                                 start = seprintf(start, end, "\t<unknown srat entry>\n");
830                 }
831         }
832         start = seprintf(start, end, "\n");
833         return start;
834 }
835
836 static struct Atable *parsesrat(struct Atable *parent,
837                                 char *name, uint8_t *p, size_t rawsize)
838 {
839
840         struct Atable *t, *tt, *tail;
841         uint8_t *pe;
842         int stlen, flags;
843         struct slice slice;
844         char buf[16];
845         int i;
846         struct Srat *st;
847
848         /* TODO: Parse the second SRAT */
849         if (srat != NULL) {
850                 warn("Multiple SRATs detected and ignored!");
851                 return NULL;
852         }
853
854         t = mkatable(parent, SRAT, name, p, rawsize, 0);
855         slice_init(&slice);
856         pe = p + rawsize;
857         for (p += 48, i = 0; p < pe; p += stlen, i++) {
858                 snprintf(buf, sizeof(buf), "%d", i);
859                 stlen = p[1];
860                 tt = mkatable(t, SRAT, buf, p, stlen, sizeof(struct Srat));
861                 st = tt->tbl;
862                 st->type = p[0];
863                 switch (st->type) {
864                         case SRlapic:
865                                 st->lapic.dom = p[2] | p[9] << 24 | p[10] << 16 | p[11] << 8;
866                                 st->lapic.apic = p[3];
867                                 st->lapic.sapic = p[8];
868                                 st->lapic.clkdom = l32get(p + 12);
869                                 if (l32get(p + 4) == 0) {
870                                         kfree(tt);
871                                         tt = NULL;
872                                 }
873                                 break;
874                         case SRmem:
875                                 st->mem.dom = l32get(p + 2);
876                                 st->mem.addr = l64get(p + 8);
877                                 st->mem.len = l64get(p + 16);
878                                 flags = l32get(p + 28);
879                                 if ((flags & 1) == 0) { /* not enabled */
880                                         kfree(tt);
881                                         tt = NULL;
882                                 } else {
883                                         st->mem.hplug = flags & 2;
884                                         st->mem.nvram = flags & 4;
885                                 }
886                                 break;
887                         case SRlx2apic:
888                                 st->lx2apic.dom = l32get(p + 4);
889                                 st->lx2apic.apic = l32get(p + 8);
890                                 st->lx2apic.clkdom = l32get(p + 16);
891                                 if (l32get(p + 12) == 0) {
892                                         kfree(tt);
893                                         tt = NULL;
894                                 }
895                                 break;
896                         default:
897                                 printd("unknown SRAT structure\n");
898                                 kfree(tt);
899                                 tt = NULL;
900                                 break;
901                 }
902                 if (tt != NULL) {
903                         finatable_nochildren(tt);
904                         slice_append(&slice, tt);
905                 }
906         }
907         srat = finatable(t, &slice);
908
909         return srat;
910 }
911
912 static char *dumpslit(char *start, char *end, struct Slit *sl)
913 {
914         int i;
915
916         if (sl == NULL)
917                 return start;
918         start = seprintf(start, end, "acpi slit:\n");
919         for (i = 0; i < sl->rowlen * sl->rowlen; i++) {
920                 start = seprintf(start, end,
921                                                  "slit: %ux\n",
922                                                  sl->e[i / sl->rowlen][i % sl->rowlen].dist);
923         }
924         start = seprintf(start, end, "\n");
925         return start;
926 }
927
928 static int cmpslitent(void *v1, void *v2)
929 {
930         struct SlEntry *se1, *se2;
931
932         se1 = v1;
933         se2 = v2;
934         return se1->dist - se2->dist;
935 }
936
937 static struct Atable *parseslit(struct Atable *parent,
938                                 char *name, uint8_t *raw, size_t rawsize)
939 {
940         struct Atable *t;
941         uint8_t *r, *re;
942         int i, j, k;
943         struct SlEntry *se;
944         size_t addsize, rowlen;
945         void *p;
946
947         addsize = sizeof(*slit);
948         rowlen = l64get(raw + 36);
949         addsize += rowlen * sizeof(struct SlEntry *);
950         addsize += sizeof(struct SlEntry) * rowlen * rowlen;
951
952         t = mkatable(parent, SLIT, name, raw, rawsize, addsize);
953         slit = t->tbl;
954         slit->rowlen = rowlen;
955         p = (void *)slit + sizeof(*slit);
956         slit->e = p;
957         p += rowlen * sizeof(struct SlEntry *);
958         for (i = 0; i < rowlen; i++) {
959                 slit->e[i] = p;
960                 p += sizeof(struct SlEntry) * rowlen;
961         }
962         for (i = 0, r = raw + 44, re = raw + rawsize; r < re; r++, i++) {
963                 int j = i / rowlen;
964                 int k = i % rowlen;
965
966                 se = &slit->e[j][k];
967                 se->dom = k;
968                 se->dist = *r;
969         }
970
971 #if 0
972         /* TODO: might need to sort this shit */
973         for (i = 0; i < slit->rowlen; i++)
974                 qsort(slit->e[i], slit->rowlen, sizeof(slit->e[0][0]), cmpslitent);
975 #endif
976
977         return finatable_nochildren(t);
978 }
979
980 int pickcore(int mycolor, int index)
981 {
982         int color;
983         int ncorepercol;
984
985         if (slit == NULL)
986                 return 0;
987         ncorepercol = num_cores / slit->rowlen;
988         color = slit->e[mycolor][index / ncorepercol].dom;
989         return color * ncorepercol + index % ncorepercol;
990 }
991
992 static char *polarity[4] = {
993         "polarity/trigger like in ISA",
994         "active high",
995         "BOGUS POLARITY",
996         "active low"
997 };
998
999 static char *trigger[] = {
1000         "BOGUS TRIGGER",
1001         "edge",
1002         "BOGUS TRIGGER",
1003         "level"
1004 };
1005
1006 static char *printiflags(char *start, char *end, int flags)
1007 {
1008
1009         return seprintf(start, end, "[%s,%s]",
1010                                         polarity[flags & AFpmask], trigger[(flags & AFtmask) >> 2]);
1011 }
1012
1013 static char *dumpmadt(char *start, char *end, struct Atable *apics)
1014 {
1015         struct Madt *mt;
1016
1017         if (apics == NULL)
1018                 return start;
1019
1020         mt = apics->tbl;
1021         if (mt == NULL)
1022                 return seprintf(start, end, "acpi: no MADT");
1023         start = seprintf(start, end, "acpi: MADT@%p: lapic paddr %p pcat %d:\n",
1024                          mt, mt->lapicpa, mt->pcat);
1025         for (int i = 0; i < apics->nchildren; i++) {
1026                 struct Atable *apic = apics->children[i];
1027                 struct Apicst *st = apic->tbl;
1028
1029                 switch (st->type) {
1030                         case ASlapic:
1031                                 start =
1032                                         seprintf(start, end, "\tlapic pid %d id %d\n",
1033                                                          st->lapic.pid, st->lapic.id);
1034                                 break;
1035                         case ASioapic:
1036                         case ASiosapic:
1037                                 start =
1038                                         seprintf(start, end,
1039                                                          "\tioapic id %d addr %p ibase %d\n",
1040                                                          st->ioapic.id, st->ioapic.addr, st->ioapic.ibase);
1041                                 break;
1042                         case ASintovr:
1043                                 start =
1044                                         seprintf(start, end, "\tintovr irq %d intr %d flags $%p",
1045                                                          st->intovr.irq, st->intovr.intr, st->intovr.flags);
1046                                 start = printiflags(start, end, st->intovr.flags);
1047                                 start = seprintf(start, end, "\n");
1048                                 break;
1049                         case ASnmi:
1050                                 start = seprintf(start, end, "\tnmi intr %d flags $%p\n",
1051                                                                  st->nmi.intr, st->nmi.flags);
1052                                 break;
1053                         case ASlnmi:
1054                                 start =
1055                                         seprintf(start, end, "\tlnmi pid %d lint %d flags $%p\n",
1056                                                          st->lnmi.pid, st->lnmi.lint, st->lnmi.flags);
1057                                 break;
1058                         case ASlsapic:
1059                                 start =
1060                                         seprintf(start, end,
1061                                                          "\tlsapic pid %d id %d eid %d puid %d puids %s\n",
1062                                                          st->lsapic.pid, st->lsapic.id, st->lsapic.eid,
1063                                                          st->lsapic.puid, st->lsapic.puids);
1064                                 break;
1065                         case ASintsrc:
1066                                 start =
1067                                         seprintf(start, end,
1068                                                          "\tintr type %d pid %d peid %d iosv %d intr %d %#x\n",
1069                                                          st->type, st->intsrc.pid, st->intsrc.peid,
1070                                                          st->intsrc.iosv, st->intsrc.intr,
1071                                                          st->intsrc.flags);
1072                                 start = printiflags(start, end, st->intsrc.flags);
1073                                 start = seprintf(start, end, "\n");
1074                                 break;
1075                         case ASlx2apic:
1076                                 start =
1077                                         seprintf(start, end, "\tlx2apic puid %d id %d\n",
1078                                                          st->lx2apic.puid, st->lx2apic.id);
1079                                 break;
1080                         case ASlx2nmi:
1081                                 start =
1082                                         seprintf(start, end, "\tlx2nmi puid %d intr %d flags $%p\n",
1083                                                          st->lx2nmi.puid, st->lx2nmi.intr,
1084                                                          st->lx2nmi.flags);
1085                                 break;
1086                         default:
1087                                 start = seprintf(start, end, "\t<unknown madt entry>\n");
1088                 }
1089         }
1090         start = seprintf(start, end, "\n");
1091         return start;
1092 }
1093
1094 static struct Atable *parsemadt(struct Atable *parent,
1095                                 char *name, uint8_t *p, size_t size)
1096 {
1097         struct Atable *t, *tt, *tail;
1098         uint8_t *pe;
1099         struct Madt *mt;
1100         struct Apicst *st, *l;
1101         int id;
1102         size_t stlen;
1103         char buf[16];
1104         int i;
1105         struct slice slice;
1106
1107         slice_init(&slice);
1108         t = mkatable(parent, MADT, name, p, size, sizeof(struct Madt));
1109         mt = t->tbl;
1110         mt->lapicpa = l32get(p + 36);
1111         mt->pcat = l32get(p + 40);
1112         pe = p + size;
1113         for (p += 44, i = 0; p < pe; p += stlen, i++) {
1114                 snprintf(buf, sizeof(buf), "%d", i);
1115                 stlen = p[1];
1116                 tt = mkatable(t, APIC, buf, p, stlen, sizeof(struct Apicst));
1117                 st = tt->tbl;
1118                 st->type = p[0];
1119                 switch (st->type) {
1120                         case ASlapic:
1121                                 st->lapic.pid = p[2];
1122                                 st->lapic.id = p[3];
1123                                 if (l32get(p + 4) == 0) {
1124                                         kfree(tt);
1125                                         tt = NULL;
1126                                 }
1127                                 break;
1128                         case ASioapic:
1129                                 st->ioapic.id = id = p[2];
1130                                 st->ioapic.addr = l32get(p + 4);
1131                                 st->ioapic.ibase = l32get(p + 8);
1132                                 /* ioapic overrides any ioapic entry for the same id */
1133                                 for (int i = 0; i < slice_len(&slice); i++) {
1134                                         l = ((struct Atable *)slice_get(&slice, i))->tbl;
1135                                         if (l->type == ASiosapic && l->iosapic.id == id) {
1136                                                 st->ioapic = l->iosapic;
1137                                                 /* we leave it linked; could be removed */
1138                                                 break;
1139                                         }
1140                                 }
1141                                 break;
1142                         case ASintovr:
1143                                 st->intovr.irq = p[3];
1144                                 st->intovr.intr = l32get(p + 4);
1145                                 st->intovr.flags = l16get(p + 8);
1146                                 break;
1147                         case ASnmi:
1148                                 st->nmi.flags = l16get(p + 2);
1149                                 st->nmi.intr = l32get(p + 4);
1150                                 break;
1151                         case ASlnmi:
1152                                 st->lnmi.pid = p[2];
1153                                 st->lnmi.flags = l16get(p + 3);
1154                                 st->lnmi.lint = p[5];
1155                                 break;
1156                         case ASladdr:
1157                                 /* This is for 64 bits, perhaps we should not
1158                                  * honor it on 32 bits.
1159                                  */
1160                                 mt->lapicpa = l64get(p + 8);
1161                                 break;
1162                         case ASiosapic:
1163                                 id = st->iosapic.id = p[2];
1164                                 st->iosapic.ibase = l32get(p + 4);
1165                                 st->iosapic.addr = l64get(p + 8);
1166                                 /* iosapic overrides any ioapic entry for the same id */
1167                                 for (int i = 0; i < slice_len(&slice); i++) {
1168                                         l = ((struct Atable*)slice_get(&slice, i))->tbl;
1169                                         if (l->type == ASioapic && l->ioapic.id == id) {
1170                                                 l->ioapic = st->iosapic;
1171                                                 kfree(tt);
1172                                                 tt = NULL;
1173                                                 break;
1174                                         }
1175                                 }
1176                                 break;
1177                         case ASlsapic:
1178                                 st->lsapic.pid = p[2];
1179                                 st->lsapic.id = p[3];
1180                                 st->lsapic.eid = p[4];
1181                                 st->lsapic.puid = l32get(p + 12);
1182                                 if (l32get(p + 8) == 0) {
1183                                         kfree(tt);
1184                                         tt = NULL;
1185                                 } else
1186                                         kstrdup(&st->lsapic.puids, (char *)p + 16);
1187                                 break;
1188                         case ASintsrc:
1189                                 st->intsrc.flags = l16get(p + 2);
1190                                 st->type = p[4];
1191                                 st->intsrc.pid = p[5];
1192                                 st->intsrc.peid = p[6];
1193                                 st->intsrc.iosv = p[7];
1194                                 st->intsrc.intr = l32get(p + 8);
1195                                 st->intsrc.any = l32get(p + 12);
1196                                 break;
1197                         case ASlx2apic:
1198                                 st->lx2apic.id = l32get(p + 4);
1199                                 st->lx2apic.puid = l32get(p + 12);
1200                                 if (l32get(p + 8) == 0) {
1201                                         kfree(tt);
1202                                         tt = NULL;
1203                                 }
1204                                 break;
1205                         case ASlx2nmi:
1206                                 st->lx2nmi.flags = l16get(p + 2);
1207                                 st->lx2nmi.puid = l32get(p + 4);
1208                                 st->lx2nmi.intr = p[8];
1209                                 break;
1210                         default:
1211                                 printd("unknown APIC structure\n");
1212                                 kfree(tt);
1213                                 tt = NULL;
1214                 }
1215                 if (tt != NULL) {
1216                         finatable_nochildren(tt);
1217                         slice_append(&slice, tt);
1218                 }
1219         }
1220         apics = finatable(t, &slice);
1221
1222         return apics;
1223 }
1224
1225 static struct Atable *parsedmar(struct Atable *parent,
1226                                 char *name, uint8_t *raw, size_t rawsize)
1227 {
1228         struct Atable *t, *tt;
1229         int i;
1230         int baselen = MIN(rawsize, 38);
1231         int nentry, nscope, npath, off, dslen, dhlen, len, type, flags;
1232         void *pathp;
1233         char buf[16];
1234         struct slice drhds;
1235         struct Drhd *drhd;
1236         struct Dmar *dt;
1237
1238         /* count the entries */
1239         for (nentry = 0, off = 48; off < rawsize; nentry++) {
1240                 dslen = l16get(raw + off + 2);
1241                 printk("acpi DMAR: entry %d is addr %p (0x%x/0x%x)\n",
1242                        nentry, raw + off, l16get(raw + off), dslen);
1243                 off = off + dslen;
1244         }
1245         printk("DMAR: %d entries\n", nentry);
1246
1247         t = mkatable(parent, DMAR, name, raw, rawsize, sizeof(*dmar));
1248         dt = t->tbl;
1249         /* The table can be only partly filled. */
1250         if (baselen >= 38 && raw[37] & 1)
1251                 dt->intr_remap = 1;
1252         if (baselen >= 37)
1253                 dt->haw = raw[36] + 1;
1254
1255         /* Now we walk all the DMAR entries. */
1256         slice_init(&drhds);
1257         for (off = 48, i = 0; i < nentry; i++, off += dslen) {
1258                 snprintf(buf, sizeof(buf), "%d", i);
1259                 dslen = l16get(raw + off + 2);
1260                 type = l16get(raw + off);
1261                 // TODO(dcross): Introduce sensible symbolic constants
1262                 // for DMAR entry types. For right now, type 0 => DRHD.
1263                 // We skip everything else.
1264                 if (type != 0)
1265                         continue;
1266                 npath = 0;
1267                 nscope = 0;
1268                 for (int o = off + 16; o < (off + dslen); o += dhlen) {
1269                         nscope++;
1270                         dhlen = *(raw + o + 1); // Single byte length.
1271                         npath += ((dhlen - 6) / 2);
1272                 }
1273                 tt = mkatable(t, DRHD, buf, raw + off, dslen,
1274                               sizeof(struct Drhd) + 2 * npath +
1275                               nscope * sizeof(struct DevScope));
1276                 flags = *(raw + off + 4);
1277                 drhd = tt->tbl;
1278                 drhd->all = flags & 1;
1279                 drhd->segment = l16get(raw + off + 6);
1280                 drhd->rba = l64get(raw + off + 8);
1281                 drhd->nscope = nscope;
1282                 drhd->scopes = (void *)drhd + sizeof(struct Drhd);
1283                 pathp = (void *)drhd +
1284                     sizeof(struct Drhd) + nscope * sizeof(struct DevScope);
1285                 for (int i = 0, o = off + 16; i < nscope; i++) {
1286                         struct DevScope *ds = &drhd->scopes[i];
1287
1288                         dhlen = *(raw + o + 1);
1289                         ds->enumeration_id = *(raw + o + 4);
1290                         ds->start_bus_number = *(raw + o + 5);
1291                         ds->npath = (dhlen - 6) / 2;
1292                         ds->paths = pathp;
1293                         for (int j = 0; j < ds->npath; j++)
1294                                 ds->paths[j] = l16get(raw + o + 6 + 2*j);
1295                         pathp += 2*ds->npath;
1296                         o += dhlen;
1297                 }
1298                 /*
1299                  * NOTE: if all is set, there should be no scopes of type
1300                  * This being ACPI, where vendors randomly copy tables
1301                  * from one system to another, and creating breakage,
1302                  * anything is possible. But we'll warn them.
1303                  */
1304                 finatable_nochildren(tt);
1305                 slice_append(&drhds, tt);
1306         }
1307         dmar = finatable(t, &drhds);
1308
1309         return dmar;
1310 }
1311
1312 /*
1313  * Map the table and keep it there.
1314  */
1315 static struct Atable *parsessdt(struct Atable *parent,
1316                                 char *name, uint8_t *raw, size_t size)
1317 {
1318         struct Atable *t;
1319         struct Sdthdr *h;
1320
1321         /*
1322          * We found it and it is too small.
1323          * Simply return with no side effect.
1324          */
1325         if (size < Sdthdrsz)
1326                 return NULL;
1327         t = mkatable(parent, SSDT, name, raw, size, 0);
1328         h = (struct Sdthdr *)raw;
1329         memmove(t->name, h->sig, sizeof(h->sig));
1330         t->name[sizeof(h->sig)] = '\0';
1331
1332         return finatable_nochildren(t);
1333 }
1334
1335 static char *dumptable(char *start, char *end, char *sig, uint8_t *p, int l)
1336 {
1337         int n, i;
1338
1339         if (2 > 1) {
1340                 start = seprintf(start, end, "%s @ %#p\n", sig, p);
1341                 if (2 > 2)
1342                         n = l;
1343                 else
1344                         n = 256;
1345                 for (i = 0; i < n; i++) {
1346                         if ((i % 16) == 0)
1347                                 start = seprintf(start, end, "%x: ", i);
1348                         start = seprintf(start, end, " %2.2ux", p[i]);
1349                         if ((i % 16) == 15)
1350                                 start = seprintf(start, end, "\n");
1351                 }
1352                 start = seprintf(start, end, "\n");
1353                 start = seprintf(start, end, "\n");
1354         }
1355         return start;
1356 }
1357
1358 static char *seprinttable(char *s, char *e, struct Atable *t)
1359 {
1360         uint8_t *p;
1361         int i, n;
1362
1363         p = (uint8_t *)t->tbl;  /* include header */
1364         n = t->rawsize;
1365         s = seprintf(s, e, "%s @ %#p\n", t->name, p);
1366         for (i = 0; i < n; i++) {
1367                 if ((i % 16) == 0)
1368                         s = seprintf(s, e, "%x: ", i);
1369                 s = seprintf(s, e, " %2.2ux", p[i]);
1370                 if ((i % 16) == 15)
1371                         s = seprintf(s, e, "\n");
1372         }
1373         return seprintf(s, e, "\n\n");
1374 }
1375
1376 static void *rsdsearch(char *signature)
1377 {
1378         uintptr_t p;
1379         uint8_t *bda;
1380         void *rsd;
1381
1382         /*
1383          * Search for the data structure signature:
1384          * 1) in the BIOS ROM between 0xE0000 and 0xFFFFF.
1385          */
1386         return sigscan(KADDR_NOCHECK(0xE0000), 0x20000, signature);
1387 }
1388
1389 /*
1390  * Note: some of this comment is from the unfinished user interpreter.
1391  *
1392  * The DSDT is always given to the user interpreter.
1393  * Tables listed here are also loaded from the XSDT:
1394  * MSCT, MADT, and FADT are processed by us, because they are
1395  * required to do early initialization before we have user processes.
1396  * Other tables are given to the user level interpreter for
1397  * execution.
1398  *
1399  * These historically returned a value to tell acpi whether or not it was okay
1400  * to unmap the table.  (return 0 means there was no table, meaning it was okay
1401  * to unmap).  We just use the kernbase mapping, so it's irrelevant.
1402  *
1403  * N.B. The intel source code defines the constants for ACPI in a
1404  * non-endian-independent manner. Rather than bring in the huge wad o' code
1405  * that represents, we just the names.
1406  */
1407 struct Parser {
1408         char *sig;
1409         struct Atable *(*parse)(struct Atable *parent,
1410                                 char *name, uint8_t *raw, size_t rawsize);
1411 };
1412
1413
1414 static struct Parser ptable[] = {
1415         {"FACP", parsefadt},
1416         {"APIC", parsemadt},
1417         {"DMAR", parsedmar},
1418         {"SRAT", parsesrat},
1419         {"SLIT", parseslit},
1420         {"MSCT", parsemsct},
1421         {"SSDT", parsessdt},
1422         {"HPET", parsehpet},
1423 };
1424
1425 /*
1426  * process xsdt table and load tables with sig, or all if NULL.
1427  * (XXX: should be able to search for sig, oemid, oemtblid)
1428  */
1429 static void parsexsdt(struct Atable *root)
1430 {
1431         ERRSTACK(1);
1432         struct Sdthdr *sdt;
1433         struct Atable *table;
1434         struct slice slice;
1435         size_t l, end;
1436         uintptr_t dhpa;
1437         struct Atable *n;
1438         uint8_t *tbl;
1439
1440         slice_init(&slice);
1441         if (waserror()) {
1442                 slice_destroy(&slice);
1443                 return;
1444         }
1445
1446         tbl = xsdt->p + sizeof(struct Sdthdr);
1447         end = xsdt->len - sizeof(struct Sdthdr);
1448         for (int i = 0; i < end; i += xsdt->asize) {
1449                 dhpa = (xsdt->asize == 8) ? l64get(tbl + i) : l32get(tbl + i);
1450                 sdt = sdtmap(dhpa, &l, 1);
1451                 if (sdt == NULL)
1452                         continue;
1453                 printd("acpi: %s addr %#p\n", tsig, sdt);
1454                 for (int j = 0; j < ARRAY_SIZE(ptable); j++) {
1455                         if (memcmp(sdt->sig, ptable[j].sig, sizeof(sdt->sig)) == 0) {
1456                                 table = ptable[j].parse(root, ptable[j].sig, (void *)sdt, l);
1457                                 if (table != NULL)
1458                                         slice_append(&slice, table);
1459                                 break;
1460                         }
1461                 }
1462         }
1463         finatable(root, &slice);
1464 }
1465
1466 void makeindex(struct Atable *root)
1467 {
1468         uint64_t index;
1469
1470         if (root == NULL)
1471                 return;
1472         index = root->qid.path >> QIndexShift;
1473         atableindex[index] = root;
1474         for (int k = 0; k < root->nchildren; k++)
1475                 makeindex(root->children[k]);
1476 }
1477
1478 static void parsersdptr(void)
1479 {
1480         struct Rsdp *rsd;
1481         int asize, cksum;
1482         uintptr_t sdtpa;
1483
1484         static_assert(sizeof(struct Sdthdr) == 36);
1485
1486         /* Find the root pointer. */
1487         rsd = rsdsearch("RSD PTR ");
1488         if (rsd == NULL) {
1489                 printk("NO RSDP\n");
1490                 return;
1491         }
1492
1493         /*
1494          * Initialize the root of ACPI parse tree.
1495          */
1496         lastpath = Qroot;
1497         root = mkatable(NULL, XSDT, devname(), NULL, 0, sizeof(struct Xsdt));
1498         root->parent = root;
1499
1500         printd("/* RSDP */ struct Rsdp = {%08c, %x, %06c, %x, %p, %d, %p, %x}\n",
1501                    rsd->signature, rsd->rchecksum, rsd->oemid, rsd->revision,
1502                    *(uint32_t *)rsd->raddr, *(uint32_t *)rsd->length,
1503                    *(uint32_t *)rsd->xaddr, rsd->xchecksum);
1504
1505         printd("acpi: RSD PTR@ %#p, physaddr $%p length %ud %#llux rev %d\n",
1506                    rsd, l32get(rsd->raddr), l32get(rsd->length),
1507                    l64get(rsd->xaddr), rsd->revision);
1508
1509         if (rsd->revision >= 2) {
1510                 cksum = sdtchecksum(rsd, 36);
1511                 if (cksum != 0) {
1512                         printk("acpi: bad RSD checksum %d, 64 bit parser aborted\n", cksum);
1513                         return;
1514                 }
1515                 sdtpa = l64get(rsd->xaddr);
1516                 asize = 8;
1517         } else {
1518                 cksum = sdtchecksum(rsd, 20);
1519                 if (cksum != 0) {
1520                         printk("acpi: bad RSD checksum %d, 32 bit parser aborted\n", cksum);
1521                         return;
1522                 }
1523                 sdtpa = l32get(rsd->raddr);
1524                 asize = 4;
1525         }
1526
1527         /*
1528          * process the RSDT or XSDT table.
1529          */
1530         xsdt = root->tbl;
1531         xsdt->p = sdtmap(sdtpa, &xsdt->len, 1);
1532         if (xsdt->p == NULL) {
1533                 printk("acpi: sdtmap failed\n");
1534                 return;
1535         }
1536         if ((xsdt->p[0] != 'R' && xsdt->p[0] != 'X')
1537                 || memcmp(xsdt->p + 1, "SDT", 3) != 0) {
1538                 printd("acpi: xsdt sig: %c%c%c%c\n",
1539                        xsdt->p[0], xsdt->p[1], xsdt->p[2], xsdt->p[3]);
1540                 xsdt = NULL;
1541                 return;
1542         }
1543         xsdt->asize = asize;
1544         printd("acpi: XSDT %#p\n", xsdt);
1545         parsexsdt(root);
1546         atableindex = kreallocarray(NULL, lastpath, sizeof(struct Atable *),
1547                                     MEM_WAIT);
1548         assert(atableindex != NULL);
1549         makeindex(root);
1550 }
1551
1552 /* Given an xsdt, find the table matching 'sig', if any. */
1553 static struct Sdthdr *xsdt_find_tbl(struct Sdthdr *xsdt, const char *sig,
1554                                     int addr_size)
1555 {
1556         uint8_t *ptr_tbl;
1557         size_t ptr_tbl_len;
1558         physaddr_t sdt_pa;
1559         struct Sdthdr *sdt;
1560
1561         ptr_tbl = (uint8_t*)xsdt + sizeof(struct Sdthdr);
1562         ptr_tbl_len = l32get(xsdt->length) - sizeof(struct Sdthdr);
1563         for (int i = 0; i < ptr_tbl_len; i += addr_size) {
1564                 sdt_pa = (addr_size == 8) ? l64get(ptr_tbl + i) : l32get(ptr_tbl + i);
1565                 sdt = KADDR_NOCHECK(sdt_pa);
1566                 if (memcmp(sdt->sig, sig, sizeof(sdt->sig)) == 0)
1567                         return sdt;
1568         }
1569         return NULL;
1570 }
1571
1572 /* This may be an overestimate, if some LAPICS are present but disabled */
1573 static int madt_get_nr_cores(struct Sdthdr *madt)
1574 {
1575         uint8_t *p, *madt_end;
1576         size_t entry_len;
1577         int nr_cores = 0;
1578
1579         p = (uint8_t*)madt;
1580         madt_end = p + l32get(madt->length);
1581         for (p += 44; p < madt_end; p += entry_len) {
1582                 entry_len = p[1];
1583                 switch (p[0]) {
1584                 case ASlapic:
1585                         nr_cores++;
1586                         break;
1587                 default:
1588                         break;
1589                 }
1590         }
1591         return nr_cores;
1592 }
1593
1594 int get_early_num_cores(void)
1595 {
1596         struct Rsdp *rsd;
1597         int asize;
1598         physaddr_t sdtpa;
1599         struct Sdthdr *xsdt, *madt;
1600         uint8_t *xsdt_buf;
1601         int nr_cores;
1602
1603         rsd = rsdsearch("RSD PTR ");
1604         assert(rsd);
1605         if (rsd->revision >= 2) {
1606                 sdtpa = l64get(rsd->xaddr);
1607                 asize = 8;
1608         } else {
1609                 sdtpa = l32get(rsd->raddr);
1610                 asize = 4;
1611         }
1612
1613         xsdt = KADDR_NOCHECK(sdtpa);
1614         xsdt_buf = (uint8_t*)xsdt;
1615         if ((xsdt_buf[0] != 'R' && xsdt_buf[0] != 'X')
1616                 || memcmp(xsdt_buf + 1, "SDT", 3) != 0) {
1617                 panic("acpi: xsdt sig: %c%c%c%c\n",
1618                        xsdt_buf[0], xsdt_buf[1], xsdt_buf[2], xsdt_buf[3]);
1619         }
1620         madt = xsdt_find_tbl(xsdt, "APIC", asize);
1621         assert(madt);
1622         nr_cores = madt_get_nr_cores(madt);
1623         if (nr_cores == 0) {
1624                 warn("MADT parsing found 0 cores!");
1625                 nr_cores = 1;
1626         }
1627         return nr_cores;
1628 }
1629
1630 /*
1631  * The invariant that each level in the tree has an associated
1632  * Atable implies that each chan can be mapped to an Atable.
1633  * The assertions here enforce that invariant.
1634  */
1635 static struct Atable *genatable(struct chan *c)
1636 {
1637         struct Atable *a;
1638         uint64_t ai;
1639
1640         ai = c->qid.path >> QIndexShift;
1641         assert(ai < lastpath);
1642         a = atableindex[ai];
1643         assert(a != NULL);
1644
1645         return a;
1646 }
1647
1648 static int acpigen(struct chan *c, char *name, struct dirtab *tab, int ntab,
1649                                    int i, struct dir *dp)
1650 {
1651         struct Atable *a = genatable(c);
1652
1653         if (i == DEVDOTDOT) {
1654                 assert((c->qid.path & QIndexMask) == Qdir);
1655                 devdir(c, a->parent->qid, a->parent->name, 0, eve.name, DMDIR | 0555,
1656                        dp);
1657                 return 1;
1658         }
1659         return devgen(c, name, a->cdirs, a->nchildren + NQtypes, i, dp);
1660 }
1661
1662 /*
1663  * Print the contents of the XSDT.
1664  */
1665 static void dumpxsdt(void)
1666 {
1667         printk("xsdt: len = %lu, asize = %lu, p = %p\n",
1668                xsdt->len, xsdt->asize, xsdt->p);
1669 }
1670
1671 static char *dumpGas(char *start, char *end, char *prefix, struct Gas *g)
1672 {
1673         start = seprintf(start, end, "%s", prefix);
1674
1675         switch (g->spc) {
1676                 case Rsysmem:
1677                 case Rsysio:
1678                 case Rembed:
1679                 case Rsmbus:
1680                 case Rcmos:
1681                 case Rpcibar:
1682                 case Ripmi:
1683                         start = seprintf(start, end, "[%s ", regnames[g->spc]);
1684                         break;
1685                 case Rpcicfg:
1686                         start = seprintf(start, end, "[pci ");
1687                         start =
1688                                 seprintf(start, end, "dev %#p ",
1689                                                  (uint32_t)(g->addr >> 32) & 0xFFFF);
1690                         start =
1691                                 seprintf(start, end, "fn %#p ",
1692                                                  (uint32_t)(g->addr & 0xFFFF0000) >> 16);
1693                         start =
1694                                 seprintf(start, end, "adr %#p ", (uint32_t)(g->addr & 0xFFFF));
1695                         break;
1696                 case Rfixedhw:
1697                         start = seprintf(start, end, "[hw ");
1698                         break;
1699                 default:
1700                         start = seprintf(start, end, "[spc=%#p ", g->spc);
1701         }
1702         start = seprintf(start, end, "off %d len %d addr %#p sz%d]",
1703                                          g->off, g->len, g->addr, g->accsz);
1704         start = seprintf(start, end, "\n");
1705         return start;
1706 }
1707
1708 static unsigned int getbanked(uintptr_t ra, uintptr_t rb, int sz)
1709 {
1710         unsigned int r;
1711
1712         r = 0;
1713         switch (sz) {
1714                 case 1:
1715                         if (ra != 0)
1716                                 r |= inb(ra);
1717                         if (rb != 0)
1718                                 r |= inb(rb);
1719                         break;
1720                 case 2:
1721                         if (ra != 0)
1722                                 r |= inw(ra);
1723                         if (rb != 0)
1724                                 r |= inw(rb);
1725                         break;
1726                 case 4:
1727                         if (ra != 0)
1728                                 r |= inl(ra);
1729                         if (rb != 0)
1730                                 r |= inl(rb);
1731                         break;
1732                 default:
1733                         printd("getbanked: wrong size\n");
1734         }
1735         return r;
1736 }
1737
1738 static unsigned int setbanked(uintptr_t ra, uintptr_t rb, int sz, int v)
1739 {
1740         unsigned int r;
1741
1742         r = -1;
1743         switch (sz) {
1744                 case 1:
1745                         if (ra != 0)
1746                                 outb(ra, v);
1747                         if (rb != 0)
1748                                 outb(rb, v);
1749                         break;
1750                 case 2:
1751                         if (ra != 0)
1752                                 outw(ra, v);
1753                         if (rb != 0)
1754                                 outw(rb, v);
1755                         break;
1756                 case 4:
1757                         if (ra != 0)
1758                                 outl(ra, v);
1759                         if (rb != 0)
1760                                 outl(rb, v);
1761                         break;
1762                 default:
1763                         printd("setbanked: wrong size\n");
1764         }
1765         return r;
1766 }
1767
1768 static unsigned int getpm1ctl(void)
1769 {
1770         assert(fadt != NULL);
1771         return getbanked(fadt->pm1acntblk, fadt->pm1bcntblk, fadt->pm1cntlen);
1772 }
1773
1774 static void setpm1sts(unsigned int v)
1775 {
1776         assert(fadt != NULL);
1777         setbanked(fadt->pm1aevtblk, fadt->pm1bevtblk, fadt->pm1evtlen / 2, v);
1778 }
1779
1780 static unsigned int getpm1sts(void)
1781 {
1782         assert(fadt != NULL);
1783         return getbanked(fadt->pm1aevtblk, fadt->pm1bevtblk, fadt->pm1evtlen / 2);
1784 }
1785
1786 static unsigned int getpm1en(void)
1787 {
1788         int sz;
1789
1790         assert(fadt != NULL);
1791         sz = fadt->pm1evtlen / 2;
1792         return getbanked(fadt->pm1aevtblk + sz, fadt->pm1bevtblk + sz, sz);
1793 }
1794
1795 static int getgpeen(int n)
1796 {
1797         return inb(gpes[n].enio) & 1 << gpes[n].enbit;
1798 }
1799
1800 static void setgpeen(int n, unsigned int v)
1801 {
1802         int old;
1803
1804         old = inb(gpes[n].enio);
1805         if (v)
1806                 outb(gpes[n].enio, old | 1 << gpes[n].enbit);
1807         else
1808                 outb(gpes[n].enio, old & ~(1 << gpes[n].enbit));
1809 }
1810
1811 static void clrgpests(int n)
1812 {
1813         outb(gpes[n].stsio, 1 << gpes[n].stsbit);
1814 }
1815
1816 static unsigned int getgpests(int n)
1817 {
1818         return inb(gpes[n].stsio) & 1 << gpes[n].stsbit;
1819 }
1820
1821 #if 0
1822 static void acpiintr(Ureg *, void *)
1823 {
1824         int i;
1825         unsigned int sts, en;
1826
1827         printd("acpi: intr\n");
1828
1829         for (i = 0; i < ngpes; i++)
1830                 if (getgpests(i)) {
1831                         printd("gpe %d on\n", i);
1832                         en = getgpeen(i);
1833                         setgpeen(i, 0);
1834                         clrgpests(i);
1835                         if (en != 0)
1836                                 printd("acpiitr: calling gpe %d\n", i);
1837                         //  queue gpe for calling gpe->ho in the
1838                         //  aml process.
1839                         //  enable it again when it returns.
1840                 }
1841         sts = getpm1sts();
1842         en = getpm1en();
1843         printd("acpiitr: pm1sts %#p pm1en %#p\n", sts, en);
1844         if (sts & en)
1845                 printd("have enabled events\n");
1846         if (sts & 1)
1847                 printd("power button\n");
1848         // XXX serve other interrupts here.
1849         setpm1sts(sts);
1850 }
1851 #endif
1852
1853 static void initgpes(void)
1854 {
1855         int i, n0, n1;
1856
1857         assert(fadt != NULL);
1858         n0 = fadt->gpe0blklen / 2;
1859         n1 = fadt->gpe1blklen / 2;
1860         ngpes = n0 + n1;
1861         gpes = kzmalloc(sizeof(struct Gpe) * ngpes, 1);
1862         for (i = 0; i < n0; i++) {
1863                 gpes[i].nb = i;
1864                 gpes[i].stsbit = i & 7;
1865                 gpes[i].stsio = fadt->gpe0blk + (i >> 3);
1866                 gpes[i].enbit = (n0 + i) & 7;
1867                 gpes[i].enio = fadt->gpe0blk + ((n0 + i) >> 3);
1868         }
1869         for (i = 0; i + n0 < ngpes; i++) {
1870                 gpes[i + n0].nb = fadt->gp1base + i;
1871                 gpes[i + n0].stsbit = i & 7;
1872                 gpes[i + n0].stsio = fadt->gpe1blk + (i >> 3);
1873                 gpes[i + n0].enbit = (n1 + i) & 7;
1874                 gpes[i + n0].enio = fadt->gpe1blk + ((n1 + i) >> 3);
1875         }
1876         for (i = 0; i < ngpes; i++) {
1877                 setgpeen(i, 0);
1878                 clrgpests(i);
1879         }
1880 }
1881
1882 static void acpiioalloc(unsigned int addr, int len)
1883 {
1884         if (addr != 0)
1885                 printd("Just TAKING port %016lx to %016lx\n", addr, addr + len);
1886 }
1887
1888 static void acpiinitonce(void)
1889 {
1890         parsersdptr();
1891         if (root != NULL)
1892                 printk("ACPI initialized\n");
1893 }
1894
1895 int acpiinit(void)
1896 {
1897         run_once(acpiinitonce());
1898         return (root == NULL) ? -1 : 0;
1899 }
1900
1901 static struct chan *acpiattach(char *spec)
1902 {
1903         int i;
1904         struct chan *c;
1905         /*
1906          * This was written for the stock kernel.
1907          * This code must use 64 registers to be acpi ready in nix.
1908          */
1909         if (acpiinit() < 0)
1910                 error(ENOSYS, "no acpi");
1911
1912         /*
1913          * should use fadt->xpm* and fadt->xgpe* registers for 64 bits.
1914          * We are not ready in this kernel for that.
1915          */
1916         assert(fadt != NULL);
1917         acpiioalloc(fadt->smicmd, 1);
1918         acpiioalloc(fadt->pm1aevtblk, fadt->pm1evtlen);
1919         acpiioalloc(fadt->pm1bevtblk, fadt->pm1evtlen);
1920         acpiioalloc(fadt->pm1acntblk, fadt->pm1cntlen);
1921         acpiioalloc(fadt->pm1bcntblk, fadt->pm1cntlen);
1922         acpiioalloc(fadt->pm2cntblk, fadt->pm2cntlen);
1923         acpiioalloc(fadt->pmtmrblk, fadt->pmtmrlen);
1924         acpiioalloc(fadt->gpe0blk, fadt->gpe0blklen);
1925         acpiioalloc(fadt->gpe1blk, fadt->gpe1blklen);
1926
1927         initgpes();
1928 #ifdef RON_SAYS_CONFIG_WE_ARE_NOT_WORTHY
1929         /* this is frightening. SMI: just say no. Although we will almost
1930          * certainly find that we have no choice.
1931          *
1932          * This starts ACPI, which may require we handle
1933          * power mgmt events ourselves. Use with care.
1934          */
1935         outb(fadt->smicmd, fadt->acpienable);
1936         for (i = 0; i < 10; i++)
1937                 if (getpm1ctl() & Pm1SciEn)
1938                         break;
1939         if (i == 10)
1940                 error(EFAIL, "acpi: failed to enable\n");
1941         if (fadt->sciint != 0)
1942                 intrenable(fadt->sciint, acpiintr, 0, BUSUNKNOWN, "acpi");
1943 #endif
1944         c = devattach(devname(), spec);
1945
1946         return c;
1947 }
1948
1949 static struct walkqid *acpiwalk(struct chan *c, struct chan *nc, char **name,
1950                                                                 unsigned int nname)
1951 {
1952         /*
1953          * Note that devwalk hard-codes a test against the location of 'devgen',
1954          * so we pretty much have to not pass it here.
1955          */
1956         return devwalk(c, nc, name, nname, NULL, 0, acpigen);
1957 }
1958
1959 static size_t acpistat(struct chan *c, uint8_t *dp, size_t n)
1960 {
1961         struct Atable *a = genatable(c);
1962
1963         if (c->qid.type == QTDIR)
1964                 a = a->parent;
1965         assert(a != NULL);
1966
1967         /* TODO(dcross): make acpigen work here. */
1968         return devstat(c, dp, n, a->cdirs, a->nchildren + NQtypes, devgen);
1969 }
1970
1971 static struct chan *acpiopen(struct chan *c, int omode)
1972 {
1973         return devopen(c, omode, NULL, 0, acpigen);
1974 }
1975
1976 static void acpiclose(struct chan *unused)
1977 {
1978 }
1979
1980 static char *ttext;
1981 static int tlen;
1982
1983 // Get the table from the qid.
1984 // Read that one table using the pointers.
1985 static size_t acpiread(struct chan *c, void *a, size_t n, off64_t off)
1986 {
1987         long q;
1988         struct Atable *t;
1989         char *ns, *s, *e, *ntext;
1990
1991         if (ttext == NULL) {
1992                 tlen = 32768;
1993                 ttext = kzmalloc(tlen, 0);
1994         }
1995         if (ttext == NULL)
1996                 error(ENOMEM, "acpiread: no memory");
1997         q = c->qid.path & QIndexMask;
1998         switch (q) {
1999         case Qdir:
2000                 return devdirread(c, a, n, NULL, 0, acpigen);
2001         case Qraw:
2002                 return readmem(off, a, n, ttext, tlen);
2003         case Qtbl:
2004                 s = ttext;
2005                 e = ttext + tlen;
2006                 strlcpy(s, "no tables\n", tlen);
2007                 for (t = tfirst; t != NULL; t = t->next) {
2008                         ns = seprinttable(s, e, t);
2009                         while (ns == e - 1) {
2010                                 ntext = krealloc(ttext, tlen * 2, 0);
2011                                 if (ntext == NULL)
2012                                         panic("acpi: no memory\n");
2013                                 s = ntext + (ttext - s);
2014                                 ttext = ntext;
2015                                 tlen *= 2;
2016                                 e = ttext + tlen;
2017                                 ns = seprinttable(s, e, t);
2018                         }
2019                         s = ns;
2020                 }
2021                 return readstr(off, a, n, ttext);
2022         case Qpretty:
2023                 s = ttext;
2024                 e = ttext + tlen;
2025                 s = dumpfadt(s, e, fadt);
2026                 s = dumpmadt(s, e, apics);
2027                 s = dumpslit(s, e, slit);
2028                 s = dumpsrat(s, e, srat);
2029                 s = dumpdmar(s, e, dmar);
2030                 dumpmsct(s, e, mscttbl);
2031                 return readstr(off, a, n, ttext);
2032         default:
2033                 error(EINVAL, "acpiread: bad path %d\n", q);
2034         }
2035         error(EPERM, ERROR_FIXME);
2036
2037         return -1;
2038 }
2039
2040 static size_t acpiwrite(struct chan *c, void *a, size_t n, off64_t off)
2041 {
2042         error(EFAIL, "acpiwrite: not until we can figure out what it's for");
2043 #if 0
2044         ERRSTACK(2);
2045         struct cmdtab *ct;
2046         struct cmdbuf *cb;
2047         struct Reg *r;
2048         unsigned int rno, fun, dev, bus, i;
2049
2050         if (c->qid.path == Qio) {
2051                 if (reg == NULL)
2052                         error(EFAIL, "region not configured");
2053                 return regio(reg, a, n, off, 1);
2054         }
2055         if (c->qid.path != Qctl)
2056                 error(EPERM, ERROR_FIXME);
2057
2058         cb = parsecmd(a, n);
2059         if (waserror()) {
2060                 kfree(cb);
2061                 nexterror();
2062         }
2063         ct = lookupcmd(cb, ctls, ARRAY_SIZE(ctls));
2064         switch (ct->index) {
2065                 case CMregion:
2066                         /* TODO: this block is racy on reg (global) */
2067                         r = reg;
2068                         if (r == NULL) {
2069                                 r = kzmalloc(sizeof(struct Reg), 0);
2070                                 r->name = NULL;
2071                         }
2072                         kstrdup(&r->name, cb->f[1]);
2073                         r->spc = acpiregid(cb->f[2]);
2074                         if (r->spc < 0) {
2075                                 kfree(r);
2076                                 reg = NULL;
2077                                 error(EFAIL, "bad region type");
2078                         }
2079                         if (r->spc == Rpcicfg || r->spc == Rpcibar) {
2080                                 rno = r->base >> Rpciregshift & Rpciregmask;
2081                                 fun = r->base >> Rpcifunshift & Rpcifunmask;
2082                                 dev = r->base >> Rpcidevshift & Rpcidevmask;
2083                                 bus = r->base >> Rpcibusshift & Rpcibusmask;
2084 #ifdef CONFIG_X86
2085                                 r->tbdf = MKBUS(BusPCI, bus, dev, fun);
2086 #else
2087                                 r->tbdf = 0
2088 #endif
2089                                 r->base = rno;  /* register ~ our base addr */
2090                         }
2091                         r->base = strtoul(cb->f[3], NULL, 0);
2092                         r->len = strtoul(cb->f[4], NULL, 0);
2093                         r->accsz = strtoul(cb->f[5], NULL, 0);
2094                         if (r->accsz < 1 || r->accsz > 4) {
2095                                 kfree(r);
2096                                 reg = NULL;
2097                                 error(EFAIL, "bad region access size");
2098                         }
2099                         reg = r;
2100                         printd("region %s %s %p %p sz%d",
2101                                    r->name, acpiregstr(r->spc), r->base, r->len, r->accsz);
2102                         break;
2103                 case CMgpe:
2104                         i = strtoul(cb->f[1], NULL, 0);
2105                         if (i >= ngpes)
2106                                 error(ERANGE, "gpe out of range");
2107                         kstrdup(&gpes[i].obj, cb->f[2]);
2108                         setgpeen(i, 1);
2109                         break;
2110                 default:
2111                         panic("acpi: unknown ctl");
2112         }
2113         poperror();
2114         kfree(cb);
2115         return n;
2116 #endif
2117 }
2118
2119 struct {
2120         char *(*pretty)(struct Atable *atbl, char *start, char *end, void *arg);
2121 } acpisw[NACPITBLS] = {
2122 };
2123
2124 static char *pretty(struct Atable *atbl, char *start, char *end, void *arg)
2125 {
2126         int type;
2127
2128         type = atbl->type;
2129         if (type < 0 || NACPITBLS < type)
2130                 return start;
2131         if (acpisw[type].pretty == NULL)
2132                 return seprintf(start, end, "\"\"\n");
2133         return acpisw[type].pretty(atbl, start, end, arg);
2134 }
2135
2136 static char *raw(struct Atable *atbl, char *start, char *end, void *unused_arg)
2137 {
2138         size_t len = MIN(end - start, atbl->rawsize);
2139
2140         memmove(start, atbl->raw, len);
2141
2142         return start + len;
2143 }
2144
2145 struct dev acpidevtab __devtab = {
2146         .name = "acpi",
2147
2148         .reset = devreset,
2149         .init = devinit,
2150         .shutdown = devshutdown,
2151         .attach = acpiattach,
2152         .walk = acpiwalk,
2153         .stat = acpistat,
2154         .open = acpiopen,
2155         .create = devcreate,
2156         .close = acpiclose,
2157         .read = acpiread,
2158         .bread = devbread,
2159         .write = acpiwrite,
2160         .bwrite = devbwrite,
2161         .remove = devremove,
2162         .wstat = devwstat,
2163 };