linux中Framebuffer的原理及实现机制

*一、FrameBuffer的原理*

         FrameBuffer 是出现在 2.2.xx 内核当中的一种驱动程序接口。
         Linux是工作在保护模式下，所以用户态进程是无法象DOS那样使用显卡BIOS里提供的中断调用来实现直接写屏，Linux抽象出 FrameBuffer这 个设备来供用户态进程实现直接写屏。Framebuffer机制模仿显卡的功能，将显卡硬件结构抽象掉，可以通过Framebuffer的读写直接对显存进行操 作。用户可以将Framebuffer看成是显示内存的一个映像，将其映射到进程地址空间之后，就可以直接进行读写操作，而写操作可以立即反应在屏幕上。 这种操 作是抽象的，统一的。用户不必关心物理显存的位置、换页机制等等具体细节。这些都是由Framebuffer设备驱动来完成的。
        但Framebuffer本身不具备任何运算数据的能力,就只好比是一个暂时存放水的水池.CPU将运算后的结果放到这个水池，水池再将结果流到显示器. 中间不会对数据做处理. 应用程序也可以直接读写这个水池的内容.在这种机制下，尽管Framebuffer需要真正的显卡驱动的支持，但所有显示任务都有CPU完成,因此CPU 负担很重.
framebuffer的设备文件一般是 /dev/fb0、/dev/fb1 等等。
可以用命令: #dd if=/dev/zero of=/dev/fb 清空屏幕.
如果显示模式是 1024×768-8 位色，用命令：$ dd if=/dev/zero of=/dev/fb0 bs=1024 count=768 清空屏幕；
用命令: #dd if=/dev/fb of=fbfile 可以将fb中的内容保存下来；
可以重新写回屏幕: #dd if=fbfile of=/dev/fb；
在使用Framebuffer时，Linux是将显卡置于图形模式下的．

在应用程序中，一般通过将 FrameBuffer 设备映射到进程地址空间的方式使用，比如下面的程序就打开 /dev/fb0 设备，并通过mmap 系统调用进行地址映射，随后用 memset 将屏幕清空（这里假设显示模式是 1024×768-8 位色模式，线性内存模式）：

[plain] view plaincopy

1. int fb;  
2. unsigned char* fb_mem;  
3. fb = open (“/dev/fb0″, O_RDWR);  
4. fb_mem = mmap (NULL, 1024*768, PROT_READ|PROT_WRITE,MAP_SHARED,fb,0);  
5. memset (fb_mem, 0, 1024*768 );  

FrameBuffer 设备还提供了若干ioctl命令，通过这些命令，可以获得显示设备的一些固定信息（比如显示内存大小）、与显示模式相关的可变信息（比如分辨率、象素结构、每扫描线的字节宽度），以及伪彩 色模式下的调色板信息等等。
通过 FrameBuffer设备，还可以获得当前内核所支持的加速显示卡的类型（通过固定信息得到），这种类型通常是和特定显示芯片相关的。比如目前最新的内核（2.4.9）中，就包含有 对S3、Matrox、nVidia、3Dfx 等等流行显示芯片的加速支持。在获得了加速芯片类型之后，应用程序就可以将 PCI设备的内存I/O（memio）映射到进程的地址空间。这些memio
一般是用来控制显示卡的寄存器，通过对这些寄存器的操作，应用程序就可以控制特定显卡的加速功能。
PCI设备可以将自己的控制寄存器映射到物理内存空间，而后，对这些控制寄存器的访问，给变成了对物理内存的访问。因此，这些寄存器又被称 为”memio”。一旦被映 射到物理内存，Linux的普通进程就可以通过 mmap 将这些内存 I/O 映射到进程地址空间，这样就可以直接访问这些寄存器了。
当然，因为不同的显示芯片具有不同的加速能力，对memio的使用和定义也各自不同，这时，就需要针对加速芯片的不同类型来编写实现不同的加速功能。比如 大多数芯片都提供了对矩形填充的硬件加速支持，但不同的芯片实现方 式不同，这时，就需要针对不同的芯片类型编写不同的用来完成填充矩形的函数。
FrameBuffer 只是一个提供显示内存和显示芯片寄存器从物理内存映射到进程地址空间中的设备。所以，对于应用程序而言，如果希望在FrameBuffer 之上进行图形编程，还需要自己动手完成其他许多工作。

