/*

 *  GRUB  --  GRand Unified Bootloader

 *  Copyright (C) 1999,2000,2001,2002,2004 Free Software Foundation, Inc.

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

/*

 * Note: These functions defined in this file may be called from C.

 *       Be careful of that you must not modify some registers. Quote

 *       from gcc-2.95.2/gcc/config/i386/i386.h:

   1 for registers not available across function calls.

   These must include the FIXED_REGISTERS and also any

   registers that can be used without being saved.

   The latter must include the registers where values are returned

   and the register where structure-value addresses are passed.

   Aside from that, you can include as many other registers as you like.

  ax,dx,cx,bx,si,di,bp,sp,st,st1,st2,st3,st4,st5,st6,st7,arg

{  1, 1, 1, 0, 0, 0, 0, 1, 1,  1,  1,  1,  1,  1,  1,  1,  1 }

 */

#define ASM_FILE

#include "shared.h"

#ifdef STAGE1_5

# define	ABS(x)	((x) - EXT_C(main) + 0x2200)

#else

# define	ABS(x)	((x) - EXT_C(main) + 0x8200)

#endif

	.file	"asm.S"

	.text

	/* Tell GAS to generate 16-bit instructions so that this code works

	   in real mode. */

	.code16

#ifndef STAGE1_5

	/* 

	 * In stage2, do not link start.S with the rest of the source

	 * files directly, so define the start symbols here just to

	 * force ld quiet. These are not referred anyway.

	 */

	.globl	start, _start

start:

_start:

#endif /* ! STAGE1_5 */

ENTRY(main)

	/*

	 *  Guarantee that "main" is loaded at 0x0:0x8200 in stage2 and

	 *  at 0x0:0x2200 in stage1.5.

	 */

	ljmp $0, $ABS(codestart)

	/*

	 *  Compatibility version number

	 *

	 *  These MUST be at byte offset 6 and 7 of the executable

	 *  DO NOT MOVE !!!

	 */

	. = EXT_C(main) + 0x6

	.byte	COMPAT_VERSION_MAJOR, COMPAT_VERSION_MINOR

	/*

	 *  This is a special data area 8 bytes from the beginning.

	 */

	. = EXT_C(main) + 0x8

VARIABLE(install_partition)

	.long	0xFFFFFF

/* This variable is here only because of a historical reason.  */

VARIABLE(saved_entryno)

	.long	0

VARIABLE(stage2_id)

	.byte	STAGE2_ID

VARIABLE(force_lba)

	.byte	0

VARIABLE(version_string)

	.string VERSION

VARIABLE(config_file)

#ifndef STAGE1_5

	.string "/boot/grub/menu.lst"

#else   /* STAGE1_5 */

	.long	0xffffffff

	.string "/boot/grub/stage2"

#endif  /* STAGE1_5 */

	/*

	 *  Leave some breathing room for the config file name.

	 */

	. = EXT_C(main) + 0x70

/* the real mode code continues... */

codestart:

	cli		/* we're not safe here! */

	/* set up %ds, %ss, and %es */

	xorw	%ax, %ax

	movw	%ax, %ds

	movw	%ax, %ss

	movw	%ax, %es

#ifndef SUPPORT_DISKLESS

	/*

	 * Save the sector number of the second sector (i.e. this sector)

	 * in INSTALL_SECOND_SECTOR. See also "stage2/start.S".

	 */

	ADDR32	movl	%ebp, EXT_C(install_second_sector)

#endif

	/* set up the real mode/BIOS stack */

	movl	$STACKOFF, %ebp

	movl	%ebp, %esp

	sti		/* we're safe again */

#ifndef SUPPORT_DISKLESS

	/* save boot drive reference */

	ADDR32	movb	%dl, EXT_C(boot_drive)

	/* reset disk system (%ah = 0) */

	int	$0x13

#endif

	/* transition to protected mode */

	DATA32	call EXT_C(real_to_prot)

	/* The ".code32" directive takes GAS out of 16-bit mode. */

	.code32

	/* clean out the bss */

	/* set %edi to the bss starting address */

#if defined(HAVE_USCORE_USCORE_BSS_START_SYMBOL)

	movl	$__bss_start, %edi

#elif defined(HAVE_USCORE_EDATA_SYMBOL)

	movl	$_edata, %edi

#elif defined(HAVE_EDATA_SYMBOL)

	movl	$edata, %edi

#endif

	/* set %ecx to the bss end */	

#if defined(HAVE_END_SYMBOL)

	movl	$end, %ecx

#elif defined(HAVE_USCORE_END_SYMBOL)

	movl	$_end, %ecx

#endif

	/* compute the bss length */

	subl	%edi, %ecx

	/* zero %al */

	xorb	%al, %al

	/* set the direction */

	cld

	/* clean out */

	rep

	stosb

	/*

	 *  Call the start of main body of C code, which does some

	 *  of it's own initialization before transferring to "cmain".

	 */

	call EXT_C(init_bios_info)

