开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 其他嵌入式/单片机内容 > 查看源码
Mode_Detect.~c
资源名称：RTD2523_MTV512.rar　[点击查看]
上传用户：xmyjxjd
上传日期：2013-05-04
资源大小：1517k
文件大小：90k
源码类别：

其他嵌入式/单片机内容

开发平台：

C/C++

Mode_Detect.~c：源码内容
  2. #define __MODEDETECT__
  4. #include "HeaderLcd_func.h"
  5. #include "HeaderLcd_Main.h"
  6. #include "HeaderAccess.h"
  7. #include "Headerconfig.h"
  8. #include "HeaderOSD.h"
  9. #include "HeaderLcd_Auto.h"
  10. #include "HeaderFrame_Sync.h"
  11. #include "HeaderSrc_Ctrl.h"
  12. #include "HeaderLCD_OSD.h"
  15. /////////////////////////////////////////////////////////
  16. //-------------------  Mode Detector  -----------------//
  17. /////////////////////////////////////////////////////////
  18. void Mode_Detector(void)
  19. {
  21.     switch (stGUD1.INPUT_SOURCE & 0x07)
  22.     {
  23.     case SOURCE_VGA :
  24.         // Save previous values of ucMode_Curr, bHpole_Curr and bVpole_Curr
  25.         bHpole_Prev = bHpole_Curr;
  26.         bVpole_Prev = bVpole_Curr;
  27.         
  28.         if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
  29.             Detect_VGA_Mode();
  30.         else
  31.             Check_VGA_Mode();
  32.         break;
  34.      case SOURCE_DVI :
  35.         // Save previous values of ucMode_Curr, bHpole_Curr and bVpole_Curr
  36.         bHpole_Prev = bHpole_Curr;
  37.         bVpole_Prev = bVpole_Curr;
  38.         
  39.         if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
  40.             Detect_DVI_Mode();
  41.         else
  42.             Check_DVI_Mode();
  43.         break;
  46.    default :
  47.         if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
  48.             Detect_Video_Mode();        // Set default polarity 
  49.         else
  50.             Check_Video_Mode();         // Set polarity after measure
  51.         break;
  52.     }
  54.     Measure_Mode();     // Measure mode-timing
  55. }
  57. void Measure_Mode(void)
  58. {
  60.     
  61.     switch (stGUD1.INPUT_SOURCE & 0x07)
  62.     {
  63.     RTDSetByte(SYNC_CTRL_4A,0x00);
  64.     case SOURCE_VGA :
  65.         RTDSetByte(SYNC_POR_4C, (SYNC_SS == ucSync_Type) ? 0x02 : 0x32);
  66.         break;
  67.  case SOURCE_DVI :
  68.         RTDSetByte(SYNC_POR_4C, 0x02);
  69.         break;
  70.     default :
  71.         RTDSetByte(SYNC_POR_4C, 0x02);
  72.         break;
  73.     }
  75. }
  77. #if(SOURCE_AUTO_SCAN)
  78. /////////////////////////////////////////////////////////
  79. //---Detect which source with valid signal-------------//
  80. /////////////////////////////////////////////////////////
  81. void Measure_Source(unsigned char SOURCE)
  82. {
  83.    switch(SOURCE)
  84.    {
  85.    case SOURCE_VGA:
  86. RTDSetByte(SYNC_CTRL_4A,0x01);
  87. break;
  88.    case SOURCE_DVI:
  89. RTDSetByte(SYNC_CTRL_4A,0x03);
  90. break;
  91.    case SOURCE_AV:
  92.         I2CWrite(V_ENABLE);
  93.         I2CWrite(AV_DETECT);
  94.         break;
  95.    case SOURCE_SV:
  96.         I2CWrite(V_ENABLE);
  97.         I2CWrite(SV_DETECT);
  98. break;
  99.    }
  100.    //RTDSetByte(SYNC_POR_4C, 0x32);
  101.    //RTDSetByte(SYNC_POR_4C, 0x02);
  102.    //RTDSetByte(SYNC_POR_4C, (stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA ? 0x32 : 0x02);
  103.    
  104.    if(((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA) && (SYNC_SS != ucSync_Type))
  105.        RTDSetByte(SYNC_POR_4C,0x32);
  106.    else
  107.        RTDSetByte(SYNC_POR_4C,0x02);
  108.    
  109.    Delay_Xms(35);
  110.    //Delay_Xms(24);
  111.    
  113. }
  114. #endif
  115. /////////////////////////////////////////////////////////
  116. //------------------  Detect VGA Mode  ----------------//
  117. /////////////////////////////////////////////////////////
  118. void Detect_VGA_Mode(void)
  119. {
  120.     unsigned char   ucMode_Temp, m;
  121.     unsigned int    usHS_Pulse;
  123.     RTDRead(SYNC_POR_4C, 0x09, Y_INC);
  125.     if (Data[0] & 0x02)
  126.     {
  127.         // Reset Sync Processor when sync signal timeout
  128.         RTDSetByte(SYNC_POR_4C, 0x20);
  130.         // Treat sync signal timeout as no signal
  131.         ucMode_Temp     = MODE_NOSIGNAL;
  132.     }
  133.     else
  134.     {
  136. //        ucMode_Temp = (Data[8] & 0xe0 ) >> 5;
  138. //        if(ucMode_Temp == 0 || ucMode_Temp >=4) //Test which edge of Hsync to latch Vsync will be safe
  139. // {
  140. //           RTDSetBit(MEAS_VS_HI_54,0xf7,0x08);  //Use positive edge of Hsync to latch Vsync
  141. //    ucDebug_Value0 = 0x08;
  142. // }
  143. // else
  144. // {
  145. //    RTDSetBit(MEAS_VS_HI_54,0xf7,0x00);  //Use negtive edge of Hsync to latch Vsync
  146. //    ucDebug_Value0 = 0x18;
  147. // }
  149.         
  150.         usStdHS   = usHsync;  // Save previous usHsync in usStdHS
  151.         usStdVS   = usVsync;  // Save previous usVsync in usStdVS
  153.         bVpole_Curr = (bit)(Data[0] & 0x08);    // Save current usVsync polarity
  154.         bHpole_Curr = (bit)(Data[0] & 0x04);    // Save current usHsync polarity
  156.         Data[7] = Data[5];
  157.         Data[6] = Data[6] & 0x0f;
  158.         Data[5] = Data[3];
  159.         Data[4] = Data[4] & 0x87;
  160.         Data[3] = Data[1];
  161.         Data[2] = Data[2] & 0x8f;
  163.         usHsync     = ((unsigned int *)Data)[1];    // Current HSYNC timing
  164.         usVsync     = ((unsigned int *)Data)[2];    // Current VSYNC timing
  165.         usHS_Pulse  = ((unsigned int *)Data)[3];    // Current HSYNC pulse width
  167.         // Calculate Vertical Refresh Rate
  168.         // Original Formula :
  169.         // ucRefresh = 24.576M / (usHsync * usVsync)
  170.         // Use Data[0~3] as a temporary long variable
  171.         ((unsigned long *)Data)[0]  = (unsigned long)usHsync * usVsync;
  172.         ucRefresh   = (unsigned long)49152000 / ((unsigned long *)Data)[0];
  173.         ucRefresh   = (ucRefresh & 0x01) ? ((ucRefresh + 1) >> 1) : (ucRefresh >> 1);
  175.         // Treat small change of usHsync/usVsync as no change
  176.         if (usStdHS <= usHsync && (usStdHS + 2) >= usHsync)     usHsync = usStdHS;
  177.         if (usStdVS <= usVsync && (usStdVS + 2) >= usVsync)     usVsync = usStdVS;
  179.         // Polarity must be correct
  180.         if ((bVpole_Curr != bVpole_Prev) || (bHpole_Curr != bHpole_Prev))
  181.         {  
  182.             RTDRead(VGIP_SIGINV_05, 0x01, N_INC);
  184.             Data[0] &= 0xd7;  // HS_RAW & VS positive
  186.             if (!bHpole_Curr)    Data[0] |= 0x20;
  187.             
  188.             if (!bVpole_Curr && SYNC_SS == ucSync_Type)     Data[0] |= 0x08;    // Seperate sync
  189.             
  190.             RTDSetByte(VGIP_SIGINV_05, Data[0]);
  192.             ucMode_Temp     = MODE_NOSUPPORT;
  193.         }
  194.         else
  195.         {
  196.             if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)
  197.             {
  198.                 ucMode_Temp     = MODE_NOSIGNAL;        // Treat overflow as no signal
  199.             }
  200.             else
  201.             {
  202.                 Data[0] = usHS_Pulse * 12 / usHsync;    // 0 : 720x350; 1 : 640x350;
  204.                 ucMode_Temp = MODE_NOSUPPORT;
  206.                 // Search for Standard Mode
  207.                 m   = MODE_1600x1200x60HZ;
  208.                 do
  209.                 {
  210.                     if ((usHsync > VGA_Mode[m][0]) && (usHsync < VGA_Mode[m][1]))
  211.                     {   
  212.                         if ((usVsync >= VGA_Mode[m][2]) && (usVsync <= VGA_Mode[m][3]))
  213.                         {
  214.                             if (MODE_1280x1024x75HZ == m)
  215.                             {
  216.                                 if (0 == (bVpole_Curr | bHpole_Curr))   m   = MODE_1280x1024x76HZ;  // SUN 1024-76
  217.                             }                            
  218.                             else if (MODE_1024x0768x75HZ == m)
  219.                             {
  220.                                 if (0 == (bVpole_Curr | bHpole_Curr))   m   = MODE_1024x0768x74HZ;  // MAC768-75
  221.                             }         
  222.                             else if (MODE_0640x0480x60HZ == m && bVpole_Curr != bHpole_Curr)
  223.                             {
  224.                                 // MODE_VGA350x60Hz         : 640x350 60Hz
  225.                                 // MODE_VGA350x60Hz | 0x40  : 720x350 60Hz
  226.                                 // MODE_VGA400x60Hz         : 640x400 60Hz
  227.                                 // MODE_VGA400x60Hz | 0x40  : 720x400 60Hz
  228.                                 if (bHpole_Curr)
  229.                                     m   = Data[0] ? MODE_VGA350x60Hz : MODE_VGA350x60Hz | 0x40;
  230.                                 else
  231.                                     m   = (stGUD1.FUNCTION & 0x10) ? MODE_VGA400x60Hz : MODE_VGA400x60Hz | 0x40;
  232.                                     //m   = (stGUD1.INPUT_SOURCE & 0x80) ? MODE_VGA400x60Hz : MODE_VGA400x60Hz | 0x40;
  233.                             }
  234.                             else if (MODE_0640x0480x50HZ == m && bVpole_Curr != bHpole_Curr)
  235.                             {
  236.                                 // MODE_VGA350x50Hz         : 640x350 50Hz
  237.                                 // MODE_VGA350x50Hz | 0x40  : 720x350 50Hz
  238.                                 // MODE_VGA400x50Hz         : 640x400 50Hz
  239.                                 // MODE_VGA400x50Hz | 0x40  : 720x400 50Hz
  240.                                 if (bHpole_Curr)
  241.                                     m   = Data[0] ? MODE_VGA350x50Hz : MODE_VGA350x50Hz | 0x40;
  242.                                 else
  243.                                     m   = (stGUD1.FUNCTION & 0x10) ? MODE_VGA400x50Hz : MODE_VGA400x50Hz | 0x40;
  244.                                     //m   = (stGUD1.INPUT_SOURCE & 0x80) ? MODE_VGA400x50Hz : MODE_VGA400x50Hz | 0x40;
  245.                             }
  246.                             else if (MODE_0720x0400x85HZ == m)
  247.                             {
  248.                                 if (1 == bHpole_Curr && 0 == bVpole_Curr)
  249.                                     m   = MODE_0640x0350x85HZ;
  250.                                 else if (stGUD1.FUNCTION & 0x10)     //else if (stGUD1.INPUT_SOURCE & 0x80)     
  251.                                     m   = MODE_0640x0400x85HZ;
  252.                             }
  253.                             else if (MODE_0720x0400x70HZ == m)
  254.                             {
  255.                                 if (1 == bHpole_Curr && 0 == bVpole_Curr)
  256.                                     m   = Data[0] ? MODE_0640x0350x70HZ : MODE_0720x0350x70HZ;
  257.                                 else if (stGUD1.FUNCTION & 0x10)//else if (stGUD1.INPUT_SOURCE & 0x80)
  258.                                     m   = MODE_0640x0400x70HZ;
  259.                             }
  261.                             ucMode_Temp     = m;
  262.                         }
  263.                     }
  264.                 }
  265.                 while ((0 != --m) && (MODE_NOSUPPORT == ucMode_Temp));
  266.                 
  267.                 // Search for User Mode
  268.                 if (MODE_NOSUPPORT == ucMode_Temp)
  269.                 {
  270.                     usIPV_ACT_LEN   = 0;
  272.                     m   = MODE_USER1600x1200;
  273.                     do
  274.                     {
  275.                         if ((usVsync >= VGA_Mode[m][2]) && (usVsync <= VGA_Mode[m][3]))
  276.                         {
  277.                             usIPV_ACT_LEN   = CAP_WIN[m][4];
  278.                             
  279.                             if ((usHsync >= VGA_Mode[m][0]) && (usHsync <= VGA_Mode[m][1]))
  280.                             {
  281.                                 ucMode_Temp     = m;    // Support User Mode
  282.                             }
  283.                         }
  284.                     }
  285.                     while ((MODE_USER720x400 <= --m) && (MODE_NOSUPPORT == ucMode_Temp));
  286.                 }
  288.                 if (48 > ucRefresh || MAX_RATE < ucRefresh)
  289.                 {
  290.                     ucMode_Temp = MODE_NOSUPPORT;   // We don't support vertical refresh rate lower than 50Hz
  291.                 }
  292.                 else if (MODE_NOSUPPORT == ucMode_Temp && 0 != usIPV_ACT_LEN)
  293.                 {
  294.                     if (DISP_LEN < usIPV_ACT_LEN)   // V Scale-down
  295.                     {
  296.                         // Estimate display clock rate for full screen
  297.                         // DCLK = (24.576MHz / usHsync) * DCLK per display line * (display image lines / input image lines)
  298.                         ((unsigned int *)Data)[0]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED1][0] * DISP_LEN 
  299.                                                     / ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
  301.                         if (MAX_DCLK < ((unsigned int *)Data)[0])
  302.                         {
  303.                             // If clock rate for full-screen display is too high, we can try partial-V display.
  304.                             // Estimate clock for partial-V display
  305.                             // DCLK = (24.576MHz / usHsync) * DCLK per display line * (min. display total lines / input total lines)
  306.                             ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED1][0] * MIN_DV_TOTAL
  307.                                                         / ((unsigned long)100 * (usVsync - 1) * usHsync);
  309.                             if (MAX_DCLK < ((unsigned int *)Data)[1])
  310.                             {
  311.                                 // Decrease usIPV_ACT_LEN to DISP_LEN and go further to check if it can be displayed.
  312.                                 usIPV_ACT_LEN   = DISP_LEN;
  313.                             }
  314.                             else
  315.                             {
  316.                                 ucMode_Temp     = MODE_UNDEFINED1 | 0x80;   // Scale-down and partial-V display
  317.                             }
  318.                         }
  319.                         else
  320.                             ucMode_Temp     = MODE_UNDEFINED1;              // Scale-down and full-V display
  321.                     }
  322.                     
  323.                     if (DISP_LEN >= usIPV_ACT_LEN)  // V Scale-up
  324.                     {
  325.                         ((unsigned int *)Data)[0]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0] * DISP_LEN 
  326.                                                     / ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
  328.                         if (MAX_DCLK < ((unsigned int *)Data)[0])
  329.                         {
  330.                             if (MIN_DV_TOTAL >= (usVsync - 1))
  331.                             {
  332.                                 ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0] * MIN_DV_TOTAL
  333.                                                             / ((unsigned long)100 * (usVsync - 1) * usHsync);
  334.                             }
  335.                             else
  336.                             {
  337.                                 ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0]
  338.                                                             / ((unsigned long)100 * usHsync);
  339.                             }
  340.                             
  341.                             if (MAX_DCLK < ((unsigned int *)Data)[1])   
  342.                                 ucMode_Temp = MODE_NOSUPPORT;           // Cannot display
  343.                             else
  344.                                 ucMode_Temp = MODE_UNDEFINED0 | 0x80;   // Scale-up and partial-V display
  345.                         }
  346.                         else
  347.                             ucMode_Temp = MODE_UNDEFINED0;              // Scale-up and full-V display
  348.                     }
  349.                 }
  350.             }
  351.         }
  352.     }
  354.     if (SYNC_SOG == ucSync_Type && 0 != (usHS_Pulse * 7 / usHsync))
  355.     {
  356.         // To prevent from SOG mode mistake
  357.         // HSYNC pulse width will never longer than 1/7*HSYNC period
  358.         ucMode_Temp = MODE_NOSIGNAL;
  359.     }
  361.     //-------------Check result-----------------------------------------
  362.     if (MODE_NOSUPPORT == ucMode_Temp || MODE_NOSIGNAL == ucMode_Temp)
  363.     {
  364.         // Treat illegal signal as no signal when SOG
  365.         if (SYNC_SOG == ucSync_Type)    ucMode_Temp = MODE_NOSIGNAL;
  367.         if (MODE_NOSUPPORT != ucMode_Found && MODE_NOSIGNAL != ucMode_Found)    ucMode_Times    = 0;
  369.         ucMode_Found    = ucMode_Temp;
  371.         if (NO_MODE_TIMES > ucMode_Times)
  372.         {
  373.             // Wait for signal stable
  374.             ucMode_Times ++;
  375.         }
  376.         else
  377.         {
  378.             bStable         = (ucMode_Curr == ucMode_Found) ? 1 : 0;    // bStable must be cleared when mode changed
  379.             ucMode_Curr     = ucMode_Found;
  380.             ucMode_Times    = NO_MODE_TIMES - 2;
  382.             if (MODE_NOSIGNAL == ucMode_Curr)
  383.             {
  384.                 if (SYNC_CS == ucSync_Type)         // CS->SS
  385.                 {
  386.                     RTDCodeW(VGA_SET_SS);
  388.                     bVpole_Curr = 1;
  389.                     bHpole_Curr = 1;
  390.                     ucSync_Type = SYNC_SS;
  392.                 }
  393.                 else if (SYNC_SS == ucSync_Type)    // SS->SOG
  394.                 {
  395.                     RTDCodeW(VGA_SET_SOG);
  397.                     bVpole_Curr = 1;
  398.                     bHpole_Curr = 1;
  399.                     ucSync_Type = SYNC_SOG;
  401.                     
  403.                 }
  404.                 else                                // SOG->CS
  405.                 {
  406.                     RTDCodeW(VGA_SET_CS);
  408.                     bVpole_Curr = 1;
  409.                     bHpole_Curr = 1;
  410.                     ucSync_Type = SYNC_CS;
  412.                     
  414.                 }
  415.             }
  416.         }
  417.     }
  418.     else
  419.     {
  420.         if (ucMode_Found != ucMode_Temp)
  421.         {
  422.             ucMode_Times    = 1;
  423.             ucMode_Found    = ucMode_Temp;
  424. #if(SOURCE_AUTO_SCAN == _FALSE)
  425.             // To prevent from mistaking CS (with VS) for SS, we check SYNC type once when finding a mode in SS.
  426.             if (SYNC_SS == ucSync_Type)
  427.             {           
  428.                 RTDSetByte(SYNC_CTRL_4B, 0x55);
  430.                 RTDSetByte(SYNC_POR_4C, 0x22);
  432.                 m   = (MODE_DETECT_FREQ + 1) * 20;       
  433.                 do
  434.                 {   
  435.                     Delay_Xms(1);
  436.                     RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  437.                 }
  438.                 while ((Data[0] & 0x02) && (--m));
  439.  
  440.                 Data[5] = Data[3];
  441.                 Data[4] = Data[4] & 0x87;
  442.                 Data[3] = Data[1];
  443.                 Data[2] = Data[2] & 0x8f;
  445.                 if ((0 == ((unsigned int *)Data)[1]) || (0x07ff <= ((unsigned int *)Data)[1]) ||
  446.                     (0 == ((unsigned int *)Data)[2]) || (0x07ff <= ((unsigned int *)Data)[2]) ||
  447.                     (0 == m))
  448.                 {
  449.                     ucSync_Type = SYNC_SS;
  451.                     RTDSetByte(SYNC_CTRL_4B, 0x14);
  452.                 }
  453.                 else
  454.                 {
  455.                     ucSync_Type = SYNC_CS;
  457.                     RTDCodeW(VGA_SET_CS);
  459.                     bVpole_Curr = 1;
  460.                     bHpole_Curr = 1;
  461.                 }
  462.             }
  463.             else if (SYNC_SOG == ucSync_Type)
  464.             {
  465.                 RTDSetByte(SYNC_CTRL_4B, 0x14);
  466.                 Delay_Xms(8);
  468.                 RTDSetByte(SYNC_POR_4C, 0x00);
  469.                 RTDSetByte(SYNC_POR_4C, 0x02);
  472.                 m   = (MODE_DETECT_FREQ + 1) * 20;       
  473.                 do
  474.                 {   
  475.                     Delay_Xms(1);
  476.                     RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  477.                 }
  478.                 while ((Data[0] & 0x02) && (--m));
  479.  
  480.                 Data[5] = Data[3];
  481.                 Data[4] = Data[4] & 0x87;
  482.                 Data[3] = Data[1];
  483.                 Data[2] = Data[2] & 0x8f;
  485.                 if ((0 == ((unsigned int *)Data)[1]) || (0x07ff <= ((unsigned int *)Data)[1]) ||
  486.                     (0 == ((unsigned int *)Data)[2]) || (0x07ff <= ((unsigned int *)Data)[2]) ||
  487.                     (0 == m))
  488.                 {
  489.                     ucSync_Type = SYNC_SOG;
  492.                     RTDSetByte(SYNC_CTRL_4B, 0x57);
  493.                     //RTDSetByte(VGIP_SIGINV_05, 0x40);
  494.                     Delay_Xms(8);
  495.                     
  496.                     RTDSetByte(SYNC_POR_4C,0x32);
  497.                     Delay_Xms(20);
  498.                     RTDSetByte(SYNC_POR_4C, 0x00);
  500.                 }
  501.                 else
  502.                 {
  503.                     ucSync_Type = SYNC_SS;
  505.                     RTDCodeW(VGA_SET_SS);
  507.                     bVpole_Curr = 1;
  508.                     bHpole_Curr = 1;
  509.                 }
  510.             }
  511. #endif
  512.         }
  513.         else
  514.         {   
  515.             if (VGA_SEARCH_TIMES > ucMode_Times)
  516.             {
  517.                 ucMode_Times ++;
  518.             }
  519.             else
  520.             {
  522.                 bLIGHT_PWR  = LIGHT_OFF;        // Turn off BackLight for reset display
  523.               
  524.                 RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  525.                 RTDCodeW(OSD_Reset);            // Clear OSD
  527.                 ucMode_Curr     = ucMode_Found; // Supported mode found
  528.                 ucMode_Times    = 0;            // Reset mode timer
  529.                 bStable         = 0;            // bStable must be cleared when mode changed
  531.                 Display_VGA_Set();              // Set VGA Mode registers
  534. #if (RTDDEBUG)
  535.                 if (ucMode_PrevAct == ucMode_Curr)
  536.                 {
  537.                     if (0xff > ucMode_QuitCnt)      ucMode_QuitCnt += 1;
  538.                 }
  539.                 else
  540.                 {
  541.                     ucMode_PrevAct  = ucMode_Curr;
  542.                     ucMode_QuitCnt  = 0;
  543.                     ucDebug         = 0;
  544.                 }
  545. #endif                
  546.             }
  547.         }
  548.     }
  549. }
  551. //-------------------  Check VGA Mode  -------------------//
  552. void Check_VGA_Mode(void)
  553. {    
  554.     RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  556.     if (Data[0] & 0x02)
  557.     {
  558.         RTDSetByte(SYNC_POR_4C, 0x20);          // Input signal time-out. Reset sync-processor
  560.         ucMode_Found    = MODE_NOSUPPORT;
  561.     }
  562.     else
  563.     {
  564.         bVpole_Curr = (bit)(Data[0] & 0x08);    // Current usVsync polarity
  565.         bHpole_Curr = (bit)(Data[0] & 0x04);    // Current usHsync polarity
  567.         Data[5] = Data[3];
  568.         Data[4] = Data[4] & 0x87;
  569.         Data[3] = Data[1];
  570.         Data[2] = Data[2] & 0x8f;
  571.         usHsync = ((unsigned int *)Data)[1];    // Current usHsync timing
  572.         usVsync = ((unsigned int *)Data)[2];    // Current usVsync timing
  574.         // Polarity must be correct
  575.         if ((bVpole_Curr != bVpole_Prev) || (bHpole_Curr != bHpole_Prev))
  576.         {
  577.             RTDRead(VGIP_SIGINV_05, 0x01, N_INC);
  578.             
  579.             Data[0] &= 0xd7;    // HS_RAW & VS positive
  581.             if (!bHpole_Curr)   Data[0] |= 0x20;
  583.             if (!bVpole_Curr && SYNC_SS == ucSync_Type)     Data[0] |= 0x08;    // Seperate sync
  584.             
  585.             RTDSetByte(VGIP_SIGINV_05, Data[0]);
  587.             ucMode_Found    = MODE_NOSUPPORT;
  588.         }
  589.         else
  590.         {
  591.             if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)     // Check overflow
  592.             {
  593.                 ucMode_Found    = MODE_NOSUPPORT;
  594.             }
  595.             else
  596.             {
  597.                 if ((usHsync < (usStdHS - 1)) || (usHsync > (usStdHS + 3)) ||
  598.                     (usVsync < (usStdVS - 1)) || (usVsync > (usStdVS + 3)))
  599.                 {   
  600.                     ucMode_Found    = MODE_NOSUPPORT;
  601.                 }
  602.                 else
  603.                 {
  604.                     ucMode_Found    = ucMode_Curr;
  605.                 }
  606.             }
  607.         }
  608.     }
  609.     
  610.     if (MODE_NOSUPPORT == ucMode_Found)
  611.         Reset_Mode();
  612.     else
  613. {
  614.         bStable = 1;    // Set bStable to 1 when signal timing is stable.
  615. #if(AS_NON_FRAMESYNC)
  616.         RTDSetByte(STATUS0_01, 0x00);  // Clear status
  617.         RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  619.         if(bFrameSync)
  620.            RTDSetBit(ODD_CTRL_8E,0xef,0x10);
  621. #endif
  622.     }
  624. }
  628. /////////////////////////////////////////////////////////
  629. //------------------  Detect DVI Mode  ----------------//
  630. /////////////////////////////////////////////////////////
  631. void Detect_DVI_Mode(void)
  632. {
  633. #if(TMDS_ENABLE)
  634.     unsigned char   ucMode_Temp, m;
  636.     RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  638.     if (Data[0] & 0x02)
  639.     {
  640.         RTDSetByte(SYNC_POR_4C, 0x00);          // Input signal time-out. Reset sync-processor
  642.         ucMode_Temp = MODE_NOSIGNAL;
  643.     }
  644.     else
  645.     {
  646.         usStdHS   = usHsync;  // Save previous usHsync in usStdHS
  647.         usStdVS   = usVsync;  // Save previous usVsync in usStdVS
  649.         bVpole_Curr = (bit)(Data[0] & 0x08);    // Save current usVsync polarity
  650.         bHpole_Curr = (bit)(Data[0] & 0x04);    // Save current usHsync polarity
  652.         Data[5] = Data[3];
  653.         Data[4] = Data[4] & 0x87;
  654.         Data[3] = Data[1];
  655.         Data[2] = Data[2] & 0x8f;
  656.         usHsync = ((unsigned int *)Data)[1];    // Current usHsync timing
  657.         usVsync = ((unsigned int *)Data)[2];    // Current usVsync timing
  659.         // Calculate Vertical Refresh Rate
  660.         // Original Formula :
  661.         // ucRefresh = 24.576M / (usHsync * usVsync)
  662.         // Use Data[0~3] as a temporary long variable
  663.         ((unsigned long *)Data)[0]  = (unsigned long)usHsync * usVsync;
  664.         ucRefresh   = (unsigned long)49152000 / ((unsigned long *)Data)[0];
  665.         ucRefresh   = (ucRefresh & 0x01) ? ((ucRefresh + 1) >> 1) : (ucRefresh >> 1);
  667.         // Treat small change of usHsync/usVsync as no change
  668.         if (usStdHS <= usHsync && (usStdHS + 2) >= usHsync)     usHsync = usStdHS;
  669.         if (usStdVS <= usVsync && (usStdVS + 2) >= usVsync)     usVsync = usStdVS;
  671.         // Set correct polarity
  672.         if ((bVpole_Curr != bVpole_Prev) || (bHpole_Curr != bHpole_Prev))
  673.         {  
  674.             RTDRead(VGIP_SIGINV_05, 0x01, N_INC);
  676.             Data[0] &= 0xf3;  // VS & HS positive
  678.             if (!bVpole_Curr)    Data[0] |= 0x08;
  679.             if (!bHpole_Curr)    Data[0] |= 0x04;
  681.             RTDSetByte(VGIP_SIGINV_05, Data[0]);            
  682.         }
  683.             
  684.         if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)
  685.         {
  686.             ucMode_Temp = MODE_NOSIGNAL;    // Treat overflow as no signal
  687.         }
  688.         else
  689.         {
  690.             ucMode_Temp     = MODE_NOSUPPORT;
  692.             // Search for Standard Mode
  693.             m   = MODE_1600x1200x60HZ;
  694.             do
  695.             {
  696.                 if ((usHsync > VGA_Mode[m][0]) && (usHsync < VGA_Mode[m][1]))
  697.                 {   
  698.                     if ((usVsync >= VGA_Mode[m][2]) && (usVsync <= VGA_Mode[m][3]))
  699.                     {
  700.                         ucMode_Temp     = m;    // Support mode
  701.                     }
  702.                 }
  703.             }
  704.             while ((0 != --m) && (MODE_NOSUPPORT == ucMode_Temp));
  705.      
  706.             if (MODE_NOSUPPORT == ucMode_Temp)
  707.             {
  708.                 // Search for User Mode
  709.                 m   = MODE_USER1600x1200;
  710.                 do
  711.                 {
  712.                     if ((usHsync >= VGA_Mode[m][0]) && (usHsync <= VGA_Mode[m][1]))
  713.                     {   
  714.                         if ((usVsync >= VGA_Mode[m][2]) && (usVsync <= VGA_Mode[m][3]))
  715.                         {
  716.                             ucMode_Temp     = m;    // Support User Mode
  717.                         }
  718.                     }
  719.                 }
  720.                 while ((MODE_USER720x400 <= --m) && (MODE_NOSUPPORT == ucMode_Temp));
  721.             }
  722.             
  723.             if (48 > ucRefresh || MAX_RATE < ucRefresh)
  724.                 ucMode_Temp = MODE_NOSUPPORT;               // We don't support vertical refresh rate lower than 50Hz
  725.             else
  726.                 ucMode_Temp = Seek_DVI_Mode(ucMode_Temp);   // Seek mode in according to data enable width and height
  727.         }
  728.     }
  730.     //-------------Check result--------------
  731.     if (MODE_NOSUPPORT == ucMode_Temp || MODE_NOSIGNAL == ucMode_Temp)  // No Detect
  732.     {
  733.         if (MODE_NOSUPPORT != ucMode_Found && MODE_NOSIGNAL != ucMode_Found)    ucMode_Times    = 0;
  735.         ucMode_Found    = ucMode_Temp;
  737.         if (NO_MODE_TIMES > ucMode_Times)
  738.         {
  739.             ucMode_Times ++;
  740.             
  741. //Enable the TMDS Hsync & Vsync error correction to improve the long cable image quality
  742.             RTDSetByte(TMDS_CORRECTION_FF,0x03); 
  743.         }
  744.         else
  745.         {
  746.     //Disable the TMDS Hsync & Vsync error correction
  747.             RTDSetByte(TMDS_CORRECTION_FF,0x00);
  749.             bStable         = (ucMode_Curr == ucMode_Found) ? 1 : 0;    // bStable must be cleared when mode changed
  750.             ucMode_Curr     = ucMode_Found;
  751.             ucMode_Times    = NO_MODE_TIMES - 2;
  752.         }
  753.     }
  754.     else
  755.     {
  756.         if (ucMode_Found != ucMode_Temp)
  757.         {
  758.             ucMode_Times    = 1;
  759.             ucMode_Found    = ucMode_Temp;
  760.         }
  761.         else
  762.         {   
  763.             if (DVI_SEARCH_TIMES > ucMode_Times)
  764.             {
  765.                 ucMode_Times ++;
  766.             }
  767.             else
  768.             {
  770.                 bLIGHT_PWR  = LIGHT_OFF;        // Turn off BackLight for reset display
  772.                 RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  773.                 RTDCodeW(OSD_Reset);            // Clear OSD
  775.                 ucMode_Curr     = ucMode_Found; // Search mode OK
  776.                 ucMode_Times    = 0;            // Reset mode timer
  777.                 bStable         = 0;            // bStable must be cleared when mode changed
  779.                 Display_DVI_Set();              // Set VGA Mode registers
  780. #if (RTDDEBUG)
  781.                 if (ucMode_PrevAct == ucMode_Curr)
  782.                 {
  783.                     if (0xff > ucMode_QuitCnt)      ucMode_QuitCnt += 1;
  784.                 }
  785.                 else
  786.                 {
  787.                     ucMode_PrevAct  = ucMode_Curr;
  788.                     ucMode_QuitCnt  = 0;
  789.                     ucDebug         = 0;
  790.                 }
  791. #endif                
  792.             }
  793.         }
  794.     }
  795. #else
  796.      Display_DVI_Set();
  797. #endif
  798. }
  800. unsigned char Seek_DVI_Mode(unsigned char mode)
  801. {
  802. #if(TMDS_ENABLE)
  803.     unsigned char   Wait_Time_Cnt;
  805.     RTDSetByte(SYNC_POR_4C, 0x03);  // Measure data enable width and height
  807.     Wait_Time_Cnt  = 60;       
  808.     do
  809.     {   
  810.         Delay_Xms(1);
  811.         RTDRead(SYNC_POR_4C, 0x07, Y_INC);
  812.     }
  813.     while ((Data[0] & 0x02) && (--Wait_Time_Cnt));
  815.     Data[7] = Data[5];
  816.     Data[6] = Data[6] & 0x0f;
  817.     Data[5] = Data[3];
  818.     Data[4] = Data[4] & 0x87;
  819.     Data[3] = Data[1];
  820.     Data[2] = Data[2] & 0x8f;
  822.     // Measure Failed !!!
  823.     if ((0 == ((unsigned int *)Data)[1]) || (0x07ff <= ((unsigned int *)Data)[1]) ||
  824.         (0 == ((unsigned int *)Data)[2]) || (0x07ff <= ((unsigned int *)Data)[2]) ||
  825.         (0 == Wait_Time_Cnt))
  826.     {
  827.         RTDSetByte(SYNC_POR_4C, 0x00);
  829.         return MODE_NOSUPPORT;
  830.     }
  832.     // Save IH_TOTAL in usADC_Clock
  833.     usADC_Clock     = ((unsigned int *)Data)[1] * 2;
  835.     // Save input data enable width and height
  836.     usIPV_ACT_LEN   = ((unsigned int *)Data)[2];
  837.     usIPH_ACT_WID   = ((unsigned int *)Data)[3] * 2;
  839.     // We don't support input image less than 350 active lines
  840.     if (350 > usIPV_ACT_LEN)    return MODE_NOSUPPORT;
  842.     // We only support 8N active width
  843.     usIPH_ACT_WID   = (2 < (usIPH_ACT_WID & 0x0007)) ? ((usIPH_ACT_WID + 8) & 0xfff8) : (usIPH_ACT_WID & 0xfff8);
  845.     // We only support active width not larger than 1280
  846.     if (1280 < usIPH_ACT_WID)   usIPH_ACT_WID   = 1280;
  848.     // Calculate maximum usIPV_ACT_LEN limitation
  849.     ((unsigned int *)Data)[0]   = (unsigned long)(usVsync - 1) * DISP_LEN / MIN_DV_TOTAL;
  851.     if (((unsigned int *)Data)[0] < usIPV_ACT_LEN)      usIPV_ACT_LEN   = ((unsigned int *)Data)[0];
  853.     if (MODE_NOSUPPORT == mode)
  854.     {
  855.         mode    = MODE_UNDEFINED0;
  856.     }
  857.     else if (CAP_WIN[mode][2] != usIPH_ACT_WID || CAP_WIN[mode][4] != usIPV_ACT_LEN)
  858.     {
  859.         switch (usIPV_ACT_LEN)
  860.         {
  861.         case 350 :
  862.             if (MODE_0640x0350x70HZ <= mode && MODE_0720x0400x70HZ >= mode)
  863.             {
  864.                 mode    = (716 > usIPH_ACT_WID) ? MODE_0640x0350x70HZ : MODE_0720x0350x70HZ;
  865.             }
  866.             else if (MODE_0640x0350x85HZ <= mode && MODE_0720x0400x85HZ >= mode)
  867.             {
  868.                 mode    = MODE_0640x0350x85HZ;
  869.             }
  870.             else if (MODE_0640x0480x50HZ == mode)
  871.             {
  872.                 mode    = MODE_VGA350x50Hz;
  873.             }
  874.             else if (MODE_0640x0480x60HZ == mode)
  875.             {
  876.                 mode    = MODE_VGA350x60Hz;
  877.             }
  878.             else
  879.             {
  880.                 mode    = MODE_UNDEFINED0;
  881.             }
  882.             break;
  883.         case 400 :
  884.             if (MODE_0640x0350x70HZ <= mode && MODE_0720x0400x70HZ >= mode)
  885.             {
  886.                 mode    = (716 > usIPH_ACT_WID) ? MODE_0640x0400x70HZ : MODE_0720x0400x70HZ;
  887.             }
  888.             else if (MODE_0640x0350x85HZ <= mode && MODE_0720x0400x85HZ >= mode)
  889.             {
  890.                 mode    = (716 > usIPH_ACT_WID) ? MODE_0640x0400x85HZ : MODE_0720x0400x85HZ;
  891.             }
  892.             else if (MODE_0640x0480x50HZ == mode)
  893.             {
  894.                 mode    = MODE_VGA400x50Hz;
  895.             }
  896.             else if (MODE_0640x0480x60HZ == mode)
  897.             {
  898.                 mode    = MODE_VGA400x60Hz;
  899.             }
  900.             else if (MODE_USER720x400 != mode)
  901.             {
  902.                 mode    = MODE_UNDEFINED0;
  903.             }
  904.             break;
  905.         case 480 :
  906.             if ((MODE_USER640x480 != mode) && ((MODE_0640x0480x50HZ > mode) || (MODE_0640x0480x85HZ < mode)))
  907.                 mode    = MODE_UNDEFINED0;
  908.             break;
  909.         case 600 :
  910.             if ((MODE_USER800x600 != mode) && ((MODE_0800x0600x56HZ > mode) || (MODE_0800x0600x85HZ < mode)))
  911.                 mode    = MODE_UNDEFINED0;
  912.             break;
  913.         case 624 :
  914.             if (MODE_0832x0624x75HZ != mode)    
  915.                 mode    = MODE_UNDEFINED0;
  916.             break;
  917.         case 768 :
  918.             if ((MODE_USER1024x768 != mode) && ((MODE_1024x0768x60HZ > mode) || (MODE_1024x0768x85HZ < mode)))
  919.                 mode    = MODE_UNDEFINED0;
  920.             break;
  921.         case 800 :
  922.             if (MODE_1024x0800x84HZ != mode)
  923.                 mode    = MODE_UNDEFINED0;
  924.             break;
  925.         case 864 :
  926.             if ((MODE_USER1152x864 != mode) && (MODE_1152x0864x75HZ != mode))   
  927.                 mode    = MODE_UNDEFINED0;
  928.             break;
  929.         case 870 :
  930.             if (MODE_1152x0870x75HZ != mode)
  931.                 mode    = MODE_UNDEFINED0;
  932.             break;
  933.         case 900 :
  934.             if ((MODE_USER1152x900 != mode) && ((MODE_1152x0900x66HZ > mode) || (MODE_1152x0900x76HZ < mode)))
  935.                 mode    = MODE_UNDEFINED0;
  936.             break;
  937.         case 960 :
  938.             if ((MODE_USER1280x960 != mode) && ((MODE_1280x0960x60HZ > mode) || (MODE_1280x0960x85HZ < mode)))
  939.                 mode    = MODE_UNDEFINED0;
  940.             break;
  941.         case 1024 :
  942.             if ((MODE_USER1280x1024 != mode) && ((MODE_1280x1024x60HZ > mode) || (MODE_1280x1024x85HZ < mode)))
  943.                 mode    = MODE_UNDEFINED0;
  944.             break;
  945.         case 1600 :
  946.             if ((MODE_USER1600x1200 != mode) && (MODE_1600x1200x60HZ != mode))
  947.                 mode    = MODE_UNDEFINED0;
  948.             break;
  949.         default :
  950.             mode    = MODE_UNDEFINED0;
  951.             break;
  952.         }
  953.     }
  955.     if (MODE_UNDEFINED0 == mode)
  956.     {
  957.         // First, we try user-mode to fit the undefined mode for full-screen display.
  958.         Wait_Time_Cnt   = MODE_USER720x400;
  959.         do
  960.         {
  961.             if (Mode_Preset[Wait_Time_Cnt][2] < CAP_WIN[Wait_Time_Cnt][4])   // V scale-down
  962.             {
  963.                 // Larger scale-down ratio may need a larger DH_TOTAL. 
  964.                 // So usIPV_ACT_LEN should not be too larger than pre-set capture window length
  965.                 if (Mode_Preset[Wait_Time_Cnt][2] > usIPV_ACT_LEN || (CAP_WIN[Wait_Time_Cnt][4] + 24) < usIPV_ACT_LEN)   continue;
  966.             }
  967.             else
  968.             {
  969.                 if (Mode_Preset[Wait_Time_Cnt][2] < usIPV_ACT_LEN)   continue;
  970.             }
  972.             ((unsigned int *)Data)[0]   = (unsigned long)2458 * Mode_Preset[Wait_Time_Cnt][0] * Mode_Preset[Wait_Time_Cnt][2]
  973.                                         / ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
  974.             
  975.             // Return if we find out a suitable user-mode.
  976.             if (MAX_DCLK > ((unsigned int *)Data)[0])   return Wait_Time_Cnt;
  977.         }
  978.         while (MODE_USER1600x1200 >= ++Wait_Time_Cnt);
  980.         // If failed, we try partial-screen display.
  982.         if (DISP_LEN < usIPV_ACT_LEN)   // Scale-down
  983.         {
  984.             ((unsigned int *)Data)[0]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED1][0] * DISP_LEN 
  985.                                         / ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
  987.             if (MAX_DCLK < ((unsigned int *)Data)[0])
  988.             {
  989.                 ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED1][0] * MIN_DV_TOTAL
  990.                                             / ((unsigned long)100 * (usVsync - 1) * usHsync);
  992.                 if (MAX_DCLK < ((unsigned int *)Data)[1])
  993.                 {
  994.                     // Decrease usIPV_ACT_LEN to DISP_LEN and go further to check if it can be displayed.
  995.                     usIPV_ACT_LEN   = DISP_LEN;
  996.                 }
  997.                 else
  998.                 {                 
  999.                     mode    = MODE_UNDEFINED1 | 0x80;   // Scale-down and partial-V display
  1000.                 }
  1001.             }
  1002.             else
  1003.                 mode    = MODE_UNDEFINED1;              // Scale-down and full-V display
  1004.         }
  1006.         if (DISP_LEN >= usIPV_ACT_LEN)  // Scale-up
  1007.         {
  1008.             ((unsigned int *)Data)[0]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0] * DISP_LEN 
  1009.                                         / ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
  1011.             if (MAX_DCLK < ((unsigned int *)Data)[0])
  1012.             {
  1013.                 if (MIN_DV_TOTAL >= (usVsync - 1))
  1014.                 {
  1015.                     ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0] * MIN_DV_TOTAL 
  1016.                                                 / ((unsigned long)100 * (usVsync - 1) * usHsync);
  1017.                 }
  1018.                 else
  1019.                 {
  1020.                     ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0]
  1021.                                                 / ((unsigned long)100 * usHsync);
  1022.                 }
  1024.                 if (MAX_DCLK < ((unsigned int *)Data)[1])
  1025.                     mode    = MODE_NOSUPPORT;           // Cannot display
  1026.                 else
  1027.                     mode    = MODE_UNDEFINED0 | 0x80;   // Scale-up and partial-screen display
  1028.             }
  1029.             else
  1030.                 mode    = MODE_UNDEFINED0;          // Scale-up and full-screen display
  1031.         }
  1032.     }
  1034.     return  mode;
  1035. #else
  1036.     mode    = MODE_UNDEFINED0;
  1037.     return  0;
  1038. #endif
  1039. }
  1041. //-------------------  Check DVI Mode  -------------------//
  1042. void Check_DVI_Mode(void)
  1043. {    
  1044. #if(TMDS_ENABLE)
  1045.     RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  1047.     if (Data[0] & 0x02)
  1048.     {
  1049.         RTDSetByte(SYNC_POR_4C, 0x00);      // Reset Sync Processor
  1051.         ucMode_Found    = MODE_NOSUPPORT;
  1052.     }
  1053.     else
  1054.     {
  1055.         bVpole_Curr = (bit)(Data[0] & 0x08);    // Current usVsync polarity
  1056.         bHpole_Curr = (bit)(Data[0] & 0x04);    // Current usHsync polarity
  1058.         Data[5] = Data[3];
  1059.         Data[4] = Data[4] & 0x87;
  1060.         Data[3] = Data[1];
  1061.         Data[2] = Data[2] & 0x8f;
  1062.         usHsync = ((unsigned int *)Data)[1];    // Current usHsync timing
  1063.         usVsync = ((unsigned int *)Data)[2];    // Current usVsync timing
  1065.         // Polarity must be correct
  1066.         if ((bVpole_Curr != bVpole_Prev) || (bHpole_Curr != bHpole_Prev))
  1067.         {
  1068.             RTDRead(VGIP_SIGINV_05, 0x01, N_INC);
  1069.             
  1070.             Data[0] &= 0xf3;  // VS & HS positive
  1072.             if (!bVpole_Curr)    Data[0] |= 0x08;
  1073.             if (!bHpole_Curr)    Data[0] |= 0x04;
  1074.             
  1075.             RTDSetByte(VGIP_SIGINV_05, Data[0]);
  1077.             ucMode_Found    = MODE_NOSUPPORT;
  1078.         }
  1079.         else
  1080.         {
  1081.             if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)     // Check overflow
  1082.             {
  1083.                 ucMode_Found    = MODE_NOSUPPORT;
  1084.             }
  1085.             else
  1086.             {
  1087.                 if ((usHsync < (usStdHS - 1)) || (usHsync > (usStdHS + 3)) ||
  1088.                     (usVsync < (usStdVS - 1)) || (usVsync > (usStdVS + 3)))
  1089.                 {   
  1090.                     ucMode_Found    = MODE_NOSUPPORT;
  1091.                 }
  1092.                 else
  1093.                 {
  1094.                     ucMode_Found    =  ucMode_Curr;
  1095.                 }
  1096.             }
  1097.         }
  1098.     }
  1099.     
  1100.     if (MODE_NOSUPPORT == ucMode_Found)
  1101.         Reset_Mode();
  1102.     else
  1103.         bStable = 1;    // Set bStable to 1 when signal timing is stable.
  1104. #endif
  1105. }
  1107. /////////////////////////////////////////////////////////
  1108. //------------------ Detect VIDEO Mode ----------------//
  1109. /////////////////////////////////////////////////////////
  1110. void Detect_Video_Mode(void)
  1111. {
  1112. #if(VIDEO_CHIP != VDC_NONE)
  1113.     I2CRead(ADDR_VIDEO, 0x1f, 0x01);
  1115.     //------ Check Horizontal Lock & Frequency ------
  1116.     if (0 == (Data[0] & 0x40))
  1117.     {   
  1118.         if ((Data[0] & 0x20) && (0x01 != (ucAV_Mode & 0x0f)))
  1119.         {
  1120.             // Field rate changed to 60Hz
  1121.             ucAV_Mode       = 0x01;
  1122.             ucMode_Found    = MODE_NOSUPPORT;
  1123.             ucMode_Times    = 0;
  1125.             Data[0] = 4;
  1126.             Data[1] = ADDR_VIDEO;
  1127.             Data[2] = 0x0e;
  1128.             Data[3] = 0x08;     // Start color search from NTSC-M
  1129.             I2CWrite(Data);
  1130.         }
  1131.         else if ((0 == (Data[0] & 0x20)) && (0x02 != (ucAV_Mode & 0x02)))
  1132.         {
  1133.             // Field rate changed to 50Hz
  1134.             ucAV_Mode       = 0x02; 
  1135.             ucMode_Found    = MODE_NOSUPPORT;
  1136.             ucMode_Times    = 0;
  1137.             
  1138.             Data[0] = 4;
  1139.             Data[1] = ADDR_VIDEO;
  1140.             Data[2] = 0x0e;
  1141.             Data[3] = 0x08;     // Start color search from PAL-BDGHI
  1142.             I2CWrite(Data);
  1143.         }
  1144.         else
  1145.         {    
  1146.             //------ Check Lock Color ------
  1147.             if (0x01 == (Data[0] & 0x01))
  1148.             {   
  1149.                 // Lock Color
  1150.                 if (ucAV_Mode & 0x01)
  1151.                 {
  1152.                     if (MODE_VIDEO60HZ == ucMode_Found)
  1153.                     {
  1154.                         ucMode_Times ++;
  1155.                     }
  1156.                     else
  1157.                     {
  1158.                         ucMode_Found    = MODE_VIDEO60HZ;
  1159.                         ucMode_Times    = 0;
  1160.                     }
  1161.                 }
  1162.                 else
  1163.                 {
  1164.                     if (MODE_VIDEO50HZ == ucMode_Found)
  1165.                     {
  1166.                         ucMode_Times ++;
  1167.                     }
  1168.                     else
  1169.                     {
  1170.                         ucMode_Found    = MODE_VIDEO50HZ;
  1171.                         ucMode_Times    = 0;
  1172.                     }
  1173.                 }
  1174.             }
  1175.             else
  1176.             {
  1177.                 // Non Lock Color
  1178.                 if (MODE_NOSUPPORT != ucMode_Found)
  1179.                 {
  1180.                     ucMode_Found    = MODE_NOSUPPORT;
  1181.                     ucMode_Times    = 0;
  1182.                 }
  1183.                 
  1184.                 Data[0] = 4;
  1185.                 Data[1] = ADDR_VIDEO;
  1186.                 Data[2] = 0x0e;
  1187.                 
  1188.                 if (0x03 == (ucAV_Mode & 0x03))
  1189.                 {
  1190.                     // SECAM -> PAL-BDGHI(50Hz)
  1191.                     Data[3] = 0x08;
  1192.                     I2CWrite(Data);                    
  1193.                     ucAV_Mode   = 0x02;
  1194.                 }
  1195.                 else
  1196.                 {
  1197.                     if (ucMode_Times & 0x01)    // Every 2-times , change color
  1198.                     {
  1199.                         switch (ucAV_Mode & 0x70)
  1200.                         {
  1201.                         case 0x00:  
  1202.                             Data[3] = 0x18; // NTSC-4.43(50Hz)  // PAL-4.43(60Hz)
  1203.                             I2CWrite(Data);
  1204.                             ucAV_Mode   = (ucAV_Mode & 0x0f) | 0x10;
  1205.                             break;
  1206.                         case 0x10:
  1207.                             Data[3] = 0x28; // PAL-N(50Hz)      // NTSC-4.43(60Hz)
  1208.                             I2CWrite(Data);
  1209.                             ucAV_Mode   = (ucAV_Mode & 0x0f) | 0x20;
  1210.                             break;
  1211.                         case 0x20:
  1212.                             Data[3] = 0x38; // NTSC-N(50Hz)     // PAL-M(60Hz)
  1213.                             I2CWrite(Data);
  1214.                             ucAV_Mode   = (ucAV_Mode & 0x0f) | 0x30;
  1215.                             break;
  1216.                         case 0x30:
  1217.                             if (ucAV_Mode & 0x02)
  1218.                             {
  1219.                                 // NTSC-N -> SECAM (50Hz)
  1220.                                 Data[3]     = 0x5c;
  1221.                                 I2CWrite(Data);
  1222.                                 ucAV_Mode   = 0x03;
  1223.                             }
  1224.                             else
  1225.                             {
  1226.                                 // PAL-M -> NTSC_M (60Hz)
  1227.                                 Data[3]     = 0x08;
  1228.                                 I2CWrite(Data);
  1229.                                 ucAV_Mode   = ucAV_Mode & 0x0f | 0x00;
  1230.                             }    
  1231.                         default:
  1232.                             break;
  1233.                         }//end of "switch (ucAV_Mode & 0x70)"
  1234.                     }//end of "if (ucMode_Times & 0x01)"
  1235.                 }//end of "if (0x03 == (ucAV_Mode & 0x03)) else"
  1236.             }//end of "Non Lock color
  1237.         }//end of "Check Lock Color"
  1238.     }//end of "if (0==(Data[0] & 0x40))"
  1239.     else
  1240.     {   
  1241.         // Non Horizontal Lock
  1242.         ucAV_Mode   = 0;
  1243.         
  1244.         if (ucMode_Found != MODE_NOSUPPORT)
  1245.         {
  1246.             ucMode_Found    = MODE_NOSUPPORT;
  1247.             ucMode_Times    = 0;
  1248.         }
  1249.     }
  1250.     
  1251.     //-------------Check result--------------
  1252.     if (MODE_NOSUPPORT != ucMode_Found)
  1253.     {   
  1254.         if (VIDEO_SEARCH_TIMES < ucMode_Times)
  1255.         {
  1257.             bLIGHT_PWR  = LIGHT_OFF;        // Turn off BackLight for reset display
  1258.             
  1259.             RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  1260.             RTDCodeW(OSD_Reset);            // Clear OSD
  1261.             
  1262.             if (SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07))
  1263.                 ucMode_Curr = (ucAV_Mode & 0x02) ? MODE_YUV50HZ : MODE_YUV60HZ;
  1264.             else
  1265.                 ucMode_Curr = ucMode_Found;
  1266.                     
  1267.             ucMode_Times    = 0;
  1268.             bStable         = 0;            // bStable must be cleared when mode changed
  1270.             Display_Video_Set();            
  1271.         }
  1272.     }
  1273.     else
  1274.     {
  1275.         ucMode_Times ++;
  1276.         
  1277.         if (ucAV_Mode)
  1278.         {
  1279.             // Force to display although we cannot lock color
  1280.             if (VIDEO_SEARCH_TIMES < ucMode_Times 
  1281.                 && (NO_COLOR_TIMES < ucMode_Times || SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07)))
  1282.             {
  1284.                 bLIGHT_PWR  = LIGHT_OFF;        // Turn off BackLight for reset display
  1286.                 RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  1287.                 RTDCodeW(OSD_Reset);            // Clear OSD
  1288.                 
  1289.                 ucAV_Mode       = (ucAV_Mode & 0x02) ? 0x82 : 0x81;
  1291.                 if (SOURCE_YUV != (stGUD1.INPUT_SOURCE & 0x07))
  1292.                     ucMode_Curr = (ucAV_Mode & 0x02) ? MODE_VIDEO50HZ : MODE_VIDEO60HZ;
  1293.                 else
  1294.                     ucMode_Curr = (ucAV_Mode & 0x02) ? MODE_YUV50HZ : MODE_YUV60HZ;
  1296.                 ucMode_Times    = 0;
  1297.                 bStable         = 0;    // bStable must be cleared when mode changed
  1299.                 Display_Video_Set();
  1300.             }
  1301.         }
  1302.         else
  1303.         {
  1304.             if (NO_MODE_TIMES < ucMode_Times)
  1305.             {
  1306.                 bStable         = 1;    // Set bStable to 1 when signal timing is stable.
  1308.                 ucMode_Times    = NO_MODE_TIMES - 1;
  1309.             }
  1310.         }
  1311.     }
  1312. #else
  1313.     Display_Video_Set();
  1314. #endif
  1315. }
  1317. //-------------------  Check AV Mode  -------------------//
  1318. void Check_Video_Mode(void)
  1319. {   
  1320. #if(VIDEO_CHIP != VDC_NONE)
  1321.     I2CRead(ADDR_VIDEO, 0x1f, 0x01);
  1322.     
  1323.     // Check color
  1324.     if (0 == (ucAV_Mode & 0x80))
  1325.     {
  1326.         if (0 == (Data[0] & 0x01))      ucMode_Curr = MODE_NOSIGNAL;    // Color standard changed
  1327.     }
  1328.     else
  1329.     {
  1330.         if (0 == (Data[0] & 0x01))
  1331.         {
  1332.             ucMode_Times    = 0;
  1333.         }
  1334.         else
  1335.         {
  1336.             // When we cannot lock color, we set color standard to PAL-BDGHI if field rate is 50Hz, 
  1337.             // and to NTSC-M if it is 60Hz.
  1338.             // If we find color is locked, we should update ucAV_Mode to indicate we now get color.
  1339.             if (VIDEO_SEARCH_TIMES < ++ucMode_Times)    ucAV_Mode = ucAV_Mode & 0x0f;
  1340.         }
  1341.     }
  1343.     // Check field rate
  1344.     if (Data[0] & 0x40)
  1345.     {
  1346.         ucMode_Curr = MODE_NOSIGNAL;
  1347.     }
  1348.     else
  1349.     {
  1350.         if (ucAV_Mode & 0x02)       // 50Hz
  1351.         {   
  1352.             if (0x00 != (Data[0] & 0x20))   ucMode_Curr = MODE_NOSIGNAL;
  1353.         } 
  1354.         else                        // 60Hz
  1355.         {
  1356.             if (0x00 == (Data[0] & 0x20))   ucMode_Curr = MODE_NOSIGNAL;
  1357.         }
  1358.     }
  1359.    
  1360.     // Check result
  1361.     if (MODE_NOSIGNAL == ucMode_Curr)
  1362.         Reset_Mode();
  1363.     else
  1364.         bStable = 1;    // Set bStable to 1 when signal timing is stable.
  1365. #endif
  1366. }
  1369. void Initial_Mode(void)
  1370. {
  1371.     unsigned char   ucOption;
  1372.     unsigned int    usDispLen;
  1374.     // bit 7 of ucMode_Curr : partial-V display.
  1375.     // bit 6 of ucMode_Curr : select 720x350 or 720x400 for VGA-50Hz and VGA-60Hz
  1376.     ucOption    = ucMode_Curr & 0xc0;
  1377.     ucMode_Curr = ucMode_Curr & 0x3f;
  1379.     
  1380. RTDSetBit(SD_CTRL_70, 0xf9, VGA_ICLK_DELAY);
  1381.     if (SOURCE_DVI == (stGUD1.INPUT_SOURCE & 0x07))
  1382.     {
  1383.         RTDSetBit(SD_CTRL_70, 0xf9, TMDS_ICLK_DELAY);
  1385.         usIPH_ACT_STA   = CAP_WIN[ucMode_Curr][1];
  1386.     }
  1387.     else
  1388.     {
  1390. if (ucOption & 0x40)
  1391. {
  1392. // Only VGA-50Hz and VGA-60Hz mode will set bit 6 of ucMode_Curr to indicate 720-pixel capture width
  1393. // In these case, we should use 720 horizontal settings instead of 640 horizontal settings in table.
  1394. usADC_Clock     = CAP_WIN[MODE_0720x0400x70HZ][0];
  1395. usIPH_ACT_STA   = CAP_WIN[MODE_0720x0400x70HZ][1];
  1396. usIPH_ACT_WID   = CAP_WIN[MODE_0720x0400x70HZ][2];
  1397. }
  1398. else
  1399. {
  1400. usADC_Clock     = CAP_WIN[ucMode_Curr][0];
  1401. usIPH_ACT_STA   = CAP_WIN[ucMode_Curr][1];
  1402. usIPH_ACT_WID   = CAP_WIN[ucMode_Curr][2];
  1404. // Calculate pixel clock rate (round to MHz)
  1405. usDispLen   = (unsigned long)24576 * usADC_Clock / ((unsigned long)usHsync * 500);
  1406. usDispLen   = (usDispLen >> 1) + (usDispLen & 0x01);
  1408. // Use ADC to do H scale-down if pixel clock rate is over spec.
  1409. if (MAX_ADC_FREQ < usDispLen && MODE_USER1152x864 <= ucMode_Curr && MODE_USER1600x1200 >= ucMode_Curr)
  1410. {
  1411. usADC_Clock     = ADC_SD_SET[ucMode_Curr - MODE_USER1152x864][0];
  1412. usIPH_ACT_STA   = ADC_SD_SET[ucMode_Curr - MODE_USER1152x864][1];
  1413. usIPH_ACT_WID   = ADC_SD_SET[ucMode_Curr - MODE_USER1152x864][2];
  1414. }
  1416. } //if (ucOption & 0x40)
  1418. // Calculate pixel clock rate (round to MHz)
  1419. usDispLen   = (unsigned long)24576 * usADC_Clock / ((unsigned long)usHsync * 500);
  1420. usDispLen   = (usDispLen >> 1) + (usDispLen & 0x01);
  1423. // To improve ADC performance ,when the data rate is slow, use single channel,otherwise, use dual channel
  1424. RTDSetBit(ADC_REG_CLK_EA,0xe0,(45 > usDispLen) ? 0x10 | (ADC_RED_PHASE_FT & 0x0c) |( ADC_BLUE_PHASE_FT & 0x03): 
  1425.                                                  0x00 | (ADC_RED_PHASE_FT & 0x0c) |( ADC_BLUE_PHASE_FT & 0x03)); 
  1428. // To imporve the FIFO efficiency only when input data rate is slow, and display data rate is high.
  1429. // RTDSetBit(VGIP_CTRL_04, 0xe3, (40 > usDispLen) ? 0x14 : 0x00);
  1430.     RTDSetBit(VGIP_CTRL_04, 0xf3, (60 > usDispLen) ? 0x08 : 0x00);
  1432. RTDSetByte(PE_CONTROL_3C, 0x00);    // HSYNC positive/negtive tracking
  1434.     RTDSetByte(ADC_FRAME_MODULE_EB,0x06);
  1435. //  RTDSetByte(ADC_FRAME_MODULE_EB,(usIPH_ACT_WID == 1280) ? 0x04 : 0x00);
  1438.   // Set ADC bandwidth to reduce high frequency noise
  1439. //  RTDSetByte(ADC_REG_TEST_E9, (35 > usDispLen) ? 0x08 : (150 > usDispLen) ? 0x10 : 0x18);
  1443. #if(ADC_DEFFERENTIAL)
  1444.     RTDSetBit(ADC_DIFF_MODE_EC,0xff,0x40); //Differential mode
  1445. #else
  1446.     RTDSetBit(ADC_DIFF_MODE_EC,0xbf,0x00); //Single endded mode
  1447. #endif
  1452. RTDSetByte(ADC_REG_CUR_H_E8, 0x0d | (ADC_GREEN_PHASE_FT & 0x30));
  1456.     RTDSetBit(ADC_FRAME_MODULE_EB,0xc7, ((ADC_RED_PHASE_FT & 0x10) << 1) | ((ADC_GREEN_PHASE_FT & 0x40) << 2) 
  1457.                                    |((ADC_BLUE_PHASE_FT & 0x04) << 1));
  1461.     RTDSetBit(TMDS_CORRECTION_FF,0xff,0x04); //Enable the ADC digital filter
  1464.     if(ucMode_Curr < MODE_1024x0768x70HZ)
  1465.      RTDSetByte(ADC_REG_TEST_E9, 0x08);
  1466.     else 
  1467.         RTDSetByte(ADC_REG_TEST_E9, 0x10);
  1470. // Get usIPV_ACT_LEN
  1471. if (MODE_UNDEFINED0 > ucMode_Curr)
  1472. {
  1473. // We've already decided usIPV_ACT_LEN in Detect_VGA_Mode() for undefined SU/SD mode.
  1474. // Only defined modes need to decide usIPV_ACT_LEN here.
  1475. usIPV_ACT_LEN   = CAP_WIN[ucMode_Curr][4];
  1476. }
  1477.     
  1478.     } //if (SOURCE_DVI == (stGUD1.INPUT_SOURCE & 0x07))
  1480.     // Get standard usIPV_ACT_STA 
  1482.     RTDSetByte(IVS_DELAY_8C, PROGRAM_VDELAY);
  1484.     usIPV_ACT_STA   = CAP_WIN[ucMode_Curr][3] - PROGRAM_VDELAY - 1;
  1487.     RTDSetByte(IHS_DELAY_8D, PROGRAM_HDELAY);
  1489. //    usIPH_ACT_STA   = usIPH_ACT_STA + CAPTURE_HDELAY - PROGRAM_HDELAY;
  1490.     if(ucMode_Curr < MODE_0800x0600x75HZ)
  1491. Data[0] = 2;
  1492.     else if(ucMode_Curr < MODE_1280x1024x75HZ)
  1493. Data[0] = 5;
  1494.     else
  1495. Data[0] = 3;
  1497. //    Data[0] = 5;
  1498.     usIPH_ACT_STA   = usIPH_ACT_STA + Data[0] - PROGRAM_HDELAY;
  1500.     // Decide display length (height) and store to usDispLen
  1502.     usDispLen   = Mode_Preset[ucMode_Curr][2];
  1504.     if (MODE_UNDEFINED0 == ucMode_Curr)         // partical-screen scale-up mode
  1505.     {
  1506.         if (ucOption & 0x80)    // partial-V
  1507.         {           
  1508. if (MIN_DV_TOTAL > (usVsync - 1))
  1509.                 usDispLen   = (unsigned long)usIPV_ACT_LEN * MIN_DV_TOTAL / (usVsync - 1);
  1510.             else
  1511.                 usDispLen   = usIPV_ACT_LEN;    // No V scale-up
  1512.         }
  1513.     }
  1514.     else if (MODE_UNDEFINED1 == ucMode_Curr)    // partial-screen scale-down mode
  1515.     {
  1516.         if (ucOption & 0x80)    // partial-V
  1517.         {
  1518.             usDispLen   = (unsigned long)usIPV_ACT_LEN * MIN_DV_TOTAL / (usVsync - 1);
  1519.         }
  1520.     } //if (MODE_UNDEFINED0 == ucMode_Curr)         // partical-screen scale-up mode
  1522.     if (Mode_Preset[ucMode_Curr][2] < usDispLen)    usDispLen   = Mode_Preset[ucMode_Curr][2];
  1524.     // This F/W do not support V scale-up(or bypass) and H scale-down simultaneously
  1525.     if (usDispLen >= usIPV_ACT_LEN && Mode_Preset[ucMode_Curr][1] < usIPH_ACT_WID)
  1526.     {
  1527.         usIPH_ACT_WID   = Mode_Preset[ucMode_Curr][1];
  1528.     }
  1530.     if (usDispLen > usIPV_ACT_LEN)                      ucOption    |= 0x01;    // bit 0 : V scale-up
  1531.     if (usDispLen < usIPV_ACT_LEN)                      ucOption    |= 0x02;    // bit 1 : V scale-down
  1532.     if (Mode_Preset[ucMode_Curr][1] > usIPH_ACT_WID)    ucOption    |= 0x04;    // bit 2 : H scale-up
  1533.     if (Mode_Preset[ucMode_Curr][1] < usIPH_ACT_WID)    ucOption    |= 0x08;    // bit 3 : H scale-down
  1535.     // Set capture window
  1536.     Data[0]     = 11;
  1537.     Data[1]     = Y_INC;
  1538.     Data[2]     = IPH_ACT_STA_06;
  1539.     Data[3]     = (unsigned char)usIPH_ACT_STA;
  1540.     Data[4]     = (unsigned char)(usIPH_ACT_STA >> 8);
  1541.     Data[5]     = (unsigned char)usIPH_ACT_WID;
  1542.     Data[6]     = (unsigned char)(usIPH_ACT_WID >> 8);
  1543.     Data[7]     = (unsigned char)usIPV_ACT_STA;
  1544.     Data[8]     = (unsigned char)(usIPV_ACT_STA >> 8);
  1545.     Data[9]     = (unsigned char)usIPV_ACT_LEN;
  1546.     Data[10]    = (unsigned char)(usIPV_ACT_LEN >> 8);
  1547.     Data[11]    = 0;
  1548.     RTDWrite(Data);
  1550.     // Set window size before scale-up
  1551.     Data[0] = 7;
  1552.     Data[1] = Y_INC;
  1553.     Data[2] = DRW_BSU_40;
  1555.     if (ucOption & 0x08)
  1556.     {
  1557.         // H scale-down
  1558.         Data[3] = (unsigned char)Mode_Preset[ucMode_Curr][1];
  1559.         Data[4] = (unsigned char)(Mode_Preset[ucMode_Curr][1] >> 8);
  1560.     }
  1561.     else
  1562.     {
  1563.         // No H scale-down
  1564.         Data[3] = Data[5];  // (unsigned char)usIPH_ACT_WID;
  1565.         Data[4] = Data[6];  // (unsigned char)(usIPH_ACT_WID >> 8);
  1566.     }
  1568.     if (ucOption & 0x02)
  1569.     {
  1570.         // V scale-down
  1571.         Data[5] = (unsigned char)usDispLen;
  1572.         Data[6] = (unsigned char)(usDispLen >> 8);
  1573.     }
  1574.     else
  1575.     {
  1576.         // No V scale-down
  1577.         Data[5] = Data[9];  // (unsigned char)usIPV_ACT_LEN;
  1578.         Data[6] = Data[10]; // (unsigned char)(usIPV_ACT_LEN >> 8);
  1579.     }
  1580.     Data[7] = 0;
  1581.     RTDWrite(Data);
  1583.     // Config scaling
  1584.     if (ucOption & 0x0a)
  1585.         RTDSetBit(SD_CTRL_70, 0xff, 0x01);      // Turn on scale-down
  1586.     else
  1587.         RTDSetBit(SD_CTRL_70, 0xfe, 0x00);      // Turn off scale-down
  1589.     if (ucOption & 0x01)
  1590.         RTDSetBit(SCALE_CTRL_15, 0xff, 0x02);   // Turn on V scale-up
  1591.     else
  1592.         RTDSetBit(SCALE_CTRL_15, 0xfd, 0x00);   // Turn off V scale-up
  1594.     if (ucOption & 0x04)
  1595.         RTDSetBit(SCALE_CTRL_15, 0xff, 0x01);   // Turn on H scale-up
  1596.     else
  1597.         RTDSetBit(SCALE_CTRL_15, 0xfe, 0x00);   // Turn off H scale-up
  1599.     // Set scale-down coefficient
  1600.     Data[0] = 7;
  1601.     Data[1] = Y_INC;
  1602.     Data[2] = H_SCALE_DL_71;
  1604.     if (ucOption & 0x08)    // H scale-down
  1605.     {
  1606.         // Data[12~15]
  1607.         ((unsigned long *)Data)[3]  = (unsigned long)256 * 4096 * usIPH_ACT_WID / Mode_Preset[ucMode_Curr][1];
  1609.         // Data[4~5]
  1610.         ((unsigned int *)Data)[2]   = (((unsigned long *)Data)[3] >> 8) + 2;
  1612.         // H scale-down factor is stored in Data[4] (high-byte) and Data[5] (low-byte)
  1613.         Data[3] = Data[5];
  1615.         RTDSetBit(VGIP_CTRL_04, 0xff, 0x40);    // Enable H scale-down compensation
  1616.     }
  1617.     else
  1618.     {
  1619.         Data[3] = 0x00;
  1620.         Data[4] = 0x10;
  1622.         RTDSetBit(VGIP_CTRL_04, 0xbf, 0x00);    // Diable H scale-down compensation
  1623.     }
  1625.     if (ucOption & 0x02)    // V scale-down
  1626.     {
  1627.         // Data[12~15]
  1628.         ((unsigned long *)Data)[3]  = (unsigned long)256 * 4096 * usIPV_ACT_LEN / usDispLen;
  1630.         // Data[6~7]
  1631.         ((unsigned int *)Data)[3]   = (((unsigned long *)Data)[3] >> 8);
  1633.         if (0 == Data[15])      ((unsigned int *)Data)[3]   = ((unsigned int *)Data)[3] - 1;
  1635.         // V scale-down factor is stored in Data[6] (high-byte) and Data[7] (low-byte)
  1636.         Data[5] = Data[7];
  1638.         RTDSetBit(VGIP_CTRL_04, 0xff, 0x80);    // Enable V scale-down compensation
  1639.     }
  1640.     else
  1641.     {
  1642.         Data[5] = 0x00;
  1643.         Data[6] = 0x10;
  1645.         RTDSetBit(VGIP_CTRL_04, 0x7f, 0x00);    // Diable V scale-down compensation
  1646.     }
  1647.     Data[7] = 0;
  1648.     RTDWrite(Data);
  1650.     // Set scale-up coefficient
  1651.     Data[0] = 8;
  1652.     Data[1] = Y_INC;
  1653.     Data[2] = HOR_SCA_16;
  1655.     if (ucOption & 0x04)    // H scale-up
  1656.     {
  1657.         // Data[12~15]
  1658.         ((unsigned long *)Data)[3]  = (unsigned long)2 * 262144 * usIPH_ACT_WID / Mode_Preset[ucMode_Curr][1];
  1659.         ((unsigned long *)Data)[3]  = ((((unsigned long *)Data)[3] >> 1) + (((unsigned long *)Data)[3] & 0x01)) << 6;
  1661.         Data[3] = Data[14];
  1662.         Data[4] = Data[13];
  1663.         Data[7] = Data[15];
  1664.     }
  1665.     else
  1666.     {
  1667.         Data[3] = 0xff;
  1668.         Data[4] = 0xff;
  1669.         Data[7] = 0;
  1670.     }
  1672.     if (ucOption & 0x01)    // V scale-up
  1673.     {
  1674.         // Data[12~15]
  1675.         ((unsigned long *)Data)[3]  = (unsigned long)2 * 262144 * usIPV_ACT_LEN / usDispLen;
  1676.         ((unsigned long *)Data)[3]  = ((((unsigned long *)Data)[3] >> 1) + (((unsigned long *)Data)[3] & 0x01)) << 6;
  1678.         Data[5] = Data[14];
  1679.         Data[6] = Data[13];
  1680.         Data[7] = Data[7] | (Data[15] >> 4);
  1681.     }
  1682.     else
  1683.     {
  1684.         Data[5] = 0xff;
  1685.         Data[6] = 0xff;
  1686.     }
  1687.     Data[8] = 0;
  1688.     RTDWrite(Data);
  1690.     // Set RTD display
  1692.     // Switch to FrameSync 1 mode and diable display
  1693.     RTDSetByte(VDIS_CTRL_20, 0x28 | DISP_BIT | DISPLAY_PORT);
  1695.     Data[0]     = 5;
  1696.     Data[1]     = Y_INC;
  1698. #if (DISP_ALIGN)
  1700.     Data[2]     = DH_ACT_STA_27;
  1702.     // DH_ACT_STA store in Data[4~5] (H~L)
  1703.     ((unsigned int *)Data)[2]   = (unsigned int)DH_ACT_END_POS - Mode_Preset[ucMode_Curr][1];
  1705.     Data[3]     = Data[5];
  1707. #else
  1709.     Data[2]     = DH_ACT_END_29;
  1711.     // DH_ACT_STA store in Data[4~5] (H~L)
  1712.     ((unsigned int *)Data)[2]   = (unsigned int)DH_ACT_STA_POS + Mode_Preset[ucMode_Curr][1];
  1714.     Data[3]     = Data[5];
  1716. #endif
  1718.     Data[5]     = 5;
  1719.     Data[6]     = Y_INC;
  1720.     Data[7]     = DV_ACT_END_34;
  1722.     // DV_ACT_END store in Data[10~11] (H~L)
  1723.     ((unsigned int *)Data)[5]   = (unsigned int)DV_ACT_STA_POS + usDispLen;
  1725.     Data[8]     = Data[11];
  1726.     Data[9]     = Data[10];
  1727.     Data[10]    = 0;
  1728.     RTDWrite(Data);
  1730.     // Get standard DH_TOTAL
  1731.     usDH_Total  = Mode_Preset[ucMode_Curr][0];
  1733.     // Switch to FrameSync 1 mode and enable display
  1734. //    if (PANEL_OFF == bPANEL_PWR)
  1735.     if (_OFF == bPanel_Status)
  1736.         RTDSetByte(VDIS_CTRL_20, 0x29 | DISP_BIT | DISPLAY_PORT);
  1737.     else
  1738.         RTDSetByte(VDIS_CTRL_20, 0x2b | DISP_BIT | DISPLAY_PORT);
  1741.     if (Mode_Preset[ucMode_Curr][3])
  1742.     {
  1743.         // Use preset DCLK M/N code
  1744.         Data[0] = 6;
  1745.         Data[1] = Y_INC;
  1746.         Data[2] = DPLL_CTRL_D0;
  1747.         Data[3] = 0x11;
  1748.         Data[4] = (unsigned char)(Mode_Preset[ucMode_Curr][3] >> 8);
  1749.         Data[5] = (unsigned char)Mode_Preset[ucMode_Curr][3];
  1750.         Data[6] = 0;
  1751.         RTDWrite(Data);
  1752.     }
  1753.     else
  1754.     {
  1755.      /*
  1756.         if (VGA_Mode[ucMode_Curr][4])
  1757.         {
  1758.             ((unsigned int *)Data)[0]   = (unsigned long)8 * usDH_Total * USER_MODE_NCODE * usDispLen 
  1759.                                         / ((unsigned long)usIPV_ACT_LEN * VGA_Mode[ucMode_Curr][4]);
  1760.         }
  1761.         else
  1762.         {
  1763. */
  1764.             ((unsigned int *)Data)[0]   = (unsigned long)8 * usDH_Total * USER_MODE_NCODE * usDispLen 
  1765.                                         / ((unsigned long)usIPV_ACT_LEN * usHsync);
  1766. //        }
  1769.         //Original Formula : DPM/Ich = 17.6 must be constant
  1770. //Ich = DPM * 10 / 176
  1771. //2*Ich = DPM * 20 / 176 , set D0[0] to 0, then I = 2 * Ich
  1772. //I  = 2 * Ich = 2.5u + D0[3]*2.5u + D0[4]*5u + D0[5]*10u + D0[6]*20u + D0[7]*30u(A)
  1773. //2I = 4 * Ich = 5u + D0[3]*5u + D0[4]*10u + D0[5]*20u + D0[6]*40u + D0[7]*60u(A)
  1774.         Data[15] = ((unsigned int *)Data)[0] >> 2;
  1775. Data[5] = (unsigned int)Data[15] * 40 / 176 - 5; //Calculate the 4*Ich,
  1776. Data[6] = 0x00;
  1777. if(Data[5] > 60)
  1778. {
  1779.     Data[5] -= 60;
  1780. Data[6] |= 0x80; 
  1781. }
  1783. if(Data[5] > 40)
  1784. {
  1785.     Data[5] -= 40;
  1786. Data[6] |= 0x40;
  1787. }
  1788.  
  1789.         if(Data[5] > 20)
  1790. {
  1791.     Data[5] -= 20;
  1792. Data[6] |= 0x20;
  1793. }
  1795. if(Data[5] > 10)
  1796. {
  1797.     Data[5] -= 10;
  1798. Data[6] |= 0x10;
  1799. }
  1801. if(Data[5] > 5)
  1802. {
  1803.     Data[5] -= 5;
  1804. Data[6] |= 0x08;
  1805. }
  1808. Data[0] = 7;
  1809. Data[1] = Y_INC;
  1810. Data[2] = DPLL_CTRL_D0;
  1811. Data[3] = Data[6];
  1812. Data[4] = Data[15] - 2;
  1813. Data[5] = 0x10 | (USER_MODE_NCODE - 2);//Offset Frequency Direction set to Downward
  1814. //Data[5] = (USER_MODE_NCODE - 2);//Offset Frequency Direction set to Downward
  1815. Data[6] = 0x04;
  1816. Data[7] = 0;
  1817. RTDWrite(Data);
  1819.  
  1820. //        ucDebug_Value0 = Data[4];
  1821.    //     ucDebug_Value1 = Data[5];
  1822.        
  1823.         //More precise Dclk in KHz
  1824. ((unsigned long*)Data)[0] = (unsigned long)24576000 / usIPV_ACT_LEN * usDispLen / usHsync * usDH_Total ;
  1825.         //((unsigned long*)Data)[0] = (unsigned long)49152000 / usIPV_ACT_LEN * usDispLen / usHsync * usDH_Total ;
  1826. //set M/N code Dclk
  1827. ((unsigned long*)Data)[1] = (unsigned long)12288000 * (Data[15] + 1) / USER_MODE_NCODE;
  1828.         //((unsigned long*)Data)[1] = (unsigned long)24576000 * (Data[15] + 1) / USER_MODE_NCODE;
  1829. ((unsigned long*)Data)[2] = ((unsigned long*)Data)[1] - ((unsigned long*)Data)[0]; //Dclk offset
  1830. ((unsigned long*)Data)[3] = ((unsigned long*)Data)[1] >> 15; //Offset resolution equal to (Dclk / 2^15)
  1831.         
  1832. ((unsigned long*)Data)[3] = ((((unsigned long*)Data)[2] << 1)/ ((unsigned long*)Data)[3]) & 0x00000fff; //Calculate the Dclk offset
  1833.         //((unsigned long*)Data)[3] = (((unsigned long*)Data)[2] / ((unsigned long*)Data)[3]) & 0x00000fff; //Calculate the Dclk offset
  1835. RTDSetByte(DCLK_OFFSET_LSB_9A,(unsigned char)((unsigned long*)Data)[3]);  //Set the Dclk offset
  1836. //        ucDebug_Value0 = (unsigned char)(((unsigned long*)Data)[3]);
  1837. //RTDSetBit(DCLK_OFFSET_MSB_9B,0xf0,(unsigned char)(((unsigned long*)Data)[3] >> 8) | 0x20);
  1838. RTDSetBit(DCLK_OFFSET_MSB_9B,0xf0,(unsigned char)(((unsigned long*)Data)[3] >> 8) | 0x20);
  1839. //        ucDebug_Value1 = (unsigned char)((((unsigned long*)Data)[3] >> 8) | 0x20);
  1840.         RTDSetBit(FX_LST_LEN_H_5A,0xff,0x08); //Enable DDS Spread Spectrum Output Function
  1841. RTDSetBit(DPLL_N_D2,0xff,0x20); //DPLL Spread Spectrum Enable
  1842. RTDSetBit(DPLL_FILTER_D3,0x7f,0x00); //Enable DPll output
  1844. }
  1845.         
  1846.    
  1847.     //usDH_Total  = usDH_Total - 2;
  1849.     // Set DH_TOTAL
  1850.     Data[0] = 5;
  1851.     Data[1] = Y_INC;
  1852.     Data[2] = DH_TOTAL_22;
  1853.     Data[3] = (unsigned char)(usDH_Total - 2);
  1854.     Data[4] = (unsigned char)((usDH_Total - 2) >> 8);
  1855.     Data[5] = 0;
  1856.     RTDWrite(Data);
  1860.     //Calculate DV_TOTAL
  1861. if((ucOption & 0x01) || (ucOption & 0x02))    // V scale up or scale down
  1862. {
  1864. #if(DISP_SIZE == DISP_800x600)
  1865. usDV_Total = (unsigned long)usVsync * 600 / (unsigned long)usIPV_ACT_LEN + 64;
  1866. #endif
  1868. #if(DISP_SIZE == DISP_1024x768)
  1869. usDV_Total = (unsigned long)usVsync * 768 / (unsigned long)usIPV_ACT_LEN + 64;
  1870. #endif
  1872. #if(DISP_SIZE == DISP_1280x1024)
  1874. usDV_Total = (unsigned long)usVsync * 1024 / (unsigned long)usIPV_ACT_LEN + 64;
  1875. #endif
  1878. }
  1879. else
  1880. usDV_Total = usVsync + 64;
  1882.     //Set DV_TOTAL
  1883. Data[0] = 5;
  1884. Data[1] = Y_INC;
  1885. Data[2] = DV_TOTAL_2D;
  1886. Data[3] = (unsigned char)usDV_Total;
  1887. Data[4] = (unsigned char)((usDV_Total >> 8) & 0x07);
  1888. Data[5] = 0;
  1889. RTDWrite(Data);
  1894.     // Calculate suitable IVS to DVS delay
  1895.     // CR[38] : IVS to DVS delay in IHS lines
  1896.     // CR[1E] : IVS to DVS delay in ICLK * 16
  1897.     ((unsigned int *)Data)[0]   = (unsigned long)32 * DV_ACT_STA_POS * usIPV_ACT_LEN / usDispLen;
  1899.     if (ucOption & 0x01)
  1900.     {
  1901.         if ((usIPV_ACT_STA + 1) < (((unsigned int *)Data)[0] >> 5))
  1902.         {
  1903.             // You should never get into this code ....
  1904.             usIPV_ACT_STA   = (((unsigned int *)Data)[0] >> 5) - 1;
  1906.             RTDSetByte(IPV_ACT_STA_0A, (unsigned char)usIPV_ACT_STA);
  1907.             RTDSetByte(IPV_ACT_STA_0A + 1, (unsigned char)(usIPV_ACT_STA >> 8));
  1908.         }
  1910.         ucDV_Delay  = usIPV_ACT_STA + 2 - (((unsigned int *)Data)[0] >> 5);     // V scale-up. Target 2.5~2.6 IHS delay
  1912.         // Too large IVS to DVS delay (2 + (22 / 32) = 86/32 = 2.6875 IHS); decrese ucDV_Delay
  1913.         if (22 < (((unsigned int *)Data)[0] & 0x001f))      ucDV_Delay  -= 1;
  1915.         ((unsigned int *)Data)[0]   = ((unsigned int *)Data)[0] + (ucDV_Delay * 32) - (usIPV_ACT_STA * 32);
  1917.         if (79 <= ((unsigned int *)Data)[0])
  1918.         {
  1919.             // Suitable IVS to DVS delay (79 / 32 = 2.46875). Fine-delay (CR[1E]) is not necessary
  1921.             RTDSetByte(FS_FT_DELAY_1E, 0x00);       // Disable fine-tune delay
  1922.         }
  1923.         else
  1924.         {
  1925.             // Fine tuning (CR[1E]) IVS to DVS delay to 2.5 (80/32) IHS.
  1927.             // Original Formula : Data[0] = usADC_Clock * ((80 - x) / 32) / 16
  1928.             Data[0] = (unsigned long)usADC_Clock * (80 - ((unsigned int *)Data)[0]) / 512;
  1930.             RTDSetByte(FS_FT_DELAY_1E, Data[0]);    // Enable fine-tune delay
  1931.         }
  1932.     }
  1933.     else
  1934.     {
  1935. #if (FULL_LINE_BUFFER)
  1937.         if ((usIPV_ACT_STA + 3) < (((unsigned int *)Data)[0] >> 5))
  1938.         {
  1939.             // You should never get into this code ....
  1940.             usIPV_ACT_STA   = (((unsigned int *)Data)[0] >> 5) - 3;
  1942.             RTDSetByte(IPV_ACT_STA_0A, (unsigned char)usIPV_ACT_STA);
  1943.             RTDSetByte(IPV_ACT_STA_0A + 1, (unsigned char)(usIPV_ACT_STA >> 8));
  1944.         }
  1946.         ucDV_Delay  = usIPV_ACT_STA + 3 - (((unsigned int *)Data)[0] >> 5);     // V no scale-up. Target 3.8~4.0 IHS delay
  1948.         ((unsigned int *)Data)[0]   = ((unsigned int *)Data)[0] + (ucDV_Delay * 32) - (usIPV_ACT_STA * 32);
  1950.         if (121 <= ((unsigned int *)Data)[0])
  1951.         {
  1952.             // Suitable IVS to DVS delay (121 / 32 = 3.78125). Fine-delay (CR[1E]) is not necessary
  1954.             RTDSetByte(FS_FT_DELAY_1E, 0x00);       // Disable fine-tune delay
  1955.         }
  1956.         else
  1957.         {
  1958.             // Fine tuning (CR[1E]) IVS to DVS delay to 3.8 (122/32) IHS.
  1960.             // Original Formula : Data[0] = usADC_Clock * ((122 - usScaleFactor) / 32) / 16
  1961.             Data[0] = (unsigned long)usADC_Clock * (122 - ((unsigned int *)Data)[0]) / 512;
  1963.             RTDSetByte(FS_FT_DELAY_1E, Data[0]);    // Enable fine-tune delay
  1964.         }
  1966. #else
  1968.         if ((usIPV_ACT_STA + 1) < (((unsigned int *)Data)[0] >> 5))
  1969.         {
  1970.             // You should never get into this code ....
  1971.             usIPV_ACT_STA   = (((unsigned int *)Data)[0] >> 5) - 1;
  1973.             RTDSetByte(IPV_ACT_STA_0A, (unsigned char)usIPV_ACT_STA);
  1974.             RTDSetByte(IPV_ACT_STA_0A + 1, (unsigned char)(usIPV_ACT_STA >> 8));
  1975.         }
  1977.         if (ucOption & 0x02)
  1978.         {
  1979.             // V scale-down            
  1980.             ucDV_Delay  = usIPV_ACT_STA + 1 - (((unsigned int *)Data)[0] >> 5);     // V scale-down. Target 2.5~2.6 IHS delay
  1982.             ((unsigned int *)Data)[0]   = ((unsigned int *)Data)[0] + (ucDV_Delay * 32) - (usIPV_ACT_STA * 32);
  1984.             if (81 <= ((unsigned int *)Data)[0])
  1985.             {
  1986.                 // Suitable IVS to DVS delay (81 / 32 = 2.53125). Fine-delay (CR[1E]) is not necessary
  1988.                 RTDSetByte(FS_FT_DELAY_1E, 0x00);       // Disable fine-tune delay
  1989.             }
  1990.             else
  1991.             {
  1992.                 // Fine tuning (CR[1E]) IVS to DVS delay to 2.5625 (82/32) IHS.
  1994.                 // Original Formula : Data[0] = usADC_Clock * ((82 - x) / 32) / 16
  1995.                 Data[0] = (unsigned long)usADC_Clock * (82 - ((unsigned int *)Data)[0]) / 512;
  1997.                 RTDSetByte(FS_FT_DELAY_1E, Data[0]);    // Enable fine-tune delay
  1998.             }
  1999.         }
  2000.         else
  2001.         {
  2002. /*
  2003.             // V no scale-down
  2004.             ucDV_Delay  = usIPV_ACT_STA + 1 - (((unsigned int *)Data)[0] >> 5);     // V no scale-down. Target 1.5~1.6 IHS delay
  2006.             // Too large IVS to DVS delay (1 + (22 / 32) = 54/32 = 1.6875 IHS); decrese ucDV_Delay
  2007.             if (22 < (((unsigned int *)Data)[0] & 0x001f))      ucDV_Delay  -= 1;
  2009.             ((unsigned int *)Data)[0]   = ((unsigned int *)Data)[0] + (ucDV_Delay * 32) - (usIPV_ACT_STA * 32);
  2010.         
  2011.             if (47 <= ((unsigned int *)Data)[0])
  2012.             {
  2013.                 // Suitable IVS to DVS delay (47 / 32 = 1.46875). Fine-delay (CR[1E]) is not necessary
  2015.                 RTDSetByte(FS_FT_DELAY_1E, 0x00);       // Disable fine-tune delay
  2016.             }
  2017.             else
  2018.             {
  2019.                 // Fine tuning (CR[1E]) IVS to DVS delay to 1.5 (48/32) IHS.
  2021.                 // Original Formula : Data[0] = usADC_Clock * ((48 - x) / 32) / 16
  2022.                 Data[0] = (unsigned long)usADC_Clock * (48 - ((unsigned int *)Data)[0]) / 512;
  2024.                 RTDSetByte(FS_FT_DELAY_1E, Data[0]);    // Enable fine-tune delay
  2025.             }
  2026. */
  2027.                     // The code below is also fine (written by Forster)
  2028. ucDV_Delay  = usIPV_ACT_STA + 1 - (((unsigned int *)Data)[0] >> 5);     // V no scale-up. Target 1.9 IHS delay
  2030. ((unsigned int *)Data)[0]   = ((unsigned int *)Data)[0] + (ucDV_Delay * 32) - (usIPV_ACT_STA * 32);
  2032. if (61 <= ((unsigned int *)Data)[0])
  2033. {
  2034. // Suitable IVS to DVS delay (61 / 32 = 1.90625). Fine-delay (CR[1E]) is not necessary
  2036. RTDSetByte(FS_FT_DELAY_1E, 0x00);       // Disable fine-tune delay
  2037. }
  2038. else
  2039. {
  2040. // Fine tuning (CR[1E]) IVS to DVS delay to 1.9375 (62/32) IHS.
  2042. // Original Formula : Data[0] = usADC_Clock * ((62 - usScaleFactor) / 32) / 16
  2043. Data[0] = (unsigned long)usADC_Clock * (62 - ((unsigned int *)Data)[0]) / 512;
  2045. RTDSetByte(FS_FT_DELAY_1E, Data[0]);    // Enable fine-tune delay
  2046. }
  2047.         }
  2049. #endif
  2050.     }
  2052. #if (FULL_LINE_BUFFER)
  2053.     // Turn on full-line buffer when no V scale-up
  2054.     RTDSetBit(OP_CRC_CTRL_68, 0xfc, (ucOption & 0x01) ? 0x00 : 0x02);
  2055. #else
  2056.     RTDSetBit(OP_CRC_CTRL_68, 0xfc, 0x00);
  2057. #endif
  2059.     // Set ucDV_Delay
  2060.     RTDSetByte(IV_DV_LINES_38, ucDV_Delay);
  2062. RTDSetByte(STATUS0_01, 0x00);  // Clear status
  2063.     RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  2065.     // Switch to FrameSync 1 mode and enable display
  2066. //    if (PANEL_OFF == bPANEL_PWR)
  2067. //        RTDSetByte(VDIS_CTRL_20, 0x29 | DISP_BIT | DISPLAY_PORT);
  2068. //    else
  2069. //        RTDSetByte(VDIS_CTRL_20, 0x2b | DISP_BIT | DISPLAY_PORT);
  2071.     // Input Run Enable
  2072.     RTDSetBit(VGIP_CTRL_04, 0xff, 0x01);
  2074. }
  2076. void Display_VGA_Set(void)
  2077. {
  2078.     unsigned char   Wait_Time_Cnt;
  2079. // unsigned char   ucI_Corr0,ucI_Corr1;
  2082.     Initial_Mode();
  2083. Sharpness();
  2085.     if((usIPH_ACT_WID == 1280) && (DISP_SIZE == DISP_1280x1024) && (stGUD1.FILTER == 0x02))
  2086.          RTDSetBit(SCALE_CTRL_15, 0xff, 0x01);   // Turn on H scale-up
  2087.     
  2089.     PowerDown_ADC();
  2090.     //Device_Power(ADC_POWER,OFF);
  2092.     // Set user's ADC gain and offset settings
  2093.     SetADC_GainOffset();
  2095.     Set_Gamma();
  2096.     Set_Dithering();
  2097.     Set_Bright_Contrast();
  2098. //    Sharpness();
  2100.     Load_MUD(ucMode_Curr);      // Read mode default settings from 24C04
  2102.     // For jitter adjust
  2103.     ucPE_Level      = 0;
  2104. //    ucPE_Count      = 0;
  2106.     // Check Clock
  2107.     if (28 > stMUD.CLOCK || 228 < stMUD.CLOCK)      stMUD.CLOCK = 128;
  2109.     
  2110.     // Update Clock Twice
  2111.     Set_Clock();
  2112. // Calculate the P correction and I correction according to the CE value
  2113.     Delay_Xms(6);
  2114.     if(ucCE_Value ==  0)
  2115.     {
  2116.        RTDRead(I_CODE_MB_CA,1,N_INC);
  2117.    RTDSetByte(I_CODE_MB_CA, 0x0d);
  2118.    Delay_Xms(4);
  2119.    RTDRead(PLL_CALIBRATION_CE,1,N_INC);
  2120.    ucP_Corr = (unsigned char)((unsigned int)(Data[0] * 200) >> (29 - P_Code));
  2121.    ucCE_Value = Data[0];  //CE value  
  2123. }
  2125. if(ucI_Code == 0)
  2126.    Adjust_I_Code();
  2127.     
  2129.     Set_Clock();
  2132.     // Check Phase
  2133. //    stMUD.PHASE &= 0x7c;    // Phase 0~31
  2135.     // Update Phase
  2136. //    Set_Phase(stMUD.PHASE);
  2138.     ucH_Max_Margin  = 128 + 50;
  2139.     ucH_Min_Margin  = 128 - 50;
  2141. //Read the usIPH_ACT_STA offset
  2142.     I2CRead(ADDR_EROM1,(ucMode_Curr - 1),0x01);
  2143. if(Data[0] > 228)
  2144.    Data[0] = 0;
  2146.     usIPH_ACT_STA   = (Data[0] & 0x80) ? usIPH_ACT_STA - 50 - (Data[0] - 0x80) : usIPH_ACT_STA + Data[0] - 50;
  2147.         
  2148.     Data[0] = 5;
  2149.     Data[1] = Y_INC;
  2150.     Data[2] = IPH_ACT_STA_06;
  2151.     Data[3] = (unsigned char)usIPH_ACT_STA;
  2152.     Data[4] = (unsigned char)(usIPH_ACT_STA >> 8);
  2153.     Data[5] = 0;    
  2154.     RTDWrite(Data);
  2156.     // Check H-Position
  2157.     if (ucH_Max_Margin < stMUD.H_POSITION)
  2158.         stMUD.H_POSITION    = ucH_Max_Margin;
  2159.     else if (ucH_Min_Margin > stMUD.H_POSITION)
  2160.         stMUD.H_POSITION    = ucH_Min_Margin;
  2162.     // Update H-Position
  2163.     Set_H_Position();
  2165.        // Check Phase
  2166.     stMUD.PHASE &= 0x7c;    // Phase 0~31
  2168.     // Update Phase
  2169.     Set_Phase(stMUD.PHASE);
  2171.     // Start auto-tracking function once
  2172.     RTDSetByte(AUTO_ADJ_CTRL_7F, 0x01);
  2173.     Delay_Xms(40);
  2175.     // Force to stop auto-tracking function
  2176.     RTDSetByte(AUTO_ADJ_CTRL_7F, 0x00);
  2177.     Delay_Xms(40);
  2179.     // Measure actual number of scan line in each frame
  2180.     Data[0]     = 14;
  2181.     Data[1]     = Y_INC;
  2182.     Data[2]     = H_BND_STA_L_75;
  2183.     Data[3]     = 0x00;
  2184.     Data[4]     = 0xff;
  2185.     Data[5]     = 0x07;
  2186.     Data[6]     = 0x00;
  2187.     Data[7]     = 0x00;
  2188.     Data[8]     = 0x00;
  2189.     Data[9]     = 0x00;
  2190.     Data[10]    = 0x00;
  2191.     Data[11]    = 0x00;
  2192.     Data[12]    = 0x00;
  2193.     Data[13]    = 0x01;
  2194.     Data[14]    = 0;
  2195.     RTDWrite(Data);
  2197.     Wait_Time_Cnt  = 60;    // Tracking timeout 60ms        
  2198.     do
  2199.     {   
  2200.         Delay_Xms(1);
  2201.         RTDRead(AUTO_ADJ_CTRL_7F, 0x01, N_INC);
  2202.     }
  2203.     while ((Data[0] & 0x01) && (--Wait_Time_Cnt));
  2205.     RTDSetByte(AUTO_ADJ_CTRL_7F, 0x00);
  2206.     
  2207.     if (Wait_Time_Cnt)
  2208.     {
  2209.         RTDRead(VER_START_80, 0x04, Y_INC);
  2210.         Data[0] = Data[3] & 0x0f;
  2211.         Data[1] = Data[2];
  2213.         usVer_End   = (usVsync < ((unsigned int *)Data)[0]) ? ((unsigned int *)Data)[0] : usVsync;
  2214.     }
  2215.     else
  2216.     {
  2217.         usVer_End   = usVsync;
  2218.     }
  2220.     // Update to reasonable usIPV_ACT_STA for user mode
  2221.     if (MODE_USER720x400 <= ucMode_Curr)
  2222.     {
  2223.         ((unsigned int *)Data)[0]   = usVer_End - VGA_Mode[ucMode_Curr][2];
  2225.         if (254 < ((unsigned int *)Data)[0] + ucDV_Delay)   ((unsigned int *)Data)[0]   = 254 - ucDV_Delay;
  2227.         usIPV_ACT_STA   += ((unsigned int *)Data)[0];
  2228.         ucDV_Delay      += ((unsigned int *)Data)[0];
  2229.     }
  2231.     // Set the ucV_Min_Margin/ucV_Max_Margin
  2232.     ucV_Min_Margin  = (128 < usIPV_ACT_STA) ? 0 : 128 - usIPV_ACT_STA + 1;
  2234.     if ((128 - 50) > ucV_Min_Margin)    ucV_Min_Margin  = 128 - 50;
  2236.     ((unsigned int *)Data)[0]   = (usVer_End + 128 - 2) - (usIPV_ACT_STA + usIPV_ACT_LEN);
  2238.     ucV_Max_Margin  = (((unsigned int *)Data)[0] > 0x00ff) ? 0xff : ((unsigned int *)Data)[0];
  2240.     // Check ucV_Min_Margin/ucV_Max_Margin :
  2241.     // ucDV_Delay can only range from 0 to 254
  2242.     // Original Formula :
  2243.     // 128 - ucV_Min_Margin >= ucDV_Delay
  2244.     // ucV_Max_Margin - 128 >= 254 - ucDV_Delay
  2246.     if ((unsigned int)128 > ((unsigned int)ucV_Min_Margin + ucDV_Delay))    ucV_Min_Margin  = 128 - ucDV_Delay;
  2247.     if ((unsigned int)382 < ((unsigned int)ucV_Max_Margin + ucDV_Delay))    ucV_Max_Margin  = 382 - ucDV_Delay;
  2249.     if ((128 + 50) < ucV_Max_Margin)    ucV_Max_Margin  = 128 + 50;
  2251.     // Check V-Position
  2252.     if (ucV_Min_Margin > stMUD.V_POSITION)
  2253.         stMUD.V_POSITION    = ucV_Min_Margin;
  2254.     else if ((unsigned int)256 - ucV_Min_Margin < stMUD.V_POSITION)
  2255.         stMUD.V_POSITION    = (unsigned int)256 - ucV_Min_Margin;
  2257.     // Update V-Position
  2258.     Set_V_Position();
  2260.     // Re-calculate actual refresh rate
  2261.     ((unsigned long *)Data)[0]  = (unsigned long)usHsync * usVer_End;
  2262.     ucRefresh   = (unsigned long)49152000 / ((unsigned long *)Data)[0];
  2263.     ucRefresh   = (ucRefresh & 0x01) ? ((ucRefresh + 1) >> 1) : (ucRefresh >> 1);
  2264.     
  2265. if(ucRefresh > V_OVERSPEC_FREQ)
  2266.     bOverSpec = _TRUE;
  2268. if((unsigned int)24576/usHsync > H_OVERSPEC_FREQ)
  2269.     bOverSpec = _TRUE;
  2271.     Data[0] = Frame_Sync();
  2273.     if (1 == Data[0])
  2274.     {
  2275.        Delay_Xms(10);
  2276.        Data[0] = Frame_Sync();     // Fail. Try again       
  2277.     }
  2279.     bFrameSync      = Data[0] ? 0 : 1;              // 0 : fail, 1 : pass
  2280.     ucSyncErrorCnt  = 0;
  2282.     RTDSetBit(OVL_CTRL_6D,0x3f,0x00);
  2283.     RTDSetByte(BGCOLOR_CONTROL_6C,0x00);
  2284. RTDSetBit(OVL_CTRL_6D,0x3f,0x40);
  2285.     RTDSetByte(BGCOLOR_CONTROL_6C,0x00);
  2286. RTDSetBit(OVL_CTRL_6D,0x3f,0x80);
  2287.     RTDSetByte(BGCOLOR_CONTROL_6C,0x00);
  2289. //    RTDSetBit(VDIS_CTRL_20, 0x5f, DHS_MASK);        // Normal display
  2290.       RTDSetBit(VDIS_CTRL_20, 0x7f, 0x20 | DHS_MASK);        // Normal display
  2292. #if(AS_PLL_NONLOCK)
  2293.    if(bFrameSync)
  2294.         RTDSetBit(ODD_CTRL_8E,0xdf,0x20);
  2295. #endif
  2297. }
  2299. void Display_DVI_Set(void)
  2300. {
  2301. #if(TMDS_ENABLE)
  2302.     unsigned char   Wait_Time_Cnt;
  2304.     Initial_Mode();
  2306.     // Set the ucV_Min_Margin/ucV_Max_Margin
  2307.     ucV_Min_Margin  = (128 < usIPV_ACT_STA) ? 0 : 128 - usIPV_ACT_STA + 1;
  2309.     // Use Data[8],Data[9] as a temporary 16-bit variable.
  2310.     ((unsigned int *)Data)[4]   = (usVsync + 128 - 2) - (usIPV_ACT_STA + usIPV_ACT_LEN);
  2312.     ucV_Max_Margin  = (0x00ff <  ((unsigned int *)Data)[4]) ? 0xff :  ((unsigned int *)Data)[4];
  2314.     // Check ucV_Min_Margin/ucV_Max_Margin :
  2315.     // ucDV_Delay can only range from 0 to 254
  2316.     // Original Formula :
  2317.     // 128 - ucV_Min_Margin <= ucDV_Delay
  2318.     // ucV_Max_Margin - 128 <= 254 - ucDV_Delay
  2320.     if ((unsigned int)128 > ((unsigned int)ucV_Min_Margin + ucDV_Delay))    ucV_Min_Margin  = 128 - ucDV_Delay;
  2321.     if ((unsigned int)382 < ((unsigned int)ucV_Max_Margin + ucDV_Delay))    ucV_Max_Margin  = 382 - ucDV_Delay;
  2323.     // Read mode default settings from 24C04
  2324.     Load_MUD(ucMode_Curr);
  2326.     Set_Gamma();
  2327.     Set_Dithering();
  2328.     Set_Bright_Contrast();
  2329.     Sharpness();
  2331.     // Issac :
  2332.     // RTD controller can support both digital mode and analog mode to capture input image data.
  2333.     // In digital mode, input image data is captured according to input data enable (IDEN) signal;
  2334.     // In analog mode, input image data is captured according to capture window settings;
  2335.     // Although can support both of them, I always use analog mode to capture input image in this F/W.
  2336.     // Because RTD controller can measure the position and size of IDEN signal, we can just set our
  2337.     // capture window to be the same size and position as IDEN.
  2339.     Data[0]     = 14;
  2340.     Data[1]     = Y_INC;
  2341.     Data[2]     = H_BND_STA_L_75;
  2342.     Data[3]     = 0x02;
  2343.     Data[4]     = usADC_Clock - 2;
  2344.     Data[5]     = (usADC_Clock - 2) >> 8;
  2345.     Data[6]     = 0x02;
  2346.     Data[7]     = usVsync - 2;
  2347.     Data[8]     = (usVsync - 2) >> 8;
  2348.     Data[9]     = 0;
  2349.     Data[10]    = 0;
  2350.     Data[11]    = 0;
  2351.     Data[12]    = 0;
  2352.     Data[13]    = 0x81;     // Measure IDEN position
  2353.     Data[14]    = 0;
  2354.     RTDWrite(Data);
  2356.     Wait_Time_Cnt  = 60;    // Tracking timeout 60ms        
  2357.     do
  2358.     {   
  2359.         Delay_Xms(1);
  2360.         RTDRead(AUTO_ADJ_CTRL_7F, 0x01, N_INC);
  2361.     }
  2362.     while ((Data[0] & 0x01) && (--Wait_Time_Cnt));
  2363.     
  2364.     if (0 == Wait_Time_Cnt)
  2365.     {
  2366.         RTDSetByte(AUTO_ADJ_CTRL_7F, 0x00);
  2367.         Reset_Mode();
  2368.     }
  2369.     else
  2370.     {
  2371.         // Read IDEN position information
  2372.         RTDRead(VER_START_80, 0x08, Y_INC);
  2373.         
  2374.         // IDEN horizontal Start
  2375.         usIPH_ACT_STA   = (unsigned int)Data[4] + ((unsigned int)Data[5] << 8) - 2;
  2377.         // IDEN vertical Start
  2378.         ((unsigned int *)Data)[0]   = (unsigned int)Data[0] + ((unsigned int)Data[1] << 8) - 1;
  2380.         if (((unsigned int *)Data)[0] > (usIPV_ACT_STA + ucV_Max_Margin - 0x80))
  2381.         {
  2382.             ((unsigned int *)Data)[1]   = (usVsync + 128 - 2) - (usIPV_ACT_STA + usIPV_ACT_LEN);    // Actual V max. Margin
  2384.             ucDV_Delay      = (unsigned char)((unsigned int)ucDV_Delay + ucV_Max_Margin - 0x80);
  2385.             usIPV_ACT_STA   = usIPV_ACT_STA + ucV_Max_Margin - 0x80;
  2387.             if (ucV_Max_Margin < ((unsigned int *)Data)[1])
  2388.             {
  2389.                 // We have to increase IVS delay to fix ucV_Max_Margin
  2390.                 if ((((unsigned int *)Data)[1] - ucV_Max_Margin) >= (((unsigned int *)Data)[0] - usIPV_ACT_STA))
  2391.                     ((unsigned int *)Data)[1]   = ((unsigned int *)Data)[0] - usIPV_ACT_STA + PROGRAM_VDELAY;
  2392.                 else
  2393.                     ((unsigned int *)Data)[1]   = usIPV_ACT_STA + ((unsigned int *)Data)[1] - ucV_Max_Margin + PROGRAM_VDELAY;
  2395.                 if (126 < ((unsigned int *)Data)[1])    ((unsigned int *)Data)[1]  = 126;
  2397.                 RTDSetByte(IVS_DELAY_8C, 0x80 | ((unsigned int *)Data)[1]);
  2398.             }
  2399.         }
  2400.         else if (((unsigned int *)Data)[0] < (usIPV_ACT_STA + ucV_Min_Margin - 0x80))
  2401.         {
  2402.             ucDV_Delay      = (unsigned char)((unsigned int)ucDV_Delay + ucV_Min_Margin - 0x80);
  2403.             usIPV_ACT_STA   = usIPV_ACT_STA + ucV_Min_Margin - 0x80;
  2405.             ((unsigned int *)Data)[1]   = usIPV_ACT_STA - ((unsigned int *)Data)[0];
  2407.             // We have to decrease IVS delay to fix ucV_Min_Margin
  2408.             if (PROGRAM_VDELAY <= ((unsigned int *)Data)[1])
  2409.                 RTDSetByte(IVS_DELAY_8C, 0x00);
  2410.             else
  2411.                 RTDSetByte(IVS_DELAY_8C, 0x80 | (PROGRAM_VDELAY - ((unsigned int *)Data)[1]));
  2412.         }
  2413.         else
  2414.         {
  2415.             ucDV_Delay      = ((unsigned int *)Data)[0] + ucDV_Delay - usIPV_ACT_STA ;
  2416.             usIPV_ACT_STA   = ((unsigned int *)Data)[0];
  2417.         }
  2419. RTDRead(TMDS_CORRECTION_FF,0x01,N_INC);
  2421. if(Data[0] & 0x03)
  2422.     usIPH_ACT_STA -= 14;//if TMDS error correction enable, then compensate the IPH_ACT_STA offset.
  2424.         Data[0]     = 5;
  2425.         Data[1]     = Y_INC;
  2426.         Data[2]     = IPH_ACT_STA_06;
  2427.         Data[3]     = (unsigned char)(usIPH_ACT_STA & 0x00ff);
  2428.         Data[4]     = (unsigned char)((usIPH_ACT_STA >> 8) & 0x00ff);
  2429.         Data[5]     = 5;
  2430.         Data[6]     = Y_INC;
  2431.         Data[7]     = IPV_ACT_STA_0A;
  2432.         Data[8]     = (unsigned char)(usIPV_ACT_STA & 0x00ff);
  2433.         Data[9]     = (unsigned char)((usIPV_ACT_STA >> 8) & 0x00ff);
  2434.         Data[10]    = 4;
  2435.         Data[11]    = N_INC;
  2436.         Data[12]    = IV_DV_LINES_38;
  2437.         Data[13]    = ucDV_Delay;
  2438.         Data[14]    = 0;
  2439.         RTDWrite(Data);
  2441.         Wait_For_Event(EVENT_DVS);
  2443.         Data[0] = Frame_Sync();
  2444.         
  2445.         if (1 == Data[0])   Data[0] = Frame_Sync();     // Fail. Try again
  2447.         bFrameSync      = Data[0] ? 0 : 1;              // 0 : fail, 1 : pass
  2448.         ucSyncErrorCnt  = 0;
  2450.         //RTDSetBit(VDIS_CTRL_20, 0x5f, DHS_MASK);        // Normal display
  2451. RTDSetBit(VDIS_CTRL_20, 0x7f, 0x20 | DHS_MASK);        // Normal display
  2452.     }
  2453. #else
  2454.     Seek_DVI_Mode(0);
  2455. #endif
  2456. }
  2458. void Set_Video_Mode(void)
  2459. {
  2460. #if(VIDEO_CHIP != VDC_NONE)
  2462. #if (VIDEO_CHIP == VDC_SAA7114 || VIDEO_CHIP == VDC_SAA7115 || VIDEO_CHIP == VDC_SAA7118)
  2463.     I2CWrite(V_DISABLE);
  2464.     I2CWrite(VIDEO_ALL);
  2465.     I2CWrite((ucAV_Mode & 0x02) ? VIDEO_50 : VIDEO_60);
  2466. #endif
  2468.     RTDCodeW((ucAV_Mode & 0x02) ? RTD_VIDEO_50 : RTD_VIDEO_60);
  2470. //    if (PANEL_OFF == MCU_ReadPanelPower())
  2471.     if (OFF == bPanel_Status)
  2472.     {
  2474.         RTDSetByte(VDIS_SIGINV_21, 0x00 | DISP_EO_SWAP | DISP_RB_SWAP | DISP_ML_SWAP);       // DHS, DVS, DEN, DCLK MUST NOT be inverted.
  2476.         RTDSetBit(VDIS_CTRL_20, 0xfd, 0x01);    // DHS, DVS, DEN, DCLK and data are clamped to 0
  2477.     }
  2480. //#if (SPREAD_SPECTRUM)
  2481. //    RTDSetBit(DPLL_CTRL_D0, 0x01, 0x08);
  2482. //    RTDRead(DPLL_M_D1, 0x01, Y_INC);
  2484. //    if (0xd2 < Data[0])
  2485. //        Data[1] = 0x09;
  2486. //    else if (0x8d < Data[0])
  2487. //        Data[1] = 0x0a;
  2488. //    else if (0x6d < Data[0])
  2489. //        Data[1] = 0x0b;
  2490. //    else if (0x57 < Data[0])
  2491. //        Data[1] = 0x0c;
  2492. //    else if (0x47 < Data[0])
  2493. //        Data[1] = 0x0d;
  2494. //    else if (0x37 < Data[0])
  2495. //        Data[1] = 0x0e;
  2496. //    else
  2497. //        Data[1] = 0x0f;
  2499. //    RTDSetByte(DPLL_FILTER_D3, Data[1]);
  2500. //    RTDSetByte(DPLL_SSP_D4, 0xf7);
  2501. //#endif
  2504. #if (VIDEO_CHIP == VDC_SAA7118)
  2505.     if (SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07))
  2506.     {
  2507.         I2CWrite(VIDEO_YUV);
  2508.     }
  2509.     else
  2510. #endif
  2511.     {
  2512.         Data[0] = (SOURCE_SV == (stGUD1.INPUT_SOURCE & 0x07)) ? 0 : 1;
  2514.         switch (ucAV_Mode)
  2515.         {
  2516.         case 0x01:          //(60Hz) NTSC-M, JAPAN(7111A)
  2517.         case 0x81:          //(60Hz) Default
  2518.             I2CWrite(Data[0] ? AV_60_0 : SV_60_0);
  2519.             break;
  2520.         case 0x11:          //(60Hz) PAL-4.43
  2521.             I2CWrite(Data[0] ? AV_60_1 : SV_60_1);
  2522.             break;
  2523.         case 0x21:          //(60Hz) NTSC-4.43
  2524.             I2CWrite(Data[0] ? AV_60_2 : SV_60_2);
  2525.             break;
  2526.         case 0x31:          //(60Hz) PAL-M
  2527.             I2CWrite(Data[0] ? AV_60_3 : SV_60_3);
  2528.             break;
  2529.         case 0x41:          //(60Hz) NTSC-JAPAN(7114)
  2530.             I2CWrite(Data[0] ? AV_60_4 : SV_60_4);
  2531.             break;
  2532.         case 0x02:          //(50Hz) PAL-BGHI
  2533.         case 0x82:          //(50Hz) Default
  2534.             I2CWrite(Data[0] ? AV_50_0 : SV_50_0);
  2535.             RTDSetBit(VGIP_SIGINV_05,0xff,0x10);
  2536.             break;
  2537.         case 0x12:          //(50Hz) NTSC-4.43
  2538.             I2CWrite(Data[0] ? AV_50_1 : SV_50_1);
  2539.             break;
  2540.         case 0x22:          //(50Hz) PAL-N
  2541.             I2CWrite(Data[0] ? AV_50_2 : SV_50_2);
  2542.             break;
  2543.         case 0x32:          //(50Hz) NTSC-N
  2544.             I2CWrite(Data[0] ? AV_50_3 : SV_50_3);
  2545.             break;
  2546.         case 0x42:          //Reserved
  2547.             I2CWrite(Data[0] ? AV_50_4 : SV_50_4);
  2548.             break;
  2549.         case 0x03:          //(50Hz) SECAM
  2550.             I2CWrite(Data[0] ? AV_SECAM : SV_SECAM);
  2551. RTDSetBit(VGIP_SIGINV_05,0xff,0x10);
  2552.             break;
  2553.         default:    
  2554.             break;
  2555.         }
  2556.     }
  2557. #endif
  2558. }
  2560. void Display_Video_Set(void)
  2561. {    
  2562. #if(VIDEO_CHIP != VDC_NONE)
  2563.     unsigned char ucCounter;
  2565.     Load_MUD(ucMode_Curr);      // Read mode default settings from 24C04
  2567.     Set_Video_Mode();
  2569.     if (SOURCE_TV == (stGUD1.INPUT_SOURCE & 0x07))      I2CWrite(TV_SOURCE_SEL);
  2571.     // Read H,V Standard Start Position and H Width
  2572.     RTDRead(IPH_ACT_STA_06, 0x08, Y_INC);
  2573.     usIPH_ACT_STA   = (unsigned int)Data[0] + ((unsigned int)Data[1] << 8);
  2574.     usIPH_ACT_STA   = usIPH_ACT_STA & 0x07ff;
  2575.     usIPH_ACT_WID   = (unsigned int)Data[2] + ((unsigned int)Data[3] << 8);
  2576.     usIPH_ACT_WID   = usIPH_ACT_WID & 0x07ff;
  2577.     usIPV_ACT_STA   = (unsigned int)Data[4] + ((unsigned int)Data[5] << 8);
  2578.     usIPV_ACT_STA   = usIPV_ACT_STA & 0x07ff;
  2579.     usIPV_ACT_LEN   = (unsigned int)Data[6] + ((unsigned int)Data[7] << 8);
  2580.     usIPV_ACT_LEN   = usIPV_ACT_LEN & 0x07ff;
  2582.     // Read ucDH_TOTAL
  2583.     RTDRead(DH_TOTAL_22, 2, Y_INC);
  2584.     usDH_Total  = ((unsigned int)(Data[1] & 0x07) << 8) + Data[0];
  2585.     
  2586.     // Read ucDV_Delay
  2587.     RTDRead(IV_DV_LINES_38, 1, N_INC);
  2588.     ucDV_Delay  = Data[0];
  2590.     ucV_Max_Margin  = 0x80;
  2591.     ucV_Min_Margin  = 0x80;
  2593.     Set_Gamma();
  2594.     Set_Dithering();
  2595.     Set_Bright_Contrast();
  2596.     Sharpness();
  2598.     // Update VDC's Contrast/Brightness/Hue/Saturation
  2599.     SetVDC_Color();
  2601.     ucCounter   = 28;
  2602.     do
  2603.     {
  2604.         RTDSetByte(SYNC_POR_4C, 0x00);  // Reset Sync Processor
  2606.         Measure_Mode();
  2608.         Delay_Xms(80);
  2610.         RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  2612.         if (Data[0] & 0x02)
  2613.         {
  2614.             usHsync = 0;
  2615.             usVsync = 0;
  2616.         }
  2617.         else
  2618.         {
  2619.             Data[5] = Data[3];
  2620.             Data[4] = Data[4] & 0x87;
  2621.             Data[3] = Data[1];
  2622.             Data[2] = Data[2] & 0x8f;
  2624.             usHsync = ((unsigned int *)Data)[1];    // Current usHsync timing
  2625.             usVsync = ((unsigned int *)Data)[2];    // Current usVsync timing
  2627.             if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)
  2628.             {
  2629.                 usHsync = 0;
  2630.                 usVsync = 0;
  2631.             }
  2632.             else
  2633.             {
  2634.                 break;
  2635.             }
  2636.         }
  2637.     }
  2638.     while (--ucCounter);
  2640. RTDSetByte(STATUS0_01, 0x00);  // Clear status  
  2641.     RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  2643. Data[0] = Frame_Sync();
  2645.     if (1 == Data[0])   Data[0] = Frame_Sync();     // Fail. Try again
  2647.     bFrameSync      = Data[0] ? 0 : 1;              // 0 : fail, 1 : pass
  2648.    
  2650.     ucSyncErrorCnt  = 0;
  2652. // RTDSetBit(VDIS_CTRL_20, 0x5f, DHS_MASK);        // Normal display
  2653.     RTDSetBit(VDIS_CTRL_20, 0x7f, 0x20 | DHS_MASK);        // Normal display
  2654. #else
  2655.     Set_Video_Mode();
  2656. #endif
  2657. }
  2658. void Input_Mode_Detector(void)
  2659. {
  2660.  RTDRead(SYNC_POR_4C, 0x01, N_INC);
  2661.             
  2662.             if (0 == (Data[0] & 0x02))      ucModeCnt   = 0;
  2664.             if (ucModeCnt)
  2665.             {                  
  2666.      ucModeCnt   -= 1;
  2667.             }
  2668.             else
  2669.             {
  2670.                 ucModeCnt   = MODE_DETECT_FREQ;
  2672. #if(SOURCE_AUTO_SCAN) 
  2673.                 Source_Auto_Scan();
  2674. #else
  2675.                 Mode_Detector();
  2676. #endif
  2678.                 if (!bStable)
  2679.                 {
  2680.                     bReload     = 1;            // Reload user's font
  2682.                     Set_Task(STATE_MODECHANGE); // Notify Task State Machine
  2683.                 }
  2684.             }
  2685. }