271 lines
7.9 KiB
ArmAsm
271 lines
7.9 KiB
ArmAsm
// vim: et:sw=12:ts=12:sts=12
|
|
|
|
.global _start
|
|
.text
|
|
.code16
|
|
|
|
// _start: entry point
|
|
_start: cli
|
|
cld
|
|
|
|
// we keep our text and data close to each other
|
|
xor %ax, %ax
|
|
mov %ax, %ds
|
|
|
|
call init_com1
|
|
|
|
mov $msg_start, %si
|
|
call print
|
|
|
|
mov $msg_a20, %si
|
|
call print
|
|
call enable_a20
|
|
|
|
mov $msg_unreal, %si
|
|
call print
|
|
call unreal
|
|
|
|
mov $msg_getmap, %si
|
|
call print
|
|
call getmap
|
|
|
|
mov $msg_mkheap, %si
|
|
call print
|
|
call makeheap
|
|
|
|
mov $msg_paging, %si
|
|
call print
|
|
call paging
|
|
|
|
mov $msg_fin, %si
|
|
call print
|
|
|
|
// hang: sleep indefinitely
|
|
hang: hlt
|
|
jmp hang
|
|
|
|
.set COM1, 0x3F8
|
|
.macro com1_write offset=0, byte
|
|
mov $COM1+\offset, %dx
|
|
mov $\byte, %al
|
|
outb %al, %dx
|
|
.endm
|
|
|
|
// init_com1: Set up COM1 port for debug output
|
|
init_com1: com1_write 1, 0x00 // clear interrupts
|
|
com1_write 3, 0x80 // set DLAB to 1
|
|
com1_write 0, 0x0C // 9600 baud rate
|
|
com1_write 1, 0x00
|
|
com1_write 3, 0x07 // 8 bit data + 1 parity bit
|
|
ret
|
|
|
|
// enable_a20: Allow use of 'high' memory
|
|
enable_a20: // TODO more thorough implementation
|
|
inb $0x92, %al
|
|
or $2, %al
|
|
outb %al, $0x92
|
|
ret
|
|
|
|
// unreal: Enter unreal mode
|
|
unreal: push %ds
|
|
lgdt gdt_ptr
|
|
|
|
mov %cr0, %eax
|
|
or $0x01, %al
|
|
mov %eax, %cr0
|
|
ljmp $0x8, $_prot
|
|
|
|
_prot: mov $0x10, %cx
|
|
mov %cx, %ds
|
|
|
|
and $0xFE, %al
|
|
mov %eax, %cr0
|
|
ljmp $0x0, $_unreal
|
|
|
|
_unreal: pop %ds
|
|
ret
|
|
|
|
// getmap: Retrieve memory map using e820 BIOS function
|
|
getmap: mov %ds, %ax
|
|
mov %ax, %es
|
|
mov $memmap, %di
|
|
xor %ebx, %ebx
|
|
mov $0x534D4150, %edx // e820 magic number
|
|
_nextmap: movl $0, 20(%di)
|
|
mov $24, %ecx
|
|
mov $0xE820, %eax
|
|
int $0x15
|
|
jc _endmap
|
|
test %ebx, %ebx
|
|
jz _endmap
|
|
add $24, %di
|
|
jmp _nextmap
|
|
_endmap: add $24, %di
|
|
mov %di, memmap_end
|
|
ret
|
|
|
|
// paging: Set up initial page tables for long mode
|
|
paging:
|
|
mov $4*4096, %ecx
|
|
call alloc
|
|
mov %eax, pd_ptr
|
|
mov $4096, %ecx
|
|
call alloc
|
|
mov %eax, pdp_ptr
|
|
mov $4096, %ecx
|
|
call alloc
|
|
mov %eax, pml4_ptr
|
|
|
|
mov pd_ptr, %edi
|
|
xor %ecx, %ecx
|
|
_pgnext: mov %ecx, %eax
|
|
shl $21, %eax
|
|
or $0b110000111, %eax
|
|
movl %eax, 0(%edi)
|
|
//movl %eax, 0(%edi,%ecx,8)
|
|
//movl $0, 4(%edi,%ecx,8)
|
|
inc %ecx
|
|
cmp $4*512, %ecx
|
|
jne _pgnext
|
|
|
|
//mov pml4_ptr, %edi
|
|
//movl 0(%edi)
|
|
//movl $0, 4(%edi)
|
|
|
|
ret
|
|
|
|
// makeheap: find a memory range suitable for heap usage
|
|
makeheap: mov $memmap-24, %si
|
|
_mhnext: add $24, %si
|
|
cmp memmap_end, %si
|
|
jae _mhdone
|
|
|
|
cmpl $1, 16(%si)
|
|
jne _mhnext
|
|
|
|
cmpl $0, 4(%si)
|
|
ja _mhnext
|
|
|
|
mov 0(%si), %ebx
|
|
mov 8(%si), %ecx
|
|
|
|
// find end of range, clip to 4Gb
|
|
add %ebx, %ecx
|
|
jnc 1f
|
|
mov $0xFFFFFFFF, %ecx
|
|
|
|
// handle wraparound if length > 4Gb
|
|
1: cmpl $0, 12(%si)
|
|
je 1f
|
|
mov $0xFFFFFFFF, %ecx
|
|
|
|
// adjust base to above 1Mb, above the bootloader
|
|
1: cmp $0x10000, %ebx
|
|
jae 1f
|
|
mov $0x10000, %ebx
|
|
|
|
// align to 4Kb boundaries
|
|
1: add $0xFFF, %ebx
|
|
and $0xFFFFF000, %ebx
|
|
and $0xFFFFF000, %ecx
|
|
|
|
sub %ebx, %ecx
|
|
cmp heap_size, %ecx
|
|
jbe _mhnext
|
|
|
|
mov %ebx, heap_start
|
|
mov %ecx, heap_size
|
|
jmp _mhnext
|
|
|
|
_mhdone: ret
|
|
|
|
// alloc: take ECX bytes from usable space in memmap
|
|
// No realignment is performed, so only alloc aligned sizes.
|
|
alloc: mov $memmap-24, %si
|
|
_anext: add $24, %si
|
|
cmp memmap_end, %si // ran over end of memmap?
|
|
jae _aerr
|
|
cmpl $1, 16(%si)
|
|
jne _anext
|
|
// TODO check that entry has enough space
|
|
cmpl $0, 4(%si) // memory is above 4Gb?
|
|
jne _aerr
|
|
mov 0(%si), %eax
|
|
addl %ecx, 0(%si)
|
|
adcl $0, 4(%si)
|
|
subl %ecx, 8(%si)
|
|
sbbl $0, 12(%si)
|
|
ret
|
|
_aerr: mov $msg_aerr, %si
|
|
call print
|
|
jmp hang
|
|
|
|
// print: print NUL-terminated string pointed to by SI
|
|
print: xor %bx, %bx
|
|
|
|
_nextchr: mov $COM1+5, %dx
|
|
inb %dx, %al
|
|
test $0x20, %al
|
|
jz _nextchr
|
|
|
|
lodsb
|
|
or %al, %al
|
|
jz _endprint
|
|
|
|
mov $COM1, %dx
|
|
outb %al, %dx
|
|
|
|
mov $0x0E, %ah
|
|
int $0x10
|
|
jmp _nextchr
|
|
|
|
_endprint: ret
|
|
|
|
// gdt: Protected mode / Unreal mode 16-bit GDT
|
|
gdt: // entry 0: null descriptor
|
|
.word 0
|
|
.word 0
|
|
.byte 0
|
|
.byte 0
|
|
.byte 0
|
|
.byte 0
|
|
// entry 1: code segment
|
|
.word 0xFFFF
|
|
.word 0
|
|
.byte 0
|
|
.byte 0b10011010
|
|
.byte 0x8F
|
|
.byte 0
|
|
// entry 2: data segment
|
|
.word 0xFFFF
|
|
.word 0
|
|
.byte 0
|
|
.byte 0b10010010
|
|
.byte 0x8F
|
|
.byte 0
|
|
.set gdt_size, .-gdt
|
|
gdt_ptr: .word gdt_size-1
|
|
.long gdt
|
|
|
|
// Messages to print
|
|
msg_start: .asciz "Netboot via fernlader v1 ...\r\n"
|
|
msg_a20: .asciz " * Enabling A20\r\n"
|
|
msg_unreal: .asciz " * Unreal Mode\r\n"
|
|
msg_getmap: .asciz " * Memory Map\r\n"
|
|
msg_mkheap: .asciz " * Making Space\r\n"
|
|
msg_paging: .asciz " * Paging\r\n"
|
|
msg_fin: .asciz "Finished.\r\n"
|
|
msg_aerr: .asciz "panic: Unable to allocate memory.\r\n"
|
|
|
|
heap_start: .long 0
|
|
heap_size: .long 0
|
|
|
|
// Long mode initial page tables
|
|
pd_ptr: .long 0
|
|
pdp_ptr: .long 0
|
|
pml4_ptr: .long 0
|
|
|
|
// Memory map area
|
|
memmap_end: .word 0
|
|
.align 8
|
|
memmap: // begins at end of binary
|