📄 rprombw.c
字号:
sHalfHOverScan.Integral = (sModeInfo.ulPelsWidth - lpModeInfo->ulPelsWidth) >> 1;
// sHalfVOverScan.Integral = (sModeInfo.ulPelsHeight - lpModeInfo->ulPelsHeight) >> 1;
if ((lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XL) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XC))
{
LoadDFPModeTableInfo(hGCO, (LPDEVMODE_INFO)&sModeInfo, (LPULONG)&ulDisplayTypes,
(LPBIOS_GENERAL_CRTC_TIMING) &sBiosGeneralCrtcTiming);
}
else
{
LoadLcdGeneralModeTableTimings(hGCO, (LPDEVMODE_INFO)&sModeInfo, (LPULONG)&ulDisplayTypes,
(LPBIOS_GENERAL_CRTC_TIMING) &sBiosGeneralCrtcTiming);
}
}
else if ((ulDisplayTypes & HW_DISPLAY_TYPE_TV) && !(ulDisplayTypes & HW_DISPLAY_TYPE_LCD))
{
LoadTvoGeneralModeTableTimings(hGCO, lpModeInfo, ulDisplayTypes,
(LPBIOS_GENERAL_CRTC_TIMING) &sBiosGeneralCrtcTiming);
}
else if ((ulDisplayTypes & HW_DISPLAY_TYPE_CRT) && !(ulDisplayTypes & HW_DISPLAY_TYPE_LCD)
&& !(ulDisplayTypes & HW_DISPLAY_TYPE_TV))
{
LoadCrtOnlyModeTableInfo(lpModeInfo, (LPBIOS_GENERAL_CRTC_TIMING) &sBiosGeneralCrtcTiming);
}
else
{
ASSERT(0);
return;
}
// pixel clock
sPixelClock.Integral = (ULONG) sBiosGeneralCrtcTiming.usPixelClock / 100;
sPixelClock.Fractional = MBW_GetFractional((ULONG)sBiosGeneralCrtcTiming.usPixelClock % 100, 100);
sTotal.Integral = (ULONG) sBiosGeneralCrtcTiming.usCRTC_H_TOTAL;
sTotal.Fractional = 0;
//if CRTC_H_TOTAL is less than CRTC_H_DISP set high bit of CRTC_H_TOTAL
if ( sBiosGeneralCrtcTiming.usCRTC_H_TOTAL < sBiosGeneralCrtcTiming.ucCRTC_H_DISP)
{
sTotal.Integral |= 0x00000100;
}
sDisp.Integral = (ULONG) sBiosGeneralCrtcTiming.ucCRTC_H_DISP;
sDisp.Fractional = 0;
vDivideFixed((LPFIXEDPOINT)&sTotal, (LPFIXEDPOINT)&sDisp);
// HBlank factor, (1+FACTOR) * DISP = TOTAL
ulHBlankFactor = sTotal.Fractional;
sTotal.Integral = (ULONG) sBiosGeneralCrtcTiming.usCRTC_V_TOTAL;
sTotal.Fractional = 0;
sDisp.Integral = (ULONG) sBiosGeneralCrtcTiming.usCRTC_V_DISP;
sDisp.Fractional = 0;
vDivideFixed((LPFIXEDPOINT)&sTotal, (LPFIXEDPOINT)&sDisp);
// VBlank factor, (1+FACTOR) * DISP = TOTAL
ulVBlankFactor = sTotal.Fractional;
vMBW_AvailHBlankTime(hGCO, &lpHTime->fHBlankTime, (LPDEVMODE_INFO)&sModeInfo, &sPixelClock, ulHBlankFactor);
vDivideFixed(&sHalfHOverScan, &sPixelClock);
// vDivideFixed((LPFIXEDPOINT)&sHalfVOverScan, &sPixelClock);
vAddFixed(&lpHTime->fHBlankTime, (LPFIXEDPOINT)&sHalfHOverScan);
vMBW_AvailHActiveTime(hGCO, &lpHTime->fHActiveTime, (LPDEVMODE_INFO)&sModeInfo, &sPixelClock, ulHBlankFactor);
ulMemClock = GetMemoryClock(hGCO);
ulMemWidth = GetMemWidth(hGCO);
if ((ulMemWidth == MBW_MEM_WID32) && (!lpHwCrtc->ucHFBOn) && !(lpHwCrtc->ulRageProCrtcCaps & RAGEPRO_CRTC_CAPS_SDRAM_21))
{
// If Memory clock > 124, modify this factor
// For 32-bit memory width MemClock is half
if (ulMemClock > 62)
{
sFactorMem32.Integral = 2;
sFactorMem32.Fractional = 0;
}
vMultiplyFixed(&lpHTime->fHActiveTime, (LPFIXEDPOINT)&sFactorMem32);
if (lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XC)
{
sFactorMem32.Integral = 1;
sFactorMem32.Fractional = 40;
vMultiplyFixed(&lpHTime->fHActiveTime, (LPFIXEDPOINT)&sFactorMem32);
sFactorMem32.Integral = 3;
sFactorMem32.Fractional = 80;
vMultiplyFixed(&lpHTime->fHBlankTime, (LPFIXEDPOINT)&sFactorMem32);
}
}
}
/****************************Public*Routine*******************************\
*
* vMBW_CalculateModeBandwidth()
*
* Calculate Display Bandwidth Request
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_CalculateModeBandwidth(HGCO hGCO, LPDEVMODE_INFO lpModeInfo, LPFIXEDPOINT lpBandwidth)
{
ULONG ulMemIPC;
ULONG ulDispFIFO;
ULONG ulHWCur_Size;
ULONG ulHWIcon_Size;
ulDispFIFO = MBW_MEM_FIFO;
ulHWCur_Size = MBW_HW_CUR_SIZE;
ulHWIcon_Size = MBW_HW_ICON_SIZE;
ulMemIPC = MBW_GetMemIPC(hGCO);
MBW_GetDispBW(lpBandwidth, ulDispFIFO, ulHWCur_Size,
ulHWIcon_Size, ulMemIPC, lpModeInfo);
}
/****************************Public*Routine*******************************\
*
* vMBW_CalculateModeHTime()
*
* Calculate Display Horinzontal Time Requests
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_CalculateModeHTime(HGCO hGCO, LPDEVMODE_INFO lpModeInfo, LPHORIZONTAL_TIME lpHTime)
{
ULONG ulMemIPC;
ULONG ulMemClock;
ULONG ulMemWidth;
ULONG ulDispFIFO;
ULONG ulHWCI_Size;
FIXEDPOINT sFactorClock143;
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
ulDispFIFO = MBW_MEM_FIFO;
ulHWCI_Size = MBW_HW_CUR_SIZE + MBW_HW_ICON_SIZE;
ulMemIPC = MBW_GetMemIPC(hGCO);
ulMemClock = GetMemoryClock(hGCO);
vMBW_GetDispHActiveTime(&lpHTime->fHActiveTime, ulDispFIFO, ulHWCI_Size,
lpModeInfo->ulPelsWidth, lpModeInfo->ulBitsPerPixel,
ulMemClock, ulMemIPC);
vMBW_GetDispHBlankTime(&lpHTime->fHBlankTime, ulDispFIFO, ulHWCI_Size,
ulMemClock, ulMemIPC);
ulMemWidth = GetMemWidth(hGCO);
if ((ulMemWidth == MBW_MEM_WID32) && !(lpHwCrtc->ulRageProCrtcCaps & RAGEPRO_CRTC_CAPS_SDRAM_21))
{
ulMemClock = GetMemoryClock(hGCO);
if (ulMemClock > 62)
{
if (lpModeInfo->ulBitsPerPixel >= 24)
{
if ((lpModeInfo->ulPelsWidth >= 800) && (lpModeInfo->ulPelsHeight >= 600))
{
sFactorClock143.Integral = 2;
sFactorClock143.Fractional = 0;
if ((lpModeInfo->ulPelsWidth >= 1024) && (lpModeInfo->ulPelsHeight >= 768))
{
sFactorClock143.Integral = 8;
sFactorClock143.Fractional = 128;
}
vAddFixed(&lpHTime->fHActiveTime, &sFactorClock143);
}
}
} else //task 5628, Fix badmode caused by lowing the mem clock.
{
if (lpModeInfo->ulBitsPerPixel >= 24)
{
if ((lpModeInfo->ulPelsWidth <= 800) && (lpModeInfo->ulPelsHeight <= 600))
{
sFactorClock143.Integral = 2;
sFactorClock143.Fractional = 0;
if ((lpModeInfo->ulPelsWidth >= 1024) && (lpModeInfo->ulPelsHeight >= 768))
{
sFactorClock143.Integral = 8;
sFactorClock143.Fractional = 128;
}
vAddFixed(&lpHTime->fHActiveTime, &sFactorClock143);
}
}
}
}
}
/****************************Public*Routine*******************************\
*
* vMBW_CalculateOverlayBandwidth()
*
* Calculate Bandwidth Request
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_CalculateOverlayBandwidth(HGCO hGCO, ULONG ulSclMode, LPDEVMODE_INFO lpOverlayMode,
LPFIXEDPOINT lpBandwidth)
{
ULONG ulMemIPC = 0;
ULONG ulSclBurst = 0;
if (ulSclMode == MBW_SCL_PLANAR_MODE)
ulSclBurst = 56; // hard code for scaler burst for planar mode
else if (ulSclMode == MBW_SCL_PACKED_MODE)
ulSclBurst = 256; // hard code for scaler burst for packed mode
ulMemIPC = MBW_GetMemIPC(hGCO);
vMBW_GetSclBW(lpBandwidth, ulSclBurst, ulSclMode, lpOverlayMode, ulMemIPC);
}
/****************************Public*Routine*******************************\
*
* vMBW_CalculateOverlayHTime()
*
* Calculate Horizontal Time Requests
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_CalculateOverlayHTime(HGCO hGCO, ULONG ulSclMode, LPDEVMODE_INFO lpOverlayMode,
LPHORIZONTAL_TIME lpHTime)
{
ULONG ulMemIPC = 0;
ULONG ulMemClock = 0;
ULONG ulSclBurst = 0;
if (ulSclMode == MBW_SCL_PLANAR_MODE)
ulSclBurst = 56; // hard code for scaler burst for planar mode
else if (ulSclMode == MBW_SCL_PACKED_MODE)
ulSclBurst = 256; // hard code for scaler burst for packed mode
ulMemClock = GetMemoryClock(hGCO);
ulMemIPC = MBW_GetMemIPC(hGCO);
vMBW_GetSclHActive(&lpHTime->fHActiveTime, ulSclBurst, ulSclMode,
lpOverlayMode->ulPelsWidth, lpOverlayMode->ulBitsPerPixel,
ulMemClock, ulMemIPC);
vMBW_GetSclHBlankTime(&lpHTime->fHBlankTime, ulSclMode, ulSclBurst,
ulMemClock, ulMemIPC);
}
/****************************Public*Routine*******************************\
*
* vMBW_CalculateVideoBandwidth()
*
* Calculate Video Capture Bandwidth Request
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_CalculateVideoBandwidth(HGCO hGCO, LPDEVMODE_INFO lpVideoMode, LPFIXEDPOINT lpBandwidth)
{
ULONG ulMemIPC;
ULONG ulVidFlush = MBW_VID_FLUSH; // hard code for video flush
ulMemIPC = MBW_GetMemIPC(hGCO);
vMBW_GetVidBW(lpBandwidth, ulVidFlush, lpVideoMode->ulPelsWidth,
ulMemIPC);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetLcdMaxRes()
*
* Get LCD MAX resolution
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetLcdMaxRes(HGCO hGCO, LPDEVMODE_INFO lpModeInfo, ULONG ulDisplayTypes)
{
USHORT ausModeTableOffset[MAX_NO_OF_LCD_RES_TIMING];
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
PANEL_INFO PanelInfo;
if ((ulDisplayTypes & HW_DISPLAY_TYPE_LCD) && !(ulDisplayTypes & HW_DISPLAY_TYPE_TV))
{
if ((lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XL) ||
(lpHwCrtc->HwAsicId.ulChipFamily == FAMILY_RAGE_XC))
{
lpModeInfo->ulPelsWidth = (ULONG)lpHwCrtc->LCDPanelInfo.usHorizontalSize;
lpModeInfo->ulPelsHeight = (ULONG)lpHwCrtc->LCDPanelInfo.usVerticalSize;
}
else
{
GetPanelInformationTable(hGCO, lpHwCrtc->BiosInfoTable.usOffsetToLcdParameterTable,
(LPUSHORT)ausModeTableOffset, (LPPANEL_INFO)&PanelInfo);
lpModeInfo->ulPelsWidth = (ULONG) PanelInfo.usHorizontalSize;
lpModeInfo->ulPelsHeight = (ULONG)PanelInfo.usVerticalSize;
}
}
}
VOID vMBW_GetCurrentHAvailableTime(HGCO hGCO, ULONG ulController, LPHORIZONTAL_TIME lpHAvailableTime)
{
FIXEDPOINT sPixelClock;
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
DEVMODE_INFO sMaxMode;
FIXEDPOINT sHBlankFactor;
FIXEDPOINT sDisp;
ULONG ulTemp;
sPixelClock.Integral = VClockValue(hGCO, ulController); // in 10KHz
// divided by 100, that is, in MHz
sPixelClock.Integral /= 100;
sPixelClock.Fractional = MBW_GetFractional(sPixelClock.Integral % 100, 100);
if ((lpHwCrtc->ulGCOSupportedRegSet & RAGE_LTPRO_REGISTER_SET) &&
(lpHwCrtc->ulGCOSupportedRegSet & RAGE_PRO_CRTC2_REGISTER_SET))
{
// Setup the LCD_REG_INDEX in LCD_INDEX register to do read/write operation on LCD_GEN_CTRL
ulTemp = MMREADULONG(lpHwCrtc->HwAsicId.lpMMR, LCD_INDEX);
ulTemp &= lpHwCrtc->ulLCDIndexRegisterMask;
MMWRITEULONG(lpHwCrtc->HwAsicId.lpMMR, LCD_INDEX, (ulTemp | LCD_INDEX_lcdGenCtrlReg));
ulTemp = MMREADULONG(lpHwCrtc->HwAsicId.lpMMR, LCD_DATA);
if (ulController == PRIMARY_CONTROLLER)
{
ulTemp &= ~LCD_GEN_CTL_CrtcRWSelect; // All CRTC registers reads/writes go to
// primary CRTC
}
else if (ulController == SECONDARY_CONTROLLER)
{
ulTemp |= LCD_GEN_CTL_CrtcRWSelect; // All CRTC registers reads/writes go to
// secondary CRTC
}
MMWRITEULONG(lpHwCrtc->HwAsicId.lpMMR, LCD_DATA, ulTemp);
}
ulTemp = MMREADULONG(lpHwCrtc->HwAsicId.lpMMR, CRTC_H_TOTAL_DISP);
// H_TOTAL
lpHAvailableTime->fHActiveTime.Integral = ((ulTemp & CRTC_H_TOTAL_DISP__CRTC_H_TOTAL_MASK) + 1) << 3;
lpHAvailableTime->fHActiveTime.Fractional = 0;
// H_DISP
sDisp.Integral = (((ulTemp & CRTC_H_TOTAL_DISP__CRTC_H_DISP_MASK) >> 16) + 1) << 3;
sDisp.Fractional = 0;
if (!sDisp.Integral)
return;
// HBLANK_FACTOR
sHBlankFactor.Fractional = MBW_GetFractional(lpHAvailableTime->fHActiveTime.Integral % sDisp.Integral, sDisp.Integral);
sHBlankFactor.Integral = 0;
if ((lpHwCrtc->ulCurrentDeviceMap[ulController] & HW_DISPLAY_TYPE_LCD) ||
(lpHwCrtc->ulCurrentDeviceMap[ulController] & HW_DISPLAY_TYPE_DFP))
{
if (!(lpHwCrtc->ulCurrentDeviceMap[ulController] & HW_DISPLAY_EXPANSION))
{
lpHAvailableTime->fHBlankTime = lpHAvailableTime->fHActiveTime;
// HTOTAL - LCD_SRC_WID
vSubtractFixed(&lpHAvailableTime->fHBlankTime, &sDisp);
}
else
{
vMBW_GetLcdMaxRes(hGCO, &sMaxMode, lpHwCrtc->ulCurrentDeviceMap[ulController]);
lpHAvailableTime->fHBlankTime.Integral = sMaxMode.ulPelsWidth;
lpHAvailableTime->fHBlankTime.Fractional = 0;
// DISP_WID * HBLANK_FACTOR
vMultiplyFixed(&lpHAvailableTime->fHBlankTime, &sHBlankFactor);
}
}
else
{
lpHAvailableTime->fHBlankTime = sDisp;
// DISP_WID * HBLANK_FACTOR
vMultiplyFixed(&lpHAvailableTime->fHBlankTime, &sHBlankFactor);
}
// AVAIL_HActiveTime
vDivideFixed(&lpHAvailableTime->fHActiveTime, &sPixelClock);
// AVAIL_HBlankTime
vDivideFixed(&lpHAvailableTime->fHBlankTime, &sPixelClock);
}
/****************************Public*Routine*******************************\
*
* vMBW_CalculateVideoHTime()
*
* Calculate Video Capture Horizontal Time Requests
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_CalculateVideoHTime(HGCO hGCO, LPDEVMODE_INFO lpVideoMode, LPHORIZONTAL_TIME lpHTime)
{
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
HORIZONTAL_TIME sHAvailableTime;
HORIZONTAL_TIME sTemp;
ULONG ulRegRead;
ULONG ulMemClock;
ULONG ⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -