├── .clang-format ├── .gitignore ├── LICENSE ├── Makefile ├── README.md ├── compile_flags.txt ├── example └── main.c ├── include └── tinyefi │ ├── console.h │ ├── protos.h │ ├── protos │ ├── dpp.h │ ├── fp.h │ ├── gop.h │ ├── lip.h │ ├── sfsp.h │ ├── stip.h │ └── stop.h │ ├── services.h │ ├── services │ ├── boot.h │ └── runtime.h │ ├── tables.h │ ├── tables │ ├── config.h │ └── system.h │ ├── tinyefi.h │ └── types.h └── src ├── console.c └── tinyefi.c /.clang-format: -------------------------------------------------------------------------------- 1 | --- 2 | BasedOnStyle: LLVM 3 | UseTab: Never 4 | IndentWidth: 4 5 | TabWidth: 4 6 | BreakBeforeBraces: Allman 7 | AllowShortIfStatementsOnASingleLine: false 8 | IndentCaseLabels: false 9 | ColumnLimit: 0 10 | AccessModifierOffset: -4 11 | FixNamespaceComments: true 12 | SpaceBeforeInheritanceColon: true 13 | BreakInheritanceList: AfterColon 14 | IndentPPDirectives: AfterHash 15 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build 2 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | CC = clang 2 | LD = lld-link 3 | 4 | CFLAGS = -ffreestanding -nostdlib -D__x86_64__ -Iinclude -Wall -Wextra -Werror -target x86_64-pc-win32-coff -ansi -fno-stack-protector -fshort-wchar -mno-red-zone 5 | LDFLAGS = -subsystem:efi_application -nodefaultlib -dll 6 | 7 | DIRECTORY_GUARD=@mkdir -p $(@D) 8 | 9 | BUILD_DIRECTORY = build 10 | 11 | EFI_FILE = $(BUILD_DIRECTORY)/main.efi 12 | 13 | OVMF = $(BUILD_DIRECTORY)/tools/OVMF.fd 14 | 15 | SRCS = $(wildcard example/*.c) 16 | 17 | TINYEFI_SRCS = $(wildcard src/*.c) 18 | OBJS = $(patsubst %.c, $(BUILD_DIRECTORY)/%.c.o, $(SRCS)) \ 19 | $(patsubst %.c, $(BUILD_DIRECTORY)/%.c.o, $(TINYEFI_SRCS)) 20 | 21 | $(EFI_FILE): $(OBJS) 22 | $(LD) $(LDFLAGS) -entry:efi_main $^ -out:$@ 23 | 24 | $(BUILD_DIRECTORY)/%.c.o: %.c 25 | $(DIRECTORY_GUARD) 26 | $(CC) $(CFLAGS) -c -o $@ $< 27 | 28 | run: $(EFI_FILE) $(OVMF) $(BUILD_DIRECTORY)/image/EFI/BOOT/BOOTX64.EFI 29 | qemu-system-x86_64 -bios $(OVMF) -cpu host -enable-kvm -drive file=fat:rw:$(BUILD_DIRECTORY)/image,media=disk,format=raw 30 | 31 | $(BUILD_DIRECTORY)/image/EFI/BOOT/BOOTX64.EFI: $(EFI_FILE) 32 | $(DIRECTORY_GUARD) 33 | ln -sf ../../../../$(EFI_FILE) $@ 34 | 35 | $(OVMF): 36 | $(DIRECTORY_GUARD) 37 | wget https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF.fd 38 | mv RELEASEX64_OVMF.fd OVMF.fd 39 | mv OVMF.fd $(@D) 40 | 41 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # tinyefi 2 | 3 | tinyefi is a tiny, public domain, EFI library originally written as part of **Brutal**. 4 | 5 | ## Naming scheme/Comparison 6 | 7 | Contrary to the standard EFI naming scheme, tinyefi uses `snake_case` for functions and `PascalCase` for types. 8 | 9 | Standard GNU EFI code: 10 | 11 | ```c 12 | #include 13 | #include 14 | 15 | EFI_STATUS 16 | EFIAPI 17 | efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable) { 18 | InitializeLib(ImageHandle, SystemTable); 19 | Print(L"Hello, world!\n"); 20 | 21 | return EFI_SUCCESS; 22 | } 23 | ``` 24 | 25 | tinyefi code: 26 | 27 | ```c 28 | #include 29 | 30 | EfiStatus efi_main(EfiHandle image_handle, EfiSystemTable *st) 31 | { 32 | efi_init(image_handle, st); 33 | 34 | efi_console_write(L"Hello, World!"); 35 | 36 | return EFI_SUCCESS; 37 | } 38 | ``` 39 | 40 | ## Example 41 | 42 | To compile and run the example, just execute `make run` 43 | -------------------------------------------------------------------------------- /compile_flags.txt: -------------------------------------------------------------------------------- 1 | -Iinclude -------------------------------------------------------------------------------- /example/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void __chkstk() { return; } 4 | 5 | void *memset(void *d, int c, size_t n) 6 | { 7 | while (n--) 8 | { 9 | *(char *)d = c; 10 | } 11 | 12 | return d; 13 | } 14 | 15 | EfiStatus efi_main(EfiHandle image_handle, EfiSystemTable *st) 16 | { 17 | efi_init(image_handle, st); 18 | 19 | efi_console_clear(); 20 | efi_console_reset(); 21 | 22 | efi_console_write(L"Hello, World!"); 23 | 24 | for (;;) 25 | { 26 | __asm__ volatile("pause"); 27 | } 28 | 29 | return EFI_SUCCESS; 30 | } -------------------------------------------------------------------------------- /include/tinyefi/console.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_CONSOLE_H 2 | #define TINYEFI_CONSOLE_H 3 | 4 | #include 5 | 6 | void efi_console_reset(void); 7 | void efi_console_set_attribute(uint64_t attribute); 8 | void efi_console_clear(void); 9 | 10 | void efi_console_write(uint16_t *s); 11 | 12 | EfiInputKey efi_console_read_key(void); 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /include/tinyefi/protos.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_PROTOS_H 2 | #define TINYEFI_PROTOS_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #endif -------------------------------------------------------------------------------- /include/tinyefi/protos/dpp.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_PROTOS_DPP_H 2 | #define TINYEFI_PROTOS_DPP_H 3 | 4 | #include 5 | 6 | #define EFI_DPP_GUID \ 7 | (EfiGuid) \ 8 | { \ 9 | 0x09576e91, 0x6d3f, 0x11d2, \ 10 | { \ 11 | 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b \ 12 | } \ 13 | } 14 | 15 | #define EFI_HARDWARE_DEVICE_PATH 0x1 16 | #define EFI_ACPI_DEVICE_PATH 0x2 17 | #define EFI_MESSAGING_DEVICE_PATH 0x3 18 | #define EFI_MEDIA_DEVICE_PATH 0x4 19 | #define EFI_BIOS_BOOT_SPECIFICATION_DEVICE_PATH 0x5 20 | #define EFI_END_OF_HARDWARE_DEVICE_PATH 0x7f 21 | 22 | typedef struct 23 | { 24 | uint8_t type; 25 | uint8_t sub_type; 26 | uint8_t len[2]; 27 | } EfiDevicePath; 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /include/tinyefi/protos/fp.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_PROTOS_FP_H 2 | #define TINYEFI_PROTOS_FP_H 3 | 4 | #include 5 | 6 | #define EFI_FILE_INFO_ID \ 7 | (EfiGuid) \ 8 | { \ 9 | 0x09576e92, 0x6d3f, 0x11d2, \ 10 | { \ 11 | 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b \ 12 | } \ 13 | } 14 | 15 | #define EFI_FILE_SYSTEM_INFO_ID \ 16 | (EfiGuid) \ 17 | { \ 18 | 0x09576e93, 0x6d3f, 0x11d2, \ 19 | { \ 20 | 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b \ 21 | } \ 22 | } 23 | 24 | #define EFI_FILE_SYSTEM_VOLUME_LABEL_ID \ 25 | (EfiGuid) \ 26 | { \ 27 | 0xdb47d7d3, 0xfe81, 0x11d3, \ 28 | { \ 29 | 0x9a, 0x35, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d \ 30 | } \ 31 | } 32 | 33 | #define EFI_FILE_MODE_READ (1 << 0) 34 | #define EFI_FILE_MODE_WRITE (1 << 1) 35 | #define EFI_FILE_MODE_CREATE (1ull << 63) 36 | 37 | #define EFI_FILE_READ_ONLY (1 << 0) 38 | #define EFI_FILE_HIDDEN (1 << 1) 39 | #define EFI_FILE_SYSTEM (1 << 2) 40 | #define EFI_FILE_RESERVED (1 << 3) 41 | #define EFI_FILE_DIRECTORY (1 << 4) 42 | #define EFI_FILE_ARCHIVE (1 << 5) 43 | #define EFI_FILE_VALID_ATTR 0x37 44 | 45 | typedef struct 46 | { 47 | uint64_t size; 48 | uint64_t file_size; 49 | uint64_t physical_size; 50 | EfiTime create_time; 51 | EfiTime last_access_time; 52 | EfiTime modification_time; 53 | uint64_t attribute; 54 | uint16_t file_name[256]; 55 | } EfiFileInfo; 56 | 57 | typedef struct 58 | { 59 | uint64_t size; 60 | bool read_only; 61 | uint64_t volume_size; 62 | uint64_t free_space; 63 | uint32_t block_size; 64 | uint16_t volume_label; 65 | } EfiFileSystemInfo; 66 | 67 | typedef struct 68 | { 69 | uint16_t volume_label[256]; 70 | } EfiFsVolumeLabel; 71 | 72 | typedef struct 73 | { 74 | EfiEvent event; 75 | EfiStatus status; 76 | uint32_t buffer_size; 77 | void *buffer; 78 | } EfiFileIoToken; 79 | 80 | struct efi_file_protocol; 81 | 82 | #define DEF_FILE_EFI_FUNC(name, ...) \ 83 | typedef EfiStatus (*EFI_FILE_##name)(struct efi_file_protocol * \ 84 | self __VA_OPT__(, ) __VA_ARGS__) 85 | 86 | DEF_FILE_EFI_FUNC(OPEN, struct efi_file_protocol **, uint16_t *, uint64_t, 87 | uint64_t); 88 | DEF_FILE_EFI_FUNC(CLOSE); 89 | DEF_FILE_EFI_FUNC(DELETE); 90 | DEF_FILE_EFI_FUNC(READ, uint64_t *, void *); 91 | DEF_FILE_EFI_FUNC(WRITE, uint8_t, void *); 92 | DEF_FILE_EFI_FUNC(GET_POSITION, uint64_t *); 93 | DEF_FILE_EFI_FUNC(SET_POSITION, uint64_t); 94 | DEF_FILE_EFI_FUNC(GET_INFO, EfiGuid *, uint64_t *, void *); 95 | DEF_FILE_EFI_FUNC(SET_INFO, EfiGuid *, uint64_t, void *); 96 | DEF_FILE_EFI_FUNC(FLUSH); 97 | DEF_FILE_EFI_FUNC(OPEN_EX, struct efi_file_protocol **, uint16_t *, uint64_t, 98 | uint64_t, EfiFileIoToken *); 99 | DEF_FILE_EFI_FUNC(READ_EX, EfiFileIoToken *); 100 | DEF_FILE_EFI_FUNC(WRITE_EX, EfiFileIoToken *); 101 | DEF_FILE_EFI_FUNC(FLUSH_EX, EfiFileIoToken *); 102 | 103 | typedef struct efi_file_protocol 104 | { 105 | uint64_t revision; 106 | EFI_FILE_OPEN open; 107 | EFI_FILE_CLOSE close; 108 | EFI_FILE_DELETE delete_file; 109 | EFI_FILE_READ read; 110 | EFI_FILE_WRITE write; 111 | EFI_FILE_GET_POSITION get_position; 112 | EFI_FILE_SET_POSITION set_position; 113 | EFI_FILE_GET_INFO get_info; 114 | EFI_FILE_SET_INFO set_info; 115 | EFI_FILE_FLUSH flush; 116 | EFI_FILE_OPEN_EX open_ex; 117 | EFI_FILE_READ_EX read_ex; 118 | EFI_FILE_WRITE_EX write_ex; 119 | EFI_FILE_FLUSH_EX flush_ex; 120 | } EfiFp; 121 | 122 | #endif 123 | -------------------------------------------------------------------------------- /include/tinyefi/protos/gop.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_PROTOS_GOP_H 2 | #define TINYEFI_PROTOS_GOP_H 3 | 4 | #include 5 | 6 | #define EFI_GOP_GUID \ 7 | { \ 8 | 0x9042a9de, 0x23dc, 0x4a38, \ 9 | { \ 10 | 0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a \ 11 | } \ 12 | } 13 | 14 | typedef struct 15 | { 16 | uint32_t red_mask; 17 | uint32_t green_mask; 18 | uint32_t blue_mask; 19 | uint32_t reserved_mask; 20 | } EfiPixelBitmap; 21 | 22 | typedef enum 23 | { 24 | PIXEL_RGB_RESERVED_8_BIT, 25 | PIXEL_BGR_8_BIT, 26 | PIXEL_BIT_MASK, 27 | PIXEL_BLT_ONLY, 28 | PIXEL_FORMAT_MAX 29 | } EfiGraphicsPixelFormat; 30 | 31 | typedef struct 32 | { 33 | uint32_t version; 34 | uint32_t horizontal_resolution; 35 | uint32_t vertical_resolution; 36 | EfiGraphicsPixelFormat pixel_format; 37 | EfiPixelBitmap pixel_information; 38 | uint32_t pixels_per_scan_line; 39 | } EfiGopModeInfo; 40 | 41 | typedef struct 42 | { 43 | uint32_t max_mode; 44 | uint32_t mode; 45 | EfiGopModeInfo *info; 46 | uint64_t size_of_info; 47 | uint64_t framebuffer_base; 48 | uint64_t framebuffer_size; 49 | } EfiGopMode; 50 | 51 | typedef struct 52 | { 53 | uint8_t blue; 54 | uint8_t green; 55 | uint8_t red; 56 | uint8_t _reserved; 57 | } EfiGopBltPixel; 58 | 59 | typedef enum 60 | { 61 | BLT_VIDEO_FILL, 62 | BLT_VIDEO_TO_BLT_BUFFER, 63 | BLT_BUFFER_TO_VIDEO, 64 | BLT_VIDEO_TO_VIDEO, 65 | BLT_OPERATION_MAX 66 | } EfiGopBltOperation; 67 | 68 | struct efi_gop; 69 | 70 | #define DEF_GOP_EFI_FUNC(name, ...) \ 71 | typedef EfiStatus (*EFI_GOP_##name)(struct efi_gop * self, __VA_ARGS__) 72 | 73 | DEF_GOP_EFI_FUNC(QUERY_MODE, uint32_t, uint64_t *, EfiGopModeInfo **); 74 | DEF_GOP_EFI_FUNC(SET_MODE, uint32_t); 75 | DEF_GOP_EFI_FUNC(BLT, EfiGopBltPixel *, EfiGopBltOperation, uint64_t s_x, 76 | uint64_t s_y, uint64_t d_x, uint64_t d_y, uint64_t width, 77 | uint64_t height, uint64_t delta); 78 | 79 | typedef struct efi_gop 80 | { 81 | EFI_GOP_QUERY_MODE query_mode; 82 | EFI_GOP_SET_MODE set_mode; 83 | EFI_GOP_BLT blt; 84 | EfiGopMode *mode; 85 | } EfiGop; 86 | 87 | #endif 88 | -------------------------------------------------------------------------------- /include/tinyefi/protos/lip.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #define EFI_LIP_GUID \ 6 | { \ 7 | 0x5b1b31a1, 0x9562, 0x11d2, \ 8 | { \ 9 | 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b \ 10 | } \ 11 | } 12 | 13 | #define EFI_LIP_REVISION 0x1000 14 | 15 | typedef EfiStatus (*EFI_IMAGE_UNLOAD)(EfiHandle); 16 | 17 | typedef struct efi_lip 18 | { 19 | uint32_t revision; 20 | EfiHandle parent_handle; 21 | EfiSystemTable *system_table; 22 | EfiHandle device_handle; 23 | EfiDevicePath *file_path; 24 | void *_reserved; 25 | uint32_t load_options_size; 26 | void *load_options; 27 | void *image_base; 28 | uint64_t image_size; 29 | uint64_t image_code_type; 30 | EFI_IMAGE_UNLOAD unload; 31 | } EfiLoadedImage; 32 | -------------------------------------------------------------------------------- /include/tinyefi/protos/sfsp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #define EFI_SFSP_REVISION 0x00010000 7 | 8 | #define EFI_SFSP_GUID \ 9 | { \ 10 | 0x0964e5b22, 0x6459, 0x11d2, \ 11 | { \ 12 | 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b \ 13 | } \ 14 | } 15 | 16 | struct efi_sfsp; 17 | 18 | typedef EfiStatus (*EFI_SFSP_OPEN_VOLUME)(struct efi_sfsp *self, EfiFp **root); 19 | 20 | typedef struct efi_sfsp 21 | { 22 | uint64_t revision; 23 | EFI_SFSP_OPEN_VOLUME open_volume; 24 | } EfiSfsp; 25 | -------------------------------------------------------------------------------- /include/tinyefi/protos/stip.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_PROTOS_STIP_H 2 | #define TINYEFI_PROTOS_STIP_H 3 | 4 | #include 5 | 6 | #define CHAR_CARRIAGE_RETURN 0x000D 7 | 8 | #define SCAN_NULL 0x0 9 | #define SCAN_UP 0x1 10 | #define SCAN_DOWN 0x2 11 | #define SCAN_RIGHT 0x3 12 | #define SCAN_LEFT 0x4 13 | #define SCAN_HOME 0x5 14 | #define SCAN_END 0x6 15 | #define SCAN_INSERT 0x7 16 | #define SCAN_DELETE 0x8 17 | #define SCAN_PAGE_UP 0x9 18 | #define SCAN_PAGE_DOWN 0xA 19 | #define SCAN_F1 0xB 20 | #define SCAN_F2 0xC 21 | #define SCAN_F3 0xD 22 | #define SCAN_F4 0xE 23 | #define SCAN_F5 0xF 24 | #define SCAN_F6 0x10 25 | #define SCAN_F7 0x11 26 | #define SCAN_F8 0x12 27 | #define SCAN_F9 0x13 28 | #define SCAN_F10 0x14 29 | #define SCAN_F11 0x15 30 | #define SCAN_F12 0x16 31 | #define SCAN_ESC 0x17 32 | 33 | #define EFI_STIP_PROTOCOL_GUID \ 34 | { \ 35 | 0x387477c1, 0x69c7, 0x11d2, \ 36 | { \ 37 | 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b \ 38 | } \ 39 | } 40 | 41 | struct efi_stip; 42 | 43 | #define DEF_TEXTI_EFI_FUNC(name, ...) \ 44 | typedef EfiStatus (*EFI_TEXTI_##name)(struct efi_stip * self, __VA_ARGS__) 45 | 46 | typedef struct 47 | { 48 | uint16_t scan_code; 49 | uint16_t unicode_char; 50 | } EfiInputKey; 51 | 52 | DEF_TEXTI_EFI_FUNC(RESET, bool); 53 | DEF_TEXTI_EFI_FUNC(READ_KEY, EfiInputKey *key); 54 | 55 | typedef struct efi_stip 56 | { 57 | EFI_TEXTI_RESET reset; 58 | EFI_TEXTI_READ_KEY read_key; 59 | EfiEvent wait_for_key; 60 | } EfiStip; 61 | 62 | #endif 63 | -------------------------------------------------------------------------------- /include/tinyefi/protos/stop.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_PROTOS_STOP_H 2 | #define TINYEFI_PROTOS_STOP_H 3 | 4 | #include 5 | 6 | #define EFI_STOP_GUID \ 7 | { \ 8 | 0x387477c2, 0x69c7, 0x11d2, \ 9 | { \ 10 | 0x82, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b \ 11 | } \ 12 | } 13 | 14 | #define EFI_BLACK 0x0 15 | #define EFI_BLUE (1 << 0) 16 | #define EFI_GREEN (1 << 1) 17 | #define EFI_CYAN (Efi_BLUE | Efi_GREEN) 18 | #define EFI_RED (1 << 2) 19 | #define EFI_MAGENTA (Efi_BLUE | Efi_RED) 20 | #define EFI_BROWN (Efi_GREEN | Efi_RED) 21 | #define EFI_LIGHTGRAY (Efi_BLUE | Efi_GREEN | Efi_RED) 22 | #define EFI_BRIGHT (1 << 3) 23 | #define EFI_DARKGRAY (Efi_BRIGHT) 24 | #define EFI_LIGHTBLUE (Efi_BLUE | Efi_BRIGHT) 25 | #define EFI_LIGHTGREEN (Efi_GREEN | Efi_BRIGHT) 26 | #define EFI_LIGHTCYAN (Efi_CYAN | Efi_BRIGHT) 27 | #define EFI_LIGHTRED (Efi_RED | Efi_BRIGHT) 28 | #define EFI_LIGHTMAGENTA (Efi_MAGENTA | Efi_BRIGHT) 29 | #define EFI_YELLOW (Efi_BROWN | Efi_BRIGHT) 30 | #define EFI_WHITE (Efi_BLUE | Efi_GREEN | Efi_RED | Efi_BRIGHT) 31 | 32 | #define EFI_BACKGROUND_BLACK 0x0 33 | #define EFI_BACKGROUND_BLUE (1 << 4) 34 | #define EFI_BACKGROUND_GREEN (1 << 5) 35 | #define EFI_BACKGROUND_CYAN (Efi_BACKGROUND_BLUE | Efi_BACKGROUND_GREEN) 36 | #define EFI_BACKGROUND_RED (1 << 6) 37 | #define EFI_BACKGROUND_MAGENTA (Efi_BACKGROUND_BLUE | Efi_BACKGROUND_RED) 38 | #define EFI_BACKGROUND_BROWN (Efi_BACKGROUND_GREEN | Efi_BACKGROUND_RED) 39 | #define EFI_BACKGROUND_LIGHTGRAY \ 40 | (Efi_BACKGROUND_BLUE | Efi_BACKGROUND_GREEN | Efi_BACKGROUND_RED) 41 | 42 | struct efi_stop; 43 | 44 | #define DEF_TEXTO_EFI_FUNC(name, ...) \ 45 | typedef EfiStatus (*EFI_TEXTO_##name)(struct efi_stop * self __VA_OPT__(, ) \ 46 | __VA_ARGS__) 47 | 48 | DEF_TEXTO_EFI_FUNC(RESET, bool verification); 49 | DEF_TEXTO_EFI_FUNC(OUTPUT_STRING, uint16_t *string); 50 | DEF_TEXTO_EFI_FUNC(TEST_STRING, uint16_t *string); 51 | DEF_TEXTO_EFI_FUNC(QUERY_MODE, uint32_t mode_number, uint32_t *columns, 52 | uint32_t *rows); 53 | DEF_TEXTO_EFI_FUNC(SET_MODE, uint32_t mode_number); 54 | DEF_TEXTO_EFI_FUNC(SET_ATTRIBUTE, uint32_t attribute); 55 | DEF_TEXTO_EFI_FUNC(CLEAR_SCREEN); 56 | DEF_TEXTO_EFI_FUNC(SET_CURSOR_POSITION, uint32_t column, uint32_t row); 57 | DEF_TEXTO_EFI_FUNC(ENABLE_CURSOR, bool visible); 58 | 59 | typedef struct 60 | { 61 | int32_t max_mode; 62 | int32_t mode; 63 | int32_t attribute; 64 | int32_t cursor_column; 65 | int32_t cursor_row; 66 | bool cursor_visible; 67 | } EfiStopMode; 68 | 69 | typedef struct efi_stop 70 | { 71 | EFI_TEXTO_RESET reset; 72 | EFI_TEXTO_OUTPUT_STRING output_string; 73 | EFI_TEXTO_TEST_STRING test_string; 74 | EFI_TEXTO_QUERY_MODE query_mode; 75 | EFI_TEXTO_SET_MODE set_mode; 76 | EFI_TEXTO_SET_ATTRIBUTE set_attribute; 77 | EFI_TEXTO_CLEAR_SCREEN clear_screen; 78 | EFI_TEXTO_SET_CURSOR_POSITION set_cursor_position; 79 | EFI_TEXTO_ENABLE_CURSOR enable_cursor; 80 | 81 | EfiStopMode *mode; 82 | } EfiStop; 83 | 84 | #endif 85 | -------------------------------------------------------------------------------- /include/tinyefi/services.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_SERVICES_H 2 | #define TINYEFI_SERVICES_H 3 | 4 | #include 5 | #include 6 | 7 | #endif -------------------------------------------------------------------------------- /include/tinyefi/services/boot.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_SERVICES_BOOT_H 2 | #define TINYEFI_SERVICES_BOOT_H 3 | 4 | #include 5 | #include 6 | 7 | /* Event Types */ 8 | #define EVT_TIMER 0x80000000 9 | #define EVT_RUNTIME 0x40000000 10 | #define EVT_NOTIFY_WAIT 0x100 11 | #define EVT_NOTIFY_SIGNAL 0x200 12 | #define EVT_SIGNAL_EXIT_BOOT_SERVICES (EVT_NOTIFY_SIGNAL | 0x1) 13 | #define EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE (EVT_NOTIFY_SIGNAL | 0x2) 14 | 15 | #define TPL_APPLICATION 4 16 | #define TPL_CALLBACK 8 17 | #define TPL_NOTIFY 16 18 | #define TPL_HIGH_LEVEL 31 19 | 20 | #define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL (1 << 0) 21 | #define EFI_OPEN_PROTOCOL_GET_PROTOCOL (1 << 1) 22 | #define EFI_OPEN_PROTOCOL_TEST_PROTOCOL (1 << 2) 23 | #define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER (1 << 3) 24 | #define EFI_OPEN_PROTOCOL_BY_DRIVER (1 << 4) 25 | #define EFI_OPEN_PROTOCOL_EXCLUSIVE (1 << 5) 26 | 27 | #define EFI_RESERVED_MEMORY_TYPE 0x0 28 | #define EFI_LOADER_CODE 0x1 29 | #define EFI_LOADER_DATA 0x2 30 | #define EFI_BOOT_SERVICES_CODE 0x3 31 | #define EFI_BOOT_SERVICES_DATA 0x4 32 | #define EFI_RUNTIME_SERVICES_CODE 0x5 33 | #define EFI_RUNTIME_SERVICES_DATA 0x6 34 | #define EFI_CONVENTIONAL_MEMORY 0x7 35 | #define EFI_UNUSABLE_MEMORY 0x8 36 | #define EFI_ACPI_RECLAIM_MEMORY 0x9 37 | #define EFI_ACPI_MEMORY_NVS 0xa 38 | #define EFI_MEMORY_MAPPED_IO 0xb 39 | #define EFI_MEMORY_MAPPED_IO_PORT_SPACE 0xc 40 | #define EFI_PAL_CODE 0xd 41 | #define EFI_PERSISTENT_MEMORY 0xe 42 | 43 | #define EFI_MAX_MEMORY_TYPE 0xe 44 | 45 | #define EFI_USER_KERNEL_MEMORY (0x80000ff0) 46 | 47 | typedef void (*EfiEventNotifyFunction)(EfiEvent, void *); 48 | 49 | typedef enum 50 | { 51 | TIMER_CANCEL, 52 | TIMER_PERIODIC, 53 | TIMER_RELATIVE 54 | } EfiTimerDelay; 55 | 56 | typedef enum 57 | { 58 | ALLOCATE_ANY_PAGES, 59 | ALLOCATE_MAX_ADDRESS, 60 | ALLOCATE_ADDRESS, 61 | MAX_ALLOCATE_TYPE 62 | } EfiAllocateType; 63 | 64 | typedef enum 65 | { 66 | EFI_NATIVE_INTERFACE 67 | } EfiInterfaceType; 68 | 69 | typedef enum 70 | { 71 | ALL_HANDLES, 72 | BY_REGISTER_NOTIFY, 73 | BY_PROTOCOL 74 | } EfiLocateSearchType; 75 | 76 | typedef struct Efi_OPEN_PROTOCOL_INFORMATION_ENTRY 77 | { 78 | EfiHandle agent_handle; 79 | EfiHandle controller_handle; 80 | uint32_t attributes; 81 | uint32_t open_count; 82 | } EfiOpenProtocolInformationEntry; 83 | 84 | #define DEF_EFI_FUNC(name, ...) typedef EfiStatus (*EFI_##name)(__VA_ARGS__) 85 | 86 | DEF_EFI_FUNC(RAISE_TPL, uint64_t); 87 | DEF_EFI_FUNC(RESTORE_TPL, uint64_t); 88 | DEF_EFI_FUNC(ALLOCATE_PAGES, uint64_t, uint64_t, uint64_t, uint64_t *); 89 | DEF_EFI_FUNC(FREE_PAGES, uint64_t, uint64_t); 90 | DEF_EFI_FUNC(GET_MEMORY_MAP, uint64_t *, EfiMemoryDescriptor *, uint64_t *, 91 | uint64_t *, uint32_t *); 92 | DEF_EFI_FUNC(ALLOCATE_POOL, uint64_t, uint64_t, void **); 93 | DEF_EFI_FUNC(FREE_POOL, void *); 94 | DEF_EFI_FUNC(CREATE_EVENT, uint32_t, uint64_t, EfiEventNotifyFunction, void *, 95 | EfiGuid *, EfiEvent *); 96 | DEF_EFI_FUNC(SET_TIMER, EfiEvent, EfiTimerDelay, uint64_t); 97 | DEF_EFI_FUNC(wait_for$_EVENT, uint64_t, EfiEvent *, uint64_t *); 98 | DEF_EFI_FUNC(SIGNAL_EVENT, EfiEvent); 99 | DEF_EFI_FUNC(CLOSE_EVENT, EfiEvent); 100 | DEF_EFI_FUNC(CHECK_EVENT, EfiEvent); 101 | DEF_EFI_FUNC(INSTALL_PROTOCOL_INTERFACE, EfiHandle *, EfiGuid *, 102 | EfiInterfaceType, void *); 103 | DEF_EFI_FUNC(REINSTALL_PROTOCOL_INTERFACE, EfiHandle, EfiGuid *, void *, 104 | void *); 105 | DEF_EFI_FUNC(UNINSTALL_PROTOCOL_INTERFACE, EfiHandle, EfiGuid *, void *); 106 | DEF_EFI_FUNC(HANDLE_PROTOCOL, EfiHandle, EfiGuid *, void **); 107 | DEF_EFI_FUNC(REGISTER_PROTOCOL_NOTIFY, EfiGuid *, EfiEvent, void **); 108 | DEF_EFI_FUNC(LOCATE_HANDLE, EfiLocateSearchType, EfiGuid *, void *, uint64_t *, 109 | EfiHandle); 110 | DEF_EFI_FUNC(LOCATE_DEVICE_PATH, EfiGuid *, EfiDevicePath **, EfiHandle); 111 | DEF_EFI_FUNC(INSTALL_CONFIGURATION_TABLE, EfiGuid *, void *); 112 | DEF_EFI_FUNC(IMAGE_LOAD, bool, EfiHandle, EfiDevicePath *, void *, uint64_t, 113 | EfiHandle *); 114 | DEF_EFI_FUNC(IMAGE_START, EfiHandle, uint64_t *, uint16_t **); 115 | DEF_EFI_FUNC(EXIT, EfiHandle, EfiStatus, uint64_t, uint16_t *); 116 | DEF_EFI_FUNC(IMAGE_UNLOAD, EfiHandle); 117 | DEF_EFI_FUNC(EXIT_BOOT_SERVICES, EfiHandle, uint64_t); 118 | DEF_EFI_FUNC(GET_NEXT_MONOTONIC_COUNT, uint64_t *); 119 | DEF_EFI_FUNC(STALL, uint64_t); 120 | DEF_EFI_FUNC(SET_WATCHDOG_TIMER, uint64_t, uint64_t, uint64_t, uint16_t *); 121 | DEF_EFI_FUNC(CONNECT_CONTROLLER, EfiHandle, EfiHandle *, EfiDevicePath *, bool); 122 | DEF_EFI_FUNC(DISCONNECT_CONTROLLER, EfiHandle, EfiHandle, EfiHandle); 123 | DEF_EFI_FUNC(OPEN_PROTOCOL, EfiHandle, EfiGuid *, void **, EfiHandle, EfiHandle, 124 | uint32_t); 125 | DEF_EFI_FUNC(CLOSE_PROTOCOL, EfiHandle, EfiGuid *, EfiHandle, EfiHandle); 126 | DEF_EFI_FUNC(OPEN_PROTOCOL_INFORMATION, EfiHandle, EfiGuid *, 127 | EfiOpenProtocolInformationEntry **, uint64_t *); 128 | DEF_EFI_FUNC(PROTOCOLS_PER_HANDLE, EfiHandle, EfiGuid **, uint64_t *); 129 | DEF_EFI_FUNC(LOCATE_HANDLE_BUFFER, EfiLocateSearchType, EfiGuid *, void *, 130 | uint64_t *, EfiHandle **); 131 | DEF_EFI_FUNC(LOCATE_PROTOCOL, EfiGuid *, void *, void **); 132 | DEF_EFI_FUNC(INSTALL_MULTIPLE_PROTOCOL_INTERFACES, EfiHandle *, ...); 133 | DEF_EFI_FUNC(UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES, EfiHandle *, ...); 134 | DEF_EFI_FUNC(CALCULATE_CRC32, void *, uint64_t, uint32_t *); 135 | DEF_EFI_FUNC(COPY_MEM, void *, void *, uint64_t); 136 | DEF_EFI_FUNC(SET_MEM, void *, uint64_t, uint8_t); 137 | DEF_EFI_FUNC(CREATE_EVENT_EX, uint32_t, uint64_t, EfiEventNotifyFunction, 138 | void *, EfiGuid *, EfiEvent *); 139 | 140 | typedef struct 141 | { 142 | EfiTableHeader hdr; 143 | EFI_RAISE_TPL raise_tpl; 144 | EFI_RESTORE_TPL restore_tpl; 145 | EFI_ALLOCATE_PAGES allocate_pages; 146 | EFI_FREE_PAGES free_pages; 147 | EFI_GET_MEMORY_MAP get_memory_map; 148 | EFI_ALLOCATE_POOL allocate_pool; 149 | EFI_FREE_POOL free_pool; 150 | EFI_CREATE_EVENT create_event; 151 | EFI_SET_TIMER set_timer; 152 | EFI_wait_for$_EVENT wait_for_event; 153 | EFI_SIGNAL_EVENT signal_event; 154 | EFI_CLOSE_EVENT close_event; 155 | EFI_CHECK_EVENT check_event; 156 | EFI_INSTALL_PROTOCOL_INTERFACE install_protocol_interface; 157 | EFI_REINSTALL_PROTOCOL_INTERFACE reinstall_protocol_interface; 158 | EFI_UNINSTALL_PROTOCOL_INTERFACE uninstall_protocol_interface; 159 | EFI_HANDLE_PROTOCOL handle_protocol; 160 | void *_reserved; 161 | EFI_REGISTER_PROTOCOL_NOTIFY register_protocol_notify; 162 | EFI_LOCATE_HANDLE locate_handle; 163 | EFI_LOCATE_DEVICE_PATH locate_device_path; 164 | EFI_INSTALL_CONFIGURATION_TABLE install_configuration_table; 165 | EFI_IMAGE_LOAD load_image; 166 | EFI_IMAGE_START start_image; 167 | EFI_EXIT exit; 168 | EFI_IMAGE_UNLOAD unload_image; 169 | EFI_EXIT_BOOT_SERVICES exit_boot_services; 170 | EFI_GET_NEXT_MONOTONIC_COUNT get_next_monotonic_count; 171 | EFI_STALL stall; 172 | EFI_SET_WATCHDOG_TIMER set_watchdog_timer; 173 | EFI_CONNECT_CONTROLLER connect_controller; 174 | EFI_DISCONNECT_CONTROLLER disconnect_controller; 175 | EFI_OPEN_PROTOCOL open_protocol; 176 | EFI_CLOSE_PROTOCOL close_protocol; 177 | EFI_OPEN_PROTOCOL_INFORMATION open_protocol_information; 178 | EFI_PROTOCOLS_PER_HANDLE protocols_per_handle; 179 | EFI_LOCATE_HANDLE_BUFFER locate_handle_buffer; 180 | EFI_LOCATE_PROTOCOL locate_protocol; 181 | EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES install_multiple_protocol_interfaces; 182 | EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES 183 | uninstall_multiple_protocol_interfaces; 184 | 185 | EFI_CALCULATE_CRC32 calculate_crc32; 186 | 187 | EFI_COPY_MEM copy_mem; 188 | EFI_SET_MEM set_mem; 189 | EFI_CREATE_EVENT_EX create_event_ex; 190 | } EfiBootServices; 191 | 192 | #endif 193 | -------------------------------------------------------------------------------- /include/tinyefi/services/runtime.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_SERVICES_RUNTIME_H 2 | #define TINYEFI_SERVICES_RUNTIME_H 3 | 4 | #include 5 | #include 6 | 7 | #define EFI_OPTIONAL_POINTER 0x00000001 8 | 9 | #define CAPSULE_FLAGS_PERSIST_ACROSS_RESET 0x00010000 10 | #define CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE 0x00020000 11 | #define CAPSULE_FLAGS_INITIATE_RESET 0x00040000 12 | 13 | typedef enum 14 | { 15 | EFI_RESET_COLD, 16 | EFI_RESET_WARM, 17 | EFI_RESET_SHUTDOWN, 18 | EFI_RESET_PLATFORM_SPECIFIC 19 | } EfiResetType; 20 | 21 | typedef struct 22 | { 23 | uint64_t len; 24 | union 25 | { 26 | uint64_t data_block; 27 | uint64_t continuation_pointer; 28 | } _union; 29 | 30 | } EfiCapsuleBlockDescriptor; 31 | 32 | typedef struct 33 | { 34 | EfiGuid capsule_guid; 35 | uint32_t header_size; 36 | uint32_t flags; 37 | uint32_t capsule_image_size; 38 | } EfiCapsuleHeader; 39 | 40 | DEF_EFI_FUNC(GET_TIME, EfiTime *, EfiTimeCapabilities *); 41 | DEF_EFI_FUNC(SET_TIME, EfiTime *); 42 | DEF_EFI_FUNC(GET_WAKEUP_TIME, bool *, bool *, EfiTime *); 43 | DEF_EFI_FUNC(SET_WAKEUP_TIME, bool, EfiTime *); 44 | DEF_EFI_FUNC(SET_VIRTUAL_ADDRESS_MAP, uint64_t, uint64_t, uint32_t, 45 | EfiMemoryDescriptor *); 46 | DEF_EFI_FUNC(CONVERT_POINTER, uint64_t, void **); 47 | DEF_EFI_FUNC(GET_VARIABLE, uint16_t *, EfiGuid *, uint32_t *, uint64_t *, 48 | void *); 49 | DEF_EFI_FUNC(GET_NEXT_VARIABLE_NAME, uint64_t, uint16_t *, EfiGuid *); 50 | DEF_EFI_FUNC(SET_VARIABLE, uint16_t *, EfiGuid *, uint32_t, uint64_t, void *); 51 | DEF_EFI_FUNC(GET_NEXT_HIGH_MONO_COUNT, uint32_t *); 52 | DEF_EFI_FUNC(RESET_SYSTEM, EfiResetType, EfiStatus, uint64_t, void *); 53 | DEF_EFI_FUNC(UPDATE_CAPSULE, EfiCapsuleHeader **, uint64_t, uint64_t); 54 | DEF_EFI_FUNC(QUERY_CAPSULE_CAPABILITIES, EfiCapsuleHeader **, uint64_t, 55 | uint64_t *, EfiResetType *); 56 | DEF_EFI_FUNC(QUERY_VARIABLE_INFO, uint32_t, uint64_t *, uint64_t *, uint64_t *); 57 | 58 | typedef struct 59 | { 60 | EfiTableHeader hdr; 61 | EFI_GET_TIME get_time; 62 | EFI_SET_TIME set_time; 63 | EFI_GET_WAKEUP_TIME get_wakeup_time; 64 | EFI_SET_WAKEUP_TIME set_wakeup_time; 65 | EFI_SET_VIRTUAL_ADDRESS_MAP set_virtual_address_map; 66 | EFI_CONVERT_POINTER convert_pointer; 67 | EFI_GET_VARIABLE get_variable; 68 | EFI_GET_NEXT_VARIABLE_NAME get_next_variable_name; 69 | EFI_SET_VARIABLE set_variable; 70 | EFI_GET_NEXT_HIGH_MONO_COUNT get_next_high_monotonic_count; 71 | EFI_RESET_SYSTEM reset_system; 72 | EFI_UPDATE_CAPSULE update_capsule; 73 | EFI_QUERY_CAPSULE_CAPABILITIES query_capsule_capabilities; 74 | EFI_QUERY_VARIABLE_INFO query_variable_info; 75 | } EfiRuntimeServices; 76 | 77 | #endif 78 | -------------------------------------------------------------------------------- /include/tinyefi/tables.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_TABLES_H 2 | #define TINYEFI_TABLES_H 3 | 4 | #include 5 | #include 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /include/tinyefi/tables/config.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_TABLES_CONFIG_H 2 | #define TINYEFI_TABLES_CONFIG_H 3 | 4 | #include 5 | 6 | #define ACPI2_TABLE_GUID \ 7 | { \ 8 | 0x8868e871, 0xe4f1, 0x11d3, \ 9 | { \ 10 | 0xbc, 0x22, 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81 \ 11 | } \ 12 | } 13 | #define ACPI_TABLE_GUID \ 14 | { \ 15 | 0xeb9d2d30, 0x2d88, 0x11d3, \ 16 | { \ 17 | 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d \ 18 | } \ 19 | } 20 | #define SAL_SYSTEM_TABLE_GUID \ 21 | { \ 22 | 0xeb9d2d32, 0x2d88, 0x11d3, \ 23 | { \ 24 | 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d \ 25 | } \ 26 | } 27 | #define SMBIOS_TABLE_GUID \ 28 | { \ 29 | 0xeb9d2d31, 0x2d88, 0x11d3, \ 30 | { \ 31 | 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d \ 32 | } \ 33 | } 34 | 35 | #define SMBIOS2_TABLE_GUID \ 36 | { \ 37 | 0xf2fd1544, 0x9794, 0x4a2c, \ 38 | { \ 39 | 0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94 \ 40 | } \ 41 | } 42 | 43 | #define MPS_TABLE_GUID \ 44 | { \ 45 | 0xeb9d2d2f, 0x2d88, 0x11d3, \ 46 | { \ 47 | 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d \ 48 | } \ 49 | } 50 | 51 | typedef struct 52 | { 53 | EfiGuid vendor_guid; 54 | void *vendor_table; 55 | } EfiConfigTable; 56 | 57 | #endif 58 | -------------------------------------------------------------------------------- /include/tinyefi/tables/system.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_TABLES_SYSTEM_H 2 | #define TINYEFI_TABLES_SYSTEM_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | typedef struct 11 | { 12 | EfiTableHeader hdr; 13 | uint16_t *firmware_vendor; 14 | uint32_t firmware_revision; 15 | EfiHandle console_in_handle; 16 | EfiStip *console_in; 17 | EfiHandle console_out_handle; 18 | EfiStop *console_out; 19 | EfiHandle std_error_handle; 20 | EfiStop *std_error; 21 | EfiRuntimeServices *runtime_services; 22 | EfiBootServices *boot_services; 23 | uint64_t num_table_entries; 24 | EfiConfigTable *config_table; 25 | } EfiSystemTable; 26 | 27 | #endif -------------------------------------------------------------------------------- /include/tinyefi/tinyefi.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_TINYEFI_H 2 | #define TINYEFI_TINYEFI_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | void efi_init(EfiHandle handle, EfiSystemTable *st); 9 | 10 | void efi_deinit(void); 11 | 12 | uint16_t *efi_str_to_utf16(const char *s, uint16_t **out, size_t len); 13 | 14 | EfiHandle efi_handle(void); 15 | 16 | EfiSystemTable *efi_st(void); 17 | 18 | /* you should free EfiMemoryDescriptor if you don't need it */ 19 | EfiMemoryDescriptor *efi_mmap_snapshot(size_t *size, size_t *desc_size); 20 | 21 | #endif -------------------------------------------------------------------------------- /include/tinyefi/types.h: -------------------------------------------------------------------------------- 1 | #ifndef TINYEFI_TYPES_H 2 | #define TINYEFI_TYPES_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | typedef struct 9 | { 10 | uint32_t data1; 11 | uint16_t data2; 12 | uint16_t data3; 13 | uint8_t data4[8]; 14 | } EfiGuid; 15 | 16 | typedef uint64_t EfiStatus; 17 | typedef void *EfiEvent; 18 | typedef void *EfiHandle; 19 | 20 | /* https://uefi.org/sites/default/files/resources/UEfi%20Spec%202.8B%20May%202020.pdf 21 | Section 8.3 */ 22 | typedef struct 23 | { 24 | uint16_t year; 25 | uint8_t month; 26 | uint8_t day; 27 | uint8_t hour; 28 | uint8_t minute; 29 | uint8_t second; 30 | uint8_t _pad1; 31 | uint32_t nanosecond; 32 | int16_t time_zone; 33 | uint8_t daylight; 34 | uint8_t _pad2; 35 | } EfiTime; 36 | 37 | typedef struct 38 | { 39 | uint32_t resolution; 40 | uint32_t accuracy; 41 | bool sets_to_zero; 42 | } EfiTimeCapabilities; 43 | 44 | typedef struct 45 | { 46 | uint32_t type; 47 | uint64_t physical_start; 48 | uint64_t virtual_start; 49 | uint64_t num_pages; 50 | uint64_t attribute; 51 | } EfiMemoryDescriptor; 52 | 53 | typedef struct 54 | { 55 | uint64_t signature; 56 | uint32_t revision; 57 | uint32_t header_size; 58 | uint32_t CRC32; 59 | uint32_t _reserved; 60 | } EfiTableHeader; 61 | 62 | #define EFI_SUCCESS 0 63 | #define EFI_ERR (1ull << 63) 64 | #define EFI_LOAD_ERROR (Efi_ERR | 0x1) 65 | #define EFI_INVALID_PARAMETER (Efi_ERR | 0x2) 66 | #define EFI_UNSUPPORTED (Efi_ERR | 0x3) 67 | #define EFI_BAD_BUFFER_SIZE (Efi_ERR | 0x4) 68 | #define EFI_BUFFER_TOO_SMALL (Efi_ERR | 0x5) 69 | #define EFI_NOT_READY (Efi_ERR | 0x6) 70 | #define EFI_DEVICE_ERROR (Efi_ERR | 0x7) 71 | #define EFI_WRITE_PROTECTED (Efi_ERR | 0x8) 72 | #define EFI_OUT_OF_RESOURCES (Efi_ERR | 0x9) 73 | #define EFI_VOLUME_CORRUPTED (Efi_ERR | 0xa) 74 | #define EFI_VOLUME_FULL (Efi_ERR | 0xb) 75 | #define EFI_NO_MEDIA (Efi_ERR | 0xc) 76 | #define EFI_MEDIA_CHANGED (Efi_ERR | 0xd) 77 | #define EFI_NOT_FOUND (Efi_ERR | 0xe) 78 | #define EFI_ACCESS_DENIED (Efi_ERR | 0xf) 79 | #define EFI_NO_RESPONSE (Efi_ERR | 0x10) 80 | #define EFI_NO_MAPPING (Efi_ERR | 0x11) 81 | #define EFI_TIMEOUT (Efi_ERR | 0x12) 82 | #define EFI_NOT_STARTED (Efi_ERR | 0x13) 83 | #define EFI_ALREADY_STARTED (Efi_ERR | 0x14) 84 | #define EFI_ABORTED (Efi_ERR | 0x15) 85 | #define EFI_ICMP_ERROR (Efi_ERR | 0x16) 86 | #define EFI_TFTP_ERROR (Efi_ERR | 0x17) 87 | #define EFI_PROTOCOL_ERROR (Efi_ERR | 0x18) 88 | #define EFI_INCOMPATIBLE_VERSION (Efi_ERR | 0x19) 89 | #define EFI_SECURITY_VIOLATION (Efi_ERR | 0x1a) 90 | #define EFI_CRC_ERROR (Efi_ERR | 0x1b) 91 | #define EFI_END_OF_MEDIA (Efi_ERR | 0x1c) 92 | #define EFI_END_OF_FILE (Efi_ERR | 0x1f) 93 | #define EFI_INVALID_LANGUAGE (Efi_ERR | 0x20) 94 | #define EFI_COMPROMISED_DATA (Efi_ERR | 0x21) 95 | #define EFI_IP_ADDRESS_CONFLICT (Efi_ERR | 0x22) 96 | #define EFI_HTTP_ERROR (Efi_ERR | 0x23) 97 | 98 | #endif -------------------------------------------------------------------------------- /src/console.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void efi_console_reset(void) 4 | { 5 | efi_st()->console_in->reset(efi_st()->console_in, false); 6 | } 7 | 8 | void efi_console_set_attribute(uint64_t attribute) 9 | { 10 | efi_st()->console_out->set_attribute(efi_st()->console_out, attribute); 11 | } 12 | 13 | void efi_console_clear(void) 14 | { 15 | efi_st()->console_out->clear_screen(efi_st()->console_out); 16 | } 17 | 18 | void efi_console_write(uint16_t *s) 19 | { 20 | efi_st()->console_out->output_string(efi_st()->console_out, s); 21 | } 22 | 23 | EfiInputKey efi_console_read_key(void) 24 | { 25 | EfiInputKey key = {}; 26 | uint64_t key_event = 0; 27 | 28 | efi_st()->boot_services->wait_for_event( 29 | 1, &efi_st()->console_in->wait_for_key, &key_event); 30 | efi_st()->console_in->read_key(efi_st()->console_in, &key); 31 | 32 | return key; 33 | } 34 | -------------------------------------------------------------------------------- /src/tinyefi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | static EfiHandle _handle; 5 | static EfiSystemTable *_st; 6 | static uint64_t _mmap_key = 0; 7 | 8 | void efi_init(EfiHandle handle, EfiSystemTable *st) 9 | { 10 | _handle = handle; 11 | _st = st; 12 | } 13 | 14 | EfiHandle efi_handle(void) { return _handle; } 15 | 16 | EfiSystemTable *efi_st(void) { return _st; } 17 | 18 | void efi_deinit(void) 19 | { 20 | efi_st()->boot_services->exit_boot_services(efi_handle(), _mmap_key); 21 | } 22 | 23 | EfiMemoryDescriptor *efi_mmap_snapshot(size_t *size, size_t *desc_size) 24 | { 25 | uint64_t mmap_size = 0; 26 | uint64_t descriptor_size = 0; 27 | uint32_t descriptor_version = 0; 28 | EfiMemoryDescriptor *mmap; 29 | 30 | efi_st()->boot_services->get_memory_map( 31 | &mmap_size, NULL, &_mmap_key, &descriptor_size, &descriptor_version); 32 | 33 | /* https://stackoverflow.com/questions/39407280/uefi-simple-example-of-using-exitbootservices-with-gnu-efi 34 | */ 35 | mmap_size += 2 * descriptor_size; 36 | 37 | efi_st()->boot_services->allocate_pool(EFI_BOOT_SERVICES_DATA, mmap_size, 38 | (void **)&mmap); 39 | 40 | efi_st()->boot_services->get_memory_map( 41 | &mmap_size, mmap, &_mmap_key, &descriptor_size, &descriptor_version); 42 | 43 | *size = (mmap_size / descriptor_size); 44 | *desc_size = descriptor_size; 45 | 46 | return mmap; 47 | } 48 | 49 | uint16_t *efi_str_to_utf16(const char *s, uint16_t **out, size_t len) 50 | { 51 | size_t i; 52 | 53 | for (i = 0; i < len; i++) 54 | { 55 | *out[i * 2] = s[i]; 56 | } 57 | return *out; 58 | } --------------------------------------------------------------------------------