Import backup from 2004-08-03

kernel/Makefile

@@ -18,7 +18,8 @@ LD_FLAGS=-nodefaultlibs -nostdlib --no-demangle -T link.ld
 all: Asm_Kernel C_Kernel
 	$(LD) $(LD_FLAGS) -Map kernel.map boot.o \
 	kernel.o asmfuncs.o mm.o vmm.o parallel.o \
-	conv.o kout.o -o kernel.bin
+	conv.o kout.o console.o devices.o \
+	-o kernel.bin
 
 Asm_Kernel:
 	$(NASM) $(NASM_FLAGS) -l boot.lst boot.asm -o boot.o
@@ -31,6 +32,8 @@ C_Kernel:
 	$(CC) $(CC_FLAGS) -c char/parallel.c -o parallel.o
 	$(CC) $(CC_FLAGS) -c lang/conv.c -o conv.o
 	$(CC) $(CC_FLAGS) -c kout.c -o kout.o
+	$(CC) $(CC_FLAGS) -c char/console.c -o console.o
+	$(CC) $(CC_FLAGS) -c fs/devices.c -o devices.o
 
 #################################################
 # Clean up the source directory of any binaries #

kernel/block/rd.c

@@ -10,7 +10,7 @@ void	rd_init()
 
 }
 
-int rd_register(byte *ramdisk, u32_t size)
+int	rd_register(byte *ramdisk, u32_t size)
 {
 	int i;
 	for (i = 0; i < 256; i++)
@@ -26,7 +26,7 @@ int rd_register(byte *ramdisk, u32_t size)
 	return -1;
 }
 
-int rd_remove(minor_t minor)
+int	rd_remove(minor_t minor)
 {
 	if (rd_refs[minor] <= 0)
 		return -1;
@@ -35,7 +35,7 @@ int rd_remove(minor_t minor)
 		free(ramdisks[minor].start);
 }
 
-int rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
+int	rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
 {
 	if (rd_refs[minor] <= 0)
 		return -1;
@@ -45,7 +45,7 @@ int rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
 
 }
 
-int rd_write_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
+int	rd_write_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
 {
 
 }

kernel/block/rd.h

@@ -11,11 +11,11 @@ typedef struct {
 	u32_t	size;
 } ramdisk_t;
 
-void rd_init();
+void	rd_init();
-int rd_register(byte *ramdisk, u32_t size);
+int	rd_register(byte *ramdisk, u32_t size);
-int rd_remove(minor_t minor);
+int	rd_remove(minor_t minor);
-int rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer);
+int	rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer);
-int rd_write_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer);
+int	rd_write_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer);
 
 #endif
 

kernel/char/console.c

@@ -1,44 +1,211 @@
 // console.c
 // Author: Josh Holtrop
 // Date: 08/02/04
+// Modified: 08/03/04
 
 #include "char/console.h"
 #include "hos_defines.h"
 #include "fs/devices.h"
+#include "mm/vmm.h"
+#include "lang/asmfuncs.h"
 
 console_t *consoles[256];
+int	activeConsole;
 
-int console_new(minor_t minor)
+void	console_put_char(minor_t id, int c);
+void	console_write_cursor(minor_t id, u16_t position);
+void	console_refresh();
+
+// initialization routine for consoles module
+int	console_init(u32_t num, int width, int height)
 {
-	if (consoles[minor])
+	activeConsole = 0;
-		return -1;	// minor already taken
+	dev_driver_t *console_driver = New(dev_driver_t);
-	if ( consoles[minor] = kmalloc(sizeof(console_t)) )
+	console_driver->block_read = NULL;
+	console_driver->block_write = NULL;
+	console_driver->char_read = NULL;
+	console_driver->char_write = console_char_write;
+	devices_register_major('c', MAJOR_CONSOLE, console_driver);
+	kfree(console_driver);
+	for (; num > 1; num--)
 	{
-		consoles[minor]->cursorPosition = 0;
+		if (( consoles[num] = New(console_t) ))
-		consoles[minor]->width = 80;
-		consoles[minor]->height = 25;
-		consoles[minor]->attribute = 0x07;
-		if (consoles[minor]->buffer = kmalloc(4000))
 		{
-			memsetw(consoles[minor]->buffer, 0, 2000);
+			if (( consoles[num]->buffer = kmalloc(width * height) ))
+			{
+				consoles[num]->cursorPosition = 0;
+				consoles[num]->width = width;
+				consoles[num]->height = height;
+				consoles[num]->cursorStackPosition = 0;
+				consoles[num]->escapeLevel = 0;
+				consoles[num]->escapePosition = 0;
+				memsetd(consoles[num]->escapeValue, 0, 8);
+				consoles[num]->attribute = 0x07;
+				memsetw(consoles[num]->buffer, 0x0720, width * height);
+			}
+			else
+			{
+				kfree(consoles[num]);
+				return -2;
+			}
 		}
 		else
-		{
+			return -1;
-			kfree (consoles[minor]);
-			consoles[minor] = 0;
-			return -3;	// couldn't allocate memory
-		}
 		
-		return 0;
 	}
-	else
+	return 0;
-		return -2;	// couldn't allocate memory
 }
 
