mirror of
https://gitlab.com/qemu-project/openbios.git
synced 2024-02-13 08:34:06 +08:00
7c2a631397
Added 8x16 font, low-level VGA register programming and mode switching functions from LinuxBIOS. Fixed incorrect VGA_BASE. git-svn-id: svn://coreboot.org/openbios/openbios-devel@69 f158a5a8-5612-0410-a976-696ce0be7e32
428 lines
14 KiB
C
428 lines
14 KiB
C
#include "asm/io.h"
|
|
#include "video_subr.h"
|
|
#include "string.h"
|
|
#include "vga.h"
|
|
|
|
/*
|
|
* $Id$
|
|
* $Source$
|
|
*
|
|
* from the Linux kernel code base.
|
|
* orig by Ben Pfaff and Petr Vandrovec.
|
|
*
|
|
* modified by
|
|
* Steve M. Gehlbach <steve@kesa.com>
|
|
*
|
|
* NOTE: to change the horiz and vertical pixels,
|
|
* change the xres,yres,xres_virt,yres_virt setting
|
|
* in the screeninfo structure below. You may also need
|
|
* to change the border settings as well.
|
|
*
|
|
* Convert the screeninfo structure to data for
|
|
* writing to the vga registers
|
|
*
|
|
*/
|
|
|
|
// prototypes
|
|
static int vga_decode_var(const struct screeninfo *var, struct vga_par *par);
|
|
static int vga_set_regs(const struct vga_par *par);
|
|
|
|
extern const u8 VgaLookupTable[];
|
|
|
|
u8 read_seq_b(u16 addr) {
|
|
outb(addr,SEQ_I);
|
|
return inb(SEQ_D);
|
|
}
|
|
u8 read_gra_b(u16 addr) {
|
|
outb(addr,GRA_I);
|
|
return inb(GRA_D);
|
|
}
|
|
u8 read_crtc_b(u16 addr) {
|
|
outb(addr,CRT_IC);
|
|
return inb(CRT_DC);
|
|
}
|
|
u8 read_att_b(u16 addr) {
|
|
inb(IS1_RC);
|
|
inb(0x80);
|
|
outb(addr,ATT_IW);
|
|
return inb(ATT_R);
|
|
}
|
|
|
|
|
|
/*
|
|
From: The Frame Buffer Device
|
|
by Geert Uytterhoeven <geert@linux-m68k.org>
|
|
in the linux kernel docs.
|
|
|
|
The following picture summarizes all timings. The horizontal retrace time is
|
|
the sum of the left margin, the right margin and the hsync length, while the
|
|
vertical retrace time is the sum of the upper margin, the lower margin and the
|
|
vsync length.
|
|
|
|
+----------+---------------------------------------------+----------+-------+
|
|
| | ^ | | |
|
|
| | |upper_margin | | |
|
|
| | | | | |
|
|
+----------###############################################----------+-------+
|
|
| # ^ # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| left # | # right | hsync |
|
|
| margin # | xres # margin | len |
|
|
|<-------->#<---------------+--------------------------->#<-------->|<----->|
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # |yres # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
| # | # | |
|
|
+----------###############################################----------+-------+
|
|
| | ^ | | |
|
|
| | |lower_margin | | |
|
|
| | | | | |
|
|
+----------+---------------------------------------------+----------+-------+
|
|
| | ^ | | |
|
|
| | |vsync_len | | |
|
|
| | | | | |
|
|
+----------+---------------------------------------------+----------+-------+
|
|
|
|
All horizontal timings are in number of dotclocks
|
|
(in picoseconds, 1E-12 s), and vertical timings in number of scanlines.
|
|
|
|
The vga uses the following fields:
|
|
|
|
- pixclock: pixel clock in ps (pico seconds)
|
|
- xres,yres,xres_v,yres_v
|
|
- left_margin: time from sync to picture
|
|
- right_margin: time from picture to sync
|
|
- upper_margin: time from sync to picture
|
|
- lower_margin: time from picture to sync
|
|
- hsync_len: length of horizontal sync
|
|
- vsync_len: length of vertical sync
|
|
|
|
*/
|
|
|
|
/* our display parameters per the above */
|
|
|
|
static const struct screeninfo vga_settings = {
|
|
640,400,640,400,/* xres,yres,xres_virt,yres_virt */
|
|
0,0, /* xoffset,yoffset */
|
|
4, /* bits_per_pixel NOT USED*/
|
|
0, /* greyscale ? */
|
|
{0,0,0}, /* R */
|
|
{0,0,0}, /* G */
|
|
{0,0,0}, /* B */
|
|
{0,0,0}, /* transparency */
|
|
0, /* standard pixel format */
|
|
0, // activate now
|
|
-1,-1, // height and width in mm
|
|
0, // accel flags
|
|
39721, // pixclock: 79442 -> 12.587 Mhz (NOT USED)
|
|
// 70616 -> 14.161
|
|
// 39721 -> 25.175
|
|
// 35308 -> 28.322
|
|
|
|
48, 16, 39, 8, // margins left,right,upper,lower
|
|
96, // hsync length
|
|
2, // vsync length
|
|
0, // sync polarity
|
|
0, // non interlaced, single mode
|
|
{0,0,0,0,0,0} // compatibility
|
|
};
|
|
|
|
// ALPHA-MODE
|
|
// Hard coded to BIOS VGA mode 3 (alpha color text)
|
|
// screen size settable in screeninfo structure
|
|
|
|
static int vga_decode_var(const struct screeninfo *var,
|
|
struct vga_par *par)
|
|
{
|
|
u8 VgaAttributeTable[16] =
|
|
{ 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x014, 0x007, 0x038, 0x039, 0x03A, 0x03B, 0x03C, 0x03D, 0x03E, 0x03F};
|
|
|
|
u32 xres, right, hslen, left, xtotal;
|
|
u32 yres, lower, vslen, upper, ytotal;
|
|
u32 vxres, xoffset, vyres, yoffset;
|
|
u32 pos;
|
|
u8 r7, rMode;
|
|
int i;
|
|
|
|
xres = (var->xres + 7) & ~7;
|
|
vxres = (var->xres_virtual + 0xF) & ~0xF;
|
|
xoffset = (var->xoffset + 7) & ~7;
|
|
left = (var->left_margin + 7) & ~7;
|
|
right = (var->right_margin + 7) & ~7;
|
|
hslen = (var->hsync_len + 7) & ~7;
|
|
|
|
if (vxres < xres)
|
|
vxres = xres;
|
|
if (xres + xoffset > vxres)
|
|
xoffset = vxres - xres;
|
|
|
|
xres >>= 3;
|
|
right >>= 3;
|
|
hslen >>= 3;
|
|
left >>= 3;
|
|
vxres >>= 3;
|
|
xtotal = xres + right + hslen + left;
|
|
if (xtotal >= 256)
|
|
return VERROR; //xtotal too big
|
|
if (hslen > 32)
|
|
return VERROR; //hslen too big
|
|
if (right + hslen + left > 64)
|
|
return VERROR; //hblank too big
|
|
par->crtc[CRTC_H_TOTAL] = xtotal - 5;
|
|
par->crtc[CRTC_H_BLANK_START] = xres - 1;
|
|
par->crtc[CRTC_H_DISP] = xres - 1;
|
|
pos = xres + right;
|
|
par->crtc[CRTC_H_SYNC_START] = pos;
|
|
pos += hslen;
|
|
par->crtc[CRTC_H_SYNC_END] = (pos & 0x1F) | 0x20 ; //<--- stpc text mode p178
|
|
pos += left - 2; /* blank_end + 2 <= total + 5 */
|
|
par->crtc[CRTC_H_BLANK_END] = (pos & 0x1F) | 0x80;
|
|
if (pos & 0x20)
|
|
par->crtc[CRTC_H_SYNC_END] |= 0x80;
|
|
|
|
yres = var->yres;
|
|
lower = var->lower_margin;
|
|
vslen = var->vsync_len;
|
|
upper = var->upper_margin;
|
|
vyres = var->yres_virtual;
|
|
yoffset = var->yoffset;
|
|
|
|
if (yres > vyres)
|
|
vyres = yres;
|
|
if (vxres * vyres > 65536) {
|
|
vyres = 65536 / vxres;
|
|
if (vyres < yres)
|
|
return VERROR; // out of memory
|
|
}
|
|
if (yoffset + yres > vyres)
|
|
yoffset = vyres - yres;
|
|
|
|
if (var->vmode & VMODE_DOUBLE) {
|
|
yres <<= 1;
|
|
lower <<= 1;
|
|
vslen <<= 1;
|
|
upper <<= 1;
|
|
}
|
|
ytotal = yres + lower + vslen + upper;
|
|
if (ytotal > 1024) {
|
|
ytotal >>= 1;
|
|
yres >>= 1;
|
|
lower >>= 1;
|
|
vslen >>= 1;
|
|
upper >>= 1;
|
|
rMode = 0x04;
|
|
} else
|
|
rMode = 0x00;
|
|
if (ytotal > 1024)
|
|
return VERROR; //ytotal too big
|
|
if (vslen > 16)
|
|
return VERROR; //vslen too big
|
|
par->crtc[CRTC_V_TOTAL] = ytotal - 2;
|
|
r7 = 0x10; /* disable linecompare */
|
|
if (ytotal & 0x100) r7 |= 0x01;
|
|
if (ytotal & 0x200) r7 |= 0x20;
|
|
par->crtc[CRTC_PRESET_ROW] = 0;
|
|
|
|
|
|
// GMODE <--> ALPHA-MODE
|
|
// default using alpha mode so we need to set char rows= CHAR_HEIGHT-1
|
|
par->crtc[CRTC_MAX_SCAN] = 0x40 | (CHAR_HEIGHT-1); /* 16 scanlines, linecmp max*/
|
|
|
|
if (var->vmode & VMODE_DOUBLE)
|
|
par->crtc[CRTC_MAX_SCAN] |= 0x80;
|
|
par->crtc[CRTC_CURSOR_START] = 0x00; // curs enabled, start line = 0
|
|
par->crtc[CRTC_CURSOR_END] = CHAR_HEIGHT-1; // end line = 12
|
|
pos = yoffset * vxres + (xoffset >> 3);
|
|
par->crtc[CRTC_START_HI] = pos >> 8;
|
|
par->crtc[CRTC_START_LO] = pos & 0xFF;
|
|
par->crtc[CRTC_CURSOR_HI] = 0x00;
|
|
par->crtc[CRTC_CURSOR_LO] = 0x00;
|
|
pos = yres - 1;
|
|
par->crtc[CRTC_V_DISP_END] = pos & 0xFF;
|
|
par->crtc[CRTC_V_BLANK_START] = pos & 0xFF;
|
|
if (pos & 0x100)
|
|
r7 |= 0x0A; /* 0x02 -> DISP_END, 0x08 -> BLANK_START */
|
|
if (pos & 0x200) {
|
|
r7 |= 0x40; /* 0x40 -> DISP_END */
|
|
par->crtc[CRTC_MAX_SCAN] |= 0x20; /* BLANK_START */
|
|
}
|
|
pos += lower;
|
|
par->crtc[CRTC_V_SYNC_START] = pos & 0xFF;
|
|
if (pos & 0x100)
|
|
r7 |= 0x04;
|
|
if (pos & 0x200)
|
|
r7 |= 0x80;
|
|
pos += vslen;
|
|
par->crtc[CRTC_V_SYNC_END] = (pos & 0x0F) & ~0x10; /* disabled reg write prot, IRQ */
|
|
pos += upper - 1; /* blank_end + 1 <= ytotal + 2 */
|
|
par->crtc[CRTC_V_BLANK_END] = pos & 0xFF; /* 0x7F for original VGA,
|
|
but some SVGA chips requires all 8 bits to set */
|
|
if (vxres >= 512)
|
|
return VERROR; //vxres too long
|
|
par->crtc[CRTC_OFFSET] = vxres >> 1;
|
|
|
|
// put the underline off of the character, necessary in alpha color mode
|
|
par->crtc[CRTC_UNDERLINE] = 0x1f;
|
|
|
|
par->crtc[CRTC_MODE] = rMode | 0xA3; // word mode
|
|
par->crtc[CRTC_LINE_COMPARE] = 0xFF;
|
|
par->crtc[CRTC_OVERFLOW] = r7;
|
|
|
|
|
|
// not used ??
|
|
par->vss = 0x00; /* 3DA */
|
|
|
|
for (i = 0x00; i < 0x10; i++) {
|
|
par->atc[i] = VgaAttributeTable[i];
|
|
}
|
|
// GMODE <--> ALPHA-MODE
|
|
par->atc[ATC_MODE] = 0x0c; // text mode
|
|
|
|
par->atc[ATC_OVERSCAN] = 0x00; // no border
|
|
par->atc[ATC_PLANE_ENABLE] = 0x0F;
|
|
par->atc[ATC_PEL] = xoffset & 7;
|
|
par->atc[ATC_COLOR_PAGE] = 0x00;
|
|
|
|
par->misc = 0x67; /* enable CPU, ports 0x3Dx, positive sync*/
|
|
if (var->sync & SYNC_HOR_HIGH_ACT)
|
|
par->misc &= ~0x40;
|
|
if (var->sync & SYNC_VERT_HIGH_ACT)
|
|
par->misc &= ~0x80;
|
|
|
|
par->seq[SEQ_CLOCK_MODE] = 0x01; //8-bit char; 0x01=alpha mode
|
|
par->seq[SEQ_PLANE_WRITE] = 0x03; // just char/attr plane
|
|
par->seq[SEQ_CHARACTER_MAP] = 0x00;
|
|
par->seq[SEQ_MEMORY_MODE] = 0x02; // A/G bit not used in stpc; O/E on, C4 off
|
|
|
|
par->gdc[GDC_SR_VALUE] = 0x00;
|
|
// bits set in the SR_EN regs will enable set/reset action
|
|
// based on the bit settings in the SR_VAL register
|
|
par->gdc[GDC_SR_ENABLE] = 0x00;
|
|
par->gdc[GDC_COMPARE_VALUE] = 0x00;
|
|
par->gdc[GDC_DATA_ROTATE] = 0x00;
|
|
par->gdc[GDC_PLANE_READ] = 0;
|
|
par->gdc[GDC_MODE] = 0x10; //Okay
|
|
|
|
// GMODE <--> ALPHA-MMODE
|
|
par->gdc[GDC_MISC] = 0x0e; // b0=0 ->alpha mode; memory at 0xb8000
|
|
|
|
par->gdc[GDC_COMPARE_MASK] = 0x00;
|
|
par->gdc[GDC_BIT_MASK] = 0xFF;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* From the Linux kernel.
|
|
* orig by Ben Pfaff and Petr Vandrovec.
|
|
* see the note in the vga.h for attribution.
|
|
*
|
|
* modified by
|
|
* Steve M. Gehlbach <steve@kesa.com>
|
|
* for the linuxbios project
|
|
*
|
|
* Write the data in the vga parameter structure
|
|
* to the vga registers, along with other default
|
|
* settings.
|
|
*
|
|
*/
|
|
static int vga_set_regs(const struct vga_par *par)
|
|
{
|
|
int i;
|
|
|
|
/* update misc output register */
|
|
outb(par->misc, MIS_W);
|
|
|
|
/* synchronous reset on */
|
|
outb(0x00, SEQ_I);
|
|
outb(0x00, SEQ_D);
|
|
|
|
/* write sequencer registers */
|
|
outb(1, SEQ_I);
|
|
outb(par->seq[1] | 0x20, SEQ_D); // blank display
|
|
for (i = 2; i < SEQ_C; i++) {
|
|
outb(i, SEQ_I);
|
|
outb(par->seq[i], SEQ_D);
|
|
}
|
|
|
|
/* synchronous reset off */
|
|
outb(0x00, SEQ_I);
|
|
outb(0x03, SEQ_D);
|
|
|
|
/* deprotect CRT registers 0-7 */
|
|
outb(0x11, CRT_IC);
|
|
outb(par->crtc[0x11], CRT_DC);
|
|
|
|
/* write CRT registers */
|
|
for (i = 0; i < CRTC_C; i++) {
|
|
outb(i, CRT_IC);
|
|
outb(par->crtc[i], CRT_DC);
|
|
}
|
|
/* write graphics controller registers */
|
|
for (i = 0; i < GRA_C; i++) {
|
|
outb(i, GRA_I);
|
|
outb(par->gdc[i], GRA_D);
|
|
}
|
|
|
|
/* write attribute controller registers */
|
|
for (i = 0; i < ATT_C; i++) {
|
|
inb(IS1_RC); /* reset flip-flop */
|
|
inb(0x80); //delay
|
|
outb(i, ATT_IW);
|
|
inb(0x80); //delay
|
|
|
|
outb(par->atc[i], ATT_IW);
|
|
inb(0x80); //delay
|
|
}
|
|
|
|
// initialize the color table
|
|
outb(0, PEL_IW);
|
|
i = 0;
|
|
// length is a magic number right now
|
|
while ( i < (0x3f*3 + 3) ) {
|
|
outb(VgaLookupTable[i++], PEL_D);
|
|
outb(VgaLookupTable[i++], PEL_D);
|
|
outb(VgaLookupTable[i++], PEL_D);
|
|
}
|
|
|
|
outb(0x0ff, PEL_MSK); // palette mask
|
|
|
|
// very important
|
|
// turn on video, disable palette access
|
|
inb(IS1_RC); /* reset flip-flop */
|
|
inb(0x80); //delay
|
|
outb(0x20, ATT_IW);
|
|
|
|
/* Wait for screen to stabilize. */
|
|
//for(i=0;i<1000;i++) { inb(0x80); }
|
|
|
|
outb(0x01, SEQ_I); // unblank display
|
|
outb(par->seq[1], SEQ_D);
|
|
|
|
// turn on display, disable access to attr palette
|
|
inb(IS1_RC);
|
|
outb(0x20, ATT_IW);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
vga_load_regs(void)
|
|
{
|
|
struct vga_par par;
|
|
|
|
vga_decode_var(&vga_settings, &par);
|
|
vga_set_regs(&par);
|
|
}
|