S5PV210的LCD控制器详解

1、FIMD结构框图

(1)Samsung的s5pv210的LCD控制器叫做FIMD（也叫显示控制器）。Display controller（显示控制器）包括用于将图像数据从相机接口控制器的本

地总线或位于系统存储器（例如：显存）中的视频缓冲器传送到外部LCD驱动器接口的逻辑。 LCD驱动接口支持三种接口，即RGB接口，I80接口和YUV

接口。显示控制器使用多达五个覆盖图像窗口（也就是虚拟窗口win0-win4），其支持各种颜色格式，如RGB、YUV。

FIMD在内部与AHB总线等相连接，在外部提供RGB接口、I80接口、YUV接口与外部相连接，我们实际使用的是RGB接口。这个接口就是我在上一篇博文中说的

LCD控制器的数据输出接口。RGB接口传输的是RGB编码的颜色数据，同理YUV接口传输的就是YUV编码的颜色数据，至于I80我不了解。本文讨论也是RGB接口。

(2)RGB接口信号

LCD_HSYNC ：水平同步信号

LCD_VSYNC：垂直同步信号

LCD_VCLK：像素时钟，LCD工作时需要主板控制器给LCD模组一个工作时钟信号，就是VCLK

LCD_VDEN：数据有效标志，时序信号，和HSYNC、VSYNC结合使用。

LCD_VD[23:0]：24根数据线，用来传输图像信息。可见LCD是并行接口，速率才够快。

2、LCD显示一帧图像的过程

(1)LCD显示单位：帧（frame）

显示器上一整个画面的内容成为一个帧(frame)，整个显示器工作时是一帧一帧的在显示。

帧内数据：一帧分为多行，一行分为多像素，因此一帧图像其实就是多个像素组成的矩阵。

帧外数据：整个视频由很多个帧构成，最终播放视频时逐个播放各个图像帧即可。

(2)显示一帧图像

首先把帧分为行，然后再把行分为像素，然后逐个像素去显示。（显示像素：其实就是LCD驱动器按照接收到的LCD控制器给的显示数据，驱动一个像素的液晶分子旋转，让

这个像素显示出相应的颜色值的过程）。

关键点：LCD控制器和驱动器之间一次只能传一个像素点的显示数据。所以一帧图像在屏幕上其实是串行的依次被显示上去的，不是同一时间显示出来的。

(3)为了向前兼容出现的六个时序参数

HSPW 水平同步信号脉宽

HBPD 水平同步信号前肩
HFPD 水平同步信号后肩
VSPW 垂直同步信号脉宽
VBPD 垂直同步信号前肩
VFPD 垂直同步信号后肩

(3.1)一行的通信过程是这样的：LCD控制器先发送一个HSYNC高电平脉冲（脉冲宽度是HSPW
），脉冲告诉驱动器下面的信息是一行信息。然后开始这一行信息，这一行信息包括3部
分：HBPD+有效行信息+HFPD。其中前肩和后肩都属于时序信息（和LCD屏幕具体有关），
有效行信息就是横向分辨率。所以你可以认为一行总共包含4部分：HSPW+HBPD+有效行信
息+HFPD。
(3.2)一帧图像其实就是一列，一列图像由多个行组成，每行都是上面讲的这个时序。
(3.3)一帧图像的通信过程是这样的：整个帧图像信号分为4部分：VSPW+VBPD+帧有效信号
+VFPD。VSPW是帧同步信号宽度，用来告诉驱动器一帧图像要开始了；VBPD和VFPD分别是
垂直同步信号前后肩。
(3.4)必须说明：这6个参数对于LCD显示器其实本来是没用的，这些信号其实是老式的CRT
显示器才需要的，LCD本身不需要，但是出于历史兼容性要求，LCD选择了兼容CRT显示器
的这些时序要求，所以理解LCD显示器时序和编程时，用CRT的方式来理解不会错。
(3.5)要注意，这几个时序参数本身是LCD屏幕本身的参数，与LCD控制器无关。所以同一个
主板如果接的屏幕不一样则时序参数设置也会不同。这些参数的来源一般是：第一，厂
家会直接给出，一般以实例代码的形式给出；第二，来自于LCD的数据手册。

2、虚拟屏幕叠加

(1)虚拟屏幕的意思是，我们平时看到的屏幕上显示出来的场景实际是很多个屏幕显示叠加在一起的效果（譬如新闻图像、电视台台标、下方飘动的字幕新闻）。

