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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/bootloader/uefi4kos/uefi64kos.asm – Rev 9253 → 9286