?? rprombw.c
字號:
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetSclHBlankTime(LPFIXEDPOINT lpHBlankTime, ULONG ulSclMode,
ULONG ulSclBurst, ULONG ulMemClock,
ULONG ulMemIPC)
{
FIXEDPOINT sTemp;
if (ulSclMode == MBW_SCL_PLANAR_MODE)
{
// planar mode
// (1 / SCL_EFF) * ((SCL_BURST * 2) / MEM_CLK)
vMBW_GetSclEff(lpHBlankTime, ulSclBurst, ulMemIPC);
sTemp.Integral = ulSclBurst << 1;
sTemp.Fractional = 0;
vMultiplyFixed(lpHBlankTime, &sTemp);
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
vDivideFixed(lpHBlankTime, &sTemp);
}
else if (ulSclMode == MBW_SCL_PACKED_MODE)
{
// packed mode
if (!ulSclBurst)
{
lpHBlankTime->Integral = 0;
lpHBlankTime->Fractional = 0;
}
else
{
// just assume we need at least 4 QWORD at 80% efficiency for now
// 1*1/4 by reciprocal
lpHBlankTime->Integral = 1;
lpHBlankTime->Fractional = MBW_GetFractional(1, 4);
sTemp.Integral = 4;
sTemp.Fractional = 0;
vMultiplyFixed(lpHBlankTime, &sTemp);
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
vDivideFixed(lpHBlankTime, &sTemp);
}
}
}
/****************************Public*Routine*******************************\
*
* MBW_ReqHBlankTime()
*
* Calculate Required Horizontal Blank Time in Micro Second
*
* Note: lpReqHBlankTime with output fixed-point value
* function return ULONG value
*
\**************************************************************************/
ULONG MBW_ReqHBlankTime(LPFIXEDPOINT lpReqHBlankTime, ULONG ulMemClock)
{
FIXEDPOINT sHBlankTime;
ULONG ulHWCI_Size;
ULONG ulMemIPC = 1; // hard code
ULONG ulVidFlush = 4; // hard code
ULONG ulHFBFIFO = 32; // hard code
ULONG ulSubBurst = 32; // hard code
ULONG ulSclMode = MBW_SCL_PLANAR_MODE; // hard code
ULONG ulSclBurst = 56; // hard code
#define HWCUR1_SIZE 2 // hard code
#define HWICON1_SIZE 4 // hard code
#define HWCUR2_SIZE 2 // hard code
#define HWICON2_SIZE 4 // hard code
ulHWCI_Size = HWCUR1_SIZE + HWICON1_SIZE;
// REQ_HBLANK = DISP1_HBLANK
vMBW_GetDispHBlankTime(lpReqHBlankTime, MBW_DISP_FIFO,
ulHWCI_Size, ulMemClock, ulMemIPC);
ulHWCI_Size = HWCUR2_SIZE + HWICON2_SIZE;
vMBW_GetDispHBlankTime(&sHBlankTime, MBW_DISP_FIFO,
ulHWCI_Size, ulMemClock, ulMemIPC);
// REQ_HBLANK += DISP2_HBLANK
vAddFixed(lpReqHBlankTime, &sHBlankTime);
// vMBW_GetVideoHBlankTime(&sHBlankTime, ulVidFlush, ulMemClock, ulMemIPC);
// REQ_HBLANK += VID_HBLANK
vAddFixed(lpReqHBlankTime, &sHBlankTime);
vMBW_GetHFBHBlankTime(&sHBlankTime, ulHFBFIFO, ulMemClock, ulMemIPC);
// REQ_HBLANK += HFB_HBLANK
vAddFixed(lpReqHBlankTime, &sHBlankTime);
vMBW_GetSubHBlankTime(&sHBlankTime, ulSubBurst, ulMemClock, ulMemIPC);
// REQ_HBLANK += SUB_HBLANK
vAddFixed(lpReqHBlankTime, &sHBlankTime);
vMBW_GetSclHBlankTime(&sHBlankTime, ulSclMode, ulSclBurst, ulMemClock,
ulMemIPC);
// REQ_HBLANK += SCL_HBLANK
vAddFixed(lpReqHBlankTime, &sHBlankTime);
if (lpReqHBlankTime->Fractional >= 128)
return lpReqHBlankTime->Integral + 1;
else
return lpReqHBlankTime->Integral;
}
/****************************Public*Routine*******************************\
*
* ULONG MBW_VGATextReqHBlankTime()
*
* Calculate VGA Text Required Horizontal Blank Time in Micro Second
*
* Note: lpHBlankTime with output fixed-point value
* function return ULONG value
*
\**************************************************************************/
ULONG MBW_VGATextReqHBlankTime(HGCO hGCO, LPFIXEDPOINT lpHBlankTime,
LPDEVMODE_INFO lpModeInfo, ULONG ulMemClock, LPFIXEDPOINT lpPixelClock)
{
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
FIXEDPOINT sEff;
FIXEDPOINT sPixClk;
FIXEDPOINT sOverhead;
FIXEDPOINT sTemp;
ULONG ulDispFIFO = 32; // hard code
ULONG ulMemIPC = 1; // hard code
#define HWICON_SIZE 4 // hard code
sPixClk = *lpPixelClock;
sOverhead.Integral = 12;
sOverhead.Fractional = 0;
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
// (2 / MEM_CLK) + (10 / MEM_CLK)
vDivideFixed(&sOverhead, &sTemp);
sTemp.Integral = 5;
sTemp.Fractional = 0;
// (5 / PIX_CLK)
vDivideFixed(&sTemp, &sPixClk);
// 5 PCLK delay for CDE_XCLK + 2 XCLK delay until daddrgen
// state machine starts + 10 XCLK states
// (5 / PIX_CLK) + (2 / MEM_CLK) + (10 / MEM_CLK)
vAddFixed(&sOverhead, &sTemp);
// (1 / CHARACTER_EFF) * DISP_FIFO
vMBW_GetBurstEff(&sEff, ulDispFIFO, ulMemIPC);
lpHBlankTime->Integral = ulDispFIFO;
lpHBlankTime->Fractional = 0;
vMultiplyFixed(lpHBlankTime, &sEff);
// (1 / FONT_EFF) * 2
vMBW_GetBurstEff(&sEff, 1, ulMemIPC);
sTemp.Integral = 2;
sTemp.Fractional = 0;
vMultiplyFixed(&sTemp, &sEff);
vAddFixed(lpHBlankTime, &sTemp);
// (1 / HWICON_EFF) * HWICON_SIZE
vMBW_GetBurstEff(&sEff, HWICON_SIZE, ulMemIPC);
sTemp.Integral = HWICON_SIZE;
sTemp.Fractional = 0;
vMultiplyFixed(&sTemp, &sEff);
vAddFixed(lpHBlankTime, &sTemp);
// Divided by MEM_CLK
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
vDivideFixed(lpHBlankTime, &sTemp);
// Add OVERHEAD
vAddFixed(lpHBlankTime, &sOverhead);
if (lpHBlankTime->Fractional >= 128)
return lpHBlankTime->Integral + 1;
else
return lpHBlankTime->Integral;
}
/****************************Private*Routine*******************************\
*
* ULONG GetMemWidth()
*
* Get Memory Width
*
* Note:
*
*
\**************************************************************************/
ULONG GetMemWidth(HGCO hGCO)
{
ULONG ulMemWidth;
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
if ((lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_VTB) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_VTB_PLUS) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_VTB_VT4) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_GTB) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_LTG) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_GTB_PLUS) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_GTB_IIC) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_GTC) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_LT_PRO))
{
ulMemWidth = MBW_MEM_WID64; // for LT PRO
}
else if ((lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_MOBILITY) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XL) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XC))
{
if (lpHwCrtc->ulMemoryInterface & MEMORY_INTERFACE_64BIT)
ulMemWidth = MBW_MEM_WID64;
else if (lpHwCrtc->ulMemoryInterface & MEMORY_INTERFACE_32BIT)
ulMemWidth = MBW_MEM_WID32;
else
ulMemWidth = 0;
}
return ulMemWidth;
}
/****************************Private*Routine*******************************\
*
* ULONG GetMemoryClock()
*
* Get Memory Clock
*
* Note:
*
*
\**************************************************************************/
ULONG GetMemoryClock(HGCO hGCO)
{
UCHAR ucAddress;
UCHAR ucResult;
UCHAR XClockDivider [] = {1,2,4,8,3,1,1,1}; // 5,6,7 is not used
ULONG ulXClock;
ULONG ulMemWidth;
PLL_DIVIDERS XClockPLLDividers;
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
// Now get the values for XCLK this is common for both CRTC
ucAddress = PLL_EXT_CNTL;
ucResult = GcoPLLReadByte(hGCO, ucAddress);
XClockPLLDividers.ucPLL_POST_DIV = XClockDivider[ (ucResult & 0x07) ];
if (ucResult & MFB_TIMES_4_2b )
{
XClockPLLDividers.usPLL_FB_DIV = 4; // incorporate Nmult in the ulXClkFeedBackDevider
}
else
{
XClockPLLDividers.usPLL_FB_DIV = 2;
}
ucAddress = MCLK_FB_DIV;
ucResult = GcoPLLReadByte(hGCO, ucAddress);
XClockPLLDividers.usPLL_FB_DIV *= (USHORT)ucResult;
ucAddress = PLL_REF_DIV;
ucResult = GcoPLLReadByte(hGCO, ucAddress);
XClockPLLDividers.usPLL_REF_DIV = (USHORT) ucResult;
if (XClockPLLDividers.ucPLL_POST_DIV == 0 ||
XClockPLLDividers.usPLL_REF_DIV == 0 ||
XClockPLLDividers.usPLL_FB_DIV == 0)
{
return 0;
}
// X Clock in kHz/10
ulXClock = (lpHwCrtc->HwAsicId.ulReferenceFrequency * (ULONG)XClockPLLDividers.usPLL_FB_DIV) /
((ULONG)XClockPLLDividers.usPLL_REF_DIV * (ULONG)XClockPLLDividers.ucPLL_POST_DIV);
ulXClock /= 100; //XClock in MHz
ulMemWidth = GetMemWidth(hGCO);
if (lpHwCrtc->ucHFBOn && (ulMemWidth == MBW_MEM_WID32))
ulXClock <<= 1;
else
// For SDRAM 2:1 Memory Clock is twice the value of XCLK.
if (lpHwCrtc->ulRageProCrtcCaps & RAGEPRO_CRTC_CAPS_SDRAM_21)
ulXClock <<= 1;
return ulXClock;
}
/****************************Private*Routine*******************************\
*
* ULONG MBW_GetMemIPC()
*
* Get MEM_IPC
*
* Note:
*
*
\**************************************************************************/
ULONG MBW_GetMemIPC(HGCO hGCO)
{
ULONG ulMemIPC;
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
if ((lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_VTB) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_VTB_PLUS) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_VTB_VT4) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_GTB) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_LTG) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_GTB_PLUS) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_GTB_IIC) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_GTC) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_LT_PRO))
{
ulMemIPC = MBW_MEM_IPC1;
}
else if ((lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_MOBILITY) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XL) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XC))
{
// 64-bit width and 1 MEM_IPC for SDR 1:1
if (lpHwCrtc->ulMemoryInterface & MEMORY_INTERFACE_64BIT)
ulMemIPC = MBW_MEM_IPC1;
// 32-bit width and 2 MEM_IPC for SDR 2:1
else if (lpHwCrtc->ulMemoryInterface & MEMORY_INTERFACE_32BIT)
ulMemIPC = MBW_MEM_IPC2;
}
return ulMemIPC;
}
/****************************Public*Routine*******************************\
*
* vMBW_GetTotalBandwidth()
*
* Get Total Bandwidth
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetTotalBandwidth(HGCO hGCO, LPFIXEDPOINT lpBandwidth)
{
ULONG ulMemClock;
ULONG ulMemWidth;
FIXEDPOINT sFactorMem32 = {1, 192};
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
ulMemClock = GetMemoryClock(hGCO);
ulMemWidth = GetMemWidth(hGCO);
vMBW_GetMemBW(lpBandwidth, ulMemClock, ulMemWidth, (lpHwCrtc->ulRageProCrtcCaps & RAGEPRO_CRTC_CAPS_BANDWIDTH_FIX));
if ((ulMemWidth == MBW_MEM_WID64) && (lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_MOBILITY))
{
// EPR# 34959 to support 1600x1200x32@85Hz
lpBandwidth->Integral += 90; // 42
}
else if ((ulMemWidth == MBW_MEM_WID32) && !(lpHwCrtc->ulRageProCrtcCaps & RAGEPRO_CRTC_CAPS_SDRAM_21))
{
vMultiplyFixed(lpBandwidth, (LPFIXEDPOINT)&sFactorMem32);
if (lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XC)
{
sFactorMem32.Fractional = 64;
vMultiplyFixed(lpBandwidth, (LPFIXEDPOINT)&sFactorMem32);
}
}
}
/****************************Public*Routine*******************************\
*
* vMBW_GetTotalHTime()
*
* Get Total HTime
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetTotalHTime(HGCO hGCO, LPHORIZONTAL_TIME lpHTime, LPDEVMODE_INFO lpModeInfo, ULONG ulDisplayTypes)
{
BIOS_GENERAL_CRTC_TIMING sBiosGeneralCrtcTiming;
USHORT ausModeTableOffset[MAX_NO_OF_LCD_RES_TIMING];
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
PANEL_INFO PanelInfo;
DEVMODE_INFO sModeInfo = *lpModeInfo;
FIXEDPOINT sTotal;
FIXEDPOINT sDisp;
FIXEDPOINT sHalfHOverScan = {0, 0};
// FIXEDPOINT sHalfVOverScan = {0, 0};
FIXEDPOINT sFactorMem32 = {1, 192};
ULONG ulMemWidth;
ULONG ulMemClock;
FIXEDPOINT sPixelClock;
ULONG ulHBlankFactor;
ULONG ulVBlankFactor;
if ((ulDisplayTypes & HW_DISPLAY_TYPE_LCD) && !(ulDisplayTypes & HW_DISPLAY_TYPE_TV))
{
if ((lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XL) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XC))
{
sModeInfo.ulPelsWidth = (ULONG)lpHwCrtc->LCDPanelInfo.usHorizontalSize;
sModeInfo.ulPelsHeight = (ULONG)lpHwCrtc->LCDPanelInfo.usVerticalSize;
}
else
{
GetPanelInformationTable(hGCO, lpHwCrtc->BiosInfoTable.usOffsetToLcdParameterTable,
(LPUSHORT)ausModeTableOffset, (LPPANEL_INFO)&PanelInfo);
sModeInfo.ulPelsWidth = (ULONG) PanelInfo.usHorizontalSize;
sModeInfo.ulPelsHeight = (ULONG)PanelInfo.usVerticalSize;
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -