Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2007-2008. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 2288 $

; Virtual-8086 mode manager

; diamond, 2007, 2008

DEBUG_SHOW_IO = 0

struc V86_machine

{

; page directory

        .pagedir dd     ?

; translation table: V86 address -> flat linear address

        .pages  dd      ?

; mutex to protect all data from writing by multiple threads at one time

        .mutex  dd      ?

; i/o permission map

        .iopm   dd      ?

.size = $

}

virtual at 0

V86_machine V86_machine

end virtual

; Create V86 machine

; in: nothing

; out: eax = handle (pointer to struc V86_machine)

;      eax = NULL => failure

; destroys: ebx, ecx, edx (due to malloc)

v86_create:

; allocate V86_machine structure

        mov     eax, V86_machine.size

        call    malloc

        test    eax, eax

        jz      .fail

; initialize mutex

        and     dword [eax+V86_machine.mutex], 0

; allocate tables

        mov     ebx, eax

; We allocate 4 pages.

; First is main page directory for V86 mode.

; Second page:

; first half (0x800 bytes) is page table for addresses 0 - 0x100000,

; second half is for V86-to-linear translation.

; Third and fourth are for I/O permission map.

        push    8000h           ; blocks less than 8 pages are discontinuous

        call    kernel_alloc

        test    eax, eax

        jz      .fail2

        mov     [ebx+V86_machine.pagedir], eax

        push    edi eax

        mov     edi, eax

        add     eax, 1800h

        mov     [ebx+V86_machine.pages], eax

; initialize tables

        mov     ecx, 2000h/4

        xor     eax, eax

        rep stosd

        mov     [ebx+V86_machine.iopm], edi

        dec     eax

        mov     ecx, 2000h/4

        rep stosd

        pop     eax

; page directory: first entry is page table...

        mov     edi, eax

        add     eax, 1000h

        push    eax

        call    get_pg_addr

        or      al, PG_UW

        stosd

; ...and also copy system page tables

; thx to Serge, system is located at high addresses

        add     edi, (OS_BASE shr 20) - 4

        push    esi

        mov     esi, (OS_BASE shr 20) + sys_pgdir

        mov     ecx, 0x80000000 shr 22

        rep movsd

        mov     eax, [ebx+V86_machine.pagedir]   ;root dir also is

        call    get_pg_addr                      ;used as page table

        or      al, PG_SW

        mov     [edi-4096+(page_tabs shr 20)], eax

        pop     esi

; now V86 specific: initialize known addresses in first Mb

        pop     eax

; first page - BIOS data (shared between all machines!)

; physical address = 0

; linear address = OS_BASE

        mov     dword [eax], 111b

        mov     dword [eax+800h], OS_BASE

; page before 0xA0000 - Extended BIOS Data Area (shared between all machines!)

; physical address = 0x9C000

; linear address = 0x8009C000

; (I have seen one computer with EBDA segment = 0x9D80,

; all other computers use less memory)

        mov     ecx, 4

        mov     edx, 0x9C000

        push    eax

        lea     edi, [eax+0x9C*4]

@@:

        lea     eax, [edx + OS_BASE]

        mov     [edi+800h], eax

        lea     eax, [edx + 111b]

        stosd

        add     edx, 0x1000

        loop    @b

        pop     eax

        pop     edi

; addresses 0xC0000 - 0xFFFFF - BIOS code (shared between all machines!)

; physical address = 0xC0000

; linear address = 0x800C0000

        mov     ecx, 0xC0

@@:

        mov     edx, ecx

        shl     edx, 12

        push    edx

        or      edx, 111b

        mov     [eax+ecx*4], edx

        pop     edx

        add     edx, OS_BASE

        mov     [eax+ecx*4+0x800], edx

        inc     cl

        jnz     @b

        mov     eax, ebx

        ret

.fail2:

        mov     eax, ebx

        call    free

.fail:

        xor     eax, eax

        ret

; Destroy V86 machine

; in: eax = handle

; out: nothing

; destroys: eax, ebx, ecx, edx (due to free)

v86_destroy:

        push    eax

        stdcall kernel_free, [eax+V86_machine.pagedir]

        pop     eax

        jmp     free

; Translate V86-address to linear address

