WebSVN – Kolibri OS – Diff – /kernel/trunk/bootloader/uefi4kos/uefi64kos.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2020-2024. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;; Version 2, or (at your option) any later version.            ;;
;;                                                              ;;
;; Written by Ivan Baravy                                       ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format pe64 efi
entry main
 
section '.text' code executable readable
 
include '../../struct.inc'
include '../../macros.inc'
include '../../kglobals.inc'
fastcall fix fstcall
include 'proc64.inc'
include '../../const.inc'
 
purge DQ
include 'uefi64.inc'
 
MEMORY_MAP_SIZE = 0x10000
PROTOCOL_HANDLERS_BUFFER_SIZE = 0x100
FILE_BUFFER_SIZE = 0x1000
 
KERNEL_TRAMPOLINE = 0x8f80      ; just before BOOT_LO
MAX_FILE_SIZE = 0x10000000
 
CODE_32_SELECTOR = 8
DATA_32_SELECTOR = 16
CODE_64_SELECTOR = 24
 
; linux/arch/x86/include/uapi/asm/e820.h
E820_RAM       = 1
E820_RESERVED  = 2
E820_ACPI      = 3
E820_NVS       = 4
E820_UNUSABLE  = 5
E820_PMEM      = 7
 
proc load_file _root, _name, _buffer, _size, _fatal
        mov     [_root], rcx
        mov     [_name], rdx
        mov     [_buffer], r8
        mov     [_size], r9
        mov     r10, [_root]
        mov     r11, [_name]
        fstcall [r10+EFI_FILE_PROTOCOL.Open], r10, file_handle, \
                r11, EFI_FILE_MODE_READ, 0
        test    eax, eax
        jz      @f
        mov     [_size], 0
        cmp     [_fatal], 1
        jnz     .done
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error_open_file
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        mov     rdx, [_name]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, [_name]
        jmp     $
@@:
        lea     rdx, [_size]
        mov     r8, [_buffer]
        mov     r10, [file_handle]
        fstcall [r10+EFI_FILE_PROTOCOL.Read], [file_handle], rdx, r8
        mov     r10, [file_handle]
        fstcall [r10+EFI_FILE_PROTOCOL.Close], [file_handle]
.done:
        call    clearbuf
        mov     rax, [_size]
        mov     rdi, msg
        call    num2dec
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_file_size
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        mov     rax, [_size]
        ret
endp
 
skip_whitespace:
.next_char:
        cmp     byte[rsi], 0
        jz      .done
        cmp     byte[rsi], 0x20 ; ' '
        jz      .whitespace
        cmp     byte[rsi], 9    ; '\t'
        jz      .whitespace
        jmp     .done
.whitespace:
        inc     rsi
        jmp     .next_char
.done:
        ret
 
skip_until_newline:
.next_char:
        cmp     byte[rsi], 0
        jz      .done
        cmp     byte[rsi], 0xd  ; '\r'
        jz      .done
        cmp     byte[rsi], 0xa  ; '\n'
        jz      .done
        inc     rsi
        jmp     .next_char
.done:
        ret
 
skip_newline:
.next_char:
        cmp     byte[rsi], 0xd  ; '\r'
        jz      .newline
        cmp     byte[rsi], 0xa  ; '\n'
        jz      .newline
        jmp     .done
.newline:
        inc     rsi
        jmp     .next_char
.done:
        ret
 
skip_line:
        call    skip_until_newline
        call    skip_newline
        ret
 
dec2bin:
        xor     edx, edx
.next_char:
        movzx   eax, byte[rsi]
        test    eax, eax
        jz      .done
        sub     eax, '0'
        jb      .done
        cmp     eax, 9
        ja      .done
        inc     rsi
        imul    edx, 10
        add     edx, eax
        jmp     .next_char
.done:
        mov     eax, edx
        ret
 
parse_option:
        mov     rbx, config_options-3*8
.try_next_option:
        add     rbx, 3*8
        mov     rdi, rsi
        mov     rdx, [rbx]      ; option name
        test    rdx, rdx
        jz      .done
.next_char:
        cmp     byte[rdx], 0
        jnz     @f
        cmp     byte[rdi], '='
        jz      .opt_name_ok
@@:
        cmp     byte[rdi], 0
        jz      .done
        movzx   eax, byte[rdi]
        cmp     [rdx], al
        jnz     .try_next_option
        inc     rdi
        inc     rdx
        jmp     .next_char
.opt_name_ok:
        inc     rdi
        mov     rsi, rdi
        call    qword[rbx+8]
.done:
        ret
 
parse_line:
.next_line:
        cmp     byte[rsi], 0
        jz      .done
        cmp     byte[rsi], 0xd  ; '\r'
        jz      .skip
        cmp     byte[rsi], 0xa  ; '\n'
        jz      .skip
        cmp     byte[rsi], '#'
        jz      .skip
        call    parse_option
        call    skip_line
        jmp     .next_line
.skip:
        call    skip_line
        jmp     .next_line
.done:
        ret
 
cfg_opt_func_resolution:
        call    dec2bin
        xor     edx, edx
        mov     [rdx+BOOT_LO.x_res], ax
        cmp     byte[rsi], 'x'
        jz      @f
        cmp     byte[rsi], '*'
        jz      @f
        jmp     .done
@@:
        inc     rsi
        call    dec2bin
        xor     edx, edx
        mov     [rdx+BOOT_LO.y_res], ax
        mov     [cfg_opt_used_resolution], 1
.done:
        ret
 
cfg_opt_func_acpi:
        call    dec2bin
        mov     [cfg_opt_used_acpi], 1
        mov     [cfg_opt_value_acpi], al
        ret
 
cfg_opt_func_debug_print:
        call    dec2bin
        mov     [cfg_opt_used_debug_print], 1
        mov     [cfg_opt_value_debug_print], al
        ret
 
cfg_opt_func_launcher_start:
        call    dec2bin
        mov     [cfg_opt_used_launcher_start], 1
        mov     [cfg_opt_value_launcher_start], al
        ret
 
cfg_opt_func_mtrr:
        call    dec2bin
        mov     [cfg_opt_used_mtrr], 1
        mov     [cfg_opt_value_mtrr], al
        ret
 
cfg_opt_func_ask_params:
        call    dec2bin
        mov     [cfg_opt_used_ask_params], 1
        mov     [cfg_opt_value_ask_params], al
        ret
 
cfg_opt_func_imgfrom:
        call    dec2bin
        mov     [cfg_opt_used_imgfrom], 1
        mov     [cfg_opt_value_imgfrom], al
        ret
 
cfg_opt_func_syspath:
        mov     rdi, cfg_opt_value_syspath
.next_char:
        movzx   eax, byte[rsi]
        cmp     al, 0xd ; \r
        jz      .done
        cmp     al, 0xa ; \n
        jz      .done
        inc     rsi
        stosb
        jmp     .next_char
.done:
        mov     byte[rdi], 0
        ret
 
proc parse_config uses rbx rsi rdi, _buffer
        mov     rsi, rcx
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_parsing_config
.next_line:
        call    parse_line
        cmp     byte[rsi], 0
        jnz     .next_line
        ret
endp
 
proc read_options_from_config
        mov     r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
        fstcall [r10+EFI_BOOT_SERVICES.HandleProtocol], [efi_handle], \
                lip_guid, lip_interface
        test    eax, eax
        jz      @f
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error_efi_lip_handle
        jmp     $
@@:
        mov     r11, [lip_interface]
        mov     r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
        fstcall [r10+EFI_BOOT_SERVICES.HandleProtocol], \
                [r11+EFI_LOADED_IMAGE_PROTOCOL.DeviceHandle], sfsp_guid, \
                sfsp_interface
        test    eax, eax
        jz      @f
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error_lip_dev_sfsp
        jmp     $
@@:
        mov     r10, [sfsp_interface]
        fstcall [r10+EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.OpenVolume], \
                [sfsp_interface], esp_root
        test    eax, eax
        jz      @f
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error_sfsp_openvolume
        jmp     $
