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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                        ;;
;;  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
 
; Now int 16 is used for keyboard support.
; This is shorter, simpler and more reliable.
if 0
getkey:      push  ecx
             push  edx
             add   ebx,0x0101
             xor   eax,eax
 
           gk1:
             in    al,0x60
             mov   cl,al
           gk0:
             in    al,0x60
             cmp   al,cl
             je    gk0
             cmp   ax,11
             jg    gk0
             gk0_1:
             mov   cl,al
 
;             add   al,47
;             mov   [ds:keyinbs-0x10000],al
;             mov   si,keyinbs-0x10000
;             call  printplain
 
           gk12:
             in    al,0x60
             cmp   al,cl
             je    gk12
             cmp   ax,240
             jne   gk13
             mov   al,cl
             jmp   gk14
           gk13:
             add   cl,128
             cmp   al,cl
             jne   gk1
             sub   al,128
           gk14:
 
             movzx edx,bl
             cmp   eax,edx
             jb    gk1
             movzx edx,bh
             cmp   eax,edx
             jg    gk1
             test  ebx,0x010000
             jnz   gk3
             mov   cx,0x1000
             mov   dx,cx
             add   eax,47
             mov   cx,ax
             cmp   cx,58
             jb    gk_nozero
             sub   cx,10
           gk_nozero:
             mov   [ds:keyin-0x10000],cl
             mov   si,keyin-0x10000
             call  printplain
           gk3:
             sub   eax,48
             pop   edx
             pop   ecx
             ret
end if
 
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
}
 
pagetable_set:
;eax - physical address
;es:di - page table
;ecx - number of pages to map
    or    al, 7
@@:
    stosd
    add    eax, 1000h
    loop    @b
    ret
 
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-0x10000
sayerr_plain:
        call    printplain
        jmp     $
@@:
        pop     si
        ret
 
; 16-bit data
; videomodes table
		org $+0x10000
gr_table:
    dw      0x112+0100000000000000b ,  640 ,  480        ; 1
    dw      0x115+0100000000000000b ,  800 ,  600        ; 2
    dw      0x118+0100000000000000b , 1024 ,  768        ; 3
    dw      0x11B+0100000000000000b , 1280 , 1024        ; 4
    dw      0x112 ,  640 , 480                ; 5
    dw      0x115 ,  800 , 600                ; 6
    dw      0x118 , 1024 , 768                ; 7
    dw      0x11B , 1280 ,1024                ; 8
    dw    0x13, 640, 480                    ; 9
    dw    0x12, 640, 480                    ; 0
 
; table for move to extended memory (int 15h, ah=87h)
       movedesc:
        db      0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
        db      0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
 
        db      0xff,0xff,0x0,0xa0,0x00,0x93,0x0,0x0
        db      0xff,0xff,0x0,0x00,0x10,0x93,0x0,0x0
 
        db      0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
        db      0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
        db      0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
        db      0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
        	org $-0x10000
 
;=========================================================================
;
;                           16 BIT CODE
;
;=========================================================================
 
 
start_of_code:
    cld
; \begin{diamond}[02.12.2005]
    cmp    ax, 'KL'
    jnz    @f
    mov    word [cs:cfgmanager.loader_block-0x10000], si
    mov    word [cs:cfgmanager.loader_block+2-0x10000], ds
@@:
; \end{diamond}[02.12.2005]
 
; 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-10000h   ; 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-10000h   ; 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
end if
 
; draw frames
    push    0xb800
    pop    es
    xor    di, di
;        mov  si,d80x25-0x10000
;        mov  cx,80*25
;        mov  ah,1*16+15
;       dfl1:
;        lodsb
;        stosw
;        loop dfl1
    mov    ah, 1*16+15
; draw top
    mov    si, d80x25_top - 0x10000
    mov    cx, d80x25_top_num * 80
@@:
    lodsb
    stosw
    loop    @b
; draw spaces
    mov    si, space_msg - 0x10000
    mov    cx, 25 - d80x25_top_num - d80x25_bottom_num
dfl1:
    push    cx
    push    si
    mov    cx, 80
@@:
    lodsb
    stosw
    loop    @b
    pop    si
    pop    cx
    loop    dfl1
; draw bottom
    mov    si, d80x25_bottom - 0x10000
    mov    cx, d80x25_bottom_num * 80
