rprombw.c

此代码为WCE5.0下显示器的源代码

  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
*