-void console_outb(minor_t id, int c)
+
+int	console_activate(int num)
+{
+	if (consoles[num])
+	{
+		activeConsole = num;
+		memcpyw((void*)CONSOLE_MEMORY, consoles[num]->buffer, consoles[num]->width * consoles[num]->height);
+		writeCursorPosition(consoles[num]->cursorPosition);
+	}
+	return -1;
+}
+
+
+int	console_char_write(minor_t id, u64_t position, int c)
+{
+	if (!consoles[id])
+		return -1;
+	int cursorY = consoles[id]->cursorPosition / consoles[id]->width;
+	int cursorX = consoles[id]->cursorPosition % consoles[id]->width;
+	switch (consoles[id]->escapeLevel)
+	{
+	case 2:
+		if (c >= '0' && c <= '9')	// c is part of an escape value
+		{
+			consoles[id]->escapeValue[consoles[id]->escapePosition] *= 10;
+			consoles[id]->escapeValue[consoles[id]->escapePosition] += c - '0';
+			return 0;
+		}
+		else if (c == ';')
+		{
+			if (consoles[id]->escapePosition < 7)
+				consoles[id]->escapePosition++;
+			return 0;
+		}
+		switch (c)
+		{
+			case 'A':	// move cursor up n rows
+				cursorY -= consoles[id]->escapeValue[0];
+				if (cursorY < 0)
+					cursorY = 0;
+				console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
+				break;
+			case 'B':	// move cursor down n rows
+				cursorY += consoles[id]->escapeValue[0];
+				if (cursorY >= consoles[id]->height)
+					cursorY = consoles[id]->height - 1;
+				console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
+				break;
+			case 'C':	// move cursor right n columns
+				cursorX -= consoles[id]->escapeValue[0];
+				if (cursorX < 0)
+					cursorX = 0;
+				console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
+				break;
+			case 'D':	// move cursor left n columns
+				cursorX += consoles[id]->escapeValue[0];
+				if (cursorX >= consoles[id]->width)
+					cursorX = consoles[id]->width - 1;
+				console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
+				break;
+			case 'H':
+			case 'f':	// move cursor to position (x,y) upper left is (1,1)
+				cursorX = consoles[id]->escapeValue[0] - 1;
+				cursorY = consoles[id]->escapeValue[1] - 1;
+				if (cursorY < 0)
+					cursorY = 0;
+				if (cursorY >= consoles[id]->height)
+					cursorY = consoles[id]->height - 1;
+				if (cursorX < 0)
+					cursorX = 0;
+				if (cursorX >= consoles[id]->width)
+					cursorX = consoles[id]->width - 1;
+				console_write_cursor(id, 0);
+				break;
+			case 'J':	// clear screen, home cursor
+				memsetw(consoles[id]->buffer, 0x0720, consoles[id]->width * consoles[id]->height);
+				console_refresh();
+				console_write_cursor(id, 0);
+				break;
+			case 'K':	// erase line from cursor position (including char. under cursor) to end of line
+				memsetw(consoles[id]->buffer + consoles[id]->cursorPosition, 0x0720, consoles[id]->width - cursorX);
+				console_refresh();
+				break;
+			case 's':	// push cursor position on an internal stack
+				if (consoles[id]->cursorStackPosition < 16)
+					consoles[id]->cursorStack[consoles[id]->cursorStackPosition++] = consoles[id]->cursorPosition;
+				break;
+			case 'u':	// pop cursor position from stack
+				if (consoles[id]->cursorStackPosition > 0)
+					consoles[id]->cursorPosition = consoles[id]->cursorStack[--consoles[id]->cursorStackPosition];
+				break;
+			case 'm':	// set text attributes
+				for (; consoles[id]->escapePosition >= 0; consoles[id]->escapePosition--)
+				{
+					switch (consoles[id]->escapeValue[consoles[id]->escapePosition])
+					{
+					case 0:
+						consoles[id]->attribute = 0x07;
+						break;
+					case 1:
+					case 5:
+					case 7:
+					case 30:
+					
+					}
+				}
+				break;
+		}
+		memsetd(consoles[id]->escapeValue, 0, 8);
+		consoles[id]->escapePosition = 0;
+		consoles[id]->escapeLevel = 0;
+		return 0;
+	case 1:
+		if (c == '[')
+			consoles[id]->escapeLevel = 2;
+			break;
+		consoles[id]->escapeLevel = 0;
+		return 0;	// invalid escape sequence
+	default:
+		if (c == '\e')
+		{
+			consoles[id]->escapeLevel = 1;
+			return 0;
+		}
+		console_put_char(id, c);
+	}
+	return 0;
+}
+
+
+void	console_put_char(minor_t id, int c)
 {
-	if (!consoles[minor])
-		return;
 
 }
 