/*

 *  This call is special...  it never returns...  in fact it should simply

 *  hang at this point!

 */

ENTRY(stop)

	call	EXT_C(prot_to_real)

	/*

	 * This next part is sort of evil.  It takes advantage of the

	 * byte ordering on the x86 to work in either 16-bit or 32-bit

	 * mode, so think about it before changing it.

	 */

ENTRY(hard_stop)

	hlt

	jmp EXT_C(hard_stop)

#ifndef STAGE1_5

/**************************************************************************

UNDI_CALL - wrapper around real-mode UNDI API calls

**************************************************************************/

ENTRY(__undi_call)

       pushl   %ebp

       movl    %esp,%ebp

       pushl   %esi

       pushl   %edi

       pushl   %ebx

       movw    8(%ebp),%cx     /* Seg:off addr of undi_call_info_t struct */

       movw    12(%ebp),%dx    /* Pass to 16-bit code in %cx:%dx */

       call EXT_C(prot_to_real)

       .code16

       movw    %cx,%es         /* Seg:off addr of undi_call_info_t struct */

       movw    %dx,%bx         /* into %es:%bx */

       movw    %es:8(%bx),%ax  /* Transfer contents of undi_call_info_t */

       pushw   %ax             /* structure to the real-mode stack */

       movw    %es:6(%bx),%ax

       pushw   %ax

       movw    %es:4(%bx),%ax

       pushw   %ax

       lcall   *%es:0(%bx)     /* Do the UNDI call */

       cld                     /* Don't know whether or not we need this */

                               /* but pxelinux includes it for some reason, */

                               /* so we put it in just in case. */

       popw    %cx             /* Tidy up the stack */

       popw    %cx

       popw    %cx

       movw    %ax,%cx         /* Return %ax via %cx */

       DATA32 call EXT_C(real_to_prot)

       .code32

       xorl    %eax,%eax       /* %ax is returned via %cx */

       movw    %cx,%ax

       popl    %ebx

       popl    %edi

       popl	%esi

       popl	%ebp

       ret

/**************************************************************************

UNDI_IRQ_HANDLER - UNDI IRQ handler: calls PXENV_UNDI_ISR and send EOI

NOTE: For some reason, this handler needs to be aligned. Else, the

	undi driver won't get the trigger count on some platforms.

**************************************************************************/

	.align 4

ENTRY(_undi_irq_handler)

	.code16

	pushw	%ax

	pushw	%bx

	pushw	%cx

	call	1f		/* Position-independent access to */

1:	popw	%bx		/* various locations.		  */

	pushw	%bx		/* save for after UNDI call */

	/* set funcflag to PXENV_UNDI_ISR_IN_START */

	movw	$1,%cs:(pxenv_undi_isr-1b+2)(%bx)

	/* push pxenv_undi_isr struct on stack */

	movl	$(ABS(pxenv_undi_isr)),%eax

	movw	%ax,%cx

	shrl	$4,%eax		/* get segment */

	pushw	%ax

	andw	$0xf,%cx	/* get offset */

	pushw	%cx

	movw    $0x14,%ax	/* opcode PXENV_UNDI_ISR */

	pushw   %ax

	lcall   *%cs:(pxenv_entrypointsp-1b)(%bx)	/* Do the UNDI call */

	cld                     /* Don't know whether or not we need this */

				/* but pxelinux includes it for some reason, */

				/* so we put it in just in case. */

	popw    %cx             /* Tidy up the stack */

	popw    %cx

	popw    %cx

	popw	%bx		/* restore old position reg */

	cmpw	$0,%ax		/* did the UNDI call succeed? */

	jne	3f

	movw	%cs:(pxenv_undi_isr-1b+2)(%bx),%ax

	cmpw	$0,%ax		/* is this our interrupt? */

	jne	3f

	/* send EOI -- non specific for now */

	movw	$0x20,%ax		/* ICR_EOI_NON_SPECIFIC */

	movb	%cs:(pxenv_undi_irq-1b),%cl

	cmpb	$8,%cl

	jg	2f

	outb	$0xa0			/* PIC2_ICR */

2:	outb	$0x20			/* PIC1_ICR */

	/* increment trigger count */

	incw	%cs:(EXT_C(_undi_irq_trigger_count)-1b)(%bx)

	/* restore other registers */

3:	popw	%cx

	popw	%bx

	popw	%ax

	iret

ENTRY(_undi_irq_trigger_count)

undi_irq_trigger_count:

	.word	0

ENTRY(_undi_irq_chain_to)

	.long	0

ENTRY(_undi_irq_chain)

	.byte	0

ENTRY(_pxenv_undi_irq)

pxenv_undi_irq:

	.byte	0

ENTRY(_pxenv_undi_entrypointsp)

