OSDev.org

Code: Select all

//Video.cpp
#include "video.h" 
Video::Video()
{
pos=0 ; off=0 ;
videomem = (unsigned short*) 0xb8000 ;
}

Video::~Video() {}

void Video::clear()
{
unsigned int i;

for(i=0; i<80>=80)
{
pos=0 ;
off += 80 ;
}

if(off>=(80*25))
{
clear() ; //should scroll the screen, but for now, just clear
}

videomem[off + pos] = (unsigned char) c | 0x0700 ;
pos++ ;
}

Code: Select all

//Video.h
#ifndef VIDEO_H
#define VIDEO_H //so we don't get multiple definitions of Video

class Video
{
public:
Video() ;
~Video() ;
void clear() ;
void write(char *cp) ;
void put(char c) ;
private:
unsigned short *videomem ; //pointer to video memory
unsigned int off ; //offset, used like a y cord
unsigned int pos ; //position, used like x cord

}; //don't forget the semicolon!
#endif

Code: Select all

//Kernel.cpp
#include "video.h"

int main(void)
{
Video vid ; //local, (global variables need some Run-Time support code)

vid.put('p');
vid.write("hi all") ;
while(1);
}

Code: Select all

; Loader.asm

[BITS 32] ; protected mode

[global start] 
[extern main] ; this is in our C++ code

start:
call main ; call int main(void) from our C++ code
cli ; interrupts could disturb the halt
hlt ; halt the CPU

Code: Select all

/* Link.ld */
OUTPUT_FORMAT("binary")
ENTRY(start)
SECTIONS
{
.text 0x100000 :
{
code = .; _code = .; __code = .;
*(.text)
. = ALIGN(4096);
}

.data :
{
data = .; _data = .; __data = .;
*(.data)
. = ALIGN(4096);
}

.bss :
{
bss = .; _bss = .; __bss = .;
*(.bss)
. = ALIGN(4096);
}

end = .; _end = .; __end = .;
}

Code: Select all

void Video::write(char *cp)
{

// char *str = cp, *ch;
// for (ch = str; *ch; ch++) put(*ch);

}

Code: Select all

%include "DK.inc"

[BITS 16]	;16 Bit
[ORG 0x7C00]	;Indirizzo da dove parte il bootloader

 xor	ax, ax
 mov	ds, ax
 mov	ss, ax
 mov	sp, 0xFFFF

 mov	si, BOOT 	;Open Source Operative System
 call	print

 mov	si, KERNEL 	;Caricamento Kernel
 call	print
	
 call	load_kernel	;Carico il kernel in memoria ma aspetto a lanciarlo

 ;Spengo il floppy disk
 mov	dx, 0x3F2
 mov	al, 0xC
 out	dx, al
 
 ;Disabilito gli interrupt non mascherabili
 in	al, 0x70
 or	al, 0x80
 out	0x70, al

 ;Abilito la linea A20 per poter utilizzare piu memoria
wait1:
 in	al, 0x64
 test	al, 0x2
 jnz	wait1
 mov	al, 0xD1
 out	0x64, al
wait2:
 in	al, 0x64
 and	ax, byte 0x2
 jnz	wait2
 mov	al, 0xDF
 out	0x60, al
	
;Carico la tabella GDT
 lgdt	[gdtinfo]
 mov	eax, CR0
 or	al, 0x1
 mov	CR0, eax
	
;Salto al codice a 32 BIT
 jmp	dword (flat_code-gdt_table):lancia_kernel


[BITS 16]
print:
 lodsb
 or	al, al
 jz	.end
 mov	ah, 0xE
 mov	bx, 0x7
 int	0x10
 jmp	print
.end:
 ret

load_kernel:
 mov	di, DK	;Dimensione del kernel in settori
 mov	ax, 0x1000	;Imposto ax a 0x1000
 mov	es, ax		;Numero del segmento
 xor	ch, ch		;Numero della traccia
 mov	cl, 0x2		;Numero del settore
 xor	dl, dl		;Numero della testina
 xor	dh, dh		;Numero del drive
 xor	bx, bx		;Azzero il buffer es:bx  = 0x1000:0 = Primo Mega
leggi:
 mov	ah, 0x2		;Numero del servizio
 mov	al, 0x1		;Numero di settori da leggere
 int	0x13		;Esegue la lettura
 jc	fdc_error	;Gestisci l'eventuale errore
 mov	ax, es		;Metto il valore di es in ax
 add	ax, 0x20	;Modifico il valore di ax
 mov	es,ax		;Riaggiorno il valore di es
 dec	di		;Decrementiamo di uno il numero dei settori
 jz 	end		;Se non vi sono più settori, termina
 inc	cx		;Incremento il numero del settore
 cmp	cl, 0x12	;Comparo cl al valore 0x12 (18)
 jna	leggi		;Se cl è <di>15
 dw	0x0000	;Base bit 0->15
 db	0x00	;Base bit 16->23
 db	0x9A	;Segmento codice con privilegio 0
 db	0xCF	;Limite bit 16->19 segmento a 32 bit step: 4096 byte
 db	0x00	;Base 24->32
flat_data:
 dw	0xFFFF	;Limite bit   0->15
 dw	0x0000	;Base bit 0->15
 db	0x00	;Base bit 16->23
 db	0x92	;Segmento dati con privilegio 0
 db	0xCF	;Limite bit 16->19 segmento a 32 bit step: 4096 byte
 db	0x00	;Base 24->32
 gdtlength	equ	$ - gdt_table	;Dimensione della GDT

[BITS 32]	;Codice a 32 bit
lancia_kernel:
 mov	ax, flat_data - gdt_table
 mov	ds, ax
 mov	es, ax
 mov	fs, ax
 mov	gs, ax
 mov	ss, ax
 mov	esp, 0x9FFF0	;Imposto lo stack
	
 ;Lancio il kernel
 push	dword 0x2	;Azzero gli EFLAGS
 popfd			;Imposto gli EFLAGS
 mov	eax, 0x10000	;Imposta la locazione di memoria del kernel
 jmp eax		;Eseguo il kernel

	

;Messaggi da stampare a video
BOOT		db	'--  OPEN SOURCE OPERATIVE SYSTEM  --', 0xD, 0xA, 0x0
KERNEL		db	'Caricamento del kernel', 0xD, 0xA, 0x0
FDC_ERROR	db	'Errore nella lettura del floppy', 0xD, 0xA, 0x0

;Azzera i byte rimanenti del bootsecto e metto la word 0xAA55 in fondo
times	510-($-$$)	db	0
dw	0xAA55

Code: Select all

gdtinfo:
 dw	gdtlength	;Numero di elementi presenti nella GDT
 dw	gdt_table	;Indirizzo della GDT
gdt_table:
 dd	0	;Il primo elemento è nullo
 dd	0	;Il primo elemento è nullo
flat_code:
 dw	0xFFFF	;Limite bit   0->15
 dw	0x0000	;Base bit 0->15
 db	0x00	;Base bit 16->23
 db	0x9A	;Segmento codice con privilegio 0
 db	0xCF	;Limite bit 16->19 segmento a 32 bit step: 4096 byte
 db	0x00	;Base 24->32
flat_data:
 dw	0xFFFF	;Limite bit   0->15
 dw	0x0000	;Base bit 0->15
 db	0x00	;Base bit 16->23
 db	0x92	;Segmento dati con privilegio 0
 db	0xCF	;Limite bit 16->19 segmento a 32 bit step: 4096 byte
 db	0x00	;Base 24->32
 gdtlength	equ	$ - gdt_table	;Dimensione della GDT