From b9222eb044e64f2a739332e3ad3339d919d346ac Mon Sep 17 00:00:00 2001 From: Thomas Oltmann Date: Mon, 10 Mar 2025 02:36:46 +0100 Subject: [PATCH] Set up a basic dev environment --- .gitignore | 2 + Makefile | 62 + config.default.mk | 14 + efi.c | 11 + gnuefi/crt0-efi-x86_64.o | Bin 0 -> 2992 bytes gnuefi/elf_x86_64_efi.lds | 112 ++ gnuefi/inc/Makefile | 24 + gnuefi/inc/aarch64/efibind.h | 160 +++ gnuefi/inc/aarch64/efilibplat.h | 25 + gnuefi/inc/aarch64/efisetjmp_arch.h | 34 + gnuefi/inc/arm/efibind.h | 168 +++ gnuefi/inc/arm/efilibplat.h | 25 + gnuefi/inc/arm/efisetjmp_arch.h | 21 + gnuefi/inc/efi.h | 90 ++ gnuefi/inc/efi_nii.h | 78 + gnuefi/inc/efi_pxe.h | 1743 +++++++++++++++++++++++ gnuefi/inc/efiapi.h | 1034 ++++++++++++++ gnuefi/inc/eficompiler.h | 60 + gnuefi/inc/eficon.h | 306 ++++ gnuefi/inc/eficonex.h | 111 ++ gnuefi/inc/efidebug.h | 620 ++++++++ gnuefi/inc/efidef.h | 258 ++++ gnuefi/inc/efidevp.h | 650 +++++++++ gnuefi/inc/efierr.h | 73 + gnuefi/inc/efifs.h | 116 ++ gnuefi/inc/efigpt.h | 68 + gnuefi/inc/efiip.h | 459 ++++++ gnuefi/inc/efilib.h | 1089 ++++++++++++++ gnuefi/inc/efilink.h | 182 +++ gnuefi/inc/efinet.h | 348 +++++ gnuefi/inc/efipart.h | 61 + gnuefi/inc/efipciio.h | 399 ++++++ gnuefi/inc/efipoint.h | 115 ++ gnuefi/inc/efiprot.h | 1466 +++++++++++++++++++ gnuefi/inc/efipxebc.h | 482 +++++++ gnuefi/inc/efirtlib.h | 193 +++ gnuefi/inc/efiser.h | 136 ++ gnuefi/inc/efisetjmp.h | 10 + gnuefi/inc/efishell.h | 449 ++++++ gnuefi/inc/efishellintf.h | 94 ++ gnuefi/inc/efistdarg.h | 33 + gnuefi/inc/efitcp.h | 391 +++++ gnuefi/inc/efiudp.h | 272 ++++ gnuefi/inc/efiui.h | 58 + gnuefi/inc/ia32/efibind.h | 294 ++++ gnuefi/inc/ia32/efilibplat.h | 26 + gnuefi/inc/ia32/efisetjmp_arch.h | 15 + gnuefi/inc/ia32/pe.h | 595 ++++++++ gnuefi/inc/ia64/efibind.h | 236 +++ gnuefi/inc/ia64/efilibplat.h | 80 ++ gnuefi/inc/ia64/efisetjmp_arch.h | 47 + gnuefi/inc/ia64/pe.h | 601 ++++++++ gnuefi/inc/ia64/salproc.h | 264 ++++ gnuefi/inc/inc.mak | 23 + gnuefi/inc/lib.h | 92 ++ gnuefi/inc/libsmbios.h | 143 ++ gnuefi/inc/loongarch64/efibind.h | 159 +++ gnuefi/inc/loongarch64/efilibplat.h | 24 + gnuefi/inc/loongarch64/efisetjmp_arch.h | 23 + gnuefi/inc/make.inf | 33 + gnuefi/inc/makefile.hdr | 48 + gnuefi/inc/mips64el/efibind.h | 168 +++ gnuefi/inc/mips64el/efilibplat.h | 25 + gnuefi/inc/mips64el/efisetjmp_arch.h | 34 + gnuefi/inc/pci22.h | 193 +++ gnuefi/inc/protocol/adapterdebug.h | 32 + gnuefi/inc/protocol/eficonsplit.h | 32 + gnuefi/inc/protocol/efidbg.h | 210 +++ gnuefi/inc/protocol/efivar.h | 133 ++ gnuefi/inc/protocol/ia64/eficontext.h | 208 +++ gnuefi/inc/protocol/intload.h | 27 + gnuefi/inc/protocol/legacyboot.h | 119 ++ gnuefi/inc/protocol/make.inf | 13 + gnuefi/inc/protocol/makefile.hdr | 29 + gnuefi/inc/protocol/piflash64.h | 121 ++ gnuefi/inc/protocol/readme.txt | 3 + gnuefi/inc/protocol/vgaclass.h | 95 ++ gnuefi/inc/riscv64/efibind.h | 128 ++ gnuefi/inc/riscv64/efilibplat.h | 7 + gnuefi/inc/riscv64/efisetjmp_arch.h | 40 + gnuefi/inc/romload.h | 41 + gnuefi/inc/x86_64/efibind.h | 396 +++++ gnuefi/inc/x86_64/efilibplat.h | 26 + gnuefi/inc/x86_64/efisetjmp_arch.h | 22 + gnuefi/inc/x86_64/pe.h | 595 ++++++++ gnuefi/libefi.a | Bin 0 -> 548594 bytes gnuefi/libgnuefi.a | Bin 0 -> 17018 bytes 87 files changed, 17502 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 config.default.mk create mode 100644 efi.c create mode 100644 gnuefi/crt0-efi-x86_64.o create mode 100644 gnuefi/elf_x86_64_efi.lds create mode 100644 gnuefi/inc/Makefile create mode 100644 gnuefi/inc/aarch64/efibind.h create mode 100644 gnuefi/inc/aarch64/efilibplat.h create mode 100644 gnuefi/inc/aarch64/efisetjmp_arch.h create mode 100644 gnuefi/inc/arm/efibind.h create mode 100644 gnuefi/inc/arm/efilibplat.h create mode 100644 gnuefi/inc/arm/efisetjmp_arch.h create mode 100644 gnuefi/inc/efi.h create mode 100644 gnuefi/inc/efi_nii.h create mode 100644 gnuefi/inc/efi_pxe.h create mode 100644 gnuefi/inc/efiapi.h create mode 100644 gnuefi/inc/eficompiler.h create mode 100644 gnuefi/inc/eficon.h create mode 100644 gnuefi/inc/eficonex.h create mode 100644 gnuefi/inc/efidebug.h create mode 100644 gnuefi/inc/efidef.h create mode 100644 gnuefi/inc/efidevp.h create mode 100644 gnuefi/inc/efierr.h create mode 100644 gnuefi/inc/efifs.h create mode 100644 gnuefi/inc/efigpt.h create mode 100644 gnuefi/inc/efiip.h create mode 100644 gnuefi/inc/efilib.h create mode 100644 gnuefi/inc/efilink.h create mode 100644 gnuefi/inc/efinet.h create mode 100644 gnuefi/inc/efipart.h create mode 100644 gnuefi/inc/efipciio.h create mode 100644 gnuefi/inc/efipoint.h create mode 100644 gnuefi/inc/efiprot.h create mode 100644 gnuefi/inc/efipxebc.h create mode 100644 gnuefi/inc/efirtlib.h create mode 100644 gnuefi/inc/efiser.h create mode 100644 gnuefi/inc/efisetjmp.h create mode 100644 gnuefi/inc/efishell.h create mode 100644 gnuefi/inc/efishellintf.h create mode 100644 gnuefi/inc/efistdarg.h create mode 100644 gnuefi/inc/efitcp.h create mode 100644 gnuefi/inc/efiudp.h create mode 100644 gnuefi/inc/efiui.h create mode 100644 gnuefi/inc/ia32/efibind.h create mode 100644 gnuefi/inc/ia32/efilibplat.h create mode 100644 gnuefi/inc/ia32/efisetjmp_arch.h create mode 100644 gnuefi/inc/ia32/pe.h create mode 100644 gnuefi/inc/ia64/efibind.h create mode 100644 gnuefi/inc/ia64/efilibplat.h create mode 100644 gnuefi/inc/ia64/efisetjmp_arch.h create mode 100644 gnuefi/inc/ia64/pe.h create mode 100644 gnuefi/inc/ia64/salproc.h create mode 100644 gnuefi/inc/inc.mak create mode 100644 gnuefi/inc/lib.h create mode 100644 gnuefi/inc/libsmbios.h create mode 100644 gnuefi/inc/loongarch64/efibind.h create mode 100644 gnuefi/inc/loongarch64/efilibplat.h create mode 100644 gnuefi/inc/loongarch64/efisetjmp_arch.h create mode 100644 gnuefi/inc/make.inf create mode 100644 gnuefi/inc/makefile.hdr create mode 100644 gnuefi/inc/mips64el/efibind.h create mode 100644 gnuefi/inc/mips64el/efilibplat.h create mode 100644 gnuefi/inc/mips64el/efisetjmp_arch.h create mode 100644 gnuefi/inc/pci22.h create mode 100644 gnuefi/inc/protocol/adapterdebug.h create mode 100644 gnuefi/inc/protocol/eficonsplit.h create mode 100644 gnuefi/inc/protocol/efidbg.h create mode 100644 gnuefi/inc/protocol/efivar.h create mode 100644 gnuefi/inc/protocol/ia64/eficontext.h create mode 100644 gnuefi/inc/protocol/intload.h create mode 100644 gnuefi/inc/protocol/legacyboot.h create mode 100644 gnuefi/inc/protocol/make.inf create mode 100644 gnuefi/inc/protocol/makefile.hdr create mode 100644 gnuefi/inc/protocol/piflash64.h create mode 100644 gnuefi/inc/protocol/readme.txt create mode 100644 gnuefi/inc/protocol/vgaclass.h create mode 100644 gnuefi/inc/riscv64/efibind.h create mode 100644 gnuefi/inc/riscv64/efilibplat.h create mode 100644 gnuefi/inc/riscv64/efisetjmp_arch.h create mode 100644 gnuefi/inc/romload.h create mode 100644 gnuefi/inc/x86_64/efibind.h create mode 100644 gnuefi/inc/x86_64/efilibplat.h create mode 100644 gnuefi/inc/x86_64/efisetjmp_arch.h create mode 100644 gnuefi/inc/x86_64/pe.h create mode 100644 gnuefi/libefi.a create mode 100644 gnuefi/libgnuefi.a diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ce3b793 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +config.mk +build/ diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..46b01f2 --- /dev/null +++ b/Makefile @@ -0,0 +1,62 @@ +# This build script uses some GNU make specific extensions. + +include config.mk + +CFLAGS += -ggdb + +# Kernel sources which are specific to the x86_64 architecture. +# Add new source files (C or Assembler) here, +# preferentially in alphabetical order. +VISOR_SOURCES_x86_64 := \ + # end of x86_64 specific sources list + +# Architecture-agnostic kernel sources. +# Add new source files (C or Assembler) here, +# preferentially in alphabetical order. +VISOR_SOURCES := \ + efi.c \ + $(VISOR_SOURCES_$(ARCH)) \ + # end of sources list + +VISOR_OBJECTS := $(VISOR_SOURCES:.c=.o) +VISOR_OBJECTS := $(VISOR_OBJECTS:.S=.o) +VISOR_OBJECTS := $(VISOR_OBJECTS:%.o=build/%.o) +VISOR_DEPFILES := $(VISOR_OBJECTS:.o=.d) +VISOR_TARGET := build/visor + +.PHONY: all clean + +all: $(VISOR_TARGET) + +clean: + rm -f $(VISOR_OBJECTS) + rm -f $(VISOR_DEPFILES) + rm -f build/visor.so + rm -f $(VISOR_TARGET) + +build/%.o: %.[cS] | build + @printf "CC %s\n" $@ + @"$(CC)" $(CFLAGS) -MMD -MP -c -o $@ $< $(CPPFLAGS) + +build/$(ARCH)/%.o: $(ARCH)/%.[cS] | build/$(ARCH) + @printf "CC %s\n" $@ + @"$(CC)" $(CFLAGS) -MMD -MP -c -o $@ $< $(CPPFLAGS) + +build/visor.so: $(VISOR_OBJECTS) gnuefi/crt0-efi-$(ARCH).o | build + @printf "LD %s\n" $@ + @"$(LD)" $(LDFLAGS) -o $@ gnuefi/crt0-efi-$(ARCH).o $(VISOR_OBJECTS) + +$(VISOR_TARGET): build/visor.so | build + @printf "ELF->PE %s\n" $@ + @objcopy -j .text -j .sdata -j .data -j .rodata -j .dynamic -j .dynsym -j .rel -j .rela -j .rel.* -j .rela.* -j .reloc --target efi-app-x86_64 --subsystem 10 build/visor.so $@ + +build: + mkdir -p $@ + +build/$(ARCH): + mkdir -p $@ + +config.mk: | config.default.mk + cp config.default.mk $@ + +-include $(VISOR_DEPFILES) diff --git a/config.default.mk b/config.default.mk new file mode 100644 index 0000000..295d92f --- /dev/null +++ b/config.default.mk @@ -0,0 +1,14 @@ +# The CPU architecture we want to compile for (x86_64 is the only one for now ...) +ARCH = x86_64 + +# Path to your cross-compiler binaries +CROSS_PATH = /usr/bin + +# C Compiler & Linker commands +CC = gcc +LD = ld + +# Compilation flags +CFLAGS = -std=c17 -Wall -ffreestanding -fpic -nostdlib -fno-stack-protector -fno-stack-check -fshort-wchar -mno-red-zone -maccumulate-outgoing-args -mno-sse -mno-mmx -mno-80387 +CPPFLAGS = -Ignuefi/inc +LDFLAGS = -shared -Bsymbolic -Lgnuefi -lgnuefi -lefi -Tgnuefi/elf_$(ARCH)_efi.lds -nostdlib diff --git a/efi.c b/efi.c new file mode 100644 index 0000000..2b05181 --- /dev/null +++ b/efi.c @@ -0,0 +1,11 @@ +#include +#include + +EFIAPI +EFI_STATUS +efi_main(EFI_HANDLE imageHandle, EFI_SYSTEM_TABLE *systemTable) +{ + InitializeLib(imageHandle, systemTable); + Print(L"Hello, World!\n"); + return EFI_SUCCESS; +} diff --git a/gnuefi/crt0-efi-x86_64.o b/gnuefi/crt0-efi-x86_64.o new file mode 100644 index 0000000000000000000000000000000000000000..92bb9ec7eb059523cca2fda8912b2ba5df909109 GIT binary patch literal 2992 zcmbtVU1%It6h5=l{Ak+ECQai{v2L{q4cN&>@#n?5Rkv=z6cSRjRk|~ion05RKkiOs z_sNxrM4QskH)+7oQfMkd9_&j&+F(l!2#GC%FM==P4?b8Bq(RVgX3v?<-fn#Hz|1-4 zyWctYoICg4c`xzm!H}kbhz9%Nt|ur!sr{}U_slr#fIdjh{N6b>o;>+HVabzElRA2A zZ2T88QpY`&oVnKd75OAv8%o|=(1_yGhR-X9k3a~ttAvSY>`P6e-(Z6H)rGFCX`0TD z=DL1!Zf@?%o$7(U$7ehG=d*S_G#EYe=r@xeL>5XznSBR~iJxvhnTXDgPkj8RV{iGb z4Q^E1PBaoqzVto$Z>@d3Hu~MLcKW018`l%78^6}hUtY?6a(VU6(9*_^{><&nV02_L zGPD2qrPz_x#6Y__Hkw(AvJz8(K9^M%q z2ydrl@kD}R>_=Ev7j9YDw+&jjJ-xVEe*|FLI+*?>CFV&y^8c%k=&t#5pT0R^L;vT? zu@lce^=(&X{l;hAXSZHFv+~36#LCF)E6KHM^BSD$*t5i`H&wb{MKeVQy%|8SQJ)5T zm5~n5zn8zw!~NxHiqh3h#-lofn|R{raG#h>T8FMCUmP8J#PoF^TD>j$-HEt-E1!(U zz$Un{3I5zBI2cYf=R$fqpRd7`Wjj+NkgB*=*@Z)SE9<;yRUAmYeDv^v(L*mms_aY^ zCoLBtr{I=r;CCLv{B$(`{-+^QGvTz>fqMQEc((u50#eEHI9o`-1= zh4}P{>|#T3`fen_erZhZ7r9mm6Px(5{_4D7RBCzGvQfL`hJH&d{J56kI#m~pwB=f0 z*p&(x9_oE}FbYN2G4Pt*hdX5QZT7Q;X`@swmYlL%V|v=Lr?aW4T*1LqzK#2;+(gI~ zGDRU+wq17KZ5p=9Rw3(P35^sK{l6uO8E8#{Yeh-p^g?O6Ptm9S7!*2>gvEm(*-SJU z??p}X$XIgcm z`Zu|7>67}W+g0tK&XrmdLV#CEOHsL_$f9$n)?epnIp^&9^Na7G;pLRVcwm|JF(I;6 zXka4Vs{bnYU*$OJpYA1zmvwmuF`7Rn189>(xY5@duKyOAtiy*mBDPOLBg^34AlQQY zK4Puv|AXtF=Xk20_JYhW^`Azp)%>Rzr2kk@RPK2k^e{=xiU1r^QUnvC=$=ZUaY$Jh#zOL&cyAA(cfRe)pI bt}^%nIRTM*1)~2+tN3N^|B4V + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice and this list of conditions, without modification. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU General Public License as published by the Free Software Foundation; + * either version 2 of the License, or (at your option) any later version. + */ + +#if !defined(_MSC_VER) && (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L )) && !defined(__cplusplus) + +// ANSI C 1999/2000 stdint.h integer width declarations + +typedef unsigned long uint64_t; +typedef long int64_t; +typedef unsigned int uint32_t; +typedef int int32_t; +typedef unsigned short uint16_t; +typedef short int16_t; +typedef unsigned char uint8_t; +typedef signed char int8_t; // unqualified 'char' is unsigned on ARM +typedef uint64_t uintptr_t; +typedef int64_t intptr_t; + +#else +#include +#endif + +// +// Basic EFI types of various widths +// + +#include + +typedef wchar_t CHAR16; +#define WCHAR CHAR16 + +typedef uint64_t UINT64; +typedef int64_t INT64; + +typedef uint32_t UINT32; +typedef int32_t INT32; + +typedef uint16_t UINT16; +typedef int16_t INT16; + +typedef uint8_t UINT8; +typedef char CHAR8; +typedef int8_t INT8; + +#undef VOID +typedef void VOID; + +typedef int64_t INTN; +typedef uint64_t UINTN; + +#define EFIERR(a) (0x8000000000000000 | a) +#define EFI_ERROR_MASK 0x8000000000000000 +#define EFIERR_OEM(a) (0xc000000000000000 | a) + +#define BAD_POINTER 0xFBFBFBFBFBFBFBFB +#define MAX_ADDRESS 0xFFFFFFFFFFFFFFFF + +#define BREAKPOINT() while (TRUE); // Make it hang on Bios[Dbg]32 + +// +// Pointers must be aligned to these address to function +// + +#define MIN_ALIGNMENT_SIZE 8 + +#define ALIGN_VARIABLE(Value ,Adjustment) \ + (UINTN)Adjustment = 0; \ + if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ + (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ + Value = (UINTN)Value + (UINTN)Adjustment + + +// +// Define macros to build data structure signatures from characters. +// + +#define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) +#define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) +#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) + +// +// EFIAPI - prototype calling convention for EFI function pointers +// BOOTSERVICE - prototype for implementation of a boot service interface +// RUNTIMESERVICE - prototype for implementation of a runtime service interface +// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service +// RUNTIME_CODE - pragma macro for declaring runtime code +// + +#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options +#define EFIAPI // Substitute expresion to force C calling convention +#endif + +#define BOOTSERVICE +#define RUNTIMESERVICE +#define RUNTIMEFUNCTION + + +#define RUNTIME_CODE(a) alloc_text("rtcode", a) +#define BEGIN_RUNTIME_DATA() data_seg("rtdata") +#define END_RUNTIME_DATA() data_seg("") + +#define VOLATILE volatile + +#define MEMORY_FENCE __sync_synchronize + +// +// When build similiar to FW, then link everything together as +// one big module. For the MSVC toolchain, we simply tell the +// linker what our driver init function is using /ENTRY. +// +#if defined(_MSC_EXTENSIONS) +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + __pragma(comment(linker, "/ENTRY:" # InitFunction)) +#else +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + InitializeDriver ( \ + VOID *ImageHandle, \ + VOID *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, \ + SystemTable); \ + } \ + \ + EFI_STATUS efi_main( \ + EFI_HANDLE image, \ + EFI_SYSTEM_TABLE *systab \ + ) __attribute__((weak, \ + alias ("InitializeDriver"))); +#endif + +#define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, entry) + + +// +// Some compilers don't support the forward reference construct: +// typedef struct XXXXX +// +// The following macro provide a workaround for such cases. + +#define INTERFACE_DECL(x) struct x + +#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__) +#define EFI_FUNCTION diff --git a/gnuefi/inc/aarch64/efilibplat.h b/gnuefi/inc/aarch64/efilibplat.h new file mode 100644 index 0000000..70a0786 --- /dev/null +++ b/gnuefi/inc/aarch64/efilibplat.h @@ -0,0 +1,25 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efilibplat.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ + +VOID +InitializeLibPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + diff --git a/gnuefi/inc/aarch64/efisetjmp_arch.h b/gnuefi/inc/aarch64/efisetjmp_arch.h new file mode 100644 index 0000000..74e1f87 --- /dev/null +++ b/gnuefi/inc/aarch64/efisetjmp_arch.h @@ -0,0 +1,34 @@ +#ifndef GNU_EFI_AARCH64_SETJMP_H +#define GNU_EFI_AARCH64_SETJMP_H + +#define JMPBUF_ALIGN 8 + +typedef struct { + /* GP regs */ + UINT64 X19; + UINT64 X20; + UINT64 X21; + UINT64 X22; + UINT64 X23; + UINT64 X24; + UINT64 X25; + UINT64 X26; + UINT64 X27; + UINT64 X28; + UINT64 FP; + UINT64 LR; + UINT64 IP0; + UINT64 _pad1; + + /* FP regs */ + UINT64 D8; + UINT64 D9; + UINT64 D10; + UINT64 D11; + UINT64 D12; + UINT64 D13; + UINT64 D14; + UINT64 D15; +} EFI_ALIGN(JMPBUF_ALIGN) jmp_buf[1]; + +#endif /* GNU_EFI_AARCH64_SETJMP_H */ diff --git a/gnuefi/inc/arm/efibind.h b/gnuefi/inc/arm/efibind.h new file mode 100644 index 0000000..8c578df --- /dev/null +++ b/gnuefi/inc/arm/efibind.h @@ -0,0 +1,168 @@ +/* + * Copright (C) 2014 - 2015 Linaro Ltd. + * Author: Ard Biesheuvel + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice and this list of conditions, without modification. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU General Public License as published by the Free Software Foundation; + * either version 2 of the License, or (at your option) any later version. + */ + +#if !defined(_MSC_VER) && (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L )) && !defined(__cplusplus) + +// ANSI C 1999/2000 stdint.h integer width declarations + +typedef unsigned long long uint64_t; +typedef long long int64_t; +typedef unsigned int uint32_t; +typedef int int32_t; +typedef unsigned short uint16_t; +typedef short int16_t; +typedef unsigned char uint8_t; +typedef signed char int8_t; // unqualified 'char' is unsigned on ARM +typedef uint32_t uintptr_t; +typedef int32_t intptr_t; + +#else +#include +#endif + +/* + * This prevents GCC from emitting GOT based relocations, and use R_ARM_REL32 + * relative relocations instead, which are more suitable for static binaries. + */ +#if defined(__GNUC__) && !__STDC_HOSTED__ +#pragma GCC visibility push (hidden) +#endif + +// +// Basic EFI types of various widths +// + +#include + +typedef wchar_t CHAR16; +#define WCHAR CHAR16 + +typedef uint64_t UINT64; +typedef int64_t INT64; + +typedef uint32_t UINT32; +typedef int32_t INT32; + +typedef uint16_t UINT16; +typedef int16_t INT16; + +typedef uint8_t UINT8; +typedef char CHAR8; +typedef int8_t INT8; + +#undef VOID +typedef void VOID; + +typedef int32_t INTN; +typedef uint32_t UINTN; + +#define EFIERR(a) (0x80000000 | a) +#define EFI_ERROR_MASK 0x80000000 +#define EFIERR_OEM(a) (0xc0000000 | a) + +#define BAD_POINTER 0xFBFBFBFB +#define MAX_ADDRESS 0xFFFFFFFF + +#define BREAKPOINT() while (TRUE); + +// +// Pointers must be aligned to these address to function +// + +#define MIN_ALIGNMENT_SIZE 4 + +#define ALIGN_VARIABLE(Value ,Adjustment) \ + (UINTN)Adjustment = 0; \ + if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ + (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ + Value = (UINTN)Value + (UINTN)Adjustment + + +// +// Define macros to build data structure signatures from characters. +// + +#define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) +#define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) +#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) + +// +// EFIAPI - prototype calling convention for EFI function pointers +// BOOTSERVICE - prototype for implementation of a boot service interface +// RUNTIMESERVICE - prototype for implementation of a runtime service interface +// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service +// RUNTIME_CODE - pragma macro for declaring runtime code +// + +#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options +#define EFIAPI // Substitute expresion to force C calling convention +#endif + +#define BOOTSERVICE +#define RUNTIMESERVICE +#define RUNTIMEFUNCTION + + +#define RUNTIME_CODE(a) alloc_text("rtcode", a) +#define BEGIN_RUNTIME_DATA() data_seg("rtdata") +#define END_RUNTIME_DATA() data_seg("") + +#define VOLATILE volatile + +#define MEMORY_FENCE __sync_synchronize + +// +// When build similiar to FW, then link everything together as +// one big module. For the MSVC toolchain, we simply tell the +// linker what our driver init function is using /ENTRY. +// +#if defined(_MSC_EXTENSIONS) +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + __pragma(comment(linker, "/ENTRY:" # InitFunction)) +#else +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + InitializeDriver ( \ + VOID *ImageHandle, \ + VOID *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, \ + SystemTable); \ + } \ + \ + EFI_STATUS efi_main( \ + EFI_HANDLE image, \ + EFI_SYSTEM_TABLE *systab \ + ) __attribute__((weak, \ + alias ("InitializeDriver"))); +#endif + +#define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, entry) + + +// +// Some compilers don't support the forward reference construct: +// typedef struct XXXXX +// +// The following macro provide a workaround for such cases. + +#define INTERFACE_DECL(x) struct x + +#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__) +#define EFI_FUNCTION diff --git a/gnuefi/inc/arm/efilibplat.h b/gnuefi/inc/arm/efilibplat.h new file mode 100644 index 0000000..70a0786 --- /dev/null +++ b/gnuefi/inc/arm/efilibplat.h @@ -0,0 +1,25 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efilibplat.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ + +VOID +InitializeLibPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + diff --git a/gnuefi/inc/arm/efisetjmp_arch.h b/gnuefi/inc/arm/efisetjmp_arch.h new file mode 100644 index 0000000..b809453 --- /dev/null +++ b/gnuefi/inc/arm/efisetjmp_arch.h @@ -0,0 +1,21 @@ +#ifndef GNU_EFI_ARM_SETJMP_H +#define GNU_EFI_ARM_SETJMP_H + +#define JMPBUF_ALIGN 4 + +typedef struct { + UINT32 R3; // A copy of R13 + UINT32 R4; + UINT32 R5; + UINT32 R6; + UINT32 R7; + UINT32 R8; + UINT32 R9; + UINT32 R10; + UINT32 R11; + UINT32 R12; + UINT32 R13; + UINT32 R14; +} EFI_ALIGN(JMPBUF_ALIGN) jmp_buf[1]; + +#endif /* GNU_EFI_ARM_SETJMP_H */ diff --git a/gnuefi/inc/efi.h b/gnuefi/inc/efi.h new file mode 100644 index 0000000..6d83374 --- /dev/null +++ b/gnuefi/inc/efi.h @@ -0,0 +1,90 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efi.h + +Abstract: + + Public EFI header files + + + +Revision History + +--*/ + + +// Add a predefined macro to detect usage of the library +#ifndef _GNU_EFI +#define _GNU_EFI +#endif + +// +// Build flags on input +// EFI32 +// EFI_DEBUG - Enable debugging code +// EFI_NT_EMULATOR - Building for running under NT +// + + +#ifndef _EFI_INCLUDE_ +#define _EFI_INCLUDE_ + +#ifdef __cplusplus +extern "C" { +#endif + +#define EFI_FIRMWARE_VENDOR L"INTEL" +#define EFI_FIRMWARE_MAJOR_REVISION 12 +#define EFI_FIRMWARE_MINOR_REVISION 33 +#define EFI_FIRMWARE_REVISION ((EFI_FIRMWARE_MAJOR_REVISION <<16) | (EFI_FIRMWARE_MINOR_REVISION)) + +#if defined(_M_X64) || defined(__x86_64__) || defined(__amd64__) +#include "x86_64/efibind.h" +#elif defined(_M_IX86) || defined(__i386__) +#include "ia32/efibind.h" +#elif defined(_M_IA64) || defined(__ia64__) +#include "ia64/efibind.h" +#elif defined (_M_ARM64) || defined(__aarch64__) +#include "aarch64/efibind.h" +#elif defined (_M_ARM) || defined(__arm__) +#include "arm/efibind.h" +#elif defined (_M_MIPS64) || defined(__mips64__) || defined(__mips64) +#include "mips64el/efibind.h" +#elif defined (__riscv) && __riscv_xlen == 64 +#include "riscv64/efibind.h" +#elif defined (__loongarch64) +#include "loongarch64/efibind.h" +#else +#error Usupported architecture +#endif + +#include "eficompiler.h" +#include "efidef.h" +#include "efidevp.h" +#include "efipciio.h" +#include "efiprot.h" +#include "eficon.h" +#include "eficonex.h" +#include "efiser.h" +#include "efi_nii.h" +#include "efipxebc.h" +#include "efinet.h" +#include "efiapi.h" +#include "efifs.h" +#include "efierr.h" +#include "efiui.h" +#include "efiip.h" +#include "efiudp.h" +#include "efitcp.h" +#include "efipoint.h" +#include "efishell.h" + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/gnuefi/inc/efi_nii.h b/gnuefi/inc/efi_nii.h new file mode 100644 index 0000000..fdf5cb4 --- /dev/null +++ b/gnuefi/inc/efi_nii.h @@ -0,0 +1,78 @@ +#ifndef _EFI_NII_H +#define _EFI_NII_H + +/*++ +Copyright (c) 2000 Intel Corporation + +Module name: + efi_nii.h + +Abstract: + +Revision history: + 2000-Feb-18 M(f)J GUID updated. + Structure order changed for machine word alignment. + Added StringId[4] to structure. + + 2000-Feb-14 M(f)J Genesis. +--*/ + +#define EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID \ + { 0xE18541CD, 0xF755, 0x4f73, {0x92, 0x8D, 0x64, 0x3C, 0x8A, 0x79, 0xB2, 0x29} } + +#define EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION 0x00010000 +#define EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE_REVISION EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION + +typedef enum { + EfiNetworkInterfaceUndi = 1 +} EFI_NETWORK_INTERFACE_TYPE; + +typedef struct _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL { + + UINT64 Revision; + // Revision of the network interface identifier protocol interface. + + UINT64 ID; + // Address of the first byte of the identifying structure for this + // network interface. This is set to zero if there is no structure. + // + // For PXE/UNDI this is the first byte of the !PXE structure. + + UINT64 ImageAddr; + // Address of the UNrelocated driver/ROM image. This is set + // to zero if there is no driver/ROM image. + // + // For 16-bit UNDI, this is the first byte of the option ROM in + // upper memory. + // + // For 32/64-bit S/W UNDI, this is the first byte of the EFI ROM + // image. + // + // For H/W UNDI, this is set to zero. + + UINT32 ImageSize; + // Size of the UNrelocated driver/ROM image of this network interface. + // This is set to zero if there is no driver/ROM image. + + CHAR8 StringId[4]; + // 4 char ASCII string to go in class identifier (option 60) in DHCP + // and Boot Server discover packets. + // For EfiNetworkInterfaceUndi this field is "UNDI". + // For EfiNetworkInterfaceSnp this field is "SNPN". + + UINT8 Type; + UINT8 MajorVer; + UINT8 MinorVer; + // Information to be placed into the PXE DHCP and Discover packets. + // This is the network interface type and version number that will + // be placed into DHCP option 94 (client network interface identifier). + BOOLEAN Ipv6Supported; + UINT8 IfNum; // interface number to be used with pxeid structure +} EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL, EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE; + +// Note: Because it conflicted with the EDK2 struct name, the +// 'EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL' GUID definition, +// from older versions of gnu-efi, is now obsoleted. +// Use 'EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID' instead. + +#endif // _EFI_NII_H diff --git a/gnuefi/inc/efi_pxe.h b/gnuefi/inc/efi_pxe.h new file mode 100644 index 0000000..d24251f --- /dev/null +++ b/gnuefi/inc/efi_pxe.h @@ -0,0 +1,1743 @@ +#ifndef _EFI_PXE_H +#define _EFI_PXE_H + + +/*++ +Copyright (c) Intel 1999 + +Module name: + efi_pxe.h + +32/64-bit PXE specification: + alpha-4, 99-Dec-17 + +Abstract: + This header file contains all of the PXE type definitions, + structure prototypes, global variables and constants that + are needed for porting PXE to EFI. +--*/ + +#pragma pack(1) + +#define PXE_INTEL_ORDER 1 // Intel order +//#define PXE_NETWORK_ORDER 1 // network order + +#define PXE_UINT64_SUPPORT 1 // UINT64 supported +//#define PXE_NO_UINT64_SUPPORT 1 // UINT64 not supported + +#define PXE_BUSTYPE(a,b,c,d) \ +((((PXE_UINT32)(d) & 0xFF) << 24) | \ +(((PXE_UINT32)(c) & 0xFF) << 16) | \ +(((PXE_UINT32)(b) & 0xFF) << 8) | \ +((PXE_UINT32)(a) & 0xFF)) + +// +// UNDI ROM ID and devive ID signature +// +#define PXE_BUSTYPE_PXE PXE_BUSTYPE('!', 'P', 'X', 'E') + +// +// BUS ROM ID signatures +// +#define PXE_BUSTYPE_PCI PXE_BUSTYPE('P', 'C', 'I', 'R') +#define PXE_BUSTYPE_PC_CARD PXE_BUSTYPE('P', 'C', 'C', 'R') +#define PXE_BUSTYPE_USB PXE_BUSTYPE('U', 'S', 'B', 'R') +#define PXE_BUSTYPE_1394 PXE_BUSTYPE('1', '3', '9', '4') + +#define PXE_SWAP_UINT16(n) \ +((((PXE_UINT16)(n) & 0x00FF) << 8) | \ +(((PXE_UINT16)(n) & 0xFF00) >> 8)) + +#define PXE_SWAP_UINT32(n) \ +((((PXE_UINT32)(n) & 0x000000FF) << 24) | \ +(((PXE_UINT32)(n) & 0x0000FF00) << 8) | \ +(((PXE_UINT32)(n) & 0x00FF0000) >> 8) | \ +(((PXE_UINT32)(n) & 0xFF000000) >> 24)) + +#if PXE_UINT64_SUPPORT != 0 +#define PXE_SWAP_UINT64(n) \ +((((PXE_UINT64)(n) & 0x00000000000000FF) << 56) | \ +(((PXE_UINT64)(n) & 0x000000000000FF00) << 40) | \ +(((PXE_UINT64)(n) & 0x0000000000FF0000) << 24) | \ +(((PXE_UINT64)(n) & 0x00000000FF000000) << 8) | \ +(((PXE_UINT64)(n) & 0x000000FF00000000) >> 8) | \ +(((PXE_UINT64)(n) & 0x0000FF0000000000) >> 24) | \ +(((PXE_UINT64)(n) & 0x00FF000000000000) >> 40) | \ +(((PXE_UINT64)(n) & 0xFF00000000000000) >> 56)) +#endif // PXE_UINT64_SUPPORT + +#if PXE_NO_UINT64_SUPPORT != 0 +#define PXE_SWAP_UINT64(n) \ +{ \ +PXE_UINT32 tmp = (PXE_UINT64)(n)[1]; \ +(PXE_UINT64)(n)[1] = PXE_SWAP_UINT32((PXE_UINT64)(n)[0]); \ +(PXE_UINT64)(n)[0] = tmp; \ +} +#endif // PXE_NO_UINT64_SUPPORT + +#define PXE_CPBSIZE_NOT_USED 0 // zero +#define PXE_DBSIZE_NOT_USED 0 // zero +#define PXE_CPBADDR_NOT_USED (PXE_UINT64)0 // zero +#define PXE_DBADDR_NOT_USED (PXE_UINT64)0 // zero + +#define PXE_CONST const + +#define PXE_VOLATILE volatile + +typedef void PXE_VOID; + +typedef unsigned char PXE_UINT8; + +typedef unsigned short PXE_UINT16; + +typedef unsigned PXE_UINT32; + +#if PXE_UINT64_SUPPORT != 0 +// typedef unsigned long PXE_UINT64; +typedef UINT64 PXE_UINT64; +#endif // PXE_UINT64_SUPPORT + +#if PXE_NO_UINT64_SUPPORT != 0 +typedef PXE_UINT32 PXE_UINT64[2]; +#endif // PXE_NO_UINT64_SUPPORT + +typedef unsigned PXE_UINTN; + +typedef PXE_UINT8 PXE_BOOL; + +#define PXE_FALSE 0 // zero +#define PXE_TRUE (!PXE_FALSE) + +typedef PXE_UINT16 PXE_OPCODE; + +// +// Return UNDI operational state. +// +#define PXE_OPCODE_GET_STATE 0x0000 + +// +// Change UNDI operational state from Stopped to Started. +// +#define PXE_OPCODE_START 0x0001 + +// +// Change UNDI operational state from Started to Stopped. +// +#define PXE_OPCODE_STOP 0x0002 + +// +// Get UNDI initialization information. +// +#define PXE_OPCODE_GET_INIT_INFO 0x0003 + +// +// Get NIC configuration information. +// +#define PXE_OPCODE_GET_CONFIG_INFO 0x0004 + +// +// Changed UNDI operational state from Started to Initialized. +// +#define PXE_OPCODE_INITIALIZE 0x0005 + +// +// Re-initialize the NIC H/W. +// +#define PXE_OPCODE_RESET 0x0006 + +// +// Change the UNDI operational state from Initialized to Started. +// +#define PXE_OPCODE_SHUTDOWN 0x0007 + +// +// Read & change state of external interrupt enables. +// +#define PXE_OPCODE_INTERRUPT_ENABLES 0x0008 + +// +// Read & change state of packet receive filters. +// +#define PXE_OPCODE_RECEIVE_FILTERS 0x0009 + +// +// Read & change station MAC address. +// +#define PXE_OPCODE_STATION_ADDRESS 0x000A + +// +// Read traffic statistics. +// +#define PXE_OPCODE_STATISTICS 0x000B + +// +// Convert multicast IP address to multicast MAC address. +// +#define PXE_OPCODE_MCAST_IP_TO_MAC 0x000C + +// +// Read or change non-volatile storage on the NIC. +// +#define PXE_OPCODE_NVDATA 0x000D + +// +// Get & clear interrupt status. +// +#define PXE_OPCODE_GET_STATUS 0x000E + +// +// Fill media header in packet for transmit. +// +#define PXE_OPCODE_FILL_HEADER 0x000F + +// +// Transmit packet(s). +// +#define PXE_OPCODE_TRANSMIT 0x0010 + +// +// Receive packet. +// +#define PXE_OPCODE_RECEIVE 0x0011 + +// last valid opcode: +#define PXE_OPCODE_VALID_MAX 0x0011 + +// +// Last valid PXE UNDI OpCode number. +// +#define PXE_OPCODE_LAST_VALID 0x0011 + +typedef PXE_UINT16 PXE_OPFLAGS; + +#define PXE_OPFLAGS_NOT_USED 0x0000 + +//////////////////////////////////////// +// UNDI Get State +// + +// No OpFlags + +//////////////////////////////////////// +// UNDI Start +// + +// No OpFlags + +//////////////////////////////////////// +// UNDI Stop +// + +// No OpFlags + +//////////////////////////////////////// +// UNDI Get Init Info +// + +// No Opflags + +//////////////////////////////////////// +// UNDI Get Config Info +// + +// No Opflags + +//////////////////////////////////////// +// UNDI Initialize +// + +#define PXE_OPFLAGS_INITIALIZE_CABLE_DETECT_MASK 0x0001 +#define PXE_OPFLAGS_INITIALIZE_DETECT_CABLE 0x0000 +#define PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE 0x0001 + +//////////////////////////////////////// +// UNDI Reset +// + +#define PXE_OPFLAGS_RESET_DISABLE_INTERRUPTS 0x0001 +#define PXE_OPFLAGS_RESET_DISABLE_FILTERS 0x0002 + +//////////////////////////////////////// +// UNDI Shutdown +// + +// No OpFlags + +//////////////////////////////////////// +// UNDI Interrupt Enables +// + +// +// Select whether to enable or disable external interrupt signals. +// Setting both enable and disable will return PXE_STATCODE_INVALID_OPFLAGS. +// +#define PXE_OPFLAGS_INTERRUPT_OPMASK 0xC000 +#define PXE_OPFLAGS_INTERRUPT_ENABLE 0x8000 +#define PXE_OPFLAGS_INTERRUPT_DISABLE 0x4000 +#define PXE_OPFLAGS_INTERRUPT_READ 0x0000 + +// +// Enable receive interrupts. An external interrupt will be generated +// after a complete non-error packet has been received. +// +#define PXE_OPFLAGS_INTERRUPT_RECEIVE 0x0001 + +// +// Enable transmit interrupts. An external interrupt will be generated +// after a complete non-error packet has been transmitted. +// +#define PXE_OPFLAGS_INTERRUPT_TRANSMIT 0x0002 + +// +// Enable command interrupts. An external interrupt will be generated +// when command execution stops. +// +#define PXE_OPFLAGS_INTERRUPT_COMMAND 0x0004 + +// +// Generate software interrupt. Setting this bit generates an external +// interrupt, if it is supported by the hardware. +// +#define PXE_OPFLAGS_INTERRUPT_SOFTWARE 0x0008 + +//////////////////////////////////////// +// UNDI Receive Filters +// + +// +// Select whether to enable or disable receive filters. +// Setting both enable and disable will return PXE_STATCODE_INVALID_OPCODE. +// +#define PXE_OPFLAGS_RECEIVE_FILTER_OPMASK 0xC000 +#define PXE_OPFLAGS_RECEIVE_FILTER_ENABLE 0x8000 +#define PXE_OPFLAGS_RECEIVE_FILTER_DISABLE 0x4000 +#define PXE_OPFLAGS_RECEIVE_FILTER_READ 0x0000 + +// +// To reset the contents of the multicast MAC address filter list, +// set this OpFlag: +// +#define PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST 0x2000 + +// +// Enable unicast packet receiving. Packets sent to the current station +// MAC address will be received. +// +#define PXE_OPFLAGS_RECEIVE_FILTER_UNICAST 0x0001 + +// +// Enable broadcast packet receiving. Packets sent to the broadcast +// MAC address will be received. +// +#define PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST 0x0002 + +// +// Enable filtered multicast packet receiving. Packets sent to any +// of the multicast MAC addresses in the multicast MAC address filter +// list will be received. If the filter list is empty, no multicast +// +#define PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST 0x0004 + +// +// Enable promiscuous packet receiving. All packets will be received. +// +#define PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS 0x0008 + +// +// Enable promiscuous multicast packet receiving. All multicast +// packets will be received. +// +#define PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST 0x0010 + +//////////////////////////////////////// +// UNDI Station Address +// + +#define PXE_OPFLAGS_STATION_ADDRESS_READ 0x0000 +#define PXE_OPFLAGS_STATION_ADDRESS_RESET 0x0001 + +//////////////////////////////////////// +// UNDI Statistics +// + +#define PXE_OPFLAGS_STATISTICS_READ 0x0000 +#define PXE_OPFLAGS_STATISTICS_RESET 0x0001 + +//////////////////////////////////////// +// UNDI MCast IP to MAC +// + +// +// Identify the type of IP address in the CPB. +// +#define PXE_OPFLAGS_MCAST_IP_TO_MAC_OPMASK 0x0003 +#define PXE_OPFLAGS_MCAST_IPV4_TO_MAC 0x0000 +#define PXE_OPFLAGS_MCAST_IPV6_TO_MAC 0x0001 + +//////////////////////////////////////// +// UNDI NvData +// + +// +// Select the type of non-volatile data operation. +// +#define PXE_OPFLAGS_NVDATA_OPMASK 0x0001 +#define PXE_OPFLAGS_NVDATA_READ 0x0000 +#define PXE_OPFLAGS_NVDATA_WRITE 0x0001 + +//////////////////////////////////////// +// UNDI Get Status +// + +// +// Return current interrupt status. This will also clear any interrupts +// that are currently set. This can be used in a polling routine. The +// interrupt flags are still set and cleared even when the interrupts +// are disabled. +// +#define PXE_OPFLAGS_GET_INTERRUPT_STATUS 0x0001 + +// +// Return list of transmitted buffers for recycling. Transmit buffers +// must not be changed or unallocated until they have recycled. After +// issuing a transmit command, wait for a transmit complete interrupt. +// When a transmit complete interrupt is received, read the transmitted +// buffers. Do not plan on getting one buffer per interrupt. Some +// NICs and UNDIs may transmit multiple buffers per interrupt. +// +#define PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS 0x0002 + +//////////////////////////////////////// +// UNDI Fill Header +// + +#define PXE_OPFLAGS_FILL_HEADER_OPMASK 0x0001 +#define PXE_OPFLAGS_FILL_HEADER_FRAGMENTED 0x0001 +#define PXE_OPFLAGS_FILL_HEADER_WHOLE 0x0000 + +//////////////////////////////////////// +// UNDI Transmit +// + +// +// S/W UNDI only. Return after the packet has been transmitted. A +// transmit complete interrupt will still be generated and the transmit +// buffer will have to be recycled. +// +#define PXE_OPFLAGS_SWUNDI_TRANSMIT_OPMASK 0x0001 +#define PXE_OPFLAGS_TRANSMIT_BLOCK 0x0001 +#define PXE_OPFLAGS_TRANSMIT_DONT_BLOCK 0x0000 + +// +// +// +#define PXE_OPFLAGS_TRANSMIT_OPMASK 0x0002 +#define PXE_OPFLAGS_TRANSMIT_FRAGMENTED 0x0002 +#define PXE_OPFLAGS_TRANSMIT_WHOLE 0x0000 + +//////////////////////////////////////// +// UNDI Receive +// + +// No OpFlags + +typedef PXE_UINT16 PXE_STATFLAGS; + +#define PXE_STATFLAGS_INITIALIZE 0x0000 + +//////////////////////////////////////// +// Common StatFlags that can be returned by all commands. +// + +// +// The COMMAND_COMPLETE and COMMAND_FAILED status flags must be +// implemented by all UNDIs. COMMAND_QUEUED is only needed by UNDIs +// that support command queuing. +// +#define PXE_STATFLAGS_STATUS_MASK 0xC000 +#define PXE_STATFLAGS_COMMAND_COMPLETE 0xC000 +#define PXE_STATFLAGS_COMMAND_FAILED 0x8000 +#define PXE_STATFLAGS_COMMAND_QUEUED 0x4000 +//#define PXE_STATFLAGS_INITIALIZE 0x0000 + +#define PXE_STATFLAGS_DB_WRITE_TRUNCATED 0x2000 + +//////////////////////////////////////// +// UNDI Get State +// + +#define PXE_STATFLAGS_GET_STATE_MASK 0x0003 +#define PXE_STATFLAGS_GET_STATE_INITIALIZED 0x0002 +#define PXE_STATFLAGS_GET_STATE_STARTED 0x0001 +#define PXE_STATFLAGS_GET_STATE_STOPPED 0x0000 + +//////////////////////////////////////// +// UNDI Start +// + +// No additional StatFlags + +//////////////////////////////////////// +// UNDI Get Init Info +// + +#define PXE_STATFLAGS_CABLE_DETECT_MASK 0x0001 +#define PXE_STATFLAGS_CABLE_DETECT_NOT_SUPPORTED 0x0000 +#define PXE_STATFLAGS_CABLE_DETECT_SUPPORTED 0x0001 + + +//////////////////////////////////////// +// UNDI Initialize +// + +#define PXE_STATFLAGS_INITIALIZED_NO_MEDIA 0x0001 + +//////////////////////////////////////// +// UNDI Reset +// + +#define PXE_STATFLAGS_RESET_NO_MEDIA 0x0001 + +//////////////////////////////////////// +// UNDI Shutdown +// + +// No additional StatFlags + +//////////////////////////////////////// +// UNDI Interrupt Enables +// + +// +// If set, receive interrupts are enabled. +// +#define PXE_STATFLAGS_INTERRUPT_RECEIVE 0x0001 + +// +// If set, transmit interrupts are enabled. +// +#define PXE_STATFLAGS_INTERRUPT_TRANSMIT 0x0002 + +// +// If set, command interrupts are enabled. +// +#define PXE_STATFLAGS_INTERRUPT_COMMAND 0x0004 + + +//////////////////////////////////////// +// UNDI Receive Filters +// + +// +// If set, unicast packets will be received. +// +#define PXE_STATFLAGS_RECEIVE_FILTER_UNICAST 0x0001 + +// +// If set, broadcast packets will be received. +// +#define PXE_STATFLAGS_RECEIVE_FILTER_BROADCAST 0x0002 + +// +// If set, multicast packets that match up with the multicast address +// filter list will be received. +// +#define PXE_STATFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST 0x0004 + +// +// If set, all packets will be received. +// +#define PXE_STATFLAGS_RECEIVE_FILTER_PROMISCUOUS 0x0008 + +// +// If set, all multicast packets will be received. +// +#define PXE_STATFLAGS_RECEIVE_FILTER_ALL_MULTICAST 0x0010 + +//////////////////////////////////////// +// UNDI Station Address +// + +// No additional StatFlags + +//////////////////////////////////////// +// UNDI Statistics +// + +// No additional StatFlags + +//////////////////////////////////////// +// UNDI MCast IP to MAC +// + +// No additional StatFlags + +//////////////////////////////////////// +// UNDI NvData +// + +// No additional StatFlags + + +//////////////////////////////////////// +// UNDI Get Status +// + +// +// Use to determine if an interrupt has occurred. +// +#define PXE_STATFLAGS_GET_STATUS_INTERRUPT_MASK 0x000F +#define PXE_STATFLAGS_GET_STATUS_NO_INTERRUPTS 0x0000 + +// +// If set, at least one receive interrupt occurred. +// +#define PXE_STATFLAGS_GET_STATUS_RECEIVE 0x0001 + +// +// If set, at least one transmit interrupt occurred. +// +#define PXE_STATFLAGS_GET_STATUS_TRANSMIT 0x0002 + +// +// If set, at least one command interrupt occurred. +// +#define PXE_STATFLAGS_GET_STATUS_COMMAND 0x0004 + +// +// If set, at least one software interrupt occurred. +// +#define PXE_STATFLAGS_GET_STATUS_SOFTWARE 0x0008 + +// +// This flag is set if the transmitted buffer queue is empty. This flag +// will be set if all transmitted buffer addresses get written into the DB. +// +#define PXE_STATFLAGS_GET_STATUS_TXBUF_QUEUE_EMPTY 0x0010 + +// +// This flag is set if no transmitted buffer addresses were written +// into the DB. (This could be because DBsize was too small.) +// +#define PXE_STATFLAGS_GET_STATUS_NO_TXBUFS_WRITTEN 0x0020 + +//////////////////////////////////////// +// UNDI Fill Header +// + +// No additional StatFlags + +//////////////////////////////////////// +// UNDI Transmit +// + +// No additional StatFlags. + +//////////////////////////////////////// +// UNDI Receive +// + +// No additional StatFlags. + +typedef PXE_UINT16 PXE_STATCODE; + +#define PXE_STATCODE_INITIALIZE 0x0000 + +//////////////////////////////////////// +// Common StatCodes returned by all UNDI commands, UNDI protocol functions +// and BC protocol functions. +// + +#define PXE_STATCODE_SUCCESS 0x0000 + +#define PXE_STATCODE_INVALID_CDB 0x0001 +#define PXE_STATCODE_INVALID_CPB 0x0002 +#define PXE_STATCODE_BUSY 0x0003 +#define PXE_STATCODE_QUEUE_FULL 0x0004 +#define PXE_STATCODE_ALREADY_STARTED 0x0005 +#define PXE_STATCODE_NOT_STARTED 0x0006 +#define PXE_STATCODE_NOT_SHUTDOWN 0x0007 +#define PXE_STATCODE_ALREADY_INITIALIZED 0x0008 +#define PXE_STATCODE_NOT_INITIALIZED 0x0009 +#define PXE_STATCODE_DEVICE_FAILURE 0x000A +#define PXE_STATCODE_NVDATA_FAILURE 0x000B +#define PXE_STATCODE_UNSUPPORTED 0x000C +#define PXE_STATCODE_BUFFER_FULL 0x000D +#define PXE_STATCODE_INVALID_PARAMETER 0x000E +#define PXE_STATCODE_INVALID_UNDI 0x000F +#define PXE_STATCODE_IPV4_NOT_SUPPORTED 0x0010 +#define PXE_STATCODE_IPV6_NOT_SUPPORTED 0x0011 +#define PXE_STATCODE_NOT_ENOUGH_MEMORY 0x0012 +#define PXE_STATCODE_NO_DATA 0x0013 + + +typedef PXE_UINT16 PXE_IFNUM; + +// +// This interface number must be passed to the S/W UNDI Start command. +// +#define PXE_IFNUM_START 0x0000 + +// +// This interface number is returned by the S/W UNDI Get State and +// Start commands if information in the CDB, CPB or DB is invalid. +// +#define PXE_IFNUM_INVALID 0x0000 + +typedef PXE_UINT16 PXE_CONTROL; + +// +// Setting this flag directs the UNDI to queue this command for later +// execution if the UNDI is busy and it supports command queuing. +// If queuing is not supported, a PXE_STATCODE_INVALID_CONTROL error +// is returned. If the queue is full, a PXE_STATCODE_CDB_QUEUE_FULL +// error is returned. +// +#define PXE_CONTROL_QUEUE_IF_BUSY 0x0002 + +// +// These two bit values are used to determine if there are more UNDI +// CDB structures following this one. If the link bit is set, there +// must be a CDB structure following this one. Execution will start +// on the next CDB structure as soon as this one completes successfully. +// If an error is generated by this command, execution will stop. +// +#define PXE_CONTROL_LINK 0x0001 +#define PXE_CONTROL_LAST_CDB_IN_LIST 0x0000 + +typedef PXE_UINT8 PXE_FRAME_TYPE; + +#define PXE_FRAME_TYPE_NONE 0x00 +#define PXE_FRAME_TYPE_UNICAST 0x01 +#define PXE_FRAME_TYPE_BROADCAST 0x02 +#define PXE_FRAME_TYPE_MULTICAST 0x03 +#define PXE_FRAME_TYPE_PROMISCUOUS 0x04 + +typedef PXE_UINT32 PXE_IPV4; + +typedef PXE_UINT32 PXE_IPV6[4]; +#define PXE_MAC_LENGTH 32 + +typedef PXE_UINT8 PXE_MAC_ADDR[PXE_MAC_LENGTH]; + +typedef PXE_UINT8 PXE_IFTYPE; +typedef PXE_UINT16 PXE_MEDIA_PROTOCOL; + +// +// This information is from the ARP section of RFC 1700. +// +// 1 Ethernet (10Mb) [JBP] +// 2 Experimental Ethernet (3Mb) [JBP] +// 3 Amateur Radio AX.25 [PXK] +// 4 Proteon ProNET Token Ring [JBP] +// 5 Chaos [GXP] +// 6 IEEE 802 Networks [JBP] +// 7 ARCNET [JBP] +// 8 Hyperchannel [JBP] +// 9 Lanstar [TU] +// 10 Autonet Short Address [MXB1] +// 11 LocalTalk [JKR1] +// 12 LocalNet (IBM PCNet or SYTEK LocalNET) [JXM] +// 13 Ultra link [RXD2] +// 14 SMDS [GXC1] +// 15 Frame Relay [AGM] +// 16 Asynchronous Transmission Mode (ATM) [JXB2] +// 17 HDLC [JBP] +// 18 Fibre Channel [Yakov Rekhter] +// 19 Asynchronous Transmission Mode (ATM) [Mark Laubach] +// 20 Serial Line [JBP] +// 21 Asynchronous Transmission Mode (ATM) [MXB1] +// + +#define PXE_IFTYPE_ETHERNET 0x01 +#define PXE_IFTYPE_TOKENRING 0x04 +#define PXE_IFTYPE_FIBRE_CHANNEL 0x12 + +typedef struct s_pxe_hw_undi { +PXE_UINT32 Signature; // PXE_ROMID_SIGNATURE +PXE_UINT8 Len; // sizeof(PXE_HW_UNDI) +PXE_UINT8 Fudge; // makes 8-bit cksum equal zero +PXE_UINT8 Rev; // PXE_ROMID_REV +PXE_UINT8 IFcnt; // physical connector count +PXE_UINT8 MajorVer; // PXE_ROMID_MAJORVER +PXE_UINT8 MinorVer; // PXE_ROMID_MINORVER +PXE_UINT16 reserved; // zero, not used +PXE_UINT32 Implementation; // implementation flags +// reserved // vendor use +// PXE_UINT32 Status; // status port +// PXE_UINT32 Command; // command port +// PXE_UINT64 CDBaddr; // CDB address port +} PXE_HW_UNDI; + +// +// Status port bit definitions +// + +// +// UNDI operation state +// +#define PXE_HWSTAT_STATE_MASK 0xC0000000 +#define PXE_HWSTAT_BUSY 0xC0000000 +#define PXE_HWSTAT_INITIALIZED 0x80000000 +#define PXE_HWSTAT_STARTED 0x40000000 +#define PXE_HWSTAT_STOPPED 0x00000000 + +// +// If set, last command failed +// +#define PXE_HWSTAT_COMMAND_FAILED 0x20000000 + +// +// If set, identifies enabled receive filters +// +#define PXE_HWSTAT_PROMISCUOUS_MULTICAST_RX_ENABLED 0x00001000 +#define PXE_HWSTAT_PROMISCUOUS_RX_ENABLED 0x00000800 +#define PXE_HWSTAT_BROADCAST_RX_ENABLED 0x00000400 +#define PXE_HWSTAT_MULTICAST_RX_ENABLED 0x00000200 +#define PXE_HWSTAT_UNICAST_RX_ENABLED 0x00000100 + +// +// If set, identifies enabled external interrupts +// +#define PXE_HWSTAT_SOFTWARE_INT_ENABLED 0x00000080 +#define PXE_HWSTAT_TX_COMPLETE_INT_ENABLED 0x00000040 +#define PXE_HWSTAT_PACKET_RX_INT_ENABLED 0x00000020 +#define PXE_HWSTAT_CMD_COMPLETE_INT_ENABLED 0x00000010 + +// +// If set, identifies pending interrupts +// +#define PXE_HWSTAT_SOFTWARE_INT_PENDING 0x00000008 +#define PXE_HWSTAT_TX_COMPLETE_INT_PENDING 0x00000004 +#define PXE_HWSTAT_PACKET_RX_INT_PENDING 0x00000002 +#define PXE_HWSTAT_CMD_COMPLETE_INT_PENDING 0x00000001 + +// +// Command port definitions +// + +// +// If set, CDB identified in CDBaddr port is given to UNDI. +// If not set, other bits in this word will be processed. +// +#define PXE_HWCMD_ISSUE_COMMAND 0x80000000 +#define PXE_HWCMD_INTS_AND_FILTS 0x00000000 + +// +// Use these to enable/disable receive filters. +// +#define PXE_HWCMD_PROMISCUOUS_MULTICAST_RX_ENABLE 0x00001000 +#define PXE_HWCMD_PROMISCUOUS_RX_ENABLE 0x00000800 +#define PXE_HWCMD_BROADCAST_RX_ENABLE 0x00000400 +#define PXE_HWCMD_MULTICAST_RX_ENABLE 0x00000200 +#define PXE_HWCMD_UNICAST_RX_ENABLE 0x00000100 + +// +// Use these to enable/disable external interrupts +// +#define PXE_HWCMD_SOFTWARE_INT_ENABLE 0x00000080 +#define PXE_HWCMD_TX_COMPLETE_INT_ENABLE 0x00000040 +#define PXE_HWCMD_PACKET_RX_INT_ENABLE 0x00000020 +#define PXE_HWCMD_CMD_COMPLETE_INT_ENABLE 0x00000010 + +// +// Use these to clear pending external interrupts +// +#define PXE_HWCMD_CLEAR_SOFTWARE_INT 0x00000008 +#define PXE_HWCMD_CLEAR_TX_COMPLETE_INT 0x00000004 +#define PXE_HWCMD_CLEAR_PACKET_RX_INT 0x00000002 +#define PXE_HWCMD_CLEAR_CMD_COMPLETE_INT 0x00000001 + +typedef struct s_pxe_sw_undi { +PXE_UINT32 Signature; // PXE_ROMID_SIGNATURE +PXE_UINT8 Len; // sizeof(PXE_SW_UNDI) +PXE_UINT8 Fudge; // makes 8-bit cksum zero +PXE_UINT8 Rev; // PXE_ROMID_REV +PXE_UINT8 IFcnt; // physical connector count +PXE_UINT8 MajorVer; // PXE_ROMID_MAJORVER +PXE_UINT8 MinorVer; // PXE_ROMID_MINORVER +PXE_UINT16 reserved1; // zero, not used +PXE_UINT32 Implementation; // Implementation flags +PXE_UINT64 EntryPoint; // API entry point +PXE_UINT8 reserved2[3]; // zero, not used +PXE_UINT8 BusCnt; // number of bustypes supported +PXE_UINT32 BusType[1]; // list of supported bustypes +} PXE_SW_UNDI; + +typedef union u_pxe_undi { +PXE_HW_UNDI hw; +PXE_SW_UNDI sw; +} PXE_UNDI; + +// +// Signature of !PXE structure +// +#define PXE_ROMID_SIGNATURE PXE_BUSTYPE('!', 'P', 'X', 'E') + +// +// !PXE structure format revision +// +#define PXE_ROMID_REV 0x02 + +// +// UNDI command interface revision. These are the values that get sent +// in option 94 (Client Network Interface Identifier) in the DHCP Discover +// and PXE Boot Server Request packets. +// +#define PXE_ROMID_MAJORVER 0x03 +#define PXE_ROMID_MINORVER 0x00 + +// +// Implementation flags +// +#define PXE_ROMID_IMP_HW_UNDI 0x80000000 +#define PXE_ROMID_IMP_SW_VIRT_ADDR 0x40000000 +#define PXE_ROMID_IMP_64BIT_DEVICE 0x00010000 +#define PXE_ROMID_IMP_FRAG_SUPPORTED 0x00008000 +#define PXE_ROMID_IMP_CMD_LINK_SUPPORTED 0x00004000 +#define PXE_ROMID_IMP_CMD_QUEUE_SUPPORTED 0x00002000 +#define PXE_ROMID_IMP_MULTI_FRAME_SUPPORTED 0x00001000 +#define PXE_ROMID_IMP_NVDATA_SUPPORT_MASK 0x00000C00 +#define PXE_ROMID_IMP_NVDATA_BULK_WRITABLE 0x00000C00 +#define PXE_ROMID_IMP_NVDATA_SPARSE_WRITABLE 0x00000800 +#define PXE_ROMID_IMP_NVDATA_READ_ONLY 0x00000400 +#define PXE_ROMID_IMP_NVDATA_NOT_AVAILABLE 0x00000000 +#define PXE_ROMID_IMP_STATISTICS_SUPPORTED 0x00000200 +#define PXE_ROMID_IMP_STATION_ADDR_SETTABLE 0x00000100 +#define PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED 0x00000080 +#define PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED 0x00000040 +#define PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED 0x00000020 +#define PXE_ROMID_IMP_FILTERED_MULTICAST_RX_SUPPORTED 0x00000010 +#define PXE_ROMID_IMP_SOFTWARE_INT_SUPPORTED 0x00000008 +#define PXE_ROMID_IMP_TX_COMPLETE_INT_SUPPORTED 0x00000004 +#define PXE_ROMID_IMP_PACKET_RX_INT_SUPPORTED 0x00000002 +#define PXE_ROMID_IMP_CMD_COMPLETE_INT_SUPPORTED 0x00000001 + + +typedef struct s_pxe_cdb { +PXE_OPCODE OpCode; +PXE_OPFLAGS OpFlags; +PXE_UINT16 CPBsize; +PXE_UINT16 DBsize; +UINT64 CPBaddr; +UINT64 DBaddr; +PXE_STATCODE StatCode; +PXE_STATFLAGS StatFlags; +PXE_UINT16 IFnum; +PXE_CONTROL Control; +} PXE_CDB; + + +typedef union u_pxe_ip_addr { +PXE_IPV6 IPv6; +PXE_IPV4 IPv4; +} PXE_IP_ADDR; + +typedef union pxe_device { +// +// PCI and PC Card NICs are both identified using bus, device +// and function numbers. For PC Card, this may require PC +// Card services to be loaded in the BIOS or preboot +// environment. +// +struct { +// +// See S/W UNDI ROMID structure definition for PCI and +// PCC BusType definitions. +// +PXE_UINT32 BusType; + +// +// Bus, device & function numbers that locate this device. +// +PXE_UINT16 Bus; +PXE_UINT8 Device; +PXE_UINT8 Function; +} PCI, PCC; + +// +// %%TBD - More information is needed about enumerating +// USB and 1394 devices. +// +struct { +PXE_UINT32 BusType; +PXE_UINT32 tdb; +} USB, _1394; +} PXE_DEVICE; + +// cpb and db definitions + +#define MAX_PCI_CONFIG_LEN 64 // # of dwords +#define MAX_EEPROM_LEN 128 // #of dwords +#define MAX_XMIT_BUFFERS 32 // recycling Q length for xmit_done +#define MAX_MCAST_ADDRESS_CNT 8 + +typedef struct s_pxe_cpb_start { + // + // PXE_VOID Delay(PXE_UINT64 microseconds); + // + // UNDI will never request a delay smaller than 10 microseconds + // and will always request delays in increments of 10 microseconds. + // The Delay() CallBack routine must delay between n and n + 10 + // microseconds before returning control to the UNDI. + // + // This field cannot be set to zero. + // + PXE_UINT64 Delay; + + // + // PXE_VOID Block(PXE_UINT32 enable); + // + // UNDI may need to block multi-threaded/multi-processor access to + // critical code sections when programming or accessing the network + // device. To this end, a blocking service is needed by the UNDI. + // When UNDI needs a block, it will call Block() passing a non-zero + // value. When UNDI no longer needs a block, it will call Block() + // with a zero value. When called, if the Block() is already enabled, + // do not return control to the UNDI until the previous Block() is + // disabled. + // + // This field cannot be set to zero. + // + PXE_UINT64 Block; + + // + // PXE_VOID Virt2Phys(PXE_UINT64 virtual, PXE_UINT64 physical_ptr); + // + // UNDI will pass the virtual address of a buffer and the virtual + // address of a 64-bit physical buffer. Convert the virtual address + // to a physical address and write the result to the physical address + // buffer. If virtual and physical addresses are the same, just + // copy the virtual address to the physical address buffer. + // + // This field can be set to zero if virtual and physical addresses + // are equal. + // + PXE_UINT64 Virt2Phys; + // + // PXE_VOID Mem_IO(PXE_UINT8 read_write, PXE_UINT8 len, PXE_UINT64 port, + // PXE_UINT64 buf_addr); + // + // UNDI will read or write the device io space using this call back + // function. It passes the number of bytes as the len parameter and it + // will be either 1,2,4 or 8. + // + // This field can not be set to zero. + // + PXE_UINT64 Mem_IO; +} PXE_CPB_START; + +#define PXE_DELAY_MILLISECOND 1000 +#define PXE_DELAY_SECOND 1000000 +#define PXE_IO_READ 0 +#define PXE_IO_WRITE 1 +#define PXE_MEM_READ 2 +#define PXE_MEM_WRITE 4 + + +typedef struct s_pxe_db_get_init_info { + // + // Minimum length of locked memory buffer that must be given to + // the Initialize command. Giving UNDI more memory will generally + // give better performance. + // + // If MemoryRequired is zero, the UNDI does not need and will not + // use system memory to receive and transmit packets. + // + PXE_UINT32 MemoryRequired; + + // + // Maximum frame data length for Tx/Rx excluding the media header. + // + PXE_UINT32 FrameDataLen; + + // + // Supported link speeds are in units of mega bits. Common ethernet + // values are 10, 100 and 1000. Unused LinkSpeeds[] entries are zero + // filled. + // + PXE_UINT32 LinkSpeeds[4]; + + // + // Number of non-volatile storage items. + // + PXE_UINT32 NvCount; + + // + // Width of non-volatile storage item in bytes. 0, 1, 2 or 4 + // + PXE_UINT16 NvWidth; + + // + // Media header length. This is the typical media header length for + // this UNDI. This information is needed when allocating receive + // and transmit buffers. + // + PXE_UINT16 MediaHeaderLen; + + // + // Number of bytes in the NIC hardware (MAC) address. + // + PXE_UINT16 HWaddrLen; + + // + // Maximum number of multicast MAC addresses in the multicast + // MAC address filter list. + // + PXE_UINT16 MCastFilterCnt; + + // + // Default number and size of transmit and receive buffers that will + // be allocated by the UNDI. If MemoryRequired is non-zero, this + // allocation will come out of the memory buffer given to the Initialize + // command. If MemoryRequired is zero, this allocation will come out of + // memory on the NIC. + // + PXE_UINT16 TxBufCnt; + PXE_UINT16 TxBufSize; + PXE_UINT16 RxBufCnt; + PXE_UINT16 RxBufSize; + + // + // Hardware interface types defined in the Assigned Numbers RFC + // and used in DHCP and ARP packets. + // See the PXE_IFTYPE typedef and PXE_IFTYPE_xxx macros. + // + PXE_UINT8 IFtype; + + // + // Supported duplex. See PXE_DUPLEX_xxxxx #defines below. + // + PXE_UINT8 Duplex; + + // + // Supported loopback options. See PXE_LOOPBACK_xxxxx #defines below. + // + PXE_UINT8 LoopBack; +} PXE_DB_GET_INIT_INFO; + +#define PXE_MAX_TXRX_UNIT_ETHER 1500 + +#define PXE_HWADDR_LEN_ETHER 0x0006 +#define PXE_MAC_HEADER_LEN_ETHER 0x000E + +#define PXE_DUPLEX_ENABLE_FULL_SUPPORTED 1 +#define PXE_DUPLEX_FORCE_FULL_SUPPORTED 2 + +#define PXE_LOOPBACK_INTERNAL_SUPPORTED 1 +#define PXE_LOOPBACK_EXTERNAL_SUPPORTED 2 + + +typedef struct s_pxe_pci_config_info { + // + // This is the flag field for the PXE_DB_GET_CONFIG_INFO union. + // For PCI bus devices, this field is set to PXE_BUSTYPE_PCI. + // + PXE_UINT32 BusType; + + // + // This identifies the PCI network device that this UNDI interface + // is bound to. + // + PXE_UINT16 Bus; + PXE_UINT8 Device; + PXE_UINT8 Function; + + // + // This is a copy of the PCI configuration space for this + // network device. + // + union { + PXE_UINT8 Byte[256]; + PXE_UINT16 Word[128]; + PXE_UINT32 Dword[64]; + } Config; +} PXE_PCI_CONFIG_INFO; + + +typedef struct s_pxe_pcc_config_info { + // + // This is the flag field for the PXE_DB_GET_CONFIG_INFO union. + // For PCC bus devices, this field is set to PXE_BUSTYPE_PCC. + // + PXE_UINT32 BusType; + + // + // This identifies the PCC network device that this UNDI interface + // is bound to. + // + PXE_UINT16 Bus; + PXE_UINT8 Device; + PXE_UINT8 Function; + + // + // This is a copy of the PCC configuration space for this + // network device. + // + union { + PXE_UINT8 Byte[256]; + PXE_UINT16 Word[128]; + PXE_UINT32 Dword[64]; + } Config; +} PXE_PCC_CONFIG_INFO; + + +typedef struct s_pxe_usb_config_info { + PXE_UINT32 BusType; + // %%TBD What should we return here... +} PXE_USB_CONFIG_INFO; + + +typedef struct s_pxe_1394_config_info { + PXE_UINT32 BusType; + // %%TBD What should we return here... +} PXE_1394_CONFIG_INFO; + + +typedef union u_pxe_db_get_config_info { + PXE_PCI_CONFIG_INFO pci; + PXE_PCC_CONFIG_INFO pcc; + PXE_USB_CONFIG_INFO usb; + PXE_1394_CONFIG_INFO _1394; +} PXE_DB_GET_CONFIG_INFO; + + +typedef struct s_pxe_cpb_initialize { + // + // Address of first (lowest) byte of the memory buffer. This buffer must + // be in contiguous physical memory and cannot be swapped out. The UNDI + // will be using this for transmit and receive buffering. + // + PXE_UINT64 MemoryAddr; + + // + // MemoryLength must be greater than or equal to MemoryRequired + // returned by the Get Init Info command. + // + PXE_UINT32 MemoryLength; + + // + // Desired link speed in Mbit/sec. Common ethernet values are 10, 100 + // and 1000. Setting a value of zero will auto-detect and/or use the + // default link speed (operation depends on UNDI/NIC functionality). + // + PXE_UINT32 LinkSpeed; + + // + // Suggested number and size of receive and transmit buffers to + // allocate. If MemoryAddr and MemoryLength are non-zero, this + // allocation comes out of the supplied memory buffer. If MemoryAddr + // and MemoryLength are zero, this allocation comes out of memory + // on the NIC. + // + // If these fields are set to zero, the UNDI will allocate buffer + // counts and sizes as it sees fit. + // + PXE_UINT16 TxBufCnt; + PXE_UINT16 TxBufSize; + PXE_UINT16 RxBufCnt; + PXE_UINT16 RxBufSize; + + // + // The following configuration parameters are optional and must be zero + // to use the default values. + // + PXE_UINT8 Duplex; + + PXE_UINT8 LoopBack; +} PXE_CPB_INITIALIZE; + + +#define PXE_DUPLEX_DEFAULT 0x00 +#define PXE_FORCE_FULL_DUPLEX 0x01 +#define PXE_ENABLE_FULL_DUPLEX 0x02 + +#define LOOPBACK_NORMAL 0 +#define LOOPBACK_INTERNAL 1 +#define LOOPBACK_EXTERNAL 2 + + +typedef struct s_pxe_db_initialize { + // + // Actual amount of memory used from the supplied memory buffer. This + // may be less that the amount of memory suppllied and may be zero if + // the UNDI and network device do not use external memory buffers. + // + // Memory used by the UNDI and network device is allocated from the + // lowest memory buffer address. + // + PXE_UINT32 MemoryUsed; + + // + // Actual number and size of receive and transmit buffers that were + // allocated. + // + PXE_UINT16 TxBufCnt; + PXE_UINT16 TxBufSize; + PXE_UINT16 RxBufCnt; + PXE_UINT16 RxBufSize; +} PXE_DB_INITIALIZE; + + +typedef struct s_pxe_cpb_receive_filters { + // + // List of multicast MAC addresses. This list, if present, will + // replace the existing multicast MAC address filter list. + // + PXE_MAC_ADDR MCastList[MAX_MCAST_ADDRESS_CNT]; +} PXE_CPB_RECEIVE_FILTERS; + + +typedef struct s_pxe_db_receive_filters { + // + // Filtered multicast MAC address list. + // + PXE_MAC_ADDR MCastList[MAX_MCAST_ADDRESS_CNT]; +} PXE_DB_RECEIVE_FILTERS; + + +typedef struct s_pxe_cpb_station_address { + // + // If supplied and supported, the current station MAC address + // will be changed. + // + PXE_MAC_ADDR StationAddr; +} PXE_CPB_STATION_ADDRESS; + + +typedef struct s_pxe_dpb_station_address { + // + // Current station MAC address. + // + PXE_MAC_ADDR StationAddr; + + // + // Station broadcast MAC address. + // + PXE_MAC_ADDR BroadcastAddr; + + // + // Permanent station MAC address. + // + PXE_MAC_ADDR PermanentAddr; +} PXE_DB_STATION_ADDRESS; + + +typedef struct s_pxe_db_statistics { + // + // Bit field identifying what statistic data is collected by the + // UNDI/NIC. + // If bit 0x00 is set, Data[0x00] is collected. + // If bit 0x01 is set, Data[0x01] is collected. + // If bit 0x20 is set, Data[0x20] is collected. + // If bit 0x21 is set, Data[0x21] is collected. + // Etc. + // + PXE_UINT64 Supported; + + // + // Statistic data. + // + PXE_UINT64 Data[64]; +} PXE_DB_STATISTICS; + +// +// Total number of frames received. Includes frames with errors and +// dropped frames. +// +#define PXE_STATISTICS_RX_TOTAL_FRAMES 0x00 + +// +// Number of valid frames received and copied into receive buffers. +// +#define PXE_STATISTICS_RX_GOOD_FRAMES 0x01 + +// +// Number of frames below the minimum length for the media. +// This would be <64 for ethernet. +// +#define PXE_STATISTICS_RX_UNDERSIZE_FRAMES 0x02 + +// +// Number of frames longer than the maxminum length for the +// media. This would be >1500 for ethernet. +// +#define PXE_STATISTICS_RX_OVERSIZE_FRAMES 0x03 + +// +// Valid frames that were dropped because receive buffers were full. +// +#define PXE_STATISTICS_RX_DROPPED_FRAMES 0x04 + +// +// Number of valid unicast frames received and not dropped. +// +#define PXE_STATISTICS_RX_UNICAST_FRAMES 0x05 + +// +// Number of valid broadcast frames received and not dropped. +// +#define PXE_STATISTICS_RX_BROADCAST_FRAMES 0x06 + +// +// Number of valid mutlicast frames received and not dropped. +// +#define PXE_STATISTICS_RX_MULTICAST_FRAMES 0x07 + +// +// Number of frames w/ CRC or alignment errors. +// +#define PXE_STATISTICS_RX_CRC_ERROR_FRAMES 0x08 + +// +// Total number of bytes received. Includes frames with errors +// and dropped frames. +// +#define PXE_STATISTICS_RX_TOTAL_BYTES 0x09 + +// +// Transmit statistics. +// +#define PXE_STATISTICS_TX_TOTAL_FRAMES 0x0A +#define PXE_STATISTICS_TX_GOOD_FRAMES 0x0B +#define PXE_STATISTICS_TX_UNDERSIZE_FRAMES 0x0C +#define PXE_STATISTICS_TX_OVERSIZE_FRAMES 0x0D +#define PXE_STATISTICS_TX_DROPPED_FRAMES 0x0E +#define PXE_STATISTICS_TX_UNICAST_FRAMES 0x0F +#define PXE_STATISTICS_TX_BROADCAST_FRAMES 0x10 +#define PXE_STATISTICS_TX_MULTICAST_FRAMES 0x11 +#define PXE_STATISTICS_TX_CRC_ERROR_FRAMES 0x12 +#define PXE_STATISTICS_TX_TOTAL_BYTES 0x13 + +// +// Number of collisions detection on this subnet. +// +#define PXE_STATISTICS_COLLISIONS 0x14 + +// +// Number of frames destined for unsupported protocol. +// +#define PXE_STATISTICS_UNSUPPORTED_PROTOCOL 0x15 + + +typedef struct s_pxe_cpb_mcast_ip_to_mac { + // + // Multicast IP address to be converted to multicast MAC address. + // + PXE_IP_ADDR IP; +} PXE_CPB_MCAST_IP_TO_MAC; + + +typedef struct s_pxe_db_mcast_ip_to_mac { + // + // Multicast MAC address. + // + PXE_MAC_ADDR MAC; +} PXE_DB_MCAST_IP_TO_MAC; + + +typedef struct s_pxe_cpb_nvdata_sparse { + // + // NvData item list. Only items in this list will be updated. + // + struct { + // Non-volatile storage address to be changed. + PXE_UINT32 Addr; + + // Data item to write into above storage address. + + union { + PXE_UINT8 Byte; + PXE_UINT16 Word; + PXE_UINT32 Dword; + } Data; + } Item[MAX_EEPROM_LEN]; +} PXE_CPB_NVDATA_SPARSE; + + +// +// When using bulk update, the size of the CPB structure must be +// the same size as the non-volatile NIC storage. +// +typedef union u_pxe_cpb_nvdata_bulk { + // + // Array of byte-wide data items. + // + PXE_UINT8 Byte[MAX_EEPROM_LEN << 2]; + + // + // Array of word-wide data items. + // + PXE_UINT16 Word[MAX_EEPROM_LEN << 1]; + + // + // Array of dword-wide data items. + // + PXE_UINT32 Dword[MAX_EEPROM_LEN]; +} PXE_CPB_NVDATA_BULK; + +typedef struct s_pxe_db_nvdata { + + // Arrays of data items from non-volatile storage. + + union { + // + // Array of byte-wide data items. + // + PXE_UINT8 Byte[MAX_EEPROM_LEN << 2]; + + // + // Array of word-wide data items. + // + PXE_UINT16 Word[MAX_EEPROM_LEN << 1]; + + // Array of dword-wide data items. + + PXE_UINT32 Dword[MAX_EEPROM_LEN]; + } Data; +} PXE_DB_NVDATA; + + +typedef struct s_pxe_db_get_status { + // + // Length of next receive frame (header + data). If this is zero, + // there is no next receive frame available. + // + PXE_UINT32 RxFrameLen; + + // + // Reserved, set to zero. + // + PXE_UINT32 reserved; + + // + // Addresses of transmitted buffers that need to be recycled. + // + PXE_UINT64 TxBuffer[MAX_XMIT_BUFFERS]; +} PXE_DB_GET_STATUS; + + + +typedef struct s_pxe_cpb_fill_header { + // + // Source and destination MAC addresses. These will be copied into + // the media header without doing byte swapping. + // + PXE_MAC_ADDR SrcAddr; + PXE_MAC_ADDR DestAddr; + + // + // Address of first byte of media header. The first byte of packet data + // follows the last byte of the media header. + // + PXE_UINT64 MediaHeader; + + // + // Length of packet data in bytes (not including the media header). + // + PXE_UINT32 PacketLen; + + // + // Protocol type. This will be copied into the media header without + // doing byte swapping. Protocol type numbers can be obtained from + // the Assigned Numbers RFC 1700. + // + PXE_UINT16 Protocol; + + // + // Length of the media header in bytes. + // + PXE_UINT16 MediaHeaderLen; +} PXE_CPB_FILL_HEADER; + + +#define PXE_PROTOCOL_ETHERNET_IP 0x0800 +#define PXE_PROTOCOL_ETHERNET_ARP 0x0806 +#define MAX_XMIT_FRAGMENTS 16 + +typedef struct s_pxe_cpb_fill_header_fragmented { + // + // Source and destination MAC addresses. These will be copied into + // the media header without doing byte swapping. + // + PXE_MAC_ADDR SrcAddr; + PXE_MAC_ADDR DestAddr; + + // + // Length of packet data in bytes (not including the media header). + // + PXE_UINT32 PacketLen; + + // + // Protocol type. This will be copied into the media header without + // doing byte swapping. Protocol type numbers can be obtained from + // the Assigned Numbers RFC 1700. + // + PXE_MEDIA_PROTOCOL Protocol; + + // + // Length of the media header in bytes. + // + PXE_UINT16 MediaHeaderLen; + + // + // Number of packet fragment descriptors. + // + PXE_UINT16 FragCnt; + + // + // Reserved, must be set to zero. + // + PXE_UINT16 reserved; + + // + // Array of packet fragment descriptors. The first byte of the media + // header is the first byte of the first fragment. + // + struct { + // + // Address of this packet fragment. + // + PXE_UINT64 FragAddr; + + // + // Length of this packet fragment. + // + PXE_UINT32 FragLen; + + // + // Reserved, must be set to zero. + // + PXE_UINT32 reserved; + } FragDesc[MAX_XMIT_FRAGMENTS]; +} PXE_CPB_FILL_HEADER_FRAGMENTED; + + + +typedef struct s_pxe_cpb_transmit { + // + // Address of first byte of frame buffer. This is also the first byte + // of the media header. + // + PXE_UINT64 FrameAddr; + + // + // Length of the data portion of the frame buffer in bytes. Do not + // include the length of the media header. + // + PXE_UINT32 DataLen; + + // + // Length of the media header in bytes. + // + PXE_UINT16 MediaheaderLen; + + // + // Reserved, must be zero. + // + PXE_UINT16 reserved; +} PXE_CPB_TRANSMIT; + + + +typedef struct s_pxe_cpb_transmit_fragments { + // + // Length of packet data in bytes (not including the media header). + // + PXE_UINT32 FrameLen; + + // + // Length of the media header in bytes. + // + PXE_UINT16 MediaheaderLen; + + // + // Number of packet fragment descriptors. + // + PXE_UINT16 FragCnt; + + // + // Array of frame fragment descriptors. The first byte of the first + // fragment is also the first byte of the media header. + // + struct { + // + // Address of this frame fragment. + // + PXE_UINT64 FragAddr; + + // + // Length of this frame fragment. + // + PXE_UINT32 FragLen; + + // + // Reserved, must be set to zero. + // + PXE_UINT32 reserved; + } FragDesc[MAX_XMIT_FRAGMENTS]; +} PXE_CPB_TRANSMIT_FRAGMENTS; + + +typedef struct s_pxe_cpb_receive { + // + // Address of first byte of receive buffer. This is also the first byte + // of the frame header. + // + PXE_UINT64 BufferAddr; + + // + // Length of receive buffer. This must be large enough to hold the + // received frame (media header + data). If the length of smaller than + // the received frame, data will be lost. + // + PXE_UINT32 BufferLen; + + // + // Reserved, must be set to zero. + // + PXE_UINT32 reserved; +} PXE_CPB_RECEIVE; + + +typedef struct s_pxe_db_receive { + // + // Source and destination MAC addresses from media header. + // + PXE_MAC_ADDR SrcAddr; + PXE_MAC_ADDR DestAddr; + + // + // Length of received frame. May be larger than receive buffer size. + // The receive buffer will not be overwritten. This is how to tell + // if data was lost because the receive buffer was too small. + // + PXE_UINT32 FrameLen; + + // + // Protocol type from media header. + // + PXE_MEDIA_PROTOCOL Protocol; + + // + // Length of media header in received frame. + // + PXE_UINT16 MediaHeaderLen; + + // + // Type of receive frame. + // + PXE_FRAME_TYPE Type; + + // + // Reserved, must be zero. + // + PXE_UINT8 reserved[7]; + +} PXE_DB_RECEIVE; + +#pragma pack() + +/* EOF - efi_pxe.h */ +#endif /* _EFI_PXE_H */ + diff --git a/gnuefi/inc/efiapi.h b/gnuefi/inc/efiapi.h new file mode 100644 index 0000000..778d513 --- /dev/null +++ b/gnuefi/inc/efiapi.h @@ -0,0 +1,1034 @@ +#ifndef _EFI_API_H +#define _EFI_API_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efiapi.h + +Abstract: + + Global EFI runtime & boot service interfaces + + + + +Revision History + +--*/ + +// +// EFI Specification Revision +// + +#define EFI_SPECIFICATION_REVISION_MAJORMINOR(major, minor) ((major<<16) | (minor)) +#define EFI_SPECIFICATION_MAJOR_REVISION 1 +#define EFI_SPECIFICATION_MINOR_REVISION 02 +#define EFI_SPECIFICATION_VERSION EFI_SPECIFICATION_REVISION_MAJORMINOR(EFI_SPECIFICATION_MAJOR_REVISION, EFI_SPECIFICATION_MINOR_REVISION) + +// +// Declare forward referenced data structures +// + +INTERFACE_DECL(_EFI_SYSTEM_TABLE); + +// +// EFI Memory +// + +typedef +EFI_STATUS +(EFIAPI *EFI_ALLOCATE_PAGES) ( + IN EFI_ALLOCATE_TYPE Type, + IN EFI_MEMORY_TYPE MemoryType, + IN UINTN NoPages, + OUT EFI_PHYSICAL_ADDRESS *Memory + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FREE_PAGES) ( + IN EFI_PHYSICAL_ADDRESS Memory, + IN UINTN NoPages + ); + +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 + ); + +#define NextMemoryDescriptor(Ptr,Size) ((EFI_MEMORY_DESCRIPTOR *) (((UINT8 *) Ptr) + Size)) + + +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 +EFI_STATUS +(EFIAPI *EFI_SET_VIRTUAL_ADDRESS_MAP) ( + IN UINTN MemoryMapSize, + IN UINTN DescriptorSize, + IN UINT32 DescriptorVersion, + IN EFI_MEMORY_DESCRIPTOR *VirtualMap + ); + + +#define EFI_OPTIONAL_PTR 0x00000001 +#define EFI_INTERNAL_FNC 0x00000002 // Pointer to internal runtime fnc +#define EFI_INTERNAL_PTR 0x00000004 // Pointer to internal runtime data + + +typedef +EFI_STATUS +(EFIAPI *EFI_CONVERT_POINTER) ( + IN UINTN DebugDisposition, + IN OUT VOID **Address + ); + + +// +// EFI Events +// + +#define EVT_TIMER 0x80000000 +#define EVT_RUNTIME 0x40000000 +#define EVT_RUNTIME_CONTEXT 0x20000000 + +#define EVT_NOTIFY_WAIT 0x00000100 +#define EVT_NOTIFY_SIGNAL 0x00000200 + +#define EVT_SIGNAL_EXIT_BOOT_SERVICES 0x00000201 +#define EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE 0x60000202 + +#define EVT_EFI_SIGNAL_MASK 0x000000FF +#define EVT_EFI_SIGNAL_MAX 4 + +#define EFI_EVENT_TIMER EVT_TIMER +#define EFI_EVENT_RUNTIME EVT_RUNTIME +#define EFI_EVENT_RUNTIME_CONTEXT EVT_RUNTIME_CONTEXT +#define EFI_EVENT_NOTIFY_WAIT EVT_NOTIFY_WAIT +#define EFI_EVENT_NOTIFY_SIGNAL EVT_NOTIFY_SIGNAL +#define EFI_EVENT_SIGNAL_EXIT_BOOT_SERVICES EVT_SIGNAL_EXIT_BOOT_SERVICES +#define EFI_EVENT_SIGNAL_VIRTUAL_ADDRESS_CHANGE EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE +#define EFI_EVENT_EFI_SIGNAL_MASK EVT_EFI_SIGNAL_MASK +#define EFI_EVENT_EFI_SIGNAL_MAX EVT_EFI_SIGNAL_MAX + + +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 enum { + TimerCancel, + TimerPeriodic, + TimerRelative, + TimerTypeMax +} EFI_TIMER_DELAY; + +typedef +EFI_STATUS +(EFIAPI *EFI_SET_TIMER) ( + IN EFI_EVENT Event, + IN EFI_TIMER_DELAY Type, + IN UINT64 TriggerTime + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SIGNAL_EVENT) ( + IN EFI_EVENT Event + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_WAIT_FOR_EVENT) ( + IN UINTN NumberOfEvents, + IN EFI_EVENT *Event, + OUT UINTN *Index + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_CLOSE_EVENT) ( + IN EFI_EVENT Event + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_CHECK_EVENT) ( + IN EFI_EVENT Event + ); + +// +// Task priority level +// + +#define TPL_APPLICATION 4 +#define TPL_CALLBACK 8 +#define TPL_NOTIFY 16 +#define TPL_HIGH_LEVEL 31 +#define EFI_TPL_APPLICATION TPL_APPLICATION +#define EFI_TPL_CALLBACK TPL_CALLBACK +#define EFI_TPL_NOTIFY TPL_NOTIFY +#define EFI_TPL_HIGH_LEVEL TPL_HIGH_LEVEL +typedef +EFI_TPL +(EFIAPI *EFI_RAISE_TPL) ( + IN EFI_TPL NewTpl + ); + +typedef +VOID +(EFIAPI *EFI_RESTORE_TPL) ( + IN EFI_TPL OldTpl + ); + + +// +// EFI platform varibles +// + +#define EFI_GLOBAL_VARIABLE \ + { 0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C} } + +// Variable attributes +#define EFI_VARIABLE_NON_VOLATILE 0x00000001 +#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x00000002 +#define EFI_VARIABLE_RUNTIME_ACCESS 0x00000004 +#define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x00000008 +#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x00000010 +#define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x00000020 +#define EFI_VARIABLE_APPEND_WRITE 0x00000040 +#define EFI_VARIABLE_ENHANCED_AUTHENTICATED_ACCESS 0x00000080 + +// Variable size limitation +#define EFI_MAXIMUM_VARIABLE_SIZE 1024 + +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 + ); + + +// +// EFI Time +// + +typedef struct { + UINT32 Resolution; // 1e-6 parts per million + UINT32 Accuracy; // hertz + BOOLEAN SetsToZero; // Set clears sub-second time +} EFI_TIME_CAPABILITIES; + + +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 + ); + + +// +// Image functions +// + + +// PE32+ Subsystem type for EFI images + +#if !defined(IMAGE_SUBSYSTEM_EFI_APPLICATION) +#define IMAGE_SUBSYSTEM_EFI_APPLICATION 10 +#define IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER 11 +#define IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER 12 +#endif + +// PE32+ Machine type for EFI images + +#if !defined(EFI_IMAGE_MACHINE_IA32) +#define EFI_IMAGE_MACHINE_IA32 0x014c +#endif + +#if !defined(EFI_IMAGE_MACHINE_IA64) +#define EFI_IMAGE_MACHINE_IA64 0x0200 +#endif + +#if !defined(EFI_IMAGE_MACHINE_EBC) +#define EFI_IMAGE_MACHINE_EBC 0x0EBC +#endif + +#if !defined(EFI_IMAGE_MACHINE_X64) +#define EFI_IMAGE_MACHINE_X64 0x8664 +#endif + +#if !defined(EFI_IMAGE_MACHINE_ARMTHUMB_MIXED) +#define EFI_IMAGE_MACHINE_ARMTHUMB_MIXED 0x01C2 +#endif + +#if !defined(EFI_IMAGE_MACHINE_AARCH64) +#define EFI_IMAGE_MACHINE_AARCH64 0xAA64 +#endif + +#if !defined(EFI_IMAGE_MACHINE_RISCV32) +#define EFI_IMAGE_MACHINE_RISCV32 0x5032 +#endif + +#if !defined(EFI_IMAGE_MACHINE_RISCV64) +#define EFI_IMAGE_MACHINE_RISCV64 0x5064 +#endif + +#if !defined(EFI_IMAGE_MACHINE_RISCV128) +#define EFI_IMAGE_MACHINE_RISCV128 0x5128 +#endif + +#if !defined(EFI_IMAGE_MACHINE_LOONGARCH32) +#define EFI_IMAGE_MACHINE_LOONGARCH32 0x6232 +#endif + +#if !defined(EFI_IMAGE_MACHINE_LOONGARCH64) +#define EFI_IMAGE_MACHINE_LOONGARCH64 0x6264 +#endif + +// Image Entry prototype + +typedef +EFI_STATUS +(EFIAPI *EFI_IMAGE_ENTRY_POINT) ( + IN EFI_HANDLE ImageHandle, + IN struct _EFI_SYSTEM_TABLE *SystemTable + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IMAGE_LOAD) ( + IN BOOLEAN BootPolicy, + IN EFI_HANDLE ParentImageHandle, + IN EFI_DEVICE_PATH *FilePath, + 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 + ); + + +// Image handle +/*#define LOADED_IMAGE_PROTOCOL \ + { 0x5B1B31A1, 0x9562, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} } + +#define EFI_IMAGE_INFORMATION_REVISION 0x1000 +typedef struct { + UINT32 Revision; + EFI_HANDLE ParentHandle; + struct _EFI_SYSTEM_TABLE *SystemTable; + + // Source location of image + EFI_HANDLE DeviceHandle; + EFI_DEVICE_PATH *FilePath; + VOID *Reserved; + + // Images load options + UINT32 LoadOptionsSize; + VOID *LoadOptions; + + // Location of where image was loaded + VOID *ImageBase; + UINT64 ImageSize; + EFI_MEMORY_TYPE ImageCodeType; + EFI_MEMORY_TYPE ImageDataType; + + // If the driver image supports a dynamic unload request + EFI_IMAGE_UNLOAD Unload; + +} EFI_LOADED_IMAGE;*/ + + +typedef +EFI_STATUS +(EFIAPI *EFI_EXIT_BOOT_SERVICES) ( + IN EFI_HANDLE ImageHandle, + IN UINTN MapKey + ); + +// +// Misc +// + + +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 *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 + ); + +#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL 0x00000001 +#define EFI_OPEN_PROTOCOL_GET_PROTOCOL 0x00000002 +#define EFI_OPEN_PROTOCOL_TEST_PROTOCOL 0x00000004 +#define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008 +#define EFI_OPEN_PROTOCOL_BY_DRIVER 0x00000010 +#define EFI_OPEN_PROTOCOL_EXCLUSIVE 0x00000020 + +typedef +EFI_STATUS +(EFIAPI *EFI_OPEN_PROTOCOL) ( + IN EFI_HANDLE Handle, + IN EFI_GUID *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 *Protocol, + IN EFI_HANDLE AgentHandle, + IN EFI_HANDLE ControllerHandle + ); + +typedef struct { + EFI_HANDLE AgentHandle; + EFI_HANDLE ControllerHandle; + UINT32 Attributes; + UINT32 OpenCount; +} EFI_OPEN_PROTOCOL_INFORMATION_ENTRY; + +typedef +EFI_STATUS +(EFIAPI *EFI_OPEN_PROTOCOL_INFORMATION) ( + IN EFI_HANDLE Handle, + IN EFI_GUID *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 ***ProtocolBuffer, + OUT UINTN *ProtocolBufferCount + ); + +typedef enum { + AllHandles, + ByRegisterNotify, + ByProtocol +} EFI_LOCATE_SEARCH_TYPE; + +typedef +EFI_STATUS +(EFIAPI *EFI_LOCATE_HANDLE_BUFFER) ( + IN EFI_LOCATE_SEARCH_TYPE SearchType, + IN EFI_GUID *Protocol OPTIONAL, + IN VOID *SearchKey OPTIONAL, + IN OUT UINTN *NoHandles, + OUT EFI_HANDLE **Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_LOCATE_PROTOCOL) ( + IN EFI_GUID *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 OUT 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_CREATE_EVENT_EX) ( + IN UINT32 Type, + IN EFI_TPL NotifyTpl, + IN EFI_EVENT_NOTIFY NotifyFunction OPTIONAL, + IN const VOID *NotifyContext OPTIONAL, + IN const EFI_GUID *EventGroup OPTIONAL, + OUT EFI_EVENT *Event + ); + +typedef enum { + EfiResetCold, + EfiResetWarm, + EfiResetShutdown +} EFI_RESET_TYPE; + +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_GET_NEXT_MONOTONIC_COUNT) ( + OUT UINT64 *Count + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_GET_NEXT_HIGH_MONO_COUNT) ( + OUT UINT32 *HighCount + ); + +typedef struct { + UINT64 Length; + union { + EFI_PHYSICAL_ADDRESS DataBlock; + EFI_PHYSICAL_ADDRESS ContinuationPointer; + } Union; +} EFI_CAPSULE_BLOCK_DESCRIPTOR; + +typedef struct { + EFI_GUID CapsuleGuid; + UINT32 HeaderSize; + UINT32 Flags; + UINT32 CapsuleImageSize; +} EFI_CAPSULE_HEADER; + +#define CAPSULE_FLAGS_PERSIST_ACROSS_RESET 0x00010000 +#define CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE 0x00020000 +#define CAPSULE_FLAGS_INITIATE_RESET 0x00040000 + +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 + ); + +// +// Protocol handler functions +// + +typedef enum { + EFI_NATIVE_INTERFACE, + EFI_PCODE_INTERFACE +} EFI_INTERFACE_TYPE; + +typedef +EFI_STATUS +(EFIAPI *EFI_INSTALL_PROTOCOL_INTERFACE) ( + IN OUT EFI_HANDLE *Handle, + IN EFI_GUID *Protocol, + IN EFI_INTERFACE_TYPE InterfaceType, + IN VOID *Interface + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_REINSTALL_PROTOCOL_INTERFACE) ( + IN EFI_HANDLE Handle, + IN EFI_GUID *Protocol, + IN VOID *OldInterface, + IN VOID *NewInterface + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UNINSTALL_PROTOCOL_INTERFACE) ( + IN EFI_HANDLE Handle, + IN EFI_GUID *Protocol, + IN VOID *Interface + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_HANDLE_PROTOCOL) ( + IN EFI_HANDLE Handle, + IN EFI_GUID *Protocol, + OUT VOID **Interface + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_REGISTER_PROTOCOL_NOTIFY) ( + IN EFI_GUID *Protocol, + IN EFI_EVENT Event, + OUT VOID **Registration + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_LOCATE_HANDLE) ( + IN EFI_LOCATE_SEARCH_TYPE SearchType, + IN EFI_GUID *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 *Protocol, + IN OUT EFI_DEVICE_PATH **DevicePath, + OUT EFI_HANDLE *Device + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_INSTALL_CONFIGURATION_TABLE) ( + IN EFI_GUID *Guid, + IN VOID *Table + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_RESERVED_SERVICE) ( + ); + +// +// Standard EFI table header +// + +typedef struct _EFI_TABLE_HEADER { + UINT64 Signature; + UINT32 Revision; + UINT32 HeaderSize; + UINT32 CRC32; + UINT32 Reserved; +} EFI_TABLE_HEADER; + + +// +// EFI Runtime Serivces Table +// + +#define EFI_RUNTIME_SERVICES_SIGNATURE 0x56524553544e5552 +#define EFI_1_02_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(1, 02) +#define EFI_1_10_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(1, 10) +#define EFI_2_00_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 00) +#define EFI_2_10_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 10) +#define EFI_2_20_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 20) +#define EFI_2_30_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 30) +#define EFI_2_31_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 31) +#define EFI_2_40_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 40) +#define EFI_2_50_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 50) +#define EFI_2_60_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 60) +#define EFI_2_70_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 70) +#define EFI_2_80_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 80) +#define EFI_2_90_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 90) +#define EFI_2_100_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 100) +#define EFI_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_VERSION + +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; + + +// +// EFI Boot Services Table +// + +#define EFI_BOOT_SERVICES_SIGNATURE 0x56524553544f4f42 +#define EFI_1_02_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(1, 02) +#define EFI_1_10_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(1, 10) +#define EFI_2_00_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 00) +#define EFI_2_10_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 10) +#define EFI_2_20_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 20) +#define EFI_2_30_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 30) +#define EFI_2_31_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 31) +#define EFI_2_40_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 40) +#define EFI_2_50_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 50) +#define EFI_2_60_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 60) +#define EFI_2_70_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 70) +#define EFI_2_80_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 80) +#define EFI_2_90_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 90) +#define EFI_2_100_BOOT_SERVICES_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 100) +#define EFI_BOOT_SERVICES_REVISION EFI_SPECIFICATION_VERSION + +typedef struct _EFI_BOOT_SERVICES { + + EFI_TABLE_HEADER Hdr; + + // + // Task priority functions + // + + EFI_RAISE_TPL RaiseTPL; + EFI_RESTORE_TPL RestoreTPL; + + // + // Memory functions + // + + EFI_ALLOCATE_PAGES AllocatePages; + EFI_FREE_PAGES FreePages; + EFI_GET_MEMORY_MAP GetMemoryMap; + EFI_ALLOCATE_POOL AllocatePool; + EFI_FREE_POOL FreePool; + + // + // Event & timer functions + // + + 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; + + // + // Protocol handler functions + // + + EFI_INSTALL_PROTOCOL_INTERFACE InstallProtocolInterface; + EFI_REINSTALL_PROTOCOL_INTERFACE ReinstallProtocolInterface; + EFI_UNINSTALL_PROTOCOL_INTERFACE UninstallProtocolInterface; + EFI_HANDLE_PROTOCOL HandleProtocol; + EFI_HANDLE_PROTOCOL PCHandleProtocol; + EFI_REGISTER_PROTOCOL_NOTIFY RegisterProtocolNotify; + EFI_LOCATE_HANDLE LocateHandle; + EFI_LOCATE_DEVICE_PATH LocateDevicePath; + EFI_INSTALL_CONFIGURATION_TABLE InstallConfigurationTable; + + // + // Image functions + // + + EFI_IMAGE_LOAD LoadImage; + EFI_IMAGE_START StartImage; + EFI_EXIT Exit; + EFI_IMAGE_UNLOAD UnloadImage; + EFI_EXIT_BOOT_SERVICES ExitBootServices; + + // + // Misc functions + // + + EFI_GET_NEXT_MONOTONIC_COUNT GetNextMonotonicCount; + EFI_STALL Stall; + EFI_SET_WATCHDOG_TIMER SetWatchdogTimer; + + // + // DriverSupport Services + // + + EFI_CONNECT_CONTROLLER ConnectController; + EFI_DISCONNECT_CONTROLLER DisconnectController; + + // + // Open and Close Protocol Services + // + EFI_OPEN_PROTOCOL OpenProtocol; + EFI_CLOSE_PROTOCOL CloseProtocol; + EFI_OPEN_PROTOCOL_INFORMATION OpenProtocolInformation; + + // + // Library Services + // + 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; + + // + // 32-bit CRC Services + // + EFI_CALCULATE_CRC32 CalculateCrc32; + + // + // Misc Services + // + EFI_COPY_MEM CopyMem; + EFI_SET_MEM SetMem; + EFI_CREATE_EVENT_EX CreateEventEx; +} EFI_BOOT_SERVICES; + + +// +// EFI Configuration Table and GUID definitions +// + +#define MPS_TABLE_GUID \ + { 0xeb9d2d2f, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +#define ACPI_TABLE_GUID \ + { 0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +#define ACPI_20_TABLE_GUID \ + { 0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} } + +#define SMBIOS_TABLE_GUID \ + { 0xeb9d2d31, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +#define SMBIOS3_TABLE_GUID \ + { 0xf2fd1544, 0x9794, 0x4a2c, {0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94} } + +#define SAL_SYSTEM_TABLE_GUID \ + { 0xeb9d2d32, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +#define EFI_DTB_TABLE_GUID \ + { 0xb1b621d5, 0xf19c, 0x41a5, {0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0} } + +typedef struct _EFI_CONFIGURATION_TABLE { + EFI_GUID VendorGuid; + VOID *VendorTable; +} EFI_CONFIGURATION_TABLE; + + +// +// EFI System Table +// + + + + +#define EFI_SYSTEM_TABLE_SIGNATURE 0x5453595320494249 +#define EFI_1_02_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(1, 02) +#define EFI_1_10_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(1, 10) +#define EFI_2_00_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 00) +#define EFI_2_10_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 10) +#define EFI_2_20_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 20) +#define EFI_2_30_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 30) +#define EFI_2_31_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 31) +#define EFI_2_40_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 40) +#define EFI_2_50_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 50) +#define EFI_2_60_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 60) +#define EFI_2_70_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 70) +#define EFI_2_80_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 80) +#define EFI_2_90_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 90) +#define EFI_2_100_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_REVISION_MAJORMINOR(2, 100) +#define EFI_SYSTEM_TABLE_REVISION EFI_SPECIFICATION_VERSION + +typedef struct _EFI_SYSTEM_TABLE { + EFI_TABLE_HEADER Hdr; + + CHAR16 *FirmwareVendor; + UINT32 FirmwareRevision; + + EFI_HANDLE ConsoleInHandle; + SIMPLE_INPUT_INTERFACE *ConIn; + + EFI_HANDLE ConsoleOutHandle; + SIMPLE_TEXT_OUTPUT_INTERFACE *ConOut; + + EFI_HANDLE StandardErrorHandle; + SIMPLE_TEXT_OUTPUT_INTERFACE *StdErr; + + EFI_RUNTIME_SERVICES *RuntimeServices; + EFI_BOOT_SERVICES *BootServices; + + UINTN NumberOfTableEntries; + EFI_CONFIGURATION_TABLE *ConfigurationTable; + +} EFI_SYSTEM_TABLE; + +#endif + diff --git a/gnuefi/inc/eficompiler.h b/gnuefi/inc/eficompiler.h new file mode 100644 index 0000000..6f6ff7d --- /dev/null +++ b/gnuefi/inc/eficompiler.h @@ -0,0 +1,60 @@ +/*++ + +Copyright (c) 2016 Pete Batard + +Module Name: + + eficompiler.h + +Abstract: + + Compiler specific adjustments + +--*/ + +#ifdef _MSC_EXTENSIONS +#define EFI_UNUSED +#else +#define EFI_UNUSED __attribute__((__unused__)) +#endif + +#ifdef _MSC_EXTENSIONS +#define EFI_NO_TAIL_CALL +#else +#ifdef __clang__ +#define EFI_NO_TAIL_CALL __attribute__((disable_tail_calls)) +#else +#define EFI_NO_TAIL_CALL __attribute__((optimize("no-optimize-sibling-calls"))) +#endif +#endif + +#ifdef _MSC_EXTENSIONS +#define EFI_OPTNONE +#else +#ifdef __clang__ +#define EFI_OPTNONE __attribute__((optnone)) +#else +#define EFI_OPTNONE __attribute__((__optimize__("0"))) +#endif +#endif + +#ifdef _MSC_EXTENSIONS +#define EFI_ALIGN(x) __declspec(align(x)) +#else +#define EFI_ALIGN(x) __attribute__((__aligned__(x))) +#endif + +#ifndef ALIGN +#define ALIGN(x) EFI_ALIGN(x) +#endif + +#ifdef _MSC_EXTENSIONS +#define EFI_NORETURN __declspec(noreturn) +#else +#define EFI_NORETURN __attribute__((noreturn)) +#endif + +/* Also add a catch-all on __attribute__() for MS compilers */ +#ifdef _MSC_EXTENSIONS +#define __attribute__(x) +#endif diff --git a/gnuefi/inc/eficon.h b/gnuefi/inc/eficon.h new file mode 100644 index 0000000..5d17e04 --- /dev/null +++ b/gnuefi/inc/eficon.h @@ -0,0 +1,306 @@ +#ifndef _EFI_CON_H +#define _EFI_CON_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + eficon.h + +Abstract: + + EFI console protocols + + + +Revision History + +--*/ + +// +// Text output protocol +// + +#define EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID \ + { 0x387477c2, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } +#define SIMPLE_TEXT_OUTPUT_PROTOCOL EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID + +INTERFACE_DECL(_SIMPLE_TEXT_OUTPUT_INTERFACE); + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_RESET) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, + IN BOOLEAN ExtendedVerification + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_OUTPUT_STRING) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, + IN CHAR16 *String + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_TEST_STRING) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, + IN CHAR16 *String + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_QUERY_MODE) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, + IN UINTN ModeNumber, + OUT UINTN *Columns, + OUT UINTN *Rows + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_SET_MODE) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, + IN UINTN ModeNumber + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_SET_ATTRIBUTE) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, + IN UINTN Attribute + ); + +#define EFI_BLACK 0x00 +#define EFI_BLUE 0x01 +#define EFI_GREEN 0x02 +#define EFI_CYAN (EFI_BLUE | EFI_GREEN) +#define EFI_RED 0x04 +#define EFI_MAGENTA (EFI_BLUE | EFI_RED) +#define EFI_BROWN (EFI_GREEN | EFI_RED) +#define EFI_LIGHTGRAY (EFI_BLUE | EFI_GREEN | EFI_RED) +#define EFI_BRIGHT 0x08 +#define EFI_DARKGRAY (EFI_BRIGHT) +#define EFI_LIGHTBLUE (EFI_BLUE | EFI_BRIGHT) +#define EFI_LIGHTGREEN (EFI_GREEN | EFI_BRIGHT) +#define EFI_LIGHTCYAN (EFI_CYAN | EFI_BRIGHT) +#define EFI_LIGHTRED (EFI_RED | EFI_BRIGHT) +#define EFI_LIGHTMAGENTA (EFI_MAGENTA | EFI_BRIGHT) +#define EFI_YELLOW (EFI_BROWN | EFI_BRIGHT) +#define EFI_WHITE (EFI_BLUE | EFI_GREEN | EFI_RED | EFI_BRIGHT) + +#define EFI_TEXT_ATTR(f,b) ((f) | ((b) << 4)) + +#define EFI_BACKGROUND_BLACK 0x00 +#define EFI_BACKGROUND_BLUE 0x10 +#define EFI_BACKGROUND_GREEN 0x20 +#define EFI_BACKGROUND_CYAN (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN) +#define EFI_BACKGROUND_RED 0x40 +#define EFI_BACKGROUND_MAGENTA (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_RED) +#define EFI_BACKGROUND_BROWN (EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED) +#define EFI_BACKGROUND_LIGHTGRAY (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED) + + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_CLEAR_SCREEN) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_SET_CURSOR_POSITION) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, + IN UINTN Column, + IN UINTN Row + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TEXT_ENABLE_CURSOR) ( + IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, + IN BOOLEAN Enable + ); + +typedef struct { + INT32 MaxMode; + // current settings + INT32 Mode; + INT32 Attribute; + INT32 CursorColumn; + INT32 CursorRow; + BOOLEAN CursorVisible; +} SIMPLE_TEXT_OUTPUT_MODE; + +typedef struct _SIMPLE_TEXT_OUTPUT_INTERFACE { + EFI_TEXT_RESET Reset; + + EFI_TEXT_OUTPUT_STRING OutputString; + EFI_TEXT_TEST_STRING TestString; + + EFI_TEXT_QUERY_MODE QueryMode; + EFI_TEXT_SET_MODE SetMode; + EFI_TEXT_SET_ATTRIBUTE SetAttribute; + + EFI_TEXT_CLEAR_SCREEN ClearScreen; + EFI_TEXT_SET_CURSOR_POSITION SetCursorPosition; + EFI_TEXT_ENABLE_CURSOR EnableCursor; + + // Current mode + SIMPLE_TEXT_OUTPUT_MODE *Mode; +} SIMPLE_TEXT_OUTPUT_INTERFACE, EFI_SIMPLE_TEXT_OUT_PROTOCOL; + +// +// Define's for required EFI Unicode Box Draw character +// + +#define BOXDRAW_HORIZONTAL 0x2500 +#define BOXDRAW_VERTICAL 0x2502 +#define BOXDRAW_DOWN_RIGHT 0x250c +#define BOXDRAW_DOWN_LEFT 0x2510 +#define BOXDRAW_UP_RIGHT 0x2514 +#define BOXDRAW_UP_LEFT 0x2518 +#define BOXDRAW_VERTICAL_RIGHT 0x251c +#define BOXDRAW_VERTICAL_LEFT 0x2524 +#define BOXDRAW_DOWN_HORIZONTAL 0x252c +#define BOXDRAW_UP_HORIZONTAL 0x2534 +#define BOXDRAW_VERTICAL_HORIZONTAL 0x253c + +#define BOXDRAW_DOUBLE_HORIZONTAL 0x2550 +#define BOXDRAW_DOUBLE_VERTICAL 0x2551 +#define BOXDRAW_DOWN_RIGHT_DOUBLE 0x2552 +#define BOXDRAW_DOWN_DOUBLE_RIGHT 0x2553 +#define BOXDRAW_DOUBLE_DOWN_RIGHT 0x2554 + +#define BOXDRAW_DOWN_LEFT_DOUBLE 0x2555 +#define BOXDRAW_DOWN_DOUBLE_LEFT 0x2556 +#define BOXDRAW_DOUBLE_DOWN_LEFT 0x2557 + +#define BOXDRAW_UP_RIGHT_DOUBLE 0x2558 +#define BOXDRAW_UP_DOUBLE_RIGHT 0x2559 +#define BOXDRAW_DOUBLE_UP_RIGHT 0x255a + +#define BOXDRAW_UP_LEFT_DOUBLE 0x255b +#define BOXDRAW_UP_DOUBLE_LEFT 0x255c +#define BOXDRAW_DOUBLE_UP_LEFT 0x255d + +#define BOXDRAW_VERTICAL_RIGHT_DOUBLE 0x255e +#define BOXDRAW_VERTICAL_DOUBLE_RIGHT 0x255f +#define BOXDRAW_DOUBLE_VERTICAL_RIGHT 0x2560 + +#define BOXDRAW_VERTICAL_LEFT_DOUBLE 0x2561 +#define BOXDRAW_VERTICAL_DOUBLE_LEFT 0x2562 +#define BOXDRAW_DOUBLE_VERTICAL_LEFT 0x2563 + +#define BOXDRAW_DOWN_HORIZONTAL_DOUBLE 0x2564 +#define BOXDRAW_DOWN_DOUBLE_HORIZONTAL 0x2565 +#define BOXDRAW_DOUBLE_DOWN_HORIZONTAL 0x2566 + +#define BOXDRAW_UP_HORIZONTAL_DOUBLE 0x2567 +#define BOXDRAW_UP_DOUBLE_HORIZONTAL 0x2568 +#define BOXDRAW_DOUBLE_UP_HORIZONTAL 0x2569 + +#define BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE 0x256a +#define BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL 0x256b +#define BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL 0x256c + +// +// EFI Required Block Elements Code Chart +// + +#define BLOCKELEMENT_FULL_BLOCK 0x2588 +#define BLOCKELEMENT_LIGHT_SHADE 0x2591 +// +// EFI Required Geometric Shapes Code Chart +// + +#define GEOMETRICSHAPE_UP_TRIANGLE 0x25b2 +#define GEOMETRICSHAPE_RIGHT_TRIANGLE 0x25ba +#define GEOMETRICSHAPE_DOWN_TRIANGLE 0x25bc +#define GEOMETRICSHAPE_LEFT_TRIANGLE 0x25c4 + +// +// EFI Required Arrow shapes +// + +#define ARROW_UP 0x2191 +#define ARROW_DOWN 0x2193 + +// +// Text input protocol +// + +#define EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID \ + { 0x387477c1, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } +#define SIMPLE_TEXT_INPUT_PROTOCOL EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID + +INTERFACE_DECL(_SIMPLE_INPUT_INTERFACE); + +typedef struct { + UINT16 ScanCode; + CHAR16 UnicodeChar; +} EFI_INPUT_KEY; + +// +// Baseline unicode control chars +// + +#define CHAR_NULL 0x0000 +#define CHAR_BACKSPACE 0x0008 +#define CHAR_TAB 0x0009 +#define CHAR_LINEFEED 0x000A +#define CHAR_CARRIAGE_RETURN 0x000D + +// +// Scan codes for base line keys +// + +#define SCAN_NULL 0x0000 +#define SCAN_UP 0x0001 +#define SCAN_DOWN 0x0002 +#define SCAN_RIGHT 0x0003 +#define SCAN_LEFT 0x0004 +#define SCAN_HOME 0x0005 +#define SCAN_END 0x0006 +#define SCAN_INSERT 0x0007 +#define SCAN_DELETE 0x0008 +#define SCAN_PAGE_UP 0x0009 +#define SCAN_PAGE_DOWN 0x000A +#define SCAN_F1 0x000B +#define SCAN_F2 0x000C +#define SCAN_F3 0x000D +#define SCAN_F4 0x000E +#define SCAN_F5 0x000F +#define SCAN_F6 0x0010 +#define SCAN_F7 0x0011 +#define SCAN_F8 0x0012 +#define SCAN_F9 0x0013 +#define SCAN_F10 0x0014 +#define SCAN_F11 0x0015 +#define SCAN_F12 0x0016 +#define SCAN_ESC 0x0017 + +typedef +EFI_STATUS +(EFIAPI *EFI_INPUT_RESET) ( + IN struct _SIMPLE_INPUT_INTERFACE *This, + IN BOOLEAN ExtendedVerification + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_INPUT_READ_KEY) ( + IN struct _SIMPLE_INPUT_INTERFACE *This, + OUT EFI_INPUT_KEY *Key + ); + +typedef struct _SIMPLE_INPUT_INTERFACE { + EFI_INPUT_RESET Reset; + EFI_INPUT_READ_KEY ReadKeyStroke; + EFI_EVENT WaitForKey; +} SIMPLE_INPUT_INTERFACE, EFI_SIMPLE_TEXT_IN_PROTOCOL; + +#endif + diff --git a/gnuefi/inc/eficonex.h b/gnuefi/inc/eficonex.h new file mode 100644 index 0000000..5746662 --- /dev/null +++ b/gnuefi/inc/eficonex.h @@ -0,0 +1,111 @@ +#ifndef _EFI_CONEX_H +#define _EFI_CONEX_H + +/*++ + +Copyright (c) 2020 Kagurazaka Kotori + +Module Name: + + eficonex.h + +Abstract: + + EFI console extension protocols + +--*/ + +// +// Simple Text Input Ex Protocol +// + +#define EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID \ + { 0xdd9e7534, 0x7762, 0x4698, {0x8c, 0x14, 0xf5, 0x85, 0x17, 0xa6, 0x25, 0xaa} } + +INTERFACE_DECL(_EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL); + +typedef UINT8 EFI_KEY_TOGGLE_STATE; + +typedef struct EFI_KEY_STATE { + UINT32 KeyShiftState; + EFI_KEY_TOGGLE_STATE KeyToggleState; +} EFI_KEY_STATE; + +typedef struct { + EFI_INPUT_KEY Key; + EFI_KEY_STATE KeyState; +} EFI_KEY_DATA; + +// Shift states +#define EFI_SHIFT_STATE_VALID 0x80000000 +#define EFI_RIGHT_SHIFT_PRESSED 0x00000001 +#define EFI_LEFT_SHIFT_PRESSED 0x00000002 +#define EFI_RIGHT_CONTROL_PRESSED 0x00000004 +#define EFI_LEFT_CONTROL_PRESSED 0x00000008 +#define EFI_RIGHT_ALT_PRESSED 0x00000010 +#define EFI_LEFT_ALT_PRESSED 0x00000020 +#define EFI_RIGHT_LOGO_PRESSED 0x00000040 +#define EFI_LEFT_LOGO_PRESSED 0x00000080 +#define EFI_MENU_KEY_PRESSED 0x00000100 +#define EFI_SYS_REQ_PRESSED 0x00000200 + +// Toggle states +#define EFI_TOGGLE_STATE_VALID 0x80 +#define EFI_KEY_STATE_EXPOSED 0x40 +#define EFI_SCROLL_LOCK_ACTIVE 0x01 +#define EFI_NUM_LOCK_ACTIVE 0x02 +#define EFI_CAPS_LOCK_ACTIVE 0x04 + +typedef +EFI_STATUS +(EFIAPI *EFI_INPUT_RESET_EX) ( + IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This, + IN BOOLEAN ExtendedVerification + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_INPUT_READ_KEY_EX) ( + IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This, + OUT EFI_KEY_DATA *KeyData + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SET_STATE) ( + IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This, + IN EFI_KEY_TOGGLE_STATE *KeyToggleState + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_KEY_NOTIFY_FUNCTION) ( + IN EFI_KEY_DATA *KeyData + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_REGISTER_KEYSTROKE_NOTIFY) ( + IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This, + IN EFI_KEY_DATA *KeyData, + IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction, + OUT VOID **NotifyHandle + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UNREGISTER_KEYSTROKE_NOTIFY) ( + IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This, + IN VOID *NotificationHandle + ); + +typedef struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL{ + EFI_INPUT_RESET_EX Reset; + EFI_INPUT_READ_KEY_EX ReadKeyStrokeEx; + EFI_EVENT WaitForKeyEx; + EFI_SET_STATE SetState; + EFI_REGISTER_KEYSTROKE_NOTIFY RegisterKeyNotify; + EFI_UNREGISTER_KEYSTROKE_NOTIFY UnregisterKeyNotify; +} EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL; + +#endif diff --git a/gnuefi/inc/efidebug.h b/gnuefi/inc/efidebug.h new file mode 100644 index 0000000..8e54dcd --- /dev/null +++ b/gnuefi/inc/efidebug.h @@ -0,0 +1,620 @@ +#ifndef _EFI_DEBUG_H +#define _EFI_DEBUG_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efidebug.h + +Abstract: + + EFI library debug functions + + + +Revision History + +--*/ + +extern UINTN EFIDebug; + +#if EFI_DEBUG + + #define DBGASSERT(a) DbgAssert(__FILE__, __LINE__, #a) + #define DEBUG(a) DbgPrint a + +#else + + #define DBGASSERT(a) + #define DEBUG(a) + +#endif + +#if EFI_DEBUG_CLEAR_MEMORY + + #define DBGSETMEM(a,l) SetMem(a,l,(CHAR8)BAD_POINTER) + +#else + + #define DBGSETMEM(a,l) + +#endif + +#define D_INIT 0x00000001 // Initialization style messages +#define D_WARN 0x00000002 // Warnings +#define D_LOAD 0x00000004 // Load events +#define D_FS 0x00000008 // EFI File system +#define D_POOL 0x00000010 // Alloc & Free's +#define D_PAGE 0x00000020 // Alloc & Free's +#define D_INFO 0x00000040 // Verbose +#define D_VAR 0x00000100 // Variable +#define D_PARSE 0x00000200 // Command parsing +#define D_BM 0x00000400 // Boot manager +#define D_BLKIO 0x00001000 // BlkIo Driver +#define D_BLKIO_ULTRA 0x00002000 // BlkIo Driver +#define D_NET 0x00004000 // SNI Driver +#define D_NET_ULTRA 0x00008000 // SNI Driver +#define D_TXTIN 0x00010000 // Simple Input Driver +#define D_TXTOUT 0x00020000 // Simple Text Output Driver +#define D_ERROR_ATA 0x00040000 // ATA error messages +#define D_ERROR 0x80000000 // Error + +#define D_RESERVED 0x7fffC880 // Bits not reserved above + +// +// Current Debug level of the system, value of EFIDebug +// +//#define EFI_DBUG_MASK (D_ERROR | D_WARN | D_LOAD | D_BLKIO | D_INIT) +#define EFI_DBUG_MASK (D_ERROR) + +// +// +// + +#if EFI_DEBUG + + #define ASSERT(a) if(!(a)) DBGASSERT(a) + #define ASSERT_LOCKED(l) if(!(l)->Lock) DBGASSERT(l not locked) + #define ASSERT_STRUCT(p,t) DBGASSERT(t not structure), p + +#else + + #define ASSERT(a) + #define ASSERT_LOCKED(l) + #define ASSERT_STRUCT(p,t) + +#endif + +// +// Prototypes +// + +INTN +DbgAssert ( + CONST CHAR8 *file, + INTN lineno, + CONST CHAR8 *string + ); + +INTN +DbgPrint ( + INTN mask, + CONST CHAR8 *format, + ... + ); + +// +// Instruction Set Architectures definitions for debuggers +// + +typedef INTN EFI_EXCEPTION_TYPE; + +// IA32 +#define EXCEPT_IA32_DIVIDE_ERROR 0 +#define EXCEPT_IA32_DEBUG 1 +#define EXCEPT_IA32_NMI 2 +#define EXCEPT_IA32_BREAKPOINT 3 +#define EXCEPT_IA32_OVERFLOW 4 +#define EXCEPT_IA32_BOUND 5 +#define EXCEPT_IA32_INVALID_OPCODE 6 +#define EXCEPT_IA32_DOUBLE_FAULT 8 +#define EXCEPT_IA32_INVALID_TSS 10 +#define EXCEPT_IA32_SEG_NOT_PRESENT 11 +#define EXCEPT_IA32_STACK_FAULT 12 +#define EXCEPT_IA32_GP_FAULT 13 +#define EXCEPT_IA32_PAGE_FAULT 14 +#define EXCEPT_IA32_FP_ERROR 16 +#define EXCEPT_IA32_ALIGNMENT_CHECK 17 +#define EXCEPT_IA32_MACHINE_CHECK 18 +#define EXCEPT_IA32_SIMD 19 + +typedef struct { + UINT16 Fcw; + UINT16 Fsw; + UINT16 Ftw; + UINT16 Opcode; + UINT32 Eip; + UINT16 Cs; + UINT16 Reserved1; + UINT32 DataOffset; + UINT16 Ds; + UINT8 Reserved2[10]; + UINT8 St0Mm0[10], Reserved3[6]; + UINT8 St1Mm1[10], Reserved4[6]; + UINT8 St2Mm2[10], Reserved5[6]; + UINT8 St3Mm3[10], Reserved6[6]; + UINT8 St4Mm4[10], Reserved7[6]; + UINT8 St5Mm5[10], Reserved8[6]; + UINT8 St6Mm6[10], Reserved9[6]; + UINT8 St7Mm7[10], Reserved10[6]; + UINT8 Xmm0[16]; + UINT8 Xmm1[16]; + UINT8 Xmm2[16]; + UINT8 Xmm3[16]; + UINT8 Xmm4[16]; + UINT8 Xmm5[16]; + UINT8 Xmm6[16]; + UINT8 Xmm7[16]; + UINT8 Reserved11[14 * 16]; +} EFI_FX_SAVE_STATE_IA32; + +typedef struct { + UINT32 ExceptionData; + EFI_FX_SAVE_STATE_IA32 FxSaveState; + UINT32 Dr0; + UINT32 Dr1; + UINT32 Dr2; + UINT32 Dr3; + UINT32 Dr6; + UINT32 Dr7; + UINT32 Cr0; + UINT32 Cr1; + UINT32 Cr2; + UINT32 Cr3; + UINT32 Cr4; + UINT32 Eflags; + UINT32 Ldtr; + UINT32 Tr; + UINT32 Gdtr[2]; + UINT32 Idtr[2]; + UINT32 Eip; + UINT32 Gs; + UINT32 Fs; + UINT32 Es; + UINT32 Ds; + UINT32 Cs; + UINT32 Ss; + UINT32 Edi; + UINT32 Esi; + UINT32 Ebp; + UINT32 Esp; + UINT32 Ebx; + UINT32 Edx; + UINT32 Ecx; + UINT32 Eax; +} EFI_SYSTEM_CONTEXT_IA32; + +// X64 +#define EXCEPT_X64_DIVIDE_ERROR 0 +#define EXCEPT_X64_DEBUG 1 +#define EXCEPT_X64_NMI 2 +#define EXCEPT_X64_BREAKPOINT 3 +#define EXCEPT_X64_OVERFLOW 4 +#define EXCEPT_X64_BOUND 5 +#define EXCEPT_X64_INVALID_OPCODE 6 +#define EXCEPT_X64_DOUBLE_FAULT 8 +#define EXCEPT_X64_INVALID_TSS 10 +#define EXCEPT_X64_SEG_NOT_PRESENT 11 +#define EXCEPT_X64_STACK_FAULT 12 +#define EXCEPT_X64_GP_FAULT 13 +#define EXCEPT_X64_PAGE_FAULT 14 +#define EXCEPT_X64_FP_ERROR 16 +#define EXCEPT_X64_ALIGNMENT_CHECK 17 +#define EXCEPT_X64_MACHINE_CHECK 18 +#define EXCEPT_X64_SIMD 19 + +typedef struct { + UINT16 Fcw; + UINT16 Fsw; + UINT16 Ftw; + UINT16 Opcode; + UINT64 Rip; + UINT64 DataOffset; + UINT8 Reserved1[8]; + UINT8 St0Mm0[10], Reserved2[6]; + UINT8 St1Mm1[10], Reserved3[6]; + UINT8 St2Mm2[10], Reserved4[6]; + UINT8 St3Mm3[10], Reserved5[6]; + UINT8 St4Mm4[10], Reserved6[6]; + UINT8 St5Mm5[10], Reserved7[6]; + UINT8 St6Mm6[10], Reserved8[6]; + UINT8 St7Mm7[10], Reserved9[6]; + UINT8 Xmm0[16]; + UINT8 Xmm1[16]; + UINT8 Xmm2[16]; + UINT8 Xmm3[16]; + UINT8 Xmm4[16]; + UINT8 Xmm5[16]; + UINT8 Xmm6[16]; + UINT8 Xmm7[16]; + UINT8 Reserved11[14 * 16]; +} EFI_FX_SAVE_STATE_X64; + +typedef struct { + UINT64 ExceptionData; + EFI_FX_SAVE_STATE_X64 FxSaveState; + UINT64 Dr0; + UINT64 Dr1; + UINT64 Dr2; + UINT64 Dr3; + UINT64 Dr6; + UINT64 Dr7; + UINT64 Cr0; + UINT64 Cr1; + UINT64 Cr2; + UINT64 Cr3; + UINT64 Cr4; + UINT64 Cr8; + UINT64 Rflags; + UINT64 Ldtr; + UINT64 Tr; + UINT64 Gdtr[2]; + UINT64 Idtr[2]; + UINT64 Rip; + UINT64 Gs; + UINT64 Fs; + UINT64 Es; + UINT64 Ds; + UINT64 Cs; + UINT64 Ss; + UINT64 Rdi; + UINT64 Rsi; + UINT64 Rbp; + UINT64 Rsp; + UINT64 Rbx; + UINT64 Rdx; + UINT64 Rcx; + UINT64 Rax; + UINT64 R8; + UINT64 R9; + UINT64 R10; + UINT64 R11; + UINT64 R12; + UINT64 R13; + UINT64 R14; + UINT64 R15; +} EFI_SYSTEM_CONTEXT_X64; + +/// IA64 +#define EXCEPT_IPF_VHTP_TRANSLATION 0 +#define EXCEPT_IPF_INSTRUCTION_TLB 1 +#define EXCEPT_IPF_DATA_TLB 2 +#define EXCEPT_IPF_ALT_INSTRUCTION_TLB 3 +#define EXCEPT_IPF_ALT_DATA_TLB 4 +#define EXCEPT_IPF_DATA_NESTED_TLB 5 +#define EXCEPT_IPF_INSTRUCTION_KEY_MISSED 6 +#define EXCEPT_IPF_DATA_KEY_MISSED 7 +#define EXCEPT_IPF_DIRTY_BIT 8 +#define EXCEPT_IPF_INSTRUCTION_ACCESS_BIT 9 +#define EXCEPT_IPF_DATA_ACCESS_BIT 10 +#define EXCEPT_IPF_BREAKPOINT 11 +#define EXCEPT_IPF_EXTERNAL_INTERRUPT 12 +#define EXCEPT_IPF_PAGE_NOT_PRESENT 20 +#define EXCEPT_IPF_KEY_PERMISSION 21 +#define EXCEPT_IPF_INSTRUCTION_ACCESS_RIGHTS 22 +#define EXCEPT_IPF_DATA_ACCESS_RIGHTS 23 +#define EXCEPT_IPF_GENERAL_EXCEPTION 24 +#define EXCEPT_IPF_DISABLED_FP_REGISTER 25 +#define EXCEPT_IPF_NAT_CONSUMPTION 26 +#define EXCEPT_IPF_SPECULATION 27 +#define EXCEPT_IPF_DEBUG 29 +#define EXCEPT_IPF_UNALIGNED_REFERENCE 30 +#define EXCEPT_IPF_UNSUPPORTED_DATA_REFERENCE 31 +#define EXCEPT_IPF_FP_FAULT 32 +#define EXCEPT_IPF_FP_TRAP 33 +#define EXCEPT_IPF_LOWER_PRIVILEGE_TRANSFER_TRAP 34 +#define EXCEPT_IPF_TAKEN_BRANCH 35 +#define EXCEPT_IPF_SINGLE_STEP 36 +#define EXCEPT_IPF_IA32_EXCEPTION 45 +#define EXCEPT_IPF_IA32_INTERCEPT 46 +#define EXCEPT_IPF_IA32_INTERRUPT 47 + +typedef struct { + UINT64 Reserved; + UINT64 R1; + UINT64 R2; + UINT64 R3; + UINT64 R4; + UINT64 R5; + UINT64 R6; + UINT64 R7; + UINT64 R8; + UINT64 R9; + UINT64 R10; + UINT64 R11; + UINT64 R12; + UINT64 R13; + UINT64 R14; + UINT64 R15; + UINT64 R16; + UINT64 R17; + UINT64 R18; + UINT64 R19; + UINT64 R20; + UINT64 R21; + UINT64 R22; + UINT64 R23; + UINT64 R24; + UINT64 R25; + UINT64 R26; + UINT64 R27; + UINT64 R28; + UINT64 R29; + UINT64 R30; + UINT64 R31; + UINT64 F2[2]; + UINT64 F3[2]; + UINT64 F4[2]; + UINT64 F5[2]; + UINT64 F6[2]; + UINT64 F7[2]; + UINT64 F8[2]; + UINT64 F9[2]; + UINT64 F10[2]; + UINT64 F11[2]; + UINT64 F12[2]; + UINT64 F13[2]; + UINT64 F14[2]; + UINT64 F15[2]; + UINT64 F16[2]; + UINT64 F17[2]; + UINT64 F18[2]; + UINT64 F19[2]; + UINT64 F20[2]; + UINT64 F21[2]; + UINT64 F22[2]; + UINT64 F23[2]; + UINT64 F24[2]; + UINT64 F25[2]; + UINT64 F26[2]; + UINT64 F27[2]; + UINT64 F28[2]; + UINT64 F29[2]; + UINT64 F30[2]; + UINT64 F31[2]; + UINT64 Pr; + UINT64 B0; + UINT64 B1; + UINT64 B2; + UINT64 B3; + UINT64 B4; + UINT64 B5; + UINT64 B6; + UINT64 B7; + UINT64 ArRsc; + UINT64 ArBsp; + UINT64 ArBspstore; + UINT64 ArRnat; + UINT64 ArFcr; + UINT64 ArEflag; + UINT64 ArCsd; + UINT64 ArSsd; + UINT64 ArCflg; + UINT64 ArFsr; + UINT64 ArFir; + UINT64 ArFdr; + UINT64 ArCcv; + UINT64 ArUnat; + UINT64 ArFpsr; + UINT64 ArPfs; + UINT64 ArLc; + UINT64 ArEc; + UINT64 CrDcr; + UINT64 CrItm; + UINT64 CrIva; + UINT64 CrPta; + UINT64 CrIpsr; + UINT64 CrIsr; + UINT64 CrIip; + UINT64 CrIfa; + UINT64 CrItir; + UINT64 CrIipa; + UINT64 CrIfs; + UINT64 CrIim; + UINT64 CrIha; + UINT64 Dbr0; + UINT64 Dbr1; + UINT64 Dbr2; + UINT64 Dbr3; + UINT64 Dbr4; + UINT64 Dbr5; + UINT64 Dbr6; + UINT64 Dbr7; + UINT64 Ibr0; + UINT64 Ibr1; + UINT64 Ibr2; + UINT64 Ibr3; + UINT64 Ibr4; + UINT64 Ibr5; + UINT64 Ibr6; + UINT64 Ibr7; + UINT64 IntNat; +} EFI_SYSTEM_CONTEXT_IPF; + +// EBC +#define EXCEPT_EBC_UNDEFINED 0 +#define EXCEPT_EBC_DIVIDE_ERROR 1 +#define EXCEPT_EBC_DEBUG 2 +#define EXCEPT_EBC_BREAKPOINT 3 +#define EXCEPT_EBC_OVERFLOW 4 +#define EXCEPT_EBC_INVALID_OPCODE 5 +#define EXCEPT_EBC_STACK_FAULT 6 +#define EXCEPT_EBC_ALIGNMENT_CHECK 7 +#define EXCEPT_EBC_INSTRUCTION_ENCODING 8 +#define EXCEPT_EBC_BAD_BREAK 9 +#define EXCEPT_EBC_STEP 10 +#define MAX_EBC_EXCEPTION EXCEPT_EBC_STEP + +typedef struct { + UINT64 R0; + UINT64 R1; + UINT64 R2; + UINT64 R3; + UINT64 R4; + UINT64 R5; + UINT64 R6; + UINT64 R7; + UINT64 Flags; + UINT64 ControlFlags; + UINT64 Ip; +} EFI_SYSTEM_CONTEXT_EBC; + +// ARM +#define EXCEPT_ARM_RESET 0 +#define EXCEPT_ARM_UNDEFINED_INSTRUCTION 1 +#define EXCEPT_ARM_SOFTWARE_INTERRUPT 2 +#define EXCEPT_ARM_PREFETCH_ABORT 3 +#define EXCEPT_ARM_DATA_ABORT 4 +#define EXCEPT_ARM_RESERVED 5 +#define EXCEPT_ARM_IRQ 6 +#define EXCEPT_ARM_FIQ 7 +#define MAX_ARM_EXCEPTION EXCEPT_ARM_FIQ + +typedef struct { + UINT32 R0; + UINT32 R1; + UINT32 R2; + UINT32 R3; + UINT32 R4; + UINT32 R5; + UINT32 R6; + UINT32 R7; + UINT32 R8; + UINT32 R9; + UINT32 R10; + UINT32 R11; + UINT32 R12; + UINT32 SP; + UINT32 LR; + UINT32 PC; + UINT32 CPSR; + UINT32 DFSR; + UINT32 DFAR; + UINT32 IFSR; + UINT32 IFAR; +} EFI_SYSTEM_CONTEXT_ARM; + + +typedef union { + EFI_SYSTEM_CONTEXT_EBC *SystemContextEbc; + EFI_SYSTEM_CONTEXT_IA32 *SystemContextIa32; + EFI_SYSTEM_CONTEXT_X64 *SystemContextX64; + EFI_SYSTEM_CONTEXT_IPF *SystemContextIpf; + EFI_SYSTEM_CONTEXT_ARM *SystemContextArm; +} EFI_SYSTEM_CONTEXT; + +typedef +VOID +(EFIAPI *EFI_EXCEPTION_CALLBACK)( + IN EFI_EXCEPTION_TYPE ExceptionType, + IN OUT EFI_SYSTEM_CONTEXT SystemContext); + +typedef +VOID +(EFIAPI *EFI_PERIODIC_CALLBACK)( + IN OUT EFI_SYSTEM_CONTEXT SystemContext); + +typedef enum { + IsaIa32 = EFI_IMAGE_MACHINE_IA32, + IsaX64 = EFI_IMAGE_MACHINE_X64, + IsaIpf = EFI_IMAGE_MACHINE_IA64, + IsaEbc = EFI_IMAGE_MACHINE_EBC, + IsaArm = EFI_IMAGE_MACHINE_ARMTHUMB_MIXED, +// IsaArm64 = EFI_IMAGE_MACHINE_AARCH64 +} EFI_INSTRUCTION_SET_ARCHITECTURE; + +// +// DEBUG_IMAGE_INFO +// + +#define EFI_DEBUG_IMAGE_INFO_TABLE_GUID \ + { 0x49152e77, 0x1ada, 0x4764, {0xb7, 0xa2, 0x7a, 0xfe, 0xfe, 0xd9, 0x5e, 0x8b} } + +#define EFI_DEBUG_IMAGE_INFO_UPDATE_IN_PROGRESS 0x01 +#define EFI_DEBUG_IMAGE_INFO_TABLE_MODIFIED 0x02 +#define EFI_DEBUG_IMAGE_INFO_INITIAL_SIZE (EFI_PAGE_SIZE / sizeof (UINTN)) +#define EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL 0x01 + +typedef struct { +UINT64 Signature; +EFI_PHYSICAL_ADDRESS EfiSystemTableBase; +UINT32 Crc32; +} EFI_SYSTEM_TABLE_POINTER; + +typedef struct { +UINT32 ImageInfoType; +EFI_LOADED_IMAGE_PROTOCOL *LoadedImageProtocolInstance; +EFI_HANDLE *ImageHandle; +} EFI_DEBUG_IMAGE_INFO_NORMAL; + +typedef union { +UINT32 *ImageInfoType; +EFI_DEBUG_IMAGE_INFO_NORMAL *NormalImage; +} EFI_DEBUG_IMAGE_INFO; + +typedef struct { +volatile UINT32 UpdateStatus; +UINT32 TableSize; +EFI_DEBUG_IMAGE_INFO *EfiDebugImageInfoTable; +} EFI_DEBUG_IMAGE_INFO_TABLE_HEADER; + +// +// EFI_DEBUGGER_PROTOCOL +// + +#define EFI_DEBUG_SUPPORT_PROTOCOL_GUID \ + { 0x2755590c, 0x6f3c, 0x42fa, {0x9e, 0xa4, 0xa3, 0xba, 0x54, 0x3c, 0xda, 0x25} } + +INTERFACE_DECL(_EFI_DEBUG_SUPPORT_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_GET_MAXIMUM_PROCESSOR_INDEX)( + IN struct _EFI_DEBUG_SUPPORT_PROTOCOL *This, + OUT UINTN *MaxProcessorIndex); + +typedef +EFI_STATUS +(EFIAPI *EFI_REGISTER_PERIODIC_CALLBACK)( + IN struct _EFI_DEBUG_SUPPORT_PROTOCOL *This, + IN UINTN ProcessorIndex, + IN EFI_PERIODIC_CALLBACK PeriodicCallback); + +typedef +EFI_STATUS +(EFIAPI *EFI_REGISTER_EXCEPTION_CALLBACK)( + IN struct _EFI_DEBUG_SUPPORT_PROTOCOL *This, + IN UINTN ProcessorIndex, + IN EFI_EXCEPTION_CALLBACK ExceptionCallback, + IN EFI_EXCEPTION_TYPE ExceptionType); + +typedef +EFI_STATUS +(EFIAPI *EFI_INVALIDATE_INSTRUCTION_CACHE)( + IN struct _EFI_DEBUG_SUPPORT_PROTOCOL *This, + IN UINTN ProcessorIndex, + IN VOID *Start, + IN UINT64 Length); + +typedef struct _EFI_DEBUG_SUPPORT_PROTOCOL { + EFI_INSTRUCTION_SET_ARCHITECTURE Isa; + EFI_GET_MAXIMUM_PROCESSOR_INDEX GetMaximumProcessorIndex; + EFI_REGISTER_PERIODIC_CALLBACK RegisterPeriodicCallback; + EFI_REGISTER_EXCEPTION_CALLBACK RegisterExceptionCallback; + EFI_INVALIDATE_INSTRUCTION_CACHE InvalidateInstructionCache; +} EFI_DEBUG_SUPPORT_PROTOCOL; + +#endif diff --git a/gnuefi/inc/efidef.h b/gnuefi/inc/efidef.h new file mode 100644 index 0000000..2934b11 --- /dev/null +++ b/gnuefi/inc/efidef.h @@ -0,0 +1,258 @@ +#ifndef _EFI_DEF_H +#define _EFI_DEF_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efidef.h + +Abstract: + + EFI definitions + + + + +Revision History + +--*/ + +#if !defined(__cplusplus) +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +typedef _Bool BOOLEAN; +#else +typedef unsigned char BOOLEAN; +#endif +#else +typedef bool BOOLEAN; +#endif + +#ifndef CONST + #define CONST const +#endif +#ifndef TRUE +#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) + #define TRUE true + #define FALSE false +#else + #define TRUE ((BOOLEAN) 1) + #define FALSE ((BOOLEAN) 0) +#endif +#endif + +#ifndef NULL +#if (defined(__cplusplus) && __cplusplus >= 201103L) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) + #define NULL nullptr +#else +#if !defined(__cplusplus) + #define NULL ((VOID *) 0) +#else + #define NULL 0 +#endif +#endif +#endif + +typedef UINTN EFI_STATUS; +typedef UINT64 EFI_LBA; +typedef UINTN EFI_TPL; +typedef VOID *EFI_HANDLE; +typedef VOID *EFI_EVENT; + + +// +// Prototype argument decoration for EFI parameters to indicate +// their direction +// +// IN - argument is passed into the function +// OUT - argument (pointer) is returned from the function +// OPTIONAL - argument is optional +// + +#ifndef IN + #define IN + #define OUT + #define OPTIONAL +#endif + + +// +// A GUID +// + +typedef struct { + UINT32 Data1; + UINT16 Data2; + UINT16 Data3; + UINT8 Data4[8]; +} EFI_GUID; + + +// +// Time +// + +typedef struct { + UINT16 Year; // 1998 - 20XX + UINT8 Month; // 1 - 12 + UINT8 Day; // 1 - 31 + UINT8 Hour; // 0 - 23 + UINT8 Minute; // 0 - 59 + UINT8 Second; // 0 - 59 + UINT8 Pad1; + UINT32 Nanosecond; // 0 - 999,999,999 + INT16 TimeZone; // -1440 to 1440 or 2047 + UINT8 Daylight; + UINT8 Pad2; +} EFI_TIME; + +// Bit definitions for EFI_TIME.Daylight +#define EFI_TIME_ADJUST_DAYLIGHT 0x01 +#define EFI_TIME_IN_DAYLIGHT 0x02 + +// Value definition for EFI_TIME.TimeZone +#define EFI_UNSPECIFIED_TIMEZONE 0x07FF + + + +// +// Networking +// + +typedef struct { + UINT8 Addr[4]; +} EFI_IPv4_ADDRESS; + +typedef struct { + UINT8 Addr[16]; +} EFI_IPv6_ADDRESS; + +typedef struct { + UINT8 Addr[32]; +} EFI_MAC_ADDRESS; + +typedef struct { + UINT32 ReceivedQueueTimeoutValue; + UINT32 TransmitQueueTimeoutValue; + UINT16 ProtocolTypeFilter; + BOOLEAN EnableUnicastReceive; + BOOLEAN EnableMulticastReceive; + BOOLEAN EnableBroadcastReceive; + BOOLEAN EnablePromiscuousReceive; + BOOLEAN FlushQueuesOnReset; + BOOLEAN EnableReceiveTimestamps; + BOOLEAN DisableBackgroundPolling; +} EFI_MANAGED_NETWORK_CONFIG_DATA; + +// +// Memory +// + +typedef UINT64 EFI_PHYSICAL_ADDRESS; +typedef UINT64 EFI_VIRTUAL_ADDRESS; + +typedef enum { + AllocateAnyPages, + AllocateMaxAddress, + AllocateAddress, + MaxAllocateType +} EFI_ALLOCATE_TYPE; + +//Preseve the attr on any range supplied. +//ConventialMemory must have WB,SR,SW when supplied. +//When allocating from ConventialMemory always make it WB,SR,SW +//When returning to ConventialMemory always make it WB,SR,SW +//When getting the memory map, or on RT for runtime types + + +typedef enum { + EfiReservedMemoryType, + EfiLoaderCode, + EfiLoaderData, + EfiBootServicesCode, + EfiBootServicesData, + EfiRuntimeServicesCode, + EfiRuntimeServicesData, + EfiConventionalMemory, + EfiUnusableMemory, + EfiACPIReclaimMemory, + EfiACPIMemoryNVS, + EfiMemoryMappedIO, + EfiMemoryMappedIOPortSpace, + EfiPalCode, + EfiPersistentMemory, + EfiUnacceptedMemoryType, + EfiMaxMemoryType +} EFI_MEMORY_TYPE; + + +// Memory cacheability attribute +#define EFI_MEMORY_UC 0x0000000000000001 +#define EFI_MEMORY_WC 0x0000000000000002 +#define EFI_MEMORY_WT 0x0000000000000004 +#define EFI_MEMORY_WB 0x0000000000000008 +#define EFI_MEMORY_UCE 0x0000000000000010 + +// Physical memory protection attribute +#define EFI_MEMORY_WP 0x0000000000001000 +#define EFI_MEMORY_RP 0x0000000000002000 +#define EFI_MEMORY_XP 0x0000000000004000 +#define EFI_MEMORY_RO 0x0000000000020000 + +// Runtime memory attribute +#define EFI_MEMORY_NV 0x0000000000008000 +#define EFI_MEMORY_RUNTIME 0x8000000000000000 + +// Other memory attribute +#define EFI_MEMORY_MORE_RELIABLE 0x0000000000010000 +#define EFI_MEMORY_SP 0x0000000000040000 +#define EFI_MEMORY_CPU_CRYPTO 0x0000000000080000 +#define EFI_MEMORY_ISA_VALID 0x4000000000000000 +#define EFI_MEMORY_ISA_MASK 0x0FFFF00000000000 + + +#define EFI_MEMORY_DESCRIPTOR_VERSION 1 +typedef struct { + UINT32 Type; // Field size is 32 bits followed by 32 bit pad + UINT32 Pad; + EFI_PHYSICAL_ADDRESS PhysicalStart; // Field size is 64 bits + EFI_VIRTUAL_ADDRESS VirtualStart; // Field size is 64 bits + UINT64 NumberOfPages; // Field size is 64 bits + UINT64 Attribute; // Field size is 64 bits +} EFI_MEMORY_DESCRIPTOR; + +// +// International Language +// + +typedef CHAR8 ISO_639_2; +#define ISO_639_2_ENTRY_SIZE 3 + +// +// +// + +#define EFI_PAGE_SIZE 4096 +#define EFI_PAGE_MASK 0xFFF +#define EFI_PAGE_SHIFT 12 + +#define EFI_SIZE_TO_PAGES(a) \ + ( ((a) >> EFI_PAGE_SHIFT) + ((a) & EFI_PAGE_MASK ? 1 : 0) ) + +#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI 0x0000000000000001 +#define EFI_OS_INDICATIONS_TIMESTAMP_REVOCATION 0x0000000000000002 +#define EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED \ + 0x0000000000000004 +#define EFI_OS_INDICATIONS_FMP_CAPSULE_SUPPORTED \ + 0x0000000000000008 +#define EFI_OS_INDICATIONS_CAPSULE_RESULT_VAR_SUPPORTED \ + 0x0000000000000010 +#define EFI_OS_INDICATIONS_START_OS_RECOVERY 0x0000000000000020 +#define EFI_OS_INDICATIONS_START_PLATFORM_RECOVERY \ + 0x0000000000000040 +#define EFI_OS_INDICATIONS_JSON_CONFIG_DATA_REFRESH \ + 0x0000000000000080 + +#endif diff --git a/gnuefi/inc/efidevp.h b/gnuefi/inc/efidevp.h new file mode 100644 index 0000000..90fa546 --- /dev/null +++ b/gnuefi/inc/efidevp.h @@ -0,0 +1,650 @@ +#ifndef _DEVPATH_H +#define _DEVPATH_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + devpath.h + +Abstract: + + Defines for parsing the EFI Device Path structures + + + +Revision History + +--*/ + +// +// Device Path structures - Section C +// + +typedef struct _EFI_DEVICE_PATH_PROTOCOL { + UINT8 Type; + UINT8 SubType; + UINT8 Length[2]; +} EFI_DEVICE_PATH_PROTOCOL; + +typedef struct _EFI_DEVICE_PATH_PROTOCOL _EFI_DEVICE_PATH; +typedef EFI_DEVICE_PATH_PROTOCOL EFI_DEVICE_PATH; + +#define EFI_DP_TYPE_MASK 0x7F +#define EFI_DP_TYPE_UNPACKED 0x80 + +//#define END_DEVICE_PATH_TYPE 0xff +#define END_DEVICE_PATH_TYPE 0x7f +//#define END_DEVICE_PATH_TYPE_UNPACKED 0x7f + +#define END_ENTIRE_DEVICE_PATH_SUBTYPE 0xff +#define END_INSTANCE_DEVICE_PATH_SUBTYPE 0x01 +#define END_DEVICE_PATH_LENGTH (sizeof(EFI_DEVICE_PATH_PROTOCOL)) + + +#define DP_IS_END_TYPE(a) +#define DP_IS_END_SUBTYPE(a) ( ((a)->SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE ) + +#define DevicePathType(a) ( ((a)->Type) & EFI_DP_TYPE_MASK ) +#define DevicePathSubType(a) ( (a)->SubType ) +#define DevicePathNodeLength(a) ( ((a)->Length[0]) | ((a)->Length[1] << 8) ) +#define NextDevicePathNode(a) ( (EFI_DEVICE_PATH_PROTOCOL *) ( ((UINT8 *) (a)) + DevicePathNodeLength(a))) +//#define IsDevicePathEndType(a) ( DevicePathType(a) == END_DEVICE_PATH_TYPE_UNPACKED ) +#define IsDevicePathEndType(a) ( DevicePathType(a) == END_DEVICE_PATH_TYPE ) +#define IsDevicePathEndSubType(a) ( (a)->SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE ) +#define IsDevicePathEnd(a) ( IsDevicePathEndType(a) && IsDevicePathEndSubType(a) ) +#define IsDevicePathUnpacked(a) ( (a)->Type & EFI_DP_TYPE_UNPACKED ) + + +#define SetDevicePathNodeLength(a,l) { \ + (a)->Length[0] = (UINT8) (l); \ + (a)->Length[1] = (UINT8) ((l) >> 8); \ + } + +#define SetDevicePathEndNode(a) { \ + (a)->Type = END_DEVICE_PATH_TYPE; \ + (a)->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE; \ + (a)->Length[0] = sizeof(EFI_DEVICE_PATH_PROTOCOL); \ + (a)->Length[1] = 0; \ + } + + +/* + * Hardware Device Path (UEFI 2.4 specification, version 2.4 § 9.3.2.) + */ + +#define HARDWARE_DEVICE_PATH 0x01 + +#define HW_PCI_DP 0x01 +typedef struct _PCI_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT8 Function; + UINT8 Device; +} PCI_DEVICE_PATH; + +#define HW_PCCARD_DP 0x02 +typedef struct _PCCARD_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT8 FunctionNumber ; +} PCCARD_DEVICE_PATH; + +#define HW_MEMMAP_DP 0x03 +typedef struct _MEMMAP_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 MemoryType; + EFI_PHYSICAL_ADDRESS StartingAddress; + EFI_PHYSICAL_ADDRESS EndingAddress; +} MEMMAP_DEVICE_PATH; + +#define HW_VENDOR_DP 0x04 +typedef struct _VENDOR_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + EFI_GUID Guid; +} VENDOR_DEVICE_PATH; + +#define UNKNOWN_DEVICE_GUID \ + { 0xcf31fac5, 0xc24e, 0x11d2, {0x85, 0xf3, 0x0, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b} } + +typedef struct _UKNOWN_DEVICE_VENDOR_DP { + VENDOR_DEVICE_PATH DevicePath; + UINT8 LegacyDriveLetter; +} UNKNOWN_DEVICE_VENDOR_DEVICE_PATH; + +#define HW_CONTROLLER_DP 0x05 +typedef struct _CONTROLLER_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 Controller; +} CONTROLLER_DEVICE_PATH; + + +/* + * ACPI Device Path (UEFI 2.4 specification, version 2.4 § 9.3.3 and 9.3.4.) + */ +#define ACPI_DEVICE_PATH 0x02 + +#define ACPI_DP 0x01 +typedef struct _ACPI_HID_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 HID; + UINT32 UID; +} ACPI_HID_DEVICE_PATH; + +#define EXPANDED_ACPI_DP 0x02 +typedef struct _EXPANDED_ACPI_HID_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 HID; + UINT32 UID; + UINT32 CID; + UINT8 HidStr[1]; +} EXPANDED_ACPI_HID_DEVICE_PATH; + +#define ACPI_ADR_DP 3 +typedef struct _ACPI_ADR_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + UINT32 ADR ; +} ACPI_ADR_DEVICE_PATH ; + +// +// EISA ID Macro +// EISA ID Definition 32-bits +// bits[15:0] - three character compressed ASCII EISA ID. +// bits[31:16] - binary number +// Compressed ASCII is 5 bits per character 0b00001 = 'A' 0b11010 = 'Z' +// +#define PNP_EISA_ID_CONST 0x41d0 +#define EISA_ID(_Name, _Num) ((UINT32) ((_Name) | (_Num) << 16)) +#define EISA_PNP_ID(_PNPId) (EISA_ID(PNP_EISA_ID_CONST, (_PNPId))) + +#define PNP_EISA_ID_MASK 0xffff +#define EISA_ID_TO_NUM(_Id) ((_Id) >> 16) + + +/* + * Messaging Device Path (UEFI 2.4 specification, version 2.4 § 9.3.5.) + */ +#define MESSAGING_DEVICE_PATH 0x03 + +#define MSG_ATAPI_DP 0x01 +typedef struct _ATAPI_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT8 PrimarySecondary; + UINT8 SlaveMaster; + UINT16 Lun; +} ATAPI_DEVICE_PATH; + +#define MSG_SCSI_DP 0x02 +typedef struct _SCSI_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT16 Pun; + UINT16 Lun; +} SCSI_DEVICE_PATH; + +#define MSG_FIBRECHANNEL_DP 0x03 +typedef struct _FIBRECHANNEL_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 Reserved; + UINT64 WWN; + UINT64 Lun; +} FIBRECHANNEL_DEVICE_PATH; + +/** + * Fibre Channel Ex SubType. + * UEFI 2.0 specification version 2.4 § 9.3.5.6. + */ +#define MSG_FIBRECHANNELEX_DP 21 +typedef struct _FIBRECHANNELEX_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + UINT32 Reserved ; + UINT8 WWN[ 8 ] ; /* World Wide Name */ + UINT8 Lun[ 8 ] ; /* Logical unit, T-10 SCSI Architecture Model 4 specification */ +} FIBRECHANNELEX_DEVICE_PATH ; + +#define MSG_1394_DP 0x04 +typedef struct _F1394_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 Reserved; + UINT64 Guid; +} F1394_DEVICE_PATH; + +#define MSG_USB_DP 0x05 +typedef struct _USB_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT8 Port; + UINT8 Endpoint; +} USB_DEVICE_PATH; + +/** + * SATA Device Path SubType. + * UEFI 2.0 specification version 2.4 § 9.3.5.6. + */ +#define MSG_SATA_DP 18 +typedef struct _SATA_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + UINT16 HBAPortNumber ; + UINT16 PortMultiplierPortNumber ; + UINT16 Lun ; /* Logical Unit Number */ +} SATA_DEVICE_PATH ; + +/** + * USB WWID Device Path SubType. + * UEFI 2.0 specification version 2.4 § 9.3.5.7. + */ +#define MSG_USB_WWID_DP 16 +typedef struct _USB_WWID_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + UINT16 InterfaceNumber ; + UINT16 VendorId ; + UINT16 ProductId ; + CHAR16 SerialNumber[ 1 ] ; /* UTF-16 characters of the USB serial number */ +} USB_WWID_DEVICE_PATH ; + +/** + * Device Logical Unit SubType. + * UEFI 2.0 specification version 2.4 § 9.3.5.8. + */ +#define MSG_DEVICE_LOGICAL_UNIT_DP 17 +typedef struct _DEVICE_LOGICAL_UNIT_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + UINT8 Lun ; /* Logical Unit Number */ +} DEVICE_LOGICAL_UNIT_DEVICE_PATH ; + +#define MSG_USB_CLASS_DP 0x0F +typedef struct _USB_CLASS_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT16 VendorId; + UINT16 ProductId; + UINT8 DeviceClass; + UINT8 DeviceSubclass; + UINT8 DeviceProtocol; +} USB_CLASS_DEVICE_PATH; + +#define MSG_I2O_DP 0x06 +typedef struct _I2O_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 Tid; +} I2O_DEVICE_PATH; + +#define MSG_MAC_ADDR_DP 0x0b +typedef struct _MAC_ADDR_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + EFI_MAC_ADDRESS MacAddress; + UINT8 IfType; +} MAC_ADDR_DEVICE_PATH; + +#define MSG_IPv4_DP 0x0c +typedef struct _IPv4_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + EFI_IPv4_ADDRESS LocalIpAddress; + EFI_IPv4_ADDRESS RemoteIpAddress; + UINT16 LocalPort; + UINT16 RemotePort; + UINT16 Protocol; + BOOLEAN StaticIpAddress; + /* new from UEFI version 2, code must check Length field in Header */ + EFI_IPv4_ADDRESS GatewayIpAddress ; + EFI_IPv4_ADDRESS SubnetMask ; +} IPv4_DEVICE_PATH; + +#define MSG_IPv6_DP 0x0d +typedef struct _IPv6_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + EFI_IPv6_ADDRESS LocalIpAddress; + EFI_IPv6_ADDRESS RemoteIpAddress; + UINT16 LocalPort; + UINT16 RemotePort; + UINT16 Protocol; + BOOLEAN IPAddressOrigin ; + /* new from UEFI version 2, code must check Length field in Header */ + UINT8 PrefixLength ; + EFI_IPv6_ADDRESS GatewayIpAddress ; +} IPv6_DEVICE_PATH; + + +/** + * Uniform Resource Identifiers SubType. + * UEFI 2.0 specification version 2.4C § 9.3.5.23. + */ +#define MSG_URI_DP 24 +typedef struct _URI_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + CHAR8 Uri[1]; +} URI_DEVICE_PATH; + +/** + * Device Logical Unit SubType. + * UEFI 2.0 specification version 2.4 § 9.3.5.8. + */ +#define MSG_VLAN_DP 20 +typedef struct _VLAN_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + UINT16 VlanId ; +} VLAN_DEVICE_PATH; + +#define MSG_INFINIBAND_DP 0x09 +typedef struct _INFINIBAND_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 ResourceFlags; + UINT8 PortGid[16]; + UINT64 ServiceId; + UINT64 TargetPortId; + UINT64 DeviceId; +} INFINIBAND_DEVICE_PATH; + +#define MSG_UART_DP 0x0e +typedef struct _UART_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 Reserved; + UINT64 BaudRate; + UINT8 DataBits; + UINT8 Parity; + UINT8 StopBits; +} UART_DEVICE_PATH; + +#define MSG_VENDOR_DP 0x0A +/* Use VENDOR_DEVICE_PATH struct */ + +#define EFI_PC_ANSI_GUID \ + { 0xe0c14753, 0xf9be, 0x11d2, {0x9a, 0x0c, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } +#define DEVICE_PATH_MESSAGING_PC_ANSI EFI_PC_ANSI_GUID + +#define EFI_VT_100_GUID \ + { 0xdfa66065, 0xb419, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } +#define DEVICE_PATH_MESSAGING_VT_100 EFI_VT_100_GUID + +#define EFI_VT_100_PLUS_GUID \ + { 0x7baec70b, 0x57e0, 0x4c76, {0x8e, 0x87, 0x2f, 0x9e, 0x28, 0x08, 0x83, 0x43} } +#define DEVICE_PATH_MESSAGING_VT_100_PLUS EFI_VT_100_PLUS_GUID + +#define EFI_VT_UTF8_GUID \ + { 0xad15a0d6, 0x8bec, 0x4acf, {0xa0, 0x73, 0xd0, 0x1d, 0xe7, 0x7e, 0x2d, 0x88} } +#define DEVICE_PATH_MESSAGING_VT_UTF8 EFI_VT_UTF8_GUID + + +/* + * Media Device Path (UEFI 2.4 specification, version 2.4 § 9.3.6.) + */ +#define MEDIA_DEVICE_PATH 0x04 + +#define MEDIA_HARDDRIVE_DP 0x01 +typedef struct _HARDDRIVE_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 PartitionNumber; + UINT64 PartitionStart; + UINT64 PartitionSize; + UINT8 Signature[16]; + UINT8 MBRType; + UINT8 SignatureType; +} HARDDRIVE_DEVICE_PATH; + +#define MBR_TYPE_PCAT 0x01 +#define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02 + +#define SIGNATURE_TYPE_MBR 0x01 +#define SIGNATURE_TYPE_GUID 0x02 + +#define MEDIA_CDROM_DP 0x02 +typedef struct _CDROM_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT32 BootEntry; + UINT64 PartitionStart; + UINT64 PartitionSize; +} CDROM_DEVICE_PATH; + +#define MEDIA_VENDOR_DP 0x03 +/* Use VENDOR_DEVICE_PATH struct */ + +#define MEDIA_FILEPATH_DP 0x04 +typedef struct _FILEPATH_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + CHAR16 PathName[1]; +} FILEPATH_DEVICE_PATH; + +#define SIZE_OF_FILEPATH_DEVICE_PATH EFI_FIELD_OFFSET(FILEPATH_DEVICE_PATH,PathName) + +#define MEDIA_PROTOCOL_DP 0x05 +typedef struct _MEDIA_PROTOCOL_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + EFI_GUID Protocol; +} MEDIA_PROTOCOL_DEVICE_PATH; + +/** + * PIWG Firmware File SubType. + * UEFI 2.0 specification version 2.4 § 9.3.6.6. + */ +#define MEDIA_PIWG_FW_FILE_DP 6 +typedef struct _MEDIA_FW_VOL_FILEPATH_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + EFI_GUID FvFileName ; +} MEDIA_FW_VOL_FILEPATH_DEVICE_PATH ; + +/** + * PIWG Firmware Volume Device Path SubType. + * UEFI 2.0 specification version 2.4 § 9.3.6.7. + */ +#define MEDIA_PIWG_FW_VOL_DP 7 +typedef struct _MEDIA_FW_VOL_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + EFI_GUID FvName ; +} MEDIA_FW_VOL_DEVICE_PATH ; + +/** + * Media relative offset range device path. + * UEFI 2.0 specification version 2.4 § 9.3.6.8. + */ +#define MEDIA_RELATIVE_OFFSET_RANGE_DP 8 +typedef struct _MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header ; + UINT32 Reserved ; + UINT64 StartingOffset ; + UINT64 EndingOffset ; +} MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH ; + + +/* + * BIOS Boot Specification Device Path (UEFI 2.4 specification, version 2.4 § 9.3.7.) + */ +#define BBS_DEVICE_PATH 0x05 + +#define BBS_BBS_DP 0x01 +typedef struct _BBS_BBS_DEVICE_PATH { + EFI_DEVICE_PATH_PROTOCOL Header; + UINT16 DeviceType; + UINT16 StatusFlag; + CHAR8 String[1]; +} BBS_BBS_DEVICE_PATH; + +/* DeviceType definitions - from BBS specification */ +#define BBS_TYPE_FLOPPY 0x01 +#define BBS_TYPE_HARDDRIVE 0x02 +#define BBS_TYPE_CDROM 0x03 +#define BBS_TYPE_PCMCIA 0x04 +#define BBS_TYPE_USB 0x05 +#define BBS_TYPE_EMBEDDED_NETWORK 0x06 +#define BBS_TYPE_DEV 0x80 +#define BBS_TYPE_UNKNOWN 0xFF + +typedef union { + EFI_DEVICE_PATH_PROTOCOL DevPath; + PCI_DEVICE_PATH Pci; + PCCARD_DEVICE_PATH PcCard; + MEMMAP_DEVICE_PATH MemMap; + VENDOR_DEVICE_PATH Vendor; + UNKNOWN_DEVICE_VENDOR_DEVICE_PATH UnknownVendor; + CONTROLLER_DEVICE_PATH Controller; + ACPI_HID_DEVICE_PATH Acpi; + + ATAPI_DEVICE_PATH Atapi; + SCSI_DEVICE_PATH Scsi; + FIBRECHANNEL_DEVICE_PATH FibreChannel; + + F1394_DEVICE_PATH F1394; + USB_DEVICE_PATH Usb; + USB_CLASS_DEVICE_PATH UsbClass; + I2O_DEVICE_PATH I2O; + MAC_ADDR_DEVICE_PATH MacAddr; + IPv4_DEVICE_PATH Ipv4; + IPv6_DEVICE_PATH Ipv6; + URI_DEVICE_PATH Uri; + INFINIBAND_DEVICE_PATH InfiniBand; + UART_DEVICE_PATH Uart; + + HARDDRIVE_DEVICE_PATH HardDrive; + CDROM_DEVICE_PATH CD; + + FILEPATH_DEVICE_PATH FilePath; + MEDIA_PROTOCOL_DEVICE_PATH MediaProtocol; + + BBS_BBS_DEVICE_PATH Bbs; + +} EFI_DEV_PATH; + +typedef union { + EFI_DEVICE_PATH_PROTOCOL *DevPath; + PCI_DEVICE_PATH *Pci; + PCCARD_DEVICE_PATH *PcCard; + MEMMAP_DEVICE_PATH *MemMap; + VENDOR_DEVICE_PATH *Vendor; + UNKNOWN_DEVICE_VENDOR_DEVICE_PATH *UnknownVendor; + CONTROLLER_DEVICE_PATH *Controller; + ACPI_HID_DEVICE_PATH *Acpi; + + ATAPI_DEVICE_PATH *Atapi; + SCSI_DEVICE_PATH *Scsi; + FIBRECHANNEL_DEVICE_PATH *FibreChannel; + + F1394_DEVICE_PATH *F1394; + USB_DEVICE_PATH *Usb; + USB_CLASS_DEVICE_PATH *UsbClass; + I2O_DEVICE_PATH *I2O; + MAC_ADDR_DEVICE_PATH *MacAddr; + IPv4_DEVICE_PATH *Ipv4; + IPv6_DEVICE_PATH *Ipv6; + URI_DEVICE_PATH *Uri; + INFINIBAND_DEVICE_PATH *InfiniBand; + UART_DEVICE_PATH *Uart; + + HARDDRIVE_DEVICE_PATH *HardDrive; + + FILEPATH_DEVICE_PATH *FilePath; + MEDIA_PROTOCOL_DEVICE_PATH *MediaProtocol; + + CDROM_DEVICE_PATH *CD; + BBS_BBS_DEVICE_PATH *Bbs; + +} EFI_DEV_PATH_PTR; + +#define EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID \ + { 0x8b843e20, 0x8132, 0x4852, {0x90, 0xcc, 0x55, 0x1a, 0x4e, 0x4a, 0x7f, 0x1c} } + +typedef +CHAR16* +(EFIAPI *EFI_DEVICE_PATH_TO_TEXT_NODE) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *DeviceNode, + IN BOOLEAN DisplayOnly, + IN BOOLEAN AllowShortcuts + ); + +typedef +CHAR16* +(EFIAPI *EFI_DEVICE_PATH_TO_TEXT_PATH) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, + IN BOOLEAN DisplayOnly, + IN BOOLEAN AllowShortcuts + ); + +typedef struct _EFI_DEVICE_PATH_TO_TEXT_PROTOCOL { + EFI_DEVICE_PATH_TO_TEXT_NODE ConvertDeviceNodeToText; + EFI_DEVICE_PATH_TO_TEXT_PATH ConvertDevicePathToText; +} EFI_DEVICE_PATH_TO_TEXT_PROTOCOL; + +#define EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL_GUID \ + { 0x5c99a21, 0xc70f, 0x4ad2, {0x8a, 0x5f, 0x35, 0xdf, 0x33, 0x43, 0xf5, 0x1e} } + +typedef +EFI_DEVICE_PATH_PROTOCOL* +(EFIAPI *EFI_DEVICE_PATH_FROM_TEXT_NODE) ( + IN CONST CHAR16 *TextDeviceNode + ); + +typedef +EFI_DEVICE_PATH_PROTOCOL* +(EFIAPI *EFI_DEVICE_PATH_FROM_TEXT_PATH) ( + IN CONST CHAR16 *TextDevicePath + ); + +typedef struct { + EFI_DEVICE_PATH_FROM_TEXT_NODE ConvertTextToDeviceNode; + EFI_DEVICE_PATH_FROM_TEXT_PATH ConvertTextToDevicePath; +} EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL; + +#define EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID \ + { 0x379be4e, 0xd706, 0x437d, {0xb0, 0x37, 0xed, 0xb8, 0x2f, 0xb7, 0x72, 0xa4} } + +typedef +UINTN +(EFIAPI *EFI_DEVICE_PATH_UTILS_GET_DEVICE_PATH_SIZE) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath + ); + +typedef +EFI_DEVICE_PATH_PROTOCOL* +(EFIAPI *EFI_DEVICE_PATH_UTILS_DUP_DEVICE_PATH) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath + ); + +typedef +EFI_DEVICE_PATH_PROTOCOL* +(EFIAPI *EFI_DEVICE_PATH_UTILS_APPEND_PATH) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *Src1, + IN CONST EFI_DEVICE_PATH_PROTOCOL *Src2 + ); + +typedef +EFI_DEVICE_PATH_PROTOCOL* +(EFIAPI *EFI_DEVICE_PATH_UTILS_APPEND_NODE) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, + IN CONST EFI_DEVICE_PATH_PROTOCOL *DeviceNode +); + +typedef +EFI_DEVICE_PATH_PROTOCOL* +(EFIAPI *EFI_DEVICE_PATH_UTILS_APPEND_INSTANCE) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, + IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathInstance +); + +typedef +EFI_DEVICE_PATH_PROTOCOL* +(EFIAPI *EFI_DEVICE_PATH_UTILS_GET_NEXT_INSTANCE) ( + IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePathInstance, + OUT UINTN *DevicePathInstanceSize OPTIONAL +); + +typedef +EFI_DEVICE_PATH_PROTOCOL* +(EFIAPI *EFI_DEVICE_PATH_UTILS_CREATE_NODE) ( + IN UINT8 NodeType, + IN UINT8 NodeSubType, + IN UINT16 NodeLength + ); + +typedef +BOOLEAN +(EFIAPI *EFI_DEVICE_PATH_UTILS_IS_MULTI_INSTANCE) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath + ); + +typedef struct _EFI_DEVICE_PATH_UTILITIES_PROTOCOL { + EFI_DEVICE_PATH_UTILS_GET_DEVICE_PATH_SIZE GetDevicePathSize; + EFI_DEVICE_PATH_UTILS_DUP_DEVICE_PATH DuplicateDevicePath; + EFI_DEVICE_PATH_UTILS_APPEND_PATH AppendDevicePath; + EFI_DEVICE_PATH_UTILS_APPEND_NODE AppendDeviceNode; + EFI_DEVICE_PATH_UTILS_APPEND_INSTANCE AppendDevicePathInstance; + EFI_DEVICE_PATH_UTILS_GET_NEXT_INSTANCE GetNextDevicePathInstance; + EFI_DEVICE_PATH_UTILS_IS_MULTI_INSTANCE IsDevicePathMultiInstance; + EFI_DEVICE_PATH_UTILS_CREATE_NODE CreateDeviceNode; +} EFI_DEVICE_PATH_UTILITIES_PROTOCOL; + +#endif diff --git a/gnuefi/inc/efierr.h b/gnuefi/inc/efierr.h new file mode 100644 index 0000000..ac9ef7b --- /dev/null +++ b/gnuefi/inc/efierr.h @@ -0,0 +1,73 @@ +#ifndef _EFI_ERR_H +#define _EFI_ERR_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efierr.h + +Abstract: + + EFI error codes + + + + +Revision History + +--*/ + + +#define EFIWARN(a) (a) +#define EFI_ERROR(a) (((INTN) a) < 0) + + +#define EFI_SUCCESS 0 +#define EFI_LOAD_ERROR EFIERR(1) +#define EFI_INVALID_PARAMETER EFIERR(2) +#define EFI_UNSUPPORTED EFIERR(3) +#define EFI_BAD_BUFFER_SIZE EFIERR(4) +#define EFI_BUFFER_TOO_SMALL EFIERR(5) +#define EFI_NOT_READY EFIERR(6) +#define EFI_DEVICE_ERROR EFIERR(7) +#define EFI_WRITE_PROTECTED EFIERR(8) +#define EFI_OUT_OF_RESOURCES EFIERR(9) +#define EFI_VOLUME_CORRUPTED EFIERR(10) +#define EFI_VOLUME_FULL EFIERR(11) +#define EFI_NO_MEDIA EFIERR(12) +#define EFI_MEDIA_CHANGED EFIERR(13) +#define EFI_NOT_FOUND EFIERR(14) +#define EFI_ACCESS_DENIED EFIERR(15) +#define EFI_NO_RESPONSE EFIERR(16) +#define EFI_NO_MAPPING EFIERR(17) +#define EFI_TIMEOUT EFIERR(18) +#define EFI_NOT_STARTED EFIERR(19) +#define EFI_ALREADY_STARTED EFIERR(20) +#define EFI_ABORTED EFIERR(21) +#define EFI_ICMP_ERROR EFIERR(22) +#define EFI_TFTP_ERROR EFIERR(23) +#define EFI_PROTOCOL_ERROR EFIERR(24) +#define EFI_INCOMPATIBLE_VERSION EFIERR(25) +#define EFI_SECURITY_VIOLATION EFIERR(26) +#define EFI_CRC_ERROR EFIERR(27) +#define EFI_END_OF_MEDIA EFIERR(28) +#define EFI_END_OF_FILE EFIERR(31) +#define EFI_INVALID_LANGUAGE EFIERR(32) +#define EFI_COMPROMISED_DATA EFIERR(33) +#define EFI_IP_ADDRESS_CONFLICT EFIERR(34) +#define EFI_HTTP_ERROR EFIERR(35) + +#define EFI_WARN_UNKOWN_GLYPH EFIWARN(1) +#define EFI_WARN_UNKNOWN_GLYPH EFIWARN(1) +#define EFI_WARN_DELETE_FAILURE EFIWARN(2) +#define EFI_WARN_WRITE_FAILURE EFIWARN(3) +#define EFI_WARN_BUFFER_TOO_SMALL EFIWARN(4) +#define EFI_WARN_STALE_DATA EFIWARN(5) +#define EFI_WARN_FILE_SYSTEM EFIWARN(6) +#define EFI_WARN_RESET_REQUIRED EFIWARN(7) + +#endif + diff --git a/gnuefi/inc/efifs.h b/gnuefi/inc/efifs.h new file mode 100644 index 0000000..fc595d1 --- /dev/null +++ b/gnuefi/inc/efifs.h @@ -0,0 +1,116 @@ +#ifndef _EFI_FS_H +#define _EFI_FS_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efifs.h + +Abstract: + + EFI File System structures + + + +Revision History + +--*/ + + +// +// EFI Partition header (normaly starts in LBA 1) +// + +#define EFI_PARTITION_SIGNATURE 0x5053595320494249 +#define EFI_PARTITION_REVISION 0x00010001 +#define MIN_EFI_PARTITION_BLOCK_SIZE 512 +#define EFI_PARTITION_LBA 1 + +typedef struct _EFI_PARTITION_HEADER { + EFI_TABLE_HEADER Hdr; + UINT32 DirectoryAllocationNumber; + UINT32 BlockSize; + EFI_LBA FirstUsableLba; + EFI_LBA LastUsableLba; + EFI_LBA UnusableSpace; + EFI_LBA FreeSpace; + EFI_LBA RootFile; + EFI_LBA SecutiryFile; +} EFI_PARTITION_HEADER; + + +// +// File header +// + +#define EFI_FILE_HEADER_SIGNATURE 0x454c494620494249 +#define EFI_FILE_HEADER_REVISION 0x00010000 +#define EFI_FILE_STRING_SIZE 260 + +typedef struct _EFI_FILE_HEADER { + EFI_TABLE_HEADER Hdr; + UINT32 Class; + UINT32 LBALOffset; + EFI_LBA Parent; + UINT64 FileSize; + UINT64 FileAttributes; + EFI_TIME FileCreateTime; + EFI_TIME FileModificationTime; + EFI_GUID VendorGuid; + CHAR16 FileString[EFI_FILE_STRING_SIZE]; +} EFI_FILE_HEADER; + + +// +// Return the file's first LBAL which is in the same +// logical block as the file header +// + +#define EFI_FILE_LBAL(a) ((EFI_LBAL *) (((CHAR8 *) (a)) + (a)->LBALOffset)) + +#define EFI_FILE_CLASS_FREE_SPACE 1 +#define EFI_FILE_CLASS_EMPTY 2 +#define EFI_FILE_CLASS_NORMAL 3 + + +// +// Logical Block Address List - the fundemental block +// description structure +// + +#define EFI_LBAL_SIGNATURE 0x4c41424c20494249 +#define EFI_LBAL_REVISION 0x00010000 + +typedef struct _EFI_LBAL { + EFI_TABLE_HEADER Hdr; + UINT32 Class; + EFI_LBA Parent; + EFI_LBA Next; + UINT32 ArraySize; + UINT32 ArrayCount; +} EFI_LBAL; + +// Array size +#define EFI_LBAL_ARRAY_SIZE(lbal,offs,blks) \ + (((blks) - (offs) - (lbal)->Hdr.HeaderSize) / sizeof(EFI_RL)) + +// +// Logical Block run-length +// + +typedef struct { + EFI_LBA Start; + UINT64 Length; +} EFI_RL; + +// +// Return the run-length structure from an LBAL header +// + +#define EFI_LBAL_RL(a) ((EFI_RL*) (((CHAR8 *) (a)) + (a)->Hdr.HeaderSize)) + +#endif + diff --git a/gnuefi/inc/efigpt.h b/gnuefi/inc/efigpt.h new file mode 100644 index 0000000..d1694ae --- /dev/null +++ b/gnuefi/inc/efigpt.h @@ -0,0 +1,68 @@ +#ifndef _EFI_GPT_H +#define _EFI_GPT_H +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + EfiGpt.h + +Abstract: + Include file for EFI partitioning scheme + + + +Revision History + +--*/ + +#define PRIMARY_PART_HEADER_LBA 1 + +typedef struct { + EFI_TABLE_HEADER Header; + EFI_LBA MyLBA; + EFI_LBA AlternateLBA; + EFI_LBA FirstUsableLBA; + EFI_LBA LastUsableLBA; + EFI_GUID DiskGUID; + EFI_LBA PartitionEntryLBA; + UINT32 NumberOfPartitionEntries; + UINT32 SizeOfPartitionEntry; + UINT32 PartitionEntryArrayCRC32; +} EFI_PARTITION_TABLE_HEADER; + +#define EFI_PTAB_HEADER_ID "EFI PART" + +typedef struct { + EFI_GUID PartitionTypeGUID; + EFI_GUID UniquePartitionGUID; + EFI_LBA StartingLBA; + EFI_LBA EndingLBA; + UINT64 Attributes; + CHAR16 PartitionName[36]; +} EFI_PARTITION_ENTRY; + +// +// EFI Partition Attributes +// +#define EFI_PART_USED_BY_EFI 0x0000000000000001 +#define EFI_PART_REQUIRED_TO_FUNCTION 0x0000000000000002 +#define EFI_PART_USED_BY_OS 0x0000000000000004 +#define EFI_PART_REQUIRED_BY_OS 0x0000000000000008 +#define EFI_PART_BACKUP_REQUIRED 0x0000000000000010 +#define EFI_PART_USER_DATA 0x0000000000000020 +#define EFI_PART_CRITICAL_USER_DATA 0x0000000000000040 +#define EFI_PART_REDUNDANT_PARTITION 0x0000000000000080 + +#define EFI_PART_TYPE_UNUSED_GUID \ + { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} } + +#define EFI_PART_TYPE_EFI_SYSTEM_PART_GUID \ + { 0xc12a7328, 0xf81f, 0x11d2, {0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b} } + +#define EFI_PART_TYPE_LEGACY_MBR_GUID \ + { 0x024dee41, 0x33e7, 0x11d3, {0x9d, 0x69, 0x00, 0x08, 0xc7, 0x81, 0xf3, 0x9f} } + +#endif + diff --git a/gnuefi/inc/efiip.h b/gnuefi/inc/efiip.h new file mode 100644 index 0000000..8395079 --- /dev/null +++ b/gnuefi/inc/efiip.h @@ -0,0 +1,459 @@ +#ifndef _EFI_IP_H +#define _EFI_IP_H + +/*++ +Copyright (c) 2013 Intel Corporation + +--*/ + +#define EFI_IP4_SERVICE_BINDING_PROTOCOL \ + {0xc51711e7,0xb4bf,0x404a,{0xbf,0xb8,0x0a,0x04, 0x8e,0xf1,0xff,0xe4}} + +#define EFI_IP4_PROTOCOL \ + {0x41d94cd2,0x35b6,0x455a,{0x82,0x58,0xd4,0xe5,0x13,0x34,0xaa,0xdd}} + +#define EFI_IP6_SERVICE_BINDING_PROTOCOL \ + {0xec835dd3,0xfe0f,0x617b,{0xa6,0x21,0xb3,0x50,0xc3,0xe1,0x33,0x88}} + +#define EFI_IP6_PROTOCOL \ + {0x2c8759d5,0x5c2d,0x66ef,{0x92,0x5f,0xb6,0x6c,0x10,0x19,0x57,0xe2}} + +INTERFACE_DECL(_EFI_IP4); +INTERFACE_DECL(_EFI_IP6); + +typedef struct { + EFI_HANDLE InstanceHandle; + EFI_IPv4_ADDRESS Ip4Address; + EFI_IPv4_ADDRESS SubnetMask; +} EFI_IP4_ADDRESS_PAIR; + +typedef struct { + EFI_HANDLE DriverHandle; + UINT32 AddressCount; + EFI_IP4_ADDRESS_PAIR AddressPairs[1]; +} EFI_IP4_VARIABLE_DATA; + +typedef struct { + UINT8 DefaultProtocol; + BOOLEAN AcceptAnyProtocol; + BOOLEAN AcceptIcmpErrors; + BOOLEAN AcceptBroadcast; + BOOLEAN AcceptPromiscuous; + BOOLEAN UseDefaultAddress; + EFI_IPv4_ADDRESS StationAddress; + EFI_IPv4_ADDRESS SubnetMask; + UINT8 TypeOfService; + UINT8 TimeToLive; + BOOLEAN DoNotFragment; + BOOLEAN RawData; + UINT32 ReceiveTimeout; + UINT32 TransmitTimeout; +} EFI_IP4_CONFIG_DATA; + +typedef struct { + EFI_IPv4_ADDRESS SubnetAddress; + EFI_IPv4_ADDRESS SubnetMask; + EFI_IPv4_ADDRESS GatewayAddress; +} EFI_IP4_ROUTE_TABLE; + +typedef struct { + UINT8 Type; + UINT8 Code; +} EFI_IP4_ICMP_TYPE; + +typedef struct { + BOOLEAN IsStarted; + UINT32 MaxPacketSize; + EFI_IP4_CONFIG_DATA ConfigData; + BOOLEAN IsConfigured; + UINT32 GroupCount; + EFI_IPv4_ADDRESS *GroupTable; + UINT32 RouteCount; + EFI_IP4_ROUTE_TABLE *RouteTable; + UINT32 IcmpTypeCount; + EFI_IP4_ICMP_TYPE *IcmpTypeList; +} EFI_IP4_MODE_DATA; + +typedef +EFI_STATUS +(EFIAPI *EFI_IP4_GET_MODE_DATA) ( + IN struct _EFI_IP4 *This, + OUT EFI_IP4_MODE_DATA *Ip4ModeData OPTIONAL, + OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL, + OUT EFI_SIMPLE_NETWORK_MODE *SnpModeData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP4_CONFIGURE) ( + IN struct _EFI_IP4 *This, + IN EFI_IP4_CONFIG_DATA *IpConfigData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP4_GROUPS) ( + IN struct _EFI_IP4 *This, + IN BOOLEAN JoinFlag, + IN EFI_IPv4_ADDRESS *GroupAddress OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP4_ROUTES) ( + IN struct _EFI_IP4 *This, + IN BOOLEAN DeleteRoute, + IN EFI_IPv4_ADDRESS *SubnetAddress, + IN EFI_IPv4_ADDRESS *SubnetMask, + IN EFI_IPv4_ADDRESS *GatewayAddress + ); + +#pragma pack(1) +typedef struct { + UINT8 HeaderLength:4; + UINT8 Version:4; + UINT8 TypeOfService; + UINT16 TotalLength; + UINT16 Identification; + UINT16 Fragmentation; + UINT8 TimeToLive; + UINT8 Protocol; + UINT16 Checksum; + EFI_IPv4_ADDRESS SourceAddress; + EFI_IPv4_ADDRESS DestinationAddress; +} EFI_IP4_HEADER; +#pragma pack() + +typedef struct { + UINT32 FragmentLength; + VOID *FragmentBuffer; +} EFI_IP4_FRAGMENT_DATA; + +typedef struct { + EFI_TIME TimeStamp; + EFI_EVENT RecycleSignal; + UINT32 HeaderLength; + EFI_IP4_HEADER *Header; + UINT32 OptionsLength; + VOID *Options; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_IP4_FRAGMENT_DATA FragmentTable[1]; +} EFI_IP4_RECEIVE_DATA; + +typedef struct { + EFI_IPv4_ADDRESS SourceAddress; + EFI_IPv4_ADDRESS GatewayAddress; + UINT8 Protocol; + UINT8 TypeOfService; + UINT8 TimeToLive; + BOOLEAN DoNotFragment; +} EFI_IP4_OVERRIDE_DATA; + +typedef struct { + EFI_IPv4_ADDRESS DestinationAddress; + EFI_IP4_OVERRIDE_DATA *OverrideData; + UINT32 OptionsLength; + VOID *OptionsBuffer; + UINT32 TotalDataLength; + UINT32 FragmentCount; + EFI_IP4_FRAGMENT_DATA FragmentTable[1]; +} EFI_IP4_TRANSMIT_DATA; + +typedef struct { + EFI_EVENT Event; + EFI_STATUS Status; + union { + EFI_IP4_RECEIVE_DATA *RxData; + EFI_IP4_TRANSMIT_DATA *TxData; + } Packet; +} EFI_IP4_COMPLETION_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_IP4_TRANSMIT) ( + IN struct _EFI_IP4 *This, + IN EFI_IP4_COMPLETION_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP4_RECEIVE) ( + IN struct _EFI_IP4 *This, + IN EFI_IP4_COMPLETION_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP4_CANCEL)( + IN struct _EFI_IP4 *This, + IN EFI_IP4_COMPLETION_TOKEN *Token OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP4_POLL) ( + IN struct _EFI_IP4 *This + ); + +typedef struct _EFI_IP4 { + EFI_IP4_GET_MODE_DATA GetModeData; + EFI_IP4_CONFIGURE Configure; + EFI_IP4_GROUPS Groups; + EFI_IP4_ROUTES Routes; + EFI_IP4_TRANSMIT Transmit; + EFI_IP4_RECEIVE Receive; + EFI_IP4_CANCEL Cancel; + EFI_IP4_POLL Poll; +} EFI_IP4; + +typedef struct { + UINT8 DefaultProtocol; + BOOLEAN AcceptAnyProtocol; + BOOLEAN AcceptIcmpErrors; + BOOLEAN AcceptPromiscuous; + EFI_IPv6_ADDRESS DestinationAddress; + EFI_IPv6_ADDRESS StationAddress; + UINT8 TrafficClass; + UINT8 HopLimit; + UINT32 FlowLabel; + UINT32 ReceiveTimeout; + UINT32 TransmitTimeout; +} EFI_IP6_CONFIG_DATA; + +typedef struct { + EFI_IPv6_ADDRESS Address; + UINT8 PrefixLength; +} EFI_IP6_ADDRESS_INFO; + +typedef struct { + EFI_IPv6_ADDRESS Gateway; + EFI_IPv6_ADDRESS Destination; + UINT8 PrefixLength; +} EFI_IP6_ROUTE_TABLE; + +typedef enum { + EfiNeighborInComplete, + EfiNeighborReachable, + EfiNeighborStale, + EfiNeighborDelay, + EfiNeighborProbe +} EFI_IP6_NEIGHBOR_STATE; + +typedef struct { + EFI_IPv6_ADDRESS Neighbor; + EFI_MAC_ADDRESS LinkAddress; + EFI_IP6_NEIGHBOR_STATE State; +} EFI_IP6_NEIGHBOR_CACHE; + +typedef struct { + UINT8 Type; + UINT8 Code; +} EFI_IP6_ICMP_TYPE; + +//*********************************************************** +// ICMPv6 type definitions for error messages +//*********************************************************** +#define ICMP_V6_DEST_UNREACHABLE 0x1 +#define ICMP_V6_PACKET_TOO_BIG 0x2 +#define ICMP_V6_TIME_EXCEEDED 0x3 +#define ICMP_V6_PARAMETER_PROBLEM 0x4 + +//*********************************************************** +// ICMPv6 type definition for informational messages +//*********************************************************** +#define ICMP_V6_ECHO_REQUEST 0x80 +#define ICMP_V6_ECHO_REPLY 0x81 +#define ICMP_V6_LISTENER_QUERY 0x82 +#define ICMP_V6_LISTENER_REPORT 0x83 +#define ICMP_V6_LISTENER_DONE 0x84 +#define ICMP_V6_ROUTER_SOLICIT 0x85 +#define ICMP_V6_ROUTER_ADVERTISE 0x86 +#define ICMP_V6_NEIGHBOR_SOLICIT 0x87 +#define ICMP_V6_NEIGHBOR_ADVERTISE 0x88 +#define ICMP_V6_REDIRECT 0x89 +#define ICMP_V6_LISTENER_REPORT_2 0x8F + +//*********************************************************** +// ICMPv6 code definitions for ICMP_V6_DEST_UNREACHABLE +//*********************************************************** +#define ICMP_V6_NO_ROUTE_TO_DEST 0x0 +#define ICMP_V6_COMM_PROHIBITED 0x1 +#define ICMP_V6_BEYOND_SCOPE 0x2 +#define ICMP_V6_ADDR_UNREACHABLE 0x3 +#define ICMP_V6_PORT_UNREACHABLE 0x4 +#define ICMP_V6_SOURCE_ADDR_FAILED 0x5 +#define ICMP_V6_ROUTE_REJECTED 0x6 + +//*********************************************************** +// ICMPv6 code definitions for ICMP_V6_TIME_EXCEEDED +//*********************************************************** +#define ICMP_V6_TIMEOUT_HOP_LIMIT 0x0 +#define ICMP_V6_TIMEOUT_REASSEMBLE 0x1 + +//*********************************************************** +// ICMPv6 code definitions for ICMP_V6_PARAMETER_PROBLEM +//*********************************************************** +#define ICMP_V6_ERRONEOUS_HEADER 0x0 +#define ICMP_V6_UNRECOGNIZE_NEXT_HDR 0x1 +#define ICMP_V6_UNRECOGNIZE_OPTION 0x2 + +typedef struct { + BOOLEAN IsStarted; + UINT32 MaxPacketSize; + EFI_IP6_CONFIG_DATA ConfigData; + BOOLEAN IsConfigured; + UINT32 AddressCount; + EFI_IP6_ADDRESS_INFO *AddressList; + UINT32 GroupCount; + EFI_IPv6_ADDRESS *GroupTable; + UINT32 RouteCount; + EFI_IP6_ROUTE_TABLE *RouteTable; + UINT32 NeighborCount; + EFI_IP6_NEIGHBOR_CACHE *NeighborCache; + UINT32 PrefixCount; + EFI_IP6_ADDRESS_INFO *PrefixTable; + UINT32 IcmpTypeCount; + EFI_IP6_ICMP_TYPE *IcmpTypeList; +} EFI_IP6_MODE_DATA; + +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_GET_MODE_DATA) ( + IN struct _EFI_IP6 *This, + OUT EFI_IP6_MODE_DATA *Ip6ModeData OPTIONAL, + OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL, + OUT EFI_SIMPLE_NETWORK_MODE *SnpModeData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_CONFIGURE) ( + IN struct _EFI_IP6 *This, + IN EFI_IP6_CONFIG_DATA *Ip6ConfigData OPTIONAL + ); +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_GROUPS) ( + IN struct _EFI_IP6 *This, + IN BOOLEAN JoinFlag, + IN EFI_IPv6_ADDRESS *GroupAddress OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_ROUTES) ( + IN struct _EFI_IP6 *This, + IN BOOLEAN DeleteRoute, + IN EFI_IPv6_ADDRESS *Destination OPTIONAL, + IN UINT8 PrefixLength, + IN EFI_IPv6_ADDRESS *GatewayAddress OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_NEIGHBORS) ( + IN struct _EFI_IP6 *This, + IN BOOLEAN DeleteFlag, + IN EFI_IPv6_ADDRESS *TargetIp6Address, + IN EFI_MAC_ADDRESS *TargetLinkAddress OPTIONAL, + IN UINT32 Timeout, + IN BOOLEAN Override + ); + +typedef struct _EFI_IP6_FRAGMENT_DATA { + UINT32 FragmentLength; + VOID *FragmentBuffer; +} EFI_IP6_FRAGMENT_DATA; + +typedef struct _EFI_IP6_OVERRIDE_DATA { + UINT8 Protocol; + UINT8 HopLimit; + UINT32 FlowLabel; +} EFI_IP6_OVERRIDE_DATA; + +typedef struct _EFI_IP6_TRANSMIT_DATA { + EFI_IPv6_ADDRESS DestinationAddress; + EFI_IP6_OVERRIDE_DATA *OverrideData; + UINT32 ExtHdrsLength; + VOID *ExtHdrs; + UINT8 NextHeader; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_IP6_FRAGMENT_DATA FragmentTable[1]; +} EFI_IP6_TRANSMIT_DATA; + +#pragma pack(1) +typedef struct _EFI_IP6_HEADER { + UINT8 TrafficClassH:4; + UINT8 Version:4; + UINT8 FlowLabelH:4; + UINT8 TrafficClassL:4; + UINT16 FlowLabelL; + UINT16 PayloadLength; + UINT8 NextHeader; + UINT8 HopLimit; + EFI_IPv6_ADDRESS SourceAddress; + EFI_IPv6_ADDRESS DestinationAddress; +} EFI_IP6_HEADER; +#pragma pack() + +typedef struct _EFI_IP6_RECEIVE_DATA { + EFI_TIME TimeStamp; + EFI_EVENT RecycleSignal; + UINT32 HeaderLength; + EFI_IP6_HEADER *Header; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_IP6_FRAGMENT_DATA FragmentTable[1]; +} EFI_IP6_RECEIVE_DATA; + +typedef struct { + EFI_EVENT Event; + EFI_STATUS Status; + union { + EFI_IP6_RECEIVE_DATA *RxData; + EFI_IP6_TRANSMIT_DATA *TxData; + } Packet; +} EFI_IP6_COMPLETION_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_TRANSMIT) ( + IN struct _EFI_IP6 *This, + IN EFI_IP6_COMPLETION_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_RECEIVE) ( + IN struct _EFI_IP6 *This, + IN EFI_IP6_COMPLETION_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_CANCEL)( + IN struct _EFI_IP6 *This, + IN EFI_IP6_COMPLETION_TOKEN *Token OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP6_POLL) ( + IN struct _EFI_IP6 *This + ); + +typedef struct _EFI_IP6 { + EFI_IP6_GET_MODE_DATA GetModeData; + EFI_IP6_CONFIGURE Configure; + EFI_IP6_GROUPS Groups; + EFI_IP6_ROUTES Routes; + EFI_IP6_NEIGHBORS Neighbors; + EFI_IP6_TRANSMIT Transmit; + EFI_IP6_RECEIVE Receive; + EFI_IP6_CANCEL Cancel; + EFI_IP6_POLL Poll; +} EFI_IP6; + +#endif /* _EFI_IP_H */ diff --git a/gnuefi/inc/efilib.h b/gnuefi/inc/efilib.h new file mode 100644 index 0000000..f35d2ed --- /dev/null +++ b/gnuefi/inc/efilib.h @@ -0,0 +1,1089 @@ +#ifndef _EFILIB_INCLUDE_ +#define _EFILIB_INCLUDE_ + +/*++ + +Copyright (c) 2000 Intel Corporation + +Module Name: + + efilib.h + +Abstract: + + EFI library functions + + + +Revision History + +--*/ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "efidebug.h" +#include "efipart.h" +#if defined(_M_X64) || defined(__x86_64__) || defined(__amd64__) +#include "x86_64/efilibplat.h" +#elif defined(_M_IX86) || defined(__i386__) +#include "ia32/efilibplat.h" +#elif defined(_M_IA64) || defined(__ia64__) +#include "ia64/efilibplat.h" +#elif defined (_M_ARM64) || defined(__aarch64__) +#include "aarch64/efilibplat.h" +#elif defined (_M_ARM) || defined(__arm__) +#include "arm/efilibplat.h" +#elif defined (_M_MIPS64) || defined(__mips64__) || defined(__mips64) +#include "mips64el/efilibplat.h" +#elif defined (__riscv) && __riscv_xlen == 64 +#include "riscv64/efilibplat.h" +#elif defined (__loongarch64) +#include "loongarch64/efilibplat.h" +#endif +#include "efilink.h" +#include "efirtlib.h" +#include "efistdarg.h" +#include "pci22.h" +#include "libsmbios.h" + +// +// Public read-only data in the EFI library +// + +extern EFI_SYSTEM_TABLE *ST; +#define gST ST +extern EFI_BOOT_SERVICES *BS; +#define gBS BS +extern EFI_RUNTIME_SERVICES *RT; +#define gRT RT + +extern EFI_GUID gEfiDevicePathProtocolGuid; +#define DevicePathProtocol gEfiDevicePathProtocolGuid +extern EFI_GUID gEfiDevicePathToTextProtocolGuid; +#define DevicePathToTextProtocol gEfiDevicePathToTextProtocolGuid +extern EFI_GUID gEfiDevicePathFromTextProtocolGuid; +#define DevicePathFromTextProtocol gEfiDevicePathFromTextProtocolGuid +extern EFI_GUID gEfiDevicePathUtilitiesProtocolGuid; +#define DevicePathUtilitiesProtocol gEfiDevicePathUtilitiesProtocolGuid +extern EFI_GUID gEfiLoadedImageProtocolGuid; +#define LoadedImageProtocol gEfiLoadedImageProtocolGuid +extern EFI_GUID gEfiSimpleTextInProtocolGuid; +#define TextInProtocol gEfiSimpleTextInProtocolGuid +extern EFI_GUID gEfiSimpleTextOutProtocolGuid; +#define TextOutProtocol gEfiSimpleTextOutProtocolGuid +extern EFI_GUID gEfiGraphicsOutputProtocolGuid; +#define GraphicsOutputProtocol gEfiGraphicsOutputProtocolGuid +extern EFI_GUID gEfiEdidDiscoveredProtocolGuid; +#define EdidDiscoveredProtocol gEfiEdidDiscoveredProtocolGuid +extern EFI_GUID gEfiEdidActiveProtocolGuid; +#define EdidActiveProtocol gEfiEdidActiveProtocolGuid +extern EFI_GUID gEfiEdidOverrideProtocolGuid; +#define EdidOverrideProtocol gEfiEdidOverrideProtocolGuid +extern EFI_GUID gEfiBlockIoProtocolGuid; +#define BlockIoProtocol gEfiBlockIoProtocolGuid +extern EFI_GUID gEfiBlockIo2ProtocolGuid; +#define BlockIo2Protocol gEfiBlockIo2ProtocolGuid +extern EFI_GUID gEfiDiskIoProtocolGuid; +#define DiskIoProtocol gEfiDiskIoProtocolGuid +extern EFI_GUID gEfiDiskIo2ProtocolGuid; +#define DiskIo2Protocol gEfiDiskIo2ProtocolGuid +extern EFI_GUID gEfiSimpleFileSystemProtocolGuid; +#define FileSystemProtocol gEfiSimpleFileSystemProtocolGuid +extern EFI_GUID gEfiLoadFileProtocolGuid; +#define LoadFileProtocol gEfiLoadFileProtocolGuid +extern EFI_GUID gEfiDeviceIoProtocolGuid; +#define DeviceIoProtocol gEfiDeviceIoProtocolGuid +extern EFI_GUID VariableStoreProtocol; +extern EFI_GUID LegacyBootProtocol; +extern EFI_GUID gEfiUnicodeCollationProtocolGuid; +#define UnicodeCollationProtocol gEfiUnicodeCollationProtocolGuid +extern EFI_GUID gEfiSerialIoProtocolGuid; +#define SerialIoProtocol gEfiSerialIoProtocolGuid +extern EFI_GUID VgaClassProtocol; +extern EFI_GUID TextOutSpliterProtocol; +extern EFI_GUID ErrorOutSpliterProtocol; +extern EFI_GUID TextInSpliterProtocol; +extern EFI_GUID gEfiSimpleNetworkProtocolGuid; +#define SimpleNetworkProtocol gEfiSimpleNetworkProtocolGuid +extern EFI_GUID gEfiPxeBaseCodeProtocolGuid; +#define PxeBaseCodeProtocol gEfiPxeBaseCodeProtocolGuid +extern EFI_GUID gEfiPxeBaseCodeCallbackProtocolGuid; +#define PxeCallbackProtocol gEfiPxeBaseCodeCallbackProtocolGuid +extern EFI_GUID gEfiNetworkInterfaceIdentifierProtocolGuid; +#define NetworkInterfaceIdentifierProtocol gEfiNetworkInterfaceIdentifierProtocolGuid +extern EFI_GUID gEFiUiInterfaceProtocolGuid; +#define UiProtocol gEFiUiInterfaceProtocolGuid +extern EFI_GUID InternalShellProtocol; +extern EFI_GUID gEfiPciIoProtocolGuid; +#define PciIoProtocol gEfiPciIoProtocolGuid +extern EFI_GUID gEfiPciRootBridgeIoProtocolGuid; +extern EFI_GUID gEfiDriverBindingProtocolGuid; +#define DriverBindingProtocol gEfiDriverBindingProtocolGuid +extern EFI_GUID gEfiComponentNameProtocolGuid; +#define ComponentNameProtocol gEfiComponentNameProtocolGuid +extern EFI_GUID gEfiComponentName2ProtocolGuid; +#define ComponentName2Protocol gEfiComponentName2ProtocolGuid +extern EFI_GUID gEfiHashProtocolGuid; +#define HashProtocol gEfiHashProtocolGuid +extern EFI_GUID gEfiPlatformDriverOverrideProtocolGuid; +#define PlatformDriverOverrideProtocol gEfiPlatformDriverOverrideProtocolGuid +extern EFI_GUID gEfiBusSpecificDriverOverrideProtocolGuid; +#define BusSpecificDriverOverrideProtocol gEfiBusSpecificDriverOverrideProtocolGuid +extern EFI_GUID gEfiDriverFamilyOverrideProtocolGuid; +#define DriverFamilyOverrideProtocol gEfiDriverFamilyOverrideProtocolGuid +extern EFI_GUID gEfiEbcProtocolGuid; + +extern EFI_GUID gEfiGlobalVariableGuid; +#define EfiGlobalVariable gEfiGlobalVariableGuid +extern EFI_GUID gEfiFileInfoGuid; +#define GenericFileInfo gEfiFileInfoGuid +extern EFI_GUID gEfiFileSystemInfoGuid; +#define FileSystemInfo gEfiFileSystemInfoGuid +extern EFI_GUID gEfiFileSystemVolumeLabelInfoIdGuid; +#define FileSystemVolumeLabelInfo gEfiFileSystemVolumeLabelInfoIdGuid +extern EFI_GUID gEfiPcAnsiGuid; +#define PcAnsiProtocol gEfiPcAnsiGuid +extern EFI_GUID gEfiVT100Guid; +#define Vt100Protocol gEfiVT100Guid +extern EFI_GUID gEfiVT100PlusGuid; +extern EFI_GUID gEfiVTUTF8Guid; + +extern EFI_GUID NullGuid; +extern EFI_GUID UnknownDevice; + +extern EFI_GUID EfiPartTypeSystemPartitionGuid; +extern EFI_GUID EfiPartTypeLegacyMbrGuid; + +extern EFI_GUID MpsTableGuid; +extern EFI_GUID AcpiTableGuid; +extern EFI_GUID SMBIOSTableGuid; +extern EFI_GUID SMBIOS3TableGuid; +extern EFI_GUID SalSystemTableGuid; +extern EFI_GUID EfiDtbTableGuid; + +extern EFI_GUID SimplePointerProtocol; +extern EFI_GUID AbsolutePointerProtocol; + +extern EFI_GUID gEfiDebugImageInfoTableGuid; +extern EFI_GUID gEfiDebugSupportProtocolGuid; + +extern EFI_GUID SimpleTextInputExProtocol; + +extern EFI_GUID ShellProtocolGuid; +extern EFI_GUID ShellParametersProtocolGuid; +extern EFI_GUID ShellDynamicCommandProtocolGuid; + +// +// EFI Variable strings +// +#define LOAD_OPTION_ACTIVE 0x00000001 + +#define VarLanguageCodes L"LangCodes" +#define VarLanguage L"Lang" +#define VarTimeout L"Timeout" +#define VarConsoleInp L"ConIn" +#define VarConsoleOut L"ConOut" +#define VarErrorOut L"ErrOut" +#define VarBootOption L"Boot%04x" +#define VarBootOrder L"BootOrder" +#define VarBootNext L"BootNext" +#define VarBootCurrent L"BootCurrent" +#define VarDriverOption L"Driver%04x" +#define VarDriverOrder L"DriverOrder" +#define VarConsoleInpDev L"ConInDev" +#define VarConsoleOutDev L"ConOutDev" +#define VarErrorOutDev L"ErrOutDev" + +#define LanguageCodeEnglish "eng" + +extern EFI_DEVICE_PATH RootDevicePath[]; +extern EFI_DEVICE_PATH EndDevicePath[]; +extern EFI_DEVICE_PATH EndInstanceDevicePath[]; + +// +// Other public data in the EFI library +// + +extern EFI_MEMORY_TYPE PoolAllocationType; + +// +// STATIC - Name is internal to the module +// INTERNAL - Name is internal to the component (i.e., directory) +// BOOTSERVCE - Name of a boot service function +// + +#define STATIC +#define INTERNAL +#define BOOTSERVICE + +// +// Prototypes +// + +VOID +InitializeLib ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + +VOID +InitializeUnicodeSupport ( + CHAR8 *LangCode + ); + +VOID +EFIDebugVariable ( + VOID + ); + +VOID +Exit( + IN EFI_STATUS ExitStatus, + IN UINTN ExitDataSize, + IN CHAR16 *ExitData OPTIONAL + ); + +INTN +GetShellArgcArgv( + EFI_HANDLE ImageHandle, + CHAR16 **Argv[] /* Statically allocated */ + ); + +VOID +SetCrc ( + IN OUT EFI_TABLE_HEADER *Hdr + ); + +VOID +SetCrcAltSize ( + IN UINTN Size, + IN OUT EFI_TABLE_HEADER *Hdr + ); + +BOOLEAN +CheckCrc ( + IN UINTN MaxSize, + IN OUT EFI_TABLE_HEADER *Hdr + ); + +BOOLEAN +CheckCrcAltSize ( + IN UINTN MaxSize, + IN UINTN Size, + IN OUT EFI_TABLE_HEADER *Hdr + ); + +UINT32 +CalculateCrc ( + UINT8 *pt, + UINTN Size + ); + +VOID +ZeroMem ( + IN VOID *Buffer, + IN UINTN Size + ); + +VOID EFIAPI +SetMem ( + IN VOID *Buffer, + IN UINTN Size, + IN UINT8 Value + ); + +VOID EFIAPI +CopyMem ( + IN VOID *Dest, + IN VOID *Src, + IN UINTN len + ); + +INTN +CompareMem ( + IN CONST VOID *Dest, + IN CONST VOID *Src, + IN UINTN len + ); + +INTN +StrCmp ( + IN CONST CHAR16 *s1, + IN CONST CHAR16 *s2 + ); + +INTN +StrnCmp ( + IN CONST CHAR16 *s1, + IN CONST CHAR16 *s2, + IN UINTN len + ); + +INTN +StriCmp ( + IN CONST CHAR16 *s1, + IN CONST CHAR16 *s2 + ); + +VOID +StrLwr ( + IN CHAR16 *Str + ); + +VOID +StrUpr ( + IN CHAR16 *Str + ); + +VOID +StrCpy ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src + ); + +VOID +StrnCpy ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src, + IN UINTN Len + ); + +CHAR16 * +StpCpy ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src + ); + +CHAR16 * +StpnCpy ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src, + IN UINTN Len + ); + +VOID +StrCat ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src + ); + +VOID +StrnCat ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src, + IN UINTN Len + ); + +UINTN +StrLen ( + IN CONST CHAR16 *s1 + ); + +UINTN +StrnLen ( + IN CONST CHAR16 *s1, + IN UINTN Len + ); + +UINTN +StrSize ( + IN CONST CHAR16 *s1 + ); + +CHAR16 * +StrDuplicate ( + IN CONST CHAR16 *Src + ); + +UINTN +strlena ( + IN CONST CHAR8 *s1 + ); + +UINTN +strcmpa ( + IN CONST CHAR8 *s1, + IN CONST CHAR8 *s2 + ); + +UINTN +strncmpa ( + IN CONST CHAR8 *s1, + IN CONST CHAR8 *s2, + IN UINTN len + ); + +UINTN +xtoi ( + CONST CHAR16 *str + ); + +UINTN +Atoi ( + CONST CHAR16 *str + ); + +BOOLEAN +MetaMatch ( + IN CHAR16 *String, + IN CHAR16 *Pattern + ); + +BOOLEAN +MetaiMatch ( + IN CHAR16 *String, + IN CHAR16 *Pattern + ); + +UINT64 +LShiftU64 ( + IN UINT64 Operand, + IN UINTN Count + ); + +UINT64 +RShiftU64 ( + IN UINT64 Operand, + IN UINTN Count + ); + +UINT64 +MultU64x32 ( + IN UINT64 Multiplicand, + IN UINTN Multiplier + ); + +UINT64 +DivU64x32 ( + IN UINT64 Dividend, + IN UINTN Divisor, + OUT UINTN *Remainder OPTIONAL + ); + +VOID +InitializeLock ( + IN OUT FLOCK *Lock, + IN EFI_TPL Priority + ); + +VOID +AcquireLock ( + IN FLOCK *Lock + ); + +VOID +ReleaseLock ( + IN FLOCK *Lock + ); + + +INTN +CompareGuid( + IN EFI_GUID *Guid1, + IN EFI_GUID *Guid2 + ); + +VOID * +AllocatePool ( + IN UINTN Size + ); + +VOID * +AllocateZeroPool ( + IN UINTN Size + ); + +VOID * +ReallocatePool ( + IN VOID *OldPool, + IN UINTN OldSize, + IN UINTN NewSize + ); + +VOID +FreePool ( + IN VOID *p + ); + + +VOID +Output ( + IN CHAR16 *Str + ); + +VOID +Input ( + IN CHAR16 *Prompt OPTIONAL, + OUT CHAR16 *InStr, + IN UINTN StrLen + ); + +VOID +IInput ( + IN SIMPLE_TEXT_OUTPUT_INTERFACE *ConOut, + IN SIMPLE_INPUT_INTERFACE *ConIn, + IN CHAR16 *Prompt OPTIONAL, + OUT CHAR16 *InStr, + IN UINTN StrLen + ); + +UINTN +Print ( + IN CONST CHAR16 *fmt, + ... + ); + +UINTN +VPrint ( + IN CONST CHAR16 *fmt, + va_list args + ); + +UINTN +UnicodeSPrint ( + OUT CHAR16 *Str, + IN UINTN StrSize, + IN CONST CHAR16 *fmt, + ... + ); + +UINTN +UnicodeVSPrint ( + OUT CHAR16 *Str, + IN UINTN StrSize, + IN CONST CHAR16 *fmt, + va_list args + ); + +CHAR16 * +VPoolPrint ( + IN CONST CHAR16 *fmt, + va_list args + ); + +CHAR16 * +PoolPrint ( + IN CONST CHAR16 *fmt, + ... + ); + +typedef struct { + CHAR16 *str; + UINTN len; + UINTN maxlen; +} POOL_PRINT; + +CHAR16 * +CatPrint ( + IN OUT POOL_PRINT *Str, + IN CONST CHAR16 *fmt, + ... + ); + +UINTN +PrintAt ( + IN UINTN Column, + IN UINTN Row, + IN CONST CHAR16 *fmt, + ... + ); + +UINTN +IPrint ( + IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out, + IN CONST CHAR16 *fmt, + ... + ); + +UINTN +IPrintAt ( + IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out, + IN UINTN Column, + IN UINTN Row, + IN CONST CHAR16 *fmt, + ... + ); + +UINTN +AsciiPrint ( + IN CONST CHAR8 *fmt, + ... + ); + +UINTN +AsciiVSPrint( + OUT CHAR8 *Str, + IN UINTN StrSize, + IN CONST CHAR8 *fmt, + va_list args +); + +// +// For compatibility with previous gnu-efi versions +// +#define SPrint UnicodeSPrint +#define VSPrint UnicodeVSPrint +#define APrint AsciiPrint + +VOID +ValueToHex ( + IN CHAR16 *Buffer, + IN UINT64 v + ); + +VOID +ValueToString ( + IN CHAR16 *Buffer, + IN BOOLEAN Comma, + IN INT64 v + ); + +VOID +FloatToString ( + IN CHAR16 *Buffer, + IN BOOLEAN Comma, + IN double v + ); + +VOID +TimeToString ( + OUT CHAR16 *Buffer, + IN EFI_TIME *Time + ); + +VOID +GuidToString ( + OUT CHAR16 *Buffer, + IN EFI_GUID *Guid + ); + +VOID +StatusToString ( + OUT CHAR16 *Buffer, + EFI_STATUS Status + ); + +VOID +DumpHex ( + IN UINTN Indent, + IN UINTN Offset, + IN UINTN DataSize, + IN VOID *UserData + ); + +BOOLEAN +GrowBuffer( + IN OUT EFI_STATUS *Status, + IN OUT VOID **Buffer, + IN UINTN BufferSize + ); + +EFI_MEMORY_DESCRIPTOR * +LibMemoryMap ( + OUT UINTN *NoEntries, + OUT UINTN *MapKey, + OUT UINTN *DescriptorSize, + OUT UINT32 *DescriptorVersion + ); + +VOID * +LibGetVariable ( + IN CHAR16 *Name, + IN EFI_GUID *VendorGuid + ); + +VOID * +LibGetVariableAndSize ( + IN CHAR16 *Name, + IN EFI_GUID *VendorGuid, + OUT UINTN *VarSize + ); + +EFI_STATUS +LibDeleteVariable ( + IN CHAR16 *VarName, + IN EFI_GUID *VarGuid + ); + +EFI_STATUS +LibSetNVVariable ( + IN CHAR16 *VarName, + IN EFI_GUID *VarGuid, + IN UINTN DataSize, + IN VOID *Data + ); + +EFI_STATUS +LibSetVariable ( + IN CHAR16 *VarName, + IN EFI_GUID *VarGuid, + IN UINTN DataSize, + IN VOID *Data + ); +EFI_STATUS +LibInsertToTailOfBootOrder ( + IN UINT16 BootOption, + IN BOOLEAN OnlyInsertIfEmpty + ); + +EFI_STATUS +LibLocateProtocol ( + IN EFI_GUID *ProtocolGuid, + OUT VOID **Interface + ); + +EFI_STATUS +LibLocateHandle ( + IN EFI_LOCATE_SEARCH_TYPE SearchType, + IN EFI_GUID *Protocol OPTIONAL, + IN VOID *SearchKey OPTIONAL, + IN OUT UINTN *NoHandles, + OUT EFI_HANDLE **Buffer + ); + +EFI_STATUS +LibLocateHandleByDiskSignature ( + IN UINT8 MBRType, + IN UINT8 SignatureType, + IN VOID *Signature, + IN OUT UINTN *NoHandles, + OUT EFI_HANDLE **Buffer + ); + +EFI_STATUS +LibInstallProtocolInterfaces ( + IN OUT EFI_HANDLE *Handle, + ... + ); + +VOID +LibUninstallProtocolInterfaces ( + IN EFI_HANDLE Handle, + ... + ); + +EFI_STATUS +LibReinstallProtocolInterfaces ( + IN OUT EFI_HANDLE *Handle, + ... + ); + +EFI_EVENT +LibCreateProtocolNotifyEvent ( + IN EFI_GUID *ProtocolGuid, + IN EFI_TPL NotifyTpl, + IN EFI_EVENT_NOTIFY NotifyFunction, + IN VOID *NotifyContext, + OUT VOID *Registration + ); + +EFI_STATUS +WaitForSingleEvent ( + IN EFI_EVENT Event, + IN UINT64 Timeout OPTIONAL + ); + +VOID +WaitForEventWithTimeout ( + IN EFI_EVENT Event, + IN UINTN Timeout, + IN UINTN Row, + IN UINTN Column, + IN CHAR16 *String, + IN EFI_INPUT_KEY TimeoutKey, + OUT EFI_INPUT_KEY *Key + ); + +EFI_FILE_HANDLE +LibOpenRoot ( + IN EFI_HANDLE DeviceHandle + ); + +EFI_FILE_INFO * +LibFileInfo ( + IN EFI_FILE_HANDLE FHand + ); + +EFI_FILE_SYSTEM_INFO * +LibFileSystemInfo ( + IN EFI_FILE_HANDLE FHand + ); + +EFI_FILE_SYSTEM_VOLUME_LABEL_INFO * +LibFileSystemVolumeLabelInfo ( + IN EFI_FILE_HANDLE FHand + ); + +BOOLEAN +ValidMBR( + IN MASTER_BOOT_RECORD *Mbr, + IN EFI_BLOCK_IO *BlkIo + ); + +BOOLEAN +LibMatchDevicePaths ( + IN EFI_DEVICE_PATH *Multi, + IN EFI_DEVICE_PATH *Single + ); + +EFI_DEVICE_PATH * +LibDuplicateDevicePathInstance ( + IN EFI_DEVICE_PATH *DevPath + ); + +EFI_DEVICE_PATH * +DevicePathFromHandle ( + IN EFI_HANDLE Handle + ); + +EFI_DEVICE_PATH * +DevicePathInstance ( + IN OUT EFI_DEVICE_PATH **DevicePath, + OUT UINTN *Size + ); + +UINTN +DevicePathInstanceCount ( + IN EFI_DEVICE_PATH *DevicePath + ); + +EFI_DEVICE_PATH * +AppendDevicePath ( + IN EFI_DEVICE_PATH *Src1, + IN EFI_DEVICE_PATH *Src2 + ); + +EFI_DEVICE_PATH * +AppendDevicePathNode ( + IN EFI_DEVICE_PATH *Src1, + IN EFI_DEVICE_PATH *Src2 + ); + +EFI_DEVICE_PATH* +AppendDevicePathInstance ( + IN EFI_DEVICE_PATH *Src, + IN EFI_DEVICE_PATH *Instance + ); + +EFI_DEVICE_PATH * +FileDevicePath ( + IN EFI_HANDLE Device OPTIONAL, + IN CHAR16 *FileName + ); + +UINTN +DevicePathSize ( + IN EFI_DEVICE_PATH *DevPath + ); + +EFI_DEVICE_PATH * +DuplicateDevicePath ( + IN EFI_DEVICE_PATH *DevPath + ); + +EFI_DEVICE_PATH * +UnpackDevicePath ( + IN EFI_DEVICE_PATH *DevPath + ); + +EFI_STATUS +LibDevicePathToInterface ( + IN EFI_GUID *Protocol, + IN EFI_DEVICE_PATH *FilePath, + OUT VOID **Interface + ); + +CHAR16 * +DevicePathToStr ( + EFI_DEVICE_PATH *DevPath + ); + +// +// BugBug: I need my own include files +// +typedef struct { + UINT8 Register; + UINT8 Function; + UINT8 Device; + UINT8 Bus; + UINT32 Reserved; +} EFI_ADDRESS; + +typedef union { + UINT64 Address; + EFI_ADDRESS EfiAddress; +} EFI_PCI_ADDRESS_UNION; + + +EFI_STATUS +PciFindDeviceClass ( + IN OUT EFI_PCI_ADDRESS_UNION *Address, + IN UINT8 BaseClass, + IN UINT8 SubClass + ); + +EFI_STATUS +PciFindDevice ( + IN OUT EFI_PCI_ADDRESS_UNION *DeviceAddress, + IN UINT16 VendorId, + IN UINT16 DeviceId, + IN OUT PCI_TYPE00 *Pci + ); + +// +// SIMPLE_READ_FILE object used to access files +// + +typedef VOID *SIMPLE_READ_FILE; + +EFI_STATUS +OpenSimpleReadFile ( + IN BOOLEAN BootPolicy, + IN VOID *SourceBuffer OPTIONAL, + IN UINTN SourceSize, + IN OUT EFI_DEVICE_PATH **FilePath, + OUT EFI_HANDLE *DeviceHandle, + OUT SIMPLE_READ_FILE *SimpleReadHandle + ); + +EFI_STATUS +ReadSimpleReadFile ( + IN SIMPLE_READ_FILE SimpleReadHandle, + IN UINTN Offset, + IN OUT UINTN *ReadSize, + OUT VOID *Buffer + ); + + +VOID +CloseSimpleReadFile ( + IN SIMPLE_READ_FILE SimpleReadHandle + ); + +VOID +InitializeGuid ( + VOID + ); + +UINT8 +DecimaltoBCD( + IN UINT8 DecValue + ); + +UINT8 +BCDtoDecimal( + IN UINT8 BcdValue + ); + +EFI_STATUS +LibGetSystemConfigurationTable( + IN EFI_GUID *TableGuid, + IN OUT VOID **Table + ); + +BOOLEAN +LibIsValidTextGraphics ( + IN CHAR16 Graphic, + OUT CHAR8 *PcAnsi, OPTIONAL + OUT CHAR8 *Ascii OPTIONAL + ); + +BOOLEAN +IsValidAscii ( + IN CHAR16 Ascii + ); + +BOOLEAN +IsValidEfiCntlChar ( + IN CHAR16 c + ); + +CHAR16 * +LibGetUiString ( + IN EFI_HANDLE Handle, + IN UI_STRING_TYPE StringType, + IN ISO_639_2 *LangCode, + IN BOOLEAN ReturnDevicePathStrOnMismatch + ); + +CHAR8* +LibGetSmbiosString ( + IN SMBIOS_STRUCTURE_POINTER *Smbios, + IN UINT16 StringNumber + ); + +EFI_STATUS +LibGetSmbiosSystemGuidAndSerialNumber ( + IN EFI_GUID *SystemGuid, + OUT CHAR8 **SystemSerialNumber + ); + + +EFI_STATUS +InitializeGlobalIoDevice ( + IN EFI_DEVICE_PATH *DevicePath, + IN EFI_GUID *Protocol, + IN CHAR8 *ErrorStr, + OUT EFI_DEVICE_IO_INTERFACE **GlobalIoFncs + ); + +UINT32 +ReadPort ( + IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, + IN EFI_IO_WIDTH Width, + IN UINTN Port + ); + +UINT32 +WritePort ( + IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, + IN EFI_IO_WIDTH Width, + IN UINTN Port, + IN UINTN Data + ); + +UINT32 +ReadPciConfig ( + IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, + IN EFI_IO_WIDTH Width, + IN UINTN Port + ); + +UINT32 +WritePciConfig ( + IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, + IN EFI_IO_WIDTH Width, + IN UINTN Port, + IN UINTN Data + ); + +VOID +Pause ( + VOID +); + +extern EFI_DEVICE_IO_INTERFACE *GlobalIoFncs; + +#define outp(_Port, _DataByte) (UINT8)WritePort(GlobalIoFncs, IO_UINT8, (UINTN)_Port, (UINTN)_DataByte) +#define inp(_Port) (UINT8)ReadPort(GlobalIoFncs, IO_UINT8, (UINTN)_Port) +#define outpw(_Port, _DataByte) (UINT16)WritePort(GlobalIoFncs, IO_UINT16, (UINTN)_Port, (UINTN)_DataByte) +#define inpw(_Port) (UINT16)ReadPort(GlobalIoFncs, IO_UINT16, (UINTN)_Port) +#define outpd(_Port, _DataByte) (UINT32)WritePort(GlobalIoFncs, IO_UINT32, (UINTN)_Port, (UINTN)_DataByte) +#define inpd(_Port) (UINT32)ReadPort(GlobalIoFncs, IO_UINT32, (UINTN)_Port) + +#define writepci8(_Addr, _DataByte) (UINT8)WritePciConfig(GlobalIoFncs, IO_UINT8, (UINTN)_Addr, (UINTN)_DataByte) +#define readpci8(_Addr) (UINT8)ReadPciConfig(GlobalIoFncs, IO_UINT8, (UINTN)_Addr) +#define writepci16(_Addr, _DataByte) (UINT16)WritePciConfig(GlobalIoFncs, IO_UINT16, (UINTN)_Addr, (UINTN)_DataByte) +#define readpci16(_Addr) (UINT16)ReadPciConfig(GlobalIoFncs, IO_UINT16, (UINTN)_Addr) +#define writepci32(_Addr, _DataByte) (UINT32)WritePciConfig(GlobalIoFncs, IO_UINT32, (UINTN)_Addr, (UINTN)_DataByte) +#define readpci32(_Addr) (UINT32)ReadPciConfig(GlobalIoFncs, IO_UINT32, (UINTN)_Addr) + +#define Port80(_PostCode) GlobalIoFncs->Io.Write (GlobalIoFncs, IO_UINT16, (UINT64)0x80, 1, &(_PostCode)) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/gnuefi/inc/efilink.h b/gnuefi/inc/efilink.h new file mode 100644 index 0000000..31f2ac6 --- /dev/null +++ b/gnuefi/inc/efilink.h @@ -0,0 +1,182 @@ +#ifndef _EFI_LINK_H +#define _EFI_LINK_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + link.h (renamed efilink.h to avoid conflicts) + +Abstract: + + EFI link list macro's + + + +Revision History + +--*/ + +#ifndef EFI_NT_EMUL + +// +// List entry - doubly linked list +// + +typedef struct _LIST_ENTRY { + struct _LIST_ENTRY *Flink; + struct _LIST_ENTRY *Blink; +} LIST_ENTRY, EFI_LIST_ENTRY; + +#endif + + +// +// VOID +// InitializeListHead( +// LIST_ENTRY *ListHead +// ); +// + +#define InitializeListHead(ListHead) \ + (ListHead)->Flink = ListHead; \ + (ListHead)->Blink = ListHead; + +// +// BOOLEAN +// IsListEmpty( +// PLIST_ENTRY ListHead +// ); +// + +#define IsListEmpty(ListHead) \ + ((ListHead)->Flink == (ListHead)) + +// +// VOID +// RemoveEntryList( +// PLIST_ENTRY Entry +// ); +// + +#define _RemoveEntryList(Entry) { \ + LIST_ENTRY *_Blink, *_Flink; \ + _Flink = (Entry)->Flink; \ + _Blink = (Entry)->Blink; \ + _Blink->Flink = _Flink; \ + _Flink->Blink = _Blink; \ + } + +#if EFI_DEBUG + #define RemoveEntryList(Entry) \ + _RemoveEntryList(Entry); \ + (Entry)->Flink = (LIST_ENTRY *) BAD_POINTER; \ + (Entry)->Blink = (LIST_ENTRY *) BAD_POINTER; +#else + #define RemoveEntryList(Entry) \ + _RemoveEntryList(Entry); +#endif + +// +// VOID +// InsertTailList( +// PLIST_ENTRY ListHead, +// PLIST_ENTRY Entry +// ); +// + +#define InsertTailList(ListHead,Entry) {\ + LIST_ENTRY *_ListHead, *_Blink; \ + _ListHead = (ListHead); \ + _Blink = _ListHead->Blink; \ + (Entry)->Flink = _ListHead; \ + (Entry)->Blink = _Blink; \ + _Blink->Flink = (Entry); \ + _ListHead->Blink = (Entry); \ + } + +// +// VOID +// InsertHeadList( +// PLIST_ENTRY ListHead, +// PLIST_ENTRY Entry +// ); +// + +#define InsertHeadList(ListHead,Entry) {\ + LIST_ENTRY *_ListHead, *_Flink; \ + _ListHead = (ListHead); \ + _Flink = _ListHead->Flink; \ + (Entry)->Flink = _Flink; \ + (Entry)->Blink = _ListHead; \ + _Flink->Blink = (Entry); \ + _ListHead->Flink = (Entry); \ + } + +// VOID +// SwapListEntries( +// PLIST_ENTRY Entry1, +// PLIST_ENTRY Entry2 +// ); +// +// Put Entry2 before Entry1 +// +#define SwapListEntries(Entry1,Entry2) {\ + LIST_ENTRY *Entry1Flink, *Entry1Blink; \ + LIST_ENTRY *Entry2Flink, *Entry2Blink; \ + Entry2Flink = (Entry2)->Flink; \ + Entry2Blink = (Entry2)->Blink; \ + Entry1Flink = (Entry1)->Flink; \ + Entry1Blink = (Entry1)->Blink; \ + Entry2Blink->Flink = Entry2Flink; \ + Entry2Flink->Blink = Entry2Blink; \ + (Entry2)->Flink = Entry1; \ + (Entry2)->Blink = Entry1Blink; \ + Entry1Blink->Flink = (Entry2); \ + (Entry1)->Blink = (Entry2); \ + } + +// +// EFI_FIELD_OFFSET - returns the byte offset to a field within a structure +// + +#define EFI_FIELD_OFFSET(TYPE,Field) ((UINTN)(intptr_t)(&(((TYPE *) 0)->Field))) + +// +// CONTAINING_RECORD - returns a pointer to the structure +// from one of it's elements. +// + +#define _CR(Record, TYPE, Field) \ + ((TYPE *) ( (CHAR8 *)(Record) - (CHAR8 *) &(((TYPE *) 0)->Field))) + +// +// EDK2 uses BASE_CR for the above +// +#define BASE_CR _CR + +#if EFI_DEBUG + #define CR(Record, TYPE, Field, Sig) \ + _CR(Record, TYPE, Field)->Signature != Sig ? \ + (TYPE *) ASSERT_STRUCT(_CR(Record, TYPE, Field), Record) : \ + _CR(Record, TYPE, Field) +#else + #define CR(Record, TYPE, Field, Signature) \ + _CR(Record, TYPE, Field) +#endif + + +// +// A lock structure +// + +typedef struct _FLOCK { + EFI_TPL Tpl; + EFI_TPL OwnerTpl; + UINTN Lock; +} FLOCK; + +#endif + diff --git a/gnuefi/inc/efinet.h b/gnuefi/inc/efinet.h new file mode 100644 index 0000000..6215816 --- /dev/null +++ b/gnuefi/inc/efinet.h @@ -0,0 +1,348 @@ +#ifndef _EFINET_H +#define _EFINET_H + + +/*++ +Copyright (c) 1999 Intel Corporation + +Module Name: + efinet.h + +Abstract: + EFI Simple Network protocol + +Revision History +--*/ + + +/////////////////////////////////////////////////////////////////////////////// +// +// Simple Network Protocol +// + +#define EFI_SIMPLE_NETWORK_PROTOCOL_GUID \ + { 0xA19832B9, 0xAC25, 0x11D3, {0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} } + +INTERFACE_DECL(_EFI_SIMPLE_NETWORK_PROTOCOL); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef struct { + // + // Total number of frames received. Includes frames with errors and + // dropped frames. + // + UINT64 RxTotalFrames; + + // + // Number of valid frames received and copied into receive buffers. + // + UINT64 RxGoodFrames; + + // + // Number of frames below the minimum length for the media. + // This would be <64 for ethernet. + // + UINT64 RxUndersizeFrames; + + // + // Number of frames longer than the maxminum length for the + // media. This would be >1500 for ethernet. + // + UINT64 RxOversizeFrames; + + // + // Valid frames that were dropped because receive buffers were full. + // + UINT64 RxDroppedFrames; + + // + // Number of valid unicast frames received and not dropped. + // + UINT64 RxUnicastFrames; + + // + // Number of valid broadcast frames received and not dropped. + // + UINT64 RxBroadcastFrames; + + // + // Number of valid mutlicast frames received and not dropped. + // + UINT64 RxMulticastFrames; + + // + // Number of frames w/ CRC or alignment errors. + // + UINT64 RxCrcErrorFrames; + + // + // Total number of bytes received. Includes frames with errors + // and dropped frames. + // + UINT64 RxTotalBytes; + + // + // Transmit statistics. + // + UINT64 TxTotalFrames; + UINT64 TxGoodFrames; + UINT64 TxUndersizeFrames; + UINT64 TxOversizeFrames; + UINT64 TxDroppedFrames; + UINT64 TxUnicastFrames; + UINT64 TxBroadcastFrames; + UINT64 TxMulticastFrames; + UINT64 TxCrcErrorFrames; + UINT64 TxTotalBytes; + + // + // Number of collisions detection on this subnet. + // + UINT64 Collisions; + + // + // Number of frames destined for unsupported protocol. + // + UINT64 UnsupportedProtocol; + +} EFI_NETWORK_STATISTICS; + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef enum { + EfiSimpleNetworkStopped, + EfiSimpleNetworkStarted, + EfiSimpleNetworkInitialized, + EfiSimpleNetworkMaxState +} EFI_SIMPLE_NETWORK_STATE; + +/////////////////////////////////////////////////////////////////////////////// +// + +#define EFI_SIMPLE_NETWORK_RECEIVE_UNICAST 0x01 +#define EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST 0x02 +#define EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST 0x04 +#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS 0x08 +#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST 0x10 + +/////////////////////////////////////////////////////////////////////////////// +// + +#define EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT 0x01 +#define EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT 0x02 +#define EFI_SIMPLE_NETWORK_COMMAND_INTERRUPT 0x04 +#define EFI_SIMPLE_NETWORK_SOFTWARE_INTERRUPT 0x08 + +/////////////////////////////////////////////////////////////////////////////// +// +#define MAX_MCAST_FILTER_CNT 16 +typedef struct { + UINT32 State; + UINT32 HwAddressSize; + UINT32 MediaHeaderSize; + UINT32 MaxPacketSize; + UINT32 NvRamSize; + UINT32 NvRamAccessSize; + UINT32 ReceiveFilterMask; + UINT32 ReceiveFilterSetting; + UINT32 MaxMCastFilterCount; + UINT32 MCastFilterCount; + EFI_MAC_ADDRESS MCastFilter[MAX_MCAST_FILTER_CNT]; + EFI_MAC_ADDRESS CurrentAddress; + EFI_MAC_ADDRESS BroadcastAddress; + EFI_MAC_ADDRESS PermanentAddress; + UINT8 IfType; + BOOLEAN MacAddressChangeable; + BOOLEAN MultipleTxSupported; + BOOLEAN MediaPresentSupported; + BOOLEAN MediaPresent; +} EFI_SIMPLE_NETWORK_MODE; + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_START) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_STOP) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_INITIALIZE) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + IN UINTN ExtraRxBufferSize OPTIONAL, + IN UINTN ExtraTxBufferSize OPTIONAL +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_RESET) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + IN BOOLEAN ExtendedVerification +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_SHUTDOWN) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_RECEIVE_FILTERS) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + IN UINT32 Enable, + IN UINT32 Disable, + IN BOOLEAN ResetMCastFilter, + IN UINTN MCastFilterCnt OPTIONAL, + IN EFI_MAC_ADDRESS *MCastFilter OPTIONAL +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_STATION_ADDRESS) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + IN BOOLEAN Reset, + IN EFI_MAC_ADDRESS *New OPTIONAL +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_STATISTICS) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + IN BOOLEAN Reset, + IN OUT UINTN *StatisticsSize OPTIONAL, + OUT EFI_NETWORK_STATISTICS *StatisticsTable OPTIONAL +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + IN BOOLEAN IPv6, + IN EFI_IP_ADDRESS *IP, + OUT EFI_MAC_ADDRESS *MAC +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_NVDATA) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + IN BOOLEAN ReadWrite, + IN UINTN Offset, + IN UINTN BufferSize, + IN OUT VOID *Buffer +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_GET_STATUS) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + OUT UINT32 *InterruptStatus OPTIONAL, + OUT VOID **TxBuf OPTIONAL +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_TRANSMIT) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + IN UINTN HeaderSize, + IN UINTN BufferSize, + IN VOID *Buffer, + IN EFI_MAC_ADDRESS *SrcAddr OPTIONAL, + IN EFI_MAC_ADDRESS *DestAddr OPTIONAL, + IN UINT16 *Protocol OPTIONAL +); + +/////////////////////////////////////////////////////////////////////////////// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_NETWORK_RECEIVE) ( + IN struct _EFI_SIMPLE_NETWORK_PROTOCOL *This, + OUT UINTN *HeaderSize OPTIONAL, + IN OUT UINTN *BufferSize, + OUT VOID *Buffer, + OUT EFI_MAC_ADDRESS *SrcAddr OPTIONAL, + OUT EFI_MAC_ADDRESS *DestAddr OPTIONAL, + OUT UINT16 *Protocol OPTIONAL +); + +/////////////////////////////////////////////////////////////////////////////// +// + +#define EFI_SIMPLE_NETWORK_PROTOCOL_REVISION 0x00010000 +#define EFI_SIMPLE_NETWORK_INTERFACE_REVISION EFI_SIMPLE_NETWORK_PROTOCOL_REVISION + +typedef struct _EFI_SIMPLE_NETWORK_PROTOCOL { + UINT64 Revision; + EFI_SIMPLE_NETWORK_START Start; + EFI_SIMPLE_NETWORK_STOP Stop; + EFI_SIMPLE_NETWORK_INITIALIZE Initialize; + EFI_SIMPLE_NETWORK_RESET Reset; + EFI_SIMPLE_NETWORK_SHUTDOWN Shutdown; + EFI_SIMPLE_NETWORK_RECEIVE_FILTERS ReceiveFilters; + EFI_SIMPLE_NETWORK_STATION_ADDRESS StationAddress; + EFI_SIMPLE_NETWORK_STATISTICS Statistics; + EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC MCastIpToMac; + EFI_SIMPLE_NETWORK_NVDATA NvData; + EFI_SIMPLE_NETWORK_GET_STATUS GetStatus; + EFI_SIMPLE_NETWORK_TRANSMIT Transmit; + EFI_SIMPLE_NETWORK_RECEIVE Receive; + EFI_EVENT WaitForPacket; + EFI_SIMPLE_NETWORK_MODE *Mode; +} EFI_SIMPLE_NETWORK_PROTOCOL; + +// Note: Because it conflicted with the EDK2 struct name, the +// 'EFI_SIMPLE_NETWORK_PROTOCOL' GUID definition, from older +// versions of gnu-efi, is now obsoleted. +// Use 'EFI_SIMPLE_NETWORK_PROTOCOL_GUID' instead. + +typedef struct _EFI_SIMPLE_NETWORK_PROTOCOL _EFI_SIMPLE_NETWORK; +typedef EFI_SIMPLE_NETWORK_PROTOCOL EFI_SIMPLE_NETWORK; + +#endif /* _EFINET_H */ diff --git a/gnuefi/inc/efipart.h b/gnuefi/inc/efipart.h new file mode 100644 index 0000000..d4c5573 --- /dev/null +++ b/gnuefi/inc/efipart.h @@ -0,0 +1,61 @@ +#ifndef _EFI_PART_H +#define _EFI_PART_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efipart.h + +Abstract: + Info about disk partitions and Master Boot Records + + + + +Revision History + +--*/ + +// +// +// + +#define EFI_PARTITION 0xef +#define MBR_SIZE 512 + +#pragma pack(1) + +typedef struct { + UINT8 BootIndicator; + UINT8 StartHead; + UINT8 StartSector; + UINT8 StartTrack; + UINT8 OSIndicator; + UINT8 EndHead; + UINT8 EndSector; + UINT8 EndTrack; + UINT8 StartingLBA[4]; + UINT8 SizeInLBA[4]; +} MBR_PARTITION_RECORD; + +#define EXTRACT_UINT32(D) (UINT32)(D[0] | (D[1] << 8) | (D[2] << 16) | (D[3] << 24)) + +#define MBR_SIGNATURE 0xaa55 +#define MIN_MBR_DEVICE_SIZE 0x80000 +#define MBR_ERRATA_PAD 0x40000 // 128 MB + +#define MAX_MBR_PARTITIONS 4 +typedef struct { + UINT8 BootStrapCode[440]; + UINT8 UniqueMbrSignature[4]; + UINT8 Unknown[2]; + MBR_PARTITION_RECORD Partition[MAX_MBR_PARTITIONS]; + UINT16 Signature; +} MASTER_BOOT_RECORD; +#pragma pack() + + +#endif diff --git a/gnuefi/inc/efipciio.h b/gnuefi/inc/efipciio.h new file mode 100644 index 0000000..e885387 --- /dev/null +++ b/gnuefi/inc/efipciio.h @@ -0,0 +1,399 @@ +#ifndef _EFI_PCI_IO_H +#define _EFI_PCI_IO_H + +#define EFI_PCI_IO_PROTOCOL_GUID \ + { 0x4cf5b200, 0x68b8, 0x4ca5, {0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x02, 0x9a} } + +#define EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID \ + { 0x2f707ebb, 0x4a1a, 0x11d4, {0x9a, 0x38, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +INTERFACE_DECL(_EFI_PCI_IO_PROTOCOL); +INTERFACE_DECL(_EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL); + +typedef enum { + EfiPciIoWidthUint8, + EfiPciIoWidthUint16, + EfiPciIoWidthUint32, + EfiPciIoWidthUint64, + EfiPciIoWidthFifoUint8, + EfiPciIoWidthFifoUint16, + EfiPciIoWidthFifoUint32, + EfiPciIoWidthFifoUint64, + EfiPciIoWidthFillUint8, + EfiPciIoWidthFillUint16, + EfiPciIoWidthFillUint32, + EfiPciIoWidthFillUint64, + EfiPciIoWidthMaximum +} EFI_PCI_IO_PROTOCOL_WIDTH, EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH; + +#define EFI_PCI_IO_PASS_THROUGH_BAR 0xff + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_POLL_IO_MEM) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN EFI_PCI_IO_PROTOCOL_WIDTH Width, + IN UINT8 BarIndex, + IN UINT64 Offset, + IN UINT64 Mask, + IN UINT64 Value, + IN UINT64 Delay, + OUT UINT64 *Result +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH Width, + IN UINT64 Address, + IN UINT64 Mask, + IN UINT64 Value, + IN UINT64 Delay, + OUT UINT64 *Result +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_IO_MEM) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN EFI_PCI_IO_PROTOCOL_WIDTH Width, + IN UINT8 BarIndex, + IN UINT64 Offset, + IN UINTN Count, + IN OUT VOID *Buffer +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH Width, + IN UINT64 Address, + IN UINTN Count, + IN OUT VOID *Buffer +); + +typedef struct { + EFI_PCI_IO_PROTOCOL_IO_MEM Read; + EFI_PCI_IO_PROTOCOL_IO_MEM Write; +} EFI_PCI_IO_PROTOCOL_ACCESS; + +typedef struct { + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM Read; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM Write; +} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS; + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_CONFIG) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN EFI_PCI_IO_PROTOCOL_WIDTH Width, + IN UINT32 Offset, + IN UINTN Count, + IN OUT VOID *Buffer +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + OUT VOID **Resources +); + +typedef struct { + EFI_PCI_IO_PROTOCOL_CONFIG Read; + EFI_PCI_IO_PROTOCOL_CONFIG Write; +} EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS; + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_COPY_MEM) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN EFI_PCI_IO_PROTOCOL_WIDTH Width, + IN UINT8 DestBarIndex, + IN UINT64 DestOffset, + IN UINT8 SrcBarIndex, + IN UINT64 SrcOffset, + IN UINTN Count +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH Width, + IN UINT64 DestAddress, + IN UINT64 SrcAddress, + IN UINTN Count +); + +typedef enum { + EfiPciIoOperationBusMasterRead, + EfiPciIoOperationBusMasterWrite, + EfiPciIoOperationBusMasterCommonBuffer, + EfiPciIoOperationMaximum +} EFI_PCI_IO_PROTOCOL_OPERATION; + +typedef enum { + EfiPciOperationBusMasterRead, + EfiPciOperationBusMasterWrite, + EfiPciOperationBusMasterCommonBuffer, + EfiPciOperationBusMasterRead64, + EfiPciOperationBusMasterWrite64, + EfiPciOperationBusMasterCommonBuffer64, + EfiPciOperationMaximum +} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION; + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_MAP) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN EFI_PCI_IO_PROTOCOL_OPERATION Operation, + IN VOID *HostAddress, + IN OUT UINTN *NumberOfBytes, + OUT EFI_PHYSICAL_ADDRESS *DeviceAddress, + OUT VOID **Mapping +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION Operation, + IN VOID *HostAddress, + IN OUT UINTN *NumberOfBytes, + OUT EFI_PHYSICAL_ADDRESS *DeviceAddress, + OUT VOID **Mapping +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_UNMAP) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN VOID *Mapping +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + IN VOID *Mapping +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_ALLOCATE_BUFFER) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN EFI_ALLOCATE_TYPE Type, + IN EFI_MEMORY_TYPE MemoryType, + IN UINTN Pages, + OUT VOID **HostAddress, + IN UINT64 Attributes +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + IN EFI_ALLOCATE_TYPE Type, + IN EFI_MEMORY_TYPE MemoryType, + IN UINTN Pages, + IN OUT VOID **HostAddress, + IN UINT64 Attributes +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_FREE_BUFFER) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN UINTN Pages, + IN VOID *HostAddress + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + IN UINTN Pages, + IN VOID *HostAddress +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_FLUSH) ( + IN struct _EFI_PCI_IO_PROTOCOL *This +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_GET_LOCATION) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + OUT UINTN *SegmentNumber, + OUT UINTN *BusNumber, + OUT UINTN *DeviceNumber, + OUT UINTN *FunctionNumber +); + +#define EFI_PCI_ATTRIBUTE_ISA_MOTHERBOARD_IO 0x0001 +#define EFI_PCI_ATTRIBUTE_ISA_IO 0x0002 +#define EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO 0x0004 +#define EFI_PCI_ATTRIBUTE_VGA_MEMORY 0x0008 +#define EFI_PCI_ATTRIBUTE_VGA_IO 0x0010 +#define EFI_PCI_ATTRIBUTE_IDE_PRIMARY_IO 0x0020 +#define EFI_PCI_ATTRIBUTE_IDE_SECONDARY_IO 0x0040 +#define EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE 0x0080 +#define EFI_PCI_ATTRIBUTE_IO 0x0100 +#define EFI_PCI_ATTRIBUTE_MEMORY 0x0200 +#define EFI_PCI_ATTRIBUTE_BUS_MASTER 0x0400 +#define EFI_PCI_ATTRIBUTE_MEMORY_CACHED 0x0800 +#define EFI_PCI_ATTRIBUTE_MEMORY_DISABLE 0x1000 +#define EFI_PCI_ATTRIBUTE_EMBEDDED_DEVICE 0x2000 +#define EFI_PCI_ATTRIBUTE_EMBEDDED_ROM 0x4000 +#define EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE 0x8000 +#define EFI_PCI_ATTRIBUTE_ISA_IO_16 0x10000 +#define EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO_16 0x20000 +#define EFI_PCI_ATTRIBUTE_VGA_IO_16 0x40000 + +#define EFI_PCI_IO_ATTRIBUTE_ISA_MOTHERBOARD_IO EFI_PCI_ATTRIBUTE_ISA_MOTHERBOARD_IO +#define EFI_PCI_IO_ATTRIBUTE_ISA_IO EFI_PCI_ATTRIBUTE_ISA_IO +#define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO +#define EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY EFI_PCI_ATTRIBUTE_VGA_MEMORY +#define EFI_PCI_IO_ATTRIBUTE_VGA_IO EFI_PCI_ATTRIBUTE_VGA_IO +#define EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO EFI_PCI_ATTRIBUTE_IDE_PRIMARY_IO +#define EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO EFI_PCI_ATTRIBUTE_IDE_SECONDARY_IO +#define EFI_PCI_IO_ATTRIBUTE_MEMORY_WRITE_COMBINE EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE +#define EFI_PCI_IO_ATTRIBUTE_IO EFI_PCI_ATTRIBUTE_IO +#define EFI_PCI_IO_ATTRIBUTE_MEMORY EFI_PCI_ATTRIBUTE_MEMORY +#define EFI_PCI_IO_ATTRIBUTE_BUS_MASTER EFI_PCI_ATTRIBUTE_BUS_MASTER +#define EFI_PCI_IO_ATTRIBUTE_MEMORY_CACHED EFI_PCI_ATTRIBUTE_MEMORY_CACHED +#define EFI_PCI_IO_ATTRIBUTE_MEMORY_DISABLE EFI_PCI_ATTRIBUTE_MEMORY_DISABLE +#define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_DEVICE EFI_PCI_ATTRIBUTE_EMBEDDED_DEVICE +#define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_ROM EFI_PCI_ATTRIBUTE_EMBEDDED_ROM +#define EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE +#define EFI_PCI_IO_ATTRIBUTE_ISA_IO_16 EFI_PCI_ATTRIBUTE_ISA_IO_16 +#define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO_16 EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO_16 +#define EFI_PCI_IO_ATTRIBUTE_VGA_IO_16 EFI_PCI_ATTRIBUTE_VGA_IO_16 + +#define EFI_PCI_ATTRIBUTE_VALID_FOR_ALLOCATE_BUFFER \ + (EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE | EFI_PCI_ATTRIBUTE_MEMORY_CACHED | EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE) + +#define EFI_PCI_ATTRIBUTE_INVALID_FOR_ALLOCATE_BUFFER \ + (~EFI_PCI_ATTRIBUTE_VALID_FOR_ALLOCATE_BUFFER) + +typedef struct { + UINT8 Register; + UINT8 Function; + UINT8 Device; + UINT8 Bus; + UINT32 ExtendedRegister; +} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS; + +typedef enum { + EfiPciIoAttributeOperationGet, + EfiPciIoAttributeOperationSet, + EfiPciIoAttributeOperationEnable, + EfiPciIoAttributeOperationDisable, + EfiPciIoAttributeOperationSupported, + EfiPciIoAttributeOperationMaximum +} EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION; + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_ATTRIBUTES) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION Operation, + IN UINT64 Attributes, + OUT UINT64 *Result OPTIONAL +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_GET_BAR_ATTRIBUTES) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN UINT8 BarIndex, + OUT UINT64 *Supports OPTIONAL, + OUT VOID **Resources OPTIONAL +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + OUT UINT64 *Supports, + OUT UINT64 *Attributes +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_IO_PROTOCOL_SET_BAR_ATTRIBUTES) ( + IN struct _EFI_PCI_IO_PROTOCOL *This, + IN UINT64 Attributes, + IN UINT8 BarIndex, + IN OUT UINT64 *Offset, + IN OUT UINT64 *Length +); + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES) ( + IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This, + IN UINT64 Attributes, + IN OUT UINT64 *ResourceBase, + IN OUT UINT64 *ResourceLength +); + +typedef struct _EFI_PCI_IO_PROTOCOL { + EFI_PCI_IO_PROTOCOL_POLL_IO_MEM PollMem; + EFI_PCI_IO_PROTOCOL_POLL_IO_MEM PollIo; + EFI_PCI_IO_PROTOCOL_ACCESS Mem; + EFI_PCI_IO_PROTOCOL_ACCESS Io; + EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS Pci; + EFI_PCI_IO_PROTOCOL_COPY_MEM CopyMem; + EFI_PCI_IO_PROTOCOL_MAP Map; + EFI_PCI_IO_PROTOCOL_UNMAP Unmap; + EFI_PCI_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer; + EFI_PCI_IO_PROTOCOL_FREE_BUFFER FreeBuffer; + EFI_PCI_IO_PROTOCOL_FLUSH Flush; + EFI_PCI_IO_PROTOCOL_GET_LOCATION GetLocation; + EFI_PCI_IO_PROTOCOL_ATTRIBUTES Attributes; + EFI_PCI_IO_PROTOCOL_GET_BAR_ATTRIBUTES GetBarAttributes; + EFI_PCI_IO_PROTOCOL_SET_BAR_ATTRIBUTES SetBarAttributes; + UINT64 RomSize; + VOID *RomImage; +} EFI_PCI_IO_PROTOCOL; + +// Note: Because it conflicted with the EDK2 struct name, the +// 'EFI_PCI_IO_PROTOCOL' GUID definition, from older versions +// of gnu-efi, is now obsoleted. +// Use 'EFI_PCI_IO_PROTOCOL_GUID' instead. + +typedef struct _EFI_PCI_IO_PROTOCOL _EFI_PCI_IO; +typedef EFI_PCI_IO_PROTOCOL EFI_PCI_IO; + +typedef struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL { + EFI_HANDLE ParentHandle; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM PollMem; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM PollIo; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Mem; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Io; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Pci; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM CopyMem; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP Map; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP Unmap; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER FreeBuffer; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH Flush; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES GetAttributes; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES SetAttributes; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION Configuration; + UINT32 SegmentNumber; +} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL; + +#endif /* _EFI_PCI_IO_H */ diff --git a/gnuefi/inc/efipoint.h b/gnuefi/inc/efipoint.h new file mode 100644 index 0000000..4dbcf18 --- /dev/null +++ b/gnuefi/inc/efipoint.h @@ -0,0 +1,115 @@ +/* Copyright (C) 2014 by John Cronin + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef _EFI_POINT_H +#define _EFI_POINT_H + +#define EFI_SIMPLE_POINTER_PROTOCOL_GUID \ + { 0x31878c87, 0xb75, 0x11d5, { 0x9a, 0x4f, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } } + +INTERFACE_DECL(_EFI_SIMPLE_POINTER); + +typedef struct { + INT32 RelativeMovementX; + INT32 RelativeMovementY; + INT32 RelativeMovementZ; + BOOLEAN LeftButton; + BOOLEAN RightButton; +} EFI_SIMPLE_POINTER_STATE; + +typedef struct { + UINT64 ResolutionX; + UINT64 ResolutionY; + UINT64 ResolutionZ; + BOOLEAN LeftButton; + BOOLEAN RightButton; +} EFI_SIMPLE_POINTER_MODE; + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_POINTER_RESET) ( + IN struct _EFI_SIMPLE_POINTER *This, + IN BOOLEAN ExtendedVerification +); + +typedef +EFI_STATUS +(EFIAPI *EFI_SIMPLE_POINTER_GET_STATE) ( + IN struct _EFI_SIMPLE_POINTER *This, + IN OUT EFI_SIMPLE_POINTER_STATE *State +); + +typedef struct _EFI_SIMPLE_POINTER { + EFI_SIMPLE_POINTER_RESET Reset; + EFI_SIMPLE_POINTER_GET_STATE GetState; + EFI_EVENT WaitForInput; + EFI_SIMPLE_POINTER_MODE *Mode; +} EFI_SIMPLE_POINTER_PROTOCOL; + +#define EFI_ABSOLUTE_POINTER_PROTOCOL_GUID \ + { 0x8D59D32B, 0xC655, 0x4AE9, { 0x9B, 0x15, 0xF2, 0x59, 0x04, 0x99, 0x2A, 0x43 } } + +INTERFACE_DECL(_EFI_ABSOLUTE_POINTER_PROTOCOL); + +typedef struct { + UINT64 AbsoluteMinX; + UINT64 AbsoluteMinY; + UINT64 AbsoluteMinZ; + UINT64 AbsoluteMaxX; + UINT64 AbsoluteMaxY; + UINT64 AbsoluteMaxZ; + UINT32 Attributes; +} EFI_ABSOLUTE_POINTER_MODE; + +typedef struct { + UINT64 CurrentX; + UINT64 CurrentY; + UINT64 CurrentZ; + UINT32 ActiveButtons; +} EFI_ABSOLUTE_POINTER_STATE; + +#define EFI_ABSP_SupportsAltActive 0x00000001 +#define EFI_ABSP_SupportsPressureAsZ 0x00000002 +#define EFI_ABSP_TouchActive 0x00000001 +#define EFI_ABS_AltActive 0x00000002 + +typedef +EFI_STATUS +(EFIAPI *EFI_ABSOLUTE_POINTER_RESET) ( + IN struct _EFI_ABSOLUTE_POINTER_PROTOCOL *This, + IN BOOLEAN ExtendedVerification +); + +typedef +EFI_STATUS +(EFIAPI *EFI_ABSOLUTE_POINTER_GET_STATE) ( + IN struct _EFI_ABSOLUTE_POINTER_PROTOCOL *This, + IN OUT EFI_ABSOLUTE_POINTER_STATE *State +); + +typedef struct _EFI_ABSOLUTE_POINTER_PROTOCOL { + EFI_ABSOLUTE_POINTER_RESET Reset; + EFI_ABSOLUTE_POINTER_GET_STATE GetState; + EFI_EVENT WaitForInput; + EFI_ABSOLUTE_POINTER_MODE *Mode; +} EFI_ABSOLUTE_POINTER_PROTOCOL; + +#endif diff --git a/gnuefi/inc/efiprot.h b/gnuefi/inc/efiprot.h new file mode 100644 index 0000000..c4457de --- /dev/null +++ b/gnuefi/inc/efiprot.h @@ -0,0 +1,1466 @@ +#ifndef _EFI_PROT_H +#define _EFI_PROT_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efiprot.h + +Abstract: + + EFI Protocols + + + +Revision History + +--*/ + +// +// FPSWA library protocol +// +#define EFI_FPSWA_PROTOCOL_GUID \ + { 0xc41b6531, 0x97b9, 0x11d3, {0x9a, 0x29, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } +#define FPSWA_PROTOCOL EFI_FPSWA_PROTOCOL_GUID + +// +// Device Path protocol +// + +#define EFI_DEVICE_PATH_PROTOCOL_GUID \ + { 0x9576e91, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } +#define DEVICE_PATH_PROTOCOL EFI_DEVICE_PATH_PROTOCOL_GUID + + +// +// Block IO protocol +// + +#define EFI_BLOCK_IO_PROTOCOL_GUID \ + { 0x964e5b21, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } +#define BLOCK_IO_PROTOCOL EFI_BLOCK_IO_PROTOCOL_GUID + +#define EFI_BLOCK_IO_PROTOCOL_REVISION 0x00010000 +#define EFI_BLOCK_IO_PROTOCOL_REVISION2 0x00020001 +#define EFI_BLOCK_IO_PROTOCOL_REVISION3 ((2<<16) | 31) +#define EFI_BLOCK_IO_INTERFACE_REVISION EFI_BLOCK_IO_PROTOCOL_REVISION +#define EFI_BLOCK_IO_INTERFACE_REVISION2 EFI_BLOCK_IO_PROTOCOL_REVISION2 +#define EFI_BLOCK_IO_INTERFACE_REVISION3 EFI_BLOCK_IO_PROTOCOL_REVISION3 + +INTERFACE_DECL(_EFI_BLOCK_IO_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_BLOCK_RESET) ( + IN struct _EFI_BLOCK_IO_PROTOCOL *This, + IN BOOLEAN ExtendedVerification + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_BLOCK_READ) ( + IN struct _EFI_BLOCK_IO_PROTOCOL *This, + IN UINT32 MediaId, + IN EFI_LBA LBA, + IN UINTN BufferSize, + OUT VOID *Buffer + ); + + +typedef +EFI_STATUS +(EFIAPI *EFI_BLOCK_WRITE) ( + IN struct _EFI_BLOCK_IO_PROTOCOL *This, + IN UINT32 MediaId, + IN EFI_LBA LBA, + IN UINTN BufferSize, + IN VOID *Buffer + ); + + +typedef +EFI_STATUS +(EFIAPI *EFI_BLOCK_FLUSH) ( + IN struct _EFI_BLOCK_IO_PROTOCOL *This + ); + + + +typedef struct { + UINT32 MediaId; + BOOLEAN RemovableMedia; + BOOLEAN MediaPresent; + + BOOLEAN LogicalPartition; + BOOLEAN ReadOnly; + BOOLEAN WriteCaching; + + UINT32 BlockSize; + UINT32 IoAlign; + + EFI_LBA LastBlock; + + /* revision 2 */ + EFI_LBA LowestAlignedLba; + UINT32 LogicalBlocksPerPhysicalBlock; + /* revision 3 */ + UINT32 OptimalTransferLengthGranularity; +} EFI_BLOCK_IO_MEDIA; + +typedef struct _EFI_BLOCK_IO_PROTOCOL { + UINT64 Revision; + + EFI_BLOCK_IO_MEDIA *Media; + + EFI_BLOCK_RESET Reset; + EFI_BLOCK_READ ReadBlocks; + EFI_BLOCK_WRITE WriteBlocks; + EFI_BLOCK_FLUSH FlushBlocks; + +} EFI_BLOCK_IO_PROTOCOL; + +typedef struct _EFI_BLOCK_IO_PROTOCOL _EFI_BLOCK_IO; +typedef EFI_BLOCK_IO_PROTOCOL EFI_BLOCK_IO; + +#define EFI_BLOCK_IO2_PROTOCOL_GUID \ + { 0xa77b2472, 0xe282, 0x4e9f, {0xa2, 0x45, 0xc2, 0xc0, 0xe2, 0x7b, 0xbc, 0xc1} } + +INTERFACE_DECL(_EFI_BLOCK_IO2_PROTOCOL); + +typedef struct { + EFI_EVENT Event; + EFI_STATUS TransactionStatus; +} EFI_BLOCK_IO2_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_BLOCK_RESET_EX) ( + IN struct _EFI_BLOCK_IO2_PROTOCOL *This, + IN BOOLEAN ExtendedVerification + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_BLOCK_READ_EX) ( + IN struct _EFI_BLOCK_IO2_PROTOCOL *This, + IN UINT32 MediaId, + IN EFI_LBA LBA, + IN OUT EFI_BLOCK_IO2_TOKEN *Token, + IN UINTN BufferSize, + OUT VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_BLOCK_WRITE_EX) ( + IN struct _EFI_BLOCK_IO2_PROTOCOL *This, + IN UINT32 MediaId, + IN EFI_LBA LBA, + IN OUT EFI_BLOCK_IO2_TOKEN *Token, + IN UINTN BufferSize, + IN VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_BLOCK_FLUSH_EX) ( + IN struct _EFI_BLOCK_IO2_PROTOCOL *This, + IN OUT EFI_BLOCK_IO2_TOKEN *Token + ); + +typedef struct _EFI_BLOCK_IO2_PROTOCOL { + EFI_BLOCK_IO_MEDIA *Media; + EFI_BLOCK_RESET_EX Reset; + EFI_BLOCK_READ_EX ReadBlocksEx; + EFI_BLOCK_WRITE_EX WriteBlocksEx; + EFI_BLOCK_FLUSH_EX FlushBlocksEx; +} EFI_BLOCK_IO2_PROTOCOL; + +// +// Disk Block IO protocol +// + +#define EFI_DISK_IO_PROTOCOL_GUID \ + { 0xce345171, 0xba0b, 0x11d2, {0x8e, 0x4f, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } +#define DISK_IO_PROTOCOL EFI_DISK_IO_PROTOCOL_GUID + +#define EFI_DISK_IO_PROTOCOL_REVISION 0x00010000 +#define EFI_DISK_IO_INTERFACE_REVISION EFI_DISK_IO_PROTOCOL_REVISION + +INTERFACE_DECL(_EFI_DISK_IO_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_DISK_READ) ( + IN struct _EFI_DISK_IO_PROTOCOL *This, + IN UINT32 MediaId, + IN UINT64 Offset, + IN UINTN BufferSize, + OUT VOID *Buffer + ); + + +typedef +EFI_STATUS +(EFIAPI *EFI_DISK_WRITE) ( + IN struct _EFI_DISK_IO_PROTOCOL *This, + IN UINT32 MediaId, + IN UINT64 Offset, + IN UINTN BufferSize, + IN VOID *Buffer + ); + + +typedef struct _EFI_DISK_IO_PROTOCOL { + UINT64 Revision; + EFI_DISK_READ ReadDisk; + EFI_DISK_WRITE WriteDisk; +} EFI_DISK_IO_PROTOCOL; + +typedef struct _EFI_DISK_IO_PROTOCOL _EFI_DISK_IO; +typedef EFI_DISK_IO_PROTOCOL EFI_DISK_IO; + + +#define EFI_DISK_IO2_PROTOCOL_GUID \ + { 0x151c8eae, 0x7f2c, 0x472c, {0x9e, 0x54, 0x98, 0x28, 0x19, 0x4f, 0x6a, 0x88} } + +#define EFI_DISK_IO2_PROTOCOL_REVISION 0x00020000 + +INTERFACE_DECL(_EFI_DISK_IO2_PROTOCOL); + +typedef struct { + EFI_EVENT Event; + EFI_STATUS TransactionStatus; +} EFI_DISK_IO2_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_DISK_CANCEL_EX) ( + IN struct _EFI_DISK_IO2_PROTOCOL *This + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_DISK_READ_EX) ( + IN struct _EFI_DISK_IO2_PROTOCOL *This, + IN UINT32 MediaId, + IN UINT64 Offset, + IN OUT EFI_DISK_IO2_TOKEN *Token, + IN UINTN BufferSize, + OUT VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_DISK_WRITE_EX) ( + IN struct _EFI_DISK_IO2_PROTOCOL *This, + IN UINT32 MediaId, + IN UINT64 Offset, + IN OUT EFI_DISK_IO2_TOKEN *Token, + IN UINTN BufferSize, + IN VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_DISK_FLUSH_EX) ( + IN struct _EFI_DISK_IO2_PROTOCOL *This, + IN OUT EFI_DISK_IO2_TOKEN *Token + ); + +typedef struct _EFI_DISK_IO2_PROTOCOL { + UINT64 Revision; + EFI_DISK_CANCEL_EX Cancel; + EFI_DISK_READ_EX ReadDiskEx; + EFI_DISK_WRITE_EX WriteDiskEx; + EFI_DISK_FLUSH_EX FlushDiskEx; +} EFI_DISK_IO2_PROTOCOL; + +// +// Simple file system protocol +// + +#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID \ + { 0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } +#define SIMPLE_FILE_SYSTEM_PROTOCOL EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID + +INTERFACE_DECL(_EFI_SIMPLE_FILE_SYSTEM_PROTOCOL); +INTERFACE_DECL(_EFI_FILE_HANDLE); + +typedef +EFI_STATUS +(EFIAPI *EFI_VOLUME_OPEN) ( + IN struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This, + OUT struct _EFI_FILE_HANDLE **Root + ); + +#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION 0x00010000 +#define EFI_FILE_IO_INTERFACE_REVISION EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION + +typedef struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL { + UINT64 Revision; + EFI_VOLUME_OPEN OpenVolume; +} EFI_SIMPLE_FILE_SYSTEM_PROTOCOL; + +typedef struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL _EFI_FILE_IO_INTERFACE; +typedef EFI_SIMPLE_FILE_SYSTEM_PROTOCOL EFI_FILE_IO_INTERFACE; + +// +// +// + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_OPEN) ( + IN struct _EFI_FILE_HANDLE *File, + OUT struct _EFI_FILE_HANDLE **NewHandle, + IN CHAR16 *FileName, + IN UINT64 OpenMode, + IN UINT64 Attributes + ); + +// Open modes +#define EFI_FILE_MODE_READ 0x0000000000000001 +#define EFI_FILE_MODE_WRITE 0x0000000000000002 +#define EFI_FILE_MODE_CREATE 0x8000000000000000 + +// File attributes +#define EFI_FILE_READ_ONLY 0x0000000000000001 +#define EFI_FILE_HIDDEN 0x0000000000000002 +#define EFI_FILE_SYSTEM 0x0000000000000004 +#define EFI_FILE_RESERVIED 0x0000000000000008 +#define EFI_FILE_DIRECTORY 0x0000000000000010 +#define EFI_FILE_ARCHIVE 0x0000000000000020 +#define EFI_FILE_VALID_ATTR 0x0000000000000037 + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_CLOSE) ( + IN struct _EFI_FILE_HANDLE *File + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_DELETE) ( + IN struct _EFI_FILE_HANDLE *File + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_READ) ( + IN struct _EFI_FILE_HANDLE *File, + IN OUT UINTN *BufferSize, + OUT VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_WRITE) ( + IN struct _EFI_FILE_HANDLE *File, + IN OUT UINTN *BufferSize, + IN VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_SET_POSITION) ( + IN struct _EFI_FILE_HANDLE *File, + IN UINT64 Position + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_GET_POSITION) ( + IN struct _EFI_FILE_HANDLE *File, + OUT UINT64 *Position + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_GET_INFO) ( + IN struct _EFI_FILE_HANDLE *File, + IN EFI_GUID *InformationType, + IN OUT UINTN *BufferSize, + OUT VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_SET_INFO) ( + IN struct _EFI_FILE_HANDLE *File, + IN EFI_GUID *InformationType, + IN UINTN BufferSize, + IN VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_FLUSH) ( + IN struct _EFI_FILE_HANDLE *File + ); + +typedef struct { + EFI_EVENT Event; + EFI_STATUS Status; + UINTN BufferSize; + VOID *Buffer; +} EFI_FILE_IO_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_OPEN_EX)( + IN struct _EFI_FILE_HANDLE *File, + OUT struct _EFI_FILE_HANDLE **NewHandle, + IN CHAR16 *FileName, + IN UINT64 OpenMode, + IN UINT64 Attributes, + IN OUT EFI_FILE_IO_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_READ_EX) ( + IN struct _EFI_FILE_HANDLE *File, + IN OUT EFI_FILE_IO_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_WRITE_EX) ( + IN struct _EFI_FILE_HANDLE *File, + IN OUT EFI_FILE_IO_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_FILE_FLUSH_EX) ( + IN struct _EFI_FILE_HANDLE *File, + IN OUT EFI_FILE_IO_TOKEN *Token + ); + +#define EFI_FILE_PROTOCOL_REVISION 0x00010000 +#define EFI_FILE_PROTOCOL_REVISION2 0x00020000 +#define EFI_FILE_PROTOCOL_LATEST_REVISION EFI_FILE_PROTOCOL_REVISION2 +#define EFI_FILE_HANDLE_REVISION EFI_FILE_PROTOCOL_REVISION + +typedef struct _EFI_FILE_HANDLE { + UINT64 Revision; + EFI_FILE_OPEN Open; + EFI_FILE_CLOSE Close; + EFI_FILE_DELETE Delete; + EFI_FILE_READ Read; + EFI_FILE_WRITE Write; + EFI_FILE_GET_POSITION GetPosition; + EFI_FILE_SET_POSITION SetPosition; + EFI_FILE_GET_INFO GetInfo; + EFI_FILE_SET_INFO SetInfo; + EFI_FILE_FLUSH Flush; + EFI_FILE_OPEN_EX OpenEx; + EFI_FILE_READ_EX ReadEx; + EFI_FILE_WRITE_EX WriteEx; + EFI_FILE_FLUSH_EX FlushEx; +} EFI_FILE_PROTOCOL, *EFI_FILE_HANDLE; + +typedef EFI_FILE_PROTOCOL EFI_FILE; + + +// +// File information types +// + +#define EFI_FILE_INFO_ID \ + { 0x9576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } + +typedef struct { + UINT64 Size; + UINT64 FileSize; + UINT64 PhysicalSize; + EFI_TIME CreateTime; + EFI_TIME LastAccessTime; + EFI_TIME ModificationTime; + UINT64 Attribute; + CHAR16 FileName[1]; +} EFI_FILE_INFO; + +// +// The FileName field of the EFI_FILE_INFO data structure is variable length. +// Whenever code needs to know the size of the EFI_FILE_INFO data structure, it needs to +// be the size of the data structure without the FileName field. The following macro +// computes this size correctly no matter how big the FileName array is declared. +// This is required to make the EFI_FILE_INFO data structure ANSI compilant. +// + +#define SIZE_OF_EFI_FILE_INFO EFI_FIELD_OFFSET(EFI_FILE_INFO,FileName) + +#define EFI_FILE_SYSTEM_INFO_ID \ + { 0x9576e93, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } + +typedef struct { + UINT64 Size; + BOOLEAN ReadOnly; + UINT64 VolumeSize; + UINT64 FreeSpace; + UINT32 BlockSize; + CHAR16 VolumeLabel[1]; +} EFI_FILE_SYSTEM_INFO; + +// +// The VolumeLabel field of the EFI_FILE_SYSTEM_INFO data structure is variable length. +// Whenever code needs to know the size of the EFI_FILE_SYSTEM_INFO data structure, it needs +// to be the size of the data structure without the VolumeLable field. The following macro +// computes this size correctly no matter how big the VolumeLable array is declared. +// This is required to make the EFI_FILE_SYSTEM_INFO data structure ANSI compilant. +// + +#define SIZE_OF_EFI_FILE_SYSTEM_INFO EFI_FIELD_OFFSET(EFI_FILE_SYSTEM_INFO,VolumeLabel) + +#define EFI_FILE_SYSTEM_VOLUME_LABEL_ID \ + { 0xDB47D7D3,0xFE81, 0x11d3, {0x9A, 0x35, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} } + +typedef struct { + CHAR16 VolumeLabel[1]; +} EFI_FILE_SYSTEM_VOLUME_LABEL; + +#define SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL_INFO EFI_FIELD_OFFSET(EFI_FILE_SYSTEM_VOLUME_LABEL,VolumeLabel) + +// +// For compatibility with older versions of gnu-efi +// +#define EFI_FILE_SYSTEM_VOLUME_LABEL_INFO_ID EFI_FILE_SYSTEM_VOLUME_LABEL_ID +#define EFI_FILE_SYSTEM_VOLUME_LABEL_INFO EFI_FILE_SYSTEM_VOLUME_LABEL + +// +// Load file protocol +// + + +#define EFI_LOAD_FILE_PROTOCOL_GUID \ + { 0x56EC3091, 0x954C, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} } +#define LOAD_FILE_PROTOCOL EFI_LOAD_FILE_PROTOCOL_GUID + +INTERFACE_DECL(_EFI_LOAD_FILE_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_LOAD_FILE) ( + IN struct _EFI_LOAD_FILE_PROTOCOL *This, + IN EFI_DEVICE_PATH *FilePath, + IN BOOLEAN BootPolicy, + IN OUT UINTN *BufferSize, + IN VOID *Buffer OPTIONAL + ); + +typedef struct _EFI_LOAD_FILE_PROTOCOL { + EFI_LOAD_FILE LoadFile; +} EFI_LOAD_FILE_PROTOCOL; + +typedef struct _EFI_LOAD_FILE_PROTOCOL _EFI_LOAD_FILE_INTERFACE; +typedef EFI_LOAD_FILE_PROTOCOL EFI_LOAD_FILE_INTERFACE; + +// +// Device IO protocol +// + +#define EFI_DEVICE_IO_PROTOCOL_GUID \ + { 0xaf6ac311, 0x84c3, 0x11d2, {0x8e, 0x3c, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } +#define DEVICE_IO_PROTOCOL EFI_DEVICE_IO_PROTOCOL_GUID + +INTERFACE_DECL(_EFI_DEVICE_IO_PROTOCOL); + +typedef enum { + IO_UINT8, + IO_UINT16, + IO_UINT32, + IO_UINT64, +// +// Specification Change: Copy from MMIO to MMIO vs. MMIO to buffer, buffer to MMIO +// + MMIO_COPY_UINT8, + MMIO_COPY_UINT16, + MMIO_COPY_UINT32, + MMIO_COPY_UINT64 +} EFI_IO_WIDTH; + +#define EFI_PCI_ADDRESS(_bus,_dev,_func) \ + ( (UINT64) ( (((UINTN)_bus) << 24) + (((UINTN)_dev) << 16) + (((UINTN)_func) << 8) ) ) + + +typedef +EFI_STATUS +(EFIAPI *EFI_DEVICE_IO) ( + IN struct _EFI_DEVICE_IO_PROTOCOL *This, + IN EFI_IO_WIDTH Width, + IN UINT64 Address, + IN UINTN Count, + IN OUT VOID *Buffer + ); + +typedef struct { + EFI_DEVICE_IO Read; + EFI_DEVICE_IO Write; +} EFI_IO_ACCESS; + +typedef +EFI_STATUS +(EFIAPI *EFI_PCI_DEVICE_PATH) ( + IN struct _EFI_DEVICE_IO_PROTOCOL *This, + IN UINT64 Address, + IN OUT EFI_DEVICE_PATH **PciDevicePath + ); + +typedef enum { + EfiBusMasterRead, + EfiBusMasterWrite, + EfiBusMasterCommonBuffer +} EFI_IO_OPERATION_TYPE; + +typedef +EFI_STATUS +(EFIAPI *EFI_IO_MAP) ( + IN struct _EFI_DEVICE_IO_PROTOCOL *This, + IN EFI_IO_OPERATION_TYPE Operation, + IN EFI_PHYSICAL_ADDRESS *HostAddress, + IN OUT UINTN *NumberOfBytes, + OUT EFI_PHYSICAL_ADDRESS *DeviceAddress, + OUT VOID **Mapping + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IO_UNMAP) ( + IN struct _EFI_DEVICE_IO_PROTOCOL *This, + IN VOID *Mapping + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IO_ALLOCATE_BUFFER) ( + IN struct _EFI_DEVICE_IO_PROTOCOL *This, + IN EFI_ALLOCATE_TYPE Type, + IN EFI_MEMORY_TYPE MemoryType, + IN UINTN Pages, + IN OUT EFI_PHYSICAL_ADDRESS *HostAddress + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IO_FLUSH) ( + IN struct _EFI_DEVICE_IO_PROTOCOL *This + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IO_FREE_BUFFER) ( + IN struct _EFI_DEVICE_IO_PROTOCOL *This, + IN UINTN Pages, + IN EFI_PHYSICAL_ADDRESS HostAddress + ); + +typedef struct _EFI_DEVICE_IO_PROTOCOL { + EFI_IO_ACCESS Mem; + EFI_IO_ACCESS Io; + EFI_IO_ACCESS Pci; + EFI_IO_MAP Map; + EFI_PCI_DEVICE_PATH PciDevicePath; + EFI_IO_UNMAP Unmap; + EFI_IO_ALLOCATE_BUFFER AllocateBuffer; + EFI_IO_FLUSH Flush; + EFI_IO_FREE_BUFFER FreeBuffer; +} EFI_DEVICE_IO_PROTOCOL; + +typedef struct _EFI_DEVICE_IO_PROTOCOL _EFI_DEVICE_IO_INTERFACE; +typedef EFI_DEVICE_IO_PROTOCOL EFI_DEVICE_IO_INTERFACE; + +// +// Unicode Collation protocol +// + +#define EFI_UNICODE_COLLATION_PROTOCOL_GUID \ + { 0x1d85cd7f, 0xf43d, 0x11d2, {0x9a, 0xc, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } +#define UNICODE_COLLATION_PROTOCOL EFI_UNICODE_COLLATION_PROTOCOL_GUID + +#define EFI_UNICODE_BYTE_ORDER_MARK (CHAR16)(0xfeff) +#define UNICODE_BYTE_ORDER_MARK EFI_UNICODE_BYTE_ORDER_MARK + +INTERFACE_DECL(_EFI_UNICODE_COLLATION_PROTOCOL); + +typedef +INTN +(EFIAPI *EFI_UNICODE_STRICOLL) ( + IN struct _EFI_UNICODE_COLLATION_PROTOCOL *This, + IN CHAR16 *s1, + IN CHAR16 *s2 + ); + +typedef +BOOLEAN +(EFIAPI *EFI_UNICODE_METAIMATCH) ( + IN struct _EFI_UNICODE_COLLATION_PROTOCOL *This, + IN CHAR16 *String, + IN CHAR16 *Pattern + ); + +typedef +VOID +(EFIAPI *EFI_UNICODE_STRLWR) ( + IN struct _EFI_UNICODE_COLLATION_PROTOCOL *This, + IN OUT CHAR16 *Str + ); + +typedef +VOID +(EFIAPI *EFI_UNICODE_STRUPR) ( + IN struct _EFI_UNICODE_COLLATION_PROTOCOL *This, + IN OUT CHAR16 *Str + ); + +typedef +VOID +(EFIAPI *EFI_UNICODE_FATTOSTR) ( + IN struct _EFI_UNICODE_COLLATION_PROTOCOL *This, + IN UINTN FatSize, + IN CHAR8 *Fat, + OUT CHAR16 *String + ); + +typedef +BOOLEAN +(EFIAPI *EFI_UNICODE_STRTOFAT) ( + IN struct _EFI_UNICODE_COLLATION_PROTOCOL *This, + IN CHAR16 *String, + IN UINTN FatSize, + OUT CHAR8 *Fat + ); + +// +// Hash Protocol +// +#define EFI_HASH_PROTOCOL_GUID \ + { 0xC5184932, 0xDBA5, 0x46DB, { 0xA5, 0xBA, 0xCC, 0x0B, 0xDA, 0x9C, 0x14, 0x35 } } +#define HASH_PROTOCOL EFI_HASH_PROTOCOL_GUID + +#define EFI_HASH_ALGORITHM_SHA1_GUID \ + { 0x2AE9D80F, 0x3FB2, 0x4095, { 0xB7, 0xB1, 0xE9, 0x31, 0x57, 0xB9, 0x46, 0xB6 } } // Deprecated +#define EFI_HASH_ALGORITHM_SHA1 EFI_HASH_ALGORITHM_SHA1_GUID + +#define EFI_HASH_ALGORITHM_SHA224_GUID \ + { 0x8DF01A06, 0x9BD5, 0x4BF7, { 0xB0, 0x21, 0xDB, 0x4F, 0xD9, 0xCC, 0xF4, 0x5B } } // Deprecated +#define EFI_HASH_ALGORITHM_SHA224 EFI_HASH_ALGORITHM_SHA224_GUID + +#define EFI_HASH_ALGORITHM_SHA256_GUID \ + { 0x51AA59DE, 0xFDF2, 0x4EA3, { 0xBC, 0x63, 0x87, 0x5F, 0xB7, 0x84, 0x2E, 0xE9 } } // Deprecated +#define EFI_HASH_ALGORITHM_SHA256 EFI_HASH_ALGORITHM_SHA256_GUID + +#define EFI_HASH_ALGORITHM_SHA384_GUID \ + { 0xEFA96432, 0xDE33, 0x4DD2, { 0xAE, 0xE6, 0x32, 0x8C, 0x33, 0xDF, 0x77, 0x7A } } // Deprecated +#define EFI_HASH_ALGORITHM_SHA384 EFI_HASH_ALGORITHM_SHA384_GUID + +#define EFI_HASH_ALGORITHM_SHA512_GUID \ + { 0xCAA4381E, 0x750C, 0x4770, { 0xB8, 0x70, 0x7A, 0x23, 0xB4, 0xE4, 0x21, 0x30 } } // Deprecated +#define EFI_HASH_ALGORITHM_SHA512 EFI_HASH_ALGORITHM_SHA512_GUID + +#define EFI_HASH_ALGORITHM_MD5_GUID \ + { 0x0AF7C79C, 0x65B5, 0x4319, { 0xB0, 0xAE, 0x44, 0xEC, 0x48, 0x4E, 0x4A, 0xD7 } } // Deprecated +#define EFI_HASH_ALGORITHM_MD5 EFI_HASH_ALGORITHM_MD5_GUID + +#define EFI_HASH_ALGORITHM_SHA1_NOPAD_GUID \ + { 0x24C5DC2F, 0x53E2, 0x40CA, { 0x9E, 0xD6, 0xA5, 0xD9, 0xA4, 0x9F, 0x46, 0x3B } } +#define EFI_HASH_ALGORITHM_SHA1_NOPAD EFI_HASH_ALGORITHM_SHA1_NOPAD_GUID + +#define EFI_HASH_ALGORITHM_SHA256_NOPAD_GUID \ + { 0x8628752A, 0x6CB7, 0x4814, { 0x96, 0xFC, 0x24, 0xA8, 0x15, 0xAC, 0x22, 0x26 } } +#define EFI_HASH_ALGORITHM_SHA256_NOPAD EFI_HASH_ALGORITHM_SHA256_NOPAD_GUID + + +INTERFACE_DECL(_EFI_HASH_PROTOCOL); + +typedef UINT8 EFI_MD5_HASH[16]; +typedef UINT8 EFI_SHA1_HASH[20]; +typedef UINT8 EFI_SHA224_HASH[28]; +typedef UINT8 EFI_SHA256_HASH[32]; +typedef UINT8 EFI_SHA384_HASH[48]; +typedef UINT8 EFI_SHA512_HASH[64]; +typedef union _EFI_HASH_OUTPUT { + EFI_MD5_HASH *Md5Hash; + EFI_SHA1_HASH *Sha1Hash; + EFI_SHA224_HASH *Sha224Hash; + EFI_SHA256_HASH *Sha256Hash; + EFI_SHA384_HASH *Sha384Hash; + EFI_SHA512_HASH *Sha512Hash; +} EFI_HASH_OUTPUT; + +typedef +EFI_STATUS +(EFIAPI *EFI_HASH_GET_HASH_SIZE) ( + IN CONST struct _EFI_HASH_PROTOCOL *This, + IN CONST EFI_GUID *HashAlgorithm, + OUT UINTN *HashSize); + +typedef +EFI_STATUS +(EFIAPI *EFI_HASH_HASH) ( + IN CONST struct _EFI_HASH_PROTOCOL *This, + IN CONST EFI_GUID *HashAlgorithm, + IN BOOLEAN Extend, + IN CONST UINT8 *Message, + IN UINT64 MessageSize, + IN OUT EFI_HASH_OUTPUT *Hash); + +typedef struct _EFI_HASH_PROTOCOL { + EFI_HASH_GET_HASH_SIZE GetHashSize; + EFI_HASH_HASH Hash; +} EFI_HASH_PROTOCOL; + +typedef struct _EFI_HASH_PROTOCOL _EFI_HASH; +typedef EFI_HASH_PROTOCOL EFI_HASH; + + +typedef struct _EFI_UNICODE_COLLATION_PROTOCOL { + + // general + EFI_UNICODE_STRICOLL StriColl; + EFI_UNICODE_METAIMATCH MetaiMatch; + EFI_UNICODE_STRLWR StrLwr; + EFI_UNICODE_STRUPR StrUpr; + + // for supporting fat volumes + EFI_UNICODE_FATTOSTR FatToStr; + EFI_UNICODE_STRTOFAT StrToFat; + + CHAR8 *SupportedLanguages; +} EFI_UNICODE_COLLATION_PROTOCOL; + +typedef EFI_UNICODE_COLLATION_PROTOCOL EFI_UNICODE_COLLATION_INTERFACE; + +/* Graphics output protocol */ +#define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID \ + { 0x9042a9de, 0x23dc, 0x4a38, {0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a } } +typedef struct _EFI_GRAPHICS_OUTPUT_PROTOCOL EFI_GRAPHICS_OUTPUT_PROTOCOL; + +typedef struct { + UINT32 RedMask; + UINT32 GreenMask; + UINT32 BlueMask; + UINT32 ReservedMask; +} EFI_PIXEL_BITMASK; + +typedef enum { + PixelRedGreenBlueReserved8BitPerColor, + PixelBlueGreenRedReserved8BitPerColor, + PixelBitMask, + PixelBltOnly, + PixelFormatMax +} EFI_GRAPHICS_PIXEL_FORMAT; + +typedef struct { + UINT32 Version; + UINT32 HorizontalResolution; + UINT32 VerticalResolution; + EFI_GRAPHICS_PIXEL_FORMAT PixelFormat; + EFI_PIXEL_BITMASK PixelInformation; + UINT32 PixelsPerScanLine; +} EFI_GRAPHICS_OUTPUT_MODE_INFORMATION; + +/** + Return the current video mode information. + + @param This Protocol instance pointer. + @param ModeNumber The mode number to return information on. + @param SizeOfInfo A pointer to the size, in bytes, of the Info buffer. + @param Info A pointer to callee allocated buffer that returns information about ModeNumber. + + @retval EFI_SUCCESS Mode information returned. + @retval EFI_BUFFER_TOO_SMALL The Info buffer was too small. + @retval EFI_DEVICE_ERROR A hardware error occurred trying to retrieve the video mode. + @retval EFI_NOT_STARTED Video display is not initialized. Call SetMode () + @retval EFI_INVALID_PARAMETER One of the input args was NULL. + +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE) ( + IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, + IN UINT32 ModeNumber, + OUT UINTN *SizeOfInfo, + OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info + ) +; + +/** + Return the current video mode information. + + @param This Protocol instance pointer. + @param ModeNumber The mode number to be set. + + @retval EFI_SUCCESS Graphics mode was changed. + @retval EFI_DEVICE_ERROR The device had an error and could not complete the request. + @retval EFI_UNSUPPORTED ModeNumber is not supported by this device. + +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE) ( + IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, + IN UINT32 ModeNumber + ); + +typedef struct { + UINT8 Blue; + UINT8 Green; + UINT8 Red; + UINT8 Reserved; +} EFI_GRAPHICS_OUTPUT_BLT_PIXEL; + +typedef union { + EFI_GRAPHICS_OUTPUT_BLT_PIXEL Pixel; + UINT32 Raw; +} EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION; + +typedef enum { + EfiBltVideoFill, + EfiBltVideoToBltBuffer, + EfiBltBufferToVideo, + EfiBltVideoToVideo, + EfiGraphicsOutputBltOperationMax +} EFI_GRAPHICS_OUTPUT_BLT_OPERATION; + +/** + The following table defines actions for BltOperations: + + EfiBltVideoFill - Write data from the BltBuffer pixel (SourceX, SourceY) + directly to every pixel of the video display rectangle + (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height). + Only one pixel will be used from the BltBuffer. Delta is NOT used. + + EfiBltVideoToBltBuffer - Read data from the video display rectangle + (SourceX, SourceY) (SourceX + Width, SourceY + Height) and place it in + the BltBuffer rectangle (DestinationX, DestinationY ) + (DestinationX + Width, DestinationY + Height). If DestinationX or + DestinationY is not zero then Delta must be set to the length in bytes + of a row in the BltBuffer. + + EfiBltBufferToVideo - Write data from the BltBuffer rectangle + (SourceX, SourceY) (SourceX + Width, SourceY + Height) directly to the + video display rectangle (DestinationX, DestinationY) + (DestinationX + Width, DestinationY + Height). If SourceX or SourceY is + not zero then Delta must be set to the length in bytes of a row in the + BltBuffer. + + EfiBltVideoToVideo - Copy from the video display rectangle (SourceX, SourceY) + (SourceX + Width, SourceY + Height) .to the video display rectangle + (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height). + The BltBuffer and Delta are not used in this mode. + + @param This Protocol instance pointer. + @param BltBuffer Buffer containing data to blit into video buffer. This + buffer has a size of Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL) + @param BltOperation Operation to perform on BlitBuffer and video memory + @param SourceX X coordinate of source for the BltBuffer. + @param SourceY Y coordinate of source for the BltBuffer. + @param DestinationX X coordinate of destination for the BltBuffer. + @param DestinationY Y coordinate of destination for the BltBuffer. + @param Width Width of rectangle in BltBuffer in pixels. + @param Height Hight of rectangle in BltBuffer in pixels. + @param Delta OPTIONAL + + @retval EFI_SUCCESS The Blt operation completed. + @retval EFI_INVALID_PARAMETER BltOperation is not valid. + @retval EFI_DEVICE_ERROR A hardware error occured writting to the video buffer. + +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT) ( + IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, + IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL + IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation, + IN UINTN SourceX, + IN UINTN SourceY, + IN UINTN DestinationX, + IN UINTN DestinationY, + IN UINTN Width, + IN UINTN Height, + IN UINTN Delta OPTIONAL + ); + +typedef struct { + UINT32 MaxMode; + UINT32 Mode; + EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info; + UINTN SizeOfInfo; + EFI_PHYSICAL_ADDRESS FrameBufferBase; + UINTN FrameBufferSize; +} EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE; + +struct _EFI_GRAPHICS_OUTPUT_PROTOCOL { + EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE QueryMode; + EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE SetMode; + EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT Blt; + EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *Mode; +}; + + + +/* + * EFI EDID Discovered Protocol + * UEFI Specification Version 2.5 Section 11.9 + */ +#define EFI_EDID_DISCOVERED_PROTOCOL_GUID \ + { 0x1C0C34F6, 0xD380, 0x41FA, { 0xA0, 0x49, 0x8a, 0xD0, 0x6C, 0x1A, 0x66, 0xAA} } + +typedef struct _EFI_EDID_DISCOVERED_PROTOCOL { + UINT32 SizeOfEdid; + UINT8 *Edid; +} EFI_EDID_DISCOVERED_PROTOCOL; + + + +/* + * EFI EDID Active Protocol + * UEFI Specification Version 2.5 Section 11.9 + */ +#define EFI_EDID_ACTIVE_PROTOCOL_GUID \ + { 0xBD8C1056, 0x9F36, 0x44EC, { 0x92, 0xA8, 0xA6, 0x33, 0x7F, 0x81, 0x79, 0x86} } + +typedef struct _EFI_EDID_ACTIVE_PROTOCOL { + UINT32 SizeOfEdid; + UINT8 *Edid; +} EFI_EDID_ACTIVE_PROTOCOL; + + + +/* + * EFI EDID Override Protocol + * UEFI Specification Version 2.5 Section 11.9 + */ +#define EFI_EDID_OVERRIDE_PROTOCOL_GUID \ + { 0x48ECB431, 0xFB72, 0x45C0, { 0xA9, 0x22, 0xF4, 0x58, 0xFE, 0x04, 0x0B, 0xD5} } + +INTERFACE_DECL(_EFI_EDID_OVERRIDE_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_EDID_OVERRIDE_PROTOCOL_GET_EDID) ( + IN struct _EFI_EDID_OVERRIDE_PROTOCOL *This, + IN EFI_HANDLE *ChildHandle, + OUT UINT32 *Attributes, + IN OUT UINTN *EdidSize, + IN OUT UINT8 **Edid); + +typedef struct _EFI_EDID_OVERRIDE_PROTOCOL { + EFI_EDID_OVERRIDE_PROTOCOL_GET_EDID GetEdid; +} EFI_EDID_OVERRIDE_PROTOCOL; + + + +INTERFACE_DECL(_EFI_SERVICE_BINDING); + +typedef +EFI_STATUS +(EFIAPI *EFI_SERVICE_BINDING_CREATE_CHILD) ( + IN struct _EFI_SERVICE_BINDING *This, + IN EFI_HANDLE *ChildHandle + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SERVICE_BINDING_DESTROY_CHILD) ( + IN struct _EFI_SERVICE_BINDING *This, + IN EFI_HANDLE ChildHandle + ); + +typedef struct _EFI_SERVICE_BINDING { + EFI_SERVICE_BINDING_CREATE_CHILD CreateChild; + EFI_SERVICE_BINDING_DESTROY_CHILD DestroyChild; +} EFI_SERVICE_BINDING; + + + +/* + * EFI Driver Binding Protocol + * UEFI Specification Version 2.5 Section 10.1 + */ +#define EFI_DRIVER_BINDING_PROTOCOL_GUID \ + { 0x18A031AB, 0xB443, 0x4D1A, { 0xA5, 0xC0, 0x0C, 0x09, 0x26, 0x1E, 0x9F, 0x71} } +#define DRIVER_BINDING_PROTOCOL EFI_DRIVER_BINDING_PROTOCOL_GUID + +INTERFACE_DECL(_EFI_DRIVER_BINDING_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_DRIVER_BINDING_PROTOCOL_SUPPORTED) ( + IN struct _EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_DEVICE_PATH *RemainingDevicePath OPTIONAL); + +typedef +EFI_STATUS +(EFIAPI *EFI_DRIVER_BINDING_PROTOCOL_START) ( + IN struct _EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_DEVICE_PATH *RemainingDevicePath OPTIONAL); + +typedef +EFI_STATUS +(EFIAPI *EFI_DRIVER_BINDING_PROTOCOL_STOP) ( + IN struct _EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN UINTN NumberOfChildren, + IN EFI_HANDLE *ChildHandleBuffer OPTIONAL); + +typedef struct _EFI_DRIVER_BINDING_PROTOCOL { + EFI_DRIVER_BINDING_PROTOCOL_SUPPORTED Supported; + EFI_DRIVER_BINDING_PROTOCOL_START Start; + EFI_DRIVER_BINDING_PROTOCOL_STOP Stop; + UINT32 Version; + EFI_HANDLE ImageHandle; + EFI_HANDLE DriverBindingHandle; +} EFI_DRIVER_BINDING_PROTOCOL; + +typedef struct _EFI_DRIVER_BINDING_PROTOCOL _EFI_DRIVER_BINDING; +typedef EFI_DRIVER_BINDING_PROTOCOL EFI_DRIVER_BINDING; + + +/* + * Backwards compatibility with older GNU-EFI versions. Deprecated. + */ +#define EFI_DRIVER_SUPPORTED EFI_DRIVER_BINDING_PROTOCOL_SUPPORTED +#define EFI_DRIVER_START EFI_DRIVER_BINDING_PROTOCOL_START +#define EFI_DRIVER_STOP EFI_DRIVER_BINDING_PROTOCOL_STOP + + + +/* + * EFI Component Name Protocol + * Deprecated - use EFI Component Name 2 Protocol instead + */ +#define EFI_COMPONENT_NAME_PROTOCOL_GUID \ + {0x107A772C, 0xD5E1, 0x11D4, { 0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} } +#define COMPONENT_NAME_PROTOCOL EFI_COMPONENT_NAME_PROTOCOL_GUID + +INTERFACE_DECL(_EFI_COMPONENT_NAME_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_COMPONENT_NAME_GET_DRIVER_NAME) ( + IN struct _EFI_COMPONENT_NAME_PROTOCOL *This, + IN CHAR8 *Language, + OUT CHAR16 **DriverName); + +typedef +EFI_STATUS +(EFIAPI *EFI_COMPONENT_NAME_GET_CONTROLLER_NAME) ( + IN struct _EFI_COMPONENT_NAME_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN CHAR8 *Language, + OUT CHAR16 **ControllerName); + +typedef struct _EFI_COMPONENT_NAME_PROTOCOL { + EFI_COMPONENT_NAME_GET_DRIVER_NAME GetDriverName; + EFI_COMPONENT_NAME_GET_CONTROLLER_NAME GetControllerName; + CHAR8 *SupportedLanguages; +} EFI_COMPONENT_NAME_PROTOCOL; + +typedef struct _EFI_COMPONENT_NAME_PROTOCOL _EFI_COMPONENT_NAME; +typedef EFI_COMPONENT_NAME_PROTOCOL EFI_COMPONENT_NAME; + + +/* + * EFI Component Name 2 Protocol + * UEFI Specification Version 2.5 Section 10.5 + */ +#define EFI_COMPONENT_NAME2_PROTOCOL_GUID \ + {0x6A7A5CFF, 0xE8D9, 0x4F70, { 0xBA, 0xDA, 0x75, 0xAB, 0x30, 0x25, 0xCE, 0x14} } +#define COMPONENT_NAME2_PROTOCOL EFI_COMPONENT_NAME2_PROTOCOL_GUID + +INTERFACE_DECL(_EFI_COMPONENT_NAME2_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_COMPONENT_NAME2_GET_DRIVER_NAME) ( + IN struct _EFI_COMPONENT_NAME2_PROTOCOL *This, + IN CHAR8 *Language, + OUT CHAR16 **DriverName); + +typedef +EFI_STATUS +(EFIAPI *EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) ( + IN struct _EFI_COMPONENT_NAME2_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN CHAR8 *Language, + OUT CHAR16 **ControllerName); + +typedef struct _EFI_COMPONENT_NAME2_PROTOCOL { + EFI_COMPONENT_NAME2_GET_DRIVER_NAME GetDriverName; + EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME GetControllerName; + CHAR8 *SupportedLanguages; +} EFI_COMPONENT_NAME2_PROTOCOL; + +typedef struct _EFI_COMPONENT_NAME2_PROTOCOL _EFI_COMPONENT_NAME2; +typedef EFI_COMPONENT_NAME2_PROTOCOL EFI_COMPONENT_NAME2; + + + +/* + * EFI Loaded Image Protocol + * UEFI Specification Version 2.5 Section 8.1 + */ +#define EFI_LOADED_IMAGE_PROTOCOL_GUID \ + { 0x5B1B31A1, 0x9562, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} } +#define LOADED_IMAGE_PROTOCOL EFI_LOADED_IMAGE_PROTOCOL_GUID + +#define EFI_LOADED_IMAGE_PROTOCOL_REVISION 0x1000 +#define EFI_IMAGE_INFORMATION_REVISION EFI_LOADED_IMAGE_PROTOCOL_REVISION + +typedef +EFI_STATUS +(EFIAPI *EFI_IMAGE_UNLOAD) ( + IN EFI_HANDLE ImageHandle + ); + +typedef struct { + UINT32 Revision; + EFI_HANDLE ParentHandle; + struct _EFI_SYSTEM_TABLE *SystemTable; + + // Source location of image + EFI_HANDLE DeviceHandle; + EFI_DEVICE_PATH *FilePath; + VOID *Reserved; + + // Images load options + UINT32 LoadOptionsSize; + VOID *LoadOptions; + + // Location of where image was loaded + VOID *ImageBase; + UINT64 ImageSize; + EFI_MEMORY_TYPE ImageCodeType; + EFI_MEMORY_TYPE ImageDataType; + + // If the driver image supports a dynamic unload request + EFI_IMAGE_UNLOAD Unload; +} EFI_LOADED_IMAGE_PROTOCOL; + +typedef EFI_LOADED_IMAGE_PROTOCOL EFI_LOADED_IMAGE; + +#define EFI_LOADED_IMAGE_DEVICE_PATH_PROTOCOL_GUID \ + {0xbc62157e, 0x3e33, 0x4fec, {0x99, 0x20, 0x2d, 0x3b, 0x36, 0xd7, 0x50, 0xdf} } + +/* + * Random Number Generator Protocol + * UEFI Specification Version 2.5 Section 35.5 + */ +#define EFI_RNG_PROTOCOL_GUID \ + { 0x3152bca5, 0xeade, 0x433d, {0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44} } + +typedef EFI_GUID EFI_RNG_ALGORITHM; + +#define EFI_RNG_ALGORITHM_SP800_90_HASH_256_GUID \ + {0xa7af67cb, 0x603b, 0x4d42, {0xba, 0x21, 0x70, 0xbf, 0xb6, 0x29, 0x3f, 0x96} } + +#define EFI_RNG_ALGORITHM_SP800_90_HMAC_256_GUID \ + {0xc5149b43, 0xae85, 0x4f53, {0x99, 0x82, 0xb9, 0x43, 0x35, 0xd3, 0xa9, 0xe7} } + +#define EFI_RNG_ALGORITHM_SP800_90_CTR_256_GUID \ + {0x44f0de6e, 0x4d8c, 0x4045, {0xa8, 0xc7, 0x4d, 0xd1, 0x68, 0x85, 0x6b, 0x9e} } + +#define EFI_RNG_ALGORITHM_X9_31_3DES_GUID \ + {0x63c4785a, 0xca34, 0x4012, {0xa3, 0xc8, 0x0b, 0x6a, 0x32, 0x4f, 0x55, 0x46} } + +#define EFI_RNG_ALGORITHM_X9_31_AES_GUID \ + {0xacd03321, 0x777e, 0x4d3d, {0xb1, 0xc8, 0x20, 0xcf, 0xd8, 0x88, 0x20, 0xc9} } + +#define EFI_RNG_ALGORITHM_RAW \ + {0xe43176d7, 0xb6e8, 0x4827, {0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61} } + +INTERFACE_DECL(_EFI_RNG_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_RNG_GET_INFO) ( + IN struct _EFI_RNG_PROTOCOL *This, + IN OUT UINTN *RNGAlgorithmListSize, + OUT EFI_RNG_ALGORITHM *RNGAlgorithmList +); + +typedef +EFI_STATUS +(EFIAPI *EFI_RNG_GET_RNG) ( + IN struct _EFI_RNG_PROTOCOL *This, + IN EFI_RNG_ALGORITHM *RNGAlgorithm, OPTIONAL + IN UINTN RNGValueLength, + OUT UINT8 *RNGValue +); + +typedef struct _EFI_RNG_PROTOCOL { + EFI_RNG_GET_INFO GetInfo; + EFI_RNG_GET_RNG GetRNG; +} EFI_RNG_PROTOCOL; + + +// +// EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL +// + +#define EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL_GUID \ + { 0x6b30c738, 0xa391, 0x11d4, {0x9a, 0x3b, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +INTERFACE_DECL(_EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER) ( +IN struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL *This, +IN EFI_HANDLE ControllerHandle, +IN OUT EFI_HANDLE *DriverImageHandle); + +typedef +EFI_STATUS +(EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER_PATH) ( +IN struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL *This, +IN EFI_HANDLE ControllerHandle, +IN OUT EFI_DEVICE_PATH **DriverImagePath); + +typedef +EFI_STATUS +(EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_DRIVER_LOADED) ( +IN struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL *This, +IN EFI_HANDLE ControllerHandle, +IN EFI_DEVICE_PATH *DriverImagePath, +IN EFI_HANDLE DriverImageHandle); + +typedef struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL { + EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER GetDriver; + EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER_PATH GetDriverPath; + EFI_PLATFORM_DRIVER_OVERRIDE_DRIVER_LOADED DriverLoaded; +} EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL; + +// +// EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL +// + +#define EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL_GUID \ + { 0x3bc1b285, 0x8a15, 0x4a82, {0xaa, 0xbf, 0x4d, 0x7d, 0x13, 0xfb, 0x32, 0x65} } + +INTERFACE_DECL(_EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_GET_DRIVER) ( +IN struct _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *This, +IN OUT EFI_HANDLE *DriverImageHandle); + +typedef struct _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL { + EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_GET_DRIVER GetDriver; +} EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL; + +// +// EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL +// + +#define EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL_GUID \ + { 0xb1ee129e, 0xda36, 0x4181, {0x91, 0xf8, 0x04, 0xa4, 0x92, 0x37, 0x66, 0xa7} } + +INTERFACE_DECL(_EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL); + +typedef +UINT32 +(EFIAPI *EFI_DRIVER_FAMILY_OVERRIDE_GET_VERSION) ( +IN struct _EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL *This); + +typedef struct _EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL { + EFI_DRIVER_FAMILY_OVERRIDE_GET_VERSION GetVersion; +} EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL; + +// +// EFI_EBC_PROTOCOL +// + +#define EFI_EBC_INTERPRETER_PROTOCOL_GUID \ + {0x13ac6dd1, 0x73d0, 0x11d4, {0xb0, 0x6b, 0x00, 0xaa, 0x00, 0xbd, 0x6d, 0xe7} } + +#define EFI_EBC_PROTOCOL_GUID EFI_EBC_INTERPRETER_PROTOCOL_GUID + +INTERFACE_DECL(_EFI_EBC_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_EBC_CREATE_THUNK)( + IN struct _EFI_EBC_PROTOCOL *This, + IN EFI_HANDLE ImageHandle, + IN VOID *EbcEntryPoint, + OUT VOID **Thunk); + +typedef +EFI_STATUS +(EFIAPI *EFI_EBC_UNLOAD_IMAGE)( + IN struct _EFI_EBC_PROTOCOL *This, + IN EFI_HANDLE ImageHandle); + +typedef +EFI_STATUS +(EFIAPI *EBC_ICACHE_FLUSH)( + IN EFI_PHYSICAL_ADDRESS Start, + IN UINT64 Length); + +typedef +EFI_STATUS +(EFIAPI *EFI_EBC_REGISTER_ICACHE_FLUSH)( + IN struct _EFI_EBC_PROTOCOL *This, + IN EBC_ICACHE_FLUSH Flush); + +typedef +EFI_STATUS +(EFIAPI *EFI_EBC_GET_VERSION)( + IN struct _EFI_EBC_PROTOCOL *This, + IN OUT UINT64 *Version); + +typedef struct _EFI_EBC_PROTOCOL { + EFI_EBC_CREATE_THUNK CreateThunk; + EFI_EBC_UNLOAD_IMAGE UnloadImage; + EFI_EBC_REGISTER_ICACHE_FLUSH RegisterICacheFlush; + EFI_EBC_GET_VERSION GetVersion; +} EFI_EBC_PROTOCOL; + +INTERFACE_DECL(_EFI_MEMORY_ATTRIBUTE_PROTOCOL); + +typedef +EFI_STATUS +(EFIAPI *EFI_GET_MEMORY_ATTRIBUTES)( + IN struct _EFI_MEMORY_ATTRIBUTE_PROTOCOL *This, + IN EFI_PHYSICAL_ADDRESS BaseAddress, + IN UINT64 Length, + OUT UINT64 *Attributes + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SET_MEMORY_ATTRIBUTES)( + IN struct _EFI_MEMORY_ATTRIBUTE_PROTOCOL *This, + IN EFI_PHYSICAL_ADDRESS BaseAddress, + IN UINT64 Length, + IN UINT64 Attributes + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_CLEAR_MEMORY_ATTRIBUTES)( + IN struct _EFI_MEMORY_ATTRIBUTE_PROTOCOL *This, + IN EFI_PHYSICAL_ADDRESS BaseAddress, + IN UINT64 Length, + IN UINT64 Attributes + ); + +typedef struct _EFI_MEMORY_ATTRIBUTE_PROTOCOL { + EFI_GET_MEMORY_ATTRIBUTES GetMemoryAttributes; + EFI_SET_MEMORY_ATTRIBUTES SetMemoryAttributes; + EFI_CLEAR_MEMORY_ATTRIBUTES ClearMemoryAttributes; +} EFI_MEMORY_ATTRIBUTE_PROTOCOL; + +#endif diff --git a/gnuefi/inc/efipxebc.h b/gnuefi/inc/efipxebc.h new file mode 100644 index 0000000..3760c7c --- /dev/null +++ b/gnuefi/inc/efipxebc.h @@ -0,0 +1,482 @@ +#ifndef _EFIPXEBC_H +#define _EFIPXEBC_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efipxebc.h + +Abstract: + + EFI PXE Base Code Protocol + + + +Revision History + +--*/ + +// +// PXE Base Code protocol +// + +#define EFI_PXE_BASE_CODE_PROTOCOL_GUID \ + { 0x03c4e603, 0xac28, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +INTERFACE_DECL(_EFI_PXE_BASE_CODE_PROTOCOL); + +#define DEFAULT_TTL 4 +#define DEFAULT_ToS 0 +// +// Address definitions +// + +typedef union { + UINT32 Addr[4]; + EFI_IPv4_ADDRESS v4; + EFI_IPv6_ADDRESS v6; +} EFI_IP_ADDRESS; + +typedef UINT16 EFI_PXE_BASE_CODE_UDP_PORT; + +// +// Packet definitions +// + +typedef struct { + UINT8 BootpOpcode; + UINT8 BootpHwType; + UINT8 BootpHwAddrLen; + UINT8 BootpGateHops; + UINT32 BootpIdent; + UINT16 BootpSeconds; + UINT16 BootpFlags; + UINT8 BootpCiAddr[4]; + UINT8 BootpYiAddr[4]; + UINT8 BootpSiAddr[4]; + UINT8 BootpGiAddr[4]; + UINT8 BootpHwAddr[16]; + UINT8 BootpSrvName[64]; + UINT8 BootpBootFile[128]; + UINT32 DhcpMagik; + UINT8 DhcpOptions[56]; +} EFI_PXE_BASE_CODE_DHCPV4_PACKET; + +typedef struct { + UINT32 MessageType:8; + UINT32 TransactionId:24; + UINT8 DhcpOptions[1024]; +} EFI_PXE_BASE_CODE_DHCPV6_PACKET; + +typedef union { + UINT8 Raw[1472]; + EFI_PXE_BASE_CODE_DHCPV4_PACKET Dhcpv4; + EFI_PXE_BASE_CODE_DHCPV6_PACKET Dhcpv6; +} EFI_PXE_BASE_CODE_PACKET; + +typedef struct { + UINT8 Type; + UINT8 Code; + UINT16 Checksum; + union { + UINT32 reserved; + UINT32 Mtu; + UINT32 Pointer; + struct { + UINT16 Identifier; + UINT16 Sequence; + } Echo; + } u; + UINT8 Data[494]; +} EFI_PXE_BASE_CODE_ICMP_ERROR; + +typedef struct { + UINT8 ErrorCode; + CHAR8 ErrorString[127]; +} EFI_PXE_BASE_CODE_TFTP_ERROR; + +// +// IP Receive Filter definitions +// +#define EFI_PXE_BASE_CODE_MAX_IPCNT 8 +typedef struct { + UINT8 Filters; + UINT8 IpCnt; + UINT16 reserved; + EFI_IP_ADDRESS IpList[EFI_PXE_BASE_CODE_MAX_IPCNT]; +} EFI_PXE_BASE_CODE_IP_FILTER; + +#define EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP 0x0001 +#define EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST 0x0002 +#define EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS 0x0004 +#define EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST 0x0008 + +// +// ARP Cache definitions +// + +typedef struct { + EFI_IP_ADDRESS IpAddr; + EFI_MAC_ADDRESS MacAddr; +} EFI_PXE_BASE_CODE_ARP_ENTRY; + +typedef struct { + EFI_IP_ADDRESS IpAddr; + EFI_IP_ADDRESS SubnetMask; + EFI_IP_ADDRESS GwAddr; +} EFI_PXE_BASE_CODE_ROUTE_ENTRY; + +// +// UDP definitions +// + +#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP 0x0001 +#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT 0x0002 +#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP 0x0004 +#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT 0x0008 +#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER 0x0010 +#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_MAY_FRAGMENT 0x0020 + +// +// Discover() definitions +// + +#define EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP 0 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_MS_WINNT_RIS 1 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_INTEL_LCM 2 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_DOSUNDI 3 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_NEC_ESMPRO 4 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_IBM_WSoD 5 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_IBM_LCCM 6 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_CA_UNICENTER_TNG 7 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_HP_OPENVIEW 8 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_9 9 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_10 10 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_11 11 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_NOT_USED_12 12 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_INSTALL 13 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_BOOT 14 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_REMBO 15 +#define EFI_PXE_BASE_CODE_BOOT_TYPE_BEOBOOT 16 +// +// 17 through 32767 are reserved +// 32768 through 65279 are for vendor use +// 65280 through 65534 are reserved +// +#define EFI_PXE_BASE_CODE_BOOT_TYPE_PXETEST 65535 + +#define EFI_PXE_BASE_CODE_BOOT_LAYER_MASK 0x7FFF +#define EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL 0x0000 + + +typedef struct { + UINT16 Type; + BOOLEAN AcceptAnyResponse; + UINT8 Reserved; + EFI_IP_ADDRESS IpAddr; +} EFI_PXE_BASE_CODE_SRVLIST; + +typedef struct { + BOOLEAN UseMCast; + BOOLEAN UseBCast; + BOOLEAN UseUCast; + BOOLEAN MustUseList; + EFI_IP_ADDRESS ServerMCastIp; + UINT16 IpCnt; + EFI_PXE_BASE_CODE_SRVLIST SrvList[1]; +} EFI_PXE_BASE_CODE_DISCOVER_INFO; + +// +// Mtftp() definitions +// + +typedef enum { + EFI_PXE_BASE_CODE_TFTP_FIRST, + EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE, + EFI_PXE_BASE_CODE_TFTP_READ_FILE, + EFI_PXE_BASE_CODE_TFTP_WRITE_FILE, + EFI_PXE_BASE_CODE_TFTP_READ_DIRECTORY, + EFI_PXE_BASE_CODE_MTFTP_GET_FILE_SIZE, + EFI_PXE_BASE_CODE_MTFTP_READ_FILE, + EFI_PXE_BASE_CODE_MTFTP_READ_DIRECTORY, + EFI_PXE_BASE_CODE_MTFTP_LAST +} EFI_PXE_BASE_CODE_TFTP_OPCODE; + +typedef struct { + EFI_IP_ADDRESS MCastIp; + EFI_PXE_BASE_CODE_UDP_PORT CPort; + EFI_PXE_BASE_CODE_UDP_PORT SPort; + UINT16 ListenTimeout; + UINT16 TransmitTimeout; +} EFI_PXE_BASE_CODE_MTFTP_INFO; + +// +// PXE Base Code Mode structure +// + +#define EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES 8 +#define EFI_PXE_BASE_CODE_MAX_ROUTE_ENTRIES 8 + +typedef struct { + BOOLEAN Started; + BOOLEAN Ipv6Available; + BOOLEAN Ipv6Supported; + BOOLEAN UsingIpv6; + BOOLEAN BisSupported; + BOOLEAN BisDetected; + BOOLEAN AutoArp; + BOOLEAN SendGUID; + BOOLEAN DhcpDiscoverValid; + BOOLEAN DhcpAckReceived; + BOOLEAN ProxyOfferReceived; + BOOLEAN PxeDiscoverValid; + BOOLEAN PxeReplyReceived; + BOOLEAN PxeBisReplyReceived; + BOOLEAN IcmpErrorReceived; + BOOLEAN TftpErrorReceived; + BOOLEAN MakeCallbacks; + UINT8 TTL; + UINT8 ToS; + EFI_IP_ADDRESS StationIp; + EFI_IP_ADDRESS SubnetMask; + EFI_PXE_BASE_CODE_PACKET DhcpDiscover; + EFI_PXE_BASE_CODE_PACKET DhcpAck; + EFI_PXE_BASE_CODE_PACKET ProxyOffer; + EFI_PXE_BASE_CODE_PACKET PxeDiscover; + EFI_PXE_BASE_CODE_PACKET PxeReply; + EFI_PXE_BASE_CODE_PACKET PxeBisReply; + EFI_PXE_BASE_CODE_IP_FILTER IpFilter; + UINT32 ArpCacheEntries; + EFI_PXE_BASE_CODE_ARP_ENTRY ArpCache[EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES]; + UINT32 RouteTableEntries; + EFI_PXE_BASE_CODE_ROUTE_ENTRY RouteTable[EFI_PXE_BASE_CODE_MAX_ROUTE_ENTRIES]; + EFI_PXE_BASE_CODE_ICMP_ERROR IcmpError; + EFI_PXE_BASE_CODE_TFTP_ERROR TftpError; +} EFI_PXE_BASE_CODE_MODE; + +// +// PXE Base Code Interface Function definitions +// + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_START) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN BOOLEAN UseIpv6 + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_STOP) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_DHCP) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN BOOLEAN SortOffers + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_DISCOVER) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN UINT16 Type, + IN UINT16 *Layer, + IN BOOLEAN UseBis, + IN OUT EFI_PXE_BASE_CODE_DISCOVER_INFO *Info OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_MTFTP) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN EFI_PXE_BASE_CODE_TFTP_OPCODE Operation, + IN OUT VOID *BufferPtr OPTIONAL, + IN BOOLEAN Overwrite, + IN OUT UINT64 *BufferSize, + IN UINTN *BlockSize OPTIONAL, + IN EFI_IP_ADDRESS *ServerIp, + IN UINT8 *Filename, + IN EFI_PXE_BASE_CODE_MTFTP_INFO *Info OPTIONAL, + IN BOOLEAN DontUseBuffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_UDP_WRITE) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN UINT16 OpFlags, + IN EFI_IP_ADDRESS *DestIp, + IN EFI_PXE_BASE_CODE_UDP_PORT *DestPort, + IN EFI_IP_ADDRESS *GatewayIp, OPTIONAL + IN EFI_IP_ADDRESS *SrcIp, OPTIONAL + IN OUT EFI_PXE_BASE_CODE_UDP_PORT *SrcPort, OPTIONAL + IN UINTN *HeaderSize, OPTIONAL + IN VOID *HeaderPtr, OPTIONAL + IN UINTN *BufferSize, + IN VOID *BufferPtr + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_UDP_READ) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN UINT16 OpFlags, + IN OUT EFI_IP_ADDRESS *DestIp, OPTIONAL + IN OUT EFI_PXE_BASE_CODE_UDP_PORT *DestPort, OPTIONAL + IN OUT EFI_IP_ADDRESS *SrcIp, OPTIONAL + IN OUT EFI_PXE_BASE_CODE_UDP_PORT *SrcPort, OPTIONAL + IN UINTN *HeaderSize, OPTIONAL + IN VOID *HeaderPtr, OPTIONAL + IN OUT UINTN *BufferSize, + IN VOID *BufferPtr + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_SET_IP_FILTER) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN EFI_PXE_BASE_CODE_IP_FILTER *NewFilter + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_ARP) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN EFI_IP_ADDRESS *IpAddr, + IN EFI_MAC_ADDRESS *MacAddr OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_SET_PARAMETERS) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN BOOLEAN *NewAutoArp, OPTIONAL + IN BOOLEAN *NewSendGUID, OPTIONAL + IN UINT8 *NewTTL, OPTIONAL + IN UINT8 *NewToS, OPTIONAL + IN BOOLEAN *NewMakeCallback OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_SET_STATION_IP) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + IN EFI_IP_ADDRESS *NewStationIp, OPTIONAL + IN EFI_IP_ADDRESS *NewSubnetMask OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_PXE_BASE_CODE_SET_PACKETS) ( + IN struct _EFI_PXE_BASE_CODE_PROTOCOL *This, + BOOLEAN *NewDhcpDiscoverValid, OPTIONAL + BOOLEAN *NewDhcpAckReceived, OPTIONAL + BOOLEAN *NewProxyOfferReceived, OPTIONAL + BOOLEAN *NewPxeDiscoverValid, OPTIONAL + BOOLEAN *NewPxeReplyReceived, OPTIONAL + BOOLEAN *NewPxeBisReplyReceived,OPTIONAL + IN EFI_PXE_BASE_CODE_PACKET *NewDhcpDiscover, OPTIONAL + IN EFI_PXE_BASE_CODE_PACKET *NewDhcpAck, OPTIONAL + IN EFI_PXE_BASE_CODE_PACKET *NewProxyOffer, OPTIONAL + IN EFI_PXE_BASE_CODE_PACKET *NewPxeDiscover, OPTIONAL + IN EFI_PXE_BASE_CODE_PACKET *NewPxeReply, OPTIONAL + IN EFI_PXE_BASE_CODE_PACKET *NewPxeBisReply OPTIONAL + ); + +// +// PXE Base Code Protocol structure +// + +#define EFI_PXE_BASE_CODE_PROTOCOL_REVISION 0x00010000 +#define EFI_PXE_BASE_CODE_INTERFACE_REVISION EFI_PXE_BASE_CODE_PROTOCOL_REVISION + +typedef struct _EFI_PXE_BASE_CODE_PROTOCOL { + UINT64 Revision; + EFI_PXE_BASE_CODE_START Start; + EFI_PXE_BASE_CODE_STOP Stop; + EFI_PXE_BASE_CODE_DHCP Dhcp; + EFI_PXE_BASE_CODE_DISCOVER Discover; + EFI_PXE_BASE_CODE_MTFTP Mtftp; + EFI_PXE_BASE_CODE_UDP_WRITE UdpWrite; + EFI_PXE_BASE_CODE_UDP_READ UdpRead; + EFI_PXE_BASE_CODE_SET_IP_FILTER SetIpFilter; + EFI_PXE_BASE_CODE_ARP Arp; + EFI_PXE_BASE_CODE_SET_PARAMETERS SetParameters; + EFI_PXE_BASE_CODE_SET_STATION_IP SetStationIp; + EFI_PXE_BASE_CODE_SET_PACKETS SetPackets; + EFI_PXE_BASE_CODE_MODE *Mode; +} EFI_PXE_BASE_CODE_PROTOCOL; + +// Note: Because it conflicted with the EDK2 struct name, the +// 'EFI_PXE_BASE_CODE_PROTOCOL' GUID definition, from older +// versions of gnu-efi, is now obsoleted. +// Use 'EFI_PXE_BASE_CODE_PROTOCOL_GUID' instead. + +typedef struct _EFI_PXE_BASE_CODE_PROTOCOL _EFI_PXE_BASE_CODE; +typedef struct _EFI_PXE_BASE_CODE_PROTOCOL EFI_PXE_BASE_CODE; + +// +// Call Back Definitions +// + +#define EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_GUID \ + { 0x245dca21, 0xfb7b, 0x11d3, {0x8f, 0x01, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } + +// +// Revision Number +// + +#define EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_REVISION 0x00010000 +#define EFI_PXE_BASE_CODE_CALLBACK_INTERFACE_REVISION EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_REVISION + +INTERFACE_DECL(_EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL); + +typedef enum { + EFI_PXE_BASE_CODE_FUNCTION_FIRST, + EFI_PXE_BASE_CODE_FUNCTION_DHCP, + EFI_PXE_BASE_CODE_FUNCTION_DISCOVER, + EFI_PXE_BASE_CODE_FUNCTION_MTFTP, + EFI_PXE_BASE_CODE_FUNCTION_UDP_WRITE, + EFI_PXE_BASE_CODE_FUNCTION_UDP_READ, + EFI_PXE_BASE_CODE_FUNCTION_ARP, + EFI_PXE_BASE_CODE_FUNCTION_IGMP, + EFI_PXE_BASE_CODE_PXE_FUNCTION_LAST +} EFI_PXE_BASE_CODE_FUNCTION; + +typedef enum { + EFI_PXE_BASE_CODE_CALLBACK_STATUS_FIRST, + EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE, + EFI_PXE_BASE_CODE_CALLBACK_STATUS_ABORT, + EFI_PXE_BASE_CODE_CALLBACK_STATUS_LAST +} EFI_PXE_BASE_CODE_CALLBACK_STATUS; + +typedef +EFI_PXE_BASE_CODE_CALLBACK_STATUS +(EFIAPI *EFI_PXE_CALLBACK) ( + IN struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL *This, + IN EFI_PXE_BASE_CODE_FUNCTION Function, + IN BOOLEAN Received, + IN UINT32 PacketLen, + IN EFI_PXE_BASE_CODE_PACKET *Packet OPTIONAL + ); + +typedef struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL { + UINT64 Revision; + EFI_PXE_CALLBACK Callback; +} EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL; + +// Note: Because it conflicted with the EDK2 struct name, the +// 'EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL' GUID definition, from +// older versions of gnu-efi, is now obsoleted. +// Use 'EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_GUID' instead. + +typedef struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL _EFI_PXE_BASE_CODE_CALLBACK; +typedef EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL EFI_PXE_BASE_CODE_CALLBACK; + +#endif /* _EFIPXEBC_H */ diff --git a/gnuefi/inc/efirtlib.h b/gnuefi/inc/efirtlib.h new file mode 100644 index 0000000..518859e --- /dev/null +++ b/gnuefi/inc/efirtlib.h @@ -0,0 +1,193 @@ +#ifndef _EFI_RT_LIB_INCLUDE_ +#define _EFI_RT_LIB_INCLUDE_ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efilib.h + +Abstract: + + EFI Runtime library functions + + + +Revision History + +--*/ + +#include "efidebug.h" +#include "efipart.h" +#if defined(_M_X64) || defined(__x86_64__) || defined(__amd64__) +#include "x86_64/efilibplat.h" +#elif defined(_M_IX86) || defined(__i386__) +#include "ia32/efilibplat.h" +#elif defined(_M_IA64) || defined(__ia64__) +#include "ia64/efilibplat.h" +#elif defined (_M_ARM64) || defined(__aarch64__) +#include "aarch64/efilibplat.h" +#elif defined (_M_ARM) || defined(__arm__) +#include "arm/efilibplat.h" +#elif defined (_M_MIPS64) || defined(__mips64__) || defined(__mips64) +#include "mips64el/efilibplat.h" +#elif defined (__riscv) && __riscv_xlen == 64 +#include "riscv64/efilibplat.h" +#endif + + +VOID +RUNTIMEFUNCTION +RtZeroMem ( + IN VOID *Buffer, + IN UINTN Size + ); + +VOID +RUNTIMEFUNCTION +RtSetMem ( + IN VOID *Buffer, + IN UINTN Size, + IN UINT8 Value + ); + +VOID +RUNTIMEFUNCTION +RtCopyMem ( + IN VOID *Dest, + IN CONST VOID *Src, + IN UINTN len + ); + +INTN +RUNTIMEFUNCTION +RtCompareMem ( + IN CONST VOID *Dest, + IN CONST VOID *Src, + IN UINTN len + ); + +INTN +RUNTIMEFUNCTION +RtStrCmp ( + IN CONST CHAR16 *s1, + IN CONST CHAR16 *s2 + ); + + +VOID +RUNTIMEFUNCTION +RtStrCpy ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src + ); + +VOID +RUNTIMEFUNCTION +RtStrnCpy ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src, + IN UINTN Len + ); + +CHAR16 * +RUNTIMEFUNCTION +RtStpCpy ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src + ); + +CHAR16 * +RUNTIMEFUNCTION +RtStpnCpy ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src, + IN UINTN Len + ); + +VOID +RUNTIMEFUNCTION +RtStrCat ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src + ); + +VOID +RUNTIMEFUNCTION +RtStrnCat ( + IN CHAR16 *Dest, + IN CONST CHAR16 *Src, + IN UINTN Len + ); + +UINTN +RUNTIMEFUNCTION +RtStrLen ( + IN CONST CHAR16 *s1 + ); + +UINTN +RUNTIMEFUNCTION +RtStrnLen ( + IN CONST CHAR16 *s1, + IN UINTN Len + ); + +UINTN +RUNTIMEFUNCTION +RtStrSize ( + IN CONST CHAR16 *s1 + ); + +INTN +RUNTIMEFUNCTION +RtCompareGuid ( + IN EFI_GUID *Guid1, + IN EFI_GUID *Guid2 + ); + +UINT8 +RUNTIMEFUNCTION +RtDecimaltoBCD( + IN UINT8 BcdValue + ); + +UINT8 +RUNTIMEFUNCTION +RtBCDtoDecimal( + IN UINT8 BcdValue + ); + +// +// Virtual mapping transition support. (Only used during +// the virtual address change transisition) +// + +VOID +RUNTIMEFUNCTION +RtLibEnableVirtualMappings ( + VOID + ); + +VOID +RUNTIMEFUNCTION +RtConvertList ( + IN UINTN DebugDisposition, + IN OUT LIST_ENTRY *ListHead + ); + +VOID +RUNTIMEFUNCTION +RtAcquireLock ( + IN FLOCK *Lock + ); + +VOID +RUNTIMEFUNCTION +RtReleaseLock ( + IN FLOCK *Lock + ); + + +#endif diff --git a/gnuefi/inc/efiser.h b/gnuefi/inc/efiser.h new file mode 100644 index 0000000..45a463e --- /dev/null +++ b/gnuefi/inc/efiser.h @@ -0,0 +1,136 @@ +#ifndef _EFI_SER_H +#define _EFI_SER_H + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efiser.h + +Abstract: + + EFI serial protocol + +Revision History + +--*/ + +// +// Serial protocol +// + +#define EFI_SERIAL_IO_PROTOCOL_GUID \ + { 0xBB25CF6F, 0xF1D4, 0x11D2, {0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0xFD} } +#define SERIAL_IO_PROTOCOL EFI_SERIAL_IO_PROTOCOL_GUID + +INTERFACE_DECL(_EFI_SERIAL_IO_PROTOCOL); + +typedef enum { + DefaultParity, + NoParity, + EvenParity, + OddParity, + MarkParity, + SpaceParity +} EFI_PARITY_TYPE; + +typedef enum { + DefaultStopBits, + OneStopBit, // 1 stop bit + OneFiveStopBits, // 1.5 stop bits + TwoStopBits // 2 stop bits +} EFI_STOP_BITS_TYPE; + +#define EFI_SERIAL_CLEAR_TO_SEND 0x0010 // RO +#define EFI_SERIAL_DATA_SET_READY 0x0020 // RO +#define EFI_SERIAL_RING_INDICATE 0x0040 // RO +#define EFI_SERIAL_CARRIER_DETECT 0x0080 // RO +#define EFI_SERIAL_REQUEST_TO_SEND 0x0002 // WO +#define EFI_SERIAL_DATA_TERMINAL_READY 0x0001 // WO +#define EFI_SERIAL_INPUT_BUFFER_EMPTY 0x0100 // RO +#define EFI_SERIAL_OUTPUT_BUFFER_EMPTY 0x0200 // RO +#define EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE 0x1000 // RW +#define EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE 0x2000 // RW +#define EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE 0x4000 // RW + +typedef +EFI_STATUS +(EFIAPI *EFI_SERIAL_RESET) ( + IN struct _EFI_SERIAL_IO_PROTOCOL *This + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SERIAL_SET_ATTRIBUTES) ( + IN struct _EFI_SERIAL_IO_PROTOCOL *This, + IN UINT64 BaudRate, + IN UINT32 ReceiveFifoDepth, + IN UINT32 Timeout, + IN EFI_PARITY_TYPE Parity, + IN UINT8 DataBits, + IN EFI_STOP_BITS_TYPE StopBits + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SERIAL_SET_CONTROL_BITS) ( + IN struct _EFI_SERIAL_IO_PROTOCOL *This, + IN UINT32 Control + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SERIAL_GET_CONTROL_BITS) ( + IN struct _EFI_SERIAL_IO_PROTOCOL *This, + OUT UINT32 *Control + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SERIAL_WRITE) ( + IN struct _EFI_SERIAL_IO_PROTOCOL *This, + IN OUT UINTN *BufferSize, + IN VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SERIAL_READ) ( + IN struct _EFI_SERIAL_IO_PROTOCOL *This, + IN OUT UINTN *BufferSize, + OUT VOID *Buffer + ); + +typedef struct { + UINT32 ControlMask; + + // current Attributes + UINT32 Timeout; + UINT64 BaudRate; + UINT32 ReceiveFifoDepth; + UINT32 DataBits; + UINT32 Parity; + UINT32 StopBits; +} SERIAL_IO_MODE; + +#define SERIAL_IO_INTERFACE_REVISION 0x00010000 + +typedef struct _EFI_SERIAL_IO_PROTOCOL { + UINT32 Revision; + EFI_SERIAL_RESET Reset; + EFI_SERIAL_SET_ATTRIBUTES SetAttributes; + EFI_SERIAL_SET_CONTROL_BITS SetControl; + EFI_SERIAL_GET_CONTROL_BITS GetControl; + EFI_SERIAL_WRITE Write; + EFI_SERIAL_READ Read; + + SERIAL_IO_MODE *Mode; +} EFI_SERIAL_IO_PROTOCOL; + +typedef struct _EFI_SERIAL_IO_PROTOCOL _SERIAL_IO_INTERFACE; +typedef EFI_SERIAL_IO_PROTOCOL SERIAL_IO_INTERFACE; + +#endif + diff --git a/gnuefi/inc/efisetjmp.h b/gnuefi/inc/efisetjmp.h new file mode 100644 index 0000000..4037688 --- /dev/null +++ b/gnuefi/inc/efisetjmp.h @@ -0,0 +1,10 @@ +#ifndef GNU_EFI_SETJMP_H +#define GNU_EFI_SETJMP_H + +#include "eficompiler.h" +#include "efisetjmp_arch.h" + +extern UINTN setjmp(jmp_buf env) __attribute__((returns_twice)); +extern VOID longjmp(jmp_buf env, UINTN value) EFI_NORETURN; + +#endif /* GNU_EFI_SETJMP_H */ diff --git a/gnuefi/inc/efishell.h b/gnuefi/inc/efishell.h new file mode 100644 index 0000000..aa3fab2 --- /dev/null +++ b/gnuefi/inc/efishell.h @@ -0,0 +1,449 @@ +/** + EFI Shell protocol as defined in the UEFI Shell Specification 2.2. + + (C) Copyright 2014 Hewlett-Packard Development Company, L.P.
+ Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.
+ SPDX-License-Identifier: BSD-2-Clause-Patent + + This file is based on MdePkg/Include/Protocol/Shell.h from EDK2 + Ported to gnu-efi by Jiaqing Zhao +**/ + +#ifndef _EFI_SHELL_H +#define _EFI_SHELL_H + +#include "efilink.h" + +#define EFI_SHELL_PROTOCOL_GUID \ + { 0x6302d008, 0x7f9b, 0x4f30, { 0x87, 0xac, 0x60, 0xc9, 0xfe, 0xf5, 0xda, 0x4e } } + +INTERFACE_DECL(_EFI_SHELL_PROTOCOL); + +typedef enum { + SHELL_SUCCESS = 0, + SHELL_LOAD_ERROR = 1, + SHELL_INVALID_PARAMETER = 2, + SHELL_UNSUPPORTED = 3, + SHELL_BAD_BUFFER_SIZE = 4, + SHELL_BUFFER_TOO_SMALL = 5, + SHELL_NOT_READY = 6, + SHELL_DEVICE_ERROR = 7, + SHELL_WRITE_PROTECTED = 8, + SHELL_OUT_OF_RESOURCES = 9, + SHELL_VOLUME_CORRUPTED = 10, + SHELL_VOLUME_FULL = 11, + SHELL_NO_MEDIA = 12, + SHELL_MEDIA_CHANGED = 13, + SHELL_NOT_FOUND = 14, + SHELL_ACCESS_DENIED = 15, + SHELL_TIMEOUT = 18, + SHELL_NOT_STARTED = 19, + SHELL_ALREADY_STARTED = 20, + SHELL_ABORTED = 21, + SHELL_INCOMPATIBLE_VERSION = 25, + SHELL_SECURITY_VIOLATION = 26, + SHELL_NOT_EQUAL = 27 +} SHELL_STATUS; + +typedef VOID *SHELL_FILE_HANDLE; + +typedef struct { + EFI_LIST_ENTRY Link; + EFI_STATUS Status; + CONST CHAR16 *FullName; + CONST CHAR16 *FileName; + SHELL_FILE_HANDLE Handle; + EFI_FILE_INFO *Info; +} EFI_SHELL_FILE_INFO; + +typedef +BOOLEAN +(EFIAPI *EFI_SHELL_BATCH_IS_ACTIVE) ( + VOID + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_CLOSE_FILE) ( + IN SHELL_FILE_HANDLE FileHandle + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_CREATE_FILE) ( + IN CONST CHAR16 *FileName, + IN UINT64 FileAttribs, + OUT SHELL_FILE_HANDLE *FileHandle + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_DELETE_FILE) ( + IN SHELL_FILE_HANDLE FileHandle + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_DELETE_FILE_BY_NAME) ( + IN CONST CHAR16 *FileName + ); + +typedef +VOID +(EFIAPI *EFI_SHELL_DISABLE_PAGE_BREAK) ( + VOID + ); + +typedef +VOID +(EFIAPI *EFI_SHELL_ENABLE_PAGE_BREAK) ( + VOID + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_EXECUTE) ( + IN EFI_HANDLE *ParentImageHandle, + IN CHAR16 *CommandLine OPTIONAL, + IN CHAR16 **Environment OPTIONAL, + OUT EFI_STATUS *StatusCode OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_FIND_FILES) ( + IN CONST CHAR16 *FilePattern, + OUT EFI_SHELL_FILE_INFO **FileList + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_FIND_FILES_IN_DIR) ( + IN SHELL_FILE_HANDLE FileDirHandle, + OUT EFI_SHELL_FILE_INFO **FileList + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_FLUSH_FILE) ( + IN SHELL_FILE_HANDLE FileHandle + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_FREE_FILE_LIST) ( + IN EFI_SHELL_FILE_INFO **FileList + ); + +typedef +CONST CHAR16 * +(EFIAPI *EFI_SHELL_GET_ALIAS) ( + IN CONST CHAR16 *Alias, + OUT BOOLEAN *Volatile OPTIONAL + ); + +typedef +CONST CHAR16 * +(EFIAPI *EFI_SHELL_GET_CUR_DIR) ( + IN CONST CHAR16 *FileSystemMapping OPTIONAL + ); + +typedef UINT32 EFI_SHELL_DEVICE_NAME_FLAGS; +#define EFI_DEVICE_NAME_USE_COMPONENT_NAME 0x00000001 +#define EFI_DEVICE_NAME_USE_DEVICE_PATH 0x00000002 + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_GET_DEVICE_NAME) ( + IN EFI_HANDLE DeviceHandle, + IN EFI_SHELL_DEVICE_NAME_FLAGS Flags, + IN CHAR8 *Language, + OUT CHAR16 **BestDeviceName + ); + +typedef +CONST EFI_DEVICE_PATH_PROTOCOL * +(EFIAPI *EFI_SHELL_GET_DEVICE_PATH_FROM_MAP) ( + IN CONST CHAR16 *Mapping + ); + +typedef +EFI_DEVICE_PATH_PROTOCOL * +(EFIAPI *EFI_SHELL_GET_DEVICE_PATH_FROM_FILE_PATH) ( + IN CONST CHAR16 *Path + ); + +typedef +CONST CHAR16 * +(EFIAPI *EFI_SHELL_GET_ENV) ( + IN CONST CHAR16 *Name + ); + +typedef +CONST CHAR16 * +(EFIAPI *EFI_SHELL_GET_ENV_EX) ( + IN CONST CHAR16 *Name, + OUT UINT32 *Attributes OPTIONAL + ); + +typedef +EFI_FILE_INFO * +(EFIAPI *EFI_SHELL_GET_FILE_INFO) ( + IN SHELL_FILE_HANDLE FileHandle + ); + +typedef +CHAR16 * +(EFIAPI *EFI_SHELL_GET_FILE_PATH_FROM_DEVICE_PATH) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *Path + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_GET_FILE_POSITION) ( + IN SHELL_FILE_HANDLE FileHandle, + OUT UINT64 *Position + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_GET_FILE_SIZE) ( + IN SHELL_FILE_HANDLE FileHandle, + OUT UINT64 *Size + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_GET_GUID_FROM_NAME) ( + IN CONST CHAR16 *GuidName, + OUT EFI_GUID *Guid + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_GET_GUID_NAME)( + IN CONST EFI_GUID *Guid, + OUT CONST CHAR16 **GuidName + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_GET_HELP_TEXT) ( + IN CONST CHAR16 *Command, + IN CONST CHAR16 *Sections, + OUT CHAR16 **HelpText + ); + +typedef +CONST CHAR16 * +(EFIAPI *EFI_SHELL_GET_MAP_FROM_DEVICE_PATH) ( + IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath + ); + +typedef +BOOLEAN +(EFIAPI *EFI_SHELL_GET_PAGE_BREAK) ( + VOID + ); + +typedef +BOOLEAN +(EFIAPI *EFI_SHELL_IS_ROOT_SHELL) ( + VOID + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_OPEN_FILE_BY_NAME) ( + IN CONST CHAR16 *FileName, + OUT SHELL_FILE_HANDLE *FileHandle, + IN UINT64 OpenMode + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_OPEN_FILE_LIST) ( + IN CHAR16 *Path, + IN UINT64 OpenMode, + IN OUT EFI_SHELL_FILE_INFO **FileList + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_OPEN_ROOT) ( + IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, + OUT SHELL_FILE_HANDLE *FileHandle + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_OPEN_ROOT_BY_HANDLE) ( + IN EFI_HANDLE DeviceHandle, + OUT SHELL_FILE_HANDLE *FileHandle + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_READ_FILE) ( + IN SHELL_FILE_HANDLE FileHandle, + IN OUT UINTN *ReadSize, + IN OUT VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_REGISTER_GUID_NAME) ( + IN CONST EFI_GUID *Guid, + IN CONST CHAR16 *GuidName + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_REMOVE_DUP_IN_FILE_LIST) ( + IN EFI_SHELL_FILE_INFO **FileList + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_SET_ALIAS) ( + IN CONST CHAR16 *Command, + IN CONST CHAR16 *Alias, + IN BOOLEAN Replace, + IN BOOLEAN Volatile + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_SET_CUR_DIR) ( + IN CONST CHAR16 *FileSystem OPTIONAL, + IN CONST CHAR16 *Dir + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_SET_ENV) ( + IN CONST CHAR16 *Name, + IN CONST CHAR16 *Value, + IN BOOLEAN Volatile + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_SET_FILE_INFO) ( + IN SHELL_FILE_HANDLE FileHandle, + IN CONST EFI_FILE_INFO *FileInfo + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_SET_FILE_POSITION) ( + IN SHELL_FILE_HANDLE FileHandle, + IN UINT64 Position + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_SET_MAP) ( + IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, + IN CONST CHAR16 *Mapping + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_SHELL_WRITE_FILE) ( + IN SHELL_FILE_HANDLE FileHandle, + IN OUT UINTN *BufferSize, + IN VOID *Buffer + ); + +typedef struct _EFI_SHELL_PROTOCOL { + EFI_SHELL_EXECUTE Execute; + EFI_SHELL_GET_ENV GetEnv; + EFI_SHELL_SET_ENV SetEnv; + EFI_SHELL_GET_ALIAS GetAlias; + EFI_SHELL_SET_ALIAS SetAlias; + EFI_SHELL_GET_HELP_TEXT GetHelpText; + EFI_SHELL_GET_DEVICE_PATH_FROM_MAP GetDevicePathFromMap; + EFI_SHELL_GET_MAP_FROM_DEVICE_PATH GetMapFromDevicePath; + EFI_SHELL_GET_DEVICE_PATH_FROM_FILE_PATH GetDevicePathFromFilePath; + EFI_SHELL_GET_FILE_PATH_FROM_DEVICE_PATH GetFilePathFromDevicePath; + EFI_SHELL_SET_MAP SetMap; + EFI_SHELL_GET_CUR_DIR GetCurDir; + EFI_SHELL_SET_CUR_DIR SetCurDir; + EFI_SHELL_OPEN_FILE_LIST OpenFileList; + EFI_SHELL_FREE_FILE_LIST FreeFileList; + EFI_SHELL_REMOVE_DUP_IN_FILE_LIST RemoveDupInFileList; + EFI_SHELL_BATCH_IS_ACTIVE BatchIsActive; + EFI_SHELL_IS_ROOT_SHELL IsRootShell; + EFI_SHELL_ENABLE_PAGE_BREAK EnablePageBreak; + EFI_SHELL_DISABLE_PAGE_BREAK DisablePageBreak; + EFI_SHELL_GET_PAGE_BREAK GetPageBreak; + EFI_SHELL_GET_DEVICE_NAME GetDeviceName; + EFI_SHELL_GET_FILE_INFO GetFileInfo; + EFI_SHELL_SET_FILE_INFO SetFileInfo; + EFI_SHELL_OPEN_FILE_BY_NAME OpenFileByName; + EFI_SHELL_CLOSE_FILE CloseFile; + EFI_SHELL_CREATE_FILE CreateFile; + EFI_SHELL_READ_FILE ReadFile; + EFI_SHELL_WRITE_FILE WriteFile; + EFI_SHELL_DELETE_FILE DeleteFile; + EFI_SHELL_DELETE_FILE_BY_NAME DeleteFileByName; + EFI_SHELL_GET_FILE_POSITION GetFilePosition; + EFI_SHELL_SET_FILE_POSITION SetFilePosition; + EFI_SHELL_FLUSH_FILE FlushFile; + EFI_SHELL_FIND_FILES FindFiles; + EFI_SHELL_FIND_FILES_IN_DIR FindFilesInDir; + EFI_SHELL_GET_FILE_SIZE GetFileSize; + EFI_SHELL_OPEN_ROOT OpenRoot; + EFI_SHELL_OPEN_ROOT_BY_HANDLE OpenRootByHandle; + EFI_EVENT ExecutionBreak; + UINT32 MajorVersion; + UINT32 MinorVersion; + // Added for Shell 2.1 + EFI_SHELL_REGISTER_GUID_NAME RegisterGuidName; + EFI_SHELL_GET_GUID_NAME GetGuidName; + EFI_SHELL_GET_GUID_FROM_NAME GetGuidFromName; + EFI_SHELL_GET_ENV_EX GetEnvEx; +} EFI_SHELL_PROTOCOL; + +#define EFI_SHELL_PARAMETERS_PROTOCOL_GUID \ + { 0x752f3136, 0x4e16, 0x4fdc, { 0xa2, 0x2a, 0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca } } + +INTERFACE_DECL(_EFI_SHELL_PARAMETERS_PROTOCOL); + +typedef struct _EFI_SHELL_PARAMETERS_PROTOCOL { + CHAR16 **Argv; + UINTN Argc; + SHELL_FILE_HANDLE StdIn; + SHELL_FILE_HANDLE StdOut; + SHELL_FILE_HANDLE StdErr; +} EFI_SHELL_PARAMETERS_PROTOCOL; + +#define EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL_GUID \ + { 0x3c7200e9, 0x005f, 0x4ea4, { 0x87, 0xde, 0xa3, 0xdf, 0xac, 0x8a, 0x27, 0xc3 } } + +INTERFACE_DECL(_EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL); + +typedef +SHELL_STATUS +(EFIAPI *SHELL_COMMAND_HANDLER)( + IN struct _EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *This, + IN EFI_SYSTEM_TABLE *SystemTable, + IN EFI_SHELL_PARAMETERS_PROTOCOL *ShellParameters, + IN EFI_SHELL_PROTOCOL *Shell + ); + +typedef +CHAR16* +(EFIAPI *SHELL_COMMAND_GETHELP)( + IN struct _EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *This, + IN CONST CHAR8 *Language + ); + +typedef struct _EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL { + CONST CHAR16 *CommandName; + SHELL_COMMAND_HANDLER Handler; + SHELL_COMMAND_GETHELP GetHelp; +} EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL; + +#endif diff --git a/gnuefi/inc/efishellintf.h b/gnuefi/inc/efishellintf.h new file mode 100644 index 0000000..e649acd --- /dev/null +++ b/gnuefi/inc/efishellintf.h @@ -0,0 +1,94 @@ +/** @file + SHELL_INTERFACE_PROTOCOL from EDK shell (no spec). + + Shell Interface - additional information (over image_info) provided + to an application started by the shell. + + ConIo provides a file-style interface to the console. + + The shell interface's and data (including ConIo) are only valid during + the applications Entry Point. Once the application returns from it's + entry point the data is freed by the invoking shell. + + Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ +/* + * This is based on ShellPkg/Include/Protocol/EfiShellInterface.h from EDK II. + */ + +#ifndef _SHELLINTERFACE_H_ +#define _SHELLINTERFACE_H_ + + +#define SHELL_INTERFACE_PROTOCOL_GUID \ + { \ + 0x47c7b223, 0xc42a, 0x11d2, {0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} \ + } + +/// +/// Bit definitions for EFI_SHELL_ARG_INFO +/// +typedef enum { + ARG_NO_ATTRIB = 0x0, + ARG_IS_QUOTED = 1<<0, + ARG_PARTIALLY_QUOTED = 1<<1, + ARG_FIRST_HALF_QUOTED = 1<<2, + ARG_FIRST_CHAR_IS_ESC = 1<<3 +} EFI_SHELL_ARG_INFO_TYPES; + +/// +/// Attributes for an argument. +/// +typedef struct _EFI_SHELL_ARG_INFO { + UINT32 Attributes; +} EFI_SHELL_ARG_INFO; + +/// +/// This protocol provides access to additional information about a shell application. +/// +typedef struct { + /// + /// Handle back to original image handle & image information. + /// + EFI_HANDLE ImageHandle; + EFI_LOADED_IMAGE *Info; + + /// + /// Parsed arg list converted more C-like format. + /// + CHAR16 **Argv; + UINTN Argc; + + /// + /// Storage for file redirection args after parsing. + /// + CHAR16 **RedirArgv; + UINTN RedirArgc; + + /// + /// A file style handle for console io. + /// + EFI_FILE *StdIn; + EFI_FILE *StdOut; + EFI_FILE *StdErr; + + /// + /// List of attributes for each argument. + /// + EFI_SHELL_ARG_INFO *ArgInfo; + + /// + /// Whether we are echoing. + /// + BOOLEAN EchoOn; +} EFI_SHELL_INTERFACE; + +#endif diff --git a/gnuefi/inc/efistdarg.h b/gnuefi/inc/efistdarg.h new file mode 100644 index 0000000..8312c3d --- /dev/null +++ b/gnuefi/inc/efistdarg.h @@ -0,0 +1,33 @@ +#ifndef _EFISTDARG_H_ +#define _EFISTDARG_H_ + +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + devpath.h + +Abstract: + + Defines for parsing the EFI Device Path structures + + + +Revision History + +--*/ + +#if !defined(GNU_EFI_USE_EXTERNAL_STDARG) && !defined(_MSC_VER) +typedef __builtin_va_list va_list; + +# define va_start(v,l) __builtin_va_start(v,l) +# define va_end(v) __builtin_va_end(v) +# define va_arg(v,l) __builtin_va_arg(v,l) +# define va_copy(d,s) __builtin_va_copy(d,s) +#else +# include +#endif + +#endif diff --git a/gnuefi/inc/efitcp.h b/gnuefi/inc/efitcp.h new file mode 100644 index 0000000..6c5df7f --- /dev/null +++ b/gnuefi/inc/efitcp.h @@ -0,0 +1,391 @@ +#ifndef _EFI_TCP_H +#define _EFI_TCP_H + +/*++ +Copyright (c) 2013 Intel Corporation + +--*/ + +#define EFI_TCP4_SERVICE_BINDING_PROTOCOL \ + { 0x00720665, 0x67eb, 0x4a99, {0xba, 0xf7, 0xd3, 0xc3, 0x3a, 0x1c,0x7c, 0xc9}} + +#define EFI_TCP4_PROTOCOL \ + { 0x65530bc7, 0xa359, 0x410f, {0xb0, 0x10, 0x5a, 0xad, 0xc7, 0xec, 0x2b, 0x62}} + +#define EFI_TCP6_SERVICE_BINDING_PROTOCOL \ + { 0xec20eb79, 0x6c1a, 0x4664, {0x9a, 0xd, 0xd2, 0xe4, 0xcc, 0x16, 0xd6, 0x64}} + +#define EFI_TCP6_PROTOCOL \ + { 0x46e44855, 0xbd60, 0x4ab7, {0xab, 0xd, 0xa6, 0x79, 0xb9, 0x44, 0x7d, 0x77}} + +INTERFACE_DECL(_EFI_TCP4); +INTERFACE_DECL(_EFI_TCP6); + +typedef struct { + BOOLEAN UseDefaultAddress; + EFI_IPv4_ADDRESS StationAddress; + EFI_IPv4_ADDRESS SubnetMask; + UINT16 StationPort; + EFI_IPv4_ADDRESS RemoteAddress; + UINT16 RemotePort; + BOOLEAN ActiveFlag; +} EFI_TCP4_ACCESS_POINT; + +typedef struct { + UINT32 ReceiveBufferSize; + UINT32 SendBufferSize; + UINT32 MaxSynBackLog; + UINT32 ConnectionTimeout; + UINT32 DataRetries; + UINT32 FinTimeout; + UINT32 TimeWaitTimeout; + UINT32 KeepAliveProbes; + UINT32 KeepAliveTime; + UINT32 KeepAliveInterval; + BOOLEAN EnableNagle; + BOOLEAN EnableTimeStamp; + BOOLEAN EnableWindowScaling; + BOOLEAN EnableSelectiveAck; + BOOLEAN EnablePAthMtuDiscovery; +} EFI_TCP4_OPTION; + +typedef struct { + // Receiving Filters + // I/O parameters + UINT8 TypeOfService; + UINT8 TimeToLive; + + // Access Point + EFI_TCP4_ACCESS_POINT AccessPoint; + + // TCP Control Options + EFI_TCP4_OPTION *ControlOption; +} EFI_TCP4_CONFIG_DATA; + +typedef enum { + Tcp4StateClosed = 0, + Tcp4StateListen = 1, + Tcp4StateSynSent = 2, + Tcp4StateSynReceived = 3, + Tcp4StateEstablished = 4, + Tcp4StateFinWait1 = 5, + Tcp4StateFinWait2 = 6, + Tcp4StateClosing = 7, + Tcp4StateTimeWait = 8, + Tcp4StateCloseWait = 9, + Tcp4StateLastAck = 10 +} EFI_TCP4_CONNECTION_STATE; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_GET_MODE_DATA) ( + IN struct _EFI_TCP4 *This, + OUT EFI_TCP4_CONNECTION_STATE *Tcp4State OPTIONAL, + OUT EFI_TCP4_CONFIG_DATA *Tcp4ConfigData OPTIONAL, + OUT EFI_IP4_MODE_DATA *Ip4ModeData OPTIONAL, + OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL, + OUT EFI_SIMPLE_NETWORK_MODE *SnpModeData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_CONFIGURE) ( + IN struct _EFI_TCP4 *This, + IN EFI_TCP4_CONFIG_DATA *TcpConfigData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_ROUTES) ( + IN struct _EFI_TCP4 *This, + IN BOOLEAN DeleteRoute, + IN EFI_IPv4_ADDRESS *SubnetAddress, + IN EFI_IPv4_ADDRESS *SubnetMask, + IN EFI_IPv4_ADDRESS *GatewayAddress +); + +typedef struct { + EFI_EVENT Event; + EFI_STATUS Status; +} EFI_TCP4_COMPLETION_TOKEN; + +typedef struct { + EFI_TCP4_COMPLETION_TOKEN CompletionToken; +} EFI_TCP4_CONNECTION_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_CONNECT) ( + IN struct _EFI_TCP4 *This, + IN EFI_TCP4_CONNECTION_TOKEN *ConnectionToken + ); + +typedef struct { + EFI_TCP4_COMPLETION_TOKEN CompletionToken; + EFI_HANDLE NewChildHandle; +} EFI_TCP4_LISTEN_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_ACCEPT) ( + IN struct _EFI_TCP4 *This, + IN EFI_TCP4_LISTEN_TOKEN *ListenToken + ); + +#define EFI_CONNECTION_FIN EFIERR(104) +#define EFI_CONNECTION_RESET EFIERR(105) +#define EFI_CONNECTION_REFUSED EFIERR(106) + +typedef struct { + UINT32 FragmentLength; + VOID *FragmentBuffer; +} EFI_TCP4_FRAGMENT_DATA; + +typedef struct { + BOOLEAN UrgentFlag; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_TCP4_FRAGMENT_DATA FragmentTable[1]; +} EFI_TCP4_RECEIVE_DATA; + +typedef struct { + BOOLEAN Push; + BOOLEAN Urgent; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_TCP4_FRAGMENT_DATA FragmentTable[1]; +} EFI_TCP4_TRANSMIT_DATA; + +typedef struct { + EFI_TCP4_COMPLETION_TOKEN CompletionToken; + union { + EFI_TCP4_RECEIVE_DATA *RxData; + EFI_TCP4_TRANSMIT_DATA *TxData; + } Packet; +} EFI_TCP4_IO_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_TRANSMIT) ( + IN struct _EFI_TCP4 *This, + IN EFI_TCP4_IO_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_RECEIVE) ( + IN struct _EFI_TCP4 *This, + IN EFI_TCP4_IO_TOKEN *Token + ); + +typedef struct { + EFI_TCP4_COMPLETION_TOKEN CompletionToken; + BOOLEAN AbortOnClose; +} EFI_TCP4_CLOSE_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_CLOSE)( + IN struct _EFI_TCP4 *This, + IN EFI_TCP4_CLOSE_TOKEN *CloseToken + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_CANCEL)( + IN struct _EFI_TCP4 *This, + IN EFI_TCP4_COMPLETION_TOKEN *Token OPTIONAL +); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP4_POLL) ( + IN struct _EFI_TCP4 *This + ); + +typedef struct _EFI_TCP4 { + EFI_TCP4_GET_MODE_DATA GetModeData; + EFI_TCP4_CONFIGURE Configure; + EFI_TCP4_ROUTES Routes; + EFI_TCP4_CONNECT Connect; + EFI_TCP4_ACCEPT Accept; + EFI_TCP4_TRANSMIT Transmit; + EFI_TCP4_RECEIVE Receive; + EFI_TCP4_CLOSE Close; + EFI_TCP4_CANCEL Cancel; + EFI_TCP4_POLL Poll; +} EFI_TCP4; + +typedef enum { + Tcp6StateClosed = 0, + Tcp6StateListen = 1, + Tcp6StateSynSent = 2, + Tcp6StateSynReceived = 3, + Tcp6StateEstablished = 4, + Tcp6StateFinWait1 = 5, + Tcp6StateFinWait2 = 6, + Tcp6StateClosing = 7, + Tcp6StateTimeWait = 8, + Tcp6StateCloseWait = 9, + Tcp6StateLastAck = 10 +} EFI_TCP6_CONNECTION_STATE; + +typedef struct { + EFI_IPv6_ADDRESS StationAddress; + UINT16 StationPort; + EFI_IPv6_ADDRESS RemoteAddress; + UINT16 RemotePort; + BOOLEAN ActiveFlag; +} EFI_TCP6_ACCESS_POINT; + +typedef struct { + UINT32 ReceiveBufferSize; + UINT32 SendBufferSize; + UINT32 MaxSynBackLog; + UINT32 ConnectionTimeout; + UINT32 DataRetries; + UINT32 FinTimeout; + UINT32 TimeWaitTimeout; + UINT32 KeepAliveProbes; + UINT32 KeepAliveTime; + UINT32 KeepAliveInterval; + BOOLEAN EnableNagle; + BOOLEAN EnableTimeStamp; + BOOLEAN EnableWindbowScaling; + BOOLEAN EnableSelectiveAck; + BOOLEAN EnablePathMtuDiscovery; +} EFI_TCP6_OPTION; + +typedef struct { + UINT8 TrafficClass; + UINT8 HopLimit; + EFI_TCP6_ACCESS_POINT AccessPoint; + EFI_TCP6_OPTION *ControlOption; +} EFI_TCP6_CONFIG_DATA; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_GET_MODE_DATA) ( + IN struct _EFI_TCP6 *This, + OUT EFI_TCP6_CONNECTION_STATE *Tcp6State OPTIONAL, + OUT EFI_TCP6_CONFIG_DATA *Tcp6ConfigData OPTIONAL, + OUT EFI_IP6_MODE_DATA *Ip6ModeData OPTIONAL, + OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL, + OUT EFI_SIMPLE_NETWORK_MODE *SnpModeData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_CONFIGURE) ( + IN struct _EFI_TCP6 *This, + IN EFI_TCP6_CONFIG_DATA *Tcp6ConfigData OPTIONAL + ); + +typedef struct { + EFI_EVENT Event; + EFI_STATUS Status; +} EFI_TCP6_COMPLETION_TOKEN; + +typedef struct { + EFI_TCP6_COMPLETION_TOKEN CompletionToken; +} EFI_TCP6_CONNECTION_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_CONNECT) ( + IN struct _EFI_TCP6 *This, + IN EFI_TCP6_CONNECTION_TOKEN *ConnectionToken + ); + +typedef struct { + EFI_TCP6_COMPLETION_TOKEN CompletionToken; + EFI_HANDLE NewChildHandle; +} EFI_TCP6_LISTEN_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_ACCEPT) ( + IN struct _EFI_TCP6 *This, + IN EFI_TCP6_LISTEN_TOKEN *ListenToken + ); + +typedef struct { + UINT32 FragmentLength; + VOID *FragmentBuffer; +} EFI_TCP6_FRAGMENT_DATA; + +typedef struct { + BOOLEAN UrgentFlag; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_TCP6_FRAGMENT_DATA FragmentTable[1]; +} EFI_TCP6_RECEIVE_DATA; + +typedef struct { + BOOLEAN Push; + BOOLEAN Urgent; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_TCP6_FRAGMENT_DATA FragmentTable[1]; +} EFI_TCP6_TRANSMIT_DATA; + +typedef struct { + EFI_TCP6_COMPLETION_TOKEN CompletionToken; + union { + EFI_TCP6_RECEIVE_DATA *RxData; + EFI_TCP6_TRANSMIT_DATA *TxData; + } Packet; +} EFI_TCP6_IO_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_TRANSMIT) ( + IN struct _EFI_TCP6 *This, + IN EFI_TCP6_IO_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_RECEIVE) ( + IN struct _EFI_TCP6 *This, + IN EFI_TCP6_IO_TOKEN *Token + ); + +typedef struct { + EFI_TCP6_COMPLETION_TOKEN CompletionToken; + BOOLEAN AbortOnClose; +} EFI_TCP6_CLOSE_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_CLOSE)( + IN struct _EFI_TCP6 *This, + IN EFI_TCP6_CLOSE_TOKEN *CloseToken + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_CANCEL)( + IN struct _EFI_TCP6 *This, + IN EFI_TCP6_COMPLETION_TOKEN *Token OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TCP6_POLL) ( + IN struct _EFI_TCP6 *This + ); + +typedef struct _EFI_TCP6 { + EFI_TCP6_GET_MODE_DATA GetModeData; + EFI_TCP6_CONFIGURE Configure; + EFI_TCP6_CONNECT Connect; + EFI_TCP6_ACCEPT Accept; + EFI_TCP6_TRANSMIT Transmit; + EFI_TCP6_RECEIVE Receive; + EFI_TCP6_CLOSE Close; + EFI_TCP6_CANCEL Cancel; + EFI_TCP6_POLL Poll; +} EFI_TCP6; + +#endif /* _EFI_TCP_H */ diff --git a/gnuefi/inc/efiudp.h b/gnuefi/inc/efiudp.h new file mode 100644 index 0000000..7c8b467 --- /dev/null +++ b/gnuefi/inc/efiudp.h @@ -0,0 +1,272 @@ +#ifndef _EFI_UDP_H +#define _EFI_UDP_H + + +/*++ +Copyright (c) 2013 Intel Corporation + +--*/ + +#define EFI_UDP4_SERVICE_BINDING_PROTOCOL \ + { 0x83f01464, 0x99bd, 0x45e5, {0xb3, 0x83, 0xaf, 0x63, 0x05, 0xd8, 0xe9, 0xe6} } + +#define EFI_UDP4_PROTOCOL \ + { 0x3ad9df29, 0x4501, 0x478d, {0xb1, 0xf8, 0x7f, 0x7f, 0xe7, 0x0e, 0x50, 0xf3} } + +#define EFI_UDP6_SERVICE_BINDING_PROTOCOL \ + { 0x66ed4721, 0x3c98, 0x4d3e, {0x81, 0xe3, 0xd0, 0x3d, 0xd3, 0x9a, 0x72, 0x54} } + +#define EFI_UDP6_PROTOCOL \ + { 0x4f948815, 0xb4b9, 0x43cb, {0x8a, 0x33, 0x90, 0xe0, 0x60, 0xb3,0x49, 0x55} } + +INTERFACE_DECL(_EFI_UDP4); +INTERFACE_DECL(_EFI_UDP6); + +typedef struct { + BOOLEAN AcceptBroadcast; + BOOLEAN AcceptPromiscuous; + BOOLEAN AcceptAnyPort; + BOOLEAN AllowDuplicatePort; + UINT8 TypeOfService; + UINT8 TimeToLive; + BOOLEAN DoNotFragment; + UINT32 ReceiveTimeout; + UINT32 TransmitTimeout; + BOOLEAN UseDefaultAddress; + EFI_IPv4_ADDRESS StationAddress; + EFI_IPv4_ADDRESS SubnetMask; + UINT16 StationPort; + EFI_IPv4_ADDRESS RemoteAddress; + UINT16 RemotePort; +} EFI_UDP4_CONFIG_DATA; + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP4_GET_MODE_DATA) ( + IN struct _EFI_UDP4 *This, + OUT EFI_UDP4_CONFIG_DATA *Udp4ConfigData OPTIONAL, + OUT EFI_IP4_MODE_DATA *Ip4ModeData OPTIONAL, + OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL, + OUT EFI_SIMPLE_NETWORK_MODE *SnpModeData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP4_CONFIGURE) ( + IN struct _EFI_UDP4 *This, + IN EFI_UDP4_CONFIG_DATA *UdpConfigData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP4_GROUPS) ( + IN struct _EFI_UDP4 *This, + IN BOOLEAN JoinFlag, + IN EFI_IPv4_ADDRESS *MulticastAddress OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP4_ROUTES) ( + IN struct _EFI_UDP4 *This, + IN BOOLEAN DeleteRoute, + IN EFI_IPv4_ADDRESS *SubnetAddress, + IN EFI_IPv4_ADDRESS *SubnetMask, + IN EFI_IPv4_ADDRESS *GatewayAddress + ); + +#define EFI_NETWORK_UNREACHABLE EFIERR(100) +#define EFI_HOST_UNREACHABLE EFIERR(101) +#define EFI_PROTOCOL_UNREACHABLE EFIERR(102) +#define EFI_PORT_UNREACHABLE EFIERR(103) + +typedef struct { + EFI_IPv4_ADDRESS SourceAddress; + UINT16 SourcePort; + EFI_IPv4_ADDRESS DestinationAddress; + UINT16 DestinationPort; +} EFI_UDP4_SESSION_DATA; + +typedef struct { + UINT32 FragmentLength; + VOID *FragmentBuffer; +} EFI_UDP4_FRAGMENT_DATA; + +typedef struct { + EFI_TIME TimeStamp; + EFI_EVENT RecycleSignal; + EFI_UDP4_SESSION_DATA UdpSession; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_UDP4_FRAGMENT_DATA FragmentTable[1]; +} EFI_UDP4_RECEIVE_DATA; + +typedef struct { + EFI_UDP4_SESSION_DATA *UdpSessionData; + EFI_IPv4_ADDRESS *GatewayAddress; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_UDP4_FRAGMENT_DATA FragmentTable[1]; +} EFI_UDP4_TRANSMIT_DATA; + +typedef struct { + EFI_EVENT Event; + EFI_STATUS Status; + union { + EFI_UDP4_RECEIVE_DATA *RxData; + EFI_UDP4_TRANSMIT_DATA *TxData; + } Packet; +} EFI_UDP4_COMPLETION_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP4_TRANSMIT) ( + IN struct _EFI_UDP4 *This, + IN EFI_UDP4_COMPLETION_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP4_RECEIVE) ( + IN struct _EFI_UDP4 *This, + IN EFI_UDP4_COMPLETION_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP4_CANCEL)( + IN struct _EFI_UDP4 *This, + IN EFI_UDP4_COMPLETION_TOKEN *Token OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP4_POLL) ( + IN struct _EFI_UDP4 *This + ); + +typedef struct _EFI_UDP4 { + EFI_UDP4_GET_MODE_DATA GetModeData; + EFI_UDP4_CONFIGURE Configure; + EFI_UDP4_GROUPS Groups; + EFI_UDP4_ROUTES Routes; + EFI_UDP4_TRANSMIT Transmit; + EFI_UDP4_RECEIVE Receive; + EFI_UDP4_CANCEL Cancel; + EFI_UDP4_POLL Poll; +} EFI_UDP4; + +typedef struct { + BOOLEAN AcceptPromiscuous; + BOOLEAN AcceptAnyPort; + BOOLEAN AllowDuplicatePort; + UINT8 TrafficClass; + UINT8 HopLimit; + UINT32 ReceiveTimeout; + UINT32 TransmitTimeout; + EFI_IPv6_ADDRESS StationAddress; + UINT16 StationPort; + EFI_IPv6_ADDRESS RemoteAddress; + UINT16 RemotePort; +} EFI_UDP6_CONFIG_DATA; + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP6_GET_MODE_DATA) ( + IN struct _EFI_UDP6 *This, + OUT EFI_UDP6_CONFIG_DATA *Udp6ConfigData OPTIONAL, + OUT EFI_IP6_MODE_DATA *Ip6ModeData OPTIONAL, + OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL, + OUT EFI_SIMPLE_NETWORK_MODE *SnpModeData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP6_CONFIGURE) ( + IN struct _EFI_UDP6 *This, + IN EFI_UDP6_CONFIG_DATA *UdpConfigData OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP6_GROUPS) ( + IN struct _EFI_UDP6 *This, + IN BOOLEAN JoinFlag, + IN EFI_IPv6_ADDRESS *MulticastAddress OPTIONAL + ); + +typedef struct { + EFI_IPv6_ADDRESS SourceAddress; + UINT16 SourcePort; + EFI_IPv6_ADDRESS DestinationAddress; + UINT16 DestinationPort; +} EFI_UDP6_SESSION_DATA; + +typedef struct { + UINT32 FragmentLength; + VOID *FragmentBuffer; +} EFI_UDP6_FRAGMENT_DATA; + +typedef struct { + EFI_TIME TimeStamp; + EFI_EVENT RecycleSignal; + EFI_UDP6_SESSION_DATA UdpSession; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_UDP6_FRAGMENT_DATA FragmentTable[1]; +} EFI_UDP6_RECEIVE_DATA; + +typedef struct { + EFI_UDP6_SESSION_DATA *UdpSessionData; + UINT32 DataLength; + UINT32 FragmentCount; + EFI_UDP6_FRAGMENT_DATA FragmentTable[1]; +} EFI_UDP6_TRANSMIT_DATA; + +typedef struct { + EFI_EVENT Event; + EFI_STATUS Status; + union { + EFI_UDP6_RECEIVE_DATA *RxData; + EFI_UDP6_TRANSMIT_DATA *TxData; + } Packet; +} EFI_UDP6_COMPLETION_TOKEN; + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP6_TRANSMIT) ( + IN struct _EFI_UDP6 *This, + IN EFI_UDP6_COMPLETION_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP6_RECEIVE) ( + IN struct _EFI_UDP6 *This, + IN EFI_UDP6_COMPLETION_TOKEN *Token + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP6_CANCEL)( + IN struct _EFI_UDP6 *This, + IN EFI_UDP6_COMPLETION_TOKEN *Token OPTIONAL + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UDP6_POLL) ( + IN struct _EFI_UDP6 *This + ); + +typedef struct _EFI_UDP6 { + EFI_UDP6_GET_MODE_DATA GetModeData; + EFI_UDP6_CONFIGURE Configure; + EFI_UDP6_GROUPS Groups; + EFI_UDP6_TRANSMIT Transmit; + EFI_UDP6_RECEIVE Receive; + EFI_UDP6_CANCEL Cancel; + EFI_UDP6_POLL Poll; +} EFI_UDP6; + +#endif /* _EFI_UDP_H */ diff --git a/gnuefi/inc/efiui.h b/gnuefi/inc/efiui.h new file mode 100644 index 0000000..3756936 --- /dev/null +++ b/gnuefi/inc/efiui.h @@ -0,0 +1,58 @@ +#ifndef _EFI_UI_H +#define _EFI_UI_H + +/*++ + +Copyright (c) 200 Intel Corporation + +Module Name: + + EfiUi.h + +Abstract: + Protocol used to build User Interface (UI) stuff. + + This protocol is just data. It is a multi dimentional array. + For each string there is an array of UI_STRING_ENTRY. Each string + is for a different language translation of the same string. The list + is terminated by a NULL UiString. There can be any number of + UI_STRING_ENTRY arrays. A NULL array terminates the list. A NULL array + entry contains all zeros. + + Thus the shortest possible EFI_UI_PROTOCOL has three UI_STRING_ENTRY. + The String, it's NULL terminator, and the NULL terminator for the entire + thing. + + +Revision History + +--*/ + +#define EFI_UI_INTERFACE_PROTOCOL_GUID \ + { 0x32dd7981, 0x2d27, 0x11d4, {0xbc, 0x8b, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} } +#define EFI_UI_PROTOCOL EFI_UI_INTERFACE_PROTOCOL_GUID + + +typedef enum { + UiDeviceString, + UiVendorString, + UiMaxString +} UI_STRING_TYPE; + +typedef struct { + ISO_639_2 *LangCode; + CHAR16 *UiString; +} UI_STRING_ENTRY; + +#define EFI_UI_INTERFACE_PROTOCOL_VERSION 0x00010000 +#define EFI_UI_VERSION EFI_UI_INTERFACE_PROTOCOL_VERSION + +typedef struct _EFI_UI_INTERFACE_PROTOCOL { + UINT32 Version; + UI_STRING_ENTRY *Entry; +} EFI_UI_INTERFACE_PROTOCOL; + +typedef struct _EFI_UI_INTERFACE_PROTOCOL _UI_INTERFACE; +typedef EFI_UI_INTERFACE_PROTOCOL UI_INTERFACE; + +#endif diff --git a/gnuefi/inc/ia32/efibind.h b/gnuefi/inc/ia32/efibind.h new file mode 100644 index 0000000..718e8d1 --- /dev/null +++ b/gnuefi/inc/ia32/efibind.h @@ -0,0 +1,294 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efefind.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ + +#ifndef __GNUC__ +#pragma pack() +#endif + +// +// Basic int types of various widths +// + +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L ) && !defined(__cplusplus) + + // No ANSI C 1999/2000 stdint.h integer width declarations + + #if defined(_MSC_EXTENSIONS) + + // Use Microsoft C compiler integer width declarations + + typedef unsigned __int64 uint64_t; + typedef __int64 int64_t; + typedef unsigned __int32 uint32_t; + typedef __int32 int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef char int8_t; + #elif defined(__GNUC__) + typedef int __attribute__((__mode__(__DI__))) int64_t; + typedef unsigned int __attribute__((__mode__(__DI__))) uint64_t; + typedef unsigned int uint32_t; + typedef int int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef signed char int8_t; + #elif defined(UNIX_LP64) + + /* Use LP64 programming model from C_FLAGS for integer width declarations */ + + typedef unsigned long uint64_t; + typedef long int64_t; + typedef unsigned int uint32_t; + typedef int int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef char int8_t; + #else + + /* Assume P64 programming model from C_FLAGS for integer width declarations */ + + typedef unsigned long long uint64_t __attribute__((aligned (8))); + typedef long long int64_t __attribute__((aligned (8))); + typedef unsigned int uint32_t; + typedef int int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef char int8_t; + #endif + typedef uint32_t uintptr_t; + typedef int32_t intptr_t; +#elif defined(__GNUC__) + #include +#endif + +// +// Basic EFI types of various widths +// + +#include + +typedef wchar_t CHAR16; +#define WCHAR CHAR16 + + +typedef uint64_t UINT64; +typedef int64_t INT64; + +#ifndef _BASETSD_H_ + typedef uint32_t UINT32; + typedef int32_t INT32; +#endif + +typedef uint16_t UINT16; +typedef int16_t INT16; + +typedef uint8_t UINT8; +typedef char CHAR8; +typedef int8_t INT8; + +#undef VOID +typedef void VOID; + + +typedef int32_t INTN; +typedef uint32_t UINTN; + +#ifdef EFI_NT_EMULATOR + #define POST_CODE(_Data) +#else + #ifdef EFI_DEBUG +#define POST_CODE(_Data) __asm mov eax,(_Data) __asm out 0x80,al + #else + #define POST_CODE(_Data) + #endif +#endif + +#define EFIERR(a) (0x80000000 | a) +#define EFI_ERROR_MASK 0x80000000 +#define EFIERR_OEM(a) (0xc0000000 | a) + + +#define BAD_POINTER 0xFBFBFBFB +#define MAX_ADDRESS 0xFFFFFFFF + +#ifdef EFI_NT_EMULATOR + #define BREAKPOINT() __asm { int 3 } +#else + #define BREAKPOINT() while (TRUE); // Make it hang on Bios[Dbg]32 +#endif + +// +// Pointers must be aligned to these address to function +// + +#define MIN_ALIGNMENT_SIZE 4 + +#define ALIGN_VARIABLE(Value ,Adjustment) \ + (UINTN)Adjustment = 0; \ + if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ + (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ + Value = (UINTN)Value + (UINTN)Adjustment + + +// +// Define macros to build data structure signatures from characters. +// + +#define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) +#define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) +#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) +// +// To export & import functions in the EFI emulator environment +// + +#ifdef EFI_NT_EMULATOR + #define EXPORTAPI __declspec( dllexport ) +#else + #define EXPORTAPI +#endif + + +// +// EFIAPI - prototype calling convention for EFI function pointers +// BOOTSERVICE - prototype for implementation of a boot service interface +// RUNTIMESERVICE - prototype for implementation of a runtime service interface +// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service +// RUNTIME_CODE - pragma macro for declaring runtime code +// + +#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options + #ifdef _MSC_EXTENSIONS + #define EFIAPI __cdecl // Force C calling convention for Microsoft C compiler + #else + #define EFIAPI // Substitute expresion to force C calling convention + #endif +#endif + +#define BOOTSERVICE +//#define RUNTIMESERVICE(proto,a) alloc_text("rtcode",a); proto a +//#define RUNTIMEFUNCTION(proto,a) alloc_text("rtcode",a); proto a +#define RUNTIMESERVICE +#define RUNTIMEFUNCTION + + +#define RUNTIME_CODE(a) alloc_text("rtcode", a) +#define BEGIN_RUNTIME_DATA() data_seg("rtdata") +#define END_RUNTIME_DATA() data_seg("") + +#define VOLATILE volatile + +#define MEMORY_FENCE() + +#ifdef EFI_NT_EMULATOR + +// +// To help ensure proper coding of integrated drivers, they are +// compiled as DLLs. In NT they require a dll init entry pointer. +// The macro puts a stub entry point into the DLL so it will load. +// + +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + __stdcall \ + _DllMainCRTStartup ( \ + UINTN Inst, \ + UINTN reason_for_call, \ + VOID *rserved \ + ) \ + { \ + return 1; \ + } \ + \ + int \ + EXPORTAPI \ + __cdecl \ + InitializeDriver ( \ + void *ImageHandle, \ + void *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, SystemTable); \ + } + + + #define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, NULL) + +#else // EFI_NT_EMULATOR + +// +// When build similiar to FW, then link everything together as +// one big module. For the MSVC toolchain, we simply tell the +// linker what our driver init function is using /ENTRY. +// +#if defined(_MSC_EXTENSIONS) + #define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + __pragma(comment(linker, "/ENTRY:" # InitFunction)) +#else + #define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + InitializeDriver ( \ + VOID *ImageHandle, \ + VOID *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, \ + SystemTable); \ + } \ + \ + EFI_STATUS efi_main( \ + EFI_HANDLE image, \ + EFI_SYSTEM_TABLE *systab \ + ) __attribute__((weak, \ + alias ("InitializeDriver"))); +#endif + + #define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, entry) + +#endif // EFI_FW_NT + +// +// Some compilers don't support the forward reference construct: +// typedef struct XXXXX +// +// The following macro provide a workaround for such cases. +// +#ifdef NO_INTERFACE_DECL +#define INTERFACE_DECL(x) +#else +#if defined(__GNUC__) || defined(_MSC_EXTENSIONS) +#define INTERFACE_DECL(x) struct x +#else +#define INTERFACE_DECL(x) typedef struct x +#endif +#endif + +/* No efi call wrapper for IA32 architecture */ +#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__) +#define EFI_FUNCTION + +#ifdef _MSC_EXTENSIONS +#pragma warning ( disable : 4731 ) // Suppress warnings about modification of EBP +#endif + diff --git a/gnuefi/inc/ia32/efilibplat.h b/gnuefi/inc/ia32/efilibplat.h new file mode 100644 index 0000000..3844578 --- /dev/null +++ b/gnuefi/inc/ia32/efilibplat.h @@ -0,0 +1,26 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efilibplat.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ + +VOID +InitializeLibPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + + diff --git a/gnuefi/inc/ia32/efisetjmp_arch.h b/gnuefi/inc/ia32/efisetjmp_arch.h new file mode 100644 index 0000000..f65432e --- /dev/null +++ b/gnuefi/inc/ia32/efisetjmp_arch.h @@ -0,0 +1,15 @@ +#ifndef GNU_EFI_IA32_SETJMP_H +#define GNU_EFI_IA32_SETJMP_H + +#define JMPBUF_ALIGN 4 + +typedef struct { + UINT32 Ebx; + UINT32 Esi; + UINT32 Edi; + UINT32 Ebp; + UINT32 Esp; + UINT32 Eip; +} EFI_ALIGN(JMPBUF_ALIGN) jmp_buf[1]; + +#endif /* GNU_EFI_IA32_SETJMP_H */ diff --git a/gnuefi/inc/ia32/pe.h b/gnuefi/inc/ia32/pe.h new file mode 100644 index 0000000..979b936 --- /dev/null +++ b/gnuefi/inc/ia32/pe.h @@ -0,0 +1,595 @@ +/* + PE32+ header file + */ +#ifndef _PE_H +#define _PE_H + +#define IMAGE_DOS_SIGNATURE 0x5A4D // MZ +#define IMAGE_OS2_SIGNATURE 0x454E // NE +#define IMAGE_OS2_SIGNATURE_LE 0x454C // LE +#define IMAGE_NT_SIGNATURE 0x00004550 // PE00 +#define IMAGE_EDOS_SIGNATURE 0x44454550 // PEED + + +typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header + UINT16 e_magic; // Magic number + UINT16 e_cblp; // Bytes on last page of file + UINT16 e_cp; // Pages in file + UINT16 e_crlc; // Relocations + UINT16 e_cparhdr; // Size of header in paragraphs + UINT16 e_minalloc; // Minimum extra paragraphs needed + UINT16 e_maxalloc; // Maximum extra paragraphs needed + UINT16 e_ss; // Initial (relative) SS value + UINT16 e_sp; // Initial SP value + UINT16 e_csum; // Checksum + UINT16 e_ip; // Initial IP value + UINT16 e_cs; // Initial (relative) CS value + UINT16 e_lfarlc; // File address of relocation table + UINT16 e_ovno; // Overlay number + UINT16 e_res[4]; // Reserved words + UINT16 e_oemid; // OEM identifier (for e_oeminfo) + UINT16 e_oeminfo; // OEM information; e_oemid specific + UINT16 e_res2[10]; // Reserved words + UINT32 e_lfanew; // File address of new exe header + } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER; + +typedef struct _IMAGE_OS2_HEADER { // OS/2 .EXE header + UINT16 ne_magic; // Magic number + UINT8 ne_ver; // Version number + UINT8 ne_rev; // Revision number + UINT16 ne_enttab; // Offset of Entry Table + UINT16 ne_cbenttab; // Number of bytes in Entry Table + UINT32 ne_crc; // Checksum of whole file + UINT16 ne_flags; // Flag UINT16 + UINT16 ne_autodata; // Automatic data segment number + UINT16 ne_heap; // Initial heap allocation + UINT16 ne_stack; // Initial stack allocation + UINT32 ne_csip; // Initial CS:IP setting + UINT32 ne_sssp; // Initial SS:SP setting + UINT16 ne_cseg; // Count of file segments + UINT16 ne_cmod; // Entries in Module Reference Table + UINT16 ne_cbnrestab; // Size of non-resident name table + UINT16 ne_segtab; // Offset of Segment Table + UINT16 ne_rsrctab; // Offset of Resource Table + UINT16 ne_restab; // Offset of resident name table + UINT16 ne_modtab; // Offset of Module Reference Table + UINT16 ne_imptab; // Offset of Imported Names Table + UINT32 ne_nrestab; // Offset of Non-resident Names Table + UINT16 ne_cmovent; // Count of movable entries + UINT16 ne_align; // Segment alignment shift count + UINT16 ne_cres; // Count of resource segments + UINT8 ne_exetyp; // Target Operating system + UINT8 ne_flagsothers; // Other .EXE flags + UINT16 ne_pretthunks; // offset to return thunks + UINT16 ne_psegrefbytes; // offset to segment ref. bytes + UINT16 ne_swaparea; // Minimum code swap area size + UINT16 ne_expver; // Expected Windows version number + } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER; + +// +// File header format. +// + +typedef struct _IMAGE_FILE_HEADER { + UINT16 Machine; + UINT16 NumberOfSections; + UINT32 TimeDateStamp; + UINT32 PointerToSymbolTable; + UINT32 NumberOfSymbols; + UINT16 SizeOfOptionalHeader; + UINT16 Characteristics; +} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER; + +#define IMAGE_SIZEOF_FILE_HEADER 20 + +#define IMAGE_FILE_RELOCS_STRIPPED 0x0001 // Relocation info stripped from file. +#define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002 // File is executable (i.e. no unresolved externel references). +#define IMAGE_FILE_LINE_NUMS_STRIPPED 0x0004 // Line nunbers stripped from file. +#define IMAGE_FILE_LOCAL_SYMS_STRIPPED 0x0008 // Local symbols stripped from file. +#define IMAGE_FILE_BYTES_REVERSED_LO 0x0080 // Bytes of machine word are reversed. +#define IMAGE_FILE_32BIT_MACHINE 0x0100 // 32 bit word machine. +#define IMAGE_FILE_DEBUG_STRIPPED 0x0200 // Debugging info stripped from file in .DBG file +#define IMAGE_FILE_SYSTEM 0x1000 // System File. +#define IMAGE_FILE_DLL 0x2000 // File is a DLL. +#define IMAGE_FILE_BYTES_REVERSED_HI 0x8000 // Bytes of machine word are reversed. + +#define IMAGE_FILE_MACHINE_UNKNOWN 0 +#define IMAGE_FILE_MACHINE_I386 0x14c // Intel 386. +#define IMAGE_FILE_MACHINE_R3000 0x162 // MIPS little-endian, 0540 big-endian +#define IMAGE_FILE_MACHINE_R4000 0x166 // MIPS little-endian +#define IMAGE_FILE_MACHINE_ALPHA 0x184 // Alpha_AXP +#define IMAGE_FILE_MACHINE_ARMTHUMB_MIXED 0x1c2 // Arm/Thumb +#define IMAGE_FILE_MACHINE_POWERPC 0x1F0 // IBM PowerPC Little-Endian +#define IMAGE_FILE_MACHINE_IA64 0x200 // IA-64 +#define IMAGE_FILE_MACHINE_TAHOE 0x7cc // Intel EM machine +#define IMAGE_FILE_MACHINE_EBC 0xebc // EFI Byte Code +#define IMAGE_FILE_MACHINE_X64 0x8664 // x86_64 +// +// Directory format. +// + +typedef struct _IMAGE_DATA_DIRECTORY { + UINT32 VirtualAddress; + UINT32 Size; +} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY; + +#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16 + +// +// Optional header format. +// + +typedef struct _IMAGE_OPTIONAL_HEADER { + // + // Standard fields. + // + + UINT16 Magic; + UINT8 MajorLinkerVersion; + UINT8 MinorLinkerVersion; + UINT32 SizeOfCode; + UINT32 SizeOfInitializedData; + UINT32 SizeOfUninitializedData; + UINT32 AddressOfEntryPoint; + UINT32 BaseOfCode; + UINT32 BaseOfData; + + // + // NT additional fields. + // + + UINT32 ImageBase; + UINT32 SectionAlignment; + UINT32 FileAlignment; + UINT16 MajorOperatingSystemVersion; + UINT16 MinorOperatingSystemVersion; + UINT16 MajorImageVersion; + UINT16 MinorImageVersion; + UINT16 MajorSubsystemVersion; + UINT16 MinorSubsystemVersion; + UINT32 Reserved1; + UINT32 SizeOfImage; + UINT32 SizeOfHeaders; + UINT32 CheckSum; + UINT16 Subsystem; + UINT16 DllCharacteristics; + UINT32 SizeOfStackReserve; + UINT32 SizeOfStackCommit; + UINT32 SizeOfHeapReserve; + UINT32 SizeOfHeapCommit; + UINT32 LoaderFlags; + UINT32 NumberOfRvaAndSizes; + IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]; +} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER; + +typedef struct _IMAGE_ROM_OPTIONAL_HEADER { + UINT16 Magic; + UINT8 MajorLinkerVersion; + UINT8 MinorLinkerVersion; + UINT32 SizeOfCode; + UINT32 SizeOfInitializedData; + UINT32 SizeOfUninitializedData; + UINT32 AddressOfEntryPoint; + UINT32 BaseOfCode; + UINT32 BaseOfData; + UINT32 BaseOfBss; + UINT32 GprMask; + UINT32 CprMask[4]; + UINT32 GpValue; +} IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER; + +#define IMAGE_SIZEOF_ROM_OPTIONAL_HEADER 56 +#define IMAGE_SIZEOF_STD_OPTIONAL_HEADER 28 +#define IMAGE_SIZEOF_NT_OPTIONAL_HEADER 224 + +#define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b +#define IMAGE_ROM_OPTIONAL_HDR_MAGIC 0x107 + +typedef struct _IMAGE_NT_HEADERS { + UINT32 Signature; + IMAGE_FILE_HEADER FileHeader; + IMAGE_OPTIONAL_HEADER OptionalHeader; +} IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS; + +typedef struct _IMAGE_ROM_HEADERS { + IMAGE_FILE_HEADER FileHeader; + IMAGE_ROM_OPTIONAL_HEADER OptionalHeader; +} IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS; + +#define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER) \ + ((UINT32)ntheader + \ + FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + \ + ((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader \ + )) + + +// Subsystem Values + +#define IMAGE_SUBSYSTEM_UNKNOWN 0 // Unknown subsystem. +#define IMAGE_SUBSYSTEM_NATIVE 1 // Image doesn't require a subsystem. +#define IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem. +#define IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem. +#define IMAGE_SUBSYSTEM_OS2_CUI 5 // image runs in the OS/2 character subsystem. +#define IMAGE_SUBSYSTEM_POSIX_CUI 7 // image run in the Posix character subsystem. + + +// Directory Entries + +#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // Export Directory +#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // Import Directory +#define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 // Resource Directory +#define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 // Exception Directory +#define IMAGE_DIRECTORY_ENTRY_SECURITY 4 // Security Directory +#define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 // Base Relocation Table +#define IMAGE_DIRECTORY_ENTRY_DEBUG 6 // Debug Directory +#define IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 // Description String +#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 // Machine Value (MIPS GP) +#define IMAGE_DIRECTORY_ENTRY_TLS 9 // TLS Directory +#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 // Load Configuration Directory + +// +// Section header format. +// + +#define IMAGE_SIZEOF_SHORT_NAME 8 + +typedef struct _IMAGE_SECTION_HEADER { + UINT8 Name[IMAGE_SIZEOF_SHORT_NAME]; + union { + UINT32 PhysicalAddress; + UINT32 VirtualSize; + } Misc; + UINT32 VirtualAddress; + UINT32 SizeOfRawData; + UINT32 PointerToRawData; + UINT32 PointerToRelocations; + UINT32 PointerToLinenumbers; + UINT16 NumberOfRelocations; + UINT16 NumberOfLinenumbers; + UINT32 Characteristics; +} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER; + +#define IMAGE_SIZEOF_SECTION_HEADER 40 + +#define IMAGE_SCN_TYPE_NO_PAD 0x00000008 // Reserved. + +#define IMAGE_SCN_CNT_CODE 0x00000020 // Section contains code. +#define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040 // Section contains initialized data. +#define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x00000080 // Section contains uninitialized data. + +#define IMAGE_SCN_LNK_OTHER 0x00000100 // Reserved. +#define IMAGE_SCN_LNK_INFO 0x00000200 // Section contains comments or some other type of information. +#define IMAGE_SCN_LNK_REMOVE 0x00000800 // Section contents will not become part of image. +#define IMAGE_SCN_LNK_COMDAT 0x00001000 // Section contents comdat. + +#define IMAGE_SCN_ALIGN_1BYTES 0x00100000 // +#define IMAGE_SCN_ALIGN_2BYTES 0x00200000 // +#define IMAGE_SCN_ALIGN_4BYTES 0x00300000 // +#define IMAGE_SCN_ALIGN_8BYTES 0x00400000 // +#define IMAGE_SCN_ALIGN_16BYTES 0x00500000 // Default alignment if no others are specified. +#define IMAGE_SCN_ALIGN_32BYTES 0x00600000 // +#define IMAGE_SCN_ALIGN_64BYTES 0x00700000 // + +#define IMAGE_SCN_MEM_DISCARDABLE 0x02000000 // Section can be discarded. +#define IMAGE_SCN_MEM_NOT_CACHED 0x04000000 // Section is not cachable. +#define IMAGE_SCN_MEM_NOT_PAGED 0x08000000 // Section is not pageable. +#define IMAGE_SCN_MEM_SHARED 0x10000000 // Section is shareable. +#define IMAGE_SCN_MEM_EXECUTE 0x20000000 // Section is executable. +#define IMAGE_SCN_MEM_READ 0x40000000 // Section is readable. +#define IMAGE_SCN_MEM_WRITE 0x80000000 // Section is writeable. + +// +// Symbol format. +// + + +#define IMAGE_SIZEOF_SYMBOL 18 + +// +// Section values. +// +// Symbols have a section number of the section in which they are +// defined. Otherwise, section numbers have the following meanings: +// + +#define IMAGE_SYM_UNDEFINED (UINT16)0 // Symbol is undefined or is common. +#define IMAGE_SYM_ABSOLUTE (UINT16)-1 // Symbol is an absolute value. +#define IMAGE_SYM_DEBUG (UINT16)-2 // Symbol is a special debug item. + +// +// Type (fundamental) values. +// + +#define IMAGE_SYM_TYPE_NULL 0 // no type. +#define IMAGE_SYM_TYPE_VOID 1 // +#define IMAGE_SYM_TYPE_CHAR 2 // type character. +#define IMAGE_SYM_TYPE_SHORT 3 // type short integer. +#define IMAGE_SYM_TYPE_INT 4 // +#define IMAGE_SYM_TYPE_LONG 5 // +#define IMAGE_SYM_TYPE_FLOAT 6 // +#define IMAGE_SYM_TYPE_DOUBLE 7 // +#define IMAGE_SYM_TYPE_STRUCT 8 // +#define IMAGE_SYM_TYPE_UNION 9 // +#define IMAGE_SYM_TYPE_ENUM 10 // enumeration. +#define IMAGE_SYM_TYPE_MOE 11 // member of enumeration. +#define IMAGE_SYM_TYPE_BYTE 12 // +#define IMAGE_SYM_TYPE_WORD 13 // +#define IMAGE_SYM_TYPE_UINT 14 // +#define IMAGE_SYM_TYPE_DWORD 15 // + +// +// Type (derived) values. +// + +#define IMAGE_SYM_DTYPE_NULL 0 // no derived type. +#define IMAGE_SYM_DTYPE_POINTER 1 // pointer. +#define IMAGE_SYM_DTYPE_FUNCTION 2 // function. +#define IMAGE_SYM_DTYPE_ARRAY 3 // array. + +// +// Storage classes. +// + +#define IMAGE_SYM_CLASS_END_OF_FUNCTION (BYTE )-1 +#define IMAGE_SYM_CLASS_NULL 0 +#define IMAGE_SYM_CLASS_AUTOMATIC 1 +#define IMAGE_SYM_CLASS_EXTERNAL 2 +#define IMAGE_SYM_CLASS_STATIC 3 +#define IMAGE_SYM_CLASS_REGISTER 4 +#define IMAGE_SYM_CLASS_EXTERNAL_DEF 5 +#define IMAGE_SYM_CLASS_LABEL 6 +#define IMAGE_SYM_CLASS_UNDEFINED_LABEL 7 +#define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT 8 +#define IMAGE_SYM_CLASS_ARGUMENT 9 +#define IMAGE_SYM_CLASS_STRUCT_TAG 10 +#define IMAGE_SYM_CLASS_MEMBER_OF_UNION 11 +#define IMAGE_SYM_CLASS_UNION_TAG 12 +#define IMAGE_SYM_CLASS_TYPE_DEFINITION 13 +#define IMAGE_SYM_CLASS_UNDEFINED_STATIC 14 +#define IMAGE_SYM_CLASS_ENUM_TAG 15 +#define IMAGE_SYM_CLASS_MEMBER_OF_ENUM 16 +#define IMAGE_SYM_CLASS_REGISTER_PARAM 17 +#define IMAGE_SYM_CLASS_BIT_FIELD 18 +#define IMAGE_SYM_CLASS_BLOCK 100 +#define IMAGE_SYM_CLASS_FUNCTION 101 +#define IMAGE_SYM_CLASS_END_OF_STRUCT 102 +#define IMAGE_SYM_CLASS_FILE 103 +// new +#define IMAGE_SYM_CLASS_SECTION 104 +#define IMAGE_SYM_CLASS_WEAK_EXTERNAL 105 + +// type packing constants + +#define N_BTMASK 017 +#define N_TMASK 060 +#define N_TMASK1 0300 +#define N_TMASK2 0360 +#define N_BTSHFT 4 +#define N_TSHIFT 2 + +// MACROS + +// +// Communal selection types. +// + +#define IMAGE_COMDAT_SELECT_NODUPLICATES 1 +#define IMAGE_COMDAT_SELECT_ANY 2 +#define IMAGE_COMDAT_SELECT_SAME_SIZE 3 +#define IMAGE_COMDAT_SELECT_EXACT_MATCH 4 +#define IMAGE_COMDAT_SELECT_ASSOCIATIVE 5 + +#define IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY 1 +#define IMAGE_WEAK_EXTERN_SEARCH_LIBRARY 2 +#define IMAGE_WEAK_EXTERN_SEARCH_ALIAS 3 + + +// +// Relocation format. +// + +typedef struct _IMAGE_RELOCATION { + UINT32 VirtualAddress; + UINT32 SymbolTableIndex; + UINT16 Type; +} IMAGE_RELOCATION; + +#define IMAGE_SIZEOF_RELOCATION 10 + +// +// I386 relocation types. +// + +#define IMAGE_REL_I386_ABSOLUTE 0 // Reference is absolute, no relocation is necessary +#define IMAGE_REL_I386_DIR16 01 // Direct 16-bit reference to the symbols virtual address +#define IMAGE_REL_I386_REL16 02 // PC-relative 16-bit reference to the symbols virtual address +#define IMAGE_REL_I386_DIR32 06 // Direct 32-bit reference to the symbols virtual address +#define IMAGE_REL_I386_DIR32NB 07 // Direct 32-bit reference to the symbols virtual address, base not included +#define IMAGE_REL_I386_SEG12 011 // Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address +#define IMAGE_REL_I386_SECTION 012 +#define IMAGE_REL_I386_SECREL 013 +#define IMAGE_REL_I386_REL32 024 // PC-relative 32-bit reference to the symbols virtual address + +// +// MIPS relocation types. +// + +#define IMAGE_REL_MIPS_ABSOLUTE 0 // Reference is absolute, no relocation is necessary +#define IMAGE_REL_MIPS_REFHALF 01 +#define IMAGE_REL_MIPS_REFWORD 02 +#define IMAGE_REL_MIPS_JMPADDR 03 +#define IMAGE_REL_MIPS_REFHI 04 +#define IMAGE_REL_MIPS_REFLO 05 +#define IMAGE_REL_MIPS_GPREL 06 +#define IMAGE_REL_MIPS_LITERAL 07 +#define IMAGE_REL_MIPS_SECTION 012 +#define IMAGE_REL_MIPS_SECREL 013 +#define IMAGE_REL_MIPS_REFWORDNB 042 +#define IMAGE_REL_MIPS_PAIR 045 + +// +// Alpha Relocation types. +// + +#define IMAGE_REL_ALPHA_ABSOLUTE 0x0 +#define IMAGE_REL_ALPHA_REFLONG 0x1 +#define IMAGE_REL_ALPHA_REFQUAD 0x2 +#define IMAGE_REL_ALPHA_GPREL32 0x3 +#define IMAGE_REL_ALPHA_LITERAL 0x4 +#define IMAGE_REL_ALPHA_LITUSE 0x5 +#define IMAGE_REL_ALPHA_GPDISP 0x6 +#define IMAGE_REL_ALPHA_BRADDR 0x7 +#define IMAGE_REL_ALPHA_HINT 0x8 +#define IMAGE_REL_ALPHA_INLINE_REFLONG 0x9 +#define IMAGE_REL_ALPHA_REFHI 0xA +#define IMAGE_REL_ALPHA_REFLO 0xB +#define IMAGE_REL_ALPHA_PAIR 0xC +#define IMAGE_REL_ALPHA_MATCH 0xD +#define IMAGE_REL_ALPHA_SECTION 0xE +#define IMAGE_REL_ALPHA_SECREL 0xF +#define IMAGE_REL_ALPHA_REFLONGNB 0x10 + +// +// IBM PowerPC relocation types. +// + +#define IMAGE_REL_PPC_ABSOLUTE 0x0000 // NOP +#define IMAGE_REL_PPC_ADDR64 0x0001 // 64-bit address +#define IMAGE_REL_PPC_ADDR32 0x0002 // 32-bit address +#define IMAGE_REL_PPC_ADDR24 0x0003 // 26-bit address, shifted left 2 (branch absolute) +#define IMAGE_REL_PPC_ADDR16 0x0004 // 16-bit address +#define IMAGE_REL_PPC_ADDR14 0x0005 // 16-bit address, shifted left 2 (load doubleword) +#define IMAGE_REL_PPC_REL24 0x0006 // 26-bit PC-relative offset, shifted left 2 (branch relative) +#define IMAGE_REL_PPC_REL14 0x0007 // 16-bit PC-relative offset, shifted left 2 (br cond relative) +#define IMAGE_REL_PPC_TOCREL16 0x0008 // 16-bit offset from TOC base +#define IMAGE_REL_PPC_TOCREL14 0x0009 // 16-bit offset from TOC base, shifted left 2 (load doubleword) + +#define IMAGE_REL_PPC_ADDR32NB 0x000A // 32-bit addr w/o image base +#define IMAGE_REL_PPC_SECREL 0x000B // va of containing section (as in an image sectionhdr) +#define IMAGE_REL_PPC_SECTION 0x000C // sectionheader number +#define IMAGE_REL_PPC_IFGLUE 0x000D // substitute TOC restore instruction iff symbol is glue code +#define IMAGE_REL_PPC_IMGLUE 0x000E // symbol is glue code; virtual address is TOC restore instruction + +#define IMAGE_REL_PPC_TYPEMASK 0x00FF // mask to isolate above values in IMAGE_RELOCATION.Type + +// Flag bits in IMAGE_RELOCATION.TYPE + +#define IMAGE_REL_PPC_NEG 0x0100 // subtract reloc value rather than adding it +#define IMAGE_REL_PPC_BRTAKEN 0x0200 // fix branch prediction bit to predict branch taken +#define IMAGE_REL_PPC_BRNTAKEN 0x0400 // fix branch prediction bit to predict branch not taken +#define IMAGE_REL_PPC_TOCDEFN 0x0800 // toc slot defined in file (or, data in toc) + +// +// Based relocation format. +// + +typedef struct _IMAGE_BASE_RELOCATION { + UINT32 VirtualAddress; + UINT32 SizeOfBlock; +// UINT16 TypeOffset[1]; +} IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION; + +#define IMAGE_SIZEOF_BASE_RELOCATION 8 + +// +// Based relocation types. +// + +#define IMAGE_REL_BASED_ABSOLUTE 0 +#define IMAGE_REL_BASED_HIGH 1 +#define IMAGE_REL_BASED_LOW 2 +#define IMAGE_REL_BASED_HIGHLOW 3 +#define IMAGE_REL_BASED_HIGHADJ 4 +#define IMAGE_REL_BASED_MIPS_JMPADDR 5 +#define IMAGE_REL_BASED_IA64_IMM64 9 +#define IMAGE_REL_BASED_DIR64 10 + +// +// Line number format. +// + +typedef struct _IMAGE_LINENUMBER { + union { + UINT32 SymbolTableIndex; // Symbol table index of function name if Linenumber is 0. + UINT32 VirtualAddress; // Virtual address of line number. + } Type; + UINT16 Linenumber; // Line number. +} IMAGE_LINENUMBER; + +#define IMAGE_SIZEOF_LINENUMBER 6 + +// +// Archive format. +// + +#define IMAGE_ARCHIVE_START_SIZE 8 +#define IMAGE_ARCHIVE_START "!\n" +#define IMAGE_ARCHIVE_END "`\n" +#define IMAGE_ARCHIVE_PAD "\n" +#define IMAGE_ARCHIVE_LINKER_MEMBER "/ " +#define IMAGE_ARCHIVE_LONGNAMES_MEMBER "// " + +typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER { + UINT8 Name[16]; // File member name - `/' terminated. + UINT8 Date[12]; // File member date - decimal. + UINT8 UserID[6]; // File member user id - decimal. + UINT8 GroupID[6]; // File member group id - decimal. + UINT8 Mode[8]; // File member mode - octal. + UINT8 Size[10]; // File member size - decimal. + UINT8 EndHeader[2]; // String to end header. +} IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER; + +#define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR 60 + +// +// DLL support. +// + +// +// Export Format +// + +typedef struct _IMAGE_EXPORT_DIRECTORY { + UINT32 Characteristics; + UINT32 TimeDateStamp; + UINT16 MajorVersion; + UINT16 MinorVersion; + UINT32 Name; + UINT32 Base; + UINT32 NumberOfFunctions; + UINT32 NumberOfNames; + UINT32 *AddressOfFunctions; + UINT32 *AddressOfNames; + UINT32 *AddressOfNameOrdinals; +} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY; + +// +// Import Format +// + +typedef struct _IMAGE_IMPORT_BY_NAME { + UINT16 Hint; + UINT8 Name[1]; +} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME; + +typedef struct _IMAGE_THUNK_DATA { + union { + UINT32 Function; + UINT32 Ordinal; + PIMAGE_IMPORT_BY_NAME AddressOfData; + } u1; +} IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA; + +#define IMAGE_ORDINAL_FLAG 0x80000000 +#define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0) +#define IMAGE_ORDINAL(Ordinal) (Ordinal & 0xffff) + +typedef struct _IMAGE_IMPORT_DESCRIPTOR { + UINT32 Characteristics; + UINT32 TimeDateStamp; + UINT32 ForwarderChain; + UINT32 Name; + PIMAGE_THUNK_DATA FirstThunk; +} IMAGE_IMPORT_DESCRIPTOR, *PIMAGE_IMPORT_DESCRIPTOR; + +#endif diff --git a/gnuefi/inc/ia64/efibind.h b/gnuefi/inc/ia64/efibind.h new file mode 100644 index 0000000..1d2745b --- /dev/null +++ b/gnuefi/inc/ia64/efibind.h @@ -0,0 +1,236 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efefind.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ + +#pragma pack() + + +// +// Basic int types of various widths +// + +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L ) && !defined(__cplusplus) + + // No ANSI C 1999/2000 stdint.h integer width declarations + + #ifdef _MSC_EXTENSIONS + // Use Microsoft C compiler integer width declarations + + typedef unsigned __int64 uint64_t; + typedef __int64 int64_t; + typedef unsigned __int32 uint32_t; + typedef __int32 int32_t; + typedef unsigned __int16 uint16_t; + typedef __int16 int16_t; + typedef unsigned __int8 uint8_t; + typedef __int8 int8_t; + #elif defined(UNIX_LP64) + // Use LP64 programming model from C_FLAGS for integer width declarations + + typedef unsigned long uint64_t; + typedef long int64_t; + typedef unsigned int uint32_t; + typedef int int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef char int8_t; + #else + // Assume P64 programming model from C_FLAGS for integer width declarations + + typedef unsigned long long uint64_t; + typedef long long int64_t; + typedef unsigned int uint32_t; + typedef int int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef char int8_t; + #endif + typedef uint64_t uintptr_t; + typedef int64_t intptr_t; +#elif defined(__GNUC__) + #include +#endif + +// +// Basic EFI types of various widths +// + +#include + +typedef wchar_t CHAR16; +#define WCHAR CHAR16 + +typedef uint64_t UINT64; +typedef int64_t INT64; + +typedef uint32_t UINT32; +typedef int32_t INT32; + +typedef uint16_t UINT16; +typedef int16_t INT16; + +typedef uint8_t UINT8; +typedef char CHAR8; +typedef int8_t INT8; + +#undef VOID +typedef void VOID; + + +typedef int64_t INTN; +typedef uint64_t UINTN; + +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BugBug: Code to debug +// +#define BIT63 0x8000000000000000 + +#define PLATFORM_IOBASE_ADDRESS (0xffffc000000 | BIT63) +#define PORT_TO_MEMD(_Port) (PLATFORM_IOBASE_ADDRESS | ( ( ( (_Port) & 0xfffc) << 10 ) | ( (_Port) & 0x0fff) ) ) + +// +// Macro's with casts make this much easier to use and read. +// +#define PORT_TO_MEM8D(_Port) (*(UINT8 *)(PORT_TO_MEMD(_Port))) +#define POST_CODE(_Data) (PORT_TO_MEM8D(0x80) = (_Data)) +// +// BugBug: End Debug Code!!! +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +#define EFIERR(a) (0x8000000000000000 | a) +#define EFI_ERROR_MASK 0x8000000000000000 +#define EFIERR_OEM(a) (0xc000000000000000 | a) + +#define BAD_POINTER 0xFBFBFBFBFBFBFBFB +#define MAX_ADDRESS 0xFFFFFFFFFFFFFFFF + +#define BREAKPOINT() while (TRUE) + +// +// Pointers must be aligned to these address to function +// you will get an alignment fault if this value is less than 8 +// +#define MIN_ALIGNMENT_SIZE 8 + +#define ALIGN_VARIABLE(Value , Adjustment) \ + (UINTN) Adjustment = 0; \ + if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ + (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ + Value = (UINTN)Value + (UINTN)Adjustment + +// +// Define macros to create data structure signatures. +// + +#define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) +#define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) +#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) +// +// To export & import functions in the EFI emulator environment +// + + #define EXPORTAPI + +// +// EFIAPI - prototype calling convention for EFI function pointers +// BOOTSERVICE - prototype for implementation of a boot service interface +// RUNTIMESERVICE - prototype for implementation of a runtime service interface +// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service +// RUNTIME_CODE - pragma macro for declaring runtime code +// + +#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options + #ifdef _MSC_EXTENSIONS + #define EFIAPI __cdecl // Force C calling convention for Microsoft C compiler + #else + #define EFIAPI // Substitute expresion to force C calling convention + #endif +#endif + +#define BOOTSERVICE +#define RUNTIMESERVICE +#define RUNTIMEFUNCTION + +#define RUNTIME_CODE(a) alloc_text("rtcode", a) +#define BEGIN_RUNTIME_DATA() data_seg("rtdata") +#define END_RUNTIME_DATA() data_seg("") + +#define VOLATILE volatile + +// +// BugBug: Need to find out if this is portable accross compliers. +// +#ifdef __GNUC__ +#define MEMORY_FENCE() __asm__ __volatile__ ("mf.a" ::: "memory") +#else +void __mf (void); +#pragma intrinsic (__mf) +#define MEMORY_FENCE() __mf() +#endif + +// +// When build similiar to FW, then link everything together as +// one big module. For the MSVC toolchain, we simply tell the +// linker what our driver init function is using /ENTRY. +// +#if defined(_MSC_EXTENSIONS) + #define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + __pragma(comment(linker, "/ENTRY:" # InitFunction)) +#else + #define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + InitializeDriver ( \ + VOID *ImageHandle, \ + VOID *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, \ + SystemTable); \ + } \ + \ + EFI_STATUS efi_main( \ + EFI_HANDLE image, \ + EFI_SYSTEM_TABLE *systab \ + ) __attribute__((weak, \ + alias ("InitializeDriver"))); +#endif + +#define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, entry) + +// +// Some compilers don't support the forward reference construct: +// typedef struct XXXXX +// +// The following macro provide a workaround for such cases. +// +#ifdef NO_INTERFACE_DECL +#define INTERFACE_DECL(x) +#else +#if defined(__GNUC__) || defined(_MSC_EXTENSIONS) +#define INTERFACE_DECL(x) struct x +#else +#define INTERFACE_DECL(x) typedef struct x +#endif +#endif + +/* No efi call wrapper for IA32 architecture */ +#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__) +#define EFI_FUNCTION diff --git a/gnuefi/inc/ia64/efilibplat.h b/gnuefi/inc/ia64/efilibplat.h new file mode 100644 index 0000000..f07be3f --- /dev/null +++ b/gnuefi/inc/ia64/efilibplat.h @@ -0,0 +1,80 @@ +#ifndef _EFI_LIB_PLAT_H +#define _EFI_LIB_PLAT_H +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efilibplat.h + +Abstract: + + EFI to compile bindings + + + +Revision History + +--*/ + +#include "salproc.h" + + +VOID +InitializeLibPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + +VOID +LibInitSalAndPalProc( + OUT PLABEL *SalPlabel, + OUT UINT64 *PalEntry + ); + +EFI_STATUS +LibGetSalIoPortMapping ( + OUT UINT64 *IoPortMapping + ); + +EFI_STATUS +LibGetSalIpiBlock ( + OUT UINT64 *IpiBlock + ); + +EFI_STATUS +LibGetSalWakeupVector ( + OUT UINT64 *WakeVector + ); + +VOID * +LibSearchSalSystemTable ( + IN UINT8 EntryType + ); + + +VOID +LibSalProc ( + IN UINT64 Arg1, + IN UINT64 Arg2, + IN UINT64 Arg3, + IN UINT64 Arg4, + IN UINT64 Arg5, + IN UINT64 Arg6, + IN UINT64 Arg7, + IN UINT64 Arg8, + OUT rArg *Results OPTIONAL + ); + +VOID +LibPalProc ( + IN UINT64 Arg1, + IN UINT64 Arg2, + IN UINT64 Arg3, + IN UINT64 Arg4, + OUT rArg *Results OPTIONAL + ); + +#endif + diff --git a/gnuefi/inc/ia64/efisetjmp_arch.h b/gnuefi/inc/ia64/efisetjmp_arch.h new file mode 100644 index 0000000..7b674f6 --- /dev/null +++ b/gnuefi/inc/ia64/efisetjmp_arch.h @@ -0,0 +1,47 @@ +#ifndef GNU_EFI_IA64_SETJMP_H +#define GNU_EFI_IA64_SETJMP_H + +#define JMPBUF_ALIGN 0x10 + +typedef struct { + UINT64 F2[2]; + UINT64 F3[2]; + UINT64 F4[2]; + UINT64 F5[2]; + UINT64 F16[2]; + UINT64 F17[2]; + UINT64 F18[2]; + UINT64 F19[2]; + UINT64 F20[2]; + UINT64 F21[2]; + UINT64 F22[2]; + UINT64 F23[2]; + UINT64 F24[2]; + UINT64 F25[2]; + UINT64 F26[2]; + UINT64 F27[2]; + UINT64 F28[2]; + UINT64 F29[2]; + UINT64 F30[2]; + UINT64 F31[2]; + UINT64 R4; + UINT64 R5; + UINT64 R6; + UINT64 R7; + UINT64 SP; + UINT64 BR0; + UINT64 BR1; + UINT64 BR2; + UINT64 BR3; + UINT64 BR4; + UINT64 BR5; + UINT64 InitialUNAT; + UINT64 AfterSpillUNAT; + UINT64 PFS; + UINT64 BSP; + UINT64 Predicates; + UINT64 LoopCount; + UINT64 FPSR; +} EFI_ALIGN(JMPBUF_ALIGN) jmp_buf[1]; + +#endif /* GNU_EFI_IA64_SETJMP_H */ diff --git a/gnuefi/inc/ia64/pe.h b/gnuefi/inc/ia64/pe.h new file mode 100644 index 0000000..b1cade2 --- /dev/null +++ b/gnuefi/inc/ia64/pe.h @@ -0,0 +1,601 @@ +/* + PE32+ header file + */ +#ifndef _PE_H +#define _PE_H + +#define IMAGE_DOS_SIGNATURE 0x5A4D // MZ +#define IMAGE_OS2_SIGNATURE 0x454E // NE +#define IMAGE_OS2_SIGNATURE_LE 0x454C // LE +#define IMAGE_NT_SIGNATURE 0x00004550 // PE00 +#define IMAGE_EDOS_SIGNATURE 0x44454550 // PEED + +/***************************************************************************** + * The following stuff comes from winnt.h from the ia64sdk, plus the Plabel for + * loading EM executables. + *****************************************************************************/ +// +// Intel IA64 specific +// + +#define IMAGE_REL_BASED_IA64_IMM64 9 +#define IMAGE_REL_BASED_IA64_DIR64 10 + +struct Plabel { + UINT64 EntryPoint; + UINT64 NewGP; +}; + +typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header + UINT16 e_magic; // Magic number + UINT16 e_cblp; // Bytes on last page of file + UINT16 e_cp; // Pages in file + UINT16 e_crlc; // Relocations + UINT16 e_cparhdr; // Size of header in paragraphs + UINT16 e_minalloc; // Minimum extra paragraphs needed + UINT16 e_maxalloc; // Maximum extra paragraphs needed + UINT16 e_ss; // Initial (relative) SS value + UINT16 e_sp; // Initial SP value + UINT16 e_csum; // Checksum + UINT16 e_ip; // Initial IP value + UINT16 e_cs; // Initial (relative) CS value + UINT16 e_lfarlc; // File address of relocation table + UINT16 e_ovno; // Overlay number + UINT16 e_res[4]; // Reserved words + UINT16 e_oemid; // OEM identifier (for e_oeminfo) + UINT16 e_oeminfo; // OEM information; e_oemid specific + UINT16 e_res2[10]; // Reserved words + UINT32 e_lfanew; // File address of new exe header + } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER; + +typedef struct _IMAGE_OS2_HEADER { // OS/2 .EXE header + UINT16 ne_magic; // Magic number + UINT8 ne_ver; // Version number + UINT8 ne_rev; // Revision number + UINT16 ne_enttab; // Offset of Entry Table + UINT16 ne_cbenttab; // Number of bytes in Entry Table + UINT32 ne_crc; // Checksum of whole file + UINT16 ne_flags; // Flag UINT16 + UINT16 ne_autodata; // Automatic data segment number + UINT16 ne_heap; // Initial heap allocation + UINT16 ne_stack; // Initial stack allocation + UINT32 ne_csip; // Initial CS:IP setting + UINT32 ne_sssp; // Initial SS:SP setting + UINT16 ne_cseg; // Count of file segments + UINT16 ne_cmod; // Entries in Module Reference Table + UINT16 ne_cbnrestab; // Size of non-resident name table + UINT16 ne_segtab; // Offset of Segment Table + UINT16 ne_rsrctab; // Offset of Resource Table + UINT16 ne_restab; // Offset of resident name table + UINT16 ne_modtab; // Offset of Module Reference Table + UINT16 ne_imptab; // Offset of Imported Names Table + UINT32 ne_nrestab; // Offset of Non-resident Names Table + UINT16 ne_cmovent; // Count of movable entries + UINT16 ne_align; // Segment alignment shift count + UINT16 ne_cres; // Count of resource segments + UINT8 ne_exetyp; // Target Operating system + UINT8 ne_flagsothers; // Other .EXE flags + UINT16 ne_pretthunks; // offset to return thunks + UINT16 ne_psegrefbytes; // offset to segment ref. bytes + UINT16 ne_swaparea; // Minimum code swap area size + UINT16 ne_expver; // Expected Windows version number + } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER; + +// +// File header format. +// + +typedef struct _IMAGE_FILE_HEADER { + UINT16 Machine; + UINT16 NumberOfSections; + UINT32 TimeDateStamp; + UINT32 PointerToSymbolTable; + UINT32 NumberOfSymbols; + UINT16 SizeOfOptionalHeader; + UINT16 Characteristics; +} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER; + +#define IMAGE_SIZEOF_FILE_HEADER 20 + +#define IMAGE_FILE_RELOCS_STRIPPED 0x0001 // Relocation info stripped from file. +#define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002 // File is executable (i.e. no unresolved externel references). +#define IMAGE_FILE_LINE_NUMS_STRIPPED 0x0004 // Line nunbers stripped from file. +#define IMAGE_FILE_LOCAL_SYMS_STRIPPED 0x0008 // Local symbols stripped from file. +#define IMAGE_FILE_BYTES_REVERSED_LO 0x0080 // Bytes of machine word are reversed. +#define IMAGE_FILE_32BIT_MACHINE 0x0100 // 32 bit word machine. +#define IMAGE_FILE_DEBUG_STRIPPED 0x0200 // Debugging info stripped from file in .DBG file +#define IMAGE_FILE_SYSTEM 0x1000 // System File. +#define IMAGE_FILE_DLL 0x2000 // File is a DLL. +#define IMAGE_FILE_BYTES_REVERSED_HI 0x8000 // Bytes of machine word are reversed. + +#define IMAGE_FILE_MACHINE_UNKNOWN 0 +#define IMAGE_FILE_MACHINE_I386 0x14c // Intel 386. +#define IMAGE_FILE_MACHINE_R3000 0x162 // MIPS little-endian, 0540 big-endian +#define IMAGE_FILE_MACHINE_R4000 0x166 // MIPS little-endian +#define IMAGE_FILE_MACHINE_ALPHA 0x184 // Alpha_AXP +#define IMAGE_FILE_MACHINE_ARMTHUMB_MIXED 0x1c2 // Arm/Thumb +#define IMAGE_FILE_MACHINE_POWERPC 0x1F0 // IBM PowerPC Little-Endian +#define IMAGE_FILE_MACHINE_IA64 0x200 // IA-64 +#define IMAGE_FILE_MACHINE_TAHOE 0x7cc // Intel EM machine +#define IMAGE_FILE_MACHINE_EBC 0xebc // EFI Byte Code +#define IMAGE_FILE_MACHINE_X64 0x8664 // x86_64 +// +// Directory format. +// + +typedef struct _IMAGE_DATA_DIRECTORY { + UINT32 VirtualAddress; + UINT32 Size; +} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY; + +#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16 + + +typedef struct _IMAGE_ROM_OPTIONAL_HEADER { + UINT16 Magic; + UINT8 MajorLinkerVersion; + UINT8 MinorLinkerVersion; + UINT32 SizeOfCode; + UINT32 SizeOfInitializedData; + UINT32 SizeOfUninitializedData; + UINT32 AddressOfEntryPoint; + UINT32 BaseOfCode; + UINT32 BaseOfData; + UINT32 BaseOfBss; + UINT32 GprMask; + UINT32 CprMask[4]; + UINT32 GpValue; +} IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER; + +typedef struct _IMAGE_OPTIONAL_HEADER { + UINT16 Magic; + UINT8 MajorLinkerVersion; + UINT8 MinorLinkerVersion; + UINT32 SizeOfCode; + UINT32 SizeOfInitializedData; + UINT32 SizeOfUninitializedData; + UINT32 AddressOfEntryPoint; + UINT32 BaseOfCode; + // UINT32 BaseOfData; + UINT64 ImageBase; + UINT32 SectionAlignment; + UINT32 FileAlignment; + UINT16 MajorOperatingSystemVersion; + UINT16 MinorOperatingSystemVersion; + UINT16 MajorImageVersion; + UINT16 MinorImageVersion; + UINT16 MajorSubsystemVersion; + UINT16 MinorSubsystemVersion; + UINT32 Win32VersionValue; + UINT32 SizeOfImage; + UINT32 SizeOfHeaders; + UINT32 CheckSum; + UINT16 Subsystem; + UINT16 DllCharacteristics; + UINT64 SizeOfStackReserve; + UINT64 SizeOfStackCommit; + UINT64 SizeOfHeapReserve; + UINT64 SizeOfHeapCommit; + UINT32 LoaderFlags; + UINT32 NumberOfRvaAndSizes; + IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]; +} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER; + + +#define IMAGE_SIZEOF_ROM_OPTIONAL_HEADER 56 +#define IMAGE_SIZEOF_STD_OPTIONAL_HEADER 28 +#define IMAGE_SIZEOF_NT_OPTIONAL_HEADER 224 +#define IMAGE_SIZEOF_NT_OPTIONAL64_HEADER 244 + +#define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b +#define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b +#define IMAGE_ROM_OPTIONAL_HDR_MAGIC 0x107 + +typedef struct _IMAGE_NT_HEADERS { + UINT32 Signature; + IMAGE_FILE_HEADER FileHeader; + IMAGE_OPTIONAL_HEADER OptionalHeader; +} IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS; + +typedef struct _IMAGE_ROM_HEADERS { + IMAGE_FILE_HEADER FileHeader; + IMAGE_ROM_OPTIONAL_HEADER OptionalHeader; +} IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS; + +#define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER) \ + ((UINT32)ntheader + \ + FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + \ + ((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader \ + )) + + +// Subsystem Values + +#define IMAGE_SUBSYSTEM_UNKNOWN 0 // Unknown subsystem. +#define IMAGE_SUBSYSTEM_NATIVE 1 // Image doesn't require a subsystem. +#define IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem. +#define IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem. +#define IMAGE_SUBSYSTEM_OS2_CUI 5 // image runs in the OS/2 character subsystem. +#define IMAGE_SUBSYSTEM_POSIX_CUI 7 // image run in the Posix character subsystem. + + +// Directory Entries + +#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // Export Directory +#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // Import Directory +#define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 // Resource Directory +#define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 // Exception Directory +#define IMAGE_DIRECTORY_ENTRY_SECURITY 4 // Security Directory +#define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 // Base Relocation Table +#define IMAGE_DIRECTORY_ENTRY_DEBUG 6 // Debug Directory +#define IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 // Description String +#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 // Machine Value (MIPS GP) +#define IMAGE_DIRECTORY_ENTRY_TLS 9 // TLS Directory +#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 // Load Configuration Directory + +// +// Section header format. +// + +#define IMAGE_SIZEOF_SHORT_NAME 8 + +typedef struct _IMAGE_SECTION_HEADER { + UINT8 Name[IMAGE_SIZEOF_SHORT_NAME]; + union { + UINT32 PhysicalAddress; + UINT32 VirtualSize; + } Misc; + UINT32 VirtualAddress; + UINT32 SizeOfRawData; + UINT32 PointerToRawData; + UINT32 PointerToRelocations; + UINT32 PointerToLinenumbers; + UINT16 NumberOfRelocations; + UINT16 NumberOfLinenumbers; + UINT32 Characteristics; +} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER; + +#define IMAGE_SIZEOF_SECTION_HEADER 40 + +#define IMAGE_SCN_TYPE_NO_PAD 0x00000008 // Reserved. + +#define IMAGE_SCN_CNT_CODE 0x00000020 // Section contains code. +#define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040 // Section contains initialized data. +#define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x00000080 // Section contains uninitialized data. + +#define IMAGE_SCN_LNK_OTHER 0x00000100 // Reserved. +#define IMAGE_SCN_LNK_INFO 0x00000200 // Section contains comments or some other type of information. +#define IMAGE_SCN_LNK_REMOVE 0x00000800 // Section contents will not become part of image. +#define IMAGE_SCN_LNK_COMDAT 0x00001000 // Section contents comdat. + +#define IMAGE_SCN_ALIGN_1BYTES 0x00100000 // +#define IMAGE_SCN_ALIGN_2BYTES 0x00200000 // +#define IMAGE_SCN_ALIGN_4BYTES 0x00300000 // +#define IMAGE_SCN_ALIGN_8BYTES 0x00400000 // +#define IMAGE_SCN_ALIGN_16BYTES 0x00500000 // Default alignment if no others are specified. +#define IMAGE_SCN_ALIGN_32BYTES 0x00600000 // +#define IMAGE_SCN_ALIGN_64BYTES 0x00700000 // + +#define IMAGE_SCN_MEM_DISCARDABLE 0x02000000 // Section can be discarded. +#define IMAGE_SCN_MEM_NOT_CACHED 0x04000000 // Section is not cachable. +#define IMAGE_SCN_MEM_NOT_PAGED 0x08000000 // Section is not pageable. +#define IMAGE_SCN_MEM_SHARED 0x10000000 // Section is shareable. +#define IMAGE_SCN_MEM_EXECUTE 0x20000000 // Section is executable. +#define IMAGE_SCN_MEM_READ 0x40000000 // Section is readable. +#define IMAGE_SCN_MEM_WRITE 0x80000000 // Section is writeable. + +// +// Symbol format. +// + + +#define IMAGE_SIZEOF_SYMBOL 18 + +// +// Section values. +// +// Symbols have a section number of the section in which they are +// defined. Otherwise, section numbers have the following meanings: +// + +#define IMAGE_SYM_UNDEFINED (UINT16)0 // Symbol is undefined or is common. +#define IMAGE_SYM_ABSOLUTE (UINT16)-1 // Symbol is an absolute value. +#define IMAGE_SYM_DEBUG (UINT16)-2 // Symbol is a special debug item. + +// +// Type (fundamental) values. +// + +#define IMAGE_SYM_TYPE_NULL 0 // no type. +#define IMAGE_SYM_TYPE_VOID 1 // +#define IMAGE_SYM_TYPE_CHAR 2 // type character. +#define IMAGE_SYM_TYPE_SHORT 3 // type short integer. +#define IMAGE_SYM_TYPE_INT 4 // +#define IMAGE_SYM_TYPE_LONG 5 // +#define IMAGE_SYM_TYPE_FLOAT 6 // +#define IMAGE_SYM_TYPE_DOUBLE 7 // +#define IMAGE_SYM_TYPE_STRUCT 8 // +#define IMAGE_SYM_TYPE_UNION 9 // +#define IMAGE_SYM_TYPE_ENUM 10 // enumeration. +#define IMAGE_SYM_TYPE_MOE 11 // member of enumeration. +#define IMAGE_SYM_TYPE_BYTE 12 // +#define IMAGE_SYM_TYPE_WORD 13 // +#define IMAGE_SYM_TYPE_UINT 14 // +#define IMAGE_SYM_TYPE_DWORD 15 // + +// +// Type (derived) values. +// + +#define IMAGE_SYM_DTYPE_NULL 0 // no derived type. +#define IMAGE_SYM_DTYPE_POINTER 1 // pointer. +#define IMAGE_SYM_DTYPE_FUNCTION 2 // function. +#define IMAGE_SYM_DTYPE_ARRAY 3 // array. + +// +// Storage classes. +// + +#define IMAGE_SYM_CLASS_END_OF_FUNCTION (BYTE )-1 +#define IMAGE_SYM_CLASS_NULL 0 +#define IMAGE_SYM_CLASS_AUTOMATIC 1 +#define IMAGE_SYM_CLASS_EXTERNAL 2 +#define IMAGE_SYM_CLASS_STATIC 3 +#define IMAGE_SYM_CLASS_REGISTER 4 +#define IMAGE_SYM_CLASS_EXTERNAL_DEF 5 +#define IMAGE_SYM_CLASS_LABEL 6 +#define IMAGE_SYM_CLASS_UNDEFINED_LABEL 7 +#define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT 8 +#define IMAGE_SYM_CLASS_ARGUMENT 9 +#define IMAGE_SYM_CLASS_STRUCT_TAG 10 +#define IMAGE_SYM_CLASS_MEMBER_OF_UNION 11 +#define IMAGE_SYM_CLASS_UNION_TAG 12 +#define IMAGE_SYM_CLASS_TYPE_DEFINITION 13 +#define IMAGE_SYM_CLASS_UNDEFINED_STATIC 14 +#define IMAGE_SYM_CLASS_ENUM_TAG 15 +#define IMAGE_SYM_CLASS_MEMBER_OF_ENUM 16 +#define IMAGE_SYM_CLASS_REGISTER_PARAM 17 +#define IMAGE_SYM_CLASS_BIT_FIELD 18 +#define IMAGE_SYM_CLASS_BLOCK 100 +#define IMAGE_SYM_CLASS_FUNCTION 101 +#define IMAGE_SYM_CLASS_END_OF_STRUCT 102 +#define IMAGE_SYM_CLASS_FILE 103 +// new +#define IMAGE_SYM_CLASS_SECTION 104 +#define IMAGE_SYM_CLASS_WEAK_EXTERNAL 105 + +// type packing constants + +#define N_BTMASK 017 +#define N_TMASK 060 +#define N_TMASK1 0300 +#define N_TMASK2 0360 +#define N_BTSHFT 4 +#define N_TSHIFT 2 + +// MACROS + +// +// Communal selection types. +// + +#define IMAGE_COMDAT_SELECT_NODUPLICATES 1 +#define IMAGE_COMDAT_SELECT_ANY 2 +#define IMAGE_COMDAT_SELECT_SAME_SIZE 3 +#define IMAGE_COMDAT_SELECT_EXACT_MATCH 4 +#define IMAGE_COMDAT_SELECT_ASSOCIATIVE 5 + +#define IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY 1 +#define IMAGE_WEAK_EXTERN_SEARCH_LIBRARY 2 +#define IMAGE_WEAK_EXTERN_SEARCH_ALIAS 3 + + +// +// Relocation format. +// + +typedef struct _IMAGE_RELOCATION { + UINT32 VirtualAddress; + UINT32 SymbolTableIndex; + UINT16 Type; +} IMAGE_RELOCATION; + +#define IMAGE_SIZEOF_RELOCATION 10 + +// +// I386 relocation types. +// + +#define IMAGE_REL_I386_ABSOLUTE 0 // Reference is absolute, no relocation is necessary +#define IMAGE_REL_I386_DIR16 01 // Direct 16-bit reference to the symbols virtual address +#define IMAGE_REL_I386_REL16 02 // PC-relative 16-bit reference to the symbols virtual address +#define IMAGE_REL_I386_DIR32 06 // Direct 32-bit reference to the symbols virtual address +#define IMAGE_REL_I386_DIR32NB 07 // Direct 32-bit reference to the symbols virtual address, base not included +#define IMAGE_REL_I386_SEG12 011 // Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address +#define IMAGE_REL_I386_SECTION 012 +#define IMAGE_REL_I386_SECREL 013 +#define IMAGE_REL_I386_REL32 024 // PC-relative 32-bit reference to the symbols virtual address + +// +// MIPS relocation types. +// + +#define IMAGE_REL_MIPS_ABSOLUTE 0 // Reference is absolute, no relocation is necessary +#define IMAGE_REL_MIPS_REFHALF 01 +#define IMAGE_REL_MIPS_REFWORD 02 +#define IMAGE_REL_MIPS_JMPADDR 03 +#define IMAGE_REL_MIPS_REFHI 04 +#define IMAGE_REL_MIPS_REFLO 05 +#define IMAGE_REL_MIPS_GPREL 06 +#define IMAGE_REL_MIPS_LITERAL 07 +#define IMAGE_REL_MIPS_SECTION 012 +#define IMAGE_REL_MIPS_SECREL 013 +#define IMAGE_REL_MIPS_REFWORDNB 042 +#define IMAGE_REL_MIPS_PAIR 045 + +// +// Alpha Relocation types. +// + +#define IMAGE_REL_ALPHA_ABSOLUTE 0x0 +#define IMAGE_REL_ALPHA_REFLONG 0x1 +#define IMAGE_REL_ALPHA_REFQUAD 0x2 +#define IMAGE_REL_ALPHA_GPREL32 0x3 +#define IMAGE_REL_ALPHA_LITERAL 0x4 +#define IMAGE_REL_ALPHA_LITUSE 0x5 +#define IMAGE_REL_ALPHA_GPDISP 0x6 +#define IMAGE_REL_ALPHA_BRADDR 0x7 +#define IMAGE_REL_ALPHA_HINT 0x8 +#define IMAGE_REL_ALPHA_INLINE_REFLONG 0x9 +#define IMAGE_REL_ALPHA_REFHI 0xA +#define IMAGE_REL_ALPHA_REFLO 0xB +#define IMAGE_REL_ALPHA_PAIR 0xC +#define IMAGE_REL_ALPHA_MATCH 0xD +#define IMAGE_REL_ALPHA_SECTION 0xE +#define IMAGE_REL_ALPHA_SECREL 0xF +#define IMAGE_REL_ALPHA_REFLONGNB 0x10 + +// +// IBM PowerPC relocation types. +// + +#define IMAGE_REL_PPC_ABSOLUTE 0x0000 // NOP +#define IMAGE_REL_PPC_ADDR64 0x0001 // 64-bit address +#define IMAGE_REL_PPC_ADDR32 0x0002 // 32-bit address +#define IMAGE_REL_PPC_ADDR24 0x0003 // 26-bit address, shifted left 2 (branch absolute) +#define IMAGE_REL_PPC_ADDR16 0x0004 // 16-bit address +#define IMAGE_REL_PPC_ADDR14 0x0005 // 16-bit address, shifted left 2 (load doubleword) +#define IMAGE_REL_PPC_REL24 0x0006 // 26-bit PC-relative offset, shifted left 2 (branch relative) +#define IMAGE_REL_PPC_REL14 0x0007 // 16-bit PC-relative offset, shifted left 2 (br cond relative) +#define IMAGE_REL_PPC_TOCREL16 0x0008 // 16-bit offset from TOC base +#define IMAGE_REL_PPC_TOCREL14 0x0009 // 16-bit offset from TOC base, shifted left 2 (load doubleword) + +#define IMAGE_REL_PPC_ADDR32NB 0x000A // 32-bit addr w/o image base +#define IMAGE_REL_PPC_SECREL 0x000B // va of containing section (as in an image sectionhdr) +#define IMAGE_REL_PPC_SECTION 0x000C // sectionheader number +#define IMAGE_REL_PPC_IFGLUE 0x000D // substitute TOC restore instruction iff symbol is glue code +#define IMAGE_REL_PPC_IMGLUE 0x000E // symbol is glue code; virtual address is TOC restore instruction + +#define IMAGE_REL_PPC_TYPEMASK 0x00FF // mask to isolate above values in IMAGE_RELOCATION.Type + +// Flag bits in IMAGE_RELOCATION.TYPE + +#define IMAGE_REL_PPC_NEG 0x0100 // subtract reloc value rather than adding it +#define IMAGE_REL_PPC_BRTAKEN 0x0200 // fix branch prediction bit to predict branch taken +#define IMAGE_REL_PPC_BRNTAKEN 0x0400 // fix branch prediction bit to predict branch not taken +#define IMAGE_REL_PPC_TOCDEFN 0x0800 // toc slot defined in file (or, data in toc) + +// +// Based relocation format. +// + +typedef struct _IMAGE_BASE_RELOCATION { + UINT32 VirtualAddress; + UINT32 SizeOfBlock; +// UINT16 TypeOffset[1]; +} IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION; + +#define IMAGE_SIZEOF_BASE_RELOCATION 8 + +// +// Based relocation types. +// + +#define IMAGE_REL_BASED_ABSOLUTE 0 +#define IMAGE_REL_BASED_HIGH 1 +#define IMAGE_REL_BASED_LOW 2 +#define IMAGE_REL_BASED_HIGHLOW 3 +#define IMAGE_REL_BASED_HIGHADJ 4 +#define IMAGE_REL_BASED_MIPS_JMPADDR 5 +#define IMAGE_REL_BASED_IA64_IMM64 9 +#define IMAGE_REL_BASED_DIR64 10 + +// +// Line number format. +// + +typedef struct _IMAGE_LINENUMBER { + union { + UINT32 SymbolTableIndex; // Symbol table index of function name if Linenumber is 0. + UINT32 VirtualAddress; // Virtual address of line number. + } Type; + UINT16 Linenumber; // Line number. +} IMAGE_LINENUMBER; + +#define IMAGE_SIZEOF_LINENUMBER 6 + +// +// Archive format. +// + +#define IMAGE_ARCHIVE_START_SIZE 8 +#define IMAGE_ARCHIVE_START "!\n" +#define IMAGE_ARCHIVE_END "`\n" +#define IMAGE_ARCHIVE_PAD "\n" +#define IMAGE_ARCHIVE_LINKER_MEMBER "/ " +#define IMAGE_ARCHIVE_LONGNAMES_MEMBER "// " + +typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER { + UINT8 Name[16]; // File member name - `/' terminated. + UINT8 Date[12]; // File member date - decimal. + UINT8 UserID[6]; // File member user id - decimal. + UINT8 GroupID[6]; // File member group id - decimal. + UINT8 Mode[8]; // File member mode - octal. + UINT8 Size[10]; // File member size - decimal. + UINT8 EndHeader[2]; // String to end header. +} IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER; + +#define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR 60 + +// +// DLL support. +// + +// +// Export Format +// + +typedef struct _IMAGE_EXPORT_DIRECTORY { + UINT32 Characteristics; + UINT32 TimeDateStamp; + UINT16 MajorVersion; + UINT16 MinorVersion; + UINT32 Name; + UINT32 Base; + UINT32 NumberOfFunctions; + UINT32 NumberOfNames; + UINT32 AddressOfFunctions; + UINT32 AddressOfNames; + UINT32 AddressOfNameOrdinals; +} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY; + +// +// Import Format +// + +typedef struct _IMAGE_IMPORT_BY_NAME { + UINT16 Hint; + UINT8 Name[1]; +} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME; + +typedef struct _IMAGE_THUNK_DATA { + union { + UINT32 Function; + UINT32 Ordinal; + PIMAGE_IMPORT_BY_NAME AddressOfData; + } u1; +} IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA; + +#define IMAGE_ORDINAL_FLAG 0x80000000 +#define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0) +#define IMAGE_ORDINAL(Ordinal) (Ordinal & 0xffff) + +typedef struct _IMAGE_IMPORT_DESCRIPTOR { + UINT32 Characteristics; + UINT32 TimeDateStamp; + UINT32 ForwarderChain; + UINT32 Name; + PIMAGE_THUNK_DATA FirstThunk; +} IMAGE_IMPORT_DESCRIPTOR, *PIMAGE_IMPORT_DESCRIPTOR; + +#endif diff --git a/gnuefi/inc/ia64/salproc.h b/gnuefi/inc/ia64/salproc.h new file mode 100644 index 0000000..62a5dca --- /dev/null +++ b/gnuefi/inc/ia64/salproc.h @@ -0,0 +1,264 @@ +#ifndef _SAL_PROC_H +#define _SAL_PROC_H +// +// +//Copyright (c) 1999 Intel Corporation +// +//Module Name: +// +// SalProc.h +// +//Abstract: +// +// Main SAL interface routins for IA-64 calls. +// +// +//Revision History +// +// + +// return value that mimicks r8,r9,r10 & r11 registers +typedef struct { + UINT64 p0; + UINT64 p1; + UINT64 p2; + UINT64 p3; +} rArg; + +#define SAL_PCI_CONFIG_READ 0x01000010 +#define SAL_PCI_CONFIG_WRITE 0x01000011 + +typedef VOID (*PFN)(); +typedef rArg (*PFN_SAL_PROC)(UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64); +typedef rArg (*PFN_SAL_CALLBACK)(UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64); + +typedef struct _PLABEL { + UINT64 ProcEntryPoint; + UINT64 GP; +} PLABEL; + +typedef struct tagIA32_BIOS_REGISTER_STATE { + + // general registers + UINT32 eax; + UINT32 ecx; + UINT32 edx; + UINT32 ebx; + + // stack registers + UINT32 esp; + UINT32 ebp; + UINT32 esi; + UINT32 edi; + + // eflags + UINT32 eflags; + + // instruction pointer + UINT32 eip; + + UINT16 cs; + UINT16 ds; + UINT16 es; + UINT16 fs; + UINT16 gs; + UINT16 ss; + + // Reserved + UINT32 Reserved1; + UINT64 Reserved2; +} IA32_BIOS_REGISTER_STATE; + +VOID EFIInitMsg(VOID); + +EFI_STATUS +PlRegisterAndStartTimer( + IN UINTN Period + ); + +EFI_STATUS +PlDeRegisterAndCancelTimer(VOID); + +VOID +SalProc ( + IN UINT64 Arg1, + IN UINT64 Arg2, + IN UINT64 Arg3, + IN UINT64 Arg4, + IN UINT64 Arg5, + IN UINT64 Arg6, + IN UINT64 Arg7, + IN UINT64 Arg8, + OUT rArg *Results OPTIONAL + ); + +VOID +SalCallBack ( + IN UINT64 Arg1, + IN UINT64 Arg2, + IN UINT64 Arg3, + IN UINT64 Arg4, + IN UINT64 Arg5, + IN UINT64 Arg6, + IN UINT64 Arg7, + IN UINT64 Arg8, + OUT rArg *Results OPTIONAL + ); + +VOID +RUNTIMEFUNCTION +RtSalCallBack ( + IN UINT64 Arg1, + IN UINT64 Arg2, + IN UINT64 Arg3, + IN UINT64 Arg4, + IN UINT64 Arg5, + IN UINT64 Arg6, + IN UINT64 Arg7, + IN UINT64 Arg8, + OUT rArg *Results OPTIONAL + ); + + +extern PLABEL RtGlobalSalProcEntry; +extern PLABEL RtGlobalSALCallBack; + +#pragma pack(1) +// +// SAL System Table +// +typedef struct { + UINT32 Signature; + UINT32 Length; + UINT16 Revision; + UINT16 EntryCount; + UINT8 CheckSum; + UINT8 Reserved[7]; + UINT16 SALA_Ver; + UINT16 SALB_Ver; + UINT8 OemId[32]; + UINT8 ProductID[32]; + UINT8 Reserved2[8]; +} SAL_SYSTEM_TABLE_HDR; + +#define SAL_ST_ENTRY_POINT 0 +#define SAL_ST_MEMORY_DESCRIPTOR 1 +#define SAL_ST_PLATFORM_FEATURES 2 +#define SAL_ST_TR_USAGE 3 +#define SAL_ST_PTC 4 +#define SAL_ST_AP_WAKEUP 5 + +typedef struct { + UINT8 Type; // Type == 0 + UINT8 Reserved[7]; + UINT64 PalProcEntry; + UINT64 SalProcEntry; + UINT64 GlobalDataPointer; + UINT64 Reserved2[2]; +} SAL_ST_ENTRY_POINT_DESCRIPTOR; + +typedef struct { + UINT8 Type; // Type == 1 + UINT8 NeedVirtualRegistration; + UINT8 MemoryAttributes; + UINT8 PageAccessRights; + UINT8 SupportedAttributes; + UINT8 Reserved; + UINT16 MemoryType; + UINT64 PhysicalMemoryAddress; + UINT32 Length; + UINT32 Reserved1; + UINT64 OemReserved; +} SAL_ST_MEMORY_DESCRIPTOR_ENTRY; + +// +// MemoryType info +// +#define SAL_SAPIC_IPI_BLOCK 0x0002 +#define SAL_IO_PORT_MAPPING 0x0003 + +typedef struct { + UINT8 Type; // Type == 2 + UINT8 PlatformFeatures; + UINT8 Reserved[14]; +} SAL_ST_MEMORY_DECRIPTOR; + +typedef struct { + UINT8 Type; // Type == 3 + UINT8 TRType; + UINT8 TRNumber; + UINT8 Reserved[5]; + UINT64 VirtualAddress; + UINT64 EncodedPageSize; + UINT64 Reserved1; +} SAL_ST_TR_DECRIPTOR; + +typedef struct { + UINT64 NumberOfProcessors; + UINT64 LocalIDRegister; +} SAL_COHERENCE_DOMAIN_INFO; + +typedef struct { + UINT8 Type; // Type == 4 + UINT8 Reserved[3]; + UINT32 NumberOfDomains; + SAL_COHERENCE_DOMAIN_INFO *DomainInformation; +} SAL_ST_CACHE_COHERENCE_DECRIPTOR; + +typedef struct { + UINT8 Type; // Type == 5 + UINT8 WakeUpType; + UINT8 Reserved[6]; + UINT64 ExternalInterruptVector; +} SAL_ST_AP_WAKEUP_DECRIPTOR; + +typedef struct { + SAL_SYSTEM_TABLE_HDR Header; + SAL_ST_ENTRY_POINT_DESCRIPTOR Entry0; +} SAL_SYSTEM_TABLE_ASCENDING_ORDER; + +#define FIT_ENTRY_PTR (0x100000000 - 32) // 4GB - 24 +#define FIT_PALA_ENTRY (0x100000000 - 48) // 4GB - 32 +#define FIT_PALB_TYPE 01 + +typedef struct { + UINT64 Address; + UINT8 Size[3]; + UINT8 Reserved; + UINT16 Revision; + UINT8 Type:7; + UINT8 CheckSumValid:1; + UINT8 CheckSum; +} FIT_ENTRY; + +#pragma pack() + +typedef + rArg +(*CALL_SAL_PROC)( + IN UINT64 Arg1, + IN UINT64 Arg2, + IN UINT64 Arg3, + IN UINT64 Arg4, + IN UINT64 Arg5, + IN UINT64 Arg6, + IN UINT64 Arg7, + IN UINT64 Arg8 + ); + +typedef + rArg +(*CALL_PAL_PROC)( + IN UINT64 Arg1, + IN UINT64 Arg2, + IN UINT64 Arg3, + IN UINT64 Arg4 + ); + +extern CALL_SAL_PROC GlobalSalProc; +extern CALL_PAL_PROC GlobalPalProc; +extern PLABEL SalProcPlabel; +extern PLABEL PalProcPlabel; + +#endif + diff --git a/gnuefi/inc/inc.mak b/gnuefi/inc/inc.mak new file mode 100644 index 0000000..992996b --- /dev/null +++ b/gnuefi/inc/inc.mak @@ -0,0 +1,23 @@ + + +INC_DEPS = $(INC_DEPS) \ + efi.h \ + efiapi.h \ + efibind.h \ + eficon.h \ + efidebug.h \ + efidef.h \ + efidevp.h \ + efierr.h \ + efifs.h \ + efilib.h \ + efipart.h \ + efipciio.h \ + efiprot.h \ + efipxe.h \ + efivar.h \ + pe.h \ + efiip.h \ + efiudp.h \ + efitcp.h \ + stdarg.h diff --git a/gnuefi/inc/lib.h b/gnuefi/inc/lib.h new file mode 100644 index 0000000..7e78c62 --- /dev/null +++ b/gnuefi/inc/lib.h @@ -0,0 +1,92 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + lib.h + +Abstract: + + EFI library header files + + + +Revision History + +--*/ + +#ifdef __GNUC__ +#pragma GCC visibility push(hidden) +#endif + +#include "efi.h" +#include "efilib.h" +#include "efirtlib.h" + +// +// Include non architectural protocols +// +#include "protocol/efivar.h" +#include "protocol/legacyboot.h" +#include "protocol/intload.h" +#include "protocol/vgaclass.h" +#include "protocol/eficonsplit.h" +#include "protocol/adapterdebug.h" +#include "protocol/intload.h" + +#include "efigpt.h" +#include "libsmbios.h" + +// +// Prototypes +// + +VOID +InitializeGuid ( + VOID + ); + +INTN EFIAPI +LibStubStriCmp ( + IN EFI_UNICODE_COLLATION_INTERFACE *This, + IN CHAR16 *S1, + IN CHAR16 *S2 + ); + +BOOLEAN EFIAPI +LibStubMetaiMatch ( + IN EFI_UNICODE_COLLATION_INTERFACE *This, + IN CHAR16 *String, + IN CHAR16 *Pattern + ); + +VOID EFIAPI +LibStubStrLwrUpr ( + IN EFI_UNICODE_COLLATION_INTERFACE *This, + IN CHAR16 *Str + ); + +BOOLEAN +LibMatchDevicePaths ( + IN EFI_DEVICE_PATH *Multi, + IN EFI_DEVICE_PATH *Single + ); + +EFI_DEVICE_PATH * +LibDuplicateDevicePathInstance ( + IN EFI_DEVICE_PATH *DevPath + ); + + +// +// Globals +// +extern BOOLEAN LibInitialized; +extern BOOLEAN LibFwInstance; +extern EFI_HANDLE LibImageHandle; +extern SIMPLE_TEXT_OUTPUT_INTERFACE *LibRuntimeDebugOut; +extern EFI_UNICODE_COLLATION_INTERFACE *UnicodeInterface; +extern EFI_UNICODE_COLLATION_INTERFACE LibStubUnicodeInterface; +extern EFI_RAISE_TPL LibRuntimeRaiseTPL; +extern EFI_RESTORE_TPL LibRuntimeRestoreTPL; diff --git a/gnuefi/inc/libsmbios.h b/gnuefi/inc/libsmbios.h new file mode 100644 index 0000000..658c01d --- /dev/null +++ b/gnuefi/inc/libsmbios.h @@ -0,0 +1,143 @@ +#ifndef _LIB_SMBIOS_H +#define _LIB_SMBIOS_H +/*++ + +Copyright (c) 2000 Intel Corporation + +Module Name: + + LibSmbios.h + +Abstract: + + Lib include for SMBIOS services. Used to get system serial number and GUID + +Revision History + +--*/ + +// +// Define SMBIOS tables. +// +#pragma pack(1) +typedef struct { + UINT8 AnchorString[4]; + UINT8 EntryPointStructureChecksum; + UINT8 EntryPointLength; + UINT8 MajorVersion; + UINT8 MinorVersion; + UINT16 MaxStructureSize; + UINT8 EntryPointRevision; + UINT8 FormattedArea[5]; + UINT8 IntermediateAnchorString[5]; + UINT8 IntermediateChecksum; + UINT16 TableLength; + UINT32 TableAddress; + UINT16 NumberOfSmbiosStructures; + UINT8 SmbiosBcdRevision; +} SMBIOS_STRUCTURE_TABLE; + +typedef struct { + UINT8 AnchorString[5]; + UINT8 EntryPointStructureChecksum; + UINT8 EntryPointLength; + UINT8 MajorVersion; + UINT8 MinorVersion; + UINT8 DocRev; + UINT8 EntryPointRevision; + UINT8 Reserved; + UINT32 TableMaximumSize; + UINT64 TableAddress; +} SMBIOS3_STRUCTURE_TABLE; + +// +// Please note that SMBIOS structures can be odd byte aligned since the +// unformated section of each record is a set of arbitrary size strings. +// + +typedef struct { + UINT8 Type; + UINT8 Length; + UINT8 Handle[2]; +} SMBIOS_HEADER; + +typedef UINT8 SMBIOS_STRING; + +typedef struct { + SMBIOS_HEADER Hdr; + SMBIOS_STRING Vendor; + SMBIOS_STRING BiosVersion; + UINT8 BiosSegment[2]; + SMBIOS_STRING BiosReleaseDate; + UINT8 BiosSize; + UINT8 BiosCharacteristics[8]; +} SMBIOS_TYPE0; + +typedef struct { + SMBIOS_HEADER Hdr; + SMBIOS_STRING Manufacturer; + SMBIOS_STRING ProductName; + SMBIOS_STRING Version; + SMBIOS_STRING SerialNumber; + + // + // always byte copy this data to prevent alignment faults! + // + EFI_GUID Uuid; + + UINT8 WakeUpType; +} SMBIOS_TYPE1; + +typedef struct { + SMBIOS_HEADER Hdr; + SMBIOS_STRING Manufacturer; + SMBIOS_STRING ProductName; + SMBIOS_STRING Version; + SMBIOS_STRING SerialNumber; +} SMBIOS_TYPE2; + +typedef struct { + SMBIOS_HEADER Hdr; + SMBIOS_STRING Manufacturer; + UINT8 Type; + SMBIOS_STRING Version; + SMBIOS_STRING SerialNumber; + SMBIOS_STRING AssetTag; + UINT8 BootupState; + UINT8 PowerSupplyState; + UINT8 ThermalState; + UINT8 SecurityStatus; + UINT8 OemDefined[4]; +} SMBIOS_TYPE3; + +typedef struct { + SMBIOS_HEADER Hdr; + UINT8 Socket; + UINT8 ProcessorType; + UINT8 ProcessorFamily; + SMBIOS_STRING ProcessorManufacture; + UINT8 ProcessorId[8]; + SMBIOS_STRING ProcessorVersion; + UINT8 Voltage; + UINT8 ExternalClock[2]; + UINT8 MaxSpeed[2]; + UINT8 CurrentSpeed[2]; + UINT8 Status; + UINT8 ProcessorUpgrade; + UINT8 L1CacheHandle[2]; + UINT8 L2CacheHandle[2]; + UINT8 L3CacheHandle[2]; +} SMBIOS_TYPE4; + +typedef union { + SMBIOS_HEADER *Hdr; + SMBIOS_TYPE0 *Type0; + SMBIOS_TYPE1 *Type1; + SMBIOS_TYPE2 *Type2; + SMBIOS_TYPE3 *Type3; + SMBIOS_TYPE4 *Type4; + UINT8 *Raw; +} SMBIOS_STRUCTURE_POINTER; +#pragma pack() + +#endif diff --git a/gnuefi/inc/loongarch64/efibind.h b/gnuefi/inc/loongarch64/efibind.h new file mode 100644 index 0000000..8ed83a5 --- /dev/null +++ b/gnuefi/inc/loongarch64/efibind.h @@ -0,0 +1,159 @@ +/* + * Copright (C) 2014 - 2015 Linaro Ltd. + * Author: Ard Biesheuvel + * Copright (C) 2017 Lemote Co. + * Author: Heiher + * Copright (C) 2021 Loongson Technology Corporation Limited. + * Author: zhoumingtao + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice and this list of conditions, without modification. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU General Public License as published by the Free Software Foundation; + * either version 2 of the License, or (at your option) any later version. + */ + +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L ) && !defined(__cplusplus) + +// ANSI C 1999/2000 stdint.h integer width declarations + +typedef unsigned long uint64_t; +typedef long int64_t; +typedef unsigned int uint32_t; +typedef int int32_t; +typedef unsigned short uint16_t; +typedef short int16_t; +typedef unsigned char uint8_t; +typedef signed char int8_t; +typedef uint64_t uintptr_t; +typedef int64_t intptr_t; + +#else +#include +#endif + +// +// Basic EFI types of various widths +// + +#include + +typedef wchar_t CHAR16; +#define WCHAR CHAR16 + +typedef uint64_t UINT64; +typedef int64_t INT64; + +typedef uint32_t UINT32; +typedef int32_t INT32; + +typedef uint16_t UINT16; +typedef int16_t INT16; + +typedef uint8_t UINT8; +typedef char CHAR8; +typedef int8_t INT8; + +#undef VOID +typedef void VOID; + +typedef int64_t INTN; +typedef uint64_t UINTN; + +#define EFIERR(a) (0x8000000000000000 | a) +#define EFI_ERROR_MASK 0x8000000000000000 +#define EFIERR_OEM(a) (0xc000000000000000 | a) + +#define BAD_POINTER 0xFBFBFBFBFBFBFBFB +#define MAX_ADDRESS 0xFFFFFFFFFFFFFFFF + +#define BREAKPOINT() while (TRUE); // Make it hang on Bios[Dbg]32 + +// +// Pointers must be aligned to these address to function +// + +#define MIN_ALIGNMENT_SIZE 8 + +#define ALIGN_VARIABLE(Value ,Adjustment) \ + (UINTN)Adjustment = 0; \ + if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ + (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ + Value = (UINTN)Value + (UINTN)Adjustment + + +// +// Define macros to build data structure signatures from characters. +// + +#define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) +#define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) +#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) + +// +// EFIAPI - prototype calling convention for EFI function pointers +// BOOTSERVICE - prototype for implementation of a boot service interface +// RUNTIMESERVICE - prototype for implementation of a runtime service interface +// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service +// RUNTIME_CODE - pragma macro for declaring runtime code +// + +#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options +#define EFIAPI // Substitute expresion to force C calling convention +#endif + +#define BOOTSERVICE +#define RUNTIMESERVICE +#define RUNTIMEFUNCTION + + +#define RUNTIME_CODE(a) alloc_text("rtcode", a) +#define BEGIN_RUNTIME_DATA() data_seg("rtdata") +#define END_RUNTIME_DATA() data_seg("") + +#define VOLATILE volatile + +#define MEMORY_FENCE __sync_synchronize + +// +// When build similiar to FW, then link everything together as +// one big module. +// + +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + InitializeDriver ( \ + VOID *ImageHandle, \ + VOID *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, \ + SystemTable); \ + } \ + \ + EFI_STATUS efi_main( \ + EFI_HANDLE image, \ + EFI_SYSTEM_TABLE *systab \ + ) __attribute__((weak, \ + alias ("InitializeDriver"))); + +#define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, entry) + + +// +// Some compilers don't support the forward reference construct: +// typedef struct XXXXX +// +// The following macro provide a workaround for such cases. + +#define INTERFACE_DECL(x) struct x + +#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__) +#define EFI_FUNCTION diff --git a/gnuefi/inc/loongarch64/efilibplat.h b/gnuefi/inc/loongarch64/efilibplat.h new file mode 100644 index 0000000..eda7c83 --- /dev/null +++ b/gnuefi/inc/loongarch64/efilibplat.h @@ -0,0 +1,24 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efilibplat.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ + +VOID +InitializeLibPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); diff --git a/gnuefi/inc/loongarch64/efisetjmp_arch.h b/gnuefi/inc/loongarch64/efisetjmp_arch.h new file mode 100644 index 0000000..41ff410 --- /dev/null +++ b/gnuefi/inc/loongarch64/efisetjmp_arch.h @@ -0,0 +1,23 @@ +#ifndef GNU_EFI_LOONGARCH64_SETJMP_H +#define GNU_EFI_LOONGARCH64_SETJMP_H + +#define JMPBUF_ALIGN 8 + +typedef struct { + /* GP regs */ + UINT64 RA; + UINT64 SP; + UINT64 FP; + + UINT64 S0; + UINT64 S1; + UINT64 S2; + UINT64 S3; + UINT64 S4; + UINT64 S5; + UINT64 S6; + UINT64 S7; + UINT64 S8; +} EFI_ALIGN(JMPBUF_ALIGN) jmp_buf[1]; + +#endif /* GNU_EFI_LOONGARCH64_SETJMP_H */ diff --git a/gnuefi/inc/make.inf b/gnuefi/inc/make.inf new file mode 100644 index 0000000..f173196 --- /dev/null +++ b/gnuefi/inc/make.inf @@ -0,0 +1,33 @@ +# +# +# + +[sources] + efi.h + efiapi.h + eficon.h + efidebug.h + efidef.h + efidevp.h + efierr.h + efifs.h + efilib.h + efipart.h + efipciio.h + efiprot.h + efipxebc.h + efistdarg.h + efinet.h + efiip.h + efiudp.h + efitcp.h + +[ia32sources] + efibind.h + pe.h + efilibplat.h + +[ia64sources] + efibind.h + pe.h + efilibplat.h diff --git a/gnuefi/inc/makefile.hdr b/gnuefi/inc/makefile.hdr new file mode 100644 index 0000000..46ef387 --- /dev/null +++ b/gnuefi/inc/makefile.hdr @@ -0,0 +1,48 @@ + +# +# This is a machine generated file - DO NOT EDIT +# Generated by genmake.exe +# Generated from make.inf +# Copyright (c) 1998 Intel Corporation +# + +INC_DEPS = $(INC_DEPS) \ + $(SDK_INSTALL_DIR)\include\efi\efi.h \ + $(SDK_INSTALL_DIR)\include\efi\efiapi.h \ + $(SDK_INSTALL_DIR)\include\efi\eficon.h \ + $(SDK_INSTALL_DIR)\include\efi\efidebug.h \ + $(SDK_INSTALL_DIR)\include\efi\efidef.h \ + $(SDK_INSTALL_DIR)\include\efi\efidevp.h \ + $(SDK_INSTALL_DIR)\include\efi\efierr.h \ + $(SDK_INSTALL_DIR)\include\efi\efifs.h \ + $(SDK_INSTALL_DIR)\include\efi\efilib.h \ + $(SDK_INSTALL_DIR)\include\efi\efipart.h \ + $(SDK_INSTALL_DIR)\include\efi\efipciio.h \ + $(SDK_INSTALL_DIR)\include\efi\efiprot.h \ + $(SDK_INSTALL_DIR)\include\efi\efipxebc.h \ + $(SDK_INSTALL_DIR)\include\efi\efistdarg.h \ + $(SDK_INSTALL_DIR)\include\efi\efinet.h \ + $(SDK_INSTALL_DIR)\include\efi\efiip.h \ + $(SDK_INSTALL_DIR)\include\efi\efiudp.h \ + $(SDK_INSTALL_DIR)\include\efi\efitcp.h \ + + +!IF "$(PROCESSOR)" == "Ia32" +INC_DEPS = $(INC_DEPS) \ + $(SDK_INSTALL_DIR)\include\efi\Ia32\efibind.h \ + $(SDK_INSTALL_DIR)\include\efi\Ia32\pe.h \ + $(SDK_INSTALL_DIR)\include\efi\Ia32\efilibplat.h \ + + +!ENDIF + + +!IF "$(PROCESSOR)" == "Ia64" +INC_DEPS = $(INC_DEPS) \ + $(SDK_INSTALL_DIR)\include\efi\Ia64\efibind.h \ + $(SDK_INSTALL_DIR)\include\efi\Ia64\pe.h \ + $(SDK_INSTALL_DIR)\include\efi\Ia64\efilibplat.h \ + + +!ENDIF + diff --git a/gnuefi/inc/mips64el/efibind.h b/gnuefi/inc/mips64el/efibind.h new file mode 100644 index 0000000..cf77ddc --- /dev/null +++ b/gnuefi/inc/mips64el/efibind.h @@ -0,0 +1,168 @@ +/* + * Copright (C) 2014 - 2015 Linaro Ltd. + * Author: Ard Biesheuvel + * Copright (C) 2017 Lemote Co. + * Author: Heiher + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice and this list of conditions, without modification. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU General Public License as published by the Free Software Foundation; + * either version 2 of the License, or (at your option) any later version. + */ + +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L ) && !defined(__cplusplus) + +// ANSI C 1999/2000 stdint.h integer width declarations + +typedef unsigned long uint64_t; +typedef long int64_t; +typedef unsigned int uint32_t; +typedef int int32_t; +typedef unsigned short uint16_t; +typedef short int16_t; +typedef unsigned char uint8_t; +typedef signed char int8_t; // unqualified 'char' is unsigned on ARM +typedef uint64_t uintptr_t; +typedef int64_t intptr_t; + +#else +#include +#endif + +// +// Basic EFI types of various widths +// + +#include + +typedef wchar_t CHAR16; +#define WCHAR CHAR16 + +typedef uint64_t UINT64; +typedef int64_t INT64; + +typedef uint32_t UINT32; +typedef int32_t INT32; + +typedef uint16_t UINT16; +typedef int16_t INT16; + +typedef uint8_t UINT8; +typedef char CHAR8; +typedef int8_t INT8; + +#undef VOID +typedef void VOID; + +typedef int64_t INTN; +typedef uint64_t UINTN; + +#define EFIERR(a) (0x8000000000000000 | a) +#define EFI_ERROR_MASK 0x8000000000000000 +#define EFIERR_OEM(a) (0xc000000000000000 | a) + +#define BAD_POINTER 0xFBFBFBFBFBFBFBFB +#define MAX_ADDRESS 0xFFFFFFFFFFFFFFFF + +#define BREAKPOINT() while (TRUE); // Make it hang on Bios[Dbg]32 + +// +// Pointers must be aligned to these address to function +// + +#define MIN_ALIGNMENT_SIZE 8 + +#define ALIGN_VARIABLE(Value ,Adjustment) \ + (UINTN)Adjustment = 0; \ + if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ + (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ + Value = (UINTN)Value + (UINTN)Adjustment + + +// +// Define macros to build data structure signatures from characters. +// + +#define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) +#define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) +#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) + +// +// EFIAPI - prototype calling convention for EFI function pointers +// BOOTSERVICE - prototype for implementation of a boot service interface +// RUNTIMESERVICE - prototype for implementation of a runtime service interface +// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service +// RUNTIME_CODE - pragma macro for declaring runtime code +// + +#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options +#define EFIAPI // Substitute expresion to force C calling convention +#endif + +#define BOOTSERVICE +#define RUNTIMESERVICE +#define RUNTIMEFUNCTION + + +#define RUNTIME_CODE(a) alloc_text("rtcode", a) +#define BEGIN_RUNTIME_DATA() data_seg("rtdata") +#define END_RUNTIME_DATA() data_seg("") + +#define VOLATILE volatile + +#define MEMORY_FENCE __sync_synchronize + +// +// When build similiar to FW, then link everything together as +// one big module. +// + +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + InitializeDriver ( \ + VOID *ImageHandle, \ + VOID *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, \ + SystemTable); \ + } \ + \ + EFI_STATUS efi_main( \ + EFI_HANDLE image, \ + EFI_SYSTEM_TABLE *systab \ + ) __attribute__((weak, \ + alias ("InitializeDriver"))); + +#define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, entry) + + +// +// Some compilers don't support the forward reference construct: +// typedef struct XXXXX +// +// The following macro provide a workaround for such cases. + +#define INTERFACE_DECL(x) struct x + +#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__) +#define EFI_FUNCTION + +static inline UINT64 swap_uint64 (UINT64 v) +{ + asm volatile ( + "dsbh %[v], %[v] \n\t" + "dshd %[v], %[v] \n\t" + :[v]"+r"(v) + ); + + return v; +} diff --git a/gnuefi/inc/mips64el/efilibplat.h b/gnuefi/inc/mips64el/efilibplat.h new file mode 100644 index 0000000..70a0786 --- /dev/null +++ b/gnuefi/inc/mips64el/efilibplat.h @@ -0,0 +1,25 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efilibplat.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ + +VOID +InitializeLibPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + diff --git a/gnuefi/inc/mips64el/efisetjmp_arch.h b/gnuefi/inc/mips64el/efisetjmp_arch.h new file mode 100644 index 0000000..e241284 --- /dev/null +++ b/gnuefi/inc/mips64el/efisetjmp_arch.h @@ -0,0 +1,34 @@ +#ifndef GNU_EFI_MIPS64EL_SETJMP_H +#define GNU_EFI_MIPS64EL_SETJMP_H + +#define JMPBUF_ALIGN 8 + +typedef struct { + /* GP regs */ + UINT64 RA; + UINT64 SP; + UINT64 FP; + UINT64 GP; + UINT64 S0; + UINT64 S1; + UINT64 S2; + UINT64 S3; + UINT64 S4; + UINT64 S5; + UINT64 S6; + UINT64 S7; + +#ifdef __mips_hard_float + /* FP regs */ + UINT64 F24; + UINT64 F25; + UINT64 F26; + UINT64 F27; + UINT64 F28; + UINT64 F29; + UINT64 F30; + UINT64 F31; +#endif +} EFI_ALIGN(JMPBUF_ALIGN) jmp_buf[1]; + +#endif /* GNU_EFI_MIPS64EL_SETJMP_H */ diff --git a/gnuefi/inc/pci22.h b/gnuefi/inc/pci22.h new file mode 100644 index 0000000..b94f519 --- /dev/null +++ b/gnuefi/inc/pci22.h @@ -0,0 +1,193 @@ +#ifndef _PCI22_H +#define _PCI22_H + +/*++ + +Copyright (c) 1999 Intel Corporation + +Module Name: + + pci22.h + +Abstract: + Support for PCI 2.2 standard. + + + + +Revision History + +--*/ + +#ifdef SOFT_SDV +#define PCI_MAX_BUS 1 +#else +#define PCI_MAX_BUS 255 +#endif + +#define PCI_MAX_DEVICE 31 +#define PCI_MAX_FUNC 7 + +// +// Command +// +#define PCI_VGA_PALETTE_SNOOP_DISABLED 0x20 + +#pragma pack(1) +typedef struct { + UINT16 VendorId; + UINT16 DeviceId; + UINT16 Command; + UINT16 Status; + UINT8 RevisionID; + UINT8 ClassCode[3]; + UINT8 CacheLineSize; + UINT8 LaytencyTimer; + UINT8 HeaderType; + UINT8 BIST; +} PCI_DEVICE_INDEPENDENT_REGION; + +typedef struct { + UINT32 Bar[6]; + UINT32 CISPtr; + UINT16 SubsystemVendorID; + UINT16 SubsystemID; + UINT32 ExpansionRomBar; + UINT32 Reserved[2]; + UINT8 InterruptLine; + UINT8 InterruptPin; + UINT8 MinGnt; + UINT8 MaxLat; +} PCI_DEVICE_HEADER_TYPE_REGION; + +typedef struct { + PCI_DEVICE_INDEPENDENT_REGION Hdr; + PCI_DEVICE_HEADER_TYPE_REGION Device; +} PCI_TYPE00; + +typedef struct { + UINT32 Bar[2]; + UINT8 PrimaryBus; + UINT8 SecondaryBus; + UINT8 SubordinateBus; + UINT8 SecondaryLatencyTimer; + UINT8 IoBase; + UINT8 IoLimit; + UINT16 SecondaryStatus; + UINT16 MemoryBase; + UINT16 MemoryLimit; + UINT16 PrefetchableMemoryBase; + UINT16 PrefetchableMemoryLimit; + UINT32 PrefetchableBaseUpper32; + UINT32 PrefetchableLimitUpper32; + UINT16 IoBaseUpper16; + UINT16 IoLimitUpper16; + UINT32 Reserved; + UINT32 ExpansionRomBAR; + UINT8 InterruptLine; + UINT8 InterruptPin; + UINT16 BridgeControl; +} PCI_BRIDGE_CONTROL_REGISTER; + +#define PCI_CLASS_DISPLAY_CTRL 0x03 +#define PCI_CLASS_VGA 0x00 + +#define PCI_CLASS_BRIDGE 0x06 +#define PCI_CLASS_ISA 0x01 +#define PCI_CLASS_ISA_POSITIVE_DECODE 0x80 + +#define PCI_CLASS_NETWORK 0x02 +#define PCI_CLASS_ETHERNET 0x00 + +#define HEADER_TYPE_DEVICE 0x00 +#define HEADER_TYPE_PCI_TO_PCI_BRIDGE 0x01 +#define HEADER_TYPE_MULTI_FUNCTION 0x80 +#define HEADER_LAYOUT_CODE 0x7f + +#define IS_PCI_BRIDGE(_p) ((((_p)->Hdr.HeaderType) & HEADER_LAYOUT_CODE) == HEADER_TYPE_PCI_TO_PCI_BRIDGE) +#define IS_PCI_MULTI_FUNC(_p) (((_p)->Hdr.HeaderType) & HEADER_TYPE_MULTI_FUNCTION) + +typedef struct { + PCI_DEVICE_INDEPENDENT_REGION Hdr; + PCI_BRIDGE_CONTROL_REGISTER Bridge; +} PCI_TYPE01; + +typedef struct { + UINT8 Register; + UINT8 Function; + UINT8 Device; + UINT8 Bus; + UINT8 Reserved[4]; +} DEFIO_PCI_ADDR; + +typedef struct { + UINT32 Reg : 8; + UINT32 Func : 3; + UINT32 Dev : 5; + UINT32 Bus : 8; + UINT32 Reserved: 7; + UINT32 Enable : 1; +} PCI_CONFIG_ACCESS_CF8; + +#pragma pack() + +#define EFI_ROOT_BRIDGE_LIST 'eprb' +typedef struct { + UINTN Signature; + + UINT16 BridgeNumber; + UINT16 PrimaryBus; + UINT16 SubordinateBus; + + EFI_DEVICE_PATH *DevicePath; + + LIST_ENTRY Link; +} PCI_ROOT_BRIDGE_ENTRY; + + +#define PCI_EXPANSION_ROM_HEADER_SIGNATURE 0xaa55 +#define EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE 0x0EF1 +#define PCI_DATA_STRUCTURE_SIGNATURE EFI_SIGNATURE_32('P','C','I','R') + +#pragma pack(1) +typedef struct { + UINT16 Signature; // 0xaa55 + UINT8 Reserved[0x16]; + UINT16 PcirOffset; +} PCI_EXPANSION_ROM_HEADER; + + +typedef struct { + UINT16 Signature; // 0xaa55 + UINT16 InitializationSize; + UINT16 EfiSignature; // 0x0EF1 + UINT16 EfiSubsystem; + UINT16 EfiMachineType; + UINT8 Reserved[0x0A]; + UINT16 EfiImageHeaderOffset; + UINT16 PcirOffset; +} EFI_PCI_EXPANSION_ROM_HEADER; + +typedef struct { + UINT32 Signature; // "PCIR" + UINT16 VendorId; + UINT16 DeviceId; + UINT16 Reserved0; + UINT16 Length; + UINT8 Revision; + UINT8 ClassCode[3]; + UINT16 ImageLength; + UINT16 CodeRevision; + UINT8 CodeType; + UINT8 Indicator; + UINT16 Reserved1; +} PCI_DATA_STRUCTURE; +#pragma pack() + +#endif + + + + + + diff --git a/gnuefi/inc/protocol/adapterdebug.h b/gnuefi/inc/protocol/adapterdebug.h new file mode 100644 index 0000000..d70af5d --- /dev/null +++ b/gnuefi/inc/protocol/adapterdebug.h @@ -0,0 +1,32 @@ +#ifndef _ADAPTER_DEBUG_H +#define _ADAPTER_DEBUG_H + +/*++ + +Copyright (c) 1999 Intel Corporation + +Module Name: + + AdapterDebug.h + +Abstract: + + Protocol to debug the EDD 3.0 enablement of BIOS option ROMs + + + +Revision History + +--*/ + +// {82F86881-282B-11d4-BC7D-0080C73C8881} +#define ADAPTER_DEBUG_PROTOCOL \ +{ 0x82f86881, 0x282b, 0x11d4, {0xbc, 0x7d, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} } + +// +// This protocol points to the BIOS_LEGACY_DRIVE data structure +// see edd.h for more details +// + +#endif + diff --git a/gnuefi/inc/protocol/eficonsplit.h b/gnuefi/inc/protocol/eficonsplit.h new file mode 100644 index 0000000..15adb92 --- /dev/null +++ b/gnuefi/inc/protocol/eficonsplit.h @@ -0,0 +1,32 @@ +#ifndef _EFI_CONFORK_H +#define _EFI_CONFORK_H +/*++ + +Copyright (c) 1999 Intel Corporation + +Module Name: + +Abstract: + + + +Revision History + +--*/ + + + +// +// ConOut Forker Protocol +// + +#define TEXT_OUT_SPLITER_PROTOCOL \ + { 0x56d830a0, 0x7e7a, 0x11d3, {0xbb, 0xa0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } + +#define ERROR_OUT_SPLITER_PROTOCOL \ + { 0xf0ba9039, 0x68f1, 0x425e, {0xaa, 0x7f, 0xd9, 0xaa, 0xf9, 0x1b, 0x82, 0xa1}} + +#define TEXT_IN_SPLITER_PROTOCOL \ + { 0xf9a3c550, 0x7fb5, 0x11d3, {0xbb, 0xa0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } + +#endif diff --git a/gnuefi/inc/protocol/efidbg.h b/gnuefi/inc/protocol/efidbg.h new file mode 100644 index 0000000..1f95a70 --- /dev/null +++ b/gnuefi/inc/protocol/efidbg.h @@ -0,0 +1,210 @@ +/* + * Copyright (c) 1999, 2000 + * Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * + * This product includes software developed by Intel Corporation and + * its contributors. + * + * 4. Neither the name of Intel Corporation or its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + */ + + +#ifndef _EFIDBG_H_ +#define _EFIDBG_H_ + +#include "eficontext.h" +#include "efiser.h" + +typedef struct _DEBUGPORT_16550_CONFIG_DATA { + UINT32 PortAddress; + UINT64 BaudRate; + UINT32 ReceiveFifoDepth; + UINT32 Timeout; + UINT8 Parity; + UINT8 DataBits; + UINT8 StopBits; + UINT32 ControlMask; + BOOLEAN RtsCtsEnable; // RTS, CTS control +} DEBUGPORT_16550_CONFIG_DATA; + +typedef struct _DEBUGPORT_16550_DEVICE_PATH { + EFI_DEVICE_PATH Header; + DEBUGPORT_16550_CONFIG_DATA ConfigData; +} DEBUGPORT_16550_DEVICE_PATH; + +typedef union { + EFI_DEVICE_PATH DevPath; + DEBUGPORT_16550_DEVICE_PATH Uart; + // add new types of debugport device paths to this union... +} DEBUGPORT_DEV_PATH; + + +// +// Debug Support protocol {2755590C-6F3C-42FA-9EA4-A3BA543CDA25} +// + +#define DEBUG_SUPPORT_PROTOCOL \ +{ 0x2755590C, 0x6F3C, 0x42fa, 0x9E, 0xA4, 0xA3, 0xBA, 0x54, 0x3C, 0xDA, 0x25 } + + +typedef UINTN EXCEPTION_TYPE; + +typedef +VOID +(*EXCEPTION_HANDLER) ( + IN EXCEPTION_TYPE ExceptionType, + IN SYSTEM_CONTEXT *SystemContext + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_REGISTER_TIMER_TICK_CALLBACK) ( + IN struct _EFI_DEBUG_SUPPORT_INTERFACE *This, + IN EXCEPTION_HANDLER TimerTickCallback + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_REGISTER_EXCEPTION_HANDLER) ( + IN struct _EFI_DEBUG_SUPPORT_INTERFACE *This, + IN EXCEPTION_HANDLER ExceptionHandler, + IN EXCEPTION_TYPE ExceptionType + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_IP_CALL_TRACE) ( + IN struct _EFI_DEBUG_SUPPORT_INTERFACE *This + ); + + +#define EFI_DEBUG_SUPPORT_INTERFACE_REVISION 0x00010000 + +typedef struct _EFI_DEBUG_SUPPORT_INTERFACE { + UINT32 Revision; + EFI_REGISTER_TIMER_TICK_CALLBACK RegisterTimerTickCallback; + EFI_REGISTER_EXCEPTION_HANDLER RegisterExceptionHandler; + EFI_IP_CALL_TRACE IpCallTrace; +} EFI_DEBUG_SUPPORT_INTERFACE; + + +// +// Debugport io protocol {EBA4E8D2-3858-41EC-A281-2647BA9660D0} +// + +#define DEBUGPORT_IO_PROTOCOL \ +{ 0XEBA4E8D2, 0X3858, 0X41EC, 0XA2, 0X81, 0X26, 0X47, 0XBA, 0X96, 0X60, 0XD0 } + + +typedef +EFI_STATUS +(EFIAPI *EFI_DEBUGPORT_IO_RESET) ( + IN struct _EFI_DEBUGPORT_IO_INTERFACE *This + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_DEBUGPORT_IO_READ) ( + IN struct _EFI_DEBUGPORT_IO_INTERFACE *This, + IN OUT UINTN *BufferSize, + OUT VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_DEBUGPORT_IO_WRITE) ( + IN struct _EFI_DEBUGPORT_IO_INTERFACE *This, + IN OUT UINTN *BufferSize, + IN VOID *Buffer + ); + +#define EFI_DEBUGPORT_IO_INTERFACE_REVISION 0x00010000 + +typedef struct _EFI_DEBUGPORT_IO_INTERFACE { + UINT32 Revision; + EFI_DEBUGPORT_IO_READ Read; + EFI_DEBUGPORT_IO_WRITE Write; + EFI_DEBUGPORT_IO_RESET Reset; +} EFI_DEBUGPORT_IO_INTERFACE; + + +// +// Debugport UART16550 control protocol {628EA978-4C26-4605-BC02-A42A496917DD} +// + +#define DEBUGPORT_UART16550_CONTROL_PROTOCOL \ +{ 0X628EA978, 0X4C26, 0X4605, 0XBC, 0X2, 0XA4, 0X2A, 0X49, 0X69, 0X17, 0XDD } + +// Note: The definitions for EFI_PARITY_TYPE, EFI_STOP_BITS_TYPE, and +// SERIAL_IO_MODE are included from efiser.h + +typedef +EFI_STATUS +(EFIAPI *EFI_UART16550_SET_ATTRIBUTES) ( + IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE *This, + IN UINT64 BaudRate, + IN UINT32 ReceiveFifoDepth, + IN UINT32 Timeout, + IN EFI_PARITY_TYPE Parity, + IN UINT8 DataBits, + IN EFI_STOP_BITS_TYPE StopBits + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UART16550_SET_CONTROL_BITS) ( + IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE *This, + IN UINT32 Control + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_UART16550_GET_CONTROL_BITS) ( + IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE *This, + OUT UINT32 *Control + ); + +#define EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE_REVISION 0x00010000 + +typedef struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE { + UINT32 Revision; + EFI_UART16550_SET_ATTRIBUTES SetAttributes; + EFI_UART16550_SET_CONTROL_BITS SetControl; + EFI_UART16550_GET_CONTROL_BITS GetControl; + DEBUGPORT_16550_CONFIG_DATA *Mode; +} EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE; + + +#define DEVICE_PATH_DEBUGPORT DEBUGPORT_IO_PROTOCOL + +#endif /* _EFIDBG_H_ */ diff --git a/gnuefi/inc/protocol/efivar.h b/gnuefi/inc/protocol/efivar.h new file mode 100644 index 0000000..92dc506 --- /dev/null +++ b/gnuefi/inc/protocol/efivar.h @@ -0,0 +1,133 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + +Abstract: + + + +Revision History + +--*/ + + + +// +// The variable store protocol interface is specific to the reference +// implementation. The initialization code adds variable store devices +// to the system, and the FW connects to the devices to provide the +// variable store interfaces through these devices. +// + +// +// Variable Store Device protocol +// + +#define VARIABLE_STORE_PROTOCOL \ + { 0xf088cd91, 0xa046, 0x11d2, {0x8e, 0x42, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } + +INTERFACE_DECL(_EFI_VARIABLE_STORE); + +typedef +EFI_STATUS +(EFIAPI *EFI_STORE_CLEAR) ( + IN struct _EFI_VARIABLE_STORE *This, + IN UINTN BankNo, + IN OUT VOID *Scratch + ); + + +typedef +EFI_STATUS +(EFIAPI *EFI_STORE_READ) ( + IN struct _EFI_VARIABLE_STORE *This, + IN UINTN BankNo, + IN UINTN Offset, + IN UINTN BufferSize, + OUT VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_STORE_UPDATE) ( + IN struct _EFI_VARIABLE_STORE *This, + IN UINTN BankNo, + IN UINTN Offset, + IN UINTN BufferSize, + IN VOID *Buffer + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_STORE_SIZE) ( + IN struct _EFI_VARIABLE_STORE *This, + IN UINTN NoBanks + ); + +typedef +EFI_STATUS +(EFIAPI *EFI_TRANSACTION_UPDATE) ( + IN struct _EFI_VARIABLE_STORE *This, + IN UINTN BankNo, + IN VOID *NewContents + ); + +typedef struct _EFI_VARIABLE_STORE { + + // + // Number of banks and bank size + // + + UINT32 Attributes; + UINT32 BankSize; + UINT32 NoBanks; + + // + // Functions to access the storage banks + // + + EFI_STORE_CLEAR ClearStore; + EFI_STORE_READ ReadStore; + EFI_STORE_UPDATE UpdateStore; + EFI_STORE_SIZE SizeStore OPTIONAL; + EFI_TRANSACTION_UPDATE TransactionUpdate OPTIONAL; + +} EFI_VARIABLE_STORE; + + +// +// +// ClearStore() - A function to clear the requested storage bank. A cleared +// bank contains all "on" bits. +// +// ReadStore() - Read data from the requested store. +// +// UpdateStore() - Updates data on the requested store. The FW will only +// ever issue updates to clear bits in the store. Updates must be +// performed in LSb to MSb order of the update buffer. +// +// SizeStore() - An optional function for non-runtime stores that can be +// dynamically sized. The FW will only ever increase or decrease the store +// by 1 banksize at a time, and it is always adding or removing a bank from +// the end of the store. +// +// By default the FW will update variables and storage banks in an +// "atomic" manner by keeping 1 old copy of the data during an update, +// and recovering appropiately if the power is lost during the middle +// of an operation. To do this the FW needs to have multiple banks +// of storage dedicated to its use. If that's not possible, the driver +// can implement an atomic bank update function and the FW will allow +// 1 bank in this case. (It will allow any number of banks, +// but it won't require an "extra" bank to provide its bank transaction +// function). +// +// TransactionUpdate() - An optional function that can clear & update an +// entire bank in an "atomic" fashion. If the operation fails in the +// middle the driver is responsible for having either the previous copy +// of the bank's data or the new copy. A copy that's partially written +// is not valid as internal data settings may get lost. Supply this +// function only when needed. +// + diff --git a/gnuefi/inc/protocol/ia64/eficontext.h b/gnuefi/inc/protocol/ia64/eficontext.h new file mode 100644 index 0000000..1a39a6d --- /dev/null +++ b/gnuefi/inc/protocol/ia64/eficontext.h @@ -0,0 +1,208 @@ +/* + * Copyright (c) 1999, 2000 + * Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * + * This product includes software developed by Intel Corporation and + * its contributors. + * + * 4. Neither the name of Intel Corporation or its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + */ + + +#ifndef _EFICONTEXT_H_ +#define _EFICONTEXT_H_ + + +// +// IA-64 processor exception types +// +#define EXCPT_ALT_DTLB 4 +#define EXCPT_DNESTED_TLB 5 +#define EXCPT_BREAKPOINT 11 +#define EXCPT_EXTERNAL_INTERRUPT 12 +#define EXCPT_GEN_EXCEPT 24 +#define EXCPT_NAT_CONSUMPTION 26 +#define EXCPT_DEBUG_EXCEPT 29 +#define EXCPT_UNALIGNED_ACCESS 30 +#define EXCPT_FP_FAULT 32 +#define EXCPT_FP_TRAP 33 +#define EXCPT_TAKEN_BRANCH 35 +#define EXCPT_SINGLE_STEP 36 + +// +// IA-64 processor context definition - must be 512 byte aligned!!! +// +typedef +struct { + UINT64 reserved; // necessary to preserve alignment for the correct bits in UNAT and to insure F2 is 16 byte aligned... + + UINT64 r1; + UINT64 r2; + UINT64 r3; + UINT64 r4; + UINT64 r5; + UINT64 r6; + UINT64 r7; + UINT64 r8; + UINT64 r9; + UINT64 r10; + UINT64 r11; + UINT64 r12; + UINT64 r13; + UINT64 r14; + UINT64 r15; + UINT64 r16; + UINT64 r17; + UINT64 r18; + UINT64 r19; + UINT64 r20; + UINT64 r21; + UINT64 r22; + UINT64 r23; + UINT64 r24; + UINT64 r25; + UINT64 r26; + UINT64 r27; + UINT64 r28; + UINT64 r29; + UINT64 r30; + UINT64 r31; + + UINT64 f2[2]; + UINT64 f3[2]; + UINT64 f4[2]; + UINT64 f5[2]; + UINT64 f6[2]; + UINT64 f7[2]; + UINT64 f8[2]; + UINT64 f9[2]; + UINT64 f10[2]; + UINT64 f11[2]; + UINT64 f12[2]; + UINT64 f13[2]; + UINT64 f14[2]; + UINT64 f15[2]; + UINT64 f16[2]; + UINT64 f17[2]; + UINT64 f18[2]; + UINT64 f19[2]; + UINT64 f20[2]; + UINT64 f21[2]; + UINT64 f22[2]; + UINT64 f23[2]; + UINT64 f24[2]; + UINT64 f25[2]; + UINT64 f26[2]; + UINT64 f27[2]; + UINT64 f28[2]; + UINT64 f29[2]; + UINT64 f30[2]; + UINT64 f31[2]; + + UINT64 pr; + + UINT64 b0; + UINT64 b1; + UINT64 b2; + UINT64 b3; + UINT64 b4; + UINT64 b5; + UINT64 b6; + UINT64 b7; + + // application registers + UINT64 ar_rsc; + UINT64 ar_bsp; + UINT64 ar_bspstore; + UINT64 ar_rnat; + + UINT64 ar_fcr; + + UINT64 ar_eflag; + UINT64 ar_csd; + UINT64 ar_ssd; + UINT64 ar_cflg; + UINT64 ar_fsr; + UINT64 ar_fir; + UINT64 ar_fdr; + + UINT64 ar_ccv; + + UINT64 ar_unat; + + UINT64 ar_fpsr; + + UINT64 ar_pfs; + UINT64 ar_lc; + UINT64 ar_ec; + + // control registers + UINT64 cr_dcr; + UINT64 cr_itm; + UINT64 cr_iva; + UINT64 cr_pta; + UINT64 cr_ipsr; + UINT64 cr_isr; + UINT64 cr_iip; + UINT64 cr_ifa; + UINT64 cr_itir; + UINT64 cr_iipa; + UINT64 cr_ifs; + UINT64 cr_iim; + UINT64 cr_iha; + + // debug registers + UINT64 dbr0; + UINT64 dbr1; + UINT64 dbr2; + UINT64 dbr3; + UINT64 dbr4; + UINT64 dbr5; + UINT64 dbr6; + UINT64 dbr7; + + UINT64 ibr0; + UINT64 ibr1; + UINT64 ibr2; + UINT64 ibr3; + UINT64 ibr4; + UINT64 ibr5; + UINT64 ibr6; + UINT64 ibr7; + + // virtual registers + UINT64 int_nat; // nat bits for R1-R31 + +} SYSTEM_CONTEXT; + +#endif /* _EFI_CONTEXT_H_ */ diff --git a/gnuefi/inc/protocol/intload.h b/gnuefi/inc/protocol/intload.h new file mode 100644 index 0000000..fb24e3f --- /dev/null +++ b/gnuefi/inc/protocol/intload.h @@ -0,0 +1,27 @@ +/*++ + +Copyright (c) 1999 Intel Corporation + +Module Name: + + intload + +Abstract: + + EFI support for loading internally linked in apps + + + +Revision History + +--*/ + +#ifndef _INTERNAL_LOAD_INCLUDE_ +#define _INTERNAL_LOAD_INCLUDE_ + +// {D65A6B8C-71E5-4df0-A909-F0D2992B5AA9} +#define INTERNAL_SHELL_GUID \ + { 0xd65a6b8c, 0x71e5, 0x4df0, {0xa9, 0x09, 0xf0, 0xd2, 0x99, 0x2b, 0x5a, 0xa9} } + + +#endif diff --git a/gnuefi/inc/protocol/legacyboot.h b/gnuefi/inc/protocol/legacyboot.h new file mode 100644 index 0000000..16e94e7 --- /dev/null +++ b/gnuefi/inc/protocol/legacyboot.h @@ -0,0 +1,119 @@ +/*++ + +Copyright (c) 1999 Intel Corporation + +Module Name: + + legacyboot + +Abstract: + + EFI support for legacy boot + + + +Revision History + +--*/ + +#ifndef _LEGACY_BOOT_INCLUDE_ +#define _LEGACY_BOOT_INCLUDE_ + +#define LEGACY_BOOT_PROTOCOL \ + { 0x376e5eb2, 0x30e4, 0x11d3, { 0xba, 0xe5, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } } + +#pragma pack(1) + +// +// BBS 1.01 (See Appendix A) IPL and BCV Table Entry Data structure. +// Seg:Off pointers have been converted to EFI pointers in this data structure +// This is the structure that also maps to the EFI device path for the boot selection +// +typedef struct { + UINT16 DeviceType; + UINT16 StatusFlag; + UINT32 Reserved; + VOID *BootHandler; // Not an EFI entry point + CHAR8 *DescString; +} BBS_TABLE_ENTRY; +#pragma pack() + +typedef +EFI_STATUS +(EFIAPI *LEGACY_BOOT_CALL) ( + IN EFI_DEVICE_PATH *DevicePath + ); + + +// +// BBS support functions +// PnP Call numbers and BiosSelector hidden in implementation +// + +typedef enum { + IplRelative, + BcvRelative +} BBS_TYPE; + +INTERFACE_DECL(_LEGACY_BOOT_INTERFACE); + +// +// == PnP Function 0x60 then BbsVersion == 0x0101 if this call fails then BbsVersion == 0x0000 +// + +// +// == PnP Function 0x61 +// +typedef +EFI_STATUS +(EFIAPI *GET_DEVICE_COUNT) ( + IN struct _LEGACY_BOOT_INTERFACE *This, + IN BBS_TYPE *TableType, + OUT UINTN *DeviceCount, + OUT UINTN *MaxCount + ); + +// +// == PnP Function 0x62 +// +typedef +EFI_STATUS +(EFIAPI *GET_PRIORITY_AND_TABLE) ( + IN struct _LEGACY_BOOT_INTERFACE *This, + IN BBS_TYPE *TableType, + IN OUT UINTN *PrioritySize, // MaxCount * sizeof(UINT8) + OUT UINTN *Priority, + IN OUT UINTN *TableSize, // MaxCount * sizeof(BBS_TABLE_ENTRY) + OUT BBS_TABLE_ENTRY *TableEntrySize + ); + +// +// == PnP Function 0x63 +// +typedef +EFI_STATUS +(EFIAPI *SET_PRIORITY) ( + IN struct _LEGACY_BOOT_INTERFACE *This, + IN BBS_TYPE *TableType, + IN OUT UINTN *PrioritySize, + OUT UINTN *Priority + ); + +typedef struct _LEGACY_BOOT_INTERFACE { + LEGACY_BOOT_CALL BootIt; + + // + // New functions to allow BBS booting to be configured from EFI + // + UINTN BbsVersion; // Currently 0x0101 + GET_DEVICE_COUNT GetDeviceCount; + GET_PRIORITY_AND_TABLE GetPriorityAndTable; + SET_PRIORITY SetPriority; +} LEGACY_BOOT_INTERFACE; + +EFI_STATUS +PlInitializeLegacyBoot ( + VOID + ); + +#endif diff --git a/gnuefi/inc/protocol/make.inf b/gnuefi/inc/protocol/make.inf new file mode 100644 index 0000000..f3bb907 --- /dev/null +++ b/gnuefi/inc/protocol/make.inf @@ -0,0 +1,13 @@ +# +# +# + +[sources] + efivar.h + legacyboot.h + VgaClass.h + intload.h + +[ia32sources] + +[ia64sources] diff --git a/gnuefi/inc/protocol/makefile.hdr b/gnuefi/inc/protocol/makefile.hdr new file mode 100644 index 0000000..118d6ba --- /dev/null +++ b/gnuefi/inc/protocol/makefile.hdr @@ -0,0 +1,29 @@ + +# +# This is a machine generated file - DO NOT EDIT +# Generated by genmake.exe +# Generated from make.inf +# Copyright (c) 1998 Intel Corporation +# + +INC_DEPS = $(INC_DEPS) \ + $(SDK_INSTALL_DIR)\include\efi\protocol\efivar.h \ + $(SDK_INSTALL_DIR)\include\efi\protocol\legacyboot.h \ + $(SDK_INSTALL_DIR)\include\efi\protocol\vgaclass.h \ + $(SDK_INSTALL_DIR)\include\efi\protocol\efidbg.h \ + + +!IF "$(PROCESSOR)" == "Ia32" +INC_DEPS = $(INC_DEPS) \ + + +!ENDIF + + +!IF "$(PROCESSOR)" == "Ia64" +INC_DEPS = $(INC_DEPS) \ + $(SDK_INSTALL_DIR)\include\efi\protocol\$(PROCESSOR)\eficontext.h \ + + +!ENDIF + diff --git a/gnuefi/inc/protocol/piflash64.h b/gnuefi/inc/protocol/piflash64.h new file mode 100644 index 0000000..d521dfc --- /dev/null +++ b/gnuefi/inc/protocol/piflash64.h @@ -0,0 +1,121 @@ +#ifndef _PIFLASH64_H +#define _PIFLASH64_H + +/*++ + +Copyright (c) 1999 Intel Corporation + +Module Name: + + PIflash64.h + +Abstract: + + Iflash64.efi protocol to abstract iflash from + the system. + +Revision History + +--*/ + +// +// Guid that identifies the IFLASH protocol +// +#define IFLASH64_PROTOCOL_PROTOCOL \ + { 0x65cba110, 0x74ab, 0x11d3, 0xbb, 0x89, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 }; + +// +// Unlock FLASH from StartAddress to EndAddress and return a LockKey +// +typedef +EFI_STATUS +(EFIAPI *UNLOCK_FLASH_API)( + IN struct _IFLASH64_PROTOCOL_INTERFACE *This + ); + +// +// Lock the flash represented by the LockKey +// +typedef +EFI_STATUS +(EFIAPI *LOCK_FLASH_API)( + IN struct _IFLASH64_PROTOCOL_INTERFACE *This + ); + +// +// Status callback for a utility like IFLASH64 +// +// Token would map to a list like Ted proposed. The utility has no idea what +// happens on the other side. +// ErrorStatus - Level of Error or success. Independent of Token. If you +// don't know the token you will at least know pass or fail. +// String - Optional extra information about the error. Could be used for +// debug or future expansion +// +// Attributes - Options screen attributes for String. Could allow the string to be different colors. +// +typedef +EFI_STATUS +(EFIAPI *UTILITY_PROGRESS_API)( + IN struct _IFLASH64_PROTOCOL_INTERFACE *This, + IN UINTN Token, + IN EFI_STATUS ErrorStatus, + IN CHAR16 *String, OPTIONAL + IN UINTN *Attributes OPTIONAL + ); + +// +// Token Values +// +// IFlash64 Token Codes +#define IFLASH_TOKEN_IFLASHSTART 0xB0 // IFlash64 has started +#define IFLASH_TOKEN_READINGFILE 0xB1 // Reading File +#define IFLASH_TOKEN_INITVPP 0xB2 // Initializing Vpp +#define IFLASH_TOKEN_DISABLEVPP 0x10 // Disable Vpp +#define IFLASH_TOKEN_FLASHUNLOCK 0xB3 // Unlocking FLASH Devices +#define IFLASH_TOKEN_FLASHERASE 0xB4 // Erasing FLASH Devices +#define IFLASH_TOKEN_FLASHPROGRAM 0xB5 // Programming FLASH +#define IFLASH_TOKEN_FLASHVERIFY 0xB6 // Verifying FLASH +#define IFLASH_TOKEN_UPDATESUCCES 0xB7 // FLASH Updage Success! + +#define IFLASH_TOKEN_PROGRESS_READINGFILE 0x11 // % Reading File +#define IFLASH_TOKEN_PROGRESS_FLASHUNLOCK 0x13 // % Unlocking FLASH Devices +#define IFLASH_TOKEN_PROGRESS_FLASHERASE 0x14 // % Erasing FLASH Devices +#define IFLASH_TOKEN_PROGRESS_FLASHPROGRAM 0x15 // % Programming FLASH +#define IFLASH_TOKEN_PROGRESS_FLASHVERIFY 0x16 // % Verifying FLASH + +#define IFLASH_TOKEN_READINGFILE_ER 0xB8 // File Read Error +#define IFLASH_TOKEN_INITVPP_ER 0xB9 // Initialization of IFB Error +#define IFLASH_TOKEN_FLASHUNLOCK_ER 0xBA // FLASH Unlock Error +#define IFLASH_TOKEN_FLASHERASE_ER 0xBB // FLASH Erase Error +#define IFLASH_TOKEN_FLASHVERIFY_ER 0xBC // FLASH Verify Error +#define IFLASH_TOKEN_FLASHPROG_ER 0xBD // FLASH Program Error + +#define IFLASH_TABLE_END 0x00 + +// +// If this number changes one of the existing API's has changes +// +#define IFLASH_PI_MAJOR_VERSION 0x01 + +// +// This number changes when new APIs or data variables get added to the end +// of the data structure +// +#define IFLASH_PI_MINOR_VERSION 0x01 + +typedef struct _IFLASH64_PROTOCOL_INTERFACE { + UINT32 MajorVersion; + UINT32 MinorVersion; + UNLOCK_FLASH_API UnlockFlash; + LOCK_FLASH_API LockFlash; + UTILITY_PROGRESS_API Progress; + + // + // Future expansion goes here + // + +} IFLASH64_PROTOCOL_INTERFACE; + + +#endif diff --git a/gnuefi/inc/protocol/readme.txt b/gnuefi/inc/protocol/readme.txt new file mode 100644 index 0000000..66e155c --- /dev/null +++ b/gnuefi/inc/protocol/readme.txt @@ -0,0 +1,3 @@ +The protocol directory contains non Architectural +Protocols that span the FW, Platform, or application +space. \ No newline at end of file diff --git a/gnuefi/inc/protocol/vgaclass.h b/gnuefi/inc/protocol/vgaclass.h new file mode 100644 index 0000000..d0deb5c --- /dev/null +++ b/gnuefi/inc/protocol/vgaclass.h @@ -0,0 +1,95 @@ +#ifndef _VGA_CLASS_H +#define _VGA_CLASS_H + +/*++ + +Copyright (c) 1999 Intel Corporation + +Module Name: + + VgaClass.h + +Abstract: + + Vga Mini port binding to Vga Class protocol + + + +Revision History + +--*/ + +// +// VGA Device Structure +// + +// {0E3D6310-6FE4-11d3-BB81-0080C73C8881} +#define VGA_CLASS_DRIVER_PROTOCOL \ + { 0xe3d6310, 0x6fe4, 0x11d3, {0xbb, 0x81, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} } + +typedef +EFI_STATUS +(* INIT_VGA_CARD) ( + IN UINTN VgaMode, + IN VOID *Context + ); + +typedef struct { + UINTN MaxColumns; + UINTN MaxRows; +} MAX_CONSOLE_GEOMETRY; + +#define VGA_CON_OUT_DEV_SIGNATURE EFI_SIGNATURE_32('c','v','g','a') +typedef struct { + UINTN Signature; + + EFI_HANDLE Handle; + SIMPLE_TEXT_OUTPUT_INTERFACE ConOut; + SIMPLE_TEXT_OUTPUT_MODE ConOutMode; + EFI_DEVICE_PATH *DevicePath; + + UINT8 *Buffer; + EFI_DEVICE_IO_INTERFACE *DeviceIo; + + // + // Video Card Context + // + INIT_VGA_CARD InitVgaCard; + VOID *VgaCardContext; + MAX_CONSOLE_GEOMETRY *Geometry; + // + // Video buffer normally 0xb8000 + // + UINT64 VideoBuffer; + + // + // Clear Screen & Default Attribute + // + UINT32 Attribute; + + // + // -1 means search for active VGA device + // + EFI_PCI_ADDRESS_UNION Pci; +} VGA_CON_OUT_DEV; + +#define VGA_CON_OUT_DEV_FROM_THIS(a) CR(a, VGA_CON_OUT_DEV, ConOut, VGA_CON_OUT_DEV_SIGNATURE) + +// +// Vga Class Driver Protocol. +// GUID defined in EFI Lib +// + +typedef +EFI_STATUS +(EFIAPI *INSTALL_VGA_DRIVER) ( + IN VGA_CON_OUT_DEV *ConOutDev + ); + +typedef struct { + UINT32 Version; + INSTALL_VGA_DRIVER InstallGenericVgaDriver; +} INSTALL_VGA_DRIVER_INTERFACE; + +#endif + diff --git a/gnuefi/inc/riscv64/efibind.h b/gnuefi/inc/riscv64/efibind.h new file mode 100644 index 0000000..d8b4f39 --- /dev/null +++ b/gnuefi/inc/riscv64/efibind.h @@ -0,0 +1,128 @@ +/* SPDX-License-Identifier: GPL-2.0+ OR BSD-2-Clause */ +/* + * Copright (C) 2014 - 2015 Linaro Ltd. + * Author: Ard Biesheuvel + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice and this list of conditions, without modification. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU General Public License as published by the Free Software Foundation; + * either version 2 of the License, or (at your option) any later version. + */ + +#include + +// +// Basic EFI types of various widths +// + +#include + +typedef uint64_t UINT64; +typedef int64_t INT64; +typedef uint32_t UINT32; +typedef int32_t INT32; +typedef uint16_t UINT16; +typedef int16_t INT16; +typedef uint8_t UINT8; +typedef int8_t INT8; +typedef char CHAR8; +typedef wchar_t CHAR16; +#define WCHAR CHAR16 +#undef VOID +typedef void VOID; +typedef int64_t INTN; +typedef uint64_t UINTN; + +#define EFI_ERROR_MASK 0x8000000000000000 +#define EFIERR(a) (EFI_ERROR_MASK | a) +#define EFIERR_OEM(a) (0xc000000000000000 | a) + +#define BAD_POINTER 0xFBFBFBFBFBFBFBFB +#define MAX_ADDRESS 0xFFFFFFFFFFFFFFFF + +#define BREAKPOINT() while(1); + +// +// Pointers must be aligned to these address to function +// +#define MIN_ALIGNMENT_SIZE 8 + +#define ALIGN_VARIABLE(Value, Adjustment) \ + (UINTN)Adjustment = 0; \ + if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ + (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ + Value = (UINTN)Value + (UINTN)Adjustment + +// +// Define macros to build data structure signatures from characters. +// +#define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) +#define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) +#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) + +// +// EFIAPI - prototype calling convention for EFI function pointers +// BOOTSERVICE - prototype for implementation of a boot service interface +// RUNTIMESERVICE - prototype for implementation of a runtime service interface +// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service +// RUNTIME_CODE - pragma macro for declaring runtime code +// +#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options +#define EFIAPI // Substitute expresion to force C calling convention +#endif +#define BOOTSERVICE +#define RUNTIMESERVICE +#define RUNTIMEFUNCTION +#define RUNTIME_CODE(a) alloc_text("rtcode", a) +#define BEGIN_RUNTIME_DATA() data_seg("rtdata") +#define END_RUNTIME_DATA() data_seg("") + +#define VOLATILE volatile +#define MEMORY_FENCE __sync_synchronize + +// +// When build similiar to FW, then link everything together as +// one big module. For the MSVC toolchain, we simply tell the +// linker what our driver init function is using /ENTRY. +// +#if defined(_MSC_EXTENSIONS) +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + __pragma(comment(linker, "/ENTRY:" # InitFunction)) +#else +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + InitializeDriver ( \ + VOID *ImageHandle, \ + VOID *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, \ + SystemTable); \ + } \ + \ + EFI_STATUS efi_main( \ + EFI_HANDLE image, \ + EFI_SYSTEM_TABLE *systab \ + ) __attribute__((weak, \ + alias ("InitializeDriver"))); +#endif + +#define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, entry) + +// +// Some compilers don't support the forward reference construct: +// typedef struct XXXXX +// +// The following macro provide a workaround for such cases. +#define INTERFACE_DECL(x) struct x + +#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__) +#define EFI_FUNCTION diff --git a/gnuefi/inc/riscv64/efilibplat.h b/gnuefi/inc/riscv64/efilibplat.h new file mode 100644 index 0000000..9b15163 --- /dev/null +++ b/gnuefi/inc/riscv64/efilibplat.h @@ -0,0 +1,7 @@ +/* SPDX-License-Identifier: GPL-2.0+ OR BSD-2-Clause */ + +VOID +InitializeLibPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); diff --git a/gnuefi/inc/riscv64/efisetjmp_arch.h b/gnuefi/inc/riscv64/efisetjmp_arch.h new file mode 100644 index 0000000..bb6f467 --- /dev/null +++ b/gnuefi/inc/riscv64/efisetjmp_arch.h @@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: GPL-2.0+ OR BSD-2-Clause */ + +#ifndef GNU_EFI_RISCV64_SETJMP_H +#define GNU_EFI_RISCV64_SETJMP_H + +#define JMPBUF_ALIGN 8 + +typedef struct { + /* GP regs */ + UINT64 s0; + UINT64 s1; + UINT64 s2; + UINT64 s3; + UINT64 s4; + UINT64 s5; + UINT64 s6; + UINT64 s7; + UINT64 s8; + UINT64 s9; + UINT64 s10; + UINT64 s11; + UINT64 sp; + UINT64 ra; + + /* FP regs */ + UINT64 fs0; + UINT64 fs1; + UINT64 fs2; + UINT64 fs3; + UINT64 fs4; + UINT64 fs5; + UINT64 fs6; + UINT64 fs7; + UINT64 fs8; + UINT64 fs9; + UINT64 fs10; + UINT64 fs11; +} EFI_ALIGN(JMPBUF_ALIGN) jmp_buf[1]; + +#endif /* GNU_EFI_RISCV64_SETJMP_H */ diff --git a/gnuefi/inc/romload.h b/gnuefi/inc/romload.h new file mode 100644 index 0000000..0506011 --- /dev/null +++ b/gnuefi/inc/romload.h @@ -0,0 +1,41 @@ +#ifndef _EFI_ROMLOAD_H +#define _EFI_ROMLOAD_H + +#define ROM_SIGNATURE 0xaa55 +#define PCIDS_SIGNATURE "PCIR" +#pragma pack(push) +#pragma pack(1) +typedef struct +{ + UINT8 Pcids_Sig[4]; + UINT16 VendId; + UINT16 DevId; + UINT16 Vpd_Off; + UINT16 Size; + UINT8 Rev; + UINT8 Class_Code[3]; + UINT16 Image_Len; + UINT16 Rev_Lvl; + UINT8 Code_Type; + UINT8 Indi; + UINT16 Rsvd; +}PciDataStructure; +typedef struct +{ + UINT16 Size; + UINT32 Header_Sig; + UINT16 SubSystem; + UINT16 MachineType; + UINT8 Resvd[10]; + UINT16 EfiOffset; +}ArchData; +typedef struct +{ + UINT16 Rom_Sig; + ArchData Arch_Data; + UINT16 Pcids_Off; + UINT8 resvd[38]; +}RomHeader; +#pragma pack(pop) + +#endif diff --git a/gnuefi/inc/x86_64/efibind.h b/gnuefi/inc/x86_64/efibind.h new file mode 100644 index 0000000..e454ed2 --- /dev/null +++ b/gnuefi/inc/x86_64/efibind.h @@ -0,0 +1,396 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efefind.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ +#ifndef X86_64_EFI_BIND +#define X86_64_EFI_BIND +#ifndef __GNUC__ +#pragma pack() +#endif + +#if defined(_MSC_VER) + #define HAVE_USE_MS_ABI 1 +#elif defined(GNU_EFI_USE_MS_ABI) + #if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)))||(defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 2))) + #define HAVE_USE_MS_ABI 1 + #else + #error Compiler is too old for GNU_EFI_USE_MS_ABI + #endif +#endif + +// +// Basic int types of various widths +// + +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L ) && !defined(__cplusplus) + + // No ANSI C 1999/2000 stdint.h integer width declarations + + #if defined(_MSC_EXTENSIONS) + + // Use Microsoft C compiler integer width declarations + + typedef unsigned __int64 uint64_t; + typedef __int64 int64_t; + typedef unsigned __int32 uint32_t; + typedef __int32 int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef char int8_t; + #elif defined(__GNUC__) + typedef int __attribute__((__mode__(__DI__))) int64_t; + typedef unsigned int __attribute__((__mode__(__DI__))) uint64_t; + typedef unsigned int uint32_t; + typedef int int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef signed char int8_t; + #elif defined(UNIX_LP64) + + /* Use LP64 programming model from C_FLAGS for integer width declarations */ + + typedef unsigned long uint64_t; + typedef long int64_t; + typedef unsigned int uint32_t; + typedef int int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef char int8_t; + #else + + /* Assume P64 programming model from C_FLAGS for integer width declarations */ + + typedef unsigned long long uint64_t __attribute__((aligned (8))); + typedef long long int64_t __attribute__((aligned (8))); + typedef unsigned int uint32_t; + typedef int int32_t; + typedef unsigned short uint16_t; + typedef short int16_t; + typedef unsigned char uint8_t; + typedef char int8_t; + #endif + typedef uint64_t uintptr_t; + typedef int64_t intptr_t; +#else + #include +#endif + +// +// Basic EFI types of various widths +// + +#include + +typedef wchar_t CHAR16; +#define WCHAR CHAR16 + +typedef uint64_t UINT64; +typedef int64_t INT64; + +#ifndef _BASETSD_H_ + typedef uint32_t UINT32; + typedef int32_t INT32; +#endif + +typedef uint16_t UINT16; +typedef int16_t INT16; + +typedef uint8_t UINT8; +typedef char CHAR8; +typedef int8_t INT8; + +#undef VOID +typedef void VOID; + + +typedef int64_t INTN; +typedef uint64_t UINTN; + +#ifdef EFI_NT_EMULATOR + #define POST_CODE(_Data) +#else + #ifdef EFI_DEBUG +#define POST_CODE(_Data) __asm mov eax,(_Data) __asm out 0x80,al + #else + #define POST_CODE(_Data) + #endif +#endif + +#define EFIERR(a) (0x8000000000000000 | a) +#define EFI_ERROR_MASK 0x8000000000000000 +#define EFIERR_OEM(a) (0xc000000000000000 | a) + + +#define BAD_POINTER 0xFBFBFBFBFBFBFBFB +#define MAX_ADDRESS 0xFFFFFFFFFFFFFFFF + +#ifdef EFI_NT_EMULATOR + #define BREAKPOINT() __asm { int 3 } +#else + #define BREAKPOINT() while (TRUE); // Make it hang on Bios[Dbg]32 +#endif + +// +// Pointers must be aligned to these address to function +// + +#define MIN_ALIGNMENT_SIZE 4 + +#define ALIGN_VARIABLE(Value ,Adjustment) \ + (UINTN)Adjustment = 0; \ + if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ + (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ + Value = (UINTN)Value + (UINTN)Adjustment + + +// +// Define macros to build data structure signatures from characters. +// + +#define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) +#define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) +#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) +// +// To export & import functions in the EFI emulator environment +// + +#ifdef EFI_NT_EMULATOR + #define EXPORTAPI __declspec( dllexport ) +#else + #define EXPORTAPI +#endif + + +// +// EFIAPI - prototype calling convention for EFI function pointers +// BOOTSERVICE - prototype for implementation of a boot service interface +// RUNTIMESERVICE - prototype for implementation of a runtime service interface +// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service +// RUNTIME_CODE - pragma macro for declaring runtime code +// + +#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options + #ifdef _MSC_EXTENSIONS + #define EFIAPI __cdecl // Force C calling convention for Microsoft C compiler + #elif defined(HAVE_USE_MS_ABI) + // Force amd64/ms calling conventions. + #define EFIAPI __attribute__((ms_abi)) + #else + #define EFIAPI // Substitute expresion to force C calling convention + #endif +#endif + +#define BOOTSERVICE +//#define RUNTIMESERVICE(proto,a) alloc_text("rtcode",a); proto a +//#define RUNTIMEFUNCTION(proto,a) alloc_text("rtcode",a); proto a +#define RUNTIMESERVICE +#define RUNTIMEFUNCTION + + +#define RUNTIME_CODE(a) alloc_text("rtcode", a) +#define BEGIN_RUNTIME_DATA() data_seg("rtdata") +#define END_RUNTIME_DATA() data_seg("") + +#define VOLATILE volatile + +#define MEMORY_FENCE() + +#ifdef EFI_NT_EMULATOR + +// +// To help ensure proper coding of integrated drivers, they are +// compiled as DLLs. In NT they require a dll init entry pointer. +// The macro puts a stub entry point into the DLL so it will load. +// + +#define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + __stdcall \ + _DllMainCRTStartup ( \ + UINTN Inst, \ + UINTN reason_for_call, \ + VOID *rserved \ + ) \ + { \ + return 1; \ + } \ + \ + int \ + EXPORTAPI \ + __cdecl \ + InitializeDriver ( \ + void *ImageHandle, \ + void *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, SystemTable); \ + } + + + #define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, NULL) + +#else // EFI_NT_EMULATOR + +// +// When build similiar to FW, then link everything together as +// one big module. For the MSVC toolchain, we simply tell the +// linker what our driver init function is using /ENTRY. +// +#if defined(_MSC_EXTENSIONS) + #define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + __pragma(comment(linker, "/ENTRY:" # InitFunction)) +#else + #define EFI_DRIVER_ENTRY_POINT(InitFunction) \ + UINTN \ + InitializeDriver ( \ + VOID *ImageHandle, \ + VOID *SystemTable \ + ) \ + { \ + return InitFunction(ImageHandle, \ + SystemTable); \ + } \ + \ + EFI_STATUS efi_main( \ + EFI_HANDLE image, \ + EFI_SYSTEM_TABLE *systab \ + ) __attribute__((weak, \ + alias ("InitializeDriver"))); +#endif + + #define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ + (_if)->LoadInternal(type, name, entry) + +#endif // EFI_NT_EMULATOR + +// +// Some compilers don't support the forward reference construct: +// typedef struct XXXXX +// +// The following macro provide a workaround for such cases. +// +#ifdef NO_INTERFACE_DECL +#define INTERFACE_DECL(x) +#else +#if defined(__GNUC__) || defined(_MSC_EXTENSIONS) +#define INTERFACE_DECL(x) struct x +#else +#define INTERFACE_DECL(x) typedef struct x +#endif +#endif + +/* for x86_64, EFI_FUNCTION_WRAPPER must be defined */ +#if defined(HAVE_USE_MS_ABI) +#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__) +#else +/* + Credits for macro-magic: + https://groups.google.com/forum/?fromgroups#!topic/comp.std.c/d-6Mj5Lko_s + http://efesx.com/2010/08/31/overloading-macros/ +*/ +#define __VA_NARG__(...) \ + __VA_NARG_(_0, ## __VA_ARGS__, __RSEQ_N()) +#define __VA_NARG_(...) \ + __VA_ARG_N(__VA_ARGS__) +#define __VA_ARG_N( \ + _0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,N,...) N +#define __RSEQ_N() \ + 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 + +#define __VA_ARG_NSUFFIX__(prefix,...) \ + __VA_ARG_NSUFFIX_N(prefix, __VA_NARG__(__VA_ARGS__)) +#define __VA_ARG_NSUFFIX_N(prefix,nargs) \ + __VA_ARG_NSUFFIX_N_(prefix, nargs) +#define __VA_ARG_NSUFFIX_N_(prefix,nargs) \ + prefix ## nargs + +/* Prototypes of EFI cdecl -> stdcall trampolines */ +UINT64 efi_call0(void *func); +UINT64 efi_call1(void *func, UINT64 arg1); +UINT64 efi_call2(void *func, UINT64 arg1, UINT64 arg2); +UINT64 efi_call3(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3); +UINT64 efi_call4(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3, + UINT64 arg4); +UINT64 efi_call5(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3, + UINT64 arg4, UINT64 arg5); +UINT64 efi_call6(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3, + UINT64 arg4, UINT64 arg5, UINT64 arg6); +UINT64 efi_call7(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3, + UINT64 arg4, UINT64 arg5, UINT64 arg6, UINT64 arg7); +UINT64 efi_call8(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3, + UINT64 arg4, UINT64 arg5, UINT64 arg6, UINT64 arg7, + UINT64 arg8); +UINT64 efi_call9(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3, + UINT64 arg4, UINT64 arg5, UINT64 arg6, UINT64 arg7, + UINT64 arg8, UINT64 arg9); +UINT64 efi_call10(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3, + UINT64 arg4, UINT64 arg5, UINT64 arg6, UINT64 arg7, + UINT64 arg8, UINT64 arg9, UINT64 arg10); + +/* Front-ends to efi_callX to avoid compiler warnings */ +#define _cast64_efi_call0(f) \ + efi_call0(f) +#define _cast64_efi_call1(f,a1) \ + efi_call1(f, (UINT64)(a1)) +#define _cast64_efi_call2(f,a1,a2) \ + efi_call2(f, (UINT64)(a1), (UINT64)(a2)) +#define _cast64_efi_call3(f,a1,a2,a3) \ + efi_call3(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3)) +#define _cast64_efi_call4(f,a1,a2,a3,a4) \ + efi_call4(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4)) +#define _cast64_efi_call5(f,a1,a2,a3,a4,a5) \ + efi_call5(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \ + (UINT64)(a5)) +#define _cast64_efi_call6(f,a1,a2,a3,a4,a5,a6) \ + efi_call6(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \ + (UINT64)(a5), (UINT64)(a6)) +#define _cast64_efi_call7(f,a1,a2,a3,a4,a5,a6,a7) \ + efi_call7(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \ + (UINT64)(a5), (UINT64)(a6), (UINT64)(a7)) +#define _cast64_efi_call8(f,a1,a2,a3,a4,a5,a6,a7,a8) \ + efi_call8(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \ + (UINT64)(a5), (UINT64)(a6), (UINT64)(a7), (UINT64)(a8)) +#define _cast64_efi_call9(f,a1,a2,a3,a4,a5,a6,a7,a8,a9) \ + efi_call9(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \ + (UINT64)(a5), (UINT64)(a6), (UINT64)(a7), (UINT64)(a8), \ + (UINT64)(a9)) +#define _cast64_efi_call10(f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) \ + efi_call10(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \ + (UINT64)(a5), (UINT64)(a6), (UINT64)(a7), (UINT64)(a8), \ + (UINT64)(a9), (UINT64)(a10)) + +/* main wrapper (va_num ignored) */ +#define uefi_call_wrapper(func,va_num,...) \ + __VA_ARG_NSUFFIX__(_cast64_efi_call, __VA_ARGS__) (func , ##__VA_ARGS__) + +#endif + +#if defined(HAVE_USE_MS_ABI) && !defined(_MSC_EXTENSIONS) + #define EFI_FUNCTION __attribute__((ms_abi)) +#else + #define EFI_FUNCTION +#endif + +#ifdef _MSC_EXTENSIONS +#pragma warning ( disable : 4731 ) // Suppress warnings about modification of EBP +#endif + +#endif diff --git a/gnuefi/inc/x86_64/efilibplat.h b/gnuefi/inc/x86_64/efilibplat.h new file mode 100644 index 0000000..3844578 --- /dev/null +++ b/gnuefi/inc/x86_64/efilibplat.h @@ -0,0 +1,26 @@ +/*++ + +Copyright (c) 1998 Intel Corporation + +Module Name: + + efilibplat.h + +Abstract: + + EFI to compile bindings + + + + +Revision History + +--*/ + +VOID +InitializeLibPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + + diff --git a/gnuefi/inc/x86_64/efisetjmp_arch.h b/gnuefi/inc/x86_64/efisetjmp_arch.h new file mode 100644 index 0000000..8d100ae --- /dev/null +++ b/gnuefi/inc/x86_64/efisetjmp_arch.h @@ -0,0 +1,22 @@ +#ifndef GNU_EFI_X86_64_SETJMP_H +#define GNU_EFI_X86_64_SETJMP_H + +#define JMPBUF_ALIGN 8 + +typedef struct { + UINT64 Rbx; + UINT64 Rsp; + UINT64 Rbp; + + UINT64 Rdi; + UINT64 Rsi; + UINT64 R12; + UINT64 R13; + UINT64 R14; + UINT64 R15; + UINT64 Rip; + UINT64 MxCsr; + UINT8 XmmBuffer[160]; // XMM6 - XMM15 +} EFI_ALIGN(JMPBUF_ALIGN) jmp_buf[1]; + +#endif /* GNU_EFI_X86_64_SETJMP_H */ diff --git a/gnuefi/inc/x86_64/pe.h b/gnuefi/inc/x86_64/pe.h new file mode 100644 index 0000000..979b936 --- /dev/null +++ b/gnuefi/inc/x86_64/pe.h @@ -0,0 +1,595 @@ +/* + PE32+ header file + */ +#ifndef _PE_H +#define _PE_H + +#define IMAGE_DOS_SIGNATURE 0x5A4D // MZ +#define IMAGE_OS2_SIGNATURE 0x454E // NE +#define IMAGE_OS2_SIGNATURE_LE 0x454C // LE +#define IMAGE_NT_SIGNATURE 0x00004550 // PE00 +#define IMAGE_EDOS_SIGNATURE 0x44454550 // PEED + + +typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header + UINT16 e_magic; // Magic number + UINT16 e_cblp; // Bytes on last page of file + UINT16 e_cp; // Pages in file + UINT16 e_crlc; // Relocations + UINT16 e_cparhdr; // Size of header in paragraphs + UINT16 e_minalloc; // Minimum extra paragraphs needed + UINT16 e_maxalloc; // Maximum extra paragraphs needed + UINT16 e_ss; // Initial (relative) SS value + UINT16 e_sp; // Initial SP value + UINT16 e_csum; // Checksum + UINT16 e_ip; // Initial IP value + UINT16 e_cs; // Initial (relative) CS value + UINT16 e_lfarlc; // File address of relocation table + UINT16 e_ovno; // Overlay number + UINT16 e_res[4]; // Reserved words + UINT16 e_oemid; // OEM identifier (for e_oeminfo) + UINT16 e_oeminfo; // OEM information; e_oemid specific + UINT16 e_res2[10]; // Reserved words + UINT32 e_lfanew; // File address of new exe header + } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER; + +typedef struct _IMAGE_OS2_HEADER { // OS/2 .EXE header + UINT16 ne_magic; // Magic number + UINT8 ne_ver; // Version number + UINT8 ne_rev; // Revision number + UINT16 ne_enttab; // Offset of Entry Table + UINT16 ne_cbenttab; // Number of bytes in Entry Table + UINT32 ne_crc; // Checksum of whole file + UINT16 ne_flags; // Flag UINT16 + UINT16 ne_autodata; // Automatic data segment number + UINT16 ne_heap; // Initial heap allocation + UINT16 ne_stack; // Initial stack allocation + UINT32 ne_csip; // Initial CS:IP setting + UINT32 ne_sssp; // Initial SS:SP setting + UINT16 ne_cseg; // Count of file segments + UINT16 ne_cmod; // Entries in Module Reference Table + UINT16 ne_cbnrestab; // Size of non-resident name table + UINT16 ne_segtab; // Offset of Segment Table + UINT16 ne_rsrctab; // Offset of Resource Table + UINT16 ne_restab; // Offset of resident name table + UINT16 ne_modtab; // Offset of Module Reference Table + UINT16 ne_imptab; // Offset of Imported Names Table + UINT32 ne_nrestab; // Offset of Non-resident Names Table + UINT16 ne_cmovent; // Count of movable entries + UINT16 ne_align; // Segment alignment shift count + UINT16 ne_cres; // Count of resource segments + UINT8 ne_exetyp; // Target Operating system + UINT8 ne_flagsothers; // Other .EXE flags + UINT16 ne_pretthunks; // offset to return thunks + UINT16 ne_psegrefbytes; // offset to segment ref. bytes + UINT16 ne_swaparea; // Minimum code swap area size + UINT16 ne_expver; // Expected Windows version number + } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER; + +// +// File header format. +// + +typedef struct _IMAGE_FILE_HEADER { + UINT16 Machine; + UINT16 NumberOfSections; + UINT32 TimeDateStamp; + UINT32 PointerToSymbolTable; + UINT32 NumberOfSymbols; + UINT16 SizeOfOptionalHeader; + UINT16 Characteristics; +} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER; + +#define IMAGE_SIZEOF_FILE_HEADER 20 + +#define IMAGE_FILE_RELOCS_STRIPPED 0x0001 // Relocation info stripped from file. +#define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002 // File is executable (i.e. no unresolved externel references). +#define IMAGE_FILE_LINE_NUMS_STRIPPED 0x0004 // Line nunbers stripped from file. +#define IMAGE_FILE_LOCAL_SYMS_STRIPPED 0x0008 // Local symbols stripped from file. +#define IMAGE_FILE_BYTES_REVERSED_LO 0x0080 // Bytes of machine word are reversed. +#define IMAGE_FILE_32BIT_MACHINE 0x0100 // 32 bit word machine. +#define IMAGE_FILE_DEBUG_STRIPPED 0x0200 // Debugging info stripped from file in .DBG file +#define IMAGE_FILE_SYSTEM 0x1000 // System File. +#define IMAGE_FILE_DLL 0x2000 // File is a DLL. +#define IMAGE_FILE_BYTES_REVERSED_HI 0x8000 // Bytes of machine word are reversed. + +#define IMAGE_FILE_MACHINE_UNKNOWN 0 +#define IMAGE_FILE_MACHINE_I386 0x14c // Intel 386. +#define IMAGE_FILE_MACHINE_R3000 0x162 // MIPS little-endian, 0540 big-endian +#define IMAGE_FILE_MACHINE_R4000 0x166 // MIPS little-endian +#define IMAGE_FILE_MACHINE_ALPHA 0x184 // Alpha_AXP +#define IMAGE_FILE_MACHINE_ARMTHUMB_MIXED 0x1c2 // Arm/Thumb +#define IMAGE_FILE_MACHINE_POWERPC 0x1F0 // IBM PowerPC Little-Endian +#define IMAGE_FILE_MACHINE_IA64 0x200 // IA-64 +#define IMAGE_FILE_MACHINE_TAHOE 0x7cc // Intel EM machine +#define IMAGE_FILE_MACHINE_EBC 0xebc // EFI Byte Code +#define IMAGE_FILE_MACHINE_X64 0x8664 // x86_64 +// +// Directory format. +// + +typedef struct _IMAGE_DATA_DIRECTORY { + UINT32 VirtualAddress; + UINT32 Size; +} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY; + +#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16 + +// +// Optional header format. +// + +typedef struct _IMAGE_OPTIONAL_HEADER { + // + // Standard fields. + // + + UINT16 Magic; + UINT8 MajorLinkerVersion; + UINT8 MinorLinkerVersion; + UINT32 SizeOfCode; + UINT32 SizeOfInitializedData; + UINT32 SizeOfUninitializedData; + UINT32 AddressOfEntryPoint; + UINT32 BaseOfCode; + UINT32 BaseOfData; + + // + // NT additional fields. + // + + UINT32 ImageBase; + UINT32 SectionAlignment; + UINT32 FileAlignment; + UINT16 MajorOperatingSystemVersion; + UINT16 MinorOperatingSystemVersion; + UINT16 MajorImageVersion; + UINT16 MinorImageVersion; + UINT16 MajorSubsystemVersion; + UINT16 MinorSubsystemVersion; + UINT32 Reserved1; + UINT32 SizeOfImage; + UINT32 SizeOfHeaders; + UINT32 CheckSum; + UINT16 Subsystem; + UINT16 DllCharacteristics; + UINT32 SizeOfStackReserve; + UINT32 SizeOfStackCommit; + UINT32 SizeOfHeapReserve; + UINT32 SizeOfHeapCommit; + UINT32 LoaderFlags; + UINT32 NumberOfRvaAndSizes; + IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]; +} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER; + +typedef struct _IMAGE_ROM_OPTIONAL_HEADER { + UINT16 Magic; + UINT8 MajorLinkerVersion; + UINT8 MinorLinkerVersion; + UINT32 SizeOfCode; + UINT32 SizeOfInitializedData; + UINT32 SizeOfUninitializedData; + UINT32 AddressOfEntryPoint; + UINT32 BaseOfCode; + UINT32 BaseOfData; + UINT32 BaseOfBss; + UINT32 GprMask; + UINT32 CprMask[4]; + UINT32 GpValue; +} IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER; + +#define IMAGE_SIZEOF_ROM_OPTIONAL_HEADER 56 +#define IMAGE_SIZEOF_STD_OPTIONAL_HEADER 28 +#define IMAGE_SIZEOF_NT_OPTIONAL_HEADER 224 + +#define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b +#define IMAGE_ROM_OPTIONAL_HDR_MAGIC 0x107 + +typedef struct _IMAGE_NT_HEADERS { + UINT32 Signature; + IMAGE_FILE_HEADER FileHeader; + IMAGE_OPTIONAL_HEADER OptionalHeader; +} IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS; + +typedef struct _IMAGE_ROM_HEADERS { + IMAGE_FILE_HEADER FileHeader; + IMAGE_ROM_OPTIONAL_HEADER OptionalHeader; +} IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS; + +#define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER) \ + ((UINT32)ntheader + \ + FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + \ + ((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader \ + )) + + +// Subsystem Values + +#define IMAGE_SUBSYSTEM_UNKNOWN 0 // Unknown subsystem. +#define IMAGE_SUBSYSTEM_NATIVE 1 // Image doesn't require a subsystem. +#define IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem. +#define IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem. +#define IMAGE_SUBSYSTEM_OS2_CUI 5 // image runs in the OS/2 character subsystem. +#define IMAGE_SUBSYSTEM_POSIX_CUI 7 // image run in the Posix character subsystem. + + +// Directory Entries + +#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // Export Directory +#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // Import Directory +#define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 // Resource Directory +#define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 // Exception Directory +#define IMAGE_DIRECTORY_ENTRY_SECURITY 4 // Security Directory +#define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 // Base Relocation Table +#define IMAGE_DIRECTORY_ENTRY_DEBUG 6 // Debug Directory +#define IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 // Description String +#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 // Machine Value (MIPS GP) +#define IMAGE_DIRECTORY_ENTRY_TLS 9 // TLS Directory +#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 // Load Configuration Directory + +// +// Section header format. +// + +#define IMAGE_SIZEOF_SHORT_NAME 8 + +typedef struct _IMAGE_SECTION_HEADER { + UINT8 Name[IMAGE_SIZEOF_SHORT_NAME]; + union { + UINT32 PhysicalAddress; + UINT32 VirtualSize; + } Misc; + UINT32 VirtualAddress; + UINT32 SizeOfRawData; + UINT32 PointerToRawData; + UINT32 PointerToRelocations; + UINT32 PointerToLinenumbers; + UINT16 NumberOfRelocations; + UINT16 NumberOfLinenumbers; + UINT32 Characteristics; +} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER; + +#define IMAGE_SIZEOF_SECTION_HEADER 40 + +#define IMAGE_SCN_TYPE_NO_PAD 0x00000008 // Reserved. + +#define IMAGE_SCN_CNT_CODE 0x00000020 // Section contains code. +#define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040 // Section contains initialized data. +#define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x00000080 // Section contains uninitialized data. + +#define IMAGE_SCN_LNK_OTHER 0x00000100 // Reserved. +#define IMAGE_SCN_LNK_INFO 0x00000200 // Section contains comments or some other type of information. +#define IMAGE_SCN_LNK_REMOVE 0x00000800 // Section contents will not become part of image. +#define IMAGE_SCN_LNK_COMDAT 0x00001000 // Section contents comdat. + +#define IMAGE_SCN_ALIGN_1BYTES 0x00100000 // +#define IMAGE_SCN_ALIGN_2BYTES 0x00200000 // +#define IMAGE_SCN_ALIGN_4BYTES 0x00300000 // +#define IMAGE_SCN_ALIGN_8BYTES 0x00400000 // +#define IMAGE_SCN_ALIGN_16BYTES 0x00500000 // Default alignment if no others are specified. +#define IMAGE_SCN_ALIGN_32BYTES 0x00600000 // +#define IMAGE_SCN_ALIGN_64BYTES 0x00700000 // + +#define IMAGE_SCN_MEM_DISCARDABLE 0x02000000 // Section can be discarded. +#define IMAGE_SCN_MEM_NOT_CACHED 0x04000000 // Section is not cachable. +#define IMAGE_SCN_MEM_NOT_PAGED 0x08000000 // Section is not pageable. +#define IMAGE_SCN_MEM_SHARED 0x10000000 // Section is shareable. +#define IMAGE_SCN_MEM_EXECUTE 0x20000000 // Section is executable. +#define IMAGE_SCN_MEM_READ 0x40000000 // Section is readable. +#define IMAGE_SCN_MEM_WRITE 0x80000000 // Section is writeable. + +// +// Symbol format. +// + + +#define IMAGE_SIZEOF_SYMBOL 18 + +// +// Section values. +// +// Symbols have a section number of the section in which they are +// defined. Otherwise, section numbers have the following meanings: +// + +#define IMAGE_SYM_UNDEFINED (UINT16)0 // Symbol is undefined or is common. +#define IMAGE_SYM_ABSOLUTE (UINT16)-1 // Symbol is an absolute value. +#define IMAGE_SYM_DEBUG (UINT16)-2 // Symbol is a special debug item. + +// +// Type (fundamental) values. +// + +#define IMAGE_SYM_TYPE_NULL 0 // no type. +#define IMAGE_SYM_TYPE_VOID 1 // +#define IMAGE_SYM_TYPE_CHAR 2 // type character. +#define IMAGE_SYM_TYPE_SHORT 3 // type short integer. +#define IMAGE_SYM_TYPE_INT 4 // +#define IMAGE_SYM_TYPE_LONG 5 // +#define IMAGE_SYM_TYPE_FLOAT 6 // +#define IMAGE_SYM_TYPE_DOUBLE 7 // +#define IMAGE_SYM_TYPE_STRUCT 8 // +#define IMAGE_SYM_TYPE_UNION 9 // +#define IMAGE_SYM_TYPE_ENUM 10 // enumeration. +#define IMAGE_SYM_TYPE_MOE 11 // member of enumeration. +#define IMAGE_SYM_TYPE_BYTE 12 // +#define IMAGE_SYM_TYPE_WORD 13 // +#define IMAGE_SYM_TYPE_UINT 14 // +#define IMAGE_SYM_TYPE_DWORD 15 // + +// +// Type (derived) values. +// + +#define IMAGE_SYM_DTYPE_NULL 0 // no derived type. +#define IMAGE_SYM_DTYPE_POINTER 1 // pointer. +#define IMAGE_SYM_DTYPE_FUNCTION 2 // function. +#define IMAGE_SYM_DTYPE_ARRAY 3 // array. + +// +// Storage classes. +// + +#define IMAGE_SYM_CLASS_END_OF_FUNCTION (BYTE )-1 +#define IMAGE_SYM_CLASS_NULL 0 +#define IMAGE_SYM_CLASS_AUTOMATIC 1 +#define IMAGE_SYM_CLASS_EXTERNAL 2 +#define IMAGE_SYM_CLASS_STATIC 3 +#define IMAGE_SYM_CLASS_REGISTER 4 +#define IMAGE_SYM_CLASS_EXTERNAL_DEF 5 +#define IMAGE_SYM_CLASS_LABEL 6 +#define IMAGE_SYM_CLASS_UNDEFINED_LABEL 7 +#define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT 8 +#define IMAGE_SYM_CLASS_ARGUMENT 9 +#define IMAGE_SYM_CLASS_STRUCT_TAG 10 +#define IMAGE_SYM_CLASS_MEMBER_OF_UNION 11 +#define IMAGE_SYM_CLASS_UNION_TAG 12 +#define IMAGE_SYM_CLASS_TYPE_DEFINITION 13 +#define IMAGE_SYM_CLASS_UNDEFINED_STATIC 14 +#define IMAGE_SYM_CLASS_ENUM_TAG 15 +#define IMAGE_SYM_CLASS_MEMBER_OF_ENUM 16 +#define IMAGE_SYM_CLASS_REGISTER_PARAM 17 +#define IMAGE_SYM_CLASS_BIT_FIELD 18 +#define IMAGE_SYM_CLASS_BLOCK 100 +#define IMAGE_SYM_CLASS_FUNCTION 101 +#define IMAGE_SYM_CLASS_END_OF_STRUCT 102 +#define IMAGE_SYM_CLASS_FILE 103 +// new +#define IMAGE_SYM_CLASS_SECTION 104 +#define IMAGE_SYM_CLASS_WEAK_EXTERNAL 105 + +// type packing constants + +#define N_BTMASK 017 +#define N_TMASK 060 +#define N_TMASK1 0300 +#define N_TMASK2 0360 +#define N_BTSHFT 4 +#define N_TSHIFT 2 + +// MACROS + +// +// Communal selection types. +// + +#define IMAGE_COMDAT_SELECT_NODUPLICATES 1 +#define IMAGE_COMDAT_SELECT_ANY 2 +#define IMAGE_COMDAT_SELECT_SAME_SIZE 3 +#define IMAGE_COMDAT_SELECT_EXACT_MATCH 4 +#define IMAGE_COMDAT_SELECT_ASSOCIATIVE 5 + +#define IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY 1 +#define IMAGE_WEAK_EXTERN_SEARCH_LIBRARY 2 +#define IMAGE_WEAK_EXTERN_SEARCH_ALIAS 3 + + +// +// Relocation format. +// + +typedef struct _IMAGE_RELOCATION { + UINT32 VirtualAddress; + UINT32 SymbolTableIndex; + UINT16 Type; +} IMAGE_RELOCATION; + +#define IMAGE_SIZEOF_RELOCATION 10 + +// +// I386 relocation types. +// + +#define IMAGE_REL_I386_ABSOLUTE 0 // Reference is absolute, no relocation is necessary +#define IMAGE_REL_I386_DIR16 01 // Direct 16-bit reference to the symbols virtual address +#define IMAGE_REL_I386_REL16 02 // PC-relative 16-bit reference to the symbols virtual address +#define IMAGE_REL_I386_DIR32 06 // Direct 32-bit reference to the symbols virtual address +#define IMAGE_REL_I386_DIR32NB 07 // Direct 32-bit reference to the symbols virtual address, base not included +#define IMAGE_REL_I386_SEG12 011 // Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address +#define IMAGE_REL_I386_SECTION 012 +#define IMAGE_REL_I386_SECREL 013 +#define IMAGE_REL_I386_REL32 024 // PC-relative 32-bit reference to the symbols virtual address + +// +// MIPS relocation types. +// + +#define IMAGE_REL_MIPS_ABSOLUTE 0 // Reference is absolute, no relocation is necessary +#define IMAGE_REL_MIPS_REFHALF 01 +#define IMAGE_REL_MIPS_REFWORD 02 +#define IMAGE_REL_MIPS_JMPADDR 03 +#define IMAGE_REL_MIPS_REFHI 04 +#define IMAGE_REL_MIPS_REFLO 05 +#define IMAGE_REL_MIPS_GPREL 06 +#define IMAGE_REL_MIPS_LITERAL 07 +#define IMAGE_REL_MIPS_SECTION 012 +#define IMAGE_REL_MIPS_SECREL 013 +#define IMAGE_REL_MIPS_REFWORDNB 042 +#define IMAGE_REL_MIPS_PAIR 045 + +// +// Alpha Relocation types. +// + +#define IMAGE_REL_ALPHA_ABSOLUTE 0x0 +#define IMAGE_REL_ALPHA_REFLONG 0x1 +#define IMAGE_REL_ALPHA_REFQUAD 0x2 +#define IMAGE_REL_ALPHA_GPREL32 0x3 +#define IMAGE_REL_ALPHA_LITERAL 0x4 +#define IMAGE_REL_ALPHA_LITUSE 0x5 +#define IMAGE_REL_ALPHA_GPDISP 0x6 +#define IMAGE_REL_ALPHA_BRADDR 0x7 +#define IMAGE_REL_ALPHA_HINT 0x8 +#define IMAGE_REL_ALPHA_INLINE_REFLONG 0x9 +#define IMAGE_REL_ALPHA_REFHI 0xA +#define IMAGE_REL_ALPHA_REFLO 0xB +#define IMAGE_REL_ALPHA_PAIR 0xC +#define IMAGE_REL_ALPHA_MATCH 0xD +#define IMAGE_REL_ALPHA_SECTION 0xE +#define IMAGE_REL_ALPHA_SECREL 0xF +#define IMAGE_REL_ALPHA_REFLONGNB 0x10 + +// +// IBM PowerPC relocation types. +// + +#define IMAGE_REL_PPC_ABSOLUTE 0x0000 // NOP +#define IMAGE_REL_PPC_ADDR64 0x0001 // 64-bit address +#define IMAGE_REL_PPC_ADDR32 0x0002 // 32-bit address +#define IMAGE_REL_PPC_ADDR24 0x0003 // 26-bit address, shifted left 2 (branch absolute) +#define IMAGE_REL_PPC_ADDR16 0x0004 // 16-bit address +#define IMAGE_REL_PPC_ADDR14 0x0005 // 16-bit address, shifted left 2 (load doubleword) +#define IMAGE_REL_PPC_REL24 0x0006 // 26-bit PC-relative offset, shifted left 2 (branch relative) +#define IMAGE_REL_PPC_REL14 0x0007 // 16-bit PC-relative offset, shifted left 2 (br cond relative) +#define IMAGE_REL_PPC_TOCREL16 0x0008 // 16-bit offset from TOC base +#define IMAGE_REL_PPC_TOCREL14 0x0009 // 16-bit offset from TOC base, shifted left 2 (load doubleword) + +#define IMAGE_REL_PPC_ADDR32NB 0x000A // 32-bit addr w/o image base +#define IMAGE_REL_PPC_SECREL 0x000B // va of containing section (as in an image sectionhdr) +#define IMAGE_REL_PPC_SECTION 0x000C // sectionheader number +#define IMAGE_REL_PPC_IFGLUE 0x000D // substitute TOC restore instruction iff symbol is glue code +#define IMAGE_REL_PPC_IMGLUE 0x000E // symbol is glue code; virtual address is TOC restore instruction + +#define IMAGE_REL_PPC_TYPEMASK 0x00FF // mask to isolate above values in IMAGE_RELOCATION.Type + +// Flag bits in IMAGE_RELOCATION.TYPE + +#define IMAGE_REL_PPC_NEG 0x0100 // subtract reloc value rather than adding it +#define IMAGE_REL_PPC_BRTAKEN 0x0200 // fix branch prediction bit to predict branch taken +#define IMAGE_REL_PPC_BRNTAKEN 0x0400 // fix branch prediction bit to predict branch not taken +#define IMAGE_REL_PPC_TOCDEFN 0x0800 // toc slot defined in file (or, data in toc) + +// +// Based relocation format. +// + +typedef struct _IMAGE_BASE_RELOCATION { + UINT32 VirtualAddress; + UINT32 SizeOfBlock; +// UINT16 TypeOffset[1]; +} IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION; + +#define IMAGE_SIZEOF_BASE_RELOCATION 8 + +// +// Based relocation types. +// + +#define IMAGE_REL_BASED_ABSOLUTE 0 +#define IMAGE_REL_BASED_HIGH 1 +#define IMAGE_REL_BASED_LOW 2 +#define IMAGE_REL_BASED_HIGHLOW 3 +#define IMAGE_REL_BASED_HIGHADJ 4 +#define IMAGE_REL_BASED_MIPS_JMPADDR 5 +#define IMAGE_REL_BASED_IA64_IMM64 9 +#define IMAGE_REL_BASED_DIR64 10 + +// +// Line number format. +// + +typedef struct _IMAGE_LINENUMBER { + union { + UINT32 SymbolTableIndex; // Symbol table index of function name if Linenumber is 0. + UINT32 VirtualAddress; // Virtual address of line number. + } Type; + UINT16 Linenumber; // Line number. +} IMAGE_LINENUMBER; + +#define IMAGE_SIZEOF_LINENUMBER 6 + +// +// Archive format. +// + +#define IMAGE_ARCHIVE_START_SIZE 8 +#define IMAGE_ARCHIVE_START "!\n" +#define IMAGE_ARCHIVE_END "`\n" +#define IMAGE_ARCHIVE_PAD "\n" +#define IMAGE_ARCHIVE_LINKER_MEMBER "/ " +#define IMAGE_ARCHIVE_LONGNAMES_MEMBER "// " + +typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER { + UINT8 Name[16]; // File member name - `/' terminated. + UINT8 Date[12]; // File member date - decimal. + UINT8 UserID[6]; // File member user id - decimal. + UINT8 GroupID[6]; // File member group id - decimal. + UINT8 Mode[8]; // File member mode - octal. + UINT8 Size[10]; // File member size - decimal. + UINT8 EndHeader[2]; // String to end header. +} IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER; + +#define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR 60 + +// +// DLL support. +// + +// +// Export Format +// + +typedef struct _IMAGE_EXPORT_DIRECTORY { + UINT32 Characteristics; + UINT32 TimeDateStamp; + UINT16 MajorVersion; + UINT16 MinorVersion; + UINT32 Name; + UINT32 Base; + UINT32 NumberOfFunctions; + UINT32 NumberOfNames; + UINT32 *AddressOfFunctions; + UINT32 *AddressOfNames; + UINT32 *AddressOfNameOrdinals; +} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY; + +// +// Import Format +// + +typedef struct _IMAGE_IMPORT_BY_NAME { + UINT16 Hint; + UINT8 Name[1]; +} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME; + +typedef struct _IMAGE_THUNK_DATA { + union { + UINT32 Function; + UINT32 Ordinal; + PIMAGE_IMPORT_BY_NAME AddressOfData; + } u1; +} IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA; + +#define IMAGE_ORDINAL_FLAG 0x80000000 +#define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0) +#define IMAGE_ORDINAL(Ordinal) (Ordinal & 0xffff) + +typedef struct _IMAGE_IMPORT_DESCRIPTOR { + UINT32 Characteristics; + UINT32 TimeDateStamp; + UINT32 ForwarderChain; + UINT32 Name; + PIMAGE_THUNK_DATA FirstThunk; +} IMAGE_IMPORT_DESCRIPTOR, *PIMAGE_IMPORT_DESCRIPTOR; + +#endif diff --git a/gnuefi/libefi.a b/gnuefi/libefi.a new file mode 100644 index 0000000000000000000000000000000000000000..6ad4b28010477a1961e38571ea0cf2ceb5d5abe3 GIT binary patch literal 548594 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%0DBoe7(@__*B2WZZu!d4_}$awko;2 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� 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

?k;CYO&~_#P>L!T7yh;a>gw7mllG)n0lz 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�Q}YJ%Q}urQ+H_vDRC(i#GnpE_ADJ?* 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 literal 0 HcmV?d00001 diff --git a/gnuefi/libgnuefi.a b/gnuefi/libgnuefi.a new file mode 100644 index 0000000000000000000000000000000000000000..84d5f9e3bf33080cf357dd690cc59adf884e5cff GIT binary patch literal 17018 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 Szm1Op`@4RR`p++P{Qm=F7otl5 literal 0 HcmV?d00001