11. Linux——LCD驱动程序

由上一节

得出写个LCD驱动入口函数,需要以下4步:

1) 分配一个fb_info结构体: framebuffer_alloc();

2) 设置fb_info

3) 设置硬件相关的操作

4) 使能LCD,并注册fb_info: register_framebuffer()

本节需要用到的函数:

 void *dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp);  //分配DMA缓存区给显存
 //返回值为:申请到的DMA缓冲区的虚拟地址,若为NULL,表示分配失败,则需要使用dma_free_writecombine()释放内存,避免内存泄漏
 //参数如下: 

 //*dev:指针,这里填0,表示这个申请的缓冲区里没有内容

 //size:分配的地址大小(字节单位)

 //*handle:申请到的物理起始地址

 //gfp:分配出来的内存参数,标志定义在<linux/gfp.h>,常用标志如下:
     //GFP_ATOMIC    用来从中断处理和进程上下文之外的其他代码中分配内存. 从不睡眠.
     //GFP_KERNEL    内核内存的正常分配. 可能睡眠.
     //GFP_USER      用来为用户空间页来分配内存; 它可能睡眠.

　　分配一段DMA缓存区,分配出来的内存会禁止cache缓存(因为DMA传输不需要CPU)

　　它和 dma_alloc_coherent ()函数相似,不过 dma_alloc_coherent ()函数是分配出来的内存会禁止cache缓存以及禁止写入缓冲区

---

 dma_free_writecombine(dev,size,cpu_addr,handle);   //释放缓存
 //cpu_addr:虚拟地址,
 //handle:物理地址

　　释放DMA缓冲区, dev和size参数和上面的一样

---

 struct fb_info *framebuffer_alloc(size_t size, struct device *dev);      //申请一个fb_info结构体,
 //size:额外的内存,
 //*dev:指针, 这里填0,表示这个申请的结构体里没有内容

 int register_framebuffer(struct fb_info *fb_info);
  //向内核中注册fb_info结构体,若内存不够,注册失败会返回负数

 int unregister_framebuffer(struct fb_info *fb_info) ;
 //注销内核中fb_info结构体

---

需要用到的结构体:

　　fb_info结构体

 struct fb_info {
         ... ...
        struct fb_var_screeninfo var;    //可变的参数
        struct fb_fix_screeninfo fix;    //固定的参数
        ... ...
        struct fb_ops *fbops;            //操作函数
        ... ...
        char __iomem *screen_base;       //显存虚拟起始地址
        unsigned long screen_size;       //显存虚拟地址长度

        void *pseudo_palette;
12    //假的16色调色板,里面存放了16色的数据,可以通过8bpp数据来找到调色板里面的16色颜色索引值,模拟出16色颜色来,节省内存,不需要的话就指向一个不用的数组即可
        ... ...
 };

　　其中操作函数fb_info-> fbops 结构体写法如下:

 static struct fb_ops s3c_lcdfb_ops = {
          .owner                = THIS_MODULE,

          .fb_setcolreg    = s3c_lcdfb_setcolreg,//设置调色板fb_info-> pseudo_palette,自己构造该函数

          .fb_fillrect      = cfb_fillrect,     //填充矩形,用/drivers/video/ cfbfillrect.c里的函数即可

          .fb_copyarea    = cfb_copyarea,  //复制数据, 用/drivers/video/cfbcopyarea.c里的函数即可

          .fb_imageblit    = cfb_imageblit, //绘画图形, 用/drivers/video/imageblit.c里的函数即可
 };

