uemacs/ibmpc.c

/* 	IBMPC.C
 *
 * The routines in this file provide support for the IBM-PC and other
 * compatible terminals. It goes directly to the graphics RAM to do
 * screen output. It compiles into nothing if not an IBM-PC driver
 * Supported monitor cards include CGA, MONO and EGA.
 *
 *	modified by Petri Kutvonen
 */

#define	termdef	1		/* don't define "term" external */

#include        <stdio.h>
#include	"estruct.h"
#include        "edef.h"

#if     IBMPC
#if	PKCODE
#define NROW	50
#else
#define NROW	43		/* Max Screen size.             */
#endif
#define NCOL    80		/* Edit if you want to.         */
#define	MARGIN	8		/* size of minimim margin and   */
#define	SCRSIZ	64		/* scroll size for extended lines */
#define	NPAUSE	200		/* # times thru update to pause */
#define BEL     0x07		/* BEL character.               */
#define ESC     0x1B		/* ESC character.               */
#define	SPACE	32		/* space character              */

#define	SCADC	0xb8000000L	/* CGA address of screen RAM    */
#define	SCADM	0xb0000000L	/* MONO address of screen RAM   */
#define SCADE	0xb8000000L	/* EGA address of screen RAM    */

#define MONOCRSR 0x0B0D		/* monochrome cursor        */
#define CGACRSR 0x0607		/* CGA cursor               */
#define EGACRSR 0x0709		/* EGA cursor               */

#define	CDCGA	0		/* color graphics card          */
#define	CDMONO	1		/* monochrome text card         */
#define	CDEGA	2		/* EGA color adapter            */
#if	PKCODE
#define	CDVGA	3
#endif
#define	CDSENSE	9		/* detect the card type         */

#if	PKCODE
#define NDRIVE	4
#else
#define NDRIVE	3		/* number of screen drivers     */
#endif

int dtype = -1;			/* current display type         */
char drvname[][8] = {		/* screen resolution names      */
	"CGA", "MONO", "EGA"
#if	PKCODE
	    , "VGA"
#endif
};
long scadd;			/* address of screen ram        */
int *scptr[NROW];		/* pointer to screen lines      */
unsigned int sline[NCOL];	/* screen line image            */
int egaexist = FALSE;		/* is an EGA card available?    */
extern union REGS rg;		/* cpu register for use of DOS calls */

extern int ttopen();		/* Forward references.          */
extern int ttgetc();
extern int ttputc();
extern int ttflush();
extern int ttclose();
extern int ibmmove();
extern int ibmeeol();
extern int ibmeeop();
extern int ibmbeep();
extern int ibmopen();
extern int ibmrev();
extern int ibmcres();
extern int ibmclose();
extern int ibmputc();
extern int ibmkopen();
extern int ibmkclose();

#if	COLOR
extern int ibmfcol();
extern int ibmbcol();
extern int ibmscroll_reg();

int cfcolor = -1;		/* current forground color */
int cbcolor = -1;		/* current background color */
int ctrans[] =			/* ansi to ibm color translation table */
#if	PKCODE
{ 0, 4, 2, 6, 1, 5, 3, 7, 15 };
#else
{ 0, 4, 2, 6, 1, 5, 3, 7 };
#endif
#endif

/*
 * Standard terminal interface dispatch table. Most of the fields point into
 * "termio" code.
 */
TERM term = {
	NROW - 1,
	NROW - 1,
	NCOL,
	NCOL,
	MARGIN,
	SCRSIZ,
	NPAUSE,
	ibmopen,
	ibmclose,
	ibmkopen,
	ibmkclose,
	ttgetc,
	ibmputc,
	ttflush,
	ibmmove,
	ibmeeol,
	ibmeeop,
	ibmbeep,
	ibmrev,
	ibmcres
#if	COLOR
	    , ibmfcol,
	ibmbcol
#endif
#if     SCROLLCODE
	    , ibmscroll_reg
#endif
};

#if	COLOR
ibmfcol(color)
    /* set the current output color */
int color;			/* color to set */

{
	cfcolor = ctrans[color];
}

ibmbcol(color)
    /* set the current background color */
int color;			/* color to set */

{
	cbcolor = ctrans[color];
}
#endif

ibmmove(row, col)
{
	rg.h.ah = 2;		/* set cursor position function code */
	rg.h.dl = col;
	rg.h.dh = row;
	rg.h.bh = 0;		/* set screen page number */
	int86(0x10, &rg, &rg);
}

