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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2020-2024. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;; Version 2, or (at your option) any later version.            ;;
;;                                                              ;;
;; Written by Ivan Baravy                                       ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format pe efi
entry main
 
section '.text' code executable readable
 
include '../../struct.inc'
include '../../macros.inc'
include '../../proc32.inc'
include '../../const.inc'
include 'uefi32.inc'
 
MEMORY_MAP_SIZE = 0x4000
GOP_BUFFER_SIZE = 0x100
LIP_BUFFER_SIZE = 0x100
FILE_BUFFER_SIZE = 0x1000
 
MAX_FILE_SIZE = 0x10000000
 
CODE_32_SELECTOR = 8
DATA_32_SELECTOR = 16
 
; 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 stdcall uses ebx esi edi, _root, _name, _buffer, _size, _fatal
        mov     eax, [_root]
        ccall   [eax+EFI_FILE_PROTOCOL.Open], eax, file_handle, [_name], \
                EFI_FILE_MODE_READ, 0
        test    eax, eax
        jz      @f
        xor     eax, eax
        cmp     [_fatal], 1
        jnz     .done
        mov     ebx, [efi_table]
        mov     ebx, [ebx+EFI_SYSTEM_TABLE.ConOut]
        ccall   [ebx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], ebx, \
                msg_error_open_file
        ccall   [ebx+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], ebx, \
                [_name]
        jmp     $
@@:
        mov     eax, [file_handle]
        lea     ecx, [_size]
        ccall   [eax+EFI_FILE_PROTOCOL.Read], eax, ecx, [_buffer]
        mov     eax, [file_handle]
        ccall   [eax+EFI_FILE_PROTOCOL.Close], eax
        mov     eax, [_size]
.done:
        ret
endp
 
proc skip_whitespace
.next_char:
        cmp     byte[esi], 0
        jz      .done
        cmp     byte[esi], 0x20 ; ' '
        jz      .whitespace
        cmp     byte[esi], 9    ; '\t'
        jz      .whitespace
        jmp     .done
.whitespace:
        inc     esi
        jmp     .next_char
.done:
        ret
endp
 
proc skip_until_newline
.next_char:
        cmp     byte[esi], 0
        jz      .done
        cmp     byte[esi], 0xd  ; '\r'
        jz      .done
        cmp     byte[esi], 0xa  ; '\n'
        jz      .done
        inc     esi
        jmp     .next_char
.done:
        ret
endp
 
proc skip_newline
.next_char:
        cmp     byte[esi], 0xd  ; '\r'
        jz      .newline
        cmp     byte[esi], 0xa  ; '\n'
        jz      .newline
        jmp     .done
.newline:
        inc     esi
        jmp     .next_char
.done:
        ret
endp
 
proc skip_line
        call    skip_until_newline
        call    skip_newline
        ret
endp
 
proc dec2bin
        xor     edx, edx
.next_char:
        movzx   eax, byte[esi]
        test    eax, eax
        jz      .done
        sub     eax, '0'
        jb      .done
        cmp     eax, 9
        ja      .done
        inc     esi
        imul    edx, 10
        add     edx, eax
        jmp     .next_char
.done:
        mov     eax, edx
        ret
endp
 
proc parse_option
        mov     ebx, config_options-3*4
.try_next_option:
        add     ebx, 3*4
        mov     edi, esi
        mov     edx, [ebx]      ; option name
        test    edx, edx
        jz      .done
.next_char:
        cmp     byte[edx], 0
        jnz     @f
        cmp     byte[edi], '='
        jz      .opt_name_ok
@@:
        cmp     byte[edi], 0
        jz      .done
        movzx   eax, byte[edi]
        cmp     [edx], al
        jnz     .try_next_option
        inc     edi
        inc     edx
        jmp     .next_char
.opt_name_ok:
        inc     edi
        mov     esi, edi
        call    dword[ebx+4]
.done:
        ret
endp
 
proc parse_line
.next_line:
        cmp     byte[esi], 0
        jz      .done
        cmp     byte[esi], 0xd  ; '\r'
        jz      .skip
        cmp     byte[esi], 0xa  ; '\n'
        jz      .skip
        cmp     byte[esi], '#'
        jz      .skip
        call    parse_option
        call    skip_line
        jmp     .next_line
.skip:
        call    skip_line
        jmp     .next_line
.done:
        ret
endp
 
