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


$Revision: 545 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. 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        ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 
;==========================================================================
;
;                           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
        cmp     al, 0
        jnz     @b
        popa
        ret
 
getkey:
; 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
        int     16h
        cmp     al, bl
        jb      getkey
        cmp     al, bh
        ja      getkey
        push    ax
        call    putchar
        pop     ax
        and     ax, 0Fh
        jnz     @f
        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
        mov     si, badsect
sayerr_plain:
        call    printplain
        jmp     $
@@:
        pop     si
        ret
 
;=========================================================================
;
;                           16 BIT CODE
;
;=========================================================================
 
 
start_of_code:
        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
 
; 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
        and     word [es:0x9031], 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
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x80
        xor     si, si  ; device index = 0
        int     0x1A
        jnc     .found
; b) class 1, subclass 1, programming interface 0x8A
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x8A
        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
        xor     si, si
        int     0x1A
        jc      .nopci
.found:
; get memory base
        mov     ax, 0xB10A
        mov     di, 0x20        ; memory base is config register at 0x20
        int     0x1A
        jc      .nopci
        and     cx, 0xFFF0      ; clear address decode type
        mov     [es:0x9031], 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
 
; --------------- APM ---------------------
        and     word [es:0x9044], 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:0x9044], ax         ; Save APM Version
        mov     [es:0x9046], 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:0x9040], ebx
        mov     [es:0x9050], ax
        mov     [es:0x9052], cx
        mov     [es:0x9054], dx
 
apm_end:
        _setcursor d80x25_top_num, 0
 
; DISPLAY VESA INFORMATION
 
        mov     ax, 0x4f00
        mov     di, 0xa000
        int     0x10
        cmp     ax, 0x004f
        mov     si, novesa
        jnz     @f
        mov     ax, [es:di+4]
        add     ax, '0'*256+'0'
        mov     si, vervesa
        mov     [si+vervesa_off], ah
        mov     [si+vervesa_off+2], al
@@:     call    print
 
; \begin{diamond}[30.11.2005]
cfgmanager:
; settings:
; a) preboot_graph = graphical mode
;    preboot_gprobe = probe this mode?
; b) preboot_dma  = use DMA access?
; c) preboot_vrrm = use VRR?
; d) preboot_device = from what boot?
        mov     di, preboot_graph
; check bootloader block
        cmp     [.loader_block], -1
        jz      .noloaderblock
        les     bx, [.loader_block]
        cmp     byte [es:bx], 1
        mov     si, loader_block_error
        jnz     sayerr
        test    byte [es:bx+1], 1
        jz      @f
; image in memory present
        cmp     [di+preboot_device-preboot_graph], 0
        jnz     @f
        mov     [di+preboot_device-preboot_graph], 3
@@:
.noloaderblock:
; determine default settings
        mov     [.bSettingsChanged], 0
        cmp     byte [di], 0
        jnz     .preboot_gr_end
        mov     [di+preboot_gprobe-preboot_graph], 0
        mov     al, [vervesa+vervesa_off]
        cmp     al, 'x'
        jz      .novesa
        cmp     al, '1'
        jz      .vesa12
        mov     [di+preboot_gprobe-preboot_graph], 2
        mov     al, 3
        jmp     @f
.vesa12:
        mov     al, 7
        jmp     @f
.novesa:
        mov     al, 10
@@:
        mov     [di], al
.preboot_gr_end:
        cmp     [di+preboot_dma-preboot_graph], 0
        jnz     @f
        mov     [di+preboot_dma-preboot_graph], 3 ; DMA: defaults to none
@@:
; following 4 lines set variables to 1 if its current value is 0
        cmp     [di+preboot_vrrm-preboot_graph], 1
        adc     [di+preboot_vrrm-preboot_graph], 0
        cmp     [di+preboot_device-preboot_graph], 1
        adc     [di+preboot_device-preboot_graph], 0
; notify user
        mov     si, linef
        call    print
        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
        mov     al, [preboot_graph]
        cmp     al, 8
        ja      .pnovesa
        mov     dl, al
        and     eax, 3
        mov     si, [modes_msg+eax*2]
        call    printplain
        mov     si, modevesa20
        cmp     dl, 4
        jbe     @f
        mov     si, modevesa12
@@:
        call    printplain
        cmp     dl, 4
        ja      .x
        mov     si, probeno_msg
        cmp     [preboot_gprobe], 2
        jnz     @f
        mov     si, probeok_msg
@@:
        call    printplain
.x:
        jmp     .c
.pnovesa:
        cmp     al, 9
        mov     si, mode9
        jz      @b
        mov     si, mode10
        jmp     @b
.c:
        mov     si, linef
        call    printplain
        mov     si, dma_msg
        call    print
        cmp     [preboot_dma], 2
        mov     si, on_msg
        jb      @f
        mov     si, off_msg
        ja      @f
        mov     si, readonly_msg
@@:
        call    printplain
        mov     si, vrrm_msg
        cmp     [preboot_vrrm], 1
        call    .say_on_off
        mov     si, preboot_device_msg
        call    print
        mov     al, [preboot_device]
        and     eax, 7
        mov     si, [preboot_device_msgs+eax*2]
        call    printplain