@@:
    lodsb
    stosw
    loop    @b
 
    mov    byte [space_msg-0x10000+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-0x10000
sayerr:
        call    print
        jmp     $
     cpugood:
 
; set up esp
    movzx    esp, sp
 
; FLUSH 8042 KEYBOARD CONTROLLER
 
;// mike.dld [
 ;       mov     al,0xED
 ;       out     0x60,al
 ;       or      cx,-1
 ;     @@:
 ;       in      al,0x64
 ;       test    al,2
 ;       jz      @f
 ;       loop    @b
 ;     @@:
 ;       mov     al,0
 ;       out     0x60,al
 ;       or      cx,-1
 ;     @@:
 ;       in      al,0x64
 ;       test    al,2
 ;       jz      @f
 ;       loop    @b
 ;     @@:
;// mike.dld ]
 
;       mov     ecx,10000
;      fl1:
;       in      al,0x64
;       loop    fl1
;       test    al,1
;       jz      fl2
;       in      al,0x60
;       jmp     fl1
;      fl2:
 
;****************************************************************
; The function is modified Mario79
;*****************************************************************
; wait_kbd:        ; variant 1
;       mov      cx,2500h  ;çàäåðæêà ïîðÿäêà 10 ìñåê
; test_kbd:
;       in       al,64h    ;÷èòàåì ñîñòîÿíèå êëàâèàòóðû
;       test     al,2      ;ïðîâåðêà áèòà ãîòîâíîñòè
;       loopnz   test_kbd
 
    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 ---------------------
    push    0
    pop    es
    mov    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 - 0x10000
    mov    [si + 5], ah
    mov    [si + 7], al
    _setcursor 0, 3
    call    printplain
    _setcursor d80x25_top_num,0
    ; ------------------
    
    mov    ax, 0x5304            ; Disconnect interface
    xor    bx, bx
    int    0x15
    mov    ax, 0x5303            ; Connect 32 bit mode interface
    xor    bx, bx
    int    0x15
    ; init selectors
    movzx    eax, ax ; real-mode segment base address of protected-mode 32-bit code segment
    shl    eax, 4
    mov    [apm_code_32 - 0x10000 + 2], ax
    shr    eax, 16
    mov    [apm_code_32 - 0x10000 + 4], al
    movzx    ecx, cx ; real-mode segment base address of protected-mode 16-bit code segment
    shl    ecx, 4
    mov    [apm_code_16 - 0x10000 + 2], cx
    shr    ecx, 16
    mov    [apm_code_16 - 0x10000 + 4], cl
    movzx    edx, dx ; real-mode segment base address of protected-mode 16-bit data segment
    shl    edx, 4
    mov    [apm_data_16 - 0x10000 + 2], dx
    shr    edx, 16
    mov    [apm_data_16 - 0x10000 + 4], dl
    mov    [es : 0x9040], ebx              ; offset of APM entry point
apm_end:
; -----------------------------------------        
 
; DISPLAY VESA INFORMATION
 
    push    0
    pop    es
        mov     ax,0x4f00
        mov     di,0xa000
        int     0x10
        cmp     ax,0x004f
        mov    si, novesa-0x10000
        jnz    @f
        mov     ax,[es:di+4]
        add     ax,'0'*256+'0'
        mov    si,vervesa-0x10000
        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_mtrr = use hardware acceleration?
; c) preboot_vrrm = use VRR?
; d) preboot_device = from what boot?
    mov    di, preboot_graph-0x10000
; check bootloader block
    cmp    [.loader_block-0x10000], 1
    jnz    .noloaderblock
    les    bx, [.loader_block-0x10000]
    cmp    byte [es:bx], 1
    mov    si, loader_block_error-0x10000
    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-0x10000], 0
    cmp    byte [di], 0
    jnz    .preboot_gr_end
    mov    [di+preboot_gprobe-preboot_graph], 0
    mov    al, [vervesa+vervesa_off-0x10000]
    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_mtrr-preboot_graph], 1
    adc    [di+preboot_mtrr-preboot_graph], 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-0x10000
    call    print
    mov    si, start_msg-0x10000
    call    print
    mov    si, time_msg-0x10000
    call    print
; get start time
    call    .gettime
    mov    [.starttime-0x10000], eax
    mov    word [.timer-0x10000], .newtimer
    mov    word [.timer-0x10000+2], cs
.printcfg:
    _setcursor 9,0
    mov    si, current_cfg_msg-0x10000
    call    print
    mov    si, curvideo_msg-0x10000
    call    print
    mov    al, [preboot_graph-0x10000]
    cmp    al, 8
    ja    .pnovesa
    mov    dl, al
    and    eax, 3
    mov    si, [modes_msg-0x10000+eax*2]
    call    printplain
    mov    si, modevesa20-0x10000
    cmp    dl, 4
    jbe    @f
    mov    si, modevesa12-0x10000
@@:
    call    printplain
    cmp    dl, 4
    ja    .x
    mov    si, probeno_msg-0x10000
    cmp    [preboot_gprobe-0x10000], 2
    jnz    @f
    mov    si, probeok_msg-0x10000
@@:
    call    printplain
.x:
    jmp    .c
.pnovesa:
    cmp    al, 9
    mov    si, mode9-0x10000
    jz    @b
    mov    si, mode10-0x10000
    jmp    @b
.c:
    mov    si, linef-0x10000
    call    printplain
    mov    si, mtrr_msg-0x10000
    cmp    [preboot_mtrr-0x10000], 1
    call    .say_on_off
    mov    si, vrrm_msg-0x10000
    cmp    [preboot_vrrm-0x10000], 1
    call    .say_on_off
    mov    si, preboot_device_msg-0x10000
    call    print
    mov    al, [preboot_device-0x10000]
    and    eax, 3
    mov    si, [preboot_device_msgs-0x10000+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-0x10000], eax
    mov    eax, [.timer-0x10000]
    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-0x10000]
    mov    [es:8*4], eax
    mov    [.timer-0x10000], eax
    _setcursor 7,0
    mov    si, space_msg-0x10000
    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-0x10000
    call    print
    mov     bx,'13'
    call    getkey
    mov    [preboot_device-0x10000], al
    _setcursor 13,0
.d:
    mov    [.bSettingsChanged-0x10000], 1
    mov    si, space_msg-0x10000
    call    printplain
    _setcursor 15,0
    mov    cx, 6
@@:
    call    printplain
    loop    @b
    jmp    .printcfg
.change_a:
    _setcursor 15,0
    mov    si, gr_mode-0x10000
    call    printplain
    mov     bx, '09'
    call    getkey
    mov    [preboot_graph-0x10000], al
    cmp    al, 4
    ja    @f
    mov    si, probetext-0x10000
    call    printplain
    mov    bx, '12'
    call    getkey
    mov    [preboot_gprobe-0x10000], al
@@:
    _setcursor 10,0
    jmp    .d
.change_b:
    _setcursor 15,0
    mov    si, gr_acc-0x10000
    call    print
    mov    bx, '12'
    call    getkey
    mov    [preboot_mtrr-0x10000], al
    _setcursor 11,0
    jmp    .d
.change_c:
    _setcursor 15,0
    mov    si, vrrmprint-0x10000
    call    print
    mov    bx, '12'
    call    getkey
    mov    [preboot_vrrm-0x10000], al
    _setcursor 12,0
    jmp    .d
