show.bend
bend-osdev-acpi@0.1.0.0 · 301 lines · 0 definitions
1# bend-osdev-acpi, show.bend: tables, errors and AML values as one line of
2# text each, for logs and for the differential test (ref/gen.py writes the
3# same text from its own reader). Numbers are decimal, 64-bit values 16 hex
4# digits, byte strings hex.
5import Base
6import bend-osdev-word64@0.1.0.0/word64.bend as W
7import bend-osdev-bytes@0.1.0.0/bytes.bend as B
8import bend-osdev-acpi@0.1.0.0/error.bend as E
9import bend-osdev-acpi@0.1.0.0/header.bend as H
10import bend-osdev-acpi@0.1.0.0/gas.bend as G
11import bend-osdev-acpi@0.1.0.0/rsdp.bend as P
12import bend-osdev-acpi@0.1.0.0/rsdt.bend as S
13import bend-osdev-acpi@0.1.0.0/madt.bend as M
14import bend-osdev-acpi@0.1.0.0/fadt.bend as F
15import bend-osdev-acpi@0.1.0.0/facs.bend as FS
16import bend-osdev-acpi@0.1.0.0/hpet.bend as Hp
17import bend-osdev-acpi@0.1.0.0/mcfg.bend as Mc
18import bend-osdev-acpi@0.1.0.0/srat.bend as Sr
19import bend-osdev-acpi@0.1.0.0/slit.bend as Sl
20import bend-osdev-acpi@0.1.0.0/bgrt.bend as Bg
21import bend-osdev-acpi@0.1.0.0/dsdt.bend as D
22import bend-osdev-acpi@0.1.0.0/registry.bend as R
23
24def sh.u(+v: U32) -> String:
25 U32.show(v)
26
27def sh.n(+v: Nat) -> String:
28 Nat.show(v)
29
30def sh.w(+v: W.W64) -> String:
31 W.W64.show_hex(v)
32
33def sh.x(o: B.Octets) -> String:
34 B.Octets.hex(o)
35
36def sh.list(xs: List<&2, String>, sep: String) -> String:
37 String.join(xs, sep)
38
39def AcpiShow.error(e: E.AcpiError) -> String:
40 match e:
41 case E.AcpiTooShort{n, g}:
42 "TooShort " ++ sh.n(n) ++ " " ++ sh.n(g)
43 case E.AcpiBadSignature{s}:
44 "BadSignature " ++ sh.x(s)
45 case E.AcpiBadLength{l}:
46 "BadLength " ++ sh.u(l)
47 case E.AcpiBadChecksum{s}:
48 "BadChecksum " ++ sh.u(s)
49 case E.AcpiRsdpBadChecksum{s}:
50 "RsdpBadChecksum " ++ sh.u(s)
51 case E.AcpiRsdpBadExtChecksum{s}:
52 "RsdpBadExtChecksum " ++ sh.u(s)
53 case E.AcpiBadRevision{r}:
54 "BadRevision " ++ sh.u(r)
55 case E.AcpiBadEntry{o, k}:
56 "BadEntry " ++ sh.n(o) ++ " " ++ sh.u(k)
57 case E.AcpiBadSize{n}:
58 "BadSize " ++ sh.n(n)
59 case E.AcpiNotMapped{a}:
60 "NotMapped " ++ sh.w(a)
61 case E.AcpiTableMissing{s}:
62 "TableMissing " ++ sh.x(s)
63 case E.AcpiAmlTruncated{}:
64 "AmlTruncated"
65 case E.AcpiAmlBadOpcode{c}:
66 "AmlBadOpcode " ++ sh.u(c)
67 case E.AcpiAmlBadPkgLength{}:
68 "AmlBadPkgLength"
69 case E.AcpiAmlBadName{}:
70 "AmlBadName"
71 case E.AcpiAmlUndefined{p}:
72 "AmlUndefined " ++ p
73 case E.AcpiAmlDuplicate{p}:
74 "AmlDuplicate " ++ p
75 case E.AcpiAmlBadOperand{c}:
76 "AmlBadOperand " ++ sh.u(c)
77 case E.AcpiAmlBadType{s}:
78 "AmlBadType"
79 case E.AcpiAmlRange{}:
80 "AmlRange"
81 case E.AcpiAmlDivZero{}:
82 "AmlDivZero"
83 case E.AcpiAmlBadControl{}:
84 "AmlBadControl"
85 case E.AcpiAmlFatal{t, c, a}:
86 "AmlFatal " ++ sh.u(t) ++ " " ++ sh.u(c) ++ " " ++ sh.w(a)
87 case E.AcpiAmlUnsupported{s}:
88 "AmlUnsupported " ++ s
89 case E.AcpiAmlStepLimit{}:
90 "AmlStepLimit"
91 case E.AcpiAmlHost{c}:
92 "AmlHost " ++ sh.u(c)
93
94def AcpiShow.header(h: H.AcpiHeader) -> String:
95 match h:
96 case H.AcpiHeader{s, l, r, c, o, t, orv, ci, cr}:
97 sh.x(s) ++ " " ++ sh.u(l) ++ " " ++ sh.u(r) ++ " " ++ sh.u(c) ++ " " ++ sh.x(o) ++ " " ++ sh.x(t) ++ " " ++ sh.u(orv) ++ " " ++ sh.x(ci) ++ " " ++ sh.u(cr)
98
99def AcpiShow.gas(g: G.AcpiGas) -> String:
100 G.AcpiGas.show(g)
101
102def sh.rsdp.ext(m: Maybe<&2, P.AcpiRsdpExt>) -> String:
103 match m:
104 case None{}:
105 "none"
106 case Some{P.AcpiRsdpExt{l, x}}:
107 sh.u(l) ++ " " ++ sh.w(x)
108
109def AcpiShow.rsdp(r: P.AcpiRsdp) -> String:
110 match r:
111 case P.AcpiRsdp{o, v, a, x}:
112 "RSDP " ++ sh.x(o) ++ " " ++ sh.u(v) ++ " " ++ sh.u(a) ++ " " ++ sh.rsdp.ext(x)
113
114def sh.ws(xs: List<&2, W.W64>) -> List<&2, String>:
115 match xs:
116 case Nil{}:
117 Nil{}
118 case Con{h, t}:
119 Con{sh.w(h), sh.ws(t)}
120
121def AcpiShow.sdt_list(t: S.AcpiSdtList) -> String:
122 match t:
123 case S.AcpiSdtList{h, es}:
124 "SDT [" ++ sh.list(sh.ws(es), ",") ++ "]"
125
126def AcpiShow.madt_entry(e: M.AcpiMadtEntry) -> String:
127 match e:
128 case M.AcpiMadtLapic{u, a, f}:
129 "lapic " ++ sh.u(u) ++ " " ++ sh.u(a) ++ " " ++ sh.u(f)
130 case M.AcpiMadtIoApic{i, a, g}:
131 "ioapic " ++ sh.u(i) ++ " " ++ sh.u(a) ++ " " ++ sh.u(g)
132 case M.AcpiMadtIso{b, s, g, f}:
133 "iso " ++ sh.u(b) ++ " " ++ sh.u(s) ++ " " ++ sh.u(g) ++ " " ++ sh.u(f)
134 case M.AcpiMadtNmiSource{f, g}:
135 "nmisrc " ++ sh.u(f) ++ " " ++ sh.u(g)
136 case M.AcpiMadtLapicNmi{u, f, l}:
137 "lapicnmi " ++ sh.u(u) ++ " " ++ sh.u(f) ++ " " ++ sh.u(l)
138 case M.AcpiMadtLapicOverride{a}:
139 "override " ++ sh.w(a)
140 case M.AcpiMadtX2apic{x, f, u}:
141 "x2apic " ++ sh.u(x) ++ " " ++ sh.u(f) ++ " " ++ sh.u(u)
142 case M.AcpiMadtX2apicNmi{f, u, l}:
143 "x2nmi " ++ sh.u(f) ++ " " ++ sh.u(u) ++ " " ++ sh.u(l)
144 case M.AcpiMadtGicc{ci, u, f, pv, pg, vg, M.AcpiGiccAddrs{pk, b, gv, gh, gr}, mp, ec, sp, tr}:
145 "gicc " ++ sh.u(ci) ++ " " ++ sh.u(u) ++ " " ++ sh.u(f) ++ " " ++ sh.u(pv) ++ " " ++ sh.u(pg) ++ " " ++ sh.u(vg) ++ " " ++ sh.w(pk) ++ " " ++ sh.w(b) ++ " " ++ sh.w(gv) ++ " " ++ sh.w(gh) ++ " " ++ sh.w(gr) ++ " " ++ sh.w(mp) ++ " " ++ sh.u(ec) ++ " " ++ sh.u(sp) ++ " " ++ sh.u(tr)
146 case M.AcpiMadtGicd{i, b, v}:
147 "gicd " ++ sh.u(i) ++ " " ++ sh.w(b) ++ " " ++ sh.u(v)
148 case M.AcpiMadtGicMsi{i, b, f, c, s}:
149 "gicmsi " ++ sh.u(i) ++ " " ++ sh.w(b) ++ " " ++ sh.u(f) ++ " " ++ sh.u(c) ++ " " ++ sh.u(s)
150 case M.AcpiMadtGicr{b, l}:
151 "gicr " ++ sh.w(b) ++ " " ++ sh.u(l)
152 case M.AcpiMadtGicIts{i, b}:
153 "gicits " ++ sh.u(i) ++ " " ++ sh.w(b)
154 case M.AcpiMadtWakeup{v, m}:
155 "wakeup " ++ sh.u(v) ++ " " ++ sh.w(m)
156 case M.AcpiMadtOther{k, d}:
157 "other " ++ sh.u(k) ++ " " ++ sh.x(d)
158
159def sh.madt.es(es: List<&2, M.AcpiMadtEntry>) -> List<&2, String>:
160 match es:
161 case Nil{}:
162 Nil{}
163 case Con{h, t}:
164 Con{AcpiShow.madt_entry(h), sh.madt.es(t)}
165
166def AcpiShow.madt(m: M.AcpiMadt) -> String:
167 match m:
168 case M.AcpiMadt{h, a, f, es}:
169 "MADT " ++ sh.u(a) ++ " " ++ sh.u(f) ++ " [" ++ sh.list(sh.madt.es(es), "; ") ++ "]"
170
171def sh.fadt.core(c: F.AcpiFadtCore) -> String:
172 match c:
173 case F.AcpiFadtCore{fc, d, im, pp, sci, smi, en, dis, s4, ps, F.AcpiFadtBlocks{e1a, e1b, c1a, c1b, c2, tm, g0, g1}, F.AcpiFadtLens{le, lc, l2, lt, lg0, lg1, gb}, cst, p2, p3, fs, fst, doff, dw, da, ma, ce, ia, fl}:
174 sh.list([sh.u(fc), sh.u(d), sh.u(im), sh.u(pp), sh.u(sci), sh.u(smi), sh.u(en), sh.u(dis), sh.u(s4), sh.u(ps), sh.u(e1a), sh.u(e1b), sh.u(c1a), sh.u(c1b), sh.u(c2), sh.u(tm), sh.u(g0), sh.u(g1), sh.u(le), sh.u(lc), sh.u(l2), sh.u(lt), sh.u(lg0), sh.u(lg1), sh.u(gb), sh.u(cst), sh.u(p2), sh.u(p3), sh.u(fs), sh.u(fst), sh.u(doff), sh.u(dw), sh.u(da), sh.u(ma), sh.u(ce), sh.u(ia), sh.u(fl)], ",")
175
176def sh.fadt.ext(m: Maybe<&2, F.AcpiFadtExt>) -> String:
177 match m:
178 case None{}:
179 "none"
180 case Some{F.AcpiFadtExt{rr, rv, ab, mv, xfc, xd, F.AcpiFadtX{e1a, e1b, c1a, c1b, c2, tm, g0, g1}}}:
181 sh.list([AcpiShow.gas(rr), sh.u(rv), sh.u(ab), sh.u(mv), sh.w(xfc), sh.w(xd), AcpiShow.gas(e1a), AcpiShow.gas(e1b), AcpiShow.gas(c1a), AcpiShow.gas(c1b), AcpiShow.gas(c2), AcpiShow.gas(tm), AcpiShow.gas(g0), AcpiShow.gas(g1)], ",")
182
183def sh.fadt.sleep(m: Maybe<&2, F.AcpiFadtSleep>) -> String:
184 match m:
185 case None{}:
186 "none"
187 case Some{F.AcpiFadtSleep{c, s}}:
188 AcpiShow.gas(c) ++ "," ++ AcpiShow.gas(s)
189
190def sh.fadt.hyp(m: Maybe<&2, W.W64>) -> String:
191 match m:
192 case None{}:
193 "none"
194 case Some{v}:
195 sh.w(v)
196
197def AcpiShow.fadt(+f: F.AcpiFadt) -> String:
198 match f:
199 case F.AcpiFadt{h, c, x, s, v}:
200 "FADT " ++ sh.fadt.core(c) ++ " ext " ++ sh.fadt.ext(x) ++ " sleep " ++ sh.fadt.sleep(s) ++ " hyp " ++ sh.fadt.hyp(v) ++ " dsdt " ++ sh.w(F.AcpiFadt.dsdt_address(f)) ++ " facs " ++ sh.w(F.AcpiFadt.facs_address(f)) ++ " pm1a " ++ AcpiShow.gas(F.AcpiFadt.block(f, F.AcpiFadtPm1aEvt{}))
201
202def AcpiShow.facs(f: FS.AcpiFacs) -> String:
203 match f:
204 case FS.AcpiFacs{l, hs, wv, gl, fl, xw, v, of}:
205 "FACS " ++ sh.list([sh.u(l), sh.u(hs), sh.u(wv), sh.u(gl), sh.u(fl), sh.w(xw), sh.u(v), sh.u(of)], " ")
206
207def AcpiShow.hpet(t: Hp.AcpiHpet) -> String:
208 match t:
209 case Hp.AcpiHpet{h, id, g, n, m, p}:
210 "HPET " ++ sh.u(id) ++ " " ++ AcpiShow.gas(g) ++ " " ++ sh.u(n) ++ " " ++ sh.u(m) ++ " " ++ sh.u(p)
211
212def sh.mcfg.es(es: List<&2, Mc.AcpiMcfgEntry>) -> List<&2, String>:
213 match es:
214 case Nil{}:
215 Nil{}
216 case Con{Mc.AcpiMcfgEntry{b, s, lo, hi}, t}:
217 Con{sh.w(b) ++ " " ++ sh.u(s) ++ " " ++ sh.u(lo) ++ " " ++ sh.u(hi), sh.mcfg.es(t)}
218
219def AcpiShow.mcfg(m: Mc.AcpiMcfg) -> String:
220 match m:
221 case Mc.AcpiMcfg{h, es}:
222 "MCFG [" ++ sh.list(sh.mcfg.es(es), "; ") ++ "]"
223
224def AcpiShow.srat_entry(e: Sr.AcpiSratEntry) -> String:
225 match e:
226 case Sr.AcpiSratLapic{d, a, f, s, c}:
227 "lapic " ++ sh.u(d) ++ " " ++ sh.u(a) ++ " " ++ sh.u(f) ++ " " ++ sh.u(s) ++ " " ++ sh.u(c)
228 case Sr.AcpiSratMemory{d, b, l, f}:
229 "mem " ++ sh.u(d) ++ " " ++ sh.w(b) ++ " " ++ sh.w(l) ++ " " ++ sh.u(f)
230 case Sr.AcpiSratX2apic{d, x, f, c}:
231 "x2apic " ++ sh.u(d) ++ " " ++ sh.u(x) ++ " " ++ sh.u(f) ++ " " ++ sh.u(c)
232 case Sr.AcpiSratGicc{d, u, f, c}:
233 "gicc " ++ sh.u(d) ++ " " ++ sh.u(u) ++ " " ++ sh.u(f) ++ " " ++ sh.u(c)
234 case Sr.AcpiSratGicIts{d, i}:
235 "its " ++ sh.u(d) ++ " " ++ sh.u(i)
236 case Sr.AcpiSratGeneric{k, ht, d, hd, f}:
237 "gen " ++ sh.u(k) ++ " " ++ sh.u(ht) ++ " " ++ sh.u(d) ++ " " ++ sh.x(hd) ++ " " ++ sh.u(f)
238 case Sr.AcpiSratOther{k, d}:
239 "other " ++ sh.u(k) ++ " " ++ sh.x(d)
240
241def sh.srat.es(es: List<&2, Sr.AcpiSratEntry>) -> List<&2, String>:
242 match es:
243 case Nil{}:
244 Nil{}
245 case Con{h, t}:
246 Con{AcpiShow.srat_entry(h), sh.srat.es(t)}
247
248def AcpiShow.srat(s: Sr.AcpiSrat) -> String:
249 match s:
250 case Sr.AcpiSrat{h, es}:
251 "SRAT [" ++ sh.list(sh.srat.es(es), "; ") ++ "]"
252
253def AcpiShow.slit(s: Sl.AcpiSlit) -> String:
254 match s:
255 case Sl.AcpiSlit{h, n, m}:
256 "SLIT " ++ sh.n(n) ++ " " ++ sh.x(m)
257
258def AcpiShow.bgrt(t: Bg.AcpiBgrt) -> String:
259 match t:
260 case Bg.AcpiBgrt{h, v, st, it, a, x, y}:
261 "BGRT " ++ sh.u(v) ++ " " ++ sh.u(st) ++ " " ++ sh.u(it) ++ " " ++ sh.w(a) ++ " " ++ sh.u(x) ++ " " ++ sh.u(y)
262
263def AcpiShow.aml(t: D.AcpiAml) -> String:
264 match t:
265 case D.AcpiAml{h, a}:
266 "AML " ++ sh.n(B.Octets.len(a))
267
268# a table read through a registry: its header, then its parser's dump
269def AcpiShow.table(~X: Data, t: R.AcpiTable<X>) -> String:
270 match t:
271 case R.AcpiTRsdt{a}:
272 AcpiShow.sdt_list(a)
273 case R.AcpiTXsdt{a}:
274 AcpiShow.sdt_list(a)
275 case R.AcpiTMadt{a}:
276 AcpiShow.madt(a)
277 case R.AcpiTFadt{a}:
278 AcpiShow.fadt(a)
279 case R.AcpiTHpet{a}:
280 AcpiShow.hpet(a)
281 case R.AcpiTMcfg{a}:
282 AcpiShow.mcfg(a)
283 case R.AcpiTSrat{a}:
284 AcpiShow.srat(a)
285 case R.AcpiTSlit{a}:
286 AcpiShow.slit(a)
287 case R.AcpiTBgrt{a}:
288 AcpiShow.bgrt(a)
289 case R.AcpiTAml{a}:
290 AcpiShow.aml(a)
291 case R.AcpiTRaw{H.AcpiSdt{h, b}}:
292 "RAW " ++ sh.n(B.Octets.len(b))
293 case R.AcpiTExt{tag, x}:
294 "EXT " ++ sh.u(tag)
295
296def AcpiShow.result(~X: Data, r: Result<&2, &2, E.AcpiError, R.AcpiTable<X>>) -> String:
297 match r:
298 case Done{t}:
299 AcpiShow.table(~X, t)
300 case Fail{e}:
301 AcpiShow.error(e)