WebSVN – Kolibri OS – Diff – /kernel/trunk/boot/bootcode.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  BOOTCODE.INC                                                ;;
;;                                                              ;;
;;  KolibriOS 16-bit loader,                                    ;;
;;                        based on bootcode for MenuetOS        ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3964 $
 
 
;==========================================================================
;
;                           16 BIT FUNCTIONS
;
;==========================================================================
 
 
putchar:
; in: al=character
        mov     ah, 0Eh
        mov     bh, 0
        int     10h
        ret
 
print:
; in: si->string
        mov     al, 186
        call    putchar
        mov     al, ' '
        call    putchar
 
printplain:
; in: si->string
        pusha
        lodsb
@@:
        call    putchar
        lodsb
        test    al, al
        jnz     @b
        popa
        ret
 
getkey:                         ; Use BIOS INT 16h to read a key from the keyboard
; get number in range [bl,bh] (bl,bh in ['0'..'9'])
; in: bx=range
; out: ax=digit (1..9, 10 for 0)
        mov     ah, 0           ; If 'int 16h' is called with 'ah' equal to zero, the BIOS will not return control
        int     16h             ; to the caller until a key is available in the system type ahead buffer. On return,
        cmp     al, bl          ; 'al' contains the ASCII code for the key read from the buffer and 'ah' contains
        jb      getkey          ; the keyboard scan code. Here we compare 'al' with the range of accepted characters.
        cmp     al, bh          ; If the key pressed is not in the range, continue waiting for another key.
        ja      getkey
        push    ax              ; If the pressed key is in the accepted range, save it on the stack and echo to screen.
        call    putchar
        pop     ax
        and     ax, 0Fh         ; ASCII code for '0' is 48 (110000b). 0F4=1111b. (110000b AND 1111b) = 0
        jnz     @f              ; So if key '0' was entered, return 10 in 'ax'
        mov     al, 10
@@:
        ret
 
setcursor:
; in: dl=column, dh=row
        mov     ah, 2
        mov     bh, 0
        int     10h
        ret
 
macro _setcursor row,column
{
        mov     dx, row*256 + column
        call    setcursor
}
 
boot_read_floppy:
        push    si
        xor     si, si
        mov     ah, 2   ; read
@@:
        push    ax
        int     0x13
        pop     ax
        jnc     @f
        inc     si
        cmp     si, 10
        jb      @b
sayerr_badsect:
        mov     si, badsect
sayerr_plain:
        call    printplain
        jmp     $
@@:
        pop     si
        ret
 
; convert abs. sector number (AX) to BIOS T:H:S
; sector number = (abs.sector%BPB_SecPerTrk)+1
; pre.track number = (abs.sector/BPB_SecPerTrk)
; head number = pre.track number%BPB_NumHeads
; track number = pre.track number/BPB_NumHeads
; Return: cl - sector number
;         ch - track number
;         dl - drive number (0 = a:)
;         dh - head number
conv_abs_to_THS:
        push    bx
        mov     bx, word [BPB_SecPerTrk]
        xor     dx, dx
        div     bx
        inc     dx
        mov     cl, dl                          ; cl = sector number
        mov     bx, word [BPB_NumHeads]
        xor     dx, dx
        div     bx
        ; !!!!!!! ax = track number, dx = head number
        mov     ch, al                          ; ch=track number
        xchg    dh, dl                          ; dh=head number
        mov     dl, 0                           ; dl=0 (drive 0 (a:))
        pop     bx
        retn
; needed variables
BPB_SecPerTrk   dw      0                       ; sectors per track
BPB_NumHeads    dw      0                       ; number of heads
BPB_FATSz16     dw      0                       ; size of FAT
BPB_RootEntCnt  dw      0                       ; count of root dir. entries
BPB_BytsPerSec  dw      0                       ; bytes per sector
BPB_RsvdSecCnt  dw      0                       ; number of reserved sectors
BPB_TotSec16    dw      0                       ; count of the sectors on the volume
BPB_SecPerClus  db      0                       ; number of sectors per cluster
BPB_NumFATs     db      0                       ; number of FAT tables
abs_sector_adj  dw      0                       ; adjustment to make abs. sector number
end_of_FAT      dw      0                       ; end of FAT table
FirstDataSector dw      0                       ; begin of data
 
;=========================================================================
;
;                           16 BIT CODE
;
;=========================================================================
 
include 'bootvesa.inc'                 ;Include source for boot vesa 
if defined extended_primary_loader
include 'parsers.inc'
end if
 
start_of_code:
 
if defined extended_primary_loader
; save data from primary loader
        mov     word [cs:bootcallback], si
        mov     word [cs:bootcallback+2], ds
        push    cs
        pop     ds
        mov     [bootdevice], ax
        mov     [bootfs], bx
 
; set up stack
        mov     ax, 3000h
        mov     ss, ax
        mov     sp, 0EC00h
 
; try to load configuration file
        mov     ax, 1
        mov     di, config_file_struct
        call    [bootcallback]
        cld
        push    cs
        pop     es
; bx=0 - ok, bx=1 - part of file loaded, assume this is ok
        cmp     bx, 1
        ja      .config_bad
; configuration file was loaded, parse
; if length is too big, use first 0FFFFh bytes
        test    dx, dx
        jz      @f
        mov     ax, 0FFFFh
@@:
; ds:si will be pointer to current data, dx = limit
        xchg    ax, dx
        push    4000h
        pop     ds
        xor     si, si
.parse_loop:
; skip spaces
        cmp     si, dx
        jae     .parse_done
        lodsb
        cmp     al, ' '
        jbe     .parse_loop
        dec     si
; loop over all possible configuration values
        mov     bx, config_file_variables
.find_variant:
; get length
        mov     cx, [es:bx]
; zero length = end of list
        jecxz   .find_newline
; skip over length
        inc     bx
        inc     bx
        mov     di, bx
; skip over string
        add     bx, cx
; test whether we have at least cx symbols left
        mov     ax, cx
        add     ax, si
        jc      .next_variant1
        cmp     ax, dx
        jae     .next_variant1
; save current position
        push    si
; compare strings
        repz cmpsb
        jnz     .next_variant2
; strings are equal; look for "=" with possible spaces before and after
@@:
        cmp     si, dx
        jae     .next_variant2
        lodsb
        cmp     al, ' '
        jbe     @b
        cmp     al, '='
        jnz     .next_variant2
; ok, we found the true variant
; ignore saved position on the stack
        pop     ax
; call the parser
        call    word [es:bx]
; line parsed, find next
.find_newline:
        cmp     si, dx
        jae     .parse_done
        lodsb
        cmp     al, 13
        jz      .parse_loop
        cmp     al, 10
        jz      .parse_loop
        jmp     .find_newline
.next_variant2:
; continue to the next variant, restoring current position
        pop     si
.next_variant1:
; continue to the next variant
; skip over the parser
        inc     bx
        inc     bx
        jmp     .find_variant
.parse_done:
.config_bad:
 
; set up segment registers
        push    cs
        pop     ds
else
        cld
; \begin{diamond}[02.12.2005]
; if bootloader sets ax = 'KL', then ds:si points to loader block
        cmp     ax, 'KL'
        jnz     @f
        mov     word [cs:cfgmanager.loader_block], si
        mov     word [cs:cfgmanager.loader_block+2], ds
@@:
; \end{diamond}[02.12.2005]
 
; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk
; (see comment to bx_from_load)
        cmp     cx, 'HA'
        jnz     no_hd_load
        cmp     dx, 'RD'
        jnz     no_hd_load
        mov     word [cs:bx_from_load], bx              ; {SPraid}[13.03.2007]
no_hd_load:
 
; set up stack
        mov     ax, 3000h
        mov     ss, ax
        mov     sp, 0EC00h
; set up segment registers
        push    cs
        pop     ds
        push    cs
        pop     es
end if
 
; set videomode
        mov     ax, 3
        int     0x10
 
if lang eq ru
 ; Load & set russian VGA font (RU.INC)
        mov     bp, RU_FNT1             ; RU_FNT1 - First part
        mov     bx, 1000h               ; 768 bytes
        mov     cx, 30h                 ; 48 symbols
        mov     dx, 80h                 ; 128 - position of first symbol
        mov     ax, 1100h
        int     10h
 
        mov     bp, RU_FNT2             ; RU_FNT2 -Second part
        mov     bx, 1000h               ; 512 bytes
        mov     cx, 20h                 ; 32 symbols
        mov     dx, 0E0h                ; 224 - position of first symbol
        mov     ax, 1100h
        int     10h
 ; End set VGA russian font
else if lang eq et
        mov     bp, ET_FNT              ; ET_FNT1
        mov     bx, 1000h               ;
        mov     cx, 255                 ; 256 symbols
        xor     dx, dx                  ; 0 - position of first symbol
        mov     ax, 1100h
        int     10h
end if
 
; draw frames
        push    0xb800
        pop     es
        xor     di, di
        mov     ah, 1*16+15
 
; draw top
        mov     si, d80x25_top
        mov     cx, d80x25_top_num * 80
@@:
        lodsb
        stosw
        loop    @b
; draw spaces
        mov     si, space_msg
        mov     dx, 25 - d80x25_top_num - d80x25_bottom_num
