先来看一下应用程序是怎么操作屏幕的：Linux是工作在保护模式下，所以用户态进程是无法象DOS那样使用显卡BIOS里提供的中断调用来实现直接写屏，Linux抽象出FrameBuffer这个设备来供用户态进程实现直接写屏。FrameBuffer机制模仿显卡的功能，将显卡硬件结构抽象掉，可以通过Framebuffer的读写直接对显存进行操作。用户可以将Framebuffer看成是显示内存的一个映像，将其映射到进程地址空间之后，就可以直接进行读写操作，而写操作可以立即反应在屏幕上。这种操作是抽象的，统一的。用户不必关心物理显存的位置、换页机制等等具体细节，这些都是由Framebuffer设备驱动来完成的。
文字说明可能不是很明白，下面以具体的程序来说明LCD的操作
g_fd = open(FB_DEVICE_NAME, O_RDWR);//只读方式打开设备驱动文件#define FB_DEVICE_NAME "/dev/fb0"
ret = ioctl(g_fd, FBIOGET_VSCREENINFO, &g_tFBVar);//取得LCD的可变参数
ret = ioctl(g_fd, FBIOGET_FSCREENINFO, &g_tFBFix);//取得LCD的固定参数
/*将当前进程的内存映射到LCD的显存上，这样操作g_pucFBMem相当于操作显存*/
/* g_dwScreenSize是从固定参数中取出来的,LCD显存的大小 */
g_pucFBMem = (unsigned char *)mmap(NULL , g_dwScreenSize, PROT_READ | PROT_WRITE, MAP_SHARED, g_fd, );
可以看到应用程序首先打开名为 /dev/fb0的帧缓冲驱动的设备文件，然后根据取得的文件索引获得LCD的一些参数，主要是LCD的帧缓冲区大小，最后将当前进程可操作的内存映射到帧缓冲区。这样操作g_pucFBMem即相当于操作LCD的帧缓冲区了，这样就可以操作LCD画图了。
下面以open函数为例，分析一下整个帧缓冲设备驱动的架构。
当应用程序调用opne函数打开/dev/fb0时，最终会调用到drivers\video\fbmem.c文件下的fb_open函数，而fb_open函数被定义在fb_fops 结构体中。
static const struct file_operations fb_fops = {
.owner = THIS_MODULE,
.read = fb_read,
.write = fb_write,
.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
};
fb_fops 结构体是在帧缓冲设备驱动注册到内核的时候被调用，可以看到fbmem_init函数是这个驱动的入口函数，这个入口函数注册了一个主设备号为29的字符设备驱动，并且创建了一个类，但是没有在类下面创建设备节点，至于创建设备节点的工作在哪里做，这个后面会介绍。
static int __init
fbmem_init(void)
{
create_proc_read_entry("fb", , NULL, fbmem_read_proc, NULL); if (register_chrdev(FB_MAJOR,"fb",&fb_fops))//注册一个主设备号为29的字符驱动设备
printk("unable to get major %d for fb devs\n", FB_MAJOR); fb_class = class_create(THIS_MODULE, "graphics");//创建一个设备类
if (IS_ERR(fb_class)) {
printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));
fb_class = NULL;
}
return ;
}
好了，到这里已经看到了帧缓冲设备的注册过程了，接着回到fb_open，这里对这个函数做一个简单的注释：可以看到fb_open首先根据次设备号在registered_fb数组中找到fb_info结构体指针，然后将它赋给file->private_data，在以后调用ioctl、read等系统调用时会用到这个结构体指针从中取出相应数据给到应用层，而info->fbops->fb_open函数可有可无。
static int
fb_open(struct inode *inode, struct file *file)
{
int fbidx = iminor(inode);//取得次设备号
struct fb_info *info;
int res = ; if (fbidx >= FB_MAX)
return -ENODEV;
#ifdef CONFIG_KMOD
if (!(info = registered_fb[fbidx]))
try_to_load(fbidx);
#endif /* CONFIG_KMOD */
if (!(info = registered_fb[fbidx]))//根据次设备号在registered_fb数组中找到info结构体
return -ENODEV;
if (!try_module_get(info->fbops->owner))
return -ENODEV;
file->private_data = info;//将info赋给file->private_data
if (info->fbops->fb_open) {//若存在info->fbops->fb_open函数
res = info->fbops->fb_open(info,);//则调用它
if (res)
module_put(info->fbops->owner);
}
return res;
}
那么就会产生一个疑问：registered_fb数组是在哪里初始化的，经过搜索发现，它是在drivers\video\fbmem.c文件下的register_framebuffer被初始化的，这个函数的主要作用有2：一是在fb_class注册一个设备节点；二就是将fb_info结构体指针放入registered_fb数组中。设备节点也有了，到这里一个帧缓冲设备驱动文件描述符也就有了，我们就可以通过操作这个文件来操作LCD了。
int
register_framebuffer(struct fb_info *fb_info)
{
int i;
struct fb_event event;
struct fb_videomode mode; if (num_registered_fb == FB_MAX)
return -ENXIO;
num_registered_fb++;
for (i = ; i < FB_MAX; i++)
if (!registered_fb[i])
break;
fb_info->node = i;//记录当前获得的设备节点 fb_info->dev = device_create(fb_class, fb_info->device,
MKDEV(FB_MAJOR, i), "fb%d", i);//在fb_class类下注册一个设备节点
if (IS_ERR(fb_info->dev)) {//如果设备节点注册失败
/* Not fatal */
printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));//
fb_info->dev = NULL;
} else//如果设备节点注册成功
fb_init_device(fb_info);//初始化fb_info if (fb_info->pixmap.addr == NULL) {
fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);
if (fb_info->pixmap.addr) {
fb_info->pixmap.size = FBPIXMAPSIZE;
fb_info->pixmap.buf_align = ;
fb_info->pixmap.scan_align = ;
fb_info->pixmap.access_align = ;
fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
}
}
fb_info->pixmap.offset = ; if (!fb_info->pixmap.blit_x)
fb_info->pixmap.blit_x = ~(u32); if (!fb_info->pixmap.blit_y)
fb_info->pixmap.blit_y = ~(u32); if (!fb_info->modelist.prev || !fb_info->modelist.next)
INIT_LIST_HEAD(&fb_info->modelist); fb_var_to_videomode(&mode, &fb_info->var);
fb_add_videomode(&mode, &fb_info->modelist);
registered_fb[i] = fb_info;//将fb_info放入registered_fb数组 event.info = fb_info;
fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);
return ;
}
接着我们看到内核自带的S3C2410的LCD的驱动结构层次，它属于平台设备驱动层次结构，若对平台设备驱动的层析结构不了解，请参考Linux驱动之平台设备驱动模型简析（驱动分离分层概念的建立）。而drivers\video\s3c2410fb.c 这个文件属于平台设备驱动层次的驱动层，而arch\arm\plat-s3c24xx\devs.c 属于设备层，这个设备层文件不止LCD一个设备，还含有其他的与S3C2410相关的一些设备。这里只关注LCD设备。可以看到s3c_device_lcd 结构与s3c2410fb_driver是匹配的。
/*以下结构位于arch\arm\plat-s3c24xx\devs.c*/
struct platform_device s3c_device_lcd = {
.name = "s3c2410-lcd",//设备的名字，与s3c2410fb.c中对应设备名字相同
.id = -,
.num_resources = ARRAY_SIZE(s3c_lcd_resource),
.resource = s3c_lcd_resource,
.dev = {
.dma_mask = &s3c_device_lcd_dmamask,
.coherent_dma_mask = 0xffffffffUL
}
};
/*以下结构位于drivers\video\s3c2410fb.c*/
static struct platform_driver s3c2410fb_driver = {
.probe = s3c2410fb_probe,
.remove = s3c2410fb_remove,
.suspend = s3c2410fb_suspend,
.resume = s3c2410fb_resume,
.driver = {
.name = "s3c2410-lcd",//与dev层的设备名字对应
.owner = THIS_MODULE,
},
};
我们知道s3c2410fb_driver 结构在platform_driver_register中注册。那么s3c_device_lcd 在哪里注册呢？接着看到在arch\arm\mach-s3c2440\mach-smdk2440.c 中有smdk2440_devices这么一个结构体指针数组
static struct platform_device *smdk2440_devices[] __initdata = {
&s3c_device_usb,
&s3c_device_lcd,
&s3c_device_wdt,
&s3c_device_i2c,
&s3c_device_iis,
&s3c2440_device_sdi,
};
接着看到调用smdk2440_devices这个指针数组的函数，它同样位于arch\arm\mach-s3c2440\mach-smdk2440.c中
static void __init smdk2440_machine_init(void)
{
s3c24xx_fb_set_platdata(&smdk2440_lcd_cfg); platform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices));//注册平台驱动的device层
smdk_machine_init();
}
接着看到smdk2440_machine_init这个函数，它位于machine_desc这个结构体中，这个宏的相关初始化在setup_arch函数中，这个函数是由内核的start_kernel调用的，所以说在Linux启动不久就将s3c_device_lcd 注册到内核中了。对于machine_desc这个结构体，参考Linux移植之tag参数列表解析过程分析。
接着看到drivers\video\s3c2410fb.c文件中的s3c2410fb_probe，当设备总线驱动中设备层与驱动层名字匹配后，这个函数被调用:
static int __init s3c2410fb_probe(struct platform_device *pdev)
{
struct s3c2410fb_info *info;
struct fb_info *fbinfo;
struct s3c2410fb_hw *mregs;
int ret;
int irq;
int i;
u32 lcdcon1; mach_info = pdev->dev.platform_data;//从dev结构中获取mach_info结构，里面存放了lcd控制器的寄存器以及配置
if (mach_info == NULL) {
dev_err(&pdev->dev,"no platform data for lcd, cannot attach\n");
return -EINVAL;
} mregs = &mach_info->regs; irq = platform_get_irq(pdev, );
if (irq < ) {
dev_err(&pdev->dev, "no irq for device\n");
return -ENOENT;
} fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), &pdev->dev);//1、分配一个fb_info结构
if (!fbinfo) {
return -ENOMEM;
} info = fbinfo->par;/*2、设置fb_info结构*/
info->fb = fbinfo;
info->dev = &pdev->dev; platform_set_drvdata(pdev, fbinfo); dprintk("devinit\n"); strcpy(fbinfo->fix.id, driver_name); memcpy(&info->regs, &mach_info->regs, sizeof(info->regs)); /* Stop the video and unset ENVID if set */
info->regs.lcdcon1 &= ~S3C2410_LCDCON1_ENVID;
lcdcon1 = readl(S3C2410_LCDCON1);
writel(lcdcon1 & ~S3C2410_LCDCON1_ENVID, S3C2410_LCDCON1); // add by thisway.diy@163.com, for eBlocks
s3c2410_gpio_setpin(S3C2410_GPB0, ); // back light control info->mach_info = pdev->dev.platform_data; 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; fbinfo->fbops = &s3c2410fb_ops;
fbinfo->flags = FBINFO_FLAG_DEFAULT;
fbinfo->pseudo_palette = &info->pseudo_pal; fbinfo->var.xres = mach_info->xres.defval;
fbinfo->var.xres_virtual = mach_info->xres.defval;
fbinfo->var.yres = mach_info->yres.defval;
fbinfo->var.yres_virtual = mach_info->yres.defval;
fbinfo->var.bits_per_pixel = mach_info->bpp.defval; fbinfo->var.upper_margin = S3C2410_LCDCON2_GET_VBPD(mregs->lcdcon2) + ;
fbinfo->var.lower_margin = S3C2410_LCDCON2_GET_VFPD(mregs->lcdcon2) + ;
fbinfo->var.vsync_len = S3C2410_LCDCON2_GET_VSPW(mregs->lcdcon2) + ; fbinfo->var.left_margin = S3C2410_LCDCON3_GET_HFPD(mregs->lcdcon3) + ;
fbinfo->var.right_margin = S3C2410_LCDCON3_GET_HBPD(mregs->lcdcon3) + ;
fbinfo->var.hsync_len = S3C2410_LCDCON4_GET_HSPW(mregs->lcdcon4) + ; fbinfo->var.red.offset = ;
fbinfo->var.green.offset = ;
fbinfo->var.blue.offset = ;
fbinfo->var.transp.offset = ;
fbinfo->var.red.length = ;
fbinfo->var.green.length = ;
fbinfo->var.blue.length = ;
fbinfo->var.transp.length = ;
fbinfo->fix.smem_len = mach_info->xres.max *
mach_info->yres.max *
mach_info->bpp.max / ;// for (i = ; i < ; i++)
info->palette_buffer[i] = PALETTE_BUFF_CLEAR; if (!request_mem_region((unsigned long)S3C24XX_VA_LCD, SZ_1M, "s3c2410-lcd")) {
ret = -EBUSY;
goto dealloc_fb;
} dprintk("got LCD region\n"); 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_mem;
} info->clk = clk_get(NULL, "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);//使能LCD时钟
dprintk("got and enabled clock\n"); msleep(); /* Initialize video memory */
ret = s3c2410fb_map_video_memory(info);//分配显存
if (ret) {
printk( KERN_ERR "Failed to allocate video RAM: %d\n", ret);
ret = -ENOMEM;
goto release_clock;
}
dprintk("got video memory\n"); ret = s3c2410fb_init_registers(info);/*3、硬件相关的设备，配置LCD寄存器*/ ret = s3c2410fb_check_var(&fbinfo->var, fbinfo); ret = register_framebuffer(fbinfo);/*4、注册fbinfo结构到registered_fb数组*/
if (ret < ) {
printk(KERN_ERR "Failed to register framebuffer device: %d\n", ret);
goto free_video_memory;
} /* create device files */
device_create_file(&pdev->dev, &dev_attr_debug); printk(KERN_INFO "fb%d: %s frame buffer device\n",
fbinfo->node, fbinfo->fix.id); return ; free_video_memory:
s3c2410fb_unmap_video_memory(info);
release_clock:
clk_disable(info->clk);
clk_put(info->clk);
release_irq:
free_irq(irq,info);
release_mem:
release_mem_region((unsigned long)S3C24XX_VA_LCD, S3C24XX_SZ_LCD);
dealloc_fb:
framebuffer_release(fbinfo);
return ret;
}
可以看到这个函数最终是注册了fbinfo结构体到帧缓存驱动的registered_fb数组。
大概总结一下这个函数的功能：
1、分配一个fb_info结构
2、设置fb_info结构
3、硬件相关的操作，配置LCD时钟、配置IO端口、配置LCD寄存器。
4、最终注册fbinfo结构到registered_fb数组
s3c2410fb_remove函数的过程与s3c2410fb_probe函数相反