mstar.c

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

#if NEWIC_18B
  //Modified by Matt for New IC @ 20050218
  if(SrcInputType==Input_Digital)
  {
	if(mStar_ReadOSDByte(IOSDC1)==0)	//Matt 20050527 Noise when no signal
		mStar_WriteByte(PDMD,0x03|VDD2LOW);  //2005-11-12 Update
	mStar_WriteByte(ISELECT, regByte);
	mStar_WriteByte(PDMD,0x00|VDD2LOW);   //2005-11-12 Update
  }
  else
  { 
	mStar_WriteByte(ISELECT, regByte);//|NIS_B);//enter into freerun mode  fendy 3005 07 20

  }
#else
  mStar_WriteByte(ISELECT, regByte);
#endif


  mStar_WriteByte(SWRST, GPR_B|ADCR_B); // enable software reset function to clear ADC & Graphic port RO register
 
  Delay1ms(2);
  mStar_WriteByte(SWRST, 0); // disable software reset
  Delay1ms(20); // delay over 1 frame time to wait for status register is ready
}

//*******************************************************************
// Function Name: mStar_SetCaptureWindow
//
// Decscription: setup input capture window for display
//
// caller: mSar_WriteWord(), mStar_ReadWord() in ms_rwreg.c
///
// callee: mStar_SetupMode() in mstar.c
//*******************************************************************
Bool mStar_SetCaptureWindow(void)
{ WORD width, height;

  if (SrcInputType==Input_Digital)
    {
    #if PanelAUM170XW01  //zwtan modify for dvi 1280*768 no video.
	      // read input width & height repeatly to confirm if DVI is stable
       UserPrefHStart=mStar_ReadWord(AOHST_H); // get hsync DE start
       UserPrefVStart=mStar_ReadWord(AOVST_H); // get vsync DE start
       width=mStar_ReadWord(AOHEND_H)-UserPrefHStart+1; // get DE width
       height=mStar_ReadWord(AOVEND_H)-UserPrefVStart+1; // get DE Height
      // check if resolution is correct
     #else
    BYTE retry;
      // read input width & height repeatly to confirm if DVI is stable
      for (retry=0; retry<5; retry++)
      	{ UserPrefHStart=mStar_ReadWord(AOHST_H); // get hsync DE start
          UserPrefVStart=mStar_ReadWord(AOVST_H); // get vsync DE start
          width=mStar_ReadWord(AOHEND_H)-UserPrefHStart+1; // get DE width
          height=mStar_ReadWord(AOVEND_H)-UserPrefVStart+1; // get DE Height
          // check if resolution is correct
          if (abs(width-StandardModeWidth)<100 && abs(height-StandardModeHeight)<100)
            break;
      	}
      if (retry>=5) // if DVI is not stable, then do mode detection again
      	{ Set_InputTimingChangeFlag();
          return FALSE;
      	}
      #endif
    }
  else
    {       		
      width=StandardModeWidth;
      height=StandardModeHeight;
	  
#if WidePanel     // sail add 
	  BlackVstartOffset=0;
      if(NormalSizeFlag)
	  	{
      		if(StandardModeGroup==Res_1280x768)
      			{
      			height+=Res1280x768Vst;
				BlackVstartOffset=Offset1280x768;
      			}	  	
      		else if(StandardModeGroup==Res_1024x768)
      			{
      			height+=Res1024x768Vst;
				BlackVstartOffset=Offset1024x768;
      			}
	  		else if(StandardModeGroup==Res_800x600)
	  			{
      			height+=Res800x600Vst;
				BlackVstartOffset=Offset800x600;				
	  			}
	  		else if(StandardModeGroup==Res_640x480)
	  			{
      			height+=Res640x480Vst;
				BlackVstartOffset=Offset640x480;				
	  			}

	  		else if(StandardModeGroup==Res_720x400)
	  			{
      			height+=Res720x400Vst;
				BlackVstartOffset=Offset720x400;				
	  			}

	  		else if(StandardModeGroup==Res_640x350)
	  			{
      			height+=Res640x350Vst;
				BlackVstartOffset=Offset640x350;				
	  			}
      	}
#if PanelCPT154WA01
	  		else if(StandardModeGroup==Res_720x400)
	  			{
      			height+=Res720x400Vst;
				BlackVstartOffset=Offset720x400;				
	  			}
	  		else if(StandardModeGroup==Res_640x350)
	  			{
      			height+=Res640x350Vst;
				BlackVstartOffset=Offset640x350;				
	  			}
#endif

#endif				
    }
  
  mStar_WriteWord(SPRHST_H, UserPrefHStart); // set capture window hstart

#if WidePanel   // sail add 
  	mStar_WriteWord(SPRVST_H, UserPrefVStart-BlackVstartOffset);  // set capture window vstart
#else	
  	mStar_WriteWord(SPRVST_H, UserPrefVStart);  // set capture window vstart
#endif    	

  mStar_WriteWord(SPRHDC_H, width); // set capture window width according input resolution
  mStar_WriteWord(SPRVDC_H, height); // set capture window height according input resolution

#if 0
  if (width==PanelWidth && height==PanelHeight) // set native mode flag
    SrcFlags|=bNativeMode;
#else
  if (width>PanelWidth || height>PanelHeight) // set native mode flag
    SrcFlags|=bShrinkMode;
#endif

  return TRUE;
}



