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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  BOOTCODE.INC                                                ;;
;;                                                              ;;
;;  KolibriOS 16-bit loader,                                    ;;
;;                        based on bootcode for MenuetOS        ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 816 $
 
 
;==========================================================================
;
;                           16 BIT FUNCTIONS
;
;==========================================================================
 
 
putchar:
; in: al=character
        mov     ah, 0Eh
        mov     bh, 0
        int     10h
        ret
 
print:
; in: si->string
        mov     al, 186
        call    putchar
        mov     al, ' '
        call    putchar
 
printplain:
; in: si->string
        pusha
        lodsb
@@:
        call    putchar
        lodsb
        cmp     al, 0
        jnz     @b
        popa
        ret
 
getkey:
; get number in range [bl,bh] (bl,bh in ['0'..'9'])
; in: bx=range
; out: ax=digit (1..9, 10 for 0)
        mov     ah, 0
        int     16h
        cmp     al, bl
        jb      getkey
        cmp     al, bh
        ja      getkey
        push    ax
        call    putchar
        pop     ax
        and     ax, 0Fh
        jnz     @f
        mov     al, 10
@@:
        ret
 
setcursor:
; in: dl=column, dh=row
        mov     ah, 2
        mov     bh, 0
        int     10h
        ret
 
macro _setcursor row,column
{
        mov     dx, row*256 + column
        call    setcursor
}
 
boot_read_floppy:
        push    si
        xor     si, si
        mov     ah, 2   ; read
@@:
        push    ax
        int     0x13
        pop     ax
        jnc     @f
        inc     si
        cmp     si, 10
        jb      @b
        mov     si, badsect
sayerr_plain:
        call    printplain
        jmp     $
@@:
        pop     si
        ret
 
; convert abs. sector number (AX) to BIOS T:H:S
; sector number = (abs.sector%BPB_SecPerTrk)+1
; pre.track number = (abs.sector/BPB_SecPerTrk)
; head number = pre.track number%BPB_NumHeads
; track number = pre.track number/BPB_NumHeads
; Return: cl - sector number
;         ch - track number
;         dl - drive number (0 = a:)
;         dh - head number
conv_abs_to_THS:
        push    bx
        mov     bx,word [BPB_SecPerTrk]
        xor     dx,dx
        div     bx
        inc     dx
        mov     cl, dl                          ; cl = sector number
        mov     bx,word [BPB_NumHeads]
        xor     dx,dx
        div     bx
        ; !!!!!!! ax = track number, dx = head number
        mov     ch,al                           ; ch=track number
        xchg    dh,dl                           ; dh=head number
        mov     dl,0                            ; dl=0 (drive 0 (a:))
        pop     bx
        retn
; needed variables
BPB_SecPerTrk   dw      0                       ; sectors per track
BPB_NumHeads    dw      0                       ; number of heads
BPB_FATSz16     dw      0                       ; size of FAT
BPB_RootEntCnt  dw      0                       ; count of root dir. entries
BPB_BytsPerSec  dw      0                       ; bytes per sector
BPB_RsvdSecCnt  dw      0                       ; number of reserved sectors
BPB_TotSec16    dw      0                       ; count of the sectors on the volume
BPB_SecPerClus  db      0                       ; number of sectors per cluster
BPB_NumFATs     db      0                       ; number of FAT tables
abs_sector_adj  dw      0                       ; adjustment to make abs. sector number
end_of_FAT      dw      0                       ; end of FAT table
FirstDataSector dw      0                       ; begin of data
 
;=========================================================================
;
;                           16 BIT CODE
;
;=========================================================================
 
include 'bootvesa.inc'                 ;Include source for boot vesa 
 
start_of_code:
        cld
; \begin{diamond}[02.12.2005]
; if bootloader sets ax = 'KL', then ds:si points to loader block
        cmp     ax, 'KL'
        jnz     @f
        mov     word [cs:cfgmanager.loader_block], si
        mov     word [cs:cfgmanager.loader_block+2], ds
@@:
; \end{diamond}[02.12.2005]
 
; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk
; (see comment to bx_from_load)
        cmp     cx, 'HA'
        jnz     no_hd_load
        cmp     dx,'RD'
        jnz     no_hd_load
        mov     word [cs:bx_from_load], bx              ; {SPraid}[13.03.2007]
no_hd_load:
 
; set up stack
        mov     ax, 3000h
        mov     ss, ax
        mov     sp, 0EC00h
; set up segment registers
        push    cs
        pop     ds
        push    cs
        pop     es
 
; set videomode
        mov     ax, 3
        int     0x10
 
if lang eq ru
 ; Load & set russian VGA font (RU.INC)
        mov     bp, RU_FNT1             ; RU_FNT1 - First part
        mov     bx, 1000h               ; 768 bytes
        mov     cx, 30h                 ; 48 symbols
        mov     dx, 80h                 ; 128 - position of first symbol
        mov     ax, 1100h
        int     10h
 
        mov     bp, RU_FNT2             ; RU_FNT2 -Second part
        mov     bx, 1000h               ; 512 bytes
        mov     cx, 20h                 ; 32 symbols
        mov     dx, 0E0h                ; 224 - position of first symbol
        mov     ax, 1100h
        int     10h
 ; End set VGA russian font
else if lang eq et
        mov     bp, ET_FNT              ; ET_FNT1
        mov     bx, 1000h               ;
        mov     cx, 255                 ; 256 symbols
        xor     dx, dx                  ; 0 - position of first symbol
        mov     ax, 1100h
        int     10h
end if
 
; draw frames
        push    0xb800
        pop     es
        xor     di, di
        mov     ah, 1*16+15
 
; draw top
        mov     si, d80x25_top
        mov     cx, d80x25_top_num * 80
@@:
        lodsb
        stosw
        loop    @b
; draw spaces
        mov     si, space_msg
        mov     dx, 25 - d80x25_top_num - d80x25_bottom_num
dfl1:
        push    si
        mov     cx, 80
@@:
        lodsb
        stosw
        loop    @b
        pop     si
        dec     dx
        jnz     dfl1
; draw bottom
        mov     si, d80x25_bottom
        mov     cx, d80x25_bottom_num * 80
@@:
        lodsb
        stosw
        loop    @b
 
        mov     byte [space_msg+80], 0    ; now space_msg is null terminated
 
        _setcursor d80x25_top_num,0
 
 
; TEST FOR 386+
 
        mov     bx, 0x4000
        pushf
        pop     ax
        mov     dx, ax
        xor     ax, bx
        push    ax
        popf
        pushf
        pop     ax
        and     ax, bx
        and     dx, bx
        cmp     ax, dx
        jnz     cpugood
        mov     si, not386
sayerr:
        call    print
        jmp     $
     cpugood:
 
        push    0
        popf
        sti
 
; set up esp
        movzx   esp, sp
 
        push    0
        pop     es
        and     word [es:0x9031], 0
; \begin{Mario79}
; find HDD IDE DMA PCI device
; check for PCI BIOS
        mov     ax, 0xB101
        int     0x1A
        jc      .nopci
        cmp     edx, 'PCI '
        jnz     .nopci
; find PCI class code
; class 1 = mass storage
; subclass 1 = IDE controller
; a) class 1, subclass 1, programming interface 0x80
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x80
        xor     si, si  ; device index = 0
        int     0x1A
        jnc     .found
; b) class 1, subclass 1, programming interface 0x8A
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x8A
        xor     si, si  ; device index = 0
        int     0x1A
        jnc     .found
; c) class 1, subclass 1, programming interface 0x85
        mov     ax, 0xB103
        mov     ecx, 1*10000h + 1*100h + 0x85
        xor     si, si
        int     0x1A
        jc      .nopci