+void	console_write_cursor(minor_t id, u16_t position)
+{
+	consoles[id]->cursorPosition = position;
+	if (activeConsole == id)
+		writeCursorPosition(position);
+}
+
+void	console_refresh()
+{
+	if (activeConsole > 0)
+	{
+		memcpyw((void*)CONSOLE_MEMORY, consoles[activeConsole]->buffer, consoles[activeConsole]->width * consoles[activeConsole]->height);
+		writeCursorPosition(consoles[activeConsole]->cursorPosition);
+	}
+}
+
+
+

kernel/char/console.h

@@ -1,6 +1,7 @@
 // console.h
 // Author: Josh Holtrop
 // Date: 08/02/04
+// Modified: 08/03/04
 
 #ifndef __HOS_CONSOLE__
 #define __HOS_CONSOLE__ __HOS_CONSOLE__
@@ -10,15 +11,21 @@
 
 typedef struct
 {
-	u32_t	cursorPosition;
+	u32_t	escapeValue[8];
+	u16_t	cursorPosition;
 	u16_t	width;
 	u16_t	height;
-	u8_t	attribute;
 	u16_t	*buffer;
+	u16_t	cursorStack[16];
+	u8_t	attribute;
+	u8_t	cursorStackPosition;
+	char	escapeLevel;
+	char	escapePosition;
 } console_t;
 
-int console_new(minor_t minor);
+int	console_init(u32_t num, int width, int height);
-void console_outb(minor_t id, int c);
+int	console_activate(int num);
+int	console_char_write(minor_t id, u64_t position, int c);
 
 #endif
 

kernel/fs/devices.c

@@ -1,6 +1,7 @@
 // devices.c
 // Author: Josh Holtrop
 // Date: 08/02/04
+// Modified: 08/03/04
 
 
 #include "fs/devices.h"
@@ -10,16 +11,22 @@ dev_driver_t drivers[256];
 char drivers_registered[256];	//0 (unregistered), 'b', 'c'
 
 
-void dev_init()
+void	devices_init()
 {
+	
 }
 
 
-int dev_register_major(major_t major, dev_driver_t *dev)
+int	devices_register_major(char type, major_t major, dev_driver_t *dev)
 {
-	if (registered[major])
+	if (type == 'b' || type == 'c')
-		return -1;	//driver already registered
+	{
-	drivers[major] = *dev;
+		if (drivers_registered[major])
-	return 0;
+			return -1;	//driver already registered
+		drivers[major] = *dev;
+		drivers_registered[major] = type;
+		return 0;
+	}
+	return -1;
 }
 

kernel/fs/devices.h

@@ -1,23 +1,27 @@
 // devices.h
 // Author: Josh Holtrop
 // Date: 08/02/04
-
+// Modified: 08/03/04
 
 #ifndef __HOS_DEVICES_H__
 #define __HOS_DEVICES_H__ __HOS_DEVICES_H__
 