@@:
        fstcall load_file, [esp_root], file_name, KERNEL_BASE, \
                FILE_BUFFER_SIZE, 0     ; not fatal
 
        test    eax, eax
        jz      @f
        fstcall parse_config, KERNEL_BASE
@@:
 
.error:
        ret
endp
 
proc print_vmode uses rax rbx rcx rdx rsi rdi
        mov     r10, rcx
        call    clearbuf
        mov     eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
        mov     rdi, msg
        call    num2dec
        mov     eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
        mov     rdi, msg+8*2
        call    num2dec
 
        mov     eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat]
        mov     rdi, msg+16*2
        call    num2dec
 
        mov     eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelsPerScanLine]
        mov     rdi, msg+24*2
        call    num2dec
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        ret
endp
 
proc find_vmode_index_by_resolution
        mov     [cfg_opt_used_resolution], 1
        mov     [cfg_opt_value_vmode], 0
.next_mode:
        movzx   edx, [cfg_opt_value_vmode]
        mov     r10, [gop_interface]
        fstcall [r10+EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode], [gop_interface], \
                rdx, gop_info_size, gop_info
        cmp     rax, EFI_SUCCESS
        jnz     .error
        mov     rcx, [gop_info]
        fstcall print_vmode
        ; PixelBlueGreenRedReserved8BitPerColor
        cmp     [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat], 1
        jnz     .skip_mode
        xor     edx, edx
        mov     eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
        cmp     ax, [rdx+BOOT_LO.x_res]
        jnz     .skip_mode
        mov     eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
        cmp     ax, [rdx+BOOT_LO.y_res]
        jnz     .skip_mode
        jmp     .done
.skip_mode:
        inc     [cfg_opt_value_vmode]
        movzx   eax, [cfg_opt_value_vmode]
        mov     rcx, [gop_interface]
        mov     rdx, [rcx+EFI_GRAPHICS_OUTPUT_PROTOCOL.Mode]
        cmp     eax, [rdx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.MaxMode]
        jnz     .next_mode
        mov     [cfg_opt_used_resolution], 0
        mov     [cfg_opt_value_ask_params], 1
 
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error_no_such_vmode
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error
        jmp     $
.error:
.done:
        ret
endp
 
ask_for_params:
        jmp     $
 
proc detect_pci_config
        fstcall get_protocol_interface, pcirbiop_guid
        mov     [pcirbiop_interface], rax
        mov     r10, rax
        fstcall [r10+EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Configuration], r10, \
                pcirbiop_resources
;        fstcall dump_pci_resources
        fstcall get_last_pci_bus
        call    clearbuf
        movzx   eax, [pci_last_bus]
        mov     rdi, msg
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_pci_last_bus
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        ret
endp
 
proc get_last_pci_bus
        mov     rsi, [pcirbiop_resources]
.next_resource:
        cmp     [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.Type], \
                EFI_RESOURCE_DESCRIPTOR_TYPE.END_TAG
        jz      .not_found
        mov     rax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.RangeMaximum]
        cmp     [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.ResourceType], \
                EFI_RESOURCE_TYPE.BUS
        jz      .found
        movzx   eax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.Length]
        lea     rsi, [rsi+rax+3]
        jmp     .next_resource
.found:
        mov     [pci_last_bus], al
.not_found:
        ret
endp
 
proc main _efi_handle, _efi_table
        mov     [efi_handle], rcx
        mov     [efi_table], rdx
        mov     rbx, rdx
 
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.Reset], rcx, 1
        test    eax, eax
        jnz     $       ; what can I do here?
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_u4k_loaded
 
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_detect_pci_config
        fstcall detect_pci_config
 
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_read_options
        fstcall read_options_from_config
 
        ; read kernel file
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_load_kernel
        fstcall load_file, [esp_root], kernel_name, KERNEL_BASE, \
                MAX_FILE_SIZE, 1 ; fatal
 
        ; read ramdisk image
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_load_ramdisk
        fstcall load_file, [esp_root], ramdisk_name, RAMDISK_BASE, \
                MAX_FILE_SIZE, 1 ; fatal
 
        ; alloc buffer for devices.dat
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_alloc_devicesdat
        mov     r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
        fstcall [r10+EFI_BOOT_SERVICES.AllocatePages], \
                EFI_ALLOCATE_MAX_ADDRESS, EFI_RESERVED_MEMORY_TYPE, 1, \
                devicesdat_data
        cmp     eax, EFI_SUCCESS
        jnz     .error
 
        ; read devices.dat
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_load_devicesdat
 
        fstcall load_file, [esp_root], devicesdat_name, [devicesdat_data], \
                [devicesdat_size], 0    ; not fatal
        mov     [devicesdat_size], rax
 
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_locate_gop_interface
 
        fstcall get_protocol_interface, gop_guid
        mov     [gop_interface], rax
 
        fstcall find_rsdp
 
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_acpi_tables_done
 
        cmp     [cfg_opt_used_resolution], 0
        jz      .not_used_resolution
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_opt_resolution
        call    clearbuf
        xor     edx, edx
        movzx   eax, [rdx+BOOT_LO.x_res]
        mov     rdi, msg
        call    num2dec
        xor     edx, edx
        movzx   eax, [rdx+BOOT_LO.y_res]
        mov     rdi, msg+8*2
        call    num2dec
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        fstcall find_vmode_index_by_resolution
.not_used_resolution:
        cmp     [cfg_opt_used_debug_print], 0
        jz      .not_used_debug_print
        movzx   eax, [cfg_opt_value_debug_print]
        xor     edx, edx
        mov     [rdx+BOOT_LO.debug_print], al
.not_used_debug_print:
 
        cmp     [cfg_opt_value_ask_params], 0
        jz      @f
        call    ask_for_params
@@:
 
        movzx   edx, [cfg_opt_value_vmode]
        mov     r10, [gop_interface]
        fstcall [r10+EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode], [gop_interface], rdx
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     rdi, msg
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error
        jmp     $
@@:
 
        mov     rcx, [gop_interface]
        mov     rdx, [rcx+EFI_GRAPHICS_OUTPUT_PROTOCOL.Mode]
        mov     rdi, [rdx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.FrameBufferBase]
        mov     [fb_base], rdi
 
        mov     edx, [rdx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.Mode]
        mov     r10, [gop_interface]
        fstcall [r10+EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode], [gop_interface], \
                rdx, gop_info_size, gop_info
        test    eax, eax
        jz      @f
        jmp     .error
@@:
        mov     rcx, [gop_info]
        mov     eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
        xor     rdx, rdx
        mov     [rdx+BOOT_LO.x_res], ax
        mov     eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
        mov     [rdx+BOOT_LO.y_res], ax
        mov     eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelsPerScanLine]
        shl     eax, 2
        mov     [rdx+BOOT_LO.pitch], ax
 
        mov     [rdx+BOOT_LO.pci_data.access_mechanism], 1
        movzx   eax, [pci_last_bus]
        mov     [rdx+BOOT_LO.pci_data.last_bus], al
        mov     [rdx+BOOT_LO.pci_data.version], 0x0300  ; PCI 3.0
        mov     [rdx+BOOT_LO.pci_data.pm_entry], 0
 
        ; kernel
;        fstcall BootServices, AllocatePages, EFI_RESERVED_MEMORY_TYPE, \
;                450000/0x1000, EFI_ALLOCATE_ADDRESS
 
        ; ramdisk
;        fstcall BootServices, AllocatePages, EFI_RESERVED_MEMORY_TYPE, \
;                2880*512/0x1000, EFI_ALLOCATE_ADDRESS
 
        fstcall calc_memmap
