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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2020. All rights reserved.      ;;
;; Distributed under terms of the GNU General Public License    ;;
;; Version 2, or (at your option) any later version.            ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format pe64 efi
entry main
 
section '.text' code executable readable
 
include '../../struct.inc'
include '../../macros.inc'
include '../../const.inc'
 
purge DQ
include 'uefi64.inc'
 
MEMORY_MAP_SIZE = 0x10000
GOP_BUFFER_SIZE = 0x100
LIP_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
 
load_file:
virtual at rsp+8
  .root   dq ?
  .name   dq ?
  .buffer dq ?
  .size   dq ?
  .fatal  dq ?
end virtual
        eficall [.root], EFI_FILE_PROTOCOL.Open, [.root], file_handle, \
                [.name], EFI_FILE_MODE_READ, 0
        test    eax, eax
        jz      @f
        xor     eax, eax
        cmp     [.fatal], 1
        jnz     .done
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error_open_file
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                [.name]
        jmp     $
@@:
 
        lea     rax, [.size]
        eficall [file_handle], EFI_FILE_PROTOCOL.Read, [file_handle], rax, \
                [.buffer]
        eficall [file_handle], EFI_FILE_PROTOCOL.Close, [file_handle]
        mov     rax, [.size]
.done:
        push    rax
        call    clearbuf
        mov     rdi, msg
        call    num2dec
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_file_size
        pop     rbx
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        pop     rbx
        pop     rax
        ret     8*5
 
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
 
parse_config:
virtual at rsp+8
  .buffer      dq ?
end virtual
;        mov     rsi, [.buffer]
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_parsing_config
        pop     rbx
        mov     rsi, KERNEL_BASE
.next_line:
        call    parse_line
        cmp     byte[rsi], 0
        jnz     .next_line
        ret     1*8
 
read_options_from_config:
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, EFI_BOOT_SERVICES.HandleProtocol, [efi_handle], lipuuid, \
                lip_interface
        test    eax, eax
        jz      @f
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error_efi_lip_handle
        pop     rbx
        jmp     $
@@:
        mov     rax, [lip_interface]
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, EFI_BOOT_SERVICES.HandleProtocol, \
                [rax+EFI_LOADED_IMAGE_PROTOCOL.DeviceHandle], sfspguid, \
                sfsp_interface
        test    eax, eax
        jz      @f
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error_lip_dev_sfsp
        pop     rbx
        jmp     $
@@:
        eficall [sfsp_interface], EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.OpenVolume, \
                [sfsp_interface], esp_root
        test    eax, eax
        jz      @f
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error_sfsp_openvolume
        pop     rbx
        jmp     $
@@:
        push    0 ; not fatal, i.e. it's ok to not find this file
        push    FILE_BUFFER_SIZE
        push    KERNEL_BASE
;        push    file_name
        mov     rax, file_name
        push    rax
        push    [esp_root]
        call    load_file
 
        test    eax, eax
        jz      @f
        push    KERNEL_BASE
        call    parse_config
@@:
 
.error:
        ret
 