.wait:
        _setcursor 25,0         ; out of screen
; set timer interrupt handler
        cli
        push    0
        pop     es
        mov     eax, [es:8*4]
        mov     [.oldtimer], eax
        mov     eax, [.timer]
        mov     [es:8*4], eax
        sti
; wait for keypressed
        mov     ah, 0
        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
        pop     ax
; switch on key
        cmp     al, 13
        jz      .continue
        or      al, 20h
        cmp     al, 'a'
        jz      .change_a
        cmp     al, 'b'
        jz      .change_b
        cmp     al, 'c'
        jz      .change_c
        cmp     al, 'd'
        jnz     .wait
        _setcursor 15,0
        mov     si, bdev
        call    print
        mov     bx, '14'
        call    getkey
        mov     [preboot_device], al
        _setcursor 13,0
.d:
        mov     [.bSettingsChanged], 1
        mov     si, space_msg
        call    printplain
        _setcursor 15,0
        mov     cx, 6
@@:
        call    printplain
        loop    @b
        jmp    .printcfg
.change_a:
        _setcursor 15,0
        mov     si, gr_mode
        call    printplain
        mov     bx, '09'
        call    getkey
        mov     [preboot_graph], al
        cmp     al, 4
        ja      @f
        mov     si, probetext
        call    printplain
        mov     bx, '12'
        call    getkey
        mov     [preboot_gprobe], al
@@:
        _setcursor 10,0
        jmp    .d
.change_b:
        _setcursor 15,0
        mov     si, ask_dma
        call    print
        mov     bx, '13'
        call    getkey
        mov     [preboot_dma], al
        _setcursor 11,0
        jmp     .d
.change_c:
        _setcursor 15,0
        mov     si, vrrmprint
        call    print
        mov     bx, '12'
        call    getkey
        mov     [preboot_vrrm], al
        _setcursor 12,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 ?
.bSettingsChanged db ?
.timer dd ?
end virtual
.loader_block dd -1
.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]
        sub     ax, 18*5
        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, 'ã'
        jz      @f
        mov     cl, 'ë'
@@:     mov     [time_str+9], cl
else if lang eq et
        cmp     al, 1
        ja      @f
        mov     [time_str+9], ' '
        mov     [time_str+10],' '
@@:
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 15,0
        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
        cmp     al, 'y'
        jnz     .waityn
        call    putchar
        mov     byte [space_msg+80], 186
        pop     eax
        push    cs
        push    .cont
        push    eax
        retf
.loadc:
        pop     eax
.cont:
        push    cs
        pop     ds
        mov     si, space_msg
        mov     byte [si+80], 0
        _setcursor 15,0
        call    printplain
        _setcursor 15,0
.load:
; \end{diamond}[02.12.2005]
 
; ASK GRAPHICS MODE
 
        movzx   ax, [preboot_graph]
        push    0
        pop     es
; address is gr_table+6*(ax-1)
        add     ax, ax
        lea     si, [gr_table + eax + eax*2 - 6]
        mov     bx, [si+0]
        mov     cx, [si+2]
        mov     dx, [si+4]
        cmp     al, 9*2
        mov     al, 32    ; BPP
        jb      @f
        mov     [es:0x9000], al
        or      dword [es:0x9018], 0xFFFFFFFF; 0x800000
@@:
        mov     [es:0x9008], bx
        mov     [es:0x900A], cx
        mov     [es:0x900C], dx
        test    bh, bh
        jz      nov
 
; USE DEFAULTS OR PROBE
 
; bx - mode : cx - x size : dx - y size
        cmp     [preboot_gprobe], 1
        jz      noprobe
 
        mov     bx, 0x100
     newprobe:
        inc     bx
        cmp     bx, 0x17f
        mov     si, prnotfnd
        jz      invalid_video_mode
 
     probemore:
        push    cx
        mov     ax, 0x4f01
        mov     cx, bx
        mov     di, 0xa000
        int     0x10
        pop     cx
 
        test    byte [es:di], 80h    ; lfb?
        jz      newprobe
        cmp     [es:di+0x12], cx    ; x size?
        jnz     newprobe
        cmp     [es:di+0x14], dx    ; y size?
        jnz     newprobe
        cmp     byte [es:di+0x19], 32 ;24
        jb      newprobe
 
;       add     bx, 0100000000000000b
        or      bh, 40h
        mov     [es:0x9008], bx
 
     noprobe:
 
 
; FIND VESA 2.0 LFB & BPP
 
        mov     ax, 0x4f01
        mov     cx, bx
        and     cx, 0xfff
        mov     di, 0xa000
        int     0x10
        ; LFB
        mov     eax, [es:di+0x28]
        mov     [es:0x9018], eax
        ; ---- vbe voodoo
        BytesPerLine equ 0x10
        mov     ax, [es:di+BytesPerLine]
        mov     [es:0x9001], ax
        ; BPP
        mov     al, byte [es:di+0x19]
        mov     [es:0x9000], al
nov:
        cmp     al, 24
        mov     si, bt24
        jz      bppl
        cmp     al, 32
        mov     si, bt32
        jz      bppl
        mov     si, btns
