projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial import, 0.1 + pk 0.2.4-B1
[unix-history] / sys / i386 / isa / codrv / co_vga.c
/*-
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* William Jolitz and Don Ahn.
* Many improvements based on this source are made by Holger Veit.
*
* 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 the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#) $RCSfile: co_vga.c,v $ $Revision: 1.11 $ (Berkeley) $Date: 93/01/23 23:14:55 $
*/
static char rcsid[] = "$Header: /usr/src/sys.386bsd/i386/isa/codrv/RCS/co_vga.c,v 1.11 93/01/23 23:14:55 root Exp Locker: root $";
/*
* History: see CO_HISTORY
*/
#include "co.h"
#include "pc.h"
#if NCO == 1
#if NPC == 0
#include "co_hdr.h"
static char isinitialized = 0; /* =1: console/vtys initialized */
u_short *Crtat = (u_short *)MONO_BUF; /* The only absolute location that is
* known from video memory, everything
* else derived from it,
* modified by device probe */
static int scrblanksave; /* save position cursor */
static u_short *scrbuf = 0; /* buffer for screen saver */
static char *card2name(int id);
/* find video config */
static void probe_video()
{
vga_whoami();
if (vds.color) {
Crtat += (CGA_BUF-MONO_BUF)/CHR;
vds.iobase = 0x3D0; /* color */
} else
vds.iobase = 0x3B0; /* mono */
vds.encoding[0] = XLAT2PC8;
vds.encoding[1] = NOFONT;
vds.f89bit = vds.cardtype >= VG_EGA ? 9 : 8;
}
int coattach(struct isa_device *dev)
{
struct cursorshape cs;
struct kbd_hotkey spec;
int i;
/* re-initialize ALL vtys */
vty_init(0);
/* initialize the ioctl subsystem */
coioctl_init();
printf(" %s", card2name(vds.cardtype));
if (vds.cardsubtype>=0)
printf("/0x%02x", vds.cardsubtype);
printf(" ram %dk io 0x%x kbd 0x%x", vds.ram, vds.iobase, kbs.id);
if (nvty>1) printf(" vtys %d",nvty);
/* create a save buffer for screen saver */
if (!scrbuf) /* XXX modify with different screen sizes */
scrbuf = (u_short*)malloc(vtys[0].size*CHR, M_TEMP, M_NOWAIT);
if (!scrbuf)
panic("coattach: no screen buffer");
#ifdef FAT_CURSOR
cs.start = 0;
cs.end = 18;
vga_setcshape(&cs);
#endif FAT_CURSOR
vds.blanking = 0;
vds.scrtimeout = BLANKTIMEOUT;
vga_doblanking(BLANKSTART);
vga_cursor(0);
/* define the basic special function keys
* CTRL-ALT-DEL (Reset)
* CTRL-ALT-ESC (Debugger)
* CTRL-ALT-F1 (VTY-1)
* CTRL-ALT-F2 (VTY-2)
* CTRL-ALT-F3 (VTY-3)
* CTRL-ALT-F4 (VTY-4)
* CTRL-ALT-F5 (VTY-5)
* CTRL-ALT-F6 (VTY-6)
* CTRL-ALT-F7 (VTY-7)
* CTRL-ALT-F8 (VTY-8)
* CTRL-ALT-F9 (VTY-9)
* CTRL-ALT-F10 (VTY-10)
* CTRL-ALT-F11 (VTY-11)
* CTRL-ALT-F12 (VTY-12)
*/
spec.key = 104; /*DEL*/
spec.modifier = KBD_EXT_CA; /*CTRL-ALT*/
spec.function = KBD_RESETKEY;
kbd_sethotkey(&spec);
#if NDDB > 0
spec.key = 110; /*ESC*/
spec.function = KBD_DEBUGKEY;
kbd_sethotkey(&spec);
#endif
for (i=0; i<12; i++) {
spec.key = 112+i;
spec.function = i;
kbd_sethotkey(&spec);
}
}
/*
* vga_cursor():
* reassigns cursor position, updated by the rescheduling clock
* which is a index (0-1999) into the text area. Note that the
* cursor is a "foreground" character, it's color determined by
* the fg_at attribute. Thus if fg_at is left as 0, (FG_BLACK),
* as when a portion of screen memory is 0, the cursor may dissappear.
*/
void vga_setcursorpos(int pos)
{
outb(vds.iobase+4, M6845_CURSORH);
outb(vds.iobase+5, pos>> 8);
outb(vds.iobase+4, M6845_CURSORL);
outb(vds.iobase+5, pos);
}
void vga_cursor(int a)
{
vga_setcursorpos(actvty->crtat-actvty->Crtat);
if (a == 0 && actvty->visible == 1)
timeout(vga_cursor, 0, hz/10);
}
#ifndef MINITERM
/* Screen saver function:
* XXX to be changed for graphics console
*
* if screenblanking is enabled, the display is switched off after delay
* given in scrtimeout (in sec.)
* Any key hit restarts display again and restarts the timer.
* scrtimeout = 0 disables blanking.
* Also, blanking is suspended if console_x_mode is active, because it
* is supposed that X11 has its own facilities to turn off display.
*/
static struct cursorshape playsave = { -1,-1 };
#if SCRSAVER == 1
/*ARGSUSED*/
static void display_off(int arg,int ctime)
{
static int play1,play2,play3,play4;
int dir[] = { -79,-81,79,81 };
register s;
int size = actvty->size;
if (!actvty->visible) return; /* no show on invisible screen */
if (vds.blanking==1) {
/* This idea was in parts borrowed from Linux, since I
* was too lazy to play around with the video registers
* (although there are suited bits to switch)
* screenplay originally by me (holgi)
*/
bcopy(actvty->Crtat,scrbuf,size*CHR);
fillw(0x0820,actvty->Crtat, actvty->size);
scrblanksave = actvty->crtat-actvty->Crtat;
vds.blanking = 2;
play1 = actvty->crtat-actvty->Crtat;
play2 = time.tv_sec;
play3 = 7;
play4 = 1;
untimeout(vga_cursor, 0);
}
/* some animation */
s = spltty();
vga_setcursorpos(play1);
if (!play3) {
play2 = (play2 % 1237) + 997;
play3 = 4 + (play2 % 9);
if (((play2>>3)&3)==play4)
play4=(play4+1)%4;
else
play4=(play2>>3)&3;
} else play3--;
play1 += dir[play4];
if (play1<0) play1 += size;
else if (play1 >= size) play1 -= size;
timeout(display_off,0,hz/4);
splx(s);
}
#else
#if SCRSAVER == 2 /* moving snake by Chr. Robitschko */
/* XXX This code could be merged with the standard saver, because there are
not many modifications, but I need things to do for the next version */
static void display_off(int arg,int ctime)
{
int dir[] = { -79,-81,79,81 };
register s, f;
#ifdef NETBSD
const char snake[] = { "NetBSD" };
#else
const char snake[] = { "386BSD" };
#endif
const int snlen = sizeof(snake) - 1;
static char *snpos[snlen];
static int play1,play2,play3,play4;
struct cursorshape cs;
int size = actvty->size;
if (!actvty->visible) return; /* no show on invisible screen */
if (vds.blanking==1) {
/* disable cursor -hv- */
vga_getcshape(&playsave);
cs.start = 31;
cs.end = 30;
vga_setcshape(&cs);
bcopy(actvty->Crtat,scrbuf,size*CHR);
fillw(0x0820,actvty->Crtat, actvty->size);
scrblanksave = actvty->crtat-actvty->Crtat;
vds.blanking = 2;
play1 = actvty->crtat-actvty->Crtat;
play2 = time.tv_sec;
play3 = 7;
play4 = 1;
for (f=0; f<snlen; f++)
snpos[f] = (char *)0;
untimeout(vga_cursor, 0);
}
/* some animation */
s = spltty();
if (snpos[snlen-1]) *snpos[snlen-1] = ' ';
for (f=snlen-1; f>0; f--)
snpos[f] = snpos[f-1];
snpos[0] = (char *)(Crtat + play1);
for (f=snlen-1; f>=0; f--)
if (snpos[f]) *snpos[f] = snake[f];
if (!play3) {
play2 = (play2 % 1237) + 997;
play3 = 4 + (play2 % 9);
if (((play2>>3)&1)==play4%2)
play4=(play4+1)%4;
else
play4=(play2>>3)&3;
} else play3--;
play1 += dir[play4];
if (play1<0) play1 += size;
else if (play1 >= size) play1 -= size;
timeout(display_off,0,hz/4);
splx(s);
}
#else
ERROR! NEED SCRSAVER=1 OR 2
#endif /* SCRSAVER=2 */
#endif /* SCRSAVER=1 */
/* XXX graphics */
static void display_on()
{
/* reload old content */
if (vds.blanking==2) {
bcopy(scrbuf,actvty->Crtat,actvty->size*CHR);
if (playsave.start != -1) vga_setcshape(&playsave);
vga_setcursorpos(scrblanksave);
vga_cursor(0);
}
}
/* XXX graphics */
void vga_doblanking(int fct)
{
/* restore display, just in case */
display_on();
/* timer was started, stop */
if (vds.blanking<3)
untimeout(display_off,0);
vds.blanking = 0;
if (fct==BLANKSTART) {
if (vds.scrtimeout) {
/* start it */
timeout(display_off,0,vds.scrtimeout*hz);
vds.blanking = 1;
}
}
/*else if(fct==BLANKSTOP) vds.blanking = 0;*/
}
#else /* MINITERM */
/*ARGSUSED*/
static void display_off(int arg,int ctime) {}
static void display_on() {}
void vga_doblanking(int fct) {}
#endif
/* normally called by init_main to do local initialisation */
/* called by sput, if anyone is faster than init_main, e.g. ddb */
void consinit ()
{
if (isinitialized == 0)
{
/* find out video card */
probe_video();
/* initialize video device */
emul_initvideo();
/* disable screensaver */
vds.blanking = 3;
/* initialize a single terminal */
vty_init(1);
isinitialized = 1;
/* NetBSD would like to have this,
* and for 386bsd it doesn't make problems */
cons_normal();
}
}
/*
* sput calls vtemul_exec for terminal emulation
* if ka, use kernel attributes.
*/
void sput(int vtynum, XCHAR c, int ka)
{
register struct vty *act;
if (!isinitialized)
consinit();
/* necessary: turn on display again */
if (vds.blanking==2) vga_doblanking(BLANKSTART);
/* select vty */
act = &vtys[vtynum];
/* select attribute set */
act->op = ka ? &act->om[1] : &act->om[0];
/* process input */
vtemul_exec(act, c);
/* re-set cursor position */
if (ka) vga_cursor(1);
}
/* both routines used by init_main for more portability */
void cons_highlight()
{
register struct vty *p = &vtys[0];
p->op = &p->om[1];
emul_setattributes(p,3,15);
}
void cons_normal()
{
register struct vty *p = &vtys[0];
p->op = &p->om[1];
emul_setattributes(p,0,0);
}
/*
* vga_whoami: try to detect whether a SVGA is present
* see Ferraro, Programmer's guide to the EGA/VGA cards for more info
*/
/*
* Try to identify, which video card is in the system
*/
void vga_whoami()
{
register int iobase;
u_char *cp;
u_char *videobios;
u_short *vp;
u_short vsave;
volatile u_char lock,save1,save2,save3,save4;
vds.color = 1; /* default */
vds.cardtype = VG_UNKNOWN;
vds.cardsubtype = -1;
vds.ram = 64;
/* first look whether there is RAM in the COLOR region, if this is
* a mono card, there is none
*/
vp = Crtat + (CGA_BUF-MONO_BUF)/CHR;
vsave = *vp;
*vp = 0xCC33;
DELAY(100); /* wait 100 us, doesn't help if you buffer your isa
* bus lines with large capacitors :-)
*/
if (*vp == 0xCC33) goto not_a_mono;
else {
/* we are paranoid */
*vp = 0xA55A;
DELAY(100);
if (*vp == 0xA55A) goto not_a_mono;
}
/* oh, that poor owner has only a MDA/Hercules card :-) */
*vp = vsave;
vds.ram = 16;
vds.color = 0;
vds.cardtype = VG_MONO;
return;
not_a_mono:
*vp = vsave;
/* there is RAM in the ???B8000 region, look which color card we have
* Hmmm... the ancient CGA was supported by the ROMBIOS, and had no ROM
* on board, but the EGA's and VGA's have
*/
videobios = cp = (u_char*)Crtat + (EGA_BIOS-MONO_BUF);
/* Some machines map video BIOS to e0000 instead of c0000.
* Check it now.
*/
if (*cp != 0x55 || *(cp+1) != 0xAA)
videobios = cp = (u_char*)Crtat + (ALTEGA_BIOS-MONO_BUF);
if (*cp != 0x55 || *(cp+1) != 0xAA) {
/* There is no ROM ID.
* you do not plan to run X11 with this card, do you?
*/
vds.ram = 16;
vds.cardtype = VG_CGA;
return;
}
/* this is an EGA or a VGA or a SVGA or something else quite strange
* so lets look whether this is a VGA. We know that several EGA
* registers are readonly, which is really a design fault.
* so just look, whether we can write and read something into
* such a register: this will hold for the CRT address register at
* iobase+4 and the graphics control address
*/
if (inb(0x3cc) & 1) {
iobase = vds.iobase = 0x3D0;
} else
{
iobase = vds.iobase = 0x3B0;
vds.color = 0;
}
outb(iobase+4, 7);
DELAY(100);
if (inb(iobase+4) != 7) vds.cardtype = VG_EGA;
else {
outb(0x3ce,2);
DELAY(100);
if (inb(0x3ce) != 2) vds.cardtype = VG_EGA;
}
if (vds.cardtype==VG_EGA) {
vds.ram = 64; /* for simplicity assume the worst */
return;
}
/* There is a problem now: 8514/A adapters also have ROM, unfortunately
* I don't have sufficient information about the 8514/A and the XGA,
* so just don't try 386BSD with it !
*/
/* I don't know whether this already qualifies for a VGA, so
* someone may add some code here, but for now I am persuaded that I
* have a VGA at this point. This might be a SVGA, however, so let's
* look if this assumption is true. Hard stuff follows...
* refer to Ferraro: Programmer's Guide to the EGA and VGA Cards
* 2nd ed, Addison-Wesley, 1990
*/
vds.cardtype = VG_VGA;
/* unlock paradise registers */
outb(iobase+4, 0x11); lock = inb(iobase+5); outb(iobase+5, lock & 0x7f);
/* now check for a PVGA1 */
cp = videobios + 0x007d;
if (*cp=='V' && *(cp+1)=='G' && *(cp+2)=='A' && *(cp+3)=='=') {
/* this is a paradise, now check which one */
vds.cardtype = VG_PARADISE;
outw(0x3CE, 0x050F);
outw(iobase+4, 0x8529);
outb(iobase+4,0x2b); save1 = inb(iobase+5);
outb(iobase+5,0xaa); save2 = inb(iobase+5);
outb(iobase+5,save1);
if (save2 != 0xaa) { vds.cardsubtype = 0x01; goto foundp2; }
outb(0x3c4,0x12); save1 = inb(0x3c5);
outb(0x3c5,save1 & 0xbf); save2 = inb(0x3c5) & 0x40;
if (save2) { vds.cardsubtype = 0x01; goto foundp2; }
outb(0x3c5,save1 | 0x40); save2 = inb(0x3c5) & 0x40;
if (!save2) { vds.cardsubtype = 0x02; goto foundp; }
outb(0x3c5,save1);
save3 = 0;
outb(0x3c4,0x10); save1 = inb(0x3c5);
outb(0x3c5, save1 & 0xfb); save2 = inb(0x3c5) & 0x04;
if (save2) save3 = 1;
outb(0x3c5, save1 | 0x04); save2 = inb(0x3c5) & 0x04;
if (!save2) save3 = 1;
vds.cardsubtype = save3 ? 0x03 : 0x04;
foundp: outb(0x3c5,save1);
foundp2: if (vds.cardsubtype != -1) {
/* find ram */
outb(0x3ce,0x0b);
switch(inb(0x3cf) & 0xc0) {
case 0x80: vds.ram = 512; break;
case 0xc0: vds.ram = 1024; break;
default: vds.ram = 256;
}
return;
}
}
/* Strategy: The ET4000 uses the reg 3x5/33, the ET3000 uses the 3x5/23
* uniquely, the WD paradises also use 3x5/33. So check for Paradise
* first, and if it's not, check for 3000/4000 with these registers
*/
/* Is this a TSENG? */
outb(0x3bf, 3);
outb(iobase+8,0xa0);
save1 = inb(iobase+0x0A);
outb(0x3C0, 0x20|0x16); save2 = inb(0x3C1);
outb(0x3C0, save2 ^ 0x10);
outb(0x3C0, 0x20|0x16); save3 = inb(0x3C1);
outb(0x3C0, save2);
if (save3 == (save2 ^ 0x10)) {
/* assume it is a Tseng, but which one */
outb(iobase+4, 0x23); save2 = inb(iobase+5);
outb(iobase+5, save2 ^ 0x07); save3 = inb(iobase+5);
outb(iobase+5, save2);
if (save3 == (save2 ^ 0x07)) {
vds.ram = 512;
vds.cardtype = VG_ET3000;
} else
{
/* same experiment for reg 33 */
outb(iobase+4, 0x33); save2 = inb(iobase+5);
outb(iobase+5, save2 ^ 0x0f); save3 = inb(iobase+5);
outb(iobase+5, save2);
if (save3 == (save2 ^ 0x0f)) {
vds.cardtype = VG_ET4000;
outb(iobase+4,0x37);
switch (inb(iobase+5) & 03) {
case 1: vds.ram = 256; break;
case 2: vds.ram = 512; break;
case 3: vds.ram = 1024; break;
}
}
}
}
/* cleanup for TSENG */
outb(0x3bf, 1);
outb(iobase+8, 0xa0);
if (vds.cardtype != VG_VGA) return;
/* now look for the GENOAs */
cp = videobios + 0x37;
cp += (u_char)*cp; /* at 0x37 is the offset to the real signature */
if (*cp==0x77 && *(cp+2)==0x66 && *(cp+3)==0x99) {
/* this is a GENOA. Note that the GENOAs 5xxx are
* really TSENG ET3000, so they should have fallen
* through the sieve above already, if not, something's
* quite strange here, so I don't believe its a GENOA
*/
vds.cardtype = VG_GENOA;
vds.cardsubtype = *(cp+1);
switch (vds.cardsubtype) {
default:
case 0x33: /* shouldn't reach this */
case 0x55: vds.cardtype = VG_VGA; return;
case 0x22:
case 0x00: vds.ram = 256; return;
case 0x11: vds.ram = 512; return;
}
/*NOTREACHED*/
}
/*
* Look for the Tridents
*/
outb(0x3c4, 0x0e); save1 = inb(0x3c5);
outb(0x3c5, 0); save2 = inb(0x3c5) & 0x0f;
outb(0x3c5, save1 ^ 0x02);
if (save2==0x02) {
/* is a Trident */
vds.cardtype = VG_TVGA;
outb(0x3c4, 0x0b);
outb(0x3c5, 0);
save1 = inb(0x3c5);
/* restore "old mode", recommended by
* chmr@edvz.tu-graz.ac.at (Christoph Robitschko)
*/
outb(0x3c5, 0);
vds.cardsubtype = save1;
if (save1== 0xfd) /*TVGA 9000*/
vds.ram = 1024;
else
vds.ram = 512; /* There is 3c4/1f, but I don't know the encoding */
return;
}
/* for the moment X11 does not know any more chips, but
* I found some more in Ferraro's book
*
* Video 7
*/
outw(0x3c4,0xea06);
outb(iobase+4,0x0c); save1 = inb(iobase+5);
outb(iobase+5,0x55); save2 = inb(iobase+5);
outb(iobase+4,0x1f); save3 = inb(iobase+5);
outb(iobase+4,0x0c); outb(iobase+5,save1);
if (save3 == (0x55^0xea)) {
/* this is a video 7 */
vds.cardtype = VG_VIDEO7;
outb(0x3c4, 0x8e);
vds.cardsubtype = inb(0x3c5);
if (vds.cardsubtype > 0x40 && vds.cardsubtype < 0x4a)
vds.ram = 1024; /* 1024i */
else
vds.ram = 512;
return;
}
/* C&T Chips, I'm not sure about that, in particular the
* strange 46E8 port, I somewhere heard that I/O space is
* 0000-03FF only, but I don't know whether any chipset
* clips this range. Anyway...
*/
outb(0x46e8,0x1e);
if (inb(0x104)==0xa5) {
outb(0x103, 0x80); outb(0x46e8, 0x0e);
outb(0x3d6, 0);
vds.cardtype = VG_CHIPS;
vds.cardsubtype = inb(0x3d7) & 0xf0;
switch(vds.cardsubtype) {
case 0x10:
outb(0x3d6, 0x3a); save1=inb(0x3d7);
outb(0x3d7, 0xaa); save2=inb(0x3d7);
outb(0x3d7, save1);
if (save2==0xaa) {
vds.cardsubtype = 0x11;
vds.ram = 1024;
} else
vds.ram = 256;
break;
case 0x20: vds.ram = 256; break;
case 0x30: vds.ram = 1024; break;
case 0x50: vds.ram = 256;
}
outb(0x46e8, 0x1e); outb(0x103, 0);
}
outb(0x46e8, 0x0e);
/* the two ATI's */
cp = videobios + 0x0031;
if (!bcmp(cp,"761295520",9)) {
/* is an ATI, also unsure about the numbers */
vds.cardtype = VG_ATI;
cp = videobios + 0x0042;
vds.cardsubtype = *cp | (*(cp+1)<<8);
vp = (u_short *) videobios + 0010;
vds._atiext = *vp;
outb(*vp,0xbb); save1 = inb((*vp)+1);
vds.ram = (save1 & 0x20) ? 512 : 256;
return;
}
/* I don't know more types, so assume
* it is a VGA (at least looks as if)
*/
vds.ram = 256;
vds.cardtype = VG_VGA;
return;
}
static char *card2name(int id)
{
static char *nametable[] = {
/* 0 */ "UNKNOWN",
/* 1 */ "MDA/Hercules",
/* 2 */ "CGA",
/* 3 */ "EGA",
/* 4 */ "VGA",
/* 5 */ "C&T",
/* 6 */ "Genoa VGA",
/* 7 */ "Paradise VGA",
/* 8 */ "Trident VGA",
/* 9 */ "Tseng ET3000",
/* 10 */ "Tseng ET4000",
/* 11 */ "Video7 VGA",
/* 12 */ "ATI VGA",
0,
};
return nametable[id];
}
/*
* set cursor shape
*/
int vga_setcshape(struct cursorshape *data)
{
register s,e;
s = data->start;
e = data->end;
/* I don't do error correction here, the user should pass
* correct and checked data! Note: The registers allow 5 Bits == 31
*/
if (s<0 || s>31 || e<0 || e>31) return EINVAL;
/* the Tridents seem to have the feature to switch off
* cursor when start is 0 (not verified)
*/
if (vds.cardtype==VG_TVGA && s==0) s=1;
outb(vds.iobase+4, M6845_CURSTART);
outb(vds.iobase+5, s);
outb(vds.iobase+4, M6845_CUREND);
outb(vds.iobase+5, e);
}
#ifndef MINITERM
int vga_getcshape(struct cursorshape *data)
{
/* update from registers */
outb(vds.iobase+4, M6845_CURSTART);
data->start = inb(vds.iobase+5) & 0x1F;
outb(vds.iobase+4, M6845_CUREND);
data->end = inb(vds.iobase+5) & 0x1F;
return 0;
}
#endif
int vga_getvideoinfo(struct videoinfo *data)
{
int i;
bcopy(card2name(vds.cardtype),data->name,20);
data->type = vds.cardtype;
data->subtype = vds.cardsubtype;
data->ram = vds.ram;
data->iobase = vds.iobase;
return 0;
}
static char modesave;
void vga_enablecg()
{
register iobase = vds.iobase;
while((inb(iobase+10)&0x08)==0); /* wait for vertical blanking */
inb(iobase+10);
outb(0x3C0,0x30); modesave = inb(0x3C1);
inb(iobase+10);
outb(0x3C0,0x30); outb(0x3C0, 0x01); /* graphics mode */
/* outw(0x3c4,0x0100);*/ /* hold sequencer synch reset */
outw(0x3c4,0x0402); /* write enable map "page" */
outw(0x3c4,0x0604); /* set sequential addressing */
/* outw(0x3c4,0x0300);*/ /* release sequencer synch reset */
outw(0x3ce,0x0204); /* select map "page" for cpu reading */
outw(0x3ce,0x0005); /* RM=0,O/E=0,WM=00 */
outw(0x3ce,0x0d06); /* map at "B8000" */
}
void vga_disablecg()
{
register iobase10 = vds.iobase+10;
char seq;
inb(iobase10);
outb(0x3C0,0x30); outb(0x3C0, modesave); /* alpha mode */
/* outw(0x3c4,0x0100);*/ /* hold sequencer synch reset */
outw(0x3c4,0x0302); /* write enable text pages */
outw(0x3c4,0x0304); /* set O/E addressing */
/* outw(0x3c4,0x0300);*/ /* release sequencer synch reset */
outw(0x3ce,0x0004); /* select map 0 for cpu reading */
outw(0x3ce,0x1005); /* RM=0,O/E=0,WM=00 */
outw(0x3ce,0x0e06); /* map at "B8000", Chain O/E */
/* set the 8/9 bit according to the state of vds.f89
* The little problem is that with a EGA we have to guess
* the old value (but it is usually 0x03)
*/
if (vds.cardtype != VG_EGA) {
inb(iobase10);
outb(0x3c0,0x20|0x10);
seq = inb(0x3c1);
}
else
seq = 0x03;
inb(iobase10);
outb(0x3c0,0x20|0x10);
if (vds.f89bit == 9) outb(0x3c0, seq | 0x04);
else outb(0x3c0, seq & ~0x04);
while(inb(iobase10)&0x08); /* wait for end of vertical blanking */
}
static u_char iso2pc8[] = {
/*A0*/ 0xff,0xad,0x9b,0x9c,0xfe,0x9d,0x7c,0x15,
/*A8*/ 0xfe,0xfe,0xa6,0xae,0xaa,0x2d,0xfe,0xfe,
/*B0*/ 0xf8,0xf1,0xfd,0xfe,0xfe,0xe6,0x14,0xf9,
/*B8*/ 0xfe,0xfe,0xa7,0xaf,0xac,0xfd,0xfe,0xa8,
/*C0*/ 0xfe,0xfe,0xfe,0xfe,0x8e,0x8f,0x92,0x80,
/*C8*/ 0xfe,0x90,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,
/*D0*/ 0xfe,0xa5,0xfe,0xfe,0xfe,0xfe,0x99,0xfe,
/*D8*/ 0xfe,0xfe,0xfe,0xfe,0x9a,0xfe,0xfe,0xe1,
/*E0*/ 0x85,0xa0,0x83,0xfe,0x84,0x86,0x91,0x87,
/*E8*/ 0x8a,0x82,0x88,0x89,0x8d,0xa1,0x8c,0x8b,
/*F0*/ 0xfe,0xa4,0x95,0xa2,0x93,0xfe,0x94,0xf6,
/*F8*/ 0xfe,0x97,0xa3,0x96,0x81,0xfe,0xfe,0x98
};
/* needs attribute byte to select font */
int vga_xlatiso646(struct vty *vp,u_short *at,u_short *sat,int c)
{
int f2flag = vp->op->f2;
if (vds.encoding[1] != NOFONT) { /* second font loaded? */
if (f2flag) {
*at |= 0x08; /* select font 2 */
*sat |= 0x08;
} else
{
*at &= 0xF7;
*sat &= 0xF7;
}
} else f2flag = 0; /* ignore font switch */
/* need to translate character? */
if (f2flag==0 && vds.encoding[0]==XLAT2PC8)
return (c<0xa0) ? c : iso2pc8[c-0xa0];
else
return c;
}
/***********************************************************************
* Support functions for the terminal emulator
**********************************************************************/
#ifndef GFX_CONSOLE
/*
* moves the cursor up n lines
*/
void vga_cursorup(struct vty *vp, int n)
{
register pos;
if (n <= 0) n = 1;
pos = vp->crtat - vp->Crtat;
pos -= vp->ncol * n;
vp->row--;
if (pos < 0) {
pos += vp->size;
vp->row = vp->nrow-1;
}
vp->crtat = vp->Crtat + pos;
}
/*
* moves the cursor down n lines
*/
void vga_cursordown(struct vty *vp, int n)
{
register pos;
if (n <= 0) n = 1;
pos = vp->crtat - vp->Crtat;
pos += vp->ncol * n;
vp->row++;
if (pos >= vp->size) {
pos -= vp->size;
vp->row = 0;
}
vp->crtat = vp->Crtat + pos;
}
/*
* moves the cursor left n columns
*/
void vga_cursorleft(struct vty *vp, int n)
{
register pos;
if (n <= 0) n = 1;
pos = vp->crtat - vp->Crtat;
pos -= n; vp->col -= n;
if (vp->col < 0) {
vp->col += vp->ncol;
pos += vp->ncol; /* cursor stays on same line */
}
vp->crtat = vp->Crtat + pos;
}
/*
* moves the cursor right n columns
* wrap=1: cursor stays on same line
*/
void vga_cursorright(struct vty *vp, int n, int wrap)
{
register pos;
if (n <= 0) n = 1;
pos = vp->crtat - vp->Crtat;
pos += n; vp->col += n;
if (wrap && vp->col >= vp->ncol) {
vp->col -= vp->ncol;
pos -= vp->ncol; /* cursor stays on same line */
}
vp->crtat = vp->Crtat + (pos % vp->size);
}
/*
* scrollup n lines and fill free space with default attribute
* cm = 1: also move cursor
*/
void vga_scrollup(struct vty *vp,int n, int cm)
{
u_short attr = vp->op->def_at;
int blkx,blky;
if (n <= 0) n = 1;
blkx = vp->ncol*n;
blky = vp->size - blkx;
bcopy(vp->Crtat+blkx, vp->Crtat, blky*CHR);
fillw((attr <<8)+' ', vp->Crtat+blky, blkx);
if (cm) {
vp->crtat -= blkx;
vp->row-= n;
}
}
#ifndef MINITERM
/*
* scroll down n lines and fill free space with default attribute
*/
void vga_scrolldown(struct vty *vp, int n)
{
u_short attr = vp->op->def_at;
int blkx;
if (n <= 0) n = 1;
blkx = vp->ncol*n;
bcopy(vp->Crtat, vp->Crtat+blkx, (vp->size-blkx)*CHR);
fillw((attr <<8)+' ', vp->Crtat, blkx);
/* XXX vp->crtat += blkx; */
}
#endif /*!MINITERM*/
/*
* set the absolute cursor position (row,col = 0..max)
*/
void vga_cursormove(struct vty *vp, int row, int col)
{
if (row==0 || col==0) {
vp->crtat = vp->Crtat;
vp->row = 0;
vp->col = 0;
} else if (col <= vp->ncol && row <= vp->nrow) {
vp->crtat = vp->Crtat + (row - 1) * vp->ncol + col - 1;
vp->col = col - 1;
vp->row = row - 1;
}
}
/*
* cursorrelative: move cursor relative, don't check for outside of screen
*/
void vga_cursorrelative(struct vty *vp, int dx, int dy)
{
int incr = dy*vp->ncol + dx;
int pos = vp->crtat - vp->Crtat;
/* if ((pos+incr) < 0 || (pos+incr) >= vp->size)
return;
*/ vp->crtat += incr;
vp->col = (vp->col+dx) % vp->ncol;
vp->row = (vp->row+dy) % vp->nrow;
}
/*
* Clear screen with default attr
* mode = 0: from cursor to end of screen
* = 1: cursor position only
* = 2: whole display
*/
void vga_clearcursor(struct vty *vp, int mode)
{
u_short attr = (vp->op->def_at << 8) | ' ';
/* clear ... */
switch (mode) {
case 0: /* ... to end of display */
fillw(attr, vp->crtat, vp->Crtat + vp->size - vp->crtat);
break;
case 1: /* ... to next location */
fillw(attr, vp->Crtat, vp->crtat - vp->Crtat + 1);
break;
case 2: /* ... whole display */
fillw(attr, vp->Crtat, vp->size);
}
}
/*
* Clear line and fill with default attr
* mode = 0: from cursor to end of line
* = 1: from beginning to cursor
* = 2: whole line
*/
#ifndef MINITERM
void vga_clearline(struct vty *vp, int mode)
{
u_short attr = (vp->op->def_at << 8) | ' ';
/* clear ... */
switch (mode) {
case 0: /* ... current to EOL */
fillw(attr, vp->crtat,
vp->ncol - (vp->crtat - vp->Crtat) % vp->ncol);
break;
case 1: /* ... beginning to next */
fillw(attr,
vp->crtat - (vp->crtat - vp->Crtat) % vp->ncol,
((vp->crtat - vp->Crtat) % vp->ncol) + 1);
break;
case 2: /* ... entire line */
fillw(attr, vp->crtat - (vp->crtat - vp->Crtat) % vp->ncol,
vp->ncol);
}
}
/*
* delete n lines from cursor position to end, pull up lines with default attr
*/
void vga_deleteline(struct vty *vp, int n)
{
u_short *crtend,*pp;
u_short attr = (vp->op->def_at <<8) | ' ';
if (n <= 0) n = 1;
/* Work from beginning of line */
vp->crtat -= (vp->crtat - vp->Crtat) % vp->ncol;
vp->col = 0;
crtend = vp->Crtat + vp->size;
/* Cap affected area at bottom of screen */
if ((pp = (vp->crtat + n*vp->ncol)) > crtend) {
n = (crtend-vp->crtat) / vp->ncol;
pp = crtend;
}
/* If there's visible lines left, move them up */
if (pp < crtend) {
bcopy(pp, vp->crtat, (crtend-pp)*CHR);
}
fillw(attr, crtend - n*vp->ncol, n*vp->ncol);
}
/*
* insert n lines from cursor position to end, fill with default attr
*/
void vga_insertline(struct vty *vp, int n)
{
u_short *crtend,*pp;
u_short attr = (vp->op->def_at << 8) | ' ';
if (n <= 0) n = 1;
/* Work from beginning of line */
vp->crtat -= (vp->crtat - vp->Crtat) % vp->ncol;
vp->col = 0;
crtend = vp->Crtat + vp->size;
/* Cap affected area at bottom of screen */
if ((pp = (vp->crtat + n*vp->ncol)) > crtend) {
n = (crtend-vp->crtat) / vp->ncol;
pp = crtend;
}
/* If there's visible lines left, move them down */
if (pp < crtend) {
bcopy(vp->crtat, pp, (crtend-pp)*CHR);
}
fillw(attr, vp->crtat, n*vp->ncol);
}
/*
* Delete n chars in line, fill free space with default attr
*/
void vga_deletechars(struct vty *vp, int n)
{
u_short *crtend,*pp;
u_short attr = (vp->op->def_at << 8) | ' ';
if (n <= 0) n = 1;
/* Point to end of current line */
pp = vp->crtat + (vp->ncol - (vp->crtat-vp->Crtat) % vp->ncol);
/* Cap delete to end of current line */
if ((vp->crtat+n) > pp)
n = pp-vp->crtat;
/* If visible characters, move in */
if ((vp->crtat+n) < pp)
bcopy(vp->crtat+n, vp->crtat, ((pp-vp->crtat)-n)*CHR);
/* Blank out space at end of line */
fillw(attr, pp-n, n);
}
/*
* Delete n chars in line, fill free space with default attr
*/
void vga_insertchars(struct vty *vp, int n)
{
u_short *crtend,*pp;
u_short attr = (vp->op->def_at << 8) | ' ';
if (n <= 0) n = 1;
/* Point to end of current line */
pp = vp->crtat + (vp-> ncol - (vp->crtat-vp->Crtat) % vp->ncol);
/* Cap insert to end of current line */
if ((vp->crtat+n) > pp)
n = pp-vp->crtat;
/* If visible characters, move out */
if ((vp->crtat) < pp)
bcopy(vp->crtat, vp->crtat+n, ((pp-vp->crtat)-n)*CHR);
/* Blank out space at new positions */
fillw(attr, vp->crtat, n);
}
#endif /*!MINITERM*/
static u_short fgansitopc[] =
{ FG_BLACK, FG_RED, FG_GREEN, FG_BROWN, FG_BLUE,
FG_MAGENTA, FG_CYAN, FG_LIGHTGREY
};
static u_short bgansitopc[] =
{ BG_BLACK, BG_RED, BG_GREEN, BG_BROWN, BG_BLUE,
BG_MAGENTA, BG_CYAN, BG_LIGHTGREY
};
/*
* set attributes
* mode = 0: reset normal attributes, attr=0: std, attr=1: kernel
* mode = 1: set ansi color background
* mode = 2: set ansi color foreground
* mode = 3: set PC attribute
* mode = 4: reset standout attributes (extension!)
*/
void vga_setattributes(struct vty *vp, int mode, int attr)
{
struct outmode *o = vp->op;
switch (mode) {
case 0: /* reset to normal attributes */
if (o == &vp->om[0]) { /* std */
o->fg_at = vds.color ? DEF_STD_C_FGAT : DEF_STD_M_FGAT;
o->bg_at = DEF_STD_BGAT;
} else
{ /* kernel */
o->fg_at = vds.color ? DEF_KERN_C_FGAT : DEF_KERN_M_FGAT;
o->bg_at = DEF_KERN_BGAT;
}
/* asa@kiae.su: fix to allow non-black background */
/*o->def_at = o->fg_at | o->bg_at;*/
break;
case 1: /* ansi background */
if (vds.color)
o->bg_at = bgansitopc[attr & 7];
break;
case 2: /* ansi foreground */
if (vds.color)
o->fg_at = fgansitopc[attr & 7];
break;
case 3: /* pc text attribute */
o->fg_at = attr & 0x8f;
o->bg_at = attr & 0x70;
break;
case 4: /* set so attribute to default */
vp->so_at = vds.color ? DEF_SO_C_AT : DEF_SO_M_AT;
}
o->def_at = o->fg_at | o->bg_at; /* asa@kiae.su */
}
void vga_selectfont(struct vty *vp,int fontnr)
{
vp->op->f2 = (fontnr==2);
}
void vga_wrtchar(struct vty *vp, u_int c, u_int at)
{
*(vp->crtat++) = (u_short)(at<<8)|c;
vp->col++;
}
/*
* check whether crtat points to outside the screen
* = 0: no, = -1: less than top of screen, =1: below bottom of screen
*/
int vga_checkcursor(struct vty *vp)
{
if (vp->crtat < vp->Crtat) return -1;
if (vp->crtat >= vp->Crtat+vp->size) return 1;
return 0;
}
/*
* return a char to the vty, i.e. simulate an (ASCII) keypress,
* used to return status messages (not for pc3)
*/
void vga_sendchar(struct vty *vp, XCHAR c)
{
/* XXX modify for real (=char) XCHAR type */
/* is it opened? */
if (vp->ttycnt)
(*linesw[vp->ttyp->t_line].l_rint)(c & 0xFF, vp->ttyp);
}
void vga_initvideo() {}
#endif
#endif /* NPC=0 */
#endif /* NCO=1 */
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.