.say_on_off:
    pushf
    call    print
    mov    si, on_msg-0x10000
    popf
    jz    @f
    mov    si, off_msg-0x10000
@@:    call    printplain
    ret
; 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
	org $+0x10000
.loader_block dd 0
	org $-0x10000
.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-0x10000]
    pushad
    call    .gettime
    sub    eax, [.starttime-0x10000]
    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-0x10000], cl
else
; wait 5/4/3/2 seconds, 1 second
    cmp    al, 1
    mov    cl, 's'
    ja    @f
    mov    cl, ' '
@@:    mov    [time_str+9-0x10000], cl
end if
    add    al, '0'
    mov    [time_str+1-0x10000], al
    mov    si, time_msg-0x10000
    _setcursor 7,0
    call    print
    _setcursor 25,0
    popad
    pop    ds
    iret
.timergo:
    push    0
    pop    es
    mov    eax, [.oldtimer-0x10000]
    mov    [es:8*4], eax
    mov    sp, 0EC00h
.continue:
    sti
    _setcursor 6,0
    mov    si, space_msg-0x10000
    call    printplain
    call    printplain
    _setcursor 6,0
    mov    si, loading_msg-0x10000
    call    print
    _setcursor 15,0
    cmp    [.bSettingsChanged-0x10000], 0
    jz    .load
    cmp    [.loader_block-0x10000], 0
    jz    .load
    les    bx, [.loader_block-0x10000]
    mov    eax, [es:bx+3]
    push    ds
    pop    es
    test    eax, eax
    jz    .load
    push    eax
    mov    si, save_quest-0x10000
    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-0x10000+80], 186
    pop    eax
    push    cs
    push    .cont
    push    eax
    retf
.loadc:
    pop    eax
.cont:
    push    cs
    pop    ds
    mov    si, space_msg-0x10000
    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-0x10000]
    push    0
    pop    es
; address is gr_table+6*(ax-1)-0x10000
        add    ax, ax
        lea    si, [gr_table-0x10000 + 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
        mov    dword [es:0x9018], 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-0x10000], 1
    jz    noprobe
 
        mov     bx,0x100
     newprobe:
        inc     bx
        cmp     bx,0x17f
        mov    si,prnotfnd-0x10000
        jz    sayerr
 
     probemore:
         push    cx
        mov     ax,0x4f01
        mov     cx,bx
        and     cx,0xfff
        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
        BytesPerScanLine equ 0x10
        mov ax, [es:di+BytesPerScanLine]
        mov [es:0x9001],ax
        ; BPP
        mov     al,byte [es:di+0x19]
        mov     [es:0x9000],al
       nov:
        cmp     al,24
        mov    si,bt24-0x10000
        jz    bppl
        cmp     al,32
        mov     si,bt32-0x10000
        jz     bppl
        mov     si,btns-0x10000
        jmp    sayerr
       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
 
        mov     al, [preboot_mtrr-0x10000]
        mov     [es:0x901C],al
 
; VRR_M USE
 
        mov     al,[preboot_vrrm-0x10000]
        mov     [es:0x9030],al
 
 
; MEMORY MODEL
 
;        movzx   eax,byte [es:preboot_memory-0x10000]
;        cmp     eax,0
;        jne     pre_mem
;;;;;;;;;;;;;;;;;;;;;;;;;
; mario79 - memory size ;
;;;;;;;;;;;;;;;;;;;;;;;;;
;           mov ax,0E801h
;;;           xor bx,bx    ; thanks to Alexei for bugfix [18.07.2004]
;           xor cx, cx
;           xor dx, dx
;           int 0x15
;           movzx ebx, dx ;bx
;           movzx eax, cx ;ax
;           shl   ebx,6   ; ïåðåâîä â êèëîáàéòû (x64)
;           add   eax,ebx
;           add eax, 1000h ;440h
;           cmp eax,40000h ; 256?
;           jge mem_256_z
;           cmp eax,20000h ; 128?
;           jge mem_128_z
;           cmp eax,10000h ; 64?
;           jge mem_64_z
;           cmp eax,8000h ; 32?
;           jge mem_32_z
;           jmp mem_16_z
;
;mem_256_z: mov     si,memokz256-0x10000
;           call    printplain
;           mov eax,5
;           jmp pre_mem
;mem_128_z: mov     si,memokz128-0x10000
;           call    printplain
;           mov eax,4
;           jmp pre_mem
;mem_64_z:  mov     si,memokz64-0x10000
;           call    printplain
;           mov eax,3
;           jmp pre_mem
;mem_32_z:  mov     si,memokz32-0x10000
;           call    printplain
;           mov eax,2
;           jmp pre_mem
;mem_16_z:  mov     si,memokz16-0x10000
;           call    printplain
;           mov eax,1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;      pre_mem:
;        push    word 0x0000
;        pop     es
;        mov     [es:0x9030],al
;        push    word 0x1000
;        pop     es
;        mov     si,linef-0x10000
;        call    printplain
 
 
 
 
; DIRECT WRITE TO LFB, PAGING DISABLED
 
;        movzx   eax,byte [es:preboot_lfb-0x10000]
;        mov     eax,1                             ; paging disabled
;        cmp     eax,0
;        jne     pre_lfb
;        mov     si,gr_direct-0x10000
;        call    printplain
;        mov     ebx,'12'
;        call    getkey
;      pre_lfb:
;        push    word 0x0000
;        pop     es
;        mov     [es:0x901E],al
;        mov     ax,0x1000
;        mov     es,ax
;        mov     si,linef-0x10000
;        call    printplain
        mov     [es:0x901E],byte 1
 
 
 
; BOOT DEVICE
 
    mov    al, [preboot_device-0x10000]
        dec     al
        mov     [boot_dev-0x10000],al
 
; READ DISKETTE TO MEMORY
 
