started big cleanup!

10 files changed, 898 insertions, 0 deletions

diff --git a/xxx/lib/buffer/ringbuffer.c b/xxx/lib/buffer/ringbuffer.c
new file mode 100644
index 0000000..a121df1
--- /dev/null
+++ b/xxx/lib/buffer/ringbuffer.c
@@ -0,0 +1,76 @@
+// can handle one buffer for a start.
+// later make it reentrant and manage multiple buffers!
+// todo: syncing access to buffer.
+
+#define FOOLOS_MODULE_NAME "ringbuffer"
+
+#include "ringbuffer.h"
+#include "kernel/x86.h"
+#include "lib/logger/log.h"
+#include "kernel/spinlock.h"
+
+#define RINGBUFFER_SIZE 10
+static int size=RINGBUFFER_SIZE;
+static volatile int front=RINGBUFFER_SIZE-1;
+static volatile int back=RINGBUFFER_SIZE-1;
+static volatile char buf[RINGBUFFER_SIZE];
+
+static spinlock sl=9;
+
+bool ringbuffer_put(char c)
+{
+
+    x86_int_disable();
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"put wants lock");
+    lock_spin(sl);
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"locked by put");
+
+    if((back-1+size)%size==front)
+    {
+	lock_release(sl);
+	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"unlocked by put");
+	x86_int_enable();
+	return false;
+    }
+
+    buf[back]=c;
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"put %d %d (%c)", back, front,c);
+    back--;
+    back+=size;
+    back%=size;
+
+    lock_release(sl);
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"unlocked by put");
+    x86_int_enable();
+    
+    return true;
+}
+
+bool ringbuffer_get(char *c)
+{
+    x86_int_disable();
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"get wants lock");
+    lock_spin(sl);
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"locked by get");
+    if(front==back)
+    {
+	lock_release(sl);
+	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"unlocked by get");
+	x86_int_enable();
+	*c='_';
+	return false;
+    }
+
+    *c=buf[front];
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"get %d %d (%c)", back, front,*c);
+
+    front--;
+    front+=size;
+    front%=size;
+
+    lock_release(sl);
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"unlocked by get");
+    x86_int_enable();
+
+    return true;
+}
diff --git a/xxx/lib/buffer/ringbuffer.h b/xxx/lib/buffer/ringbuffer.h
new file mode 100644
index 0000000..038e33a
--- /dev/null
+++ b/xxx/lib/buffer/ringbuffer.h
@@ -0,0 +1,3 @@
+#include <stdbool.h>
+bool ringbuffer_put(char c);
+bool ringbuffer_get(char *c);
diff --git a/xxx/lib/logger/log.c b/xxx/lib/logger/log.c
new file mode 100644
index 0000000..430f982
--- /dev/null
+++ b/xxx/lib/logger/log.c
@@ -0,0 +1,94 @@
+#define FOOLOS_MODULE_NAME "log"
+
+#include <stdarg.h>
+#include <stdbool.h>
+
+#include "log.h"
+#include "kernel/config.h"
+#include "terminal/vt52.h"
+#include "lib/printf/printf.h"
+#include "kernel/timer.h"
+
+
+static char buffer[LOG_BUF_SIZE];
+static int first=0;
+static int last=0;
+static bool init=true;// 
+
+static void init_log()
+{
+}
+
+void log(char *module_name, int log_level, char *format_string, ...)
+{
+
+    #ifdef FOOLOS_LOG_OFF
+    return;
+    #endif
+
+    if(log_level<FOOLOS_LOG_INFO)return;
+
+    char buf_info[256];
+    char buf_log[256];
+    char buf_time[20];
+
+    uint32_t t=timer_get_ticks();
+    uint32_t s=t/25;
+    uint32_t ms=t*1000/25-1000*s;
+
+    tfp_sprintf(buf_time,"[%3d.%05d]",s,ms);
+
+    va_list va;
+    va_start(va,format_string);
+    tfp_vsprintf(buf_info,format_string,va);
+    va_end(va);
+
+    tfp_sprintf(buf_log,"%s %s: %s\n",buf_time,module_name,buf_info);
+
+    if(init)console_put_str_gray(buf_log);
+
+    for(int i=0;buf_log[i]!=0;i++)
+    {
+	buffer[last]=buf_log[i];
+	last=(last+1)%LOG_BUF_SIZE;
+	if(first<last)if(last-first>=LOG_BUF_SIZE)first=(first+1)%LOG_BUF_SIZE;
+	if(last>first)if(LOG_BUF_SIZE-last+first>=LOG_BUF_SIZE)first=(first+1)%LOG_BUF_SIZE;
+    }
+
+
+}
+
+void panic(char *module_name,  char *message)
+{
+    char buf_log[256];
+    tfp_sprintf(buf_log,"KERNEL PANIC !! %s: %s\n",module_name,message);
+    //console_put_str_red(buf_log);
+
+    while(1)
+    {
+        asm volatile("cli");
+	asm volatile("hlt");
+    }
+
+}
+
+// unused shit!
+/*
+static void log_log()
+{
+    #ifdef FOOLOS_LOG_OFF
+    return;
+    #endif
+
+    char buf_log[256];
+    tfp_sprintf(buf_log,"[  0.00000] log: buffer state: first=%d, last=%d, buf_size=%d\n",first,last,LOG_BUF_SIZE);
+    console_put_str_gray(buf_log);
+    for(int i=first;i!=last;i++)
+    {
+	console_put_char_gray(buffer[i]);
+
+    }
+
+    init=true;
+}
+*/
diff --git a/xxx/lib/logger/log.h b/xxx/lib/logger/log.h
new file mode 100644
index 0000000..da27340
--- /dev/null
+++ b/xxx/lib/logger/log.h
@@ -0,0 +1,14 @@
+#ifndef FOOLOS_LOG_H
+#define FOOLOS_LOG_H
+
+#define FOOLOS_LOG_ERROR 5
+#define FOOLOS_LOG_WARNING 4
+#define FOOLOS_LOG_INFO 3
+#define FOOLOS_LOG_DEBUG 2
+#define FOOLOS_LOG_FINE 1
+
+void log(char *module_name, int prio, char *format_string, ...);
+void panic(char *module_name, char *format_string);
+void log_log();
+
+#endif
diff --git a/xxx/lib/printf/printf.c b/xxx/lib/printf/printf.c
new file mode 100644
index 0000000..23d3d46
--- /dev/null
+++ b/xxx/lib/printf/printf.c
@@ -0,0 +1,250 @@
+/*

+ * Copyright (c) 2004,2012 Kustaa Nyholm / SpareTimeLabs

+ *

+ * All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without modification, 

+ * are permitted provided that the following conditions are met:

+ *

+ * Redistributions of source code must retain the above copyright notice, this list 

+ * of conditions and the following disclaimer.

+ * 

+ * Redistributions in binary form must reproduce the above copyright notice, this 

+ * list of conditions and the following disclaimer in the documentation and/or other

+ * materials provided with the distribution.

+ *  

+ * Neither the name of the Kustaa Nyholm or SpareTimeLabs nor the names of its 

+ * contributors may be used to endorse or promote products derived from this software 

+ * without specific prior written permission.

+ * 

+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 

+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 

+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 

+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 

+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 

+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 

+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 

+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 

+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY

+ * OF SUCH DAMAGE.

+ */

