📄 rprombw.c

📁 此代码为WCE5.0下显示器的源代码
💻 C
📖 第 1 页 / 共 5 页
字号:
* 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 + -