(2)像S5PV210的LCD控制器中有5个虚拟屏幕Window0到Window4，虚拟屏幕不存在于真实而存在于内存中。（之前讲过，LCd显示时实际是显示的是对应的内存

中的显存区域的数值）虚拟屏幕其实就是一个内存中的显存区域，有几个显存区域就有几个虚拟屏幕，但是这些虚拟屏幕都被映射到一个真实的显示屏上面，所以将

来真实的现实效果实际是这几个虚拟屏幕的显示内容的叠加。（叠加时要注意上面一层会覆盖下面一层，所以要注意谁在前谁在后，设置寄存器时有这个选项）。

(3)使用虚拟屏幕而不是整个LCD使用一个显存是有一定好处的：第一，可以保证不污染源图像，方便程序处理；第二，可以减少屏幕刷新，提高显示效率，减少CPU工作量。

3、虚拟显示

(1)如何实现在小分辨率的屏幕上（真实）显示大分辨率的图像？

细节上，我们需要屏幕上看到不同图像时，需要对显存区域进行刷新。即使我们只需要屏幕显示移动一点点，整个屏幕对应的显存空间也需要整个重新刷新，工作量和完全

重新显示一幅图像是一样的。这个显然不好，这样CPU刷新屏幕的工作量太大了，效率很低。

如何能够在显示一个大图片的不同区域时让CPU刷新屏幕工作量减少？

有，方法就是虚拟显示。具体做法就是在内存中建立显示缓存的时候实际建立一个很大的区域，然后让LCD去对应其中的一部分区域作为有效的显示区域。将来要显示大图像

时，直接将大图像全部一次性加载入显示缓存区，然后通过移动有效显示区域就可以显示大图像的不同区域了。

4、LCD控制器的主要寄存器

LCD相关寄存器寄存器介绍：因为这里面的寄存器实在太多了，我们的一个原则就是能够 

让LCD工作就行了，所以很多寄存器我们都没有涉及到，同一个寄存器中有些位也是没有
涉及到的，所以需要用到的位我们就设置，不需要我们暂且不管，如果以后做方面相关
的时候再去好好研究。

(1)VIDCON0：

bit[0]: 当前帧结束后是否使能视频输出控制器，也就是一帧画面显示结束后是否使能
LCD控制器,1使能 0禁止
bit[1]: 使能视频输出控制器（指的是当前） 1使能 0禁止
bit[2]: 时钟源选择 0=HCLK_DSYS 1=SCLK_FIMD
bit[13:6]: 时钟源分频器分频系数设置 本LCd控制器时钟不超过100MHZ，最终的时钟频
率是需要考虑LCD控制器和LCD驱动器两个方面，要低于两个中的最小值。
bit[4]: 时钟控制，使用分频器设置后的时钟还是源时钟，0是源时钟 1是分频器设置
后 的时钟。
bit[18]: 选择显示的模式，0是RGB并行模式 1是RGB串行模式
bit[28:26]: 选择视频输出格式，000=RGB接口 010=I80接口 011=I80接口...

(2)VIDCON1：
bit[4]: VSYNC信号反转控制，要跟LCd驱动器的电平要一致
bit[5]: HSYNC信号反转控制，要跟LCD驱动器的电平要一致

(3)VIDTCON0：
bit[7:0]: VSPW设置，意思在上面已经说过
bit[15:8]: VFPD设置
bit[23:16]: VBPD设置

(4)VIDTCON1：
bit[7:0]: HSPW设置
bit[15:8]: HFPD设置
bit[23:16]: HBPD设置

(5)VIDTCON2：
bit[10:0]: 显示水平大小设置，水平分辨率
bit[21:11]: 显示垂直大小设置，垂直分辨率

(6)WINCON0，WINCON1，WINCON2，WINCON3，WINCON4：
分别设置5个虚拟显示，对应分配的5个显存
bit[0]: 使能位，0禁止当前显存 1使能当前显存
bit[5:2]: 选择像素深度（bpp）
0000=1bpp 0001=2bpp 0010=4bpp.....1011=24bpp(R:8 G:8 B:8)
bit[15]: 像素交换使能控制位，像素交换就是 24位数据怎么分布的问题，是RGB还是
BGR
0禁止 1使能交换

(7)VIDOSD0A，VIDOSD1A，VIDOSD2A，VIDOSD3A....
用来设置虚拟显存的位置相关的
bit[10:0]: 指定左上像素的垂直坐标
bit[21:11]: 指定左上像素的水平坐标