+#include "hos_defines.h"
+
+#define MAJOR_CONSOLE 4
+
 typedef unsigned char major_t;
 typedef unsigned char minor_t;
 
 typedef struct {
-	int	(*block_read)(u32_t blockStart, u32_t blocks, void *buffer);
+	int	(*block_read)(minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
-	int	(*block_write)(u32_t blockStart, u32_t blocks, void *buffer);
+	int	(*block_write)(minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
-	int	(*char_read)(u64_t position);
+	int	(*char_read)(minor_t minor, u64_t position);
-	int	(*char_write)(u64_t position, int value);
+	int	(*char_write)(minor_t minor, u64_t position, int value);
 } dev_driver_t;
 
-void dev_init();
+void	devices_init();
-int dev_register_major(major_t major, dev_driver_t *dev);
+int	devices_register_major(char type, major_t major, dev_driver_t *dev);
 
 #endif
 

kernel/hos_defines.h

@@ -16,6 +16,8 @@
 
 #define NULL 0
 
+#define New(x) kmalloc(sizeof(x))
+
 typedef unsigned long long u64_t;
 typedef unsigned int u32_t;
 typedef unsigned short u16_t;

kernel/kernel.c

@@ -9,6 +9,8 @@
 #include "char/parallel.h"
 #include "kout.h"
 #include "lang/conv.h"
+#include "char/console.h"
+#include "fs/devices.h"
 
 mb_info_t mb_info_block;
 mb_mmap_t mb_mmap[MAX_MMAP];
@@ -83,42 +85,17 @@ int k_mbsave(mb_info_t *mbinfo, unsigned int mb_magic)
 /* Main kernel initialization routine */
 void k_init()
 {
-	kprintf("k_init()\n");
+	criticalCounter++;
-	k_enter_critical();
 	mm_init();
 	vmm_init();
+	devices_init();
+	console_init(6, 80, 25);
+	console_activate(1);
 	if (real_mode_module)
 	{
 		kprintf("Real mode module present\n");
 	}
-	u32_t alloc_size = 1;
-	void *addresses[32];
-	memsetd(addresses, 0, 32);
-	void *address;
-	int i;
-	for (i = -5; i < 5; i++)
-	{
-		kprintf("Counting down... %d\t0x%x\t%u\n", i, i, i);
-	}
-	for (i = 0; i < 32; i++)
-	{
-		kprintf("\e[31mAllocating %u (0x%x) bytes\e[0m,\tmm_freepages = %u...\n", alloc_size, alloc_size, mm_freepages);
-		address = kmalloc(alloc_size);
-		if (!address)
-			break;
-		addresses[i] = address;
-		alloc_size <<= 1;
-	}
-	for (i = 0; i < 32; i++)
-	{
-		if (!addresses[i])
-			break;
-		kprintf("\e[32mFreeing 0x%x\e[0m,\tmm_freepages = %u...\n", addresses[i], mm_freepages);
-		kfree(addresses[i]);
-	}
 
-//	dev_init();
-	kprintf("End of k_init()\n");
 	criticalCounter--;
 }
 

kernel/kout.h

@@ -7,7 +7,7 @@
 
 #include "hos_defines.h"
 
-void	printf(char *fmt, ...);
+void	kprintf(char *fmt, ...);
 void	putHex(u32_t number);
 void	kio_putBCD(u32_t bcd);
 void	putc(int c);

kernel/lang/asmfuncs.asm

@@ -134,6 +134,29 @@ _memcpy:
 	ret
 
 
+;copies memory of n words (n*2 bytes) from src to destination
+;void memcpyw(void *dest, void *src, dword n);
+[global _memcpyw]
+_memcpyw:
+	push	ebp
+	mov	ebp, esp
+	push	esi
+	push	edi
+	push	ecx
+	mov	edi, [ebp+8]
+	mov	esi, [ebp+12]
+	mov	ecx, [ebp+16]
+
+	cld
+	rep	movsw
+
+	pop	ecx
+	pop	edi
+	pop	esi
+	pop	ebp
+	ret
+
+
 ;copies memory of n dwords (n*4 bytes) from src to destination
 ;void memcpyd(void *dest, void *src, dword n);
 [global _memcpyd]

kernel/lang/asmfuncs.h

@@ -15,6 +15,7 @@ void writeCursorPosition(u32_t pos);
 u32_t getCursorPosition();
 void strcpy(char *dest, const char *src);
 void memcpy(void *dest, const void *src, u32_t n);
+void memcpyw(void *dest, const void *src, u32_t n);
 void memcpyd(void *dest, const void *src, u32_t n);
 void *memset(void *buffer, int c, int num);
 void *memsetw(void *buffer, int c, int num);