dfl1:
        push    si
        mov     cx, 80
@@:
        lodsb
        stosw
        loop    @b
        pop     si
        dec     dx
        jnz     dfl1
; draw bottom
        mov     si, d80x25_bottom
        mov     cx, d80x25_bottom_num * 80
@@:
        lodsb
        stosw
        loop    @b
 
        mov     byte [space_msg+80], 0    ; now space_msg is null terminated
 
        _setcursor d80x25_top_num,0
 
 
; TEST FOR 386+
 
        mov     bx, 0x4000
        pushf
        pop     ax
        mov     dx, ax
        xor     ax, bx
        push    ax
        popf
        pushf
        pop     ax
        and     ax, bx
        and     dx, bx
        cmp     ax, dx
        jnz     cpugood
        mov     si, not386
sayerr:
        call    print
        jmp     $
     cpugood:
 
        push    0
        popf
        sti
 
; set up esp
        movzx   esp, sp
 
        push    0
        pop     es
        xor     ax, ax
        and     word [es:BOOT_IDE_BASE_ADDR], ax        ;0
        and     word [es:BOOT_IDE_BAR0_16], ax  ;0
        and     word [es:BOOT_IDE_BAR1_16], ax  ;0
        and     word [es:BOOT_IDE_BAR2_16], ax  ;0
        and     word [es:BOOT_IDE_BAR3_16], ax  ;0
; \begin{Mario79}
; find HDD IDE DMA PCI device
; check for PCI BIOS
        mov     ax, 0xB101
        int     0x1A
        jc      .nopci
        cmp     edx, 'PCI '
        jnz     .nopci
; find PCI class code
; class 1 = mass storage
; subclass 1 = IDE controller
; a) class 1, subclass 1, programming interface 0x80
; This is a Parallel IDE Controller which uses IRQs 14 and 15.
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x80
        mov     [es:BOOT_IDE_PI_16], cx
        xor     si, si  ; device index = 0
        int     0x1A
        jnc     .found_1 ; Parallel IDE Controller
; b) class 1, subclass 1, programming interface 0x8f
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x8f
        mov     [es:BOOT_IDE_PI_16], cx
        xor     si, si  ; device index = 0
        int     0x1A
        jnc     .found
; c) class 1, subclass 1, programming interface 0x85
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x85
        mov     [es:BOOT_IDE_PI_16], cx
        xor     si, si  ; device index = 0
        int     0x1A
        jnc     .found
; d) class 1, subclass 1, programming interface 0x8A
; This is a Parallel IDE Controller which uses IRQs 14 and 15.
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x8A
        mov     [es:BOOT_IDE_PI_16], cx
        xor     si, si  ; device index = 0
        int     0x1A
        jnc     .found ; Parallel IDE Controller
; Controller not found!
        xor     ax, ax
        mov     [es:BOOT_IDE_PI_16], ax
        jmp     .nopci
;--------------------------------------
.found_1:
; get memory base BAR4
        mov     ax, 0xB10A
        mov     di, 0x20        ; memory base is config register at 0x20
        push    cx
        int     0x1A
        jc      .no_BAR4        ;.nopci
        and     cx, 0xFFFC      ; clear address decode type
        mov     [es:BOOT_IDE_BASE_ADDR], cx
.no_BAR4:
        pop     cx
;--------------------------------------
.found:
; get Interrupt Line
        mov     ax, 0xB10A
        mov     di, 0x3c        ; memory base is config register at 0x3c
        push    cx
        int     0x1A
        jc      .no_Interrupt        ;.nopci
 
        mov     [es:BOOT_IDE_INTERR_16], cx
.no_Interrupt:
        pop     cx
;--------------------------------------
; get memory base BAR0
        mov     ax, 0xB10A
        mov     di, 0x10        ; memory base is config register at 0x10
        push    cx
        int     0x1A
        jc      .no_BAR0        ;.nopci
 
        mov     [es:BOOT_IDE_BAR0_16], cx
.no_BAR0:
        pop     cx
;--------------------------------------
; get memory base BAR1
        mov     ax, 0xB10A
        mov     di, 0x14        ; memory base is config register at 0x14
        push    cx
        int     0x1A
        jc      .no_BAR1        ;.nopci
 
        mov     [es:BOOT_IDE_BAR1_16], cx
.no_BAR1:
        pop     cx
;--------------------------------------
; get memory base BAR2
        mov     ax, 0xB10A
        mov     di, 0x18        ; memory base is config register at 0x18
        push    cx
        int     0x1A
        jc      .no_BAR2        ;.nopci
 
        mov     [es:BOOT_IDE_BAR2_16], cx
.no_BAR2:
        pop     cx
;--------------------------------------
; get memory base BAR3
        mov     ax, 0xB10A
        mov     di, 0x1C        ; memory base is config register at 0x1c
        push    cx
        int     0x1A
        jc      .no_BAR3        ;.nopci
 
        mov     [es:BOOT_IDE_BAR3_16], cx
.no_BAR3:
        pop     cx
;--------------------------------------
.nopci:
; \end{Mario79}
 
        mov     al, 0xf6        ; Сброс клавиатуры, разрешить сканирование
        out     0x60, al
        xor     cx, cx
wait_loop:       ; variant 2
; reading state of port of 8042 controller
        in      al, 64h
        and     al, 00000010b  ; ready flag
; wait until 8042 controller is ready
        loopnz  wait_loop
 
;;;/diamond today   5.02.2008
; set keyboard typematic rate & delay
        mov     al, 0xf3
        out     0x60, al
        xor     cx, cx
@@:
        in      al, 64h
        test    al, 2
        loopnz  @b
        mov     al, 0
        out     0x60, al
        xor     cx, cx
@@:
        in      al, 64h
        test    al, 2
        loopnz  @b
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; --------------- APM ---------------------
        and     word [es:BOOT_APM_VERSION], 0     ; ver = 0.0 (APM not found)
        mov     ax, 0x5300
        xor     bx, bx
        int     0x15
        jc      apm_end                 ; APM not found
        test    cx, 2
        jz      apm_end                 ; APM 32-bit protected-mode interface not supported
        mov     [es:BOOT_APM_VERSION], ax         ; Save APM Version
        mov     [es:BOOT_APM_FLAGS], cx           ; Save APM flags
 
        ; Write APM ver ----
        and     ax, 0xf0f
        add     ax, '00'
        mov     si, msg_apm
        mov     [si + 5], ah
        mov     [si + 7], al
        _setcursor 0, 3
        call    printplain
        ; ------------------
 
        mov     ax, 0x5304              ; Disconnect interface
        xor     bx, bx
        int     0x15
        mov     ax, 0x5303              ; Connect 32 bit mode interface
        xor     bx, bx
        int     0x15
 
        mov     [es:BOOT_APM_ENTRY], ebx
        mov     [es:BOOT_APM_CODE_32], ax
        mov     [es:BOOT_APM_CODE_16], cx
        mov     [es:BOOT_APM_DATA_16], dx
 
apm_end:
        _setcursor d80x25_top_num, 0
 
if ~ defined extended_primary_loader
;CHECK current of code
        cmp     [cfgmanager.loader_block], -1
        jz      noloaderblock
        les     bx, [cfgmanager.loader_block]
        cmp     byte [es:bx], 1
        mov     si, loader_block_error
        jnz     sayerr
        push    0
        pop     es
end if
 
noloaderblock:
; DISPLAY VESA INFORMATION
        call    print_vesa_info
        call    calc_vmodes_table
        call    check_first_parm   ;check and enable cursor_pos
 
; \begin{diamond}[30.11.2005]
cfgmanager:
; settings:
; a) preboot_graph = graphical mode
;    preboot_gprobe = probe this mode?
; b) preboot_biosdisk  = use BIOS disks through V86 emulation? // (earlier was: preboot_dma  = use DMA access?)
; c) preboot_debug = duplicates kernel debug output to the screen // (earlier was: preboot_vrrm = use VRR?)
;    // VRR is an obsolete functionality, used only with CRT monitors: increase display frequency by reducing screen resolution
; d) preboot_launcher = start the first app (right now it's LAUNCHER) after kernel is loaded?
; e) preboot_device = from where to boot?
 
; determine default settings
if ~ defined extended_primary_loader
        mov     [.bSettingsChanged], 0
end if
 
;.preboot_gr_end:
        mov     di, preboot_device
; if image in memory is present and [preboot_device] is uninitialized,
; set it to use this preloaded image
        cmp     byte [di], 0
        jnz     .preboot_device_inited
if defined extended_primary_loader
        inc     byte [di]
        cmp     byte [bootdevice], 'f' ; floppy?
        jz      .preboot_device_inited
        inc     byte [di]
else
        cmp     [.loader_block], -1
        jz      @f
        les     bx, [.loader_block]
        test    byte [es:bx+1], 1
        jz      @f
        mov     byte [di], 3
        jmp     .preboot_device_inited
@@:
; otherwise, set [preboot_device] to 1 (default value - boot from floppy)
        mov     byte [di], 1
end if
.preboot_device_inited:
; following 4 lines set variables to 1 if its current value is 0
        cmp     byte [di+preboot_dma-preboot_device], 1
        adc     byte [di+preboot_dma-preboot_device], 0
        cmp     byte [di+preboot_launcher-preboot_device], 1        ; Start LAUNCHER by default
        adc     byte [di+preboot_launcher-preboot_device], 0        