invalid_video_mode:
        call    print
        _setcursor (d80x25_top_num+2), 0
        mov     si, start_msg
        call    print
        jmp     cfgmanager.printcfg
bppl:
        call    print
 
 
; FIND VESA 1.2 PM BANK SWITCH ADDRESS
 
        push    es
        mov     ax, 0x4f0A
        xor     bx, bx
        int     0x10
        xor     eax, eax
        mov     ax, es
        shl     eax, 4
        movzx   ebx, di
        add     eax, ebx
        mov     bx, [es:di]
        add     eax, ebx
        pop     es
        mov     [es:0x9014], eax
 
 
; GRAPHICS ACCELERATION
; force yes
        mov     [es:0x901C], byte 1
 
; DMA ACCESS TO HD
 
        mov     al, [preboot_dma]
        mov     [es:0x901F], al
 
; VRR_M USE
 
        mov     al,[preboot_vrrm]
        mov     [es:0x9030], al
        mov     [es:0x901E], byte 1
 
; BOOT DEVICE
 
        mov     al, [preboot_device]
        dec     al
        mov     [boot_dev], al
 
; 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
; now load floppy image to memory
; at first load boot sector and first FAT table
        mov     cx, 0x0001      ; startcyl,startsector
        xor     dx, dx          ; starthead,drive
        mov     al, 1+9         ; no of sectors to read
        mov     bx, 0xB000      ; es:bx -> data area
        call    boot_read_floppy
; and copy them to extended memory
        mov     si, movedesc
        mov     [si+8*2+3], bh
        push    es
        push    ds
        pop     es
        mov     cx, 256*10
        mov     ah, 0x87
        int     0x15
        test    ah, ah
        jz      @f
sayerr_floppy:
        mov     dx, 0x3f2
        mov     al, 0
        out     dx, al
        mov     si, memmovefailed
        jmp     sayerr_plain
@@:
        add     dword [si+8*3+2], 512*10
; copy FAT to second copy
        mov     byte [si+8*2+3], 0xB2
        mov     cx, 256*9
        mov     ah, 0x87
        int     0x15
        pop     es
        test    ah, ah
        jnz     sayerr_floppy
        add     dword [si+8*3+2], 512*9
; calculate total number of sectors to read
        mov     ax, 1+9+14      ; boot+FAT+root
        mov     di, 0xB203
.calc_loop:
        test    word [es:di], 0xFFF
        jz      @f
        inc     ax
@@:
        test    word [es:di+1], 0xFFF0
        jz      @f
        inc     ax
@@:
        add     di, 3
        cmp     di, 0xB200+1440*3
        jb      .calc_loop
        push    ax
        mov     bp, 1+9         ; already read sectors
; now read rest
        mov     byte [si+8*2+3], 0xA0
        mov     di, 2-14        ; absolute sector-31
        mov     cx, 0x0002      ; cylinder=0, sector=2
        mov     dx, 0x0100      ; head=1, disk=0
.read_loop:
; determine whether sector must be read
        cmp     di, 2
        jl      .read
        mov     bx, di
        shr     bx, 1
        jnc     .even
        test    word [es:bx+di+0xB200], 0xFFF0
        jmp     @f
.even:
        test    word [es:bx+di+0xB200], 0xFFF
@@:
        jz      .skip
.read:
        mov     bx, 0xA000
        mov     al, 1           ; 1 sector
        call    boot_read_floppy
        inc     bp
        push    es
        push    ds
        pop     es
        pusha
        mov     cx, 256
        mov     ah, 0x87
        int     0x15
        test    ah, ah
        popa
        pop     es
        jnz     sayerr_floppy
.skip:
        add     dword [si+8*3+2], 512
        inc     cx
        cmp     cl, 19
        jnz     @f
        mov     cl, 1
        inc     dh
        cmp     dh, 2
        jnz     @f
        mov     dh, 0
        inc     ch
@@:
        pop     ax
        push    ax
        pusha
; draw percentage
; total sectors: ax
; read sectors: bp
        xchg    ax, bp
        mov     cx, 100
        mul     cx
        div     bp
        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, 2880-31
        jnz     .read_loop
 
;        mov     cx, 0x0001      ; startcyl,startsector
;        xor     dx, dx          ; starthead,drive
;        push    word 80*2               ; read no of sect
;       reads:
;        pusha
;        xor     si,si
;       newread:
;        mov     bx,0xa000               ; es:bx -> data area
;        mov     ax,0x0200+18            ; read, no of sectors to read
;        int     0x13
;        test    ah, ah
;        jz      goodread
;        inc    si
;        cmp     si,10
;        jnz     newread
;        mov     si,badsect-0x10000
;sayerr_plain:
;        call    printplain
;        jmp     $
;       goodread:
;        ; move -> 1mb
;        mov     si,movedesc-0x10000
;        push    es
;        push    ds
;        pop     es
;        mov     cx,256*18
;        mov     ah,0x87
;        int     0x15
;        pop    es
;
;        test    ah,ah                  ; was the move successfull ?
;        je      goodmove
;        mov     dx,0x3f2              ; floppy motor off
;        mov     al,0
;        out     dx,al
;        mov     si,memmovefailed-0x10000
;        jmp    sayerr_plain
;      goodmove:
;
;    add    dword [movedesc-0x10000+0x18+2], 512*18
;        popa
;        inc     dh
;        cmp     dh,2
;        jnz     bb2
;        mov     dh,0
;        inc     ch
;        pusha                        ; print prosentage
;        mov     si,pros-0x10000
;    shr    ch, 2
;    mov    al, '5'
;    test    ch, 1
;    jnz    @f
;    mov    al, '0'
;@@:
;    mov    [si+1], al
;    shr    ch, 1
;    add    ch, '0'
;    mov    [si], ch
;        call    printplain
;        popa
;       bb2:
;        pop     ax
;        dec     ax
;        push    ax
;        jnz     reads
;       readdone:
;        pop     ax
 
        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
 
 
