/*
* Copyright 2004-2010, Axel Dörfler, axeld@pinc-software.de.
* Distributed under the terms of the MIT License.
*/
/*! This file contains code to call BIOS functions out of a protected
mode environment. It doesn't use the virtual86 mode - it switches
to real mode, make the BIOS call, and switch back to protected
mode again. It's meant to be used in a single-threaded boot loader,
not in a multi-tasking operating system.
It relies on the real mode segment descriptors found in shell.S.
*/
#define FUNCTION(x) .globl x
#define REAL_MODE_STACK 0x9000
// the location of the stack in real mode
#define SAVED_ESP 0x10000
#define SAVED_CR3 0x10004
#define SAVED_EAX 0x10008
#define SAVED_ES 0x1000c
#define SAVED_FLAGS 0x10010
#define SAVED_EBP 0x10014
// we're overwriting the start of our boot loader to hold some
// temporary values - the first 1024 bytes of it are used at
// startup only, and we avoid some linking issues this way
.text
.code32
/*! This function brings you back to protected mode after you've
switched to it using switch_to_real_mode().
Should restore the whole environment to what it looked like
before. Clobbers %eax.
*/
FUNCTION(switch_to_protected_mode)
cli // turn off interrupts
.code16
movl %cr0, %eax // set the PE bit (0) to switch to protected mode
orb $0x1, %al
movl %eax, %cr0
.code32
.byte 0x66 // jump to the protected mode segment
ljmp $0x8, $_protected_code_segment
_protected_code_segment:
movw $0x10, %ax // setup data and stack selectors
movw %ax, %ds
movw %ax, %es
movw %ax, %fs
movw %ax, %gs
movw %ax, %ss
// turn on paging again
movl SAVED_CR3, %eax // restore the saved page directory
orl %eax, %eax // is there a paging directory at all?
jz _no_paging
movl %eax, %cr3
movl %cr0, %eax // set the PG bit (31) to enable paging
orl $0x80000000, %eax
movl %eax, %cr0
_no_paging:
// save the return address so that we can pick it up again later
movl (%esp), %eax
movl %eax, REAL_MODE_STACK
// setup protected stack frame again
movl SAVED_ESP, %eax
movl %eax, %esp
movl SAVED_EBP, %ebp
// copy the return address to the current stack
movl REAL_MODE_STACK, %eax
movl %eax, (%esp)
ret
//--------------------------------------------------------------
/*! Switches from protected mode back to real mode.
It will disable paging and set the real mode segment selectors to 0x1000,
except for the stack selector, which will be 0x0 (the stack is at 0x9000
which is where the BFS boot loader puts it as well).
Clobbers %eax.
*/
FUNCTION(switch_to_real_mode)
// save the %esp register
movl %esp, %eax
movl %eax, SAVED_ESP
movl %ebp, SAVED_EBP
// put the return address on the real mode stack
movl (%esp), %eax
movl %eax, REAL_MODE_STACK
// disable paging
movl %cr3, %eax // save the page directory address
movl %eax, SAVED_CR3
movl %cr0, %eax
andl $0x7fffffff, %eax // clear PG bit (31)
movl %eax, %cr0
xor %eax, %eax // clear page directory to flush TLBs
movl %eax, %cr3
// setup real mode stack
movl $REAL_MODE_STACK, %eax
movl %eax, %esp
movl %eax, %ebp
// setup selectors to point to our 16 bit segments
movw $0x20, %ax
movw %ax, %ds
movw %ax, %es
movw %ax, %fs
movw %ax, %gs
movw $0x28, %ax
movw %ax, %ss
ljmp $0x18, $(_almost_real_code_segment - 0x10000)
_almost_real_code_segment:
movl %cr0, %eax // switch to real mode
andb $0xfe, %al // clear PE bit (0)
movl %eax, %cr0
.byte 0x66
ljmp $0x1000, $(_real_code_segment - 0x10000)
_real_code_segment:
.code16
movw $0x1000, %ax // setup data & stack segments
movw %ax, %ds // data in segment 0x1000,
movw %ax, %es
movw %ax, %fs
movw %ax, %gs
xor %ax, %ax // stack in segment 0x0
movw %ax, %ss
sti // turn on interrupts again
ret
.code32
//--------------------------------------------------------------
/*! void call_bios_internal(uint8 num, struct bios_regs *regs)
Does a BIOS call by triggering a software interrupt in real
mode.
*/
FUNCTION(call_bios_internal)
pushal
pushfl
// make sure the correct IDT is in place
lidt idt_descriptor
// get the interrupt vector and patch the instruction at the target address
movl 40(%esp), %eax
mov %al, int_number
// Fills registers from the passed in structure
// Since switch_to_real_mode() clobbers %eax, we have to handle
// it specially here (by temporarily storing it to an arbitrary
// memory location, SAVED_EAX)
movl 44(%esp), %ebp
movl (%ebp), %eax
movl %eax, SAVED_EAX
movl 4(%ebp), %ebx
movl 8(%ebp), %ecx
movl 12(%ebp), %edx
movl 16(%ebp), %esi
movl 20(%ebp), %edi
movw 24(%ebp), %ax
movw %ax, SAVED_ES
call switch_to_real_mode
.code16
// restore %eax and %es from saved location
movl (SAVED_EAX - 0x10000), %eax
movw (SAVED_ES - 0x10000), %es
// call the interrupt (will be dynamically changed above)
.byte 0xcd
int_number:
.byte 0
// we're interested in the flags state as well
pushf
// save %eax from the call
movl %eax, (SAVED_EAX - 0x10000)
// save flags from the call
pop %ax
movw %ax, (SAVED_FLAGS - 0x10000)
// back to protected mode
call switch_to_protected_mode
.code32
// store the register state into the structure that has been passed in
movl 44(%esp), %eax
movl %ebx, 4(%eax)
movl %ecx, 8(%eax)
movl %edx, 12(%eax)
movl %esi, 16(%eax)
movl %edi, 20(%eax)
movl SAVED_EAX, %ecx // special handling for %eax and flags
movl %ecx, (%eax)
movw SAVED_FLAGS, %cx
movw %cx, 26(%eax)
popfl
popal
ret
//--------------------------------------------------------------
/*! uint32 boot_key_in_keyboard_buffer()
Search keyboard buffer for the keycodes for space in the first run, and,
if not found - for the escape key at the last two positions of this buffer
*/
FUNCTION(boot_key_in_keyboard_buffer)
pushal
pushfl
// make sure the correct IDT is in place
lidt idt_descriptor
call switch_to_real_mode
.code16
cld
push %ds
xorl %eax, %eax
mov %ax, %ds
mov $0x41E, %si // BIOS kbd buffer
search_cycle1:
lodsw
cmp $0x3920, %ax // test space key
jz to_ret
cmp $0x440, %si
jnz search_cycle1
addw 0x41C, %si
movw -0x42(%si), %ax
cmp $0x011B, %ax // test ESC key
jz to_ret
movw -0x44(%si), %ax
cmp $0x011B, %ax // test ESC key
to_ret:
pop %ds
// save %eax
movl %eax, (SAVED_EAX - 0x10000)
call switch_to_protected_mode
.code32
popfl
popal
// restore %eax
movl SAVED_EAX, %eax
ret
//--------------------------------------------------------------
.globl idt_descriptor
idt_descriptor:
.short 0x7ff // IDT at 0x0, default real mode location
.long 0x0
