banan-os/bootloader/bios/boot.S

.code16

#########################################
#
# STAGE 1 BOOTLOADER
#
# its sole purpose is to load stage2 from
# bios boot partition
#
#########################################

.section .stage1

.global stage1_main
stage1_main:
	# setup segments
	movw $0, %ax
	movw %ax, %ds
	movw %ax, %es

	# setup stack
	movw %ax, %ss
	movl $0x7C00, %esp

	# save boot disk number
	call read_stage2_into_memory

	jmp stage2_main

.global print_and_halt
print_and_halt:
	call puts
halt:
	hlt
	jmp halt


#########################################
#
# STAGE 2 BOOTLOADER
#
#########################################

.section .stage2

stage2_main:
	# clear screen and enter 80x25 text mode
	movb $0x03, %al
	movb $0x00, %ah
	int $0x10

	# print hello message
	movw $hello_msg, %si
	call puts; call print_newline

	call enter_unreal_mode
	movw $unreal_enter_msg, %si
	call puts; call print_newline

	call get_memory_map
	call read_user_command_line
	
	movw $800, %ax
	movw $600, %bx
	movb $32,  %cl
	call vesa_find_video_mode

	call print_newline

	movw $start_kernel_load_msg, %si
	call puts; call print_newline

	call print_memory_map

	call find_root_disk
	call find_root_partition

	call print_root_partition_info
	call print_newline

	call has_ext2_filesystem
	testb %al, %al
	jz print_and_halt

	call ext2_find_kernel
	movl $ext2_inode_read_bytes, %esi

	call elf_read_kernel_to_memory

	call vesa_set_target_mode

	cli

	# setup protected mode
	movl %cr0, %ebx
	orb $1, %bl
	movl %ebx, %cr0

	# jump to kernel in protected mode
	ljmpl $0x18, $protected_mode


.code32
protected_mode:
	movw $0x10, %bx
	movw %bx, %ds
	movw %bx, %es
	movw %bx, %fs
	movw %bx, %gs
	movw %bx, %ss

	movl %eax, %ecx

	movl $0xD3C60CFF, %eax
	movl $banan_boot_info, %ebx
	xorl %edx, %edx
	xorl %esi, %esi
	xorl %edi, %edi

	jmp *%ecx


.code16
enter_unreal_mode:
	cli
	pushw %ds

	lgdt gdtr

	movl %cr0, %eax
	orb $1, %al
	movl %eax, %cr0
	ljmpl $0x8, $.enter_unreal_mode_pmode

 .enter_unreal_mode_pmode:
	movw $0x10, %bx
	movw %bx, %ds

	andb 0xFE, %al
	movl %eax, %cr0
	ljmpl $0x0, $.enter_unreal_mode_unreal

 .enter_unreal_mode_unreal:
	popw %ds
	sti

	ret

hello_msg:
	.asciz "This is banan-os bootloader"

unreal_enter_msg:
	.asciz "Entered unreal mode"

start_kernel_load_msg:
	.asciz "Starting to load kernel"

gdt:
	.quad 0x0000000000000000
	.quad 0x00009A000000FFFF
	.quad 0x00CF92000000FFFF
	.quad 0x00CF9A000000FFFF
gdtr:
	.short . - gdt - 1
	.quad gdt

banan_boot_info:
	boot_command_line:
		.long command_line
	boot_framebuffer:
		.long framebuffer
	boot_memory_map:
		.long memory_map
Bootloader: Start work on bootloader I wrote a fast first stage bootloader and a installer to put it into a disk image. 2023-11-09 22:42:47 +02:00			`.code16`

			`#########################################`
			`#`
			`# STAGE 1 BOOTLOADER`
			`#`
			`# its sole purpose is to load stage2 from`
			`# bios boot partition`
			`#`
			`#########################################`

			`.section .stage1`

Bootloader: Split bootloader into multiple files This cleans up the code since bootloader is starting to near 1k lines 2023-11-14 03:26:03 +02:00			`.global stage1_main`
Bootloader: Continue work on bootloader Bootloader can now get the memory map and read cmdline from user. Now 'just' video mode query, ext2 and ELF parsing are needed :D 2023-11-11 22:49:00 +02:00			`stage1_main:`
Bootloader: Start work on bootloader I wrote a fast first stage bootloader and a installer to put it into a disk image. 2023-11-09 22:42:47 +02:00			`# setup segments`
			`movw $0, %ax`
			`movw %ax, %ds`
			`movw %ax, %es`

			`# setup stack`
			`movw %ax, %ss`
