Linux framebuffer的框架非常简单， 对于应用程序就是操作一块内存（俗称帧缓存）， 当然也有可能是双缓存， 一般用于高帧率场景， 一块帧在填充数据时， 另一块在显示， 接着对调过来，
    那通过设置哪里告知驱动层读取哪块帧数据呢？ 答案是用vinfo.xoffset， vinfo.yoffset
    需要注意的是， 无论用write()、还是mmap()后直接操作内存都只是填充内存而已， 并不代表能够立马显示， 这得看驱动， 如果驱动实现了自刷新（不断从帧缓存拿数据刷到LCD上）， 那填充数据到帧缓存就会立马显示出来，
    如果驱动没有实现，那应用程序需要主动的调用 ioctl(fp, FBIOPAN_DISPLAY, &vinfo);， 告知驱动可以刷数据了， 如果这都没显示出来， 估计驱动没实现FBIOPAN_DISPLAY功能。
    示例代码：（驱动实现自刷新， 应用依次显示黄、蓝、红，最后画线）

    1. #include <unistd.h>  
    2. #include <stdio.h>  
    3. #include <fcntl.h>  
    4. #include <linux/fb.h>  
    5. #include <sys/mman.h>  
    6. #include <stdlib.h>  
    7. #include <string.h>
    9. #define RED    0xF800
    10. #define YELLOW    0xFFE0
    11. #define BLUE     0x001F
    12. #define WHITE    0xFFFF 
    13. #define BLACK    0x0000
    16. void fill_color16(short *fb_addr, short bit_map, int psize)
    17. {
    18.     int i;
    19.     for(i=0; i<psize; i++) {
    20.         *fb_addr = bit_map;
    21.         fb_addr++;
    22.     }
    23. }
    25. int main ()   
    26. {  
    27.     int fp=0;  
    28.     struct fb_var_screeninfo vinfo;  
    29.     struct fb_fix_screeninfo finfo;  
    30.     long screensize=0;  
    31.     char *fbp = NULL, *test_fbp=NULL;    
    32.     int x = 0, y = 0;  
    33.     long location = 0;
    34.     int i;
    35.     int num = 5;
    36.     int pix_size=0;
    38.     fp = open("/dev/graphics/fb0", O_RDWR);  
    40.     if(fp < 0) {  
    41.         printf("Error : Can not open framebuffer device/n");  
    42.         exit(1);  
    43.     }  
    45.     if(ioctl(fp, FBIOGET_FSCREENINFO, &finfo)){  
    46.         printf("Error reading fixed information/n");  
    47.         exit(2);  
    48.     }  
    50.     if(ioctl(fp, FBIOGET_VSCREENINFO, &vinfo)){  
    51.         printf("Error reading variable information/n");  
    52.         exit(3);  
    53.     }  
    55.     screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8;  
    57.     printf("The phy mem = 0x%x, total size = %d(byte)\n", finfo.smem_start, finfo.smem_len);  
    58.     printf("xres =  %d, yres =  %d, bits_per_pixel = %d\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);  
    59.     printf("So the screensize = %d(byte), using %d frame\n", screensize, finfo.smem_len/screensize);
    60.     printf("vinfo.xoffset = %d, vinfo.yoffset = %d\n", vinfo.xoffset, vinfo.yoffset);  
    61.     printf("vinfo.vmode is :%d\n", vinfo.vmode);  
    62.     printf("finfo.ypanstep is :%d\n", finfo.ypanstep);  
    63.     printf("vinfo.red.offset=0x%x\n", vinfo.red.offset);
    64.     printf("vinfo.red.length=0x%x\n", vinfo.red.length);
    65.     printf("vinfo.green.offset=0x%x\n", vinfo.green.offset);
    66.     printf("vinfo.green.length=0x%x\n", vinfo.green.length);
    67.     printf("vinfo.blue.offset=0x%x\n", vinfo.blue.offset);
    68.     printf("vinfo.blue.length=0x%x\n", vinfo.blue.length);
    69.     printf("vinfo.transp.offset=0x%x\n", vinfo.transp.offset);
    70.     printf("vinfo.transp.length=0x%x\n", vinfo.transp.length);
    73.     fbp =(char *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fp,0);  
    74.     if ((int)fbp == -1)  
    75.     {    
    76.         printf ("Error: failed to map framebuffer device to memory./n");  
    77.         exit (4);  
    78.     }
    79.     printf("Get virt mem = %p\n", fbp);  
    82.     pix_size = vinfo.xres * vinfo.yres;
    83.     /* using first frame, for FBIOPAN_DISPLAY
    84.      * 当刷新需要调用FBIOPAN_DISPLAY， 要告知驱动刷哪块帧， 用到下面两个参数
    85.      * 如果使用第二帧buffer -> vinfo.xoffset = 0; vinfo.yoffset = vinfo.yres;
    86.      */
    87.     vinfo.xoffset = 0;
    88.     vinfo.yoffset = 0;
    90.     /* show color loop */
    91.     while(num--) {
    92.         printf("\ndrawing YELLOW......\n");
    93.         fill_color16((short *)fbp, YELLOW, pix_size);
    94.         //ioctl(fp, FBIOPAN_DISPLAY, &vinfo);
    95.         sleep(3);
    97.         printf("\ndrawing BLUE......\n");
    98.         fill_color16((short *)fbp, BLUE, pix_size);
    99.         //ioctl(fp, FBIOPAN_DISPLAY, &vinfo);
    100.         sleep(3);
    102.         printf("\ndrawing RED......\n");
    103.         fill_color16((short *)fbp, RED, pix_size);
    104.         //ioctl(fp, FBIOPAN_DISPLAY, &vinfo);
    105.         sleep(3);
    106.     }
    107. #if 1
    108.     /*这是你想画的点的位置坐标,(0，0)点在屏幕左上角*/    
    109.     x = 10;  
    110.     y = 10;  
    111.     location = x * (vinfo.bits_per_pixel / 8) + y  *  finfo.line_length;  
    112.     test_fbp = fbp + location;
    113.     printf("draw line.......\n");
    114.     for(i = 0; i < (vinfo.xres - x); i++)
    115.         *test_fbp++ = i+30;
    117.     //ioctl(fp, FBIOPAN_DISPLAY, &vinfo);
    118. #endif
    120.     munmap(fbp, screensize); /*解除映射*/  
    122.     close (fp);
    123.     return 0;
    124. }

    当然用read()/write()， 也可以， 就是效率非常低， 太多系统调用导致系统在用户态和kernel态切换， 而且每次还传输一个字节， 但作为例子可以参考一下：

    #include <unistd.h>  
#include <stdio.h>  
#include <fcntl.h>  
#include <linux/fb.h>  
#include <sys/mman.h>  
#include <stdlib.h>  
#include <string.h>

#define RED    0xF800
#define YELLOW    0xFFE0
#define BLUE     0x001F
#define WHITE    0xFFFF 
#define BLACK    0x0000



int main ()   
{  
    int fp=0;  
    struct fb_var_screeninfo vinfo;  
    int i;
    int pix_size=0;
    unsigned char color1, color2;

    fp = open("/dev/graphics/fb0", O_RDWR);  

    if(fp < 0) {  
        printf("Error : Can not open framebuffer device/n");  
        exit(1);  
    }  

    if(ioctl(fp, FBIOGET_VSCREENINFO, &vinfo)){  
        printf("Error reading variable information/n");  
        exit(3);  
    }  


    pix_size = vinfo.xres * vinfo.yres;
    color1 = 0;
    color2 = 0xf8;
    for(i=0; i<pix_size; i++) {
        write(fp, &color1, 1);
        write(fp, &color2, 1);        
    }

    close (fp);
    return 0;
}