(8)VIDOSD0B................
bit[10:0]: 指定右下角像素的垂直坐标
bit[21:11]: 指定右下角像素的水平坐标

(9)VIDOSD0C....... 设置显存的大小、注意显存的大小可以大于LCD实际的一帧数据的大
小的，这是需要理解的。
bit[23:0]: 注意这里设置其实是以像素为单位的，也就是说这里设置的是我们的显存
的

(10)VIDW00ADD0B0（分为5组）分别对应我们的5个虚拟显存
bit[31:0]: 显存的内存地址设置 ， 将地址值写入这个寄存器

VIDW00ADD1B0（分为5组）分别对应我们的5个虚拟显存
bit[31:0]: 显存的大小，以字节为单位

SHADOWCON：用来设置我们的5个虚拟显存使能控制位和叠加方式寄存器，如果我们显示
的图片是需要叠加的话是需要好好看看这里的。
bit[0]: win0显存使能控制开关 0禁止 1使能 所以由此可知我们的每一个虚拟显存
的使能开关有两个一个就是在各自的寄存器上，另一个就是在这里集中的控制
，当然我们还有总的视频控制输出开关，之前说过了。
....

/*************************************************************************************/

附上裸机下操作LCD控制器的代码：（基于：S5PV210平台）

#define HSPW             (40)                // 1~40 DCLK
#define HBPD            (10 - 1)            // 46
#define HFPD             (240 - 1)            // 16 210 354
#define VSPW            (20)                // 1~20 DCLK
#define VBPD             (10 - 1)            // 23
#define VFPD             (30 - 1)            // 7 22 147

#define FB_ADDR            (0x23000000)
#define ROW                (600)
#define COL                (1024)
#define HOZVAL            (COL-1)
#define LINEVAL            (ROW-1)

#define XSIZE            COL
#define YSIZE            ROW

#define LeftTopX     0
#define LeftTopY     0
#define RightBotX   1023
#define RightBotY   599

#define  GPF0CON   (*(volatile unsigned int *)0xE0200120)
#define  GPF1CON   (*(volatile unsigned int *)0xE0200140)
#define  GPF2CON   (*(volatile unsigned int *)0xE0200160)
#define  GPF3CON   (*(volatile unsigned int *)0xE0200180)

#define  GPD0CON   (*(volatile unsigned int *)0xE02000A0)
#define  GPD0DAT   (*(volatile unsigned int *)0xE02000A4)

#define  DISPLAY_CONTROL   (*(volatile unsigned int *)0xE0107008)

#define  VIDCON0   (*(volatile unsigned int *)0xF8000000) 
#define  VIDCON1   (*(volatile unsigned int *)0xF8000004)

#define  VIDTCON0  (*(volatile unsigned int *)0xF8000010)
#define  VIDTCON1  (*(volatile unsigned int *)0xF8000014)
#define  VIDTCON2  (*(volatile unsigned int *)0xF8000018)
#define  VIDOSD0A  (*(volatile unsigned long *)0xF8000040)
#define  VIDOSD0B  (*(volatile unsigned long *)0xF8000044)
#define  VIDOSD0C  (*(volatile unsigned long *)0xF8000048)
#define  VIDW00ADD0B0     (*(volatile unsigned long *)0xF80000A0)
#define  VIDW00ADD1B0     (*(volatile unsigned long *)0xF80000D0)
#define  WINCON0         (*(volatile unsigned long *)0xF8000020)
#define  SHADOWCON         (*(volatile unsigned long *)0xF8000034)


typedef unsigned int u32;
typedef unsigned short u16;


/*填充像素点*/
static inline void lcd_draw_pixel(u32 x, u32 y, u32 color)
{
    *(u32 *)(FB_ADDR + (COL*x + y)*4) = color;
}

/*填充LCD背景*/
void lcd_draw_background(const u32 color)
{
     u32 i = 0;
     u32 j = 0;
     
     for (i = 1; i <= ROW; ++i)
     {
         for (j = 0; j <= COL; ++j)
             lcd_draw_pixel(i, j, color);
     }
} 

/*在LCd上绘制水平线*/
void lcd_draw_lline(const u32 x, const u32 y, const u32 length,
                     const u32 width, const u32 color)              
{
    volatile u32 i = 0;
    volatile u32 j = 0;
    
    for (i = x; i < width+x; i++)
    {
        for (j = y; j < length+y; j++)
        {
            lcd_draw_pixel(i, j, color);
        }
    }    
}

