LCD设备驱动程序

LCD是Liquid  Crystal  Display的简称，也就是经常所说的液晶显示器

LCD能够支持彩色图像的显示和视频的播放，是一种非常重要的输出设备

 

Framebuffer 是Linux系统为显示设备提供的一个接口，它将显示缓冲区抽象，屏蔽图像硬件的底层差异，允许上层应用程序在图形模式下直接对显示缓冲区进行操作

 

Framebuffer又叫帧缓冲，是Linux为操作显示设备提供的一个用户接口。用户应用程序可以通过Framebuffer透明地访问不同类型的显示设备。

从这个方面来说，Framebuffer是硬件设备显示缓冲区的抽象。Linux抽象出Framebuffer这个帧缓冲区可以供用户应用程序直接读写，通过更改Framebuffer中的内容，就可以立刻显示在LCD显示屏上

 

Framebuffer是显卡硬件的抽象：

Framebuffer机制模仿显卡的功能，将显卡硬件结构抽象为一系列的数据结构，可以通过Framebuffer的读写直接对显存进行操作。用户可以将Framebuffer看成是显示内存的一个映像，将其映射到进程地址空间之后，就可以直接进行读写操作，而写操作可以立即反映在屏幕上。这些操作是由抽象的，统一的。用户不必关心物理显存的位置、换页机制等具体细节。这些都是由Framebuffer设备驱动完成的

 对于Framebuffer而言，只要在帧缓冲区中与显示点对应的区域写入颜色值，对应的颜色会自动在LCD屏幕上显示出来

 

Frambuffer 是标准的字符设备：

Framebuffer 是一个标准的字符设备，主设备号是29，次设备号根据缓冲区 的数目而定。

Framebuffer 对应 /dev/fb%d 设备文件。根据显卡的多少，设备文件可能是/dev/fb0、/dev/sb1等。缓冲区设备也是一种普通的内存设备,可以直接对其进行读写。

例如：对屏幕进行抓屏，可以使用下面的命令：

cp  /dev/fb0 myfile.png

一个系统上有多个显示设备。例如一个系统上，又有一个独立的显卡，那么就有两个缓冲区设备文件/dev/fb1 和 /dev/fb2,应用程序利用它们来工作，向其中写入数据，就能够在屏幕上立刻看到显示的变化

 

Framebuffer与应用程序的交互：

          在Linux中，Framebuffer是一种能够提取图形的硬件设备，是用户进入图形界面的很好接口。

　　   Framebuffer是显存抽象后的一种设备，它允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。

          这种操作是抽象的、统一的。

          用户不必关系物理显存的位置、换页机制等具体细节

          这些都由Framebuffer设备驱动程序来完成的

          有了Framebuffer，用户程序不需要对底层的驱动深入了解就能够作出很好的图形

         对用户程序而言，它和 /dev 下面的其他设备没有什么区别，用户可以把FrameBuffer看成一块内存，既可以写，又可以读。显示器将根据内存数据显示对应的图像界面。这一切都由LCD控制器和响应的驱动程序来完成

        Framebuffer的显示缓冲区位于Linux的内核态地址空间。而在Linux中，每个应用程序都有自己的虚拟地址空间，在应用程序中是不能直接访问物理缓冲区的。为此，Linux在文件操作file_operations结构中提供了mmap()函数，可将文件的内容映射到用户空间。对应帧缓冲设备，则可以通过映射操作，将屏幕缓冲区（Framebuffer）的物理地址映射到用户空间的一段虚拟地址中，之后用户就可以通过读写这段虚拟地址访问屏幕缓冲区，在屏幕上绘图。

  Framebuffer与应用程序的交互如下图：

Framebuffer显示原理：

通过Framebuffer，应用程序用mmap()把显存映射到应用程序虚拟地址空间。帧缓冲设备主设备号29，次设备号从0到31.分别对应/dev/fd0  ~   /dev/fd31

 

简单地说：Framebuffer驱动的功能就是分配一块内存作为显存，然后LCD控制器的寄存器做一些设置。LCD显示器会不断地从显存中获取数据，并将其显示在LCD显示器上。LCD显示器可以显示显存中的一个区域或者整个区域。framebuffer驱动程序提供了操作显存的功能，例如复制显存、向显存中写入数据（画园，画方型等）

具体来说：实现这些操作的方法是，填充一个fbinfo结构，用register_framebuffer(fbinfo *)将fbinfo结构注册到内核，对于fbinfo结构，最主要的它的fs_ops成员，需要针对具体设备实现fs_ops中的接口

 

Framebuffer是LCD驱动中最重要的一部分，通过Framebuffer使Linux内核可以使用大多数显示设备的功能

