//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/****************************************************************************\
*
*  Module Name    rprombw.c
*
*  (c) 1998 ATI Technologies Inc.
*
*
*  LOG OF CHANGES
*
*  12-07-98   1.0 [TD] initial revision
*
\****************************************************************************/

#include "rprombw.h"
#include "crtcrpro.h"
#include "rprocrtc.h"
#include "rprod.h"


/****************************Private*Routine*******************************\
*
* ULONG MBW_GetFractional()
*
* Calculate Fractional Given Modulo and Denominator
* 
* return ulModulo * 256 / ulDenom
* 
* Note: ulModulo < ulDenom AND ulDenom > 0
*       
*
\**************************************************************************/
ULONG MBW_GetFractional(ULONG ulModulo, ULONG ulDenom)
{
  ULONG ulFract;

  if ((ulModulo >= ulDenom) || !ulDenom)
    return 0;

  ulModulo <<= 8;

  ulFract = ulModulo / ulDenom;

  // round to least significant bit in fractional
  ulModulo %= ulDenom;
  if (ulModulo > (ulDenom >> 1))
    ulFract++;

  return ulFract;
}



/****************************Private*Routine*******************************\
*
* vAddFixed()
*
* Calculate Addition of Two FIXEDPOINT Values 
* 
* Dest = Dest + Sour
*
* Note: This is an accumulation operation
*       
*
\**************************************************************************/

VOID vAddFixed(LPFIXEDPOINT lpDest, LPFIXEDPOINT lpSour)
{
  lpDest->Fractional += lpSour->Fractional;
  
  lpDest->Integral += lpSour->Integral;

  lpDest->Integral += (lpDest->Fractional & 0xFFFFFF00) >> 8;

  lpDest->Fractional &= 0x000000FF;
}



/****************************Private*Routine*******************************\
*
* ULONG CompareFixed()
*
* Compare Two FIXEDPOINT Values 
* 
* 
*
* Note: If Dest >= Sour, return 1. Else return 0. 
* 
*
\**************************************************************************/

ULONG CompareFixed(LPFIXEDPOINT lpDest, LPFIXEDPOINT lpSour)
{
  if ((lpDest->Integral > lpSour->Integral) || 
      ((lpDest->Integral == lpSour->Integral) &&
       (lpDest->Fractional >= lpSour->Fractional)))
  {
    return 1;
  }
  else
  {
    return 0;
  }
}



/****************************Private*Routine*******************************\
*
* vSubtractFixed()
*
* Subtract Sour from Dest if Dest >= Sour
* 
* 
*
* Note:
* 
*
\**************************************************************************/

VOID vSubtractFixed(LPFIXEDPOINT lpDest, LPFIXEDPOINT lpSour)
{
  if (CompareFixed(lpDest, lpSour))
  {
    lpDest->Integral -=  lpSour->Integral;

    if (lpDest->Fractional < lpSour->Fractional)
    {
      lpDest->Integral--;
      lpDest->Fractional += 256;
    }

    lpDest->Fractional -= lpSour->Fractional;
  }
}



/****************************Private*Routine*******************************\
*
* LONG vDiffFixed()
*
* Calculate Difference of Two FIXEDPOINT Values 
* 
* Return = Dest - Sour
*
* Note: Return value is long
*       
*
\**************************************************************************/

LONG vDiffFixed(LPFIXEDPOINT lpDest, LPFIXEDPOINT lpSour)
{
  LONG         lRetV;
  FIXEDPOINT   sTemp;

  if (CompareFixed(lpDest, lpSour))
  {
    sTemp.Integral = lpDest->Integral - lpSour->Integral;
    sTemp.Fractional = lpDest->Fractional;

    if (sTemp.Fractional < lpSour->Fractional)
    {
      sTemp.Integral--;
      sTemp.Fractional = lpDest->Fractional + 256;

    }

    sTemp.Fractional -= lpSour->Fractional;

    if (sTemp.Fractional >= 128)
    {
      sTemp.Integral++;
      sTemp.Fractional -= 128;
   
    }
    return sTemp.Integral;
  }
  else
  {
    sTemp.Integral = lpSour->Integral - lpDest->Integral;
    sTemp.Fractional = lpSour->Fractional;

    if (sTemp.Fractional < lpDest->Fractional)
    {
      sTemp.Integral--;
      sTemp.Fractional = lpSour->Fractional + 256;

    }

    sTemp.Fractional -= lpDest->Fractional;

    if (sTemp.Fractional >= 128)
      sTemp.Integral++;

    lRetV = -1 * sTemp.Integral; 

    return lRetV;
  }
}