;        cmp     byte [di+preboot_biosdisk-preboot_device], 1
;        adc     byte [di+preboot_biosdisk-preboot_device], 0
;; default value for VRR is OFF
;        cmp     byte [di+preboot_vrrm-preboot_device], 0
;        jnz    @f
;        mov    byte [di+preboot_vrrm-preboot_device], 2
;@@:
; notify user
        _setcursor 5,2
 
        mov     si, linef
        call    printplain
        mov     si, start_msg
        call    print
        mov     si, time_msg
        call    print
; get start time
        call    .gettime
        mov     [.starttime], eax
        mov     word [.timer], .newtimer
        mov     word [.timer+2], cs
.printcfg:
 
        _setcursor 9,0
        mov     si, current_cfg_msg
        call    print
        mov     si, curvideo_msg
        call    print
 
        call    draw_current_vmode
 
        mov     si, usebd_msg
        cmp     [preboot_biosdisk], 1
        call    .say_on_off
;        mov     si, vrrm_msg
;        cmp     [preboot_vrrm], 1
;        call    .say_on_off
        mov     si, debug_mode_msg
        cmp     [preboot_debug], 1
        call    .say_on_off
        mov     si, launcher_msg
        cmp     [preboot_launcher], 1
        call    .say_on_off
        mov     si, preboot_device_msg
        call    print
        mov     al, [preboot_device]
if defined extended_primary_loader
        and     eax, 3
else
        and     eax, 7
end if
        mov     si, [preboot_device_msgs+eax*2]
        call    printplain
.show_remarks:
; show remarks in gray color
        mov     di, ((21-num_remarks)*80 + 2)*2
        push    0xB800
        pop     es
        mov     cx, num_remarks
        mov     si, remarks
.write_remarks:
        lodsw
        push    si
        xchg    ax, si
        mov     ah, 1*16+7      ; background: blue (1), foreground: gray (7)
        push    di
.write_remark:
        lodsb
        test    al, al
        jz      @f
        stosw
        jmp     .write_remark
@@:
        pop     di
        pop     si
        add     di, 80*2
        loop    .write_remarks
.wait:
        _setcursor 25,0         ; out of screen
; set timer interrupt handler
        cli
        push    0
        pop     es
        push    dword [es:8*4]
        pop     dword [.oldtimer]
        push    dword [.timer]
        pop     dword [es:8*4]
;        mov     eax, [es:8*4]
;        mov     [.oldtimer], eax
;        mov     eax, [.timer]
;        mov     [es:8*4], eax
        sti
; wait for keypressed
        xor     ax, ax
        int     16h
        push    ax
; restore timer interrupt
;        push    0
;        pop     es
        mov     eax, [.oldtimer]
        mov     [es:8*4], eax
        mov     [.timer], eax
 
        _setcursor 7,0
        mov     si, space_msg
        call    printplain
; clear remarks and restore normal attributes
        push    es
        mov     di, ((21-num_remarks)*80 + 2)*2
        push    0xB800
        pop     es
        mov     cx, num_remarks
        mov     ax, ' ' + (1*16 + 15)*100h
@@:
        push    cx
        mov     cx, 76
        rep stosw
        pop     cx
        add     di, 4*2
        loop    @b
        pop     es
        pop     ax
; switch on key
        cmp     al, 13
        jz      .continue
        or      al, 20h
        cmp     al, 'a'         ; select graphical mode
        jz      .change_a
        cmp     al, 'q'         ; Trick to make 'A' key on azerty keyboard work
        je      .change_a
        cmp     al, 'b'         ; use BIOS disks? // (selecting YES will make BIOS disks visible as /bd)
        jz      .change_b
        cmp     al, 'c'         ; load kernel in debug mode?  // (earlier was: use VRR?)
        jz      .change_c
        cmp     al, 'd'         ; start launcher after kernel is loaded?
        jz      .change_d
        cmp     al, 'e'         ; select boot origin
        jnz     .show_remarks
; e) preboot_device = from where to boot?
        _setcursor 16,0
        mov     si, bdev
        call    print
if defined extended_primary_loader
        mov     bx, '12'        ; range accepted for answer: 1-2
else
        mov     bx, '14'        ; range accepted for answer: 1-4
end if
        call    getkey
        mov     [preboot_device], al
        _setcursor 14,0
.d:
if ~ defined extended_primary_loader
        mov     [.bSettingsChanged], 1
end if
        call    clear_vmodes_table             ;clear vmodes_table
        jmp     .printcfg
.change_a:
        call    clear_vmodes_table             ;clear vmodes_table
.loops:
        call    draw_vmodes_table
        _setcursor 25,0         ; out of screen
        xor     ax, ax
        int     0x16
;        call    clear_table_cursor             ;clear current position of cursor
 
        mov     si, word [cursor_pos]
 
        cmp     ah, 0x48;x,0x48E0               ; up
        jne     .down
        cmp     si, modes_table
        jbe     .loops
        sub     word [cursor_pos], size_of_step
        jmp     .loops
 
.down:
        cmp     ah, 0x50;x,0x50E0               ; down
        jne     .pgup
        cmp     word[es:si+10], -1
        je      .loops
        add     word [cursor_pos], size_of_step
        jmp     .loops
 
.pgup:
        cmp     ah, 0x49                ; page up
        jne     .pgdn
        sub     si, size_of_step*long_v_table
        cmp     si, modes_table
        jae     @f
        mov     si, modes_table
@@:
        mov     word [cursor_pos], si
        mov     si, word [home_cursor]
        sub     si, size_of_step*long_v_table
        cmp     si, modes_table
        jae     @f
        mov     si, modes_table
@@:
        mov     word [home_cursor], si
        jmp     .loops
 
.pgdn:
        cmp     ah, 0x51                ; page down
        jne     .enter
        mov     ax, [end_cursor]
        add     si, size_of_step*long_v_table
        cmp     si, ax
        jb      @f
        mov     si, ax
        sub     si, size_of_step
@@:
        mov     word [cursor_pos], si
        mov     si, word [home_cursor]
        sub     ax, size_of_step*long_v_table
        add     si, size_of_step*long_v_table
        cmp     si, ax
        jb      @f
        mov     si, ax
@@:
        mov     word [home_cursor], si
        jmp     .loops
 
.enter:
        cmp     al, 0x0D;x,0x1C0D               ; enter
        jne     .loops
        push    word [cursor_pos]
        pop     bp
        push    word [es:bp]
        pop     word [x_save]
        push    word [es:bp+2]
        pop     word [y_save]
        push    word [es:bp+6]
        pop     word [number_vm]
        mov     word [preboot_graph], bp          ;save choose
        
        jmp     .d
 
.change_b:                      ; b) preboot_biosdisk  = use BIOS disks through V86 emulation?
        _setcursor 16,0
;        mov     si, ask_dma    // (earlier was: preboot_dma  = use DMA access?)
;        call    print
;        mov     bx, '13'       ; range accepted for answer: 1-3
;        call    getkey
;        mov     [preboot_dma], al
        mov     si, ask_bd
        call    print
        mov     bx, '12'        ; range accepted for answer: 1-2
        call    getkey
        mov     [preboot_biosdisk], al
        _setcursor 11,0
        jmp     .d
;.change_c:                     ; //  VRR is an obsolete functionality, used only with CRT monitors
;        _setcursor 16,0
;        mov     si, vrrmprint
;        call    print
;        mov     bx, '12'       ; range accepted for answer: 1-2
;        call    getkey
;        mov     [preboot_vrrm], al
;        _setcursor 12,0
;        jmp     .d
.change_c:                      ; c) preboot_debug = duplicates kernel debug output to the screen
        _setcursor 16,0
        mov     si, ask_debug
        call    print
        mov     bx, '12'        ; range accepted for answer: 1-2
        call    getkey
        mov     [preboot_debug], al
        _setcursor 12,0
        jmp     .d
