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

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

其他嵌入式/单片机内容

开发平台：

C/C++

Access.c：源码内容
  1. #define __ACCESS__
  3. #include "reg52.h"
  4. #include "intrins.h"
  6. #include "HeaderMAIN_DEF.H"
  7. #include "HeaderACCESS.h"
  8. #include "HeaderCONFIG.H"
  9. #include "HeaderMTV512.H"
  10. #include "HeaderOSD.H"
  11. #include "HeaderPower_Ctrl.h"
  13. #if(MCU_TYPE == MCU_MTV512)
  14. ///////////////////////////////////////////////////////////////////////
  15. // SCL Processor                                                                                                //
  16. ///////////////////////////////////////////////////////////////////////
  17. void MCU_WriteI2cScl(bit Status)
  18. {
  19.        bIIC_SCL = Status;
  20. }
  21. ///////////////////////////////////////////////////////////////////////
  22. // SDA Processor                                                                                               //
  23. ///////////////////////////////////////////////////////////////////////
  24. void MCU_WriteI2cSda(bit Status)
  25. {
  26.        bIIC_SDA = Status;
  27. }
  29. bit MCU_ReadI2cSda(void)
  30. {
  31.        return(bIIC_SDA);
  32. }
  33. ///////////////////////////////////////////////////////////////////////
  34. // RTD Reset Processor                                                                                      //
  35. ///////////////////////////////////////////////////////////////////////
  36. #if(RESET_TYPE == RESET_IN)
  37. void MCU_WriteRtdReset(bit Status)
  38. {
  39.        bRTD_RST = Status;
  40. }
  42. bit MCU_ReadRtdReset(void)
  43. {
  44.        return(bRTD_RST);
  45. }
  46. #endif
  49. ///////////////////////////////////////////////////////////////////////
  50. // RTD SDIO Processor                                                                                       //
  51. ///////////////////////////////////////////////////////////////////////
  52. /*
  53. void MCU_WriteRtdSdio(bit Status)
  54. {
  55.        bRTD_SDIO_0 = Status;
  56. }
  58. bit MCU_ReadRtdSdio(void)
  59. {
  60.        return(bRTD_SDIO_0);
  61. }
  62. */
  63. ///////////////////////////////////////////////////////////////////////
  64. // RTD Sclk Processor                                                                                        //
  65. ///////////////////////////////////////////////////////////////////////
  66. void MCU_WriteRtdSclk(bit Status)
  67. {
  68.        bRTD_SCLK = Status;
  69. }
  70. ///////////////////////////////////////////////////////////////////////
  71. // RTD Scsb Processor                                                                                       //
  72. ///////////////////////////////////////////////////////////////////////
  73. void MCU_WriteRtdScsb(bit Status)
  74. {
  75.        bRTD_SCSB = Status;
  76. }
  77. ///////////////////////////////////////////////////////////////////////
  78. // VIDEO POWER Processor                                                                                //
  79. ///////////////////////////////////////////////////////////////////////
  80. #if (VIDEO_CHIP != VDC_NONE)
  81. void MCU_WriteVideoPower(bit Status)
  82. {
  83.        bVDC_PWR = Status;
  84. }
  85. #endif
  87. ///////////////////////////////////////////////////////////////////////
  88. // PANEL POWER Processor                                                                                 //
  89. ///////////////////////////////////////////////////////////////////////
  90. void MCU_WritePanelPower(bit Status)
  91. {
  92.        bPANEL_PWR = Status;
  93.        bPanel_Status = Status ? 1 : 0;
  94. }
  95. /*
  96. bit MCU_ReadPanelPower(void)
  97. {
  98.        return(bPANEL_PWR);
  99. }
  100. */
  101. ///////////////////////////////////////////////////////////////////////
  102. // BACKLIGHT POWER Processor                                                                         //
  103. ///////////////////////////////////////////////////////////////////////
  104. void MCU_WriteBacklightPower(bit Status)
  105. {
  106.        bLIGHT_PWR = (Status);
  107. }
  110. ///////////////////////////////////////////////////////////////////////
  111. // VGA CONNECT Processor                                                                                //
  112. ///////////////////////////////////////////////////////////////////////
  113. bit MCU_ReadVgaConnect(void)
  114. {
  115.        return(bVGA_CONNECT);
  116. }
  118. #endif
  120. void BitDly(void)
  121. {
  122.     _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  123.     _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  124.     _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  125.     _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  126. }
  128. void I2CRead(unsigned char addr, unsigned char index, unsigned char count)
  129. {
  130.     unsigned char   n;
  132.     if (count)
  133.     {
  134.         I2CSendAddr(addr, index, 0);
  135.         
  136.         I2CSendAddr(addr, 0, 1);
  138.         count   = count - 1;
  140.         for (n = 0; n < count; n++)     Data[n] = I2CGetByte(0);
  142.         Data[count] = I2CGetByte(1);
  144.         I2CSendStop();
  145.     }
  146. }
  148. void I2CWrite(unsigned char *array)
  149. {
  150.     unsigned char   n, len;
  152.     if (3 <= array[0])
  153.     {
  154.         len     = array[0];
  155.         I2CSendAddr(array[1], array[2], 0);     
  157.         for (n = 3; n < len; n++)   I2CSendByte(array[n]);
  159.         I2CSendStop();
  160.     }
  161. }
  164. unsigned char I2CGetByte(unsigned char ack) 
  165. {
  166.     unsigned char   r, m;
  168.     r = 0;
  169. #if(MCU_TYPE == MCU_WINBOND)
  170.     for (m = 0; m < 8; m++)         // Each bit at a time, MSB first
  171.     {
  172.         bIIC_SCL    = 1;
  173.         BitDly();                   // Delay
  175.         r   = (r << 1) | bIIC_SDA;
  177.         bIIC_SCL    = 0;
  178.         BitDly();                   // Delay
  179.     }  
  181.     // Send ACK according to 'ack'
  182.     bIIC_SDA    = (bit)(ack & 0x01);
  183.     BitDly();                       // Delay
  184.     
  185.     bIIC_SCL    = 1; 
  186.     BitDly();                       // Delay
  187.     
  188.     bIIC_SCL    = 0; 
  189.     BitDly();                       // Delay
  190.     
  191.     bIIC_SDA    = 1;
  192. #else
  193.    
  194.     for (m = 0; m < 8; m++)         // Each bit at a time, MSB first
  195.     {
  196.         MCU_WriteI2cScl(_HIGH);
  197.         BitDly();                   // Delay
  198.         r   = (r << 1) | MCU_ReadI2cSda();
  199.         MCU_WriteI2cScl(_LOW);
  200.         BitDly();                   // Delay
  201.     }  
  202.     // Send ACK according to 'ack'
  203.     MCU_WriteI2cSda((bit)(ack & 0x01));
  204.     BitDly();                       // Delay
  205.     MCU_WriteI2cScl(_HIGH);
  206.     BitDly();                       // Delay
  207.     MCU_WriteI2cScl(_LOW);
  208.     BitDly();                       // Delay
  209.     MCU_WriteI2cSda(_HIGH);
  211. #endif
  213.     return (r);
  214. }
  216. void I2CSendByte(unsigned char send)
  217. {
  218.     unsigned char   m;
  219. #if(MCU_TYPE == MCU_WINBOND)    
  220.     for (m = 0; m < 8; m++)
  221.     {
  222.         bIIC_SDA    = (bit)(send & 0x80);   // Send each bit, MSB first
  223.         BitDly();
  225.         bIIC_SCL    = 1;
  226.         BitDly();
  228.         bIIC_SCL    = 0;
  230.         send    = send << 1;
  231.     }
  233.     bIIC_SDA    = 1;
  234.     bIIC_SCL    = 1;
  235.     BitDly();
  237.     bIIC_SCL    = 0;
  238.     BitDly();
  239. #else
  240.     for (m = 0; m < 8; m++)
  241.     {
  242.         MCU_WriteI2cSda((bit)(send & 0x80));   // Send each bit, MSB first
  243.         BitDly();
  244.         MCU_WriteI2cScl(_HIGH);
  245.         BitDly();
  246.         MCU_WriteI2cScl(_LOW);;
  247.         send    = send << 1;
  248.     }
  249.     MCU_WriteI2cSda(_HIGH);
  250.     MCU_WriteI2cScl(_HIGH);
  251.     BitDly();
  252.     MCU_WriteI2cScl(_LOW);;
  253.     BitDly();
  255. #endif
  256. } 
  258. void I2CSendAddr(unsigned char addr, unsigned char index, unsigned char rd)
  259. {         
  260. #if(MCU_TYPE == MCU_WINBOND)         
  261.     bIIC_SCL    = 1;
  262.     bIIC_SDA    = 0;    // Start
  263.     BitDly();
  265.     bIIC_SCL    = 0;
  266.     I2CSendByte(addr + rd);             // Send address byte
  268.     if (0 == rd)    I2CSendByte(index); // Send index byte  
  269. #else
  270.     MCU_WriteI2cScl(_HIGH);
  271.     MCU_WriteI2cSda(_LOW);    // Start
  272.     BitDly();
  273.     MCU_WriteI2cScl(_LOW);;
  274.     I2CSendByte(addr + rd);             // Send address byte
  275.     if (0 == rd)    I2CSendByte(index); // Send index byte 
  276. #endif
  277. }
  279. void I2CSendStop(void)
  280. {
  281. #if(MCU_TYPE == MCU_WINBOND)
  282.     bIIC_SDA    = 0; 
  283.     BitDly();
  285.     bIIC_SCL    = 1;
  286.     BitDly();
  288.     bIIC_SDA    = 1;
  289.     BitDly();
  290. #else
  291.     MCU_WriteI2cSda(_LOW); 
  292.     BitDly();
  293.     MCU_WriteI2cScl(_HIGH);
  294.     BitDly();
  295.     MCU_WriteI2cSda(_HIGH);
  296.     BitDly();
  297. #endif
  298. }
  300. unsigned char RTDGetByte(void) 
  301. {
  303. #if(PARALLEL_PORT)
  305. #if(1)
  306.    bRTD_SCLK = 1;
  307.    bRTD_SCLK = 0;
  308.    r0        = bRTD_SDIO_0;
  309.    r1        = bRTD_SDIO_1;
  310.    r2        = bRTD_SDIO_2;
  311.    r3        = bRTD_SDIO_3;
  313.    bRTD_SCLK = 1;
  314.    bRTD_SCLK = 0;
  315.    r4        = bRTD_SDIO_0;
  316.    r5        = bRTD_SDIO_1;
  317.    r6        = bRTD_SDIO_2;
  318.    r7        = bRTD_SDIO_3;
  320.    bRTD_SCLK   = 1;
  321. #else
  323.    bRTD_SCLK = 1;
  324.    bRTD_SCLK = 0;
  326.    Reg = P0 & 0x0f;
  328.    bRTD_SCLK = 1;
  329.    bRTD_SCLK = 0;
  331.    Reg = Reg | ((P0 & 0x0f) << 4);
  333.    bRTD_SCLK   = 1;
  335. #endif
  337. #else //serial port
  338.     bRTD_SCLK   = 1;
  339.     bRTD_SCLK   = 0;
  340.     r0          = bRTD_SDIO_0;
  342.     bRTD_SCLK   = 1;
  343.     bRTD_SCLK   = 0;
  344.     r1          = bRTD_SDIO_0;
  346.     bRTD_SCLK   = 1;
  347.     bRTD_SCLK   = 0;
  348.     r2          = bRTD_SDIO_0;
  350.     bRTD_SCLK   = 1;
  351.     bRTD_SCLK   = 0;
  352.     r3          = bRTD_SDIO_0;
  354.     bRTD_SCLK   = 1;
  355.     bRTD_SCLK   = 0;
  356.     r4          = bRTD_SDIO_0;
  358.     bRTD_SCLK   = 1;
  359.     bRTD_SCLK   = 0;
  360.     r5          = bRTD_SDIO_0;
  362.     bRTD_SCLK   = 1;
  363.     bRTD_SCLK   = 0;
  364.     r6          = bRTD_SDIO_0;
  366.     bRTD_SCLK   = 1;
  367.     bRTD_SCLK   = 0;
  368.     r7          = bRTD_SDIO_0;
  370.     bRTD_SCLK   = 1;
  372. #endif
  375.     return Reg;
  376. }
  378. void RTDSendByte(unsigned char send)
  379. {
  382. #if(PARALLEL_PORT)
  384. #if(1)
  385.     bRTD_SDIO_0 = (bit)(send & 0x01);
  386. bRTD_SDIO_1 = (bit)(send & 0x02);
  387. bRTD_SDIO_2 = (bit)(send & 0x04);
  388. bRTD_SDIO_3 = (bit)(send & 0x08);
  389. bRTD_SCLK   = 1;
  390.     bRTD_SCLK   = 0;
  392. bRTD_SDIO_0 = (bit)(send & 0x10);
  393. bRTD_SDIO_1 = (bit)(send & 0x20);
  394. bRTD_SDIO_2 = (bit)(send & 0x40);
  395. bRTD_SDIO_3 = (bit)(send & 0x80);
  396. bRTD_SCLK   = 1;
  397.     bRTD_SCLK   = 0;
  399. bRTD_SDIO_0 = 1;
  400. bRTD_SDIO_1 = 1;
  401. bRTD_SDIO_2 = 1;
  402. bRTD_SDIO_3 = 1;
  403. bRTD_SCLK   = 1;
  404. #else
  405.     unsigned char ucTemp;
  407. ucTemp = P0 & 0xf0;
  409.     P0 = ucTemp | (send & 0x0f);
  410.     bRTD_SCLK   = 1;
  411.     bRTD_SCLK   = 0;
  413.     P0 = ucTemp | (send >> 4);
  415.     bRTD_SCLK   = 1;
  416.     bRTD_SCLK   = 0;
  418.     P0 = ucTemp | 0x0f;
  419.     bRTD_SCLK   = 1;
  421. #endif
  423. #else //serial port
  424.     bRTD_SDIO_0 = (bit)(send & 0x01);
  425.     bRTD_SCLK   = 1;
  426.     bRTD_SCLK   = 0;
  428.     bRTD_SDIO_0 = (bit)(send & 0x02);
  429.     bRTD_SCLK   = 1;
  430.     bRTD_SCLK   = 0;
  432.     bRTD_SDIO_0 = (bit)(send & 0x04);
  433.     bRTD_SCLK   = 1;
  434.     bRTD_SCLK   = 0;
  436.     bRTD_SDIO_0 = (bit)(send & 0x08);
  437.     bRTD_SCLK   = 1;
  438.     bRTD_SCLK   = 0;
  440.     bRTD_SDIO_0 = (bit)(send & 0x10);
  441.     bRTD_SCLK   = 1;
  442.     bRTD_SCLK   = 0;
  444.     bRTD_SDIO_0 = (bit)(send & 0x20);
  445.     bRTD_SCLK   = 1;
  446.     bRTD_SCLK   = 0;
  448.     bRTD_SDIO_0 = (bit)(send & 0x40);
  449.     bRTD_SCLK   = 1;
  450.     bRTD_SCLK   = 0;
  452.     bRTD_SDIO_0 = (bit)(send & 0x80);
  453.     bRTD_SCLK   = 1;
  454.     bRTD_SCLK   = 0;
  456.     bRTD_SDIO_0 = 1;
  457.     bRTD_SCLK   = 1;
  459. #endif
  462. }
  464. void RTDSendAddr(unsigned char addr, unsigned char rd, unsigned char inc)   // rd   : 0 - Write, 1 - Read
  465. {
  467. #if(PARALLEL_PORT)
  469.     RTDSendByte(addr);
  471. bRTD_SDIO_0 = (bit)(rd & 0x01);
  472. bRTD_SDIO_1 = (bit)(inc & 0x01);
  474. bRTD_SCLK = 0;
  476. bRTD_SDIO_0 = 1;
  477. bRTD_SDIO_1 = 1;
  478. bRTD_SCLK = 1;
  479. #else // serial port
  480.     RTDSendByte(addr);
  482.     bRTD_SDIO_0 = 1;
  483.     bRTD_SCLK   = 1;        
  484.     bRTD_SDIO_0 = (bit)(rd & 0x01); 
  485.     bRTD_SCLK   = 1;
  486.     bRTD_SCLK   = 0;
  487.     bRTD_SDIO_0 = (bit)(inc & 0x01); 
  488.     bRTD_SCLK   = 1;
  489.     bRTD_SCLK   = 0;
  490.     bRTD_SDIO_0 = 1;
  491. #endif
  494. }
  496. void RTDSendStop(void)
  497. {
  499.         bRTD_SCLK   = 0;
  500.         bRTD_SCLK   = 1; 
  501.         bRTD_SCSB   = 1;
  503. }
  505. void RTDRead(unsigned char index, unsigned char count, unsigned char inc)
  506. {
  507.     if (count)
  508.     {
  509.         bRTD_SCSB   = 0;
  511.         RTDSendAddr(index, 1, inc);
  513.         index   = 0;
  514.         do
  515.         {
  516.             Data[index++]   = RTDGetByte();
  517.         }
  518.         while (--count);
  520. RTDSendStop();
  522.     }
  523. }
  525. void RTDWrite(unsigned char data *array)
  526. {
  528.     unsigned char   len, m;
  530.     do
  531.     {
  532.         if (0 == (array[0] & 0xfc))     return;
  534.         len     = array[0] - 3;
  535.         array   = array + 1;
  536.         bRTD_SCSB   = 0;
  539.         if (BURST == array[0])
  540.         {
  541.             RTDSendAddr(array[1], 0, N_INC);
  543.             array   = array + 2;
  544.             m       = array[0];
  546.             do
  547.             {
  548.                 RTDSendByte(m);
  549.             }
  550.             while (--len);
  552.             array   = array + 1;
  553.         }
  554.         else
  555.         {
  556.             RTDSendAddr(array[1], 0, array[0]);
  558.             array   = array + 2;
  559.             do
  560.             {
  561.                 RTDSendByte(*array++);
  562.             }
  563.             while (--len);
  564.         }
  565. RTDSendStop();
  566.     }
  567.     while (1);
  568. }
  570. void RTDCodeW(unsigned char code *array)
  571. {
  572.     unsigned char   len, m;
  574.     do
  575.     {
  576.         if (0 == (array[0] & 0xfc))     return;
  578.         len     = array[0] - 3;
  579.         array   = array + 1;
  580.         bRTD_SCSB   = 0;
  582.         if (BURST == array[0])
  583.         {
  584.             RTDSendAddr(array[1], 0, N_INC);
  586.             array   = array + 2;
  587.             m       = array[0];
  588.             
  589.             do
  590.             {
  591.                 RTDSendByte(m);
  592.             }
  593.             while (--len);
  595.             array   = array + 1;
  596.         }
  597.         else
  598.         {
  599.             RTDSendAddr(array[1], 0, array[0]);
  601.             array   = array + 2;
  602.             do
  603.             {
  604.                 RTDSendByte(*array++);
  605.             }
  606.             while (--len);
  607.         }
  608. RTDSendStop();
  610.     }
  611.     while (1);
  612. }
  614. void RTDOSDW(unsigned char code *array)
  615. {
  616.     unsigned char   len;
  617.     do
  618.     {
  619.         if (array[0] == _end_)     return;
  620.     
  621. bRTD_SCSB   = 0;
  622.         RTDSendAddr(OSD_ROW_90,WRITE,Y_INC);
  623.         RTDSendByte(*array++);
  624.         RTDSendByte(*array++);
  626. RTDSendStop();
  628. bRTD_SCSB   = 0;
  629.         RTDSendAddr(OSD_DATA_92,WRITE,N_INC);
  630.         do
  631. {
  632.            if(array[0] == _ext_)
  633.            {
  634.                if(array[2] == _bb_)
  635.                {
  636.                   do
  637.                   {
  638.                      len = array[3] - 1;
  639.                      RTDSendByte(_ext_ + array[1]);
  640.                    }while(len--);
  642.                    array += 4;
  643.                }
  644.                else
  645.                {
  646.                    RTDSendByte(_ext_ + array[1]);
  647.                    array += 2;
  648.                }
  649.            }
  650.            else if(array[1] == _bb_)
  651.    {
  652.        len = array[2] - 1;
  653.    do
  654.    {
  655.       RTDSendByte(*array);
  656.    }while(len--);
  657.        
  658.    array += 3;
  659.    }
  660.    else
  661.        RTDSendByte(*array++);
  664. }while(array[0] != _nn_);
  665. array +=1 ;
  666. RTDSendStop();
  668.     }
  669.     while (1);
  671. }
  674. void RTDSetByte(unsigned char addr, unsigned char val)
  675. {
  676.     // Set Write Address
  677.     bRTD_SCSB   = 0;   
  679.     RTDSendAddr(addr, 0, 1);
  681.     // Write one Byte
  682.     RTDSendByte(val);
  684. RTDSendStop();
  686. }
  688. void RTDSetBit(unsigned char addr, unsigned char and, unsigned char or)
  689. {
  690.     // Set Read Address
  691.     bRTD_SCSB   = 0;
  692.     RTDSendAddr(addr, 1, 1);
  694.     // Read 1 Byte
  695.     or      = (RTDGetByte() & and) | or;
  697. RTDSendStop();
  699.     // Set Write Address
  700.     bRTD_SCSB   = 0;   
  701.     RTDSendAddr(addr, 0, 1);
  703.     // Write one Byte
  704.     RTDSendByte(or);
  706. RTDSendStop();
  709. }
  711. #if(VLC_COMPRESS)
  712. void Load_VLC_Font(unsigned char code *array, unsigned int start, unsigned int length)
  713. {
  714. unsigned char n,m;
  715. unsigned char ucTemp[3];
  716. unsigned char idata ucTemp_VLD[3];
  718. #if(PARALLEL_PORT)
  719. // unsigned char ucTemp1;
  720. #endif
  722. start += FONT_BASE_ADDRESS;
  724. bRTD_SCSB   = 0;   
  725. RTDSendAddr(OSD_ROW_90, WRITE, Y_INC);
  726. ucTemp[0] = (unsigned char)((start >> 8) & 0x000f) | 0xd0;
  727. RTDSendByte(ucTemp[0]);
  728. ucTemp[0] = (unsigned char)(start & 0x00ff);
  729. RTDSendByte(ucTemp[0]);
  731. RTDSendStop();
  733. bRTD_SCSB   = 0;   
  734. RTDSendAddr(OSD_DATA_92, WRITE, N_INC);
  736. ucCnt = 0;
  737. uiCount = 0;
  738. bBit = 0;
  739. ucByte_Temp = 0;
  741. do
  742. {
  743. for(m=0; m<9; m++)
  744. {
  746. ucTemp_VLD[0] = Get_VLD(array) << 4;
  747. ucTemp_VLD[0] |= Get_VLD(array);
  748. ucTemp_VLD[1] = Get_VLD(array) << 4;
  749. ucTemp_VLD[1] |= Get_VLD(array);
  750. ucTemp_VLD[2] = Get_VLD(array) << 4;
  751. ucTemp_VLD[2] |= Get_VLD(array);
  753. //Rearrange the byte order
  754. ucTemp[0] = (ucTemp_VLD[1] << 4) | (ucTemp_VLD[2] & 0x0f);
  755. ucTemp[1] = (ucTemp_VLD[2] & 0xf0) | (ucTemp_VLD[0] & 0x0f);
  756. ucTemp[2] = (ucTemp_VLD[0] & 0xf0) | (ucTemp_VLD[1] >> 4);
  758. for(n=0;n<3;n++)
  759. {
  760. #if(PARALLEL_PORT)
  762. #if(KINGMICE)
  763. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x01);
  764. bRTD_SDIO_1 = (bit)(ucTemp[n] & 0x02);
  765. bRTD_SDIO_2 = (bit)(ucTemp[n] & 0x04);
  766. bRTD_SDIO_3 = (bit)(ucTemp[n] & 0x08);
  767. bRTD_SCLK   = 1;
  768. bRTD_SCLK   = 0;
  769. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x10);
  770. bRTD_SDIO_1 = (bit)(ucTemp[n] & 0x20);
  771. bRTD_SDIO_2 = (bit)(ucTemp[n] & 0x40);
  772. bRTD_SDIO_3 = (bit)(ucTemp[n] & 0x80);
  773. bRTD_SCLK   = 1;
  774. bRTD_SCLK   = 0;
  775. bRTD_SDIO_0 = 1;
  776. bRTD_SDIO_1 = 1;
  777. bRTD_SDIO_2 = 1;
  778. bRTD_SDIO_3 = 1;
  779. bRTD_SCLK   = 1;
  780. #else
  781. ucTemp1 = P0 & 0xf0;
  783. P0 = ucTemp1 | (ucTemp[n] & 0x0f);
  784. bRTD_SCLK   = 1;
  785. bRTD_SCLK   = 0;
  786. P0 = ucTemp1 | (ucTemp[n] >> 4);
  787. bRTD_SCLK   = 1;
  788. bRTD_SCLK   = 0;
  789. P0 = ucTemp1 | 0x0f;
  790. bRTD_SCLK   = 1;
  791. #endif
  793. #else
  794. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x01);
  795. bRTD_SCLK   = 1;
  796. bRTD_SCLK   = 0;
  797. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x02);
  798. bRTD_SCLK   = 1;
  799. bRTD_SCLK   = 0;
  800. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x04);
  801. bRTD_SCLK   = 1;
  802. bRTD_SCLK   = 0;
  803. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x08);
  804. bRTD_SCLK   = 1;
  805. bRTD_SCLK   = 0;
  806. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x10);
  807. bRTD_SCLK   = 1;
  808. bRTD_SCLK   = 0;
  809. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x20);
  810. bRTD_SCLK   = 1;
  811. bRTD_SCLK   = 0;
  812. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x40);
  813. bRTD_SCLK   = 1;
  814. bRTD_SCLK   = 0;
  815. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x80);
  816. bRTD_SCLK   = 1;
  817. bRTD_SCLK   = 0;
  818. bRTD_SDIO_0 = 1;
  819. bRTD_SCLK   = 1;
  820. #endif
  821. }
  822. }
  823. }
  824. while (--length);
  826. RTDSendStop();
  828. }
  830. unsigned char Get_VLD(unsigned char code *array)
  831. {
  832. unsigned char data ucZero_Cnt = 0;
  833. bit bSec_Part = 0;
  835. while(1)
  836. {
  837. if( ucCnt == 0 )
  838. {
  839. ucByte_Temp = *(array + uiCount);
  840. ucCnt = 0x80;
  841. uiCount++;
  842. }
  844. while( ucCnt > 0 )
  845. {
  846. bBit = (bit)(ucByte_Temp & ucCnt);
  847. ucCnt >>= 1;
  849. if( (bBit) && (bSec_Part == 0) )
  850. {
  851. bSec_Part = 1;
  852. }
  853. else
  854. {
  855. ucZero_Cnt++;
  856. }
  858. if( bSec_Part == 1 )
  859. {
  860. switch(ucZero_Cnt)
  861. {
  862. case 0:
  863. bSec_Part = 0;
  864. ucZero_Cnt = 0;
  865. return 0;
  867. case 1:
  868. Getbit(array);
  869. bSec_Part = 0;
  870. ucZero_Cnt = 0;
  872. if(!bBit)
  873. {
  874. return 1;
  875. }
  876. else
  877. {
  878. return 15;
  879. }
  881. case 2:
  882. Getbit(array);
  883. bSec_Part = 0;
  884. ucZero_Cnt = 0;
  886. if(!bBit)
  887. {
  888. return 2;
  889. }
  890. else
  891. {
  892. return 8;
  893. }
  895. case 3:
  896. Getbit(array);
  897. bSec_Part = 0;
  898. ucZero_Cnt = 0;
  900. if(!bBit)
  901. {
  902. return 12;
  903. }
  904. else
  905. {
  906. return 7;
  907. }
  909. case 4:
  910. Getbit(array);
  911. bSec_Part = 0;
  912. ucZero_Cnt = 0;
  914. if(bBit)
  915. {
  916. Getbit(array);
  918. if(!bBit)
  919. {
  920. return 4;
  921. }
  922. else
  923. {
  924. return 9;
  925. }
  926. }
  927. else
  928. {
  929. Getbit(array);
  931. if(!bBit)
  932. {
  933. Getbit(array);
  935. if(!bBit)
  936. {
  937. return 3;
  938. }
  939. else
  940. {
  941. return 11;
  942. }
  944. }
  945. else
  946. {
  947. Getbit(array);
  949. if(!bBit)
  950. {
  951. return 10;
  952. }
  953. else
  954. {
  955. return 5;
  956. }
  958. }
  959. }
  961. case 5:
  962. Getbit(array);
  963. bSec_Part = 0;
  964. ucZero_Cnt = 0;
  966. if(bBit)
  967. {
  968. Getbit(array);
  970. if(!bBit)
  971. {
  972. return 14;
  973. }
  974. else
  975. {
  976. return 13;
  977. }
  978. }
  979. else
  980. {
  981. Getbit(array);
  982. if(bBit)
  983. {
  984. return 6;
  985. }
  986. }
  987. }
  988. }
  989. }
  990. }
  991. }
  993. void Getbit(unsigned char code *array)
  994. {
  995. if( ucCnt == 0 )
  996. {
  997. ucByte_Temp = *(array + uiCount);
  998. ucCnt = 0x80;
  999. uiCount++;
  1000. }
  1002. bBit = (bit)(ucByte_Temp & ucCnt);
  1003. ucCnt >>= 1;
  1005. }
  1006. #else
  1007. //length represent the number of character
  1008. // character number of 1 bit font  = 1
  1009. // character number of 2 bit font  = 2
  1010. // character number of 4 bit font  = 4
  1011. // length = (1 bit font amount) x 1 + (2 bit font amount) x 2 + (4 bit font amount) x 4
  1012. void Load_Font(unsigned char code *array, unsigned int start, unsigned int length)
  1013. {
  1014.     unsigned char   n,m;
  1015.     unsigned char   ucTemp[3];
  1016. #if(PARALLEL_PORT)
  1017. // unsigned char ucTemp1;
  1018. #endif
  1020.     start = start * 9;
  1021.     start += FONT_BASE_ADDRESS;
  1023. bRTD_SCSB   = 0;   
  1024. RTDSendAddr(OSD_ROW_90, WRITE, Y_INC);
  1025. ucTemp[0] = (unsigned char)((start >> 8) & 0x000f) | 0xd0;
  1026. RTDSendByte(ucTemp[0]);
  1027. ucTemp[0] = (unsigned char)(start & 0x00ff);
  1028. RTDSendByte(ucTemp[0]);
  1030. RTDSendStop();
  1032. bRTD_SCSB   = 0;   
  1033. RTDSendAddr(OSD_DATA_92, WRITE, N_INC);
  1035.     do
  1036.     {
  1037.         for(m=0; m<9; m++)
  1038.         {
  1039. //Rearrange the byte order
  1041.             ucTemp[0] = (*(array + 1) << 4) | (*(array + 2) & 0x0f);
  1042. ucTemp[1] = (*(array + 2) & 0xf0) | (*array & 0x0f);
  1043. ucTemp[2] = (*array & 0xf0) | (*(array + 1) >> 4);
  1045. for(n=0;n<3;n++)
  1046. {
  1047. #if(PARALLEL_PORT)
  1049. #if(1)
  1050. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x01);
  1051. bRTD_SDIO_1 = (bit)(ucTemp[n] & 0x02);
  1052. bRTD_SDIO_2 = (bit)(ucTemp[n] & 0x04);
  1053. bRTD_SDIO_3 = (bit)(ucTemp[n] & 0x08);
  1054.                 bRTD_SCLK   = 1;
  1055. bRTD_SCLK   = 0;
  1056. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x10);
  1057. bRTD_SDIO_1 = (bit)(ucTemp[n] & 0x20);
  1058. bRTD_SDIO_2 = (bit)(ucTemp[n] & 0x40);
  1059. bRTD_SDIO_3 = (bit)(ucTemp[n] & 0x80);
  1060. bRTD_SCLK   = 1;
  1061. bRTD_SCLK   = 0;
  1062. bRTD_SDIO_0 = 1;
  1063. bRTD_SDIO_1 = 1;
  1064. bRTD_SDIO_2 = 1;
  1065. bRTD_SDIO_3 = 1;
  1066. bRTD_SCLK   = 1;
  1067. #else
  1068. ucTemp1 = P0 & 0xf0;
  1070. P0 = ucTemp1 | (ucTemp[n] & 0x0f);
  1071. bRTD_SCLK   = 1;
  1072. bRTD_SCLK   = 0;
  1073. P0 = ucTemp1 | (ucTemp[n] >> 4);
  1074. bRTD_SCLK   = 1;
  1075. bRTD_SCLK   = 0;
  1076. P0 = ucTemp1 | 0x0f;
  1077. bRTD_SCLK   = 1;
  1078. #endif
  1080. #else
  1081. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x01);
  1082. bRTD_SCLK   = 1;
  1083. bRTD_SCLK   = 0;
  1084. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x02);
  1085. bRTD_SCLK   = 1;
  1086. bRTD_SCLK   = 0;
  1087. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x04);
  1088. bRTD_SCLK   = 1;
  1089. bRTD_SCLK   = 0;
  1090. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x08);
  1091. bRTD_SCLK   = 1;
  1092. bRTD_SCLK   = 0;
  1093. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x10);
  1094. bRTD_SCLK   = 1;
  1095. bRTD_SCLK   = 0;
  1096. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x20);
  1097. bRTD_SCLK   = 1;
  1098. bRTD_SCLK   = 0;
  1099. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x40);
  1100. bRTD_SCLK   = 1;
  1101. bRTD_SCLK   = 0;
  1102. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x80);
  1103. bRTD_SCLK   = 1;
  1104. bRTD_SCLK   = 0;
  1105. bRTD_SDIO_0 = 1;
  1106. bRTD_SCLK   = 1;
  1107. #endif
  1108.             }
  1109.             array += 3;
  1110.         }
  1111.     }
  1112.     while (--length);
  1114. RTDSendStop();
  1115. }
  1116. #endif
  1119. #if(HDCP_ENABLE)
  1120. void KEYCodeW(unsigned char code *array)
  1121. {
  1122.     unsigned int m;  
  1124.    RTDSetBit(DVI_CTRL1_AF, 0x7f,0x00);  //Reset the HDCP key download index
  1125.    RTDSetBit(DVI_CTRL1_AF, 0x7f,0x80);
  1127.     for(m = 0; m < 320; m++)   //Key 0 ~ Key39   
  1128.     {
  1129. RTDSetByte(0xb1,array[m]);
  1130.     }
  1132.     RTDSetBit(DVI_CTRL1_AF, 0x7f,0x00);  //Disable the Key Access Download port
  1133.     RTDSetBit(TMDS_INPUT_ENA_A1, 0x7f, 0x00);   // Turn on HDCP DDC channel  
  1134. }
  1135. #endif