+

+#include "printf.h"

+

+typedef void (*putcf) (void*,char);

+static putcf stdout_putf;

+static void* stdout_putp;

+

+

+#ifdef PRINTF_LONG_SUPPORT

+

+static void uli2a(unsigned long int num, unsigned int base, int uc,char * bf)

+	{

+	int n=0;

+	unsigned int d=1;

+	while (num/d >= base)

+		d*=base;		 

+	while (d!=0) {

+		int dgt = num / d;

+		num%=d;

+		d/=base;

+		if (n || dgt>0|| d==0) {

+			*bf++ = dgt+(dgt<10 ? '0' : (uc ? 'A' : 'a')-10);

+			++n;

+			}

+		}

+	*bf=0;

+	}

+

+static void li2a (long num, char * bf)

+	{

+	if (num<0) {

+		num=-num;

+		*bf++ = '-';

+		}

+	uli2a(num,10,0,bf);

+	}

+

+#endif

+

+static void ui2a(unsigned int num, unsigned int base, int uc,char * bf)

+	{

+	int n=0;

+	unsigned int d=1;

+	while (num/d >= base)

+		d*=base;		

+	while (d!=0) {

+		int dgt = num / d;

+		num%= d;

+		d/=base;

+		if (n || dgt>0 || d==0) {

+			*bf++ = dgt+(dgt<10 ? '0' : (uc ? 'A' : 'a')-10);

+			++n;

+			}

+		}

+	*bf=0;

+	}