/*在LCd上绘制垂直线*/
void lcd_draw_vline(const u32 x, const u32 y, const u32 length,
                     const u32 width, const u32 color)
{
    volatile u32 i = 0;
    volatile u32 j = 0;
    
    for (i = x; i < length+x; i++)
    {
        for (j = y; j < width+y; j++)
        {
            lcd_draw_pixel(i, j, color);
        }
    }
}

// glib库中的画线函数，可以画斜线，线两端分别是(x1, y1)和(x2, y2)
void glib_line(unsigned int x1, unsigned int y1, 
                  unsigned int x2, unsigned int y2, unsigned int color)
{
    int dx,dy,e;
    dx=x2-x1; 
    dy=y2-y1;
    
    if(dx>=0)
    {
        if(dy >= 0) // dy>=0
        {
            if(dx>=dy) // 1/8 octant
            {
                e=dy-dx/2;  
                while(x1<=x2)
                {
                    lcd_draw_pixel(x1,y1,color);
                    if(e>0){y1+=1;e-=dx;}    
                    x1+=1;
                    e+=dy;
                }
            }
            else        // 2/8 octant
            {
                e=dx-dy/2;
                while(y1<=y2)
                {
                    lcd_draw_pixel(x1,y1,color);
                    if(e>0){x1+=1;e-=dy;}    
                    y1+=1;
                    e+=dx;
                }
            }
        }
        else           // dy<0
        {
            dy=-dy;   // dy=abs(dy)

            if(dx>=dy) // 8/8 octant
            {
                e=dy-dx/2;
                while(x1<=x2)
                {
                    lcd_draw_pixel(x1,y1,color);
                    if(e>0){y1-=1;e-=dx;}    
                    x1+=1;
                    e+=dy;
                }
            }
            else     // 7/8 octant
            {
                e=dx-dy/2;
                while(y1>=y2)
                {
                    lcd_draw_pixel(x1,y1,color);
                    if(e>0){x1+=1;e-=dy;}    
                    y1-=1;
                    e+=dx;
                }
            }
        }    
    }
    else //dx<0
    {
        dx=-dx;        //dx=abs(dx)
        if(dy >= 0) // dy>=0
        {
            if(dx>=dy) // 4/8 octant
            {
                e=dy-dx/2;
                while(x1>=x2)
                {
                    lcd_draw_pixel(x1,y1,color);
                    if(e>0){y1+=1;e-=dx;}    
                    x1-=1;
                    e+=dy;
                }
            }
            else        // 3/8 octant
            {
                e=dx-dy/2;
                while(y1<=y2)
                {
                    lcd_draw_pixel(x1,y1,color);
                    if(e>0){x1-=1;e-=dy;}    
                    y1+=1;
                    e+=dx;
                }
            }
        }
        else           // dy<0
        {
            dy=-dy;   // dy=abs(dy)

            if(dx>=dy) // 5/8 octant
            {
                e=dy-dx/2;
                while(x1>=x2)
                {
                    lcd_draw_pixel(x1,y1,color);
                    if(e>0){y1-=1;e-=dx;}    
                    x1-=1;
                    e+=dy;
                }
            }
            else        // 6/8 octant
            {
                e=dx-dy/2;
                while(y1>=y2)
                {
                    lcd_draw_pixel(x1,y1,color);
                    if(e>0){x1-=1;e-=dy;}    
                    y1-=1;
                    e+=dx;
                }
            }
        }    
    }
}

//画圆函数，圆心坐标是(centerX, centerY)，半径是radius，圆的颜色是color
void draw_circular(unsigned int centerX, unsigned int centerY, 
                       unsigned int radius, unsigned int color)
{
    int x,y ;
    int tempX,tempY;;
    int SquareOfR = radius*radius;

    for(y=0; y<XSIZE; y++)
    {
        for(x=0; x<YSIZE; x++)
        {
            if(y<=centerY && x<=centerX)
            {
                tempY=centerY-y;
                tempX=centerX-x;                        
            }
            else if(y<=centerY&& x>=centerX)
            {
                tempY=centerY-y;
                tempX=x-centerX;                        
            }
            else if(y>=centerY&& x<=centerX)
            {
                tempY=y-centerY;
                tempX=centerX-x;                        
            }
            else
            {
                tempY = y-centerY;
                tempX = x-centerX;
            }
            if ((tempY*tempY+tempX*tempX)<=SquareOfR)
                lcd_draw_pixel(x, y, color);
        }
    }
}


