OSDev.org

Code: Select all

[BITS 16]      ; 16 bit code generation
[ORG 0x7C00]   ; Origin location

; Main program
main:		; Label for the start of the main program

 mov ax,0x0000	; Setup the Data Segment register
		; Location of data is DS:Offset
 mov ds,ax	; This can not be loaded directly it has to be in two steps.
		; 'mov ds, 0x0000' will NOT work due to limitations on the CPU

 mov si, HelloWorld	; Load the string into position for the procedure.
 call PutStr	; Call/start the procedure

jmp $		; Never ending loop

; Procedures
PutStr:		; Procedure label/start
 ; Set up the registers for the interrupt call
 mov ah,0x0E	; The function to display a chacter (teletype)
 mov bh,0x00	; Page number
 mov bl,0x07	; Normal text attribute

.nextchar	; Internal label (needed to loop round for the next character)
 lodsb		; I think of this as LOaD String Block 
		; (Not sure if thats the real meaning though)
		; Loads [SI] into AL and increases SI by one
 ; Check for end of string '0' 
 or al,al	; Sets the zero flag if al = 0 
		; (OR outputs 0's where there is a zero bit in the register)
 jz .return	; If the zero flag has been set go to the end of the procedure.
		; Zero flag gets set when an instruction returns 0 as the answer.
 int 0x10	; Run the BIOS video interrupt 
 jmp .nextchar	; Loop back round tothe top
.return		; Label at the end to jump to when complete
 ret		; Return to main program

; Data

HelloWorld db 'Hello World',13,10,0

; End Matter
times 510-($-$$) db 0	; Fill the rest with zeros
dw 0xAA55		; Boot loader signature

Code: Select all

nasm.exe boot.txt -f bin -o boot

Code: Select all

bprint	proc near
	mov	bx, 0007H
	lodsb
	or	al, al
	je	bpout
	mov	ah, 0eH
	int	10H
	jmp	bprint
bpout:
	ret
bprint	endp

Code: Select all

;==============================================================================
;  test assembled with: cd %COSPATH%/fasm/ && ./fasm %PATH%/CruiseOS/kernel_sa.asm %PATH%/CruiseOS/kernel.bin
;	 ".bin" is for flashing	to bochs hdd image
;  release assembled with: cd %COSPATH%/fasm/ && ./fasm %PATH%/CruiseOS/kernel.asm %PATH%/CruiseOS/kernel.img 
;	".img" is for flashing onto usb
;  Kernel is flashed to usb using ImageWriter for Ubuntu
;  Kernel is flashed to a 4gb bochs hdd using a cpp program I created, let me know if you need a copy of the 
;	program source.
;
;File Name: kernel_sa.asm
;Revision: New
;Date Created: January 15th, 2012 
;Date Last Modified: February 7th 2012
;Version: 0.0.0b.0
;Supported OS: CruiseOS
;Author: Timothy Giddens
;
;Assembled with: FASM
;	ver: 1.69.35
;Overview:
;	This is the kernel modual of CruiseOS with minimum procedures directly included, so 
;	that this is stand alone. This file is intended for use when asking for help.


format binary			;FASM outputs the file in machine code directly as writen below
				;This is to facilitate flashing directly to USB

use16				;Use x86 16-bit opcodes

label BOOT_SEC_START at 0x07C0 	;BIOS loads boot sec into segment:offset 0x07C0:0000
	
  mov ax, BOOT_SEC_START	;Initialize segments for boot loader
  mov ds, ax
  mov es, ax

LBA_CHECK:			;This checks the BIOS for LBA compatability
  mov ah, 0x41			;BIOS LBA Check operation
  mov bx, 0x55AA
  mov dl, 0x80			;HDD 1 (susspect this is why not booting on AMD box)
  int 0x13
; jc error 			;Sets carry on error. Some sort of exeption handler will go here eventually

DAP:				;(Disk Address Packet)This data structure is used for LBA reads
  db 0x10			;Always 0x10 (16) (structure size)
  db 0x00			;Always 0x00
  dw 0x0003			;Number of LBA's to read (512 bytes per LBA) (max 16 sectors per read) (max 8192 bytes per read)
  dd 0x0000:0x0500		;Segment:offset of memory to read bytes to.
  dq 0x0000000000000001		;LBA # to start read.


LBA_READ:			;This reads data from hdd
  mov si, DAP			;Point to data structure
  mov ah, 0x42			;BIOS LBA read operation
  mov dl, 0x80			;
  int 0x13

  jmp 0x00:0x0500		;Jump to kernel segment
  
  db 510-($-$$) dup 0 		; boot sector must be 510 bytes plus 2 bytes at BOOT_SEC_END
  
BOOT_SEC_END:
  db 0x55
  db 0xAA

org 0x0500			;Set everything to address from zero in kernel segment
KERNEL_START16:			;Start of 16-bit mode

;***********************Macros************************
macro ClrScr
{
  call clr_scr
}

macro WriteString STRING*		;STRING structure, or reg pointing to
					;string
{
  pushad
  mov si, STRING
  call write_string
  popad
}

macro GetInput BUFFER*		;BUFFER structure
{
   mov di, BUFFER
   mov dh, [#BUFFER#.size]
    call get_input
}

macro strcmp string1*,string2*
{
  pushad
  mov si, string1
  mov di, string2
  call pStrcmp
  popad
}

struc STRING [string]
;structure creates a null terminated string and a size.
{
  common
  . db string
  db 0
  .size = $ - .
}

struc BUFFER size
;creates a buffer of size.
{
  common
  . db size dup 0
  .size = $ - .
}

lf equ 0x0A
cr equ 0x0D
nl equ lf,cr

;*********************END MACROS***************************


  mov ax, 0x0000  		; set up segments
  mov ds, ax
  mov es, ax
  jmp start

start:
  ClrScr
  WriteString welcome
  jmp mainloop
 
mainloop:
  WriteString prompt
 
  GetInput input
 
  mov si, input
  cmp byte [si], 0  		;If the input line is blank ignore it
  je mainloop       		;
 
  strcmp cmd_hi, input  	; "hi" command
  jc .helloworld
 
  strcmp cmd_help, input  	; "help" command
  jc .help

  strcmp cmd_test, input	; "test" command
  jc .test
 
  WriteString badcommand 
  jmp mainloop  
 
.helloworld:
  WriteString msg_helloworld

  jmp mainloop
 
.help:
  WriteString msg_help
 
  jmp mainloop


;*****************TEST PROGRAM AREA******************
;This is where I am putting code as I test my system

.test:
  
jmp mainloop
;*****************END TEST AREA**********************

;*****************DATA*******************************
 
  welcome STRING 'Welcome to CruiseOS V.0.0.0b.0!',nl
  msg_helloworld STRING 'Hello User!',nl
  badcommand STRING 'Bad command entered.',nl
  prompt STRING '$>'
  cmd_hi STRING 'hi'
  cmd_help STRING 'help'
  cmd_test STRING 'test'
  msg_help STRING 'My OS: Commands: hi, help, test',nl
  input BUFFER 64

KERNEL_END:

;*******************Procedures********************
;These were all pulled out of the include files
;So this can be assembled and tested as is, 
;Thanks for your help!.


clr_scr:
  pusha
  mov cx, 0x0000		;0x'row''column' (upper row)
  mov dx, 0x184F		;0x'row''column' (lower row)
  mov bh, 0x07			;black bkgd, white cursor blink enabled
				;will change this to a var later
  mov ax, 0x0600		;0x'scroll up''num rows' 0=all
  int 0x10			;BIOS interrupt
  
  mov bh, 0x00			;Page number
  mov dx, 0x0000		;0x'row''column'
  mov ah, 0x02			;Set cursor position
  int 0x10			;BIOS interrupt
  popa
ret ;END clr_scr


write_string:
  lodsb        			;Load a byte based on SI
 
  or al, al  			;If result is zero then al is zero
  jz .done   			;and we have reached end of string 
  mov ah, 0x0E			;If al not zero print the character
  int 0x10      		;
 
  jmp write_string		;Try next character
 
  .done:			;Done printing
    ret
;End WriteString

get_input:
   xor cl, cl			;wipe out cl used as a counter
 
  .loop:
    mov ah, 0			;wait for user keypress
    int 0x16   			;users key will be in AL
    cmp al, 0x08
    je .backspace		;Handle backspace event   
    cmp al, 0x0D 
    je .done      		;Handle enter/return event
    cmp al, 0x1B		;
    je .escape			;handle escape event
    sub dh, 1
    cmp cl, dh		 	;Will only read in up to one less buffer size
    je .loop      		;If limit is reached only enter and backspace is read
    mov ah, 0x0E
    int 0x10      		;Print out "Echo" character
    stosb  			;put character in buffer
    inc cl			;Increment character count
    jmp .loop			;Return for more input
 
  .backspace:			;Handle backspace event
    cmp cl, 0			;If this is the beginning of the prompt
    je .loop			;ignore that backspace was pressed
    dec di			;Move back one character in "buffer"
    mov byte [di], 0		;Write a null "delete character"
    dec cl			;decrement character count

    mov ah, 0x0E		;"Echo" backspace
    mov al, 0x08		;"cursor back one space"
    int 10h			;
    mov al, ' '			;black char print
    int 10h			;
    mov al, 0x08		;"cursor back one space"
    int 0x10			;
 
    jmp .loop			;Get more input

  .escape:
    cmp cl, 0
    jg .decpos
    mov byte [di], 0x1B
    jmp .done
  .decpos:
    cmp cl, 0			;If this is the beginning of the prompt
    je .loop			;ignore that backspace was pressed
    dec di			;Move back one character in "buffer"
    mov byte [di], 0		;Write a null "delete character"
    dec cl			;decrement character count

    mov ah, 0x0E		;"Echo" backspace
    mov al, 0x08		;"cursor back one space"
    int 10h			;
    mov al, ' '			;black char print
    int 10h			;
    mov al, 0x08		;"cursor back one space"
    int 10h	
  jmp .escape

  .done:
    mov al, 0			;Add a null terminator to the string
    stosb
 
    mov ah, 0x0E		;Move cursor to new line
    mov al, 0x0D		;Carriage Return
    int 0x10
    mov al, 0x0A		;Line Feed	
    int 0x10
 
  ret
;End get_input


pStrcmp:
  .loop:
    mov al, [si]   		;Grab a byte from SI
    mov bl, [di]   		;Grab a byte from DI
    cmp al, bl     		;Are the two equal?
    jne .notequal  		;If not then exit.
 
    cmp al, 0  			;If both bytes are here they are equal, if they are null then the strings are finished
    je .done   			;yes, we're done.
 
    inc di     			;increment DI
    inc si     			;increment SI
    jmp .loop  			;
 
  .notequal:
    clc  			;Clear the carry flag if strings are not equal
    ret
 
  .done: 	
    stc  			;Set the carry flag if strings are equal
    ret
;End strcmp

macro mPadhddseg
;
;	the intent of this macro is to pad the current address space to a 512
;	byte boundry for direct flashing of the kernel so that it boots
;	properly.
;
{
  if $-$$ = 0
  else
    pad equ (((($-$$)/512)+1)*512)-($-$$)
    if pad = 0
    else
      db pad dup 0
    end if
  end if
}
  
mPadhddseg