+

+static void i2a (int num, char * bf)

+	{

+	if (num<0) {

+		num=-num;

+		*bf++ = '-';

+		}

+	ui2a(num,10,0,bf);

+	}

+

+static int a2d(char ch)

+	{

+	if (ch>='0' && ch<='9') 

+		return ch-'0';

+	else if (ch>='a' && ch<='f')

+		return ch-'a'+10;

+	else if (ch>='A' && ch<='F')

+		return ch-'A'+10;

+	else return -1;

+	}

+

+static char a2i(char ch, char** src,int base,int* nump)

+	{

+	char* p= *src;

+	int num=0;

+	int digit;

+	while ((digit=a2d(ch))>=0) {

+		if (digit>base) break;

+		num=num*base+digit;

+		ch=*p++;

+		}

+	*src=p;

+	*nump=num;

+	return ch;

+	}

+

+static void putchw(void* putp,putcf putf,int n, char z, char* bf)

+	{

+	char fc=z? '0' : ' ';

+	char ch;

+	char* p=bf;

+	while (*p++ && n > 0)

+		n--;

+	while (n-- > 0) 

+		putf(putp,fc);

+	while ((ch= *bf++))

+		putf(putp,ch);

+	}

+

+void tfp_format(void* putp,putcf putf,char *fmt, va_list va)

+	{

+	char bf[12];

+    

+	char ch;

+

+

+	while ((ch=*(fmt++))) {

+		if (ch!='%') 

+			putf(putp,ch);

+		else {

+			char lz=0;

+#ifdef 	PRINTF_LONG_SUPPORT

+			char lng=0;

+#endif

+			int w=0;

+			ch=*(fmt++);

+			if (ch=='0') {

+				ch=*(fmt++);

+				lz=1;

+				}

+			if (ch>='0' && ch<='9') {

+				ch=a2i(ch,&fmt,10,&w);

+				}

+#ifdef 	PRINTF_LONG_SUPPORT

+			if (ch=='l') {

+				ch=*(fmt++);

+				lng=1;

+			}

+#endif

+			switch (ch) {

+				case 0: 

+					goto abort;

+				case 'u' : {

+#ifdef 	PRINTF_LONG_SUPPORT

+					if (lng)

+						uli2a(va_arg(va, unsigned long int),10,0,bf);

+					else

+#endif

+					ui2a(va_arg(va, unsigned int),10,0,bf);

+					putchw(putp,putf,w,lz,bf);

+					break;

+					}

+				case 'd' :  {

+#ifdef 	PRINTF_LONG_SUPPORT

+					if (lng)

+						li2a(va_arg(va, unsigned long int),bf);

+					else

+#endif

+					i2a(va_arg(va, int),bf);

+					putchw(putp,putf,w,lz,bf);

+					break;

+					}

+				case 'x': case 'X' : 

+#ifdef 	PRINTF_LONG_SUPPORT

+					if (lng)

+						uli2a(va_arg(va, unsigned long int),16,(ch=='X'),bf);

+					else

+#endif

+					ui2a(va_arg(va, unsigned int),16,(ch=='X'),bf);

+					putchw(putp,putf,w,lz,bf);

+					break;

+				case 'c' : 

+					putf(putp,(char)(va_arg(va, int)));

+					break;

+				case 's' : 

+					putchw(putp,putf,w,0,va_arg(va, char*));

+					break;

+				case '%' :

+					putf(putp,ch);

+				default:

+					break;

+				}

+			}

+		}

+	abort:;

+	}

+

+

+void init_printf(void* putp,void (*putf) (void*,char))

+	{

+	stdout_putf=putf;

+	stdout_putp=putp;

+	}