　　固定的参数fb_info-> fix 结构体如下:

 struct fb_fix_screeninfo {
        char id[];                   //id名字
        unsigned long smem_start;  //framebuffer物理起始地址
        __u32 smem_len;           //framebuffer长度,字节为单位
        __u32 type;                 //lcd类型,默认值0即可
        __u32 type_aux;               //附加类型,为0
        __u32 visual;                     //画面设置,常用参数如下
 // FB_VISUAL_MONO01             0 　　单色,0:白色,1:黑色
 // FB_VISUAL_MONO10             1  　 单色,1:白色,0:黑色
 // FB_VISUAL_TRUECOLOR          2     真彩(TFT:真彩)
 // FB_VISUAL_PSEUDOCOLOR 　　　　3     伪彩
 // FB_VISUAL_DIRECTCOLOR        4     直彩

 　　　　__u16 xpanstep;                /*如果没有硬件panning就赋值为0 */
 　　　　__u16 ypanstep;                /*如果没有硬件panning就赋值为0 */
 　　　　__u16 ywrapstep;                 /*如果没有硬件ywrap就赋值为0 */

 　　　　__u32 line_length;                 /*一行的字节数 ,例:(RGB565)240*320,那么这里就等于240*16/8 */

 　　　　/*以下成员都可以不需要*/
 　　　　unsigned long mmio_start;        /*内存映射IO的起始地址,用于应用层直接访问寄存器,可以不需要*/
        __u32 mmio_len;                   /* 内存映射IO的长度,可以不需要*/
        __u32 accel;
        __u16 reserved[];        

 };

fb_info->fix

　　可变的参数fb_info-> var 结构体如下:

 structfb_var_screeninfo{
 　　 __u32xres;                    /*可见屏幕一行有多少个像素点*/
     __u32 yres;                      /*可见屏幕一列有多少个像素点*/
     __u32 xres_virtual;         /*虚拟屏幕一行有多少个像素点 */
     __u32  yres_virtual;       /*虚拟屏幕一列有多少个像素点*/
     __u32 xoffset;                 /*虚拟到可见屏幕之间的行偏移,若可见和虚拟的分辨率一样,就直接设为0*/
     __u32 yoffset;                 /*虚拟到可见屏幕之间的列偏移*/
     __u32  bits_per_pixel;    /*每个像素的位数即BPP,比如:RGB565则填入16*/
     __u32 grayscale;           /*非0时，指的是灰度,真彩直接填0即可*/

     struct fb_bitfield red;          //fb缓存的R位域, fb_bitfield结构体成员如下:
 //__u32 offset;          区域偏移值,比如RGB565中的R,就在第11位
 //__u32 length;                   区域长度,比如RGB565的R,共有5位
 //__u32 msb_right;  msb_right ==0,表示数据左边最大, msb_right!=0,表示数据右边最大

     struct fb_bitfield green;    /*fb缓存的G位域*/
     struct fb_bitfield blue;       /*fb缓存的B位域*/

 　　 /*以下参数都可以不填,默认为0*/
     struct fb_bitfield transp;   /*透明度,不需要填0即可*/    

     __u32nonstd;                    /* != 0表示非标准像素格式*/
     __u32 activate;                 /*设为0即可*/
     __u32height;                     /*外设高度(单位mm),一般不需要填*/
     __u32width;                      /*外设宽度(单位mm),一般不需要填*/
     __u32 accel_flags;        /*过时的参数,不需要填*/

     /* 除了pixclock本身外，其他的都以像素时钟为 单位*/
     __u32pixclock;                   /*像素时钟(皮秒)*/
     __u32 left_margin;         /*行切换，从同步到绘图之间的延迟*/
     __u32right_margin;        /*行切换，从绘图到同步之间的延迟*/
     __u32upper_margin;       /*帧切换，从同步到绘图之间的延迟*/
     __u32lower_margin;       /*帧切换，从绘图到同步之间的延迟*/
     __u32hsync_len;              /*水平同步的长度*/
     __u32 vsync_len;           /*垂直同步的长度*/
     __u32 sync;
     __u32 vmode;
     __u32 rotate;
     __u32reserved[];        /*保留*/

 }

fb_info->var

1.写驱动程序:

(驱动设置:参考自带的LCD平台驱动drivers/video/s3c2410fb.c )

(LCD控制寄存器设置:参考韦老大的LCD裸机驱动:)