proc cfg_opt_func_resolution
        call    dec2bin
        xor     edx, edx
        mov     [edx+BOOT_LO.x_res], ax
        cmp     byte[esi], 'x'
        jz      @f
        cmp     byte[esi], '*'
        jz      @f
        jmp     .done
@@:
        inc     esi
        call    dec2bin
        xor     edx, edx
        mov     [edx+BOOT_LO.y_res], ax
        mov     [cfg_opt_used_resolution], 1
.done:
        ret
endp
 
proc cfg_opt_func_acpi
        call    dec2bin
        mov     [cfg_opt_used_acpi], 1
        mov     [cfg_opt_value_acpi], al
        ret
endp
 
proc cfg_opt_func_debug_print
        call    dec2bin
        mov     [cfg_opt_used_debug_print], 1
        mov     [cfg_opt_value_debug_print], al
        ret
endp
 
proc cfg_opt_func_launcher_start
        call    dec2bin
        mov     [cfg_opt_used_launcher_start], 1
        mov     [cfg_opt_value_launcher_start], al
        ret
endp
 
proc cfg_opt_func_mtrr
        call    dec2bin
        mov     [cfg_opt_used_mtrr], 1
        mov     [cfg_opt_value_mtrr], al
        ret
endp
 
proc cfg_opt_func_ask_params
        call    dec2bin
        mov     [cfg_opt_used_ask_params], 1
        mov     [cfg_opt_value_ask_params], al
        ret
endp
 
proc cfg_opt_func_imgfrom
        call    dec2bin
        mov     [cfg_opt_used_imgfrom], 1
        mov     [cfg_opt_value_imgfrom], al
        ret
endp
 
proc cfg_opt_func_syspath
        mov     edi, cfg_opt_value_syspath
.next_char:
        movzx   eax, byte[esi]
        cmp     al, 0xd ; \r
        jz      .done
        cmp     al, 0xa ; \n
        jz      .done
        inc     esi
        stosb
        jmp     .next_char
.done:
        mov     byte[edi], 0
        ret
endp
 
proc parse_config stdcall uses ebx esi edi, _buffer
;        mov     esi, [_buffer]
        mov     esi, KERNEL_BASE
.next_line:
        call    parse_line
        cmp     byte[esi], 0
        jnz     .next_line
        ret
endp
 
proc read_options_from_config stdcall uses ebx esi edi
        mov     ebx, [efi_table]
        mov     ebx, [ebx+EFI_SYSTEM_TABLE.BootServices]
        ccall   [ebx+EFI_BOOT_SERVICES.HandleProtocol], [efi_handle], \
                lipuuid, lip_interface
        test    eax, eax
        jnz     .error
        mov     eax, [lip_interface]
 
        mov     ebx, [efi_table]
        mov     ebx, [ebx+EFI_SYSTEM_TABLE.BootServices]
        ccall   [ebx+EFI_BOOT_SERVICES.HandleProtocol], \
                [eax+EFI_LOADED_IMAGE_PROTOCOL.DeviceHandle], sfspguid, \
                sfsp_interface
        test    eax, eax
        jnz     .error
 
        mov     eax, [sfsp_interface]
        ccall   [eax+EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.OpenVolume], eax, esp_root
        test    eax, eax
        jnz     .error
 
        stdcall load_file, [esp_root], file_name, KERNEL_BASE, \
                FILE_BUFFER_SIZE, 0
        test    eax, eax
        jz      @f
        stdcall parse_config, KERNEL_BASE
@@:
.error:
        ret
endp
 
