source: trunk/hal/x86_64/core/hal_init.c @ 164

Last change on this file since 164 was 164, checked in by max@…, 5 years ago

we're gonna use an array of TSSs

File size: 11.3 KB
Line 
1/*
2 * hal_init.c - C initialization procedure for x86.
3 *
4 * Copyright (c) 2017 Maxime Villard
5 *
6 * This file is part of ALMOS-MKH.
7 *
8 * ALMOS-MKH is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2.0 of the License.
11 *
12 * ALMOS-MKH is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with ALMOS-MKH.; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include <hal_types.h>
23#include <hal_boot.h>
24#include <hal_multiboot.h>
25#include <hal_segmentation.h>
26#include <hal_acpi.h>
27#include <hal_apic.h>
28#include <hal_internal.h>
29#include <hal_remote.h>
30#include <hal_irqmask.h>
31
32#include <memcpy.h>
33#include <thread.h>
34#include <string.h>
35#include <process.h>
36#include <printk.h>
37#include <vmm.h>
38#include <core.h>
39#include <cluster.h>
40#include <chdev.h>
41
42#include <boot_info.h>
43
44void kernel_init(boot_info_t *info);
45
46static void gdt_create();
47static void idt_create();
48void cpu_attach();
49
50size_t mytest __in_kdata = 0;
51
52struct multiboot_info mb_info __in_kdata;
53char mb_loader_name[PAGE_SIZE] __in_kdata;
54uint8_t mb_mmap[PAGE_SIZE] __in_kdata;
55
56/* -------------------------------------------------------------------------- */
57
58static void
59dump_memmap()
60{
61        size_t mmap_length = mb_info.mi_mmap_length;
62        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
63        size_t i;
64
65        if (!(mb_info.mi_flags & MULTIBOOT_INFO_HAS_MMAP))
66                x86_panic("No mmap");
67
68        i = 0;
69        while (i < mmap_length) {
70                struct multiboot_mmap *mm;
71
72                mm = (struct multiboot_mmap *)(mmap_addr + i);
73
74                x86_printf("-> [%Z, %Z] %s\n", mm->mm_base_addr,
75                    mm->mm_base_addr + mm->mm_length,
76                    (mm->mm_type == 1) ? "ram" : "rsv" );
77
78                i += mm->mm_size + 4;
79        }
80}
81
82/* -------------------------------------------------------------------------- */
83
84static void init_bootinfo_icu(boot_device_t *dev)
85{
86        extern uint32_t hwi_baseidx;
87        extern uint32_t wti_baseidx;
88        extern uint32_t pti_baseidx;
89        extern size_t ioapic_pins;
90
91        memset(dev, 0, sizeof(boot_device_t));
92
93        dev->base = 0;
94        dev->type = (DEV_FUNC_ICU << 16) | IMPL_ICU_XCU;
95        dev->channels = 1;
96
97#if NOTYET
98        /*
99         * Give 20% of the pins to HWI, 80% to WTI.
100         */
101        dev->param0 = (ioapic_pins * 20) / 100;  /* hwi_nr */
102        dev->param1 = ioapic_pins - dev->param0; /* wti_nr */
103#else
104        dev->param0 = 1; /* hwi_nr */
105        dev->param1 = 1; /* wti_nr */
106#endif
107
108        /*
109         * We always set 1 for pti_nr. On x86, timer interrupts are handled by
110         * LAPIC, which is per-cpu and not global. Therefore, we always have one
111         * timer for each CPU, and its IRQ number is faked to 0.
112         */
113        dev->param2 = 1; /* pti_nr */
114
115        dev->param3 = 0;
116
117        /* Set the base idx for the XCU driver */
118        hwi_baseidx = 0;
119        wti_baseidx = dev->param0;
120        pti_baseidx = 0xFFFFFFFF;
121
122#ifdef NOTYET
123    uint32_t    irqs;                 /*! number of input IRQs                              */
124    boot_irq_t  irq[32];              /*! array of input IRQS (PIC and ICU only)            */
125#endif
126}
127
128static size_t init_bootinfo_pages_nr()
129{
130        size_t mmap_length = mb_info.mi_mmap_length;
131        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
132        paddr_t maxpa, pa;
133        size_t i;
134
135        i = 0;
136        maxpa = 0;
137        while (i < mmap_length) {
138                struct multiboot_mmap *mm;
139
140                mm = (struct multiboot_mmap *)(mmap_addr + i);
141
142                if (mm->mm_type == 1) {
143                        pa = mm->mm_base_addr + mm->mm_length;
144                        if (pa > maxpa)
145                                maxpa = pa;
146                }
147
148                i += mm->mm_size + 4;
149        }
150
151        return (maxpa / PAGE_SIZE);
152}
153
154static size_t init_bootinfo_rsvd(boot_rsvd_t *rsvd)
155{
156        size_t mmap_length = mb_info.mi_mmap_length;
157        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
158        size_t i, rsvd_nr;
159
160        memset(rsvd, 0, sizeof(boot_rsvd_t) * CONFIG_PPM_MAX_RSVD);
161
162        i = 0, rsvd_nr = 0;
163        while (i < mmap_length) {
164                struct multiboot_mmap *mm;
165
166                mm = (struct multiboot_mmap *)(mmap_addr + i);
167
168                if (mm->mm_type != 1) {
169                        rsvd[rsvd_nr].first_page =
170                            rounddown(mm->mm_base_addr, PAGE_SIZE) / PAGE_SIZE;
171                        rsvd[rsvd_nr].npages =
172                            roundup(mm->mm_length, PAGE_SIZE) / PAGE_SIZE;
173                        rsvd_nr++;
174                        if (rsvd_nr == CONFIG_PPM_MAX_RSVD)
175                                x86_panic("too many memory holes");
176                }
177
178                i += mm->mm_size + 4;
179        }
180
181        return rsvd_nr;
182}
183
184static void init_bootinfo_core(boot_core_t *core)
185{
186        memset(core, 0, sizeof(boot_core_t));
187
188        core->gid = hal_lapic_gid();
189        core->lid = 0;
190        core->cxy = 0;
191}
192
193static void init_bootinfo_txt(boot_device_t *dev)
194{
195        memset(dev, 0, sizeof(boot_device_t));
196
197        dev->base = 0xB8000;
198        dev->type = (DEV_FUNC_TXT << 16) | IMPL_TXT_X86;
199        dev->channels = 1;
200        dev->param0 = 0;
201        dev->param1 = 0;
202        dev->param2 = 0;
203        dev->param3 = 0;
204
205#ifdef NOTYET
206    uint32_t    irqs;    /*! number of input IRQs                    */
207    boot_irq_t  irq[32]; /*! array of input IRQS (PIC and ICU only)  */
208#endif
209}
210
211static void init_bootinfo(boot_info_t *info)
212{
213        size_t offset;
214
215        extern uint64_t __kernel_data_start;
216        extern uint64_t __kernel_end;
217
218        memset(info, 0, sizeof(boot_info_t));
219
220        info->signature = 0;
221
222        info->paddr_width = 0;
223        info->x_width = 1;
224        info->y_width = 1;
225        info->x_size = 1;
226        info->y_size = 1;
227        info->io_cxy = 0;
228
229        info->ext_dev_nr = 1;
230        init_bootinfo_txt(&info->ext_dev[0]);
231
232        info->cxy = 0;
233        info->cores_nr = 1;
234        init_bootinfo_core(&info->core[0]);
235
236        info->rsvd_nr = init_bootinfo_rsvd((boot_rsvd_t *)&info->rsvd);
237
238        init_bootinfo_icu(&info->dev_icu);
239        /* TODO: dev_mmc */
240        /* TODO: dev_dma */
241
242        offset = hal_gpt_bootstrap_uniformize();
243        info->pages_offset = offset / PAGE_SIZE;
244        info->pages_nr = init_bootinfo_pages_nr();
245
246        info->kernel_code_start = (intptr_t)(KERNTEXTOFF - KERNBASE);
247        info->kernel_code_end = (intptr_t)(&__kernel_data_start - KERNBASE) - 1;
248        info->kernel_data_start = (intptr_t)(&__kernel_data_start - KERNBASE);
249        info->kernel_code_end = (intptr_t)(&__kernel_end - KERNBASE) - 1;
250}
251
252void init_x86_64(paddr_t firstpa)
253{
254        boot_info_t btinfo;
255
256        /* Initialize the serial port */
257        hal_com_init_early();
258
259        x86_printf("[+] init_x86_64 called\n");
260
261        /* Create the global structures */
262        gdt_create();
263        idt_create();
264
265        /* Attach cpu0 */
266        cpu_attach(0);
267        x86_printf("[+] cpu_attach called\n");
268
269        x86_printf("[+] bootloader: '%s'\n", mb_loader_name);
270
271        dump_memmap();
272        x86_printf("[+] dump finished\n");
273
274        hal_gpt_init(firstpa);
275        x86_printf("[+] hal_gpt_init called\n");
276
277        hal_acpi_init();
278        x86_printf("[+] hal_acpi_init called\n");
279
280        hal_gpt_bootstrap_reset();
281        x86_printf("[+] hal_gpt_bootstrap_reset called\n");
282
283        hal_apic_init();
284        x86_printf("[+] hal_apic_init called\n");
285
286        hal_tls_init_cpu0();
287        x86_printf("[+] hal_tls_init_cpu0 called\n");
288
289        x86_printf("-> mytest = %z\n", mytest);
290        void *hoho = &init_x86_64;
291        xptr_t myptr = XPTR(0, &mytest);
292
293        hal_remote_spt(myptr, hoho);
294        x86_printf("-> mytest = %Z\n", hal_remote_lpt(myptr));
295
296        init_bootinfo(&btinfo);
297
298        reg_t dummy;
299        hal_enable_irq(&dummy);
300
301        while (1);
302
303        kernel_init(&btinfo);
304
305        x86_printf("[+] kernel_init called\n");
306
307        while (1);
308
309//      void x86_stop();
310//      x86_stop();
311}
312
313/* -------------------------------------------------------------------------- */
314
315uint8_t gdtstore[PAGE_SIZE] __in_kdata;
316uint8_t idtstore[PAGE_SIZE] __in_kdata;
317struct tss cpu_tss[CONFIG_MAX_LOCAL_CORES] __in_kdata;
318uint8_t cpu_intr_stack[CONFIG_MAX_LOCAL_CORES][STKSIZE] __in_kdata;
319uint8_t cpu_dbfl_stack[CONFIG_MAX_LOCAL_CORES][STKSIZE] __in_kdata;
320uint8_t cpu_nmfl_stack[CONFIG_MAX_LOCAL_CORES][STKSIZE] __in_kdata;
321
322static void
323setregion(struct region_descriptor *rd, void *base, uint16_t limit)
324{
325        rd->rd_limit = limit;
326        rd->rd_base = (uint64_t)base;
327}
328
329/* -------------------------------------------------------------------------- */
330
331static void
332gdt_set_memseg(struct gdt_memseg *sd, void *base, size_t limit,
333        int type, int dpl, int gran, int is64)
334{
335        sd->sd_lolimit = (unsigned)limit;
336        sd->sd_lobase = (unsigned long)base;
337        sd->sd_type = type;
338        sd->sd_dpl = dpl;
339        sd->sd_p = 1;
340        sd->sd_hilimit = (unsigned)limit >> 16;
341        sd->sd_avl = 0;
342        sd->sd_long = is64;
343        sd->sd_def32 = 0;
344        sd->sd_gran = gran;
345        sd->sd_hibase = (unsigned long)base >> 24;
346}
347
348static void
349gdt_set_sysseg(struct gdt_sysseg *sd, void *base, size_t limit,
350        int type, int dpl, int gran)
351{
352        memset(sd, 0, sizeof *sd);
353        sd->sd_lolimit = (unsigned)limit;
354        sd->sd_lobase = (uint64_t)base;
355        sd->sd_type = type;
356        sd->sd_dpl = dpl;
357        sd->sd_p = 1;
358        sd->sd_hilimit = (unsigned)limit >> 16;
359        sd->sd_gran = gran;
360        sd->sd_hibase = (uint64_t)base >> 24;
361}
362
363static void gdt_create()
364{
365        memset(&gdtstore, 0, PAGE_SIZE);
366
367        /* Flat segments */
368        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_KCODE_SEL), 0,
369            0xfffff, SDT_MEMERA, SEL_KPL, 1, 1);
370        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_KDATA_SEL), 0,
371            0xfffff, SDT_MEMRWA, SEL_KPL, 1, 1);
372        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UCODE_SEL), 0,
373            0xfffff, SDT_MEMERA, SEL_UPL, 1, 1);
374        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UDATA_SEL), 0,
375            0xfffff, SDT_MEMRWA, SEL_UPL, 1, 1);
376}
377
378void cpu_load_gdt()
379{
380        struct region_descriptor region;
381        setregion(&region, &gdtstore, PAGE_SIZE - 1);
382        lgdt(&region);
383}
384
385/* -------------------------------------------------------------------------- */
386
387static void
388idt_set_seg(struct idt_seg *seg, void *func, int ist, int type, int dpl, int sel)
389{
390        seg->gd_looffset = (uint64_t)func & 0xffff;
391        seg->gd_selector = sel;
392        seg->gd_ist = ist;
393        seg->gd_type = type;
394        seg->gd_dpl = dpl;
395        seg->gd_p = 1;
396        seg->gd_hioffset = (uint64_t)func >> 16;
397        seg->gd_zero = 0;
398        seg->gd_xx1 = 0;
399        seg->gd_xx2 = 0;
400        seg->gd_xx3 = 0;
401}
402
403static void idt_create()
404{
405        extern uint64_t x86_traps[], x86_intrs[], x86_rsvd;
406        struct idt_seg *idt;
407        size_t i;
408
409        idt = (struct idt_seg *)&idtstore;
410
411        /* First, put a dead entry */
412        for (i = 0; i < NIDT; i++) {
413                idt_set_seg(&idt[i], (void *)&x86_rsvd, 0,
414                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
415        }
416
417        /* General exceptions */
418        for (i = CPUVEC_MIN; i < CPUVEC_MAX; i++) {
419                idt_set_seg(&idt[i], (void *)x86_traps[i - CPUVEC_MIN], 0,
420                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
421        }
422
423        /* Dynamically configured interrupts */
424        for (i = DYNVEC_MIN; i < DYNVEC_MAX; i++) {
425                idt_set_seg(&idt[i], (void *)x86_intrs[i - DYNVEC_MIN], 0,
426                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
427        }
428}
429
430void cpu_load_idt()
431{
432        struct region_descriptor region;
433        setregion(&region, &idtstore, PAGE_SIZE - 1);
434        lidt(&region);
435}
436
437/* -------------------------------------------------------------------------- */
438
439/*
440 * The gdt bitmap must be per-cluster.
441 */
442int tss_alloc(struct tss *tss, size_t lid)
443{
444        int slot;
445
446        /* Once we have proper SMP support, we will change that */
447        slot = GDT_CPUTSS_SEL + lid;
448
449        gdt_set_sysseg(GDT_ADDR_SYS(gdtstore, slot), tss,
450            sizeof(*tss) - 1, SDT_SYS386TSS, SEL_KPL, 0);
451
452        return GDT_DYNAM_SEL(slot, SEL_KPL);
453}
454
455void cpu_create_tss(size_t lid)
456{
457        struct tss *tss = &cpu_tss[lid];
458        int sel;
459
460        /* Create the tss */
461        memset(tss, 0, sizeof(*tss));
462
463        /* tss->tss_rsp0 */
464        tss->tss_ist[0] = (uint64_t)cpu_intr_stack[lid] + STKSIZE;
465        tss->tss_ist[1] = (uint64_t)cpu_dbfl_stack[lid] + STKSIZE;
466        tss->tss_ist[2] = (uint64_t)cpu_nmfl_stack[lid] + STKSIZE;
467        tss->tss_iobase = IOMAP_INVALOFF << 16;
468        sel = tss_alloc(tss, lid);
469
470        /* Load it */
471        ltr(sel);
472}
473
474/* -------------------------------------------------------------------------- */
475
476void cpu_attach(size_t lid)
477{
478        cpu_load_gdt();
479        cpu_load_idt();
480        cpu_create_tss(lid);
481}
482
Note: See TracBrowser for help on using the repository browser.