autofunc.c

完整的软件学习--显示器驱动视频软件

  BYTE retry=8;
  BYTE adcStatus;
  BYTE atgFlags=0;

  maxRGain=maxGGain=maxBGain=0xFF;
  minRGain=minGGain=minBGain=0;

  while (retry--)
    { rGain=((WORD)maxRGain+minRGain)/2;
      gGain=((WORD)maxGGain+minGGain)/2;
      bGain=((WORD)maxBGain+minBGain)/2;
      mStar_AdjustAdcGain(rGain, gGain, bGain);
      Delay1ms(vsyncTime);
      WaitAutoStatusReady(ATGCTRL, ATGR_B);
      adcStatus=mStar_ReadByte(ATGCTRL);
#if MSTMCU
	#if SingleBoard
	if (adcStatus&MAXB_B)
	#else
	if (adcStatus&MAXR_B)
	#endif
#else
	if (adcStatus&MAXR_B)
#endif	
        rGain--;
      else
        rGain++;

      if (adcStatus&MAXG_B)
        gGain--;
      else
      	gGain++;

#if MSTMCU
	#if SingleBoard
	if (adcStatus&MAXR_B)
	#else
	if (adcStatus&MAXB_B)
	#endif
#else
	if (adcStatus&MAXB_B)
#endif	
        bGain--;

      else
      	bGain++;

      if (adcStatus&(MAXR_B|MAXG_B|MAXB_B))
      	atgFlags|=OverFlow;
      else
      	atgFlags|=NoneOverFlow;
      mStar_AdjustAdcGain(rGain, gGain, bGain);
      Delay1ms(vsyncTime);
      WaitAutoStatusReady(ATGCTRL, ATGR_B);
      adcStatus=mStar_ReadByte(ATGCTRL);
#if MSTMCU
	#if SingleBoard
      	if (adcStatus&MAXB_B)	
	#else
	if (adcStatus&MAXR_B)
	#endif
#else
      if (adcStatus&MAXR_B)
#endif
        maxRGain=rGain+1;
      else
      	minRGain=rGain-1;

      if (adcStatus&MAXG_B)
        maxGGain=gGain+1;
      else
      	minGGain=gGain-1;

#if MSTMCU
	#if SingleBoard
      	if (adcStatus&MAXR_B)
	#else
      	if (adcStatus&MAXB_B)
	#endif
#else
      if (adcStatus&MAXB_B)
#endif
        maxBGain=bGain+1;
      else
      	minBGain=bGain-1;

      if (CheckSyncLoss())
      	return FALSE;
      if (adcStatus&(MAXR_B|MAXG_B|MAXB_B))
      	atgFlags|=OverFlow;
      else
      	atgFlags|=NoneOverFlow;
    }

  if ((atgFlags&0xC0)!=0xC0)
    return FALSE;
 #if Fujitsu//Fujitsu_MST8111B_NoAudio_AU_EG01
  UserPrefAdcRedGain=((WORD)(rGain-1))*91/100;
  UserPrefAdcGreenGain=((WORD)(gGain-1))*91/100;
  UserPrefAdcBlueGain=((WORD)(bGain-1))*91/100;
 #else
  UserPrefAdcRedGain=rGain-1;
  UserPrefAdcGreenGain=gGain-1;
  UserPrefAdcBlueGain=bGain-1;
 #endif
  mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);

  return TRUE;
}