;        fstcall dump_memmap
 
        mov     r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
        fstcall [r10+EFI_BOOT_SERVICES.ExitBootServices], [efi_handle], \
                [memory_map_key]
        fstcall halt_on_error
 
        cli
 
        xor     edx, edx
        xor     esi, esi
        mov     [rsi+BOOT_LO.bpp], 32
        mov     [rsi+BOOT_LO.vesa_mode], dx
        mov     [rsi+BOOT_LO.bank_switch], edx
        mov     rdi, [fb_base]
        mov     [rsi+BOOT_LO.lfb], edi
 
        movzx   eax, [cfg_opt_value_mtrr]
        mov     [rsi+BOOT_LO.mtrr], al
 
        movzx   eax, [cfg_opt_value_launcher_start]
        mov     [rsi+BOOT_LO.launcher_start], al
 
        movzx   eax, [cfg_opt_value_debug_print]
        mov     [rsi+BOOT_LO.debug_print], al
 
        mov     [rsi+BOOT_LO.dma], dl
        mov     [rsi+BOOT_LO.apm_entry], edx
        mov     [rsi+BOOT_LO.apm_version], dx
        mov     [rsi+BOOT_LO.apm_flags], dx
        mov     [rsi+BOOT_LO.apm_code_32], dx
        mov     [rsi+BOOT_LO.apm_code_16], dx
        mov     [rsi+BOOT_LO.apm_data_16], dx
        mov     [rsi+BOOT_LO.bios_hd_cnt], dl
 
        movzx   eax, [cfg_opt_value_imgfrom]
        mov     [rsi+BOOT_LO.rd_load_from], al
 
        mov     eax, dword[devicesdat_size]
        mov     [rdx+BOOT_LO.devicesdat_size], eax
        mov     eax, dword[devicesdat_data]
        mov     [rdx+BOOT_LO.devicesdat_data], eax
 
        mov     rsi, cfg_opt_value_syspath
        mov     rdi, BOOT_LO.syspath
        mov     ecx, 0x17
        rep movsb
 
        ; kernel trampoline
        mov     rsi, kernel_trampoline
        mov     rdi, KERNEL_TRAMPOLINE
        mov     ecx, kernel_trampoline.size
        rep movsb
 
        mov     rax, GDTR
        lgdt    [cs:rax]
 
        mov     ax, DATA_32_SELECTOR
        mov     ds, ax
        mov     es, ax
        mov     fs, ax
        mov     gs, ax
        mov     ss, ax
 
        push    CODE_32_SELECTOR
        mov     rax, KERNEL_TRAMPOLINE
        push    rax
        retf
 
.error:
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error
        jmp     $
endp
 
proc halt_on_error
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     rdi, msg
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        jmp     $
@@:
        ret
endp
 
proc get_protocol_interface uses rsi rdi, _guid
locals
        .status dq ?
endl
        mov     [_guid], rcx
        mov     [prot_handlers_buffer_size], PROTOCOL_HANDLERS_BUFFER_SIZE
        mov     r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
        fstcall [r10+EFI_BOOT_SERVICES.LocateHandle], \
                EFI_LOCATE_SEARCH_TYPE.ByProtocol, [_guid], 0, \
                prot_handlers_buffer_size, prot_handlers_buffer
        mov     [.status], rax
 
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_protocol_buffer_size
        call    clearbuf
        mov     rax, [prot_handlers_buffer_size]
        mov     rdi, msg
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
 
        mov     rax, [.status]
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     rdi, msg
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        jmp     $
@@:
 
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_look_for_handler
 
        mov     rsi, prot_handlers_buffer
.try_next_handle:
        mov     rax, rsi
        mov     rcx, prot_handlers_buffer
        sub     rax, rcx
        cmp     rax, [prot_handlers_buffer_size]
        jb      @f
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error_out_of_handlers
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_error
        jmp     $
@@:
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_query_handler
 
        mov     r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
        fstcall [r10+EFI_BOOT_SERVICES.HandleProtocol], qword[rsi], [_guid], \
                prot_interface
;mov rax, 0x8000_0000_0000_0003
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     rdi, msg
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
 
        add     rsi, 8
        jmp     .try_next_handle
@@:
        mov     rax, [prot_interface]
        ret
endp
 
 
proc find_rsdp uses rsi rdi
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_look_for_rsdp
 
        mov     rdi, [rbx+EFI_SYSTEM_TABLE.ConfigurationTable]
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.NumberOfTableEntries]
        mov     rax, 0x11d3e4f18868e871
        mov     rdx, 0x81883cc7800022bc
.next_table:
        dec     ecx
        js      .all_tables_done
        cmp     [rdi+0], rax
        jnz     .not_acpi20
        cmp     [rdi+8], rdx
        jnz     .not_acpi20
        mov     rax, [rdi+16]
        mov     rdx, BOOT_LO.acpi_rsdp
        mov     [rdx], eax
        jmp     .all_tables_done
.not_acpi20:
        add     rdi, 24
        jmp     .next_table
.all_tables_done:
        ret
endp
 
proc dump_pci_resources uses rsi rdi
        xor     eax, eax
        mov     rsi, [pcirbiop_resources]
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_dump_pci_resources
.next_resource:
        call    clearbuf
        movzx   eax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.Type]
        cmp     eax, EFI_RESOURCE_DESCRIPTOR_TYPE.END_TAG
        jz      .done
        mov     rdi, msg
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        call    clearbuf
        movzx   eax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.ResourceType]
        mov     rdi, msg
        call    num2dec
        mov     rax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.RangeMinimum]
        mov     rdi, msg+2*2
        call    num2hex
        mov     rax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.RangeMaximum]
        mov     rdi, msg+19*2
        call    num2hex
        mov     rax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.TranslationOffset]
        mov     rdi, msg+36*2
        call    num2hex
        mov     rax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.AddressLength]
        mov     rdi, msg+53*2
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        movzx   eax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.Length]
        add     eax, 3
        add     rsi, rax
        jmp     .next_resource
.done:
        ret
endp
 
proc calc_memmap uses rsi rdi
        mov     r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
        fstcall [r10+EFI_BOOT_SERVICES.AllocatePages], EFI_ALLOCATE_ANY_PAGES, \
                EFI_RESERVED_MEMORY_TYPE, MEMORY_MAP_SIZE/0x1000, memory_map
        call    halt_on_error
 
        mov     r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
        fstcall [r10+EFI_BOOT_SERVICES.GetMemoryMap], memory_map_size, \
                [memory_map], memory_map_key, descriptor_size, descriptor_ver
        call    halt_on_error
 
        mov     rdi, BOOT_LO.memmap_blocks
        mov     dword[rdi-4], 0 ; memmap_block_cnt
        mov     rsi, [memory_map]
        mov     r10, rsi
        add     r10, [memory_map_size]
.next_descr:
        fstcall add_uefi_memmap
        add     rsi, [descriptor_size]
        cmp     rsi, r10
        jb      .next_descr
        ret
endp
 
proc dump_memmap uses rsi rdi
        xor     eax, eax
        mov     rsi, BOOT_LO.memmap_blocks
        mov     r12, [rax+BOOT_LO.memmap_block_cnt]
 
        call    clearbuf
        mov     eax, ebx
        mov     rdi, msg
        call    num2dec
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
                msg_memmap
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        call    clearbuf
.next_mapping:
        dec     r12d
        js      .done
        mov     rax, rsi
        mov     rcx, BOOT_LO.memmap_blocks
        sub     rax, rcx
        mov     ecx, sizeof.e820entry
        xor     edx, edx
        div     ecx
        mov     rdi, msg
        call    num2dec
        mov     rax, [rsi+e820entry.addr]
        mov     rdi, msg+4*2
        call    num2hex
        mov     rax, [rsi+e820entry.size]
        mov     rdi, msg+24*2
        call    num2hex
        mov     rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
        add     rsi, sizeof.e820entry
        jmp     .next_mapping
.done:
        ret
endp
 
