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