+

+void tfp_printf(char *fmt, ...)

+	{

+	va_list va;

+	va_start(va,fmt);

+	tfp_format(stdout_putp,stdout_putf,fmt,va);

+	va_end(va);

+	}

+

+static void putcp(void* p,char c)

+	{

+	*(*((char**)p))++ = c;

+	}

+

+

+

+void tfp_vsprintf(char* s,char *fmt, va_list va)

+	{

+	tfp_format(&s,putcp,fmt,va);

+	putcp(&s,0);

+	}

+

+void tfp_sprintf(char* s,char *fmt, ...)

+	{

+	va_list va;

+	va_start(va,fmt);

+	tfp_vsprintf(s,fmt,va);

+	va_end(va);

+	}

+

+

diff --git a/xxx/lib/printf/printf.h b/xxx/lib/printf/printf.h
new file mode 100644
index 0000000..0e65915
--- /dev/null
+++ b/xxx/lib/printf/printf.h
@@ -0,0 +1,125 @@
+/*

+File: printf.h

+ 

+Copyright (c) 2004,2012 Kustaa Nyholm / SpareTimeLabs

+

+All rights reserved.

+

+Redistribution and use in source and binary forms, with or without modification, 

+are permitted provided that the following conditions are met:

+

+Redistributions of source code must retain the above copyright notice, this list 

+of conditions and the following disclaimer.

+

+Redistributions in binary form must reproduce the above copyright notice, this 

+list of conditions and the following disclaimer in the documentation and/or other

+materials provided with the distribution.

+ 

+Neither the name of the Kustaa Nyholm or SpareTimeLabs nor the names of its 

+contributors may be used to endorse or promote products derived from this software 

+without specific prior written permission.

+

+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 

+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 

+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 

+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 

+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 

+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 

+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 

+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 

+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY

+OF SUCH DAMAGE.

+

+----------------------------------------------------------------------

+

+This library is realy just two files: 'printf.h' and 'printf.c'.

+

+They provide a simple and small (+200 loc) printf functionality to 

+be used in embedded systems.

+

+I've found them so usefull in debugging that I do not bother with a 

+debugger at all.

+

+They are distributed in source form, so to use them, just compile them 

+into your project. 

+

+Two printf variants are provided: printf and sprintf. 

+

+The formats supported by this implementation are: 'd' 'u' 'c' 's' 'x' 'X'.

+

+Zero padding and field width are also supported.

+

+If the library is compiled with 'PRINTF_SUPPORT_LONG' defined then the 

+long specifier is also

+supported. Note that this will pull in some long math routines (pun intended!)

+and thus make your executable noticably longer.

+

+The memory foot print of course depends on the target cpu, compiler and 

+compiler options, but a rough guestimate (based on a H8S target) is about 

+1.4 kB for code and some twenty 'int's and 'char's, say 60 bytes of stack space. 

+Not too bad. Your milage may vary. By hacking the source code you can 

+get rid of some hunred bytes, I'm sure, but personally I feel the balance of 

+functionality and flexibility versus  code size is close to optimal for

+many embedded systems.

+

+To use the printf you need to supply your own character output function, 

+something like :

+

+void putc ( void* p, char c)

+	{

+	while (!SERIAL_PORT_EMPTY) ;

+	SERIAL_PORT_TX_REGISTER = c;

+	}

+

+Before you can call printf you need to initialize it to use your 

+character output function with something like:

+

+init_printf(NULL,putc);

+

+Notice the 'NULL' in 'init_printf' and the parameter 'void* p' in 'putc', 

+the NULL (or any pointer) you pass into the 'init_printf' will eventually be 

+passed to your 'putc' routine. This allows you to pass some storage space (or 

+anything realy) to the character output function, if necessary. 

+This is not often needed but it was implemented like that because it made 

+implementing the sprintf function so neat (look at the source code).

+

+The code is re-entrant, except for the 'init_printf' function, so it 

+is safe to call it from interupts too, although this may result in mixed output. 

+If you rely on re-entrancy, take care that your 'putc' function is re-entrant!

+

+The printf and sprintf functions are actually macros that translate to 

+'tfp_printf' and 'tfp_sprintf'. This makes it possible

+to use them along with 'stdio.h' printf's in a single source file. 

+You just need to undef the names before you include the 'stdio.h'.

+Note that these are not function like macros, so if you have variables

+or struct members with these names, things will explode in your face.

+Without variadic macros this is the best we can do to wrap these

+fucnction. If it is a problem just give up the macros and use the

+functions directly or rename them.

+

+For further details see source code.

+

+regs Kusti, 23.10.2004

+*/