;        cmp     [boot_dev-0x10000],0
        jne     no_sys_on_floppy
        mov     si,diskload-0x10000
        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-0x10000
        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-0x10000
        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-0x10000
        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-0x10000
        call    printplain
        mov     si,okt-0x10000
        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
 
    push    es
; PAGE TABLE
 
    push    dword [es:0x9018]
 
        map_mem equ 64                ; amount of memory to map
 
        push    0x6000
        pop    es                    ; es:di = 6000:0
        xor     di,di
        mov     cx,256*map_mem         ; Map (mapmem) M
; initialize as identity mapping
    xor    eax, eax
    call    pagetable_set
 
        
; 4 KB PAGE DIRECTORY
 
    push    0x7F00
    pop    es                ; es:di = 7F00:0
        xor     di, di
        mov     cx, 64 / 4
        mov     eax, 0x60007            ; for 0 M
        call    pagetable_set
        xor     si,si
        mov     di,second_base_address shr 20
        mov     cx,64/2
        rep     movs word [es:di], [es:si]
       
        mov     eax, 0x7F000 +8+16      ; Page directory and enable caches
        mov     cr3, eax
 
; SET GRAPHICS
 
    pop    es
        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-0x10000
        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 134	Rev 140
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; BOOTCODE.INC ;;	3	;; BOOTCODE.INC ;;
4	;; ;;	4	;; ;;
5	;; KolibriOS 16-bit loader, ;;	5	;; KolibriOS 16-bit loader, ;;
6	;; based on bootcode for MenuetOS ;;	6	;; based on bootcode for MenuetOS ;;
7	;; ;;	7	;; ;;
8	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	8	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9		9
10		10
11		11
12	;==========================================================================	12	;==========================================================================
13	;	13	;
14	; 16 BIT FUNCTIONS	14	; 16 BIT FUNCTIONS
15	;	15	;
16	;==========================================================================	16	;==========================================================================
17		17
18	putchar:	18	putchar:
19	; in: al=character	19	; in: al=character
20	mov ah, 0Eh	20	mov ah, 0Eh
21	mov bh, 0	21	mov bh, 0
22	int 10h	22	int 10h
23	ret	23	ret
24		24
25	print:	25	print:
26	; in: si->string	26	; in: si->string
27	mov al, 186	27	mov al, 186
28	call putchar	28	call putchar
29	mov al, ' '	29	mov al, ' '
30	call putchar	30	call putchar
31		31
32	printplain:	32	printplain:
33	; in: si->string	33	; in: si->string
34	pusha	34	pusha
35	lodsb	35	lodsb
36	@@:	36	@@:
37	call putchar	37	call putchar
38	lodsb	38	lodsb
39	cmp al, 0	39	cmp al, 0
40	jnz @b	40	jnz @b
41	popa	41	popa
42	ret	42	ret
43		43
44	; Now int 16 is used for keyboard support.	44	; Now int 16 is used for keyboard support.
45	; This is shorter, simpler and more reliable.	45	; This is shorter, simpler and more reliable.
46	if 0	46	if 0
47	getkey: push ecx	47	getkey: push ecx
48	push edx	48	push edx
49	add ebx,0x0101	49	add ebx,0x0101
50	xor eax,eax	50	xor eax,eax
51		51
52	gk1:	52	gk1:
53	in al,0x60	53	in al,0x60
54	mov cl,al	54	mov cl,al
55	gk0:	55	gk0:
56	in al,0x60	56	in al,0x60
57	cmp al,cl	57	cmp al,cl
58	je gk0	58	je gk0
59	cmp ax,11	59	cmp ax,11
60	jg gk0	60	jg gk0
61	gk0_1:	61	gk0_1:
62	mov cl,al	62	mov cl,al
63		63
64	; add al,47	64	; add al,47
65	; mov [ds:keyinbs-0x10000],al	65	; mov [ds:keyinbs-0x10000],al
66	; mov si,keyinbs-0x10000	66	; mov si,keyinbs-0x10000
67	; call printplain	67	; call printplain
68		68
69	gk12:	69	gk12:
70	in al,0x60	70	in al,0x60
71	cmp al,cl	71	cmp al,cl
72	je gk12	72	je gk12
73	cmp ax,240	73	cmp ax,240
74	jne gk13	74	jne gk13
75	mov al,cl	75	mov al,cl
76	jmp gk14	76	jmp gk14
77	gk13:	77	gk13:
78	add cl,128	78	add cl,128
79	cmp al,cl	79	cmp al,cl
80	jne gk1	80	jne gk1
81	sub al,128	81	sub al,128
82	gk14:	82	gk14:
83		83
84	movzx edx,bl	84	movzx edx,bl
85	cmp eax,edx	85	cmp eax,edx
86	jb gk1	86	jb gk1
87	movzx edx,bh	87	movzx edx,bh
88	cmp eax,edx	88	cmp eax,edx
89	jg gk1	89	jg gk1
90	test ebx,0x010000	90	test ebx,0x010000
91	jnz gk3	91	jnz gk3
92	mov cx,0x1000	92	mov cx,0x1000
93	mov dx,cx	93	mov dx,cx
94	add eax,47	94	add eax,47
95	mov cx,ax	95	mov cx,ax
96	cmp cx,58	96	cmp cx,58
97	jb gk_nozero	97	jb gk_nozero
98	sub cx,10	98	sub cx,10
99	gk_nozero:	99	gk_nozero:
100	mov [ds:keyin-0x10000],cl	100	mov [ds:keyin-0x10000],cl
101	mov si,keyin-0x10000	101	mov si,keyin-0x10000
102	call printplain	102	call printplain
103	gk3:	103	gk3:
104	sub eax,48	104	sub eax,48
105	pop edx	105	pop edx
106	pop ecx	106	pop ecx
107	ret	107	ret
108	end if	108	end if
109		109
110	getkey:	110	getkey:
111	; get number in range [bl,bh] (bl,bh in ['0'..'9'])	111	; get number in range [bl,bh] (bl,bh in ['0'..'9'])
112	; in: bx=range	112	; in: bx=range
113	; out: ax=digit (1..9, 10 for 0)	113	; out: ax=digit (1..9, 10 for 0)
114	mov ah, 0	114	mov ah, 0
115	int 16h	115	int 16h
116	cmp al, bl	116	cmp al, bl
117	jb getkey	117	jb getkey
118	cmp al, bh	118	cmp al, bh
119	ja getkey	119	ja getkey
120	push ax	120	push ax
121	call putchar	121	call putchar
122	pop ax	122	pop ax
123	and ax, 0Fh	123	and ax, 0Fh
124	jnz @f	124	jnz @f
125	mov al, 10	125	mov al, 10
126	@@:	126	@@:
127	ret	127	ret
128		128
129	setcursor:	129	setcursor:
130	; in: dl=column, dh=row	130	; in: dl=column, dh=row
131	mov ah, 2	131	mov ah, 2
132	mov bh, 0	132	mov bh, 0
133	int 10h	133	int 10h
134	ret	134	ret
135		135
136	macro _setcursor row,column	136	macro _setcursor row,column
137	{	137	{
138	mov dx, row*256 + column	138	mov dx, row*256 + column
139	call setcursor	139	call setcursor
140	}	140	}
141		141
142	pagetable_set:	142	pagetable_set:
143	;eax - physical address	143	;eax - physical address
144	;es:di - page table	144	;es:di - page table
145	;ecx - number of pages to map	145	;ecx - number of pages to map
146	or al, 7	146	or al, 7
147	@@:	147	@@:
148	stosd	148	stosd
149	add eax, 1000h	149	add eax, 1000h
150	loop @b	150	loop @b
151	ret	151	ret
152		152
153	boot_read_floppy:	153	boot_read_floppy:
154	push si	154	push si
155	xor si, si	155	xor si, si
156	mov ah, 2 ; read	156	mov ah, 2 ; read
157	@@:	157	@@:
158	push ax	158	push ax
159	int 0x13	159	int 0x13
160	pop ax	160	pop ax
161	jnc @f	161	jnc @f
162	inc si	162	inc si
163	cmp si, 10	163	cmp si, 10
164	jb @b	164	jb @b
165	mov si, badsect-0x10000	165	mov si, badsect-0x10000
166	sayerr_plain:	166	sayerr_plain:
167	call printplain	167	call printplain
168	jmp $	168	jmp $
169	@@:	169	@@:
170	pop si	170	pop si
171	ret	171	ret
172		172
173	; 16-bit data	173	; 16-bit data
174	; videomodes table	174	; videomodes table
175	org $+0x10000	175	org $+0x10000
176	gr_table:	176	gr_table:
177	dw 0x112+0100000000000000b , 640 , 480 ; 1	177	dw 0x112+0100000000000000b , 640 , 480 ; 1
178	dw 0x115+0100000000000000b , 800 , 600 ; 2	178	dw 0x115+0100000000000000b , 800 , 600 ; 2
179	dw 0x118+0100000000000000b , 1024 , 768 ; 3	179	dw 0x118+0100000000000000b , 1024 , 768 ; 3
180	dw 0x11B+0100000000000000b , 1280 , 1024 ; 4	180	dw 0x11B+0100000000000000b , 1280 , 1024 ; 4
181	dw 0x112 , 640 , 480 ; 5	181	dw 0x112 , 640 , 480 ; 5
182	dw 0x115 , 800 , 600 ; 6	182	dw 0x115 , 800 , 600 ; 6
183	dw 0x118 , 1024 , 768 ; 7	183	dw 0x118 , 1024 , 768 ; 7
184	dw 0x11B , 1280 ,1024 ; 8	184	dw 0x11B , 1280 ,1024 ; 8
185	dw 0x13, 640, 480 ; 9	185	dw 0x13, 640, 480 ; 9
186	dw 0x12, 640, 480 ; 0	186	dw 0x12, 640, 480 ; 0
187		187
188	; table for move to extended memory (int 15h, ah=87h)	188	; table for move to extended memory (int 15h, ah=87h)
189	movedesc:	189	movedesc:
190	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	190	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
191	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	191	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
192		192
193	db 0xff,0xff,0x0,0xa0,0x00,0x93,0x0,0x0	193	db 0xff,0xff,0x0,0xa0,0x00,0x93,0x0,0x0
194	db 0xff,0xff,0x0,0x00,0x10,0x93,0x0,0x0	194	db 0xff,0xff,0x0,0x00,0x10,0x93,0x0,0x0
195		195
196	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	196	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
197	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	197	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
198	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	198	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
199	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	199	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
200	org $-0x10000	200	org $-0x10000
201		201
202	;=========================================================================	202	;=========================================================================
203	;	203	;
204	; 16 BIT CODE	204	; 16 BIT CODE
205	;	205	;
206	;=========================================================================	206	;=========================================================================
207		207
208		208
209	start_of_code:	209	start_of_code:
210	cld	210	cld
211	; \begin{diamond}[02.12.2005]	211	; \begin{diamond}[02.12.2005]
212	cmp ax, 'KL'	212	cmp ax, 'KL'
213	jnz @f	213	jnz @f
214	mov word [cs:cfgmanager.loader_block-0x10000], si	214	mov word [cs:cfgmanager.loader_block-0x10000], si
215	mov word [cs:cfgmanager.loader_block+2-0x10000], ds	215	mov word [cs:cfgmanager.loader_block+2-0x10000], ds
216	@@:	216	@@:
217	; \end{diamond}[02.12.2005]	217	; \end{diamond}[02.12.2005]
218		218
219	; set up stack	219	; set up stack
220	mov ax, 3000h	220	mov ax, 3000h
221	mov ss, ax	221	mov ss, ax
222	mov sp, 0EC00h	222	mov sp, 0EC00h
223	; set up segment registers	223	; set up segment registers
224	push cs	224	push cs
225	pop ds	225	pop ds
226	push cs	226	push cs
227	pop es	227	pop es
228		228
229	; set videomode	229	; set videomode
230	mov ax, 3	230	mov ax, 3
231	int 0x10	231	int 0x10
232		232
233	if lang eq ru	233	if lang eq ru
234	; Load & set russian VGA font (RU.INC)	234	; Load & set russian VGA font (RU.INC)
235	mov bp,RU_FNT1-10000h ; RU_FNT1 - First part	235	mov bp,RU_FNT1-10000h ; RU_FNT1 - First part
236	mov bx,1000h ; 768 bytes	236	mov bx,1000h ; 768 bytes
237	mov cx,30h ; 48 symbols	237	mov cx,30h ; 48 symbols
238	mov dx,80h ; 128 - position of first symbol	238	mov dx,80h ; 128 - position of first symbol
239	mov ax,1100h	239	mov ax,1100h
240	int 10h	240	int 10h
241		241
242	mov bp,RU_FNT2-10000h ; RU_FNT2 -Second part	242	mov bp,RU_FNT2-10000h ; RU_FNT2 -Second part
243	mov bx,1000h ; 512 bytes	243	mov bx,1000h ; 512 bytes
244	mov cx,20h ; 32 symbols	244	mov cx,20h ; 32 symbols
245	mov dx,0E0h ; 224 - position of first symbol	245	mov dx,0E0h ; 224 - position of first symbol
246	mov ax,1100h	246	mov ax,1100h
247	int 10h	247	int 10h
248	; End set VGA russian font	248	; End set VGA russian font
249	end if	249	end if
250		250
251	; draw frames	251	; draw frames
252	push 0xb800	252	push 0xb800
253	pop es	253	pop es
254	xor di, di	254	xor di, di
255	; mov si,d80x25-0x10000	255	; mov si,d80x25-0x10000
256	; mov cx,80*25	256	; mov cx,80*25
257	; mov ah,1*16+15	257	; mov ah,1*16+15
258	; dfl1:	258	; dfl1:
259	; lodsb	259	; lodsb
260	; stosw	260	; stosw
261	; loop dfl1	261	; loop dfl1
262	mov ah, 1*16+15	262	mov ah, 1*16+15
263	; draw top	263	; draw top
264	mov si, d80x25_top - 0x10000	264	mov si, d80x25_top - 0x10000
265	mov cx, d80x25_top_num * 80	265	mov cx, d80x25_top_num * 80
266	@@:	266	@@:
267	lodsb	267	lodsb
268	stosw	268	stosw
269	loop @b	269	loop @b
270	; draw spaces	270	; draw spaces
271	mov si, space_msg - 0x10000	271	mov si, space_msg - 0x10000
272	mov cx, 25 - d80x25_top_num - d80x25_bottom_num	272	mov cx, 25 - d80x25_top_num - d80x25_bottom_num
273	dfl1:	273	dfl1:
274	push cx	274	push cx
275	push si	275	push si
276	mov cx, 80	276	mov cx, 80
277	@@:	277	@@:
278	lodsb	278	lodsb
279	stosw	279	stosw
280	loop @b	280	loop @b
281	pop si	281	pop si
282	pop cx	282	pop cx
283	loop dfl1	283	loop dfl1
284	; draw bottom	284	; draw bottom
285	mov si, d80x25_bottom - 0x10000	285	mov si, d80x25_bottom - 0x10000
286	mov cx, d80x25_bottom_num * 80	286	mov cx, d80x25_bottom_num * 80
287	@@:	287	@@:
288	lodsb	288	lodsb
289	stosw	289	stosw
290	loop @b	290	loop @b
291		291
292	mov byte [space_msg-0x10000+80], 0 ; now space_msg is null terminated	292	mov byte [space_msg-0x10000+80], 0 ; now space_msg is null terminated
293		293
294	_setcursor d80x25_top_num,0	294	_setcursor d80x25_top_num,0
295		295
296		296
297	; TEST FOR 386+	297	; TEST FOR 386+
298		298
299	mov bx, 0x4000	299	mov bx, 0x4000
300	pushf	300	pushf
301	pop ax	301	pop ax
302	mov dx,ax	302	mov dx,ax
303	xor ax,bx	303	xor ax,bx
304	push ax	304	push ax
305	popf	305	popf
306	pushf	306	pushf
307	pop ax	307	pop ax
308	and ax,bx	308	and ax,bx
309	and dx,bx	309	and dx,bx
310	cmp ax,dx	310	cmp ax,dx
311	jnz cpugood	311	jnz cpugood
312	mov si,not386-0x10000	312	mov si,not386-0x10000
313	sayerr:	313	sayerr:
314	call print	314	call print
315	jmp $	315	jmp $
316	cpugood:	316	cpugood:
317		317
318	; set up esp	318	; set up esp
319	movzx esp, sp	319	movzx esp, sp
320		320
321	; FLUSH 8042 KEYBOARD CONTROLLER	321	; FLUSH 8042 KEYBOARD CONTROLLER
322		322
323	;// mike.dld [	323	;// mike.dld [
324	; mov al,0xED	324	; mov al,0xED
325	; out 0x60,al	325	; out 0x60,al
326	; or cx,-1	326	; or cx,-1
327	; @@:	327	; @@:
328	; in al,0x64	328	; in al,0x64
329	; test al,2	329	; test al,2
330	; jz @f	330	; jz @f
331	; loop @b	331	; loop @b
332	; @@:	332	; @@:
333	; mov al,0	333	; mov al,0
334	; out 0x60,al	334	; out 0x60,al
335	; or cx,-1	335	; or cx,-1
336	; @@:	336	; @@:
337	; in al,0x64	337	; in al,0x64
338	; test al,2	338	; test al,2
339	; jz @f	339	; jz @f
340	; loop @b	340	; loop @b
341	; @@:	341	; @@:
342	;// mike.dld ]	342	;// mike.dld ]
343		343
344	; mov ecx,10000	344	; mov ecx,10000
345	; fl1:	345	; fl1:
346	; in al,0x64	346	; in al,0x64
347	; loop fl1	347	; loop fl1
348	; test al,1	348	; test al,1
349	; jz fl2	349	; jz fl2
350	; in al,0x60	350	; in al,0x60
351	; jmp fl1	351	; jmp fl1
352	; fl2:	352	; fl2:
353		353
354	;****************************************************************	354	;****************************************************************
355	; The function is modified Mario79	355	; The function is modified Mario79
356	;*****************************************************************	356	;*****************************************************************
357	; wait_kbd: ; variant 1	357	; wait_kbd: ; variant 1
358	; mov cx,2500h ;çàäåðæêà ïîðÿäêà 10 ìñåê	358	; mov cx,2500h ;çàäåðæêà ïîðÿäêà 10 ìñåê
359	; test_kbd:	359	; test_kbd:
360	; in al,64h ;÷èòàåì ñîñòîÿíèå êëàâèàòóðû	360	; in al,64h ;÷èòàåì ñîñòîÿíèå êëàâèàòóðû
361	; test al,2 ;ïðîâåðêà áèòà ãîòîâíîñòè	361	; test al,2 ;ïðîâåðêà áèòà ãîòîâíîñòè
362	; loopnz test_kbd	362	; loopnz test_kbd
363		363
364	mov al,0xf6 ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå	364	mov al,0xf6 ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå
365	out 0x60,al	365	out 0x60,al
366	xor cx,cx	366	xor cx,cx
367	wait_loop: ; variant 2	367	wait_loop: ; variant 2
368	; reading state of port of 8042 controller	368	; reading state of port of 8042 controller
369	in al,64h	369	in al,64h
370	and al,00000010b ; ready flag	370	and al,00000010b ; ready flag
371	; wait until 8042 controller is ready	371	; wait until 8042 controller is ready
372	loopnz wait_loop	372	loopnz wait_loop
373		373
374	; --------------- APM ---------------------	374	; --------------- APM ---------------------
375	push 0	375	push 0
376	pop es	376	pop es
377	mov word [es : 0x9044], 0 ; ver = 0.0 (APM not found)	377	mov word [es : 0x9044], 0 ; ver = 0.0 (APM not found)
378	mov ax, 0x5300	378	mov ax, 0x5300
379	xor bx, bx	379	xor bx, bx
380	int 0x15	380	int 0x15
381	jc apm_end ; APM not found	381	jc apm_end ; APM not found
382	test cx, 2	382	test cx, 2
383	jz apm_end ; APM 32-bit protected-mode interface not supported	383	jz apm_end ; APM 32-bit protected-mode interface not supported
384	mov [es : 0x9044], ax ; Save APM Version	384	mov [es : 0x9044], ax ; Save APM Version
385	mov [es : 0x9046], cx ; Save APM flags	385	mov [es : 0x9046], cx ; Save APM flags
386		386
387	; Write APM ver ----	387	; Write APM ver ----
388	and ax, 0xf0f	388	and ax, 0xf0f
389	add ax, '00'	389	add ax, '00'
390	mov si, msg_apm - 0x10000	390	mov si, msg_apm - 0x10000
391	mov [si + 5], ah	391	mov [si + 5], ah
392	mov [si + 7], al	392	mov [si + 7], al
393	_setcursor 0, 3	393	_setcursor 0, 3
394	call printplain	394	call printplain
395	_setcursor d80x25_top_num,0	395	_setcursor d80x25_top_num,0
396	; ------------------	396	; ------------------
397		397
398	mov ax, 0x5304 ; Disconnect interface	398	mov ax, 0x5304 ; Disconnect interface
399	xor bx, bx	399	xor bx, bx
400	int 0x15	400	int 0x15
401	mov ax, 0x5303 ; Connect 32 bit mode interface	401	mov ax, 0x5303 ; Connect 32 bit mode interface
402	xor bx, bx	402	xor bx, bx
403	int 0x15	403	int 0x15
404	; init selectors	404	; init selectors
405	movzx eax, ax ; real-mode segment base address of protected-mode 32-bit code segment	405	movzx eax, ax ; real-mode segment base address of protected-mode 32-bit code segment
406	shl eax, 4	406	shl eax, 4
407	mov [apm_code_32 - 0x10000 + 2], ax	407	mov [apm_code_32 - 0x10000 + 2], ax
408	shr eax, 16	408	shr eax, 16
409	mov [apm_code_32 - 0x10000 + 4], al	409	mov [apm_code_32 - 0x10000 + 4], al
410	movzx ecx, cx ; real-mode segment base address of protected-mode 16-bit code segment	410	movzx ecx, cx ; real-mode segment base address of protected-mode 16-bit code segment
411	shl ecx, 4	411	shl ecx, 4
412	mov [apm_code_16 - 0x10000 + 2], cx	412	mov [apm_code_16 - 0x10000 + 2], cx
413	shr ecx, 16	413	shr ecx, 16
414	mov [apm_code_16 - 0x10000 + 4], cl	414	mov [apm_code_16 - 0x10000 + 4], cl
415	movzx edx, dx ; real-mode segment base address of protected-mode 16-bit data segment	415	movzx edx, dx ; real-mode segment base address of protected-mode 16-bit data segment
416	shl edx, 4	416	shl edx, 4
417	mov [apm_data_16 - 0x10000 + 2], dx	417	mov [apm_data_16 - 0x10000 + 2], dx
418	shr edx, 16	418	shr edx, 16
419	mov [apm_data_16 - 0x10000 + 4], dl	419	mov [apm_data_16 - 0x10000 + 4], dl
420	mov [es : 0x9040], ebx ; offset of APM entry point	420	mov [es : 0x9040], ebx ; offset of APM entry point
421	apm_end:	421	apm_end:
422	; -----------------------------------------	422	; -----------------------------------------
423		423
424	; DISPLAY VESA INFORMATION	424	; DISPLAY VESA INFORMATION
425		425
426	push 0	426	push 0
427	pop es	427	pop es
428	mov ax,0x4f00	428	mov ax,0x4f00
429	mov di,0xa000	429	mov di,0xa000
430	int 0x10	430	int 0x10
431	cmp ax,0x004f	431	cmp ax,0x004f
432	mov si, novesa-0x10000	432	mov si, novesa-0x10000
433	jnz @f	433	jnz @f
434	mov ax,[es:di+4]	434	mov ax,[es:di+4]
435	add ax,'0'*256+'0'	435	add ax,'0'*256+'0'
436	mov si,vervesa-0x10000	436	mov si,vervesa-0x10000
437	mov [si+vervesa_off], ah	437	mov [si+vervesa_off], ah
438	mov [si+vervesa_off+2], al	438	mov [si+vervesa_off+2], al
439	@@: call print	439	@@: call print
440		440
441	; \begin{diamond}[30.11.2005]	441	; \begin{diamond}[30.11.2005]
442	cfgmanager:	442	cfgmanager:
443	; settings:	443	; settings:
444	; a) preboot_graph = graphical mode	444	; a) preboot_graph = graphical mode
445	; preboot_gprobe = probe this mode?	445	; preboot_gprobe = probe this mode?
446	; b) preboot_mtrr = use hardware acceleration?	446	; b) preboot_mtrr = use hardware acceleration?
447	; c) preboot_vrrm = use VRR?	447	; c) preboot_vrrm = use VRR?
448	; d) preboot_device = from what boot?	448	; d) preboot_device = from what boot?
449	mov di, preboot_graph-0x10000	449	mov di, preboot_graph-0x10000
450	; check bootloader block	450	; check bootloader block
451	cmp [.loader_block-0x10000], 0	451	cmp [.loader_block-0x10000], 1
452	jz .noloaderblock	452	jnz .noloaderblock
453	les bx, [.loader_block-0x10000]	453	les bx, [.loader_block-0x10000]
454	cmp byte [es:bx], 1	454	cmp byte [es:bx], 1
455	mov si, loader_block_error-0x10000	455	mov si, loader_block_error-0x10000
456	jnz sayerr	456	jnz sayerr
457	test byte [es:bx+1], 1	457	test byte [es:bx+1], 1
458	jz @f	458	jz @f
459	; image in memory present	459	; image in memory present
460	cmp [di+preboot_device-preboot_graph], 0	460	cmp [di+preboot_device-preboot_graph], 0
461	jnz @f	461	jnz @f
462	mov [di+preboot_device-preboot_graph], 3	462	mov [di+preboot_device-preboot_graph], 3
463	@@:	463	@@:
464	.noloaderblock:	464	.noloaderblock:
465	; determine default settings	465	; determine default settings
466	mov [.bSettingsChanged-0x10000], 0	466	mov [.bSettingsChanged-0x10000], 0
467	cmp byte [di], 0	467	cmp byte [di], 0
468	jnz .preboot_gr_end	468	jnz .preboot_gr_end
469	mov [di+preboot_gprobe-preboot_graph], 0	469	mov [di+preboot_gprobe-preboot_graph], 0
470	mov al, [vervesa+vervesa_off-0x10000]	470	mov al, [vervesa+vervesa_off-0x10000]
471	cmp al, 'x'	471	cmp al, 'x'
472	jz .novesa	472	jz .novesa
473	cmp al, '1'	473	cmp al, '1'
474	jz .vesa12	474	jz .vesa12
475	mov [di+preboot_gprobe-preboot_graph], 2	475	mov [di+preboot_gprobe-preboot_graph], 2
476	mov al, 3	476	mov al, 3
477	jmp @f	477	jmp @f
478	.vesa12:	478	.vesa12:
479	mov al, 7	479	mov al, 7
480	jmp @f	480	jmp @f
481	.novesa:	481	.novesa:
482	mov al, 10	482	mov al, 10
483	@@:	483	@@:
484	mov [di], al	484	mov [di], al
485	.preboot_gr_end:	485	.preboot_gr_end:
486	cmp [di+preboot_mtrr-preboot_graph], 1	486	cmp [di+preboot_mtrr-preboot_graph], 1
487	adc [di+preboot_mtrr-preboot_graph], 0	487	adc [di+preboot_mtrr-preboot_graph], 0
488	cmp [di+preboot_vrrm-preboot_graph], 1	488	cmp [di+preboot_vrrm-preboot_graph], 1
489	adc [di+preboot_vrrm-preboot_graph], 0	489	adc [di+preboot_vrrm-preboot_graph], 0
490	cmp [di+preboot_device-preboot_graph], 1	490	cmp [di+preboot_device-preboot_graph], 1
491	adc [di+preboot_device-preboot_graph], 0	491	adc [di+preboot_device-preboot_graph], 0
492	; notify user	492	; notify user
493	mov si, linef-0x10000	493	mov si, linef-0x10000
494	call print	494	call print
495	mov si, start_msg-0x10000	495	mov si, start_msg-0x10000
496	call print	496	call print
497	mov si, time_msg-0x10000	497	mov si, time_msg-0x10000
498	call print	498	call print
499	; get start time	499	; get start time
500	call .gettime	500	call .gettime

Subversion Repositories Kolibri OS

(root)/kernel/trunk/boot/bootcode.inc @ 134 – Rev 134 → 140