proc print_vmode uses eax ebx ecx esi edi, _gop_if
        mov     ebx, [_gop_if]
        call    clearbuf
        mov     eax, [ebx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
        mov     edi, msg
        call    num2dec
        mov     eax, [ebx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
        mov     edi, msg+8*2
        call    num2dec
 
        mov     eax, [ebx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat]
        mov     edi, msg+16*2
        call    num2dec
 
        mov     eax, [ebx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelsPerScanLine]
        mov     edi, msg+24*2
        call    num2dec
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, msg
        ret
endp
 
proc find_vmode_index_by_resolution uses ebx esi edi
        mov     [cfg_opt_value_vmode], 0
.next_mode:
;        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
;        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
;                msg_query_vmode
 
        movzx   ecx, [cfg_opt_value_vmode]
        mov     eax, [gop_interface]
        ccall   [eax+EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode], eax, ecx, \
                gop_info_size, gop_info
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     edi, msg
        call    num2hex
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, msg
        jmp     .skip_mode
@@:
        mov     ecx, [gop_info]
        stdcall print_vmode, ecx
        ; PixelBlueGreenRedReserved8BitPerColor
        cmp     [ecx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelFormat], 1
        jnz     .skip_mode
        xor     edx, edx
        mov     eax, [ecx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
        cmp     ax, [edx+BOOT_LO.x_res]
        jnz     .skip_mode
        mov     eax, [ecx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
        cmp     ax, [edx+BOOT_LO.y_res]
        jnz     .skip_mode
        jmp     .done
.skip_mode:
        inc     [cfg_opt_value_vmode]
        movzx   eax, [cfg_opt_value_vmode]
        mov     ecx, [gop_interface]
        mov     edx, [ecx+EFI_GRAPHICS_OUTPUT_PROTOCOL.Mode]
        cmp     eax, [edx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.MaxMode]
        jnz     .next_mode
        mov     [cfg_opt_used_resolution], 0
        mov     [cfg_opt_value_ask_params], 1
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_error_no_such_vmode
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, msg_error
        jmp     $
.error:
.done:
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_vmode_found
        ret
endp
 
proc ask_for_params
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_ask_for_params
        jmp     $
.error:
.done:
        ret
endp
 
main:
        mov     esi, [esp+4]
        mov     [efi_handle], esi
        mov     esi, [esp+8]
        mov     [efi_table], esi
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.Reset], eax, 1
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_u4k_loaded
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_read_options
        call    read_options_from_config
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_load_kernel
        stdcall load_file, [esp_root], kernel_name, KERNEL_BASE, MAX_FILE_SIZE, 1
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_load_ramdisk
        stdcall load_file, [esp_root], ramdisk_name, RAMDISK_BASE, MAX_FILE_SIZE, 1
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_alloc_devicesdat
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.BootServices]
        ccall   [eax+EFI_BOOT_SERVICES.AllocatePages], \
                EFI_ALLOCATE_MAX_ADDRESS, EFI_RESERVED_MEMORY_TYPE, 1, \
                devicesdat_data
        call    halt_on_error
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_load_devicesdat
 
        ccall   load_file, [esp_root], devicesdat_name, [devicesdat_data], \
                [devicesdat_size], 0
        mov     [devicesdat_size], eax
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_locate_gop_handlers
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.BootServices]
        ccall   [eax+EFI_BOOT_SERVICES.LocateHandle], \
                EFI_LOCATE_SEARCH_TYPE.ByProtocol, gopuuid, 0, \
                gop_buffer_size, gop_buffer
        mov     [status], eax
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_gop_buffer_size
        call    clearbuf
        mov     eax, [gop_buffer_size]
        mov     edi, msg
        call    num2hex
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, msg
 
        mov     eax, [status]
        call    halt_on_error
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_look_for_gop_handler
 
        mov     ebx, gop_buffer
.next_gop_handle:
        mov     eax, ebx
        sub     eax, gop_buffer
        cmp     eax, [gop_buffer_size]
        jb      @f
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_error_out_of_handlers
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, msg_error
        jmp     $
@@:
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_query_handler
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.BootServices]
        ccall   [eax+EFI_BOOT_SERVICES.HandleProtocol], \
                [ebx], gopuuid, gop_interface
;mov eax, 0x80000003
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     edi, msg
        call    num2hex
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, msg
 
        add     ebx, 4
        jmp     .next_gop_handle
