2064 lines
53 KiB
C
2064 lines
53 KiB
C
/*
|
|
* Copyright (c) 1999, 2000 Hellmuth Michaelis
|
|
*
|
|
* Copyright (c) 1992, 1995 Hellmuth Michaelis and Joerg Wunsch.
|
|
*
|
|
* Copyright (c) 1992, 1993 Brian Dunford-Shore and Scott Turner.
|
|
*
|
|
* Copyright (C) 1992, 1993 Soeren Schmidt.
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* For the sake of compatibility, portions of this code regarding the
|
|
* X server interface are taken from Soeren Schmidt's syscons driver.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. 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.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Hellmuth Michaelis,
|
|
* Brian Dunford-Shore, Joerg Wunsch, Scott Turner and Soeren Schmidt.
|
|
* 4. The name authors may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS 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.
|
|
*/
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
*
|
|
* pcvt_sup.c VT220 Driver Support Routines
|
|
* ---------------------------------------------
|
|
*
|
|
* Last Edit-Date: [Wed Apr 5 17:24:20 2000]
|
|
*
|
|
* $FreeBSD$
|
|
*
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
#include <i386/isa/pcvt/pcvt_hdr.h> /* global include */
|
|
|
|
#include <sys/resource.h>
|
|
|
|
static void vid_cursor ( struct cursorshape *data );
|
|
static void vgasetfontattr ( struct vgafontattr *data );
|
|
static void vgagetfontattr ( struct vgafontattr *data );
|
|
static void vgaloadchar ( struct vgaloadchar *data );
|
|
static void vid_getscreen ( struct screeninfo *data, dev_t dev );
|
|
static void vid_setscreen ( struct screeninfo *data, dev_t dev );
|
|
static void setchargen ( void );
|
|
static void setchargen3 ( void );
|
|
static void resetchargen ( void );
|
|
static void vgareadpel ( struct vgapel *data, dev_t dev );
|
|
static void vgawritepel ( struct vgapel *data, dev_t dev );
|
|
static void vgapcvtid ( struct pcvtid *data );
|
|
static void vgapcvtinfo ( struct pcvtinfo *data );
|
|
|
|
#ifdef XSERVER
|
|
static unsigned char * compute_charset_base ( unsigned fontset );
|
|
#endif /* XSERVER */
|
|
|
|
static struct callout_handle async_update_ch =
|
|
CALLOUT_HANDLE_INITIALIZER(&async_update_ch);
|
|
|
|
#if PCVT_SCREENSAVER
|
|
static void scrnsv_timedout ( void *arg );
|
|
static struct callout_handle scrnsv_timeout_ch =
|
|
CALLOUT_HANDLE_INITIALIZER(&scrnsv_timeout_ch);
|
|
static u_short *savedscreen = (u_short *)0; /* ptr to screen contents */
|
|
static size_t scrnsv_size = (size_t)-1; /* size of saved image */
|
|
|
|
#ifndef XSERVER
|
|
static unsigned scrnsv_timeout = 0; /* initially off */
|
|
static void pcvt_set_scrnsv_tmo ( int timeout );/* else declared global */
|
|
#endif /* XSERVER */
|
|
|
|
#if PCVT_PRETTYSCRNS
|
|
static u_short *scrnsv_current = (u_short *)0; /* attention char ptr */
|
|
static struct callout_handle scrnsv_blink_ch =
|
|
CALLOUT_HANDLE_INITIALIZER(&scrnsv_blink_ch);
|
|
static void scrnsv_blink ( void * );
|
|
static u_short getrand ( void );
|
|
#endif /* PCVT_PRETTYSCRNS */
|
|
|
|
#endif /* PCVT_SCREENSAVER */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* execute vga ioctls
|
|
*---------------------------------------------------------------------------*/
|
|
int
|
|
vgaioctl(dev_t dev, int cmd, caddr_t data, int flag)
|
|
{
|
|
if(minor(dev) >= PCVT_NSCREENS)
|
|
return -1;
|
|
|
|
/*
|
|
* Some of the commands are not applicable if the vt in question, or the
|
|
* current vt is in graphics mode (i.e., the X server acts on it); they
|
|
* will cause an EAGAIN (resource temporarily unavailable) to be returned.
|
|
*/
|
|
|
|
#ifdef XSERVER
|
|
#define is_dev_grafx vs[minor(dev)].vt_status & VT_GRAFX
|
|
#define is_current_grafx vsp->vt_status & VT_GRAFX
|
|
#else /* !XSERVER */
|
|
#define is_dev_grafx 0
|
|
#define is_current_grafx 0
|
|
#endif /* XSERVER */
|
|
|
|
switch(cmd)
|
|
{
|
|
case VGACURSOR:
|
|
if(is_current_grafx)
|
|
return EAGAIN;
|
|
vid_cursor((struct cursorshape *)data);
|
|
break;
|
|
|
|
case VGALOADCHAR:
|
|
if((adaptor_type != VGA_ADAPTOR) &&
|
|
(adaptor_type != EGA_ADAPTOR))
|
|
return -1;
|
|
if(is_current_grafx)
|
|
return EAGAIN;
|
|
vgaloadchar((struct vgaloadchar *)data);
|
|
break;
|
|
|
|
case VGASETFONTATTR:
|
|
if((adaptor_type != VGA_ADAPTOR) &&
|
|
(adaptor_type != EGA_ADAPTOR))
|
|
return -1;
|
|
|
|
#if PCVT_SCREENSAVER
|
|
pcvt_scrnsv_reset();
|
|
#endif /* PCVT_SCREENSAVER */
|
|
|
|
vgasetfontattr((struct vgafontattr *)data);
|
|
break;
|
|
|
|
case VGAGETFONTATTR:
|
|
if((adaptor_type != VGA_ADAPTOR) &&
|
|
(adaptor_type != EGA_ADAPTOR))
|
|
return -1;
|
|
vgagetfontattr((struct vgafontattr *)data);
|
|
break;
|
|
|
|
case VGASETSCREEN:
|
|
#if PCVT_SCREENSAVER
|
|
pcvt_scrnsv_reset();
|
|
#endif /* PCVT_SCREENSAVER */
|
|
|
|
vid_setscreen((struct screeninfo *)data, dev);
|
|
break;
|
|
|
|
case VGAGETSCREEN:
|
|
vid_getscreen((struct screeninfo *)data, dev);
|
|
break;
|
|
|
|
case VGAREADPEL:
|
|
if(adaptor_type != VGA_ADAPTOR)
|
|
return -1;
|
|
if(is_dev_grafx)
|
|
return EAGAIN;
|
|
vgareadpel((struct vgapel *)data, dev);
|
|
break;
|
|
|
|
case VGAWRITEPEL:
|
|
if(adaptor_type != VGA_ADAPTOR)
|
|
return -1;
|
|
if(is_dev_grafx)
|
|
return EAGAIN;
|
|
vgawritepel((struct vgapel *)data, dev);
|
|
break;
|
|
|
|
#if PCVT_SCREENSAVER
|
|
case VGASCREENSAVER:
|
|
if(is_current_grafx)
|
|
return EAGAIN;
|
|
pcvt_set_scrnsv_tmo(*(int *)data);
|
|
pcvt_scrnsv_reset();
|
|
break;
|
|
#endif /* PCVT_SCREENSAVER */
|
|
|
|
case VGAPCVTID:
|
|
vgapcvtid((struct pcvtid *)data);
|
|
break;
|
|
|
|
case VGAPCVTINFO:
|
|
vgapcvtinfo((struct pcvtinfo *)data);
|
|
break;
|
|
|
|
case VGASETCOLMS:
|
|
if(is_dev_grafx)
|
|
return EAGAIN;
|
|
if(*(int *)data == 80)
|
|
(void)vt_col(&vs[minor(dev)], SCR_COL80);
|
|
else if(*(int *)data == 132)
|
|
{
|
|
if(vt_col(&vs[minor(dev)], SCR_COL132) == 0)
|
|
return EINVAL; /* not a VGA */
|
|
}
|
|
else
|
|
return EINVAL;
|
|
break;
|
|
|
|
#if 0
|
|
case SETSCROLLSIZE:
|
|
reallocate_scrollbuffer(vsp, *(u_short *)data);
|
|
break;
|
|
#endif
|
|
|
|
case TIOCSWINSZ:
|
|
/* do nothing here */
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
return 0;
|
|
|
|
#undef is_dev_grafx
|
|
#undef is_current_grafx
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* video ioctl - return driver id
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vgapcvtid(struct pcvtid *data)
|
|
{
|
|
snprintf(data->name, sizeof(data->name), "%s", PCVTIDNAME);
|
|
data->rmajor = PCVTIDMAJOR;
|
|
data->rminor = PCVTIDMINOR;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* video ioctl - return driver compile time options data
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vgapcvtinfo(struct pcvtinfo *data)
|
|
{
|
|
data->nscreens = PCVT_NSCREENS;
|
|
data->scanset = PCVT_SCANSET;
|
|
data->updatefast= PCVT_UPDATEFAST;
|
|
data->updateslow= PCVT_UPDATESLOW;
|
|
data->sysbeepf = PCVT_SYSBEEPF;
|
|
data->pcburst = PCVT_PCBURST;
|
|
data->kbd_fifo_sz = PCVT_KBD_FIFO_SZ;
|
|
|
|
data->compile_opts = (0
|
|
|
|
#if PCVT_VT220KEYB
|
|
| CONF_VT220KEYB
|
|
#endif
|
|
#if PCVT_SCREENSAVER
|
|
| CONF_SCREENSAVER
|
|
#endif
|
|
#if PCVT_PRETTYSCRNS
|
|
| CONF_PRETTYSCRNS
|
|
#endif
|
|
#if PCVT_CTRL_ALT_DEL
|
|
| CONF_CTRL_ALT_DEL
|
|
#endif
|
|
#if PCVT_USEKBDSEC
|
|
| CONF_USEKBDSEC
|
|
#endif
|
|
#if PCVT_24LINESDEF
|
|
| CONF_24LINESDEF
|
|
#endif
|
|
#if PCVT_SHOWKEYS
|
|
| CONF_SHOWKEYS
|
|
#endif
|
|
#if PCVT_NULLCHARS
|
|
| CONF_NULLCHARS
|
|
#endif
|
|
#if PCVT_SETCOLOR
|
|
| CONF_SETCOLOR
|
|
#endif
|
|
#if PCVT_132GENERIC
|
|
| CONF_132GENERIC
|
|
#endif
|
|
#ifdef XSERVER
|
|
| CONF_XSERVER
|
|
#endif
|
|
#if PCVT_INHIBIT_NUMLOCK
|
|
| CONF_INHIBIT_NUMLOCK
|
|
#endif
|
|
#if PCVT_META_ESC
|
|
| CONF_META_ESC
|
|
#endif
|
|
#if PCVT_SLOW_INTERRUPT
|
|
| CONF_SLOW_INTERRUPT
|
|
#endif
|
|
#if PCVT_NO_LED_UPDATE
|
|
| CONF_NO_LED_UPDATE
|
|
#endif
|
|
#if PCVT_GREENSAVER
|
|
| CONF_GREENSAVER
|
|
#endif
|
|
|
|
);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* video ioctl - set cursor appearence
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vid_cursor(struct cursorshape *data)
|
|
{
|
|
int screen;
|
|
int start;
|
|
int end;
|
|
int line_height;
|
|
int character_set;
|
|
|
|
/* for which virtual screen, -1 for current */
|
|
screen = data->screen_no;
|
|
|
|
if(screen == -1) /* current ? */
|
|
screen = current_video_screen;
|
|
else if(screen > totalscreens - 1)
|
|
screen = totalscreens - 1;
|
|
else if(screen < 0)
|
|
screen = 0;
|
|
|
|
if(adaptor_type == VGA_ADAPTOR || adaptor_type == EGA_ADAPTOR)
|
|
{
|
|
character_set = vs[screen].vga_charset;
|
|
character_set = (character_set < 0) ? 0 :
|
|
((character_set < totalfonts) ?
|
|
character_set :
|
|
totalfonts-1);
|
|
|
|
line_height = vgacs[character_set].char_scanlines & 0x1F;
|
|
}
|
|
else if(adaptor_type == MDA_ADAPTOR)
|
|
{
|
|
line_height = 14;
|
|
}
|
|
else
|
|
{
|
|
line_height = 8; /* CGA */
|
|
}
|
|
|
|
start = (data->start < 0) ? 0 :
|
|
((data->start > line_height) ? line_height : data->start);
|
|
|
|
if((vga_family == VGA_F_TRI) && (start == 0))
|
|
start = 1;
|
|
|
|
end = (data->end < 0) ? 0 :
|
|
((data->end > line_height) ? line_height : data->end);
|
|
|
|
vs[screen].cursor_start = start;
|
|
vs[screen].cursor_end = end;
|
|
|
|
if(screen == current_video_screen)
|
|
{
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
outb(addr_6845+1, start);
|
|
outb(addr_6845,CRTC_CUREND); /* cursor end reg */
|
|
outb(addr_6845+1, end);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* ega/vga ioctl - set font attributes
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vgasetfontattr(struct vgafontattr *data)
|
|
{
|
|
register int i;
|
|
int vga_character_set;
|
|
int lines_per_character;
|
|
int totscanlines;
|
|
int size;
|
|
|
|
vga_character_set = data->character_set;
|
|
vga_character_set = (vga_character_set < 0) ? 0 :
|
|
((vga_character_set < totalfonts) ?
|
|
vga_character_set : totalfonts-1);
|
|
|
|
vgacs[vga_character_set].loaded = data->font_loaded;
|
|
|
|
/* Limit Characters to 32 scanlines doubled */
|
|
vgacs[vga_character_set].char_scanlines =
|
|
(data->character_scanlines & 0x1F)
|
|
| 0x40; /* always set bit 9 of line cmp reg */
|
|
|
|
if(adaptor_type == EGA_ADAPTOR)
|
|
/* ...and screen height to scan 350 lines */
|
|
vgacs[vga_character_set].scr_scanlines =
|
|
(data->screen_scanlines > 0x5d) ?
|
|
0x5d : data->screen_scanlines;
|
|
else
|
|
/* ...and screen height to scan 480 lines */
|
|
vgacs[vga_character_set].scr_scanlines =
|
|
(data->screen_scanlines > 0xdF) ?
|
|
0xdF : data->screen_scanlines;
|
|
|
|
lines_per_character =
|
|
(int)(0x1F & vgacs[vga_character_set].char_scanlines)+1;
|
|
|
|
totscanlines = 0x101 + (int)vgacs[vga_character_set].scr_scanlines;
|
|
|
|
size = data->screen_size;
|
|
|
|
if(adaptor_type == EGA_ADAPTOR)
|
|
{
|
|
switch(size)
|
|
{
|
|
case SIZ_25ROWS: /* This case is always OK */
|
|
break;
|
|
|
|
case SIZ_35ROWS:
|
|
if(totscanlines/lines_per_character >= 35)
|
|
size = SIZ_35ROWS;
|
|
else
|
|
size = SIZ_25ROWS;
|
|
break;
|
|
|
|
case SIZ_43ROWS:
|
|
default:
|
|
if(totscanlines/lines_per_character >= 43)
|
|
size = SIZ_43ROWS;
|
|
else if(totscanlines/lines_per_character >= 35)
|
|
size = SIZ_35ROWS;
|
|
else
|
|
size = SIZ_25ROWS;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(size)
|
|
{
|
|
case SIZ_25ROWS: /* This case is always OK */
|
|
break;
|
|
|
|
case SIZ_28ROWS:
|
|
if(totscanlines/lines_per_character >= 28)
|
|
size = SIZ_28ROWS;
|
|
else
|
|
size = SIZ_25ROWS;
|
|
break;
|
|
|
|
case SIZ_40ROWS:
|
|
if(totscanlines/lines_per_character >= 40)
|
|
size = SIZ_40ROWS;
|
|
else if(totscanlines/lines_per_character >= 28)
|
|
size = SIZ_28ROWS;
|
|
else
|
|
size = SIZ_25ROWS;
|
|
break;
|
|
|
|
case SIZ_50ROWS:
|
|
default:
|
|
if(totscanlines/lines_per_character >= 50)
|
|
size = SIZ_50ROWS;
|
|
else if(totscanlines/lines_per_character >= 40)
|
|
size = SIZ_40ROWS;
|
|
else if(totscanlines/lines_per_character >= 28)
|
|
size = SIZ_28ROWS;
|
|
else
|
|
size = SIZ_25ROWS;
|
|
break;
|
|
}
|
|
}
|
|
|
|
vgacs[vga_character_set].screen_size = size;
|
|
|
|
for (i = 0;i < PCVT_NSCREENS;i++)
|
|
{
|
|
if(vga_character_set == vs[i].vga_charset)
|
|
set_charset(&(vs[i]),vga_character_set);
|
|
}
|
|
|
|
#ifdef XSERVER
|
|
switch_screen(current_video_screen, 0, 0);
|
|
#else
|
|
vgapage(current_video_screen);
|
|
#endif /* XSERVER */
|
|
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* ega/vga ioctl - get font attributes
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vgagetfontattr(struct vgafontattr *data)
|
|
{
|
|
int vga_character_set;
|
|
|
|
vga_character_set = data->character_set;
|
|
vga_character_set = (vga_character_set < 0) ? 0 :
|
|
((vga_character_set < (int)totalfonts) ?
|
|
vga_character_set :
|
|
(int)(totalfonts-1));
|
|
|
|
data->character_set = (int)vga_character_set;
|
|
|
|
data->font_loaded = (int)vgacs[vga_character_set].loaded;
|
|
|
|
data->character_scanlines =
|
|
(int)vgacs[vga_character_set].char_scanlines
|
|
& 0x1f; /* do not display the overflow bits */
|
|
|
|
data->screen_scanlines = (int)vgacs[vga_character_set].scr_scanlines;
|
|
|
|
data->screen_size = (int)vgacs[vga_character_set].screen_size;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* ega/vga ioctl - load a character shape into character set
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vgaloadchar(struct vgaloadchar *data)
|
|
{
|
|
int vga_character_set;
|
|
int character;
|
|
int lines_per_character;
|
|
|
|
vga_character_set = data->character_set;
|
|
vga_character_set = (vga_character_set < 0) ? 0 :
|
|
((vga_character_set < (int)totalfonts) ?
|
|
vga_character_set : (int)(totalfonts-1));
|
|
|
|
character = (data->character < 0) ? 0 :
|
|
((data->character > 255) ? 255 : data->character);
|
|
|
|
lines_per_character = (int)data->character_scanlines;
|
|
lines_per_character = (lines_per_character < 0) ? 0 :
|
|
((lines_per_character > 32) ? 32 : lines_per_character);
|
|
|
|
loadchar(vga_character_set,character,lines_per_character,
|
|
data->char_table);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* video ioctl - get screen information
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vid_getscreen(struct screeninfo *data, dev_t dev)
|
|
{
|
|
int device = minor(dev);
|
|
data->adaptor_type = adaptor_type; /* video adapter installed */
|
|
data->monitor_type = color; /* monitor type installed */
|
|
data->totalfonts = totalfonts; /* no of downloadble fonts */
|
|
data->totalscreens = totalscreens; /* no of virtual screens */
|
|
data->screen_no = device; /* this screen number */
|
|
data->current_screen = current_video_screen; /* displayed screen no */
|
|
/* screen size */
|
|
data->screen_size = vgacs[(vs[device].vga_charset)].screen_size;
|
|
/* pure VT mode or HP/VT mode */
|
|
data->pure_vt_mode = vs[device].vt_pure_mode;
|
|
data->vga_family = vga_family; /* manufacturer, family */
|
|
data->vga_type = vga_type; /* detected chipset type */
|
|
data->vga_132 = can_do_132col; /* 132 column support */
|
|
data->force_24lines = vs[device].force24; /* force 24 lines */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* video ioctl - set screen information
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vid_setscreen(struct screeninfo *data, dev_t dev)
|
|
{
|
|
int screen;
|
|
|
|
if(data->current_screen == -1)
|
|
{
|
|
screen = minor(dev);
|
|
}
|
|
else
|
|
{
|
|
if(data->current_screen >= PCVT_NSCREENS)
|
|
return; /* XXXXXX */
|
|
screen = data->current_screen;
|
|
}
|
|
|
|
vgapage(screen);
|
|
|
|
#ifdef XSERVER
|
|
{
|
|
int x = spltty(), waitfor = screen + 1;
|
|
/* if the vt is yet to be released by a process, wait here */
|
|
if(vs[screen].vt_status & VT_WAIT_REL)
|
|
(void)usl_vt_ioctl(dev, VT_WAITACTIVE,
|
|
(caddr_t)&waitfor, 0, 0);
|
|
splx(x);
|
|
}
|
|
/* make sure the switch really happened */
|
|
if(screen != current_video_screen)
|
|
return; /* XXX should say "EAGAIN" here */
|
|
#endif /* XSERVER */
|
|
|
|
if((data->screen_size != -1) || (data->force_24lines != -1))
|
|
{
|
|
if(data->screen_size == -1)
|
|
data->screen_size =
|
|
vgacs[(vs[screen].vga_charset)].screen_size;
|
|
|
|
if(data->force_24lines != -1)
|
|
{
|
|
vs[screen].force24 = data->force_24lines;
|
|
|
|
if(vs[screen].force24)
|
|
{
|
|
swritefkl(2,(u_char *)"FORCE24 ENABLE *",
|
|
&vs[screen]);
|
|
}
|
|
else
|
|
{
|
|
swritefkl(2,(u_char *)"FORCE24 ENABLE ",
|
|
&vs[screen]);
|
|
}
|
|
}
|
|
|
|
if((data->screen_size == SIZ_25ROWS) ||
|
|
(data->screen_size == SIZ_28ROWS) ||
|
|
(data->screen_size == SIZ_35ROWS) ||
|
|
(data->screen_size == SIZ_40ROWS) ||
|
|
(data->screen_size == SIZ_43ROWS) ||
|
|
(data->screen_size == SIZ_50ROWS))
|
|
{
|
|
if(data->screen_no == -1)
|
|
set_screen_size(vsp, data->screen_size);
|
|
else
|
|
set_screen_size(&vs[minor(dev)],
|
|
data->screen_size);
|
|
}
|
|
}
|
|
|
|
if(data->pure_vt_mode != -1)
|
|
{
|
|
if((data->pure_vt_mode == M_HPVT) ||
|
|
(data->pure_vt_mode == M_PUREVT))
|
|
{
|
|
if(data->screen_no == -1)
|
|
set_emulation_mode(vsp, data->pure_vt_mode);
|
|
else
|
|
set_emulation_mode(&vs[minor(dev)],
|
|
data->pure_vt_mode);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* set screen size/resolution for a virtual screen
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
set_screen_size(struct video_state *svsp, int size)
|
|
{
|
|
int i;
|
|
|
|
for(i = 0; i < totalfonts; i++)
|
|
{
|
|
if(vgacs[i].screen_size == size)
|
|
{
|
|
set_charset(svsp, i);
|
|
clr_parms(svsp); /* escape parameter init */
|
|
svsp->state = STATE_INIT; /* initial state */
|
|
svsp->scrr_beg = 0; /* start of scrolling region */
|
|
svsp->sc_flag = 0; /* invalidate saved cursor
|
|
* position */
|
|
svsp->transparent = 0; /* disable control code
|
|
* processing */
|
|
|
|
/* Update tty to reflect screen size */
|
|
|
|
if (svsp->vs_tty)
|
|
{
|
|
svsp->vs_tty->t_winsize.ws_col = svsp->maxcol;
|
|
svsp->vs_tty->t_winsize.ws_xpixel =
|
|
(svsp->maxcol == 80)? 720: 1056;
|
|
svsp->vs_tty->t_winsize.ws_ypixel = 400;
|
|
svsp->vs_tty->t_winsize.ws_row =
|
|
svsp->screen_rows;
|
|
}
|
|
/* screen_rows already calculated in set_charset() */
|
|
if(svsp->vt_pure_mode == M_HPVT && svsp->labels_on)
|
|
{
|
|
if(svsp->which_fkl == SYS_FKL)
|
|
sw_sfkl(svsp);
|
|
else if(svsp->which_fkl == USR_FKL)
|
|
sw_ufkl(svsp);
|
|
}
|
|
|
|
|
|
svsp->scrr_len = svsp->screen_rows;
|
|
svsp->scrr_end = svsp->scrr_len - 1;
|
|
|
|
if (svsp->vs_tty && svsp->vs_tty->t_pgrp) {
|
|
PGRP_LOCK(svsp->vs_tty->t_pgrp);
|
|
pgsignal(svsp->vs_tty->t_pgrp, SIGWINCH, 1);
|
|
PGRP_UNLOCK(svsp->vs_tty->t_pgrp);
|
|
}
|
|
|
|
reallocate_scrollbuffer(svsp, svsp->scrollback_pages);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* resize the scrollback buffer to the specified number of "pages"
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
reallocate_scrollbuffer(struct video_state *svsp, int pages)
|
|
{
|
|
int s;
|
|
u_short *stmp;
|
|
|
|
if(pages < 2)
|
|
pages = 2;
|
|
if(pages > 50)
|
|
pages = 50;
|
|
|
|
s = splhigh();
|
|
|
|
if((stmp = (u_short *)malloc(svsp->maxcol * svsp->screen_rows *
|
|
pages * CHR, M_DEVBUF, M_NOWAIT)) == NULL)
|
|
{
|
|
splx(s);
|
|
printf("pcvt: reallocate_scrollbuffer, malloc failed\n");
|
|
return;
|
|
}
|
|
|
|
svsp->max_off = svsp->screen_rows * pages - 1;
|
|
|
|
if(svsp->Scrollback)
|
|
{
|
|
bcopy(svsp->Scrollback, stmp,
|
|
(min(pages, svsp->scrollback_pages)) *
|
|
svsp->screen_rows * svsp->maxcol * CHR);
|
|
free(svsp->Scrollback, M_DEVBUF);
|
|
svsp->Scrollback = stmp;
|
|
}
|
|
else
|
|
{
|
|
svsp->scr_offset = 0;
|
|
svsp->scrolling = 0;
|
|
svsp->Scrollback = stmp;
|
|
|
|
bcopy(svsp->Crtat, svsp->Scrollback,
|
|
svsp->screen_rows * svsp->maxcol * CHR);
|
|
|
|
svsp->scr_offset = svsp->row;
|
|
}
|
|
|
|
svsp->scrollback_pages = pages;
|
|
|
|
splx(s);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* VGA ioctl - read DAC palette entry
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vgareadpel(struct vgapel *data, dev_t dev)
|
|
{
|
|
register unsigned vpage = minor(dev);
|
|
register unsigned idx = data->idx;
|
|
|
|
if(idx >= NVGAPEL)
|
|
return; /* no such entry */
|
|
|
|
/* do not read VGA palette directly, use saved values */
|
|
data->r = vs[vpage].palette[idx].r;
|
|
data->g = vs[vpage].palette[idx].g;
|
|
data->b = vs[vpage].palette[idx].b;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* VGA ioctl - write DAC palette entry
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
vgawritepel(struct vgapel *data, dev_t dev)
|
|
{
|
|
register unsigned vpage = minor(dev);
|
|
register unsigned idx = data->idx;
|
|
|
|
if(idx >= NVGAPEL)
|
|
return; /* no such entry */
|
|
|
|
/* first, update saved values for this video screen */
|
|
vs[vpage].palette[idx].r = data->r;
|
|
vs[vpage].palette[idx].g = data->g;
|
|
vs[vpage].palette[idx].b = data->b;
|
|
|
|
/* if this happens on active screen, update VGA DAC, too */
|
|
if(vpage == current_video_screen)
|
|
vgapaletteio(idx, &vs[vpage].palette[idx], 1);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* VGA physical IO - read/write one palette entry
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vgapaletteio(unsigned idx, struct rgb *val, int writeit)
|
|
{
|
|
if(writeit)
|
|
{
|
|
outb(VGA_DAC + 2, idx);
|
|
outb(VGA_DAC + 3, val->r & VGA_PMSK);
|
|
outb(VGA_DAC + 3, val->g & VGA_PMSK);
|
|
outb(VGA_DAC + 3, val->b & VGA_PMSK);
|
|
}
|
|
else /* read it */
|
|
{
|
|
outb(VGA_DAC + 1, idx);
|
|
val->r = inb(VGA_DAC + 3) & VGA_PMSK;
|
|
val->g = inb(VGA_DAC + 3) & VGA_PMSK;
|
|
val->b = inb(VGA_DAC + 3) & VGA_PMSK;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
*
|
|
* update asynchronous: cursor, cursor pos displ, sys load, keyb scan
|
|
*
|
|
* arg is:
|
|
* UPDATE_START = do update; requeue
|
|
* UPDATE_STOP = suspend updates
|
|
* UPDATE_KERN = do update for kernel printfs
|
|
*
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
async_update(void *arg)
|
|
{
|
|
static int lastpos = 0;
|
|
static int counter = PCVT_UPDATESLOW;
|
|
|
|
#ifdef XSERVER
|
|
/* need a method to suspend the updates */
|
|
|
|
if(arg == UPDATE_STOP)
|
|
{
|
|
untimeout(async_update, UPDATE_START, async_update_ch);
|
|
return;
|
|
}
|
|
#endif /* XSERVER */
|
|
|
|
/* first check if update is possible */
|
|
|
|
if(chargen_access) /* does no-one load characters? */
|
|
{
|
|
goto async_update_exit; /* do not update anything */
|
|
}
|
|
|
|
#if PCVT_SCREENSAVER
|
|
if(reset_screen_saver && (counter == PCVT_UPDATESLOW))
|
|
{
|
|
pcvt_scrnsv_reset(); /* yes, do it */
|
|
reset_screen_saver = 0; /* re-init */
|
|
}
|
|
else if(scrnsv_active) /* is the screen not blanked? */
|
|
{
|
|
goto async_update_exit; /* do not update anything */
|
|
}
|
|
#endif /* PCVT_SCREENSAVER */
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
/* this takes place on EVERY virtual screen (if not in X mode etc...)*/
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
if ( cursor_pos_valid &&
|
|
(lastpos != (vsp->Crtat + vsp->cur_offset - Crtat)))
|
|
{
|
|
lastpos = vsp->Crtat + vsp->cur_offset - Crtat;
|
|
outb(addr_6845, CRTC_CURSORH); /* high register */
|
|
outb(addr_6845+1, ((lastpos) >> 8));
|
|
outb(addr_6845, CRTC_CURSORL); /* low register */
|
|
outb(addr_6845+1, (lastpos));
|
|
}
|
|
|
|
if (arg == UPDATE_KERN) /* Magic arg: for kernel printfs */
|
|
return;
|
|
|
|
if(--counter) /* below is possible update */
|
|
goto async_update_exit; /* just now and then ..... */
|
|
counter = PCVT_UPDATESLOW; /* caution, see screensaver above !! */
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
/* this takes place ONLY on screen 0 if in HP mode, labels on, !X */
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
/* additional processing for HP necessary ? */
|
|
|
|
if((vs[0].vt_pure_mode == M_HPVT) && (vs[0].labels_on))
|
|
{
|
|
static volatile u_char buffer[] =
|
|
"System Load: 1min: 0.00 5min: 0.00 15min: 0.00";
|
|
register int tmp, i;
|
|
#if PCVT_SHOWKEYS
|
|
extern u_char rawkeybuf[80];
|
|
|
|
if(keyboard_show)
|
|
{
|
|
for(i = 0; i < 80; i++)
|
|
{
|
|
*((vs[0].Crtat+((vs[0].screen_rows+2)
|
|
* vs[0].maxcol))+i) =
|
|
user_attr | rawkeybuf[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#endif /* PCVT_SHOWKEYS */
|
|
|
|
/* display load averages in last line (taken from tty.c) */
|
|
i = 18;
|
|
tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2)
|
|
>> FSHIFT;
|
|
buffer[i++] =
|
|
((((tmp/100)/10) == 0) ?
|
|
' ' :
|
|
((tmp/100)/10) + '0');
|
|
buffer[i++] = ((tmp/100)%10) + '0';
|
|
buffer[i++] = '.';
|
|
buffer[i++] = ((tmp%100)/10) + '0';
|
|
buffer[i++] = ((tmp%100)%10) + '0';
|
|
i += 6;
|
|
tmp = (averunnable.ldavg[1] * 100 + FSCALE / 2)
|
|
>> FSHIFT;
|
|
buffer[i++] = ((((tmp/100)/10) == 0) ?
|
|
' ' :
|
|
((tmp/100)/10) + '0');
|
|
buffer[i++] = ((tmp/100)%10) + '0';
|
|
buffer[i++] = '.';
|
|
buffer[i++] = ((tmp%100)/10) + '0';
|
|
buffer[i++] = ((tmp%100)%10) + '0';
|
|
i += 7;
|
|
tmp = (averunnable.ldavg[2] * 100 + FSCALE / 2)
|
|
>> FSHIFT;
|
|
buffer[i++] = ((((tmp/100)/10) == 0) ?
|
|
' ' :
|
|
((tmp/100)/10) + '0');
|
|
buffer[i++] = ((tmp/100)%10) + '0';
|
|
buffer[i++] = '.';
|
|
buffer[i++] = ((tmp%100)/10) + '0';
|
|
buffer[i++] = ((tmp%100)%10) + '0';
|
|
buffer[i] = '\0';
|
|
|
|
for(i = 0; buffer[i]; i++)
|
|
{
|
|
*((vs[0].Crtat +
|
|
((vs[0].screen_rows + 2) * vs[0].maxcol)
|
|
) + i
|
|
) = user_attr | buffer[i];
|
|
}
|
|
|
|
#if PCVT_SHOWKEYS
|
|
for(; i < 77; i++)
|
|
{
|
|
*((vs[0].Crtat +
|
|
((vs[0].screen_rows + 2) * vs[0].maxcol)
|
|
) + i
|
|
) = user_attr | ' ';
|
|
}
|
|
|
|
}
|
|
#endif /* PCVT_SHOWKEYS */
|
|
}
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
/* this takes place on EVERY screen which is in HP mode, labels on,!X*/
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
if((vsp->vt_pure_mode == M_HPVT) && (vsp->labels_on))
|
|
{
|
|
register int col = vsp->col+1;
|
|
register u_short *p = vsp->Crtat +
|
|
(vsp->screen_rows * vsp->maxcol);
|
|
|
|
/* update column display between labels */
|
|
|
|
if(vsp->maxcol == SCR_COL132)
|
|
{
|
|
p += (SCR_COL132 - SCR_COL80)/2;
|
|
|
|
if(col >= 100)
|
|
{
|
|
*(p + LABEL_COLU) = user_attr | '1';
|
|
col -= 100;
|
|
}
|
|
else
|
|
{
|
|
*(p + LABEL_COLU) = user_attr | '0';
|
|
}
|
|
}
|
|
*(p + LABEL_COLH) = user_attr | ((col/10) + '0');
|
|
*(p + LABEL_COLL) = user_attr | ((col%10) + '0');
|
|
|
|
/* update row display between labels */
|
|
|
|
*(p + LABEL_ROWH) = (user_attr | (((vsp->row+1)/10) + '0'));
|
|
*(p + LABEL_ROWL) = (user_attr | (((vsp->row+1)%10) + '0'));
|
|
}
|
|
|
|
async_update_exit:
|
|
|
|
if(arg == UPDATE_START)
|
|
{
|
|
async_update_ch = timeout(async_update, UPDATE_START,
|
|
PCVT_UPDATEFAST);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* set character set for virtual screen
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
set_charset(struct video_state *svsp, int curvgacs)
|
|
{
|
|
static int sizetab[] = { 25, 28, 35, 40, 43, 50 };
|
|
int oldsize, oldrows, newsize, newrows;
|
|
|
|
if((curvgacs < 0) || (curvgacs > (NVGAFONTS-1)))
|
|
return;
|
|
|
|
svsp->vga_charset = curvgacs;
|
|
|
|
select_vga_charset(curvgacs);
|
|
|
|
oldsize = svsp->screen_rowsize;
|
|
oldrows = svsp->screen_rows;
|
|
newsize = sizetab[(vgacs[curvgacs].screen_size)];
|
|
newrows = newsize;
|
|
if (svsp->vt_pure_mode == M_HPVT)
|
|
newrows -= 3;
|
|
if (newrows == 25 && svsp->force24)
|
|
newrows = 24;
|
|
if (newrows < oldrows) {
|
|
int nscroll = svsp->row + 1 - newrows;
|
|
|
|
if (svsp->row >= oldrows) /* Sanity check */
|
|
nscroll = oldrows - newrows;
|
|
if (nscroll > 0) {
|
|
/* Scroll up */
|
|
bcopy (svsp->Crtat + nscroll * svsp->maxcol,
|
|
svsp->Crtat,
|
|
newrows * svsp->maxcol * CHR);
|
|
svsp->row -= nscroll;
|
|
svsp->cur_offset -= nscroll * svsp->maxcol;
|
|
}
|
|
if (newrows < newsize)
|
|
fillw(user_attr | ' ',
|
|
svsp->Crtat + newrows * svsp->maxcol,
|
|
(newsize - newrows) * svsp->maxcol);
|
|
} else if (oldrows < newsize)
|
|
fillw(user_attr | ' ',
|
|
svsp->Crtat + oldrows * svsp->maxcol,
|
|
(newsize - oldrows) * svsp->maxcol);
|
|
|
|
svsp->screen_rowsize = newsize;
|
|
svsp->screen_rows = newrows;
|
|
|
|
/* Clip scrolling region */
|
|
if(svsp->scrr_end > svsp->screen_rows - 1)
|
|
svsp->scrr_end = svsp->screen_rows - 1;
|
|
svsp->scrr_len = svsp->scrr_end - svsp->scrr_beg + 1;
|
|
|
|
/* Clip cursor pos */
|
|
|
|
if(svsp->cur_offset > (svsp->scrr_len * svsp->maxcol))
|
|
svsp->cur_offset = (svsp->scrr_len * svsp->maxcol) + svsp->col;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* select a vga character set
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
select_vga_charset(int vga_charset)
|
|
{
|
|
int first, second;
|
|
int fflag = 0;
|
|
int sflag = 0;
|
|
u_char cmap = 0;
|
|
|
|
static u_char cmaptaba[] =
|
|
{0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13};
|
|
|
|
static u_char cmaptabb[] =
|
|
{0x00, 0x04, 0x08, 0x0c, 0x20, 0x24, 0x28, 0x2c};
|
|
|
|
if((adaptor_type != EGA_ADAPTOR) && (adaptor_type != VGA_ADAPTOR))
|
|
return;
|
|
|
|
if((vga_charset < 0) || (vga_charset >= totalfonts))
|
|
return;
|
|
|
|
if(!vgacs[vga_charset].loaded)
|
|
return;
|
|
|
|
/*--------------------------------------------------------------
|
|
find the the first and second charset of a given resolution.
|
|
the first is used for lower 256 and the second (if any) is
|
|
used for the upper 256 entries of a complete 512 entry ega/
|
|
vga charset.
|
|
--------------------------------------------------------------*/
|
|
|
|
for(first = 0; first < totalfonts; first++)
|
|
{
|
|
if(!vgacs[first].loaded)
|
|
continue;
|
|
if(vgacs[first].screen_size != vgacs[vga_charset].screen_size)
|
|
continue;
|
|
if(vgacs[first].char_scanlines !=
|
|
vgacs[vga_charset].char_scanlines)
|
|
continue;
|
|
if(vgacs[first].scr_scanlines !=
|
|
vgacs[vga_charset].scr_scanlines)
|
|
continue;
|
|
fflag = 1;
|
|
break;
|
|
}
|
|
|
|
if(fflag != 1)
|
|
return;
|
|
|
|
for(second = first+1; second < totalfonts; second++)
|
|
{
|
|
if(!vgacs[second].loaded)
|
|
continue;
|
|
if(vgacs[second].screen_size != vgacs[vga_charset].screen_size)
|
|
continue;
|
|
if(vgacs[second].char_scanlines !=
|
|
vgacs[vga_charset].char_scanlines)
|
|
continue;
|
|
if(vgacs[second].scr_scanlines !=
|
|
vgacs[vga_charset].scr_scanlines)
|
|
continue;
|
|
sflag = 1;
|
|
break;
|
|
}
|
|
|
|
cmap = cmaptaba[first];
|
|
if(sflag)
|
|
{
|
|
cmap |= cmaptabb[second];
|
|
vgacs[first].secondloaded = second;
|
|
}
|
|
else
|
|
{
|
|
vgacs[first].secondloaded = 0; /*cs 0 can never become a 2nd!*/
|
|
}
|
|
|
|
if(vsp->wd132col)
|
|
{
|
|
cmap = (vga_charset & 0x07);
|
|
cmap |= 0x10;
|
|
}
|
|
|
|
outb(TS_INDEX, TS_FONTSEL); /* character map select register */
|
|
outb(TS_DATA, cmap); /* new char map */
|
|
|
|
outb(addr_6845, CRTC_MAXROW); /* max scan line reg */
|
|
outb(addr_6845+1,
|
|
vgacs[first].char_scanlines); /* scanlines/char */
|
|
|
|
outb(addr_6845, CRTC_VDE); /* vert display enable end */
|
|
outb(addr_6845+1,
|
|
vgacs[first].scr_scanlines); /* low byte of scr scanlines */
|
|
|
|
if((color == 0) && (adaptor_type == VGA_ADAPTOR))
|
|
{
|
|
outb(addr_6845, CRTC_ULOC); /* underline location reg */
|
|
outb(addr_6845+1, (vgacs[first].char_scanlines & 0x1F));
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* switch vga-card to load a character set
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
setchargen(void)
|
|
{
|
|
chargen_access = 1; /* flag we are accessing the chargen ram */
|
|
|
|
/* program sequencer to access character generator */
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x01); /* synchronous reset */
|
|
|
|
outb(TS_INDEX, TS_WRPLMASK);
|
|
outb(TS_DATA, 0x04); /* write to map 2 */
|
|
|
|
outb(TS_INDEX, TS_MEMMODE);
|
|
outb(TS_DATA, 0x07); /* sequential addressing */
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x03); /* clear synchronous reset */
|
|
|
|
/* program graphics controller to access character generator */
|
|
|
|
outb(GDC_INDEX, GDC_RDPLANESEL);
|
|
outb(GDC_DATA, 0x02); /* select map 2 for cpu reads */
|
|
|
|
outb(GDC_INDEX, GDC_MODE);
|
|
outb(GDC_DATA, 0x00); /* disable odd-even addressing */
|
|
|
|
outb(GDC_INDEX, GDC_MISC);
|
|
outb(GDC_DATA, 0x00); /* map starts at 0xA000 */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* switch vga-card to load a character set to plane 3
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
setchargen3(void)
|
|
{
|
|
chargen_access = 1; /* flag we are accessing the chargen ram */
|
|
|
|
/* program sequencer to access character generator */
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x01); /* synchronous reset */
|
|
|
|
outb(TS_INDEX, TS_WRPLMASK);
|
|
outb(TS_DATA, 0x08); /* write to map 3 */
|
|
|
|
outb(TS_INDEX, TS_MEMMODE);
|
|
outb(TS_DATA, 0x07); /* sequential addressing */
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x03); /* clear synchronous reset */
|
|
|
|
/* program graphics controller to access character generator */
|
|
|
|
outb(GDC_INDEX, GDC_RDPLANESEL);
|
|
outb(GDC_DATA, 0x03); /* select map 3 for cpu reads */
|
|
|
|
outb(GDC_INDEX, GDC_MODE);
|
|
outb(GDC_DATA, 0x00); /* disable odd-even addressing */
|
|
|
|
outb(GDC_INDEX, GDC_MISC);
|
|
outb(GDC_DATA, 0x00); /* map starts at 0xA000 */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* switch back vga-card to normal operation
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
resetchargen(void)
|
|
{
|
|
/* program sequencer to access video ram */
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x01); /* synchronous reset */
|
|
|
|
outb(TS_INDEX, TS_WRPLMASK);
|
|
outb(TS_DATA, 0x03); /* write to map 0 & 1 */
|
|
|
|
outb(TS_INDEX, TS_MEMMODE);
|
|
outb(TS_DATA, 0x03); /* odd-even addressing */
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x03); /* clear synchronous reset */
|
|
|
|
/* program graphics controller to access character generator */
|
|
|
|
outb(GDC_INDEX, GDC_RDPLANESEL);
|
|
outb(GDC_DATA, 0x00); /* select map 0 for cpu reads */
|
|
|
|
outb(GDC_INDEX, GDC_MODE);
|
|
outb(GDC_DATA, 0x10); /* enable odd-even addressing */
|
|
|
|
outb(GDC_INDEX, GDC_MISC);
|
|
if(color)
|
|
outb(GDC_DATA, 0x0e); /* map starts at 0xb800 */
|
|
else
|
|
outb(GDC_DATA, 0x0a); /* map starts at 0xb000 */
|
|
|
|
chargen_access = 0; /* flag we are NOT accessing the chargen ram */
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* switch screen off (VGA only)
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vga_screen_off(void)
|
|
{
|
|
unsigned char old;
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x01); /* synchronous reset */
|
|
|
|
outb(TS_INDEX, TS_MODE); /* clocking mode reg */
|
|
old = inb(TS_DATA); /* get current value */
|
|
|
|
outb(TS_INDEX, TS_MODE); /* clocking mode reg */
|
|
outb(TS_DATA, (old | 0x20)); /* screen off bit on */
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x03); /* clear synchronous reset */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* switch screen back on (VGA only)
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vga_screen_on(void)
|
|
{
|
|
unsigned char old;
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x01); /* synchronous reset */
|
|
|
|
outb(TS_INDEX, TS_MODE); /* clocking mode reg */
|
|
old = inb(TS_DATA); /* get current value */
|
|
|
|
outb(TS_INDEX, TS_MODE); /* clocking mode reg */
|
|
outb(TS_DATA, (old & ~0x20)); /* screen off bit off */
|
|
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x03); /* clear synchronous reset */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* compute character set base address (in kernel map)
|
|
*---------------------------------------------------------------------------*/
|
|
static unsigned char *
|
|
compute_charset_base(unsigned fontset)
|
|
{
|
|
unsigned char *d = (unsigned char *)Crtat;
|
|
|
|
static int charset_offset[8] = { 0x0000, 0x4000, 0x8000, 0xC000,
|
|
0x2000, 0x6000, 0xA000, 0xE000 };
|
|
|
|
static int charsetw_offset[8] = { 0x0000, 0x2000, 0x4000, 0x6000,
|
|
0x8000, 0xA000, 0xC000, 0xE000 };
|
|
|
|
switch(adaptor_type)
|
|
{
|
|
case EGA_ADAPTOR:
|
|
fontset = (fontset > 3) ? 3 : fontset;
|
|
break;
|
|
|
|
case VGA_ADAPTOR:
|
|
fontset = (fontset > 7) ? 7 : fontset;
|
|
break;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
if(color)
|
|
d -= (0xB8000 - 0xA0000); /* Point to 0xA0000 */
|
|
else
|
|
d -= (0xB0000 - 0xA0000); /* Point to 0xA0000 */
|
|
|
|
if(vsp->wd132col)
|
|
d += charsetw_offset[fontset]; /* Load into Character set n */
|
|
else
|
|
d += charset_offset[fontset]; /* Load into Character set n */
|
|
|
|
return d;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* load a char into ega/vga character generator ram
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
loadchar(int fontset, int character, int char_scanlines, u_char *char_table)
|
|
{
|
|
unsigned char *d;
|
|
unsigned char *bak;
|
|
int j, k;
|
|
|
|
if((d = compute_charset_base(fontset)) == 0)
|
|
return;
|
|
|
|
d += (character * 32); /* 32 bytes per character */
|
|
|
|
if(vsp->wd132col &&
|
|
(fontset == 1||fontset == 3||fontset == 5||fontset == 7))
|
|
setchargen3(); /* access chargen ram */
|
|
else
|
|
setchargen(); /* access chargen ram */
|
|
|
|
for(j = k = 0; j < char_scanlines; j++) /* x bit high characters */
|
|
{
|
|
*d = char_table[k];
|
|
d++;
|
|
k++;
|
|
}
|
|
for(; j < 32; j++) /* Up to 32 bytes per character image*/
|
|
{
|
|
*d = 0x00;
|
|
d++;
|
|
}
|
|
|
|
resetchargen(); /* access video ram */
|
|
|
|
if(saved_charsets[fontset] == 0)
|
|
saved_charsets[fontset] =
|
|
(u_char *)malloc(32 * 256, M_DEVBUF, M_WAITOK);
|
|
|
|
if((bak = saved_charsets[fontset]))
|
|
{
|
|
/* make a backup copy of this char */
|
|
bak += (character * 32);
|
|
bzero(bak, 32);
|
|
bcopy(char_table, bak, char_scanlines);
|
|
}
|
|
#ifdef DIAGNOSTIC
|
|
else
|
|
panic("pcvt loadchar: no backup buffer");
|
|
#endif /* DIAGNOSTIC */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* save/restore character set n to addr b
|
|
* since there are always backed up copies, we do not save anything here
|
|
* parameter "b" is totally ignored
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vga_move_charset(unsigned n, unsigned char *b, int save_it)
|
|
{
|
|
unsigned char *d = compute_charset_base(n);
|
|
|
|
if(save_it)
|
|
return;
|
|
|
|
if(saved_charsets[n] == 0)
|
|
#ifdef DIAGNOSTIC
|
|
panic("pcvt: restoring unbuffered charset");
|
|
#else
|
|
return;
|
|
#endif
|
|
|
|
#ifdef DIAGNOSTIC
|
|
if(d == 0)
|
|
panic("vga_move_charset: wrong adaptor");
|
|
#endif
|
|
|
|
if(vsp->wd132col && (n == 1||n == 3||n == 5||n == 7))
|
|
{
|
|
setchargen3();
|
|
d -= 0x2000;
|
|
}
|
|
else
|
|
{
|
|
setchargen();
|
|
}
|
|
|
|
/* PLEASE, leave the following alone using bcopyb, as several */
|
|
/* chipsets have problems if their memory is accessed with 32 */
|
|
/* or 16 bits wide, don't change this to using bcopy for speed! */
|
|
|
|
bcopyb(saved_charsets[n], d,
|
|
256 /* chars */ * 32 /* bytes per char */);
|
|
|
|
resetchargen();
|
|
}
|
|
|
|
#ifndef XSERVER
|
|
/*---------------------------------------------------------------------------*
|
|
* switch to virtual screen n (0 ... PCVT_NSCREENS-1)
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vgapage(int n)
|
|
{
|
|
int cols = vsp->maxcol; /* get current col val */
|
|
|
|
if(n < 0 || n >= totalscreens)
|
|
return;
|
|
|
|
/* video board memory -> kernel memory */
|
|
|
|
bcopy(vsp->Crtat, vsp->Memory, vsp->screen_rows * vsp->maxcol * CHR);
|
|
|
|
vsp->Crtat = vsp->Memory; /* operate in memory now */
|
|
|
|
/* update global screen pointers/variables */
|
|
|
|
current_video_screen = n; /* current screen no */
|
|
|
|
pcvt_ttyp = &pcvt_tty[n]; /* current tty */
|
|
|
|
vsp = &vs[n]; /* current video state ptr */
|
|
|
|
/* kernel memory -> video board memory */
|
|
|
|
bcopy(vsp->Crtat, Crtat, vsp->screen_rows * vsp->maxcol * CHR);
|
|
|
|
vsp->Crtat = Crtat; /* operate on screen now */
|
|
|
|
outb(addr_6845, CRTC_STARTADRH);
|
|
outb(addr_6845+1, 0);
|
|
outb(addr_6845, CRTC_STARTADRL);
|
|
outb(addr_6845+1, 0);
|
|
|
|
select_vga_charset(vsp->vga_charset);
|
|
|
|
if(vsp->maxcol != cols)
|
|
vga_col(vsp, vsp->maxcol); /* select 80/132 columns */
|
|
|
|
outb(addr_6845, CRTC_CURSORH); /* select high register */
|
|
outb(addr_6845+1, vsp->cur_offset >> 8);
|
|
outb(addr_6845, CRTC_CURSORL); /* select low register */
|
|
outb(addr_6845+1, vsp->cur_offset);
|
|
|
|
if(vsp->cursor_on)
|
|
{
|
|
outb(addr_6845, CRTC_CURSTART); /* select high register */
|
|
outb(addr_6845+1, vsp->cursor_start);
|
|
outb(addr_6845, CRTC_CUREND); /* select low register */
|
|
outb(addr_6845+1, vsp->cursor_end);
|
|
}
|
|
else
|
|
{
|
|
sw_cursor(0);
|
|
}
|
|
|
|
if(adaptor_type == VGA_ADAPTOR)
|
|
{
|
|
unsigned i;
|
|
|
|
/* switch VGA DAC palette entries */
|
|
|
|
for(i = 0; i < NVGAPEL; i++)
|
|
vgapaletteio(i, &vsp->palette[i], 1);
|
|
}
|
|
|
|
update_led(); /* update led's */
|
|
|
|
update_hp(vsp); /* update fkey labels, if present */
|
|
}
|
|
#endif /* XSERVER */
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* test if it is a vga
|
|
*---------------------------------------------------------------------------*/
|
|
int
|
|
vga_test(void)
|
|
{
|
|
u_char old, new, check;
|
|
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
old = inb(addr_6845+1); /* get current value */
|
|
|
|
new = old | CURSOR_ON_BIT; /* set cursor on by setting bit 5 on */
|
|
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
outb(addr_6845+1,new); /* cursor should be on now */
|
|
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
check = inb(addr_6845+1); /* get current value */
|
|
|
|
if(check != new)
|
|
{
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
outb(addr_6845+1,old); /* failsafe */
|
|
return(0); /* must be ega */
|
|
}
|
|
|
|
new = old & ~CURSOR_ON_BIT; /* turn cursor off by clearing bit 5 */
|
|
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
outb(addr_6845+1,new); /* cursor should be off now */
|
|
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
check = inb(addr_6845+1); /* get current value */
|
|
|
|
if(check != new)
|
|
{
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
outb(addr_6845+1,old); /* failsafe */
|
|
return(0); /* must be ega */
|
|
}
|
|
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
outb(addr_6845+1,old); /* failsafe */
|
|
|
|
return(1); /* vga */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* convert upper/lower sixel font array to vga font array
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
sixel_vga(struct sixels *sixelp, u_char *vgachar)
|
|
{
|
|
register int i, j;
|
|
register int shift;
|
|
register u_char mask;
|
|
|
|
for(j = 0; j < 16; j++)
|
|
vgachar[j] = 0;
|
|
|
|
mask = 0x01;
|
|
for(j = 0; j < 6; j++)
|
|
{
|
|
for(i = 0, shift = 7; i < 8; i++, shift--)
|
|
vgachar[j] |= ((((sixelp->upper[i]) & mask) >> j)
|
|
<< shift);
|
|
mask <<= 1;
|
|
}
|
|
|
|
mask = 0x01;
|
|
for(j = 0; j < 4; j++)
|
|
{
|
|
for(i = 0, shift = 7; i < 8; i++, shift--)
|
|
vgachar[j+6] |= ((((sixelp->lower[i]) & mask) >>j)
|
|
<< shift);
|
|
mask <<= 1;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Expand 8x10 EGA/VGA characters to 8x16 EGA/VGA characters
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vga10_vga16(u_char *invga, u_char *outvga)
|
|
{
|
|
register int i,j;
|
|
|
|
/*
|
|
* Keep the top and bottom scanlines the same and double every scan
|
|
* line in between.
|
|
*/
|
|
|
|
outvga[0] = invga[0];
|
|
outvga[1] = invga[1];
|
|
outvga[14] = invga[8];
|
|
outvga[15] = invga[9];
|
|
|
|
for(i = j = 2;i < 8 && j < 14;i++,j += 2)
|
|
{
|
|
outvga[j] = invga[i];
|
|
outvga[j+1] = invga[i];
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Expand 8x10 EGA/VGA characters to 8x14 EGA/VGA characters
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vga10_vga14(u_char *invga, u_char *outvga)
|
|
{
|
|
register int i;
|
|
|
|
/*
|
|
* Double the top two and bottom two scanlines and copy everything
|
|
* in between.
|
|
*/
|
|
|
|
outvga[0] = invga[0];
|
|
outvga[1] = invga[0];
|
|
outvga[2] = invga[1];
|
|
outvga[3] = invga[1];
|
|
outvga[10] = invga[8];
|
|
outvga[11] = invga[8];
|
|
outvga[12] = invga[9];
|
|
outvga[13] = invga[9];
|
|
|
|
for(i = 2;i < 8;i++)
|
|
outvga[i+2] = invga[i];
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Expand 8x10 EGA/VGA characters to 8x10 EGA/VGA characters
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vga10_vga10(u_char *invga, u_char *outvga)
|
|
{
|
|
register int i;
|
|
|
|
for(i = 0;i < 10;i++)
|
|
outvga[i] = invga[i];
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Contract 8x10 EGA/VGA characters to 8x8 EGA/VGA characters
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vga10_vga8(u_char *invga, u_char *outvga)
|
|
{
|
|
/* Skip scanlines 3 and 7 */
|
|
|
|
outvga[0] = invga[0];
|
|
outvga[1] = invga[1];
|
|
outvga[2] = invga[2];
|
|
outvga[3] = invga[4];
|
|
outvga[4] = invga[5];
|
|
outvga[5] = invga[6];
|
|
outvga[6] = invga[8];
|
|
outvga[7] = invga[9];
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* disconnect attribute bit 3 from generating intensity
|
|
* (and use it for a second character set !)
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
set_2ndcharset(void)
|
|
{
|
|
if(color) /* prepare to access index register! */
|
|
inb(GN_INPSTAT1C);
|
|
else
|
|
inb(GN_INPSTAT1M);
|
|
|
|
/* select color plane enable reg, caution: set ATC access bit ! */
|
|
|
|
outb(ATC_INDEX, (ATC_COLPLEN | ATC_ACCESS));
|
|
outb(ATC_DATAW, 0x07); /* disable plane 3 */
|
|
}
|
|
|
|
#if PCVT_SCREENSAVER
|
|
#if PCVT_PRETTYSCRNS
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* produce some kinda random number, had a look into the system library...
|
|
*---------------------------------------------------------------------------*/
|
|
static u_short
|
|
getrand(void)
|
|
{
|
|
static unsigned long seed = 1;
|
|
register u_short res = (u_short)seed;
|
|
seed = seed * 1103515245L + time_second;
|
|
return res;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* produce "nice" screensaving ....
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
scrnsv_blink(void * arg)
|
|
{
|
|
static struct rgb blink_rgb[8] =
|
|
{
|
|
{63, 63, 63}, /* white */
|
|
{0, 63, 42}, /* pale green */
|
|
{63, 63, 0}, /* yellow */
|
|
{63, 21, 63}, /* violet */
|
|
{42, 63, 0}, /* yellow-green */
|
|
{63, 42, 0}, /* amber */
|
|
{63, 42, 42}, /* rose */
|
|
{21, 42, 42} /* cyan */
|
|
};
|
|
register u_short r = getrand();
|
|
unsigned pos = (r % (scrnsv_size / 2));
|
|
|
|
*scrnsv_current = /* (0 << 8) + */ ' ';
|
|
scrnsv_current = vsp->Crtat + pos;
|
|
*scrnsv_current = (7 /* LIGHTGRAY */ << 8) + '*';
|
|
if(adaptor_type == VGA_ADAPTOR)
|
|
vgapaletteio(7 /* LIGHTGRAY */, &blink_rgb[(r >> 4) & 7], 1);
|
|
scrnsv_blink_ch = timeout(scrnsv_blink, NULL, hz);
|
|
}
|
|
|
|
#endif /* PCVT_PRETTYSCRNS */
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* set timeout time
|
|
*---------------------------------------------------------------------------*/
|
|
#ifndef XSERVER
|
|
static void
|
|
pcvt_set_scrnsv_tmo(int timeout)
|
|
#else
|
|
void
|
|
pcvt_set_scrnsv_tmo(int timeout)
|
|
#endif /* XSERVER */
|
|
{
|
|
int x = splhigh();
|
|
|
|
if(scrnsv_timeout)
|
|
untimeout(scrnsv_timedout, NULL, scrnsv_timeout_ch);
|
|
|
|
scrnsv_timeout = timeout;
|
|
pcvt_scrnsv_reset(); /* sanity */
|
|
splx(x);
|
|
if(timeout == 0 && savedscreen)
|
|
{
|
|
/* release buffer when screen saver turned off */
|
|
free(savedscreen, M_TEMP);
|
|
savedscreen = (u_short *)0;
|
|
}
|
|
}
|
|
|
|
#if PCVT_GREENSAVER
|
|
/*---------------------------------------------------------------------------*
|
|
* switch monitor on/off
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
green_saver(int blank)
|
|
{
|
|
u_char val;
|
|
|
|
if (blank)
|
|
{
|
|
outb(TS_INDEX, 0x01);
|
|
val = inb(TS_DATA);
|
|
outb(TS_INDEX, 0x01);
|
|
outb(TS_DATA, val | 0x20);
|
|
outb(addr_6845, 0x17);
|
|
val = inb(addr_6845 + 1);
|
|
outb(addr_6845 + 1, val & ~0x80);
|
|
}
|
|
else
|
|
{
|
|
outb(TS_INDEX, 0x01);
|
|
val = inb(TS_DATA);
|
|
outb(TS_INDEX, 0x01);
|
|
outb(TS_DATA, val & 0xDF);
|
|
outb(addr_6845, 0x17);
|
|
val = inb(addr_6845 + 1);
|
|
outb(addr_6845 + 1, val | 0x80);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* we were timed out
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
scrnsv_timedout(void *arg)
|
|
{
|
|
/* this function is called by timeout() */
|
|
/* raise priority to avoid conflicts with kbd intr */
|
|
int x = spltty();
|
|
|
|
/*
|
|
* due to some undefined problems with video adaptor RAM
|
|
* access timing, the following has been splitted into
|
|
* two pieces called subsequently with a time difference
|
|
* of 100 millisec
|
|
*/
|
|
|
|
if(++scrnsv_active == 1)
|
|
{
|
|
register size_t s;
|
|
/*
|
|
* first, allocate a buffer
|
|
* do only if none allocated yet or another size required
|
|
* this reduces malloc() overhead by avoiding successive
|
|
* calls to malloc() and free() if they would have requested
|
|
* the same buffer
|
|
*
|
|
* XXX This is inherited from old days where no buffering
|
|
* happened at all. Meanwhile we should use the standard
|
|
* screen buffer instead. Any volunteers? :-) [At least,
|
|
* this code proved to work...]
|
|
*/
|
|
|
|
s = sizeof(u_short) * vsp->screen_rowsize * vsp->maxcol;
|
|
|
|
if(savedscreen == (u_short *)0 || s != scrnsv_size)
|
|
{
|
|
/* really need to allocate */
|
|
if(savedscreen)
|
|
free(savedscreen, M_TEMP);
|
|
scrnsv_size = s;
|
|
if((savedscreen =
|
|
(u_short *)malloc(s, M_TEMP, M_NOWAIT))
|
|
== (u_short *)0)
|
|
{
|
|
/*
|
|
* didn't get the buffer memory,
|
|
* turn off screen saver
|
|
*/
|
|
scrnsv_timeout = scrnsv_active = 0;
|
|
splx(x);
|
|
return;
|
|
}
|
|
}
|
|
/* save current screen */
|
|
bcopy(vsp->Crtat, savedscreen, scrnsv_size);
|
|
|
|
/* on VGA's, make sure palette is set to blank screen */
|
|
if(adaptor_type == VGA_ADAPTOR)
|
|
{
|
|
struct rgb black = {0, 0, 0};
|
|
vgapaletteio(0 /* BLACK */, &black, 1);
|
|
}
|
|
/* prepare for next time... */
|
|
scrnsv_timeout_ch = timeout(scrnsv_timedout, NULL, hz / 10);
|
|
}
|
|
else
|
|
{
|
|
/* second call, now blank the screen */
|
|
/* fill screen with blanks */
|
|
fillw(/* (BLACK<<8) + */ ' ', vsp->Crtat, scrnsv_size / 2);
|
|
|
|
#if PCVT_PRETTYSCRNS
|
|
scrnsv_current = vsp->Crtat;
|
|
scrnsv_blink_ch = timeout(scrnsv_blink, NULL, hz);
|
|
#endif /* PCVT_PRETTYSCRNS */
|
|
|
|
sw_cursor(0); /* cursor off on mda/cga */
|
|
|
|
#if PCVT_GREENSAVER
|
|
green_saver(1);
|
|
#endif
|
|
}
|
|
splx(x);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* interface to screensaver "subsystem"
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
pcvt_scrnsv_reset(void)
|
|
{
|
|
/*
|
|
* to save lotta time with superfluous timeout()/untimeout() calls
|
|
* when having massive output operations, we remember the last
|
|
* second of kernel timer we've rescheduled scrnsv_timedout()
|
|
*/
|
|
static long last_schedule = 0L;
|
|
register int x = splhigh();
|
|
int reschedule = 0;
|
|
|
|
if((scrnsv_active == 1 || scrnsv_timeout) &&
|
|
last_schedule != time_second)
|
|
{
|
|
last_schedule = time_second;
|
|
reschedule = 1;
|
|
untimeout(scrnsv_timedout, NULL, scrnsv_timeout_ch);
|
|
}
|
|
if(scrnsv_active)
|
|
{
|
|
|
|
#if PCVT_PRETTYSCRNS
|
|
if(scrnsv_active > 1)
|
|
untimeout(scrnsv_blink, NULL, scrnsv_blink_ch);
|
|
#endif /* PCVT_PRETTYSCRNS */
|
|
|
|
bcopy(savedscreen, vsp->Crtat, scrnsv_size);
|
|
if(adaptor_type == VGA_ADAPTOR)
|
|
{
|
|
/* back up VGA palette info */
|
|
vgapaletteio(0 /* BLACK */, &vsp->palette[0], 1);
|
|
|
|
#if PCVT_PRETTYSCRNS
|
|
vgapaletteio(7 /* LIGHTGRAY */, &vsp->palette[7], 1);
|
|
#endif /* PCVT_PRETTYSCRNS */
|
|
|
|
#if PCVT_GREENSAVER
|
|
green_saver(0);
|
|
#endif
|
|
}
|
|
scrnsv_active = 0;
|
|
|
|
if(vsp->cursor_on)
|
|
sw_cursor(1); /* cursor on */
|
|
}
|
|
|
|
if(reschedule)
|
|
{
|
|
/* mark next timeout */
|
|
scrnsv_timeout_ch = timeout(scrnsv_timedout, NULL,
|
|
scrnsv_timeout * hz);
|
|
}
|
|
splx(x);
|
|
}
|
|
|
|
#endif /* PCVT_SCREENSAVER */
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* switch cursor on/off
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
sw_cursor(int onoff)
|
|
{
|
|
if(adaptor_type == EGA_ADAPTOR)
|
|
{
|
|
int start, end;
|
|
if(onoff)
|
|
{
|
|
start = vsp->cursor_start;
|
|
end = vsp->cursor_end;
|
|
}
|
|
else
|
|
{
|
|
int cs = vs[current_video_screen].vga_charset;
|
|
|
|
cs = (cs < 0) ? 0 : ((cs < totalfonts) ?
|
|
cs : totalfonts-1);
|
|
|
|
start = (vgacs[cs].char_scanlines & 0x1F) + 1;
|
|
end = 0;
|
|
}
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
outb(addr_6845+1, start);
|
|
outb(addr_6845,CRTC_CUREND); /* cursor end reg */
|
|
outb(addr_6845+1, end);
|
|
}
|
|
else /* mda, cga, vga */
|
|
{
|
|
outb(addr_6845,CRTC_CURSTART); /* cursor start reg */
|
|
if(onoff)
|
|
outb(addr_6845+1, vsp->cursor_start);
|
|
else
|
|
outb(addr_6845+1, CURSOR_ON_BIT);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* cold init support, if a mono monitor is attached to a
|
|
* vga or ega, it comes up with a mda emulation. switch
|
|
* board to generic ega/vga mode in this case.
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
mda2egaorvga(void)
|
|
{
|
|
/*
|
|
* program sequencer to access
|
|
* video ram
|
|
*/
|
|
|
|
/* synchronous reset */
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x01);
|
|
|
|
/* write to map 0 & 1 */
|
|
outb(TS_INDEX, TS_WRPLMASK);
|
|
outb(TS_DATA, 0x03);
|
|
|
|
/* odd-even addressing */
|
|
outb(TS_INDEX, TS_MEMMODE);
|
|
outb(TS_DATA, 0x03);
|
|
|
|
/* clear synchronous reset */
|
|
outb(TS_INDEX, TS_SYNCRESET);
|
|
outb(TS_DATA, 0x03);
|
|
|
|
/*
|
|
* program graphics controller
|
|
* to access character
|
|
* generator
|
|
*/
|
|
|
|
/* select map 0 for cpu reads */
|
|
outb(GDC_INDEX, GDC_RDPLANESEL);
|
|
outb(GDC_DATA, 0x00);
|
|
|
|
/* enable odd-even addressing */
|
|
outb(GDC_INDEX, GDC_MODE);
|
|
outb(GDC_DATA, 0x10);
|
|
|
|
/* map starts at 0xb000 */
|
|
outb(GDC_INDEX, GDC_MISC);
|
|
outb(GDC_DATA, 0x0a);
|
|
}
|
|
|
|
/* ------------------------- E O F ------------------------------------------*/
|