void lcd_draw_Chinese(const u32 x, const u32 y, 
                     const u32 color, const char *Chinese)
{
    u32 j = 0;
    u32 count = 0;
    u32 g = 0;
    u32 y1 = y;
    const unsigned char *ptr = (unsigned char *)0;
    
    if (*Chinese == 'd')
        ptr = deng;
    else
        ptr = tao;
    
    for (g = x; g < x+97; g++)
    {
        u32 i = 0;
        u32 k = 0;
        
        for (i = count; i < count +12; i++)
        {
            for (j = 0, k = y1; j <= 7; j++, k++)
            {
                if (((1 << j) & ptr[count]) == 1)
                    lcd_draw_pixel(x, k, color);                    
            }
            
            y1 = k;    //更新y值
        }
        
        y1 = y;
        
        count = i;        //更新count计数
    }
}                     


void lcd_init(void)
{
    /*GPIO初始化*/
    GPF0CON = 0x22222222;
    GPF1CON = 0x22222222;
    GPF2CON = 0x22222222;
    GPF3CON = 0x332222;
    
    /*打开LCD背光*/
    GPD0CON &= ~(0xf << 0); 
    GPD0CON |= (1 << 0);     //配置为输出模式
    GPD0DAT &= ~(1 << 0);    //输出为低电平
    
    /*设置RGB格式由FIMD输出 其实就是指定GRB格式由FIMD输出*/  // Display path selection
    DISPLAY_CONTROL = 2 << 0;                // RGB=FIMD I80=FIMD ITU=FIMD
    
    /*CON0寄存器配置*/
    VIDCON0 &= ~((1 << 18) | (7 << 26));     //选择显示模式和输出格式
    VIDCON0 &= ~(1 << 2);                   //选择时钟源HCLK
    VIDCON0 &= ~(0xff << 6);               
    VIDCON0 |= ((4 << 6) | (1 << 4));       //设置分频器系数和使能分频器  
    VIDCON0 |= ((1 << 0)|(1 << 1)) ;        //使能视频输出和使能帧结束视频输出    
    
    /*CON1寄存器配置*/
    VIDCON1 |= ((1<<5) | (1<<6));           //VSYNC和HSYNC信号反转，是否反转与LCd显示器相关
    
    /*关于时序的6个参数的设置*/
    VIDTCON0 &= ~(0xffffff << 0);
    VIDTCON0 |= (VSPW << 0) | (VFPD << 8) | (VBPD << 16);
    VIDTCON1 &= ~(0xffffff << 0);
    VIDTCON1 |= (HSPW << 0) | (HFPD << 8) | (HBPD << 16);
    
    /*设置LCD像素，对应实际的LCd像素*/
    VIDTCON2 &= ~(0x3fffff << 0);
    VIDTCON2 |= (LINEVAL << 11) | (HOZVAL << 0);
    
    /*设置window0的像素空间范围和空间大小*/
    VIDOSD0A &= ~(0x3fffff << 0);
    VIDOSD0A |= (LeftTopX << 11) | (LeftTopY << 0);
    VIDOSD0B &= ~(0x3fffff << 0);
    VIDOSD0B |= (RightBotX << 11) | (RightBotY << 0);
    VIDOSD0C &= ~(0xffffffff << 0);
    VIDOSD0C |= (LINEVAL + 1) * (HOZVAL + 1);
    
    /*设置window0显存的内存地址*/
    VIDW00ADD0B0 = FB_ADDR;     //内存地址
    VIDW00ADD1B0 = (HOZVAL + 1) * (LINEVAL + 1) * 4;    //显存字节大小，这个空间可以做很大的

    /*使能window0*/
    WINCON0 &= ~(0xf << 2);
    WINCON0 |= (0xb << 2);             //选择像素深度 = 24bpp（RGB888）
    WINCON0 |= (1 << 0) | (1 << 15); //使能显存和使能交换
    
    // 使能channel 0传输数据 对应window0
    SHADOWCON = 0x1;
    
}

参考：《朱友鹏嵌入式Linux开发1.ARM裸机全集1.14.ARM裸机第十四部分-LCD显示器》

          http://blog.chinaunix.net/uid-27411029-id-3302040.html

          http://blog.csdn.net/xubin341719/article/details/9177085