diff --git a/Kernel/arch/amd64/bootstrap/multiboot/mb2_parse.cpp b/Kernel/arch/amd64/bootstrap/multiboot/mb2_parse.cpp index e85e20ad..5be7b2ee 100644 --- a/Kernel/arch/amd64/bootstrap/multiboot/mb2_parse.cpp +++ b/Kernel/arch/amd64/bootstrap/multiboot/mb2_parse.cpp @@ -24,10 +24,8 @@ void multiboot2_parse(BootInfo &mb2binfo, uintptr_t Magic, uintptr_t Info) { - auto InfoAddress = Info; - for (auto Tag = (struct multiboot_tag *)((uint8_t *)InfoAddress + 8); - ; - Tag = (struct multiboot_tag *)((multiboot_uint8_t *)Tag + ((Tag->size + 7) & ~7))) + auto infoAddr = Info; + for (auto Tag = (struct multiboot_tag *)((uint8_t *)infoAddr + 8);; Tag = (struct multiboot_tag *)((multiboot_uint8_t *)Tag + ((Tag->size + 7) & ~7))) { if (Tag->type == MULTIBOOT_TAG_TYPE_END) { @@ -39,17 +37,17 @@ void multiboot2_parse(BootInfo &mb2binfo, uintptr_t Magic, uintptr_t Info) { case MULTIBOOT_TAG_TYPE_CMDLINE: { - strncpy(mb2binfo.Kernel.CommandLine, - ((multiboot_tag_string *)Tag)->string, - strlen(((multiboot_tag_string *)Tag)->string)); + multiboot_tag_string *cmdline = (multiboot_tag_string *)Tag; + strncpy(mb2binfo.Kernel.CommandLine, cmdline->string, strlen(cmdline->string)); + debug("Kernel command line: %s", mb2binfo.Kernel.CommandLine); break; } case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME: { - strncpy(mb2binfo.Bootloader.Name, - ((multiboot_tag_string *)Tag)->string, - strlen(((multiboot_tag_string *)Tag)->string)); + multiboot_tag_string *blName = (multiboot_tag_string *)Tag; + strncpy(mb2binfo.Bootloader.Name, blName->string, strlen(blName->string)); + debug("Bootloader name: %s", mb2binfo.Bootloader.Name); break; } @@ -60,24 +58,29 @@ void multiboot2_parse(BootInfo &mb2binfo, uintptr_t Magic, uintptr_t Info) mb2binfo.Modules[module_count].Address = (void *)(uint64_t)module->mod_start; mb2binfo.Modules[module_count].Size = module->mod_end - module->mod_start; strncpy(mb2binfo.Modules[module_count].Path, "(null)", 6); - strncpy(mb2binfo.Modules[module_count].CommandLine, module->cmdline, - strlen(module->cmdline)); - debug("Module: %s", mb2binfo.Modules[module_count].Path); + strncpy(mb2binfo.Modules[module_count].CommandLine, module->cmdline, strlen(module->cmdline)); + + debug("Module: %s", mb2binfo.Modules[module_count].CommandLine); module_count++; break; } case MULTIBOOT_TAG_TYPE_BASIC_MEMINFO: { multiboot_tag_basic_meminfo *meminfo = (multiboot_tag_basic_meminfo *)Tag; + fixme("basic_meminfo->[mem_lower: %#x, mem_upper: %#x]", - meminfo->mem_lower, meminfo->mem_upper); + meminfo->mem_lower, + meminfo->mem_upper); break; } case MULTIBOOT_TAG_TYPE_BOOTDEV: { multiboot_tag_bootdev *bootdev = (multiboot_tag_bootdev *)Tag; + fixme("bootdev->[biosdev: %#x, slice: %#x, part: %#x]", - bootdev->biosdev, bootdev->slice, bootdev->part); + bootdev->biosdev, + bootdev->slice, + bootdev->part); break; } case MULTIBOOT_TAG_TYPE_MMAP: @@ -92,6 +95,7 @@ void multiboot2_parse(BootInfo &mb2binfo, uintptr_t Magic, uintptr_t Info) warn("Too many memory entries, skipping the rest..."); break; } + multiboot_mmap_entry entry = mmap->entries[i]; mb2binfo.Memory.Size += entry.len; switch (entry.type) @@ -127,6 +131,7 @@ void multiboot2_parse(BootInfo &mb2binfo, uintptr_t Magic, uintptr_t Info) mb2binfo.Memory.Entry[i].Type = Unknown; break; } + debug("Memory entry: [BaseAddress: %#x, Length: %#x, Type: %d]", mb2binfo.Memory.Entry[i].BaseAddress, mb2binfo.Memory.Entry[i].Length, @@ -137,54 +142,52 @@ void multiboot2_parse(BootInfo &mb2binfo, uintptr_t Magic, uintptr_t Info) case MULTIBOOT_TAG_TYPE_VBE: { multiboot_tag_vbe *vbe = (multiboot_tag_vbe *)Tag; + fixme("vbe->[vbe_mode: %#x, vbe_interface_seg: %#x, vbe_interface_off: %#x, vbe_interface_len: %#x]", - vbe->vbe_mode, vbe->vbe_interface_seg, vbe->vbe_interface_off, vbe->vbe_interface_len); + vbe->vbe_mode, + vbe->vbe_interface_seg, + vbe->vbe_interface_off, + vbe->vbe_interface_len); break; } case MULTIBOOT_TAG_TYPE_FRAMEBUFFER: { multiboot_tag_framebuffer *fb = (multiboot_tag_framebuffer *)Tag; - static int fb_count = 0; - mb2binfo.Framebuffer[fb_count].BaseAddress = (void *)fb->common.framebuffer_addr; - mb2binfo.Framebuffer[fb_count].Width = fb->common.framebuffer_width; - mb2binfo.Framebuffer[fb_count].Height = fb->common.framebuffer_height; - mb2binfo.Framebuffer[fb_count].Pitch = fb->common.framebuffer_pitch; - mb2binfo.Framebuffer[fb_count].BitsPerPixel = fb->common.framebuffer_bpp; + static int fbCount = 0; + mb2binfo.Framebuffer[fbCount].BaseAddress = (void *)fb->common.framebuffer_addr; + mb2binfo.Framebuffer[fbCount].Width = fb->common.framebuffer_width; + mb2binfo.Framebuffer[fbCount].Height = fb->common.framebuffer_height; + mb2binfo.Framebuffer[fbCount].Pitch = fb->common.framebuffer_pitch; + mb2binfo.Framebuffer[fbCount].BitsPerPixel = fb->common.framebuffer_bpp; switch (fb->common.framebuffer_type) { case MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED: - { - mb2binfo.Framebuffer[fb_count].Type = Indexed; + mb2binfo.Framebuffer[fbCount].Type = Indexed; break; - } case MULTIBOOT_FRAMEBUFFER_TYPE_RGB: - { - mb2binfo.Framebuffer[fb_count].Type = RGB; - mb2binfo.Framebuffer[fb_count].RedMaskSize = fb->framebuffer_red_mask_size; - mb2binfo.Framebuffer[fb_count].RedMaskShift = fb->framebuffer_red_field_position; - mb2binfo.Framebuffer[fb_count].GreenMaskSize = fb->framebuffer_green_mask_size; - mb2binfo.Framebuffer[fb_count].GreenMaskShift = fb->framebuffer_green_field_position; - mb2binfo.Framebuffer[fb_count].BlueMaskSize = fb->framebuffer_blue_mask_size; - mb2binfo.Framebuffer[fb_count].BlueMaskShift = fb->framebuffer_blue_field_position; + mb2binfo.Framebuffer[fbCount].Type = RGB; + mb2binfo.Framebuffer[fbCount].RedMaskSize = fb->framebuffer_red_mask_size; + mb2binfo.Framebuffer[fbCount].RedMaskShift = fb->framebuffer_red_field_position; + mb2binfo.Framebuffer[fbCount].GreenMaskSize = fb->framebuffer_green_mask_size; + mb2binfo.Framebuffer[fbCount].GreenMaskShift = fb->framebuffer_green_field_position; + mb2binfo.Framebuffer[fbCount].BlueMaskSize = fb->framebuffer_blue_mask_size; + mb2binfo.Framebuffer[fbCount].BlueMaskShift = fb->framebuffer_blue_field_position; break; - } case MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT: - { - mb2binfo.Framebuffer[fb_count].Type = EGA; + mb2binfo.Framebuffer[fbCount].Type = EGA; break; - } default: - { - mb2binfo.Framebuffer[fb_count].Type = Unknown_Framebuffer_Type; + mb2binfo.Framebuffer[fbCount].Type = Unknown_Framebuffer_Type; break; } - } - debug("Framebuffer %d: %dx%d %d bpp", fb_count, fb->common.framebuffer_width, fb->common.framebuffer_height, fb->common.framebuffer_bpp); - debug("More info:\nAddress: %p\nPitch: %d\nMemoryModel: %d\nRedMaskSize: %d\nRedMaskShift: %d\nGreenMaskSize: %d\nGreenMaskShift: %d\nBlueMaskSize: %d\nBlueMaskShift: %d", + + debug("fb %d: %dx%d %d bpp", fbCount, fb->common.framebuffer_width, fb->common.framebuffer_height, fb->common.framebuffer_bpp); + debug("More info: addr:%#lx pitch:%d mm:%d RMSize:%d RMShift:%d GMSize:%d GMShift:%d BMSize:%d BMShift:%d", fb->common.framebuffer_addr, fb->common.framebuffer_pitch, fb->common.framebuffer_type, - fb->framebuffer_red_mask_size, fb->framebuffer_red_field_position, fb->framebuffer_green_mask_size, - fb->framebuffer_green_field_position, fb->framebuffer_blue_mask_size, fb->framebuffer_blue_field_position); - fb_count++; + fb->framebuffer_red_mask_size, fb->framebuffer_red_field_position, + fb->framebuffer_green_mask_size, fb->framebuffer_green_field_position, + fb->framebuffer_blue_mask_size, fb->framebuffer_blue_field_position); + fbCount++; break; } case MULTIBOOT_TAG_TYPE_ELF_SECTIONS: @@ -194,73 +197,115 @@ void multiboot2_parse(BootInfo &mb2binfo, uintptr_t Magic, uintptr_t Info) mb2binfo.Kernel.Symbols.EntSize = elf->entsize; mb2binfo.Kernel.Symbols.Shndx = elf->shndx; mb2binfo.Kernel.Symbols.Sections = r_cst(uintptr_t, elf->sections); + + debug("elf_sections->[num: %d, entsize: %d, shndx: %d, sections: %#lx]", + elf->num, elf->entsize, elf->shndx, elf->sections); break; } case MULTIBOOT_TAG_TYPE_APM: { multiboot_tag_apm *apm = (multiboot_tag_apm *)Tag; - fixme("apm->[version: %d, cseg: %d, offset: %d, cseg_16: %d, dseg: %d, flags: %d, cseg_len: %d, cseg_16_len: %d, dseg_len: %d]", - apm->version, apm->cseg, apm->offset, apm->cseg_16, apm->dseg, apm->flags, apm->cseg_len, apm->cseg_16_len, apm->dseg_len); + + fixme("apm->[version:%d, cseg:%d, offset:%d, cseg_16:%d, dseg:%d, flags:%d, cseg_len:%d, cseg_16_len:%d, dseg_len:%d]", + apm->version, apm->cseg, apm->offset, apm->cseg_16, apm->dseg, + apm->flags, apm->cseg_len, apm->cseg_16_len, apm->dseg_len); break; } case MULTIBOOT_TAG_TYPE_EFI32: { + mb2binfo.EFI.Info.Enabled = 1; + mb2binfo.EFI.Info.ST = 1; + multiboot_tag_efi32 *efi32 = (multiboot_tag_efi32 *)Tag; - fixme("efi32->[pointer: %p, size: %d]", efi32->pointer, efi32->size); + mb2binfo.EFI.SystemTable = (void *)(uintptr_t)efi32->pointer; + + debug("efi32->[pointer: %#lx, size: %d]", efi32->pointer, efi32->size); break; } case MULTIBOOT_TAG_TYPE_EFI64: { + mb2binfo.EFI.Info.Enabled = 1; + mb2binfo.EFI.Info.ST = 1; + multiboot_tag_efi64 *efi64 = (multiboot_tag_efi64 *)Tag; - fixme("efi64->[pointer: %p, size: %d]", efi64->pointer, efi64->size); + mb2binfo.EFI.SystemTable = (void *)(uintptr_t)efi64->pointer; + + debug("efi64->[pointer: %#lx, size: %d]", efi64->pointer, efi64->size); break; } case MULTIBOOT_TAG_TYPE_SMBIOS: { multiboot_tag_smbios *smbios = (multiboot_tag_smbios *)Tag; - fixme("smbios->[major: %d, minor: %d]", smbios->major, smbios->minor); + mb2binfo.SMBIOSPtr = (void *)smbios->tables; + + debug("smbios->[major: %d, minor: %d]", smbios->major, smbios->minor); break; } case MULTIBOOT_TAG_TYPE_ACPI_OLD: { mb2binfo.RSDP = (BootInfo::RSDPInfo *)((multiboot_tag_old_acpi *)Tag)->rsdp; - debug("OLD ACPI RSDP: %p", mb2binfo.RSDP); + + debug("OLD ACPI RSDP: %#lx", mb2binfo.RSDP); break; } case MULTIBOOT_TAG_TYPE_ACPI_NEW: { mb2binfo.RSDP = (BootInfo::RSDPInfo *)((multiboot_tag_new_acpi *)Tag)->rsdp; - debug("NEW ACPI RSDP: %p", mb2binfo.RSDP); + + debug("NEW ACPI RSDP: %#lx", mb2binfo.RSDP); break; } case MULTIBOOT_TAG_TYPE_NETWORK: { multiboot_tag_network *net = (multiboot_tag_network *)Tag; - fixme("network->[dhcpack: %p]", net->dhcpack); + + fixme("network->[dhcpack: %#lx]", net->dhcpack); break; } case MULTIBOOT_TAG_TYPE_EFI_MMAP: { + mb2binfo.EFI.Info.Enabled = 1; + mb2binfo.EFI.Info.MemoryMap = 1; + multiboot_tag_efi_mmap *efi_mmap = (multiboot_tag_efi_mmap *)Tag; - fixme("efi_mmap->[descr_size: %d, descr_vers: %d, efi_mmap: %p]", + mb2binfo.EFI.MemoryMap.BaseAddress = (void *)efi_mmap->efi_mmap; + mb2binfo.EFI.MemoryMap.DescriptorSize = efi_mmap->descr_size; + mb2binfo.EFI.MemoryMap.DescriptorVersion = efi_mmap->descr_vers; + mb2binfo.EFI.MemoryMap.NumberOfEntries = (efi_mmap->size - sizeof(multiboot_tag_efi_mmap)) / efi_mmap->descr_size; + // mb2binfo.EFI.MemoryMap.NumberOfEntries = efi_mmap->size / efi_mmap->descr_size; + + debug("efi_mmap->[descr_size: %d, descr_vers: %d, efi_mmap: %#lx]", efi_mmap->descr_size, efi_mmap->descr_vers, efi_mmap->efi_mmap); break; } case MULTIBOOT_TAG_TYPE_EFI_BS: { - fixme("efi_bs->[%p] (unknown structure)", Tag); + mb2binfo.EFI.Info.Enabled = 1; + mb2binfo.EFI.Info.BS = 1; + + debug("efi_bs"); break; } case MULTIBOOT_TAG_TYPE_EFI32_IH: { + mb2binfo.EFI.Info.Enabled = 1; + mb2binfo.EFI.Info.IH = 1; + multiboot_tag_efi32_ih *efi32_ih = (multiboot_tag_efi32_ih *)Tag; - fixme("efi32_ih->[pointer: %p]", efi32_ih->pointer); + mb2binfo.EFI.ImageHandle = (void *)(uintptr_t)efi32_ih->pointer; + + debug("efi32_ih->[pointer: %#lx]", efi32_ih->pointer); break; } case MULTIBOOT_TAG_TYPE_EFI64_IH: { + mb2binfo.EFI.Info.Enabled = 1; + mb2binfo.EFI.Info.IH = 1; + multiboot_tag_efi64_ih *efi64_ih = (multiboot_tag_efi64_ih *)Tag; - fixme("efi64_ih->[pointer: %p]", efi64_ih->pointer); + mb2binfo.EFI.ImageHandle = (void *)(uintptr_t)efi64_ih->pointer; + + debug("efi64_ih->[pointer: %#lx]", efi64_ih->pointer); break; } case MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR: @@ -269,7 +314,8 @@ void multiboot2_parse(BootInfo &mb2binfo, uintptr_t Magic, uintptr_t Info) mb2binfo.Kernel.PhysicalBase = (void *)(uint64_t)load_base_addr->load_base_addr; mb2binfo.Kernel.VirtualBase = (void *)(uint64_t)(load_base_addr->load_base_addr + 0xFFFFFFFF80000000); mb2binfo.Kernel.Size = ((uint64_t)&_kernel_end - (uint64_t)&_kernel_start) + ((uint64_t)&_bootstrap_end - (uint64_t)&_bootstrap_start); - debug("Kernel base: %p (physical) %p (virtual)", mb2binfo.Kernel.PhysicalBase, mb2binfo.Kernel.VirtualBase); + + debug("Kernel base: %#lx (physical) %#lx (virtual)", mb2binfo.Kernel.PhysicalBase, mb2binfo.Kernel.VirtualBase); break; } default: diff --git a/Kernel/efi/boot.cpp b/Kernel/efi/boot.cpp new file mode 100644 index 00000000..24d8ede1 --- /dev/null +++ b/Kernel/efi/boot.cpp @@ -0,0 +1,140 @@ +/* + This file is part of Fennix Kernel. + + Fennix Kernel is free software: you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation, either version 3 of + the License, or (at your option) any later version. + + Fennix Kernel is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Fennix Kernel. If not, see . +*/ + +#include + +#include +#include + +extern struct BootInfo bInfo; + +VOID SearchSMBIOS(EFI_SYSTEM_TABLE *SystemTable) +{ + EFI_GUID Smbios3TableGuid = {0xf2fd1544, 0x9794, 0x4a2c, {0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94}}; + EFI_GUID SmbiosTableGuid = {0xEB9D2D31, 0x2D88, 0x11D3, {0x9A, 0x16, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}}; + + for (UINTN i = 0; i < SystemTable->NumberOfTableEntries; i++) + { + EFI_CONFIGURATION_TABLE *config = &SystemTable->ConfigurationTable[i]; + + if (CompareGuid(&config->VendorGuid, &Smbios3TableGuid) || + CompareGuid(&config->VendorGuid, &SmbiosTableGuid)) + { + bInfo.SMBIOSPtr = config->VendorTable; + debug("SMBIOS EPS found at address: %#lx", bInfo.SMBIOSPtr); + return; + } + } +} + +VOID SearchRSDP(EFI_SYSTEM_TABLE *SystemTable) +{ + EFI_GUID AcpiTableGuid = {0x8868E871, 0xE4F1, 0x11D3, {0xBC, 0x22, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81}}; + + for (UINTN i = 0; i < SystemTable->NumberOfTableEntries; i++) + { + EFI_CONFIGURATION_TABLE *config = &SystemTable->ConfigurationTable[i]; + if (CompareGuid(&config->VendorGuid, &AcpiTableGuid)) + { + bInfo.RSDP = (BootInfo::RSDPInfo *)config->VendorTable; + debug("RSDP found at address: %#lx", bInfo.RSDP); + break; + } + } +} + +VOID InitializeMemoryEntries(EFI_MEMORY_DESCRIPTOR *MemoryMap, UINTN NumberOfEntries, UINTN DescriptorSize) +{ + debug("Memory map: %#lx", MemoryMap); + debug("Number of entries: %d", NumberOfEntries); + debug("Descriptor size: %d", DescriptorSize); + + for (UINTN i = 0; i < NumberOfEntries; i++) + { + EFI_MEMORY_DESCRIPTOR *desc = (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)MemoryMap + i * DescriptorSize); + +#ifdef DEBUG + const char *EFI_MEMORY_TYPE_STRINGS[] = { + "ReservedMemoryType", + "LoaderCode", + "LoaderData", + "BootServicesCode", + "BootServicesData", + "RuntimeServicesCode", + "RuntimeServicesData", + "ConventionalMemory", + "UnusableMemory", + "ACPIReclaimMemory", + "ACPIMemoryNVS", + "MemoryMappedIO", + "MemoryMappedIOPortSpace", + "PalCode", + "PersistentMemory", + "MaxMemoryType"}; + + debug("Entry %d: Type: %s, PhysicalStart: %p, VirtualStart: %p, NumberOfPages: %lu, Attribute: %lx", + i, EFI_MEMORY_TYPE_STRINGS[desc->Type], desc->PhysicalStart, desc->VirtualStart, desc->NumberOfPages, desc->Attribute); +#endif + } +} + +VOID InitializeMemory(EFI_SYSTEM_TABLE *SystemTable) +{ + EFI_MEMORY_DESCRIPTOR *MemoryMap = (EFI_MEMORY_DESCRIPTOR *)bInfo.EFI.MemoryMap.BaseAddress; + UINTN NumberOfEntries = bInfo.EFI.MemoryMap.NumberOfEntries; + UINTN DescriptorSize = bInfo.EFI.MemoryMap.DescriptorSize; + + EFI_STATUS Status = SystemTable->BootServices->AllocatePool(EfiLoaderData, NumberOfEntries * DescriptorSize, (void **)&MemoryMap); + if (EFI_ERROR(Status)) + { + error("Failed to allocate memory for memory map: %#lx", Status); + return; + } + + Status = SystemTable->BootServices->GetMemoryMap(&NumberOfEntries, MemoryMap, &DescriptorSize, NULL, NULL); + if (EFI_ERROR(Status)) + { + error("Failed to get memory map: %#lx", Status); + return; + } + + InitializeMemoryEntries(MemoryMap, NumberOfEntries, DescriptorSize); +} + +VOID InitializeMemoryNoBS() +{ + EFI_MEMORY_DESCRIPTOR *MemoryMap = (EFI_MEMORY_DESCRIPTOR *)bInfo.EFI.MemoryMap.BaseAddress; + UINTN NumberOfEntries = bInfo.EFI.MemoryMap.NumberOfEntries; + UINTN DescriptorSize = bInfo.EFI.MemoryMap.DescriptorSize; + InitializeMemoryEntries(MemoryMap, NumberOfEntries, DescriptorSize); +} + +EFI_STATUS EFIAPI efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable) +{ + if (bInfo.EFI.Info.ST == 1) + { + SearchSMBIOS(SystemTable); + SearchRSDP(SystemTable); + } + + if (bInfo.EFI.Info.BS == 0 && bInfo.EFI.Info.MemoryMap == 1) + InitializeMemoryNoBS(); + else if (bInfo.EFI.Info.BS == 1) + InitializeMemory(SystemTable); + + return EFI_SUCCESS; +} diff --git a/Kernel/efi/lib.cpp b/Kernel/efi/lib.cpp new file mode 100644 index 00000000..8f5cc82a --- /dev/null +++ b/Kernel/efi/lib.cpp @@ -0,0 +1,36 @@ +/* + This file is part of Fennix Kernel. + + Fennix Kernel is free software: you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation, either version 3 of + the License, or (at your option) any later version. + + Fennix Kernel is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Fennix Kernel. If not, see . +*/ + +#include + +#include + +BOOLEAN EFIAPI CompareGuid(IN CONST GUID *Guid1, IN CONST GUID *Guid2) +{ + if (Guid1 == NULL || Guid2 == NULL) + return FALSE; + + return (Guid1->Data1 == Guid2->Data1 && + Guid1->Data2 == Guid2->Data2 && + Guid1->Data3 == Guid2->Data3 && + memcmp(Guid1->Data4, Guid2->Data4, sizeof(Guid1->Data4)) == 0); +} + +VOID InitializeLib(IN EFI_HANDLE, IN EFI_SYSTEM_TABLE *) +{ + /* Does nothing */ +} diff --git a/Kernel/include/boot/binfo.h b/Kernel/include/boot/binfo.h index 251d6fc8..5b8eaf75 100644 --- a/Kernel/include/boot/binfo.h +++ b/Kernel/include/boot/binfo.h @@ -20,24 +20,24 @@ enum MemoryType { - Unknown_Memory_Type, - Usable, - Reserved, - ACPIReclaimable, - ACPINVS, - BadMemory, - BootloaderReclaimable, - KernelAndModules, - Framebuffer, - Unknown + Unknown_Memory_Type, + Usable, + Reserved, + ACPIReclaimable, + ACPINVS, + BadMemory, + BootloaderReclaimable, + KernelAndModules, + Framebuffer, + Unknown }; enum FramebufferType { - Unknown_Framebuffer_Type, - Indexed, - RGB, - EGA + Unknown_Framebuffer_Type, + Indexed, + RGB, + EGA }; #define MAX_FRAMEBUFFERS 16 @@ -46,110 +46,137 @@ enum FramebufferType struct BootInfo { - struct FramebufferInfo - { - enum FramebufferType Type; - void *BaseAddress; - __UINT32_TYPE__ Width; - __UINT32_TYPE__ Height; - __SIZE_TYPE__ Pitch; - __UINT16_TYPE__ BitsPerPixel; - __UINT8_TYPE__ RedMaskSize; - __UINT8_TYPE__ RedMaskShift; - __UINT8_TYPE__ GreenMaskSize; - __UINT8_TYPE__ GreenMaskShift; - __UINT8_TYPE__ BlueMaskSize; - __UINT8_TYPE__ BlueMaskShift; - void *ExtendedDisplayIdentificationData; - __SIZE_TYPE__ EDIDSize; - } Framebuffer[MAX_FRAMEBUFFERS]; + struct FramebufferInfo + { + enum FramebufferType Type; + void *BaseAddress; + __UINT32_TYPE__ Width; + __UINT32_TYPE__ Height; + __SIZE_TYPE__ Pitch; + __UINT16_TYPE__ BitsPerPixel; + __UINT8_TYPE__ RedMaskSize; + __UINT8_TYPE__ RedMaskShift; + __UINT8_TYPE__ GreenMaskSize; + __UINT8_TYPE__ GreenMaskShift; + __UINT8_TYPE__ BlueMaskSize; + __UINT8_TYPE__ BlueMaskShift; + void *ExtendedDisplayIdentificationData; + __SIZE_TYPE__ EDIDSize; + } Framebuffer[MAX_FRAMEBUFFERS]; - struct MemoryInfo - { - struct MemoryEntryInfo - { - void *BaseAddress; - __SIZE_TYPE__ Length; - enum MemoryType Type; - } Entry[MAX_MEMORY_ENTRIES]; - __SIZE_TYPE__ Entries; - __SIZE_TYPE__ Size; - } Memory; + struct MemoryInfo + { + struct MemoryEntryInfo + { + void *BaseAddress; + __SIZE_TYPE__ Length; + enum MemoryType Type; + } Entry[MAX_MEMORY_ENTRIES]; + __SIZE_TYPE__ Entries; + __SIZE_TYPE__ Size; + } Memory; - struct ModuleInfo - { - void *Address; - char Path[256]; - char CommandLine[256]; - __SIZE_TYPE__ Size; - } Modules[MAX_MODULES]; + struct ModuleInfo + { + void *Address; + char Path[256]; + char CommandLine[256]; + __SIZE_TYPE__ Size; + } Modules[MAX_MODULES]; - struct RSDPInfo - { - /** - * @brief Signature - */ - __UINT8_TYPE__ Signature[8]; - /** - * @brief Checksum - */ - __UINT8_TYPE__ Checksum; - /** - * @brief OEM ID - */ - __UINT8_TYPE__ OEMID[6]; - /** - * @brief Revision - */ - __UINT8_TYPE__ Revision; - /** - * @brief Address of the Root System Description Table - */ - __UINT32_TYPE__ RSDTAddress; - /* END OF RSDP 1.0 */ + struct RSDPInfo + { + /** + * @brief Signature + */ + __UINT8_TYPE__ Signature[8]; + /** + * @brief Checksum + */ + __UINT8_TYPE__ Checksum; + /** + * @brief OEM ID + */ + __UINT8_TYPE__ OEMID[6]; + /** + * @brief Revision + */ + __UINT8_TYPE__ Revision; + /** + * @brief Address of the Root System Description Table + */ + __UINT32_TYPE__ RSDTAddress; + /* END OF RSDP 1.0 */ - /** - * @brief Length - */ - __UINT32_TYPE__ Length; - /** - * @brief Extended System Descriptor Table - */ - __UINT64_TYPE__ XSDTAddress; - /** - * @brief Extended checksum - */ - __UINT8_TYPE__ ExtendedChecksum; - /** - * @brief Reserved - */ - __UINT8_TYPE__ Reserved[3]; - } __attribute__((packed)) * RSDP; + /** + * @brief Length + */ + __UINT32_TYPE__ Length; + /** + * @brief Extended System Descriptor Table + */ + __UINT64_TYPE__ XSDTAddress; + /** + * @brief Extended checksum + */ + __UINT8_TYPE__ ExtendedChecksum; + /** + * @brief Reserved + */ + __UINT8_TYPE__ Reserved[3]; + } __attribute__((packed)) * RSDP; - struct KernelInfo - { - void *PhysicalBase; - void *VirtualBase; - void *FileBase; - char CommandLine[256]; - __SIZE_TYPE__ Size; + struct KernelInfo + { + void *PhysicalBase; + void *VirtualBase; + void *FileBase; + char CommandLine[256]; + __SIZE_TYPE__ Size; - struct KernelSymbolInfo - { - __UINT32_TYPE__ Num; - __UINT32_TYPE__ EntSize; - __UINT32_TYPE__ Shndx; - __UINTPTR_TYPE__ Sections; - } Symbols; - } Kernel; + struct KernelSymbolInfo + { + __UINT32_TYPE__ Num; + __UINT32_TYPE__ EntSize; + __UINT32_TYPE__ Shndx; + __UINTPTR_TYPE__ Sections; + } Symbols; + } Kernel; - struct BootloaderInfo - { - char Name[256]; - char Version[64]; - } Bootloader; + struct BootloaderInfo + { + char Name[256]; + char Version[64]; + } Bootloader; - void *SMBIOSPtr; + void *SMBIOSPtr; + + struct EFIInfo + { + union + { + struct + { + __UINT8_TYPE__ Enabled : 1; + __UINT8_TYPE__ BS : 1; + __UINT8_TYPE__ IH : 1; + __UINT8_TYPE__ ST : 1; + __UINT8_TYPE__ MemoryMap : 1; + } __attribute__((packed)); + __UINT8_TYPE__ raw; + } Info; + + struct + { + void *BaseAddress; + __SIZE_TYPE__ DescriptorSize; + __SIZE_TYPE__ DescriptorVersion; + __SIZE_TYPE__ NumberOfEntries; + } MemoryMap; + + void *ImageHandle; + void *SystemTable; + } EFI; }; #endif // !__FENNIX_KERNEL_BOOT_INFO_H__ diff --git a/Kernel/include/boot/protocol/multiboot2.h b/Kernel/include/boot/protocol/multiboot2.h index 32f8d995..e1664d79 100644 --- a/Kernel/include/boot/protocol/multiboot2.h +++ b/Kernel/include/boot/protocol/multiboot2.h @@ -72,12 +72,11 @@ #define MULTIBOOT_HEADER_TAG_FRAMEBUFFER 5 #define MULTIBOOT_HEADER_TAG_MODULE_ALIGN 6 #define MULTIBOOT_HEADER_TAG_EFI_BS 7 -#define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI32 8 #define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64 9 #define MULTIBOOT_HEADER_TAG_RELOCATABLE 10 -#define MULTIBOOT_ARCHITECTURE_I386 0 -#define MULTIBOOT_ARCHITECTURE_MIPS32 4 +#define MULTIBOOT2_ARCHITECTURE_I386 0 +#define MULTIBOOT2_ARCHITECTURE_MIPS32 4 #define MULTIBOOT_HEADER_TAG_OPTIONAL 1 #define MULTIBOOT_LOAD_PREFERENCE_NONE 0 @@ -96,320 +95,320 @@ typedef unsigned long long multiboot_uint64_t; struct multiboot_header { - /* Must be MULTIBOOT_MAGIC - see above. */ - multiboot_uint32_t magic; + /* Must be MULTIBOOT_MAGIC - see above. */ + multiboot_uint32_t magic; - /* ISA */ - multiboot_uint32_t architecture; + /* ISA */ + multiboot_uint32_t architecture; - /* Total header length. */ - multiboot_uint32_t header_length; + /* Total header length. */ + multiboot_uint32_t header_length; - /* The above fields plus this one must equal 0 mod 2^32. */ - multiboot_uint32_t checksum; + /* The above fields plus this one must equal 0 mod 2^32. */ + multiboot_uint32_t checksum; }; struct multiboot_header_tag { - multiboot_uint16_t type; - multiboot_uint16_t flags; - multiboot_uint32_t size; + multiboot_uint16_t type; + multiboot_uint16_t flags; + multiboot_uint32_t size; }; struct multiboot_header_tag_information_request { - multiboot_uint16_t type; - multiboot_uint16_t flags; - multiboot_uint32_t size; - multiboot_uint32_t requests[0]; + multiboot_uint16_t type; + multiboot_uint16_t flags; + multiboot_uint32_t size; + multiboot_uint32_t requests[0]; }; struct multiboot_header_tag_address { - multiboot_uint16_t type; - multiboot_uint16_t flags; - multiboot_uint32_t size; - multiboot_uint32_t header_addr; - multiboot_uint32_t load_addr; - multiboot_uint32_t load_end_addr; - multiboot_uint32_t bss_end_addr; + multiboot_uint16_t type; + multiboot_uint16_t flags; + multiboot_uint32_t size; + multiboot_uint32_t header_addr; + multiboot_uint32_t load_addr; + multiboot_uint32_t load_end_addr; + multiboot_uint32_t bss_end_addr; }; struct multiboot_header_tag_entry_address { - multiboot_uint16_t type; - multiboot_uint16_t flags; - multiboot_uint32_t size; - multiboot_uint32_t entry_addr; + multiboot_uint16_t type; + multiboot_uint16_t flags; + multiboot_uint32_t size; + multiboot_uint32_t entry_addr; }; struct multiboot_header_tag_console_flags { - multiboot_uint16_t type; - multiboot_uint16_t flags; - multiboot_uint32_t size; - multiboot_uint32_t console_flags; + multiboot_uint16_t type; + multiboot_uint16_t flags; + multiboot_uint32_t size; + multiboot_uint32_t console_flags; }; struct multiboot_header_tag_framebuffer { - multiboot_uint16_t type; - multiboot_uint16_t flags; - multiboot_uint32_t size; - multiboot_uint32_t width; - multiboot_uint32_t height; - multiboot_uint32_t depth; + multiboot_uint16_t type; + multiboot_uint16_t flags; + multiboot_uint32_t size; + multiboot_uint32_t width; + multiboot_uint32_t height; + multiboot_uint32_t depth; }; struct multiboot_header_tag_module_align { - multiboot_uint16_t type; - multiboot_uint16_t flags; - multiboot_uint32_t size; + multiboot_uint16_t type; + multiboot_uint16_t flags; + multiboot_uint32_t size; }; struct multiboot_header_tag_relocatable { - multiboot_uint16_t type; - multiboot_uint16_t flags; - multiboot_uint32_t size; - multiboot_uint32_t min_addr; - multiboot_uint32_t max_addr; - multiboot_uint32_t align; - multiboot_uint32_t preference; + multiboot_uint16_t type; + multiboot_uint16_t flags; + multiboot_uint32_t size; + multiboot_uint32_t min_addr; + multiboot_uint32_t max_addr; + multiboot_uint32_t align; + multiboot_uint32_t preference; }; struct multiboot_color { - multiboot_uint8_t red; - multiboot_uint8_t green; - multiboot_uint8_t blue; + multiboot_uint8_t red; + multiboot_uint8_t green; + multiboot_uint8_t blue; }; struct multiboot_mmap_entry { - multiboot_uint64_t addr; - multiboot_uint64_t len; + multiboot_uint64_t addr; + multiboot_uint64_t len; #define MULTIBOOT_MEMORY_AVAILABLE 1 #define MULTIBOOT_MEMORY_RESERVED 2 #define MULTIBOOT_MEMORY_ACPI_RECLAIMABLE 3 #define MULTIBOOT_MEMORY_NVS 4 #define MULTIBOOT_MEMORY_BADRAM 5 - multiboot_uint32_t type; - multiboot_uint32_t zero; + multiboot_uint32_t type; + multiboot_uint32_t zero; }; typedef struct multiboot_mmap_entry multiboot_memory_map_t; struct multiboot_tag { - multiboot_uint32_t type; - multiboot_uint32_t size; + multiboot_uint32_t type; + multiboot_uint32_t size; }; struct multiboot_tag_string { - multiboot_uint32_t type; - multiboot_uint32_t size; - char string[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + char string[0]; }; struct multiboot_tag_module { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t mod_start; - multiboot_uint32_t mod_end; - char cmdline[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t mod_start; + multiboot_uint32_t mod_end; + char cmdline[0]; }; struct multiboot_tag_basic_meminfo { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t mem_lower; - multiboot_uint32_t mem_upper; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t mem_lower; + multiboot_uint32_t mem_upper; }; struct multiboot_tag_bootdev { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t biosdev; - multiboot_uint32_t slice; - multiboot_uint32_t part; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t biosdev; + multiboot_uint32_t slice; + multiboot_uint32_t part; }; struct multiboot_tag_mmap { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t entry_size; - multiboot_uint32_t entry_version; - struct multiboot_mmap_entry entries[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t entry_size; + multiboot_uint32_t entry_version; + struct multiboot_mmap_entry entries[0]; }; struct multiboot_vbe_info_block { - multiboot_uint8_t external_specification[512]; + multiboot_uint8_t external_specification[512]; }; struct multiboot_vbe_mode_info_block { - multiboot_uint8_t external_specification[256]; + multiboot_uint8_t external_specification[256]; }; struct multiboot_tag_vbe { - multiboot_uint32_t type; - multiboot_uint32_t size; + multiboot_uint32_t type; + multiboot_uint32_t size; - multiboot_uint16_t vbe_mode; - multiboot_uint16_t vbe_interface_seg; - multiboot_uint16_t vbe_interface_off; - multiboot_uint16_t vbe_interface_len; + multiboot_uint16_t vbe_mode; + multiboot_uint16_t vbe_interface_seg; + multiboot_uint16_t vbe_interface_off; + multiboot_uint16_t vbe_interface_len; - struct multiboot_vbe_info_block vbe_control_info; - struct multiboot_vbe_mode_info_block vbe_mode_info; + struct multiboot_vbe_info_block vbe_control_info; + struct multiboot_vbe_mode_info_block vbe_mode_info; }; struct multiboot_tag_framebuffer_common { - multiboot_uint32_t type; - multiboot_uint32_t size; + multiboot_uint32_t type; + multiboot_uint32_t size; - multiboot_uint64_t framebuffer_addr; - multiboot_uint32_t framebuffer_pitch; - multiboot_uint32_t framebuffer_width; - multiboot_uint32_t framebuffer_height; - multiboot_uint8_t framebuffer_bpp; + multiboot_uint64_t framebuffer_addr; + multiboot_uint32_t framebuffer_pitch; + multiboot_uint32_t framebuffer_width; + multiboot_uint32_t framebuffer_height; + multiboot_uint8_t framebuffer_bpp; #define MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED 0 #define MULTIBOOT_FRAMEBUFFER_TYPE_RGB 1 #define MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT 2 - multiboot_uint8_t framebuffer_type; - multiboot_uint16_t reserved; + multiboot_uint8_t framebuffer_type; + multiboot_uint16_t reserved; }; struct multiboot_tag_framebuffer { - struct multiboot_tag_framebuffer_common common; + struct multiboot_tag_framebuffer_common common; - union - { - struct - { - multiboot_uint16_t framebuffer_palette_num_colors; - struct multiboot_color framebuffer_palette[0]; - }; - struct - { - multiboot_uint8_t framebuffer_red_field_position; - multiboot_uint8_t framebuffer_red_mask_size; - multiboot_uint8_t framebuffer_green_field_position; - multiboot_uint8_t framebuffer_green_mask_size; - multiboot_uint8_t framebuffer_blue_field_position; - multiboot_uint8_t framebuffer_blue_mask_size; - }; - }; + union + { + struct + { + multiboot_uint16_t framebuffer_palette_num_colors; + struct multiboot_color framebuffer_palette[0]; + }; + struct + { + multiboot_uint8_t framebuffer_red_field_position; + multiboot_uint8_t framebuffer_red_mask_size; + multiboot_uint8_t framebuffer_green_field_position; + multiboot_uint8_t framebuffer_green_mask_size; + multiboot_uint8_t framebuffer_blue_field_position; + multiboot_uint8_t framebuffer_blue_mask_size; + }; + }; }; struct multiboot_tag_elf_sections { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t num; - multiboot_uint32_t entsize; - multiboot_uint32_t shndx; - char sections[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t num; + multiboot_uint32_t entsize; + multiboot_uint32_t shndx; + char sections[0]; }; struct multiboot_tag_apm { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint16_t version; - multiboot_uint16_t cseg; - multiboot_uint32_t offset; - multiboot_uint16_t cseg_16; - multiboot_uint16_t dseg; - multiboot_uint16_t flags; - multiboot_uint16_t cseg_len; - multiboot_uint16_t cseg_16_len; - multiboot_uint16_t dseg_len; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint16_t version; + multiboot_uint16_t cseg; + multiboot_uint32_t offset; + multiboot_uint16_t cseg_16; + multiboot_uint16_t dseg; + multiboot_uint16_t flags; + multiboot_uint16_t cseg_len; + multiboot_uint16_t cseg_16_len; + multiboot_uint16_t dseg_len; }; struct multiboot_tag_efi32 { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t pointer; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t pointer; }; struct multiboot_tag_efi64 { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint64_t pointer; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint64_t pointer; }; struct multiboot_tag_smbios { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint8_t major; - multiboot_uint8_t minor; - multiboot_uint8_t reserved[6]; - multiboot_uint8_t tables[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint8_t major; + multiboot_uint8_t minor; + multiboot_uint8_t reserved[6]; + multiboot_uint8_t tables[0]; }; struct multiboot_tag_old_acpi { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint8_t rsdp[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint8_t rsdp[0]; }; struct multiboot_tag_new_acpi { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint8_t rsdp[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint8_t rsdp[0]; }; struct multiboot_tag_network { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint8_t dhcpack[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint8_t dhcpack[0]; }; struct multiboot_tag_efi_mmap { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t descr_size; - multiboot_uint32_t descr_vers; - multiboot_uint8_t efi_mmap[0]; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t descr_size; + multiboot_uint32_t descr_vers; + multiboot_uint8_t efi_mmap[0]; }; struct multiboot_tag_efi32_ih { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t pointer; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t pointer; }; struct multiboot_tag_efi64_ih { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint64_t pointer; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint64_t pointer; }; struct multiboot_tag_load_base_addr { - multiboot_uint32_t type; - multiboot_uint32_t size; - multiboot_uint32_t load_base_addr; + multiboot_uint32_t type; + multiboot_uint32_t size; + multiboot_uint32_t load_base_addr; }; #endif /* ! ASM_FILE */ diff --git a/Kernel/include/efi.h b/Kernel/include/efi.h new file mode 100644 index 00000000..313d92f2 --- /dev/null +++ b/Kernel/include/efi.h @@ -0,0 +1,356 @@ +/* + This file is part of Fennix Kernel. + + Fennix Kernel is free software: you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation, either version 3 of + the License, or (at your option) any later version. + + Fennix Kernel is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Fennix Kernel. If not, see . +*/ + +#pragma once + +#include + +#ifdef __x86_64__ +#define EFIAPI __attribute__((__ms_abi__)) +#else +#define EFIAPI +#endif + +#define IN +#define OUT +#define OPTIONAL +#define CONST const + +#define FALSE 0 +#define TRUE 1 + +#define MAX_BIT (~((UINTN) - 1 >> 1)) + +typedef intptr_t INTN; +typedef uintptr_t UINTN; +typedef int8_t INT8; +typedef uint8_t UINT8; +typedef int16_t INT16; +typedef uint16_t UINT16; +typedef int32_t INT32; +typedef uint32_t UINT32; +typedef int64_t INT64; +typedef uint64_t UINT64; +typedef int8_t CHAR8; +typedef uint16_t CHAR16; + +typedef void VOID; +typedef bool BOOLEAN; + +typedef INTN EFI_STATUS; +typedef VOID *EFI_HANDLE; +typedef VOID *EFI_EVENT; + +typedef UINT64 EFI_PHYSICAL_ADDRESS; +typedef UINT64 EFI_VIRTUAL_ADDRESS; + +typedef EFI_STATUS RETURN_STATUS; +typedef UINTN EFI_TPL; + +enum EFI_MEMORY_TYPE +{ + EfiReservedMemoryType, + EfiLoaderCode, + EfiLoaderData, + EfiBootServicesCode, + EfiBootServicesData, + EfiRuntimeServicesCode, + EfiRuntimeServicesData, + EfiConventionalMemory, + EfiUnusableMemory, + EfiACPIReclaimMemory, + EfiACPIMemoryNVS, + EfiMemoryMappedIO, + EfiMemoryMappedIOPortSpace, + EfiPalCode, + EfiPersistentMemory, + EfiMaxMemoryType +}; + +enum EFI_ALLOCATE_TYPE +{ + AllocateAnyPages, + AllocateMaxAddress, + AllocateAddress, + MaxAllocateType +}; + +enum EFI_TIMER_DELAY +{ + TimerCancel, + TimerPeriodic, + TimerRelative +}; + +enum EFI_LOCATE_SEARCH_TYPE +{ + AllHandles, + ByRegisterNotify, + ByProtocol +}; + +enum EFI_INTERFACE_TYPE +{ + EFI_NATIVE_INTERFACE +}; + +typedef enum +{ + EfiResetCold, + EfiResetWarm, + EfiResetShutdown +} EFI_RESET_TYPE; + +#include +#include + +struct EFI_OPEN_PROTOCOL_INFORMATION_ENTRY +{ + EFI_HANDLE AgentHandle; + EFI_HANDLE ControllerHandle; + UINT32 Attributes; + UINT32 OpenCount; +}; + +struct EFI_DEVICE_PATH_PROTOCOL +{ + UINT8 Type; + UINT8 SubType; + UINT8 Length[2]; +}; + +typedef struct +{ + UINT16 ScanCode; + CHAR16 UnicodeChar; +} EFI_INPUT_KEY; + +struct EFI_TABLE_HEADER +{ + UINT64 Signature; + UINT32 Revision; + UINT32 HeaderSize; + UINT32 CRC32; + UINT32 Reserved; +}; + +struct _EFI_GUID +{ + UINT32 Data1; + UINT16 Data2; + UINT16 Data3; + UINT8 Data4[8]; +}; + +typedef struct +{ + _EFI_GUID CapsuleGuid; + UINT32 HeaderSize; + UINT32 Flags; + UINT32 CapsuleImageSize; +} EFI_CAPSULE_HEADER; + +typedef struct +{ + UINT16 Year; + UINT8 Month; + UINT8 Day; + UINT8 Hour; + UINT8 Minute; + UINT8 Second; + UINT8 Pad1; + UINT32 Nanosecond; + INT16 TimeZone; + UINT8 Daylight; + UINT8 Pad2; +} EFI_TIME; + +typedef struct +{ + UINT32 Resolution; + UINT32 Accuracy; + BOOLEAN SetsToZero; +} EFI_TIME_CAPABILITIES; + +typedef struct _EFI_GUID EFI_GUID; +typedef struct _EFI_GUID GUID; + +typedef struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL EFI_SIMPLE_TEXT_INPUT_PROTOCOL; +typedef struct _EFI_MEMORY_DESCRIPTOR EFI_MEMORY_DESCRIPTOR; + +#include + +struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL +{ + EFI_INPUT_RESET Reset; + EFI_INPUT_READ_KEY ReadKeyStroke; + EFI_EVENT WaitForKey; +}; + +struct EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL +{ + void * /*EFI_TEXT_RESET*/ Reset; + + void * /*EFI_TEXT_STRING*/ OutputString; + void * /*EFI_TEXT_TEST_STRING*/ TestString; + + void * /*EFI_TEXT_QUERY_MODE*/ QueryMode; + void * /*EFI_TEXT_SET_MODE*/ SetMode; + void * /*EFI_TEXT_SET_ATTRIBUTE*/ SetAttribute; + + void * /*EFI_TEXT_CLEAR_SCREEN*/ ClearScreen; + void * /*EFI_TEXT_SET_CURSOR_POSITION*/ SetCursorPosition; + void * /*EFI_TEXT_ENABLE_CURSOR*/ EnableCursor; + + void /*EFI_SIMPLE_TEXT_OUTPUT_MODE*/ *Mode; +}; + +struct EFI_CONFIGURATION_TABLE +{ + EFI_GUID VendorGuid; + VOID *VendorTable; +}; + +struct EFI_BOOT_SERVICES; + +typedef struct +{ + EFI_TABLE_HEADER Hdr; + + // + // Time services + // + + EFI_GET_TIME GetTime; + EFI_SET_TIME SetTime; + EFI_GET_WAKEUP_TIME GetWakeupTime; + EFI_SET_WAKEUP_TIME SetWakeupTime; + + // + // Virtual memory services + // + + EFI_SET_VIRTUAL_ADDRESS_MAP SetVirtualAddressMap; + EFI_CONVERT_POINTER ConvertPointer; + + // + // Variable serviers + // + + EFI_GET_VARIABLE GetVariable; + EFI_GET_NEXT_VARIABLE_NAME GetNextVariableName; + EFI_SET_VARIABLE SetVariable; + + // + // Misc + // + + EFI_GET_NEXT_HIGH_MONO_COUNT GetNextHighMonotonicCount; + EFI_RESET_SYSTEM ResetSystem; + + EFI_UPDATE_CAPSULE UpdateCapsule; + EFI_QUERY_CAPSULE_CAPABILITIES QueryCapsuleCapabilities; + EFI_QUERY_VARIABLE_INFO QueryVariableInfo; +} EFI_RUNTIME_SERVICES; + +typedef struct +{ + EFI_TABLE_HEADER Hdr; + CHAR16 *FirmwareVendor; + UINT32 FirmwareRevision; + EFI_HANDLE ConsoleInHandle; + EFI_SIMPLE_TEXT_INPUT_PROTOCOL *ConIn; + EFI_HANDLE ConsoleOutHandle; + EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut; + EFI_HANDLE StandardErrorHandle; + EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *StdErr; + EFI_RUNTIME_SERVICES *RuntimeServices; + EFI_BOOT_SERVICES *BootServices; + UINTN NumberOfTableEntries; + EFI_CONFIGURATION_TABLE *ConfigurationTable; +} EFI_SYSTEM_TABLE; + +struct _EFI_MEMORY_DESCRIPTOR +{ + UINT32 Type; + EFI_PHYSICAL_ADDRESS PhysicalStart; + EFI_VIRTUAL_ADDRESS VirtualStart; + UINT64 NumberOfPages; + UINT64 Attribute; +}; + +struct EFI_BOOT_SERVICES +{ + EFI_TABLE_HEADER Hdr; + EFI_RAISE_TPL RaiseTPL; + EFI_RESTORE_TPL RestoreTPL; + + EFI_ALLOCATE_PAGES AllocatePages; + EFI_FREE_PAGES FreePages; + EFI_GET_MEMORY_MAP GetMemoryMap; + EFI_ALLOCATE_POOL AllocatePool; + EFI_FREE_POOL FreePool; + + EFI_CREATE_EVENT CreateEvent; + EFI_SET_TIMER SetTimer; + EFI_WAIT_FOR_EVENT WaitForEvent; + EFI_SIGNAL_EVENT SignalEvent; + EFI_CLOSE_EVENT CloseEvent; + EFI_CHECK_EVENT CheckEvent; + + EFI_INSTALL_PROTOCOL_INTERFACE InstallProtocolInterface; + EFI_REINSTALL_PROTOCOL_INTERFACE ReinstallProtocolInterface; + EFI_UNINSTALL_PROTOCOL_INTERFACE UninstallProtocolInterface; + EFI_HANDLE_PROTOCOL HandleProtocol; + VOID *Reserved; + EFI_REGISTER_PROTOCOL_NOTIFY RegisterProtocolNotify; + EFI_LOCATE_HANDLE LocateHandle; + EFI_LOCATE_DEVICE_PATH LocateDevicePath; + EFI_INSTALL_CONFIGURATION_TABLE InstallConfigurationTable; + + EFI_IMAGE_LOAD LoadImage; + EFI_IMAGE_START StartImage; + EFI_EXIT Exit; + EFI_IMAGE_UNLOAD UnloadImage; + EFI_EXIT_BOOT_SERVICES ExitBootServices; + + EFI_GET_NEXT_MONOTONIC_COUNT GetNextMonotonicCount; + EFI_STALL Stall; + EFI_SET_WATCHDOG_TIMER SetWatchdogTimer; + + EFI_CONNECT_CONTROLLER ConnectController; + EFI_DISCONNECT_CONTROLLER DisconnectController; + + EFI_OPEN_PROTOCOL OpenProtocol; + EFI_CLOSE_PROTOCOL CloseProtocol; + EFI_OPEN_PROTOCOL_INFORMATION OpenProtocolInformation; + + EFI_PROTOCOLS_PER_HANDLE ProtocolsPerHandle; + EFI_LOCATE_HANDLE_BUFFER LocateHandleBuffer; + EFI_LOCATE_PROTOCOL LocateProtocol; + + EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES InstallMultipleProtocolInterfaces; + EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES UninstallMultipleProtocolInterfaces; + + EFI_CALCULATE_CRC32 CalculateCrc32; + + EFI_COPY_MEM CopyMem; + EFI_SET_MEM SetMem; +}; + +VOID InitializeLib(IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable); +BOOLEAN EFIAPI CompareGuid(IN CONST GUID *Guid1, IN CONST GUID *Guid2); diff --git a/Kernel/include/efi/calls.h b/Kernel/include/efi/calls.h new file mode 100644 index 00000000..b8ee4f23 --- /dev/null +++ b/Kernel/include/efi/calls.h @@ -0,0 +1,301 @@ +/* + This file is part of Fennix Kernel. + + Fennix Kernel is free software: you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation, either version 3 of + the License, or (at your option) any later version. + + Fennix Kernel is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Fennix Kernel. If not, see . +*/ + +#pragma once + +typedef EFI_STATUS(EFIAPI *EFI_INPUT_RESET)( + IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This, + IN BOOLEAN ExtendedVerification); + +typedef EFI_STATUS(EFIAPI *EFI_INPUT_READ_KEY)( + IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This, + OUT EFI_INPUT_KEY *Key); + +typedef EFI_TPL(EFIAPI *EFI_RAISE_TPL)( + IN EFI_TPL NewTpl); + +typedef VOID(EFIAPI *EFI_RESTORE_TPL)( + IN EFI_TPL OldTpl); + +typedef EFI_STATUS(EFIAPI *EFI_ALLOCATE_PAGES)( + IN EFI_ALLOCATE_TYPE Type, + IN EFI_MEMORY_TYPE MemoryType, + IN UINTN Pages, + IN OUT EFI_PHYSICAL_ADDRESS *Memory); + +typedef EFI_STATUS(EFIAPI *EFI_FREE_PAGES)( + IN EFI_PHYSICAL_ADDRESS Memory, + IN UINTN Pages); + +typedef EFI_STATUS(EFIAPI *EFI_GET_MEMORY_MAP)( + IN OUT UINTN *MemoryMapSize, + IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, + OUT UINTN *MapKey, + OUT UINTN *DescriptorSize, + OUT UINT32 *DescriptorVersion); + +typedef EFI_STATUS(EFIAPI *EFI_ALLOCATE_POOL)( + IN EFI_MEMORY_TYPE PoolType, + IN UINTN Size, + OUT VOID **Buffer); + +typedef EFI_STATUS(EFIAPI *EFI_FREE_POOL)( + IN VOID *Buffer); + +typedef VOID(EFIAPI *EFI_EVENT_NOTIFY)( + IN EFI_EVENT Event, + IN VOID *Context); + +typedef EFI_STATUS(EFIAPI *EFI_CREATE_EVENT)( + IN UINT32 Type, + IN EFI_TPL NotifyTpl, + IN EFI_EVENT_NOTIFY NotifyFunction, + IN VOID *NotifyContext, + OUT EFI_EVENT *Event); + +typedef EFI_STATUS(EFIAPI *EFI_SET_TIMER)( + IN EFI_EVENT Event, + IN EFI_TIMER_DELAY Type, + IN UINT64 TriggerTime); + +typedef EFI_STATUS(EFIAPI *EFI_WAIT_FOR_EVENT)( + IN UINTN NumberOfEvents, + IN EFI_EVENT *Event, + OUT UINTN *Index); + +typedef EFI_STATUS(EFIAPI *EFI_SIGNAL_EVENT)( + IN EFI_EVENT Event); + +typedef EFI_STATUS(EFIAPI *EFI_CLOSE_EVENT)( + IN EFI_EVENT Event); + +typedef EFI_STATUS(EFIAPI *EFI_CHECK_EVENT)( + IN EFI_EVENT Event); + +typedef EFI_STATUS(EFIAPI *EFI_INSTALL_PROTOCOL_INTERFACE)( + IN OUT EFI_HANDLE *Handle, + IN EFI_GUID const *Protocol, + IN EFI_INTERFACE_TYPE InterfaceType, + IN VOID *Interface); + +typedef EFI_STATUS(EFIAPI *EFI_REINSTALL_PROTOCOL_INTERFACE)( + IN EFI_HANDLE Handle, + IN EFI_GUID const *Protocol, + IN VOID *OldInterface, + IN VOID *NewInterface); + +typedef EFI_STATUS(EFIAPI *EFI_UNINSTALL_PROTOCOL_INTERFACE)( + IN EFI_HANDLE Handle, + IN EFI_GUID const *Protocol, + IN VOID *Interface); + +typedef EFI_STATUS(EFIAPI *EFI_HANDLE_PROTOCOL)( + IN EFI_HANDLE Handle, + IN EFI_GUID const *Protocol, + OUT VOID **Interface); + +typedef EFI_STATUS(EFIAPI *EFI_REGISTER_PROTOCOL_NOTIFY)( + IN EFI_GUID const *Protocol, + IN EFI_EVENT Event, + OUT VOID **Registration); + +typedef EFI_STATUS(EFIAPI *EFI_LOCATE_HANDLE)( + IN EFI_LOCATE_SEARCH_TYPE SearchType, + IN EFI_GUID const *Protocol, OPTIONAL IN VOID *SearchKey, OPTIONAL IN OUT UINTN *BufferSize, + OUT EFI_HANDLE *Buffer); + +typedef EFI_STATUS(EFIAPI *EFI_LOCATE_DEVICE_PATH)( + IN EFI_GUID const *Protocol, + IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath, + OUT EFI_HANDLE *Device); + +typedef EFI_STATUS(EFIAPI *EFI_INSTALL_CONFIGURATION_TABLE)( + IN EFI_GUID const *Guid, + IN VOID *Table); + +typedef EFI_STATUS(EFIAPI *EFI_IMAGE_LOAD)( + IN BOOLEAN BootPolicy, + IN EFI_HANDLE ParentImageHandle, + IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, + IN VOID *SourceBuffer OPTIONAL, + IN UINTN SourceSize, + OUT EFI_HANDLE *ImageHandle); + +typedef EFI_STATUS(EFIAPI *EFI_IMAGE_START)( + IN EFI_HANDLE ImageHandle, + OUT UINTN *ExitDataSize, + OUT CHAR16 **ExitData OPTIONAL); + +typedef EFI_STATUS(EFIAPI *EFI_EXIT)( + IN EFI_HANDLE ImageHandle, + IN EFI_STATUS ExitStatus, + IN UINTN ExitDataSize, + IN CHAR16 *ExitData OPTIONAL); + +typedef EFI_STATUS(EFIAPI *EFI_IMAGE_UNLOAD)( + IN EFI_HANDLE ImageHandle); + +typedef EFI_STATUS(EFIAPI *EFI_EXIT_BOOT_SERVICES)( + IN EFI_HANDLE ImageHandle, + IN UINTN MapKey); + +typedef EFI_STATUS(EFIAPI *EFI_GET_NEXT_MONOTONIC_COUNT)( + OUT UINT64 *Count); + +typedef EFI_STATUS(EFIAPI *EFI_STALL)( + IN UINTN Microseconds); + +typedef EFI_STATUS(EFIAPI *EFI_SET_WATCHDOG_TIMER)( + IN UINTN Timeout, + IN UINT64 WatchdogCode, + IN UINTN DataSize, + IN CHAR16 *WatchdogData OPTIONAL); + +typedef EFI_STATUS(EFIAPI *EFI_CONNECT_CONTROLLER)( + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE *DriverImageHandle, OPTIONAL IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath, OPTIONAL IN BOOLEAN Recursive); + +typedef EFI_STATUS(EFIAPI *EFI_DISCONNECT_CONTROLLER)( + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE DriverImageHandle, OPTIONAL IN EFI_HANDLE ChildHandle OPTIONAL); + +typedef EFI_STATUS(EFIAPI *EFI_OPEN_PROTOCOL)( + IN EFI_HANDLE Handle, + IN EFI_GUID const *Protocol, + OUT VOID **Interface, OPTIONAL IN EFI_HANDLE AgentHandle, + IN EFI_HANDLE ControllerHandle, + IN UINT32 Attributes); + +typedef EFI_STATUS(EFIAPI *EFI_CLOSE_PROTOCOL)( + IN EFI_HANDLE Handle, + IN EFI_GUID const *Protocol, + IN EFI_HANDLE AgentHandle, + IN EFI_HANDLE ControllerHandle); + +typedef EFI_STATUS(EFIAPI *EFI_OPEN_PROTOCOL_INFORMATION)( + IN EFI_HANDLE Handle, + IN EFI_GUID const *Protocol, + OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer, + OUT UINTN *EntryCount); + +typedef EFI_STATUS(EFIAPI *EFI_PROTOCOLS_PER_HANDLE)( + IN EFI_HANDLE Handle, + OUT EFI_GUID const ***ProtocolBuffer, + OUT UINTN *ProtocolBufferCount); + +typedef EFI_STATUS(EFIAPI *EFI_LOCATE_HANDLE_BUFFER)( + IN EFI_LOCATE_SEARCH_TYPE SearchType, + IN EFI_GUID const *Protocol, OPTIONAL IN VOID *SearchKey, OPTIONAL IN OUT UINTN *NoHandles, + OUT EFI_HANDLE **Buffer); + +typedef EFI_STATUS(EFIAPI *EFI_LOCATE_PROTOCOL)( + IN EFI_GUID const *Protocol, + IN VOID *Registration, OPTIONAL OUT VOID **Interface); + +typedef EFI_STATUS(EFIAPI *EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES)( + IN OUT EFI_HANDLE *Handle, + ...); + +typedef EFI_STATUS(EFIAPI *EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES)( + IN EFI_HANDLE Handle, + ...); + +typedef EFI_STATUS(EFIAPI *EFI_CALCULATE_CRC32)( + IN VOID *Data, + IN UINTN DataSize, + OUT UINT32 *Crc32); + +typedef VOID(EFIAPI *EFI_COPY_MEM)( + IN VOID *Destination, + IN VOID *Source, + IN UINTN Length); + +typedef VOID(EFIAPI *EFI_SET_MEM)( + IN VOID *Buffer, + IN UINTN Size, + IN UINT8 Value); + +typedef EFI_STATUS(EFIAPI *EFI_GET_TIME)( + OUT EFI_TIME *Time, + OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL); + +typedef EFI_STATUS(EFIAPI *EFI_SET_TIME)( + IN EFI_TIME *Time); + +typedef EFI_STATUS(EFIAPI *EFI_GET_WAKEUP_TIME)( + OUT BOOLEAN *Enabled, + OUT BOOLEAN *Pending, + OUT EFI_TIME *Time); + +typedef EFI_STATUS(EFIAPI *EFI_SET_WAKEUP_TIME)( + IN BOOLEAN Enable, + IN EFI_TIME *Time OPTIONAL); + +typedef EFI_STATUS(EFIAPI *EFI_SET_VIRTUAL_ADDRESS_MAP)( + IN UINTN MemoryMapSize, + IN UINTN DescriptorSize, + IN UINT32 DescriptorVersion, + IN EFI_MEMORY_DESCRIPTOR *VirtualMap); + +typedef EFI_STATUS(EFIAPI *EFI_CONVERT_POINTER)( + IN UINTN DebugDisposition, + IN OUT VOID **Address); + +typedef EFI_STATUS(EFIAPI *EFI_GET_VARIABLE)( + IN CHAR16 *VariableName, + IN EFI_GUID *VendorGuid, + OUT UINT32 *Attributes OPTIONAL, + IN OUT UINTN *DataSize, + OUT VOID *Data); + +typedef EFI_STATUS(EFIAPI *EFI_GET_NEXT_VARIABLE_NAME)( + IN OUT UINTN *VariableNameSize, + IN OUT CHAR16 *VariableName, + IN OUT EFI_GUID *VendorGuid); + +typedef EFI_STATUS(EFIAPI *EFI_SET_VARIABLE)( + IN CHAR16 *VariableName, + IN EFI_GUID *VendorGuid, + IN UINT32 Attributes, + IN UINTN DataSize, + IN VOID *Data); + +typedef EFI_STATUS(EFIAPI *EFI_GET_NEXT_HIGH_MONO_COUNT)( + OUT UINT32 *HighCount); + +typedef EFI_STATUS(EFIAPI *EFI_RESET_SYSTEM)( + IN EFI_RESET_TYPE ResetType, + IN EFI_STATUS ResetStatus, + IN UINTN DataSize, + IN CHAR16 *ResetData OPTIONAL); + +typedef EFI_STATUS(EFIAPI *EFI_UPDATE_CAPSULE)( + IN EFI_CAPSULE_HEADER **CapsuleHeaderArray, + IN UINTN CapsuleCount, + IN EFI_PHYSICAL_ADDRESS ScatterGatherList OPTIONAL); + +typedef EFI_STATUS(EFIAPI *EFI_QUERY_CAPSULE_CAPABILITIES)( + IN EFI_CAPSULE_HEADER **CapsuleHeaderArray, + IN UINTN CapsuleCount, + OUT UINT64 *MaximumCapsuleSize, + OUT EFI_RESET_TYPE *ResetType); + +typedef EFI_STATUS(EFIAPI *EFI_QUERY_VARIABLE_INFO)( + IN UINT32 Attributes, + OUT UINT64 *MaximumVariableStorageSize, + OUT UINT64 *RemainingVariableStorageSize, + OUT UINT64 *MaximumVariableSize); diff --git a/Kernel/include/efi/errors.h b/Kernel/include/efi/errors.h new file mode 100644 index 00000000..76cb35d8 --- /dev/null +++ b/Kernel/include/efi/errors.h @@ -0,0 +1,106 @@ +/* + This file is part of Fennix Kernel. + + Fennix Kernel is free software: you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation, either version 3 of + the License, or (at your option) any later version. + + Fennix Kernel is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Fennix Kernel. If not, see . +*/ + +#pragma once + +#define ENCODE_ERROR(StatusCode) ((RETURN_STATUS)(MAX_BIT | (StatusCode))) +#define ENCODE_WARNING(StatusCode) ((RETURN_STATUS)(StatusCode)) +#define RETURN_ERROR(StatusCode) (((StatusCode)) < 0) + +#define RETURN_SUCCESS 0 +#define RETURN_LOAD_ERROR ENCODE_ERROR(1) +#define RETURN_INVALID_PARAMETER ENCODE_ERROR(2) +#define RETURN_UNSUPPORTED ENCODE_ERROR(3) +#define RETURN_BAD_BUFFER_SIZE ENCODE_ERROR(4) +#define RETURN_BUFFER_TOO_SMALL ENCODE_ERROR(5) +#define RETURN_NOT_READY ENCODE_ERROR(6) +#define RETURN_DEVICE_ERROR ENCODE_ERROR(7) +#define RETURN_WRITE_PROTECTED ENCODE_ERROR(8) +#define RETURN_OUT_OF_RESOURCES ENCODE_ERROR(9) +#define RETURN_VOLUME_CORRUPTED ENCODE_ERROR(10) +#define RETURN_VOLUME_FULL ENCODE_ERROR(11) +#define RETURN_NO_MEDIA ENCODE_ERROR(12) +#define RETURN_MEDIA_CHANGED ENCODE_ERROR(13) +#define RETURN_NOT_FOUND ENCODE_ERROR(14) +#define RETURN_ACCESS_DENIED ENCODE_ERROR(15) +#define RETURN_NO_RESPONSE ENCODE_ERROR(16) +#define RETURN_NO_MAPPING ENCODE_ERROR(17) +#define RETURN_TIMEOUT ENCODE_ERROR(18) +#define RETURN_NOT_STARTED ENCODE_ERROR(19) +#define RETURN_ALREADY_STARTED ENCODE_ERROR(20) +#define RETURN_ABORTED ENCODE_ERROR(21) +#define RETURN_ICMP_ERROR ENCODE_ERROR(22) +#define RETURN_TFTP_ERROR ENCODE_ERROR(23) +#define RETURN_PROTOCOL_ERROR ENCODE_ERROR(24) +#define RETURN_INCOMPATIBLE_VERSION ENCODE_ERROR(25) +#define RETURN_SECURITY_VIOLATION ENCODE_ERROR(26) +#define RETURN_CRC_ERROR ENCODE_ERROR(27) +#define RETURN_END_OF_MEDIA ENCODE_ERROR(28) +#define RETURN_END_OF_FILE ENCODE_ERROR(31) +#define RETURN_INVALID_LANGUAGE ENCODE_ERROR(32) +#define RETURN_COMPROMISED_DATA ENCODE_ERROR(33) +#define RETURN_HTTP_ERROR ENCODE_ERROR(35) +#define RETURN_WARN_UNKNOWN_GLYPH ENCODE_WARNING(1) +#define RETURN_WARN_DELETE_FAILURE ENCODE_WARNING(2) +#define RETURN_WARN_WRITE_FAILURE ENCODE_WARNING(3) +#define RETURN_WARN_BUFFER_TOO_SMALL ENCODE_WARNING(4) +#define RETURN_WARN_STALE_DATA ENCODE_WARNING(5) +#define RETURN_WARN_FILE_SYSTEM ENCODE_WARNING(6) + +#define EFI_SUCCESS RETURN_SUCCESS +#define EFI_LOAD_ERROR RETURN_LOAD_ERROR +#define EFI_INVALID_PARAMETER RETURN_INVALID_PARAMETER +#define EFI_UNSUPPORTED RETURN_UNSUPPORTED +#define EFI_BAD_BUFFER_SIZE RETURN_BAD_BUFFER_SIZE +#define EFI_BUFFER_TOO_SMALL RETURN_BUFFER_TOO_SMALL +#define EFI_NOT_READY RETURN_NOT_READY +#define EFI_DEVICE_ERROR RETURN_DEVICE_ERROR +#define EFI_WRITE_PROTECTED RETURN_WRITE_PROTECTED +#define EFI_OUT_OF_RESOURCES RETURN_OUT_OF_RESOURCES +#define EFI_VOLUME_CORRUPTED RETURN_VOLUME_CORRUPTED +#define EFI_VOLUME_FULL RETURN_VOLUME_FULL +#define EFI_NO_MEDIA RETURN_NO_MEDIA +#define EFI_MEDIA_CHANGED RETURN_MEDIA_CHANGED +#define EFI_NOT_FOUND RETURN_NOT_FOUND +#define EFI_ACCESS_DENIED RETURN_ACCESS_DENIED +#define EFI_NO_RESPONSE RETURN_NO_RESPONSE +#define EFI_NO_MAPPING RETURN_NO_MAPPING +#define EFI_TIMEOUT RETURN_TIMEOUT +#define EFI_NOT_STARTED RETURN_NOT_STARTED +#define EFI_ALREADY_STARTED RETURN_ALREADY_STARTED +#define EFI_ABORTED RETURN_ABORTED +#define EFI_ICMP_ERROR RETURN_ICMP_ERROR +#define EFI_TFTP_ERROR RETURN_TFTP_ERROR +#define EFI_PROTOCOL_ERROR RETURN_PROTOCOL_ERROR +#define EFI_INCOMPATIBLE_VERSION RETURN_INCOMPATIBLE_VERSION +#define EFI_SECURITY_VIOLATION RETURN_SECURITY_VIOLATION +#define EFI_CRC_ERROR RETURN_CRC_ERROR +#define EFI_END_OF_MEDIA RETURN_END_OF_MEDIA +#define EFI_END_OF_FILE RETURN_END_OF_FILE +#define EFI_INVALID_LANGUAGE RETURN_INVALID_LANGUAGE +#define EFI_COMPROMISED_DATA RETURN_COMPROMISED_DATA +#define EFI_HTTP_ERROR RETURN_HTTP_ERROR + +#define EFI_WARN_UNKNOWN_GLYPH RETURN_WARN_UNKNOWN_GLYPH +#define EFI_WARN_DELETE_FAILURE RETURN_WARN_DELETE_FAILURE +#define EFI_WARN_WRITE_FAILURE RETURN_WARN_WRITE_FAILURE +#define EFI_WARN_BUFFER_TOO_SMALL RETURN_WARN_BUFFER_TOO_SMALL +#define EFI_WARN_STALE_DATA RETURN_WARN_STALE_DATA +#define EFI_WARN_FILE_SYSTEM RETURN_WARN_FILE_SYSTEM + +#define EFIERR(_a) ENCODE_ERROR(_a) +#define EFI_ERROR(A) RETURN_ERROR(A) diff --git a/Kernel/include/efi/tables.h b/Kernel/include/efi/tables.h new file mode 100644 index 00000000..28b3e43e --- /dev/null +++ b/Kernel/include/efi/tables.h @@ -0,0 +1,33 @@ +/* + This file is part of Fennix Kernel. + + Fennix Kernel is free software: you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation, either version 3 of + the License, or (at your option) any later version. + + Fennix Kernel is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Fennix Kernel. If not, see . +*/ + +#pragma once + +#define ACPI_20_TABLE_GUID \ + {0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81}} + +#define ACPI_TABLE_GUID \ + {0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d}} + +#define SAL_SYSTEM_TABLE_GUID \ + {0xeb9d2d32, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d}} + +#define SMBIOS_TABLE_GUID \ + {0xeb9d2d31, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d}} + +#define MPS_TABLE_GUID \ + {0xeb9d2d2f, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d}} diff --git a/Kernel/kernel.cpp b/Kernel/kernel.cpp index 982e7efd..e6861b1a 100644 --- a/Kernel/kernel.cpp +++ b/Kernel/kernel.cpp @@ -27,11 +27,14 @@ #include #include #include +#include #include #include "core/smbios.hpp" #include "tests/t.h" +EFI_STATUS EFIAPI efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable); + bool DebuggerIsAttached = false; NewLock(KernelLock); @@ -269,6 +272,9 @@ EXTERNC __no_stack_protector nif cold void Entry(BootInfo *Info) if (strcmp(CPU::Hypervisor(), x86_CPUID_VENDOR_TCG) == 0) DebuggerIsAttached = true; + if (bInfo.EFI.Info.IH || bInfo.EFI.Info.ST) + efi_main((EFI_HANDLE)bInfo.EFI.ImageHandle, (EFI_SYSTEM_TABLE *)bInfo.EFI.SystemTable); + #if defined(__amd64__) || defined(__i386__) if (!bInfo.SMBIOSPtr) {