VOID
DevDisableDGX(
PHW_DEVICE_EXTENSION HwDeviceExtension
)
/*++
Routine Description:
Disables the DGX and turns on VGA pass-thru.
Arguments:
HwDeviceExtension - Pointer to the miniport driver's device extension.
Return Value:
--*/
{
UCHAR cTemp, *pPort;
VideoDebugPrint((2, "DGX: DevDisableDGX\n"));
*HwDeviceExtension->pControlRegA = 0xb47370;
DacDelay();
pPort = (PCHAR)HwDeviceExtension->DGXControlPorts;
if (HwDeviceExtension->ModelNumber == 1) {
VideoPortWritePortUchar((PUCHAR)HwDeviceExtension->DGX1OutputPort,
0x6);
DacDelay();
pPort += 4;
VideoPortWritePortUchar(pPort, 0x1);
} else {
if (HwDeviceExtension->ModelNumber == 2) {
pPort += 8;
cTemp = VideoPortReadPortUchar(pPort);
cTemp &= 0xaf;
VideoPortWritePortUchar(pPort,
cTemp);
} else {
return;
}
}
}
static VOID FASTCALL
vgaSaveRegisters(PVGA_REGISTERS Registers)
{
UCHAR i;
for (i = 0; i < sizeof(Registers->CRT); i++)
{
VideoPortWritePortUchar(CRTC, i);
Registers->CRT[i] = VideoPortReadPortUchar(CRTCDATA);
}
for (i = 0; i < sizeof(Registers->Attribute); i++)
{
VideoPortReadPortUchar(STATUS);
VideoPortWritePortUchar(ATTRIB, i);
Registers->Attribute[i] = VideoPortReadPortUchar(ATTRIBREAD);
}
for (i = 0; i < sizeof(Registers->Graphics); i++)
{
VideoPortWritePortUchar(GRAPHICS, i);
Registers->Graphics[i] = VideoPortReadPortUchar(GRAPHICSDATA);
}
for (i = 0; i < sizeof(Registers->Sequencer); i++)
{
VideoPortWritePortUchar(SEQ, i);
Registers->Sequencer[i] = VideoPortReadPortUchar(SEQDATA);
}
Registers->Misc = VideoPortReadPortUchar(MISC);
}
static VOID FASTCALL
vgaSetRegisters(PVGA_REGISTERS Registers)
{
UCHAR i;
/* Update misc output register */
VideoPortWritePortUchar(MISC, Registers->Misc);
/* Synchronous reset on */
VideoPortWritePortUchar(SEQ, 0x00);
VideoPortWritePortUchar(SEQDATA, 0x01);
/* Write sequencer registers */
for (i = 1; i < sizeof(Registers->Sequencer); i++)
{
VideoPortWritePortUchar(SEQ, i);
VideoPortWritePortUchar(SEQDATA, Registers->Sequencer[i]);
}
/* Synchronous reset off */
VideoPortWritePortUchar(SEQ, 0x00);
VideoPortWritePortUchar(SEQDATA, 0x03);
/* Deprotect CRT registers 0-7 */
VideoPortWritePortUchar(CRTC, 0x11);
VideoPortWritePortUchar(CRTCDATA, Registers->CRT[0x11] & 0x7f);
/* Write CRT registers */
for (i = 0; i < sizeof(Registers->CRT); i++)
{
VideoPortWritePortUchar(CRTC, i);
VideoPortWritePortUchar(CRTCDATA, Registers->CRT[i]);
}
/* Write graphics controller registers */
for (i = 0; i < sizeof(Registers->Graphics); i++)
{
VideoPortWritePortUchar(GRAPHICS, i);
VideoPortWritePortUchar(GRAPHICSDATA, Registers->Graphics[i]);
}
/* Write attribute controller registers */
for (i = 0; i < sizeof(Registers->Attribute); i++)
{
VideoPortReadPortUchar(STATUS);
VideoPortWritePortUchar(ATTRIB, i);
VideoPortWritePortUchar(ATTRIB, Registers->Attribute[i]);
}
/* Renable screen. */
VideoPortWritePortUchar(ATTRIB, 0x20);
}
VOID
VgaZeroVideoMemory(
PHW_DEVICE_EXTENSION HwDeviceExtension
)
/*++
Routine Description:
This routine zeros the first 256K on the VGA.
Arguments:
HwDeviceExtension - Pointer to the miniport driver's device extension.
Return Value:
None.
--*/
{
UCHAR temp;
//
// Map font buffer at A0000
//
VgaInterpretCmdStream(HwDeviceExtension, EnableA000Data);
//
// Enable all planes.
//
VideoPortWritePortUchar(HwDeviceExtension->IOAddress + SEQ_ADDRESS_PORT,
IND_MAP_MASK);
temp = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
SEQ_DATA_PORT) | (UCHAR)0x0F;
VideoPortWritePortUchar(HwDeviceExtension->IOAddress + SEQ_DATA_PORT,
temp);
//
// Zero the memory.
//
VideoPortZeroDeviceMemory(HwDeviceExtension->VideoMemoryAddress,
0xFFFF);
VgaInterpretCmdStream(HwDeviceExtension, DisableA000Color);
} // VgaZeroVideoMemory(...)
VP_STATUS
VgaInterpretCmdStream(
PHW_DEVICE_EXTENSION HwDeviceExtension,
PUSHORT pusCmdStream
)
/*++
Routine Description:
Interprets the appropriate command array to set up VGA registers for the
requested mode. Typically used to set the VGA into a particular mode by
programming all of the registers
Arguments:
HwDeviceExtension - Pointer to the miniport driver's device extension.
pusCmdStream - array of commands to be interpreted.
Return Value:
The status of the operation (can only fail on a bad command); TRUE for
success, FALSE for failure.
--*/
{
ULONG ulCmd;
ULONG ulPort;
UCHAR jValue;
USHORT usValue;
ULONG culCount;
ULONG ulIndex;
ULONG ulBase;
if (pusCmdStream == NULL) {
VideoDebugPrint((1, "VgaInterpretCmdStream - Invalid pusCmdStream\n"));
return TRUE;
}
ulBase = (ULONG)HwDeviceExtension->IOAddress;
//
// Now set the adapter to the desired mode.
//
while ((ulCmd = *pusCmdStream++) != EOD) {
//
// Determine major command type
//
switch (ulCmd & 0xF0) {
//
// Basic input/output command
//
case INOUT:
//
// Determine type of inout instruction
//
if (!(ulCmd & IO)) {
//
// Out instruction. Single or multiple outs?
//
if (!(ulCmd & MULTI)) {
//
// Single out. Byte or word out?
//
if (!(ulCmd & BW)) {
//
// Single byte out
//
ulPort = *pusCmdStream++;
jValue = (UCHAR) *pusCmdStream++;
VideoPortWritePortUchar((PUCHAR)(ulBase+ulPort),
jValue);
} else {
//
// Single word out
//
ulPort = *pusCmdStream++;
usValue = *pusCmdStream++;
VideoPortWritePortUshort((PUSHORT)(ulBase+ulPort),
usValue);
}
} else {
//
// Output a string of values
// Byte or word outs?
//
if (!(ulCmd & BW)) {
//
// String byte outs. Do in a loop; can't use
// VideoPortWritePortBufferUchar because the data
// is in USHORT form
//
ulPort = ulBase + *pusCmdStream++;
culCount = *pusCmdStream++;
while (culCount--) {
jValue = (UCHAR) *pusCmdStream++;
VideoPortWritePortUchar((PUCHAR)ulPort,
jValue);
}
} else {
//
// String word outs
//
ulPort = *pusCmdStream++;
culCount = *pusCmdStream++;
VideoPortWritePortBufferUshort((PUSHORT)
(ulBase + ulPort), pusCmdStream, culCount);
pusCmdStream += culCount;
}
}
} else {
// In instruction
//
// Currently, string in instructions aren't supported; all
// in instructions are handled as single-byte ins
//
// Byte or word in?
//
if (!(ulCmd & BW)) {
//
// Single byte in
//
ulPort = *pusCmdStream++;
jValue = VideoPortReadPortUchar((PUCHAR)ulBase+ulPort);
} else {
//
// Single word in
//
ulPort = *pusCmdStream++;
usValue = VideoPortReadPortUshort((PUSHORT)
(ulBase+ulPort));
}
}
break;
//
// Higher-level input/output commands
//
case METAOUT:
//
// Determine type of metaout command, based on minor
// command field
//
switch (ulCmd & 0x0F) {
//
// Indexed outs
//
case INDXOUT:
ulPort = ulBase + *pusCmdStream++;
culCount = *pusCmdStream++;
ulIndex = *pusCmdStream++;
while (culCount--) {
usValue = (USHORT) (ulIndex +
(((ULONG)(*pusCmdStream++)) << 8));
VideoPortWritePortUshort((PUSHORT)ulPort, usValue);
ulIndex++;
}
break;
//
// Masked out (read, AND, XOR, write)
//
case MASKOUT:
ulPort = *pusCmdStream++;
jValue = VideoPortReadPortUchar((PUCHAR)ulBase+ulPort);
jValue &= *pusCmdStream++;
jValue ^= *pusCmdStream++;
VideoPortWritePortUchar((PUCHAR)ulBase + ulPort,
jValue);
break;
//
// Attribute Controller out
//
case ATCOUT:
ulPort = ulBase + *pusCmdStream++;
culCount = *pusCmdStream++;
ulIndex = *pusCmdStream++;
while (culCount--) {
// Write Attribute Controller index
VideoPortWritePortUchar((PUCHAR)ulPort,
(UCHAR)ulIndex);
// Write Attribute Controller data
jValue = (UCHAR) *pusCmdStream++;
VideoPortWritePortUchar((PUCHAR)ulPort, jValue);
ulIndex++;
}
break;
//
// None of the above; error
//
default:
return FALSE;
}
break;
//
// NOP
//
case NCMD:
break;
//
// Unknown command; error
//
default:
return FALSE;
}
}
return TRUE;
} // end VgaInterpretCmdStream()
VP_STATUS
VgaSetMode(
PHW_DEVICE_EXTENSION HwDeviceExtension,
PVIDEO_MODE Mode,
ULONG ModeSize
)
/*++
Routine Description:
This routine sets the vga into the requested mode.
Arguments:
HwDeviceExtension - Pointer to the miniport driver's device extension.
Mode - Pointer to the structure containing the information about the
font to be set.
ModeSize - Length of the input buffer supplied by the user.
Return Value:
ERROR_INSUFFICIENT_BUFFER if the input buffer was not large enough
for the input data.
ERROR_INVALID_PARAMETER if the mode number is invalid.
NO_ERROR if the operation completed successfully.
--*/
{
PVIDEOMODE pRequestedMode;
VP_STATUS status;
#ifdef INT10_MODE_SET
VIDEO_X86_BIOS_ARGUMENTS biosArguments;
#endif
//
// Check if the size of the data in the input buffer is large enough.
//
if (ModeSize < sizeof(VIDEO_MODE)) {
return ERROR_INSUFFICIENT_BUFFER;
}
//
// Extract the clear memory bit.
//
if (Mode->RequestedMode & VIDEO_MODE_NO_ZERO_MEMORY) {
Mode->RequestedMode &= ~VIDEO_MODE_NO_ZERO_MEMORY;
} else {
VgaZeroVideoMemory(HwDeviceExtension);
}
//
// Check to see if we are requesting a valid mode
//
if ( (Mode->RequestedMode >= NumVideoModes) ||
(!ModesVGA[Mode->RequestedMode].ValidMode) ) {
return ERROR_INVALID_PARAMETER;
}
pRequestedMode = &ModesVGA[Mode->RequestedMode];
#ifdef INT10_MODE_SET
VideoPortZeroMemory(&biosArguments, sizeof(VIDEO_X86_BIOS_ARGUMENTS));
biosArguments.Ebx = pRequestedMode->Int10ModeNumber;
if (biosArguments.Ebx != 0) {
biosArguments.Eax = 0x6f05;
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
if (status != NO_ERROR) {
return status;
}
}
#endif
//
// Call the interpreter
//
VgaInterpretCmdStream(HwDeviceExtension,
pRequestedMode->CmdStrings[HwDeviceExtension->AdapterType]);
#ifdef INT10_MODE_SET
{
UCHAR temp;
UCHAR dummy;
UCHAR bIsColor;
if (!(pRequestedMode->fbType & VIDEO_MODE_GRAPHICS)) {
//
// Fix to make sure we always set the colors in text mode to be
// intensity, and not flashing
// For this zero out the Mode Control Regsiter bit 3 (index 0x10
// of the Attribute controller).
//
if (VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
MISC_OUTPUT_REG_READ_PORT) & 0x01) {
bIsColor = TRUE;
} else {
bIsColor = FALSE;
}
if (bIsColor) {
dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
INPUT_STATUS_1_COLOR);
} else {
dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
INPUT_STATUS_1_MONO);
}
VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
ATT_ADDRESS_PORT, (0x10 | VIDEO_ENABLE));
temp = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
ATT_DATA_READ_PORT);
temp &= 0xF7;
if (bIsColor) {
dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
INPUT_STATUS_1_COLOR);
} else {
dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
INPUT_STATUS_1_MONO);
}
VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
ATT_ADDRESS_PORT, (0x10 | VIDEO_ENABLE));
VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
ATT_DATA_WRITE_PORT, temp);
}
}
#endif
//
// Update the location of the physical frame buffer within video memory.
//
HwDeviceExtension->PhysicalFrameLength =
MemoryMaps[pRequestedMode->MemMap].MaxSize;
HwDeviceExtension->PhysicalFrameBase.LowPart =
MemoryMaps[pRequestedMode->MemMap].Start;
//
// Store the new mode value.
//
HwDeviceExtension->ModeIndex = Mode->RequestedMode;
HwDeviceExtension->CurrentMode = pRequestedMode;
return NO_ERROR;
} //end VgaSetMode()
VP_STATUS
VgaSetMode(
PHW_DEVICE_EXTENSION HwDeviceExtension,
PVIDEO_MODE Mode,
ULONG ModeSize
)
/*++
Routine Description:
This routine sets the VGA into the requested mode.
Arguments:
HwDeviceExtension - Pointer to the miniport driver's device extension.
Mode - Pointer to the structure containing the information about the
font to be set.
ModeSize - Length of the input buffer supplied by the user.
Return Value:
ERROR_INSUFFICIENT_BUFFER if the input buffer was not large enough
for the input data.
ERROR_INVALID_PARAMETER if the mode number is invalid.
NO_ERROR if the operation completed successfully.
--*/
{
PVIDEOMODE pRequestedMode;
VP_STATUS status;
//
// Check if the size of the data in the input buffer is large enough.
//
if (ModeSize < sizeof(VIDEO_MODE)) {
return ERROR_INSUFFICIENT_BUFFER;
}
//
// Extract the clear memory bit.
//
if (Mode->RequestedMode & VIDEO_MODE_NO_ZERO_MEMORY) {
Mode->RequestedMode &= ~VIDEO_MODE_NO_ZERO_MEMORY;
} else {
VgaZeroVideoMemory(HwDeviceExtension);
}
//
// Check to see if we are requesting a valid mode
//
if ((Mode->RequestedMode >= NUM_VIDEO_MODES) ||
(!ModesVGA[Mode->RequestedMode].ValidMode)) {
VideoDebugPrint((0,"AVGA.sys: VGASetMode - ERROR_INVALID_PARAMETER.\n"));
return ERROR_INVALID_PARAMETER;
}
pRequestedMode = &ModesVGA[Mode->RequestedMode];
HwDeviceExtension->ModeIndex = Mode->RequestedMode;
//
// Store the new mode value.
//
HwDeviceExtension->CurrentMode = pRequestedMode;
#ifdef INT10_MODE_SET
{
VIDEO_X86_BIOS_ARGUMENTS biosArguments;
UCHAR temp;
UCHAR dummy;
UCHAR bIsColor;
/***********************************************************************
*** There appears to be a problem with some application ***
*** which reset the first 16 palette registers. ***
*** Since the palette is not reset when going to and ***
*** from text modes by doing a set mode (instead of ***
*** the hardware save restore), some colors might not ***
*** appear as expected in the text modes. The bios ***
*** calls seem to reload the palette so Andre Vachon ***
*** suggested that we implement an Int10 mode set for the ***
*** text modes. ***
*** To accomplish this, we need to hard code the first ***
*** three modes in modeset.h in the following switch. ***
*** If more text modes are added to modeset.h, their ***
*** index must be added to this switch statement. ***
***********************************************************************/
VideoPortZeroMemory(&biosArguments, sizeof(VIDEO_X86_BIOS_ARGUMENTS));
switch (Mode->RequestedMode) {
case 0: // 720x400
/***********************************************************************
*** Prepare the card for the VGA mode 3+ instead of the CGA mode 3 ***
***********************************************************************/
biosArguments.Eax = 0x1202; // Select Scan line number
biosArguments.Ebx = 0x0030; // to be 400 scan lines
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
/***********************************************************************
*** Set the video mode to BIOS mode 3. ***
***********************************************************************/
VideoPortZeroMemory(&biosArguments, sizeof(VIDEO_X86_BIOS_ARGUMENTS));
biosArguments.Eax = 0x03; // bios mode 0x03
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
break;
case 1: // 640x350
/***********************************************************************
*** Prepare the card for the EGA mode 3* instead of the CGA mode 3 ***
***********************************************************************/
biosArguments.Eax = 0x1201; // Select Scan line number
biosArguments.Ebx = 0x0030; // to be 350 scan lines
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
/***********************************************************************
*** Set the video mode to BIOS mode 3. ***
***********************************************************************/
VideoPortZeroMemory(&biosArguments, sizeof(VIDEO_X86_BIOS_ARGUMENTS));
biosArguments.Eax = 0x03; // bios mode 0x03
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
break;
default: // all graphics modes are
// handled by the default case
biosArguments.Eax = pRequestedMode->Int10ModeNumber;
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
break;
}
if (status != NO_ERROR) {
return status;
}
//
// Fix to get 640x350 text mode
//
if (!(pRequestedMode->fbType & VIDEO_MODE_GRAPHICS)) {
// if ((pRequestedMode->hres == 640) &&
// (pRequestedMode->vres == 350)) {
//
// VgaInterpretCmdStream(HwDeviceExtension, VGA_TEXT_1);
//
// } else {
//
// Fix to make sure we always set the colors in text mode to be
// intensity, and not flashing
// For this zero out the Mode Control Regsiter bit 3 (index 0x10
// of the Attribute controller).
//
if (VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
MISC_OUTPUT_REG_READ_PORT) & 0x01) {
bIsColor = TRUE;
} else {
bIsColor = FALSE;
}
if (bIsColor) {
dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
INPUT_STATUS_1_COLOR);
} else {
dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
INPUT_STATUS_1_MONO);
}
VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
ATT_ADDRESS_PORT, (0x10 | VIDEO_ENABLE));
temp = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
ATT_DATA_READ_PORT);
temp &= 0xF7;
if (bIsColor) {
dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
INPUT_STATUS_1_COLOR);
} else {
dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
INPUT_STATUS_1_MONO);
}
VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
ATT_ADDRESS_PORT, (0x10 | VIDEO_ENABLE));
VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
ATT_DATA_WRITE_PORT, temp);
// }
}
}
#else
VgaInterpretCmdStream(HwDeviceExtension, pRequestedMode->CmdStrings);
#endif
//
// Update the location of the physical frame buffer within video memory.
//
HwDeviceExtension->PhysicalFrameLength =
MemoryMaps[pRequestedMode->MemMap].MaxSize;
HwDeviceExtension->PhysicalFrameBase.LowPart =
MemoryMaps[pRequestedMode->MemMap].Start;
return NO_ERROR;
} // end VgaSetMode()
BOOLEAN
PciGetBaseAddr(
PHW_DEVICE_EXTENSION HwDeviceExtension
)
/*++
Routine Description:
Perform board detection and if present return the P9 base address.
Arguments:
HwDeviceExtension - Pointer to the miniport driver's device extension.
Return Value:
TRUE - Board found, P9 and Frame buffer address info was placed in
the device extension. PCI extended base address was placed in the
device extension.
FALSE - Board not found.
--*/
{
VIDEO_ACCESS_RANGE PciAccessRange;
PVIDEO_ACCESS_RANGE DefaultDACRegRange;
ULONG ulTempAddr;
ULONG ulBiosAddr;
ULONG ulBoardAddr;
ULONG ulTemp;
LONG i;
VP_STATUS status;
ULONG wcpID;
//
// Only the viper p9000 works on the Siemens boxes
//
if (HwDeviceExtension->MachineType == SIEMENS
|| HwDeviceExtension->MachineType == SIEMENS_P9100_VLB)
{
return FALSE;
}
//
// See if the PCI HAL can locate a Weitek 9001 PCI Board.
//
//
// First check for a P9100
//
if (PciFindDevice(HwDeviceExtension,
WTK_9100_ID,
WTK_VENDOR_ID,
&HwDeviceExtension->PciSlotNum))
{
wcpID = P9100_ID;
HwDeviceExtension->usBusType = PCI;
// Just a hack to get things working.
// NOTE: !!! WE should really do the detection.
HwDeviceExtension->p91State.bVideoPowerEnabled = FALSE;
// Now make sure we are looking for a P9100, if were not
// then fail.
if (HwDeviceExtension->P9CoprocInfo.CoprocId != P9100_ID)
{
return(FALSE);
}
#ifdef _MIPS_
//
// SNI platform recognition and specific stuff
//
{
extern VP_STATUS GetCPUIdCallback(
PVOID HwDeviceExtension,
PVOID Context,
VIDEO_DEVICE_DATA_TYPE DeviceDataType,
PVOID Identifier,
ULONG IdentifierLength,
PVOID ConfigurationData,
ULONG ConfigurationDataLength,
PVOID ComponentInformation,
ULONG ComponentInformationLength
);
if(VideoPortIsCpu(L"RM200PCI")
|| VideoPortIsCpu(L"RM300PCI")
|| VideoPortIsCpu(L"RM300PCI MP")
|| VideoPortIsCpu(L"RM400PCI")
|| VideoPortIsCpu(L"RM4x0PCI"))
{
// adjust the VGA physical address with the E/ISA I/O space
DriverAccessRanges[1].RangeStart.LowPart += 0x14000000 ;
HwDeviceExtension->MachineType = SIEMENS_P9100_PCi;
}
}
#endif
}
else if (PciFindDevice(HwDeviceExtension,
WTK_9001_ID,
WTK_VENDOR_ID,
&HwDeviceExtension->PciSlotNum))
{
wcpID = P9000_ID;
// Now make sure we are looking for a P9000, if were not
// then fail.
if (HwDeviceExtension->P9CoprocInfo.CoprocId != P9000_ID)
{
return(FALSE);
}
//
// Read the config space to determine if
// this is Rev 1 or 2. This will determine at which addresses
// the DAC registers are mapped.
//
if (!VideoPortGetBusData(HwDeviceExtension,
PCIConfiguration,
HwDeviceExtension->PciSlotNum,
&ulTemp,
P9001_REV_ID,
sizeof(ulTemp)))
{
return(FALSE);
}
//
// Got the 9001 rev id. Choose the appropriate table of DAC register
// addresses.
//
switch((UCHAR) (ulTemp))
{
case 1 :
//
// This is a Rev 1 9001, which uses the standard VL DAC
// Addresses. All known rev 1 implementations use the
// Weitek 5286 VGA chip.
//
DefaultDACRegRange = VLDefDACRegRange;
HwDeviceExtension->AdapterDesc.bWtk5x86 = TRUE;
break;
case 2 :
default:
//
// This is a Rev 2 9001. Set up the table of DAC register
// offsets accordingly.
//
DefaultDACRegRange = Pci9001DefDACRegRange;
//
// A Rev 2 9001 is present. Get the BIOS ROM address from the
// PCI configuration space so we can do a ROM scan to
// determine if this is a Viper PCI adapter.
//
PciAccessRange.RangeStart.LowPart = 0;
PciAccessRange.RangeStart.HighPart = 0;
if (VideoPortGetBusData(HwDeviceExtension,
PCIConfiguration,
HwDeviceExtension->PciSlotNum,
&PciAccessRange.RangeStart.LowPart,
P9001_BIOS_BASE_ADDR,
sizeof(ULONG)) == 0)
{
return FALSE;
}
if (PciAccessRange.RangeStart.LowPart)
{
//
// We found an address for the BIOS. Verify it.
//
// Set up the access range so we can map out the BIOS ROM
// space. This will allow us to scan the ROM and detect the
// presence of a Viper PCI adapter.
//
PciAccessRange.RangeInIoSpace = FALSE;
PciAccessRange.RangeVisible = TRUE;
PciAccessRange.RangeShareable = TRUE;
PciAccessRange.RangeLength = BIOS_RANGE_LEN;
//
// Check to see if another miniport driver has allocated the
// BIOS' memory space.
//
if (VideoPortVerifyAccessRanges(HwDeviceExtension,
1L,
&PciAccessRange) != NO_ERROR)
{
PciAccessRange.RangeStart.LowPart = 0;
}
}
if (PciAccessRange.RangeStart.LowPart == 0)
{
//
// The Adapter has not been enabled, so we need to map the
// BIOS address.
//
IO_RESOURCE_DESCRIPTOR ioResource = {
IO_RESOURCE_PREFERRED,
CmResourceTypeMemory,
CmResourceShareDeviceExclusive,
0,
CM_RESOURCE_MEMORY_READ_WRITE,
0,
{
BIOS_RANGE_LEN, // Length
BIOS_RANGE_LEN, // Alignment
{ 0x10000000, 0 }, // Minimum start address
{ 0xefffffff, 0} // Maximum end address
}
};
status = VideoPortGetAccessRanges(HwDeviceExtension,
1,
&ioResource,
1,
&PciAccessRange,
NULL,
NULL,
&HwDeviceExtension->PciSlotNum);
if (status != NO_ERROR)
{
return(FALSE);
}
}
//
// Map in the BIOS' memory space. If it can't be mapped,
// return an error.
//
if ((ulBiosAddr = (ULONG)
VideoPortGetDeviceBase(HwDeviceExtension,
PciAccessRange.RangeStart,
PciAccessRange.RangeLength,
PciAccessRange.RangeInIoSpace)) == 0)
{
return(FALSE);
}
//
// Enable the Adapter BIOS.
//
ulTemp = PciAccessRange.RangeStart.LowPart | PCI_BIOS_ENB;
VideoPortSetBusData(HwDeviceExtension,
PCIConfiguration,
HwDeviceExtension->PciSlotNum,
&ulTemp,
P9001_BIOS_BASE_ADDR,
sizeof(ULONG));
if (VideoPortScanRom(HwDeviceExtension,
(PUCHAR) ulBiosAddr,
BIOS_RANGE_LEN,
VIPER_ID_STR))
{
//
// A Viper PCI is present, use the Viper set mode,
// enable/disable video function pointers, and clk
// divisor values. Also, Viper PCI does not
// use a Weitek VGA.
//
HwDeviceExtension->AdapterDesc.OEMSetMode = ViperSetMode;
HwDeviceExtension->AdapterDesc.P9EnableVideo =
ViperPciP9Enable;
HwDeviceExtension->AdapterDesc.P9DisableVideo =
ViperPciP9Disable;
HwDeviceExtension->AdapterDesc.iClkDiv = 4;
HwDeviceExtension->AdapterDesc.bWtk5x86 = FALSE;
}
else
{
//
// All non-Viper Rev 2 implementations use a Weitek
// 5286 VGA chip.
//
HwDeviceExtension->AdapterDesc.bWtk5x86 = TRUE;
}
//
// Restore the BIOS register to it's original value.
//
VideoPortSetBusData(HwDeviceExtension,
PCIConfiguration,
HwDeviceExtension->PciSlotNum,
&ulTempAddr,
P9001_BIOS_BASE_ADDR,
sizeof(ULONG));
VideoPortFreeDeviceBase(HwDeviceExtension, (PVOID) ulBiosAddr);
break;
}
}
else if (PciFindDevice(HwDeviceExtension, // Search for a Weitek 9002.
WTK_9002_ID,
WTK_VENDOR_ID,
&HwDeviceExtension->PciSlotNum))
{
wcpID = P9000_ID;
// Now make sure we are looking for a P9000, if were not
// then fail.
if (HwDeviceExtension->P9CoprocInfo.CoprocId != P9000_ID)
{
return(FALSE);
}
//
// Found a 9002 board. Set up the table of DAC addresses
// accordingly.
//
DefaultDACRegRange = Pci9002DefDACRegRange;
}
else
{
//
// No Weitek PCI devices were found, return an error.
//
return(FALSE);
}
//
// Get the base address of the adapter.
// Some machines rely on the address not changing - if the address changes
// the machine randomly appears to corrupt memory.
// So use the pre-configured address if it is available.
//
HwDeviceExtension->P9PhysAddr.LowPart = 0;
VideoPortGetBusData(HwDeviceExtension,
PCIConfiguration,
HwDeviceExtension->PciSlotNum,
&HwDeviceExtension->P9PhysAddr.LowPart,
P9001_BASE_ADDR,
sizeof(ULONG));
if (HwDeviceExtension->P9PhysAddr.LowPart == 0)
{
IO_RESOURCE_DESCRIPTOR ioResource = {
IO_RESOURCE_PREFERRED,
CmResourceTypeMemory,
CmResourceShareDeviceExclusive,
0,
CM_RESOURCE_MEMORY_READ_WRITE,
0,
{
RESERVE_PCI_ADDRESS_SPACE, // Length
RESERVE_PCI_ADDRESS_SPACE, // Alignment
{ 0x10000000, 0 }, // Minimum start address
{ 0xefffffff, 0} // Maximum end address
}
};
status = VideoPortGetAccessRanges(HwDeviceExtension,
1,
&ioResource,
1,
&PciAccessRange,
NULL,
NULL,
&HwDeviceExtension->PciSlotNum);
if (status == NO_ERROR)
{
HwDeviceExtension->P9PhysAddr = PciAccessRange.RangeStart;
//
// Save the physical base address in the PCI config space.
//
VideoPortSetBusData(HwDeviceExtension,
PCIConfiguration,
HwDeviceExtension->PciSlotNum,
&HwDeviceExtension->P9PhysAddr.LowPart,
P9001_BASE_ADDR,
sizeof(ULONG));
}
}
if (HwDeviceExtension->P9PhysAddr.LowPart == 0)
{
return(FALSE);
}
//
// The P9100 can access the DAC directly, so no I/O space needs to be
// allocated for DAC access.
//
if (wcpID == P9000_ID)
{
//
// The Adapter has not been enabled, so we need to map the
// base IO address.
//
IO_RESOURCE_DESCRIPTOR ioResource = {
IO_RESOURCE_PREFERRED,
CmResourceTypePort,
CmResourceShareDeviceExclusive,
0,
CM_RESOURCE_PORT_IO,
0,
{
P9001_IO_RANGE, // Length
P9001_IO_RANGE, // Alignment
{ 0x00001000, 0 }, // Minimum start address
{ 0x0000ffff, 0} // Maximum end address
}
};
status = VideoPortGetAccessRanges(HwDeviceExtension,
1,
&ioResource,
1,
&PciAccessRange,
NULL,
NULL,
&HwDeviceExtension->PciSlotNum);
if (status == NO_ERROR)
{
HwDeviceExtension->P9001PhysicalAddress = PciAccessRange.RangeStart;
}
else
{
return(FALSE);
}
//
// Save the physical base address in the PCI config space.
//
ulTemp = HwDeviceExtension->P9001PhysicalAddress.LowPart | 0x01;
VideoPortSetBusData(HwDeviceExtension,
PCIConfiguration,
HwDeviceExtension->PciSlotNum,
&ulTemp,
P9001_REG_BASE,
sizeof(ULONG));
//
// Compute the actual base address.
//
HwDeviceExtension->P9001PhysicalAddress.LowPart &= 0xFFFFFFFE;
//
// If this is a 9002 board, map in and read the VGA id register.
//
if (DefaultDACRegRange == Pci9002DefDACRegRange)
{
//
// Set up the access range so we can map out the VGA ID register.
//
PciAccessRange.RangeInIoSpace = TRUE;
PciAccessRange.RangeVisible = TRUE;
PciAccessRange.RangeShareable = TRUE;
PciAccessRange.RangeLength = 1;
PciAccessRange.RangeStart = HwDeviceExtension->P9001PhysicalAddress;
PciAccessRange.RangeStart.LowPart += P9002_VGA_ID;
//
// Map in the VGA ID register. If it can't be mapped,
// we can't determine the VGA type, so just use the default.
//
if ((ulBoardAddr = (ULONG)
VideoPortGetDeviceBase(HwDeviceExtension,
PciAccessRange.RangeStart,
PciAccessRange.RangeLength,
PciAccessRange.RangeInIoSpace)) != 0)
{
HwDeviceExtension->AdapterDesc.bWtk5x86 =
(VideoPortReadPortUchar((PUCHAR) ulBoardAddr) & VGA_MSK == WTK_VGA);
VideoPortFreeDeviceBase(HwDeviceExtension,
(PVOID) ulBoardAddr);
}
else
{
//
// Assume this is a 5x86 VGA.
//
HwDeviceExtension->AdapterDesc.bWtk5x86 = TRUE;
}
}
//
// Compute the actual DAC register addresses relative to the PCI
// base address.
//
for (i = 0; i < HwDeviceExtension->Dac.cDacRegs; i++)
{
//
// If this is not a palette addr or data register, and the board
// is not using the standard VL addresses, compute the register
// address relative to the register base address.
//
if ((i > 3) && (DefaultDACRegRange != VLDefDACRegRange))
{
DefaultDACRegRange[i].RangeStart.LowPart +=
HwDeviceExtension->P9001PhysicalAddress.LowPart;
}
}
//
// Copy the DAC register access range into the global list of access
// ranges.
//
VideoPortMoveMemory(&DriverAccessRanges[NUM_DRIVER_ACCESS_RANGES],
DefaultDACRegRange,
sizeof(VIDEO_ACCESS_RANGE) *
HwDeviceExtension->Dac.cDacRegs);
//
// This is a hack. Initialize an additional access range to map out
// the entire 4K range of contiguous IO space starting at PCI_REG_BASE.
// apparently the 9001 decodes accesses over this entire range rather
// than the individual register offsets within this range.
//
//
// Set up the access range so we can map the entire 4k IO range.
//
PciAccessRange.RangeInIoSpace = TRUE;
PciAccessRange.RangeVisible = TRUE;
PciAccessRange.RangeShareable = TRUE;
PciAccessRange.RangeLength = P9001_IO_RANGE;
PciAccessRange.RangeStart = HwDeviceExtension->P9001PhysicalAddress;
VideoPortMoveMemory(&DriverAccessRanges[NUM_DRIVER_ACCESS_RANGES +
NUM_DAC_ACCESS_RANGES],
&PciAccessRange,
sizeof(VIDEO_ACCESS_RANGE));
}
return(TRUE);
}
static BOOLEAN
ReadfromSMBus(UCHAR Address, UCHAR bRegister, UCHAR Size, ULONG *Data_to_smbus)
{
int nRetriesToLive=50;
while (0 != (VideoPortReadPortUshort((PUSHORT) (I2C_IO_BASE + 0)) & 0x0800))
{
; /* Franz's spin while bus busy with any master traffic */
}
while (0 != nRetriesToLive--)
{
UCHAR b;
int temp;
VideoPortWritePortUchar((PUCHAR) (I2C_IO_BASE + 4), (Address << 1) | 1);
VideoPortWritePortUchar((PUCHAR) (I2C_IO_BASE + 8), bRegister);
temp = VideoPortReadPortUshort((PUSHORT) (I2C_IO_BASE + 0));
VideoPortWritePortUshort((PUSHORT) (I2C_IO_BASE + 0), temp); /* clear down all preexisting errors */
switch (Size)
{
case 4:
VideoPortWritePortUchar((PUCHAR) (I2C_IO_BASE + 2), 0x0d); /* DWORD modus ? */
break;
case 2:
VideoPortWritePortUchar((PUCHAR) (I2C_IO_BASE + 2), 0x0b); /* WORD modus */
break;
default:
VideoPortWritePortUchar((PUCHAR) (I2C_IO_BASE + 2), 0x0a); // BYTE
break;
}
b = 0;
while (0 == (b & 0x36))
{
b = VideoPortReadPortUchar((PUCHAR) (I2C_IO_BASE + 0));
}
if (0 != (b & 0x24))
{
/* printf("I2CTransmitByteGetReturn error %x\n", b); */
}
if(0 == (b & 0x10))
{
/* printf("I2CTransmitByteGetReturn no complete, retry\n"); */
}
else
{
switch (Size)
{
case 4:
VideoPortReadPortUchar((PUCHAR) (I2C_IO_BASE + 6));
VideoPortReadPortUchar((PUCHAR) (I2C_IO_BASE + 9));
VideoPortReadPortUchar((PUCHAR) (I2C_IO_BASE + 9));
VideoPortReadPortUchar((PUCHAR) (I2C_IO_BASE + 9));
VideoPortReadPortUchar((PUCHAR) (I2C_IO_BASE + 9));
break;
case 2:
*Data_to_smbus = VideoPortReadPortUshort((PUSHORT) (I2C_IO_BASE + 6));
break;
default:
*Data_to_smbus = VideoPortReadPortUchar((PUCHAR) (I2C_IO_BASE + 6));
break;
}
return TRUE;
}
}
return FALSE;
}
ULONG
QRY_ControllerASICID( PUCHAR IOAddress )
/*++
Function: QRY_ControllerASICID
This function returns the ASIC id of Compaq Video controllers.
Return value:
The return value is a ULONG with bytes defined as follows:
3 2 1 0 (byte positions)
ULONG ---> XX FF FF FF
-- -- -- --
| | | |____ASIC ID
| | |_______Extended ID
| |__________Second Extended ID
|_____________Not used (will be zero)
--*/
//---------------------------------------------------------------------------
{
ULONG ulReturn = 0L;
UCHAR ucTemp = 0 ;
// unlock QVision registers
//
VideoPortWritePortUchar((PUCHAR)(IOAddress + GRAPH_ADDRESS_PORT),
0x0f);
ucTemp = VideoPortReadPortUchar((IOAddress + \
GRAPH_DATA_PORT)) & 0xf0;
VideoPortWritePortUchar((PUCHAR)(IOAddress + GRAPH_DATA_PORT),
(UCHAR)(0x05 | ucTemp));
VideoPortWritePortUchar((PUCHAR)(IOAddress + GRAPH_ADDRESS_PORT),
0x10);
ucTemp = VideoPortReadPortUchar((PUCHAR)(IOAddress + GRAPH_DATA_PORT));
VideoPortWritePortUchar((PUCHAR)(IOAddress + GRAPH_DATA_PORT),
(UCHAR)(0x28 | ucTemp));
//
// get asic id
//
VideoPortWritePortUchar((PUCHAR)(IOAddress + GRAPH_ADDRESS_PORT), 0x0c);
// read in asic id
//
ucTemp = VideoPortReadPortUchar(IOAddress + GRAPH_DATA_PORT) ;
ulReturn = (ULONG)ucTemp; // save asic id
//
// is extended id info available ?
//
if (ucTemp & EXTENDED_ID_BIT) {
VideoPortWritePortUchar((PUCHAR)(IOAddress + GRAPH_ADDRESS_PORT), 0x0d);
//
// read in extended id
//
ucTemp = VideoPortReadPortUchar(IOAddress + GRAPH_DATA_PORT) ;
ulReturn |= ((ULONG)(ucTemp)) << 8 ;
//
// is second extended id info available ?
//
if (ucTemp & EXTENDED_ID2_BIT) {
VideoPortWritePortUchar((PUCHAR)(IOAddress + GRAPH_ADDRESS_PORT), 0x0e);
//
// read in second extended id
//
ucTemp = VideoPortReadPortUchar(IOAddress + GRAPH_DATA_PORT) ;
ulReturn |= ((ULONG)(ucTemp)) << 16 ;
}
}
return (ulReturn);
}
