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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                        ;;
;;  BOOTCODE.INC                                          ;;
;;                                                        ;;
;;  KolibriOS 16-bit loader,                              ;;
;;                        based on bootcode for MenuetOS  ;;
;;                                                        ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 
;==========================================================================
;
;                           16 BIT FUNCTIONS
;
;==========================================================================
 
; 16-bit data
		org $+0x10000
 
old_ints_h:
        dw      0x400
        dd      0
        dw      0
 
kernel_restart_bootblock:
    db    1    ; version
    dw    1    ; floppy image is in memory
    dd    0    ; cannot save parameters
 
 
align 32
 
; GDT TABLE
 
gdts:
 
        dw     gdte-$-1
        dd     gdts
        dw     0
 
int_code_l:
os_code_l:
 
        dw     0xffff
        dw     0x0000
        db     0x00
        dw     11011111b *256 +10011010b
        db     0x00
 
int_data_l:
os_data_l:
 
        dw     0xffff
        dw     0x0000
        db     0x00
        dw     11011111b *256 +10010010b
        db     0x00
 
; --------------- APM ---------------------
apm_code_32:
        dw     0x10        ; limit 64kb
        db     0, 0, 0
        dw     11011111b *256 +10011010b
        db     0x00
apm_code_16:
        dw     0x10
        db     0, 0, 0
        dw     10011111b *256 +10011010b
        db     0x00
apm_data_16:
        dw     0x10
        db     0, 0, 0
        dw     10011111b *256 +10010010b
        db     0x00
; -----------------------------------------
 
app_code_l:
      dw 0xFFFF;((0x80000000-std_application_base_address) shr 12) and 0xffff
      dw 0
      db 0x40
      db cpl3
      dw G32+D32+0x6000+0x7;
 
app_data_l:
      dw 0xFFFF;(0x80000000-std_application_base_address) shr 12 and 0xffff
      dw 0
      db 0x40
      db drw3
      dw G32+D32+0x6000+0x7;
 
graph_data_l:
 
        dw     0x3ff
        dw     0x0000
        db     0x00
        dw     11010000b *256 +11110010b
        db     0x00
 
tss0_l:
;      times (max_processes+10) dd 0,0
gdte = $ + (max_processes+10)*8
 
; videomodes table
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
 
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 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
 
        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
        mov     si, 0   ; 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
        mov     si, 0   ; device index = 0
        int     0x1A
        jnc     .found
; c) class 1, subclass 1, programming interface 0x85
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x85
        mov     si, 0
        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 ---------------------
    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 bx, word [es:di+0x12]
        shl ebx,16
        mov [es:0x9050], ebx
        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
    jz    .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 -1
	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], -1
    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], 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-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]
;
;        mmap_mem equ 64                ; amount of memory to map
;
        push    0x6000
        pop    es                    ; es:di = 6000:0
