?? rprombw.c
字號:
FIXEDPOINT sTemp;
vMBW_GetBurstEff(&sEff, ulBurstSize, ulMemIPC);
// QW_WID = WID * BPP / 64
lpHActiveTime->Integral = ulWidth * ulBPP >> 6;
lpHActiveTime->Fractional = 0;
// (1 / EFF) * QW_WID
vMultiplyFixed(lpHActiveTime, &sEff);
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
// Divided by MEM_CLK
vDivideFixed(lpHActiveTime, &sTemp);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetHFBHActiveTime()
*
* Calculate Half Frame Buffer Horizontal Active Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetHFBHActiveTime(LPFIXEDPOINT lpHActiveTime, ULONG ulHFBFIFO,
ULONG ulHFBWid, ULONG ulBPP, ULONG ulMemClock,
ULONG ulMemIPC)
{
FIXEDPOINT sFactor;
vMBW_GetHActiveTime(lpHActiveTime, ulHFBFIFO, ulHFBWid, ulBPP, ulMemClock,
ulMemIPC);
sFactor.Integral = 2;
sFactor.Fractional = 0;
vMultiplyFixed(lpHActiveTime, &sFactor);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetSubHActiveTime()
*
* Calculate DVD Subpicture Horizontal Active Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetSubHActiveTime(LPFIXEDPOINT lpHActiveTime, ULONG ulSubBurst,
ULONG ulSubWid, ULONG ulBPP, ULONG ulMemClock,
ULONG ulMemIPC)
{
vMBW_GetHActiveTime(lpHActiveTime, ulSubBurst, ulSubWid, ulBPP, ulMemClock,
ulMemIPC);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetSclHActive()
*
* Calculate Scaler / Overlay Horizontal Active Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetSclHActive(LPFIXEDPOINT lpHActiveTime, ULONG ulSclBurst, ULONG ulSclMode,
ULONG ulSclWidth, ULONG ulSclBPP, ULONG ulMemClock,
ULONG ulMemIPC)
{
FIXEDPOINT sTemp;
if (ulSclMode == MBW_SCL_PLANAR_MODE)
{
// planar mode
vMBW_GetSclEff(&sTemp, ulSclBurst, ulMemIPC);
}
else if (ulSclMode == MBW_SCL_PACKED_MODE)
{
// packed mode - assume page size of 256 * 64 bits
vMBW_GetSclEff(&sTemp, 256, ulMemIPC);
}
// SCL_QW_WID
lpHActiveTime->Integral = ulSclWidth * ulSclBPP / 64;
lpHActiveTime->Fractional = 0;
// (1 / SCL_EFF) * SCL_QW_WID
vMultiplyFixed(lpHActiveTime, &sTemp);
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
// (1 / SCL_EFF) * SCL_QW_WID / MEM_CLK
vDivideFixed(lpHActiveTime, &sTemp);
}
/****************************Public*Routine*******************************\
*
* ULONG MBW_ReqHActiveTime()
*
* Calculate Required Horizontal Active Time in Micro Second
*
* Note: lpHActiveTime with output fixed-point value
* function return ULONG value
*
\**************************************************************************/
ULONG MBW_ReqHActiveTime(HGCO hGCO, LPFIXEDPOINT lpHActiveTime, ULONG ulMemClock)
{
FIXEDPOINT sTemp;
FIXEDPOINT sHTotalTime;
DEVMODE_INFO sModeInfo = {0, 1600, 1200, 32, 60};
ULONG ulHWCI_Size;
ULONG ulMemIPC = 1; // hard code
ULONG ulDisp1FIFO = 32; // hard code
ULONG ulDisp1Width = 1600; // hard code
ULONG ulDisp1BPP = 32; // hard code
ULONG ulDisp2FIFO = 32; // hard code
ULONG ulDisp2Width = 1600; // hard code
ULONG ulDisp2BPP = 32; // hard code
ULONG ulVidFlush = 32; // hard code
ULONG ulVidClock = 100; // hard code
ULONG ulVidWidth = 720; // hard code
ULONG ulHFBFIFO = 8; // hard code
ULONG ulHFBWidth = 32; // hard code
ULONG ulSubBurst = 32; // hard code
ULONG ulSubWidth = 32; // hard code
ULONG ulSclBurst = 32; // hard code
ULONG ulSclWidth = 720; // hard code
ULONG ulSclMode = MBW_SCL_PLANAR_MODE; // hard code
#define HWCUR1_SIZE 2
#define HWICON1_SIZE 4
#define HWCUR2_SIZE 2
#define HWICON2_SIZE 4
ulHWCI_Size = HWCUR1_SIZE + HWICON1_SIZE;
vMBW_GetDispHActiveTime(lpHActiveTime, ulDisp1FIFO, ulHWCI_Size, ulDisp1Width,
ulDisp1BPP, ulMemClock, ulMemIPC);
ulHWCI_Size = HWCUR2_SIZE + HWICON2_SIZE;
vMBW_GetDispHActiveTime(&sTemp, ulDisp2FIFO, ulHWCI_Size, ulDisp2Width,
ulDisp2BPP, ulMemClock, ulMemIPC);
vAddFixed(lpHActiveTime, &sTemp);
// vMBW_AvailHActiveTime(hGCO, &sHTotalTime, &sModeInfo);
vMBW_GetVidHActiveTime(&sTemp, ulVidFlush, ulVidWidth,
&sHTotalTime, ulMemClock, ulMemIPC);
vAddFixed(lpHActiveTime, &sTemp);
vMBW_GetHFBHActiveTime(&sTemp, ulHFBFIFO, ulHFBWidth, ulDisp2BPP, ulMemClock,
ulMemIPC);
vAddFixed(lpHActiveTime, &sTemp);
vMBW_GetSubHActiveTime(&sTemp, ulSubBurst, ulSubWidth, ulDisp2BPP, ulMemClock,
ulMemIPC);
vAddFixed(lpHActiveTime, &sTemp);
vMBW_GetSclHActive(&sTemp, ulSclBurst, ulSclMode, ulSclWidth, ulDisp2BPP,
ulMemClock, ulMemIPC);
vAddFixed(lpHActiveTime, &sTemp);
if (lpHActiveTime->Fractional >= 128)
return lpHActiveTime->Integral + 1;
else
return lpHActiveTime->Integral;
}
/****************************Public*Routine*******************************\
*
* ULONG MBW_VGATextReqHActiveTime()
*
* Calculate VGA Text Required Horizontal Active Time in Micro Second
*
* Note: lpHActiveTime with output fixed-point value
* function return ULONG value
*
\**************************************************************************/
ULONG MBW_VGATextReqHActiveTime(HGCO hGCO, LPFIXEDPOINT lpHActiveTime, LPDEVMODE_INFO lpModeInfo,
ULONG ulMemClock, ULONG ulMemIPC, LPFIXEDPOINT lpPixelClock)
{
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
FIXEDPOINT sEff;
FIXEDPOINT sPixClk;
FIXEDPOINT sOverhead;
FIXEDPOINT sTemp;
ULONG ulDispFIFO = 32; // hard code
#define HWICON_SIZE 4
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);
// assume 640*480 worst case mode - that is 80 characters per line
// (1 / CHARACTER_EFF) * 80
vMBW_GetBurstEff(&sEff, ulDispFIFO, ulMemIPC);
lpHActiveTime->Integral = 80;
lpHActiveTime->Fractional = 0;
vMultiplyFixed(lpHActiveTime, &sEff);
// (1 / FONT_EFF) * 80
vMBW_GetBurstEff(&sEff, 1, ulMemIPC);
sTemp.Integral = 80;
sTemp.Fractional = 0;
vMultiplyFixed(&sTemp, &sEff);
vAddFixed(lpHActiveTime, &sTemp);
// (1 / HWICON_EFF) * HWICON_SIZE
vMBW_GetBurstEff(&sEff, HWICON_SIZE, ulMemIPC);
sTemp.Integral = HWICON_SIZE;
sTemp.Fractional = 0;
vMultiplyFixed(&sTemp, &sEff);
vAddFixed(lpHActiveTime, &sTemp);
// Divided by MEM_CLK
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
vDivideFixed(lpHActiveTime, &sTemp);
// Add OVERHEAD
vAddFixed(lpHActiveTime, &sOverhead);
if (lpHActiveTime->Fractional >= 128)
return lpHActiveTime->Integral + 1;
else
return lpHActiveTime->Integral;
}
/****************************Private*Routine*******************************\
*
* vMBW_AvailHBlankTime()
*
* Calculate Available Blank Time in Micro Second
*
* Note: lpBlankTime with output fixed-point value
* function return ULONG value
*
\**************************************************************************/
VOID vMBW_AvailHBlankTime(HGCO hGCO, LPFIXEDPOINT lpHBlankTime, LPDEVMODE_INFO lpModeInfo,
LPFIXEDPOINT lpPixelClock, ULONG ulHBlankFactor)
{
FIXEDPOINT sTemp;
lpHBlankTime->Integral = 0;
lpHBlankTime->Fractional = ulHBlankFactor;
sTemp.Integral = lpModeInfo->ulPelsWidth;
sTemp.Fractional = 0;
vMultiplyFixed(lpHBlankTime, &sTemp);
vDivideFixed(lpHBlankTime, lpPixelClock);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetDispHBlankTime()
*
* Calculate Display Horizontal Blank Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetDispHBlankTime(LPFIXEDPOINT lpHBlankTime, ULONG ulDispFIFO,
ULONG ulHWCI_Size, ULONG ulMemClock,
ULONG ulMemIPC)
{
FIXEDPOINT sDispEff;
FIXEDPOINT sHWCIEff;
FIXEDPOINT sTemp;
vMBW_GetHBlankBurstEff(&sDispEff, ulDispFIFO, ulMemIPC);
vMBW_GetHBlankBurstEff(&sHWCIEff, ulHWCI_Size, ulMemIPC);
// (1/DISP_EFF) * DISP_FIFO
*lpHBlankTime = sDispEff;
sTemp.Integral = MBW_DISP_FIFO;
sTemp.Fractional = 0;
vMultiplyFixed(lpHBlankTime, &sTemp);
// (1/HWCI_EFF) * HWCI_SIZE
sTemp.Integral = ulHWCI_Size;
sTemp.Fractional = 0;
vMultiplyFixed(&sHWCIEff, &sTemp);
// (1/DISP_EFF) * DISP_FIFO + (1/HWCI_EFF) * HWCI_SIZE
vAddFixed(lpHBlankTime, &sHWCIEff);
// Divided by MEM_CLK
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
vDivideFixed(lpHBlankTime, &sTemp);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetVideoHBlankTime()
*
* Calculate Horizontal Video Blank Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetVideoHBlankTime(LPFIXEDPOINT lpHBlankTime, ULONG ulVidFlush,
LPFIXEDPOINT lpAvailHBlankTime, ULONG ulMemClock,
ULONG ulVidWid, ULONG ulMemIPC)
{
FIXEDPOINT sMemBw;
FIXEDPOINT sTemp;
if (!ulMemIPC)
return;
// VID_BW
vMBW_GetVidBW(&sTemp, ulVidFlush, ulVidWid, ulMemIPC);
// MEM_BW = MEM_CLK * 8 / MEM_IPC
sMemBw.Integral = (ulMemClock << 3) / ulMemIPC;
sMemBw.Fractional = 0;
// VID_PORTION = VID_BW / MEM_BW
vDivideFixed(&sTemp, &sMemBw);
*lpHBlankTime = *lpAvailHBlankTime;
// VID_PORTION * HBLANK_TIME
vMultiplyFixed(lpHBlankTime, &sTemp);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetHBlankTime()
*
* Calculate Blank Time in Micro Second for Half Frame Buffer
* and Subpicture
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetHBlankTime(LPFIXEDPOINT lpHBlankTime, ULONG ulBurstSize,
ULONG ulMemClock, ULONG ulMemIPC)
{
FIXEDPOINT sEff;
FIXEDPOINT sTemp;
vMBW_GetBurstEff(&sEff, ulBurstSize, ulMemIPC);
*lpHBlankTime = sEff;
sTemp.Integral = ulBurstSize;
sTemp.Fractional = 0;
vMultiplyFixed(lpHBlankTime, &sTemp);
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
vDivideFixed(lpHBlankTime, &sTemp);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetHFBHBlankTime()
*
* Calculate Horizontal Half Frame Buffer Blank Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetHFBHBlankTime(LPFIXEDPOINT lpHBlankTime, ULONG ulHFBFIFO, ULONG ulMemClock,
ULONG ulMemIPC)
{
vMBW_GetHBlankTime(lpHBlankTime, ulHFBFIFO, ulMemClock, ulMemIPC);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetSubHBlankTime()
*
* Calculate Horizontal Subpicture Blank Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetSubHBlankTime(LPFIXEDPOINT lpHBlankTime, ULONG ulSubBurst, ULONG ulMemClock,
ULONG ulMemIPC)
{
vMBW_GetHBlankTime(lpHBlankTime, ulSubBurst, ulMemClock, ulMemIPC);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetSclHBlankTime()
*
* Calculate Horizontal Subpicture Blank Time in Micro Second
*
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -