NetBSD/sys/arch/i386/bioscall/biostramp.S

338 lines
8.1 KiB
ArmAsm

/* $NetBSD: biostramp.S,v 1.5 1996/11/04 23:04:43 jtc Exp $ */
/*-
* Copyright (c) 1996 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by John Kohl.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* biostramp.S: provide a means for NetBSD to call BIOS interrupts
* by switching to real mode, calling it, and switching
* back to protected & paging mode.
*/
/*
* Micro$haft's book on i386/i486 programming says you should do the following
* to return to real mode from protected mode:
*
* 1) disable paging, by jumping to code with identical virtual and physical
* addresses, clearing PG in CR0, and zeroing CR3 (PDBR).
*
* 2) segment descriptors must be byte-granular with limit 64k-1, def32 = 0,
* (i.e. 16-bit data accesses and/or 80286 instructions)
* CS must be executable; DS,ES,FS,GS should be writable
*
* 3) disable interrupts, load IDTR with original value (base 0, limit 1023)
*
* 4) clear PE in CR0, execute FAR jump to load CS.
*
* 5) load SP, and off you go
*
*/
#include "assym.h"
#include <i386/include/param.h>
#include <i386/include/specialreg.h>
#include <i386/include/segments.h>
#include <i386/include/apmvar.h>
#include <i386/include/psl.h>
#include <i386/include/asm.h>
#define addr32 .byte 0x67
#define data32 .byte 0x66
.set MYBASE,NBPG
.set MYSCRATCH,NBPG+NBPG
.set CR3_ADDR,(MYSCRATCH-4)
.set IDTR_SAVE_ADDR,CR3_ADDR-6
.set GDTR_SAVE_ADDR,IDTR_SAVE_ADDR-6
.set GDTR_LOCAL_ADDR,GDTR_SAVE_ADDR-6
.set STACK_PTR_ADDR,GDTR_LOCAL_ADDR-4
.set BASE_PTR_ADDR,STACK_PTR_ADDR-4
.set FUNCTION_ADDR,(BASE_PTR_ADDR-2)
.set GDT_COPY_ADDR,(FUNCTION_ADDR-NGDT*8)
.set AX_REGADDR,(GDT_COPY_ADDR-2)
.set BX_REGADDR,(AX_REGADDR-2)
.set CX_REGADDR,(BX_REGADDR-2)
.set DX_REGADDR,(CX_REGADDR-2)
.set SI_REGADDR,(DX_REGADDR-2)
.set DI_REGADDR,(SI_REGADDR-2)
.set FLAGS_REGADDR,(DI_REGADDR-2)
.set ENDREGADDR,(FLAGS_REGADDR-2)
.set REALSTACK,ENDREGADDR-16 # leave a red zone?
#define COPY_FLAGS (PSL_C|PSL_PF|PSL_AF|PSL_Z|PSL_N|PSL_D|PSL_V)
/*
* do_bios_call(int function, struct apmregs *regs)
*/
ENTRY(do_bios_call)
pushl %ebp
movl %esp,%ebp /* set up frame ptr */
pushl %esi
pushl %edi
pushl %ebx
pushl %ds
pushl %es
pushl %fs
pushl %gs
# copy data to where the real-mode hook can handle it
movl 8(%ebp),%eax
movw %ax,FUNCTION_ADDR
movl 12(%ebp),%ebx
movw APMREG_AX(%ebx),%ax
movw %ax,AX_REGADDR
movw APMREG_BX(%ebx),%ax
movw %ax,BX_REGADDR
movw APMREG_CX(%ebx),%ax
movw %ax,CX_REGADDR
movw APMREG_DX(%ebx),%ax
movw %ax,DX_REGADDR
movw APMREG_SI(%ebx),%ax
movw %ax,SI_REGADDR
movw APMREG_DI(%ebx),%ax
movw %ax,DI_REGADDR
# merge current flags with certain provided flags
movw APMREG_FLAGS(%ebx),%cx
pushfl
popl %eax
andl $~(COPY_FLAGS|PSL_I),%eax
andl $COPY_FLAGS,%ecx
orl %ecx,%eax
movw %ax,FLAGS_REGADDR
# save flags, disable interrupts, do real mode stuff
pushfl
# save GDT
sgdt GDTR_SAVE_ADDR
# copy the GDT to local area
movl GDTR_SAVE_ADDR+2,%esi
movl $GDT_COPY_ADDR,%edi
movl $(NGDT*8),%ecx
cld
rep
movsb
movw $(NGDT*8)-1,GDTR_LOCAL_ADDR
movl $GDT_COPY_ADDR,GDTR_LOCAL_ADDR+2
# install GDT copy
lgdt GDTR_LOCAL_ADDR
cli
# save IDT
sidt IDTR_SAVE_ADDR
# set up new stack: save old ones, create new segs
movl %esp,STACK_PTR_ADDR
movl %ebp,BASE_PTR_ADDR
movl $REALSTACK,%esp
movl $0,%ebp # leave no trace, there is none.
# save CR3
movl %cr3,%eax
movl %eax,CR3_ADDR
# turn off paging
movl %cr0,%eax
andl $~(CR0_PG),%eax
movl %eax,%cr0
# flush TLB, drop PDBR
xorl %eax,%eax
movl %eax,%cr3
## load 16-bit segment descriptors
movw $GSEL(GBIOSDATA_SEL,SEL_KPL),%bx
movw %bx,%ds
movw %bx,%es
movw %bx,%fs
movw %bx,%gs
ljmp $GSEL(GBIOSCODE_SEL,SEL_KPL),$x16+MYBASE
x16:
# turn off protected mode--yikes!
mov %cr0,%eax
data32
and $~CR0_PE,%eax
mov %eax,%cr0
# need inter-segment jump to reload real-mode CS
data32
ljmp $(MYBASE>>4),$xreal
xreal: # really in real mode now
# set up segment selectors. Note: everything is now relative
# to zero-base in this file, except %ss.
# data items in our scratch area need to reflect MYADDR
xorl %ax,%ax
movw %ax,%ss
movw %cs,%ax
movw %ax,%es
movw %ax,%fs
movw %ax,%gs
movw %ax,%ds
## load IDT, now that we are here.
addr32
lidt IDT_bios
# Don't forget that we're in real mode, with 16-bit default data.
# all these movl's are really movw's !
addr32
movl DI_REGADDR-MYBASE,%edi
addr32
movl SI_REGADDR-MYBASE,%esi
addr32
movl DX_REGADDR-MYBASE,%edx
addr32
movl CX_REGADDR-MYBASE,%ecx
addr32
movl BX_REGADDR-MYBASE,%ebx
addr32
movb FUNCTION_ADDR-MYBASE,%al
addr32
movb %al,intaddr+1 # self modifying code, yuck. no indirect interrupt instruction!
# long jump to flush processor cache to reflect code modification
data32
ljmp $(MYBASE>>4),$flushit
flushit:
addr32
movl FLAGS_REGADDR-MYBASE,%eax
pushl %eax
popfl
addr32
movl AX_REGADDR-MYBASE,%eax
intaddr:
int $0xff
# save results
pushf
addr32
movl %eax,AX_REGADDR-MYBASE
addr32
movl %ebx,BX_REGADDR-MYBASE
addr32
movl %ecx,CX_REGADDR-MYBASE
addr32
movl %edx,DX_REGADDR-MYBASE
addr32
movl %esi,SI_REGADDR-MYBASE
addr32
movl %edi,DI_REGADDR-MYBASE
pop %eax
addr32
movl %eax,FLAGS_REGADDR-MYBASE
# and return to protected mode
cli # just to be sure
mov %cr0,%eax
data32
or $CR0_PE,%eax
mov %eax,%cr0
# long jump to 32-bit code segment
data32
ljmp $GSEL(GCODE_SEL,SEL_KPL),$x32+MYBASE
x32:
#back in 32-bit mode/protected mode (but not paging yet).
# Reload the segment registers & IDT
movw $GSEL(GDATA_SEL,SEL_KPL),%bx
movw %bx,%ds
movw %bx,%ss
movw %bx,%es
# reload PDBR
movl CR3_ADDR,%eax
movl %eax,%cr3
movl %cr0,%eax
orl $CR0_PG,%eax
movl %eax,%cr0
# reload system copy of GDT
lgdt GDTR_SAVE_ADDR
# restore protected-mode stack
movl STACK_PTR_ADDR,%esp
movl BASE_PTR_ADDR,%ebp
#restore protected-mode IDT
lidt IDTR_SAVE_ADDR
# copy back arguments from holding pen
movl 12(%ebp),%ebx
movw AX_REGADDR,%ax
movw %ax,APMREG_AX(%ebx)
movw BX_REGADDR,%ax
movw %ax,APMREG_BX(%ebx)
movw CX_REGADDR,%ax
movw %ax,APMREG_CX(%ebx)
movw DX_REGADDR,%ax
movw %ax,APMREG_DX(%ebx)
movw SI_REGADDR,%ax
movw %ax,APMREG_SI(%ebx)
movw DI_REGADDR,%ax
movw %ax,APMREG_DI(%ebx)
movw FLAGS_REGADDR,%ax
movw %ax,APMREG_FLAGS(%ebx)
# finish up, restore registers, and return
popfl
popl %gs
popl %fs
popl %es
popl %ds # see above
popl %ebx
popl %edi
popl %esi
leave
ret
.align 4
IDT_bios: # BIOS IDT descriptor (real-mode)
.word 1023
.long 0