stage1/stage1.S

/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 1996   Erich Boleyn  <erich@uruk.org>
 *
 *  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.
 */

/*
 *  defines for the code go here
 */

#define SIGNATURE   0xaa55
#define BPBEND      0x3e
#define PARTSTART   0x1be	/* starting address of partition table */
#define PARTEND     0x1fe	/* ending addres of the partition table */
#define MINPARAMSIZ 13		/* size of extra data parameters */
#define LISTSIZ     8		/* size of sector list */
#define REALSTACK   0x2000	/* stack for this code and BIOS calls */
#define BUFFERSEG   0x7000	/* segment address of disk buffer, the
				   disk buffer MUST be 32K long and cannot
				   straddle a 64K boundary */
#define BIOS_HD_FLAG 0x80	/* bit set in BIOS drive number to designate
				   a hard disk vs. a floppy */

	/* Absolute addresses
	   This makes the assembler generate the address without support
	   from the linker. (ELF can't relocate 16bit addresses!) */
#define ABS(x) (x-_start+0x7c00)
	
	/* Relative addresses (for jumps)
	   These macros use the local label 0, so start with your local
	   label at 1! */
#define REL(x)  .word x-0f; 0:
#define RELB(x) .byte x-0f; 0:
	
	/* Print message string
	   movw $x, %cx; call message */
#define MSG(x)	movw $x, %aw; .byte 0xe8; REL(message)

	.file	"stage1.S"

	.text

	/*
	 *  The ".code16" directive only works in GAS, the GNU assembler!
	 *  This adds 32-bit data or addressing directives so that this
	 *  code will work in real mode!
	 */
	.code16

.globl _start; _start:
	/*
	 * _start is loaded at 0x7c00 and is jumped to with CS:IP 0:0x7c00
	 */

	/*
	 * Beginning of the sector is compatible with the FAT/HPFS BIOS
	 * parameter block.
	 */

	/* jmp after_BPB */
	.byte 0xeb; RELB(after_BPB)
	nop	/* do I care about this ??? */

	/*
	 * This space is for the BIOS parameter block!!!!  Don't change
	 * the first jump, nor start the code anywhere but right after
	 * this area.
	 */

	. = _start + 4

	/* scratch space */
sectors:
	.word	0
heads:
	.word	0
cylinders:
	.word	0
	/* more space... */

	. = _start + BPBEND

	/*
	 * End of BIOS parameter block.
	 */

after_BPB:

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

	/* set up %ds and %ss as offset from 0 */
	xorw	%ax, %ax
	movw	%ax, %ds
	movw	%ax, %ss

	/* set up the REAL stack */
	movw	$REALSTACK, %sp

	sti		/* we're safe again */

	/*
	 *  Check if we have a forced disk reference here
	 */
	/* movb	firstlist, %al */
	.byte	0xa0; .word ABS(firstlist)
	cmpb	$0xff, %al
	/* je	1f */
	.byte	0x74; RELB(1f)
	movb	%al, %dl
1:	
	/* save drive reference first thing! */
	pushw	%dx

	/*
	 *  Jump to floppy probe instead of the hard disk probe ?
	 */
	movb	%dl, %al
	andb	$BIOS_HD_FLAG, %al

	/* jz	floppy_probe */
	.byte	0x0f, 0x84; REL(floppy_probe)

	/*
	 *  Determine the hard disk geometry from the BIOS!
	 */
	movb	$8, %ah
	int	$0x13

	/* if BIOS geometry call fails, display error and die! */
	/* jc	hd_probe_error   (16-bit)*/
	.byte	0x0f, 0x82; REL(hd_probe_error)

final_init:
	xorb	%ah, %ah
	movb	%dh, %al
	incw	%ax

	/* movw	%ax, heads */	/* save num heads */
	.byte	0xA3; .word ABS(heads)

	xorw	%dx, %dx
	movb	%cl, %dl
	shlw	$2, %dx
	movb	%ch, %al
	movb	%dh, %ah

	incw	%ax

	/* movw	%ax, cylinders */	/* save num cylinders */
	.byte	0xA3; .word ABS(cylinders)

	xorw	%ax, %ax
	movb	%dl, %al
	shrb	$2, %al

	/* save a byte on addressing by moving this forward ?? */
	movw	$ABS(sectors), %si

	/* movw	%ax, (%si) */	/* save num sectors */
	.byte	0x89, 0x04

	/* this sets up for the first run through "bootloop" */
	movw	$ABS(firstlist), %di


        /* this is the loop for reading the secondary boot-loader in */