/****************************Private*Routine*******************************\
*
* vMultiplyFixed()
*
* Calculate Product of Two FIXEDPOINT Values 
* 
* Dest = Dest * Sour
*
* Note: 
*       
*
\**************************************************************************/

VOID vMultiplyFixed(LPFIXEDPOINT lpDest, LPFIXEDPOINT lpSour)
{
  ULONG   ulIntegral;
  ULONG   ulFractional;
  ULONG   ulTemp;

  ulIntegral = lpDest->Integral * lpSour->Integral;

  ulTemp = lpDest->Integral * lpSour->Fractional;
  ulIntegral += ulTemp >> 8;
  ulFractional = ulTemp & 0x000000FF;

  ulTemp = lpSour->Integral * lpDest->Fractional;
  ulFractional += ulTemp & 0x000000FF;
  ulIntegral += ulFractional >> 8;
  ulFractional &= 0x000000FF;
  ulIntegral += ulTemp >> 8;

  ulTemp = lpDest->Fractional * lpSour->Fractional;
  ulIntegral += ulTemp >> 16;
  ulFractional += ulTemp >> 8;

  // round
  if ((ulTemp & 0xFF) >= 128)
    ulFractional++;

  ulIntegral += ulFractional >> 8;
  ulFractional &= 0x000000FF;

  lpDest->Integral = ulIntegral;
  lpDest->Fractional = ulFractional;
}

/****************************Private*Routine*******************************\
*
* vDivideFixed()
*
* Calculate Quotient of Two FIXEDPOINT Values 
* 
* Dest = Dest / Sour
*
* Note:  Pre-condition is Dest < 1000000 and Sour < 1000000
*       
*
\**************************************************************************/
VOID vDivideFixed(LPFIXEDPOINT lpDest, LPFIXEDPOINT lpSour)
{
  ULONG   ulNumer;
  ULONG   ulDenom;
  ULONG   ulModulo;

  if (!(lpSour->Integral || lpSour->Fractional))
    return;

  if ((lpDest->Integral & 0xFF000000) || (lpSour->Integral & 0xFF000000))
    return;

  ulNumer = (lpDest->Integral << 8) + lpDest->Fractional;
  ulDenom = (lpSour->Integral << 8) + lpSour->Fractional;

  lpDest->Integral = ulNumer / ulDenom;
  ulModulo = ulNumer % ulDenom;

  lpDest->Fractional = MBW_GetFractional(ulModulo, ulDenom);
}

/****************************Private*Routine*******************************\
*
* vMBW_GetBurstEff()
*
* Calculate Reciprocal of Burst Efficiency in Cycle per QWord 
* 
* Note: 
*       
*
\**************************************************************************/

VOID vMBW_GetBurstEff(LPFIXEDPOINT lpEff, ULONG ulBurstSize, ULONG ulMemIPC)
{
  ULONG   ulModulo;
  ULONG   ulBuff;

  lpEff->Integral = 1;
  lpEff->Fractional = 0;

  // calculate efficiency = (BurstSize*MEM_IPC + 2*MEM_PFC) / BurstSize
  if (ulBurstSize)
  {
    ulBuff = ulBurstSize * ulMemIPC + (MBW_MEM_PFC * 3 );//<< 1);
 
    lpEff->Integral = ulBuff / ulBurstSize;

    ulModulo = ulBuff % ulBurstSize;
    lpEff->Fractional = MBW_GetFractional(ulModulo, ulBurstSize);
  }
}



