在上一节 Linux-LCD 驱动程序概述 中，可知LCD驱动主要实现是帧缓冲设备的实现。

一、帧缓冲设备驱动在Linux子系统中的结构：

      帧缓冲设备提供给用户空间的file_operations结构体由fbmem.c的file_operation提供，而特定帧缓冲设备结构体的注册、注销以及其中成员的维护，尤其是fb_ops中成员函数的实现则由xxxfb.c文件实现，fb_ops中成员函数最终会操作LCD控制器硬件寄存器。

二、帧缓冲相关的重要数据结构

      从帧缓冲设备驱动程序结构 看，该驱动主要跟fb_info结构体有关，该结构体记录了帧缓冲设备的全部信息，包括设备的设置参数、状态以及对底层硬件操作的函数指针。在Linux 中，帧缓冲设备最关键的一个数据结构体是fb_info，fb_info中包括了关于帧缓冲设备属性和操作的完整描述。每一个帧缓冲设备都必须对应一个fb_info，fb_info在/linux/fb.h中的定义如下：(只列出重要的一些)

2.1 fb_info结构体

struct fb_info {
    int node;
    int flags;
    struct mutex lock;            /* 用于open/release/ioctl的锁*/
    struct fb_var_screeninfo var;/*LCD可变参数*/
    struct fb_fix_screeninfo fix;/*LCD固定参数*/
    struct fb_monspecs monspecs; /*LCD显示器标准*/
    struct work_struct queue;    /*帧缓冲事件队列*/
    struct fb_pixmap pixmap;     /*图像硬件mapper*/
    struct fb_pixmap sprite;     /*光标硬件mapper*/
    struct fb_cmap cmap;         /*当前的颜色表*/
    struct fb_videomode *mode;   /*当前的显示模式*/

#ifdef CONFIG_FB_BACKLIGHT
    struct backlight_device *bl_dev;/*对应的背光设备*/
    struct mutex bl_curve_mutex;
    u8 bl_curve[FB_BACKLIGHT_LEVELS];/*背光调整*/
#endif
#ifdef CONFIG_FB_DEFERRED_IO
    struct delayed_work deferred_work;
    struct fb_deferred_io *fbdefio;
#endif

    struct fb_ops *fbops; /*对底层硬件操作的函数指针*/
    struct device *device;
    struct device *dev;   /*fb设备*/
    int class_flag;    
#ifdef CONFIG_FB_TILEBLITTING
    struct fb_tile_ops *tileops; /*图块Blitting*/
#endif
    char __iomem *screen_base;   /*显存虚拟基地址*/
    unsigned long screen_size;   /*LCD IO映射的虚拟内存大小*/ 
    /*假的16色调色板,里面存放了16色的数据,可以通过8bpp数据来找到调色板里面的
  *16色颜色索引值,模拟出16色颜色来,节省内存,不需要的话就指向一个不用的数组即可*/
    void *pseudo_palette;        /*伪16色颜色表*/ 
#define FBINFO_STATE_RUNNING    0
#define FBINFO_STATE_SUSPENDED  1
    u32 state;  /*LCD的挂起或恢复状态*/
    void *fbcon_par;
    void *par;    
};

其中，比较重要的成员有struct fb_var_screeninfo var、struct fb_fix_screeninfo fix和struct fb_ops *fbops，他们也都是结构体，下面我们一个一个的来看。

2.2 struct fb_var_screeninfo 结构体

      fb_var_screeninfo结构体主要记录用户可以修改的控制器的参数，比如屏幕的分辨率和每个像素的比特数等。例如：fb_var_screeninfo中的xres定义屏幕一行有多少个点，yres定义一屏幕一列有多少个点，bits_per_pixel定义每个点用多少个自己表示。该结构体定义如下：

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

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

    /*以下参数都可以不填,默认为0*/
    struct fb_bitfield transp; /*透明度*/    
    __u32 nonstd;              /* != 0 非标准像素格式*/
    __u32 activate;            /*设为0即可*/   
    __u32 height;              /*外设高度(单位mm),一般不需要填*/
    __u32 width;               /*外设宽度(单位mm),一般不需要填*/
    __u32 accel_flags;        /*过时的参数,不需要填*/

    /*定时：除了pixclock本身外，其他的都以像素时钟为单位*/
    __u32 pixclock;            /*像素时钟(皮秒)*/
    __u32 left_margin;         /*行切换，从同步到绘图之间的延迟*/
    __u32 right_margin;        /*行切换，从绘图到同步之间的延迟*/
    __u32 upper_margin;        /*帧切换，从同步到绘图之间的延迟*/
    __u32 lower_margin;        /*帧切换，从绘图到同步之间的延迟*/
    __u32 hsync_len;           /*水平同步的长度*/
    __u32 vsync_len;           /*垂直同步的长度*/
    __u32 sync;
    __u32 vmode;
    __u32 rotate;
    __u32 reserved[5];         /*保留*/
};

