/************************************************************************/
/* */
/* CVTDDC.C */
/* */
/* November 10 1995 (c) 1995 ATI Technologies Incorporated. */
/************************************************************************/
/********************** PolyTron RCS Utilities
$Revision: 1.5 $
$Date: 10 Apr 1996 16:58:22 $
$Author: RWolff $
$Log: S:/source/wnt/ms11/miniport/archive/cvtddc.c_v $
//
// Rev 1.5 10 Apr 1996 16:58:22 RWolff
//Temorarily treats all cards as non-DDC to avoid system hang due to
//conflict over system timer registers. Final solution is to make DDC
//query in the miniport, using the StallExecution function, rather than
//calling the BIOS function which can hang the machine.
//
// Rev 1.4 01 Mar 1996 12:13:28 RWolff
//Now saves and restores the portion of video memory used as
//a buffer to hold data returned by the DDC query call.
//
// Rev 1.3 02 Feb 1996 17:15:44 RWolff
//Now gets DDC/VDIF merge source information from hardware device
//extension rather than storing it in static variables, moved code to
//obtain a buffer in VGA memory to a separate routine.
//
// Rev 1.2 29 Jan 1996 16:54:40 RWolff
//Now uses VideoPortInt10() rather than no-BIOS code on PPC.
//
// Rev 1.1 11 Jan 1996 19:37:44 RWolff
//Now restricts "canned" mode tables by both maximum index and maximum
//pixel clock frequency, and EDID mode tables by maximum pixel clock
//frequency only, rather than both by maximum refresh rate.
//
// Rev 1.0 21 Nov 1995 11:04:38 RWolff
//Initial revision.
End of PolyTron RCS section *****************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include "dderror.h"
#include "miniport.h"
#include "ntddvdeo.h"
#include "video.h" /* for VP_STATUS definition */
#include "stdtyp.h"
#include "amachcx.h"
#include "amach1.h"
#include "atimp.h"
#include "cvtvga.h"
#include "services.h"
#include "vdptocrt.h"
#include "cvtvdif.h"
#define INCLUDE_CVTDDC
#include "cvtddc.h"
/*
* Allow miniport to be swapped out when not needed.
*/
#if defined (ALLOC_PRAGMA)
#pragma alloc_text(PAGE_CX, IsDDCSupported)
#pragma alloc_text(PAGE_DDC, MergeEDIDTables)
#endif
/*****************************************************************************
*
* ULONG IsDDCSupported(void);
*
* DESCRIPTION:
* Reports the degree of DDC support for the available monitor/graphics
* card combination.
*
* RETURN VALUE:
* MERGE_EDID_DDC if DDC can return EDID data structures
* MERGE_VDIF_FILE if no monitor data available from DDC
*
* GLOBALS CHANGED:
* None
*
* CALLED BY:
* SetFixedModes()
*
* AUTHOR:
* Robert Wolff
*
* CHANGE HISTORY:
*
* TEST HISTORY:
*
***************************************************************************/
ULONG IsDDCSupported(void)
{
VIDEO_X86_BIOS_ARGUMENTS Registers; /* Used in VideoPortInt10() calls */
VP_STATUS RetVal; /* Status returned by VideoPortInt10() */
ULONG MergeSource; /* Source of mode tables to merge with "canned" tables */
VideoPortZeroMemory(&Registers, sizeof(VIDEO_X86_BIOS_ARGUMENTS));
Registers.Eax = BIOS_DDC_SUPPORT;
Registers.Ebx = 0;
if ((RetVal = VideoPortInt10(phwDeviceExtension, &Registers)) != NO_ERROR)
/*
* If we can't find out DDC status from the BIOS,
* assume DDC is not supported.
*/
{
VideoDebugPrint((DEBUG_ERROR, "Error querying DDC status, assume it's not supported\n"));
MergeSource = MERGE_VDIF_FILE;
}
else
{
#if 0
/*
* Workaround: Our BIOS call to obtain the DDC information uses
* the system timer (0x40/0x43) registers, which (according to
* Microsoft) the video BIOS is not supposed to touch. This
* causes some machines to hang during the DDC query. Until
* we can bring the DDC query into the miniport (using approved
* time delay routines), report that this card doesn't support
* DDC.
*/
if ((Registers.Eax & 0x00000002) && (Registers.Ebx & 0x00000002))
{
/*
* DDC2 supported by both BIOS and monitor. Check separately
* for DDC1 and DDC2 in case we decide to handle them
* differently in future.
*/
VideoDebugPrint((DEBUG_NORMAL, "DDC2 supported\n"));
MergeSource = MERGE_EDID_DDC;
}
else if ((Registers.Eax & 0x00000001) && (Registers.Ebx & 0x00000001))
{
/*
* DDC1 supported by both BIOS and monitor.
*/
VideoDebugPrint((DEBUG_NORMAL, "DDC1 supported\n"));
MergeSource = MERGE_EDID_DDC;
}
else
{
/*
* Either the BIOS or the monitor does not support DDC.
*/
VideoDebugPrint((DEBUG_NORMAL, "DDC not supported\n"));
MergeSource = MERGE_VDIF_FILE;
}
#else
MergeSource = MERGE_VDIF_FILE;
#endif
}
return MergeSource;
} /* IsDDCSupported() */
/*****************************************************************************
*
* VP_STATUS MergeEDIDTables(void);
*
* DESCRIPTION:
* Merges canned mode tables from BookValues[] with tables found in an
* EDID structure retrieved via DDC. Global pointer variable pCallbackArgs
* is used to point to a structure that passes data in both directions
* between this function and SetFixedModes(). For details on input and
* output data see definition of stVDIFCallbackData structure.
*
* RETURN VALUE:
* NO_ERROR if tables retrieved correctly
* ERROR_INVALID_PARAMETER if unable to retrieve data via DDC
*
* GLOBALS CHANGED:
* None
*
* CALLED BY:
* SetFixedModes()
*
* AUTHOR:
* Robert Wolff
*
* CHANGE HISTORY:
*
* TEST HISTORY:
*
***************************************************************************/
VP_STATUS MergeEDIDTables(void)
{
VIDEO_X86_BIOS_ARGUMENTS Registers; /* Used in VideoPortInt10() calls */
VP_STATUS RetVal; /* Status returned by VideoPortInt10() */
ULONG BufferSeg; /* Segment to use for buffer */
ULONG BufferSize = 128; /* EDID structure is 128 bytes long */
PUCHAR MappedBuffer; /* Pointer to buffer used for BIOS query */
static UCHAR FixedBuffer[128]; /* Buffer used to avoid repeated BIOS queries */
struct EdidDetailTiming *EdidPtr; /* Used in extracting information from buffer */
ULONG DetailOffset; /* Offset of detailed timing into EDID structure */
ULONG Scratch; /* Temporary variable */
struct stVDIFCallbackData *pArgs; /* Pointer to arguments structure */
struct st_mode_table BuildTbl; /* Mode table being built */
struct st_mode_table LiveTables[4]; /* Tables already extracted */
USHORT NumTablesFound = 0; /* Number of valid entries in LiveTables[] */
USHORT NumLowerTables; /* Number of tables with a lower refresh rate than BuildTbl */
USHORT HorTotal; /* Horizontal total */
USHORT VerTotal; /* Vertical total */
USHORT SyncStrt; /* Sync start */
USHORT HighBound; /* Highest frame rate to look for */
UCHAR SavedScreen[128]; /* Data saved from screen buffer used for DDC query */
pArgs = pCallbackArgs;
/*
* If we haven't already retrieved the EDID information into local
* storage, do it now.
*/
if (phwDeviceExtension->EdidChecksum == 0)
{
MappedBuffer = GetVgaBuffer(BufferSize, 0x500, &BufferSeg, SavedScreen);
/*
* We now have a buffer big enough to hold the EDID structure,
* so make the BIOS call to fill it in.
*/
VideoPortZeroMemory(&Registers, sizeof(VIDEO_X86_BIOS_ARGUMENTS));
Registers.Eax = BIOS_DDC_SUPPORT;
Registers.Ebx = 1;
Registers.Ecx = BufferSize;
Registers.Edx = BufferSeg;
Registers.Edi = 0;
if ((RetVal = VideoPortInt10(phwDeviceExtension, &Registers)) != NO_ERROR)
{
VideoDebugPrint((DEBUG_ERROR, "MergeEDIDTables() - failed BIOS_DDC_SUPPORT call\n"));
VideoPortFreeDeviceBase(phwDeviceExtension, MappedBuffer);
return RetVal;
}
/*
* Copy the EDID structure into local storage, then restore
* the contents of the buffer we used for the DDC query.
*/
for (Scratch = 0; Scratch < 128; Scratch++)
{
FixedBuffer[Scratch] = VideoPortReadRegisterUchar(&(MappedBuffer[Scratch]));
phwDeviceExtension->EdidChecksum += FixedBuffer[Scratch];
VideoPortWriteRegisterUchar(&(MappedBuffer[Scratch]), SavedScreen[Scratch]);
}
/*
* Check if we have a valid EDID header. If we don't, then
* we can't extract EDID information. Occasionally, a
* monitor hooked up to a switchbox will return corrupt
* EDID data.
*/
if ((FixedBuffer[0] != 0) ||
(FixedBuffer[1] != 0xFF) ||
(FixedBuffer[2] != 0xFF) ||
(FixedBuffer[3] != 0xFF) ||
(FixedBuffer[4] != 0xFF) ||
(FixedBuffer[5] != 0xFF) ||
(FixedBuffer[6] != 0xFF) ||
(FixedBuffer[7] != 0))
{
VideoDebugPrint((DEBUG_ERROR, "Invalid EDID header\n"));
return ERROR_INVALID_PARAMETER;
}
/*
* We now have the EDID structure in local storage, so we can free
* the buffer we collected it into. If the lower 8 bits of the
* checksum are nonzero, the structure is invalid.
*/
VideoPortFreeDeviceBase(phwDeviceExtension, MappedBuffer);
if ((phwDeviceExtension->EdidChecksum & 0x000000FF) != 0)
{
VideoDebugPrint((DEBUG_ERROR, "MergeEDIDTables() - invalid checksum 0x%X\n", phwDeviceExtension->EdidChecksum));
return ERROR_INVALID_PARAMETER;
}
} /* endif (phwDeviceExtension->EdidChecksum == 0) */
/*
* There are 4 detailed timing blocks in the EDID structure. Read
* each of them in turn.
*/
for (DetailOffset = 54; DetailOffset <= 108; DetailOffset += 18)
{
((PUCHAR)EdidPtr) = FixedBuffer + DetailOffset;
/*
* Initially check only the horizontal and vertical
* resolution. If they don't match the resolution we
* are working on, skip to the next detailed timing block.
*/
BuildTbl.m_x_size = ((EdidPtr->HorHighNybbles & 0xF0) << 4) | EdidPtr->HorActiveLowByte;
BuildTbl.m_y_size = ((EdidPtr->VerHighNybbles & 0xF0) << 4) | EdidPtr->VerActiveLowByte;
if ((BuildTbl.m_x_size != pArgs->HorRes) || (BuildTbl.m_y_size != pArgs->VerRes))
{
VideoDebugPrint((DEBUG_DETAIL, "EDID mode %dx%d doesn't match desired mode %dx%d, skipping\n",
BuildTbl.m_x_size, BuildTbl.m_y_size, pArgs->HorRes, pArgs->VerRes));
continue;
}
/*
* The table we are looking at matches the resolution we are
* working on. Fill in the remaining parameters.
*/
BuildTbl.m_h_disp = (UCHAR)(BuildTbl.m_x_size / 8 - 1);
BuildTbl.m_v_disp = (short) normal_to_skip2((long)(BuildTbl.m_y_size - 1));
BuildTbl.ClockFreq = (ULONG)(EdidPtr->PixClock) * 10000L;
/*
* If the pixel clock frequency for this mode is greater than
* the maximum pixel clock frequency the graphics card supports
* for the current resolution and pixel depth (this routine deals
* with only one resolution/pixel depth combination at a time,
* so our limiting pixel clock rate will always be for the current
* resolution/pixel depth combination), we can't use this mode.
*/
if (BuildTbl.ClockFreq > pArgs->MaxDotClock)
{
VideoDebugPrint((DEBUG_NORMAL, "Skipping table because pixel clock rate is too high\n"));
continue;
}
HorTotal = ((EdidPtr->HorHighNybbles & 0x0F) << 8) | EdidPtr->HorBlankLowByte;
HorTotal += BuildTbl.m_x_size;
BuildTbl.m_h_total = (UCHAR)(HorTotal / 8 - 1);
VerTotal = ((EdidPtr->VerHighNybbles & 0x0F) << 8) | EdidPtr->VerBlankLowByte;
VerTotal += BuildTbl.m_y_size;
BuildTbl.m_v_total = (short) normal_to_skip2((long)(VerTotal - 1));
SyncStrt = ((EdidPtr->SyncHighBits & 0xC0) << 2) | EdidPtr->HSyncOffsetLB;
SyncStrt += BuildTbl.m_x_size;
BuildTbl.m_h_sync_strt = (UCHAR)(SyncStrt / 8 - 1);
SyncStrt = ((EdidPtr->SyncHighBits & 0x0C) << 2) | ((EdidPtr->VSyncOffWidLN & 0xF0) >> 4);
SyncStrt += BuildTbl.m_y_size;
BuildTbl.m_v_sync_strt = (short) normal_to_skip2((long)(SyncStrt - 1));
/*
* We only support digital separate sync monitors.
*/
if ((EdidPtr->Flags & EDID_FLAGS_SYNC_TYPE_MASK) != EDID_FLAGS_SYNC_DIGITAL_SEP)
{
VideoDebugPrint((DEBUG_NORMAL, "Skipping table due to wrong sync type\n"));
continue;
}
Scratch = ((EdidPtr->SyncHighBits & 0x30) << 4) | EdidPtr->HSyncWidthLB;
if (!(EdidPtr->Flags & EDID_FLAGS_H_SYNC_POS))
Scratch |= 0x20;
BuildTbl.m_h_sync_wid = (UCHAR)Scratch;
Scratch = ((EdidPtr->SyncHighBits & 0x03) << 4) | (EdidPtr->VSyncOffWidLN & 0x0F);
if (!(EdidPtr->Flags & EDID_FLAGS_V_SYNC_POS))
Scratch |= 0x20;
BuildTbl.m_v_sync_wid = (UCHAR)Scratch;
BuildTbl.m_status_flags = 0;
BuildTbl.m_vfifo_16 = 8;
BuildTbl.m_vfifo_24 = 8;
BuildTbl.m_clock_select = 0x800;
BuildTbl.m_h_overscan = 0;
BuildTbl.m_v_overscan = 0;
BuildTbl.m_overscan_8b = 0;
BuildTbl.m_overscan_gr = 0;
if (EdidPtr->Flags & EDID_FLAGS_INTERLACE)
BuildTbl.m_disp_cntl = 0x33;
else
BuildTbl.m_disp_cntl = 0x23;
/*
* The EDID detailed timing tables don't include the refresh
* rate. In our VDIF to monitor timings routines, we obtain
* the horizontal and vertical totals from the equations
*
* Htot = PixClk/HorFreq
* Vtot = HorFreq/FrameRate
*
* These equations can be rearranged to
*
* HorFreq = PixClk/Htot
* FrameRate = HorFreq/Vtot = (PixClk/Htot)/Vtot = PixClk/(Htot*Vtot)
*
* The multiplication, addition, and division below is to
* round up to the nearest whole number, since we don't
* have access to floating point.
*/
Scratch = (BuildTbl.ClockFreq * 10)/(HorTotal*VerTotal);
Scratch += 5;
Scratch /= 10;
BuildTbl.Refresh = (short)Scratch;
VideoDebugPrint((DEBUG_DETAIL, "Refresh rate = %dHz\n", BuildTbl.Refresh));
/*
* Set the pixel depth and pitch, and adjust the clock frequency
* if the DAC needs multiple clocks per pixel.
*/
SetOtherModeParameters(pArgs->PixelDepth, pArgs->Pitch,
pArgs->Multiplier, &BuildTbl);
/*
* We now have a mode table for the resolution we are
* looking at. If this is the first table we have found
* at this resolution, we can simply fill in the first
* entry in LiveTables[]. If not, we must put the table
* into the list in order by refresh rate.
*/
if (NumTablesFound == 0)
{
VideoDebugPrint((DEBUG_DETAIL, "First DDC table for this resolution\n"));
VideoPortMoveMemory(&(LiveTables[0]), &BuildTbl, sizeof(struct st_mode_table));
NumTablesFound = 1;
}
else
{
/*
* Run through the list of tables we have already found.
* Skip over the tables which have refresh rates lower than
* the new table, and shift tables with higher refresh
* rates up one position to make room for the new table.
* There is no need to check for available spaces in the
* LiveTables[] array, since this array has 4 entries and
* the EDID structure can hold a maximum of 4 detailed
* timings.
*/
for (NumLowerTables = 0; NumLowerTables < NumTablesFound; NumLowerTables++)
{
if (LiveTables[NumLowerTables].Refresh < BuildTbl.Refresh)
{
VideoDebugPrint((DEBUG_DETAIL, "Skipping table %d, since %dHz is less than %dHz\n",
NumLowerTables, LiveTables[NumLowerTables].Refresh, BuildTbl.Refresh));
continue;
}
/*
* NumLowerTables now holds the number of tables in LiveTables[] which
* have refresh rates lower than that in BuildTbl. We must now move
* the tables in LiveTables[] with refresh rates higher than that in
* BuildTbl up one space to make room for BuildTbl to be inserted.
* After moving the tables, break out of the outer loop.
*/
for (Scratch = NumTablesFound; Scratch >= NumLowerTables; Scratch--)
{
VideoDebugPrint((DEBUG_DETAIL, "Moving table %d, since %dHz is more than %dHz\n",
Scratch, LiveTables[Scratch].Refresh, BuildTbl.Refresh));
VideoPortMoveMemory(&(LiveTables[Scratch+1]), &(LiveTables[Scratch]), sizeof(struct st_mode_table));
}
break;
}
/*
* When we get here, one of two conditions is satisfied:
*
* 1. All the existing tables in LiveTables[] have a refresh
* rate less than that in BuildTbl, so the outer loop will
* have exited with NumLowerTables equal to NumTablesFound.
*
* 2. There are some tables in LiveTables[] which have a refresh
* rate greater than that in BuildTbl. The inner loop will
* have exited after moving these tables up one space, then
* we will have broken out of the outer loop. NumLowerTables
* is equal to the number of existing tables which have a
* refresh rate less than that in BuildTbl.
*
* In both cases, LiveTables[NumLowerTables] is a free slot
* at the location where BuildTbl should be copied.
*/
VideoDebugPrint((DEBUG_DETAIL, "Copying new table to entry %d\n", NumLowerTables));
VideoPortMoveMemory(&(LiveTables[NumLowerTables]), &BuildTbl, sizeof(struct st_mode_table));
NumTablesFound++;
} /* end if (NumTablesFound != 0) */
} /* end for (look at next detailed timing block) */
/*
* We now have all the mode tables from the EDID structure which
* match the desired resolution stored in LiveTables[] in order
* of increasing refresh rate, with the number of such tables
* in NumTablesFound. Now we must merge the results with the
* "canned" mode tables.
*/
HighBound = BookValues[pArgs->EndIndex].Refresh;
/*
* Use NumLowerTables to go through the list of tables from
* the EDID structure.
*
* Since there will never be a legitimate mode table with a
* pixel clock frequency of zero hertz, we can use this value
* as a flag to show that we don't want to use the tables from
* the EDID structure. Initially, we only want to lock out the
* use of these tables if none exist, but we will later lock
* them out if we have already used all of them.
*/
NumLowerTables = 0;
if (NumTablesFound == 0)
LiveTables[0].ClockFreq = 0;
while (pArgs->FreeTables > 0)
{
/*
* If the EDID table exists, and either it has a refresh rate
* less than or equal to that of the next "canned" table or
* we have run out of acceptable "canned" tables, use the EDID
* table. We know that any EDID table will have an acceptable
* pixel clock frequency because we have already discarded any
* that are out of range.
*/
if ((LiveTables[NumLowerTables].ClockFreq != 0) &&
((LiveTables[NumLowerTables].Refresh <= BookValues[pArgs->Index].Refresh) ||
(pArgs->Index > pArgs->EndIndex) ||
(BookValues[pArgs->Index].ClockFreq > pArgs->MaxDotClock)))
{
VideoDebugPrint((DEBUG_DETAIL, "Copying %dHz table from EDID\n", LiveTables[NumLowerTables].Refresh));
VideoPortMoveMemory((*pArgs->ppFreeTables), &(LiveTables[NumLowerTables]), sizeof(struct st_mode_table));
NumLowerTables++;
}
/*
* The above check will have failed if the EDID table did not exist,
* or if it did but an acceptable "canned" table with a lower
* refresh rate also exists. Check to see if we have an acceptable
* "canned" table, and use it if we do.
*/
else if ((pArgs->Index <= pArgs->EndIndex) &&
(BookValues[pArgs->Index].ClockFreq <= pArgs->MaxDotClock))
{
VideoDebugPrint((DEBUG_DETAIL, "Copying %dHz \"canned\" table\n", BookValues[pArgs->Index].Refresh));
BookVgaTable(pArgs->Index, *pArgs->ppFreeTables);
SetOtherModeParameters(pArgs->PixelDepth, pArgs->Pitch,
pArgs->Multiplier, *pArgs->ppFreeTables);
pArgs->Index++;
}
/*
* The only way we will fail both of the above checks is if there
* are no acceptable mode tables remaining, either from the EDID
* structure or from our list of "canned" tables. If this is the
* case, we don't need to look for more mode tables to add to
* our list.
*/
else
{
break;
}
/*
* Update the lower bound, since we don't want to consider
* tables with refresh rates lower than or equal to the one
* in the table we just added to the list. After we have
* done this, skip ahead in both the "canned" and EDID tables
* to get past those which are below the new lower bound.
*
* Don't skip a mode table from the EDID structure with a pixel
* clock frequency of zero, since this is a flag to show that we
* have already used all of the suitable mode tables from the
* EDID structure, rather than a legitimate mode table.
*/
pArgs->LowBound = (*pArgs->ppFreeTables)->Refresh + 1;
while ((pArgs->Index <= pArgs->EndIndex) &&
(BookValues[pArgs->Index].Refresh < pArgs->LowBound))
{
VideoDebugPrint((DEBUG_DETAIL, "Skipping %dHz \"canned\" table\n", BookValues[pArgs->Index].Refresh));
pArgs->Index++;
}
while ((NumLowerTables < NumTablesFound) &&
(LiveTables[NumLowerTables].ClockFreq != 0) &&
(LiveTables[NumLowerTables].Refresh < pArgs->LowBound))
{
VideoDebugPrint((DEBUG_DETAIL, "Skipping %dHz table from EDID\n", LiveTables[NumLowerTables].Refresh));
NumLowerTables++;
}
/*
* If we have run out of EDID tables, mark the EDID tables
* with our flag to show that they should be ignored (no
* legitimate mode will have a pixel clock rate of zero
* hertz).
*
* We must do this in the first entry of the structure then
* reset the "next EDID table to use" index to point to the
* first entry, rather than modifying whatever happens to be
* the next entry, to avoid trampling data outside our array
* in the (unlikely) event that all of the possible detailed
* timings in the EDID structure were valid mode tables with
* in-range pixel clock frequencies for the resolution we are
* looking at.
*
* There is no need to set a flag if we run out of "canned"
* tables because we identify this condition by the index
* being higher than the highest index we want to look for,
* which is an input parameter.
*/
if (NumLowerTables == NumTablesFound)
{
VideoDebugPrint((DEBUG_DETAIL, "Ran out of EDID tables\n"));
NumLowerTables = 0;
LiveTables[0].ClockFreq = 0;
}
/*
* Adjust the free tables pointer and count to reflect the
* table we have just added.
*/
(*pArgs->ppFreeTables)++;
pArgs->NumModes++;
pArgs->FreeTables--;
} /* end while (more tables and not yet reached high bound) */
return NO_ERROR;
} /* MergeEDIDTables() */