/include/linux/fb.h        

/drivers/video/fbmem.c

Framebuffer驱动主要位于上面两个文件中，它们处于驱动体系结构的中间层，为上层用户程序提供系统调用，也为底层特定硬件驱动提供了接口

 

fb.h中定义了一些主要的数据结构，Frameuffer设备在很大程度上依靠了下面的3个数据结构。

struct  fb_var_screeninfo、struct  fb_fix_screeninfo   和 struct  fb_info

第一个结构体用来描述图形卡的特性，通常是被用户设置的

第二个结构体定义了图形卡的硬件特性，是不能改变的，用户选定了LCD控制器和显示器后，那么硬件特性也就定下来了

第三个结构体定义了当前图形卡Framebuffer设备的独立状态，一个图形卡可能有两个Framebuffer，在这种情况下，就需要两个fb_info结构。这个结构是唯一内核空间可见的

其他数据结构：

1，struct  fb_cmap结构体：用来定义帧缓存区设备的颜色表（colormap）信息，可以通过ioctl（）函数的FBIOGETCMAP和FBIOPUTCMAP命令来设置colormap

2，struct  fb_info 结构体：包含当前显示卡的状态信息，struct  fb_info结构体只对内核可见

3，struct fb_ops结构体：应用程序使用这些函数操作底层的LCD硬件，fb_ops结构中定义的方法用于支持这些操作。这些操作需要驱动开发人员来实现

4，struct fb_fix_screeninfo结构体：定义了显卡信息，如framebuffer内存的起始地址，地址的长度

5，struct fb_var_screeninfo结构体：描述了一种显示模式的所有信息，如宽、高、颜色深度等，不同显示模式对应不同的信息

在Framebuffer设备驱动程序中，这些结构是互相关联，互相配合使用的。只有每一个结构体起到自己的作用，才能使整个Framebuffer设备驱动程序正常工作。

它们有如下工作：

其中struct fb_info结构体包含了其他4个结构体的指针

 

Framebuffer驱动实现：

一般来说，应用程序通过内核对Framebuffer的控制，主要有以下3种方式：

1，读/写  /dev/fb相当于读/写屏幕缓冲区

2，通过映射操作，可将屏幕缓冲区的物理地址映射到用户空间的一段虚拟地址中，之后用户就可以通过读写这段虚拟地址访问屏幕缓冲区，在屏幕上绘图

3，I/O控制对于帧缓冲设备，设备文件的ioctl（）函数可读取/设置显示设备及屏幕的参数，如分辨率、显示颜色数、屏幕大小等。ioctl（）函数由底层的驱动程序完成

因此，Framebuffer驱动要完成的工作已经很少了，只需分配显存的大小、初始化LCD控制寄存器、设置修改硬件设备相应的struct fb_fix_screeninfo信息和 struct fb_var_screeninfo信息。这些信息是与具体的显示设备相关的。

帧缓冲设备属于字符设备，采用“文件层——驱动层”的接口方式，在文件层次上，Linux定义了fb_fops

static const struct file_operations fb_fops = {
    .owner =    THIS_MODULE,
    .read =        fb_read,                               //读操作
    .write =    fb_write,                                   //写操作
    .unlocked_ioctl = fb_ioctl,                         //控制操作
#ifdef CONFIG_COMPAT
    .compat_ioctl = fb_compat_ioctl,                   
#endif
    .mmap =        fb_mmap,                              //映射操作
    .open =        fb_open,                                  //打开操作
    .release =    fb_release,                               //关闭操作
#ifdef HAVE_ARCH_FB_UNMAPPED_AREA
    .get_unmapped_area = get_fb_unmapped_area,
#endif
#ifdef CONFIG_FB_DEFERRED_IO
    .fsync =    fb_deferred_io_fsync,
#endif
};

在Linux中，由于帧缓冲设备是字符设备，应用程序需按文件的方式打开一个帧缓冲设备。

如果打开成功，则可对帧缓冲设备进行读、写等操作。

读、写帧缓冲设备最主要的任务就是获取帧缓冲设备在内存中的物理地址空间及相应LCD的一些特性。应用程序通过写帧缓冲设备来显示图形的全过程如下：

编写帧缓冲驱动的工作：

1，编写初始化函数：初始化函数首先初始化LCD控制器，通过写寄存器设置显示模式和显示颜色数，然后分配LCD显示缓冲区。在Linux中可通过kmalloc（）函数分配一片连续的空间。例如：采用的LCD显示方式为320X240，256位灰度。需要分配的显示缓冲区为：240X320 = 750K字节，缓冲区通常分配在大容量的片外SDRAM中，其实地址保存在LCD控制器寄存器中。最后是初始化一个fb_info 结构，填充其中的成员变量，并调用register_framebuffer(&fb_info)，将fb_info登记入内核。

