Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/ntos/nthals/halsgi/mips/sxdisp.c
Microsoft ce47f986d8 First commit
2020-09-30 17:12:29 +02:00

1385 lines
30 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) 1991 Microsoft Corporation
Copyright (c) 1992 Silicon Graphics, Inc.
Module Name:
s3disp.c
Abstract:
This module implements the HAL display initialization and output
routines for the SGI Indigo system.
Author:
David N. Cutler (davec) 27-Apr-1991
Kevin Meier (o-kevinm ) 8-Sept-1992
Environment:
Kernel mode
Revision History:
--*/
#include "halp.h"
#include "sgirex.h"
//
// Put all code for HAL initialization in the INIT section. It will be
// deallocated by memory management when phase 1 initialization is
// completed.
//
#if defined(ALLOC_PRAGMA)
#pragma alloc_text(INIT, HalpInitializeDisplay0)
#pragma alloc_text(INIT, HalpInitializeDisplay1)
#endif
//
// Define forward referenced procedure prototypes.
//
VOID
HalpInitializeREX
(
VOID
);
VOID
HalpInitializeCLK
(
VOID
);
VOID
HalpInitializeDAC
(
VOID
);
VOID
HalpLoadSRAM
(
IN PUCHAR Data,
IN USHORT Addr,
IN USHORT Length
);
VOID
HalpInitializeVC1
(
VOID
);
VOID
HalpDisplayCharacter
(
IN UCHAR Character
);
VOID
HalpOutputCharacter
(
IN PUCHAR Glyph
);
//
// Define frame buffer parameters.
//
#define DISPLAY_WIDTH 1024 // number of pixels in scan line
#define DISPLAY_HEIGHT 768 // number of scan lines in display
//#define CHARACTER_WIDTH 9 // number of pixels per character
//#define CHARACTER_HEIGHT 15 // number of scan lines per character
//#define CHARACTER_LINES (DISPLAY_HEIGHT/CHARACTER_HEIGHT)
//#define GLYPH_SIZE CHARACTER_HEIGHT - 1 // size of glyph in ulongs
//
// Define virtual address of the REX chip
//
#define REX_BASE (KSEG1_BASE | REX_ADDRESS)
//
// Memory layout of VC1 SRAM
//
#define VC1_VID_LINE_TBL_ADDR 0x0000
#define VC1_VID_FRAME_TBL_ADDR 0x0800
#define VC1_CURSOR_GLYPH_ADDR 0x0700
#define VC1_DID_LINE_TBL_ADDR 0x4800
#define VC1_DID_FRAME_TBL_ADDR 0x4000
//
// Define global data used for the x and y positions in the frame buffer
// and the address of the idle process kernel object.
//
// Define OEM font variables.
//
ULONG HalpBytesPerRow;
ULONG HalpCharacterHeight;
ULONG HalpCharacterWidth;
ULONG HalpColumn;
ULONG HalpDisplayText;
ULONG HalpDisplayWidth;
POEM_FONT_FILE_HEADER HalpFontHeader;
ULONG HalpRow;
//
// Define display variables.
//
BOOLEAN HalpDisplayOwnedByHal;
PREX_REGS HalpRexRegs;
ULONG HalpSmallMon;
ULONG HalpBoardRev;
#define LG1_SMALLMON 6
//
// Declare externally defined data.
//
extern ULONG HalpUsFont8x14[];
static UCHAR clkStuff[17] =
{
0xC4, 0x00, 0x10, 0x24, 0x30, 0x40, 0x59, 0x60, 0x72, 0x80, 0x90,
0xAD, 0xB6, 0xD1, 0xE0, 0xF0, 0xC4
};
static UCHAR vtgLineTable[] =
{
0x08, 0x00, 0x98, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c,
0x85, 0x7f, 0x8c, 0x78, 0x0c, 0x05, 0x90, 0x81, 0x00, 0x00,
0x00, 0x08, 0x00, 0x98, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03,
0x0c, 0x85, 0x7f, 0x8c, 0xf9, 0x00, 0x00, 0x15, 0x08, 0x00,
0x99, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c, 0x87, 0x7f,
0x8c, 0x78, 0x0c, 0x8f, 0x81, 0x00, 0x00, 0x26, 0x08, 0x00,
0x9d, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c, 0x87, 0x7f,
0x8c, 0x78, 0x0c, 0x8f, 0x81, 0x00, 0x00, 0x3a, 0x08, 0x00,
0x9d, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c, 0x87, 0x78,
0x0c, 0x07, 0x9f, 0x7f, 0x0c, 0x8f, 0x81, 0x00, 0x00, 0x4e,
0x04, 0x00, 0x9f, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c,
0x87, 0x14, 0xac, 0x01, 0xf8, 0x02, 0xfc, 0x02, 0xfe, 0x02,
0x7e, 0xa7, 0x01, 0x7f, 0xf7, 0x7f, 0xff, 0x39, 0xdf, 0x01,
0x8f, 0x11, 0x8d, 0x02, 0x0d, 0xd7, 0x01, 0x0c, 0x87, 0x0e,
0x0c, 0x8f, 0x81, 0x00, 0x00, 0x92, 0x04, 0x00, 0x9f, 0x02,
0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c, 0x87, 0x0a, 0xfc, 0x01,
0xf8, 0x02, 0xfc, 0x0c, 0xfe, 0x02, 0x7e, 0xa7, 0x01, 0x7f,
0xf7, 0x61, 0xaf, 0x01, 0x87, 0x02, 0x8f, 0x11, 0xff, 0x01,
0xfb, 0x02, 0xff, 0x4a, 0xbf, 0x01, 0x8f, 0x07, 0x8d, 0x02,
0x0d, 0xd7, 0x01, 0x0c, 0x87, 0x0e, 0x0c, 0x8f, 0x81, 0x00,
0x00, 0xca, 0x04, 0x00, 0x9f, 0x02, 0x8c, 0x0b, 0x0c, 0x84,
0x03, 0x0c, 0x87, 0x14, 0xac, 0x01, 0xf8, 0x02, 0xfc, 0x02,
0xfe, 0x02, 0x7e, 0xa7, 0x01, 0x7f, 0xf7, 0x7f, 0xff, 0x39,
0xdf, 0x01, 0x8f, 0x11, 0x8d, 0x02, 0x0d, 0xd7, 0x01, 0x0c,
0x87, 0x0e, 0x0c, 0x8f, 0x81, 0x00, 0x00, 0xf8, 0x04, 0x00,
0x9f, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c, 0x87, 0x05,
0xdc, 0x01, 0xfc, 0x01, 0xf8, 0x02, 0xfc, 0x10, 0xfe, 0x02,
0x7e, 0xa7, 0x01, 0x7f, 0xf7, 0x10, 0xaf, 0x01, 0x87, 0x02,
0x8f, 0x11, 0xff, 0x01, 0xfb, 0x02, 0xff, 0x7f, 0xff, 0x18,
0xaf, 0x01, 0x8f, 0x0b, 0x8d, 0x02, 0x0d, 0xd7, 0x01, 0x0c,
0x87, 0x0e, 0x0c, 0x8f, 0x81, 0x00, 0x01, 0x34, 0x04, 0x00,
0x9f, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c, 0x87, 0x0c,
0xbc, 0x01, 0xfc, 0x01, 0xf8, 0x02, 0xfc, 0x09, 0xfe, 0x02,
0x7e, 0xa7, 0x01, 0x7f, 0xf7, 0x7f, 0xff, 0x0b, 0x8f, 0x01,
0x87, 0x02, 0x8f, 0x10, 0xdf, 0x01, 0xfb, 0x02, 0xff, 0x24,
0xdf, 0x01, 0x8f, 0x05, 0x8d, 0x02, 0x0d, 0xd7, 0x01, 0x0c,
0x87, 0x0e, 0x0c, 0x8f, 0x81, 0x00, 0x01, 0x70, 0x04, 0x00,
0x9f, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c, 0x87, 0x14,
0xac, 0x01, 0xf8, 0x02, 0xfc, 0x02, 0xfe, 0x02, 0x7e, 0xa7,
0x01, 0x7f, 0xf7, 0x7f, 0xff, 0x39, 0xdf, 0x01, 0x8f, 0x11,
0x8d, 0x02, 0x0d, 0xd7, 0x01, 0x0c, 0x87, 0x0e, 0x0c, 0x8f,
0x81, 0x00, 0x01, 0x9e, 0x04, 0x00, 0x9f, 0x02, 0x8c, 0x0b,
0x0c, 0x84, 0x03, 0x0c, 0x87, 0x08, 0xac, 0x01, 0xf8, 0x02,
0xfc, 0x0e, 0xfe, 0x02, 0x7e, 0xa7, 0x01, 0x7f, 0xf7, 0x39,
0x8f, 0x01, 0x87, 0x02, 0x8f, 0x10, 0xdf, 0x01, 0xfb, 0x02,
0xff, 0x71, 0xcf, 0x01, 0x8f, 0x09, 0x8d, 0x02, 0x0d, 0xd7,
0x01, 0x0c, 0x87, 0x0e, 0x0c, 0x8f, 0x81, 0x00, 0x01, 0xd6,
0x04, 0x00, 0x9f, 0x02, 0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c,
0x87, 0x14, 0xac, 0x01, 0xf8, 0x02, 0xfc, 0x02, 0xfe, 0x02,
0x7e, 0xa7, 0x01, 0x7f, 0xf7, 0x7f, 0xff, 0x39, 0xdf, 0x01,
0x8f, 0x11, 0x8d, 0x02, 0x0d, 0xd7, 0x01, 0x0c, 0x87, 0x0e,
0x0c, 0x8f, 0x81, 0x00, 0x00, 0x64, 0x04, 0x00, 0x9f, 0x02,
0x8c, 0x0b, 0x0c, 0x84, 0x03, 0x0c, 0x87, 0x14, 0xac, 0x01,
0xf8, 0x02, 0xfc, 0x02, 0xfe, 0x02, 0x7e, 0xa7, 0x01, 0x7f,
0xf7, 0x7f, 0xff, 0x39, 0xdf, 0x01, 0x8f, 0x11, 0x8d, 0x02,
0x0d, 0xd7, 0x01, 0x0c, 0x87, 0x0e, 0x0c, 0x8f, 0x81, 0x00,
0x02, 0x04
};
static UCHAR vtgFrameTable[] =
{
0x03, 0x2d, 0x00, 0x00, 0x01, 0x00, 0x15, 0x02, 0x00, 0x3a,
0x26, 0x00, 0x4e, 0x01, 0x00, 0x64, 0x78, 0x00, 0x64, 0x78,
0x00, 0x64, 0x78, 0x00, 0x64, 0x78, 0x00, 0x64, 0x78, 0x00,
0x64, 0x78, 0x00, 0x64, 0x2f, 0x02, 0x04, 0x01, 0x00, 0x26,
0x03, 0x00
};
static UCHAR didLineTable[] =
{
0x0,0x1,0x0,0x0,
0x0,0x1,0x0,0x1,
0x0,0x1,0x0,0x2,
0x0,0x1,0x0,0x3,
0x0,0x1,0x0,0x4,
0x0,0x1,0x0,0x5,
0x0,0x1,0x0,0x6,
0x0,0x1,0x0,0x7,
0x0,0x1,0x0,0x8,
0x0,0x1,0x0,0x9,
0x0,0x1,0x0,0xa,
0x0,0x1,0x0,0xb,
0x0,0x1,0x0,0xc,
0x0,0x1,0x0,0xd,
0x0,0x1,0x0,0xe,
0x0,0x1,0x0,0xf,
0x0,0x1,0x0,0x10,
0x0,0x1,0x0,0x11,
0x0,0x1,0x0,0x12,
0x0,0x1,0x0,0x13,
0x0,0x1,0x0,0x14,
0x0,0x1,0x0,0x15,
0x0,0x1,0x0,0x16,
0x0,0x1,0x0,0x17,
0x0,0x1,0x0,0x18,
0x0,0x1,0x0,0x19,
0x0,0x1,0x0,0x1a,
0x0,0x1,0x0,0x1b,
0x0,0x1,0x0,0x1c,
0x0,0x1,0x0,0x1d,
0x0,0x1,0x0,0x1e,
0x0,0x1,0x0,0x1f,
0x0,0x4,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0
};
VOID
HalpInitializeREX
(
VOID
)
/*++
Routine Description:
Initialize the REX chip and clear both overlay and pixel planes.
Arguments:
None.
Return Value:
None.
--*/
{
//
// Wait for chip to become idle
//
REX_WAIT(HalpRexRegs);
//
// Set origin to upper left of screen
//
HalpRexRegs->Config.Set.xyWin = 0x08000800;
//
// Set max FIFO depths (disables FIFO INTs) and set VC1 clock for 1024
//
// HalpRexRegs->Config.Set.ConfigMode = BFIFOMAX(0x1F) | DFIFOMAX(0x5) | FASTCLOCK;
HalpRexRegs->Config.Set.ConfigMode = BFIFOMAX(6) | DFIFOMAX(11) | FASTCLOCK;
//
// Bits for GL are set to 0 for Windows
//
HalpRexRegs->Draw.Set.Aux1 = 0;
HalpRexRegs->Draw.Go.Command = OC_NOOP;
REX_WAIT(HalpRexRegs);
//
// Clear overlay planes
//
HalpRexRegs->Config.Set.Aux2 = PLANES_OVERLAY;
HalpRexRegs->Draw.Set.Command = OC_DRAW | STOPONX | STOPONY | BLOCK | QUADMODE;
HalpRexRegs->Draw.Set.State = 0x03FF0000;
HalpRexRegs->Draw.Set.xStartI = 0;
HalpRexRegs->Draw.Set.yStartI = 0;
HalpRexRegs->Draw.Set.xEndI = 1023;
HalpRexRegs->Draw.Go.yEndI = 767;
REX_WAIT(HalpRexRegs);
//
// Clear pixel planes
//
HalpRexRegs->Config.Set.Aux2 = PLANES_PIXEL;
HalpRexRegs->Draw.Set.Command = OC_DRAW | STOPONX | STOPONY | BLOCK | QUADMODE;
HalpRexRegs->Draw.Set.State = 0x03FF0001;
HalpRexRegs->Draw.Set.xStartI = 0;
HalpRexRegs->Draw.Set.yStartI = 0;
HalpRexRegs->Draw.Set.xEndI = 1023;
HalpRexRegs->Draw.Go.yEndI = 767;
//
// Set background color to 1, foreground to 0
//
HalpRexRegs->Draw.Set.State = 0x03FF0100;
}
VOID
HalpInitializeCLK
(
VOID
)
/*++
Routine Description:
Initialize the clock timing table.
Arguments:
None.
Return Value:
None.
--*/
{
USHORT i;
HalpRexRegs->Config.Go.ConfigSel = 2;
for (i = 0; i < 17; i++)
{
HalpRexRegs->Config.Set.WClock = clkStuff[i];
HalpRexRegs->Config.Go.WClock = clkStuff[i];
}
}
VOID
HalpInitializeBt
(
ULONG Sync
)
/*++
Routine Description:
Initiliaze the bt479 DAC. Load a GL colorramp into cmap 0 and clear
the rest.
Arguments:
None.
Return Value:
None.
--*/
{
USHORT i;
//
// Address of windows bounds register
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x00);
//
// Init 8 bytes for each of 16 windows to 0
//
for (i = 0; i < 128; i++)
{
DAC_WRITE(HalpRexRegs, WRITE_ADDR, i);
DAC_WRITE(HalpRexRegs, CONTROL, 0x00);
}
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x82);
//
// Command register 0
//
DAC_WRITE(HalpRexRegs, CONTROL, 0x00);
//
// Command register 1
//
DAC_WRITE(HalpRexRegs, CONTROL, 0x02 | (Sync << 3));
//
// Flood register lo
//
DAC_WRITE(HalpRexRegs, CONTROL, 0x00);
//
// Flood register hi
//
DAC_WRITE(HalpRexRegs, CONTROL, 0x00);
//
// Pixel read mask
//
DAC_WRITE(HalpRexRegs, PIXEL_READ_MASK, 0xFF);
//
// Init color map 0
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x82);
DAC_WRITE(HalpRexRegs, CONTROL, 0x00);
//
// Init address to start of map
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x00);
//
// For first map, set entry 0 to WHITE, entry 1 to BLUE
//
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xFF);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xFF);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xFF);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x90);
for (i = 2; i < 256; i++)
{
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
}
//
// Init color map 1
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x82);
DAC_WRITE(HalpRexRegs, CONTROL, 0x10);
//
// Init address to start of map
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x00);
for (i = 0; i < 256; i++)
{
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
}
//
// Init color map 2
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x82);
DAC_WRITE(HalpRexRegs, CONTROL, 0x20);
//
// Init address to start of map
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x00);
for (i = 0; i < 256; i++)
{
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
}
//
// Init color map 3
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x82);
DAC_WRITE(HalpRexRegs, CONTROL, 0x30);
//
// Init address to start of map
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xff);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xff);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xff);
for (i = 4; i < 256; i++)
{
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
}
//
// Init color map
//
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x82);
//
// Command register 0
//
DAC_WRITE(HalpRexRegs, CONTROL, 0x00);
}
VOID
HalpInitializeLUT
(
ULONG Sync
)
/*++
Routine Description:
Load the LUT on the LG2 board
Arguments:
Sync - Enable Sync-on-green
Return Value:
None.
--*/
{
int i;
ULONG lutcmd;
HalpRexRegs->Config.Set.ConfigSel = 6;
if ( Sync )
HalpRexRegs->Config.Go.RWDAC = 3; /* sync on green */
else
HalpRexRegs->Config.Go.RWDAC = 2;
HalpRexRegs->Config.Set.ConfigSel = CONTROL;
lutcmd = HalpRexRegs->Config.Go.RWDAC;
lutcmd = HalpRexRegs->Config.Set.RWDAC;
lutcmd &= 0xf;
//
// Init color map 0
//
DAC_WRITE(HalpRexRegs, CONTROL, lutcmd);
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0x00);
//
// For first map, set entry 0 to WHITE, entry 1 to BLUE
//
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xFF);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xFF);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xFF);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x90);
for (i = 2; i < 256; i++)
{
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
}
//
// Init color map 1
//
DAC_WRITE(HalpRexRegs, CONTROL, lutcmd | (1 << 6));
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0);
for (i = 0; i < 256; i++)
{
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
}
//
// Init color map 2
//
DAC_WRITE(HalpRexRegs, CONTROL, lutcmd | (2 << 6));
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0);
for (i = 0; i < 256; i++)
{
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
}
//
// Init color map 3
//
DAC_WRITE(HalpRexRegs, CONTROL, lutcmd | (3 << 6));
DAC_WRITE(HalpRexRegs, WRITE_ADDR, 0);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xff);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xff);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0xff);
for (i = 4; i < 256; i++)
{
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
DAC_WRITE(HalpRexRegs, PALETTE_RAM, 0x00);
}
//
// Command register 0
//
DAC_WRITE(HalpRexRegs, CONTROL, lutcmd);
return;
}
VOID
HalpInitializeDAC
(
VOID
)
/*++
Routine Description:
Load the DAC on the LG1/2 board
Arguments:
None.
Return Value:
None.
--*/
{
if (HalpBoardRev >= 2)
HalpInitializeLUT (!(HalpSmallMon == LG1_SMALLMON));
else
HalpInitializeBt (!(HalpSmallMon == LG1_SMALLMON));
return;
}
VOID
HalpLoadSRAM
(
IN PUCHAR Data,
IN USHORT Addr,
IN USHORT Length
)
/*++
Routine Description:
Load the data table into the external SRAM of the VC1.
Arguments:
Data - Pointer to data array to be placed in SRAM
Addr - Address in SRAM to load table
Length - Lenght of data table in bytes
Return Value:
None.
--*/
{
USHORT i;
VC1_WRITE_ADDR(HalpRexRegs, Addr, 0x02);
KeStallExecutionProcessor(1);
for (i = 0; i < Length; i += 2)
{
VC1_WRITE8(HalpRexRegs, Data[i]);
VC1_WRITE8(HalpRexRegs, Data[i + 1]);
KeStallExecutionProcessor(1);
}
}
VOID
HalpInitializeVC1
(
VOID
)
/*++
Routine Description:
Initialize the VC1 by loading all the timing and display tables into
external SRAM.
Arguments:
None.
Return Value:
None.
--*/
{
USHORT i;
UCHAR didFrameTable[768 * 2];
UCHAR cursorTable[256];
//
// Disable VC1 function
//
HalpRexRegs->Config.Go.ConfigSel = 0x06;
VC1_WRITE8(HalpRexRegs, 0x03);
//
// Load video timing generator table
//
HalpLoadSRAM(vtgLineTable, VC1_VID_LINE_TBL_ADDR, sizeof(vtgLineTable));
HalpLoadSRAM(vtgFrameTable, VC1_VID_FRAME_TBL_ADDR, sizeof(vtgFrameTable));
//
// Write VC1 VID_EP, VID_ENCODE(0x1D) register
//
VC1_WRITE_ADDR(HalpRexRegs, 0x00, 0x00);
VC1_WRITE16(HalpRexRegs, (VC1_VID_FRAME_TBL_ADDR) | 0x8000);
VC1_WRITE_ADDR(HalpRexRegs, 0x14, 0x00);
VC1_WRITE16(HalpRexRegs, 0x1d00);
//
// Load DID table
//
for (i = 0; i < sizeof(didFrameTable); i += 2)
{
didFrameTable[i] = 0x48;
didFrameTable[i + 1] = 0x00;
}
didFrameTable[767 * 2] = 0x48;
didFrameTable[767 * 2 + 1] = 0x40;
HalpLoadSRAM(didFrameTable, VC1_DID_FRAME_TBL_ADDR, sizeof(didFrameTable));
HalpLoadSRAM(didLineTable, VC1_DID_LINE_TBL_ADDR, sizeof(didLineTable));
//
// Write VC1 WIDs
//
VC1_WRITE_ADDR(HalpRexRegs, 0x40, 0x00);
VC1_WRITE16(HalpRexRegs, 0x4000);
VC1_WRITE16(HalpRexRegs, 0x4600);
VC1_WRITE8(HalpRexRegs, 1024/5);
VC1_WRITE8(HalpRexRegs, 1024%5);
VC1_WRITE_ADDR(HalpRexRegs, 0x60, 0x00);
VC1_WRITE8(HalpRexRegs, 0x01);
VC1_WRITE8(HalpRexRegs, 0x01);
//
// Write VC1 DID mode registers
//
VC1_WRITE_ADDR(HalpRexRegs, 0x00, 0x01);
for (i = 0; i < 0x40; i += 2)
{
VC1_WRITE16(HalpRexRegs, 0x0000);
}
//
// Load NULL cursor
//
for (i = 0; i < 256; i++)
cursorTable[i] = 0x00;
HalpLoadSRAM(cursorTable, 0x3000, sizeof(cursorTable));
VC1_WRITE_ADDR(HalpRexRegs, 0x20, 0x00);
VC1_WRITE16(HalpRexRegs, 0x3000);
VC1_WRITE16(HalpRexRegs, 0x0240);
VC1_WRITE16(HalpRexRegs, 0x0240);
// Set cursor XMAP 3, submap 0, mode normal
//
VC1_WRITE16(HalpRexRegs, 0xC000);
//
// Enable VC1 function
//
HalpRexRegs->Config.Go.ConfigSel = 6;
VC1_WRITE8(HalpRexRegs, 0xBD);
}
VOID
HalpReinitializeDisplay (
VOID
)
{
ULONG rev;
// figure out board revision
//
HalpRexRegs->Config.Set.ConfigSel = 4;
rev = HalpRexRegs->Config.Go.WClock;
rev = HalpRexRegs->Config.Set.WClock;
HalpBoardRev = rev & 0x7;
HalpSmallMon = (rev >> 3) & 0x7;
HalpInitializeREX();
HalpInitializeCLK();
HalpInitializeDAC();
HalpInitializeVC1();
HalpDisplayOwnedByHal = TRUE;
}
BOOLEAN
HalpInitializeDisplay0
(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
)
/*++
Routine Description:
This routine initializes the Starter Graphics subsystem
Arguments:
LoaderBlock - Supplies a pointer to the loader parameter block.
Return Value:
If the initialization is successfully completed, than a value of TRUE
is returned. Otherwise, a value of FALSE is returned.
--*/
{
ULONG CpuCtrl;
POEM_FONT_FILE_HEADER FontHeader;
//
// Set the address of the font file header and compute display variables.
//
// N.B. The font information suppled by the OS Loader is used during phase
// 0 initialization. During phase 1 initialization, a pool buffer is
// allocated and the font information is copied from the OS Loader
// heap into pool.
//
FontHeader = (POEM_FONT_FILE_HEADER)LoaderBlock->OemFontFile;
HalpFontHeader = FontHeader;
HalpBytesPerRow = (FontHeader->PixelWidth + 7) / 8;
HalpCharacterHeight = FontHeader->PixelHeight;
HalpCharacterWidth = FontHeader->PixelWidth;
//
// Compute character output display parameters.
//
HalpDisplayText = DISPLAY_HEIGHT / HalpCharacterHeight;
HalpDisplayWidth = DISPLAY_WIDTH / HalpCharacterWidth;
HalpRexRegs = (PREX_REGS)REX_BASE;
//
// Reset the REX chip through the CPU configuration register
//
CpuCtrl = READ_REGISTER_ULONG(SGI_CPUCTRL_BASE);
WRITE_REGISTER_ULONG(SGI_CPUCTRL_BASE, CpuCtrl & ~0x8000);
KeStallExecutionProcessor(15);
WRITE_REGISTER_ULONG(SGI_CPUCTRL_BASE, CpuCtrl | 0x8000);
KeStallExecutionProcessor(15);
HalpReinitializeDisplay();
//
// Display welcome message
//
HalpColumn = 40;
HalpRow = 0;
HalDisplayString("Silicon Graphics, Inc. (c) 1993\n");
HalDisplayString("\n");
return(TRUE);
}
BOOLEAN
HalpInitializeDisplay1 (
IN PLOADER_PARAMETER_BLOCK LoaderBlock
)
/*++
Routine Description:
This routine allocates pool for the OEM font file and copies the font
information from the OS Loader heap into the allocated pool.
Arguments:
LoaderBlock - Supplies a pointer to the loader parameter block.
Return Value:
If the initialization is successfully completed, than a value of TRUE
is returned. Otherwise, a value of FALSE is returned.
--*/
{
PVOID FontHeader;
//
// Allocate a pool block and copy the OEM font information from the
// OS Loader heap into the pool block.
//
FontHeader = ExAllocatePool(NonPagedPool, HalpFontHeader->FileSize);
if (FontHeader == NULL) {
return FALSE;
}
RtlMoveMemory(FontHeader, HalpFontHeader, HalpFontHeader->FileSize);
HalpFontHeader = (POEM_FONT_FILE_HEADER)FontHeader;
return TRUE;
}
VOID
HalAcquireDisplayOwnership (
IN PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParameters
)
/*++
Routine Description:
This routine switches ownership of the display away from the HAL to
the system display driver. It is called when the system has reached
a point during bootstrap where it is self supporting and can output
its own messages. Once ownership has passed to the system display
driver any attempts to output messages using HalDisplayString must
result in ownership of the display reverting to the HAL and the
display hardware reinitialized for use by the HAL.
Arguments:
ResetDisplayParameters - if non-NULL the address of a function
the hal can call to reset the video card. The function returns
TRUE if the display was reset.
Return Value:
None.
--*/
{
//
// Set HAL ownership of the display to false.
//
HalpDisplayOwnedByHal = FALSE;
return;
}
VOID
HalDisplayString
(
PUCHAR String
)
/*++
Routine Description:
This routine displays a character string on the display screen.
Arguments:
String - Supplies a pointer to the characters that are to be displayed.
Return Value:
None.
--*/
{
KIRQL OldIrql;
KeRaiseIrql(HIGH_LEVEL, &OldIrql);
if (HalpDisplayOwnedByHal == FALSE)
HalpReinitializeDisplay();
//
// Display characters until a null byte is encountered.
//
while (*String != 0)
{
HalpDisplayCharacter(*String++);
}
KeLowerIrql(OldIrql);
}
VOID
HalpDisplayCharacter
(
IN UCHAR Character
)
/*++
Routine Description:
This routine displays a character at the current x and y positions in
the frame buffer. If a newline is encounter, then the frame buffer is
scrolled. If characters extend below the end of line, then they are not
displayed.
Arguments:
Character - Supplies a character to be displayed.
Return Value:
None.
--*/
{
//
// If the character is a newline, then scroll the screen up, blank the
// bottom line, and reset the x position.
//
if (Character == '\n')
{
HalpColumn = 0;
if (HalpRow < (HalpDisplayText - 1))
{
HalpRow += 1;
}
else
{
//
// Program REX to do a screen-screen BLT for scrolling.
//
REX_WAIT(HalpRexRegs);
HalpRexRegs->Draw.Set.xStartI = 0;
HalpRexRegs->Draw.Set.yStartI = 0;
HalpRexRegs->Draw.Set.xEndI = 1023;
HalpRexRegs->Draw.Set.yEndI = 764 - HalpCharacterHeight;
HalpRexRegs->Draw.Set.xyMove = HalpCharacterHeight;
HalpRexRegs->Draw.Go.Command = OC_DRAW
| LO_COPY
| LOGICSRC
| STOPONX
| STOPONY
| BLOCK
| QUADMODE;
//
// Clear bottom text line.
//
REX_WAIT(HalpRexRegs);
HalpRexRegs->Draw.Set.xStartI = 0;
HalpRexRegs->Draw.Set.yStartI = 764 - HalpCharacterHeight;
HalpRexRegs->Draw.Set.xEndI = 1023;
HalpRexRegs->Draw.Set.yEndI = 767;
HalpRexRegs->Draw.Go.Command = OC_DRAW
| LO_COPY
| STOPONX
| STOPONY
| BLOCK
| QUADMODE;
}
} else if (Character == '\r') {
HalpColumn = 0;
} else {
if ((Character < HalpFontHeader->FirstCharacter) ||
(Character > HalpFontHeader->LastCharacter)) {
Character = HalpFontHeader->DefaultCharacter;
}
Character -= HalpFontHeader->FirstCharacter;
HalpOutputCharacter((PUCHAR)HalpFontHeader + HalpFontHeader->Map[Character].Offset);
}
return;
}
VOID
HalQueryDisplayParameters (
OUT PULONG WidthInCharacters,
OUT PULONG HeightInLines,
OUT PULONG CursorColumn,
OUT PULONG CursorRow
)
/*++
Routine Description:
This routine return information about the display area and current
cursor position.
Arguments:
WidthInCharacter - Supplies a pointer to a varible that receives
the width of the display area in characters.
HeightInLines - Supplies a pointer to a variable that receives the
height of the display area in lines.
CursorColumn - Supplies a pointer to a variable that receives the
current display column position.
CursorRow - Supplies a pointer to a variable that receives the
current display row position.
Return Value:
None.
--*/
{
//
// Set the display parameter values and return.
//
*WidthInCharacters = HalpDisplayWidth;
*HeightInLines = HalpDisplayText;
*CursorColumn = HalpColumn;
*CursorRow = HalpRow;
return;
}
VOID
HalSetDisplayParameters (
IN ULONG CursorColumn,
IN ULONG CursorRow
)
/*++
Routine Description:
This routine set the current cursor position on the display area.
Arguments:
CursorColumn - Supplies the new display column position.
CursorRow - Supplies a the new display row position.
Return Value:
None.
--*/
{
//
// Set the display parameter values and return.
//
if (CursorColumn > HalpDisplayWidth) {
CursorColumn = HalpDisplayWidth;
}
if (CursorRow > HalpDisplayText) {
CursorRow = HalpDisplayText;
}
HalpColumn = CursorColumn;
HalpRow = CursorRow;
return;
}
VOID
HalpOutputCharacter
(
IN PUCHAR Glyph
)
/*++
Routine Description:
This routine insert a set of pixels into the display at the current x
cursor position. If the x cursor position is at the end of the line,
then no pixels are inserted in the display.
Arguments:
Glyph - Supplies a character bitmap to be displayed.
Return Value:
None.
--*/
{
ULONG x;
ULONG y;
USHORT i, j;
ULONG FontValue;
//
// If the current x cursor position is at the end of the line, then
// output a line feed before displaying the character.
//
if (HalpColumn >= HalpDisplayWidth) {
HalpDisplayCharacter('\n');
}
//
// Output the specified character and update the x cursor position.
//
//
// Calculate pixel positions for the character.
//
x = HalpColumn * HalpCharacterWidth;
y = HalpRow * HalpCharacterHeight;
//
// Wait for REX to become idle.
//
REX_WAIT(HalpRexRegs);
//
// Program REX to do a pattern block fill.
//
HalpRexRegs->Draw.Set.xStartI = x;
HalpRexRegs->Draw.Set.yStartI = y;
HalpRexRegs->Draw.Set.xEndI = x + HalpCharacterWidth - 1;
HalpRexRegs->Draw.Set.yEndI = y + HalpCharacterHeight - 1;
HalpRexRegs->Draw.Go.Command = OC_NOOP;
HalpRexRegs->Draw.Set.Command = OC_DRAW
| LO_COPY
| STOPONX
| XYCONTINUE
| BLOCK
| QUADMODE
| ENLSPATTERN
| LSOPAQUE;
for (i = 0; i <= HalpCharacterHeight; i++) {
FontValue = 0;
for (j = 0; j < HalpBytesPerRow; j++) {
FontValue |= *(Glyph + (j * HalpCharacterHeight)) << (24 - (j * 8));
}
HalpRexRegs->Draw.Go.lsPattern = FontValue;
Glyph++;
}
HalpColumn++;
return;
}
Reference in New Issue View Git Blame Copy Permalink