/*      $NetBSD: biostramp.S,v 1.14 2008/04/28 20:23:23 martin 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.
*
* 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 FOUNDATION 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*2
       .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 EAX_REGADDR,(GDT_COPY_ADDR-4)
       .set EBX_REGADDR,(EAX_REGADDR-4)
       .set ECX_REGADDR,(EBX_REGADDR-4)
       .set EDX_REGADDR,(ECX_REGADDR-4)
       .set ESI_REGADDR,(EDX_REGADDR-4)
       .set EDI_REGADDR,(ESI_REGADDR-4)
       .set EFLAGS_REGADDR,(EDI_REGADDR-4)
       .set ES_REGADDR, (EFLAGS_REGADDR-4)
       .set ENDREGADDR,(ES_REGADDR-4)

       .set REALSTACK,ENDREGADDR-20            # 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 bioscall *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
       movl BIOSCALLREG_EAX(%ebx),%eax
       movl %eax,EAX_REGADDR
       movl BIOSCALLREG_EBX(%ebx),%eax
       movl %eax,EBX_REGADDR
       movl BIOSCALLREG_ECX(%ebx),%eax
       movl %eax,ECX_REGADDR
       movl BIOSCALLREG_EDX(%ebx),%eax
       movl %eax,EDX_REGADDR
       movl BIOSCALLREG_ESI(%ebx),%eax
       movl %eax,ESI_REGADDR
       movl BIOSCALLREG_EDI(%ebx),%eax
       movl %eax,EDI_REGADDR
       # merge current flags with certain provided flags
       movl BIOSCALLREG_EFLAGS(%ebx),%ecx
       pushfl
       popl %eax
       andl $~(COPY_FLAGS|PSL_I),%eax
       andl $COPY_FLAGS,%ecx
       orl %ecx,%eax
       movl %eax,EFLAGS_REGADDR
       movl $0, ES_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 %eax,%eax
       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, and movw's are movl's!
       addr32
       movw EDI_REGADDR-MYBASE,%di
       addr32
       movw ESI_REGADDR-MYBASE,%si
       addr32
       movw EDX_REGADDR-MYBASE,%dx
       addr32
       movw ECX_REGADDR-MYBASE,%cx
       addr32
       movw EBX_REGADDR-MYBASE,%bx
       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
       movw EFLAGS_REGADDR-MYBASE,%ax
       pushl %eax
       popfl
       addr32
       movw EAX_REGADDR-MYBASE,%ax

intaddr:
       int $0xff

       # save results
       pushf
       addr32
       movw %ax,EAX_REGADDR-MYBASE
       addr32
       movw %bx,EBX_REGADDR-MYBASE
       addr32
       movw %cx,ECX_REGADDR-MYBASE
       addr32
       movw %dx,EDX_REGADDR-MYBASE
       addr32
       movw %si,ESI_REGADDR-MYBASE
       addr32
       movw %di,EDI_REGADDR-MYBASE
       pop %ax
       addr32
       movw %ax,EFLAGS_REGADDR-MYBASE
       addr32
       movw %es,ES_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
       movl EAX_REGADDR,%eax
       movl %eax,BIOSCALLREG_EAX(%ebx)
       movl EBX_REGADDR,%eax
       movl %eax,BIOSCALLREG_EBX(%ebx)
       movl ECX_REGADDR,%eax
       movl %eax,BIOSCALLREG_ECX(%ebx)
       movl EDX_REGADDR,%eax
       movl %eax,BIOSCALLREG_EDX(%ebx)
       movl ESI_REGADDR,%eax
       movl %eax,BIOSCALLREG_ESI(%ebx)
       movl EDI_REGADDR,%eax
       movl %eax,BIOSCALLREG_EDI(%ebx)
       movl EFLAGS_REGADDR,%eax
       movl %eax,BIOSCALLREG_EFLAGS(%ebx)
       movl ES_REGADDR, %eax
       movl %eax,BIOSCALLREG_ES(%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

#ifdef __ELF__
       .align 16
#else
       .align 4
#endif
IDT_bios:                       # BIOS IDT descriptor (real-mode)
       .word 1023
       .long 0