驱动05.lcd设备驱动程序

参考s3c2410fb.c总结出框架

1.代码分析

1.1 入口函数

 int __devinit s3c2410fb_init(void)
 {
     return platform_driver_register(&s3c2410fb_driver);
 }

注册一个platform_driver结构体，如果存在同名的设备dev时，将调用probe函数。

 static struct platform_driver s3c2410fb_driver = {
     .probe        = s3c2410fb_probe,
     .remove        = s3c2410fb_remove,
     .suspend    = s3c2410fb_suspend,
     .resume        = s3c2410fb_resume,
     .driver        = {
         .name    = "s3c2410-lcd",   //如果存在有同名"s3c2410-lcd"的平台设备，就会调用s3c2410fb_driver的s3c2410fb_probe函数
         .owner    = THIS_MODULE,
     },
 };      //这是s3c2410fb_driver这个结构体的具体成员

搜索s3c2410-lcd可得下面的s3c_device_lcd结构体

 struct platform_device s3c_device_lcd = {
     .name          = "s3c2410-lcd",
     .id          = -,
     .num_resources      = ARRAY_SIZE(s3c_lcd_resource),
     .resource      = s3c_lcd_resource,               //最重要的部分
     .dev              = {
         .dma_mask        = &s3c_device_lcd_dmamask,
         .coherent_dma_mask    = 0xffffffffUL
     }
 };

1.2 probe函数(只列出关键性代码)

 static int __init s3c2410fb_probe(struct platform_device *pdev)
 {
     struct s3c2410fb_info *info;
     struct fb_info       *fbinfo;
                         ......

     fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), &pdev->dev);
     if (!fbinfo) {
         return -ENOMEM;
     }
                         ......
     fbinfo->fix.type        = FB_TYPE_PACKED_PIXELS;
     fbinfo->fix.type_aux        = ;
     fbinfo->fix.xpanstep        = ;
     fbinfo->fix.ypanstep        = ;
     fbinfo->fix.ywrapstep        = ;
     fbinfo->fix.accel        = FB_ACCEL_NONE;

     fbinfo->var.nonstd        = ;
     fbinfo->var.activate        = FB_ACTIVATE_NOW;
     fbinfo->var.height        = mach_info->height;
     fbinfo->var.width        = mach_info->width;
     fbinfo->var.accel_flags     = ;
     fbinfo->var.vmode        = FB_VMODE_NONINTERLACED;
                         .......
     ret = register_framebuffer(fbinfo);
     return ;

 }

由此可知，其主要框架是

（1）分配一个fb_info结构体

（2）设置其参数

（3）注册这个结构体

（4）硬件相关的操作

1.3 fb_info结构体成员的了解

lcd为标准的帧缓冲设备，其主设备号为29，对应的设备为/dev/fb*

     struct fb_info {
         int node;                       //用作次设备号索引
         int flags;
         struct mutex lock;              //用于open/release/ioctl函数的锁
         struct fb_var_screeninfo var;   //可变参数，重点
         struct fb_fix_screeninfo fix;   //固定参数，重点
         struct fb_monspecs monspecs;    //显示器标准
         struct work_struct queue;       //帧缓冲区队列
         struct fb_pixmap pixmap;        //图像硬件映射
         struct fb_pixmap sprite;        //光标硬件映射
         struct fb_cmap cmap;            //当前颜色表
         struct list_head modelist;      //模式链表
         struct fb_videomode *mode;      //当前video模式  

         char __iomem *screen_base;      //显存基地址
         unsigned long screen_size;      //显存大小
         void *pseudo_palette;           //16色调色板
     #define FBINFO_STATE_RUNNING    0
     #define FBINFO_STATE_SUSPENDED  1
         u32 state;                      //硬件状态，如挂起
         void *fbcon_par;                //用作私有数据区
         void *par;                      //info->par指向了额外多申请内存空间的首地址
     };  

另外，fb_fix_screeninfo和fb_var_screeninfo也是两个比较重要的结构体，在设置fb_info结构体时会大量用到。

 struct fb_fix_screeninfo {
     char id[];            /* identification string eg "TT Builtin" */
     unsigned long smem_start;    /* Start of frame buffer mem */
                     /* (physical address) */
     __u32 smem_len;            /* Length of frame buffer mem */
     __u32 type;            /* see FB_TYPE_*        */
     __u32 type_aux;            /* Interleave for interleaved Planes */
     __u32 visual;            /* see FB_VISUAL_*        */
     __u16 xpanstep;            /* zero if no hardware panning  */
     __u16 ypanstep;            /* zero if no hardware panning  */
     __u16 ywrapstep;        /* zero if no hardware ywrap    */
     __u32 line_length;        /* length of a line in bytes    */
     unsigned long mmio_start;    /* Start of Memory Mapped I/O   */
                     /* (physical address) */
     __u32 mmio_len;            /* Length of Memory Mapped I/O  */
     __u32 accel;            /* Indicate to driver which    */
                     /*  specific chip/card we have    */
     __u16 reserved[];        /* Reserved for future compatibility */
 };

