i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed some unused code. not finished yet

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@18997 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Marcus Overhagen
2006-10-04 23:11:30 +00:00
parent f974492c2d
commit 5fc3827fb4
1 changed files with 11 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/system/boot/platform/pxe_ia32/pxe_stage2.S
+11 -297
View File
@@ -1,264 +1,31 @@
/*
* Copyright 2004-2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
* Copyright 2006, Marcus Overhagen, marcus@overhagen.de. All rights reserved.
* Distributed under the terms of the MIT License.
*/
/** This file contains the boot floppy and BFS boot block entry points for
* the stage 2 boot loader.
* The floppy entry point is at offset 0. It's loaded at 0x07c0:0x000. It
* will load the rest of the loader to 0x1000:0x0200 and execute it.
* The BFS boot block will load the whole stage 2 loader to 0x1000:0x0000
* and will then jump to 0x1000:0x0200 as its entry point.
/** This file contains the stage 2 boot loader for the PXE (preboot execution
* environment) image.
* It gets loaded by the PXE stage1 loader to 0xffff:0010 (0x100000), and is
* starts execution in 16 bit real mode. Entry point is at offset 0.
* This code will then switch to protected mode and will directly call
* the entry function of the embedded ELF part of the loader.
*/
#define GLOBAL(x) .globl x ; x
// this saves us some trouble with relocation (I didn't manage GAS to
// create 32 bit references to labels)
#define FAILURE_STRING 0x1d0
#define DOT_STRING 0x1fc
#define DRIVE_RETRIES 3
// when the drive reading fails for some reason, it will
// retry this many times until it will report a failure
.text
.code16
/** This is the entry point when we were written directly to a floppy disk */
jmp floppy_start
sNumSectors:
// this location will contain the length of the boot loader as
// written by the "makeflop" command in 512 byte blocks
// 0x180 is the allowed maximum, as the zipped TAR with the
// kernel and the boot module might start at offset 192 kB
.word 0x0180
floppy_start:
pxe_start:
cli
cld
// set up the stack to 0x0000:0x9000
xor %ax, %ax
mov %ax, %ss
mov $0x9000, %sp
push $0x07c0
pop %ds
push $0x1000
pop %es
// load the rest of the boot loader to 0x1000:0x0200
.code32 // we need to create a 32-bit relocation entry for the linker...
.byte 0x67
movw sNumSectors - 0x10000, %di
// the loader symbols are located at offset 0x10000
.code16
xor %dh, %dh // head 0, don't change BIOS boot device
mov $0x2, %cx // sector 2
mov $0x200, %bx // to 0x1000:0x0200
call load_sectors
// ToDo: this seems to be problematic, at least under Bochs (reboot will fail)
#if 0
or %dl, %dl // if it's a floppy, turn off its motor
jnz start_loader
call disable_floppy_motor
#endif
start_loader:
// indicate that we were booted from CD/floppy/whatever
.code32
.byte 0x67
movb $1, gBootedFromImage - 0x7c00
// %ds is 0x7c0 right now, but the symbol were loaded
// to offset 0x10000
.code16
// set our environment and jump to the standard BFS boot block entry point
xor %dx, %dx // boot device ID and partition offset to 0
xor %eax, %eax
ljmp $0x1000, $0x0200
/** Loads %di sectors from floppy disk, starting at head %dh, sector %cx.
* The data is loaded to %es:%bx. On exit, %es:%bx will point immediately
* behind the loaded data, so that you can continue to read in data.
* %ax, %cx, %dx, %bp, %di and %si will be clobbered.
*/
load_sectors:
// first, get information about the drive as we intend to read whole tracks
push %bx
push %cx
push %dx
push %di
push %es
movb $8, %ah // get drive parameters - changes a lot of registers
int $0x13
pop %es
pop %di
// ToDo: store the number of heads somewhere (it's in %dh)
pop %dx
and $63, %cx // mask out max. sector number (bit 0-5)
mov %cx, %si // and remember it
pop %cx
pop %bx
load_track:
mov %di, %ax // limit the sector count to track boundaries
add %cl, %al
dec %ax
cmp %si, %ax
jbe matches_track_boundary
mov %si, %ax
matches_track_boundary:
inc %ax // take the current sector offset into account
sub %cl, %al
// make sure we don't cross a 64kB address boundary or else the read will fail
// (this small piece of knowledge took me some time to accept :))
shl $9, %ax
mov %ax, %bp
add %bx, %bp
jnc respects_boundary
xor %ax, %ax // only read up to the 64kB boundary
sub %bx, %ax
respects_boundary:
shr $9, %ax
mov DRIVE_RETRIES, %bp
try_to_read:
pusha
movb $2, %ah // load sectors from drive
int $0x13
jnc read_succeeded
xor %ax, %ax
int $0x13 // reset drive
popa
dec %bp
jz load_failed // if already retried often enough, bail out
jmp try_to_read
read_succeeded:
mov $DOT_STRING, %si
call print_string
popa
xor %ah, %ah
add %ax, %cx // next sector start
sub %ax, %di // update sectors left to be read
shl $9, %ax // get byte offset
add %ax, %bx // update target address
jnz check_sector_start
mov %es, %ax // overflow to the next 64kB, %bx is already zero
add $0x1000, %ax
mov %ax, %es
check_sector_start:
mov %si, %ax // compare the sectors, not the cylinders
cmp %al, %cl
jbe continue_reading
sub %si, %cx
inc %dh // next head
cmp $1, %dh
// ToDo: check max. number of heads!
jbe check_sector_start
xor %dh, %dh // next cylinder
inc %ch
jmp check_sector_start
continue_reading:
or %di, %di
jnz load_track
ret
load_failed:
mov $FAILURE_STRING, %si
call print_string
xor %ax, %ax
int $0x16 // wait for key
int $0x19 // and reboot
disable_floppy_motor:
xor %al, %al
mov $0x3f2, %dx
out %al, %dx
ret
print_string:
movb $0x0e, %ah
xor %bx, %bx
print_char:
lodsb
orb %al, %al // are there still characters left?
jz no_more_chars
int $0x10
jmp print_char
no_more_chars:
ret
floppy_end:
.org FAILURE_STRING
.string " Loading failed! Press key to reboot.\r\n"
.org DOT_STRING
.string "."
.org 0x01fe
.word 0xaa55
// this bumps the "start" label to offset 0x0200 as
// expected by the BFS boot loader, and also marks
// this block as valid boot block for the BIOS
//--------------------------------------------------------------
/** This is the entry point of the stage2 bootloader when it has
* been loaded from the stage1 loader from a BFS disk.
*/
bfs_start:
cld // set the data, and extra segment to our code start
pushw $0x1000
pop %ds
push %ds
pop %es
.code32 // save knowledge from the BFS boot block for later use
.byte 0x67
movb %dl, gBootDriveID - 0x10000
.byte 0x67
.byte 0x66
movl %eax, gBootPartitionOffset - 0x10000
.code16
xor %ax, %ax // set up stack at 0x0000:0x9000
mov %ax, %ss
mov $0x9000, %sp
cli // no interrupts please
call enable_a20 // enable a20 gate
.code32 // This forces a 32 bit relocation entry
.byte 0x66 // that allows linking with others
.byte 0x67
lgdt gdt_descriptor - 0x10000
// load global descriptor table; we're still in real mode segment
// 0x1000 so we have to manually correct the address
lgdt gdt_descriptor + 0x100000
.code16
movl %cr0, %eax // set the PE bit of cr0 to switch to protected mode
@@ -283,60 +50,9 @@ _protected_code_segment:
//--------------------------------------------------------------
/** Enables the a20 gate. It will first try to enable it through
* the BIOS, and, if that fails, will use the old style AT mechanism
* using the keyboard port.
* ToDo: it no longer does this! Now, it just uses the "fast A20"
* mechanism using port 0x92. This does work on all systems
* I have access to.
*/
enable_a20:
inb $0x92, %al
testb $0x02, %al
jnz _a20_out
orb $0x02, %al
andb $0xfe, %al
outb %al, $0x92
_a20_out:
ret
// ToDo: the code below didn't seem to work properly on all machines
/* movw $0x2402, %ax // first, query the a20 status
int $0x15
jc _a20_old_method // if that fails, use the old AT method
test $0x1, %al
jnz _a20_done // Is a20 gate already enabled?
movw $0x2401, %ax
int $0x15
jnc _a20_done
_a20_old_method:
call _a20_loop1 // empty the keyboard buffer
jnz _a20_done
movb $0xd1, %al
outb %al, $0x64
call _a20_loop1 // empty the keyboard buffer
jnz _a20_done
movb $0xdf, %al
outb %al, $0x60
_a20_loop1:
movl $0x20000, %ecx
_a20_loop2:
inb $0x64, %al
test $0x2, %al
loopne _a20_loop2
_a20_done:
ret
*/
//--------------------------------------------------------------
.org 896
// since we don't need the above space when the boot loader is
// running, it is used as a real mode scratch buffer (as our
// boot loader spans over the whole real mode 0x1000 segment)
/* global data table */
.balign 8
gdt:
// null descriptor
@@ -365,12 +81,10 @@ gdt_descriptor:
.long gdt
GLOBAL(gBootedFromImage):
.byte 0
.byte 1
GLOBAL(gBootDriveID):
.byte 0
.byte 0xff
GLOBAL(gBootPartitionOffset):
.long 0
.org 1024
.long 0xffffffff