ttfc.c

keil C51 LCD 驱动源码,其中还有I2C驱动,ADC驱动,键盘操作等,是一个完整的keil源代码,供大家参考

/****************************************************************************
   +----------------------------------------------------------------------+
   | Copyright Trumpion Microelectronics Inc. 1999                        |
   | Trumpion Microelectronics Inc. reserves the right to change products |
   | or specifications without notice.                                    |
   +----------------------------------------------------------------------+
   Project    : LCD monitor
   Version    : 0.94
   File Name  : ttfc.c
   Functions  : Zurac initial table and function for various mode
   Revision   :

   1999-05-18  OriginalTeam    First Created
   2000-07-17  Bill Tseng      Modified for Zurac-II
   2000-07-24  Bill Tseng      Modify 640x480/all mode ttfc table for v-position smooth moving
                               double 800x600/56Hz,75Hz scaling factor(6f,70) 
   2000-08-21  Bill Tseng      Add gamma-factor-table for factor 1/2.60,1/2.40,..,2.60
   2000-11-02  Bill Tseng      Add PV_AStart,PV_Total,BV_Start online calculatig routine
****************************************************************************/

//=========================================================================
// include files                                                          =
//=========================================================================
#include  "lib\extent.h"
#include  "lib\wreg516.h"
#include  "lib\declare.h"

#include  "lib\global.h"
#include  "lib\modedata.h"
#include  "lib\initial.h"
#include  "lib\define.h"
#include  "lib\eeprom.h"
#include  "lib\ttfc.h"
#include  "lib\hwmd.h"