Bootloader: Find root partition from GPT header 2023-11-13 18:55:48 +02:00			`movl $0x7C00, %esp`
Bootloader: Start work on bootloader I wrote a fast first stage bootloader and a installer to put it into a disk image. 2023-11-09 22:42:47 +02:00
			`# save boot disk number`
Bootloader: Split bootloader into multiple files This cleans up the code since bootloader is starting to near 1k lines 2023-11-14 03:26:03 +02:00			`call read_stage2_into_memory`
Bootloader: Find root partition from GPT header 2023-11-13 18:55:48 +02:00
Bootloader: Continue work on bootloader Bootloader can now get the memory map and read cmdline from user. Now 'just' video mode query, ext2 and ELF parsing are needed :D 2023-11-11 22:49:00 +02:00			`jmp stage2_main`
Bootloader: Start work on bootloader I wrote a fast first stage bootloader and a installer to put it into a disk image. 2023-11-09 22:42:47 +02:00
Bootloader: Split bootloader into multiple files This cleans up the code since bootloader is starting to near 1k lines 2023-11-14 03:26:03 +02:00			`.global print_and_halt`
Bootloader: Start work on bootloader I wrote a fast first stage bootloader and a installer to put it into a disk image. 2023-11-09 22:42:47 +02:00			`print_and_halt:`
			`call puts`
			`halt:`
			`hlt`
			`jmp halt`


			`#########################################`
			`#`
			`# STAGE 2 BOOTLOADER`
			`#`
			`#########################################`

			`.section .stage2`
Bootloader: Continue work on bootloader Bootloader can now get the memory map and read cmdline from user. Now 'just' video mode query, ext2 and ELF parsing are needed :D 2023-11-11 22:49:00 +02:00
Bootloader: Find root partition from GPT header 2023-11-13 18:55:48 +02:00			`stage2_main:`
			`# clear screen and enter 80x25 text mode`
			`movb $0x03, %al`
			`movb $0x00, %ah`
			`int $0x10`

			`# print hello message`
			`movw $hello_msg, %si`
			`call puts; call print_newline`

Bootloader enter unreal mode at the start of stage2 2023-11-17 14:22:21 +02:00			`call enter_unreal_mode`
			`movw $unreal_enter_msg, %si`
			`call puts; call print_newline`

Bootloader: Find root partition from GPT header 2023-11-13 18:55:48 +02:00			`call get_memory_map`
Bootloader: Split bootloader into multiple files This cleans up the code since bootloader is starting to near 1k lines 2023-11-14 03:26:03 +02:00			`call read_user_command_line`
Bootloader: Implement VESA video mode query and pass it to kernel Kernel now gets framebuffer from bootloader. Framebuffer dimensions and bpp are hardcoded in bootloader, but will probably be read from config file at some point. 2023-11-17 22:45:35 +02:00
Bootloader: Generalize framebuffer video mode search Framebuffer size is now taken as arguments to vesa_find_video_mode 2023-12-09 16:48:04 +02:00			`movw $800, %ax`
			`movw $600, %bx`
			`movb $32, %cl`
Bootloader: Implement VESA video mode query and pass it to kernel Kernel now gets framebuffer from bootloader. Framebuffer dimensions and bpp are hardcoded in bootloader, but will probably be read from config file at some point. 2023-11-17 22:45:35 +02:00			`call vesa_find_video_mode`
Bootloader: Find root partition from GPT header 2023-11-13 18:55:48 +02:00
			`call print_newline`

			`movw $start_kernel_load_msg, %si`
			`call puts; call print_newline`

			`call print_memory_map`

			`call find_root_disk`
			`call find_root_partition`

Bootloader: Split bootloader into multiple files This cleans up the code since bootloader is starting to near 1k lines 2023-11-14 03:26:03 +02:00			`call print_root_partition_info`
Bootloader: Implement basic ext2 filesystem This can search for files in an ext2 filesystem. Only 12 blocks are currently supported. Now only ELF loading is missing for loading the actual kernel! 2023-11-15 16:36:53 +02:00			`call print_newline`

			`call has_ext2_filesystem`
			`testb %al, %al`
			`jz print_and_halt`

			`call ext2_find_kernel`
Bootloader: Load kernel to memory and jump to it! 2023-11-17 16:36:29 +02:00			`movl $ext2_inode_read_bytes, %esi`

			`call elf_read_kernel_to_memory`