*二、FrameBuffer在Linux中的实现和机制*

Framebuffer对应的源文件在linux/drivers/video/目录下。总的抽象设备文件为fbcon.c，在这个目录下还有与各种显卡驱动相关的源文件。
(一)、分析Framebuffer设备驱动
需要特别提出的是在INTEL平台上，老式的VESA1.2卡，如CGA/EGA卡，是不能支持Framebuffer的，因为Framebuffer要 求显卡支持线性帧缓冲，即CPU可以访问显缓冲中的每一位， 但是VESA1.2 卡只能允许CPU一次访问64K的地址空间。
FrameBuffer设备驱动基于如下两个文件：
1) linux/include/linux/fb.h
2) linux/drivers/video/fbmem.c 下面分析这两个文件。
1、fb.h
几乎主要的结构都是在这个中文件定义的。这些结构包括：

1）fb_var_screeninfo

这个结构描述了显示卡的特性：

[plain] view plaincopy

1. struct fb_var_screeninfo  
2. {  
3. __u32 xres; /* visible resolution */  
4. __u32 yres;  
5. __u32 xres_virtual; /* virtual resolution */  
6. __u32 yres_virtual;  
7. __u32 xoffset; /* offset from virtual to visible resolution */  
8. __u32 yoffset;  
9. __u32 bits_per_pixel; /* guess what */  
10. __u32 grayscale; /* != 0 Gray levels instead of colors */  
11. struct fb_bitfield red; /* bitfield in fb mem if true color, */  
12. struct fb_bitfield green; /* else only length is significant */  
13. struct fb_bitfield blue;  
14. struct fb_bitfield transp; /* transparency */  
15. __u32 nonstd; /* != 0 Non standard pixel format */  
16. __u32 activate; /* see FB_ACTIVATE_* */  
17. __u32 height; /* height of picture in mm */  
18. __u32 width; /* width of picture in mm */  
19. __u32 accel_flags; /* acceleration flags (hints) */  
20. /* Timing: All values in pixclocks, except pixclock (of course) */  
21. __u32 pixclock; /* pixel clock in ps (pico seconds) */  
22. __u32 left_margin; /* time from sync to picture */  
23. __u32 right_margin; /* time from picture to sync */  
24. __u32 upper_margin; /* time from sync to picture */  
25. __u32 lower_margin;  
26. __u32 hsync_len; /* length of horizontal sync */  
27. __u32 vsync_len; /* length of vertical sync */  
28. __u32 sync; /* see FB_SYNC_* */  
29. __u32 vmode; /* see FB_VMODE_* */  
30. __u32 reserved[6]; /* Reserved for future compatibility */  
31. };  

2) fb_fix_screeninfon

这个结构在显卡被设定模式后创建，它描述显示卡的属性，并且系统运行时不能被修改；比如FrameBuffer内存的起始地址。它依赖于被设定的模式，当一个模 式被设定后，内存信息由显示卡硬件给出，内存的位置等信息就不可以修改。

[plain] view plaincopy

1. struct fb_fix_screeninfo {  
2. char id[16]; /* identification string eg “TT Builtin” */  
3. unsigned long smem_start; /* Start of frame buffer mem */  
4. /* (physical address) */  
5. __u32 smem_len; /* Length of frame buffer mem */  
6. __u32 type; /* see FB_TYPE_* */  
7. __u32 type_aux; /* Interleave for interleaved Planes */  
8. __u32 visual; /* see FB_VISUAL_* */  
9. __u16 xpanstep; /* zero if no hardware panning */  
10. __u16 ypanstep; /* zero if no hardware panning */  
11. __u16 ywrapstep; /* zero if no hardware ywrap */  
12. __u32 line_length; /* length of a line in bytes */  
13. unsigned long mmio_start; /* Start of Memory Mapped I/O */  
14. /* (physical address) */  
15. __u32 mmio_len; /* Length of Memory Mapped I/O */  
16. __u32 accel; /* Type of acceleration available */  
17. __u16 reserved[3]; /* Reserved for future compatibility */  
18. };  