struct fb_var_screeninfo {
    __u32 xres;            /* visible resolution        */
    __u32 yres;
    __u32 xres_virtual;        /* virtual resolution        */
    __u32 yres_virtual;
    __u32 xoffset;            /* offset from virtual to visible */
    __u32 yoffset;            /* resolution            */

    __u32 bits_per_pixel;        /* guess what            */
    __u32 grayscale;        /* != 0 Graylevels instead of colors */

    struct fb_bitfield red;        /* bitfield in fb mem if true color, */
    struct fb_bitfield green;    /* else only length is significant */
    struct fb_bitfield blue;
    struct fb_bitfield transp;    /* transparency            */    

    __u32 nonstd;            /* != 0 Non standard pixel format */

    __u32 activate;            /* see FB_ACTIVATE_*        */

    __u32 height;            /* height of picture in mm    */
    __u32 width;            /* width of picture in mm     */

    __u32 accel_flags;        /* (OBSOLETE) see fb_info.flags */

    /* Timing: All values in pixclocks, except pixclock (of course) */
    __u32 pixclock;            /* pixel clock in ps (pico seconds) */
    __u32 left_margin;        /* time from sync to picture    */
    __u32 right_margin;        /* time from picture to sync    */
    __u32 upper_margin;        /* time from sync to picture    */
    __u32 lower_margin;
    __u32 hsync_len;        /* length of horizontal sync    */
    __u32 vsync_len;        /* length of vertical sync    */
    __u32 sync;            /* see FB_SYNC_*        */
    __u32 vmode;            /* see FB_VMODE_*        */
    __u32 rotate;            /* angle we rotate counter clockwise */
    __u32 reserved[];        /* Reserved for future compatibility */
};

1.4 fb_open函数

app：  open("/dev/fb0"...)   主设备号：29   次设备号：0
-----------------------------------------------------------
kernel:
      fb_open
               int fbidx = iminor(inode)//获取次设备号
                    struct fb_info *info =  registered_fb[fbidx]

1.5 fb_read函数

app：    read()
------------------------------------------------------------            
kernel:
            fb_read
                int fbidx = iminor(inode);
                struct fb_info *info = registered_fb[fbidx];    
                    if (info->fbops->fb_read)
                            return info->fbops->fb_read(info, buf, count, ppos);
                    src = (u32 __iomem *) (info->screen_base + p);
                    *dst++ = fb_readl(src++);
                    copy_to_user(buf, buffer, c)

1.6 registered_fb数组由谁来定义？

register_framebuffer

　　registered_fb[i] = fb_info

2 写代码

由1.2我们可以得知，代码的总体框架为：

（1）分配一个fb_info结构体

（2）设置其参数

（3）注册这个结构体

（4）硬件相关的操作

其实难点就在于第（2）步，主要是设置fb_info结构体的固定参数 fb_fix_screeninfo结构体和可变参数fb_var_screeninfo结构体，还有就是硬件相关

的设置，比如lcd时序参数的设置，也就是要设置lcdcon1~lcdcon5，lcdaddr1~lcdaddr3个寄存器。