2，编写结构struct fb_info中函数指针fb_ops对应的成员函数，对于嵌入式系统的简单实现，只需要实现少量的函数

 

fb_info是帧缓冲Framebuffer设备驱动中一个非常重要的结构体。它包含了驱动实现的底层函数和记录设备状态的数据。一个帧缓冲区对应一个fb_info结构体：

struct fb_info {
    int node;                                                        
    int flags;
    struct mutex lock;        /* Lock for open/release/ioctl funcs */                            //为 open/release/ioctl 等函数准备的互斥锁
    struct fb_var_screeninfo var;    /* Current var */                                                //当前缓冲区的可变参数，也就是当前视频信息
    struct fb_fix_screeninfo fix;    /* Current fix */                                                   //当前缓冲区的固定参数
    struct fb_monspecs monspecs;    /* Current Monitor specs */                         //当前显示器的标志
    struct work_struct queue;    /* Framebuffer event queue */                              //帧缓冲的事件队列
    struct fb_pixmap pixmap;    /* Image hardware mapper */                               //图像硬件mapper
    struct fb_pixmap sprite;    /* Cursor hardware mapper */                                 //光标硬件mapper
    struct fb_cmap cmap;        /* Current cmap */                                                  //当前的颜色板，也叫调色板
    struct list_head modelist;      /* mode list */                                                      //模块列表t
    struct fb_videomode *mode;    /* current mode */                                            //当前视频模式
   
#ifdef CONFIG_FB_BACKLIGHT                      //如果配置了LCD支持背光灯
    /* assigned backlight device */
    /* set before framebuffer registration, 
       remove after unregister */
    struct backlight_device *bl_dev;                    //对应的背光灯设备，设置bl_dev这个变量，应该在注册Framebuffer之前

    /* Backlight level curve */
    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;        /* This is the parent */                       //指向父设备结构体
    struct device *dev;        /* This is this fb device */                    //内嵌的Framebuffer设备自身
    int class_flag;                    /* private sysfs flags */                  //私有sysfs标志
#ifdef CONFIG_FB_TILEBLITTING
    struct fb_tile_ops *tileops;    /* Tile Blitting */                       //图块Blitting
#endif
    char __iomem *screen_base;    /* Virtual address */                               //虚拟基地址
    unsigned long screen_size;    /* Amount of ioremapped VRAM or 0 */          //ioremap的虚拟内存大小
    void *pseudo_palette;        /* Fake palette of 16 colors */                               //伪16位调色板
#define FBINFO_STATE_RUNNING    0                                      // 运行状态
#define FBINFO_STATE_SUSPENDED    1                                  // 挂起状态
    u32 state;            /* Hardware state i.e suspend */                    //硬件的状态
    void *fbcon_par;                /* fbcon use-only private area */                 //fbcon使用的私有数据
    /* From here on everything is device dependent */
    void *par;    
};

 

 

struct fb_videomode {                               //视频模式
    const char *name;    /* optional */
    u32 refresh;        /* optional */
    u32 xres;
    u32 yres;
    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 flag;
};

 

struct fb_pixmap {
    u8  *addr;        /* pointer to memory            */
    u32 size;        /* size of buffer in bytes        */
    u32 offset;        /* current offset to buffer        */
    u32 buf_align;        /* byte alignment of each bitmap    */
    u32 scan_align;        /* alignment per scanline        */
    u32 access_align;    /* alignment per read/write (bits)    */
    u32 flags;        /* see FB_PIXMAP_*            */
    u32 blit_x;             /* supported bit block dimensions (1-32)*/
    u32 blit_y;             /* Format: blit_x = 1 << (width - 1)    */
                            /*         blit_y = 1 << (height - 1)   */
                            /* if 0, will be set to 0xffffffff (all)*/
    /* access methods */
    void (*writeio)(struct fb_info *info, void __iomem *dst, void *src, unsigned int size);
    void (*readio) (struct fb_info *info, void *dst, void __iomem *src, unsigned int size);
};

 

