limine/test/stivale2.c

282 lines
12 KiB
C
Raw Normal View History

#include <stivale2.h>
#include <stdint.h>
#include <e9print.h>
#include <stddef.h>
2020-10-25 14:41:13 +03:00
typedef uint8_t stack[4096];
2021-08-17 01:37:24 +03:00
static stack stacks[64] = {0};
void stivale2_main(struct stivale2_struct *info);
struct stivale2_header_tag_slide_hhdm slide_hhdm = {
.tag = {
.identifier = STIVALE2_HEADER_TAG_SLIDE_HHDM_ID,
.next = 0
},
.flags = 0,
.alignment = 0x10000000
};
2021-04-07 03:10:28 +03:00
struct stivale2_header_tag_terminal terminal_request = {
.tag = {
.identifier = STIVALE2_HEADER_TAG_TERMINAL_ID,
.next = (uint64_t)&slide_hhdm
2021-04-07 03:10:28 +03:00
},
.flags = 0
};
struct stivale2_header_tag_smp smp_request = {
.tag = {
.identifier = STIVALE2_HEADER_TAG_SMP_ID,
2021-04-07 03:10:28 +03:00
.next = (uint64_t)&terminal_request
},
.flags = 0
};
struct stivale2_tag unmap_null_request = {
.identifier = STIVALE2_HEADER_TAG_UNMAP_NULL_ID,
.next = (uint64_t)&smp_request
};
2021-08-17 01:37:24 +03:00
struct stivale2_header_tag_any_video any_video_request = {
.tag = {
2021-08-17 01:37:24 +03:00
.identifier = STIVALE2_HEADER_TAG_ANY_VIDEO_ID,
.next = (uint64_t)&unmap_null_request
},
2021-08-17 01:37:24 +03:00
.preference = 0
};
__attribute__((section(".stivale2hdr"), used))
struct stivale2_header header2 = {
.entry_point = (uint64_t)stivale2_main,
2020-10-25 14:41:13 +03:00
.stack = (uintptr_t)stacks[0] + sizeof(stack),
2021-11-10 09:40:57 +03:00
.flags = (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4),
2021-08-17 01:37:24 +03:00
.tags = (uint64_t)&any_video_request
};
static volatile int cpu_up = 0;
static void ap_entry(struct stivale2_smp_info *s) {
2021-04-07 03:10:28 +03:00
e9_printf(" AP %d started", s->lapic_id);
cpu_up = 1;
2022-03-18 00:47:58 +03:00
for (;;) __asm__("hlt");
2020-10-25 14:41:13 +03:00
}
static void print_guid(struct stivale2_guid guid) {
e9_printf("\t\ta: %x", guid.a);
e9_printf("\t\tb: %x", guid.b);
e9_printf("\t\tc: %x", guid.c);
e9_puts("\t\td: [");
for (uint8_t i = 0; i < 8; i++) {
e9_printf("\t\t\t%x,", guid.d[i]);
}
e9_puts("\t\t]\n");
}
void stivale2_main(struct stivale2_struct *info) {
2021-04-07 03:10:28 +03:00
// Print the tags.
struct stivale2_tag *tag = (struct stivale2_tag *)info->tags;
while (tag != NULL) {
if (tag->identifier == STIVALE2_STRUCT_TAG_TERMINAL_ID) {
struct stivale2_struct_tag_terminal *t = (void *)tag;
stivale2_print = (void *)(uintptr_t)t->term_write;
}
tag = (void *)tag->next;
}
// Print stuff.
e9_puts("Stivale2 info passed to the kernel:");
e9_printf("Bootloader brand: %s", info->bootloader_brand);
e9_printf("Bootloader version: %s", info->bootloader_version);
// Print the tags.
2021-04-07 03:10:28 +03:00
tag = (struct stivale2_tag *)info->tags;
while (tag != NULL) {
switch (tag->identifier) {
case STIVALE2_STRUCT_TAG_CMDLINE_ID: {
struct stivale2_struct_tag_cmdline *c = (struct stivale2_struct_tag_cmdline *)tag;
e9_puts("Commandline tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tCmdline: %s", (char*)(c->cmdline));
break;
}
case STIVALE2_STRUCT_TAG_MEMMAP_ID: {
struct stivale2_struct_tag_memmap *m = (struct stivale2_struct_tag_memmap *)tag;
e9_puts("Memmap tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tEntries: %d", m->entries);
2021-07-07 06:54:40 +03:00
size_t total_mem = 0;
for (size_t i = 0; i < m->entries; i++) {
struct stivale2_mmap_entry me = m->memmap[i];
2021-05-23 00:11:18 +03:00
e9_printf("\t\t[%x+%x] %x", me.base, me.length, me.type);
2021-07-07 06:54:40 +03:00
if (m->memmap[i].type == 1) {
total_mem += m->memmap[i].length;
}
}
2021-07-07 06:54:40 +03:00
e9_printf("\tTotal usable memory: %d", total_mem);
break;
}
case STIVALE2_STRUCT_TAG_FRAMEBUFFER_ID: {
struct stivale2_struct_tag_framebuffer *f = (struct stivale2_struct_tag_framebuffer *)tag;
e9_puts("Framebuffer tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tAddress: %x", f->framebuffer_addr);
e9_printf("\tWidth: %d", f->framebuffer_width);
e9_printf("\tHeight: %d", f->framebuffer_height);
e9_printf("\tPitch: %d", f->framebuffer_pitch);
e9_printf("\tBPP: %d", f->framebuffer_bpp);
e9_printf("\tMemory model: %d", f->memory_model);
e9_printf("\tRed mask size: %d", f->red_mask_size);
e9_printf("\tRed mask size: %d", f->red_mask_shift);
e9_printf("\tGreen mask size: %d", f->green_mask_size);
e9_printf("\tGreen mask size: %d", f->green_mask_shift);
e9_printf("\tBlue mask size: %d", f->blue_mask_size);
e9_printf("\tBlue mask size: %d", f->blue_mask_shift);
break;
}
2021-08-17 01:58:02 +03:00
case STIVALE2_STRUCT_TAG_TEXTMODE_ID: {
struct stivale2_struct_tag_textmode *tm = (struct stivale2_struct_tag_textmode *)tag;
e9_puts("Textmode tag");
break;
}
case STIVALE2_STRUCT_TAG_EDID_ID: {
struct stivale2_struct_tag_edid *edid = (struct stivale2_struct_tag_edid *)tag;
e9_printf("EDID information at %x:", edid->edid_information);
2021-05-23 00:11:18 +03:00
e9_printf("\tSize: %d", edid->edid_size);
2021-04-07 03:51:56 +03:00
break;
}
case STIVALE2_STRUCT_TAG_FB_MTRR_ID: {
e9_puts("Framebuffer WC MTRR tag:");
2021-05-23 00:11:18 +03:00
e9_puts("\tFramebuffer WC MTRR enabled");
2021-04-07 03:10:28 +03:00
break;
}
case STIVALE2_STRUCT_TAG_TERMINAL_ID: {
struct stivale2_struct_tag_terminal *term = (struct stivale2_struct_tag_terminal *)tag;
e9_puts("Terminal tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tTerminal write entry point at: %x", term->term_write);
break;
}
case STIVALE2_STRUCT_TAG_MODULES_ID: {
struct stivale2_struct_tag_modules *m = (struct stivale2_struct_tag_modules *)tag;
e9_puts("Modules tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tCount: %d", m->module_count);
for (size_t i = 0; i < m->module_count; i++) {
struct stivale2_module me = m->modules[i];
2021-05-23 00:11:18 +03:00
e9_printf("\t\t[%x+%x] %s", me.begin, me.end, me.string);
}
break;
}
case STIVALE2_STRUCT_TAG_RSDP_ID: {
struct stivale2_struct_tag_rsdp *r = (struct stivale2_struct_tag_rsdp *)tag;
e9_puts("RSDP tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tRSDP: %x", r->rsdp);
break;
}
case STIVALE2_STRUCT_TAG_SMBIOS_ID: {
struct stivale2_struct_tag_smbios *r = (struct stivale2_struct_tag_smbios *)tag;
e9_puts("SMBIOS tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tFlags: %x", r->flags);
e9_printf("\tSMBIOS 32-bit entry point: %x", r->smbios_entry_32);
e9_printf("\tSMBIOS 64-bit entry point: %x", r->smbios_entry_64);
break;
}
case STIVALE2_STRUCT_TAG_EPOCH_ID: {
struct stivale2_struct_tag_epoch *e = (struct stivale2_struct_tag_epoch *)tag;
e9_puts("Epoch tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tEpoch: %x", e->epoch);
break;
}
case STIVALE2_STRUCT_TAG_FIRMWARE_ID: {
struct stivale2_struct_tag_firmware *f = (struct stivale2_struct_tag_firmware *)tag;
e9_puts("Firmware tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tFlags: %x", f->flags);
break;
}
case STIVALE2_STRUCT_TAG_EFI_SYSTEM_TABLE_ID: {
struct stivale2_struct_tag_efi_system_table *t = (struct stivale2_struct_tag_efi_system_table *)tag;
e9_printf("EFI system table at: %x", t->system_table);
break;
}
2021-03-28 16:46:59 +03:00
case STIVALE2_STRUCT_TAG_KERNEL_FILE_ID: {
struct stivale2_struct_tag_kernel_file *t = (struct stivale2_struct_tag_kernel_file *)tag;
e9_printf("Raw kernel file loaded at: %x", t->kernel_file);
break;
}
case STIVALE2_STRUCT_TAG_KERNEL_FILE_V2_ID: {
struct stivale2_struct_tag_kernel_file_v2 *t = (struct stivale2_struct_tag_kernel_file_v2 *)tag;
e9_puts("Kernel file V2 tag:");
e9_printf("\tkernel_file: %x", t->kernel_file);
e9_printf("\tkernel_size: %x", t->kernel_size);
break;
}
2021-03-28 17:20:23 +03:00
case STIVALE2_STRUCT_TAG_KERNEL_SLIDE_ID: {
struct stivale2_struct_tag_kernel_slide *t = (struct stivale2_struct_tag_kernel_slide *)tag;
e9_printf("Kernel slide: %x", t->kernel_slide);
break;
}
2021-07-15 17:20:29 +03:00
case STIVALE2_STRUCT_TAG_PMRS_ID: {
struct stivale2_struct_tag_pmrs *t = (struct stivale2_struct_tag_pmrs *)tag;
e9_puts("PMRs tag:");
e9_printf("\t%d ranges:", t->entries);
for (size_t i = 0; i < t->entries; i++) {
e9_printf("\t\tBase: %x Length: %x Perms: %x",
t->pmrs[i].base, t->pmrs[i].length, t->pmrs[i].permissions);
}
2021-07-15 18:16:55 +03:00
break;
2021-07-15 17:20:29 +03:00
}
case STIVALE2_STRUCT_TAG_HHDM_ID: {
struct stivale2_struct_tag_hhdm *t = (struct stivale2_struct_tag_hhdm *)tag;
e9_printf("Higher half direct map at: %x", t->addr);
break;
}
case STIVALE2_STRUCT_TAG_KERNEL_BASE_ADDRESS_ID: {
struct stivale2_struct_tag_kernel_base_address *t = (void *)tag;
e9_puts("Kernel base address:");
e9_printf("\tPhysical base address: %x", t->physical_base_address);
e9_printf("\tVirtual base address: %x", t->virtual_base_address);
break;
}
case STIVALE2_STRUCT_TAG_BOOT_VOLUME_ID: {
struct stivale2_struct_tag_boot_volume *t = (void *)tag;
e9_puts("Boot volume:");
e9_printf("\tGUID:");
print_guid(t->guid);
e9_printf("\tPartition GUID:");
print_guid(t->part_guid);
break;
}
case STIVALE2_STRUCT_TAG_SMP_ID: {
struct stivale2_struct_tag_smp *s = (struct stivale2_struct_tag_smp *)tag;
e9_puts("SMP tag:");
2021-05-23 00:11:18 +03:00
e9_printf("\tFlags: %x", s->flags);
e9_printf("\tBSP LAPIC ID: %d", s->bsp_lapic_id);
e9_printf("\tCPU Count: %d", s->cpu_count);
for (size_t i = 0; i < s->cpu_count; i++) {
2020-10-25 14:41:13 +03:00
struct stivale2_smp_info *in = &s->smp_info[i];
2021-05-23 00:11:18 +03:00
e9_printf("\t\tProcessor ID: %d", in->processor_id);
e9_printf("\t\tLAPIC ID: %d", in->lapic_id);
e9_printf("\t\tTarget Stack: %x", in->target_stack);
e9_printf("\t\tGOTO Address: %x", in->goto_address);
e9_printf("\t\tExtra Argument: %x", in->extra_argument);
2020-10-25 14:41:13 +03:00
if (in->lapic_id != s->bsp_lapic_id) {
in->target_stack = (uintptr_t)stacks[in->lapic_id] + sizeof(stack);
in->goto_address = (uintptr_t)ap_entry;
while (cpu_up == 0);
cpu_up = 0;
2020-10-25 14:41:13 +03:00
}
}
break;
}
default:
2021-04-07 03:10:28 +03:00
e9_printf("BUG: Unidentified tag %x", tag->identifier);
}
tag = (struct stivale2_tag *)tag->next;
}
// Enter our sublime pale slumber.
2022-03-18 00:47:58 +03:00
for (;;) __asm__("hlt");
}