.found:
; get memory base
        mov     ax, 0xB10A
        mov     di, 0x20        ; memory base is config register at 0x20
        int     0x1A
        jc      .nopci
        and     cx, 0xFFF0      ; clear address decode type
        mov     [es:0x9031], cx
.nopci:
; \end{Mario79}
 
        mov     al, 0xf6        ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå
        out     0x60, al
        xor     cx, cx
wait_loop:       ; variant 2
; reading state of port of 8042 controller
        in      al, 64h
        and     al, 00000010b  ; ready flag
; wait until 8042 controller is ready
        loopnz  wait_loop
 
;;;/diamond today   5.02.2008
; set keyboard typematic rate & delay
        mov     al, 0xf3
        out     0x60, al
        xor     cx, cx
@@:
        in      al, 64h
        test    al, 2
        loopnz  @b
        mov     al, 0
        out     0x60, al
        xor     cx, cx
@@:
        in      al, 64h
        test    al, 2
        loopnz  @b
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; --------------- APM ---------------------
        and     word [es:0x9044], 0     ; ver = 0.0 (APM not found)
        mov     ax, 0x5300
        xor     bx, bx
        int     0x15
        jc      apm_end                 ; APM not found
        test    cx, 2
        jz      apm_end                 ; APM 32-bit protected-mode interface not supported
        mov     [es:0x9044], ax         ; Save APM Version
        mov     [es:0x9046], cx         ; Save APM flags
 
        ; Write APM ver ----
        and     ax, 0xf0f
        add     ax, '00'
        mov     si, msg_apm
        mov     [si + 5], ah
        mov     [si + 7], al
        _setcursor 0, 3
        call    printplain
        ; ------------------
 
        mov     ax, 0x5304              ; Disconnect interface
        xor     bx, bx
        int     0x15
        mov     ax, 0x5303              ; Connect 32 bit mode interface
        xor     bx, bx
        int     0x15
 
        mov     [es:0x9040], ebx
        mov     [es:0x9050], ax
        mov     [es:0x9052], cx
        mov     [es:0x9054], dx
 
apm_end:
        _setcursor d80x25_top_num, 0
 
;CHECK current of code
        cmp     [cfgmanager.loader_block], -1
        jz      noloaderblock
        les     bx, [cfgmanager.loader_block]
        cmp     byte [es:bx], 1
        mov     si, loader_block_error
        jnz     sayerr
        push    0
        pop     es
 
noloaderblock:
; DISPLAY VESA INFORMATION
         call    print_vesa_info
         call    calc_vmodes_table
         call    check_first_parm  ;check and enable cursor_pos
 
 
; \begin{diamond}[30.11.2005]
cfgmanager:
; settings:
; a) preboot_graph = graphical mode
;    preboot_gprobe = probe this mode?
; b) preboot_dma  = use DMA access?
; c) preboot_vrrm = use VRR?
; d) preboot_device = from what boot?
 
; determine default settings
        mov     [.bSettingsChanged], 0
 
;.preboot_gr_end:
        mov     di, preboot_device
; if image in memory is present and [preboot_device] is uninitialized,
; set it to use this preloaded image
        cmp     byte [di], 0
        jnz     .preboot_device_inited
        cmp     [.loader_block], -1
        jz      @f
        les     bx, [.loader_block]
        test    byte [es:bx+1], 1
        jz      @f
        mov     byte [di], 3
        jmp     .preboot_device_inited
@@:
; otherwise, set [preboot_device] to 1 (default value - boot from floppy)
        mov     byte [di], 1
.preboot_device_inited:
; following 6 lines set variables to 1 if its current value is 0
        cmp     byte [di+preboot_dma-preboot_device], 1
        adc     byte [di+preboot_dma-preboot_device], 0
        cmp     byte [di+preboot_biosdisk-preboot_device], 1
        adc     byte [di+preboot_biosdisk-preboot_device], 0
        cmp     byte [di+preboot_vrrm-preboot_device], 1
        adc     byte [di+preboot_vrrm-preboot_device], 0
; notify user
        _setcursor 5,2
 
        mov     si, linef
        call    printplain
        mov     si, start_msg
        call    print
        mov     si, time_msg
        call    print
; get start time
        call    .gettime
        mov     [.starttime], eax
        mov     word [.timer], .newtimer
        mov     word [.timer+2], cs
.printcfg:
        _setcursor 9,0
        mov     si, current_cfg_msg
        call    print
        mov     si, curvideo_msg
        call    print
 
            call    draw_current_vmode
 
        mov     si, usebd_msg
        cmp     [preboot_biosdisk], 1
        call    .say_on_off
        mov     si, vrrm_msg
        cmp     [preboot_vrrm], 1
        call    .say_on_off
        mov     si, preboot_device_msg
        call    print
        mov     al, [preboot_device]
        and     eax, 7
        mov     si, [preboot_device_msgs+eax*2]
        call    printplain
.show_remarks:
; show remarks in gray color
        mov     di, ((21-num_remarks)*80 + 2)*2
        push    0xB800
        pop     es
        mov     cx, num_remarks
        mov     si, remarks
.write_remarks:
        lodsw
        push    si
        xchg    ax, si
        mov     ah, 1*16+7      ; background: blue (1), foreground: gray (7)
        push    di
.write_remark:
        lodsb
        test    al, al
        jz      @f
        stosw
        jmp     .write_remark
@@:
        pop     di
        pop     si
        add     di, 80*2
        loop    .write_remarks
.wait:
        _setcursor 25,0         ; out of screen
; set timer interrupt handler
        cli
        push    0
        pop     es
        push    dword [es:8*4]
        pop     dword [.oldtimer]
        push    dword [.timer]
        pop     dword [es:8*4]    
;        mov     eax, [es:8*4]
;        mov     [.oldtimer], eax
;        mov     eax, [.timer]
;        mov     [es:8*4], eax
        sti
; wait for keypressed
        xor     ax,ax
        int     16h
        push    ax
; restore timer interrupt
;        push    0
;        pop     es
        mov     eax, [.oldtimer]
        mov     [es:8*4], eax
        mov     [.timer], eax
        _setcursor 7,0
        mov     si, space_msg
        call    printplain
; clear remarks and restore normal attributes
        push    es
        mov     di, ((21-num_remarks)*80 + 2)*2
        push    0xB800
        pop     es
        mov     cx, num_remarks
        mov     ax, ' ' + (1*16 + 15)*100h
@@:
        push    cx
        mov     cx, 76
        rep     stosw
        pop     cx
        add     di, 4*2
        loop    @b
        pop     es
        pop     ax
; switch on key
        cmp     al, 13
        jz      .continue
        or      al, 20h
        cmp     al, 'a'
        jz      .change_a
        cmp     al, 'b'
        jz      .change_b
        cmp     al, 'c'
        jz      .change_c
        cmp     al, 'd'
        jnz     .show_remarks
        _setcursor 15,0
        mov     si, bdev
        call    print
        mov     bx, '14'
        call    getkey
        mov     [preboot_device], al
        _setcursor 13,0
.d:
        mov     [.bSettingsChanged], 1
        call    clear_vmodes_table             ;clear vmodes_table
        jmp    .printcfg
.change_a:
.loops:
        call    draw_vmodes_table
 
        _setcursor 25,0         ; out of screen
        xor     ax,ax
        int     0x16
;        call    clear_table_cursor             ;clear current position of cursor
 
        mov     si,word [cursor_pos]
 
        cmp     ah,0x48;x,0x48E0               ; up
        jne     .down
        cmp     si,modes_table
        jbe     .loops
        sub     word [cursor_pos],size_of_step
        jmp     .loops
 