Bool mStar_AutoAdjustAdcOffset(BYTE vsyncTime)
{ BYTE rOffset, gOffset, bOffset;
  BYTE maxROffset, maxGOffset, maxBOffset;
  BYTE minROffset, minGOffset, minBOffset;
  BYTE retry=8;
  BYTE adcStatus;
  BYTE atgFlags=0;
 
  maxROffset=maxGOffset=maxBOffset=0xFF;
  minROffset=minGOffset=minBOffset=0;
 
  while (retry--)
    { rOffset=((WORD)maxROffset+minROffset)/2;
      gOffset=((WORD)maxGOffset+minGOffset)/2;
      bOffset=((WORD)maxBOffset+minBOffset)/2;
      mStar_AdjustAdcOffset(rOffset, gOffset, bOffset);
      Delay1ms(vsyncTime);
      WaitAutoStatusReady(ATGCTRL, ATGR_B);
      adcStatus=mStar_ReadByte(ATGST);
      if (adcStatus&MINR_B)
        rOffset++;
      else
        rOffset--;
 
      if (adcStatus&MING_B)
        gOffset++;
      else
       gOffset--;
 
      if (adcStatus&MINB_B)
        bOffset++;
      else
       bOffset--;
 
      if (adcStatus&MINR_B)
       atgFlags|=UnderFlowR;
      else
       atgFlags|=NoneUnderFlowR;
      if (adcStatus&MING_B)
       atgFlags|=UnderFlowG;
      else
       atgFlags|=NoneUnderFlowG;
      if (adcStatus&MINB_B)
       atgFlags|=UnderFlowB;
      else
       atgFlags|=NoneUnderFlowB;
      mStar_AdjustAdcOffset(rOffset, gOffset, bOffset);
      Delay1ms(vsyncTime);
      WaitAutoStatusReady(ATGCTRL, ATGR_B);
      adcStatus=mStar_ReadByte(ATGST);
      if (adcStatus&MINR_B)
        minROffset=rOffset-1;
      else
       maxROffset=rOffset+1;
 
      if (adcStatus&MING_B)
        minGOffset=gOffset-1;
      else
       maxGOffset=gOffset+1;
 
      if (adcStatus&MINB_B)
        minBOffset=bOffset-1;
      else
       maxBOffset=bOffset+1;
 
      if (CheckSyncLoss())
       return FALSE;
      if (adcStatus&MINR_B)
       atgFlags|=UnderFlowR;
      else
       atgFlags|=NoneUnderFlowR;
      if (adcStatus&MING_B)
       atgFlags|=UnderFlowG;
      else
       atgFlags|=NoneUnderFlowG;
      if (adcStatus&MINB_B)
       atgFlags|=UnderFlowB;
      else
       atgFlags|=NoneUnderFlowB;
    }

  #if 1//(!PanelAUEN02&&!PanelAUM190EN03&&!PanelAUM190EN04)
  if ((atgFlags&0xFC)!=0xFC)
  	{
  	DebugAddress=0x00;
       return FALSE;
  	}
  #endif
 
#if (PanelAUEN02|PanelAUM190EN03|PanelAUM190EN04|PanelLTM190EX_L01)
  UserPrefAdcRedOffset=rOffset;
  UserPrefAdcGreenOffset=gOffset-1;
  UserPrefAdcBlueOffset=bOffset;
#else
  UserPrefAdcRedOffset=rOffset+1;
  UserPrefAdcGreenOffset=gOffset+1;
  UserPrefAdcBlueOffset=bOffset+1;
#endif  
  mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);
 
  return TRUE;
}

//==================================================================
Bool mStar_AutoAdcColor(BYTE vsyncTime)
{
    BYTE result;

    if (SrcInputType==Input_Digital)
        return FALSE;

    mStar_WriteByte(ATGCTRL, 0x11); // enable auto Gain
    mStar_WriteByte(REGBK, REGBANKADC);
    mStar_WriteByte(DBFC, 0);
    mStar_WriteByte(REGBK, REGBANKSCALER);

//  vsyncTime=GetVSyncTime();

    result=mStar_AutoAdjustAdcOffset(vsyncTime);
    if (!result)
        mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);
  
    result=mStar_AutoAdjustAdcGain(vsyncTime);
    if (!result)
        mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);

    mStar_WriteByte(REGBK, REGBANKADC);
    mStar_WriteByte(DBFC, 1);
    mStar_WriteByte(REGBK, REGBANKSCALER);
    mStar_WriteByte(ATGCTRL, 0); // enable auto Gain

    return result;
}

