You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1342 lines
51 KiB
1342 lines
51 KiB
/************************************************************************/
|
|
/* */
|
|
/* SETUP_CX.C */
|
|
/* */
|
|
/* Aug 27 1993 (c) 1993, ATI Technologies Incorporated. */
|
|
/************************************************************************/
|
|
|
|
/********************** PolyTron RCS Utilities
|
|
|
|
$Revision: 1.21 $
|
|
$Date: 15 May 1996 16:36:04 $
|
|
$Author: RWolff $
|
|
$Log: S:/source/wnt/ms11/miniport/archive/setup_cx.c_v $
|
|
*
|
|
* Rev 1.21 15 May 1996 16:36:04 RWolff
|
|
* Now records in registry if we have to cut back on BIOS claim
|
|
* size (conflict with SCSI card having BIOS segment below 0xD000:0000)
|
|
* so we only get event log messages on the first boot, rather
|
|
* than on every boot.
|
|
*
|
|
* Rev 1.20 03 May 1996 15:16:42 RWolff
|
|
* Made new temporary variable conditional on platform type to avoid
|
|
* warning when compiling for non-Alpha platforms.
|
|
*
|
|
* Rev 1.19 03 May 1996 14:07:26 RWolff
|
|
* Fixed drawing problem with GX-F ASIC on DEC Alpha.
|
|
*
|
|
* Rev 1.18 15 Apr 1996 13:51:30 RWolff
|
|
* Fallback to claiming 32k of BIOS if we can't get the full 64k, to avoid
|
|
* conflict with Adaptec 154x adapters with their BIOS segment set to
|
|
* 0xC800:0000 or 0xCC00:0000
|
|
*
|
|
* Rev 1.17 29 Jan 1996 17:01:56 RWolff
|
|
* Now uses VideoPortInt10() rather than no-BIOS code on PPC, now
|
|
* rejects exhaustive list of non-Mach 64 cards and accepts all
|
|
* others when looking for block I/O cards, rather than accepting
|
|
* exhaustive list of Mach 64 cards and rejecting all others.
|
|
*
|
|
* Rev 1.16 23 Jan 1996 17:52:16 RWolff
|
|
* Added GT to list of Mach 64 cards capable of supporting block I/O.
|
|
*
|
|
* Rev 1.15 23 Jan 1996 11:49:38 RWolff
|
|
* Eliminated level 3 warnings, added debug print statements, removed
|
|
* conditionally-compilec code to use VideoPortGetAccessRanges() to
|
|
* find block I/O cards, since this function remaps the I/O base address
|
|
* and this is incompatible with the use of INT 10.
|
|
*
|
|
* Rev 1.14 12 Jan 1996 11:18:50 RWolff
|
|
* Reduced size of buffer requested through VideoPortGetBusData()
|
|
*
|
|
* Rev 1.13 23 Nov 1995 11:31:42 RWolff
|
|
* Now searches each PCI slot for our cards, rather than using
|
|
* VideoPortGetAccessRanges(), since that routine won't detect
|
|
* block-relocatable GX-F2s properly. This change is not sanctioned
|
|
* by Microsoft, and must be backed out if they fix their routine.
|
|
*
|
|
* Rev 1.12 24 Aug 1995 15:39:06 RWolff
|
|
* Changed detection of block I/O cards to match Microsoft's
|
|
* standard for plug-and-play.
|
|
*
|
|
* Rev 1.11 13 Jun 1995 15:11:18 RWOLFF
|
|
* On Alpha systems, now only uses dense space for the memory mapped
|
|
* registers on PCI cards. This is to allow support for ISA cards on
|
|
* the Jensen (EISA machine, no PCI support), which doesn't support
|
|
* dense space.
|
|
*
|
|
* Rev 1.10 30 Mar 1995 12:02:14 RWOLFF
|
|
* WaitForIdle_cx() and CheckFIFOSpace_cx() now time out and reset
|
|
* the engine after 3 seconds (no operation should take this long)
|
|
* to clear a hung engine, changed permanent debug print statements
|
|
* to use new debug level thresholds.
|
|
*
|
|
* Rev 1.9 08 Mar 1995 11:35:44 ASHANMUG
|
|
* Modified return values to be correct
|
|
*
|
|
* Rev 1.7 27 Feb 1995 17:53:26 RWOLFF
|
|
* Added routine that reports whether the I/O registers are packed
|
|
* (relocatable) or not.
|
|
*
|
|
* Rev 1.6 24 Feb 1995 12:30:44 RWOLFF
|
|
* Added code to support relocatable I/O. This is not yet fully
|
|
* operational, so it is disabled for this release.
|
|
*
|
|
* Rev 1.5 23 Dec 1994 10:47:12 ASHANMUG
|
|
* ALPHA/Chrontel-DAC
|
|
*
|
|
* Rev 1.4 18 Nov 1994 11:48:18 RWOLFF
|
|
* Added support for Mach 64 with no BIOS, routine to get the I/O base
|
|
* address for the card being used.
|
|
*
|
|
* Rev 1.3 20 Jul 1994 12:59:12 RWOLFF
|
|
* Added support for multiple I/O base addresses for accelerator registers.
|
|
*
|
|
* Rev 1.2 30 Jun 1994 18:16:50 RWOLFF
|
|
* Added IsApertureConflict_cx() (moved from QUERY_CX.C). Instead of checking
|
|
* to see if we can read back what we have written to the aperture, then
|
|
* looking for the proper text attribute, we now make a call to
|
|
* VideoPortVerifyAccessRanges() which includes the aperture in the list of
|
|
* ranges we are trying to claim. If this call fails, we make another call
|
|
* which does not include the LFB. We always claim the VGA aperture (shareable),
|
|
* since we need to use it when querying the card.
|
|
*
|
|
* Rev 1.1 07 Feb 1994 14:14:12 RWOLFF
|
|
* Added alloc_text() pragmas to allow miniport to be swapped out when
|
|
* not needed.
|
|
*
|
|
* Rev 1.0 31 Jan 1994 11:20:42 RWOLFF
|
|
* Initial revision.
|
|
*
|
|
* Rev 1.1 30 Nov 1993 18:30:06 RWOLFF
|
|
* Fixed calculation of offset for memory mapped address ranges.
|
|
*
|
|
* Rev 1.0 05 Nov 1993 13:36:14 RWOLFF
|
|
* Initial revision.
|
|
|
|
End of PolyTron RCS section *****************/
|
|
|
|
#ifdef DOC
|
|
SETUP_CX.C - Setup routines for 68800CX accelerators.
|
|
|
|
DESCRIPTION
|
|
This file contains routines which provide services specific to
|
|
the 68800CX-compatible family of ATI accelerators.
|
|
|
|
OTHER FILES
|
|
|
|
#endif
|
|
|
|
#include "dderror.h"
|
|
|
|
#include "miniport.h"
|
|
#include "ntddvdeo.h"
|
|
#include "video.h"
|
|
|
|
#include "stdtyp.h"
|
|
#include "amachcx.h"
|
|
#include "amach1.h"
|
|
#include "atimp.h"
|
|
|
|
#include "query_cx.h"
|
|
#include "services.h"
|
|
#define INCLUDE_SETUP_CX
|
|
#include "setup_cx.h"
|
|
|
|
|
|
static ULONG FindNextBlockATICard(void);
|
|
|
|
/*
|
|
* Allow miniport to be swapped out when not needed.
|
|
*/
|
|
#if defined (ALLOC_PRAGMA)
|
|
#pragma alloc_text(PAGE_CX, CompatIORangesUsable_cx)
|
|
#pragma alloc_text(PAGE_CX, CompatMMRangesUsable_cx)
|
|
#pragma alloc_text(PAGE_CX, WaitForIdle_cx)
|
|
#pragma alloc_text(PAGE_CX, CheckFIFOSpace_cx)
|
|
#pragma alloc_text(PAGE_CX, IsApertureConflict_cx)
|
|
#pragma alloc_text(PAGE_CX, GetIOBase_cx)
|
|
#pragma alloc_text(PAGE_CX, IsPackedIO_cx)
|
|
#pragma alloc_text(PAGE_CX, FindNextBlockATICard)
|
|
#endif
|
|
|
|
|
|
|
|
UCHAR LookForAnotherCard = 1;
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* VP_STATUS CompatIORangesUsable_cx(void);
|
|
*
|
|
* DESCRIPTION:
|
|
* Ask Windows NT for permission to use the I/O space address ranges
|
|
* needed by the 68800CX accelerator.
|
|
*
|
|
* RETURN VALUE:
|
|
* NO_ERROR if successful
|
|
* error code if unable to gain access to the ranges we need.
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* none
|
|
*
|
|
* CALLED BY:
|
|
* ATIMPFindAdapter()
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
VP_STATUS CompatIORangesUsable_cx(INTERFACE_TYPE SystemBus)
|
|
{
|
|
VP_STATUS Status; /* Value returned by operating system calls */
|
|
short Count; /* Loop counter */
|
|
VIDEO_ACCESS_RANGE SaveFirstMM; /* Place to save the first memory mapped registers */
|
|
USHORT BaseIndex; /* Index into register base array */
|
|
USHORT VariableIndex; /* Index into array of variable part of register array */
|
|
ULONG BaseAddress; /* I/O base address for relocatable I/O */
|
|
ULONG ClaimSize; /* Size of VGA aperture/BIOS block to claim */
|
|
ULONG InitialClaimSize; /* Initial size of the BIOS block to claim */
|
|
BOOL FoundSafeClaim = FALSE; /* Have we found a BIOS block we can claim safely? */
|
|
|
|
|
|
/*
|
|
* Check to see if someone has added or deleted I/O ranges without
|
|
* changing the defined value. I/O registers start at index 0.
|
|
*
|
|
* All the I/O mapped registers are before the first register which
|
|
* exists only in memory-mapped form.
|
|
*/
|
|
if ((DriverIORange_cx[NUM_IO_REGISTERS-1].RangeStart.HighPart == DONT_USE) ||
|
|
(DriverIORange_cx[NUM_IO_REGISTERS].RangeStart.HighPart != DONT_USE))
|
|
{
|
|
VideoDebugPrint((DEBUG_ERROR, "Wrong defined value for number of I/O ranges\n"));
|
|
return ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
/*
|
|
* Clear the list of mapped I/O addresses so we can identify
|
|
* which ones have been mapped in order to unmap them if
|
|
* there is a failure partway through the mapping.
|
|
*/
|
|
for (Count = 0; Count < NUM_IO_REGISTERS; Count++)
|
|
{
|
|
phwDeviceExtension->aVideoAddressIO[Count] = 0;
|
|
}
|
|
|
|
/*
|
|
* Run through the list of base addresses, trying each
|
|
* until we find the one that the Mach 64 is using.
|
|
*/
|
|
for (BaseIndex = 0; BaseIndex < NUM_BASE_ADDRESSES; BaseIndex++)
|
|
{
|
|
/*
|
|
* Possible problem area: if this is the first bus to be
|
|
* tested which contains a fixed-base Mach 64, but a previous
|
|
* bus had at least one block-relocatable card without
|
|
* having the maximum number we support (which would have
|
|
* been caught in ATIMPFindAdapter()), we don't want to
|
|
* look for fixed-base cards. This is because we don't
|
|
* support a mixture of fixed-base and block-relocatable
|
|
* cards.
|
|
*/
|
|
if (NumBlockCardsFound != 0)
|
|
{
|
|
VideoDebugPrint((DEBUG_NORMAL, "Skipping fixed base because block cards found\n"));
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Build up the accelerator registers using the current
|
|
* base address.
|
|
*/
|
|
for (VariableIndex = 0; VariableIndex < NUM_REGS_TO_BUILD; VariableIndex++)
|
|
{
|
|
DriverIORange_cx[VariableIndex+FIRST_REG_TO_BUILD].RangeStart.LowPart =
|
|
VariableRegisterBases[BaseIndex] + VariableRegisterOffsets[VariableIndex];
|
|
}
|
|
|
|
/*
|
|
* If we encounter a conflict claiming the full 64k of the BIOS
|
|
* area, it will generate two messages in the event log even
|
|
* though this is not a fatal error. To avoid this, we must
|
|
* store claim restrictions in the registry, and on subsequent
|
|
* boots start claiming where we were successful last time.
|
|
*
|
|
* If we can't read the registry entry, assume that we can
|
|
* claim the full 64k area starting at 0xC000:0000.
|
|
*
|
|
* Don't worry about a user upgrading to a Mach 64 with a 64k
|
|
* video BIOS and moving the SCSI card above 0xD000:0000, since
|
|
* our install script will clear this registry entry to its
|
|
* "claim 64k" value.
|
|
*/
|
|
if (VideoPortGetRegistryParameters(phwDeviceExtension,
|
|
L"BiosClaimSize",
|
|
FALSE,
|
|
RegistryParameterCallback,
|
|
NULL) == NO_ERROR)
|
|
{
|
|
InitialClaimSize = *RegistryBuffer;
|
|
VideoDebugPrint((DEBUG_DETAIL, "Read initial claim size 0x%X\n", VgaResourceSize[InitialClaimSize]));
|
|
}
|
|
else
|
|
{
|
|
InitialClaimSize = CLAIM_32k_BIOS;
|
|
VideoDebugPrint((DEBUG_DETAIL, "Using default initial claim size 0x%X\n", VgaResourceSize[InitialClaimSize]));
|
|
}
|
|
|
|
if ((InitialClaimSize < CLAIM_32k_BIOS) || (InitialClaimSize > CLAIM_APERTURE_ONLY) )
|
|
InitialClaimSize = CLAIM_32k_BIOS;
|
|
|
|
/*
|
|
* Claim as much as possible of our BIOS area. If we fail to
|
|
* claim the full 64k, try restricting ourselves to 32k and
|
|
* finally no BIOS area, only giving up on the current I/O
|
|
* base address if we can't claim our access ranges even with
|
|
* no BIOS area.
|
|
*/
|
|
for (ClaimSize = InitialClaimSize; ClaimSize <= CLAIM_APERTURE_ONLY; ClaimSize++)
|
|
{
|
|
/*
|
|
* Set up our VGA resource claim size.
|
|
*/
|
|
DriverApertureRange_cx[0].RangeLength = VgaResourceSize[ClaimSize];
|
|
|
|
/*
|
|
* Check to see if there is a hardware resource conflict. We must save
|
|
* the information for the first memory mapped register, copy in
|
|
* the information for the VGA aperture (which we always need),
|
|
* and restore the memory mapped register information after
|
|
* we have verified that we can use the required address ranges.
|
|
*/
|
|
VideoPortMoveMemory(&SaveFirstMM, DriverIORange_cx+VGA_APERTURE_ENTRY, sizeof(VIDEO_ACCESS_RANGE));
|
|
VideoPortMoveMemory(DriverIORange_cx+VGA_APERTURE_ENTRY, DriverApertureRange_cx, sizeof(VIDEO_ACCESS_RANGE));
|
|
|
|
Status = VideoPortVerifyAccessRanges(phwDeviceExtension,
|
|
NUM_IO_REGISTERS + 1,
|
|
DriverIORange_cx);
|
|
|
|
VideoPortMoveMemory(DriverIORange_cx+VGA_APERTURE_ENTRY, &SaveFirstMM, sizeof(VIDEO_ACCESS_RANGE));
|
|
|
|
/*
|
|
* If there is a hardware resource conflict, we can't use this
|
|
* base address and BIOS region size, so try the next. If there
|
|
* is no conflict, use the current size.
|
|
*
|
|
* If the size of the BIOS block we were able to claim
|
|
* differs from our initial attempt, record the "maximum
|
|
* possible BIOS block size" in the registry so that on
|
|
* subsequent boots we won't generate event log entries
|
|
* by claiming a BIOS region that conflicts with another
|
|
* card.
|
|
*/
|
|
if (Status != NO_ERROR)
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Rejecting VGA aperture/BIOS block size of 0x%X bytes\n", VgaResourceSize[ClaimSize]));
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "VGA aperture/BIOS block size = 0x%X bytes\n", VgaResourceSize[ClaimSize]));
|
|
if (FoundSafeClaim == FALSE)
|
|
{
|
|
FoundSafeClaim = TRUE;
|
|
if (ClaimSize != InitialClaimSize)
|
|
{
|
|
//ClaimSize = 1;
|
|
VideoDebugPrint((DEBUG_DETAIL, "Writing claim size 0x%X\n", VgaResourceSize[ClaimSize]));
|
|
VideoPortSetRegistryParameters(phwDeviceExtension,
|
|
L"BiosClaimSize",
|
|
&ClaimSize,
|
|
sizeof(ULONG));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
} /* end for (decreasing claim size) */
|
|
|
|
/*
|
|
* If we fell out of the above loop, rather than breaking out,
|
|
* go on to the next I/O base address, since we have run into
|
|
* a hardware resource conflict.
|
|
*/
|
|
if ((Status != NO_ERROR) && (ClaimSize > CLAIM_APERTURE_ONLY))
|
|
continue;
|
|
|
|
/*
|
|
* Map the video controller address ranges we need to identify
|
|
* our cards into the system virtual address space. If a register
|
|
* only exists in memory-mapped form, set its I/O mapped address
|
|
* to zero (won't be used because memory-mapped takes precedence
|
|
* over I/O mapped).
|
|
*
|
|
* Initialize the mapped addresses for memory mapped registers
|
|
* to 0 (flag to show the registers are not memory mapped) in
|
|
* case they were initialized to a nonzero value.
|
|
*/
|
|
for (Count=0; Count < NUM_DRIVER_ACCESS_RANGES; Count++)
|
|
{
|
|
if (Count < NUM_IO_REGISTERS)
|
|
{
|
|
if ((phwDeviceExtension->aVideoAddressIO[Count] =
|
|
VideoPortGetDeviceBase(phwDeviceExtension,
|
|
DriverIORange_cx[Count].RangeStart,
|
|
DriverIORange_cx[Count].RangeLength,
|
|
DriverIORange_cx[Count].RangeInIoSpace)) == NULL)
|
|
{
|
|
/*
|
|
* There was an error in mapping. Remember this
|
|
* so we don't try to find a Mach 64 without all
|
|
* the registers being mapped properly, then
|
|
* break out of the mapping loop. We will have
|
|
* another shot at mapping all the addresses
|
|
* when we try the next base address for the
|
|
* accelerator registers.
|
|
*/
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
VideoDebugPrint((DEBUG_ERROR, "Mapping error 1\n"));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
phwDeviceExtension->aVideoAddressIO[Count] = 0;
|
|
}
|
|
phwDeviceExtension->aVideoAddressMM[Count] = 0;
|
|
} /* End for */
|
|
|
|
/*
|
|
* If all I/O registers were successfully mapped, check to see
|
|
* if a Mach 64 is present at the current base address. If it
|
|
* is, report that we have successfully mapped our registers
|
|
* and found a Mach 64. Since this means we have found a
|
|
* card which is not block relocatable, we do not want to
|
|
* look for further cards. Also, since this is the only
|
|
* Mach 64 in the system, assume that its VGA is enabled.
|
|
*/
|
|
if (Status == NO_ERROR)
|
|
{
|
|
if (DetectMach64() == MACH64_ULTRA)
|
|
{
|
|
FoundNonBlockCard = TRUE;
|
|
LookForAnotherCard = 0;
|
|
phwDeviceExtension->BiosPrefix = BIOS_PREFIX_VGA_ENAB;
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We did not find a Mach 64 at this base address, so unmap
|
|
* the I/O mapped registers in preparation for trying the
|
|
* next base address. Only unmap those registers which were
|
|
* mapped, in case the mapping loop aborted due to a failure
|
|
* to map one register.
|
|
*/
|
|
for (Count = 1; Count < NUM_IO_REGISTERS; Count++)
|
|
{
|
|
if (phwDeviceExtension->aVideoAddressIO[Count] != 0)
|
|
{
|
|
VideoPortFreeDeviceBase(phwDeviceExtension,
|
|
phwDeviceExtension->aVideoAddressIO[Count]);
|
|
phwDeviceExtension->aVideoAddressIO[Count] = 0;
|
|
}
|
|
}
|
|
|
|
} /* End for (loop of base addresses) */
|
|
|
|
/*
|
|
* The video card in the machine isn't a Mach 64 that uses one of
|
|
* the standard I/O base addresses. Check if it's a Mach 64 with
|
|
* relocatable I/O.
|
|
*
|
|
* All our relocatable cards are PCI implementations. The code we
|
|
* use to detect them is PCI-specific, so if the bus we are currently
|
|
* dealing with is not PCI, don't look for relocatable cards.
|
|
*/
|
|
if (SystemBus != PCIBus)
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Not PCI bus - can't check for relocatable card\n"));
|
|
return ERROR_DEV_NOT_EXIST;
|
|
}
|
|
|
|
BaseAddress = FindNextBlockATICard();
|
|
|
|
/*
|
|
* BaseAddress will be zero if FindNextBlockATICard()
|
|
* couldn't find a block-relocatable ATI card.
|
|
*/
|
|
if (BaseAddress == 0)
|
|
{
|
|
LookForAnotherCard = 0;
|
|
VideoDebugPrint((DEBUG_NORMAL, "Finished checking for relocatable cards\n"));
|
|
return ERROR_DEV_NOT_EXIST;
|
|
}
|
|
|
|
/*
|
|
* We have found a block relocatable ATI card. Save its I/O base
|
|
* address so we can (during ATIMPInitialize()) match it up to
|
|
* the accelerator prefix for the card, and set the initial prefix
|
|
* to show that this card needs its I/O base and accelerator prefix
|
|
* matched.
|
|
*/
|
|
phwDeviceExtension->BaseIOAddress = BaseAddress;
|
|
phwDeviceExtension->BiosPrefix = BIOS_PREFIX_UNASSIGNED;
|
|
NumBlockCardsFound++;
|
|
VideoDebugPrint((DEBUG_NORMAL, "Block relocatable card found, I/O base 0x%X\n", BaseAddress));
|
|
|
|
|
|
/*
|
|
* We now have the I/O base address. Map in the I/O addresses,
|
|
* then check to see if we have a Mach 64 card. Depending on
|
|
* the results, either report success or unmap the addresses
|
|
* and report failure.
|
|
*/
|
|
VideoDebugPrint((DEBUG_DETAIL, "About to map I/O addresses\n"));
|
|
for (VariableIndex = 0; VariableIndex < NUM_REGS_TO_BUILD; VariableIndex++)
|
|
{
|
|
DriverIORange_cx[VariableIndex+FIRST_REG_TO_BUILD].RangeStart.LowPart =
|
|
BaseAddress + (RelocatableRegisterOffsets[VariableIndex] * 4);
|
|
}
|
|
|
|
/*
|
|
* Claim as much as possible of our BIOS area. If we fail to
|
|
* claim the full 64k, try restricting ourselves to 32k and
|
|
* finally no BIOS area, only giving up on the current I/O
|
|
* base address if we can't claim our access ranges even with
|
|
* no BIOS area.
|
|
*/
|
|
for (ClaimSize = InitialClaimSize; ClaimSize <= CLAIM_APERTURE_ONLY; ClaimSize++)
|
|
{
|
|
/*
|
|
* Set up our VGA resource claim size.
|
|
*/
|
|
DriverApertureRange_cx[0].RangeLength = VgaResourceSize[ClaimSize];
|
|
|
|
/*
|
|
* Check to see if there is a hardware resource conflict. We must save
|
|
* the information for the first memory mapped register, copy in
|
|
* the information for the VGA aperture (which we always need),
|
|
* and restore the memory mapped register information after
|
|
* we have verified that we can use the required address ranges.
|
|
*/
|
|
VideoPortMoveMemory(&SaveFirstMM, DriverIORange_cx+VGA_APERTURE_ENTRY, sizeof(VIDEO_ACCESS_RANGE));
|
|
VideoPortMoveMemory(DriverIORange_cx+VGA_APERTURE_ENTRY, DriverApertureRange_cx, sizeof(VIDEO_ACCESS_RANGE));
|
|
|
|
Status = VideoPortVerifyAccessRanges(phwDeviceExtension,
|
|
NUM_IO_REGISTERS + 1,
|
|
DriverIORange_cx);
|
|
|
|
VideoPortMoveMemory(DriverIORange_cx+VGA_APERTURE_ENTRY, &SaveFirstMM, sizeof(VIDEO_ACCESS_RANGE));
|
|
|
|
/*
|
|
* If there is a hardware resource conflict, we are either trying
|
|
* to claim a bigger BIOS block than we need, and someone else is
|
|
* sitting in (and claiming as nonshareable) the "slack", or we have
|
|
* a conflict over the I/O base address. Try the next smallest BIOS
|
|
* block.
|
|
*
|
|
* If the size of the BIOS block we were able to claim
|
|
* differs from our initial attempt, record the "maximum
|
|
* possible BIOS block size" in the registry so that on
|
|
* subsequent boots we won't generate event log entries
|
|
* by claiming a BIOS region that conflicts with another
|
|
* card.
|
|
*/
|
|
if (Status != NO_ERROR)
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Rejecting VGA aperture/BIOS block size of 0x%X bytes\n", VgaResourceSize[ClaimSize]));
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "VGA aperture/BIOS block size = 0x%X bytes\n", VgaResourceSize[ClaimSize]));
|
|
if (FoundSafeClaim == FALSE)
|
|
{
|
|
FoundSafeClaim = TRUE;
|
|
if (ClaimSize != InitialClaimSize)
|
|
{
|
|
//ClaimSize = 1;
|
|
VideoDebugPrint((DEBUG_DETAIL, "Writing claim size 0x%X\n", VgaResourceSize[ClaimSize]));
|
|
VideoPortSetRegistryParameters(phwDeviceExtension,
|
|
L"BiosClaimSize",
|
|
&ClaimSize,
|
|
sizeof(ULONG));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
} /* end for (decreasing claim size) */
|
|
|
|
/*
|
|
* If there is a conflict over the I/O base address, we can't use
|
|
* it. Since this is our last chance to find a Mach 64, report failure.
|
|
*/
|
|
if (Status != NO_ERROR)
|
|
{
|
|
VideoDebugPrint((DEBUG_ERROR, "VideoPortVerifyAccessRanges() failed in check for relocatable Mach 64\n"));
|
|
return ERROR_DEV_NOT_EXIST;
|
|
}
|
|
|
|
/*
|
|
* Map the video controller address ranges we need to identify
|
|
* our cards into the system virtual address space. If a register
|
|
* only exists in memory-mapped form, set its I/O mapped address
|
|
* to zero (won't be used because memory-mapped takes precedence
|
|
* over I/O mapped).
|
|
*
|
|
* Initialize the mapped addresses for memory mapped registers
|
|
* to 0 (flag to show the registers are not memory mapped) in
|
|
* case they were initialized to a nonzero value.
|
|
*/
|
|
for (Count=0; Count < NUM_DRIVER_ACCESS_RANGES; Count++)
|
|
{
|
|
if (Count < NUM_IO_REGISTERS)
|
|
{
|
|
if ((phwDeviceExtension->aVideoAddressIO[Count] =
|
|
VideoPortGetDeviceBase(phwDeviceExtension,
|
|
DriverIORange_cx[Count].RangeStart,
|
|
DriverIORange_cx[Count].RangeLength,
|
|
DriverIORange_cx[Count].RangeInIoSpace)) == NULL)
|
|
{
|
|
/*
|
|
* There was an error in mapping. Remember this
|
|
* so we don't try to find a Mach 64 without all
|
|
* the registers being mapped properly, then
|
|
* break out of the mapping loop.
|
|
*/
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
VideoDebugPrint((DEBUG_ERROR, "Mapping error 2\n"));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
phwDeviceExtension->aVideoAddressIO[Count] = 0;
|
|
}
|
|
phwDeviceExtension->aVideoAddressMM[Count] = 0;
|
|
} /* End for */
|
|
|
|
/*
|
|
* If all I/O registers were successfully mapped, check to see
|
|
* if a Mach 64 is present at the current base address. If it
|
|
* is, report that we have successfully mapped our registers
|
|
* and found a Mach 64.
|
|
*/
|
|
if (Status == NO_ERROR)
|
|
{
|
|
if (DetectMach64() == MACH64_ULTRA)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We did not find a Mach 64 at this base address, so clean
|
|
* up after ourselves by unmapping the I/O mapped registers
|
|
* before reporting failure. Only unmap those registers which
|
|
* were mapped, in case the mapping loop aborted due to a
|
|
* failure to map one register.
|
|
*/
|
|
for (Count = 1; Count < NUM_IO_REGISTERS; Count++)
|
|
{
|
|
if (phwDeviceExtension->aVideoAddressIO[Count] != 0)
|
|
{
|
|
VideoPortFreeDeviceBase(phwDeviceExtension,
|
|
phwDeviceExtension->aVideoAddressIO[Count]);
|
|
phwDeviceExtension->aVideoAddressIO[Count] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* We haven't found a Mach 64 at any of the allowable base addresses,
|
|
* so report that there is no Mach 64 in the machine.
|
|
*/
|
|
VideoDebugPrint((DEBUG_NORMAL, "No Mach 64 found at this address\n"));
|
|
return ERROR_DEV_NOT_EXIST;
|
|
|
|
} /* CompatIORangesUsable_cx() */
|
|
|
|
/***************************************************************************
|
|
*
|
|
* VP_STATUS CompatMMRangesUsable_cx(void);
|
|
*
|
|
* DESCRIPTION:
|
|
* Ask Windows NT for permission to use the memory mapped registers
|
|
* needed by the 68800CX accelerator.
|
|
*
|
|
* RETURN VALUE:
|
|
* NO_ERROR if successful
|
|
* error code if unable to gain access to the ranges we need.
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* none
|
|
*
|
|
* CALLED BY:
|
|
* ATIMPFindAdapter()
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
VP_STATUS CompatMMRangesUsable_cx(void)
|
|
{
|
|
PHYSICAL_ADDRESS MMrange; /* Used in translating offset to memory address */
|
|
ULONG RegisterOffset; /* Offset of memory mapped registers start of address space */
|
|
int Count; /* Loop counter */
|
|
struct query_structure *QueryPtr; /* Query information for the card */
|
|
UCHAR InIOSpace;
|
|
#if defined (ALPHA)
|
|
ULONG Scratch;
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Get a formatted pointer into the query section of HwDeviceExtension.
|
|
* The CardInfo[] field is an unformatted buffer.
|
|
*/
|
|
QueryPtr = (struct query_structure *) (phwDeviceExtension->CardInfo);
|
|
|
|
/*
|
|
* Set the offset of the memory mapped registers from the start of
|
|
* the aperture to the appropriate value for the aperture size
|
|
* being used.
|
|
*/
|
|
if ((QueryPtr->q_aperture_cfg & BIOS_AP_SIZEMASK) == BIOS_AP_8M)
|
|
RegisterOffset = phwDeviceExtension->PhysicalFrameAddress.LowPart + OFFSET_8M;
|
|
else if ((QueryPtr->q_aperture_cfg & BIOS_AP_SIZEMASK) == BIOS_AP_4M)
|
|
RegisterOffset = phwDeviceExtension->PhysicalFrameAddress.LowPart + OFFSET_4M;
|
|
else
|
|
RegisterOffset = OFFSET_VGA;
|
|
|
|
/*
|
|
* We are working in a 32 bit address space, so the upper DWORD
|
|
* of the quad word address is always zero.
|
|
*/
|
|
MMrange.HighPart = 0;
|
|
|
|
#if defined (ALPHA)
|
|
/*
|
|
* All Alpha systems are capable of supporting sparse space
|
|
* (normal memory mapped space for the Alpha). Newer systems
|
|
* (those that have PCI buses) are also able to support dense
|
|
* space, but older systems can't. In almost all cases, non-PCI
|
|
* cards are a sign that we are using an older system, but
|
|
* assuming this is an older system when it is actually an ISA
|
|
* card in a newer system is mostly harmless (slight performance
|
|
* penalty). Assuming that dense space is available on all Alpha
|
|
* systems will crash a Jensen (older system).
|
|
*/
|
|
if (QueryPtr->q_bus_type == BUS_PCI)
|
|
InIOSpace = 4; // DENSE Space
|
|
else
|
|
InIOSpace = 0;
|
|
|
|
/*
|
|
* The GX-F ASIC has a bug where burst reads of a quadword of
|
|
* memory will result in the high doubleword being corrupted.
|
|
* The memory-mapped form of CONFIG_CHIP_ID is the high doubleword,
|
|
* and on the Alpha in dense space (on PCI cards we always use
|
|
* dense space for our memory-mapped registers) all read access
|
|
* to memory is by quadwords, so we will run into the burst mode
|
|
* problem. The I/O mapped form of this register is safe to use.
|
|
*/
|
|
Scratch = INPD(CONFIG_CHIP_ID);
|
|
if (((Scratch & CONFIG_CHIP_ID_TypeMask) == CONFIG_CHIP_ID_TypeGX) &&
|
|
((Scratch & CONFIG_CHIP_ID_RevMask) == CONFIG_CHIP_ID_RevF))
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "GX-F detected, must use I/O mapped form of CRTC_OFF_PITCH\n"));
|
|
DriverMMRange_cx[CRTC_OFF_PITCH].RangeStart.HighPart = DONT_USE;
|
|
}
|
|
#else
|
|
InIOSpace = 0; // memory mapped I/O Space
|
|
#endif
|
|
|
|
for (Count=1; Count < NUM_DRIVER_ACCESS_RANGES; Count++)
|
|
{
|
|
/*
|
|
* In a 32-bit address space, the high doubleword of all
|
|
* physical addresses is zero. Setting this value to DONT_USE
|
|
* indicates that this accelerator register isn't memory mapped.
|
|
*/
|
|
if (DriverMMRange_cx[Count].RangeStart.HighPart != DONT_USE)
|
|
{
|
|
/*
|
|
* DriverMMRange_cx[Count].RangeStart.LowPart is the offset
|
|
* (in doublewords) of the memory mapped register from the
|
|
* beginning of the block of memory mapped registers. We must
|
|
* convert this to bytes, add the offset of the start of the
|
|
* memory mapped register area from the start of the aperture
|
|
* and the physical address of the start of the linear
|
|
* framebuffer to get the physical address of this
|
|
* memory mapped register.
|
|
*/
|
|
MMrange.LowPart = (DriverMMRange_cx[Count].RangeStart.LowPart * 4) + RegisterOffset;
|
|
phwDeviceExtension->aVideoAddressMM[Count] =
|
|
VideoPortGetDeviceBase(phwDeviceExtension,
|
|
MMrange,
|
|
DriverMMRange_cx[Count].RangeLength,
|
|
InIOSpace); // not in IO space
|
|
|
|
/*
|
|
* If we were unable to claim the memory-mapped version of
|
|
* this register, and it exists only in memory-mapped form,
|
|
* then we have a register which we can't access. Report
|
|
* this as an error condition.
|
|
*/
|
|
if ((phwDeviceExtension->aVideoAddressMM[Count] == 0) &&
|
|
(DriverIORange_cx[Count].RangeStart.HighPart == DONT_USE))
|
|
{
|
|
VideoDebugPrint((DEBUG_ERROR, "Mapping error 3\n"));
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
}
|
|
|
|
VideoDebugPrint((DEBUG_DETAIL, "CompatMMRangesUsable_cx() succeeded\n"));
|
|
return NO_ERROR;
|
|
|
|
} /* CompatMMRangesUsable_cx() */
|
|
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* int WaitForIdle_cx(void);
|
|
*
|
|
* DESCRIPTION:
|
|
* Poll GUI_STAT waiting for GuiActive field to go low. If it does not go
|
|
* low within 3 seconds (arbitrary value, but no operation should take
|
|
* that long), time out.
|
|
*
|
|
* RETURN VALUE:
|
|
* FALSE if timeout
|
|
* TRUE if engine is idle
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* none
|
|
*
|
|
* CALLED BY:
|
|
* Any 68800CX-specific routine may call this routine.
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
int WaitForIdle_cx(void)
|
|
{
|
|
int i;
|
|
ULONG Scratch;
|
|
|
|
for (i=0; i<300; i++)
|
|
{
|
|
if ((INPD(GUI_STAT) & GUI_STAT_GuiActive) == 0)
|
|
return TRUE;
|
|
|
|
/*
|
|
* Wait 1/100th of a second
|
|
*/
|
|
delay(10);
|
|
}
|
|
|
|
/*
|
|
* Something has happened, so reset the engine and return FALSE.
|
|
*/
|
|
VideoDebugPrint((DEBUG_ERROR, "ATI: Timeout on WaitForIdle_cx()\n"));
|
|
Scratch = INPD(GEN_TEST_CNTL) & ~GEN_TEST_CNTL_GuiEna;
|
|
OUTPD(GEN_TEST_CNTL, Scratch);
|
|
Scratch |= GEN_TEST_CNTL_GuiEna;
|
|
OUTPD(GEN_TEST_CNTL, Scratch);
|
|
return FALSE;
|
|
|
|
} /* WaitForIdle_cx() */
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* void CheckFIFOSpace_cx(SpaceNeeded);
|
|
*
|
|
* WORD SpaceNeeded; Number of free FIFO entries needed
|
|
*
|
|
* DESCRIPTION:
|
|
* Wait until the specified number of FIFO entries are free
|
|
* on a 68800CX-compatible ATI accelerator.
|
|
*
|
|
* If the specified number of entries does not become free in
|
|
* 3 seconds (arbitrary value greater than any operation should
|
|
* take), assume the engine has locked and reset it.
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* none
|
|
*
|
|
* CALLED BY:
|
|
* Any 68800CX-specific routine may call this routine.
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
void CheckFIFOSpace_cx(WORD SpaceNeeded)
|
|
{
|
|
ULONG LoopCount;
|
|
ULONG Scratch;
|
|
|
|
for (LoopCount = 0; LoopCount < 300; LoopCount++)
|
|
{
|
|
/*
|
|
* Return from test if enough entries are free
|
|
*/
|
|
if (!(INPD(FIFO_STAT)&SpaceNeeded))
|
|
return;
|
|
|
|
/*
|
|
* Wait 1/100th of a second
|
|
*/
|
|
delay(10);
|
|
}
|
|
|
|
/*
|
|
* Something has happened, so reset the engine and return FALSE.
|
|
*/
|
|
VideoDebugPrint((DEBUG_ERROR, "ATI: Timeout on CheckFIFOSpace_cx()\n"));
|
|
Scratch = INPD(GEN_TEST_CNTL) & ~GEN_TEST_CNTL_GuiEna;
|
|
OUTPD(GEN_TEST_CNTL, Scratch);
|
|
Scratch |= GEN_TEST_CNTL_GuiEna;
|
|
OUTPD(GEN_TEST_CNTL, Scratch);
|
|
return;
|
|
|
|
} /* CheckFIFOSpace_cx() */
|
|
|
|
|
|
|
|
/*
|
|
* BOOL IsApertureConflict_cx(QueryPtr);
|
|
*
|
|
* struct query_structure *QueryPtr; Pointer to query structure
|
|
*
|
|
* Check to see if the linear aperture conflicts with other memory.
|
|
* If a conflict exists, disable the linear aperture.
|
|
*
|
|
* Returns:
|
|
* TRUE if a conflict exists (aperture unusable)
|
|
* FALSE if the aperture is usable.
|
|
*/
|
|
BOOL IsApertureConflict_cx(struct query_structure *QueryPtr)
|
|
{
|
|
DWORD Scratch; /* Used in manipulating registers */
|
|
VP_STATUS Status; /* Return value from VideoPortVerifyAccessRanges() */
|
|
VIDEO_X86_BIOS_ARGUMENTS Registers; /* Used in VideoPortInt10() calls */
|
|
VIDEO_ACCESS_RANGE SaveFirstMM[2]; /* Place to save the first two memory mapped registers */
|
|
USHORT VariableIndex; /* Index into array of variable part of register array */
|
|
|
|
/*
|
|
* Set up by disabling the memory boundary (must be disabled in order
|
|
* to access accelerator memory through the VGA aperture).
|
|
*/
|
|
Scratch = INPD(MEM_CNTL);
|
|
Scratch &= ~MEM_CNTL_MemBndryEn;
|
|
OUTPD(MEM_CNTL, Scratch);
|
|
|
|
/*
|
|
* If there is an aperture conflict, a call to
|
|
* VideoPortVerifyAccessRanges() including our linear framebuffer in
|
|
* the range list will return an error. If there is no conflict, it
|
|
* will return success.
|
|
*
|
|
* We must save the contents of the first 2 memory mapped register
|
|
* entries, copy in the aperture ranges (VGA and linear) we need
|
|
* to claim, then restore the memory mapped entries after we
|
|
* have verified that we can use the aperture(s).
|
|
*
|
|
* DriverIORange_cx[] contains the physical addresses of the registers
|
|
* for the last card we have dealt with. In a single-card setup, this
|
|
* is no problem, but in a multi-card setup we must re-load this
|
|
* array with the physical addresses of the card we want to claim
|
|
* the aperture for.
|
|
*/
|
|
if (NumBlockCardsFound > 1)
|
|
{
|
|
for (VariableIndex = 0; VariableIndex < NUM_REGS_TO_BUILD; VariableIndex++)
|
|
{
|
|
DriverIORange_cx[VariableIndex+FIRST_REG_TO_BUILD].RangeStart.LowPart =
|
|
phwDeviceExtension->BaseIOAddress + (RelocatableRegisterOffsets[VariableIndex] * 4);
|
|
}
|
|
}
|
|
DriverApertureRange_cx[LFB_ENTRY].RangeStart.LowPart = QueryPtr->q_aperture_addr*ONE_MEG;
|
|
if ((QueryPtr->q_aperture_cfg & BIOS_AP_SIZEMASK) == BIOS_AP_8M)
|
|
DriverApertureRange_cx[LFB_ENTRY].RangeLength = 8*ONE_MEG;
|
|
else
|
|
DriverApertureRange_cx[LFB_ENTRY].RangeLength = 4*ONE_MEG;
|
|
|
|
VideoPortMoveMemory(SaveFirstMM, DriverIORange_cx+VGA_APERTURE_ENTRY, 2*sizeof(VIDEO_ACCESS_RANGE));
|
|
VideoPortMoveMemory(DriverIORange_cx+VGA_APERTURE_ENTRY, DriverApertureRange_cx, 2*sizeof(VIDEO_ACCESS_RANGE));
|
|
|
|
Status = VideoPortVerifyAccessRanges(phwDeviceExtension,
|
|
NUM_IO_REGISTERS+2,
|
|
DriverIORange_cx);
|
|
if (Status != NO_ERROR)
|
|
{
|
|
/*
|
|
* If there is an aperture conflict, reclaim our I/O ranges without
|
|
* asking for the LFB. This call should not fail, since we would not
|
|
* have reached this point if there were a conflict.
|
|
*/
|
|
Status = VideoPortVerifyAccessRanges(phwDeviceExtension,
|
|
NUM_IO_REGISTERS+1,
|
|
DriverIORange_cx);
|
|
if (Status != NO_ERROR)
|
|
VideoDebugPrint((DEBUG_ERROR, "ERROR: Can't reclaim I/O ranges\n"));
|
|
|
|
VideoPortMoveMemory(DriverIORange_cx+VGA_APERTURE_ENTRY, SaveFirstMM, 2*sizeof(VIDEO_ACCESS_RANGE));
|
|
ISAPitchAdjust(QueryPtr);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
VideoPortMoveMemory(DriverIORange_cx+VGA_APERTURE_ENTRY, SaveFirstMM, 2*sizeof(VIDEO_ACCESS_RANGE));
|
|
|
|
/*
|
|
* There is no aperture conflict, so enable the linear aperture.
|
|
*/
|
|
VideoPortZeroMemory(&Registers, sizeof(VIDEO_X86_BIOS_ARGUMENTS));
|
|
Registers.Eax = BIOS_APERTURE;
|
|
Registers.Ecx = BIOS_LINEAR_APERTURE;
|
|
VideoPortInt10(phwDeviceExtension, &Registers);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
} /* IsApertureConflict_cx() */
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* USHORT GetIOBase_cx(void);
|
|
*
|
|
* DESCRIPTION:
|
|
* Get the I/O base address being used by this card.
|
|
*
|
|
* RETURN VALUE:
|
|
* I/O base register
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* none
|
|
*
|
|
* CALLED BY:
|
|
* Any 68800CX-specific routine may call this routine after
|
|
* CompatIORangesUsable_cx() has returned success. Results
|
|
* are undefined if this routine is called either before
|
|
* CompatIORangesUsable_cx() is called, or after it retunrs
|
|
* failure.
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
USHORT GetIOBase_cx(void)
|
|
{
|
|
|
|
/*
|
|
* CRTC_H_TOTAL_DISP is at offset 0 from the base address.
|
|
* In a single-card setup, after CompatIORangesUsable_cx()
|
|
* returns, the value in
|
|
* DriverIORange_cx[CRTC_H_TOTAL_DISP].RangeStart.LowPart
|
|
* will be either the I/O base address in use (returned
|
|
* success) or the last I/O base address tried (returned
|
|
* failure).
|
|
*
|
|
* In a multi-card setup, this value will hold the I/O base
|
|
* for the last card which was set up, but the I/O base for
|
|
* each card is stored in its hardware device extension
|
|
* structure. This second storage location is not guaranteed
|
|
* for single-card setups, so use the DriverIORange location
|
|
* for them.
|
|
*/
|
|
if (NumBlockCardsFound > 1)
|
|
return (USHORT)(phwDeviceExtension->BaseIOAddress);
|
|
else
|
|
return (USHORT)(DriverIORange_cx[CRTC_H_TOTAL_DISP].RangeStart.LowPart);
|
|
|
|
} /* GetIOBase_cx() */
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* BOOL IsPackedIO_cx(void);
|
|
*
|
|
* DESCRIPTION:
|
|
* Report whether or not we are using packed (relocatable) I/O.
|
|
*
|
|
* RETURN VALUE:
|
|
* TRUE if using packed I/O
|
|
* FALSE if using sparse I/O
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* none
|
|
*
|
|
* CALLED BY:
|
|
* Any 68800CX-specific routine may call this routine after
|
|
* CompatIORangesUsable_cx() has returned success. Results
|
|
* are undefined if this routine is called either before
|
|
* CompatIORangesUsable_cx() is called, or after it retunrs
|
|
* failure.
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
BOOL IsPackedIO_cx(void)
|
|
{
|
|
|
|
/*
|
|
* CRTC_H_TOTAL_DISP and CRTC_H_SYNC_STRT_WID are the registers
|
|
* with the lowest I/O addresses (CRTC_H_TOTAL_DISP is at
|
|
* offset 0 from the base address). If we are using packed I/O,
|
|
* the DriverIORange_cx[].RangeStart.LowPart entries for these
|
|
* two registers will differ by 4 bytes, while if we are using
|
|
* normal (sparse) I/O, they will differ by 0x400 bytes.
|
|
*/
|
|
if (DriverIORange_cx[CRTC_H_SYNC_STRT_WID].RangeStart.LowPart -
|
|
DriverIORange_cx[CRTC_H_TOTAL_DISP].RangeStart.LowPart == 4)
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Reporting dense I/O\n"));
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Reporting sparse I/O\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
} /* IsPackedIO_cx() */
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* ULONG FindNextBlockATICard(void);
|
|
*
|
|
* DESCRIPTION:
|
|
* Find the next Mach 64 which uses block relocatable I/O.
|
|
*
|
|
* RETURN VALUE:
|
|
* I/O base address if card is found
|
|
* 0 if no card is found
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* none
|
|
*
|
|
* CALLED BY:
|
|
* CompatIORangesUsable_cx()
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
static ULONG FindNextBlockATICard(void)
|
|
{
|
|
PCI_COMMON_CONFIG ConfigData; /* Configuration information about PCI device */
|
|
PCI_SLOT_NUMBER SlotNumber; /* PCI slot under test */
|
|
static ULONG DeviceNumber=0; /* PCI device number */
|
|
static ULONG FunctionNumber=0; /* PCI function number */
|
|
ULONG BaseAddress=0; /* I/O base address */
|
|
ULONG RetVal; /* Value returned by function calls */
|
|
|
|
/*
|
|
* The PCI_SLOT_NUMBER union allows 32 slot numbers with 8
|
|
* function numbers each. The upper 24 bits are reserved.
|
|
*/
|
|
while (DeviceNumber < 32)
|
|
{
|
|
while (FunctionNumber < 8)
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Checking device 0x%X function 0x%X\n", DeviceNumber, FunctionNumber));
|
|
SlotNumber.u.bits.DeviceNumber = DeviceNumber;
|
|
SlotNumber.u.bits.FunctionNumber = FunctionNumber;
|
|
SlotNumber.u.bits.Reserved = 0;
|
|
ConfigData.VendorID = PCI_INVALID_VENDORID;
|
|
|
|
RetVal = VideoPortGetBusData(phwDeviceExtension,
|
|
PCIConfiguration,
|
|
SlotNumber.u.AsULONG,
|
|
&ConfigData,
|
|
0,
|
|
PCI_COMMON_HDR_LENGTH);
|
|
FunctionNumber++;
|
|
|
|
/*
|
|
* If we received an error return, skip to the
|
|
* next possible slot.
|
|
*/
|
|
if (RetVal != PCI_COMMON_HDR_LENGTH)
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Error return 0x%X, skipping to next slot\n", RetVal));
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* If this is not an ATI card, we are not interested.
|
|
* Instead, go on to the next candidate.
|
|
*/
|
|
VideoDebugPrint((DEBUG_DETAIL, "Vendor ID = 0x%X\n", ConfigData.VendorID));
|
|
if (ConfigData.VendorID != 0x1002)
|
|
continue;
|
|
|
|
/*
|
|
* We have found an ATI card. On all our block-relocatable
|
|
* cards, we must mask off the lowest order bit of the
|
|
* reported address, since this is always reported as 1
|
|
* (I/O space), but its actual value is always 0.
|
|
*
|
|
* Not all ATI PCI cards are block-relocatable Mach 64
|
|
* cards. Since we only look for block-relocatable cards
|
|
* if we have failed to find a fixed-base Mach 64, we can
|
|
* safely assume that any Mach 64 we find is block-relocatable.
|
|
*
|
|
* Despite this assumption, we must still distinguish Mach 64
|
|
* cards from non-Mach 64 cards, either by recognizing and
|
|
* accepting all Mach 64 device IDs and rejecting other
|
|
* device IDs, or by recognizing and rejecting all non-Mach 64
|
|
* device IDs and accepting other device IDs. The latter
|
|
* route is safer, since new device IDs are more likely
|
|
* to be Mach 64 than non-Mach 64, and this route will
|
|
* not falsely reject new Mach 64 cards. Currently, our
|
|
* only non-Mach 64 PCI card is the Mach 32 AX.
|
|
*
|
|
* Resetting BaseAddress to zero for non-Mach 64 cards
|
|
* will result in the same treatment as for non-ATI
|
|
* cards, i.e. we will treat the current slot as not
|
|
* containing a block-relocatable Mach 64, and search
|
|
* the next slot.
|
|
*/
|
|
BaseAddress = (ConfigData.u.type0.BaseAddresses[PCI_ADDRESS_IO_SPACE]) & 0xFFFFFFFE;
|
|
VideoDebugPrint((DEBUG_NORMAL, "Found card with device ID 0x%X\n", ConfigData.DeviceID));
|
|
switch (ConfigData.DeviceID)
|
|
{
|
|
case ATI_DEVID_M32AX:
|
|
VideoDebugPrint((DEBUG_NORMAL, "Mach 32 AX card found, skipping it\n"));
|
|
BaseAddress = 0;
|
|
break;
|
|
|
|
// GT, exclude GTBs
|
|
case 0x4754:
|
|
|
|
if ((ConfigData.RevisionID == 0x9A) ||
|
|
(ConfigData.RevisionID == 0x5A) ||
|
|
(ConfigData.RevisionID == 0x1A) ||
|
|
(ConfigData.RevisionID == 0x19) ||
|
|
(ConfigData.RevisionID == 0x41) ||
|
|
(ConfigData.RevisionID == 0x01))
|
|
{
|
|
VideoDebugPrint((DEBUG_NORMAL, "Rejecting GT card with revision ID 0x%X, treating as Mach 64\n", ConfigData.RevisionID));
|
|
BaseAddress = 0;
|
|
continue;
|
|
}
|
|
|
|
VideoDebugPrint((DEBUG_NORMAL, "Found ATI card with device ID 0x%X, treating as Mach 64\n", ConfigData.DeviceID));
|
|
break;
|
|
|
|
// VT, exclude VTBs
|
|
case 0x5654:
|
|
|
|
if ((ConfigData.RevisionID == 0x9A) ||
|
|
(ConfigData.RevisionID == 0x5A) ||
|
|
(ConfigData.RevisionID == 0x01))
|
|
{
|
|
VideoDebugPrint((DEBUG_NORMAL, "Rejecting VT card with revision ID 0x%X, treating as Mach 64\n", ConfigData.RevisionID));
|
|
BaseAddress = 0;
|
|
continue;
|
|
}
|
|
|
|
VideoDebugPrint((DEBUG_NORMAL, "Found ATI card with device ID 0x%X, treating as Mach 64\n", ConfigData.DeviceID));
|
|
break;
|
|
|
|
// Other supported PCI chips.
|
|
case 0x00D7: // mach64 GX
|
|
case 0x0057: // mach64 CX
|
|
case 0x4354: /* CT */
|
|
case 0x4554: /* ET */
|
|
case 0x4C54: /* LT */
|
|
case 0x4D54: /* MT */
|
|
case 0x5254: /* RT */
|
|
case 0x3354: /* 3T */
|
|
VideoDebugPrint((DEBUG_NORMAL, "Found ATI card with device ID 0x%X, treating as Mach 64\n", ConfigData.DeviceID));
|
|
|
|
break;
|
|
|
|
default:
|
|
VideoDebugPrint((DEBUG_NORMAL, "Unsupported ATI card with device ID 0x%X\n", ConfigData.DeviceID));
|
|
continue;
|
|
|
|
}
|
|
|
|
/*
|
|
* We will only reach this point if we find an ATI card.
|
|
* If it is a block-relocatable card, BaseAddress will
|
|
* be set to the I/O base address, and we must get out
|
|
* of the loop. If it is not a block-relocatable card,
|
|
* BaseAddress will be zero, and we must continue looking.
|
|
*/
|
|
if (BaseAddress != 0)
|
|
break;
|
|
|
|
} /* end while (FunctionNumber < 8) */
|
|
|
|
/*
|
|
* If we have found a Mach 64 relocatable card, we will have
|
|
* broken out of the inner loop, but we will still be in the
|
|
* outer loop. Since BaseAddress is zero if we have not found
|
|
* a card, and nonzero if we have found one, check this value
|
|
* to determine whether we should break out of the outer loop.
|
|
*/
|
|
if (BaseAddress != 0)
|
|
break;
|
|
|
|
VideoDebugPrint((DEBUG_DETAIL, "Finished inner loop, zeroing function number and incrementing device number\n"));
|
|
FunctionNumber = 0;
|
|
DeviceNumber++;
|
|
|
|
} /* end while (DeviceNumber < 32) */
|
|
|
|
return BaseAddress;
|
|
|
|
} /* FindNextBlockATICard() */
|