.down:  cmp     ah,0x50;x,0x50E0               ; down
        jne     .pgup
        cmp     word[es:si+10],-1
        je      .loops        
        add     word [cursor_pos],size_of_step
        jmp     .loops
 
.pgup:  cmp     ah,0x49                 ; page up
        jne     .pgdn
        sub     si, size_of_step*long_v_table
        cmp     si, modes_table
        jae     @f
        mov     si, modes_table
@@:
        mov     word [cursor_pos], si
        mov     si, word [home_cursor]
        sub     si, size_of_step*long_v_table
        cmp     si, modes_table
        jae     @f
        mov     si, modes_table
@@:
        mov     word [home_cursor], si
        jmp     .loops
 
.pgdn:  cmp     ah,0x51                 ; page down
        jne     .enter
        mov     ax, [end_cursor]
        add     si, size_of_step*long_v_table
        cmp     si, ax
        jb      @f
        mov     si, ax
        sub     si, size_of_step
@@:
        mov     word [cursor_pos], si
        mov     si, word [home_cursor]
        sub     ax, size_of_step*long_v_table
        add     si, size_of_step*long_v_table
        cmp     si, ax
        jb      @f
        mov     si, ax
@@:
        mov     word [home_cursor], si
        jmp     .loops
 
.enter: cmp     al,0x0D;x,0x1C0D               ; enter
        jne     .loops
        push    word [cursor_pos]
        pop     bp
        push    word [es:bp]
        pop     word [x_save]
        push    word [es:bp+2]
        pop     word [y_save]
        push    word [es:bp+6]
        pop     word [number_vm]
        mov     word [preboot_graph],bp           ;save choose
        
        jmp    .d
 
.change_b:
        _setcursor 15,0
;        mov     si, ask_dma
;        call    print
;        mov     bx, '13'
;        call    getkey
;        mov     [preboot_dma], al
        mov     si, ask_bd
        call    print
        mov     bx, '12'
        call    getkey
        mov     [preboot_biosdisk], al
        _setcursor 11,0
        jmp     .d
.change_c:
        _setcursor 15,0
        mov     si, vrrmprint
        call    print
        mov     bx, '12'
        call    getkey
        mov     [preboot_vrrm], al
        _setcursor 12,0
        jmp     .d
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.say_on_off:
        pushf
        call    print
        mov     si, on_msg
        popf
        jz      @f
        mov     si, off_msg
@@:     jmp     printplain
; novesa and vervesa strings are not used at the moment of executing this code
virtual at novesa
.oldtimer dd ?
.starttime dd ?
.bSettingsChanged db ?
.timer dd ?
end virtual
.loader_block dd -1
.gettime:
        mov     ah, 0
        int     1Ah
        xchg    ax, cx
        shl     eax, 10h
        xchg    ax, dx
        ret
.newtimer:
        push    ds
        push    cs
        pop     ds
        pushf
        call    [.oldtimer]
        pushad
        call    .gettime
        sub     eax, [.starttime]
        sub     ax, 18*5
        jae     .timergo
        neg     ax
        add     ax, 18-1
        mov     bx, 18
        xor     dx, dx
        div     bx
if lang eq ru
; ¯®¤®¦¤¨â¥ 5 á¥ªã­¤, 4/3/2 á¥ªã­¤ë, 1 á¥ªã­¤ã
        cmp     al, 5
        mov     cl, ' '
        jae     @f
        cmp     al, 1
        mov     cl, 'ã'
        jz      @f
        mov     cl, 'ë'
@@:     mov     [time_str+9], cl
else if lang eq et
        cmp     al, 1
        ja      @f
        mov     [time_str+9], ' '
        mov     [time_str+10],' '
@@:
else
; wait 5/4/3/2 seconds, 1 second
        cmp     al, 1
        mov     cl, 's'
        ja      @f
        mov     cl, ' '
@@:     mov     [time_str+9], cl
end if
        add     al, '0'
        mov     [time_str+1], al
        mov     si, time_msg
        _setcursor 7,0
        call    print
        _setcursor 25,0
        popad
        pop     ds
        iret
.timergo:
        push    0
        pop     es
        mov     eax, [.oldtimer]
        mov     [es:8*4], eax
        mov     sp, 0EC00h
.continue:
        sti
        _setcursor 6,0
        mov     si, space_msg
        call    printplain
        call    printplain
        _setcursor 6,0
        mov     si, loading_msg
        call    print
        _setcursor 15,0
        cmp     [.bSettingsChanged], 0
        jz      .load
        cmp     [.loader_block], -1
        jz      .load
        les     bx, [.loader_block]
        mov     eax, [es:bx+3]
        push    ds
        pop     es
        test    eax, eax
        jz      .load
        push    eax
        mov     si, save_quest
        call    print
.waityn:
        mov     ah, 0
        int     16h
        or      al, 20h
        cmp     al, 'n'
        jz      .loadc
        cmp     al, 'y'
        jnz     .waityn
        call    putchar
        mov     byte [space_msg+80], 186
        pop     eax
        push    cs
        push    .cont
        push    eax
        retf
.loadc:
        pop     eax
.cont:
        push    cs
        pop     ds
        mov     si, space_msg
        mov     byte [si+80], 0
        _setcursor 15,0
        call    printplain
        _setcursor 15,0
.load:
; \end{diamond}[02.12.2005]
 
; ASK GRAPHICS MODE
 
        call    set_vmode
 
; GRAPHICS ACCELERATION
; force yes
        mov     [es:0x901C], byte 1
 
; DMA ACCESS TO HD
 
        mov     al, [preboot_dma]
        mov     [es:0x901F], al
 
; VRR_M USE
 
        mov     al,[preboot_vrrm]
        mov     [es:0x9030], al
        mov     [es:0x901E], byte 1
 
; BOOT DEVICE
 
        mov     al, [preboot_device]
        dec     al
        mov     [boot_dev], al
 
; READ DISKETTE TO MEMORY
 
;        cmp     [boot_dev],0
        jne     no_sys_on_floppy
        mov     si,diskload
        call    print
        xor     ax, ax            ; reset drive
        xor     dx, dx
        int     0x13
; do we boot from CD-ROM?
        mov     ah, 41h
        mov     bx, 55AAh
        xor     dx, dx
        int     0x13
        jc      .nocd
        cmp     bx, 0AA55h
        jnz     .nocd
        mov     ah, 48h
        push    ds
        push    es
        pop     ds
        mov     si, 0xa000
        mov     word [si], 30
        int     0x13
        pop     ds
        jc      .nocd
        push    ds
        lds     si, [es:si+26]
        test    byte [ds:si+10], 40h
        pop     ds
        jz      .nocd
; yes - read all floppy by 18 sectors
 
; TODO: !!!! read only first sector and set variables !!!!!
; ...
; TODO: !!! then read flippy image track by track
        
        mov     cx, 0x0001      ; startcyl,startsector
.a1:
        push    cx dx
        mov     al, 18
        mov     bx, 0xa000
        call    boot_read_floppy
        mov     si, movedesc
        push    es
        push    ds
        pop     es
        mov     cx, 256*18
        mov     ah, 0x87
        int     0x15
        pop     es
        pop     dx cx
        test    ah, ah
        jnz     sayerr_floppy
        add     dword [si+8*3+2], 512*18
        inc     dh
        cmp     dh, 2
        jnz     .a1
        mov     dh, 0
        inc     ch
        cmp     ch, 80
        jae     ok_sys_on_floppy
        pusha
        mov     al, ch
        shr     ch, 2
        add     al, ch
        aam
        xchg    al, ah
        add     ax, '00'
        mov     si, pros
        mov     [si], ax
        call    printplain
        popa
        jmp     .a1