struct fb_monspecs {
    struct fb_chroma chroma;
    struct fb_videomode *modedb;    /* mode database */
    __u8  manufacturer[4];        /* Manufacturer */
    __u8  monitor[14];        /* Monitor String */
    __u8  serial_no[14];        /* Serial Number */
    __u8  ascii[14];        /* ? */
    __u32 modedb_len;        /* mode database length */
    __u32 model;            /* Monitor Model */
    __u32 serial;            /* Serial Number - Integer */
    __u32 year;            /* Year manufactured */
    __u32 week;            /* Week Manufactured */
    __u32 hfmin;            /* hfreq lower limit (Hz) */
    __u32 hfmax;            /* hfreq upper limit (Hz) */
    __u32 dclkmin;            /* pixelclock lower limit (Hz) */
    __u32 dclkmax;            /* pixelclock upper limit (Hz) */
    __u16 input;            /* display type - see FB_DISP_* */
    __u16 dpms;            /* DPMS support - see FB_DPMS_ */
    __u16 signal;            /* Signal Type - see FB_SIGNAL_* */
    __u16 vfmin;            /* vfreq lower limit (Hz) */
    __u16 vfmax;            /* vfreq upper limit (Hz) */
    __u16 gamma;            /* Gamma - in fractions of 100 */
    __u16 gtf    : 1;        /* supports GTF */
    __u16 misc;            /* Misc flags - see FB_MISC_* */
    __u8  version;            /* EDID version... */
    __u8  revision;            /* ...and revision */
    __u8  max_x;            /* Maximum horizontal size (cm) */
    __u8  max_y;            /* Maximum vertical size (cm) */
};

 

struct fb_chroma {
    __u32 redx;    /* in fraction of 1024 */
    __u32 greenx;
    __u32 bluex;
    __u32 whitex;
    __u32 redy;
    __u32 greeny;
    __u32 bluey;
    __u32 whitey;
};

 

struct fb_cmap_user {
    __u32 start;            /* First entry    */
    __u32 len;            /* Number of entries */
    __u16 __user *red;        /* Red values    */
    __u16 __user *green;
    __u16 __user *blue;
    __u16 __user *transp;        /* transparency, can be NULL */
};

struct fb_image_user {
    __u32 dx;            /* Where to place image */
    __u32 dy;
    __u32 width;            /* Size of image */
    __u32 height;
    __u32 fg_color;            /* Only used when a mono bitmap */
    __u32 bg_color;
    __u8  depth;            /* Depth of the image */
    const char __user *data;    /* Pointer to image data */
    struct fb_cmap_user cmap;    /* color map info */
};

struct fb_cursor_user {
    __u16 set;            /* what to set */
    __u16 enable;            /* cursor on/off */
    __u16 rop;            /* bitop operation */
    const char __user *mask;    /* cursor mask bits */
    struct fbcurpos hot;        /* cursor hot spot */
    struct fb_image_user image;    /* Cursor image */
};

 

fb_ops结构体用来实现对帧缓冲设备的操作。用户可以使用ioctl（）函数来操作设备：

struct fb_ops {
    /* open/release and usage marking */
    struct module *owner;                                                  //模块计数指针
    int (*fb_open)(struct fb_info *info, int user);                           //打开设备指针
    int (*fb_release)(struct fb_info *info, int user);                       //释放设备指针

    /* For framebuffers with strange non linear layouts or that do not
     * work with normal memory mapped access
     */             //下面两个函数对于非线性布局的常规内存无法工作的帧缓冲区设备有效
    ssize_t (*fb_read)(struct fb_info *info, char __user *buf,
               size_t count, loff_t *ppos);                                             
    ssize_t (*fb_write)(struct fb_info *info, const char __user *buf,
                size_t count, loff_t *ppos);

    /* checks var and eventually tweaks it to something supported,
     * DO NOT MODIFY PAR */
    int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);     //检查可变参数，并调整到支持设备。用来检查和改变帧缓存设备的可变参数，当帧缓冲设备中的参数不满足驱动程序要求时，会调用这个函数

    /* set the video mode according to info->var */
    int (*fb_set_par)(struct fb_info *info);                                                 //设置视频模式。根据info->var变量设备视频模式

    /* set color register */
    int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
                unsigned blue, unsigned transp, struct fb_info *info);                                   //设置color寄存器。用来设置帧缓冲区设备的颜色相关寄存器的值

    /* set color registers in batch */
    int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);                       //批量的设置颜色寄存器的值，即设置颜色表

    /* blank display */
    int (*fb_blank)(int blank, struct fb_info *info);                                         //显示空白。用于缓冲区设备的开关操作

    /* pan display */
    int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);                         //显示pan。用于设置帧缓冲设备的开关设备

    /* Draws a rectangle */
    void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);                                //填充一个矩形
    /* Copy data from area to another */
    void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);                  //复制数据从一个区域到另一个区域
    /* Draws a image to the display */
    void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);                    //画一个图像到屏幕上

    /* Draws cursor */
    int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);                                     //绘制光标

    /* Rotates the display */
    void (*fb_rotate)(struct fb_info *info, int angle);                                                            //旋转屏幕并且显示出来 。旋转显示缓冲区

    /* wait for blit idle, optional */
    int (*fb_sync)(struct fb_info *info);                                                                               //等待blit空闲。用于数据发送

    /* perform fb specific ioctl (optional) */
    int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
            unsigned long arg);                                                                      //实现fb特定的ioctl操作。用于执行ioctl（）操作，类似字符设备的ioctl（）函数

    /* Handle 32bit compat ioctl (optional) */
    int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
            unsigned long arg);                                                                          //处理32位的兼容ioctl操作

    /* perform fb specific mmap */
    int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);             //实现fb特定的mmap操作。执行帧缓冲设备具体的内存映射

    /* save current hardware state */
    void (*fb_save_state)(struct fb_info *info);                                                   //保存当前的硬件状态。用来保存当前硬件的寄存器的值

    /* restore saved state */
    void (*fb_restore_state)(struct fb_info *info);                                               //恢复被保存的硬件状态

    /* get capability given var */
    void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
                struct fb_var_screeninfo *var);                                                  //通过fb_info获得Framebuffer的能力。用来获得Framebuffer设备的能力。外部应用程序可以通过这个函数快速的得到设备的信息 
};