; in: eax=V86 address

;     esi=handle

; out: eax=linear address

; destroys: nothing

v86_get_lin_addr:

        push    ecx edx

        mov     ecx, eax

        mov     edx, [esi+V86_machine.pages]

        shr     ecx, 12

        and     eax, 0xFFF

        add     eax, [edx+ecx*4]        ; atomic operation, no mutex needed

        pop     edx ecx

        ret

; Sets linear address for V86-page

; in: eax=linear address (must be page-aligned)

;     ecx=V86 page (NOT address!)

;     esi=handle

; out: nothing

; destroys: nothing

v86_set_page:

        push    eax ebx

        mov     ebx, [esi+V86_machine.pagedir]

        mov     [ebx+ecx*4+0x1800], eax

        call    get_pg_addr

        or      al, 111b

        mov     [ebx+ecx*4+0x1000], eax

        pop     ebx eax

        ret

; Allocate memory in V86 machine

; in: eax=size (in bytes)

;     esi=handle

; out: eax=V86 address, para-aligned (0x10 multiple)

; destroys: nothing

; ­¥¤®¯¨á ­ !!!

;v86_alloc:

;        push    ebx ecx edx edi

;        lea     ebx, [esi+V86_machine.mutex]

;        call    wait_mutex

;        add     eax, 0x1F

;        shr     eax, 4

;        mov     ebx, 0x1000  ; start with address 0x1000 (second page)

;        mov     edi, [esi+V86_machine.tables]

;.l:

;        mov     ecx, ebx

;        shr     ecx, 12

;        mov     edx, [edi+0x1000+ecx*4] ; get linear address

;        test    edx, edx                ; page allocated?

;        jz      .unalloc

;        mov     ecx, ebx

;        and     ecx, 0xFFF

;        add     edx, ecx

;        cmp     dword [edx], 0          ; free block?

;        jnz     .n

;        cmp     dword [edx+4],

;        and     [esi+V86_machine.mutex], 0

;        pop     edi edx ecx ebx

;        ret

uglobal

sys_v86_machine dd      ?

endg

; Called from kernel.asm at first stages of loading

; Initialize system V86 machine (used to simulate BIOS int 13h)

init_sys_v86:

        call    v86_create

        mov     [sys_v86_machine], eax

        test    eax, eax

        jz      .ret

        mov     byte [OS_BASE + 0x500], 0xCD

        mov     byte [OS_BASE + 0x501], 0x13

        mov     byte [OS_BASE + 0x502], 0xF4

        mov     byte [OS_BASE + 0x503], 0xCD

        mov     byte [OS_BASE + 0x504], 0x10

        mov     byte [OS_BASE + 0x505], 0xF4

        mov     esi, eax

        mov     ebx, [eax+V86_machine.pagedir]

; one page for stack, two pages for results (0x2000 bytes = 16 sectors)

        mov     dword [ebx+0x99*4+0x1000], 0x99000 or 111b

        mov     dword [ebx+0x99*4+0x1800], OS_BASE + 0x99000

        mov     dword [ebx+0x9A*4+0x1000], 0x9A000 or 111b

        mov     dword [ebx+0x9A*4+0x1800], OS_BASE + 0x9A000

        mov     dword [ebx+0x9B*4+0x1000], 0x9B000 or 111b

        mov     dword [ebx+0x9B*4+0x1800], OS_BASE + 0x9B000

if ~DEBUG_SHOW_IO

; allow access to all ports

        mov     ecx, [esi+V86_machine.iopm]

        xor     eax, eax

        mov     edi, ecx

        mov     ecx, 10000h/8/4

        rep stosd

end if

.ret:

        ret

struc v86_regs

{

; don't change the order, it is important

        .edi    dd      ?

        .esi    dd      ?

        .ebp    dd      ?

                dd      ?       ; ignored

        .ebx    dd      ?

        .edx    dd      ?

        .ecx    dd      ?

        .eax    dd      ?

        .eip    dd      ?

        .cs     dd      ?

        .eflags dd      ?       ; VM flag must be set!

        .esp    dd      ?

        .ss     dd      ?

        .es     dd      ?

        .ds     dd      ?

        .fs     dd      ?

        .gs     dd      ?

.size = $