;        xor     di,di
;        mov     cx,256*mmap_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
 
        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-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 183	Rev 187
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	; 16-bit data	18	; 16-bit data
19	org $+0x10000	19	org $+0x10000
20		20
21	old_ints_h:	21	old_ints_h:
22	dw 0x400	22	dw 0x400
23	dd 0	23	dd 0
24	dw 0	24	dw 0
25		25
26	kernel_restart_bootblock:	26	kernel_restart_bootblock:
27	db 1 ; version	27	db 1 ; version
28	dw 1 ; floppy image is in memory	28	dw 1 ; floppy image is in memory
29	dd 0 ; cannot save parameters	29	dd 0 ; cannot save parameters
30		30
31		31
32	align 32	32	align 32
33		33
34	; GDT TABLE	34	; GDT TABLE
35		35
36	gdts:	36	gdts:
37		37
38	dw gdte-$-1	38	dw gdte-$-1
39	dd gdts	39	dd gdts
40	dw 0	40	dw 0
41		41
42	int_code_l:	42	int_code_l:
43	os_code_l:	43	os_code_l:
44		44
45	dw 0xffff	45	dw 0xffff
46	dw 0x0000	46	dw 0x0000
47	db 0x00	47	db 0x00
48	dw 11011111b *256 +10011010b	48	dw 11011111b *256 +10011010b
49	db 0x00	49	db 0x00
50		50
51	int_data_l:	51	int_data_l:
52	os_data_l:	52	os_data_l:
53		53
54	dw 0xffff	54	dw 0xffff
55	dw 0x0000	55	dw 0x0000
56	db 0x00	56	db 0x00
57	dw 11011111b *256 +10010010b	57	dw 11011111b *256 +10010010b
58	db 0x00	58	db 0x00
59		59
60	; --------------- APM ---------------------	60	; --------------- APM ---------------------
61	apm_code_32:	61	apm_code_32:
62	dw 0x10 ; limit 64kb	62	dw 0x10 ; limit 64kb
63	db 0, 0, 0	63	db 0, 0, 0
64	dw 11011111b *256 +10011010b	64	dw 11011111b *256 +10011010b
65	db 0x00	65	db 0x00
66	apm_code_16:	66	apm_code_16:
67	dw 0x10	67	dw 0x10
68	db 0, 0, 0	68	db 0, 0, 0
69	dw 10011111b *256 +10011010b	69	dw 10011111b *256 +10011010b
70	db 0x00	70	db 0x00
71	apm_data_16:	71	apm_data_16:
72	dw 0x10	72	dw 0x10
73	db 0, 0, 0	73	db 0, 0, 0
74	dw 10011111b *256 +10010010b	74	dw 10011111b *256 +10010010b
75	db 0x00	75	db 0x00
76	; -----------------------------------------	76	; -----------------------------------------
77		77
78	app_code_l:	78	app_code_l:
79	dw 0xFFFF;((0x80000000-std_application_base_address) shr 12) and 0xffff	79	dw 0xFFFF;((0x80000000-std_application_base_address) shr 12) and 0xffff
80	dw 0	80	dw 0
81	db 0x40	81	db 0x40
82	db cpl3	82	db cpl3
83	dw G32+D32+0x6000+0x7;	83	dw G32+D32+0x6000+0x7;
84		84
85	app_data_l:	85	app_data_l:
86	dw 0xFFFF;(0x80000000-std_application_base_address) shr 12 and 0xffff	86	dw 0xFFFF;(0x80000000-std_application_base_address) shr 12 and 0xffff
87	dw 0	87	dw 0
88	db 0x40	88	db 0x40
89	db drw3	89	db drw3
90	dw G32+D32+0x6000+0x7;	90	dw G32+D32+0x6000+0x7;
91		91
92	graph_data_l:	92	graph_data_l:
93		93
94	dw 0x3ff	94	dw 0x3ff
95	dw 0x0000	95	dw 0x0000
96	db 0x00	96	db 0x00
97	dw 11010000b *256 +11110010b	97	dw 11010000b *256 +11110010b
98	db 0x00	98	db 0x00
99		99
100	tss0_l:	100	tss0_l:
101	; times (max_processes+10) dd 0,0	101	; times (max_processes+10) dd 0,0
102	gdte = $ + (max_processes+10)*8	102	gdte = $ + (max_processes+10)*8
103		103
104	; videomodes table	104	; videomodes table
105	gr_table:	105	gr_table:
106	dw 0x112+0100000000000000b , 640 , 480 ; 1	106	dw 0x112+0100000000000000b , 640 , 480 ; 1
107	dw 0x115+0100000000000000b , 800 , 600 ; 2	107	dw 0x115+0100000000000000b , 800 , 600 ; 2
108	dw 0x118+0100000000000000b , 1024 , 768 ; 3	108	dw 0x118+0100000000000000b , 1024 , 768 ; 3
109	dw 0x11B+0100000000000000b , 1280 , 1024 ; 4	109	dw 0x11B+0100000000000000b , 1280 , 1024 ; 4
110	dw 0x112 , 640 , 480 ; 5	110	dw 0x112 , 640 , 480 ; 5
111	dw 0x115 , 800 , 600 ; 6	111	dw 0x115 , 800 , 600 ; 6
112	dw 0x118 , 1024 , 768 ; 7	112	dw 0x118 , 1024 , 768 ; 7
113	dw 0x11B , 1280 ,1024 ; 8	113	dw 0x11B , 1280 ,1024 ; 8
114	dw 0x13, 640, 480 ; 9	114	dw 0x13, 640, 480 ; 9
115	dw 0x12, 640, 480 ; 0	115	dw 0x12, 640, 480 ; 0
116		116
117	; table for move to extended memory (int 15h, ah=87h)	117	; table for move to extended memory (int 15h, ah=87h)
118	movedesc:	118	movedesc:
119	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	119	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
120	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	120	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
121		121
122	db 0xff,0xff,0x0,0xa0,0x00,0x93,0x0,0x0	122	db 0xff,0xff,0x0,0xa0,0x00,0x93,0x0,0x0
123	db 0xff,0xff,0x0,0x00,0x10,0x93,0x0,0x0	123	db 0xff,0xff,0x0,0x00,0x10,0x93,0x0,0x0
124		124
125	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	125	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
126	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	126	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
127	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	127	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
128	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0	128	db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0
129	org $-0x10000	129	org $-0x10000
130		130
131	putchar:	131	putchar:
132	; in: al=character	132	; in: al=character
133	mov ah, 0Eh	133	mov ah, 0Eh
134	mov bh, 0	134	mov bh, 0
135	int 10h	135	int 10h
136	ret	136	ret
137		137
138	print:	138	print:
139	; in: si->string	139	; in: si->string
140	mov al, 186	140	mov al, 186
141	call putchar	141	call putchar
142	mov al, ' '	142	mov al, ' '
143	call putchar	143	call putchar
144		144
145	printplain:	145	printplain:
146	; in: si->string	146	; in: si->string
147	pusha	147	pusha
148	lodsb	148	lodsb
149	@@:	149	@@:
150	call putchar	150	call putchar
151	lodsb	151	lodsb
152	cmp al, 0	152	cmp al, 0
153	jnz @b	153	jnz @b
154	popa	154	popa
155	ret	155	ret
156		156
157	; Now int 16 is used for keyboard support.	157	; Now int 16 is used for keyboard support.
158	; This is shorter, simpler and more reliable.	158	; This is shorter, simpler and more reliable.
159	if 0	159	if 0
160	getkey: push ecx	160	getkey: push ecx
161	push edx	161	push edx
162	add ebx,0x0101	162	add ebx,0x0101
163	xor eax,eax	163	xor eax,eax
164		164
165	gk1:	165	gk1:
166	in al,0x60	166	in al,0x60
167	mov cl,al	167	mov cl,al
168	gk0:	168	gk0:
169	in al,0x60	169	in al,0x60
170	cmp al,cl	170	cmp al,cl
171	je gk0	171	je gk0
172	cmp ax,11	172	cmp ax,11
173	jg gk0	173	jg gk0
174	gk0_1:	174	gk0_1:
175	mov cl,al	175	mov cl,al
176		176
177	; add al,47	177	; add al,47
178	; mov [ds:keyinbs-0x10000],al	178	; mov [ds:keyinbs-0x10000],al
179	; mov si,keyinbs-0x10000	179	; mov si,keyinbs-0x10000
180	; call printplain	180	; call printplain
181		181
182	gk12:	182	gk12:
183	in al,0x60	183	in al,0x60
184	cmp al,cl	184	cmp al,cl
185	je gk12	185	je gk12
186	cmp ax,240	186	cmp ax,240
187	jne gk13	187	jne gk13
188	mov al,cl	188	mov al,cl
189	jmp gk14	189	jmp gk14
190	gk13:	190	gk13:
191	add cl,128	191	add cl,128
192	cmp al,cl	192	cmp al,cl
193	jne gk1	193	jne gk1
194	sub al,128	194	sub al,128
195	gk14:	195	gk14:
196		196
197	movzx edx,bl	197	movzx edx,bl
198	cmp eax,edx	198	cmp eax,edx
199	jb gk1	199	jb gk1
200	movzx edx,bh	200	movzx edx,bh
201	cmp eax,edx	201	cmp eax,edx
202	jg gk1	202	jg gk1
203	test ebx,0x010000	203	test ebx,0x010000
204	jnz gk3	204	jnz gk3
205	mov cx,0x1000	205	mov cx,0x1000
206	mov dx,cx	206	mov dx,cx
207	add eax,47	207	add eax,47
208	mov cx,ax	208	mov cx,ax
209	cmp cx,58	209	cmp cx,58
210	jb gk_nozero	210	jb gk_nozero
211	sub cx,10	211	sub cx,10
212	gk_nozero:	212	gk_nozero:
213	mov [ds:keyin-0x10000],cl	213	mov [ds:keyin-0x10000],cl
214	mov si,keyin-0x10000	214	mov si,keyin-0x10000
215	call printplain	215	call printplain
216	gk3:	216	gk3:
217	sub eax,48	217	sub eax,48
218	pop edx	218	pop edx
219	pop ecx	219	pop ecx
220	ret	220	ret
221	end if	221	end if
222		222
223	getkey:	223	getkey:
224	; get number in range [bl,bh] (bl,bh in ['0'..'9'])	224	; get number in range [bl,bh] (bl,bh in ['0'..'9'])
225	; in: bx=range	225	; in: bx=range
226	; out: ax=digit (1..9, 10 for 0)	226	; out: ax=digit (1..9, 10 for 0)
227	mov ah, 0	227	mov ah, 0
228	int 16h	228	int 16h
229	cmp al, bl	229	cmp al, bl
230	jb getkey	230	jb getkey
231	cmp al, bh	231	cmp al, bh
232	ja getkey	232	ja getkey
233	push ax	233	push ax
234	call putchar	234	call putchar
235	pop ax	235	pop ax
236	and ax, 0Fh	236	and ax, 0Fh
237	jnz @f	237	jnz @f
238	mov al, 10	238	mov al, 10
239	@@:	239	@@:
240	ret	240	ret
241		241
242	setcursor:	242	setcursor:
243	; in: dl=column, dh=row	243	; in: dl=column, dh=row
244	mov ah, 2	244	mov ah, 2
245	mov bh, 0	245	mov bh, 0
246	int 10h	246	int 10h
247	ret	247	ret
248		248
249	macro _setcursor row,column	249	macro _setcursor row,column
250	{	250	{
251	mov dx, row*256 + column	251	mov dx, row*256 + column
252	call setcursor	252	call setcursor
253	}	253	}
254		254
255	;pagetable_set:	255	;pagetable_set:
256	;eax - physical address	256	;eax - physical address
257	;es:di - page table	257	;es:di - page table
258	;ecx - number of pages to map	258	;ecx - number of pages to map
259	; or al, 7	259	; or al, 7
260	;@@:	260	;@@:
261	; stosd	261	; stosd
262	; add eax, 1000h	262	; add eax, 1000h
263	; loop @b	263	; loop @b
264	; ret	264	; ret
265		265
266	boot_read_floppy:	266	boot_read_floppy:
267	push si	267	push si
268	xor si, si	268	xor si, si
269	mov ah, 2 ; read	269	mov ah, 2 ; read
270	@@:	270	@@:
271	push ax	271	push ax
272	int 0x13	272	int 0x13
273	pop ax	273	pop ax
274	jnc @f	274	jnc @f
275	inc si	275	inc si
276	cmp si, 10	276	cmp si, 10
277	jb @b	277	jb @b
278	mov si, badsect-0x10000	278	mov si, badsect-0x10000
279	sayerr_plain:	279	sayerr_plain:
280	call printplain	280	call printplain
281	jmp $	281	jmp $
282	@@:	282	@@:
283	pop si	283	pop si
284	ret	284	ret
285		285
286	;=========================================================================	286	;=========================================================================
287	;	287	;
288	; 16 BIT CODE	288	; 16 BIT CODE
289	;	289	;
290	;=========================================================================	290	;=========================================================================
291		291
292		292
293	start_of_code:	293	start_of_code:
294	cld	294	cld
295	; \begin{diamond}[02.12.2005]	295	; \begin{diamond}[02.12.2005]
296	cmp ax, 'KL'	296	cmp ax, 'KL'
297	jnz @f	297	jnz @f
298	mov word [cs:cfgmanager.loader_block-0x10000], si	298	mov word [cs:cfgmanager.loader_block-0x10000], si
299	mov word [cs:cfgmanager.loader_block+2-0x10000], ds	299	mov word [cs:cfgmanager.loader_block+2-0x10000], ds
300	@@:	300	@@:
301	; \end{diamond}[02.12.2005]	301	; \end{diamond}[02.12.2005]
302		302
303	; set up stack	303	; set up stack
304	mov ax, 3000h	304	mov ax, 3000h
305	mov ss, ax	305	mov ss, ax
306	mov sp, 0EC00h	306	mov sp, 0EC00h
307	; set up segment registers	307	; set up segment registers
308	push cs	308	push cs
309	pop ds	309	pop ds
310	push cs	310	push cs
311	pop es	311	pop es
312		312
313	; set videomode	313	; set videomode
314	mov ax, 3	314	mov ax, 3
315	int 0x10	315	int 0x10
316		316
317	if lang eq ru	317	if lang eq ru
318	; Load & set russian VGA font (RU.INC)	318	; Load & set russian VGA font (RU.INC)
319	mov bp,RU_FNT1-10000h ; RU_FNT1 - First part	319	mov bp,RU_FNT1-10000h ; RU_FNT1 - First part
320	mov bx,1000h ; 768 bytes	320	mov bx,1000h ; 768 bytes
321	mov cx,30h ; 48 symbols	321	mov cx,30h ; 48 symbols
322	mov dx,80h ; 128 - position of first symbol	322	mov dx,80h ; 128 - position of first symbol
323	mov ax,1100h	323	mov ax,1100h
324	int 10h	324	int 10h
325		325
326	mov bp,RU_FNT2-10000h ; RU_FNT2 -Second part	326	mov bp,RU_FNT2-10000h ; RU_FNT2 -Second part
327	mov bx,1000h ; 512 bytes	327	mov bx,1000h ; 512 bytes
328	mov cx,20h ; 32 symbols	328	mov cx,20h ; 32 symbols
329	mov dx,0E0h ; 224 - position of first symbol	329	mov dx,0E0h ; 224 - position of first symbol
330	mov ax,1100h	330	mov ax,1100h
331	int 10h	331	int 10h
332	; End set VGA russian font	332	; End set VGA russian font
333	end if	333	end if
334		334
335	; draw frames	335	; draw frames
336	push 0xb800	336	push 0xb800
337	pop es	337	pop es
338	xor di, di	338	xor di, di
339	; mov si,d80x25-0x10000	339	; mov si,d80x25-0x10000
340	; mov cx,80*25	340	; mov cx,80*25
341	; mov ah,1*16+15	341	; mov ah,1*16+15
342	; dfl1:	342	; dfl1:
343	; lodsb	343	; lodsb
344	; stosw	344	; stosw
345	; loop dfl1	345	; loop dfl1
346	mov ah, 1*16+15	346	mov ah, 1*16+15
347	; draw top	347	; draw top
348	mov si, d80x25_top - 0x10000	348	mov si, d80x25_top - 0x10000
349	mov cx, d80x25_top_num * 80	349	mov cx, d80x25_top_num * 80
350	@@:	350	@@:
351	lodsb	351	lodsb
352	stosw	352	stosw
353	loop @b	353	loop @b
354	; draw spaces	354	; draw spaces
355	mov si, space_msg - 0x10000	355	mov si, space_msg - 0x10000
356	mov cx, 25 - d80x25_top_num - d80x25_bottom_num	356	mov cx, 25 - d80x25_top_num - d80x25_bottom_num
357	dfl1:	357	dfl1:
358	push cx	358	push cx
359	push si	359	push si
360	mov cx, 80	360	mov cx, 80
361	@@:	361	@@:
362	lodsb	362	lodsb
363	stosw	363	stosw
364	loop @b	364	loop @b
365	pop si	365	pop si
366	pop cx	366	pop cx
367	loop dfl1	367	loop dfl1
368	; draw bottom	368	; draw bottom
369	mov si, d80x25_bottom - 0x10000	369	mov si, d80x25_bottom - 0x10000
370	mov cx, d80x25_bottom_num * 80	370	mov cx, d80x25_bottom_num * 80
371	@@:	371	@@:
372	lodsb	372	lodsb
373	stosw	373	stosw
374	loop @b	374	loop @b
375		375
376	mov byte [space_msg-0x10000+80], 0 ; now space_msg is null terminated	376	mov byte [space_msg-0x10000+80], 0 ; now space_msg is null terminated
377		377
378	_setcursor d80x25_top_num,0	378	_setcursor d80x25_top_num,0
379		379
380		380
381	; TEST FOR 386+	381	; TEST FOR 386+
382		382
383	mov bx, 0x4000	383	mov bx, 0x4000
384	pushf	384	pushf
385	pop ax	385	pop ax
386	mov dx,ax	386	mov dx,ax
387	xor ax,bx	387	xor ax,bx
388	push ax	388	push ax
389	popf	389	popf
390	pushf	390	pushf
391	pop ax	391	pop ax
392	and ax,bx	392	and ax,bx
393	and dx,bx	393	and dx,bx
394	cmp ax,dx	394	cmp ax,dx
395	jnz cpugood	395	jnz cpugood
396	mov si,not386-0x10000	396	mov si,not386-0x10000
397	sayerr:	397	sayerr:
398	call print	398	call print
399	jmp $	399	jmp $
400	cpugood:	400	cpugood:
401		401
402	; set up esp	402	; set up esp
403	movzx esp, sp	403	movzx esp, sp
404		404
405	; FLUSH 8042 KEYBOARD CONTROLLER	405	; FLUSH 8042 KEYBOARD CONTROLLER
406		406
407	;// mike.dld [	407	;// mike.dld [
408	; mov al,0xED	408	; mov al,0xED
409	; out 0x60,al	409	; out 0x60,al
410	; or cx,-1	410	; or cx,-1
411	; @@:	411	; @@:
412	; in al,0x64	412	; in al,0x64
413	; test al,2	413	; test al,2
414	; jz @f	414	; jz @f
415	; loop @b	415	; loop @b
416	; @@:	416	; @@:
417	; mov al,0	417	; mov al,0
418	; out 0x60,al	418	; out 0x60,al
419	; or cx,-1	419	; or cx,-1
420	; @@:	420	; @@:
421	; in al,0x64	421	; in al,0x64
422	; test al,2	422	; test al,2
423	; jz @f	423	; jz @f
424	; loop @b	424	; loop @b
425	; @@:	425	; @@:
426	;// mike.dld ]	426	;// mike.dld ]
427		427
428	; mov ecx,10000	428	; mov ecx,10000
429	; fl1:	429	; fl1:
430	; in al,0x64	430	; in al,0x64
431	; loop fl1	431	; loop fl1
432	; test al,1	432	; test al,1
433	; jz fl2	433	; jz fl2
434	; in al,0x60	434	; in al,0x60
435	; jmp fl1	435	; jmp fl1
436	; fl2:	436	; fl2:
437		437
438	;****************************************************************	438	;****************************************************************
439	; The function is modified Mario79	439	; The function is modified Mario79
440	;*****************************************************************	440	;*****************************************************************
441	; wait_kbd: ; variant 1	441	; wait_kbd: ; variant 1
442	; mov cx,2500h ;çàäåðæêà ïîðÿäêà 10 ìñåê	442	; mov cx,2500h ;çàäåðæêà ïîðÿäêà 10 ìñåê
443	; test_kbd:	443	; test_kbd:
444	; in al,64h ;÷èòàåì ñîñòîÿíèå êëàâèàòóðû	444	; in al,64h ;÷èòàåì ñîñòîÿíèå êëàâèàòóðû
445	; test al,2 ;ïðîâåðêà áèòà ãîòîâíîñòè	445	; test al,2 ;ïðîâåðêà áèòà ãîòîâíîñòè
446	; loopnz test_kbd	446	; loopnz test_kbd
447		447
448	push 0	448	push 0
449	pop es	449	pop es
450	and word [es:0x9031], 0	450	and word [es:0x9031], 0
451	; \begin{Mario79}	451	; \begin{Mario79}
452	; find HDD IDE DMA PCI device	452	; find HDD IDE DMA PCI device
453	; check for PCI BIOS	453	; check for PCI BIOS
454	mov ax, 0xB101	454	mov ax, 0xB101
455	int 0x1A	455	int 0x1A
456	jc .nopci	456	jc .nopci
457	cmp edx, 'PCI '	457	cmp edx, 'PCI '
458	jnz .nopci	458	jnz .nopci
459	; find PCI class code	459	; find PCI class code
460	; class 1 = mass storage	460	; class 1 = mass storage
461	; subclass 1 = IDE controller	461	; subclass 1 = IDE controller
462	; a) class 1, subclass 1, programming interface 0x80	462	; a) class 1, subclass 1, programming interface 0x80
463	mov ax, 0xB103	463	mov ax, 0xB103
464	mov ecx, 110000h + 1100h + 0x80	464	mov ecx, 110000h + 1100h + 0x80
465	mov si, 0 ; device index = 0	465	mov si, 0 ; device index = 0
466	int 0x1A	466	int 0x1A
467	jnc .found	467	jnc .found
468	; b) class 1, subclass 1, programming interface 0x85	468	; b) class 1, subclass 1, programming interface 0x8A
469	mov ax, 0xB103	469	mov ax, 0xB103
470	mov ecx, 110000h + 1100h + 0x85	470	mov ecx, 110000h + 1100h + 0x8A
471	mov si, 0 ; device index = 0	471	mov si, 0 ; device index = 0
472	int 0x1A	472	int 0x1A
473	jnc .found	473	jnc .found
474	; c) class 1, subclass 1, programming interface 0x8A	474	; c) class 1, subclass 1, programming interface 0x85
475	mov ax, 0xB103	475	mov ax, 0xB103
476	mov ecx, 110000h + 1100h + 0x8A	476	mov ecx, 110000h + 1100h + 0x85
477	mov si, 0	477	mov si, 0
478	int 0x1A	478	int 0x1A
479	jc .nopci	479	jc .nopci
480	.found:	480	.found:
481	; get memory base	481	; get memory base
482	mov ax, 0xB10A	482	mov ax, 0xB10A
483	mov di, 0x20 ; memory base is config register at 0x20	483	mov di, 0x20 ; memory base is config register at 0x20
484	int 0x1A	484	int 0x1A
485	jc .nopci	485	jc .nopci
486	and cx, 0xFFF0 ; clear address decode type	486	and cx, 0xFFF0 ; clear address decode type
487	mov [es:0x9031], cx	487	mov [es:0x9031], cx
488	.nopci:	488	.nopci:
489	; \end{Mario79}	489	; \end{Mario79}
490		490
491	mov al,0xf6 ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå	491	mov al,0xf6 ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå
492	out 0x60,al	492	out 0x60,al
493	xor cx,cx	493	xor cx,cx
494	wait_loop: ; variant 2	494	wait_loop: ; variant 2
495	; reading state of port of 8042 controller	495	; reading state of port of 8042 controller
496	in al,64h	496	in al,64h
497	and al,00000010b ; ready flag	497	and al,00000010b ; ready flag
498	; wait until 8042 controller is ready	498	; wait until 8042 controller is ready
499	loopnz wait_loop	499	loopnz wait_loop
500		500

Subversion Repositories Kolibri OS

(root)/kernel/trunk/boot/bootcode.inc @ 183 – Rev 183 → 187