.nocd:
; no - read only used sectors from floppy
; now load floppy image to memory
; at first load boot sector and first FAT table
 
; read only first sector and fill variables
        mov     cx, 0x0001      ; first logical sector
        xor     dx, dx          ; head = 0, drive = 0 (a:)
        mov     al, 1           ; read one sector
        mov     bx, 0xB000      ; es:bx -> data area
        call    boot_read_floppy
; fill the necessary parameters to work with a floppy
        mov     ax, word [es:bx+24]
        mov     word [BPB_SecPerTrk], ax
        mov     ax, word [es:bx+26]
        mov     word [BPB_NumHeads], ax
        mov     ax, word [es:bx+22]
        mov     word [BPB_FATSz16], ax
        mov     ax, word [es:bx+17]
        mov     word [BPB_RootEntCnt], ax
        mov     ax, word [es:bx+11]
        mov     word [BPB_BytsPerSec], ax
        mov     ax, word [es:bx+14]
        mov     word [BPB_RsvdSecCnt], ax
        mov     ax, word [es:bx+19]
        mov     word [BPB_TotSec16], ax
        mov     al, byte [es:bx+13]
        mov     byte [BPB_SecPerClus], al
        mov     al, byte [es:bx+16]
        mov     byte [BPB_NumFATs], al
; count of clusters in FAT12 ((size_of_FAT*2)/3)
        mov     ax, word [BPB_FATSz16]
        mov     cx, word [BPB_BytsPerSec]
        xor     dx, dx
        mul     cx
        shl     ax, 1
        mov     cx, 3
        div     cx              ; now ax - number of clusters in FAT12
        mov     word [end_of_FAT], ax
 
; load first FAT table
        mov     cx, 0x0002      ; startcyl,startsector          ; TODO!!!!!
        xor     dx, dx          ; starthead,drive
        mov     al, byte [BPB_FATSz16]     ; no of sectors to read
        add     bx, word [BPB_BytsPerSec]  ; es:bx -> data area
        call    boot_read_floppy
        mov     bx, 0xB000
 
; and copy them to extended memory
        mov     si, movedesc
        mov     [si+8*2+3], bh          ; from
        
        mov     ax, word [BPB_BytsPerSec]
        shr     ax, 1                   ; words per sector
        mov     cx, word [BPB_RsvdSecCnt]
        add     cx, word [BPB_FATSz16]
        mul     cx
        push    ax                      ; save to stack count of words in boot+FAT
        xchg    ax, cx
        
        push    es
        push    ds
        pop     es
        mov     ah, 0x87
        int     0x15
        pop     es
        test    ah, ah
        jz      @f
sayerr_floppy:
        mov     dx, 0x3f2
        mov     al, 0
        out     dx, al
        mov     si, memmovefailed
        jmp     sayerr_plain
@@:
        pop     ax                      ; restore from stack count of words in boot+FAT
        shl     ax, 1                   ; make bytes count from count of words
        and     eax, 0ffffh
        add     dword [si+8*3+2], eax
 
; copy first FAT to second copy
; TODO: BPB_NumFATs !!!!!
        add     bx, word [BPB_BytsPerSec]       ; !!! TODO: may be need multiply by BPB_RsvdSecCnt !!!
        mov     byte [si+8*2+3], bh     ; bx - begin of FAT
        
        mov     ax, word [BPB_BytsPerSec]
        shr     ax, 1                   ; words per sector
        mov     cx, word [BPB_FATSz16]
        mul     cx
        mov     cx, ax                  ; cx - count of words in FAT
 
        push    es
        push    ds
        pop     es
        mov     ah, 0x87
        int     0x15
        pop     es
        test    ah, ah
        jnz     sayerr_floppy
        
        mov     ax, cx
        shl     ax, 1
        and     eax, 0ffffh             ; ax - count of bytes in FAT
        add     dword [si+8*3+2], eax
        
; reading RootDir
; TODO: BPB_NumFATs
        add     bx, ax
        add     bx, 100h
        and     bx, 0ff00h                      ; bx - place in buffer to write RootDir
        push    bx
 
        mov     bx, word [BPB_BytsPerSec]
        shr     bx, 5                           ; divide bx by 32
        mov     ax, word [BPB_RootEntCnt]
        xor     dx, dx
        div     bx
        push    ax                              ; ax - count of RootDir sectors
 
        mov     ax, word [BPB_FATSz16]
        xor     cx, cx
        mov     cl, byte [BPB_NumFATs]
        mul     cx
        add     ax, word [BPB_RsvdSecCnt]       ; ax - first sector of RootDir
 
        mov     word [FirstDataSector], ax
        pop     bx
        push    bx
        add     word [FirstDataSector], bx      ; Begin of data region of floppy
        
; read RootDir
        call    conv_abs_to_THS
        pop     ax
        pop     bx                              ; place in buffer to write
        push    ax
        call    boot_read_floppy                ; read RootDir into buffer
; copy RootDir
        mov     byte [si+8*2+3], bh             ; from buffer
        pop     ax                              ; ax = count of RootDir sectors
        mov     cx, word [BPB_BytsPerSec]
        mul     cx
        shr     ax, 1
        mov     cx, ax                          ; count of words to copy
        push    es
        push    ds
        pop     es
        mov     ah, 0x87
        int     0x15
        pop     es
 
        mov     ax, cx
        shl     ax, 1
        and     eax, 0ffffh             ; ax - count of bytes in RootDir
        add     dword [si+8*3+2], eax   ; add count of bytes copied
 
; Reading data clusters from floppy
        mov     byte [si+8*2+3], bh
        push    bx
 
        mov     di, 2                   ; First data cluster
.read_loop:
        mov     bx, di
        shr     bx, 1                   ; bx+di = di*1.5
        jnc     .even
        test    word [es:bx+di+0xB200], 0xFFF0  ; TODO: may not be 0xB200 !!!
        jmp     @f
.even:
        test    word [es:bx+di+0xB200], 0xFFF   ; TODO: may not be 0xB200 !!!
 
@@:
        jz      .skip
; read cluster di
;.read:
        ;conv cluster di to abs. sector ax
        ; ax = (N-2) * BPB_SecPerClus + FirstDataSector
        mov     ax, di
        sub     ax, 2
        xor     bx, bx
        mov     bl, byte [BPB_SecPerClus]
        mul     bx
        add     ax, word [FirstDataSector]
        call    conv_abs_to_THS
        pop     bx
        push    bx
        mov     al, byte [BPB_SecPerClus]       ; number of sectors in cluster
        call    boot_read_floppy
        push    es
        push    ds
        pop     es
        pusha
;
        mov     ax, word [BPB_BytsPerSec]
        xor     cx, cx
        mov     cl, byte [BPB_SecPerClus]
        mul     cx
        shr     ax, 1                           ; ax = (BPB_BytsPerSec * BPB_SecPerClus)/2
        mov     cx, ax                          ; number of words to copy (count words in cluster)
;
        mov     ah, 0x87
        int     0x15                            ; copy data
        test    ah, ah
        popa
        pop     es
        jnz     sayerr_floppy
; skip cluster di
.skip:
        mov     ax, word [BPB_BytsPerSec]
        xor     cx, cx
        mov     cl, byte [BPB_SecPerClus]
        mul     cx
        and     eax, 0ffffh             ; ax - count of bytes in cluster
        add     dword [si+8*3+2], eax
 
        mov     ax, word [end_of_FAT]   ; max cluster number
        pusha