pxenv_entrypointsp:

	.word	0	/* offset */

	.word	0	/* segment */

pxenv_undi_isr:

	.word	0	/* status */

	.word	0	/* funcflag */

	.long	0	/* struct padding not used by ISR */

	.long	0

	.long	0

	.code32

/*

 * stop_floppy()

 *

 * Stops the floppy drive from spinning, so that other software is

 * jumped to with a known state.

 */

ENTRY(stop_floppy)

	pusha

	call	EXT_C(prot_to_real)

	.code16

	xorb	%dl, %dl

	int	$0x13

	DATA32  call EXT_C(real_to_prot)

	.code32

	popa

	ret

/*

 * grub_reboot()

 *

 * Reboot the system. At the moment, rely on BIOS.

 */

ENTRY(grub_reboot)

	call	EXT_C(prot_to_real)

	.code16

	/* cold boot */

	movw	$0x0472, %di

	movw	%ax, (%di)

	ljmp	$0xFFFF, $0x0000

	.code32

/*

 * grub_halt(int no_apm)

 *

 * Halt the system, using APM if possible. If NO_APM is true, don't use

 * APM even if it is available.

 */

ENTRY(grub_halt)

	/* get the argument */

	movl	4(%esp), %eax

	/* see if zero */

	testl	%eax, %eax

	jnz	EXT_C(stop)

	call	EXT_C(prot_to_real)

	.code16

	/* detect APM */

	movw	$0x5300, %ax

	xorw	%bx, %bx

	int	$0x15

	jc	EXT_C(hard_stop)

	/* don't check %bx for buggy BIOSes... */

	/* disconnect APM first */

	movw	$0x5304, %ax

	xorw	%bx, %bx

	int	$0x15

	/* connect APM */

	movw	$0x5301, %ax

	xorw	%bx, %bx

	int	$0x15

	jc	EXT_C(hard_stop)

	/* set APM protocol level - 1.1 or bust. (this covers APM 1.2 also) */

	movw	$0x530E, %ax

	xorw	%bx, %bx

	movw	$0x0101, %cx

	int	$0x15

	jc	EXT_C(hard_stop)

	/* set the power state to off */

	movw	$0x5307, %ax

	movw	$1, %bx

	movw	$3, %cx

	int	$0x15

	/* shouldn't reach here */

	jmp	EXT_C(hard_stop)

	.code32

/*

 * track_int13(int drive)

 *

 * Track the int13 handler to probe I/O address space.

 */

ENTRY(track_int13)

	pushl	%ebp

	movl	%esp, %ebp

	pushl	%ebx

	pushl	%edi

	/* copy the original int13 handler segment:offset */

	movl	$0x4c, %edi

	movl	(%edi), %eax

	movl	%eax, track_int13_addr

	/* replace the int1 handler */

	movl	$0x4, %edi

	pushl	(%edi)

	movl	$ABS(int1_handler), %eax

	movl	%eax, (%edi)

	/* read the MBR to call int13 successfully */

	movb	8(%ebp), %dl

	call	EXT_C(prot_to_real)

	.code16

	movw	$SCRATCHSEG, %ax

	movw	%ax, %es

	xorw	%bx, %bx

	movw	$1, %cx

	xorb	%dh, %dh

	/* save FLAGS on the stack to emulate int13 */

	pushfw

	/* set the TF flag */

	/* FIXME: this can be simplified not to use AX */

	pushfw

	popw	%ax

	orw	$0x100, %ax

	pushw	%ax

	popfw

	movw	$0x0201, %ax

	.byte	0x9a		/* lcall */

track_int13_addr:

	.word	0		/* offset */

	.word	0		/* segment */

	/* TF is cleared here automatically */

	DATA32	call	EXT_C(real_to_prot)

	.code32

	/* restore the int1 handler */

	movl	$0x4, %edi

	popl	(%edi)

	popl	%edi

	popl	%ebx

	popl	%ebp

	ret

/*

 * Check if the next instruction is I/O, and if this is true, add the

 * port into the io map.

 *

 * Note: Probably this will make the execution of int13 very slow.

 *

 * Note2: In this implementation, all we can know is I/O-mapped I/O. It

 * is impossible to detect memory-mapped I/O.

 */

int1_handler:

	.code16

	pushw	%bp

	movw	%sp, %bp

	pushw	%ds

	pushw	%ax

	pushw	%si

	pushw	%dx

	/* IP */

	movw	2(%bp), %si

	/* CS */

	movw	4(%bp), %ax

	movw	%ax, %ds

	/* examine the next instruction */

1:	lodsb	(%si), %al

	/* skip this code if it is a prefix */

	cmpb	$0x2E, %al

	je	1b

	cmpb	$0x36, %al

	je	1b

	cmpb	$0x3E, %al

	je	1b

	cmpb	$0x26, %al

	je	1b

	cmpb	$0x64, %al