; linux/arch/x86/platform/efi/efi.c
; do_add_efi_memmap
proc add_uefi_memmap
        xor     eax, eax
        cmp     [rax+BOOT_LO.memmap_block_cnt], MAX_MEMMAP_BLOCKS
        jz      .done
 
        mov     rax, [rsi+EFI_MEMORY_DESCRIPTOR.PhysicalStart]
        mov     [rdi+e820entry.addr], rax
 
        mov     rax, [rsi+EFI_MEMORY_DESCRIPTOR.NumberOfPages]
        shl     rax, 12
        mov     [rdi+e820entry.size], rax
 
        mov     ecx, [rsi+EFI_MEMORY_DESCRIPTOR.Type]
        cmp     ecx, EFI_LOADER_CODE
        jz      .mem_ram_if_wb
        cmp     ecx, EFI_LOADER_DATA
        jz      .mem_ram_if_wb
        cmp     ecx, EFI_BOOT_SERVICES_CODE
        jz      .mem_ram_if_wb
        cmp     ecx, EFI_BOOT_SERVICES_DATA
        jz      .mem_ram_if_wb
        cmp     ecx, EFI_CONVENTIONAL_MEMORY
        jz      .mem_ram_if_wb
        cmp     ecx, EFI_ACPI_RECLAIM_MEMORY
        mov     eax, E820_ACPI
        jz      .type_done
        cmp     ecx, EFI_ACPI_MEMORY_NVS
        mov     eax, E820_NVS
        jz      .type_done
        cmp     ecx, EFI_UNUSABLE_MEMORY
        mov     eax, E820_UNUSABLE
        jz      .type_done
        cmp     ecx, EFI_PERSISTENT_MEMORY
        mov     eax, E820_PMEM
        jz      .type_done
        jmp     .reserved
.mem_ram_if_wb:
        test    [rsi+EFI_MEMORY_DESCRIPTOR.Attribute], dword EFI_MEMORY_WB
        mov     eax, E820_RAM
        jnz     .type_done
.reserved:
        mov     eax, E820_RESERVED
.type_done:
        mov     [rdi+e820entry.type], eax
        cmp     eax, E820_RAM
        jnz     @f
        xor     eax, eax
        inc     [rax+BOOT_LO.memmap_block_cnt]
        add     rdi, sizeof.e820entry
@@:
.done:
        ret
endp
 
num2dec:
        push    rbx rcx rdx rdi
 
        xor     ecx, ecx
        mov     ebx, 10
.next_digit:
        xor     edx, edx
        div     ebx
        push    rdx
        inc     ecx
        test    eax, eax
        jnz     .next_digit
 
.next_char:
        pop     rax
        add     eax, '0'
        stosw
        loop    .next_char
 
        pop     rdi rdx rcx rbx
        ret
 
 
num2hex:
        push    rbx rcx rdx rdi
 
        xchg    rdx, rax
        mov     ecx, 16
.next_tetra:
        rol     rdx, 4
        movzx   eax, dl
        and     eax, 0x0f
        movzx   eax, byte[hex_abc+eax]
        stosw
        loop    .next_tetra
 
        pop     rdi rdx rcx rbx
        ret
 
clearbuf:
        push    rcx rdi
        mov     eax, ' '
        mov     ecx, 79
        mov     rdi, msg
        rep stosw
        pop     rdi rcx
        ret
 
use32
kernel_trampoline:
org KERNEL_TRAMPOLINE
        mov     eax, cr0
        and     eax, not CR0_PG
        mov     cr0, eax
 
        mov     ecx, MSR_AMD_EFER
        rdmsr
        btr     eax, 8                  ; LME
        wrmsr
 
        mov     eax, cr4
        and     eax, not CR4_PAE
        mov     cr4, eax
 
        mov     eax, KERNEL_BASE
        ; add the 32-bit entry point
        add     eax, [eax+kernel_header.b32_offset]
        push    eax
        retn
 
align 16
GDTR:
        dw 4*8-1
        dq GDT
align 16
GDT:
        dw 0, 0, 0, 0
        dw 0FFFFh,0,9A00h,0CFh          ; 32-bit code
        dw 0FFFFh,0,9200h,0CFh          ; flat data
        dw 0FFFFh,0,9A00h,0AFh          ; 64-bit code
assert $ < BOOT_LO
kernel_trampoline.size = $ - KERNEL_TRAMPOLINE
 
section '.rodata' data readable
gop_guid        db EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID
lip_guid        db EFI_LOADED_IMAGE_PROTOCOL_GUID
sfsp_guid       db EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID
pcirbiop_guid   db EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID
 
file_name       du '\EFI\KOLIBRIOS\KOLIBRI.INI',0
kernel_name     du '\EFI\KOLIBRIOS\KOLIBRI.KRN',0
ramdisk_name    du '\EFI\KOLIBRIOS\KOLIBRI.IMG',0
devicesdat_name du '\EFI\KOLIBRIOS\DEVICES.DAT',0
 
config_options  dq cfg_opt_name_resolution, cfg_opt_func_resolution, \
                   cfg_opt_cmnt_resolution, \
                   cfg_opt_name_acpi,  cfg_opt_func_acpi, cfg_opt_cmnt_acpi, \
                   cfg_opt_name_debug_print, cfg_opt_func_debug_print, \
                   cfg_opt_cmnt_debug_print, \
                   cfg_opt_name_launcher_start, cfg_opt_func_launcher_start, \
                   cfg_opt_cmnt_launcher_start, \
                   cfg_opt_name_mtrr,  cfg_opt_func_mtrr, cfg_opt_cmnt_mtrr, \
                   cfg_opt_name_ask_params,  cfg_opt_func_ask_params, \
                   cfg_opt_cmnt_ask_params, \
                   cfg_opt_name_imgfrom, cfg_opt_func_imgfrom, \
                   cfg_opt_cmnt_imgfrom, \
                   cfg_opt_name_syspath, cfg_opt_func_syspath, \
                   cfg_opt_cmnt_syspath, \
                   0
 
cfg_opt_name_resolution     db "resolution",0
cfg_opt_name_acpi           db "acpi",0
cfg_opt_name_debug_print    db "debug_print",0
cfg_opt_name_launcher_start db "launcher_start",0
cfg_opt_name_mtrr           db "mtrr",0
cfg_opt_name_ask_params     db "ask_params",0
cfg_opt_name_imgfrom        db "imgfrom",0
cfg_opt_name_syspath        db "syspath",0
 
cfg_opt_cmnt_resolution     db "# Graphic mode",0
cfg_opt_cmnt_acpi           db "# ACPI settings",0xa, \
                               "#   0: don't use",0xa, \
                               "#   1: parse ACPI tables",0xa, \
                               "#   2: + call _PIC method",0xa, \
                               "#   3: + get APIC interrupts",0xa,0
cfg_opt_cmnt_debug_print    db "# Duplicate debug output to the screen",0
cfg_opt_cmnt_launcher_start db "# Start LAUNCHER app after kernel is loaded",0
cfg_opt_cmnt_mtrr           db "# Configure MTRR's",0
cfg_opt_cmnt_ask_params     db "# Interrupt booting to ask the user for boot", \
                               " params",0
cfg_opt_cmnt_imgfrom        db "# Where to load ramdisk image from",0
cfg_opt_cmnt_syspath        db "# Path to /sys directory",0
 
