Linux驱动之内核自带的S3C2440的LCD驱动分析-程序员宅基地

先来看一下应用程序是怎么操作屏幕的：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, 0);

可以看到应用程序首先打开名为 /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", 0, 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 0;
}

好了，到这里已经看到了帧缓冲设备的注册过程了，接着回到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 = 0;

    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,1);//则调用它
        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 = 0 ; 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 = 1;
            fb_info->pixmap.scan_align = 1;
            fb_info->pixmap.access_align = 32;
            fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
        }
    }    
    fb_info->pixmap.offset = 0;

    if (!fb_info->pixmap.blit_x)
        fb_info->pixmap.blit_x = ~(u32)0;

    if (!fb_info->pixmap.blit_y)
        fb_info->pixmap.blit_y = ~(u32)0;

    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 0;
}

接着我们看到内核自带的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          = -1,
    .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, 0);
    if (irq < 0) {
        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 [email protected], for eBlocks
    s3c2410_gpio_setpin(S3C2410_GPB0, 0);    // back light control

    info->mach_info            = pdev->dev.platform_data;

    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.height        = mach_info->height;
    fbinfo->var.width        = mach_info->width;
    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;

    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) + 1;
    fbinfo->var.lower_margin    = S3C2410_LCDCON2_GET_VFPD(mregs->lcdcon2) + 1;
    fbinfo->var.vsync_len        = S3C2410_LCDCON2_GET_VSPW(mregs->lcdcon2) + 1;

    fbinfo->var.left_margin        = S3C2410_LCDCON3_GET_HFPD(mregs->lcdcon3) + 1;
    fbinfo->var.right_margin    = S3C2410_LCDCON3_GET_HBPD(mregs->lcdcon3) + 1;
    fbinfo->var.hsync_len        = S3C2410_LCDCON4_GET_HSPW(mregs->lcdcon4) + 1;

    fbinfo->var.red.offset      = 11;
    fbinfo->var.green.offset    = 5;
    fbinfo->var.blue.offset     = 0;
    fbinfo->var.transp.offset   = 0;
    fbinfo->var.red.length      = 5;
    fbinfo->var.green.length    = 6;
    fbinfo->var.blue.length     = 5;
    fbinfo->var.transp.length   = 0;
    fbinfo->fix.smem_len        =    mach_info->xres.max *
                    mach_info->yres.max *
                    mach_info->bpp.max / 8;//

    for (i = 0; i < 256; 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(1);

    /* 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 < 0) {
        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 0;

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函数相反