3) fb_cmap

描述设备无关的颜色映射信息。可以通过FBIOGETCMAP 和 FBIOPUTCMAP 对应的ioctl操作设定或获取颜色映射信息.

[plain] view plaincopy

1. struct fb_cmap {  
2. __u32 start; /* First entry */  
3. __u32 len; /* Number of entries */  
4. __u16 *red; /* Red values */  
5. __u16 *green;  
6. __u16 *blue;  
7. __u16 *transp; /* transparency, can be NULL */  
8. };  

4) fb_info

定义当显卡的当前状态；fb_info结构仅在内核中可见，在这个结构中有一个fb_ops指针， 指向驱动设备工作所需的函数集。

[plain] view plaincopy

1. struct fb_info {  
2. char modename[40]; /* default video mode */  
3. kdev_t node;  
4. int flags;  
5. int open; /* Has this been open already ? */  
6. #define FBINFO_FLAG_MODULE 1 /* Low-level driver is a module */  
7. struct fb_var_screeninfo var; /* Current var */  
8. struct fb_fix_screeninfo fix; /* Current fix */  
9. struct fb_monspecs monspecs; /* Current Monitor specs */  
10. struct fb_cmap cmap; /* Current cmap */  
11. struct fb_ops *fbops;  
12. char *screen_base; /* Virtual address */  
13. struct display *disp; /* initial display variable */  
14. struct vc_data *display_fg; /* Console visible on this display */  
15. char fontname[40]; /* default font name */  
16. devfs_handle_t devfs_handle; /* Devfs handle for new name */  
17. devfs_handle_t devfs_lhandle; /* Devfs handle for compat. symlink */  
18. int (*changevar)(int); /* tell console var has changed */  
19. int (*switch_con)(int, struct fb_info*);  
20. /* tell fb to switch consoles */  
21. int (*updatevar)(int, struct fb_info*);  
22. /* tell fb to update the vars */  
23. void (*blank)(int, struct fb_info*); /* tell fb to (un)blank the screen */  
24. /* arg = 0: unblank */  
25. /* arg > 0: VESA level (arg-1) */  
26. void *pseudo_palette; /* Fake palette of 16 colors and  
27. the cursor’s color for non  
28. palette mode */  
29. /* From here on everything is device dependent */  
30. void *par;  
31. };  

5) struct fb_ops

用户应用可以使用ioctl()系统调用来操作设备，这个结构就是用一支持ioctl()的这些操作的。

[plain] view plaincopy

1. struct fb_ops {  
2. /* open/release and usage marking */  
3. struct module *owner;  
4. int (*fb_open)(struct fb_info *info, int user);  
5. int (*fb_release)(struct fb_info *info, int user);  
6. /* get non settable parameters */  
7. int (*fb_get_fix)(struct fb_fix_screeninfo *fix, int con,  
8. struct fb_info *info);  
9. /* get settable parameters */  
10. int (*fb_get_var)(struct fb_var_screeninfo *var, int con,  
11. struct fb_info *info);  
12. /* set settable parameters */  
13. int (*fb_set_var)(struct fb_var_screeninfo *var, int con,  
14. struct fb_info *info);  
15. /* get colormap */  
16. int (*fb_get_cmap)(struct fb_cmap *cmap, int kspc, int con,  
17. struct fb_info *info);  
18. /* set colormap */  
19. int (*fb_set_cmap)(struct fb_cmap *cmap, int kspc, int con,  
20. struct fb_info *info);  
21. /* pan display (optional) */  
22. int (*fb_pan_display)(struct fb_var_screeninfo *var, int con,  
23. struct fb_info *info);  
24. /* perform fb specific ioctl (optional) */  
25. int (*fb_ioctl)(struct inode *inode, struct file *file, unsigned int cmd,  
26. unsigned long arg, int con, struct fb_info *info);  
27. /* perform fb specific mmap */  
28. int (*fb_mmap)(struct fb_info *info, struct file *file, struct  
29. vm_area_struct *vma);  
30. /* switch to/from raster image mode */  
31. int (*fb_rasterimg)(struct fb_info *info, int start);  
32. };  

