GNUBoot/coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
coreboot-kgpe-d16/payloads/libpayload/curses/PDCurses-3.4/dos/pdcscrn.c
Patrick Georgi 3b77b723ca libpayload: Add PDCurses and ncurses' libform/libmenu 
PDCurses provides an alternative implementation of the curses library
standard in addition to tinycurses.
Where tinycurses is really tiny, PDCurses is more complete and provides
virtually unlimited windows and the full API.
The PDCurses code is brought in "vanilla", with all local changes
residing in curses/pdcurses-backend/

In addition to a curses library, this change also provides libpanel (as
part of the PDCurses code), and libform and libmenu which were derived
from ncurses-5.9.
As they rely on ncurses internals (and PDCurses is not ncurses), more
changes were required for these libraries to work.

The build system is extended to install the right set of header files
depending on the selected curses implementation.

Change-Id: I9e5b920f94b6510da01da2f656196a993170d1c5
Signed-off-by: Patrick Georgi <patrick.georgi@secunet.com>
Reviewed-on: http://review.coreboot.org/106
Tested-by: build bot (Jenkins)
Reviewed-by: Marc Jones <marcj303@gmail.com>
2011-08-04 08:10:41 +02:00

757 lines
16 KiB
C
Raw Blame History

/* Public Domain Curses */
#include "pdcdos.h"
RCSID("$Id: pdcscrn.c,v 1.89 2008/07/13 16:08:17 wmcbrine Exp $")
#include <stdlib.h>
#ifdef CHTYPE_LONG
# define PDC_OFFSET 32
#else
# define PDC_OFFSET 8
#endif
/* COLOR_PAIR to attribute encoding table. */
unsigned char *pdc_atrtab = (unsigned char *)NULL;
int pdc_adapter; /* screen type */
int pdc_scrnmode; /* default screen mode */
int pdc_font; /* default font size */
bool pdc_direct_video; /* allow direct screen memory writes */
bool pdc_bogus_adapter; /* TRUE if adapter has insane values */
unsigned pdc_video_seg; /* video base segment */
unsigned pdc_video_ofs; /* video base offset */
static short curstoreal[16], realtocurs[16] =
{
COLOR_BLACK, COLOR_BLUE, COLOR_GREEN, COLOR_CYAN, COLOR_RED,
COLOR_MAGENTA, COLOR_YELLOW, COLOR_WHITE, COLOR_BLACK + 8,
COLOR_BLUE + 8, COLOR_GREEN + 8, COLOR_CYAN + 8, COLOR_RED + 8,
COLOR_MAGENTA + 8, COLOR_YELLOW + 8, COLOR_WHITE + 8
};
static bool sizeable = FALSE; /* TRUE if adapter is resizeable */
static unsigned short *saved_screen = NULL;
static int saved_lines = 0;
static int saved_cols = 0;
static int saved_scrnmode[3];
static int saved_font[3];
/* Thanks to Jeff Duntemann, K16RA for providing the impetus
(through the Dr. Dobbs Journal, March 1989 issue) for getting
the routines below merged into Bjorn Larsson's PDCurses 1.3...
-- frotz@dri.com 900730 */
/* _get_font() - Get the current font size */
static int _get_font(void)
{
int retval;
retval = getdosmemword(0x485);
/* Assume the MDS Genius is in 66 line mode. */
if ((retval == 0) && (pdc_adapter == _MDS_GENIUS))
retval = _FONT15;
switch (pdc_adapter)
{
case _MDA:
retval = 10; /* POINTS is not certain on MDA/Hercules */
break;
case _EGACOLOR:
case _EGAMONO:
switch (retval)
{
case _FONT8:
case _FONT14:
break;
default:
retval = _FONT14;
}
break;
case _CGA:
retval = _FONT8;
}
return retval;
}
/* _set_font() - Sets the current font size, if the adapter allows such a
change. It is an error to attempt to change the font size on a
"bogus" adapter. The reason for this is that we have a known video
adapter identity problem. e.g. Two adapters report the same identifying
characteristics. */
static void _set_font(int size)
{
PDCREGS regs;
if (pdc_bogus_adapter)
return;
switch (pdc_adapter)
{
case _CGA:
case _MDA:
case _MCGACOLOR:
case _MCGAMONO:
case _MDS_GENIUS:
break;
case _EGACOLOR:
case _EGAMONO:
if (sizeable && (pdc_font != size))
{
switch (size)
{
case _FONT8:
regs.W.ax = 0x1112;
regs.h.bl = 0x00;
PDCINT(0x10, regs);
break;
case _FONT14:
regs.W.ax = 0x1111;
regs.h.bl = 0x00;
PDCINT(0x10, regs);
}
}
break;
case _VGACOLOR:
case _VGAMONO:
if (sizeable && (pdc_font != size))
{
switch (size)
{
case _FONT8:
regs.W.ax = 0x1112;
regs.h.bl = 0x00;
PDCINT(0x10, regs);
break;
case _FONT14:
regs.W.ax = 0x1111;
regs.h.bl = 0x00;
PDCINT(0x10, regs);
break;
case _FONT16:
regs.W.ax = 0x1114;
regs.h.bl = 0x00;
PDCINT(0x10, regs);
}
}
}
curs_set(SP->visibility);
pdc_font = _get_font();
}
/* _set_80x25() - force a known screen state: 80x25 text mode. Forces the
appropriate 80x25 alpha mode given the display adapter. */
static void _set_80x25(void)
{
PDCREGS regs;
switch (pdc_adapter)
{
case _CGA:
case _EGACOLOR:
case _EGAMONO:
case _VGACOLOR:
case _VGAMONO:
case _MCGACOLOR:
case _MCGAMONO:
regs.h.ah = 0x00;
regs.h.al = 0x03;
PDCINT(0x10, regs);
break;
case _MDA:
regs.h.ah = 0x00;
regs.h.al = 0x07;
PDCINT(0x10, regs);
}
}
/* _get_scrn_mode() - Return the current BIOS video mode */
static int _get_scrn_mode(void)
{
PDCREGS regs;
regs.h.ah = 0x0f;
PDCINT(0x10, regs);
return (int)regs.h.al;
}
/* _set_scrn_mode() - Sets the BIOS Video Mode Number only if it is
different from the current video mode. */
static void _set_scrn_mode(int new_mode)
{
PDCREGS regs;
if (_get_scrn_mode() != new_mode)
{
regs.h.ah = 0;
regs.h.al = (unsigned char) new_mode;
PDCINT(0x10, regs);
}
pdc_font = _get_font();
pdc_scrnmode = new_mode;
LINES = PDC_get_rows();
COLS = PDC_get_columns();
}
/* _sanity_check() - A video adapter identification sanity check. This
routine will force sane values for various control flags. */
static int _sanity_check(int adapter)
{
int fontsize = _get_font();
int rows = PDC_get_rows();
PDC_LOG(("_sanity_check() - called: Adapter %d\n", adapter));
switch (adapter)
{
case _EGACOLOR:
case _EGAMONO:
switch (rows)
{
case 25:
case 43:
break;
default:
pdc_bogus_adapter = TRUE;
}
switch (fontsize)
{
case _FONT8:
case _FONT14:
break;
default:
pdc_bogus_adapter = TRUE;
}
break;
case _VGACOLOR:
case _VGAMONO:
break;
case _CGA:
case _MDA:
case _MCGACOLOR:
case _MCGAMONO:
switch (rows)
{
case 25:
break;
default:
pdc_bogus_adapter = TRUE;
}
break;
default:
pdc_bogus_adapter = TRUE;
}
if (pdc_bogus_adapter)
{
sizeable = FALSE;
pdc_direct_video = FALSE;
}
return adapter;
}
/* _query_adapter_type() - Determine PC video adapter type. */
static int _query_adapter_type(void)
{
PDCREGS regs;
int retval = _NONE;
/* thanks to paganini@ax.apc.org for the GO32 fix */
#if !defined(__DJGPP__) && !defined(__WATCOMC__)
struct SREGS segs;
#endif
short video_base = getdosmemword(0x463);
PDC_LOG(("_query_adapter_type() - called\n"));
/* attempt to call VGA Identify Adapter Function */
regs.W.ax = 0x1a00;
PDCINT(0x10, regs);
if ((regs.h.al == 0x1a) && (retval == _NONE))
{
/* We know that the PS/2 video BIOS is alive and well. */
switch (regs.h.al)
{
case 0:
retval = _NONE;
break;
case 1:
retval = _MDA;
break;
case 2:
retval = _CGA;
break;
case 4:
retval = _EGACOLOR;
sizeable = TRUE;
break;
case 5:
retval = _EGAMONO;
break;
case 26: /* ...alt. VGA BIOS... */
case 7:
retval = _VGACOLOR;
sizeable = TRUE;
break;
case 8:
retval = _VGAMONO;
break;
case 10:
case 13:
retval = _MCGACOLOR;
break;
case 12:
retval = _MCGAMONO;
break;
default:
retval = _CGA;
}
}
else
{
/* No VGA BIOS, check for an EGA BIOS by selecting an
Alternate Function Service...
bx == 0x0010 --> return EGA information */
regs.h.ah = 0x12;
regs.W.bx = 0x10;
PDCINT(0x10, regs);
if ((regs.h.bl != 0x10) && (retval == _NONE))
{
/* An EGA BIOS exists */
regs.h.ah = 0x12;
regs.h.bl = 0x10;
PDCINT(0x10, regs);
if (regs.h.bh == 0)
retval = _EGACOLOR;
else
retval = _EGAMONO;
}
else if (retval == _NONE)
{
/* Now we know we only have CGA or MDA */
PDCINT(0x11, regs);
switch (regs.h.al & 0x30)
{
case 0x10:
case 0x20:
retval = _CGA;
break;
case 0x30:
retval = _MDA;
break;
default:
retval = _NONE;
}
}
}
if (video_base == 0x3d4)
{
pdc_video_seg = 0xb800;
switch (retval)
{
case _EGAMONO:
retval = _EGACOLOR;
break;
case _VGAMONO:
retval = _VGACOLOR;
}
}
if (video_base == 0x3b4)
{
pdc_video_seg = 0xb000;
switch (retval)
{
case _EGACOLOR:
retval = _EGAMONO;
break;
case _VGACOLOR:
retval = _VGAMONO;
}
}
if ((retval == _NONE)
#ifndef CGA_DIRECT
|| (retval == _CGA)
#endif
)
pdc_direct_video = FALSE;
if ((unsigned)pdc_video_seg == 0xb000)
SP->mono = TRUE;
else
SP->mono = FALSE;
/* Check for DESQview shadow buffer
thanks to paganini@ax.apc.org for the GO32 fix */
#ifndef __WATCOMC__
regs.h.ah = 0xfe;
regs.h.al = 0;
regs.x.di = pdc_video_ofs;
# ifdef __DJGPP__
regs.x.es = pdc_video_seg;
__dpmi_int(0x10, &regs);
pdc_video_seg = regs.x.es;
# else
segs.es = pdc_video_seg;
int86x(0x10, &regs, &regs, &segs);
pdc_video_seg = segs.es;
# endif
pdc_video_ofs = regs.x.di;
#endif
if (!pdc_adapter)
pdc_adapter = retval;
return _sanity_check(retval);
}
/* close the physical screen -- may restore the screen to its state
before PDC_scr_open(); miscellaneous cleanup */
void PDC_scr_close(void)
{
#if SMALL || MEDIUM
# ifndef __PACIFIC__
struct SREGS segregs;
# endif
int ds;
#endif
PDC_LOG(("PDC_scr_close() - called\n"));
if (getenv("PDC_RESTORE_SCREEN") && saved_screen)
{
#ifdef __DJGPP__
dosmemput(saved_screen, saved_lines * saved_cols * 2,
(unsigned long)_FAR_POINTER(pdc_video_seg,
pdc_video_ofs));
#else
# if (SMALL || MEDIUM)
# ifdef __PACIFIC__
ds = FP_SEG((void far *)saved_screen);
# else
segread(&segregs);
ds = segregs.ds;
# endif
movedata(ds, (int)saved_screen, pdc_video_seg, pdc_video_ofs,
(saved_lines * saved_cols * 2));
# else
memcpy((void *)_FAR_POINTER(pdc_video_seg, pdc_video_ofs),
(void *)saved_screen, (saved_lines * saved_cols * 2));
# endif
#endif
free(saved_screen);
saved_screen = NULL;
}
reset_shell_mode();
if (SP->visibility != 1)
curs_set(1);
/* Position cursor to the bottom left of the screen. */
PDC_gotoyx(PDC_get_rows() - 2, 0);
}
void PDC_scr_free(void)
{
if (SP)
free(SP);
if (pdc_atrtab)
free(pdc_atrtab);
pdc_atrtab = (unsigned char *)NULL;
}
/* open the physical screen -- allocate SP, miscellaneous intialization,
and may save the existing screen for later restoration */
int PDC_scr_open(int argc, char **argv)
{
#if SMALL || MEDIUM
# ifndef __PACIFIC__
struct SREGS segregs;
# endif
int ds;
#endif
int i;
PDC_LOG(("PDC_scr_open() - called\n"));
SP = calloc(1, sizeof(SCREEN));
pdc_atrtab = calloc(PDC_COLOR_PAIRS * PDC_OFFSET, 1);
if (!SP || !pdc_atrtab)
return ERR;
for (i = 0; i < 16; i++)
curstoreal[realtocurs[i]] = i;
SP->orig_attr = FALSE;
pdc_direct_video = TRUE; /* Assume that we can */
pdc_video_seg = 0xb000; /* Base screen segment addr */
pdc_video_ofs = 0x0; /* Base screen segment ofs */
pdc_adapter = _query_adapter_type();
pdc_scrnmode = _get_scrn_mode();
pdc_font = _get_font();
SP->lines = PDC_get_rows();
SP->cols = PDC_get_columns();
SP->mouse_wait = PDC_CLICK_PERIOD;
SP->audible = TRUE;
/* If the environment variable PDCURSES_BIOS is set, the DOS int10()
BIOS calls are used in place of direct video memory access. */
if (getenv("PDCURSES_BIOS"))
pdc_direct_video = FALSE;
/* This code for preserving the current screen. */
if (getenv("PDC_RESTORE_SCREEN"))
{
saved_lines = SP->lines;
saved_cols = SP->cols;
saved_screen = malloc(saved_lines * saved_cols * 2);
if (!saved_screen)
{
SP->_preserve = FALSE;
return OK;
}
#ifdef __DJGPP__
dosmemget((unsigned long)_FAR_POINTER(pdc_video_seg, pdc_video_ofs),
saved_lines * saved_cols * 2, saved_screen);
#else
# if SMALL || MEDIUM
# ifdef __PACIFIC__
ds = FP_SEG((void far *) saved_screen);
# else
segread(&segregs);
ds = segregs.ds;
# endif
movedata(pdc_video_seg, pdc_video_ofs, ds, (int)saved_screen,
(saved_lines * saved_cols * 2));
# else
memcpy((void *)saved_screen,
(void *)_FAR_POINTER(pdc_video_seg, pdc_video_ofs),
(saved_lines * saved_cols * 2));
# endif
#endif
}
SP->_preserve = (getenv("PDC_PRESERVE_SCREEN") != NULL);
return OK;
}
/* the core of resize_term() */
int PDC_resize_screen(int nlines, int ncols)
{
PDC_LOG(("PDC_resize_screen() - called. Lines: %d Cols: %d\n",
nlines, ncols));
/* Trash the stored value of orig_cursor -- it's only good if the
video mode doesn't change */
SP->orig_cursor = 0x0607;
switch (pdc_adapter)
{
case _EGACOLOR:
if (nlines >= 43)
_set_font(_FONT8);
else
_set_80x25();
break;
case _VGACOLOR:
if (nlines > 28)
_set_font(_FONT8);
else
if (nlines > 25)
_set_font(_FONT14);
else
_set_80x25();
}
PDC_set_blink(COLORS == 8);
return OK;
}
void PDC_reset_prog_mode(void)
{
PDC_LOG(("PDC_reset_prog_mode() - called.\n"));
}
void PDC_reset_shell_mode(void)
{
PDC_LOG(("PDC_reset_shell_mode() - called.\n"));
}
void PDC_restore_screen_mode(int i)
{
if (i >= 0 && i <= 2)
{
pdc_font = _get_font();
_set_font(saved_font[i]);
if (_get_scrn_mode() != saved_scrnmode[i])
_set_scrn_mode(saved_scrnmode[i]);
}
}
void PDC_save_screen_mode(int i)
{
if (i >= 0 && i <= 2)
{
saved_font[i] = pdc_font;
saved_scrnmode[i] = pdc_scrnmode;
}
}
void PDC_init_pair(short pair, short fg, short bg)
{
unsigned char att, temp_bg;
chtype i;
fg = curstoreal[fg];
bg = curstoreal[bg];
for (i = 0; i < PDC_OFFSET; i++)
{
att = fg | (bg << 4);
if (i & (A_REVERSE >> PDC_ATTR_SHIFT))
att = bg | (fg << 4);
if (i & (A_UNDERLINE >> PDC_ATTR_SHIFT))
att = 1;
if (i & (A_INVIS >> PDC_ATTR_SHIFT))
{
temp_bg = att >> 4;
att = temp_bg << 4 | temp_bg;
}
if (i & (A_BOLD >> PDC_ATTR_SHIFT))
att |= 8;
if (i & (A_BLINK >> PDC_ATTR_SHIFT))
att |= 128;
pdc_atrtab[pair * PDC_OFFSET + i] = att;
}
}
int PDC_pair_content(short pair, short *fg, short *bg)
{
*fg = realtocurs[pdc_atrtab[pair * PDC_OFFSET] & 0x0F];
*bg = realtocurs[(pdc_atrtab[pair * PDC_OFFSET] & 0xF0) >> 4];
return OK;
}
/* _egapal() - Find the EGA palette value (0-63) for the color (0-15).
On VGA, this is an index into the DAC. */
static short _egapal(short color)
{
PDCREGS regs;
regs.W.ax = 0x1007;
regs.h.bl = curstoreal[color];
PDCINT(0x10, regs);
return regs.h.bh;
}
bool PDC_can_change_color(void)
{
return (pdc_adapter == _VGACOLOR);
}
/* These are only valid when pdc_adapter == _VGACOLOR */
int PDC_color_content(short color, short *red, short *green, short *blue)
{
PDCREGS regs;
/* Read single DAC register */
regs.W.ax = 0x1015;
regs.h.bl = _egapal(color);
PDCINT(0x10, regs);
/* Scale and store */
*red = DIVROUND((unsigned)(regs.h.dh) * 1000, 63);
*green = DIVROUND((unsigned)(regs.h.ch) * 1000, 63);
*blue = DIVROUND((unsigned)(regs.h.cl) * 1000, 63);
return OK;
}
int PDC_init_color(short color, short red, short green, short blue)
{
PDCREGS regs;
/* Scale */
regs.h.dh = DIVROUND((unsigned)red * 63, 1000);
regs.h.ch = DIVROUND((unsigned)green * 63, 1000);
regs.h.cl = DIVROUND((unsigned)blue * 63, 1000);
/* Set single DAC register */
regs.W.ax = 0x1010;
regs.W.bx = _egapal(color);
PDCINT(0x10, regs);
return OK;
}
Reference in a new issue View git blame Copy permalink