#include "vga.h"
#include "memory.h"
#include "asm.h"
#include "port.h"
#include "types.h"
#include "modes.c"
#include "8x8fnt.c"
#include "8x16fnt.c"

/* Registres VGAs */

#define sequencer 0x3c4
#define misc 0x3c2
#define ccrt 0x3D4
#define attribs 0x3c0
#define graphics 0x3ce
#define state 0x3da

/* Taille d'un plan de bit */

#define planesize 0x10000

static u16 resX,resY,color,splitY;        /* resolution x,y en caractères et profondeur */	

static u8  pages,activepage,showedpage; /* nombre de pages disponibles N° de la page active*/
static u32 linesize,pagesize;/* Taille d'une ligne et d'une page */
static u8  vmode=0xFF; /* mode en cours d'utilisation */
static u32 basemem; 	     /* Adresse de la mémoire vidéo */
static bool scrolling,graphic,blink;/* Activation du défilement, Flag du mode graphique */

/*******************************************************************************/

/* Donne la resolution max horizontale */

u16 getxres()
{
return resX;
}

/*******************************************************************************/

/* Donne la profondeur en bit */

u8 getdepth()
{
return color;
}

/*******************************************************************************/

/* Donne la resolution max verticale */

u16 getyres()
{
return resY-splitY;
}

/*******************************************************************************/

/* Donne le nombre max de page ecran dispo */

u16 getnbpages()
{
return pages;
}

/*******************************************************************************/

/* Fixe la page ecran de travail */

void setpage(u8 page)
{
if (page<pages) activepage=page;
}

/*******************************************************************************/

/* Recupere la page ecran de travail */

u8 getpage()
{
return activepage;
}

/*******************************************************************************/

/* Affiche la page ecran specifié */

void showpage(u8 page)
{
if (page<pages) 
{
u16 addr;
  addr=page*pagesize/2;
	outb(ccrt,  0x0C);
	outb(ccrt+1,(addr>>8));
	outb(ccrt,  0x0D);
	outb(ccrt+1,(addr&0xFF));	
	showedpage=page;
}
}
/*******************************************************************************/

/* Sépare l'écran en 2 a partir de la ligne Y */

void split(u16 y)
{
u16 addr;
if (graphic==0)
  addr=(y<<3);
else
  addr=y; 
  /* line compare pour ligne atteinte */
	outb(ccrt,  0x18);
	outb(ccrt+1,(addr&0xFF));
  /* overflow pour le bit 8 */
  
	outb(ccrt,  0x07);
	outb(ccrt+1,(inb(ccrt+1) & ~16)|((addr>>4)&16));

 /*  Maximum Scan Line pour le bit 9 */ 	
	
	outb(ccrt,  0x09);
	outb(ccrt+1,(inb(ccrt+1) & ~64)|((addr>>3)&64));
	splitY=y;
}
/*******************************************************************************/

/* Sépare l'écran en 2 a partir de la ligne Y */

void unsplit()
{
  /* line compare pour ligne atteinte */
	outb(ccrt,  0x18);
	outb(ccrt+1,0);
  /* overflow pour le bit 8 */
  
	outb(ccrt,  0x07);
	outb(ccrt+1,inb(ccrt+1) & ~16);

 /*  Maximum Scan Line pour le bit 9 */ 	
	
	outb(ccrt,  0x09);
	outb(ccrt+1,inb(ccrt+1) & ~64);
	splitY=0;
}

/*******************************************************************************/

/* Attend la retrace verticale */

void waitvretrace (void)
{
	while ((inb(state)&8)==0);
}

/*******************************************************************************/

/* Attend la retrace horizontale */

void waithretrace (void)
{
	while ((inb(state)&1)==0);
}

/*******************************************************************************/

/* Active l'affichage du curseur de texte */

void enablecursor (void)
{
	u8 curs;
	/* active le curseur hardware */
	outb(ccrt, 10);
	curs = inb(ccrt+1)&~32;
	outb(ccrt+1, curs);	
}

/*******************************************************************************/

/* Desactive l'affichage du curseur de texte */

void disablecursor (void)
{
	u8 curs;
	/* Desactive le curseur hardware */
	outb(ccrt, 10);
	curs = inb(ccrt+1)|32;
	outb(ccrt+1, curs);		
}

/*******************************************************************************/

/* Active le scrolling en cas de débordement d'écran */

void enablescroll (void)

{
	scrolling=true;
}

/*******************************************************************************/

/* Desactive le scrolling en cas de débordement d'écran */

void disablescroll (void)
{
	scrolling=false;
}

/*******************************************************************************/

/* Utilise le plan de bit spécifié */