fb_cmap结构体记录了一个颜色信息，也可以叫做调色板。用户可以使用ioctl（）函数的FBIOGETCMAP和FBIOPUTCMAP命令读取和设置颜色表的值：

struct fb_cmap {
    __u32 start;            /* First entry    */                             //表示颜色板的第一个元素入口位置
    __u32 len;            /* Number of entries */                       //len表示元素的个数
    __u16 *red;            /* Red values    */                             //红色分量的值
    __u16 *green;                                                                 //绿色分量的值
    __u16 *blue;                                                                     //蓝色分量的值
    __u16 *transp;            /* transparency, can be NULL */            //透明度分量的值
};

fb_cmap结构体对应的存储结构体如下图：

 

fb_var_screeninfo结构体存储了用户可以修改的显示器控制器的参数。例如屏幕分辨率、每个像素的比特数、透明度等:

struct fb_var_screeninfo {
    __u32 xres;            /* visible resolution        */             //xres和yres表示可见解析度，即分辨率。xres表示一行有多少个像素点，yres表示屏幕一列有多少个像素点
    __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 */                                //非0时的灰度值

    struct fb_bitfield red;        /* bitfield in fb mem if true color, */                                   //下面是fb缓存的R、G、B位域
    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 */                        //fb_info的标志

    /* 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[5];        /* Reserved for future compatibility */                                          //保留
};

 

struct fb_bitfield {
    __u32 offset;            /* beginning of bitfield    */
    __u32 length;            /* length of bitfield        */
    __u32 msb_right;        /* != 0 : Most significant bit is */ 
                    /* right */ 
};

fb_fix_screeninfo结构体，记录了用户不能修改的固定显示器控制参数。这些固定参数如缓冲区的物理地址、缓冲区的长度、显示色彩模式、内存映射的开始位置等。这个结构体的成员都需要在驱动程序初始化时设置：

struct fb_fix_screeninfo {
    char id[16];            /* identification string eg "TT Builtin" */                                   //字符串形式的标志符
    unsigned long smem_start;    /* Start of frame buffer mem */                               //fb缓冲区的开始位置
                    /* (physical address) */
    __u32 smem_len;            /* Length of frame buffer mem */                                   //fb缓冲区的长度
    __u32 type;            /* see FB_TYPE_*        */                                                         //FB_TYPE_*类型
    __u32 type_aux;            /* Interleave for interleaved Planes */                              //分界
    __u32 visual;            /* see FB_VISUAL_*        */                                                   //屏幕使用色彩模式
    __u16 xpanstep;            /* zero if no hardware panning  */                                    //如果没有硬件panning，赋值0
    __u16 ypanstep;            /* zero if no hardware panning  */                                     //如果没有硬件panning，赋值0
    __u16 ywrapstep;        /* zero if no hardware ywrap    */                                        //如果没有硬件panning，赋值0

    __u32 line_length;        /* length of a line in bytes    */                                             //一行的字节数
    unsigned long mmio_start;    /* Start of Memory Mapped I/O   */                             //内存映射I/O的开始位置
                    /* (physical address) */
    __u32 mmio_len;            /* Length of Memory Mapped I/O  */                                   //内存映射I/O的长度
    __u32 accel;            /* Indicate to driver which    */                                                     //特定的芯片
                    /*  specific chip/card we have    */
    __u16 reserved[3];        /* Reserved for future compatibility */                                     //保留
};