6) structure map

[plain] view plaincopy

1. struct fb_info_gen | struct fb_info | fb_var_screeninfo  
2. | | fb_fix_screeninfo  
3. | | fb_cmap  
4. | | modename[40]  
5. | | fb_ops —|—>ops on var  
6. | | … | fb_open  
7. | | | fb_release  
8. | | | fb_ioctl  
9. | | | fb_mmap  
10. | struct fbgen_hwswitch -|-> detect  
11. | | encode_fix  
12. | | encode_var  
13. | | decode_fix  
14. | | decode_var  
15. | | get_var  
16. | | set_var  
17. | | getcolreg  
18. | | setcolreg  
19. | | pan_display  
20. | | blank  
21. | | set_disp  

[编排有点困难，第一行的第一条竖线和下面的第一列竖线对齐，第一行的第二条竖线和下面的第二列竖线对齐就可以了]
这个结构 fbgen_hwswitch抽象了硬件的操作.虽然它不是必需的，但有时候很有用.
2、 fbmem.c
fbmem.c 处于Framebuffer设备驱动技术的中心位置.它为上层应用程序提供系统调用也为下一层的特定硬件驱动提供接口；那些底层硬件驱动需要用到这儿的接口来向 系统内核注册它们自己.
fbmem.c 为所有支持FrameBuffer的设备驱动提供了通用的接口，避免重复工作.
1) 全局变量

[plain] view plaincopy

1. struct fb_info *registered_fb[FB_MAX];  
2. int num_registered_fb;  

这两变量记录了所有fb_info 结构的实例，fb_info 结构描述显卡的当前状态，所有设备对应的fb_info结构都保存在这个数组中，当一个FrameBuffer设备驱动向系统注册自己时，其对应的 fb_info结构就会添加到这个结构中，同时num_registered_fb 为自动加1.

[plain] view plaincopy

1. static struct {  
2. const char *name;  
3. int (*init)(void);  
4. int (*setup)(void);  
5. } fb_drivers[] __initdata= { ….};  

如果FrameBuffer设备被静态链接到内核，其对应的入口就会添加到这个表中；如果是动态加载的，即使用insmod/rmmod,就不需要关心这个表。

[plain] view plaincopy

1. static struct file_operations fb_ops ={  
2. owner: THIS_MODULE,  
3. read: fb_read,  
4. write: fb_write,  
5. ioctl: fb_ioctl,  
6. mmap: fb_mmap,  
7. open: fb_open,  
8. release: fb_release  
9. };  

这是一个提供给应用程序的接口.
2）fbmem.c 实现了如下函数.

[plain] view plaincopy

1. register_framebuffer(struct fb_info *fb_info);  
2. unregister_framebuffer(struct fb_info *fb_info);  