print_vmode:
        push    rax rbx rcx rdx rsi rdi
        mov     rbx, rcx
        call    clearbuf
        mov     eax, [rbx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
        mov     rdi, msg
        call    num2dec
        mov     eax, [rbx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
        mov     rdi, msg+8*2
        call    num2dec
 
        mov     eax, [rbx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat]
        mov     rdi, msg+16*2
        call    num2dec
 
        mov     eax, [rbx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelsPerScanLine]
        mov     rdi, msg+24*2
        call    num2dec
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        pop     rdi rsi rdx rcx rbx rax
        ret
 
find_vmode_index_by_resolution:
        mov     [cfg_opt_used_resolution], 1
        mov     [cfg_opt_value_vmode], 0
.next_mode:
        movzx   eax, [cfg_opt_value_vmode]
        eficall [gop_interface], EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode, \
                [gop_interface], rax, gop_info_size, gop_info
        cmp     rax, EFI_SUCCESS
        jnz     .error
        mov     rcx, [gop_info]
        call    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     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error_no_such_vmode
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error
        jmp     $
.error:
.done:
        ret
 
ask_for_params:
        ret
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, EFI_BOOT_SERVICES.HandleProtocol, [rax], gopuuid, \
                msg_ask_for_params
        jmp     $
 
        xor     ebx, ebx
.next_mode:
        call    clearbuf
        mov     eax, ebx
        lea     rdi, [msg]
        call    num2dec
 
        push    rbx
        eficall [gop_interface], EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode, \
                [gop_interface], rbx, gop_info_size, gop_info
        cmp     rax, EFI_SUCCESS
        jnz     .error
        mov     rcx, [gop_info]
        ; PixelBlueGreenRedReserved8BitPerColor
        cmp     [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat], 1
        jnz     .skip
        mov     eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
        lea     rdi, [msg+4*2]
        call    num2dec
        mov     eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
        lea     rdi, [msg+9*2]
        call    num2dec
;        mov     eax, [rcx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelsPerScanLine]
;        lea     rdi, [msg+14*2]
;        call    num2dec
.skip:
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        cmp     rax, EFI_SUCCESS
        jnz     .error
 
        pop     rbx
        inc     rbx
        mov     rcx, [gop_interface]
        mov     rdx, [rcx+EFI_GRAPHICS_OUTPUT_PROTOCOL.Mode]
        cmp     ebx, [rdx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.MaxMode]
        jnz     .next_mode
 
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConIn]
        eficall rbx, SIMPLE_INPUT_INTERFACE.Reset, rbx, 1
        cmp     rax, EFI_SUCCESS
        jnz     .error
        xor     ecx, ecx
    @@:
        push    rcx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConIn]
        eficall rbx, SIMPLE_INPUT_INTERFACE.ReadKeyStroke, rbx, msg
        pop     rcx
        mov     rdx, EFI_DEVICE_ERROR
        cmp     rax, rdx
        jz      .error
        mov     rdx, EFI_NOT_READY
        cmp     rax, rdx
        jz      @b
;        cmp     rax, EFI_SUCCESS
        movzx   eax, word[msg+2]
;jmp .key_done
        cmp     al, 0x0D
        jz      .key_done
        imul    ecx, 10
        sub     eax, '0'
        add     ecx, eax
        jmp     @b
.key_done:
        mov     [cfg_opt_value_vmode], cl
.error:
.done:
        ret
 
main:
        mov     [efi_handle], rcx
        mov     [efi_table], rdx
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.Reset, rbx, 1
        test    eax, eax
        jz      @f
        jmp     $       ; what can I do here?
@@:
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_u4k_loaded
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_read_options
        call    read_options_from_config
 
        ; read kernel file
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_load_kernel
        push    1       ; fatal
        push    MAX_FILE_SIZE
        push    KERNEL_BASE
;        push    kernel_name
        mov     rax, kernel_name
        push    rax
        push    [esp_root]
        call    load_file
 
        ; read ramdisk image
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_load_ramdisk
        push    1       ; fatal
        push    MAX_FILE_SIZE
        push    RAMDISK_BASE
;        push    ramdisk_name
        mov     rax, ramdisk_name
        push    rax
        push    [esp_root]
        call    load_file
 
        ; alloc buffer for devices.dat
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_alloc_devicesdat
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, 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     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_load_devicesdat
 
        push    0 ; not fatal
        push    [devicesdat_size]
        push    [devicesdat_data]
;        push    devicesdat_name
        mov     rax, devicesdat_name
        push    rax
        push    [esp_root]
        call    load_file
        mov     [devicesdat_size], rax
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_locate_gop_handlers
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, EFI_BOOT_SERVICES.LocateHandle, \
                EFI_LOCATE_SEARCH_TYPE.ByProtocol, gopuuid, 0, \
                gop_buffer_size, gop_buffer
        mov     [status], rax
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_gop_buffer_size
        call    clearbuf
        mov     rax, [gop_buffer_size]
        mov     rdi, msg
        call    num2hex
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
 
        mov     rax, [status]
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     rdi, msg
        call    num2hex
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        jmp     $
@@:
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_look_for_gop_handler
 
        mov     rbx, gop_buffer