1.1 步骤如下:

在驱动init入口函数中:

1)分配一个fb_info结构体

2)设置fb_info

　　2.1)设置固定的参数fb_info-> fix

　　2.2) 设置可变的参数fb_info-> var

　　2.3) 设置操作函数fb_info-> fbops

　　2.4) 设置fb_info 其它的成员

3)设置硬件相关的操作

　　3.1)配置LCD引脚

　　3.2)根据LCD手册设置LCD控制器

　　3.3)分配显存(framebuffer),把地址告诉LCD控制器和fb_info

4)开启LCD,并注册fb_info: register_framebuffer()

　　4.1) 直接在init函数中开启LCD(后面讲到电源管理,再来优化)

　　　　控制LCDCON5允许PWREN信号,

　　　　然后控制LCDCON1输出PWREN信号,

　　　　输出GPB0高电平来开背光,

　　4.2) 注册fb_info

在驱动exit出口函数中:

1)卸载内核中的fb_info

2) 控制LCDCON1关闭PWREN信号,关背光,iounmap注销地址

3)释放DMA缓存地址dma_free_writecombine()

4)释放注册的fb_info

1.2 具体代码如下:

 /*写程序的思路如下：
 * 1.查看LCD芯片手册，查看相关的时间参数、分辨率、引脚极性；

 * 2.根据以上信息设置LCD控制器寄存器，让其发出正确信号；

 * 3.在内存里面分配一个FrameBuffer，在里面用若干位表示一个像素，再把首地址告诉LCD控制器；

 之后LCD控制器就能周而复始取出FrameBuffer里面的像素数据，配合其它控制信号，发送给电子枪，
 电子枪再让在LCD上显示出来。若想显示图像，只需要编写程序向FrameBuffer填入相应数据即可，
 硬件会自动的完成显示操作。*/

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
 #include <linux/workqueue.h>
 #include <linux/wait.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>

 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/div64.h>

 #include <asm/mach/map.h>
 #include <asm/arch/regs-lcd.h>
 #include <asm/arch/regs-gpio.h>
 #include <asm/arch/fb.h>

 static struct fb_info *s3c_lcd;
 static volatile unsigned long *gpbcon;
 static volatile unsigned long *gpbdat;
 static volatile unsigned long *gpccon;
 static volatile unsigned long *gpdcon;
 static volatile unsigned long *gpgcon;
 static volatile struct lcd_regs *lcd_regs; //定义一个结构体指针，并进行映射
 static u32 pseudo_palette[]; ///调色板数组,被fb_info->pseudo_palette调用

 /* LCD Control */
 struct lcd_regs {
     unsigned long    lcdcon1;
     unsigned long    lcdcon2;
     unsigned long    lcdcon3;
     unsigned long    lcdcon4;
     unsigned long    lcdcon5;
     unsigned long    lcdsaddr1;
     unsigned long    lcdsaddr2;
     unsigned long    lcdsaddr3;
     unsigned long    redlut;
     unsigned long    greenlut;
     unsigned long    bluelut;
     unsigned long    reserved[]; //28--4C 相差36(16进制)，除以4-->9byte
     unsigned long    dithmode;
     unsigned long    tpal;
     unsigned long    lcdintpnd;
     unsigned long    lcdsrcpnd;
     unsigned long    lcdintmsk;
     unsigned long    lpcsel;
 };

 static inline unsigned int chan_to_field(u_int chan, struct fb_bitfield *bf)
 {
     chan &= 0xffff;
     chan >>=  - bf->length; //右移,将数据靠到位0上
     return chan << bf->offset; //左移一定偏移值,放入16色数据中对应的位置
 }

 /* 类比调色板，混3色于碟子regno,  */
 static int s3c_lcdfb_setcolreg(unsigned int regno, unsigned int red,
                  unsigned int green, unsigned int blue,
                  unsigned int transp, struct fb_info *info)
 {
     unsigned int val;
     if (regno > )
         return ;

     /* 用red, green, blue三原色构造出16色数据val */

     val  = chan_to_field(red,    &info->var.red);
     val |= chan_to_field(green,  &info->var.green);
     val |= chan_to_field(blue,    &info->var.blue);

     //((u32 *)(info->pseudo_palette))[regno] = val;
     pseudo_palette[regno] = val;
     return ;

 }

 static struct fb_ops s3c_lcdfb_ops = {
     .owner          = THIS_MODULE,
     .fb_setcolreg    = s3c_lcdfb_setcolreg, //设置调色板fb_info-> pseudo_palette,自己构造该函数
     .fb_fillrect        = cfb_fillrect,  //填充矩形
     .fb_copyarea        = cfb_copyarea,  //复制数据
     .fb_imageblit    = cfb_imageblit, //绘画图形,
 };

 static int lcd_init(void)
 {
     /* 1.分配一个fbinfo结构体：framebuffer_alloc*/
     s3c_lcd = framebuffer_alloc(, NULL);

     /* 2.设置 fb_info*/
     /* 2.1设置固定的参数(4.3寸横屏) */
     strcpy(s3c_lcd->fix.id, "mylcd");  //字符串拷贝至参数dest所指的地址
     s3c_lcd->fix.smem_len = **; //480*272个像素点*16位/像素
     s3c_lcd->fix.type     = FB_TYPE_PACKED_PIXELS; //FB_TYPE_:LCD类型，默认0
     s3c_lcd->fix.visual   = FB_VISUAL_TRUECOLOR;   //表示真彩色
     s3c_lcd->fix.line_length = *;       //一行的字节数，240*16/8

     /* 2.2设置可变的参数 */
     s3c_lcd->var.xres           = ;  //可见屏X 分辨率
     s3c_lcd->var.yres           = ;  //可见屏y 分辨率
     s3c_lcd->var.xres_virtual   = ;  //虚拟屏x分辨率
     s3c_lcd->var.yres_virtual   = ;  //虚拟屏y分辨率
     s3c_lcd->var.xoffset        =   ;  //虚拟到可见屏幕之间的行偏移
     s3c_lcd->var.yoffset        =   ;  //虚拟到可见屏幕之间的行偏移
     s3c_lcd->var.bits_per_pixel =  ;  //像素为16BPP
     s3c_lcd->var.grayscale      =   ;  //灰色比例

     /* R-G-B : 5-6-5*/
     s3c_lcd->var.red.offset     = ;
     s3c_lcd->var.red.length     = ;

     s3c_lcd->var.green.offset   = ;
     s3c_lcd->var.green.length   = ;

     s3c_lcd->var.blue.offset    = ;
     s3c_lcd->var.blue.length    = ;

     s3c_lcd->var.activate       = ;

     /* 2.3设置操作函数 */
     s3c_lcd->fbops               = &s3c_lcdfb_ops;

     /* 2.4其他的设置 */
     s3c_lcd->pseudo_palette     = pseudo_palette; //假的调色板
     //s3c_lcd->screen_base        = ; //显存的虚拟地址,,在分配显存时，得到的返回值就是虚拟地址
     s3c_lcd->screen_size            = **;//显存的物理大小

     /* 3.硬件相关操作 */
     /* 3.1配置GPIO用于LCD */
     gpbcon = ioremap(0x56000010, );
     gpbdat = gpbcon + ;
     gpccon = ioremap(0x56000020, );
     gpdcon = ioremap(0x56000030, );
     gpgcon = ioremap(0x56000060, );

     *gpccon = 0xaaaaaaaa;   // GPIO管脚用于VD[7:0],LCDVF[2:0],VM,VFRAME,VLINE,VCLK,LEND
     *gpdcon = 0xaaaaaaaa;   // GPIO管脚用于VD[23:8]
       *gpbcon &= ~();  // GPB0设置为输出引脚，先清零
     *gpbcon |= ;
     *gpbdat &= ~;    // Power off,先输出低电平,再后面使能的时候再输出高电平

     *gpgcon |= (0x03<<); //GPG4用作LCD_PWREN

     /* 3.2根据LCD手册设置LCD控制器，比如VCLK的频率 */
         /* 将寄存器放入结构体中，同一映射，方便 */
     lcd_regs = ioremap(0x4D000000, sizeof(struct lcd_regs));

     /*
      *bit[17:8] : VCLK = HCLK / [(CLKVAL+1) x 2] ( CLKVAL >=  0 )
      *       10MHZ(10ns)= 100MHZ/ [(CLKVAL+1) x 2]-->LCD手册P14
      *       CLKVAL = 4;
      *bit[7]: MMODE--决定VM的触发频率，不用管
      *bit[6:5]:PNRMODE--选择显示模式--TFT LCD面板--[1:1]
      *bit[4:1]:BPPMODE--位每像素--1100=16bpp
      *bit[0]  :ENVID  --LCD视频输出和逻辑使能/禁止(使能LCD控制器)
      */
     lcd_regs->lcdcon1 = (<<) | (<<) | (0x0c<<);

     /*垂直方向的时间参数
      *bit[31:24] :VBPD, VSYNC之后再过多长时间才能发出第一行数据
      *     LCD手册 :T0-(T1+T2) = 4 --> VBPD = 3
      *bit[23:14] :LINEVAL+1 = 272行-->271
      *bit[13:6]  :VFPD,发出最后一行数据之后，再过多久才发出VSYNC
      *             :LCD手册T2 - T5 = 2-->VFPD = 2-1
      *bit[5:0]   :VSPW, VSYNC信号的脉冲宽度，手册，1-1=0
      */
     lcd_regs->lcdcon2 = (<<) | (<<) | (<<) | (<<);

     /*水平方向的时间参数
      *bit[25:19] :HBPD, HSYNC之后多久才能发出第一个像素的数据
      *             T6 - T7 - T8 = 17, HBPD = 16
      *bit[18:8]  :HOZVAL,480-1 = 479
      *bit[7:0]   :最后一行有效数据结束后，过多久发出HSYNC
      *             :LCD手册T8-T11=251-240=11, 所以HFPD=11-1=10
      */
     lcd_regs->lcdcon3 = (<<) | (<<) | (<<);

     /* 水平方向的同步信号
      * bit[7:0]    : HSPW, HSYNC信号的脉冲宽度, LCD手册T7=5, 所以HSPW=5-1=4
      */
     lcd_regs->lcdcon4 = ;

     /* 信号的极性 */
     /*bit[11]: 选择16bpp输出视频数据的格式---1 = 5:6:5 Format
      *bit[10]: 默认0--在下降沿取数据
      *bit[ 9]: 在2440芯片手册上Hsync信号为高电平有效，但是在LCD产品手册上，
      *           是低电平有效，要与产品手册一致，故反转，低电平有效，1
      *bit[ 8]:VSYNC，与HSYNC同样，低电平有效，故反转
      *bit[ 7]:INVVD, VD(视频数据)不需要管
      *bit[ 6]:INVVDEN,VDEN不需要反转， 0
      *bit[ 5]:INVPWREN,电源使能信号，不需要反转
      *bit[ 4]:INVLEND, 没用到LEND信号不用管
      *bit[ 3]:决定使能信号PWREN是否有效，1
      *bit[ 2]:不用管
      *bit[ 1]:BSWP = 0
      *bit[ 0]:HWSWP = 1
      */
     lcd_regs->lcdcon5 = (<<) | (<<) | (<<) | (<<) | (<<);

     /* 3.3分配显存，framebuffer，并把地址告诉LCD控制器 */
     //s3c_lcd->fix.smem_start = xxx; 显存的物理地址
                                                  //(dev, size,     物理地址，             , 标记)
     s3c_lcd->screen_base = dma_alloc_writecombine(NULL, **, &s3c_lcd->fix.smem_start, GFP_KERNEL);

     /* 将framebuffer的起始地址的[30:1]保存到此寄存器的[29:0]中*/
     lcd_regs->lcdsaddr1 = (s3c_lcd->fix.smem_start >> ) & ~(<<);

     /* 将framebuffer的结束地址的[21:1]保存到此寄存器的[20:0]中 */
     lcd_regs->lcdsaddr2 = (s3c_lcd->fix.smem_start + s3c_lcd->fix.smem_len >>) & 0x1fffff;

     /* 虚拟屏地址设置，虚拟盘与真实屏尺寸相同，offsize,[21:11] = 0,  */
     /* PAGEWIDTH, 虚拟盘页宽度，即真实屏一行宽度，单位(半字) */
     lcd_regs->lcdsaddr3 = (*/);  

     /* 注册前要使能LCD本身，及开启背光，可以提供接口，便于管理，
      *但涉及到电源管理，此处全程为使能的状态，直接启动
      */
     /* 启动LCD */
     lcd_regs->lcdcon1 |= (<<);//使能LCD控制器
     lcd_regs->lcdcon5 |= (<<);//令使能信号LCD_PWREN有效，使能LCD本身
     *gpbdat |= ;  //KEYBOARD-->GPB0 ,背光使能，输出高电平
     /* 4.注册 */
     register_framebuffer(s3c_lcd);

 return ;
 }

 static void lcd_exit(void)
 {
     unregister_framebuffer(s3c_lcd); //卸载内核中的info
     lcd_regs->lcdcon1 &= ~(<<);    //关闭LCD
     *gpbdat &= ~;    //关闭背光
     dma_free_writecombine(NULL, s3c_lcd->fix.smem_len, s3c_lcd->screen_base, s3c_lcd->fix.smem_start);
     iounmap(lcd_regs);
     iounmap(gpbcon);
     iounmap(gpccon);
     iounmap(gpdcon);
     iounmap(gpgcon);
     framebuffer_release(s3c_lcd); //释放显存
 }

 module_init(lcd_init); //修饰入口函数
 module_exit(lcd_exit); //修饰出口函数

 MODULE_LICENSE("GPL");       //声明函数