这两个是提供给下层FrameBuffer设备驱动的接口，设备驱动通过这两函数向系统注册或注销自己。几乎底层设备驱动所要做的所有事情就是填充fb_inf o结构然后向系统注册或注销它。
（二）一个LCD显示芯片的驱动实例
以Skeleton LCD控制器驱动为例，在LINUX中存有一个/fb/skeleton.c的skeleton的Framebuffer驱动程序，很简单，仅仅是填充了 fb_info结构，并且注册/注销自己。设备驱动是向用户程序提供系统调用接口，所以我们需要实现底层硬件操作并且定义file_operations 结构来向系统提供系统调用接口，从而实现更有效的LCD控制器驱动程序。
1）在系统内存中分配显存
在fbmem.c文件中可以看到,file_operations结构中的open()和release()操作不需底层支持，但read()、 write()和 mmap()操作需要函数fb_get_fix()的支持.因此需要重新实现函数fb_get_fix()。另外还需要在系统内存中分配显存空间，大多数 的LCD控制器都没有自己的显存空间，被分配的地址空间的起 始地址与长度将会被填充到fb_fix_screeninfo结构的smem_start 和smem_len 的两个变量中.被分配的空间必须是物理连续的。
2）实现 fb_ops 中的函数
用户应用程序通过ioctl()系统调用操作硬件，fb_ops 中的函数就用于支持这些操作。（注： fb_ops结构与file_operations结构不同，fb_ops是底层操作的抽象,而file_operations是提供给上层系统调用的接 口，可以直接调用ioctl()系统调用在文件fbmem.c中实现，通过观察可以发现ioctl()命令与fb_ops’s 中函数的关系:

[plain] view plaincopy

1. FBIOGET_VSCREENINFO fb_get_var  
2. FBIOPUT_VSCREENINFO fb_set_var  
3. FBIOGET_FSCREENINFO fb_get_fix  
4. FBIOPUTCMAP fb_set_cmap  
5. FBIOGETCMAP fb_get_cmap  
6. FBIOPAN_DISPLAY fb_pan_display  

 如果我们定义了fb_XXX_XXX 方法，用户程序就可以使用FBIOXXXX宏的ioctl()操作来操作硬件。
文件linux/drivers/video/fbgen.c或者linux/drivers/video目录下的其它设备驱动是比较好的参考资料。在所 有的这 些函数中fb_set_var()是最重要的，它用于设定显示卡的模式和其它属性，下面是函数fb_set_var()的执行步骤：
1)检测是否必须设定模式
2)设定模式
3)设定颜色映射
4) 根据以前的设定重新设置LCD控制器的各寄存器。
第四步表明了底层操作到底放置在何处。在系统内存中分配显存后，显存的起始地址及长度将被设定到LCD控制器的各寄存器中（一般通过 fb_set_var()函数），显存中的内容将自动被LCD控制器输出到屏幕上。另一方面，用户程序通过函数mmap()将显存映射到用户进程地址空间 中，然后用户进程向映射空间发送 的所有数据都将会被显示到LCD显示器上。

*三、FrameBuffer的应用* 

1. FrameBuffer主要是根据VESA标准的实现的，所以只能实现最简单的功能。 
2. 由于涉及内核的问题，FrameBuffer是不允许在系统起来后修改显示模式等一系列操作。（好象很多人都想要这样干，这是不被允许的，当然如果你自己写驱动 的话，是可以实现的）. 
3. 对FrameBuffer的操作，会直接影响到本机的所有控制台的输出，包括XWIN的图形界面。 
好，现在可以让我们开始实现直接写屏： 
1、打开一个FrameBuffer设备 
2、通过mmap调用把显卡的物理内存空间映射到用户空间 
3、直接写内存。 

[cpp] view plaincopy