/****************************Private*Routine*******************************\
*
* vMBW_GetSclEff()
*
* Calculate Reciprocal of Scaler/Overlay Efficiency in Cycle per QWord 
* 
* Note: 
*       
*
\**************************************************************************/

VOID vMBW_GetSclEff(LPFIXEDPOINT lpEff, ULONG ulBurstSize, ULONG ulMemIPC)
{
  ULONG   ulModulo;
  ULONG   ulBuff;

  lpEff->Integral = 1;
  lpEff->Fractional = 0;

  // calculate efficiency = (BurstSize*MEM_IPC + 3*MEM_PFC) / BurstSize
  if (ulBurstSize)
  {
    ulBuff = ulBurstSize * ulMemIPC + 3 * MBW_MEM_PFC;

    lpEff->Integral = ulBuff / ulBurstSize;

    ulModulo = ulBuff % ulBurstSize;
    lpEff->Fractional = MBW_GetFractional(ulModulo, ulBurstSize);
  }
}



/****************************Private*Routine*******************************\
*
* vMBW_GetVidEff()
*
* Calculate Reciprocal of Video Efficiency in Cycle per QWord 
* 
* Note: 
*       
*
\**************************************************************************/

VOID vMBW_GetVidEff(LPFIXEDPOINT lpEff, ULONG ulVidFlush, ULONG ulMemIPC)
{
  vMBW_GetBurstEff(lpEff, ulVidFlush, ulMemIPC);
}



/****************************Private*Routine*******************************\
*
* vMBW_GetSubEff()
*
* Calculate Reciprocal of Subpicture Efficiency in Cycle per QWord 
* 
* Note: 
*       
*
\**************************************************************************/

VOID vMBW_GetSubEff(LPFIXEDPOINT lpEff, ULONG ulSubBurst, ULONG ulMemIPC)
{
  ULONG   ulModulo;
  ULONG   ulBuff;

  lpEff->Integral = 1;
  lpEff->Fractional = 0;

  // calculate efficiency = (SubBurst*MEM_IPC + 4*MEM_PFC) / SubBurst
  if (ulSubBurst)
  {
    ulBuff = ulSubBurst * ulMemIPC + (MBW_MEM_PFC << 2);

    lpEff->Integral = ulBuff / ulSubBurst;

    ulModulo = ulBuff % ulSubBurst;
    lpEff->Fractional = MBW_GetFractional(ulModulo, ulSubBurst);
  }
}



/****************************Private*Routine*******************************\
*
* vMBW_GetHBlankBurstEff()
*
* Calculate Reciprocal of Blank Burst Efficiency in Cycle per QWord 
* 
* Note: 
*       
*
\**************************************************************************/

VOID vMBW_GetHBlankBurstEff(LPFIXEDPOINT lpEff, ULONG ulBurstSize, ULONG ulMemIPC)
{
  vMBW_GetSclEff(lpEff, ulBurstSize, ulMemIPC);
}



/****************************Private*Routine*******************************\
*
* vMBW_GetMemBW()
*
* Calculate Memory Bandwidth in MBytes per Second
* 
* Note: 
*       
*
\**************************************************************************/

VOID vMBW_GetMemBW(LPFIXEDPOINT lpBW, ULONG ulMemClock, ULONG ulMemWidth, ULONG ulBandwidthFix)
{
  // Factor for Megabytes (1MHz = 1 000 000 Hz; 1MB = 1 048 576 Bytes) 
  FIXEDPOINT  sTemp = {0, 244};

  // MEM_BW = MEM_CLK * MEM_WID / 8
  lpBW->Integral = (ulMemClock * ulMemWidth) >> 3;
  lpBW->Fractional = 0;

  if (ulBandwidthFix)
    vMultiplyFixed(lpBW, &sTemp);
}



/****************************Private*Routine*******************************\
*
* vMBW_GetBW()
*
* Calculate Bandwidth in MBytes per Second
* 
* Note: 
*       
*
\**************************************************************************/

VOID vMBW_GetBW(LPFIXEDPOINT lpBandWidth, ULONG ulDispWidth, ULONG ulDispHeight,