裸机S3C6410显示控制器(4)- 显示图像到屏幕

时间：2022-06-11 12:24:21


 

裸机S3C6410显示控制器(4)- 显示图像到屏幕

分类： [项目]S3C6410移植LINUX 2012-11-08 22:41  186人阅读  评论(0)  收藏  举报

    最近忙于工作和家庭，这几天才得以继续完成S3C6410的LCD裸机程序。

   （1）背光控制

    刚开始误认为drivers/video/mini6410_backlight.c是背光的驱动程序，但实际它不是。TINY6410的LCD屏的驱动不同于其它LCD的驱动写法，它使用所谓的“一线触屏”驱动，驱动文件是drivers/input/touchscreen/mini6410_1wire_host.c。

裸机S3C6410显示控制器(4)- 显示图像到屏幕

驱动初始化：

[cpp]  view plain copy
  1. static int __init dev_init(void)  
  2. {  
  3.     int ret;  
  4.     ret = misc_register(&ts_misc) | misc_register(&bl_misc) ;  
  5.   
  6.     //set PWM as output, set output is 1.  
  7.     set_pin_up();  
  8.     set_pin_value(1);  
  9.     set_pin_as_output();  
  10.   
  11.     if (ret == 0) {  
  12.         setup_irq(IRQ_TIMER3, &timer_for_1wire_irq);  
  13.         ret = init_timer_for_1wire();  
  14.         init_timer(&one_wire_timer);  
  15.         one_wire_timer_proc(0);        //设置背光为127 (默认)  
  16.         create_proc_read_entry("driver/one-wire-info", 0, NULL, read_proc, NULL);  
  17.     }  
  18.       
  19.     if (ret == 0) {  
  20.         printk (TOUCH_DEVICE_NAME"\tinitialized\n");  
  21.         printk (BACKLIGHT_DEVICE_NAME"\tinitialized\n");  
  22.     }  
  23.     return ret;  
  24. }  
  25.   
  26.   
  27. static void __exit dev_exit(void)  
  28. {  
  29.     exitting = 1;  
  30.     remove_proc_entry("driver/one-wire-info", NULL);  
  31.     del_timer_sync(&one_wire_timer);  
  32.     free_irq(IRQ_TIMER3, &timer_for_1wire_irq);  
  33.     misc_deregister(&ts_misc);  
  34.     misc_deregister(&bl_misc);  
  35. }  

一线触屏状态机：

[cpp]  view plain copy
  1. enum {  
  2.     IDLE,  
  3.     START,  
  4.     REQUEST,  
  5.     WAITING,  
  6.     RESPONSE,  
  7.     STOPING,  
  8. } one_wire_status = IDLE;  
  9.   
  10. static volatile unsigned int io_bit_count;  
  11. static volatile unsigned int io_data;  
  12. static volatile unsigned char one_wire_request;  
  13. static irqreturn_t timer_for_1wire_interrupt(int irq, void *dev_id)  
  14. {  
  15.     io_bit_count--;  
  16.     switch(one_wire_status) {       
  17.     case START:                                       
  18.         if (io_bit_count == 0) {  
  19.             io_bit_count = 16;  
  20.             one_wire_status = REQUEST;  
  21.         }  
  22.         break;  
  23.   
  24.     case REQUEST:                                 
  25.         // Send a bit           
  26.         set_pin_value(io_data & (1U << 31));  
  27.         io_data <<= 1;  
  28.         if (io_bit_count == 0) {  
  29.             io_bit_count = 2;  
  30.             one_wire_status = WAITING;  
  31.         }  
  32.         break;  
  33.           
  34.     case WAITING:                               
  35.         if (io_bit_count == 0) {  
  36.             io_bit_count = 32;  
  37.             one_wire_status = RESPONSE;  
  38.         }  
  39.         if (io_bit_count == 1) {  
  40.             set_pin_as_input();  
  41.             set_pin_value(1);  
  42.         }  
  43.         break;  
  44.           
  45.     case RESPONSE:                          
  46.         // Get a bit                      
  47.         io_data = (io_data << 1) | get_pin_value();  
  48.         if (io_bit_count == 0) {  
  49.             io_bit_count = 2;  
  50.             one_wire_status = STOPING;  
  51.             set_pin_value(1);  
  52.             set_pin_as_output();  
  53.             one_wire_session_complete(one_wire_request, io_data);  
  54.         }  
  55.         break;  
  56.   
  57.     case STOPING:                     // 2  
  58.         if (io_bit_count == 0) {  
  59.             one_wire_status = IDLE;  
  60.             stop_timer_for_1wire();  
  61.         }  
  62.         break;  
  63.           
  64.     default:  
  65.         stop_timer_for_1wire();  
  66.     }  
  67.     return IRQ_HANDLED;  
  68. }  