; SET GRAPHICS
 
        xor     ax, ax
        mov     es, ax
 
        mov     ax, [es:0x9008]         ; 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     sayerr
; 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 523	Rev 545
1	$Revision: 523 $	1	$Revision: 545 $
2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3	;; ;;	3	;; ;;
4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
5	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;	5	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;
6	;; Distributed under terms of the GNU General Public License ;;	6	;; Distributed under terms of the GNU General Public License ;;
7	;; ;;	7	;; ;;
8	;; BOOTCODE.INC ;;	8	;; BOOTCODE.INC ;;
9	;; ;;	9	;; ;;
10	;; KolibriOS 16-bit loader, ;;	10	;; KolibriOS 16-bit loader, ;;
11	;; based on bootcode for MenuetOS ;;	11	;; based on bootcode for MenuetOS ;;
12	;; ;;	12	;; ;;
13	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	13	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
14		14
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	cmp al, 0	45	cmp al, 0
46	jnz @b	46	jnz @b
47	popa	47	popa
48	ret	48	ret
49		49
50	getkey:	50	getkey:
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	54	mov ah, 0
55	int 16h	55	int 16h
56	cmp al, bl	56	cmp al, bl
57	jb getkey	57	jb getkey
58	cmp al, bh	58	cmp al, bh
59	ja getkey	59	ja getkey
60	push ax	60	push ax
61	call putchar	61	call putchar
62	pop ax	62	pop ax
63	and ax, 0Fh	63	and ax, 0Fh
64	jnz @f	64	jnz @f
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	mov si, badsect	94	mov si, badsect
95	sayerr_plain:	95	sayerr_plain:
96	call printplain	96	call printplain
97	jmp $	97	jmp $
98	@@:	98	@@:
99	pop si	99	pop si
100	ret	100	ret
101		101
102	;=========================================================================	102	;=========================================================================
103	;	103	;
104	; 16 BIT CODE	104	; 16 BIT CODE
105	;	105	;
106	;=========================================================================	106	;=========================================================================
107		107
108		108
109	start_of_code:	109	start_of_code:
110	cld	110	cld
111	; \begin{diamond}[02.12.2005]	111	; \begin{diamond}[02.12.2005]
112	; if bootloader sets ax = 'KL', then ds:si points to loader block	112	; if bootloader sets ax = 'KL', then ds:si points to loader block
113	cmp ax, 'KL'	113	cmp ax, 'KL'
114	jnz @f	114	jnz @f
115	mov word [cs:cfgmanager.loader_block], si	115	mov word [cs:cfgmanager.loader_block], si
116	mov word [cs:cfgmanager.loader_block+2], ds	116	mov word [cs:cfgmanager.loader_block+2], ds
117	@@:	117	@@:
118	; \end{diamond}[02.12.2005]	118	; \end{diamond}[02.12.2005]
119		119
120	; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk	120	; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk
121	; (see comment to bx_from_load)	121	; (see comment to bx_from_load)
122	cmp cx, 'HA'	122	cmp cx, 'HA'
123	jnz no_hd_load	123	jnz no_hd_load
124	cmp dx,'RD'	124	cmp dx,'RD'
125	jnz no_hd_load	125	jnz no_hd_load
126	mov word [cs:bx_from_load], bx ; {SPraid}[13.03.2007]	126	mov word [cs:bx_from_load], bx ; {SPraid}[13.03.2007]
127	no_hd_load:	127	no_hd_load:
128		128
129	; set up stack	129	; set up stack
130	mov ax, 3000h	130	mov ax, 3000h
131	mov ss, ax	131	mov ss, ax
132	mov sp, 0EC00h	132	mov sp, 0EC00h
133	; set up segment registers	133	; set up segment registers
134	push cs	134	push cs
135	pop ds	135	pop ds
136	push cs	136	push cs
137	pop es	137	pop es
138		138
139	; set videomode	139	; set videomode
140	mov ax, 3	140	mov ax, 3
141	int 0x10	141	int 0x10
142		142
143	if lang eq ru	143	if lang eq ru
144	; Load & set russian VGA font (RU.INC)	144	; Load & set russian VGA font (RU.INC)
145	mov bp, RU_FNT1 ; RU_FNT1 - First part	145	mov bp, RU_FNT1 ; RU_FNT1 - First part
146	mov bx, 1000h ; 768 bytes	146	mov bx, 1000h ; 768 bytes
147	mov cx, 30h ; 48 symbols	147	mov cx, 30h ; 48 symbols
148	mov dx, 80h ; 128 - position of first symbol	148	mov dx, 80h ; 128 - position of first symbol
149	mov ax, 1100h	149	mov ax, 1100h
150	int 10h	150	int 10h
151		151
152	mov bp, RU_FNT2 ; RU_FNT2 -Second part	152	mov bp, RU_FNT2 ; RU_FNT2 -Second part
153	mov bx, 1000h ; 512 bytes	153	mov bx, 1000h ; 512 bytes
154	mov cx, 20h ; 32 symbols	154	mov cx, 20h ; 32 symbols
155	mov dx, 0E0h ; 224 - position of first symbol	155	mov dx, 0E0h ; 224 - position of first symbol
156	mov ax, 1100h	156	mov ax, 1100h
157	int 10h	157	int 10h
158	; End set VGA russian font	158	; End set VGA russian font
159	else if lang eq et	159	else if lang eq et
160	mov bp, ET_FNT ; ET_FNT1	160	mov bp, ET_FNT ; ET_FNT1
161	mov bx, 1000h ;	161	mov bx, 1000h ;
162	mov cx, 255 ; 256 symbols	162	mov cx, 255 ; 256 symbols
163	xor dx, dx ; 0 - position of first symbol	163	xor dx, dx ; 0 - position of first symbol
164	mov ax, 1100h	164	mov ax, 1100h
165	int 10h	165	int 10h
166	end if	166	end if
167		167
168	; draw frames	168	; draw frames
169	push 0xb800	169	push 0xb800
170	pop es	170	pop es
171	xor di, di	171	xor di, di
172	mov ah, 1*16+15	172	mov ah, 1*16+15
173		173
174	; draw top	174	; draw top
175	mov si, d80x25_top	175	mov si, d80x25_top
176	mov cx, d80x25_top_num * 80	176	mov cx, d80x25_top_num * 80
177	@@:	177	@@:
178	lodsb	178	lodsb
179	stosw	179	stosw
180	loop @b	180	loop @b
181	; draw spaces	181	; draw spaces
182	mov si, space_msg	182	mov si, space_msg
183	mov dx, 25 - d80x25_top_num - d80x25_bottom_num	183	mov dx, 25 - d80x25_top_num - d80x25_bottom_num
184	dfl1:	184	dfl1:
185	push si	185	push si
186	mov cx, 80	186	mov cx, 80
187	@@:	187	@@:
188	lodsb	188	lodsb
189	stosw	189	stosw
190	loop @b	190	loop @b
191	pop si	191	pop si
192	dec dx	192	dec dx
193	jnz dfl1	193	jnz dfl1
194	; draw bottom	194	; draw bottom
195	mov si, d80x25_bottom	195	mov si, d80x25_bottom
196	mov cx, d80x25_bottom_num * 80	196	mov cx, d80x25_bottom_num * 80
197	@@:	197	@@:
198	lodsb	198	lodsb
199	stosw	199	stosw
200	loop @b	200	loop @b
201		201
202	mov byte [space_msg+80], 0 ; now space_msg is null terminated	202	mov byte [space_msg+80], 0 ; now space_msg is null terminated
203		203
204	_setcursor d80x25_top_num,0	204	_setcursor d80x25_top_num,0
205		205
206		206
207	; TEST FOR 386+	207	; TEST FOR 386+
208		208
209	mov bx, 0x4000	209	mov bx, 0x4000
210	pushf	210	pushf
211	pop ax	211	pop ax
212	mov dx, ax	212	mov dx, ax
213	xor ax, bx	213	xor ax, bx
214	push ax	214	push ax
215	popf	215	popf
216	pushf	216	pushf
217	pop ax	217	pop ax
218	and ax, bx	218	and ax, bx
219	and dx, bx	219	and dx, bx
220	cmp ax, dx	220	cmp ax, dx
221	jnz cpugood	221	jnz cpugood
222	mov si, not386	222	mov si, not386
223	sayerr:	223	sayerr:
224	call print	224	call print
225	jmp $	225	jmp $
226	cpugood:	226	cpugood:
227		227
228	push 0	228	push 0
229	popf	229	popf
230	sti	230	sti
231		231
232	; set up esp	232	; set up esp
233	movzx esp, sp	233	movzx esp, sp
234		234
235	push 0	235	push 0
236	pop es	236	pop es
237	and word [es:0x9031], 0	237	and word [es:0x9031], 0
238	; \begin{Mario79}	238	; \begin{Mario79}
239	; find HDD IDE DMA PCI device	239	; find HDD IDE DMA PCI device
240	; check for PCI BIOS	240	; check for PCI BIOS
241	mov ax, 0xB101	241	mov ax, 0xB101
242	int 0x1A	242	int 0x1A
243	jc .nopci	243	jc .nopci
244	cmp edx, 'PCI '	244	cmp edx, 'PCI '
245	jnz .nopci	245	jnz .nopci
246	; find PCI class code	246	; find PCI class code
247	; class 1 = mass storage	247	; class 1 = mass storage
248	; subclass 1 = IDE controller	248	; subclass 1 = IDE controller
249	; a) class 1, subclass 1, programming interface 0x80	249	; a) class 1, subclass 1, programming interface 0x80
250	mov ax, 0xB103	250	mov ax, 0xB103
251	mov ecx, 110000h + 1100h + 0x80	251	mov ecx, 110000h + 1100h + 0x80
252	xor si, si ; device index = 0	252	xor si, si ; device index = 0
253	int 0x1A	253	int 0x1A
254	jnc .found	254	jnc .found
255	; b) class 1, subclass 1, programming interface 0x8A	255	; b) class 1, subclass 1, programming interface 0x8A
256	mov ax, 0xB103	256	mov ax, 0xB103
257	mov ecx, 110000h + 1100h + 0x8A	257	mov ecx, 110000h + 1100h + 0x8A
258	xor si, si ; device index = 0	258	xor si, si ; device index = 0
259	int 0x1A	259	int 0x1A
260	jnc .found	260	jnc .found
261	; c) class 1, subclass 1, programming interface 0x85	261	; c) class 1, subclass 1, programming interface 0x85
262	mov ax, 0xB103	262	mov ax, 0xB103
263	mov ecx, 110000h + 1100h + 0x85	263	mov ecx, 110000h + 1100h + 0x85
264	xor si, si	264	xor si, si
265	int 0x1A	265	int 0x1A
266	jc .nopci	266	jc .nopci
267	.found:	267	.found:
268	; get memory base	268	; get memory base
269	mov ax, 0xB10A	269	mov ax, 0xB10A
270	mov di, 0x20 ; memory base is config register at 0x20	270	mov di, 0x20 ; memory base is config register at 0x20
271	int 0x1A	271	int 0x1A
272	jc .nopci	272	jc .nopci
273	and cx, 0xFFF0 ; clear address decode type	273	and cx, 0xFFF0 ; clear address decode type
274	mov [es:0x9031], cx	274	mov [es:0x9031], cx
275	.nopci:	275	.nopci:
276	; \end{Mario79}	276	; \end{Mario79}
277		277
278	mov al, 0xf6 ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå	278	mov al, 0xf6 ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå
279	out 0x60, al	279	out 0x60, al
280	xor cx, cx	280	xor cx, cx
281	wait_loop: ; variant 2	281	wait_loop: ; variant 2
282	; reading state of port of 8042 controller	282	; reading state of port of 8042 controller
283	in al, 64h	283	in al, 64h
284	and al, 00000010b ; ready flag	284	and al, 00000010b ; ready flag
285	; wait until 8042 controller is ready	285	; wait until 8042 controller is ready
286	loopnz wait_loop	286	loopnz wait_loop
287		287
288	; --------------- APM ---------------------	288	; --------------- APM ---------------------
289	and word [es:0x9044], 0 ; ver = 0.0 (APM not found)	289	and word [es:0x9044], 0 ; ver = 0.0 (APM not found)
290	mov ax, 0x5300	290	mov ax, 0x5300
291	xor bx, bx	291	xor bx, bx
292	int 0x15	292	int 0x15
293	jc apm_end ; APM not found	293	jc apm_end ; APM not found
294	test cx, 2	294	test cx, 2
295	jz apm_end ; APM 32-bit protected-mode interface not supported	295	jz apm_end ; APM 32-bit protected-mode interface not supported
296	mov [es:0x9044], ax ; Save APM Version	296	mov [es:0x9044], ax ; Save APM Version
297	mov [es:0x9046], cx ; Save APM flags	297	mov [es:0x9046], cx ; Save APM flags
298		298
299	; Write APM ver ----	299	; Write APM ver ----
300	and ax, 0xf0f	300	and ax, 0xf0f
301	add ax, '00'	301	add ax, '00'
302	mov si, msg_apm	302	mov si, msg_apm
303	mov [si + 5], ah	303	mov [si + 5], ah
304	mov [si + 7], al	304	mov [si + 7], al
305	_setcursor 0, 3	305	_setcursor 0, 3
306	call printplain	306	call printplain
307	; ------------------	307	; ------------------
308		308
309	mov ax, 0x5304 ; Disconnect interface	309	mov ax, 0x5304 ; Disconnect interface
310	xor bx, bx	310	xor bx, bx
311	int 0x15	311	int 0x15
312	mov ax, 0x5303 ; Connect 32 bit mode interface	312	mov ax, 0x5303 ; Connect 32 bit mode interface
313	xor bx, bx	313	xor bx, bx
314	int 0x15	314	int 0x15
315		315
316	mov [es:0x9040], ebx	316	mov [es:0x9040], ebx
317	mov [es:0x9050], ax	317	mov [es:0x9050], ax
318	mov [es:0x9052], cx	318	mov [es:0x9052], cx
319	mov [es:0x9054], dx	319	mov [es:0x9054], dx
320		320
321	apm_end:	321	apm_end:
322	_setcursor d80x25_top_num, 0	322	_setcursor d80x25_top_num, 0
323		323
324	; DISPLAY VESA INFORMATION	324	; DISPLAY VESA INFORMATION
325		325
326	mov ax, 0x4f00	326	mov ax, 0x4f00
327	mov di, 0xa000	327	mov di, 0xa000
328	int 0x10	328	int 0x10
329	cmp ax, 0x004f	329	cmp ax, 0x004f
330	mov si, novesa	330	mov si, novesa
331	jnz @f	331	jnz @f
332	mov ax, [es:di+4]	332	mov ax, [es:di+4]
333	add ax, '0'*256+'0'	333	add ax, '0'*256+'0'
334	mov si, vervesa	334	mov si, vervesa
335	mov [si+vervesa_off], ah	335	mov [si+vervesa_off], ah
336	mov [si+vervesa_off+2], al	336	mov [si+vervesa_off+2], al
337	@@: call print	337	@@: call print
338		338
339	; \begin{diamond}[30.11.2005]	339	; \begin{diamond}[30.11.2005]
340	cfgmanager:	340	cfgmanager:
341	; settings:	341	; settings:
342	; a) preboot_graph = graphical mode	342	; a) preboot_graph = graphical mode
343	; preboot_gprobe = probe this mode?	343	; preboot_gprobe = probe this mode?
344	; b) preboot_dma = use DMA access?	344	; b) preboot_dma = use DMA access?
345	; c) preboot_vrrm = use VRR?	345	; c) preboot_vrrm = use VRR?
346	; d) preboot_device = from what boot?	346	; d) preboot_device = from what boot?
347	mov di, preboot_graph	347	mov di, preboot_graph
348	; check bootloader block	348	; check bootloader block
349	cmp [.loader_block], -1	349	cmp [.loader_block], -1
350	jz .noloaderblock	350	jz .noloaderblock
351	les bx, [.loader_block]	351	les bx, [.loader_block]
352	cmp byte [es:bx], 1	352	cmp byte [es:bx], 1
353	mov si, loader_block_error	353	mov si, loader_block_error
354	jnz sayerr	354	jnz sayerr
355	test byte [es:bx+1], 1	355	test byte [es:bx+1], 1
356	jz @f	356	jz @f
357	; image in memory present	357	; image in memory present
358	cmp [di+preboot_device-preboot_graph], 0	358	cmp [di+preboot_device-preboot_graph], 0
359	jnz @f	359	jnz @f
360	mov [di+preboot_device-preboot_graph], 3	360	mov [di+preboot_device-preboot_graph], 3
361	@@:	361	@@:
362	.noloaderblock:	362	.noloaderblock:
363	; determine default settings	363	; determine default settings
364	mov [.bSettingsChanged], 0	364	mov [.bSettingsChanged], 0
365	cmp byte [di], 0	365	cmp byte [di], 0
366	jnz .preboot_gr_end	366	jnz .preboot_gr_end
367	mov [di+preboot_gprobe-preboot_graph], 0	367	mov [di+preboot_gprobe-preboot_graph], 0
368	mov al, [vervesa+vervesa_off]	368	mov al, [vervesa+vervesa_off]
369	cmp al, 'x'	369	cmp al, 'x'
370	jz .novesa	370	jz .novesa
371	cmp al, '1'	371	cmp al, '1'
372	jz .vesa12	372	jz .vesa12
373	mov [di+preboot_gprobe-preboot_graph], 2	373	mov [di+preboot_gprobe-preboot_graph], 2
374	mov al, 3	374	mov al, 3
375	jmp @f	375	jmp @f
376	.vesa12:	376	.vesa12:
377	mov al, 7	377	mov al, 7
378	jmp @f	378	jmp @f
379	.novesa:	379	.novesa:
380	mov al, 10	380	mov al, 10
381	@@:	381	@@:
382	mov [di], al	382	mov [di], al
383	.preboot_gr_end:	383	.preboot_gr_end:
384	cmp [di+preboot_dma-preboot_graph], 0	384	cmp [di+preboot_dma-preboot_graph], 0
385	jnz @f	385	jnz @f
386	mov [di+preboot_dma-preboot_graph], 3 ; DMA: defaults to none	386	mov [di+preboot_dma-preboot_graph], 3 ; DMA: defaults to none
387	@@:	387	@@:
388	; following 4 lines set variables to 1 if its current value is 0	388	; following 4 lines set variables to 1 if its current value is 0
389	cmp [di+preboot_vrrm-preboot_graph], 1	389	cmp [di+preboot_vrrm-preboot_graph], 1
390	adc [di+preboot_vrrm-preboot_graph], 0	390	adc [di+preboot_vrrm-preboot_graph], 0
391	cmp [di+preboot_device-preboot_graph], 1	391	cmp [di+preboot_device-preboot_graph], 1
392	adc [di+preboot_device-preboot_graph], 0	392	adc [di+preboot_device-preboot_graph], 0
393	; notify user	393	; notify user
394	mov si, linef	394	mov si, linef
395	call print	395	call print
396	mov si, start_msg	396	mov si, start_msg
397	call print	397	call print
398	mov si, time_msg	398	mov si, time_msg
399	call print	399	call print
400	; get start time	400	; get start time
401	call .gettime	401	call .gettime
402	mov [.starttime], eax	402	mov [.starttime], eax
403	mov word [.timer], .newtimer	403	mov word [.timer], .newtimer
404	mov word [.timer+2], cs	404	mov word [.timer+2], cs
405	.printcfg:	405	.printcfg:
406	_setcursor 9,0	406	_setcursor 9,0
407	mov si, current_cfg_msg	407	mov si, current_cfg_msg
408	call print	408	call print
409	mov si, curvideo_msg	409	mov si, curvideo_msg
410	call print	410	call print
411	mov al, [preboot_graph]	411	mov al, [preboot_graph]
412	cmp al, 8	412	cmp al, 8
413	ja .pnovesa	413	ja .pnovesa
414	mov dl, al	414	mov dl, al
415	and eax, 3	415	and eax, 3
416	mov si, [modes_msg+eax*2]	416	mov si, [modes_msg+eax*2]
417	call printplain	417	call printplain
418	mov si, modevesa20	418	mov si, modevesa20
419	cmp dl, 4	419	cmp dl, 4
420	jbe @f	420	jbe @f
421	mov si, modevesa12	421	mov si, modevesa12
422	@@:	422	@@:
423	call printplain	423	call printplain
424	cmp dl, 4	424	cmp dl, 4
425	ja .x	425	ja .x
426	mov si, probeno_msg	426	mov si, probeno_msg
427	cmp [preboot_gprobe], 2	427	cmp [preboot_gprobe], 2
428	jnz @f	428	jnz @f
429	mov si, probeok_msg	429	mov si, probeok_msg
430	@@:	430	@@:
431	call printplain	431	call printplain
432	.x:	432	.x:
433	jmp .c	433	jmp .c
434	.pnovesa:	434	.pnovesa:
435	cmp al, 9	435	cmp al, 9
436	mov si, mode9	436	mov si, mode9
437	jz @b	437	jz @b
438	mov si, mode10	438	mov si, mode10
439	jmp @b	439	jmp @b
440	.c:	440	.c:
441	mov si, linef	441	mov si, linef
442	call printplain	442	call printplain
443	mov si, dma_msg	443	mov si, dma_msg
444	call print	444	call print
445	cmp [preboot_dma], 2	445	cmp [preboot_dma], 2
446	mov si, on_msg	446	mov si, on_msg
447	jb @f	447	jb @f
448	mov si, off_msg	448	mov si, off_msg
449	ja @f	449	ja @f
450	mov si, readonly_msg	450	mov si, readonly_msg
451	@@:	451	@@:
452	call printplain	452	call printplain
453	mov si, vrrm_msg	453	mov si, vrrm_msg
454	cmp [preboot_vrrm], 1	454	cmp [preboot_vrrm], 1
455	call .say_on_off	455	call .say_on_off
456	mov si, preboot_device_msg	456	mov si, preboot_device_msg
457	call print	457	call print
458	mov al, [preboot_device]	458	mov al, [preboot_device]
459	and eax, 3	459	and eax, 7
460	mov si, [preboot_device_msgs+eax*2]	460	mov si, [preboot_device_msgs+eax*2]
461	call printplain	461	call printplain
462	.wait:	462	.wait:
463	_setcursor 25,0 ; out of screen	463	_setcursor 25,0 ; out of screen
464	; set timer interrupt handler	464	; set timer interrupt handler
465	cli	465	cli
466	push 0	466	push 0
467	pop es	467	pop es
468	mov eax, [es:8*4]	468	mov eax, [es:8*4]
469	mov [.oldtimer], eax	469	mov [.oldtimer], eax
470	mov eax, [.timer]	470	mov eax, [.timer]
471	mov [es:8*4], eax	471	mov [es:8*4], eax
472	sti	472	sti
473	; wait for keypressed	473	; wait for keypressed
474	mov ah, 0	474	mov ah, 0
475	int 16h	475	int 16h
476	push ax	476	push ax
477	; restore timer interrupt	477	; restore timer interrupt
478	push 0	478	push 0
479	pop es	479	pop es
480	mov eax, [.oldtimer]	480	mov eax, [.oldtimer]
481	mov [es:8*4], eax	481	mov [es:8*4], eax
482	mov [.timer], eax	482	mov [.timer], eax
483	_setcursor 7,0	483	_setcursor 7,0
484	mov si, space_msg	484	mov si, space_msg
485	call printplain	485	call printplain
486	pop ax	486	pop ax
487	; switch on key	487	; switch on key
488	cmp al, 13	488	cmp al, 13
489	jz .continue	489	jz .continue
490	or al, 20h	490	or al, 20h
491	cmp al, 'a'	491	cmp al, 'a'
492	jz .change_a	492	jz .change_a
493	cmp al, 'b'	493	cmp al, 'b'
494	jz .change_b	494	jz .change_b
495	cmp al, 'c'	495	cmp al, 'c'
496	jz .change_c	496	jz .change_c
497	cmp al, 'd'	497	cmp al, 'd'
498	jnz .wait	498	jnz .wait
499	_setcursor 15,0	499	_setcursor 15,0
500	mov si, bdev	500	mov si, bdev

Subversion Repositories Kolibri OS

(root)/kernel/trunk/boot/bootcode.inc – Rev 523 → 545