平台驱动的加载和卸载：

int __init s3c2410fb_init(void)
{
    int ret = platform_driver_register(&s3c2410fb_driver);           //注册平台驱动，将平台驱动添加到虚拟的总线上

    if (ret == 0)
        ret = platform_driver_register(&s3c2412fb_driver);;                      //防止驱动注册成功，但是探测函数探测LCD控制器设备失败

    return ret;
}

static void __exit s3c2410fb_cleanup(void)
{
    platform_driver_unregister(&s3c2410fb_driver);
    platform_driver_unregister(&s3c2412fb_driver);
}

 

平台驱动：s3c2410_i2c_driver

static struct platform_driver s3c2410fb_driver = {
    .probe        = s3c2410fb_probe,
    .remove        = s3c2410fb_remove,
    .suspend    = s3c2410fb_suspend,
    .resume        = s3c2410fb_resume,
    .driver        = {
        .name    = "s3c2410-lcd",
        .owner    = THIS_MODULE,
    },
};

 

LCD驱动程序的平台数据：

为了方便管理，Linux内核将LCD驱动程序归入平台设备的范畴。这样可以使用平台设备的方法操作LCD设备。LCD驱动程序的平台设备定义为s3c_devcie_lcd:

struct  platform_device   s3c_device_lcd =

{

　　.name = "s3c2410-lcd",

       .id = -1  ,              //ID表示LCD设备的编号，-1表示只有这样一个设备

       .num_resource =  ARRAY_SIZE(s3c_lcd_resource),           //资源数量

       .resource  =      s3c_lcd_resource,                                    //资源指针

       .dev = 

       {

                     .dam_mask  = &s3c_device_lcd_dmamask,

                     .coherent_dma_mask      =     0xffffffffUL

         }

};

 

enum s3c_drv_type {
    DRV_S3C2410,
    DRV_S3C2412,
};

struct s3c2410fb_info {
    struct device        *dev;
    struct clk        *clk;

    struct resource        *mem;
    void __iomem        *io;
    void __iomem        *irq_base;

    enum s3c_drv_type    drv_type;
    struct s3c2410fb_hw    regs;

    unsigned int        palette_ready;

    /* keep these registers in case we need to re-write palette */
    u32            palette_buffer[256];
    u32            pseudo_pal[16];
};

 

 

static struct     resource   s3c_lcd_resource[]

{

     [0] = {

                       //LCD的I/O内存开始位置，地址被定义为0x4D000000

                        .start = S3C24XX_PA_LCD,

                        .end  =  S3C24XX_PA_LCD + S3C24XX_SZ_LCD  -  1,                //1M的地址空间

                         .flags  = IORESOURCE_MEM,                                                       //I/O内存资源

                },

      [1] = {

                        .start  =  IRQ_LCD,                 //LCD开始中断号

                        .end    =  IRQ_LCD,                 //LCD结束中断号

                        .flags = IRQRESOURCE_IRQ,       //中断的IRQ资源

               }

};

 

s3c2410_mach_info表示LCD显示的平台信息：

struct s3c2410fb_mach_info {
 struct s3c2410fb_display *displays; /* attached diplays info */        //存储相似信息
 unsigned num_displays; /* number of defined displays */                 //显示缓冲的数量
 unsigned default_display;
 /* GPIOs */           //GPIO引脚
 unsigned long gpcup;
 unsigned long gpcup_mask;
 unsigned long gpccon;
 unsigned long gpccon_mask;
 unsigned long gpdup;
 unsigned long gpdup_mask;
 unsigned long gpdcon;
 unsigned long gpdcon_mask;
 /* lpc3600 control register */         //lpc3600控制寄存器
 unsigned long lpcsel;
};

 

 

/* LCD description */
struct s3c2410fb_display {
 /* LCD type */
 unsigned type;                       //LCD显示屏的类型
 /* Screen size */
 unsigned short width;                 //屏的大小，宽度
 unsigned short height;               //屏高
 /* Screen info */         //下面3行存储的是屏幕信息
 unsigned short xres;
 unsigned short yres;
 unsigned short bpp;
 unsigned pixclock; /* pixclock in picoseconds */
 unsigned short left_margin; /* value in pixels (TFT) or HCLKs (STN) */
 unsigned short right_margin; /* value in pixels (TFT) or HCLKs (STN) */
 unsigned short hsync_len; /* value in pixels (TFT) or HCLKs (STN) */
 unsigned short upper_margin; /* value in lines (TFT) or 0 (STN) */
 unsigned short lower_margin; /* value in lines (TFT) or 0 (STN) */
 unsigned short vsync_len; /* value in lines (TFT) or 0 (STN) */
 /* lcd configuration registers */
 unsigned long lcdcon5;                 //LCD配置寄存器
};

 