msg_u4k_loaded            du "uefi64kos loaded",13,10,0
msg_detect_pci_config     du "Detect PCI configuration",13,10,0
msg_dump_pci_resources    du "Dump PCI resources",13,10,0
msg_pci_last_bus          du "Last PCI bus",13,10,0
msg_read_options          du "Read options from config file",13,10,0
msg_file_size             du "File size:",13,10,0
msg_parsing_config        du "Parsing config file",13,10,0
msg_load_kernel           du "Load kernel",13,10,0
msg_load_ramdisk          du "Load ramdisk",13,10,0
msg_load_devicesdat       du "Load DEVICES.DAT",13,10,0
msg_alloc_devicesdat      du "Allocate memory for DEVICES.DAT",13,10,0
msg_locate_gop_interface  du "Locate GOP interface",13,10,0
msg_look_for_handler      du "Look for protocol handler",13,10,0
msg_query_handler         du "Query handler",13,10,0
msg_query_vmode           du "Query vmode",13,10,0
msg_vmode_found           du "Video mode found",13,10,0
msg_look_for_rsdp         du "Look for RSDP",13,10,0
msg_rsdp_found            du "RSDP found",13,10,0
msg_acpi_tables_done      du "ACPI tables done",13,10,0
msg_ask_for_params        du "Ask for params",13,10,0
msg_set_graphic_mode      du "Set graphic mode",13,10,0
msg_success               du "Success!",13,10,0
msg_protocol_buffer_size  du "Protocol buffer size",13,10,0
msg_opt_resolution        du "Option resolution: ",0
msg_memmap                du "Memmap",13,10,0
msg_error                 du "Error!",13,10,0
msg_error_efi_lip_handle  du "efi_handle can't handle LIP",13,10,0
msg_error_lip_dev_sfsp    du "LIP device handle can't handle SFSP",13,10,0
msg_error_sfsp_openvolume du "SFSP OpenVolume failed",13,10,0
msg_error_no_such_vmode   du "No such vmode",13,10,0
msg_error_out_of_handlers du "Out of handlers",13,10,0
msg_error_open_file       du "Error: can't open file ",0
msg_error_exit_boot_services du "Error: Exit boot services",13,10,0
msg                       du 79 dup " ",13,10,0
msg_debug                 du "Debug ",13,10,0
 
section '.data' data readable writeable
efi_handle  dq 0
efi_table   dq 0
 
fb_base         dq 0
 
gop_interface   dq 0
gop_info_size   dq 0
gop_info        dq 0
 
lip_interface   dq 0
 
sfsp_interface  dq 0
 
pci_last_bus db 254
 
cfg_opt_used_resolution     db 0
cfg_opt_used_acpi           db 0
cfg_opt_used_debug_print    db 0
cfg_opt_used_launcher_start db 0
cfg_opt_used_mtrr           db 0
cfg_opt_used_ask_params     db 0
cfg_opt_used_imgfrom        db 0
cfg_opt_used_syspath        db 0
 
cfg_opt_value_vmode          db 0
cfg_opt_value_acpi           db 0
cfg_opt_value_debug_print    db 0
cfg_opt_value_launcher_start db 1
cfg_opt_value_mtrr           db 0
cfg_opt_value_ask_params     db 0
cfg_opt_value_imgfrom        db RD_LOAD_FROM_MEMORY
cfg_opt_value_syspath        db "/RD/1",0
                             rb 20
 
memory_map_key  dq 0
descriptor_size dq 0
descriptor_ver  dq 0
memory_map_size dq MEMORY_MAP_SIZE
 
efi_fs_info_id db EFI_FILE_SYSTEM_INFO_ID
efi_fs_info_size dq sizeof.EFI_FILE_SYSTEM_INFO
 
devicesdat_data dq 0xffffffff
devicesdat_size dq 0x1000
 
hex_abc db '0123456789ABCDEF'
 
section '.bss' data readable writeable discardable
prot_handlers_buffer_size dq ?
prot_interface  dq ?
esp_root        dq ?
file_handle     dq ?
pcirbiop_interface dq ?
pcirbiop_resources dq ?
efi_fs_info EFI_FILE_SYSTEM_INFO
memory_map      dq ?
prot_handlers_buffer rq PROTOCOL_HANDLERS_BUFFER_SIZE/8
pcirbio_buffer  rq PROTOCOL_HANDLERS_BUFFER_SIZE/8
 
section '.reloc' fixups data discardable