+

+

+#ifndef __TFP_PRINTF__

+#define __TFP_PRINTF__

+

+#include <stdarg.h>

+

+void init_printf(void* putp,void (*putf) (void*,char));

+

+void tfp_printf(char *fmt, ...);

+void tfp_sprintf(char* s,char *fmt, ...);

+void tfp_vsprintf(char* s,char *fmt, va_list va);

+

+void tfp_format(void* putp,void (*putf) (void*,char),char *fmt, va_list va);

+

+#define printf tfp_printf 

+#define sprintf tfp_sprintf 

+

+#endif

+

+

+

diff --git a/xxx/lib/string/string.c b/xxx/lib/string/string.c
new file mode 100644
index 0000000..729c509
--- /dev/null
+++ b/xxx/lib/string/string.c
@@ -0,0 +1,37 @@
+#include <stdbool.h>
+
+//length 0 for null terminated strings;
+bool strcmp(char *str1, char *str2, int length)
+{
+    int i=0;
+    while(true)
+    {
+	if(str1[i]!=str2[i])return false;
+	i++;
+
+	if(i==length) return true;
+	if(str1[i]==0||str2[i]==0)
+	{
+	    if(str1[i]==str2[i])return true;
+	    return false;
+	}
+    }
+
+}
+
+void* memcpy(void* restrict dstptr, const void* restrict srcptr, int size)
+{
+	unsigned char* dst = (unsigned char*) dstptr;
+	const unsigned char* src = (const unsigned char*) srcptr;
+	for ( int i = 0; i < size; i++ )
+		dst[i] = src[i];
+	return dstptr;
+}
+
+int strlen(const char* string)
+{
+	int result = 0;
+	while ( string[result] )
+		result++;
+	return result;
+}
diff --git a/xxx/lib/string/string.h b/xxx/lib/string/string.h
new file mode 100644
index 0000000..a804de9
--- /dev/null
+++ b/xxx/lib/string/string.h
@@ -0,0 +1,3 @@
+#include <stdbool.h>
+bool strcmp(char *str1, char *str2, int length);
+void* memcpy(void* restrict dstptr, const void* restrict srcptr, int size);
diff --git a/xxx/video/vesa.c b/xxx/video/vesa.c
new file mode 100644
index 0000000..a5ee4e5
--- /dev/null
+++ b/xxx/video/vesa.c
@@ -0,0 +1,249 @@
+//http://wiki.osdev.org/GUI
+#include <stdarg.h>
+#include "kernel/mem.h"
+#include "vesa.h"
+
+#include "lib/logger/log.h"	// logger facilities
+#include "lib/printf/printf.h"
+#define FOOLOS_MODULE_NAME "vesa"
+
+#define FOOLSOS_SHOW_VESAMODES
+
+
+static foolfont *deffont;
+static vbemodeinfo *VbeModeInfoBlock;
+
+static int console_x;
+static int console_y;
+
+static int console_lines;
+static int console_cols;
+
+static uint8_t* buffer;
+static uint8_t* physbase;
+
+void PutConsoleNL();
+void PutPixel(int x,int y, int color);
+
+void vesa_switch_buffers()
+{
+    for(int i=0;i<800*600*2;i++)physbase[i]=buffer[i];
+    
+}
+
+void vesa_put_rect(int x, int y, int w , int h, int color)
+{
+    for(int i=x;i<x+w;i++)
+	for(int j=y;j<y+h;j++)
+	    PutPixel(i,j,color);
+}
+
+void vesa_clear_screen()
+{
+    vesa_put_rect(0,0,VbeModeInfoBlock->Xres, VbeModeInfoBlock->Yres, 0xffffff);
+}
+
+
+void vesa_set_physbase(uint32_t addr)
+{
+    VbeModeInfoBlock->physbase=addr;
+}
+
+    // 
+    // We want to get output to the screen as fast as possible!
+    //
+    // Our Fool-Boot-Loader did set up VESA already for us.
+    // The desired VESA mode is hardcoded in [boot/mbr.asm].
+    //
+    // The [vesa_init(...)] function requires:
+    //
+    //	* the addresses of the vbeinfo struct
+    //	* the address of the vbemodeinfo struct (for selected mode).
+    //	* Fool Font loaded inside ramimage
+    //
+    //	The first two paramters are hardcoded in [boot/mbr.asm],
+    //	while the last one is set in the Makefile. The font binary
+    //	is integrated in the kernel image.
+    //
+    //  this function returns the physical base address of 
+    //  our video memory 
+    //
+    
+uint32_t vesa_init(vbeinfo *info,vbemodeinfo *mode,foolfont *rawfont)
+{
+    //the only functionallu important init lines! (rest is log)
+    VbeModeInfoBlock=mode;
+    deffont=rawfont;
+    console_x=0;
+    console_y=0;
+
+    int line_height=12;
+    int col_width=10;
+    console_lines=mode->Yres/line_height;
+    console_cols=mode->Xres/col_width;
+    
+    // vesa info
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"vbe version: 0x%x / video mode ptr: 0x%x 0x%x",
+	    info->VbeVersion, info->VideoModePtr[1], info->VideoModePtr[0]);
+
+    // vesa info on selected mode:
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"colors r:%d 0x%x g:%d 0x%x b:%d 0x%x",
+	    mode->red_position,mode->red_mask, 
+	    mode->green_position,mode->green_mask, 
+	    mode->blue_position,mode->blue_mask);
+
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"res: %d * %d / banks: %d / attr: 0x%x",
+	    mode->Xres, mode->Yres, mode->banks, mode->attributes);
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"bpp: %d / physbase: 0x%x",
+	    mode->bpp,mode->physbase);
+
+     // vesa modes
+     // todo: take segment from vbeinfo!
+#ifdef FOOLSOS_SHOW_VESAMODES
+    uint16_t *modeptr=info->VideoModePtr[0];
+
+    while(*modeptr!=0xffff&&*modeptr!=0)
+    {
+	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"mode supported : 0x%X", (*modeptr));
+	modeptr++;
+    }
+#endif
+
+
+    return VbeModeInfoBlock->physbase;   
+
+}
+
+void PutPixel(int x,int y, int color){
+
+    //do not write memory outside the screen buffer, check parameters against the VBE mode info
+    if (x<0 || x>VbeModeInfoBlock->Xres|| y<0 || y>VbeModeInfoBlock->Yres) return;
+    if (x) x = (x*(VbeModeInfoBlock->bpp>>3)); // get bytes (divide by 8)
+    if (y) y = (y*VbeModeInfoBlock->pitch);
+    uint8_t *cTemp=VbeModeInfoBlock->physbase;
+
+    cTemp[x+y] =  (uint8_t)(color & 0xff);
+    cTemp[x+y+1] = (uint8_t)((color>>8) & 0xff);
+    //cTemp[x+y+2] = (uint8_t)((color>>16) & 0xff);
+    
+ }
+
+
+void PutFont(char c, int x,int y, int color)
+{
+
+    int fnt=0x126-0x20;
+
+    if(c>=0x20&&c<=0x126)fnt=c-0x20;
+
+    int posx, posy, sizex=8, sizey=10;
+
+    for(posx=x;posx<x+sizex;posx++)
+    {
+
+	for(posy=y;posy<y+sizey;posy++)
+	{
+	    if(deffont[fnt].line[posy-y]&1<<(7-(posx-x)))
+	    {
+		PutPixel(posx,posy,color);
+	    }
+	    else
+	    {
+		PutPixel(posx,posy,0);
+	    }
+
+	}
+    }
+
+}
+
+void PutString(char *str, int x,int y, int color, va_list va)
+{
+
+    char buff[256];
+    tfp_sprintf(buff,str,va);
+    str=buff;
+
+    int i=x;
+    while((*str)!=0)
+    {
+	PutFont(*str, i,y, color);
+	i+=9; // spacing 
+	str++;
+    }
+
+}
+
+void PutConsoleChar(char c, int color)
+{
+	if(c=='\n')
+	{
+	    PutConsoleNL();
+	    return;
+	}
+	PutFont(c, console_x*10,console_y*12, color);
+	console_x++;
+
+
+	#ifdef FOOLOS_CONSOLE_AUTOBREAK
+	if(console_x>=console_cols)PutConsoleNL();
+	#endif
+}
+
+void PutConsole(char *str, int color)
+{
+
+    while((*str)!=0)
+    {
+	PutConsoleChar(*str,color);
+	str++;
+    }
+
+}
+void PutConsoleNL()
+{
+    console_x=0;
+    console_y++;
+    if(console_y>=console_lines-5)console_y=0;
+
+    for(int i=0;i<console_cols;i++)
+    {
+	PutFont(' ',i*10,(console_y)*12,0);
+    }
+}
+
+static int boxx;
+static int boxy;
+////////////////
+void vesa_render()
+{
+    vesa_clear_screen();
+    vesa_put_rect(100,100,VbeModeInfoBlock->Xres-200,VbeModeInfoBlock->Yres-200,0xff);
+    vesa_put_rect(boxx-10,boxy-10,20,20,0x999999);
+
+    boxx++;
+//    boxy+=boxx;
+    if(boxx>VbeModeInfoBlock->Xres-100)boxx=100;
+  //  if(boxy>VbeModeInfoBlock->Yres-200)boxy=200;
+
+
+    vesa_switch_buffers();
+}
+
+/*
+void vesa_init_doublebuff()
+{
+    boxx=300;
+    boxy=300;
+
+    int blocks=800*600*2/4096+1;
+    physbase=VbeModeInfoBlock->physbase;
+    buffer=pmmngr_alloc_blocks(blocks);
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Init buffer of %d blocks at 0x%08X",blocks,buffer);
+
+    VbeModeInfoBlock->physbase=buffer;
+}
+*/
+
+
+
diff --git a/xxx/video/vesa.h b/xxx/video/vesa.h
new file mode 100644
index 0000000..371e944
--- /dev/null
+++ b/xxx/video/vesa.h
@@ -0,0 +1,47 @@
+#include <stdint.h>
+
+typedef struct foolfont_struct
+{
+    uint8_t line[10]; //every single fool font consists of 10 lines a 8 bit
+
+}foolfont;
+
+typedef struct vbeinfo_struct{
+   char VbeSignature[4];             // == "VESA"
+   uint16_t VbeVersion;                 // == 0x0300 for VBE 3.0
+   uint16_t OemStringPtr[2];            // isa vbeFarPtr
+   uint8_t Capabilities[4];
+   uint16_t VideoModePtr[2];         // isa vbeFarPtr
+   uint16_t TotalMemory;             // as # of 64KB blocks
+}vbeinfo;
+
+
+typedef struct ModeInfoBlock {
+  uint16_t attributes;
+  uint8_t winA,winB;
+  uint16_t granularity;
+  uint16_t winsize;
+  uint16_t segmentA, segmentB;
+  uint16_t realFctPtr[2];
+//  VBE_FAR(realFctPtr);
+  uint16_t pitch; // bytes per scanline
+ 
+  uint16_t Xres, Yres;
+  uint8_t Wchar, Ychar, planes, bpp, banks;
+  uint8_t memory_model, bank_size, image_pages;
+  uint8_t reserved0;
+ 
+  uint8_t red_mask, red_position;
+  uint8_t green_mask, green_position;
+  uint8_t blue_mask, blue_position;
+  uint8_t rsv_mask, rsv_position;
+  uint8_t directcolor_attributes;
+ 
+  volatile  uint32_t physbase;  // your LFB (Linear Framebuffer) address ;)
+  uint32_t reserved1;
+  uint16_t reserved2;
+}vbemodeinfo;
+
+uint32_t vesa_init(vbeinfo *info,vbemodeinfo *mode,foolfont *rawfont);
+void PutConsoleChar(char c, int color);
+void PutConsole(char *str, int color);