//*******************************************************************
// Function Name: mStar_SetupADC
//
// Decscription: setup ADC bandwidth/filter, clock, phase for sampling input data
//               and R/G/B gains, offsets
// caller: mSar_WriteByte(), mStar_ReadByte() in ms_rwreg.c
///
// callee: mStar_SetupMode() in mstar.c
//*******************************************************************
BYTE code ADCWB[4][3]= // ADC parameter table for setup ADC
{// HS_LVL,	BWCOEF,		DCOEF
  {0x60,	0x06,		0x2}, // <38 MHz
  {0x40,	0x05,		0x3}, // 38< < 75
  {0x20,	0x03,		0x3}, // 75< <155
  {0x00,	0x01,		0x3}  //  >155
};
void mStar_SetupADC(void)
{ WORD tempValue;

  mStar_WriteByte(REGBK, REGBANKADC); // switch to ADC bank
  if (SrcInputType<Input_Digital || SrcInputType==Input_YPbPr)
    { BYTE regByte=mStar_ReadByte(GCTRL)&~HSP_B;
      //mStar_WriteByte(GCTRL, regByte);
      // setup ADC bandwidth/filter according input dot clock
      tempValue=((DWORD)MST_CLOCK_MHZ*10+SrcHPeriod/2)/SrcHPeriod; //calculate hfreq: round 5
      tempValue=((DWORD)tempValue*UserPrefHTotal+5000)/10000; //dclk= hfreq * htotal
      //printData("input dclk %d", tempValue);
      if (tempValue<38)
        tempValue=0;
      else if (tempValue<75)//82)
        tempValue=1;
      else if (tempValue<155)
        tempValue=2;
      else
      	tempValue=3;

#if (PanelCPTEA03||PanelHST170ME13||PanelCMO170E5)//MA782IS_AD_CPT			//sail add 20040624
 	if(SrcModeIndex>=33&&SrcModeIndex<=35)
	{
		mStar_WriteByte(HS_LVL, ADCWB[3][0]); // setup ADC bandwidth     
	}
	else
		mStar_WriteByte(HS_LVL, ADCWB[tempValue][0]); // setup ADC bandwidth 
#else
      mStar_WriteByte(HS_LVL, ADCWB[tempValue][0]); // setup ADC bandwidth     
#endif
      //mStar_WriteByte(HS_LVL, ADCWB[tempValue][0]); // setup ADC bandwidth     
      mStar_WriteByte(BWCOEF, ADCWB[tempValue][1]);   // setup ADC
      mStar_WriteByte(DCOEF,  ADCWB[tempValue][2]);

      // setup clock
      tempValue=UserPrefHTotal-3;
      mStar_WriteByte(PLLDIVM, tempValue>>4);
      mStar_WriteByte(PLLDIVL, (tempValue&0xF)<<4);
      // setup phase
      mStar_WriteByte(CLKCTRL1, UserPrefPhase+8);
      mStar_WriteByte(CLKCTRL2, UserPrefPhase);
      // setup hsync polarity
      { tempValue=regByte;

      	if (!(SrcFlags&bHSyncNegative))
          regByte|=HSP_B;
        mStar_WriteByte(GCTRL, regByte);
      }
      // setup ADC gain
      mStar_WriteByte(REDGAIN, 0xFF-UserPrefAdcRedGain);
      mStar_WriteByte(GRNGAIN, 0xFF-UserPrefAdcGreenGain);
      mStar_WriteByte(BLUGAIN, 0xFF-UserPrefAdcBlueGain);
      // setup ADC offset
      mStar_WriteByte(REDOFST, 0xFF-UserPrefAdcRedOffset);
      mStar_WriteByte(GRNOFST, 0xFF-UserPrefAdcGreenOffset);
      mStar_WriteByte(BLUOFST, 0xFF-UserPrefAdcBlueOffset);
      // setup hsync polarity again
      { if (SrcFlags&bHSyncNegative)
          tempValue|=HSP_B;
        mStar_WriteByte(GCTRL, tempValue);
      }
    }
  else if (SrcInputType==Input_Digital)
    { mStar_WriteByte(HS_LVL, 0x00); // setup ADC bandwidth
      mStar_WriteByte(BWCOEF, 0x01);   // setup ADC
      mStar_WriteByte(DCOEF,  0x03);
#if SwapDVIRB//0//(!NEWIC_18A&&!NEWIC_18B)//Albert 20031031 For Inverse R,B of input
      //Costdown model set "0",8XXX set "1"//lotus 20041101
      //Define SwapDVIRB for model control //lotus 20041106
	  mStar_WriteByte(GCTRL, mStar_ReadByte(GCTRL)|DRBS);
#endif
    }
  mStar_WriteByte(REGBK, REGBANKSCALER); // switch to scaler bank
}