2.3 struct fb_fix_screeninfo结构体

      fb_fix_screeninfo结构体又主要记录用户不可以修改的控制器的参数，比如屏幕缓冲区的物理地址和长度等。当帧缓冲设备进行映射操作的时候，就是从fb_fix_screeninfo中取得缓冲区物理地址。该结构体的定义如下：

struct fb_fix_screeninfo {
    char id[16];                /*字符串形式的标示符 */
    unsigned long smem_start;   /*framebuffer物理起始地址    */
    __u32 smem_len;             /*framebuffer长度,字节为单位 */
    __u32 type;                 /*看FB_TYPE_* */
    __u32 type_aux;             /*分界*/
    __u32 visual;               /*看FB_VISUAL_* */ 
    __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[3];          /*保留*/
};

2.4 fb_ops结构体

      fb_ops结构体是对底层硬件操作的函数指针，该结构体中定义了对硬件的操作有:(这里只列出了常用的操作)

struct fb_ops {
    struct module *owner;
    //检查可变参数并进行设置
    int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);

    //根据设置的值进行更新，使之有效
    int (*fb_set_par)(struct fb_info *info);

    //设置颜色寄存器
    int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
             unsigned blue, unsigned transp, struct fb_info *info);

    //显示空白
    int (*fb_blank)(int blank, struct fb_info *info);

    //矩形填充
    void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);

    //复制数据
    void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);

    //图形填充
    void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);
};

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

static struct fb_ops s3c_lcdfb_ops = {
         .owner                = THIS_MODULE,
         //设置调色板fb_info-> pseudo_palette,自己构造该函数
         .fb_setcolreg    = my_lcdfb_setcolreg,
         //填充矩形,用/drivers/video/ cfbfillrect.c里的函数即可
         .fb_fillrect      = cfb_fillrect,    
        //复制数据, 用/drivers/video/cfbcopyarea.c里的函数即可
         .fb_copyarea    = cfb_copyarea,  
        //绘画图形, 用/drivers/video/imageblit.c里的函数即可
         .fb_imageblit    = cfb_imageblit,
};

三、帧缓冲相关的重要函数

3.1 申请一个fb_info结构体

函数原型：struct fb_info *framebuffer_alloc(size_t size, struct device *dev);
参数说明 ：size 额外的内存
                  *dev 指针, 这里填0,表示这个申请的结构体里没有内容

3.2 fb_info的注册与注销

函数原型：int register_framebuffer(struct fb_info *fb_info)
参数说明 : fb_info 待注册的fb_info对象
                  向内核中注册fb_info结构体,若内存不够,注册失败会返回负数

函数原型：int unregister_framebuffer(struct fb_info *fb_info)
说明 :注销内核中fb_info结构体

3.3 分配DMA缓存区给显存

分配一段DMA缓存区,分配出来的内存会禁止cache缓存(因为DMA传输不需要CPU);
它和 dma_alloc_coherent ()函数相似,不过 dma_alloc_coherent ()函数是分配出来的内存会禁止cache缓存以及禁止写入缓冲区。

函数原型：void *dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t handle, gfp_t gfp)
参数说明 ：dev 指针,这里填0,表示这个申请的缓冲区里没有内容
                  size 分配的地址大小(字节单位)
                  *handle 申请到的物理起始地址
                  gfp 分配出来的内存参数,标志定义在<linux/gfp.h>,常用标志如下:
                  //GFP_ATOMIC 用来从中断处理和进程上下文之外的其他代码中分配内存. 从不睡眠.
                  //GFP_KERNEL 内核内存的正常分配. 可能睡眠.
                  //GFP_USER 用来为用户空间页来分配内存; 它可能睡眠.
返回值: 申请到的DMA缓冲区的虚拟地址,若为NULL,表示分配失败,则需要使用dma_free_writecombine()释放内存,避免内存泄漏

四、驱动实现

在驱动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

代码实现如下：

#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>

/*LCD :  480*272     */
#define   LCD_xres     480        //LCD 行分辨率
#define   LCD_yres     272          //LCD列分辨率
 