bootloop:

	/* update position to load from */
	subw	$LISTSIZ, %di

	/* cmpw	$0, 4(%di) */   /* check the number of sectors to read */
	.byte	0x81, 0x7d, 0x04; .word	0

	/* je	bootit	  (16-bit)*/	/* if zero, go to the start function */
	.byte	0x0f, 0x84; REL(bootit)

	/* movl	(%di), %ax */	/* load logical sector start (bottom half) */
	.byte	0x8b, 0x05

	/* movl	2(%di), %dx */	/* load logical sector start (top half) */
	.byte	0x8b, 0x55, 0x02

	/* divw	(%si), %dx:%ax */	/* divide by number of sectors */
	.byte	0xf7, 0x34

	/* movb	%dl, (%di) */	/* save sector start */
	.byte	0x88, 0x15

	xorw	%dx, %dx	/* zero %dx */
	/* divw	2(%si), %dx:%ax */	/* divide by number of heads */
	.byte	0xf7, 0x74, 0x02

	/* movb	%dl, 1(%di) */	/* save head start */
	.byte	0x88, 0x55, 0x01

	/* movw	%ax, 2(%di) */	/* save cylinder start */
	.byte	0x89, 0x45, 0x02

	/* cmpw	4(%si), %ax */	/* do we need too many cylinders? */
	.byte	0x3b, 0x44, 0x04

	/* jge	geometry_error (16-bit) */
	.byte	0x0f, 0x8d; REL(geometry_error)

setup_sectors:

	/* determine the maximum sector length of this read */
	/* movw	(%si), %ax */	/* get number of sectors per track/head */
	.byte	0x8b, 0x04

	/* subb	(%di), %al */	/* subtract sector start */
	.byte	0x2a, 0x05

	/* how many do we really want to read? */
	/* cmpw	%ax, 4(%di) */	/* compare against total number of sectors */
	.byte	0x39, 0x45, 0x04

	/* jg	more_sectors  (8-bit)*/	/* which is greater? */
	.byte	0x7f; RELB(more_sectors)

	/* movw	4(%di), %ax */	/* if less than, set to total */
	.byte	0x8b, 0x45, 0x04

more_sectors:
	/* subw	%ax, 4(%di) */	/* subtract from total */
	.byte	0x29, 0x45, 0x04

/*
 *  This is the loop for taking care of BIOS geometry translation (ugh!)
 */

	/* movb	3(%di), %dl */	/* get high bits of cylinder */
	.byte	0x8a, 0x55, 0x03

	shlb	$6, %dl		/* shift left by 6 bits */
	/* movw	(%di), %cl */	/* get sector */
	.byte	0x8b, 0x0d

	incb	%cl		/* normalize sector (sectors go
					from 1-N, not 0-(N-1) ) */
	orb	%dl, %cl	/* composite together */
	/* movb	2(%di), %ch */	/* sector+hcyl in cl, cylinder in ch */
	.byte	0x8a, 0x6d, 0x02

	/* restore %dx */
	popw	%dx
	pushw	%dx

	/* movb	1(%di), %dh */	/* head num */
	.byte	0x8a, 0x75, 0x01

	pushw	%ax	/* save %ax from destruction! */

