From 5fc3827fb48467288c7df289e2fd80d451d7e0d0 Mon Sep 17 00:00:00 2001 From: Marcus Overhagen Date: Wed, 4 Oct 2006 23:11:30 +0000 Subject: [PATCH] removed some unused code. not finished yet git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@18997 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- .../boot/platform/pxe_ia32/pxe_stage2.S | 308 +----------------- 1 file changed, 11 insertions(+), 297 deletions(-) diff --git a/src/system/boot/platform/pxe_ia32/pxe_stage2.S b/src/system/boot/platform/pxe_ia32/pxe_stage2.S index ff3130fb69..bb1b516534 100644 --- a/src/system/boot/platform/pxe_ia32/pxe_stage2.S +++ b/src/system/boot/platform/pxe_ia32/pxe_stage2.S @@ -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