Import backup from 2004-01-26

Import backup from 2004-01-20
Import backup from 2004-01-18
2017-07-25 22:23:46 -04:00 · 2017-07-25 22:23:46 -04:00 · 2017-07-25 22:23:46 -04:00 · 2017-07-25 22:23:46 -04:00 · 2017-07-25 22:23:45 -04:00 · 2017-07-25 22:23:45 -04:00
85 changed files with 4696 additions and 2155 deletions
@@ -0,0 +1,276 @@
+//Functions.c
+//05/07/03 Josh Holtrop
+//for HOS
+//Modified: 10/30/03
+
+//Writes a byte out to a port
+inline void outportb(unsigned int port, unsigned char value)		// Output a byte to a port
+{
+    asm volatile ("outb %%al,%%dx"::"d" (port), "a" (value));
+};
+
+//Writes a word out to a port
+inline void outportw(unsigned int port, unsigned int value)		// Output a word to a port
+{
+    asm volatile ("outw %%ax,%%dx"::"d" (port), "a" (value));
+};
+
+//Reads a byte from a port
+inline byte inportb(unsigned short port)
+{
+	unsigned char ret_val;
+
+	asm volatile("inb %w1,%b0"
+		: "=a"(ret_val)
+		: "d"(port));
+	return ret_val;
+};
+
+//Enables (SeTs) Interrupt Flag on the processor
+inline void enable_ints()
+{
+	asm("sti");
+};
+
+//Disables (CLears) Interrupt Flag on the processor
+inline void disable_ints()
+{
+	asm("cli");
+};
+
+
+char *strcat(char *dest, char *src)
+{
+	strcpy(dest+strlen(dest), src);
+}
+
+
+//converts a binary-coded-decimal byte to its decimal equivalent
+inline byte bcd2byte(byte bcd)
+{
+ 	return (10* ((bcd & 0xF0) >> 4)) + (bcd & 0x0F);
+}
+
+//converts a binary-coded-decimal byte to its decimal equivalent
+inline byte byte2bcd(byte bite)
+{
+	return ((bite / 10) << 4) | (bite % 10);
+}
+
+void	rtrim(char *str)
+{
+	str += strlen(str);	//now points to the null character at the end of the string
+	str--;
+	for (;;)
+	{
+		if ((*str == ' ') || (*str == '\t') || (*str == '\n'))
+			*str-- = 0;
+		else
+			break;
+	}
+}
+
+
+char	*ucase(char *str)
+{
+	char *ret = str;
+	for (;;)
+	{
+		if (*str == 0)
+			break;
+		if ((*str >= 'a') && (*str <= 'z'))
+			*str = (*str) - 32;
+		str++;
+	}
+	return ret;
+}
+
+
+char	*lcase(char *str)
+{
+	char *ret = str;
+	for (;;)
+	{
+		if (*str == 0)
+			break;
+		if ((*str >= 'A') && (*str <= 'Z'))
+			*str = (*str) + 32;
+		str++;
+	}
+	return ret;
+}
+
+
+//Re-maps the Programmable Interrupr Controllers so IRQ0->pic1 base address, IRG8->pic2 base address
+void remap_pics(int pic1, int pic2)
+{
+	byte	a1, a2;
+
+	a1 = inportb(PIC1_DATA);      //0x21
+	a2 = inportb(PIC2_DATA);      //0xA1
+
+	outportb(PIC1_COMMAND, ICW1_INIT+ICW1_ICW4);	//0x20, 0x10+0x01 00010001b
+	outportb(PIC2_COMMAND, ICW1_INIT+ICW1_ICW4);	//0xA0, 0x10+0x01 00010001b
+	outportb(PIC1_DATA, pic1);			//0x21, pic1
+	outportb(PIC2_DATA, pic2);			//0xA1, pic2
+	outportb(PIC1_DATA, 4);				//0x21, 0x04      00000100b
+	outportb(PIC2_DATA, 2);				//0xA1, 0x02      00000010b
+	outportb(PIC1_DATA, ICW4_8086);			//0x21, 0x01      00000001b
+	outportb(PIC2_DATA, ICW4_8086);			//0xA1, 0x01      00000001b
+
+	outportb(PIC1_DATA, a1);			//0x21
+	outportb(PIC2_DATA, a2);			//0xA1
+}
+
+//Masks interrupts on first Programmable Interrupt Controller
+inline void pic1_mask(byte mask)
+{
+	outportb(PIC1_DATA, mask);			//0x21, maskfield *OCW1*
+}
+
+//Masks interrupts on second Programmable Interrupt Controller
+inline void pic2_mask(byte mask)
+{
+ 	outportb(PIC2_DATA, mask);			//0xA1, maskfield *OCW1*
+}
+
+//Restarts the computer
+inline void restart()
+{
+ 	enable_ints();
+ 	byte temp;
+	do
+	{
+		temp = inportb(0x64);
+		if (temp & 1)
+		inportb(0x60);
+	} while(temp & 2);
+
+
+	outportb (0x64, 0xfe);
+	for (;;)
+	{
+	}
+}
+
+//Halts (freezes) the computer
+inline void halt()
+{
+ 	asm("cli");
+ 	asm("hlt");
+ 	while (1)
+ 	;
+}
+
+//Initializes 8253 Programmable Interrupt Timer
+inline void init_timer()
+{
+ 	//set timer : 2e9c = 100hz
+	outportb(0x43, 0x34);
+	outportb(0x40, 0x9c); //lsb
+	outportb(0x40, 0x2e); //msb
+}
+
+//Signals an End Of Interrupt signal to the first PIC
+inline void eoi()
+{
+	outportb(0x20, 0x20);
+}
+
+//Signals an End Of Interrupt signal to both the second and first PIC unit
+inline void eoi2()
+{
+ 	outportb(0xA0, 0x20);
+ 	outportb(0x20, 0x20);
+}
+
+//Returns the size of the kernel (code & data)
+// - this does not include the bss section
+// - this should be 4kb aligned per the linker script
+// - this should be the size of kernel.bin
+inline dword kernel_size()
+{
+	return (dword)(&_bss)-(dword)(&_code);
+}
+
+
+//These functions are for reading and writing various values stored on the CMOS Real Time Clock
+byte	rtc_readDay()
+{
+	outportb(0x70, 7);
+	return bcd2byte(inportb(0x71));
+}
+
+byte	rtc_readMonth()
+{
+	outportb(0x70, 8);
+	return bcd2byte(inportb(0x71));
+}
+
+byte	rtc_readYear()
+{
+	outportb(0x70, 9);
+	return bcd2byte(inportb(0x71));
+}
+
+byte	rtc_readSecond()
+{
+	outportb(0x70, 0);
+	return bcd2byte(inportb(0x71));
+}
+
+byte	rtc_readMinute()
+{
+	outportb(0x70, 2);
+	return bcd2byte(inportb(0x71));
+}
+
+byte	rtc_readHour()
+{
+	outportb(0x70, 4);
+	return bcd2byte(inportb(0x71));
+}
+
+void	rtc_setDay(byte day)
+{
+	outportb(0x70, 7);
+	outportb(0x71, byte2bcd(day));
+}
+
+void	rtc_setMonth(byte month)
+{
+	outportb(0x70, 8);
+	outportb(0x71, byte2bcd(month));
+}
+
+void	rtc_setYear(byte year)
+{
+	outportb(0x70, 9);
+	outportb(0x71, byte2bcd(year));
+}
+
+void	rtc_setSecond(byte second)
+{
+	outportb(0x70, 0);
+	outportb(0x71, byte2bcd(second));
+}
+
+void	rtc_setMinute(byte minute)
+{
+	outportb(0x70, 2);
+	outportb(0x71, byte2bcd(minute));
+}
+
+void	rtc_setHour(byte hour)
+{
+	outportb(0x70, 4);
+	outportb(0x71, byte2bcd(hour));
+}
+
+
+
+
+
+
+
+
@@ -1,37 +0,0 @@
-
-KERNEL_FILE := hos.gz
-MKISOFS     := genisoimage
-ISO         := hos.iso
-QEMU        := qemu-system-x86_64
-BOCHS       := bochs
-
-# default target: build the kernel and ISO image
-all: kernel iso
-
-# build the kernel
-.PHONY: kernel
-kernel:
-	$(MAKE) -C $@
-
-# build the ISO image
-.PHONY: iso
-iso: $(ISO) kernel
-
-$(ISO): kernel
-	cp kernel/$(KERNEL_FILE) iso/boot
-	-rm -f $(ISO)
-	$(MKISOFS) -R -b boot/grub/stage2_eltorito -no-emul-boot \
-		-boot-load-size 4 -boot-info-table -o $(ISO) iso
-
-.PHONY: qemu
-qemu: iso
-	$(QEMU) -cdrom $(ISO) -boot d -m 384 -localtime
-
-.PHONY: bochs
-bochs: iso
-	-$(BOCHS)
-
-.PHONY: clean
-clean:
-	$(MAKE) -C kernel clean
-	-rm -f $(ISO) iso/boot/$(KERNEL_FILE)
@@ -0,0 +1,470 @@
+; asmfuncs.asm
+; Josh Holtrop
+; Created: 10/23/03
+; Modified: 12/25/03
+
+[extern _putc]
+[extern _console_memory]
+[extern _cursorPosition]
+[extern _video_drawConsole]
+[extern _videoMode]
+
+%macro jzfar 1
+	jnz	%%skip
+	jmp	%1
+%%skip:
+
+%endmacro
+
+;stores the parameter to the CR0 register
+;extern dword write_cr0(dword cr0);
+[global _write_cr0]
+_write_cr0:
+	push	ebp
+	mov	ebp, esp
+	mov	eax, [ebp+8]
+	mov	cr0, eax
+	pop	ebp
+	ret
+
+;returns the value in the CR0 register
+;extern dword read_cr0();
+[global _read_cr0]
+_read_cr0:
+	mov	eax, cr0;
+	ret
+
+;stores the parameter to the CR3 register
+;extern dword write_cr3(dword cr3);
+[global _write_cr3]
+_write_cr3:
+	push	ebp
+	mov	ebp, esp
+	mov	eax, [ebp+8]
+	mov	cr3, eax
+	pop	ebp
+	ret
+
+
+;returns the value in the CR2 register
+;extern dword read_cr2();
+[global _read_cr2]
+_read_cr2:
+	mov	eax, cr2;
+	ret
+
+
+
+;returns the value in the CR3 register
+;extern dword read_cr3();
+[global _read_cr3]
+_read_cr3:
+	mov	eax, cr3;
+	ret
+
+
+;compares one string to another
+;returns 0 if the strings are different
+;extern dword strcmp(char *str1, char *str2);
+[global _strcmp]
+_strcmp:
+	push	ebp
+	mov	ebp, esp
+	push	esi
+	push	edi
+
+	mov	esi, [ebp+8]
+	mov	edi, [ebp+12]
+strcmp_loop1:
+	lodsb
+	mov	ah, [edi]
+	inc	edi
+	cmp	ah, al
+	jnz	strcmp_ne
+	or	al, al
+	jz	strcmp_e
+	jmp	strcmp_loop1
+strcmp_e:
+	mov	eax, 1
+	jmp short strcmp_done
+strcmp_ne:
+	xor	eax, eax
+strcmp_done:
+
+	pop	edi
+	pop	esi
+	pop	ebp
+	ret
+
+;copies a string from the source to the destination parameter
+;extern void strcpy(char *dest, char *src);
+[global _strcpy]
+_strcpy:
+	push	ebp
+	mov	ebp, esp
+	push	esi
+	push	edi
+	mov	edi, [ebp+8]
+	mov	esi, [ebp+12]
+strcpyloop:
+	lodsb
+	stosb
+	or	al, al
+	jnz	strcpyloop
+	pop	edi
+	pop	esi
+	pop	ebp
+	ret
+
+;copies memory of n bytes from src to destination
+;extern void memcpy(dword dest, dword src, dword n);
+[global _memcpy]
+_memcpy:
+	push	ebp
+	mov	ebp, esp
+	push	esi
+	push	edi
+	push	ecx
+	mov	edi, [ebp+8]
+	mov	esi, [ebp+12]
+	mov	ecx, [ebp+16]
+
+	rep	movsb
+
+	pop	ecx
+	pop	edi
+	pop	esi
+	pop	ebp
+	ret
+
+;returns the number of characters in a string
+;extern dword strlen(char *str);
+[global _strlen]
+_strlen:
+	push	ebp
+	mov	ebp, esp
+	push	esi
+	push	ebx
+	mov	esi, [ebp+8]
+	xor	ebx, ebx
+strlenloop:
+	lodsb
+	or	al, al
+	jz	strlendone
+	inc	ebx
+	jmp	strlenloop
+strlendone:
+	mov	eax, ebx
+	pop	ebx
+	pop	esi
+	pop	ebp
+	ret
+
+;this function invalidates the page directory/table entry that
+; would be used to access the memory address given in the parameter
+;extern void invlpg(dword addr);
+[global _invlpg]
+_invlpg:
+	mov	eax, [esp+4]
+	invlpg	[eax]
+	ret
+
+
+;
+;void writeCursorPosition(word pos)
+;
+[global _writeCursorPosition]
+_writeCursorPosition:
+	push	ebp
+	mov	ebp, esp
+
+	push	eax
+	push	ebx
+	push	edx
+
+	mov	eax, [ebp+8]	;cursor position in ax
+
+	mov	bl, al
+	mov	dx, 0x03D4
+	mov	al, 0x0E
+	out	dx, al
+
+	inc	dx
+	mov	al, ah
+	out	dx, al
+
+	dec	dx
+	mov	al, 0x0F
+	out	dx, al
+
+	inc	dx
+	mov	al, bl
+	out	dx, al
+
+	pop	edx
+	pop	ebx
+	pop	eax
+	pop	ebp
+
+	ret
+
+
+;
+;word getCursorPosition()
+;
+[global _getCursorPosition]
+_getCursorPosition:
+	push	ebx
+	push	edx
+
+	xor	eax, eax
+	mov	dx, 0x03D4
+	mov	al, 0x0E
+	out	dx, al
+
+	inc	dx
+	in	al, dx
+	mov	bl, al
+
+	dec	dx
+	mov	al, 0x0F
+	out	dx, al
+
+	inc	dx
+	in	al, dx
+	mov	ah, bl
+
+	pop	edx
+	pop	ebx
+
+	ret
+
+
+;
+;void console_scroll()
+;
+[global _console_scroll]
+_console_scroll:
+	pusha
+	mov	esi, _console_memory+160
+	mov	edi, _console_memory
+	mov	ecx, 960			;(2000-80)/2
+	rep	movsd
+	mov	ax, 0x0720
+	mov	ecx, 80
+	rep	stosw
+	mov	esi, _console_memory
+	mov	edi, 0xC00B8000
+	mov	ecx, 1000
+	rep	movsd
+	mov	eax, [_videoMode]
+	cmp	eax, 0
+	jz	_console_scroll_end
+	call	_video_drawConsole
+_console_scroll_end:
+	popa
+	ret
+
+
+
+;
+;void console_cls()
+;
+[global _console_cls]
+_console_cls:
+	pusha
+	mov	edi, _console_memory
+	mov	ax, 0x0720
+	mov	ecx, 2000
+	rep	stosw
+	push	dword 0
+	call	_writeCursorPosition
+	add	esp, 4
+	mov	[_cursorPosition], dword 0
+	mov	esi, _console_memory
+	mov	edi, 0xC00B8000
+	mov	ecx, 1000
+	rep	movsd
+	popa
+	ret
+
+
+
+
+;
+;int puts(char *str)
+;
+[global _puts]
+_puts:
+	push	ebp
+	mov	ebp, esp
+	push	esi
+	push	eax
+	mov	esi, [ebp+8]			;esi = to string
+puts_loop:
+	lodsb
+	cmp	al, 0
+	jz	puts_done
+	push	eax
+	call	_putc
+	add	esp, 4
+	jmp	puts_loop
+
+puts_done:
+	pop	eax
+	pop	esi
+	pop	ebp
+	ret
+
+
+
+        
+[global _putDecu]
+_putDecu:
+	push	ebp
+	mov	ebp, esp
+	sub	esp, 24
+	mov	DWORD [ebp-4], 1
+	mov	BYTE [ebp-5], 0
+L2:
+	mov	edx, DWORD [ebp+8]
+	mov	eax, -858993459
+	mul	edx
+	mov	eax, edx
+	shr	eax, 3
+	cmp	eax, DWORD [ebp-4]
+	jae	L4
+	jmp	L3
+L4:
+	mov	eax, DWORD [ebp-4]
+	mov	edx, eax
+	sal	edx, 2
+	add	edx, eax
+	lea	eax, [edx+edx]
+	mov	DWORD [ebp-4], eax
+	jmp	L2
+L3:
+	nop
+L5:
+	cmp	DWORD [ebp-4], 1
+	ja	L7
+	jmp	L6
+L7:
+	mov	edx, DWORD [ebp+8]
+	mov	eax, edx
+	mov	edx, 0
+	div	DWORD [ebp-4]
+	mov	DWORD [ebp-12], eax
+	mov	al, BYTE [ebp-12]
+	mov	BYTE [ebp-5], al
+	mov	eax, 0
+	mov	al, BYTE [ebp-5]
+	imul	eax, DWORD [ebp-4]
+	sub	DWORD [ebp+8], eax
+	mov	edx, DWORD [ebp-4]
+	mov	eax, -858993459
+	mul	edx
+	mov	eax, edx
+	shr	eax, 3
+	mov	DWORD [ebp-4], eax
+	lea	eax, [ebp-5]
+	add	BYTE [eax], 48
+	sub	esp, 12
+	mov	eax, 0
+	mov	al, BYTE [ebp-5]
+	push	eax
+	call	_putc
+	add	esp, 16
+	jmp	L5
+L6:
+	sub	esp, 12
+	mov	al, BYTE [ebp+8]
+	add	eax, 48
+	and	eax, 255
+	push	eax
+	call	_putc
+	add	esp, 16
+	leave
+	ret
+
+
+
+
+[global _putDec]
+_putDec:
+	push	ebp
+	mov	ebp, esp
+	sub	esp, 24
+	cmp	DWORD [ebp+8], 0
+	jns	L9
+	sub	esp, 12
+	push	45
+	call	_putc
+	add	esp, 16
+	neg	DWORD [ebp+8]
+L9:
+	mov	DWORD [ebp-4], 1
+	mov	BYTE [ebp-5], 0
+L10:
+	mov	eax, DWORD [ebp+8]
+	cmp	eax, DWORD [ebp-4]
+	jae	L12
+	jmp	L11
+L12:
+	mov	eax, DWORD [ebp-4]
+	mov	edx, eax
+	sal	edx, 2
+	add	edx, eax
+	lea	eax, [edx+edx]
+	mov	DWORD [ebp-4], eax
+	jmp	L10
+L11:
+	mov	edx, DWORD [ebp-4]
+	mov	eax, -858993459
+	mul	edx
+	mov	eax, edx
+	shr	eax, 3
+	mov	DWORD [ebp-4], eax
+L13:
+	cmp	DWORD [ebp-4], 1
+	ja	L15
+	jmp	L14
+L15:
+	mov	edx, DWORD [ebp+8]
+	mov	eax, edx
+	mov	edx, 0
+	div	DWORD [ebp-4]
+	mov	DWORD [ebp-12], eax
+	mov	al, BYTE [ebp-12]
+	mov	BYTE [ebp-5], al
+	mov	eax, 0
+	mov	al, BYTE [ebp-5]
+	imul	eax, DWORD [ebp-4]
+	sub	DWORD [ebp+8], eax
+	mov	edx, DWORD [ebp-4]
+	mov	eax, -858993459
+	mul	edx
+	mov	eax, edx
+	shr	eax, 3
+	mov	DWORD [ebp-4], eax
+	lea	eax, [ebp-5]
+	add	BYTE [eax], 48
+	sub	esp, 12
+	mov	eax, 0
+	mov	al, BYTE [ebp-5]
+	push	eax
+	call	_putc
+	add	esp, 16
+	jmp	L13
+L14:
+	sub	esp, 12
+	mov	al, BYTE [ebp+8]
+	add	eax, 48
+	and	eax, 255
+	push	eax
+	call	_putc
+	add	esp, 16
+	leave
+	ret
+
+
@@ -0,0 +1,12 @@
+@echo off
+echo Backing up to .\Backup\%1
+
+mkdir .\Backup\%1
+
+copy *.h .\Backup\%1
+copy *.c .\Backup\%1
+copy *.inc .\Backup\%1
+copy *.asm .\Backup\%1
+copy *.ld .\Backup\%1
+copy *.bat .\Backup\%1
+
@@ -1,52 +0,0 @@
-# configuration file generated by Bochs
-plugin_ctrl: unmapped=1, biosdev=1, speaker=1, extfpuirq=1, gameport=1, pci_ide=1, acpi=1, ioapic=1
-config_interface: textconfig
-display_library: sdl
-megs: 32
-romimage: file="/usr/share/bochs/BIOS-bochs-latest"
-vgaromimage: file="/usr/share/bochs/VGABIOS-lgpl-latest"
-boot: cdrom
-floppy_bootsig_check: disabled=0
-# no floppya
-# no floppyb
-ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14
-ata0-master: type=cdrom, path="hos.iso", status=inserted, biosdetect=auto, model="Generic 1234"
-ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15
-ata2: enabled=0
-ata3: enabled=0
-parport1: enabled=1, file=""
-parport2: enabled=0
-com1: enabled=1, mode=null, dev=""
-com2: enabled=0
-com3: enabled=0
-com4: enabled=0
-usb_uhci: enabled=0
-usb_ohci: enabled=0
-i440fxsupport: enabled=1
-vga_update_interval: 50000
-vga: extension=vbe
-cpu: count=1, ips=4000000, reset_on_triple_fault=1, cpuid_limit_winnt=0
-print_timestamps: enabled=0
-# no gdb stub
-port_e9_hack: enabled=0
-text_snapshot_check: enabled=0
-private_colormap: enabled=0
-clock: sync=none, time0=local
-# no cmosimage
-ne2k: enabled=0
-pnic: enabled=0
-sb16: enabled=0
-# no loader
-log: -
-logprefix: %t%e%d
-panic: action=ask
-error: action=report
-info: action=report
-debug: action=ignore
-pass: action=fatal
-keyboard_type: mf
-keyboard_serial_delay: 250
-keyboard_paste_delay: 100000
-keyboard_mapping: enabled=0, map=
-user_shortcut: keys=none
-mouse: enabled=0, type=ps2
@@ -0,0 +1,26 @@
+
+%define VERSION		"0.13"			;HOS version
+
+%define BOOT_FAT_SEG	0x07E0			;right after boot sector
+%define BOOT_ROOT_SEG	0x0900			;right after FAT
+%define BOOT_KERNEL_SEG	0x0AC0			;right after ROOT_DIR
+%define BOOT_STAGE2_SEG	0x0B00			;right after KERNEL_SEG
+%define BOOT_STAGE2_ADD	0xB000			;address of stage2 to jump to, org at
+%define BOOT_KERNEL_ADD	0x106000		;final pmode kernel destination - physical
+%define BOOT_RD_ADD	0x200000		;2mb for ram disk
+
+%define BOOT_DATA_SEG	0x9000			;data gathered by stage2 loader goes here
+
+%define BOOT_HASRD	0x0000		;1
+%define BOOT_VESA	0x0002		;2 - 0 for console, otherwise VESA mode
+%define BOOT_VESA_OEM	0x0004		;258 - null-terminated OEM identification string
+%define BOOT_VESA_VBE	0x0106		;512 - copy of VESA VBEInfoBlock
+%define	BOOT_VESA_INFO	0x0306		;256 - copy of VESA ModeInfoBlock for selected mode
+%define BOOT_MEMENTRIES	0x040A		;4 - dword = number of memmap entries
+%define BOOT_MEMMAP	0x2000		;? -  memory map information
+
+
+
+%define BOOT_DRIVE	0x7C24		;1 - boot drive
+
+
@@ -0,0 +1,2 @@
+nasmw -f aout -o ks.o -l .\lst\kernel.lst kernel.asm
+
@@ -0,0 +1 @@
+gcc -ffreestanding -fno-builtin -nostdlib -nodefaultlibs -c kernel.c -o kernel.o
@@ -0,0 +1 @@
+nasmw -f aout -o asmfuncs.o -l .\lst\asmfuncs.lst asmfuncs.asm
@@ -0,0 +1 @@
+copy kernel.bin a:
@@ -0,0 +1,2 @@
+rem rawrite -f stage1.bin -d a -n
+partcopy stage1.bin 0 200 -f0
@@ -0,0 +1 @@
+copy stage2.bin a:
@@ -0,0 +1 @@
+nasmw -f bin -o stage1.bin -l .\lst\stage1.lst stage1.asm
@@ -0,0 +1 @@
+nasmw -f bin -o stage2.bin -l .\lst\stage2.lst stage2.asm
@@ -0,0 +1,345 @@
+// fat12.c
+// Author: Josh Holtrop
+// Created: 01/04/04
+// Modified: 01/14/04
+
+
+byte *fat12_readFile(char *fileName, DiskDevice *dd)
+{
+	char *fileNameUCase = malloc(strlen(fileName) + 1);
+	strcpy(fileNameUCase, fileName);
+	ucase(fileNameUCase);
+	dword iMadeClusterChain = getClusterChain(dd);
+	Fat12Entry fe;
+	if (fat12_getFileHandle(fileNameUCase, dd, &fe))
+	{
+		free(fileNameUCase);
+		if (iMadeClusterChain)
+		{
+			free(clusterChain);
+			clusterChain = 0;
+		}
+		return 0;
+	}
+	byte *fp = (byte *)fat12_readClusterChain(dd, &fe);
+	free(fileNameUCase);
+	if (iMadeClusterChain)
+	{
+		free(clusterChain);
+		clusterChain = 0;
+	}
+	return fp;
+}
+
+
+dword	fat12_getFileHandle(char *fileName, DiskDevice *dd, Fat12Entry *destination)
+{
+ 	if (strlen(fileName) < 1)
+ 		return 1;
+ 	if (fileName[strlen(fileName)-1] == '/')
+ 		return 2;
+	dword iMadeClusterChain = getClusterChain(dd);
+	int fileName_length = strlen(fileName);
+	int a;
+	int entries = 1;
+	for (a = 0; a < fileName_length; a++)
+	{
+		if (fileName[a] == '/')
+		{
+			fileName[a] = 0;
+			entries++;
+		}
+	}
+	char *pointer = fileName;
+	Fat12Entry *workingDirectory = 0;
+	Fat12Entry workingDir;
+	for (a = 0; a < (entries - 1); a++)
+	{
+		if (fat12_getDirectoryHandle(pointer, dd, workingDirectory, &workingDir))	//an error occurred if this returns nonzero
+		{
+			if (iMadeClusterChain)
+			{
+				free(clusterChain);
+				clusterChain = 0;
+			}
+			return 3;
+		}
+		workingDirectory = &workingDir;
+		for (;;)				//advance to the next dir name
+		{
+			pointer++;
+			if (*pointer == 0)
+			{
+				pointer++;
+				break;
+			}
+		}
+	}
+	if (fat12_getFileHandleInDirectory(pointer, dd, workingDirectory, destination))		//an error occurred if this returns nonzero
+	{
+		if (iMadeClusterChain)
+		{
+			free(clusterChain);
+			clusterChain = 0;
+		}
+		return 4;
+	}
+	if (iMadeClusterChain)
+	{
+		free(clusterChain);
+		clusterChain = 0;
+	}
+	return 0;
+}
+
+
+dword	fat12_getFileHandleInDirectory(char *fileName, DiskDevice *dd, Fat12Entry *currDir, Fat12Entry *destination)
+{
+	if (!currDir)			// we are working in the root directory
+	{
+		Fat12Entry *rootDir = malloc(14*512);		//root directory is 14 sectors long
+		vfs_readSector(dd, 19, (byte *)rootDir, 14);
+		int a;
+		for (a = 0; a < 224; a++)			//224 max root directory entries in 14 sectors
+		{
+			if (rootDir[a].fileName[0] == 0)
+				break;
+			if ((byte)rootDir[a].fileName[0] != 0xE5)
+			{
+				if ((rootDir[a].attributes & 0x18) == 0)	//this entry is a directory
+				{
+					char dirName[9];
+					char dirExt[4];
+					memcpy(dirName, rootDir[a].fileName, 8);
+					dirName[8] = 0;
+					memcpy(dirExt, rootDir[a].ext, 3);
+					dirExt[3] = 0;
+					rtrim(dirName);
+					rtrim(dirExt);
+					char dirWhole[14];
+					strcpy(dirWhole, dirName);
+					if (strlen(dirExt) > 0)			//the directory has an extension
+					{
+						strcat(dirWhole, ".");
+						strcat(dirWhole, dirExt);
+					}
+					if (strcmp(dirWhole, fileName))	//the entry found is a match
+					{
+						free(rootDir);
+						*destination = rootDir[a];
+						return 0;
+					}
+				}
+			}
+		}
+		free(rootDir);
+		return 1;	//no match found
+	}
+	dword retVal = 2;
+	dword iMadeClusterChain = getClusterChain(dd);
+	Fat12Entry *subDirectory = fat12_readClusterChain(dd, currDir);
+	if (!subDirectory)
+		return 5;
+	dword numberOfClusters = fat12_readClusterChainCount(dd, currDir);
+	int a;
+	for (a = 0; a < (numberOfClusters * 16); a++)
+	{
+		if (subDirectory[a].fileName[0] == 0)
+			break;
+		if ((byte)subDirectory[a].fileName[0] != 0xE5)
+		{
+			if ((subDirectory[a].attributes & 0x18) == 0)	//this entry is a directory
+			{
+				char dirName[9];
+				char dirExt[4];
+				memcpy(dirName, subDirectory[a].fileName, 8);
+				dirName[8] = 0;
+				memcpy(dirExt, subDirectory[a].ext, 3);
+				dirExt[3] = 0;
+				rtrim(dirName);
+				rtrim(dirExt);
+				char dirWhole[14];
+				strcpy(dirWhole, dirName);
+				if (strlen(dirExt) > 0)			//the directory has an extension
+				{
+					strcat(dirWhole, ".");
+					strcat(dirWhole, dirExt);
+				}
+				if (strcmp(dirWhole, fileName))	//the entry found is a match
+				{
+					*destination = subDirectory[a];
+					retVal = 0;
+					break;
+				}
+			}
+		}
+	}
+	free(subDirectory);
+	if (iMadeClusterChain)
+	{
+		free(clusterChain);
+		clusterChain = 0;
+	}
+	return retVal;
+}
+
+
+dword	fat12_getDirectoryHandle(char *directory, DiskDevice *dd, Fat12Entry *currDir, Fat12Entry *destination)
+{
+	if (!currDir)			// we are working in the root directory
+	{
+		Fat12Entry *rootDir = malloc(14*512);		//root directory is 14 sectors long
+		vfs_readSector(dd, 19, (byte *)rootDir, 14);
+		int a;
+		for (a = 0; a < 224; a++)			//224 max root directory entries in 14 sectors
+		{
+			if (rootDir[a].fileName[0] == 0)
+				break;
+			if ((byte)rootDir[a].fileName[0] != 0xE5)
+			{
+				if ((rootDir[a].attributes & 0x18) == 0x10)	//this entry is a directory
+				{
+					char dirName[9];
+					char dirExt[4];
+					memcpy(dirName, rootDir[a].fileName, 8);
+					dirName[8] = 0;
+					memcpy(dirExt, rootDir[a].ext, 3);
+					dirExt[3] = 0;
+					rtrim(dirName);
+					rtrim(dirExt);
+					char dirWhole[14];
+					strcpy(dirWhole, dirName);
+					if (strlen(dirExt) > 0)			//the directory has an extension
+					{
+						strcat(dirWhole, ".");
+						strcat(dirWhole, dirExt);
+					}
+					if (strcmp(dirWhole, directory))	//the entry found is a match
+					{
+						free(rootDir);
+						*destination = rootDir[a];
+						return 0;
+					}
+				}
+			}
+		}
+		free(rootDir);
+		return 1;	//no match found
+	}
+	dword retVal = 2;
+	dword iMadeClusterChain = getClusterChain(dd);
+	Fat12Entry *subDirectory = fat12_readClusterChain(dd, currDir);
+	if (!subDirectory)
+		return 5;
+	dword numberOfClusters = fat12_readClusterChainCount(dd, currDir);
+	int a;
+	for (a = 0; a < (numberOfClusters * 16); a++)
+	{
+		if (subDirectory[a].fileName[0] == 0)
+			break;
+		if ((byte)subDirectory[a].fileName[0] != 0xE5)
+		{
+			if ((subDirectory[a].attributes & 0x18) == 0x10)	//this entry is a directory
+			{
+				char dirName[9];
+				char dirExt[4];
+				memcpy(dirName, subDirectory[a].fileName, 8);
+				dirName[8] = 0;
+				memcpy(dirExt, subDirectory[a].ext, 3);
+				dirExt[3] = 0;
+				rtrim(dirName);
+				rtrim(dirExt);
+				char dirWhole[14];
+				strcpy(dirWhole, dirName);
+				if (strlen(dirExt) > 0)			//the directory has an extension
+				{
+					strcat(dirWhole, ".");
+					strcat(dirWhole, dirExt);
+				}
+				if (strcmp(dirWhole, directory))	//the entry found is a match
+				{
+					*destination = subDirectory[a];
+					retVal = 0;
+					break;
+				}
+			}
+		}
+	}
+	free(subDirectory);
+	if (iMadeClusterChain)
+	{
+		free(clusterChain);
+		clusterChain = 0;
+	}
+	return retVal;
+}
+
+
+Fat12Entry *fat12_readClusterChain(DiskDevice *dd, Fat12Entry *directory)
+{
+	dword numberOfClusters = fat12_readClusterChainCount(dd, directory);
+	if (numberOfClusters == 0)
+		return 0;
+	byte *bp = malloc(numberOfClusters * 512);
+	Fat12Entry *retVal = (Fat12Entry *)bp;
+	dword cluster = directory->firstCluster;
+	while (cluster < 0xFF0)
+	{
+		vfs_readSector(dd, cluster + 31, bp, 1);
+		cluster = fat12_getNextCluster(cluster);
+		bp += 512;
+	}
+	return retVal;
+}
+
+
+dword	fat12_readClusterChainCount(DiskDevice *dd, Fat12Entry *directory)
+{
+	dword numberOfClusters = 0;
+	dword cluster = directory->firstCluster;
+	if (cluster == 0)
+		return 0;
+	while (cluster < 0xFF0)
+	{
+		cluster = fat12_getNextCluster(cluster);
+		numberOfClusters++;
+	}
+	return numberOfClusters;
+}
+
+
+dword	fat12_getNextCluster(dword thisCluster)
+{
+	dword nextCluster = *(word *)((dword)clusterChain + ((thisCluster * 3) >> 1));
+	if (thisCluster & 0x01)		//this is an odd cluster
+		return nextCluster >> 4;
+	else				//this is an even cluster
+		return nextCluster & 0x0FFF;
+}
+
+
+dword	fat12_getFileSize(char *fileName, DiskDevice *dd)
+{
+	Fat12Entry fe;
+	if (fat12_getFileHandle(fileName, dd, &fe))
+		return 0xFFFFFFFF;
+	return fe.fileSize;
+}
+
+
+dword	getClusterChain(DiskDevice *dd)
+{
+	if (!clusterChain)
+	{
+		clusterChain = malloc(9*512);	//9 sectors for File Allocation Table (cluster chain)
+		vfs_readSector(dd, 1, clusterChain, 9);	//sectors 1 through 9 contain the first FAT
+		return 1;			//this call created the cluster chain
+	}
+	else
+		return 0;			//this call did not create the cluster chain
+}
+
+
+
+
+
@@ -0,0 +1,58 @@
+// fat12.h
+// Author: Josh Holtrop
+// Created: 01/04/04
+
+
+typedef struct	{
+	char	fileName[8];
+	char	ext[3];
+	byte	attributes;
+	dword	createTime;
+	word	createDate;
+	word	accessDate;
+	word	unused0;
+	word	modifiedDate;
+	word	modifiedTime;
+	word	firstCluster;
+	dword	fileSize;
+} __attribute__((packed)) Fat12Entry;
+
+typedef struct	{
+	byte	jump[3];
+	byte	sysName[8];
+	word    bytesPerSector;
+	byte	sectorsPerCluster;
+	word	reservedSectors;
+	byte	FATcount;
+	word	maxRootEntries;
+	word	totalSectors1;
+	byte	mediaDescriptor;
+	word	sectorsPerFAT;
+	word	sectorsPerTrack;
+	word	headCount;
+	dword	hiddenSectors;
+	dword	totalSectors2;
+	byte	driveNumber;
+	byte	reserved1;
+	byte	extBootSignature;
+	dword	volumeSerial;
+	char	volumeLabel[11];
+	char	fileSystemID[8];
+} __attribute__((packed)) Fat12BootSector;
+
+
+byte *fat12_readFile(char *fileName, DiskDevice *dd);
+dword	fat12_getFileHandle(char *fileName, DiskDevice *dd, Fat12Entry *destination);
+dword	fat12_getDirectoryHandle(char *directory, DiskDevice *dd, Fat12Entry *currDir, Fat12Entry *destination);
+Fat12Entry *fat12_readClusterChain(DiskDevice *dd, Fat12Entry *directory);
+dword	fat12_getFileHandleInDirectory(char *fileName, DiskDevice *dd, Fat12Entry *currDir, Fat12Entry *destination);
+dword	fat12_readClusterChainCount(DiskDevice *dd, Fat12Entry *directory);
+dword	fat12_getFileSize(char *fileName, DiskDevice *dd);
+dword	getClusterChain(DiskDevice *dd);
+dword	fat12_getNextCluster(dword thisCluster);
+
+byte	*clusterChain = 0;
+
+
+
+
@@ -0,0 +1,9 @@
+//fdc.c
+//Author: Josh Holtrop
+//Date: 10/30/03
+
+
+inline	void	fdc_sendDOR(byte dor)
+{
+	outportb(FDC_DOR, dor);
+}
@@ -0,0 +1,12 @@
+//fdc.h
+//Author: Josh Holtrop
+//Date: 10/30/03
+
+
+#define FDC_DOR 0x3f2
+#define FDC_MSR 0x3f4
+
+
+inline	void	fdc_sendDOR(byte dor);
+
+
@@ -0,0 +1,46 @@
+//functions.h
+//05/07/03 Josh Holtrop
+//for HOS
+//Modified: 10/30/03
+
+extern dword _code;
+extern dword _bss;
+extern dword _end;
+
+inline void outportb(unsigned int port, unsigned char value);
+inline void outportw(unsigned int port, unsigned int value);
+inline byte inportb(unsigned short port);
+inline void enable_ints();
+inline void disable_ints();
+inline void restart();
+inline void halt();
+void remap_pics(int pic1, int pic2);
+inline void pic1_mask(byte mask);
+inline void pic2_mask(byte mask);
+inline void eoi();
+inline void eoi2();
+inline dword kernel_size();
+inline void init_timer();
+char *strcat(char *dest, char *src);
+void	rtrim(char *str);
+char	*ucase(char *str);
+char	*lcase(char *str);
+inline byte bcd2byte(byte bcd);
+inline byte byte2bcd(byte bite);
+byte	rtc_readDay();
+byte	rtc_readMonth();
+byte	rtc_readYear();
+byte	rtc_readSecond();
+byte	rtc_readMinute();
+byte	rtc_readHour();
+void	rtc_setDay(byte dat);
+void	rtc_setMonth(byte month);
+void	rtc_setYear(byte year);
+void	rtc_setSecond(byte second);
+void	rtc_setMinute(byte minute);
+void	rtc_setHour(byte hour);
+
+
+
+
+
@@ -0,0 +1 @@
+gcc -S kernel.c -masm=intel -fno-builtin
@@ -0,0 +1,71 @@
+;gdt.inc
+;Author: Josh Holtrop
+;for HOS
+;Modified: 10/30/03
+
+gdtr:
+	dw	gdt_end-gdt-1
+	dd	GDT_P
+gdt:
+	dd	0
+	dd	0
+KERNEL_CODE equ $-gdt
+	dw	0xffff	;limit 15:0
+	dw	0x0000	;base  15:0
+	db	0x00	;base  23:16
+	db	0x9A	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
+	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
+	db	0x00	;base  31:24
+KERNEL_DATA equ $-gdt
+	dw	0xffff	;limit 15:0
+	dw	0x0000	;base  15:0
+	db	0x00	;base  23:16
+	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
+	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
+	db	0x00	;base  31:24
+VESA_CODE equ $-gdt
+	dw	0xffff	;limit 15:0
+	dw	0x0000	;base  15:0
+	db	0x00	;base  23:16
+	db	0x9A	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
+	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
+	db	0x00	;base  31:24
+VESA_DATA equ $-gdt
+	dw	0xffff	;limit 15:0
+	dw	0x0000	;base  15:0
+	db	0x00	;base  23:16
+	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
+	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
+	db	0x00	;base  31:24
+VIDEO_TEXT equ $-gdt
+	dw	0x7FFF	;limit 15:0
+	dw	0x8000	;base  15:0
+	db	0x0B	;base  23:16
+	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
+	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
+	db	0x00	;base  31:24
+VIDEO_GRAPHICS equ $-gdt
+	dw	0xFFFF	;limit 15:0
+	dw	0x0000	;base  15:0
+	db	0x0A	;base  23:16
+	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
+	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
+	db	0x00	;base  31:24
+USER_CODE equ $-gdt
+	dw	0xffff	;limit 15:0
+	dw	0x0000	;base  15:0
+	db	0x00	;base  23:16
+	db	0xFA	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
+	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
+	db	0x00	;base  31:24
+USER_DATA equ $-gdt
+	dw	0xffff	;limit 15:0
+	dw	0x0000	;base  15:0
+	db	0x00	;base  23:16
+	db	0xF2	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
+	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
+	db	0x00	;base  31:24
+gdt_end:
+
+
+
@@ -0,0 +1 @@
+partcopy -f0 0 168000 flop.img
@@ -0,0 +1,111 @@
+;idt.inc
+;Author: Josh Holtrop
+;for HOS
+;Modified: 10/30/03
+
+idtr:
+	dw	50*8-1		;size of idt
+	dd	IDT_V		;address of idt
+
+
+%macro isr_label 1
+isr_%1:
+	push	eax
+	mov	eax, %1
+	jmp	isr_main
+%endmacro
+
+isr_label	0
+isr_label	1
+isr_label	2
+isr_label	3
+isr_label	4
+isr_label	5
+isr_label	6
+isr_label	7
+isr_label	8
+isr_label	9
+isr_label	10
+isr_label	11
+isr_label	12
+isr_label	13
+isr_label	14
+isr_label	15
+isr_label	16
+isr_label	17
+isr_label	18
+isr_label	19
+isr_label	20
+isr_label	21
+isr_label	22
+isr_label	23
+isr_label	24
+isr_label	25
+isr_label	26
+isr_label	27
+isr_label	28
+isr_label	29
+isr_label	30
+isr_label	31
+isr_label	32
+isr_label	33
+isr_label	34
+isr_label	35
+isr_label	36
+isr_label	37
+isr_label	38
+isr_label	39
+isr_label	40
+isr_label	41
+isr_label	42
+isr_label	43
+isr_label	44
+isr_label	45
+isr_label	46
+isr_label	47
+isr_label	48
+isr_label	49
+
+isr_main:
+	cmp	eax, 0x30
+	jz	isr_syscall
+
+	pusha
+	push	ds
+	push	es
+
+	push	eax
+
+	call	_isr
+
+	pop	eax
+
+	pop	es
+	pop	ds
+	popa
+	pop	eax
+
+	iret
+
+
+isr_syscall:
+	pop	eax	;syscall function number
+	pusha
+	push	ds
+	push	es
+
+	push	ebx
+	call	_putc
+	add	esp, 4
+
+	pop	es
+	pop	ds
+	popa
+	iret
+
+
+
+
+
+
+
@@ -1,6 +0,0 @@
-
-timeout 2
-default 0
-
-title HOS
-kernel /boot/hos.gz
@@ -0,0 +1,51 @@
+//k_defines.h
+//03/17/03 Josh Holtrop
+//Modified: 10/30/03
+
+#define	PIC1		0x20
+#define	PIC2		0xA0
+#define	PIC1_COMMAND	PIC1
+#define	PIC1_DATA	(PIC1+1)
+#define	PIC2_COMMAND	PIC2
+#define	PIC2_DATA	(PIC2+1)
+#define	PIC_EOI		0x20
+
+#define	ICW1_ICW4	0x01		/* ICW4 (not) needed */
+#define	ICW1_SINGLE	0x02		/* Single (cascade) mode */
+#define	ICW1_INTERVAL4	0x04		/* Call address interval 4 (8) */
+#define	ICW1_LEVEL	0x08		/* Level triggered (edge) mode */
+#define	ICW1_INIT	0x10		/* Initialization - required! */
+
+#define	ICW4_8086	0x01		/* 8086/88 (MCS-80/85) mode */
+#define	ICW4_AUTO	0x02		/* Auto (normal) EOI */
+#define	ICW4_BUF_SLAVE	0x08		/* Buffered mode/slave */
+#define	ICW4_BUF_MASTER	0x0C		/* Buffered mode/master */
+#define	ICW4_SFNM	0x10		/* Special fully nested (not) */
+
+#define BLUE_TXT	0x01
+#define RED_TXT		0x04
+#define WHITE_TXT	0x07
+#define CYAN_TXT	0x0B
+#define YELLOW_TXT	0x0E
+#define BRWHITE_TXT	0x0F
+
+#define FREERAM_START	0x368000	// 0x368000 is first available byte (this is right after the initrd @ 2mb, 1440kb.
+#define MAX_RAM		0x40000000	//1gb maximum RAM supported
+
+#define PID_KERNEL	0x02		//kernel's PID
+#define PID_VMM		0x03
+#define PID_USER	0x10000		//user processes' start PID
+
+typedef	unsigned char	byte;
+typedef	unsigned short	word;
+typedef	unsigned int	dword;
+
+typedef struct {
+	dword	lowdword;
+	dword	highdword;
+} __attribute__((packed)) qword;
+
+
+
+
+
@@ -0,0 +1,101 @@
+;kernel.asm
+;Author: Josh Holtrop
+;Modified: 10/30/03
+
+%define GDT_P	0x100000;	;1mb physical - Global Descriptor Table space
+%define GDT_V	GDT_P+0xC0000000
+%define IDT_P	0x102000	;1mb+8kb - Interrupt Descriptor Table space
+%define IDT_V	IDT_P+0xC0000000
+%define PDBR_P	0x104000	;1mb+16kb - Page Directory Base Register (first PD)
+%define PDBR_V	PDBR_P+0xC0000000
+%define LOPT_P	0x105000	;1mb+20kb - LOw Page Table for mapping first 4mb
+%define LOPT_V	LOPT_P+0xC0000000
+%define KERNEL_P 0x106000	;1mb+24kb - the kernel's physical address
+%define KERNEL_V KERNEL_P+0xC0000000	;3gb+1mb+24kb, the virtual address of the kernel
+
+[global start]
+[extern _isr]
+[extern _k_init]
+[extern _putc]
+
+bits 32
+
+;This is where the kernel begins execution
+;At this point, the temporary gdt is set up to "map" 0xC000_0000 to 0x0.
+;We must enable paging with the first 4mb mapped 1:1 virtual:physical
+; and with the 4mb starting at 0xC000_0000 mapped to the first 4mb physical.
+;Then we can start using our "real" gdt, then unmap the lower 4mb.
+start:
+	cli					;if they weren't already off
+	
+	xor	eax, eax
+	mov	edi, PDBR_V
+	mov	ecx, 1024			;clear the PDBR
+	rep stosd
+	mov	[PDBR_V], dword LOPT_P|0x03		;store the physical address of the LOw Page Table (read/write, present)
+	mov	[PDBR_V+0xC00], dword LOPT_P|0x03	;store the physical address of the LOw Page Table (read/write, present)
+
+	mov	edi, LOPT_V
+	mov	ecx, 1024
+	mov	eax, 0x03			;starting physical address = 0x0 (read/write, present flags)
+fill_lopt_loop:					;fill the page table
+	stosd
+	add	eax, 4096			;increment next phsyical address by 4kb
+	loop	fill_lopt_loop
+
+	mov	eax, PDBR_P
+	mov	cr3, eax			;store the Page Directory Base Address
+	mov	eax, cr0
+	or	eax, 0x80000000			;set page enable bit
+	mov	cr0, eax			;now paging is active!
+
+
+	mov	edi, GDT_V
+	mov	esi, gdt
+	mov	ecx, gdt_end-gdt
+copy_gdt:
+	lodsb
+	stosb
+	loop	copy_gdt
+
+	mov	edi, IDT_V		;destination
+	mov	esi, isr_0		;address of isr0
+	mov	edx, isr_1-isr_0	;distance between isr labels
+	mov	ecx, 50			;number of isrlabels
+fill_idt:
+	mov	ebx, esi
+	mov	ax, si
+	stosw				;0 offset 15:0
+	mov	ax, KERNEL_CODE
+	stosw				;2 selector 15:0
+	mov	ax, 0x8E00
+	stosw				;4 [P][DPL][0][TYPE][0][0][0][0][0][0][0][0]
+	shr	esi, 16
+	mov	ax, si
+	stosw				;6 offset 31:16
+	mov	esi, ebx
+	add	esi, edx
+	loop	fill_idt
+	mov	word	[IDT_V+0x30*8+4], 0xEE00	;interrupt 0x30 has user priviledges
+
+	lgdt	[gdtr]			;load gdt
+	jmp	KERNEL_CODE:newgdtcontinue
+newgdtcontinue:
+	mov	ax, KERNEL_DATA
+	mov	es, ax
+	mov	ds, ax
+	mov	gs, ax
+	mov	fs, ax
+	mov	ss, ax
+	mov	esp, 0xc01ffffc		;stack just under 3gb+2mb, moves downward
+	lidt	[idtr]			;load idt
+
+	call	_k_init
+haltit:
+	hlt				;halt processor when k_init is done
+	jmp	haltit			;shouldn't get here...
+
+%include "gdt.inc"
+%include "idt.inc"
+
+
@@ -0,0 +1,144 @@
+//kernel.c
+//08/13/03 Josh Holtrop
+//Holtrop's Operating System
+//Version: 0.12
+//Modified: 12/30/03
+
+#include "k_defines.h"		//#DEFINE's for kernel
+
+
+#include "functions.h"		//general functions
+#include "video.h"		//video functions
+#include "mm.h"			//physical memory management functions
+#include "vmm.h"		//virtual memory management & paging functions
+#include "keyboard.h"		//generic keyboard driver & functions
+#include "mouse.h"		//generic ps/2 mouse driver & functions
+#include "fdc.h"		//Floppy Disk Controller functions
+#include "stdfont.h"		//Standard font bitmask array
+#include "kio.h"
+#include "vfs.h"
+#include "rd.h"
+#include "fat12.h"
+
+void isr(dword num);
+void k_init();
+
+/* These functions are defined in asmfuncs.asm */
+extern dword write_cr0(dword cr0);
+extern dword read_cr0();
+extern dword write_cr3(dword cr3);
+extern dword read_cr2();
+extern dword read_cr3();
+extern void writeCursorPosition(dword pos);
+extern dword getCursorPosition();
+extern void console_scroll();
+extern void console_cls();
+extern int puts(char *str);
+extern int putDec(int number);
+extern int putDecu(dword number);
+extern void strcpy(char *dest, char *src);
+extern void memcpy(void *dest, void *src, dword n);
+extern dword strlen(char *str);
+
+#include "fat12.c"
+#include "rd.c"
+#include "vfs.c"
+#include "kio.c"
+#include "fdc.c"
+#include "mouse.c"
+#include "keyboard.c"
+#include "mm.c"
+#include "vmm.c"
+#include "functions.c"
+#include "video.c"
+
+dword	timer = 0;
+
+//Main kernel initialization method
+void k_init()
+{
+		// ===== Initialization
+	fdc_sendDOR(0x0C);		//turn off floppy motor!!
+	console_cls();
+	video_init();
+	mm_init();
+	vmm_init();
+	remap_pics(0x20, 0x28);
+	init_timer();
+	mouse_init();
+	pic1_mask(0);			//unmask IRQ's 0-7
+	pic2_mask(0);			//unmask IRQ's 8-15
+	vfs_init();
+	enable_ints();
+	kbd_resetLEDs();		//after enabling interrupts!!
+	if (videoMode)
+	{
+		int p = video_mode.XResolution*video_mode.YResolution-1;
+		for (; p >= 0; p--)
+			video_psetp(p, 0x00000044);
+		video_drawConsole();
+	}
+
+	printf("HOS 0.13 - Kernel File Size: %u kb\tData Size: %u bytes\n", kernel_size()>>10, (dword)(&_end)-(dword)(&_code));
+	printf("Memory available to OS: %u MB (%u bytes)\n", mm_megabytes, mm_totalmem);
+	printf("Free memory: %u bytes (%u pages)\n", mm_freemem(), mm_freemem()>>12);
+	printf("%d/%d/%d\t%d:%d:%d\n", rtc_readMonth(), rtc_readDay(), rtc_readYear(), rtc_readHour(), rtc_readMinute(), rtc_readSecond());
+	printf("Root Directory: %s/\n", rootDevice->id);
+
+
+/*	int a;
+	byte *addr = 0;
+	for (a = 0; a < 5; a++)
+	{
+		byte *app = mm_palloc();
+		vmm_map1((dword)addr, (dword)app);
+		addr += 4096;
+	}
+
+	addr = vfs_readFile("/bin/hash.hos");
+	memcpy(0, addr, 4192);
+	asm("call 0");
+	free(addr);
+*/
+
+	dword key = 0;
+	for (;;)
+	{
+		key = kbdWaitKey();
+		if ((key & 0xFF) > 2)	//key is not a control key
+			putc(key);
+	}
+}
+
+// main Interrupt Service Routine - handles all interrupts unless caught by kernel.asm
+void isr(dword num)
+{
+	switch(num)
+	{
+	case 14:
+		printf("Page fault, CR2 = 0x%x\n", read_cr2());
+		halt();
+		break;
+	case 0x20:         		// IRQ0 - timer interrupt
+		timer++;
+		(*(byte *)(0xc00b8000))++;
+		eoi();
+		break;
+	case 0x21:  			// IRQ1 - keyboard interrupt
+		isr_keyboard();    	//isr_keybard() takes care of calling eoi()
+		break;
+	case 0x2C:			// IRQ12 - PS/2 mouse
+		isr_mouse();
+		eoi2();
+		break;
+	default:
+		printf("Interrupt %d (0x%x) Unhandled!!\n", num, num);
+		halt();
+		break;
+	}
+}
+
+
+
+
+
@@ -1,45 +0,0 @@
-
-CROSS_COMPILE   := i586-elf-
-
-export LD       := $(CROSS_COMPILE)ld
-export CC       := $(CROSS_COMPILE)gcc
-export CXX      := $(CROSS_COMPILE)g++
-export OBJDUMP  := $(CROSS_COMPILE)objdump
-export NASM     := nasm
-
-export HOS_TOPLEVEL := $(shell pwd)
-LDSCRIPT        := link.ld
-KERNEL          := hos
-export CPPFLAGS := -I$(HOS_TOPLEVEL) -I$(HOS_TOPLEVEL)/include
-export CFLAGS   := -Wall -O2 -g
-export CXXFLAGS := -Wall -O2 -fno-rtti -fno-exceptions -g
-export LDFLAGS  := -T $(LDSCRIPT) -Map $(KERNEL).map
-export LDLIBS   := `$(CC) -print-libgcc-file-name`
-
-SUBDIRS         := boot mm lang isr sys
-SUBDIRS_clean   := $(SUBDIRS:%=%.clean)
-
-.PHONY: all
-all: $(KERNEL).gz
-
-$(KERNEL).gz: $(KERNEL)
-	gzip -c $< > $@
-
-$(KERNEL): $(KERNEL).o
-	$(LD) $(LDFLAGS) -o $@ $<
-	$(OBJDUMP) --disassemble --source $@ > $@.dump
-#	strip $@
-	
-$(KERNEL).o: $(SUBDIRS)
-	$(LD) -r -o $@ $(foreach subdir,$(SUBDIRS),$(subdir)/$(subdir)_all.o) $(LDLIBS)
-
-.PHONY: $(SUBDIRS)
-$(SUBDIRS):
-	$(MAKE) -C $@ SUBDIR=$@
-
-.PHONY: clean
-clean: $(SUBDIRS_clean)
-	-rm -f *~ $(KERNEL) $(KERNEL).{gz,o,elf,dump,map}
-
-%.clean:
-	$(MAKE) -C $* clean clean=1
@@ -1,2 +0,0 @@
-
-include $(HOS_TOPLEVEL)/subdir.mak
@@ -1,23 +0,0 @@
-; boot.asm
-; Author: Josh Holtrop
-; Date: 2009-06-25
-; Adapted from HOS 0.16 source
-
-%define CONSOLE_MEMORY              0xB8000
-
-; Symbols from C
-extern k_bootstrap, bootstrap_stack
-
-;**************************************************************************
-;* This is the entry point for the kernel.                                *
-;**************************************************************************
-[global start]
-start:
-    mov     cx, 0x0700 + 'a'
-    mov     [CONSOLE_MEMORY+160*8+0*2], cx
-
-    mov     esp, bootstrap_stack+4096       ; set up temporary stack space
-
-    push    eax                             ; multiboot bootloader magic value
-    push    ebx                             ; pointer to multiboot info struct
-    call    k_bootstrap
@@ -1,85 +0,0 @@
-
-#include "k_bootstrap.h"
-#include "k_main.h"
-#include "hos_types.h"
-#include "hos_defines.h"
-#include "multiboot.h"
-#include "sys/cpu.h"
-#include "k_early_panic.h"
-#include "mm/mm.h"
-#include "mm/stack.h"
-#include "lang/kio.h"
-#include "isr/interrupts.h"
-
-#define DEBUG_LETTER(col,chr) *(u16_t *)(KERNEL_OFFSET + CONSOLE_MEMORY \
-                                  + 160 * 8 + (col) * 2) \
-                                  = 0x0700 | (chr)
-extern "C" {
-
-u8_t bootstrap_stack[4096];
-
-/**************************************************************************
- * Multiboot header data block                                            *
- *************************************************************************/
-u32_t mb_header[] __attribute__ ((section (".multiboot_header") )) = {
-    MB_HEADER_MAGIC,                            /* magic */
-    MB_HEADER_FLAGS,                            /* flags */
-    -(MB_HEADER_MAGIC + MB_HEADER_FLAGS)        /* checksum */
-};
-
-/**************************************************************************
- * This function is invoked to bootstrap the kernel.                      *
- *************************************************************************/
-void k_bootstrap(mb_info_t * mb_info, u32_t mb_magic)
-{
-    DEBUG_LETTER(1, 'b');
-
-    if (mb_magic != MB_BOOTLOADER_MAGIC)
-    {
-        k_early_panic("Bad multiboot magic identifier!");
-    }
-
-    if ( ! (mb_info->flags & MB_BOOTLOADER_MMAP) )
-    {
-        k_early_panic("No memory map provided by bootloader!");
-    }
-
-    for (mb_mmap_t * mmap = (mb_mmap_t *) (mb_info->mmap_addr + KERNEL_OFFSET),
-                   * end = (mb_mmap_t *) ((u32_t)mmap + mb_info->mmap_length);
-         mmap < end;
-         mmap = (mb_mmap_t *) (((u32_t)mmap) + mmap->size + 4))
-    {
-//        kprintf(" ** size: %d, type: %d ", mmap->size, mmap->type);
-        mm_record_mmap_entry(mmap);
-    }
-
-    DEBUG_LETTER(2, 'c');
-
-    /*
-     * These functions could destroy the multiboot information block and
-     * associated structures, so we must be finished reading those structures
-     * before calling them.
-     */
-    mm_bootstrap();
-    DEBUG_LETTER(3, 'd');
-    interrupts_bootstrap();
-    DEBUG_LETTER(4, 'e');
-    kio_bootstrap();
-    DEBUG_LETTER(5, 'f');
-
-    /* begin using the permanent stack */
-    write_esp(KERNEL_STACK_TOP);
-    k_main();
-
-    idle_loop();
-}
-
-void idle_loop()
-{
-    for (;;)
-    {
-        __asm__ __volatile__ ("hlt");
-    }
-}
-
-} /* extern "C" */
@@ -1,17 +0,0 @@
-
-#ifndef K_BOOTSTRAP_H
-#define K_BOOTSTRAP_H
-
-#include "hos_types.h"
-#include "multiboot.h"
-
-extern "C" {
-
-void k_bootstrap(mb_info_t * mb_info, u32_t mb_magic)
-    __attribute__ ((noreturn));
-void idle_loop()
-    __attribute__ ((noreturn));
-
-}
-
-#endif
@@ -1,18 +0,0 @@
-
-#include "hos_types.h"
-#include "hos_defines.h"
-#include "k_early_panic.h"
-
-void k_early_panic(const char * msg)
-{
-    char * dest = (char *) (CONSOLE_MEMORY + KERNEL_OFFSET);
-    while (*msg)
-    {
-        *dest++ = *msg++;
-        *dest++ = 0x04;         /* red error message */
-    }
-
-    /* infinite loop */
-    for (;;)
-        ;
-}
@@ -1,15 +0,0 @@
-
-#ifndef K_EARLY_PANIC_H
-#define K_EARLY_PANIC_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void k_early_panic(const char * msg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -1,28 +0,0 @@
-
-#include "k_main.h"
-#include "lang/kio.h"
-#include "mm/mm.h"
-#include "sys/timer.h"
-#include "sys/pic.h"
-#include "isr/interrupts.h"
-
-extern "C" {
-
-void k_main()
-{
-    kprintf("Kernel load address: 0x%08x\n", KERNEL_CODE);
-    kprintf("Kernel code size: %d KB (%d bytes)\n",
-            (KERNEL_DATA - KERNEL_CODE) >> 10, KERNEL_DATA - KERNEL_CODE);
-    kprintf("Kernel data size: %d KB (%d bytes)\n",
-            (KERNEL_BSS - KERNEL_DATA) >> 10, KERNEL_BSS - KERNEL_DATA);
-    kprintf("Kernel bss size:  %d KB (%d bytes)\n",
-            (KERNEL_END - KERNEL_BSS) >> 10, KERNEL_END - KERNEL_BSS);
-    mm_print_memory_map();
-    timer_init(KERNEL_TIMER_FREQ);
-    pic_remap(0x20, 0x28);
-    pic_mask1(0x0);
-    pic_mask2(0x0);
-    interrupts_enable();
-}
-
-} /* extern "C" */
@@ -1,11 +0,0 @@
-
-#ifndef K_MAIN_H
-#define K_MAIN_H
-
-extern "C" {
-
-void k_main();
-
-}
-
-#endif
@@ -1,47 +0,0 @@
-
-#ifndef HOS_DEFINES_H
-#define HOS_DEFINES_H
-
-#include "hos_types.h"
-
-#define KERNEL_OFFSET           0x00000000
-
-#define PAGE_LOG_SIZE           12u
-#define PAGE_SIZE               (1 << PAGE_LOG_SIZE)
-#define PAGE_HIGH_MASK          (0xFFFFFFFFu << PAGE_LOG_SIZE)
-#define PAGE_LOW_MASK           (0xFFFFFFFFu >> (32 - PAGE_LOG_SIZE))
-
-#define CONSOLE_MEMORY          0xB8000
-
-#define KERNEL_CODE             (&_code)
-#define KERNEL_DATA             (&_data)
-#define KERNEL_BSS              (&_bss)
-#define KERNEL_END              (&_end)
-
-#define KERNEL_PHYSICAL_ADDRESS ((u32_t)(KERNEL_CODE - KERNEL_OFFSET))
-#define KERNEL_VIRTUAL_ADDRESS  ((u32_t)KERNEL_CODE)
-#define KERNEL_SIZE             ((u32_t)(KERNEL_END - KERNEL_CODE))
-
-#define KERNEL_TIMER_FREQ       1000
-
-#define BUILD_BUG_ON(condition) \
-    do { \
-        typedef struct { int negative_width_test : ((condition)?-1:1); } \
-            BUILD_BUG_ON_DUMMY_STRUCT; \
-    } \
-    while(0)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern  u8_t    _code;
-extern  u8_t    _data;
-extern  u8_t    _bss;
-extern  u8_t    _end;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -1,55 +0,0 @@
-
-#ifndef HOS_TYPES_H
-#define HOS_TYPES_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef unsigned char       u8_t;
-typedef signed char         s8_t;
-typedef unsigned short      u16_t;
-typedef signed short        s16_t;
-typedef unsigned int        u32_t;
-typedef signed int          s32_t;
-typedef unsigned long long  u64_t;
-typedef signed long long    s64_t;
-
-typedef struct
-{
-    u32_t   gs;
-    u32_t   fs;
-    u32_t   es;
-    u32_t   ds;
-
-    u32_t   edi;
-    u32_t   esi;
-    u32_t   ebp;
-    u32_t   esp_junk;               /* the esp value saved by 'pusha' */
-    u32_t   ebx;
-    u32_t   edx;
-    u32_t   ecx;
-    u32_t   eax;
-
-    u32_t   error;                  /* valid on exceptions 8, 10-14 */
-
-    u32_t   eip;
-    u32_t   cs;
-    u32_t   eflags;
-    u32_t   esp;                    /* present if privilege transition */
-    u32_t   ss;
-} int_stack_t;
-
-typedef struct
-{
-    u16_t   limit;
-    u32_t   base;
-} __attribute__ ((packed)) gdtr_t;
-
-typedef gdtr_t idtr_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -1,154 +0,0 @@
-
-#ifndef MULTIBOOT_H
-#define MULTIBOOT_H
-
-#include "hos_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* The magic number for the Multiboot header. */
-#define MB_HEADER_MAGIC             0x1BADB002
-#define MB_HEADER_FLAGS             0x00000003
-
-#define MB_HEADER_ALIGN_MODULES     (1 << 0)
-#define MB_HEADER_MEM_INFO          (1 << 1)
-#define MB_HEADER_VIDEO_INFO        (1 << 2)
-#define MB_HEADER_KLUDGE_OFFSETS    (1 << 16)
-
-/* The magic number passed by a Multiboot-compliant boot loader. */
-#define MB_BOOTLOADER_MAGIC         0x2BADB002
-
-#define MB_BOOTLOADER_MEM_INFO      (1 << 0)
-#define MB_BOOTLOADER_BOOT_DEVICE   (1 << 1)
-#define MB_BOOTLOADER_COMMAND_LINE  (1 << 2)
-#define MB_BOOTLOADER_MODS          (1 << 3)
-#define MB_BOOTLOADER_AOUT          (1 << 4)
-#define MB_BOOTLOADER_ELF           (1 << 5)
-#define MB_BOOTLOADER_MMAP          (1 << 6)
-#define MB_BOOTLOADER_DRIVES        (1 << 7)
-#define MB_BOOTLOADER_CONFIG        (1 << 8)
-#define MB_BOOTLOADER_APM           (1 << 9)
-#define MB_BOOTLOADER_GRAPHICS      (1 << 10)
-
-#define MB_DRIVE_MODE_CHS           0
-#define MB_DRIVE_MODE_LBA           1
-
-#define MB_MMAP_TYPE_RAM            1
-
-/* The Multiboot header. */
-typedef struct
-{
-    u32_t   magic;
-    u32_t   flags;
-    u32_t   checksum;
-    u32_t   header_addr;        // if flags[16]
-    u32_t   load_addr;          // if flags[16]
-    u32_t   load_end_addr;      // if flags[16]
-    u32_t   bss_end_addr;       // if flags[16]
-    u32_t   entry_addr;         // if flags[16]
-    u32_t   mode_type;          // if flags[2]
-    u32_t   width;              // if flags[2]
-    u32_t   height;             // if flags[2]
-    u32_t   depth;              // if flags[2]
-} mb_header_t;
-
-/* The symbol table for a.out. */
-typedef struct
-{
-    u32_t   tabsize;
-    u32_t   strsize;
-    u32_t   addr;
-    u32_t   reserved;
-} mb_aout_symbol_table_t;
-
-/* The section header table for ELF. */
-typedef struct
-{
-    u32_t   num;
-    u32_t   size;
-    u32_t   addr;
-    u32_t   shndx;
-} mb_elf_section_header_table_t;
-
-/* The Multiboot information. */
-typedef struct
-{
-    u32_t   flags;
-    u32_t   mem_lower;          // present if flags[0] is set
-    u32_t   mem_upper;
-    u32_t   boot_device;        // 1
-    u32_t   cmdline;            // 2
-    u32_t   mods_count;         // 3
-    u32_t   mods_addr;          // 3
-    union
-    {
-        mb_aout_symbol_table_t          aout_sym;   // 4
-        mb_elf_section_header_table_t   elf_sec;    // 5
-    };
-    u32_t   mmap_length;        // 6
-    u32_t   mmap_addr;          // 6
-    u32_t   drives_length;      // 7
-    u32_t   drives_addr;        // 7
-    u32_t   config_table;       // 8
-    u32_t   bootloader_name;    // 9
-    u32_t   apm_table;          // 10
-
-    u32_t   vbe_control_info;   // 11
-    u32_t   vbe_mode_info;      // 11
-    u16_t   vbe_mode;           // 11
-    u16_t   vbe_interface_seg;  // 11
-    u16_t   vbe_interface_off;  // 11
-    u16_t   vbe_interface_len;  // 11
-} mb_info_t;
-
-/* The module structure. */
-typedef struct
-{
-    u32_t   mod_start;
-    u32_t   mod_end;
-    u32_t   string;
-    u32_t   reserved;
-} mb_module_t;
-
-/* The memory map. Be careful that the offset 0 is base_addr_low, not size. */
-typedef struct
-{
-    u32_t   size;                 // offset -4
-    u64_t   base;                 // offset 0
-    u64_t   length;
-    u32_t   type;
-} mb_mmap_t;
-
-/* The drive structure */
-typedef struct
-{
-    u32_t   size;
-    u8_t    drive_number;
-    u8_t    drive_mode;
-    u8_t    drive_cylinders;
-    u8_t    drive_heads;
-    u8_t    drive_sectors;
-    u16_t   drive_ports[1];
-} mb_drive_t;
-
-/* APM table structure */
-typedef struct
-{
-    u16_t   version;
-    u16_t   cseg;
-    u32_t   offset;
-    u16_t   cseg_16;
-    u16_t   dseg;
-    u16_t   flags;
-    u16_t   cseg_len;
-    u16_t   cseg_16_len;
-    u16_t   dseg_len;
-} mb_apm_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -1,37 +0,0 @@
-
-#ifndef PORTIO_H
-#define PORTIO_H
-
-#include "hos_types.h"
-
-#define outportb(port, val) \
-    __asm__ __volatile__ ("outb %%al, %%dx" : : "a" (val), "d" (port));
-
-#define outportw(port, val) \
-    __asm__ __volatile__ ("outw %%ax, %%dx" : : "a" (val), "d" (port));
-
-#define outportd(port, val) \
-    __asm__ __volatile__ ("outl %%eax, %%dx" : : "a" (val), "d" (port));
-
-static inline u8_t inportb(u16_t port)
-{
-    u8_t val;
-    __asm__ __volatile__ ("inb %%dx, %%al" : "=a" (val) : "d" (port));
-    return val;
-}
-
-static inline u16_t inportw(u16_t port)
-{
-    u16_t val;
-    __asm__ __volatile__ ("inw %%dx, %%al" : "=a" (val) : "d" (port));
-    return val;
-}
-
-static inline u32_t inportd(u16_t port)
-{
-    u32_t val;
-    __asm__ __volatile__ ("inl %%dx, %%al" : "=a" (val) : "d" (port));
-    return val;
-}
-
-#endif
@@ -1,2 +0,0 @@
-
-include $(HOS_TOPLEVEL)/subdir.mak
@@ -1,110 +0,0 @@
-
-#include "hos_types.h"
-#include "interrupts.h"
-#include "mm/mm.h"
-#include "lang/kio.h"
-#include "sys/pic.h"
-#include "sys/cpu.h"
-
-extern "C" {
-
-idtr_t idtr;
-
-void isr(u8_t int_num, int_stack_t * istack)
-{
-    switch (int_num)
-    {
-    case 0x20:                  /* timer interrupt */
-        (*(u16_t *)CONSOLE_MEMORY)++;
-        pic_eoi();
-        break;
-    case 0x21:
-        /* TODO: keyboard hook */
-        pic_eoi();
-        break;
-    default:
-        kputs("--------------------------------------------------------------------------------");
-        kprintf("Unhandled Interrupt #%d\n", int_num);
-        kprintf("    ds: 0x%08x     es: 0x%08x     fs: 0x%08x     gs: 0x%08x\n",
-                istack->ds, istack->es, istack->fs, istack->gs);
-        kprintf("   eax: 0x%08x    ebx: 0x%08x    ecx: 0x%08x    edx: 0x%08x\n",
-                istack->eax, istack->ebx, istack->ecx, istack->edx);
-        kprintf("   ebp: 0x%08x    esi: 0x%08x    edi: 0x%08x eflags: 0x%08x\n",
-                istack->ebp, istack->esi, istack->edi, istack->eflags);
-        kprintf("    cs: 0x%08x    eip: 0x%08x     ss: 0x%08x    esp: 0x%08x\n",
-                istack->cs, istack->eip, istack->ss, istack->esp);
-        kprintf("   cr0: 0x%08x    cr2: 0x%08x    cr3: 0x%08x\n",
-                read_cr0(), read_cr2(), read_cr3());
-        kprintf(" Error: 0x%08x (%d)\n", istack->error, istack->error);
-        kputs("--------------------------------------------------------------------------------");
-
-        kprintf("Halting!\n");
-        for (;;)
-            ;
-        break;
-    }
-}
-
-} /* extern "C" */
-
-void interrupts_bootstrap()
-{
-    u32_t idt_phys = mm_page_alloc();
-    u32_t idt_virt = mm_early_vpage_alloc();
-    mm_map(idt_virt, idt_phys, 0, 1);
-
-    u64_t * idt = (u64_t *) idt_virt;
-    idt[0]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_0,  0);
-    idt[1]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_1,  0);
-    idt[2]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_2,  0);
-    idt[3]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_3,  0);
-    idt[4]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_4,  0);
-    idt[5]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_5,  0);
-    idt[6]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_6,  0);
-    idt[7]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_7,  0);
-    idt[8]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_8,  0);
-    idt[9]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_9,  0);
-    idt[10] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_10, 0);
-    idt[11] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_11, 0);
-    idt[12] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_12, 0);
-    idt[13] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_13, 0);
-    idt[14] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_14, 0);
-    idt[15] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_15, 0);
-    idt[16] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_16, 0);
-    idt[17] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_17, 0);
-    idt[18] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_18, 0);
-    idt[19] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_19, 0);
-    idt[20] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_20, 0);
-    idt[21] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_21, 0);
-    idt[22] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_22, 0);
-    idt[23] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_23, 0);
-    idt[24] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_24, 0);
-    idt[25] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_25, 0);
-    idt[26] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_26, 0);
-    idt[27] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_27, 0);
-    idt[28] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_28, 0);
-    idt[29] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_29, 0);
-    idt[30] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_30, 0);
-    idt[31] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_31, 0);
-    idt[32] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_32, 0);
-    idt[33] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_33, 0);
-    idt[34] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_34, 0);
-    idt[35] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_35, 0);
-    idt[36] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_36, 0);
-    idt[37] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_37, 0);
-    idt[38] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_38, 0);
-    idt[39] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_39, 0);
-    idt[40] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_40, 0);
-    idt[41] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_41, 0);
-    idt[42] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_42, 0);
-    idt[43] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_43, 0);
-    idt[44] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_44, 0);
-    idt[45] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_45, 0);
-    idt[46] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_46, 0);
-    idt[47] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_47, 0);
-    idt[48] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_48, 0);
-    idt[49] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_49, 0);
-    idtr.base = idt_phys;
-    idtr.limit = 49 * sizeof(idt[0]) - 1;
-    __asm__ __volatile__ ("lidt (idtr)" : : : "memory");
-}
@@ -1,79 +0,0 @@
-
-#ifndef INTERRUPTS_H
-#define INTERRUPTS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void isr(u8_t int_num, int_stack_t * int_stack);
-
-extern void isr_0();
-extern void isr_1();
-extern void isr_2();
-extern void isr_3();
-extern void isr_4();
-extern void isr_5();
-extern void isr_6();
-extern void isr_7();
-extern void isr_8();
-extern void isr_9();
-extern void isr_10();
-extern void isr_11();
-extern void isr_12();
-extern void isr_13();
-extern void isr_14();
-extern void isr_15();
-extern void isr_16();
-extern void isr_17();
-extern void isr_18();
-extern void isr_19();
-extern void isr_20();
-extern void isr_21();
-extern void isr_22();
-extern void isr_23();
-extern void isr_24();
-extern void isr_25();
-extern void isr_26();
-extern void isr_27();
-extern void isr_28();
-extern void isr_29();
-extern void isr_30();
-extern void isr_31();
-extern void isr_32();
-extern void isr_33();
-extern void isr_34();
-extern void isr_35();
-extern void isr_36();
-extern void isr_37();
-extern void isr_38();
-extern void isr_39();
-extern void isr_40();
-extern void isr_41();
-extern void isr_42();
-extern void isr_43();
-extern void isr_44();
-extern void isr_45();
-extern void isr_46();
-extern void isr_47();
-extern void isr_48();
-extern void isr_49();
-
-#ifdef __cplusplus
-}
-#endif
-
-#define MAKE_IDT_DESCRIPTOR(selector, offset, dpl) \
-    (u64_t) ( ( (((u64_t) offset) & 0xFFFF0000ull) << 32 )  /* offset 31:16 */ \
-            | ( ( (u64_t) 0x1ull) << 47 )                   /* present */      \
-            | ( (((u64_t) dpl) & 0x3) << 45 )               /* DPL */          \
-            | ( ( (u64_t) 0xEull) << 40 )                   /* TODO: gate? */  \
-            | ( (((u64_t) selector) & 0xFFFFull) << 16 )    /* selector */     \
-            | ( (((u64_t) offset) & 0x0000FFFFull) ) )      /* offset 15:0 */
-
-void interrupts_bootstrap();
-
-#define interrupts_enable() __asm__ __volatile__ ("sti");
-#define interrupts_disable() __asm__ __volatile__ ("cli");
-
-#endif
@@ -1,56 +0,0 @@
-
-; C ISR routine
-[extern isr]
-
-
-; Macro for creating a single ISR label
-; We need to push a junk value on the stack first
-; if the interrupt number is not 8 or 10-14.
-; This is to properly align the stack for both exceptions
-; having and not having error codes.
-%macro isr_label 1
-[global isr_%1]
-isr_%1:
-    %if ( (%1 != 8) && (%1 < 10 || %1 > 14) )
-        push    eax                 ; junk value to take error code stack space
-    %endif
-    pusha                           ; eax, ecx, edx, ebx, esp, ebp, esi, edi
-    mov     al, %1                  ; save interrupt number in al
-    %if ($ - isr_common) < 127      ; do a short jump and save 3 bytes if we can
-        jmp short isr_common
-    %else
-        jmp     isr_common
-    %endif
-%endmacro
-
-
-; The common ISR routine
-isr_common:
-    push    ds
-    push    es
-    push    fs
-    push    gs
-
-    push    esp                     ; pointer to interrupt stack
-    push    eax                     ; interrupt number
-    call    isr
-    pop     eax                     ; restore stack pointer (this is shorter
-    pop     eax                     ; than "add esp, 8" and "lea esp, [esp+8]")
-
-    pop     gs
-    pop     fs
-    pop     es
-    pop     ds
-    popa                            ; edi, esi, ebp, <null>, ebx, edx, ecx, eax
-    lea     esp, [esp+4]            ; bypass error code
-
-    iret
-
-
-; Loop to create all of our ISR entry points
-%assign i 0
-%rep 50
-    isr_label i
-    %assign i i+1
-%endrep
-
@@ -1,2 +0,0 @@
-
-include $(HOS_TOPLEVEL)/subdir.mak
@@ -1,317 +0,0 @@
-
-#include "hos_types.h"
-#include "hos_defines.h"
-#include "kio.h"
-#include "string.h"
-#include "portio.h"
-
-#include <limits.h>
-#include <stdarg.h>                 /* va_*() */
-
-static void fmt_d2a(char * buf, int val);
-static void fmt_u2a(char * buf, unsigned int val);
-static void fmt_ll2a(char * buf, long long val);
-static void fmt_ull2a(char * buf, unsigned long long val);
-static void fmt_x2a(char * buf, unsigned int val);
-static void fmt_xl2a(char * buf, unsigned long long val);
-static void fmt_o2a(char * buf, unsigned int val);
-
-static int cursor_x, cursor_y;
-
-static void writeCursorPosition(int x, int y)
-{
-    u16_t pos = 80 * y + x;
-    outportb(0x3D4, 0x0E);
-    outportb(0x3D5, pos >> 8);
-    outportb(0x3D4, 0x0F);
-    outportb(0x3D5, pos);
-}
-
-extern "C" {
-
-void kio_bootstrap()
-{
-    cursor_x = 0;
-    cursor_y = 9;
-    writeCursorPosition(cursor_x, cursor_y);
-}
-
-void kprintf(const char * fmt, ...)
-{
-    va_list args;
-    va_start(args, fmt);
-
-    kvprintf(fmt, args);
-
-    va_end(args);
-}
-
-void kvprintf(const char * fmt, va_list args)
-{
-    char tmpbuf[25];
-    for ( ; *fmt; fmt++)
-    {
-        if (*fmt == '%')
-        {
-            fmt++;
-            if (*fmt)
-            {
-                int width = 0;
-                char pad_char = ' ';
-                bool pad_right = false;
-                if (*fmt == '0')
-                {
-                    pad_char = '0';
-                    fmt++;
-                }
-                else if (*fmt == '-')
-                {
-                    pad_right = true;
-                    fmt++;
-                }
-                for ( ; '0' <= *fmt && *fmt <= '9'; fmt++)
-                {
-                    if (width == 0)
-                    {
-                        width = *fmt - '0';
-                    }
-                    else
-                    {
-                        width *= 10;
-                        width += *fmt - '0';
-                    }
-                }
-                switch (*fmt)
-                {
-                    case 'c':
-                        kputc(va_arg(args, int));
-                        break;
-                    case 'd':
-                        fmt_d2a(tmpbuf, va_arg(args, int));
-                        kputs_pad(tmpbuf, width, pad_char, pad_right);
-                        break;
-                    case 'l':
-                        fmt_ll2a(tmpbuf, va_arg(args, long long));
-                        kputs_pad(tmpbuf, width, pad_char, pad_right);
-                        break;
-                    case 'L':
-                        fmt_ull2a(tmpbuf, va_arg(args, unsigned long long));
-                        kputs_pad(tmpbuf, width, pad_char, pad_right);
-                        break;
-                    case 'o':
-                        fmt_o2a(tmpbuf, va_arg(args, unsigned int));
-                        kputs_pad(tmpbuf, width, pad_char, pad_right);
-                        break;
-                    case 's':
-                        kputs_pad(va_arg(args, char *),
-                                  width, pad_char, pad_right);
-                        break;
-                    case 'u':
-                        fmt_u2a(tmpbuf, va_arg(args, unsigned int));
-                        kputs_pad(tmpbuf, width, pad_char, pad_right);
-                        break;
-                    case 'x':
-                        fmt_x2a(tmpbuf, va_arg(args, unsigned int));
-                        kputs_pad(tmpbuf, width, pad_char, pad_right);
-                        break;
-                    case 'X':
-                        fmt_xl2a(tmpbuf, va_arg(args, unsigned long long));
-                        kputs_pad(tmpbuf, width, pad_char, pad_right);
-                        break;
-                    case '%':
-                        kputc('%');
-                        break;
-                }
-            }
-        }
-        else
-        {
-            kputc(*fmt);
-        }
-        if (!*fmt)
-        {
-            break;
-        }
-    }
-}
-
-void kputc(char c)
-{
-    u16_t * console_memory = (u16_t *) CONSOLE_MEMORY;
-    console_memory += 80 * cursor_y + cursor_x;
-    switch (c)
-    {
-        case '\t':
-            {
-                int to_advance = 8 - (cursor_x & 0x3);
-                while (to_advance--)
-                {
-                    *console_memory++ = 0x0720;
-                }
-            }
-            break;
-        case '\n':
-            cursor_x = 0;
-            cursor_y++;
-            break;
-        default:
-            *console_memory = 0x0700 | (c & 0xFF);
-            cursor_x++;
-            break;
-    }
-    if (cursor_x >= 80)
-    {
-        cursor_x = 0;
-        cursor_y++;
-    }
-    if (cursor_y >= 25)
-    {
-        memcpy((u8_t *) CONSOLE_MEMORY,
-               (u8_t *) (CONSOLE_MEMORY + 80 * 2),
-               2 * 80 * 24);
-        memsetw((u16_t *) (CONSOLE_MEMORY + 2 * 80 * 24), 0x0720, 80);
-        cursor_y = 24;
-    }
-    writeCursorPosition(cursor_x, cursor_y);
-}
-
-void kputs(const char * s)
-{
-    while (*s)
-    {
-        kputc(*s);
-        s++;
-    }
-}
-
-void kputs_pad(const char * s, int width, char pad_char, bool pad_right)
-{
-    int len = strlen(s);
-    if (pad_right)
-    {
-        kputs(s);
-    }
-    int num_pad_chars = width - len;
-    for (int i = 0; i < num_pad_chars; i++)
-    {
-        kputc(pad_char);
-    }
-    if (!pad_right)
-    {
-        kputs(s);
-    }
-}
-
-} /* extern "C" */
-
-static void fmt_d2a(char * buf, int val)
-{
-    if (val < 0)
-    {
-        *buf++ = '-';
-        val = -val;
-    }
-    fmt_u2a(buf, (unsigned int) val);
-}
-
-static void fmt_u2a(char * buf, unsigned int val)
-{
-    bool printing = false;
-    for (unsigned int div = 1000000000; div >= 1; div /= 10)
-    {
-        unsigned int n = val / div;
-        if (n || div == 1)
-        {
-            printing = true;
-        }
-        if (printing)
-        {
-            *buf++ = '0' + n;
-        }
-        val -= n * div;
-    }
-    *buf = '\0';
-}
-
-static void fmt_ll2a(char * buf, long long val)
-{
-    if (val < 0)
-    {
-        *buf++ = '-';
-        val = -val;
-    }
-    fmt_ull2a(buf, (unsigned long long) val);
-}
-
-static void fmt_ull2a(char * buf, unsigned long long val)
-{
-    bool printing = false;
-    for (unsigned long long div = 10000000000000000000ull; div >= 1; div /= 10)
-    {
-        unsigned long long n = val / div;
-        if (n || div == 1)
-        {
-            printing = true;
-        }
-        if (printing)
-        {
-            *buf++ = '0' + n;
-        }
-        val -= n * div;
-    }
-    *buf = '\0';
-}
-
-static void fmt_x2a(char * buf, unsigned int val)
-{
-    bool printing = false;
-    for (int s = 28; s >= 0; s -= 4)
-    {
-        unsigned int n = (val >> s) & 0xF;
-        if (n || s == 0)
-        {
-            printing = true;
-        }
-        if (printing)
-        {
-            *buf++ = "0123456789abcdef"[n];
-        }
-    }
-    *buf = '\0';
-}
-
-static void fmt_xl2a(char * buf, unsigned long long val)
-{
-    bool printing = false;
-    for (int s = 60; s >= 0; s -= 4)
-    {
-        unsigned int n = (val >> s) & 0xF;
-        if (n || s == 0)
-        {
-            printing = true;
-        }
-        if (printing)
-        {
-            *buf++ = "0123456789abcdef"[n];
-        }
-    }
-    *buf = '\0';
-}
-
-static void fmt_o2a(char * buf, unsigned int val)
-{
-    bool printing = false;
-    for (int s = 30; s >= 0; s -= 3)
-    {
-        unsigned int n = (val >> s) & 0x7;
-        if (n || s == 0)
-        {
-            printing = true;
-        }
-        if (printing)
-        {
-            *buf++ = "01234567"[n];
-        }
-    }
-    *buf = '\0';
-}
@@ -1,27 +0,0 @@
-
-#ifndef KIO_H
-#define KIO_H
-
-#include <stdarg.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void kio_bootstrap();
-
-void kprintf(const char * fmt, ...);
-
-void kvprintf(const char * fmt, va_list args);
-
-void kputc(char c);
-
-void kputs(const char * s);
-
-void kputs_pad(const char * s, int width, char pad_char, bool pad_right);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif
@@ -1,73 +0,0 @@
-
-#include "string.h"
-
-extern "C" {
-
-void strcpy(char * dst, const char * src)
-{
-    while (*src)
-    {
-        *dst++ = *src++;
-    }
-    *dst = '\0';
-}
-
-u32_t strlen(const char * s)
-{
-    u32_t len = 0;
-    while (*s++)
-    {
-        len++;
-    }
-    return len;
-}
-
-void memcpy(u8_t * dst, u8_t * src, u32_t size)
-{
-    for (u32_t n = 0; n < size; n++)
-    {
-        *dst++ = *src++;
-    }
-}
-
-void memcpyw(u16_t * dst, u16_t * src, u32_t size)
-{
-    for (u32_t n = 0; n < size; n++)
-    {
-        *dst++ = *src++;
-    }
-}
-
-void memcpyd(u32_t * dst, u32_t * src, u32_t size)
-{
-    for (u32_t n = 0; n < size; n++)
-    {
-        *dst++ = *src++;
-    }
-}
-
-void memset(u8_t * dst, u8_t val, u32_t size)
-{
-    for (u32_t n = 0; n < size; n++)
-    {
-        *dst++ = val;
-    }
-}
-
-void memsetw(u16_t * dst, u16_t val, u32_t size)
-{
-    for (u32_t n = 0; n < size; n++)
-    {
-        *dst++ = val;
-    }
-}
-
-void memsetd(u32_t * dst, u32_t val, u32_t size)
-{
-    for (u32_t n = 0; n < size; n++)
-    {
-        *dst++ = val;
-    }
-}
-
-} /* extern "C" */
@@ -1,27 +0,0 @@
-
-#ifndef STRING_H
-#define STRING_H
-
-#include "hos_defines.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void strcpy(char * dst, const char * src);
-
-u32_t strlen(const char * s);
-
-void memcpy(u8_t * dst, u8_t * src, u32_t size);
-void memcpyw(u16_t * dst, u16_t * src, u32_t size);
-void memcpyd(u32_t * dst, u32_t * src, u32_t size);
-
-void memset(u8_t * dst, u8_t val, u32_t size);
-void memsetw(u16_t * dst, u16_t val, u32_t size);
-void memsetd(u32_t * dst, u32_t val, u32_t size);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -1,34 +0,0 @@
-OUTPUT_FORMAT(elf32-i386)
-ENTRY(start)
-virt = 0x00100000;
-phys = 0x00100000;
-SECTIONS
-{
-    .text virt : AT(phys) {
-        code = .; _code = .; __code = .;
-        *(.multiboot_header*)
-        *(.text*)
-        *(.gnu.linkonce*)
-        . = ALIGN(4096);
-    }
-    .rodata : {
-        *(.rodata*)
-        . = ALIGN(4096);
-    }
-    .other : {
-        *(.eh_*)
-        *(.rel*)
-        . = ALIGN(4096);
-    }
-    .data : {
-        data = .; _data = .; __data = .;
-        *(.data*)
-        . = ALIGN(4096);
-    }
-    .bss : {
-        bss = .; _bss = .; __bss = .;
-        *(.bss*)
-        . = ALIGN(4096);
-    }
-    end = .; _end = .; __end = .;
-}
@@ -1,2 +0,0 @@
-
-include $(HOS_TOPLEVEL)/subdir.mak
@@ -1,405 +0,0 @@
-
-#include <stddef.h>
-
-#include "mm.h"
-#include "stack.h"
-#include "boot/k_early_panic.h"
-#include "lang/string.h"
-#include "lang/kio.h"
-#include "sys/cpu.h"
-
-#define MM_MAX_MMAP_ENTRIES 64
-
-/* mmap management */
-static mm_mem_range_t mm_mmap_entries[MM_MAX_MMAP_ENTRIES];
-static int mm_mmap_num_entries = 0;
-
-/* free/total page statistics */
-static int mm_num_free_pages = 0;
-static int mm_num_total_pages = 0;
-
-gdtr_t mm_gdtr;
-static u64_t * mm_gdt;              /* NOT mapped into virtual address space */
-static u32_t mm_heap_base;          /* virtual address of start of heap */
-static pagedirectory_t * early_page_directory_ptr;
-
-/* physical addresses of page allocation pages to map in before the heap */
-static u32_t page_alloc_page_numbers[1025]; /* supports 4GB physical memory */
-static int last_page_alloc_page = -1; /* index of last valid page alloc page */
-static int page_alloc_page_index = -1;
-static mm_page_alloc_page_t * page_alloc_pages;
-static int page_alloc_pages_index = -1;
-
-/**************************************************************************
- * Internal Functions                                                     *
- *************************************************************************/
-static void record_phys_page(u32_t base_address);
-
-/**************************************************************************
- * Compile-time tests                                                     *
- *************************************************************************/
-static void build_tests()
-{
-    /* check that a mm_page_alloc_page_t fits exactly in a page */
-    BUILD_BUG_ON(sizeof(mm_page_alloc_page_t) != PAGE_SIZE);
-}
-
-/**************************************************************************
- * This function is run in segmented memory before paging is in effect.   *
- * Record an mmap entry from the bootloader into our kernel space.        *
- *************************************************************************/
-void mm_record_mmap_entry(mb_mmap_t * mmap)
-{
-    if (mm_mmap_num_entries < MM_MAX_MMAP_ENTRIES)
-    {
-        if (mmap->type == MB_MMAP_TYPE_RAM)
-        {
-            mm_mmap_entries[mm_mmap_num_entries].base   = mmap->base;
-            mm_mmap_entries[mm_mmap_num_entries].length = mmap->length;
-            mm_mmap_num_entries++;
-        }
-    }
-    else
-    {
-        k_early_panic("Too many mmap_entries!");
-    }
-}
-
-/**************************************************************************
- * This function is run in segmented memory before paging is in effect.   *
- * It is run after the bootloader information has been read, so we can    *
- * overwrite that memory now.                                             *
- *************************************************************************/
-void mm_bootstrap()
-{
-    u32_t max_ram_address = KERNEL_PHYSICAL_ADDRESS + KERNEL_SIZE - 1;
-
-    if (mm_mmap_num_entries < 1)
-    {
-        k_early_panic("No mmap entries read from bootloader!");
-    }
-
-    mm_heap_base = (u32_t) KERNEL_END;
-    page_alloc_pages = (mm_page_alloc_page_t *) mm_heap_base;
-
-    for (int mmap_idx = 0; mmap_idx < mm_mmap_num_entries; mmap_idx++)
-    {
-        u32_t base_address = mm_mmap_entries[mmap_idx].base;
-        u32_t address_limit = base_address + mm_mmap_entries[mmap_idx].length;
-
-        if (base_address & PAGE_LOW_MASK)
-        {
-            /* start of this mmap range is not page-aligned */
-            base_address = (base_address & PAGE_HIGH_MASK) + PAGE_SIZE;
-        }
-        if (address_limit & PAGE_LOW_MASK)
-        {
-            /* end of this mmap range is not page-aligned */
-            address_limit &= PAGE_HIGH_MASK;
-        }
-
-        /* record the highest RAM address found */
-        if ((address_limit - 1) > max_ram_address)
-        {
-            max_ram_address = (address_limit - 1);
-        }
-
-        /*
-         * loop through every page in the mmap range and add
-         * pages into the free page linked list
-         */
-        for (; base_address < address_limit; base_address += PAGE_SIZE)
-        {
-            /* check to make sure the page doesn't overlap the kernel */
-            if ( base_address + PAGE_SIZE <= KERNEL_PHYSICAL_ADDRESS
-              || base_address >= KERNEL_PHYSICAL_ADDRESS + KERNEL_SIZE )
-            {
-                record_phys_page(base_address);
-                mm_num_free_pages++;
-            }
-            mm_num_total_pages++;
-        }
-    }
-
-    if (mm_num_free_pages < 10)
-    {
-        k_early_panic("Not enough free pages of RAM!");
-    }
-
-    /* ok, now mm_early_page_alloc() should be functional */
-
-    /* move the heap back to after the page allocation pages */
-    mm_heap_base = (u32_t) &page_alloc_pages[last_page_alloc_page + 1];
-
-    /* ok, now mm_early_vpage_alloc() should be functional */
-
-    /* allocate the page directory */
-    u32_t page_directory_phys = mm_early_page_alloc();
-    early_page_directory_ptr = (pagedirectory_t *)
-        (page_directory_phys + KERNEL_OFFSET);
-
-    /* Clear the page directory */
-    for (unsigned int i = 0; i < NUM_PAGETABLE_ENTRIES; i++)
-    {
-        (*early_page_directory_ptr)[i] = 0;
-    }
-
-    /* ok, now mm_early_map() should be functional */
-
-    /* map in the page directory itself so we can modify it once paging is on */
-    (*early_page_directory_ptr)[PAGE_DIR_SELF_REF_INDEX] =
-        (page_directory_phys) | (0x1 << 1) | (0x1);
-
-    /* map in the physical page allocator pages */
-    for (int i = 0; i <= last_page_alloc_page; i++)
-    {
-        mm_early_map((u32_t) &page_alloc_pages[i],
-                page_alloc_page_numbers[i], 0, 1);
-    }
-
-    /* map the kernel's virtual address space into RAM */
-    for (u32_t page_base = KERNEL_VIRTUAL_ADDRESS;
-         page_base < KERNEL_VIRTUAL_ADDRESS + KERNEL_SIZE;
-         page_base += PAGE_SIZE)
-    {
-        /* map page_base to page_base - KERNEL_OFFSET */
-        mm_early_map(page_base, page_base - KERNEL_OFFSET, 0, 1);
-    }
-
-    /* map console memory */
-    mm_early_map(CONSOLE_MEMORY, CONSOLE_MEMORY, 0, 1);
-
-    /* set up the global descriptor table */
-    u32_t gdt_base = mm_early_page_alloc();
-    mm_gdt = (u64_t *) ((u32_t) gdt_base + (u32_t) KERNEL_OFFSET);
-    mm_gdt[0] = 0x0ull;
-    mm_gdt[1] = MAKE_DESCRIPTOR(0, 0xFFFFF, 1, 0, 1, 1);    /* kernel code */
-    mm_gdt[2] = MAKE_DESCRIPTOR(0, 0xFFFFF, 1, 0, 1, 0);    /* kernel data */
-    mm_gdtr.limit = 3 * sizeof(mm_gdt[0]) - 1;
-    mm_gdtr.base = gdt_base;
-
-    __asm__ __volatile__ (
-            "lgdt (mm_gdtr);\n"
-            "jmp $0x08, $42f;\n"
-            "42:\n"
-            "mov $0x10, %%cx\n"
-            "mov %%cx, %%ss\n"
-            "mov %%cx, %%ds\n"
-            "mov %%cx, %%es\n"
-            "mov %%cx, %%fs\n"
-            "mov %%cx, %%gs\n"
-            : /* no outputs */
-            : /* no inputs */
-            : "ecx");
-
-    /* set the page directory base register */
-    write_cr3(page_directory_phys);
-
-    /* set up permanent stack before enabling paging */
-    stack_bootstrap();
-
-    /* turn on paging */
-    write_cr0(read_cr0() | (1 << 31));
-}
-
-/**************************************************************************
- * This function is run in segmented memory before paging is in effect.   *
- * Record a physical page in the page allocation pages.                   *
- *************************************************************************/
-static void record_phys_page(u32_t base_address)
-{
-    if (page_alloc_page_index < 0)
-    {
-        /* allocate a new page alloc page */
-        last_page_alloc_page++;
-        page_alloc_pages_index++;
-        page_alloc_page_numbers[last_page_alloc_page] = base_address;
-        page_alloc_page_index = 0;
-    }
-    else
-    {
-        mm_page_alloc_page_t * current_page_alloc_page =
-            (mm_page_alloc_page_t *)
-            (page_alloc_page_numbers[page_alloc_pages_index] + KERNEL_OFFSET);
-        page_alloc_page_index++;
-        (*current_page_alloc_page)[page_alloc_page_index] = base_address;
-        if (page_alloc_page_index == NUM_PAGETABLE_ENTRIES - 1)
-        {
-            page_alloc_page_index = -1;
-        }
-    }
-}
-
-/**************************************************************************
- * Map virtual_address to physical_address.                               *
- * Both addresses should be page-aligned.                                 *
- * This 'early' version can be used during segmented bootstrapping        *
- *************************************************************************/
-int mm_early_map(u32_t virtual_address, u32_t physical_address,
-                 u32_t user_mode, u32_t writable)
-{
-    u32_t directory_index = (virtual_address >> 22) & 0x3FF;
-    u32_t table_index = (virtual_address >> 12) & 0x3FF;
-
-    if ((*early_page_directory_ptr)[directory_index] == 0)
-    {
-        /* allocate a new page table */
-        u32_t page_table_phys = mm_early_page_alloc();
-        if (page_table_phys == 0)
-        {
-            return 0;
-        }
-        pagedirectory_entry_t * page_table_virt = (pagedirectory_entry_t *)
-            (page_table_phys + KERNEL_OFFSET);
-        for (unsigned int i = 0; i < NUM_PAGETABLE_ENTRIES; i++)
-        {
-            page_table_virt[i] = 0;
-        }
-        (*early_page_directory_ptr)[directory_index] = page_table_phys
-                                  | (0x1 << 2)  /* PTs can be user mode */
-                                  | (0x1 << 1)  /* writable */
-                                  | (0x1);      /* present */
-    }
-    u32_t page_table_phys =
-        (*early_page_directory_ptr)[directory_index] & PAGE_HIGH_MASK;
-
-    pagedirectory_entry_t * page_table =
-        (pagedirectory_entry_t *) (page_table_phys + KERNEL_OFFSET);
-
-    page_table[table_index] = (physical_address & PAGE_HIGH_MASK)
-                            | ((user_mode & 0x1) << 2)
-                            | ((writable & 0x1) << 1)
-                            | 0x1;      /* present */
-
-    return 1;
-}
-
-/**************************************************************************
- * Map virtual_address to physical_address.                               *
- * Both addresses should be page-aligned.                                 *
- *************************************************************************/
-int mm_map(u32_t virtual_address, u32_t physical_address,
-           u32_t user_mode, u32_t writable)
-{
-    u32_t directory_index = (virtual_address >> 22) & 0x3FF;
-    u32_t table_index = (virtual_address >> 12) & 0x3FF;
-    pagedirectory_entry_t * page_dir_entry = (pagedirectory_entry_t *)
-        (PAGE_DIR_SELF_REF2 | (directory_index << 2));
-
-    if (*page_dir_entry == 0)
-    {
-        /* allocate a new page table */
-        u32_t page_table_phys = mm_page_alloc();
-        if (page_table_phys == 0)
-        {
-            return 0;
-        }
-        *page_dir_entry = page_table_phys
-                        | (0x1 << 2)    /* PTs can be user mode */
-                        | (0x1 << 1)    /* writable */
-                        | (0x1);        /* present */
-        pagedirectory_entry_t * page_table = (pagedirectory_entry_t *)
-            (PAGE_DIR_SELF_REF | (directory_index << 12));
-        for (unsigned int i = 0; i < NUM_PAGETABLE_ENTRIES; i++)
-        {
-            page_table[i] = 0;
-        }
-    }
-
-    pagedirectory_entry_t * page_table_entry = (pagedirectory_entry_t *)
-        (PAGE_DIR_SELF_REF | (directory_index << 12) | (table_index << 2));
-
-    *page_table_entry = (physical_address & PAGE_HIGH_MASK)
-                      | ((user_mode & 0x1) << 2)
-                      | ((writable & 0x1) << 1)
-                      | 0x1;      /* present */
-
-    return 1;
-}
-
-/**************************************************************************
- * Returns the physical base address of a page in RAM                     *
- * or 0 if no pages were available                                        *
- * This 'early' version can be used during segmented bootstrapping        *
- *************************************************************************/
-u32_t mm_early_page_alloc()
-{
-    u32_t page_address = 0;
-    if (page_alloc_pages_index >= 0)
-    {
-        if (page_alloc_page_index >= 0)
-        {
-            mm_page_alloc_page_t * current_pap = (mm_page_alloc_page_t *)
-                (page_alloc_page_numbers[page_alloc_pages_index]
-                    + KERNEL_OFFSET);
-            page_address = (*current_pap)[page_alloc_page_index];
-            page_alloc_page_index--;
-        }
-        else
-        {
-            /* return the page allocation page itself */
-            page_address = page_alloc_page_numbers[page_alloc_pages_index];
-            page_alloc_pages_index--;
-            page_alloc_page_index = NUM_PAGETABLE_ENTRIES - 1;
-        }
-        mm_num_free_pages--;
-    }
-    return page_address;
-}
-
-/**************************************************************************
- * Returns the physical base address of a page in RAM                     *
- * or 0 if no pages were available                                        *
- *************************************************************************/
-u32_t mm_page_alloc()
-{
-    u32_t page_address = 0;
-    if (page_alloc_pages_index >= 0)
-    {
-        if (page_alloc_page_index >= 0)
-        {
-            page_address =
-                page_alloc_pages[page_alloc_pages_index][page_alloc_page_index];
-            page_alloc_page_index--;
-        }
-        else
-        {
-            /* return the page allocation page itself */
-            page_address = page_alloc_page_numbers[page_alloc_pages_index];
-            page_alloc_pages_index--;
-            page_alloc_page_index = NUM_PAGETABLE_ENTRIES - 1;
-        }
-        mm_num_free_pages--;
-    }
-    return page_address;
-}
-
-/**************************************************************************
- * This function allocates a virtual page. It should only be called       *
- * during the bootstrap process, before the kernel begins its normal      *
- * operation. It adjusts the heap pointer to push it back beyond any      *
- * bootstrap pages allocated.                                             *
- *************************************************************************/
-u32_t mm_early_vpage_alloc()
-{
-    u32_t vaddress = mm_heap_base;
-    mm_heap_base += PAGE_SIZE;
-    return vaddress;
-}
-
-void mm_print_memory_map()
-{
-    kprintf("Bootloader provided memory map:\n");
-    kprintf("  Base Address       Length\n");
-    for (int i = 0; i < mm_mmap_num_entries; i++)
-    {
-        kprintf("  0x%016X 0x%016X (%l bytes / %l KB / %l MB)\n",
-                mm_mmap_entries[i].base,
-                mm_mmap_entries[i].length,
-                mm_mmap_entries[i].length,
-                mm_mmap_entries[i].length >> 10,
-                mm_mmap_entries[i].length >> 20);
-    }
-    kprintf("Used pages: %d\n", mm_num_total_pages - mm_num_free_pages);
-    kprintf("Free pages: %d\n", mm_num_free_pages);
-}
@@ -1,65 +0,0 @@
-
-#ifndef MM_H
-#define MM_H MM_H
-
-#include "hos_types.h"
-#include "hos_defines.h"
-#include "multiboot.h"
-
-#define KERNEL_CODE_SEGMENT 0x08
-#define KERNEL_DATA_SEGMENT 0x10
-
-typedef u32_t pagedirectory_entry_t;
-
-#define NUM_PAGETABLE_ENTRIES   (PAGE_SIZE / sizeof(pagedirectory_entry_t))
-
-#define PAGE_DIR_SELF_REF   (0x20000000u - (PAGE_SIZE * NUM_PAGETABLE_ENTRIES))
-#define PAGE_DIR_SELF_REF_INDEX ((PAGE_DIR_SELF_REF >> 22) & 0x3FF)
-#define PAGE_DIR_SELF_REF2  (PAGE_DIR_SELF_REF | (PAGE_DIR_SELF_REF_INDEX << 12))
-
-typedef pagedirectory_entry_t pagedirectory_t[NUM_PAGETABLE_ENTRIES];
-
-typedef struct
-{
-    u64_t   base;
-    u64_t   length;
-} mm_mem_range_t;
-
-typedef u32_t mm_page_alloc_page_t[NUM_PAGETABLE_ENTRIES];
-
-/* http://courses.ece.illinois.edu/ece391/references/descriptors.pdf */
-/* granularity: 0: limit in bytes; 1: limit in pages */
-/* dpl: 0: system mode; 3: user mode */
-/* normal: 0: TSS/LDT/call gate; 1: code/data segment */
-/* code_seg: 0: data segment; 1: code segment */
-#define MAKE_DESCRIPTOR(base, limit, granularity, dpl, normal, code_seg)       \
-        (u64_t) ( ( (((u64_t) base) & 0xFF000000ull) << 32 ) /* base 31:24 */  \
-                | ( (((u64_t) granularity) & 0x1ull) << 55 ) /* granularity */ \
-                | ( ( (u64_t) 0x1ull) << 54 )                /* 32-bit */      \
-                | ( (((u64_t) limit) & 0xF0000ull) << 32 )   /* limit 19:16 */ \
-                | ( ( (u64_t) 0x1ull) << 47 )                /* present */     \
-                | ( (((u64_t) dpl) & 0x3ull) << 45 )         /* dpl */         \
-                | ( (((u64_t) normal) & 0x1ull) << 44 )      /* normal */      \
-                | ( (((u64_t) code_seg) & 0x1ull) << 43 )    /* code seg */    \
-                | ( ( (u64_t) 0x2ull) << 40 )                /* ? */           \
-                | ( (((u64_t) base) & 0x00FFFFFFull) << 16)  /* base 23:00 */  \
-                | ( (((u64_t) limit) & 0x0000FFFFull) ) )    /* limit 15:00 */
-
-typedef u64_t descriptor_t;
-
-void mm_record_mmap_entry(mb_mmap_t * mmap);
-void mm_bootstrap();
-
-int mm_early_map(u32_t virtual_address, u32_t physical_address,
-                 u32_t user_mode, u32_t writable);
-int mm_map(u32_t virtual_address, u32_t physical_address,
-           u32_t user_mode, u32_t writable);
-
-u32_t mm_early_page_alloc();
-u32_t mm_page_alloc();
-u32_t mm_early_vpage_alloc();
-
-void mm_print_memory_map();
-
-#endif
-
@@ -1,19 +0,0 @@
-
-#include "stack.h"
-#include "mm.h"
-#include "hos_defines.h"
-
-void stack_bootstrap()
-{
-    /*
-     * running from our temporary stack while segmentation is enabled,
-     * set up the "permanent" stack for use while paging
-     */
-    u32_t stack_page_virt = KERNEL_STACK_TOP - PAGE_SIZE;
-    for (int i = 0; i < STACK_INITIAL_SIZE; i++)
-    {
-        u32_t stack_page_phys = mm_early_page_alloc();
-        mm_early_map(stack_page_virt, stack_page_phys, 0, 1);
-        stack_page_virt -= PAGE_SIZE;
-    }
-}
@@ -1,13 +0,0 @@
-
-#ifndef STACK_H
-#define STACK_H
-
-#include "mm/mm.h"
-
-#define KERNEL_STACK_TOP    PAGE_DIR_SELF_REF
-
-#define STACK_INITIAL_SIZE 2        /* number of initial stack pages */
-
-void stack_bootstrap();
-
-#endif
@@ -1,54 +0,0 @@
-
-ASMOBJS         := $(patsubst %.asm,%.o,$(wildcard *.asm))
-COBJS           := $(patsubst %.c,%.o,$(wildcard *.c))
-CXXOBJS         := $(patsubst %.cc,%.o,$(wildcard *.cc))
-CDEPS           := $(COBJS:.o=.dep)
-CXXDEPS         := $(CXXOBJS:.o=.dep)
-DEPS			:= $(CDEPS) $(CXXDEPS)
-OUTPUT_FILE     := $(SUBDIR)_all.o
-
-ifdef SUBDIRS
-SUBDIRS_clean   := $(SUBDIRS:%=%.clean)
-endif
-
-all: $(OUTPUT_FILE)
-
-$(OUTPUT_FILE): $(ASMOBJS) $(COBJS) $(CXXOBJS) $(SUBDIRS)
-	$(LD) -r -o $@ $(ASMOBJS) $(COBJS) $(CXXOBJS) $(foreach subdir,$(SUBDIRS),$(subdir)/$(subdir)_all.o)
-
-%.o: %.asm
-	$(NASM) -f elf -o $@ -l $<.lst $<
-
-%.o: %.c
-	$(CC) -c -o $@ $(CPPFLAGS) $(CFLAGS) $<
-
-%.o: %.cc
-	$(CXX) -c -o $@ $(CPPFLAGS) $(CXXFLAGS) $<
-
-ifdef SUBDIRS
-.PHONY: $(SUBDIRS)
-$(SUBDIRS):
-	$(MAKE) -C $@ SUBDIR=$@
-endif
-
-# Make dependency files
-%.dep: %.c
-	@set -e; rm -f $@; \
-	  $(CC) -MM $(CPPFLAGS) $< | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@
-
-%.dep: %.cc
-	@set -e; rm -f $@; \
-	  $(CXX) -MM $(CPPFLAGS) $< | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@
-
-clean: $(SUBDIRS_clean)
-	-rm -f *.o *.dep *.lst *~
-
-ifdef SUBDIRS
-%.clean:
-	$(MAKE) -C $* clean clean=1
-endif
-
-# Include dependency files
-ifndef clean
-include $(DEPS)
-endif
@@ -1,2 +0,0 @@
-
-include $(HOS_TOPLEVEL)/subdir.mak
@@ -1,40 +0,0 @@
-
-#ifndef CPU_H
-#define CPU_H
-
-#include "hos_types.h"
-
-static u32_t read_cr0() __attribute__ ((unused));
-static u32_t read_cr0()
-{
-    u32_t val;
-    __asm__ __volatile__ ("movl %%cr0, %0" : "=r" (val));
-    return val;
-}
-
-static u32_t read_cr2() __attribute__ ((unused));
-static u32_t read_cr2()
-{
-    u32_t val;
-    __asm__ __volatile__ ("movl %%cr2, %0" : "=r" (val));
-    return val;
-}
-
-static u32_t read_cr3() __attribute__ ((unused));
-static u32_t read_cr3()
-{
-    u32_t val;
-    __asm__ __volatile__ ("movl %%cr3, %0" : "=r" (val));
-    return val;
-}
-
-#define write_cr0(val) \
-    __asm__ __volatile__ ("movl %0, %%cr0" : : "r" (val));
-
-#define write_cr3(val) \
-    __asm__ __volatile__ ("movl %0, %%cr3" : : "r" (val));
-
-#define write_esp(val) \
-    __asm__ __volatile__ ("movl %0, %%esp" : : "r" (val));
-
-#endif
@@ -1,29 +0,0 @@
-
-#include "pic.h"
-#include "portio.h"
-
-/*
- * Re-maps the Programmable Interrupr Controllers
- * so IRQ0->pic1 base address, IRG8->pic2 base address
- */
-void pic_remap(u8_t base1, u8_t base2)
-{
-    u8_t    a1, a2;
-
-    a1 = inportb(PIC1_DATA);        /* 0x21 */
-    a2 = inportb(PIC2_DATA);        /* 0xA1 */
-
-    outportb(PIC1_COMMAND, ICW1_INIT+ICW1_ICW4); /* 0x20, 0x10+0x01 00010001b */
-    outportb(PIC2_COMMAND, ICW1_INIT+ICW1_ICW4); /* 0xA0, 0x10+0x01 00010001b */
-    outportb(PIC1_DATA, base1);     /* 0x21, pic1 */
-    outportb(PIC2_DATA, base2);     /* 0xA1, pic2 */
-    outportb(PIC1_DATA, 4);         /* 0x21, 0x04 00000100b */
-    outportb(PIC2_DATA, 2);         /* 0xA1, 0x02 00000010b */
-    outportb(PIC1_DATA, ICW4_8086); /* 0x21, 0x01 00000001b */
-    outportb(PIC2_DATA, ICW4_8086); /* 0xA1, 0x01 00000001b */
-
-    outportb(PIC1_DATA, a1);        /* 0x21 */
-    outportb(PIC2_DATA, a2);        /* 0xA1 */
-}
-
-
@@ -1,46 +0,0 @@
-
-#ifndef PIC_H
-#define PIC_H
-
-#include "hos_types.h"
-#include "portio.h"
-
-#define PIC1            0x20
-#define PIC2            0xA0
-#define PIC1_COMMAND    PIC1
-#define PIC1_DATA       (PIC1+1)
-#define PIC2_COMMAND    PIC2
-#define PIC2_DATA       (PIC2+1)
-#define PIC_EOI         0x20
-
-#define ICW1_ICW4       0x01            /* ICW4 (not) needed */
-#define ICW1_SINGLE     0x02            /* Single (cascade) mode */
-#define ICW1_INTERVAL4  0x04            /* Call address interval 4 (8) */
-#define ICW1_LEVEL      0x08            /* Level triggered (edge) mode */
-#define ICW1_INIT       0x10            /* Initialization - required! */
-
-#define ICW4_8086       0x01            /* 8086/88 (MCS-80/85) mode */
-#define ICW4_AUTO       0x02            /* Auto (normal) EOI */
-#define ICW4_BUF_SLAVE  0x08            /* Buffered mode/slave */
-#define ICW4_BUF_MASTER 0x0C            /* Buffered mode/master */
-#define ICW4_SFNM       0x10            /* Special fully nested (not) */
-
-void pic_remap(u8_t base1, u8_t base2);
-
-/* Masks interrupts on first Programmable Interrupt Controller */
-#define pic_mask1(mask) outportb(PIC1_DATA, mask) /* 0x21, maskfield *OCW1* */
-
-/* Masks interrupts on second Programmable Interrupt Controller */
-#define pic_mask2(mask) outportb(PIC2_DATA, mask) /* 0xA1, maskfield *OCW1* */
-
-/* Signals an End Of Interrupt signal to the first PIC */
-#define pic_eoi() outportb(0x20, 0x20)
-
-/* Signals an End Of Interrupt signal to both the second and first PIC unit */
-static inline void pic_eoi2()
-{
-        outportb(0xA0, 0x20);
-        outportb(0x20, 0x20);
-}
-
-#endif
@@ -1,12 +0,0 @@
-
-#include "timer.h"
-#include "portio.h"
-
-void timer_init(u32_t freq)
-{
-    /* how many ticks the PIT must wait before issuing an interrupt */
-    u32_t wait = 1193180 / freq;
-    outportb(0x43, 0x34);
-    outportb(0x40, wait);       /* LSB */
-    outportb(0x40, wait >> 8);  /* MSB */
-}
@@ -1,9 +0,0 @@
-
-#ifndef TIMER_H
-#define TIMER_H
-
-#include "hos_types.h"
-
-void timer_init(u32_t freq);
-
-#endif
@@ -0,0 +1,254 @@
+//Keyboard.c
+// Created: 04/17/03 Josh Holtrop
+// Modified: 10/30/03
+//for HOS
+
+#define KBD_BUFFER_LENGTH 64
+
+byte kbdFlags = 0;		//holds current keyboard flags - caps/num/scroll/shift/ctrl/alt
+byte kbdAscii = 0;		//holds ASCII value of a key pressed
+byte kbdScan = 0;		//holds the keyboard scan code of a key pressed
+
+dword kbdBuffer[KBD_BUFFER_LENGTH];	//a buffer for all keypresses
+int kbdBufferStart = 0;			//position of next key in buffer
+int kbdBufferLen = 0;			//number of keys left in the buffer
+byte kbdExt = 0;			//# of extended key codes left to input
+byte kbdExt2 = 0;                       //# of 2nd-set-extended key codes left to input
+byte ackReason = 0;		//used to record the reason why we would get an acknowledge byte (0xFA)
+
+
+//these arrays convert a keyboard scan code to an ASCII character value
+                                   //nul esc            bksp tab              lctl            lsft            rsft lalt caps F1  F2  F3  F4  F5  F6  F7  F8  F9  F10 numScrlNumPad-------                                  unknown---- F11 F12 unknown....
+const byte SCAN2ASCII[128]      = "\000\0331234567890-=\010\011qwertyuiop[]\n\001asdfghjkl;'`\001\\zxcvbnm,./\001*\001 \001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001-\001\001\001+\001\001\001\001\001\002\002\002\001\001\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002";
+const byte SCAN2ASCIISHIFT[128] = "\000\033!@#$%^&*()_+\010\011QWERTYUIOP{}\n\001ASDFGHJKL:\"~\001|ZXCVBNM<>?\001*\001 \001\001\001\001\001\001\001\001\001\001\001\001\001789-456+1230.\002\002\002\001\001\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002";
+
+//====FUNCTIONS:
+// The Keyboard Interrupt Service Routine
+void isr_keyboard()
+{
+	kbdScan = inportb(0x60);
+	//printf("\nKEYBOARD INTERRUPT: 0x%x", kbdScan);
+	byte inState = inportb(0x61);
+	outportb(0x61, inState|0x80);
+	outportb(0x61, inState);
+	
+	//printf("IRQ 1: %x\n", kbdScan);
+
+	if (kbdScan == 0xFA)	//250					//ACKnowledge
+	{
+		//printf("KBD_ACK 0x%x!\n", ackReason);
+		if (ackReason == 0xED)					//reset LEDs
+		{
+			outportb(0x60, (kbdFlags & 0x07));
+		}
+		ackReason = 0;
+	}
+	if (kbdScan == 224)						//extended key
+	{
+		kbdExt = 1;
+		eoi();
+		return;
+	}
+	if (kbdScan == 225)						//2nd-set-extended key
+	{
+		kbdExt2 = 2;
+		eoi();
+		return;
+	}
+
+//====handle control keys::
+	kbdAscii = 2;
+	switch (kbdScan)						//control keys
+	{
+		case KBD_SCAN_LSHIFT:
+			kbdFlags |= KBD_SHIFT;
+			kbdAscii = 1;
+			break;
+		case KBD_SCAN_RSHIFT:
+			kbdFlags |= KBD_SHIFT;
+			kbdAscii = 1;
+			break;
+		case KBD_SCAN_LCTRL:
+			kbdFlags |= KBD_CTRL;
+			kbdAscii = 1;
+			break;
+		case KBD_SCAN_LALT:
+			kbdFlags |= KBD_ALT;			
+			kbdAscii = 1;
+			break;
+
+		case KBD_SCAN_LSHIFT + KBD_SCAN_RELEASED:
+			kbdFlags &= (KBD_SHIFT ^ 0xFF);
+			kbdAscii = 1;
+			break;
+		case KBD_SCAN_RSHIFT + KBD_SCAN_RELEASED:
+			kbdFlags &= (KBD_SHIFT ^ 0xFF);
+			kbdAscii = 1;
+			break;
+		case KBD_SCAN_LCTRL + KBD_SCAN_RELEASED:
+			kbdFlags &= (KBD_CTRL ^ 0xFF);
+			kbdAscii = 1;
+			break;
+		case KBD_SCAN_LALT + KBD_SCAN_RELEASED:
+			kbdFlags &= (KBD_ALT ^ 0xFF);
+			kbdAscii = 1;
+			break;
+
+		case KBD_SCAN_CAPS+KBD_SCAN_RELEASED:
+			kbdFlags ^= KBD_CAPS;
+			kbdAscii = 1;
+			kbd_resetLEDs();				//update LEDs
+			break;
+		case KBD_SCAN_SCROLL+KBD_SCAN_RELEASED:
+			kbdFlags ^= KBD_SCROLL;
+			kbdAscii = 1;
+			kbd_resetLEDs();				//update LEDs
+			break;
+		case KBD_SCAN_NUM+KBD_SCAN_RELEASED:
+			kbdFlags ^= KBD_NUM;
+			kbdAscii = 1;
+			kbd_resetLEDs();				//update LEDs
+			break;
+	}
+	if (kbdAscii == 1)
+	{
+		if (kbdExt > 0)
+			kbdExt--;
+		eoi();
+		return;
+	}
+//====determine ASCII value of key::
+	if (kbdExt > 0)						//extended key, kbdScan holds extended key
+	{
+		kbdExt--;
+		kbdAscii = 1;
+		switch (kbdScan)
+		{
+			case KBD_SCANE_ENTER:
+				kbdAscii = '\n';	break;
+			case 53:				// '/' character (divide on numpad)
+				kbdAscii = '/';		break;
+		}
+	}
+	else if (kbdExt2 > 0)					//extended key 2
+	{
+		kbdExt2--;
+//		if (kbdScan == 69)				// (pause|break)
+//			kbdAscii = 2;				//flag ascii value of 1 means control character (pausebreak)
+//		else
+			kbdAscii = 2;				//flag ascii value of 2 means ignore key (or unknown value)
+	}
+	else							//not an extended key
+	{
+			// if letter key
+		if (((kbdScan >= 16) && (kbdScan <= 25)) || ((kbdScan >= 30) && (kbdScan <= 38)) || ((kbdScan >= 44) && (kbdScan <= 50)))
+		{
+			// if caps and shift are different (either one pressed, not both)
+			if (((kbdFlags & KBD_SHIFT) != 0) & ((kbdFlags & KBD_CAPS) != 0))
+				kbdAscii = SCAN2ASCII[kbdScan & 0x7F];
+			else if (((kbdFlags & KBD_SHIFT) == 0) & ((kbdFlags & KBD_CAPS) == 0))
+				kbdAscii = SCAN2ASCII[kbdScan & 0x7F];
+			else
+				kbdAscii = SCAN2ASCIISHIFT[kbdScan & 0x7F];
+		}
+			// if numpad key
+		else if ((kbdScan >= 71) && (kbdScan <= 83))
+		{
+			// if numlock on
+			if (kbdFlags & KBD_NUM)
+				kbdAscii = SCAN2ASCIISHIFT[kbdScan & 0x7F];
+			else
+				kbdAscii = SCAN2ASCII[kbdScan & 0x7F];
+		}
+			// other key
+		else
+		{
+			if ((kbdFlags & KBD_SHIFT) != 0)
+				kbdAscii = SCAN2ASCIISHIFT[kbdScan & 0x7F];
+			else
+				kbdAscii = SCAN2ASCII[kbdScan & 0x7F];
+		}
+	}
+
+//====do something with key::
+//	printf("kbdScan == %d\nkbdAscii == %d\nkbdFlags == %d\n", kbdScan, kbdAscii, kbdFlags);
+	if ((kbdScan == 83) && (kbdFlags & KBD_CTRL) && (kbdFlags & KBD_ALT))
+	{
+		printf("Initiating reboot.");
+		restart();
+	}
+	if (kbdAscii == 2)							//unknown key / ignore key
+	{
+		eoi();
+		return;
+	}
+	if (kbdScan < KBD_SCAN_RELEASED)					//a key was pressed, save it
+	{
+		if (kbdBufferLen >= KBD_BUFFER_LENGTH)				//no key slots available
+		{
+			eoi();
+			return;
+		}
+		else
+		{
+			kbdBuffer[(kbdBufferStart+kbdBufferLen++)%KBD_BUFFER_LENGTH] = (dword) ((kbdFlags << 16) | (kbdScan << 8) | kbdAscii);
+//			printf("S:%d\tL:%d\tR:%x\n", kbdBufferStart, kbdBufferLen, kbdBuffer[kbdBufferStart]);
+		}
+	}
+
+	eoi();
+
+}
+
+//Switches the case of an ASCII character
+/*inline byte (byte asciiCode)
+{
+	if ((asciiCode >= 'A') & (asciiCode <= 'Z'))
+		return (asciiCode + ('a' - 'A'));
+	if ((asciiCode >= 'a') & (asciiCode <= 'z'))
+		return (asciiCode - ('a' - 'A'));
+	return asciiCode;
+}*/
+
+//Gets a key from the buffer, returns 0 if no keys available, returns immediately
+dword kbdGetKey()
+{
+	if (kbdBufferLen == 0)					//buffer empty
+		return 0;
+	dword retVal = kbdBuffer[kbdBufferStart];
+	kbdBufferStart++;
+	kbdBufferLen--;
+	if (kbdBufferStart >= KBD_BUFFER_LENGTH)
+		kbdBufferStart = 0;
+	return retVal;
+}
+
+//Gets a key from the buffer, if no keys available, waits for one to be entered
+dword kbdWaitKey()
+{
+	for (;;)
+	{
+		if (kbdBufferLen != 0)					//buffer empty
+			break;
+	}		
+	dword retVal = kbdBuffer[kbdBufferStart];
+	kbdBufferStart++;
+	kbdBufferLen--;
+	if (kbdBufferStart >= KBD_BUFFER_LENGTH)
+		kbdBufferStart = 0;
+	return retVal;
+}
+
+//Resets the keyboard LEDs to reflect the current state of the num lock, caps lock, and scroll lock bits
+inline void kbd_resetLEDs()
+{
+	outportb(0x60, 0xED);
+	//outportb(0x60, (kbdFlags & 0x07));
+	ackReason = 0xED;
+}
+
+
+
+
+
+
@@ -0,0 +1,47 @@
+//Keyboard.h
+// Created: 04/17/03 Josh Holtrop
+// Modified: 05/07/03
+//for HOS
+
+#define KBD_SCROLL 0x01
+#define KBD_NUM 0x02
+#define KBD_CAPS 0x04
+#define KBD_SHIFT 0x10
+#define KBD_CTRL 0x20
+#define KBD_ALT 0x40
+
+#define KBD_SCAN_RELEASED 128
+
+#define KBD_SCAN_LCTRL 29
+#define KBD_SCAN_LSHIFT 42
+#define KBD_SCAN_RSHIFT 54
+#define KBD_SCAN_LALT 56
+#define KBD_SCAN_SCROLL 70
+#define KBD_SCAN_CAPS 58
+#define KBD_SCAN_NUM 69
+
+#define KBD_SCANE_PRINTSCREEN 55
+#define KBD_SCANE_INS 82
+#define KBD_SCANE_HOME 71
+#define KBD_SCANE_PGUP 73
+#define KBD_SCANE_DEL 83
+#define KBD_SCANE_END 79
+#define KBD_SCANE_PGDN 81
+#define KBD_SCANE_ENTER 28
+
+#define KBD_SCANE_NULL 42
+
+
+
+//====PROTOTYPES:
+
+void isr_keyboard();
+inline void kbd_resetLEDs();
+inline byte kbd_ascii(dword keycode);
+inline byte kbd_scancode(dword keycode);
+inline byte kbd_flags(dword keycode);
+inline byte switchCase(byte asciiCode);
+dword kbdGetKey();
+dword kbdWaitKey();
+
+
@@ -0,0 +1,133 @@
+
+//kio.c
+// Author: Josh Holtrop
+// Created: 12/25/03
+// Modified: 12/25/03
+
+
+// This is the main output routine, it uses a format string and a variable
+//  number of arguments to print formatted text
+void	printf(char *fmt, ...)
+{
+	dword *params = ((dword *)(&fmt)) + 1;		//points to the first paramater
+	int i;
+	int special = 0;
+	for (i = 0; ; i++)
+	{
+		if (special)
+		{
+			special = 0;
+			switch (fmt[i])
+			{
+			case 0:
+				return;
+			case '%':
+				putc('%');
+				break;
+			case 's': case 'S':
+				puts((char *)*params);
+				params++;
+				break;
+			case 'c': case 'C':
+				putc(*params);
+				params++;
+				break;
+			case 'd': case 'D':
+				putDec(*params);
+				params++;
+				break;
+			case 'u': case 'U':
+				putDecu(*params);
+				params++;
+				break;
+			case 'x': case 'X':
+				putHex(*params);
+				params++;
+				break;
+			}
+		}
+		else
+		{
+			switch (fmt[i])
+			{
+			case '%':
+				special = 1;
+				break;
+			case 0:
+				return;
+			default:
+				putc(fmt[i]);
+			}
+		}
+	}
+}
+
+
+// This function draws a single character
+void	putc(dword chr)
+{
+ 	char charac = (char)chr;
+	word *vidmem = (word *)0xC00B8000;
+	if (charac == '\n')
+	{
+		if (cursorPosition % 80)
+			cursorPosition = cursorPosition + 80 - (cursorPosition % 80);
+		else
+			cursorPosition += 80;
+	}
+	else if (charac == '\t')
+	{
+		if (cursorPosition % 8)
+			cursorPosition = cursorPosition + 8 - (cursorPosition % 8);
+		else
+			cursorPosition += 8;
+	}
+	else
+	{
+		if (videoMode)
+		{
+			console_memory[cursorPosition] = charac | 0x0700;
+			video_drawConsoleChar(cursorPosition);
+		}
+		else
+		{
+			console_memory[cursorPosition] = charac | 0x0700;
+			vidmem[cursorPosition] = charac | 0x0700;
+		}
+		cursorPosition++;
+	}
+	if (cursorPosition >= 2000)
+	{
+		console_scroll();
+		cursorPosition = 2000-80;
+		if (videoMode)
+			video_drawConsole();
+	}
+	if (!videoMode)
+		writeCursorPosition(cursorPosition);
+}
+
+
+// This function displays a number in hexadecimal
+int putHex(dword number)
+{
+	int hitNum = 0;
+	int i;
+	for (i = 7; i >= 0; i--)
+	{
+		dword val = (number >> (i*4)) & 0xF;
+		if ((val != 0) || (i == 0))
+			hitNum = 1;
+		if (hitNum)
+		{
+			val = val + '0';
+			if (val > '9')
+				val = val + ('A' - '9' - 1);
+			putc(val);
+		}
+	}
+}
+
+
+
+
@@ -0,0 +1,15 @@
+//kio.h
+// Author: Josh Holtrop
+// Created: 12/25/03
+// Modified: 12/25/03
+
+
+
+void	printf(char *fmt, ...);
+void	putc(dword chr);
+int	putHex(dword number);
+
+
+dword	cursorPosition = 0;		//Caches the current cursor position
+
+
@@ -0,0 +1 @@
+ld -nodefaultlibs -nostdlib -T link.ld -o kernel.bin -Map .\lst\LDout.doc ks.o kernel.o asmfuncs.o
@@ -0,0 +1,22 @@
+OUTPUT_FORMAT("binary")
+ENTRY(start)
+SECTIONS
+{
+  .text  0xC0106000 : {
+    code = .; _code = .; __code = .;
+    *(.text)
+    . = ALIGN(4096);
+  }
+  .data  : {
+    data = .; _data = .; __data = .;
+    *(.data)
+    . = ALIGN(4096);
+  }
+  .bss  :
+  {
+    bss = .; _bss = .; __bss = .;
+    *(.bss)
+    . = ALIGN(4096);
+  }
+  end = .; _end = .; __end = .;
+}
@@ -0,0 +1,121 @@
+// mm.c
+// Author: Josh Holtrop
+// Created: 09/01/03
+// Modified: 12/28/03
+
+//The total amount of physical memory available (bytes)
+#define BITMAP_SIZE	0x20000
+dword	mm_totalmem = 0;
+dword	mm_megabytes;
+byte	page_bitmap[BITMAP_SIZE];		//used to store a bit for each page that is used, 0 if available
+					//0x20000*(8 bits/byte)=0x100000 pages in 4gb total
+
+//This function initializes the memory manager's linked list, filling it with the
+// memory areas returned by bios interrupt 0x8E20
+void	mm_init()
+{
+	dword	memmap_entries = *(dword *)0xC009040A;
+	memmap_entry	*maps = (memmap_entry *) 0xC0092000;
+	dword a;
+ 	for (a = 0; a < BITMAP_SIZE; a++)
+ 	{
+ 		page_bitmap[a] = 0xFF;	//all pages used
+ 	}
+	for (a = 0; a < memmap_entries; a++)
+	{
+		if (maps[a].attributes == 1)		// (1) mem free to OS
+		{
+			mm_totalmem += maps[a].limit.lowdword;
+			if  ((maps[a].base.lowdword + maps[a].limit.lowdword) >= (FREERAM_START+4096))	//goes past where we start freeram
+			{
+				if (maps[a].base.lowdword < FREERAM_START)
+				{
+					mm_pfreen(FREERAM_START, (maps[a].limit.lowdword - (FREERAM_START - maps[a].base.lowdword)) >> 12);
+				}
+				else
+				{
+					mm_pfreen(maps[a].base.lowdword, maps[a].limit.lowdword >> 12);	//set the appropriate bits as "free" in the page bitmap
+				}
+			}
+		}
+	}
+	if (mm_totalmem % 0x100000)
+		mm_megabytes = (mm_totalmem >> 20) + 1;
+	else
+		mm_megabytes = mm_totalmem >> 20;
+}
+
+
+// This function frees a certain number of pages starting at the address
+//  specified in base for a length of pages pages
+void	mm_pfreen(dword base, dword pages)
+{
+	dword a;
+	dword max = base + (pages << 12);
+	for (a = base; a < max; a += 4096)
+	{
+		mm_pfree(a);
+	}
+}
+
+
+// This function frees a single page
+void	mm_pfree(dword base)
+{
+//	dword pageNumber = base >> 12;	// >>12 == /4096
+	dword byteNumber = base >> 15;	//pageNumber >> 3;	//pageNumber/8
+	dword bitNumber = (base >> 12) % 8; //pageNumber % 8;
+	page_bitmap[byteNumber] = page_bitmap[byteNumber] & ((0x01 << bitNumber) ^ 0xFF);
+}
+
+
+// This function allocates a single page, returning its physical address
+void	*mm_palloc()
+{
+	dword bite;
+	for (bite = 0; bite < BITMAP_SIZE; bite++)
+	{
+		if (page_bitmap[bite] != 0xFF)	//there is an available page within this 8-page region
+		{
+			int bit;
+			for (bit = 0; bit < 8; bit++)
+			{
+				if (!(page_bitmap[bite] & (1 << bit)))	//this bite/bit combination is available
+				{
+					page_bitmap[bite] = page_bitmap[bite] | (1 << bit);	//set page as used
+					return (void *)((bite << 15) | (bit << 12));
+				}
+			}
+		}
+	}
+	return 0;	//no free page
+}
+
+
+// This function reports the number of bytes of free physical memory
+dword	mm_freemem()
+{
+	dword a;
+	dword pages = 0;
+	for (a = 0; a < BITMAP_SIZE; a++)
+	{
+		int bit;
+		for (bit = 0; bit < 8; bit++)
+		{
+			if (!(page_bitmap[a] & (1 << bit)))
+				pages++;
+		}
+	}
+	return pages << 12;
+}
+
+
+
+
+
+
+
+
+
+
+
@@ -0,0 +1,21 @@
+
+
+typedef struct {
+	qword	base;
+	qword	limit;
+	dword	attributes;
+} __attribute__((packed)) memmap_entry;
+
+
+
+void	mm_init();
+void	mm_pfreen(dword base, dword pages);
+void	mm_pfree(dword base);
+void	*mm_palloc();
+dword	mm_freemem();
+
+
+
+
+
+
@@ -0,0 +1,60 @@
+// mouse.c
+// 10/03/03
+// Author: Josh Holtrop
+
+
+//This method initializes the ps/2 mouse
+void mouse_init()
+{
+	outportb(0x64, 0x20);		//tell keyboard controller we are going to read keyboard controller command byte
+	byte temp = inportb(0x60);	//read keyboard controller command byte
+	outportb(0x64, 0x60);		//tell keyboard controller we are going to write keyboard controller command byte
+	outportb(0x60, 0x03 | (temp&0x40));	//write keyboard controller command byte: enable mouse/keyboard ints, include original XLATE bit from temp (bit6)
+
+ 	outportb(0x64, 0xA8);	//enable mouse port
+
+	outportb(0x64, 0xD4);	//send command to mouse, not kbd
+	outportb(0x60, 0xF4);	//enable data reporting
+	
+	mouse_x = video_mode.XResolution >> 1;
+	mouse_y = video_mode.YResolution >> 1;
+
+	//outportb(0x64, 0xD4);
+	//outportb(0x60, 0xE7);	//scaling 2:1
+}
+
+
+//This method is called when a mouse interrupt occurs
+void isr_mouse()
+{
+	byte inb = inportb(0x60);	//read mouse byte
+	if ((inb == 0xFA) && (mouse_bytesRead < 1))		//ACK
+		return;
+	mouse_inbuffer[mouse_bytesRead] = inb;
+	mouse_bytesRead++;
+	if (mouse_bytesRead == 3)	//complete packet received
+	{
+		mouse_bytesRead = 0;
+		int adjx = (char) mouse_inbuffer[1];
+		int adjy = (char) mouse_inbuffer[2];
+		mouse_x += adjx;
+		mouse_y -= adjy;						//-= because screen y coordinates are opposite mouse y coordinates
+		if (mouse_x < 0)
+			mouse_x = 0;
+		if (mouse_x >= video_mode.XResolution)
+			mouse_x = video_mode.XResolution - 1;
+		if (mouse_y < 0)
+			mouse_y = 0;
+		if (mouse_y >= video_mode.YResolution)
+			mouse_y = video_mode.YResolution - 1;
+		if (mouse_inbuffer[0] & 0x01)	//left button
+			video_pset(mouse_x, mouse_y, 0x00FF8800);
+		else
+			video_pset(mouse_x, mouse_y, 0x00FFFFFF);
+	}
+}
+
+
+
+
+
@@ -0,0 +1,17 @@
+// mouse.h
+// 10/03/03
+// Author: Josh Holtrop
+
+
+int mouse_x;
+int mouse_y;
+int mouse_bytesRead = 0;
+byte mouse_inbuffer[16];
+
+void mouse_init();
+void isr_mouse();
+
+
+
+
+
@@ -0,0 +1,14 @@
+// rd.c
+// Author: Josh Holtrop
+// Created: 12/31/03
+// Modified: 01/04/04
+
+
+byte	*rd_readSector(DiskDevice *rd, dword sector, byte *dest)
+{
+	memcpy(dest, (void *)(rd->location + (sector * 512)), 512);
+	return dest;
+}
+
+
+
@@ -0,0 +1,9 @@
+// rd.h
+// Author: Josh Holtrop
+// Created: 12/31/03
+// Modified: 01/04/04
+
+
+byte	*rd_readSector(DiskDevice *rd, dword sector, byte *dest);
+
+
@@ -0,0 +1,228 @@
+
+%include "bootdef.inc"
+
+[bits 16]
+
+org 0x7c00
+
+	jmp short start
+
+; --------------------------------------------------
+; data portion of the "DOS BOOT RECORD"
+; ----------------------------------------------------------------------
+brINT13Flag     DB      90H             ; 0002h - 0EH for INT13 AH=42 READ
+brOEM           DB      'MSDOS5.0'      ; 0003h - OEM ID - Windows 95B
+brBPS           DW      512             ; 000Bh - Bytes per sector
+brSPC           DB      1               ; 000Dh - Sector per cluster
+brSc_b4_fat	DW      1               ; 000Eh - Reserved sectors
+brFATs          DB      2               ; 0010h - FAT copies
+brRootEntries   DW      0E0H		; 0011h - Root directory entries
+brSectorCount   DW      2880		; 0013h - Sectors in volume, < 32MB
+brMedia         DB      240		; 0015h - Media descriptor
+brSPF           DW      9               ; 0016h - Sectors per FAT
+brSc_p_trk	DW      18              ; 0018h - Sectors per head/track
+brHPC           DW      2		; 001Ah - Heads per cylinder
+brSc_b4_prt	DD      0               ; 001Ch - Hidden sectors
+brSectors       DD      0	        ; 0020h - Total number of sectors
+brDrive		DB      0               ; 0024h - Physical drive no.
+		DB      0               ; 0025h - Reserved (FAT32)
+		DB      29H             ; 0026h - Extended boot record sig (FAT32)
+brSerialNum     DD      404418EAH       ; 0027h - Volume serial number
+brLabel         DB      'Holtrops OS'   ; 002Bh - Volume label
+brFSID          DB      'FAT12   '      ; 0036h - File System ID
+;------------------------------------------------------------------------
+
+start:
+	jmp	0:jmphere		;ensure that cs=0 and ip=0x7c00...
+jmphere:
+	;dl=drive number, save it!
+	xor	ax, ax
+	mov	ds, ax
+	mov	[brDrive], dl
+	cli
+	mov	ss, ax
+	mov	sp, 0x7Bfe		;right under boot sector
+	sti
+
+	mov	ax, 0xb800
+	mov	ds, ax
+	mov	es, ax
+
+	xor	di, di
+	mov	ax, 0x0700
+	mov	cx, 2000
+cls:
+	stosw
+	loop	cls
+
+enable_a20:
+	in	al, 0x64
+	test	al, 2
+	jnz	enable_a20
+	mov	al, 0xD1
+	out	0x64, al
+ea20_2:	in	al, 0x64
+	and	ax, byte 2
+	jnz	ea20_2
+	mov	al, 0xDF
+	out	0x60, al
+
+unreal:
+	xor	ax, ax
+	mov	es, ax
+	mov	ds, ax
+
+	lgdt	[gdtr]		;load gdt
+	cli
+	push	es
+	push	ds		;save segment values
+	mov	ebx, cr0
+	inc	bl
+	mov	cr0, ebx	;pmode!
+	mov	ax, KERNEL_DATA
+	mov	es, ax
+	mov	ds, ax		;load segment limits
+	dec	bl
+	mov	cr0, ebx	;back to real mode!
+	pop	ds
+	pop	es		;segments back, with 4gb limits!
+	sti
+
+;now lets read in the FAT and root directory so we can search for the stage2 file...
+	mov	ax, 0x0209		;FAT1
+	mov	cx, 0x0002
+	xor	dh, dh
+	mov	dl, [brDrive]
+	mov	bx, BOOT_FAT_SEG
+	mov	es, bx
+	xor	bx, bx
+	int	0x13
+
+	mov	ax, 0x020E		;root directory
+	mov	cx, 0x0002		;cyl/sect
+	mov	dh, 0x01		;head
+	mov	dl, [brDrive]		;drive
+	mov	bx, BOOT_ROOT_SEG
+	mov	es, bx
+	xor	bx, bx
+	int	0x13
+
+;k now read root directory
+	mov	bx, BOOT_ROOT_SEG
+	mov	ds, bx
+	xor	si, si			;k now ds:si points to beginning of root directory
+	mov	es, si
+	mov	cx, 224			;max root entries
+loop_compare:
+	mov	di, stage2
+	push	cx
+	push	si			;save pointer to root dir entry
+	mov	cx, 11
+loop_name:
+	cmpsb
+	loopz	loop_name
+	jnz	goon			;cx didn't get to zero, bad file
+	pop	si
+	pop	cx
+	jmp	found_file		;good file, ds:si points to start of root directory entry
+goon:
+	pop	si
+	pop	cx
+	add	si, 32
+	loop	loop_compare
+
+error:
+	jmp	$			;halt! no kernel file found!
+
+found_file:				;ds:si points to root dir entry
+	xor	ax, ax
+	mov	gs, ax
+	mov	ax, BOOT_STAGE2_SEG
+	mov	es, ax
+
+	mov	ax, [ds:si+26]
+	mov	bx, BOOT_FAT_SEG
+	mov	ds, bx			;ds points to beginning of FAT
+	xor	di, di
+
+readstage2_loop:
+	cmp	ax, 0xff7
+	jg	readstage2_done
+	inc	di
+	push	ax
+	call	getCHSfromCluster
+	mov	ax, 0x0201
+	mov	dl, [gs:BOOT_DRIVE]
+	xor	bx, bx
+	int	0x13
+	mov	bx, es
+	add	bx, 0x0020
+	mov	es, bx
+	pop	ax			;current logical cluster #
+
+	mov	cx, ax			;cx=logical cluster
+	mov	dx, 3
+	mul	dx
+	shr	ax, 1			;ax=logical cluster * 3 / 2
+	mov	si, ax
+	test	cl, 1			;is bit0 set?
+	jnz	odd_cluster
+even_cluster:
+	lodsw
+	and	ax, 0x0fff
+	jmp	got_cluster
+odd_cluster:
+	lodsw
+	shr	ax, 4
+got_cluster:
+	jmp	readstage2_loop
+
+readstage2_done:
+
+	jmp	0:BOOT_STAGE2_ADD
+
+;------------------------------------------------------
+getCHSfromCluster:
+	;input: ax=lba of sector on floppy (0-2879)
+	add	ax, 31			;convert logical cluster# to lba#
+	xor	dx, dx			;lba->chs
+	mov	bx, 18
+	div	bx
+	inc	dx
+	mov	cl, dl			;sector# (1-18)
+	xor	dx, dx
+	mov	bx, 2
+	div	bx
+	mov	ch, al			;cylinder# (0-79)
+	mov	dh, dl			;head# (0-1)
+	ret
+
+
+;-------------------------------------------------------
+gdtr:
+	dw	gdt_end-gdt-1
+	dd	gdt
+gdt:
+	dd	0
+	dd	0
+
+KERNEL_DATA equ $-gdt
+	db	0xff		;segment 16 = 4gb data
+	db	0xff
+	db	0x00
+	db	0x00
+	db	0x00
+	db	0x92
+	db	0xcf		;cf
+	db	0x00
+
+gdt_end:
+
+
+
+stage2:	db	"STAGE2  BIN"
+
+times 510-($-$$)	db 0
+
+db	0x55, 0xaa
+
@@ -0,0 +1,971 @@
+
+%include "bootdef.inc"
+
+%define VESA_MODEINFO_SEG 0x0120
+%define VESA_MODELIST_SEG 0x0140
+%define GOOD_MODELIST_SEG 0x0160
+
+[bits 16]
+
+org BOOT_STAGE2_ADD
+
+
+;k now read root directory
+	mov	bx, BOOT_ROOT_SEG
+	mov	ds, bx
+	xor	si, si			;k now ds:si points to beginning of root directory
+	mov	es, si
+	mov	cx, 224			;max root entries
+loop_compare:
+	mov	di, kernel
+	push	cx
+	push	si			;save pointer to root dir entry
+	mov	cx, 11
+loop_name:
+	cmpsb
+	loopz	loop_name
+	jnz	goon			;cx didn't get to zero, bad file
+	pop	si
+	pop	cx
+	jmp	found_file		;good file, ds:si points to start of root directory entry
+goon:
+	pop	si
+	add	si, 32
+	pop	cx
+	loop	loop_compare
+
+error:
+	jmp	$			;halt! no kernel file found!
+
+found_file:				;ds:si points to root dir entry of kernel file
+	xor	ax, ax
+	mov	gs, ax
+	mov	ax, [ds:si+26]
+	mov	bx, BOOT_FAT_SEG
+	mov	ds, bx			;ds points to beginning of FAT
+	mov	edi, BOOT_KERNEL_ADD
+
+readkernel_loop:
+	cmp	ax, 0xff7
+	jg	readkernel_done
+	push	ax
+	call	getCHSfromCluster
+	mov	ax, 0x0201
+	mov	dl, [gs:BOOT_DRIVE]
+	mov	bx, BOOT_KERNEL_SEG
+	mov	es, bx
+	xor	bx, bx
+	int	0x13
+	mov	cx, 256
+	xor	ax, ax
+	mov	es, ax
+	mov	esi, BOOT_KERNEL_SEG*16
+copykernel_loop:
+	mov	ax, [es:esi]
+	mov	[es:edi], ax
+	inc	esi
+	inc	esi
+	inc	edi
+	inc	edi
+	loop	copykernel_loop
+
+	pop	ax			;current logical cluster #
+
+	mov	cx, ax			;cx=logical cluster
+	mov	dx, 3
+	mul	dx
+	shr	ax, 1			;ax=logical cluster * 3 / 2
+	mov	si, ax
+	test	cl, 1			;is bit0 set?
+	jnz	odd_cluster
+even_cluster:
+	lodsw
+	and	ax, 0x0fff
+	jmp	got_cluster
+odd_cluster:
+	lodsw
+	shr	ax, 4
+got_cluster:
+	jmp	readkernel_loop
+
+;------------------------------------------------------
+readkernel_done:			;-------------put more real mode init stuff here!
+					;----ask to load RD from floppy
+	mov	ax, 0xb800
+	mov	es, ax
+	xor	ax, ax
+	mov	ds, ax
+	xor	di, di
+	mov	cx, 2000
+	mov	ax, 0x0700
+cls_loop:
+	stosw
+	loop	cls_loop
+
+	mov	dx, 0x3d4		;move cursor off screen...
+	mov	al, 0x0e
+	out	dx, al
+	inc	dx
+	mov	al, 0xff
+	out	dx, al
+	dec	dx
+	mov	al, 0x0f
+	out	dx, al
+	inc	dx
+	out	dx, al
+
+	xor	di, di
+	mov	si, txt_welcome
+	mov	ah, 0x1f
+	call	puts
+
+	mov	di, 160
+	mov	si, txt_rd1
+	mov	ah, 7
+	call	puts
+
+	mov	si, txt_rd2
+	mov	di, 160*2
+	call	puts
+
+	mov	di, 160*3
+	mov	si, txt_input
+	call	puts
+
+get_rd:
+	xor	ax, ax
+	int	0x16
+	cmp	al, '1'
+	jz	got_rd
+	cmp	al, '2'
+	jnz	get_rd
+got_rd:	
+	stosb
+	sub	al, '1'
+	push	ds
+	mov	bx, BOOT_DATA_SEG		;segment for data to send kernel
+	mov	ds, bx
+	mov	[ds:BOOT_HASRD], al
+	pop	ds				;ds=0
+	cmp	al, 0				;dont load rd
+	jnz	yes_rd
+	jmp	no_rd
+yes_rd:
+	mov	cx, 80
+	mov	edi, 0xb8000+160*4
+filler_loop:                                    ;draw a red bar
+	mov	word [ds:edi], 0x0400+177
+	inc	edi
+	inc	edi
+	loop	filler_loop
+
+	mov	cx, 80				;80 cylinders to read
+	xor	si, si                          ;start at cylinder 0
+	mov	edi, BOOT_RD_ADD		;ram disk address
+read_cylinder:
+	push	cx
+	
+	mov	bx, 0x0100			;read sectors from head 0
+	mov	es, bx
+	xor	bx, bx                          ;es:bx = data buffer for read
+	mov	ax, 0x0212			;ah = int 0x13 function 2, al = number of sectors to read
+	mov	cx, si                          ;what cyl. we are on is now in cx
+	mov	ch, cl				;ch = cyl. number
+	mov	cl, 1                           ;cl = sector number 1-63
+	xor	dx, dx				;dh = head number
+	mov	dl, [gs:BOOT_DRIVE]             ;dl = drive number
+	int	0x13
+
+	mov	bx, 0x0100			;now read sectors from head 1
+	mov	es, bx
+	mov	bx, 9216                        ;es:bx = data buffer for read
+	mov	ax, 0x0212			;ah = int 0x13 function 2, al = number of sectors to read
+	mov	cx, si                          ;what cyl. we are on is now in cx
+	mov	ch, cl				;ch = cyl. number
+	mov	cl, 1                           ;cl = sector number 1-63
+	mov	dh, 1				;dh = head number
+	mov	dl, [gs:BOOT_DRIVE]             ;dl = drive number
+	int	0x13
+
+	mov	ebx, 0xb8000
+	add	bx, si
+	shl	bl, 1
+	mov	word [ds:ebx+160*4], 0x0200+219
+
+	push	si
+	mov	esi, 0x1000
+	mov	cx, 0x2400
+copydisk_loop:
+	mov	ax, [ds:esi]
+	inc	esi
+	inc	esi
+	mov	[ds:edi], ax
+	inc	edi
+	inc	edi
+	loop	copydisk_loop
+
+	pop	si				;what cylinder# we are on...
+	inc	si
+	pop	cx
+	loop	read_cylinder
+
+;------------------------------------------------------
+no_rd:
+	mov	ax, BOOT_DATA_SEG
+	mov	es, ax
+	mov	di, BOOT_MEMMAP			;store memmap info in es:di for kernel
+	xor	edx, edx
+	mov	ax, 0x0100
+	mov	ds, ax
+	xor	ebx, ebx
+getmemmap_loop:
+	push	es
+	push	di
+	push	edx
+	mov	ax, 0x0100			;get memory map
+	mov	es, ax
+	xor	di, di
+	mov	eax, 0x0000E820
+	mov	ecx, 0x00000014
+	;mov	ebx, 0x00000000
+	mov	edx, 0x534D4150			;'SMAP'
+	int	0x15
+	jc	getmemmap_carry
+	cmp	eax, 0x534D4150			;eax should be 'SMAP' on return...
+	jnz	getmemmap_error
+	cmp	ebx, 0
+	jz	getmemmap_done
+
+	pop	edx				;now, copy memmap entry to es:di on the stack
+	pop	di
+	pop	es
+	xor	si, si
+	mov	cx, 20
+getmemmap_copymem_loop:
+	lodsb
+	stosb
+	loop	getmemmap_copymem_loop
+	inc	edx
+	jmp	getmemmap_loop
+
+getmemmap_error:
+	mov	ax, 0xb800
+	mov	es, ax
+	mov	di, 160*24
+	xor	ax, ax
+	mov	ds, ax
+	mov	si, txt_memerror
+	mov	ah, 0x04
+	call	puts
+	hlt
+	jmp	$
+
+getmemmap_carry:
+	dec	edx
+getmemmap_done:
+	pop	edx
+	pop	di
+	pop	es
+
+	xor	si, si
+	mov	cx, 20
+getmemmap_done_copymem_loop:
+	lodsb
+	stosb
+	loop	getmemmap_done_copymem_loop
+	inc	edx
+
+	mov	di, BOOT_MEMENTRIES
+	mov	[es:di], edx			;save # of memmap entries for kernel
+
+						;on to vesa info...
+	xor	ax, ax
+	mov	gs, ax
+	mov	ds, ax
+	mov	ax, 0xb800
+	mov	es, ax
+	mov	di, 160
+	mov	cx, 2000-80
+	mov	ax, 0x0700
+cls_vesa_loop:
+	stosw
+	loop	cls_vesa_loop
+	mov	si, txt_vesa
+	mov	di, 160*1
+	mov	ah, 7
+	call	puts
+
+	push	di
+	mov	ax, 0x0100
+	mov	es, ax
+	xor	di, di
+	mov	dword [es:di], "2EBV"
+	mov	ax, 0x4F00
+
+	int	0x10
+	pop	di
+	cmp	ax, 0x004F
+	jz	vesa_good
+	mov	si, txt_novesa
+	mov	ax, 0xb800
+	mov	es, ax
+	mov	ah, 7
+	call	puts
+	mov	ax, BOOT_DATA_SEG
+	mov	ds, ax
+	mov	word [ds:BOOT_VESA], 0
+	jmp	vesa_done
+vesa_good:
+	mov	ax, 0xb800
+	mov	es, ax
+	mov	ax, 0x0100
+	mov	ds, ax
+	xor	si, si
+	mov	bx, [4]
+	mov	al, bh
+	call	puthex
+	mov	al, '.'
+	stosb
+	mov	al, 7
+	stosb
+	mov	al, bl
+	call	puthex
+	add	di, 4
+	cmp	bh, 2
+	jge	vesa_good2
+	xor	ax, ax
+	mov	ds, ax
+	mov	si, txt_vesaold
+	mov	ah, 7
+	call	puts
+	mov	ax, BOOT_DATA_SEG
+	mov	ds, ax
+	mov	word [ds:BOOT_VESA], 0
+	jmp	vesa_done
+vesa_good2:
+	mov	ebx, [6]			;something like 0x00000E60
+	mov	edx, [14]
+	mov	si, bx
+	shr	ebx, 16
+	mov	ds, bx				;ds:si points to null-terminated OEM identification string
+	mov	ah, 2
+	push	si
+	call	puts
+	pop	si
+	mov	ax, BOOT_DATA_SEG
+	mov	es, ax
+	mov	di, BOOT_VESA_OEM
+vesa_copyoem:
+	lodsb
+	stosb
+	or	al, al
+	jnz	vesa_copyoem
+	mov	ax, 0x0100
+	mov	ds, ax
+	xor	si, si
+	mov	di, BOOT_VESA_VBE
+	mov	cx, 512
+vesa_copyvbe:
+	lodsb
+	stosb
+	loop	vesa_copyvbe
+
+	mov	si, dx
+	shr	edx, 16
+	mov	ds, dx				;ds:si points to video mode list
+	mov	ax, VESA_MODELIST_SEG
+	mov	es, ax
+	xor	di, di
+vesa_copymodes:
+	lodsw
+	stosw
+	cmp	ax, 0xffff
+	jnz	vesa_copymodes
+
+	mov	ax, GOOD_MODELIST_SEG
+	mov	es, ax
+	xor	di, di
+	mov	cx, 256
+	mov	ax, 0xffff
+clear_good_mode_list_loop:
+	stosw
+	loop	clear_good_mode_list_loop
+
+	mov	ax, VESA_MODELIST_SEG
+	mov	ds, ax
+	xor	si, si				;ds:si points to video mode list where we can edit it :)
+	mov	ax, GOOD_MODELIST_SEG
+	mov	es, ax
+	xor	di, di
+	xor	dx, dx				;dx=what good mode # we are on
+vesa_readmodeinfo_loop:
+	lodsw
+	cmp	ax, 0xffff
+	jz	vesa_endofmodes
+	push	ax				;save mode#
+	call	checkmode
+	cmp	ax, 0
+	jz	vesa_readmodeinfo_good
+	pop	ax
+	jmp	vesa_readmodeinfo_loop
+vesa_readmodeinfo_good:
+	pop	ax				;restore mode#
+	stosw
+	call	vesa_showmodeinfo
+	inc	dx
+	jmp	vesa_readmodeinfo_loop
+
+vesa_endofmodes:				;here we have a list of good modes at GOOD_MODELIST_SEG:0
+	xor	ax, ax
+	mov	ds, ax
+	mov	si, txt_consolemode
+	mov	ax, 0xb800
+	mov	es, ax
+	mov	di, 160*2
+	mov	ah, 7
+	call	puts
+	mov	di, 160*3
+	mov	cx, dx
+	mov	al, 'b'
+vesa_displaylabels:
+	stosb
+	push	ax
+	mov	al, 7
+	stosb
+	mov	al, '.'
+	stosb
+	mov	al, 7
+	stosb
+	pop	ax
+	inc	al
+	add	di, 160-4
+	loop	vesa_displaylabels		;done drawing screen of VESA choices, now ask for one
+						;valid options are 'a' through (al-1)
+	mov	bl, al
+	xor	ax, ax
+	mov	ds, ax
+	mov	di, 160*24
+	mov	si, txt_input
+	mov	ah, 14
+	call	puts
+vesa_getchoice:
+	xor	ax, ax
+	int	0x16
+	cmp	al, 'a'
+	jl	vesa_getchoice
+	cmp	al, bl
+	jge	vesa_getchoice
+	stosb
+	push	ax
+	mov	al, 14
+	stosb
+	pop	ax
+	xor	ah, ah
+	sub	ax, 'a'
+	cmp	ax, 0
+	jz	vesa_consolemode_only
+	mov	cx, ax				;cx holds good mode# (1=first good vesa mode)
+	dec	cx
+	mov	ax, GOOD_MODELIST_SEG
+	mov	ds, ax
+	shl	cx, 1
+	mov	si, cx				;ds:si points to word containing selected mode#
+	lodsw
+	mov	cx, ax
+	mov	dx, ax				;cx and dx hold mode#
+
+	mov	ax, VESA_MODEINFO_SEG
+	mov	es, ax
+	xor	di, di
+	mov	ax, 0x4F01
+	int	0x10
+	call	checkvesa
+
+	mov	ax, VESA_MODEINFO_SEG
+	mov	ds, ax
+	xor	si, si
+	mov	ax, BOOT_DATA_SEG
+	mov	es, ax
+	mov	di, BOOT_VESA_INFO
+	mov	cx, 256
+vesa_copymodeinfo_loop:
+	lodsb
+	stosb
+	loop	vesa_copymodeinfo_loop		;store ModeInfoBlock for current
+
+	mov	[es:BOOT_VESA], dx		;store mode# for kernel
+
+;	mov	ax, 0xb800
+;	mov	es, ax
+;	xor	di, di
+;	mov	al, dh
+;	call	puthex2
+;	mov	al, dl
+;	call	puthex2
+
+	mov	bx, dx
+	or	bx, 0x4000			;set "use LFB" bit of mode#
+	mov	ax, 0x4F02
+	int	0x10				;switch to graphics mode!!!
+	call	checkvesa
+
+	jmp	vesa_done
+
+vesa_consolemode_only:
+	mov	ax, BOOT_DATA_SEG
+	mov	es, ax
+	mov	word [es:BOOT_VESA], 0
+
+	jmp	vesa_done
+
+;------------------------------------------------------
+vesa_showmodeinfo:
+	pusha
+	push	es
+	push	ds
+	mov	ax, VESA_MODEINFO_SEG
+	mov	ds, ax
+	xor	si, si
+	mov	ax, 0xb800
+	mov	es, ax
+
+	mov	cx, dx
+
+	mov	ax, 160
+	mul	dx				;ax=160*mod#
+	add	ax, 160*3+6			;offset first line of modes and room on left for label
+	mov	di, ax
+
+	mov	ax, [ds:18]
+	call	console_putDec
+	add	di, 10
+	mov	al, 'x'
+	call	console_putChar
+	inc	di
+	inc	di
+	mov	ax, [ds:20]
+	call	console_putDec
+	add	di, 10
+	mov	al, 'x'
+	call	console_putChar
+	inc	di
+	inc	di
+	xor	ah, ah
+	mov	al, [ds:25]
+	call	console_putDec
+	add	di, 8
+	mov	al, [ds:0]
+	test	al, 0x80
+	jz	vesa_showmodeinfo_done
+	mov	al, 'L'
+	call	console_putChar
+	mov	al, 'F'
+	call	console_putChar
+	mov	al, 'B'
+	call	console_putChar
+	inc	di
+	inc	di
+	mov	ebx, [ds:40]
+	mov	eax, ebx
+	shr	eax, 24
+	call	puthex2
+	mov	eax, ebx
+	shr	eax, 16
+	call	puthex2
+	mov	al, bh
+	call	puthex2
+	mov	al, bl
+	call	puthex2
+vesa_showmodeinfo_done:
+	pop	ds
+	pop	es
+	popa
+	ret
+
+;------------------------------------------------------
+checkmode:
+	push	bx
+	push	cx
+	push	dx
+	push	es
+	push	ds
+	push	di
+	push	si
+	mov	cx, ax				;cx=modenumber
+	mov	ax, VESA_MODEINFO_SEG
+	mov	es, ax
+	xor	di, di
+	mov	ax, 0x4F01
+	int	0x10
+	call	checkvesa
+	xor	di, di				;es:di -> ModeInfoBlock struc
+	mov	ax, [es:di]			;ModeAttributes
+	test	al, 1				;mode supported
+	jz	vesa_modenogood
+	test	al, 8				;color mode
+	jz	vesa_modenogood
+	test	al, 0x10			;graphics mode
+	jz	vesa_modenogood
+	test	al, 0x80			;Linear Frame Buffer supported
+	jz	vesa_modenogood
+	mov	al, [es:di+25]			;BitsPerPixel
+	cmp	al, 16
+	jz	vesa_bppok
+	cmp	al, 24
+	jz	vesa_bppok
+	cmp	al, 32
+	jnz	vesa_modenogood
+vesa_bppok:
+	mov	ax, [es:di+18]			;XResolution
+	mov	bx, [es:di+20]			;YResolution
+	cmp	ax, 640				;640x480
+	jnz	res_goon1
+	cmp	bx, 480
+	jnz	vesa_modenogood
+	jmp	vesa_modegood
+res_goon1:
+	cmp	ax, 800
+	jnz	res_goon2
+	cmp	bx, 600
+	jnz	vesa_modenogood
+	jmp	vesa_modegood
+res_goon2:
+	cmp	ax, 1024
+	jnz	res_goon3
+	cmp	bx, 768
+	jnz	vesa_modenogood
+	jmp	vesa_modegood
+res_goon3:
+	cmp	ax, 1280
+	jnz	res_goon4
+	cmp	bx, 1024
+	jz	vesa_modegood
+	cmp	bx, 960
+	jz	vesa_modegood
+	jmp	vesa_modenogood
+res_goon4:
+	cmp	ax, 1600
+	jnz	vesa_modenogood
+	cmp	bx, 1200
+	jnz	vesa_modenogood
+vesa_modegood:
+	pop	si
+	pop	di
+	pop	ds
+	pop	es
+	pop	dx
+	pop	cx
+	pop	bx
+	xor	ax, ax
+	ret
+vesa_modenogood:
+	pop	si
+	pop	di
+	pop	ds
+	pop	es
+	pop	dx
+	pop	cx
+	pop	bx
+	mov	ax, 0xffff
+	ret
+
+;------------------------------------------------------
+vesa_done:
+
+;	xor	ax, ax				;wait for keypress...
+;	int	0x16
+
+	jmp	go_pm
+
+;------------------------------------------------------
+puts:
+	lodsb
+	or	al, al
+	jz	puts_done
+	stosb
+	mov	al, ah
+	stosb
+	jmp	puts
+puts_done:
+	ret
+
+;------------------------------------------------------
+checkvesa:
+	cmp	ax, 0x004F
+	jnz	vesaerror
+	ret
+vesaerror:
+	mov	ax, 0xb800
+	mov	es, ax
+	xor	ax, ax
+	mov	ds, ax
+	mov	si, txt_vesaerror
+	mov	di, 160*24
+	mov	ah, 4
+	call	puts
+	cli
+	hlt
+
+;-------Function console_putDec
+;input:
+; AX = number to display
+;output:
+; number written in decimal to es:di
+console_putDec:
+	pusha
+	xor	dx, dx
+	xor	bh, bh			;no characters written yet
+	mov	cx, 10000
+	div	cx			;ax=quotiont, dx=remainder
+	add	ax, '0'
+	cmp	ax, '0'
+	je	.goon1
+	call	console_putChar
+	mov	bh, 1
+
+.goon1:
+	mov	ax, dx			;load remainder to ax
+	xor	dx, dx
+	mov	cx, 1000
+	div	cx			;ax=quotiont, dx=remainder
+	add	ax, '0'
+	cmp	ax, '0'
+	je	.goon11
+	call	console_putChar
+	mov	bh, 1
+	jmp	.goon2
+.goon11:
+	cmp	bh, 0
+	je	.goon2
+	call	console_putChar
+
+.goon2:
+	mov	ax, dx			;load remainder to ax
+	xor	dx, dx
+	mov	cx, 100
+	div	cx			;ax=quotiont, dx=remainder
+	add	ax, '0'
+	cmp	ax, '0'
+	je	.goon21
+	call	console_putChar
+	mov	bh, 1
+	jmp	.goon3
+.goon21:
+	cmp	bh, 0
+	je	.goon3
+	call	console_putChar
+
+.goon3:
+	mov	ax, dx			;load remainder to ax
+	xor	dx, dx
+	mov	cx, 10
+	div	cx			;ax=quotiont, dx=remainder
+	add	ax, '0'
+	cmp	ax, '0'
+	je	.goon31
+	call	console_putChar
+	mov	bh, 1
+	jmp	.goon4
+.goon31:
+	cmp	bh, 0
+	je	.goon4
+	call	console_putChar
+.goon4:					;here dx contains last remainder
+	mov	ax, dx
+	add	ax, '0'
+	call	console_putChar
+
+	popa
+	ret
+
+;------------------------------------------------------
+console_putChar:
+	stosb
+	mov	al, 7
+	stosb
+	ret
+
+;------------------------------------------------------
+puthex:
+	;es:di points to video memory
+	;al holds hex value
+
+	push	ax
+	mov	ah, al
+	shr	ax, 4
+	and	al, 0x0F
+	add	al, '0'
+	cmp	al, '9'
+	jle	puthex_goon1
+	add	al, 'A'-'9'-1
+puthex_goon1:
+	cmp	al, '0'
+	jz	puthex_skipzero
+	stosb
+	mov	al, 7
+	stosb
+puthex_skipzero:
+	pop	ax
+	push	ax
+	and	al, 0x0F
+	add	al, '0'
+	cmp	al, '9'
+	jle	puthex_goon2
+	add	al, 'A'-'9'-1
+puthex_goon2:
+	stosb
+	mov	al, 7
+	stosb
+	pop	ax
+	ret
+
+;------------------------------------------------------
+puthex2:
+	;es:di points to video memory, always displays 2 characters!
+	;al holds hex value
+
+	push	ax
+	mov	ah, al
+	shr	ax, 4
+	and	al, 0x0F
+	add	al, '0'
+	cmp	al, '9'
+	jle	puthex2_goon1
+	add	al, 'A'-'9'-1
+puthex2_goon1:
+	stosb
+	mov	al, 7
+	stosb
+	pop	ax
+	push	ax
+	and	al, 0x0F
+	add	al, '0'
+	cmp	al, '9'
+	jle	puthex2_goon2
+	add	al, 'A'-'9'-1
+puthex2_goon2:
+	stosb
+	mov	al, 7
+	stosb
+	pop	ax
+	ret
+
+;------------------------------------------------------
+txt_welcome: db	"                             Welcome to HOS v", VERSION, "!                              ", 0
+txt_rd1: db	"1. Do not load an initial ram disk", 0
+txt_rd2: db	"2. Load initial ram disk from floppy", 0
+txt_input: db	"Enter your selection: ", 0
+txt_vesa: db	"VESA version: ", 0
+txt_vesaerror: db "VESA function call error! Halting system!", 0
+txt_novesa: db	"VESA not found. Starting in console mode...", 0
+txt_vesaold: db	"VESA version 2.0 required. Starting in console mode...", 0
+txt_consolemode: db "a. Console mode only.", 0
+txt_memerror: db "Extended Memory Map information unavailable! Halting system...", 0
+
+;------------------------------------------------------
+getCHSfromCluster:
+	;input: ax=lba of sector on floppy (0-2879)
+	add	ax, 31			;convert logical cluster# to lba#
+	xor	dx, dx			;lba->chs
+	mov	bx, 18
+	div	bx
+	inc	dx
+	mov	cl, dl			;sector# (1-18)
+	xor	dx, dx
+	mov	bx, 2
+	div	bx
+	mov	ch, al			;cylinder# (0-79)
+	mov	dh, dl			;head# (0-1)
+	ret
+
+
+;-------------------------------------------------------
+gdtr:
+	dw	gdt_end-gdt-1
+	dd	gdt
+gdt:
+	dd	0
+	dd	0
+
+KERNEL_CODE equ $-gdt
+	db	0xff		;limit	7:0
+	db	0xff		;limit	15:8
+	db	0x00		;base	7:0
+	db	0x00		;base	15:8
+	db	0x00		;base	23:16
+	db	0x9a		;access
+	db	0xcf		;flags / limit 19:16
+	db	0x00		;base	31:24
+
+KERNEL_DATA equ $-gdt
+	db	0xff		;segment 16 = 4gb data
+	db	0xff
+	db	0x00
+	db	0x00
+	db	0x00
+	db	0x92
+	db	0xcf
+	db	0x00
+
+gdt_end:
+
+
+;-------------------------------------------------------
+gdtr32:
+	dw	gdt_end32-gdt32-1
+	dd	gdt32
+gdt32:
+	dd	0
+	dd	0
+
+	;a base of 0x4000_0000, when added to 0xC000_0000 will produce 0x0000_0000 physical before paging in effect
+KERNEL_CODE32 equ $-gdt32
+	db	0xff		;limit	7:0
+	db	0xff		;limit	15:8
+	db	0x00		;base	7:0
+	db	0x00		;base	15:8
+	db	0x00		;base	23:16
+	db	0x9a		;access
+	db	0xcf		;flags / limit 19:16
+	db	0x40		;base	31:24
+
+KERNEL_DATA32 equ $-gdt32
+	db	0xff		;segment 16 = 4gb data
+	db	0xff
+	db	0x00
+	db	0x00
+	db	0x00
+	db	0x92
+	db	0xcf
+	db	0x40
+
+gdt_end32:
+
+;------------------------------------------------------
+go_pm:
+	xor	ax, ax
+	mov	ds, ax
+	lgdt	[gdtr]
+	cli
+	mov	eax, cr0
+	inc	eax
+	mov	cr0, eax
+
+	jmp	KERNEL_CODE:pmode
+
+bits 32
+pmode:
+	lgdt	[gdtr32]
+	jmp	KERNEL_CODE32:pmode_offsetted+0xC0000000
+
+pmode_offsetted:
+	mov	ax, KERNEL_DATA32
+	mov	es, ax
+	mov	ds, ax
+	mov	fs, ax
+	mov	gs, ax
+	jmp	KERNEL_CODE:BOOT_KERNEL_ADD+0xC0000000
+
+kernel:	db	"KERNEL  BIN", 0
+
+
@@ -0,0 +1,258 @@
+const byte stdfont[] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xE0, 0xC0, 0x80, 
+	0x00, 0x08, 0x18, 0x38, 0x78, 0x38, 0x18, 0x08, 
+	0x00, 0x20, 0x70, 0xA8, 0x20, 0xA8, 0x70, 0x20, 
+	0x00, 0xA0, 0xA0, 0xA0, 0xA0, 0x00, 0xA0, 0xA0, 
+	0x00, 0x78, 0xA8, 0xA8, 0x78, 0x28, 0x28, 0x68, 
+	0x00, 0x78, 0x80, 0x70, 0x88, 0x70, 0x08, 0xF0, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xF8, 
+	0x00, 0x20, 0x70, 0xA8, 0x20, 0xA8, 0x70, 0xF8, 
+	0x00, 0x20, 0x70, 0xA8, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x20, 0x20, 0x20, 0x20, 0xA8, 0x70, 0x20, 
+	0x00, 0x00, 0x20, 0x10, 0xF8, 0x10, 0x20, 0x00, 
+	0x00, 0x00, 0x20, 0x40, 0xF8, 0x40, 0x20, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 
+	0x00, 0x60, 0x90, 0x60, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x20, 0x70, 0xF8, 0xF8, 0x00, 0x00, 
+	0x00, 0x00, 0xF8, 0xF8, 0x70, 0x20, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0x20, 0x20, 
+	0x00, 0x50, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x50, 0xF8, 0x50, 0x50, 0x50, 0xF8, 0x50, 
+	0x00, 0x20, 0x78, 0xA0, 0x70, 0x28, 0xF0, 0x20, 
+	0x00, 0x00, 0x08, 0x90, 0x20, 0x48, 0x80, 0x00, 
+	0x00, 0x20, 0x50, 0x50, 0x20, 0x58, 0x90, 0x68, 
+	0x00, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x20, 0x40, 0x40, 0x40, 0x40, 0x40, 0x20, 
+	0x00, 0x40, 0x20, 0x20, 0x20, 0x20, 0x20, 0x40, 
+	0x00, 0x00, 0xA8, 0x70, 0xF8, 0x70, 0xA8, 0x00, 
+	0x00, 0x00, 0x20, 0x20, 0xF8, 0x20, 0x20, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x40, 
+	0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 
+	0x00, 0x00, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 
+	0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 
+	0x00, 0x20, 0x60, 0xA0, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x70, 0x88, 0x08, 0x10, 0x20, 0x40, 0xF8, 
+	0x00, 0x70, 0x88, 0x08, 0x10, 0x08, 0x88, 0x70, 
+	0x00, 0x30, 0x50, 0x90, 0x90, 0xF8, 0x10, 0x10, 
+	0x00, 0xF8, 0x80, 0x80, 0xF8, 0x08, 0x88, 0x70, 
+	0x00, 0x38, 0x40, 0x80, 0xF0, 0x88, 0x88, 0x70, 
+	0x00, 0xF8, 0x08, 0x10, 0x20, 0x40, 0x40, 0x40, 
+	0x00, 0x70, 0x88, 0x88, 0x70, 0x88, 0x88, 0x70, 
+	0x00, 0x70, 0x88, 0x88, 0x78, 0x08, 0x10, 0x60, 
+	0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 
+	0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x40, 
+	0x00, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 
+	0x00, 0x00, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x00, 
+	0x00, 0x80, 0x40, 0x20, 0x10, 0x20, 0x40, 0x80, 
+	0x00, 0x70, 0x88, 0x08, 0x10, 0x20, 0x00, 0x20, 
+	0x00, 0x70, 0x88, 0x88, 0xB8, 0xB0, 0x80, 0x78, 
+	0x00, 0x70, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
+	0x00, 0xF0, 0x88, 0x88, 0xF0, 0x88, 0x88, 0xF0, 
+	0x00, 0x70, 0x88, 0x80, 0x80, 0x80, 0x88, 0x70, 
+	0x00, 0xF0, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF0, 
+	0x00, 0xF8, 0x80, 0x80, 0xF0, 0x80, 0x80, 0xF8, 
+	0x00, 0xF8, 0x80, 0x80, 0xF0, 0x80, 0x80, 0x80, 
+	0x00, 0x70, 0x88, 0x80, 0xB8, 0x88, 0x88, 0x70, 
+	0x00, 0x88, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
+	0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x90, 0x60, 
+	0x00, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88, 
+	0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xF8, 
+	0x00, 0x88, 0xD8, 0xA8, 0x88, 0x88, 0x88, 0x88, 
+	0x00, 0x88, 0xC8, 0xE8, 0xB8, 0x98, 0x88, 0x88, 
+	0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 
+	0x00, 0xF0, 0x88, 0x88, 0xF0, 0x80, 0x80, 0x80, 
+	0x00, 0x70, 0x88, 0x88, 0x88, 0xA8, 0x98, 0x70, 
+	0x00, 0xF0, 0x88, 0x88, 0xF0, 0xA0, 0x90, 0x88, 
+	0x00, 0x70, 0x88, 0x80, 0x70, 0x08, 0x88, 0x70, 
+	0x00, 0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 
+	0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0x50, 0x20, 
+	0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0xA8, 0x50, 
+	0x00, 0x88, 0x50, 0x20, 0x20, 0x50, 0x88, 0x88, 
+	0x00, 0x88, 0x88, 0x50, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0xF8, 0x08, 0x10, 0x20, 0x40, 0x80, 0xF8, 
+	0x00, 0x70, 0x40, 0x40, 0x40, 0x40, 0x40, 0x70, 
+	0x00, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x08, 0x00, 
+	0x00, 0xE0, 0x20, 0x20, 0x20, 0x20, 0x20, 0xE0, 
+	0x00, 0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 
+	0x00, 0x60, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x70, 0x08, 0x78, 0x88, 0x78, 
+	0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0x88, 0xF0, 
+	0x00, 0x00, 0x00, 0x70, 0x88, 0x80, 0x88, 0x70, 
+	0x00, 0x08, 0x08, 0x78, 0x88, 0x88, 0x88, 0x78, 
+	0x00, 0x00, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x78, 
+	0x00, 0x30, 0x40, 0x40, 0xE0, 0x40, 0x40, 0x40, 
+	0x00, 0x00, 0x00, 0x78, 0x88, 0x78, 0x08, 0x70, 
+	0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0x88, 0x88, 
+	0x00, 0x20, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x10, 0x00, 0x10, 0x10, 0x10, 0x90, 0x60, 
+	0x00, 0x80, 0x80, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 
+	0x00, 0xC0, 0x40, 0x40, 0x40, 0x40, 0x40, 0xE0, 
+	0x00, 0x00, 0x00, 0xD0, 0xA8, 0xA8, 0xA8, 0xA8, 
+	0x00, 0x00, 0x00, 0xF0, 0x88, 0x88, 0x88, 0x88, 
+	0x00, 0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x70, 
+	0x00, 0x00, 0x00, 0xF0, 0x88, 0xF0, 0x80, 0x80, 
+	0x00, 0x00, 0x00, 0x78, 0x88, 0x78, 0x08, 0x38, 
+	0x00, 0x00, 0x00, 0x70, 0x48, 0x40, 0x40, 0x40, 
+	0x00, 0x00, 0x00, 0x78, 0x80, 0x70, 0x08, 0xF0, 
+	0x00, 0x40, 0x40, 0xE0, 0x40, 0x40, 0x40, 0x20, 
+	0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0x88, 0x78, 
+	0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 
+	0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0xA8, 0x50, 
+	0x00, 0x00, 0x00, 0x88, 0x50, 0x20, 0x50, 0x88, 
+	0x00, 0x00, 0x00, 0x88, 0x88, 0x78, 0x08, 0xF0, 
+	0x00, 0x00, 0x00, 0xF8, 0x10, 0x20, 0x40, 0xF8, 
+	0x00, 0x30, 0x40, 0x40, 0x80, 0x40, 0x40, 0x30, 
+	0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0xC0, 0x20, 0x20, 0x10, 0x20, 0x20, 0xC0, 
+	0x00, 0x00, 0x68, 0x90, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x70, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
+	0x00, 0xF8, 0x88, 0x80, 0xF0, 0x88, 0x88, 0xF0, 
+	0x00, 0xF0, 0x88, 0x88, 0xF0, 0x88, 0x88, 0xF0, 
+	0x00, 0xF8, 0x48, 0x40, 0x40, 0x40, 0x40, 0xE0, 
+	0x00, 0xF0, 0x50, 0x50, 0x50, 0x50, 0x78, 0x88, 
+	0x00, 0xF8, 0x80, 0x80, 0xF0, 0x80, 0x80, 0xF8, 
+	0x00, 0xA8, 0xA8, 0x70, 0x20, 0x70, 0xA8, 0xA8, 
+	0x00, 0x70, 0x88, 0x08, 0x30, 0x08, 0x88, 0x70, 
+	0x00, 0x88, 0x98, 0xA8, 0xA8, 0xA8, 0xC8, 0x88, 
+	0x00, 0xA8, 0xC8, 0x98, 0xA8, 0xA8, 0xC8, 0x88, 
+	0x00, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88, 
+	0x00, 0xF8, 0x50, 0x50, 0x50, 0x50, 0x50, 0x90, 
+	0x00, 0x88, 0xD8, 0xA8, 0x88, 0x88, 0x88, 0x88, 
+	0x00, 0x88, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
+	0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 
+	0x00, 0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 
+	0x00, 0xF0, 0x88, 0x88, 0xF0, 0x80, 0x80, 0x80, 
+	0x00, 0x70, 0x88, 0x80, 0x80, 0x80, 0x88, 0x70, 
+	0x00, 0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 0x40, 0x80, 
+	0x00, 0x70, 0x20, 0xF8, 0xA8, 0xF8, 0x20, 0x70, 
+	0x00, 0x88, 0x88, 0x50, 0x20, 0x50, 0x88, 0x88, 
+	0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF8, 0x08, 
+	0x00, 0x88, 0x88, 0x88, 0xF8, 0x08, 0x08, 0x38, 
+	0x00, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 
+	0x00, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 0x08, 
+	0x00, 0xC0, 0x40, 0x40, 0x78, 0x48, 0x48, 0x78, 
+	0x00, 0x88, 0x88, 0xC8, 0xA8, 0xA8, 0xA8, 0xE8, 
+	0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0x88, 0xF0, 
+	0x00, 0xF0, 0x88, 0x08, 0x78, 0x08, 0x88, 0xF0, 
+	0x00, 0x90, 0xA8, 0xA8, 0xE8, 0xA8, 0xA8, 0x90, 
+	0x00, 0x78, 0x88, 0x88, 0x78, 0x28, 0x48, 0x88, 
+	0x00, 0x00, 0x70, 0x08, 0x78, 0x88, 0x88, 0x78, 
+	0x00, 0x00, 0xF8, 0x80, 0xF0, 0x88, 0x88, 0xF0, 
+	0x00, 0x00, 0xF0, 0x88, 0xF0, 0x88, 0x88, 0xF0, 
+	0x00, 0x00, 0xF8, 0x48, 0x48, 0x40, 0x40, 0xE0, 
+	0x00, 0x00, 0x78, 0x50, 0x50, 0x50, 0x70, 0x88, 
+	0x00, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x88, 0x70, 
+	0x00, 0x00, 0xA8, 0x70, 0x20, 0x70, 0xA8, 0xA8, 
+	0x00, 0x00, 0x00, 0xF0, 0x88, 0x30, 0x88, 0x70, 
+	0x00, 0x00, 0x88, 0x98, 0xA8, 0xC8, 0x88, 0x88, 
+	0x00, 0x50, 0x20, 0x88, 0x98, 0xA8, 0xC8, 0x88, 
+	0x00, 0x00, 0x88, 0x90, 0xA0, 0xE0, 0x90, 0x88, 
+	0x00, 0x00, 0xF8, 0x48, 0x48, 0x48, 0x48, 0xC8, 
+	0x00, 0x00, 0x88, 0xD8, 0xA8, 0x88, 0x88, 0x88, 
+	0x00, 0x00, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
+	0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x70, 
+	0x00, 0x00, 0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x70, 0x50, 0x70, 0x08, 0x78, 0x88, 0x78, 
+	0x00, 0x88, 0x00, 0x70, 0x08, 0x78, 0x88, 0x78, 
+	0x00, 0x88, 0x00, 0x70, 0x88, 0x88, 0x88, 0x70, 
+	0x00, 0x88, 0x00, 0x88, 0x88, 0x88, 0x88, 0x78, 
+	0x00, 0x90, 0x00, 0xF0, 0x80, 0xE0, 0x80, 0xF0, 
+	0x00, 0x00, 0x70, 0x48, 0x70, 0x48, 0x48, 0xF0, 
+	0x00, 0x88, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x88, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x78, 
+	0x00, 0x70, 0x50, 0x70, 0x88, 0xF8, 0x88, 0x88, 
+	0x00, 0x88, 0x70, 0x88, 0x88, 0xF8, 0x88, 0x88, 
+	0x00, 0x88, 0x70, 0x88, 0x88, 0x88, 0x88, 0x70, 
+	0x00, 0x88, 0x00, 0x88, 0x88, 0x88, 0x88, 0x78, 
+	0x00, 0x88, 0xF8, 0x80, 0xE0, 0x80, 0x80, 0xF8, 
+	0x00, 0x40, 0x20, 0x70, 0x88, 0xF8, 0x80, 0x78, 
+	0x00, 0x10, 0x20, 0x70, 0x88, 0xF8, 0x80, 0x78, 
+	0x00, 0x20, 0x50, 0x70, 0x88, 0xF8, 0x80, 0x78, 
+	0x00, 0x40, 0x20, 0x70, 0x08, 0x78, 0x88, 0x78, 
+	0x00, 0x20, 0x50, 0x00, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x20, 0x10, 0x88, 0x88, 0x88, 0x88, 0x78, 
+	0x00, 0x00, 0x00, 0x70, 0x80, 0x80, 0x70, 0x20, 
+	0x00, 0x70, 0x88, 0x40, 0xF0, 0x40, 0x40, 0xF8, 
+	0x00, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x88, 0x88, 0x88, 0xF0, 0x80, 0x80, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0xF0, 0x88, 0x88, 0xF0, 0x80, 0x80, 
+	0x00, 0x00, 0x70, 0x88, 0x80, 0x80, 0x88, 0x70,
+	0x00, 0x00, 0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 
+	0x00, 0x00, 0x88, 0x88, 0x50, 0x20, 0x40, 0x80, 
+	0x00, 0x00, 0x70, 0x20, 0xF8, 0xF8, 0x20, 0x70, 
+	0x00, 0x00, 0x88, 0x50, 0x20, 0x50, 0x88, 0x88, 
+	0x00, 0x00, 0x88, 0x88, 0x88, 0x88, 0xF8, 0x08, 
+	0x00, 0x00, 0x88, 0x88, 0x88, 0xF8, 0x08, 0x38, 
+	0x00, 0x00, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 
+	0x00, 0x00, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 0x08, 
+	0x00, 0x00, 0xC0, 0x40, 0x70, 0x48, 0x48, 0x70, 
+	0x00, 0x00, 0x88, 0x88, 0xC8, 0xA8, 0xA8, 0xE8, 
+	0x00, 0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0xF0, 
+	0x00, 0x00, 0x70, 0x88, 0x38, 0x08, 0x88, 0x70, 
+	0x00, 0x00, 0x90, 0xA8, 0xA8, 0xE8, 0xA8, 0x90, 
+	0x00, 0x00, 0x38, 0x48, 0x48, 0x38, 0x28, 0x48, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00	};
+
@@ -1,100 +0,0 @@
-#!/bin/bash -x
-
-BINUTILS_VERSION=${BINUTILS_VERSION:-"2.20"}
-GCC_VERSION=${GCC_VERSION:-"4.4.2"}
-TARGET=${TARGET:-"i586-elf"}
-PREFIX=${PREFIX:-"$HOME/local/$TARGET"}
-GNUFTP=ftp://ftp.gnu.org/gnu
-export PATH=$PREFIX/bin:$PATH
-
-mkdir -p build-binutils build-gcc
-
-if [ ! -f "binutils-$BINUTILS_VERSION.tar.bz2" ]; then
-    wget "$GNUFTP/binutils/binutils-$BINUTILS_VERSION.tar.bz2"
-    if [ $? != 0 ]; then
-        echo "Error downloading binutils"
-        exit 1
-    fi
-fi
-
-if [ ! -f "gcc-$GCC_VERSION.tar.bz2" ]; then
-    wget "$GNUFTP/gcc/gcc-$GCC_VERSION/gcc-$GCC_VERSION.tar.bz2"
-    if [ $? != 0 ]; then
-        echo "Error downloading gcc"
-        exit 1
-    fi
-fi
-
-if [ ! -d "binutils-$BINUTILS_VERSION" ]; then
-    tar xvjf "binutils-$BINUTILS_VERSION.tar.bz2"
-    if [ $? != 0 ]; then
-        echo "Error extracting binutils"
-        exit 1
-    fi
-fi
-
-if [ ! -d "gcc-$GCC_VERSION" ]; then
-    tar xvjf "gcc-$GCC_VERSION.tar.bz2"
-    if [ $? != 0 ]; then
-        echo "Error extracting gcc"
-        exit 1
-    fi
-fi
-
-
-# build binutils
-dum=`which $TARGET-ar`
-if [ $? != 0 ]; then
-    pushd build-binutils
-    ../binutils-$BINUTILS_VERSION/configure --target=$TARGET --prefix=$PREFIX --disable-nls
-    if [ $? != 0 ]; then
-        echo "Error configuring binutils"
-        exit 1
-    fi
-    make all
-    if [ $? != 0 ]; then
-        echo "Error building binutils"
-        exit 1
-    fi
-    make install
-    if [ $? != 0 ]; then
-        echo "Error installing binutils"
-        exit 1
-    fi
-    popd
-fi
-
-
-# build gcc
-dum=`which $TARGET-gcc`
-if [ $? != 0 ]; then
-    pushd build-gcc
-    ../gcc-$GCC_VERSION/configure --target=$TARGET --prefix=$PREFIX --disable-nls --enable-languages=c,c++ --without-headers
-    if [ $? != 0 ]; then
-        echo "Error configuring gcc"
-        exit 1
-    fi
-    make all-gcc
-    if [ $? != 0 ]; then
-        echo "Error building gcc"
-        exit 1
-    fi
-    make install-gcc
-    if [ $? != 0 ]; then
-        echo "Error installing gcc"
-        exit 1
-    fi
-    make all-target-libgcc
-    if [ $? != 0 ]; then
-        echo "Error building libgcc"
-        exit 1
-    fi
-    make install-target-libgcc
-    if [ $? != 0 ]; then
-        echo "Error installing libgcc"
-        exit 1
-    fi
-    popd
-fi
-
-exit 0
@@ -0,0 +1,91 @@
+// vfs.c
+// Author: Josh Holtrop
+// Created: 12/31/03
+// Modified: 01/04/04
+
+
+void	vfs_init()
+{
+	firstDiskDevice = malloc(sizeof(DiskDevice));
+	firstDiskDevice->type = VFS_DISK_FD;
+	firstDiskDevice->fileSystem = VFS_FS_FAT12;
+	firstDiskDevice->location = VFS_LOC_FD0;
+	firstDiskDevice->link = 0;
+	strcpy(firstDiskDevice->id, "fd0");
+	rootDevice = firstDiskDevice;
+	if (*(byte *)0xC0090000)			// the user chose to load an initial ram disk from the floppy
+	{
+		DiskDevice *rd = malloc(sizeof(DiskDevice));
+		firstDiskDevice->link = (dword)rd;
+		rd->type = VFS_DISK_RD;
+		rd->fileSystem = VFS_FS_FAT12;
+		rd->location = 0xC0200000;
+		rd->link = 0;
+		strcpy(rd->id, "rd0");
+		rootDevice = rd;
+	}
+}
+
+
+byte *vfs_readFile(char *fileName)
+{
+	DiskDevice *dd;
+	dword	fileStartPosition;
+	if (fileName[0] == '/')
+	{
+		dd = rootDevice;
+		fileStartPosition = 1;
+	}
+	else
+	{
+		if (strlen(fileName) < 5)	//not a long enough file name
+			return 0;
+		if (!((fileName[3] == ':') && (fileName[4] == '/')))	//if we aren't using the root directory, then there must be a 3 character device explicitly specified
+			return 0;					// followed by a colon and then a slash
+		char device[4];
+		memcpy(device, fileName, 3);	//copy the 3 digit device id to device
+		device[3] = 0;			//null-terminating character for device string
+		dd = vfs_getDiskDeviceByID(device);
+		if (!dd)			//the specified device was not found
+			return 0;
+		fileStartPosition = 5;
+	}
+	switch (dd->fileSystem)
+	{
+	case VFS_FS_FAT12:
+		return fat12_readFile(fileName+fileStartPosition, dd);
+	}
+	return 0;
+}
+
+
+byte *vfs_readSector(DiskDevice *dd, dword sector, byte *dest, dword sectors)
+{
+	byte	*origDest = dest;
+	switch (dd->type)
+	{
+	case VFS_DISK_RD:
+		for (; sectors > 0; sectors--, dest += 512, sector++)
+			rd_readSector(dd, sector, dest);
+		return origDest;
+	}
+	return 0;
+}
+
+
+DiskDevice *vfs_getDiskDeviceByID(char *id)
+{
+	DiskDevice *dd = firstDiskDevice;
+	for (;;)
+	{
+		if (strcmp(dd->id, id))
+			return dd;
+		dd = (DiskDevice *)dd->link;
+		if (!dd)
+			break;
+	}
+	return 0;
+}
+
+
+
@@ -0,0 +1,33 @@
+// vfs.h
+// Author: Josh Holtrop
+// Created: 12/31/03
+// Modified: 01/04/04
+
+
+#define	VFS_DISK_RD	1
+#define	VFS_DISK_FD	2
+#define	VFS_DISK_HD	3
+
+#define	VFS_FS_FAT12	1
+
+#define	VFS_LOC_FD0	1
+
+
+typedef struct	{
+	dword	type;
+	dword	fileSystem;
+	dword	location;
+	dword	link;
+	char	id[4];
+} __attribute__((packed)) DiskDevice;
+
+
+void	vfs_init();
+byte *vfs_readFile(char *fileName);
+byte *vfs_readSector(DiskDevice *dd, dword sector, byte *dest, dword sectors);
+DiskDevice *vfs_getDiskDeviceByID(char *id);
+
+DiskDevice *rootDevice = 0;
+DiskDevice *firstDiskDevice = 0;
+
+
@@ -0,0 +1,176 @@
+//video.c
+// 08/13/03 Josh Holtrop
+// Modified: 11/12/03
+
+
+//Initialized the video mode information block video_mode and allocated double-buffer memory for graphics display
+void	video_init()
+{
+	videoMode = *(word *)0xC0090002;
+
+        if (!videoMode)	//we are in console mode
+		return;
+
+	video_mode = *(ModeInfoBlock *) 0xC0090306;
+
+	switch(video_mode.BitsPerPixel)
+	{
+	case 16:
+		video_psetp = &video_psetp16;
+		break;
+	case 24:
+		video_psetp = &video_psetp24;
+		break;
+	case 32:
+		video_psetp = &video_psetp32;
+	}
+}
+
+//Renders a character using stdfont[] as a bitmask
+void	video_renderChar(int x, int y, int character, dword color)
+{
+	int charpos = (character & 0xFF) * 8;
+	int row;
+	int col;
+	for (row = 0; row < 8; row++)
+	{
+		for (col = 0; col < 5; col++)
+		{
+			if ((stdfont[charpos+row] >> (col+3)) & 0x01)
+				video_pset(x+(5-col), y+row, color);
+		}
+	}
+}
+
+//Draws a horizontal line
+void	video_horiz(int y, int x1, int x2, dword color)
+{
+	if (x1 > x2)
+	{
+		int tmp = x2;
+		x2 = x1;
+		x1 = tmp;		//x2 >= x1 now
+	}
+	if (x2 < 0)
+		return;
+	if (x1 > video_mode.XResolution)
+		return;
+	if (x1 < 0)
+		x1 = 0;
+	if (x2 > video_mode.XResolution)
+		x2 = video_mode.XResolution;
+	int pixel = y*video_mode.XResolution+x1;
+	for (; x1 <= x2; x1++)
+	{
+		video_psetp(pixel++, color);
+	}
+}
+
+//Draws a vertical line
+void	video_vert(int x, int y1, int y2, dword color)
+{
+	if (y1 > y2)
+	{
+		int tmp = y2;
+		y2 = y1;
+		y1 = tmp;		//y2 >= y1 now
+	}
+	if (y2 < 0)
+		return;
+	if (y1 > video_mode.YResolution)
+		return;
+	if (y1 < 0)
+		y1 = 0;
+	if (y2 > video_mode.YResolution)
+		y2 = video_mode.YResolution;
+	int pixel = y1*video_mode.XResolution+x;
+	for (; y1 <= y2; y1++)
+	{
+		video_psetp(pixel, color);
+		pixel+=video_mode.XResolution;
+	}
+}
+
+//Draws a rectangle
+void	video_rect(int x1, int y1, int x2, int y2, dword color)
+{
+	video_horiz(y1, x1, x2, color);
+	video_horiz(y2, x1, x2, color);
+	video_vert(x1, y1, y2, color);
+	video_vert(x2, y1, y2, color);
+}
+
+//Draws a filled rectangle
+void	video_rectf(int x1, int y1, int x2, int y2, dword color)
+{
+	if (y2 < y1)
+	{
+		int tmp = y2;
+		y2 = y1;
+		y1 = tmp;
+	}
+	for (; y1 <= y2; y1++)
+		video_horiz(y1, x1, x2, color);
+}
+
+//Draws a single pixel
+inline void video_pset(int x, int y, dword color)
+{
+	if ((x < 0) || (x > video_mode.XResolution) || (y < 0) || (y > video_mode.YResolution))
+		return;
+	video_psetp(y*video_mode.XResolution+x, color);
+}
+
+//Draws a pixel at the specified pixel position
+void	video_psetp16(int pixel, dword color)
+{
+	vid_ptr16[pixel] = ((color&0xFF)>>3) | ((((color>>8)&0xFF)>>2)<<5) | ((((color>>16)&0xFF)>>3)<<11);
+}
+
+//Draws a pixel at the specified pixel position
+void	video_psetp24(int pixel, dword color)
+{
+	vid_ptr24[pixel*3] = color & 0xFF;
+	vid_ptr24[pixel*3+1] = (color>>8) & 0xFF;
+	vid_ptr24[pixel*3+2] = (color>>16) & 0xFF;
+}
+
+//Draws a pixel at the specified pixel position
+void	video_psetp32(int pixel, dword color)
+{
+	vid_ptr32[pixel] = color;
+}
+
+//Dummy function to not draw anything if there is no graphical mode enabled
+void	video_psetpnull(int pixel, dword color) {}
+
+
+// This function draws a simple "console" window in graphical mode to display text
+void	video_drawConsole()
+{
+	video_rectf(9, 9, 490, 260, 0);
+	video_rect(8, 8, 491, 261, 0x00777777);
+	int x, y;
+	for (x = 0; x < 80; x++)
+	{
+		for (y = 0; y < 25; y++)
+		{
+			video_renderChar(x*6+10, y*10+10, console_memory[y*80+x], 0x00FFFFFF);
+		}
+	}
+}
+
+
+// This function draws a "console" character to the graphical video screen
+void	video_drawConsoleChar(dword position)
+{
+ 	int x = position % 80;
+ 	int y = position / 80;
+	video_renderChar(x*6+10, y*10+10, console_memory[y*80+x], 0x00FFFFFF);
+}
+
+
+
+
+
+
@@ -0,0 +1,72 @@
+//video.h
+// 08/18/03 Josh Holtrop
+// Modified: 12/28/03
+
+void	video_init();
+void	video_horiz(int y, int x1, int x2, dword color);
+void	video_vert(int x, int y1, int y2, dword color);
+void	video_rect(int x1, int y1, int x2, int y2, dword color);
+void	video_rectf(int x1, int y1, int x2, int y2, dword color);
+inline void video_pset(int x, int y, dword color);
+void	video_psetp16(int pixel, dword color);
+void	video_psetp24(int pixel, dword color);
+void	video_psetp32(int pixel, dword color);
+void	video_psetpnull(int pixel, dword color);
+void	video_renderChar(int x, int y, int character, dword color);
+void	video_drawConsole();
+void	video_drawConsoleChar(dword position);
+
+
+typedef struct{
+	word	ModeAttributes;
+	byte	WinAAttributes;
+	byte	WinBAttributes;
+	word	WinGranularity;
+	word	WinSize;
+	word	WinASegment;
+	word	WinBSegment;
+	dword	WinFuncPtr;
+	word	BytesPerScanLine;
+
+	word	XResolution;
+	word	YResolution;
+	byte	XCharSize;
+	byte	YCharSize;
+	byte	NumberOfPlanes;
+	byte	BitsPerPixel;
+	byte	NumberOfBanks;
+	byte	MemoryModel;
+	byte	BankSize;
+	byte	NumberOfImagePages;
+	byte	Reserved1;
+
+	byte	RedMaskSize;
+	byte	RedFieldPosition;
+	byte	GreenMaskSize;
+	byte	GreenFieldPosition;
+	byte	BlueMaskSize;
+	byte	BlueFieldPosition;
+	byte	RsvdMaskSize;
+	byte	RsvdFieldPosition;
+	byte	DirectColorModeInfo;
+
+	dword	PhysBasePtr;
+	dword	OffScreenMemOffset;
+	word	OffScreenMemSize;
+	byte	Reserved[206];
+} ModeInfoBlock;
+
+
+ModeInfoBlock	video_mode;
+dword	videoMode = 0;			//what video mode # we are in, 0 for console mode
+word	*vid_ptr16 = (word *)0xF0000000;
+byte	*vid_ptr24 = (byte *)0xF0000000;
+dword	*vid_ptr32 = (dword *)0xF0000000;
+word	console_memory[2000];		//holds a copy of the console's memory
+void (*video_psetp)(int, dword) = video_psetpnull;	//function pointer to set a pixel
+
+
+
+
+
+
@@ -0,0 +1,354 @@
+// vmm.c
+// Author: Josh Holtrop
+// Date: 09/30/03
+// Rewritten from scratch: 12/23/03
+// Modified: 12/30/03
+
+
+// This is the initialization procedure for the Virtual Memory Manager
+//  It sets up the final page directory/page table setup and maps video memory, if present
+void	vmm_init()
+{
+	dword *pageTables = (dword *)0xC0104000;	//this is the location of the page directory
+	pageTables[0x3FF] = 0x104000|0x03;		//the last page directory entry points to the page directory itself
+	pageTables[0] = 0;
+	invlpg(0);
+	if (videoMode)	//we are in a graphical mode
+	{
+		dword vidPages = video_mode.XResolution * video_mode.YResolution * (video_mode.BitsPerPixel >> 3);
+		if (vidPages % 4096)
+			vidPages = (vidPages >> 12) + 1;
+		else
+			vidPages = (vidPages >> 12);
+		vmm_mapn(0xF0000000, video_mode.PhysBasePtr, vidPages);
+	}
+	dword firstHeapEntryBlock = (dword)mm_palloc();
+	vmm_map1((dword)firstHeapEntry, firstHeapEntryBlock);
+	HeapEntryBlock *heb = (HeapEntryBlock *)firstHeapEntry;
+	vmm_heb_init(heb);
+	heb->entry[0].base = (dword)firstHeapEntry;	//start of kernel's heap memory
+	heb->entry[0].size = 4096;			//the first HeapEntryBlock is 1 page long
+	heb->entry[0].attributes = VMM_HE_HEB;		//this is a HeapEntryBlock
+	heb->entry[1].base = (dword)firstHeapEntry+4096;	//this is the start of the rest of the kernel's heap memory
+	heb->entry[1].size = 0x10000000-4096;		//the rest of the kernel's heap memory: 256mb - 4kb
+	heb->entry[1].attributes = VMM_HE_HOLE;		//this is a hold - an unmapped section of heap memory
+}
+
+
+// This function initialzes a Heap Entry Block to unused entries linked together
+void	vmm_heb_init(HeapEntryBlock *heb)
+{
+	int a;
+	for (a = 0; a < 256; a++)
+	{
+		heb->entry[a].base = 0;
+		heb->entry[a].size = 0;
+		heb->entry[a].attributes = VMM_HE_UNUSED;
+		heb->entry[a].link = (dword)&(heb->entry[a+1]);
+	}
+	heb->entry[255].link = 0;
+}
+
+
+// This function maps a virtual address to a physical address using the page directory / page table
+void	vmm_map1(dword virt, dword physical)
+{
+	dword pde = virt >> 22;
+	dword pte = (virt & 0x003FF000) >> 12;
+	dword *pageTables = (dword *)0xC0104000;	//this is the location of the page directory
+	if (!(pageTables[pde] & 0x01))		//the page directory entry does not exist, we must allocate a page for it
+	{
+		dword *newpagetable = mm_palloc();
+		pageTables[pde] = ((dword)newpagetable) | 0x03;
+		invlpg(virt);
+		dword *newpteptr = (dword *)(0xFFC00000 | (pde << 12));	//points to first dword of newly allocated page table
+		int a;
+		for (a = 0; a < 1024; a++)
+		{
+			newpteptr[a] = 0;
+		}
+	}
+	dword *pteptr = (dword *)(0xFFC00000 | (pde << 12) | (pte << 2));
+	*pteptr = physical | 0x03;
+	invlpg(virt);
+}
+
+
+// This function maps a variable number of pages in a row
+void	vmm_mapn(dword virt, dword physical, dword n)
+{
+	for (; n > 0; n--)
+	{
+		vmm_map1(virt, physical);
+		virt += 4096;
+		physical += 4096;
+	}
+}
+
+
+// This function removes the virtual address's entry in the page directory / page table
+void	vmm_unmap1(dword virt)
+{
+	dword *pteptr = (dword *)(0xFFC00000 | ((virt & 0xFFC00000) >> 10) | ((virt & 0x003FF000) >> 10));
+	*pteptr = 0;
+ 	invlpg(virt);
+}
+
+
+// This function removes multiple pages' entries
+void	vmm_unmapn(dword virt, dword n)
+{
+	for (; n > 0; n--)
+	{
+		vmm_unmap1(virt);
+		virt += 4096;
+	}
+}
+
+
+// Virtual Memory allocator function
+void	*malloc(dword bytes)
+{
+ 	if (bytes % VMM_MALLOC_GRANULARITY)
+ 		bytes = bytes + VMM_MALLOC_GRANULARITY - (bytes % VMM_MALLOC_GRANULARITY);
+	void *attempt = vmm_getFreeChunk(bytes);
+	if (attempt)
+		return attempt;
+	if(vmm_moreCore(bytes))
+		return 0;			//we could not get any more heap memory
+	return vmm_getFreeChunk(bytes);
+}
+
+
+// This function returns a pointer if a free chunk of memory exists
+void	*vmm_getFreeChunk(dword bytes)
+{
+	HeapEntry *he = firstHeapEntry;
+	for (;;)
+	{
+		if (he->attributes == VMM_HE_FREE)
+		{
+			if (he->size > bytes)
+			{
+				HeapEntry *nhe = vmm_nextHeapEntry();
+				nhe->base = he->base;
+				nhe->size = bytes;
+				nhe->attributes = VMM_HE_USED;
+				he->base += bytes;
+				he->size -= bytes;
+				return (void *)(nhe->base);
+			}
+			if (he->size == bytes)
+			{
+				he->attributes = VMM_HE_USED;
+				return (void *)(he->base);
+			}
+		}
+		he = (HeapEntry *)he->link;
+		if (!he)
+			break;
+	}
+	return 0;
+}
+
+
+// This function coalesces any two adjacent heap entries into one entry
+void	vmm_coalesceHeapEntry(HeapEntry *he)
+{
+	if (!(he->attributes == VMM_HE_FREE || he->attributes == VMM_HE_HOLE))
+		return;
+	if (he->size == 0)
+	{
+		he->attributes = VMM_HE_UNUSED;
+		return;
+	}
+	HeapEntry *hec = firstHeapEntry;
+	for (;;)
+	{
+		if (hec->attributes == he->attributes)
+		{
+			if ((hec->base + hec->size) == he->base)	//hec ends where he begins
+			{
+				he->base = hec->base;
+				he->size += hec->size;
+				hec->attributes = VMM_HE_UNUSED;
+			}
+			if ((he->base + he->size) == hec->base)		//he ends where hec begins
+			{
+				he->size += hec->size;
+				hec->attributes = VMM_HE_UNUSED;
+			}
+		}
+		hec = (HeapEntry *)hec->link;
+		if (!hec)
+			break;
+	}
+}
+
+
+// This function retrieves more physical memory for the heap
+int	vmm_moreCore(dword bytes)
+{
+	dword pages = (bytes >> 12) + 1;
+	bytes = pages << 12;
+	HeapEntry *he = vmm_getFirstHoleHeapEntry(bytes);
+	dword virt = he->base;
+	for (; pages > 0; pages--)
+	{
+		dword phys = (dword)mm_palloc();
+		if (!phys)
+			return 1;
+		vmm_map1(virt, phys);
+		virt += 4096;
+	}
+	if (he->size == bytes)
+	{
+		he->attributes = VMM_HE_FREE;
+		vmm_coalesceHeapEntry(he);
+	}
+	else
+	{
+		HeapEntry *nhe = vmm_nextHeapEntry();
+		nhe->base = he->base;
+		nhe->size = bytes;
+		nhe->attributes = VMM_HE_FREE;
+		he->base += bytes;
+		he->size -= bytes;
+		vmm_coalesceHeapEntry(nhe);
+	}
+	return 0;
+}
+
+
+// This function returns the next available heap entry, creates more entries if we are running low
+HeapEntry *vmm_nextHeapEntry()
+{
+	if (vmm_heapEntriesLeft() < 10)
+		vmm_addHeapEntryBlock();
+	return vmm_getFirstUnusedHeapEntry();
+}
+
+
+// This function creates a new block (page) of heap entries (256)
+void	vmm_addHeapEntryBlock()
+{
+	HeapEntry *he = vmm_getFirstHoleHeapEntry(4096);
+	HeapEntry *newBlock = vmm_getFirstUnusedHeapEntry();
+	dword heb = (dword)mm_palloc();
+	vmm_map1(he->base, heb);
+	vmm_heb_init((HeapEntryBlock *)he->base);
+	HeapEntry *lhe = vmm_getLastHeapEntry();
+	if (he->size == 4096)
+	{
+		he->attributes = VMM_HE_HEB;
+		lhe->link = (dword)he->base;
+	}
+	else
+	{
+		newBlock->base = he->base;
+		newBlock->size = 4096;
+		newBlock->attributes = VMM_HE_HEB;
+		he->base += 4096;
+		he->size -= 4096;
+		lhe->link = (dword)newBlock->base;
+	}
+	return;
+}
+
+
+// This function returns the last heap entry in the linked list, useful for setting
+//  its link field to point to the first entry of a newly allocated list
+HeapEntry *vmm_getLastHeapEntry()
+{
+	HeapEntry *he = firstHeapEntry;
+	for (;;)
+	{
+		if (he->link == 0)
+			return he;
+		he = (HeapEntry *)he->link;
+	}
+}
+
+
+// This function returns the first heap entry corresponding to a memory "hole"
+HeapEntry *vmm_getFirstHoleHeapEntry(dword minBytes)
+{
+	HeapEntry *he = firstHeapEntry;
+	for (;;)
+	{
+		if ((he->attributes == VMM_HE_HOLE) && (he->size >= minBytes))
+			return he;
+		he = (HeapEntry *)he->link;
+		if (!he)
+			break;
+	}
+	return 0;
+}
+
+
+// This function returns the first heap entry that is not being used
+HeapEntry *vmm_getFirstUnusedHeapEntry()
+{
+	HeapEntry *he = firstHeapEntry;
+	for (;;)
+	{
+		if (he->attributes == VMM_HE_UNUSED)
+			return he;
+		he = (HeapEntry *)he->link;
+		if (!he)
+			break;
+	}
+	return 0;
+}
+
+
+// This function returns the number of heap entries available for use
+dword	vmm_heapEntriesLeft()
+{
+ 	HeapEntry *he = firstHeapEntry;
+ 	dword entries = 0;
+ 	for (;;)
+ 	{
+ 		if (he->attributes == VMM_HE_UNUSED)
+ 			entries++;
+ 		he = (HeapEntry *)he->link;
+ 		if (!he)
+ 			break;
+ 	}
+	return entries;
+}
+
+
+// This function "frees" an area of memory previously allocated with malloc()
+int	free(void *ptr)
+{
+	HeapEntry *he = vmm_getHeapEntryByBase((dword)ptr);
+	if (!he)
+		return 1;	//a heap entry starting at the given address was not found
+	he->attributes = VMM_HE_FREE;
+	vmm_coalesceHeapEntry(he);
+	return 0;
+}
+
+
+// This function scans the heap entry linked list for an entry that begins at the given address
+HeapEntry *vmm_getHeapEntryByBase(dword base)
+{
+	HeapEntry *he = firstHeapEntry;
+	for (;;)
+	{
+		if (he->base == base)
+			return he;
+		he = (HeapEntry *)he->link;
+		if (!he)
+			break;
+	}
+	return 0;
+}
+
+
+
+
+
+
+
@@ -0,0 +1,55 @@
+// vmm.h
+// Author: Josh Holtrop
+// Date: 09/30/03
+// Rewritten from scratch: 12/23/03
+// Modified: 12/30/03
+
+
+#define	VMM_HE_UNUSED	0		//available entry
+#define	VMM_HE_FREE	1		//free section of memory
+#define	VMM_HE_USED	2		//used section of memory
+#define	VMM_HE_HOLE	3		//a "hole" (unmapped) section of virtual memory
+#define	VMM_HE_HEB	4		//HeapEntryBlock
+
+#define	VMM_MALLOC_GRANULARITY	4	//granularity for all memory requests
+
+typedef struct {
+	dword	base;			//virtual base address
+	dword	size;			//size in bytes
+	dword	attributes;		//free/used/hole
+	dword	link;			//link to next HeapEntry
+} __attribute__((packed)) HeapEntry;
+
+
+typedef struct {
+	HeapEntry	entry[256];	//256 HeapEntry objects = 4kb (1 page)
+} __attribute__((packed)) HeapEntryBlock;
+
+
+void	vmm_init();
+void   *malloc(dword bytes);
+int	free(void *ptr);
+void	vmm_map1(dword virt, dword physical);
+void	vmm_mapn(dword virt, dword physical, dword n);
+void	vmm_unmap1(dword virt);
+void	vmm_unmapn(dword virt, dword n);
+void	vmm_heb_init(HeapEntryBlock *heb);
+void	*vmm_getFreeChunk(dword bytes);
+HeapEntry *vmm_nextHeapEntry();
+dword	vmm_heapEntriesLeft();
+HeapEntry *vmm_getLastHeapEntry();
+HeapEntry *vmm_getFirstUnusedHeapEntry();
+HeapEntry *vmm_getFirstHoleHeapEntry(dword minBytes);
+void	vmm_addHeapEntryBlock();
+int	vmm_moreCore(dword bytes);
+void	vmm_coalesceHeapEntry(HeapEntry *he);
+HeapEntry *vmm_getHeapEntryByBase(dword base);
+
+
+HeapEntry *firstHeapEntry = (HeapEntry *)0xD0000000;	//this is where heap memory starts
+
+
+
+
+
+
Author	SHA1	Message	Date
josh	311b8afc83	Import backup from 2004-01-26	2017-07-25 22:23:46 -04:00
josh	21e3943b5e	Import backup from 2004-01-20	2017-07-25 22:23:46 -04:00
josh	10fd7102ca	Import backup from 2004-01-18	2017-07-25 22:23:46 -04:00
josh	7de4f94423	Import backup from 2004-01-15	2017-07-25 22:23:46 -04:00
josh	0a546f1467	Import backup from 2004-01-07	2017-07-25 22:23:45 -04:00
josh	af6087ecec	Import backup from 2004-01-04	2017-07-25 22:23:45 -04:00
josh	c613002307	Import backup from 2003-12-31	2017-07-25 22:23:45 -04:00
josh	76398df125	Import backup from 2003-12-30	2017-07-25 22:23:45 -04:00
josh	e83408ce83	Import backup from 2003-12-29	2017-07-25 22:23:45 -04:00
josh	715bb9341a	Import backup from 2003-12-28	2017-07-25 22:23:45 -04:00
josh	e82bf2ecdf	Import backup from 2003-12-25	2017-07-25 22:23:45 -04:00
josh	528527a7ed	Import backup from 2003-12-23_2	2017-07-25 22:23:45 -04:00
josh	71aaa7a598	Import backup from 2003-12-23	2017-07-25 22:23:45 -04:00
josh	9070a76b18	Import backup from 2003-12-22_2	2017-07-25 22:23:45 -04:00
josh	5048a93ff7	Import backup from 2003-12-22	2017-07-25 22:23:45 -04:00
josh	282b856e24	Import backup from 2003-12-21	2017-07-25 22:23:45 -04:00
josh	3bb1e5fffc	Import backup from 2003-12-20	2017-07-25 22:23:45 -04:00
josh	5ccfd0fc74	Import backup from 2003-11-13	2017-07-25 22:23:45 -04:00
josh	70d6bb1eb3	Import backup from 2003-11-12	2017-07-25 22:23:45 -04:00
josh	294b4b0e27	Import backup from 2003-11-11	2017-07-25 22:23:45 -04:00
josh	57980293e6	Import backup from 2003-11-03	2017-07-25 22:23:45 -04:00
josh	ba97e8a7f0	Import backup from 2003-10-30	2017-07-25 22:23:45 -04:00
josh	36b025ccb4	Import backup from 2003-10-27	2017-07-25 22:23:45 -04:00
josh	aab5ff3c90	Import backup from 2003-10-23	2017-07-25 22:23:45 -04:00
josh	8bf6e65a95	Import backup from 2003-10-16	2017-07-25 22:23:45 -04:00
josh	5da602b162	Import backup from 2003-10-06	2017-07-25 22:23:45 -04:00
josh	7a0351e123	Import backup from 2003-10-03	2017-07-25 22:23:45 -04:00
josh	3dc0fe5e2b	Import backup from 2003-09-30	2017-07-25 22:23:45 -04:00
josh	82da40c9f0	Import backup from 2003-09-29	2017-07-25 22:23:45 -04:00
josh	8d5b28f823	Import backup from 2003-09-28	2017-07-25 22:23:45 -04:00
josh	68fd6cad70	Import backup from 2003-09-26	2017-07-25 22:23:45 -04:00
josh	c3309d4e5d	Import backup from 2003-09-23	2017-07-25 22:23:45 -04:00
josh	06d7cbef47	Import backup from 2003-09-13	2017-07-25 22:23:44 -04:00
josh	e8b1abb265	Import backup from 2003-09-12	2017-07-25 22:23:44 -04:00
josh	a40131b163	Import backup from 2003-09-11	2017-07-25 22:23:44 -04:00
josh	fdfeb94ae3	Import backup from 2003-09-09	2017-07-25 22:23:44 -04:00
josh	3f4c7ff32f	Import backup from 2003-09-08	2017-07-25 22:23:44 -04:00
josh	02d7fc9a69	Import backup from 2003-09-07	2017-07-25 22:23:44 -04:00
josh	e147635333	Import backup from 2003-09-03	2017-07-25 22:23:44 -04:00
josh	5ffee3c2d8	Import backup from 2003-09-02	2017-07-25 22:23:44 -04:00
josh	9076a15f08	Import backup from 2003-09-01_2	2017-07-25 22:23:44 -04:00
josh	dae5569216	Import backup from 2003-09-01	2017-07-25 22:23:44 -04:00
josh	594502f824	Import backup from 2003-08-31	2017-07-25 22:23:44 -04:00
josh	c968aa28ac	Import backup from 2003-08-26	2017-07-25 22:23:44 -04:00
josh	449917d434	Import backup from 2003-08-24	2017-07-25 22:23:44 -04:00
josh	8efede851c	Import backup from 2003-08-19	2017-07-25 22:23:44 -04:00
josh	82cf9a9de4	Import backup from 2003-08-18_2	2017-07-25 22:23:44 -04:00
josh	b0c1c492b2	Import backup from 2003-08-18	2017-07-25 22:23:44 -04:00
josh	162e52b121	Import backup from 2003-08-17_3	2017-07-25 22:23:44 -04:00
josh	9ee980bc94	Import backup from 2003-08-17_2	2017-07-25 22:23:44 -04:00
josh	43f3ea24f8	Import backup from 2003-08-17	2017-07-25 22:23:44 -04:00
josh	149541fbf1	Import backup from 2003-08-16	2017-07-25 22:23:44 -04:00
josh	588b3f06ba	Import backup from 2003-08-13_2	2017-07-25 22:23:44 -04:00
josh	75c132cbd4	Import backup from 2003-08-13	2017-07-25 22:23:44 -04:00
josh	4e4baeba63	Import backup from 2003-08-12	2017-07-25 22:23:44 -04:00
josh	1c3e9ebdc4	Import backup from 2003-08-11	2017-07-25 22:23:44 -04:00
josh	9035beda29	Import backup from 2003-08-10	2017-07-25 22:23:44 -04:00
josh	ff819331cf	Import backup from 2003-08-09	2017-07-25 22:23:44 -04:00
josh	06fbbb1c87	Import backup from 2003-08-06	2017-07-25 22:23:44 -04:00
josh	2ada7fd5df	Import backup from 2003-08-05	2017-07-25 22:23:44 -04:00
josh	e6805ee94c	Import backup from 2003-08-04	2017-07-25 22:23:44 -04:00
josh	7a4586bb06	Import backup from 2003-08-03	2017-07-25 22:23:44 -04:00
				`@@ -0,0 +1,2 @@`
				`nasmw -f aout -o ks.o -l .\lst\kernel.lst kernel.asm`
				`@@ -0,0 +1 @@`
				`gcc -ffreestanding -fno-builtin -nostdlib -nodefaultlibs -c kernel.c -o kernel.o`
				`@@ -0,0 +1 @@`
				`nasmw -f aout -o asmfuncs.o -l .\lst\asmfuncs.lst asmfuncs.asm`
				`@@ -0,0 +1 @@`
				`nasmw -f bin -o stage1.bin -l .\lst\stage1.lst stage1.asm`
				`@@ -0,0 +1 @@`
				`nasmw -f bin -o stage2.bin -l .\lst\stage2.lst stage2.asm`
				`@@ -0,0 +1 @@`
				`ld -nodefaultlibs -nostdlib -T link.ld -o kernel.bin -Map .\lst\LDout.doc ks.o kernel.o asmfuncs.o`