2.2 源代码

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

 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[];
     unsigned long dithmode;
     unsigned long tpal;
     unsigned long lcdintpnd;
     unsigned long lcdsrcpnd;
     unsigned long lcdintmsk;
     unsigned long tconsel;
 };

 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 u32 pseudo_palette[];
 static volatile struct lcd_regs *lcd_regs;

 static inline unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf)
 {
     chan &= 0xffff;
     chan >>=  - bf->length;
     return chan << bf->offset;
 }

 static int s3c_lcdfb_setcolreg(unsigned regno,
                    unsigned red, unsigned green, unsigned blue,
                    unsigned transp, struct fb_info *info)
 {
     unsigned int val;

     if (regno < )
     {
 //        u32 *pal = fbi->fb->pseudo_palette;
         val  = chan_to_field(red,   &info->var.red);
         val |= chan_to_field(green, &info->var.green);
         val |= chan_to_field(blue,  &info->var.blue);
         pseudo_palette[regno] = val;
     }
     else
         return ;

     return ;

 }

 static struct fb_ops s3clcdfb_ops = {
     .owner        = THIS_MODULE,
     .fb_setcolreg    = s3c_lcdfb_setcolreg,//调色板
     .fb_fillrect    = cfb_fillrect,
     .fb_copyarea    = cfb_copyarea,
     .fb_imageblit    = cfb_imageblit,
 };

 static int lcd_init(void)
 {
     int ret;
     /*1.分配一个fb_info结构体*/
     s3c_lcd = framebuffer_alloc(, NULL);
     if (!s3c_lcd) {
         return -ENOMEM;
     }

     /*2.设置 */
     strcpy(s3c_lcd->fix.id, "mylcd");

     /*2.1设置固定数据fix*/
     s3c_lcd->fix.smem_len = **/;
     s3c_lcd->fix.type         = FB_TYPE_PACKED_PIXELS;
     s3c_lcd->fix.type_aux   = ;
     s3c_lcd->fix.visual           = FB_VISUAL_TRUECOLOR;//TFT真彩色
     s3c_lcd->fix.line_length = */;
 //    s3c_lcd->fix.smem_start

     /*2.2设置可变参数var*/
     s3c_lcd->var.xres = ;
     s3c_lcd->var.yres = ;
     s3c_lcd->var.xres_virtual = ;
     s3c_lcd->var.yres_virtual = ;
     s3c_lcd->var.bits_per_pixel = ;

     /*RGB:565*/
     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 = FB_ACTIVATE_NOW;

     s3c_lcd->fbops            = &s3clcdfb_ops;
     s3c_lcd->pseudo_palette = pseudo_palette;
     s3c_lcd->screen_size   = **/;

     /*3.硬件相关的操作*/
     /*3.1GPIO的初始化*/
     gpbcon = ioremap(0x56000010, );
     gpbdat = gpbcon+;
     gpccon = ioremap(0x56000020, );
     gpdcon = ioremap(0x56000030, );
     gpgcon = ioremap(0x56000060, );

     *gpccon = 0xaaaaaaaa;
     *gpdcon = 0xaaaaaaaa;

     *gpbcon &= ~();
     *gpbcon |= ;
     *gpbdat &= ~;//背光使能

     *gpgcon  |= (<<); //LCD 电源使能

     /*3.2 设置LCD controller*/
     lcd_regs = ioremap(0x4D000000,sizeof(struct lcd_regs));

     lcd_regs->lcdcon1 = (<<) |(<<) |(0x0c<<);
     //lcdcon1[0] Enable the video output and the LCD control signal

     lcd_regs->lcdcon2 = (<<) |(<<) |(<<) |();

     lcd_regs->lcdcon3 = (<<) |(<<) |();

     lcd_regs->lcdcon4 = ;

     lcd_regs->lcdcon5 = (<<) |(<<) |(<<) |(<<);

     /*3.3 设置显存的地址*/
     s3c_lcd->screen_base = dma_alloc_writecombine(NULL,s3c_lcd->fix.smem_len,&s3c_lcd->fix.smem_start,GFP_KERNEL);

     lcd_regs->lcdsaddr1 = (s3c_lcd->fix.smem_start>>) & ~(<<);
     lcd_regs->lcdsaddr2 = (s3c_lcd->fix.smem_start + s3c_lcd->fix.smem_len) & 0x1fffff;
     lcd_regs->lcdsaddr3 = (*/);//行的长度

     /*启动lcd*/

     lcd_regs->lcdcon1 |= ();//使能LCD控制器
     lcd_regs->lcdcon5 |= (<<);//使能LCD电源
     *gpbdat |=;  //使能背光

     /*4.注册该结构体*/
     ret = register_framebuffer(s3c_lcd);
     if (ret < ) {
         printk("Failed to register framebuffer device: %d\n", ret);
     }

     return ;
 }

 static int lcd_exit(void)
 {
     unregister_framebuffer(s3c_lcd);
     lcd_regs->lcdcon1 &= ~;
     lcd_regs->lcdcon5 &= ~(<<);
     *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);
     return ;
 }

 module_init(lcd_init);
 module_exit(lcd_exit);

 MODULE_AUTHOR("lwd20170110");

 MODULE_LICENSE("GPL");

lcd驱动程序

测试：
. make menuconfig去掉原来的驱动程序
-> Device Drivers
  -> Graphics support
<M> S3C2410 LCD framebuffer support

. make uImage
   make modules  

. 使用新的uImage启动开发板:

.
insmod cfbcopyarea.ko
insmod cfbfillrect.ko
insmod cfbimgblt.ko
insmod lcd.ko

echo hello > /dev/tty1  // 可以在LCD上看见hello
cat lcd.ko > /dev/fb0   // 花屏

. 修改 /etc/inittab
tty1::askfirst:-/bin/sh
用新内核重启开发板

insmod cfbcopyarea.ko
insmod cfbfillrect.ko
insmod cfbimgblt.ko
insmod lcd.ko
insmod buttons.ko

2.3 待解决：1.出现段错误。2.用新内核启动后无法挂载nfs。

2017-01-10 16:12:27