.next_gop_handle:
        mov     rax, rbx
        mov     rcx, gop_buffer
        sub     rax, rcx
        cmp     rax, [gop_buffer_size]
        jb      @f
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error_out_of_handlers
        pop     rbx
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg_error
        pop     rbx
        jmp     $
@@:
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_query_handler
        pop     rbx
 
        mov     rax, rbx
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, EFI_BOOT_SERVICES.HandleProtocol, [rax], gopuuid, \
                gop_interface
        pop     rbx
;mov rax, 0x8000_0000_0000_0003
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     rdi, msg
        call    num2hex
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        pop     rbx
 
        add     rbx, 8
        jmp     .next_gop_handle
@@:
 
        call    find_rsdp
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_acpi_tables_done
 
        cmp     [cfg_opt_used_resolution], 0
        jz      .not_used_resolution
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                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     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        call    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   ecx, [cfg_opt_value_vmode]
        eficall [gop_interface], EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode, \
                [gop_interface], rcx
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     rdi, msg
        call    num2hex
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                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     ebx, [rdx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.Mode]
        eficall [gop_interface], EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode, \
                [gop_interface], rbx, 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     byte[rdx+BOOT_LO.pci_data+0], 1    ; PCI access mechanism
        mov     byte[rdx+BOOT_LO.pci_data+1], 8    ; last bus, don't know how to count them
        mov     byte[rdx+BOOT_LO.pci_data+2], 0x10 ; PCI version
        mov     byte[rdx+BOOT_LO.pci_data+3], 0x02
        mov     dword[rdx+BOOT_LO.pci_data+4], 0xe3
 
        ; kernel
;        eficall BootServices, AllocatePages, EFI_RESERVED_MEMORY_TYPE, \
;                450000/0x1000, EFI_ALLOCATE_ADDRESS
 
        ; ramdisk
;        eficall BootServices, AllocatePages, EFI_RESERVED_MEMORY_TYPE, \
;                2880*512/0x1000, EFI_ALLOCATE_ADDRESS
 
        call    calc_memmap
;        call    dump_memmap
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, EFI_BOOT_SERVICES.ExitBootServices, [efi_handle], \
                [memory_map_key]
        call    halt_on_error
 
        cli
 
        xor     edx, edx
        xor     esi, esi
        mov     [esi+BOOT_LO.bpp], 32
        mov     [esi+BOOT_LO.vesa_mode], dx
        mov     [esi+BOOT_LO.bank_switch], edx
        mov     rdi, [fb_base]
        mov     [esi+BOOT_LO.lfb], edi
 
        movzx   eax, [cfg_opt_value_mtrr]
        mov     [esi+BOOT_LO.mtrr], al
 
        movzx   eax, [cfg_opt_value_launcher_start]
        mov     [esi+BOOT_LO.launcher_start], al
 
        movzx   eax, [cfg_opt_value_debug_print]
        mov     [esi+BOOT_LO.debug_print], al
 
        mov     [esi+BOOT_LO.dma], dl