1. /********************************  
2. File name : fbtools.h  
3. */   
4. #ifndef _FBTOOLS_H_   
5. #define _FBTOOLS_H_   
6. #include <linux/fb.h>   
7. //a framebuffer device structure;   
8. typedef struct fbdev{   
9.        int fb;   
10.        unsigned long fb_mem_offset;   
11.        unsigned long fb_mem;   
12.        struct fb_fix_screeninfo fb_fix;   
13.        struct fb_var_screeninfo fb_var;   
14.        char dev[20];   
15. } FBDEV, *PFBDEV;   
16.   
17.   
18.   
19.   
20. //open & init a frame buffer   
21. //to use this function,   
22. //you must set FBDEV.dev="/dev/fb0"   
23. //or "/dev/fbX"   
24. //it's your frame buffer.   
25. int fb_open(PFBDEV pFbdev);   
26. //close a frame buffer   
27. int fb_close(PFBDEV pFbdev);   
28. //get display depth   
29. int get_display_depth(PFBDEV pFbdev);   
30. //full screen clear   
31. void fb_memset(void *addr, int c, size_t len);   
32. #endif   
33. /******************   

[cpp] view plaincopy

1. File name : fbtools.c   
2. */   
3. #include <stdio.h>   
4. #include <stdlib.h>   
5. #include <fcntl.h>   
6. #include <unistd.h>   
7. #include <string.h>   
8. #include <sys/ioctl.h>   
9. #include <sys/mman.h>   
10. #include <asm/page.h>   
11. #include "fbtools.h"   
12. #define TRUE        1   
13. #define FALSE       0   
14. #define MAX(x,y)        ((x)>(y)?(x)y))   
15. #define MIN(x,y)        ((x)<(y)?(x)y))   
16. //open & init a frame buffer   
17. int fb_open(PFBDEV pFbdev)   
18. {   
19.        pFbdev->fb = open(pFbdev->dev, O_RDWR);   
20.        if(pFbdev->fb < 0)   
21.        {   
22.               printf("Error opening %s: %m. Check kernel config\n",   
23. pFbdev->dev);   
24.               return FALSE;   
25.        }   
26.        if (-1 == ioctl(pFbdev->fb,FBIOGET_VSCREENINFO,&(pFbdev->fb_var)))   
27.        {   
28.               printf("ioctl FBIOGET_VSCREENINFO\n");   
29.               return FALSE;   
30.        }   
31.        if (-1 == ioctl(pFbdev->fb,FBIOGET_FSCREENINFO,&(pFbdev->fb_fix)))   
32.        {   
33.               printf("ioctl FBIOGET_FSCREENINFO\n");   
34.               return FALSE;   
35.        }   
36.        //map physics address to virtual address   
37.        pFbdev->fb_mem_offset = (unsigned long)(pFbdev->fb_fix.smem_start) &   
38. (~PAGE_MASK);   
39.        pFbdev->fb_mem = (unsigned long int)mmap(NULL,   
40. pFbdev->fb_fix.smem_len + pFbdev->fb_mem_offset,              PROT_READ |   
41. PROT_WRITE, MAP_SHARED, pFbdev->fb, 0);   
42.        if (-1L == (long) pFbdev->fb_mem)   
43.        {   
44.               printf("mmap error! mem:%d offset:%d\n", pFbdev->fb_mem,   
45. pFbdev->fb_mem_offset);   
46.               return FALSE;   
47.        }   
48.        return TRUE;   
49. }   
50.   
51.   
52.   
53.   
54. //close frame buffer   
55. int fb_close(PFBDEV pFbdev)   
56. {   
57.        close(pFbdev->fb);   
58.        pFbdev->fb=-1;   
59. }   
60.   
61.   
62.   
63.   
64. //get display depth   
65. int get_display_depth(PFBDEV pFbdev);   
66. {   
67.        if(pFbdev->fb<=0)   
68.        {   
69.               printf("fb device not open, open it first\n");   
70.               return FALSE;   
71.        }   
72.        return pFbdev->fb_var.bits_per_pixel;   
73. }   
74.   
75.   
76.   
77.   
78. //full screen clear   
79. void fb_memset (void *addr, int c, size_t len)   
80. {   
81.     memset(addr, c, len);   
82. }   

[cpp] view plaincopy

1. //use by test   
2. #define DEBUG   
3. #ifdef DEBUG   
4. main()   
5. {   
6.        FBDEV fbdev;   
7.        memset(&fbdev, 0, sizeof(FBDEV));   
8.        strcpy(fbdev.dev, "/dev/fb0");   
9.        if(fb_open(&fbdev)==FALSE)   
10.        {   
11.               printf("open frame buffer error\n");   
12.               return;   
13.        }   
14.        fb_memset(fbdev.fb_mem + fbdev.fb_mem_offset, 0,   
15. fbdev.fb_fix.smem_len);   
16.               fb_close(&fbdev);   
17. }