ibmeeol()
{				/* erase to the end of the line */
	unsigned int attr;	/* attribute byte mask to place in RAM */
	unsigned int *lnptr;	/* pointer to the destination line */
	int i;
	int ccol;		/* current column cursor lives */
	int crow;		/*         row  */

	/* find the current cursor position */
	rg.h.ah = 3;		/* read cursor position function code */
	rg.h.bh = 0;		/* current video page */
	int86(0x10, &rg, &rg);
	ccol = rg.h.dl;		/* record current column */
	crow = rg.h.dh;		/* and row */

	/* build the attribute byte and setup the screen pointer */
#if	COLOR
	if (dtype != CDMONO)
		attr = (((cbcolor & 15) << 4) | (cfcolor & 15)) << 8;
	else
		attr = 0x0700;
#else
	attr = 0x0700;
#endif
	lnptr = &sline[0];
	for (i = 0; i < term.t_ncol; i++)
		*lnptr++ = SPACE | attr;

	if (flickcode && (dtype == CDCGA)) {
		/* wait for vertical retrace to be off */
		while ((inp(0x3da) & 8));

		/* and to be back on */
		while ((inp(0x3da) & 8) == 0);
	}

	/* and send the string out */
	movmem(&sline[0], scptr[crow] + ccol, (term.t_ncol - ccol) * 2);

}

ibmputc(ch)
    /* put a character at the current position in the
       current colors */
int ch;

{
	rg.h.ah = 14;		/* write char to screen with current attrs */
	rg.h.al = ch;
#if	COLOR
	if (dtype != CDMONO)
		rg.h.bl = cfcolor;
	else
		rg.h.bl = 0x07;
#else
	rg.h.bl = 0x07;
#endif
	int86(0x10, &rg, &rg);
}

ibmeeop()
{
	int attr;		/* attribute to fill screen with */

	rg.h.ah = 6;		/* scroll page up function code */
	rg.h.al = 0;		/* # lines to scroll (clear it) */
	rg.x.cx = 0;		/* upper left corner of scroll */
	rg.x.dx = (term.t_nrow << 8) | (term.t_ncol - 1);
	/* lower right corner of scroll */
#if	COLOR
	if (dtype != CDMONO)
		attr =
		    ((ctrans[gbcolor] & 15) << 4) | (ctrans[gfcolor] & 15);
	else
		attr = 0;
#else
	attr = 0;
#endif
	rg.h.bh = attr;
	int86(0x10, &rg, &rg);
}

ibmrev(state)
    /* change reverse video state */
int state;			/* TRUE = reverse, FALSE = normal */

{
	/* This never gets used under the IBM-PC driver */
}

ibmcres(res)
    /* change screen resolution */
char *res;			/* resolution to change to */

{
	int i;			/* index */

	for (i = 0; i < NDRIVE; i++)
		if (strcmp(res, drvname[i]) == 0) {
			scinit(i);
			return (TRUE);
		}
	return (FALSE);
}

#if SCROLLCODE

/* move howmany lines starting at from to to */
ibmscroll_reg(from, to, howmany)
{
	int i;

	if (to < from)
		for (i = 0; i < howmany; i++)
			movmem(scptr[from + i], scptr[to + i],
			       term.t_ncol * 2);
	else if (to > from)
		for (i = howmany - 1; i >= 0; i--)
			movmem(scptr[from + i], scptr[to + i],
			       term.t_ncol * 2);
	return;
}

#endif

spal()
{				/* reset the pallette registers */
	/* nothin here now..... */
}

ibmbeep()
{
	bdos(6, BEL, 0);
}

ibmopen()
{
	scinit(CDSENSE);
	revexist = TRUE;
	ttopen();
}

ibmclose()
{
#if	COLOR
	ibmfcol(7);
	ibmbcol(0);
#endif
	/* if we had the EGA open... close it */
	if (dtype == CDEGA)
		egaclose();
#if	PKCODE
	if (dtype == CDVGA)
		egaclose();
#endif

	ttclose();
}

ibmkopen()
{				/* open the keyboard */
}

ibmkclose()
{				/* close the keyboard */
}

scinit(type)
    /* initialize the screen head pointers */
int type;			/* type of adapter to init for */