;        mov     qword[esi+BOOT_LO.pci_data], 0
        mov     [esi+BOOT_LO.apm_entry], edx
        mov     [esi+BOOT_LO.apm_version], dx
        mov     [esi+BOOT_LO.apm_flags], dx
        mov     [esi+BOOT_LO.apm_code_32], dx
        mov     [esi+BOOT_LO.apm_code_16], dx
        mov     [esi+BOOT_LO.apm_data_16], dx
        mov     [esi+BOOT_LO.bios_hd_cnt], dl
 
        movzx   eax, [cfg_opt_value_imgfrom]
        mov     [esi+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     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error
        jmp     $
 
 
halt_on_error:
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     rdi, msg
        call    num2hex
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_error
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        jmp     $
@@:
        ret
 
find_rsdp:
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_look_for_rsdp
        pop     rbx
 
        mov     rbx, [efi_table]
        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
 
calc_memmap:
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, EFI_BOOT_SERVICES.AllocatePages, EFI_ALLOCATE_ANY_PAGES, \
                EFI_RESERVED_MEMORY_TYPE, MEMORY_MAP_SIZE/0x1000, memory_map
        call    halt_on_error
 
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.BootServices]
        eficall rbx, 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     rbx, rsi
        add     rbx, [memory_map_size]
.next_descr:
        call    add_uefi_memmap
        add     rsi, [descriptor_size]
        cmp     rsi, rbx
        jb      .next_descr
        ret
 
dump_memmap:
        xor     eax, eax
        mov     rsi, BOOT_LO.memmap_blocks
        mov     ebx, [rax+BOOT_LO.memmap_block_cnt]
 
        call    clearbuf
        mov     eax, ebx
        mov     rdi, msg
        call    num2dec
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, \
                msg_memmap
        pop     rbx
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        pop     rbx
        call    clearbuf
.next_mapping:
        dec     ebx
        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
        push    rbx
        mov     rbx, [efi_table]
        mov     rbx, [rbx+EFI_SYSTEM_TABLE.ConOut]
        eficall rbx, EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString, rbx, msg
        pop     rbx
        add     rsi, sizeof.e820entry
        jmp     .next_mapping
.done:
        ret
 
 
; linux/arch/x86/platform/efi/efi.c
; do_add_efi_memmap
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
 
 
num2dec:
        push    rax rbx rcx rdx rsi 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 rsi rdx rcx rbx rax
        ret
 
 
num2hex:
        push    rax rbx rcx rdx rsi rdi
 
        xchg    rdx, rax
        mov     ecx, 16
.next_tetra:
        rol     rdx, 4
        movzx   eax, dl
        and     eax, 0x0f
        movzx   eax, byte[hex+eax]
        stosw
        loop    .next_tetra
 
        pop     rdi rsi rdx rcx rbx rax
        ret
 
hex db '0123456789ABCDEF'
 
clearbuf:
        push    rax rbx rcx rdx rsi rdi
        mov     eax, 0x0020
        mov     ecx, 79
        mov     rdi, msg
        rep stosw
        pop     rdi rsi rdx rcx rbx rax
        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
gopuuid         db EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID
lipuuid         db EFI_LOADED_IMAGE_PROTOCOL_GUID
sfspguid        db EFI_SIMPLE_FILE_SYSTEM_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_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_handlers   du "Locate GOP handlers",13,10,0
msg_look_for_gop_handler  du "Look for GOP 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_gop_buffer_size       du "GOP 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
 
 
section '.data' data readable writeable
efi_handle  dq 0
efi_table   dq 0
uefi_rsptmp dq 0
 
fb_base         dq 0
 
gop_buffer_size dq GOP_BUFFER_SIZE
gop_handle      dq 0
gop_interface   dq 0
gop_info_size   dq 0
gop_info        dq 0
 
lip_buffer_size dq LIP_BUFFER_SIZE
lip_handle      dq 0
lip_interface   dq 0
 
sfsp_interface  dq 0
 
esp_root        dq ?
file_handle     dq ?
file_buffer_size dq FILE_BUFFER_SIZE-1  ; leave the last byte for \0
 
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
efi_fs_info EFI_FILE_SYSTEM_INFO
 
memory_map      dq ?
gop_buffer      rq GOP_BUFFER_SIZE/8
devicesdat_data dq 0xffffffff
devicesdat_size dq 0x1000
status          dq ?
 
section '.reloc' fixups data discardable

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/bootloader/uefi4kos/uefi64kos.asm – Rev 8284 → 8656