595 lines
19 KiB
C
595 lines
19 KiB
C
/************************************************************************/
|
|
/* */
|
|
/* SETUP_M.C */
|
|
/* */
|
|
/* Aug 27 1993 (c) 1993, ATI Technologies Incorporated. */
|
|
/************************************************************************/
|
|
|
|
/********************** PolyTron RCS Utilities
|
|
|
|
$Revision: 1.11 $
|
|
$Date: 23 Jan 1996 11:52:14 $
|
|
$Author: RWolff $
|
|
$Log: S:/source/wnt/ms11/miniport/archive/setup_m.c_v $
|
|
*
|
|
* Rev 1.11 23 Jan 1996 11:52:14 RWolff
|
|
* Eliminated level 3 warnings.
|
|
*
|
|
* Rev 1.10 31 Mar 1995 11:52:06 RWOLFF
|
|
* Changed from all-or-nothing debug print statements to thresholds
|
|
* depending on importance of the message.
|
|
*
|
|
* Rev 1.9 14 Mar 1995 18:17:18 ASHANMUG
|
|
* Reset engine on fifo space check time-out.
|
|
*
|
|
* Rev 1.8 14 Mar 1995 15:59:42 ASHANMUG
|
|
* Timeout on idle check and fifo check.
|
|
*
|
|
* Rev 1.7 08 Mar 1995 11:35:50 ASHANMUG
|
|
* Modified return values to be correct
|
|
*
|
|
* Rev 1.5 22 Jul 1994 17:47:28 RWOLFF
|
|
* Merged with Richard's non-x86 code stream.
|
|
*
|
|
* Rev 1.4 06 Jul 1994 16:41:00 RWOLFF
|
|
* Changed a few loops that I missed for the last checkin to use
|
|
* NUM_IO_ACCESS_RANGES instead of NUM_DRIVER_ACCESS_RANGES.
|
|
*
|
|
* Rev 1.3 30 Jun 1994 18:23:14 RWOLFF
|
|
* Moved IsApertureConflict_m() from QUERY_M.C. Instead of checking to see if
|
|
* we can read back a value we write to the aperture, then looking for the
|
|
* correct text attribute, we now call VideoPortVerifyAccessRanges() with
|
|
* the LFB included in the list of address ranges we are trying to claim.
|
|
* If the call succeeds, the aperture is enabled. If it fails, we make another
|
|
* call that does not try to claim the LFB (this call shouldn't fail, since
|
|
* it's a duplicate of a call which has succeeded previously). Added routine
|
|
* IsVGAConflict_m(), which does the same thing except for the VGA aperture
|
|
* instead of the LFB.
|
|
*
|
|
* Rev 1.2 14 Mar 1994 16:36:42 RWOLFF
|
|
* Functions used by ATIMPResetHw() are not pageable.
|
|
*
|
|
* Rev 1.1 07 Feb 1994 14:14:48 RWOLFF
|
|
* Added alloc_text() pragmas to allow miniport to be swapped out when
|
|
* not needed.
|
|
*
|
|
* Rev 1.0 31 Jan 1994 11:20:58 RWOLFF
|
|
* Initial revision.
|
|
*
|
|
* Rev 1.4 14 Jan 1994 15:26:36 RWOLFF
|
|
* Fixed de-initialization of memory mapped registers, added routine
|
|
* to see if memory mapped registers are available.
|
|
*
|
|
* Rev 1.3 15 Dec 1993 16:02:26 RWOLFF
|
|
* No longer allows use of memory mapped registers on EISA machines,
|
|
* starts mapping of memory mapped registers at index 0 due to removal
|
|
* of placeholder for linear framebuffer.
|
|
*
|
|
* Rev 1.2 05 Nov 1993 13:32:36 RWOLFF
|
|
* Can now unmap I/O address ranges.
|
|
*
|
|
* Rev 1.1 08 Oct 1993 11:18:24 RWOLFF
|
|
* Now checks to see if memory mapped registers can be used, and unmaps them
|
|
* if they aren't usable (NCR Dual Pentium fix).
|
|
*
|
|
* Rev 1.0 03 Sep 1993 14:25:36 RWOLFF
|
|
* Initial revision.
|
|
|
|
End of PolyTron RCS section *****************/
|
|
|
|
#ifdef DOC
|
|
SETUP_M.C - Setup routines for 8514/A compatible accelerators.
|
|
|
|
DESCRIPTION
|
|
This file contains routines which provide services specific to
|
|
the 8514/A-compatible family of ATI accelerators.
|
|
|
|
OTHER FILES
|
|
|
|
#endif
|
|
|
|
#include "dderror.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "miniport.h"
|
|
#include "video.h"
|
|
#include "ntddvdeo.h"
|
|
|
|
#include "stdtyp.h"
|
|
#include "amach.h"
|
|
#include "amach1.h"
|
|
#include "atimp.h"
|
|
|
|
#include "services.h"
|
|
#define INCLUDE_SETUP_M
|
|
#include "setup_m.h"
|
|
|
|
|
|
/*
|
|
* Allow miniport to be swapped out when not needed.
|
|
*
|
|
* WaitForIdle_m() is called by ATIMPResetHw(), which
|
|
* must be in nonpageable memory.
|
|
*/
|
|
#if defined (ALLOC_PRAGMA)
|
|
#pragma alloc_text(PAGE_M, CompatIORangesUsable_m)
|
|
#pragma alloc_text(PAGE_M, CompatMMRangesUsable_m)
|
|
#pragma alloc_text(PAGE_M, UnmapIORanges_m)
|
|
#pragma alloc_text(PAGE_M, MemoryMappedEnabled_m)
|
|
#pragma alloc_text(PAGE_M, CheckFIFOSpace_m)
|
|
#pragma alloc_text(PAGE_M, IsApertureConflict_m)
|
|
#pragma alloc_text(PAGE_M, IsVGAConflict_m)
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
* VP_STATUS CompatIORangesUsable_m(void);
|
|
*
|
|
* Ask Windows NT for permission to use the I/O space address ranges
|
|
* needed by the 8514/A compatible ATI accelerators.
|
|
*
|
|
* Returns:
|
|
* NO_ERROR if successful
|
|
* error code if unable to gain access to the ranges we need.
|
|
*/
|
|
VP_STATUS CompatIORangesUsable_m(void)
|
|
{
|
|
VP_STATUS Status; /* Value returned by operating system calls */
|
|
short Count; /* Loop counter */
|
|
|
|
|
|
/*
|
|
* Check to see if there is a hardware resource conflict.
|
|
*/
|
|
Status = VideoPortVerifyAccessRanges(phwDeviceExtension,
|
|
NUM_IO_ACCESS_RANGES,
|
|
DriverIORange_m);
|
|
if (Status != NO_ERROR)
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
* Clear the list of I/O mapped registers. This is done so
|
|
* that if the loop below fails because one I/O range can't
|
|
* be mapped, and we need to unmap these registers before,
|
|
* mapping the registers needed for another accelerator type,
|
|
* we don't unmap nonexistant address ranges due to the
|
|
* array of processed addresses containing random data.
|
|
*/
|
|
memset(phwDeviceExtension->aVideoAddressIO, 0, NUM_IO_ACCESS_RANGES * sizeof(ULONG));
|
|
|
|
/*
|
|
* Map the video controller address ranges we need to identify
|
|
* our cards into the system virtual address space.
|
|
*
|
|
* Since we only use I/O mapped registers here, set 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_IO_ACCESS_RANGES; Count++)
|
|
{
|
|
if ((phwDeviceExtension->aVideoAddressIO[Count] =
|
|
VideoPortGetDeviceBase(phwDeviceExtension,
|
|
DriverIORange_m[Count].RangeStart,
|
|
DriverIORange_m[Count].RangeLength,
|
|
DriverIORange_m[Count].RangeInIoSpace)) == NULL)
|
|
{
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
phwDeviceExtension->aVideoAddressMM[Count] = 0;
|
|
} /* End for */
|
|
|
|
return NO_ERROR;
|
|
|
|
} /* CompatIORangesUsable_m() */
|
|
|
|
/*
|
|
* void CompatMMRangesUsable_m(void);
|
|
*
|
|
* Ask Windows NT for permission to use the memory mapped registers
|
|
* needed by the 8514/A compatible ATI accelerators.
|
|
*/
|
|
void CompatMMRangesUsable_m(void)
|
|
{
|
|
PHYSICAL_ADDRESS MMrange; /* Used in translating offset to memory address */
|
|
USHORT USTemp; /* Used to enable memory mapped registers */
|
|
int Count; /* Loop counter */
|
|
WORD SrcX; /* Saved contents of SRC_X register */
|
|
DWORD ExtGeStatusMM; /* Memory mapped address for EXT_GE_STATUS */
|
|
struct query_structure *QueryPtr; /* Query information for the card */
|
|
|
|
/*
|
|
* Get a formatted pointer into the query section of HwDeviceExtension.
|
|
* The CardInfo[] field is an unformatted buffer.
|
|
*/
|
|
QueryPtr = (struct query_structure *) (phwDeviceExtension->CardInfo);
|
|
|
|
/*
|
|
* Memory mapped registers are not available on EISA cards.
|
|
*/
|
|
if (QueryPtr->q_bus_type == BUS_EISA)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* ALPHA machines crash during the test to see whether memory-mapped
|
|
* registers are usable, so on these machines we assume that
|
|
* memory-mapped registers are not available.
|
|
*/
|
|
#if defined (ALPHA) || defined (_ALPHA_)
|
|
return;
|
|
#endif
|
|
|
|
/*
|
|
* Use an I/O mapped read on the register we're going to use to see
|
|
* if memory mapped registers are usable, because if they aren't usable
|
|
* we won't get a valid result if we wait until we've enabled
|
|
* memory mapped registers before reading it.
|
|
*/
|
|
SrcX = INPW(R_SRC_X);
|
|
|
|
USTemp = INPW(LOCAL_CONTROL);
|
|
USTemp |= 0x0020; // Enable memory mapped registers
|
|
OUTPW(LOCAL_CONTROL, USTemp);
|
|
MMrange.HighPart = 0;
|
|
|
|
for (Count=0; Count < NUM_IO_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_m[Count].RangeStart.HighPart != DONT_USE)
|
|
{
|
|
/*
|
|
* DriverMMRange_m[Count].RangeStart.LowPart is the offset of
|
|
* the memory mapped register from the beginning of the
|
|
* block of memory mapped registers. We must add the offset
|
|
* of the start of the memory mapped register area from
|
|
* the start of the linear framebuffer (4M aperture assumed)
|
|
* and the physical address of the start of the linear
|
|
* framebuffer to get the physical address of this
|
|
* memory mapped register.
|
|
*/
|
|
MMrange.LowPart = DriverMMRange_m[Count].RangeStart.LowPart + 0x3FFE00 + phwDeviceExtension->PhysicalFrameAddress.LowPart;
|
|
phwDeviceExtension->aVideoAddressMM[Count] =
|
|
VideoPortGetDeviceBase(phwDeviceExtension,
|
|
MMrange,
|
|
DriverMMRange_m[Count].RangeLength,
|
|
FALSE); // not in IO space
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Some cards use an ASIC which is capable of using memory mapped
|
|
* registers, but an older board design which doesn't allow their
|
|
* use. To test this, check whether the SRC_X register (this register
|
|
* is available as memory mapped on any card which is capable of
|
|
* supporting memory mapped registers) remembers a value that is written
|
|
* to it. If it doesn't, then undo the memory mapping, since this
|
|
* test shows that memory mapped registers are not available.
|
|
*/
|
|
VideoDebugPrint((DEBUG_DETAIL, "About to test whether memory mapped registers can be used\n"));
|
|
OUTPW(SRC_X, 0x0AAAA);
|
|
|
|
/*
|
|
* WaitForIdle_m() uses the EXT_GE_STATUS register, which is handled
|
|
* as memory mapped if available. Since we don't know if memory mapped
|
|
* registers are available, work around this by saving the address
|
|
* of the memory mapped EXT_GE_STATUS register, setting the address
|
|
* to zero to force the use of the I/O mapped EXT_GE_STATUS, then
|
|
* restoring the address after WaitForIdle_m() has finished.
|
|
*/
|
|
ExtGeStatusMM = (DWORD) phwDeviceExtension->aVideoAddressMM[EXT_GE_STATUS];
|
|
phwDeviceExtension->aVideoAddressMM[EXT_GE_STATUS] = 0;
|
|
WaitForIdle_m();
|
|
phwDeviceExtension->aVideoAddressMM[EXT_GE_STATUS] = (PVOID) ExtGeStatusMM;
|
|
|
|
if (INPW(R_SRC_X) != 0x02AA)
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Can't use memory mapped ranges\n"));
|
|
for (Count = 0; Count < NUM_IO_ACCESS_RANGES; Count++)
|
|
{
|
|
if (phwDeviceExtension->aVideoAddressMM[Count] != 0)
|
|
{
|
|
VideoPortFreeDeviceBase(phwDeviceExtension,
|
|
phwDeviceExtension->aVideoAddressMM[Count]);
|
|
phwDeviceExtension->aVideoAddressMM[Count] = 0;
|
|
}
|
|
}
|
|
USTemp = INPW(LOCAL_CONTROL);
|
|
USTemp &= 0x0FFDF; /* Disable memory mapped registers */
|
|
OUTPW(LOCAL_CONTROL, USTemp);
|
|
}
|
|
else
|
|
{
|
|
VideoDebugPrint((DEBUG_DETAIL, "Memory mapped registers are usable\n"));
|
|
}
|
|
OUTPW(SRC_X, SrcX);
|
|
VideoDebugPrint((DEBUG_DETAIL, "Memory mapped register test complete\n"));
|
|
|
|
return;
|
|
|
|
} /* CompatMMRangesUsable_m() */
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* void UnmapIORanges_m(void);
|
|
*
|
|
* DESCRIPTION:
|
|
* Unmap the I/O address ranges mapped by CompatIORangesUsable_m() prior
|
|
* to mapping the I/O address ranges used by a non-8514/A-compatible
|
|
* ATI accelerator.
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* phwDeviceExtension->aVideoAddressIO[]
|
|
*
|
|
* CALLED BY:
|
|
* ATIMPFindAdapter()
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
void UnmapIORanges_m(void)
|
|
{
|
|
short Count; /* Loop counter */
|
|
|
|
for (Count=1; Count < NUM_IO_ACCESS_RANGES; Count++)
|
|
{
|
|
/*
|
|
* Only unmap those ranges which have been mapped. We don't need
|
|
* to worry about unmapping nonexistant addresses (due to
|
|
* uninitialized data) if CompatIORangesUsable_m() failed
|
|
* partway through mapping because this routine initialized all
|
|
* phwDeviceExtension->aVideoAddressIO[] entries to zero
|
|
* before it started mapping the I/O ranges.
|
|
*/
|
|
if (phwDeviceExtension->aVideoAddressIO[Count] != 0)
|
|
{
|
|
VideoPortFreeDeviceBase(phwDeviceExtension,
|
|
phwDeviceExtension->aVideoAddressIO[Count]);
|
|
phwDeviceExtension->aVideoAddressIO[Count] = 0;
|
|
}
|
|
}
|
|
return;
|
|
|
|
} /* UnmapIORanges_m() */
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* BOOL MemoryMappedEnabled_m(void);
|
|
*
|
|
* DESCRIPTION:
|
|
* Check to see whether we are using memory mapped registers.
|
|
*
|
|
* RETURN VALUE:
|
|
* TRUE if memory mapped registers are available
|
|
* FALSE if they are not
|
|
*
|
|
* GLOBALS CHANGED:
|
|
* None
|
|
*
|
|
* CALLED BY:
|
|
* May be called by any function after CompatMMRangesUsable_m()
|
|
* has been called.
|
|
*
|
|
* AUTHOR:
|
|
* Robert Wolff
|
|
*
|
|
* CHANGE HISTORY:
|
|
*
|
|
* TEST HISTORY:
|
|
*
|
|
***************************************************************************/
|
|
|
|
BOOL MemoryMappedEnabled_m(void)
|
|
{
|
|
/*
|
|
* If memory mapped registers are enabled, EXT_GE_STATUS will be
|
|
* available in memory mapped form.
|
|
*/
|
|
if (phwDeviceExtension->aVideoAddressMM[EXT_GE_STATUS] != 0)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
|
|
} /* MemoryMappedEnabled_m() */
|
|
|
|
|
|
|
|
|
|
/*
|
|
* int WaitForIdle_m(void);
|
|
*
|
|
* Poll GE_STAT waiting for GE_BUSY to go low. If GE_BUSY does not go
|
|
* low within a reasonable number of attempts, time out.
|
|
*
|
|
* Returns:
|
|
* FALSE if timeout: 3 seconds is an arbitrary value
|
|
* TRUE if engine is idle
|
|
*/
|
|
int WaitForIdle_m(void)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<300; i++)
|
|
{
|
|
if ((INPW(EXT_GE_STATUS) & GE_ACTIVE) == 0)
|
|
return(TRUE);
|
|
|
|
/* Delay for 1/100th of a second */
|
|
delay(10);
|
|
}
|
|
|
|
/* Something has happened, reset the engine and return false */
|
|
VideoDebugPrint((DEBUG_ERROR, "ATI: Timeout on WaitForIdle_m()\n"));
|
|
OUTPW(SUBSYS_CNTL, 0x900F);
|
|
OUTPW(SUBSYS_CNTL, 0x500F);
|
|
|
|
return(FALSE);
|
|
|
|
} /* WaitForIdle_m() */
|
|
|
|
|
|
|
|
/*
|
|
* void CheckFIFOSpace_m(SpaceNeeded);
|
|
*
|
|
* WORD SpaceNeeded; Number of free FIFO entries needed
|
|
*
|
|
* Wait until the specified number of FIFO entries are free
|
|
* on an 8514/A-compatible ATI accelerator.
|
|
*
|
|
* Timeout after 3 seconds
|
|
*/
|
|
void CheckFIFOSpace_m(WORD SpaceNeeded)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<300; i++)
|
|
{
|
|
/* Return from test if no more space is needed */
|
|
if ( !(INPW(EXT_FIFO_STATUS)&SpaceNeeded) )
|
|
return;
|
|
|
|
delay(10);
|
|
}
|
|
|
|
/* Something bad has happened, just return */
|
|
VideoDebugPrint((DEBUG_ERROR, "ATI: Timeout on CheckFIFOSpace_m()\n"));
|
|
OUTPW(SUBSYS_CNTL, 0x900F);
|
|
OUTPW(SUBSYS_CNTL, 0x500F);
|
|
return;
|
|
|
|
} /* CheckFIFOSpace_m() */
|
|
|
|
|
|
|
|
/*
|
|
* BOOL IsApertureConflict_m(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_m(struct query_structure *QueryPtr)
|
|
{
|
|
WORD ApertureData; /* Value read from MEM_CFG register */
|
|
VP_STATUS Status; /* Return value from VideoPortVerifyAccessRanges() */
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
DriverIORange_m[FRAMEBUFFER_ENTRY].RangeStart.LowPart = QueryPtr->q_aperture_addr*ONE_MEG;
|
|
DriverIORange_m[FRAMEBUFFER_ENTRY].RangeLength = 4*ONE_MEG;
|
|
Status = VideoPortVerifyAccessRanges(phwDeviceExtension,
|
|
NUM_DRIVER_ACCESS_RANGES,
|
|
DriverIORange_m);
|
|
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_ACCESS_RANGES,
|
|
DriverIORange_m);
|
|
if (Status != NO_ERROR)
|
|
VideoDebugPrint((DEBUG_ERROR, "ERROR: Can't reclaim I/O ranges\n"));
|
|
|
|
/*
|
|
* Adjust the list of mode tables to take into account the
|
|
* fact that we're using the VGA aperture instead of the LFB.
|
|
*/
|
|
ISAPitchAdjust(QueryPtr);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Enable the linear aperture
|
|
*/
|
|
ApertureData = INPW(MEM_CFG) & 0x0fffc; /* Preserve bits 2-15 */
|
|
ApertureData |= 0x0002; /* 4M aperture */
|
|
OUTPW(MEM_CFG, ApertureData);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
} /* IsApertureConflict_m() */
|
|
|
|
|
|
|
|
/*
|
|
* BOOL IsVGAConflict_m(void);
|
|
*
|
|
* Check to see if the VGA aperture conflicts with other memory.
|
|
*
|
|
* Returns:
|
|
* TRUE if a conflict exists (VGA aperture unusable)
|
|
* FALSE if the VGA aperture is usable.
|
|
*/
|
|
BOOL IsVGAConflict_m(void)
|
|
{
|
|
VP_STATUS Status; /* Return value from VideoPortVerifyAccessRanges() */
|
|
|
|
/*
|
|
* If there is an aperture conflict, a call to
|
|
* VideoPortVerifyAccessRanges() including the VGA aperture in
|
|
* the range list will return an error. If there is no conflict, it
|
|
* will return success.
|
|
*/
|
|
DriverIORange_m[FRAMEBUFFER_ENTRY].RangeStart.LowPart = 0xA0000;
|
|
DriverIORange_m[FRAMEBUFFER_ENTRY].RangeLength = 0x10000;
|
|
DriverIORange_m[FRAMEBUFFER_ENTRY].RangeShareable = TRUE;
|
|
Status = VideoPortVerifyAccessRanges(phwDeviceExtension,
|
|
NUM_DRIVER_ACCESS_RANGES,
|
|
DriverIORange_m);
|
|
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_ACCESS_RANGES,
|
|
DriverIORange_m);
|
|
if (Status != NO_ERROR)
|
|
VideoDebugPrint((DEBUG_ERROR, "ERROR: Can't reclaim I/O ranges\n"));
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
} /* IsVGAConflict_m() */
|