void useplane(u8 plan)
{
	u8 mask;
	plan &= 3;
	mask = 1 << plan;
	/* choisi le plan de lecture */
	outb(graphics, 4);
	outb(graphics+1, plan);
	/* choisi le plan d'ecriture */
	outb(sequencer, 2);
	outb(sequencer+1, mask);
}

/*******************************************************************************/

/* Renvoie l'adresse du segment video */

u32 getbase(void)
{
	u32 base;
	outb(graphics, 6);
	base = inb(graphics+1);
	base >>= 2;
	base &= 3;
	switch(base)
	{
	case 0:
	case 1:
		base = 0xA0000;
		break;
	case 2:
		base = 0xB0000;
		break;
	case 3:
		base = 0xB8000;
		break;
	}
	return base;
}

/*******************************************************************************/

/* efface l'écran */

void (*fill)(u8 attrib);


void fill_text (u8 attrib)
{
	memset((u8 *)(basemem+activepage*pagesize),' ',pagesize/2,2);
	memset((u8 *)(basemem+activepage*pagesize+1),attrib,pagesize/2,2);
}

void fill_chain (u8 attrib)
{
	memset((u8 *)(basemem+activepage*pagesize),attrib&0x0F,pagesize,1);
}

void fill_unchain (u8 attrib)
{
	int i;
	for(i=0;i<4;i++)
	{
		useplane(i);
		memset((u8 *)(basemem+activepage*pagesize),attrib&0x0F,pagesize,1);
	}
}

/*******************************************************************************/

/* fixe la position du curseur texte */

void gotoscr(u16 x,u16 y)
{
	u16 pos;
	if (splitY==0)
 pos=(showedpage*pagesize/2+x+y*resX);
 else
 pos=(x+y*resX);
  outb(ccrt,0x0F);
	outb(ccrt+1,(u8)(pos&0x00FF));	
	outb(ccrt,0x0E);
	outb(ccrt+1,(u8)((pos&0xFF00)>>8));				
}

/*******************************************************************************/

/* Fait defiler l'ecran de n lignes vers le haut */

void (*scroll)(u8 lines,u8 attrib);

void scroll_unchain(u8 lines,u8 attrib)
{
if (scrolling)
{
	u8 i;
	for(i=0;i<4;i++)
	{
		useplane(i);
		memcpy((u8*)(basemem+activepage*pagesize+linesize*8*lines),(u8*)basemem,pagesize-linesize*8*lines,1);
		memset((u8*)(basemem+activepage*pagesize+pagesize-linesize*8*lines),attrib&0x0F,linesize*8*lines,1);
	}
	}
}

void scroll_chain(u8 lines,u8 attrib)
{
if (scrolling)
{
	memcpy((u8*)basemem+activepage*pagesize+linesize*8*lines,(u8*)basemem+activepage*pagesize,pagesize-linesize*8*lines,1);
	memset((u8*)(basemem+activepage*pagesize+pagesize-linesize*8*lines),attrib&0x0F,linesize*8*lines,1);
}
}

void scroll_text(u8 lines,u8 attrib)
{
if (scrolling)
{
	memcpy((u8*)basemem+activepage*pagesize+linesize*lines,(u8*)basemem+activepage*pagesize,pagesize-linesize*lines,1);
	memset((u8*)(basemem+activepage*pagesize+pagesize-linesize*lines-2),' ',(linesize*lines)/2,2);
	memset((u8*)(basemem+activepage*pagesize+pagesize-linesize*lines-1),attrib,(linesize*lines)/2,2);
}
}

/*******************************************************************************/

/* Affiche le caractère a l'écran */

void (*showchar)(u16 coordx,u16 coordy,u8 thechar,u8 attrib);

void showchar_graphic(u16 coordx,u16 coordy,u8 thechar,u8 attrib)
{
	u8 x,y,pattern,set;
	for(y=0;y<8;y++)
	{
		pattern=font8x8[thechar*8+y];
		for(x=0;x<8;x++)
		{
			set=((pattern>>(7-x))&0x1);   /* mettre un ROL importé depuis asm */
			if (set==0)
			writepxl(coordx*8+x,coordy*8+y,((attrib&0xF0)>>8)*set);
			else
			writepxl(coordx*8+x,coordy*8+y,(attrib&0x0F)*set);			
		}
	}
}



void showchar_text(u16 coordx,u16 coordy,u8 thechar,u8 attrib)

{
	u8 *screen;		
	screen = (u8 *)basemem+activepage*pagesize+2*(coordx+coordy*resX);
	*screen = thechar;
	*(++screen) =attrib;
}

/*******************************************************************************/

/* Recupere le caractère a l'écran */

u8 (*getchar)(u16 coordx,u16 coordy);

u8 getchar_text(u16 coordx,u16 coordy)