lcd.c

2.测试

2.1重新编译内核,去掉默认的LCD

　　make menuconfig ,进入menu菜单重新设置内核参数:

进入Device Drivers-> Graphics support:
<M> S3C2410 LCD framebuffer support          //将自带的LCD驱动设为模块, 不编进内核中

　　make uImage 编译内核

　  make modules 编译模块

为什么要编译模块？

因为LCD驱动相关的文件也没有编进内核,而fb_ops里的成员fb_fillrect(), fb_copyarea(), fb_imageblit()用的都是drivers/video下面的3个文件,所以需要这3个的.ko模块,

2.2挂载驱动

将编译好的LCD驱动模块 和drivers/video里的3个.ko模块 放入nfs文件系统目录中

然后烧写内核, 先装载3个/drivers/video下编译好的模块,再来装载LCD驱动模块

可以通过  ls -l /dev/fb*   命令查看已挂载的LCD设备节点

2.3测试运行

测试有两种:

echo hello> /dev/tty1     // LCD上便显示hello字段

cat Makefile>/dev/tty1    // LCD上便显示Makeflie文件的内容

2.4使用上节的键盘驱动在LCD终端打印命令行

vi  /etc/inittab         //修改inittab, inittab:配置文件,用于启动init进程时,读取inittab

添加->tty1::askfirst:-/bin/sh   //将sh进程(命令行)输出到tty1里,也就是使LCD输出信息

　　然后重启,insmod装载3个/drivers/video下编译好的模块,再来insmod装载LCD驱动模块,tty1设备便有了,就能看到提示信息:

　　insmod上一节的键盘驱动后,按下enter键,便能在LCD终端上操作linux

　　但是我测试出的显示有花屏，花屏之后隐约能看见显示信息（有待解决）

（以上大部分摘自：16.Linux-LCD驱动(详解)）