; draw percentage
; total clusters: ax
; read clusters: di
        xchg    ax, di
        mov     cx, 100
        mul     cx
        div     di
        aam
        xchg    al, ah
        add     ax, '00'
        mov     si, pros
        cmp     [si], ax
        jz      @f
        mov     [si], ax
        call    printplain
@@:
        popa
        inc     di
        cmp     di, word [end_of_FAT]   ; max number of cluster
        jnz     .read_loop
        pop     bx                      ; clear stack
 
ok_sys_on_floppy:
        mov     si, backspace2
        call    printplain
        mov     si, okt
        call    printplain
no_sys_on_floppy:
        xor     ax, ax          ; reset drive
        xor     dx, dx
        int     0x13
        mov     dx, 0x3f2       ; floppy motor off
        mov     al, 0
        out     dx, al
 
 
; SET GRAPHICS
 
        xor     ax, ax
        mov     es, ax
 
        mov     ax, [es:0x9008]         ; vga & 320x200
        mov     bx, ax
        cmp     ax, 0x13
        je      setgr
        cmp     ax, 0x12
        je      setgr
        mov     ax, 0x4f02              ; Vesa
setgr:
        int     0x10
        test    ah, ah
        mov     si, fatalsel
        jnz     v_mode_error
; set mode 0x12 graphics registers:
        cmp     bx, 0x12
        jne     gmok2
 
        mov     al, 0x05
        mov     dx, 0x03ce
        push    dx
        out     dx, al      ; select GDC mode register
        mov     al, 0x02
        inc     dx
        out     dx, al      ; set write mode 2
 
        mov     al, 0x02
        mov     dx, 0x03c4
        out     dx, al      ; select VGA sequencer map mask register
        mov     al, 0x0f
        inc     dx
        out     dx, al      ; set mask for all planes 0-3
 
        mov     al, 0x08
        pop     dx
        out     dx, al      ; select GDC bit mask register
                           ; for writes to 0x03cf
gmok2:
        push    ds
        pop     es