Rev 9958	Rev 9977
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2020-2024. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2020-2024. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; Version 2, or (at your option) any later version. ;;	5	;; Version 2, or (at your option) any later version. ;;
6	;; ;;	6	;; ;;
7	;; Written by Ivan Baravy ;;	7	;; Written by Ivan Baravy ;;
8	;; ;;	8	;; ;;
9	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	9	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10		10
11	format pe64 efi	11	format pe64 efi
12	entry main	12	entry main
13		13
14	section '.text' code executable readable	14	section '.text' code executable readable
15		15
16	include '../../struct.inc'	16	include '../../struct.inc'
17	include '../../macros.inc'	17	include '../../macros.inc'
18	include '../../kglobals.inc'	18	include '../../kglobals.inc'
19	fastcall fix fstcall	19	fastcall fix fstcall
20	include 'proc64.inc'	20	include 'proc64.inc'
21	include '../../const.inc'	21	include '../../const.inc'
22		22
23	purge DQ	23	purge DQ
24	include 'uefi64.inc'	24	include 'uefi64.inc'
25		25
26	MEMORY_MAP_SIZE = 0x10000	26	MEMORY_MAP_SIZE = 0x10000
27	PROTOCOL_HANDLERS_BUFFER_SIZE = 0x100	27	PROTOCOL_HANDLERS_BUFFER_SIZE = 0x100
28	FILE_BUFFER_SIZE = 0x1000	28	FILE_BUFFER_SIZE = 0x1000
29		29
30	KERNEL_TRAMPOLINE = 0x8f80 ; just before BOOT_LO	30	KERNEL_TRAMPOLINE = 0x8f80 ; just before BOOT_LO
31	MAX_FILE_SIZE = 0x10000000	31	MAX_FILE_SIZE = 0x10000000
32		32
33	CODE_32_SELECTOR = 8	33	CODE_32_SELECTOR = 8
34	DATA_32_SELECTOR = 16	34	DATA_32_SELECTOR = 16
35	CODE_64_SELECTOR = 24	35	CODE_64_SELECTOR = 24
36		36
37	; linux/arch/x86/include/uapi/asm/e820.h	37	; linux/arch/x86/include/uapi/asm/e820.h
38	E820_RAM = 1	38	E820_RAM = 1
39	E820_RESERVED = 2	39	E820_RESERVED = 2
40	E820_ACPI = 3	40	E820_ACPI = 3
41	E820_NVS = 4	41	E820_NVS = 4
42	E820_UNUSABLE = 5	42	E820_UNUSABLE = 5
43	E820_PMEM = 7	43	E820_PMEM = 7
44		44
45	proc load_file _root, _name, _buffer, _size, _fatal	45	proc load_file _root, _name, _buffer, _size, _fatal
46	mov [_root], rcx	46	mov [_root], rcx
47	mov [_name], rdx	47	mov [_name], rdx
48	mov [_buffer], r8	48	mov [_buffer], r8
49	mov [_size], r9	49	mov [_size], r9
50	mov r10, [_root]	50	mov r10, [_root]
51	mov r11, [_name]	51	mov r11, [_name]
52	fstcall [r10+EFI_FILE_PROTOCOL.Open], r10, file_handle, \	52	fstcall [r10+EFI_FILE_PROTOCOL.Open], r10, file_handle, \
53	r11, EFI_FILE_MODE_READ, 0	53	r11, EFI_FILE_MODE_READ, 0
54	test eax, eax	54	test eax, eax
55	jz @f	55	jz @f
56	mov [_size], 0	56	mov [_size], 0
57	cmp [_fatal], 1	57	cmp [_fatal], 1
58	jnz .done	58	jnz .done
59	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	59	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
60	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	60	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
61	msg_error_open_file	61	msg_error_open_file
62	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	62	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
63	mov rdx, [_name]	63	mov rdx, [_name]
64	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, [_name]	64	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, [_name]
65	jmp $	65	jmp $
66	@@:	66	@@:
67	lea rdx, [_size]	67	lea rdx, [_size]
68	mov r8, [_buffer]	68	mov r8, [_buffer]
69	mov r10, [file_handle]	69	mov r10, [file_handle]
70	fstcall [r10+EFI_FILE_PROTOCOL.Read], [file_handle], rdx, r8	70	fstcall [r10+EFI_FILE_PROTOCOL.Read], [file_handle], rdx, r8
71	mov r10, [file_handle]	71	mov r10, [file_handle]
72	fstcall [r10+EFI_FILE_PROTOCOL.Close], [file_handle]	72	fstcall [r10+EFI_FILE_PROTOCOL.Close], [file_handle]
73	.done:	73	.done:
74	call clearbuf	74	call clearbuf
75	mov rax, [_size]	75	mov rax, [_size]
76	mov rdi, msg	76	mov rdi, msg
77	call num2dec	77	call num2dec
78	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	78	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
79	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	79	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
80	msg_file_size	80	msg_file_size
81	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	81	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
82	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg	82	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
83	mov rax, [_size]	83	mov rax, [_size]
84	ret	84	ret
85	endp	85	endp
86		86
87	skip_whitespace:	87	skip_whitespace:
88	.next_char:	88	.next_char:
89	cmp byte[rsi], 0	89	cmp byte[rsi], 0
90	jz .done	90	jz .done
91	cmp byte[rsi], 0x20 ; ' '	91	cmp byte[rsi], 0x20 ; ' '
92	jz .whitespace	92	jz .whitespace
93	cmp byte[rsi], 9 ; '\t'	93	cmp byte[rsi], 9 ; '\t'
94	jz .whitespace	94	jz .whitespace
95	jmp .done	95	jmp .done
96	.whitespace:	96	.whitespace:
97	inc rsi	97	inc rsi
98	jmp .next_char	98	jmp .next_char
99	.done:	99	.done:
100	ret	100	ret
101		101
102	skip_until_newline:	102	skip_until_newline:
103	.next_char:	103	.next_char:
104	cmp byte[rsi], 0	104	cmp byte[rsi], 0
105	jz .done	105	jz .done
106	cmp byte[rsi], 0xd ; '\r'	106	cmp byte[rsi], 0xd ; '\r'
107	jz .done	107	jz .done
108	cmp byte[rsi], 0xa ; '\n'	108	cmp byte[rsi], 0xa ; '\n'
109	jz .done	109	jz .done
110	inc rsi	110	inc rsi
111	jmp .next_char	111	jmp .next_char
112	.done:	112	.done:
113	ret	113	ret
114		114
115	skip_newline:	115	skip_newline:
116	.next_char:	116	.next_char:
117	cmp byte[rsi], 0xd ; '\r'	117	cmp byte[rsi], 0xd ; '\r'
118	jz .newline	118	jz .newline
119	cmp byte[rsi], 0xa ; '\n'	119	cmp byte[rsi], 0xa ; '\n'
120	jz .newline	120	jz .newline
121	jmp .done	121	jmp .done
122	.newline:	122	.newline:
123	inc rsi	123	inc rsi
124	jmp .next_char	124	jmp .next_char
125	.done:	125	.done:
126	ret	126	ret
127		127
128	skip_line:	128	skip_line:
129	call skip_until_newline	129	call skip_until_newline
130	call skip_newline	130	call skip_newline
131	ret	131	ret
132		132
133	dec2bin:	133	dec2bin:
134	mov edx, 0	134	xor edx, edx
135	.next_char:	135	.next_char:
136	movzx eax, byte[rsi]	136	movzx eax, byte[rsi]
137	test eax, eax	137	test eax, eax
138	jz .done	138	jz .done
139	sub eax, '0'	139	sub eax, '0'
140	jb .done	140	jb .done
141	cmp eax, 9	141	cmp eax, 9
142	ja .done	142	ja .done
143	inc rsi	143	inc rsi
144	imul edx, 10	144	imul edx, 10
145	add edx, eax	145	add edx, eax
146	jmp .next_char	146	jmp .next_char
147	.done:	147	.done:
148	mov eax, edx	148	mov eax, edx
149	ret	149	ret
150		150
151	parse_option:	151	parse_option:
152	mov rbx, config_options-3*8	152	mov rbx, config_options-3*8
153	.try_next_option:	153	.try_next_option:
154	add rbx, 3*8	154	add rbx, 3*8
155	mov rdi, rsi	155	mov rdi, rsi
156	mov rdx, [rbx] ; option name	156	mov rdx, [rbx] ; option name
157	test rdx, rdx	157	test rdx, rdx
158	jz .done	158	jz .done
159	.next_char:	159	.next_char:
160	cmp byte[rdx], 0	160	cmp byte[rdx], 0
161	jnz @f	161	jnz @f
162	cmp byte[rdi], '='	162	cmp byte[rdi], '='
163	jz .opt_name_ok	163	jz .opt_name_ok
164	@@:	164	@@:
165	cmp byte[rdi], 0	165	cmp byte[rdi], 0
166	jz .done	166	jz .done
167	movzx eax, byte[rdi]	167	movzx eax, byte[rdi]
168	cmp [rdx], al	168	cmp [rdx], al
169	jnz .try_next_option	169	jnz .try_next_option
170	inc rdi	170	inc rdi
171	inc rdx	171	inc rdx
172	jmp .next_char	172	jmp .next_char
173	.opt_name_ok:	173	.opt_name_ok:
174	inc rdi	174	inc rdi
175	mov rsi, rdi	175	mov rsi, rdi
176	call qword[rbx+8]	176	call qword[rbx+8]
177	.done:	177	.done:
178	ret	178	ret
179		179
180	parse_line:	180	parse_line:
181	.next_line:	181	.next_line:
182	cmp byte[rsi], 0	182	cmp byte[rsi], 0
183	jz .done	183	jz .done
184	cmp byte[rsi], 0xd ; '\r'	184	cmp byte[rsi], 0xd ; '\r'
185	jz .skip	185	jz .skip
186	cmp byte[rsi], 0xa ; '\n'	186	cmp byte[rsi], 0xa ; '\n'
187	jz .skip	187	jz .skip
188	cmp byte[rsi], '#'	188	cmp byte[rsi], '#'
189	jz .skip	189	jz .skip
190	call parse_option	190	call parse_option
191	call skip_line	191	call skip_line
192	jmp .next_line	192	jmp .next_line
193	.skip:	193	.skip:
194	call skip_line	194	call skip_line
195	jmp .next_line	195	jmp .next_line
196	.done:	196	.done:
197	ret	197	ret
198		198
199	cfg_opt_func_resolution:	199	cfg_opt_func_resolution:
200	call dec2bin	200	call dec2bin
201	xor edx, edx	201	xor edx, edx
202	mov [rdx+BOOT_LO.x_res], ax	202	mov [rdx+BOOT_LO.x_res], ax
203	cmp byte[rsi], 'x'	203	cmp byte[rsi], 'x'
204	jz @f	204	jz @f
205	cmp byte[rsi], '*'	205	cmp byte[rsi], '*'
206	jz @f	206	jz @f
207	jmp .done	207	jmp .done
208	@@:	208	@@:
209	inc rsi	209	inc rsi
210	call dec2bin	210	call dec2bin
211	xor edx, edx	211	xor edx, edx
212	mov [rdx+BOOT_LO.y_res], ax	212	mov [rdx+BOOT_LO.y_res], ax
213	mov [cfg_opt_used_resolution], 1	213	mov [cfg_opt_used_resolution], 1
214	.done:	214	.done:
215	ret	215	ret
216		216
217	cfg_opt_func_acpi:	217	cfg_opt_func_acpi:
218	call dec2bin	218	call dec2bin
219	mov [cfg_opt_used_acpi], 1	219	mov [cfg_opt_used_acpi], 1
220	mov [cfg_opt_value_acpi], al	220	mov [cfg_opt_value_acpi], al
221	ret	221	ret
222		222
223	cfg_opt_func_debug_print:	223	cfg_opt_func_debug_print:
224	call dec2bin	224	call dec2bin
225	mov [cfg_opt_used_debug_print], 1	225	mov [cfg_opt_used_debug_print], 1
226	mov [cfg_opt_value_debug_print], al	226	mov [cfg_opt_value_debug_print], al
227	ret	227	ret
228		228
229	cfg_opt_func_launcher_start:	229	cfg_opt_func_launcher_start:
230	call dec2bin	230	call dec2bin
231	mov [cfg_opt_used_launcher_start], 1	231	mov [cfg_opt_used_launcher_start], 1
232	mov [cfg_opt_value_launcher_start], al	232	mov [cfg_opt_value_launcher_start], al
233	ret	233	ret
234		234
235	cfg_opt_func_mtrr:	235	cfg_opt_func_mtrr:
236	call dec2bin	236	call dec2bin
237	mov [cfg_opt_used_mtrr], 1	237	mov [cfg_opt_used_mtrr], 1
238	mov [cfg_opt_value_mtrr], al	238	mov [cfg_opt_value_mtrr], al
239	ret	239	ret
240		240
241	cfg_opt_func_ask_params:	241	cfg_opt_func_ask_params:
242	call dec2bin	242	call dec2bin
243	mov [cfg_opt_used_ask_params], 1	243	mov [cfg_opt_used_ask_params], 1
244	mov [cfg_opt_value_ask_params], al	244	mov [cfg_opt_value_ask_params], al
245	ret	245	ret
246		246
247	cfg_opt_func_imgfrom:	247	cfg_opt_func_imgfrom:
248	call dec2bin	248	call dec2bin
249	mov [cfg_opt_used_imgfrom], 1	249	mov [cfg_opt_used_imgfrom], 1
250	mov [cfg_opt_value_imgfrom], al	250	mov [cfg_opt_value_imgfrom], al
251	ret	251	ret
252		252
253	cfg_opt_func_syspath:	253	cfg_opt_func_syspath:
254	mov rdi, cfg_opt_value_syspath	254	mov rdi, cfg_opt_value_syspath
255	.next_char:	255	.next_char:
256	movzx eax, byte[rsi]	256	movzx eax, byte[rsi]
257	cmp al, 0xd ; \r	257	cmp al, 0xd ; \r
258	jz .done	258	jz .done
259	cmp al, 0xa ; \n	259	cmp al, 0xa ; \n
260	jz .done	260	jz .done
261	inc rsi	261	inc rsi
262	stosb	262	stosb
263	jmp .next_char	263	jmp .next_char
264	.done:	264	.done:
265	mov byte[rdi], 0	265	mov byte[rdi], 0
266	ret	266	ret
267		267
268	proc parse_config uses rbx rsi rdi, _buffer	268	proc parse_config uses rbx rsi rdi, _buffer
269	mov rsi, rcx	269	mov rsi, rcx
270	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	270	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
271	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	271	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
272	msg_parsing_config	272	msg_parsing_config
273	.next_line:	273	.next_line:
274	call parse_line	274	call parse_line
275	cmp byte[rsi], 0	275	cmp byte[rsi], 0
276	jnz .next_line	276	jnz .next_line
277	ret	277	ret
278	endp	278	endp
279		279
280	proc read_options_from_config	280	proc read_options_from_config
281	mov r10, [rbx+EFI_SYSTEM_TABLE.BootServices]	281	mov r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
282	fstcall [r10+EFI_BOOT_SERVICES.HandleProtocol], [efi_handle], \	282	fstcall [r10+EFI_BOOT_SERVICES.HandleProtocol], [efi_handle], \
283	lip_guid, lip_interface	283	lip_guid, lip_interface
284	test eax, eax	284	test eax, eax
285	jz @f	285	jz @f
286	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	286	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
287	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	287	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
288	msg_error_efi_lip_handle	288	msg_error_efi_lip_handle
289	jmp $	289	jmp $
290	@@:	290	@@:
291	mov r11, [lip_interface]	291	mov r11, [lip_interface]
292	mov r10, [rbx+EFI_SYSTEM_TABLE.BootServices]	292	mov r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
293	fstcall [r10+EFI_BOOT_SERVICES.HandleProtocol], \	293	fstcall [r10+EFI_BOOT_SERVICES.HandleProtocol], \
294	[r11+EFI_LOADED_IMAGE_PROTOCOL.DeviceHandle], sfsp_guid, \	294	[r11+EFI_LOADED_IMAGE_PROTOCOL.DeviceHandle], sfsp_guid, \
295	sfsp_interface	295	sfsp_interface
296	test eax, eax	296	test eax, eax
297	jz @f	297	jz @f
298	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	298	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
299	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	299	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
300	msg_error_lip_dev_sfsp	300	msg_error_lip_dev_sfsp
301	jmp $	301	jmp $
302	@@:	302	@@:
303	mov r10, [sfsp_interface]	303	mov r10, [sfsp_interface]
304	fstcall [r10+EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.OpenVolume], \	304	fstcall [r10+EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.OpenVolume], \
305	[sfsp_interface], esp_root	305	[sfsp_interface], esp_root
306	test eax, eax	306	test eax, eax
307	jz @f	307	jz @f
308	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	308	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
309	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	309	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
310	msg_error_sfsp_openvolume	310	msg_error_sfsp_openvolume
311	jmp $	311	jmp $
312	@@:	312	@@:
313	fstcall load_file, [esp_root], file_name, KERNEL_BASE, \	313	fstcall load_file, [esp_root], file_name, KERNEL_BASE, \
314	FILE_BUFFER_SIZE, 0 ; not fatal	314	FILE_BUFFER_SIZE, 0 ; not fatal
315		315
316	test eax, eax	316	test eax, eax
317	jz @f	317	jz @f
318	fstcall parse_config, KERNEL_BASE	318	fstcall parse_config, KERNEL_BASE
319	@@:	319	@@:
320		320
321	.error:	321	.error:
322	ret	322	ret
323	endp	323	endp
324		324
325	proc print_vmode uses rax rbx rcx rdx rsi rdi	325	proc print_vmode uses rax rbx rcx rdx rsi rdi
326	mov r10, rcx	326	mov r10, rcx
327	call clearbuf	327	call clearbuf
328	mov eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]	328	mov eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
329	mov rdi, msg	329	mov rdi, msg
330	call num2dec	330	call num2dec
331	mov eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]	331	mov eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
332	mov rdi, msg+8*2	332	mov rdi, msg+8*2
333	call num2dec	333	call num2dec
334		334
335	mov eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat]	335	mov eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat]
336	mov rdi, msg+16*2	336	mov rdi, msg+16*2
337	call num2dec	337	call num2dec
338		338
339	mov eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelsPerScanLine]	339	mov eax, [r10+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelsPerScanLine]
340	mov rdi, msg+24*2	340	mov rdi, msg+24*2
341	call num2dec	341	call num2dec
342	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	342	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
343	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg	343	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
344	ret	344	ret
345	endp	345	endp
346		346
347	proc find_vmode_index_by_resolution	347	proc find_vmode_index_by_resolution
348	mov [cfg_opt_used_resolution], 1	348	mov [cfg_opt_used_resolution], 1
349	mov [cfg_opt_value_vmode], 0	349	mov [cfg_opt_value_vmode], 0
350	.next_mode:	350	.next_mode:
351	movzx edx, [cfg_opt_value_vmode]	351	movzx edx, [cfg_opt_value_vmode]
352	mov r10, [gop_interface]	352	mov r10, [gop_interface]
353	fstcall [r10+EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode], [gop_interface], \	353	fstcall [r10+EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode], [gop_interface], \
354	rdx, gop_info_size, gop_info	354	rdx, gop_info_size, gop_info
355	cmp rax, EFI_SUCCESS	355	cmp rax, EFI_SUCCESS
356	jnz .error	356	jnz .error
357	mov rcx, [gop_info]	357	mov rcx, [gop_info]
358	fstcall print_vmode	358	fstcall print_vmode
359	; PixelBlueGreenRedReserved8BitPerColor	359	; PixelBlueGreenRedReserved8BitPerColor
360	cmp [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat], 1	360	cmp [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat], 1
361	jnz .skip_mode	361	jnz .skip_mode
362	xor edx, edx	362	xor edx, edx
363	mov eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]	363	mov eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
364	cmp ax, [rdx+BOOT_LO.x_res]	364	cmp ax, [rdx+BOOT_LO.x_res]
365	jnz .skip_mode	365	jnz .skip_mode
366	mov eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]	366	mov eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
367	cmp ax, [rdx+BOOT_LO.y_res]	367	cmp ax, [rdx+BOOT_LO.y_res]
368	jnz .skip_mode	368	jnz .skip_mode
369	jmp .done	369	jmp .done
370	.skip_mode:	370	.skip_mode:
371	inc [cfg_opt_value_vmode]	371	inc [cfg_opt_value_vmode]
372	movzx eax, [cfg_opt_value_vmode]	372	movzx eax, [cfg_opt_value_vmode]
373	mov rcx, [gop_interface]	373	mov rcx, [gop_interface]
374	mov rdx, [rcx+EFI_GRAPHICS_OUTPUT_PROTOCOL.Mode]	374	mov rdx, [rcx+EFI_GRAPHICS_OUTPUT_PROTOCOL.Mode]
375	cmp eax, [rdx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.MaxMode]	375	cmp eax, [rdx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.MaxMode]
376	jnz .next_mode	376	jnz .next_mode
377	mov [cfg_opt_used_resolution], 0	377	mov [cfg_opt_used_resolution], 0
378	mov [cfg_opt_value_ask_params], 1	378	mov [cfg_opt_value_ask_params], 1
379		379
380	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	380	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
381	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	381	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
382	msg_error_no_such_vmode	382	msg_error_no_such_vmode
383	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	383	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
384	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	384	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
385	msg_error	385	msg_error
386	jmp $	386	jmp $
387	.error:	387	.error:
388	.done:	388	.done:
389	ret	389	ret
390	endp	390	endp
391		391
392	ask_for_params:	392	ask_for_params:
393	jmp $	393	jmp $
394		394
395	proc detect_pci_config	395	proc detect_pci_config
396	fstcall get_protocol_interface, pcirbiop_guid	396	fstcall get_protocol_interface, pcirbiop_guid
397	mov [pcirbiop_interface], rax	397	mov [pcirbiop_interface], rax
398	mov r10, rax	398	mov r10, rax
399	fstcall [r10+EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Configuration], r10, \	399	fstcall [r10+EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Configuration], r10, \
400	pcirbiop_resources	400	pcirbiop_resources
401	; fstcall dump_pci_resources	401	; fstcall dump_pci_resources
402	fstcall get_last_pci_bus	402	fstcall get_last_pci_bus
403	call clearbuf	403	call clearbuf
404	movzx eax, [pci_last_bus]	404	movzx eax, [pci_last_bus]
405	mov rdi, msg	405	mov rdi, msg
406	call num2hex	406	call num2hex
407	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	407	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
408	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	408	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
409	msg_pci_last_bus	409	msg_pci_last_bus
410	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	410	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
411	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg	411	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, msg
412	ret	412	ret
413	endp	413	endp
414		414
415	proc get_last_pci_bus	415	proc get_last_pci_bus
416	mov rsi, [pcirbiop_resources]	416	mov rsi, [pcirbiop_resources]
417	.next_resource:	417	.next_resource:
418	cmp [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.Type], \	418	cmp [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.Type], \
419	EFI_RESOURCE_DESCRIPTOR_TYPE.END_TAG	419	EFI_RESOURCE_DESCRIPTOR_TYPE.END_TAG
420	jz .not_found	420	jz .not_found
421	mov rax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.RangeMaximum]	421	mov rax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.RangeMaximum]
422	cmp [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.ResourceType], \	422	cmp [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.ResourceType], \
423	EFI_RESOURCE_TYPE.BUS	423	EFI_RESOURCE_TYPE.BUS
424	jz .found	424	jz .found
425	movzx eax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.Length]	425	movzx eax, [rsi+EFI_QWORD_ADDRESS_SPACE_DESCRIPTOR.Length]
426	lea rsi, [rsi+rax+3]	426	lea rsi, [rsi+rax+3]
427	jmp .next_resource	427	jmp .next_resource
428	.found:	428	.found:
429	mov [pci_last_bus], al	429	mov [pci_last_bus], al
430	.not_found:	430	.not_found:
431	ret	431	ret
432	endp	432	endp
433		433
434	proc main _efi_handle, _efi_table	434	proc main _efi_handle, _efi_table
435	mov [efi_handle], rcx	435	mov [efi_handle], rcx
436	mov [efi_table], rdx	436	mov [efi_table], rdx
437	mov rbx, rdx	437	mov rbx, rdx
438		438
439	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	439	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
440	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.Reset], rcx, 1	440	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.Reset], rcx, 1
441	test eax, eax	441	test eax, eax
442	jnz $ ; what can I do here?	442	jnz $ ; what can I do here?
443	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	443	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
444	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	444	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
445	msg_u4k_loaded	445	msg_u4k_loaded
446		446
447	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	447	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
448	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	448	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
449	msg_detect_pci_config	449	msg_detect_pci_config
450	fstcall detect_pci_config	450	fstcall detect_pci_config
451		451
452	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	452	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
453	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	453	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
454	msg_read_options	454	msg_read_options
455	fstcall read_options_from_config	455	fstcall read_options_from_config
456		456
457	; read kernel file	457	; read kernel file
458	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	458	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
459	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	459	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
460	msg_load_kernel	460	msg_load_kernel
461	fstcall load_file, [esp_root], kernel_name, KERNEL_BASE, \	461	fstcall load_file, [esp_root], kernel_name, KERNEL_BASE, \
462	MAX_FILE_SIZE, 1 ; fatal	462	MAX_FILE_SIZE, 1 ; fatal
463		463
464	; read ramdisk image	464	; read ramdisk image
465	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	465	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
466	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	466	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
467	msg_load_ramdisk	467	msg_load_ramdisk
468	fstcall load_file, [esp_root], ramdisk_name, RAMDISK_BASE, \	468	fstcall load_file, [esp_root], ramdisk_name, RAMDISK_BASE, \
469	MAX_FILE_SIZE, 1 ; fatal	469	MAX_FILE_SIZE, 1 ; fatal
470		470
471	; alloc buffer for devices.dat	471	; alloc buffer for devices.dat
472	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	472	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
473	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	473	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
474	msg_alloc_devicesdat	474	msg_alloc_devicesdat
475	mov r10, [rbx+EFI_SYSTEM_TABLE.BootServices]	475	mov r10, [rbx+EFI_SYSTEM_TABLE.BootServices]
476	fstcall [r10+EFI_BOOT_SERVICES.AllocatePages], \	476	fstcall [r10+EFI_BOOT_SERVICES.AllocatePages], \
477	EFI_ALLOCATE_MAX_ADDRESS, EFI_RESERVED_MEMORY_TYPE, 1, \	477	EFI_ALLOCATE_MAX_ADDRESS, EFI_RESERVED_MEMORY_TYPE, 1, \
478	devicesdat_data	478	devicesdat_data
479	cmp eax, EFI_SUCCESS	479	cmp eax, EFI_SUCCESS
480	jnz .error	480	jnz .error
481		481
482	; read devices.dat	482	; read devices.dat
483	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	483	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
484	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	484	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
485	msg_load_devicesdat	485	msg_load_devicesdat
486		486
487	fstcall load_file, [esp_root], devicesdat_name, [devicesdat_data], \	487	fstcall load_file, [esp_root], devicesdat_name, [devicesdat_data], \
488	[devicesdat_size], 0 ; not fatal	488	[devicesdat_size], 0 ; not fatal
489	mov [devicesdat_size], rax	489	mov [devicesdat_size], rax
490		490
491	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	491	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]
492	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \	492	fstcall [rcx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], rcx, \
493	msg_locate_gop_interface	493	msg_locate_gop_interface
494		494
495	fstcall get_protocol_interface, gop_guid	495	fstcall get_protocol_interface, gop_guid
496	mov [gop_interface], rax	496	mov [gop_interface], rax
497		497
498	fstcall find_rsdp	498	fstcall find_rsdp
499		499
500	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]	500	mov rcx, [rbx+EFI_SYSTEM_TABLE.ConOut]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/bootloader/uefi4kos/uefi64kos.asm @ 8284 – Rev 9958 → 9977