.change_d:                      ; d) preboot_launcher = start the first app (right now it's LAUNCHER) after kernel is loaded?
        _setcursor 16,0
        mov     si, ask_launcher
        call    print
        mov     bx, '12'        ; range accepted for answer: 1-2
        call    getkey
        mov     [preboot_launcher], al
        _setcursor 13,0
        jmp     .d
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.say_on_off:
        pushf
        call    print
        mov     si, on_msg
        popf
        jz      @f
        mov     si, off_msg
@@:
        jmp     printplain
; novesa and vervesa strings are not used at the moment of executing this code
virtual at novesa
.oldtimer dd ?
.starttime dd ?
if ~ defined extended_primary_loader
.bSettingsChanged db ?
end if
.timer dd ?
end virtual
if ~ defined extended_primary_loader
.loader_block dd -1
end if
.gettime:
        mov     ah, 0
        int     1Ah
        xchg    ax, cx
        shl     eax, 10h
        xchg    ax, dx
        ret
.newtimer:
        push    ds
        push    cs
        pop     ds
        pushf
        call    [.oldtimer]
        pushad
        call    .gettime
        sub     eax, [.starttime]
if defined extended_primary_loader
        sub     ax, [preboot_timeout]
else
        sub     ax, 18*5
end if
        jae     .timergo
        neg     ax
        add     ax, 18-1
        mov     bx, 18
        xor     dx, dx
        div     bx
if lang eq ru
; подождите 5 секунд, 4/3/2 секунды, 1 секунду
        cmp     al, 5
        mov     cl, ' '
        jae     @f
        cmp     al, 1
        mov     cl, 0xE3 ; 'у' in cp866
        jz      @f
        mov     cl, 0xEB ; 'ы' in cp866
@@:
        mov     [time_str+9], cl
else if lang eq et
        cmp     al, 1
        ja      @f
        mov     byte [time_str+9], ' '
        mov     byte [time_str+10], ' '
@@:
else if lang eq sp
; esperar 5/4/3/2 segundos, 1 segundo
        cmp     al, 1
        mov     cl, 's'
        ja      @f
        mov     cl, ' '
@@:
        mov     [time_str+10], cl
else
; wait 5/4/3/2 seconds, 1 second
        cmp     al, 1
        mov     cl, 's'
        ja      @f
        mov     cl, ' '
@@:
        mov     [time_str+9], cl
end if
        add     al, '0'
        mov     [time_str+1], al
        mov     si, time_msg
        _setcursor 7,0
        call    print
        _setcursor 25,0
        popad
        pop     ds
        iret
.timergo:
        push    0
        pop     es
        mov     eax, [.oldtimer]
        mov     [es:8*4], eax
        mov     sp, 0EC00h
.continue:
        sti
        _setcursor 6,0
        mov     si, space_msg
        call    printplain
        call    printplain
        _setcursor 6,0
        mov     si, loading_msg
        call    print
        _setcursor 16,0
if ~ defined extended_primary_loader
        cmp     [.bSettingsChanged], 0
        jz      .load
        cmp     [.loader_block], -1
        jz      .load
        les     bx, [.loader_block]
        mov     eax, [es:bx+3]
        push    ds
        pop     es
        test    eax, eax
        jz      .load
        push    eax
        mov     si, save_quest
        call    print
.waityn:
        mov     ah, 0
        int     16h
        or      al, 20h
        cmp     al, 'n'
        jz      .loadc
        if lang eq sp
        cmp     al, 's'
        else
        cmp     al, 'y'
        end if
        jnz     .waityn
        call    putchar
        mov     byte [space_msg+80], 186
 
        pop     eax
        push    cs
        push    .cont
        push    eax
        retf                          ;call back
.loadc:
        pop     eax
.cont:
        push    cs
        pop     ds
        mov     si, space_msg
        mov     byte [si+80], 0
        _setcursor 16,0
        call    printplain
        _setcursor 16,0
.load:
end if
; \end{diamond}[02.12.2005]
 
; ASK GRAPHICS MODE
 
        call    set_vmode
 
; GRAPHICS ACCELERATION
; force yes
        mov     [es:BOOT_MTRR], byte 1
 
; DMA ACCESS TO HD
 
        mov     al, [preboot_dma]
        mov     [es:BOOT_DMA], al
 
;; VRR_M USE
;
;        mov     al,[preboot_vrrm]
;        mov     [es:BOOT_VRR], al              ;// 0x9030
 
; Set kernel DEBUG mode - if nonzero, duplicates debug output to the screen.
        mov     al, [preboot_debug]
        mov     [es:BOOT_DEBUG_PRINT], al       ;// 0x901E
 
; Start the first app (right now it's LAUNCHER) after kernel is loaded?
        mov     al, [preboot_launcher]
        mov     [es:BOOT_LAUNCHER_START], al    ;// 0x901D        
 
; BOOT DEVICE
 
        mov     al, [preboot_device]
        dec     al
        mov     [boot_dev], al
 
; GET MEMORY MAP
include '../detect/biosmem.inc'
 
; READ DISKETTE TO MEMORY
 
        cmp     [boot_dev], 0
        jne     no_sys_on_floppy
        mov     si, diskload
        call    print
        xor     ax, ax            ; reset drive
        xor     dx, dx
        int     0x13
; do we boot from CD-ROM?
        mov     ah, 41h
        mov     bx, 55AAh
        xor     dx, dx
        int     0x13
        jc      .nocd
        cmp     bx, 0AA55h
        jnz     .nocd
        mov     ah, 48h
        push    ds
        push    es
        pop     ds
        mov     si, 0xa000
        mov     word [si], 30
        int     0x13
        pop     ds
        jc      .nocd
        push    ds
        lds     si, [es:si+26]
        test    byte [ds:si+10], 40h
        pop     ds
        jz      .nocd
; yes - read all floppy by 18 sectors
 
; TODO: !!!! read only first sector and set variables !!!!!
; ...
; TODO: !!! then read flippy image track by track
        
        mov     cx, 0x0001      ; startcyl,startsector
.a1:
        push    cx dx
        mov     al, 18
        mov     bx, 0xa000
        call    boot_read_floppy
        mov     si, movedesc
        push    es
        push    ds
        pop     es
        mov     cx, 256*18
        mov     ah, 0x87
        int     0x15
        pop     es
        pop     dx cx
        test    ah, ah
        jnz     sayerr_floppy
        add     dword [si+8*3+2], 512*18
        inc     dh
        cmp     dh, 2
        jnz     .a1
        mov     dh, 0
        inc     ch
        cmp     ch, 80
        jae     ok_sys_on_floppy
        pusha
        mov     al, ch
        shr     ch, 2
        add     al, ch
        aam
        xchg    al, ah
        add     ax, '00'
        mov     si, pros
        mov     [si], ax
        call    printplain
        popa
        jmp     .a1
.nocd:
; no - read only used sectors from floppy
; now load floppy image to memory
; at first load boot sector and first FAT table
 
; read only first sector and fill variables
        mov     cx, 0x0001      ; first logical sector
        xor     dx, dx          ; head = 0, drive = 0 (a:)
        mov     al, 1           ; read one sector
        mov     bx, 0xB000      ; es:bx -> data area
        call    boot_read_floppy
; fill the necessary parameters to work with a floppy
        mov     ax, word [es:bx+24]
        mov     word [BPB_SecPerTrk], ax
        mov     ax, word [es:bx+26]
        mov     word [BPB_NumHeads], ax
        mov     ax, word [es:bx+17]
        mov     word [BPB_RootEntCnt], ax
        mov     ax, word [es:bx+14]
        mov     word [BPB_RsvdSecCnt], ax
        mov     ax, word [es:bx+19]
        mov     word [BPB_TotSec16], ax
        mov     al, byte [es:bx+13]
        mov     byte [BPB_SecPerClus], al
        mov     al, byte [es:bx+16]
        mov     byte [BPB_NumFATs], al
; 18.11.2008
        mov     ax, word [es:bx+22]
        mov     word [BPB_FATSz16], ax
        mov     cx, word [es:bx+11]
        mov     word [BPB_BytsPerSec], cx
 
; count of clusters in FAT12 ((size_of_FAT*2)/3)
;        mov     ax, word [BPB_FATSz16]
;        mov     cx, word [BPB_BytsPerSec]
;end  18.11.2008
        xor     dx, dx
        mul     cx
        shl     ax, 1
        mov     cx, 3
        div     cx              ; now ax - number of clusters in FAT12
        mov     word [end_of_FAT], ax
 
; load first FAT table
        mov     cx, 0x0002      ; startcyl,startsector          ; TODO!!!!!
        xor     dx, dx          ; starthead,drive
        mov     al, byte [BPB_FATSz16]     ; no of sectors to read
        add     bx, word [BPB_BytsPerSec]  ; es:bx -> data area
        call    boot_read_floppy
        mov     bx, 0xB000
 
; and copy them to extended memory
        mov     si, movedesc
        mov     [si+8*2+3], bh          ; from
        
        mov     ax, word [BPB_BytsPerSec]
        shr     ax, 1                   ; words per sector
        mov     cx, word [BPB_RsvdSecCnt]
        add     cx, word [BPB_FATSz16]
        mul     cx
        push    ax                      ; save to stack count of words in boot+FAT
        xchg    ax, cx
        
        push    es
        push    ds
        pop     es
        mov     ah, 0x87
        int     0x15
        pop     es
        test    ah, ah
        jz      @f
sayerr_floppy:
        mov     dx, 0x3f2
        mov     al, 0
        out     dx, al
sayerr_memmove:
        mov     si, memmovefailed
        jmp     sayerr_plain
@@:
        pop     ax                      ; restore from stack count of words in boot+FAT
        shl     ax, 1                   ; make bytes count from count of words
        and     eax, 0ffffh
        add     dword [si+8*3+2], eax
 
; copy first FAT to second copy
; TODO: BPB_NumFATs !!!!!
        add     bx, word [BPB_BytsPerSec]       ; !!! TODO: may be need multiply by BPB_RsvdSecCnt !!!
        mov     byte [si+8*2+3], bh     ; bx - begin of FAT
        
        mov     ax, word [BPB_BytsPerSec]
        shr     ax, 1                   ; words per sector
        mov     cx, word [BPB_FATSz16]
        mul     cx
        mov     cx, ax                  ; cx - count of words in FAT
 
        push    es
        push    ds
        pop     es
        mov     ah, 0x87
        int     0x15
        pop     es
        test    ah, ah
        jnz     sayerr_floppy
        
        mov     ax, cx
        shl     ax, 1
        and     eax, 0ffffh             ; ax - count of bytes in FAT
        add     dword [si+8*3+2], eax
        
; reading RootDir
; TODO: BPB_NumFATs
        add     bx, ax
        add     bx, 100h
        and     bx, 0ff00h                      ; bx - place in buffer to write RootDir
        push    bx
 
        mov     bx, word [BPB_BytsPerSec]
        shr     bx, 5                           ; divide bx by 32
        mov     ax, word [BPB_RootEntCnt]
        xor     dx, dx
        div     bx
        push    ax                              ; ax - count of RootDir sectors
 
        mov     ax, word [BPB_FATSz16]
        xor     cx, cx
        mov     cl, byte [BPB_NumFATs]
        mul     cx
        add     ax, word [BPB_RsvdSecCnt]       ; ax - first sector of RootDir
 
        mov     word [FirstDataSector], ax
        pop     bx
        push    bx
        add     word [FirstDataSector], bx      ; Begin of data region of floppy
        
; read RootDir
        call    conv_abs_to_THS
        pop     ax
        pop     bx                              ; place in buffer to write
        push    ax
        call    boot_read_floppy                ; read RootDir into buffer
; copy RootDir
        mov     byte [si+8*2+3], bh             ; from buffer
        pop     ax                              ; ax = count of RootDir sectors
        mov     cx, word [BPB_BytsPerSec]
        mul     cx
        shr     ax, 1
        mov     cx, ax                          ; count of words to copy
        push    es
        push    ds
        pop     es
        mov     ah, 0x87
        int     0x15
        pop     es
 
        mov     ax, cx
        shl     ax, 1
        and     eax, 0ffffh             ; ax - count of bytes in RootDir
        add     dword [si+8*3+2], eax   ; add count of bytes copied
 
; Reading data clusters from floppy
        mov     byte [si+8*2+3], bh
        push    bx
 
        mov     di, 2                   ; First data cluster
.read_loop:
        mov     bx, di
        shr     bx, 1                   ; bx+di = di*1.5
        jnc     .even
        test    word [es:bx+di+0xB200], 0xFFF0  ; TODO: may not be 0xB200 !!!
        jmp     @f
.even:
        test    word [es:bx+di+0xB200], 0xFFF   ; TODO: may not be 0xB200 !!!
 
@@:
        jz      .skip
; read cluster di
;.read:
        ;conv cluster di to abs. sector ax
        ; ax = (N-2) * BPB_SecPerClus + FirstDataSector
        mov     ax, di
        sub     ax, 2
        xor     bx, bx
        mov     bl, byte [BPB_SecPerClus]
        mul     bx
        add     ax, word [FirstDataSector]
        call    conv_abs_to_THS
        pop     bx
        push    bx
        mov     al, byte [BPB_SecPerClus]       ; number of sectors in cluster
        call    boot_read_floppy
        push    es
        push    ds
        pop     es
        pusha
;
        mov     ax, word [BPB_BytsPerSec]
        xor     cx, cx
        mov     cl, byte [BPB_SecPerClus]
        mul     cx
        shr     ax, 1                           ; ax = (BPB_BytsPerSec * BPB_SecPerClus)/2
        mov     cx, ax                          ; number of words to copy (count words in cluster)
;
        mov     ah, 0x87
        int     0x15                            ; copy data
        test    ah, ah
        popa
        pop     es
        jnz     sayerr_floppy
; skip cluster di
.skip:
        mov     ax, word [BPB_BytsPerSec]
        xor     cx, cx
        mov     cl, byte [BPB_SecPerClus]
        mul     cx
        and     eax, 0ffffh             ; ax - count of bytes in cluster
        add     dword [si+8*3+2], eax
 
        mov     ax, word [end_of_FAT]   ; max cluster number
        pusha
; draw percentage
; total clusters: ax
; read clusters: di
        xchg    ax, di
        mov     cx, 100
        mul     cx
        div     di
        aam
        xchg    al, ah
        add     ax, '00'
        mov     si, pros
        cmp     [si], ax
        jz      @f
        mov     [si], ax
        call    printplain
@@:
        popa
        inc     di
        cmp     di, word [end_of_FAT]   ; max number of cluster
        jnz     .read_loop
        pop     bx                      ; clear stack
 
ok_sys_on_floppy:
        mov     si, backspace2
        call    printplain
        mov     si, okt
        call    printplain
no_sys_on_floppy:
        xor     ax, ax          ; reset drive
        xor     dx, dx
        int     0x13
        mov     dx, 0x3f2       ; floppy motor off
        mov     al, 0
        out     dx, al
 
if defined extended_primary_loader
        cmp     [boot_dev], 1
        jne     no_sys_from_primary
; load kolibri.img using callback from primary loader
        and     word [movedesc + 24 + 2], 0
        mov     byte [movedesc + 24 + 4], 10h
; read in blocks of 64K until file is fully loaded
        mov     ax, 1
.repeat:
        mov     di, image_file_struct
        call    [bootcallback]
        push    cs
        pop     ds
        push    cs
        pop     es
        cmp     bx, 1
        ja      sayerr_badsect
        push    bx
        mov     si, movedesc
        and     word [si + 16 + 2], 0
        mov     byte [si + 16 + 4], 4
        mov     ah, 87h
        mov     cx, 8000h
        int     15h
        pop     bx
        test    ah, ah
        jnz     sayerr_memmove
        inc     byte [si + 24 + 4]
        test    bx, bx
        jz      no_sys_from_primary
        mov     ax, 2
        jmp     .repeat
no_sys_from_primary:
end if
 
; SET GRAPHICS
 
        xor     ax, ax
        mov     es, ax
 
        mov     ax, [es:BOOT_VESA_MODE]         ; vga & 320x200
        mov     bx, ax
        cmp     ax, 0x13
        je      setgr
        cmp     ax, 0x12
        je      setgr
        mov     ax, 0x4f02              ; Vesa
setgr:
        int     0x10
        test    ah, ah
        mov     si, fatalsel
        jnz     v_mode_error
; set mode 0x12 graphics registers:
        cmp     bx, 0x12
        jne     gmok2
 
        mov     al, 0x05
        mov     dx, 0x03ce
        push    dx
        out     dx, al      ; select GDC mode register
        mov     al, 0x02
        inc     dx
        out     dx, al      ; set write mode 2
 
        mov     al, 0x02
        mov     dx, 0x03c4
        out     dx, al      ; select VGA sequencer map mask register
        mov     al, 0x0f
        inc     dx
        out     dx, al      ; set mask for all planes 0-3
 
        mov     al, 0x08
        pop     dx
        out     dx, al      ; select GDC bit mask register
                           ; for writes to 0x03cf
gmok2:
        push    ds
        pop     es

Rev 3797	Rev 3964
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;	4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;
5	;; Distributed under terms of the GNU General Public License ;;	5	;; Distributed under terms of the GNU General Public License ;;
6	;; ;;	6	;; ;;
7	;; BOOTCODE.INC ;;	7	;; BOOTCODE.INC ;;
8	;; ;;	8	;; ;;
9	;; KolibriOS 16-bit loader, ;;	9	;; KolibriOS 16-bit loader, ;;
10	;; based on bootcode for MenuetOS ;;	10	;; based on bootcode for MenuetOS ;;
11	;; ;;	11	;; ;;
12	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	12	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13		13
14	$Revision: 3797 $	14	$Revision: 3964 $
15		15
16		16
17	;==========================================================================	17	;==========================================================================
18	;	18	;
19	; 16 BIT FUNCTIONS	19	; 16 BIT FUNCTIONS
20	;	20	;
21	;==========================================================================	21	;==========================================================================
22		22
23		23
24	putchar:	24	putchar:
25	; in: al=character	25	; in: al=character
26	mov ah, 0Eh	26	mov ah, 0Eh
27	mov bh, 0	27	mov bh, 0
28	int 10h	28	int 10h
29	ret	29	ret
30		30
31	print:	31	print:
32	; in: si->string	32	; in: si->string
33	mov al, 186	33	mov al, 186
34	call putchar	34	call putchar
35	mov al, ' '	35	mov al, ' '
36	call putchar	36	call putchar
37		37
38	printplain:	38	printplain:
39	; in: si->string	39	; in: si->string
40	pusha	40	pusha
41	lodsb	41	lodsb
42	@@:	42	@@:
43	call putchar	43	call putchar
44	lodsb	44	lodsb
45	test al, al	45	test al, al
46	jnz @b	46	jnz @b
47	popa	47	popa
48	ret	48	ret
49		49
50	getkey: ; Use BIOS INT 16h to read a key from the keyboard	50	getkey: ; Use BIOS INT 16h to read a key from the keyboard
51	; get number in range [bl,bh] (bl,bh in ['0'..'9'])	51	; get number in range [bl,bh] (bl,bh in ['0'..'9'])
52	; in: bx=range	52	; in: bx=range
53	; out: ax=digit (1..9, 10 for 0)	53	; out: ax=digit (1..9, 10 for 0)
54	mov ah, 0 ; If 'int 16h' is called with 'ah' equal to zero, the BIOS will not return control	54	mov ah, 0 ; If 'int 16h' is called with 'ah' equal to zero, the BIOS will not return control
55	int 16h ; to the caller until a key is available in the system type ahead buffer. On return,	55	int 16h ; to the caller until a key is available in the system type ahead buffer. On return,
56	cmp al, bl ; 'al' contains the ASCII code for the key read from the buffer and 'ah' contains	56	cmp al, bl ; 'al' contains the ASCII code for the key read from the buffer and 'ah' contains
57	jb getkey ; the keyboard scan code. Here we compare 'al' with the range of accepted characters.	57	jb getkey ; the keyboard scan code. Here we compare 'al' with the range of accepted characters.
58	cmp al, bh ; If the key pressed is not in the range, continue waiting for another key.	58	cmp al, bh ; If the key pressed is not in the range, continue waiting for another key.
59	ja getkey	59	ja getkey
60	push ax ; If the pressed key is in the accepted range, save it on the stack and echo to screen.	60	push ax ; If the pressed key is in the accepted range, save it on the stack and echo to screen.
61	call putchar	61	call putchar
62	pop ax	62	pop ax
63	and ax, 0Fh ; ASCII code for '0' is 48 (110000b). 0F4=1111b. (110000b AND 1111b) = 0	63	and ax, 0Fh ; ASCII code for '0' is 48 (110000b). 0F4=1111b. (110000b AND 1111b) = 0
64	jnz @f ; So if key '0' was entered, return 10 in 'ax'	64	jnz @f ; So if key '0' was entered, return 10 in 'ax'
65	mov al, 10	65	mov al, 10
66	@@:	66	@@:
67	ret	67	ret
68		68
69	setcursor:	69	setcursor:
70	; in: dl=column, dh=row	70	; in: dl=column, dh=row
71	mov ah, 2	71	mov ah, 2
72	mov bh, 0	72	mov bh, 0
73	int 10h	73	int 10h
74	ret	74	ret
75		75
76	macro _setcursor row,column	76	macro _setcursor row,column
77	{	77	{
78	mov dx, row*256 + column	78	mov dx, row*256 + column
79	call setcursor	79	call setcursor
80	}	80	}
81		81
82	boot_read_floppy:	82	boot_read_floppy:
83	push si	83	push si
84	xor si, si	84	xor si, si
85	mov ah, 2 ; read	85	mov ah, 2 ; read
86	@@:	86	@@:
87	push ax	87	push ax
88	int 0x13	88	int 0x13
89	pop ax	89	pop ax
90	jnc @f	90	jnc @f
91	inc si	91	inc si
92	cmp si, 10	92	cmp si, 10
93	jb @b	93	jb @b
94	sayerr_badsect:	94	sayerr_badsect:
95	mov si, badsect	95	mov si, badsect
96	sayerr_plain:	96	sayerr_plain:
97	call printplain	97	call printplain
98	jmp $	98	jmp $
99	@@:	99	@@:
100	pop si	100	pop si
101	ret	101	ret
102		102
103	; convert abs. sector number (AX) to BIOS T:H:S	103	; convert abs. sector number (AX) to BIOS T:H:S
104	; sector number = (abs.sector%BPB_SecPerTrk)+1	104	; sector number = (abs.sector%BPB_SecPerTrk)+1
105	; pre.track number = (abs.sector/BPB_SecPerTrk)	105	; pre.track number = (abs.sector/BPB_SecPerTrk)
106	; head number = pre.track number%BPB_NumHeads	106	; head number = pre.track number%BPB_NumHeads
107	; track number = pre.track number/BPB_NumHeads	107	; track number = pre.track number/BPB_NumHeads
108	; Return: cl - sector number	108	; Return: cl - sector number
109	; ch - track number	109	; ch - track number
110	; dl - drive number (0 = a:)	110	; dl - drive number (0 = a:)
111	; dh - head number	111	; dh - head number
112	conv_abs_to_THS:	112	conv_abs_to_THS:
113	push bx	113	push bx
114	mov bx, word [BPB_SecPerTrk]	114	mov bx, word [BPB_SecPerTrk]
115	xor dx, dx	115	xor dx, dx
116	div bx	116	div bx
117	inc dx	117	inc dx
118	mov cl, dl ; cl = sector number	118	mov cl, dl ; cl = sector number
119	mov bx, word [BPB_NumHeads]	119	mov bx, word [BPB_NumHeads]
120	xor dx, dx	120	xor dx, dx
121	div bx	121	div bx
122	; !!!!!!! ax = track number, dx = head number	122	; !!!!!!! ax = track number, dx = head number
123	mov ch, al ; ch=track number	123	mov ch, al ; ch=track number
124	xchg dh, dl ; dh=head number	124	xchg dh, dl ; dh=head number
125	mov dl, 0 ; dl=0 (drive 0 (a:))	125	mov dl, 0 ; dl=0 (drive 0 (a:))
126	pop bx	126	pop bx
127	retn	127	retn
128	; needed variables	128	; needed variables
129	BPB_SecPerTrk dw 0 ; sectors per track	129	BPB_SecPerTrk dw 0 ; sectors per track
130	BPB_NumHeads dw 0 ; number of heads	130	BPB_NumHeads dw 0 ; number of heads
131	BPB_FATSz16 dw 0 ; size of FAT	131	BPB_FATSz16 dw 0 ; size of FAT
132	BPB_RootEntCnt dw 0 ; count of root dir. entries	132	BPB_RootEntCnt dw 0 ; count of root dir. entries
133	BPB_BytsPerSec dw 0 ; bytes per sector	133	BPB_BytsPerSec dw 0 ; bytes per sector
134	BPB_RsvdSecCnt dw 0 ; number of reserved sectors	134	BPB_RsvdSecCnt dw 0 ; number of reserved sectors
135	BPB_TotSec16 dw 0 ; count of the sectors on the volume	135	BPB_TotSec16 dw 0 ; count of the sectors on the volume
136	BPB_SecPerClus db 0 ; number of sectors per cluster	136	BPB_SecPerClus db 0 ; number of sectors per cluster
137	BPB_NumFATs db 0 ; number of FAT tables	137	BPB_NumFATs db 0 ; number of FAT tables
138	abs_sector_adj dw 0 ; adjustment to make abs. sector number	138	abs_sector_adj dw 0 ; adjustment to make abs. sector number
139	end_of_FAT dw 0 ; end of FAT table	139	end_of_FAT dw 0 ; end of FAT table
140	FirstDataSector dw 0 ; begin of data	140	FirstDataSector dw 0 ; begin of data
141		141
142	;=========================================================================	142	;=========================================================================
143	;	143	;
144	; 16 BIT CODE	144	; 16 BIT CODE
145	;	145	;
146	;=========================================================================	146	;=========================================================================
147		147
148	include 'bootvesa.inc' ;Include source for boot vesa	148	include 'bootvesa.inc' ;Include source for boot vesa
149	if defined extended_primary_loader	149	if defined extended_primary_loader
150	include 'parsers.inc'	150	include 'parsers.inc'
151	end if	151	end if
152		152
153	start_of_code:	153	start_of_code:
154		154
155	if defined extended_primary_loader	155	if defined extended_primary_loader
156	; save data from primary loader	156	; save data from primary loader
157	mov word [cs:bootcallback], si	157	mov word [cs:bootcallback], si
158	mov word [cs:bootcallback+2], ds	158	mov word [cs:bootcallback+2], ds
159	push cs	159	push cs
160	pop ds	160	pop ds
161	mov [bootdevice], ax	161	mov [bootdevice], ax
162	mov [bootfs], bx	162	mov [bootfs], bx
163		163
164	; set up stack	164	; set up stack
165	mov ax, 3000h	165	mov ax, 3000h
166	mov ss, ax	166	mov ss, ax
167	mov sp, 0EC00h	167	mov sp, 0EC00h
168		168
169	; try to load configuration file	169	; try to load configuration file
170	mov ax, 1	170	mov ax, 1
171	mov di, config_file_struct	171	mov di, config_file_struct
172	call [bootcallback]	172	call [bootcallback]
173	cld	173	cld
174	push cs	174	push cs
175	pop es	175	pop es
176	; bx=0 - ok, bx=1 - part of file loaded, assume this is ok	176	; bx=0 - ok, bx=1 - part of file loaded, assume this is ok
177	cmp bx, 1	177	cmp bx, 1
178	ja .config_bad	178	ja .config_bad
179	; configuration file was loaded, parse	179	; configuration file was loaded, parse
180	; if length is too big, use first 0FFFFh bytes	180	; if length is too big, use first 0FFFFh bytes
181	test dx, dx	181	test dx, dx
182	jz @f	182	jz @f
183	mov ax, 0FFFFh	183	mov ax, 0FFFFh
184	@@:	184	@@:
185	; ds:si will be pointer to current data, dx = limit	185	; ds:si will be pointer to current data, dx = limit
186	xchg ax, dx	186	xchg ax, dx
187	push 4000h	187	push 4000h
188	pop ds	188	pop ds
189	xor si, si	189	xor si, si
190	.parse_loop:	190	.parse_loop:
191	; skip spaces	191	; skip spaces
192	cmp si, dx	192	cmp si, dx
193	jae .parse_done	193	jae .parse_done
194	lodsb	194	lodsb
195	cmp al, ' '	195	cmp al, ' '
196	jbe .parse_loop	196	jbe .parse_loop
197	dec si	197	dec si
198	; loop over all possible configuration values	198	; loop over all possible configuration values
199	mov bx, config_file_variables	199	mov bx, config_file_variables
200	.find_variant:	200	.find_variant:
201	; get length	201	; get length
202	mov cx, [es:bx]	202	mov cx, [es:bx]
203	; zero length = end of list	203	; zero length = end of list
204	jecxz .find_newline	204	jecxz .find_newline
205	; skip over length	205	; skip over length
206	inc bx	206	inc bx
207	inc bx	207	inc bx
208	mov di, bx	208	mov di, bx
209	; skip over string	209	; skip over string
210	add bx, cx	210	add bx, cx
211	; test whether we have at least cx symbols left	211	; test whether we have at least cx symbols left
212	mov ax, cx	212	mov ax, cx
213	add ax, si	213	add ax, si
214	jc .next_variant1	214	jc .next_variant1
215	cmp ax, dx	215	cmp ax, dx
216	jae .next_variant1	216	jae .next_variant1
217	; save current position	217	; save current position
218	push si	218	push si
219	; compare strings	219	; compare strings
220	repz cmpsb	220	repz cmpsb
221	jnz .next_variant2	221	jnz .next_variant2
222	; strings are equal; look for "=" with possible spaces before and after	222	; strings are equal; look for "=" with possible spaces before and after
223	@@:	223	@@:
224	cmp si, dx	224	cmp si, dx
225	jae .next_variant2	225	jae .next_variant2
226	lodsb	226	lodsb
227	cmp al, ' '	227	cmp al, ' '
228	jbe @b	228	jbe @b
229	cmp al, '='	229	cmp al, '='
230	jnz .next_variant2	230	jnz .next_variant2
231	; ok, we found the true variant	231	; ok, we found the true variant
232	; ignore saved position on the stack	232	; ignore saved position on the stack
233	pop ax	233	pop ax
234	; call the parser	234	; call the parser
235	call word [es:bx]	235	call word [es:bx]
236	; line parsed, find next	236	; line parsed, find next
237	.find_newline:	237	.find_newline:
238	cmp si, dx	238	cmp si, dx
239	jae .parse_done	239	jae .parse_done
240	lodsb	240	lodsb
241	cmp al, 13	241	cmp al, 13
242	jz .parse_loop	242	jz .parse_loop
243	cmp al, 10	243	cmp al, 10
244	jz .parse_loop	244	jz .parse_loop
245	jmp .find_newline	245	jmp .find_newline
246	.next_variant2:	246	.next_variant2:
247	; continue to the next variant, restoring current position	247	; continue to the next variant, restoring current position
248	pop si	248	pop si
249	.next_variant1:	249	.next_variant1:
250	; continue to the next variant	250	; continue to the next variant
251	; skip over the parser	251	; skip over the parser
252	inc bx	252	inc bx
253	inc bx	253	inc bx
254	jmp .find_variant	254	jmp .find_variant
255	.parse_done:	255	.parse_done:
256	.config_bad:	256	.config_bad:
257		257
258	; set up segment registers	258	; set up segment registers
259	push cs	259	push cs
260	pop ds	260	pop ds
261	else	261	else
262	cld	262	cld
263	; \begin{diamond}[02.12.2005]	263	; \begin{diamond}[02.12.2005]
264	; if bootloader sets ax = 'KL', then ds:si points to loader block	264	; if bootloader sets ax = 'KL', then ds:si points to loader block
265	cmp ax, 'KL'	265	cmp ax, 'KL'
266	jnz @f	266	jnz @f
267	mov word [cs:cfgmanager.loader_block], si	267	mov word [cs:cfgmanager.loader_block], si
268	mov word [cs:cfgmanager.loader_block+2], ds	268	mov word [cs:cfgmanager.loader_block+2], ds
269	@@:	269	@@:
270	; \end{diamond}[02.12.2005]	270	; \end{diamond}[02.12.2005]
271		271
272	; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk	272	; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk
273	; (see comment to bx_from_load)	273	; (see comment to bx_from_load)
274	cmp cx, 'HA'	274	cmp cx, 'HA'
275	jnz no_hd_load	275	jnz no_hd_load
276	cmp dx, 'RD'	276	cmp dx, 'RD'
277	jnz no_hd_load	277	jnz no_hd_load
278	mov word [cs:bx_from_load], bx ; {SPraid}[13.03.2007]	278	mov word [cs:bx_from_load], bx ; {SPraid}[13.03.2007]
279	no_hd_load:	279	no_hd_load:
280		280
281	; set up stack	281	; set up stack
282	mov ax, 3000h	282	mov ax, 3000h
283	mov ss, ax	283	mov ss, ax
284	mov sp, 0EC00h	284	mov sp, 0EC00h
285	; set up segment registers	285	; set up segment registers
286	push cs	286	push cs
287	pop ds	287	pop ds
288	push cs	288	push cs
289	pop es	289	pop es
290	end if	290	end if
291		291
292	; set videomode	292	; set videomode
293	mov ax, 3	293	mov ax, 3
294	int 0x10	294	int 0x10
295		295
296	if lang eq ru	296	if lang eq ru
297	; Load & set russian VGA font (RU.INC)	297	; Load & set russian VGA font (RU.INC)
298	mov bp, RU_FNT1 ; RU_FNT1 - First part	298	mov bp, RU_FNT1 ; RU_FNT1 - First part
299	mov bx, 1000h ; 768 bytes	299	mov bx, 1000h ; 768 bytes
300	mov cx, 30h ; 48 symbols	300	mov cx, 30h ; 48 symbols
301	mov dx, 80h ; 128 - position of first symbol	301	mov dx, 80h ; 128 - position of first symbol
302	mov ax, 1100h	302	mov ax, 1100h
303	int 10h	303	int 10h
304		304
305	mov bp, RU_FNT2 ; RU_FNT2 -Second part	305	mov bp, RU_FNT2 ; RU_FNT2 -Second part
306	mov bx, 1000h ; 512 bytes	306	mov bx, 1000h ; 512 bytes
307	mov cx, 20h ; 32 symbols	307	mov cx, 20h ; 32 symbols
308	mov dx, 0E0h ; 224 - position of first symbol	308	mov dx, 0E0h ; 224 - position of first symbol
309	mov ax, 1100h	309	mov ax, 1100h
310	int 10h	310	int 10h
311	; End set VGA russian font	311	; End set VGA russian font
312	else if lang eq et	312	else if lang eq et
313	mov bp, ET_FNT ; ET_FNT1	313	mov bp, ET_FNT ; ET_FNT1
314	mov bx, 1000h ;	314	mov bx, 1000h ;
315	mov cx, 255 ; 256 symbols	315	mov cx, 255 ; 256 symbols
316	xor dx, dx ; 0 - position of first symbol	316	xor dx, dx ; 0 - position of first symbol
317	mov ax, 1100h	317	mov ax, 1100h
318	int 10h	318	int 10h
319	end if	319	end if
320		320
321	; draw frames	321	; draw frames
322	push 0xb800	322	push 0xb800
323	pop es	323	pop es
324	xor di, di	324	xor di, di
325	mov ah, 1*16+15	325	mov ah, 1*16+15
326		326
327	; draw top	327	; draw top
328	mov si, d80x25_top	328	mov si, d80x25_top
329	mov cx, d80x25_top_num * 80	329	mov cx, d80x25_top_num * 80
330	@@:	330	@@:
331	lodsb	331	lodsb
332	stosw	332	stosw
333	loop @b	333	loop @b
334	; draw spaces	334	; draw spaces
335	mov si, space_msg	335	mov si, space_msg
336	mov dx, 25 - d80x25_top_num - d80x25_bottom_num	336	mov dx, 25 - d80x25_top_num - d80x25_bottom_num
337	dfl1:	337	dfl1:
338	push si	338	push si
339	mov cx, 80	339	mov cx, 80
340	@@:	340	@@:
341	lodsb	341	lodsb
342	stosw	342	stosw
343	loop @b	343	loop @b
344	pop si	344	pop si
345	dec dx	345	dec dx
346	jnz dfl1	346	jnz dfl1
347	; draw bottom	347	; draw bottom
348	mov si, d80x25_bottom	348	mov si, d80x25_bottom
349	mov cx, d80x25_bottom_num * 80	349	mov cx, d80x25_bottom_num * 80
350	@@:	350	@@:
351	lodsb	351	lodsb
352	stosw	352	stosw
353	loop @b	353	loop @b
354		354
355	mov byte [space_msg+80], 0 ; now space_msg is null terminated	355	mov byte [space_msg+80], 0 ; now space_msg is null terminated
356		356
357	_setcursor d80x25_top_num,0	357	_setcursor d80x25_top_num,0
358		358
359		359
360	; TEST FOR 386+	360	; TEST FOR 386+
361		361
362	mov bx, 0x4000	362	mov bx, 0x4000
363	pushf	363	pushf
364	pop ax	364	pop ax
365	mov dx, ax	365	mov dx, ax
366	xor ax, bx	366	xor ax, bx
367	push ax	367	push ax
368	popf	368	popf
369	pushf	369	pushf
370	pop ax	370	pop ax
371	and ax, bx	371	and ax, bx
372	and dx, bx	372	and dx, bx
373	cmp ax, dx	373	cmp ax, dx
374	jnz cpugood	374	jnz cpugood
375	mov si, not386	375	mov si, not386
376	sayerr:	376	sayerr:
377	call print	377	call print
378	jmp $	378	jmp $
379	cpugood:	379	cpugood:
380		380
381	push 0	381	push 0
382	popf	382	popf
383	sti	383	sti
384		384
385	; set up esp	385	; set up esp
386	movzx esp, sp	386	movzx esp, sp
387		387
388	push 0	388	push 0
389	pop es	389	pop es
390	xor ax, ax	390	xor ax, ax
391	and word [es:BOOT_IDE_BASE_ADDR], ax ;0	391	and word [es:BOOT_IDE_BASE_ADDR], ax ;0
392	and word [es:BOOT_IDE_BAR0_16], ax ;0	392	and word [es:BOOT_IDE_BAR0_16], ax ;0
393	and word [es:BOOT_IDE_BAR1_16], ax ;0	393	and word [es:BOOT_IDE_BAR1_16], ax ;0
394	and word [es:BOOT_IDE_BAR2_16], ax ;0	394	and word [es:BOOT_IDE_BAR2_16], ax ;0
395	and word [es:BOOT_IDE_BAR3_16], ax ;0	395	and word [es:BOOT_IDE_BAR3_16], ax ;0
396	; \begin{Mario79}	396	; \begin{Mario79}
397	; find HDD IDE DMA PCI device	397	; find HDD IDE DMA PCI device
398	; check for PCI BIOS	398	; check for PCI BIOS
399	mov ax, 0xB101	399	mov ax, 0xB101
400	int 0x1A	400	int 0x1A
401	jc .nopci	401	jc .nopci
402	cmp edx, 'PCI '	402	cmp edx, 'PCI '
403	jnz .nopci	403	jnz .nopci
404	; find PCI class code	404	; find PCI class code
405	; class 1 = mass storage	405	; class 1 = mass storage
406	; subclass 1 = IDE controller	406	; subclass 1 = IDE controller
407	; a) class 1, subclass 1, programming interface 0x80	407	; a) class 1, subclass 1, programming interface 0x80
408	; This is a Parallel IDE Controller which uses IRQs 14 and 15.	408	; This is a Parallel IDE Controller which uses IRQs 14 and 15.
409	mov ax, 0xB103	409	mov ax, 0xB103
410	mov ecx, 110000h + 1100h + 0x80	410	mov ecx, 110000h + 1100h + 0x80
411	mov [es:BOOT_IDE_PI_16], cx	411	mov [es:BOOT_IDE_PI_16], cx
412	xor si, si ; device index = 0	412	xor si, si ; device index = 0
413	int 0x1A	413	int 0x1A
414	jnc .found_1 ; Parallel IDE Controller	414	jnc .found_1 ; Parallel IDE Controller
415	; b) class 1, subclass 1, programming interface 0x8f	415	; b) class 1, subclass 1, programming interface 0x8f
416	mov ax, 0xB103	416	mov ax, 0xB103
417	mov ecx, 110000h + 1100h + 0x8f	417	mov ecx, 110000h + 1100h + 0x8f
418	mov [es:BOOT_IDE_PI_16], cx	418	mov [es:BOOT_IDE_PI_16], cx
419	xor si, si ; device index = 0	419	xor si, si ; device index = 0
420	int 0x1A	420	int 0x1A
421	jnc .found	421	jnc .found
422	; c) class 1, subclass 1, programming interface 0x85	422	; c) class 1, subclass 1, programming interface 0x85
423	mov ax, 0xB103	423	mov ax, 0xB103
424	mov ecx, 110000h + 1100h + 0x85	424	mov ecx, 110000h + 1100h + 0x85
425	mov [es:BOOT_IDE_PI_16], cx	425	mov [es:BOOT_IDE_PI_16], cx
426	xor si, si ; device index = 0	426	xor si, si ; device index = 0
427	int 0x1A	427	int 0x1A
428	jnc .found	428	jnc .found
429	; d) class 1, subclass 1, programming interface 0x8A	429	; d) class 1, subclass 1, programming interface 0x8A
430	; This is a Parallel IDE Controller which uses IRQs 14 and 15.	430	; This is a Parallel IDE Controller which uses IRQs 14 and 15.
431	mov ax, 0xB103	431	mov ax, 0xB103
432	mov ecx, 110000h + 1100h + 0x8A	432	mov ecx, 110000h + 1100h + 0x8A
433	mov [es:BOOT_IDE_PI_16], cx	433	mov [es:BOOT_IDE_PI_16], cx
434	xor si, si ; device index = 0	434	xor si, si ; device index = 0
435	int 0x1A	435	int 0x1A
436	jnc .found_1 ; Parallel IDE Controller	436	jnc .found ; Parallel IDE Controller
437	; Controller not found!	437	; Controller not found!
438	xor ax, ax	438	xor ax, ax
439	mov [es:BOOT_IDE_PI_16], ax	439	mov [es:BOOT_IDE_PI_16], ax
440	jmp .nopci	440	jmp .nopci
441	;--------------------------------------	441	;--------------------------------------
442	.found_1:	442	.found_1:
443	; get memory base BAR4	443	; get memory base BAR4
444	mov ax, 0xB10A	444	mov ax, 0xB10A
445	mov di, 0x20 ; memory base is config register at 0x20	445	mov di, 0x20 ; memory base is config register at 0x20
446	push cx	446	push cx
447	int 0x1A	447	int 0x1A
448	jc .no_BAR4 ;.nopci	448	jc .no_BAR4 ;.nopci
449	and cx, 0xFFFC ; clear address decode type	449	and cx, 0xFFFC ; clear address decode type
450	mov [es:BOOT_IDE_BASE_ADDR], cx	450	mov [es:BOOT_IDE_BASE_ADDR], cx
451	.no_BAR4:	451	.no_BAR4:
452	pop cx	452	pop cx
453	;--------------------------------------	453	;--------------------------------------
454	.found:	454	.found:
455	; get Interrupt Line	455	; get Interrupt Line
456	mov ax, 0xB10A	456	mov ax, 0xB10A
457	mov di, 0x3c ; memory base is config register at 0x3c	457	mov di, 0x3c ; memory base is config register at 0x3c
458	push cx	458	push cx
459	int 0x1A	459	int 0x1A
460	jc .no_Interrupt ;.nopci	460	jc .no_Interrupt ;.nopci
461		461
462	mov [es:BOOT_IDE_INTERR_16], cx	462	mov [es:BOOT_IDE_INTERR_16], cx
463	.no_Interrupt:	463	.no_Interrupt:
464	pop cx	464	pop cx
465	;--------------------------------------	465	;--------------------------------------
466	; get memory base BAR0	466	; get memory base BAR0
467	mov ax, 0xB10A	467	mov ax, 0xB10A
468	mov di, 0x10 ; memory base is config register at 0x10	468	mov di, 0x10 ; memory base is config register at 0x10
469	push cx	469	push cx
470	int 0x1A	470	int 0x1A
471	jc .no_BAR0 ;.nopci	471	jc .no_BAR0 ;.nopci
472		472
473	mov [es:BOOT_IDE_BAR0_16], cx	473	mov [es:BOOT_IDE_BAR0_16], cx
474	.no_BAR0:	474	.no_BAR0:
475	pop cx	475	pop cx
476	;--------------------------------------	476	;--------------------------------------
477	; get memory base BAR1	477	; get memory base BAR1
478	mov ax, 0xB10A	478	mov ax, 0xB10A
479	mov di, 0x14 ; memory base is config register at 0x14	479	mov di, 0x14 ; memory base is config register at 0x14
480	push cx	480	push cx
481	int 0x1A	481	int 0x1A
482	jc .no_BAR1 ;.nopci	482	jc .no_BAR1 ;.nopci
483		483
484	mov [es:BOOT_IDE_BAR1_16], cx	484	mov [es:BOOT_IDE_BAR1_16], cx
485	.no_BAR1:	485	.no_BAR1:
486	pop cx	486	pop cx
487	;--------------------------------------	487	;--------------------------------------
488	; get memory base BAR2	488	; get memory base BAR2
489	mov ax, 0xB10A	489	mov ax, 0xB10A
490	mov di, 0x18 ; memory base is config register at 0x18	490	mov di, 0x18 ; memory base is config register at 0x18
491	push cx	491	push cx
492	int 0x1A	492	int 0x1A
493	jc .no_BAR2 ;.nopci	493	jc .no_BAR2 ;.nopci
494		494
495	mov [es:BOOT_IDE_BAR2_16], cx	495	mov [es:BOOT_IDE_BAR2_16], cx
496	.no_BAR2:	496	.no_BAR2:
497	pop cx	497	pop cx
498	;--------------------------------------	498	;--------------------------------------
499	; get memory base BAR3	499	; get memory base BAR3
500	mov ax, 0xB10A	500	mov ax, 0xB10A

Subversion Repositories Kolibri OS

(root)/kernel/trunk/boot/bootcode.inc – Rev 3797 → 3964