struct s3c2410fb_hw {                    //5个LCD配置寄存器
 unsigned long lcdcon1;
 unsigned long lcdcon2;
 unsigned long lcdcon3;
 unsigned long lcdcon4;
 unsigned long lcdcon5;
};

 

LCD模块探测函数：

s3c2412fb_probe()函数中调用了s3c24xxfb_probe()，第二个参数是处理器的类型：

static int __init s3c2412fb_probe(struct platform_device *pdev)
{
    return s3c24xxfb_probe(pdev, DRV_S3C2412);
}

static int __init s3c24xxfb_probe(struct platform_device *pdev,
                  enum s3c_drv_type drv_type)
{
    struct s3c2410fb_info *info;
    struct s3c2410fb_display *display;
    struct fb_info *fbinfo;
    struct s3c2410fb_mach_info *mach_info;
    struct resource *res;
    int ret;
    int irq;
    int i;
    int size;
    u32 lcdcon1;

    mach_info = pdev->dev.platform_data;                                 //得到s3c2410fb_mach_info类型结构体变量，保存在内核中的平台设备数据
    if (mach_info == NULL) {                                                            //没有相关的平台设备，LCD驱动程序提前退出
        dev_err(&pdev->dev,
            "no platform data for lcd, cannot attach\n");
        return -EINVAL;
    }

    if (mach_info->default_display >= mach_info->num_displays) {                          
        dev_err(&pdev->dev, "default is %d but only %d displays\n",
            mach_info->default_display, mach_info->num_displays);
        return -EINVAL;
    }

    display = mach_info->displays + mach_info->default_display;                                //获取内核定义的Framebuffer平台设备的LCD配置信息结构体数据

    irq = platform_get_irq(pdev, 0);                                                 //获取LCD中断号
    if (irq < 0) {                                                                       //<0，没有中断，返回相应的错误
        dev_err(&pdev->dev, "no irq for device\n");
        return -ENOENT;
    }

    fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), &pdev->dev);                                //申请一个struct s3c2410_info结构体空间，存储驱动相关数据
    if (!fbinfo)
        return -ENOMEM;

    platform_set_drvdata(pdev, fbinfo);                                                //这4行，填充info结构体变量

    info = fbinfo->par;
    info->dev = &pdev->dev;
    info->drv_type = drv_type;

    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);                //获得I/O端口资源，大小1M，
    if (res == NULL) {
        dev_err(&pdev->dev, "failed to get memory registers\n");
        ret = -ENXIO;
        goto dealloc_fb;
    }

    size = (res->end - res->start) + 1;
    info->mem = request_mem_region(res->start, size, pdev->name);                     //申请LCD设备的I/O端口所占用的I/O空间
    if (info->mem == NULL) {
        dev_err(&pdev->dev, "failed to get memory region\n");
        ret = -ENOENT;
        goto dealloc_fb;
    }

    info->io = ioremap(res->start, size);                   //将LCD的I/O端口占用的这段I/O空间映射到内存的虚拟地址：I/O空间映射后才能使用
    if (info->io == NULL) {
        dev_err(&pdev->dev, "ioremap() of registers failed\n");
        ret = -ENXIO;
        goto release_mem;
    }

    info->irq_base = info->io + ((drv_type == DRV_S3C2412) ? S3C2412_LCDINTBASE : S3C2410_LCDINTBASE);       

    dprintk("devinit\n");

    strcpy(fbinfo->fix.id, driver_name);

    /* Stop the video */
    lcdcon1 = readl(info->io + S3C2410_LCDCON1);
    writel(lcdcon1 & ~S3C2410_LCDCON1_ENVID, info->io + S3C2410_LCDCON1);

    fbinfo->fix.type        = FB_TYPE_PACKED_PIXELS;
    fbinfo->fix.type_aux        = 0;
    fbinfo->fix.xpanstep        = 0;
    fbinfo->fix.ypanstep        = 0;
    fbinfo->fix.ywrapstep        = 0;
    fbinfo->fix.accel        = FB_ACCEL_NONE;

    fbinfo->var.nonstd        = 0;
    fbinfo->var.activate        = FB_ACTIVATE_NOW;
    fbinfo->var.accel_flags     = 0;
    fbinfo->var.vmode        = FB_VMODE_NONINTERLACED;

    fbinfo->fbops            = &s3c2410fb_ops;
    fbinfo->flags            = FBINFO_FLAG_DEFAULT;
    fbinfo->pseudo_palette      = &info->pseudo_pal;

    for (i = 0; i < 256; i++)
        info->palette_buffer[i] = PALETTE_BUFF_CLEAR;

    ret = request_irq(irq, s3c2410fb_irq, IRQF_DISABLED, pdev->name, info);
    if (ret) {
        dev_err(&pdev->dev, "cannot get irq %d - err %d\n", irq, ret);
        ret = -EBUSY;
        goto release_regs;
    }

    info->clk = clk_get(NULL, "lcd");                 //获得LCD时钟，因为各种那个控制信号的延迟都与LCD的时钟有关
    if (!info->clk || IS_ERR(info->clk)) {
        printk(KERN_ERR "failed to get lcd clock source\n");
        ret = -ENOENT;
        goto release_irq;
    }

    clk_enable(info->clk);                //使能时钟
    dprintk("got and enabled clock\n");

    msleep(1);

    /* find maximum required memory size for display */
    for (i = 0; i < mach_info->num_displays; i++) {
        unsigned long smem_len = mach_info->displays[i].xres;

        smem_len *= mach_info->displays[i].yres;
        smem_len *= mach_info->displays[i].bpp;
        smem_len >>= 3;
        if (fbinfo->fix.smem_len < smem_len)
            fbinfo->fix.smem_len = smem_len;
    }

    /* Initialize video memory */
    ret = s3c2410fb_map_video_memory(fbinfo);                           //分配DRAM内存给Framebuffer，并且初始化这段内存
    if (ret) {
        printk(KERN_ERR "Failed to allocate video RAM: %d\n", ret);
        ret = -ENOMEM;
        goto release_clock;
    }

    dprintk("got video memory\n");

    fbinfo->var.xres = display->xres;
    fbinfo->var.yres = display->yres;
    fbinfo->var.bits_per_pixel = display->bpp;

    s3c2410fb_init_registers(fbinfo);                              //初始化LCD控制器相关的寄存器
        
    s3c2410fb_check_var(&fbinfo->var, fbinfo);     //检查Framebuffer的相关参数

    ret = register_framebuffer(fbinfo);      //注册这个帧缓冲设备fb_info到系统中
    if (ret < 0) {
        printk(KERN_ERR "Failed to register framebuffer device: %d\n",
            ret);
        goto free_video_memory;
    }

    /* create device files */
    ret = device_create_file(&pdev->dev, &dev_attr_debug);            //对设备文件系统支持
    if (ret) {
        printk(KERN_ERR "failed to add debug attribute\n");
    }

    printk(KERN_INFO "fb%d: %s frame buffer device\n", 
        fbinfo->node, fbinfo->fix.id);

    return 0;


