4b3a5c696c07c6a2824d1aae87fca4c8f167e722
[akaros.git] / user / vmm / biostables.c
1 /* Copyright (c) 2017 Google Inc.
2  * See LICENSE for details.
3  *
4  * ACPI setup. */
5
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <sys/fcntl.h>
9 #include <sys/mman.h>
10 #include <ros/arch/mmu.h>
11 #include <vmm/util.h>
12 #include <vmm/vmm.h>
13
14 #include <vmm/acpi/acpi.h>
15 #include <vmm/acpi/vmm_simple_dsdt.h>
16
17 /* By 1999, you could just scan the hardware
18  * and work it out. But 2005, that was no longer possible. How sad.
19  * so we have to fake acpi to make it all work.
20  * This will be copied to memory at 0xe0000, so the kernel can find it.
21  */
22
23 /* assume they're all 256 bytes long just to make it easy.
24  * Just have pointers that point to aligned things.
25  */
26
27 struct acpi_table_rsdp rsdp = {
28         .signature = ACPI_SIG_RSDP,
29         .oem_id = "AKAROS",
30         .revision = 2,
31         .length = 36,
32 };
33
34 struct acpi_table_xsdt xsdt = {
35         .header = {
36                 .signature = ACPI_SIG_DSDT,
37                 .revision = 2,
38                 .oem_id = "AKAROS",
39                 .oem_table_id = "ALPHABET",
40                 .oem_revision = 0,
41                 .asl_compiler_id = "RON ",
42                 .asl_compiler_revision = 0,
43         },
44 };
45 struct acpi_table_fadt fadt = {
46         .header = {
47                 .signature = ACPI_SIG_FADT,
48                 .revision = 2,
49                 .oem_id = "AKAROS",
50                 .oem_table_id = "ALPHABET",
51                 .oem_revision = 0,
52                 .asl_compiler_id = "RON ",
53                 .asl_compiler_revision = 0,
54         },
55 };
56
57
58 /* This has to be dropped into memory, then the other crap just follows it.
59  */
60 struct acpi_table_madt madt = {
61         .header = {
62                 .signature = ACPI_SIG_MADT,
63                 .revision = 2,
64                 .oem_id = "AKAROS",
65                 .oem_table_id = "ALPHABET",
66                 .oem_revision = 0,
67                 .asl_compiler_id = "RON ",
68                 .asl_compiler_revision = 0,
69         },
70
71         .address = APIC_GPA,
72         .flags = 0,
73 };
74
75 struct acpi_madt_io_apic
76         Apic1 = {.header = {.type = ACPI_MADT_TYPE_IO_APIC,
77                  .length = sizeof(struct acpi_madt_io_apic)},
78                  .id = 0, .address = 0xfec00000, .global_irq_base = 0};
79
80 struct acpi_madt_interrupt_override isor[] = {
81         /* From the ACPI Specification Version 6.1: For example, if your machine
82          * has the ISA Programmable Interrupt Timer (PIT) connected to ISA IRQ
83          * 0, but in APIC mode, it is connected to I/O APIC interrupt input 2,
84          * then you would need an Interrupt Source Override where the source
85          * entry is ‘0’ and the Global System Interrupt is ‘2.’ */
86 };
87
88 void lowmem(void)
89 {
90         asm volatile (".section .lowmem, \"aw\";"
91                       "low: ;"
92                       ".=0x1000;"
93                       ".align 0x100000;"
94                       ".previous;");
95 }
96
97 static uint8_t acpi_tb_checksum(uint8_t *buffer, uint32_t length)
98 {
99         uint8_t sum = 0;
100         uint8_t *end = buffer + length;
101
102         fprintf(stderr, "tbchecksum %p for %d", buffer, length);
103         while (buffer < end) {
104                 if (end - buffer < 2)
105                         fprintf(stderr, "%02x\n", sum);
106                 sum = (uint8_t)(sum + *(buffer++));
107         }
108         fprintf(stderr, " is %02x\n", sum);
109         return sum;
110 }
111
112 static void gencsum(uint8_t *target, void *data, int len)
113 {
114         uint8_t csum;
115
116         // blast target to zero so it does not get counted
117         // (it might be in the struct we checksum) And, yes, it is, goodness.
118         fprintf(stderr, "gencsum %p target %p source %d bytes\n", target, data,
119                 len);
120         *target = 0;
121         csum = acpi_tb_checksum((uint8_t *)data, len);
122         *target = ~csum + 1;
123         fprintf(stderr, "Cmoputed is %02x\n", *target);
124 }
125
126 /* Initialize the MADT structs for each local apic. */
127 static void *init_madt_local_apic(struct virtual_machine *vm, void *start)
128 {
129         struct acpi_madt_local_apic *apic = start;
130
131         for (int i = 0; i < vm->nr_gpcs; i++) {
132                 apic->header.type = ACPI_MADT_TYPE_LOCAL_APIC;
133                 apic->header.length = sizeof(struct acpi_madt_local_apic);
134                 apic->processor_id = i;
135                 apic->id = i;
136                 apic->lapic_flags = 1;
137                 apic = (void *)apic + sizeof(struct acpi_madt_local_apic);
138         }
139         return apic;
140 }
141
142 /* Initialize the MADT structs for each local x2apic. */
143 static void *init_madt_local_x2apic(struct virtual_machine *vm, void *start)
144 {
145         struct acpi_madt_local_x2apic *apic = start;
146
147         for (int i = 0; i < vm->nr_gpcs; i++) {
148                 apic->header.type = ACPI_MADT_TYPE_LOCAL_X2APIC;
149                 apic->header.length = sizeof(struct acpi_madt_local_x2apic);
150                 apic->local_apic_id = i;
151                 apic->uid = i;
152                 apic->lapic_flags = 1;
153                 apic = (void *)apic + sizeof(struct acpi_madt_local_x2apic);
154         }
155         return apic;
156 }
157
158 /* smbios reads the smbios into the e segment. By convention the
159  * e segment includes the f segment and is 128 kbytes. */
160 static int smbios(char *smbiostable, void *esegment)
161 {
162         int amt;
163
164         amt = cat(smbiostable, esegment, 128 * 1024);
165         if (amt < 0) {
166                 fprintf(stderr, "%s: %r\n", smbiostable);
167                 exit(1);
168         }
169
170         return amt;
171 }
172
173 void *setup_biostables(struct virtual_machine *vm,
174                        void *a, void *smbiostable)
175 {
176         struct acpi_table_rsdp *r;
177         struct acpi_table_fadt *f;
178         struct acpi_table_madt *m;
179         struct acpi_table_xsdt *x;
180         void *low1m;
181         uint8_t csum;
182
183
184         // The low 1m is so we can fill in bullshit like ACPI.
185         // And, sorry, due to the STUPID format of the RSDP for now we need the
186         // low 1M.
187         low1m = mmap((int*)4096, MiB-4096, PROT_READ | PROT_WRITE,
188                      MAP_POPULATE | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
189         if (low1m != (void *)4096) {
190                 perror("Unable to mmap low 1m");
191                 exit(1);
192         }
193
194         /* As I understood it, the spec was that SMBIOS
195          * tables live at f0000. We've been finding that
196          * they can have pointers to exxxx. So, for now,
197          * we assume you will take a 128K snapshot of flash
198          * and we'll just splat the whole mess in at
199          * 0xe0000. We can get more sophisticated about
200          * this later if needed. TODO: parse the table,
201          * and make sure that ACPI doesn't trash it.
202          * Although you'll know instantly if that happens
203          * as you'll get dmidecode errors. But it still needs
204          * to be better. */
205         if (smbiostable) {
206                 fprintf(stderr, "Using SMBIOS table %s\n", smbiostable);
207                 smbios(smbiostable, (void *)0xe0000);
208         }
209
210         r = a;
211         fprintf(stderr, "install rsdp to %p\n", r);
212         *r = rsdp;
213         a += sizeof(*r);
214         r->xsdt_physical_address = (uint64_t)a;
215         gencsum(&r->checksum, r, ACPI_RSDP_CHECKSUM_LENGTH);
216         csum = acpi_tb_checksum((uint8_t *) r, ACPI_RSDP_CHECKSUM_LENGTH);
217         if (csum != 0) {
218                 fprintf(stderr, "RSDP has bad checksum; summed to %x\n", csum);
219                 exit(1);
220         }
221
222         /* Check extended checksum if table version >= 2 */
223         gencsum(&r->extended_checksum, r, ACPI_RSDP_XCHECKSUM_LENGTH);
224         if ((rsdp.revision >= 2) &&
225             (acpi_tb_checksum((uint8_t*)r, ACPI_RSDP_XCHECKSUM_LENGTH) != 0)) {
226                 fprintf(stderr, "RSDP has bad checksum v2\n");
227                 exit(1);
228         }
229
230         /* just leave a bunch of space for the xsdt. */
231         /* we need to zero the area since it has pointers. */
232         x = a;
233         a += sizeof(*x) + 8*sizeof(void *);
234         memset(x, 0, a - (void *)x);
235         fprintf(stderr, "install xsdt to %p\n", x);
236         *x = xsdt;
237         x->table_offset_entry[0] = 0;
238         x->table_offset_entry[1] = 0;
239         x->header.length = a - (void *)x;
240
241         f = a;
242         fprintf(stderr, "install fadt to %p\n", f);
243         *f = fadt;
244         x->table_offset_entry[0] = (uint64_t)f; // fadt MUST be first in xsdt!
245         a += sizeof(*f);
246         f->header.length = a - (void *)f;
247
248         f->Xdsdt = (uint64_t) a;
249         fprintf(stderr, "install dsdt to %p\n", a);
250         memcpy(a, &DSDT_DSDTTBL_Header, 36);
251         a += 36;
252
253         gencsum(&f->header.checksum, f, f->header.length);
254         if (acpi_tb_checksum((uint8_t *)f, f->header.length) != 0) {
255                 fprintf(stderr, "fadt has bad checksum v2\n");
256                 exit(1);
257         }
258
259         m = a;
260         *m = madt;
261         x->table_offset_entry[3] = (uint64_t) m;
262         a += sizeof(*m);
263         fprintf(stderr, "install madt to %p\n", m);
264
265         a = init_madt_local_apic(vm, a);
266
267         memmove(a, &Apic1, sizeof(Apic1));
268         a += sizeof(Apic1);
269
270         a = init_madt_local_x2apic(vm, a);
271
272         memmove(a, &isor, sizeof(isor));
273         a += sizeof(isor);
274         m->header.length = a - (void *)m;
275
276         gencsum(&m->header.checksum, m, m->header.length);
277         if (acpi_tb_checksum((uint8_t *) m, m->header.length) != 0) {
278                 fprintf(stderr, "madt has bad checksum v2\n");
279                 exit(1);
280         }
281
282         gencsum(&x->header.checksum, x, x->header.length);
283         csum = acpi_tb_checksum((uint8_t *) x, x->header.length);
284         if (csum != 0) {
285                 fprintf(stderr, "XSDT has bad checksum; summed to %x\n", csum);
286                 exit(1);
287         }
288
289         fprintf(stderr, "allchecksums ok\n");
290
291         a = (void *)(((unsigned long)a + 0xfff) & ~0xfff);
292
293         return a;
294 }