Bootloader: Implement VESA video mode query and pass it to kernel Kernel now gets framebuffer from bootloader. Framebuffer dimensions and bpp are hardcoded in bootloader, but will probably be read from config file at some point. 2023-11-17 22:45:35 +02:00			`call vesa_set_target_mode`
Bootloader: Load kernel to memory and jump to it! 2023-11-17 16:36:29 +02:00
Bootloader: Clear screen, better memcpy Clear screen before jumping to kernel. Memcpy now uses ebx as offset register, so only one register has to updated every loop 2023-11-17 20:31:42 +02:00			`cli`
Bootloader: Load kernel to memory and jump to it! 2023-11-17 16:36:29 +02:00
			`# setup protected mode`
			`movl %cr0, %ebx`
			`orb $1, %bl`
			`movl %ebx, %cr0`
Bootloader: Continue work on bootloader Bootloader can now get the memory map and read cmdline from user. Now 'just' video mode query, ext2 and ELF parsing are needed :D 2023-11-11 22:49:00 +02:00
Bootloader: Load kernel to memory and jump to it! 2023-11-17 16:36:29 +02:00			`# jump to kernel in protected mode`
			`ljmpl $0x18, $protected_mode`
Bootloader enter unreal mode at the start of stage2 2023-11-17 14:22:21 +02:00
Bootloader: Load kernel to memory and jump to it! 2023-11-17 16:36:29 +02:00
			`.code32`
			`protected_mode:`
			`movw $0x10, %bx`
			`movw %bx, %ds`
			`movw %bx, %es`
			`movw %bx, %fs`
			`movw %bx, %gs`
			`movw %bx, %ss`
Kernel/Bootloader: banan-os can now be booted with my bootloader :D 2023-11-17 20:33:02 +02:00
			`movl %eax, %ecx`

			`movl $0xD3C60CFF, %eax`
			`movl $banan_boot_info, %ebx`
			`xorl %edx, %edx`
			`xorl %esi, %esi`
			`xorl %edi, %edi`

			`jmp *%ecx`
Bootloader: Load kernel to memory and jump to it! 2023-11-17 16:36:29 +02:00

			`.code16`
Bootloader enter unreal mode at the start of stage2 2023-11-17 14:22:21 +02:00			`enter_unreal_mode:`
			`cli`
			`pushw %ds`

			`lgdt gdtr`

			`movl %cr0, %eax`
			`orb $1, %al`
			`movl %eax, %cr0`
			`ljmpl $0x8, $.enter_unreal_mode_pmode`

			`.enter_unreal_mode_pmode:`
			`movw $0x10, %bx`
			`movw %bx, %ds`

			`andb 0xFE, %al`
			`movl %eax, %cr0`
			`ljmpl $0x0, $.enter_unreal_mode_unreal`

			`.enter_unreal_mode_unreal:`
			`popw %ds`
			`sti`

			`ret`

Bootloader: Start work on bootloader I wrote a fast first stage bootloader and a installer to put it into a disk image. 2023-11-09 22:42:47 +02:00			`hello_msg:`
			`.asciz "This is banan-os bootloader"`

Bootloader enter unreal mode at the start of stage2 2023-11-17 14:22:21 +02:00			`unreal_enter_msg:`
			`.asciz "Entered unreal mode"`

Bootloader: Continue work on bootloader Bootloader can now get the memory map and read cmdline from user. Now 'just' video mode query, ext2 and ELF parsing are needed :D 2023-11-11 22:49:00 +02:00			`start_kernel_load_msg:`
			`.asciz "Starting to load kernel"`
Bootloader enter unreal mode at the start of stage2 2023-11-17 14:22:21 +02:00
			`gdt:`
			`.quad 0x0000000000000000`
			`.quad 0x00009A000000FFFF`
			`.quad 0x00CF92000000FFFF`
Bootloader: Load kernel to memory and jump to it! 2023-11-17 16:36:29 +02:00			`.quad 0x00CF9A000000FFFF`
Bootloader enter unreal mode at the start of stage2 2023-11-17 14:22:21 +02:00			`gdtr:`
			`.short . - gdt - 1`
			`.quad gdt`
Kernel/Bootloader: banan-os can now be booted with my bootloader :D 2023-11-17 20:33:02 +02:00
			`banan_boot_info:`
			`boot_command_line:`
			`.long command_line`
Bootloader: Implement VESA video mode query and pass it to kernel Kernel now gets framebuffer from bootloader. Framebuffer dimensions and bpp are hardcoded in bootloader, but will probably be read from config file at some point. 2023-11-17 22:45:35 +02:00			`boot_framebuffer:`
			`.long framebuffer`
Kernel/Bootloader: banan-os can now be booted with my bootloader :D 2023-11-17 20:33:02 +02:00			`boot_memory_map:`
			`.long memory_map`