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

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

其他嵌入式/单片机内容

开发平台：

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. case SOURCE_DVI :
  25.         // Save previous values of ucMode_Curr, bHpole_Curr and bVpole_Curr
  26.         bHpole_Prev = bHpole_Curr;
  27.         bVpole_Prev = bVpole_Curr;
  28.         
  29.         if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
  30.             Detect_Input_Mode();
  31.         else
  32.             Check_Input_Mode();
  33.         break;
  35.    default :
  36.         if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
  37.             Detect_Video_Mode();        // Set default polarity 
  38.         else
  39.             Check_Video_Mode();         // Set polarity after measure
  40.         break;
  41.     }
  43.     Measure_Mode();     // Measure mode-timing
  44. }
  46. void Measure_Mode(void)
  47. {
  49.     
  50.     switch (stGUD1.INPUT_SOURCE & 0x07)
  51.     {
  52.     RTDSetByte(SYNC_CTRL_4A,0x00);
  53. case SOURCE_VGA :
  54. RTDSetByte(SYNC_POR_4C, (SYNC_SS == ucSync_Type) ? 0x02 : 0x32);
  55. break;
  57.   case SOURCE_DVI :
  58. /*//eric 0729 test issue:DVI source change 
  59. #if (TMDS_ENABLE)
  60.         if (0 == ucTMDS_SEARCH_COUNTER && MODE_NOSIGNAL == ucMode_Curr) // V101C modified
  61.         {
  62.             RTDCodeW(TMDS_MANUAL_ON);
  64.             ucTMDS_SEARCH_COUNTER  = 0x08;
  65.         }        
  66.         ucTMDS_SEARCH_COUNTER -= 0x01;
  67. #endif
  68. */
  69. RTDSetByte(SYNC_POR_4C, 0x02);
  70. break;
  72. default :
  73. RTDSetByte(SYNC_POR_4C, 0x02);
  74. break;
  75.     }
  77. }
  79. #if(SOURCE_AUTO_SCAN)
  80. /////////////////////////////////////////////////////////
  81. //---Detect which source with valid signal-------------//
  82. /////////////////////////////////////////////////////////
  83. void Measure_Source(unsigned char SOURCE)
  84. {
  85.    switch(SOURCE)
  86.    {
  87.    case SOURCE_VGA:
  88. RTDSetByte(SYNC_CTRL_4A,0x01);
  89. break;
  90.    case SOURCE_DVI:
  91. RTDSetByte(SYNC_CTRL_4A,0x03);
  92. break;
  93.    case SOURCE_AV:
  94.         I2CWrite(V_ENABLE);
  95.         I2CWrite(AV_DETECT);
  96.         break;
  97.    case SOURCE_SV:
  98.         I2CWrite(V_ENABLE);
  99.         I2CWrite(SV_DETECT);
  100. break;
  101.    }
  102.    //RTDSetByte(SYNC_POR_4C, 0x32);
  103.    //RTDSetByte(SYNC_POR_4C, 0x02);
  104.    //RTDSetByte(SYNC_POR_4C, (stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA ? 0x32 : 0x02);
  105.    
  106.    if(((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA) && (SYNC_SS != ucSync_Type))
  107.        RTDSetByte(SYNC_POR_4C,0x32);
  108.    else
  109.        RTDSetByte(SYNC_POR_4C,0x02);
  110.    
  111.    Delay_Xms(35);
  112.    //Delay_Xms(24);
  113.    
  115. }
  116. #endif
  118. unsigned char VGA_Mode_Search(unsigned int HS_Pulse)
  119. {
  120.   unsigned char ucMode_Temp,m;
  121.   Data[0] = HS_Pulse * 12 / usHsync;    // 0 : 720x350; 1 : 640x350;
  123.   ucMode_Temp = MODE_NOSUPPORT;
  125.   // Search for Standard Mode
  126.   m   = MODE_1280x1024x75HZ; //anson
  127. //  m   = MODE_1600x1200x60HZ;
  128.   do
  129.   {
  130.   if ((usHsync > VGA_Mode[m][0]) && (usHsync < VGA_Mode[m][1]))
  131.   {   
  132.   if ((usVsync >= VGA_Mode[m][2]) && (usVsync <= VGA_Mode[m][3]))
  133.   {
  134.   if (MODE_1280x1024x75HZ == m)
  135.   {
  136.   if (0 == (bVpole_Curr | bHpole_Curr))   m   = MODE_1280x1024x76HZ;  // SUN 1024-76
  137.   }                            
  138.   else if (MODE_1024x0768x75HZ == m)
  139.   {
  140.   if (0 == (bVpole_Curr | bHpole_Curr))   m   = MODE_1024x0768x74HZ;  // MAC768-75
  141.   }         
  142.   else if (MODE_0640x0480x60HZ == m && bVpole_Curr != bHpole_Curr)
  143.   {
  144.   // MODE_VGA350x60Hz         : 640x350 60Hz
  145.   // MODE_VGA350x60Hz | 0x40  : 720x350 60Hz
  146.   // MODE_VGA400x60Hz         : 640x400 60Hz
  147.   // MODE_VGA400x60Hz | 0x40  : 720x400 60Hz
  148.   if (bHpole_Curr)
  149.   m   = Data[0] ? MODE_VGA350x60Hz : MODE_VGA350x60Hz | 0x40;
  150.   else
  151.   m   = (stGUD1.FUNCTION & 0x10) ? MODE_VGA400x60Hz : MODE_VGA400x60Hz | 0x40;
  152.   //m   = (stGUD1.INPUT_SOURCE & 0x80) ? MODE_VGA400x60Hz : MODE_VGA400x60Hz | 0x40;
  153.   }
  154.   else if (MODE_0640x0480x50HZ == m && bVpole_Curr != bHpole_Curr)
  155.   {
  156.   // MODE_VGA350x50Hz         : 640x350 50Hz
  157.   // MODE_VGA350x50Hz | 0x40  : 720x350 50Hz
  158.   // MODE_VGA400x50Hz         : 640x400 50Hz
  159.   // MODE_VGA400x50Hz | 0x40  : 720x400 50Hz
  160.   if (bHpole_Curr)
  161.   m   = Data[0] ? MODE_VGA350x50Hz : MODE_VGA350x50Hz | 0x40;
  162.   else
  163.   m   = (stGUD1.FUNCTION & 0x10) ? MODE_VGA400x50Hz : MODE_VGA400x50Hz | 0x40;
  164.   //m   = (stGUD1.INPUT_SOURCE & 0x80) ? MODE_VGA400x50Hz : MODE_VGA400x50Hz | 0x40;
  165.   }
  166.   else if (MODE_0720x0400x85HZ == m)
  167.   {
  168.   if (1 == bHpole_Curr && 0 == bVpole_Curr)
  169.   m   = MODE_0640x0350x85HZ;
  170.   else if (stGUD1.FUNCTION & 0x10)     //else if (stGUD1.INPUT_SOURCE & 0x80)     
  171.   m   = MODE_0640x0400x85HZ;
  172.   }
  173.   else if (MODE_0720x0400x70HZ == m)
  174.   {
  175.   if (1 == bHpole_Curr && 0 == bVpole_Curr)
  176.   m   = Data[0] ? MODE_0640x0350x70HZ : MODE_0720x0350x70HZ;
  177.   else if ((stGUD1.FUNCTION & 0x10)==0)     //else if (stGUD1.INPUT_SOURCE & 0x80) //anson
  178. //   else if (stGUD1.FUNCTION & 0x10)     //else if (stGUD1.INPUT_SOURCE & 0x80)
  179.   m   = MODE_0640x0400x70HZ;
  180.   }
  181.   else if (MODE_1024x0768x59HZ == m)
  182.   {
  183.   if(HS_Pulse > 45)
  184.   m = MODE_1024x0768x60HZ;
  185.   }
  186.   else if (MODE_1024x0768x60HZ == m)
  187.   {
  188.   if(HS_Pulse <= 45)
  189.   m = MODE_1024x0768x59HZ;    
  190.   }
  191.   else if(MODE_1024x0768x72HZ == m) //anson 05_0321
  192.   {
  193.      if(ucRefresh <= 71)
  194.       m = MODE_1024x0768x70HZ;
  195.   }
  197.   ucMode_Temp     = m;
  198.   }
  199.   }
  200.   }
  201.   while ((0 != --m) && (MODE_NOSUPPORT == ucMode_Temp));
  202.   
  203.   // Search for User Mode
  204.   if (MODE_NOSUPPORT == ucMode_Temp)
  205.   {
  206.   usIPV_ACT_LEN   = 0;
  208.   m   = MODE_USER1280x1024; //anson
  209. //   m   = MODE_USER1600x1200;
  210.   do
  211.   {
  212.   if ((usVsync >= VGA_Mode[m][2]) && (usVsync <= VGA_Mode[m][3]))
  213.   {
  214.   usIPV_ACT_LEN   = CAP_WIN[m][4];
  215.   
  216.   if ((usHsync >= VGA_Mode[m][0]) && (usHsync <= VGA_Mode[m][1]))
  217.   {
  218.   ucMode_Temp     = m;    // Support User Mode
  219.   }
  220.   }
  221.   }
  222.   while ((MODE_USER720x400 <= --m) && (MODE_NOSUPPORT == ucMode_Temp));
  223.   }
  225.   return ucMode_Temp;
  227. }
  229. unsigned char Partial_Display(void)
  230. {
  231. unsigned char ucMode_Temp;
  233. if (DISP_LEN < usIPV_ACT_LEN)   // V Scale-down
  234. {
  235. // Estimate display clock rate for full screen
  236. // DCLK = (24.576MHz / usHsync) * DCLK per display line * (display image lines / input image lines)
  237. ((unsigned int *)Data)[0]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED1][0] * DISP_LEN 
  238. / ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
  240. if (MAX_DCLK < ((unsigned int *)Data)[0])
  241. {
  242. // If clock rate for full-screen display is too high, we can try partial-V display.
  243. // Estimate clock for partial-V display
  244. // DCLK = (24.576MHz / usHsync) * DCLK per display line * (min. display total lines / input total lines)
  245. ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED1][0] * MIN_DV_TOTAL
  246. / ((unsigned long)100 * (usVsync - 1) * usHsync);
  248. if (MAX_DCLK < ((unsigned int *)Data)[1])
  249. {
  250. // Decrease usIPV_ACT_LEN to DISP_LEN and go further to check if it can be displayed.
  251. usIPV_ACT_LEN   = DISP_LEN;
  252. }
  253. else
  254. {
  255. ucMode_Temp     = MODE_UNDEFINED1 | 0x80;   // Scale-down and partial-V display
  256. }
  257. }
  258. else
  259. ucMode_Temp     = MODE_UNDEFINED1;              // Scale-down and full-V display
  260. }
  262. if (DISP_LEN >= usIPV_ACT_LEN)  // V Scale-up
  263. {
  264. ((unsigned int *)Data)[0]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0] * DISP_LEN 
  265. / ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
  267. if (MAX_DCLK < ((unsigned int *)Data)[0])
  268. {
  269. if (MIN_DV_TOTAL >= (usVsync - 1))
  270. {
  271. ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0] * MIN_DV_TOTAL
  272. / ((unsigned long)100 * (usVsync - 1) * usHsync);
  273. }
  274. else
  275. {
  276. ((unsigned int *)Data)[1]   = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0]
  277. / ((unsigned long)100 * usHsync);
  278. }
  280. if (MAX_DCLK < ((unsigned int *)Data)[1])   
  281. ucMode_Temp = MODE_NOSUPPORT;           // Cannot display
  282. else
  283. ucMode_Temp = MODE_UNDEFINED0 | 0x80;   // Scale-up and partial-V display
  284. }
  285. else
  286. ucMode_Temp = MODE_UNDEFINED0;              // Scale-up and full-V display
  287. }
  289. return ucMode_Temp;
  291. }
  293. void Sync_Type_Switch(void)
  294. {
  295. if (MODE_NOSIGNAL == ucMode_Curr)
  296. {
  297. if (SYNC_CS == ucSync_Type)         // CS->SS
  298. {
  299. RTDCodeW(VGA_SET_SS);
  301. bVpole_Curr = 1;
  302. bHpole_Curr = 1;
  303. ucSync_Type = SYNC_SS;
  305. }
  306. else if (SYNC_SS == ucSync_Type)    // SS->SOG
  307. {
  308. RTDCodeW(VGA_SET_SOG);
  310. bVpole_Curr = 1;
  311. bHpole_Curr = 1;
  312. ucSync_Type = SYNC_SOG;
  316. }
  317. else                                // SOG->CS
  318. {
  319. RTDCodeW(VGA_SET_CS);
  321. bVpole_Curr = 1;
  322. bHpole_Curr = 1;
  323. ucSync_Type = SYNC_CS;
  327. }
  328. }
  329. }
  331. void Sync_Type_Confirm(void)
  332. {
  333.   
  334. #if(SOURCE_AUTO_SCAN == _FALSE)
  335. unsigned char m;
  336.             
  337. // To prevent from mistaking CS (with VS) for SS, we check SYNC type once when finding a mode in SS.
  338.             
  339.       if (SYNC_SS == ucSync_Type)
  340.   {           
  341.   RTDSetByte(SYNC_CTRL_4B, 0x55);
  343.   RTDSetByte(SYNC_POR_4C, 0x22);
  345.   m   = (MODE_DETECT_FREQ + 1) * 20;       
  346.   do
  347.   {   
  348.   Delay_Xms(1);
  349.   RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  350.   }
  351.   while ((Data[0] & 0x02) && (--m));
  352.   
  353.   Data[5] = Data[3];
  354.   Data[4] = Data[4] & 0x87;
  355.   Data[3] = Data[1];
  356.   Data[2] = Data[2] & 0x8f;
  358.   if ((0 == ((unsigned int *)Data)[1]) || (0x07ff <= ((unsigned int *)Data)[1]) ||
  359.   (0 == ((unsigned int *)Data)[2]) || (0x07ff <= ((unsigned int *)Data)[2]) ||
  360.   (0 == m))
  361.   {
  362.   ucSync_Type = SYNC_SS;
  364.   RTDSetByte(SYNC_CTRL_4B, 0x14);
  365.   }
  366.   else
  367.   {
  368.   ucSync_Type = SYNC_CS;
  370.   RTDCodeW(VGA_SET_CS);
  372.   bVpole_Curr = 1;
  373.   bHpole_Curr = 1;
  374.   }
  375.   }
  376.   else if (SYNC_SOG == ucSync_Type)
  377.   {
  378.   RTDSetByte(SYNC_CTRL_4B, 0x14);
  379.   Delay_Xms(8);
  381.   RTDSetByte(SYNC_POR_4C, 0x00);
  382.   RTDSetByte(SYNC_POR_4C, 0x02);
  383.   
  385.   m   = (MODE_DETECT_FREQ + 1) * 20;       
  386.   do
  387.   {   
  388.   Delay_Xms(1);
  389.   RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  390.   }
  391.   while ((Data[0] & 0x02) && (--m));
  392.   
  393.   Data[5] = Data[3];
  394.   Data[4] = Data[4] & 0x87;
  395.   Data[3] = Data[1];
  396.   Data[2] = Data[2] & 0x8f;
  398.   if ((0 == ((unsigned int *)Data)[1]) || (0x07ff <= ((unsigned int *)Data)[1]) ||
  399.   (0 == ((unsigned int *)Data)[2]) || (0x07ff <= ((unsigned int *)Data)[2]) ||
  400.   (0 == m))
  401.   {
  402.   ucSync_Type = SYNC_SOG;
  404.   
  405.   RTDSetByte(SYNC_CTRL_4B, 0x57);
  406.   //RTDSetByte(VGIP_SIGINV_05, 0x40);
  407.   Delay_Xms(8);
  408.   
  409.   RTDSetByte(SYNC_POR_4C,0x32);
  410.   Delay_Xms(20);
  411.   RTDSetByte(SYNC_POR_4C, 0x00);
  412.   
  413.   }
  414.   else
  415.   {
  416.   ucSync_Type = SYNC_SS;
  418.   RTDCodeW(VGA_SET_SS);
  420.   bVpole_Curr = 1;
  421.   bHpole_Curr = 1;
  422.   }
  423.   }
  424. #endif
  426. }
  427. /////////////////////////////////////////////////////////
  428. //------------  Detect VGA & DVI Mode  ----------------//
  429. /////////////////////////////////////////////////////////
  430. void Detect_Input_Mode(void)
  431. {
  432.     unsigned char   ucMode_Temp;
  433.     unsigned int    usHS_Pulse;
  435.     RTDRead(SYNC_POR_4C, 0x09, Y_INC);
  437.     if (Data[0] & 0x02)
  438.     {
  439.         // Reset Sync Processor when sync signal timeout
  440.         RTDSetByte(SYNC_POR_4C, ((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA) ? 0x20 : 0x00);
  442.         // Treat sync signal timeout as no signal
  443.         ucMode_Temp     = MODE_NOSIGNAL;
  444.     }
  445.     else
  446.     {
  447.           
  448. //        ucMode_Temp = (Data[8] & 0xe0 ) >> 5;
  450. //        if(ucMode_Temp == 0 || ucMode_Temp >=4) //Test which edge of Hsync to latch Vsync will be safe
  451. // {
  452. //           RTDSetBit(MEAS_VS_HI_54,0xf7,0x08);  //Use positive edge of Hsync to latch Vsync
  453. //    ucDebug_Value0 = 0x08;
  454. // }
  455. // else
  456. // {
  457. //    RTDSetBit(MEAS_VS_HI_54,0xf7,0x00);  //Use negtive edge of Hsync to latch Vsync
  458. //    ucDebug_Value0 = 0x18;
  459. // }
  461.         
  462.         usStdHS   = usHsync;  // Save previous usHsync in usStdHS
  463.         usStdVS   = usVsync;  // Save previous usVsync in usStdVS
  465.         bVpole_Curr = (bit)(Data[0] & 0x08);    // Save current usVsync polarity
  466.         bHpole_Curr = (bit)(Data[0] & 0x04);    // Save current usHsync polarity
  468.         Data[7] = Data[5];
  469.         Data[6] = Data[6] & 0x0f;
  470.         Data[5] = Data[3];
  471.         Data[4] = Data[4] & 0x87;
  472.         Data[3] = Data[1];
  473.         Data[2] = Data[2] & 0x8f;
  475.         usHsync     = ((unsigned int *)Data)[1];    // Current HSYNC timing
  476.         usVsync     = ((unsigned int *)Data)[2];    // Current VSYNC timing
  478.         if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA)
  479.             usHS_Pulse  = ((unsigned int *)Data)[3];    // Current HSYNC pulse width
  481.         // Calculate Vertical Refresh Rate
  482.         // Original Formula :
  483.         // ucRefresh = 24.576M / (usHsync * usVsync)
  484.         // Use Data[0~3] as a temporary long variable
  485.         ((unsigned long *)Data)[0]  = (unsigned long)usHsync * usVsync;
  486.         ucRefresh   = (unsigned long)49152000 / ((unsigned long *)Data)[0];
  487.         ucRefresh   = (ucRefresh & 0x01) ? ((ucRefresh + 1) >> 1) : (ucRefresh >> 1);
  489.         // Treat small change of usHsync/usVsync as no change
  490.         if (usStdHS <= usHsync && (usStdHS + 2) >= usHsync)     usHsync = usStdHS;
  491.         if (usStdVS <= usVsync && (usStdVS + 2) >= usVsync)     usVsync = usStdVS;
  493.         // Polarity must be correct
  494.         if ((bVpole_Curr != bVpole_Prev) || (bHpole_Curr != bHpole_Prev))
  495.         {  
  496.             RTDRead(VGIP_SIGINV_05, 0x01, N_INC);
  497.           
  498.             if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA)
  499.             {
  500.                Data[0] &= 0xd7;  // HS_RAW & VS positive
  502.                if (!bHpole_Curr)    Data[0] |= 0x20;
  503.             
  504.                if (!bVpole_Curr && SYNC_SS == ucSync_Type)     Data[0] |= 0x08;    // Seperate sync
  506.    ucMode_Temp     = MODE_NOSUPPORT;
  507.             }
  508.             else if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_DVI)
  509.             {
  510.                Data[0] &= 0xf3;  // VS & HS positive
  512.                if (!bVpole_Curr)    Data[0] |= 0x08;
  513.                if (!bHpole_Curr)    Data[0] |= 0x04;
  514.             }            
  515.             RTDSetByte(VGIP_SIGINV_05, Data[0]);
  517.             
  518.         }
  519.         else
  520.         {
  521.             if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)
  522.             {
  523.                 ucMode_Temp     = MODE_NOSIGNAL;        // Treat overflow as no signal
  524.             }
  525.             else
  526.             {
  527.                 ucMode_Temp = ((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA) ? VGA_Mode_Search(usHS_Pulse) : MODE_NOSUPPORT;
  530.                 if (48 > ucRefresh || MAX_RATE < ucRefresh)
  531.                 {
  532.                     ucMode_Temp = MODE_NOSUPPORT;   // We don't support vertical refresh rate lower than 50Hz
  533.                 }
  534.                 else if (MODE_NOSUPPORT == ucMode_Temp && (0 != usIPV_ACT_LEN) && ((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA))
  535.                 {     
  536.         ucMode_Temp = Partial_Display();
  537. }
  538. else if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_DVI)
  539.       ucMode_Temp = Seek_DVI_Mode(ucMode_Temp);
  541. // ucDebug_Value0 = ucMode_Temp;
  542.         }
  543.         }
  544.     }
  546. if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA)
  547. {
  548.         if (SYNC_SOG == ucSync_Type && 0 != (usHS_Pulse * 7 / usHsync))
  549.         {
  550.           // To prevent from SOG mode mistake
  551.           // HSYNC pulse width will never longer than 1/7*HSYNC period
  552.           ucMode_Temp = MODE_NOSIGNAL;
  553.         }
  554. }
  556.     //-------------Check result-----------------------------------------
  557.     if (MODE_NOSUPPORT == ucMode_Temp || MODE_NOSIGNAL == ucMode_Temp)
  558.     {
  559.         // Treat illegal signal as no signal when SOG
  560. if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA)
  561. {
  562.            if (SYNC_SOG == ucSync_Type)    
  563.        ucMode_Temp = MODE_NOSIGNAL;
  564.  }
  566.         if (MODE_NOSUPPORT != ucMode_Found && MODE_NOSIGNAL != ucMode_Found)    ucMode_Times    = 0;
  568.         ucMode_Found    = ucMode_Temp;
  570.         if (NO_MODE_TIMES > ucMode_Times)
  571.         {
  572.             // Wait for signal stable
  573.             ucMode_Times ++;
  575. if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_DVI)
  576. {
  577.    //Enable the TMDS Hsync & Vsync error correction to improve the long cable image quality
  578.                RTDSetByte(TMDS_CORRECTION_FF,0x03);
  579. }
  580.         }
  581.         else
  582.         {
  583.     if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_DVI)
  584. {
  585.    //Disable the TMDS Hsync & Vsync error correction
  586.                RTDSetByte(TMDS_CORRECTION_FF,0x00);
  587. }
  589.             bStable         = (ucMode_Curr == ucMode_Found) ? 1 : 0;    // bStable must be cleared when mode changed
  590.             ucMode_Curr     = ucMode_Found;
  591.             ucMode_Times    = NO_MODE_TIMES - 2;
  593. if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA)
  594.     Sync_Type_Switch();
  595.             
  596.         }
  597.     }
  598.     else
  599.     {
  600.         if (ucMode_Found != ucMode_Temp)
  601.         {
  602.             ucMode_Times    = 1;
  603.             ucMode_Found    = ucMode_Temp;
  605. if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA)
  606.     Sync_Type_Confirm();
  607.         }
  608.         else
  609.         {   
  610.     Data[0] = ((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA) ? VGA_SEARCH_TIMES : DVI_SEARCH_TIMES;
  611.             //if (VGA_SEARCH_TIMES > ucMode_Times)
  612. if (Data[0] > ucMode_Times)
  613.             {
  614.                 ucMode_Times ++;
  615.             }
  616.             else
  617.             {
  619.                 bLIGHT_PWR  = LIGHT_OFF;        // Turn off BackLight for reset display
  620.               
  621.                 RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  622.                 RTDOSDW(OSD_Reset);            // Clear OSD
  624.                 ucMode_Curr     = ucMode_Found; // Supported mode found
  625.                 ucMode_Times    = 0;            // Reset mode timer
  626.                 bStable         = 0;            // bStable must be cleared when mode changed
  628. if((stGUD1.INPUT_SOURCE & 0x07)== SOURCE_VGA)
  629.                     Display_VGA_Set();              // Set VGA Mode registers
  630. else
  631.     Display_DVI_Set();
  634. #if (RTDDEBUG)
  635.                 if (ucMode_PrevAct == ucMode_Curr)
  636.                 {
  637.                     if (0xff > ucMode_QuitCnt)      ucMode_QuitCnt += 1;
  638.                 }
  639.                 else
  640.                 {
  641.                     ucMode_PrevAct  = ucMode_Curr;
  642.                     ucMode_QuitCnt  = 0;
  643.                     ucDebug         = 0;
  644.                 }
  645. #endif                
  646.             }
  647.         }
  648.     }
  649. }
  651. //-------------------  Check VGA & DVI Mode  -------------------//
  652. void Check_Input_Mode(void)
  653. {    
  654.     RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  656.     if (Data[0] & 0x02)
  657.     {
  658.         RTDSetByte(SYNC_POR_4C, ((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA) ? 0x20 : 0x00);          // Input signal time-out. Reset sync-processor
  660.         ucMode_Found    = MODE_NOSUPPORT;
  661.     }
  662.     else
  663.     {
  664.         bVpole_Curr = (bit)(Data[0] & 0x08);    // Current usVsync polarity
  665.         bHpole_Curr = (bit)(Data[0] & 0x04);    // Current usHsync polarity
  667.         Data[5] = Data[3];
  668.         Data[4] = Data[4] & 0x87;
  669.         Data[3] = Data[1];
  670.         Data[2] = Data[2] & 0x8f;
  671.         usHsync = ((unsigned int *)Data)[1];    // Current usHsync timing
  672.         usVsync = ((unsigned int *)Data)[2];    // Current usVsync timing
  674.         // Polarity must be correct
  675.         if ((bVpole_Curr != bVpole_Prev) || (bHpole_Curr != bHpole_Prev))
  676.         {
  677.             RTDRead(VGIP_SIGINV_05, 0x01, N_INC);
  678.             /*
  679.             Data[0] &= 0xd7;    // HS_RAW & VS positive
  681.             if (!bHpole_Curr)   Data[0] |= 0x20;
  683.             if (!bVpole_Curr && SYNC_SS == ucSync_Type)     Data[0] |= 0x08;    // Seperate sync
  684.             */
  685.             
  687.             if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA)
  688.             {
  689.                  Data[0] &= 0xd7;    // HS_RAW & VS positive
  691.                  if (!bHpole_Curr)   Data[0] |= 0x20;
  693.                  if (!bVpole_Curr && SYNC_SS == ucSync_Type)     Data[0] |= 0x08;    // Seperate sync
  694.             }
  695.             else if((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_DVI)
  696.             {
  697.                  Data[0] &= 0xf3;  // VS & HS positive
  699.                  if (!bVpole_Curr)    Data[0] |= 0x08;
  700.                  if (!bHpole_Curr)    Data[0] |= 0x04;
  701.             }
  703.             RTDSetByte(VGIP_SIGINV_05, Data[0]);
  705.             ucMode_Found    = MODE_NOSUPPORT;
  706.         }
  707.         else
  708.         {
  709.             if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)     // Check overflow
  710.             {
  711.                 ucMode_Found    = MODE_NOSUPPORT;
  712.             }
  713.             else
  714.             {
  715.                 if ((usHsync < (usStdHS - 1)) || (usHsync > (usStdHS + 3)) ||
  716.                     (usVsync < (usStdVS - 1)) || (usVsync > (usStdVS + 3)))
  717.                 {   
  718.                     ucMode_Found    = MODE_NOSUPPORT;
  719.                 }
  720.                 else
  721.                 {
  722.                     ucMode_Found    = ucMode_Curr;
  723.                 }
  724.             }
  725.         }
  726.     }
  727.     
  728.     if (MODE_NOSUPPORT == ucMode_Found)
  729.         Reset_Mode();
  730.     else
  731. {
  732.         bStable = 1;    // Set bStable to 1 when signal timing is stable.
  733. #if(AS_NON_FRAMESYNC)
  734.         RTDSetByte(STATUS0_01, 0x00);  // Clear status
  735.         RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  737.         if(bFrameSync)
  738.            RTDSetBit(ODD_CTRL_8E,0xef,0x10);
  739. #endif
  740.     }
  742. }
  747. unsigned char Seek_DVI_Mode(unsigned char mode)
  748. {
  749. #if(TMDS_ENABLE)
  750.     unsigned char   Wait_Time_Cnt;
  752.     RTDSetByte(SYNC_POR_4C, 0x03);  // Measure data enable width and height
  754.     Wait_Time_Cnt  = 60;       
  755.     do
  756.     {   
  757.         Delay_Xms(1);
  758.         RTDRead(SYNC_POR_4C, 0x07, Y_INC);
  759.     }
  760.     while ((Data[0] & 0x02) && (--Wait_Time_Cnt));
  762.     Data[7] = Data[5];
  763.     Data[6] = Data[6] & 0x0f;
  764.     Data[5] = Data[3];
  765.     Data[4] = Data[4] & 0x87;
  766.     Data[3] = Data[1];
  767.     Data[2] = Data[2] & 0x8f;
  769.     // Measure Failed !!!
  770.     if ((0 == ((unsigned int *)Data)[1]) || (0x07ff <= ((unsigned int *)Data)[1]) ||
  771.         (0 == ((unsigned int *)Data)[2]) || (0x07ff <= ((unsigned int *)Data)[2]) ||
  772.         (0 == Wait_Time_Cnt))
  773.     {
  774.         RTDSetByte(SYNC_POR_4C, 0x00);
  776.         return MODE_NOSUPPORT;
  777.     }
  779.     // Save IH_TOTAL in usADC_Clock
  780.     usADC_Clock     = ((unsigned int *)Data)[1] * 2;
  782.     // Save input data enable width and height
  783.     usIPV_ACT_LEN   = ((unsigned int *)Data)[2];
  784.     usIPH_ACT_WID   = ((unsigned int *)Data)[3] * 2;
  786.     // We don't support input image less than 350 active lines
  787.     if (350 > usIPV_ACT_LEN)    return MODE_NOSUPPORT;
  789.     // We only support 8N active width
  790.     usIPH_ACT_WID   = (2 < (usIPH_ACT_WID & 0x0007)) ? ((usIPH_ACT_WID + 8) & 0xfff8) : (usIPH_ACT_WID & 0xfff8);
  792.     // We only support active width not larger than 1280
  793.     if (1280 < usIPH_ACT_WID)   usIPH_ACT_WID   = 1280;
  795.     // Calculate maximum usIPV_ACT_LEN limitation
  796.     ((unsigned int *)Data)[0]   = (unsigned long)(usVsync - 1) * DISP_LEN / MIN_DV_TOTAL;
  798.     if (((unsigned int *)Data)[0] < usIPV_ACT_LEN)      usIPV_ACT_LEN   = ((unsigned int *)Data)[0];
  800.     mode    = MODE_UNDEFINED0;
  801.   
  802.     if (MODE_UNDEFINED0 == mode)
  803.     {
  804.         // First, we try user-mode to fit the undefined mode for full-screen display.
  805.         Wait_Time_Cnt   = MODE_USER720x400;
  806.         do
  807.         {
  808.             if (Mode_Preset[Wait_Time_Cnt][2] < CAP_WIN[Wait_Time_Cnt][4])   // V scale-down
  809.             {
  810.                 // Larger scale-down ratio may need a larger DH_TOTAL. 
  811.                 // So usIPV_ACT_LEN should not be too larger than pre-set capture window length
  812.                 if (Mode_Preset[Wait_Time_Cnt][2] > usIPV_ACT_LEN || (CAP_WIN[Wait_Time_Cnt][4] + 24) < usIPV_ACT_LEN)   continue;
  813.             }
  814.             else
  815.             {
  816.                 if (Mode_Preset[Wait_Time_Cnt][2] < usIPV_ACT_LEN)   continue;
  817.             }
  819.             ((unsigned int *)Data)[0]   = (unsigned long)2458 * Mode_Preset[Wait_Time_Cnt][0] * Mode_Preset[Wait_Time_Cnt][2]
  820.                                         / ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
  821.             
  822.             // Return if we find out a suitable user-mode.
  823.             if (MAX_DCLK > ((unsigned int *)Data)[0])   return Wait_Time_Cnt;
  824.         }
  825.         while (MODE_USER1600x1200 >= ++Wait_Time_Cnt);
  827. mode = Partial_Display();
  828.         // If failed, we try partial-screen display.
  830.     }
  833.     return  mode;
  834. #else
  835.     mode    = MODE_UNDEFINED0;
  836.     return  0;
  837. #endif
  838. }
  840. /////////////////////////////////////////////////////////
  841. //------------------ Detect VIDEO Mode ----------------//
  842. /////////////////////////////////////////////////////////
  843. void Detect_Video_Mode(void)
  844. {
  845. #if(VIDEO_CHIP != VDC_NONE)
  846.     I2CRead(ADDR_VIDEO, 0x1f, 0x01);
  848.     //------ Check Horizontal Lock & Frequency ------
  849.     if (0 == (Data[0] & 0x40))
  850.     {   
  851.         if ((Data[0] & 0x20) && (0x01 != (ucAV_Mode & 0x0f)))
  852.         {
  853.             // Field rate changed to 60Hz
  854.             ucAV_Mode       = 0x01;
  855.             ucMode_Found    = MODE_NOSUPPORT;
  856.             ucMode_Times    = 0;
  858.             Data[0] = 4;
  859.             Data[1] = ADDR_VIDEO;
  860.             Data[2] = 0x0e;
  861.             Data[3] = 0x08;     // Start color search from NTSC-M
  862.             I2CWrite(Data);
  863.         }
  864.         else if ((0 == (Data[0] & 0x20)) && (0x02 != (ucAV_Mode & 0x02)))
  865.         {
  866.             // Field rate changed to 50Hz
  867.             ucAV_Mode       = 0x02; 
  868.             ucMode_Found    = MODE_NOSUPPORT;
  869.             ucMode_Times    = 0;
  870.             
  871.             Data[0] = 4;
  872.             Data[1] = ADDR_VIDEO;
  873.             Data[2] = 0x0e;
  874.             Data[3] = 0x08;     // Start color search from PAL-BDGHI
  875.             I2CWrite(Data);
  876.         }
  877.         else
  878.         {    
  879.             //------ Check Lock Color ------
  880.             if (0x01 == (Data[0] & 0x01))
  881.             {   
  882.                 // Lock Color
  883.                 if (ucAV_Mode & 0x01)
  884.                 {
  885.                     if (MODE_VIDEO60HZ == ucMode_Found)
  886.                     {
  887.                         ucMode_Times ++;
  888.                     }
  889.                     else
  890.                     {
  891.                         ucMode_Found    = MODE_VIDEO60HZ;
  892.                         ucMode_Times    = 0;
  893.                     }
  894.                 }
  895.                 else
  896.                 {
  897.                     if (MODE_VIDEO50HZ == ucMode_Found)
  898.                     {
  899.                         ucMode_Times ++;
  900.                     }
  901.                     else
  902.                     {
  903.                         ucMode_Found    = MODE_VIDEO50HZ;
  904.                         ucMode_Times    = 0;
  905.                     }
  906.                 }
  907.             }
  908.             else
  909.             {
  910.                 // Non Lock Color
  911.                 if (MODE_NOSUPPORT != ucMode_Found)
  912.                 {
  913.                     ucMode_Found    = MODE_NOSUPPORT;
  914.                     ucMode_Times    = 0;
  915.                 }
  916.                 
  917.                 Data[0] = 4;
  918.                 Data[1] = ADDR_VIDEO;
  919.                 Data[2] = 0x0e;
  920.                 
  921.                 if (0x03 == (ucAV_Mode & 0x03))
  922.                 {
  923.                     // SECAM -> PAL-BDGHI(50Hz)
  924.                     Data[3] = 0x08;
  925.                     I2CWrite(Data);                    
  926.                     ucAV_Mode   = 0x02;
  927.                 }
  928.                 else
  929.                 {
  930.                     if (ucMode_Times & 0x01)    // Every 2-times , change color
  931.                     {
  932.                         switch (ucAV_Mode & 0x70)
  933.                         {
  934.                         case 0x00:  
  935.                             Data[3] = 0x18; // NTSC-4.43(50Hz)  // PAL-4.43(60Hz)
  936.                             I2CWrite(Data);
  937.                             ucAV_Mode   = (ucAV_Mode & 0x0f) | 0x10;
  938.                             break;
  939.                         case 0x10:
  940.                             Data[3] = 0x28; // PAL-N(50Hz)      // NTSC-4.43(60Hz)
  941.                             I2CWrite(Data);
  942.                             ucAV_Mode   = (ucAV_Mode & 0x0f) | 0x20;
  943.                             break;
  944.                         case 0x20:
  945.                             Data[3] = 0x38; // NTSC-N(50Hz)     // PAL-M(60Hz)
  946.                             I2CWrite(Data);
  947.                             ucAV_Mode   = (ucAV_Mode & 0x0f) | 0x30;
  948.                             break;
  949.                         case 0x30:
  950.                             if (ucAV_Mode & 0x02)
  951.                             {
  952.                                 // NTSC-N -> SECAM (50Hz)
  953.                                 Data[3]     = 0x5c;
  954.                                 I2CWrite(Data);
  955.                                 ucAV_Mode   = 0x03;
  956.                             }
  957.                             else
  958.                             {
  959.                                 // PAL-M -> NTSC_M (60Hz)
  960.                                 Data[3]     = 0x08;
  961.                                 I2CWrite(Data);
  962.                                 ucAV_Mode   = ucAV_Mode & 0x0f | 0x00;
  963.                             }    
  964.                         default:
  965.                             break;
  966.                         }//end of "switch (ucAV_Mode & 0x70)"
  967.                     }//end of "if (ucMode_Times & 0x01)"
  968.                 }//end of "if (0x03 == (ucAV_Mode & 0x03)) else"
  969.             }//end of "Non Lock color
  970.         }//end of "Check Lock Color"
  971.     }//end of "if (0==(Data[0] & 0x40))"
  972.     else
  973.     {   
  974.         // Non Horizontal Lock
  975.         ucAV_Mode   = 0;
  976.         
  977.         if (ucMode_Found != MODE_NOSUPPORT)
  978.         {
  979.             ucMode_Found    = MODE_NOSUPPORT;
  980.             ucMode_Times    = 0;
  981.         }
  982.     }
  983.     
  984.     //-------------Check result--------------
  985.     if (MODE_NOSUPPORT != ucMode_Found)
  986.     {   
  987.         if (VIDEO_SEARCH_TIMES < ucMode_Times)
  988.         {
  990.             bLIGHT_PWR  = LIGHT_OFF;        // Turn off BackLight for reset display
  991.             
  992.             RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  993.             RTDOSDW(OSD_Reset);            // Clear OSD
  994.             
  995.             if (SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07))
  996.                 ucMode_Curr = (ucAV_Mode & 0x02) ? MODE_YUV50HZ : MODE_YUV60HZ;
  997.             else
  998.                 ucMode_Curr = ucMode_Found;
  999.                     
  1000.             ucMode_Times    = 0;
  1001.             bStable         = 0;            // bStable must be cleared when mode changed
  1003.             Display_Video_Set();            
  1004.         }
  1005.     }
  1006.     else
  1007.     {
  1008.         ucMode_Times ++;
  1009.         
  1010.         if (ucAV_Mode)
  1011.         {
  1012.             // Force to display although we cannot lock color
  1013.             if (VIDEO_SEARCH_TIMES < ucMode_Times 
  1014.                 && (NO_COLOR_TIMES < ucMode_Times || SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07)))
  1015.             {
  1017.                 bLIGHT_PWR  = LIGHT_OFF;        // Turn off BackLight for reset display
  1019.                 RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  1020.                 RTDOSDW(OSD_Reset);            // Clear OSD
  1021.                 
  1022.                 ucAV_Mode       = (ucAV_Mode & 0x02) ? 0x82 : 0x81;
  1024.                 if (SOURCE_YUV != (stGUD1.INPUT_SOURCE & 0x07))
  1025.                     ucMode_Curr = (ucAV_Mode & 0x02) ? MODE_VIDEO50HZ : MODE_VIDEO60HZ;
  1026.                 else
  1027.                     ucMode_Curr = (ucAV_Mode & 0x02) ? MODE_YUV50HZ : MODE_YUV60HZ;
  1029.                 ucMode_Times    = 0;
  1030.                 bStable         = 0;    // bStable must be cleared when mode changed
  1032.                 Display_Video_Set();
  1033.             }
  1034.         }
  1035.         else
  1036.         {
  1037.             if (NO_MODE_TIMES < ucMode_Times)
  1038.             {
  1039.                 bStable         = 1;    // Set bStable to 1 when signal timing is stable.
  1041.                 ucMode_Times    = NO_MODE_TIMES - 1;
  1042.             }
  1043.         }
  1044.     }
  1045. #else
  1046.     Display_Video_Set();
  1047. #endif
  1048. }
  1051. //-------------------  Check AV Mode  -------------------//
  1052. void Check_Video_Mode(void)
  1053. {   
  1054. #if(VIDEO_CHIP != VDC_NONE)
  1055.     I2CRead(ADDR_VIDEO, 0x1f, 0x01);
  1056.     
  1057.     // Check color
  1058.     if (0 == (ucAV_Mode & 0x80))
  1059.     {
  1060.         if (0 == (Data[0] & 0x01))      ucMode_Curr = MODE_NOSIGNAL;    // Color standard changed
  1061.     }
  1062.     else
  1063.     {
  1064.         if (0 == (Data[0] & 0x01))
  1065.         {
  1066.             ucMode_Times    = 0;
  1067.         }
  1068.         else
  1069.         {
  1070.             // When we cannot lock color, we set color standard to PAL-BDGHI if field rate is 50Hz, 
  1071.             // and to NTSC-M if it is 60Hz.
  1072.             // If we find color is locked, we should update ucAV_Mode to indicate we now get color.
  1073.             if (VIDEO_SEARCH_TIMES < ++ucMode_Times)    ucAV_Mode = ucAV_Mode & 0x0f;
  1074.         }
  1075.     }
  1077.     // Check field rate
  1078.     if (Data[0] & 0x40)
  1079.     {
  1080.         ucMode_Curr = MODE_NOSIGNAL;
  1081.     }
  1082.     else
  1083.     {
  1084.         if (ucAV_Mode & 0x02)       // 50Hz
  1085.         {   
  1086.             if (0x00 != (Data[0] & 0x20))   ucMode_Curr = MODE_NOSIGNAL;
  1087.         } 
  1088.         else                        // 60Hz
  1089.         {
  1090.             if (0x00 == (Data[0] & 0x20))   ucMode_Curr = MODE_NOSIGNAL;
  1091.         }
  1092.     }
  1093.    
  1094.     // Check result
  1095.     if (MODE_NOSIGNAL == ucMode_Curr)
  1096.         Reset_Mode();
  1097.     else
  1098.         bStable = 1;    // Set bStable to 1 when signal timing is stable.
  1099. #endif
  1100. }
  1103. void Calculate_IVS2DVS_Delay(unsigned char integer, unsigned char fraction, unsigned int DVStart)
  1104. {
  1105.        if ((usIPV_ACT_STA + integer) < (DVStart >> 6))
  1106.         {
  1107.             // You should never get into this code ....
  1108.             usIPV_ACT_STA   = ( DVStart >> 6) - integer;
  1110.             RTDSetByte(IPV_ACT_STA_0A, (unsigned char)usIPV_ACT_STA);
  1111.             RTDSetByte(IPV_ACT_STA_0A + 1, (unsigned char)(usIPV_ACT_STA >> 8));
  1112.         }
  1114.         ((unsigned int*)Data)[0] = ((usIPV_ACT_STA + integer) << 6) + ((unsigned int)fraction << 6)/10 - DVStart;
  1116.         
  1117. ucDV_Delay = (unsigned char)(((unsigned int*)Data)[0] >> 6);
  1119. Data[6] = ((unsigned int*)Data)[0] - (ucDV_Delay << 6);
  1121. Data[6] = (unsigned long)usADC_Clock * Data[6] / 1024;//512;
  1123. RTDSetByte(FS_FT_DELAY_1E, Data[6]);
  1125.        
  1126. }
  1128. void Set_Dclk(unsigned int DispLen)
  1129. {
  1130.     if (Mode_Preset[ucMode_Curr][3])
  1131.     {
  1132.         // Use preset DCLK M/N code
  1133.         Data[0] = 6;
  1134.         Data[1] = Y_INC;
  1135.         Data[2] = DPLL_CTRL_D0;
  1136.         Data[3] = 0x11;
  1137.         Data[4] = (unsigned char)(Mode_Preset[ucMode_Curr][3] >> 8);
  1138.         Data[5] = (unsigned char)Mode_Preset[ucMode_Curr][3];
  1139.         Data[6] = 0;
  1140.         RTDWrite(Data);
  1141.     }
  1142.     else
  1143.     {
  1144.      
  1145. //        if (VGA_Mode[ucMode_Curr][4])
  1146. //        {
  1147. //            ((unsigned int *)Data)[0]   = (unsigned long)8 * usDH_Total * USER_MODE_NCODE * usDispLen 
  1148. //                                        / ((unsigned long)usIPV_ACT_LEN * VGA_Mode[ucMode_Curr][4]);
  1149. //        }
  1150. //        else
  1151. //        {
  1153.             ((unsigned int *)Data)[0]   = (unsigned long)8 * usDH_Total * USER_MODE_NCODE * DispLen 
  1154.                                         / ((unsigned long)usIPV_ACT_LEN * usHsync);
  1155. //        }
  1158.         //Original Formula : DPM/Ich = 17.6 must be constant
  1159. //Ich = DPM * 10 / 176
  1160. //2*Ich = DPM * 20 / 176 , set D0[0] to 0, then I = 2 * Ich
  1161. //I  = 2 * Ich = 2.5u + D0[3]*2.5u + D0[4]*5u + D0[5]*10u + D0[6]*20u + D0[7]*30u(A)
  1162. //2I = 4 * Ich = 5u + D0[3]*5u + D0[4]*10u + D0[5]*20u + D0[6]*40u + D0[7]*60u(A)
  1163.         Data[15] = ((unsigned int *)Data)[0] >> 2;
  1164. Data[5] = (unsigned int)Data[15] * 40 / 176 - 5; //Calculate the 4*Ich,
  1165. Data[6] = 0x00;
  1166. if(Data[5] > 60)
  1167. {
  1168.     Data[5] -= 60;
  1169. Data[6] |= 0x80; 
  1170. }
  1172. if(Data[5] > 40)
  1173. {
  1174.     Data[5] -= 40;
  1175. Data[6] |= 0x40;
  1176. }
  1177.  
  1178.         if(Data[5] > 20)
  1179. {
  1180.     Data[5] -= 20;
  1181. Data[6] |= 0x20;
  1182. }
  1184. if(Data[5] > 10)
  1185. {
  1186.     Data[5] -= 10;
  1187. Data[6] |= 0x10;
  1188. }
  1190. if(Data[5] > 5)
  1191. {
  1192.     Data[5] -= 5;
  1193. Data[6] |= 0x08;
  1194. }
  1197. Data[0] = 7;
  1198. Data[1] = Y_INC;
  1199. Data[2] = DPLL_CTRL_D0;
  1200. Data[3] = Data[6];
  1201. Data[4] = Data[15] - 2;
  1202. Data[5] = 0x10 | (USER_MODE_NCODE - 2);//Offset Frequency Direction set to Downward
  1203. //Data[5] = (USER_MODE_NCODE - 2);//Offset Frequency Direction set to Downward
  1204. Data[6] = 0x04;
  1205. Data[7] = 0;
  1206. RTDWrite(Data);
  1208.  
  1209. //        ucDebug_Value0 = Data[4];
  1210.    //     ucDebug_Value1 = Data[5];
  1211.        
  1212.         //More precise Dclk in KHz
  1213. ((unsigned long*)Data)[0] = (unsigned long)24576000 / usIPV_ACT_LEN * DispLen / usHsync * usDH_Total ;
  1214.         //((unsigned long*)Data)[0] = (unsigned long)49152000 / usIPV_ACT_LEN * usDispLen / usHsync * usDH_Total ;
  1215. //set M/N code Dclk
  1216. ((unsigned long*)Data)[1] = (unsigned long)12288000 * (Data[15] + 1) / USER_MODE_NCODE;
  1217.         //((unsigned long*)Data)[1] = (unsigned long)24576000 * (Data[15] + 1) / USER_MODE_NCODE;
  1218. ((unsigned long*)Data)[2] = ((unsigned long*)Data)[1] - ((unsigned long*)Data)[0]; //Dclk offset
  1219. ((unsigned long*)Data)[3] = ((unsigned long*)Data)[1] >> 15; //Offset resolution equal to (Dclk / 2^15)
  1220.         
  1221. ((unsigned long*)Data)[3] = ((((unsigned long*)Data)[2] << 1)/ ((unsigned long*)Data)[3]) & 0x00000fff; //Calculate the Dclk offset
  1222.         //((unsigned long*)Data)[3] = (((unsigned long*)Data)[2] / ((unsigned long*)Data)[3]) & 0x00000fff; //Calculate the Dclk offset
  1224. RTDSetByte(DCLK_OFFSET_LSB_9A,(unsigned char)((unsigned long*)Data)[3]);  //Set the Dclk offset
  1225. //        ucDebug_Value0 = (unsigned char)(((unsigned long*)Data)[3]);
  1226. //RTDSetBit(DCLK_OFFSET_MSB_9B,0xf0,(unsigned char)(((unsigned long*)Data)[3] >> 8) | 0x20);
  1227. RTDSetBit(DCLK_OFFSET_MSB_9B,0xf0,(unsigned char)(((unsigned long*)Data)[3] >> 8) | 0x20);
  1228. //        ucDebug_Value1 = (unsigned char)((((unsigned long*)Data)[3] >> 8) | 0x20);
  1229.         RTDSetBit(FX_LST_LEN_H_5A,0xff,0x08); //Enable DDS Spread Spectrum Output Function
  1230. RTDSetBit(DPLL_N_D2,0xff,0x20); //DPLL Spread Spectrum Enable
  1231. RTDSetBit(DPLL_FILTER_D3,0x7f,0x00); //Enable DPll output
  1232. }
  1233. }
  1235. void Initial_Mode(void)
  1236. {
  1237.     unsigned char   ucOption;
  1238.     unsigned int    usDispLen;
  1240.     // bit 7 of ucMode_Curr : partial-V display.
  1241.     // bit 6 of ucMode_Curr : select 720x350 or 720x400 for VGA-50Hz and VGA-60Hz
  1242.     ucOption    = ucMode_Curr & 0xc0;
  1243.     ucMode_Curr = ucMode_Curr & 0x3f;
  1245.     
  1246. RTDSetBit(SD_CTRL_70, 0xf9, VGA_ICLK_DELAY);
  1247.     if (SOURCE_DVI == (stGUD1.INPUT_SOURCE & 0x07))
  1248.     {
  1249.         RTDSetBit(SD_CTRL_70, 0xf9, TMDS_ICLK_DELAY);
  1251.         usIPH_ACT_STA   = CAP_WIN[ucMode_Curr][1];
  1252.     }
  1253.     else
  1254.     {
  1256. if (ucOption & 0x40)
  1257. {
  1258. // Only VGA-50Hz and VGA-60Hz mode will set bit 6 of ucMode_Curr to indicate 720-pixel capture width
  1259. // In these case, we should use 720 horizontal settings instead of 640 horizontal settings in table.
  1260. usADC_Clock     = CAP_WIN[MODE_0720x0400x70HZ][0];
  1261. usIPH_ACT_STA   = CAP_WIN[MODE_0720x0400x70HZ][1];
  1262. usIPH_ACT_WID   = CAP_WIN[MODE_0720x0400x70HZ][2];
  1263. }
  1264. else
  1265. {
  1266. usADC_Clock     = CAP_WIN[ucMode_Curr][0];
  1267. usIPH_ACT_STA   = CAP_WIN[ucMode_Curr][1];
  1268. usIPH_ACT_WID   = CAP_WIN[ucMode_Curr][2];
  1270. // Calculate pixel clock rate (round to MHz)
  1271. usDispLen   = (unsigned long)24576 * usADC_Clock / ((unsigned long)usHsync * 500);
  1272. usDispLen   = (usDispLen >> 1) + (usDispLen & 0x01);
  1274. // Use ADC to do H scale-down if pixel clock rate is over spec.
  1275. if (MAX_ADC_FREQ < usDispLen && MODE_USER1152x864 <= ucMode_Curr && MODE_USER1600x1200 >= ucMode_Curr)
  1276. {
  1277. usADC_Clock     = ADC_SD_SET[ucMode_Curr - MODE_USER1152x864][0];
  1278. usIPH_ACT_STA   = ADC_SD_SET[ucMode_Curr - MODE_USER1152x864][1];
  1279. usIPH_ACT_WID   = ADC_SD_SET[ucMode_Curr - MODE_USER1152x864][2];
  1280. }
  1282. } //if (ucOption & 0x40)
  1284. // Calculate pixel clock rate (round to MHz)
  1285. usDispLen   = (unsigned long)24576 * usADC_Clock / ((unsigned long)usHsync * 500);
  1286. usDispLen   = (usDispLen >> 1) + (usDispLen & 0x01);
  1289. // To improve ADC performance ,when the data rate is slow, use single channel,otherwise, use dual channel
  1290. RTDSetBit(ADC_REG_CLK_EA,0xe0,(45 > usDispLen) ? 0x10 | (ADC_RED_PHASE_FT & 0x0c) |( ADC_BLUE_PHASE_FT & 0x03): 
  1291.                                                  0x00 | (ADC_RED_PHASE_FT & 0x0c) |( ADC_BLUE_PHASE_FT & 0x03)); 
  1294. // To imporve the FIFO efficiency only when input data rate is slow, and display data rate is high.
  1295. // RTDSetBit(VGIP_CTRL_04, 0xe3, (40 > usDispLen) ? 0x14 : 0x00);
  1296.     RTDSetBit(VGIP_CTRL_04, 0xf3, (60 > usDispLen) ? 0x08 : 0x00);
  1298. RTDSetByte(PE_CONTROL_3C, 0x00);    // HSYNC positive/negtive tracking
  1300.     RTDSetByte(ADC_FRAME_MODULE_EB,0x06);
  1301. //  RTDSetByte(ADC_FRAME_MODULE_EB,(usIPH_ACT_WID == 1280) ? 0x04 : 0x00);
  1304.   // Set ADC bandwidth to reduce high frequency noise
  1305. //  RTDSetByte(ADC_REG_TEST_E9, (35 > usDispLen) ? 0x08 : (150 > usDispLen) ? 0x10 : 0x18);
  1309. #if(ADC_DEFFERENTIAL)
  1310.     RTDSetBit(ADC_DIFF_MODE_EC,0xff,0x40); //Differential mode
  1311. #else
  1312.     RTDSetBit(ADC_DIFF_MODE_EC,0xbf,0x00); //Single endded mode
  1313. #endif
  1318. RTDSetByte(ADC_REG_CUR_H_E8, 0x0d | (ADC_GREEN_PHASE_FT & 0x30));
  1322.     RTDSetBit(ADC_FRAME_MODULE_EB,0xc7, ((ADC_RED_PHASE_FT & 0x10) << 1) | ((ADC_GREEN_PHASE_FT & 0x40) << 2) 
  1323.                                    |((ADC_BLUE_PHASE_FT & 0x04) << 1));
  1327.     RTDSetBit(TMDS_CORRECTION_FF,0xff,0x04); //Enable the ADC digital filter
  1330.     if(ucMode_Curr < MODE_1024x0768x70HZ)
  1331.      RTDSetByte(ADC_REG_TEST_E9, 0x08);
  1332.     else 
  1333.         RTDSetByte(ADC_REG_TEST_E9, 0x10);
  1336. // Get usIPV_ACT_LEN
  1337. if (MODE_UNDEFINED0 > ucMode_Curr)
  1338. {
  1339. // We've already decided usIPV_ACT_LEN in Detect_VGA_Mode() for undefined SU/SD mode.
  1340. // Only defined modes need to decide usIPV_ACT_LEN here.
  1341. usIPV_ACT_LEN   = CAP_WIN[ucMode_Curr][4];
  1342. }
  1343.     
  1344.     } //if (SOURCE_DVI == (stGUD1.INPUT_SOURCE & 0x07))
  1346.     // Get standard usIPV_ACT_STA 
  1348.     RTDSetByte(IVS_DELAY_8C, PROGRAM_VDELAY);
  1350.     usIPV_ACT_STA   = CAP_WIN[ucMode_Curr][3] - PROGRAM_VDELAY - 1;
  1353.     RTDSetByte(IHS_DELAY_8D, PROGRAM_HDELAY);
  1355. //    usIPH_ACT_STA   = usIPH_ACT_STA + CAPTURE_HDELAY - PROGRAM_HDELAY;
  1356.     if(ucMode_Curr < MODE_0800x0600x75HZ)
  1357. Data[0] = 2;
  1358.     else if(ucMode_Curr < MODE_1280x1024x75HZ)
  1359. Data[0] = 5;
  1360.     else
  1361. Data[0] = 3;
  1363. //    Data[0] = 5;
  1364.     usIPH_ACT_STA   = usIPH_ACT_STA + Data[0] - PROGRAM_HDELAY;
  1366.     // Decide display length (height) and store to usDispLen
  1368.     usDispLen   = Mode_Preset[ucMode_Curr][2];
  1370.     if (MODE_UNDEFINED0 == ucMode_Curr)         // partical-screen scale-up mode
  1371.     {
  1372.         if (ucOption & 0x80)    // partial-V
  1373.         {           
  1374. if (MIN_DV_TOTAL > (usVsync - 1))
  1375.                 usDispLen   = (unsigned long)usIPV_ACT_LEN * MIN_DV_TOTAL / (usVsync - 1);
  1376.             else
  1377.                 usDispLen   = usIPV_ACT_LEN;    // No V scale-up
  1378.         }
  1379.     }
  1380.     else if (MODE_UNDEFINED1 == ucMode_Curr)    // partial-screen scale-down mode
  1381.     {
  1382.         if (ucOption & 0x80)    // partial-V
  1383.         {
  1384.             usDispLen   = (unsigned long)usIPV_ACT_LEN * MIN_DV_TOTAL / (usVsync - 1);
  1385.         }
  1386.     } //if (MODE_UNDEFINED0 == ucMode_Curr)         // partical-screen scale-up mode
  1388.     if (Mode_Preset[ucMode_Curr][2] < usDispLen)    usDispLen   = Mode_Preset[ucMode_Curr][2];
  1390.     // This F/W do not support V scale-up(or bypass) and H scale-down simultaneously
  1391.     if (usDispLen >= usIPV_ACT_LEN && Mode_Preset[ucMode_Curr][1] < usIPH_ACT_WID)
  1392.     {
  1393.         usIPH_ACT_WID   = Mode_Preset[ucMode_Curr][1];
  1394.     }
  1396.     if (usDispLen > usIPV_ACT_LEN)                      ucOption    |= 0x01;    // bit 0 : V scale-up
  1397.     if (usDispLen < usIPV_ACT_LEN)                      ucOption    |= 0x02;    // bit 1 : V scale-down
  1398.     if (Mode_Preset[ucMode_Curr][1] > usIPH_ACT_WID)    ucOption    |= 0x04;    // bit 2 : H scale-up
  1399.     if (Mode_Preset[ucMode_Curr][1] < usIPH_ACT_WID)    ucOption    |= 0x08;    // bit 3 : H scale-down
  1401.     // Set capture window
  1402.     Data[0]     = 11;
  1403.     Data[1]     = Y_INC;
  1404.     Data[2]     = IPH_ACT_STA_06;
  1405.     Data[3]     = (unsigned char)usIPH_ACT_STA;
  1406.     Data[4]     = (unsigned char)(usIPH_ACT_STA >> 8);
  1407.     Data[5]     = (unsigned char)usIPH_ACT_WID;
  1408.     Data[6]     = (unsigned char)(usIPH_ACT_WID >> 8);
  1409.     Data[7]     = (unsigned char)usIPV_ACT_STA;
  1410.     Data[8]     = (unsigned char)(usIPV_ACT_STA >> 8);
  1411.     Data[9]     = (unsigned char)usIPV_ACT_LEN;
  1412.     Data[10]    = (unsigned char)(usIPV_ACT_LEN >> 8);
  1413.     Data[11]    = 0;
  1414.     RTDWrite(Data);
  1416.     // Set window size before scale-up
  1417.     Data[0] = 7;
  1418.     Data[1] = Y_INC;
  1419.     Data[2] = DRW_BSU_40;
  1421.     if (ucOption & 0x08)
  1422.     {
  1423.         // H scale-down
  1424.         Data[3] = (unsigned char)Mode_Preset[ucMode_Curr][1];
  1425.         Data[4] = (unsigned char)(Mode_Preset[ucMode_Curr][1] >> 8);
  1426.     }
  1427.     else
  1428.     {
  1429.         // No H scale-down
  1430.         Data[3] = Data[5];  // (unsigned char)usIPH_ACT_WID;
  1431.         Data[4] = Data[6];  // (unsigned char)(usIPH_ACT_WID >> 8);
  1432.     }
  1434.     if (ucOption & 0x02)
  1435.     {
  1436.         // V scale-down
  1437.         Data[5] = (unsigned char)usDispLen;
  1438.         Data[6] = (unsigned char)(usDispLen >> 8);
  1439.     }
  1440.     else
  1441.     {
  1442.         // No V scale-down
  1443.         Data[5] = Data[9];  // (unsigned char)usIPV_ACT_LEN;
  1444.         Data[6] = Data[10]; // (unsigned char)(usIPV_ACT_LEN >> 8);
  1445.     }
  1446.     Data[7] = 0;
  1447.     RTDWrite(Data);
  1449.     // Config scaling
  1450.     if (ucOption & 0x0a)
  1451.         RTDSetBit(SD_CTRL_70, 0xff, 0x01);      // Turn on scale-down
  1452.     else
  1453.         RTDSetBit(SD_CTRL_70, 0xfe, 0x00);      // Turn off scale-down
  1455.     if (ucOption & 0x01)
  1456.         RTDSetBit(SCALE_CTRL_15, 0xff, 0x02);   // Turn on V scale-up
  1457.     else
  1458.         RTDSetBit(SCALE_CTRL_15, 0xfd, 0x00);   // Turn off V scale-up
  1460.     if (ucOption & 0x04)
  1461.         RTDSetBit(SCALE_CTRL_15, 0xff, 0x01);   // Turn on H scale-up
  1462.     else
  1463.         RTDSetBit(SCALE_CTRL_15, 0xfe, 0x00);   // Turn off H scale-up
  1465.     // Set scale-down coefficient
  1466.     Data[0] = 7;
  1467.     Data[1] = Y_INC;
  1468.     Data[2] = H_SCALE_DL_71;
  1470.     if (ucOption & 0x08)    // H scale-down
  1471.     {
  1472.         // Data[12~15]
  1473.         ((unsigned long *)Data)[3]  = (unsigned long)256 * 4096 * usIPH_ACT_WID / Mode_Preset[ucMode_Curr][1];
  1475.         // Data[4~5]
  1476.         ((unsigned int *)Data)[2]   = (((unsigned long *)Data)[3] >> 8) + 2;
  1478.         // H scale-down factor is stored in Data[4] (high-byte) and Data[5] (low-byte)
  1479.         Data[3] = Data[5];
  1481.         RTDSetBit(VGIP_CTRL_04, 0xff, 0x40);    // Enable H scale-down compensation
  1482.     }
  1483.     else
  1484.     {
  1485.         Data[3] = 0x00;
  1486.         Data[4] = 0x10;
  1488.         RTDSetBit(VGIP_CTRL_04, 0xbf, 0x00);    // Diable H scale-down compensation
  1489.     }
  1491.     if (ucOption & 0x02)    // V scale-down
  1492.     {
  1493.         // Data[12~15]
  1494.         ((unsigned long *)Data)[3]  = (unsigned long)256 * 4096 * usIPV_ACT_LEN / usDispLen;
  1496.         // Data[6~7]
  1497.         ((unsigned int *)Data)[3]   = (((unsigned long *)Data)[3] >> 8);
  1499.         if (0 == Data[15])      ((unsigned int *)Data)[3]   = ((unsigned int *)Data)[3] - 1;
  1501.         // V scale-down factor is stored in Data[6] (high-byte) and Data[7] (low-byte)
  1502.         Data[5] = Data[7];
  1504.         RTDSetBit(VGIP_CTRL_04, 0xff, 0x80);    // Enable V scale-down compensation
  1505.     }
  1506.     else
  1507.     {
  1508.         Data[5] = 0x00;
  1509.         Data[6] = 0x10;
  1511.         RTDSetBit(VGIP_CTRL_04, 0x7f, 0x00);    // Diable V scale-down compensation
  1512.     }
  1513.     Data[7] = 0;
  1514.     RTDWrite(Data);
  1516.     // Set scale-up coefficient
  1517.     Data[0] = 8;
  1518.     Data[1] = Y_INC;
  1519.     Data[2] = HOR_SCA_16;
  1521.     if (ucOption & 0x04)    // H scale-up
  1522.     {
  1523.         // Data[12~15]
  1524.         ((unsigned long *)Data)[3]  = (unsigned long)2 * 262144 * usIPH_ACT_WID / Mode_Preset[ucMode_Curr][1];
  1525.         ((unsigned long *)Data)[3]  = ((((unsigned long *)Data)[3] >> 1) + (((unsigned long *)Data)[3] & 0x01)) << 6;
  1527.         Data[3] = Data[14];
  1528.         Data[4] = Data[13];
  1529.         Data[7] = Data[15];
  1530.     }
  1531.     else
  1532.     {
  1533.         Data[3] = 0xff;
  1534.         Data[4] = 0xff;
  1535.         Data[7] = 0;
  1536.     }
  1538.     if (ucOption & 0x01)    // V scale-up
  1539.     {
  1540.         // Data[12~15]
  1541.         ((unsigned long *)Data)[3]  = (unsigned long)2 * 262144 * usIPV_ACT_LEN / usDispLen;
  1542.         ((unsigned long *)Data)[3]  = ((((unsigned long *)Data)[3] >> 1) + (((unsigned long *)Data)[3] & 0x01)) << 6;
  1544.         Data[5] = Data[14]; //anson 05_0315
  1545. //        Data[5] = 0x90;
  1546.         Data[6] = Data[13];
  1547. //        Data[6] = 0xc0;
  1548.         Data[7] = Data[7] | (Data[15] >> 4);
  1549.     }
  1550.     else
  1551.     {
  1552.         Data[5] = 0xff;
  1553.         Data[6] = 0xff;
  1554.     }
  1555.     Data[8] = 0;
  1556.     RTDWrite(Data);
  1558.     // Set RTD display
  1560.     // Switch to FrameSync 1 mode and diable display
  1561.     RTDSetByte(VDIS_CTRL_20, 0x28 | DISP_BIT | DISPLAY_PORT);
  1563.     Data[0]     = 5;
  1564.     Data[1]     = Y_INC;
  1566. #if (DISP_ALIGN)
  1568.     Data[2]     = DH_ACT_STA_27;
  1570.     // DH_ACT_STA store in Data[4~5] (H~L)
  1571.     ((unsigned int *)Data)[2]   = (unsigned int)DH_ACT_END_POS - Mode_Preset[ucMode_Curr][1];
  1573.     Data[3]     = Data[5];
  1575. #else
  1577.     Data[2]     = DH_ACT_END_29;
  1579.     // DH_ACT_STA store in Data[4~5] (H~L)
  1580.     ((unsigned int *)Data)[2]   = (unsigned int)DH_ACT_STA_POS + Mode_Preset[ucMode_Curr][1];
  1582.     Data[3]     = Data[5];
  1584. #endif
  1586.     Data[5]     = 5;
  1587.     Data[6]     = Y_INC;
  1588.     Data[7]     = DV_ACT_END_34;
  1590.     // DV_ACT_END store in Data[10~11] (H~L)
  1591.     ((unsigned int *)Data)[5]   = (unsigned int)DV_ACT_STA_POS + usDispLen;
  1593.     Data[8]     = Data[11];
  1594.     Data[9]     = Data[10];
  1595.     Data[10]    = 0;
  1596.     RTDWrite(Data);
  1598.     // Get standard DH_TOTAL
  1599.     usDH_Total  = Mode_Preset[ucMode_Curr][0];
  1601.     // Switch to FrameSync 1 mode and enable display
  1602. //    if (PANEL_OFF == bPANEL_PWR)
  1603.     if (_OFF == bPanel_Status)
  1604.         RTDSetByte(VDIS_CTRL_20, 0x29 | DISP_BIT | DISPLAY_PORT);
  1605.     else
  1606.         RTDSetByte(VDIS_CTRL_20, 0x2b | DISP_BIT | DISPLAY_PORT);
  1608. Set_Dclk(usDispLen);
  1609.    
  1610.     //usDH_Total  = usDH_Total - 2;
  1612.     // Set DH_TOTAL
  1613.     Data[0] = 5;
  1614.     Data[1] = Y_INC;
  1615.     Data[2] = DH_TOTAL_22;
  1616.     Data[3] = (unsigned char)(usDH_Total - 2);
  1617.     Data[4] = (unsigned char)((usDH_Total - 2) >> 8);
  1618.     Data[5] = 0;
  1619.     RTDWrite(Data);
  1623.     //Calculate DV_TOTAL
  1624. if((ucOption & 0x01) || (ucOption & 0x02))    // V scale up or scale down
  1625. {
  1627. #if(DISP_SIZE == DISP_800x600)
  1628. usDV_Total = (unsigned long)usVsync * 600 / (unsigned long)usIPV_ACT_LEN + 64;
  1629. #endif
  1631. #if(DISP_SIZE == DISP_1024x768)
  1632. usDV_Total = (unsigned long)usVsync * 768 / (unsigned long)usIPV_ACT_LEN + 64;
  1633. #endif
  1635. #if(DISP_SIZE == DISP_1280x1024)
  1637. usDV_Total = (unsigned long)usVsync * 1024 / (unsigned long)usIPV_ACT_LEN + 64;
  1638. #endif
  1641. }
  1642. else
  1643. usDV_Total = usVsync + 64;
  1645.     //Set DV_TOTAL
  1646. Data[0] = 5;
  1647. Data[1] = Y_INC;
  1648. Data[2] = DV_TOTAL_2D;
  1649. Data[3] = (unsigned char)usDV_Total;
  1650. Data[4] = (unsigned char)((usDV_Total >> 8) & 0x07);
  1651. Data[5] = 0;
  1652. RTDWrite(Data);
  1657.     // Calculate suitable IVS to DVS delay
  1658.     // CR[38] : IVS to DVS delay in IHS lines
  1659.     // CR[1E] : IVS to DVS delay in ICLK * 16
  1660.     //((unsigned int *)Data)[0]   = (unsigned long)64 * DV_ACT_STA_POS * usIPV_ACT_LEN / usDispLen;
  1661. ((unsigned int *)Data)[0]   = (unsigned long)64 * DV_ACT_STA_POS * usIPV_ACT_LEN / usDispLen;
  1663.     if (ucOption & 0x01)
  1664.     {
  1665.     Calculate_IVS2DVS_Delay(2,5,((unsigned int*)Data)[0]);  // V scale-up. Target 2.5~2.6 IHS delay
  1667.     }
  1668.     else
  1669.     {
  1670. #if (FULL_LINE_BUFFER)
  1671.         Calculate_IVS2DVS_Delay(3,8,((unsigned int*)Data)[0]);  // V no scale-up. Target 3.8~4.0 IHS delay
  1672. #else
  1673.         if (ucOption & 0x02)
  1674.         {
  1675.     // V scale-down            
  1676.     Calculate_IVS2DVS_Delay(2,6,((unsigned int*)Data)[0]);   // V scale-down. Target 2.5~2.6 IHS delay
  1677. }
  1678.         else
  1679.         {
  1681.             Calculate_IVS2DVS_Delay(1,9,((unsigned int*)Data)[0]);                  // V no scale-up. Target 1.9 IHS delay
  1682.         }
  1684. #endif
  1685.     }
  1687. #if (FULL_LINE_BUFFER)
  1688.     // Turn on full-line buffer when no V scale-up
  1689.     RTDSetBit(OP_CRC_CTRL_68, 0xfc, (ucOption & 0x01) ? 0x00 : 0x02);
  1690. #else
  1691.     RTDSetBit(OP_CRC_CTRL_68, 0xfc, 0x00);
  1692. #endif
  1694.     // Set ucDV_Delay
  1695.     RTDSetByte(IV_DV_LINES_38, ucDV_Delay);
  1697. RTDSetByte(STATUS0_01, 0x00);  // Clear status
  1698.     RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  1700.     // Switch to FrameSync 1 mode and enable display
  1701. //    if (PANEL_OFF == bPANEL_PWR)
  1702. //        RTDSetByte(VDIS_CTRL_20, 0x29 | DISP_BIT | DISPLAY_PORT);
  1703. //    else
  1704. //        RTDSetByte(VDIS_CTRL_20, 0x2b | DISP_BIT | DISPLAY_PORT);
  1706.     // Input Run Enable
  1707.     RTDSetBit(VGIP_CTRL_04, 0xff, 0x01);
  1709. }
  1711. void Display_VGA_Set(void)
  1712. {
  1713.     unsigned char   Wait_Time_Cnt;
  1714. // unsigned char   ucI_Corr0,ucI_Corr1;
  1717.     Initial_Mode();
  1718. Sharpness();
  1720.     if((usIPH_ACT_WID == 1280) && (DISP_SIZE == DISP_1280x1024) && (stGUD1.FILTER == 0x02))
  1721.          RTDSetBit(SCALE_CTRL_15, 0xff, 0x01);   // Turn on H scale-up
  1722.     
  1724.     PowerDown_ADC();
  1725.     //Device_Power(ADC_POWER,OFF);
  1727.     // Set user's ADC gain and offset settings
  1728.     SetADC_GainOffset();
  1730.     Set_Gamma();
  1731.     Set_Dithering();
  1732.     Set_Bright_Contrast();
  1733. //    Sharpness();
  1735.     Load_MUD(ucMode_Curr);      // Read mode default settings from 24C04
  1737.     // For jitter adjust
  1738.     ucPE_Level      = 0;
  1739. //    ucPE_Count      = 0;
  1741.     // Check Clock
  1742.     if (28 > stMUD.CLOCK || 228 < stMUD.CLOCK)      stMUD.CLOCK = 128;
  1744.     
  1745.     // Update Clock Twice
  1746.     Set_Clock();
  1747. // Calculate the P correction and I correction according to the CE value
  1748.     Delay_Xms(6);
  1750.     if(ucCE_Value ==  0)
  1751.     {
  1752.        RTDRead(I_CODE_MB_CA,1,N_INC);
  1753.    RTDSetByte(I_CODE_MB_CA, 0x0d);
  1754.    Delay_Xms(4);
  1755.    RTDRead(PLL_CALIBRATION_CE,1,N_INC);
  1756.    ucP_Corr = (unsigned char)((unsigned int)(Data[0] * 200) >> (29 - P_Code));
  1757.    ucCE_Value = Data[0];  //CE value  
  1759. }
  1761. if(ucI_Code == 0)
  1762.    Adjust_I_Code();
  1763.     
  1765.     Set_Clock();
  1768.     // Check Phase
  1769. //    stMUD.PHASE &= 0x7c;    // Phase 0~31
  1771.     // Update Phase
  1772. //    Set_Phase(stMUD.PHASE);
  1774.     ucH_Max_Margin  = 128 + 50;
  1775.     ucH_Min_Margin  = 128 - 50;
  1777. //Read the usIPH_ACT_STA offset
  1778.     I2CRead(ADDR_EROM1,(ucMode_Curr - 1),0x01);
  1779. if(Data[0] > 228)
  1780.    Data[0] = 0;
  1782.     usIPH_ACT_STA   = (Data[0] & 0x80) ? usIPH_ACT_STA - 50 - (Data[0] - 0x80) : usIPH_ACT_STA + Data[0] - 50;
  1783.         
  1784.     Data[0] = 5;
  1785.     Data[1] = Y_INC;
  1786.     Data[2] = IPH_ACT_STA_06;
  1787.     Data[3] = (unsigned char)usIPH_ACT_STA;
  1788.     Data[4] = (unsigned char)(usIPH_ACT_STA >> 8);
  1789.     Data[5] = 0;    
  1790.     RTDWrite(Data);
  1792.     // Check H-Position
  1793.     if (ucH_Max_Margin < stMUD.H_POSITION)
  1794.         stMUD.H_POSITION    = ucH_Max_Margin;
  1795.     else if (ucH_Min_Margin > stMUD.H_POSITION)
  1796.         stMUD.H_POSITION    = ucH_Min_Margin;
  1798.     // Update H-Position
  1799.     Set_H_Position();
  1801.        // Check Phase
  1802.     stMUD.PHASE &= 0x7c;    // Phase 0~31
  1804.     // Update Phase
  1805.     Set_Phase(stMUD.PHASE);
  1807.     // Start auto-tracking function once
  1808.     RTDSetByte(AUTO_ADJ_CTRL_7F, 0x01);
  1809.     Delay_Xms(40);
  1811.     // Force to stop auto-tracking function
  1812.     RTDSetByte(AUTO_ADJ_CTRL_7F, 0x00);
  1813.     Delay_Xms(40);
  1815.     // Measure actual number of scan line in each frame
  1816.     Data[0]     = 14;
  1817.     Data[1]     = Y_INC;
  1818.     Data[2]     = H_BND_STA_L_75;
  1819.     Data[3]     = 0x00;
  1820.     Data[4]     = 0xff;
  1821.     Data[5]     = 0x07;
  1822.     Data[6]     = 0x00;
  1823.     Data[7]     = 0x00;
  1824.     Data[8]     = 0x00;
  1825.     Data[9]     = 0x00;
  1826.     Data[10]    = 0x00;
  1827.     Data[11]    = 0x00;
  1828.     Data[12]    = 0x00;
  1829.     Data[13]    = 0x01;
  1830.     Data[14]    = 0;
  1831.     RTDWrite(Data);
  1833.     Wait_Time_Cnt  = 60;    // Tracking timeout 60ms        
  1834.     do
  1835.     {   
  1836.         Delay_Xms(1);
  1837.         RTDRead(AUTO_ADJ_CTRL_7F, 0x01, N_INC);
  1838.     }
  1839.     while ((Data[0] & 0x01) && (--Wait_Time_Cnt));
  1841.     RTDSetByte(AUTO_ADJ_CTRL_7F, 0x00);
  1842.     
  1843.     if (Wait_Time_Cnt)
  1844.     {
  1845.         RTDRead(VER_START_80, 0x04, Y_INC);
  1846.         Data[0] = Data[3] & 0x0f;
  1847.         Data[1] = Data[2];
  1849.         usVer_End   = (usVsync < ((unsigned int *)Data)[0]) ? ((unsigned int *)Data)[0] : usVsync;
  1850.     }
  1851.     else
  1852.     {
  1853.         usVer_End   = usVsync;
  1854.     }
  1856.     // Update to reasonable usIPV_ACT_STA for user mode
  1857.     if (MODE_USER720x400 <= ucMode_Curr)
  1858.     {
  1859.         ((unsigned int *)Data)[0]   = usVer_End - VGA_Mode[ucMode_Curr][2];
  1861.         if (254 < ((unsigned int *)Data)[0] + ucDV_Delay)   ((unsigned int *)Data)[0]   = 254 - ucDV_Delay;
  1863.         usIPV_ACT_STA   += ((unsigned int *)Data)[0];
  1864.         ucDV_Delay      += ((unsigned int *)Data)[0];
  1865.     }
  1867.     // Set the ucV_Min_Margin/ucV_Max_Margin
  1868.     ucV_Min_Margin  = (128 < usIPV_ACT_STA) ? 0 : 128 - usIPV_ACT_STA + 1;
  1870.     if ((128 - 50) > ucV_Min_Margin)    ucV_Min_Margin  = 128 - 50;
  1872.     ((unsigned int *)Data)[0]   = (usVer_End + 128 - 2) - (usIPV_ACT_STA + usIPV_ACT_LEN);
  1874.     ucV_Max_Margin  = (((unsigned int *)Data)[0] > 0x00ff) ? 0xff : ((unsigned int *)Data)[0];
  1876.     // Check ucV_Min_Margin/ucV_Max_Margin :
  1877.     // ucDV_Delay can only range from 0 to 254
  1878.     // Original Formula :
  1879.     // 128 - ucV_Min_Margin >= ucDV_Delay
  1880.     // ucV_Max_Margin - 128 >= 254 - ucDV_Delay
  1882.     if ((unsigned int)128 > ((unsigned int)ucV_Min_Margin + ucDV_Delay))    ucV_Min_Margin  = 128 - ucDV_Delay;
  1883.     if ((unsigned int)382 < ((unsigned int)ucV_Max_Margin + ucDV_Delay))    ucV_Max_Margin  = 382 - ucDV_Delay;
  1885.     if ((128 + 50) < ucV_Max_Margin)    ucV_Max_Margin  = 128 + 50;
  1887.     // Check V-Position
  1888.     if (ucV_Min_Margin > stMUD.V_POSITION)
  1889.         stMUD.V_POSITION    = ucV_Min_Margin;
  1890.     else if ((unsigned int)256 - ucV_Min_Margin < stMUD.V_POSITION)
  1891.         stMUD.V_POSITION    = (unsigned int)256 - ucV_Min_Margin;
  1893.     // Update V-Position
  1894.     Set_V_Position();
  1896.     // Re-calculate actual refresh rate
  1897.     ((unsigned long *)Data)[0]  = (unsigned long)usHsync * usVer_End;
  1898.     ucRefresh   = (unsigned long)49152000 / ((unsigned long *)Data)[0];
  1899.     ucRefresh   = (ucRefresh & 0x01) ? ((ucRefresh + 1) >> 1) : (ucRefresh >> 1);
  1900.     
  1901. if(ucRefresh > V_OVERSPEC_FREQ)
  1902.     bOverSpec = _TRUE;
  1904. if((unsigned int)24576/usHsync > H_OVERSPEC_FREQ)
  1905.     bOverSpec = _TRUE;
  1907.     Data[0] = Frame_Sync();
  1909.     if (1 == Data[0])
  1910.     {
  1911.        Delay_Xms(10);
  1912.        Data[0] = Frame_Sync();     // Fail. Try again       
  1913.     }
  1915.     bFrameSync      = Data[0] ? 0 : 1;              // 0 : fail, 1 : pass
  1916.     ucSyncErrorCnt  = 0;
  1918.     RTDSetBit(OVL_CTRL_6D,0x3f,0x00);
  1919.     RTDSetByte(BGCOLOR_CONTROL_6C,0x00);
  1920. RTDSetBit(OVL_CTRL_6D,0x3f,0x40);
  1921.     RTDSetByte(BGCOLOR_CONTROL_6C,0x00);
  1922. RTDSetBit(OVL_CTRL_6D,0x3f,0x80);
  1923.     RTDSetByte(BGCOLOR_CONTROL_6C,0x00);
  1925. //    RTDSetBit(VDIS_CTRL_20, 0x5f, DHS_MASK);        // Normal display
  1926.       RTDSetBit(VDIS_CTRL_20, 0x7f, 0x20 | DHS_MASK);        // Normal display
  1928. #if(AS_PLL_NONLOCK)
  1929.    if(bFrameSync)
  1930.         RTDSetBit(ODD_CTRL_8E,0xdf,0x20);
  1931. #endif
  1933.     //anson 05_0314
  1934.     ucfrist = (ucMode_Curr - 1 ) / 8 ;
  1935.     I2CRead(ADDR_EROM1, ucfrist , 1);
  1936.     ucfrist = ucMode_Curr - (ucfrist*8) ;
  1937.     ucfrist  = Data[0] >> (ucfrist-1) ;
  1938.     ucfrist  = ucfrist & 0x01;
  1939.     stGUD1.OSD_INPUT = stGUD1.OSD_INPUT | 0x20; //First Time Into This Mode
  1942. }
  1944. void Display_DVI_Set(void)
  1945. {
  1946. #if(TMDS_ENABLE)
  1947.     unsigned char   Wait_Time_Cnt;
  1949.     Initial_Mode();
  1951.     // Set the ucV_Min_Margin/ucV_Max_Margin
  1952.     ucV_Min_Margin  = (128 < usIPV_ACT_STA) ? 0 : 128 - usIPV_ACT_STA + 1;
  1954.     // Use Data[8],Data[9] as a temporary 16-bit variable.
  1955.     ((unsigned int *)Data)[4]   = (usVsync + 128 - 2) - (usIPV_ACT_STA + usIPV_ACT_LEN);
  1957.     ucV_Max_Margin  = (0x00ff <  ((unsigned int *)Data)[4]) ? 0xff :  ((unsigned int *)Data)[4];
  1959.     // Check ucV_Min_Margin/ucV_Max_Margin :
  1960.     // ucDV_Delay can only range from 0 to 254
  1961.     // Original Formula :
  1962.     // 128 - ucV_Min_Margin <= ucDV_Delay
  1963.     // ucV_Max_Margin - 128 <= 254 - ucDV_Delay
  1965.     if ((unsigned int)128 > ((unsigned int)ucV_Min_Margin + ucDV_Delay))    ucV_Min_Margin  = 128 - ucDV_Delay;
  1966.     if ((unsigned int)382 < ((unsigned int)ucV_Max_Margin + ucDV_Delay))    ucV_Max_Margin  = 382 - ucDV_Delay;
  1968.     // Read mode default settings from 24C04
  1969.     Load_MUD(ucMode_Curr);
  1971.     Set_Gamma();
  1972.     Set_Dithering();
  1973.     Set_Bright_Contrast();
  1974.     Sharpness();
  1976.     // Issac :
  1977.     // RTD controller can support both digital mode and analog mode to capture input image data.
  1978.     // In digital mode, input image data is captured according to input data enable (IDEN) signal;
  1979.     // In analog mode, input image data is captured according to capture window settings;
  1980.     // Although can support both of them, I always use analog mode to capture input image in this F/W.
  1981.     // Because RTD controller can measure the position and size of IDEN signal, we can just set our
  1982.     // capture window to be the same size and position as IDEN.
  1984.     Data[0]     = 14;
  1985.     Data[1]     = Y_INC;
  1986.     Data[2]     = H_BND_STA_L_75;
  1987.     Data[3]     = 0x02;
  1988.     Data[4]     = usADC_Clock - 2;
  1989.     Data[5]     = (usADC_Clock - 2) >> 8;
  1990.     Data[6]     = 0x02;
  1991.     Data[7]     = usVsync - 2;
  1992.     Data[8]     = (usVsync - 2) >> 8;
  1993.     Data[9]     = 0;
  1994.     Data[10]    = 0;
  1995.     Data[11]    = 0;
  1996.     Data[12]    = 0;
  1997.     Data[13]    = 0x81;     // Measure IDEN position
  1998.     Data[14]    = 0;
  2001.     RTDWrite(Data);
  2003.     Wait_Time_Cnt  = 60;    // Tracking timeout 60ms        
  2004.     do
  2005.     {   
  2006.         Delay_Xms(1);
  2007.         RTDRead(AUTO_ADJ_CTRL_7F, 0x01, N_INC);
  2008.     }
  2009.     while ((Data[0] & 0x01) && (--Wait_Time_Cnt));
  2010.     
  2011.     if (0 == Wait_Time_Cnt)
  2012.     {
  2013.         RTDSetByte(AUTO_ADJ_CTRL_7F, 0x00);
  2014.         Reset_Mode();
  2015.     }
  2016.     else
  2017.     {
  2018.         // Read IDEN position information
  2019.         RTDRead(VER_START_80, 0x08, Y_INC);
  2020.         
  2021.         // IDEN horizontal Start
  2022.         usIPH_ACT_STA   = (unsigned int)Data[4] + ((unsigned int)Data[5] << 8) - 2;
  2024.         // IDEN vertical Start
  2025.         ((unsigned int *)Data)[0]   = (unsigned int)Data[0] + ((unsigned int)Data[1] << 8) - 1;
  2027.         if (((unsigned int *)Data)[0] > (usIPV_ACT_STA + ucV_Max_Margin - 0x80))
  2028.         {
  2029.             ((unsigned int *)Data)[1]   = (usVsync + 128 - 2) - (usIPV_ACT_STA + usIPV_ACT_LEN);    // Actual V max. Margin
  2031.             ucDV_Delay      = (unsigned char)((unsigned int)ucDV_Delay + ucV_Max_Margin - 0x80);
  2032.             usIPV_ACT_STA   = usIPV_ACT_STA + ucV_Max_Margin - 0x80;
  2034.             if (ucV_Max_Margin < ((unsigned int *)Data)[1])
  2035.             {
  2036.                 // We have to increase IVS delay to fix ucV_Max_Margin
  2037.                 if ((((unsigned int *)Data)[1] - ucV_Max_Margin) >= (((unsigned int *)Data)[0] - usIPV_ACT_STA))
  2038.                     ((unsigned int *)Data)[1]   = ((unsigned int *)Data)[0] - usIPV_ACT_STA + PROGRAM_VDELAY;
  2039.                 else
  2040.                     ((unsigned int *)Data)[1]   = usIPV_ACT_STA + ((unsigned int *)Data)[1] - ucV_Max_Margin + PROGRAM_VDELAY;
  2042.                 if (126 < ((unsigned int *)Data)[1])    ((unsigned int *)Data)[1]  = 126;
  2044.                 RTDSetByte(IVS_DELAY_8C, 0x80 | ((unsigned int *)Data)[1]);
  2045.             }
  2046.         }
  2047.         else if (((unsigned int *)Data)[0] < (usIPV_ACT_STA + ucV_Min_Margin - 0x80))
  2048.         {
  2049.             ucDV_Delay      = (unsigned char)((unsigned int)ucDV_Delay + ucV_Min_Margin - 0x80);
  2050.             usIPV_ACT_STA   = usIPV_ACT_STA + ucV_Min_Margin - 0x80;
  2052.             ((unsigned int *)Data)[1]   = usIPV_ACT_STA - ((unsigned int *)Data)[0];
  2054.             // We have to decrease IVS delay to fix ucV_Min_Margin
  2055.             if (PROGRAM_VDELAY <= ((unsigned int *)Data)[1])
  2056.                 RTDSetByte(IVS_DELAY_8C, 0x00);
  2057.             else
  2058.                 RTDSetByte(IVS_DELAY_8C, 0x80 | (PROGRAM_VDELAY - ((unsigned int *)Data)[1]));
  2059.         }
  2060.         else
  2061.         {
  2062.             ucDV_Delay      = ((unsigned int *)Data)[0] + ucDV_Delay - usIPV_ACT_STA ;
  2063.             usIPV_ACT_STA   = ((unsigned int *)Data)[0];
  2064.         }
  2066. RTDRead(TMDS_CORRECTION_FF,0x01,N_INC);
  2068. if(Data[0] & 0x03)
  2069.     usIPH_ACT_STA -= 14;//if TMDS error correction enable, then compensate the IPH_ACT_STA offset.
  2071.         Data[0]     = 5;
  2072.         Data[1]     = Y_INC;
  2073.         Data[2]     = IPH_ACT_STA_06;
  2074.         Data[3]     = (unsigned char)(usIPH_ACT_STA & 0x00ff);
  2075.         Data[4]     = (unsigned char)((usIPH_ACT_STA >> 8) & 0x00ff);
  2076.         Data[5]     = 5;
  2077.         Data[6]     = Y_INC;
  2078.         Data[7]     = IPV_ACT_STA_0A;
  2079.         Data[8]     = (unsigned char)(usIPV_ACT_STA & 0x00ff);
  2080.         Data[9]     = (unsigned char)((usIPV_ACT_STA >> 8) & 0x00ff);
  2081.         Data[10]    = 4;
  2082.         Data[11]    = N_INC;
  2083.         Data[12]    = IV_DV_LINES_38;
  2084.         Data[13]    = ucDV_Delay;
  2085.         Data[14]    = 0;
  2086.         RTDWrite(Data);
  2088.         Wait_For_Event(EVENT_DVS);
  2090.         Data[0] = Frame_Sync();
  2091.         
  2092.         if (1 == Data[0])   Data[0] = Frame_Sync();     // Fail. Try again
  2094.         bFrameSync      = Data[0] ? 0 : 1;              // 0 : fail, 1 : pass
  2095.         ucSyncErrorCnt  = 0;
  2097.         //RTDSetBit(VDIS_CTRL_20, 0x5f, DHS_MASK);        // Normal display
  2098. RTDSetBit(VDIS_CTRL_20, 0x7f, 0x20 | DHS_MASK);        // Normal display
  2099.     }
  2100. #else
  2101.     Seek_DVI_Mode(0);
  2102. #endif
  2103. }
  2105. void Set_Video_Mode(void)
  2106. {
  2107. #if(VIDEO_CHIP != VDC_NONE)
  2109. #if (VIDEO_CHIP == VDC_SAA7114 || VIDEO_CHIP == VDC_SAA7115 || VIDEO_CHIP == VDC_SAA7118)
  2110.     I2CWrite(V_DISABLE);
  2111.     I2CWrite(VIDEO_ALL);
  2112.     I2CWrite((ucAV_Mode & 0x02) ? VIDEO_50 : VIDEO_60);
  2113. #endif
  2115.     RTDCodeW((ucAV_Mode & 0x02) ? RTD_VIDEO_50 : RTD_VIDEO_60);
  2117. //    if (PANEL_OFF == MCU_ReadPanelPower())
  2118.     if (OFF == bPanel_Status)
  2119.     {
  2121.         RTDSetByte(VDIS_SIGINV_21, 0x00 | DISP_EO_SWAP | DISP_RB_SWAP | DISP_ML_SWAP);       // DHS, DVS, DEN, DCLK MUST NOT be inverted.
  2123.         RTDSetBit(VDIS_CTRL_20, 0xfd, 0x01);    // DHS, DVS, DEN, DCLK and data are clamped to 0
  2124.     }
  2127. #if (VIDEO_CHIP == VDC_SAA7118)
  2128.     if (SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07))
  2129.     {
  2130.         I2CWrite(VIDEO_YUV);
  2131.     }
  2132.     else
  2133. #endif
  2134.     {
  2135.         Data[0] = (SOURCE_SV == (stGUD1.INPUT_SOURCE & 0x07)) ? 0 : 1;
  2137.         switch (ucAV_Mode)
  2138.         {
  2139.         case 0x01:          //(60Hz) NTSC-M, JAPAN(7111A)
  2140.         case 0x81:          //(60Hz) Default
  2141.             I2CWrite(Data[0] ? AV_60_0 : SV_60_0);
  2142.             break;
  2143.         case 0x11:          //(60Hz) PAL-4.43
  2144.             I2CWrite(Data[0] ? AV_60_1 : SV_60_1);
  2145.             break;
  2146.         case 0x21:          //(60Hz) NTSC-4.43
  2147.             I2CWrite(Data[0] ? AV_60_2 : SV_60_2);
  2148.             break;
  2149.         case 0x31:          //(60Hz) PAL-M
  2150.             I2CWrite(Data[0] ? AV_60_3 : SV_60_3);
  2151.             break;
  2152.         case 0x41:          //(60Hz) NTSC-JAPAN(7114)
  2153.             I2CWrite(Data[0] ? AV_60_4 : SV_60_4);
  2154.             break;
  2155.         case 0x02:          //(50Hz) PAL-BGHI
  2156.         case 0x82:          //(50Hz) Default
  2157.             I2CWrite(Data[0] ? AV_50_0 : SV_50_0);
  2158.             RTDSetBit(VGIP_SIGINV_05,0xff,0x10);
  2159.             break;
  2160.         case 0x12:          //(50Hz) NTSC-4.43
  2161.             I2CWrite(Data[0] ? AV_50_1 : SV_50_1);
  2162.             break;
  2163.         case 0x22:          //(50Hz) PAL-N
  2164.             I2CWrite(Data[0] ? AV_50_2 : SV_50_2);
  2165.             break;
  2166.         case 0x32:          //(50Hz) NTSC-N
  2167.             I2CWrite(Data[0] ? AV_50_3 : SV_50_3);
  2168.             break;
  2169.         case 0x42:          //Reserved
  2170.             I2CWrite(Data[0] ? AV_50_4 : SV_50_4);
  2171.             break;
  2172.         case 0x03:          //(50Hz) SECAM
  2173.             I2CWrite(Data[0] ? AV_SECAM : SV_SECAM);
  2174. RTDSetBit(VGIP_SIGINV_05,0xff,0x10);
  2175.             break;
  2176.         default:    
  2177.             break;
  2178.         }
  2179.     }
  2180. #endif
  2181. }
  2183. void Display_Video_Set(void)
  2184. {    
  2185. #if(VIDEO_CHIP != VDC_NONE)
  2186.     unsigned char ucCounter;
  2188.     Load_MUD(ucMode_Curr);      // Read mode default settings from 24C04
  2190.     Set_Video_Mode();
  2192.     if (SOURCE_TV == (stGUD1.INPUT_SOURCE & 0x07))      I2CWrite(TV_SOURCE_SEL);
  2194.     // Read H,V Standard Start Position and H Width
  2195.     RTDRead(IPH_ACT_STA_06, 0x08, Y_INC);
  2196.     usIPH_ACT_STA   = (unsigned int)Data[0] + ((unsigned int)Data[1] << 8);
  2197.     usIPH_ACT_STA   = usIPH_ACT_STA & 0x07ff;
  2198.     usIPH_ACT_WID   = (unsigned int)Data[2] + ((unsigned int)Data[3] << 8);
  2199.     usIPH_ACT_WID   = usIPH_ACT_WID & 0x07ff;
  2200.     usIPV_ACT_STA   = (unsigned int)Data[4] + ((unsigned int)Data[5] << 8);
  2201.     usIPV_ACT_STA   = usIPV_ACT_STA & 0x07ff;
  2202.     usIPV_ACT_LEN   = (unsigned int)Data[6] + ((unsigned int)Data[7] << 8);
  2203.     usIPV_ACT_LEN   = usIPV_ACT_LEN & 0x07ff;
  2205.     // Read ucDH_TOTAL
  2206.     RTDRead(DH_TOTAL_22, 2, Y_INC);
  2207.     usDH_Total  = ((unsigned int)(Data[1] & 0x07) << 8) + Data[0];
  2208.     
  2209.     // Read ucDV_Delay
  2210.     RTDRead(IV_DV_LINES_38, 1, N_INC);
  2211.     ucDV_Delay  = Data[0];
  2213.     ucV_Max_Margin  = 0x80;
  2214.     ucV_Min_Margin  = 0x80;
  2216.     Set_Gamma();
  2217.     Set_Dithering();
  2218.     Set_Bright_Contrast();
  2219.     Sharpness();
  2221.     // Update VDC's Contrast/Brightness/Hue/Saturation
  2222.     SetVDC_Color();
  2224.     ucCounter   = 28;
  2225.     do
  2226.     {
  2227.         RTDSetByte(SYNC_POR_4C, 0x00);  // Reset Sync Processor
  2229.         Measure_Mode();
  2231.         Delay_Xms(80);
  2233.         RTDRead(SYNC_POR_4C, 0x05, Y_INC);
  2235.         if (Data[0] & 0x02)
  2236.         {
  2237.             usHsync = 0;
  2238.             usVsync = 0;
  2239.         }
  2240.         else
  2241.         {
  2242.             Data[5] = Data[3];
  2243.             Data[4] = Data[4] & 0x87;
  2244.             Data[3] = Data[1];
  2245.             Data[2] = Data[2] & 0x8f;
  2247.             usHsync = ((unsigned int *)Data)[1];    // Current usHsync timing
  2248.             usVsync = ((unsigned int *)Data)[2];    // Current usVsync timing
  2250.             if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)
  2251.             {
  2252.                 usHsync = 0;
  2253.                 usVsync = 0;
  2254.             }
  2255.             else
  2256.             {
  2257.                 break;
  2258.             }
  2259.         }
  2260.     }
  2261.     while (--ucCounter);
  2263. RTDSetByte(STATUS0_01, 0x00);  // Clear status  
  2264.     RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  2266. Data[0] = Frame_Sync();
  2268.     if (1 == Data[0])   Data[0] = Frame_Sync();     // Fail. Try again
  2270.     bFrameSync      = Data[0] ? 0 : 1;              // 0 : fail, 1 : pass
  2271.    
  2273.     ucSyncErrorCnt  = 0;
  2275. // RTDSetBit(VDIS_CTRL_20, 0x5f, DHS_MASK);        // Normal display
  2276.     RTDSetBit(VDIS_CTRL_20, 0x7f, 0x20 | DHS_MASK);        // Normal display
  2277. #else
  2278.     Set_Video_Mode();
  2279. #endif
  2280. }
  2282. void Input_Mode_Detector(void)
  2283. {
  2284.  RTDRead(SYNC_POR_4C, 0x01, N_INC);
  2285.             
  2286.             if (0 == (Data[0] & 0x02))      ucModeCnt   = 0;
  2288.             if (ucModeCnt)
  2289.             {                  
  2290.      ucModeCnt   -= 1;
  2291.             }
  2292.             else
  2293.             {
  2294.                 ucModeCnt   = MODE_DETECT_FREQ;
  2296. #if(SOURCE_AUTO_SCAN) 
  2297.                 Source_Auto_Scan();
  2298. #else
  2299.                 Mode_Detector();
  2300. #endif
  2302.                 if (!bStable)
  2303.                 {
  2304.                     bReload     = 1;            // Reload user's font
  2306.                     Set_Task(STATE_MODECHANGE); // Notify Task State Machine
  2307.                 }
  2308.             }
  2309. }
  2311. ///////////////////////////////////////////////////////////////////////////////////
  2312. //anson 05_0314
  2313. ///////////////////////////////////////////////////////////////////////////////////
  2314. void New_Mode_Auto(void)
  2315. {
  2317. if (bStable && 
  2318. bFrameSync && 
  2319. ((stGUD1.OSD_INPUT & 0x20) == 0x20) && 
  2320. (MODE_NOSIGNAL != ucMode_Curr) &&
  2321. (MODE_NOSUPPORT != ucMode_Curr) && 
  2322. ucfrist 
  2323. )
  2324. {
  2325. OSD_Position(OSD_ENABLE);
  2326. OSD_Position(OSD_ENABLE);
  2327. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);
  2328. RTDOSDW(OSD_Reset);
  2329. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x01);
  2330. RTDOSDW(OSD_AUTO);
  2331. RTDOSDW(strTabAuto_Atb[stGUD1.FUNCTION & 0x07]); //anson
  2332. Auto_Config();
  2333. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);
  2334. RTDOSDW(OSD_Reset);
  2336. stGUD1.OSD_INPUT &= 0xdf;//Clear "First Time Into Mode" Bit
  2337. Save_GUD1();
  2338. ucfrist = (ucMode_Curr - 1 ) / 8 ;                
  2339. I2CRead(ADDR_EROM1, ucfrist , 1);
  2340. Data[1] = 0x01;
  2341. Data[1] = Data[1] << (ucMode_Curr - 1 - (ucfrist*8)) ; 
  2342. Data[3] = Data[0] & ~Data[1];
  2344. Data[0] = 4;
  2345. Data[1] = ADDR_EROM1;
  2346. Data[2] = ucfrist;                                                                             
  2347. I2CWrite(Data);
  2348. Delay_Xms(SET_2404_DELAY);
  2349. ucfrist = 0;
  2350. }
  2352. }