//以下是错误处理：释放时钟、取消内存映射、释放资源
free_video_memory:
    s3c2410fb_unmap_video_memory(fbinfo);
release_clock:
    clk_disable(info->clk);
    clk_put(info->clk);
release_irq:
    free_irq(irq, info);
release_regs:
    iounmap(info->io);
release_mem:
    release_resource(info->mem);
    kfree(info->mem);
dealloc_fb:
    platform_set_drvdata(pdev, NULL);
    framebuffer_release(fbinfo);
    return ret;
}

与s3c2412fb_probe()函数完成相反功能的是s3c2410fb_remove()：

static int s3c2410fb_remove(struct platform_device *pdev)
{
    struct fb_info *fbinfo = platform_get_drvdata(pdev);       //调用platform_get_drvdata()函数从平台设备中获得fbinfo结构体指针，该结构包含了Framebuffer主要信息
    struct s3c2410fb_info *info = fbinfo->par;                 //从fbinfo->par中获得info指针
    int irq;

    unregister_framebuffer(fbinfo);                         //注销帧缓存设备

    s3c2410fb_lcd_enable(info, 0);              //关闭LCD控制器，第二个参数为1，打开；为0，关闭
    msleep(1);                                                   //等待1ms时间，等待向LCD控制器的寄存器写入成功。因为寄存器的写入速度要比程序执行速度慢得多
 
    s3c2410fb_unmap_video_memory(fbinfo);             //释放显示缓冲区

    if (info->clk) {                                                         //释放时钟源
        clk_disable(info->clk);          
        clk_put(info->clk);
        info->clk = NULL;
    }

    irq = platform_get_irq(pdev, 0);                                       
    free_irq(irq, info);                                                            //释放IRQ中断

    iounmap(info->io);                                                        //取消寄存器的内存映射

    release_resource(info->mem);                                  //释放内存区域占用的资源
    kfree(info->mem);                                                       //释放内存

    platform_set_drvdata(pdev, NULL);
    framebuffer_release(fbinfo);                                        //向内核注销Framebuffer设备

    return 0;
}