Newer versions of the GNU assembler (observed with binutils 2.41) will complain about the ".arch i386" in files assembled with "as --64", with the message "Error: 64bit mode not supported on 'i386'". In files such as stack.S that contain no instructions to be assembled, the ".arch i386" is redundant and may be removed entirely. In the remaining files, fix by moving ".arch i386" below the relevant ".code16" or ".code32" directive, so that the assembler is no longer expecting 64-bit instructions to be used by the time that the ".arch i386" directive is encountered. Reported-by: Ali Mustakim <alim@forwardcomputers.com> Signed-off-by: Michael Brown <mcb30@ipxe.org>
861 lines
20 KiB
ArmAsm
861 lines
20 KiB
ArmAsm
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
|
|
|
|
#define PXENV_UNDI_SHUTDOWN 0x0005
|
|
#define PXENV_UNDI_GET_NIC_TYPE 0x0012
|
|
#define PXENV_UNDI_GET_IFACE_INFO 0x0013
|
|
#define PXENV_STOP_UNDI 0x0015
|
|
#define PXENV_UNLOAD_STACK 0x0070
|
|
#define PXENV_GET_CACHED_INFO 0x0071
|
|
#define PXENV_PACKET_TYPE_DHCP_ACK 0x0002
|
|
#define PXENV_FILE_CMDLINE 0x00e8
|
|
|
|
#define PXE_HACK_EB54 0x0001
|
|
|
|
.section ".note.GNU-stack", "", @progbits
|
|
.code16
|
|
.arch i386
|
|
.org 0
|
|
|
|
#include <librm.h>
|
|
#include <undi.h>
|
|
|
|
#define STACK_MAGIC ( 'L' + ( 'R' << 8 ) + ( 'E' << 16 ) + ( 'T' << 24 ) )
|
|
#define EB_MAGIC_1 ( 'E' + ( 't' << 8 ) + ( 'h' << 16 ) + ( 'e' << 24 ) )
|
|
#define EB_MAGIC_2 ( 'r' + ( 'b' << 8 ) + ( 'o' << 16 ) + ( 'o' << 24 ) )
|
|
|
|
/* Prefix memory layout:
|
|
*
|
|
* iPXE binary image
|
|
* Temporary stack
|
|
* Temporary copy of DHCPACK packet
|
|
* Temporary copy of command line
|
|
*/
|
|
#define PREFIX_STACK_SIZE 2048
|
|
#define PREFIX_TEMP_DHCPACK PREFIX_STACK_SIZE
|
|
#define PREFIX_TEMP_DHCPACK_SIZE ( 1260 /* sizeof ( BOOTPLAYER_t ) */ )
|
|
#define PREFIX_TEMP_CMDLINE ( PREFIX_TEMP_DHCPACK + PREFIX_TEMP_DHCPACK_SIZE )
|
|
#define PREFIX_TEMP_CMDLINE_SIZE 4096
|
|
|
|
/*****************************************************************************
|
|
* Entry point: set operating context, print welcome message
|
|
*****************************************************************************
|
|
*/
|
|
.section ".prefix", "ax", @progbits
|
|
.globl _pxe_start
|
|
_pxe_start:
|
|
jmp $0x7c0, $1f
|
|
1:
|
|
/* Preserve registers for possible return to PXE */
|
|
pushfl
|
|
pushal
|
|
pushw %gs
|
|
pushw %fs
|
|
pushw %es
|
|
pushw %ds
|
|
|
|
/* Store magic word on PXE stack and remember PXE %ss:esp */
|
|
pushl $STACK_MAGIC
|
|
movw %ss, %cs:pxe_ss
|
|
movl %esp, %cs:pxe_esp
|
|
|
|
/* Set up segments */
|
|
movw %cs, %ax
|
|
movw %ax, %ds
|
|
movw $0x40, %ax /* BIOS data segment access */
|
|
movw %ax, %fs
|
|
/* Set up temporary stack immediately after the iPXE image */
|
|
movw %cs, %ax
|
|
addw image_size_pgh, %ax
|
|
movw %ax, %ss
|
|
movl $PREFIX_STACK_SIZE, %esp
|
|
/* Clear direction flag, for the sake of sanity */
|
|
cld
|
|
/* Print welcome message */
|
|
movw $10f, %si
|
|
xorw %di, %di
|
|
call print_message
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz "PXE->EB:"
|
|
.previous
|
|
|
|
/* Image size (for stack placement calculation) */
|
|
.section ".prefix.data", "aw", @progbits
|
|
image_size_pgh:
|
|
.word 0
|
|
.previous
|
|
.section ".zinfo.fixup", "a", @progbits /* Compressor fixups */
|
|
.ascii "ADDW"
|
|
.long image_size_pgh
|
|
.long 16
|
|
.long 0
|
|
.previous
|
|
|
|
/*****************************************************************************
|
|
* Find us a usable !PXE or PXENV+ entry point
|
|
*****************************************************************************
|
|
*/
|
|
detect_pxe:
|
|
/* Plan A: !PXE pointer from the stack */
|
|
lgsl pxe_esp, %ebp /* %gs:%bp -> original stack */
|
|
lesw %gs:52(%bp), %bx
|
|
call is_valid_ppxe
|
|
je have_ppxe
|
|
|
|
/* Plan B: PXENV+ pointer from initial ES:BX */
|
|
movw %gs:32(%bp),%bx
|
|
movw %gs:8(%bp),%es
|
|
call is_valid_pxenv
|
|
je have_pxenv
|
|
|
|
/* Plan C: PXENV+ structure via INT 1Ah */
|
|
movw $0x5650, %ax
|
|
int $0x1a
|
|
jc 1f
|
|
cmpw $0x564e, %ax
|
|
jne 1f
|
|
call is_valid_pxenv
|
|
je have_pxenv
|
|
1:
|
|
/* Plan D: scan base memory for !PXE */
|
|
call memory_scan_ppxe
|
|
je have_ppxe
|
|
|
|
/* Plan E: scan base memory for PXENV+ */
|
|
call memory_scan_pxenv
|
|
jne stack_not_found
|
|
|
|
have_pxenv:
|
|
movw %bx, pxenv_offset
|
|
movw %es, pxenv_segment
|
|
|
|
cmpw $0x201, %es:6(%bx) /* API version >= 2.01 */
|
|
jb 1f
|
|
cmpb $0x2c, %es:8(%bx) /* ... and structure long enough */
|
|
jb 2f
|
|
|
|
lesw %es:0x28(%bx), %bx /* Find !PXE from PXENV+ */
|
|
call is_valid_ppxe
|
|
je have_ppxe
|
|
2:
|
|
call memory_scan_ppxe /* We are *supposed* to have !PXE... */
|
|
je have_ppxe
|
|
1:
|
|
lesw pxenv_segoff, %bx /* Nope, we're stuck with PXENV+ */
|
|
|
|
/* Record entry point and UNDI segments */
|
|
pushl %es:0x0a(%bx) /* Entry point */
|
|
pushw %es:0x24(%bx) /* UNDI code segment */
|
|
pushw %es:0x26(%bx) /* UNDI code size */
|
|
pushw %es:0x20(%bx) /* UNDI data segment */
|
|
pushw %es:0x22(%bx) /* UNDI data size */
|
|
|
|
/* Print "PXENV+ at <address>" */
|
|
movw $10f, %si
|
|
jmp check_have_stack
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " PXENV+ at "
|
|
.previous
|
|
|
|
have_ppxe:
|
|
movw %bx, ppxe_offset
|
|
movw %es, ppxe_segment
|
|
|
|
pushl %es:0x10(%bx) /* Entry point */
|
|
pushw %es:0x30(%bx) /* UNDI code segment */
|
|
pushw %es:0x36(%bx) /* UNDI code size */
|
|
pushw %es:0x28(%bx) /* UNDI data segment */
|
|
pushw %es:0x2e(%bx) /* UNDI data size */
|
|
|
|
/* Print "!PXE at <address>" */
|
|
movw $10f, %si
|
|
jmp check_have_stack
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " !PXE at "
|
|
.previous
|
|
|
|
is_valid_ppxe:
|
|
cmpl $0x45585021, %es:(%bx)
|
|
jne 1f
|
|
movzbw %es:4(%bx), %cx
|
|
cmpw $0x58, %cx
|
|
jae is_valid_checksum
|
|
1:
|
|
ret
|
|
|
|
is_valid_pxenv:
|
|
cmpl $0x4e455850, %es:(%bx)
|
|
jne 1b
|
|
cmpw $0x2b56, %es:4(%bx)
|
|
jne 1b
|
|
movzbw %es:8(%bx), %cx
|
|
cmpw $0x28, %cx
|
|
jb 1b
|
|
|
|
is_valid_checksum:
|
|
pushw %ax
|
|
movw %bx, %si
|
|
xorw %ax, %ax
|
|
2:
|
|
es lodsb
|
|
addb %al, %ah
|
|
loopw 2b
|
|
popw %ax
|
|
ret
|
|
|
|
memory_scan_ppxe:
|
|
movw $is_valid_ppxe, %dx
|
|
jmp memory_scan_common
|
|
|
|
memory_scan_pxenv:
|
|
movw $is_valid_pxenv, %dx
|
|
|
|
memory_scan_common:
|
|
movw %fs:(0x13), %ax
|
|
shlw $6, %ax
|
|
decw %ax
|
|
1: incw %ax
|
|
cmpw $( 0xa000 - 1 ), %ax
|
|
ja 2f
|
|
movw %ax, %es
|
|
xorw %bx, %bx
|
|
call *%dx
|
|
jne 1b
|
|
2: ret
|
|
|
|
/*****************************************************************************
|
|
* Sanity check: we must have an entry point
|
|
*****************************************************************************
|
|
*/
|
|
check_have_stack:
|
|
/* Save common values pushed onto the stack */
|
|
popl undi_data_segoff
|
|
popl undi_code_segoff
|
|
popl entry_segoff
|
|
|
|
/* Print have !PXE/PXENV+ message; structure pointer in %es:%bx */
|
|
call print_message
|
|
call print_segoff
|
|
movb $( ',' ), %al
|
|
call print_character
|
|
|
|
/* Check for entry point */
|
|
movl entry_segoff, %eax
|
|
testl %eax, %eax
|
|
jnz 99f
|
|
/* No entry point: print message and skip everything else */
|
|
stack_not_found:
|
|
movw $10f, %si
|
|
call print_message
|
|
jmp finished
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " No PXE stack found!\n"
|
|
.previous
|
|
99:
|
|
|
|
/*****************************************************************************
|
|
* Calculate base memory usage by UNDI
|
|
*****************************************************************************
|
|
*/
|
|
find_undi_basemem_usage:
|
|
movw undi_code_segment, %ax
|
|
movw undi_code_size, %bx
|
|
movw undi_data_segment, %cx
|
|
movw undi_data_size, %dx
|
|
cmpw %ax, %cx
|
|
ja 1f
|
|
xchgw %ax, %cx
|
|
xchgw %bx, %dx
|
|
1: /* %ax:%bx now describes the lower region, %cx:%dx the higher */
|
|
shrw $6, %ax /* Round down to nearest kB */
|
|
movw %ax, undi_fbms_start
|
|
addw $0x0f, %dx /* Round up to next segment */
|
|
shrw $4, %dx
|
|
addw %dx, %cx
|
|
addw $((1024 / 16) - 1), %cx /* Round up to next kB */
|
|
shrw $6, %cx
|
|
movw %cx, undi_fbms_end
|
|
|
|
/*****************************************************************************
|
|
* Print information about detected PXE stack
|
|
*****************************************************************************
|
|
*/
|
|
print_structure_information:
|
|
/* Print entry point */
|
|
movw $10f, %si
|
|
call print_message
|
|
les entry_segoff, %bx
|
|
call print_segoff
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " entry point at "
|
|
.previous
|
|
/* Print UNDI code segment */
|
|
movw $10f, %si
|
|
call print_message
|
|
les undi_code_segoff, %bx
|
|
call print_segoff
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz "\n UNDI code segment "
|
|
.previous
|
|
/* Print UNDI data segment */
|
|
movw $10f, %si
|
|
call print_message
|
|
les undi_data_segoff, %bx
|
|
call print_segoff
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz ", data segment "
|
|
.previous
|
|
/* Print UNDI memory usage */
|
|
movw $10f, %si
|
|
call print_message
|
|
movw undi_fbms_start, %ax
|
|
call print_word
|
|
movb $( '-' ), %al
|
|
call print_character
|
|
movw undi_fbms_end, %ax
|
|
call print_word
|
|
movw $20f, %si
|
|
call print_message
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " ("
|
|
20: .asciz "kB)\n"
|
|
.previous
|
|
|
|
/*****************************************************************************
|
|
* Determine physical device
|
|
*****************************************************************************
|
|
*/
|
|
get_physical_device:
|
|
/* Issue PXENV_UNDI_GET_NIC_TYPE */
|
|
movw $PXENV_UNDI_GET_NIC_TYPE, %bx
|
|
call pxe_call
|
|
jnc 1f
|
|
call print_pxe_error
|
|
jmp no_physical_device
|
|
1: /* Determine physical device type */
|
|
movb ( pxe_parameter_structure + 0x02 ), %al
|
|
cmpb $2, %al
|
|
je pci_physical_device
|
|
jmp no_physical_device
|
|
|
|
pci_physical_device:
|
|
/* Record PCI bus:dev.fn and vendor/device IDs */
|
|
movl ( pxe_parameter_structure + 0x03 ), %eax
|
|
movl %eax, pci_vendor
|
|
movw ( pxe_parameter_structure + 0x0b ), %ax
|
|
movw %ax, pci_busdevfn
|
|
movw $10f, %si
|
|
call print_message
|
|
call print_pci_busdevfn
|
|
jmp 99f
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " UNDI device is PCI "
|
|
.previous
|
|
|
|
no_physical_device:
|
|
/* No device found, or device type not understood */
|
|
movw $10f, %si
|
|
call print_message
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " Unable to determine UNDI physical device"
|
|
.previous
|
|
|
|
99:
|
|
|
|
/*****************************************************************************
|
|
* Determine interface type
|
|
*****************************************************************************
|
|
*/
|
|
get_iface_type:
|
|
/* Issue PXENV_UNDI_GET_IFACE_INFO */
|
|
movw $PXENV_UNDI_GET_IFACE_INFO, %bx
|
|
call pxe_call
|
|
jnc 1f
|
|
call print_pxe_error
|
|
jmp 99f
|
|
1: /* Print interface type */
|
|
movw $10f, %si
|
|
call print_message
|
|
leaw ( pxe_parameter_structure + 0x02 ), %si
|
|
call print_message
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz ", type "
|
|
.previous
|
|
/* Check for "Etherboot" interface type */
|
|
cmpl $EB_MAGIC_1, ( pxe_parameter_structure + 0x02 )
|
|
jne 99f
|
|
cmpl $EB_MAGIC_2, ( pxe_parameter_structure + 0x06 )
|
|
jne 99f
|
|
movw $10f, %si
|
|
call print_message
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " (workaround enabled)"
|
|
.previous
|
|
/* Flag Etherboot workarounds as required */
|
|
orw $PXE_HACK_EB54, pxe_hacks
|
|
|
|
99: movb $0x0a, %al
|
|
call print_character
|
|
|
|
/*****************************************************************************
|
|
* Get cached DHCP_ACK packet
|
|
*****************************************************************************
|
|
*/
|
|
get_dhcpack:
|
|
/* Issue PXENV_GET_CACHED_INFO */
|
|
xorl %esi, %esi
|
|
movw %ss, %si
|
|
movw %si, ( pxe_parameter_structure + 0x08 )
|
|
movw $PREFIX_TEMP_DHCPACK, ( pxe_parameter_structure + 0x06 )
|
|
movw $PREFIX_TEMP_DHCPACK_SIZE, ( pxe_parameter_structure +0x04 )
|
|
movw $PXENV_PACKET_TYPE_DHCP_ACK, ( pxe_parameter_structure + 0x02 )
|
|
movw $PXENV_GET_CACHED_INFO, %bx
|
|
call pxe_call
|
|
jnc 1f
|
|
call print_pxe_error
|
|
jmp 99f
|
|
1: /* Store physical address of packet */
|
|
shll $4, %esi
|
|
addl $PREFIX_TEMP_DHCPACK, %esi
|
|
movl %esi, pxe_cached_dhcpack
|
|
99:
|
|
.section ".prefix.data", "aw", @progbits
|
|
pxe_cached_dhcpack:
|
|
.long 0
|
|
.previous
|
|
|
|
/*****************************************************************************
|
|
* Check for a command line
|
|
*****************************************************************************
|
|
*/
|
|
get_cmdline:
|
|
/* Issue PXENV_FILE_CMDLINE */
|
|
xorl %esi, %esi
|
|
movw %ss, %si
|
|
movw %si, ( pxe_parameter_structure + 0x06 )
|
|
movw $PREFIX_TEMP_CMDLINE, ( pxe_parameter_structure + 0x04 )
|
|
movw $PREFIX_TEMP_CMDLINE_SIZE, ( pxe_parameter_structure + 0x02 )
|
|
movw $PXENV_FILE_CMDLINE, %bx
|
|
call pxe_call
|
|
jc 99f /* Suppress errors; this is an iPXE extension API call */
|
|
/* Check for non-NULL command line */
|
|
movw ( pxe_parameter_structure + 0x02 ), %ax
|
|
testw %ax, %ax
|
|
jz 99f
|
|
/* Record command line */
|
|
shll $4, %esi
|
|
addl $PREFIX_TEMP_CMDLINE, %esi
|
|
movl %esi, pxe_cmdline
|
|
99:
|
|
.section ".prefix.data", "aw", @progbits
|
|
pxe_cmdline:
|
|
.long 0
|
|
.previous
|
|
|
|
/*****************************************************************************
|
|
* Leave NIC in a safe state
|
|
*****************************************************************************
|
|
*/
|
|
#ifndef PXELOADER_KEEP_PXE
|
|
shutdown_nic:
|
|
/* Issue PXENV_UNDI_SHUTDOWN */
|
|
movw $PXENV_UNDI_SHUTDOWN, %bx
|
|
call pxe_call
|
|
jnc 1f
|
|
call print_pxe_error
|
|
1:
|
|
unload_base_code:
|
|
/* Etherboot treats PXENV_UNLOAD_STACK as PXENV_STOP_UNDI, so
|
|
* we must not issue this call if the underlying stack is
|
|
* Etherboot and we were not intending to issue a PXENV_STOP_UNDI.
|
|
*/
|
|
#ifdef PXELOADER_KEEP_UNDI
|
|
testw $PXE_HACK_EB54, pxe_hacks
|
|
jnz 99f
|
|
#endif /* PXELOADER_KEEP_UNDI */
|
|
/* Issue PXENV_UNLOAD_STACK */
|
|
movw $PXENV_UNLOAD_STACK, %bx
|
|
call pxe_call
|
|
jnc 1f
|
|
call print_pxe_error
|
|
jmp 99f
|
|
1: /* Free base memory used by PXE base code */
|
|
movw undi_fbms_start, %ax
|
|
movw %fs:(0x13), %bx
|
|
call free_basemem
|
|
99:
|
|
andw $~( UNDI_FL_INITIALIZED | UNDI_FL_KEEP_ALL ), flags
|
|
#endif /* PXELOADER_KEEP_PXE */
|
|
|
|
/*****************************************************************************
|
|
* Unload UNDI driver
|
|
*****************************************************************************
|
|
*/
|
|
#ifndef PXELOADER_KEEP_UNDI
|
|
unload_undi:
|
|
/* Issue PXENV_STOP_UNDI */
|
|
movw $PXENV_STOP_UNDI, %bx
|
|
call pxe_call
|
|
jnc 1f
|
|
call print_pxe_error
|
|
jmp 99f
|
|
1: /* Free base memory used by UNDI */
|
|
movw undi_fbms_end, %ax
|
|
movw undi_fbms_start, %bx
|
|
call free_basemem
|
|
/* Clear UNDI_FL_STARTED */
|
|
andw $~UNDI_FL_STARTED, flags
|
|
99:
|
|
#endif /* PXELOADER_KEEP_UNDI */
|
|
|
|
/*****************************************************************************
|
|
* Print remaining free base memory
|
|
*****************************************************************************
|
|
*/
|
|
print_free_basemem:
|
|
movw $10f, %si
|
|
call print_message
|
|
movw %fs:(0x13), %ax
|
|
call print_word
|
|
movw $20f, %si
|
|
call print_message
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " "
|
|
20: .asciz "kB free base memory after PXE unload\n"
|
|
.previous
|
|
|
|
/*****************************************************************************
|
|
* Exit point
|
|
*****************************************************************************
|
|
*/
|
|
finished:
|
|
jmp run_ipxe
|
|
|
|
/*****************************************************************************
|
|
* Subroutine: print segment:offset address
|
|
*
|
|
* Parameters:
|
|
* %es:%bx : segment:offset address to print
|
|
* %ds:di : output buffer (or %di=0 to print to console)
|
|
* Returns:
|
|
* %ds:di : next character in output buffer (if applicable)
|
|
*****************************************************************************
|
|
*/
|
|
print_segoff:
|
|
/* Preserve registers */
|
|
pushw %ax
|
|
/* Print "<segment>:offset" */
|
|
movw %es, %ax
|
|
call print_hex_word
|
|
movb $( ':' ), %al
|
|
call print_character
|
|
movw %bx, %ax
|
|
call print_hex_word
|
|
/* Restore registers and return */
|
|
popw %ax
|
|
ret
|
|
|
|
/*****************************************************************************
|
|
* Subroutine: print decimal word
|
|
*
|
|
* Parameters:
|
|
* %ax : word to print
|
|
* %ds:di : output buffer (or %di=0 to print to console)
|
|
* Returns:
|
|
* %ds:di : next character in output buffer (if applicable)
|
|
*****************************************************************************
|
|
*/
|
|
print_word:
|
|
/* Preserve registers */
|
|
pushw %ax
|
|
pushw %bx
|
|
pushw %cx
|
|
pushw %dx
|
|
/* Build up digit sequence on stack */
|
|
movw $10, %bx
|
|
xorw %cx, %cx
|
|
1: xorw %dx, %dx
|
|
divw %bx, %ax
|
|
pushw %dx
|
|
incw %cx
|
|
testw %ax, %ax
|
|
jnz 1b
|
|
/* Print digit sequence */
|
|
1: popw %ax
|
|
call print_hex_nibble
|
|
loop 1b
|
|
/* Restore registers and return */
|
|
popw %dx
|
|
popw %cx
|
|
popw %bx
|
|
popw %ax
|
|
ret
|
|
|
|
/*****************************************************************************
|
|
* Subroutine: zero 1kB block of base memory
|
|
*
|
|
* Parameters:
|
|
* %bx : block to zero (in kB)
|
|
* Returns:
|
|
* Nothing
|
|
*****************************************************************************
|
|
*/
|
|
zero_kb:
|
|
/* Preserve registers */
|
|
pushw %ax
|
|
pushw %cx
|
|
pushw %di
|
|
pushw %es
|
|
/* Zero block */
|
|
movw %bx, %ax
|
|
shlw $6, %ax
|
|
movw %ax, %es
|
|
movw $0x400, %cx
|
|
xorw %di, %di
|
|
xorw %ax, %ax
|
|
rep stosb
|
|
/* Restore registers and return */
|
|
popw %es
|
|
popw %di
|
|
popw %cx
|
|
popw %ax
|
|
ret
|
|
|
|
/*****************************************************************************
|
|
* Subroutine: free and zero base memory
|
|
*
|
|
* Parameters:
|
|
* %ax : Desired new free base memory counter (in kB)
|
|
* %bx : Expected current free base memory counter (in kB)
|
|
* %fs : BIOS data segment (0x40)
|
|
* Returns:
|
|
* None
|
|
*
|
|
* The base memory from %bx kB to %ax kB is unconditionally zeroed.
|
|
* It will be freed if and only if the expected current free base
|
|
* memory counter (%bx) matches the actual current free base memory
|
|
* counter in 0x40:0x13; if this does not match then the memory will
|
|
* be leaked.
|
|
*****************************************************************************
|
|
*/
|
|
free_basemem:
|
|
/* Zero base memory */
|
|
pushw %bx
|
|
1: cmpw %bx, %ax
|
|
je 2f
|
|
call zero_kb
|
|
incw %bx
|
|
jmp 1b
|
|
2: popw %bx
|
|
/* Free base memory */
|
|
cmpw %fs:(0x13), %bx /* Update FBMS only if "old" value */
|
|
jne 1f /* is correct */
|
|
1: movw %ax, %fs:(0x13)
|
|
ret
|
|
|
|
/*****************************************************************************
|
|
* Subroutine: make a PXE API call. Works with either !PXE or PXENV+ API.
|
|
*
|
|
* Parameters:
|
|
* %bx : PXE API call number
|
|
* %ds:pxe_parameter_structure : Parameters for PXE API call
|
|
* Returns:
|
|
* %ax : PXE status code (not exit code)
|
|
* CF set if %ax is non-zero
|
|
*****************************************************************************
|
|
*/
|
|
pxe_call:
|
|
/* Preserve registers */
|
|
pushw %di
|
|
pushw %es
|
|
/* Set up registers for PXENV+ API. %bx already set up */
|
|
pushw %ds
|
|
popw %es
|
|
movw $pxe_parameter_structure, %di
|
|
/* Set up stack for !PXE API */
|
|
pushw %es
|
|
pushw %di
|
|
pushw %bx
|
|
/* Make the API call */
|
|
lcall *entry_segoff
|
|
/* Reset the stack */
|
|
addw $6, %sp
|
|
movw pxe_parameter_structure, %ax
|
|
clc
|
|
testw %ax, %ax
|
|
jz 1f
|
|
stc
|
|
1: /* Clear direction flag, for the sake of sanity */
|
|
cld
|
|
/* Restore registers and return */
|
|
popw %es
|
|
popw %di
|
|
ret
|
|
|
|
/*****************************************************************************
|
|
* Subroutine: print PXE API call error message
|
|
*
|
|
* Parameters:
|
|
* %ax : PXE status code
|
|
* %bx : PXE API call number
|
|
* Returns:
|
|
* Nothing
|
|
*****************************************************************************
|
|
*/
|
|
print_pxe_error:
|
|
pushw %si
|
|
movw $10f, %si
|
|
call print_message
|
|
xchgw %ax, %bx
|
|
call print_hex_word
|
|
movw $20f, %si
|
|
call print_message
|
|
xchgw %ax, %bx
|
|
call print_hex_word
|
|
movw $30f, %si
|
|
call print_message
|
|
popw %si
|
|
ret
|
|
.section ".prefix.data", "aw", @progbits
|
|
10: .asciz " UNDI API call "
|
|
20: .asciz " failed: status code "
|
|
30: .asciz "\n"
|
|
.previous
|
|
|
|
/*****************************************************************************
|
|
* PXE data structures
|
|
*****************************************************************************
|
|
*/
|
|
.section ".prefix.data"
|
|
|
|
pxe_esp: .long 0
|
|
pxe_ss: .word 0
|
|
|
|
pxe_parameter_structure: .fill 64
|
|
|
|
undi_code_segoff:
|
|
undi_code_size: .word 0
|
|
undi_code_segment: .word 0
|
|
|
|
undi_data_segoff:
|
|
undi_data_size: .word 0
|
|
undi_data_segment: .word 0
|
|
|
|
pxe_hacks: .word 0
|
|
|
|
/* The following fields are part of a struct undi_device */
|
|
|
|
undi_device:
|
|
|
|
pxenv_segoff:
|
|
pxenv_offset: .word 0
|
|
pxenv_segment: .word 0
|
|
|
|
ppxe_segoff:
|
|
ppxe_offset: .word 0
|
|
ppxe_segment: .word 0
|
|
|
|
entry_segoff:
|
|
entry_offset: .word 0
|
|
entry_segment: .word 0
|
|
|
|
undi_fbms_start: .word 0
|
|
undi_fbms_end: .word 0
|
|
|
|
pci_busdevfn: .word UNDI_NO_PCI_BUSDEVFN
|
|
isapnp_csn: .word UNDI_NO_ISAPNP_CSN
|
|
isapnp_read_port: .word UNDI_NO_ISAPNP_READ_PORT
|
|
|
|
pci_vendor: .word 0
|
|
pci_device: .word 0
|
|
flags:
|
|
.word ( UNDI_FL_INITIALIZED | UNDI_FL_STARTED | UNDI_FL_KEEP_ALL )
|
|
|
|
.equ undi_device_size, ( . - undi_device )
|
|
|
|
/*****************************************************************************
|
|
* Run iPXE main code
|
|
*****************************************************************************
|
|
*/
|
|
.section ".prefix"
|
|
run_ipxe:
|
|
/* Install iPXE */
|
|
call install
|
|
|
|
/* Set up real-mode stack */
|
|
movw %bx, %ss
|
|
movw $_estack16, %sp
|
|
|
|
#ifdef PXELOADER_KEEP_UNDI
|
|
/* Copy our undi_device structure to the preloaded_undi variable */
|
|
movw %bx, %es
|
|
movw $preloaded_undi, %di
|
|
movw $undi_device, %si
|
|
movw $undi_device_size, %cx
|
|
rep movsb
|
|
#endif
|
|
|
|
/* Retrieve PXE %ss:esp */
|
|
movw pxe_ss, %di
|
|
movl pxe_esp, %ebp
|
|
|
|
/* Retrieve PXE command line, if any */
|
|
movl pxe_cmdline, %esi
|
|
|
|
/* Retrieve cached DHCPACK, if any */
|
|
movl pxe_cached_dhcpack, %ecx
|
|
|
|
/* Jump to .text16 segment with %ds pointing to .data16 */
|
|
movw %bx, %ds
|
|
pushw %ax
|
|
pushw $1f
|
|
lret
|
|
.section ".text16", "ax", @progbits
|
|
1:
|
|
/* Update the exit hook */
|
|
movw %cs, ( pxe_exit_hook + 2 )
|
|
|
|
/* Store command-line pointer */
|
|
movl %esi, cmdline_phys
|
|
|
|
/* Store cached DHCPACK pointer */
|
|
movl %ecx, cached_dhcpack_phys
|
|
|
|
/* Run main program */
|
|
virtcall main
|
|
|
|
/* Uninstall iPXE */
|
|
call uninstall
|
|
|
|
/* Restore PXE stack */
|
|
movw %di, %ss
|
|
movl %ebp, %esp
|
|
|
|
/* Jump to hook if applicable */
|
|
ljmpw *pxe_exit_hook
|
|
|
|
.section ".data16", "aw", @progbits
|
|
.globl pxe_exit_hook
|
|
pxe_exit_hook:
|
|
.word exit_ipxe, 0
|
|
.previous
|
|
|
|
exit_ipxe:
|
|
/* Check PXE stack magic */
|
|
popl %eax
|
|
cmpl $STACK_MAGIC, %eax
|
|
jne 1f
|
|
|
|
/* PXE stack OK: return to caller */
|
|
popw %ds
|
|
popw %es
|
|
popw %fs
|
|
popw %gs
|
|
popal
|
|
popfl
|
|
xorw %ax, %ax /* Return success */
|
|
lret
|
|
|
|
1: /* PXE stack corrupt or removed: use INT 18 */
|
|
int $0x18
|
|
.previous
|