//==================================================================
#if 0//MSTMCU
Bool mStar_AutoGeomtry(void)
{ Bool result=TRUE;
  BYTE vsyncTime;

  vsyncTime=GetVSyncTime();
#if 0//AOC
  //if (FactoryModeFlag)
    { mStar_AutoAdcColor(vsyncTime);
      if (InputTimingChangeFlag)
      	return FALSE;
    }
#endif
  if (SrcInputType<Input_Digital)
    { // Automatically adjusting Data threshold
      mStar_WriteByte(DBFC, 0);
      //mStar_AdjustAdcGain(0x80, 0x80, 0x80);
      //mStar_AdjustAdcOffset(0x90, 0x90, 0x90);
      // auto adjust threshold
      AutoSetDataThreshold(vsyncTime+3);//*2);
      if (InputTimingChangeFlag)
      	{ result=FALSE;
          goto AutoGeomtryFailed;
      	}
      // auto adjust htotal
      result=mStar_AutoHTotal(vsyncTime+3);
      if (InputTimingChangeFlag)
      	{ result=FALSE;
          goto AutoGeomtryFailed;
      	}
      // auto adjust phase
      if (result)
        { mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);
          mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);
          mStar_AutoPhase(vsyncTime+6);//*3);
      	}
      if (InputTimingChangeFlag)
      	{ result=FALSE;
          goto AutoGeomtryFailed;
      	}
      mStar_WriteByte(DBFC, 5);
      Delay1ms(vsyncTime*2);
      mStar_AutoPosition();
    }
AutoGeomtryFailed:

  mStar_WriteByte(AOVDV, 0x20);
  mStar_WriteByte(DBFC, 5);
  mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);
  mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);

  return result;
}

#else
Bool mStar_AutoGeomtry(void)
{
    Bool result=TRUE;
    BYTE vsyncTime;

    vsyncTime=GetVSyncTime();
	
#if 0
    if (FactoryModeFlag)
    {
        mStar_AutoAdcColor(vsyncTime);
        if (InputTimingChangeFlag)
      	    return FALSE;
    }
#endif

    mStar_WriteByte(DBFC, 0);
    if (SrcInputType!=Input_Digital)
    {
        // Automatically adjusting Data threshold
	#if !PanelAUEN02
        mStar_AdjustAdcGain(0x80, 0x80, 0x80);
        mStar_AdjustAdcOffset(0x90, 0x90, 0x90);
	#endif
        // auto adjust threshold
    #if !QuickAuto
        AutoSetDataThreshold(vsyncTime*2);
    #else
        mStar_WriteByte(AOVDV, ThresholdLevel<<4);
    #endif
	    if (CheckPowerKeyStatus())
      	{
      	    result=FALSE;
            goto AutoGeomtryFailed;
      	}
        if (InputTimingChangeFlag)
      	{ 
      	    result=FALSE;
            goto AutoGeomtryFailed;
      	}
        // auto adjust htotal
        result=mStar_AutoHTotal(vsyncTime*2);
        if (InputTimingChangeFlag)
      	{
      	    result=FALSE;
            goto AutoGeomtryFailed;
      	}
	    if (CheckPowerKeyStatus())
      	{
      	    result=FALSE;
            goto AutoGeomtryFailed;
      	}
        // auto adjust phase
        if (result)
        {
          mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);
          mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);
          mStar_AutoPhase(vsyncTime*2);
        }
        if (InputTimingChangeFlag)
      	{
        	result=FALSE;
            goto AutoGeomtryFailed;
      	}
        Delay1ms(vsyncTime*2);
        mStar_AutoPosition();
    }
AutoGeomtryFailed:

    mStar_WriteByte(AOVDV, ThresholdLevel<<4);
    mStar_WriteByte(DBFC, 5);
    mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);
    mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);
  
    return result;
}
#endif

Bool mStar_AutoColor(void)
{ 
    Bool result;
    BYTE vsyncTime;

  vsyncTime=GetVSyncTime();
  result=mStar_AutoAdcColor(vsyncTime*2+3);
    if (InputTimingChangeFlag)
        return FALSE;
    return result;
}