（2）LCD的初始化

[cpp]  view plain copy
  1. void LCDTest()  
  2. {  
  3.     int i, j;  
  4.       
  5.     trace("Enter LCDTest().\r\n");  
  6.   
  7.     (*(volatile unsigned int *)0x7410800c)=0;   //Must be '0' for Normal-path instead of By-pass  
  8.   
  9.        
  10.      ///set GPE0  
  11.     //*(volatile unsigned int*)0x7F008080 = 0x00011111;     
  12.     //*(volatile unsigned int*)0x7F008084 = 0x00000001;  
  13.     //*(volatile unsigned int*)0x7F008088 = 0x00000000;  
  14.   
  15.     GPIO_SetLCDType(eRGBIF); //set LCD mode to RGB mode  
  16.       
  17.     //Set LCD GPIO Port  
  18.     GPIO_SetFunctionAll(eGPIO_I, 0xaaaaaaaa, 2); //GPI[15..0]-> RGB VD[15..0]  
  19.     GPIO_SetFunctionAll(eGPIO_J, 0xaaaaaaaa, 2); //GPJ[7..0]-> RGB VD[23..16], GPJ[11..8]-> VCLK, VDEN, VSYNC, HSYNC  
  20.       
  21.     GPIO_SetFunctionEach(eGPIO_E, eGPIO_0, 1); //GPF[15] -> Output  
  22.     GPIO_SetDataEach(eGPIO_E, eGPIO_0 , 1); //GPF[15] -> High  
  23.   
  24.     trace("LCD GPIO init ok.\r\n");  
  25.       
  26.     //other pin gpio not set yet.  
  27.     //LCD reset has not done  
  28.     //LCD cmd init has not done  
  29.       
  30.     //begin base display test.  
  31.     eBgWin = WIN0;  
  32.     eFgWin = WIN1;  
  33.       
  34.     /*  RGB 5-6-5 format for SMDK EVAL BOARD */  
  35.     eBgBpp = RGB16;  
  36.     eFgBpp = RGB16;  
  37.   
  38.     *(volatile unsigned long *)0x7E00F030 |= 1 << 3;  //set lcd clk enable in hclk_gate register  
  39.   
  40.       
  41.       
  42.     LCD_InitDISPC(eBgBpp, uLcdFbAddr, eBgWin, false);  
  43.     LCD_SetWinOnOff(1, eBgWin);  
  44.   
  45.   
  46.     trace("Invoke LCD_Start().\r\n");  
  47.     LCD_Start();  
  48.   
  49.     trace("Invoke set_bklight.\r\n");  
  50.       
  51.   
  52.     set_bklight();  
  53.   
  54. }  