@@:
 
        call    find_rsdp
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_acpi_tables_done
 
        cmp     [cfg_opt_used_resolution], 0
        jz      .not_used_resolution
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_opt_resolution
        call    clearbuf
        xor     edx, edx
        movzx   eax, [edx+BOOT_LO.x_res]
        mov     edi, msg
        call    num2dec
        xor     edx, edx
        movzx   eax, [edx+BOOT_LO.y_res]
        mov     edi, msg+8*2
        call    num2dec
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, 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     [edx+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]
        mov     eax, [gop_interface]
        ccall   [eax+EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode], eax, ecx
        call    halt_on_error
 
        mov     ecx, [gop_interface]
        mov     edx, [ecx+EFI_GRAPHICS_OUTPUT_PROTOCOL.Mode]
        mov     edi, [edx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.FrameBufferBase.lo]
        mov     [fb_base], edi
 
 
        mov     ebx, [edx+EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.Mode]
        mov     eax, [gop_interface]
        ccall   [eax+EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode], eax, ebx, \
                gop_info_size, gop_info
        test    eax, eax
        jnz     .error
        mov     ecx, [gop_info]
        mov     eax, [ecx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.HorizontalResolution]
        xor     edx, edx
        mov     [edx+BOOT_LO.x_res], ax
        mov     eax, [ecx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.VerticalResolution]
        mov     [edx+BOOT_LO.y_res], ax
        mov     eax, [ecx+EFI_GRAPHICS_OUTPUT_MODE_INFORMATION.PixelsPerScanLine]
        shl     eax, 2
        mov     [edx+BOOT_LO.pitch], ax
 
        mov     [edx+BOOT_LO.pci_data.access_mechanism], 1
        movzx   eax, [pci_last_bus]
        mov     [edx+BOOT_LO.pci_data.last_bus], al
        mov     [edx+BOOT_LO.pci_data.version], 0x0300  ; PCI 3.0
        mov     [edx+BOOT_LO.pci_data.pm_entry], 0
 
        ; 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     eax, [efi_table]
        mov     eax, [eax+EFI_SYSTEM_TABLE.BootServices]
        ccall   [eax+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     edi, [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     [edx+BOOT_LO.devicesdat_size], eax
        mov     eax, dword[devicesdat_data]
        mov     [edx+BOOT_LO.devicesdat_data], eax
 
        mov     esi, cfg_opt_value_syspath
        mov     edi, BOOT_LO.syspath
        mov     ecx, 0x17
        rep movsb
 
        lgdt    [cs:GDTR]
 
        mov     ax, DATA_32_SELECTOR
        mov     ds, ax
        mov     es, ax
        mov     fs, ax
        mov     gs, ax
        mov     ss, ax
 
        push    CODE_32_SELECTOR
        lea     eax, [.next]
        push    eax
        retf
 
.next:
        mov     eax, cr0
        and     eax, not CR0_PG
        mov     cr0, eax
 
        mov     eax, cr4
        and     eax, not CR4_PAE
        mov     cr4, eax
 
        mov     eax, KERNEL_BASE
        ; add the 32-bit entry point
        add     eax, [eax+kernel_header.b32_offset]
        push    eax
        retn
 
.error:
        mov     esi, [efi_table]
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_error
        jmp     $
 
halt_on_error:
        test    eax, eax
        jz      @f
        call    clearbuf
        mov     edi, msg
        call    num2hex
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_error
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, msg
        jmp     $
@@:
        ret
 
proc find_rsdp
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_look_for_rsdp
 
        mov     edi, [esi+EFI_SYSTEM_TABLE.ConfigurationTable]
        mov     ecx, [esi+EFI_SYSTEM_TABLE.NumberOfTableEntries]
.next_table:
        dec     ecx
        js      .all_tables_done
        ; EFI_ACPI_TABLE_GUID
        cmp     dword[edi+EFI_CONFIGURATION_TABLE.VendorGUID+0x0], 0x8868e871
        jnz     .not_acpi20
        cmp     dword[edi+EFI_CONFIGURATION_TABLE.VendorGUID+0x4], 0x11d3e4f1
        jnz     .not_acpi20
        cmp     dword[edi+EFI_CONFIGURATION_TABLE.VendorGUID+0x8], 0x800022bc
        jnz     .not_acpi20
        cmp     dword[edi+EFI_CONFIGURATION_TABLE.VendorGUID+0xc], 0x81883cc7
        jnz     .not_acpi20
        mov     eax, [edi+EFI_CONFIGURATION_TABLE.VendorTable]
        mov     edx, BOOT_LO.acpi_rsdp
        mov     [edx], eax
        mov     eax, [esi+EFI_SYSTEM_TABLE.ConOut]
        ccall   [eax+EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString], eax, \
                msg_rsdp_found
        jmp     .all_tables_done
.not_acpi20:
        add     edi, sizeof.EFI_CONFIGURATION_TABLE
        jmp     .next_table
.all_tables_done:
        ret
endp
 
proc calc_memmap
        mov     eax, [esi+EFI_SYSTEM_TABLE.BootServices]
        ccall   [eax+EFI_BOOT_SERVICES.AllocatePages], EFI_ALLOCATE_ANY_PAGES, \
                EFI_RESERVED_MEMORY_TYPE, MEMORY_MAP_SIZE/0x1000, memory_map
        call    halt_on_error
 
        mov     eax, [esi+EFI_SYSTEM_TABLE.BootServices]
        ccall   [eax+EFI_BOOT_SERVICES.GetMemoryMap], memory_map_size, \
                [memory_map], memory_map_key, descriptor_size, descriptor_ver
        call    halt_on_error
 
        push    esi
        mov     edi, BOOT_LO.memmap_blocks
        mov     dword[edi-4], 0 ; memmap_block_cnt
        mov     esi, [memory_map]
        mov     ebx, esi
        add     ebx, [memory_map_size]
.next_descr:
        call    add_uefi_memmap
        add     esi, [descriptor_size]
        cmp     esi, ebx
        jb      .next_descr
        pop     esi
        ret
endp
 
; linux/arch/x86/platform/efi/efi.c
; do_add_efi_memmap
proc add_uefi_memmap
        cmp     [BOOT_LO.memmap_block_cnt], MAX_MEMMAP_BLOCKS
        jz      .done
 
        mov     eax, [esi+EFI_MEMORY_DESCRIPTOR.PhysicalStart.lo]
        mov     edx, [esi+EFI_MEMORY_DESCRIPTOR.PhysicalStart.hi]
        mov     [edi+e820entry.addr.lo], eax
        mov     [edi+e820entry.addr.hi], edx
 
        mov     eax, [esi+EFI_MEMORY_DESCRIPTOR.NumberOfPages.lo]
        mov     edx, [esi+EFI_MEMORY_DESCRIPTOR.NumberOfPages.hi]
        shld    edx, eax, 12
        shl     eax, 12
        mov     [edi+e820entry.size.lo], eax
        mov     [edi+e820entry.size.hi], edx
 
        mov     ecx, [esi+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    [esi+EFI_MEMORY_DESCRIPTOR.Attribute.lo], EFI_MEMORY_WB
        mov     eax, E820_RAM
        jnz     .type_done
.reserved:
        mov     eax, E820_RESERVED
.type_done:
        mov     [edi+e820entry.type], eax
        cmp     eax, E820_RAM
        jnz     @f
        inc     [BOOT_LO.memmap_block_cnt]
        add     edi, sizeof.e820entry
@@:
.done:
        ret
endp
 
 
proc num2dec
        pushad
 
        xor     ecx, ecx
        mov     ebx, 10
.next_digit:
        xor     edx, edx
        div     ebx
        push    edx
        inc     ecx
        test    eax, eax
        jnz     .next_digit
 
.next_char:
        pop     eax
        add     eax, '0'
        stosw
        loop    .next_char
 
        popad
        ret
endp
 
 
proc num2hex
        pushad
 
        xchg    edx, eax
        mov     ecx, 8
.next_tetra:
        rol     edx, 4
        movzx   eax, dl
        and     eax, 0x0f
        movzx   eax, byte[hex+eax]
        stosw
        loop    .next_tetra
 
        popad
        ret
endp
 
 
hex db '0123456789ABCDEF'
 
proc clearbuf
        pushad
        mov     eax, 0x0020
        mov     ecx, 79
        mov     edi, msg
        rep stosw
        popad
        ret
endp
 
section '.rodata' data readable
align 16
GDTR:
        dw 3*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
 
gopuuid         db EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID
lipuuid         db EFI_LOADED_IMAGE_PROTOCOL_GUID
sfspguid        db EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID
pcirbguid       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  dd 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 "uefi32kos loaded",13,10,0
msg_read_options          du "Read options from 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_error                 du "Error!",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                       du 79 dup " ",13,10,0
 
 
section '.data' data readable writeable
efi_handle dd 0
efi_table  dd 0
 
fb_base         dd 0
 
gop_buffer_size dd GOP_BUFFER_SIZE
gop_handle      dd 0
gop_interface   dd 0
gop_info_size   dd 0
gop_info        dd 0
 
lip_buffer_size dd LIP_BUFFER_SIZE
lip_handle      dd 0
lip_interface   dd 0
 
sfsp_interface  dd 0
 
pci_last_bus db 254
 
esp_root        dd ?
file_handle     dd ?
file_buffer_size dd 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  dd 0
descriptor_size dd 0
descriptor_ver  dd 0
memory_map_size dd 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      dd ?
gop_buffer      rd GOP_BUFFER_SIZE/4
devicesdat_data dd 0xffffffff
devicesdat_size dd 0x1000
status dd ?
 
section '.reloc' fixups data discardable

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

Subversion Repositories Kolibri OS

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