/*
 * 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 ; 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