Rev 795	Rev 816
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;	4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;
5	;; Distributed under terms of the GNU General Public License ;;	5	;; Distributed under terms of the GNU General Public License ;;
6	;; ;;	6	;; ;;
7	;; BOOTCODE.INC ;;	7	;; BOOTCODE.INC ;;
8	;; ;;	8	;; ;;
9	;; KolibriOS 16-bit loader, ;;	9	;; KolibriOS 16-bit loader, ;;
10	;; based on bootcode for MenuetOS ;;	10	;; based on bootcode for MenuetOS ;;
11	;; ;;	11	;; ;;
12	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	12	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13		13
14	$Revision: 795 $	14	$Revision: 816 $
15		15
16		16
17	;==========================================================================	17	;==========================================================================
18	;	18	;
19	; 16 BIT FUNCTIONS	19	; 16 BIT FUNCTIONS
20	;	20	;
21	;==========================================================================	21	;==========================================================================
22		22
23		23
24	putchar:	24	putchar:
25	; in: al=character	25	; in: al=character
26	mov ah, 0Eh	26	mov ah, 0Eh
27	mov bh, 0	27	mov bh, 0
28	int 10h	28	int 10h
29	ret	29	ret
30		30
31	print:	31	print:
32	; in: si->string	32	; in: si->string
33	mov al, 186	33	mov al, 186
34	call putchar	34	call putchar
35	mov al, ' '	35	mov al, ' '
36	call putchar	36	call putchar
37		37
38	printplain:	38	printplain:
39	; in: si->string	39	; in: si->string
40	pusha	40	pusha
41	lodsb	41	lodsb
42	@@:	42	@@:
43	call putchar	43	call putchar
44	lodsb	44	lodsb
45	cmp al, 0	45	cmp al, 0
46	jnz @b	46	jnz @b
47	popa	47	popa
48	ret	48	ret
49		49
50	getkey:	50	getkey:
51	; get number in range [bl,bh] (bl,bh in ['0'..'9'])	51	; get number in range [bl,bh] (bl,bh in ['0'..'9'])
52	; in: bx=range	52	; in: bx=range
53	; out: ax=digit (1..9, 10 for 0)	53	; out: ax=digit (1..9, 10 for 0)
54	mov ah, 0	54	mov ah, 0
55	int 16h	55	int 16h
56	cmp al, bl	56	cmp al, bl
57	jb getkey	57	jb getkey
58	cmp al, bh	58	cmp al, bh
59	ja getkey	59	ja getkey
60	push ax	60	push ax
61	call putchar	61	call putchar
62	pop ax	62	pop ax
63	and ax, 0Fh	63	and ax, 0Fh
64	jnz @f	64	jnz @f
65	mov al, 10	65	mov al, 10
66	@@:	66	@@:
67	ret	67	ret
68		68
69	setcursor:	69	setcursor:
70	; in: dl=column, dh=row	70	; in: dl=column, dh=row
71	mov ah, 2	71	mov ah, 2
72	mov bh, 0	72	mov bh, 0
73	int 10h	73	int 10h
74	ret	74	ret
75		75
76	macro _setcursor row,column	76	macro _setcursor row,column
77	{	77	{
78	mov dx, row*256 + column	78	mov dx, row*256 + column
79	call setcursor	79	call setcursor
80	}	80	}
81		81
82	boot_read_floppy:	82	boot_read_floppy:
83	push si	83	push si
84	xor si, si	84	xor si, si
85	mov ah, 2 ; read	85	mov ah, 2 ; read
86	@@:	86	@@:
87	push ax	87	push ax
88	int 0x13	88	int 0x13
89	pop ax	89	pop ax
90	jnc @f	90	jnc @f
91	inc si	91	inc si
92	cmp si, 10	92	cmp si, 10
93	jb @b	93	jb @b
94	mov si, badsect	94	mov si, badsect
95	sayerr_plain:	95	sayerr_plain:
96	call printplain	96	call printplain
97	jmp $	97	jmp $
98	@@:	98	@@:
99	pop si	99	pop si
100	ret	100	ret
101		101
102	; convert abs. sector number (AX) to BIOS T:H:S	102	; convert abs. sector number (AX) to BIOS T:H:S
103	; sector number = (abs.sector%BPB_SecPerTrk)+1	103	; sector number = (abs.sector%BPB_SecPerTrk)+1
104	; pre.track number = (abs.sector/BPB_SecPerTrk)	104	; pre.track number = (abs.sector/BPB_SecPerTrk)
105	; head number = pre.track number%BPB_NumHeads	105	; head number = pre.track number%BPB_NumHeads
106	; track number = pre.track number/BPB_NumHeads	106	; track number = pre.track number/BPB_NumHeads
107	; Return: cl - sector number	107	; Return: cl - sector number
108	; ch - track number	108	; ch - track number
109	; dl - drive number (0 = a:)	109	; dl - drive number (0 = a:)
110	; dh - head number	110	; dh - head number
111	conv_abs_to_THS:	111	conv_abs_to_THS:
112	push bx	112	push bx
113	mov bx,word [BPB_SecPerTrk]	113	mov bx,word [BPB_SecPerTrk]
114	xor dx,dx	114	xor dx,dx
115	div bx	115	div bx
116	inc dx	116	inc dx
117	mov cl, dl ; cl = sector number	117	mov cl, dl ; cl = sector number
118	mov bx,word [BPB_NumHeads]	118	mov bx,word [BPB_NumHeads]
119	xor dx,dx	119	xor dx,dx
120	div bx	120	div bx
121	; !!!!!!! ax = track number, dx = head number	121	; !!!!!!! ax = track number, dx = head number
122	mov ch,al ; ch=track number	122	mov ch,al ; ch=track number
123	xchg dh,dl ; dh=head number	123	xchg dh,dl ; dh=head number
124	mov dl,0 ; dl=0 (drive 0 (a:))	124	mov dl,0 ; dl=0 (drive 0 (a:))
125	pop bx	125	pop bx
126	retn	126	retn
127	; needed variables	127	; needed variables
128	BPB_SecPerTrk dw 0 ; sectors per track	128	BPB_SecPerTrk dw 0 ; sectors per track
129	BPB_NumHeads dw 0 ; number of heads	129	BPB_NumHeads dw 0 ; number of heads
130	BPB_FATSz16 dw 0 ; size of FAT	130	BPB_FATSz16 dw 0 ; size of FAT
131	BPB_RootEntCnt dw 0 ; count of root dir. entries	131	BPB_RootEntCnt dw 0 ; count of root dir. entries
132	BPB_BytsPerSec dw 0 ; bytes per sector	132	BPB_BytsPerSec dw 0 ; bytes per sector
133	BPB_RsvdSecCnt dw 0 ; number of reserved sectors	133	BPB_RsvdSecCnt dw 0 ; number of reserved sectors
134	BPB_TotSec16 dw 0 ; count of the sectors on the volume	134	BPB_TotSec16 dw 0 ; count of the sectors on the volume
135	BPB_SecPerClus db 0 ; number of sectors per cluster	135	BPB_SecPerClus db 0 ; number of sectors per cluster
136	BPB_NumFATs db 0 ; number of FAT tables	136	BPB_NumFATs db 0 ; number of FAT tables
137	abs_sector_adj dw 0 ; adjustment to make abs. sector number	137	abs_sector_adj dw 0 ; adjustment to make abs. sector number
138	end_of_FAT dw 0 ; end of FAT table	138	end_of_FAT dw 0 ; end of FAT table
139	FirstDataSector dw 0 ; begin of data	139	FirstDataSector dw 0 ; begin of data
140		140
141	;=========================================================================	141	;=========================================================================
142	;	142	;
143	; 16 BIT CODE	143	; 16 BIT CODE
144	;	144	;
145	;=========================================================================	145	;=========================================================================
146		146
147	include 'bootvesa.inc' ;Include source for boot vesa	147	include 'bootvesa.inc' ;Include source for boot vesa
148		148
149	start_of_code:	149	start_of_code:
150	cld	150	cld
151	; \begin{diamond}[02.12.2005]	151	; \begin{diamond}[02.12.2005]
152	; if bootloader sets ax = 'KL', then ds:si points to loader block	152	; if bootloader sets ax = 'KL', then ds:si points to loader block
153	cmp ax, 'KL'	153	cmp ax, 'KL'
154	jnz @f	154	jnz @f
155	mov word [cs:cfgmanager.loader_block], si	155	mov word [cs:cfgmanager.loader_block], si
156	mov word [cs:cfgmanager.loader_block+2], ds	156	mov word [cs:cfgmanager.loader_block+2], ds
157	@@:	157	@@:
158	; \end{diamond}[02.12.2005]	158	; \end{diamond}[02.12.2005]
159		159
160	; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk	160	; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk
161	; (see comment to bx_from_load)	161	; (see comment to bx_from_load)
162	cmp cx, 'HA'	162	cmp cx, 'HA'
163	jnz no_hd_load	163	jnz no_hd_load
164	cmp dx,'RD'	164	cmp dx,'RD'
165	jnz no_hd_load	165	jnz no_hd_load
166	mov word [cs:bx_from_load], bx ; {SPraid}[13.03.2007]	166	mov word [cs:bx_from_load], bx ; {SPraid}[13.03.2007]
167	no_hd_load:	167	no_hd_load:
168		168
169	; set up stack	169	; set up stack
170	mov ax, 3000h	170	mov ax, 3000h
171	mov ss, ax	171	mov ss, ax
172	mov sp, 0EC00h	172	mov sp, 0EC00h
173	; set up segment registers	173	; set up segment registers
174	push cs	174	push cs
175	pop ds	175	pop ds
176	push cs	176	push cs
177	pop es	177	pop es
178		178
179	; set videomode	179	; set videomode
180	mov ax, 3	180	mov ax, 3
181	int 0x10	181	int 0x10
182		182
183	if lang eq ru	183	if lang eq ru
184	; Load & set russian VGA font (RU.INC)	184	; Load & set russian VGA font (RU.INC)
185	mov bp, RU_FNT1 ; RU_FNT1 - First part	185	mov bp, RU_FNT1 ; RU_FNT1 - First part
186	mov bx, 1000h ; 768 bytes	186	mov bx, 1000h ; 768 bytes
187	mov cx, 30h ; 48 symbols	187	mov cx, 30h ; 48 symbols
188	mov dx, 80h ; 128 - position of first symbol	188	mov dx, 80h ; 128 - position of first symbol
189	mov ax, 1100h	189	mov ax, 1100h
190	int 10h	190	int 10h
191		191
192	mov bp, RU_FNT2 ; RU_FNT2 -Second part	192	mov bp, RU_FNT2 ; RU_FNT2 -Second part
193	mov bx, 1000h ; 512 bytes	193	mov bx, 1000h ; 512 bytes
194	mov cx, 20h ; 32 symbols	194	mov cx, 20h ; 32 symbols
195	mov dx, 0E0h ; 224 - position of first symbol	195	mov dx, 0E0h ; 224 - position of first symbol
196	mov ax, 1100h	196	mov ax, 1100h
197	int 10h	197	int 10h
198	; End set VGA russian font	198	; End set VGA russian font
199	else if lang eq et	199	else if lang eq et
200	mov bp, ET_FNT ; ET_FNT1	200	mov bp, ET_FNT ; ET_FNT1
201	mov bx, 1000h ;	201	mov bx, 1000h ;
202	mov cx, 255 ; 256 symbols	202	mov cx, 255 ; 256 symbols
203	xor dx, dx ; 0 - position of first symbol	203	xor dx, dx ; 0 - position of first symbol
204	mov ax, 1100h	204	mov ax, 1100h
205	int 10h	205	int 10h
206	end if	206	end if
207		207
208	; draw frames	208	; draw frames
209	push 0xb800	209	push 0xb800
210	pop es	210	pop es
211	xor di, di	211	xor di, di
212	mov ah, 1*16+15	212	mov ah, 1*16+15
213		213
214	; draw top	214	; draw top
215	mov si, d80x25_top	215	mov si, d80x25_top
216	mov cx, d80x25_top_num * 80	216	mov cx, d80x25_top_num * 80
217	@@:	217	@@:
218	lodsb	218	lodsb
219	stosw	219	stosw
220	loop @b	220	loop @b
221	; draw spaces	221	; draw spaces
222	mov si, space_msg	222	mov si, space_msg
223	mov dx, 25 - d80x25_top_num - d80x25_bottom_num	223	mov dx, 25 - d80x25_top_num - d80x25_bottom_num
224	dfl1:	224	dfl1:
225	push si	225	push si
226	mov cx, 80	226	mov cx, 80
227	@@:	227	@@:
228	lodsb	228	lodsb
229	stosw	229	stosw
230	loop @b	230	loop @b
231	pop si	231	pop si
232	dec dx	232	dec dx
233	jnz dfl1	233	jnz dfl1
234	; draw bottom	234	; draw bottom
235	mov si, d80x25_bottom	235	mov si, d80x25_bottom
236	mov cx, d80x25_bottom_num * 80	236	mov cx, d80x25_bottom_num * 80
237	@@:	237	@@:
238	lodsb	238	lodsb
239	stosw	239	stosw
240	loop @b	240	loop @b
241		241
242	mov byte [space_msg+80], 0 ; now space_msg is null terminated	242	mov byte [space_msg+80], 0 ; now space_msg is null terminated
243		243
244	_setcursor d80x25_top_num,0	244	_setcursor d80x25_top_num,0
245		245
246		246
247	; TEST FOR 386+	247	; TEST FOR 386+
248		248
249	mov bx, 0x4000	249	mov bx, 0x4000
250	pushf	250	pushf
251	pop ax	251	pop ax
252	mov dx, ax	252	mov dx, ax
253	xor ax, bx	253	xor ax, bx
254	push ax	254	push ax
255	popf	255	popf
256	pushf	256	pushf
257	pop ax	257	pop ax
258	and ax, bx	258	and ax, bx
259	and dx, bx	259	and dx, bx
260	cmp ax, dx	260	cmp ax, dx
261	jnz cpugood	261	jnz cpugood
262	mov si, not386	262	mov si, not386
263	sayerr:	263	sayerr:
264	call print	264	call print
265	jmp $	265	jmp $
266	cpugood:	266	cpugood:
267		267
268	push 0	268	push 0
269	popf	269	popf
270	sti	270	sti
271		271
272	; set up esp	272	; set up esp
273	movzx esp, sp	273	movzx esp, sp
274		274
275	push 0	275	push 0
276	pop es	276	pop es
277	and word [es:0x9031], 0	277	and word [es:0x9031], 0
278	; \begin{Mario79}	278	; \begin{Mario79}
279	; find HDD IDE DMA PCI device	279	; find HDD IDE DMA PCI device
280	; check for PCI BIOS	280	; check for PCI BIOS
281	mov ax, 0xB101	281	mov ax, 0xB101
282	int 0x1A	282	int 0x1A
283	jc .nopci	283	jc .nopci
284	cmp edx, 'PCI '	284	cmp edx, 'PCI '
285	jnz .nopci	285	jnz .nopci
286	; find PCI class code	286	; find PCI class code
287	; class 1 = mass storage	287	; class 1 = mass storage
288	; subclass 1 = IDE controller	288	; subclass 1 = IDE controller
289	; a) class 1, subclass 1, programming interface 0x80	289	; a) class 1, subclass 1, programming interface 0x80
290	mov ax, 0xB103	290	mov ax, 0xB103
291	mov ecx, 110000h + 1100h + 0x80	291	mov ecx, 110000h + 1100h + 0x80
292	xor si, si ; device index = 0	292	xor si, si ; device index = 0
293	int 0x1A	293	int 0x1A
294	jnc .found	294	jnc .found
295	; b) class 1, subclass 1, programming interface 0x8A	295	; b) class 1, subclass 1, programming interface 0x8A
296	mov ax, 0xB103	296	mov ax, 0xB103
297	mov ecx, 110000h + 1100h + 0x8A	297	mov ecx, 110000h + 1100h + 0x8A
298	xor si, si ; device index = 0	298	xor si, si ; device index = 0
299	int 0x1A	299	int 0x1A
300	jnc .found	300	jnc .found
301	; c) class 1, subclass 1, programming interface 0x85	301	; c) class 1, subclass 1, programming interface 0x85
302	mov ax, 0xB103	302	mov ax, 0xB103
303	mov ecx, 110000h + 1100h + 0x85	303	mov ecx, 110000h + 1100h + 0x85
304	xor si, si	304	xor si, si
305	int 0x1A	305	int 0x1A
306	jc .nopci	306	jc .nopci
307	.found:	307	.found:
308	; get memory base	308	; get memory base
309	mov ax, 0xB10A	309	mov ax, 0xB10A
310	mov di, 0x20 ; memory base is config register at 0x20	310	mov di, 0x20 ; memory base is config register at 0x20
311	int 0x1A	311	int 0x1A
312	jc .nopci	312	jc .nopci
313	and cx, 0xFFF0 ; clear address decode type	313	and cx, 0xFFF0 ; clear address decode type
314	mov [es:0x9031], cx	314	mov [es:0x9031], cx
315	.nopci:	315	.nopci:
316	; \end{Mario79}	316	; \end{Mario79}
317		317
318	mov al, 0xf6 ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå	318	mov al, 0xf6 ; Ñáðîñ êëàâèàòóðû, ðàçðåøèòü ñêàíèðîâàíèå
319	out 0x60, al	319	out 0x60, al
320	xor cx, cx	320	xor cx, cx
321	wait_loop: ; variant 2	321	wait_loop: ; variant 2
322	; reading state of port of 8042 controller	322	; reading state of port of 8042 controller
323	in al, 64h	323	in al, 64h
324	and al, 00000010b ; ready flag	324	and al, 00000010b ; ready flag
325	; wait until 8042 controller is ready	325	; wait until 8042 controller is ready
326	loopnz wait_loop	326	loopnz wait_loop
327		327
328	;;;/diamond today 5.02.2008	328	;;;/diamond today 5.02.2008
329	; set keyboard typematic rate & delay	329	; set keyboard typematic rate & delay
330	mov al, 0xf3	330	mov al, 0xf3
331	out 0x60, al	331	out 0x60, al
332	xor cx, cx	332	xor cx, cx
333	@@:	333	@@:
334	in al, 64h	334	in al, 64h
335	test al, 2	335	test al, 2
336	loopnz @b	336	loopnz @b
337	mov al, 0	337	mov al, 0
338	out 0x60, al	338	out 0x60, al
339	xor cx, cx	339	xor cx, cx
340	@@:	340	@@:
341	in al, 64h	341	in al, 64h
342	test al, 2	342	test al, 2
343	loopnz @b	343	loopnz @b
344	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	344	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
345	; --------------- APM ---------------------	345	; --------------- APM ---------------------
346	and word [es:0x9044], 0 ; ver = 0.0 (APM not found)	346	and word [es:0x9044], 0 ; ver = 0.0 (APM not found)
347	mov ax, 0x5300	347	mov ax, 0x5300
348	xor bx, bx	348	xor bx, bx
349	int 0x15	349	int 0x15
350	jc apm_end ; APM not found	350	jc apm_end ; APM not found
351	test cx, 2	351	test cx, 2
352	jz apm_end ; APM 32-bit protected-mode interface not supported	352	jz apm_end ; APM 32-bit protected-mode interface not supported
353	mov [es:0x9044], ax ; Save APM Version	353	mov [es:0x9044], ax ; Save APM Version
354	mov [es:0x9046], cx ; Save APM flags	354	mov [es:0x9046], cx ; Save APM flags
355		355
356	; Write APM ver ----	356	; Write APM ver ----
357	and ax, 0xf0f	357	and ax, 0xf0f
358	add ax, '00'	358	add ax, '00'
359	mov si, msg_apm	359	mov si, msg_apm
360	mov [si + 5], ah	360	mov [si + 5], ah
361	mov [si + 7], al	361	mov [si + 7], al
362	_setcursor 0, 3	362	_setcursor 0, 3
363	call printplain	363	call printplain
364	; ------------------	364	; ------------------
365		365
366	mov ax, 0x5304 ; Disconnect interface	366	mov ax, 0x5304 ; Disconnect interface
367	xor bx, bx	367	xor bx, bx
368	int 0x15	368	int 0x15
369	mov ax, 0x5303 ; Connect 32 bit mode interface	369	mov ax, 0x5303 ; Connect 32 bit mode interface
370	xor bx, bx	370	xor bx, bx
371	int 0x15	371	int 0x15
372		372
373	mov [es:0x9040], ebx	373	mov [es:0x9040], ebx
374	mov [es:0x9050], ax	374	mov [es:0x9050], ax
375	mov [es:0x9052], cx	375	mov [es:0x9052], cx
376	mov [es:0x9054], dx	376	mov [es:0x9054], dx
377		377
378	apm_end:	378	apm_end:
379	_setcursor d80x25_top_num, 0	379	_setcursor d80x25_top_num, 0
380		380
381	;CHECK current of code	381	;CHECK current of code
382	cmp [cfgmanager.loader_block], -1	382	cmp [cfgmanager.loader_block], -1
383	jz noloaderblock	383	jz noloaderblock
384	les bx, [cfgmanager.loader_block]	384	les bx, [cfgmanager.loader_block]
385	cmp byte [es:bx], 1	385	cmp byte [es:bx], 1
386	mov si, loader_block_error	386	mov si, loader_block_error
387	jnz sayerr	387	jnz sayerr
388	push 0	388	push 0
389	pop es	389	pop es
390		390
391	noloaderblock:	391	noloaderblock:
392	; DISPLAY VESA INFORMATION	392	; DISPLAY VESA INFORMATION
393	call print_vesa_info	393	call print_vesa_info
394	call calc_vmodes_table	394	call calc_vmodes_table
395	call check_first_parm ;check and enable cursor_pos	395	call check_first_parm ;check and enable cursor_pos
396		396
397		397
398	; \begin{diamond}[30.11.2005]	398	; \begin{diamond}[30.11.2005]
399	cfgmanager:	399	cfgmanager:
400	; settings:	400	; settings:
401	; a) preboot_graph = graphical mode	401	; a) preboot_graph = graphical mode
402	; preboot_gprobe = probe this mode?	402	; preboot_gprobe = probe this mode?
403	; b) preboot_dma = use DMA access?	403	; b) preboot_dma = use DMA access?
404	; c) preboot_vrrm = use VRR?	404	; c) preboot_vrrm = use VRR?
405	; d) preboot_device = from what boot?	405	; d) preboot_device = from what boot?
406		406
407	; determine default settings	407	; determine default settings
408	mov [.bSettingsChanged], 0	408	mov [.bSettingsChanged], 0
409		409
410	;.preboot_gr_end:	410	;.preboot_gr_end:
411	mov di, preboot_device	411	mov di, preboot_device
412	; if image in memory is present and [preboot_device] is uninitialized,	412	; if image in memory is present and [preboot_device] is uninitialized,
413	; set it to use this preloaded image	413	; set it to use this preloaded image
414	cmp byte [di], 0	414	cmp byte [di], 0
415	jnz .preboot_device_inited	415	jnz .preboot_device_inited
416	cmp [.loader_block], -1	416	cmp [.loader_block], -1
417	jz @f	417	jz @f
418	les bx, [.loader_block]	418	les bx, [.loader_block]
419	test byte [es:bx+1], 1	419	test byte [es:bx+1], 1
420	jz @f	420	jz @f
421	mov byte [di], 3	421	mov byte [di], 3
422	jmp .preboot_device_inited	422	jmp .preboot_device_inited
423	@@:	423	@@:
424	; otherwise, set [preboot_device] to 1 (default value - boot from floppy)	424	; otherwise, set [preboot_device] to 1 (default value - boot from floppy)
425	mov byte [di], 1	425	mov byte [di], 1
426	.preboot_device_inited:	426	.preboot_device_inited:
427	; following 6 lines set variables to 1 if its current value is 0	427	; following 6 lines set variables to 1 if its current value is 0
428	cmp byte [di+preboot_dma-preboot_device], 1	428	cmp byte [di+preboot_dma-preboot_device], 1
429	adc byte [di+preboot_dma-preboot_device], 0	429	adc byte [di+preboot_dma-preboot_device], 0
430	cmp byte [di+preboot_biosdisk-preboot_device], 1	430	cmp byte [di+preboot_biosdisk-preboot_device], 1
431	adc byte [di+preboot_biosdisk-preboot_device], 0	431	adc byte [di+preboot_biosdisk-preboot_device], 0
432	cmp byte [di+preboot_vrrm-preboot_device], 1	432	cmp byte [di+preboot_vrrm-preboot_device], 1
433	adc byte [di+preboot_vrrm-preboot_device], 0	433	adc byte [di+preboot_vrrm-preboot_device], 0
434	; notify user	434	; notify user
435	_setcursor 5,2	435	_setcursor 5,2
436		436
437	mov si, linef	437	mov si, linef
438	call printplain	438	call printplain
439	mov si, start_msg	439	mov si, start_msg
440	call print	440	call print
441	mov si, time_msg	441	mov si, time_msg
442	call print	442	call print
443	; get start time	443	; get start time
444	call .gettime	444	call .gettime
445	mov [.starttime], eax	445	mov [.starttime], eax
446	mov word [.timer], .newtimer	446	mov word [.timer], .newtimer
447	mov word [.timer+2], cs	447	mov word [.timer+2], cs
448	.printcfg:	448	.printcfg:
449	_setcursor 9,0	449	_setcursor 9,0
450	mov si, current_cfg_msg	450	mov si, current_cfg_msg
451	call print	451	call print
452	mov si, curvideo_msg	452	mov si, curvideo_msg
453	call print	453	call print
454		454
455	call draw_current_vmode	455	call draw_current_vmode
456		456
457	mov si, usebd_msg	457	mov si, usebd_msg
458	cmp [preboot_biosdisk], 1	458	cmp [preboot_biosdisk], 1
459	call .say_on_off	459	call .say_on_off
460	mov si, vrrm_msg	460	mov si, vrrm_msg
461	cmp [preboot_vrrm], 1	461	cmp [preboot_vrrm], 1
462	call .say_on_off	462	call .say_on_off
463	mov si, preboot_device_msg	463	mov si, preboot_device_msg
464	call print	464	call print
465	mov al, [preboot_device]	465	mov al, [preboot_device]
466	and eax, 7	466	and eax, 7
467	mov si, [preboot_device_msgs+eax*2]	467	mov si, [preboot_device_msgs+eax*2]
468	call printplain	468	call printplain
469	.show_remarks:	469	.show_remarks:
470	; show remarks in gray color	470	; show remarks in gray color
471	mov di, ((21-num_remarks)80 + 2)2	471	mov di, ((21-num_remarks)80 + 2)2
472	push 0xB800	472	push 0xB800
473	pop es	473	pop es
474	mov cx, num_remarks	474	mov cx, num_remarks
475	mov si, remarks	475	mov si, remarks
476	.write_remarks:	476	.write_remarks:
477	lodsw	477	lodsw
478	push si	478	push si
479	xchg ax, si	479	xchg ax, si
480	mov ah, 1*16+7 ; background: blue (1), foreground: gray (7)	480	mov ah, 1*16+7 ; background: blue (1), foreground: gray (7)
481	push di	481	push di
482	.write_remark:	482	.write_remark:
483	lodsb	483	lodsb
484	test al, al	484	test al, al
485	jz @f	485	jz @f
486	stosw	486	stosw
487	jmp .write_remark	487	jmp .write_remark
488	@@:	488	@@:
489	pop di	489	pop di
490	pop si	490	pop si
491	add di, 80*2	491	add di, 80*2
492	loop .write_remarks	492	loop .write_remarks
493	.wait:	493	.wait:
494	_setcursor 25,0 ; out of screen	494	_setcursor 25,0 ; out of screen
495	; set timer interrupt handler	495	; set timer interrupt handler
496	cli	496	cli
497	push 0	497	push 0
498	pop es	498	pop es
499	push dword [es:8*4]	499	push dword [es:8*4]
500	pop dword [.oldtimer]	500	pop dword [.oldtimer]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/boot/bootcode.inc – Rev 795 → 816