//**************************************************************************
// PROGRAM SECTION
//**************************************************************************
void Ttfc(Byte ModeNum, Byte ModeModify)
{
    Byte  i,thn,thd,tvn,tvd;
    Word  wtemp,wtemp2;

    i   = mode_factor[ModeNum]*4;
    thn = scale_factor_table[i];      /* Hsf numerator   */
    thd = scale_factor_table[i+1];    /* Hsf denominator */
    tvn = scale_factor_table[i+2];    /* Vsf numerator   */
    tvd = scale_factor_table[i+3];    /* Vsf denominator */

    if( ModeModify )
    {
       /*** send IO control register[0x01..0x06] ***/
       SlvAdr      = ZURAC_ADDRESS;
       DataPointer = Scale_IO_control_table[ModeNum] + 1;
       ByteCnt     = 7;
       TrmBuf[0]   = 0x01;    /* INCTR0 */
       for( i=1; i<=6; i++ )
          TrmBuf[i] = *(DataPointer++);
       if( InputSource==INPUT_ANALOG )
       {
          if( ModeInputport[ModeNum]==2 )
             TrmBuf[2] &= 0xFD;      /* bit[1]==0 RGB 48 bit input */
          else                 
             TrmBuf[2] |= 0x02;      /* bit[1]==1 RGB 24 bit input */
#if  (ADC_CHIP==ADI_9883)
          TrmBuf[2] |= 0x80;         /* bit[7]==1 invert input clock */
#endif
       }
       else if( InputSource==INPUT_DIGITAL )
       {
          TrmBuf[1] = 0x08;
          TrmBuf[2] = 0x01;
       }
       else
       {
#if  (VIDEO_DECODER==VIDEO_S7114)
          TrmBuf[2] = 0xe0;
#endif
       }
       TrmBuf[3] = Zurac03Value( ModeNum );
       if( DitherMode!=0 )   /* dithering Feedback ON  */
          TrmBuf[5] |= 0x02;
       SendData();
       
       /*** send Panel PLL register[0xBA..0xBE] ***/
       DataPointer = Scale_panel_pll_table[ModeNum];
       ByteCnt     = 6;
       TrmBuf[0]   = PLL_PANEL_ADDR;
       for( i=1; i<=5; i++ )
          TrmBuf[i] = *(DataPointer++);
       SendData();

       /*** send IO Control register[0x0A..0x0B] ***/
       ByteCnt     = 3;
       TrmBuf[0]   = 0x0A;               
       if( ModeModify==1 )
       {
          DataPointer = Scale_IO_control_table[ModeNum]+10;
          TrmBuf[1] = *DataPointer++;
          TrmBuf[2] = *DataPointer;               
//        if( FgGammaEnable )  TrmBuf[1] |= 0x80;
	  if(GammaIndex!=0)    TrmBuf[1] |= 0x80;
          if( DitherMode && (InputSource==INPUT_DIGITAL) )  TrmBuf[2] |= 0x30;
       }
       else /* FreeRun mode, ModeModify==2 */      
       {
          TrmBuf[1] = 0x08;
          TrmBuf[2] = 0x03;       
       }
       SendData();

       /*** send OUTPUT Ccontrol register[0x30..0x3F] ***/
       DataPointer = Scale_output_para_table[ModeNum];
       ByteCnt     = 17;
       TrmBuf[0]   = OUTPUT_PARA_ADDR;
       for( i=1; i<=16; i++ )
          TrmBuf[i] = *(DataPointer++);

       // Check Panel Horizontal and Vertical active region
       if( InputSource<=INPUT_DIGITAL )
       {
             wtemp = MAKEWORD( Scale_input_para_table[ModeNum][3],Scale_input_para_table[ModeNum][2] );
             if (ModeCounter >=25)     wtemp = 1024; ///* 25,1152*864/70  */
             wtemp2 = wtemp;
             if( (HorPositionValue + wtemp + 4 ) >= (ClockValue) )
                wtemp2 = ClockValue - HorPositionValue -  4;
   //        if( (HorPositionValue + wtemp     ) >= (ClockValue) )
   //           wtemp2 = ClockValue - HorPositionValue -  1;

             if( wtemp2 < wtemp )   // IH-AWIDTH
             {
                 wtemp = MAKEWORD( Scale_output_para_table[ModeNum][3],Scale_output_para_table[ModeNum][2] );
                 wtemp = (Word) (((long)wtemp2 * (long)thn) / (long)thd); // - 2;
             }
             else
             {
                 wtemp = MAKEWORD( Scale_output_para_table[ModeNum][3],Scale_output_para_table[ModeNum][2] );
             }
             if( wtemp >= PANEL_WIDTH )  wtemp = PANEL_WIDTH;

   #if  ZURAC_HSCALING
             wtemp2 = MAKEWORD( Scale_output_para_table[ModeNum][1],Scale_output_para_table[ModeNum][0] );
             if( InputSource==INPUT_ANALOG )
             {
                if( HScaling < 32 )
                {
                   if( (hscaling_table[ModeNum] & 0xF0)==0x00 )   /* scale up mode */
                   {
                      wtemp  = wtemp  - (32 - HScaling)*2;
                      wtemp++;
                      wtemp2 = wtemp2 + (32 - HScaling);
                   }
                }
                else
                {
                   wtemp = wtemp + (HScaling - 32) * 2;
                   if( wtemp>=PANEL_WIDTH )  wtemp = PANEL_WIDTH;
                }
             }
             TrmBuf[1] = LOBYTE( wtemp2 );
             TrmBuf[2] = HIBYTE( wtemp2 );
   #endif

          TrmBuf[3] = LOBYTE( wtemp );
          TrmBuf[4] = HIBYTE( wtemp );

          if( ModeModify==1 )
          {
#if ((OUTPUT_MODE==OUTPUT_SXGA) && (PANEL_DEFAULT==PANEL_ACER))
             wtemp  = (Word) (((Long)HS2frCount * (Long)tvn) / (Long)tvd);   /* actual output_total */
             wtemp /= 2;
#else
             wtemp  = (Word) (((Long)HS1frCount * (Long)tvn) / (Long)tvd);   /* actual output_total */
#endif              

#if  (OUTPUT_MODE==OUTPUT_XGA)
 #if  (PANEL_DEFAULT==PANEL_HANNSTAR)
             if( ModeCounter > 9 )      wtemp -= 2;
             else if( ModeCounter==9 )  wtemp -= 4;   
             else                       wtemp -= 3;
 #else
             if( FgInterlace==0 )       wtemp -= 2;
 #endif
#elif (OUTPUT_MODE==OUTPUT_SXGA)
 #if (PANEL_DEFAULT==PANEL_ACER)
             if ( ModeCounter == 20 )	// wtemp -= 1;
             {
             	if(wtemp == 0x434)	wtemp--;
             }
             else if ( ModeCounter >= 18 )   wtemp -= 2;
             else                       wtemp -= 1;
 #else
             if ( ModeCounter == 20 )	// wtemp -= 1;
             {
             	if(wtemp == 0x434)	wtemp--;
             }
             else			wtemp -= 2;
 #endif
#else
             wtemp -= 2;
#endif              
             wtemp2 = MAKEWORD( Scale_output_para_table[ModeNum][5],Scale_output_para_table[ModeNum][4] );

             if( (wtemp2+PANEL_HEIGHT+4)>wtemp )  /* set PV_ASTART */
             {
                wtemp2 = wtemp - PANEL_HEIGHT - 4;
                TrmBuf[5] = LOBYTE( wtemp2 );
                TrmBuf[6] = HIBYTE( wtemp2 );
                
                TrmBuf[13] = LOBYTE( wtemp2+1 );
                TrmBuf[14] = HIBYTE( wtemp2+1 );
             }
             TrmBuf[ 9] = LOBYTE( wtemp );
             TrmBuf[10] = HIBYTE( wtemp );
             TrmBuf[15] = LOBYTE( wtemp );
             TrmBuf[16] = HIBYTE( wtemp );
          }
#if (PANEL_DEFAULT==PANEL_ACER)
          if( InputSource==INPUT_ANALOG )  /* to fix acer panel bug */
          {
             i = ModeVShift[ModeNum][2] - ModeVShift[ModeNum][1];
             if(i>30)	i=0;
             wtemp = PANEL_HEIGHT + ModeVShift[ModeNum][1] + i;
             TrmBuf[7] = LOBYTE( wtemp );
             TrmBuf[8] = HIBYTE( wtemp );
          }
#endif
          if( InputSource==INPUT_DIGITAL )   /* set input vertical active width */
          {
             wtemp = MAKEWORD( Scale_input_para_table[ModeNum][9],Scale_input_para_table[ModeNum][8] );
             wtemp = (Word) (((long)wtemp * (long)tvn) / (long)tvd);
             if( wtemp > PANEL_HEIGHT )
                wtemp = PANEL_HEIGHT;
             TrmBuf[7] = LOBYTE( wtemp );
             TrmBuf[8] = HIBYTE( wtemp );
          }          
       }
       SendData();

       /*** send BACKGROUND Control register[0x40..0x47] ***/
       DataPointer = Scale_background_table[ModeNum];
       ByteCnt     = 9;
       TrmBuf[0]   = BACKGROUND_ADDR;
       for( i=1; i<=8; i++ )
          TrmBuf[i] = *(DataPointer++);
       if( (InputSource<=INPUT_DIGITAL) && (ModeModify==1) )
       {
#if (PANEL_DEFAULT==PANEL_ACER)
          if( InputSource==INPUT_ANALOG )
             wtemp2 += ModeVShift[ModeNum][2]; /* to fix acer panel bug */
#endif          
          TrmBuf[5] = LOBYTE( wtemp2 );      /* Background V-start */
          TrmBuf[6] = HIBYTE( wtemp2 );
          wtemp2 += PANEL_HEIGHT;
          TrmBuf[7] = LOBYTE( wtemp2 );      /* Background V-end */
          TrmBuf[8] = HIBYTE( wtemp2 );
       }        
       SendData();

       /*** send CLAMP control register[0x7A..0x7B] ***/
       ByteCnt     = 3;
       TrmBuf[0]   = CLAMP_REG_ADDR;
       TrmBuf[1]   = 0x10;
       TrmBuf[2]   = 0x10;
       SendData();

       /*** Brightness and Contrast control[0xAE..0xB1,0xB7..0xB8] ***/
       ZuracBCAdjust();

       /*** send Color-Lookup-Table[0xB5] ***/
       DataPointer = color_LUT_table;
       for( i=0; i<16; i++ )
       {
          ZuracWriteByte(0xB5,*(DataPointer+1));   /* Low  byte */
          ZuracWriteByte(0xB5, *(DataPointer) );   /* High byte */
          DataPointer += 2;
       }
    }

    /*** send INPUT control register[0x10..0x1E] ***/
    SlvAdr = ZURAC_ADDRESS;
    DataPointer = Scale_input_para_table[ModeNum];
    ByteCnt = 16;
    TrmBuf[0] = INPUT_PARA_ADDR;
    for( i=1; i<=15; i++ )
       TrmBuf[i] = *(DataPointer++);
    
    wtemp = HorPositionValue;
    if( InputSource==INPUT_DIGITAL )  /* for auto-DE adjust */
       wtemp &= 0xFFFE;
    TrmBuf[1] = LOBYTE(wtemp);
    TrmBuf[2] = HIBYTE(wtemp);
    // check Input Horizontal Active Width
    wtemp = MAKEWORD( Scale_input_para_table[ModeNum][3],
                      Scale_input_para_table[ModeNum][2] );
    wtemp2 = wtemp;
    if( (HorPositionValue + wtemp) >= (ClockValue-1) )
       wtemp2 = ClockValue - HorPositionValue - 2;
//  if( (HorPositionValue + wtemp -15) >= (ClockValue) )
//     wtemp2 = ClockValue - HorPositionValue - 15;
    TrmBuf[3] = LOBYTE(wtemp2);
    TrmBuf[4] = HIBYTE(wtemp2);
    wtemp2 = ClockValue;
    if( wtemp2>0x07FF )
       wtemp2 = 0x07FF;
    TrmBuf[5] = LOBYTE(wtemp2);
    TrmBuf[6] = HIBYTE(wtemp2);      
    
    wtemp = VerPositionValue;
#if (PANEL_DEFAULT==PANEL_ACER || PANEL_DEFAULT==PANEL_SAMSUNG)
    wtemp = VerPositionValue - ModeVShift[ModeNum][0];   /* to fix acer panel bug */
#endif
    TrmBuf[7] = LOBYTE(wtemp);
    TrmBuf[8] = HIBYTE(wtemp);
    // check Input Vertical Active Width
    wtemp  = MAKEWORD( Scale_input_para_table[ModeNum][9],
                       Scale_input_para_table[ModeNum][8] );
    wtemp2 = MAKEWORD( Scale_input_para_table[ModeNum][11],
                       Scale_input_para_table[ModeNum][10] );
    if( (wtemp + VerPositionValue) >= wtemp2 )
    {
       wtemp = wtemp2 - VerPositionValue - 1;
       TrmBuf[9]  = LOBYTE(wtemp);
       TrmBuf[10] = HIBYTE(wtemp);
    }
    SendData();

    /*** send SCALING_FACTOR Control register[0x60..0x70] ***/
    DataPointer = Scale_scaling_factor_table[ModeNum];
    ByteCnt   = 18;
    TrmBuf[0] = SCALING_FAC_ADDR;
    for( i=1; i<=17; i++ )
       TrmBuf[i] = *(DataPointer++);
    if( InputSource<=INPUT_DIGITAL )
    {
       wtemp = (Word) (((Long)ClockValue * (Long)tvd) / (Long)tvn);

       if( InputSource==INPUT_ANALOG )
       {
          if( ModeInputport[ModeNum]==2 )   /* double input port */
             wtemp = wtemp / 2;
       }
       else if( InputSource==INPUT_DIGITAL )