/*
 * BIOS call "INT 0x13 Function 0x2" to read sectors from disk into memory
 *	Call with	%ah = 0x2
 *			%al = number of sectors
 *			%ch = cylinder
 *			%cl = sector (bits 6-7 are high bits of "cylinder")
 *			%dh = head
 *			%dl = drive (0x80 for hard disk, 0x0 for floppy disk)
 *			%es:%bx = segment:offset of buffer
 *	Return:
 *			%al = 0x0 on success; err code on failure
 */

	movw	$BUFFERSEG, %bx
	movw	%bx, %es	/* load %es segment with disk buffer */

	xorw	%bx, %bx	/* %bx = 0, put it at 0 in the segment */
	movb	$0x2, %ah	/* function 2 */
	int	$0x13

	/* jc	read_error */
	.byte	0x72; RELB(read_error)

	movw	%es, %ax
	movw	%ax, %fs	/* load source segment */

	/* load addresses for copy from disk buffer to destination */
	/* movw	6(%di), %es */	/* load destination segment */
	.byte	0x8e, 0x45, 0x06

	/* restore %ax */
	popw	%ax

	/* determine the next possible destination address (presuming
		512 byte sectors!) */
	shlw	$5, %ax		/* shift %ax five bits to the left */
	/* addw	%ax, 6(%di) */	/* add the corrected value to the destination
				   address for next time */
	.byte	0x01, 0x45, 0x06

	/* get the copy length */
	shlw	$4, %ax
	movw	%ax, %cx

	/* save addressing regs */
	pushw	%si
	pushw	%di

	xorw	%di, %di	/* zero offset of destination addresses */
	xorw	%si, %si	/* zero offset of source addresses */
	cld		/* sets the copy direction to forward */

	/* perform copy */
	rep		/* sets a repeat */
	fs		/* this overrides the source segment from %ds to %fs */
	movsb		/* this runs the actual copy */

	/* restore addressing regs */
	popw	%di
	popw	%si

	/* check if finished with this dataset */
	/* cmpw	$0, 4(%di) */
	.byte	0x81, 0x7d, 0x04; .word	0

	/* je	bootloop */
	.byte	0x0f, 0x84; REL(bootloop)

	/* find out the next BIOS set to load in */
	/* movb	$0, (%di) */	/* set the sector start */
	.byte	0xc6, 0x05, 0

	xorb	%ah, %ah	/* zero %ah */
	/* movb	1(%di), %al */	/* load head number into %al */
	.byte	0x8a, 0x45, 0x01

	incw	%ax		/* increment current head number */
	/* cmpw	2(%si), %ax */	/* compare to total number of heads */
	.byte	0x3b, 0x44, 0x02

	/* jne	update_heads   (8-bit)*/
	.byte	0x75; RELB(update_heads)

	/* movw	2(%di), %ax */	/* load cylinder number into %ax */
	.byte	0x8b, 0x45, 0x02

	incw	%ax		/* increment current cylinder number */
	/* cmpw	4(%si), %ax */	/* compare to total number of cylinders */
	.byte	0x3b, 0x44, 0x04

	/* je	geometry_error */	/* display error and die if greater */
	.byte	0x74; RELB(geometry_error)

	/* movw	%ax, 2(%di) */	/* store new cylinder number */
	.byte	0x89, 0x45, 0x02

	movb	$0, %al		/* for storing new head number */

update_heads:
	/* movb	%al, 1(%di) */	/* store new head number */
	.byte	0x88, 0x45, 0x01

	/* jump to "setup_sectors" to determine length of the new read */
	/* jmp	setup_sectors */
	.byte	0xe9; REL(setup_sectors)

/* END OF MAIN LOOP */

/*
 * BIOS Geometry translation error (past the end of the disk geometry!).
 */
geometry_error:
	movw	$geometry_error_string, %si
	/* call message */
	.byte	0xe8; REL(message)
	/* jmp	display_error  (8-bit) */
	.byte	0xeb; RELB(general_error)

/*
 * Disk probe failure.
 */
hd_probe_error:
	movw	$hd_probe_error_string, %si
	/* call message */
	.byte	0xe8; REL(message)
	/* jmp	display_error  (8-bit) */
	.byte	0xeb; RELB(general_error)

/*
 * Read error on the disk.
 */
read_error:
	movw	$read_error_string, %si
	/* call message */
	.byte	0xe8; REL(message)

general_error:
	movw	$general_error_string, %si
	/* call message */
	.byte	0xe8; REL(message)

/* go here when you need to stop the machine hard after an error condition */
stop:	/* jmp	stop  (8-bit) */
	.byte	0xeb; RELB(stop)

geometry_error_string:	.string "Geom"
hd_probe_error_string:	.string "Hard Disk"
read_error_string:	.string "Read"
general_error_string:	.string " Error"

