#define PXENV_UNDI_CLEANUP 0x02
#define PXENV_UNDI_SHUTDOWN 0x05
#define PXENV_STOP_UNDI 0x15
#define PXENV_UNLOAD_STACK 0x70
#define PXENV_STOP_BASE 0x76
#define PXE_STACK_MAGIC 0x57ac /* 'STac' */
.text
.code16
.arch i386
.org 0
.section ".prefix", "ax", @progbits
/*****************************************************************************
* Entry point: set cs, ds, bp, print welcome message
*****************************************************************************
*/
jmp $0x7c0, $code_start
10: .asciz "PXE->EB "
code_start:
/* Preserve registers for return to PXE stack */
pushfl
pushal
pushw %gs
pushw %fs
pushw %es
pushw %ds
pushw %ss
pushw %cs
pushw $PXE_STACK_MAGIC /* PXE stack magic marker */
/* Set up stack just below 0x7c00 */
pushw %ss
popw %es
movw %sp, %di
xorw %ax, %ax
movw %ax, %ss
movw $0x7c00, %sp
pushw %es /* Save old PXE stack pointer */
pushw %di
/* Set up our other segment registers */
pushw %cs
popw %ds
movw $0x40, %ax /* BIOS data segment access */
movw %ax, %fs
/* Print welcome message */
movw $10b, %si
call print_message
/*****************************************************************************
* Detect type of PXE available (!PXE, PXENV+ or none)
*****************************************************************************
*/
detect_pxe:
les %es:54(%di), %di /* !PXE structure */
cmpl $0x45585021, %es:(%di) /* '!PXE' signature */
je detected_pxe
movw $0x5650, %ax
int $0x1a
cmpw $0x564e, %ax
jne detected_nothing
cmpl $0x4e455850, %es:(%bx) /* 'PXEN' signature */
jne detected_nothing
cmpw $0x2b56, %es:4(%bx) /* 'V+' signature */
je detected_pxenv
detected_nothing:
movw $10f, %si
call print_message
jmp finished_with_error
10: .asciz "No PXE "
detected_pxenv: /* es:bx points to PXENV+ structure */
pushw %es
pushw %bx
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 */
les %es:0x0a(%bx), %di /* Entry point to %es:%di */
movw $10f, %si
jmp pxe_setup_done
10: .asciz "PXENV+ "
detected_pxe: /* es:di points to !PXE structure */
pushw %es
pushw %di
pushw %es:0x30(%di) /* UNDI code segment */
pushw %es:0x36(%di) /* UNDI code size */
pushw %es:0x28(%di) /* UNDI data segment */
pushw %es:0x2e(%di) /* UNDI data size */
les %es:0x10(%di), %di /* Entry point to %es:%di */
movw $10f, %si
jmp pxe_setup_done
10: .asciz "!PXE "
pxe_setup_done:
movw %es, pxe_entry_segment
movw %di, pxe_entry_offset
popw undi_data_size
popw undi_data_segment
popw undi_code_size
popw undi_code_segment
call print_message
popw %di
popw %es /* Exit with %es:%di containing structure address */
/*****************************************************************************
* Print information about located structure
*****************************************************************************
*/
print_structure_information:
call print_segoff /* %es:%di contains address of structure */
les pxe_entry_segoff, %di
call print_segoff
les undi_code_segoff, %di
call print_segoff
les undi_data_segoff, %di
call print_segoff
/*****************************************************************************
* Unload PXE base code and UNDI driver
*****************************************************************************
*/
#ifdef PXELOADER_KEEP_ALL
xorw %ax, %ax /* Force zero flag to show success */
jmp do_not_free_base_mem /* Skip the unloading */
#endif /* PXELOADER_KEEP_ALL */
unload_pxe:
movw $PXENV_UNLOAD_STACK, %bx
call pxe_call
movw $PXENV_STOP_UNDI, %bx
call pxe_call
pushfw /* Ignore PXENV_UNDI_CLEANUP errors */
movw $PXENV_UNDI_CLEANUP, %bx
call pxe_call
popfw
/* On exit, zero flag is set iff all calls were successful */
/*****************************************************************************
* Free base memory
*****************************************************************************
*/
free_base_mem:
jnz do_not_free_base_mem /* Using zero flag from unload_pxe */
movw undi_code_segment, %bx
movw undi_data_segment, %cx
movw undi_code_size, %ax
cmpw %bx, %cx
jb 1f
movw %cx, %bx
movw undi_data_size, %ax
1: addw $0x0f, %ax /* Round up to next segment */
shrw $4, %ax
addw %bx, %ax /* Highest segment address into %ax */
addw $(1024 / 16 - 1), %ax /* Round up to next kb */
shrw $6, %ax /* New free basemem size in %ax */
movw %fs:(0x13), %bx /* Old free base memory in %bx */
movw %ax, %fs:(0x13) /* Store new free base memory size */
/* Note that zero_mem_loop will also zero out our stack, so make
* sure the stack is empty at this point.
*/
movw %ax, %dx
subw %bx, %dx /* numberof kb to zero in %dx */
shlw $6, %bx /* Segment address into %bx */
zero_mem_loop:
movw %bx, %es /* kB boundary into %es:00 */
xorw %ax, %ax
xorw %di, %di
movw $0x400, %cx
rep stosb /* fill kB with zeroes */
addw $(1024 / 16), %bx
decw %dx
jnz zero_mem_loop
/* Will exit here with zero flag set, so no need to set it explicitly
* in order to indicate success.
*/
do_not_free_base_mem:
pushfw /* Save success (zero) flag status */
movw %fs:(0x13), %ax /* Free base memory in %ax */
call print_hex_word /* Print free base memory */
popfw /* Restore success (zero) flag */
/*****************************************************************************
* Exit point
* Jump to finished with the zero flag set to indicate success, or to
* finished_with_error to always report an error
*****************************************************************************
*/
finished:
movw $10f, %si
jz 1f
finished_with_error:
movw $20f, %si
1:
call print_message
jmp run_etherboot
10: .asciz " ok\n"
20: .asciz " err\n"
/*****************************************************************************
* Subroutine: print character in %al (with LF -> LF,CR translation)
*****************************************************************************
*/
print_character:
movw $0x0007, %bx /* page 0, attribute 7 (normal) */
movb $0x0e, %ah /* write char, tty mode */
cmpb $0x0a, %al /* '\n'? */
jne 1f
int $0x10
movb $0x0d, %al
1: int $0x10
ret
/*****************************************************************************
* Subroutine: print a zero-terminated message starting at %si
*****************************************************************************
*/
print_message:
1: lodsb
testb %al, %al
je 2f
call print_character
jmp 1b
2: ret
/*****************************************************************************
* Subroutine: print hex word in %ax
*****************************************************************************
*/
print_hex_word:
movw $4, %cx
1:
pushw %ax
shrw $12, %ax
/* Courtesy of Norbert Juffa <norbert.juffa@amd.com> */
cmpb $10, %al
sbbb $0x69, %al
das
call print_character
popw %ax
shlw $4, %ax
loop 1b
ret
/*****************************************************************************
* Subroutine: print segment:offset address in %es:%di
*****************************************************************************
*/
print_segoff:
pushw %di
pushw %es
popw %ax
call print_hex_word
movb $0x3a,%al /* ':' */
call print_character
popw %ax
call print_hex_word
movb $0x20, %al /* ' ' */
call print_character
ret
/*****************************************************************************
* Make a PXE API call. Works with either !PXE or PXENV+ API.
* Opcode in %bx. pxe_parameter_structure always used.
* Returns status code (not exit code) in %bx and prints it.
* ORs status code with overall status code in pxe_overall_status, returns
* with zero flag set iff all PXE API calls have been successful.
*****************************************************************************
*/
pxe_call:
/* 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 %cs
pushw %di
pushw %bx
/* Make the API call */
lcall *pxe_entry_segoff
/* Reset the stack */
addw $6, %sp
movw pxe_parameter_structure, %ax
pushw %ax
call print_hex_word
movw $0x20, %ax /* ' ' */
call print_character
popw %bx
orw %bx, pxe_overall_status
ret
/*****************************************************************************
* PXE data structures
*****************************************************************************
*/
pxe_overall_status: .word 0
pxe_entry_segoff:
pxe_entry_offset: .word 0
pxe_entry_segment: .word 0
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_parameter_structure:
.word 0
.word 0,0,0,0,0
/*****************************************************************************
* Run Etherboot main code
*****************************************************************************
*/
run_etherboot:
/* Install Etherboot */
call install
/* Jump to .text16 segment with %ds pointing to .data16*/
movw %bx, %ds
pushw %ax
pushw $1f
lret
.section ".text16", "ax", @progbits
1:
/* Original PXE stack pointer to es:di. We must hold it in
* registers, because our current stack may be vapourised by
* the time main() returns. (main() will still be able to
* return, because prot_call() transfers the return address to
* the internal stack and back again).
*/
popw %di
popw %es
/* Run main program */
pushl $main
pushw %cs
call prot_call
popl %eax /* discard */
/* If original PXE stack is intact, return via PXE, else via INT 18 */
cmpw $PXE_STACK_MAGIC, %es:0(%di)
jne exit_via_int18
exit_via_pxe: /* Stack OK, return to PXE */
movw $exit_via_pxe_message, %si
call print_exit_message
pushw %es /* Restore original PXE stack */
popw %ss
movw %di, %sp
popw %ax /* discard PXE_STACK_MAGIC */
popw %ax /* discard %cs */
popw %ax /* discard %ss */
popw %ds
popw %es
popw %fs
popw %gs
popal
popfl
xorw %ax, %ax /* Return PXENV_STATUS_SUCCESS */
lret
exit_via_int18: /* Stack damaged, do int 18 */
movw $exit_via_int18_message, %si
call print_exit_message
int $0x18
print_exit_message:
movw $0x0007, %bx /* page 0, attribute 7 (normal) */
movb $0x0e, %ah /* write char, tty mode */
1: lodsb
testb %al, %al
je 2f
int $0x10
jmp 1b
2: ret
.section ".data16", "aw", @progbits
exit_via_pxe_message:
.asciz "EB->PXE\r\n"
exit_via_int18_message:
.asciz "EB->BIOS\r\n"