{
	union {
		long laddr;	/* long form of address */
		int *paddr;	/* pointer form of address */
	} addr;
	int i;

	/* if asked...find out what display is connected */
	if (type == CDSENSE)
		type = getboard();

	/* if we have nothing to do....don't do it */
	if (dtype == type)
		return (TRUE);

	/* if we try to switch to EGA and there is none, don't */
	if (type == CDEGA && egaexist != TRUE)
		return (FALSE);

	/* if we had the EGA open... close it */
	if (dtype == CDEGA)
		egaclose();
#if	PKCODE
	if (dtype == CDVGA)
		egaclose();
#endif

	/* and set up the various parameters as needed */
	switch (type) {
	case CDMONO:		/* Monochrome adapter */
		scadd = SCADM;
		newsize(TRUE, 25);
		break;

	case CDCGA:		/* Color graphics adapter */
		scadd = SCADC;
		newsize(TRUE, 25);
		break;

	case CDEGA:		/* Enhanced graphics adapter */
		scadd = SCADE;
		egaopen();
		newsize(TRUE, 43);
		break;
	case CDVGA:		/* Enhanced graphics adapter */
		scadd = SCADE;
		egaopen();
		newsize(TRUE, 50);
		break;
	}

	/* reset the $sres environment variable */
	strcpy(sres, drvname[type]);
	dtype = type;

	/* initialize the screen pointer array */
	for (i = 0; i < NROW; i++) {
		addr.laddr = scadd + (long) (NCOL * i * 2);
		scptr[i] = addr.paddr;
	}
	return (TRUE);
}

/* getboard:	Determine which type of display board is attached.
		Current known types include:

		CDMONO	Monochrome graphics adapter
		CDCGA	Color Graphics Adapter
		CDEGA	Extended graphics Adapter
*/

/* getboard:	Detect the current display adapter
		if MONO		set to MONO
		   CGA		set to CGA	EGAexist = FALSE
		   EGA		set to CGA	EGAexist = TRUE
*/

int getboard()
{
	int type;		/* board type to return */

	type = CDCGA;
	int86(0x11, &rg, &rg);
	if ((((rg.x.ax >> 4) & 3) == 3))
		type = CDMONO;

	/* test if EGA present */
	rg.x.ax = 0x1200;
	rg.x.bx = 0xff10;
	int86(0x10, &rg, &rg);	/* If EGA, bh=0-1 and bl=0-3 */
	egaexist = !(rg.x.bx & 0xfefc);	/* Yes, it's EGA */
	return (type);
}

egaopen()
{				/* init the computer to work with the EGA */
	/* put the beast into EGA 43 row mode */
	rg.x.ax = 3;
	int86(16, &rg, &rg);

	rg.h.ah = 17;		/* set char. generator function code */
	rg.h.al = 18;		/*  to 8 by 8 double dot ROM         */
	rg.h.bl = 0;		/* block 0                           */
	int86(16, &rg, &rg);

	rg.h.ah = 18;		/* alternate select function code    */
	rg.h.al = 0;		/* clear AL for no good reason       */
	rg.h.bl = 32;		/* alt. print screen routine         */
	int86(16, &rg, &rg);

	rg.h.ah = 1;		/* set cursor size function code */
	rg.x.cx = 0x0607;	/* turn cursor on code */
	int86(0x10, &rg, &rg);

	outp(0x3d4, 10);	/* video bios bug patch */
	outp(0x3d5, 6);
}

egaclose()
{
	/* put the beast into 80 column mode */
	rg.x.ax = 3;
	int86(16, &rg, &rg);
}

scwrite(row, outstr, forg, bacg)
    /* write a line out */
int row;			/* row of screen to place outstr on */
char *outstr;			/* string to write out (must be term.t_ncol long) */
int forg;			/* forground color of string to write */
int bacg;			/* background color */

{
	unsigned int attr;	/* attribute byte mask to place in RAM */
	unsigned int *lnptr;	/* pointer to the destination line */
	int i;

	/* build the attribute byte and setup the screen pointer */
#if	COLOR
	if (dtype != CDMONO)
		attr =
		    (((ctrans[bacg] & 15) << 4) | (ctrans[forg] & 15)) <<
		    8;
	else
		attr = (((bacg & 15) << 4) | (forg & 15)) << 8;
#else
	attr = (((bacg & 15) << 4) | (forg & 15)) << 8;
#endif
	lnptr = &sline[0];
	for (i = 0; i < term.t_ncol; i++)
		*lnptr++ = (outstr[i] & 255) | attr;

	if (flickcode && (dtype == CDCGA)) {
		/* wait for vertical retrace to be off */
		while ((inp(0x3da) & 8));

		/* and to be back on */
		while ((inp(0x3da) & 8) == 0);
	}

	/* and send the string out */
	movmem(&sline[0], scptr[row], term.t_ncol * 2);
}

#if	FNLABEL
fnclabel(f, n)
    /* label a function key */
int f, n;			/* default flag, numeric argument [unused] */

{
	/* on machines with no function keys...don't bother */
	return (TRUE);
}
#endif
#endif