| ;**************************************************************************** |
| ;* |
| ;* SciTech OS Portability Manager Library |
| ;* |
| ;* ======================================================================== |
| ;* |
| ;* The contents of this file are subject to the SciTech MGL Public |
| ;* License Version 1.0 (the "License"); you may not use this file |
| ;* except in compliance with the License. You may obtain a copy of |
| ;* the License at http://www.scitechsoft.com/mgl-license.txt |
| ;* |
| ;* Software distributed under the License is distributed on an |
| ;* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or |
| ;* implied. See the License for the specific language governing |
| ;* rights and limitations under the License. |
| ;* |
| ;* The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc. |
| ;* |
| ;* The Initial Developer of the Original Code is SciTech Software, Inc. |
| ;* All Rights Reserved. |
| ;* |
| ;* ======================================================================== |
| ;* |
| ;* Based on original code Copyright 1994 Otto Chrons |
| ;* |
| ;* Language: 80386 Assembler, TASM 4.0 or later |
| ;* Environment: IBM PC 32 bit protected mode |
| ;* |
| ;* Description: Low level page fault handler for virtual linear framebuffers. |
| ;* |
| ;**************************************************************************** |
| |
| IDEAL |
| JUMPS |
| |
| include "scitech.mac" ; Memory model macros |
| |
| header _vflat ; Set up memory model |
| |
| VFLAT_START EQU 0F0000000h |
| VFLAT_END EQU 0F03FFFFFh |
| PAGE_PRESENT EQU 1 |
| PAGE_NOTPRESENT EQU 0 |
| PAGE_READ EQU 0 |
| PAGE_WRITE EQU 2 |
| |
| ifdef DOS4GW |
| |
| ;---------------------------------------------------------------------------- |
| ; DOS4G/W flat linear framebuffer emulation. |
| ;---------------------------------------------------------------------------- |
| |
| begdataseg _vflat |
| |
| ; Near pointers to the page directory base and our page tables. All of |
| ; this memory is always located in the first Mb of DOS memory. |
| |
| PDBR dd 0 ; Page directory base register (CR3) |
| accessPageAddr dd 0 |
| accessPageTable dd 0 |
| |
| ; CauseWay page directory & 1st page table linear addresses. |
| |
| CauseWayDIRLinear dd 0 |
| CauseWay1stLinear dd 0 |
| |
| ; Place to store a copy of the original Page Table Directory before we |
| ; intialised our virtual buffer code. |
| |
| pageDirectory: resd 1024 ; Saved page table directory |
| |
| ValidCS dw 0 ; Valid CS for page faults |
| Ring0CS dw 0 ; Our ring 0 code selector |
| LastPage dd 0 ; Last page we mapped in |
| BankFuncBuf: resb 101 ; Place to store bank switch code |
| BankFuncPtr dd offset BankFuncBuf |
| |
| INT14Gate: |
| INT14Offset dd 0 ; eip of original vector |
| INT14Selector dw 0 ; cs of original vector |
| |
| cextern _PM_savedDS,USHORT |
| cextern VF_haveCauseWay,BOOL |
| |
| enddataseg _vflat |
| |
| begcodeseg _vflat ; Start of code segment |
| |
| cextern VF_malloc,FPTR |
| |
| ;---------------------------------------------------------------------------- |
| ; PF_handler64k - Page fault handler for 64k banks |
| ;---------------------------------------------------------------------------- |
| ; The handler below is a 32 bit ring 0 page fault handler. It receives |
| ; control immediately after any page fault or after an IRQ6 (hardware |
| ; interrupt). This provides the fastest possible handling of page faults |
| ; since it jump directly here. If this is a page fault, the number |
| ; immediately on the stack will be an error code, at offset 4 will be |
| ; the eip of the faulting instruction, at offset 8 will be the cs of the |
| ; faulting instruction. If it is a hardware interrupt, it will not have |
| ; the error code and the eflags will be at offset 8. |
| ;---------------------------------------------------------------------------- |
| cprocfar PF_handler64k |
| |
| ; Check if this is a processor exeception or a page fault |
| |
| push eax |
| mov ax,[cs:ValidCS] ; Use CS override to access data |
| cmp [ss:esp+12],ax ; Is this a page fault? |
| jne @@ToOldHandler ; Nope, jump to the previous handler |
| |
| ; Get address of page fault and check if within our handlers range |
| |
| mov eax,cr2 ; EBX has page fault linear address |
| cmp eax,VFLAT_START ; Is the fault less than ours? |
| jb @@ToOldHandler ; Yep, go to previous handler |
| cmp eax,VFLAT_END ; Is the fault more than ours? |
| jae @@ToOldHandler ; Yep, go to previous handler |
| |
| ; This is our page fault, so we need to handle it |
| |
| pushad |
| push ds |
| push es |
| mov ebx,eax ; EBX := page fault address |
| and ebx,invert 0FFFFh ; Mask to 64k bank boundary |
| mov ds,[cs:_PM_savedDS]; Load segment registers |
| mov es,[cs:_PM_savedDS] |
| |
| ; Map in the page table for our virtual framebuffer area for modification |
| |
| mov edi,[PDBR] ; EDI points to page directory |
| mov edx,ebx ; EDX = linear address |
| shr edx,22 ; EDX = offset to page directory |
| mov edx,[edx*4+edi] ; EDX = physical page table address |
| mov eax,edx |
| mov edx,[accessPageTable] |
| or eax,7 |
| mov [edx],eax |
| mov eax,cr3 |
| mov cr3,eax ; Update page table cache |
| |
| ; Mark all pages valid for the new page fault area |
| |
| mov esi,ebx ; ESI := linear address for page |
| shr esi,10 |
| and esi,0FFFh ; Offset into page table |
| add esi,[accessPageAddr] |
| ifdef USE_NASM |
| %assign off 0 |
| %rep 16 |
| or [DWORD esi+off],0000000001h ; Enable pages |
| %assign off off+4 |
| %endrep |
| else |
| off = 0 |
| REPT 16 |
| or [DWORD esi+off],0000000001h ; Enable pages |
| off = off+4 |
| ENDM |
| endif |
| |
| ; Mark all pages invalid for the previously mapped area |
| |
| xchg esi,[LastPage] ; Save last page for next page fault |
| test esi,esi |
| jz @@DoneMapping ; Dont update if first time round |
| ifdef USE_NASM |
| %assign off 0 |
| %rep 16 |
| or [DWORD esi+off],0FFFFFFFEh ; Disable pages |
| %assign off off+4 |
| %endrep |
| else |
| off = 0 |
| REPT 16 |
| and [DWORD esi+off],0FFFFFFFEh ; Disable pages |
| off = off+4 |
| ENDM |
| endif |
| |
| @@DoneMapping: |
| mov eax,cr3 |
| mov cr3,eax ; Flush the TLB |
| |
| ; Now program the new SuperVGA starting bank address |
| |
| mov eax,ebx ; EAX := page fault address |
| shr eax,16 |
| and eax,0FFh ; Mask to 0-255 |
| call [BankFuncPtr] ; Call the bank switch function |
| |
| pop es |
| pop ds |
| popad |
| pop eax |
| add esp,4 ; Pop the error code from stack |
| iretd ; Return to faulting instruction |
| |
| @@ToOldHandler: |
| pop eax |
| ifdef USE_NASM |
| jmp far dword [cs:INT14Gate]; Chain to previous handler |
| else |
| jmp [FWORD cs:INT14Gate]; Chain to previous handler |
| endif |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; PF_handler4k - Page fault handler for 4k banks |
| ;---------------------------------------------------------------------------- |
| ; The handler below is a 32 bit ring 0 page fault handler. It receives |
| ; control immediately after any page fault or after an IRQ6 (hardware |
| ; interrupt). This provides the fastest possible handling of page faults |
| ; since it jump directly here. If this is a page fault, the number |
| ; immediately on the stack will be an error code, at offset 4 will be |
| ; the eip of the faulting instruction, at offset 8 will be the cs of the |
| ; faulting instruction. If it is a hardware interrupt, it will not have |
| ; the error code and the eflags will be at offset 8. |
| ;---------------------------------------------------------------------------- |
| cprocfar PF_handler4k |
| |
| ; Fill in when we have tested all the 64Kb code |
| |
| ifdef USE_NASM |
| jmp far dword [cs:INT14Gate]; Chain to previous handler |
| else |
| jmp [FWORD cs:INT14Gate]; Chain to previous handler |
| endif |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; void InstallFaultHandler(void *baseAddr,int bankSize) |
| ;---------------------------------------------------------------------------- |
| ; Installes the page fault handler directly int the interrupt descriptor |
| ; table for maximum performance. This of course requires ring 0 access, |
| ; but none of this stuff will run without ring 0! |
| ;---------------------------------------------------------------------------- |
| cprocstart InstallFaultHandler |
| |
| ARG baseAddr:ULONG, bankSize:UINT |
| |
| enter_c |
| |
| mov [DWORD LastPage],0 ; No pages have been mapped |
| mov ax,cs |
| mov [ValidCS],ax ; Save CS value for page faults |
| |
| ; Put address of our page fault handler into the IDT directly |
| |
| sub esp,6 ; Allocate space on stack |
| ifdef USE_NASM |
| sidt [ss:esp] ; Store pointer to IDT |
| else |
| sidt [FWORD ss:esp] ; Store pointer to IDT |
| endif |
| pop ax ; add esp,2 |
| pop eax ; Absolute address of IDT |
| add eax,14*8 ; Point to Int #14 |
| |
| ; Note that Interrupt gates do not have the high and low word of the |
| ; offset in adjacent words in memory, there are 4 bytes separating them. |
| |
| mov ecx,[eax] ; Get cs and low 16 bits of offset |
| mov edx,[eax+6] ; Get high 16 bits of offset in dx |
| shl edx,16 |
| mov dx,cx ; edx has offset |
| mov [INT14Offset],edx ; Save offset |
| shr ecx,16 |
| mov [INT14Selector],cx ; Save original cs |
| mov [eax+2],cs ; Install new cs |
| mov edx,offset PF_handler64k |
| cmp [UINT bankSize],4 |
| jne @@1 |
| mov edx,offset PF_handler4k |
| @@1: mov [eax],dx ; Install low word of offset |
| shr edx,16 |
| mov [eax+6],dx ; Install high word of offset |
| |
| leave_c |
| ret |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; void RemoveFaultHandler(void) |
| ;---------------------------------------------------------------------------- |
| ; Closes down the virtual framebuffer services and restores the previous |
| ; page fault handler. |
| ;---------------------------------------------------------------------------- |
| cprocstart RemoveFaultHandler |
| |
| enter_c |
| |
| ; Remove page fault handler from IDT |
| |
| sub esp,6 ; Allocate space on stack |
| ifdef USE_NASM |
| sidt [ss:esp] ; Store pointer to IDT |
| else |
| sidt [FWORD ss:esp] ; Store pointer to IDT |
| endif |
| |
| pop ax ; add esp,2 |
| pop eax ; Absolute address of IDT |
| add eax,14*8 ; Point to Int #14 |
| mov cx,[INT14Selector] |
| mov [eax+2],cx ; Restore original CS |
| mov edx,[INT14Offset] |
| mov [eax],dx ; Install low word of offset |
| shr edx,16 |
| mov [eax+6],dx ; Install high word of offset |
| |
| leave_c |
| ret |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; void InstallBankFunc(int codeLen,void *bankFunc) |
| ;---------------------------------------------------------------------------- |
| ; Installs the bank switch function by relocating it into our data segment |
| ; and making it into a callable function. We do it this way to make the |
| ; code identical to the way that the VflatD devices work under Windows. |
| ;---------------------------------------------------------------------------- |
| cprocstart InstallBankFunc |
| |
| ARG codeLen:UINT, bankFunc:DPTR |
| |
| enter_c |
| |
| mov esi,[bankFunc] ; Copy the code into buffer |
| mov edi,offset BankFuncBuf |
| mov ecx,[codeLen] |
| rep movsb |
| mov [BYTE edi],0C3h ; Terminate the function with a near ret |
| |
| leave_c |
| ret |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; int InitPaging(void) |
| ;---------------------------------------------------------------------------- |
| ; Initializes paging system. If paging is not enabled, builds a page table |
| ; directory and page tables for physical memory |
| ; |
| ; Exit: 0 - Successful |
| ; -1 - Couldn't initialize paging mechanism |
| ;---------------------------------------------------------------------------- |
| cprocstart InitPaging |
| |
| push ebx |
| push ecx |
| push edx |
| push esi |
| push edi |
| |
| ; Are we running under CauseWay? |
| |
| mov ax,0FFF9h |
| int 31h |
| jc @@NotCauseway |
| cmp ecx,"CAUS" |
| jnz @@NotCauseway |
| cmp edx,"EWAY" |
| jnz @@NotCauseway |
| |
| mov [BOOL VF_haveCauseWay],1 |
| mov [CauseWayDIRLinear],esi |
| mov [CauseWay1stLinear],edi |
| |
| ; Check for DPMI |
| |
| mov ax,0ff00h |
| push es |
| int 31h |
| pop es |
| shr edi,2 |
| and edi,3 |
| cmp edi,2 |
| jz @@ErrExit ; Not supported under DPMI |
| |
| mov eax,[CauseWayDIRLinear] |
| jmp @@CopyCR3 |
| |
| @@NotCauseway: |
| mov ax,cs |
| test ax,3 ; Which ring are we running |
| jnz @@ErrExit ; Needs zero ring to access |
| ; page tables (CR3) |
| mov eax,cr0 ; Load CR0 |
| test eax,80000000h ; Is paging enabled? |
| jz @@ErrExit ; No, we must have paging! |
| |
| mov eax,cr3 ; Load directory address |
| and eax,0FFFFF000h |
| |
| @@CopyCR3: |
| mov [PDBR],eax ; Save it |
| mov esi,eax |
| mov edi,offset pageDirectory |
| mov ecx,1024 |
| cld |
| rep movsd ; Copy the original page table directory |
| cmp [DWORD accessPageAddr],0; Check if we have allocated page |
| jne @@HaveRealMem ; table already (we cant free it) |
| |
| mov eax,0100h ; DPMI DOS allocate |
| mov ebx,8192/16 |
| int 31h ; Allocate 8192 bytes |
| and eax,0FFFFh |
| shl eax,4 ; EAX points to newly allocated memory |
| add eax,4095 |
| and eax,0FFFFF000h ; Page align |
| mov [accessPageAddr],eax |
| |
| @@HaveRealMem: |
| mov eax,[accessPageAddr] ; EAX -> page table in 1st Mb |
| shr eax,12 |
| and eax,3FFh ; Page table offset |
| shl eax,2 |
| cmp [BOOL VF_haveCauseWay],0 |
| jz @@NotCW0 |
| mov ebx,[CauseWay1stLinear] |
| jmp @@Put1st |
| |
| @@NotCW0: |
| mov ebx,[PDBR] |
| mov ebx,[ebx] |
| and ebx,0FFFFF000h ; Page table for 1st megabyte |
| |
| @@Put1st: |
| add eax,ebx |
| mov [accessPageTable],eax |
| sub eax,eax ; No error |
| jmp @@Exit |
| |
| @@ErrExit: |
| mov eax,-1 |
| |
| @@Exit: pop edi |
| pop esi |
| pop edx |
| pop ecx |
| pop ebx |
| ret |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; void ClosePaging(void) |
| ;---------------------------------------------------------------------------- |
| ; Closes the paging system |
| ;---------------------------------------------------------------------------- |
| cprocstart ClosePaging |
| |
| push eax |
| push ecx |
| push edx |
| push esi |
| push edi |
| |
| mov eax,[accessPageAddr] |
| call AccessPage ; Restore AccessPage mapping |
| mov edi,[PDBR] |
| mov esi,offset pageDirectory |
| mov ecx,1024 |
| cld |
| rep movsd ; Restore the original page table directory |
| |
| @@Exit: pop edi |
| pop esi |
| pop edx |
| pop ecx |
| pop eax |
| ret |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; long AccessPage(long phys) |
| ;---------------------------------------------------------------------------- |
| ; Maps a known page to given physical memory |
| ; Entry: EAX - Physical memory |
| ; Exit: EAX - Linear memory address of mapped phys mem |
| ;---------------------------------------------------------------------------- |
| cprocstatic AccessPage |
| |
| push edx |
| mov edx,[accessPageTable] |
| or eax,7 |
| mov [edx],eax |
| mov eax,cr3 |
| mov cr3,eax ; Update page table cache |
| mov eax,[accessPageAddr] |
| pop edx |
| ret |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; long GetPhysicalAddress(long linear) |
| ;---------------------------------------------------------------------------- |
| ; Returns the physical address of linear address |
| ; Entry: EAX - Linear address to convert |
| ; Exit: EAX - Physical address |
| ;---------------------------------------------------------------------------- |
| cprocstatic GetPhysicalAddress |
| |
| push ebx |
| push edx |
| mov edx,eax |
| shr edx,22 ; EDX is the directory offset |
| mov ebx,[PDBR] |
| mov edx,[edx*4+ebx] ; Load page table address |
| push eax |
| mov eax,edx |
| call AccessPage ; Access the page table |
| mov edx,eax |
| pop eax |
| shr eax,12 |
| and eax,03FFh ; EAX offset into page table |
| mov eax,[edx+eax*4] ; Load physical address |
| and eax,0FFFFF000h |
| pop edx |
| pop ebx |
| ret |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; void CreatePageTable(long pageDEntry) |
| ;---------------------------------------------------------------------------- |
| ; Creates a page table for specific address (4MB) |
| ; Entry: EAX - Page directory entry (top 10-bits of address) |
| ;---------------------------------------------------------------------------- |
| cprocstatic CreatePageTable |
| |
| push ebx |
| push ecx |
| push edx |
| push edi |
| mov ebx,eax ; Save address |
| mov eax,8192 |
| push eax |
| call VF_malloc ; Allocate page table directory |
| add esp,4 |
| add eax,0FFFh |
| and eax,0FFFFF000h ; Page align (4KB) |
| mov edi,eax ; Save page table linear address |
| sub eax,eax ; Fill with zero |
| mov ecx,1024 |
| cld |
| rep stosd ; Clear page table |
| sub edi,4096 |
| mov eax,edi |
| call GetPhysicalAddress |
| mov edx,[PDBR] |
| or eax,7 ; Present/write/user bit |
| mov [edx+ebx*4],eax ; Save physical address into page directory |
| mov eax,cr3 |
| mov cr3,eax ; Update page table cache |
| pop edi |
| pop edx |
| pop ecx |
| pop ebx |
| ret |
| |
| cprocend |
| |
| ;---------------------------------------------------------------------------- |
| ; void MapPhysical2Linear(ulong pAddr, ulong lAddr, int pages, int flags); |
| ;---------------------------------------------------------------------------- |
| ; Maps physical memory into linear memory |
| ; Entry: pAddr - Physical address |
| ; lAddr - Linear address |
| ; pages - Number of 4K pages to map |
| ; flags - Page flags |
| ; bit 0 = present |
| ; bit 1 = Read(0)/Write(1) |
| ;---------------------------------------------------------------------------- |
| cprocstart MapPhysical2Linear |
| |
| ARG pAddr:ULONG, lAddr:ULONG, pages:UINT, pflags:UINT |
| |
| enter_c |
| |
| and [ULONG pAddr],0FFFFF000h; Page boundary |
| and [ULONG lAddr],0FFFFF000h; Page boundary |
| mov ecx,[pflags] |
| and ecx,11b ; Just two bits |
| or ecx,100b ; Supervisor bit |
| mov [pflags],ecx |
| |
| mov edx,[lAddr] |
| shr edx,22 ; EDX = Directory |
| mov esi,[PDBR] |
| mov edi,[pages] ; EDI page count |
| mov ebx,[lAddr] |
| |
| @@CreateLoop: |
| mov ecx,[esi+edx*4] ; Load page table address |
| test ecx,1 ; Is it present? |
| jnz @@TableOK |
| mov eax,edx |
| call CreatePageTable ; Create a page table |
| @@TableOK: |
| mov eax,ebx |
| shr eax,12 |
| and eax,3FFh |
| sub eax,1024 |
| neg eax ; EAX = page count in this table |
| inc edx ; Next table |
| mov ebx,0 ; Next time we'll map 1K pages |
| sub edi,eax ; Subtract mapped pages from page count |
| jns @@CreateLoop ; Create more tables if necessary |
| |
| mov ecx,[pages] ; ECX = Page count |
| mov esi,[lAddr] |
| shr esi,12 ; Offset part isn't needed |
| mov edi,[pAddr] |
| @@MappingLoop: |
| mov eax,esi |
| shr eax,10 ; EAX = offset to page directory |
| mov ebx,[PDBR] |
| mov eax,[eax*4+ebx] ; EAX = page table address |
| call AccessPage |
| mov ebx,esi |
| and ebx,3FFh ; EBX = offset to page table |
| mov edx,edi |
| add edi,4096 ; Next physical address |
| inc esi ; Next linear page |
| or edx,[pflags] ; Update flags... |
| mov [eax+ebx*4],edx ; Store page table entry |
| loop @@MappingLoop |
| mov eax,cr3 |
| mov cr3,eax ; Update page table cache |
| |
| leave_c |
| ret |
| |
| cprocend |
| |
| endcodeseg _vflat |
| |
| endif |
| |
| END ; End of module |