{
	u8 *screen;		
	screen = (u8 *)basemem+activepage*pagesize+2*(coordx+coordy*resX);
	return *screen;
}

/*******************************************************************************/

/* Recupere les attributs a l'écran */

u8 (*getattrib)(u16 coordx,u16 coordy);

u8 getattrib_text(u16 coordx,u16 coordy)

{
	u8 *screen;		
	screen = (u8 *)basemem+activepage*pagesize+2*(coordx+coordy*resX)+1;
	return *screen;
}


/*******************************************************************************/

/* Ecrit un pixel a l'écran */

void (*writepxl)(u16 x, u16 y, u32 c);

void writepxl_1bit(u16 x, u16 y, u32 c)
{
	u8* off;
	u8 mask;
	c = (c & 1) * 0xFF;
	off = (u8*)(basemem+activepage*pagesize+linesize * y + x / 8);
	x = (x & 7) * 1;
	mask = 0x80 >> x;
	*off= ((*off) & ~mask) | (c & mask);
}

void writepxl_2bits(u16 x, u16 y, u32 c)
{
	u8 *off;
	u8 mask;
	c = (c & 3) * 0x55;
	off = (u8*)(basemem+activepage*pagesize+linesize * y + x / 4);
	x = (x & 3) * 2;
	mask = 0xC0 >> x;
	*off= ((*off) & ~mask) | (c & mask);
}

void writepxl_4bits(u16 x, u16 y, u32 c)
{
	u8*  off;
	u8   mask, p, pmask;
	off = (u8*)(basemem+activepage*pagesize+linesize * y + x / 8);
	x = (x & 7) * 1;
	mask = 0x80 >> x;
	pmask = 1;
	for(p = 0; p < 4; p++)
	{
		useplane(p);
		if(pmask & c)
		*off= ((*off) | mask);
		else
		*off= ((*off) & ~mask);
		pmask <<= 1;
	}
}

void writepxl_8bits(u16 x, u16 y, u32 c)
{
	u8* off;
	off = (u8*)(basemem+activepage*pagesize+linesize * y + x);
	*off=c;
}

void writepxl_8bitsunchain(u16 x, u16 y, u32 c)
{
	u8* off;
	off = (u8*)(basemem+activepage*pagesize+linesize * y + x / 4);
	useplane(x & 3);
	*off=c;
}

/*******************************************************************************/

/* Change le mode video courant */

u32 setvmode(u8 mode)
{
	u8 *def,gmode;
	/* Récupere la definition des registres VGA en fonction du mode
graphique : >0x80
text      : 0x00 - 0x7F
*/
	if (mode>=0x80)
	{
		gmode=mode-0x80;
		if (gmode>maxgraphmode) return 1; /* mode inexistant */	
		def=graphmodes[gmode];
		graphic=true;
	}
	else
	{
		if (mode>maxtextmode) return 1; /* mode inexistant */	
		def=textmodes[mode];
		graphic=false;
		loadfont(font8x8,8,1);
		loadfont(font8x16,16,0);
	}
	/* Initialise les registre "divers" */
	outb(misc,def[0]);
	/* Initialise les registre d'etat */
	outb(state,0x00);
	/* Initialise le séquenceur */
	outreg(sequencer,&def[1],5);
	/* Debloque le verouillage des registres controleur CRT */
	outb(ccrt,0x11);
	outb(ccrt+1,0x0E);
	/* Initialise le controleur CRT */	
	outreg(ccrt,&def[6],25);
	/* Initialise le controleur graphique */ 	
	outreg(graphics,&def[31],9);	 	
	inb(state);	
	/* Initialise le controleur d'attributs */	
	outregsame(attribs,&def[40],21);	
	inb(state);
	outb(attribs,0x20);
	/* Récupere depuis la table de définition des mode la résolution et la
profondeur (en bits) */
	resX=def[61];
	resY=def[62];
	color=def[63];	
	/* Initialise l'adresse des procedures de gestion graphique et les differentes
variables en fonction de la profondeur et du mode*/
	if (!graphic)
	{
		/* mode texte */
		linesize=resX*2;
		writepxl=NULL;           /* pas d'affichage de pixels */
		showchar=showchar_text;
		scroll=scroll_text;
		fill=fill_text;
		pagesize=resY*linesize;
		getchar=getchar_text;
		getattrib=getattrib_text;
	}
	else
	{
		switch(color)
		{
		case 1:
			/* mode N&B */
			linesize=resX;
			writepxl=writepxl_1bit;
			fill=fill_chain;
			scroll=scroll_chain;
			break;
		case 2:
			/* mode 4 couleurs */
			linesize=(resX<<1);
			writepxl=writepxl_2bits;
			fill=fill_chain;
			scroll=scroll_chain;
			break;
		case 4:
			/* mode 16 couleurs */
			linesize=resX;
			writepxl=writepxl_4bits;
			fill=fill_unchain;
			scroll=scroll_unchain;
			break;
		case 8:
			/* mode 256 couleurs */
			if (def[5]==0x0E)
			{
				/* mode chainé (plus rapide mais limité en mémoire) */
				linesize=(resX<<3);
				writepxl=writepxl_8bits;
				scroll=scroll_chain;
				fill=fill_chain;
			}
			else
			{
				/* mode non chainé */
				linesize=(resX<<1);
				writepxl=writepxl_8bitsunchain;
				scroll=scroll_unchain;
				fill=fill_unchain;
			}
			break;
		default:
			break;
		}
		showchar=showchar_graphic;
		pagesize=((resY*linesize)<<3);
	}
	/* calcul des variables d'état video */
	activepage=0;
	showedpage=0;
	splitY=0;
	vmode=mode;
	scrolling=1;
	pages=(planesize/pagesize);
	basemem=(def[20]<<8)+def[21]+getbase();		
	return 0;
}