//*******************************************************************
// Function Name: mStar_SetScalingFactor
//
// Decscription: setup scaler hor/ver scaling factor to expand image to full screen
//
// caller: mSar_WriteByte(), mStar_ReadByte() in ms_rwreg.c
///
// callee: mStar_SetupMode() in mstar.c
//*******************************************************************
#define HSC_offset	1
void mStar_SetScalingFactor(void)
{ DWORD factor;
  WORD width, height;
  BYTE UpBlackLine=0;

#if (WidePanel||WidePanel_16_9)    // sail add
   WORD temp=0;
#endif

  width=mStar_ReadWord(SPRHDC_H);
  height=mStar_ReadWord(SPRVDC_H);
  
  //printData("input height %d",height);
  //printData("input width %d",width);
  
#if WidePanel
  	ForceDelay1ms(80);

   if(StandardModeGroup==Res_1024x768||StandardModeGroup==Res_800x600||StandardModeGroup==Res_640x480
   	||StandardModeGroup==Res_720x400||StandardModeGroup==Res_640x350)  
   	{
   		if(NormalSizeFlag)
   		temp=0x80;
   	}    
   
#if PanelCPT154WA01
	if(StandardModeGroup==Res_720x400||StandardModeGroup==Res_640x350)  
   		temp=0x80;	
	if(StandardModeGroup==Res_1280x600)
		temp=0;	
#endif

   mStar_WriteWord(SIHST_H, PanelHStart+temp);
   mStar_WriteWord(SIHEND_H, PanelHStart+PanelWidth-temp-1);
   
#if PanelCPT154WA01 
	if(StandardModeGroup==Res_720x400||StandardModeGroup==Res_640x350
    ||(StandardModeGroup!=Res_1280x800&&NormalSizeFlag&&StandardModeGroup!=Res_1280x600)) 
		{
   		mStar_WriteWord(SIVEND_H, PanelHeight-0x10-1);
		UpBlackLine=0x0f;   		
		}
	else
		mStar_WriteWord(SIVEND_H, PanelHeight-1);	
	
   		mStar_WriteWord(DEVEND_H, PanelHeight-1-UpBlackLine);
		
#elif (PanelTB154l|PanelHITACHI15W)
   if(StandardModeGroup!=Res_1280x800&&NormalSizeFlag)
		UpBlackLine=0x10;   
   		mStar_WriteWord(SIVEND_H, PanelHeight-UpBlackLine-1);
   		mStar_WriteWord(DEVEND_H, PanelHeight-UpBlackLine-1);  // Vert. DE end      	
#endif

#endif 

#if WidePanel_16_9 //ZWTAN ADD 20040901
  	ForceDelay1ms(80);

   if(StandardModeGroup==Res_1024x768||StandardModeGroup==Res_800x600||StandardModeGroup==Res_640x480
   	||StandardModeGroup==Res_720x400||StandardModeGroup==Res_640x350||Res_832x624)  
   	{
   		if(NormalSizeFlag)
   		temp=0x80;
   	}
if(StandardModeGroup==Res_1280x768) temp=0x00;
if ((mStar_ReadWord(SPRHDC_H)&0xfffe)==1280) temp=0x00;
   mStar_WriteWord(SIHST_H, PanelHStart+temp);
   mStar_WriteWord(SIHEND_H, PanelHStart+PanelWidth-temp-1);
#endif 

  if (SrcFlags&bInterlaceMode)
    height/=2; // if input timing is interlace, must use 1/2 height to get scaler factor
  if (width==640)
    mStar_WriteWord(SPRHDC_H, width+1);
  
  // Setup horizontal expansion  
#if (WidePanel||WidePanel_16_9)
  if (width!=PanelWidth-temp*2) // set expansion factor
     { 
        factor=width-HSC_offset; // factor=((input width-1)*2^20)/(output width-1) + 1
      	factor=((DWORD)(factor<<20))/(PanelWidth-HSC_offset-temp*2)+1;
		mStar_WriteWord(SRH_M, factor&0xFFFF);
      	mStar_WriteByte(SRH_H, ((factor>>16)&0xFF)|SENH_B);
  	}
#else 
  if (width!=PanelWidth) // set expansion factor
    { 
    	factor=width-HSC_offset; // factor=((input width-1)*2^20)/(output width-1) + 1	  	
      	factor=((DWORD)(factor<<20))/(PanelWidth-HSC_offset)+1; 	  	
      	mStar_WriteWord(SRH_M, factor&0xFFFF);
      	mStar_WriteByte(SRH_H, ((factor>>16)&0xFF)|SENH_B);
  	}
#endif	  
  else
    mStar_WriteByte(SRH_H, 0); // input width=output width, then disable expansion
    
    
  // Setup vertical expansion
#if WidePanel // sail add
    if (height!=PanelHeight-UpBlackLine)
    { factor=height-1; // factor=((input height-1)*2^20)/(output height-1) + 1
      factor=((DWORD)(factor<<20))/(PanelHeight-1-UpBlackLine)+1;
      mStar_WriteWord(SRV_M, factor&0xFFFF);
      mStar_WriteByte(SRV_H, ((factor>>16)&0xFF)|SENV_B);
    }		
#else 
    if (height!=PanelHeight)
    { factor=height-1; // factor=((input height-1)*2^20)/(output height-1) + 1
      factor=((DWORD)(factor<<20))/(PanelHeight-1)+1;
      mStar_WriteWord(SRV_M, factor&0xFFFF);
      mStar_WriteByte(SRV_H, ((factor>>16)&0xFF)|SENV_B);
    }
#endif 	
  else
    mStar_WriteByte(SRV_H, 0); // input height=output height, then disable expansion

#if 0//WidePanel
	mStar_AutoPosition();
#endif
}

//*******************************************************************
// Function Name: mStar_ResetDClkPLL
//
// Decscription: Reset output PLL to prevent from PLL works abnormally by
//               toggle power down/on of PLL
//
// caller: mSar_WriteByte(), mStar_ReadByte() in ms_rwreg.c
///
// callee: mStar_SetupMode() in mstar.c
//*******************************************************************
void mStar_ResetDClkPLL(void)
{ BYTE regByte;

  regByte=mStar_ReadByte(PLLCTRL2);
  Delay1ms(10);
  mStar_WriteByte(PLLCTRL2, regByte|LP_PD_B); // force PLL power down
  Delay1ms(10);
  mStar_WriteByte(PLLCTRL2, regByte); // then re-enable PLL
}

//*******************************************************************
// Function Name: mStar_SetPanelTiming
//
// Decscription: Setup panel output dclk.
//
// callee: mStar_ResetDClkPLL() in mstar.c
//         mSar_ReadWord(), mStar_WriteWord(), mStar_WriteByte() in ms_rwreg.c
//
// caller: mStar_SetupMode() in mstar.c
//*******************************************************************