/* GPIO prot   */
static unsigned long  *GPBcon;
static unsigned long  *GPCcon;
static unsigned long  *GPDcon;
static unsigned long  *GPGcon;  //GPG4:控制LCD信号 
static unsigned long  *GPBdat;   //GPB0: 控制背光


/* LCD control */ 
 struct  lcd_reg{  
              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[9];  
              unsigned long       dithmode;     
              unsigned long       tpal ;            
              unsigned long       lcdintpnd;
              unsigned long       lcdsrcpnd;
              unsigned long       lcdintmsk;
              unsigned long       tconsel;  
};

static struct lcd_reg  *lcd_reg;
 
static struct fb_info *my_lcd;    //定义一个全局变量
static u32 pseudo_palette[16];   //调色板数组,被fb_info->pseudo_palette调用

static inline unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf)
{
/*内核中的单色都是16位,默认从左到右排列,比如G颜色[0x1f],那么chan就等于0XF800*/
       chan       &= 0xffff;
       chan       >>= 16 - bf->length;    //右移,将数据靠到位0上
       return chan << bf->offset;    //左移一定偏移值,放入16色数据中对应的位置
}

static int my_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 >=16)                //调色板数组不能大于15
              return 1;

       /* 用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;     //放到调色板数组中
       return 0;
}


static struct fb_ops my_lcdfb_ops = {
      .owner           = THIS_MODULE,
      .fb_setcolreg  = my_lcdfb_setcolreg,//调用my_lcdfb_setcolreg()函数,来设置调色板fb_info-> pseudo_palette
      .fb_fillrect       = cfb_fillrect,     //填充矩形
      .fb_copyarea   = cfb_copyarea,     //复制数据
      .fb_imageblit  = cfb_imageblit,    //绘画图形,
};

static int lcd_init(void)
{
  /*1.申请一个fb_info结构体*/
  my_lcd= framebuffer_alloc(0,0); 

  /*2.设置fb_info*/
 
  /* 2.1设置固定的参数fb_info-> fix */
  /*my_lcd->fix.smem_start    物理地址后面注册MDA缓存区设置*/ 
  strcpy(my_lcd->fix.id, "mylcd");                       //名字
  my_lcd->fix.smem_len =LCD_xres*LCD_yres*2;             //地址长
  my_lcd->fix.type        =FB_TYPE_PACKED_PIXELS;
  my_lcd->fix.visual            =FB_VISUAL_TRUECOLOR;            //真彩色
  my_lcd->fix.line_length      =LCD_xres*2;               //LCD 一行的字节

  /* 2.2 设置可变的参数fb_info-> var  */
  my_lcd->var.xres        =LCD_xres;                          //可见屏X 分辨率
  my_lcd->var.yres        =LCD_yres;                          //可见屏y 分辨率
  my_lcd->var.xres_virtual     =LCD_xres;                   //虚拟屏x分辨率
  my_lcd->var.yres_virtual     =LCD_yres;                   //虚拟屏y分辨率
  my_lcd->var.xoffset           = 0;                     //虚拟到可见屏幕之间的行偏移
  my_lcd->var.yoffset           =0;                      //虚拟到可见屏幕之间的行偏移

  my_lcd->var.bits_per_pixel=16;                //像素为16BPP
  my_lcd->var.grayscale       =   0;            //灰色比例
 
  my_lcd->var.red.offset      =     11;
  my_lcd->var.red.length      =     5;
  my_lcd->var.green.offset  =       5;
  my_lcd->var.green.length  =       6;
  my_lcd->var.blue.offset     =     0;
  my_lcd->var.blue.length     =     5;