/*
 * message: write the string pointed to by %si
 *
 *   WARNING: trashes %si, %ax, and %bx
 */

	/*
	 * Use BIOS "int 10H Function 0Eh" to write character in teletype mode
	 *	%ah = 0xe	%al = character
	 *	%bh = page	%bl = foreground color (graphics modes)
	 */
1:
	movw	$0x0001, %bx
	movb	$0xe, %ah
	int	$0x10		/* display a byte */

	incw	%si
message:
	/* movb	(%si), %al */
	.byte	0x8a, 0x4
	cmpb	$0, %al
	/* jne	1b */
	.byte	0x75; RELB(1b)	/* if not end of string, jmp to display */

	/* ret */
	.byte	0xc3
lastlist:

/*
 *  This area is an empty space between the main body of code below which
 *  grows up (fixed after compilation, but between releases it may change
 *  in size easily), and the lists of sectors to read, which grows down
 *  from a fixed top location.
 */

        /*
         *  This data area is for keeping general parameters.
         */
	. = _start + PARTSTART - MINPARAMSIZ - LISTSIZ

	/* this next data area before the partition area is specifically
	   sized, you should update "MINPARAMSIZ" to reflect any additions
	   or deletions to this area */

	.word 0
	.word 0

        /* fill the first data listing with the default */
#ifdef  FFS_STAGE1_5
	.long 2		/* this is the sector start parameter, in logical
			   sectors from the start of the disk, sector 0 */
	.word 14	/* this is the number of sectors to read */
	.word 0x0200	/* this is the segment of the starting address
			   to load the data into */
#else
	.long 1		/* this is the sector start parameter, in logical
			   sectors from the start of the disk, sector 0 */
	.word 80	/* this is the number of sectors to read */
	.word 0x0800	/* this is the segment of the starting address
			   to load the data into */
#endif
firstlist:	/* this label has to be after the list data!!! */

	.byte 0xff	/* the disk to load stage2 from */
			/* 0xff means use the boot drive */

	/*
	 *  Jump here when all data loading is done.  This
	 *  goes to the second stage bootloader.
	 */

bootit:
	popw	%dx	/* this makes sure %dl is our "boot" drive */
	/* ljmp	$myoffset, $myseg */
	.byte	0xea
#ifdef  STAGE1_5
	.word	0x2000, 0
#else
	.word	0x8000, 0
#endif

	/*
	 *  This is the compatibility version number.
	 *
	 *  DO NOT MOVE THIS!!!
	 */
	.byte	2, 0

	/*
	 *  This is where an MBR would go if on a hard disk.  The code
	 *  here isn't even referenced unless we're on a floppy.  Kinda
	 *  sneaky, huh?
	 */

	. = _start + PARTSTART

probe_values:
	.byte	36, 18, 15, 9, 0

floppy_probe:
/*
 *  Perform floppy probe.
 */

	movw	$ABS(probe_values-1), %si

probe_loop:
	/* reset floppy controller INT 13h AH=0 */
	xorw	%ax, %ax
	int	$0x13

	incw	%si

	/* movb	  (%si), %cl */
	.byte	0x8a, 0x0c

	/* if number of sectors is 0, display error and die */
	cmpb	$0, %cl

	/* jne	1f  (8-bit) */
	.byte	0x75; RELB(1f)

/*
 * Floppy disk probe failure.
 */
	movw	$fd_probe_error_string, %si
	/* call message */
	.byte	0xe8; REL(message)
	/* jmp	display_error  (16-bit) */
	.byte	0xe9; REL(general_error)

fd_probe_error_string:	.string "Floppy"

1:
	/* perform read */
	movw	$REALSTACK, %bx
	movw	$0x201, %ax
	movb	$0, %ch
	movb	$0, %dh
	int	$0x13

	/* if error, jump to "probe_loop" */
	/* jc probe_loop	(8-bit)*/
	.byte	0x72; RELB(probe_loop)

	/* %cl is already the correct value! */
	movb	$1, %dh
	movb	$79, %ch

	/* jmp	final_init */
	.byte	0xe9; REL(final_init)

	. = _start + PARTEND

/* the last 2 bytes in the sector 0 contain the signature */
	.word	SIGNATURE