diff options
Diffstat (limited to 'sys/boot')
| -rw-r--r-- | sys/boot/i386/btx/btx/Makefile | 16 | ||||
| -rw-r--r-- | sys/boot/i386/btx/btx/btx.S | 28 | ||||
| -rw-r--r-- | sys/boot/i386/btx/btx/btx.s | 1173 | ||||
| -rw-r--r-- | sys/boot/i386/btx/btxldr/Makefile | 11 | ||||
| -rw-r--r-- | sys/boot/i386/btx/btxldr/btxldr.S | 48 | ||||
| -rw-r--r-- | sys/boot/i386/btx/btxldr/btxldr.s | 396 | ||||
| -rw-r--r-- | sys/boot/i386/pxeldr/Makefile | 11 | ||||
| -rw-r--r-- | sys/boot/i386/pxeldr/pxeldr.S | 8 | ||||
| -rw-r--r-- | sys/boot/i386/pxeldr/pxeldr.s | 287 |
9 files changed, 53 insertions, 1925 deletions
diff --git a/sys/boot/i386/btx/btx/Makefile b/sys/boot/i386/btx/btx/Makefile index 9ed8d49..510716f 100644 --- a/sys/boot/i386/btx/btx/Makefile +++ b/sys/boot/i386/btx/btx/Makefile @@ -3,13 +3,11 @@ PROG= btx.out INTERNALPROG= NOMAN= -SRCS= btx.s +SRCS= btx.S CLEANFILES= btx -M4?= m4 - .if defined(PAGING) -M4FLAGS+= -DPAGING +CFLAGS+=-DPAGING .endif .if defined(BOOT_BTX_NOHANG) @@ -18,15 +16,15 @@ BOOT_BTX_FLAGS=0x1 BOOT_BTX_FLAGS=0x0 .endif -AFLAGS+= --defsym BTX_FLAGS=${BOOT_BTX_FLAGS} +CFLAGS+=-DBTX_FLAGS=${BOOT_BTX_FLAGS} .if defined(BTX_SERIAL) BOOT_COMCONSOLE_PORT?= 0x3f8 BOOT_COMCONSOLE_SPEED?= 9600 B2SIOFMT?= 0x3 -M4FLAGS+= -DBTX_SERIAL -DSIOPRT=${BOOT_COMCONSOLE_PORT} \ - -DSIOFMT=${B2SIOFMT} -DSIOSPD=${BOOT_COMCONSOLE_SPEED} +CFLAGS+=-DBTX_SERIAL -DSIOPRT=${BOOT_COMCONSOLE_PORT} \ + -DSIOFMT=${B2SIOFMT} -DSIOSPD=${BOOT_COMCONSOLE_SPEED} .endif ORG= 0x9000 @@ -38,8 +36,4 @@ LDFLAGS=-N -e start -Ttext ${ORG} btx: btx.out objcopy -S -O binary btx.out ${.TARGET} -btx.o: btx.s - (cd ${.CURDIR}; ${M4} ${M4FLAGS} btx.s) | \ - ${AS} ${AFLAGS} -o ${.TARGET} - .include <bsd.prog.mk> diff --git a/sys/boot/i386/btx/btx/btx.S b/sys/boot/i386/btx/btx/btx.S index 0215530..6695ef4 100644 --- a/sys/boot/i386/btx/btx/btx.S +++ b/sys/boot/i386/btx/btx/btx.S @@ -158,7 +158,7 @@ init.4: movb $_ESP0H,TSS_ESP0+1(%di) # Set ESP0 movb $SEL_SDATA,TSS_SS0(%di) # Set SS0 movb $_ESP1H,TSS_ESP1+1(%di) # Set ESP1 movb $_TSSIO,TSS_MAP(%di) # Set I/O bit map base -ifdef(`PAGING',` +#ifdef PAGING # # Create page directory. # @@ -191,25 +191,25 @@ init.6: mov $0x7,%al # Set U:W:P flags init.7: stosl # Set entry add %edx,%eax # Next address loop init.6 # Till done -') +#endif # # Bring up the system. # mov $0x2820,%bx # Set protected mode callw setpic # IRQ offsets lidt idtdesc # Set IDT -ifdef(`PAGING',` +#ifdef PAGING xor %eax,%eax # Set base mov $MEM_DIR>>0x8,%ah # of page mov %eax,%cr3 # directory -') +#endif lgdt gdtdesc # Set GDT mov %cr0,%eax # Switch to protected -ifdef(`PAGING',` +#ifdef PAGING or $0x80000001,%eax # mode and enable paging -',` +#else or $0x01,%eax # mode -') +#endif mov %eax,%cr0 # ljmp $SEL_SCODE,$init.8 # To 32-bit code .code32 @@ -240,9 +240,9 @@ init.8: xorl %ecx,%ecx # Zero movb $0x7,%cl # Set remaining init.9: push $0x0 # general loop init.9 # registers -ifdef(`BTX_SERIAL',` +#ifdef BTX_SERIAL call sio_init # setup the serial console -') +#endif popa # and initialize popl %es # Initialize popl %ds # user @@ -860,13 +860,13 @@ intx30: cmpl $SYS_EXEC,%eax # Exec system call? movl $MEM_USR,%eax # User base address addl 0xc(%esp,1),%eax # Change to user leal 0x4(%eax),%esp # stack -ifdef(`PAGING',` +#ifdef PAGING movl %cr0,%eax # Turn andl $~0x80000000,%eax # off movl %eax,%cr0 # paging xorl %eax,%eax # Flush movl %eax,%cr3 # TLB -') +#endif popl %eax # Call call *%eax # program intx30.1: orb $0x1,%ss:btx_hdr+0x7 # Flag reboot @@ -970,7 +970,7 @@ putstr: lodsb # Load char testb %al,%al # End of string? jnz putstr.0 # No ret # To caller -ifdef(`BTX_SERIAL',` +#ifdef BTX_SERIAL .set SIO_PRT,SIOPRT # Base port .set SIO_FMT,SIOFMT # 8N1 .set SIO_DIV,(115200/SIOSPD) # 115200 / SPD @@ -1043,7 +1043,7 @@ putchr.1: pushl %eax # Push the character call sio_putc # Output the character popa # Restore ret # To caller -',` +#else # # Output character AL to the console. # @@ -1085,7 +1085,7 @@ putchr.3: cmpb $SCR_ROW,%dh # Beyond screen? putchr.4: movw %dx,(%ebx) # Update position popa # Restore ret # To caller -') +#endif .p2align 4 # diff --git a/sys/boot/i386/btx/btx/btx.s b/sys/boot/i386/btx/btx/btx.s deleted file mode 100644 index 0215530..0000000 --- a/sys/boot/i386/btx/btx/btx.s +++ /dev/null @@ -1,1173 +0,0 @@ -# -# Copyright (c) 1998 Robert Nordier -# All rights reserved. -# -# Redistribution and use in source and binary forms are freely -# permitted provided that the above copyright notice and this -# paragraph and the following disclaimer are duplicated in all -# such forms. -# -# This software is provided "AS IS" and without any express or -# implied warranties, including, without limitation, the implied -# warranties of merchantability and fitness for a particular -# purpose. -# - -# $FreeBSD$ - -# -# Memory layout. -# - .set MEM_BTX,0x1000 # Start of BTX memory - .set MEM_ESP0,0x1800 # Supervisor stack - .set MEM_BUF,0x1800 # Scratch buffer - .set MEM_ESP1,0x1e00 # Link stack - .set MEM_IDT,0x1e00 # IDT - .set MEM_TSS,0x1f98 # TSS - .set MEM_MAP,0x2000 # I/O bit map - .set MEM_DIR,0x4000 # Page directory - .set MEM_TBL,0x5000 # Page tables - .set MEM_ORG,0x9000 # BTX code - .set MEM_USR,0xa000 # Start of user memory -# -# Paging control. -# - .set PAG_SIZ,0x1000 # Page size - .set PAG_CNT,0x1000 # Pages to map -# -# Segment selectors. -# - .set SEL_SCODE,0x8 # Supervisor code - .set SEL_SDATA,0x10 # Supervisor data - .set SEL_RCODE,0x18 # Real mode code - .set SEL_RDATA,0x20 # Real mode data - .set SEL_UCODE,0x28|3 # User code - .set SEL_UDATA,0x30|3 # User data - .set SEL_TSS,0x38 # TSS -# -# Task state segment fields. -# - .set TSS_ESP0,0x4 # PL 0 ESP - .set TSS_SS0,0x8 # PL 0 SS - .set TSS_ESP1,0xc # PL 1 ESP - .set TSS_MAP,0x66 # I/O bit map base -# -# System calls. -# - .set SYS_EXIT,0x0 # Exit - .set SYS_EXEC,0x1 # Exec -# -# V86 constants. -# - .set V86_FLG,0x208eff # V86 flag mask - .set V86_STK,0x400 # V86 stack allowance -# -# Dump format control bytes. -# - .set DMP_X16,0x1 # Word - .set DMP_X32,0x2 # Long - .set DMP_MEM,0x4 # Memory - .set DMP_EOL,0x8 # End of line -# -# Screen defaults and assumptions. -# - .set SCR_MAT,0x7 # Mode/attribute - .set SCR_COL,0x50 # Columns per row - .set SCR_ROW,0x19 # Rows per screen -# -# BIOS Data Area locations. -# - .set BDA_MEM,0x413 # Free memory - .set BDA_KEYFLAGS,0x417 # Keyboard shift-state flags - .set BDA_SCR,0x449 # Video mode - .set BDA_POS,0x450 # Cursor position - .set BDA_BOOT,0x472 # Boot howto flag -# -# Derivations, for brevity. -# - .set _ESP0H,MEM_ESP0>>0x8 # Byte 1 of ESP0 - .set _ESP1H,MEM_ESP1>>0x8 # Byte 1 of ESP1 - .set _TSSIO,MEM_MAP-MEM_TSS # TSS I/O base - .set _TSSLM,MEM_DIR-MEM_TSS-1 # TSS limit - .set _IDTLM,MEM_TSS-MEM_IDT-1 # IDT limit -# -# Code segment. -# - .globl start - .code16 -start: # Start of code -# -# BTX header. -# -btx_hdr: .byte 0xeb # Machine ID - .byte 0xe # Header size - .ascii "BTX" # Magic - .byte 0x1 # Major version - .byte 0x1 # Minor version - .byte BTX_FLAGS # Flags - .word PAG_CNT-MEM_ORG>>0xc # Paging control - .word break-start # Text size - .long 0x0 # Entry address -# -# Initialization routine. -# -init: cli # Disable interrupts - xor %ax,%ax # Zero/segment - mov %ax,%ss # Set up - mov $MEM_ESP0,%sp # stack - mov %ax,%es # Address - mov %ax,%ds # data - pushl $0x2 # Clear - popfl # flags -# -# Initialize memory. -# - mov $MEM_IDT,%di # Memory to initialize - mov $(MEM_ORG-MEM_IDT)/2,%cx # Words to zero - push %di # Save - rep # Zero-fill - stosw # memory - pop %di # Restore -# -# Create IDT. -# - mov $idtctl,%si # Control string -init.1: lodsb # Get entry - cbw # count - xchg %ax,%cx # as word - jcxz init.4 # If done - lodsb # Get segment - xchg %ax,%dx # P:DPL:type - lodsw # Get control - xchg %ax,%bx # set - lodsw # Get handler offset - mov $SEL_SCODE,%dh # Segment selector -init.2: shr %bx # Handle this int? - jnc init.3 # No - mov %ax,(%di) # Set handler offset - mov %dh,0x2(%di) # and selector - mov %dl,0x5(%di) # Set P:DPL:type - add $0x4,%ax # Next handler -init.3: lea 0x8(%di),%di # Next entry - loop init.2 # Till set done - jmp init.1 # Continue -# -# Initialize TSS. -# -init.4: movb $_ESP0H,TSS_ESP0+1(%di) # Set ESP0 - movb $SEL_SDATA,TSS_SS0(%di) # Set SS0 - movb $_ESP1H,TSS_ESP1+1(%di) # Set ESP1 - movb $_TSSIO,TSS_MAP(%di) # Set I/O bit map base -ifdef(`PAGING',` -# -# Create page directory. -# - xor %edx,%edx # Page - mov $PAG_SIZ>>0x8,%dh # size - xor %eax,%eax # Zero - mov $MEM_DIR,%di # Page directory - mov $PAG_CNT>>0xa,%cl # Entries - mov $MEM_TBL|0x7,%ax # First entry -init.5: stosl # Write entry - add %dx,%ax # To next - loop init.5 # Till done -# -# Create page tables. -# - mov $MEM_TBL,%di # Page table - mov $PAG_CNT>>0x8,%ch # Entries - xor %ax,%ax # Start address -init.6: mov $0x7,%al # Set U:W:P flags - cmp btx_hdr+0x8,%cx # Standard user page? - jb init.7 # Yes - cmp $PAG_CNT-MEM_BTX>>0xc,%cx # BTX memory? - jae init.7 # No or first page - and $~0x2,%al # Clear W flag - cmp $PAG_CNT-MEM_USR>>0xc,%cx # User page zero? - jne init.7 # No - testb $0x80,btx_hdr+0x7 # Unmap it? - jz init.7 # No - and $~0x1,%al # Clear P flag -init.7: stosl # Set entry - add %edx,%eax # Next address - loop init.6 # Till done -') -# -# Bring up the system. -# - mov $0x2820,%bx # Set protected mode - callw setpic # IRQ offsets - lidt idtdesc # Set IDT -ifdef(`PAGING',` - xor %eax,%eax # Set base - mov $MEM_DIR>>0x8,%ah # of page - mov %eax,%cr3 # directory -') - lgdt gdtdesc # Set GDT - mov %cr0,%eax # Switch to protected -ifdef(`PAGING',` - or $0x80000001,%eax # mode and enable paging -',` - or $0x01,%eax # mode -') - mov %eax,%cr0 # - ljmp $SEL_SCODE,$init.8 # To 32-bit code - .code32 -init.8: xorl %ecx,%ecx # Zero - movb $SEL_SDATA,%cl # To 32-bit - movw %cx,%ss # stack -# -# Launch user task. -# - movb $SEL_TSS,%cl # Set task - ltr %cx # register - movl $MEM_USR,%edx # User base address - movzwl %ss:BDA_MEM,%eax # Get free memory - shll $0xa,%eax # To bytes - subl $0x1000,%eax # Less arg space - subl %edx,%eax # Less base - movb $SEL_UDATA,%cl # User data selector - pushl %ecx # Set SS - pushl %eax # Set ESP - push $0x202 # Set flags (IF set) - push $SEL_UCODE # Set CS - pushl btx_hdr+0xc # Set EIP - pushl %ecx # Set GS - pushl %ecx # Set FS - pushl %ecx # Set DS - pushl %ecx # Set ES - pushl %edx # Set EAX - movb $0x7,%cl # Set remaining -init.9: push $0x0 # general - loop init.9 # registers -ifdef(`BTX_SERIAL',` - call sio_init # setup the serial console -') - popa # and initialize - popl %es # Initialize - popl %ds # user - popl %fs # segment - popl %gs # registers - iret # To user mode -# -# Exit routine. -# -exit: cli # Disable interrupts - movl $MEM_ESP0,%esp # Clear stack -# -# Turn off paging. -# - movl %cr0,%eax # Get CR0 - andl $~0x80000000,%eax # Disable - movl %eax,%cr0 # paging - xorl %ecx,%ecx # Zero - movl %ecx,%cr3 # Flush TLB -# -# Restore the GDT in case we caught a kernel trap. -# - lgdt gdtdesc # Set GDT -# -# To 16 bits. -# - ljmpw $SEL_RCODE,$exit.1 # Reload CS - .code16 -exit.1: mov $SEL_RDATA,%cl # 16-bit selector - mov %cx,%ss # Reload SS - mov %cx,%ds # Load - mov %cx,%es # remaining - mov %cx,%fs # segment - mov %cx,%gs # registers -# -# To real-address mode. -# - dec %ax # Switch to - mov %eax,%cr0 # real mode - ljmp $0x0,$exit.2 # Reload CS -exit.2: xor %ax,%ax # Real mode segment - mov %ax,%ss # Reload SS - mov %ax,%ds # Address data - mov $0x7008,%bx # Set real mode - callw setpic # IRQ offsets - lidt ivtdesc # Set IVT -# -# Reboot or await reset. -# - sti # Enable interrupts - testb $0x1,btx_hdr+0x7 # Reboot? -exit.3: jz exit.3 # No - movw $0x1234, BDA_BOOT # Do a warm boot - ljmp $0xf000,$0xfff0 # reboot the machine -# -# Set IRQ offsets by reprogramming 8259A PICs. -# -setpic: in $0x21,%al # Save master - push %ax # IMR - in $0xa1,%al # Save slave - push %ax # IMR - movb $0x11,%al # ICW1 to - outb %al,$0x20 # master, - outb %al,$0xa0 # slave - movb %bl,%al # ICW2 to - outb %al,$0x21 # master - movb %bh,%al # ICW2 to - outb %al,$0xa1 # slave - movb $0x4,%al # ICW3 to - outb %al,$0x21 # master - movb $0x2,%al # ICW3 to - outb %al,$0xa1 # slave - movb $0x1,%al # ICW4 to - outb %al,$0x21 # master, - outb %al,$0xa1 # slave - pop %ax # Restore slave - outb %al,$0xa1 # IMR - pop %ax # Restore master - outb %al,$0x21 # IMR - retw # To caller - .code32 -# -# Initiate return from V86 mode to user mode. -# -inthlt: hlt # To supervisor mode -# -# Exception jump table. -# -intx00: push $0x0 # Int 0x0: #DE - jmp ex_noc # Divide error - push $0x1 # Int 0x1: #DB - jmp ex_noc # Debug - push $0x3 # Int 0x3: #BP - jmp ex_noc # Breakpoint - push $0x4 # Int 0x4: #OF - jmp ex_noc # Overflow - push $0x5 # Int 0x5: #BR - jmp ex_noc # BOUND range exceeded - push $0x6 # Int 0x6: #UD - jmp ex_noc # Invalid opcode - push $0x7 # Int 0x7: #NM - jmp ex_noc # Device not available - push $0x8 # Int 0x8: #DF - jmp except # Double fault - push $0xa # Int 0xa: #TS - jmp except # Invalid TSS - push $0xb # Int 0xb: #NP - jmp except # Segment not present - push $0xc # Int 0xc: #SS - jmp except # Stack segment fault - push $0xd # Int 0xd: #GP - jmp ex_v86 # General protection - push $0xe # Int 0xe: #PF - jmp except # Page fault -intx10: push $0x10 # Int 0x10: #MF - jmp ex_noc # Floating-point error -# -# Handle #GP exception. -# -ex_v86: testb $0x2,0x12(%esp,1) # V86 mode? - jz except # No - jmp v86mon # To monitor -# -# Save a zero error code. -# -ex_noc: pushl (%esp,1) # Duplicate int no - movb $0x0,0x4(%esp,1) # Fake error code -# -# Handle exception. -# -except: cld # String ops inc - pushl %ds # Save - pushl %es # most - pusha # registers - movb $0x6,%al # Push loop count - testb $0x2,0x3a(%esp,1) # V86 mode? - jnz except.1 # Yes - pushl %gs # Set GS - pushl %fs # Set FS - pushl %ds # Set DS - pushl %es # Set ES - movb $0x2,%al # Push loop count - cmpw $SEL_SCODE,0x44(%esp,1) # Supervisor mode? - jne except.1 # No - pushl %ss # Set SS - leal 0x50(%esp,1),%eax # Set - pushl %eax # ESP - jmp except.2 # Join common code -except.1: pushl 0x50(%esp,1) # Set GS, FS, DS, ES - decb %al # (if V86 mode), and - jne except.1 # SS, ESP -except.2: push $SEL_SDATA # Set up - popl %ds # to - pushl %ds # address - popl %es # data - movl %esp,%ebx # Stack frame - movl $dmpfmt,%esi # Dump format string - movl $MEM_BUF,%edi # Buffer - pushl %edi # Dump to - call dump # buffer - popl %esi # and - call putstr # display - leal 0x18(%esp,1),%esp # Discard frame - popa # Restore - popl %es # registers - popl %ds # saved - cmpb $0x3,(%esp,1) # Breakpoint? - je except.3 # Yes - cmpb $0x1,(%esp,1) # Debug? - jne except.2a # No - testl $0x100,0x10(%esp,1) # Trap flag set? - jnz except.3 # Yes -except.2a: jmp exit # Exit -except.3: leal 0x8(%esp,1),%esp # Discard err, int no - iret # From interrupt -# -# Return to user mode from V86 mode. -# -intrtn: cld # String ops inc - pushl %ds # Address - popl %es # data - leal 0x3c(%ebp),%edx # V86 Segment registers - movl MEM_TSS+TSS_ESP1,%esi # Link stack pointer - lodsl # INT_V86 args pointer - movl %esi,%ebx # Saved exception frame - testl %eax,%eax # INT_V86 args? - jz intrtn.2 # No - movl $MEM_USR,%edi # User base - movl 0x1c(%esi),%ebx # User ESP - movl %eax,(%edi,%ebx,1) # Restore to user stack - leal 0x8(%edi,%eax,1),%edi # Arg segment registers - testb $0x4,-0x6(%edi) # Return flags? - jz intrtn.1 # No - movl 0x30(%ebp),%eax # Get V86 flags - movw %ax,0x18(%esi) # Set user flags -intrtn.1: leal 0x10(%esi),%ebx # Saved exception frame - xchgl %edx,%esi # Segment registers - movb $0x4,%cl # Update seg regs - rep # in INT_V86 - movsl # args -intrtn.2: movl %edx,%esi # Segment registers - leal 0x28(%ebp),%edi # Set up seg - movb $0x4,%cl # regs for - rep # later - movsl # pop - movl %ebx,%esi # Restore exception - movb $0x5,%cl # frame to - rep # supervisor - movsl # stack - movl %esi,MEM_TSS+TSS_ESP1 # Link stack pointer - popa # Restore - leal 0x8(%esp,1),%esp # Discard err, int no - popl %es # Restore - popl %ds # user - popl %fs # segment - popl %gs # registers - iret # To user mode -# -# V86 monitor. -# -v86mon: cld # String ops inc - pushl $SEL_SDATA # Set up for - popl %ds # flat addressing - pusha # Save registers - movl %esp,%ebp # Address stack frame - movzwl 0x2c(%ebp),%edi # Load V86 CS - shll $0x4,%edi # To linear - movl 0x28(%ebp),%esi # Load V86 IP - addl %edi,%esi # Code pointer - xorl %ecx,%ecx # Zero - movb $0x2,%cl # 16-bit operands - xorl %eax,%eax # Zero -v86mon.1: lodsb # Get opcode - cmpb $0x66,%al # Operand size prefix? - jne v86mon.2 # No - movb $0x4,%cl # 32-bit operands - jmp v86mon.1 # Continue -v86mon.2: cmpb $0xf4,%al # HLT? - jne v86mon.3 # No - cmpl $inthlt+0x1,%esi # Is inthlt? - jne v86mon.7 # No (ignore) - jmp intrtn # Return to user mode -v86mon.3: cmpb $0xf,%al # Prefixed instruction? - jne v86mon.4 # No - cmpb $0x09,(%esi) # Is it a WBINVD? - je v86wbinvd # Yes - cmpb $0x30,(%esi) # Is it a WRMSR? - je v86wrmsr # Yes - cmpb $0x32,(%esi) # Is it a RDMSR? - je v86rdmsr # Yes - cmpb $0x20,(%esi) # Is this a - jne v86mon.4 # MOV EAX,CR0 - cmpb $0xc0,0x1(%esi) # instruction? - je v86mov # Yes -v86mon.4: cmpb $0xfa,%al # CLI? - je v86cli # Yes - cmpb $0xfb,%al # STI? - je v86sti # Yes - movzwl 0x38(%ebp),%ebx # Load V86 SS - shll $0x4,%ebx # To offset - pushl %ebx # Save - addl 0x34(%ebp),%ebx # Add V86 SP - movl 0x30(%ebp),%edx # Load V86 flags - cmpb $0x9c,%al # PUSHF/PUSHFD? - je v86pushf # Yes - cmpb $0x9d,%al # POPF/POPFD? - je v86popf # Yes - cmpb $0xcd,%al # INT imm8? - je v86intn # Yes - cmpb $0xcf,%al # IRET/IRETD? - je v86iret # Yes - popl %ebx # Restore - popa # Restore - jmp except # Handle exception -v86mon.5: movl %edx,0x30(%ebp) # Save V86 flags -v86mon.6: popl %edx # V86 SS adjustment - subl %edx,%ebx # Save V86 - movl %ebx,0x34(%ebp) # SP -v86mon.7: subl %edi,%esi # From linear - movl %esi,0x28(%ebp) # Save V86 IP - popa # Restore - leal 0x8(%esp,1),%esp # Discard int no, error - iret # To V86 mode -# -# Emulate MOV EAX,CR0. -# -v86mov: movl %cr0,%eax # CR0 to - movl %eax,0x1c(%ebp) # saved EAX - incl %esi # Adjust IP -# -# Return from emulating a 0x0f prefixed instruction -# -v86preret: incl %esi # Adjust IP - jmp v86mon.7 # Finish up -# -# Emulate WBINVD -# -v86wbinvd: wbinvd # Write back and invalidate - # cache - jmp v86preret # Finish up -# -# Emulate WRMSR -# -v86wrmsr: movl 0x18(%ebp),%ecx # Get user's %ecx (MSR to write) - movl 0x14(%ebp),%edx # Load the value - movl 0x1c(%ebp),%eax # to write - wrmsr # Write MSR - jmp v86preret # Finish up -# -# Emulate RDMSR -# -v86rdmsr: movl 0x18(%ebp),%ecx # MSR to read - rdmsr # Read the MSR - movl %eax,0x1c(%ebp) # Return the value of - movl %edx,0x14(%ebp) # the MSR to the user - jmp v86preret # Finish up -# -# Emulate CLI. -# -v86cli: andb $~0x2,0x31(%ebp) # Clear IF - jmp v86mon.7 # Finish up -# -# Emulate STI. -# -v86sti: orb $0x2,0x31(%ebp) # Set IF - jmp v86mon.7 # Finish up -# -# Emulate PUSHF/PUSHFD. -# -v86pushf: subl %ecx,%ebx # Adjust SP - cmpb $0x4,%cl # 32-bit - je v86pushf.1 # Yes - data16 # 16-bit -v86pushf.1: movl %edx,(%ebx) # Save flags - jmp v86mon.6 # Finish up -# -# Emulate IRET/IRETD. -# -v86iret: movzwl (%ebx),%esi # Load V86 IP - movzwl 0x2(%ebx),%edi # Load V86 CS - leal 0x4(%ebx),%ebx # Adjust SP - movl %edi,0x2c(%ebp) # Save V86 CS - xorl %edi,%edi # No ESI adjustment -# -# Emulate POPF/POPFD (and remainder of IRET/IRETD). -# -v86popf: cmpb $0x4,%cl # 32-bit? - je v86popf.1 # Yes - movl %edx,%eax # Initialize - data16 # 16-bit -v86popf.1: movl (%ebx),%eax # Load flags - addl %ecx,%ebx # Adjust SP - andl $V86_FLG,%eax # Merge - andl $~V86_FLG,%edx # the - orl %eax,%edx # flags - jmp v86mon.5 # Finish up -# -# trap int 15, function 87 -# reads %es:%si from saved registers on stack to find a GDT containing -# source and destination locations -# reads count of words from saved %cx -# returns success by setting %ah to 0 -# -int15_87: pushl %eax # Save - pushl %ebx # some information - pushl %esi # onto the stack. - pushl %edi - xorl %eax,%eax # clean EAX - xorl %ebx,%ebx # clean EBX - movl 0x4(%ebp),%esi # Get user's ESI - movl 0x3C(%ebp),%ebx # store ES - movw %si,%ax # store SI - shll $0x4,%ebx # Make it a seg. - addl %eax,%ebx # ebx=(es<<4)+si - movb 0x14(%ebx),%al # Grab the - movb 0x17(%ebx),%ah # necessary - shll $0x10,%eax # information - movw 0x12(%ebx),%ax # from - movl %eax,%esi # the - movb 0x1c(%ebx),%al # GDT in order to - movb 0x1f(%ebx),%ah # have %esi offset - shll $0x10,%eax # of source and %edi - movw 0x1a(%ebx),%ax # of destination. - movl %eax,%edi - pushl %ds # Make: - popl %es # es = ds - pushl %ecx # stash ECX - xorl %ecx,%ecx # highw of ECX is clear - movw 0x18(%ebp),%cx # Get user's ECX - shll $0x1,%ecx # Convert from num words to num - # bytes - rep # repeat... - movsb # perform copy. - popl %ecx # Restore - popl %edi - popl %esi # previous - popl %ebx # register - popl %eax # values. - movb $0x0,0x1d(%ebp) # set ah = 0 to indicate - # success - andb $0xfe,%dl # clear CF - jmp v86mon.5 # Finish up - -# -# Reboot the machine by setting the reboot flag and exiting -# -reboot: orb $0x1,btx_hdr+0x7 # Set the reboot flag - jmp exit # Terminate BTX and reboot - -# -# Emulate INT imm8... also make sure to check if it's int 15/87 -# -v86intn: lodsb # Get int no - cmpb $0x19,%al # is it int 19? - je reboot # yes, reboot the machine - cmpb $0x15,%al # is it int 15? - jne v86intn.3 # no, skip parse - pushl %eax # stash EAX - movl 0x1c(%ebp),%eax # user's saved EAX - cmpb $0x87,%ah # is it the memcpy subfunction? - jne v86intn.1 # no, keep checking - popl %eax # get the stack straight - jmp int15_87 # it's our cue -v86intn.1: cmpw $0x4f53,%ax # is it the delete key callout? - jne v86intn.2 # no, handle the int normally - movb BDA_KEYFLAGS,%al # get the shift key state - andb $0xc,%al # mask off just Ctrl and Alt - cmpb $0xc,%al # are both Ctrl and Alt down? - jne v86intn.2 # no, handle the int normally - popl %eax # restore EAX - jmp reboot # reboot the machine -v86intn.2: popl %eax # restore EAX -v86intn.3: subl %edi,%esi # From - shrl $0x4,%edi # linear - movw %dx,-0x2(%ebx) # Save flags - movw %di,-0x4(%ebx) # Save CS - leal -0x6(%ebx),%ebx # Adjust SP - movw %si,(%ebx) # Save IP - shll $0x2,%eax # Scale - movzwl (%eax),%esi # Load IP - movzwl 0x2(%eax),%edi # Load CS - movl %edi,0x2c(%ebp) # Save CS - xorl %edi,%edi # No ESI adjustment - andb $~0x1,%dh # Clear TF - jmp v86mon.5 # Finish up -# -# Hardware interrupt jump table. -# -intx20: push $0x8 # Int 0x20: IRQ0 - jmp int_hw # V86 int 0x8 - push $0x9 # Int 0x21: IRQ1 - jmp int_hw # V86 int 0x9 - push $0xa # Int 0x22: IRQ2 - jmp int_hw # V86 int 0xa - push $0xb # Int 0x23: IRQ3 - jmp int_hw # V86 int 0xb - push $0xc # Int 0x24: IRQ4 - jmp int_hw # V86 int 0xc - push $0xd # Int 0x25: IRQ5 - jmp int_hw # V86 int 0xd - push $0xe # Int 0x26: IRQ6 - jmp int_hw # V86 int 0xe - push $0xf # Int 0x27: IRQ7 - jmp int_hw # V86 int 0xf - push $0x70 # Int 0x28: IRQ8 - jmp int_hw # V86 int 0x70 - push $0x71 # Int 0x29: IRQ9 - jmp int_hw # V86 int 0x71 - push $0x72 # Int 0x2a: IRQ10 - jmp int_hw # V86 int 0x72 - push $0x73 # Int 0x2b: IRQ11 - jmp int_hw # V86 int 0x73 - push $0x74 # Int 0x2c: IRQ12 - jmp int_hw # V86 int 0x74 - push $0x75 # Int 0x2d: IRQ13 - jmp int_hw # V86 int 0x75 - push $0x76 # Int 0x2e: IRQ14 - jmp int_hw # V86 int 0x76 - push $0x77 # Int 0x2f: IRQ15 - jmp int_hw # V86 int 0x77 -# -# Reflect hardware interrupts. -# -int_hw: testb $0x2,0xe(%esp,1) # V86 mode? - jz intusr # No - pushl $SEL_SDATA # Address - popl %ds # data - xchgl %eax,(%esp,1) # Swap EAX, int no - pushl %ebp # Address - movl %esp,%ebp # stack frame - pushl %ebx # Save - shll $0x2,%eax # Get int - movl (%eax),%eax # vector - subl $0x6,0x14(%ebp) # Adjust V86 ESP - movzwl 0x18(%ebp),%ebx # V86 SS - shll $0x4,%ebx # * 0x10 - addl 0x14(%ebp),%ebx # + V86 ESP - xchgw %ax,0x8(%ebp) # Swap V86 IP - rorl $0x10,%eax # Swap words - xchgw %ax,0xc(%ebp) # Swap V86 CS - roll $0x10,%eax # Swap words - movl %eax,(%ebx) # CS:IP for IRET - movl 0x10(%ebp),%eax # V86 flags - movw %ax,0x4(%ebx) # Flags for IRET - andb $~0x3,0x11(%ebp) # Clear IF, TF - popl %ebx # Restore - popl %ebp # saved - popl %eax # registers - iret # To V86 mode -# -# Invoke V86 interrupt from user mode, with arguments. -# -intx31: stc # Have btx_v86 - pushl %eax # Missing int no -# -# Invoke V86 interrupt from user mode. -# -intusr: std # String ops dec - pushl %eax # Expand - pushl %eax # stack - pushl %eax # frame - pusha # Save - pushl %gs # Save - movl %esp,%eax # seg regs - pushl %fs # and - pushl %ds # point - pushl %es # to them - push $SEL_SDATA # Set up - popl %ds # to - pushl %ds # address - popl %es # data - movl $MEM_USR,%ebx # User base - movl %ebx,%edx # address - jc intusr.1 # If btx_v86 - xorl %edx,%edx # Control flags - xorl %ebp,%ebp # btx_v86 pointer -intusr.1: leal 0x50(%esp,1),%esi # Base of frame - pushl %esi # Save - addl -0x4(%esi),%ebx # User ESP - movl MEM_TSS+TSS_ESP1,%edi # Link stack pointer - leal -0x4(%edi),%edi # Adjust for push - xorl %ecx,%ecx # Zero - movb $0x5,%cl # Push exception - rep # frame on - movsl # link stack - xchgl %eax,%esi # Saved seg regs - movl 0x40(%esp,1),%eax # Get int no - testl %edx,%edx # Have btx_v86? - jz intusr.2 # No - movl (%ebx),%ebp # btx_v86 pointer - movb $0x4,%cl # Count - addl %ecx,%ebx # Adjust for pop - rep # Push saved seg regs - movsl # on link stack - addl %ebp,%edx # Flatten btx_v86 ptr - leal 0x14(%edx),%esi # Seg regs pointer - movl 0x4(%edx),%eax # Get int no/address - movzwl 0x2(%edx),%edx # Get control flags -intusr.2: movl %ebp,(%edi) # Push btx_v86 and - movl %edi,MEM_TSS+TSS_ESP1 # save link stack ptr - popl %edi # Base of frame - xchgl %eax,%ebp # Save intno/address - movl 0x48(%esp,1),%eax # Get flags - testb $0x2,%dl # Simulate CALLF? - jnz intusr.3 # Yes - decl %ebx # Push flags - decl %ebx # on V86 - movw %ax,(%ebx) # stack -intusr.3: movb $0x4,%cl # Count - subl %ecx,%ebx # Push return address - movl $inthlt,(%ebx) # on V86 stack - rep # Copy seg regs to - movsl # exception frame - xchgl %eax,%ecx # Save flags - movl %ebx,%eax # User ESP - subl $V86_STK,%eax # Less bytes - ja intusr.4 # to - xorl %eax,%eax # keep -intusr.4: shrl $0x4,%eax # Gives segment - stosl # Set SS - shll $0x4,%eax # To bytes - xchgl %eax,%ebx # Swap - subl %ebx,%eax # Gives offset - stosl # Set ESP - xchgl %eax,%ecx # Get flags - btsl $0x11,%eax # Set VM - andb $~0x1,%ah # Clear TF - stosl # Set EFL - xchgl %eax,%ebp # Get int no/address - testb $0x1,%dl # Address? - jnz intusr.5 # Yes - shll $0x2,%eax # Scale - movl (%eax),%eax # Load int vector -intusr.5: movl %eax,%ecx # Save - shrl $0x10,%eax # Gives segment - stosl # Set CS - movw %cx,%ax # Restore - stosl # Set EIP - leal 0x10(%esp,1),%esp # Discard seg regs - popa # Restore - iret # To V86 mode -# -# System Call. -# -intx30: cmpl $SYS_EXEC,%eax # Exec system call? - jne intx30.1 # No - pushl %ss # Set up - popl %es # all - pushl %es # segment - popl %ds # registers - pushl %ds # for the - popl %fs # program - pushl %fs # we're - popl %gs # invoking - movl $MEM_USR,%eax # User base address - addl 0xc(%esp,1),%eax # Change to user - leal 0x4(%eax),%esp # stack -ifdef(`PAGING',` - movl %cr0,%eax # Turn - andl $~0x80000000,%eax # off - movl %eax,%cr0 # paging - xorl %eax,%eax # Flush - movl %eax,%cr3 # TLB -') - popl %eax # Call - call *%eax # program -intx30.1: orb $0x1,%ss:btx_hdr+0x7 # Flag reboot - jmp exit # Exit -# -# Dump structure [EBX] to [EDI], using format string [ESI]. -# -dump.0: stosb # Save char -dump: lodsb # Load char - testb %al,%al # End of string? - jz dump.10 # Yes - testb $0x80,%al # Control? - jz dump.0 # No - movb %al,%ch # Save control - movb $'=',%al # Append - stosb # '=' - lodsb # Get offset - pushl %esi # Save - movsbl %al,%esi # To - addl %ebx,%esi # pointer - testb $DMP_X16,%ch # Dump word? - jz dump.1 # No - lodsw # Get and - call hex16 # dump it -dump.1: testb $DMP_X32,%ch # Dump long? - jz dump.2 # No - lodsl # Get and - call hex32 # dump it -dump.2: testb $DMP_MEM,%ch # Dump memory? - jz dump.8 # No - pushl %ds # Save - testb $0x2,0x52(%ebx) # V86 mode? - jnz dump.3 # Yes - verr 0x4(%esi) # Readable selector? - jnz dump.3 # No - ldsl (%esi),%esi # Load pointer - jmp dump.4 # Join common code -dump.3: lodsl # Set offset - xchgl %eax,%edx # Save - lodsl # Get segment - shll $0x4,%eax # * 0x10 - addl %edx,%eax # + offset - xchgl %eax,%esi # Set pointer -dump.4: movb $2,%dl # Num lines -dump.4a: movb $0x10,%cl # Bytes to dump -dump.5: lodsb # Get byte and - call hex8 # dump it - decb %cl # Keep count - jz dump.6a # If done - movb $'-',%al # Separator - cmpb $0x8,%cl # Half way? - je dump.6 # Yes - movb $' ',%al # Use space -dump.6: stosb # Save separator - jmp dump.5 # Continue -dump.6a: decb %dl # Keep count - jz dump.7 # If done - movb $0xa,%al # Line feed - stosb # Save one - movb $7,%cl # Leading - movb $' ',%al # spaces -dump.6b: stosb # Dump - decb %cl # spaces - jnz dump.6b - jmp dump.4a # Next line -dump.7: popl %ds # Restore -dump.8: popl %esi # Restore - movb $0xa,%al # Line feed - testb $DMP_EOL,%ch # End of line? - jnz dump.9 # Yes - movb $' ',%al # Use spaces - stosb # Save one -dump.9: jmp dump.0 # Continue -dump.10: stosb # Terminate string - ret # To caller -# -# Convert EAX, AX, or AL to hex, saving the result to [EDI]. -# -hex32: pushl %eax # Save - shrl $0x10,%eax # Do upper - call hex16 # 16 - popl %eax # Restore -hex16: call hex16.1 # Do upper 8 -hex16.1: xchgb %ah,%al # Save/restore -hex8: pushl %eax # Save - shrb $0x4,%al # Do upper - call hex8.1 # 4 - popl %eax # Restore -hex8.1: andb $0xf,%al # Get lower 4 - cmpb $0xa,%al # Convert - sbbb $0x69,%al # to hex - das # digit - orb $0x20,%al # To lower case - stosb # Save char - ret # (Recursive) -# -# Output zero-terminated string [ESI] to the console. -# -putstr.0: call putchr # Output char -putstr: lodsb # Load char - testb %al,%al # End of string? - jnz putstr.0 # No - ret # To caller -ifdef(`BTX_SERIAL',` - .set SIO_PRT,SIOPRT # Base port - .set SIO_FMT,SIOFMT # 8N1 - .set SIO_DIV,(115200/SIOSPD) # 115200 / SPD - -# void sio_init(void) - -sio_init: movw $SIO_PRT+0x3,%dx # Data format reg - movb $SIO_FMT|0x80,%al # Set format - outb %al,(%dx) # and DLAB - pushl %edx # Save - subb $0x3,%dl # Divisor latch reg - movw $SIO_DIV,%ax # Set - outw %ax,(%dx) # BPS - popl %edx # Restore - movb $SIO_FMT,%al # Clear - outb %al,(%dx) # DLAB - incl %edx # Modem control reg - movb $0x3,%al # Set RTS, - outb %al,(%dx) # DTR - incl %edx # Line status reg - -# void sio_flush(void) - -sio_flush.0: call sio_getc.1 # Get character -sio_flush: call sio_ischar # Check for character - jnz sio_flush.0 # Till none - ret # To caller - -# void sio_putc(int c) - -sio_putc: movw $SIO_PRT+0x5,%dx # Line status reg - xor %ecx,%ecx # Timeout - movb $0x40,%ch # counter -sio_putc.1: inb (%dx),%al # Transmitter - testb $0x20,%al # buffer empty? - loopz sio_putc.1 # No - jz sio_putc.2 # If timeout - movb 0x4(%esp,1),%al # Get character - subb $0x5,%dl # Transmitter hold reg - outb %al,(%dx) # Write character -sio_putc.2: ret $0x4 # To caller - -# int sio_getc(void) - -sio_getc: call sio_ischar # Character available? - jz sio_getc # No -sio_getc.1: subb $0x5,%dl # Receiver buffer reg - inb (%dx),%al # Read character - ret # To caller - -# int sio_ischar(void) - -sio_ischar: movw $SIO_PRT+0x5,%dx # Line status register - xorl %eax,%eax # Zero - inb (%dx),%al # Received data - andb $0x1,%al # ready? - ret # To caller - -# -# Output character AL to the serial console. -# -putchr: pusha # Save - cmpb $10, %al # is it a newline? - jne putchr.1 # no?, then leave - push $13 # output a carriage - call sio_putc # return first - movb $10, %al # restore %al -putchr.1: pushl %eax # Push the character - # onto the stack - call sio_putc # Output the character - popa # Restore - ret # To caller -',` -# -# Output character AL to the console. -# -putchr: pusha # Save - xorl %ecx,%ecx # Zero for loops - movb $SCR_MAT,%ah # Mode/attribute - movl $BDA_POS,%ebx # BDA pointer - movw (%ebx),%dx # Cursor position - movl $0xb8000,%edi # Regen buffer (color) - cmpb %ah,BDA_SCR-BDA_POS(%ebx) # Mono mode? - jne putchr.1 # No - xorw %di,%di # Regen buffer (mono) -putchr.1: cmpb $0xa,%al # New line? - je putchr.2 # Yes - xchgl %eax,%ecx # Save char - movb $SCR_COL,%al # Columns per row - mulb %dh # * row position - addb %dl,%al # + column - adcb $0x0,%ah # position - shll %eax # * 2 - xchgl %eax,%ecx # Swap char, offset - movw %ax,(%edi,%ecx,1) # Write attr:char - incl %edx # Bump cursor - cmpb $SCR_COL,%dl # Beyond row? - jb putchr.3 # No -putchr.2: xorb %dl,%dl # Zero column - incb %dh # Bump row -putchr.3: cmpb $SCR_ROW,%dh # Beyond screen? - jb putchr.4 # No - leal 2*SCR_COL(%edi),%esi # New top line - movw $(SCR_ROW-1)*SCR_COL/2,%cx # Words to move - rep # Scroll - movsl # screen - movb $0x20,%al # Space - movb $SCR_COL,%cl # Columns to clear - rep # Clear - stosw # line - movb $SCR_ROW-1,%dh # Bottom line -putchr.4: movw %dx,(%ebx) # Update position - popa # Restore - ret # To caller -') - - .p2align 4 -# -# Global descriptor table. -# -gdt: .word 0x0,0x0,0x0,0x0 # Null entry - .word 0xffff,0x0,0x9a00,0xcf # SEL_SCODE - .word 0xffff,0x0,0x9200,0xcf # SEL_SDATA - .word 0xffff,0x0,0x9a00,0x0 # SEL_RCODE - .word 0xffff,0x0,0x9200,0x0 # SEL_RDATA - .word 0xffff,MEM_USR,0xfa00,0xcf# SEL_UCODE - .word 0xffff,MEM_USR,0xf200,0xcf# SEL_UDATA - .word _TSSLM,MEM_TSS,0x8900,0x0 # SEL_TSS -gdt.1: -# -# Pseudo-descriptors. -# -gdtdesc: .word gdt.1-gdt-1,gdt,0x0 # GDT -idtdesc: .word _IDTLM,MEM_IDT,0x0 # IDT -ivtdesc: .word 0x400-0x0-1,0x0,0x0 # IVT -# -# IDT construction control string. -# -idtctl: .byte 0x10, 0x8e # Int 0x0-0xf - .word 0x7dfb,intx00 # (exceptions) - .byte 0x10, 0x8e # Int 0x10 - .word 0x1, intx10 # (exception) - .byte 0x10, 0x8e # Int 0x20-0x2f - .word 0xffff,intx20 # (hardware) - .byte 0x1, 0xee # int 0x30 - .word 0x1, intx30 # (system call) - .byte 0x2, 0xee # Int 0x31-0x32 - .word 0x1, intx31 # (V86, null) - .byte 0x0 # End of string -# -# Dump format string. -# -dmpfmt: .byte '\n' # "\n" - .ascii "int" # "int=" - .byte 0x80|DMP_X32, 0x40 # "00000000 " - .ascii "err" # "err=" - .byte 0x80|DMP_X32, 0x44 # "00000000 " - .ascii "efl" # "efl=" - .byte 0x80|DMP_X32, 0x50 # "00000000 " - .ascii "eip" # "eip=" - .byte 0x80|DMP_X32|DMP_EOL,0x48 # "00000000\n" - .ascii "eax" # "eax=" - .byte 0x80|DMP_X32, 0x34 # "00000000 " - .ascii "ebx" # "ebx=" - .byte 0x80|DMP_X32, 0x28 # "00000000 " - .ascii "ecx" # "ecx=" - .byte 0x80|DMP_X32, 0x30 # "00000000 " - .ascii "edx" # "edx=" - .byte 0x80|DMP_X32|DMP_EOL,0x2c # "00000000\n" - .ascii "esi" # "esi=" - .byte 0x80|DMP_X32, 0x1c # "00000000 " - .ascii "edi" # "edi=" - .byte 0x80|DMP_X32, 0x18 # "00000000 " - .ascii "ebp" # "ebp=" - .byte 0x80|DMP_X32, 0x20 # "00000000 " - .ascii "esp" # "esp=" - .byte 0x80|DMP_X32|DMP_EOL,0x0 # "00000000\n" - .ascii "cs" # "cs=" - .byte 0x80|DMP_X16, 0x4c # "0000 " - .ascii "ds" # "ds=" - .byte 0x80|DMP_X16, 0xc # "0000 " - .ascii "es" # "es=" - .byte 0x80|DMP_X16, 0x8 # "0000 " - .ascii " " # " " - .ascii "fs" # "fs=" - .byte 0x80|DMP_X16, 0x10 # "0000 " - .ascii "gs" # "gs=" - .byte 0x80|DMP_X16, 0x14 # "0000 " - .ascii "ss" # "ss=" - .byte 0x80|DMP_X16|DMP_EOL,0x4 # "0000\n" - .ascii "cs:eip" # "cs:eip=" - .byte 0x80|DMP_MEM|DMP_EOL,0x48 # "00 00 ... 00 00\n" - .ascii "ss:esp" # "ss:esp=" - .byte 0x80|DMP_MEM|DMP_EOL,0x0 # "00 00 ... 00 00\n" - .asciz "BTX halted\n" # End -# -# End of BTX memory. -# - .p2align 4 -break: diff --git a/sys/boot/i386/btx/btxldr/Makefile b/sys/boot/i386/btx/btxldr/Makefile index 23008a5..358e396 100644 --- a/sys/boot/i386/btx/btxldr/Makefile +++ b/sys/boot/i386/btx/btxldr/Makefile @@ -3,14 +3,13 @@ PROG= btxldr.out INTERNALPROG= NOMAN= -SRCS= btxldr.s +SRCS= btxldr.S CLEANFILES= btxldr -M4?= m4 -M4FLAGS+= -DLOADER_ADDRESS=${LOADER_ADDRESS} +CFLAGS+=-DLOADER_ADDRESS=${LOADER_ADDRESS} .if defined(BTXLDR_VERBOSE) -M4FLAGS+= -DBTXLDR_VERBOSE +CFLAGS+=-DBTXLDR_VERBOSE .endif all: btxldr @@ -20,8 +19,4 @@ LDFLAGS=-N -e start -Ttext ${LOADER_ADDRESS} btxldr: btxldr.out objcopy -S -O binary btxldr.out ${.TARGET} -btxldr.o: btxldr.s - (cd ${.CURDIR}; ${M4} ${M4FLAGS} btxldr.s ) | \ - ${AS} ${AFLAGS} -o ${.TARGET} - .include <bsd.prog.mk> diff --git a/sys/boot/i386/btx/btxldr/btxldr.S b/sys/boot/i386/btx/btxldr/btxldr.S index 7d4b121..1a94212 100644 --- a/sys/boot/i386/btx/btxldr/btxldr.S +++ b/sys/boot/i386/btx/btxldr/btxldr.S @@ -69,16 +69,16 @@ start: cld # String ops inc movzwl BDA_MEM,%eax # Get base memory shll $0xa,%eax # in bytes movl %eax,%ebp # Base of user stack -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl $m_mem,%esi # Display call hexout # amount of call putstr # base memory -') +#endif lgdt gdtdesc # Load new GDT # # Relocate caller's arguments. # -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl $m_esp,%esi # Display movl %esp,%eax # caller call hexout # stack @@ -91,7 +91,7 @@ start.1: movl (%ebx),%eax # Get argument and call hexout # Display it loop start.1 # Till done call putstr # End message -') +#endif movl $0x48,%ecx # Allocate space subl %ecx,%ebp # for bootinfo movl 0x18(%esp,1),%esi # Source: bootinfo @@ -101,24 +101,24 @@ start.1: movl (%ebx),%eax # Get argument and rep # Copy movsb # it movl %ebp,0x18(%esp,1) # Update pointer -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl $m_rel_bi,%esi # Display movl %ebp,%eax # bootinfo call hexout # relocation call putstr # message -') +#endif start_null_bi: movl $0x18,%ecx # Allocate space subl %ecx,%ebp # for arguments leal 0x4(%esp,1),%esi # Source movl %ebp,%edi # Destination rep # Copy movsb # them -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl $m_rel_args,%esi # Display movl %ebp,%eax # argument call hexout # relocation call putstr # message -') +#endif # # Set up BTX kernel. # @@ -149,30 +149,30 @@ ifdef(`BTXLDR_VERBOSE',` addl $MEM_TBL,%edi # address pushl %edi # Save load address movzwl 0xa(%ebx),%ecx # Image size -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE pushl %ecx # Save image size -') +#endif rep # Relocate movsb # BTX movl %esi,%ebx # Keep place -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl $m_rel_btx,%esi # Restore popl %eax # parameters call hexout # and -') +#endif popl %ebp # display -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl %ebp,%eax # the call hexout # relocation call putstr # message -') +#endif addl $PAG_SIZ,%ebp # Display -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl $m_base,%esi # the movl %ebp,%eax # user call hexout # base call putstr # address -') +#endif # # Set up ELF-format client program. # @@ -182,18 +182,18 @@ ifdef(`BTXLDR_VERBOSE',` call putstr # message start.2: jmp start.2 # Hang start.3: -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl $m_elf,%esi # Display ELF call putstr # message movl $m_segs,%esi # Format string -') +#endif movl $0x2,%edi # Segment count movl 0x1c(%ebx),%edx # Get e_phoff addl %ebx,%edx # To pointer movzwl 0x2c(%ebx),%ecx # Get e_phnum start.4: cmpl $0x1,(%edx) # Is p_type PT_LOAD? jne start.6 # No -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl 0x4(%edx),%eax # Display call hexout # p_offset movl 0x8(%edx),%eax # Display @@ -203,7 +203,7 @@ ifdef(`BTXLDR_VERBOSE',` movl 0x14(%edx),%eax # Display call hexout # p_memsz call putstr # End message -') +#endif pushl %esi # Save pushl %edi # working pushl %ecx # registers @@ -228,10 +228,10 @@ start.5: popl %ecx # Restore start.6: addl $0x20,%edx # To next entry loop start.4 # Till done start.7: -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE movl $m_done,%esi # Display done call putstr # message -') +#endif movl $start.8,%esi # Real mode stub movl $MEM_STUB,%edi # Destination movl $start.9-start.8,%ecx # Size @@ -366,7 +366,7 @@ gdtdesc: .word gdt.1-gdt-1 # Limit m_logo: .asciz " \nBTX loader 1.00 " m_vers: .asciz "BTX version is \0\n" e_fmt: .asciz "Error: Client format not supported\n" -ifdef(`BTXLDR_VERBOSE',` +#ifdef BTXLDR_VERBOSE m_mem: .asciz "Starting in protected mode (base mem=\0)\n" m_esp: .asciz "Arguments passed (esp=\0):\n" m_args: .asciz"<howto=" @@ -389,7 +389,7 @@ m_segs: .asciz "text segment: offset=" .asciz " filesz=" .asciz " memsz=\0\n" m_done: .asciz "Loading complete\n" -') +#endif # # Uninitialized data area. # diff --git a/sys/boot/i386/btx/btxldr/btxldr.s b/sys/boot/i386/btx/btxldr/btxldr.s deleted file mode 100644 index 7d4b121..0000000 --- a/sys/boot/i386/btx/btxldr/btxldr.s +++ /dev/null @@ -1,396 +0,0 @@ -# -# Copyright (c) 1998 Robert Nordier -# All rights reserved. -# -# Redistribution and use in source and binary forms are freely -# permitted provided that the above copyright notice and this -# paragraph and the following disclaimer are duplicated in all -# such forms. -# -# This software is provided "AS IS" and without any express or -# implied warranties, including, without limitation, the implied -# warranties of merchantability and fitness for a particular -# purpose. -# - -# $FreeBSD$ - -# -# Prototype BTX loader program, written in a couple of hours. The -# real thing should probably be more flexible, and in C. -# - -# -# Memory locations. -# - .set MEM_STUB,0x600 # Real mode stub - .set MEM_ESP,0x1000 # New stack pointer - .set MEM_TBL,0x5000 # BTX page tables - .set MEM_ENTRY,0x9010 # BTX entry point - .set MEM_DATA,start+0x1000 # Data segment -# -# Segment selectors. -# - .set SEL_SCODE,0x8 # 4GB code - .set SEL_SDATA,0x10 # 4GB data - .set SEL_RCODE,0x18 # 64K code - .set SEL_RDATA,0x20 # 64K data -# -# Paging constants. -# - .set PAG_SIZ,0x1000 # Page size - .set PAG_ENT,0x4 # Page entry size -# -# Screen constants. -# - .set SCR_MAT,0x7 # Mode/attribute - .set SCR_COL,0x50 # Columns per row - .set SCR_ROW,0x19 # Rows per screen -# -# BIOS Data Area locations. -# - .set BDA_MEM,0x413 # Free memory - .set BDA_SCR,0x449 # Video mode - .set BDA_POS,0x450 # Cursor position -# -# Required by aout gas inadequacy. -# - .set SIZ_STUB,0x1a # Size of stub -# -# We expect to be loaded by boot2 at the origin defined in ./Makefile. -# - .globl start -# -# BTX program loader for ELF clients. -# -start: cld # String ops inc - movl $m_logo,%esi # Identify - call putstr # ourselves - movzwl BDA_MEM,%eax # Get base memory - shll $0xa,%eax # in bytes - movl %eax,%ebp # Base of user stack -ifdef(`BTXLDR_VERBOSE',` - movl $m_mem,%esi # Display - call hexout # amount of - call putstr # base memory -') - lgdt gdtdesc # Load new GDT -# -# Relocate caller's arguments. -# -ifdef(`BTXLDR_VERBOSE',` - movl $m_esp,%esi # Display - movl %esp,%eax # caller - call hexout # stack - call putstr # pointer - movl $m_args,%esi # Format string - leal 0x4(%esp,1),%ebx # First argument - movl $0x6,%ecx # Count -start.1: movl (%ebx),%eax # Get argument and - addl $0x4,%ebx # bump pointer - call hexout # Display it - loop start.1 # Till done - call putstr # End message -') - movl $0x48,%ecx # Allocate space - subl %ecx,%ebp # for bootinfo - movl 0x18(%esp,1),%esi # Source: bootinfo - cmpl $0x0, %esi # If the bootinfo pointer - je start_null_bi # is null, don't copy it - movl %ebp,%edi # Destination - rep # Copy - movsb # it - movl %ebp,0x18(%esp,1) # Update pointer -ifdef(`BTXLDR_VERBOSE',` - movl $m_rel_bi,%esi # Display - movl %ebp,%eax # bootinfo - call hexout # relocation - call putstr # message -') -start_null_bi: movl $0x18,%ecx # Allocate space - subl %ecx,%ebp # for arguments - leal 0x4(%esp,1),%esi # Source - movl %ebp,%edi # Destination - rep # Copy - movsb # them -ifdef(`BTXLDR_VERBOSE',` - movl $m_rel_args,%esi # Display - movl %ebp,%eax # argument - call hexout # relocation - call putstr # message -') -# -# Set up BTX kernel. -# - movl $MEM_ESP,%esp # Set up new stack - movl $MEM_DATA,%ebx # Data segment - movl $m_vers,%esi # Display BTX - call putstr # version message - movb 0x5(%ebx),%al # Get major version - addb $'0',%al # Display - call putchr # it - movb $'.',%al # And a - call putchr # dot - movb 0x6(%ebx),%al # Get minor - xorb %ah,%ah # version - movb $0xa,%dl # Divide - divb %dl,%al # by 10 - addb $'0',%al # Display - call putchr # tens - movb %ah,%al # Get units - addb $'0',%al # Display - call putchr # units - call putstr # End message - movl %ebx,%esi # BTX image - movzwl 0x8(%ebx),%edi # Compute - orl $PAG_SIZ/PAG_ENT-1,%edi # the - incl %edi # BTX - shll $0x2,%edi # load - addl $MEM_TBL,%edi # address - pushl %edi # Save load address - movzwl 0xa(%ebx),%ecx # Image size -ifdef(`BTXLDR_VERBOSE',` - pushl %ecx # Save image size -') - rep # Relocate - movsb # BTX - movl %esi,%ebx # Keep place -ifdef(`BTXLDR_VERBOSE',` - movl $m_rel_btx,%esi # Restore - popl %eax # parameters - call hexout # and -') - popl %ebp # display -ifdef(`BTXLDR_VERBOSE',` - movl %ebp,%eax # the - call hexout # relocation - call putstr # message -') - addl $PAG_SIZ,%ebp # Display -ifdef(`BTXLDR_VERBOSE',` - movl $m_base,%esi # the - movl %ebp,%eax # user - call hexout # base - call putstr # address -') -# -# Set up ELF-format client program. -# - cmpl $0x464c457f,(%ebx) # ELF magic number? - je start.3 # Yes - movl $e_fmt,%esi # Display error - call putstr # message -start.2: jmp start.2 # Hang -start.3: -ifdef(`BTXLDR_VERBOSE',` - movl $m_elf,%esi # Display ELF - call putstr # message - movl $m_segs,%esi # Format string -') - movl $0x2,%edi # Segment count - movl 0x1c(%ebx),%edx # Get e_phoff - addl %ebx,%edx # To pointer - movzwl 0x2c(%ebx),%ecx # Get e_phnum -start.4: cmpl $0x1,(%edx) # Is p_type PT_LOAD? - jne start.6 # No -ifdef(`BTXLDR_VERBOSE',` - movl 0x4(%edx),%eax # Display - call hexout # p_offset - movl 0x8(%edx),%eax # Display - call hexout # p_vaddr - movl 0x10(%edx),%eax # Display - call hexout # p_filesz - movl 0x14(%edx),%eax # Display - call hexout # p_memsz - call putstr # End message -') - pushl %esi # Save - pushl %edi # working - pushl %ecx # registers - movl 0x4(%edx),%esi # Get p_offset - addl %ebx,%esi # as pointer - movl 0x8(%edx),%edi # Get p_vaddr - addl %ebp,%edi # as pointer - movl 0x10(%edx),%ecx # Get p_filesz - rep # Set up - movsb # segment - movl 0x14(%edx),%ecx # Any bytes - subl 0x10(%edx),%ecx # to zero? - jz start.5 # No - xorb %al,%al # Then - rep # zero - stosb # them -start.5: popl %ecx # Restore - popl %edi # working - popl %esi # registers - decl %edi # Segments to do - je start.7 # If none -start.6: addl $0x20,%edx # To next entry - loop start.4 # Till done -start.7: -ifdef(`BTXLDR_VERBOSE',` - movl $m_done,%esi # Display done - call putstr # message -') - movl $start.8,%esi # Real mode stub - movl $MEM_STUB,%edi # Destination - movl $start.9-start.8,%ecx # Size - rep # Relocate - movsb # it - ljmp $SEL_RCODE,$MEM_STUB # To 16-bit code - .code16 -start.8: xorw %ax,%ax # Data - movb $SEL_RDATA,%al # selector - movw %ax,%ss # Reload SS - movw %ax,%ds # Reset - movw %ax,%es # other - movw %ax,%fs # segment - movw %ax,%gs # limits - movl %cr0,%eax # Switch to - decw %ax # real - movl %eax,%cr0 # mode - ljmp $0,$MEM_ENTRY # Jump to BTX entry point -start.9: - .code32 -# -# Output message [ESI] followed by EAX in hex. -# -hexout: pushl %eax # Save - call putstr # Display message - popl %eax # Restore - pushl %esi # Save - pushl %edi # caller's - movl $buf,%edi # Buffer - pushl %edi # Save - call hex32 # To hex - xorb %al,%al # Terminate - stosb # string - popl %esi # Restore -hexout.1: lodsb # Get a char - cmpb $'0',%al # Leading zero? - je hexout.1 # Yes - testb %al,%al # End of string? - jne hexout.2 # No - decl %esi # Undo -hexout.2: decl %esi # Adjust for inc - call putstr # Display hex - popl %edi # Restore - popl %esi # caller's - ret # To caller -# -# Output zero-terminated string [ESI] to the console. -# -putstr.0: call putchr # Output char -putstr: lodsb # Load char - testb %al,%al # End of string? - jne putstr.0 # No - ret # To caller -# -# Output character AL to the console. -# -putchr: pusha # Save - xorl %ecx,%ecx # Zero for loops - movb $SCR_MAT,%ah # Mode/attribute - movl $BDA_POS,%ebx # BDA pointer - movw (%ebx),%dx # Cursor position - movl $0xb8000,%edi # Regen buffer (color) - cmpb %ah,BDA_SCR-BDA_POS(%ebx) # Mono mode? - jne putchr.1 # No - xorw %di,%di # Regen buffer (mono) -putchr.1: cmpb $0xa,%al # New line? - je putchr.2 # Yes - xchgl %eax,%ecx # Save char - movb $SCR_COL,%al # Columns per row - mulb %dh # * row position - addb %dl,%al # + column - adcb $0x0,%ah # position - shll %eax # * 2 - xchgl %eax,%ecx # Swap char, offset - movw %ax,(%edi,%ecx,1) # Write attr:char - incl %edx # Bump cursor - cmpb $SCR_COL,%dl # Beyond row? - jb putchr.3 # No -putchr.2: xorb %dl,%dl # Zero column - incb %dh # Bump row -putchr.3: cmpb $SCR_ROW,%dh # Beyond screen? - jb putchr.4 # No - leal 2*SCR_COL(%edi),%esi # New top line - movw $(SCR_ROW-1)*SCR_COL/2,%cx # Words to move - rep # Scroll - movsl # screen - movb $' ',%al # Space - movb $SCR_COL,%cl # Columns to clear - rep # Clear - stosw # line - movb $SCR_ROW-1,%dh # Bottom line -putchr.4: movw %dx,(%ebx) # Update position - popa # Restore - ret # To caller -# -# Convert EAX, AX, or AL to hex, saving the result to [EDI]. -# -hex32: pushl %eax # Save - shrl $0x10,%eax # Do upper - call hex16 # 16 - popl %eax # Restore -hex16: call hex16.1 # Do upper 8 -hex16.1: xchgb %ah,%al # Save/restore -hex8: pushl %eax # Save - shrb $0x4,%al # Do upper - call hex8.1 # 4 - popl %eax # Restore -hex8.1: andb $0xf,%al # Get lower 4 - cmpb $0xa,%al # Convert - sbbb $0x69,%al # to hex - das # digit - orb $0x20,%al # To lower case - stosb # Save char - ret # (Recursive) - - .data - .p2align 4 -# -# Global descriptor table. -# -gdt: .word 0x0,0x0,0x0,0x0 # Null entry - .word 0xffff,0x0,0x9a00,0xcf # SEL_SCODE - .word 0xffff,0x0,0x9200,0xcf # SEL_SDATA - .word 0xffff,0x0,0x9a00,0x0 # SEL_RCODE - .word 0xffff,0x0,0x9200,0x0 # SEL_RDATA -gdt.1: -gdtdesc: .word gdt.1-gdt-1 # Limit - .long gdt # Base -# -# Messages. -# -m_logo: .asciz " \nBTX loader 1.00 " -m_vers: .asciz "BTX version is \0\n" -e_fmt: .asciz "Error: Client format not supported\n" -ifdef(`BTXLDR_VERBOSE',` -m_mem: .asciz "Starting in protected mode (base mem=\0)\n" -m_esp: .asciz "Arguments passed (esp=\0):\n" -m_args: .asciz"<howto=" - .asciz" bootdev=" - .asciz" junk=" - .asciz" " - .asciz" " - .asciz" bootinfo=\0>\n" -m_rel_bi: .asciz "Relocated bootinfo (size=48) to \0\n" -m_rel_args: .asciz "Relocated arguments (size=18) to \0\n" -m_rel_btx: .asciz "Relocated kernel (size=\0) to \0\n" -m_base: .asciz "Client base address is \0\n" -m_elf: .asciz "Client format is ELF\n" -m_segs: .asciz "text segment: offset=" - .asciz " vaddr=" - .asciz " filesz=" - .asciz " memsz=\0\n" - .asciz "data segment: offset=" - .asciz " vaddr=" - .asciz " filesz=" - .asciz " memsz=\0\n" -m_done: .asciz "Loading complete\n" -') -# -# Uninitialized data area. -# -buf: # Scratch buffer diff --git a/sys/boot/i386/pxeldr/Makefile b/sys/boot/i386/pxeldr/Makefile index 3d9228f..f628e6d 100644 --- a/sys/boot/i386/pxeldr/Makefile +++ b/sys/boot/i386/pxeldr/Makefile @@ -7,21 +7,20 @@ PROG= ${LDR}.out INTERNALPROG= FILES= ${BOOT} MAN= ${BOOT}.8 -SRCS= ${LDR}.s +SRCS= ${LDR}.S CLEANFILES= ${BOOT} BOOT= pxeboot LDR= pxeldr ORG= 0x7c00 LOADER= loader -M4?= m4 .if defined(BOOT_PXELDR_PROBE_KEYBOARD) -M4FLAGS+= -DPROBE_KEYBOARD +CFLAGS+=-DPROBE_KEYBOARD .endif .if defined(BOOT_PXELDR_ALWAYS_SERIAL) -M4FLAGS+= -DALWAYS_SERIAL +CFLAGS+=-DALWAYS_SERIAL .endif LOADERBIN= ${.OBJDIR}/../loader/loader.bin @@ -40,10 +39,6 @@ ${LDR}: ${LDR}.out LDFLAGS+= -N -e start -Ttext ${ORG} -${LDR}.o: ${LDR}.s - (cd ${.CURDIR}; ${M4} ${M4FLAGS} ${LDR}.s) | \ - ${AS} ${AFLAGS} -o ${.TARGET} - CLEANFILES+= ${LOADER} ${LOADER}: ${LOADERBIN} ${BTXLDR} ${BTXKERN} diff --git a/sys/boot/i386/pxeldr/pxeldr.S b/sys/boot/i386/pxeldr/pxeldr.S index fa93c9c..a4bd663 100644 --- a/sys/boot/i386/pxeldr/pxeldr.S +++ b/sys/boot/i386/pxeldr/pxeldr.S @@ -110,12 +110,12 @@ start: cld # string ops inc orb $KARGS_FLAGS_PXE, 0x8(%bx) # kargs->bootflags |= # KARGS_FLAGS_PXE popl 0xc(%bx) # kargs->pxeinfo = *PXENV+ -ifdef(`ALWAYS_SERIAL',` +#ifdef ALWAYS_SERIAL # # set the RBX_SERIAL bit in the howto byte. orl $RB_SERIAL, (%bx) # enable serial console -') -ifdef(`PROBE_KEYBOARD',` +#endif +#ifdef PROBE_KEYBOARD # # Look at the BIOS data area to see if we have an enhanced keyboard. If not, # set the RBX_SERIAL bit in the howto byte. @@ -123,7 +123,7 @@ ifdef(`PROBE_KEYBOARD',` jnz keyb # yes, so skip orl $RB_SERIAL, (%bx) # enable serial console keyb: -') +#endif # # Turn on the A20 address line # diff --git a/sys/boot/i386/pxeldr/pxeldr.s b/sys/boot/i386/pxeldr/pxeldr.s deleted file mode 100644 index fa93c9c..0000000 --- a/sys/boot/i386/pxeldr/pxeldr.s +++ /dev/null @@ -1,287 +0,0 @@ -# -# Copyright (c) 2000 John Baldwin -# All rights reserved. -# -# Redistribution and use in source and binary forms are freely -# permitted provided that the above copyright notice and this -# paragraph and the following disclaimer are duplicated in all -# such forms. -# -# This software is provided "AS IS" and without any express or -# implied warranties, including, without limitation, the implied -# warranties of merchantability and fitness for a particular -# purpose. -# - -# $FreeBSD$ - -# -# This simple program is a preloader for the normal boot3 loader. It is simply -# prepended to the beginning of a fully built and btxld'd loader. It then -# copies the loader to the address boot2 normally loads it, emulates the -# boot[12] environment (protected mode, a bootinfo struct, etc.), and then jumps -# to the start of btxldr to start the boot process. This method allows a stock -# /boot/loader to be booted over the network via PXE w/o having to write a -# separate PXE-aware client just to load the loader. -# - -# -# Memory locations. -# - .set MEM_PAGE_SIZE,0x1000 # memory page size, 4k - .set MEM_ARG,0x900 # Arguments at start - .set MEM_ARG_BTX,0xa100 # Where we move them to so the - # BTX client can see them - .set MEM_ARG_SIZE,0x18 # Size of the arguments - .set MEM_BTX_ADDRESS,0x9000 # where BTX lives - .set MEM_BTX_ENTRY,0x9010 # where BTX starts to execute - .set MEM_BTX_OFFSET,MEM_PAGE_SIZE # offset of BTX in the loader - .set MEM_BTX_CLIENT,0xa000 # where BTX clients live - .set MEM_BIOS_KEYBOARD,0x496 # BDA byte with keyboard bit -# -# a.out header fields -# - .set AOUT_TEXT,0x04 # text segment size - .set AOUT_DATA,0x08 # data segment size - .set AOUT_BSS,0x0c # zero'd BSS size - .set AOUT_SYMBOLS,0x10 # symbol table - .set AOUT_ENTRY,0x14 # entry point - .set AOUT_HEADER,MEM_PAGE_SIZE # size of the a.out header -# -# Flags for kargs->bootflags -# - .set KARGS_FLAGS_PXE,0x2 # flag to indicate booting from - # PXE loader -# -# Boot howto bits -# - .set RB_SERIAL,0x1000 # serial console -# -# Segment selectors. -# - .set SEL_SDATA,0x8 # Supervisor data - .set SEL_RDATA,0x10 # Real mode data - .set SEL_SCODE,0x18 # PM-32 code - .set SEL_SCODE16,0x20 # PM-16 code -# -# BTX constants -# - .set INT_SYS,0x30 # BTX syscall interrupt -# -# Bit in MEM_BIOS_KEYBOARD that is set if an enhanced keyboard is present -# - .set KEYBOARD_BIT,0x10 -# -# We expect to be loaded by the BIOS at 0x7c00 (standard boot loader entry -# point) -# - .code16 - .globl start - .org 0x0, 0x0 -# -# BTX program loader for PXE network booting -# -start: cld # string ops inc - xorw %ax, %ax # zero %ax - movw %ax, %ss # setup the - movw $start, %sp # stack - movw %es, %cx # save PXENV+ segment - movw %ax, %ds # setup the - movw %ax, %es # data segments - andl $0xffff, %ecx # clear upper words - andl $0xffff, %ebx # of %ebx and %ecx - shll $4, %ecx # calculate the offset of - addl %ebx, %ecx # the PXENV+ struct and - pushl %ecx # save it on the stack - movw $welcome_msg, %si # %ds:(%si) -> welcome message - callw putstr # display the welcome message -# -# Setup the arguments that the loader is expecting from boot[12] -# - movw $bootinfo_msg, %si # %ds:(%si) -> boot args message - callw putstr # display the message - movw $MEM_ARG, %bx # %ds:(%bx) -> boot args - movw %bx, %di # %es:(%di) -> boot args - xorl %eax, %eax # zero %eax - movw $(MEM_ARG_SIZE/4), %cx # Size of arguments in 32-bit - # dwords - rep # Clear the arguments - stosl # to zero - orb $KARGS_FLAGS_PXE, 0x8(%bx) # kargs->bootflags |= - # KARGS_FLAGS_PXE - popl 0xc(%bx) # kargs->pxeinfo = *PXENV+ -ifdef(`ALWAYS_SERIAL',` -# -# set the RBX_SERIAL bit in the howto byte. - orl $RB_SERIAL, (%bx) # enable serial console -') -ifdef(`PROBE_KEYBOARD',` -# -# Look at the BIOS data area to see if we have an enhanced keyboard. If not, -# set the RBX_SERIAL bit in the howto byte. - testb $KEYBOARD_BIT, MEM_BIOS_KEYBOARD # keyboard present? - jnz keyb # yes, so skip - orl $RB_SERIAL, (%bx) # enable serial console -keyb: -') -# -# Turn on the A20 address line -# - callw seta20 # Turn A20 on -# -# Relocate the loader and BTX using a very lazy protected mode -# - movw $relocate_msg, %si # Display the - callw putstr # relocation message - movl end+AOUT_ENTRY, %edi # %edi is the destination - movl $(end+AOUT_HEADER), %esi # %esi is - # the start of the text - # segment - movl end+AOUT_TEXT, %ecx # %ecx = length of the text - # segment - lgdt gdtdesc # setup our own gdt - cli # turn off interrupts - movl %cr0, %eax # Turn on - orb $0x1, %al # protected - movl %eax, %cr0 # mode - ljmp $SEL_SCODE,$pm_start # long jump to clear the - # instruction pre-fetch queue - .code32 -pm_start: movw $SEL_SDATA, %ax # Initialize - movw %ax, %ds # %ds and - movw %ax, %es # %es to a flat selector - rep # Relocate the - movsb # text segment - addl $(MEM_PAGE_SIZE - 1), %edi # pad %edi out to a new page - andl $~(MEM_PAGE_SIZE - 1), %edi # for the data segment - movl end+AOUT_DATA, %ecx # size of the data segment - rep # Relocate the - movsb # data segment - movl end+AOUT_BSS, %ecx # size of the bss - xorl %eax, %eax # zero %eax - addb $3, %cl # round %ecx up to - shrl $2, %ecx # a multiple of 4 - rep # zero the - stosl # bss - movl end+AOUT_ENTRY, %esi # %esi -> relocated loader - addl $MEM_BTX_OFFSET, %esi # %esi -> BTX in the loader - movl $MEM_BTX_ADDRESS, %edi # %edi -> where BTX needs to go - movzwl 0xa(%esi), %ecx # %ecx -> length of BTX - rep # Relocate - movsb # BTX - ljmp $SEL_SCODE16,$pm_16 # Jump to 16-bit PM - .code16 -pm_16: movw $SEL_RDATA, %ax # Initialize - movw %ax, %ds # %ds and - movw %ax, %es # %es to a real mode selector - movl %cr0, %eax # Turn off - andb $~0x1, %al # protected - movl %eax, %cr0 # mode - ljmp $0,$pm_end # Long jump to clear the - # instruction pre-fetch queue -pm_end: sti # Turn interrupts back on now -# -# Copy the BTX client to MEM_BTX_CLIENT -# - xorw %ax, %ax # zero %ax and set - movw %ax, %ds # %ds and %es - movw %ax, %es # to segment 0 - movw $MEM_BTX_CLIENT, %di # Prepare to relocate - movw $btx_client, %si # the simple btx client - movw $(btx_client_end-btx_client), %cx # length of btx client - rep # Relocate the - movsb # simple BTX client -# -# Copy the boot[12] args to where the BTX client can see them -# - movw $MEM_ARG, %si # where the args are at now - movw $MEM_ARG_BTX, %di # where the args are moving to - movw $(MEM_ARG_SIZE/4), %cx # size of the arguments in longs - rep # Relocate - movsl # the words -# -# Save the entry point so the client can get to it later on -# - movl end+AOUT_ENTRY, %eax # load the entry point - stosl # add it to the end of the - # arguments -# -# Now we just start up BTX and let it do the rest -# - movw $jump_message, %si # Display the - callw putstr # jump message - ljmp $0,$MEM_BTX_ENTRY # Jump to the BTX entry point - -# -# Display a null-terminated string -# -putstr: lodsb # load %al from %ds:(%si) - testb %al,%al # stop at null - jnz putc # if the char != null, output it - retw # return when null is hit -putc: movw $0x7,%bx # attribute for output - movb $0xe,%ah # BIOS: put_char - int $0x10 # call BIOS, print char in %al - jmp putstr # keep looping - -# -# Enable A20 -# -seta20: cli # Disable interrupts -seta20.1: inb $0x64,%al # Get status - testb $0x2,%al # Busy? - jnz seta20.1 # Yes - movb $0xd1,%al # Command: Write - outb %al,$0x64 # output port -seta20.2: inb $0x64,%al # Get status - testb $0x2,%al # Busy? - jnz seta20.2 # Yes - movb $0xdf,%al # Enable - outb %al,$0x60 # A20 - sti # Enable interrupts - retw # To caller - -# -# BTX client to start btxldr -# - .code32 -btx_client: movl $(MEM_ARG_BTX-MEM_BTX_CLIENT+MEM_ARG_SIZE-4), %esi - # %ds:(%esi) -> end - # of boot[12] args - movl $(MEM_ARG_SIZE/4), %ecx # Number of words to push - std # Go backwards -push_arg: lodsl # Read argument - pushl %eax # Push it onto the stack - loop push_arg # Push all of the arguments - cld # In case anyone depends on this - pushl MEM_ARG_BTX-MEM_BTX_CLIENT+MEM_ARG_SIZE # Entry point of - # the loader - pushl %eax # Emulate a near call - movl $0x1, %eax # 'exec' system call - int $INT_SYS # BTX system call -btx_client_end: - .code16 - - .p2align 4 -# -# Global descriptor table. -# -gdt: .word 0x0,0x0,0x0,0x0 # Null entry - .word 0xffff,0x0,0x9200,0xcf # SEL_SDATA - .word 0xffff,0x0,0x9200,0x0 # SEL_RDATA - .word 0xffff,0x0,0x9a00,0xcf # SEL_SCODE (32-bit) - .word 0xffff,0x0,0x9a00,0x8f # SEL_SCODE16 (16-bit) -gdt.1: -# -# Pseudo-descriptors. -# -gdtdesc: .word gdt.1-gdt-1 # Limit - .long gdt # Base - -welcome_msg: .asciz "PXE Loader 1.00\r\n\n" -bootinfo_msg: .asciz "Building the boot loader arguments\r\n" -relocate_msg: .asciz "Relocating the loader and the BTX\r\n" -jump_message: .asciz "Starting the BTX loader\r\n" - - .p2align 4 -end: |