/* 2.3 设置操作函数fb_info-> fbops  */
  my_lcd->fbops                 = &my_lcdfb_ops;


  /* 2.4 设置fb_info 其它的成员  */ 
 /*my_lcd->screen_base    虚拟地址在后面注册MDA缓存区设置*/
  my_lcd->pseudo_palette   =pseudo_palette;            //保存调色板数组
  my_lcd->screen_size          =LCD_xres * LCD_yres *2;     //虚拟地址长

  /*3   设置硬件相关的操作*/
  /*3.1 配置LCD引脚*/
  GPBcon                     = ioremap(0x56000010, 8);
  GPBdat                     = GPBcon+1;
  GPCcon                     = ioremap(0x56000020, 4);
  GPDcon              　　　　= ioremap(0x56000030, 4);
  GPGcon            　　　　  = ioremap(0x56000060, 4);

  *GPBcon            &=~(0x03<<(0*2));
  *GPBcon            |= (0x01<<(0*2));     //PGB0背光
  *GPBdat            &=~(0X1<<0);           //关背光
  *GPCcon            =0xaaaaaaaa;
  *GPDcon            =0xaaaaaaaa;
  *GPGcon            |=(0x03<<(4*2));    //GPG4:LCD信号

  /*3.2 根据LCD手册设置LCD控制器,参考之前的裸机驱动*/
  lcd_reg=ioremap(0X4D000000, sizeof( lcd_reg) );
   /*HCLK:100Mhz */
   lcd_reg->lcdcon1     = (4<<8) | (0X3<<5) |  (0x0C<<1) ;
   lcd_reg->lcdcon2     = ((3)<<24) | (271<<14) |  ((1)<<6) |((0)<<0);
   lcd_reg->lcdcon3     = ((16)<<19) | (479<<8) | ((10));
   lcd_reg->lcdcon4     = (4);
   lcd_reg->lcdcon5     = (1<<11) | (1<<9) | (1<<8) |(1<<0);     

   lcd_reg->lcdcon1     &=~(1<<0);              // 关闭PWREN信号输出
   lcd_reg->lcdcon5     &=~(1<<3);              //禁止PWREN信号

 /* 3.3  分配显存(framebuffer),把地址告诉LCD控制器和fb_info*/
   my_lcd->screen_base=dma_alloc_writecombine(0,my_lcd->fix.smem_len,  &my_lcd->fix.smem_start, GFP_KERNEL);

   /*lcd控制器的地址必须是物理地址*/
   lcd_reg->lcdsaddr1 =(my_lcd->fix.smem_start>>1)&0X3FFFFFFF;  //保存缓冲起始地址A[30:1]  
   lcd_reg->lcdsaddr2 =((my_lcd->fix.smem_start+my_lcd->screen_size)>>1)&0X1FFFFF; //保存存缓冲结束地址A[21:1]
   lcd_reg->lcdsaddr3 =LCD_xres& 0x3ff;　　　　　　　　//OFFSIZE[21:11]:保存LCD上一行结尾和下一行开头的地址之间的差
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  //PAGEWIDTH [10:0]:保存LCD一行占的宽度(半字数为单位)

   /*4开启LCD,并注册fb_info: register_framebuffer()*/
   /*4.1 直接在init函数中开启LCD(后面讲到电源管理,再来优化)*/
  lcd_reg->lcdcon1      |=1<<0;         //输出PWREN信号
  lcd_reg->lcdcon5      |=1<<3;        //允许PWREN信号
  *GPBdat                   |=(0X1<<0);           //开背光

   /*4.2 注册fb_info*/
   register_framebuffer(my_lcd);
   return 0;
}

static int lcd_exit(void)
{
   /* 1卸载内核中的fb_info*/
     unregister_framebuffer(my_lcd);

  /*2 控制LCDCON1关闭PWREN信号,关背光,iounmap注销地址*/
   lcd_reg->lcdcon1 &=~(1<<0);              // 关闭PWREN信号输出
   lcd_reg->lcdcon5 &=~(1<<3);            //禁止PWREN信号
   *GPBdat            &=~(0X1<<4);           //关背光
   iounmap(GPBcon);
   iounmap(GPCcon);
   iounmap(GPDcon);
   iounmap(GPGcon);

  /*3.释放DMA缓存地址dma_free_writecombine()*/
  dma_free_writecombine(0,my_lcd->screen_size,my_lcd->screen_base,my_lcd->fix.smem_start);

   /*4.释放注册的fb_info*/
   framebuffer_release(my_lcd);

   return 0;
}

module_init(lcd_init);
module_exit(lcd_exit);
MODULE_LICENSE("GPL");

五、测试

5.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模块,如下图所示:

5.2挂载驱动

将编译好的LCD驱动模块 和drivers/video里的3个.ko模块 放入nfs文件系统目录中
然后烧写内核, 先装载3个/drivers/video下编译好的模块,再来装载LCD驱动模块
挂载LCD驱动后, 如下图,可以通过 ls -l /dev/fb* 命令查看已挂载的LCD设备节点:

$ ls /dev/fb*
$ /dev/fb0

5.3 测试运行

echo hello > /dev/tty1 // LCD上便显示hello字段
cat Makefile > /dev/tty1 // LCD上便显示Makeflie文件的内容（花屏）