/*******************************************************************************/

/* Récupère le mode vidéo en cours */

u8 getvmode(void)
{
	return vmode;
}

/*******************************************************************************/

/* Charge une nouvelle police de caractère */

u32 loadfont(u8* def,u8 size,u8 font)

{
	if (graphics==1) return 1;
	u8 oldregs[5]={0,0,0,0,0};
	u8* base;
	u16 i;
	if (font>7) return 1;	
	if (font<4)
	base = (u8 *)(getbase()+(font<<14));
	else
	base = (u8 *)(getbase()+((((font-4)<<1)+1)<<13));
	/* sauve les anciens registres */
	outb(sequencer,2);
	oldregs[0]=inb(sequencer+1);
	outb(sequencer,4);
	oldregs[1]=inb(sequencer+1);
	/* Adressage paire/impair desactivé (lineaire) */
	outb(sequencer+1, oldregs[1]|0x04);
	outb(graphics,4);
	oldregs[2]=inb(graphics+1);
	outb(graphics,5);
	oldregs[3]=inb(graphics+1);
	/* Adressage paire/impair desactivé (lineaire) */
	outb(graphics+1, oldregs[3]&~0x10);
	outb(graphics,6);
	oldregs[4]=inb(graphics+1);
	/* Adressage paire/impair desactivé (lineaire) */
	outb(graphics+1, oldregs[4] & ~0x02);
	/* utilisation du plan N°2 */
	useplane(2);	
	for(i=0; i < 256; i++)
	{
		memcpy(def,base+i*32,size,1);
		def += size;
	}
	outb(sequencer,2);
	outb(sequencer+1,oldregs[0]);
	outb(sequencer,4);
	outb(sequencer+1,oldregs[1]);
	outb(graphics,4);
	outb(graphics+1,oldregs[2]);
	outb(graphics,5);
	outb(graphics+1,oldregs[3]);
	outb(graphics,6);
	outb(graphics+1,oldregs[4]);
	return 0;
}

/*******************************************************************************/

/* Récupere le N° de la police de caractère en cours d'utilisation */

u8 getfont()
{
 u8 num,tmp;
  outb(sequencer,3);
  tmp=inb(sequencer+1);
  num=(tmp&0x03)|((tmp&0x10)>>2);
	return num;	
}

/*******************************************************************************/

/* Récupere le N° de la police de caractère en cours d'utilisation */

u8 getfont2()
{
 u8 num,tmp;
  outb(sequencer,3);
  tmp=inb(sequencer+1);
  num=((tmp&0x0C)>>2)|((tmp&0x20)>>3);
	return num;	
}


/*******************************************************************************/

/* Fixe le N° de la police de caractère a utiliser */

void setfont(u8 num)
{
	num&=0x07;
	outb(sequencer,3);
	outb(sequencer+1,(inb(sequencer+1)&0xEC)|((num&0x03)+((num&0x04)<<2)));	
}

/*******************************************************************************/

/* Fixe le N° de la police de caractère a utiliser */

void setfont2(u8 num)
{
	num&=0x07;
	outb(sequencer,3);
	outb(sequencer+1,(inb(sequencer+1)&0xD3)|(((num&0x03)<<2)+((num&0x04)<<3)));	
}

/*******************************************************************************/

/* Fixe le N° de la police de caractère a utiliser */

void enableblink()
{
	outb(ccrt,0x10);
	outb(ccrt+1,(inb(sequencer+1)|0x04));	
}

/*******************************************************************************/

/* Fixe le N° de la police de caractère a utiliser */

void disableblink()
{
	outb(ccrt,0x10);
	outb(ccrt+1,(inb(sequencer+1)&~0x04));	
}

/*******************************************************************************/