[cpp]  view plain copy
  1. void LCD_InitBase(void)  
  2. {  
  3.     u32 uLcdCon;  
  4.     u32 uILcdIntCon;  
  5.     u32 uClkVal, uClkDir;  
  6.     CLK_SRC_m eVClkSrc;  
  7.     u32 uVidconReg;  
  8.     u32 i;  
  9.     LCD_WINDOW eWin;  
  10.   
  11.     oLcdc.m_bIsAutoBuf = false;  
  12.     oLcdc.m_uScanMode = 0; // progressive mode  
  13.     oLcdc.m_bIsLocalCalled[0] = false;  
  14.     oLcdc.m_bIsLocalCalled[1] = false;  
  15.     oLcdc.m_bIsLocalCalled[2] = false;  
  16.       
  17.       
  18.     /*set lcd clock source:  
  19.     CLKSEL_F_HCLK           (0<<2) 
  20.     CLKSEL_F_SYSCON         (1<<2) 
  21.     CLKSEL_F_EXTCLK         (3<<2) 
  22.     */  
  23.     oLcdc.m_uVideoClockSource = CLKSEL_F_HCLK;  
  24.     eVClkSrc = SRC_HCLK;  
  25.       
  26.     oLcdc.m_uLcdHSz = 800;  
  27.     oLcdc.m_uLcdVSz = 480;  
  28.     oLcdc.m_uVidOutFormat = VIDOUT_RGBIF;  
  29.     oLcdc.m_uDitherMode = RDITHPOS_5BIT|GDITHPOS_6BIT|BDITHPOS_5BIT;  
  30.     oLcdc.m_uDitherMode &= ~DITHERING_ENABLE;  
  31.       
  32.     LcdcOutp32(rVIDCON1, IHSYNC_INVERT | IVSYNC_INVERT);    //Check   
  33.           
  34.     LcdcOutp32(rVIDTCON0, VBPDE(S3CFB_VBP) | VBPD(S3CFB_VBP) | VFPD(S3CFB_VFP) | VSPW(S3CFB_VSW));  
  35.     LcdcOutp32(rVIDTCON1, VFPDE(S3CFB_VFP) | HBPD(S3CFB_HBP) | HFPD(S3CFB_HFP) | HSPW(S3CFB_HSW));  
  36.     LcdcOutp32(rVIDTCON2, LINEVAL(oLcdc.m_uLcdVSz-1) | HOZVAL(oLcdc.m_uLcdHSz-1));  
  37.     LcdcOutp32(rDITHMODE, oLcdc.m_uDitherMode); // Fixed Dithering Matrix  
  38.           
  39.     LCD_Stop();  
  40.       
  41.     //Check up LCD to turn off  
  42.       
  43.     while (1)  
  44.     {  
  45.         uLcdCon=Inp32(LCD_BASE+rVIDCON0);  
  46.         if( (uLcdCon&0x03) == 0 ) // checking whether disable the video output and the Display control signal or not.  
  47.         break;  
  48.     }  
  49.       
  50.     LCD_SetClkSrc(eVClkSrc);  
  51.       
  52.     /** 
  53.  * WARNING: CLKVAL is defined upon 133 MHz HCLK, please update it 
  54.  * when HCLK freq changed. 
  55.  *   VCLK = 133 MHz / (CLKVAL + 1) 
  56.  *   = ~33.25 MHz  
  57.  */  
  58.     uClkVal = 3;  
  59.     uClkDir = 1;  
  60.     uVidconReg =  
  61.         PROGRESSIVE | oLcdc.m_uVidOutFormat | SUB_16_MODE | MAIN_16_MODE | PNRMODE_RGB_P | CLKVALUP_ALWAYS |  
  62.         CLKVAL_F(uClkVal) | /*VCLKEN_DISABLE |*/ CLKDIR_F(uClkDir) | oLcdc.m_uVideoClockSource|  
  63.         ENVID_DISABLE | ENVID_F_DISABLE;  
  64.     LcdcOutp32(rVIDCON0, uVidconReg);  
  65.   
  66.     uILcdIntCon =Inp32(LCD_BASE+rVIDINTCON0);  
  67.     LcdcOutp32(rVIDINTCON0, 0);  
  68.     //LcdcOutp32(rVIDINTCON0, uILcdIntCon | FRAMESEL0_BACK | FRAMESEL1_NONE | INTFRMEN_DISABLE |  
  69.     //          FIFOSEL_WIN0 | FIFOLEVEL_25 | INTFIFOEN_DISABLE | INTEN_DISABLE);  
  70.       
  71.     LCD_SetAllWinOnOff(0); // Turn all windows off  
  72.     LCD_SetAllWinColorMapOnOff(0); // Turn all windows color map off  
  73.     LCD_SetAllWinColorKeyOnOff(0); // Turn all windows Color Key off  
  74.   
  75.     for (i=1; i<5; i++)  
  76.     {  
  77.         eWin =  
  78.             (i == 1) ? WIN1 :  
  79.             (i == 2) ? WIN2 :  
  80.             (i == 3) ? WIN3 : WIN4;  
  81.   
  82.         LCD_SetAlpha(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, eWin);  
  83.     }  
  84.       
  85. }  
  86.   
  87. void LCD_InitWinRegs(LCD_WINDOW eWin)  
  88. {  
  89.     u32 uWinConXReg;  
  90.     u32 uAlphaValReg;  
  91.     u32 uFrmBufStAddrReg;  
  92.     u32 uFrmBufEndAddrReg;  
  93.     u32 uOffsetPageWidthReg;  
  94.     u32 uOsdLeftPosReg;  
  95.     u32 uOsdRightPosReg;  
  96.     u32 uWinConXRegVal;  
  97.     u32 uLcdEndX, uLcdEndY;  
  98.       
  99.   
  100.   
  101.   
  102.     uWinConXReg =  
  103.         (eWin == WIN0) ? rWINCON0 :  
  104.         (eWin == WIN1) ? rWINCON1 :  
  105.         (eWin == WIN2) ? rWINCON2 :  
  106.         (eWin == WIN3) ? rWINCON3 : rWINCON4;  
  107.   
  108.     uAlphaValReg =  
  109.         (eWin == WIN1) ? rVIDOSD1C :  
  110.         (eWin == WIN2) ? rVIDOSD2C :  
  111.         (eWin == WIN3) ? rVIDOSD3C :  
  112.         (eWin == WIN4) ? rVIDOSD4C : rVIDOSD1C;  
  113.   
  114.     uFrmBufStAddrReg =  
  115.         (eWin == WIN0) ? rVIDW00ADD0B0 :  
  116.         (eWin == WIN1) ? rVIDW01ADD0B0:  
  117.         (eWin == WIN2) ? rVIDW02ADD0 :  
  118.         (eWin == WIN3) ? rVIDW03ADD0 : rVIDW04ADD0;  
  119.   
  120.     uFrmBufEndAddrReg =  
  121.         (eWin == WIN0) ? rVIDW00ADD1B0 :  
  122.         (eWin == WIN1) ? rVIDW01ADD1B0 :  
  123.         (eWin == WIN2) ? rVIDW02ADD1 :  
  124.         (eWin == WIN3) ? rVIDW03ADD1 : rVIDW04ADD1;  
  125.   
  126.     uOffsetPageWidthReg =  
  127.         (eWin == WIN0) ? rVIDW00ADD2 :  
  128.         (eWin == WIN1) ? rVIDW01ADD2 :  
  129.         (eWin == WIN2) ? rVIDW02ADD2 :  
  130.         (eWin == WIN3) ? rVIDW03ADD2 : rVIDW04ADD2;  
  131.   
  132.     uOsdLeftPosReg =  
  133.         (eWin == WIN0) ? rVIDOSD0A :  
  134.         (eWin == WIN1) ? rVIDOSD1A :  
  135.         (eWin == WIN2) ? rVIDOSD2A :  
  136.         (eWin == WIN3) ? rVIDOSD3A : rVIDOSD4A;  
  137.   
  138.     uOsdRightPosReg =  
  139.         (eWin == WIN0) ? rVIDOSD0B :  
  140.         (eWin == WIN1) ? rVIDOSD1B :  
  141.         (eWin == WIN2) ? rVIDOSD2B :  
  142.         (eWin == WIN3) ? rVIDOSD3B : rVIDOSD4B;  
  143.   
  144.     uWinConXRegVal = 0;  
  145.       
  146.     if (eWin == WIN0)  
  147.     {  
  148.         if (!oLcdc.m_bIsLocalCalled[0]) // Input path is DMA  
  149.         {  
  150.             uWinConXRegVal =  
  151.                 W0DMA | W0BUF0 | W0BUFAUTO_DISABLE | BITSWP_DISABLE |  
  152.                 oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode|  
  153.                 oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | oLcdc.m_uBppMode |  
  154.                 ENWIN_F_DISABLE;  
  155.               
  156.         }  
  157.         else // Input path is Local  
  158.         {  
  159.             //Assert(oLcdc.m_eLocalIn[0] == IN_POST);  
  160.   
  161.             if(oLcdc.m_uLocalInColorSpace[0] == LOCALIN_YCbCr)  
  162.             {  
  163.                 uWinConXRegVal =  
  164.                 W0LOCAL_POST | W0BUF0 | W0BUFAUTO_DISABLE | BITSWP_DISABLE |  
  165.                 oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode| IN_LOCAL_YUV |  
  166.                 oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | oLcdc.m_uBppMode |  
  167.                 ENWIN_F_DISABLE;  
  168.             }  
  169.             else  
  170.             {  
  171.                 uWinConXRegVal =  
  172.                 W0LOCAL_POST | W0BUF0 | W0BUFAUTO_DISABLE | BITSWP_DISABLE |  
  173.                 oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode| IN_LOCAL_RGB |  
  174.                 oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | oLcdc.m_uBppMode |  
  175.                 ENWIN_F_DISABLE;  
  176.             }  
  177.               
  178.         }  
  179.   
  180.         LcdcOutp32(rVIDW00ADD0B1, oLcdc.m_uDoubleBufStAddr[0]);  
  181.         LcdcOutp32(rVIDW00ADD1B1, oLcdc.m_uDoubleBufEndAddr[0]);  
  182.         LcdcOutp32(rVIDOSD0C, OSDSIZE(oLcdc.m_uViewHSz[0]*oLcdc.m_uViewVSz[0]));  
  183.     }  
  184.     else  
  185.     {  
  186.         if (eWin == WIN1)  
  187.         {  
  188.             if (!oLcdc.m_bIsLocalCalled[1]) // Input path is DMA  
  189.             {  
  190.                 uWinConXRegVal =  
  191.                     W0DMA | W0BUF0 | W0BUFAUTO_DISABLE | BITSWP_DISABLE |  
  192.                     oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode|  
  193.                     oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | BLD_PIX_PLANE | oLcdc.m_uBppMode |  
  194.                     BLEND_ALPHA0_PLANE | ENWIN_F_DISABLE;  
  195.             }  
  196.             else // Input path is Local  
  197.             {  
  198.                 //Assert(oLcdc.m_eLocalIn[1] == IN_POST || oLcdc.m_eLocalIn[1] == IN_CIM);  
  199.   
  200.                 if(oLcdc.m_uLocalInColorSpace[1] == LOCALIN_YCbCr)  
  201.                 {  
  202.                     uWinConXRegVal =  
  203.                     ((oLcdc.m_eLocalIn[1] == IN_CIM) ? W1ENLOCAL_CIM : W1ENLOCAL_POST) |  
  204.                     W1LOCAL| W0BUF0 | W0BUFAUTO_DISABLE | BITSWP_DISABLE |  
  205.                     oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode| IN_LOCAL_YUV |  
  206.                     oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | BLD_PIX_PLANE | oLcdc.m_uBppMode |  
  207.                     BLEND_ALPHA0_PLANE | ENWIN_F_DISABLE;  
  208.                 }  
  209.                 else  
  210.                 {  
  211.                     uWinConXRegVal =  
  212.                     ((oLcdc.m_eLocalIn[1] == IN_CIM) ? W1ENLOCAL_CIM : W1ENLOCAL_POST) |  
  213.                     W1LOCAL| W0BUF0 | W0BUFAUTO_DISABLE | BITSWP_DISABLE |  
  214.                     oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode| IN_LOCAL_RGB |  
  215.                     oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | BLD_PIX_PLANE | oLcdc.m_uBppMode |  
  216.                     BLEND_ALPHA0_PLANE | ENWIN_F_DISABLE;  
  217.                 }     
  218.             }  
  219.               
  220.             // set double buf. addr. and offset size  
  221.             LcdcOutp32(rVIDW01ADD0B1, oLcdc.m_uDoubleBufStAddr[1]);  
  222.             LcdcOutp32(rVIDW01ADD1B1, oLcdc.m_uDoubleBufEndAddr[1]);  
  223.   
  224.             LcdcOutp32(rVIDOSD1D, OSDSIZE(oLcdc.m_uViewHSz[1]*oLcdc.m_uViewVSz[1]));              
  225.         }  
  226.         else // eWin == WIN2 OR WIN3 OR WIN4  
  227.         {  
  228.             if (eWin == WIN2)  
  229.             {  
  230.                 if (!oLcdc.m_bIsLocalCalled[2]) // Input path is DMA  
  231.                 {  
  232.                     uWinConXRegVal =  
  233.                         W0DMA | BITSWP_DISABLE |  
  234.                         oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode|  
  235.                         oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | BLD_PIX_PLANE | oLcdc.m_uBppMode |  
  236.                         BLEND_ALPHA0_PLANE | ENWIN_F_DISABLE;  
  237.                 }  
  238.                 else // Input path is Local  
  239.                 {  
  240.                     //Assert(oLcdc.m_eLocalIn[2] == IN_POST || oLcdc.m_eLocalIn[2] == IN_CIM);  
  241.   
  242.                     if(oLcdc.m_uLocalInColorSpace[2] == LOCALIN_YCbCr)  
  243.                     {  
  244.                       
  245.                         uWinConXRegVal =  
  246.                         ((oLcdc.m_eLocalIn[2] == IN_CIM) ? W1ENLOCAL_CIM : W1ENLOCAL_POST) |   
  247.                         W1LOCAL | BITSWP_DISABLE |oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode| IN_LOCAL_YUV |  
  248.                         oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | BLD_PIX_PLANE | oLcdc.m_uBppMode |  
  249.                         BLEND_ALPHA0_PLANE | ENWIN_F_DISABLE;  
  250.                     }  
  251.                     else   
  252.                     {  
  253.                           
  254.                         uWinConXRegVal =  
  255.                         ((oLcdc.m_eLocalIn[2] == IN_CIM) ? W1ENLOCAL_CIM : W1ENLOCAL_POST) |   
  256.                         W1LOCAL | BITSWP_DISABLE |oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode| IN_LOCAL_RGB |  
  257.                         oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen | BLD_PIX_PLANE | oLcdc.m_uBppMode |  
  258.                         BLEND_ALPHA0_PLANE | ENWIN_F_DISABLE;  
  259.                     }  
  260.                       
  261.                 }  
  262.   
  263.                 LcdcOutp32(rVIDOSD2D, OSDSIZE(oLcdc.m_uViewHSz[2]*oLcdc.m_uViewVSz[2]));                  
  264.             }  
  265.             else // eWin == WIN3 || eWin == WIN4  
  266.             {  
  267.                 uWinConXRegVal =   
  268.                     BITSWP_DISABLE | oLcdc.m_uBytSwpMode | oLcdc.m_uHawSwpMode |  
  269.                     oLcdc.m_uMinBurstLen | oLcdc.m_uMaxBurstLen |  
  270.                     BLD_PIX_PLANE | oLcdc.m_uBppMode | BLEND_ALPHA0_PLANE | ENWIN_F_DISABLE;  
  271.             }  
  272.         }  
  273.   
  274.         LcdcOutp32(uAlphaValReg,  
  275.             ALPHA0_R(0xF) | ALPHA0_G(0xF) | ALPHA0_B(0xF) |  
  276.             ALPHA1_R(0xF) | ALPHA1_G(0xF)| ALPHA1_B(0xF));  
  277.     }  
  278.   
  279.     LcdcOutp32(uWinConXReg, uWinConXRegVal);          
  280.     LcdcOutp32(uFrmBufStAddrReg, oLcdc.m_uFbStAddr[eWin]);  
  281.     LcdcOutp32(uFrmBufEndAddrReg, oLcdc.m_uFbEndAddr[eWin]);  
  282.     LcdcOutp32(uOffsetPageWidthReg, (oLcdc.m_uOffsetSz[eWin]<<13) | oLcdc.m_uPageWidth[eWin]);  
  283.   
  284.     uLcdEndX = oLcdc.m_uLcdStX + oLcdc.m_uViewHSz[eWin] - 1;  
  285.     uLcdEndY = oLcdc.m_uLcdStY + oLcdc.m_uViewVSz[eWin] - 1;  
  286.   
  287.     if (oLcdc.m_uScanMode == 1) // Interlace mode  
  288.     {  
  289.         //Assert(!(oLcdc.m_uLcdStX%2)); // Left top -> Y coordinate must be even number in interlace mode  
  290.         //Assert(uLcdEndY%2);           // Rigth bottom -> Y coordinate must be odd number in interlace mode  
  291.   
  292.         // In interlace mode, Left Top Y(oLcdc.m_uLcdStY) and Right Bottom Y(uLcdEndY) must be divided by 2.  
  293.         // And, Right Bottom Y must be rounded down  
  294.         LcdcOutp32(uOsdLeftPosReg, OSD_LTX_F(oLcdc.m_uLcdStX) | (OSD_LTY_F(oLcdc.m_uLcdStY)>>1));  
  295.         LcdcOutp32(uOsdRightPosReg, OSD_RBX_F(uLcdEndX) | (OSD_RBY_F(uLcdEndY)>>1));  
  296.     }  
  297.     else // Progressive mode  
  298.     {  
  299.         LcdcOutp32(uOsdLeftPosReg, OSD_LTX_F(oLcdc.m_uLcdStX) | OSD_LTY_F(oLcdc.m_uLcdStY));  
  300.         LcdcOutp32(uOsdRightPosReg, OSD_RBX_F(uLcdEndX) | OSD_RBY_F(uLcdEndY));  
  301.     }  
  302. }  
  303.   
  304. void LCD_SetWinOnOff(u32 uOnOff, LCD_WINDOW eWin)  
  305. {  
  306.     u32 uWinTemp;  
  307.     u32 uWinConReg;  
  308.   
  309.     uWinConReg =  
  310.         (eWin == WIN0) ? rWINCON0 :  
  311.         (eWin == WIN1) ? rWINCON1 :  
  312.         (eWin == WIN2) ? rWINCON2 :  
  313.         (eWin == WIN3) ? rWINCON3 : rWINCON4;  
  314.   
  315.     uWinTemp=Inp32(LCD_BASE+uWinConReg);  
  316.   
  317.     if (uOnOff) // Turn OSD on  
  318.         uWinTemp |= ENWIN_F_ENABLE;  
  319.     else // Turn OSD off  
  320.         uWinTemp &= ~ENWIN_F_ENABLE;  
  321.   
  322.     LcdcOutp32(uWinConReg, uWinTemp);  
  323. }  
  324.   
  325.   
  326. void LCD_InitWin(CSPACE eBpp,   
  327.                   u32 uFrameH,        //800  
  328.                   u32 uFrameV,       //480  
  329.                   u32 uX_Frame,    //0  
  330.                   u32 uY_Frame,   //0  
  331.                   u32 uViewH,       //800  
  332.                   u32 uViewV,       //480  
  333.                   u32 uX_Lcd,       //0  
  334.                   u32 uY_Lcd,      //0  
  335.                   u32 uFbAddr,     //  
  336.                   LCD_WINDOW eWin,  
  337.                   u8 bIsDoubleBuf)  
  338. {  
  339.     u32 uOffset;  
  340.     //u32 uLineVal;  
  341.     u32 uBurstSize;  
  342.   
  343.     //if ( (eWin != WIN0 && eWin != WIN1) && bIsDoubleBuf == true )  
  344.     //  Assert(0); // In WIN2, WIN3 or WIN4, Double buffering can't be supported  
  345.   
  346.     // Viewport size must be less than LCD size  
  347.     //Assert(uViewH <= oLcdc.m_uLcdHSz);  
  348.     //Assert(uViewV <= oLcdc.m_uLcdVSz);  
  349.   
  350.     // Check (X,Y) coordinate is valid in LCD and Frame?  
  351.     //Assert( ((uX_Frame + uViewH) <= uFrameH) && ((uY_Frame + uViewV) <= uFrameV) );  
  352.     //Assert( (uX_Lcd + uViewH <= oLcdc.m_uLcdHSz) && (uY_Lcd + uViewV <= oLcdc.m_uLcdVSz) );  
  353.   
  354.     // Double buffering is supported by only window 0 and window 1  
  355.     //if ( ((eWin != WIN0) && (eWin != WIN1)) && (bIsDoubleBuf == true) )  
  356.     //  Assert(0);  
  357.   
  358.     oLcdc.m_uFrmHSz[eWin] = uFrameH;   //800  
  359.     oLcdc.m_uFrmVSz[eWin] = uFrameV;   //480  
  360.   
  361.     oLcdc.m_uViewHSz[eWin] = uViewH;   //800  
  362.     oLcdc.m_uViewVSz[eWin] = uViewV;   //480  
  363.   
  364.     oLcdc.m_uLcdStX = uX_Lcd;     //0  
  365.     oLcdc.m_uLcdStY = uY_Lcd;     //0  
  366.   
  367.     uOffset = oLcdc.m_uFrmHSz[eWin] - oLcdc.m_uViewHSz[eWin];   //=0  
  368.   
  369.     oLcdc.m_uBytSwpMode = BYTSWP_DISABLE;       // BYTE swap disable  
  370.     oLcdc.m_uHawSwpMode = HAWSWP_DISABLE;       // Half-Word swap disable  
  371.   
  372.     oLcdc.m_uMaxBurstLen = MAX_BURSTLEN_16WORD;     // DMA'burst max 16word burst  
  373.     oLcdc.m_uMinBurstLen = MIN_BURSTLEN_16WORD;     // DMA'burst min 16 word burst  
  374.   
  375.   
  376.     //m_uBytes濂藉儚鏄鍗犲灏戜釜瀛楄妭锛屽鏋滃皬浜庝竴涓瓧鑺傦紝閭ｄ箞m_uBytes=1锛屽苟涓攎_uBits琛ㄧず鍗犲灏戜綅銆?  
  377.       
  378.   
  379.   
  380.     //else if (eBpp == RGB16)  
  381.     //{  
  382.         oLcdc.m_uBytes = 2;  
  383.         oLcdc.m_uBits = 1;  
  384.         //Assert( !(uOffset%2) ); // Must keep to word-alignment  
  385.   
  386.         oLcdc.m_uBppMode = BPPMODE_F_16BPP_565;  //5<<2  
  387.         oLcdc.m_uHawSwpMode = HAWSWP_ENABLE;    // 1<<16  
  388.     //}  
  389.       
  390.   
  391.     // Get offsetsize, pagewidth and lineVal  
  392.     if (oLcdc.m_uFrmHSz[eWin] >= oLcdc.m_uViewHSz[eWin])  
  393.     {  
  394.         oLcdc.m_uOffsetSz[eWin] = uOffset*oLcdc.m_uBytes/oLcdc.m_uBits;      //0  
  395.         oLcdc.m_uPageWidth[eWin] = oLcdc.m_uViewHSz[eWin]*oLcdc.m_uBytes/oLcdc.m_uBits;  //=1600  
  396.   
  397.         // Offset size must be more than the burst size  
  398.         uBurstSize =  
  399.             (oLcdc.m_uMaxBurstLen == MAX_BURSTLEN_16WORD) ? 16*4 :   //16  
  400.             (oLcdc.m_uMaxBurstLen == MAX_BURSTLEN_8WORD) ? 8*4 : 4*4;  
  401.   
  402.         // Offset size must be more than the burst size  
  403.         //Assert( oLcdc.m_uOffsetSz[eWin] == 0 || !(oLcdc.m_uOffsetSz[eWin]%4) );  
  404.         //Assert(oLcdc.m_uPageWidth[eWin] > uBurstSize); // Page width must be more than burst size and be word-aligned  
  405.   
  406.         //uLineVal = oLcdc.m_uViewVSz[eWin] - 1;  
  407.     }   
  408.     else  
  409.     {  
  410.         //Assert(0);  
  411.     }  
  412.   
  413.     oLcdc.m_uImgStAddr[eWin] = uFbAddr;  
  414.   
  415.     oLcdc.m_uFbStAddr[eWin] = uFbAddr + (oLcdc.m_uFrmHSz[eWin]*uY_Frame + uX_Frame)*oLcdc.m_uBytes/oLcdc.m_uBits;  //= uFbAddr  
  416.     oLcdc.m_uFbEndAddr[eWin] = oLcdc.m_uFbStAddr[eWin] + (oLcdc.m_uOffsetSz[eWin]+oLcdc.m_uPageWidth[eWin])*(uFrameV);  //uFbAddr + 1600*480  
  417.   
  418.     if ( (bIsDoubleBuf == true) && ((eWin == WIN0) || (eWin == WIN1)) )  
  419.     {  
  420.         oLcdc.m_uDoubleBufImgStAddr[eWin] = oLcdc.m_uImgStAddr[eWin] + oLcdc.m_uFrmHSz[eWin]*oLcdc.m_uFrmVSz[eWin]*oLcdc.m_uBytes/oLcdc.m_uBits;  
  421.         oLcdc.m_uDoubleBufStAddr[eWin] = oLcdc.m_uFbStAddr[eWin] + oLcdc.m_uFrmHSz[eWin]*oLcdc.m_uFrmVSz[eWin]*oLcdc.m_uBytes/oLcdc.m_uBits;  
  422.         oLcdc.m_uDoubleBufEndAddr[eWin] = oLcdc.m_uDoubleBufStAddr[eWin] + (oLcdc.m_uOffsetSz[eWin]+oLcdc.m_uPageWidth[eWin])*(uFrameV);  
  423.     }  
  424.     else if ( (bIsDoubleBuf == false) && ((eWin == WIN0) || (eWin == WIN1)) )  
  425.     {  
  426.         oLcdc.m_uDoubleBufStAddr[eWin] = oLcdc.m_uFbStAddr[eWin];  
  427.         oLcdc.m_uDoubleBufEndAddr[eWin] = oLcdc.m_uFbEndAddr[eWin];  
  428.     }  
  429.   
  430.     LCD_InitWinRegs(eWin);  
  431.   
  432.     // For back-ward compatibility LCDC V2.0  
  433.     if(eWin == WIN0)  
  434.         LCD_SetWinOnOff(1, WIN0); // first arguement == 1 -> turn on window  
  435. }  

（3）显示图像

裸机S3C6410显示控制器(4)- 显示图像到屏幕



标签：

相关文章